texlive/SOURCES/texlive-20180414-poppler-20.11.0-luatex.patch

commit 69c061f2071d5826fee7940ce7f83ae4a1c8fc2e
Author: Akira Kakuto <kakuto@fuk.kindai.ac.jp>
Date:   Sat Apr 28 07:36:22 2018 +0000

    support poppler-0.64.0
    
    git-svn-id: svn://tug.org/texlive/trunk/Build/source@47470 c570f23f-e606-0410-a88d-b1316a301751

diff --git a/texk/web2c/luatexdir/image/pdftoepdf.w b/texk/web2c/luatexdir/image/pdftoepdf.w
index 7ba29731c..d69795926 100644
--- a/texk/web2c/luatexdir/image/pdftoepdf.w
+++ b/texk/web2c/luatexdir/image/pdftoepdf.w
@@ -472,10 +472,10 @@ static void copyObject(PDF pdf, PdfDocument * pdf_doc, Object * obj)
         break;
     */
     case objString:
-        copyString(pdf, obj->getString());
+        copyString(pdf, (GooString *)obj->getString());
         break;
     case objName:
-        copyName(pdf, obj->getName());
+        copyName(pdf, (char *)obj->getName());
         break;
     case objNull:
         pdf_add_null(pdf);
diff --git a/texk/web2c/luatexdir/lua/lepdflib.cc b/texk/web2c/luatexdir/lua/lepdflib.cc
index a16bf3bd4..32bcdab01 100644
--- a/texk/web2c/luatexdir/lua/lepdflib.cc
+++ b/texk/web2c/luatexdir/lua/lepdflib.cc
@@ -674,7 +674,7 @@ static int m_##in##_##function(lua_State * L)                  \
     uin = (udstruct *) luaL_checkudata(L, 1, M_##in);          \
     if (uin->pd != NULL && uin->pd->pc != uin->pc)             \
         pdfdoc_changed_error(L);                               \
-    gs = ((in *) uin->d)->function();                          \
+    gs = (GooString *)((in *) uin->d)->function();             \
     if (gs != NULL)                                            \
         lua_pushlstring(L, gs->getCString(), gs->getLength()); \
     else                                                       \
@@ -1813,7 +1813,7 @@ static int m_Object_getString(lua_State * L)
     if (uin->pd != NULL && uin->pd->pc != uin->pc)
         pdfdoc_changed_error(L);
     if (((Object *) uin->d)->isString()) {
-        gs = ((Object *) uin->d)->getString();
+        gs = (GooString *)((Object *) uin->d)->getString();
         lua_pushlstring(L, gs->getCString(), gs->getLength());
     } else
         lua_pushnil(L);
diff --git a/texk/web2c/pdftexdir/ChangeLog b/texk/web2c/pdftexdir/ChangeLog
index c022bc252..f4af0358e 100644
--- a/texk/web2c/pdftexdir/ChangeLog
+++ b/texk/web2c/pdftexdir/ChangeLog
@@ -1,3 +1,8 @@
+2018-04-28  Akira Kakuto  <kakuto@fuk.kindai.ac.jp>
+
+	* pdftoepdf-newpoppler.cc, pdftosrc-newpoppler.cc:
+	Support poppler 0.64.0.
+
 2018-04-14  Karl Berry  <karl@tug.org>
 
 	* TeX Live 2018 release, pdftex 1.40.19.
diff --git a/texk/web2c/pdftexdir/pdftoepdf-newpoppler.cc b/texk/web2c/pdftexdir/pdftoepdf-newpoppler.cc
index 10fea2999..750579d61 100644
--- a/texk/web2c/pdftexdir/pdftoepdf-newpoppler.cc
+++ b/texk/web2c/pdftexdir/pdftoepdf-newpoppler.cc
@@ -290,7 +290,7 @@ static void copyName(char *s)
 static void copyDictEntry(Object * obj, int i)
 {
     Object obj1;
-    copyName(obj->dictGetKey(i));
+    copyName((char *)obj->dictGetKey(i));
     pdf_puts(" ");
     obj1 = obj->dictGetValNF(i);
     copyObject(&obj1);
@@ -355,7 +355,7 @@ static void copyProcSet(Object * obj)
         if (!procset.isName())
             pdftex_fail("PDF inclusion: invalid ProcSet entry type <%s>",
                         procset.getTypeName());
-        copyName(procset.getName());
+        copyName((char *)procset.getName());
         pdf_puts(" ");
     }
     pdf_puts("]\n");
@@ -418,7 +418,7 @@ static void copyFont(char *tag, Object * fontRef)
         && fontdescRef.isRef()
         && fontdesc.isDict()
         && embeddableFont(&fontdesc)
-        && (fontmap = lookup_fontmap(basefont.getName())) != NULL) {
+        && (fontmap = lookup_fontmap((char *)basefont.getName())) != NULL) {
         // round /StemV value, since the PDF input is a float
         // (see Font Descriptors in PDF reference), but we only store an
         // integer, since we don't want to change the struct.
@@ -427,7 +427,7 @@ static void copyFont(char *tag, Object * fontRef)
         charset = fontdesc.dictLookup("CharSet");
         if (!charset.isNull() &&
             charset.isString() && is_subsetable(fontmap))
-            epdf_mark_glyphs(fd, charset.getString()->getCString());
+            epdf_mark_glyphs(fd, (char *)charset.getString()->getCString());
         else
             embed_whole_font(fd);
         addFontDesc(fontdescRef.getRef(), fd);
@@ -456,7 +456,7 @@ static void copyFontResources(Object * obj)
         if (fontRef.isRef())
             copyFont(obj->dictGetKey(i), &fontRef);
         else if (fontRef.isDict()) {   // some programs generate pdf with embedded font object
-            copyName(obj->dictGetKey(i));
+            copyName((char *)obj->dictGetKey(i));
             pdf_puts(" ");
             copyObject(&fontRef);
         }
@@ -565,7 +565,7 @@ static void copyObject(Object * obj)
     } else if (obj->isNum()) {
         pdf_printf("%s", convertNumToPDF(obj->getNum()));
     } else if (obj->isString()) {
-        s = obj->getString();
+        s = (GooString *)obj->getString();
         p = s->getCString();
         l = s->getLength();
         if (strlen(p) == (unsigned int) l) {
@@ -589,7 +589,7 @@ static void copyObject(Object * obj)
             pdf_puts(">");
         }
     } else if (obj->isName()) {
-        copyName(obj->getName());
+        copyName((char *)obj->getName());
     } else if (obj->isNull()) {
         pdf_puts("null");
     } else if (obj->isArray()) {
diff --git a/texk/web2c/pdftexdir/pdftosrc-newpoppler.cc b/texk/web2c/pdftexdir/pdftosrc-newpoppler.cc
index 4e2bcadbd..0db154b4f 100644
--- a/texk/web2c/pdftexdir/pdftosrc-newpoppler.cc
+++ b/texk/web2c/pdftexdir/pdftosrc-newpoppler.cc
@@ -109,7 +109,7 @@ int main(int argc, char *argv[])
             fprintf(stderr, "No SourceName found\n");
             exit(1);
         }
-        outname = srcName.getString()->getCString();
+        outname = (char *)srcName.getString()->getCString();
         // We cannot free srcName, as objname shares its string.
         // srcName.free();
     } else if (objnum > 0) {
commit 5f7832c4bf868184f41ac0a5f80af10475ae1ff4
Author: Karl Berry <karl@freefriends.org>
Date:   Tue Jul 31 20:52:36 2018 +0000

    doc,sync
    
    git-svn-id: svn://tug.org/texlive/trunk/Build/source@48318 c570f23f-e606-0410-a88d-b1316a301751

diff --git a/doc/tlbuild.info b/doc/tlbuild.info
index 62391d8af..fb7848e3a 100644
--- a/doc/tlbuild.info
+++ b/doc/tlbuild.info
@@ -356,7 +356,8 @@ finish for working on 'dvipdfm-x'.
      make check
 
    Then you modify source files in 'mydir/texk/dvipdfm-x' and rerun
-'make' in 'mydir/Work/texk/dvipdfm-x' to rebuild.
+'make' in 'mydir/Work/texk/dvipdfm-x' to rebuild (that build directory
+is where the binaries end up).
 
    The second line of the 'configure' invocation shows examples of extra
 things you likely want to specify if you intend to hack the sources (and
@@ -375,8 +376,8 @@ do so.  If you cut down the source tree, you must also give additional
 'configure' flags to individually disable using system versions of
 libraries, or the intricacies of the dependencies (such as 'teckit'
 requiring 'zlib') will have undesired side effects.  For an example, see
-the 'build-pdftex.sh' script in the 'pdftex' development source
-(<http://pdftex.org>), which is indeed a cut-down TL source tree.
+the 'build-pdftex.sh' script in the 'pdftex' development source (details
+at <http://pdftex.org>), which is indeed a cut-down TL source tree.
 
    Even with '--disable-all-pkgs', dependencies will be checked.  For
 instance, if a non-MacOSX system does not have 'fontconfig', XeTeX
@@ -517,7 +518,7 @@ This section discusses the results of 'make install' in the source tree.
 
    The main consideration is that 'make install' is not enough to make a
 usable TeX installation.  Beyond the compiled binaries, (thousands of)
-support files are needed; just as a first example 'plain.tex' is not in
+support files are needed; just as a first example, 'plain.tex' is not in
 the source tree.
 
    These support files are maintained completely independently and are
@@ -5045,7 +5046,7 @@ Index
 * --enable-maintainer-mode:              Build system tools.   (line 28)
 * --enable-maintainer-mode <1>:          --enable-maintainer-mode.
                                                                (line  6)
-* --enable-missing to ignore dependencies: Build one package.  (line 67)
+* --enable-missing to ignore dependencies: Build one package.  (line 68)
 * --enable-mktextfm-default:             kpathsea library.     (line 20)
 * --enable-multiplatform:                --enable-multiplatform.
                                                                (line  6)
@@ -5161,7 +5162,7 @@ Index
 * callexe.c:                             Macros for Windows.   (line 32)
 * CC:                                    Variables for configure.
                                                                (line 10)
-* CC=C-COMPILER:                         Build one package.    (line 73)
+* CC=C-COMPILER:                         Build one package.    (line 74)
 * CC_BUILD:                              Cross problems.       (line 13)
 * chktex:                                Declarations and definitions.
                                                                (line 18)
@@ -5220,7 +5221,7 @@ Index
 * ctangle:                               Cross problems.       (line 26)
 * CXX:                                   Variables for configure.
                                                                (line 11)
-* CXX=C++-COMPILER:                      Build one package.    (line 73)
+* CXX=C++-COMPILER:                      Build one package.    (line 74)
 * Debian installation of build prerequisites: Prerequisites.   (line 60)
 * declarations and definitions, in source code: Declarations and definitions.
                                                                (line  6)
@@ -5408,7 +5409,7 @@ Index
 * motif:                                 Configure options for texk/xdvik.
                                                                (line  9)
 * native cross compilation:              Cross compilation.    (line 10)
-* OBJCXX=OBJC-COMPILER:                  Build one package.    (line 73)
+* OBJCXX=OBJC-COMPILER:                  Build one package.    (line 74)
 * one package, building:                 Build one package.    (line  6)
 * OpenGL, required for Asymptote:        asymptote.            (line  6)
 * operating system distribution, building for: Distro builds.  (line  6)
@@ -5451,7 +5452,7 @@ Index
 * setup macros, general:                 General setup macros. (line  6)
 * shared libraries, using vs. avoiding:  Distro builds.        (line 11)
 * size of PDF and PS files:              --disable-largefile.  (line 10)
-* size of source tree:                   Build one package.    (line 57)
+* size of source tree:                   Build one package.    (line 58)
 * source code declarations:              Declarations and definitions.
                                                                (line  6)
 * source directory building, not supported: Building.          (line 17)
@@ -5547,360 +5548,360 @@ Node: Build problems10656
 Node: Build in parallel11059
 Node: Build distribution11651
 Node: Build one package12222
-Node: Cross compilation15600
-Node: Cross configuring16881
-Node: Cross problems18558
-Node: Installing20209
-Node: Installation directories21224
-Node: Linked scripts23040
-Node: Distro builds24521
-Node: Layout and infrastructure26911
-Node: Build system tools27739
-Node: Top-level directories29750
-Node: Autoconf macros32164
-Node: General setup macros32865
-Node: Macros for programs33732
-Node: Macros for compilers34544
-Node: Macros for libraries35978
-Node: Macros for library and header flags36404
-Node: Macros for Windows38284
-Node: Library modules39861
-Node: png library40350
-Node: zlib library42624
-Node: freetype library43139
-Node: kpathsea library43667
-Node: Program modules45066
-Node: t1utils package45494
-Node: xindy package46045
-Node: xdvik package47195
-Node: asymptote48268
-Node: Extending TeX Live48719
-Node: Adding a new program module49496
-Node: Adding a new generic library module52791
-Node: Adding a new TeX-specific library module55004
-Node: Configure options55691
-Node: Global configure options57074
-Node: --disable-native-texlive-build57616
-Node: --prefix --bindir ...58606
-Node: --disable-largefile59146
-Node: --disable-missing59831
-Node: --enable-compiler-warnings=LEVEL60232
-Node: --enable-cxx-runtime-hack60971
-Node: --enable-maintainer-mode61398
-Node: --enable-multiplatform61927
-Node: --enable-shared62465
-Node: --enable-silent-rules62836
-Node: --without-ln-s63292
-Node: --without-x63643
-Node: Program-specific configure options63831
-Node: --enable-PROG --disable-PROG64474
-Node: --disable-all-pkgs64751
-Node: Configure options for texk/web2c65737
-Node: Configure options for texk/bibtex-x68255
-Node: Configure options for texk/dvipdfm-x68798
-Node: Configure options for texk/dvisvgm69571
-Node: Configure options for texk/texlive70457
-Node: Configure options for texk/xdvik70878
-Node: Configure options for utils/xindy71482
-Node: Library-specific configure options72383
-Node: Configure options for kpathsea73394
-Node: Configure options for system poppler74103
-Node: Variables for configure74894
-Node: Coding conventions76322
-Node: Declarations and definitions77061
-Node: Const79243
-Node: Continuous integration81106
-Node: Transfer from Subversion to Github81760
-Node: Automatic update of the Git mirror83942
-Node: CI testing on Travis-CI84530
-Node: install-tl85210
-Node: install-tl NAME85579
-Node: install-tl SYNOPSIS85737
-Node: install-tl DESCRIPTION85995
-Node: install-tl REFERENCES87062
-Node: install-tl OPTIONS87588
-Ref: install-tl *-gui* [[=]_module_]87929
-Ref: install-tl text88139
-Ref: install-tl wizard88262
-Ref: install-tl perltk88416
-Ref: install-tl *-no-gui*88847
-Ref: install-tl *-lang* _llcode_88928
-Ref: install-tl *-repository* _url|path_89615
-Ref: install-tl *-select-repository*91495
-Ref: install-tl *-all-options*91931
-Ref: install-tl *-custom-bin* _path_92186
-Ref: install-tl *-debug-translation*93017
-Ref: install-tl *-force-platform* _platform_93236
-Ref: install-tl *-help*, *--help*, *-?*93480
-Ref: install-tl *-in-place*93887
-Ref: install-tl *-init-from-profile* _profile_file_94432
-Ref: install-tl *-logfile* _file_94652
-Ref: install-tl *-no-cls*95003
-Ref: install-tl *-non-admin*95137
-Ref: install-tl *-persistent-downloads*95242
-Ref: install-tl *-no-persistent-downloads*95270
-Ref: install-tl *-no-verify-downloads*95888
-Ref: install-tl *-portable*96249
-Ref: install-tl *-print-platform*96388
-Ref: install-tl *-profile* _profile_file_96586
-Ref: install-tl *-q*96766
-Ref: install-tl *-scheme* _scheme_96828
-Ref: install-tl *-v*97302
-Ref: install-tl *-version*, *--version*97457
-Node: install-tl PROFILES97588
-Ref: install-tl instopt_adjustpath (default 0 on Unix, 1 on Windows)100238
-Ref: install-tl instopt_adjustrepo (default 1)100314
-Ref: install-tl instopt_letter (default 0)100451
-Ref: install-tl instopt_portable (default 0)100542
-Ref: install-tl instopt_write18_restricted (default 1)100638
-Node: install-tl ENVIRONMENT VARIABLES101957
-Ref: install-tl TEXLIVE_INSTALL_ENV_NOCHECK102348
-Ref: install-tl TEXLIVE_INSTALL_NO_CONTEXT_CACHE102550
-Ref: install-tl TEXLIVE_INSTALL_NO_WELCOME102660
-Ref: install-tl TEXLIVE_INSTALL_PREFIX102781
-Ref: install-tl TEXLIVE_INSTALL_TEXDIR102807
-Ref: install-tl TEXLIVE_INSTALL_TEXMFCONFIG102838
-Ref: install-tl TEXLIVE_INSTALL_TEXMFVAR102866
-Ref: install-tl TEXLIVE_INSTALL_TEXMFHOME102895
-Ref: install-tl TEXLIVE_INSTALL_TEXMFLOCAL102925
-Ref: install-tl TEXLIVE_INSTALL_TEXMFSYSCONFIG102959
-Ref: install-tl TEXLIVE_INSTALL_TEXMFSYSVAR102990
-Ref: install-tl NOPERLDOC103361
-Node: install-tl AUTHORS AND COPYRIGHT103425
-Node: tlmgr103841
-Node: tlmgr NAME104294
-Node: tlmgr SYNOPSIS104426
-Node: tlmgr DESCRIPTION104616
-Node: tlmgr EXAMPLES105712
-Ref: tlmgr tlmgr option repository ctan105963
-Ref: tlmgr tlmgr option repository http://mirror.ctan.org/systems/texlive/tlnet106035
-Ref: tlmgr tlmgr update --list106487
-Ref: tlmgr tlmgr update --all106580
-Ref: tlmgr tlmgr info _what_106737
-Node: tlmgr OPTIONS106999
-Ref: tlmgr *--repository* _url|path_107519
-Ref: tlmgr *--gui* [_action_]108244
-Ref: tlmgr *--gui-lang* _llcode_108651
-Ref: tlmgr *--debug-translation*109334
-Ref: tlmgr *--machine-readable*109537
-Ref: tlmgr *--no-execute-actions*109805
-Ref: tlmgr *--package-logfile* _file_109998
-Ref: tlmgr *--pause*110252
-Ref: tlmgr *--persistent-downloads*110407
-Ref: tlmgr *--no-persistent-downloads*110435
-Ref: tlmgr *--pin-file*110929
-Ref: tlmgr *--usermode*111147
-Ref: tlmgr *--usertree* _dir_111267
-Ref: tlmgr *--verify-repo=[none|main|all]*111393
-Node: tlmgr ACTIONS112292
-Node: tlmgr help113144
-Node: tlmgr version113620
-Node: tlmgr backup113883
-Ref: tlmgr *backup [_option_...] --all*114054
-Ref: tlmgr *backup [_option_...] _pkg_...*114087
-Ref: tlmgr *--backupdir* _directory_114942
-Ref: tlmgr *--all*115159
-Ref: tlmgr *--clean*[=_N_]115411
-Ref: tlmgr *--dry-run*115738
-Node: tlmgr candidates _pkg_115868
-Node: tlmgr check [_option_...] [files|depends|executes|runfiles|all]116214
-Ref: tlmgr *files*116587
-Ref: tlmgr *depends*116722
-Ref: tlmgr *executes*117064
-Ref: tlmgr *runfiles*117182
-Ref: tlmgr *--use-svn*117303
-Node: tlmgr conf117420
-Ref: tlmgr *conf [texmf|tlmgr|updmap [--conffile _file_] [--delete] [_key_ [_value_]]]*117699
-Ref: tlmgr *conf auxtrees [--conffile _file_] [show|add|delete] [_value_]*117763
-Node: tlmgr dump-tlpdb [_option_...] [--json]120108
-Ref: tlmgr *--local*120541
-Ref: tlmgr *--remote*120580
-Ref: tlmgr *--json*120618
-Node: tlmgr generate121189
-Ref: tlmgr *generate [_option_...] language*121385
-Ref: tlmgr *generate [_option_...] language.dat*121424
-Ref: tlmgr *generate [_option_...] language.def*121463
-Ref: tlmgr *generate [_option_...] language.dat.lua*121506
-Ref: tlmgr *--dest* _output_file_123832
-Ref: tlmgr *--localcfg* _local_conf_file_124408
-Ref: tlmgr *--rebuild-sys*124531
-Node: tlmgr gui125346
-Node: tlmgr info125524
-Ref: tlmgr *info [_option_...] _pkg_...*125686
-Ref: tlmgr *info [_option_...] collections*125720
-Ref: tlmgr *info [_option_...] schemes*125750
-Ref: tlmgr *--list*127280
-Ref: tlmgr *--only-installed*127594
-Ref: tlmgr *--data item1,item2,...*127793
-Ref: tlmgr *--json* 1128374
-Node: tlmgr init-usertree128757
-Node: tlmgr install [_option_...] _pkg_...129138
-Ref: tlmgr *--dry-run* 1129648
-Ref: tlmgr *--file*129765
-Ref: tlmgr *--force*129987
-Ref: tlmgr *--no-depends*130207
-Ref: tlmgr *--no-depends-at-all*130366
-Ref: tlmgr *--reinstall*130766
-Ref: tlmgr *--with-doc*131144
-Ref: tlmgr *--with-src*131157
-Node: tlmgr key131679
-Ref: tlmgr *key list*131837
-Ref: tlmgr *key add _file_*131855
-Ref: tlmgr *key remove _keyid_*131877
-Node: tlmgr list132472
-Node: tlmgr option132634
-Ref: tlmgr *option [--json] [show]*132789
-Ref: tlmgr *option [--json] showall*132815
-Ref: tlmgr *option _key_ [_value_]*132841
-Node: tlmgr paper137238
-Ref: tlmgr *paper [a4|letter]*137387
-Ref: tlmgr *[xdvi|pdftex|dvips|dvipdfmx|context|psutils] paper [_papersize_|--list]*137461
-Ref: tlmgr *paper --json*137476
-Node: tlmgr path138691
-Ref: tlmgr *path [--w32mode=user|admin] add*138852
-Ref: tlmgr *path [--w32mode=user|admin] remove*138889
-Node: tlmgr pinning140229
-Ref: tlmgr pinning show140470
-Ref: tlmgr pinning add _repo_ _pkgglob_...140543
-Ref: tlmgr pinning remove _repo_ _pkgglob_...140662
-Ref: tlmgr pinning remove _repo_ --all140815
-Node: tlmgr platform140869
-Ref: tlmgr *platform list|add|remove _platform_...*141055
-Ref: tlmgr *platform set _platform_*141082
-Ref: tlmgr *platform set auto*141103
-Ref: tlmgr *--dry-run* 2141989
-Node: tlmgr postaction142108
-Ref: tlmgr *postaction [_option_...] install [shortcut|fileassoc|script] [_pkg_...]*142338
-Ref: tlmgr *postaction [_option_...] remove [shortcut|fileassoc|script] [_pkg_...]*142412
-Ref: tlmgr *--w32mode=[user|admin]*142727
-Ref: tlmgr *--fileassocmode=[1|2]*143143
-Ref: tlmgr *--all* 1143428
-Node: tlmgr print-platform143483
-Node: tlmgr print-platform-info143814
-Node: tlmgr remove [_option_...] _pkg_...144114
-Ref: tlmgr *--all* 2144598
-Ref: tlmgr *--backup*144708
-Ref: tlmgr *--backupdir* _directory_ 1144734
-Ref: tlmgr *--no-depends* 1145139
-Ref: tlmgr *--no-depends-at-all* 1145201
-Ref: tlmgr *--force* 1145304
-Ref: tlmgr *--dry-run* 3145777
-Node: tlmgr repository145884
-Ref: tlmgr *repository list*146072
-Ref: tlmgr *repository list _path|tag_*146102
-Ref: tlmgr *repository add _path_ [_tag_]*146135
-Ref: tlmgr *repository remove _path|tag_*146167
-Ref: tlmgr *repository set _path_[#_tag_] [_path_[#_tag_] ...]*146221
-Node: tlmgr restore147274
-Ref: tlmgr *restore [_option_...] _pkg_ [_rev_]*147453
-Ref: tlmgr *restore [_option_...] --all*147483
-Ref: tlmgr *--all* 3148183
-Ref: tlmgr *--backupdir* _directory_ 2148397
-Ref: tlmgr *--dry-run* 4148578
-Ref: tlmgr *--force* 2148710
-Ref: tlmgr *--json* 2148756
-Node: tlmgr search149083
-Ref: tlmgr *search [_option_...] _what_*149247
-Ref: tlmgr *search [_option_...] --file _what_*149284
-Ref: tlmgr *search [_option_...] --all _what_*149320
-Ref: tlmgr *--file* 1149540
-Ref: tlmgr *--all* 4149602
-Ref: tlmgr *--global*149691
-Ref: tlmgr *--word*149818
-Node: tlmgr shell150133
-Ref: tlmgr protocol150868
-Ref: tlmgr help 1150932
-Ref: tlmgr version 1150985
-Ref: tlmgr quit, end, bye, byebye, EOF151053
-Ref: tlmgr restart151074
-Ref: tlmgr load [local|remote]151197
-Ref: tlmgr save151267
-Ref: tlmgr get [_var_] =item set [_var_ [_val_]]151390
-Node: tlmgr show151991
-Node: tlmgr uninstall152158
-Node: tlmgr update [_option_...] [_pkg_...]152388
-Ref: tlmgr *--all* 5152759
-Ref: tlmgr *--self*154500
-Ref: tlmgr *--dry-run* 5155264
-Ref: tlmgr *--list* [_pkg_]155441
-Ref: tlmgr *--exclude* _pkg_156130
-Ref: tlmgr *--no-auto-remove* [_pkg_...]156930
-Ref: tlmgr *--no-auto-install* [_pkg_...]157381
-Ref: tlmgr *--reinstall-forcibly-removed*158037
-Ref: tlmgr *--backup* 1158572
-Ref: tlmgr *--backupdir* _directory_ 3158598
-Ref: tlmgr *--no-depends* 2159764
-Ref: tlmgr *--no-depends-at-all* 2159967
-Ref: tlmgr *--force* 3160070
-Node: tlmgr CONFIGURATION FILE FOR TLMGR160885
-Ref: tlmgr auto-remove, value 0 or 1 (default 1), same as command-line option.161898
-Ref: tlmgr gui-expertmode, value 0 or 1 (default 1). This switches between the full GUI and a simplified GUI with only the most common settings.162035
-Ref: tlmgr gui-lang _llcode_, with a language code value as with the command-line option.162117
-Ref: tlmgr no-checksums, value 0 or 1 (default 0, see below).162171
-Ref: tlmgr persistent-downloads, value 0 or 1 (default 1), same as command-line option.162251
-Ref: tlmgr require-verification, value 0 or 1 (default 0), same as command-line option.162331
-Ref: tlmgr update-exclude, value: comma-separated list of packages (no space allowed). Same as the command line option --exclude for the action update.162479
-Ref: tlmgr verify-downloads, value 0 or 1 (default 1), same as command-line option.162555
-Ref: tlmgr allowed-actions _action1_ [,_action_,...] The value is a comma-separated list of tlmgr actions which are allowed to be executed when tlmgr is invoked in system mode (that is, without --usermode).162824
-Node: tlmgr CRYPTOGRAPHIC VERIFICATION163910
-Node: tlmgr Configuration of GnuPG invocation166059
-Node: tlmgr USER MODE166697
-Node: tlmgr User mode install169543
-Node: tlmgr User mode backup, restore, remove, update170687
-Node: tlmgr User mode generate, option, paper171129
-Node: tlmgr MULTIPLE REPOSITORIES171505
-Node: tlmgr Pinning173234
-Node: tlmgr GUI FOR TLMGR175209
-Node: tlmgr Main display176549
-Node: tlmgr Display configuration area176801
-Ref: tlmgr Status177162
-Ref: tlmgr Category177326
-Ref: tlmgr Match177512
-Ref: tlmgr Selection177693
-Ref: tlmgr Display configuration buttons177897
-Node: tlmgr Package list area178080
-Ref: tlmgr a checkbox178664
-Ref: tlmgr package name178800
-Ref: tlmgr local revision (and version)178899
-Ref: tlmgr remote revision (and version)179274
-Ref: tlmgr short description179571
-Node: tlmgr Main display action buttons179616
-Ref: tlmgr Update all installed179882
-Ref: tlmgr Update180254
-Ref: tlmgr Install180304
-Ref: tlmgr Remove180490
-Ref: tlmgr Backup180668
-Node: tlmgr Menu bar180825
-Ref: tlmgr tlmgr menu181048
-Ref: tlmgr Options menu181356
-Ref: tlmgr Actions menu182439
-Ref: tlmgr Help menu182867
-Node: tlmgr GUI options183000
-Ref: tlmgr -background _color_183246
-Ref: tlmgr -font " _fontname_ _fontsize_ "183311
-Ref: tlmgr -foreground _color_183469
-Ref: tlmgr -geometry _geomspec_183521
-Ref: tlmgr -xrm _xresource_183713
-Node: tlmgr MACHINE-READABLE OUTPUT183981
-Node: tlmgr Machine-readable update and install output184791
-Ref: tlmgr location-url _location_186067
-Ref: tlmgr total-bytes _count_186283
-Ref: tlmgr _pkgname_186693
-Ref: tlmgr _status_186903
-Ref: tlmgr d186981
-Ref: tlmgr f187041
-Ref: tlmgr u187220
-Ref: tlmgr r187266
-Ref: tlmgr a187389
-Ref: tlmgr i187567
-Ref: tlmgr I187686
-Ref: tlmgr _localrev_187788
-Ref: tlmgr _serverrev_187895
-Ref: tlmgr _size_188007
-Ref: tlmgr _runtime_188176
-Ref: tlmgr _esttot_188246
-Node: tlmgr Machine-readable option output188279
-Node: tlmgr AUTHORS AND COPYRIGHT188791
-Node: Index189190
+Node: Cross compilation15663
+Node: Cross configuring16944
+Node: Cross problems18621
+Node: Installing20272
+Node: Installation directories21288
+Node: Linked scripts23104
+Node: Distro builds24585
+Node: Layout and infrastructure26975
+Node: Build system tools27803
+Node: Top-level directories29814
+Node: Autoconf macros32228
+Node: General setup macros32929
+Node: Macros for programs33796
+Node: Macros for compilers34608
+Node: Macros for libraries36042
+Node: Macros for library and header flags36468
+Node: Macros for Windows38348
+Node: Library modules39925
+Node: png library40414
+Node: zlib library42688
+Node: freetype library43203
+Node: kpathsea library43731
+Node: Program modules45130
+Node: t1utils package45558
+Node: xindy package46109
+Node: xdvik package47259
+Node: asymptote48332
+Node: Extending TeX Live48783
+Node: Adding a new program module49560
+Node: Adding a new generic library module52855
+Node: Adding a new TeX-specific library module55068
+Node: Configure options55755
+Node: Global configure options57138
+Node: --disable-native-texlive-build57680
+Node: --prefix --bindir ...58670
+Node: --disable-largefile59210
+Node: --disable-missing59895
+Node: --enable-compiler-warnings=LEVEL60296
+Node: --enable-cxx-runtime-hack61035
+Node: --enable-maintainer-mode61462
+Node: --enable-multiplatform61991
+Node: --enable-shared62529
+Node: --enable-silent-rules62900
+Node: --without-ln-s63356
+Node: --without-x63707
+Node: Program-specific configure options63895
+Node: --enable-PROG --disable-PROG64538
+Node: --disable-all-pkgs64815
+Node: Configure options for texk/web2c65801
+Node: Configure options for texk/bibtex-x68319
+Node: Configure options for texk/dvipdfm-x68862
+Node: Configure options for texk/dvisvgm69635
+Node: Configure options for texk/texlive70521
+Node: Configure options for texk/xdvik70942
+Node: Configure options for utils/xindy71546
+Node: Library-specific configure options72447
+Node: Configure options for kpathsea73458
+Node: Configure options for system poppler74167
+Node: Variables for configure74958
+Node: Coding conventions76386
+Node: Declarations and definitions77125
+Node: Const79307
+Node: Continuous integration81170
+Node: Transfer from Subversion to Github81824
+Node: Automatic update of the Git mirror84006
+Node: CI testing on Travis-CI84594
+Node: install-tl85274
+Node: install-tl NAME85643
+Node: install-tl SYNOPSIS85801
+Node: install-tl DESCRIPTION86059
+Node: install-tl REFERENCES87126
+Node: install-tl OPTIONS87652
+Ref: install-tl *-gui* [[=]_module_]87993
+Ref: install-tl text88203
+Ref: install-tl wizard88326
+Ref: install-tl perltk88480
+Ref: install-tl *-no-gui*88911
+Ref: install-tl *-lang* _llcode_88992
+Ref: install-tl *-repository* _url|path_89679
+Ref: install-tl *-select-repository*91559
+Ref: install-tl *-all-options*91995
+Ref: install-tl *-custom-bin* _path_92250
+Ref: install-tl *-debug-translation*93081
+Ref: install-tl *-force-platform* _platform_93300
+Ref: install-tl *-help*, *--help*, *-?*93544
+Ref: install-tl *-in-place*93951
+Ref: install-tl *-init-from-profile* _profile_file_94496
+Ref: install-tl *-logfile* _file_94716
+Ref: install-tl *-no-cls*95067
+Ref: install-tl *-non-admin*95201
+Ref: install-tl *-persistent-downloads*95306
+Ref: install-tl *-no-persistent-downloads*95334
+Ref: install-tl *-no-verify-downloads*95952
+Ref: install-tl *-portable*96313
+Ref: install-tl *-print-platform*96452
+Ref: install-tl *-profile* _profile_file_96650
+Ref: install-tl *-q*96830
+Ref: install-tl *-scheme* _scheme_96892
+Ref: install-tl *-v*97366
+Ref: install-tl *-version*, *--version*97521
+Node: install-tl PROFILES97652
+Ref: install-tl instopt_adjustpath (default 0 on Unix, 1 on Windows)100302
+Ref: install-tl instopt_adjustrepo (default 1)100378
+Ref: install-tl instopt_letter (default 0)100515
+Ref: install-tl instopt_portable (default 0)100606
+Ref: install-tl instopt_write18_restricted (default 1)100702
+Node: install-tl ENVIRONMENT VARIABLES102021
+Ref: install-tl TEXLIVE_INSTALL_ENV_NOCHECK102412
+Ref: install-tl TEXLIVE_INSTALL_NO_CONTEXT_CACHE102614
+Ref: install-tl TEXLIVE_INSTALL_NO_WELCOME102724
+Ref: install-tl TEXLIVE_INSTALL_PREFIX102845
+Ref: install-tl TEXLIVE_INSTALL_TEXDIR102871
+Ref: install-tl TEXLIVE_INSTALL_TEXMFCONFIG102902
+Ref: install-tl TEXLIVE_INSTALL_TEXMFVAR102930
+Ref: install-tl TEXLIVE_INSTALL_TEXMFHOME102959
+Ref: install-tl TEXLIVE_INSTALL_TEXMFLOCAL102989
+Ref: install-tl TEXLIVE_INSTALL_TEXMFSYSCONFIG103023
+Ref: install-tl TEXLIVE_INSTALL_TEXMFSYSVAR103054
+Ref: install-tl NOPERLDOC103425
+Node: install-tl AUTHORS AND COPYRIGHT103489
+Node: tlmgr103905
+Node: tlmgr NAME104358
+Node: tlmgr SYNOPSIS104490
+Node: tlmgr DESCRIPTION104680
+Node: tlmgr EXAMPLES105776
+Ref: tlmgr tlmgr option repository ctan106027
+Ref: tlmgr tlmgr option repository http://mirror.ctan.org/systems/texlive/tlnet106099
+Ref: tlmgr tlmgr update --list106551
+Ref: tlmgr tlmgr update --all106644
+Ref: tlmgr tlmgr info _what_106801
+Node: tlmgr OPTIONS107063
+Ref: tlmgr *--repository* _url|path_107583
+Ref: tlmgr *--gui* [_action_]108308
+Ref: tlmgr *--gui-lang* _llcode_108715
+Ref: tlmgr *--debug-translation*109398
+Ref: tlmgr *--machine-readable*109601
+Ref: tlmgr *--no-execute-actions*109869
+Ref: tlmgr *--package-logfile* _file_110062
+Ref: tlmgr *--pause*110316
+Ref: tlmgr *--persistent-downloads*110471
+Ref: tlmgr *--no-persistent-downloads*110499
+Ref: tlmgr *--pin-file*110993
+Ref: tlmgr *--usermode*111211
+Ref: tlmgr *--usertree* _dir_111331
+Ref: tlmgr *--verify-repo=[none|main|all]*111457
+Node: tlmgr ACTIONS112356
+Node: tlmgr help113208
+Node: tlmgr version113684
+Node: tlmgr backup113947
+Ref: tlmgr *backup [_option_...] --all*114118
+Ref: tlmgr *backup [_option_...] _pkg_...*114151
+Ref: tlmgr *--backupdir* _directory_115006
+Ref: tlmgr *--all*115223
+Ref: tlmgr *--clean*[=_N_]115475
+Ref: tlmgr *--dry-run*115802
+Node: tlmgr candidates _pkg_115932
+Node: tlmgr check [_option_...] [files|depends|executes|runfiles|all]116278
+Ref: tlmgr *files*116651
+Ref: tlmgr *depends*116786
+Ref: tlmgr *executes*117128
+Ref: tlmgr *runfiles*117246
+Ref: tlmgr *--use-svn*117367
+Node: tlmgr conf117484
+Ref: tlmgr *conf [texmf|tlmgr|updmap [--conffile _file_] [--delete] [_key_ [_value_]]]*117763
+Ref: tlmgr *conf auxtrees [--conffile _file_] [show|add|delete] [_value_]*117827
+Node: tlmgr dump-tlpdb [_option_...] [--json]120172
+Ref: tlmgr *--local*120605
+Ref: tlmgr *--remote*120644
+Ref: tlmgr *--json*120682
+Node: tlmgr generate121253
+Ref: tlmgr *generate [_option_...] language*121449
+Ref: tlmgr *generate [_option_...] language.dat*121488
+Ref: tlmgr *generate [_option_...] language.def*121527
+Ref: tlmgr *generate [_option_...] language.dat.lua*121570
+Ref: tlmgr *--dest* _output_file_123896
+Ref: tlmgr *--localcfg* _local_conf_file_124472
+Ref: tlmgr *--rebuild-sys*124595
+Node: tlmgr gui125410
+Node: tlmgr info125588
+Ref: tlmgr *info [_option_...] _pkg_...*125750
+Ref: tlmgr *info [_option_...] collections*125784
+Ref: tlmgr *info [_option_...] schemes*125814
+Ref: tlmgr *--list*127344
+Ref: tlmgr *--only-installed*127658
+Ref: tlmgr *--data item1,item2,...*127857
+Ref: tlmgr *--json* 1128438
+Node: tlmgr init-usertree128821
+Node: tlmgr install [_option_...] _pkg_...129202
+Ref: tlmgr *--dry-run* 1129712
+Ref: tlmgr *--file*129829
+Ref: tlmgr *--force*130051
+Ref: tlmgr *--no-depends*130271
+Ref: tlmgr *--no-depends-at-all*130430
+Ref: tlmgr *--reinstall*130830
+Ref: tlmgr *--with-doc*131208
+Ref: tlmgr *--with-src*131221
+Node: tlmgr key131743
+Ref: tlmgr *key list*131901
+Ref: tlmgr *key add _file_*131919
+Ref: tlmgr *key remove _keyid_*131941
+Node: tlmgr list132536
+Node: tlmgr option132698
+Ref: tlmgr *option [--json] [show]*132853
+Ref: tlmgr *option [--json] showall*132879
+Ref: tlmgr *option _key_ [_value_]*132905
+Node: tlmgr paper137302
+Ref: tlmgr *paper [a4|letter]*137451
+Ref: tlmgr *[xdvi|pdftex|dvips|dvipdfmx|context|psutils] paper [_papersize_|--list]*137525
+Ref: tlmgr *paper --json*137540
+Node: tlmgr path138755
+Ref: tlmgr *path [--w32mode=user|admin] add*138916
+Ref: tlmgr *path [--w32mode=user|admin] remove*138953
+Node: tlmgr pinning140293
+Ref: tlmgr pinning show140534
+Ref: tlmgr pinning add _repo_ _pkgglob_...140607
+Ref: tlmgr pinning remove _repo_ _pkgglob_...140726
+Ref: tlmgr pinning remove _repo_ --all140879
+Node: tlmgr platform140933
+Ref: tlmgr *platform list|add|remove _platform_...*141119
+Ref: tlmgr *platform set _platform_*141146
+Ref: tlmgr *platform set auto*141167
+Ref: tlmgr *--dry-run* 2142053
+Node: tlmgr postaction142172
+Ref: tlmgr *postaction [_option_...] install [shortcut|fileassoc|script] [_pkg_...]*142402
+Ref: tlmgr *postaction [_option_...] remove [shortcut|fileassoc|script] [_pkg_...]*142476
+Ref: tlmgr *--w32mode=[user|admin]*142791
+Ref: tlmgr *--fileassocmode=[1|2]*143207
+Ref: tlmgr *--all* 1143492
+Node: tlmgr print-platform143547
+Node: tlmgr print-platform-info143878
+Node: tlmgr remove [_option_...] _pkg_...144178
+Ref: tlmgr *--all* 2144662
+Ref: tlmgr *--backup*144772
+Ref: tlmgr *--backupdir* _directory_ 1144798
+Ref: tlmgr *--no-depends* 1145203
+Ref: tlmgr *--no-depends-at-all* 1145265
+Ref: tlmgr *--force* 1145368
+Ref: tlmgr *--dry-run* 3145841
+Node: tlmgr repository145948
+Ref: tlmgr *repository list*146136
+Ref: tlmgr *repository list _path|tag_*146166
+Ref: tlmgr *repository add _path_ [_tag_]*146199
+Ref: tlmgr *repository remove _path|tag_*146231
+Ref: tlmgr *repository set _path_[#_tag_] [_path_[#_tag_] ...]*146285
+Node: tlmgr restore147338
+Ref: tlmgr *restore [_option_...] _pkg_ [_rev_]*147517
+Ref: tlmgr *restore [_option_...] --all*147547
+Ref: tlmgr *--all* 3148247
+Ref: tlmgr *--backupdir* _directory_ 2148461
+Ref: tlmgr *--dry-run* 4148642
+Ref: tlmgr *--force* 2148774
+Ref: tlmgr *--json* 2148820
+Node: tlmgr search149147
+Ref: tlmgr *search [_option_...] _what_*149311
+Ref: tlmgr *search [_option_...] --file _what_*149348
+Ref: tlmgr *search [_option_...] --all _what_*149384
+Ref: tlmgr *--file* 1149604
+Ref: tlmgr *--all* 4149666
+Ref: tlmgr *--global*149755
+Ref: tlmgr *--word*149882
+Node: tlmgr shell150197
+Ref: tlmgr protocol150932
+Ref: tlmgr help 1150996
+Ref: tlmgr version 1151049
+Ref: tlmgr quit, end, bye, byebye, EOF151117
+Ref: tlmgr restart151138
+Ref: tlmgr load [local|remote]151261
+Ref: tlmgr save151331
+Ref: tlmgr get [_var_] =item set [_var_ [_val_]]151454
+Node: tlmgr show152055
+Node: tlmgr uninstall152222
+Node: tlmgr update [_option_...] [_pkg_...]152452
+Ref: tlmgr *--all* 5152823
+Ref: tlmgr *--self*154564
+Ref: tlmgr *--dry-run* 5155328
+Ref: tlmgr *--list* [_pkg_]155505
+Ref: tlmgr *--exclude* _pkg_156194
+Ref: tlmgr *--no-auto-remove* [_pkg_...]156994
+Ref: tlmgr *--no-auto-install* [_pkg_...]157445
+Ref: tlmgr *--reinstall-forcibly-removed*158101
+Ref: tlmgr *--backup* 1158636
+Ref: tlmgr *--backupdir* _directory_ 3158662
+Ref: tlmgr *--no-depends* 2159828
+Ref: tlmgr *--no-depends-at-all* 2160031
+Ref: tlmgr *--force* 3160134
+Node: tlmgr CONFIGURATION FILE FOR TLMGR160949
+Ref: tlmgr auto-remove, value 0 or 1 (default 1), same as command-line option.161962
+Ref: tlmgr gui-expertmode, value 0 or 1 (default 1). This switches between the full GUI and a simplified GUI with only the most common settings.162099
+Ref: tlmgr gui-lang _llcode_, with a language code value as with the command-line option.162181
+Ref: tlmgr no-checksums, value 0 or 1 (default 0, see below).162235
+Ref: tlmgr persistent-downloads, value 0 or 1 (default 1), same as command-line option.162315
+Ref: tlmgr require-verification, value 0 or 1 (default 0), same as command-line option.162395
+Ref: tlmgr update-exclude, value: comma-separated list of packages (no space allowed). Same as the command line option --exclude for the action update.162543
+Ref: tlmgr verify-downloads, value 0 or 1 (default 1), same as command-line option.162619
+Ref: tlmgr allowed-actions _action1_ [,_action_,...] The value is a comma-separated list of tlmgr actions which are allowed to be executed when tlmgr is invoked in system mode (that is, without --usermode).162888
+Node: tlmgr CRYPTOGRAPHIC VERIFICATION163974
+Node: tlmgr Configuration of GnuPG invocation166123
+Node: tlmgr USER MODE166761
+Node: tlmgr User mode install169607
+Node: tlmgr User mode backup, restore, remove, update170751
+Node: tlmgr User mode generate, option, paper171193
+Node: tlmgr MULTIPLE REPOSITORIES171569
+Node: tlmgr Pinning173298
+Node: tlmgr GUI FOR TLMGR175273
+Node: tlmgr Main display176613
+Node: tlmgr Display configuration area176865
+Ref: tlmgr Status177226
+Ref: tlmgr Category177390
+Ref: tlmgr Match177576
+Ref: tlmgr Selection177757
+Ref: tlmgr Display configuration buttons177961
+Node: tlmgr Package list area178144
+Ref: tlmgr a checkbox178728
+Ref: tlmgr package name178864
+Ref: tlmgr local revision (and version)178963
+Ref: tlmgr remote revision (and version)179338
+Ref: tlmgr short description179635
+Node: tlmgr Main display action buttons179680
+Ref: tlmgr Update all installed179946
+Ref: tlmgr Update180318
+Ref: tlmgr Install180368
+Ref: tlmgr Remove180554
+Ref: tlmgr Backup180732
+Node: tlmgr Menu bar180889
+Ref: tlmgr tlmgr menu181112
+Ref: tlmgr Options menu181420
+Ref: tlmgr Actions menu182503
+Ref: tlmgr Help menu182931
+Node: tlmgr GUI options183064
+Ref: tlmgr -background _color_183310
+Ref: tlmgr -font " _fontname_ _fontsize_ "183375
+Ref: tlmgr -foreground _color_183533
+Ref: tlmgr -geometry _geomspec_183585
+Ref: tlmgr -xrm _xresource_183777
+Node: tlmgr MACHINE-READABLE OUTPUT184045
+Node: tlmgr Machine-readable update and install output184855
+Ref: tlmgr location-url _location_186131
+Ref: tlmgr total-bytes _count_186347
+Ref: tlmgr _pkgname_186757
+Ref: tlmgr _status_186967
+Ref: tlmgr d187045
+Ref: tlmgr f187105
+Ref: tlmgr u187284
+Ref: tlmgr r187330
+Ref: tlmgr a187453
+Ref: tlmgr i187631
+Ref: tlmgr I187750
+Ref: tlmgr _localrev_187852
+Ref: tlmgr _serverrev_187959
+Ref: tlmgr _size_188071
+Ref: tlmgr _runtime_188240
+Ref: tlmgr _esttot_188310
+Node: tlmgr Machine-readable option output188343
+Node: tlmgr AUTHORS AND COPYRIGHT188855
+Node: Index189254
 
 End Tag Table
diff --git a/texk/texlive/linked_scripts/texlive/tlmgr.pl b/texk/texlive/linked_scripts/texlive/tlmgr.pl
index f0c125b5a..d2cfaaebb 100755
--- a/texk/texlive/linked_scripts/texlive/tlmgr.pl
+++ b/texk/texlive/linked_scripts/texlive/tlmgr.pl
@@ -8178,7 +8178,7 @@ With the C<list> argument, C<key> lists all keys.
 
 The C<add> argument requires another argument, either a filename or
 C<-> for stdin, from which the key is added. The key is added to the
-local keyring C<GNUPGHOME/repository-keys.gpg>, which is normally)
+local keyring C<GNUPGHOME/repository-keys.gpg>, which is normally
 C<tlpkg/gpg/repository-keys.gpg>.
 
 The C<remove> argument requires a key id and removes the requested id
diff --git a/texk/web2c/configure b/texk/web2c/configure
index 65955e941..681a176fc 100755
--- a/texk/web2c/configure
+++ b/texk/web2c/configure
@@ -18592,6 +18592,7 @@ fi
 
 
 
+# Include additional code for web2c.
 
 ## texk/web2c/ac/web2c.ac: configure.ac fragment for the TeX Live subdirectory texk/web2c/
 ## configure options for TeX and MF
@@ -19003,12 +19004,14 @@ fi
 
 
 
+# LuaTeX and XeTeX now require C++11 because poppler does :(.
+# XeTeX also requires C+11 because of ICU.
 if test "x$enable_xetex" = xyes \
    || test "x$enable_luatex" = xyes \
    || test "x$enable_luajittex" = xyes \
    || test "x$enable_luatex53" = xyes; then
-  { $as_echo "$as_me:${as_lineno-$LINENO}: LuaTeX enabled, requiring C++11 support" >&5
-$as_echo "$as_me: LuaTeX enabled, requiring C++11 support" >&6;}
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for C++11, since LuaTeX and/or XeTeX enabled" >&5
+$as_echo "$as_me: checking for C++11, since LuaTeX and/or XeTeX enabled" >&6;}
     ax_cxx_compile_alternatives="11 0x"    ax_cxx_compile_cxx11_required=true
   ac_ext=cpp
 ac_cpp='$CXXCPP $CPPFLAGS'
diff --git a/texk/web2c/configure.ac b/texk/web2c/configure.ac
index 902902ca5..6c0839297 100644
--- a/texk/web2c/configure.ac
+++ b/texk/web2c/configure.ac
@@ -42,16 +42,17 @@ AC_PROG_OBJCXX
 KPSE_CXX_HACK
 KPSE_LT_HACK
 
-dnl Include additional code for web2c.
+# Include additional code for web2c.
 KPSE_WEB2C_PREPARE
 m4_include([ac/web2c.ac])
 
-dnl LuaTeX requires C++11 because poppler does :(.
+# LuaTeX and XeTeX now require C++11 because poppler does :(.
+# XeTeX also requires C+11 because of ICU.
 if test "x$enable_xetex" = xyes \
    || test "x$enable_luatex" = xyes \
    || test "x$enable_luajittex" = xyes \
    || test "x$enable_luatex53" = xyes; then
-  AC_MSG_NOTICE([LuaTeX enabled, requiring C++11 support])
+  AC_MSG_NOTICE([checking for C++11, since LuaTeX and/or XeTeX enabled])
   AX_CXX_COMPILE_STDCXX([11])
 fi
 
commit aa5363bd0dc180752c7d8eb9d847c2581e453b1a
Author: Luigi Scarso <luigi.scarso@gmail.com>
Date:   Wed Sep 5 21:30:41 2018 +0000

    sync with luatex revision 6924.
    
    git-svn-id: svn://tug.org/texlive/trunk/Build/source@48591 c570f23f-e606-0410-a88d-b1316a301751

diff --git a/libs/lua53/ChangeLog b/libs/lua53/ChangeLog
index 8ef10ff28..d5c4b88bc 100644
--- a/libs/lua53/ChangeLog
+++ b/libs/lua53/ChangeLog
@@ -1,3 +1,14 @@
+2018-07-21 Luigi Scarso <luigi.scarso@gmail.com>
+	
+	* Adapted for Lua 5.3.5
+
+
+2018-06-18 Luigi Scarso <luigi.scarso@gmail.com>
+	
+	* dropped poppler, new pplib from
+	  http://eurydyka.kaliope.org.pl/~pawel/libpp/html/ppapi.html
+
+
 2017-10-24 Luigi Scarso <luigi.scarso@gmail.com>
 	
 	* Adapted for Lua 5.3.4
diff --git a/libs/lua53/Makefile.am b/libs/lua53/Makefile.am
index a7994ea5a..f736ce9a3 100644
--- a/libs/lua53/Makefile.am
+++ b/libs/lua53/Makefile.am
@@ -65,6 +65,7 @@ nodist_libtexlua53_la_SOURCES = \
 	@LUA53_TREE@/src/lvm.c \
 	@LUA53_TREE@/src/lzio.c 
 
+
 lua53includedir = ${includedir}/texlua53
 
 lua53include_HEADERS = \
diff --git a/libs/lua53/TLpatches/ChangeLog b/libs/lua53/TLpatches/ChangeLog
index 882ddcdde..dd2bcb2f0 100644
--- a/libs/lua53/TLpatches/ChangeLog
+++ b/libs/lua53/TLpatches/ChangeLog
@@ -1,3 +1,7 @@
+2018-07-21 Luigi Scarso <luigi.scarso@gmail.com>
+	Adapted for lua 5.3.5
+
+
 2017-10-24 Luigi Scarso <luigi.scarso@gmail.com>
 	Adapted for lua 5.3.4
 
diff --git a/libs/lua53/TLpatches/patch-01-utf-8 b/libs/lua53/TLpatches/patch-01-utf-8
index f2ac40134..0f7cb8981 100644
--- a/libs/lua53/TLpatches/patch-01-utf-8
+++ b/libs/lua53/TLpatches/patch-01-utf-8
@@ -1,7 +1,16 @@
-diff -ur lua-5.3.4.orig/src/lctype.h lua-5.3.4/src/lctype.h
---- lctype.h.orig	2017-10-24 15:14:50.724139638 +0200
-+++ lctype.h	2017-10-24 15:15:51.704137138 +0200
-@@ -53,9 +53,11 @@
+diff -u lctype.h.orig lctype.h 
+--- lctype.h.orig	2018-07-21 09:57:36.061692228 +0200
++++ lctype.h	2018-07-21 10:03:29.625677730 +0200
+@@ -7,6 +7,8 @@
+ #ifndef lctype_h
+ #define lctype_h
+ 
++#include <ctype.h>
++
+ #include "lua.h"
+ 
+ 
+@@ -53,9 +55,11 @@
  
  /*
  ** 'lalpha' (Lua alphabetic) and 'lalnum' (Lua alphanumeric) both include '_'
diff --git a/libs/lua53/TLpatches/patch-02-FreeBSD b/libs/lua53/TLpatches/patch-02-FreeBSD
index fc59f4842..ad85a5988 100644
--- a/libs/lua53/TLpatches/patch-02-FreeBSD
+++ b/libs/lua53/TLpatches/patch-02-FreeBSD
@@ -1,6 +1,6 @@
-diff -ur liolib.c.orig liolib.c 
---- liolib.c.orig	2017-10-24 15:16:06.036136550 +0200
-+++ liolib.c	2017-10-24 15:16:49.968134748 +0200
+diff -u liolib.c.orig liolib.c 
+--- liolib.c.orig	2017-04-19 19:29:57.000000000 +0200
++++ liolib.c	2018-07-21 10:04:50.965674394 +0200
 @@ -16,6 +16,9 @@
  #include <stdio.h>
  #include <stdlib.h>
diff --git a/libs/lua53/TLpatches/patch-03-export b/libs/lua53/TLpatches/patch-03-export
index dda2b87b2..9bc2a4627 100644
--- a/libs/lua53/TLpatches/patch-03-export
+++ b/libs/lua53/TLpatches/patch-03-export
@@ -1,6 +1,6 @@
-diff -ur lopcodes.h.orig lopcodes.h 
---- lopcodes.h.orig	2017-10-24 15:22:51.012119943 +0200
-+++ lopcodes.h	2017-10-24 15:18:37.924130321 +0200
+diff -u lopcodes.h.orig lopcodes.h 
+--- lopcodes.h.orig	2018-07-21 09:59:37.349687255 +0200
++++ lopcodes.h	2018-07-21 10:07:04.413668921 +0200
 @@ -278,7 +278,7 @@
    OpArgK   /* argument is a constant or register/constant */
  };
@@ -20,9 +20,10 @@ diff -ur lopcodes.h.orig lopcodes.h
  
  /* number of list items to accumulate before a SETLIST instruction */
 
-diff -ur lundump.h.orig lundump.h 
---- lundump.h.orig	2017-10-24 15:19:03.860129258 +0200
-+++ lundump.h	2017-10-24 15:19:47.088127485 +0200
+
+diff -u lundump.h.orig lundump.h 
+--- lundump.h.orig	2018-07-21 10:00:01.545686262 +0200
++++ lundump.h	2018-07-21 10:08:12.341666136 +0200
 @@ -26,7 +26,7 @@
  LUAI_FUNC LClosure* luaU_undump (lua_State* L, ZIO* Z, const char* name);
  
@@ -32,4 +33,3 @@ diff -ur lundump.h.orig lundump.h
                           void* data, int strip);
  
  #endif
-
diff --git a/libs/lua53/lua53-src/README b/libs/lua53/lua53-src/README
index 0b31908a0..ed424defe 100644
--- a/libs/lua53/lua53-src/README
+++ b/libs/lua53/lua53-src/README
@@ -1,5 +1,5 @@
 
-This is Lua 5.3.4, released on 12 Jan 2017.
+This is Lua 5.3.5, released on 26 Jun 2018.
 
 For installation instructions, license details, and
 further information about Lua, see doc/readme.html.
diff --git a/libs/lua53/lua53-src/doc/contents.html b/libs/lua53/lua53-src/doc/contents.html
index 445556f96..c4eb26779 100644
--- a/libs/lua53/lua53-src/doc/contents.html
+++ b/libs/lua53/lua53-src/doc/contents.html
@@ -32,7 +32,7 @@ For a complete introduction to Lua programming, see the book
 
 <P>
 <SMALL>
-Copyright &copy; 2015&ndash;2017 Lua.org, PUC-Rio.
+Copyright &copy; 2015&ndash;2018 Lua.org, PUC-Rio.
 Freely available under the terms of the
 <A HREF="http://www.lua.org/license.html">Lua license</A>.
 </SMALL>
@@ -609,10 +609,10 @@ Freely available under the terms of the
 
 <P CLASS="footer">
 Last update:
-Thu Dec 22 18:29:39 BRST 2016
+Mon Jun 18 22:56:06 -03 2018
 </P>
 <!--
-Last change: revised for Lua 5.3.4
+Last change: revised for Lua 5.3.5
 -->
 
 </BODY>
diff --git a/libs/lua53/lua53-src/doc/lua.css b/libs/lua53/lua53-src/doc/lua.css
index 5bedf7eb8..cbd0799d1 100644
--- a/libs/lua53/lua53-src/doc/lua.css
+++ b/libs/lua53/lua53-src/doc/lua.css
@@ -10,7 +10,7 @@ body {
 	line-height: 1.25 ;
 	margin: 16px auto ;
 	padding: 32px ;
-	border: solid #a0a0a0 1px ;
+	border: solid #ccc 1px ;
 	border-radius: 20px ;
 	max-width: 70em ;
 	width: 90% ;
@@ -111,36 +111,29 @@ pre.session {
 	border-radius: 8px ;
 }
 
-td.gutter {
-	width: 4% ;
-}
-
-table.columns {
+table {
 	border: none ;
 	border-spacing: 0 ;
 	border-collapse: collapse ;
 }
 
-table.columns td {
-	vertical-align: top ;
+td {
 	padding: 0 ;
-	padding-bottom: 1em ;
-	text-align: justify ;
-	line-height: 1.25 ;
+	margin: 0 ;
 }
 
-p.logos a:link:hover, p.logos a:visited:hover {
-	background-color: inherit ;
+td.gutter {
+	width: 4% ;
 }
 
-table.book {
-	border: none ;
-	border-spacing: 0 ;
-	border-collapse: collapse ;
+table.columns td {
+	vertical-align: top ;
+	padding-bottom: 1em ;
+	text-align: justify ;
+	line-height: 1.25 ;
 }
 
 table.book td {
-	padding: 0 ;
 	vertical-align: top ;
 }
 
@@ -159,6 +152,10 @@ table.book span {
 	margin-top: 0.25em ;
 }
 
+p.logos a:link:hover, p.logos a:visited:hover {
+	background-color: inherit ;
+}
+
 img {
 	background-color: white ;
 }
diff --git a/libs/lua53/lua53-src/doc/manual.html b/libs/lua53/lua53-src/doc/manual.html
index 3126b5d6a..89a642a45 100644
--- a/libs/lua53/lua53-src/doc/manual.html
+++ b/libs/lua53/lua53-src/doc/manual.html
@@ -19,7 +19,7 @@ by Roberto Ierusalimschy, Luiz Henrique de Figueiredo, Waldemar Celes
 
 <P>
 <SMALL>
-Copyright &copy; 2015&ndash;2017 Lua.org, PUC-Rio.
+Copyright &copy; 2015&ndash;2018 Lua.org, PUC-Rio.
 Freely available under the terms of the
 <a href="http://www.lua.org/license.html">Lua license</a>.
 </SMALL>
@@ -35,7 +35,7 @@ Freely available under the terms of the
 <!-- ====================================================================== -->
 <p>
 
-<!-- $Id: manual.of,v 1.167 2017/01/09 15:18:11 roberto Exp $ -->
+<!-- $Id: manual.of,v 1.167.1.2 2018/06/26 15:49:07 roberto Exp $ -->
 
 
 
@@ -203,8 +203,8 @@ even those that do not support threads natively.
 
 <p>
 The type <em>table</em> implements associative arrays,
-that is, arrays that can be indexed not only with numbers,
-but with any Lua value except <b>nil</b> and NaN.
+that is, arrays that can have as indices not only numbers,
+but any Lua value except <b>nil</b> and NaN.
 (<em>Not a Number</em> is a special value used to represent
 undefined or unrepresentable numerical results, such as <code>0/0</code>.)
 Tables can be <em>heterogeneous</em>;
@@ -400,6 +400,8 @@ with the event name prefixed by two underscores;
 the corresponding values are called <em>metamethods</em>.
 In the previous example, the key is "<code>__add</code>"
 and the metamethod is the function that performs the addition.
+Unless stated otherwise,
+metamethods should be function values.
 
 
 <p>
@@ -597,7 +599,7 @@ it is also slower than a real <code>__le</code> metamethod.)
 </li>
 
 <li><b><code>__index</code>: </b>
-The indexing access <code>table[key]</code>.
+The indexing access operation <code>table[key]</code>.
 This event happens when <code>table</code> is not a table or
 when <code>key</code> is not present in <code>table</code>.
 The metamethod is looked up in <code>table</code>.
@@ -1276,13 +1278,8 @@ Square brackets are used to index a table:
 <pre>
 	var ::= prefixexp &lsquo;<b>[</b>&rsquo; exp &lsquo;<b>]</b>&rsquo;
 </pre><p>
-The meaning of accesses to table fields can be changed via metatables.
-An access to an indexed variable <code>t[i]</code> is equivalent to
-a call <code>gettable_event(t,i)</code>.
-(See <a href="#2.4">&sect;2.4</a> for a complete description of the
-<code>gettable_event</code> function.
-This function is not defined or callable in Lua.
-We use it here only for explanatory purposes.)
+The meaning of accesses to table fields can be changed via metatables
+(see <a href="#2.4">&sect;2.4</a>).
 
 
 <p>
@@ -1476,23 +1473,18 @@ and
 cyclically permutes the values of <code>x</code>, <code>y</code>, and <code>z</code>.
 
 
-<p>
-The meaning of assignments to global variables
-and table fields can be changed via metatables.
-An assignment to an indexed variable <code>t[i] = val</code> is equivalent to
-<code>settable_event(t,i,val)</code>.
-(See <a href="#2.4">&sect;2.4</a> for a complete description of the
-<code>settable_event</code> function.
-This function is not defined or callable in Lua.
-We use it here only for explanatory purposes.)
-
-
 <p>
 An assignment to a global name <code>x = val</code>
 is equivalent to the assignment
 <code>_ENV.x = val</code> (see <a href="#2.2">&sect;2.2</a>).
 
 
+<p>
+The meaning of assignments to table fields and
+global variables (which are actually table fields, too)
+can be changed via metatables (see <a href="#2.4">&sect;2.4</a>).
+
+
 
 
 
@@ -1831,17 +1823,17 @@ Here are some examples:
      g(f(), x)          -- f() is adjusted to 1 result
      g(x, f())          -- g gets x plus all results from f()
      a,b,c = f(), x     -- f() is adjusted to 1 result (c gets nil)
-     a,b = ...          -- a gets the first vararg parameter, b gets
+     a,b = ...          -- a gets the first vararg argument, b gets
                         -- the second (both a and b can get nil if there
-                        -- is no corresponding vararg parameter)
+                        -- is no corresponding vararg argument)
      
      a,b,c = x, f()     -- f() is adjusted to 2 results
      a,b,c = f()        -- f() is adjusted to 3 results
      return f()         -- returns all results from f()
-     return ...         -- returns all received vararg parameters
+     return ...         -- returns all received vararg arguments
      return x,y,f()     -- returns x, y, and all results from f()
      {f()}              -- creates a list with all results from f()
-     {...}              -- creates a list with all vararg parameters
+     {...}              -- creates a list with all vararg arguments
      {f(), nil}         -- f() is adjusted to 1 result
 </pre>
 
@@ -2039,9 +2031,12 @@ two objects are considered equal only if they are the same object.
 Every time you create a new object
 (a table, userdata, or thread),
 this new object is different from any previously existing object.
-Closures with the same reference are always equal.
+A closure is always equal to itself.
 Closures with any detectable difference
 (different behavior, different definition) are always different.
+Closures created at different times but with no detectable differences
+may be classified as equal or not
+(depending on internal caching details).
 
 
 <p>
@@ -2303,7 +2298,7 @@ If the value of prefixexp has type <em>function</em>,
 then this function is called
 with the given arguments.
 Otherwise, the prefixexp "call" metamethod is called,
-having as first parameter the value of prefixexp,
+having as first argument the value of prefixexp,
 followed by the original call arguments
 (see <a href="#2.4">&sect;2.4</a>).
 
@@ -2881,7 +2876,7 @@ it can do whatever it wants on that Lua state,
 as it should be already protected.
 However,
 when C code operates on other Lua states
-(e.g., a Lua parameter to the function,
+(e.g., a Lua argument to the function,
 a Lua state stored in the registry, or
 the result of <a href="#lua_newthread"><code>lua_newthread</code></a>),
 it should use them only in API calls that cannot raise errors.
@@ -3370,7 +3365,7 @@ it is left unchanged.
 Destroys all objects in the given Lua state
 (calling the corresponding garbage-collection metamethods, if any)
 and frees all dynamic memory used by this state.
-On several platforms, you may not need to call this function,
+In several platforms, you may not need to call this function,
 because all resources are naturally released when the host program ends.
 On the other hand, long-running programs that create multiple states,
 such as daemons or web servers,
@@ -5584,7 +5579,7 @@ given as argument to a hook (see <a href="#lua_Hook"><code>lua_Hook</code></a>).
 
 
 <p>
-To get information about a function you push it onto the stack
+To get information about a function, you push it onto the stack
 and start the <code>what</code> string with the character '<code>&gt;</code>'.
 (In that case,
 <code>lua_getinfo</code> pops the function from the top of the stack.)
@@ -6462,7 +6457,7 @@ file-related functions in the standard library
 
 <p>
 Pushes onto the stack the field <code>e</code> from the metatable
-of the object at index <code>obj</code> and returns the type of pushed value.
+of the object at index <code>obj</code> and returns the type of the pushed value.
 If the object does not have a metatable,
 or if the metatable does not have this field,
 pushes nothing and returns <code>LUA_TNIL</code>.
@@ -6749,7 +6744,7 @@ In words, if the argument <code>arg</code> is nil or absent,
 the macro results in the default <code>dflt</code>.
 Otherwise, it results in the result of calling <code>func</code>
 with the state <code>L</code> and the argument index <code>arg</code> as
-parameters.
+arguments.
 Note that it evaluates the expression <code>dflt</code> only if needed.
 
 
@@ -8680,7 +8675,7 @@ the lowercase letters plus the '<code>-</code>' character.
 <p>
 You can put a closing square bracket in a set
 by positioning it as the first character in the set.
-You can put an hyphen in a set
+You can put a hyphen in a set
 by positioning it as the first or the last character in the set.
 (You can also use an escape for both cases.)
 
@@ -9082,8 +9077,8 @@ Returns the destination table <code>a2</code>.
 
 
 <p>
-Returns a new table with all parameters stored into keys 1, 2, etc.
-and with a field "<code>n</code>" with the total number of parameters.
+Returns a new table with all arguments stored into keys 1, 2, etc.
+and with a field "<code>n</code>" with the total number of arguments.
 Note that the resulting table may not be a sequence.
 
 
@@ -9215,7 +9210,7 @@ Returns the arc sine of <code>x</code> (in radians).
 <p>
 
 Returns the arc tangent of <code>y/x</code> (in radians),
-but uses the signs of both parameters to find the
+but uses the signs of both arguments to find the
 quadrant of the result.
 (It also handles correctly the case of <code>x</code> being zero.)
 
@@ -9516,7 +9511,7 @@ all I/O functions return <b>nil</b> on failure
 (plus an error message as a second result and
 a system-dependent error code as a third result)
 and some value different from <b>nil</b> on success.
-On non-POSIX systems,
+In non-POSIX systems,
 the computation of the error message and error code
 in case of errors
 may be not thread safe,
@@ -9553,7 +9548,7 @@ When called with a file name, it opens the named file (in text mode),
 and sets its handle as the default input file.
 When called with a file handle,
 it simply sets this file handle as the default input file.
-When called without parameters,
+When called without arguments,
 it returns the current default input file.
 
 
@@ -9580,7 +9575,7 @@ it returns no values (to finish the loop) and automatically closes the file.
 The call <code>io.lines()</code> (with no file name) is equivalent
 to <code>io.input():lines("*l")</code>;
 that is, it iterates over the lines of the default input file.
-In this case it does not close the file when the loop ends.
+In this case, the iterator does not close the file when the loop ends.
 
 
 <p>
@@ -9963,7 +9958,7 @@ the host system and on the current locale.
 
 
 <p>
-On non-POSIX systems,
+In non-POSIX systems,
 this function may be not thread safe
 because of its reliance on C&nbsp;function <code>gmtime</code> and C&nbsp;function <code>localtime</code>.
 
@@ -10163,7 +10158,7 @@ and explicitly removed when no longer needed.
 
 
 <p>
-On POSIX systems,
+In POSIX systems,
 this function also creates a file with that name,
 to avoid security risks.
 (Someone else might create the file with wrong permissions
@@ -10301,8 +10296,8 @@ The first parameter or local variable has index&nbsp;1, and so on,
 following the order that they are declared in the code,
 counting only the variables that are active
 in the current scope of the function.
-Negative indices refer to vararg parameters;
--1 is the first vararg parameter.
+Negative indices refer to vararg arguments;
+-1 is the first vararg argument.
 The function returns <b>nil</b> if there is no variable with the given index,
 and raises an error when called with a level out of range.
 (You can call <a href="#pdf-debug.getinfo"><code>debug.getinfo</code></a> to check whether the level is valid.)
@@ -10400,7 +10395,7 @@ When called without arguments,
 
 
 <p>
-When the hook is called, its first parameter is a string
+When the hook is called, its first argument is a string
 describing the event that has triggered its call:
 <code>"call"</code> (or <code>"tail call"</code>),
 <code>"return"</code>,
@@ -10551,7 +10546,8 @@ The options are:
 
 <ul>
 <li><b><code>-e <em>stat</em></code>: </b> executes string <em>stat</em>;</li>
-<li><b><code>-l <em>mod</em></code>: </b> "requires" <em>mod</em>;</li>
+<li><b><code>-l <em>mod</em></code>: </b> "requires" <em>mod</em> and assigns the
+  result to global @<em>mod</em>;</li>
 <li><b><code>-i</code>: </b> enters interactive mode after running <em>script</em>;</li>
 <li><b><code>-v</code>: </b> prints version information;</li>
 <li><b><code>-E</code>: </b> ignores environment variables;</li>
@@ -10629,7 +10625,7 @@ For instance, the call
 </pre><p>
 will print "<code>-e</code>".
 If there is a script,
-the script is called with parameters
+the script is called with arguments
 <code>arg[1]</code>, &middot;&middot;&middot;, <code>arg[#arg]</code>.
 (Like all chunks in Lua,
 the script is compiled as a vararg function.)
@@ -10815,7 +10811,7 @@ The following functions were deprecated in the mathematical library:
 <code>frexp</code>, and <code>ldexp</code>.
 You can replace <code>math.pow(x,y)</code> with <code>x^y</code>;
 you can replace <code>math.atan2</code> with <code>math.atan</code>,
-which now accepts one or two parameters;
+which now accepts one or two arguments;
 you can replace <code>math.ldexp(x,exp)</code> with <code>x * 2.0^exp</code>.
 For the other operations,
 you can either use an external library or
@@ -10850,7 +10846,7 @@ of the first result.)
 <ul>
 
 <li>
-Continuation functions now receive as parameters what they needed
+Continuation functions now receive as arguments what they needed
 to get through <code>lua_getctx</code>,
 so <code>lua_getctx</code> has been removed.
 Adapt your code accordingly.
@@ -10973,12 +10969,13 @@ and LiteralString, see <a href="#3.1">&sect;3.1</a>.)
 
 
 
+
 <P CLASS="footer">
 Last update:
-Mon Jan  9 13:30:53 BRST 2017
+Tue Jun 26 13:16:37 -03 2018
 </P>
 <!--
-Last change: revised for Lua 5.3.4
+Last change: revised for Lua 5.3.5
 -->
 
 </body></html>
diff --git a/libs/lua53/lua53-src/doc/readme.html b/libs/lua53/lua53-src/doc/readme.html
index 96a9386e2..b118f7b02 100644
--- a/libs/lua53/lua53-src/doc/readme.html
+++ b/libs/lua53/lua53-src/doc/readme.html
@@ -107,7 +107,7 @@ Here are the details.
 <OL>
 <LI>
 Open a terminal window and move to
-the top-level directory, which is named <TT>lua-5.3.x</TT>.
+the top-level directory, which is named <TT>lua-5.3.5</TT>.
 The <TT>Makefile</TT> there controls both the build process and the installation process.
 <P>
 <LI>
@@ -355,10 +355,10 @@ THE SOFTWARE.
 
 <P CLASS="footer">
 Last update:
-Thu Dec 22 18:22:57 BRST 2016
+Mon Jun 18 22:57:33 -03 2018
 </P>
 <!--
-Last change: revised for Lua 5.3.4
+Last change: revised for Lua 5.3.5
 -->
 
 </BODY>
diff --git a/libs/lua53/lua53-src/src/Makefile b/libs/lua53/lua53-src/src/Makefile
index d71c75c87..64c78f775 100644
--- a/libs/lua53/lua53-src/src/Makefile
+++ b/libs/lua53/lua53-src/src/Makefile
@@ -102,7 +102,7 @@ c89:
 
 
 freebsd:
-	$(MAKE) $(ALL) SYSCFLAGS="-DLUA_USE_LINUX" SYSLIBS="-Wl,-E -lreadline"
+	$(MAKE) $(ALL) SYSCFLAGS="-DLUA_USE_LINUX -DLUA_USE_READLINE -I/usr/include/edit" SYSLIBS="-Wl,-E -ledit" CC="cc"
 
 generic: $(ALL)
 
@@ -110,7 +110,7 @@ linux:
 	$(MAKE) $(ALL) SYSCFLAGS="-DLUA_USE_LINUX" SYSLIBS="-Wl,-E -ldl -lreadline"
 
 macosx:
-	$(MAKE) $(ALL) SYSCFLAGS="-DLUA_USE_MACOSX" SYSLIBS="-lreadline" CC=cc
+	$(MAKE) $(ALL) SYSCFLAGS="-DLUA_USE_MACOSX" SYSLIBS="-lreadline"
 
 mingw:
 	$(MAKE) "LUA_A=lua53.dll" "LUA_T=lua.exe" \
diff --git a/libs/lua53/lua53-src/src/lapi.c b/libs/lua53/lua53-src/src/lapi.c
index c9455a5d8..02b7fab7e 100644
--- a/libs/lua53/lua53-src/src/lapi.c
+++ b/libs/lua53/lua53-src/src/lapi.c
@@ -1,5 +1,5 @@
 /*
-** $Id: lapi.c,v 2.259 2016/02/29 14:27:14 roberto Exp $
+** $Id: lapi.c,v 2.259.1.2 2017/12/06 18:35:12 roberto Exp $
 ** Lua API
 ** See Copyright Notice in lua.h
 */
@@ -533,6 +533,7 @@ LUA_API void lua_pushcclosure (lua_State *L, lua_CFunction fn, int n) {
   lua_lock(L);
   if (n == 0) {
     setfvalue(L->top, fn);
+    api_incr_top(L);
   }
   else {
     CClosure *cl;
@@ -546,9 +547,9 @@ LUA_API void lua_pushcclosure (lua_State *L, lua_CFunction fn, int n) {
       /* does not need barrier because closure is white */
     }
     setclCvalue(L, L->top, cl);
+    api_incr_top(L);
+    luaC_checkGC(L);
   }
-  api_incr_top(L);
-  luaC_checkGC(L);
   lua_unlock(L);
 }
 
diff --git a/libs/lua53/lua53-src/src/lapi.h b/libs/lua53/lua53-src/src/lapi.h
index 6d36dee3f..8e16ad53d 100644
--- a/libs/lua53/lua53-src/src/lapi.h
+++ b/libs/lua53/lua53-src/src/lapi.h
@@ -1,5 +1,5 @@
 /*
-** $Id: lapi.h,v 2.9 2015/03/06 19:49:50 roberto Exp $
+** $Id: lapi.h,v 2.9.1.1 2017/04/19 17:20:42 roberto Exp $
 ** Auxiliary functions from Lua API
 ** See Copyright Notice in lua.h
 */
diff --git a/libs/lua53/lua53-src/src/lauxlib.c b/libs/lua53/lua53-src/src/lauxlib.c
index f7a383663..8bdada50a 100644
--- a/libs/lua53/lua53-src/src/lauxlib.c
+++ b/libs/lua53/lua53-src/src/lauxlib.c
@@ -1,5 +1,5 @@
 /*
-** $Id: lauxlib.c,v 1.289 2016/12/20 18:37:00 roberto Exp $
+** $Id: lauxlib.c,v 1.289.1.1 2017/04/19 17:20:42 roberto Exp $
 ** Auxiliary functions for building Lua libraries
 ** See Copyright Notice in lua.h
 */
diff --git a/libs/lua53/lua53-src/src/lauxlib.h b/libs/lua53/lua53-src/src/lauxlib.h
index 9a2e66aa0..9857d3a83 100644
--- a/libs/lua53/lua53-src/src/lauxlib.h
+++ b/libs/lua53/lua53-src/src/lauxlib.h
@@ -1,5 +1,5 @@
 /*
-** $Id: lauxlib.h,v 1.131 2016/12/06 14:54:31 roberto Exp $
+** $Id: lauxlib.h,v 1.131.1.1 2017/04/19 17:20:42 roberto Exp $
 ** Auxiliary functions for building Lua libraries
 ** See Copyright Notice in lua.h
 */
diff --git a/libs/lua53/lua53-src/src/lbaselib.c b/libs/lua53/lua53-src/src/lbaselib.c
index 08523e6e7..6460e4f8d 100644
--- a/libs/lua53/lua53-src/src/lbaselib.c
+++ b/libs/lua53/lua53-src/src/lbaselib.c
@@ -1,5 +1,5 @@
 /*
-** $Id: lbaselib.c,v 1.314 2016/09/05 19:06:34 roberto Exp $
+** $Id: lbaselib.c,v 1.314.1.1 2017/04/19 17:39:34 roberto Exp $
 ** Basic library
 ** See Copyright Notice in lua.h
 */
diff --git a/libs/lua53/lua53-src/src/lbitlib.c b/libs/lua53/lua53-src/src/lbitlib.c
index 1cb1d5b93..4786c0d48 100644
--- a/libs/lua53/lua53-src/src/lbitlib.c
+++ b/libs/lua53/lua53-src/src/lbitlib.c
@@ -1,5 +1,5 @@
 /*
-** $Id: lbitlib.c,v 1.30 2015/11/11 19:08:09 roberto Exp $
+** $Id: lbitlib.c,v 1.30.1.1 2017/04/19 17:20:42 roberto Exp $
 ** Standard library for bitwise operations
 ** See Copyright Notice in lua.h
 */
diff --git a/libs/lua53/lua53-src/src/lcode.c b/libs/lua53/lua53-src/src/lcode.c
index 0bb414262..12619f54a 100644
--- a/libs/lua53/lua53-src/src/lcode.c
+++ b/libs/lua53/lua53-src/src/lcode.c
@@ -1,5 +1,5 @@
 /*
-** $Id: lcode.c,v 2.112 2016/12/22 13:08:50 roberto Exp $
+** $Id: lcode.c,v 2.112.1.1 2017/04/19 17:20:42 roberto Exp $
 ** Code generator for Lua
 ** See Copyright Notice in lua.h
 */
diff --git a/libs/lua53/lua53-src/src/lcode.h b/libs/lua53/lua53-src/src/lcode.h
index cd306d573..882dc9c15 100644
--- a/libs/lua53/lua53-src/src/lcode.h
+++ b/libs/lua53/lua53-src/src/lcode.h
@@ -1,5 +1,5 @@
 /*
-** $Id: lcode.h,v 1.64 2016/01/05 16:22:37 roberto Exp $
+** $Id: lcode.h,v 1.64.1.1 2017/04/19 17:20:42 roberto Exp $
 ** Code generator for Lua
 ** See Copyright Notice in lua.h
 */
diff --git a/libs/lua53/lua53-src/src/lcorolib.c b/libs/lua53/lua53-src/src/lcorolib.c
index 2303429e7..0b17af9e3 100644
--- a/libs/lua53/lua53-src/src/lcorolib.c
+++ b/libs/lua53/lua53-src/src/lcorolib.c
@@ -1,5 +1,5 @@
 /*
-** $Id: lcorolib.c,v 1.10 2016/04/11 19:19:55 roberto Exp $
+** $Id: lcorolib.c,v 1.10.1.1 2017/04/19 17:20:42 roberto Exp $
 ** Coroutine Library
 ** See Copyright Notice in lua.h
 */
diff --git a/libs/lua53/lua53-src/src/lctype.c b/libs/lua53/lua53-src/src/lctype.c
index ae9367e69..f8ad7a2ed 100644
--- a/libs/lua53/lua53-src/src/lctype.c
+++ b/libs/lua53/lua53-src/src/lctype.c
@@ -1,5 +1,5 @@
 /*
-** $Id: lctype.c,v 1.12 2014/11/02 19:19:04 roberto Exp $
+** $Id: lctype.c,v 1.12.1.1 2017/04/19 17:20:42 roberto Exp $
 ** 'ctype' functions for Lua
 ** See Copyright Notice in lua.h
 */
diff --git a/libs/lua53/lua53-src/src/lctype.h b/libs/lua53/lua53-src/src/lctype.h
index b961175bc..a963eb901 100644
--- a/libs/lua53/lua53-src/src/lctype.h
+++ b/libs/lua53/lua53-src/src/lctype.h
@@ -1,5 +1,5 @@
 /*
-** $Id: lctype.h,v 1.12 2011/07/15 12:50:29 roberto Exp $
+** $Id: lctype.h,v 1.12.1.1 2013/04/12 18:48:47 roberto Exp $
 ** 'ctype' functions for Lua
 ** See Copyright Notice in lua.h
 */
@@ -76,6 +76,7 @@ LUAI_DDEC const lu_byte luai_ctype_[UCHAR_MAX + 2];
 
 
 #else			/* }{ */
+
 /*
 ** use standard C ctypes
 */
diff --git a/libs/lua53/lua53-src/src/lctype.h.orig b/libs/lua53/lua53-src/src/lctype.h.orig
index 99c7d1223..b09b21a33 100644
--- a/libs/lua53/lua53-src/src/lctype.h.orig
+++ b/libs/lua53/lua53-src/src/lctype.h.orig
@@ -1,5 +1,5 @@
 /*
-** $Id: lctype.h,v 1.12 2011/07/15 12:50:29 roberto Exp $
+** $Id: lctype.h,v 1.12.1.1 2013/04/12 18:48:47 roberto Exp $
 ** 'ctype' functions for Lua
 ** See Copyright Notice in lua.h
 */
diff --git a/libs/lua53/lua53-src/src/ldblib.c b/libs/lua53/lua53-src/src/ldblib.c
index 786f6cd95..9d29afb0a 100644
--- a/libs/lua53/lua53-src/src/ldblib.c
+++ b/libs/lua53/lua53-src/src/ldblib.c
@@ -1,5 +1,5 @@
 /*
-** $Id: ldblib.c,v 1.151 2015/11/23 11:29:43 roberto Exp $
+** $Id: ldblib.c,v 1.151.1.1 2017/04/19 17:20:42 roberto Exp $
 ** Interface from Lua to its debug API
 ** See Copyright Notice in lua.h
 */
diff --git a/libs/lua53/lua53-src/src/ldebug.c b/libs/lua53/lua53-src/src/ldebug.c
index 239affb76..e1389296e 100644
--- a/libs/lua53/lua53-src/src/ldebug.c
+++ b/libs/lua53/lua53-src/src/ldebug.c
@@ -1,5 +1,5 @@
 /*
-** $Id: ldebug.c,v 2.121 2016/10/19 12:32:10 roberto Exp $
+** $Id: ldebug.c,v 2.121.1.2 2017/07/10 17:21:50 roberto Exp $
 ** Debug Interface
 ** See Copyright Notice in lua.h
 */
@@ -653,6 +653,7 @@ l_noret luaG_runerror (lua_State *L, const char *fmt, ...) {
   CallInfo *ci = L->ci;
   const char *msg;
   va_list argp;
+  luaC_checkGC(L);  /* error message uses memory */
   va_start(argp, fmt);
   msg = luaO_pushvfstring(L, fmt, argp);  /* format message */
   va_end(argp);
diff --git a/libs/lua53/lua53-src/src/ldebug.h b/libs/lua53/lua53-src/src/ldebug.h
index 0e31546b1..8cea0ee0a 100644
--- a/libs/lua53/lua53-src/src/ldebug.h
+++ b/libs/lua53/lua53-src/src/ldebug.h
@@ -1,5 +1,5 @@
 /*
-** $Id: ldebug.h,v 2.14 2015/05/22 17:45:56 roberto Exp $
+** $Id: ldebug.h,v 2.14.1.1 2017/04/19 17:20:42 roberto Exp $
 ** Auxiliary functions from Debug Interface module
 ** See Copyright Notice in lua.h
 */
diff --git a/libs/lua53/lua53-src/src/ldo.c b/libs/lua53/lua53-src/src/ldo.c
index 90b695fb0..316e45c8f 100644
--- a/libs/lua53/lua53-src/src/ldo.c
+++ b/libs/lua53/lua53-src/src/ldo.c
@@ -1,5 +1,5 @@
 /*
-** $Id: ldo.c,v 2.157 2016/12/13 15:52:21 roberto Exp $
+** $Id: ldo.c,v 2.157.1.1 2017/04/19 17:20:42 roberto Exp $
 ** Stack and Call structure of Lua
 ** See Copyright Notice in lua.h
 */
diff --git a/libs/lua53/lua53-src/src/ldo.h b/libs/lua53/lua53-src/src/ldo.h
index 4f5d51c3c..3b2983a38 100644
--- a/libs/lua53/lua53-src/src/ldo.h
+++ b/libs/lua53/lua53-src/src/ldo.h
@@ -1,5 +1,5 @@
 /*
-** $Id: ldo.h,v 2.29 2015/12/21 13:02:14 roberto Exp $
+** $Id: ldo.h,v 2.29.1.1 2017/04/19 17:20:42 roberto Exp $
 ** Stack and Call structure of Lua
 ** See Copyright Notice in lua.h
 */
diff --git a/libs/lua53/lua53-src/src/ldump.c b/libs/lua53/lua53-src/src/ldump.c
index 016e30082..f025acac3 100644
--- a/libs/lua53/lua53-src/src/ldump.c
+++ b/libs/lua53/lua53-src/src/ldump.c
@@ -1,5 +1,5 @@
 /*
-** $Id: ldump.c,v 2.37 2015/10/08 15:53:49 roberto Exp $
+** $Id: ldump.c,v 2.37.1.1 2017/04/19 17:20:42 roberto Exp $
 ** save precompiled Lua chunks
 ** See Copyright Notice in lua.h
 */
diff --git a/libs/lua53/lua53-src/src/lfunc.c b/libs/lua53/lua53-src/src/lfunc.c
index 67967dab3..ccafbb8ab 100644
--- a/libs/lua53/lua53-src/src/lfunc.c
+++ b/libs/lua53/lua53-src/src/lfunc.c
@@ -1,5 +1,5 @@
 /*
-** $Id: lfunc.c,v 2.45 2014/11/02 19:19:04 roberto Exp $
+** $Id: lfunc.c,v 2.45.1.1 2017/04/19 17:39:34 roberto Exp $
 ** Auxiliary functions to manipulate prototypes and closures
 ** See Copyright Notice in lua.h
 */
diff --git a/libs/lua53/lua53-src/src/lfunc.h b/libs/lua53/lua53-src/src/lfunc.h
index 2eeb0d5a4..c916e9878 100644
--- a/libs/lua53/lua53-src/src/lfunc.h
+++ b/libs/lua53/lua53-src/src/lfunc.h
@@ -1,5 +1,5 @@
 /*
-** $Id: lfunc.h,v 2.15 2015/01/13 15:49:11 roberto Exp $
+** $Id: lfunc.h,v 2.15.1.1 2017/04/19 17:39:34 roberto Exp $
 ** Auxiliary functions to manipulate prototypes and closures
 ** See Copyright Notice in lua.h
 */
diff --git a/libs/lua53/lua53-src/src/lgc.c b/libs/lua53/lua53-src/src/lgc.c
index ba2c19e14..db4df8292 100644
--- a/libs/lua53/lua53-src/src/lgc.c
+++ b/libs/lua53/lua53-src/src/lgc.c
@@ -1,5 +1,5 @@
 /*
-** $Id: lgc.c,v 2.215 2016/12/22 13:08:50 roberto Exp $
+** $Id: lgc.c,v 2.215.1.2 2017/08/31 16:15:27 roberto Exp $
 ** Garbage Collector
 ** See Copyright Notice in lua.h
 */
@@ -643,8 +643,9 @@ static void clearkeys (global_State *g, GCObject *l, GCObject *f) {
     for (n = gnode(h, 0); n < limit; n++) {
       if (!ttisnil(gval(n)) && (iscleared(g, gkey(n)))) {
         setnilvalue(gval(n));  /* remove value ... */
-        removeentry(n);  /* and remove entry from table */
       }
+      if (ttisnil(gval(n)))  /* is entry empty? */
+        removeentry(n);  /* remove entry from table */
     }
   }
 }
diff --git a/libs/lua53/lua53-src/src/lgc.h b/libs/lua53/lua53-src/src/lgc.h
index aed3e18a5..425cd7cef 100644
--- a/libs/lua53/lua53-src/src/lgc.h
+++ b/libs/lua53/lua53-src/src/lgc.h
@@ -1,5 +1,5 @@
 /*
-** $Id: lgc.h,v 2.91 2015/12/21 13:02:14 roberto Exp $
+** $Id: lgc.h,v 2.91.1.1 2017/04/19 17:39:34 roberto Exp $
 ** Garbage Collector
 ** See Copyright Notice in lua.h
 */
diff --git a/libs/lua53/lua53-src/src/linit.c b/libs/lua53/lua53-src/src/linit.c
index afcaf98b2..480da52c7 100644
--- a/libs/lua53/lua53-src/src/linit.c
+++ b/libs/lua53/lua53-src/src/linit.c
@@ -1,5 +1,5 @@
 /*
-** $Id: linit.c,v 1.39 2016/12/04 20:17:24 roberto Exp $
+** $Id: linit.c,v 1.39.1.1 2017/04/19 17:20:42 roberto Exp $
 ** Initialization of libraries for lua.c and other clients
 ** See Copyright Notice in lua.h
 */
diff --git a/libs/lua53/lua53-src/src/liolib.c b/libs/lua53/lua53-src/src/liolib.c
index d47be5a27..76f372acb 100644
--- a/libs/lua53/lua53-src/src/liolib.c
+++ b/libs/lua53/lua53-src/src/liolib.c
@@ -1,5 +1,5 @@
 /*
-** $Id: liolib.c,v 2.151 2016/12/20 18:37:00 roberto Exp $
+** $Id: liolib.c,v 2.151.1.1 2017/04/19 17:29:57 roberto Exp $
 ** Standard I/O (and system) library
 ** See Copyright Notice in lua.h
 */
@@ -209,11 +209,16 @@ static int aux_close (lua_State *L) {
 }
 
 
+static int f_close (lua_State *L) {
+  tofile(L);  /* make sure argument is an open stream */
+  return aux_close(L);
+}
+
+
 static int io_close (lua_State *L) {
   if (lua_isnone(L, 1))  /* no argument? */
     lua_getfield(L, LUA_REGISTRYINDEX, IO_OUTPUT);  /* use standard output */
-  tofile(L);  /* make sure argument is an open stream */
-  return aux_close(L);
+  return f_close(L);
 }
 
 
@@ -715,7 +720,7 @@ static const luaL_Reg iolib[] = {
 ** methods for file handles
 */
 static const luaL_Reg flib[] = {
-  {"close", io_close},
+  {"close", f_close},
   {"flush", f_flush},
   {"lines", f_lines},
   {"read", f_read},
diff --git a/libs/lua53/lua53-src/src/liolib.c.orig b/libs/lua53/lua53-src/src/liolib.c.orig
index 156840358..8a9e75cd0 100644
--- a/libs/lua53/lua53-src/src/liolib.c.orig
+++ b/libs/lua53/lua53-src/src/liolib.c.orig
@@ -1,5 +1,5 @@
 /*
-** $Id: liolib.c,v 2.151 2016/12/20 18:37:00 roberto Exp $
+** $Id: liolib.c,v 2.151.1.1 2017/04/19 17:29:57 roberto Exp $
 ** Standard I/O (and system) library
 ** See Copyright Notice in lua.h
 */
@@ -206,11 +206,16 @@ static int aux_close (lua_State *L) {
 }
 
 
+static int f_close (lua_State *L) {
+  tofile(L);  /* make sure argument is an open stream */
+  return aux_close(L);
+}
+
+
 static int io_close (lua_State *L) {
   if (lua_isnone(L, 1))  /* no argument? */
     lua_getfield(L, LUA_REGISTRYINDEX, IO_OUTPUT);  /* use standard output */
-  tofile(L);  /* make sure argument is an open stream */
-  return aux_close(L);
+  return f_close(L);
 }
 
 
@@ -712,7 +717,7 @@ static const luaL_Reg iolib[] = {
 ** methods for file handles
 */
 static const luaL_Reg flib[] = {
-  {"close", io_close},
+  {"close", f_close},
   {"flush", f_flush},
   {"lines", f_lines},
   {"read", f_read},
diff --git a/libs/lua53/lua53-src/src/llex.c b/libs/lua53/lua53-src/src/llex.c
index 70328273f..66fd411ba 100644
--- a/libs/lua53/lua53-src/src/llex.c
+++ b/libs/lua53/lua53-src/src/llex.c
@@ -1,5 +1,5 @@
 /*
-** $Id: llex.c,v 2.96 2016/05/02 14:02:12 roberto Exp $
+** $Id: llex.c,v 2.96.1.1 2017/04/19 17:20:42 roberto Exp $
 ** Lexical Analyzer
 ** See Copyright Notice in lua.h
 */
diff --git a/libs/lua53/lua53-src/src/llex.h b/libs/lua53/lua53-src/src/llex.h
index 2363d87e4..2ed0af66a 100644
--- a/libs/lua53/lua53-src/src/llex.h
+++ b/libs/lua53/lua53-src/src/llex.h
@@ -1,5 +1,5 @@
 /*
-** $Id: llex.h,v 1.79 2016/05/02 14:02:12 roberto Exp $
+** $Id: llex.h,v 1.79.1.1 2017/04/19 17:20:42 roberto Exp $
 ** Lexical Analyzer
 ** See Copyright Notice in lua.h
 */
diff --git a/libs/lua53/lua53-src/src/llimits.h b/libs/lua53/lua53-src/src/llimits.h
index f21377fef..d1036f6bc 100644
--- a/libs/lua53/lua53-src/src/llimits.h
+++ b/libs/lua53/lua53-src/src/llimits.h
@@ -1,5 +1,5 @@
 /*
-** $Id: llimits.h,v 1.141 2015/11/19 19:16:22 roberto Exp $
+** $Id: llimits.h,v 1.141.1.1 2017/04/19 17:20:42 roberto Exp $
 ** Limits, basic types, and some other 'installation-dependent' definitions
 ** See Copyright Notice in lua.h
 */
diff --git a/libs/lua53/lua53-src/src/lmathlib.c b/libs/lua53/lua53-src/src/lmathlib.c
index b7f8baee0..7ef7e593f 100644
--- a/libs/lua53/lua53-src/src/lmathlib.c
+++ b/libs/lua53/lua53-src/src/lmathlib.c
@@ -1,5 +1,5 @@
 /*
-** $Id: lmathlib.c,v 1.119 2016/12/22 13:08:50 roberto Exp $
+** $Id: lmathlib.c,v 1.119.1.1 2017/04/19 17:20:42 roberto Exp $
 ** Standard mathematical library
 ** See Copyright Notice in lua.h
 */
diff --git a/libs/lua53/lua53-src/src/lmem.c b/libs/lua53/lua53-src/src/lmem.c
index 0a0476cc7..0241cc3ba 100644
--- a/libs/lua53/lua53-src/src/lmem.c
+++ b/libs/lua53/lua53-src/src/lmem.c
@@ -1,5 +1,5 @@
 /*
-** $Id: lmem.c,v 1.91 2015/03/06 19:45:54 roberto Exp $
+** $Id: lmem.c,v 1.91.1.1 2017/04/19 17:20:42 roberto Exp $
 ** Interface to Memory Manager
 ** See Copyright Notice in lua.h
 */
diff --git a/libs/lua53/lua53-src/src/lmem.h b/libs/lua53/lua53-src/src/lmem.h
index 30f484895..357b1e43e 100644
--- a/libs/lua53/lua53-src/src/lmem.h
+++ b/libs/lua53/lua53-src/src/lmem.h
@@ -1,5 +1,5 @@
 /*
-** $Id: lmem.h,v 1.43 2014/12/19 17:26:14 roberto Exp $
+** $Id: lmem.h,v 1.43.1.1 2017/04/19 17:20:42 roberto Exp $
 ** Interface to Memory Manager
 ** See Copyright Notice in lua.h
 */
diff --git a/libs/lua53/lua53-src/src/loadlib.c b/libs/lua53/lua53-src/src/loadlib.c
index 4791e748b..45f44d322 100644
--- a/libs/lua53/lua53-src/src/loadlib.c
+++ b/libs/lua53/lua53-src/src/loadlib.c
@@ -1,5 +1,5 @@
 /*
-** $Id: loadlib.c,v 1.130 2017/01/12 17:14:26 roberto Exp $
+** $Id: loadlib.c,v 1.130.1.1 2017/04/19 17:20:42 roberto Exp $
 ** Dynamic library loader for Lua
 ** See Copyright Notice in lua.h
 **
diff --git a/libs/lua53/lua53-src/src/lobject.c b/libs/lua53/lua53-src/src/lobject.c
index 2da76899a..2218c8cdd 100644
--- a/libs/lua53/lua53-src/src/lobject.c
+++ b/libs/lua53/lua53-src/src/lobject.c
@@ -1,5 +1,5 @@
 /*
-** $Id: lobject.c,v 2.113 2016/12/22 13:08:50 roberto Exp $
+** $Id: lobject.c,v 2.113.1.1 2017/04/19 17:29:57 roberto Exp $
 ** Some generic functions over Lua objects
 ** See Copyright Notice in lua.h
 */
@@ -435,7 +435,8 @@ const char *luaO_pushvfstring (lua_State *L, const char *fmt, va_list argp) {
       }
       case 'p': {  /* a pointer */
         char buff[4*sizeof(void *) + 8]; /* should be enough space for a '%p' */
-        int l = l_sprintf(buff, sizeof(buff), "%p", va_arg(argp, void *));
+        void *p = va_arg(argp, void *);
+        int l = lua_pointer2str(buff, sizeof(buff), p);
         pushstr(L, buff, l);
         break;
       }
diff --git a/libs/lua53/lua53-src/src/lobject.h b/libs/lua53/lua53-src/src/lobject.h
index 3c0422894..240886140 100644
--- a/libs/lua53/lua53-src/src/lobject.h
+++ b/libs/lua53/lua53-src/src/lobject.h
@@ -1,5 +1,5 @@
 /*
-** $Id: lobject.h,v 2.117 2016/08/01 19:51:24 roberto Exp $
+** $Id: lobject.h,v 2.117.1.1 2017/04/19 17:39:34 roberto Exp $
 ** Type definitions for Lua objects
 ** See Copyright Notice in lua.h
 */
diff --git a/libs/lua53/lua53-src/src/lopcodes.c b/libs/lua53/lua53-src/src/lopcodes.c
index a1cbef857..5ca3eb261 100644
--- a/libs/lua53/lua53-src/src/lopcodes.c
+++ b/libs/lua53/lua53-src/src/lopcodes.c
@@ -1,5 +1,5 @@
 /*
-** $Id: lopcodes.c,v 1.55 2015/01/05 13:48:33 roberto Exp $
+** $Id: lopcodes.c,v 1.55.1.1 2017/04/19 17:20:42 roberto Exp $
 ** Opcodes for Lua virtual machine
 ** See Copyright Notice in lua.h
 */
diff --git a/libs/lua53/lua53-src/src/lopcodes.h b/libs/lua53/lua53-src/src/lopcodes.h
index f9b438e15..df6c2264b 100644
--- a/libs/lua53/lua53-src/src/lopcodes.h
+++ b/libs/lua53/lua53-src/src/lopcodes.h
@@ -1,5 +1,5 @@
 /*
-** $Id: lopcodes.h,v 1.149 2016/07/19 17:12:21 roberto Exp $
+** $Id: lopcodes.h,v 1.149.1.1 2017/04/19 17:20:42 roberto Exp $
 ** Opcodes for Lua virtual machine
 ** See Copyright Notice in lua.h
 */
diff --git a/libs/lua53/lua53-src/src/lopcodes.h.orig b/libs/lua53/lua53-src/src/lopcodes.h.orig
index bbc4b6196..6feaa1cd0 100644
--- a/libs/lua53/lua53-src/src/lopcodes.h.orig
+++ b/libs/lua53/lua53-src/src/lopcodes.h.orig
@@ -1,5 +1,5 @@
 /*
-** $Id: lopcodes.h,v 1.149 2016/07/19 17:12:21 roberto Exp $
+** $Id: lopcodes.h,v 1.149.1.1 2017/04/19 17:20:42 roberto Exp $
 ** Opcodes for Lua virtual machine
 ** See Copyright Notice in lua.h
 */
diff --git a/libs/lua53/lua53-src/src/loslib.c b/libs/lua53/lua53-src/src/loslib.c
index 5a94eb906..de590c6b7 100644
--- a/libs/lua53/lua53-src/src/loslib.c
+++ b/libs/lua53/lua53-src/src/loslib.c
@@ -1,5 +1,5 @@
 /*
-** $Id: loslib.c,v 1.65 2016/07/18 17:58:58 roberto Exp $
+** $Id: loslib.c,v 1.65.1.1 2017/04/19 17:29:57 roberto Exp $
 ** Standard Operating System library
 ** See Copyright Notice in lua.h
 */
@@ -293,7 +293,8 @@ static int os_date (lua_State *L) {
   else
     stm = l_localtime(&t, &tmr);
   if (stm == NULL)  /* invalid date? */
-    luaL_error(L, "time result cannot be represented in this installation");
+    return luaL_error(L,
+                 "time result cannot be represented in this installation");
   if (strcmp(s, "*t") == 0) {
     lua_createtable(L, 0, 9);  /* 9 = number of fields */
     setallfields(L, stm);
@@ -340,7 +341,8 @@ static int os_time (lua_State *L) {
     setallfields(L, &ts);  /* update fields with normalized values */
   }
   if (t != (time_t)(l_timet)t || t == (time_t)(-1))
-    luaL_error(L, "time result cannot be represented in this installation");
+    return luaL_error(L,
+                  "time result cannot be represented in this installation");
   l_pushtime(L, t);
   return 1;
 }
diff --git a/libs/lua53/lua53-src/src/lparser.c b/libs/lua53/lua53-src/src/lparser.c
index cd4512d4d..cc54de43c 100644
--- a/libs/lua53/lua53-src/src/lparser.c
+++ b/libs/lua53/lua53-src/src/lparser.c
@@ -1,5 +1,5 @@
 /*
-** $Id: lparser.c,v 2.155 2016/08/01 19:51:24 roberto Exp $
+** $Id: lparser.c,v 2.155.1.2 2017/04/29 18:11:40 roberto Exp $
 ** Lua Parser
 ** See Copyright Notice in lua.h
 */
@@ -1392,7 +1392,7 @@ static void test_then_block (LexState *ls, int *escapelist) {
     luaK_goiffalse(ls->fs, &v);  /* will jump to label if condition is true */
     enterblock(fs, &bl, 0);  /* must enter block before 'goto' */
     gotostat(ls, v.t);  /* handle goto/break */
-    skipnoopstat(ls);  /* skip other no-op statements */
+    while (testnext(ls, ';')) {}  /* skip colons */
     if (block_follow(ls, 0)) {  /* 'goto' is the entire block? */
       leaveblock(fs);
       return;  /* and that is it */
diff --git a/libs/lua53/lua53-src/src/lparser.h b/libs/lua53/lua53-src/src/lparser.h
index 02e9b03ae..f45b23cba 100644
--- a/libs/lua53/lua53-src/src/lparser.h
+++ b/libs/lua53/lua53-src/src/lparser.h
@@ -1,5 +1,5 @@
 /*
-** $Id: lparser.h,v 1.76 2015/12/30 18:16:13 roberto Exp $
+** $Id: lparser.h,v 1.76.1.1 2017/04/19 17:20:42 roberto Exp $
 ** Lua Parser
 ** See Copyright Notice in lua.h
 */
diff --git a/libs/lua53/lua53-src/src/lprefix.h b/libs/lua53/lua53-src/src/lprefix.h
index 02daa837f..9a749a3f3 100644
--- a/libs/lua53/lua53-src/src/lprefix.h
+++ b/libs/lua53/lua53-src/src/lprefix.h
@@ -1,5 +1,5 @@
 /*
-** $Id: lprefix.h,v 1.2 2014/12/29 16:54:13 roberto Exp $
+** $Id: lprefix.h,v 1.2.1.1 2017/04/19 17:20:42 roberto Exp $
 ** Definitions for Lua code that must come before any other header file
 ** See Copyright Notice in lua.h
 */
diff --git a/libs/lua53/lua53-src/src/lstate.c b/libs/lua53/lua53-src/src/lstate.c
index 9194ac341..c1a76643c 100644
--- a/libs/lua53/lua53-src/src/lstate.c
+++ b/libs/lua53/lua53-src/src/lstate.c
@@ -1,5 +1,5 @@
 /*
-** $Id: lstate.c,v 2.133 2015/11/13 12:16:51 roberto Exp $
+** $Id: lstate.c,v 2.133.1.1 2017/04/19 17:39:34 roberto Exp $
 ** Global State
 ** See Copyright Notice in lua.h
 */
diff --git a/libs/lua53/lua53-src/src/lstate.h b/libs/lua53/lua53-src/src/lstate.h
index a469466c4..56b374100 100644
--- a/libs/lua53/lua53-src/src/lstate.h
+++ b/libs/lua53/lua53-src/src/lstate.h
@@ -1,5 +1,5 @@
 /*
-** $Id: lstate.h,v 2.133 2016/12/22 13:08:50 roberto Exp $
+** $Id: lstate.h,v 2.133.1.1 2017/04/19 17:39:34 roberto Exp $
 ** Global State
 ** See Copyright Notice in lua.h
 */
@@ -26,6 +26,24 @@
 ** 'tobefnz': all objects ready to be finalized;
 ** 'fixedgc': all objects that are not to be collected (currently
 ** only small strings, such as reserved words).
+**
+** Moreover, there is another set of lists that control gray objects.
+** These lists are linked by fields 'gclist'. (All objects that
+** can become gray have such a field. The field is not the same
+** in all objects, but it always has this name.)  Any gray object
+** must belong to one of these lists, and all objects in these lists
+** must be gray:
+**
+** 'gray': regular gray objects, still waiting to be visited.
+** 'grayagain': objects that must be revisited at the atomic phase.
+**   That includes
+**   - black objects got in a write barrier;
+**   - all kinds of weak tables during propagation phase;
+**   - all threads.
+** 'weak': tables with weak values to be cleared;
+** 'ephemeron': ephemeron tables with white->white entries;
+** 'allweak': tables with weak keys and/or weak values to be cleared.
+** The last three lists are used only during the atomic phase.
 
 */
 
diff --git a/libs/lua53/lua53-src/src/lstring.c b/libs/lua53/lua53-src/src/lstring.c
index 9351766fd..6257f211d 100644
--- a/libs/lua53/lua53-src/src/lstring.c
+++ b/libs/lua53/lua53-src/src/lstring.c
@@ -1,5 +1,5 @@
 /*
-** $Id: lstring.c,v 2.56 2015/11/23 11:32:51 roberto Exp $
+** $Id: lstring.c,v 2.56.1.1 2017/04/19 17:20:42 roberto Exp $
 ** String table (keeps all strings handled by Lua)
 ** See Copyright Notice in lua.h
 */
diff --git a/libs/lua53/lua53-src/src/lstring.h b/libs/lua53/lua53-src/src/lstring.h
index 27efd2077..d612abd33 100644
--- a/libs/lua53/lua53-src/src/lstring.h
+++ b/libs/lua53/lua53-src/src/lstring.h
@@ -1,5 +1,5 @@
 /*
-** $Id: lstring.h,v 1.61 2015/11/03 15:36:01 roberto Exp $
+** $Id: lstring.h,v 1.61.1.1 2017/04/19 17:20:42 roberto Exp $
 ** String table (keep all strings handled by Lua)
 ** See Copyright Notice in lua.h
 */
diff --git a/libs/lua53/lua53-src/src/lstrlib.c b/libs/lua53/lua53-src/src/lstrlib.c
index c7aa755fa..b4bed7e93 100644
--- a/libs/lua53/lua53-src/src/lstrlib.c
+++ b/libs/lua53/lua53-src/src/lstrlib.c
@@ -1,5 +1,5 @@
 /*
-** $Id: lstrlib.c,v 1.254 2016/12/22 13:08:50 roberto Exp $
+** $Id: lstrlib.c,v 1.254.1.1 2017/04/19 17:29:57 roberto Exp $
 ** Standard library for string operations and pattern-matching
 ** See Copyright Notice in lua.h
 */
@@ -879,7 +879,7 @@ static int lua_number2strx (lua_State *L, char *buff, int sz,
       buff[i] = toupper(uchar(buff[i]));
   }
   else if (fmt[SIZELENMOD] != 'a')
-    luaL_error(L, "modifiers for format '%%a'/'%%A' not implemented");
+    return luaL_error(L, "modifiers for format '%%a'/'%%A' not implemented");
   return n;
 }
 
@@ -1199,8 +1199,8 @@ static int getnum (const char **fmt, int df) {
 static int getnumlimit (Header *h, const char **fmt, int df) {
   int sz = getnum(fmt, df);
   if (sz > MAXINTSIZE || sz <= 0)
-    luaL_error(h->L, "integral size (%d) out of limits [1,%d]",
-                     sz, MAXINTSIZE);
+    return luaL_error(h->L, "integral size (%d) out of limits [1,%d]",
+                            sz, MAXINTSIZE);
   return sz;
 }
 
diff --git a/libs/lua53/lua53-src/src/ltable.c b/libs/lua53/lua53-src/src/ltable.c
index d080189f2..ea4fe7fcb 100644
--- a/libs/lua53/lua53-src/src/ltable.c
+++ b/libs/lua53/lua53-src/src/ltable.c
@@ -1,5 +1,5 @@
 /*
-** $Id: ltable.c,v 2.118 2016/11/07 12:38:35 roberto Exp $
+** $Id: ltable.c,v 2.118.1.4 2018/06/08 16:22:51 roberto Exp $
 ** Lua tables (hash)
 ** See Copyright Notice in lua.h
 */
@@ -223,7 +223,9 @@ static unsigned int computesizes (unsigned int nums[], unsigned int *pna) {
   unsigned int na = 0;  /* number of elements to go to array part */
   unsigned int optimal = 0;  /* optimal size for array part */
   /* loop while keys can fill more than half of total size */
-  for (i = 0, twotoi = 1; *pna > twotoi / 2; i++, twotoi *= 2) {
+  for (i = 0, twotoi = 1;
+       twotoi > 0 && *pna > twotoi / 2;
+       i++, twotoi *= 2) {
     if (nums[i] > 0) {
       a += nums[i];
       if (a > twotoi/2) {  /* more than half elements present? */
@@ -330,17 +332,34 @@ static void setnodevector (lua_State *L, Table *t, unsigned int size) {
 }
 
 
+typedef struct {
+  Table *t;
+  unsigned int nhsize;
+} AuxsetnodeT;
+
+
+static void auxsetnode (lua_State *L, void *ud) {
+  AuxsetnodeT *asn = cast(AuxsetnodeT *, ud);
+  setnodevector(L, asn->t, asn->nhsize);
+}
+
+
 void luaH_resize (lua_State *L, Table *t, unsigned int nasize,
                                           unsigned int nhsize) {
   unsigned int i;
   int j;
+  AuxsetnodeT asn;
   unsigned int oldasize = t->sizearray;
   int oldhsize = allocsizenode(t);
   Node *nold = t->node;  /* save old hash ... */
   if (nasize > oldasize)  /* array part must grow? */
     setarrayvector(L, t, nasize);
   /* create new hash part with appropriate size */
-  setnodevector(L, t, nhsize);
+  asn.t = t; asn.nhsize = nhsize;
+  if (luaD_rawrunprotected(L, auxsetnode, &asn) != LUA_OK) {  /* mem. error? */
+    setarrayvector(L, t, oldasize);  /* array back to its original size */
+    luaD_throw(L, LUA_ERRMEM);  /* rethrow memory error */
+  }
   if (nasize < oldasize) {  /* array part must shrink? */
     t->sizearray = nasize;
     /* re-insert elements from vanishing slice */
@@ -610,13 +629,13 @@ void luaH_setint (lua_State *L, Table *t, lua_Integer key, TValue *value) {
 }
 
 
-static int unbound_search (Table *t, unsigned int j) {
-  unsigned int i = j;  /* i is zero or a present index */
+static lua_Unsigned unbound_search (Table *t, lua_Unsigned j) {
+  lua_Unsigned i = j;  /* i is zero or a present index */
   j++;
   /* find 'i' and 'j' such that i is present and j is not */
   while (!ttisnil(luaH_getint(t, j))) {
     i = j;
-    if (j > cast(unsigned int, MAX_INT)/2) {  /* overflow? */
+    if (j > l_castS2U(LUA_MAXINTEGER) / 2) {  /* overflow? */
       /* table was built with bad purposes: resort to linear search */
       i = 1;
       while (!ttisnil(luaH_getint(t, i))) i++;
@@ -626,7 +645,7 @@ static int unbound_search (Table *t, unsigned int j) {
   }
   /* now do a binary search between them */
   while (j - i > 1) {
-    unsigned int m = (i+j)/2;
+    lua_Unsigned m = (i+j)/2;
     if (ttisnil(luaH_getint(t, m))) j = m;
     else i = m;
   }
@@ -638,7 +657,7 @@ static int unbound_search (Table *t, unsigned int j) {
 ** Try to find a boundary in table 't'. A 'boundary' is an integer index
 ** such that t[i] is non-nil and t[i+1] is nil (and 0 if t[1] is nil).
 */
-int luaH_getn (Table *t) {
+lua_Unsigned luaH_getn (Table *t) {
   unsigned int j = t->sizearray;
   if (j > 0 && ttisnil(&t->array[j - 1])) {
     /* there is a boundary in the array part: (binary) search for it */
diff --git a/libs/lua53/lua53-src/src/ltable.h b/libs/lua53/lua53-src/src/ltable.h
index 6da9024fe..92db0ac7b 100644
--- a/libs/lua53/lua53-src/src/ltable.h
+++ b/libs/lua53/lua53-src/src/ltable.h
@@ -1,5 +1,5 @@
 /*
-** $Id: ltable.h,v 2.23 2016/12/22 13:08:50 roberto Exp $
+** $Id: ltable.h,v 2.23.1.2 2018/05/24 19:39:05 roberto Exp $
 ** Lua tables (hash)
 ** See Copyright Notice in lua.h
 */
@@ -54,7 +54,7 @@ LUAI_FUNC void luaH_resize (lua_State *L, Table *t, unsigned int nasize,
 LUAI_FUNC void luaH_resizearray (lua_State *L, Table *t, unsigned int nasize);
 LUAI_FUNC void luaH_free (lua_State *L, Table *t);
 LUAI_FUNC int luaH_next (lua_State *L, Table *t, StkId key);
-LUAI_FUNC int luaH_getn (Table *t);
+LUAI_FUNC lua_Unsigned luaH_getn (Table *t);
 
 
 #if defined(LUA_DEBUG)
diff --git a/libs/lua53/lua53-src/src/ltablib.c b/libs/lua53/lua53-src/src/ltablib.c
index 98b2f8713..c5349578e 100644
--- a/libs/lua53/lua53-src/src/ltablib.c
+++ b/libs/lua53/lua53-src/src/ltablib.c
@@ -1,5 +1,5 @@
 /*
-** $Id: ltablib.c,v 1.93 2016/02/25 19:41:54 roberto Exp $
+** $Id: ltablib.c,v 1.93.1.1 2017/04/19 17:20:42 roberto Exp $
 ** Library for Table Manipulation
 ** See Copyright Notice in lua.h
 */
diff --git a/libs/lua53/lua53-src/src/ltm.c b/libs/lua53/lua53-src/src/ltm.c
index 14e525788..0e7c71321 100644
--- a/libs/lua53/lua53-src/src/ltm.c
+++ b/libs/lua53/lua53-src/src/ltm.c
@@ -1,5 +1,5 @@
 /*
-** $Id: ltm.c,v 2.38 2016/12/22 13:08:50 roberto Exp $
+** $Id: ltm.c,v 2.38.1.1 2017/04/19 17:39:34 roberto Exp $
 ** Tag methods
 ** See Copyright Notice in lua.h
 */
diff --git a/libs/lua53/lua53-src/src/ltm.h b/libs/lua53/lua53-src/src/ltm.h
index 63db7269b..8170688da 100644
--- a/libs/lua53/lua53-src/src/ltm.h
+++ b/libs/lua53/lua53-src/src/ltm.h
@@ -1,5 +1,5 @@
 /*
-** $Id: ltm.h,v 2.22 2016/02/26 19:20:15 roberto Exp $
+** $Id: ltm.h,v 2.22.1.1 2017/04/19 17:20:42 roberto Exp $
 ** Tag methods
 ** See Copyright Notice in lua.h
 */
diff --git a/libs/lua53/lua53-src/src/lua.c b/libs/lua53/lua53-src/src/lua.c
index 3f082da6b..ca5b29852 100644
--- a/libs/lua53/lua53-src/src/lua.c
+++ b/libs/lua53/lua53-src/src/lua.c
@@ -1,5 +1,5 @@
 /*
-** $Id: lua.c,v 1.230 2017/01/12 17:14:26 roberto Exp $
+** $Id: lua.c,v 1.230.1.1 2017/04/19 17:29:57 roberto Exp $
 ** Lua stand-alone interpreter
 ** See Copyright Notice in lua.h
 */
@@ -138,7 +138,7 @@ static void print_usage (const char *badoption) {
   "Available options are:\n"
   "  -e stat  execute string 'stat'\n"
   "  -i       enter interactive mode after executing 'script'\n"
-  "  -l name  require library 'name'\n"
+  "  -l name  require library 'name' into global 'name'\n"
   "  -v       show version information\n"
   "  -E       ignore environment variables\n"
   "  --       stop handling options\n"
diff --git a/libs/lua53/lua53-src/src/lua.h b/libs/lua53/lua53-src/src/lua.h
index 26c0e2d69..c236e3609 100644
--- a/libs/lua53/lua53-src/src/lua.h
+++ b/libs/lua53/lua53-src/src/lua.h
@@ -1,5 +1,5 @@
 /*
-** $Id: lua.h,v 1.332 2016/12/22 15:51:20 roberto Exp $
+** $Id: lua.h,v 1.332.1.2 2018/06/13 16:58:17 roberto Exp $
 ** Lua - A Scripting Language
 ** Lua.org, PUC-Rio, Brazil (http://www.lua.org)
 ** See Copyright Notice at the end of this file
@@ -19,11 +19,11 @@
 #define LUA_VERSION_MAJOR	"5"
 #define LUA_VERSION_MINOR	"3"
 #define LUA_VERSION_NUM		503
-#define LUA_VERSION_RELEASE	"4"
+#define LUA_VERSION_RELEASE	"5"
 
 #define LUA_VERSION	"Lua " LUA_VERSION_MAJOR "." LUA_VERSION_MINOR
 #define LUA_RELEASE	LUA_VERSION "." LUA_VERSION_RELEASE
-#define LUA_COPYRIGHT	LUA_RELEASE "  Copyright (C) 1994-2017 Lua.org, PUC-Rio"
+#define LUA_COPYRIGHT	LUA_RELEASE "  Copyright (C) 1994-2018 Lua.org, PUC-Rio"
 #define LUA_AUTHORS	"R. Ierusalimschy, L. H. de Figueiredo, W. Celes"
 
 
@@ -460,7 +460,7 @@ struct lua_Debug {
 
 
 /******************************************************************************
-* Copyright (C) 1994-2017 Lua.org, PUC-Rio.
+* Copyright (C) 1994-2018 Lua.org, PUC-Rio.
 *
 * Permission is hereby granted, free of charge, to any person obtaining
 * a copy of this software and associated documentation files (the
diff --git a/libs/lua53/lua53-src/src/luac.c b/libs/lua53/lua53-src/src/luac.c
index c0c91d017..549ad3950 100644
--- a/libs/lua53/lua53-src/src/luac.c
+++ b/libs/lua53/lua53-src/src/luac.c
@@ -1,5 +1,5 @@
 /*
-** $Id: luac.c,v 1.75 2015/03/12 01:58:27 lhf Exp $
+** $Id: luac.c,v 1.76 2018/06/19 01:32:02 lhf Exp $
 ** Lua compiler (saves bytecodes to files; also lists bytecodes)
 ** See Copyright Notice in lua.h
 */
@@ -206,7 +206,7 @@ int main(int argc, char* argv[])
 }
 
 /*
-** $Id: luac.c,v 1.75 2015/03/12 01:58:27 lhf Exp $
+** $Id: luac.c,v 1.76 2018/06/19 01:32:02 lhf Exp $
 ** print bytecodes
 ** See Copyright Notice in lua.h
 */
@@ -348,6 +348,7 @@ static void PrintCode(const Proto* f)
    case OP_ADD:
    case OP_SUB:
    case OP_MUL:
+   case OP_MOD:
    case OP_POW:
    case OP_DIV:
    case OP_IDIV:
diff --git a/libs/lua53/lua53-src/src/luaconf.h b/libs/lua53/lua53-src/src/luaconf.h
index dbd399e3c..9eeeea69e 100644
--- a/libs/lua53/lua53-src/src/luaconf.h
+++ b/libs/lua53/lua53-src/src/luaconf.h
@@ -1,5 +1,5 @@
 /*
-** $Id: luaconf.h,v 1.259 2016/12/22 13:08:50 roberto Exp $
+** $Id: luaconf.h,v 1.259.1.1 2017/04/19 17:29:57 roberto Exp $
 ** Configuration file for Lua
 ** See Copyright Notice in lua.h
 */
@@ -604,8 +604,6 @@
 */
 #if !defined(LUA_USE_C89)
 #define l_sprintf(s,sz,f,i)	snprintf(s,sz,f,i)
-/* Should we use this line ? */
-/*#define l_sprintf(s,sz,f,i)	((void)(sz), sprintf(s,f,i))*/
 #else
 #define l_sprintf(s,sz,f,i)	((void)(sz), sprintf(s,f,i))
 #endif
@@ -622,6 +620,13 @@
 #endif
 
 
+/*
+@@ lua_pointer2str converts a pointer to a readable string in a
+** non-specified way.
+*/
+#define lua_pointer2str(buff,sz,p)	l_sprintf(buff,sz,"%p",p)
+
+
 /*
 @@ lua_number2strx converts a float to an hexadecimal numeric string.
 ** In C99, 'sprintf' (with format specifiers '%a'/'%A') does that.
diff --git a/libs/lua53/lua53-src/src/lualib.h b/libs/lua53/lua53-src/src/lualib.h
index 6c0bc4cb0..f5304aa0d 100644
--- a/libs/lua53/lua53-src/src/lualib.h
+++ b/libs/lua53/lua53-src/src/lualib.h
@@ -1,5 +1,5 @@
 /*
-** $Id: lualib.h,v 1.45 2017/01/12 17:14:26 roberto Exp $
+** $Id: lualib.h,v 1.45.1.1 2017/04/19 17:20:42 roberto Exp $
 ** Lua standard libraries
 ** See Copyright Notice in lua.h
 */
diff --git a/libs/lua53/lua53-src/src/lundump.c b/libs/lua53/lua53-src/src/lundump.c
index 4080af9c0..7a67d75aa 100644
--- a/libs/lua53/lua53-src/src/lundump.c
+++ b/libs/lua53/lua53-src/src/lundump.c
@@ -1,5 +1,5 @@
 /*
-** $Id: lundump.c,v 2.44 2015/11/02 16:09:30 roberto Exp $
+** $Id: lundump.c,v 2.44.1.1 2017/04/19 17:20:42 roberto Exp $
 ** load precompiled Lua chunks
 ** See Copyright Notice in lua.h
 */
diff --git a/libs/lua53/lua53-src/src/lundump.h b/libs/lua53/lua53-src/src/lundump.h
index fe4a97463..f3e2e9061 100644
--- a/libs/lua53/lua53-src/src/lundump.h
+++ b/libs/lua53/lua53-src/src/lundump.h
@@ -1,5 +1,5 @@
 /*
-** $Id: lundump.h,v 1.45 2015/09/08 15:41:05 roberto Exp $
+** $Id: lundump.h,v 1.45.1.1 2017/04/19 17:20:42 roberto Exp $
 ** load precompiled Lua chunks
 ** See Copyright Notice in lua.h
 */
diff --git a/libs/lua53/lua53-src/src/lundump.h.orig b/libs/lua53/lua53-src/src/lundump.h.orig
index aa5cc82f1..ce492d689 100644
--- a/libs/lua53/lua53-src/src/lundump.h.orig
+++ b/libs/lua53/lua53-src/src/lundump.h.orig
@@ -1,5 +1,5 @@
 /*
-** $Id: lundump.h,v 1.45 2015/09/08 15:41:05 roberto Exp $
+** $Id: lundump.h,v 1.45.1.1 2017/04/19 17:20:42 roberto Exp $
 ** load precompiled Lua chunks
 ** See Copyright Notice in lua.h
 */
diff --git a/libs/lua53/lua53-src/src/lutf8lib.c b/libs/lua53/lua53-src/src/lutf8lib.c
index de9e3dcdd..10bd238a7 100644
--- a/libs/lua53/lua53-src/src/lutf8lib.c
+++ b/libs/lua53/lua53-src/src/lutf8lib.c
@@ -1,5 +1,5 @@
 /*
-** $Id: lutf8lib.c,v 1.16 2016/12/22 13:08:50 roberto Exp $
+** $Id: lutf8lib.c,v 1.16.1.1 2017/04/19 17:29:57 roberto Exp $
 ** Standard library for UTF-8 manipulation
 ** See Copyright Notice in lua.h
 */
@@ -171,7 +171,7 @@ static int byteoffset (lua_State *L) {
   }
   else {
     if (iscont(s + posi))
-      luaL_error(L, "initial position is a continuation byte");
+      return luaL_error(L, "initial position is a continuation byte");
     if (n < 0) {
        while (n < 0 && posi > 0) {  /* move back */
          do {  /* find beginning of previous character */
diff --git a/libs/lua53/lua53-src/src/lvm.c b/libs/lua53/lua53-src/src/lvm.c
index 84ade6b2f..cc43d8714 100644
--- a/libs/lua53/lua53-src/src/lvm.c
+++ b/libs/lua53/lua53-src/src/lvm.c
@@ -1,5 +1,5 @@
 /*
-** $Id: lvm.c,v 2.268 2016/02/05 19:59:14 roberto Exp $
+** $Id: lvm.c,v 2.268.1.1 2017/04/19 17:39:34 roberto Exp $
 ** Lua virtual machine
 ** See Copyright Notice in lua.h
 */
diff --git a/libs/lua53/lua53-src/src/lvm.h b/libs/lua53/lua53-src/src/lvm.h
index 422f87194..a8f954f04 100644
--- a/libs/lua53/lua53-src/src/lvm.h
+++ b/libs/lua53/lua53-src/src/lvm.h
@@ -1,5 +1,5 @@
 /*
-** $Id: lvm.h,v 2.41 2016/12/22 13:08:50 roberto Exp $
+** $Id: lvm.h,v 2.41.1.1 2017/04/19 17:20:42 roberto Exp $
 ** Lua virtual machine
 ** See Copyright Notice in lua.h
 */
diff --git a/libs/lua53/lua53-src/src/lzio.c b/libs/lua53/lua53-src/src/lzio.c
index c9e1f491f..6f7909441 100644
--- a/libs/lua53/lua53-src/src/lzio.c
+++ b/libs/lua53/lua53-src/src/lzio.c
@@ -1,5 +1,5 @@
 /*
-** $Id: lzio.c,v 1.37 2015/09/08 15:41:05 roberto Exp $
+** $Id: lzio.c,v 1.37.1.1 2017/04/19 17:20:42 roberto Exp $
 ** Buffered streams
 ** See Copyright Notice in lua.h
 */
diff --git a/libs/lua53/lua53-src/src/lzio.h b/libs/lua53/lua53-src/src/lzio.h
index e7b6f34b1..d89787081 100644
--- a/libs/lua53/lua53-src/src/lzio.h
+++ b/libs/lua53/lua53-src/src/lzio.h
@@ -1,5 +1,5 @@
 /*
-** $Id: lzio.h,v 1.31 2015/09/08 15:41:05 roberto Exp $
+** $Id: lzio.h,v 1.31.1.1 2017/04/19 17:20:42 roberto Exp $
 ** Buffered streams
 ** See Copyright Notice in lua.h
 */
diff --git a/libs/luajit/native/Makefile.am b/libs/luajit/native/Makefile.am
index f89c2fa76..c9ed9d7a1 100644
--- a/libs/luajit/native/Makefile.am
+++ b/libs/luajit/native/Makefile.am
@@ -28,6 +28,7 @@ buildvm_arch.h: minilua$(EXEEXT) $(LUAJIT_TREE)/dynasm/dynasm.lua
 	  `cat ../dynasm_flags` \
 	  -o $@ $(srcdir)/$(LUAJIT_TREE)/src/vm_$(DASM_ARCH).dasc
 
+minilua_CPPFLAGS = $(AM_CPPFLAGS) $(LUAJIT_DEFINES) `cat ../native_flags`
 nodist_minilua_SOURCES = \
 	@LUAJIT_TREE@/src/host/minilua.c
 minilua_LDADD = $(MATH_LIB)
diff --git a/libs/zziplib/zziplib-src/zzip/lib.h b/libs/zziplib/zziplib-src/zzip/lib.h
index 4a02f5473..b09a13028 100644
--- a/libs/zziplib/zziplib-src/zzip/lib.h
+++ b/libs/zziplib/zziplib-src/zzip/lib.h
@@ -16,6 +16,7 @@
 #include <zzip/zzip.h>
 #include <zzip/plugin.h>
 #include <zzip/stdint.h>
+#include <zzip/zzip32.h>
 
 #ifdef __cplusplus
 extern "C" {
diff --git a/texk/web2c/Makefile.am b/texk/web2c/Makefile.am
index 38740776a..ec388fc2b 100644
--- a/texk/web2c/Makefile.am
+++ b/texk/web2c/Makefile.am
@@ -237,6 +237,7 @@ include $(srcdir)/luatexdir/am/libunilib.am
 include $(srcdir)/luatexdir/am/luafontforge.am
 include $(srcdir)/luatexdir/am/libluatex.am
 include $(srcdir)/luatexdir/am/luaffi.am
+include $(srcdir)/luatexdir/am/luapplib.am 
 include $(srcdir)/luatexdir/am/luatex.am
 
 ## XeTeX
diff --git a/texk/web2c/ac/web2c.ac b/texk/web2c/ac/web2c.ac
index 8cf40e03c..27bd6bb2c 100644
--- a/texk/web2c/ac/web2c.ac
+++ b/texk/web2c/ac/web2c.ac
@@ -35,9 +35,9 @@ m4_define([kpse_tex_progs], [dnl
 [[euptex],    [yes], [yes], [e-upTeX],    [ptexenc]],
 [[aleph],     [yes], [],    [Aleph],      []],
 [[pdftex],    [yes], [yes], [pdfTeX],     [xpdf libpng]],
-[[luatex],    [yes], [],    [LuaTeX],     [poppler mpfr libpng zziplib lua52]],
-[[luatex53],  [yes], [],    [LuaTeX53],   [poppler mpfr libpng zziplib lua53]],
-[[luajittex], [yes], [],    [LuaJITTeX],  [poppler mpfr libpng zziplib luajit]],
+[[luatex],    [yes], [],    [LuaTeX],     [libpng zziplib lua52]],
+[[luatex53],  [yes], [],    [LuaTeX53],   [libpng zziplib lua53]],
+[[luajittex], [yes], [],    [LuaJITTeX],  [libpng zziplib luajit]],
 [[mp],        [yes], [],    [MetaPost],   [mpfr cairo libpng]],
 [[pmp],       [yes], [],    [pMetaPost],  [mpfr cairo libpng ptexenc]],
 [[upmp],      [yes], [],    [upMetaPost], [mpfr cairo libpng ptexenc]],
diff --git a/texk/web2c/configure.ac b/texk/web2c/configure.ac
index 6c0839297..5448f6203 100644
--- a/texk/web2c/configure.ac
+++ b/texk/web2c/configure.ac
@@ -46,13 +46,10 @@ KPSE_LT_HACK
 KPSE_WEB2C_PREPARE
 m4_include([ac/web2c.ac])
 
-# LuaTeX and XeTeX now require C++11 because poppler does :(.
+# XeTeX now requires C++11 because poppler does :(.
 # XeTeX also requires C+11 because of ICU.
-if test "x$enable_xetex" = xyes \
-   || test "x$enable_luatex" = xyes \
-   || test "x$enable_luajittex" = xyes \
-   || test "x$enable_luatex53" = xyes; then
-  AC_MSG_NOTICE([checking for C++11, since LuaTeX and/or XeTeX enabled])
+if test "x$enable_xetex" = xyes; then
+  AC_MSG_NOTICE([checking for C++11, since XeTeX enabled])
   AX_CXX_COMPILE_STDCXX([11])
 fi
 
diff --git a/texk/web2c/luatexdir/ChangeLog b/texk/web2c/luatexdir/ChangeLog
index 94cbfc3e6..62d4ab049 100644
--- a/texk/web2c/luatexdir/ChangeLog
+++ b/texk/web2c/luatexdir/ChangeLog
@@ -1,3 +1,7 @@
+2018-08-27 Luigi Scarso <luigi.scarso@gmail.com>
+	* dropped dependency from gmp and mpfr
+
+
 2017-11-02 Luigi Scarso <luigi.scarso@gmail.com>
 	LuaFilesystem 1.7.0
 
diff --git a/texk/web2c/luatexdir/NEWS b/texk/web2c/luatexdir/NEWS
index 91a4ec7fe..5c044e77e 100644
--- a/texk/web2c/luatexdir/NEWS
+++ b/texk/web2c/luatexdir/NEWS
@@ -1,3 +1,38 @@
+==============================================================
+LuaTeX 1.08 2018-08-28
+==============================================================
+
+
+(1) This release is a prelude to 1.10, the next stable iteration of LuaTeX
+after version 1.00.
+
+(2) Lua 5.3 is now considered to be default and we might use 5.4 in version
+1.10. There are no real functional changed expected. You still need to rename
+the binary for 5.3!
+
+(3) Binary mode is no longer available in MPlib but it is still available in
+stand alone MetaPost. This simplifies compilation and reduces dependencies.
+
+(4) The dependency on Poppler for pdf image inclusion has been removed. We
+now use a small dedicated library written by Pawel Jakowski. We no longer
+need c++ compilers. We're in the process of making it behave well on all
+platforms. It has been tested on intel platforms.
+
+(5) We know that there can be some (alignment) issues with the arm platform
+but these are looked into. Therefore, later this year we will release 1.09.
+Version 1.10 is planned for TeXlive. We hope that ffi works ok on intel and
+arm platforms at that point.
+
+(6) There have been some extensions to the Lua libraries and some callbacks
+have been added. Also, a few new primitives have been introduced. The
+documentation mentions the stable extensions.
+
+(7) There are the usual bug fixes and cleanups but there have been no real
+fundamental changes in the API.
+
+
+
+
 ==============================================================
 LuaTeX 1.07 2018-01-17
 ==============================================================
diff --git a/texk/web2c/luatexdir/am/libluatex.am b/texk/web2c/luatexdir/am/libluatex.am
index 3e90186ac..e3678b64b 100644
--- a/texk/web2c/luatexdir/am/libluatex.am
+++ b/texk/web2c/luatexdir/am/libluatex.am
@@ -26,9 +26,10 @@ liblua53tex_a_DEPENDENCIES = libff.a liblua53misc.a
 libluajittex_a_DEPENDENCIES = libff.a libluajitmisc.a
 
 libluatex_a_preflags = $(AM_CPPFLAGS) $(ZLIB_INCLUDES) $(LIBPNG_INCLUDES)
-libluatex_a_preflags += $(POPPLER_INCLUDES) -I$(srcdir)/libmd5
+libluatex_a_preflags += -I$(srcdir)/libmd5
 libluatex_a_preflags += -DpdfTeX -I$(srcdir)/luatexdir
 libluatex_a_preflags += -I$(srcdir)/luatexdir/unilib
+libluatex_a_preflags += -I$(srcdir)/luatexdir/luapplib/util
 libluatex_a_preflags += -I$(srcdir)/luatexdir/luafontloader/fontforge/inc
 libluatex_a_preflags += -DLUA_FF_LIB=1 -I$(srcdir)/luatexdir/luafontloader/fontforge/fontforge
 libluatex_a_preflags += -DSYNCTEX_ENGINE_H='<synctex-luatex.h>' -I$(srcdir)/synctexdir
@@ -43,29 +44,31 @@ liblua53tex_a_CXXFLAGS = $(WARNING_CXXFLAGS)
 libluajittex_a_CXXFLAGS = $(WARNING_CXXFLAGS)
 
 dist_libluatex_a_SOURCES = \
-	luatexdir/lua/lstrlibext.c
+	luatexdir/lua/lstrlibext.c \
+	luatexdir/lua/helpers.c \
+	luatexdir/lua/texluac.c 
 nodist_libluatex_a_SOURCES = \
-	helpers.c luastuff.c texluac.c \
 	$(dist_libluatex_sources) \
 	$(nodist_libluatex_sources)
 dist_liblua53tex_a_SOURCES = \
-	luatexdir/lua/lstrlibext.c
+	luatexdir/lua/lstrlibext.c \
+	luatexdir/lua/helpers.c \
+	luatexdir/lua/texluac.c 
 nodist_liblua53tex_a_SOURCES = \
-	helpers.c luastuff.c texluac.c \
 	$(dist_libluatex_sources) \
 	$(nodist_libluatex_sources)
 dist_libluajittex_a_SOURCES = \
 	luatexdir/lua/lauxlib_bridge.h \
-	luatexdir/lua/lstrlibext.c
+	luatexdir/lua/lstrlibext.c \
+	luatexdir/lua/texluajitc.c
 nodist_libluajittex_a_SOURCES = \
-	luastuff.c texluajitc.c \
 	$(dist_libluatex_sources) \
 	$(nodist_libluatex_sources)
 
 ## mplib "stub" backends are in mplibstuff.c
-$(libluatex_a_OBJECTS): libff.a libmplibcore.a libluamisc.a $(POPPLER_DEPEND)
-$(liblua53tex_a_OBJECTS): libff.a libmplibcore.a liblua53misc.a $(POPPLER_DEPEND)
-$(libluajittex_a_OBJECTS): libff.a libmplibcore.a libluajitmisc.a $(POPPLER_DEPEND)
+$(libluatex_a_OBJECTS): libff.a libmplibcore.a libluamisc.a 
+$(liblua53tex_a_OBJECTS): libff.a libmplibcore.a liblua53misc.a 
+$(libluajittex_a_OBJECTS): libff.a libmplibcore.a libluajitmisc.a 
 
 
 ## from luatexdir
@@ -91,76 +94,77 @@ dist_libluatex_sources += \
 ##
 luatex_dvi_ctangle = $(ctangle_silent)CWEBINPUTS=$(srcdir)/luatexdir/dvi $(ctangle)
 
-dvigen.c: ctangle$(EXEEXT) luatexdir/dvi/dvigen.w
-	$(luatex_dvi_ctangle) dvigen.w
+#dvigen.c: ctangle$(EXEEXT) luatexdir/dvi/dvigen.w
+#	$(luatex_dvi_ctangle) dvigen.w
 
-libluatex_web += luatexdir/dvi/dvigen.w
+#libluatex_web += luatexdir/dvi/dvigen.w
 
-nodist_libluatex_sources += dvigen.c
+#nodist_libluatex_sources += dvigen.c
 
 dist_libluatex_sources += \
-	luatexdir/dvi/dvigen.h
+	luatexdir/dvi/dvigen.h \
+	luatexdir/dvi/dvigen.c
 
 ## from luatexdir/font
 ##
 luatex_font_ctangle = $(ctangle_silent)CWEBINPUTS=$(srcdir)/luatexdir/font $(ctangle)
 
-dofont.c: ctangle$(EXEEXT) luatexdir/font/dofont.w
-	$(luatex_font_ctangle) dofont.w
-luafont.c: ctangle$(EXEEXT) luatexdir/font/luafont.w
-	$(luatex_font_ctangle) luafont.w
-mapfile.c: ctangle$(EXEEXT) luatexdir/font/mapfile.w
-	$(luatex_font_ctangle) mapfile.w
-pkin.c: ctangle$(EXEEXT) luatexdir/font/pkin.w
-	$(luatex_font_ctangle) pkin.w
-sfnt.c: ctangle$(EXEEXT) luatexdir/font/sfnt.w
-	$(luatex_font_ctangle) sfnt.w
-texfont.c: ctangle$(EXEEXT) luatexdir/font/texfont.w
-	$(luatex_font_ctangle) texfont.w
-tfmofm.c: ctangle$(EXEEXT) luatexdir/font/tfmofm.w
-	$(luatex_font_ctangle) tfmofm.w
-tounicode.c: ctangle$(EXEEXT) luatexdir/font/tounicode.w
-	$(luatex_font_ctangle) tounicode.w
-tt_glyf.c: ctangle$(EXEEXT) luatexdir/font/tt_glyf.w
-	$(luatex_font_ctangle) tt_glyf.w
-tt_table.c: ctangle$(EXEEXT) luatexdir/font/tt_table.w
-	$(luatex_font_ctangle) tt_table.w
-vfovf.c: ctangle$(EXEEXT) luatexdir/font/vfovf.w
-	$(luatex_font_ctangle) vfovf.w
-vfpacket.c: ctangle$(EXEEXT) luatexdir/font/vfpacket.w
-	$(luatex_font_ctangle) vfpacket.w
-writecff.c: ctangle$(EXEEXT) luatexdir/font/writecff.w
-	$(luatex_font_ctangle) writecff.w
-writeenc.c: ctangle$(EXEEXT) luatexdir/font/writeenc.w
-	$(luatex_font_ctangle) writeenc.w
-writefont.c: ctangle$(EXEEXT) luatexdir/font/writefont.w
-	$(luatex_font_ctangle) writefont.w
-writet1.c: ctangle$(EXEEXT) luatexdir/font/writet1.w
-	$(luatex_font_ctangle) writet1.w
-writet3.c: ctangle$(EXEEXT) luatexdir/font/writet3.w
-	$(luatex_font_ctangle) writet3.w
-writettf.c: ctangle$(EXEEXT) luatexdir/font/writettf.w
-	$(luatex_font_ctangle) writettf.w
-writetype0.c: ctangle$(EXEEXT) luatexdir/font/writetype0.w
-	$(luatex_font_ctangle) writetype0.w
-writetype2.c: ctangle$(EXEEXT) luatexdir/font/writetype2.w
-	$(luatex_font_ctangle) writetype2.w
-
-libluatex_web += luatexdir/font/dofont.w luatexdir/font/luafont.w luatexdir/font/mapfile.w
-libluatex_web += luatexdir/font/pkin.w luatexdir/font/sfnt.w 
-libluatex_web += luatexdir/font/texfont.w luatexdir/font/tfmofm.w
-libluatex_web += luatexdir/font/tounicode.w luatexdir/font/tt_glyf.w
-libluatex_web += luatexdir/font/tt_table.w luatexdir/font/vfovf.w
-libluatex_web += luatexdir/font/vfpacket.w luatexdir/font/writecff.w
-libluatex_web += luatexdir/font/writeenc.w luatexdir/font/writefont.w
-libluatex_web += luatexdir/font/writet1.w luatexdir/font/writet3.w
-libluatex_web += luatexdir/font/writettf.w luatexdir/font/writetype0.w
-libluatex_web += luatexdir/font/writetype2.w
-
-nodist_libluatex_sources += dofont.c luafont.c mapfile.c pkin.c sfnt.c 
-nodist_libluatex_sources += texfont.c tfmofm.c tounicode.c tt_glyf.c tt_table.c vfovf.c vfpacket.c
-nodist_libluatex_sources += writecff.c writeenc.c writefont.c writet1.c writet3.c writettf.c
-nodist_libluatex_sources += writetype0.c writetype2.c
+# dofont.c: ctangle$(EXEEXT) luatexdir/font/dofont.w
+# 	$(luatex_font_ctangle) dofont.w
+# luafont.c: ctangle$(EXEEXT) luatexdir/font/luafont.w
+# 	$(luatex_font_ctangle) luafont.w
+# mapfile.c: ctangle$(EXEEXT) luatexdir/font/mapfile.w
+# 	$(luatex_font_ctangle) mapfile.w
+# pkin.c: ctangle$(EXEEXT) luatexdir/font/pkin.w
+# 	$(luatex_font_ctangle) pkin.w
+# sfnt.c: ctangle$(EXEEXT) luatexdir/font/sfnt.w
+# 	$(luatex_font_ctangle) sfnt.w
+# texfont.c: ctangle$(EXEEXT) luatexdir/font/texfont.w
+# 	$(luatex_font_ctangle) texfont.w
+# tfmofm.c: ctangle$(EXEEXT) luatexdir/font/tfmofm.w
+# 	$(luatex_font_ctangle) tfmofm.w
+# tounicode.c: ctangle$(EXEEXT) luatexdir/font/tounicode.w
+# 	$(luatex_font_ctangle) tounicode.w
+# tt_glyf.c: ctangle$(EXEEXT) luatexdir/font/tt_glyf.w
+# 	$(luatex_font_ctangle) tt_glyf.w
+# tt_table.c: ctangle$(EXEEXT) luatexdir/font/tt_table.w
+# 	$(luatex_font_ctangle) tt_table.w
+# vfovf.c: ctangle$(EXEEXT) luatexdir/font/vfovf.w
+# 	$(luatex_font_ctangle) vfovf.w
+# vfpacket.c: ctangle$(EXEEXT) luatexdir/font/vfpacket.w
+# 	$(luatex_font_ctangle) vfpacket.w
+# writecff.c: ctangle$(EXEEXT) luatexdir/font/writecff.w
+# 	$(luatex_font_ctangle) writecff.w
+# writeenc.c: ctangle$(EXEEXT) luatexdir/font/writeenc.w
+# 	$(luatex_font_ctangle) writeenc.w
+# writefont.c: ctangle$(EXEEXT) luatexdir/font/writefont.w
+# 	$(luatex_font_ctangle) writefont.w
+# writet1.c: ctangle$(EXEEXT) luatexdir/font/writet1.w
+# 	$(luatex_font_ctangle) writet1.w
+# writet3.c: ctangle$(EXEEXT) luatexdir/font/writet3.w
+# 	$(luatex_font_ctangle) writet3.w
+# writettf.c: ctangle$(EXEEXT) luatexdir/font/writettf.w
+# 	$(luatex_font_ctangle) writettf.w
+# writetype0.c: ctangle$(EXEEXT) luatexdir/font/writetype0.w
+# 	$(luatex_font_ctangle) writetype0.w
+# writetype2.c: ctangle$(EXEEXT) luatexdir/font/writetype2.w
+# 	$(luatex_font_ctangle) writetype2.w
+
+# libluatex_web += luatexdir/font/dofont.w luatexdir/font/luafont.w luatexdir/font/mapfile.w
+# libluatex_web += luatexdir/font/pkin.w luatexdir/font/sfnt.w 
+# libluatex_web += luatexdir/font/texfont.w luatexdir/font/tfmofm.w
+# libluatex_web += luatexdir/font/tounicode.w luatexdir/font/tt_glyf.w
+# libluatex_web += luatexdir/font/tt_table.w luatexdir/font/vfovf.w
+# libluatex_web += luatexdir/font/vfpacket.w luatexdir/font/writecff.w
+# libluatex_web += luatexdir/font/writeenc.w luatexdir/font/writefont.w
+# libluatex_web += luatexdir/font/writet1.w luatexdir/font/writet3.w
+# libluatex_web += luatexdir/font/writettf.w luatexdir/font/writetype0.w
+# libluatex_web += luatexdir/font/writetype2.w
+
+# nodist_libluatex_sources += dofont.c luafont.c mapfile.c pkin.c sfnt.c 
+# nodist_libluatex_sources += texfont.c tfmofm.c tounicode.c tt_glyf.c tt_table.c vfovf.c vfpacket.c
+# nodist_libluatex_sources += writecff.c writeenc.c writefont.c writet1.c writet3.c writettf.c
+# nodist_libluatex_sources += writetype0.c writetype2.c
 
 dist_libluatex_sources += \
 	luatexdir/font/luatexfont.h \
@@ -170,33 +174,54 @@ dist_libluatex_sources += \
 	luatexdir/font/tt_glyf.h \
 	luatexdir/font/tt_table.h \
 	luatexdir/font/writecff.h \
-	luatexdir/font/writettf.h
+	luatexdir/font/writettf.h \
+	luatexdir/font/dofont.c \
+	luatexdir/font/luafont.c \
+	luatexdir/font/mapfile.c \
+	luatexdir/font/pkin.c \
+	luatexdir/font/sfnt.c \
+	luatexdir/font/texfont.c \
+	luatexdir/font/tfmofm.c \
+	luatexdir/font/tounicode.c \
+	luatexdir/font/tt_glyf.c \
+	luatexdir/font/tt_table.c \
+	luatexdir/font/vfovf.c \
+	luatexdir/font/vfpacket.c \
+	luatexdir/font/writecff.c \
+	luatexdir/font/writeenc.c \
+	luatexdir/font/writefont.c \
+	luatexdir/font/writet1.c \
+	luatexdir/font/writet3.c \
+	luatexdir/font/writettf.c \
+	luatexdir/font/writetype0.c \
+	luatexdir/font/writetype2.c 
+
 
 ## from luatexdir/image
 ##
 luatex_image_ctangle = $(ctangle_silent)CWEBINPUTS=$(srcdir)/luatexdir/image $(ctangle)
 
-writeimg.c: ctangle$(EXEEXT) luatexdir/image/writeimg.w
-	$(luatex_image_ctangle) writeimg.w
-writejbig2.c: ctangle$(EXEEXT) luatexdir/image/writejbig2.w
-	$(luatex_image_ctangle) writejbig2.w
-writejpg.c: ctangle$(EXEEXT) luatexdir/image/writejpg.w
-	$(luatex_image_ctangle) writejpg.w
-writejp2.c: ctangle$(EXEEXT) luatexdir/image/writejp2.w
-	$(luatex_image_ctangle) writejp2.w
-writepng.c: ctangle$(EXEEXT) luatexdir/image/writepng.w
-	$(luatex_image_ctangle) writepng.w
-pdftoepdf.cc: ctangle$(EXEEXT) luatexdir/image/pdftoepdf.w
-	$(luatex_image_ctangle) pdftoepdf.w - $@
-
-libluatex_web += luatexdir/image/writeimg.w
-libluatex_web += luatexdir/image/writejbig2.w
-libluatex_web += luatexdir/image/writejpg.w
-libluatex_web += luatexdir/image/writejp2.w
-libluatex_web += luatexdir/image/writepng.w
-libluatex_web += luatexdir/image/pdftoepdf.w
-
-nodist_libluatex_sources += writeimg.c writejbig2.c writejpg.c writejp2.c writepng.c pdftoepdf.cc
+#writeimg.c: ctangle$(EXEEXT) luatexdir/image/writeimg.w
+#	$(luatex_image_ctangle) writeimg.w
+#writejbig2.c: ctangle$(EXEEXT) luatexdir/image/writejbig2.w
+#	$(luatex_image_ctangle) writejbig2.w
+#writejpg.c: ctangle$(EXEEXT) luatexdir/image/writejpg.w
+#	$(luatex_image_ctangle) writejpg.w
+#writejp2.c: ctangle$(EXEEXT) luatexdir/image/writejp2.w
+#	$(luatex_image_ctangle) writejp2.w
+#writepng.c: ctangle$(EXEEXT) luatexdir/image/writepng.w
+#	$(luatex_image_ctangle) writepng.w
+#pdftoepdf.cc: ctangle$(EXEEXT) luatexdir/image/pdftoepdf.w
+#	$(luatex_image_ctangle) pdftoepdf.w - $@
+
+#libluatex_web += luatexdir/image/writeimg.w
+#libluatex_web += luatexdir/image/writejbig2.w
+#libluatex_web += luatexdir/image/writejpg.w
+#libluatex_web += luatexdir/image/writejp2.w
+#libluatex_web += luatexdir/image/writepng.w
+#libluatex_web += luatexdir/image/pdftoepdf.w
+
+#nodist_libluatex_sources += writeimg.c writejbig2.c writejpg.c writejp2.c writepng.c 
 
 dist_libluatex_sources += \
 	luatexdir/image/epdf.h \
@@ -206,72 +231,61 @@ dist_libluatex_sources += \
 	luatexdir/image/writejbig2.h \
 	luatexdir/image/writejpg.h \
 	luatexdir/image/writejp2.h \
-	luatexdir/image/writepng.h
+	luatexdir/image/writepng.h \
+	luatexdir/image/pdftoepdf.c \
+	luatexdir/image/writeimg.c \
+	luatexdir/image/writejbig2.c \
+	luatexdir/image/writejp2.c \
+	luatexdir/image/writejpg.c \
+	luatexdir/image/writepng.c
 
 ## from luatexdir/lang
 ##
 luatex_lang_ctangle = $(ctangle_silent)CWEBINPUTS=$(srcdir)/luatexdir/lang $(ctangle)
 
-hnjalloc.c: ctangle$(EXEEXT) luatexdir/lang/hnjalloc.w
-	$(luatex_lang_ctangle) hnjalloc.w
-hyphen.c: ctangle$(EXEEXT) luatexdir/lang/hyphen.w
-	$(luatex_lang_ctangle) hyphen.w
-texlang.c: ctangle$(EXEEXT) luatexdir/lang/texlang.w
-	$(luatex_lang_ctangle) texlang.w
-
-libluatex_web += luatexdir/lang/texlang.w luatexdir/lang/hyphen.w luatexdir/lang/hnjalloc.w
-
-nodist_libluatex_sources += texlang.c hyphen.c hnjalloc.c
-
 dist_libluatex_sources += \
 	luatexdir/lang/hnjalloc.h \
 	luatexdir/lang/hyphen.h \
-	luatexdir/lang/texlang.h
+	luatexdir/lang/texlang.h \
+	luatexdir/lang/hnjalloc.c \
+	luatexdir/lang/hyphen.c \
+	luatexdir/lang/texlang.c
 
 ## from luatexdir/lua
 ##
 luatex_lua_ctangle = $(ctangle_silent)CWEBINPUTS=$(srcdir)/luatexdir/lua $(ctangle)
 
-helpers.c: ctangle$(EXEEXT) luatexdir/lua/helpers.w
-	$(luatex_lua_ctangle) helpers.w
-luainit.c: ctangle$(EXEEXT) luatexdir/lua/luainit.w
-	$(luatex_lua_ctangle) luainit.w
+#helpers.c: ctangle$(EXEEXT) luatexdir/lua/helpers.w
+#	$(luatex_lua_ctangle) helpers.w
+#luainit.c: ctangle$(EXEEXT) luatexdir/lua/luainit.w
+#	$(luatex_lua_ctangle) luainit.w
 #luajitstuff.c: ctangle$(EXEEXT) luatexdir/lua/luajitstuff.w
 #	$(luatex_lua_ctangle) luajitstuff.w
-luanode.c: ctangle$(EXEEXT) luatexdir/lua/luanode.w
-	$(luatex_lua_ctangle) luanode.w
-luastuff.c: ctangle$(EXEEXT) luatexdir/lua/luastuff.w
-	$(luatex_lua_ctangle) luastuff.w
-luatoken.c: ctangle$(EXEEXT) luatexdir/lua/luatoken.w
-	$(luatex_lua_ctangle) luatoken.w
-mplibstuff.c: ctangle$(EXEEXT) luatexdir/lua/mplibstuff.w
-	$(luatex_lua_ctangle) mplibstuff.w
-texluac.c: ctangle$(EXEEXT) luatexdir/lua/texluac.w
-	$(luatex_lua_ctangle) texluac.w
-texluajitc.c: ctangle$(EXEEXT) luatexdir/lua/texluajitc.w
-	$(luatex_lua_ctangle) texluajitc.w
-
-libluatex_web += luatexdir/lua/helpers.w
-#libluatex_web += luatexdir/lua/luainit.w luatexdir/lua/luajitstuff.w
-libluatex_web += luatexdir/lua/luainit.w 
-libluatex_web += luatexdir/lua/luanode.w luatexdir/lua/luastuff.w luatexdir/lua/luatoken.w
-libluatex_web += luatexdir/lua/mplibstuff.w
-libluatex_web += luatexdir/lua/texluac.w luatexdir/lua/texluajitc.w
+#luanode.c: ctangle$(EXEEXT) luatexdir/lua/luanode.w
+#	$(luatex_lua_ctangle) luanode.w
+#luastuff.c: ctangle$(EXEEXT) luatexdir/lua/luastuff.w
+#	$(luatex_lua_ctangle) luastuff.w
+#luatoken.c: ctangle$(EXEEXT) luatexdir/lua/luatoken.w
+#	$(luatex_lua_ctangle) luatoken.w
+#mplibstuff.c: ctangle$(EXEEXT) luatexdir/lua/mplibstuff.w
+#	$(luatex_lua_ctangle) mplibstuff.w
+#texluac.c: ctangle$(EXEEXT) luatexdir/lua/texluac.w
+#	$(luatex_lua_ctangle) texluac.w
+#texluajitc.c: ctangle$(EXEEXT) luatexdir/lua/texluajitc.w
+#	$(luatex_lua_ctangle) texluajitc.w
 
-nodist_libluatex_sources +=  luainit.c luanode.c luatoken.c
-nodist_libluatex_sources +=  mplibstuff.c
+#libluatex_web += luatexdir/lua/luainit.w luatexdir/lua/luajitstuff.w
 
 
 dist_libluatex_sources += \
 	luatexdir/lua/lcallbacklib.c \
 	luatexdir/lua/lfontlib.c \
 	luatexdir/lua/limglib.c \
-	luatexdir/lua/lpdfscannerlib.cc \
-	luatexdir/lua/lepdflib.cc \
+	luatexdir/lua/lpdfelib.c \
+	luatexdir/lua/lpdfscannerlib.c \
 	luatexdir/lua/lkpselib.c \
 	luatexdir/lua/llanglib.c \
 	luatexdir/lua/llualib.c \
-	luatexdir/lua/llfslibext.c \
 	luatexdir/lua/lnodelib.c \
 	luatexdir/lua/liolibext.c \
 	luatexdir/lua/loslibext.c \
@@ -281,71 +295,79 @@ dist_libluatex_sources += \
 	luatexdir/lua/ltexlib.c \
 	luatexdir/lua/lnewtokenlib.c \
 	luatexdir/lua/luatex-api.h \
-	luatexdir/lua/luatex-core.c
+	luatexdir/lua/luatex-core.c \
+	luatexdir/lua/helpers.c \
+	luatexdir/lua/luainit.c \
+	luatexdir/lua/luanode.c \
+	luatexdir/lua/luastuff.c \
+	luatexdir/lua/luatoken.c \
+	luatexdir/lua/mplibstuff.c 
+
+
 
 ## from luatexdir/pdf
 ##
 luatex_pdf_ctangle = $(ctangle_silent)CWEBINPUTS=$(srcdir)/luatexdir/pdf $(ctangle)
 
-pdfpagetree.c: ctangle$(EXEEXT) luatexdir/pdf/pdfpagetree.w
-	$(luatex_pdf_ctangle) pdfpagetree.w
-pdfaction.c: ctangle$(EXEEXT) luatexdir/pdf/pdfaction.w
-	$(luatex_pdf_ctangle) pdfaction.w
-pdfannot.c: ctangle$(EXEEXT) luatexdir/pdf/pdfannot.w
-	$(luatex_pdf_ctangle) pdfannot.w
-pdfcolorstack.c: ctangle$(EXEEXT) luatexdir/pdf/pdfcolorstack.w
-	$(luatex_pdf_ctangle) pdfcolorstack.w
-pdfdest.c: ctangle$(EXEEXT) luatexdir/pdf/pdfdest.w
-	$(luatex_pdf_ctangle) pdfdest.w
-pdffont.c: ctangle$(EXEEXT) luatexdir/pdf/pdffont.w
-	$(luatex_pdf_ctangle) pdffont.w
-pdfgen.c: ctangle$(EXEEXT) luatexdir/pdf/pdfgen.w
-	$(luatex_pdf_ctangle) pdfgen.w
-pdfglyph.c: ctangle$(EXEEXT) luatexdir/pdf/pdfglyph.w
-	$(luatex_pdf_ctangle) pdfglyph.w
-pdfimage.c: ctangle$(EXEEXT) luatexdir/pdf/pdfimage.w
-	$(luatex_pdf_ctangle) pdfimage.w
-pdflink.c: ctangle$(EXEEXT) luatexdir/pdf/pdflink.w
-	$(luatex_pdf_ctangle) pdflink.w
-pdflistout.c: ctangle$(EXEEXT) luatexdir/pdf/pdflistout.w
-	$(luatex_pdf_ctangle) pdflistout.w
-pdfliteral.c: ctangle$(EXEEXT) luatexdir/pdf/pdfliteral.w
-	$(luatex_pdf_ctangle) pdfliteral.w
-pdfobj.c: ctangle$(EXEEXT) luatexdir/pdf/pdfobj.w
-	$(luatex_pdf_ctangle) pdfobj.w
-pdfoutline.c: ctangle$(EXEEXT) luatexdir/pdf/pdfoutline.w
-	$(luatex_pdf_ctangle) pdfoutline.w
-pdfpage.c: ctangle$(EXEEXT) luatexdir/pdf/pdfpage.w
-	$(luatex_pdf_ctangle) pdfpage.w
-pdfrule.c: ctangle$(EXEEXT) luatexdir/pdf/pdfrule.w
-	$(luatex_pdf_ctangle) pdfrule.w
-pdfsaverestore.c: ctangle$(EXEEXT) luatexdir/pdf/pdfsaverestore.w
-	$(luatex_pdf_ctangle) pdfsaverestore.w
-pdfsetmatrix.c: ctangle$(EXEEXT) luatexdir/pdf/pdfsetmatrix.w
-	$(luatex_pdf_ctangle) pdfsetmatrix.w
-pdfshipout.c: ctangle$(EXEEXT) luatexdir/pdf/pdfshipout.w
-	$(luatex_pdf_ctangle) pdfshipout.w
-pdftables.c: ctangle$(EXEEXT) luatexdir/pdf/pdftables.w
-	$(luatex_pdf_ctangle) pdftables.w
-pdfthread.c: ctangle$(EXEEXT) luatexdir/pdf/pdfthread.w
-	$(luatex_pdf_ctangle) pdfthread.w
-pdfxform.c: ctangle$(EXEEXT) luatexdir/pdf/pdfxform.w
-	$(luatex_pdf_ctangle) pdfxform.w
-
-libluatex_web += luatexdir/pdf/pdfpagetree.w luatexdir/pdf/pdfaction.w luatexdir/pdf/pdfannot.w
-libluatex_web += luatexdir/pdf/pdfcolorstack.w luatexdir/pdf/pdfdest.w
-libluatex_web += luatexdir/pdf/pdffont.w luatexdir/pdf/pdfgen.w luatexdir/pdf/pdfglyph.w
-libluatex_web += luatexdir/pdf/pdfimage.w luatexdir/pdf/pdflink.w luatexdir/pdf/pdflistout.w
-libluatex_web += luatexdir/pdf/pdfliteral.w luatexdir/pdf/pdfobj.w
-libluatex_web += luatexdir/pdf/pdfoutline.w luatexdir/pdf/pdfpage.w luatexdir/pdf/pdfrule.w
-libluatex_web += luatexdir/pdf/pdfsaverestore.w luatexdir/pdf/pdfsetmatrix.w
-libluatex_web += luatexdir/pdf/pdfshipout.w luatexdir/pdf/pdftables.w
-libluatex_web += luatexdir/pdf/pdfthread.w luatexdir/pdf/pdfxform.w
-
-nodist_libluatex_sources += pdfpagetree.c pdfaction.c pdfannot.c pdfcolorstack.c pdfdest.c pdffont.c
-nodist_libluatex_sources += pdfgen.c pdfglyph.c pdfimage.c pdflink.c pdflistout.c pdfliteral.c
-nodist_libluatex_sources += pdfobj.c pdfoutline.c pdfpage.c pdfrule.c pdfsaverestore.c
-nodist_libluatex_sources += pdfsetmatrix.c pdfshipout.c pdftables.c pdfthread.c pdfxform.c
+# pdfpagetree.c: ctangle$(EXEEXT) luatexdir/pdf/pdfpagetree.w
+# 	$(luatex_pdf_ctangle) pdfpagetree.w
+# pdfaction.c: ctangle$(EXEEXT) luatexdir/pdf/pdfaction.w
+# 	$(luatex_pdf_ctangle) pdfaction.w
+# pdfannot.c: ctangle$(EXEEXT) luatexdir/pdf/pdfannot.w
+# 	$(luatex_pdf_ctangle) pdfannot.w
+# pdfcolorstack.c: ctangle$(EXEEXT) luatexdir/pdf/pdfcolorstack.w
+# 	$(luatex_pdf_ctangle) pdfcolorstack.w
+# pdfdest.c: ctangle$(EXEEXT) luatexdir/pdf/pdfdest.w
+# 	$(luatex_pdf_ctangle) pdfdest.w
+# pdffont.c: ctangle$(EXEEXT) luatexdir/pdf/pdffont.w
+# 	$(luatex_pdf_ctangle) pdffont.w
+# pdfgen.c: ctangle$(EXEEXT) luatexdir/pdf/pdfgen.w
+# 	$(luatex_pdf_ctangle) pdfgen.w
+# pdfglyph.c: ctangle$(EXEEXT) luatexdir/pdf/pdfglyph.w
+# 	$(luatex_pdf_ctangle) pdfglyph.w
+# pdfimage.c: ctangle$(EXEEXT) luatexdir/pdf/pdfimage.w
+# 	$(luatex_pdf_ctangle) pdfimage.w
+# pdflink.c: ctangle$(EXEEXT) luatexdir/pdf/pdflink.w
+# 	$(luatex_pdf_ctangle) pdflink.w
+# pdflistout.c: ctangle$(EXEEXT) luatexdir/pdf/pdflistout.w
+# 	$(luatex_pdf_ctangle) pdflistout.w
+# pdfliteral.c: ctangle$(EXEEXT) luatexdir/pdf/pdfliteral.w
+# 	$(luatex_pdf_ctangle) pdfliteral.w
+# pdfobj.c: ctangle$(EXEEXT) luatexdir/pdf/pdfobj.w
+# 	$(luatex_pdf_ctangle) pdfobj.w
+# pdfoutline.c: ctangle$(EXEEXT) luatexdir/pdf/pdfoutline.w
+# 	$(luatex_pdf_ctangle) pdfoutline.w
+# pdfpage.c: ctangle$(EXEEXT) luatexdir/pdf/pdfpage.w
+# 	$(luatex_pdf_ctangle) pdfpage.w
+# pdfrule.c: ctangle$(EXEEXT) luatexdir/pdf/pdfrule.w
+# 	$(luatex_pdf_ctangle) pdfrule.w
+# pdfsaverestore.c: ctangle$(EXEEXT) luatexdir/pdf/pdfsaverestore.w
+# 	$(luatex_pdf_ctangle) pdfsaverestore.w
+# pdfsetmatrix.c: ctangle$(EXEEXT) luatexdir/pdf/pdfsetmatrix.w
+# 	$(luatex_pdf_ctangle) pdfsetmatrix.w
+# pdfshipout.c: ctangle$(EXEEXT) luatexdir/pdf/pdfshipout.w
+# 	$(luatex_pdf_ctangle) pdfshipout.w
+# pdftables.c: ctangle$(EXEEXT) luatexdir/pdf/pdftables.w
+# 	$(luatex_pdf_ctangle) pdftables.w
+# pdfthread.c: ctangle$(EXEEXT) luatexdir/pdf/pdfthread.w
+# 	$(luatex_pdf_ctangle) pdfthread.w
+# pdfxform.c: ctangle$(EXEEXT) luatexdir/pdf/pdfxform.w
+# 	$(luatex_pdf_ctangle) pdfxform.w
+
+#libluatex_web += luatexdir/pdf/pdfpagetree.w luatexdir/pdf/pdfaction.w luatexdir/pdf/pdfannot.w
+#libluatex_web += luatexdir/pdf/pdfcolorstack.w luatexdir/pdf/pdfdest.w
+#libluatex_web += luatexdir/pdf/pdffont.w luatexdir/pdf/pdfgen.w luatexdir/pdf/pdfglyph.w
+#libluatex_web += luatexdir/pdf/pdfimage.w luatexdir/pdf/pdflink.w luatexdir/pdf/pdflistout.w
+#libluatex_web += luatexdir/pdf/pdfliteral.w luatexdir/pdf/pdfobj.w
+#libluatex_web += luatexdir/pdf/pdfoutline.w luatexdir/pdf/pdfpage.w luatexdir/pdf/pdfrule.w
+#libluatex_web += luatexdir/pdf/pdfsaverestore.w luatexdir/pdf/pdfsetmatrix.w
+#libluatex_web += luatexdir/pdf/pdfshipout.w luatexdir/pdf/pdftables.w
+#libluatex_web += luatexdir/pdf/pdfthread.w luatexdir/pdf/pdfxform.w
+
+#nodist_libluatex_sources += pdfpagetree.c pdfaction.c pdfannot.c pdfcolorstack.c pdfdest.c pdffont.c
+#nodist_libluatex_sources += pdfgen.c pdfglyph.c pdfimage.c pdflink.c pdflistout.c pdfliteral.c
+#nodist_libluatex_sources += pdfobj.c pdfoutline.c pdfpage.c pdfrule.c pdfsaverestore.c
+#nodist_libluatex_sources += pdfsetmatrix.c pdfshipout.c pdftables.c pdfthread.c pdfxform.c
 
 dist_libluatex_sources += \
 	luatexdir/pdf/pdfpagetree.h \
@@ -370,7 +392,29 @@ dist_libluatex_sources += \
 	luatexdir/pdf/pdftables.h \
 	luatexdir/pdf/pdfthread.h \
 	luatexdir/pdf/pdftypes.h \
-	luatexdir/pdf/pdfxform.h
+	luatexdir/pdf/pdfxform.h \
+	luatexdir/pdf/pdfaction.c \
+	luatexdir/pdf/pdfannot.c \
+	luatexdir/pdf/pdfcolorstack.c \
+	luatexdir/pdf/pdfdest.c \
+	luatexdir/pdf/pdffont.c \
+	luatexdir/pdf/pdfgen.c \
+	luatexdir/pdf/pdfglyph.c \
+	luatexdir/pdf/pdfimage.c \
+	luatexdir/pdf/pdflink.c \
+	luatexdir/pdf/pdflistout.c \
+	luatexdir/pdf/pdfliteral.c \
+	luatexdir/pdf/pdfobj.c \
+	luatexdir/pdf/pdfoutline.c \
+	luatexdir/pdf/pdfpage.c \
+	luatexdir/pdf/pdfpagetree.c \
+	luatexdir/pdf/pdfrule.c \
+	luatexdir/pdf/pdfsaverestore.c \
+	luatexdir/pdf/pdfsetmatrix.c \
+	luatexdir/pdf/pdfshipout.c \
+	luatexdir/pdf/pdftables.c \
+	luatexdir/pdf/pdfthread.c \
+	luatexdir/pdf/pdfxform.c 
 
 ################################################################################
 ################################################################################
@@ -415,93 +459,79 @@ dist_libluatex_sources += \
 ##
 luatex_tex_ctangle = $(ctangle_silent)CWEBINPUTS=$(srcdir)/luatexdir/tex $(ctangle)
 
-align.c: ctangle$(EXEEXT) luatexdir/tex/align.w
-	$(luatex_tex_ctangle) align.w
-arithmetic.c: ctangle$(EXEEXT) luatexdir/tex/arithmetic.w
-	$(luatex_tex_ctangle) arithmetic.w
-buildpage.c: ctangle$(EXEEXT) luatexdir/tex/buildpage.w
-	$(luatex_tex_ctangle) buildpage.w
-commands.c: ctangle$(EXEEXT) luatexdir/tex/commands.w
-	$(luatex_tex_ctangle) commands.w
-conditional.c: ctangle$(EXEEXT) luatexdir/tex/conditional.w
-	$(luatex_tex_ctangle) conditional.w
-directions.c: ctangle$(EXEEXT) luatexdir/tex/directions.w
-	$(luatex_tex_ctangle) directions.w
-dumpdata.c: ctangle$(EXEEXT) luatexdir/tex/dumpdata.w
-	$(luatex_tex_ctangle) dumpdata.w
-equivalents.c: ctangle$(EXEEXT) luatexdir/tex/equivalents.w
-	$(luatex_tex_ctangle) equivalents.w
-errors.c: ctangle$(EXEEXT) luatexdir/tex/errors.w
-	$(luatex_tex_ctangle) errors.w
-expand.c: ctangle$(EXEEXT) luatexdir/tex/expand.w
-	$(luatex_tex_ctangle) expand.w
-extensions.c: ctangle$(EXEEXT) luatexdir/tex/extensions.w
-	$(luatex_tex_ctangle) extensions.w
-filename.c: ctangle$(EXEEXT) luatexdir/tex/filename.w
-	$(luatex_tex_ctangle) filename.w
-inputstack.c: ctangle$(EXEEXT) luatexdir/tex/inputstack.w
-	$(luatex_tex_ctangle) inputstack.w
-linebreak.c: ctangle$(EXEEXT) luatexdir/tex/linebreak.w
-	$(luatex_tex_ctangle) linebreak.w
-mainbody.c: ctangle$(EXEEXT) luatexdir/tex/mainbody.w
-	$(luatex_tex_ctangle) mainbody.w
-maincontrol.c: ctangle$(EXEEXT) luatexdir/tex/maincontrol.w
-	$(luatex_tex_ctangle) maincontrol.w
-mathcodes.c: ctangle$(EXEEXT) luatexdir/tex/mathcodes.w
-	$(luatex_tex_ctangle) mathcodes.w
-memoryword.c: ctangle$(EXEEXT) luatexdir/tex/memoryword.w
-	$(luatex_tex_ctangle) memoryword.w
-mlist.c: ctangle$(EXEEXT) luatexdir/tex/mlist.w
-	$(luatex_tex_ctangle) mlist.w
-nesting.c: ctangle$(EXEEXT) luatexdir/tex/nesting.w
-	$(luatex_tex_ctangle) nesting.w
-packaging.c: ctangle$(EXEEXT) luatexdir/tex/packaging.w
-	$(luatex_tex_ctangle) packaging.w
-postlinebreak.c: ctangle$(EXEEXT) luatexdir/tex/postlinebreak.w
-	$(luatex_tex_ctangle) postlinebreak.w
-primitive.c: ctangle$(EXEEXT) luatexdir/tex/primitive.w
-	$(luatex_tex_ctangle) primitive.w
-printing.c: ctangle$(EXEEXT) luatexdir/tex/printing.w
-	$(luatex_tex_ctangle) printing.w
-scanning.c: ctangle$(EXEEXT) luatexdir/tex/scanning.w
-	$(luatex_tex_ctangle) scanning.w
-stringpool.c: ctangle$(EXEEXT) luatexdir/tex/stringpool.w
-	$(luatex_tex_ctangle) stringpool.w
-texdeffont.c: ctangle$(EXEEXT) luatexdir/tex/texdeffont.w
-	$(luatex_tex_ctangle) texdeffont.w
-texfileio.c: ctangle$(EXEEXT) luatexdir/tex/texfileio.w
-	$(luatex_tex_ctangle) texfileio.w
-texmath.c: ctangle$(EXEEXT) luatexdir/tex/texmath.w
-	$(luatex_tex_ctangle) texmath.w
-texnodes.c: ctangle$(EXEEXT) luatexdir/tex/texnodes.w
-	$(luatex_tex_ctangle) texnodes.w
-textcodes.c: ctangle$(EXEEXT) luatexdir/tex/textcodes.w
-	$(luatex_tex_ctangle) textcodes.w
-textoken.c: ctangle$(EXEEXT) luatexdir/tex/textoken.w
-	$(luatex_tex_ctangle) textoken.w
-
-libluatex_web += luatexdir/tex/align.w luatexdir/tex/arithmetic.w luatexdir/tex/buildpage.w
-libluatex_web += luatexdir/tex/commands.w luatexdir/tex/conditional.w luatexdir/tex/directions.w
-libluatex_web += luatexdir/tex/dumpdata.w luatexdir/tex/equivalents.w luatexdir/tex/errors.w
-libluatex_web += luatexdir/tex/expand.w luatexdir/tex/extensions.w luatexdir/tex/filename.w
-libluatex_web += luatexdir/tex/inputstack.w luatexdir/tex/linebreak.w luatexdir/tex/mainbody.w
-libluatex_web += luatexdir/tex/maincontrol.w luatexdir/tex/mathcodes.w luatexdir/tex/memoryword.w
-libluatex_web += luatexdir/tex/mlist.w luatexdir/tex/nesting.w luatexdir/tex/packaging.w
-libluatex_web += luatexdir/tex/postlinebreak.w luatexdir/tex/primitive.w luatexdir/tex/printing.w
-libluatex_web += luatexdir/tex/scanning.w luatexdir/tex/stringpool.w luatexdir/tex/texdeffont.w
-libluatex_web += luatexdir/tex/texfileio.w luatexdir/tex/texmath.w luatexdir/tex/texnodes.w
-libluatex_web += luatexdir/tex/textcodes.w luatexdir/tex/textoken.w
-
-nodist_libluatex_sources += align.c arithmetic.c buildpage.c commands.c conditional.c directions.c
-nodist_libluatex_sources += dumpdata.c equivalents.c errors.c expand.c extensions.c filename.c
-nodist_libluatex_sources += inputstack.c linebreak.c mainbody.c maincontrol.c mathcodes.c
-nodist_libluatex_sources += memoryword.c mlist.c nesting.c packaging.c postlinebreak.c
-nodist_libluatex_sources += primitive.c printing.c scanning.c stringpool.c texdeffont.c
-nodist_libluatex_sources += texfileio.c texmath.c texnodes.c textcodes.c textoken.c
+# align.c: ctangle$(EXEEXT) luatexdir/tex/align.w
+# 	$(luatex_tex_ctangle) align.w
+#arithmetic.c: ctangle$(EXEEXT) luatexdir/tex/arithmetic.w
+#	$(luatex_tex_ctangle) arithmetic.w
+# buildpage.c: ctangle$(EXEEXT) luatexdir/tex/buildpage.w
+# 	$(luatex_tex_ctangle) buildpage.w
+#commands.c: ctangle$(EXEEXT) luatexdir/tex/commands.w
+#	$(luatex_tex_ctangle) commands.w
+#conditional.c: ctangle$(EXEEXT) luatexdir/tex/conditional.w
+#	$(luatex_tex_ctangle) conditional.w
+#directions.c: ctangle$(EXEEXT) luatexdir/tex/directions.w
+#	$(luatex_tex_ctangle) directions.w
+#dumpdata.c: ctangle$(EXEEXT) luatexdir/tex/dumpdata.w
+#	$(luatex_tex_ctangle) dumpdata.w
+#equivalents.c: ctangle$(EXEEXT) luatexdir/tex/equivalents.w
+#	$(luatex_tex_ctangle) equivalents.w
+#errors.c: ctangle$(EXEEXT) luatexdir/tex/errors.w
+#	$(luatex_tex_ctangle) errors.w
+# expand.c: ctangle$(EXEEXT) luatexdir/tex/expand.w
+# 	$(luatex_tex_ctangle) expand.w
+# extensions.c: ctangle$(EXEEXT) luatexdir/tex/extensions.w
+# 	$(luatex_tex_ctangle) extensions.w
+#filename.c: ctangle$(EXEEXT) luatexdir/tex/filename.w
+#	$(luatex_tex_ctangle) filename.w
+#inputstack.c: ctangle$(EXEEXT) luatexdir/tex/inputstack.w
+#	$(luatex_tex_ctangle) inputstack.w
+# linebreak.c: ctangle$(EXEEXT) luatexdir/tex/linebreak.w
+# 	$(luatex_tex_ctangle) linebreak.w
+#mainbody.c: ctangle$(EXEEXT) luatexdir/tex/mainbody.w
+#	$(luatex_tex_ctangle) mainbody.w
+#maincontrol.c: ctangle$(EXEEXT) luatexdir/tex/maincontrol.w
+#	$(luatex_tex_ctangle) maincontrol.w
+#mathcodes.c: ctangle$(EXEEXT) luatexdir/tex/mathcodes.w
+#	$(luatex_tex_ctangle) mathcodes.w
+#memoryword.c: ctangle$(EXEEXT) luatexdir/tex/memoryword.w
+#	$(luatex_tex_ctangle) memoryword.w
+# mlist.c: ctangle$(EXEEXT) luatexdir/tex/mlist.w
+# 	$(luatex_tex_ctangle) mlist.w
+#nesting.c: ctangle$(EXEEXT) luatexdir/tex/nesting.w
+#	$(luatex_tex_ctangle) nesting.w
+# packaging.c: ctangle$(EXEEXT) luatexdir/tex/packaging.w
+# 	$(luatex_tex_ctangle) packaging.w
+#postlinebreak.c: ctangle$(EXEEXT) luatexdir/tex/postlinebreak.w
+#	$(luatex_tex_ctangle) postlinebreak.w
+#primitive.c: ctangle$(EXEEXT) luatexdir/tex/primitive.w
+#	$(luatex_tex_ctangle) primitive.w
+#printing.c: ctangle$(EXEEXT) luatexdir/tex/printing.w
+#	$(luatex_tex_ctangle) printing.w
+# scanning.c: ctangle$(EXEEXT) luatexdir/tex/scanning.w
+# 	$(luatex_tex_ctangle) scanning.w
+#stringpool.c: ctangle$(EXEEXT) luatexdir/tex/stringpool.w
+#	$(luatex_tex_ctangle) stringpool.w
+#texdeffont.c: ctangle$(EXEEXT) luatexdir/tex/texdeffont.w
+#	$(luatex_tex_ctangle) texdeffont.w
+# texfileio.c: ctangle$(EXEEXT) luatexdir/tex/texfileio.w
+# 	$(luatex_tex_ctangle) texfileio.w
+# texmath.c: ctangle$(EXEEXT) luatexdir/tex/texmath.w
+# 	$(luatex_tex_ctangle) texmath.w
+# texnodes.c: ctangle$(EXEEXT) luatexdir/tex/texnodes.w
+# 	$(luatex_tex_ctangle) texnodes.w
+#textcodes.c: ctangle$(EXEEXT) luatexdir/tex/textcodes.w
+#	$(luatex_tex_ctangle) textcodes.w
+# textoken.c: ctangle$(EXEEXT) luatexdir/tex/textoken.w
+# 	$(luatex_tex_ctangle) textoken.w
+
+
+
 
 dist_libluatex_sources += \
 	luatexdir/tex/align.h \
 	luatexdir/tex/arithmetic.h \
+	luatexdir/tex/backend.h \
+	luatexdir/tex/backend.c \
 	luatexdir/tex/buildpage.h \
 	luatexdir/tex/commands.h \
 	luatexdir/tex/conditional.h \
@@ -530,25 +560,58 @@ dist_libluatex_sources += \
 	luatexdir/tex/texfileio.h \
 	luatexdir/tex/texmath.h \
 	luatexdir/tex/texnodes.h \
+	luatexdir/tex/textcodes.h \
 	luatexdir/tex/textoken.h \
-	luatexdir/tex/textcodes.h 
+	luatexdir/tex/align.c \
+	luatexdir/tex/arithmetic.c \
+	luatexdir/tex/buildpage.c \
+	luatexdir/tex/commands.c \
+	luatexdir/tex/conditional.c \
+	luatexdir/tex/directions.c \
+	luatexdir/tex/dumpdata.c \
+	luatexdir/tex/equivalents.c \
+	luatexdir/tex/errors.c \
+	luatexdir/tex/expand.c \
+	luatexdir/tex/extensions.c \
+	luatexdir/tex/filename.c \
+	luatexdir/tex/inputstack.c \
+	luatexdir/tex/linebreak.c \
+	luatexdir/tex/mainbody.c \
+	luatexdir/tex/maincontrol.c \
+	luatexdir/tex/mathcodes.c \
+	luatexdir/tex/memoryword.c \
+	luatexdir/tex/mlist.c \
+	luatexdir/tex/nesting.c \
+	luatexdir/tex/packaging.c \
+	luatexdir/tex/postlinebreak.c \
+	luatexdir/tex/primitive.c \
+	luatexdir/tex/printing.c \
+	luatexdir/tex/scanning.c \
+	luatexdir/tex/stringpool.c \
+	luatexdir/tex/texdeffont.c \
+	luatexdir/tex/texfileio.c \
+	luatexdir/tex/texmath.c \
+	luatexdir/tex/texnodes.c \
+	luatexdir/tex/textcodes.c \
+	luatexdir/tex/textoken.c 
+
 
 ## from luatexdir/utils
 ##
 luatex_utils_ctangle = $(ctangle_silent)CWEBINPUTS=$(srcdir)/luatexdir/utils $(ctangle)
 
-avlstuff.c: ctangle$(EXEEXT) luatexdir/utils/avlstuff.w
-	$(luatex_utils_ctangle) avlstuff.w
-managed-sa.c: ctangle$(EXEEXT) luatexdir/utils/managed-sa.w
-	$(luatex_utils_ctangle) managed-sa.w
-utils.c: ctangle$(EXEEXT) luatexdir/utils/utils.w
-	$(luatex_utils_ctangle) utils.w
-unistring.c: ctangle$(EXEEXT) luatexdir/utils/unistring.w
-	$(luatex_utils_ctangle) unistring.w
+#avlstuff.c: ctangle$(EXEEXT) luatexdir/utils/avlstuff.w
+#	$(luatex_utils_ctangle) avlstuff.w
+#managed-sa.c: ctangle$(EXEEXT) luatexdir/utils/managed-sa.w
+#	$(luatex_utils_ctangle) managed-sa.w
+#utils.c: ctangle$(EXEEXT) luatexdir/utils/utils.w
+#	$(luatex_utils_ctangle) utils.w
+#unistring.c: ctangle$(EXEEXT) luatexdir/utils/unistring.w
+#	$(luatex_utils_ctangle) unistring.w
 
-libluatex_web += luatexdir/utils/avlstuff.w luatexdir/utils/managed-sa.w luatexdir/utils/utils.w luatexdir/utils/unistring.w
+#libluatex_web += luatexdir/utils/avlstuff.w luatexdir/utils/managed-sa.w luatexdir/utils/utils.w luatexdir/utils/unistring.w
 
-nodist_libluatex_sources += avlstuff.c managed-sa.c utils.c unistring.c
+#nodist_libluatex_sources += avlstuff.c managed-sa.c utils.c unistring.c
 
 dist_libluatex_sources += \
 	luatexdir/utils/avl.c \
@@ -556,7 +619,11 @@ dist_libluatex_sources += \
 	luatexdir/utils/avlstuff.h \
 	luatexdir/utils/managed-sa.h \
 	luatexdir/utils/utils.h \
-	luatexdir/utils/unistring.h
+	luatexdir/utils/unistring.h \
+	luatexdir/utils/avlstuff.c \
+	luatexdir/utils/managed-sa.c \
+	luatexdir/utils/unistring.c \
+	luatexdir/utils/utils.c
 
 ## from ../synctexdir
 ##
diff --git a/texk/web2c/luatexdir/am/luamisc.am b/texk/web2c/luatexdir/am/luamisc.am
index 7e874ae09..014b6eb3f 100644
--- a/texk/web2c/luatexdir/am/luamisc.am
+++ b/texk/web2c/luatexdir/am/luamisc.am
@@ -8,9 +8,9 @@
 ## and slnunicode)
 EXTRA_LIBRARIES += libluamisc.a liblua53misc.a  libluajitmisc.a
 
-libluamisc_a_DEPENDENCIES = $(ZZIPLIB_DEPEND) libluasocket.a libluaffi.a
-liblua53misc_a_DEPENDENCIES = $(ZZIPLIB_DEPEND) liblua53socket.a liblua53ffi.a
-libluajitmisc_a_DEPENDENCIES = $(ZZIPLIB_DEPEND) libluajitsocket.a
+libluamisc_a_DEPENDENCIES = $(ZZIPLIB_DEPEND) libluasocket.a libluaffi.a libluapplib.a
+liblua53misc_a_DEPENDENCIES = $(ZZIPLIB_DEPEND) liblua53socket.a liblua53ffi.a liblua53pplib.a
+libluajitmisc_a_DEPENDENCIES = $(ZZIPLIB_DEPEND) libluajitsocket.a libluajitpplib.a
 
 $(libluamisc_a_OBJECTS): $(libluamisc_a_DEPENDENCIES)
 $(liblua53misc_a_OBJECTS): $(liblua53misc_a_DEPENDENCIES)
diff --git a/texk/web2c/luatexdir/am/luatex.am b/texk/web2c/luatexdir/am/luatex.am
index 4482ffe60..2fb4d64f6 100644
--- a/texk/web2c/luatexdir/am/luatex.am
+++ b/texk/web2c/luatexdir/am/luatex.am
@@ -42,11 +42,11 @@ endif LUAJITTEX
 EXTRA_PROGRAMS += luatex luatex53 luajittex
 
 # Force Automake to use CXXLD for linking
-nodist_EXTRA_luatex_SOURCES = dummy.cxx
-nodist_EXTRA_luatex53_SOURCES = dummy.cxx
-nodist_EXTRA_luajittex_SOURCES = dummy.cxx
+#nodist_EXTRA_luatex_SOURCES = dummy.cxx
+#nodist_EXTRA_luatex53_SOURCES = dummy.cxx
+#nodist_EXTRA_luajittex_SOURCES = dummy.cxx
 
-luatex_preflags = $(AM_CPPFLAGS) $(ZLIB_INCLUDES) $(LIBPNG_INCLUDES) $(POPPLER_INCLUDES) 
+luatex_preflags = $(AM_CPPFLAGS) $(ZLIB_INCLUDES) $(LIBPNG_INCLUDES) 
 luatex_postflags = -I$(srcdir)/libmd5 -DpdfTeX -I$(srcdir)/luatexdir -I$(srcdir)/mplibdir
 luatex_postflags += -Dextra_version_info=`date +-%Y%m%d%H`
 luatex_postflags += -I$(srcdir)/synctexdir -DSYNCTEX_ENGINE_H='<synctex-luatex.h>'
@@ -64,14 +64,15 @@ luatex_LDFLAGS = -export-dynamic
 luatex53_LDFLAGS = -export-dynamic
 luajittex_LDFLAGS = -export-dynamic $(LUAJIT_LDEXTRA)
 
-luatex_postldadd = libmplibcore.a $(MPFR_LIBS) $(GMP_LIBS) 
-luatex_postldadd += $(ZZIPLIB_LIBS) $(LIBPNG_LIBS) $(ZLIB_LIBS) $(POPPLER_LIBS)
+#luatex_postldadd = libmplibcore.a $(MPFR_LIBS) $(GMP_LIBS) 
+luatex_postldadd = libmplibcore.a 
+luatex_postldadd += $(ZZIPLIB_LIBS) $(LIBPNG_LIBS) $(ZLIB_LIBS) 
 luatex_postldadd += $(LDADD) libmputil.a libunilib.a libmd5.a $(lua_socketlibs)
 
 
-luatex_LDADD = libluatex.a libff.a libluamisc.a libluasocket.a libluaffi.a $(LUA_LIBS) $(luatex_postldadd)
-luatex53_LDADD = liblua53tex.a libff.a liblua53misc.a liblua53socket.a liblua53ffi.a $(LUA_LUA53_LIBS) $(luatex_postldadd)
-luajittex_LDADD = libluajittex.a libff.a libluajitmisc.a libluajitsocket.a $(LUAJIT_LIBS) $(luatex_postldadd)
+luatex_LDADD = libluatex.a libff.a libluamisc.a libluasocket.a libluaffi.a libluapplib.a $(LUA_LIBS) $(luatex_postldadd)
+luatex53_LDADD = liblua53tex.a libff.a liblua53misc.a liblua53socket.a liblua53ffi.a liblua53pplib.a $(LUA_LUA53_LIBS) $(luatex_postldadd)
+luajittex_LDADD = libluajittex.a libff.a libluajitmisc.a libluajitsocket.a libluajitpplib.a $(LUAJIT_LIBS) $(luatex_postldadd)
 
 luatex_depend = $(proglib) $(KPATHSEA_DEPEND) $(LIBPNG_DEPEND) libmputil.a libmd5.a
 luatex_DEPENDENCIES = $(luatex_depend) libluatex.a
diff --git a/texk/web2c/luatexdir/dvi/dvigen.h b/texk/web2c/luatexdir/dvi/dvigen.h
index 49552f1d9..cfbbc6245 100644
--- a/texk/web2c/luatexdir/dvi/dvigen.h
+++ b/texk/web2c/luatexdir/dvi/dvigen.h
@@ -21,166 +21,34 @@
 #ifndef DVIGEN_H
 #  define DVIGEN_H
 
-extern int total_pages;
-extern scaled max_v;
-extern scaled max_h;
-extern int max_push;
-extern int last_bop;
-extern int dead_cycles;
-extern boolean doing_leaders;
-extern int oval, ocmd;
-extern int lq, lr;
-extern int cur_s;
-
-typedef int dvi_index;          /* an index into the output buffer */
+/* todo: move initialization from mainbody to ensure_open */
 
 extern int dvi_buf_size;
 extern eight_bits *dvi_buf;     /* 0 is unused */
-extern dvi_index half_buf;
-extern dvi_index dvi_limit;
-extern dvi_index dvi_ptr;
-extern int dvi_offset;
-extern int dvi_gone;
-
-/*
-To put a byte in the buffer without paying the cost of invoking a procedure
-each time, we use the macro |dvi_out|.
-*/
-
-#  define dvi_out(A) do {                       \
-	dvi_buf[dvi_ptr++]=(eight_bits)(A);	\
-    if (dvi_ptr==dvi_limit) dvi_swap();         \
-  } while (0)
-
-extern void dvi_swap(void);
-extern void dvi_four(int x);
-extern void dvi_push(void);
-extern void dvi_pop(int l);
-extern void out_cmd(void);
-extern void dvi_font_def(internal_font_number f);
-
-#  define dvi_set(A,B)  do {                    \
-    oval=A; ocmd=set1; out_cmd(); dvi.h += (B); \
-  } while (0)
-
-#  define dvi_put(A)  do {                      \
-    oval=A; ocmd=put1; out_cmd();               \
-  } while (0)
-
-#  define location(A) varmem[(A)+1].cint
-
-extern halfword down_ptr, right_ptr;    /* heads of the down and right stacks */
-
-/*
-The |vinfo| fields in the entries of the down stack or the right stack
-have six possible settings: |y_here| or |z_here| mean that the \.{DVI}
-command refers to |y| or |z|, respectively (or to |w| or |x|, in the
-case of horizontal motion); |yz_OK| means that the \.{DVI} command is
-\\{down} (or \\{right}) but can be changed to either |y| or |z| (or
-to either |w| or |x|); |y_OK| means that it is \\{down} and can be changed
-to |y| but not |z|; |z_OK| is similar; and |d_fixed| means it must stay
-\\{down}.
-
-The four settings |yz_OK|, |y_OK|, |z_OK|, |d_fixed| would not need to
-be distinguished from each other if we were simply solving the
-digit-subscripting problem mentioned above. But in \TeX's case there is
-a complication because of the nested structure of |push| and |pop|
-commands. Suppose we add parentheses to the digit-subscripting problem,
-redefining hits so that $\delta_y\ldots \delta_y$ is a hit if all $y$'s between
-the $\delta$'s are enclosed in properly nested parentheses, and if the
-parenthesis level of the right-hand $\delta_y$ is deeper than or equal to
-that of the left-hand one. Thus, `(' and `)' correspond to `|push|'
-and `|pop|'. Now if we want to assign a subscript to the final 1 in the
-sequence
-$$2_y\,7_d\,1_d\,(\,8_z\,2_y\,8_z\,)\,1$$
-we cannot change the previous $1_d$ to $1_y$, since that would invalidate
-the $2_y\ldots2_y$ hit. But we can change it to $1_z$, scoring a hit
-since the intervening $8_z$'s are enclosed in parentheses.
-*/
-
-typedef enum {
-    y_here = 1,                 /* |vinfo| when the movement entry points to a |y| command */
-    z_here = 2,                 /* |vinfo| when the movement entry points to a |z| command */
-    yz_OK = 3,                  /* |vinfo| corresponding to an unconstrained \\{down} command */
-    y_OK = 4,                   /* |vinfo| corresponding to a \\{down} that can't become a |z| */
-    z_OK = 5,                   /* |vinfo| corresponding to a \\{down} that can't become a |y| */
-    d_fixed = 6,                /* |vinfo| corresponding to a \\{down} that can't change */
-} movement_codes;
-
-/* As we search through the stack, we are in one of three states,
-   |y_seen|, |z_seen|, or |none_seen|, depending on whether we have
-   encountered |y_here| or |z_here| nodes. These states are encoded as
-   multiples of 6, so that they can be added to the |info| fields for quick
-   decision-making. */
-
-#  define none_seen 0           /* no |y_here| or |z_here| nodes have been encountered yet */
-#  define y_seen 6              /* we have seen |y_here| but not |z_here| */
-#  define z_seen 12             /* we have seen |z_here| but not |y_here| */
-
-extern void movement(scaled w, eight_bits o);
-extern void prune_movements(int l);
-
-/*
-The actual distances by which we want to move might be computed as the
-sum of several separate movements. For example, there might be several
-glue nodes in succession, or we might want to move right by the width of
-some box plus some amount of glue. More importantly, the baselineskip
-distances are computed in terms of glue together with the depth and
-height of adjacent boxes, and we want the \.{DVI} file to lump these
-three quantities together into a single motion.
-
-Therefore, \TeX\ maintains two pairs of global variables: |dvi.h| and |dvi.v|
-are the |h| and |v| coordinates corresponding to the commands actually
-output to the \.{DVI} file, while |cur.h| and |cur.v| are the coordinates
-corresponding to the current state of the output routines. Coordinate
-changes will accumulate in |cur.h| and |cur.v| without being reflected
-in the output, until such a change becomes necessary or desirable; we
-can call the |movement| procedure whenever we want to make |dvi.h=pos.h|
-or |dvi.v=pos.v|.
-
-The current font reflected in the \.{DVI} output is called |dvi_f|;
-there is no need for a `\\{cur\_f}' variable.
-
-The depth of nesting of |hlist_out| and |vlist_out| is called |cur_s|;
-this is essentially the depth of |push| commands in the \.{DVI} output.
-*/
-
-#  define synch_h(p) do {                       \
-    if (p.h != dvi.h) {                         \
-      movement(p.h - dvi.h, right1);            \
-      dvi.h = p.h;                              \
-    }                                           \
-  } while (0)
-
-#  define synch_v(p) do {                       \
-    if (p.v != dvi.v) {                         \
-      movement(dvi.v - p.v, down1);             \
-      dvi.v = p.v;                              \
-    }                                           \
-  } while (0)
-
-#  define synch_dvi_with_pos(p) do {synch_h(p); synch_v(p); } while (0)
-
-#  define billion 1000000000.0
-
-#  define vet_glue(A) do { glue_temp=A;         \
-    if (glue_temp>billion)                      \
-      glue_temp=billion;                        \
-    else if (glue_temp<-billion)                \
-      glue_temp=-billion;                       \
-  } while (0)
-
-extern scaledpos dvi;
 
-extern void dvi_special(PDF pdf, halfword p);
+/*tex Housekeeping.  */
 
-extern void ensure_dvi_header_written(PDF pdf);
-extern void finish_dvi_file(PDF pdf, int version, int revision);
+extern void dvi_open_file(PDF pdf);
+extern void dvi_write_header(PDF pdf);
+extern void dvi_finish_file(PDF pdf, int fatal_error);
+extern void dvi_begin_page(PDF pdf);
+extern void dvi_end_page(PDF pdf);
+
+/*tex Specific injections. */
 
 extern void dvi_place_glyph(PDF pdf, internal_font_number f, int c, int ex);
 extern void dvi_place_rule(PDF pdf, halfword q, scaledpos size);
+extern void dvi_special(PDF pdf, halfword p);
 
-extern void dvi_begin_page(PDF pdf);
-extern void dvi_end_page(PDF pdf);
+/*tex List handling (and nesting). */
+
+extern void dvi_push_list(PDF pdf, scaledpos *saved_pos, int *saved_loc);
+extern void dvi_pop_list(PDF pdf, scaledpos *saved_pos, int *saved_loc);
+extern void dvi_set_reference_point(PDF pdf, posstructure *refpoint);
+
+/*tex Status information used in |lstatslib|. Not that useful. */
+
+extern int dvi_get_status_ptr(PDF pdf);
+extern int dvi_get_status_gone(PDF pdf);
 
 #endif
diff --git a/texk/web2c/luatexdir/font/luatexfont.h b/texk/web2c/luatexdir/font/luatexfont.h
index 459d2092b..7016b8872 100644
--- a/texk/web2c/luatexdir/font/luatexfont.h
+++ b/texk/web2c/luatexdir/font/luatexfont.h
@@ -1,4 +1,4 @@
-/* luatexfont.h --- General font definitions
+/*
 
    Copyright 2008-2013 Taco Hoekwater <taco@luatex.org>
 
@@ -15,45 +15,36 @@
    License for more details.
 
    You should have received a copy of the GNU General Public License along
-   with LuaTeX; if not, see <http://www.gnu.org/licenses/>. */
+   with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
 
+*/
 
 #ifndef LUATEXFONT_H
-#  define LUATEXFONT_H
-
-#  include "ptexlib.h"
-#  ifndef pdfTeX
-#    define pdfTeX
-#    include "sfnt.h"           /* which wants that pdfTeX is defined */
-#    undef pdfTeX
-#  else
-#    include "sfnt.h"
-#  endif
-
-/**********************************************************************/
-
-#  define ASCENT_CODE       0
-#  define CAPHEIGHT_CODE    1
-#  define DESCENT_CODE      2
-#  define ITALIC_ANGLE_CODE 3
-#  define STEMV_CODE        4
-#  define XHEIGHT_CODE      5
-#  define FONTBBOX1_CODE    6
-#  define FONTBBOX2_CODE    7
-#  define FONTBBOX3_CODE    8
-#  define FONTBBOX4_CODE    9
-#  define FONTNAME_CODE     10
-#  define GEN_KEY_NUM       (XHEIGHT_CODE + 1)
-#  define MAX_KEY_CODE      (FONTBBOX1_CODE + 1)
-#  define INT_KEYS_NUM      (FONTBBOX4_CODE + 1)
-#  define FONT_KEYS_NUM     (FONTNAME_CODE + 1)
-
-#  define FD_FLAGS_NOT_SET_IN_MAPLINE -1
-#  define FD_FLAGS_DEFAULT_EMBED  4     /* a symbol font */
-#  define FD_FLAGS_DEFAULT_NON_EMBED 0x22
-                                        /* a nonsymbolic serif font */
-
-/**********************************************************************/
+
+#define LUATEXFONT_H
+
+#include "ptexlib.h"
+#include "sfnt.h"
+
+#define ASCENT_CODE       0
+#define CAPHEIGHT_CODE    1
+#define DESCENT_CODE      2
+#define ITALIC_ANGLE_CODE 3
+#define STEMV_CODE        4
+#define XHEIGHT_CODE      5
+#define FONTBBOX1_CODE    6
+#define FONTBBOX2_CODE    7
+#define FONTBBOX3_CODE    8
+#define FONTBBOX4_CODE    9
+#define FONTNAME_CODE     10
+#define GEN_KEY_NUM       (XHEIGHT_CODE + 1)
+#define MAX_KEY_CODE      (FONTBBOX1_CODE + 1)
+#define INT_KEYS_NUM      (FONTBBOX4_CODE + 1)
+#define FONT_KEYS_NUM     (FONTNAME_CODE + 1)
+
+#define FD_FLAGS_NOT_SET_IN_MAPLINE -1
+#define FD_FLAGS_DEFAULT_EMBED  4          /* a symbol font */
+#define FD_FLAGS_DEFAULT_NON_EMBED 0x22    /* a nonsymbolic serif font */
 
 typedef struct {
     const char *pdfname;
@@ -63,60 +54,59 @@ typedef struct {
 
 extern const key_entry font_key[FONT_KEYS_NUM];
 
-#  include "mapfile.h"
+#include "mapfile.h"
 
 typedef struct {
-    int val;                    /* value */
-    boolean set;                /* true if parameter has been set */
+    int val;                         /* value */
+    boolean set;                     /* true if parameter has been set */
 } intparm;
 
 typedef struct {
-    int fe_objnum;              /* object number */
-    char *name;                 /* encoding file name */
-    char **glyph_names;         /* array of glyph names */
-    struct avl_table *tx_tree;  /* tree of encoding positions marked as used by TeX */
+    int fe_objnum;                   /* object number */
+    char *name;                      /* encoding file name */
+    char **glyph_names;              /* array of glyph names */
+    struct avl_table *tx_tree;       /* tree of encoding positions marked as used by TeX */
 } fe_entry;
 
 typedef struct fd_entry_ {
-    int fd_objnum;              /* object number of the font descriptor object */
-    char *fontname;             /* /FontName (without subset tag) */
-    char *subset_tag;           /* 6-character subset tag */
+    int fd_objnum;                   /* object number of the font descriptor object */
+    char *fontname;                  /* /FontName (without subset tag) */
+    char *subset_tag;                /* 6-character subset tag */
     boolean ff_found;
-    int ff_objnum;              /* object number of the font program stream */
-    boolean all_glyphs;         /* embed all glyphs? */
+    int ff_objnum;                   /* object number of the font program stream */
+    boolean all_glyphs;              /* embed all glyphs? */
     boolean write_ttf_glyph_names;
     intparm font_dim[FONT_KEYS_NUM];
-    fe_entry *fe;               /* pointer to encoding structure */
-    char **builtin_glyph_names; /* builtin encoding as read from the Type1 font file */
-    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 */
+    fe_entry *fe;                    /* pointer to encoding structure */
+    char **builtin_glyph_names;      /* builtin encoding as read from the Type1 font file */
+    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_ {
-    int fo_objnum;              /* object number of the font dictionary */
-    internal_font_number tex_font;      /* needed only for \pdffontattr{} */
-    fm_entry *fm;               /* pointer to font map structure for this font dictionary */
-    fd_entry *fd;               /* pointer to /FontDescriptor object structure */
-    fe_entry *fe;               /* pointer to encoding structure */
-    int cw_objnum;              /* object number of the font program object */
-    int first_char;             /* first character used in this font */
-    int last_char;              /* last character used in this font */
-    struct avl_table *tx_tree;  /* tree of non-reencoded TeX characters marked as used */
-    int tounicode_objnum;       /* object number of ToUnicode */
+    int fo_objnum;                   /* object number of the font dictionary */
+    internal_font_number tex_font;   /* needed only for \pdffontattr{} */
+    fm_entry *fm;                    /* pointer to font map structure for this font dictionary */
+    fd_entry *fd;                    /* pointer to /FontDescriptor object structure */
+    fe_entry *fe;                    /* pointer to encoding structure */
+    int cw_objnum;                   /* object number of the font program object */
+    int first_char;                  /* first character used in this font */
+    int last_char;                   /* last character used in this font */
+    struct avl_table *tx_tree;       /* tree of non-reencoded TeX characters marked as used */
+    int tounicode_objnum;            /* object number of ToUnicode */
 } fo_entry;
 
 typedef struct {
-    char *name;                 /* glyph name */
-    long code;                  /* -1 = undefined; -2 = multiple codes, stored
-                                   as string in unicode_seq; otherwise unicode value */
-    char *unicode_seq;          /* multiple unicode sequence */
+    char *name;                      /* glyph name */
+    long code;                       /* -1 = undefined; -2 = multiple codes, stored as string in unicode_seq; otherwise unicode value */
+    char *unicode_seq;               /* multiple unicode sequence */
 } glyph_unicode_entry;
 
-typedef struct glw_entry_ {     /* subset glyphs for inclusion in CID-based fonts */
-    unsigned int id;            /* glyph CID */
-    signed int wd;              /* glyph width in 1/1000 em parts */
+typedef struct glw_entry_ {          /* subset glyphs for inclusion in CID-based fonts */
+    unsigned int id;                 /* glyph CID */
+    signed int wd;                   /* glyph width in 1/1000 em parts */
 } glw_entry;
 
 typedef struct {
@@ -124,19 +114,18 @@ typedef struct {
     halfword *raster;
 } chardesc;
 
-/**********************************************************************/
-
-#  include "texfont.h"
+#include "texfont.h"
 
 /* tounicode.c */
+
 int write_cid_tounicode(PDF, fo_entry *, internal_font_number);
 void glyph_unicode_free(void);
 void def_tounicode(str_number, str_number);
 int write_tounicode(PDF, char **, char *);
 
 /* vfpacket.c */
-void replace_packet_fonts(internal_font_number f, int *old_fontid,
-                          int *new_fontid, int count);
+
+void replace_packet_fonts(internal_font_number f, int *old_fontid, int *new_fontid, int count);
 int *packet_local_fonts(internal_font_number f, int *num);
 
 int packet_cur_s;               /* current |do_vf_packet()| recursion level */
@@ -144,12 +133,15 @@ int packet_stack_ptr;           /* pointer into |packet_stack| */
 vf_struct *new_vfstruct(void);
 
 /* writecff.c */
+
 void writetype1w(PDF pdf, fd_entry * fd);
 
 /* writetype0.c */
+
 void writetype0(PDF pdf, fd_entry * fd);
 
 /* writefont.c */
+
 void do_pdf_font(PDF, internal_font_number);
 fd_entry *lookup_fd_entry(char *);
 fd_entry *new_fd_entry(internal_font_number);
@@ -157,6 +149,7 @@ void write_fontstuff(PDF);
 void register_fd_entry(fd_entry * fd);
 
 /* writet1.c */
+
 boolean t1_subset(char *, char *, unsigned char *);
 char **load_enc_file(char *);
 void writet1(PDF, fd_entry *);
@@ -164,36 +157,40 @@ void t1_free(void);
 extern int t1_length1, t1_length2, t1_length3;
 
 /* writetype2.c */
+
 boolean writetype2(PDF, fd_entry *);
 extern unsigned long cidtogid_obj;
-pdf_obj *pdf_new_stream(void);
-void pdf_add_stream(pdf_obj * stream, unsigned char *buf, long len);
-void pdf_release_obj(pdf_obj * stream);
 unsigned long ttc_read_offset(sfnt * sfont, int ttc_idx, fd_entry *fd);
 
 /* writeenc.c */
+
 fe_entry *get_fe_entry(char *);
 void enc_free(void);
 void write_fontencodings(PDF pdf);
 
 /* writettf.c */
+
 void writettf(PDF, fd_entry *);
 void writeotf(PDF, fd_entry *);
 void ttf_free(void);
 extern int ttf_length;
 
 /* pkin.c */
+
 int readchar(boolean, chardesc *);
 
 /* macnames.c */
+
 extern char notdef[];
 
 /* vfovf.c */
+
 internal_font_number letter_space_font(internal_font_number f, int e, boolean nolig);
 void pdf_check_vf(internal_font_number f);
 internal_font_number copy_font_info(internal_font_number f);
 
 /* writet3.c */
+
 extern FILE *t3_file;
 void writet3(PDF, internal_font_number);
 
@@ -201,12 +198,11 @@ extern unsigned char *t3_buffer;
 extern int t3_size;
 extern int t3_curbyte;
 
-#  define t3_read_file() readbinfile(t3_file, &t3_buffer, &t3_size)
-#  define t3_close()     xfclose(t3_file, cur_file_name)
-#  define t3_getchar()   t3_buffer[t3_curbyte++]
-#  define t3_eof()       (t3_curbyte>t3_size)
-
-#  define t3_prefix(s)   (!strncmp(t3_line_array, s, strlen(s)))
-#  define t3_putchar(c)  pdfout(c)
+#define t3_read_file() readbinfile(t3_file, &t3_buffer, &t3_size)
+#define t3_close()     xfclose(t3_file, cur_file_name)
+#define t3_getchar()   t3_buffer[t3_curbyte++]
+#define t3_eof()       (t3_curbyte>t3_size)
+#define t3_prefix(s)   (!strncmp(t3_line_array, s, strlen(s)))
+#define t3_putchar(c)  pdfout(c)
 
-#endif                          /* LUATEXFONT_H */
+#endif
diff --git a/texk/web2c/luatexdir/font/mapfile.h b/texk/web2c/luatexdir/font/mapfile.h
index ad752af74..e3e0e613a 100644
--- a/texk/web2c/luatexdir/font/mapfile.h
+++ b/texk/web2c/luatexdir/font/mapfile.h
@@ -98,13 +98,6 @@ typedef struct {
 
 /**********************************************************************/
 
-#  define FONT_SLANT_MIN   -2000
-#  define FONT_SLANT_MAX    2000
-#  define FONT_EXTEND_MIN  -5000
-#  define FONT_EXTEND_MAX   5000
-
-/**********************************************************************/
-
 fm_entry *getfontmap(char *tfm_name);
 void fm_free(void);
 ff_entry *check_ff_exist(char *, boolean);
diff --git a/texk/web2c/luatexdir/font/sfnt.h b/texk/web2c/luatexdir/font/sfnt.h
index dce4248e9..602a0805f 100644
--- a/texk/web2c/luatexdir/font/sfnt.h
+++ b/texk/web2c/luatexdir/font/sfnt.h
@@ -28,11 +28,12 @@
 #  endif                        /* HAVE_CONFIG_H_ */
 
 /* Data Types as described in Apple's TTRefMan */
-typedef unsigned char BYTE;
+
+/*typedef unsigned char BYTE;*/ /* defined in pdfgen.h */
 typedef signed char ICHAR;
 typedef unsigned short USHORT;
 typedef signed short SHORT;
-typedef unsigned long ULONG;
+/*typedef unsigned long ULONG;*//* defined in pdfgen.h */
 typedef signed long LONG;
 typedef unsigned long Fixed;    /* 16.16-bit signed fixed-point number */
 typedef short FWord;
@@ -70,40 +71,16 @@ struct sfnt_table_directory {
 typedef struct {
     int type;
     struct sfnt_table_directory *directory;
-#  ifdef XETEX
-    FT_Face ft_face;
-    long loc;
-#  elif defined(pdfTeX)
     BYTE *buffer;
     long buflen;
     long loc;
-#  else
-    FILE *stream;
-#  endif
 } sfnt;
 
 /* Convert sfnt "fixed" type to double */
+
 #  define fixed(a) ((double)((a)%0x10000L)/(double)(0x10000L) + \
  (a)/0x10000L - (((a)/0x10000L > 0x7fffL) ? 0x10000L : 0))
 
-#  ifdef XETEX
-UNSIGNED_BYTE ft_unsigned_byte(sfnt * f);
-SIGNED_BYTE ft_signed_byte(sfnt * f);
-UNSIGNED_PAIR ft_unsigned_pair(sfnt * f);
-SIGNED_PAIR ft_signed_pair(sfnt * f);
-UNSIGNED_QUAD ft_unsigned_quad(sfnt * f);
-unsigned long ft_read(unsigned char *buf, unsigned long len, sfnt * f);
-
-#    define sfnt_get_byte(s)   ((BYTE)   ft_unsigned_byte(s))
-#    define sfnt_get_char(s)   ((ICHAR)   ft_signed_byte  (s))
-#    define sfnt_get_ushort(s) ((USHORT) ft_unsigned_pair(s))
-#    define sfnt_get_short(s)  ((SHORT)  ft_signed_pair  (s))
-#    define sfnt_get_ulong(s)  ((ULONG)  ft_unsigned_quad(s))
-#    define sfnt_get_long(s)   ((LONG)   ft_signed_quad  (s))
-
-#    define sfnt_seek_set(s,o) (s)->loc = (o)
-#    define sfnt_read(b,l,s)   ft_read((b), (l), (s))
-#  elif defined(pdfTeX)
 BYTE get_unsigned_byte(sfnt * f);
 ICHAR get_signed_byte(sfnt * f);
 USHORT get_unsigned_pair(sfnt * f);
@@ -111,45 +88,28 @@ SHORT get_signed_pair(sfnt * f);
 ULONG get_unsigned_quad(sfnt * f);
 int do_sfnt_read(unsigned char *dest, int len, sfnt * f);
 
-#    define sfnt_get_byte(s)   ((BYTE)   get_unsigned_byte(s))
-#    define sfnt_get_char(s)   ((ICHAR)   get_signed_byte  (s))
-#    define sfnt_get_ushort(s) ((USHORT) get_unsigned_pair(s))
-#    define sfnt_get_short(s)  ((SHORT)  get_signed_pair  (s))
-#    define sfnt_get_ulong(s)  ((ULONG)  get_unsigned_quad(s))
-#    define sfnt_get_long(s)   ((LONG)   get_signed_quad  (s))
-
-#    define sfnt_seek_set(s,o) (s)->loc = (o)
-#    define sfnt_read(b,l,s)   do_sfnt_read((b), (l), (s))
-#  else
-/* get_***_*** from numbers.h */
-#    define sfnt_get_byte(s)   ((BYTE)   get_unsigned_byte((s)->stream))
-#    define sfnt_get_char(s)   ((ICHAR)  get_signed_byte  ((s)->stream))
-#    define sfnt_get_ushort(s) ((USHORT) get_unsigned_pair((s)->stream))
-#    define sfnt_get_short(s)  ((SHORT)  get_signed_pair  ((s)->stream))
-#    define sfnt_get_ulong(s)  ((ULONG)  get_unsigned_quad((s)->stream))
-#    define sfnt_get_long(s)   ((LONG)   get_signed_quad  ((s)->stream))
-
-#    define sfnt_seek_set(s,o)   seek_absolute((s)->stream, (o))
-#    define sfnt_read(b,l,s)     fread((b), 1, (l), (s)->stream)
-#  endif
+#define sfnt_get_byte(s)   ((BYTE)   get_unsigned_byte(s))
+#define sfnt_get_char(s)   ((ICHAR)   get_signed_byte  (s))
+#define sfnt_get_ushort(s) ((USHORT) get_unsigned_pair(s))
+#define sfnt_get_short(s)  ((SHORT)  get_signed_pair  (s))
+#define sfnt_get_ulong(s)  ((ULONG)  get_unsigned_quad(s))
+#define sfnt_get_long(s)   ((LONG)   get_signed_quad  (s))
+
+#define sfnt_seek_set(s,o) (s)->loc = (o)
+#define sfnt_read(b,l,s)   do_sfnt_read((b), (l), (s))
 
 extern int put_big_endian(void *s, LONG q, int n);
 
-#  define sfnt_put_ushort(s,v) put_big_endian((s), v, 2);
-#  define sfnt_put_short(s,v)  put_big_endian((s), v, 2);
-#  define sfnt_put_ulong(s,v)  put_big_endian((s), v, 4);
-#  define sfnt_put_long(s,v)   put_big_endian((s), v, 4);
+#define sfnt_put_ushort(s,v) put_big_endian((s), v, 2);
+#define sfnt_put_short(s,v)  put_big_endian((s), v, 2);
+#define sfnt_put_ulong(s,v)  put_big_endian((s), v, 4);
+#define sfnt_put_long(s,v)   put_big_endian((s), v, 4);
 
-#  ifdef XETEX
-extern sfnt *sfnt_open(FT_Face face, int accept_types);
-#  elif defined(pdfTeX)
 extern sfnt *sfnt_open(unsigned char *buffer, int buflen);
-#  else
-extern sfnt *sfnt_open(FILE * fp);
-#  endif
 extern void sfnt_close(sfnt * sfont);
 
 /* table directory */
+
 extern int sfnt_read_table_directory(sfnt * sfont, ULONG offset);
 extern ULONG sfnt_find_table_len(sfnt * sfont, const char *tag);
 extern ULONG sfnt_find_table_pos(sfnt * sfont, const char *tag);
@@ -159,18 +119,10 @@ extern void sfnt_set_table(sfnt * sfont,
                            const char *tag, void *data, ULONG length);
 extern int sfnt_require_table(sfnt * sfont, const char *tag, int must_exist);
 
-#  ifdef pdfTeX
-typedef struct {
-    ULONG length;
-    BYTE *data;
-} pdf_obj;
-
-#    define ASSERT(a) assert(a)
-#    define RELEASE(a) free(a)
-#    define NEW(a,b) xmalloc((unsigned)((unsigned)(a)*sizeof(b)))
-#    define RENEW(a,b,c) xrealloc(a, (unsigned)((unsigned)(b)*sizeof(c)))
-
-#  endif
+#define ASSERT(a) assert(a)
+#define RELEASE(a) free(a)
+#define NEW(a,b) xmalloc((unsigned)((unsigned)(a)*sizeof(b)))
+#define RENEW(a,b,c) xrealloc(a, (unsigned)((unsigned)(b)*sizeof(c)))
 
 extern pdf_obj *sfnt_create_FontFile_stream(sfnt * sfont);
 
diff --git a/texk/web2c/luatexdir/font/texfont.h b/texk/web2c/luatexdir/font/texfont.h
index 75beafe66..2622b7a14 100644
--- a/texk/web2c/luatexdir/font/texfont.h
+++ b/texk/web2c/luatexdir/font/texfont.h
@@ -32,6 +32,17 @@
 
 #  define pointer halfword
 
+#  define FONT_SLANT_MIN   -2000
+#  define FONT_SLANT_MAX    2000
+#  define FONT_EXTEND_MIN  -5000
+#  define FONT_EXTEND_MAX   5000
+#  define FONT_SQUEEZE_MIN -5000
+#  define FONT_SQUEEZE_MAX  5000
+#  define FONT_MODE_MIN        0
+#  define FONT_MODE_MAX        3 /* pdf values */
+#  define FONT_WIDTH_MIN       0
+#  define FONT_WIDTH_MAX    5000
+
 /* these are dumped en block, so they need endianness tests */
 
 typedef struct liginfo {
@@ -141,6 +152,9 @@ typedef struct texfont {
     boolean _font_oldmath;      /* default to false when MathConstants seen */
     int _font_slant;            /* a slant in ppt */
     int _font_extend;           /* an extension in ppt, or 1000 */
+    int _font_squeeze;          /* an extension in ppt, or 1000 */
+    int _font_width;
+    int _font_mode;
     int font_max_shrink;
     int font_max_stretch;
     int _font_step;             /* amount of one step of expansion */
@@ -329,6 +343,15 @@ boolean cmp_font_area(int, str_number);
 #  define font_extend(a)                 font_tables[a]->_font_extend
 #  define set_font_extend(a,b)           font_extend(a) = b
 
+#  define font_squeeze(a)                font_tables[a]->_font_squeeze
+#  define set_font_squeeze(a,b)          font_squeeze(a) = b
+
+#  define font_width(a)                  font_tables[a]->_font_width
+#  define set_font_width(a,b)            font_width(a) = b
+
+#  define font_mode(a)                   font_tables[a]->_font_mode
+#  define set_font_mode(a,b)             font_mode(a) = b
+
 #  define font_shrink(a)                 font_tables[a]->_font_shrink
 #  define set_font_shrink(a,b)           font_shrink(a) = b
 
@@ -625,7 +648,7 @@ typedef enum { packet_char_code,
     packet_scale_code,
     packet_lua_code,
     packet_pdf_code,
-    packet_pdf_mode,
+    packet_pdf_mode
 } packet_command_codes;
 
 extern scaled store_scaled_f(scaled sq, int fw);
diff --git a/texk/web2c/luatexdir/image/epdf.h b/texk/web2c/luatexdir/image/epdf.h
index 57bb2e39a..9c32c06b7 100644
--- a/texk/web2c/luatexdir/image/epdf.h
+++ b/texk/web2c/luatexdir/image/epdf.h
@@ -18,15 +18,19 @@
    with LuaTeX; if not, see <http://www.gnu.org/licenses/>. */
 
 
-// this is the common header file for C++ sources pdftoepdf.cc and lepdflib.cc
+/* this is the common header file for C++ sources pdftoepdf.c and lepdflib.c */
 
 #ifndef EPDF_H
 #  define EPDF_H
-extern "C" {
+
+/*extern "C" {*/
+
 #ifdef HAVE_CONFIG_H
 #include <w2c/config.h>
 #endif
-}
+
+/*}*/
+
 #  include <stdlib.h>
 #  include <math.h>
 #  include <stddef.h>
@@ -35,41 +39,22 @@ extern "C" {
 #  include <kpathsea/c-ctype.h>
 #  include <sys/stat.h>
 #  include <dirent.h>
-#  include <poppler-config.h>
-#  include <goo/GooString.h>
-#  include <goo/gmem.h>
-#  include <goo/gfile.h>
-#  include <Object.h>
-#  include <Stream.h>
-#  include <Gfx.h>
-#  include <Annot.h>
-#  include <Array.h>
-#  include <Dict.h>
-#  include <XRef.h>
-#  include <Catalog.h>
-#  include <StructTreeRoot.h>
-#  include <Link.h>
-#  include <Page.h>
-#  include <GfxFont.h>
-#  include <PDFDoc.h>
-#  include <GlobalParams.h>
-#  include <Error.h>
-#  include <FileSpec.h>
-
-extern "C" {
+
+/*extern "C" { */
 
 #  include <kpathsea/c-auto.h>
 
-    extern char *xstrdup(const char *);
+extern char *xstrdup(const char *);
 
-    typedef enum { FE_FAIL, FE_RETURN_NULL } file_error_mode;
+typedef enum { FE_FAIL, FE_RETURN_NULL } file_error_mode;
 
 /* the following code is extremly ugly but needed for including web2c/config.h */
 
-    typedef const char *const_string;   /* including kpathsea/types.h doesn't work on some systems */
+typedef const char *const_string;   /* including kpathsea/types.h doesn't work on some systems */
 
 #  define KPATHSEA_CONFIG_H     /* avoid including other kpathsea header files */
-    /* from web2c/config.h */
+
+/* from web2c/config.h */
 
 #  ifdef CONFIG_H               /* CONFIG_H has been defined by some xpdf */
 #    undef CONFIG_H             /* header file */
@@ -84,117 +69,105 @@ extern "C" {
 #  include "lua.h"
 #  include "lauxlib.h"
 
-    /* pdfgen.w */
-    extern int ten_pow[10];
-    __attribute__ ((format(printf, 2, 3)))
-    extern void pdf_printf(PDF, const char *fmt, ...);
-    extern void pdf_begin_obj(PDF, int, int);
-    extern void pdf_end_obj(PDF);
-    extern void pdf_begin_dict(PDF);
-    extern void pdf_end_dict(PDF);
-    extern void pdf_begin_array(PDF);
-    extern void pdf_end_array(PDF);
-    extern void pdf_add_null(PDF);
-    extern void pdf_add_bool(PDF, int i);
-    extern void pdf_add_int(PDF, int i);
-    extern void pdf_add_ref(PDF, int num);
-    extern void pdf_add_name(PDF, const char *name);
-    extern void pdf_dict_add_streaminfo(PDF);
-    extern void pdf_begin_stream(PDF);
-    extern void pdf_end_stream(PDF);
-    extern void pdf_room(PDF, int);
-    extern void pdf_out_block(PDF pdf, const char *s, size_t n);
-
-    extern void pdf_dict_add_int(PDF, const char *key, int i);
-    extern void pdf_dict_add_ref(PDF, const char *key, int num);
-    extern void pdf_dict_add_name(PDF, const char *key, const char *val);
-    extern void pdf_dict_add_streaminfo(PDF);
-
-#  define pdf_out(pdf, A) do { pdf_room(pdf, 1); *(pdf->buf->p++) = A; } while (0)
-#  define pdf_quick_out(pdf,A) *(pdf->buf->p++)=(unsigned char)(A)
+# include "luapplib/pplib.h"
+
+/* pdfgen.w */
+
+extern int ten_pow[10];
+__attribute__ ((format(printf, 2, 3)))
+extern void pdf_printf(PDF, const char *fmt, ...);
+extern void pdf_begin_obj(PDF, int, int);
+extern void pdf_end_obj(PDF);
+extern void pdf_begin_dict(PDF);
+extern void pdf_end_dict(PDF);
+extern void pdf_begin_array(PDF);
+extern void pdf_end_array(PDF);
+extern void pdf_add_null(PDF);
+extern void pdf_add_bool(PDF, int i);
+extern void pdf_add_int(PDF, int i);
+extern void pdf_add_real(PDF, double d);
+extern void pdf_add_ref(PDF, int num);
+extern void pdf_add_name(PDF, const char *name);
+extern void pdf_dict_add_streaminfo(PDF);
+extern void pdf_begin_stream(PDF);
+extern void pdf_end_stream(PDF);
+extern void pdf_room(PDF, int);
+extern void pdf_out_block(PDF pdf, const char *s, size_t n);
+
+extern void pdf_dict_add_int(PDF, const char *key, int i);
+extern void pdf_dict_add_ref(PDF, const char *key, int num);
+extern void pdf_dict_add_name(PDF, const char *key, const char *val);
+extern void pdf_dict_add_streaminfo(PDF);
+
+/* Conflict with pdfgen.h */
+/*#  define pdf_out(pdf, A) do { pdf_room(pdf, 1); *(pdf->buf->p++) = A; } while (0)*/
+/*#  define pdf_quick_out(pdf,A) *(pdf->buf->p++)=(unsigned char)(A) */
+
 #  define pdf_puts(pdf, s) pdf_out_block((pdf), (s), strlen(s))
 
-    /* pdfpage.w */
-    extern void print_pdffloat(PDF pdf, pdffloat f);
+/* pdfpage.w */
 
-    /* pdftables.w */
-    extern int pdf_create_obj(PDF pdf, int t, int i);
+extern void print_pdffloat(PDF pdf, pdffloat f);
 
-    /* pdftoepdf.cc */
-    extern void read_pdf_info(image_dict *);
-    extern void flush_pdf_info(image_dict *);
-    extern void write_epdf(PDF, image_dict *, int suppress_optional_info);
-    extern void unrefPdfDocument(char *);
-    extern void unrefMemStreamPdfDocument(char *);
-    extern void epdf_free(void);
-    extern void copyReal(PDF pdf, double d);
+/* pdftables.w */
 
-    /* writeimg.w */
-    extern void pdf_dict_add_img_filename(PDF pdf, image_dict * idict);
+extern int pdf_create_obj(PDF pdf, int t, int i);
 
-    /* utils.w */
-    extern char *convertStringToPDFString(char *in, int len);
+/* pdftoepdf.c */
 
-    /* lepdflib.w */
-    int luaopen_epdf(lua_State * L);
+extern void read_pdf_info(image_dict *);
+extern void flush_pdf_info(image_dict *);
 
-#  include "luatex-common.h"
+extern void write_epdf(PDF, image_dict *, int suppress_optional_info);
+extern int  write_epdf_object(PDF, image_dict *, int n);
 
-};
+extern void unrefPdfDocument(char *);
+extern void unrefMemStreamPdfDocument(char *);
 
-/**********************************************************************/
-
-// PdfObject encapsulates the xpdf Object type,
-// and properly frees its resources on destruction.
-// Use obj-> to access members of the Object,
-// and &obj to get a pointer to the object.
-// It is no longer necessary to call Object::free explicitely.
-
-#  if 0
-// PdfObject is replaced by xpdf's Object type, with manual obj.free()
-
-// *INDENT-OFF*
-class PdfObject {
-  public:
-    PdfObject() {               // nothing
-    }
-    ~PdfObject() {
-        iObject.free();
-    }
-    Object *operator->() {
-        return &iObject;
-    }
-    Object *operator&() {
-        return &iObject;
-    }
-  private:                     // no copying or assigning
-    PdfObject(const PdfObject &);
-    void operator=(const PdfObject &);
-  public:
-    Object iObject;
-};
-// *INDENT-ON*
-#  endif
+extern void epdf_free(void);
+
+/* writeimg.w */
 
-/**********************************************************************/
+extern void pdf_dict_add_img_filename(PDF pdf, image_dict * idict);
+
+/* utils.w */
+
+/*extern char *convertStringToPDFString(const char *in, int len);*/
+
+/* lepdflib.w */
+
+int luaopen_epdf(lua_State * L);
+
+#  include "luatex-common.h"
+
+/*}*/
+
+typedef struct InObj InObj;
 
 struct InObj {
-    Ref ref;                    // ref in original PDF
-    int num;                    // new object number in output PDF
-    InObj *next;                // next entry in list of indirect objects
-};
+    ppref *ref;                 /* ref in original PDF */
+    int num;                    /* new object number in output PDF */
+    InObj *next;                /* next entry in list of indirect objects */
+} ;
+
+
+typedef struct avl_table avl_table;
 
 struct PdfDocument {
-    char *file_path;            // full file name including path
-    char *checksum;             // for reopening
-    PDFDoc *doc;
-    InObj *inObjList;           // temporary linked list
-    avl_table *ObjMapTree;      // permanent over luatex run
-    unsigned int occurences;    // number of references to the PdfDocument; it can be deleted when occurences == 0
-    unsigned int pc;            // counter to track PDFDoc generation or deletion
+    char *file_path;            /* full file name including path */
+    char *checksum;             /* for reopening */
+    ppdoc *pdfe;
+    InObj *inObjList;           /* temporary linked list */
+    avl_table *ObjMapTree;      /* permanent over luatex run */
+    int is_mem;
+    char *memstream;
+    unsigned int occurences;    /* number of references to the PdfDocument; it can be deleted when occurences == 0 */
+    unsigned int pc;            /* counter to track PDFDoc generation or deletion */
 };
 
-PdfDocument *refPdfDocument(const char *file_path, file_error_mode fe);
+typedef struct PdfDocument PdfDocument;
+
+PdfDocument *refPdfDocument(const char *file_path, file_error_mode fe, const char *userpassword, const char *ownerpassword);
 
 PdfDocument *refMemStreamPdfDocument(char *docstream, unsigned long long streamsize, const char *file_id);
 
diff --git a/texk/web2c/luatexdir/image/image.h b/texk/web2c/luatexdir/image/image.h
index 7c79723f1..985f53d06 100644
--- a/texk/web2c/luatexdir/image/image.h
+++ b/texk/web2c/luatexdir/image/image.h
@@ -39,6 +39,7 @@ extern scaled one_hundred_bp;   /* from pdfgen.w */
 
 typedef struct {
     char *stream;
+    size_t size;
 } pdf_stream_struct;
 
 typedef struct {
@@ -116,6 +117,8 @@ typedef struct {
     char *filepath;             /* full file path after kpathsea */
     char *attr;                 /* additional image dict entries */
     FILE *file;
+    char *userpassword;
+    char *ownerpassword;
     imgtype_e image_type;
     int procset;                /* /ProcSet flags */
     int color_depth;            /* color depth */
@@ -125,6 +128,7 @@ typedef struct {
     int flags;
     int luaref ;
     boolean keepopen;
+    boolean nolength;
     int errorlevel;
     int pdfmajorversion;
     int pdfminorversion;
@@ -159,6 +163,8 @@ typedef struct {
 #  define img_pagename(N)         ((N)->pagename)
 #  define img_filename(N)         ((N)->filename)
 #  define img_visiblefilename(N)  ((N)->visiblefilename)
+#  define img_userpassword(N)     ((N)->userpassword)
+#  define img_ownerpassword(N)    ((N)->ownerpassword)
 #  define img_filepath(N)         ((N)->filepath)
 #  define img_attr(N)             ((N)->attr)
 #  define img_file(N)             ((N)->file)
@@ -171,12 +177,14 @@ typedef struct {
 #  define img_flags(N)            ((N)->flags)
 #  define img_luaref(N)           ((N)->luaref)
 #  define img_keepopen(N)         ((N)->keepopen)
+#  define img_nolength(N)         ((N)->nolength)
 #  define img_errorlevel(N)       ((N)->errorlevel)
 #  define img_pdfmajorversion(N)  ((N)->pdfmajorversion)
 #  define img_pdfminorversion(N)  ((N)->pdfminorversion)
 
 #  define img_pdfstream_ptr(N)    ((N)->img_struct.pdfstream)
 #  define img_pdfstream_stream(N) ((N)->img_struct.pdfstream->stream)
+#  define img_pdfstream_size(N)   ((N)->img_struct.pdfstream->size)
 
 #  define img_png_ptr(N)          ((N)->img_struct.png)
 #  define img_png_png_ptr(N)      ((N)->img_struct.png->png_ptr)
diff --git a/texk/web2c/luatexdir/image/pdftoepdf.h b/texk/web2c/luatexdir/image/pdftoepdf.h
index 0a8ef942c..cc8f0e150 100644
--- a/texk/web2c/luatexdir/image/pdftoepdf.h
+++ b/texk/web2c/luatexdir/image/pdftoepdf.h
@@ -30,12 +30,7 @@ void flush_pdf_info(image_dict *);
 void unrefPdfDocument(char *);
 void unrefMemStreamPdfDocument(char *);
 void write_epdf(PDF, image_dict *, int suppress_optional_info);
-void epdf_check_mem(void);
-void copyReal(PDF pdf, double d);
-
-int poppler_version_major(void);
-int poppler_version_minor(void);
-int poppler_version_micro(void);
+int write_epdf_object(PDF, image_dict *, int n);
 
 /* epdf.c --- this should go in an own header file */
 
diff --git a/texk/web2c/luatexdir/image/writeimg.h b/texk/web2c/luatexdir/image/writeimg.h
index 46c42d265..dc86648e2 100644
--- a/texk/web2c/luatexdir/image/writeimg.h
+++ b/texk/web2c/luatexdir/image/writeimg.h
@@ -38,6 +38,7 @@ void scan_pdfrefximage(PDF pdf);
 scaled_whd tex_scale(scaled_whd nat, scaled_whd tex);
 scaled_whd scale_img(image_dict *, scaled_whd, int);
 void write_img(PDF, image_dict *);
+int write_img_object(PDF, image_dict *, int n);
 void pdf_write_image(PDF pdf, int n);
 void check_pdfstream_dict(image_dict *);
 void write_pdfstream(PDF, image_dict *);
diff --git a/texk/web2c/luatexdir/lua/lcallbacklib.c b/texk/web2c/luatexdir/lua/lcallbacklib.c
index f3ff58a75..32cf66302 100644
--- a/texk/web2c/luatexdir/lua/lcallbacklib.c
+++ b/texk/web2c/luatexdir/lua/lcallbacklib.c
@@ -22,6 +22,9 @@
 
 int callback_count = 0;
 int saved_callback_count = 0;
+int direct_callback_count = 0;
+int late_callback_count = 0;
+int function_callback_count = 0;
 
 int callback_set[total_callbacks] = { 0 };
 
@@ -74,7 +77,12 @@ static const char *const callbacknames[] = {
     "call_edit",
     "build_page_insert",
     "glyph_stream_provider",
-    "finish_synctex_callback",
+    "font_descriptor_objnum_provider",
+    "finish_synctex",
+    "wrapup_run",
+    "new_graf",
+    "page_objnum_provider",
+    "make_extensible",
     NULL
 };
 
@@ -207,7 +215,6 @@ int run_saved_callback(int r, const char *name, const char *values, ...)
     lua_rawget(Luas, -2);
     if (lua_isfunction(Luas, -1)) {
         saved_callback_count++;
-        callback_count++;
         ret = do_run_callback(2, values, args);
     }
     va_end(args);
diff --git a/texk/web2c/luatexdir/lua/lepdflib.cc b/texk/web2c/luatexdir/lua/lepdflib.cc
index 32bcdab01..ea8ed96b0 100644
--- a/texk/web2c/luatexdir/lua/lepdflib.cc
+++ b/texk/web2c/luatexdir/lua/lepdflib.cc
@@ -17,3627 +17,3 @@
 
    You should have received a copy of the GNU General Public License along
    with LuaTeX; if not, see <http://www.gnu.org/licenses/>. */
-
-
-#include "image/epdf.h"
-
-// Patches for the new poppler 0.59 from
-// https://www.mail-archive.com/arch-commits@archlinux.org/msg357548.html
-// with some modifications to comply the poppler API.
-
-// define DEBUG
-
-//**********************************************************************
-// TODO: add more poppler functions (many are still missing)
-
-//**********************************************************************
-// objects allocated by poppler may not be deleted in the lepdflib
-
-typedef enum { ALLOC_POPPLER, ALLOC_LEPDF } alloctype;
-
-typedef struct {
-    void *d;
-    alloctype atype;            // was it allocated by poppler or the lepdflib.cc?
-    PdfDocument *pd;            // reference to PdfDocument, or NULL
-    unsigned long pc;           // counter to detect PDFDoc change
-} udstruct;
-
-static const char *ErrorCodeNames[] = { "None", "OpenFile", "BadCatalog",
-    "Damaged", "Encrypted", "HighlightFile", "BadPrinter", "Printing",
-    "Permission", "BadPageNum", "FileIO", NULL
-};
-
-//**********************************************************************
-
-#define M_Annot            "epdf.Annot" /* ls-hh: epdf.* gives better protection in registry */
-#define M_Annots           "epdf.Annots"
-#define M_Array            "epdf.Array"
-#define M_Catalog          "epdf.Catalog"
-#define M_Dict             "epdf.Dict"
-#define M_EmbFile          "epdf.EmbFile"
-#define M_FileSpec         "epdf.FileSpec"
-#define M_GooString        "epdf.GooString"
-#define M_LinkDest         "epdf.LinkDest"
-#define M_Link             "epdf.Link"
-#define M_Links            "epdf.Links"
-#define M_Object           "epdf.Object"
-#define M_Page             "epdf.Page"
-#define M_PDFDoc           "epdf.PDFDoc"
-#define M_PDFRectangle     "epdf.PDFRectangle"
-#define M_Ref              "epdf.Ref"
-#define M_Stream           "epdf.Stream"
-#define M_StructElement    "epdf.StructElement"
-#define M_Attribute        "epdf.Attribute"
-#define M_TextSpan         "epdf.TextSpan"
-#define M_StructTreeRoot   "epdf.StructTreeRoot"
-#define M_XRefEntry        "epdf.XRefEntry"
-#define M_XRef             "epdf.XRef"
-
-//**********************************************************************
-
-#define new_poppler_userdata(type)                                              \
-static udstruct *new_##type##_userdata(lua_State * L)                           \
-{                                                                               \
-    udstruct *a;                                                                \
-    a = (udstruct *) lua_newuserdata(L, sizeof(udstruct));  /* udstruct ... */  \
-    a->atype = ALLOC_POPPLER;                                                   \
-    luaL_getmetatable(L, M_##type);     /* m udstruct ... */                    \
-    lua_setmetatable(L, -2);    /* udstruct ... */                              \
-    return a;                                                                   \
-}
-
-new_poppler_userdata(PDFDoc);
-
-new_poppler_userdata(Annot);
-new_poppler_userdata(Array);
-new_poppler_userdata(Catalog);
-new_poppler_userdata(Dict);
-new_poppler_userdata(EmbFile);
-new_poppler_userdata(FileSpec);
-new_poppler_userdata(LinkDest);
-new_poppler_userdata(Links);
-new_poppler_userdata(Object);
-new_poppler_userdata(Page);
-new_poppler_userdata(PDFRectangle);
-new_poppler_userdata(Ref);
-new_poppler_userdata(Stream);
-new_poppler_userdata(StructElement);
-new_poppler_userdata(Attribute);
-new_poppler_userdata(TextSpan);
-new_poppler_userdata(StructTreeRoot);
-new_poppler_userdata(XRef);
-
-//**********************************************************************
-
-static void pdfdoc_changed_error(lua_State * L)
-{
-    luaL_error(L, "PDFDoc changed or gone");
-}
-
-static void pdfdoc_differs_error(lua_State * L)
-{
-    luaL_error(L, "PDFDoc differs between arguments");
-}
-
-//**********************************************************************
-
-static int l_open_PDFDoc(lua_State * L)
-{
-    const char *file_path;
-    udstruct *uout;
-    PdfDocument *d;
-    file_path = luaL_checkstring(L, 1); // path
-    d = refPdfDocument(file_path, FE_RETURN_NULL);
-    if (d == NULL)
-        lua_pushnil(L);
-    else {
-      if (!(globalParams)) // globalParams could be already created
-          globalParams = new GlobalParams();
-        uout = new_PDFDoc_userdata(L);
-        uout->d = d;
-        uout->atype = ALLOC_LEPDF;
-        uout->pc = d->pc;
-        uout->pd = d;
-    }
-    return 1;                   // doc path
-}
-
-static int l_open_MemStreamPDFDoc(lua_State * L)
-{
-    const char *docstream = NULL;
-    char *docstream_usr = NULL ;
-    const char *file_id;
-    unsigned long long stream_size;
-    udstruct *uout;
-    PdfDocument *d;
-    switch (lua_type(L, 1)) {
-      case LUA_TSTRING:
-         docstream = luaL_checkstring(L, 1); // stream as Lua string
-         break;
-      case LUA_TLIGHTUSERDATA:
-         docstream = (const char *) lua_touserdata(L, 1); // stream as sequence of bytes
-	 break;
-       default:
-         luaL_error(L, "bad argument: string or lightuserdata expected");
-    }
-    if (docstream==NULL)
-      luaL_error(L, "bad document");
-    stream_size = (unsigned long long) luaL_checkint(L, 2);// size of the stream
-    file_id  =  luaL_checkstring(L, 3); // a symbolic name for this stream, mandatory
-    if (file_id == NULL)
-      luaL_error(L, "PDFDoc has an invalid id");
-    if (strlen(file_id) >STREAM_FILE_ID_LEN )  // a limit to the length of the string
-      luaL_error(L, "PDFDoc has a too long id");
-    docstream_usr = (char *)gmalloc((unsigned) (stream_size + 1));
-    if (!docstream_usr)
-      luaL_error(L, "no room for PDFDoc");
-    memcpy(docstream_usr, docstream, (stream_size + 1));
-    docstream_usr[stream_size]='\0';
-    d = refMemStreamPdfDocument(docstream_usr, stream_size, file_id);
-    if (d == NULL) {
-      lua_pushnil(L);
-      lua_pushnil(L);
-      lua_pushnil(L);
-    }
-    else if (d->file_path == NULL ) {
-      lua_pushnil(L);
-      lua_pushnil(L);
-      lua_pushnil(L);
-    }
-    else {
-      if (!(globalParams)) // globalParams could be already created
-        globalParams = new GlobalParams();
-      uout = new_PDFDoc_userdata(L);
-      uout->d = d;
-      uout->atype = ALLOC_LEPDF;
-      uout->pc = d->pc;
-      uout->pd = d;
-      lua_pushstring(L,d->file_path);
-      lua_pushstring(L,STREAM_URI);
-    }
-    return 3;                   // stream, stream_id, stream_uri
-}
-
-
-
-
-static int l_new_Array(lua_State * L)
-{
-    udstruct *uxref, *uout;
-    uxref = (udstruct *) luaL_checkudata(L, 1, M_XRef);
-    if (uxref->pd != NULL && uxref->pd->pc != uxref->pc)
-        pdfdoc_changed_error(L);
-    uout = new_Array_userdata(L);
-    uout->d = new Array((XRef *) uxref->d);     // automatic init to length 0
-    uout->atype = ALLOC_LEPDF;
-    uout->pc = uxref->pc;
-    uout->pd = uxref->pd;
-    return 1;
-}
-
-static int l_new_Attribute(lua_State * L)
-{
-    Attribute::Type t;
-    const char *n;
-    int nlen;
-    udstruct *uobj, *uout;
-
-    if (lua_type(L,1)==LUA_TNUMBER) {
-       uobj = (udstruct *) luaL_checkudata(L, 2, M_Object);
-       if (uobj->pd != NULL && uobj->pd->pc != uobj->pc)
-           pdfdoc_changed_error(L);
-       t = (Attribute::Type) luaL_checkint(L, 1);
-       uout = new_Attribute_userdata(L);
-       uout->d = new Attribute(t, (Object *)uobj->d);
-       uout->atype = ALLOC_LEPDF;
-       uout->pc = uobj->pc;
-       uout->pd = uobj->pd;
-
-    } else if (lua_type(L,1)==LUA_TSTRING) {
-       n = luaL_checkstring(L,1);
-       nlen = luaL_checkint(L,2);
-       uobj = (udstruct *) luaL_checkudata(L, 3, M_Object);
-       if (uobj->pd != NULL && uobj->pd->pc != uobj->pc)
-          pdfdoc_changed_error(L);
-       uout = new_Attribute_userdata(L);
-       uout->d = new Attribute(n, nlen, (Object *)uobj->d);
-       uout->atype = ALLOC_LEPDF;
-       uout->pc = uobj->pc;
-       uout->pd = uobj->pd;
-    } else
-       lua_pushnil(L);
-    return 1;
-}
-
-#define ATTRIBUTE_TYPE_ENTRY(name)          \
-   lua_pushstring(L, #name);                \
-   lua_pushinteger(L, Attribute::name);     \
-   lua_settable(L,-3)
-
-
-#define OBJECT_TYPE(name)                   \
-   lua_pushstring(L, #name);                \
-   lua_pushinteger(L, (int)name);           \
-   lua_settable(L,-3)
-
-
-#define STRUCTELEMENT_TYPE_ENTRY(name)      \
-   lua_pushstring(L, #name);                \
-   lua_pushinteger(L, StructElement::name); \
-   lua_settable(L,-3)
-
-
-static int l_Attribute_Type(lua_State * L) {
-   lua_createtable (L, 0, 42);
-   ATTRIBUTE_TYPE_ENTRY(BBox);
-   ATTRIBUTE_TYPE_ENTRY(BackgroundColor);
-   ATTRIBUTE_TYPE_ENTRY(BorderColor);
-   ATTRIBUTE_TYPE_ENTRY(BorderThickness);
-   ATTRIBUTE_TYPE_ENTRY(Color);
-   ATTRIBUTE_TYPE_ENTRY(ColumnGap);
-   ATTRIBUTE_TYPE_ENTRY(ColumnWidths);
-   ATTRIBUTE_TYPE_ENTRY(Desc);
-   ATTRIBUTE_TYPE_ENTRY(Role);
-   ATTRIBUTE_TYPE_ENTRY(TextDecorationColor);
-   ATTRIBUTE_TYPE_ENTRY(TextDecorationThickness);
-   ATTRIBUTE_TYPE_ENTRY(BaselineShift);
-   ATTRIBUTE_TYPE_ENTRY(BlockAlign);
-   ATTRIBUTE_TYPE_ENTRY(BorderStyle);
-   ATTRIBUTE_TYPE_ENTRY(ColSpan);
-   ATTRIBUTE_TYPE_ENTRY(ColumnCount);
-   ATTRIBUTE_TYPE_ENTRY(EndIndent);
-   ATTRIBUTE_TYPE_ENTRY(GlyphOrientationVertical);
-   ATTRIBUTE_TYPE_ENTRY(Headers);
-   ATTRIBUTE_TYPE_ENTRY(Height);
-   ATTRIBUTE_TYPE_ENTRY(InlineAlign);
-   ATTRIBUTE_TYPE_ENTRY(LineHeight);
-   ATTRIBUTE_TYPE_ENTRY(ListNumbering);
-   ATTRIBUTE_TYPE_ENTRY(Padding);
-   ATTRIBUTE_TYPE_ENTRY(Placement);
-   ATTRIBUTE_TYPE_ENTRY(RowSpan);
-   ATTRIBUTE_TYPE_ENTRY(RubyAlign);
-   ATTRIBUTE_TYPE_ENTRY(RubyPosition);
-   ATTRIBUTE_TYPE_ENTRY(Scope);
-   ATTRIBUTE_TYPE_ENTRY(SpaceAfter);
-   ATTRIBUTE_TYPE_ENTRY(SpaceBefore);
-   ATTRIBUTE_TYPE_ENTRY(StartIndent);
-   ATTRIBUTE_TYPE_ENTRY(Summary);
-   ATTRIBUTE_TYPE_ENTRY(TBorderStyle);
-   ATTRIBUTE_TYPE_ENTRY(TPadding);
-   ATTRIBUTE_TYPE_ENTRY(TextAlign);
-   ATTRIBUTE_TYPE_ENTRY(TextDecorationType);
-   ATTRIBUTE_TYPE_ENTRY(TextIndent);
-   ATTRIBUTE_TYPE_ENTRY(Width);
-   ATTRIBUTE_TYPE_ENTRY(WritingMode);
-   ATTRIBUTE_TYPE_ENTRY(Unknown);
-   ATTRIBUTE_TYPE_ENTRY(checked);
-   return 1;
-}
-
-static int l_Object_Type(lua_State * L) {
-   lua_createtable(L,0,16);/*nr of ObjType values*/ ;
-   OBJECT_TYPE(objBool);
-   OBJECT_TYPE(objInt);
-   OBJECT_TYPE(objReal);
-   OBJECT_TYPE(objString);
-   OBJECT_TYPE(objName);
-   OBJECT_TYPE(objNull);
-   OBJECT_TYPE(objArray);
-   OBJECT_TYPE(objDict);
-   OBJECT_TYPE(objStream);
-   OBJECT_TYPE(objRef);
-   OBJECT_TYPE(objCmd);
-   OBJECT_TYPE(objError);
-   OBJECT_TYPE(objEOF);
-   OBJECT_TYPE(objNone);
-   OBJECT_TYPE(objInt64);
-   OBJECT_TYPE(objDead);
-   return 1;
-}
-
-
-static int l_StructElement_Type(lua_State * L) {
-   lua_createtable (L, 0, 50);
-   STRUCTELEMENT_TYPE_ENTRY(Document);
-   STRUCTELEMENT_TYPE_ENTRY(Part);
-   STRUCTELEMENT_TYPE_ENTRY(Art);
-   STRUCTELEMENT_TYPE_ENTRY(Sect);
-   STRUCTELEMENT_TYPE_ENTRY(Div);
-   STRUCTELEMENT_TYPE_ENTRY(BlockQuote);
-   STRUCTELEMENT_TYPE_ENTRY(Caption);
-   STRUCTELEMENT_TYPE_ENTRY(NonStruct);
-   STRUCTELEMENT_TYPE_ENTRY(Index);
-   STRUCTELEMENT_TYPE_ENTRY(Private);
-   STRUCTELEMENT_TYPE_ENTRY(Span);
-   STRUCTELEMENT_TYPE_ENTRY(Quote);
-   STRUCTELEMENT_TYPE_ENTRY(Note);
-   STRUCTELEMENT_TYPE_ENTRY(Reference);
-   STRUCTELEMENT_TYPE_ENTRY(BibEntry);
-   STRUCTELEMENT_TYPE_ENTRY(Code);
-   STRUCTELEMENT_TYPE_ENTRY(Link);
-   STRUCTELEMENT_TYPE_ENTRY(Annot);
-   STRUCTELEMENT_TYPE_ENTRY(Ruby);
-   STRUCTELEMENT_TYPE_ENTRY(RB);
-   STRUCTELEMENT_TYPE_ENTRY(RT);
-   STRUCTELEMENT_TYPE_ENTRY(RP);
-   STRUCTELEMENT_TYPE_ENTRY(Warichu);
-   STRUCTELEMENT_TYPE_ENTRY(WT);
-   STRUCTELEMENT_TYPE_ENTRY(WP);
-   STRUCTELEMENT_TYPE_ENTRY(P);
-   STRUCTELEMENT_TYPE_ENTRY(H);
-   STRUCTELEMENT_TYPE_ENTRY(H1);
-   STRUCTELEMENT_TYPE_ENTRY(H2);
-   STRUCTELEMENT_TYPE_ENTRY(H3);
-   STRUCTELEMENT_TYPE_ENTRY(H4);
-   STRUCTELEMENT_TYPE_ENTRY(H5);
-   STRUCTELEMENT_TYPE_ENTRY(H6);
-   STRUCTELEMENT_TYPE_ENTRY(L);
-   STRUCTELEMENT_TYPE_ENTRY(LI);
-   STRUCTELEMENT_TYPE_ENTRY(Lbl);
-   STRUCTELEMENT_TYPE_ENTRY(LBody);
-   STRUCTELEMENT_TYPE_ENTRY(Table);
-   STRUCTELEMENT_TYPE_ENTRY(TR);
-   STRUCTELEMENT_TYPE_ENTRY(TH);
-   STRUCTELEMENT_TYPE_ENTRY(TD);
-   STRUCTELEMENT_TYPE_ENTRY(THead);
-   STRUCTELEMENT_TYPE_ENTRY(TFoot);
-   STRUCTELEMENT_TYPE_ENTRY(TBody);
-   STRUCTELEMENT_TYPE_ENTRY(Figure);
-   STRUCTELEMENT_TYPE_ENTRY(Formula);
-   STRUCTELEMENT_TYPE_ENTRY(Form);
-   STRUCTELEMENT_TYPE_ENTRY(TOC);
-   STRUCTELEMENT_TYPE_ENTRY(TOCI);
-   lua_pushstring(L, "Unknown");
-   lua_pushinteger(L, 0);
-   lua_settable(L,-3);
-   return 1;
-}
-
-static int l_AttributeOwner_Type(lua_State * L) {
-  lua_createtable (L, 0, 12);
-  lua_pushstring(L, "XML-1.00");       lua_pushinteger(L, Attribute::XML_1_00);      lua_settable(L,-3);
-  lua_pushstring(L, "HTML-3.20");      lua_pushinteger(L, Attribute::HTML_3_20);     lua_settable(L,-3);
-  lua_pushstring(L, "HTML-4.01");      lua_pushinteger(L, Attribute::HTML_4_01);     lua_settable(L,-3);
-  lua_pushstring(L, "OEB-1.00");       lua_pushinteger(L, Attribute::OEB_1_00);      lua_settable(L,-3);
-  lua_pushstring(L, "RTF-1.05");       lua_pushinteger(L, Attribute::RTF_1_05);      lua_settable(L,-3);
-  lua_pushstring(L, "CSS-1.00");       lua_pushinteger(L, Attribute::CSS_1_00);      lua_settable(L,-3);
-  lua_pushstring(L, "CSS-2.00");       lua_pushinteger(L, Attribute::CSS_2_00);      lua_settable(L,-3);
-  lua_pushstring(L, "Layout");	       lua_pushinteger(L, Attribute::Layout);        lua_settable(L,-3);
-  lua_pushstring(L, "PrintField");     lua_pushinteger(L, Attribute::PrintField);    lua_settable(L,-3);
-  lua_pushstring(L, "Table");	       lua_pushinteger(L, Attribute::Table);         lua_settable(L,-3);
-  lua_pushstring(L, "List");	       lua_pushinteger(L, Attribute::List);          lua_settable(L,-3);
-  lua_pushstring(L, "UserProperties"); lua_pushinteger(L, Attribute::UserProperties);lua_settable(L,-3);
-  return 1;
-}
-
-
-static int l_new_Dict(lua_State * L)
-{
-    udstruct *uxref, *uout;
-    uxref = (udstruct *) luaL_checkudata(L, 1, M_XRef);
-    if (uxref->pd != NULL && uxref->pd->pc != uxref->pc)
-        pdfdoc_changed_error(L);
-    uout = new_Dict_userdata(L);
-    uout->d = new Dict((XRef *) uxref->d);      // automatic init to length 0
-    uout->atype = ALLOC_LEPDF;
-    uout->pc = uxref->pc;
-    uout->pd = uxref->pd;
-    return 1;
-}
-
-static int l_new_Object(lua_State * L)
-{
-    udstruct *uout;
-    int n = lua_gettop(L); // number of arguments
-    uout = new_Object_userdata(L);
-    switch(n) {
-    case 0:
-      uout->d = new Object();     // automatic init to type "none"
-      uout->atype = ALLOC_LEPDF;
-      uout->pc = 0;
-      uout->pd = NULL;            // not connected to any PDFDoc
-      break;
-    case 1:
-      if (lua_isboolean (L,1)) {
-	uout->d = new Object(lua_toboolean(L, 1)? gTrue : gFalse);
-	uout->atype = ALLOC_LEPDF;
-	uout->pc = 0;
-	uout->pd = NULL;
-      } else if (lua_isnumber (L,1)) {
-	double d = lua_tonumber(L,1);
-	// Missed :Object(long long int64gA)
-	if (d==((int)d)) {
-	  uout->d = new Object((int)d);
-	} else {
-	  uout->d = new Object(d);
-	}
-	uout->atype = ALLOC_LEPDF;
-	uout->pc = 0;
-	uout->pd = NULL;
-      } else if (lua_isstring (L,1)){
-	GooString *gs;
-	const char *s;
-	size_t len;
-	s = luaL_checklstring(L, 2, &len);
-	gs = new GooString(s, len);
-	uout->d = new Object(gs);
-	uout->atype = ALLOC_LEPDF;
-	uout->pc = 0;
-	uout->pd = NULL;
-      } else if (luaL_testudata(L,1,M_Array)){
-	udstruct *u;
-	Array *a;
-	u = (udstruct *) luaL_checkudata(L, 1, M_Array);
-	a = (Array *)u->d;
-	uout->d = new Object(a);
-	uout->atype = ALLOC_LEPDF;
-	uout->pc = 0;
-	uout->pd = NULL;
-      } else if (luaL_testudata(L,1,M_Dict)){
-	udstruct *u;
-	Dict *d;
-	u = (udstruct *) luaL_checkudata(L, 1, M_Dict);
-	d = (Dict *)u->d;
-	uout->d = new Object(d);
-	uout->atype = ALLOC_LEPDF;
-	uout->pc = 0;
-	uout->pd = NULL;
-      } else if (luaL_testudata(L,1,M_Stream)){
-	udstruct *u;
-	Stream *s;
-	u = (udstruct *) luaL_checkudata(L, 1, M_Stream);
-	s = (Stream *)u->d;
-	*((Object *) uout->d) = Object(s);
-      } else
-	luaL_error(L, "Invalid/unsupported value for Object constructor");
-      break;
-    case 2:
-      if (lua_isnumber (L,1) && lua_isnumber (L,2)) {
-	double numA = lua_tonumber(L,1);
-	double genA = lua_tonumber(L,2);
-	if ( ((numA)==(int)(numA)) && ((genA)==(int)(genA)) ){
-	  uout->d = new Object((int)(numA), (int)(genA));
-	  uout->atype = ALLOC_LEPDF;
-	  uout->pc = 0;
-	  uout->pd = NULL;
-	}
-      } else if (lua_isnumber (L,1) && (lua_isstring(L,2)|| lua_isnoneornil(L,2))) {
-	double d_typeA = lua_tonumber(L,1);
-	int typeA = (int)(d_typeA);
-	if (d_typeA==typeA){
-	  switch((int)(typeA)) {
-	  case     objBool:
-	  case     objInt:
-	  case     objReal:
-	  case     objString:
-	  case     objName:
-	  case     objNull:
-	  case     objArray:
-	  case     objDict:
-	  case     objStream:
-	  case     objRef:
-	  case     objCmd:
-	  case     objError:
-	  case     objEOF:
-	  case     objNone:
-	  case     objInt64:
-	  case     objDead:
-	    if (lua_isstring(L,2))
-	      uout->d = new Object((ObjType)(typeA), luaL_checkstring(L, 2));
-	    else
-	      uout->d = new Object((ObjType)(typeA));
-	    uout->atype = ALLOC_LEPDF;
-	    uout->pc = 0;
-	    uout->pd = NULL;
-
-	    break;
-	  default:
-	    luaL_error(L, "Invalid values for Object constructor");
-	    break;
-	  }//switch((int)(d))
-	} else //  (d_typeA)!=(typeA)
-	  luaL_error(L, "Invalid/unsupported values for Object constructor");
-      } // if (lua_isnumber (L,1) && (lua_isstring(L,2)|| lua_isnoneornil(L,2)))
-      break;
-    default:
-      luaL_error(L, "Invalid specification for Object constructor");
-    }
-    lua_settop(L,1);
-    return 1;
-}
-
-// static int l_new_Object(lua_State * L)
-// {
-//     udstruct *uout;
-//     uout = new_Object_userdata(L);
-//     uout->d = new Object();     // automatic init to type "none"
-//     uout->atype = ALLOC_LEPDF;
-//     uout->pc = 0;
-//     uout->pd = NULL;            // not connected to any PDFDoc
-//     return 1;
-// }
-
-
-// PDFRectangle see Page.h
-
-static int l_new_PDFRectangle(lua_State * L)
-{
-    udstruct *uout;
-    uout = new_PDFRectangle_userdata(L);
-    uout->d = new PDFRectangle();       // automatic init to [0, 0, 0, 0]
-    uout->atype = ALLOC_LEPDF;
-    uout->pc = 0;
-    uout->pd = NULL;
-    return 1;
-}
-
-static const struct luaL_Reg epdflib_f[] = {
-    {"open", l_open_PDFDoc},
-    {"openMemStream", l_open_MemStreamPDFDoc},
-    {"Array", l_new_Array},
-    {"Attribute",          l_new_Attribute},
-    {"StructElement_Type", l_StructElement_Type},
-    {"Attribute_Type",     l_Attribute_Type},
-    {"AttributeOwner_Type",l_AttributeOwner_Type},
-    {"Dict", l_new_Dict},
-    {"Object", l_new_Object},
-    {"Object_Type", l_Object_Type},
-    {"PDFRectangle", l_new_PDFRectangle},
-    {NULL, NULL}                // sentinel
-};
-
-//**********************************************************************
-
-#define m_poppler_get_poppler(in, out, function)               \
-static int m_##in##_##function(lua_State * L)                  \
-{                                                              \
-    out *o;                                                    \
-    udstruct *uin, *uout;                                      \
-    uin = (udstruct *) luaL_checkudata(L, 1, M_##in);          \
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)             \
-        pdfdoc_changed_error(L);                               \
-    o = ((in *) uin->d)->function();                           \
-    if (o != NULL) {                                           \
-        uout = new_##out##_userdata(L);                        \
-        uout->d = o;                                           \
-        uout->pc = uin->pc;                                    \
-        uout->pd = uin->pd;                                    \
-    } else                                                     \
-        lua_pushnil(L);                                        \
-    return 1;                                                  \
-}
-
-#define m_poppler_get_BOOL(in, function)                       \
-static int m_##in##_##function(lua_State * L)                  \
-{                                                              \
-    udstruct *uin;                                             \
-    uin = (udstruct *) luaL_checkudata(L, 1, M_##in);          \
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)             \
-        pdfdoc_changed_error(L);                               \
-    if (((in *) uin->d)->function())                           \
-        lua_pushboolean(L, 1);                                 \
-    else                                                       \
-        lua_pushboolean(L, 0);                                 \
-    return 1;                                                  \
-}
-
-#define m_poppler_get_INT(in, function)                        \
-static int m_##in##_##function(lua_State * L)                  \
-{                                                              \
-    int i;                                                     \
-    udstruct *uin;                                             \
-    uin = (udstruct *) luaL_checkudata(L, 1, M_##in);          \
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)             \
-        pdfdoc_changed_error(L);                               \
-    i = (int) ((in *) uin->d)->function();                     \
-    lua_pushinteger(L, i);                                     \
-    return 1;                                                  \
-}
-
-
-#define m_poppler_get_GUINT(in, function)                      \
-static int m_##in##_##function(lua_State * L)                  \
-{                                                              \
-    unsigned int i;                                            \
-    udstruct *uin;                                             \
-    uin = (udstruct *) luaL_checkudata(L, 1, M_##in);          \
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)             \
-        pdfdoc_changed_error(L);                               \
-    i = (unsigned int) ((in *) uin->d)->function();            \
-    lua_pushinteger(L, i);                                     \
-    return 1;                                                  \
-}
-
-#define m_poppler_get_UINT(in, function)                       \
-m_poppler_get_GUINT(in, function)
-
-
-
-#define m_poppler_get_DOUBLE(in, function)                     \
-static int m_##in##_##function(lua_State * L)                  \
-{                                                              \
-    double d;                                                  \
-    udstruct *uin;                                             \
-    uin = (udstruct *) luaL_checkudata(L, 1, M_##in);          \
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)             \
-        pdfdoc_changed_error(L);                               \
-    d = (double) ((in *) uin->d)->function();                  \
-    lua_pushnumber(L, d); /* float */                          \
-    return 1;                                                  \
-}
-
-#define m_poppler_get_GOOSTRING(in, function)                  \
-static int m_##in##_##function(lua_State * L)                  \
-{                                                              \
-    GooString *gs;                                             \
-    udstruct *uin;                                             \
-    uin = (udstruct *) luaL_checkudata(L, 1, M_##in);          \
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)             \
-        pdfdoc_changed_error(L);                               \
-    gs = (GooString *)((in *) uin->d)->function();             \
-    if (gs != NULL)                                            \
-        lua_pushlstring(L, gs->getCString(), gs->getLength()); \
-    else                                                       \
-        lua_pushnil(L);                                        \
-    return 1;                                                  \
-}
-
-#define m_poppler_get_OBJECT(in, function)                     \
-static int m_##in##_##function(lua_State * L)                  \
-{                                                              \
-    udstruct *uin, *uout;                                      \
-    uin = (udstruct *) luaL_checkudata(L, 1, M_##in);          \
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)             \
-        pdfdoc_changed_error(L);                               \
-    uout = new_Object_userdata(L);                             \
-    uout->d = new Object();                                    \
-    *((Object *)uout->d) = ((in *) uin->d)->function();                  \
-    uout->atype = ALLOC_LEPDF;                                 \
-    uout->pc = uin->pc;                                        \
-    uout->pd = uin->pd;                                        \
-    return 1;                                                  \
-}
-
-#define m_poppler_do(in, function)                             \
-static int m_##in##_##function(lua_State * L)                  \
-{                                                              \
-    udstruct *uin;                                             \
-    uin = (udstruct *) luaL_checkudata(L, 1, M_##in);          \
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)             \
-        pdfdoc_changed_error(L);                               \
-    ((in *) uin->d)->function();                               \
-    return 0;                                                  \
-}
-
-#define m_poppler__tostring(type)                              \
-static int m_##type##__tostring(lua_State * L)                 \
-{                                                              \
-    udstruct *uin;                                             \
-    uin = (udstruct *) luaL_checkudata(L, 1, M_##type);        \
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)             \
-        pdfdoc_changed_error(L);                               \
-    lua_pushfstring(L, "%s: %p", #type, (type *) uin->d);      \
-    return 1;                                                  \
-}
-
-#define m_poppler_check_string(in, function)                   \
-static int m_##in##_##function(lua_State * L)                  \
-{                                                              \
-    const char *s;                                             \
-    udstruct *uin;                                             \
-    uin = (udstruct *) luaL_checkudata(L, 1, M_##in);          \
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)             \
-        pdfdoc_changed_error(L);                               \
-    s = luaL_checkstring(L, 2);                                \
-    if (((in *) uin->d)->function(s))                          \
-        lua_pushboolean(L, 1);                                 \
-    else                                                       \
-        lua_pushboolean(L, 0);                                 \
-    return 1;                                                  \
-}
-
-//**********************************************************************
-// Annot
-
-m_poppler_get_BOOL(Annot, isOk);
-
-static int m_Annot_match(lua_State * L)
-{
-    udstruct *uin, *uref;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_Annot);
-    uref = (udstruct *) luaL_checkudata(L, 2, M_Ref);
-    if (uin->pd != NULL && uref->pd != NULL && uin->pd != uref->pd)
-        pdfdoc_differs_error(L);
-    if ((uin->pd != NULL && uin->pd->pc != uin->pc)
-        || (uref->pd != NULL && uref->pd->pc != uref->pc))
-        pdfdoc_changed_error(L);
-    lua_pushboolean(L, ((Annot *) uin->d)->match((Ref *) uref->d));
-    return 1;
-}
-
-m_poppler__tostring(Annot);
-
-static int m_Annot__gc(lua_State * L)
-{
-    udstruct *uin;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_Annot);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-#ifdef DEBUG
-    printf("\n===== Annot GC ===== uin=<%p>\n", uin);
-#endif
-    if (uin->atype == ALLOC_LEPDF)
-#if 1                           /* def HAVE_ANNOTDECREFCNT */
-        ((Annot *) uin->d)->decRefCnt();
-#else
-        delete(Annot *) uin->d;
-#endif
-    return 0;
-}
-
-static const struct luaL_Reg Annot_m[] = {
-    {"isOk", m_Annot_isOk},
-    {"match", m_Annot_match},
-    {"__tostring", m_Annot__tostring},
-    {"__gc", m_Annot__gc},
-    {NULL, NULL}                // sentinel
-};
-
-//**********************************************************************
-// Annots
-
-m_poppler_get_INT(Annots, getNumAnnots);
-
-static int m_Annots_getAnnot(lua_State * L)
-{
-    int i, annots;
-    udstruct *uin, *uout;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_Annots);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-    i = luaL_checkint(L, 2);
-    annots = ((Annots *) uin->d)->getNumAnnots();
-    if (i > 0 && i <= annots) {
-        uout = new_Annot_userdata(L);
-        uout->d = ((Annots *) uin->d)->getAnnot(i);
-        uout->pc = uin->pc;
-        uout->pd = uin->pd;
-    } else
-        lua_pushnil(L);
-    return 1;
-}
-
-m_poppler__tostring(Annots);
-
-static const struct luaL_Reg Annots_m[] = {
-    {"getNumAnnots", m_Annots_getNumAnnots},
-    {"getAnnot", m_Annots_getAnnot},
-    {"__tostring", m_Annots__tostring},
-    {NULL, NULL}                // sentinel
-};
-
-//**********************************************************************
-// Array
-// Now private
-// static int m_Array_incRef(lua_State * L)
-// {
-//     udstruct *uin;
-//     uin = (udstruct *) luaL_checkudata(L, 1, M_Array);
-//     if (uin->pd != NULL && uin->pd->pc != uin->pc)
-//         pdfdoc_changed_error(L);
-//     lua_pushinteger(L, 1);
-//     return 1;
-// }
-// Now private
-// static int m_Array_decRef(lua_State * L)
-// {
-//     int i;
-//     udstruct *uin;
-//     uin = (udstruct *) luaL_checkudata(L, 1, M_Array);
-//     if (uin->pd != NULL && uin->pd->pc != uin->pc)
-//         pdfdoc_changed_error(L);
-//     lua_pushinteger(L, 1);
-//     return 1;
-// }
-
-m_poppler_get_INT(Array, getLength);
-
-static int m_Array_add(lua_State * L)
-{
-    udstruct *uin, *uobj;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_Array);
-    uobj = (udstruct *) luaL_checkudata(L, 2, M_Object);
-    if (uin->pd != NULL && uobj->pd != NULL && uin->pd != uobj->pd)
-        pdfdoc_differs_error(L);
-    if ((uin->pd != NULL && uin->pd->pc != uin->pc)
-        || (uobj->pd != NULL && uobj->pd->pc != uobj->pc))
-        pdfdoc_changed_error(L);
-    ((Array *) uin->d)->add(std::move(*((Object *) uobj->d)));
-    return 0;
-}
-
-static int m_Array_get(lua_State * L)
-{
-    int i, len;
-    udstruct *uin, *uout;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_Array);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-    i = luaL_checkint(L, 2);
-    len = ((Array *) uin->d)->getLength();
-    if (i > 0 && i <= len) {
-        uout = new_Object_userdata(L);
-        uout->d = new Object();
-        *((Object *) uout->d) = ((Array *) uin->d)->get(i - 1);
-        uout->atype = ALLOC_LEPDF;
-        uout->pc = uin->pc;
-        uout->pd = uin->pd;
-    } else
-        lua_pushnil(L);
-    return 1;
-}
-
-static int m_Array_getNF(lua_State * L)
-{
-    int i, len;
-    udstruct *uin, *uout;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_Array);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-    i = luaL_checkint(L, 2);
-    len = ((Array *) uin->d)->getLength();
-    if (i > 0 && i <= len) {
-        uout = new_Object_userdata(L);
-        uout->d = new Object();
-        *((Object *) uout->d) = ((Array *) uin->d)->getNF(i - 1);
-        uout->atype = ALLOC_LEPDF;
-        uout->pc = uin->pc;
-        uout->pd = uin->pd;
-    } else
-        lua_pushnil(L);
-    return 1;
-}
-
-static int m_Array_getString(lua_State * L)
-{
-    GooString *gs;
-    int i, len;
-    udstruct *uin;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_Array);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-    i = luaL_checkint(L, 2);
-    len = ((Array *) uin->d)->getLength();
-    if (i > 0 && i <= len) {
-        gs = new GooString();
-        if (((Array *) uin->d)->getString(i - 1, gs))
-            lua_pushlstring(L, gs->getCString(), gs->getLength());
-        else
-            lua_pushnil(L);
-        delete gs;
-    } else
-        lua_pushnil(L);
-    return 1;
-}
-
-m_poppler__tostring(Array);
-
-static const struct luaL_Reg Array_m[] = {
-    // {"incRef", m_Array_incRef},// Now private
-    // {"decRef", m_Array_decRef},// Now private
-    {"getLength", m_Array_getLength},
-    {"add", m_Array_add},
-    {"get", m_Array_get},
-    {"getNF", m_Array_getNF},
-    {"getString", m_Array_getString},
-    {"__tostring", m_Array__tostring},
-    {NULL, NULL}                // sentinel
-};
-
-//**********************************************************************
-// Catalog
-
-m_poppler_get_BOOL(Catalog, isOk);
-m_poppler_get_INT(Catalog, getNumPages);
-
-static int m_Catalog_getPage(lua_State * L)
-{
-    int i, pages;
-    udstruct *uin, *uout;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_Catalog);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-    i = luaL_checkint(L, 2);
-    pages = ((Catalog *) uin->d)->getNumPages();
-    if (i > 0 && i <= pages) {
-        uout = new_Page_userdata(L);
-        uout->d = ((Catalog *) uin->d)->getPage(i);
-        uout->pc = uin->pc;
-        uout->pd = uin->pd;
-    } else
-        lua_pushnil(L);
-    return 1;
-}
-
-static int m_Catalog_getPageRef(lua_State * L)
-{
-    int i, pages;
-    udstruct *uin, *uout;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_Catalog);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-    i = luaL_checkint(L, 2);
-    pages = ((Catalog *) uin->d)->getNumPages();
-    if (i > 0 && i <= pages) {
-        uout = new_Ref_userdata(L);
-        uout->d = (Ref *) gmalloc(sizeof(Ref));
-        ((Ref *) uout->d)->num = ((Catalog *) uin->d)->getPageRef(i)->num;
-        ((Ref *) uout->d)->gen = ((Catalog *) uin->d)->getPageRef(i)->gen;
-        uout->atype = ALLOC_LEPDF;
-        uout->pc = uin->pc;
-        uout->pd = uin->pd;
-    } else
-        lua_pushnil(L);
-    return 1;
-}
-
-m_poppler_get_GOOSTRING(Catalog, getBaseURI);
-m_poppler_get_GOOSTRING(Catalog, readMetadata);
-m_poppler_get_poppler(Catalog, StructTreeRoot, getStructTreeRoot);
-
-static int m_Catalog_findPage(lua_State * L)
-{
-    int num, gen, i;
-    udstruct *uin;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_Catalog);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-    num = luaL_checkint(L, 2);
-    gen = luaL_checkint(L, 3);
-    i = ((Catalog *) uin->d)->findPage(num, gen);
-    if (i > 0)
-        lua_pushinteger(L, i);
-    else
-        lua_pushnil(L);
-    return 1;
-}
-
-static int m_Catalog_findDest(lua_State * L)
-{
-    GooString *name;
-    LinkDest *dest;
-    const char *s;
-    size_t len;
-    udstruct *uin, *uout;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_Catalog);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-    s = luaL_checklstring(L, 2, &len);
-    name = new GooString(s, len);
-    dest = ((Catalog *) uin->d)->findDest(name);
-    if (dest != NULL) {
-        uout = new_LinkDest_userdata(L);
-        uout->d = dest;
-        uout->pc = uin->pc;
-        uout->pd = uin->pd;
-    } else
-        lua_pushnil(L);
-    delete name;
-    return 1;
-}
-
-m_poppler_get_poppler(Catalog, Object, getDests);
-m_poppler_get_INT(Catalog, numEmbeddedFiles);
-
-static int m_Catalog_embeddedFile(lua_State * L)
-{
-    int i, len;
-    udstruct *uin, *uout;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_Catalog);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-    i = luaL_checkint(L, 2);
-    len = ((Catalog *) uin->d)->numEmbeddedFiles();
-    if (i > 0 && i <= len) {
-        uout = new_FileSpec_userdata(L);
-        uout->d = ((Catalog *) uin->d)->embeddedFile(i - 1);
-        uout->pc = uin->pc;
-        uout->pd = uin->pd;
-    } else
-        lua_pushnil(L);
-    return 1;
-}
-
-m_poppler_get_INT(Catalog, numJS);
-
-static int m_Catalog_getJS(lua_State * L)
-{
-    GooString *gs;
-    int i, len;
-    udstruct *uin;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_Catalog);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-    i = luaL_checkint(L, 2);
-    len = ((Catalog *) uin->d)->numJS();
-    if (i > 0 && i <= len) {
-        gs = ((Catalog *) uin->d)->getJS(i - 1);
-        if (gs != NULL)
-            lua_pushlstring(L, gs->getCString(), gs->getLength());
-        else
-            lua_pushnil(L);
-        delete gs;
-    } else
-        lua_pushnil(L);
-    return 1;
-}
-
-m_poppler_get_poppler(Catalog, Object, getOutline);
-m_poppler_get_poppler(Catalog, Object, getAcroForm);
-
-m_poppler__tostring(Catalog);
-
-static const struct luaL_Reg Catalog_m[] = {
-    {"isOk", m_Catalog_isOk},
-    {"getNumPages", m_Catalog_getNumPages},
-    {"getPage", m_Catalog_getPage},
-    {"getPageRef", m_Catalog_getPageRef},
-    {"getBaseURI", m_Catalog_getBaseURI},
-    {"readMetadata", m_Catalog_readMetadata},
-    {"getStructTreeRoot", m_Catalog_getStructTreeRoot},
-    {"findPage", m_Catalog_findPage},
-    {"findDest", m_Catalog_findDest},
-    {"getDests", m_Catalog_getDests},
-    {"numEmbeddedFiles", m_Catalog_numEmbeddedFiles},
-    {"embeddedFile", m_Catalog_embeddedFile},
-    {"numJS", m_Catalog_numJS},
-    {"getJS", m_Catalog_getJS},
-    {"getOutline", m_Catalog_getOutline},
-    {"getAcroForm", m_Catalog_getAcroForm},
-    {"__tostring", m_Catalog__tostring},
-    {NULL, NULL}                // sentinel
-};
-
-//**********************************************************************
-// Dict
-// Now private
-// static int m_Dict_incRef(lua_State * L)
-// {
-//     udstruct *uin;
-//     uin = (udstruct *) luaL_checkudata(L, 1, M_Dict);
-//     if (uin->pd != NULL && uin->pd->pc != uin->pc)
-//         pdfdoc_changed_error(L);
-//     lua_pushinteger(L, 1);
-//     return 1;
-// }
-// Now private
-// static int m_Dict_decRef(lua_State * L)
-// {
-//     udstruct *uin;
-//     uin = (udstruct *) luaL_checkudata(L, 1, M_Dict);
-//     if (uin->pd != NULL && uin->pd->pc != uin->pc)
-//         pdfdoc_changed_error(L);
-//     lua_pushinteger(L, 1);
-//     return 1;
-// }
-
-m_poppler_get_INT(Dict, getLength);
-
-static int m_Dict_add(lua_State * L)
-{
-    char *s;
-    udstruct *uin, *uobj;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_Dict);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-    s = copyString(luaL_checkstring(L, 2));
-    uobj = (udstruct *) luaL_checkudata(L, 3, M_Object);
-    ((Dict *) uin->d)->add(s, std::move(*((Object *) uobj->d)));
-    return 0;
-}
-
-static int m_Dict_set(lua_State * L)
-{
-    const char *s;
-    udstruct *uin, *uobj;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_Dict);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-    s = luaL_checkstring(L, 2);
-    uobj = (udstruct *) luaL_checkudata(L, 3, M_Object);
-    ((Dict *) uin->d)->set(s, std::move(*((Object *) uobj->d)));
-    return 0;
-}
-
-static int m_Dict_remove(lua_State * L)
-{
-    const char *s;
-    udstruct *uin;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_Dict);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-    s = luaL_checkstring(L, 2);
-    ((Dict *) uin->d)->remove(s);
-    return 0;
-}
-
-m_poppler_check_string(Dict, is);
-
-static int m_Dict_lookup(lua_State * L)
-{
-    const char *s;
-    udstruct *uin, *uout;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_Dict);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-    s = luaL_checkstring(L, 2);
-    uout = new_Object_userdata(L);
-    uout->d = new Object();
-    *((Object *) uout->d) = ((Dict *) uin->d)->lookup(s);
-    uout->atype = ALLOC_LEPDF;
-    uout->pc = uin->pc;
-    uout->pd = uin->pd;
-    return 1;
-}
-
-static int m_Dict_lookupNF(lua_State * L)
-{
-    const char *s;
-    udstruct *uin, *uout;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_Dict);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-    s = luaL_checkstring(L, 2);
-    uout = new_Object_userdata(L);
-    uout->d = new Object();
-    *((Object *) uout->d) = ((Dict *) uin->d)->lookupNF(s);
-    uout->atype = ALLOC_LEPDF;
-    uout->pc = uin->pc;
-    uout->pd = uin->pd;
-    return 1;
-}
-
-static int m_Dict_lookupInt(lua_State * L)
-{
-    const char *s1, *s2;
-    int i;
-    udstruct *uin;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_Dict);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-    s1 = luaL_checkstring(L, 2);
-    s2 = luaL_checkstring(L, 3);
-    if (((Dict *) uin->d)->lookupInt(s1, s2, &i))
-        lua_pushinteger(L, i);
-    else
-        lua_pushnil(L);
-    return 1;
-}
-
-static int m_Dict_getKey(lua_State * L)
-{
-    int i, len;
-    udstruct *uin;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_Dict);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-    i = luaL_checkint(L, 2);
-    len = ((Dict *) uin->d)->getLength();
-    if (i > 0 && i <= len)
-        lua_pushstring(L, ((Dict *) uin->d)->getKey(i - 1));
-    else
-        lua_pushnil(L);
-    return 1;
-}
-
-static int m_Dict_getVal(lua_State * L)
-{
-    int i, len;
-    udstruct *uin, *uout;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_Dict);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-    i = luaL_checkint(L, 2);
-    len = ((Dict *) uin->d)->getLength();
-    if (i > 0 && i <= len) {
-        uout = new_Object_userdata(L);
-        uout->d = new Object();
-        *((Object *) uout->d) = ((Dict *) uin->d)->getVal(i - 1);
-        uout->atype = ALLOC_LEPDF;
-        uout->pc = uin->pc;
-        uout->pd = uin->pd;
-    } else
-        lua_pushnil(L);
-    return 1;
-}
-
-static int m_Dict_getValNF(lua_State * L)
-{
-    int i, len;
-    udstruct *uin, *uout;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_Dict);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-    i = luaL_checkint(L, 2);
-    len = ((Dict *) uin->d)->getLength();
-    if (i > 0 && i <= len) {
-        uout = new_Object_userdata(L);
-        uout->d = new Object();
-        *((Object *) uout->d) = ((Dict *) uin->d)->getValNF(i - 1);
-        uout->atype = ALLOC_LEPDF;
-        uout->pc = uin->pc;
-        uout->pd = uin->pd;
-    } else
-        lua_pushnil(L);
-    return 1;
-}
-
-m_poppler_check_string(Dict, hasKey);
-
-m_poppler__tostring(Dict);
-
-static const struct luaL_Reg Dict_m[] = {
-    // {"incRef", m_Dict_incRef},// Now private
-    // {"decRef", m_Dict_decRef},// Now private
-    {"getLength", m_Dict_getLength},
-    {"add", m_Dict_add},
-    {"set", m_Dict_set},
-    {"remove", m_Dict_remove},
-    {"is", m_Dict_is},
-    {"lookup", m_Dict_lookup},
-    {"lookupNF", m_Dict_lookupNF},
-    {"lookupInt", m_Dict_lookupInt},
-    {"getKey", m_Dict_getKey},
-    {"getVal", m_Dict_getVal},
-    {"getValNF", m_Dict_getValNF},
-    {"hasKey", m_Dict_hasKey},
-    {"__tostring", m_Dict__tostring},
-    {NULL, NULL}                // sentinel
-};
-
-//**********************************************************************
-// EmbFile
-
-m_poppler_get_INT(EmbFile, size);
-m_poppler_get_GOOSTRING(EmbFile, modDate);
-m_poppler_get_GOOSTRING(EmbFile, createDate);
-m_poppler_get_GOOSTRING(EmbFile, checksum);
-m_poppler_get_GOOSTRING(EmbFile, mimeType);
-
-m_poppler_get_BOOL(EmbFile, isOk);
-
-static int m_EmbFile_save(lua_State * L)
-{
-    const char *s;
-    size_t len;
-    udstruct *uin;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_EmbFile);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-    s = luaL_checklstring(L, 2, &len);
-    if (((EmbFile *) uin->d)->save(s))
-        lua_pushboolean(L, 1);
-    else
-        lua_pushboolean(L, 0);
-    return 1;
-}
-
-m_poppler__tostring(EmbFile);
-
-static const struct luaL_Reg EmbFile_m[] = {
-    {"size", m_EmbFile_size},
-    {"modDate", m_EmbFile_modDate},
-    {"createDate", m_EmbFile_createDate},
-    {"checksum", m_EmbFile_checksum},
-    {"mimeType", m_EmbFile_mimeType},
-    {"isOk", m_EmbFile_isOk},
-    {"save", m_EmbFile_save},
-    {"__tostring", m_EmbFile__tostring},
-    {NULL, NULL}                // sentinel
-};
-
-//**********************************************************************
-// FileSpec
-
-m_poppler_get_BOOL(FileSpec, isOk);
-m_poppler_get_GOOSTRING(FileSpec, getFileName);
-m_poppler_get_GOOSTRING(FileSpec, getFileNameForPlatform);
-m_poppler_get_GOOSTRING(FileSpec, getDescription);
-
-static int m_FileSpec_getEmbeddedFile(lua_State * L)
-{
-    udstruct *uin, *uout;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_FileSpec);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-    uout = new_EmbFile_userdata(L);
-    uout->d = ((FileSpec *) uin->d)->getEmbeddedFile();
-    uout->pc = uin->pc;
-    uout->pd = uin->pd;
-    return 1;
-}
-
-m_poppler__tostring(FileSpec);
-
-static const struct luaL_Reg FileSpec_m[] = {
-    {"isOk", m_FileSpec_isOk},
-    {"getFileName", m_FileSpec_getFileName},
-    {"getFileNameForPlatform", m_FileSpec_getFileNameForPlatform},
-    {"getDescription", m_FileSpec_getDescription},
-    {"getEmbeddedFile", m_FileSpec_getEmbeddedFile},
-    {"__tostring", m_FileSpec__tostring},
-    {NULL, NULL}                // sentinel
-};
-
-//**********************************************************************
-// GooString
-
-static int m_GooString__tostring(lua_State * L)
-{
-    udstruct *uin;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_GooString);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-    lua_pushlstring(L, ((GooString *) uin->d)->getCString(),
-                    ((GooString *) uin->d)->getLength());
-    return 1;
-}
-
-static const struct luaL_Reg GooString_m[] = {
-    {"__tostring", m_GooString__tostring},
-    {NULL, NULL}                // sentinel
-};
-
-//**********************************************************************
-// LinkDest
-
-static const char *LinkDestKindNames[] =
-    { "XYZ", "Fit", "FitH", "FitV", "FitR", "FitB", "FitBH", "FitBV", NULL };
-
-m_poppler_get_BOOL(LinkDest, isOk);
-
-static int m_LinkDest_getKind(lua_State * L)
-{
-    int i;
-    udstruct *uin;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_LinkDest);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-    i = (int) ((LinkDest *) uin->d)->getKind();
-    lua_pushinteger(L, i);
-    return 1;
-}
-
-static int m_LinkDest_getKindName(lua_State * L)
-{
-    int i;
-    udstruct *uin;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_LinkDest);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-    i = (int) ((LinkDest *) uin->d)->getKind();
-    lua_pushstring(L, LinkDestKindNames[i]);
-    return 1;
-}
-
-m_poppler_get_BOOL(LinkDest, isPageRef);
-m_poppler_get_INT(LinkDest, getPageNum);
-
-static int m_LinkDest_getPageRef(lua_State * L)
-{
-    udstruct *uin, *uout;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_LinkDest);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-    uout = new_Ref_userdata(L);
-    uout->d = (Ref *) gmalloc(sizeof(Ref));
-    ((Ref *) uout->d)->num = ((LinkDest *) uin->d)->getPageRef().num;
-    ((Ref *) uout->d)->gen = ((LinkDest *) uin->d)->getPageRef().gen;
-    uout->atype = ALLOC_LEPDF;
-    uout->pc = uin->pc;
-    uout->pd = uin->pd;
-    return 1;
-}
-
-m_poppler_get_DOUBLE(LinkDest, getLeft);
-m_poppler_get_DOUBLE(LinkDest, getBottom);
-m_poppler_get_DOUBLE(LinkDest, getRight);
-m_poppler_get_DOUBLE(LinkDest, getTop);
-m_poppler_get_DOUBLE(LinkDest, getZoom);
-m_poppler_get_BOOL(LinkDest, getChangeLeft);
-m_poppler_get_BOOL(LinkDest, getChangeTop);
-m_poppler_get_BOOL(LinkDest, getChangeZoom);
-
-m_poppler__tostring(LinkDest);
-
-static const struct luaL_Reg LinkDest_m[] = {
-    {"isOk", m_LinkDest_isOk},
-    {"getKind", m_LinkDest_getKind},
-    {"getKindName", m_LinkDest_getKindName},    // not poppler
-    {"isPageRef", m_LinkDest_isPageRef},
-    {"getPageNum", m_LinkDest_getPageNum},
-    {"getPageRef", m_LinkDest_getPageRef},
-    {"getLeft", m_LinkDest_getLeft},
-    {"getBottom", m_LinkDest_getBottom},
-    {"getRight", m_LinkDest_getRight},
-    {"getTop", m_LinkDest_getTop},
-    {"getZoom", m_LinkDest_getZoom},
-    {"getChangeLeft", m_LinkDest_getChangeLeft},
-    {"getChangeTop", m_LinkDest_getChangeTop},
-    {"getChangeZoom", m_LinkDest_getChangeZoom},
-    {"__tostring", m_LinkDest__tostring},
-    {NULL, NULL}                // sentinel
-};
-
-//**********************************************************************
-// Links
-
-m_poppler_get_INT(Links, getNumLinks);
-
-m_poppler__tostring(Links);
-
-static const struct luaL_Reg Links_m[] = {
-    {"getNumLinks", m_Links_getNumLinks},
-    //{"getLink", m_Links_getLink},
-    {"__tostring", m_Links__tostring},
-    {NULL, NULL}                // sentinel
-};
-
-//**********************************************************************
-// Object
-
-#ifdef HAVE_OBJECT_INITCMD_CONST_CHARP
-#define CHARP_CAST
-#else
-// must cast arg of Object::initCmd, Object::isStream, and Object::streamIs
-// from 'const char *' to 'char *', although they are not modified.
-#define CHARP_CAST (char *)
-#endif
-
-// Special type checking.
-#define m_Object_isType_(function, cast)                                   \
-static int m_Object_##function(lua_State * L)                              \
-{                                                                          \
-    udstruct *uin;                                                         \
-    uin = (udstruct *) luaL_checkudata(L, 1, M_Object);                    \
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)                         \
-        pdfdoc_changed_error(L);                                           \
-    if (lua_gettop(L) >= 2) {                                              \
-        if (lua_isstring(L, 2)                                             \
-            && ((Object *) uin->d)->function(cast lua_tostring(L, 2)))     \
-            lua_pushboolean(L, 1);                                         \
-        else                                                               \
-            lua_pushboolean(L, 0);                                         \
-    } else {                                                               \
-        if (((Object *) uin->d)->function())                               \
-            lua_pushboolean(L, 1);                                         \
-        else                                                               \
-            lua_pushboolean(L, 0);                                         \
-    }                                                                      \
-    return 1;                                                              \
-}
-#define m_Object_isType(function) m_Object_isType_(function, )
-#define m_Object_isType_nonconst(function) m_Object_isType_(function, CHARP_CAST)
-
-static int m_Object_initBool(lua_State * L)
-{
-    udstruct *uin;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_Object);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-    luaL_checktype(L, 2, LUA_TBOOLEAN);
-    if (lua_toboolean(L, 2) != 0)
-        *((Object *) uin->d) = Object(gTrue);
-    else
-        *((Object *) uin->d) = Object(gFalse);
-    return 0;
-}
-
-static int m_Object_initInt(lua_State * L)
-{
-    int i;
-    udstruct *uin;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_Object);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-    i = luaL_checkint(L, 2);
-    *((Object *) uin->d) = Object(i);
-    return 0;
-}
-
-static int m_Object_initReal(lua_State * L)
-{
-    double d;
-    udstruct *uin;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_Object);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-    d = luaL_checknumber(L, 2);
-    *((Object *) uin->d) = Object(d);
-    return 0;
-}
-
-static int m_Object_initString(lua_State * L)
-{
-    GooString *gs;
-    const char *s;
-    size_t len;
-    udstruct *uin;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_Object);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-    s = luaL_checklstring(L, 2, &len);
-    gs = new GooString(s, len);
-    *((Object *) uin->d) = Object(gs);
-    return 0;
-}
-
-static int m_Object_initName(lua_State * L)
-{
-    const char *s;
-    udstruct *uin;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_Object);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-    s = luaL_checkstring(L, 2);
-    *((Object *) uin->d) = Object(objName, s);
-    return 0;
-}
-
-static int m_Object_initNull(lua_State * L)
-{
-    udstruct *uin;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_Object);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-    *((Object *) uin->d) = Object(objNull);
-    return 0;
-}
-
-static int m_Object_initArray(lua_State * L)
-{
-    udstruct *uin, *uxref;
-    Array *a;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_Object);
-    uxref = (udstruct *) luaL_checkudata(L, 2, M_XRef);
-    if (uin->pd != NULL && uxref->pd != NULL && uin->pd != uxref->pd)
-        pdfdoc_differs_error(L);
-    if ((uin->pd != NULL && uin->pd->pc != uin->pc)
-        || (uxref->pd != NULL && uxref->pd->pc != uxref->pc))
-        pdfdoc_changed_error(L);
-    a = new Array((XRef *) uxref->d);
-    *((Object *) uin->d) = Object(a);
-    return 0;
-}
-
-// TODO: decide betweeen
-//   Object *initDict(XRef *xref);
-//   Object *initDict(Dict *dictA);
-
-static int m_Object_initDict(lua_State * L)
-{
-    udstruct *uin, *uxref;
-    Dict *d;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_Object);
-    uxref = (udstruct *) luaL_checkudata(L, 2, M_XRef);
-    if (uin->pd != NULL && uxref->pd != NULL && uin->pd != uxref->pd)
-        pdfdoc_differs_error(L);
-    if ((uin->pd != NULL && uin->pd->pc != uin->pc)
-        || (uxref->pd != NULL && uxref->pd->pc != uxref->pc))
-        pdfdoc_changed_error(L);
-    d = new Dict((XRef *) uxref->d);
-    *((Object *) uin->d) = Object(d);
-    return 0;
-}
-
-static int m_Object_initStream(lua_State * L)
-{
-    udstruct *uin, *ustream;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_Object);
-    ustream = (udstruct *) luaL_checkudata(L, 2, M_Stream);
-    if (uin->pd != NULL && ustream->pd != NULL && uin->pd != ustream->pd)
-        pdfdoc_differs_error(L);
-    if ((uin->pd != NULL && uin->pd->pc != uin->pc)
-        || (ustream->pd != NULL && ustream->pd->pc != ustream->pc))
-        pdfdoc_changed_error(L);
-    *((Object *) uin->d) = Object((Stream *) ustream->d);
-    return 0;
-}
-
-static int m_Object_initRef(lua_State * L)
-{
-    int num, gen;
-    udstruct *uin;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_Object);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-    num = luaL_checkint(L, 2);
-    gen = luaL_checkint(L, 3);
-    *((Object *) uin->d) = Object(num, gen);
-    return 0;
-}
-
-static int m_Object_initCmd(lua_State * L)
-{
-    const char *s;
-    udstruct *uin;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_Object);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-    s = luaL_checkstring(L, 2);
-    *((Object *) uin->d) = Object(objCmd, s);
-    return 0;
-}
-
-static int m_Object_initError(lua_State * L)
-{
-    udstruct *uin;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_Object);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-    *((Object *) uin->d) = Object(objError);
-    return 0;
-}
-
-static int m_Object_initEOF(lua_State * L)
-{
-    udstruct *uin;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_Object);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-    *((Object *) uin->d) = Object(objEOF);
-    return 0;
-}
-
-static int m_Object_fetch(lua_State * L)
-{
-    udstruct *uin, *uxref, *uout;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_Object);
-    uxref = (udstruct *) luaL_checkudata(L, 2, M_XRef);
-    if (uin->pd != NULL && uxref->pd != NULL && uin->pd != uxref->pd)
-        pdfdoc_differs_error(L);
-    if ((uin->pd != NULL && uin->pd->pc != uin->pc)
-        || (uxref->pd != NULL && uxref->pd->pc != uxref->pc))
-        pdfdoc_changed_error(L);
-    uout = new_Object_userdata(L);
-    uout->d = new Object();
-    *((Object *) uout->d) = ((Object *) uin->d)->fetch((XRef *) uxref->d);
-    uout->atype = ALLOC_LEPDF;
-    uout->pc = uin->pc;
-    uout->pd = uin->pd;
-    return 1;
-}
-
-static int m_Object_getType(lua_State * L)
-{
-    ObjType t;
-    udstruct *uin;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_Object);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-    t = ((Object *) uin->d)->getType();
-    lua_pushinteger(L, (int) t);
-    return 1;
-}
-
-static int m_Object_getTypeName(lua_State * L)
-{
-    udstruct *uin;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_Object);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-    lua_pushstring(L, ((Object *) uin->d)->getTypeName());
-    return 1;
-}
-
-m_poppler_get_BOOL(Object, isBool);
-m_poppler_get_BOOL(Object, isInt);
-m_poppler_get_BOOL(Object, isReal);
-m_poppler_get_BOOL(Object, isNum);
-m_poppler_get_BOOL(Object, isString);
-m_Object_isType(isName);
-m_poppler_get_BOOL(Object, isNull);
-m_poppler_get_BOOL(Object, isArray);
-m_Object_isType(isDict);
-m_Object_isType_nonconst(isStream);
-m_poppler_get_BOOL(Object, isRef);
-m_Object_isType(isCmd);
-m_poppler_get_BOOL(Object, isError);
-m_poppler_get_BOOL(Object, isEOF);
-m_poppler_get_BOOL(Object, isNone);
-
-static int m_Object_getBool(lua_State * L)
-{
-    udstruct *uin;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_Object);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-    if (((Object *) uin->d)->isBool()) {
-        if (((Object *) uin->d)->getBool())
-            lua_pushboolean(L, 1);
-        else
-            lua_pushboolean(L, 0);
-    } else
-        lua_pushnil(L);
-    return 1;
-}
-
-static int m_Object_getInt(lua_State * L)
-{
-    udstruct *uin;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_Object);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-    if (((Object *) uin->d)->isInt())
-        lua_pushinteger(L, ((Object *) uin->d)->getInt());
-    else
-        lua_pushnil(L);
-    return 1;
-}
-
-static int m_Object_getReal(lua_State * L)
-{
-    udstruct *uin;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_Object);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-    if (((Object *) uin->d)->isReal())
-        lua_pushnumber(L, ((Object *) uin->d)->getReal()); /* float */
-    else
-        lua_pushnil(L);
-    return 1;
-}
-
-static int m_Object_getNum(lua_State * L)
-{
-    udstruct *uin;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_Object);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-    if (((Object *) uin->d)->isInt())
-        lua_pushinteger(L, ((Object *) uin->d)->getInt());
-    else if (((Object *) uin->d)->isReal())
-        lua_pushinteger(L, ((Object *) uin->d)->getReal());
-    else if (((Object *) uin->d)->isNum()) /* redundant */
-        lua_pushnumber(L, ((Object *) uin->d)->getNum()); /* integer or float */
-    else
-        lua_pushnil(L);
-    return 1;
-}
-
-static int m_Object_getString(lua_State * L)
-{
-    GooString *gs;
-    udstruct *uin;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_Object);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-    if (((Object *) uin->d)->isString()) {
-        gs = (GooString *)((Object *) uin->d)->getString();
-        lua_pushlstring(L, gs->getCString(), gs->getLength());
-    } else
-        lua_pushnil(L);
-    return 1;
-}
-
-static int m_Object_getName(lua_State * L)
-{
-    udstruct *uin;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_Object);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-    if (((Object *) uin->d)->isName())
-        lua_pushstring(L, ((Object *) uin->d)->getName());
-    else
-        lua_pushnil(L);
-    return 1;
-}
-
-static int m_Object_getArray(lua_State * L)
-{
-    udstruct *uin, *uout;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_Object);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-    if (((Object *) uin->d)->isArray()) {
-        uout = new_Array_userdata(L);
-        uout->d = ((Object *) uin->d)->getArray();
-        uout->pc = uin->pc;
-        uout->pd = uin->pd;
-    } else
-        lua_pushnil(L);
-    return 1;
-}
-
-static int m_Object_getDict(lua_State * L)
-{
-    udstruct *uin, *uout;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_Object);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-    if (((Object *) uin->d)->isDict()) {
-        uout = new_Dict_userdata(L);
-        uout->d = ((Object *) uin->d)->getDict();
-        uout->pc = uin->pc;
-        uout->pd = uin->pd;
-    } else
-        lua_pushnil(L);
-    return 1;
-}
-
-static int m_Object_getStream(lua_State * L)
-{
-    udstruct *uin, *uout;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_Object);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-    if (((Object *) uin->d)->isStream()) {
-        uout = new_Stream_userdata(L);
-        uout->d = ((Object *) uin->d)->getStream();
-        uout->pc = uin->pc;
-        uout->pd = uin->pd;
-    } else
-        lua_pushnil(L);
-    return 1;
-}
-
-static int m_Object_getRef(lua_State * L)
-{
-    udstruct *uin, *uout;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_Object);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-    if (((Object *) uin->d)->isRef()) {
-        uout = new_Ref_userdata(L);
-        uout->d = (Ref *) gmalloc(sizeof(Ref));
-        ((Ref *) uout->d)->num = ((Object *) uin->d)->getRef().num;
-        ((Ref *) uout->d)->gen = ((Object *) uin->d)->getRef().gen;
-        uout->atype = ALLOC_LEPDF;
-        uout->pc = uin->pc;
-        uout->pd = uin->pd;
-    } else
-        lua_pushnil(L);
-    return 1;
-}
-
-static int m_Object_getRefNum(lua_State * L)
-{
-    int i;
-    udstruct *uin;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_Object);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-    if (((Object *) uin->d)->isRef()) {
-        i = ((Object *) uin->d)->getRef().num;
-        lua_pushinteger(L, i);
-    } else
-        lua_pushnil(L);
-    return 1;
-}
-
-static int m_Object_getRefGen(lua_State * L)
-{
-    int i;
-    udstruct *uin;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_Object);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-    if (((Object *) uin->d)->isRef()) {
-        i = ((Object *) uin->d)->getRef().gen;
-        lua_pushinteger(L, i);
-    } else
-        lua_pushnil(L);
-    return 1;
-}
-
-static int m_Object_getCmd(lua_State * L)
-{
-    udstruct *uin;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_Object);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-    if (((Object *) uin->d)->isCmd())
-        lua_pushstring(L, ((Object *) uin->d)->getCmd());
-    else
-        lua_pushnil(L);
-    return 1;
-}
-
-static int m_Object_arrayGetLength(lua_State * L)
-{
-    int len;
-    udstruct *uin;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_Object);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-    if (((Object *) uin->d)->isArray()) {
-        len = ((Object *) uin->d)->arrayGetLength();
-        lua_pushinteger(L, len);
-    } else
-        lua_pushnil(L);
-    return 1;
-}
-
-static int m_Object_arrayAdd(lua_State * L)
-{
-    udstruct *uin, *uobj;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_Object);
-    uobj = (udstruct *) luaL_checkudata(L, 2, M_Object);
-    if (uin->pd != NULL && uobj->pd != NULL && uin->pd != uobj->pd)
-        pdfdoc_differs_error(L);
-    if ((uin->pd != NULL && uin->pd->pc != uin->pc)
-        || (uobj->pd != NULL && uobj->pd->pc != uobj->pd->pc))
-        pdfdoc_changed_error(L);
-    if (!((Object *) uin->d)->isArray())
-        luaL_error(L, "Object is not an Array");
-    ((Object *) uin->d)->arrayAdd(std::move(*((Object *) uobj->d)));
-    return 0;
-}
-
-static int m_Object_arrayGet(lua_State * L)
-{
-    int i, len;
-    udstruct *uin, *uout;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_Object);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-    i = luaL_checkint(L, 2);
-    if (((Object *) uin->d)->isArray()) {
-        len = ((Object *) uin->d)->arrayGetLength();
-        if (i > 0 && i <= len) {
-            uout = new_Object_userdata(L);
-            uout->d = new Object();
-            *((Object *) uout->d) = ((Object *) uin->d)->arrayGet(i - 1);
-            uout->atype = ALLOC_LEPDF;
-            uout->pc = uin->pc;
-            uout->pd = uin->pd;
-        } else
-            lua_pushnil(L);
-    } else
-        lua_pushnil(L);
-    return 1;
-}
-
-static int m_Object_arrayGetNF(lua_State * L)
-{
-    int i, len;
-    udstruct *uin, *uout;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_Object);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-    i = luaL_checkint(L, 2);
-    if (((Object *) uin->d)->isArray()) {
-        len = ((Object *) uin->d)->arrayGetLength();
-        if (i > 0 && i <= len) {
-            uout = new_Object_userdata(L);
-            uout->d = new Object();
-            *((Object *) uout->d) = ((Object *) uin->d)->arrayGetNF(i - 1);
-            uout->atype = ALLOC_LEPDF;
-            uout->pc = uin->pc;
-            uout->pd = uin->pd;
-        } else
-            lua_pushnil(L);
-    } else
-        lua_pushnil(L);
-    return 1;
-}
-
-static int m_Object_dictGetLength(lua_State * L)
-{
-    int len;
-    udstruct *uin;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_Object);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-    if (((Object *) uin->d)->isDict()) {
-        len = ((Object *) uin->d)->dictGetLength();
-        lua_pushinteger(L, len);
-    } else
-        lua_pushnil(L);
-    return 1;
-}
-
-static int m_Object_dictAdd(lua_State * L)
-{
-    const char *s;
-    udstruct *uin, *uobj;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_Object);
-    s = luaL_checkstring(L, 2);
-    uobj = (udstruct *) luaL_checkudata(L, 3, M_Object);
-    if (uin->pd != NULL && uobj->pd != NULL && uin->pd != uobj->pd)
-        pdfdoc_differs_error(L);
-    if ((uin->pd != NULL && uin->pd->pc != uin->pc)
-        || (uobj->pd != NULL && uobj->pd->pc != uobj->pd->pc))
-        pdfdoc_changed_error(L);
-    if (!((Object *) uin->d)->isDict())
-        luaL_error(L, "Object is not a Dict");
-    ((Object *) uin->d)->dictAdd(copyString(s), std::move(*((Object *) uobj->d)));
-    return 0;
-}
-
-static int m_Object_dictSet(lua_State * L)
-{
-    const char *s;
-    udstruct *uin, *uobj;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_Object);
-    s = luaL_checkstring(L, 2);
-    uobj = (udstruct *) luaL_checkudata(L, 3, M_Object);
-    if (uin->pd != NULL && uobj->pd != NULL && uin->pd != uobj->pd)
-        pdfdoc_differs_error(L);
-    if ((uin->pd != NULL && uin->pd->pc != uin->pc)
-        || (uobj->pd != NULL && uobj->pd->pc != uobj->pd->pc))
-        pdfdoc_changed_error(L);
-    if (!((Object *) uin->d)->isDict())
-        luaL_error(L, "Object is not a Dict");
-    ((Object *) uin->d)->dictSet(s, std::move(*((Object *) uobj->d)));
-    return 0;
-}
-
-static int m_Object_dictLookup(lua_State * L)
-{
-    const char *s;
-    udstruct *uin, *uout;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_Object);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-    s = luaL_checkstring(L, 2);
-    if (((Object *) uin->d)->isDict()) {
-        uout = new_Object_userdata(L);
-        uout->d = new Object();
-        *((Object *) uout->d) = ((Object *) uin->d)->dictLookup(s);
-        uout->atype = ALLOC_LEPDF;
-        uout->pc = uin->pc;
-        uout->pd = uin->pd;
-    } else
-        lua_pushnil(L);
-    return 1;
-}
-
-static int m_Object_dictLookupNF(lua_State * L)
-{
-    const char *s;
-    udstruct *uin, *uout;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_Object);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-    s = luaL_checkstring(L, 2);
-    if (((Object *) uin->d)->isDict()) {
-        uout = new_Object_userdata(L);
-        uout->d = new Object();
-        *((Object *) uout->d) = ((Object *) uin->d)->dictLookupNF(s);
-        uout->atype = ALLOC_LEPDF;
-        uout->pc = uin->pc;
-        uout->pd = uin->pd;
-    } else
-        lua_pushnil(L);
-    return 1;
-}
-
-static int m_Object_dictGetKey(lua_State * L)
-{
-    int i, len;
-    udstruct *uin;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_Object);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-    i = luaL_checkint(L, 2);
-    if (((Object *) uin->d)->isDict()) {
-        len = ((Object *) uin->d)->dictGetLength();
-        if (i > 0 && i <= len)
-            lua_pushstring(L, ((Object *) uin->d)->dictGetKey(i - 1));
-        else
-            lua_pushnil(L);
-    } else
-        lua_pushnil(L);
-    return 1;
-}
-
-static int m_Object_dictGetVal(lua_State * L)
-{
-    int i, len;
-    udstruct *uin, *uout;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_Object);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-    i = luaL_checkint(L, 2);
-    if (((Object *) uin->d)->isDict()) {
-        len = ((Object *) uin->d)->dictGetLength();
-        if (i > 0 && i <= len) {
-            uout = new_Object_userdata(L);
-            uout->d = new Object();
-	    *((Object *) uout->d) = ((Object *) uin->d)->dictGetVal(i - 1);
-            uout->atype = ALLOC_LEPDF;
-            uout->pc = uin->pc;
-            uout->pd = uin->pd;
-        } else
-            lua_pushnil(L);
-    } else
-        lua_pushnil(L);
-    return 1;
-}
-
-static int m_Object_dictGetValNF(lua_State * L)
-{
-    int i, len;
-    udstruct *uin, *uout;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_Object);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-    i = luaL_checkint(L, 2);
-    if (((Object *) uin->d)->isDict()) {
-        len = ((Object *) uin->d)->dictGetLength();
-        if (i > 0 && i <= len) {
-            uout = new_Object_userdata(L);
-            uout->d = new Object();
-            *((Object *) uout->d) = ((Object *) uin->d)->dictGetValNF(i - 1);
-            uout->atype = ALLOC_LEPDF;
-            uout->pc = uin->pc;
-            uout->pd = uin->pd;
-        } else
-            lua_pushnil(L);
-    } else
-        lua_pushnil(L);
-    return 1;
-}
-
-static int m_Object_streamIs(lua_State * L)
-{
-    const char *s;
-    udstruct *uin;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_Object);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-    s = luaL_checkstring(L, 2);
-    if (((Object *) uin->d)->isStream()) {
-        if (((Object *) uin->d)->streamIs(CHARP_CAST s))
-            lua_pushboolean(L, 1);
-        else
-            lua_pushboolean(L, 0);
-    } else
-        lua_pushnil(L);
-    return 1;
-}
-
-static int m_Object_streamReset(lua_State * L)
-{
-    udstruct *uin;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_Object);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-    if (((Object *) uin->d)->isStream())
-        ((Object *) uin->d)->streamReset();
-    return 0;
-}
-
-static int m_Object_streamGetChar(lua_State * L)
-{
-    int i;
-    udstruct *uin;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_Object);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-    if (((Object *) uin->d)->isStream()) {
-        i = ((Object *) uin->d)->streamGetChar();
-        lua_pushinteger(L, i);
-    } else
-        lua_pushnil(L);
-    return 1;
-}
-
-static int m_Object_streamLookChar(lua_State * L)
-{
-    int i;
-    udstruct *uin;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_Object);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-    if (((Object *) uin->d)->isStream()) {
-        i = ((Object *) uin->d)->streamLookChar();
-        lua_pushinteger(L, i);
-    } else
-        lua_pushnil(L);
-    return 1;
-}
-
-static int m_Object_streamGetPos(lua_State * L)
-{
-    int i;
-    udstruct *uin;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_Object);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-    if (((Object *) uin->d)->isStream()) {
-        i = (int) ((Object *) uin->d)->streamGetPos();
-        lua_pushinteger(L, i);
-    } else
-        lua_pushnil(L);
-    return 1;
-}
-
-static int m_Object_streamSetPos(lua_State * L)
-{
-    int i;
-    udstruct *uin;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_Object);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-    i = luaL_checkint(L, 2);
-    if (((Object *) uin->d)->isStream())
-        ((Object *) uin->d)->streamSetPos(i);
-    return 0;
-}
-
-static int m_Object_streamGetDict(lua_State * L)
-{
-    udstruct *uin, *uout;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_Object);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-    if (((Object *) uin->d)->isStream()) {
-        uout = new_Dict_userdata(L);
-        uout->d = ((Object *) uin->d)->streamGetDict();
-        uout->pc = uin->pc;
-        uout->pd = uin->pd;
-    } else
-        lua_pushnil(L);
-    return 1;
-}
-
-static int m_Object__gc(lua_State * L)
-{
-    udstruct *uin;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_Object);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-#ifdef DEBUG
-    printf("\n===== Object GC ===== uin=<%p>\n", uin);
-#endif
-    if (uin->atype == ALLOC_LEPDF) {
-      // free() seems to collide with the lua gc
-      //((Object *) uin->d)->free();
-        delete(Object *) uin->d;
-    }
-    return 0;
-}
-
-m_poppler__tostring(Object);
-
-static const struct luaL_Reg Object_m[] = {
-    {"initBool", m_Object_initBool},
-    {"initInt", m_Object_initInt},
-    {"initReal", m_Object_initReal},
-    {"initString", m_Object_initString},
-    {"initName", m_Object_initName},
-    {"initNull", m_Object_initNull},
-    {"initArray", m_Object_initArray},
-    {"initDict", m_Object_initDict},
-    {"initStream", m_Object_initStream},
-    {"initRef", m_Object_initRef},
-    {"initCmd", m_Object_initCmd},
-    {"initError", m_Object_initError},
-    {"initEOF", m_Object_initEOF},
-    // {"copy", m_Object_copy},
-    {"fetch", m_Object_fetch},
-    {"getType", m_Object_getType},
-    {"getTypeName", m_Object_getTypeName},
-    {"isBool", m_Object_isBool},
-    {"isInt", m_Object_isInt},
-    {"isReal", m_Object_isReal},
-    {"isNum", m_Object_isNum},
-    {"isString", m_Object_isString},
-    {"isName", m_Object_isName},
-    {"isNull", m_Object_isNull},
-    {"isArray", m_Object_isArray},
-    {"isDict", m_Object_isDict},
-    {"isStream", m_Object_isStream},
-    {"isRef", m_Object_isRef},
-    {"isCmd", m_Object_isCmd},
-    {"isError", m_Object_isError},
-    {"isEOF", m_Object_isEOF},
-    {"isNone", m_Object_isNone},
-    {"getBool", m_Object_getBool},
-    {"getInt", m_Object_getInt},
-    {"getReal", m_Object_getReal},
-    {"getNum", m_Object_getNum},
-    {"getString", m_Object_getString},
-    {"getName", m_Object_getName},
-    {"getArray", m_Object_getArray},
-    {"getDict", m_Object_getDict},
-    {"getStream", m_Object_getStream},
-    {"getRef", m_Object_getRef},
-    {"getRefNum", m_Object_getRefNum},
-    {"getRefGen", m_Object_getRefGen},
-    {"getCmd", m_Object_getCmd},
-    {"arrayGetLength", m_Object_arrayGetLength},
-    {"arrayAdd", m_Object_arrayAdd},
-    {"arrayGet", m_Object_arrayGet},
-    {"arrayGetNF", m_Object_arrayGetNF},
-    {"dictGetLength", m_Object_dictGetLength},
-    {"dictAdd", m_Object_dictAdd},
-    {"dictSet", m_Object_dictSet},
-    {"dictLookup", m_Object_dictLookup},
-    {"dictLookupNF", m_Object_dictLookupNF},
-    {"dictGetKey", m_Object_dictGetKey},
-    {"dictGetVal", m_Object_dictGetVal},
-    {"dictGetValNF", m_Object_dictGetValNF},
-    {"streamIs", m_Object_streamIs},
-    {"streamReset", m_Object_streamReset},
-    // {"streamClose", m_Object_streamClose},
-    {"streamGetChar", m_Object_streamGetChar},
-    {"streamLookChar", m_Object_streamLookChar},
-    // {"streamGetLine", m_Object_streamGetLine},
-    {"streamGetPos", m_Object_streamGetPos},
-    {"streamSetPos", m_Object_streamSetPos},
-    {"streamGetDict", m_Object_streamGetDict},
-    {"__tostring", m_Object__tostring},
-    {"__gc", m_Object__gc},     // finalizer
-    {NULL, NULL}                // sentinel
-};
-
-//**********************************************************************
-// Page
-
-m_poppler_get_BOOL(Page, isOk);
-m_poppler_get_INT(Page, getNum);
-m_poppler_get_poppler(Page, PDFRectangle, getMediaBox);
-m_poppler_get_poppler(Page, PDFRectangle, getCropBox);
-m_poppler_get_BOOL(Page, isCropped);
-m_poppler_get_DOUBLE(Page, getMediaWidth);
-m_poppler_get_DOUBLE(Page, getMediaHeight);
-m_poppler_get_DOUBLE(Page, getCropWidth);
-m_poppler_get_DOUBLE(Page, getCropHeight);
-m_poppler_get_poppler(Page, PDFRectangle, getBleedBox);
-m_poppler_get_poppler(Page, PDFRectangle, getTrimBox);
-m_poppler_get_poppler(Page, PDFRectangle, getArtBox);
-m_poppler_get_INT(Page, getRotate);
-m_poppler_get_GOOSTRING(Page, getLastModified);
-m_poppler_get_poppler(Page, Dict, getBoxColorInfo);
-m_poppler_get_poppler(Page, Dict, getGroup);
-m_poppler_get_poppler(Page, Stream, getMetadata);
-m_poppler_get_poppler(Page, Dict, getPieceInfo);
-m_poppler_get_poppler(Page, Dict, getSeparationInfo);
-m_poppler_get_poppler(Page, Dict, getResourceDict);
-m_poppler_get_OBJECT(Page, getAnnotsObject);
-
-m_poppler_get_OBJECT(Page, getContents);
-
-m_poppler__tostring(Page);
-
-static const struct luaL_Reg Page_m[] = {
-    {"isOk", m_Page_isOk},
-    {"getNum", m_Page_getNum},
-    {"getMediaBox", m_Page_getMediaBox},
-    {"getCropBox", m_Page_getCropBox},
-    {"isCropped", m_Page_isCropped},
-    {"getMediaWidth", m_Page_getMediaWidth},
-    {"getMediaHeight", m_Page_getMediaHeight},
-    {"getCropWidth", m_Page_getCropWidth},
-    {"getCropHeight", m_Page_getCropHeight},
-    {"getBleedBox", m_Page_getBleedBox},
-    {"getTrimBox", m_Page_getTrimBox},
-    {"getArtBox", m_Page_getArtBox},
-    {"getRotate", m_Page_getRotate},
-    {"getLastModified", m_Page_getLastModified},
-    {"getBoxColorInfo", m_Page_getBoxColorInfo},
-    {"getGroup", m_Page_getGroup},
-    {"getMetadata", m_Page_getMetadata},
-    {"getPieceInfo", m_Page_getPieceInfo},
-    {"getSeparationInfo", m_Page_getSeparationInfo},
-    {"getResourceDict", m_Page_getResourceDict},
-    {"getAnnotsObject", m_Page_getAnnotsObject},
-    {"getContents", m_Page_getContents},
-    {"__tostring", m_Page__tostring},
-    {NULL, NULL}                // sentinel
-};
-
-//**********************************************************************
-// PDFDoc
-
-#define m_PDFDoc_BOOL(function)                         \
-static int m_PDFDoc_##function(lua_State * L)           \
-{                                                       \
-    udstruct *uin;                                      \
-    uin = (udstruct *) luaL_checkudata(L, 1, M_PDFDoc); \
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)      \
-        pdfdoc_changed_error(L);                        \
-    if (((PdfDocument *) uin->d)->doc->function())      \
-        lua_pushboolean(L, 1);                          \
-    else                                                \
-        lua_pushboolean(L, 0);                          \
-    return 1;                                           \
-}
-
-#define m_PDFDoc_INT(function)                          \
-static int m_PDFDoc_##function(lua_State * L)           \
-{                                                       \
-    int i;                                              \
-    udstruct *uin;                                      \
-    uin = (udstruct *) luaL_checkudata(L, 1, M_PDFDoc); \
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)      \
-        pdfdoc_changed_error(L);                        \
-    i = ((PdfDocument *) uin->d)->doc->function();      \
-    lua_pushinteger(L, i);                              \
-    return 1;                                           \
-}
-
-m_PDFDoc_BOOL(isOk);
-m_PDFDoc_INT(getErrorCode);
-
-static int m_PDFDoc_getFileName(lua_State * L)
-{
-    GooString *gs;
-    udstruct *uin;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_PDFDoc);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-    gs = ((PdfDocument *) uin->d)->doc->getFileName();
-    if (gs != NULL)
-        lua_pushlstring(L, gs->getCString(), gs->getLength());
-    else
-        lua_pushnil(L);
-    return 1;
-}
-
-static int m_PDFDoc_getErrorCodeName(lua_State * L)
-{
-    int i;
-    udstruct *uin;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_PDFDoc);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-    i = ((PdfDocument *) uin->d)->doc->getErrorCode();
-    lua_pushstring(L, ErrorCodeNames[i]);
-    return 1;
-}
-
-static int m_PDFDoc_getXRef(lua_State * L)
-{
-    XRef *xref;
-    udstruct *uin, *uout;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_PDFDoc);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-    xref = ((PdfDocument *) uin->d)->doc->getXRef();
-    if (xref->isOk()) {
-        uout = new_XRef_userdata(L);
-        uout->d = xref;
-        uout->pc = uin->pc;
-        uout->pd = uin->pd;
-    } else
-        lua_pushnil(L);
-    return 1;
-}
-
-static int m_PDFDoc_getCatalog(lua_State * L)
-{
-    Catalog *cat;
-    udstruct *uin, *uout;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_PDFDoc);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-    cat = ((PdfDocument *) uin->d)->doc->getCatalog();
-    if (cat->isOk()) {
-        uout = new_Catalog_userdata(L);
-        uout->d = cat;
-        uout->pc = uin->pc;
-        uout->pd = uin->pd;
-    } else
-        lua_pushnil(L);
-    return 1;
-}
-
-#define m_PDFDoc_PAGEDIMEN(function)                             \
-static int m_PDFDoc_##function(lua_State * L)                    \
-{                                                                \
-    int i, pages;                                                \
-    double d;                                                    \
-    udstruct *uin;                                               \
-    uin = (udstruct *) luaL_checkudata(L, 1, M_PDFDoc);          \
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)               \
-        pdfdoc_changed_error(L);                                 \
-    i = luaL_checkint(L, 2);                                     \
-    pages = ((PdfDocument *) uin->d)->doc->getNumPages();        \
-    if (i > 0 && i <= pages) {                                   \
-        d = (double) ((PdfDocument *) uin->d)->doc->function(i); \
-        lua_pushnumber(L, d); /* float */                        \
-    } else                                                       \
-        lua_pushnil(L);                                          \
-    return 1;                                                    \
-}
-
-m_PDFDoc_PAGEDIMEN(getPageMediaWidth);
-m_PDFDoc_PAGEDIMEN(getPageMediaHeight);
-m_PDFDoc_PAGEDIMEN(getPageCropWidth);
-m_PDFDoc_PAGEDIMEN(getPageCropHeight);
-m_PDFDoc_INT(getNumPages);
-
-static int m_PDFDoc_readMetadata(lua_State * L)
-{
-    GooString *gs;
-    udstruct *uin;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_PDFDoc);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-    if (((PdfDocument *) uin->d)->doc->getCatalog()->isOk()) {
-        gs = ((PdfDocument *) uin->d)->doc->readMetadata();
-        if (gs != NULL)
-            lua_pushlstring(L, gs->getCString(), gs->getLength());
-        else
-            lua_pushnil(L);
-    } else
-        lua_pushnil(L);
-    return 1;
-}
-
-static int m_PDFDoc_getStructTreeRoot(lua_State * L)
-{
-    StructTreeRoot *obj;
-    udstruct *uin, *uout;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_PDFDoc);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-    if (((PdfDocument *) uin->d)->doc->getCatalog()->isOk()) {
-        obj = ((PdfDocument *) uin->d)->doc->getStructTreeRoot();
-        uout = new_StructTreeRoot_userdata(L);
-        uout->d = obj;
-        uout->pc = uin->pc;
-        uout->pd = uin->pd;
-    } else
-        lua_pushnil(L);
-    return 1;
-}
-
-static int m_PDFDoc_findPage(lua_State * L)
-{
-    int num, gen, i;
-    udstruct *uin;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_PDFDoc);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-    num = luaL_checkint(L, 2);
-    gen = luaL_checkint(L, 3);
-    if (((PdfDocument *) uin->d)->doc->getCatalog()->isOk()) {
-        i = ((PdfDocument *) uin->d)->doc->findPage(num, gen);
-        if (i > 0)
-            lua_pushinteger(L, i);
-        else
-            lua_pushnil(L);
-    } else
-        lua_pushnil(L);
-    return 1;
-}
-
-static int m_PDFDoc_getLinks(lua_State * L)
-{
-    int i, pages;
-    Links *links;
-    udstruct *uin, *uout;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_PDFDoc);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-    i = luaL_checkint(L, 2);
-    pages = ((PdfDocument *) uin->d)->doc->getNumPages();
-    if (i > 0 && i <= pages) {
-        links = ((PdfDocument *) uin->d)->doc->getLinks(i);
-        if (links != NULL) {
-            uout = new_Links_userdata(L);
-            uout->d = links;
-            uout->pc = uin->pc;
-            uout->pd = uin->pd;
-        } else
-            lua_pushnil(L);
-    } else
-        lua_pushnil(L);
-    return 1;
-}
-
-static int m_PDFDoc_findDest(lua_State * L)
-{
-    GooString *name;
-    LinkDest *dest;
-    const char *s;
-    size_t len;
-    udstruct *uin, *uout;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_PDFDoc);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-    s = luaL_checklstring(L, 2, &len);
-    name = new GooString(s, len);
-    if (((PdfDocument *) uin->d)->doc->getCatalog()->isOk()) {
-        dest = ((PdfDocument *) uin->d)->doc->findDest(name);
-        if (dest != NULL) {
-            uout = new_LinkDest_userdata(L);
-            uout->d = dest;
-            uout->pc = uin->pc;
-            uout->pd = uin->pd;
-        } else
-            lua_pushnil(L);
-    } else
-        lua_pushnil(L);
-    delete name;
-    return 1;
-}
-
-m_PDFDoc_BOOL(isEncrypted);
-m_PDFDoc_BOOL(okToPrint);
-m_PDFDoc_BOOL(okToChange);
-m_PDFDoc_BOOL(okToCopy);
-m_PDFDoc_BOOL(okToAddNotes);
-m_PDFDoc_BOOL(isLinearized);
-
-static int m_PDFDoc_getDocInfo(lua_State * L)
-{
-    udstruct *uin, *uout;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_PDFDoc);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-    if (((PdfDocument *) uin->d)->doc->getXRef()->isOk()) {
-        uout = new_Object_userdata(L);
-        uout->d = new Object();
-        *((Object *) uout->d) = ((PdfDocument *) uin->d)->doc->getDocInfo();
-        uout->atype = ALLOC_LEPDF;
-        uout->pc = uin->pc;
-        uout->pd = uin->pd;
-    } else
-        lua_pushnil(L);
-    return 1;
-}
-
-static int m_PDFDoc_getDocInfoNF(lua_State * L)
-{
-    udstruct *uin, *uout;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_PDFDoc);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-    if (((PdfDocument *) uin->d)->doc->getXRef()->isOk()) {
-        uout = new_Object_userdata(L);
-        uout->d = new Object();
-        *((Object *) uout->d) = ((PdfDocument *) uin->d)->doc->getDocInfoNF();
-        uout->atype = ALLOC_LEPDF;
-        uout->pc = uin->pc;
-        uout->pd = uin->pd;
-    } else
-        lua_pushnil(L);
-    return 1;
-}
-
-m_PDFDoc_INT(getPDFMajorVersion);
-m_PDFDoc_INT(getPDFMinorVersion);
-
-m_poppler__tostring(PDFDoc);
-
-static int m_PDFDoc__gc(lua_State * L)
-{
-    udstruct *uin;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_PDFDoc);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-#ifdef DEBUG
-    printf("\n===== PDFDoc GC ===== file_path=<%s>\n",
-           ((PdfDocument *) uin->d)->file_path);
-#endif
-    assert(uin->atype == ALLOC_LEPDF);
-    unrefPdfDocument(((PdfDocument *) uin->d)->file_path);
-    return 0;
-}
-
-static const struct luaL_Reg PDFDoc_m[] = {
-    {"isOk", m_PDFDoc_isOk},
-    {"getErrorCode", m_PDFDoc_getErrorCode},
-    {"getErrorCodeName", m_PDFDoc_getErrorCodeName},    // not poppler
-    {"getFileName", m_PDFDoc_getFileName},
-    {"getXRef", m_PDFDoc_getXRef},
-    {"getCatalog", m_PDFDoc_getCatalog},
-    // {"getBaseStream", m_PDFDoc_getBaseStream},
-    {"getPageMediaWidth", m_PDFDoc_getPageMediaWidth},
-    {"getPageMediaHeight", m_PDFDoc_getPageMediaHeight},
-    {"getPageCropWidth", m_PDFDoc_getPageCropWidth},
-    {"getPageCropHeight", m_PDFDoc_getPageCropHeight},
-    {"getNumPages", m_PDFDoc_getNumPages},
-    {"readMetadata", m_PDFDoc_readMetadata},
-    {"getStructTreeRoot", m_PDFDoc_getStructTreeRoot},
-    {"findPage", m_PDFDoc_findPage},
-    {"getLinks", m_PDFDoc_getLinks},
-    {"findDest", m_PDFDoc_findDest},
-    {"isEncrypted", m_PDFDoc_isEncrypted},
-    {"okToPrint", m_PDFDoc_okToPrint},
-    {"okToChange", m_PDFDoc_okToChange},
-    {"okToCopy", m_PDFDoc_okToCopy},
-    {"okToAddNotes", m_PDFDoc_okToAddNotes},
-    {"isLinearized", m_PDFDoc_isLinearized},
-    {"getDocInfo", m_PDFDoc_getDocInfo},
-    {"getDocInfoNF", m_PDFDoc_getDocInfoNF},
-    {"getPDFMajorVersion", m_PDFDoc_getPDFMajorVersion},
-    {"getPDFMinorVersion", m_PDFDoc_getPDFMinorVersion},
-    {"__tostring", m_PDFDoc__tostring},
-    {"__gc", m_PDFDoc__gc},     // finalizer
-    {NULL, NULL}                // sentinel
-};
-
-//**********************************************************************
-// PDFRectangle
-
-m_poppler_get_BOOL(PDFRectangle, isValid);
-
-m_poppler__tostring(PDFRectangle);
-
-static int m_PDFRectangle__index(lua_State * L)
-{
-    const char *s;
-    udstruct *uin;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_PDFRectangle);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-    s = luaL_checkstring(L, 2);
-    if (strlen(s) == 2) {
-        if (s[0] == 'x') {
-            if (s[1] == '1')
-                lua_pushnumber(L, ((PDFRectangle *) uin->d)->x1); /* float */
-            else if (s[1] == '2')
-                lua_pushnumber(L, ((PDFRectangle *) uin->d)->x2); /* float */
-            else
-                lua_pushnil(L);
-        } else if (s[0] == 'y') {
-            if (s[1] == '1')
-                lua_pushnumber(L, ((PDFRectangle *) uin->d)->y1); /* float */
-            else if (s[1] == '2')
-                lua_pushnumber(L, ((PDFRectangle *) uin->d)->y2); /* float */
-            else
-                lua_pushnil(L);
-        } else
-            lua_pushnil(L);
-    } else
-        lua_pushnil(L);
-    return 1;
-}
-
-static int m_PDFRectangle__newindex(lua_State * L)
-{
-    double d;
-    const char *s;
-    udstruct *uin;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_PDFRectangle);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-    s = luaL_checkstring(L, 2);
-    d = luaL_checknumber(L, 3);
-    if (strlen(s) == 2) {
-        if (s[0] == 'x') {
-            if (s[1] == '1')
-                ((PDFRectangle *) uin->d)->x1 = d;
-            else if (s[1] == '2')
-                ((PDFRectangle *) uin->d)->x2 = d;
-            else
-                luaL_error(L, "wrong PDFRectangle coordinate (%s)", s);
-        } else if (s[0] == 'y') {
-            if (s[1] == '1')
-                ((PDFRectangle *) uin->d)->y1 = d;
-            else if (s[1] == '2')
-                ((PDFRectangle *) uin->d)->y2 = d;
-        } else
-            luaL_error(L, "wrong PDFRectangle coordinate (%s)", s);
-    } else
-        luaL_error(L, "wrong PDFRectangle coordinate (%s)", s);
-    return 0;
-}
-
-static int m_PDFRectangle__gc(lua_State * L)
-{
-    udstruct *uin;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_PDFRectangle);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-#ifdef DEBUG
-    printf("\n===== PDFRectangle GC ===== uin=<%p>\n", uin);
-#endif
-    if (uin->atype == ALLOC_LEPDF)
-        delete(PDFRectangle *) uin->d;
-    return 0;
-}
-
-static const struct luaL_Reg PDFRectangle_m[] = {
-    {"isValid", m_PDFRectangle_isValid},
-    {"__index", m_PDFRectangle__index},
-    {"__newindex", m_PDFRectangle__newindex},
-    {"__tostring", m_PDFRectangle__tostring},
-    {"__gc", m_PDFRectangle__gc},
-    {NULL, NULL}                // sentinel
-};
-
-//**********************************************************************
-// Ref
-
-static int m_Ref__index(lua_State * L)
-{
-    const char *s;
-    udstruct *uin;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_Ref);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-    s = luaL_checkstring(L, 2);
-    if (strcmp(s, "num") == 0)
-        lua_pushinteger(L, ((Ref *) uin->d)->num);
-    else if (strcmp(s, "gen") == 0)
-        lua_pushinteger(L, ((Ref *) uin->d)->gen);
-    else
-        lua_pushnil(L);
-    return 1;
-}
-
-m_poppler__tostring(Ref);
-
-static int m_Ref__gc(lua_State * L)
-{
-    udstruct *uin;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_Ref);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-#ifdef DEBUG
-    printf("\n===== Ref GC ===== uin=<%p>\n", uin);
-#endif
-    if (uin->atype == ALLOC_LEPDF && ((Ref *) uin->d) != NULL)
-        gfree(((Ref *) uin->d));
-    return 0;
-}
-
-static const struct luaL_Reg Ref_m[] = {
-    {"__index", m_Ref__index},
-    {"__tostring", m_Ref__tostring},
-    {"__gc", m_Ref__gc},        // finalizer
-    {NULL, NULL}                // sentinel
-};
-
-//**********************************************************************
-// Stream
-
-static const char *StreamKindNames[] =
-    { "File", "ASCIIHex", "ASCII85", "LZW", "RunLength", "CCITTFax", "DCT",
-    "Flate", "JBIG2", "JPX", "Weird", NULL
-};
-
-m_poppler_get_INT(Stream, getKind);
-
-static int m_Stream_getKindName(lua_State * L)
-{
-    StreamKind t;
-    udstruct *uin;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_Stream);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-    t = ((Stream *) uin->d)->getKind();
-    lua_pushstring(L, StreamKindNames[t]);
-    return 1;
-}
-
-m_poppler_do(Stream, reset);
-m_poppler_do(Stream, close);
-m_poppler_get_INT(Stream, getChar);
-m_poppler_get_INT(Stream, lookChar);
-m_poppler_get_INT(Stream, getRawChar);
-m_poppler_get_INT(Stream, getUnfilteredChar);
-m_poppler_do(Stream, unfilteredReset);
-m_poppler_get_INT(Stream, getPos);
-m_poppler_get_BOOL(Stream, isBinary);
-m_poppler_get_poppler(Stream, Stream, getUndecodedStream);
-m_poppler_get_poppler(Stream, Dict, getDict);
-
-m_poppler__tostring(Stream);
-
-static const struct luaL_Reg Stream_m[] = {
-    {"getKind", m_Stream_getKind},
-    {"getKindName", m_Stream_getKindName},      // not poppler
-    {"reset", m_Stream_reset},
-    {"close", m_Stream_close},
-    {"getUndecodedStream", m_Stream_getUndecodedStream},
-    {"getChar", m_Stream_getChar},
-    {"lookChar", m_Stream_lookChar},
-    {"getRawChar", m_Stream_getRawChar},
-    {"getUnfilteredChar", m_Stream_getUnfilteredChar},
-    {"unfilteredReset", m_Stream_unfilteredReset},
-    // {"getLine", m_Stream_getLine},
-    {"getPos", m_Stream_getPos},
-    {"isBinary", m_Stream_isBinary},
-    {"getUndecodedStream", m_Stream_getUndecodedStream},
-    {"getDict", m_Stream_getDict},
-    {"__tostring", m_Stream__tostring},
-    {NULL, NULL}                // sentinel
-};
-
-//**********************************************************************
-// TextSpan
-
-m_poppler_get_GOOSTRING(TextSpan, getText);
-m_poppler__tostring(TextSpan);
-
-static const struct luaL_Reg TextSpan_m[] = {
-    {"getText", m_TextSpan_getText},
-    {"__tostring", m_TextSpan__tostring},
-    {NULL, NULL}                // sentinel
-};
-
-
-
-
-//**********************************************************************
-// Attribute
-m_poppler_get_BOOL(Attribute,isOk);
-m_poppler_get_INT(Attribute,getType);
-m_poppler_get_INT(Attribute,getOwner);
-m_poppler_get_GOOSTRING(Attribute,getName);
-
-static int m_Attribute_getTypeName(lua_State * L)
-{
-    udstruct *uin;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_Attribute);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-    lua_pushstring(L, ((Attribute *) uin->d)->getTypeName());
-    return 1;
-}
-
-static int m_Attribute_getOwnerName(lua_State * L)
-{
-    udstruct *uin;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_Attribute);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-    lua_pushstring(L, ((Attribute *) uin->d)->getOwnerName());
-    return 1;
-}
-
-static int m_Attribute_getValue(lua_State * L)
-{
-    udstruct *uin, *uout;
-    Object *origin;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_Attribute);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-    uout = new_Object_userdata(L);
-    uout->d = new Object();
-    origin = (Object *) (((Attribute *) uin->d)->getValue());
-    *((Object *) uout->d) = origin->copy();
-    uout->atype = ALLOC_LEPDF;
-    uout->pc = uin->pc;
-    uout->pd = uin->pd;
-    return 1;
-}
-
-
-static int m_Attribute_getDefaultValue(lua_State * L)
-{
-    Attribute::Type t;
-    udstruct *uin, *uout;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_Attribute);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-    t = (Attribute::Type) luaL_checkint(L, 2);
-    uout = new_Object_userdata(L);
-    uout->d = ((Attribute *)uin->d)->getDefaultValue(t)  ;
-    //uout->atype = ALLOC_LEPDF;
-    uout->pc = uin->pc;
-    uout->pd = uin->pd;
-    return 1;
-}
-
-
-m_poppler_get_GUINT(Attribute,getRevision);
-
-static int m_Attribute_setRevision(lua_State * L)
-{
-    Guint i;
-    udstruct *uin;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_Attribute);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-    i = (Guint) luaL_checkint(L, 2);
-    ((Attribute *) uin->d)->setRevision(i);
-    return 0;
-}
-
-m_poppler_get_BOOL(Attribute, isHidden);
-
-static int m_Attribute_setHidden(lua_State * L)
-{
-    GBool i;
-    udstruct *uin;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_Attribute);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-    i = (GBool) lua_toboolean(L, 2);
-    ((Attribute *) uin->d)->setHidden(i);
-    return 0;
-}
-
-static int m_Attribute_getFormattedValue(lua_State * L)
-{
-    udstruct *uin;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_Attribute);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-    lua_pushstring(L, ((Attribute *) uin->d)->getFormattedValue());
-    return 1;
-}
-
-
-static int m_Attribute_setFormattedValue(lua_State * L)
-{
-    const char *c;
-    udstruct *uin;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_Attribute);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-    c = luaL_checkstring(L, 2);
-    ((Attribute *) uin->d)->setFormattedValue(c);
-    return 0;
-}
-
-static int m_Attribute__gc(lua_State * L)
-{
-    udstruct *uin;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_Attribute);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-#ifdef DEBUG
-    printf("\n===== Attribute GC ===== uin=<%p>\n", uin);
-#endif
-    if (uin->atype == ALLOC_LEPDF) {
-        delete(Attribute *) uin->d;
-    }
-    return 0;
-}
-
-
-m_poppler__tostring(Attribute);
-
-
-static const struct luaL_Reg Attribute_m[] = {
-  {"isOk",m_Attribute_isOk},
-  {"getType",m_Attribute_getType},
-  {"getOwner",m_Attribute_getOwner},
-  {"getTypeName",m_Attribute_getTypeName},
-  {"getOwnerName",m_Attribute_getOwnerName},
-  {"getValue",m_Attribute_getValue},
-  {"getDefaultValue",m_Attribute_getDefaultValue},
-  {"getName",m_Attribute_getName},
-  {"getRevision",m_Attribute_getRevision},
-  {"setRevision",m_Attribute_setRevision},
-  {"istHidden",m_Attribute_isHidden},
-  {"setHidden",m_Attribute_setHidden},
-  {"getFormattedValue",m_Attribute_getFormattedValue},
-  {"setFormattedValue",m_Attribute_setFormattedValue},
-  {"__gc", m_Attribute__gc},
-  {"__tostring", m_Attribute__tostring},
-  {NULL, NULL}                // sentinel
-};
-
-
-
-
-//**********************************************************************
-// StructElement
-
-
-m_poppler_get_INT(StructElement,getType);
-m_poppler_get_BOOL(StructElement,isOk);
-m_poppler_get_BOOL(StructElement,isBlock);
-m_poppler_get_BOOL(StructElement,isInline);
-m_poppler_get_BOOL(StructElement,isGrouping);
-m_poppler_get_BOOL(StructElement,isContent);
-m_poppler_get_BOOL(StructElement,isObjectRef);
-m_poppler_get_BOOL(StructElement,hasPageRef);
-m_poppler_get_INT(StructElement,getMCID);
-m_poppler_get_INT(StructElement, getNumChildren);
-
-m_poppler_get_GUINT(StructElement,getRevision);
-m_poppler_get_UINT(StructElement,getNumAttributes);
-
-m_poppler_get_GOOSTRING(StructElement, getID);
-m_poppler_get_GOOSTRING(StructElement, getLanguage);
-m_poppler_get_GOOSTRING(StructElement, getTitle);
-m_poppler_get_GOOSTRING(StructElement, getExpandedAbbr);
-m_poppler_get_GOOSTRING(StructElement, getAltText);
-m_poppler_get_GOOSTRING(StructElement, getActualText);
-
-m_poppler_get_poppler(StructElement, StructTreeRoot, getStructTreeRoot);
-m_poppler__tostring(StructElement);
-
-
-static int m_StructElement_getObjectRef(lua_State * L)
-{
-    udstruct *uin, *uout;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_StructElement);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-    uout = new_Ref_userdata(L);
-    uout->d = (Ref *) gmalloc(sizeof(Ref));
-    ((Ref *) uout->d)->num = ((StructElement *) uin->d)->getObjectRef().num;
-    ((Ref *) uout->d)->gen = ((StructElement *) uin->d)->getObjectRef().gen;
-    uout->atype = ALLOC_LEPDF;
-    uout->pc = uin->pc;
-    uout->pd = uin->pd;
-    return 1;
-}
-
-
-static int m_StructElement_getParentRef(lua_State * L)
-{
-    udstruct *uin, *uout;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_StructElement);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-    uout = new_Ref_userdata(L);
-    uout->d = (Ref *) gmalloc(sizeof(Ref));
-    ((Ref *) uout->d)->num = ((StructElement *) uin->d)->getParentRef().num;
-    ((Ref *) uout->d)->gen = ((StructElement *) uin->d)->getParentRef().gen;
-    uout->atype = ALLOC_LEPDF;
-    uout->pc = uin->pc;
-    uout->pd = uin->pd;
-    return 1;
-}
-
-// Not exactly as the header:
-// Ref = StructElement:getPageRef()
-// Ref is false if the C++ functione return false
-static int m_StructElement_getPageRef(lua_State * L)
-{
-    GBool b;
-    Ref *r;
-    udstruct *uin, *uout;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_StructElement);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-    r = (Ref *) gmalloc(sizeof(Ref));
-    b = ((StructElement *) uin->d)->getPageRef( *r );
-    if (b) {
-      uout = new_Ref_userdata(L);
-      uout->d = r ;
-      //uout->atype = ALLOC_LEPDF;
-      uout->pc = uin->pc;
-      uout->pd = uin->pd;
-    } else
-      lua_pushboolean(L,0);
-    return 1;
-}
-
-
-
-static int m_StructElement_getTypeName(lua_State * L)
-{
-    udstruct *uin;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_StructElement);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-    lua_pushstring(L, ((StructElement *) uin->d)->getTypeName());
-    return 1;
-}
-
-
-static int m_StructElement_setRevision(lua_State * L)
-{
-    Guint i;
-    udstruct *uin;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_StructElement);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-    i = (Guint) luaL_checkint(L, 2);
-    ((StructElement *) uin->d)->setRevision(i);
-    return 0;
-}
-
-static int m_StructElement_getText(lua_State * L)
-{
-    GBool i;
-    GooString *gs;
-    udstruct *uin;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_StructElement);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-    i = (GBool) lua_toboolean(L, 2);
-    gs =  ((StructElement *) uin->d)->getText(i);
-    if (gs != NULL)
-        lua_pushlstring(L, gs->getCString(), gs->getLength());
-    else
-        lua_pushnil(L);
-    return 1;
-}
-
-
-static int m_StructElement_getChild(lua_State * L)
-{
-    StructElement *c;
-    int i;
-    udstruct *uin, *uout;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_StructElement);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-    i = (int) luaL_checkint(L, 2);
-    c =  ((StructElement *) uin->d)->getChild(i-1);
-    if (c != NULL) {
-      uout = new_StructElement_userdata(L);
-      uout->d = c ;
-      //uout->atype = ALLOC_LEPDF;
-      uout->pc = uin->pc;
-      uout->pd = uin->pd;
-    }
-    else
-        lua_pushnil(L);
-    return 1;
-}
-
-
-static int m_StructElement_appendChild(lua_State * L)
-{
-    udstruct *uin, *uin1;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_StructElement);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-    uin1 = (udstruct *) luaL_checkudata(L, 2, M_StructElement);
-    if (uin1->pd != NULL && uin1->pd->pc != uin1->pc)
-        pdfdoc_changed_error(L);
-    ((StructElement *) uin->d)->appendChild( (StructElement *)uin1->d );
-    return 0;
-}
-
-
-static int m_StructElement_getAttribute(lua_State * L)
-{
-    Attribute *a;
-    int i;
-    udstruct *uin, *uout;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_StructElement);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-    i = (int) luaL_checkint(L, 2);
-    a =  ((StructElement *) uin->d)->getAttribute(i-1);
-    if (a != NULL) {
-      uout = new_Attribute_userdata(L);
-      uout->d = a ;
-      uout->pc = uin->pc;
-      uout->pd = uin->pd;
-    }
-    else
-        lua_pushnil(L);
-    return 1;
-}
-
-
-
-static int m_StructElement_appendAttribute(lua_State * L)
-{
-
-    udstruct *uin, *uin1;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_StructElement);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-    uin1 = (udstruct *) luaL_checkudata(L, 2, M_Attribute);
-    if (uin1->pd != NULL && uin1->pd->pc != uin1->pc)
-        pdfdoc_changed_error(L);
-    ((StructElement *) uin->d)->appendAttribute( (Attribute *)uin1->d );
-    return 0;
-}
-
-
-static int m_StructElement_findAttribute(lua_State * L)
-{
-    Attribute::Type t;
-    Attribute::Owner o;
-    GBool g;
-    udstruct *uin, *uout;
-    const Attribute *a;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_StructElement);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-    t = (Attribute::Type) luaL_checkint(L,1);
-    o = (Attribute::Owner) luaL_checkint(L,2);
-    g = (GBool) lua_toboolean(L, 3);
-    a = ((StructElement *) uin->d)->findAttribute(t,g,o);
-
-    if (a!=NULL){
-      uout = new_Attribute_userdata(L);
-      uout->d = new Attribute(a->getType(),a->getValue());
-      uout->atype = ALLOC_LEPDF;
-      uout->pc = uin->pc;
-      uout->pd = uin->pd;
-    } else
-        lua_pushnil(L);
-    return 1;
-}
-
-// This returns a lua table
-static int m_StructElement_getTextSpans(lua_State * L)
-{
-    int i ;
-    udstruct *uin, *uout;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_StructElement);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-
-    if ((((StructElement *) uin->d)->getTextSpans()).size()>0) {
-      lua_createtable (L,
-		       (int) (((StructElement *) uin->d)->getTextSpans()).size(),
-		       0);
-      for(i=0;i<(int) (((StructElement *) uin->d)->getTextSpans()).size(); i++){
-	uout = new_TextSpan_userdata(L);
-	uout->d = new TextSpan( (((StructElement *) uin->d)->getTextSpans())[i] );
-	uout->atype = ALLOC_LEPDF;
-	uout->pc = uin->pc;
-	uout->pd = uin->pd;
-	lua_rawseti(L,-2,i+1);
-      }
-    } else
-      lua_pushnil(L);
-    return 1;
-}
-
-
-
-static const struct luaL_Reg StructElement_m[] = {
-  {"getTypeName", m_StructElement_getTypeName},
-  {"getType",m_StructElement_getType},
-  {"isOk",m_StructElement_isOk},
-  {"isBlock",m_StructElement_isBlock},
-  {"isInline",m_StructElement_isInline},
-  {"isGrouping",m_StructElement_isGrouping},
-  {"isContent",m_StructElement_isContent},
-  {"isObjectRef",m_StructElement_isObjectRef},
-  {"getMCID",m_StructElement_getMCID},
-  {"getObjectRef",m_StructElement_getObjectRef},
-  {"getParentRef",m_StructElement_getParentRef},
-  {"hasPageRef",m_StructElement_hasPageRef},
-  {"getPageRef",m_StructElement_getPageRef},
-  {"getStructTreeRoot",m_StructElement_getStructTreeRoot},
-  {"getID",m_StructElement_getID},
-  {"getLanguage",m_StructElement_getLanguage},
-  {"getRevision",m_StructElement_getRevision},
-  {"setRevision",m_StructElement_setRevision},
-  {"getTitle",m_StructElement_getTitle},
-  {"getExpandedAbbr",m_StructElement_getExpandedAbbr},
-  {"getNumChildren",m_StructElement_getNumChildren},
-  {"getChild",m_StructElement_getChild},
-  {"appendChild",m_StructElement_appendChild},
-  {"getNumAttributes",m_StructElement_getNumAttributes},
-  {"getAttribute",m_StructElement_getAttribute},
-  {"appendAttribute",m_StructElement_appendAttribute},
-  {"findAttribute",m_StructElement_findAttribute},
-  {"getAltText",m_StructElement_getAltText},
-  {"getActualText",m_StructElement_getActualText},
-  {"getText",m_StructElement_getText},
-  {"getTextSpans",m_StructElement_getTextSpans},
-  {"__tostring", m_StructElement__tostring},
-  {NULL, NULL}                // sentinel
-};
-
-
-//**********************************************************************
-// StructTreeRoot
-
-m_poppler_get_INT(StructTreeRoot, getNumChildren);
-m_poppler_get_poppler(StructTreeRoot, PDFDoc, getDoc);
-m_poppler_get_poppler(StructTreeRoot, Dict, getRoleMap);
-m_poppler_get_poppler(StructTreeRoot, Dict, getClassMap);
-m_poppler__tostring(StructTreeRoot);
-
-static int m_StructTreeRoot_getChild(lua_State * L)
-{
-    unsigned int i;
-    udstruct *uin, *uout;
-    StructElement *child ;
-    StructTreeRoot *root ;
-
-    uin = (udstruct *) luaL_checkudata(L, 1, M_StructTreeRoot);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-    i = (unsigned) luaL_checkint(L, 2);
-    root = (StructTreeRoot *) uin->d;
-    if (i-1 < root->getNumChildren() ){
-       child = root->getChild(i-1);
-       uout = new_StructElement_userdata(L);
-       uout->d = child;
-       //uout->atype = ALLOC_LEPDF;
-       uout->pc = uin->pc;
-       uout->pd = uin->pd;
-    } else
-      lua_pushnil(L);
-    return 1;
-}
-
-static int m_StructTreeRoot_appendChild(lua_State * L)
-{
-    udstruct *uin, *uin_child;
-    StructElement *child ;
-    StructTreeRoot *root ;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_StructTreeRoot);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-    uin_child = (udstruct *) luaL_checkudata(L, 2, M_StructElement);
-    if (uin_child->pd != NULL && uin_child->pd->pc != uin_child->pc)
-        pdfdoc_changed_error(L);
-    root = (StructTreeRoot *) uin->d;
-    child = (StructElement *) uin_child->d;
-    root->appendChild(child);
-    return 0;
-}
-
-
-static int m_StructTreeRoot_findParentElement(lua_State * L)
-{
-    unsigned int i;
-    udstruct *uin,  *uout;
-    const StructElement *parent ;
-    StructTreeRoot *root ;
-
-    uin = (udstruct *) luaL_checkudata(L, 1, M_StructTreeRoot);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-    i = (unsigned) luaL_checkint(L, 2);
-    root = (StructTreeRoot *) uin->d;
-    parent = root->findParentElement(i-1);
-    if (parent != NULL) {
-       uout = new_StructElement_userdata(L);
-       // see https://isocpp.org/wiki/faq/const-correctness#aliasing-and-const
-       uout->d = (StructElement *) parent;
-       uout->atype = ALLOC_LEPDF;
-       uout->pc = uin->pc;
-       uout->pd = uin->pd;
-    } else
-      lua_pushnil(L);
-    return 1;
-}
-
-
-static const struct luaL_Reg StructTreeRoot_m[] = {
-  {"getDoc",m_StructTreeRoot_getDoc},
-  {"getRoleMap",m_StructTreeRoot_getRoleMap},
-  {"getClassMap",m_StructTreeRoot_getClassMap},
-  {"getNumChildren",m_StructTreeRoot_getNumChildren},
-  {"getChild",m_StructTreeRoot_getChild},
-  {"appendChild",m_StructTreeRoot_appendChild},
-  {"findParentElement",m_StructTreeRoot_findParentElement},
-  {"__tostring", m_StructTreeRoot__tostring},
-  {NULL, NULL}                // sentinel
-};
-
-//**********************************************************************
-// XRef
-
-m_poppler_get_BOOL(XRef, isOk);
-m_poppler_get_INT(XRef, getErrorCode);
-m_poppler_get_BOOL(XRef, isEncrypted);
-m_poppler_get_BOOL(XRef, okToPrint);
-m_poppler_get_BOOL(XRef, okToPrintHighRes);
-m_poppler_get_BOOL(XRef, okToChange);
-m_poppler_get_BOOL(XRef, okToCopy);
-m_poppler_get_BOOL(XRef, okToAddNotes);
-m_poppler_get_BOOL(XRef, okToFillForm);
-m_poppler_get_BOOL(XRef, okToAccessibility);
-m_poppler_get_BOOL(XRef, okToAssemble);
-m_poppler_get_OBJECT(XRef, getCatalog);
-
-static int m_XRef_fetch(lua_State * L)
-{
-    int num, gen;
-    udstruct *uin, *uout;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_XRef);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-    num = luaL_checkint(L, 2);
-    gen = luaL_checkint(L, 3);
-    uout = new_Object_userdata(L);
-    uout->d = new Object();
-    *((Object *) uout->d) = ((XRef *) uin->d)->fetch(num, gen);
-    uout->atype = ALLOC_LEPDF;
-    uout->pc = uin->pc;
-    uout->pd = uin->pd;
-    return 1;
-}
-
-m_poppler_get_OBJECT(XRef, getDocInfo);
-m_poppler_get_OBJECT(XRef, getDocInfoNF);
-m_poppler_get_INT(XRef, getNumObjects);
-m_poppler_get_INT(XRef, getRootNum);
-m_poppler_get_INT(XRef, getRootGen);
-// getStreamEnd
-
-static int m_XRef_getNumEntry(lua_State * L)
-{
-    int i, offset;
-    udstruct *uin;
-    uin = (udstruct *) luaL_checkudata(L, 1, M_XRef);
-    if (uin->pd != NULL && uin->pd->pc != uin->pc)
-        pdfdoc_changed_error(L);
-    offset = luaL_checkint(L, 2);
-    i = ((XRef *) uin->d)->getNumEntry(offset);
-    if (i >= 0)
-        lua_pushinteger(L, i);
-    else
-        lua_pushnil(L);
-    return 1;
-}
-
-m_poppler_get_poppler(XRef, Object, getTrailerDict);
-
-m_poppler__tostring(XRef);
-
-static const struct luaL_Reg XRef_m[] = {
-    {"isOk", m_XRef_isOk},
-    {"getErrorCode", m_XRef_getErrorCode},
-    {"isEncrypted", m_XRef_isEncrypted},
-    {"okToPrint", m_XRef_okToPrint},
-    {"okToPrintHighRes", m_XRef_okToPrintHighRes},
-    {"okToChange", m_XRef_okToChange},
-    {"okToCopy", m_XRef_okToCopy},
-    {"okToAddNotes", m_XRef_okToAddNotes},
-    {"okToFillForm", m_XRef_okToFillForm},
-    {"okToAccessibility", m_XRef_okToAccessibility},
-    {"okToAssemble", m_XRef_okToAssemble},
-    {"getCatalog", m_XRef_getCatalog},
-    {"fetch", m_XRef_fetch},
-    {"getDocInfo", m_XRef_getDocInfo},
-    {"getDocInfoNF", m_XRef_getDocInfoNF},
-    {"getNumObjects", m_XRef_getNumObjects},
-    {"getRootNum", m_XRef_getRootNum},
-    {"getRootGen", m_XRef_getRootGen},
-    // {"getStreamEnd", m_XRef_getStreamEnd},
-    {"getNumEntry", m_XRef_getNumEntry},
-    {"getTrailerDict", m_XRef_getTrailerDict},
-    {"__tostring", m_XRef__tostring},
-    {NULL, NULL}                // sentinel
-};
-
-//**********************************************************************
-// XRefEntry
-
-m_poppler__tostring(XRefEntry);
-
-static const struct luaL_Reg XRefEntry_m[] = {
-    {"__tostring", m_XRefEntry__tostring},
-    {NULL, NULL}                // sentinel
-};
-
-//**********************************************************************
-
-#ifdef LuajitTeX
-#define setfuncs_meta(type)                 \
-    luaL_newmetatable(L, M_##type);         \
-    lua_pushvalue(L, -1);                   \
-    lua_setfield(L, -2, "__index");         \
-    lua_pushstring(L, "no user access");    \
-    lua_setfield(L, -2, "__metatable");     \
-    luaL_openlib(L, NULL, type##_m, 0)
-#else
-#define setfuncs_meta(type)                 \
-    luaL_newmetatable(L, M_##type);         \
-    lua_pushvalue(L, -1);                   \
-    lua_setfield(L, -2, "__index");         \
-    lua_pushstring(L, "no user access");    \
-    lua_setfield(L, -2, "__metatable");     \
-    luaL_setfuncs(L, type##_m, 0)
-#endif
-
-int luaopen_epdf(lua_State * L)
-{
-    setfuncs_meta(Annot);
-    setfuncs_meta(Annots);
-    setfuncs_meta(Array);
-    setfuncs_meta(Catalog);
-    setfuncs_meta(Dict);
-    setfuncs_meta(EmbFile);
-    setfuncs_meta(FileSpec);
-    setfuncs_meta(GooString);
-    setfuncs_meta(LinkDest);
-    setfuncs_meta(Links);
-    setfuncs_meta(Object);
-    setfuncs_meta(Page);
-    setfuncs_meta(PDFDoc);
-    setfuncs_meta(PDFRectangle);
-    setfuncs_meta(Ref);
-    setfuncs_meta(Stream);
-    setfuncs_meta(Attribute);
-    setfuncs_meta(StructElement);
-    setfuncs_meta(StructTreeRoot);
-    setfuncs_meta(TextSpan);
-    setfuncs_meta(XRef);
-    setfuncs_meta(XRefEntry);
-    luaL_openlib(L, "epdf", epdflib_f, 0);
-    return 1;
-}
diff --git a/texk/web2c/luatexdir/lua/lfontlib.c b/texk/web2c/luatexdir/lua/lfontlib.c
index a709e42c4..2592ffba6 100644
--- a/texk/web2c/luatexdir/lua/lfontlib.c
+++ b/texk/web2c/luatexdir/lua/lfontlib.c
@@ -324,7 +324,9 @@ static int l_vf_char(lua_State * L)
     }
     mat_p = &(vsp->packet_stack[vsp->packet_stack_level]);
     w = char_width(lf, k);
-    mat_p->pos.h += round_xn_over_d(w, 1000 + ex_glyph, 1000);
+    if (ex_glyph != 0)
+        w = round_xn_over_d(w, 1000 + ex_glyph, 1000);
+    mat_p->pos.h += w;
     synch_pos_with_cur(static_pdf->posstruct, vsp->refpos, mat_p->pos);
     return 0;
 }
@@ -416,11 +418,14 @@ static int l_vf_right(lua_State * L)
 {
     scaled i;
     vf_struct *vsp = static_pdf->vfstruct;
+    int ex_glyph = vsp->ex_glyph/1000;
     packet_stack_record *mat_p;
     if (!vsp->vflua)
         normal_error("vf", "vf.right() outside virtual font");
     mat_p = &(vsp->packet_stack[vsp->packet_stack_level]);
     i = (scaled) luaL_checkinteger(L, 1);
+    if (ex_glyph != 0 && i != 0) /* new, experiment */
+        i = round_xn_over_d(i, 1000 + ex_glyph, 1000);
     i = store_scaled_f(i, vsp->fs_f);
     mat_p->pos.h += i;
     synch_pos_with_cur(static_pdf->posstruct, vsp->refpos, mat_p->pos);
@@ -431,11 +436,14 @@ static int l_vf_rule(lua_State * L)
 {
     scaledpos size;
     vf_struct *vsp = static_pdf->vfstruct;
+    int ex_glyph = vsp->ex_glyph/1000;
     packet_stack_record *mat_p;
     if (!vsp->vflua)
         normal_error("vf", "vf.rule() outside virtual font");
     size.h = (scaled) luaL_checkinteger(L, 1);
     size.v = (scaled) luaL_checkinteger(L, 2);
+    if (ex_glyph != 0 && size.h > 0) /* new, experiment */
+        size.h = round_xn_over_d(size.h, 1000 + ex_glyph, 1000);
     size.h = store_scaled_f(size.h, vsp->fs_f);
     size.v = store_scaled_f(size.v, vsp->fs_f);
     if (size.h > 0 && size.v > 0)
@@ -460,6 +468,16 @@ static int l_vf_special(lua_State * L)
     return 0;
 }
 
+static int l_vf_pdf(lua_State * L)
+{
+    vf_struct *vsp = static_pdf->vfstruct;
+    if (!vsp->vflua)
+        normal_error("vf", "vf.special() outside virtual font");
+    luapdfprint(L);
+    pdf_out(static_pdf, '\n');
+    return 0;
+}
+
 static const struct luaL_Reg vflib[] = {
     {"char", l_vf_char},
     {"down", l_vf_down},
@@ -476,6 +494,7 @@ static const struct luaL_Reg vflib[] = {
     /* {"scale", l_vf_scale}, */
     /* {"slot", l_vf_slot}, */
     {"special", l_vf_special},
+    {"pdf", l_vf_pdf},
     {NULL, NULL}                /* sentinel */
 };
 
diff --git a/texk/web2c/luatexdir/lua/limglib.c b/texk/web2c/luatexdir/lua/limglib.c
index f9d863eef..ce2b4b7b5 100644
--- a/texk/web2c/luatexdir/lua/limglib.c
+++ b/texk/web2c/luatexdir/lua/limglib.c
@@ -24,7 +24,7 @@
 #include "lua.h"
 #include "lauxlib.h"
 
-#define img_types_max 7
+#define img_types_max 8
 
 const char *img_types[] = {
     "none",
@@ -243,6 +243,26 @@ static void write_image_or_node(lua_State * L, wrtype_e writetype)
         img_state(ad) = DICT_REFERED;
 }
 
+static int write_image_object(lua_State * L, wrtype_e writetype)
+{
+    image *a, **aa;
+    image_dict *ad;
+    int num;
+    if (lua_gettop(L) != 2)
+        luaL_error(L, "%s expects two argument", wrtype_s[writetype]);
+    aa = (image **) luaL_checkudata(L, 1, TYPE_IMG);
+    a = *aa;
+    ad = img_dict(a);
+
+    read_img(ad);
+
+    /*   setup_image(static_pdf, a, writetype); */
+    num = (int) lua_tointeger(L, 2);
+    num = write_img_object(static_pdf, ad, num);
+    lua_pushinteger(L,num);
+    return 1;
+}
+
 static int l_write_image(lua_State * L)
 {
     write_image_or_node(L, WR_WRITE);
@@ -260,6 +280,17 @@ static int l_immediatewrite_image(lua_State * L)
     return 1;
 }
 
+static int l_immediatewrite_image_object(lua_State * L)
+{
+    check_o_mode(static_pdf, "img.immediatewriteobject", 1 << OMODE_PDF, true);
+    if (global_shipping_mode != NOT_SHIPPING) {
+        luaL_error(L, "img.immediatewriteobject can not be used with \\latelua");
+    } else {
+        write_image_object(L, WR_IMMEDIATEWRITE);
+    }
+    return 1;
+}
+
 static int l_image_node(lua_State * L)
 {
     write_image_or_node(L, WR_NODE);
@@ -273,7 +304,7 @@ static int l_image_keys(lua_State * L)
 
 static int l_image_types(lua_State * L)
 {
-    return lua_show_valid_list(L, img_types, img_types_max);
+    return lua_show_valid_list(L, img_types, 0, img_types_max);
 }
 
 static int l_image_boxes(lua_State * L)
@@ -287,10 +318,13 @@ static const struct luaL_Reg imglib_f[] = {
     { "scan", l_scan_image },
     { "write", l_write_image },
     { "immediatewrite", l_immediatewrite_image },
+    { "immediatewriteobject", l_immediatewrite_image_object },
     { "node", l_image_node },
-    { "keys", l_image_keys },
+    { "fields", l_image_keys },
     { "types", l_image_types },
     { "boxes", l_image_boxes },
+    /* for a while: */
+    { "keys", l_image_keys },
     { NULL, NULL }
 };
 
@@ -348,14 +382,10 @@ static int m_img_get(lua_State * L)
         } else {
             lua_pushstring(L, img_filename(d));
         }
-    } else if (lua_key_eq(s,visiblefilename)) {
-        if (img_visiblefilename(d) == NULL || strlen(img_visiblefilename(d)) == 0) {
-            lua_pushnil(L);
-        } else {
-            lua_pushstring(L, img_visiblefilename(d));
-        }
     } else if (lua_key_eq(s,keepopen)) {
         lua_pushboolean(L, img_keepopen(d));
+    } else if (lua_key_eq(s,nolength)) {
+        lua_pushboolean(L, img_nolength(d));
     } else if (lua_key_eq(s,filepath)) {
         if (img_filepath(d) == NULL || strlen(img_filepath(d)) == 0) {
             lua_pushnil(L);
@@ -461,10 +491,28 @@ static int m_img_get(lua_State * L)
         if (img_type(d) != IMG_TYPE_PDFSTREAM
                 || img_pdfstream_ptr(d) == NULL
                 || img_pdfstream_stream(d) == NULL
-                || strlen(img_pdfstream_stream(d)) == 0) {
+                || img_pdfstream_size(d) == 0) {
+            lua_pushnil(L);
+        } else {
+            lua_pushlstring(L, img_pdfstream_stream(d), img_pdfstream_size(d));
+        }
+    } else if (lua_key_eq(s,visiblefilename)) {
+        if (img_visiblefilename(d) == NULL || strlen(img_visiblefilename(d)) == 0) {
+            lua_pushnil(L);
+        } else {
+            lua_pushstring(L, img_visiblefilename(d));
+        }
+    } else if (lua_key_eq(s,userpassword)) {
+        if (img_userpassword(d) == NULL || strlen(img_userpassword(d)) == 0) {
+            lua_pushnil(L);
+        } else {
+            lua_pushstring(L, img_userpassword(d));
+        }
+    } else if (lua_key_eq(s,ownerpassword)) {
+        if (img_ownerpassword(d) == NULL || strlen(img_ownerpassword(d)) == 0) {
             lua_pushnil(L);
         } else {
-            lua_pushstring(L, img_pdfstream_stream(d));
+            lua_pushstring(L, img_ownerpassword(d));
         }
     } else if (lua_key_eq(s,ref_count)) {
         lua_pushinteger(L, img_luaref(d));
@@ -520,7 +568,7 @@ static void lua_to_image(lua_State * L, image * a, image_dict * d)
         if (img_state(d) >= DICT_FILESCANNED) {
             luaL_error(L, "image.filename is now read-only");
         } else if (img_type(d) == IMG_TYPE_PDFSTREAM) {
-            luaL_error(L, "image.filename can't be used with image.stream");
+            /* just ignore */
         } else if (t == LUA_TSTRING) {
             xfree(img_filename(d));
             img_filename(d) = xstrdup(lua_tostring(L, -1));
@@ -531,13 +579,35 @@ static void lua_to_image(lua_State * L, image * a, image_dict * d)
         if (img_state(d) >= DICT_FILESCANNED) {
             luaL_error(L, "image.visiblefilename is now read-only");
         } else if (img_type(d) == IMG_TYPE_PDFSTREAM) {
-            luaL_error(L, "image.visiblefilename can't be used with image.stream");
+            img_visiblefilename(d) = NULL;
         } else if (t == LUA_TSTRING) {
             xfree(img_visiblefilename(d));
             img_visiblefilename(d) = xstrdup(lua_tostring(L, -1));
         } else {
             luaL_error(L, "image.visiblefilename needs string value");
         }
+    } else if (lua_key_eq(s,userpassword)) {
+        if (img_state(d) >= DICT_FILESCANNED) {
+            luaL_error(L, "image.userpassword is now read-only");
+        } else if (img_type(d) == IMG_TYPE_PDFSTREAM) {
+            img_userpassword(d) = NULL;
+        } else if (t == LUA_TSTRING) {
+            xfree(img_userpassword(d));
+            img_userpassword(d) = xstrdup(lua_tostring(L, -1));
+        } else {
+            luaL_error(L, "image.userpassword needs string value");
+        }
+    } else if (lua_key_eq(s,ownerpassword)) {
+        if (img_state(d) >= DICT_FILESCANNED) {
+            luaL_error(L, "image.ownerpassword is now read-only");
+        } else if (img_type(d) == IMG_TYPE_PDFSTREAM) {
+            img_ownerpassword(d) = NULL;
+        } else if (t == LUA_TSTRING) {
+            xfree(img_ownerpassword(d));
+            img_ownerpassword(d) = xstrdup(lua_tostring(L, -1));
+        } else {
+            luaL_error(L, "image.ownerpassword needs string value");
+        }
     } else if (lua_key_eq(s,attr)) {
         if (img_state(d) >= DICT_FILESCANNED) {
             luaL_error(L, "image.attr is now read-only");
@@ -607,6 +677,8 @@ static void lua_to_image(lua_State * L, image * a, image_dict * d)
         } else {
             img_keepopen(d) = lua_toboolean(L, -1);
         }
+    } else if (lua_key_eq(s,nolength)) {
+        img_nolength(d) = lua_toboolean(L, -1);
     } else if (lua_key_eq(s,bbox)) {
         if (img_state(d) >= DICT_FILESCANNED) {
             luaL_error(L, "image.bbox is now read-only");
@@ -636,11 +708,15 @@ static void lua_to_image(lua_State * L, image * a, image_dict * d)
         } else if (img_state(d) >= DICT_FILESCANNED) {
             luaL_error(L, "image.stream is now read-only");
         } else {
+            size_t size = 0;
+            const char *stream = lua_tolstring(L, -1, &size);
             if (img_pdfstream_ptr(d) == NULL) {
                 new_img_pdfstream_struct(d);
             }
             xfree(img_pdfstream_stream(d));
-            img_pdfstream_stream(d) = xstrdup(lua_tostring(L, -1));
+            img_pdfstream_size(d) = size;
+            img_pdfstream_stream(d) = xmalloc(size);
+            memcpy(img_pdfstream_stream(d),stream,size);
             img_type(d) = IMG_TYPE_PDFSTREAM;
         }
     } else {
diff --git a/texk/web2c/luatexdir/lua/liolibext.c b/texk/web2c/luatexdir/lua/liolibext.c
index 29ad8447a..71b9b41d1 100644
--- a/texk/web2c/luatexdir/lua/liolibext.c
+++ b/texk/web2c/luatexdir/lua/liolibext.c
@@ -125,7 +125,7 @@ static int readcardinal1_s(lua_State *L) {
     size_t l;
     const char *s = luaL_checklstring(L, 1, &l);
     size_t p = luaL_checkinteger(L, 2) - 1;
-    if (p < 0 || p >= l) {
+    if (p >= l) {
         lua_pushnil(L);
     } else {
         int a = uchar(s[p]);
@@ -150,7 +150,7 @@ static int readcardinal2_s(lua_State *L) {
     size_t l;
     const char *s = luaL_checklstring(L, 1, &l);
     size_t p = luaL_checkinteger(L, 2) - 1;
-    if (p < 0 || p+1 >= l) {
+    if (p+1 >= l) {
         lua_pushnil(L);
     } else {
         int a = uchar(s[p++]);
@@ -177,7 +177,7 @@ static int readcardinal3_s(lua_State *L) {
     size_t l;
     const char *s = luaL_checklstring(L, 1, &l);
     size_t p = luaL_checkinteger(L, 2) - 1;
-    if (p < 0 || p+2 >= l) {
+    if (p+2 >= l) {
         lua_pushnil(L);
     } else {
         int a = uchar(s[p++]);
@@ -206,7 +206,7 @@ static int readcardinal4_s(lua_State *L) {
     size_t l;
     const char *s = luaL_checklstring(L, 1, &l);
     size_t p = luaL_checkinteger(L, 2) - 1;
-    if (p < 0 || p+3 >= l) {
+    if (p+3 >= l) {
         lua_pushnil(L);
     } else {
         int a = uchar(s[p++]);
@@ -218,6 +218,139 @@ static int readcardinal4_s(lua_State *L) {
     return 1;
 }
 
+static int readcardinaltable(lua_State *L) {
+    FILE *f = tofile(L);
+    int n = lua_tointeger(L,2);
+    int b = lua_tointeger(L,3);
+    int i;
+    lua_createtable(L,n,0);
+    switch (b) {
+        case 1:
+            for (i=1;i<=n;i++) {
+                int a = getc(f);
+                if (a == EOF) {
+                    break;
+                } else {
+                    lua_pushinteger(L, a);
+                    lua_rawseti(L, -2, i);
+                }
+            }
+            break;
+        case 2:
+            for (i=1;i<=n;i++) {
+                int a = getc(f);
+                int b = getc(f);
+                if (b == EOF) {
+                    break;
+                } else {
+                    /* (a<<8) | b */
+                    lua_pushinteger(L, 0x100 * a + b);
+                    lua_rawseti(L, -2, i);
+                }
+            }
+            break;
+        case 3:
+            for (i=1;i<=n;i++) {
+                int a = getc(f);
+                int b = getc(f);
+                int c = getc(f);
+                if (c == EOF) {
+                    break;
+                } else {
+                    /* (a<<16) | (b<<8) | c */
+                    lua_pushinteger(L, 0x10000 * a + 0x100 * b + c);
+                    lua_rawseti(L, -2, i);
+                }
+            }
+            break;
+        case 4:
+            for (i=1;i<=n;i++) {
+                int a = getc(f);
+                int b = getc(f);
+                int c = getc(f);
+                int d = getc(f);
+                if (d == EOF) {
+                    break;
+                } else {
+                    /* (a<<24) | (b<<16) | (c<<8) | d */
+                    lua_pushinteger(L,0x1000000 * a + 0x10000 * b + 0x100 * c + d);
+                    lua_rawseti(L, -2, i);
+                }
+            }
+            break;
+        default:
+            break;
+    }
+    return 1;
+}
+
+static int readcardinaltable_s(lua_State *L) {
+    size_t l;
+    const char *s = luaL_checklstring(L, 1, &l);
+    size_t p = luaL_checkinteger(L, 2) - 1;
+    int n = lua_tointeger(L,3);
+    int b = lua_tointeger(L,4);
+    int i;
+    lua_createtable(L,n,0);
+    /*if (p >= 0) {*/
+        switch (b) {
+            case 1:
+                for (i=1;i<=n;i++) {
+                    if (p >= l) {
+                        break;
+                    } else {
+                        int a = uchar(s[p++]);
+                        lua_pushinteger(L, a);
+                        lua_rawseti(L, -2, i);
+                    }
+                }
+                break;
+            case 2:
+                for (i=1;i<=n;i++) {
+                    if (p+1 >= l) {
+                        break;
+                    } else {
+                        int a = uchar(s[p++]);
+                        int b = uchar(s[p++]);
+                        lua_pushinteger(L, 0x100 * a + b);
+                        lua_rawseti(L, -2, i);
+                    }
+                }
+                break;
+            case 3:
+                for (i=1;i<=n;i++) {
+                    if (p+2 >= l) {
+                        break;
+                    } else {
+                        int a = uchar(s[p++]);
+                        int b = uchar(s[p++]);
+                        int c = uchar(s[p++]);
+                        lua_pushinteger(L, 0x10000 * a + 0x100 * b + c);
+                        lua_rawseti(L, -2, i);
+                    }
+                }
+                break;
+            case 4:
+                for (i=1;i<=n;i++) {
+                    if (p+3 >= l) {
+                        break;
+                    } else {
+                        int a = uchar(s[p++]);
+                        int b = uchar(s[p++]);
+                        int c = uchar(s[p++]);
+                        int d = uchar(s[p++]);
+                        lua_pushinteger(L,0x1000000 * a + 0x10000 * b + 0x100 * c + d);
+                        lua_rawseti(L, -2, i);
+                    }
+                }
+                break;
+            default:
+                break;
+        }
+    /*}*/
+    return 1;
+}
+
 static int readinteger1(lua_State *L) {
     FILE *f = tofile(L);
     int a = getc(f);
@@ -234,7 +367,7 @@ static int readinteger1_s(lua_State *L) {
     size_t l;
     const char *s = luaL_checklstring(L, 1, &l);
     size_t p = luaL_checkinteger(L, 2) - 1;
-    if (p < 0 || p >= l) {
+    if (p >= l) {
         lua_pushnil(L);
     } else {
         int a = uchar(s[p]);
@@ -263,7 +396,7 @@ static int readinteger2_s(lua_State *L) {
     size_t l;
     const char *s = luaL_checklstring(L, 1, &l);
     size_t p = luaL_checkinteger(L, 2) - 1;
-    if (p < 0 || p+1 >= l) {
+    if (p+1 >= l) {
         lua_pushnil(L);
     } else {
         int a = uchar(s[p++]);
@@ -294,7 +427,7 @@ static int readinteger3_s(lua_State *L) {
     size_t l;
     const char *s = luaL_checklstring(L, 1, &l);
     size_t p = luaL_checkinteger(L, 2) - 1;
-    if (p < 0 || p+2 >= l) {
+    if (p+2 >= l) {
         lua_pushnil(L);
     } else {
         int a = uchar(s[p++]);
@@ -327,7 +460,7 @@ static int readinteger4_s(lua_State *L) {
     size_t l;
     const char *s = luaL_checklstring(L, 1, &l);
     size_t p = luaL_checkinteger(L, 2) - 1;
-    if (p < 0 || p+3 >= l) {
+    if (p+3 >= l) {
         lua_pushnil(L);
     } else {
         int a = uchar(s[p++]);
@@ -342,6 +475,160 @@ static int readinteger4_s(lua_State *L) {
     return 1;
 }
 
+static int readintegertable(lua_State *L) {
+    FILE *f = tofile(L);
+    int n = lua_tointeger(L,2);
+    int b = lua_tointeger(L,3);
+    int i;
+    lua_createtable(L,n,0);
+    switch (b) {
+        case 1:
+            for (i=1;i<=n;i++) {
+                int a = getc(f);
+                if (a == EOF) {
+                    break;
+                } else if (a >= 0x80) {
+                    lua_pushinteger(L, a - 0x100);
+                } else {
+                    lua_pushinteger(L, a);
+                }
+                lua_rawseti(L, -2, i);
+            }
+            break;
+        case 2:
+            for (i=1;i<=n;i++) {
+                int a = getc(f);
+                int b = getc(f);
+                if (b == EOF) {
+                    break;
+                } else if (a >= 0x80) {
+                    lua_pushinteger(L, 0x100 * a + b - 0x10000);
+                } else {
+                    lua_pushinteger(L, 0x100 * a + b);
+                }
+                lua_rawseti(L, -2, i);
+            }
+            break;
+        case 3:
+            for (i=1;i<=n;i++) {
+                int a = getc(f);
+                int b = getc(f);
+                int c = getc(f);
+                if (c == EOF) {
+                    break;
+                } else if (a >= 0x80) {
+                    lua_pushinteger(L, 0x10000 * a + 0x100 * b + c - 0x1000000);
+                } else {
+                    lua_pushinteger(L, 0x10000 * a + 0x100 * b + c);
+                }
+                lua_rawseti(L, -2, i);
+            }
+            break;
+        case 4:
+            for (i=1;i<=n;i++) {
+                int a = getc(f);
+                int b = getc(f);
+                int c = getc(f);
+                int d = getc(f);
+                if (d == EOF) {
+                    break;
+                } else if (a >= 0x80) {
+                    lua_pushinteger(L, 0x1000000 * a + 0x10000 * b + 0x100 * c + d - 0x100000000);
+                } else {
+                    lua_pushinteger(L, 0x1000000 * a + 0x10000 * b + 0x100 * c + d);
+                }
+                lua_rawseti(L, -2, i);
+            }
+            break;
+        default:
+            break;
+    }
+    return 1;
+}
+
+static int readintegertable_s(lua_State *L) {
+    size_t l;
+    const char *s = luaL_checklstring(L, 1, &l);
+    size_t p = luaL_checkinteger(L, 2) - 1;
+    int n = lua_tointeger(L,3);
+    int b = lua_tointeger(L,4);
+    int i;
+    lua_createtable(L,n,0);
+    /*if (p >= 0) {*/
+        switch (b) {
+            case 1:
+                for (i=1;i<=n;i++) {
+                    if (p >= l) {
+                        break;
+                    } else {
+                        int a = uchar(s[p++]);
+                        if (a >= 0x80) {
+                            lua_pushinteger(L, a - 0x100);
+                        } else {
+                            lua_pushinteger(L, a);
+                        }
+                        lua_rawseti(L, -2, i);
+                    }
+                }
+                break;
+            case 2:
+                for (i=1;i<=n;i++) {
+                    if (p+1 >= l) {
+                        break;
+                    } else {
+                        int a = uchar(s[p++]);
+                        int b = uchar(s[p++]);
+                        if (a >= 0x80) {
+                            lua_pushinteger(L, 0x100 * a + b - 0x10000);
+                        } else {
+                            lua_pushinteger(L, 0x100 * a + b);
+                        }
+                        lua_rawseti(L, -2, i);
+                    }
+                }
+                break;
+            case 3:
+                for (i=1;i<=n;i++) {
+                    if (p+2 >= l) {
+                        break;
+                    } else {
+                        int a = uchar(s[p++]);
+                        int b = uchar(s[p++]);
+                        int c = uchar(s[p++]);
+                        if (a >= 0x80) {
+                            lua_pushinteger(L, 0x10000 * a + 0x100 * b + c - 0x1000000);
+                        } else {
+                            lua_pushinteger(L, 0x10000 * a + 0x100 * b + c);
+                        }
+                        lua_rawseti(L, -2, i);
+                    }
+                }
+                break;
+            case 4:
+                for (i=1;i<=n;i++) {
+                    if (p+3 >= l) {
+                        break;
+                    } else {
+                        int a = uchar(s[p++]);
+                        int b = uchar(s[p++]);
+                        int c = uchar(s[p++]);
+                        int d = uchar(s[p++]);
+                        if (a >= 0x80) {
+                            lua_pushinteger(L, 0x1000000 * a + 0x10000 * b + 0x100 * c + d - 0x100000000);
+                        } else {
+                            lua_pushinteger(L, 0x1000000 * a + 0x10000 * b + 0x100 * c + d);
+                        }
+                        lua_rawseti(L, -2, i);
+                    }
+                }
+                break;
+            default:
+                break;
+        }
+    /*}*/
+    return 1;
+}
+
 static int readfixed2(lua_State *L) {
     FILE *f = tofile(L);
     int a = getc(f);
@@ -359,7 +646,7 @@ static int readfixed2_s(lua_State *L) {
     size_t l;
     const char *s = luaL_checklstring(L, 1, &l);
     size_t p = luaL_checkinteger(L, 2) - 1;
-    if (p < 0 || p+3 >= l) {
+    if (p+3 >= l) {
         lua_pushnil(L);
     } else {
         int a = uchar(s[p++]);
@@ -394,7 +681,7 @@ static int readfixed4_s(lua_State *L) {
     size_t l;
     const char *s = luaL_checklstring(L, 1, &l);
     size_t p = luaL_checkinteger(L, 2) - 1;
-    if (p < 0 || p+3 >= l) {
+    if (p+3 >= l) {
         lua_pushnil(L);
     } else {
         int a = uchar(s[p++]);
@@ -427,7 +714,7 @@ static int read2dot14_s(lua_State *L) {
     size_t l;
     const char *s = luaL_checklstring(L, 1, &l);
     size_t p = luaL_checkinteger(L, 2) - 1;
-    if (p < 0 || p+1 >= l) {
+    if (p+1 >= l) {
         lua_pushnil(L);
     } else {
         int a = uchar(s[p++]);
@@ -497,7 +784,7 @@ static int readbytetable_s(lua_State *L) {
     const char *s = luaL_checklstring(L, 1, &l);
     size_t p = luaL_checkinteger(L, 2) - 1;
     int n = lua_tointeger(L,3);
-    if (p < 0 || p >= l) {
+    if (p >= l) {
         lua_pushnil(L);
     } else {
         int i ;
@@ -534,7 +821,7 @@ static int readbytes_s(lua_State *L) {
     const char *s = luaL_checklstring(L, 1, &l);
     size_t p = luaL_checkinteger(L, 2) - 1;
     int n = lua_tointeger(L,3);
-    if (p < 0 || p >= l) {
+    if (p >= l) {
         return 0;
     } else {
         int i ;
@@ -644,44 +931,48 @@ static int readline(lua_State *L)
 
 static const luaL_Reg fiolib[] = {
     /* helpers */
-    { "readcardinal1",   readcardinal1 },
-    { "readcardinal2",   readcardinal2 },
-    { "readcardinal3",   readcardinal3 },
-    { "readcardinal4",   readcardinal4 },
-    { "readinteger1",    readinteger1 },
-    { "readinteger2",    readinteger2 },
-    { "readinteger3",    readinteger3 },
-    { "readinteger4",    readinteger4 },
-    { "readfixed2",      readfixed2 },
-    { "readfixed4",      readfixed4 },
-    { "read2dot14",      read2dot14 },
-    { "setposition",     setposition },
-    { "getposition",     getposition },
-    { "skipposition",    skipposition },
-    { "readbytes",       readbytes },
-    { "readbytetable",   readbytetable },
-    { "readline",        readline },
+    { "readcardinal1",     readcardinal1 },
+    { "readcardinal2",     readcardinal2 },
+    { "readcardinal3",     readcardinal3 },
+    { "readcardinal4",     readcardinal4 },
+    { "readcardinaltable", readcardinaltable },
+    { "readinteger1",      readinteger1 },
+    { "readinteger2",      readinteger2 },
+    { "readinteger3",      readinteger3 },
+    { "readinteger4",      readinteger4 },
+    { "readintegertable",  readintegertable },
+    { "readfixed2",        readfixed2 },
+    { "readfixed4",        readfixed4 },
+    { "read2dot14",        read2dot14 },
+    { "setposition",       setposition },
+    { "getposition",       getposition },
+    { "skipposition",      skipposition },
+    { "readbytes",         readbytes },
+    { "readbytetable",     readbytetable },
+    { "readline",          readline },
     /* extras */
-    { "recordfilename",  recordfilename },
-    { "checkpermission", checkpermission },
+    { "recordfilename",    recordfilename },
+    { "checkpermission",   checkpermission },
     /* done */
     {NULL, NULL}
 };
 
 static const luaL_Reg siolib[] = {
-    { "readcardinal1",   readcardinal1_s },
-    { "readcardinal2",   readcardinal2_s },
-    { "readcardinal3",   readcardinal3_s },
-    { "readcardinal4",   readcardinal4_s },
-    { "readinteger1",    readinteger1_s },
-    { "readinteger2",    readinteger2_s },
-    { "readinteger3",    readinteger3_s },
-    { "readinteger4",    readinteger4_s },
-    { "readfixed2",      readfixed2_s },
-    { "readfixed4",      readfixed4_s },
-    { "read2dot14",      read2dot14_s },
-    { "readbytes",       readbytes_s },
-    { "readbytetable",   readbytetable_s },
+    { "readcardinal1",     readcardinal1_s },
+    { "readcardinal2",     readcardinal2_s },
+    { "readcardinal3",     readcardinal3_s },
+    { "readcardinal4",     readcardinal4_s },
+    { "readcardinaltable", readcardinaltable_s },
+    { "readinteger1",      readinteger1_s },
+    { "readinteger2",      readinteger2_s },
+    { "readinteger3",      readinteger3_s },
+    { "readinteger4",      readinteger4_s },
+    { "readintegertable",  readintegertable_s },
+    { "readfixed2",        readfixed2_s },
+    { "readfixed4",        readfixed4_s },
+    { "read2dot14",        read2dot14_s },
+    { "readbytes",         readbytes_s },
+    { "readbytetable",     readbytetable_s },
     /* done */
     {NULL, NULL}
 };
diff --git a/texk/web2c/luatexdir/lua/llanglib.c b/texk/web2c/luatexdir/lua/llanglib.c
index 382d40944..5855f33fc 100644
--- a/texk/web2c/luatexdir/lua/llanglib.c
+++ b/texk/web2c/luatexdir/lua/llanglib.c
@@ -20,7 +20,6 @@
 #include "ptexlib.h"
 #include "lua/luatex-api.h"
 
-
 #define LANG_METATABLE "luatex.lang"
 
 #define check_islang(L,b) (struct tex_language **)luaL_checkudata(L,b,LANG_METATABLE)
@@ -84,7 +83,6 @@ static int lang_clear_patterns(lua_State * L)
     return 0;
 }
 
-
 static int lang_hyphenation(lua_State * L)
 {
     struct tex_language **lang_ptr;
@@ -137,7 +135,6 @@ static int lang_post_hyphen_char(lua_State * L)
     }
 }
 
-
 static int lang_pre_exhyphen_char(lua_State * L)
 {
     struct tex_language **lang_ptr;
@@ -262,7 +259,6 @@ static int do_lang_hyphenate(lua_State * L)
 }
 
 static const struct luaL_Reg langlib_d[] = {
-    /* *INDENT-OFF* */
     {"clear_patterns",    lang_clear_patterns},
     {"clear_hyphenation", lang_clear_hyphenation},
     {"patterns",          lang_patterns},
@@ -275,13 +271,11 @@ static const struct luaL_Reg langlib_d[] = {
     {"sethjcode",         lang_sethjcode},
     {"gethjcode",         lang_gethjcode},
     {"id",                lang_id},
-    /* *INDENT-ON* */
-    {NULL, NULL}                /* sentinel */
+    /*tex sentinel */
+    {NULL,                NULL}
 };
 
-
 static const struct luaL_Reg langlib[] = {
-    /* *INDENT-OFF* */
     {"clear_patterns",    lang_clear_patterns},
     {"clear_hyphenation", lang_clear_hyphenation},
     {"patterns",          lang_patterns},
@@ -297,17 +291,19 @@ static const struct luaL_Reg langlib[] = {
     {"clean",             do_lang_clean},
     {"hyphenate",         do_lang_hyphenate},
     {"new",               lang_new},
-    /* *INDENT-ON* */
-    {NULL, NULL}                /* sentinel */
+    /*tex sentinel */
+    {NULL,                NULL}
 };
 
-
 int luaopen_lang(lua_State * L)
 {
     luaL_newmetatable(L, LANG_METATABLE);
-    lua_pushvalue(L, -1);       /* push metatable */
-    lua_setfield(L, -2, "__index");     /* metatable.__index = metatable */
-    luaL_openlib(L, NULL, langlib_d, 0);  /* dict methods */
+    /*tex push metatable */
+    lua_pushvalue(L, -1);
+    /*tex metatable.__index = metatable */
+    lua_setfield(L, -2, "__index");
+    /*tex set dict methods */
+    luaL_openlib(L, NULL, langlib_d, 0);
     luaL_openlib(L, "lang", langlib, 0);
     return 1;
 }
diff --git a/texk/web2c/luatexdir/lua/llualib.c b/texk/web2c/luatexdir/lua/llualib.c
index a73e3abf2..ac9b03ffe 100644
--- a/texk/web2c/luatexdir/lua/llualib.c
+++ b/texk/web2c/luatexdir/lua/llualib.c
@@ -20,14 +20,13 @@
 #include "ptexlib.h"
 #include "lua/luatex-api.h"
 
-
-#define LOAD_BUF_SIZE 256
+#define LOAD_BUF_SIZE 64*1024
 #define UINT_MAX32 0xFFFFFFFF
 
 typedef struct {
     unsigned char *buf;
     int size;
-    int done;
+ /* int done; */
     int alloc;
 } bytecode;
 
@@ -95,7 +94,7 @@ void undump_luac_registers(void)
         lua_bytecode_registers = xmalloc((unsigned) (i * sizeof(bytecode)));
         luabytecode_bytes = (unsigned) (i * sizeof(bytecode));
         for (i = 0; i <= (unsigned) luabytecode_max; i++) {
-            lua_bytecode_registers[i].done = 0;
+         /* lua_bytecode_registers[i].done = 0; */
             lua_bytecode_registers[i].size = 0;
             lua_bytecode_registers[i].buf = NULL;
         }
@@ -170,14 +169,18 @@ static int writer(lua_State * L, const void *b, size_t size, void *B)
 static const char *reader(lua_State * L, void *ud, size_t * size)
 {
     bytecode *buf = (bytecode *) ud;
-    (void) L;                   /* for -Wunused */
+    (void) L; /* for -Wunused */
+    /*
     if (buf->done == buf->size) {
         *size = 0;
         buf->done = 0;
         return NULL;
     }
+    */
     *size = (size_t) buf->size;
+    /*
     buf->done = buf->size;
+    */
     return (const char *) buf->buf;
 }
 
@@ -196,7 +199,7 @@ static int get_bytecode(lua_State * L)
 #else
                  "bytecode", NULL)) {
 #endif
-		return luaL_error(L, "bad bytecode register");
+                return luaL_error(L, "bad bytecode register");
             } else {
                 lua_pushvalue(L, -1);
                 bytecode_register_shadow_set(L, k);
@@ -208,6 +211,41 @@ static int get_bytecode(lua_State * L)
     return 1;
 }
 
+void luabytecodecall(int slot)
+{
+    int i;
+    int stacktop = lua_gettop(Luas);
+    lua_active++;
+    if (slot < 0 || slot > luabytecode_max) {
+        luaL_error(Luas, "bytecode register out of range");
+    } else if (bytecode_register_shadow_get(Luas, slot) || lua_bytecode_registers[slot].buf == NULL) {
+        luaL_error(Luas, "undefined bytecode register");
+    } else if (lua_load(Luas, reader, (void *) (lua_bytecode_registers + slot),
+#ifdef LuajitTeX
+             "bytecode"))
+#else
+             "bytecode", NULL))
+#endif
+    {
+        luaL_error(Luas, "bytecode register doesn't load well");
+    } else {
+        int base = lua_gettop(Luas); /* function index */
+        lua_pushinteger(Luas, slot);
+        lua_pushcfunction(Luas, lua_traceback); /* push traceback function */
+        lua_insert(Luas, base); /* put it under chunk  */
+++function_callback_count; /* this will be a dedicated counter */
+        i = lua_pcall(Luas, 1, 0, base);
+        lua_remove(Luas, base); /* remove traceback function */
+        if (i != 0) {
+            lua_gc(Luas, LUA_GCCOLLECT, 0);
+            Luas = luatex_error(Luas, (i == LUA_ERRRUN ? 0 : 1));
+        }
+    }
+
+    lua_settop(Luas,stacktop);
+    lua_active--;
+}
+
 static int set_bytecode(lua_State * L)
 {
     int k, ltype;
@@ -244,7 +282,7 @@ static int set_bytecode(lua_State * L)
         for (i = (unsigned) (luabytecode_max + 1); i <= (unsigned) k; i++) {
             lua_bytecode_registers[i].buf = NULL;
             lua_bytecode_registers[i].size = 0;
-            lua_bytecode_registers[i].done = 0;
+         /* lua_bytecode_registers[i].done = 0; */
         }
         luabytecode_max = k;
     }
@@ -252,7 +290,7 @@ static int set_bytecode(lua_State * L)
         xfree(lua_bytecode_registers[k].buf);
         luabytecode_bytes -= (unsigned) lua_bytecode_registers[k].size;
         lua_bytecode_registers[k].size = 0;
-        lua_bytecode_registers[k].done = 0;
+     /* lua_bytecode_registers[k].done = 0; */
         lua_pushnil(L);
         bytecode_register_shadow_set(L, k);
     }
@@ -268,7 +306,7 @@ static int set_bytecode(lua_State * L)
         lua_dump(L, writer, (void *) (lua_bytecode_registers + k),strip);
 #endif
 #if LUA_VERSION_NUM == 502
-        lua_dump(L, writer, (void *) (lua_bytecode_registers + k));    
+        lua_dump(L, writer, (void *) (lua_bytecode_registers + k));
 #endif
 #endif
     }
@@ -329,6 +367,18 @@ static int new_table(lua_State * L) /* hh */
     return 1;
 }
 
+static int get_stack_top(lua_State * L) /* hh */
+{
+    lua_pushinteger(L, lua_gettop(L));
+    return 1;
+}
+
+static int get_call_level(lua_State * L) /* hh */
+{
+    lua_pushinteger(L, lua_active);
+    return 1;
+}
+
 static const struct luaL_Reg lualib[] = {
     /* *INDENT-OFF* */
     {"getluaname",  get_luaname},
@@ -337,6 +387,8 @@ static const struct luaL_Reg lualib[] = {
     {"setbytecode", set_bytecode},
     {"newtable",    new_table},
     {"get_functions_table",lua_functions_get_table},
+    {"getstacktop",get_stack_top},
+    {"getcalllevel", get_call_level},
     /* *INDENT-ON* */
     {NULL, NULL}                /* sentinel */
 };
diff --git a/texk/web2c/luatexdir/lua/lnewtokenlib.c b/texk/web2c/luatexdir/lua/lnewtokenlib.c
index 085129d54..3e879b54a 100644
--- a/texk/web2c/luatexdir/lua/lnewtokenlib.c
+++ b/texk/web2c/luatexdir/lua/lnewtokenlib.c
@@ -33,10 +33,12 @@
 #include "ptexlib.h"
 #include "lua/luatex-api.h"
 
+/*
 typedef struct lua_token {
     int token;
     int origin;
 } lua_token;
+*/
 
 typedef struct saved_tex_scanner {
     int token;
@@ -145,33 +147,51 @@ static void push_token(lua_State * L, int tok)
     lua_setmetatable(L, -2);
 }
 
-/* static int run_get_cs_offset(lua_State * L) */
-/* { */
-/*     lua_pushinteger(L, cs_token_flag); */
-/*     return 1; */
-/* } */
-
-/* static int run_get_command_id(lua_State * L) */
-/* { */
-/*     int cs = -1; */
-/*     if (lua_type(L, -1) == LUA_TSTRING) { */
-/*         cs = get_command_id(lua_tostring(L, -1)); */
-/*     } */
-/*     lua_pushinteger(L, cs); */
-/*     return 1; */
-/* } */
-
-/* static int run_get_csname_id(lua_State * L) */
-/* { */
-/*     const char *s; */
-/*     size_t k, cs = 0; */
-/*     if (lua_type(L, -1) == LUA_TSTRING) { */
-/*         s = lua_tolstring(L, -1, &k); */
-/*         cs = (size_t) string_lookup(s, k); */
-/*     } */
-/*     lua_pushinteger(L, (lua_Number) cs); */
-/*     return 1; */
-/* } */
+static int run_get_biggest_char(lua_State * L)
+{
+    lua_pushinteger(L, biggest_char);
+    return 1;
+}
+
+/* not that useful:
+
+static int run_get_cs_offset(lua_State * L)
+{
+    lua_pushinteger(L, cs_token_flag);
+    return 1;
+}
+
+*/
+
+static int run_get_command_id(lua_State * L)
+{
+    int id = -1;
+    if (lua_type(L, -1) == LUA_TSTRING) {
+        id = get_command_id(lua_tostring(L, -1));
+    }
+    if (id >= 0) {
+        lua_pushinteger(L, id);
+    } else {
+        lua_pushnil(L);
+    }
+    return 1;
+}
+
+/* not that useful:
+
+static int run_get_csname_id(lua_State * L)
+{
+    const char *s;
+    size_t k, cs = 0;
+    if (lua_type(L, -1) == LUA_TSTRING) {
+        s = lua_tolstring(L, -1, &k);
+        cs = (size_t) string_lookup(s, k);
+    }
+    lua_pushinteger(L, (lua_Number) cs);
+    return 1;
+}
+
+*/
 
 static int run_get_next(lua_State * L)
 {
@@ -296,6 +316,22 @@ static int run_scan_keyword(lua_State * L)
     return 1;
 }
 
+static int run_scan_keyword_cs(lua_State * L)
+{
+    saved_tex_scanner texstate;
+    const char *s = luaL_checkstring(L, -1);
+    int v = 0;
+    if (s) {
+        save_tex_scanner(texstate);
+        if (scan_keyword_case_sensitive(s)) {
+            v = 1;
+        }
+        unsave_tex_scanner(texstate);
+    }
+    lua_pushboolean(L,v);
+    return 1;
+}
+
 static int run_scan_csname(lua_State * L)
 {
     unsigned char *s;
@@ -328,6 +364,138 @@ static int run_scan_int(lua_State * L)
     return 1;
 }
 
+/*
+    char * str ;
+*/
+
+# define declare_buffer \
+    unsigned char word[5 + 1]; \
+    char *uindex = (char *)word; \
+    luaL_Buffer b ; \
+    luaL_buffinit(L,&b) ;
+
+/*
+    str = (char *) uni2str(cur_chr);
+    luaL_addstring(&b,(char *) str);
+    xfree(str);
+*/
+
+# define add_to_buffer(chr) \
+    if (chr <= 255) { \
+        luaL_addchar(&b,(unsigned) (char) chr); \
+    } else { \
+        uindex = uni2string((char *)word,(unsigned) chr); \
+        *uindex = '\0'; \
+        luaL_addstring(&b,(char *) word); \
+    }
+
+# define push_buffer \
+    luaL_pushresult(&b);
+
+static int run_scan_float_indeed(lua_State * L, boolean exponent)
+{
+    saved_tex_scanner texstate;
+    int ok;
+    boolean negative = false;
+    double d;
+    declare_buffer;
+    save_tex_scanner(texstate);
+    /* we collapse as in scan_dimen */
+    while(1) {
+        do {
+            get_x_token();
+        } while (cur_cmd == spacer_cmd);
+        if (cur_tok == minus_token) {
+            negative = !negative;
+        } else if (cur_tok != plus_token) {
+            break;
+        }
+    }
+    if (negative) {
+        add_to_buffer('-');
+    }
+    /* we accept [.,]digits */
+    if (cur_tok == point_token || cur_tok == comma_token) {
+        add_to_buffer('.');
+        while (1) {
+            get_x_token();
+            if ((cur_tok >= zero_token) && (cur_tok <= nine_token)) {
+                add_to_buffer(cur_chr);
+            } else if (exponent) {
+                goto EXPONENT;
+            } else {
+                back_input();
+                goto DONE;
+            }
+        }
+    } else {
+        back_input();
+        while (1) {
+            get_x_token();
+            if ((cur_tok >= zero_token) && (cur_tok <= nine_token)) {
+                add_to_buffer(cur_chr);
+            } else {
+                if (cur_tok == point_token || cur_tok == comma_token) {
+                    add_to_buffer('.');
+                    while (1) {
+                        get_x_token();
+                        if ((cur_tok >= zero_token) && (cur_tok <= nine_token)) {
+                            add_to_buffer(cur_chr);
+                        } else {
+                            back_input();
+                            break;
+                        }
+                    }
+                } else if (exponent) {
+                    goto EXPONENT;
+                } else {
+                    back_input();
+                    goto DONE;
+                }
+            }
+        }
+    }
+EXPONENT:
+    if ((cur_chr == 'E') || (cur_chr == 'e')) {
+        add_to_buffer(cur_chr);
+        get_x_token();
+        if ((cur_tok == minus_token) || (cur_tok == plus_token)) {
+            add_to_buffer(cur_chr);
+        } else if ((cur_tok >= zero_token) && (cur_tok <= nine_token)) {
+            add_to_buffer(cur_chr);
+        }
+        while (1) {
+            get_x_token();
+            if ((cur_tok >= zero_token) && (cur_tok <= nine_token)) {
+                add_to_buffer(cur_chr);
+            } else {
+                break;
+            }
+        }
+    }
+    back_input();
+DONE:
+    push_buffer;
+    d = lua_tonumberx(L,1,&ok);
+    if (ok) {
+        lua_pushnumber(L,d);
+    } else {
+        lua_pushnil(L);
+    }
+    unsave_tex_scanner(texstate);
+    return 1;
+}
+
+static int run_scan_float(lua_State * L)
+{
+    return run_scan_float_indeed(L,true);
+}
+
+static int run_scan_real(lua_State * L)
+{
+    return run_scan_float_indeed(L,false);
+}
+
 static int run_scan_dimen(lua_State * L)
 {
     saved_tex_scanner texstate;
@@ -339,7 +507,7 @@ static int run_scan_dimen(lua_State * L)
     if (t>1)
       mu = lua_toboolean(L,2);  /* mu units required ?*/
     save_tex_scanner(texstate);
-    scan_dimen( mu,inf, false); /* arg3 = shortcut */
+    scan_dimen(mu,inf, false); /* arg3 = shortcut */
     v = cur_val;
     o = cur_order;
     unsave_tex_scanner(texstate);
@@ -415,25 +583,67 @@ static int run_scan_string(lua_State * L) /* HH */
     } else if (cur_cmd == call_cmd) {
         t = token_link(cur_chr);
         tokenlist_to_luastring(L,t);
+    } else if (cur_cmd == 11 || cur_cmd == 12 ) {
+        declare_buffer;
+        while (1) {
+            add_to_buffer(cur_chr);
+            get_x_token();
+            if (cur_cmd != 11 && cur_cmd != 12 ) {
+                break ;
+            }
+        }
+        back_input();
+        push_buffer;
     } else {
-        if (cur_cmd == 11 || cur_cmd == 12 ) {
-            char * str ;
-            luaL_Buffer b ;
-            luaL_buffinit(L,&b) ;
-            while (1) {
-                str = (char *) uni2str(cur_chr);
-                luaL_addstring(&b,(char *) str);
-                get_x_token();
-                if (cur_cmd != 11 && cur_cmd != 12 ) {
-                    break ;
-                }
+        back_input();
+        lua_pushnil(L);
+    }
+    unsave_tex_scanner(texstate);
+    return 1;
+}
+
+static int run_scan_argument(lua_State * L) /* HH */
+{   /* can be simplified, no need for intermediate list */
+    saved_tex_scanner texstate;
+    halfword t, saved_defref;
+    save_tex_scanner(texstate);
+    do {
+        get_token();
+    } while ((cur_cmd == spacer_cmd) || (cur_cmd == relax_cmd));
+    if (cur_cmd == left_brace_cmd) {
+        back_input();
+        saved_defref = def_ref;
+        (void) scan_toks(false, true);
+        t = def_ref;
+        def_ref = saved_defref;
+        tokenlist_to_luastring(L,t);
+    } else if (cur_cmd == call_cmd) {
+        halfword saved_cur_tok = cur_tok;
+        cur_tok = right_brace_token + '}';
+        back_input();
+        cur_tok = saved_cur_tok;
+        back_input();
+        cur_tok = left_brace_token + '{';
+        back_input();
+        saved_defref = def_ref;
+        (void) scan_toks(false, true);
+        t = def_ref;
+        def_ref = saved_defref;
+        tokenlist_to_luastring(L,t);
+    } else if (cur_cmd == 11 || cur_cmd == 12 ) {
+        declare_buffer;
+        while (1) {
+            add_to_buffer(cur_chr);
+            get_x_token();
+            if (cur_cmd != 11 && cur_cmd != 12 ) {
+                break ;
             }
-            back_input();
-            luaL_pushresult(&b);
-        } else {
-            back_input();
-            lua_pushnil(L);
         }
+        back_input();
+        push_buffer;
+    } else {
+        back_input();
+        lua_pushnil(L);
     }
     unsave_tex_scanner(texstate);
     return 1;
@@ -447,20 +657,16 @@ static int run_scan_word(lua_State * L) /* HH */
         get_x_token();
     } while ((cur_cmd == spacer_cmd) || (cur_cmd == relax_cmd));
     if (cur_cmd == 11 || cur_cmd == 12 ) {
-        char *str ;
-        luaL_Buffer b ;
-        luaL_buffinit(L,&b) ;
+        declare_buffer;
         while (1) {
-            str = (char *) uni2str(cur_chr);
-            luaL_addstring(&b,str);
-            xfree(str);
+            add_to_buffer(cur_chr);
             get_x_token();
             if (cur_cmd != 11 && cur_cmd != 12 ) {
                 break ;
             }
         }
         back_input();
-        luaL_pushresult(&b);
+        push_buffer;
     } else {
         back_input();
         lua_pushnil(L);
@@ -503,12 +709,12 @@ static int lua_tokenlib_is_token(lua_State * L) /* HH */
     return 1;
 }
 
-/* static int run_expand(lua_State * L) */
-/* { */
-/*     (void) L; */
-/*     expand(); */
-/*     return 0; */
-/* } */
+static int run_expand(lua_State * L)
+{
+    (void) L;
+    expand();
+    return 0;
+}
 
 static int run_lookup(lua_State * L)
 {
@@ -529,6 +735,21 @@ static int run_lookup(lua_State * L)
     return 1;
 }
 
+static int lua_tokenlib_is_defined(lua_State * L)
+{
+    const char *s;
+    size_t l;
+    if (lua_type(L, -1) == LUA_TSTRING) {
+        s = lua_tolstring(L, -1, &l);
+        if (l > 0) {
+            lua_pushboolean(L,string_lookup(s, l) != undefined_control_sequence);
+            return 1;
+        }
+    }
+    lua_pushnil(L);
+    return 1;
+}
+
 static int run_build(lua_State * L)
 {
     if (lua_type(L, 1) == LUA_TNUMBER) {
@@ -550,6 +771,15 @@ static int run_build(lua_State * L)
     }
 }
 
+static int run_new(lua_State * L)
+{
+    int cs = 0;
+    int chr = (int) lua_tointeger(L, 1);
+    int cmd = (int) lua_tointeger(L, 2);
+    make_new_token(L, cmd, chr, cs);
+    return 1;
+}
+
 /* token instance functions */
 
 static int lua_tokenlib_free(lua_State * L)
@@ -602,7 +832,6 @@ inline static int lua_tokenlib_get_index(lua_State * L)
             e -= toks_base;
             break;
         default:
-            e = -1;
             break;
     }
     if ((e >= 0) && (e <= 65535)) {
@@ -630,7 +859,7 @@ inline static int lua_tokenlib_get_cmdname(lua_State * L)
     lua_token *n = check_istoken(L, 1);
     halfword t = token_info(n->token);
     int cmd = (t >= cs_token_flag ? eq_type(t - cs_token_flag) : token_cmd(t));
-    lua_pushstring(L, command_names[cmd].cmd_name); /* can be sped up */
+    lua_push_string_by_index(L, command_names[cmd].lua);
     return 1;
 }
 
@@ -750,7 +979,7 @@ static int lua_tokenlib_equal(lua_State * L)
     n = check_istoken(L, 1);
     m = check_istoken(L, 2);
     if (token_info(n->token) == token_info(m->token)) {
-	lua_pushboolean(L,1);
+    lua_pushboolean(L,1);
         return 1;
     }
     lua_pushboolean(L,0);
@@ -789,6 +1018,19 @@ static int run_scan_token(lua_State * L)
     return 1;
 }
 
+static int run_scan_list(lua_State * L)
+{
+    saved_tex_scanner texstate;
+    save_tex_scanner(texstate);
+    /*tex
+        This is s tricky call as we are in \LUA\ and therefore
+        mess with the main loop.
+    */
+    lua_nodelib_push_fast(L, local_scan_box());
+    unsave_tex_scanner(texstate);
+    return 1;
+}
+
 /* experiment */
 
 /* [catcodetable] csname content        : \def\csname{content}  */
@@ -844,6 +1086,56 @@ static int get_macro(lua_State * L)
     return 0;
 }
 
+static int set_lua(lua_State *L)
+{
+    const char *name = null;
+    const char *s  = null;
+    size_t lname = 0;
+    int cs;
+    int n = lua_gettop(L);
+    int a = 0; /* global state */
+    int p = 0; /* protected state */
+    int f = 0; /* function index */
+    int nncs = no_new_control_sequence;
+    if (n < 2) {
+        return 0 ;
+    }
+    name = lua_tolstring(L, 1, &lname);
+    if (name == null) {
+        return 0 ;
+    }
+    f = lua_tointeger(L, 2);
+    if (n > 2)  {
+        s = lua_tostring(L, 3);
+        if (s) {
+            if (lua_key_eq(s, global)) {
+                a = 4;
+            } else if (lua_key_eq(s, protected)) {
+                p = 1;
+            }
+        }
+        if (n > 3) {
+            s = lua_tostring(L, 4);
+            if (s) {
+                if (lua_key_eq(s, global)) {
+                    a = 4;
+                } else if (lua_key_eq(s, protected)) {
+                    p = 1;
+                }
+            }
+        }
+    }
+    no_new_control_sequence = false ;
+    cs = string_lookup(name, lname);
+    no_new_control_sequence = nncs;
+    if (p) {
+        define(cs, lua_call_cmd, f);
+    } else {
+        define(cs, lua_expandable_call_cmd, f);
+    }
+    return 0;
+}
+
 static int set_macro(lua_State * L)
 {
     const char *name = null;
@@ -963,27 +1255,75 @@ static int set_macro(lua_State * L)
     return 0;
 }
 
+static int set_char(lua_State * L)
+{
+    const char *name = null;
+    const char *s  = null;
+    size_t lname = 0;
+    int cs, value;
+    int n = lua_gettop(L);
+    int a = 0 ; /* global state */
+    int nncs = no_new_control_sequence;
+    if (n < 2)
+        return 0;
+    name = lua_tolstring(L, 1, &lname);
+    if (name == null)
+        return 0;
+    value = lua_tointeger(L, 2);
+    if (value < 0)
+        return 0;
+    if (n > 2)
+        s = lua_tostring(L, 3);
+    if (s && (lua_key_eq(s, global))) {
+        a = 4;
+    }
+    no_new_control_sequence = false ;
+    cs = string_lookup(name, lname);
+    no_new_control_sequence = nncs;
+    define(cs, char_given_cmd, value);
+    return 0;
+}
+
+static int get_command_names(lua_State * L)
+{
+    int i;
+    lua_createtable(L,data_cmd+1,0);
+    for (i = 0; command_names[i].lua != 0; i++) {
+        lua_rawgeti(L, LUA_REGISTRYINDEX, command_names[i].lua);
+        lua_rawseti(L, -2, i);
+    }
+    return 1;
+}
+
 static const struct luaL_Reg tokenlib[] = {
     { "type", lua_tokenlib_type },
     { "create", run_build },
+    { "new", run_new },
     { "is_token", lua_tokenlib_is_token },
+    { "is_defined", lua_tokenlib_is_defined },
+    { "commands", get_command_names },
+    { "command_id", run_get_command_id },
+    { "biggest_char", run_get_biggest_char },
     /* scanners */
     { "get_next", run_get_next },
-    { "put_next", run_put_next },
     { "scan_keyword", run_scan_keyword },
+    { "scan_keyword_cs", run_scan_keyword_cs },
     { "scan_int", run_scan_int },
+    { "scan_float", run_scan_float },
+    { "scan_real", run_scan_real },
     { "scan_dimen", run_scan_dimen },
     { "scan_glue", run_scan_glue },
     { "scan_toks", run_scan_toks },
     { "scan_code", run_scan_code },
     { "scan_string", run_scan_string },
+    { "scan_argument", run_scan_argument },
     { "scan_word", run_scan_word },
     { "scan_csname", run_scan_csname },
     { "scan_token", run_scan_token }, /* expands next token if needed */
-    /* push into input stream */
-    /*
-    { "write",luatwrite },
-    */
+    { "scan_list", run_scan_list },
+    /* writers */
+    { "put_next", run_put_next },
+    { "expand", run_expand },
     /* getters */
     { "get_command", lua_tokenlib_get_command },
     { "get_index", lua_tokenlib_get_index },
@@ -995,15 +1335,12 @@ static const struct luaL_Reg tokenlib[] = {
     { "get_active", lua_tokenlib_get_active },
     { "get_expandable", lua_tokenlib_get_expandable },
     { "get_protected", lua_tokenlib_get_protected },
-    /* maybe more setters */
-    { "set_macro", set_macro },
     { "get_macro", get_macro },
     { "get_meaning", get_meaning },
-    /* probably never */
- /* {"expand", run_expand},               */ /* does not work yet! */
- /* {"csname_id", run_get_csname_id},     */ /* yes or no */
- /* {"command_id", run_get_command_id},   */ /* yes or no */
- /* {"cs_offset", run_get_cs_offset},     */ /* not that useful */
+    /* setters */
+    { "set_macro", set_macro },
+    { "set_char", set_char },
+    { "set_lua", set_lua },
     {NULL, NULL}
 };
 
diff --git a/texk/web2c/luatexdir/lua/lnodelib.c b/texk/web2c/luatexdir/lua/lnodelib.c
index 7b4c614ea..d8732df76 100644
--- a/texk/web2c/luatexdir/lua/lnodelib.c
+++ b/texk/web2c/luatexdir/lua/lnodelib.c
@@ -209,6 +209,80 @@ halfword *check_isnode(lua_State * L, int i)
     return NULL;
 }
 
+static int nodelib_setdir_text(lua_State * L, int i, halfword n)
+{
+    if (lua_type(L, i) == LUA_TSTRING) {
+        const char *s = lua_tostring(L, i);
+        if (s==lua_key_plus(TLT)) {
+            dir_dir(n) = 0 ;
+            subtype(n) = normal_dir;
+        } else if (s==lua_key_minus(TLT)) {
+            dir_dir(n) = 0 ;
+            subtype(n) = cancel_dir;
+        } else if (s==lua_key_plus(TRT)) {
+            dir_dir(n) = 1 ;
+            subtype(n) = normal_dir;
+        } else if (s==lua_key_minus(TRT)) {
+            dir_dir(n) = 1 ;
+            subtype(n) = cancel_dir;
+        } else if (s==lua_key_plus(LTL)) {
+            dir_dir(n) = 2 ;
+            subtype(n) = normal_dir;
+        } else if (s==lua_key_minus(LTL)) {
+            dir_dir(n) = 2 ;
+            subtype(n) = cancel_dir;
+        } else if (s==lua_key_plus(RTT)) {
+            dir_dir(n) = 3 ;
+            subtype(n) = normal_dir;
+        } else if (s==lua_key_minus(RTT)) {
+            dir_dir(n) = 3 ;
+            subtype(n) = cancel_dir;
+        } else {
+            luaL_error(L, "Bad direction specifier %s", s);
+        }
+    } else {
+        luaL_error(L, "Direction specifiers have to be strings");
+    }
+    return 0;
+}
+
+static int nodelib_getdir_par(lua_State * L, int n)
+{
+    if (lua_type(L, n) == LUA_TSTRING) {
+        const char *s = lua_tostring(L, n);
+        if (s==lua_key(TLT))
+            return 0 ;
+        else if (s==lua_key(TRT))
+            return 1 ;
+        else if (s==lua_key(LTL))
+            return 2 ;
+        else if (s==lua_key(RTT))
+            return 3 ;
+        else
+            luaL_error(L, "Bad direction specifier %s", s);
+    } else {
+        luaL_error(L, "Direction specifiers have to be strings");
+    }
+    return 0;
+}
+
+static int nodelib_getdirection(lua_State * L, int n)
+{
+    if (lua_type(L, n) == LUA_TNUMBER) {
+        int i = lua_tointeger(L, n);
+        check_dir_value(i);
+        return i;
+    } else {
+        luaL_error(L, "Direction specifiers have to be numbers");
+    }
+    return 0;
+}
+
+int nodelib_getdir(lua_State * L, int n) /* the api public one */
+{
+    return nodelib_getdir_par(L,n);
+}
+
 /*
 
     This routine finds the numerical value of a string (or number) at
@@ -216,13 +290,32 @@ halfword *check_isnode(lua_State * L, int i)
 
 */
 
+/* s = lua_tostring(L, 2); */
+/* if (lua_key_eq(s, id)) { */
+
 static int get_node_type_id_from_name(lua_State * L, int n, node_info * data)
 {
-    int j;
-    const char *s = lua_tostring(L, n);
-    for (j = 0; data[j].id != -1; j++) {
-        if (strcmp(s, data[j].name) == 0) {
-            return j;
+    if (data != NULL) {
+        int j;
+        const char *s = lua_tostring(L, n);
+        for (j = 0; data[j].id != -1; j++) {
+            if (s == data[j].name) {
+                return j;
+            }
+        }
+    }
+    return -1;
+}
+
+static int get_node_subtype_id_from_name(lua_State * L, int n, subtype_info * data)
+{
+    if (data != NULL) {
+        int j;
+        const char *s = lua_tostring(L, n);
+        for (j = 0; data[j].id != -1; j++) {
+            if (s == data[j].name) {
+                return j;
+            }
         }
     }
     return -1;
@@ -234,7 +327,7 @@ static int get_valid_node_type_id(lua_State * L, int n)
     int t = lua_type(L, n);
     if (t == LUA_TSTRING) {
         i = get_node_type_id_from_name(L,n,node_data);
-        if (i<0) {
+        if (i < 0) {
             luaL_error(L, "invalid node type id: %s", lua_tostring(L, n));
         }
     } else if (t == LUA_TNUMBER) {
@@ -347,6 +440,31 @@ void lua_nodelib_push_fast(lua_State * L, halfword n)
     return;
 }
 
+/* getting and setting fields (helpers) */
+
+int nodelib_getlist(lua_State * L, int n)
+{
+    if (lua_isuserdata(L, n)) {
+        halfword m = *check_isnode(L, n);
+        return m;
+    } else {
+        return null;
+    }
+}
+
+static str_number nodelib_getstring(lua_State * L, int a)
+{
+    size_t k;
+    const char *s = lua_tolstring(L, a, &k);
+    return maketexlstring(s, k);
+}
+
+static int nodelib_cantset(lua_State * L, int n, const char *s)
+{
+    luaL_error(L,"You cannot set field %s in a node of type %s",s,node_data[type(n)].name);
+    return 0;
+}
+
 /* converts type strings to type ids */
 
 static int lua_nodelib_id(lua_State * L)
@@ -439,6 +557,44 @@ static int lua_nodelib_direct_setsubtype(lua_State * L)
         return 1;
     }
 
+/* node.direct.getexpansion */
+/* node.direct.setexpansion */
+
+static int lua_nodelib_direct_getexpansion(lua_State * L)
+{
+    halfword n = lua_tointeger(L, 1);
+    if (n != null) {
+        halfword t = type(n);
+        if (t == glyph_node) {
+            lua_pushinteger(L, ex_glyph(n));
+            return 1;
+        } else if (t == kern_node) {
+            lua_pushinteger(L, ex_kern(n));
+            return 1;
+        }
+    }
+    lua_pushnil(L);
+    return 1;
+}
+
+static int lua_nodelib_direct_setexpansion(lua_State * L)
+{
+    halfword n = lua_tointeger(L, 1);
+    if (n) {
+        halfword t = type(n);
+        halfword e = 0;
+        if (lua_type(L, 2) == LUA_TNUMBER) {
+            e = (halfword) lua_tointeger(L, 2);
+        }
+        if (t == glyph_node) {
+            ex_glyph(n) = e;
+        } else if ( t == kern_node) {
+            ex_kern(n) = e;
+        }
+    }
+    return 0;
+}
+
 /* node.direct.getfont */
 /* node.direct.setfont */
 
@@ -530,6 +686,10 @@ static int lua_nodelib_direct_getfam(lua_State * L)
             lua_pushinteger(L, math_fam(n));
         } else if (t == delim_node) {
             lua_pushinteger(L, small_fam(n));
+        } else if (t == fraction_noad) {
+            lua_pushinteger(L, fraction_fam(n));
+        } else if (t == simple_noad) {
+            lua_pushinteger(L, noad_fam(n));
         } else {
             lua_pushnil(L);
         }
@@ -565,6 +725,10 @@ static int lua_nodelib_direct_setfam(lua_State * L)
             math_fam(n) = (halfword) lua_tointeger(L, 2);
         } else if (t == delim_node) {
             small_fam(n) = (halfword) lua_tointeger(L, 2);
+        } else if (t == fraction_noad) {
+            fraction_fam(n) = (halfword) lua_tointeger(L, 2);
+        } else if (t == simple_noad) {
+            noad_fam(n) = (halfword) lua_tointeger(L, 2);
         }
     }
     return 0;
@@ -572,7 +736,7 @@ static int lua_nodelib_direct_setfam(lua_State * L)
 
     /* node.getchar */
 
-    static int lua_nodelib_getchar(lua_State * L)
+static int lua_nodelib_getchar(lua_State * L)
     {
         halfword *n = lua_touserdata(L, 1);
         if ((n == NULL) || (! lua_getmetatable(L,1))) {
@@ -665,7 +829,8 @@ static int lua_nodelib_direct_setattributelist(lua_State * L)
 {
     halfword n = lua_tointeger(L, 1);
     if ((n) && nodetype_has_attributes(type(n))) {
-        if (lua_type(L, 2) == LUA_TNUMBER) {
+        int t = lua_type(L, 2);
+        if (t == LUA_TNUMBER) {
             halfword a =lua_tointeger(L, 2);
             if (type(a) == attribute_list_node) {
                 reassign_attribute(n,a);
@@ -674,6 +839,12 @@ static int lua_nodelib_direct_setattributelist(lua_State * L)
             } else {
                 reassign_attribute(n,null);
             }
+        } else if (t == LUA_TBOOLEAN) {
+            if (lua_toboolean(L,2)) {
+                reassign_attribute(n,current_attribute_list());
+            } else {
+                reassign_attribute(n,null);
+            }
         } else {
             reassign_attribute(n,null);
         }
@@ -681,7 +852,6 @@ static int lua_nodelib_direct_setattributelist(lua_State * L)
     }
     return 0;
 }
-
 /* node.direct.getpenalty */
 /* node.direct.setpenalty */
 
@@ -827,7 +997,15 @@ static int lua_nodelib_direct_getkern(lua_State * L)
     halfword n = lua_tointeger(L, 1);
     if (n) {
         halfword t = type(n);
-        if (t == kern_node || t == margin_kern_node) {
+        if (t == kern_node) {
+            if (lua_toboolean(L,2)) {
+                lua_pushnumber(L, (1+ex_kern(n)/1000) * width(n));
+                lua_pushinteger(L, ex_kern(n));
+                return 2;
+            } else {
+                lua_pushinteger(L, width(n));
+            }
+        } else if (t == margin_kern_node) {
             lua_pushinteger(L, width(n));
         } else if (t == math_node) {
             lua_pushinteger(L, surround(n));
@@ -874,7 +1052,7 @@ static int lua_nodelib_direct_getdir(lua_State * L)
     if (n) {
         halfword t = type(n);
         if (t == dir_node) {
-            lua_push_dir_text(L, dir_dir(n));
+            lua_push_dir_text(L, dir_dir(n), subtype(n));
         } else if (t == hlist_node || t == vlist_node) {
             lua_push_dir_par(L, box_dir(n));
         } else if (t == rule_node) {
@@ -890,19 +1068,68 @@ static int lua_nodelib_direct_getdir(lua_State * L)
     return 1;
 }
 
+static int lua_nodelib_direct_getdirection(lua_State * L)
+{
+    halfword n = lua_tointeger(L, 1);
+    if (n) {
+        halfword t = type(n);
+        if (t == dir_node) {
+            lua_push_direction(L, dir_dir(n));
+            lua_pushboolean(L, subtype(n));
+            return 2;
+        } else if (t == hlist_node || t == vlist_node) {
+            lua_push_direction(L, box_dir(n));
+        } else if (t == rule_node) {
+            lua_push_direction(L, rule_dir(n));
+        } else if (t == local_par_node) {
+            lua_push_direction(L, local_par_dir(n));
+        } else {
+            lua_pushnil(L);
+        }
+    } else {
+        lua_pushnil(L);
+    }
+    return 1;
+}
+
 static int lua_nodelib_direct_setdir(lua_State * L)
 {
     halfword n = lua_tointeger(L, 1);
     if (n) {
         halfword t = type(n);
         if (t == dir_node) {
-            dir_dir(n) = nodelib_getdir(L, 2, 0);
+            nodelib_setdir_text(L, 2, n);
         } else if (t == hlist_node || type(n) == vlist_node) {
-            box_dir(n) = nodelib_getdir(L, 2, 1);
+            box_dir(n) = nodelib_getdir_par(L, 2);
         } else if (t == rule_node) {
-            rule_dir(n) = nodelib_getdir(L, 2, 1);
+            rule_dir(n) = nodelib_getdir_par(L, 2);
         } else if (t == local_par_node) {
-            local_par_dir(n) = nodelib_getdir(L, 3, 1);
+            local_par_dir(n) = nodelib_getdir_par(L, 2);
+        }
+    }
+    return 0;
+}
+
+static int lua_nodelib_direct_setdirection(lua_State * L)
+{
+    halfword n = lua_tointeger(L, 1);
+    if (n) {
+        halfword t = type(n);
+        if (t == dir_node) {
+            dir_dir(n) = nodelib_getdirection(L, 2);
+            if ((lua_type(L, 3) == LUA_TBOOLEAN)) {
+                if (lua_toboolean(L, 3)) {
+                    subtype(n) = cancel_dir;
+                } else {
+                    subtype(n) = normal_dir;
+                }
+            }
+        } else if (t == hlist_node || type(n) == vlist_node) {
+            box_dir(n) = nodelib_getdirection(L, 2);
+        } else if (t == rule_node) {
+            rule_dir(n) = nodelib_getdirection(L, 2);
+        } else if (t == local_par_node) {
+            local_par_dir(n) = nodelib_getdirection(L, 2);
         }
     }
     return 0;
@@ -1017,15 +1244,24 @@ static int lua_nodelib_direct_setdisc(lua_State * L)
 /* node.direct.getwhd */
 /* node.direct.setwhd */
 
-#define push_list_whd(n) \
-    lua_pushinteger(L, width(n));  \
+#define push_list_whd(n) do { \
+    lua_pushinteger(L, width(n)); \
     lua_pushinteger(L, height(n)); \
-    lua_pushinteger(L, depth(n));  \
+    lua_pushinteger(L, depth(n)); \
+} while (0)
+
+#define push_char_whd(n) do { \
+    lua_pushinteger(L, char_width(font(n),character(n))); \
+    lua_pushinteger(L, char_height(font(n),character(n))); \
+    lua_pushinteger(L, char_depth(font(n),character(n))); \
+} while (0)
 
-#define push_char_whd(n) \
-    lua_pushinteger(L, char_width(font(n),character(n)));  \
+#define push_char_ehd(n) do { \
+    lua_pushnumber(L, (1+ex_glyph(n)/1000) * char_width(font(n),character(n))); \
     lua_pushinteger(L, char_height(font(n),character(n))); \
-    lua_pushinteger(L, char_depth(font(n),character(n)));  \
+    lua_pushinteger(L, char_depth(font(n),character(n))); \
+    lua_pushinteger(L, ex_glyph(n)); \
+} while (0)
 
 static int lua_nodelib_direct_getwhd(lua_State * L)
 {
@@ -1036,8 +1272,13 @@ static int lua_nodelib_direct_getwhd(lua_State * L)
             push_list_whd(n);
             return 3;
         } else if (t == glyph_node) {
-            push_char_whd(n);
-            return 3;
+            if (lua_toboolean(L,2)) {
+                push_char_ehd(n);
+                return 4;
+            } else {
+                push_char_whd(n);
+                return 3;
+            }
         } else if (t == glue_node) {
             halfword l = leader_ptr(n);
             if (l != null) {
@@ -1104,8 +1345,13 @@ static int lua_nodelib_direct_setwhd(lua_State * L)
                 push_list_whd(*n);
                 return 3;
             } else if (t == glyph_node) {
-                push_char_whd(*n);
-                return 3;
+                if (lua_toboolean(L,2)) {
+                    push_char_ehd(*n);
+                    return 4;
+                } else {
+                    push_char_whd(*n);
+                    return 3;
+                }
             } else if (t == glue_node) {
                 halfword l = leader_ptr(*n);
                 if (l != null) {
@@ -1214,7 +1460,7 @@ static int lua_nodelib_direct_getleader(lua_State * L)
     return 1;
 }
 
-    static int lua_nodelib_direct_setleader(lua_State * L)
+static int lua_nodelib_direct_setleader(lua_State * L)
 {
     halfword n = lua_tointeger(L, 1);
     if ((n) && (type(n) == glue_node)) {
@@ -1227,7 +1473,7 @@ static int lua_nodelib_direct_getleader(lua_State * L)
     return 0;
 }
 
-    /* node.getleader */
+/* node.getleader */
 
     static int lua_nodelib_getleader(lua_State * L)
     {
@@ -1243,6 +1489,241 @@ static int lua_nodelib_direct_getleader(lua_State * L)
         return 1;
     }
 
+/* node.direct.getdata */
+/* node.direct.setdata */
+
+#define get_user_node_direct_value(L, n) do {                          \
+    switch (user_node_type(n)) {                                       \
+        case 'a':                                                      \
+            nodelib_pushdirect(user_node_value(n));                    \
+            break;                                                     \
+        case 'd':                                                      \
+            lua_pushinteger(L, user_node_value(n));                    \
+            break;                                                     \
+        case 'l':                                                      \
+            if (user_node_value(n) != 0) {                             \
+                lua_rawgeti(L, LUA_REGISTRYINDEX, user_node_value(n)); \
+            } else {                                                   \
+                lua_pushnil(L);                                        \
+            }                                                          \
+            break;                                                     \
+        case 'n':                                                      \
+            nodelib_pushdirect(user_node_value(n));                    \
+            break;                                                     \
+        case 's':                                                      \
+            nodelib_pushstring(L, user_node_value(n));                 \
+            break;                                                     \
+        case 't':                                                      \
+            tokenlist_to_lua(L, user_node_value(n));                   \
+            break;                                                     \
+        default:                                                       \
+            lua_pushinteger(L, user_node_value(n));                    \
+            break;                                                     \
+    }                                                                  \
+} while (0)
+
+#define set_user_node_direct_value(L,n,i) do {                       \
+    switch (user_node_type(n)) {                                     \
+        case 'a':                                                    \
+            user_node_value(n) = nodelib_getlist(L, i);              \
+            break;                                                   \
+        case 'd':                                                    \
+            user_node_value(n) = (halfword) lua_roundnumber(L, i);   \
+            break;                                                   \
+        case 'l':                                                    \
+            lua_pushvalue(L, i);                                     \
+            if (user_node_value(n) != 0) {                           \
+                luaL_unref(L, LUA_REGISTRYINDEX,user_node_value(n)); \
+            }                                                        \
+            user_node_value(n) = luaL_ref(L, LUA_REGISTRYINDEX);     \
+            break;                                                   \
+        case 'n':                                                    \
+            user_node_value(n) = nodelib_getlist(L, i);              \
+            break;                                                   \
+        case 's':                                                    \
+            user_node_value(n) = nodelib_getstring(L, i);            \
+            break;                                                   \
+        case 't':                                                    \
+            user_node_value(n) = nodelib_gettoks(L, i);              \
+            break;                                                   \
+        default:                                                     \
+            user_node_value(n) = (halfword) lua_roundnumber(L, i);   \
+            break;                                                   \
+    }                                                                \
+} while (0)
+
+#define get_pdf_literal_direct_value(L,n) do {                  \
+    if (pdf_literal_type(n) == lua_refid_literal) {             \
+        lua_rawgeti(L, LUA_REGISTRYINDEX, pdf_literal_data(n)); \
+    } else if (pdf_literal_type(n) == lua_refid_literal) {      \
+        tokenlist_to_luastring(L, pdf_literal_data(n));         \
+    }                                                           \
+} while (0)
+
+#define set_pdf_literal_direct_normal(L,n,i) do {             \
+    if (ini_version) {                                        \
+        pdf_literal_data(n) = nodelib_gettoks(L, i);          \
+        pdf_literal_type(n) = normal;                         \
+    } else {                                                  \
+        lua_pushvalue(L, i);                                  \
+        pdf_literal_data(n) = luaL_ref(L, LUA_REGISTRYINDEX); \
+        pdf_literal_type(n) = lua_refid_literal;              \
+    }                                                         \
+} while (0)
+
+#define set_pdf_literal_direct_token(L,n,i) do { \
+    pdf_literal_data(n) = nodelib_gettoks(L, i); \
+} while (0)
+
+#define cleanup_late_lua(n) do {                               \
+    if (late_lua_data(n) != 0) {                               \
+        if (late_lua_type(n) == normal) {                      \
+            delete_token_ref(late_lua_data(n));                \
+        } else if (late_lua_type(n) == lua_refid_literal) {    \
+            luaL_unref(L, LUA_REGISTRYINDEX,late_lua_data(n)); \
+        }                                                      \
+    }                                                          \
+} while (0)
+
+#define cleanup_late_lua_name(n) do {       \
+    if (late_lua_name(n) != 0) {            \
+        delete_token_ref(late_lua_name(n)); \
+    }                                       \
+} while (0)
+
+#define set_late_lua_direct_normal(L,n,i) do {             \
+    cleanup_late_lua(n) ;                                  \
+    if (ini_version) {                                     \
+        late_lua_data(n) = nodelib_gettoks(L, i);          \
+        late_lua_type(n) = normal;                         \
+    } else if (lua_type(L, i) == LUA_TNUMBER) {            \
+        late_lua_data(n) = lua_tointeger(L,i);             \
+        late_lua_type(n) = lua_refid_call;                 \
+    } else {                                               \
+        lua_pushvalue(L, i);                               \
+        late_lua_data(n) = luaL_ref(L, LUA_REGISTRYINDEX); \
+        late_lua_type(n) = lua_refid_literal;              \
+    }                                                      \
+} while (0)
+
+#define set_late_lua_direct_token(L,n,i) do { \
+    cleanup_late_lua(n) ;                     \
+    late_lua_data(n) = nodelib_gettoks(L, i); \
+    late_lua_type(n) = normal;                \
+} while (0)
+
+#define get_late_lua_direct_value(L,n) do {                  \
+    if (late_lua_type(n) == lua_refid_literal) {             \
+        lua_rawgeti(L, LUA_REGISTRYINDEX, late_lua_data(n)); \
+    } else if (late_lua_type(n) == lua_refid_call) {         \
+        lua_pushinteger(L, late_lua_data(n));                \
+    } else if (late_lua_type(n) == normal) {                 \
+        tokenlist_to_luastring(L, late_lua_data(n));         \
+    }                                                        \
+} while (0)
+
+#define set_special_direct_value(L,n,i) do { \
+    write_tokens(n) = nodelib_gettoks(L, i); \
+} while (0)
+
+#define get_special_direct_value(L,n) do {     \
+    tokenlist_to_luastring(L, write_tokens(n)); \
+} while (0)
+
+#define set_write_direct_value(L,n,i) do {   \
+    write_tokens(n) = nodelib_gettoks(L, i); \
+} while (0)
+
+#define get_write_direct_value(L,n) do {  \
+    tokenlist_to_lua(L, write_tokens(n)); \
+} while (0)
+
+#define set_pdf_setmatrix_direct_value(L,n,i) do { \
+    pdf_setmatrix_data(n) = nodelib_gettoks(L, i);  \
+} while (0)
+
+#define get_pdf_setmatrix_direct_value(L,n) do {     \
+    tokenlist_to_luastring(L, pdf_setmatrix_data(n)); \
+} while (0)
+
+/*tex
+
+    These getter and setter get |data| as well as |value| fields. One can
+    make them equivalent to |getvalue| and |setvalue| if needed.
+
+*/
+
+static int lua_nodelib_direct_getdata(lua_State * L)
+{
+    halfword n = lua_tointeger(L, 1);
+    if (n == null) {
+        lua_pushnil(L);
+    } else {
+        halfword t = type(n) ;
+        if (t == glyph_node) {
+            lua_pushinteger(L,glyph_node_data(n));
+        } else if (t == boundary_node) {
+            lua_pushinteger(L,boundary_value(n));
+        } else if (t == whatsit_node) {
+            halfword s = subtype(n);
+            if (s == user_defined_node) {
+                get_user_node_direct_value(L, n);
+            } else if (s == pdf_literal_node) {
+                get_pdf_literal_direct_value(L, n);
+                /*tex A bonus. */
+                lua_pushinteger(L,pdf_literal_mode(n));
+                return 2;
+            } else if (s == late_lua_node) {
+                get_late_lua_direct_value(L, n);
+            } else if (s == pdf_setmatrix_node) {
+                get_pdf_setmatrix_direct_value(L, n);
+            } else if (s == special_node) {
+                get_special_direct_value(L, n);
+            } else if (s == write_node) {
+                get_write_direct_value(L, n);
+            } else {
+                lua_pushnil(L);
+            }
+        } else {
+            lua_pushnil(L);
+        }
+    }
+    return 1;
+}
+
+static int lua_nodelib_direct_setdata(lua_State * L) /* data and value */
+{
+    halfword n = lua_tointeger(L, 1);
+    if (n != null) {
+        halfword t = type(n) ;
+        if (t == glyph_node) {
+            glyph_node_data(n) = lua_tointeger(L,2);
+        } else if (t == boundary_node) {
+            boundary_value(n) = lua_tointeger(L,2);
+        } else if (t == whatsit_node) {
+            halfword s = subtype(n);
+            if (s == user_defined_node) {
+                set_user_node_direct_value(L, n, 2);
+            } else if (s == pdf_literal_node) {
+                set_pdf_literal_direct_normal(L, n, 2);
+                if (lua_type(L,2) == LUA_TNUMBER) {
+                    /*tex A bonus. */
+                    pdf_literal_mode(n) = lua_tointeger(L,2);
+                }
+            } else if (s == late_lua_node) {
+                set_late_lua_direct_normal(L, n, 2);
+            } else if (s == pdf_setmatrix_node) {
+                set_pdf_setmatrix_direct_value(L, n, 2);
+            } else if (s == special_node) {
+                set_special_direct_value(L, n, 2);
+            } else if (s == write_node) {
+                set_write_direct_value(L,n,2);
+            }
+        }
+    }
+    return 0;
+}
+
 /* node.direct.getnext */
 /* node.direct.setnext */
 
@@ -1488,11 +1969,13 @@ static int lua_nodelib_type(lua_State * L)
     if (lua_type(L,1) == LUA_TNUMBER) {
         int i = lua_tointeger(L, 1);
         if (known_node_type(i)) {
-            lua_pushstring(L, node_data[i].name);
+         /* lua_pushstring(L, node_data[i].name); */
+            lua_push_string_by_index(L, node_data[i].lua);
             return 1;
         }
     } else if (maybe_isnode(L, 1) != NULL) {
-        lua_pushstring(L,"node");
+     /* lua_pushstring(L,"node"); */
+        lua_push_string_by_name(L,node);
         return 1;
     }
     lua_pushnil(L);
@@ -1501,10 +1984,9 @@ static int lua_nodelib_type(lua_State * L)
 
 /* node.new (allocate a new node) */
 
-static int lua_nodelib_new(lua_State * L)
+static halfword lua_nodelib_new_node(lua_State * L)
 {
     int i, j;
-    halfword n = null;
     int t = lua_type(L, 1);
     if (t == LUA_TNUMBER) {
         i = lua_tointeger(L,1);
@@ -1536,33 +2018,26 @@ static int lua_nodelib_new(lua_State * L)
         }
     } else if (t == LUA_TNUMBER) {
         j = (int) lua_tointeger(L, 2);
+    } else if (t == LUA_TSTRING) {
+        j = get_node_subtype_id_from_name(L,2,node_data[i].subtypes);
     } else {
         j = 0;
     }
-    n = new_node(i, j);
+    return new_node(i, j);
+}
+
+static int lua_nodelib_new(lua_State * L)
+{
+    halfword n = lua_nodelib_new_node(L);
     lua_nodelib_push_fast(L, n);
     return 1;
 }
 
-/* node.direct.new (still with checking) */
+/* node.direct.new */
 
 static int lua_nodelib_direct_new(lua_State * L)
 {
-    int j;
-    halfword n ;
-    int i = get_valid_node_type_id(L, 1);
-    if (i == whatsit_node) {
-        j = -1;
-        if (lua_gettop(L) > 1)
-            j = get_valid_node_subtype_id(L, 2);
-        if (j < 0)
-            luaL_error(L, "Creating a whatsit requires the subtype number as a second argument");
-    } else {
-        j = 0;
-        if (lua_gettop(L) > 1)
-            j = (int) lua_tointeger(L, 2);
-    }
-    n = new_node(i, j);
+    halfword n = lua_nodelib_new_node(L);
     lua_pushinteger(L,n);
     return 1;
 }
@@ -1704,9 +2179,6 @@ static int lua_nodelib_remove(lua_State * L)
             alink(vlink(current)) = t;
         current = vlink(current);
     }
-#if DEBUG
-    show_node_links(head, "after");
-#endif
     /* can be: lua_nodelib_push_fast(L, head); */
     lua_pushinteger(L, head);
     lua_nodelib_push(L);
@@ -1843,8 +2315,9 @@ static int lua_nodelib_direct_insert_before(lua_State * L)
         current = tail_of_list(head);
     if (head != current) {
         halfword t = alink(current);
-        if (t == null || vlink(t) != current)
+        if (t == null || vlink(t) != current) {
             set_t_to_prev(head, current);
+        }
         couple_nodes(t, n);
     }
     couple_nodes(n, current); /*  nice but incompatible: couple_nodes(tail_of_list(n),current) */
@@ -2091,8 +2564,10 @@ static int lua_nodelib_hpack(lua_State * L)
                 luaL_error(L, "wrong mode in hpack");
             }
             if (lua_gettop(L) > 3) {
-                if (lua_type(L, 4) == LUA_TSTRING) {
-                    d = nodelib_getdir(L, 4, 1);
+                if (lua_type(L, 4) == LUA_TNUMBER) {
+                    d = nodelib_getdirection(L, 4);
+                } else if (lua_type(L, 4) == LUA_TSTRING) {
+                    d = nodelib_getdir_par(L, 4);
                 } else {
                     lua_pushstring(L, "incorrect 4th argument");
                 }
@@ -2138,8 +2613,10 @@ static int lua_nodelib_direct_hpack(lua_State * L)
                 lua_pushstring(L, "incorrect 3rd argument");
             }
             if (lua_gettop(L) > 3) {
-                if (lua_type(L, 4) == LUA_TSTRING) {
-                    d = nodelib_getdir(L, 4, 1);
+                if (lua_type(L, 4) == LUA_TNUMBER) {
+                    d = nodelib_getdirection(L, 4);
+                } else if (lua_type(L, 4) == LUA_TSTRING) {
+                    d = nodelib_getdir_par(L, 4);
                 } else {
                     lua_pushstring(L, "incorrect 4th argument");
                 }
@@ -2177,8 +2654,10 @@ static int lua_nodelib_vpack(lua_State * L)
                 }
 
                 if (lua_gettop(L) > 3) {
-                    if (lua_type(L, 4) == LUA_TSTRING) {
-                        d = nodelib_getdir(L, 4, 1);
+                    if (lua_type(L, 4) == LUA_TNUMBER) {
+                        d = nodelib_getdirection(L, 4);
+                    } else if (lua_type(L, 4) == LUA_TSTRING) {
+                        d = nodelib_getdir_par(L, 4);
                     } else {
                         lua_pushstring(L, "incorrect 4th argument");
                     }
@@ -2222,8 +2701,10 @@ static int lua_nodelib_direct_vpack(lua_State * L)
                 }
 
                 if (lua_gettop(L) > 3) {
-                    if (lua_type(L, 4) == LUA_TSTRING) {
-                        d = nodelib_getdir(L, 4, 1);
+                    if (lua_type(L, 4) == LUA_TNUMBER) {
+                        d = nodelib_getdirection(L, 4);
+                    } else if (lua_type(L, 4) == LUA_TSTRING) {
+                        d = nodelib_getdir_par(L, 4);
                     } else {
                         lua_pushstring(L, "incorrect 4th argument");
                     }
@@ -2269,13 +2750,17 @@ static int lua_nodelib_dimensions(lua_State * L)
         n = *(check_isnode(L, i));
         if (lua_gettop(L) > i && !lua_isnil(L, (i + 1))) {
             if (lua_type(L, (i + 1)) == LUA_TSTRING) {
-                d = nodelib_getdir(L, (i + 1), 1);
+                d = nodelib_getdir_par(L, (i + 1));
             } else {
                 p = *(check_isnode(L, (i + 1)));
             }
         }
-        if (lua_gettop(L) > (i + 1) && lua_type(L, (i + 2)) == LUA_TSTRING) {
-            d = nodelib_getdir(L, (i + 2), 1);
+        if (lua_gettop(L) > (i + 1)) {
+            if (lua_type(L, (i + 2)) == LUA_TNUMBER) {
+                d = nodelib_getdirection(L, (i + 2));
+            } else if (lua_type(L, (i + 2)) == LUA_TSTRING) {
+                d = nodelib_getdir_par(L, (i + 2));
+            }
         }
         siz = natural_sizes(n, p, g_mult, g_sign, g_order, d);
         lua_pushinteger(L, siz.wd);
@@ -2322,7 +2807,8 @@ static int lua_nodelib_direct_dimensions(lua_State * L)
         int g_order = normal;
         int i = 1;
         int d = -1;
-        halfword n = null, p = null;
+        halfword n = null;
+        halfword p = null;
         if (top > 3) {
             i += 3;
             g_mult = (glue_ratio) lua_tonumber(L, 1); /* integer or float */
@@ -2332,13 +2818,18 @@ static int lua_nodelib_direct_dimensions(lua_State * L)
         n = (halfword) lua_tointeger(L,i);
         if (lua_gettop(L) > i && !lua_isnil(L, (i + 1))) {
             if (lua_type(L, (i + 1)) == LUA_TSTRING) {
-                d = nodelib_getdir(L, (i + 1), 1);
+                d = nodelib_getdir_par(L, (i + 1));
             } else {
                 p = (halfword) lua_tointeger(L,i+1);
             }
         }
-        if (lua_gettop(L) > (i + 1) && lua_type(L, (i + 2)) == LUA_TSTRING)
-            d = nodelib_getdir(L, (i + 2), 1);
+        if (lua_gettop(L) > (i + 1)) {
+            if (lua_type(L, (i + 2)) == LUA_TNUMBER) {
+                d = nodelib_getdirection(L, (i + 2));
+            } else if (lua_type(L, (i + 2)) == LUA_TSTRING) {
+                d = nodelib_getdir_par(L, (i + 2));
+            }
+        }
         siz = natural_sizes(n, p, g_mult, g_sign, g_order, d);
         lua_pushinteger(L, siz.wd);
         lua_pushinteger(L, siz.ht);
@@ -2383,7 +2874,7 @@ static int lua_nodelib_mlist_to_hlist(lua_State * L)
     luaL_checkany(L, 3);
     m = lua_toboolean(L, 3);
     mlist_to_hlist(n, m, w);
-    alink(vlink(temp_head)) = null; /*hh-ls */
+    alink(vlink(temp_head)) = null;
     lua_nodelib_push_fast(L, vlink(temp_head));
     return 1;
 }
@@ -2407,8 +2898,8 @@ static int lua_nodelib_mfont(lua_State * L)
     identifiers.  It has to do some more work, because not all
     identifiers are valid for all types of nodes.
 
-    If really needed we can optimize this one using a big if ..
-    .. else like with the getter and setter.
+    We can make this faster if needed but when this needs to
+    be called often something is wrong with the code.
 
 */
 
@@ -2438,16 +2929,19 @@ static int get_node_field_id(lua_State * L, int n, int node)
         }
     } else {
         int j;
-        const char **fields = node_data[t].fields;
+        field_info *fields ;
         if (t == whatsit_node) {
             fields = whatsit_node_data[subtype(node)].fields;
+        } else {
+            fields = node_data[t].fields;
         }
         if (lua_key_eq(s, list)) {
             s = lua_key(head);
         }
         if (fields != NULL) {
-            for (j = 0; fields[j] != NULL; j++) {
-                if (strcmp(s, fields[j]) == 0) {
+            for (j = 0; fields[j].lua != 0; j++) {
+             // if (strcmp(s, fields[j]) == 0) {
+                if (fields[j].name == s) {
                     return j + 3;
                 }
             }
@@ -2549,7 +3043,7 @@ static int lua_nodelib_fields(lua_State * L)
 {
     int i = -1;
     int offset = 2;
-    const char **fields;
+    field_info *fields;
     int t = get_valid_node_type_id(L, 1);
     if (t == whatsit_node) {
         t = get_valid_node_subtype_id(L, 2);
@@ -2573,26 +3067,63 @@ static int lua_nodelib_fields(lua_State * L)
         lua_rawseti(L, -2, -1);
     }
     if (fields != NULL) {
-        for (i = 0; fields[i] != NULL; i++) {
-            lua_pushstring(L, fields[i]); /* todo */
+        for (i = 0; fields[i].lua != 0; i++) {
+         // lua_pushstring(L, fields[i]); /* todo */
+            lua_rawgeti(L, LUA_REGISTRYINDEX, fields[i].lua);
             lua_rawseti(L, -2, (i + offset));
         }
     }
     return 1;
 }
 
+static int lua_nodelib_values(lua_State * L)
+{
+    int i = -1;
+    subtype_info *values = NULL;
+    const char *s ;
+    int t = lua_type(L,1);
+    if (t == LUA_TSTRING) {
+        /*
+            delimiter options (bit set)
+            delimiter modes   (bit set)
+        */
+        s = lua_tostring(L,1);
+             if (lua_key_eq(s,dir))         values = node_values_dir;
+        else if (lua_key_eq(s,direction))   values = node_values_dir;
+        else if (lua_key_eq(s,glue))        values = node_values_fill;
+        /* backend */
+        else if (lua_key_eq(s,pdf_literal)) values = node_values_pdf_literal;
+        else if (lua_key_eq(s,pdf_action))  values = node_values_pdf_action;
+        else if (lua_key_eq(s,pdf_window))  values = node_values_pdf_window;
+        else if (lua_key_eq(s,color_stack)) values = node_values_color_stack;
+        /* extras */
+        else if (lua_key_eq(s,pagestate))   values = other_values_page_states;
+    }
+    if (values != NULL) {
+        lua_checkstack(L, 2);
+        lua_newtable(L);
+        for (i = 0; values[i].id >= 0 ; i++) {
+            lua_rawgeti(L, LUA_REGISTRYINDEX, values[i].lua);
+            lua_rawseti(L, -2, values[i].id);
+        }
+    } else {
+        lua_pushnil(L);
+    }
+    return 1;
+}
+
 static int lua_nodelib_subtypes(lua_State * L)
 {
     int i = -1;
-    int l = 0;
-    const char **subtypes = NULL;
+    subtype_info *subtypes = NULL;
     const char *s ;
     int t = lua_type(L,1);
     if (t == LUA_TSTRING) {
         /* official accessors */
         s = lua_tostring(L,1);
              if (lua_key_eq(s,glyph))           subtypes = node_subtypes_glyph;
-        else if (lua_key_eq(s,glue))          { subtypes = node_subtypes_glue; l = 1; }
+        else if (lua_key_eq(s,glue))            subtypes = node_subtypes_glue;
+        else if (lua_key_eq(s,dir))             subtypes = node_subtypes_dir;
         else if (lua_key_eq(s,boundary))        subtypes = node_subtypes_boundary;
         else if (lua_key_eq(s,penalty))         subtypes = node_subtypes_penalty;
         else if (lua_key_eq(s,kern))            subtypes = node_subtypes_kern;
@@ -2602,8 +3133,8 @@ static int lua_nodelib_subtypes(lua_State * L)
              ||  lua_key_eq(s,vlist))           subtypes = node_subtypes_list; /* too many but ok as reserved */
         else if (lua_key_eq(s,adjust))          subtypes = node_subtypes_adjust;
         else if (lua_key_eq(s,disc))            subtypes = node_subtypes_disc;
-        else if (lua_key_eq(s,fill))            subtypes = node_subtypes_fill;
-        else if (lua_key_eq(s,leader))        { subtypes = node_subtypes_leader; l = 2; }
+        else if (lua_key_eq(s,fill))            subtypes = node_values_fill;
+        else if (lua_key_eq(s,leader))          subtypes = node_subtypes_leader;
         else if (lua_key_eq(s,marginkern))      subtypes = node_subtypes_marginkern;
         else if (lua_key_eq(s,math))            subtypes = node_subtypes_math;
         else if (lua_key_eq(s,noad))            subtypes = node_subtypes_noad;
@@ -2611,13 +3142,14 @@ static int lua_nodelib_subtypes(lua_State * L)
         else if (lua_key_eq(s,accent))          subtypes = node_subtypes_accent;
         else if (lua_key_eq(s,fence))           subtypes = node_subtypes_fence;
         /* backend */
-        else if (lua_key_eq(s,pdf_destination)) subtypes = node_subtypes_pdf_destination;
-        else if (lua_key_eq(s,pdf_literal))     subtypes = node_subtypes_pdf_literal;
+        else if (lua_key_eq(s,pdf_destination)) subtypes = node_values_pdf_destination;
+        else if (lua_key_eq(s,pdf_literal))     subtypes = node_values_pdf_literal;
     } else if (t == LUA_TNUMBER) {
         /* maybe */
         t = lua_tointeger(L,1);
              if (t == glyph_node)               subtypes = node_subtypes_glyph;
-        else if (t == glue_node)              { subtypes = node_subtypes_glue; l = 1; }
+        else if (t == glue_node)                subtypes = node_subtypes_glue;
+        else if (t == dir_node)                 subtypes = node_subtypes_dir;
         else if (t == boundary_node)            subtypes = node_subtypes_boundary;
         else if (t == penalty_node)             subtypes = node_subtypes_penalty;
         else if (t == kern_node)                subtypes = node_subtypes_kern;
@@ -2626,7 +3158,7 @@ static int lua_nodelib_subtypes(lua_State * L)
              || (t == vlist_node))              subtypes = node_subtypes_list;
         else if (t == adjust_node)              subtypes = node_subtypes_adjust;
         else if (t == disc_node)                subtypes = node_subtypes_disc;
-        else if (t == glue_spec_node)           subtypes = node_subtypes_fill;
+        else if (t == glue_spec_node)           subtypes = node_values_fill;
         else if (t == margin_kern_node)         subtypes = node_subtypes_marginkern;
         else if (t == math_node)                subtypes = node_subtypes_math;
         else if (t == simple_noad)              subtypes = node_subtypes_noad;
@@ -2634,29 +3166,15 @@ static int lua_nodelib_subtypes(lua_State * L)
         else if (t == accent_noad)              subtypes = node_subtypes_accent;
         else if (t == fence_noad)               subtypes = node_subtypes_fence;
         /* backend */
-        else if (t == pdf_dest_node)            subtypes = node_subtypes_pdf_destination;
-        else if (t == pdf_literal_node)         subtypes = node_subtypes_pdf_literal;
+        else if (t == pdf_dest_node)            subtypes = node_values_pdf_destination;
+        else if (t == pdf_literal_node)         subtypes = node_values_pdf_literal;
     }
     if (subtypes != NULL) {
         lua_checkstack(L, 2);
         lua_newtable(L);
-        if (l < 2) {
-            for (i = 0; subtypes[i] != NULL; i++) {
-                lua_pushstring(L, subtypes[i]); /* todo */
-                lua_rawseti(L, -2, i);
-            }
-        }
-        if (l > 0) {
-            /* add math states */
-            for (i = 0; node_subtypes_mathglue[i] != NULL; i++) {
-                lua_pushstring(L, node_subtypes_mathglue[i]); /* todo */
-                lua_rawseti(L, -2, 98 + i);
-            }
-            /* add leaders */
-            for (i = 0; node_subtypes_leader[i] != NULL; i++) {
-                lua_pushstring(L, node_subtypes_leader[i]); /* todo */
-                lua_rawseti(L, -2, 100 + i);
-            }
+        for (i = 0; subtypes[i].id >= 0 ; i++) {
+            lua_rawgeti(L, LUA_REGISTRYINDEX, subtypes[i].lua);
+            lua_rawseti(L, -2, subtypes[i].id);
         }
     } else {
         lua_pushnil(L);
@@ -2823,7 +3341,10 @@ static int lua_nodelib_get_attribute(lua_State * L)
         if (p != null) {
             p = vlink(p);
             if (p != null) {
-                int i = lua_tointeger(L, 2);
+                int i = 0;
+                if (lua_gettop(L) > 1) {
+                    i = lua_tointeger(L, 2);
+                }
                 while (p != null) {
                     if (attribute_id(p) == i) {
                         int ret = attribute_value(p);
@@ -2895,7 +3416,10 @@ static int lua_nodelib_direct_get_attribute(lua_State * L)
         if (p != null) {
             p = vlink(p);
             if (p != null) {
-                int i = lua_tointeger(L, 2);
+                int i = 0;
+                if (lua_gettop(L) > 1) {
+                    i = lua_tointeger(L, 2);
+                }
                 while (p != null) {
                     if (attribute_id(p) == i) {
                         int ret = attribute_value(p);
@@ -3049,10 +3573,24 @@ static int lua_nodelib_direct_getwidth(lua_State * L)
         if (t == hlist_node || t == vlist_node || t == rule_node) {
             lua_pushinteger(L,width(n));
         } else if (t == glyph_node) {
-            lua_pushinteger(L, char_width(font(n),character(n)));
+            if (lua_toboolean(L,2)) {
+                lua_pushnumber(L, (1+ex_glyph(n)/1000) * char_width(font(n),character(n)));
+                lua_pushinteger(L, ex_glyph(n));
+                return 2;
+            } else {
+                lua_pushinteger(L, char_width(font(n),character(n)));
+            }
         } else if (t == glue_node || t == glue_spec_node || t == math_node || t == ins_node) {
             lua_pushinteger(L,width(n));
-        } else if (t == kern_node || t == margin_kern_node) {
+        } else if (t == kern_node) {
+            if (lua_toboolean(L,2)) {
+                lua_pushnumber(L, (1+ex_kern(n)/1000) * width(n));
+                lua_pushinteger(L, ex_kern(n));
+                return 2;
+            } else {
+                lua_pushinteger(L, width(n));
+            }
+        } else if (t == margin_kern_node) {
             lua_pushinteger(L,width(n));
         } else if (t == unset_node) {
             lua_pushinteger(L,width(n));
@@ -3071,7 +3609,8 @@ static int lua_nodelib_direct_setwidth(lua_State * L)
     if (n) {
         halfword t = type(n);
         if (t == hlist_node || t == vlist_node || t == rule_node || t == glue_node || t == glue_spec_node || t == math_node ||
-                t == kern_node || t == margin_kern_node ||  t == ins_node || t == unset_node) {
+                t == kern_node || t == margin_kern_node ||  t == ins_node || t == unset_node ||
+                t == fraction_noad || t == radical_noad ) {
             if (lua_type(L, 2) == LUA_TNUMBER) {
                 width(n) = lua_roundnumber(L,2);
             } else {
@@ -3093,6 +3632,8 @@ static int lua_nodelib_direct_getheight(lua_State * L)
             lua_pushinteger(L, char_height(font(n),character(n)));
         } else if (t == unset_node || t == ins_node) {
             lua_pushinteger(L,height(n));
+        } else if (t == fence_noad) {
+            lua_pushinteger(L,delimiterheight(n));
         } else {
             lua_pushnil(L);
         }
@@ -3107,12 +3648,14 @@ static int lua_nodelib_direct_setheight(lua_State * L)
     halfword n = lua_tointeger(L, 1);
     if (n) {
         halfword t = type(n);
+        halfword h = 0;
+        if (lua_type(L, 2) == LUA_TNUMBER) {
+            h = lua_roundnumber(L,2);
+        }
         if (t == hlist_node || t == vlist_node || t == rule_node || t == unset_node) {
-            if (lua_type(L, 2) == LUA_TNUMBER) {
-                height(n) = lua_roundnumber(L,2);
-            } else {
-                height(n) = 0;
-            }
+            height(n) = h;
+        } else if (t == fence_noad) {
+            delimiterheight(n) = h;
         }
     }
     return 0;
@@ -3129,6 +3672,8 @@ static int lua_nodelib_direct_getdepth(lua_State * L)
             lua_pushinteger(L, char_depth(font(n),character(n)));
         } else if (t == unset_node || t == ins_node) {
             lua_pushinteger(L,depth(n));
+        } else if (t == fence_noad) {
+            lua_pushinteger(L,delimiterdepth(n));
         } else {
             lua_pushnil(L);
         }
@@ -3143,12 +3688,14 @@ static int lua_nodelib_direct_setdepth(lua_State * L)
     halfword n = lua_tointeger(L, 1);
     if (n) {
         halfword t = type(n);
+        halfword d = 0;
+        if (lua_type(L, 2) == LUA_TNUMBER) {
+            d = lua_roundnumber(L,2);
+        }
         if (t == hlist_node || t == vlist_node || t == rule_node || t == unset_node) {
-            if (lua_type(L, 2) == LUA_TNUMBER) {
-                depth(n) = lua_roundnumber(L,2);
-            } else {
-                depth(n) = 0;
-            }
+            depth(n) = d;
+        } else if (t == fence_noad) {
+            delimiterdepth(n) = d;
         }
     }
     return 0;
@@ -3324,9 +3871,51 @@ static int nodelib_aux_nil(lua_State * L)
     return 1;
 }
 
-/* node.direct.traverse_id */
 /* node.direct.traverse */
+/* node.direct.traverse_id */
 /* node.direct.traverse_char */
+/* node.direct.traverse_glyph */
+/* node.direct.traverse_list */
+
+static int nodelib_direct_aux_next(lua_State * L)
+{
+    halfword t;
+    if (lua_isnil(L, 2)) {
+        t = lua_tointeger(L,1) ;
+        lua_settop(L,1);
+    } else {
+        t = lua_tointeger(L,2) ;
+        t = vlink(t);
+        lua_settop(L,2);
+    }
+    if (t == null) {
+        lua_pushnil(L);
+        return 1;
+    } else {
+        lua_pushinteger(L,t);
+        lua_pushinteger(L,type(t));
+        lua_pushinteger(L,subtype(t));
+        return 3;
+    }
+}
+
+static int lua_nodelib_direct_traverse(lua_State * L)
+{
+    halfword n;
+    if (lua_isnil(L, 1)) {
+        lua_pushcclosure(L, nodelib_aux_nil, 0);
+        return 1;
+    }
+    n = (halfword) lua_tointeger(L, 1);
+    if (n == null) {
+        lua_pushcclosure(L, nodelib_aux_nil, 0);
+        return 1;
+    }
+    lua_pushcclosure(L, nodelib_direct_aux_next, 0);
+    lua_pushinteger(L,n);
+    lua_pushnil(L);
+    return 3;
+}
 
 static int nodelib_direct_aux_next_filtered(lua_State * L)
 {
@@ -3340,18 +3929,17 @@ static int nodelib_direct_aux_next_filtered(lua_State * L)
         t = vlink(t);
         lua_settop(L,2);
     }
-    while (1) {
-        if (t == null) {
-            break;
-        } else if (type(t) == i) {
-            lua_pushinteger(L,t);
-            return 1;
-        } else {
-            t = vlink(t);
-        }
+    while (t != null && type(t) != i) {
+        t = vlink(t);
+    }
+    if (t == null) {
+        lua_pushnil(L);
+        return 1;
+    } else {
+        lua_pushinteger(L,t);
+        lua_pushinteger(L,subtype(t));
+        return 2;
     }
-    lua_pushnil(L);
-    return 1;
 }
 
 static int lua_nodelib_direct_traverse_filtered(lua_State * L)
@@ -3371,7 +3959,7 @@ static int lua_nodelib_direct_traverse_filtered(lua_State * L)
     return 3;
 }
 
-static int nodelib_direct_aux_next(lua_State * L)
+static int nodelib_direct_aux_next_char(lua_State * L)
 {
     halfword t;            /* traverser */
     if (lua_isnil(L, 2)) { /* first call */
@@ -3382,15 +3970,21 @@ static int nodelib_direct_aux_next(lua_State * L)
         t = vlink(t);
         lua_settop(L,2);
     }
+    while (! ((t == null) || (type(t) == glyph_node && subtype(t) < 256))) {
+        t = vlink(t);
+    }
     if (t == null) {
         lua_pushnil(L);
+        return 1;
     } else {
         lua_pushinteger(L,t);
+        lua_pushinteger(L,character(t));
+        lua_pushinteger(L,font(t));
+        return 3;
     }
-    return 1;
 }
 
-static int lua_nodelib_direct_traverse(lua_State * L)
+static int lua_nodelib_direct_traverse_char(lua_State * L)
 {
     halfword n;
     if (lua_isnil(L, 1)) {
@@ -3402,13 +3996,13 @@ static int lua_nodelib_direct_traverse(lua_State * L)
         lua_pushcclosure(L, nodelib_aux_nil, 0);
         return 1;
     }
-    lua_pushcclosure(L, nodelib_direct_aux_next, 0);
+    lua_pushcclosure(L, nodelib_direct_aux_next_char, 0);
     lua_pushinteger(L,n);
     lua_pushnil(L);
     return 3;
 }
 
-static int nodelib_direct_aux_next_char(lua_State * L)
+static int nodelib_direct_aux_next_glyph(lua_State * L)
 {
     halfword t;            /* traverser */
     if (lua_isnil(L, 2)) { /* first call */
@@ -3419,21 +4013,65 @@ static int nodelib_direct_aux_next_char(lua_State * L)
         t = vlink(t);
         lua_settop(L,2);
     }
-    while (1) {
-        if (t == null) {
-            break;
-        } else if ((type(t) == glyph_node) && (subtype(t) < 256)){
-            lua_pushinteger(L,t);
-            return 1;
-        } else {
-            t = vlink(t);
-        }
+    while (t != null && type(t) != glyph_node) {
+        t = vlink(t);
+    }
+    if (t == null) {
+        lua_pushnil(L);
+        return 1;
+    } else {
+        lua_pushinteger(L,t);
+        lua_pushinteger(L,character(t));
+        lua_pushinteger(L,font(t));
+        return 3;
     }
+}
+
+static int lua_nodelib_direct_traverse_glyph(lua_State * L)
+{
+    halfword n;
+    if (lua_isnil(L, 1)) {
+        lua_pushcclosure(L, nodelib_aux_nil, 0);
+        return 1;
+    }
+    n = (halfword) lua_tointeger(L, 1);
+    if (n == null) {
+        lua_pushcclosure(L, nodelib_aux_nil, 0);
+        return 1;
+    }
+    lua_pushcclosure(L, nodelib_direct_aux_next_glyph, 0);
+    lua_pushinteger(L,n);
     lua_pushnil(L);
-    return 1;
+    return 3;
 }
 
-static int lua_nodelib_direct_traverse_char(lua_State * L)
+static int nodelib_direct_aux_next_list(lua_State * L)
+{
+    halfword t;        /* traverser */
+    if (lua_isnil(L, 2)) {      /* first call */
+        t = lua_tointeger(L,1) ;
+        lua_settop(L,1);
+    } else {
+        t = lua_tointeger(L,2) ;
+        t = vlink(t);
+        lua_settop(L,2);
+    }
+    while (t != null && type(t) != hlist_node && type(t) != vlist_node) {
+        t = vlink(t);
+    }
+    if (t == null) {
+        lua_pushnil(L);
+        return 1;
+    } else {
+        lua_pushinteger(L,t);
+        lua_pushinteger(L,type(t));
+        lua_pushinteger(L,subtype(t));
+        nodelib_pushdirect_or_nil(list_ptr(t));
+        return 4;
+    }
+}
+
+static int lua_nodelib_direct_traverse_list(lua_State * L)
 {
     halfword n;
     if (lua_isnil(L, 1)) {
@@ -3445,22 +4083,101 @@ static int lua_nodelib_direct_traverse_char(lua_State * L)
         lua_pushcclosure(L, nodelib_aux_nil, 0);
         return 1;
     }
-    lua_pushcclosure(L, nodelib_direct_aux_next_char, 0);
-    lua_pushinteger(L,n);
+    lua_pushcclosure(L, nodelib_direct_aux_next_list, 1);
+    lua_pushinteger(L, n);
+    lua_pushnil(L);
+    return 3;
+}
+
+/* node.traverse */
+/* node.traverse_id */
+/* node.traverse_char */
+/* node.traverse_glyph */
+/* node.traverse_list */
+
+static int nodelib_aux_next(lua_State * L)
+{
+    halfword t;
+    halfword *a;
+    if (lua_isnil(L, 2)) {
+        t = *check_isnode(L, 1);
+        lua_settop(L,1);
+    } else {
+        t = *check_isnode(L, 2);
+        t = vlink(t);
+        lua_settop(L,2);
+    }
+    if (t == null) {
+        lua_pushnil(L);
+        return 1;
+    } else {
+        fast_metatable_top(t);
+        lua_pushinteger(L,type(t));
+        lua_pushinteger(L,subtype(t));
+        return 3;
+    }
+}
+
+static int lua_nodelib_traverse(lua_State * L)
+{
+    halfword n;
+    if (lua_isnil(L, 1)) {
+        lua_pushcclosure(L, nodelib_aux_nil, 0);
+        return 1;
+    }
+    n = *check_isnode(L, 1);
+    lua_pushcclosure(L, nodelib_aux_next, 0);
+    lua_nodelib_push_fast(L, n);
+    lua_pushnil(L);
+    return 3;
+}
+
+static int nodelib_aux_next_filtered(lua_State * L)
+{
+    halfword t;        /* traverser */
+    halfword *a;
+    int i = (int) lua_tointeger(L, lua_upvalueindex(1));
+    if (lua_isnil(L, 2)) {      /* first call */
+        t = *check_isnode(L, 1);
+        lua_settop(L,1);
+    } else {
+        t = *check_isnode(L, 2);
+        t = vlink(t);
+        lua_settop(L,2);
+    }
+    while (t != null && type(t) != i) {
+        t = vlink(t);
+    }
+    if (t == null) {
+        lua_pushnil(L);
+        return 1;
+    } else {
+        fast_metatable_top(t);
+        lua_pushinteger(L,subtype(t));
+        return 2;
+    }
+}
+
+static int lua_nodelib_traverse_filtered(lua_State * L)
+{
+    halfword n;
+    if (lua_isnil(L, 2)) {
+        lua_pushcclosure(L, nodelib_aux_nil, 0);
+        return 1;
+    }
+    n = *check_isnode(L, 2);
+    lua_pop(L, 1);              /* the node, integer remains */
+    lua_pushcclosure(L, nodelib_aux_next_filtered, 1);
+    lua_nodelib_push_fast(L, n);
     lua_pushnil(L);
     return 3;
 }
 
-/* node.traverse_id */
-/* node.traverse */
-/* node.traverse_char */
-
-static int nodelib_aux_next_filtered(lua_State * L)
+static int nodelib_aux_next_char(lua_State * L)
 {
-    halfword t;        /* traverser */
+    halfword t;            /* traverser */
     halfword *a;
-    int i = (int) lua_tointeger(L, lua_upvalueindex(1));
-    if (lua_isnil(L, 2)) {      /* first call */
+    if (lua_isnil(L, 2)) { /* first call */
         t = *check_isnode(L, 1);
         lua_settop(L,1);
     } else {
@@ -3468,36 +4185,38 @@ static int nodelib_aux_next_filtered(lua_State * L)
         t = vlink(t);
         lua_settop(L,2);
     }
-    while (t != null && type(t) != i) {
+    while (! ((t == null) || (type(t) == glyph_node && subtype(t) < 256))) {
         t = vlink(t);
     }
     if (t == null) {
         lua_pushnil(L);
+        return 1;
     } else {
         fast_metatable_top(t);
+        lua_pushinteger(L,character(t));
+        lua_pushinteger(L,font(t));
+        return 3;
     }
-    return 1;
 }
 
-static int lua_nodelib_traverse_filtered(lua_State * L)
+static int lua_nodelib_traverse_char(lua_State * L)
 {
     halfword n;
-    if (lua_isnil(L, 2)) {
+    if (lua_isnil(L, 1)) {
         lua_pushcclosure(L, nodelib_aux_nil, 0);
         return 1;
     }
-    n = *check_isnode(L, 2);
-    lua_pop(L, 1);              /* the node, integer remains */
-    lua_pushcclosure(L, nodelib_aux_next_filtered, 1);
+    n = *check_isnode(L, 1);
+    lua_pushcclosure(L, nodelib_aux_next_char, 0);
     lua_nodelib_push_fast(L, n);
     lua_pushnil(L);
     return 3;
 }
 
-static int nodelib_aux_next(lua_State * L)
+static int nodelib_aux_next_glyph(lua_State * L)
 {
     halfword t;            /* traverser */
-    halfword *a;           /* a or *a */
+    halfword *a;
     if (lua_isnil(L, 2)) { /* first call */
         t = *check_isnode(L, 1);
         lua_settop(L,1);
@@ -3506,15 +4225,21 @@ static int nodelib_aux_next(lua_State * L)
         t = vlink(t);
         lua_settop(L,2);
     }
+    while (t != null && type(t) != glyph_node) {
+        t = vlink(t);
+    }
     if (t == null) {
         lua_pushnil(L);
+        return 1;
     } else {
         fast_metatable_top(t);
+        lua_pushinteger(L,character(t));
+        lua_pushinteger(L,font(t));
+        return 3;
     }
-    return 1;
 }
 
-static int lua_nodelib_traverse(lua_State * L)
+static int lua_nodelib_traverse_glyph(lua_State * L)
 {
     halfword n;
     if (lua_isnil(L, 1)) {
@@ -3522,17 +4247,17 @@ static int lua_nodelib_traverse(lua_State * L)
         return 1;
     }
     n = *check_isnode(L, 1);
-    lua_pushcclosure(L, nodelib_aux_next, 0);
+    lua_pushcclosure(L, nodelib_aux_next_glyph, 0);
     lua_nodelib_push_fast(L, n);
     lua_pushnil(L);
     return 3;
 }
 
-static int nodelib_aux_next_char(lua_State * L)
+static int nodelib_aux_next_list(lua_State * L)
 {
-    halfword t;            /* traverser */
+    halfword t;        /* traverser */
     halfword *a;
-    if (lua_isnil(L, 2)) { /* first call */
+    if (lua_isnil(L, 2)) {      /* first call */
         t = *check_isnode(L, 1);
         lua_settop(L,1);
     } else {
@@ -3540,20 +4265,22 @@ static int nodelib_aux_next_char(lua_State * L)
         t = vlink(t);
         lua_settop(L,2);
     }
-    while (1) {
-        if (t == null) {
-            break;
-        } else if ((type(t) == glyph_node) && (subtype(t) < 256)){
-            fast_metatable_top(t);
-            return 1;
-        } else {
-            t = vlink(t);
-        }
+    while (t != null && type(t) != hlist_node && type(t) != vlist_node) {
+        t = vlink(t);
+    }
+    if (t == null) {
+        lua_pushnil(L);
+        return 1;
+    } else {
+        fast_metatable_top(t);
+        lua_pushinteger(L,type(t));
+        lua_pushinteger(L,subtype(t));
+        fast_metatable_or_nil(list_ptr(t));
+        return 4;
     }
-    return 1;
 }
 
-static int lua_nodelib_traverse_char(lua_State * L)
+static int lua_nodelib_traverse_list(lua_State * L)
 {
     halfword n;
     if (lua_isnil(L, 1)) {
@@ -3561,7 +4288,7 @@ static int lua_nodelib_traverse_char(lua_State * L)
         return 1;
     }
     n = *check_isnode(L, 1);
-    lua_pushcclosure(L, nodelib_aux_next_char, 0);
+    lua_pushcclosure(L, nodelib_aux_next_list, 1);
     lua_nodelib_push_fast(L, n);
     lua_pushnil(L);
     return 3;
@@ -3638,46 +4365,6 @@ static int lua_nodelib_count(lua_State * L)
     return do_lua_nodelib_count(L, m, i, n);
 }
 
-/* getting and setting fields (helpers) */
-
-int nodelib_getlist(lua_State * L, int n)
-{
-    if (lua_isuserdata(L, n)) {
-        halfword m = *check_isnode(L, n);
-        return m;
-    } else {
-        return null;
-    }
-}
-
-int nodelib_getdir(lua_State * L, int n, int absolute_only)
-{
-    if (lua_type(L, n) == LUA_TSTRING) {
-        const char *s = lua_tostring(L, n);
-        RETURN_DIR_VALUES(TLT);
-        RETURN_DIR_VALUES(TRT);
-        RETURN_DIR_VALUES(LTL);
-        RETURN_DIR_VALUES(RTT);
-        luaL_error(L, "Bad direction specifier %s", s);
-    } else {
-        luaL_error(L, "Direction specifiers have to be strings");
-    }
-    return 0;
-}
-
-static str_number nodelib_getstring(lua_State * L, int a)
-{
-    size_t k;
-    const char *s = lua_tolstring(L, a, &k);
-    return maketexlstring(s, k);
-}
-
-static int nodelib_cantset(lua_State * L, int n, const char *s)
-{
-    luaL_error(L,"You cannot set field %s in a node of type %s",s,node_data[type(n)].name);
-    return 0;
-}
-
 /* node.direct.getfield */
 
 static void lua_nodelib_getfield_whatsit(lua_State * L, int n, const char *s)
@@ -3690,54 +4377,48 @@ static void lua_nodelib_getfield_whatsit(lua_State * L, int n, const char *s)
             lua_pushinteger(L, user_node_type(n));
         } else if (lua_key_eq(s, value)) {
             switch (user_node_type(n)) {
-            case 'a':
-                nodelib_pushlist(L, user_node_value(n));
-                break;
-            case 'd':
-                lua_pushinteger(L, user_node_value(n));
-                break;
-            case 'l':
-                if (user_node_value(n) != 0) {
-                    lua_rawgeti(L, LUA_REGISTRYINDEX, user_node_value(n));
-                } else {
-                    lua_pushnil(L);
-                }
-                break;
-            case 'n':
-                nodelib_pushlist(L, user_node_value(n));
-                break;
-            case 's':
-                nodelib_pushstring(L, user_node_value(n));
-                break;
-            case 't':
-                tokenlist_to_lua(L, user_node_value(n));
-                break;
-            default:
-                lua_pushinteger(L, user_node_value(n));
-                break;
+                case 'a':
+                    nodelib_pushlist(L, user_node_value(n));
+                    break;
+                case 'd':
+                    lua_pushinteger(L, user_node_value(n));
+                    break;
+                case 'l':
+                    if (user_node_value(n) != 0) {
+                        lua_rawgeti(L, LUA_REGISTRYINDEX, user_node_value(n));
+                    } else {
+                        lua_pushnil(L);
+                    }
+                    break;
+                case 'n':
+                    nodelib_pushlist(L, user_node_value(n));
+                    break;
+                case 's':
+                    nodelib_pushstring(L, user_node_value(n));
+                    break;
+                case 't':
+                    tokenlist_to_lua(L, user_node_value(n));
+                    break;
+                default:
+                    lua_pushinteger(L, user_node_value(n));
+                    break;
             }
         } else {
             lua_pushnil(L);
         }
     } else if (t == pdf_literal_node) {
+        /*tex The |string| key is obsolete. */
         if (lua_key_eq(s, mode)) {
             lua_pushinteger(L, pdf_literal_mode(n));
-        } else if (lua_key_eq(s, data)) {
-            if (pdf_literal_type(n) == lua_refid_literal) {
-                lua_rawgeti(L, LUA_REGISTRYINDEX, pdf_literal_data(n));
-            } else {
-                tokenlist_to_luastring(L, pdf_literal_data(n));
-            }
+        } else if (lua_key_eq(s, data) || lua_key_eq(s, token) || lua_key_eq(s, string)) {
+            get_pdf_literal_direct_value(L, n);
         } else {
             lua_pushnil(L);
         }
     } else if (t == late_lua_node) {
-        if (lua_key_eq(s, string) || lua_key_eq(s, data)) {
-            if (late_lua_type(n) == lua_refid_literal) {
-                lua_rawgeti(L, LUA_REGISTRYINDEX, late_lua_data(n));
-            } else {
-                tokenlist_to_luastring(L, late_lua_data(n));
-            }
+        /*tex The |string| key is obsolete. */
+        if (lua_key_eq(s, data) || lua_key_eq(s, token) || lua_key_eq(s, string)) {
+            get_late_lua_direct_value(L,n);
         } else if (lua_key_eq(s, name)) {
             tokenlist_to_luastring(L, late_lua_name(n));
         } else {
@@ -3782,7 +4463,7 @@ static void lua_nodelib_getfield_whatsit(lua_State * L, int n, const char *s)
         }
     } else if (t == pdf_setmatrix_node) {
         if (lua_key_eq(s, data)) {
-            tokenlist_to_luastring(L, pdf_setmatrix_data(n));
+            get_pdf_setmatrix_direct_value(L,n);
         } else {
             lua_pushnil(L);
         }
@@ -3806,13 +4487,13 @@ static void lua_nodelib_getfield_whatsit(lua_State * L, int n, const char *s)
         if (lua_key_eq(s, stream)) {
             lua_pushinteger(L, write_stream(n));
         } else if (lua_key_eq(s, data)) {
-            tokenlist_to_lua(L, write_tokens(n));
+            get_write_direct_value(L,n);
         } else {
             lua_pushnil(L);
         }
     } else if (t == special_node) {
         if (lua_key_eq(s, data)) {
-            tokenlist_to_luastring(L, write_tokens(n));
+            get_special_direct_value(L,n);
         } else {
             lua_pushnil(L);
         }
@@ -3978,8 +4659,8 @@ static int lua_nodelib_fast_getfield(lua_State * L)
             lua_pushinteger(L, x_displace(n));
         } else if (lua_key_eq(s, yoffset)) {
             lua_pushinteger(L, y_displace(n));
-        } else if (lua_key_eq(s, xadvance)) {
-            lua_pushinteger(L, x_advance(n));
+        } else if (lua_key_eq(s, data)) {
+            lua_pushinteger(L, glyph_node_data(n));
         } else if (lua_key_eq(s, width)) {
             lua_pushinteger(L, char_width(font(n),character(n)));
         } else if (lua_key_eq(s, height)) {
@@ -4013,6 +4694,8 @@ static int lua_nodelib_fast_getfield(lua_State * L)
             lua_pushinteger(L, height(n));
         } else if (lua_key_eq(s, depth)) {
             lua_pushinteger(L, depth(n));
+        } else if (lua_key_eq(s, direction)) {
+            lua_pushinteger(L, box_dir(n));
         } else if (lua_key_eq(s, dir)) {
             lua_push_dir_par(L, box_dir(n));
         } else if (lua_key_eq(s, shift)) {
@@ -4086,6 +4769,12 @@ static int lua_nodelib_fast_getfield(lua_State * L)
             lua_pushinteger(L, height(n));
         } else if (lua_key_eq(s, depth)) {
             lua_pushinteger(L, depth(n));
+        } else if (lua_key_eq(s, left)) {
+            lua_pushinteger(L,rule_left(n));
+        } else if (lua_key_eq(s, right)) {
+            lua_pushinteger(L,rule_right(n));
+        } else if (lua_key_eq(s, direction)) {
+            lua_pushinteger(L, rule_dir(n));
         } else if (lua_key_eq(s, dir)) {
             lua_push_dir_par(L, rule_dir(n));
         } else if (lua_key_eq(s, index)) {
@@ -4096,8 +4785,10 @@ static int lua_nodelib_fast_getfield(lua_State * L)
             lua_pushnil(L);
         }
     } else if (t == dir_node) {
-        if (lua_key_eq(s, dir)) {
-            lua_push_dir_text(L, dir_dir(n));
+        if (lua_key_eq(s, direction)) {
+            lua_pushinteger(L, dir_dir(n));
+        } else if (lua_key_eq(s, dir)) {
+            lua_push_dir_text(L, dir_dir(n),subtype(n));
         } else if (lua_key_eq(s, level)) {
             lua_pushinteger(L, dir_level(n));
         } else if (lua_key_eq(s, subtype)) { /* can be used for anything */
@@ -4110,6 +4801,8 @@ static int lua_nodelib_fast_getfield(lua_State * L)
             lua_pushinteger(L, local_pen_inter(n));
         } else if (lua_key_eq(s, pen_broken)) {
             lua_pushinteger(L, local_pen_broken(n));
+        } else if (lua_key_eq(s, direction)) {
+            lua_pushinteger(L, local_par_dir(n));
         } else if (lua_key_eq(s, dir)) {
             lua_push_dir_par(L, local_par_dir(n));
         } else if (lua_key_eq(s, box_left)) {
@@ -4241,6 +4934,8 @@ static int lua_nodelib_fast_getfield(lua_State * L)
             fast_metatable_or_nil(right_delimiter(n));
         } else if (lua_key_eq(s, middle)) {
             fast_metatable_or_nil(middle_delimiter(n));
+        } else if (lua_key_eq(s, fam)) {
+            lua_pushinteger(L, fraction_fam(n));
         } else if (lua_key_eq(s, options)) {
             lua_pushinteger(L, fractionoptions(n));
         } else {
@@ -4409,6 +5104,8 @@ static int lua_nodelib_fast_getfield(lua_State * L)
             lua_pushinteger(L, height(n));
         } else if (lua_key_eq(s, depth)) {
             lua_pushinteger(L, depth(n));
+        } else if (lua_key_eq(s, direction)) {
+            lua_pushinteger(L, box_dir(n));
         } else if (lua_key_eq(s, dir)) {
             lua_push_dir_par(L, box_dir(n));
         } else if (lua_key_eq(s, shrink)) {
@@ -4477,55 +5174,23 @@ static void lua_nodelib_direct_getfield_whatsit(lua_State * L, int n, const char
         } else if (lua_key_eq(s, type)) {
             lua_pushinteger(L, user_node_type(n));
         } else if (lua_key_eq(s, value)) {
-            switch (user_node_type(n)) {
-            case 'a':
-                nodelib_pushdirect(user_node_value(n));
-                break;
-            case 'd':
-                lua_pushinteger(L, user_node_value(n));
-                break;
-            case 'l':
-                if (user_node_value(n) != 0) {
-                    lua_rawgeti(L, LUA_REGISTRYINDEX, user_node_value(n));
-                } else {
-                    lua_pushnil(L);
-                }
-                break;
-            case 'n':
-                nodelib_pushdirect(user_node_value(n));
-                break;
-            case 's':
-                nodelib_pushstring(L, user_node_value(n));
-                break;
-            case 't':
-                tokenlist_to_lua(L, user_node_value(n));
-                break;
-            default:
-                lua_pushinteger(L, user_node_value(n));
-                break;
-            }
+            get_user_node_direct_value(L, n);
         } else {
             lua_pushnil(L);
         }
     } else if (t == pdf_literal_node) {
+        /*tex The |string| key is obsolete. */
         if (lua_key_eq(s, mode)) {
             lua_pushinteger(L, pdf_literal_mode(n));
-        } else if (lua_key_eq(s, data)) {
-            if (pdf_literal_type(n) == lua_refid_literal) {
-                lua_rawgeti(L, LUA_REGISTRYINDEX, pdf_literal_data(n));
-            } else {
-                tokenlist_to_luastring(L, pdf_literal_data(n));
-            }
+        } else if (lua_key_eq(s, data) || lua_key_eq(s, token) || lua_key_eq(s, string)) {
+            get_pdf_literal_direct_value(L, n);
         } else {
             lua_pushnil(L);
         }
     } else if (t == late_lua_node) {
-        if (lua_key_eq(s, string) || lua_key_eq(s, data)) {
-            if (late_lua_type(n) == lua_refid_literal) {
-                lua_rawgeti(L, LUA_REGISTRYINDEX, late_lua_data(n));
-            } else {
-                tokenlist_to_luastring(L, late_lua_data(n));
-            }
+        /*tex The |string| key is obsolete. */
+        if (lua_key_eq(s, data) || lua_key_eq(s, token) || lua_key_eq(s, string)) {
+            get_late_lua_direct_value(L,n);
         } else if (lua_key_eq(s, name)) {
             tokenlist_to_luastring(L, late_lua_name(n));
         } else {
@@ -4570,7 +5235,7 @@ static void lua_nodelib_direct_getfield_whatsit(lua_State * L, int n, const char
         }
     } else if (t == pdf_setmatrix_node) {
         if (lua_key_eq(s, data)) {
-            tokenlist_to_luastring(L, pdf_setmatrix_data(n));
+            get_pdf_setmatrix_direct_value(L,n);
         } else {
             lua_pushnil(L);
         }
@@ -4594,13 +5259,13 @@ static void lua_nodelib_direct_getfield_whatsit(lua_State * L, int n, const char
         if (lua_key_eq(s, stream)) {
             lua_pushinteger(L, write_stream(n));
         } else if (lua_key_eq(s, data)) {
-            tokenlist_to_lua(L, write_tokens(n));
+            get_write_direct_value(L,n);
         } else {
             lua_pushnil(L);
         }
     } else if (t == special_node) {
         if (lua_key_eq(s, data)) {
-            tokenlist_to_luastring(L, write_tokens(n));
+            get_special_direct_value(L,n);
         } else {
             lua_pushnil(L);
         }
@@ -4751,8 +5416,8 @@ static int lua_nodelib_direct_getfield(lua_State * L)
             lua_pushinteger(L, x_displace(n));
         } else if (lua_key_eq(s, yoffset)) {
             lua_pushinteger(L, y_displace(n));
-        } else if (lua_key_eq(s, xadvance)) {
-            lua_pushinteger(L, x_advance(n));
+        } else if (lua_key_eq(s, data)) {
+            lua_pushinteger(L, glyph_node_data(n));
         } else if (lua_key_eq(s, width)) {
             lua_pushinteger(L, char_width(font(n),character(n)));
         } else if (lua_key_eq(s, height)) {
@@ -4784,6 +5449,8 @@ static int lua_nodelib_direct_getfield(lua_State * L)
             lua_pushinteger(L, height(n));
         } else if (lua_key_eq(s, depth)) {
             lua_pushinteger(L, depth(n));
+        } else if (lua_key_eq(s, direction)) {
+            lua_pushinteger(L, box_dir(n));
         } else if (lua_key_eq(s, dir)) {
             lua_push_dir_par(L, box_dir(n));
         } else if (lua_key_eq(s, shift)) {
@@ -4847,6 +5514,12 @@ static int lua_nodelib_direct_getfield(lua_State * L)
             lua_pushinteger(L, height(n));
         } else if (lua_key_eq(s, depth)) {
             lua_pushinteger(L, depth(n));
+        } else if (lua_key_eq(s, left)) {
+            lua_pushinteger(L,rule_left(n));
+        } else if (lua_key_eq(s, right)) {
+            lua_pushinteger(L,rule_right(n));
+        } else if (lua_key_eq(s, direction)) {
+            lua_pushinteger(L, rule_dir(n));
         } else if (lua_key_eq(s, dir)) {
             lua_push_dir_par(L, rule_dir(n));
         } else if (lua_key_eq(s, index)) {
@@ -4857,8 +5530,10 @@ static int lua_nodelib_direct_getfield(lua_State * L)
             lua_pushnil(L);
         }
     } else if (t == dir_node) {
-        if (lua_key_eq(s, dir)) {
-            lua_push_dir_text(L, dir_dir(n));
+        if (lua_key_eq(s, direction)) {
+            lua_pushinteger(L, dir_dir(n));
+        } else if (lua_key_eq(s, dir)) {
+            lua_push_dir_text(L, dir_dir(n), subtype(n));
         } else if (lua_key_eq(s, level)) {
             lua_pushinteger(L, dir_level(n));
         } else if (lua_key_eq(s, subtype)) { /* can be used for anything */
@@ -4871,6 +5546,8 @@ static int lua_nodelib_direct_getfield(lua_State * L)
             lua_pushinteger(L, local_pen_inter(n));
         } else if (lua_key_eq(s, pen_broken)) {
             lua_pushinteger(L, local_pen_broken(n));
+        } else if (lua_key_eq(s, direction)) {
+            lua_pushinteger(L, local_par_dir(n));
         } else if (lua_key_eq(s, dir)) {
             lua_push_dir_par(L, local_par_dir(n));
         } else if (lua_key_eq(s, box_left)) {
@@ -4969,6 +5646,8 @@ static int lua_nodelib_direct_getfield(lua_State * L)
             nodelib_pushdirect_or_nil(right_delimiter(n));
         } else if (lua_key_eq(s, middle)) {
             nodelib_pushdirect_or_nil(middle_delimiter(n));
+        } else if (lua_key_eq(s, fam)) {
+            lua_pushinteger(L, fraction_fam(n));
         } else if (lua_key_eq(s, options)) {
             lua_pushinteger(L, fractionoptions(n));
         } else {
@@ -5111,6 +5790,8 @@ static int lua_nodelib_direct_getfield(lua_State * L)
             lua_pushinteger(L, height(n));
         } else if (lua_key_eq(s, depth)) {
             lua_pushinteger(L, depth(n));
+        } else if (lua_key_eq(s, direction)) {
+            lua_pushinteger(L, box_dir(n));
         } else if (lua_key_eq(s, dir)) {
             lua_push_dir_par(L, box_dir(n));
         } else if (lua_key_eq(s, shrink)) {
@@ -5213,7 +5894,7 @@ static int lua_nodelib_equal(lua_State * L)
 static int font_tex_ligaturing(lua_State * L)
 {
     /* on the stack are two nodes and a direction */
-    /* hh-ls: we need to deal with prev nodes when a range starts with a ligature */
+    /* we need to deal with prev nodes when a range starts with a ligature */
     halfword tmp_head;
     halfword h;
     halfword t = null;
@@ -5254,7 +5935,7 @@ static int font_tex_ligaturing(lua_State * L)
 static int font_tex_direct_ligaturing(lua_State * L)
 {
     /* on the stack are two nodes and a direction */
-    /* hh-ls: we need to deal with prev nodes when a range starts with a ligature */
+    /* we need to deal with prev nodes when a range starts with a ligature */
     halfword tmp_head;
     halfword h;
     halfword t = null;
@@ -5805,57 +6486,29 @@ static int lua_nodelib_direct_tonode(lua_State * L)
 
 /* node.setfield */
 
-#define cleanup_late_lua(n) do { \
-    if (late_lua_data(n) != 0) { \
-        if (late_lua_type(n) == normal) { \
-            delete_token_ref(late_lua_data(n)); \
-        } else if (late_lua_type(n) == lua_refid_literal) { \
-            luaL_unref(L, LUA_REGISTRYINDEX,late_lua_data(n)); \
-        } \
-    } \
-} while (0)
-
-#define cleanup_late_lua_name(n) do { \
-    if (late_lua_name(n) != 0) { \
-        delete_token_ref(late_lua_name(n)); \
-    } \
-} while (0)
-
 static int lua_nodelib_setfield_whatsit(lua_State * L, int n, const char *s)
 {
     int t = subtype(n);
 
     if (t == pdf_literal_node) {
+        /*tex The |string| key is obsolete. */
         if (lua_key_eq(s, mode)) {
             pdf_literal_mode(n) = (quarterword) lua_tointeger(L, 3);
-        } else if (lua_key_eq(s, data)) {
-            if (ini_version) {
-                pdf_literal_data(n) = nodelib_gettoks(L, 3);
-            } else {
-                lua_pushvalue(L, 3);
-                pdf_literal_data(n) = luaL_ref(L, LUA_REGISTRYINDEX);
-                pdf_literal_type(n) = lua_refid_literal;
-            }
+        } else if (lua_key_eq(s, data) || lua_key_eq(s, string)) {
+            set_pdf_literal_direct_normal(L, n, 3);
+        } else if (lua_key_eq(s, token)) {
+            set_pdf_literal_direct_token(L, n, 3);
         } else {
             return nodelib_cantset(L, n, s);
         }
     } else if (t == late_lua_node) {
-        if (lua_key_eq(s, string)) {
-            cleanup_late_lua(n) ; /* ls-hh */
-            if (ini_version) {
-                late_lua_data(n) = nodelib_gettoks(L, 3);
-                late_lua_type(n) = normal;
-            } else {
-                lua_pushvalue(L, 3);
-                late_lua_data(n) = luaL_ref(L, LUA_REGISTRYINDEX);
-                late_lua_type(n) = lua_refid_literal;
-            }
-        } else if (lua_key_eq(s, data)) {
-            cleanup_late_lua(n) ; /* ls-hh */
-            late_lua_data(n) = nodelib_gettoks(L, 3);
-            late_lua_type(n) = normal;
+        /*tex The |string| key is obsolete. */
+        if (lua_key_eq(s, data) || lua_key_eq(s, string)) {
+            set_late_lua_direct_normal(L, n, 3);
+        } else if (lua_key_eq(s, token)) {
+            set_late_lua_direct_token(L, n, 3);
         } else if (lua_key_eq(s, name)) {
-            cleanup_late_lua_name(n) ; /* ls-hh */
+            cleanup_late_lua_name(n) ;
             late_lua_name(n) = nodelib_gettoks(L, 3);
         } else {
             return nodelib_cantset(L, n, s);
@@ -5868,31 +6521,31 @@ static int lua_nodelib_setfield_whatsit(lua_State * L, int n, const char *s)
             user_node_type(n) = (halfword) lua_tointeger(L, 3);
         } else if (lua_key_eq(s, value)) {
             switch (user_node_type(n)) {
-            case 'a':
-                user_node_value(n) = nodelib_getlist(L, 3);
-                break;
-            case 'd':
-                user_node_value(n) = (halfword) lua_roundnumber(L, 3);
-                break;
-            case 'l':
-                lua_pushvalue(L, 3);
-                if (user_node_value(n) != 0) {
-                    luaL_unref(L, LUA_REGISTRYINDEX,user_node_value(n));
-                }
-                user_node_value(n) = luaL_ref(L, LUA_REGISTRYINDEX);
-                break;
-            case 'n':
-                user_node_value(n) = nodelib_getlist(L, 3);
-                break;
-            case 's':
-                user_node_value(n) = nodelib_getstring(L, 3);
-                break;
-            case 't':
-                user_node_value(n) = nodelib_gettoks(L, 3);
-                break;
-            default:
-                user_node_value(n) = (halfword) lua_roundnumber(L, 3);
-                break;
+                case 'a':
+                    user_node_value(n) = nodelib_getlist(L, 3);
+                    break;
+                case 'd':
+                    user_node_value(n) = (halfword) lua_roundnumber(L, 3);
+                    break;
+                case 'l':
+                    lua_pushvalue(L, 3);
+                    if (user_node_value(n) != 0) {
+                        luaL_unref(L, LUA_REGISTRYINDEX,user_node_value(n));
+                    }
+                    user_node_value(n) = luaL_ref(L, LUA_REGISTRYINDEX);
+                    break;
+                case 'n':
+                    user_node_value(n) = nodelib_getlist(L, 3);
+                    break;
+                case 's':
+                    user_node_value(n) = nodelib_getstring(L, 3);
+                    break;
+                case 't':
+                    user_node_value(n) = nodelib_gettoks(L, 3);
+                    break;
+                default:
+                    user_node_value(n) = (halfword) lua_roundnumber(L, 3);
+                    break;
             }
         } else {
             return nodelib_cantset(L, n, s);
@@ -5937,7 +6590,7 @@ static int lua_nodelib_setfield_whatsit(lua_State * L, int n, const char *s)
         }
     } else if (t == pdf_setmatrix_node) {
         if (lua_key_eq(s, data)) {
-            pdf_setmatrix_data(n) = nodelib_gettoks(L, 3);
+            set_pdf_setmatrix_direct_value(L,n,3);
         } else {
             return nodelib_cantset(L, n, s);
         }
@@ -5967,7 +6620,7 @@ static int lua_nodelib_setfield_whatsit(lua_State * L, int n, const char *s)
         if (lua_key_eq(s, stream)) {
             write_stream(n) = (halfword) lua_tointeger(L, 3);
         } else if (lua_key_eq(s, data)) {
-            write_tokens(n) = nodelib_gettoks(L, 3);
+            set_write_direct_value(L,n,3);
         } else {
             return nodelib_cantset(L, n, s);
         }
@@ -6023,7 +6676,7 @@ static int lua_nodelib_setfield_whatsit(lua_State * L, int n, const char *s)
         }
     } else if (t == special_node) {
         if (lua_key_eq(s, data)) {
-            write_tokens(n) = nodelib_gettoks(L, 3);
+            set_special_direct_value(L,n,3);
         } else {
             return nodelib_cantset(L, n, s);
         }
@@ -6107,8 +6760,8 @@ static int lua_nodelib_fast_setfield(lua_State * L)
             x_displace(n) = (halfword) lua_roundnumber(L, 3);
         } else if (lua_key_eq(s, yoffset)) {
             y_displace(n) = (halfword) lua_roundnumber(L, 3);
-        } else if (lua_key_eq(s, xadvance)) {
-            x_advance(n) = (halfword) lua_roundnumber(L, 3);
+        } else if (lua_key_eq(s, data)) {
+            glyph_node_data(n) = (halfword) lua_tointeger(L, 3);;
         } else if (lua_key_eq(s, width)) {
             /* not yet */
         } else if (lua_key_eq(s, height)) {
@@ -6141,8 +6794,10 @@ static int lua_nodelib_fast_setfield(lua_State * L)
             height(n) = (halfword) lua_roundnumber(L, 3);
         } else if (lua_key_eq(s, depth)) {
             depth(n) = (halfword) lua_roundnumber(L, 3);
+        } else if (lua_key_eq(s, direction)) {
+            box_dir(n) = nodelib_getdirection(L, 3);
         } else if (lua_key_eq(s, dir)) {
-            box_dir(n) = nodelib_getdir(L, 3, 1);
+            box_dir(n) = nodelib_getdir_par(L, 3);
         } else if (lua_key_eq(s, shift)) {
             shift_amount(n) = (halfword) lua_roundnumber(L, 3);
         } else if (lua_key_eq(s, glue_order)) {
@@ -6213,8 +6868,14 @@ static int lua_nodelib_fast_setfield(lua_State * L)
             height(n) = (halfword) lua_roundnumber(L, 3);
         } else if (lua_key_eq(s, depth)) {
             depth(n) = (halfword) lua_roundnumber(L, 3);
+        } else if (lua_key_eq(s, left)) {
+            rule_left(n) = (halfword) lua_roundnumber(L, 3);
+        } else if (lua_key_eq(s, right)) {
+            rule_right(n) = (halfword) lua_roundnumber(L, 3);
+        } else if (lua_key_eq(s, direction)) {
+            rule_dir(n) = nodelib_getdirection(L, 3);
         } else if (lua_key_eq(s, dir)) {
-            rule_dir(n) = nodelib_getdir(L, 3, 1);
+            rule_dir(n) = nodelib_getdir_par(L, 3);
         } else if (lua_key_eq(s, index)) {
             rule_index(n) = (halfword) lua_tointeger(L, 3);
         } else if (lua_key_eq(s, transform)) {
@@ -6223,12 +6884,12 @@ static int lua_nodelib_fast_setfield(lua_State * L)
             return nodelib_cantset(L, n, s);
         }
     } else if (t == dir_node) {
-        if (lua_key_eq(s, dir)) {
-            dir_dir(n) = nodelib_getdir(L, 3, 0);
+        if (lua_key_eq(s, direction)) {
+            dir_dir(n) = nodelib_getdirection(L, 3);
+        } else if (lua_key_eq(s, dir)) {
+            nodelib_setdir_text(L, 3, n);
         } else if (lua_key_eq(s, level)) {
             dir_level(n) = (halfword) lua_tointeger(L, 3);
-        } else if (lua_key_eq(s, subtype)) { /* can be used for anything */
-            subtype(n) = (quarterword) lua_tointeger(L, 3);
         } else {
             return nodelib_cantset(L, n, s);
         }
@@ -6237,8 +6898,10 @@ static int lua_nodelib_fast_setfield(lua_State * L)
             local_pen_inter(n) = (halfword) lua_tointeger(L, 3);
         } else if (lua_key_eq(s, pen_broken)) {
             local_pen_broken(n) = (halfword) lua_tointeger(L, 3);
+        } else if (lua_key_eq(s, direction)) {
+            local_par_dir(n) = nodelib_getdirection(L, 3);
         } else if (lua_key_eq(s, dir)) {
-            local_par_dir(n) = nodelib_getdir(L, 3, 1);
+            local_par_dir(n) = nodelib_getdir_par(L, 3);
         } else if (lua_key_eq(s, box_left)) {
             local_box_left(n) = nodelib_getlist(L, 3);
         } else if (lua_key_eq(s, box_left_width)) {
@@ -6349,6 +7012,8 @@ static int lua_nodelib_fast_setfield(lua_State * L)
             right_delimiter(n) = nodelib_getlist(L, 3);
         } else if (lua_key_eq(s, middle)) {
             middle_delimiter(n) = nodelib_getlist(L, 3);
+        } else if (lua_key_eq(s, fam)) {
+            fraction_fam(n) = (halfword) lua_tointeger(L, 3);
         } else if (lua_key_eq(s, options)) {
             fractionoptions(n) = (halfword) lua_tointeger(L, 3);
         } else {
@@ -6517,8 +7182,10 @@ static int lua_nodelib_fast_setfield(lua_State * L)
             height(n) = (halfword) lua_roundnumber(L, 3);
         } else if (lua_key_eq(s, depth)) {
             depth(n) = (halfword) lua_roundnumber(L, 3);
+        } else if (lua_key_eq(s, direction)) {
+            box_dir(n) = nodelib_getdirection(L, 3);
         } else if (lua_key_eq(s, dir)) {
-            box_dir(n) = nodelib_getdir(L, 3, 1);
+            box_dir(n) = nodelib_getdir_par(L, 3);
         } else if (lua_key_eq(s, shrink)) {
             glue_shrink(n) = (halfword) lua_roundnumber(L, 3);
         } else if (lua_key_eq(s, glue_order)) {
@@ -6592,36 +7259,24 @@ static int lua_nodelib_direct_setfield_whatsit(lua_State * L, int n, const char
 {
     int t = subtype(n);
     if (t == pdf_literal_node) {
+        /*tex The |string| key is obsolete. */
         if (lua_key_eq(s, mode)) {
             pdf_literal_mode(n) = (quarterword) lua_tointeger(L, 3);
-        } else if (lua_key_eq(s, data)) {
-            if (ini_version) {
-                pdf_literal_data(n) = nodelib_gettoks(L, 3);
-            } else {
-                lua_pushvalue(L, 3);
-                pdf_literal_data(n) = luaL_ref(L, LUA_REGISTRYINDEX);
-                pdf_literal_type(n) = lua_refid_literal;
-            }
+        } else if (lua_key_eq(s, data) || lua_key_eq(s, string)) {
+            set_pdf_literal_direct_normal(L, n, 3);
+        } else if (lua_key_eq(s, token)) {
+            set_pdf_literal_direct_token(L, n, 3);
         } else {
             return nodelib_cantset(L, n, s);
         }
     } else if (t == late_lua_node) {
-        if (lua_key_eq(s, string)) {
-            cleanup_late_lua(n) ; /* ls-hh */
-            if (ini_version) {
-                late_lua_data(n) = nodelib_gettoks(L, 3);
-                late_lua_type(n) = normal;
-            } else {
-                lua_pushvalue(L, 3);
-                late_lua_data(n) = luaL_ref(L, LUA_REGISTRYINDEX);
-                late_lua_type(n) = lua_refid_literal;
-            }
-        } else if (lua_key_eq(s, data)) {
-            cleanup_late_lua(n) ; /* ls-hh */
-            late_lua_data(n) = nodelib_gettoks(L, 3);
-            late_lua_type(n) = normal;
+        /*tex The |string| key is obsolete. */
+        if (lua_key_eq(s, data) || lua_key_eq(s, string)) {
+            set_late_lua_direct_normal(L, n, 3);
+        } else if (lua_key_eq(s, token)) {
+            set_late_lua_direct_token(L, n, 3);
         } else if (lua_key_eq(s, name)) {
-            cleanup_late_lua_name(n) ; /* ls-hh */
+            cleanup_late_lua_name(n) ;
             late_lua_name(n) = nodelib_gettoks(L, 3);
         } else {
             return nodelib_cantset(L, n, s);
@@ -6632,33 +7287,7 @@ static int lua_nodelib_direct_setfield_whatsit(lua_State * L, int n, const char
         } else if (lua_key_eq(s, type)) {
             user_node_type(n) = (halfword) lua_tointeger(L, 3);
         } else if (lua_key_eq(s, value)) {
-            switch (user_node_type(n)) {
-            case 'a':
-                user_node_value(n) = nodelib_getlist(L, 3);
-                break;
-            case 'd':
-                user_node_value(n) = (halfword) lua_roundnumber(L, 3);
-                break;
-            case 'l':
-                lua_pushvalue(L, 3);
-                if (user_node_value(n) != 0) {
-                    luaL_unref(L, LUA_REGISTRYINDEX,user_node_value(n));
-                }
-                user_node_value(n) = luaL_ref(L, LUA_REGISTRYINDEX);
-                break;
-            case 'n':
-                user_node_value(n) = nodelib_getlist(L, 3);
-                break;
-            case 's':
-                user_node_value(n) = nodelib_getstring(L, 3);
-                break;
-            case 't':
-                user_node_value(n) = nodelib_gettoks(L, 3);
-                break;
-            default:
-                user_node_value(n) = (halfword) lua_roundnumber(L, 3);
-                break;
-            }
+            set_user_node_direct_value(L, n, 3);
         } else {
             return nodelib_cantset(L, n, s);
         }
@@ -6702,7 +7331,7 @@ static int lua_nodelib_direct_setfield_whatsit(lua_State * L, int n, const char
         }
     } else if (t == pdf_setmatrix_node) {
         if (lua_key_eq(s, data)) {
-            pdf_setmatrix_data(n) = nodelib_gettoks(L, 3);
+            set_pdf_setmatrix_direct_value(L, n, 3);
         } else {
             return nodelib_cantset(L, n, s);
         }
@@ -6730,9 +7359,9 @@ static int lua_nodelib_direct_setfield_whatsit(lua_State * L, int n, const char
         }
     } else if (t == write_node) {
         if (lua_key_eq(s, stream)) {
-            write_stream(n) = (halfword) lua_tointeger(L, 3);
+            set_write_direct_value(L,n,3);
         } else if (lua_key_eq(s, data)) {
-            write_tokens(n) = nodelib_gettoks(L, 3);
+            set_write_direct_value(L,n,3);
         } else {
             return nodelib_cantset(L, n, s);
         }
@@ -6788,7 +7417,7 @@ static int lua_nodelib_direct_setfield_whatsit(lua_State * L, int n, const char
         }
     } else if (t == special_node) {
         if (lua_key_eq(s, data)) {
-            write_tokens(n) = nodelib_gettoks(L, 3);
+            set_special_direct_value(L, n, 3);
         } else {
             return nodelib_cantset(L, n, s);
         }
@@ -6963,8 +7592,8 @@ static int lua_nodelib_direct_setfield(lua_State * L)
             x_displace(n) = (halfword) lua_roundnumber(L, 3);
         } else if (lua_key_eq(s, yoffset)) {
             y_displace(n) = (halfword) lua_roundnumber(L, 3);
-        } else if (lua_key_eq(s, xadvance)) {
-            x_advance(n) = (halfword) lua_roundnumber(L, 3);
+        } else if (lua_key_eq(s, data)) {
+            glyph_node_data(n) = (halfword) lua_tointeger(L, 3);
         } else if (lua_key_eq(s, expansion_factor)) {
             ex_glyph(n) = (halfword) lua_roundnumber(L, 3);
         } else if (lua_key_eq(s, components)) {
@@ -6997,8 +7626,10 @@ static int lua_nodelib_direct_setfield(lua_State * L)
             height(n) = (halfword) lua_roundnumber(L, 3);
         } else if (lua_key_eq(s, depth)) {
             depth(n) = (halfword) lua_roundnumber(L, 3);
+        } else if (lua_key_eq(s, direction)) {
+            box_dir(n) = nodelib_getdirection(L, 3);
         } else if (lua_key_eq(s, dir)) {
-            box_dir(n) = nodelib_getdir(L, 3, 1);
+            box_dir(n) = nodelib_getdir_par(L, 3);
         } else if (lua_key_eq(s, shift)) {
             shift_amount(n) = (halfword) lua_roundnumber(L, 3);
         } else if (lua_key_eq(s, glue_order)) {
@@ -7069,8 +7700,14 @@ static int lua_nodelib_direct_setfield(lua_State * L)
             height(n) = (halfword) lua_roundnumber(L, 3);
         } else if (lua_key_eq(s, depth)) {
             depth(n) = (halfword) lua_roundnumber(L, 3);
+        } else if (lua_key_eq(s, left)) {
+            rule_left(n) = (halfword) lua_roundnumber(L, 3);
+        } else if (lua_key_eq(s, right)) {
+            rule_right(n) = (halfword) lua_roundnumber(L, 3);
+        } else if (lua_key_eq(s, direction)) {
+            rule_dir(n) = nodelib_getdirection(L, 3);
         } else if (lua_key_eq(s, dir)) {
-            rule_dir(n) = nodelib_getdir(L, 3, 1);
+            rule_dir(n) = nodelib_getdir_par(L, 3);
         } else if (lua_key_eq(s, index)) {
             rule_index(n) = (halfword) lua_tointeger(L, 3);
         } else if (lua_key_eq(s, transform)) {
@@ -7079,12 +7716,12 @@ static int lua_nodelib_direct_setfield(lua_State * L)
             return nodelib_cantset(L, n, s);
         }
     } else if (t == dir_node) {
-        if (lua_key_eq(s, dir)) {
-            dir_dir(n) = nodelib_getdir(L, 3, 0);
+        if (lua_key_eq(s, direction)) {
+            dir_dir(n) = nodelib_getdirection(L, 3);
+        } else if (lua_key_eq(s, dir)) {
+            nodelib_setdir_text(L, 3, n);
         } else if (lua_key_eq(s, level)) {
             dir_level(n) = (halfword) lua_tointeger(L, 3);
-        } else if (lua_key_eq(s, subtype)) { /* can be used for anything */
-            subtype(n) = (quarterword) lua_tointeger(L, 3);
         } else {
             return nodelib_cantset(L, n, s);
         }
@@ -7099,8 +7736,10 @@ static int lua_nodelib_direct_setfield(lua_State * L)
             local_pen_inter(n) = (halfword) lua_tointeger(L, 3);
         } else if (lua_key_eq(s, pen_broken)) {
             local_pen_broken(n) = (halfword) lua_tointeger(L, 3);
+        } else if (lua_key_eq(s, direction)) {
+            local_par_dir(n) = nodelib_getdirection(L, 3);
         } else if (lua_key_eq(s, dir)) {
-            local_par_dir(n) = nodelib_getdir(L, 3, 1);
+            local_par_dir(n) = nodelib_getdir_par(L, 3);
         } else if (lua_key_eq(s, box_left)) {
             local_box_left(n) = nodelib_getlist(L, 3);
         } else if (lua_key_eq(s, box_left_width)) {
@@ -7205,6 +7844,8 @@ static int lua_nodelib_direct_setfield(lua_State * L)
             right_delimiter(n) = nodelib_popdirect(3);
         } else if (lua_key_eq(s, middle)) {
             middle_delimiter(n) = nodelib_popdirect(3);
+        } else if (lua_key_eq(s, fam)) {
+            fraction_fam(n) = (halfword) lua_tointeger(L, 3);
         } else if (lua_key_eq(s, options)) {
             fractionoptions(n) = (halfword) lua_tointeger(L, 3);
         } else {
@@ -7373,8 +8014,10 @@ static int lua_nodelib_direct_setfield(lua_State * L)
             height(n) = (halfword) lua_roundnumber(L, 3);
         } else if (lua_key_eq(s, depth)) {
             depth(n) = (halfword) lua_roundnumber(L, 3);
+        } else if (lua_key_eq(s, direction)) {
+            box_dir(n) = nodelib_getdirection(L, 3);
         } else if (lua_key_eq(s, dir)) {
-            box_dir(n) = nodelib_getdir(L, 3, 1);
+            box_dir(n) = nodelib_getdir_par(L, 3);
         } else if (lua_key_eq(s, shrink)) {
             glue_shrink(n) = (halfword) lua_roundnumber(L, 3);
         } else if (lua_key_eq(s, glue_order)) {
@@ -7516,6 +8159,8 @@ static int lua_nodelib_direct_setbox(lua_State * L)
 
 /* node.is_node(n) */
 
+/*
+
 static int lua_nodelib_is_node(lua_State * L)
 {
     if (maybe_isnode(L,1) == NULL)
@@ -7525,6 +8170,18 @@ static int lua_nodelib_is_node(lua_State * L)
     return 1;
 }
 
+*/
+
+static int lua_nodelib_is_node(lua_State * L)
+{
+    halfword *p = maybe_isnode(L, 1);
+    if (p == NULL)
+        lua_pushboolean(L,0);
+    else
+        lua_pushinteger(L, *((halfword *)p));
+    return 1;
+}
+
 /* node.direct.is_direct(n) (handy for mixed usage testing) */
 
 static int lua_nodelib_direct_is_direct(lua_State * L)
@@ -7571,7 +8228,7 @@ static int lua_nodelib_direct_is_node(lua_State * L)
     mechanism. And, one can always sweep the table empty.
 */
 
-static int lua_nodelib_properties_set_mode(lua_State * L) /* hh */
+static int lua_nodelib_properties_set_mode(lua_State * L)
 {   /* <boolean> */
     if (lua_isboolean(L,1)) {
         lua_properties_enabled = lua_toboolean(L,1);
@@ -7584,7 +8241,7 @@ static int lua_nodelib_properties_set_mode(lua_State * L) /* hh */
 
 /* We used to have variants in assigned defaults but they made no sense. */
 
-static int lua_nodelib_properties_flush_table(lua_State * L) /* hh */
+static int lua_nodelib_properties_flush_table(lua_State * L)
 {   /* <node|direct> <number> */
     lua_get_metatablelua(node_properties);
     lua_pushnil(L); /* initializes lua_next */
@@ -7599,7 +8256,7 @@ static int lua_nodelib_properties_flush_table(lua_State * L) /* hh */
 
 /* maybe we should allocate a proper index 0..var_mem_max but not now */
 
-static int lua_nodelib_get_property(lua_State * L) /* hh */
+static int lua_nodelib_get_property(lua_State * L)
 {   /* <node> */
     halfword n = *((halfword *) lua_touserdata(L, 1));
     if (n == null) {
@@ -7611,7 +8268,7 @@ static int lua_nodelib_get_property(lua_State * L) /* hh */
     return 1;
 }
 
-static int lua_nodelib_direct_get_property(lua_State * L) /* hh */
+static int lua_nodelib_direct_get_property(lua_State * L)
 {   /* <direct> */
     halfword n = lua_tointeger(L, 1);
     if (n == null) {
@@ -7623,7 +8280,7 @@ static int lua_nodelib_direct_get_property(lua_State * L) /* hh */
     return 1;
 }
 
-static int lua_nodelib_set_property(lua_State * L) /* hh */
+static int lua_nodelib_set_property(lua_State * L)
 {
     /* <node> <value> */
     halfword n = *((halfword *) lua_touserdata(L, 1));
@@ -7638,7 +8295,7 @@ static int lua_nodelib_set_property(lua_State * L) /* hh */
     return 0;
 }
 
-static int lua_nodelib_direct_set_property(lua_State * L) /* hh */
+static int lua_nodelib_direct_set_property(lua_State * L)
 {
     /* <direct> <value> */
     halfword n = lua_tointeger(L, 1);
@@ -7653,13 +8310,13 @@ static int lua_nodelib_direct_set_property(lua_State * L) /* hh */
     return 0;
 }
 
-static int lua_nodelib_direct_properties_get_table(lua_State * L) /* hh */
+static int lua_nodelib_direct_properties_get_table(lua_State * L)
 {   /* <node|direct> */
     lua_get_metatablelua(node_properties);
     return 1;
 }
 
-static int lua_nodelib_properties_get_table(lua_State * L) /* hh */
+static int lua_nodelib_properties_get_table(lua_State * L)
 {   /* <node|direct> */
     lua_get_metatablelua(node_properties_indirect);
     return 1;
@@ -7667,7 +8324,7 @@ static int lua_nodelib_properties_get_table(lua_State * L) /* hh */
 
 /* bonus */
 
-static int lua_nodelib_get_property_t(lua_State * L) /* hh */
+static int lua_nodelib_get_property_t(lua_State * L)
 {   /* <table> <node> */
     halfword n = *((halfword *) lua_touserdata(L, 2));
     if (n == null) {
@@ -7678,7 +8335,7 @@ static int lua_nodelib_get_property_t(lua_State * L) /* hh */
     return 1;
 }
 
-static int lua_nodelib_set_property_t(lua_State * L) /* hh */
+static int lua_nodelib_set_property_t(lua_State * L)
 {
     /* <table> <node> <value> */
     halfword n = *((halfword *) lua_touserdata(L, 2));
@@ -7804,7 +8461,7 @@ static int lua_nodelib_direct_flatten_discretionaries(lua_State * L)
                     try_couple_nodes(alink(current),h);
                 }
                 vlink(n) = null ;
-              //tlink(n) = null;
+              /*tlink(n) = null; */
             } else {
                 if (current == head) {
                     head = next;
@@ -7870,7 +8527,7 @@ static int lua_nodelib_flatten_discretionaries(lua_State * L)
                     try_couple_nodes(alink(current),h);
                 }
                 vlink(n) = null ;
-              //tlink(n) = null;
+              /*tlink(n) = null; */
             } else {
                 if (current == head) {
                     head = next;
@@ -7967,6 +8624,115 @@ static int lua_nodelib_direct_get_synctex_fields(lua_State * L)
     return 0;
 }
 
+/* helper, assumes one node, returns node and delta .. to be tested */
+
+static int lua_nodelib_prepend_prevdepth(lua_State * L)
+{
+    halfword *a;
+    halfword p;
+    halfword prevdepth;
+    boolean mirrored;
+    halfword n = *check_isnode(L, 1);
+    if (!(type(n) == hlist_node || type(n) == vlist_node)) {
+        lua_pushnil(L);
+        return 1;
+    }
+    prevdepth = lua_tointeger(L,2);
+    mirrored = (type(n) == hlist_node) && is_mirrored(box_dir(n)) ;
+    if (prevdepth > ignore_depth) {
+        halfword d;
+        if (mirrored) {
+            d = width(baseline_skip_par) - prevdepth - depth(n);
+        } else {
+            d = width(baseline_skip_par) - prevdepth - height(n);
+        }
+        if (d < line_skip_limit_par) {
+            p = new_param_glue(line_skip_code);
+        } else {
+            p = new_skip_param(baseline_skip_code);
+            width(p) = d;
+        }
+        couple_nodes(p,n);
+        fast_metatable_or_nil(p); /* glue */
+    } else {
+        fast_metatable_or_nil(n); /* node */
+    }
+    if (mirrored) {
+        prevdepth = height(n);
+    } else {
+        prevdepth = depth(n);
+    }
+    lua_pushinteger(L,prevdepth); /* new prevdepth */
+    return 2;
+}
+
+static int lua_nodelib_direct_prepend_prevdepth(lua_State * L)
+{
+    halfword p;
+    halfword prevdepth;
+    boolean mirrored;
+    halfword n = lua_tointeger(L, 1);
+    if (type(n) == hlist_node || type(n) == vlist_node) {
+        lua_pushnil(L);
+        return 1;
+    }
+    prevdepth = lua_tointeger(L,2);
+    mirrored = (type(n) == hlist_node) && is_mirrored(box_dir(n)) ;
+    if (prevdepth > ignore_depth) {
+        halfword d;
+        if (mirrored) {
+            d = width(baseline_skip_par) - prevdepth - depth(n);
+        } else {
+            d = width(baseline_skip_par) - prevdepth - height(n);
+        }
+        if (d < line_skip_limit_par) {
+            p = new_param_glue(line_skip_code);
+        } else {
+            p = new_skip_param(baseline_skip_code);
+            width(p) = d;
+        }
+        couple_nodes(p,n);
+        lua_pushinteger(L,p); /* glue */
+    } else {
+        lua_pushinteger(L,n); /* node */
+    }
+    if (mirrored) {
+        prevdepth = height(n);
+    } else {
+        prevdepth = depth(n);
+    }
+    lua_pushinteger(L,prevdepth); /* new prevdepth */
+    return 2;
+}
+
+static int lua_nodelib_make_extensible(lua_State * L)
+{
+    int top = lua_gettop(L);
+    if (top >= 3) {
+        halfword fnt = lua_tointeger(L,1);
+        halfword chr = lua_tointeger(L,2);
+        halfword size = lua_tointeger(L,3);
+        halfword overlap = 65536 ;
+        halfword attlist = null;
+        halfword b = null;
+        int horizontal = 0;
+        if (top >= 4) {
+            overlap = lua_tointeger(L,4);
+        }
+        if (top >= 5) {
+            horizontal = lua_toboolean(L,5);
+        }
+        if (top >= 6) {
+            attlist = *check_isnode(L, 6);
+        }
+        b = make_extensible(fnt,chr,size,overlap,horizontal,attlist);
+        nodelib_pushlist(L,b);
+    } else {
+        lua_pushnil(L);
+    }
+    return 1;
+}
+
 /* done */
 
 static const struct luaL_Reg nodelib_p[] = {
@@ -8022,6 +8788,7 @@ static const struct luaL_Reg direct_nodelib_f[] = {
     {"getshift", lua_nodelib_direct_getshift},
     {"getfield", lua_nodelib_direct_getfield},
     {"getfont", lua_nodelib_direct_getfont},
+    {"getexpansion", lua_nodelib_direct_getexpansion},
     {"getfam", lua_nodelib_direct_getfam},
     {"getid", lua_nodelib_direct_getid},
     {"getnext", lua_nodelib_direct_getnext},
@@ -8029,11 +8796,13 @@ static const struct luaL_Reg direct_nodelib_f[] = {
     {"getboth", lua_nodelib_direct_getboth},
     {"getlist", lua_nodelib_direct_getlist},
     {"getleader", lua_nodelib_direct_getleader},
+    {"getdata", lua_nodelib_direct_getdata},
     {"getsubtype", lua_nodelib_direct_getsubtype},
     {"getattributelist", lua_nodelib_direct_getattributelist},
     {"getnucleus", lua_nodelib_direct_getnucleus},
     {"getsub", lua_nodelib_direct_getsub},
     {"getsup", lua_nodelib_direct_getsup},
+    {"getdirection", lua_nodelib_direct_getdirection},
     {"has_glyph", lua_nodelib_direct_has_glyph},
     {"has_attribute", lua_nodelib_direct_has_attribute},
     {"get_attribute", lua_nodelib_direct_get_attribute},
@@ -8064,12 +8833,14 @@ static const struct luaL_Reg direct_nodelib_f[] = {
     {"setfield", lua_nodelib_direct_setfield},
     {"setchar", lua_nodelib_direct_setchar},
     {"setfont", lua_nodelib_direct_setfont},
+    {"setexpansion", lua_nodelib_direct_setexpansion},
     {"setfam", lua_nodelib_direct_setfam},
     {"setcomponents", lua_nodelib_direct_setcomponents},
     {"setlang", lua_nodelib_direct_setlang},
     {"setkern", lua_nodelib_direct_setkern},
     {"setpenalty", lua_nodelib_direct_setpenalty},
     {"setdir", lua_nodelib_direct_setdir},
+    {"setdirection", lua_nodelib_direct_setdirection},
     {"setoffsets", lua_nodelib_direct_setoffsets},
     {"setdisc", lua_nodelib_direct_setdisc},
     {"setwhd", lua_nodelib_direct_setwhd},
@@ -8084,6 +8855,7 @@ static const struct luaL_Reg direct_nodelib_f[] = {
     {"setsplit", lua_nodelib_direct_setsplit},
     {"setlist", lua_nodelib_direct_setlist},
     {"setleader", lua_nodelib_direct_setleader},
+    {"setdata", lua_nodelib_direct_setdata},
     {"setsubtype", lua_nodelib_direct_setsubtype},
     {"setattributelist", lua_nodelib_direct_setattributelist},
     {"setnucleus", lua_nodelib_direct_setnucleus},
@@ -8097,6 +8869,8 @@ static const struct luaL_Reg direct_nodelib_f[] = {
     {"traverse", lua_nodelib_direct_traverse},
     {"traverse_id", lua_nodelib_direct_traverse_filtered},
     {"traverse_char", lua_nodelib_direct_traverse_char},
+    {"traverse_glyph", lua_nodelib_direct_traverse_glyph},
+    {"traverse_list", lua_nodelib_direct_traverse_list},
  /* {"type", lua_nodelib_type}, */ /* no node argument */
  /* {"types", lua_nodelib_types}, */ /* no node argument */
     {"unprotect_glyphs", lua_nodelib_direct_unprotect_glyphs},
@@ -8110,14 +8884,15 @@ static const struct luaL_Reg direct_nodelib_f[] = {
  /* {"whatsits", lua_nodelib_whatsits}, */ /* no node argument */
     {"write", lua_nodelib_direct_append},
     {"set_properties_mode",lua_nodelib_properties_set_mode},
-    {"flush_properties_table",lua_nodelib_properties_flush_table}, /* hh experiment */
-    {"get_properties_table",lua_nodelib_direct_properties_get_table}, /* hh experiment */
+    {"flush_properties_table",lua_nodelib_properties_flush_table},
+    {"get_properties_table",lua_nodelib_direct_properties_get_table},
     {"getproperty", lua_nodelib_direct_get_property},
     {"setproperty", lua_nodelib_direct_set_property},
     {"effective_glue", lua_nodelib_direct_effective_glue},
     {"check_discretionary", lua_nodelib_direct_check_discretionary},
     {"check_discretionaries", lua_nodelib_direct_check_discretionaries},
     {"flatten_discretionaries",lua_nodelib_direct_flatten_discretionaries},
+    {"prepend_prevdepth",lua_nodelib_direct_prepend_prevdepth},
     /* done */
     {"set_synctex_fields", lua_nodelib_direct_set_synctex_fields},
     {"get_synctex_fields", lua_nodelib_direct_get_synctex_fields},
@@ -8139,6 +8914,7 @@ static const struct luaL_Reg nodelib_f[] = {
     {"family_font", lua_nodelib_mfont},
     {"fields", lua_nodelib_fields},
     {"subtypes", lua_nodelib_subtypes},
+    {"values", lua_nodelib_values},
     {"first_glyph", lua_nodelib_first_glyph},
     {"flush_list", lua_nodelib_flush_list},
     {"flush_node", lua_nodelib_flush_node},
@@ -8191,33 +8967,34 @@ static const struct luaL_Reg nodelib_f[] = {
     {"traverse", lua_nodelib_traverse},
     {"traverse_id", lua_nodelib_traverse_filtered},
     {"traverse_char", lua_nodelib_traverse_char},
+    {"traverse_glyph", lua_nodelib_traverse_glyph},
+    {"traverse_list", lua_nodelib_traverse_list},
     {"type", lua_nodelib_type},
     {"types", lua_nodelib_types},
     {"unprotect_glyphs", lua_nodelib_unprotect_glyphs},
     {"unprotect_glyph", lua_nodelib_unprotect_glyph},
     {"unset_attribute", lua_nodelib_unset_attribute},
-    {"setglue",lua_nodelib_set_glue},
-    {"getglue",lua_nodelib_get_glue},
-    {"is_zero_glue",lua_nodelib_is_zero_glue},
+    {"setglue", lua_nodelib_set_glue},
+    {"getglue", lua_nodelib_get_glue},
+    {"is_zero_glue", lua_nodelib_is_zero_glue},
     {"usedlist", lua_nodelib_usedlist},
     {"vpack", lua_nodelib_vpack},
     {"whatsits", lua_nodelib_whatsits},
     {"write", lua_nodelib_append},
     /* experiment */
- /* {"attributes_to_table",lua_nodelib_attributes_to_table}, */ /* hh experiment */
+ /* {"attributes_to_table",lua_nodelib_attributes_to_table}, */
     /* experiment */
-    {"set_properties_mode",lua_nodelib_properties_set_mode}, /* hh experiment */
-    {"flush_properties_table",lua_nodelib_properties_flush_table}, /* hh experiment */
-    {"get_properties_table",lua_nodelib_properties_get_table}, /* bonus */ /* hh experiment */
-    {"getproperty", lua_nodelib_get_property}, /* hh experiment */
-    {"setproperty", lua_nodelib_set_property}, /* hh experiment */
+    {"set_properties_mode", lua_nodelib_properties_set_mode},
+    {"flush_properties_table", lua_nodelib_properties_flush_table},
+    {"get_properties_table", lua_nodelib_properties_get_table},
+    {"getproperty", lua_nodelib_get_property},
+    {"setproperty", lua_nodelib_set_property},
     {"effective_glue", lua_nodelib_effective_glue},
     {"check_discretionary", lua_nodelib_check_discretionary},
     {"check_discretionaries", lua_nodelib_check_discretionaries},
-    {"flatten_discretionaries",lua_nodelib_flatten_discretionaries},
-    /* done */
- /* {"set_synctex_fields", lua_nodelib_set_synctex_fields}, */
- /* {"get_synctex_fields", lua_nodelib_get_synctex_fields}, */
+    {"flatten_discretionaries", lua_nodelib_flatten_discretionaries},
+    {"prepend_prevdepth", lua_nodelib_prepend_prevdepth},
+    {"make_extensible", lua_nodelib_make_extensible},
     /* done */
     {"fix_node_lists", lua_nodelib_fix_node_lists},
     {NULL, NULL} /* sentinel */
@@ -8255,12 +9032,12 @@ void nodelist_to_lua(lua_State * L, int n)
     lua_nodelib_push(L);
 }
 
-int nodelist_from_lua(lua_State * L)
+int nodelist_from_lua(lua_State * L, int n)
 {
-    if (lua_isnil(L, -1)) {
+    if (lua_isnil(L, n)) {
         return null;
     } else {
-        halfword n= *check_isnode(L, -1);
-        return (n ? n : null);
+        halfword list = *check_isnode(L, n);
+        return (list ? list : null);
     }
 }
diff --git a/texk/web2c/luatexdir/lua/loslibext.c b/texk/web2c/luatexdir/lua/loslibext.c
index 309d636c4..979f72472 100644
--- a/texk/web2c/luatexdir/lua/loslibext.c
+++ b/texk/web2c/luatexdir/lua/loslibext.c
@@ -703,28 +703,49 @@ static int uname(struct utsname *uts)
     GetVersionEx(&osver);
     GetSystemInfo(&sysinfo);
 
+
+    /*
+        Windows 10               10.0*
+        Windows Server 2016      10.0*
+        Windows 8.1               6.3*
+        Windows Server 2012 R2    6.3*
+        Windows 8                 6.2
+        Windows Server 2012       6.2
+        Windows 7                 6.1
+        Windows Server 2008 R2	  6.1
+        Windows Server 2008       6.0
+        Windows Vista             6.0
+        Windows Server 2003 R2	  5.2
+        Windows Server 2003       5.2
+        Windows XP 64-Bit Edition 5.2
+        Windows XP                5.1
+        Windows 2000              5.0
+    */
+
     switch (osver.dwPlatformId) {
-    case VER_PLATFORM_WIN32_NT:        /* NT, Windows 2000 or Windows XP */
+    case VER_PLATFORM_WIN32_NT:
         if (osver.dwMajorVersion == 4)
-            strcpy(uts->sysname, "Windows NT4x");       /* NT4x */
+            strcpy(uts->sysname, "Windows NT 4");
         else if (osver.dwMajorVersion <= 3)
-            strcpy(uts->sysname, "Windows NT3x");       /* NT3x */
+            strcpy(uts->sysname, "Windows NT 3");
         else if (osver.dwMajorVersion == 5) {
             if (osver.dwMinorVersion == 0)
-                strcpy(uts->sysname, "Windows 2000");   /* 2k */
+                strcpy(uts->sysname, "Windows 2000");
             else if (osver.dwMinorVersion == 1)
-                strcpy(uts->sysname, "Windows XP");     /* XP */
+                strcpy(uts->sysname, "Windows XP");
             else if (osver.dwMinorVersion == 2)
-                strcpy(uts->sysname, "Windows Server 2003");    /* Server 2003 */
+                strcpy(uts->sysname, "Windows XP 64-Bit");
         } else if (osver.dwMajorVersion == 6) {
-            /*
-               if( osver.wProductType == VER_NT_WORKSTATION )
-             */
-            strcpy(uts->sysname, "Windows Vista");      /* Vista */
-            /*
-               else
-               strcpy (uts->sysname, "Windows Server 2008");
-             */
+            if (osver.dwMinorVersion == 0)
+                strcpy(uts->sysname, "Windows Vista");
+            else if (osver.dwMinorVersion == 1)
+                strcpy(uts->sysname, "Windows 7");
+            else if (osver.dwMinorVersion == 2)
+                strcpy(uts->sysname, "Windows 8");
+            else if (osver.dwMinorVersion == 3)
+                strcpy(uts->sysname, "Windows 8.1");
+        } else if (osver.dwMajorVersion == 10) {
+                strcpy(uts->sysname, "Windows 10");
         }
         os = WinNT;
         break;
diff --git a/texk/web2c/luatexdir/lua/lpdflib.c b/texk/web2c/luatexdir/lua/lpdflib.c
index 096600de3..d8e051f3f 100644
--- a/texk/web2c/luatexdir/lua/lpdflib.c
+++ b/texk/web2c/luatexdir/lua/lpdflib.c
@@ -22,7 +22,7 @@
 #include "lua/luatex-api.h"
 #include "pdf/pdftables.h"
 
-static int luapdfprint(lua_State * L)
+int luapdfprint(lua_State * L)
 {
     int n;
     const_lstring st;
@@ -82,6 +82,7 @@ static int luapdfprint(lua_State * L)
     }
     st.s = lua_tolstring(L, n, &st.l);
     pdf_out_block(static_pdf, st.s, st.l);
+/*  pdf_out(pdf, '\n'); */
     return 0;
 }
 
@@ -193,6 +194,7 @@ static int table_obj(lua_State * L)
     const_lstring attr, st;
     lstring buf;
     int immediate = 0;          /* default: not immediate */
+    int nolength = 0;
     attr.s = st.s = NULL;
     attr.l = 0;
     assert(lua_istable(L, 1));  /* t */
@@ -213,6 +215,12 @@ static int table_obj(lua_State * L)
         immediate = lua_toboolean(L, -1);       /* 0 or 1 */
     }
     lua_pop(L, 1);              /* t */
+    lua_key_rawgeti(nolength);
+    if (!lua_isnil(L, -1)) {    /* b? t */
+        if (lua_isboolean(L, -1))      /* !b t */
+            nolength = lua_toboolean(L, -1);       /* 0 or 1 */
+    }
+    lua_pop(L, 1);              /* t */
 
     /* is a reserved object referenced by "objnum"? */
 
@@ -335,19 +343,29 @@ static int table_obj(lua_State * L)
     } else {
         if (immediate == 1) {
             pdf_begin_obj(static_pdf, k, OBJSTM_NEVER); /* 0 = not an object stream candidate! */
-            pdf_begin_dict(static_pdf);
-            if (attr.s != NULL) {
+            if (nolength && attr.s != NULL) {
+                /* we have a direct copy possible with compressed data */
+                pdf_begin_dict(static_pdf);
                 pdf_out_block(static_pdf, attr.s, attr.l);
-                if (attr.s[attr.l - 1] != '\n')
-                    pdf_out(static_pdf, '\n');
+                static_pdf->compress_level = 0;
+                static_pdf->stream_deflate = false;
+                pdf_end_dict(static_pdf);
+            } else {
+                pdf_begin_dict(static_pdf);
+                if (attr.s != NULL) {
+                    pdf_check_space(static_pdf);
+                    pdf_out_block(static_pdf, attr.s, attr.l);
+                    pdf_set_space(static_pdf);
+                }
+                if (compress_level > -1)
+                    static_pdf->compress_level = compress_level;
+                pdf_dict_add_streaminfo(static_pdf);
+                pdf_end_dict(static_pdf);
             }
-            if (compress_level > -1)
-                static_pdf->compress_level = compress_level;
-            pdf_dict_add_streaminfo(static_pdf);
-            pdf_end_dict(static_pdf);
             pdf_begin_stream(static_pdf);
         } else {
             set_obj_obj_is_stream(static_pdf, k);
+            set_obj_obj_no_length(static_pdf, k);
             if (compress_level > -1)
                 obj_obj_pdfcompresslevel(static_pdf, k) = compress_level;
         }
@@ -404,42 +422,42 @@ static int orig_obj(lua_State * L)
     obj_data_ptr(static_pdf, k) = pdf_get_mem(static_pdf, pdfmem_obj_size);
     init_obj_obj(static_pdf, k);
     switch (n - first_arg + 1) {
-    case 0:
-        luaL_error(L, "pdf.obj() needs at least one argument");
-        break;
-    case 1:
-        if (!lua_isstring(L, first_arg)) /* or number */
-            luaL_error(L, "pdf.obj() 1st argument must be string");
-        break;
-    case 2:
-    case 3:
-        if (lua_type(L, first_arg) != LUA_TSTRING)
-            luaL_error(L, "pdf.obj() 1st argument must be string");
-        if (!lua_isstring(L, first_arg + 1)) /* or number */
-            luaL_error(L, "pdf.obj() 2nd argument must be string");
-        st_s = lua_tostring(L, first_arg);
-        if (lua_key_eq(st_s, file)) {
-            if (n == first_arg + 2)
-                luaL_error(L, "pdf.obj() 3rd argument forbidden in file mode");
-            set_obj_obj_is_file(static_pdf, k);
-        } else {
-            if (n == first_arg + 2) {   /* write attr text */
-                if (!lua_isstring(L, -1)) /* or number */
-                    luaL_error(L, "pdf.obj() 3rd argument must be string");
-                obj_obj_stream_attr(static_pdf, k) =
-                    luaL_ref(Luas, LUA_REGISTRYINDEX);
-            }
-            if (lua_key_eq(st_s, stream)) {
-                set_obj_obj_is_stream(static_pdf, k);
-            } else if (lua_key_eq(st_s, streamfile)) {
-                set_obj_obj_is_stream(static_pdf, k);
+        case 0:
+            luaL_error(L, "pdf.obj() needs at least one argument");
+            break;
+        case 1:
+            if (!lua_isstring(L, first_arg)) /* or number */
+                luaL_error(L, "pdf.obj() 1st argument must be string");
+            break;
+        case 2:
+        case 3:
+            if (lua_type(L, first_arg) != LUA_TSTRING)
+                luaL_error(L, "pdf.obj() 1st argument must be string");
+            if (!lua_isstring(L, first_arg + 1)) /* or number */
+                luaL_error(L, "pdf.obj() 2nd argument must be string");
+            st_s = lua_tostring(L, first_arg);
+            if (lua_key_eq(st_s, file)) {
+                if (n == first_arg + 2)
+                    luaL_error(L, "pdf.obj() 3rd argument forbidden in file mode");
                 set_obj_obj_is_file(static_pdf, k);
-            } else
-                luaL_error(L, "pdf.obj() invalid argument");
-        }
-        break;
-    default:
-        luaL_error(L, "pdf.obj() allows max. 3 arguments");
+            } else {
+                if (n == first_arg + 2) {   /* write attr text */
+                    if (!lua_isstring(L, -1)) /* or number */
+                        luaL_error(L, "pdf.obj() 3rd argument must be string");
+                    obj_obj_stream_attr(static_pdf, k) =
+                        luaL_ref(Luas, LUA_REGISTRYINDEX);
+                }
+                if (lua_key_eq(st_s, stream)) {
+                    set_obj_obj_is_stream(static_pdf, k);
+                } else if (lua_key_eq(st_s, streamfile)) {
+                    set_obj_obj_is_stream(static_pdf, k);
+                    set_obj_obj_is_file(static_pdf, k);
+                } else
+                    luaL_error(L, "pdf.obj() invalid argument");
+            }
+            break;
+        default:
+            luaL_error(L, "pdf.obj() allows max. 3 arguments");
     }
     obj_obj_data(static_pdf, k) = luaL_ref(L, LUA_REGISTRYINDEX);
     return k;
@@ -478,23 +496,23 @@ static int l_reserveobj(lua_State * L)
     const char *st_s = NULL;
     n = lua_gettop(L);
     switch (n) {
-    case 0:
-        static_pdf->obj_count++;
-        pdf_last_obj = pdf_create_obj(static_pdf, obj_type_obj, static_pdf->obj_ptr + 1);
-        break;
-    case 1:
-        if (lua_type(L, -1) != LUA_TSTRING)
-            luaL_error(L, "pdf.reserveobj() optional argument must be string");
-        st_s = luaL_checkstring(L, 1);
-        if (lua_key_eq(st_s, annot)) {
-            pdf_last_annot = pdf_create_obj(static_pdf, obj_type_annot, 0);
-        } else {
-            luaL_error(L, "pdf.reserveobj() optional string must be \"annot\"");
-        }
-        lua_pop(L, 1);
-        break;
-    default:
-        luaL_error(L, "pdf.reserveobj() allows max. 1 argument");
+        case 0:
+            static_pdf->obj_count++;
+            pdf_last_obj = pdf_create_obj(static_pdf, obj_type_obj, static_pdf->obj_ptr + 1);
+            break;
+        case 1:
+            if (lua_type(L, -1) != LUA_TSTRING)
+                luaL_error(L, "pdf.reserveobj() optional argument must be string");
+            st_s = luaL_checkstring(L, 1);
+            if (lua_key_eq(st_s, annot)) {
+                pdf_last_annot = pdf_create_obj(static_pdf, obj_type_annot, 0);
+            } else {
+                luaL_error(L, "pdf.reserveobj() optional string must be \"annot\"");
+            }
+            lua_pop(L, 1);
+            break;
+        default:
+            luaL_error(L, "pdf.reserveobj() allows max. 1 argument");
     }
     lua_pushinteger(L, static_pdf->obj_ptr);
     return 1;
@@ -505,16 +523,16 @@ static int l_registerannot(lua_State * L)
     int n, i;
     n = lua_gettop(L);
     switch (n) {
-    case 1:
-        if (global_shipping_mode == NOT_SHIPPING)
-            luaL_error(L, "pdf.registerannot() can only be used in late lua");
-        i = (int) luaL_checkinteger(L, 1);
-        if (i <= 0)
-            luaL_error(L, "pdf.registerannot() can only register positive object numbers");
-        addto_page_resources(static_pdf, obj_type_annot, i);
-        break;
-    default:
-        luaL_error(L, "pdf.registerannot() needs exactly 1 argument");
+        case 1:
+            if (global_shipping_mode == NOT_SHIPPING)
+                luaL_error(L, "pdf.registerannot() can only be used in late lua");
+            i = (int) luaL_checkinteger(L, 1);
+            if (i <= 0)
+                luaL_error(L, "pdf.registerannot() can only register positive object numbers");
+            addto_page_resources(static_pdf, obj_type_annot, i);
+            break;
+        default:
+            luaL_error(L, "pdf.registerannot() needs exactly 1 argument");
     }
     return 0;
 }
@@ -599,55 +617,30 @@ static int l_set_xformresources (lua_State * L) { l_set_pdf_value(xformresources
 static int l_set_xformattributes(lua_State * L) { l_set_pdf_value(xformattributes); }
 static int l_set_trailerid      (lua_State * L) { l_set_pdf_value(trailerid); }
 
-/*
-
-static int setpdf(lua_State * L)
+static int getpdfobjtype(lua_State * L)
 {
-    const char *s ;
-    if (lua_gettop(L) != 3) {
-        return 0;
-    }
-    if (lua_type(L, -2) == LUA_TSTRING) {
-        s = lua_tostring(L, -1);
-        if (valid_pdf_key) {
-            lua_get_metatablelua(pdf_data);
-            lua_replace(L, -4);
+    if (lua_type(L, 1) == LUA_TNUMBER) {
+        int n = (int) lua_tointeger(L, 1);
+        if (n > 0 && n <= static_pdf->obj_ptr) {
+            lua_pushstring(L, pdf_obj_typenames[obj_type(static_pdf, n)]);
+            return 1;
         }
     }
-    lua_rawset(L, -3);
-    return 0;
-}
-
-*/
-
-static int l_objtype(lua_State * L)
-{
-    int n = lua_gettop(L);
-    if (n != 1)
-        luaL_error(L, "pdf.objtype() needs exactly 1 argument");
-    n = (int) luaL_checkinteger(L, 1);
-    if (n < 0 || n > static_pdf->obj_ptr)
-        lua_pushnil(L);
-    else
-        lua_pushstring(L, pdf_obj_typenames[obj_type(static_pdf, n)]);
+    lua_pushnil(L);
     return 1;
 }
 
-static int l_maxobjnum(lua_State * L)
+static int getpdfmaxobjnum(lua_State * L)
 {
-    int n = lua_gettop(L);
-    if (n != 0)
-        luaL_error(L, "pdf.maxobjnum() needs 0 arguments");
     lua_pushinteger(L, static_pdf->obj_ptr);
     return 1;
 }
 
 static int l_mapfile(lua_State * L)
 {
-    char *s;
     const char *st;
-    if ((lua_type(L,-1) == LUA_TSTRING) && (st = lua_tostring(L, -1)) != NULL) {
-        s = xstrdup(st);
+    if ((lua_type(L, 1) == LUA_TSTRING) && (st = lua_tostring(L, 1)) != NULL) {
+        char *s = xstrdup(st);
         process_map_item(s, MAPFILE);
         free(s);
     }
@@ -656,29 +649,15 @@ static int l_mapfile(lua_State * L)
 
 static int l_mapline(lua_State * L)
 {
-    char *s;
     const char *st;
-    if ((lua_type(L,-1) == LUA_TSTRING) && (st = lua_tostring(L, -1)) != NULL) {
-        s = xstrdup(st);
+    if ((lua_type(L, 1) == LUA_TSTRING) && (st = lua_tostring(L, 1)) != NULL) {
+        char *s = xstrdup(st);
         process_map_item(s, MAPLINE);
         free(s);
     }
     return 0;
 }
 
-static int l_pageref(lua_State * L)
-{
-    int n = lua_gettop(L);
-    if (n != 1)
-        luaL_error(L, "pdf.pageref() needs exactly 1 argument");
-    n = (int) luaL_checkinteger(L, 1);
-    if (n <= 0)
-        luaL_error(L, "pdf.pageref() needs page number > 0");
-    n = pdf_get_obj(static_pdf, obj_type_page, n, false);
-    lua_pushinteger(L, n);
-    return 1;
-}
-
 static int l_getpos(lua_State * L)
 {
     lua_pushinteger(L, static_pdf->posstruct->pos.h);
@@ -770,6 +749,12 @@ static int l_get_obj_compress_level(lua_State * L)
     return 1 ;
 }
 
+static int l_get_recompress(lua_State * L)
+{
+    lua_pushinteger(L, (pdf_recompress));
+    return 1 ;
+}
+
 static int l_set_compress_level(lua_State * L)
 {
     if (lua_type(L, 1) == LUA_TNUMBER) {
@@ -796,6 +781,19 @@ static int l_set_obj_compress_level(lua_State * L)
     return 0 ;
 }
 
+    static int l_set_recompress(lua_State * L)
+{
+    if (lua_type(L, 1) == LUA_TNUMBER) {
+        int c = (int) lua_tointeger(L, 1);
+        if (c<0)
+            c = 0 ;
+        else if (c>9)
+            c = 9 ;
+        set_pdf_recompress(c);
+    }
+    return 0 ;
+}
+
 /* fonts */
 
 static int getpdfgentounicode(lua_State * L)
@@ -826,6 +824,18 @@ static int setpdfomitcidset(lua_State * L)
     return 0 ;
 }
 
+/* for tracing purposes when no pages are flushed */
+
+static int setforcefile(lua_State * L)
+{
+    if (lua_type(L, 1) == LUA_TBOOLEAN) {
+        static_pdf->force_file = lua_toboolean(L,1);
+    } else {
+        static_pdf->force_file = 0;
+    }
+    return 0 ;
+}
+
 /* accuracy */
 
 static int l_get_decimal_digits(lua_State * L)
@@ -879,9 +889,10 @@ static int getpdffontname(lua_State * L)
     int c, ff ;
     if (lua_type(L, 1) == LUA_TNUMBER) {
         c = (int) lua_tointeger(L, 1);
-        pdf_check_vf(c);
-        if (!font_used(c))
+     /* pdf_check_vf(c); */
+        if (!font_used(c)) {
             pdf_init_font(static_pdf,c);
+        }
         set_ff(c);
         lua_pushinteger(L, (obj_info(static_pdf, pdf_font_num(ff))));
     } else {
@@ -895,9 +906,10 @@ static int getpdffontobjnum(lua_State * L)
     if (lua_type(L, 1) == LUA_TNUMBER) {
         int ff;
         int c = (int) lua_tointeger(L, 1);
-        pdf_check_vf(c);
-        if (!font_used(c))
+     /* pdf_check_vf(c); */
+        if (!font_used(c)) {
             pdf_init_font(static_pdf,c);
+        }
         set_ff(c);
         lua_pushinteger(L, (pdf_font_num(ff)));
     } else {
@@ -917,21 +929,19 @@ static int getpdffontsize(lua_State * L)
     return 1 ;
 }
 
-/*
-
 static int getpdfpageref(lua_State * L)
 {
     if (lua_type(L, 1) == LUA_TNUMBER) {
         int c = (int) lua_tointeger(L, 1);
-        lua_pushinteger(L, (pdf_get_obj(static_pdf, obj_type_page, c, false)));
-    } else {
-        lua_pushnil(L);
+        if (c > 0) {
+            lua_pushinteger(L, (pdf_get_obj(static_pdf, obj_type_page, c, false)));
+            return 1;
+        }
     }
+    lua_pushnil(L);
     return 1 ;
 }
 
-*/
-
 static int getpdfxformname(lua_State * L)
 {
     if (lua_type(L, 1) == LUA_TNUMBER) {
@@ -944,12 +954,6 @@ static int getpdfxformname(lua_State * L)
     return 1 ;
 }
 
-static int getpdfversion(lua_State * L)
-{
-    lua_pushinteger(L,1);
-    return 1 ;
-}
-
 static int getpdfcreationdate(lua_State * L)
 {
     initialize_start_time(static_pdf);
@@ -1169,6 +1173,76 @@ static int l_set_font_attributes(lua_State * L)
     return 0;
 }
 
+static int pdfincludechar(lua_State * L)
+{
+    int f = lua_tointeger(L, 1);
+    if (lua_type(L,2) == LUA_TTABLE) {
+        int i, c;
+        int n = lua_rawlen(L, 2);
+        for (i=1; i<=n; i++) {
+            lua_rawgeti(L, 2, i);
+            c = lua_tointeger(L, 3);
+            pdf_mark_char(f,c);
+            lua_pop(L, 1);
+        }
+    } else {
+        int c = lua_tointeger(L, 2);
+        pdf_mark_char(f,c);
+    }
+    return 0;
+}
+
+static int pdfincludefont(lua_State * L)
+{
+    int f = lua_tointeger(L, 1);
+    pdf_init_font(static_pdf,f);
+    return 0;
+}
+
+static int pdfincludeimage(lua_State * L)
+{
+    /*tex How to check for a valid entry? */
+    image_dict *idict = idict_array[lua_tointeger(L,1)];
+    int objnum = img_objnum(idict);
+    if (img_state(idict) < DICT_OUTIMG) {
+        img_state(idict) = DICT_OUTIMG;
+    }
+    if (! is_obj_written(static_pdf, objnum)) {
+        pdf_write_image(static_pdf, objnum);
+    }
+    lua_pushinteger(L,img_type(idict));
+    lua_pushinteger(L,img_xorig(idict));
+    lua_pushinteger(L,img_yorig(idict));
+    lua_pushinteger(L,img_xsize(idict));
+    lua_pushinteger(L,img_ysize(idict));
+    lua_pushinteger(L,img_rotation(idict));
+    lua_pushinteger(L,objnum);
+    if (img_type(idict) == IMG_TYPE_PNG) {
+        lua_pushinteger(L,img_group_ref(idict));
+    } else {
+        lua_pushnil(L);
+    }
+    return 8;
+}
+
+static int getpdfnofobjects(lua_State * L)
+{
+    int k;
+    int written = 0;
+    int dropped = 0;
+    for (k = 1; k <= static_pdf->obj_ptr; k++) {
+        if (is_obj_written(static_pdf, k)) {
+            written += 1;
+        } else {
+            dropped += 1;
+        }
+    }
+    lua_pushinteger(L,written);
+    lua_pushinteger(L,dropped);
+    return 2;
+}
+
+/*tex For normal output see |pdflistout.c|: */
 
 static const struct luaL_Reg pdflib[] = {
     { "gethpos", l_gethpos },
@@ -1179,11 +1253,10 @@ static const struct luaL_Reg pdflib[] = {
     { "registerannot", l_registerannot },
     { "reserveobj", l_reserveobj },
     { "getpos", l_getpos },
- /* { "pageref", getpdfpageref }, */
-    { "maxobjnum", l_maxobjnum },
-    { "pageref", l_pageref },
+    { "getpageref", getpdfpageref },
+    { "getmaxobjnum", getpdfmaxobjnum },
     { "print", luapdfprint },
-    { "objtype", l_objtype },
+    { "getobjtype", getpdfobjtype },
     { "getmatrix", l_getmatrix },
     { "hasmatrix", l_hasmatrix },
     { "setfontattributes", l_set_font_attributes },
@@ -1213,20 +1286,20 @@ static const struct luaL_Reg pdflib[] = {
     { "getlastannot", l_get_lastannot },
     { "getcompresslevel", l_get_compress_level },
     { "getobjcompresslevel", l_get_obj_compress_level },
+    { "getrecompress", l_get_recompress },
     { "setcompresslevel", l_set_compress_level },
     { "setobjcompresslevel", l_set_obj_compress_level },
+    { "setrecompress", l_set_recompress },
     { "getdecimaldigits", l_get_decimal_digits },
     { "setdecimaldigits", l_set_decimal_digits },
     { "getpkresolution", l_get_pk_resolution },
     { "setpkresolution", l_set_pk_resolution },
     { "getsuppressoptionalinfo", l_get_suppress_optional_info },
     { "setsuppressoptionalinfo", l_set_suppress_optional_info },
-    /* moved from tex table */
-    { "fontname", getpdffontname },
-    { "fontobjnum", getpdffontobjnum },
-    { "fontsize", getpdffontsize },
-    { "xformname", getpdfxformname },
-    { "getversion", getpdfversion },
+    { "getfontname", getpdffontname },
+    { "getfontobjnum", getpdffontobjnum },
+    { "getfontsize", getpdffontsize },
+    { "getxformname", getpdfxformname },
     { "getcreationdate", getpdfcreationdate },
     { "getmajorversion", getpdfmajorversion },
     { "setmajorversion", setpdfmajorversion },
@@ -1253,8 +1326,22 @@ static const struct luaL_Reg pdflib[] = {
     { "setignoreunknownimages", setpdfignoreunknownimages },
     { "setgentounicode", setpdfgentounicode },
     { "setomitcidset", setpdfomitcidset },
+    { "setforcefile", setforcefile },
     { "mapfile", l_mapfile },
     { "mapline", l_mapline },
+    { "includechar", pdfincludechar },
+    { "includefont", pdfincludefont },
+    /* might go, used when sanitizing backend */
+    { "includeimage", pdfincludeimage },
+    { "getnofobjects", getpdfnofobjects },
+    /* for a while */
+    { "maxobjnum", getpdfmaxobjnum },
+    { "pageref", getpdfpageref },
+    { "objtype", getpdfobjtype },
+    { "fontname", getpdffontname },
+    { "fontobjnum", getpdffontobjnum },
+    { "fontsize", getpdffontsize },
+    { "xformname", getpdfxformname },
     /* sentinel */
     {NULL, NULL}
 };
diff --git a/texk/web2c/luatexdir/lua/lpdfscannerlib.cc b/texk/web2c/luatexdir/lua/lpdfscannerlib.cc
index 8bafd6122..56452b2ff 100644
--- a/texk/web2c/luatexdir/lua/lpdfscannerlib.cc
+++ b/texk/web2c/luatexdir/lua/lpdfscannerlib.cc
@@ -17,6 +17,70 @@
    You should have received a copy of the GNU General Public License along
    with LuaTeX; if not, see <http://www.gnu.org/licenses/>. */
 
+/* converted example in manual:
+
+local operatortable = { }
+
+operatortable.Do = function(scanner,info)
+    local resources = info.resources
+    if resources then
+        local val     = scanner:pop()
+        local name    = val[2]
+        local xobject = pdfe.dictionarytotable(resources.XObject[2])
+        print(info.space .. "Uses XObject " .. name)
+        local kind,
+              entry  = unpack(xobject[name])
+        local dict
+        if kind == 10 then -- reference
+            kind,
+            entry,
+            dict = pdfe.getfromreference(entry)
+        end
+        if kind == 9 then -- stream
+            dict = pdfe.dictionarytotable(dict)
+            local resources = dict.Resources
+            if resources then
+                local newinfo =  {
+                    space     = info.space .. "  " ,
+                    resources = Resources[2],
+                }
+                pdfscanner.scan(entry, operatortable, newinfo)
+            end
+        end
+    end
+end
+
+local function Analyze(filename)
+    local doc = pdfe.open(filename)
+    if doc then
+        local pagenum  = 1
+        local n        = 1 -- pdfe.getnofpages(doc)
+        for i=1,n do
+            local page = pdfe.getpage(doc,i)
+            local kind,
+                  data = pdfe.getfromdictionarybyname(page,"Resources")
+            if kind == 10 then -- reference
+                kind, data = pdfe.getfromreference(data)
+            end
+            data = pdfe.dictionarytotable(data)
+            local info = {
+              space     = "  " ,
+              resources = data,
+            }
+            print("Page " .. i)
+            kind, data = pdfe.getfromdictionarybyname(page,"Contents")
+            if kind == 10 then -- reference
+                kind, data = pdfe.getfromreference(data)
+            end
+            pdfscanner.scan(data,operatortable,info)
+        end
+    end
+end
+
+Analyze("e:/tmp/oeps.pdf")
+
+*/
+
 #  include <stdlib.h>
 #  include <stdio.h>
 #  include <stdarg.h>
@@ -28,26 +92,9 @@ extern "C" {
 #  include <lua.h>
 #  include <lauxlib.h>
 #  include <lualib.h>
-}
 
-#  include <poppler-config.h>
-#  include <goo/GooString.h>
-#  include <goo/gmem.h>
-#  include <goo/gfile.h>
-#  include <Object.h>
-#  include <Stream.h>
-#  include <Gfx.h>
-#  include <Annot.h>
-#  include <Array.h>
-#  include <Dict.h>
-#  include <XRef.h>
-#  include <Catalog.h>
-#  include <Link.h>
-#  include <Page.h>
-#  include <GfxFont.h>
-#  include <PDFDoc.h>
-#  include <GlobalParams.h>
-#  include <Error.h>
+#  include "luapplib/pplib.h"
+}
 
 #  include <lua/luatex-api.h>
 
@@ -57,48 +104,47 @@ extern "C" {
 #define MAXOPERANDS 1000
 
 typedef enum {
-  pdf_integer = 1,
-  pdf_real,
-  pdf_boolean,
-  pdf_name,
-  pdf_operator,
-  pdf_string,
-  pdf_startarray,
-  pdf_stoparray,
-  pdf_startdict,
-  pdf_stopdict,
+    pdf_integer = 1,
+    pdf_real,
+    pdf_boolean,
+    pdf_name,
+    pdf_operator,
+    pdf_string,
+    pdf_startarray,
+    pdf_stoparray,
+    pdf_startdict,
+    pdf_stopdict,
 } pdf_token_type ;
 
-
 typedef struct Token {
-  pdf_token_type type;
-  double value;
-  char *string;
+    pdf_token_type type;
+    double value;
+    char *string;
 } Token;
 
 typedef struct ObjectList {
-  struct ObjectList *next;
-  Object *stream;
+    struct ObjectList *next;
+    ppstream *stream;
 } ObjectList;
 
 typedef struct scannerdata {
-  int _ininlineimage;
-  int _nextoperand;
-  Token ** _operandstack;
-  Object * _stream;
-  ObjectList * _streams;
+    int _ininlineimage;
+    int _nextoperand;
+    Token ** _operandstack;
+    ppstream * _stream;
+    ObjectList * _streams;
+    const char *buffer;
+    size_t position;
+    size_t size;
 } scannerdata;
 
-typedef enum { ALLOC_POPPLER, ALLOC_LEPDF } alloctype;
-
-#define M_Object           "Object"
-#define M_Stream           "Stream"
+#define PDFE_METATABLE_ARRAY  "luatex.pdfe.array"
+#define PDFE_METATABLE_STREAM "luatex.pdfe.stream"
 
 typedef struct {
     void *d;
-    alloctype atype;            // was it allocated by poppler or the lepdflib.cc?
     void *pd;            // reference to PdfDocument, or NULL
-    unsigned long pc;           // counter to detect PDFDoc change
+    unsigned long pc;    // counter to detect PDFDoc change
 } udstruct;
 
 static void clear_operand_stack (scannerdata *self, int from);
@@ -119,8 +165,8 @@ static void *priv_xrealloc (void *old_ptr, size_t size)
 {
     void *new_mem = (void *)realloc(old_ptr, size);
     if (new_mem == NULL) {
-      fprintf(stderr,"fatal: memory exhausted (realloc of %lu bytes).\n", (unsigned long)size);
-      exit(EXIT_FAILURE);
+        fprintf(stderr,"fatal: memory exhausted (realloc of %lu bytes).\n", (unsigned long)size);
+        exit(EXIT_FAILURE);
     }
     return new_mem;
 }
@@ -129,20 +175,20 @@ static void *priv_xrealloc (void *old_ptr, size_t size)
 
 #define INITBUFSIZE 64
 
-#define define_buffer(a)				\
-  char *a = (char *)priv_xmalloc (INITBUFSIZE);		\
-  int a##_size = INITBUFSIZE;				\
-  int a##index = 0;					\
+#define define_buffer(a) \
+  char *a = (char *)priv_xmalloc (INITBUFSIZE); \
+  int a##_size = INITBUFSIZE; \
+  int a##index = 0; \
   memset (a,0,INITBUFSIZE)
 
-#define check_overflow(a, wsize) do {					\
-    if (wsize >= a##_size) {						\
-      int nsize = a##_size + a##_size / 4;				\
-      a = (char *) xreallocarray(a, char, (unsigned) nsize);		\
-      memset (a+a##_size, 0, a##_size / 4);				\
-      a##_size = nsize;							\
-    }									\
-  } while (0)
+#define check_overflow(a, wsize) do { \
+    if (wsize >= a##_size) { \
+        int nsize = a##_size + a##_size / 4; \
+        a = (char *) xreallocarray(a, char, (unsigned) nsize); \
+        memset (a+a##_size, 0, a##_size / 4); \
+        a##_size = nsize; \
+    } \
+} while (0)
 
 
 static scannerdata * scanner_push(lua_State * L)
@@ -155,769 +201,814 @@ static scannerdata * scanner_push(lua_State * L)
 
 static scannerdata *scanner_check (lua_State *L, int index)
 {
-  scannerdata *bar;
-  luaL_checktype(L, index, LUA_TUSERDATA);
-  bar = (scannerdata *)luaL_checkudata(L, index, SCANNER);
-  if (bar == NULL) luaL_argerror(L, index, SCANNER " expected");
-  return bar;
+    scannerdata *bar;
+    luaL_checktype(L, index, LUA_TUSERDATA);
+    bar = (scannerdata *)luaL_checkudata(L, index, SCANNER);
+    if (bar == NULL)
+        luaL_argerror(L, index, SCANNER " expected");
+    return bar;
 }
 
 static void free_token (Token *token)
 {
-  if (token->string) {
-    free(token->string);
-  }
-  free(token);
+    if (token->string) {
+        free(token->string);
+    }
+    free(token);
 }
 
 static void clear_operand_stack (scannerdata *self, int from)
 {
-  int i = self->_nextoperand-1;
-  while (i>=from) {
-    if (self->_operandstack[i]) {
-      free_token(self->_operandstack[i]);
-      self->_operandstack[i] = NULL;
+    int i = self->_nextoperand-1;
+        while (i>=from) {
+            if (self->_operandstack[i]) {
+            free_token(self->_operandstack[i]);
+            self->_operandstack[i] = NULL;
+        }
+        i--;
     }
-    i--;
-  }
-  self->_nextoperand = from;
+    self->_nextoperand = from;
 }
 
 static void push_operand (scannerdata *self, Token *token)
 {
-  if (self->_nextoperand+1> MAXOPERANDS) {
-    fprintf(stderr, "out of operand stack space");
-    exit(1);
-  }
-  self->_operandstack[self->_nextoperand++] = token;
+    if (self->_nextoperand+1> MAXOPERANDS) {
+        fprintf(stderr, "out of operand stack space");
+        exit(1);
+    }
+    self->_operandstack[self->_nextoperand++] = token;
 }
 
 static Token * new_operand (pdf_token_type c)
 {
-  Token *token = (Token *)priv_xmalloc(sizeof(Token));
-  memset (token, 0, sizeof(Token));
-  token->type = c;
-  return token;
+    Token *token = (Token *)priv_xmalloc(sizeof(Token));
+    memset (token, 0, sizeof(Token));
+    token->type = c;
+    return token;
+}
+
+static void _nextStream (scannerdata *self)
+{
+    if (self->buffer != NULL) {
+        ppstream_done(self->_stream);
+    }
+    ObjectList *rover = self->_streams;
+    self->_stream = rover->stream;
+    self->buffer = (const char*) ppstream_all(self->_stream,&self->size,1);
+    self->position = 0;
+    self->_streams = rover->next;
+    free(rover);
+}
+
+static int streamGetChar (scannerdata *self)
+{
+    int i = EOF ;
+    if (self->position < self->size) {
+        const char c = self->buffer[self->position];
+        ++self->position;
+        i = (int) c;
+    }
+    if (i<0 && self->_streams) {
+        _nextStream(self);
+        i = streamGetChar(self);
+    }
+    return i;
 }
 
-static void _nextStream (scannerdata *self) {
-  self->_stream->streamClose();
-  ObjectList *rover = self->_streams;
-  self->_stream = rover->stream;
-  self->_stream->streamReset();
-  self->_streams = rover->next;
-  free(rover);
+static int streamLookChar (scannerdata *self)
+{
+    int i = EOF ;
+    if (self->position < self->size) {
+        const char c = self->buffer[self->position];
+     /* ++self->position; */
+        i = (int) c;
+    }
+    if (i<0 && self->_streams) {
+        _nextStream(self);
+        i = streamGetChar(self);
+    }
+    return i;
 }
 
-static int streamGetChar (scannerdata *self) {
-  int i = self->_stream->streamGetChar();
-  if (i<0 && self->_streams) {
-    _nextStream(self);
-    i = streamGetChar(self);
-  }
-  return i;
+static void streamReset (scannerdata *self)
+{
+    self->buffer = (const char*) ppstream_all(self->_stream,&self->size,1);
+    self->position = 0;
 }
 
-static int streamLookChar (scannerdata *self) {
-  int i= self->_stream->streamLookChar();
-  if (i<0 && self->_streams) {
-    _nextStream(self);
-    i = streamLookChar(self);
-  }
-  return i;
+static void streamClose (scannerdata *self) {
+    ppstream_done(self->_stream);
+    self->buffer = NULL;
+    self->_stream = NULL;
 }
 
+/* end of stream interface */
+
 static Token * _parseSpace (scannerdata *self)
 {
-  return _parseToken (self,streamGetChar(self));
+    return _parseToken (self,streamGetChar(self));
 }
 
 static Token * _parseString (scannerdata *self, int c)
 {
-  //   local token = {type = pdf_string,value = ''}
-  define_buffer(found);
-  int level = 1;
-  while (1) {
-    c = streamGetChar(self);
-    if (c == '(') {
-      level = level + 1 ;
-    }
-    if (c == ')') {
-      level = level - 1 ;
-      if (level < 1) break;
-    }
-    if (c == '\\') {
-      int next = streamGetChar(self);
-      if (next == '(' || next == ')' || next == '\\') {
-	c = next;
-      } else if (next == '\n' || next == '\r') {
-	c = '\0';
-      } else if (next == 'n') {
-	c = '\n';
-      } else if (next == 'r') {
-	c = '\r';
-      } else if (next == 't') {
-	c = '\t';
-      } else if (next == 'b') {
-	c = '\b';
-      } else if (next == 'f') {
-	c = '\f';
-      } else if (next >= '0' && next <= '7') {
-	next = next - '0';
- 	int next2 = streamLookChar(self);
-	if (next2 >= '0' && next2 <= '7') {
-	  next2 = streamGetChar(self);
-	  next2 = next2 - '0';
-	  int next3 = streamLookChar(self);
-	  if (next3 >= '0' && next3 <= '7') {
-	    next3 = streamGetChar(self);
-	    next3 = next3 - '0';
-	    c = (next*64+next2*8+next3);
-	  } else {
-	    c = (next*8+next2);
-	  }
-	} else {
-	  c = next;
-	}
-      } else {
-	c = next;
-      }
-    }
-    check_overflow(found,foundindex);
-    if (c>=0) {
-      found[foundindex++] = c;
-    }
-  }
-  Token *token = new_operand(pdf_string);
-  token->value = foundindex;
-  token->string = found;
-  return token;
+    define_buffer(found);
+    int level = 1;
+    while (1) {
+        c = streamGetChar(self);
+        if (c == '(') {
+            level = level + 1 ;
+        } else if (c == ')') {
+            level = level - 1 ;
+            if (level < 1) break;
+        } else if (c == '\\') {
+            int next = streamGetChar(self);
+            if (next == '(' || next == ')' || next == '\\') {
+                c = next;
+            } else if (next == '\n' || next == '\r') {
+                c = '\0';
+            } else if (next == 'n') {
+                c = '\n';
+            } else if (next == 'r') {
+                c = '\r';
+            } else if (next == 't') {
+                c = '\t';
+            } else if (next == 'b') {
+                c = '\b';
+            } else if (next == 'f') {
+                c = '\f';
+            } else if (next >= '0' && next <= '7') {
+                next = next - '0';
+                int next2 = streamLookChar(self);
+                if (next2 >= '0' && next2 <= '7') {
+                    next2 = streamGetChar(self);
+                    next2 = next2 - '0';
+                    int next3 = streamLookChar(self);
+                    if (next3 >= '0' && next3 <= '7') {
+                        next3 = streamGetChar(self);
+                        next3 = next3 - '0';
+                        c = (next*64+next2*8+next3);
+                    } else {
+                        c = (next*8+next2);
+                    }
+                } else {
+                    c = next;
+                }
+            } else {
+                c = next;
+            }
+        }
+        check_overflow(found,foundindex);
+        if (c>=0) {
+            found[foundindex++] = c;
+        }
+    }
+    Token *token = new_operand(pdf_string);
+    token->value = foundindex;
+    token->string = found;
+    return token;
 }
 
-
 static Token * _parseNumber (scannerdata *self, int c)
 {
-  double value = 0;
-  pdf_token_type type = pdf_integer;
-  int isfraction = 0;
-  int isnegative = 0;
-  int i = 0;
-  if (c == '-') {
-    isnegative = 1;
-    c = streamGetChar(self);
-  }
-  if (c == '.') {
-    type = pdf_real;
-    isfraction = 1;
-  } else  {
-    value = c - '0';
-  }
-  c = streamLookChar(self);
-  if ((c>= '0'&&  c<= '9') || c == '.') {
-    c = streamGetChar(self);
-    while (1) {
-      if (c == '.') {
-	type = pdf_real;
-	isfraction = 1;
-      } else {
-	i = c - '0';
-	if (isfraction>0) {
-	  value = value + (i/(pow(10.0,isfraction)));
-	  isfraction = isfraction + 1;
-	} else {
-	  value = (value * 10) + i;
-	}
-      }
-      c = streamLookChar(self);
-      if (! ((c>= '0' && c<= '9') ||  c == '.')) break ;
-      c = streamGetChar(self);
-    }
-  }
-  if (isnegative) {
-    value = -value;
-  }
-  Token *token = new_operand(type);
-  token->value = value;
-  return token;
+    double value = 0;
+    pdf_token_type type = pdf_integer;
+    int isfraction = 0;
+    int isnegative = 0;
+    int i = 0;
+    if (c == '-') {
+        isnegative = 1;
+        c = streamGetChar(self);
+    }
+    if (c == '.') {
+        type = pdf_real;
+        isfraction = 1;
+    } else  {
+        value = c - '0';
+    }
+    c = streamLookChar(self);
+    if ((c>= '0'&&  c<= '9') || c == '.') {
+        c = streamGetChar(self);
+        while (1) {
+            if (c == '.') {
+                type = pdf_real;
+                isfraction = 1;
+            } else {
+                i = c - '0';
+                if (isfraction>0) {
+                    value = value + (i/(pow(10.0,isfraction)));
+                    isfraction = isfraction + 1;
+                } else {
+                    value = (value * 10) + i;
+                }
+            }
+            c = streamLookChar(self);
+            if (! ((c>= '0' && c<= '9') ||  c == '.'))
+                break ;
+            c = streamGetChar(self);
+        }
+    }
+    if (isnegative) {
+        value = -value;
+    }
+    Token *token = new_operand(type);
+    token->value = value;
+    return token;
 }
 
-
 static Token *_parseName (scannerdata *self, int c)
 {
-  define_buffer(found);
-  c = streamGetChar(self);
-  while (1) {
-    check_overflow(found,foundindex);
-    found[foundindex++] = c;
-    c = streamLookChar(self);
-    if (c == ' ' || c == '\n' || c == '\r' || c == '\t' ||
-	c == '/' || c == '[' || c == '(' || c == '<') break ;
+    define_buffer(found);
     c = streamGetChar(self);
-  }
-  Token *token = new_operand(pdf_name);
-  token->string = found;
-  token->value = strlen(found);
-  return token;
+    while (1) {
+        check_overflow(found,foundindex);
+        found[foundindex++] = c;
+        c = streamLookChar(self);
+        if (c == ' ' || c == '\n' || c == '\r' || c == '\t' ||
+            c == '/' || c == '[' || c == '(' || c == '<') break ;
+        c = streamGetChar(self);
+    }
+    Token *token = new_operand(pdf_name);
+    token->string = found;
+    token->value = strlen(found);
+    return token;
 }
 
-#define hexdigit(c)							\
+#define hexdigit(c)	\
   (c>= '0' && c<= '9') ? (c - '0') : ((c>= 'A' && c<= 'F') ? (c - 'A' + 10) : (c - 'a' + 10))
 
 static Token *_parseHexstring (scannerdata *self, int c)
 {
-  int isodd = 1;
-  int hexval = 0;
-  define_buffer(found);
-  while (c != '>') {
-    if ((c>= '0' && c<= '9') ||
-	(c>= 'A' && c<= 'F') ||
-	(c>= 'a' && c<= 'f')) {
-      if (isodd==1) {
-	int v = hexdigit(c);
-	hexval = 16 * v;
-      } else {
-	hexval += hexdigit(c);
-	check_overflow(found,foundindex);
-	found[foundindex++] = hexval;
-      }
-      isodd = (isodd==1 ? 0 : 1);
+    int isodd = 1;
+    int hexval = 0;
+    define_buffer(found);
+    while (c != '>') {
+        if ((c>= '0' && c<= '9') || (c>= 'A' && c<= 'F') || (c>= 'a' && c<= 'f')) {
+            if (isodd==1) {
+                int v = hexdigit(c);
+                hexval = 16 * v;
+            } else {
+                hexval += hexdigit(c);
+                check_overflow(found,foundindex);
+                found[foundindex++] = hexval;
+            }
+            isodd = (isodd==1 ? 0 : 1);
+        }
+        c = streamGetChar(self);
     }
-    c = streamGetChar(self);
-  }
-  Token *token = new_operand(pdf_string);
-  token->value = foundindex;
-  token->string = found;
-  return token;
+    Token *token = new_operand(pdf_string);
+    token->value = foundindex;
+    token->string = found;
+    return token;
 }
 
 #define pdf_isspace(a) (a == '\0' || a == ' ' || a == '\n' || a == '\r' || a == '\t' || a == '\v')
 
 // -- this is rather horrible
+
 static Token *_parseInlineImage (scannerdata *self, int c)
 {
-  define_buffer(found);
-  if (c == ' ') { // first space can be ignored
-    c = streamGetChar(self);
-  }
-  check_overflow(found, foundindex);
-  found[foundindex++] = c;
-  while (1) {
-    c = streamLookChar(self);
-    if (c == 'E' && (found[foundindex-1] == '\n' || found[foundindex-1] == '\r')) {
-      c = streamGetChar(self);
-      check_overflow(found, foundindex);
-      found[foundindex++] = c;
-      c = streamLookChar(self);
-      if (c == 'I') {
-	c = streamGetChar(self);
-	check_overflow(found, foundindex);
-	found[foundindex++] = c;
-	c = streamLookChar(self);
-	if (pdf_isspace(c)) {
-	  found[--foundindex] = '\0'; /* I */
-	  found[--foundindex] = '\0'; /* E */
-	  /* remove end-of-line before EI */
-	  if (found[foundindex-1] == '\n') {
-	    found[--foundindex] = '\0';
-	  }
-	  if (found[foundindex-1] == '\r') {
-	    found[--foundindex] = '\0';
-	  }
-	  break;
-	} else {
-	  c = streamGetChar(self);
-	  check_overflow(found, foundindex);
-	  found[foundindex++] = c;
-	}
-      } else {
-	c = streamGetChar(self);
-	check_overflow(found, foundindex);
-	found[foundindex++] = c;
-      }
-    } else {
-      c = streamGetChar(self);
-      check_overflow(found, foundindex);
-      found[foundindex++] = c;
+    define_buffer(found);
+    if (c == ' ') { // first space can be ignored
+        c = streamGetChar(self);
     }
-  }
-  Token *token = new_operand(pdf_string);
-  token->value = foundindex;
-  token->string = found;
-  return token;
-}
-
-static Token *_parseOperator (scannerdata *self, int c)
-{
-  define_buffer(found);
-  while (1) {
     check_overflow(found, foundindex);
     found[foundindex++] = c;
-    c = streamLookChar(self);
-    if ((c<0) || (c == ' ' || c == '\n' || c == '\r' || c == '\t' ||
-		  c == '/' || c == '[' || c == '(' || c == '<'))
-      break ;
-    c = streamGetChar(self);
-  }
-  // print (found)
-  if (strcmp(found, "ID") == 0) {
-    self->_ininlineimage = 1;
-  }
-  if (strcmp(found,"false") == 0) {
-    Token *token = new_operand(pdf_boolean);
-    token->value = 0;
-    free(found);
-    return token;
-  } else if (strcmp(found,"true") == 0) {
-    Token *token = new_operand(pdf_boolean);
-    token->value = 1.0;
-    free(found);
-    return token;
-  } else {
-    Token *token = new_operand(pdf_operator);
+    while (1) {
+        c = streamLookChar(self);
+        if (c == 'E' && (found[foundindex-1] == '\n' || found[foundindex-1] == '\r')) {
+            c = streamGetChar(self);
+            check_overflow(found, foundindex);
+            found[foundindex++] = c;
+            c = streamLookChar(self);
+            if (c == 'I') {
+                c = streamGetChar(self);
+                check_overflow(found, foundindex);
+                found[foundindex++] = c;
+                c = streamLookChar(self);
+                if (pdf_isspace(c)) {
+                    found[--foundindex] = '\0'; /* I */
+                    found[--foundindex] = '\0'; /* E */
+                    /* remove end-of-line before EI */
+                    if (found[foundindex-1] == '\n') {
+                        found[--foundindex] = '\0';
+                    }
+                    if (found[foundindex-1] == '\r') {
+                        found[--foundindex] = '\0';
+                    }
+                    break;
+                } else {
+                    c = streamGetChar(self);
+                    check_overflow(found, foundindex);
+                    found[foundindex++] = c;
+                }
+            } else {
+                c = streamGetChar(self);
+                check_overflow(found, foundindex);
+                found[foundindex++] = c;
+            }
+        } else {
+            c = streamGetChar(self);
+            check_overflow(found, foundindex);
+            found[foundindex++] = c;
+        }
+    }
+    Token *token = new_operand(pdf_string);
+    token->value = foundindex;
     token->string = found;
     return token;
-  }
+}
+
+static Token *_parseOperator (scannerdata *self, int c)
+{
+    define_buffer(found);
+    while (1) {
+        check_overflow(found, foundindex);
+        found[foundindex++] = c;
+        c = streamLookChar(self);
+        if ((c<0) || (c == ' ' || c == '\n' || c == '\r' || c == '\t' ||
+                c == '/' || c == '[' || c == '(' || c == '<'))
+            break ;
+        c = streamGetChar(self);
+    }
+    // print (found)
+    if (strcmp(found, "ID") == 0) {
+        self->_ininlineimage = 1;
+    }
+    if (strcmp(found,"false") == 0) {
+        Token *token = new_operand(pdf_boolean);
+        token->value = 0;
+        free(found);
+        return token;
+    } else if (strcmp(found,"true") == 0) {
+        Token *token = new_operand(pdf_boolean);
+        token->value = 1.0;
+        free(found);
+        return token;
+    } else {
+        Token *token = new_operand(pdf_operator);
+        token->string = found;
+        return token;
+    }
 }
 
 
 static Token * _parseComment  (scannerdata *self, int c)
 {
-  do {
-    c = streamGetChar(self);
-  } while (c != '\n' && c != '\r' && c != -1);
-  return _parseToken(self,streamGetChar(self));
+    do {
+        c = streamGetChar(self);
+    } while (c != '\n' && c != '\r' && c != -1);
+    return _parseToken(self,streamGetChar(self));
 }
 
 static Token *_parseLt (scannerdata *self, int c)
 {
-  c = streamGetChar(self);
-  if (c == '<') {
-    return new_operand(pdf_startdict);
-  } else {
-    return _parseHexstring(self,c);
-  }
+    c = streamGetChar(self);
+    if (c == '<') {
+        return new_operand(pdf_startdict);
+    } else {
+        return _parseHexstring(self,c);
+    }
 }
 
 static Token * _parseGt (scannerdata *self, int c)
 {
-  c = streamGetChar(self);
-  if (c== '>') {
-    return new_operand(pdf_stopdict);
-  } else {
-    fprintf(stderr,"stray > in stream");
-    return NULL;
-  }
+    c = streamGetChar(self);
+    if (c== '>') {
+        return new_operand(pdf_stopdict);
+    } else {
+        fprintf(stderr,"stray > in stream");
+        return NULL;
+    }
 }
 
-
 static Token *_parseError (int c)
 {
-  fprintf(stderr, "stray %c [%d] in stream", c, c);
-  return NULL;
+    fprintf(stderr, "stray %c [%d] in stream", c, c);
+    return NULL;
 }
 
 static Token *_parseStartarray ()
 {
-  return new_operand (pdf_startarray);
+    return new_operand (pdf_startarray);
 }
 
 static Token *_parseStoparray ()
 {
-  return new_operand (pdf_stoparray);
+    return new_operand (pdf_stoparray);
 }
 
 
 static Token *_parseToken (scannerdata *self, int c)
 {
-   if (self->_ininlineimage==1) {
-     self->_ininlineimage = 2;
-     return _parseInlineImage(self,c);
-   } else if (self->_ininlineimage==2) {
-     self->_ininlineimage = 0;
-     Token *token = new_operand(pdf_operator);
-     token->string = strdup("EI");
-     return token;
-   }
-   if (c<0)  return NULL ;
-   switch (c) {
-   case '(': return _parseString(self,c); break;
-   case ')': return _parseError(c); break;
-   case '[': return _parseStartarray(); break;
-   case ']': return _parseStoparray(); break;
-   case '/': return _parseName(self,c); break;
-   case '<': return _parseLt(self,c); break;
-   case '>': return _parseGt(self,c); break;
-   case '%': return _parseComment(self,c); break;
-   case ' ':
-   case '\r':
-   case '\n':
-   case '\t':
-     return _parseSpace(self); break;
-   case '0':
-   case '1':
-   case '2':
-   case '3':
-   case '4':
-   case '5':
-   case '6':
-   case '7':
-   case '8':
-   case '9':
-   case '-':
-   case '.':
-     return _parseNumber(self,c); break;
-   default:
-     if (c<=127) {
-       return _parseOperator(self,c);
-     } else {
-       return _parseError(c);
-     }
-   }
+    if (self->_ininlineimage==1) {
+        self->_ininlineimage = 2;
+        return _parseInlineImage(self,c);
+    } else if (self->_ininlineimage==2) {
+        self->_ininlineimage = 0;
+        Token *token = new_operand(pdf_operator);
+        token->string = strdup("EI");
+        return token;
+    }
+    if (c<0)
+        return NULL ;
+    switch (c) {
+        case '(':
+            return _parseString(self,c);
+            break;
+        case ')':
+            return _parseError(c);
+            break;
+        case '[':
+            return _parseStartarray();
+            break;
+        case ']':
+            return _parseStoparray();
+            break;
+        case '/':
+            return _parseName(self,c);
+            break;
+        case '<':
+            return _parseLt(self,c);
+            break;
+        case '>':
+            return _parseGt(self,c);
+            break;
+        case '%':
+            return _parseComment(self,c);
+            break;
+        case ' ':
+        case '\r':
+        case '\n':
+        case '\t':
+            return _parseSpace(self);
+        break;
+        case '0':
+        case '1':
+        case '2':
+        case '3':
+        case '4':
+        case '5':
+        case '6':
+        case '7':
+        case '8':
+        case '9':
+        case '-':
+        case '.':
+            return _parseNumber(self,c);
+        break;
+        default:
+            if (c<=127) {
+                return _parseOperator(self,c);
+            } else {
+                return _parseError(c);
+            }
+    }
 }
 
 static int scanner_scan(lua_State * L)
 {
-  Token *token;
-  scannerdata *self;
-  if (lua_gettop(L) != 3) {
-    return 0;
-  }
-  luaL_checktype(L, 2, LUA_TTABLE);
-  luaL_checktype(L, 3, LUA_TTABLE);
-  self = scanner_push(L);
-  memset(self,0,sizeof(scannerdata));
-  self->_operandstack = (Token **)priv_xmalloc (MAXOPERANDS * sizeof (Token));
-  memset (self->_operandstack,0,(MAXOPERANDS * sizeof (Token)));
-  // 4 = self
-  if (lua_type(L,1)== LUA_TTABLE) {
-    udstruct *uin;
-    int i = 1;
-    while (1) {
-      lua_rawgeti(L,1,i);
-      if (lua_type(L,-1)== LUA_TUSERDATA) {
-	uin = (udstruct *) luaL_checkudata(L, -1, M_Object);
-	if (((Object *) uin->d)->isStream()) {
-	  ObjectList *rover = self->_streams;
-	  ObjectList *item = (ObjectList *)priv_xmalloc (sizeof(ObjectList));
-	  item->stream = ((Object *) uin->d);
-	  item->next = NULL;
-	  if (!rover) {
-	    rover = item;
-	    self->_streams = rover;
-	  } else {
-	    while (rover->next)
-	      rover = rover->next;
-	    rover->next = item;
-	  }
-	}
-      } else { // done
-	ObjectList *rover = self->_streams;
-	self->_stream = rover->stream;
-	self->_streams = rover->next;
-	free(rover);
-	lua_pop(L,1);
-	break;
-      }
-      lua_pop(L,1);
-      i++;
-    }
-
-  } else {
-    udstruct *uin;
-    luaL_checktype(L, 1, LUA_TUSERDATA);
-    uin = (udstruct *) luaL_checkudata(L, 1, M_Object);
-    if (((Object *) uin->d)->isStream()) {
-      self->_stream = ((Object *) uin->d);
-    } else if (((Object *) uin->d)->isArray()) {
-      Array *arrayref = ((Object *) uin->d)->getArray();
-      int count = arrayref->getLength();
-      int i;
-      for (i=0;i<count;i++) {
-	Object *val = new Object();
-	*val = arrayref->get(i);
-	if (val->isStream()) {
-	  ObjectList *rover = self->_streams;
-	  ObjectList *item = (ObjectList *)priv_xmalloc (sizeof(ObjectList));
-	  item->stream = val;
-	  item->next = NULL;
-	  if (!rover) {
-	    rover = item;
-	    self->_streams = rover;
-	  } else {
-	    while (rover->next)
-	      rover = rover->next;
-	    rover->next = item;
-	  }
-	}
-      }
-      ObjectList *rover = self->_streams;
-      self->_stream = rover->stream;
-      self->_streams = rover->next;
-    }
-
-  }
-  assert (lua_gettop(L) == 4);
-  self->_stream->streamReset();
-  token = _parseToken(self,streamGetChar(self));
-  while (token) {
-    if (token->type == pdf_operator) {
-      lua_pushstring(L, token->string);
-      free_token(token);
-      lua_rawget(L,2); // operator table
-      if (lua_isfunction(L,-1)) {
-	lua_pushvalue(L,4);
-	lua_pushvalue(L,3);
-	(void)lua_call(L,2,0);
-      } else {
-	lua_pop(L,1); // nil
-      }
-      clear_operand_stack(self,0);
-    } else {
-      push_operand(self, token);
+    Token *token;
+    scannerdata *self;
+    if (lua_gettop(L) != 3) {
+        return 0;
     }
-    if (!self->_stream) {
-      break;
+    luaL_checktype(L, 2, LUA_TTABLE);
+    luaL_checktype(L, 3, LUA_TTABLE);
+    self = scanner_push(L);
+    memset(self,0,sizeof(scannerdata));
+    self->_operandstack = (Token **)priv_xmalloc (MAXOPERANDS * sizeof (Token));
+    memset (self->_operandstack,0,(MAXOPERANDS * sizeof (Token)));
+    // 4 = self
+    if (lua_type(L,1)== LUA_TTABLE) {
+        udstruct *uin;
+        void *ud;
+        int i = 1;
+        while (1) {
+            lua_rawgeti(L,1,i);
+            if (lua_type(L,-1)== LUA_TUSERDATA) {
+                ud = luaL_checkudata(L, -1, PDFE_METATABLE_STREAM);
+                if (ud != NULL) {
+                    uin = (udstruct *) ud;
+                    ObjectList *rover = self->_streams;
+                    ObjectList *item = (ObjectList *)priv_xmalloc (sizeof(ObjectList));
+                    item->stream = ((ppstream *) uin->d);
+                    item->next = NULL;
+                    if (!rover) {
+                        rover = item;
+                        self->_streams = rover;
+                    } else {
+                        while (rover->next)
+                            rover = rover->next;
+                        rover->next = item;
+                    }
+                }
+            } else {
+                ObjectList *rover = self->_streams;
+                self->_stream = rover->stream;
+                self->_streams = rover->next;
+                free(rover);
+                lua_pop(L,1);
+                break;
+            }
+            lua_pop(L,1);
+            i++;
+        }
+    } else {
+        udstruct *uin;
+        void *ud;
+        luaL_checktype(L, 1, LUA_TUSERDATA);
+        ud = luaL_checkudata(L, 1, PDFE_METATABLE_STREAM);
+        if (ud != NULL) {
+            uin = (udstruct *) ud;
+            self->_stream = ((ppstream *) uin->d);
+        } else {
+            ud = luaL_checkudata(L, 1, PDFE_METATABLE_ARRAY);
+            if (ud != NULL) {
+                uin = (udstruct *) ud;
+                pparray * array = (pparray *) uin->d;
+                int count = array->size;
+                int i;
+                for (i=0;i<count;i++) {
+                    ppobj *obj = pparray_at(array,i);
+                    if (obj->type == PPSTREAM) {
+                        ObjectList *rover = self->_streams;
+                        ObjectList *item = (ObjectList *)priv_xmalloc (sizeof(ObjectList));
+                        item->stream = obj->stream;
+                        item->next = NULL;
+                        if (!rover) {
+                            rover = item;
+                            self->_streams = rover;
+                        } else {
+                            while (rover->next)
+                            rover = rover->next;
+                            rover->next = item;
+                        }
+                    }
+                }
+                ObjectList *rover = self->_streams;
+                self->_stream = rover->stream;
+                self->_streams = rover->next;
+            }
+        }
     }
+    streamReset(self);
     token = _parseToken(self,streamGetChar(self));
-  }
-  /* wrap up */
-  if (self->_stream) {
-    self->_stream->streamClose();
-    self->_stream = NULL;
-  }
-  clear_operand_stack(self,0);
-  free(self->_operandstack);
-  return 0;
+    while (token) {
+        if (token->type == pdf_operator) {
+            lua_pushstring(L, token->string);
+            free_token(token);
+            lua_rawget(L,2); // operator table
+            if (lua_isfunction(L,-1)) {
+                lua_pushvalue(L,4);
+                lua_pushvalue(L,3);
+                (void)lua_call(L,2,0);
+            } else {
+                lua_pop(L,1); // nil
+            }
+            clear_operand_stack(self,0);
+        } else {
+            push_operand(self, token);
+        }
+        if (!self->_stream) {
+            break;
+        }
+        token = _parseToken(self,streamGetChar(self));
+    }
+    /* wrap up */
+    if (self->_stream) {
+        streamClose(self);
+    }
+    clear_operand_stack(self,0);
+    free(self->_operandstack);
+    return 0;
 }
 
 static int scanner_done(lua_State * L)
 {
-  int c;
-  scannerdata *self = scanner_check(L,1);
-  while ((c=streamGetChar(self))>=0)
-    ;
-  return 0;
+    int c;
+    scannerdata *self = scanner_check(L,1);
+    while ((c=streamGetChar(self))>=0) ;
+    return 0;
 }
 
 // here are the stack popping functions, and their helpers
 
 static void operandstack_backup (scannerdata *self) {
-  int i = self->_nextoperand-1;
-  int balance = 0;
-  int backupstart = 0;
-  int backupstop = self->_operandstack[i]->type;
-  if (backupstop == pdf_stopdict) {
-    backupstart = pdf_startdict;
-  } else if (backupstop == pdf_stoparray) {
-    backupstart = pdf_startarray;
-  } else {
-    return;
-  }
-  for (;i>=0;i--) {
-    if (self->_operandstack[i]->type == backupstop) {
-      balance++;
-    } else if (self->_operandstack[i]->type == backupstart) {
-      balance--;
-    }
-    if (balance==0) {
-      break;
-    }
-  }
-  self->_nextoperand = i+1;
+    int i = self->_nextoperand-1;
+    int balance = 0;
+    int backupstart = 0;
+    int backupstop = self->_operandstack[i]->type;
+    if (backupstop == pdf_stopdict) {
+        backupstart = pdf_startdict;
+    } else if (backupstop == pdf_stoparray) {
+        backupstart = pdf_startarray;
+    } else {
+        return;
+    }
+    for (;i>=0;i--) {
+        if (self->_operandstack[i]->type == backupstop) {
+            balance++;
+        } else if (self->_operandstack[i]->type == backupstart) {
+            balance--;
+        }
+        if (balance==0) {
+            break;
+        }
+    }
+    self->_nextoperand = i+1;
 }
 
 static void push_array (lua_State *L, scannerdata *self)
 {
-  int balance = 1; // nesting tracking
-  int index = 1;  // lua array index
-  Token *token =  self->_operandstack[self->_nextoperand++];
-  lua_newtable(L);
-  while (token) {
-    if (token->type == pdf_stoparray)
-      balance --;
-    if (token->type == pdf_startarray)
-      balance ++;
-    if (!balance) {
-      break;
-    } else {
-      push_token(L,self);
-      lua_rawseti(L,-2, index++);
+    int balance = 1; // nesting tracking
+    int index = 1;   // lua array index
+    Token *token =  self->_operandstack[self->_nextoperand++];
+    lua_newtable(L);
+    while (token) {
+        if (token->type == pdf_stoparray)
+            balance --;
+        if (token->type == pdf_startarray)
+            balance ++;
+        if (!balance) {
+            break;
+        } else {
+            push_token(L,self);
+            lua_rawseti(L,-2, index++);
+        }
+        token =  self->_operandstack[self->_nextoperand++];
     }
-    token =  self->_operandstack[self->_nextoperand++];
-  }
 }
 
 
 static void push_dict (lua_State *L, scannerdata *self)
 {
-  int balance = 1; // nesting tracking
-  int needskey = 1; // toggle between lua value and lua key
-  Token *token =  self->_operandstack[self->_nextoperand++];
-  lua_newtable(L);
-  while (token) {
-    if (token->type == pdf_stopdict)
-      balance --;
-    if (token->type == pdf_startdict)
-      balance ++;
-    if (!balance) {
-      break;
-    } else {
-      if (needskey) {
-	lua_pushlstring(L, token->string, token->value);
-	needskey = 0;
-      } else {
-	push_token(L,self);
-	needskey = 1;
-	lua_rawset(L,-3);
-      }
+    int balance = 1; // nesting tracking
+    int needskey = 1; // toggle between lua value and lua key
+    Token *token =  self->_operandstack[self->_nextoperand++];
+    lua_newtable(L);
+    while (token) {
+        if (token->type == pdf_stopdict)
+            balance --;
+        if (token->type == pdf_startdict)
+            balance ++;
+        if (!balance) {
+            break;
+        } else if (needskey) {
+            lua_pushlstring(L, token->string, token->value);
+            needskey = 0;
+        } else {
+            push_token(L,self);
+            needskey = 1;
+            lua_rawset(L,-3);
+        }
+        token =  self->_operandstack[self->_nextoperand++];
     }
-    token =  self->_operandstack[self->_nextoperand++];
-  }
 }
 
-const char *typenames[pdf_stopdict+1] =
-  { "unknown", "integer", "real", "boolean", "name", "operator",
-    "string", "array", "array", "dict", "dict" };
+const char *typenames[pdf_stopdict+1] = {
+    "unknown", "integer", "real", "boolean", "name", "operator",
+    "string", "array", "array", "dict", "dict"
+};
 
 static void push_token (lua_State *L, scannerdata *self)
 {
-  Token *token =  self->_operandstack[self->_nextoperand-1];
-  lua_createtable(L,2,0);
-  lua_pushstring (L, typenames[token->type]);
-  lua_rawseti(L,-2,1);
-  if (token->type == pdf_string || token->type == pdf_name) {
-    lua_pushlstring(L, token->string, token->value);
-  } else if (token->type == pdf_real || token->type == pdf_integer) {
-    lua_pushnumber(L, token->value); /* integer or float */
-  } else if (token->type == pdf_boolean) {
-    lua_pushboolean(L, (int)token->value);
-  } else if (token->type == pdf_startarray) {
-    push_array(L, self);
-  } else if (token->type == pdf_startdict) {
-    push_dict(L, self);
-  } else {
-    lua_pushnil(L);
-  }
-  lua_rawseti(L,-2, 2);
+    Token *token =  self->_operandstack[self->_nextoperand-1];
+    lua_createtable(L,2,0);
+    lua_pushstring (L, typenames[token->type]);
+    lua_rawseti(L,-2,1);
+    if (token->type == pdf_string || token->type == pdf_name) {
+        lua_pushlstring(L, token->string, token->value);
+    } else if (token->type == pdf_real || token->type == pdf_integer) {
+        lua_pushnumber(L, token->value); /* integer or float */
+    } else if (token->type == pdf_boolean) {
+        lua_pushboolean(L, (int)token->value);
+    } else if (token->type == pdf_startarray) {
+        push_array(L, self);
+    } else if (token->type == pdf_startdict) {
+        push_dict(L, self);
+    } else {
+        lua_pushnil(L);
+    }
+    lua_rawseti(L,-2, 2);
 }
 
 static int scanner_popsingular (lua_State * L, int token_type) {
-  int clear = 0; // how much of the operand stack needs deleting
-  scannerdata *self = scanner_check(L,1);
-  if (self->_nextoperand==0) {
-    return 0;
-  }
-  clear = self->_nextoperand-1;
-  Token *token = self->_operandstack[self->_nextoperand-1];
-  if (token ==NULL || (token->type != token_type )) {
-    return 0;
-  }
-  // the simple cases can be written out directly, but dicts and
-  // arrays are better done via the recursive function
-  if (token_type == pdf_stoparray || token_type == pdf_stopdict) {
-    operandstack_backup(self);
+    int clear = 0; // how much of the operand stack needs deleting
+    scannerdata *self = scanner_check(L,1);
+    if (self->_nextoperand==0) {
+        return 0;
+    }
     clear = self->_nextoperand-1;
-    push_token(L, self);
-    lua_rawgeti(L,-1,2);
-  } else if (token_type == pdf_real || token_type == pdf_integer) {
-    lua_pushnumber(L, token->value); /* integer or float */
-  } else if (token_type == pdf_boolean) {
-    lua_pushboolean(L,(int)token->value);
-  } else if (token_type == pdf_name || token_type == pdf_string) {
-    lua_pushlstring(L, token->string, token->value);
-  } else {
-    return 0;
-  }
-  clear_operand_stack(self,clear);
-  return 1;
+    Token *token = self->_operandstack[self->_nextoperand-1];
+    if (token ==NULL || (token->type != token_type )) {
+        return 0;
+    }
+    // the simple cases can be written out directly, but dicts and
+    // arrays are better done via the recursive function
+    if (token_type == pdf_stoparray || token_type == pdf_stopdict) {
+        operandstack_backup(self);
+        clear = self->_nextoperand-1;
+        push_token(L, self);
+        lua_rawgeti(L,-1,2);
+    } else if (token_type == pdf_real || token_type == pdf_integer) {
+        lua_pushnumber(L, token->value); /* integer or float */
+    } else if (token_type == pdf_boolean) {
+        lua_pushboolean(L,(int)token->value);
+    } else if (token_type == pdf_name || token_type == pdf_string) {
+        lua_pushlstring(L, token->string, token->value);
+    } else {
+        return 0;
+    }
+    clear_operand_stack(self,clear);
+    return 1;
 }
 
 static int scanner_popanything (lua_State * L) {
-  int clear = 0; // how much of the operand stack needs deleting
-  scannerdata *self = scanner_check(L,1);
-  if (self->_nextoperand==0) {
-    return 0;
-  }
-  clear = self->_nextoperand-1;
-  Token *token = self->_operandstack[self->_nextoperand-1];
-  if (token ==NULL) {
-    return 0;
-  }
-  int token_type = token->type;
-  // the simple cases can be written out directly, but dicts and
-  // arrays are better done via the recursive function
-  if (token_type == pdf_stoparray || token_type == pdf_stopdict) {
-    operandstack_backup(self);
+    int clear = 0; // how much of the operand stack needs deleting
+    scannerdata *self = scanner_check(L,1);
+    if (self->_nextoperand==0) {
+        return 0;
+    }
     clear = self->_nextoperand-1;
-    push_token(L, self);
-  } else {
-    push_token(L, self);
-  }
-  clear_operand_stack(self,clear);
-  return 1;
+    Token *token = self->_operandstack[self->_nextoperand-1];
+    if (token ==NULL) {
+        return 0;
+    }
+    int token_type = token->type;
+    // the simple cases can be written out directly, but dicts and
+    // arrays are better done via the recursive function
+    if (token_type == pdf_stoparray || token_type == pdf_stopdict) {
+        operandstack_backup(self);
+        clear = self->_nextoperand-1;
+        push_token(L, self);
+    } else {
+        push_token(L, self);
+    }
+    clear_operand_stack(self,clear);
+    return 1;
 }
 
 
 static int scanner_popnumber(lua_State * L)
 {
-  if(scanner_popsingular(L,pdf_real))
-    return 1;
-  if (scanner_popsingular(L,pdf_integer))
-    return 1;
-  lua_pushnil(L);
+    if(scanner_popsingular(L,pdf_real))
+        return 1;
+    if (scanner_popsingular(L,pdf_integer))
+        return 1;
+    lua_pushnil(L);
   return 1;
 }
 
 static int scanner_popboolean(lua_State * L)
 {
-  if(scanner_popsingular(L,pdf_boolean))
+    if(scanner_popsingular(L,pdf_boolean))
+        return 1;
+    lua_pushnil(L);
     return 1;
-  lua_pushnil(L);
-  return 1;
 }
 
 static int scanner_popstring(lua_State * L)
 {
-  if (scanner_popsingular(L,pdf_string))
+    if (scanner_popsingular(L,pdf_string))
+        return 1;
+    lua_pushnil(L);
     return 1;
-  lua_pushnil(L);
-  return 1;
 }
 
 static int scanner_popname(lua_State * L)
 {
-  if (scanner_popsingular(L,pdf_name))
+    if (scanner_popsingular(L,pdf_name))
+        return 1;
+    lua_pushnil(L);
     return 1;
-  lua_pushnil(L);
-  return 1;
 }
 
 static int scanner_poparray(lua_State * L)
 {
-  if (scanner_popsingular(L,pdf_stoparray))
+    if (scanner_popsingular(L,pdf_stoparray))
+        return 1;
+    lua_pushnil(L);
     return 1;
-  lua_pushnil(L);
-  return 1;
 }
 
 static int scanner_popdictionary(lua_State * L)
 {
-  if (scanner_popsingular(L,pdf_stopdict))
+    if (scanner_popsingular(L,pdf_stopdict))
+        return 1;
+    lua_pushnil(L);
     return 1;
-  lua_pushnil(L);
-  return 1;
 }
 
 static int scanner_popany(lua_State * L)
 {
-  if (scanner_popanything(L))
+    if (scanner_popanything(L))
+        return 1;
+    lua_pushnil(L);
     return 1;
-  lua_pushnil(L);
-  return 1;
 }
 
 static const luaL_Reg scannerlib_meta[] = {
-  {0, 0}
+    {0, 0}
 };
 
 static const struct luaL_Reg scannerlib_m[] = {
@@ -929,10 +1020,9 @@ static const struct luaL_Reg scannerlib_m[] = {
     {"popDict",     scanner_popdictionary},
     {"popBool",     scanner_popboolean},
     {"pop",         scanner_popany},
-    {NULL, NULL}                /* sentinel */
+    {NULL, NULL}    /* sentinel */
 };
 
-
 static const luaL_Reg scannerlib[] = {
     {"scan", scanner_scan},
     {NULL, NULL}
diff --git a/texk/web2c/luatexdir/lua/lstatslib.c b/texk/web2c/luatexdir/lua/lstatslib.c
index 43f33008d..5f3b72262 100644
--- a/texk/web2c/luatexdir/lua/lstatslib.c
+++ b/texk/web2c/luatexdir/lua/lstatslib.c
@@ -147,13 +147,15 @@ static lua_Number get_luatexhashchars(void)
 static const char *get_luatexhashtype(void)
 {
 #ifdef LuajitTeX
-     return (const char *)jithash_hashname;
+     if (jithash_hashname)
+        return (const char *)jithash_hashname;
+     else
+        return "???";
 #else
   return "lua";
 #endif
 }
 
-
 static lua_Number get_pdf_gone(void)
 {
     if (static_pdf != NULL)
@@ -266,8 +268,22 @@ static lua_Number get_development_id(void)
     return (lua_Number) luatex_svn_revision ;
 }
 
+static lua_Number get_dvi_gone(void)
+{
+    if (static_pdf != NULL)
+        return (lua_Number) dvi_get_status_gone(static_pdf);
+    return (lua_Number) 0;
+}
+
+static lua_Number get_dvi_ptr(void)
+{
+    if (static_pdf != NULL)
+        return (lua_Number) dvi_get_status_ptr(static_pdf);
+    return (lua_Number) 0;
+}
 
 /* temp, for backward compat */
+
 static int init_pool_ptr = 0;
 
 static struct statistic stats[] = {
@@ -291,8 +307,9 @@ static struct statistic stats[] = {
 
     {"pdf_gone", 'N', &get_pdf_gone},
     {"pdf_ptr", 'N', &get_pdf_ptr},
-    {"dvi_gone", 'g', &dvi_offset},
-    {"dvi_ptr", 'g', &dvi_ptr},
+    {"dvi_gone", 'g', &get_dvi_gone},
+    {"dvi_ptr", 'g', &get_dvi_ptr},
+
     {"total_pages", 'g', &total_pages},
     {"output_file_name", 'S', (void *) &get_output_file_name},
     {"log_name", 'S', (void *) &getlogname},
@@ -355,9 +372,14 @@ static struct statistic stats[] = {
     {"luabytecodes", 'g', &luabytecode_max},
     {"luabytecode_bytes", 'g', &luabytecode_bytes},
     {"luastate_bytes", 'g', &luastate_bytes},
+
     {"callbacks", 'g', &callback_count},
+    {"indirect_callbacks", 'g', &saved_callback_count}, /* these are file io callbacks */
 
-    {"indirect_callbacks", 'g', &saved_callback_count},
+    {"saved_callbacks", 'g', &saved_callback_count},
+    {"late_callbacks", 'g', &late_callback_count},
+    {"direct_callbacks", 'g', &direct_callback_count},
+    {"function_callbacks", 'g', &function_callback_count},
 
     {"lc_ctype", 'S', (void *) &get_lc_ctype},
     {"lc_collate", 'S', (void *) &get_lc_collate},
diff --git a/texk/web2c/luatexdir/lua/ltexiolib.c b/texk/web2c/luatexdir/lua/ltexiolib.c
index f0fa5d369..5f1786c65 100644
--- a/texk/web2c/luatexdir/lua/ltexiolib.c
+++ b/texk/web2c/luatexdir/lua/ltexiolib.c
@@ -155,10 +155,26 @@ static int texio_setescape(lua_State * L)
     return 0 ;
 }
 
+static int texio_closeinput(lua_State * L)
+{
+    /*
+        printf("before, first %i, index %i, iname %i, inopen %i, pointer %i\n",istart,iindex,iname,in_open,input_ptr);
+    */
+    if (iindex > 0) {
+        end_token_list();
+        end_file_reading();
+        /*
+            printf("after, first %i, index %i, iname %i, inopen %i, pointer %i\n",istart,iindex,iname,in_open,input_ptr);
+        */
+    }
+    return 0 ;
+}
+
 static const struct luaL_Reg texiolib[] = {
     {"write", texio_print},
     {"write_nl", texio_printnl},
     {"setescape", texio_setescape},
+    {"closeinput",texio_closeinput},
     {NULL, NULL}
 };
 
diff --git a/texk/web2c/luatexdir/lua/ltexlib.c b/texk/web2c/luatexdir/lua/ltexlib.c
index 65e55705e..c3e459b22 100644
--- a/texk/web2c/luatexdir/lua/ltexlib.c
+++ b/texk/web2c/luatexdir/lua/ltexlib.c
@@ -35,7 +35,8 @@ typedef struct {
     void *next;
     boolean partial;
     int cattable;
- /* halfword tok; */
+    halfword tok;
+    halfword nod;
 } rope;
 
 typedef struct {
@@ -54,33 +55,64 @@ static int spindle_size  = 0;
 static spindle *spindles = NULL;
 static int spindle_index = 0;
 
-static void luac_store(lua_State * L, int i, int partial, int cattable)
+static int luac_store(lua_State * L, int i, int partial, int cattable)
 {
-    const char *sttemp;
-    char *st;
-    size_t tsize;
+    char *st = NULL;
+    size_t tsize = 0;
     rope *rn = NULL;
-    sttemp = lua_tolstring(L, i, &tsize);
-    st = xmalloc((unsigned) (tsize + 1));
-    memcpy(st, sttemp, (tsize + 1));
-    if (st) {
-        luacstrings++;
-        rn = (rope *) xmalloc(sizeof(rope));
-        rn->text = st;
-        rn->tsize = (unsigned) tsize;
-        rn->partial = partial;
-        rn->cattable = cattable;
-        rn->next = NULL;
-     /* rn->tok = 0; */
-        if (write_spindle.head == NULL) {
-            assert(write_spindle.tail == NULL);
-            write_spindle.head = rn;
+    halfword tok = null;
+    halfword nod = null;
+    int t = lua_type(L, i);
+    if (t == LUA_TNUMBER || t == LUA_TSTRING) {
+        const char *sttemp;
+        sttemp = lua_tolstring(L, i, &tsize);
+        st = xmalloc((unsigned) (tsize + 1));
+        memcpy(st, sttemp, (tsize + 1));
+    } else if (t == LUA_TUSERDATA) {
+        void *p ;
+        p = lua_touserdata(L, i);
+        if (p == NULL) {
+            return 0;
+        } else if (lua_getmetatable(L, i)) {
+            lua_get_metatablelua(luatex_token);
+            if (lua_rawequal(L, -1, -2)) {
+                tok = (halfword) token_info((*((lua_token *)p)).token);
+                lua_pop(L, 2);
+            } else {
+                lua_get_metatablelua(luatex_node);
+                if (lua_rawequal(L, -1, -3)) {
+                    nod = *((halfword *)p);
+                    lua_pop(L, 3);
+                } else {
+                    lua_pop(L, 3);
+                    return 0;
+                }
+            }
         } else {
-            write_spindle.tail->next = rn;
+            return 0;
         }
-        write_spindle.tail = rn;
-        write_spindle.complete = 0;
+    } else {
+        return 0;
+    }
+    /* common */
+    luacstrings++;
+    rn = (rope *) xmalloc(sizeof(rope));
+    rn->text = st;
+    rn->tsize = (unsigned) tsize;
+    rn->tok = tok;
+    rn->nod = nod;
+    rn->next = NULL;
+    rn->partial = partial;
+    rn->cattable = cattable;
+    /* add */
+    if (write_spindle.head == NULL) {
+        write_spindle.head = rn;
+    } else {
+        write_spindle.tail->next = rn;
     }
+    write_spindle.tail = rn;
+    write_spindle.complete = 0;
+    return 1;
 }
 
 static int do_luacprint(lua_State * L, int partial, int deftable)
@@ -93,47 +125,33 @@ static int do_luacprint(lua_State * L, int partial, int deftable)
             cattable = lua_tointeger(L, 1);
             startstrings = 2;
             if (cattable != -1 && cattable != -2 && !valid_catcode_table(cattable)) {
-       cattable = DEFAULT_CAT_TABLE;
-     }
+                cattable = DEFAULT_CAT_TABLE;
+            }
         }
     }
     if (lua_type(L, startstrings) == LUA_TTABLE) {
         int i;
         for (i = 1;; i++) {
             lua_rawgeti(L, startstrings, i);
-            if (lua_isstring(L,-1)) { /* or number */
-                luac_store(L, -1, partial, cattable);
+            if (luac_store(L, -1, partial, cattable)) {
                 lua_pop(L, 1);
             } else {
+                lua_pop(L, 1);
                 break;
             }
         }
     } else {
         int i;
         for (i = startstrings; i <= n; i++) {
-            if (!lua_isstring(L,i)) { /* or number */
-                luaL_error(L, "no string to print");
-            }
             luac_store(L, i, partial, cattable);
         }
-        /* hh: We could use this but it makes not much different, apart from allocating more ropes so less
-           memory. To be looked into: lua 5.2 buffer mechanism as now we still hash the concatination. This
-           test was part of the why-eis-luajit-so-slow on crited experiments. */
-        /*
-        if (startstrings == n) {
-            luac_store(L, n, partial, cattable);
-        } else {
-            lua_concat(L,n-startstrings+1);
-            luac_store(L, startstrings, partial, cattable);
-        }
-        */
     }
     return 0;
 }
 
-/*
+/* the next one writes a raw token (number) */
 
-// some first experiments .. somewhat tricky at the other end
+/*
 
 int luatwrite(lua_State * L)
 {
@@ -148,6 +166,7 @@ int luatwrite(lua_State * L)
         rn->cattable = DEFAULT_CAT_TABLE;
         rn->next = NULL;
         rn->tok = 0;
+        rn->nod = 0;
         if (write_spindle.head == NULL) {
             write_spindle.head = rn;
         } else {
@@ -165,6 +184,7 @@ int luatwrite(lua_State * L)
                 r->cattable = DEFAULT_CAT_TABLE;
                 r->next = NULL;
                 r->tok = 0;
+                r->nod = 0;
                 rn->next = r;
                 rn = r;
                 write_spindle.tail = rn;
@@ -179,21 +199,79 @@ int luatwrite(lua_State * L)
 
 */
 
+/* the next one writes a raw node (number) */
+
+/*
+
+int luanwrite(lua_State * L)
+{
+    int top = lua_gettop(L);
+    if (top>0) {
+        rope *rn = xmalloc(sizeof(rope)); // overkill
+        int i = 1 ;
+        luacstrings++; // should be luactokens
+        rn->text = NULL;
+        rn->tsize = 0;
+        rn->partial = 0;
+        rn->cattable = DEFAULT_CAT_TABLE;
+        rn->next = NULL;
+        rn->tok = 0;
+        rn->nod = 0;
+        if (write_spindle.head == NULL) {
+            write_spindle.head = rn;
+        } else {
+            write_spindle.tail->next = rn;
+        }
+        write_spindle.tail = rn;
+        write_spindle.complete = 0;
+        while (1) {
+            rn->nod = lua_tointeger(L,i);
+            if (i<top) {
+                rope *r = xmalloc(sizeof(rope)); // overkill
+                r->text = NULL;
+                r->tsize = 0;
+                r->partial = 0;
+                r->cattable = DEFAULT_CAT_TABLE;
+                r->next = NULL;
+                r->tok = 0;
+                r->nod = 0;
+                rn->next = r;
+                rn = r;
+                write_spindle.tail = rn;
+                i++;
+            } else {
+                break;
+            }
+        }
+    }
+    return 0;
+}
+
+*/
+
+/* lua.write */
+
 static int luacwrite(lua_State * L)
 {
     return do_luacprint(L, FULL_LINE, NO_CAT_TABLE);
 }
 
+/* lua.print */
+
 static int luacprint(lua_State * L)
 {
     return do_luacprint(L, FULL_LINE, DEFAULT_CAT_TABLE);
 }
 
+/* lua.sprint */
+
 static int luacsprint(lua_State * L)
 {
     return do_luacprint(L, PARTIAL_LINE, DEFAULT_CAT_TABLE);
 }
 
+/* lua.cprint */
+
 static int luaccprint(lua_State * L)
 {
     /* so a negative value is a specific catcode with offset 1 */
@@ -207,10 +285,10 @@ static int luaccprint(lua_State * L)
         int i;
         for (i = 1;; i++) {
             lua_rawgeti(L, 2, i);
-            if (lua_isstring(L,-1)) { /* or number */
-                luac_store(L, -1, PARTIAL_LINE, cattable);
+            if (luac_store(L, -1, PARTIAL_LINE, cattable)) {
                 lua_pop(L, 1);
             } else {
+                lua_pop(L, 1);
                 break;
             }
         }
@@ -218,15 +296,14 @@ static int luaccprint(lua_State * L)
         int i;
         int n = lua_gettop(L);
         for (i = 2; i <= n; i++) {
-            if (!lua_isstring(L,i)) { /* or number */
-                luaL_error(L, "no string to print");
-            }
             luac_store(L, i, PARTIAL_LINE, cattable);
         }
     }
     return 0;
 }
 
+/* lua.tprint */
+
 static int luactprint(lua_State * L)
 {
     int i, j;
@@ -238,7 +315,7 @@ static int luactprint(lua_State * L)
         if (lua_type(L, i) != LUA_TTABLE) {
             luaL_error(L, "no string to print");
         }
-        lua_pushvalue(L, i);    /* push the table */
+        lua_pushvalue(L, i); /* push the table */
         lua_pushinteger(L, 1);
         lua_gettable(L, -2);
         if (lua_type(L, -1) == LUA_TNUMBER) {
@@ -252,15 +329,14 @@ static int luactprint(lua_State * L)
         for (j = startstrings;; j++) {
             lua_pushinteger(L, j);
             lua_gettable(L, -2);
-            if (lua_isstring(L, -1)) { /* or number */
-                luac_store(L, -1, PARTIAL_LINE, cattable);
+            if (luac_store(L, -1, PARTIAL_LINE, cattable)) {
                 lua_pop(L, 1);
             } else {
                 lua_pop(L, 1);
                 break;
             }
         }
-        lua_pop(L, 1);          /* pop the table */
+        lua_pop(L, 1); /* pop the table */
     }
     return 0;
 }
@@ -280,7 +356,7 @@ int luacstring_final_line(void)
     return (read_spindle.tail->next == NULL);
 }
 
-int luacstring_input(void)
+int luacstring_input(halfword *n)
 {
     rope *t = read_spindle.head;
     int ret = 1 ;
@@ -308,12 +384,15 @@ int luacstring_input(void)
         }
         free(t->text);
         t->text = NULL;
-    /*
     } else if (t->tok > 0) {
-        ret = - t->tok;
-    */
-    }
-    if (read_spindle.tail != NULL) {    /* not a one-liner */
+        *n = t->tok;
+        ret = 2;
+    } else if (t->nod > 0) {
+        *n = t->nod;
+        ret = 3;
+    }
+    if (read_spindle.tail != NULL) {
+        /* not a one-liner */
         free(read_spindle.tail);
     }
     read_spindle.tail = t;
@@ -322,11 +401,13 @@ int luacstring_input(void)
 }
 
 /* open for reading, and make a new one for writing */
+
 void luacstring_start(int n)
 {
-    (void) n;                   /* for -W */
+    (void) n; /* for -W */
     spindle_index++;
-    if (spindle_size == spindle_index) {        /* add a new one */
+    if (spindle_size == spindle_index) {
+        /* add a new one */
         spindles = xrealloc(spindles, (unsigned) (sizeof(spindle) * (unsigned) (spindle_size + 1)));
         spindles[spindle_index].head = NULL;
         spindles[spindle_index].tail = NULL;
@@ -340,7 +421,7 @@ void luacstring_start(int n)
 void luacstring_close(int n)
 {
     rope *next, *t;
-    (void) n;                   /* for -W */
+    (void) n; /* for -W */
     next = read_spindle.head;
     while (next != NULL) {
         if (next->text != NULL)
@@ -378,15 +459,15 @@ void luacstring_close(int n)
 
 static const char *scan_integer_part(lua_State * L, const char *ss, int *ret, int *radix_ret)
 {
-    boolean negative = false;   /* should the answer be negated? */
-    int m = 214748364;          /* |$2^{31}$ / radix|, the threshold of danger */
-    int d;                      /* the digit just scanned */
-    boolean vacuous = true;     /* have no digits appeared? */
-    boolean OK_so_far = true;   /* has an error message been issued? */
-    int radix1 = 10;            /* the radix of the integer */
-    int c = 0;                  /* the current character */
-    const char *s;              /* where we stopped in the string |ss| */
-    integer val = 0;            /* return value */
+    boolean negative = false; /* should the answer be negated? */
+    int m = 214748364;        /* |$2^{31}$ / radix|, the threshold of danger */
+    int d;                    /* the digit just scanned */
+    boolean vacuous = true;   /* have no digits appeared? */
+    boolean OK_so_far = true; /* has an error message been issued? */
+    int radix1 = 10;          /* the radix of the integer */
+    int c = 0;                /* the current character */
+    const char *s;            /* where we stopped in the string |ss| */
+    integer val = 0;          /* return value */
     s = ss;
     do {
         do {
@@ -448,9 +529,9 @@ static const char *scan_integer_part(lua_State * L, const char *ss, int *ret, in
 
 #define set_conversion(A,B) do { num=(A); denom=(B); } while(0)
 
+/* sets |cur_val| to a dimension */
 
 static const char *scan_dimen_part(lua_State * L, const char *ss, int *ret)
-/* sets |cur_val| to a dimension */
 {
     boolean negative = false;   /* should the answer be negated? */
     int f = 0;                  /* numerator of a fraction whose denominator is $2^{16}$ */
@@ -460,7 +541,7 @@ static const char *scan_dimen_part(lua_State * L, const char *ss, int *ret)
     int save_cur_val;           /* temporary storage of |cur_val| */
     int c;                      /* the current character */
     const char *s = ss;         /* where we are in the string */
-    int radix1 = 0;              /* the current radix */
+    int radix1 = 0;             /* the current radix */
     int rdig[18];               /* to save the |dig[]| array */
     int saved_tex_remainder;    /* to save |tex_remainder|  */
     int saved_arith_error;      /* to save |arith_error|  */
@@ -468,9 +549,9 @@ static const char *scan_dimen_part(lua_State * L, const char *ss, int *ret)
     saved_tex_remainder = tex_remainder;
     saved_arith_error = arith_error;
     saved_cur_val = cur_val;
-    /* Get the next non-blank non-sign... */
+    /* get the next non-blank non-sign */
     do {
-        /* Get the next non-blank non-call token */
+        /* get the next non-blank non-call token */
         do {
             c = *s++;
         } while (c && c == ' ');
@@ -493,16 +574,18 @@ static const char *scan_dimen_part(lua_State * L, const char *ss, int *ret)
     if (c == ',')
         c = '.';
     if ((radix1 == 10) && (c == '.')) {
-        /* Scan decimal fraction */
+        /* scan decimal fraction */
         for (k = 0; k < 18; k++)
             rdig[k] = dig[k];
         k = 0;
-        s++;                    /* get rid of the '.' */
+        s++;
+        /* get rid of the '.' */
         while (1) {
             c = *s++;
             if ((c > '0' + 9) || (c < '0'))
                 break;
-            if (k < 17) {       /* digits for |k>=17| cannot affect the result */
+            if (k < 17) {
+                /* digits for |k>=17| cannot affect the result */
                 dig[k++] = c - '0';
             }
         }
@@ -516,8 +599,10 @@ static const char *scan_dimen_part(lua_State * L, const char *ss, int *ret)
         negative = !negative;
         cur_val = -cur_val;
     }
-    /* Scan for (u)units that are internal dimensions;
-       |goto attach_sign| with |cur_val| set if found */
+    /*
+        Scan for (u)units that are internal dimensions; |goto attach_sign| with
+        |cur_val| set if found.
+    */
     save_cur_val = cur_val;
     /* Get the next non-blank non-call... */
     do {
@@ -570,8 +655,10 @@ static const char *scan_dimen_part(lua_State * L, const char *ss, int *ret)
         s += 2;
         goto ATTACH_FRACTION;   /* the easy case */
     }
-    /* Scan for (a)all other units and adjust |cur_val| and |f| accordingly;
-       |goto done| in the case of scaled points */
+    /*
+        Scan for (a)all other units and adjust |cur_val| and |f| accordingly; |goto done|
+        in the case of scaled points
+    */
     if (strncmp(s, "mm", 2) == 0) {
         s += 2;
         set_conversion(7227, 2540);
@@ -715,7 +802,7 @@ static int get_item_index(lua_State * L, int i, int base)
             s = lua_tolstring(L, i, &kk);
             cur_cs1 = string_lookup(s, kk);
             if (cur_cs1 == undefined_control_sequence || cur_cs1 == undefined_cs_cmd)
-                k = -1;             /* guarandeed invalid */
+                k = -1; /* guarandeed invalid */
             else
                 k = (equiv(cur_cs1) - base);
             break;
@@ -724,7 +811,7 @@ static int get_item_index(lua_State * L, int i, int base)
             break;
         default:
             luaL_error(L, "argument must be a string or a number");
-            k = -1;                 /* not a valid index */
+            k = -1; /* not a valid index */
     }
     return k;
 }
@@ -1311,7 +1398,7 @@ static int vsetbox(lua_State * L, int is_global)
     } else if (t == LUA_TNIL) {
         j = null;
     } else {
-        j = nodelist_from_lua(L);
+        j = nodelist_from_lua(L,-1);
         if (j != null && type(j) != hlist_node && type(j) != vlist_node) {
             luaL_error(L, "setbox: incompatible node type (%s)\n", get_node_name(type(j), subtype(j)));
             return 0;
@@ -2112,6 +2199,7 @@ static int gettex(lua_State * L)
             case assign_int_cmd:
             case assign_attr_cmd:
             case assign_dir_cmd:
+            case assign_direction_cmd:
             case assign_dimen_cmd:
             case set_aux_cmd:
             case set_prev_graf_cmd:
@@ -2141,8 +2229,9 @@ static int gettex(lua_State * L)
 static int getlist(lua_State * L)
 {
     const char *str;
-    if (lua_type(L,2) == LUA_TSTRING) {
-        str = lua_tostring(L, 2);
+    int top = lua_gettop(L);
+    if (lua_type(L,top) == LUA_TSTRING) {
+        str = lua_tostring(L, top);
         if (lua_key_eq(str,page_ins_head)) {
             if (vlink(page_ins_head) == page_ins_head)
                 lua_pushinteger(L, null);
@@ -2203,17 +2292,18 @@ static int getlist(lua_State * L)
 
 static int setlist(lua_State * L)
 {
-    if (lua_type(L,2) == LUA_TSTRING) {
-        const char *str = lua_tostring(L, 2);
+    int top = (lua_type(L,1) == LUA_TTABLE) ? 2 : 1 ;
+    if (lua_type(L,top) == LUA_TSTRING) {
+        const char *str = lua_tostring(L, top);
         if (lua_key_eq(str,best_size)) {
-            best_size = (int) lua_tointeger(L, 3);
+            best_size = (int) lua_tointeger(L, top+1);
         } else if (lua_key_eq(str,least_page_cost)) {
-            least_page_cost = (int) lua_tointeger(L, 3);
+            least_page_cost = (int) lua_tointeger(L, top+1);
         } else {
             halfword *n_ptr;
             halfword n = 0;
-            if (!lua_isnil(L, 3)) {
-                n_ptr = check_isnode(L, 3);
+            if (!lua_isnil(L, top+1)) {
+                n_ptr = check_isnode(L, top+1);
                 n = *n_ptr;
             }
             if (lua_key_eq(str,page_ins_head)) {
@@ -2359,24 +2449,32 @@ static void init_nest_lib(lua_State * L)
 static int getnest(lua_State * L)
 {
     list_state_record **nestitem;
-    int t = lua_type(L, 2);
-    if (t == LUA_TNUMBER) {
-        int ptr = lua_tointeger(L, 2);
-        if (ptr >= 0 && ptr <= nest_ptr) {
-            nestitem = lua_newuserdata(L, sizeof(list_state_record *));
-            *nestitem = &nest[ptr];
-            luaL_getmetatable(L, NEST_METATABLE);
-            lua_setmetatable(L, -2);
-        } else {
-            lua_pushnil(L);
-        }
-    } else if (t == LUA_TSTRING) {
-        const char *s = lua_tostring(L, 2);
-        if (lua_key_eq(s,ptr)) {
-            lua_pushinteger(L, nest_ptr);
-        } else {
-            lua_pushnil(L);
+    int n = lua_gettop(L);
+    int p = -1 ;
+    if (n == 0) {
+        p = nest_ptr;
+    } else {
+        int t = lua_type(L, n);
+        if (t == LUA_TNUMBER) {
+            int ptr = lua_tointeger(L, n);
+            if (ptr >= 0 && ptr <= nest_ptr) {
+                p = ptr;
+            }
+        } else if (t == LUA_TSTRING) {
+            const char *s = lua_tostring(L, n);
+            if (lua_key_eq(s,top)) {
+                p = nest_ptr;
+            } else if (lua_key_eq(s,ptr)) {
+                lua_pushinteger(L, nest_ptr);
+                return 1;
+            }
         }
+    }
+    if (p > -1) {
+        nestitem = lua_newuserdata(L, sizeof(list_state_record *));
+        *nestitem = &nest[p];
+        luaL_getmetatable(L, NEST_METATABLE);
+        lua_setmetatable(L, -2);
     } else {
         lua_pushnil(L);
     }
@@ -2386,7 +2484,7 @@ static int getnest(lua_State * L)
 static int setnest(lua_State * L)
 {
     luaL_error(L, "You can't modify the semantic nest array directly");
-    return 2;
+    return 0;
 }
 
 static int do_integer_error(double m)
@@ -2859,7 +2957,7 @@ static int tex_run_linebreak(lua_State * L)
     }
     lua_key_rawgeti(pardir);
     if (lua_type(L, -1) == LUA_TSTRING) {
-        paragraph_dir = nodelib_getdir(L, -1, 1);
+        paragraph_dir = nodelib_getdir(L, -1);
     }
     lua_pop(L, 1);
 
@@ -3117,8 +3215,21 @@ static int tex_save_box_resource(lua_State * L)
     int type = 0;
     int margin = pdf_xform_margin;
     boolean immediate = false;
+    /* more or less same as scanner variant */
+    if (lua_type(L,1) == LUA_TNUMBER) {
+        halfword boxnumber = lua_tointeger(L,1);
+        boxdata = box(boxnumber);
+        box(boxnumber) = null;
+    } else {
+        boxdata = nodelist_from_lua(L,1);
+        if (type(boxdata) != hlist_node && type(boxdata) != vlist_node) {
+            normal_error("pdf backend", "xforms can only be used with a box or [h|v]list");
+        }
+    }
+    if (boxdata == null) {
+        normal_error("pdf backend", "xforms cannot be used with a void box or empty [h|v]list");
+    }
     /* box attributes resources */
-    halfword boxnumber = lua_tointeger(L,1);
     if (lua_type(L,2) == LUA_TSTRING) {
         lua_pushvalue(L, 2);
         attributes = luaL_ref(L, LUA_REGISTRYINDEX);
@@ -3136,10 +3247,6 @@ static int tex_save_box_resource(lua_State * L)
     if (lua_type(L,6) == LUA_TNUMBER) {
         margin = lua_tointeger(L, 6);
     }
-    /* more or less same as scanner variant */
-    boxdata = box(boxnumber);
-    if (boxdata == null)
-        normal_error("pdf backend", "xforms cannot be used with a void box");
     static_pdf->xform_count++;
     index = pdf_create_obj(static_pdf, obj_type_xform, static_pdf->xform_count);
     set_obj_data_ptr(static_pdf, index, pdf_get_mem(static_pdf, pdfmem_xform_size));
@@ -3153,7 +3260,6 @@ static int tex_save_box_resource(lua_State * L)
     set_obj_xform_depth(static_pdf, index, depth(boxdata));
     set_obj_xform_type(static_pdf, index, type);
     set_obj_xform_margin(static_pdf, index, margin);
-    box(boxnumber) = null;
     last_saved_box_index = index;
     lua_pushinteger(L, index);
     if (immediate) {
@@ -3229,12 +3335,35 @@ static int tex_get_box_resource_dimensions(lua_State * L)
     return 4;
 }
 
+static int tex_get_box_resource_box(lua_State * L)
+{
+    /* no checking yet as this might go */
+    halfword b;
+    int index = lua_tointeger(L,1);
+    check_obj_type(static_pdf, obj_type_xform, index);
+    b = obj_xform_box(static_pdf, index);
+    nodelist_to_lua(L, b);
+    return 1;
+}
+
 static int tex_build_page(lua_State * L)
 {
     build_page();
     return 0;
 }
 
+static int lua_get_page_state(lua_State * L)
+{
+    lua_pushinteger(L,page_contents);
+    return 1;
+}
+
+static int lua_get_local_level(lua_State * L)
+{
+    lua_pushinteger(L,current_local_level());
+    return 1;
+}
+
 /* synctex */
 
 static int lua_set_synctex_mode(lua_State * L)
@@ -3296,6 +3425,82 @@ static int lua_set_synctex_no_files(lua_State * L)
     return 0;
 }
 
+/*
+    This is experimental and might change. In version 10 we hope to have the
+    final version available. It actually took quite a bit of time to understand
+    the implications of mixing lua prints in here. The current variant is (so far)
+    the most robust (wrt crashes and side effects).
+*/
+
+#define mode mode_par
+
+/*
+    When we add save levels then we can get crashes when one flushed bad
+    groups due to out of order flushing. So we play safe! But still we can
+    have issues so best make sure you're in hmode.
+*/
+
+static int forcehmode(lua_State * L)
+{
+    if (abs(mode) == vmode) {
+        if (lua_type(L,1) == LUA_TBOOLEAN) {
+            new_graf(lua_toboolean(L,1));
+        } else {
+            new_graf(1);
+        }
+    }
+    return 0;
+}
+
+static int runtoks(lua_State * L)
+{
+    if (lua_type(L,1) == LUA_TFUNCTION) {
+        int old_mode = mode;
+        int ref;
+        pointer r = get_avail();
+        pointer t = get_avail();
+        token_info(r) = token_val(extension_cmd,end_local_code);
+        lua_pushvalue(L, 1);
+        ref = luaL_ref(L,LUA_REGISTRYINDEX);
+        token_info(t) = token_val(lua_local_call_cmd, ref);
+        begin_token_list(r,inserted);
+        begin_token_list(t,inserted);
+        if (luacstrings > 0) {
+            lua_string_start();
+        }
+        if (tracing_nesting_par > 2) {
+            local_control_message("entering token scanner via function");
+        }
+        mode = -hmode;
+        local_control();
+        mode = old_mode;
+        luaL_unref(L,LUA_REGISTRYINDEX,ref);
+    } else {
+        int k = get_item_index(L, lua_gettop(L), toks_base);
+        halfword t = toks(k);
+        check_index_range(k, "gettoks");
+        if (t != null) {
+            int old_mode = mode;
+            pointer r = get_avail();
+            token_info(r) = token_val(extension_cmd,end_local_code);
+            begin_token_list(r,inserted);
+            /* new_save_level(semi_simple_group); */
+            begin_token_list(t,local_text);
+            if (luacstrings > 0) {
+                lua_string_start();
+            }
+            if (tracing_nesting_par > 2) {
+                local_control_message("entering token scanner via register");
+            }
+            mode = -hmode;
+            local_control();
+            mode = old_mode;
+            /* unsave(); */
+        }
+    }
+    return 0;
+}
+
 /* till here */
 
 void init_tex_table(lua_State * L)
@@ -3315,10 +3520,14 @@ static const struct luaL_Reg texlib[] = {
     { "finish", tex_run_end },    /* may be needed  */
     { "write", luacwrite },
     { "print", luacprint },
+    { "sprint", luacsprint },
     { "tprint", luactprint },
     { "cprint", luaccprint },
+    /*
+    { "twrite", luatwrite },
+    { "nwrite", luanwrite },
+    */
     { "error", texerror },
-    { "sprint", luacsprint },
     { "set", settex },
     { "get", gettex },
     { "isdimen", isdimen },
@@ -3327,11 +3536,13 @@ static const struct luaL_Reg texlib[] = {
     { "isskip", isskip },
     { "setskip", setskip },
     { "getskip", getskip },
+    { "isglue", isskip },
     { "setglue", setglue },
     { "getglue", getglue },
     { "ismuskip", ismuskip },
     { "setmuskip", setmuskip },
     { "getmuskip", getmuskip },
+    { "ismuglue", ismuskip },
     { "setmuglue", setmuglue },
     { "getmuglue", getmuglue },
     { "isattribute", isattribute },
@@ -3350,7 +3561,7 @@ static const struct luaL_Reg texlib[] = {
     { "splitbox", splitbox },
     { "setlist", setlist },
     { "getlist", getlist },
-    { "setnest", setnest },
+    { "setnest", setnest }, /* only a message */
     { "getnest", getnest },
     { "setcatcode", setcatcode },
     { "getcatcode", getcatcode },
@@ -3395,8 +3606,12 @@ static const struct luaL_Reg texlib[] = {
     { "saveboxresource", tex_save_box_resource },
     { "useboxresource", tex_use_box_resource },
     { "getboxresourcedimensions", tex_get_box_resource_dimensions },
+    /* might go, used when sanitizing backend */
+    { "getboxresourcebox", tex_get_box_resource_box },
     /* just for testing: it will probably stay but maybe with options */
     { "triggerbuildpage", tex_build_page },
+    { "getpagestate", lua_get_page_state },
+    { "getlocallevel", lua_get_local_level },
     /* not the best place but better than in node */
     { "set_synctex_mode", lua_set_synctex_mode },
     { "get_synctex_mode", lua_get_synctex_mode },
@@ -3407,6 +3622,9 @@ static const struct luaL_Reg texlib[] = {
     { "force_synctex_line", lua_force_synctex_line },
     { "set_synctex_line", lua_set_synctex_line },
     { "get_synctex_line", lua_get_synctex_line },
+    /* test */
+    { "runtoks", runtoks },
+    { "forcehmode", forcehmode },
     /* sentinel */
     { NULL, NULL }
 };
@@ -3451,6 +3669,8 @@ int luaopen_tex(lua_State * L)
     spindles[0].tail = NULL;
     spindle_size = 1;
     /* a somewhat odd place for this assert, maybe */
-    assert(command_names[data_cmd].command_offset == data_cmd);
+    if (command_names[data_cmd].id != data_cmd) {
+        fatal_error("mismatch between tex and lua command name tables");
+    };
     return 1;
 }
diff --git a/texk/web2c/luatexdir/lua/luatex-api.h b/texk/web2c/luatexdir/lua/luatex-api.h
index 36b2f5979..399dccb04 100644
--- a/texk/web2c/luatexdir/lua/luatex-api.h
+++ b/texk/web2c/luatexdir/lua/luatex-api.h
@@ -35,8 +35,10 @@ extern int draft_mode_value;
 /* get_o_mode translates from output_mode to output_mode_used */
 /* fix_o_mode freezes output_mode as soon as anything goes through the backend */
 
+/*
 extern output_mode get_o_mode(void);
 extern void fix_o_mode(void);
+*/
 
 /* till here */
 
@@ -66,8 +68,7 @@ typedef struct LoadS {
 
 extern lua_State *Luas;
 
-extern void make_table(lua_State * L, const char *tab, const char *mttab, const char *getfunc,
-                       const char *setfunc);
+extern void make_table(lua_State * L, const char *tab, const char *mttab, const char *getfunc, const char *setfunc);
 
 extern int luac_main(int argc, char *argv[]);
 
@@ -76,6 +77,8 @@ extern int luaopen_pdf(lua_State * L);
 extern int luaopen_texio(lua_State * L);
 extern int luaopen_lang(lua_State * L);
 
+extern int luapdfprint(lua_State * L);
+
 #  define LUA_TEXFILEHANDLE "TEXFILE*"
 
 extern lua_State *luatex_error(lua_State * L, int fatal);
@@ -85,6 +88,7 @@ extern int luaopen_zip(lua_State * L);
 extern int luaopen_lfs(lua_State * L);
 extern int luaopen_lpeg(lua_State * L);
 extern int luaopen_md5(lua_State * L);
+extern int luaopen_sha2(lua_State * L);
 
 #ifndef LuajitTeX
  extern int luaopen_ffi(lua_State * L);
@@ -101,14 +105,13 @@ extern void luatex_socketlua_open(lua_State * L);
 
 extern int luaopen_img(lua_State * L);
 extern int l_new_image(lua_State * L);
-extern int luaopen_epdf(lua_State * L);
+extern int luaopen_pdfe(lua_State * L);
 extern int luaopen_pdfscanner(lua_State * L);
 extern int luaopen_mplib(lua_State * L);
 extern int luaopen_fio(lua_State * L);
 
 extern void open_oslibext(lua_State * L);
 extern void open_strlibext(lua_State * L);
-extern void open_lfslibext(lua_State * L);
 
 extern void initfilecallbackids(int max);
 extern void setinputfilecallbackid(int n, int i);
@@ -118,6 +121,8 @@ extern int getreadfilecallbackid(int n);
 
 extern void lua_initialize(int ac, char **av);
 
+extern void luacall_vf(int p, int f, int c);
+
 extern int luaopen_kpse(lua_State * L);
 
 extern int luaopen_callback(lua_State * L);
@@ -138,12 +143,12 @@ extern void tokenlist_to_luastring(lua_State * L, int p);
 extern int tokenlist_from_lua(lua_State * L);
 
 extern void lua_nodelib_push(lua_State * L);
-extern int nodelib_getdir(lua_State * L, int n, int absolute_only);
+extern int nodelib_getdir(lua_State * L, int n);
 extern int nodelib_getlist(lua_State * L, int n);
 
 extern int luaopen_node(lua_State * L);
 extern void nodelist_to_lua(lua_State * L, int n);
-extern int nodelist_from_lua(lua_State * L);
+extern int nodelist_from_lua(lua_State * L, int n);
 
 extern int dimen_to_number(lua_State * L, const char *s);
 
@@ -158,8 +163,6 @@ extern const char *lc_ctype;
 extern const char *lc_collate;
 extern const char *lc_numeric;
 
-
-
 #ifdef LuajitTeX
 extern int luajiton;
 extern char *jithash_hashname ;
@@ -177,9 +180,9 @@ extern void unhide_lua_value(lua_State * lua, const char *name, const char *item
 extern int hide_lua_value(lua_State * lua, const char *name, const char *item);
 
 typedef struct command_item_ {
-    const char *cmd_name;
-    int command_offset;
-    const char **commands;
+    int id;
+    const char *name;
+    int lua;
 } command_item;
 
 extern command_item command_names[];
@@ -193,6 +196,9 @@ extern int luastate_bytes;
 
 extern int callback_count;
 extern int saved_callback_count;
+extern int direct_callback_count;
+extern int late_callback_count;
+extern int function_callback_count;
 
 extern const char *luatex_banner;
 extern const char *engine_name;
@@ -256,7 +262,13 @@ extern char **environ;
 }
 #endif
 
+typedef struct lua_token {
+    int token;
+    int origin;
+} lua_token;
+
 extern int luatwrite(lua_State * L);
+extern int luanwrite(lua_State * L);
 
 /*
     Same as in lnodelib.c, but with prefix G_ for now.
@@ -342,22 +354,58 @@ preassign these at startup time. */
 #define LOCAL_PAR_SIZE        5
 #define MATH_STYLE_NAME_SIZE  8
 #define APPEND_LIST_SIZE      5
-#define DIR_PAR_SIZE          8
-#define DIR_TEXT_SIZE         8
+#define DIR_PAR_SIZE          4
+#define DIR_TEXT_SIZE         4
 
 extern int l_pack_type_index       [PACK_TYPE_SIZE];
 extern int l_group_code_index      [GROUP_CODE_SIZE];
 extern int l_local_par_index       [LOCAL_PAR_SIZE];
 extern int l_math_style_name_index [MATH_STYLE_NAME_SIZE];
 extern int l_dir_par_index         [DIR_PAR_SIZE];
-extern int l_dir_text_index        [DIR_TEXT_SIZE];
+extern int l_dir_text_index_normal [DIR_TEXT_SIZE];
+extern int l_dir_text_index_cancel [DIR_TEXT_SIZE];
 
 #define lua_push_pack_type(L,pack_type)        lua_rawgeti(L, LUA_REGISTRYINDEX, l_pack_type_index[pack_type] );
 #define lua_push_group_code(L,group_code)      lua_rawgeti(L, LUA_REGISTRYINDEX, l_group_code_index[group_code]);
 #define lua_push_local_par_mode(L,par_mode)    lua_rawgeti(L, LUA_REGISTRYINDEX, l_local_par_index[par_mode]);
 #define lua_push_math_style_name(L,style_name) lua_rawgeti(L, LUA_REGISTRYINDEX, l_math_style_name_index[style_name]);
-#define lua_push_dir_par(L,dir)                lua_rawgeti(L, LUA_REGISTRYINDEX, l_dir_par_index[dir+dir_swap])
-#define lua_push_dir_text(L,dir)               lua_rawgeti(L, LUA_REGISTRYINDEX, l_dir_text_index[dir+dir_swap])
+
+#define lua_push_direction(L,direction) \
+    if (direction < 0) { \
+        lua_pushnil(L); \
+    } else { \
+        lua_pushinteger(L,direction); \
+    }
+
+#define lua_push_dir_par(L,dir) \
+    if (dir < 0) { \
+        lua_pushnil(L); \
+    } else { \
+        lua_rawgeti(L, LUA_REGISTRYINDEX, l_dir_par_index[dir]); \
+    }
+
+#define lua_push_dir_text_normal(L,dir) \
+    if (dir < 0) { \
+        lua_pushnil(L); \
+    } else { \
+        lua_rawgeti(L, LUA_REGISTRYINDEX, l_dir_text_index_normal[dir]); \
+    }
+
+#define lua_push_dir_text_cancel(L,dir) \
+    if (dir < 0) { \
+        lua_pushnil(L); \
+    } else { \
+        lua_rawgeti(L, LUA_REGISTRYINDEX, l_dir_text_index_cancel[dir]); \
+    }
+
+#define lua_push_dir_text(L,dir,sub) \
+    if (dir < 0) { \
+        lua_pushnil(L); \
+    } else if (sub) { \
+        lua_rawgeti(L, LUA_REGISTRYINDEX, l_dir_text_index_cancel[dir]); \
+    } else { \
+        lua_rawgeti(L, LUA_REGISTRYINDEX, l_dir_text_index_normal[dir]); \
+    }
 
 #define lua_push_string_by_index(L,index)      lua_rawgeti(L, LUA_REGISTRYINDEX, index)
 #define lua_push_string_by_name(L,index)       lua_rawgeti(L, LUA_REGISTRYINDEX, lua_key_index(index))
@@ -414,21 +462,17 @@ l_math_style_name_index[cramped_script_script_style] = lua_key_index(crampedscri
 l_dir_par_index[dir_TLT]   = lua_key_index(TLT);\
 l_dir_par_index[dir_TRT]   = lua_key_index(TRT);\
 l_dir_par_index[dir_LTL]   = lua_key_index(LTL);\
-l_dir_par_index[dir_RTT]   = lua_key_index(RTT);\
-l_dir_par_index[dir_TLT+4] = lua_key_index(TLT);\
-l_dir_par_index[dir_TRT+4] = lua_key_index(TRT);\
-l_dir_par_index[dir_LTL+4] = lua_key_index(LTL);\
-l_dir_par_index[dir_RTT+4] = lua_key_index(RTT);\
+l_dir_par_index[dir_RTT]   = lua_key_index(RTT);
 
 #define set_l_dir_text_index \
-l_dir_text_index[dir_TLT]   = lua_key_index(mTLT);\
-l_dir_text_index[dir_TRT]   = lua_key_index(mTRT);\
-l_dir_text_index[dir_LTL]   = lua_key_index(mLTL);\
-l_dir_text_index[dir_RTT]   = lua_key_index(mRTT);\
-l_dir_text_index[dir_TLT+4] = lua_key_index(pTLT);\
-l_dir_text_index[dir_TRT+4] = lua_key_index(pTRT);\
-l_dir_text_index[dir_LTL+4] = lua_key_index(pLTL);\
-l_dir_text_index[dir_RTT+4] = lua_key_index(pRTT);\
+l_dir_text_index_normal[dir_TLT] = lua_key_index(pTLT);\
+l_dir_text_index_normal[dir_TRT] = lua_key_index(pTRT);\
+l_dir_text_index_normal[dir_LTL] = lua_key_index(pLTL);\
+l_dir_text_index_normal[dir_RTT] = lua_key_index(pRTT);\
+l_dir_text_index_cancel[dir_TLT] = lua_key_index(mTLT);\
+l_dir_text_index_cancel[dir_TRT] = lua_key_index(mTRT);\
+l_dir_text_index_cancel[dir_LTL] = lua_key_index(mLTL);\
+l_dir_text_index_cancel[dir_RTT] = lua_key_index(mRTT);
 
 #define img_parms_max     25
 #define img_pageboxes_max  6
@@ -438,6 +482,7 @@ extern int img_pageboxes [img_pageboxes_max];
 
 # define set_l_img_keys_index \
 img_parms[ 0] = lua_key_index(attr); \
+img_parms[ 0] = lua_key_index(attribute_list); \
 img_parms[ 1] = lua_key_index(bbox); \
 img_parms[ 2] = lua_key_index(colordepth); \
 img_parms[ 3] = lua_key_index(colorspace); \
@@ -474,17 +519,16 @@ img_pageboxes[5] = lua_key_index(art); \
 #define lua_push_img_key(L,key)     lua_rawgeti(L, LUA_REGISTRYINDEX, img_parms[key] );
 #define lua_push_img_pagebox(L,box) lua_rawgeti(L, LUA_REGISTRYINDEX, img_pageboxes[box]);
 
-extern int lua_show_valid_list(lua_State *L, const char **list, int max);
+extern int lua_show_valid_list(lua_State *L, const char **list, int offset, int max);
 extern int lua_show_valid_keys(lua_State *L, int *list, int max);
 
 #define set_make_keys \
-make_lua_key(cmdname);make_lua_key(expandable);make_lua_key(protected);\
-make_lua_key(LTL);\
-make_lua_key(MathConstants);\
-make_lua_key(RTT);\
-make_lua_key(TLT);\
-make_lua_key(TRT);\
+make_lua_key(__index);\
+make_lua_key(above);\
+make_lua_key(abovedisplayshortskip);\
+make_lua_key(abovedisplayskip);\
 make_lua_key(accent);\
+make_lua_key(accentkern);\
 make_lua_key(action);\
 make_lua_key(action_id);\
 make_lua_key(action_type);\
@@ -496,53 +540,107 @@ make_lua_key(adjust_head);\
 make_lua_key(adjusted_hbox);\
 make_lua_key(adjustspacing);\
 make_lua_key(advance);\
+make_lua_key(after_assignment);\
 make_lua_key(after_display);\
+make_lua_key(after_group);\
 make_lua_key(after_output);\
+make_lua_key(afterdisplaypenalty);\
 make_lua_key(align);\
 make_lua_key(align_head);\
+make_lua_key(align_record);\
 make_lua_key(align_set);\
+make_lua_key(align_stack);\
 make_lua_key(alignment);\
+make_lua_key(always);\
 make_lua_key(annot);\
 make_lua_key(area);\
 make_lua_key(art);\
+make_lua_key(assign_attr);\
+make_lua_key(assign_box_dir);\
+make_lua_key(assign_box_direction);\
+make_lua_key(assign_dimen);\
+make_lua_key(assign_dir);\
+make_lua_key(assign_direction);\
+make_lua_key(assign_font_dimen);\
+make_lua_key(assign_font_int);\
+make_lua_key(assign_glue);\
+make_lua_key(assign_hang_indent);\
+make_lua_key(assign_int);\
+make_lua_key(assign_local_box);\
+make_lua_key(assign_mu_glue);\
+make_lua_key(assign_toks);\
 make_lua_key(attr);\
+make_lua_key(attribute);\
+make_lua_key(attribute_list);\
 make_lua_key(attributes);\
+make_lua_key(automatic);\
+make_lua_key(baselineskip);\
 make_lua_key(bbox);\
 make_lua_key(before_display);\
+make_lua_key(beforedisplaypenalty);\
+make_lua_key(begin_group);\
+make_lua_key(beginmath);\
+make_lua_key(belowdisplayshortskip);\
+make_lua_key(belowdisplayskip);\
 make_lua_key(best_ins_ptr);\
 make_lua_key(best_page_break);\
 make_lua_key(best_size);\
+make_lua_key(bin);\
 make_lua_key(bleed);\
 make_lua_key(bot);\
 make_lua_key(bot_accent);\
+make_lua_key(bothflexible);\
 make_lua_key(bottom_left);\
 make_lua_key(bottom_right);\
 make_lua_key(boundary);\
 make_lua_key(box);\
 make_lua_key(box_left);\
 make_lua_key(box_left_width);\
+make_lua_key(box_ref);\
 make_lua_key(box_right);\
 make_lua_key(box_right_width);\
+make_lua_key(box_there);\
+make_lua_key(break_penalty);\
 make_lua_key(broken_ins);\
 make_lua_key(broken_ptr);\
 make_lua_key(brokenpenalty);\
 make_lua_key(cache);\
 make_lua_key(cal_expand_ratio);\
+make_lua_key(call);\
+make_lua_key(cancel);\
+make_lua_key(car_ret);\
+make_lua_key(case_shift);\
+make_lua_key(Catalog);\
 make_lua_key(catalog);\
+make_lua_key(cell);\
 make_lua_key(char);\
+make_lua_key(char_ghost);\
+make_lua_key(char_given);\
+make_lua_key(char_num);\
+make_lua_key(character);\
 make_lua_key(characters);\
 make_lua_key(checksum);\
+make_lua_key(choice);\
 make_lua_key(cidinfo);\
 make_lua_key(class);\
+make_lua_key(cleaders);\
+make_lua_key(close);\
 make_lua_key(clubpenalty);\
+make_lua_key(cmd);\
+make_lua_key(cmdname);\
+make_lua_key(color_stack);\
 make_lua_key(colordepth);\
 make_lua_key(colorspace);\
+make_lua_key(combinetoks);\
 make_lua_key(command);\
 make_lua_key(commands);\
 make_lua_key(comment);\
 make_lua_key(components);\
 make_lua_key(compresslevel);\
+make_lua_key(conditionalmathskip);\
 make_lua_key(contrib_head);\
+make_lua_key(convert);\
+make_lua_key(copy_font);\
 make_lua_key(core);\
 make_lua_key(cost);\
 make_lua_key(count);\
@@ -551,11 +649,21 @@ make_lua_key(crampedscript);\
 make_lua_key(crampedscriptscript);\
 make_lua_key(crampedtext);\
 make_lua_key(crop);\
+make_lua_key(cs_name);\
 make_lua_key(csname);\
+make_lua_key(current);\
 make_lua_key(data);\
+make_lua_key(def);\
+make_lua_key(def_char_code);\
+make_lua_key(def_del_code);\
+make_lua_key(def_family);\
+make_lua_key(def_font);\
+make_lua_key(def_lua_call);\
 make_lua_key(degree);\
 make_lua_key(delim);\
+make_lua_key(delim_num);\
 make_lua_key(delimptr);\
+make_lua_key(delta);\
 make_lua_key(demerits);\
 make_lua_key(denom);\
 make_lua_key(depth);\
@@ -568,46 +676,92 @@ make_lua_key(direct);\
 make_lua_key(direction);\
 make_lua_key(dirs);\
 make_lua_key(disc);\
+make_lua_key(discretionary);\
 make_lua_key(display);\
+make_lua_key(divide);\
+make_lua_key(dont_expand);\
 make_lua_key(doublehyphendemerits);\
 make_lua_key(down);\
 make_lua_key(embedding);\
 make_lua_key(emergencystretch);\
+make_lua_key(empty);\
 make_lua_key(empty_string);\
 make_lua_key(encodingbytes);\
 make_lua_key(encodingname);\
 make_lua_key(end);\
-make_lua_key(etex);\
+make_lua_key(end_cs_name);\
+make_lua_key(end_group);\
+make_lua_key(end_template);\
+make_lua_key(endmath);\
+make_lua_key(endv);\
+make_lua_key(eq_no);\
 make_lua_key(equation);\
 make_lua_key(equation_number);\
+make_lua_key(equationnumber);\
+make_lua_key(equationnumberpenalty);\
+make_lua_key(etex);\
+make_lua_key(ex_space);\
 make_lua_key(exactly);\
+make_lua_key(expand_after);\
+make_lua_key(expand_font);\
+make_lua_key(expandable);\
 make_lua_key(expansion_factor);\
+make_lua_key(explicit);\
+make_lua_key(expr_stack);\
 make_lua_key(ext);\
+make_lua_key(extdef_del_code);\
+make_lua_key(extdef_math_code);\
 make_lua_key(extend);\
 make_lua_key(extender);\
 make_lua_key(extensible);\
+make_lua_key(extension);\
 make_lua_key(extra_space);\
 make_lua_key(fam);\
 make_lua_key(fast);\
+make_lua_key(feedback);\
 make_lua_key(fence);\
+make_lua_key(fi);\
+make_lua_key(fi_or_else);\
+make_lua_key(fil);\
 make_lua_key(file);\
 make_lua_key(filename);\
 make_lua_key(filepath);\
 make_lua_key(fill);\
+make_lua_key(filll);\
+make_lua_key(fillll);\
 make_lua_key(fin_row);\
 make_lua_key(finalhyphendemerits);\
+make_lua_key(finalpenalty);\
+make_lua_key(first);\
+make_lua_key(fit);\
+make_lua_key(fitb);\
+make_lua_key(fitbh);\
+make_lua_key(fitbv);\
+make_lua_key(fith);\
+make_lua_key(fitr);\
+make_lua_key(fitv);\
+make_lua_key(fixedboth);\
+make_lua_key(fixedbottom);\
+make_lua_key(fixedtop);\
 make_lua_key(font);\
+make_lua_key(fontkern);\
 make_lua_key(fonts);\
 make_lua_key(format);\
 make_lua_key(fraction);\
 make_lua_key(fullname);\
+make_lua_key(ghost);\
+make_lua_key(gleaders);\
 make_lua_key(global);\
 make_lua_key(glue);\
 make_lua_key(glue_order);\
+make_lua_key(glue_ref);\
 make_lua_key(glue_set);\
 make_lua_key(glue_sign);\
+make_lua_key(glue_spec);\
 make_lua_key(glyph);\
+make_lua_key(goto);\
 make_lua_key(h);\
+make_lua_key(halign);\
 make_lua_key(hangafter);\
 make_lua_key(hangindent);\
 make_lua_key(hbox);\
@@ -615,20 +769,37 @@ make_lua_key(head);\
 make_lua_key(height);\
 make_lua_key(hlist);\
 make_lua_key(hmode_par);\
+make_lua_key(hmove);\
 make_lua_key(hold_head);\
 make_lua_key(horiz_variants);\
+make_lua_key(hrule);\
 make_lua_key(hsize);\
+make_lua_key(hskip);\
+make_lua_key(hyph_data);\
+make_lua_key(hyphenated);\
 make_lua_key(hyphenchar);\
 make_lua_key(id);\
 make_lua_key(identity);\
+make_lua_key(if_stack);\
+make_lua_key(if_test);\
+make_lua_key(ignore_spaces);\
 make_lua_key(image);\
 make_lua_key(imagetype);\
 make_lua_key(immediate);\
+make_lua_key(in_stream);\
+make_lua_key(indent);\
 make_lua_key(index);\
 make_lua_key(info);\
+make_lua_key(Info);\
+make_lua_key(inner);\
+make_lua_key(input);\
+make_lua_key(ins);\
 make_lua_key(insert);\
+make_lua_key(inserts_only);\
 make_lua_key(interlinepenalty);\
+make_lua_key(ital_corr);\
 make_lua_key(italic);\
+make_lua_key(italiccorrection);\
 make_lua_key(keepopen);\
 make_lua_key(kern);\
 make_lua_key(kerns);\
@@ -636,95 +807,191 @@ make_lua_key(lang);\
 make_lua_key(large_char);\
 make_lua_key(large_fam);\
 make_lua_key(last_ins_ptr);\
+make_lua_key(last_item);\
 make_lua_key(lastlinefit);\
+make_lua_key(late_lua);\
 make_lua_key(leader);\
+make_lua_key(leader_ship);\
+make_lua_key(leaders);\
 make_lua_key(least_page_cost);\
 make_lua_key(left);\
 make_lua_key(left_boundary);\
+make_lua_key(left_brace);\
 make_lua_key(left_protruding);\
+make_lua_key(left_right);\
 make_lua_key(leftskip);\
+make_lua_key(let);\
+make_lua_key(letter);\
+make_lua_key(letterspace_font);\
 make_lua_key(level);\
+make_lua_key(ligature);\
 make_lua_key(ligatures);\
+make_lua_key(limit_switch);\
+make_lua_key(line);\
+make_lua_key(linebreakpenalty);\
 make_lua_key(linepenalty);\
+make_lua_key(lineskip);\
 make_lua_key(link_attr);\
 make_lua_key(list);\
 make_lua_key(local_box);\
+make_lua_key(local_par);\
 make_lua_key(log);\
+make_lua_key(long_call);\
+make_lua_key(long_outer_call);\
 make_lua_key(looseness);\
+make_lua_key(LTL);\
 make_lua_key(lua);\
+make_lua_key(lua_bytecode_call);\
 make_lua_key(lua_bytecodes_indirect);\
+make_lua_key(lua_call);\
+make_lua_key(lua_expandable_call);\
+make_lua_key(lua_local_call);\
+make_lua_key(lua_function_call);\
 make_lua_key(lua_functions);\
 make_lua_key(luatex);\
 make_lua_key(luatex_node);\
 make_lua_key(luatex_token);\
-make_lua_key(mLTL);\
-make_lua_key(mRTT);\
-make_lua_key(mTLT);\
-make_lua_key(mTRT);\
+make_lua_key(luatex_pdfe);\
+make_lua_key(luatex_pdfe_dictionary);\
+make_lua_key(luatex_pdfe_array);\
+make_lua_key(luatex_pdfe_stream);\
+make_lua_key(luatex_pdfe_reference);\
+make_lua_key(mac_param);\
+make_lua_key(make_box);\
+make_lua_key(margin_kern);\
 make_lua_key(marginkern);\
 make_lua_key(mark);\
 make_lua_key(math);\
+make_lua_key(math_accent);\
+make_lua_key(math_char);\
+make_lua_key(math_char_num);\
 make_lua_key(math_choice);\
+make_lua_key(math_comp);\
+make_lua_key(math_given);\
 make_lua_key(math_left);\
 make_lua_key(math_shift);\
+make_lua_key(math_shift_cs);\
+make_lua_key(math_style);\
+make_lua_key(math_sub_box);\
+make_lua_key(math_sub_mlist);\
+make_lua_key(math_text_char);\
+make_lua_key(MathConstants);\
 make_lua_key(mathdir);\
 make_lua_key(mathkern);\
+make_lua_key(mathskip);\
 make_lua_key(mathstyle);\
 make_lua_key(media);\
+make_lua_key(medmuskip);\
+make_lua_key(message);\
 make_lua_key(mid);\
 make_lua_key(middle);\
+make_lua_key(mkern);\
+make_lua_key(mLTL);\
 make_lua_key(mode);\
 make_lua_key(modeline);\
+make_lua_key(movement_stack);\
+make_lua_key(mRTT);\
+make_lua_key(mskip);\
+make_lua_key(mTLT);\
+make_lua_key(mTRT);\
+make_lua_key(muglue);\
+make_lua_key(multiply);\
 make_lua_key(name);\
 make_lua_key(named_id);\
 make_lua_key(names);\
+make_lua_key(nested_list);\
+make_lua_key(new);\
 make_lua_key(new_graf);\
 make_lua_key(new_window);\
 make_lua_key(next);\
 make_lua_key(no);\
+make_lua_key(nolength);\
 make_lua_key(no_align);\
+make_lua_key(no_expand);\
+make_lua_key(no_super_sub_script);\
 make_lua_key(noad);\
+make_lua_key(noadpenalty);\
 make_lua_key(node);\
 make_lua_key(node_properties);\
 make_lua_key(node_properties_indirect);\
+make_lua_key(nohrule);\
 make_lua_key(nomath);\
+make_lua_key(non_script);\
 make_lua_key(none);\
+make_lua_key(nonew);\
 make_lua_key(nop);\
+make_lua_key(normal);\
+make_lua_key(novrule);\
 make_lua_key(nucleus);\
 make_lua_key(num);\
 make_lua_key(number);\
 make_lua_key(objcompression);\
 make_lua_key(objnum);\
 make_lua_key(oldmath);\
-make_lua_key(ordering);\
+make_lua_key(omit);\
+make_lua_key(opdisplaylimits);\
+make_lua_key(open);\
+make_lua_key(oplimits);\
+make_lua_key(opnolimits);\
+make_lua_key(option);\
 make_lua_key(options);\
+make_lua_key(ord);\
+make_lua_key(ordering);\
 make_lua_key(orientation);\
 make_lua_key(origin);\
+make_lua_key(other_char);\
+make_lua_key(outer_call);\
+make_lua_key(outline);\
 make_lua_key(output);\
+make_lua_key(over);\
 make_lua_key(overlay_accent);\
-make_lua_key(pLTL);\
-make_lua_key(pRTT);\
-make_lua_key(pTLT);\
-make_lua_key(pTRT);\
+make_lua_key(ownerpassword);\
 make_lua_key(page);\
-make_lua_key(pages);\
 make_lua_key(page_discards_head);\
 make_lua_key(page_head);\
 make_lua_key(page_ins_head);\
+make_lua_key(page_insert);\
 make_lua_key(pageattributes);\
 make_lua_key(pagebox);\
 make_lua_key(pageresources);\
+make_lua_key(pages);\
+make_lua_key(Pages);\
 make_lua_key(pagesattributes);\
+make_lua_key(pagestate);\
+make_lua_key(par_end);\
 make_lua_key(parameters);\
 make_lua_key(pardir);\
+make_lua_key(parfillskip);\
 make_lua_key(parshape);\
+make_lua_key(parskip);\
+make_lua_key(passive);\
 make_lua_key(pdf);\
+make_lua_key(pdfe);\
+make_lua_key(pdf_action);\
+make_lua_key(pdf_annot);\
+make_lua_key(pdf_colorstack);\
 make_lua_key(pdf_data);\
+make_lua_key(pdf_dest);\
 make_lua_key(pdf_destination);\
+make_lua_key(pdf_end_link);\
+make_lua_key(pdf_end_thread);\
+make_lua_key(pdf_link_data);\
 make_lua_key(pdf_literal);\
+make_lua_key(pdf_refobj);\
+make_lua_key(pdf_restore);\
+make_lua_key(pdf_save);\
+make_lua_key(pdf_setmatrix);\
+make_lua_key(pdf_setobj);\
+make_lua_key(pdf_start);\
+make_lua_key(pdf_start_link);\
+make_lua_key(pdf_start_thread);\
+make_lua_key(pdf_thread);\
+make_lua_key(pdf_thread_data);\
+make_lua_key(pdf_window);\
 make_lua_key(pen_broken);\
 make_lua_key(pen_inter);\
 make_lua_key(penalty);\
+make_lua_key(pLTL);\
 make_lua_key(pop);\
 make_lua_key(post);\
 make_lua_key(post_linebreak);\
@@ -734,35 +1001,71 @@ make_lua_key(pre_adjust_head);\
 make_lua_key(pre_align);\
 make_lua_key(pre_box);\
 make_lua_key(preamble);\
+make_lua_key(prefix);\
 make_lua_key(pretolerance);\
 make_lua_key(prev);\
 make_lua_key(prevdepth);\
 make_lua_key(prevgraf);\
+make_lua_key(protected);\
 make_lua_key(protrudechars);\
+make_lua_key(protrusion);\
+make_lua_key(pRTT);\
+make_lua_key(pseudo_file);\
+make_lua_key(pseudo_line);\
 make_lua_key(psname);\
+make_lua_key(pTLT);\
 make_lua_key(ptr);\
+make_lua_key(pTRT);\
+make_lua_key(punct);\
 make_lua_key(push);\
 make_lua_key(quad);\
 make_lua_key(radical);\
 make_lua_key(raw);\
+make_lua_key(read_to_cs);\
+make_lua_key(recompress);\
 make_lua_key(ref_count);\
 make_lua_key(reg);\
+make_lua_key(register);\
 make_lua_key(registry);\
+make_lua_key(regular);\
+make_lua_key(rel);\
+make_lua_key(relax);\
+make_lua_key(remove_item);\
 make_lua_key(renew);\
 make_lua_key(rep);\
 make_lua_key(replace);\
 make_lua_key(resources);\
 make_lua_key(right);\
 make_lua_key(right_boundary);\
+make_lua_key(right_brace);\
 make_lua_key(right_protruding);\
 make_lua_key(rightskip);\
 make_lua_key(rotation);\
+make_lua_key(RTT);\
 make_lua_key(rule);\
+make_lua_key(save_pos);\
 make_lua_key(scale);\
 make_lua_key(script);\
 make_lua_key(scriptscript);\
+make_lua_key(second);\
 make_lua_key(semi_simple);\
+make_lua_key(set);\
+make_lua_key(set_aux);\
+make_lua_key(set_box);\
+make_lua_key(set_box_dimen);\
+make_lua_key(set_etex_shape);\
+make_lua_key(set_font);\
+make_lua_key(set_font_id);\
+make_lua_key(set_interaction);\
+make_lua_key(set_math_param);\
+make_lua_key(set_page_dimen);\
+make_lua_key(set_page_int);\
+make_lua_key(set_prev_graf);\
+make_lua_key(set_tex_shape);\
+make_lua_key(shape);\
+make_lua_key(shape_ref);\
 make_lua_key(shift);\
+make_lua_key(shorthand_def);\
 make_lua_key(shrink);\
 make_lua_key(shrink_order);\
 make_lua_key(simple);\
@@ -776,13 +1079,22 @@ make_lua_key(space);\
 make_lua_key(space_shrink);\
 make_lua_key(space_stretch);\
 make_lua_key(spacefactor);\
+make_lua_key(spacer);\
+make_lua_key(spaceskip);\
+make_lua_key(span);\
+make_lua_key(spec);\
 make_lua_key(special);\
 make_lua_key(split_discards_head);\
+make_lua_key(split_insert);\
 make_lua_key(split_keep);\
 make_lua_key(split_off);\
+make_lua_key(splittopskip);\
+make_lua_key(squeeze);\
 make_lua_key(stack);\
 make_lua_key(start);\
+make_lua_key(start_par);\
 make_lua_key(step);\
+make_lua_key(stop);\
 make_lua_key(stream);\
 make_lua_key(streamfile);\
 make_lua_key(streamprovider);\
@@ -791,72 +1103,122 @@ make_lua_key(stretch_order);\
 make_lua_key(string);\
 make_lua_key(style);\
 make_lua_key(sub);\
+make_lua_key(sub_box);\
+make_lua_key(sub_mark);\
+make_lua_key(sub_mlist);\
 make_lua_key(subst_ex_font);\
 make_lua_key(subtype);\
 make_lua_key(sup);\
+make_lua_key(sup_mark);\
+make_lua_key(super_sub_script);\
 make_lua_key(supplement);\
 make_lua_key(surround);\
+make_lua_key(tab_mark);\
+make_lua_key(tabskip);\
 make_lua_key(tail);\
+make_lua_key(temp);\
 make_lua_key(temp_head);\
 make_lua_key(term);\
 make_lua_key(term_and_log);\
 make_lua_key(tex);\
 make_lua_key(text);\
+make_lua_key(the);\
+make_lua_key(thickmuskip);\
+make_lua_key(thinmuskip);\
+make_lua_key(thread);\
 make_lua_key(thread_attr);\
 make_lua_key(thread_id);\
-make_lua_key(tolerance);\
+make_lua_key(TLT);\
 make_lua_key(tok);\
 make_lua_key(token);\
+make_lua_key(toks_register);\
+make_lua_key(tolerance);\
 make_lua_key(top);\
 make_lua_key(top_accent);\
+make_lua_key(top_bot_mark);\
 make_lua_key(top_left);\
 make_lua_key(top_right);\
+make_lua_key(topskip);\
 make_lua_key(tounicode);\
 make_lua_key(tracingparagraphs);\
 make_lua_key(trailer);\
+make_lua_key(Trailer);\
 make_lua_key(trailerid);\
 make_lua_key(transform);\
 make_lua_key(trim);\
+make_lua_key(TRT);\
 make_lua_key(type);\
 make_lua_key(uchyph);\
+make_lua_key(udelimiterover);\
+make_lua_key(udelimiterunder);\
+make_lua_key(un_hbox);\
+make_lua_key(un_vbox);\
+make_lua_key(undefined_cs);\
+make_lua_key(under);\
+make_lua_key(unhyphenated);\
 make_lua_key(units_per_em);\
+make_lua_key(unknown);\
+make_lua_key(unset);\
+make_lua_key(uoverdelimiter);\
+make_lua_key(uradical);\
+make_lua_key(uroot);\
 make_lua_key(used);\
+make_lua_key(user);\
+make_lua_key(userpassword);\
+make_lua_key(user_defined);\
 make_lua_key(user_id);\
+make_lua_key(userkern);\
+make_lua_key(userpenalty);\
+make_lua_key(userskip);\
+make_lua_key(uunderdelimiter);\
 make_lua_key(v);\
+make_lua_key(vadjust);\
+make_lua_key(valign);\
 make_lua_key(value);\
+make_lua_key(variable);\
 make_lua_key(vbox);\
 make_lua_key(vcenter);\
 make_lua_key(version);\
 make_lua_key(vert_italic);\
 make_lua_key(vert_variants);\
-make_lua_key(vmode_par);\
 make_lua_key(visiblefilename);\
 make_lua_key(vlist);\
+make_lua_key(vmode_par);\
+make_lua_key(vmove);\
+make_lua_key(vrule);\
+make_lua_key(vskip);\
 make_lua_key(vtop);\
+make_lua_key(whatsit);\
 make_lua_key(widowpenalty);\
 make_lua_key(width);\
+make_lua_key(word);\
+make_lua_key(wordpenalty);\
+make_lua_key(write); \
+make_lua_key(writingmode); \
 make_lua_key(x_height);\
 make_lua_key(xadvance);\
-make_lua_key(xformresources);\
 make_lua_key(xformattributes);\
+make_lua_key(xformresources);\
+make_lua_key(xleaders);\
+make_lua_key(xmath_given);\
 make_lua_key(xoffset);\
+make_lua_key(xray);\
 make_lua_key(xres);\
 make_lua_key(xsize);\
+make_lua_key(xspaceskip);\
+make_lua_key(xyz);\
 make_lua_key(xyz_zoom);\
 make_lua_key(yoffset); \
 make_lua_key(yres); \
-make_lua_key(ysize); \
-make_lua_key(writingmode); \
-make_lua_key(__index)
+make_lua_key(ysize);
 
 #define set_init_keys \
-init_lua_key(cmdname);init_lua_key(expandable);init_lua_key(protected);\
-init_lua_key(LTL);\
-init_lua_key(MathConstants);\
-init_lua_key(RTT);\
-init_lua_key(TLT);\
-init_lua_key(TRT);\
+init_lua_key(__index);\
+init_lua_key(above);\
+init_lua_key(abovedisplayshortskip);\
+init_lua_key(abovedisplayskip);\
 init_lua_key(accent);\
+init_lua_key(accentkern);\
 init_lua_key(action);\
 init_lua_key(action_id);\
 init_lua_key(action_type);\
@@ -868,53 +1230,107 @@ init_lua_key(adjust_head);\
 init_lua_key(adjusted_hbox);\
 init_lua_key(adjustspacing);\
 init_lua_key(advance);\
+init_lua_key(after_assignment);\
 init_lua_key(after_display);\
+init_lua_key(after_group);\
 init_lua_key(after_output);\
+init_lua_key(afterdisplaypenalty);\
 init_lua_key(align);\
 init_lua_key(align_head);\
+init_lua_key(align_record);\
 init_lua_key(align_set);\
+init_lua_key(align_stack);\
 init_lua_key(alignment);\
+init_lua_key(always);\
 init_lua_key(annot);\
 init_lua_key(area);\
 init_lua_key(art);\
+init_lua_key(assign_attr);\
+init_lua_key(assign_box_dir);\
+init_lua_key(assign_box_direction);\
+init_lua_key(assign_dimen);\
+init_lua_key(assign_dir);\
+init_lua_key(assign_direction);\
+init_lua_key(assign_font_dimen);\
+init_lua_key(assign_font_int);\
+init_lua_key(assign_glue);\
+init_lua_key(assign_hang_indent);\
+init_lua_key(assign_int);\
+init_lua_key(assign_local_box);\
+init_lua_key(assign_mu_glue);\
+init_lua_key(assign_toks);\
 init_lua_key(attr);\
+init_lua_key(attribute);\
+init_lua_key(attribute_list);\
 init_lua_key(attributes);\
+init_lua_key(automatic);\
+init_lua_key(baselineskip);\
 init_lua_key(bbox);\
 init_lua_key(before_display);\
+init_lua_key(beforedisplaypenalty);\
+init_lua_key(begin_group);\
+init_lua_key(beginmath);\
+init_lua_key(belowdisplayshortskip);\
+init_lua_key(belowdisplayskip);\
 init_lua_key(best_ins_ptr);\
 init_lua_key(best_page_break);\
 init_lua_key(best_size);\
+init_lua_key(bin);\
 init_lua_key(bleed);\
 init_lua_key(bot);\
 init_lua_key(bot_accent);\
+init_lua_key(bothflexible);\
 init_lua_key(bottom_left);\
 init_lua_key(bottom_right);\
 init_lua_key(boundary);\
 init_lua_key(box);\
 init_lua_key(box_left);\
 init_lua_key(box_left_width);\
+init_lua_key(box_ref);\
 init_lua_key(box_right);\
 init_lua_key(box_right_width);\
+init_lua_key(box_there);\
+init_lua_key(break_penalty);\
 init_lua_key(broken_ins);\
 init_lua_key(broken_ptr);\
 init_lua_key(brokenpenalty);\
 init_lua_key(cache);\
 init_lua_key(cal_expand_ratio);\
+init_lua_key(call);\
+init_lua_key(cancel);\
+init_lua_key(car_ret);\
+init_lua_key(case_shift);\
+init_lua_key(Catalog);\
 init_lua_key(catalog);\
+init_lua_key(cell);\
 init_lua_key(char);\
+init_lua_key(char_ghost);\
+init_lua_key(char_given);\
+init_lua_key(char_num);\
+init_lua_key(character);\
 init_lua_key(characters);\
 init_lua_key(checksum);\
+init_lua_key(choice);\
 init_lua_key(cidinfo);\
 init_lua_key(class);\
+init_lua_key(cleaders);\
+init_lua_key(close);\
 init_lua_key(clubpenalty);\
+init_lua_key(cmd);\
+init_lua_key(cmdname);\
+init_lua_key(color_stack);\
 init_lua_key(colordepth);\
 init_lua_key(colorspace);\
+init_lua_key(combinetoks);\
 init_lua_key(command);\
 init_lua_key(commands);\
 init_lua_key(comment);\
 init_lua_key(components);\
 init_lua_key(compresslevel);\
+init_lua_key(conditionalmathskip);\
 init_lua_key(contrib_head);\
+init_lua_key(convert);\
+init_lua_key(copy_font);\
 init_lua_key(core);\
 init_lua_key(cost);\
 init_lua_key(count);\
@@ -923,11 +1339,21 @@ init_lua_key(crampedscript);\
 init_lua_key(crampedscriptscript);\
 init_lua_key(crampedtext);\
 init_lua_key(crop);\
+init_lua_key(cs_name);\
 init_lua_key(csname);\
+init_lua_key(current);\
 init_lua_key(data);\
+init_lua_key(def);\
+init_lua_key(def_char_code);\
+init_lua_key(def_del_code);\
+init_lua_key(def_family);\
+init_lua_key(def_font);\
+init_lua_key(def_lua_call);\
 init_lua_key(degree);\
 init_lua_key(delim);\
+init_lua_key(delim_num);\
 init_lua_key(delimptr);\
+init_lua_key(delta);\
 init_lua_key(demerits);\
 init_lua_key(denom);\
 init_lua_key(depth);\
@@ -940,45 +1366,91 @@ init_lua_key(direct);\
 init_lua_key(direction);\
 init_lua_key(dirs);\
 init_lua_key(disc);\
+init_lua_key(discretionary);\
 init_lua_key(display);\
+init_lua_key(divide);\
+init_lua_key(dont_expand);\
 init_lua_key(doublehyphendemerits);\
 init_lua_key(down);\
 init_lua_key(embedding);\
 init_lua_key(emergencystretch);\
+init_lua_key(empty);\
 init_lua_key(encodingbytes);\
 init_lua_key(encodingname);\
 init_lua_key(end);\
-init_lua_key(etex);\
+init_lua_key(end_cs_name);\
+init_lua_key(end_group);\
+init_lua_key(end_template);\
+init_lua_key(endmath);\
+init_lua_key(endv);\
+init_lua_key(eq_no);\
 init_lua_key(equation);\
 init_lua_key(equation_number);\
+init_lua_key(equationnumber);\
+init_lua_key(equationnumberpenalty);\
+init_lua_key(etex);\
+init_lua_key(ex_space);\
 init_lua_key(exactly);\
+init_lua_key(expand_after);\
+init_lua_key(expand_font);\
+init_lua_key(expandable);\
 init_lua_key(expansion_factor);\
+init_lua_key(explicit);\
+init_lua_key(expr_stack);\
 init_lua_key(ext);\
+init_lua_key(extdef_del_code);\
+init_lua_key(extdef_math_code);\
 init_lua_key(extend);\
 init_lua_key(extender);\
 init_lua_key(extensible);\
+init_lua_key(extension);\
 init_lua_key(extra_space);\
 init_lua_key(fam);\
 init_lua_key(fast);\
+init_lua_key(feedback);\
 init_lua_key(fence);\
+init_lua_key(fi);\
+init_lua_key(fi_or_else);\
+init_lua_key(fil);\
 init_lua_key(file);\
 init_lua_key(filename);\
 init_lua_key(filepath);\
 init_lua_key(fill);\
+init_lua_key(filll);\
+init_lua_key(fillll);\
 init_lua_key(fin_row);\
 init_lua_key(finalhyphendemerits);\
+init_lua_key(finalpenalty);\
+init_lua_key(first);\
+init_lua_key(fit);\
+init_lua_key(fitb);\
+init_lua_key(fitbh);\
+init_lua_key(fitbv);\
+init_lua_key(fith);\
+init_lua_key(fitr);\
+init_lua_key(fitv);\
+init_lua_key(fixedboth);\
+init_lua_key(fixedbottom);\
+init_lua_key(fixedtop);\
 init_lua_key(font);\
+init_lua_key(fontkern);\
 init_lua_key(fonts);\
 init_lua_key(format);\
 init_lua_key(fraction);\
 init_lua_key(fullname);\
+init_lua_key(ghost);\
+init_lua_key(gleaders);\
 init_lua_key(global);\
 init_lua_key(glue);\
 init_lua_key(glue_order);\
+init_lua_key(glue_ref);\
 init_lua_key(glue_set);\
 init_lua_key(glue_sign);\
+init_lua_key(glue_spec);\
 init_lua_key(glyph);\
+init_lua_key(goto);\
 init_lua_key(h);\
+init_lua_key(halign);\
 init_lua_key(hangafter);\
 init_lua_key(hangindent);\
 init_lua_key(hbox);\
@@ -986,20 +1458,37 @@ init_lua_key(head);\
 init_lua_key(height);\
 init_lua_key(hlist);\
 init_lua_key(hmode_par);\
+init_lua_key(hmove);\
 init_lua_key(hold_head);\
 init_lua_key(horiz_variants);\
+init_lua_key(hrule);\
 init_lua_key(hsize);\
+init_lua_key(hskip);\
+init_lua_key(hyph_data);\
+init_lua_key(hyphenated);\
 init_lua_key(hyphenchar);\
 init_lua_key(id);\
 init_lua_key(identity);\
+init_lua_key(if_stack);\
+init_lua_key(if_test);\
+init_lua_key(ignore_spaces);\
 init_lua_key(image);\
 init_lua_key(imagetype);\
 init_lua_key(immediate);\
+init_lua_key(in_stream);\
+init_lua_key(indent);\
 init_lua_key(index);\
 init_lua_key(info);\
+init_lua_key(Info);\
+init_lua_key(inner);\
+init_lua_key(input);\
+init_lua_key(ins);\
 init_lua_key(insert);\
+init_lua_key(inserts_only);\
 init_lua_key(interlinepenalty);\
+init_lua_key(ital_corr);\
 init_lua_key(italic);\
+init_lua_key(italiccorrection);\
 init_lua_key(keepopen);\
 init_lua_key(kern);\
 init_lua_key(kerns);\
@@ -1007,82 +1496,179 @@ init_lua_key(lang);\
 init_lua_key(large_char);\
 init_lua_key(large_fam);\
 init_lua_key(last_ins_ptr);\
+init_lua_key(last_item);\
 init_lua_key(lastlinefit);\
-init_lua_key(leftskip);\
+init_lua_key(late_lua);\
 init_lua_key(leader);\
+init_lua_key(leader_ship);\
+init_lua_key(leaders);\
 init_lua_key(least_page_cost);\
 init_lua_key(left);\
 init_lua_key(left_boundary);\
+init_lua_key(left_brace);\
 init_lua_key(left_protruding);\
+init_lua_key(left_right);\
 init_lua_key(leftskip);\
+init_lua_key(let);\
+init_lua_key(letter);\
+init_lua_key(letterspace_font);\
 init_lua_key(level);\
+init_lua_key(ligature);\
 init_lua_key(ligatures);\
-init_lua_key(leftskip);\
+init_lua_key(limit_switch);\
+init_lua_key(line);\
+init_lua_key(linebreakpenalty);\
 init_lua_key(linepenalty);\
+init_lua_key(lineskip);\
 init_lua_key(link_attr);\
 init_lua_key(list);\
 init_lua_key(local_box);\
+init_lua_key(local_par);\
 init_lua_key(log);\
+init_lua_key(long_call);\
+init_lua_key(long_outer_call);\
 init_lua_key(looseness);\
+init_lua_key(LTL);\
 init_lua_key(lua);\
+init_lua_key(lua_bytecode_call);\
 init_lua_key(lua_bytecodes_indirect);\
+init_lua_key(lua_call);\
+init_lua_key(lua_expandable_call);\
+init_lua_key(lua_local_call);\
+init_lua_key(lua_function_call);\
 init_lua_key(lua_functions);\
 init_lua_key(luatex);\
 init_lua_key(luatex_node);\
 init_lua_key(luatex_token);\
+init_lua_key(luatex_pdfe);\
+init_lua_key(luatex_pdfe_dictionary);\
+init_lua_key(luatex_pdfe_array);\
+init_lua_key(luatex_pdfe_stream);\
+init_lua_key(luatex_pdfe_reference);\
+init_lua_key(mac_param);\
+init_lua_key(make_box);\
+init_lua_key(margin_kern);\
 init_lua_key(marginkern);\
 init_lua_key(mark);\
 init_lua_key(math);\
+init_lua_key(math_accent);\
+init_lua_key(math_char);\
+init_lua_key(math_char_num);\
 init_lua_key(math_choice);\
+init_lua_key(math_comp);\
+init_lua_key(math_given);\
 init_lua_key(math_left);\
 init_lua_key(math_shift);\
+init_lua_key(math_shift_cs);\
+init_lua_key(math_style);\
+init_lua_key(math_sub_box);\
+init_lua_key(math_sub_mlist);\
+init_lua_key(math_text_char);\
+init_lua_key(MathConstants);\
 init_lua_key(mathdir);\
 init_lua_key(mathkern);\
+init_lua_key(mathskip);\
 init_lua_key(mathstyle);\
 init_lua_key(media);\
+init_lua_key(medmuskip);\
+init_lua_key(message);\
 init_lua_key(mid);\
 init_lua_key(middle);\
+init_lua_key(mkern);\
 init_lua_key(mode);\
 init_lua_key(modeline);\
+init_lua_key(movement_stack);\
+init_lua_key(mskip);\
+init_lua_key(muglue);\
+init_lua_key(multiply);\
 init_lua_key(name);\
 init_lua_key(named_id);\
 init_lua_key(names);\
+init_lua_key(nested_list);\
+init_lua_key(new);\
 init_lua_key(new_graf);\
 init_lua_key(new_window);\
 init_lua_key(next);\
 init_lua_key(no);\
+init_lua_key(nolength);\
 init_lua_key(no_align);\
+init_lua_key(no_expand);\
+init_lua_key(no_super_sub_script);\
 init_lua_key(noad);\
+init_lua_key(noadpenalty);\
 init_lua_key(node);\
+init_lua_key(nohrule);\
 init_lua_key(nomath);\
+init_lua_key(non_script);\
 init_lua_key(none);\
+init_lua_key(nonew);\
 init_lua_key(nop);\
+init_lua_key(normal);\
+init_lua_key(novrule);\
 init_lua_key(nucleus);\
 init_lua_key(num);\
 init_lua_key(number);\
 init_lua_key(objcompression);\
 init_lua_key(objnum);\
 init_lua_key(oldmath);\
+init_lua_key(omit);\
+init_lua_key(opdisplaylimits);\
+init_lua_key(open);\
+init_lua_key(oplimits);\
+init_lua_key(opnolimits);\
+init_lua_key(option);\
 init_lua_key(options);\
+init_lua_key(ord);\
+init_lua_key(ordering);\
 init_lua_key(orientation);\
 init_lua_key(origin);\
-init_lua_key(ordering);\
+init_lua_key(other_char);\
+init_lua_key(outer_call);\
+init_lua_key(outline);\
 init_lua_key(output);\
+init_lua_key(over);\
 init_lua_key(overlay_accent);\
+init_lua_key(ownerpassword);\
 init_lua_key(page);\
-init_lua_key(pages);\
 init_lua_key(page_discards_head);\
 init_lua_key(page_head);\
 init_lua_key(page_ins_head);\
+init_lua_key(page_insert);\
 init_lua_key(pageattributes);\
 init_lua_key(pagebox);\
 init_lua_key(pageresources);\
+init_lua_key(pages);\
+init_lua_key(Pages);\
 init_lua_key(pagesattributes);\
+init_lua_key(pagestate);\
+init_lua_key(par_end);\
 init_lua_key(parameters);\
 init_lua_key(pardir);\
+init_lua_key(parfillskip);\
 init_lua_key(parshape);\
+init_lua_key(parskip);\
+init_lua_key(passive);\
+init_lua_key(pdfe);\
+init_lua_key(pdf_action);\
+init_lua_key(pdf_annot);\
+init_lua_key(pdf_colorstack);\
+init_lua_key(pdf_dest);\
 init_lua_key(pdf_destination);\
+init_lua_key(pdf_end_link);\
+init_lua_key(pdf_end_thread);\
+init_lua_key(pdf_link_data);\
 init_lua_key(pdf_literal);\
+init_lua_key(pdf_refobj);\
+init_lua_key(pdf_restore);\
+init_lua_key(pdf_save);\
+init_lua_key(pdf_setmatrix);\
+init_lua_key(pdf_setobj);\
+init_lua_key(pdf_start);\
+init_lua_key(pdf_start_link);\
+init_lua_key(pdf_start_thread);\
+init_lua_key(pdf_thread);\
+init_lua_key(pdf_thread_data);\
+init_lua_key(pdf_window);\
 init_lua_key(pen_broken);\
 init_lua_key(pen_inter);\
 init_lua_key(penalty);\
@@ -1095,35 +1681,68 @@ init_lua_key(pre_adjust_head);\
 init_lua_key(pre_align);\
 init_lua_key(pre_box);\
 init_lua_key(preamble);\
+init_lua_key(prefix);\
 init_lua_key(pretolerance);\
 init_lua_key(prev);\
 init_lua_key(prevdepth);\
 init_lua_key(prevgraf);\
+init_lua_key(protected);\
 init_lua_key(protrudechars);\
+init_lua_key(protrusion);\
+init_lua_key(pseudo_file);\
+init_lua_key(pseudo_line);\
 init_lua_key(psname);\
 init_lua_key(ptr);\
+init_lua_key(punct);\
 init_lua_key(push);\
 init_lua_key(quad);\
 init_lua_key(radical);\
 init_lua_key(raw);\
+init_lua_key(read_to_cs);\
 init_lua_key(ref_count);\
+init_lua_key(recompress);\
 init_lua_key(reg);\
+init_lua_key(register);\
 init_lua_key(registry);\
+init_lua_key(regular);\
+init_lua_key(rel);\
+init_lua_key(relax);\
+init_lua_key(remove_item);\
 init_lua_key(renew);\
 init_lua_key(rep);\
 init_lua_key(replace);\
 init_lua_key(resources);\
 init_lua_key(right);\
 init_lua_key(right_boundary);\
+init_lua_key(right_brace);\
 init_lua_key(right_protruding);\
 init_lua_key(rightskip);\
 init_lua_key(rotation);\
+init_lua_key(RTT);\
 init_lua_key(rule);\
+init_lua_key(save_pos);\
 init_lua_key(scale);\
 init_lua_key(script);\
 init_lua_key(scriptscript);\
+init_lua_key(second);\
 init_lua_key(semi_simple);\
+init_lua_key(set);\
+init_lua_key(set_aux);\
+init_lua_key(set_box);\
+init_lua_key(set_box_dimen);\
+init_lua_key(set_etex_shape);\
+init_lua_key(set_font);\
+init_lua_key(set_font_id);\
+init_lua_key(set_interaction);\
+init_lua_key(set_math_param);\
+init_lua_key(set_page_dimen);\
+init_lua_key(set_page_int);\
+init_lua_key(set_prev_graf);\
+init_lua_key(set_tex_shape);\
+init_lua_key(shape);\
+init_lua_key(shape_ref);\
 init_lua_key(shift);\
+init_lua_key(shorthand_def);\
 init_lua_key(shrink);\
 init_lua_key(shrink_order);\
 init_lua_key(simple);\
@@ -1137,13 +1756,22 @@ init_lua_key(space);\
 init_lua_key(space_shrink);\
 init_lua_key(space_stretch);\
 init_lua_key(spacefactor);\
+init_lua_key(spacer);\
+init_lua_key(spaceskip);\
+init_lua_key(span);\
+init_lua_key(spec);\
 init_lua_key(special);\
 init_lua_key(split_discards_head);\
+init_lua_key(split_insert);\
 init_lua_key(split_keep);\
 init_lua_key(split_off);\
+init_lua_key(splittopskip);\
+init_lua_key(squeeze);\
 init_lua_key(stack);\
 init_lua_key(start);\
+init_lua_key(start_par);\
 init_lua_key(step);\
+init_lua_key(stop);\
 init_lua_key(stream);\
 init_lua_key(streamfile);\
 init_lua_key(streamprovider);\
@@ -1152,67 +1780,123 @@ init_lua_key(stretch_order);\
 init_lua_key(string);\
 init_lua_key(style);\
 init_lua_key(sub);\
+init_lua_key(sub_box);\
+init_lua_key(sub_mark);\
+init_lua_key(sub_mlist);\
 init_lua_key(subst_ex_font);\
 init_lua_key(subtype);\
 init_lua_key(sup);\
+init_lua_key(sup_mark);\
+init_lua_key(super_sub_script);\
 init_lua_key(supplement);\
 init_lua_key(surround);\
+init_lua_key(tab_mark);\
+init_lua_key(tabskip);\
 init_lua_key(tail);\
+init_lua_key(temp);\
 init_lua_key(temp_head);\
 init_lua_key(term);\
 init_lua_key(tex);\
 init_lua_key(text);\
+init_lua_key(the);\
+init_lua_key(thickmuskip);\
+init_lua_key(thinmuskip);\
+init_lua_key(thread);\
 init_lua_key(thread_attr);\
 init_lua_key(thread_id);\
-init_lua_key(tolerance);\
+init_lua_key(TLT);\
 init_lua_key(tok);\
 init_lua_key(token);\
+init_lua_key(toks_register);\
+init_lua_key(tolerance);\
 init_lua_key(top);\
 init_lua_key(top_accent);\
+init_lua_key(top_bot_mark);\
 init_lua_key(top_left);\
 init_lua_key(top_right);\
+init_lua_key(topskip);\
 init_lua_key(tounicode);\
 init_lua_key(tracingparagraphs);\
 init_lua_key(trailer);\
+init_lua_key(Trailer);\
 init_lua_key(trailerid);\
 init_lua_key(transform);\
 init_lua_key(trim);\
+init_lua_key(TRT);\
 init_lua_key(type);\
 init_lua_key(uchyph);\
+init_lua_key(udelimiterover);\
+init_lua_key(udelimiterunder);\
+init_lua_key(un_hbox);\
+init_lua_key(un_vbox);\
+init_lua_key(undefined_cs);\
+init_lua_key(under);\
+init_lua_key(unhyphenated);\
 init_lua_key(units_per_em);\
+init_lua_key(unknown);\
+init_lua_key(unset);\
+init_lua_key(uoverdelimiter);\
+init_lua_key(uradical);\
+init_lua_key(uroot);\
 init_lua_key(used);\
+init_lua_key(user);\
+init_lua_key(userpassword);\
+init_lua_key(user_defined);\
 init_lua_key(user_id);\
+init_lua_key(userkern);\
+init_lua_key(userpenalty);\
+init_lua_key(userskip);\
+init_lua_key(uunderdelimiter);\
 init_lua_key(v);\
+init_lua_key(vadjust);\
+init_lua_key(valign);\
 init_lua_key(value);\
+init_lua_key(variable);\
 init_lua_key(vbox);\
 init_lua_key(vcenter);\
 init_lua_key(version);\
 init_lua_key(vert_italic);\
 init_lua_key(vert_variants);\
-init_lua_key(vmode_par);\
 init_lua_key(visiblefilename);\
 init_lua_key(vlist);\
+init_lua_key(vmode_par);\
+init_lua_key(vmove);\
+init_lua_key(vrule);\
+init_lua_key(vskip);\
 init_lua_key(vtop);\
+init_lua_key(whatsit);\
 init_lua_key(widowpenalty);\
 init_lua_key(width);\
+init_lua_key(word);\
+init_lua_key(wordpenalty);\
+init_lua_key(write);\
+init_lua_key(writingmode);\
 init_lua_key(x_height);\
 init_lua_key(xadvance);\
-init_lua_key(xformresources);\
 init_lua_key(xformattributes);\
+init_lua_key(xformresources);\
+init_lua_key(xleaders);\
+init_lua_key(xmath_given);\
 init_lua_key(xoffset);\
+init_lua_key(xray);\
 init_lua_key(xres);\
 init_lua_key(xsize);\
+init_lua_key(xspaceskip);\
+init_lua_key(xyz);\
 init_lua_key(xyz_zoom);\
 init_lua_key(yoffset);\
 init_lua_key(yres);\
 init_lua_key(ysize);\
-init_lua_key(writingmode);\
-init_lua_key(__index);\
 init_lua_key_alias(empty_string,"");\
 init_lua_key_alias(lua_bytecodes_indirect,"lua.bytecodes.indirect");\
 init_lua_key_alias(lua_functions,"lua.functions");\
 init_lua_key_alias(luatex_node, "luatex.node");\
 init_lua_key_alias(luatex_token, "luatex.token");\
+init_lua_key_alias(luatex_pdfe, "luatex.pdfe");\
+init_lua_key_alias(luatex_pdfe_dictionary, "luatex.pdfe.dictionary");\
+init_lua_key_alias(luatex_pdfe_array, "luatex.pdfe.array");\
+init_lua_key_alias(luatex_pdfe_stream, "luatex.pdfe.stream");\
+init_lua_key_alias(luatex_pdfe_reference, "luatex.pdfe.reference");\
 init_lua_key_alias(mLTL,"-LTL");\
 init_lua_key_alias(mRTT,"-RTT");\
 init_lua_key_alias(mTLT,"-TLT");\
@@ -1268,14 +1952,12 @@ extern FILE *_cairo_win_tmpfile( void );
 /* These keys have to available to different files */
 /*                                                 */
 
-use_lua_key(cmdname);use_lua_key(expandable);use_lua_key(protected);
-
-use_lua_key(LTL);
-use_lua_key(MathConstants);
-use_lua_key(RTT);
-use_lua_key(TLT);
-use_lua_key(TRT);
+use_lua_key(__index);
+use_lua_key(above);
+use_lua_key(abovedisplayshortskip);
+use_lua_key(abovedisplayskip);
 use_lua_key(accent);
+use_lua_key(accentkern);
 use_lua_key(action);
 use_lua_key(action_id);
 use_lua_key(action_type);
@@ -1287,53 +1969,107 @@ use_lua_key(adjust_head);
 use_lua_key(adjusted_hbox);
 use_lua_key(adjustspacing);
 use_lua_key(advance);
+use_lua_key(after_assignment);
 use_lua_key(after_display);
+use_lua_key(after_group);
 use_lua_key(after_output);
+use_lua_key(afterdisplaypenalty);
 use_lua_key(align);
 use_lua_key(align_head);
+use_lua_key(align_record);
 use_lua_key(align_set);
+use_lua_key(align_stack);
 use_lua_key(alignment);
+use_lua_key(always);
 use_lua_key(annot);
 use_lua_key(area);
 use_lua_key(art);
+use_lua_key(assign_attr);
+use_lua_key(assign_box_dir);
+use_lua_key(assign_box_direction);
+use_lua_key(assign_dimen);
+use_lua_key(assign_dir);
+use_lua_key(assign_direction);
+use_lua_key(assign_font_dimen);
+use_lua_key(assign_font_int);
+use_lua_key(assign_glue);
+use_lua_key(assign_hang_indent);
+use_lua_key(assign_int);
+use_lua_key(assign_local_box);
+use_lua_key(assign_mu_glue);
+use_lua_key(assign_toks);
 use_lua_key(attr);
+use_lua_key(attribute);
+use_lua_key(attribute_list);
 use_lua_key(attributes);
+use_lua_key(automatic);
+use_lua_key(baselineskip);
 use_lua_key(bbox);
 use_lua_key(before_display);
+use_lua_key(beforedisplaypenalty);
+use_lua_key(begin_group);
+use_lua_key(beginmath);
+use_lua_key(belowdisplayshortskip);
+use_lua_key(belowdisplayskip);
 use_lua_key(best_ins_ptr);
 use_lua_key(best_page_break);
 use_lua_key(best_size);
+use_lua_key(bin);
 use_lua_key(bleed);
 use_lua_key(bot);
 use_lua_key(bot_accent);
+use_lua_key(bothflexible);
 use_lua_key(bottom_left);
 use_lua_key(bottom_right);
 use_lua_key(boundary);
 use_lua_key(box);
 use_lua_key(box_left);
 use_lua_key(box_left_width);
+use_lua_key(box_ref);
 use_lua_key(box_right);
 use_lua_key(box_right_width);
+use_lua_key(box_there);
+use_lua_key(break_penalty);
 use_lua_key(broken_ins);
 use_lua_key(broken_ptr);
 use_lua_key(brokenpenalty);
 use_lua_key(cache);
 use_lua_key(cal_expand_ratio);
+use_lua_key(call);
+use_lua_key(cancel);
+use_lua_key(car_ret);
+use_lua_key(case_shift);
+use_lua_key(Catalog);
 use_lua_key(catalog);
+use_lua_key(cell);
 use_lua_key(char);
+use_lua_key(char_ghost);
+use_lua_key(char_given);
+use_lua_key(char_num);
+use_lua_key(character);
 use_lua_key(characters);
 use_lua_key(checksum);
+use_lua_key(choice);
 use_lua_key(cidinfo);
 use_lua_key(class);
+use_lua_key(cleaders);
+use_lua_key(close);
 use_lua_key(clubpenalty);
+use_lua_key(cmd);
+use_lua_key(cmdname);
+use_lua_key(color_stack);
 use_lua_key(colordepth);
 use_lua_key(colorspace);
+use_lua_key(combinetoks);
 use_lua_key(command);
 use_lua_key(commands);
 use_lua_key(comment);
 use_lua_key(components);
 use_lua_key(compresslevel);
+use_lua_key(conditionalmathskip);
 use_lua_key(contrib_head);
+use_lua_key(convert);
+use_lua_key(copy_font);
 use_lua_key(core);
 use_lua_key(cost);
 use_lua_key(count);
@@ -1342,11 +2078,21 @@ use_lua_key(crampedscript);
 use_lua_key(crampedscriptscript);
 use_lua_key(crampedtext);
 use_lua_key(crop);
+use_lua_key(cs_name);
 use_lua_key(csname);
+use_lua_key(current);
 use_lua_key(data);
+use_lua_key(def);
+use_lua_key(def_char_code);
+use_lua_key(def_del_code);
+use_lua_key(def_family);
+use_lua_key(def_font);
+use_lua_key(def_lua_call);
 use_lua_key(degree);
 use_lua_key(delim);
+use_lua_key(delim_num);
 use_lua_key(delimptr);
+use_lua_key(delta);
 use_lua_key(demerits);
 use_lua_key(denom);
 use_lua_key(depth);
@@ -1359,46 +2105,92 @@ use_lua_key(direct);
 use_lua_key(direction);
 use_lua_key(dirs);
 use_lua_key(disc);
+use_lua_key(discretionary);
 use_lua_key(display);
+use_lua_key(divide);
+use_lua_key(dont_expand);
 use_lua_key(doublehyphendemerits);
 use_lua_key(down);
 use_lua_key(embedding);
 use_lua_key(emergencystretch);
+use_lua_key(empty);
 use_lua_key(empty_string);
 use_lua_key(encodingbytes);
 use_lua_key(encodingname);
 use_lua_key(end);
-use_lua_key(etex);
+use_lua_key(end_cs_name);
+use_lua_key(end_group);
+use_lua_key(end_template);
+use_lua_key(endmath);
+use_lua_key(endv);
+use_lua_key(eq_no);
 use_lua_key(equation);\
 use_lua_key(equation_number);\
+use_lua_key(equationnumber);
+use_lua_key(equationnumberpenalty);
+use_lua_key(etex);
+use_lua_key(ex_space);
 use_lua_key(exactly);
+use_lua_key(expand_after);
+use_lua_key(expand_font);
+use_lua_key(expandable);
 use_lua_key(expansion_factor);
+use_lua_key(explicit);
+use_lua_key(expr_stack);
 use_lua_key(ext);
+use_lua_key(extdef_del_code);
+use_lua_key(extdef_math_code);
 use_lua_key(extend);
 use_lua_key(extender);
 use_lua_key(extensible);
+use_lua_key(extension);
 use_lua_key(extra_space);
 use_lua_key(fam);
 use_lua_key(fast);
+use_lua_key(feedback);
 use_lua_key(fence);
+use_lua_key(fi);
+use_lua_key(fi_or_else);
+use_lua_key(fil);
 use_lua_key(file);
 use_lua_key(filename);
 use_lua_key(filepath);
 use_lua_key(fill);
+use_lua_key(filll);
+use_lua_key(fillll);
 use_lua_key(fin_row);
 use_lua_key(finalhyphendemerits);
+use_lua_key(finalpenalty);
+use_lua_key(first);
+use_lua_key(fit);
+use_lua_key(fitb);
+use_lua_key(fitbh);
+use_lua_key(fitbv);
+use_lua_key(fith);
+use_lua_key(fitr);
+use_lua_key(fitv);
+use_lua_key(fixedboth);
+use_lua_key(fixedbottom);
+use_lua_key(fixedtop);
 use_lua_key(font);
+use_lua_key(fontkern);
 use_lua_key(fonts);
 use_lua_key(format);
 use_lua_key(fraction);
 use_lua_key(fullname);
+use_lua_key(ghost);
+use_lua_key(gleaders);
 use_lua_key(global);
 use_lua_key(glue);
 use_lua_key(glue_order);
+use_lua_key(glue_ref);
 use_lua_key(glue_set);
 use_lua_key(glue_sign);
+use_lua_key(glue_spec);
 use_lua_key(glyph);
+use_lua_key(goto);
 use_lua_key(h);
+use_lua_key(halign);
 use_lua_key(hangafter);
 use_lua_key(hangindent);
 use_lua_key(hbox);
@@ -1406,20 +2198,37 @@ use_lua_key(head);
 use_lua_key(height);
 use_lua_key(hlist);
 use_lua_key(hmode_par);
+use_lua_key(hmove);
 use_lua_key(hold_head);
 use_lua_key(horiz_variants);
+use_lua_key(hrule);
 use_lua_key(hsize);
+use_lua_key(hskip);
+use_lua_key(hyph_data);
+use_lua_key(hyphenated);
 use_lua_key(hyphenchar);
 use_lua_key(id);
 use_lua_key(identity);
+use_lua_key(if_stack);
+use_lua_key(if_test);
+use_lua_key(ignore_spaces);
 use_lua_key(image);
 use_lua_key(imagetype);
 use_lua_key(immediate);
+use_lua_key(in_stream);
+use_lua_key(indent);
 use_lua_key(index);
 use_lua_key(info);
+use_lua_key(Info);
+use_lua_key(inner);
+use_lua_key(input);
+use_lua_key(ins);
 use_lua_key(insert);
+use_lua_key(inserts_only);
 use_lua_key(interlinepenalty);
+use_lua_key(ital_corr);
 use_lua_key(italic);
+use_lua_key(italiccorrection);
 use_lua_key(keepopen);
 use_lua_key(kern);
 use_lua_key(kerns);
@@ -1427,95 +2236,191 @@ use_lua_key(lang);
 use_lua_key(large_char);
 use_lua_key(large_fam);
 use_lua_key(last_ins_ptr);
+use_lua_key(last_item);
 use_lua_key(lastlinefit);
+use_lua_key(late_lua);
 use_lua_key(leader);
+use_lua_key(leader_ship);
+use_lua_key(leaders);
 use_lua_key(least_page_cost);
 use_lua_key(left);
 use_lua_key(left_boundary);
+use_lua_key(left_brace);
 use_lua_key(left_protruding);
+use_lua_key(left_right);
 use_lua_key(leftskip);
+use_lua_key(let);
+use_lua_key(letter);
+use_lua_key(letterspace_font);
 use_lua_key(level);
+use_lua_key(ligature);
 use_lua_key(ligatures);
+use_lua_key(limit_switch);
+use_lua_key(line);
+use_lua_key(linebreakpenalty);
 use_lua_key(linepenalty);
+use_lua_key(lineskip);
 use_lua_key(link_attr);
 use_lua_key(list);
 use_lua_key(local_box);
+use_lua_key(local_par);
 use_lua_key(log);
+use_lua_key(long_call);
+use_lua_key(long_outer_call);
 use_lua_key(looseness);
+use_lua_key(LTL);
 use_lua_key(lua);
+use_lua_key(lua_bytecode_call);
 use_lua_key(lua_bytecodes_indirect);
+use_lua_key(lua_call);
+use_lua_key(lua_expandable_call);
+use_lua_key(lua_local_call);
+use_lua_key(lua_function_call);
 use_lua_key(lua_functions);
 use_lua_key(luatex);
 use_lua_key(luatex_node);
 use_lua_key(luatex_token);
-use_lua_key(mLTL);
-use_lua_key(mRTT);
-use_lua_key(mTLT);
-use_lua_key(mTRT);
+use_lua_key(luatex_pdfe);
+use_lua_key(luatex_pdfe_dictionary);
+use_lua_key(luatex_pdfe_array);
+use_lua_key(luatex_pdfe_stream);
+use_lua_key(luatex_pdfe_reference);
+use_lua_key(mac_param);
+use_lua_key(make_box);
+use_lua_key(margin_kern);
 use_lua_key(marginkern);
 use_lua_key(mark);
 use_lua_key(math);
+use_lua_key(math_accent);
+use_lua_key(math_char);
+use_lua_key(math_char_num);
 use_lua_key(math_choice);
+use_lua_key(math_comp);
+use_lua_key(math_given);
 use_lua_key(math_left);
 use_lua_key(math_shift);
+use_lua_key(math_shift_cs);
+use_lua_key(math_style);
+use_lua_key(math_sub_box);
+use_lua_key(math_sub_mlist);
+use_lua_key(math_text_char);
+use_lua_key(MathConstants);
 use_lua_key(mathdir);
 use_lua_key(mathkern);
+use_lua_key(mathskip);
 use_lua_key(mathstyle);
 use_lua_key(media);
+use_lua_key(medmuskip);
+use_lua_key(message);
 use_lua_key(mid);
 use_lua_key(middle);
+use_lua_key(mkern);
+use_lua_key(mLTL);
 use_lua_key(mode);
 use_lua_key(modeline);
+use_lua_key(movement_stack);
+use_lua_key(mRTT);
+use_lua_key(mskip);
+use_lua_key(mTLT);
+use_lua_key(mTRT);
+use_lua_key(muglue);
+use_lua_key(multiply);
 use_lua_key(name);
 use_lua_key(named_id);
 use_lua_key(names);
+use_lua_key(nested_list);
+use_lua_key(new);
 use_lua_key(new_graf);
 use_lua_key(new_window);
 use_lua_key(next);
 use_lua_key(no);
+use_lua_key(nolength);
 use_lua_key(no_align);
+use_lua_key(no_expand);
+use_lua_key(no_super_sub_script);
 use_lua_key(noad);
+use_lua_key(noadpenalty);
 use_lua_key(node);
 use_lua_key(node_properties);
 use_lua_key(node_properties_indirect);
+use_lua_key(nohrule);
 use_lua_key(nomath);
+use_lua_key(non_script);
 use_lua_key(none);
+use_lua_key(nonew);
 use_lua_key(nop);
+use_lua_key(normal);
+use_lua_key(novrule);
 use_lua_key(nucleus);
 use_lua_key(num);
 use_lua_key(number);
 use_lua_key(objcompression);
 use_lua_key(objnum);
 use_lua_key(oldmath);
+use_lua_key(omit);
+use_lua_key(opdisplaylimits);
+use_lua_key(open);
+use_lua_key(oplimits);
+use_lua_key(opnolimits);
+use_lua_key(option);
 use_lua_key(options);
+use_lua_key(ord);
+use_lua_key(ordering);
 use_lua_key(orientation);
 use_lua_key(origin);
-use_lua_key(ordering);
+use_lua_key(other_char);
+use_lua_key(outer_call);
+use_lua_key(outline);
 use_lua_key(output);
+use_lua_key(over);
 use_lua_key(overlay_accent);
-use_lua_key(pLTL);
-use_lua_key(pRTT);
-use_lua_key(pTLT);
-use_lua_key(pTRT);
+use_lua_key(ownerpassword);
 use_lua_key(page);
-use_lua_key(pages);
 use_lua_key(page_discards_head);
 use_lua_key(page_head);
 use_lua_key(page_ins_head);
-use_lua_key(pagebox);
+use_lua_key(page_insert);
 use_lua_key(pageattributes);
+use_lua_key(pagebox);
 use_lua_key(pageresources);
+use_lua_key(pages);
+use_lua_key(Pages);
 use_lua_key(pagesattributes);
+use_lua_key(pagestate);
+use_lua_key(par_end);
 use_lua_key(parameters);
 use_lua_key(pardir);
+use_lua_key(parfillskip);
 use_lua_key(parshape);
+use_lua_key(parskip);
+use_lua_key(passive);
 use_lua_key(pdf);
+use_lua_key(pdfe);
+use_lua_key(pdf_action);
+use_lua_key(pdf_annot);
+use_lua_key(pdf_colorstack);
 use_lua_key(pdf_data);
+use_lua_key(pdf_dest);
 use_lua_key(pdf_destination);
+use_lua_key(pdf_end_link);
+use_lua_key(pdf_end_thread);
+use_lua_key(pdf_link_data);
 use_lua_key(pdf_literal);
+use_lua_key(pdf_refobj);
+use_lua_key(pdf_restore);
+use_lua_key(pdf_save);
+use_lua_key(pdf_setmatrix);
+use_lua_key(pdf_setobj);
+use_lua_key(pdf_start);
+use_lua_key(pdf_start_link);
+use_lua_key(pdf_start_thread);
+use_lua_key(pdf_thread);
+use_lua_key(pdf_thread_data);
+use_lua_key(pdf_window);
 use_lua_key(pen_broken);
 use_lua_key(pen_inter);
 use_lua_key(penalty);
+use_lua_key(pLTL);
 use_lua_key(pop);
 use_lua_key(post);
 use_lua_key(post_linebreak);
@@ -1525,35 +2430,71 @@ use_lua_key(pre_adjust_head);
 use_lua_key(pre_align);
 use_lua_key(pre_box);
 use_lua_key(preamble);
+use_lua_key(prefix);
 use_lua_key(pretolerance);
 use_lua_key(prev);
 use_lua_key(prevdepth);
 use_lua_key(prevgraf);
+use_lua_key(protected);
 use_lua_key(protrudechars);
+use_lua_key(protrusion);
+use_lua_key(pRTT);
+use_lua_key(pseudo_file);
+use_lua_key(pseudo_line);
 use_lua_key(psname);
+use_lua_key(pTLT);
 use_lua_key(ptr);
+use_lua_key(pTRT);
+use_lua_key(punct);
 use_lua_key(push);
 use_lua_key(quad);
 use_lua_key(radical);
 use_lua_key(raw);
+use_lua_key(read_to_cs);
 use_lua_key(ref_count);
+use_lua_key(recompress);
 use_lua_key(reg);
+use_lua_key(register);
 use_lua_key(registry);
+use_lua_key(regular);
+use_lua_key(rel);
+use_lua_key(relax);
+use_lua_key(remove_item);
 use_lua_key(renew);
 use_lua_key(rep);
 use_lua_key(replace);
 use_lua_key(resources);
 use_lua_key(right);
 use_lua_key(right_boundary);
+use_lua_key(right_brace);
 use_lua_key(right_protruding);
 use_lua_key(rightskip);
 use_lua_key(rotation);
+use_lua_key(RTT);
 use_lua_key(rule);
+use_lua_key(save_pos);
 use_lua_key(scale);
 use_lua_key(script);
 use_lua_key(scriptscript);
+use_lua_key(second);
 use_lua_key(semi_simple);
+use_lua_key(set);
+use_lua_key(set_aux);
+use_lua_key(set_box);
+use_lua_key(set_box_dimen);
+use_lua_key(set_etex_shape);
+use_lua_key(set_font);
+use_lua_key(set_font_id);
+use_lua_key(set_interaction);
+use_lua_key(set_math_param);
+use_lua_key(set_page_dimen);
+use_lua_key(set_page_int);
+use_lua_key(set_prev_graf);
+use_lua_key(set_tex_shape);
+use_lua_key(shape);
+use_lua_key(shape_ref);
 use_lua_key(shift);
+use_lua_key(shorthand_def);
 use_lua_key(shrink);
 use_lua_key(shrink_order);
 use_lua_key(simple);
@@ -1567,13 +2508,22 @@ use_lua_key(space);
 use_lua_key(space_shrink);
 use_lua_key(space_stretch);
 use_lua_key(spacefactor);
+use_lua_key(spacer);
+use_lua_key(spaceskip);
+use_lua_key(span);
+use_lua_key(spec);
 use_lua_key(special);
 use_lua_key(split_discards_head);
+use_lua_key(split_insert);
 use_lua_key(split_keep);
 use_lua_key(split_off);
+use_lua_key(splittopskip);
+use_lua_key(squeeze);
 use_lua_key(stack);
 use_lua_key(start);
+use_lua_key(start_par);
 use_lua_key(step);
+use_lua_key(stop);
 use_lua_key(stream);
 use_lua_key(streamfile);
 use_lua_key(streamprovider);
@@ -1582,60 +2532,111 @@ use_lua_key(stretch_order);
 use_lua_key(string);
 use_lua_key(style);
 use_lua_key(sub);
+use_lua_key(sub_box);
+use_lua_key(sub_mark);
+use_lua_key(sub_mlist);
 use_lua_key(subst_ex_font);
 use_lua_key(subtype);
 use_lua_key(sup);
+use_lua_key(sup_mark);
+use_lua_key(super_sub_script);
 use_lua_key(supplement);
 use_lua_key(surround);
+use_lua_key(tab_mark);
+use_lua_key(tabskip);
 use_lua_key(tail);
+use_lua_key(temp);
 use_lua_key(temp_head);
 use_lua_key(term);
 use_lua_key(term_and_log);
 use_lua_key(tex);
 use_lua_key(text);
+use_lua_key(the);
+use_lua_key(thickmuskip);
+use_lua_key(thinmuskip);
+use_lua_key(thread);
 use_lua_key(thread_attr);
 use_lua_key(thread_id);
-use_lua_key(tolerance);
+use_lua_key(TLT);
 use_lua_key(tok);
 use_lua_key(token);
+use_lua_key(toks_register);
+use_lua_key(tolerance);
 use_lua_key(top);
 use_lua_key(top_accent);
+use_lua_key(top_bot_mark);
 use_lua_key(top_left);
 use_lua_key(top_right);
+use_lua_key(topskip);
 use_lua_key(tounicode);
 use_lua_key(tracingparagraphs);
 use_lua_key(trailer);
+use_lua_key(Trailer);
 use_lua_key(trailerid);
 use_lua_key(transform);
 use_lua_key(trim);
+use_lua_key(TRT);
 use_lua_key(type);
 use_lua_key(uchyph);
+use_lua_key(udelimiterover);
+use_lua_key(udelimiterunder);
+use_lua_key(un_hbox);
+use_lua_key(un_vbox);
+use_lua_key(undefined_cs);
+use_lua_key(under);
+use_lua_key(unhyphenated);
 use_lua_key(units_per_em);
+use_lua_key(unknown);
+use_lua_key(unset);
+use_lua_key(uoverdelimiter);
+use_lua_key(uradical);
+use_lua_key(uroot);
 use_lua_key(used);
+use_lua_key(user);
+use_lua_key(userpassword);
+use_lua_key(user_defined);
 use_lua_key(user_id);
+use_lua_key(userkern);
+use_lua_key(userpenalty);
+use_lua_key(userskip);
+use_lua_key(uunderdelimiter);
 use_lua_key(v);
+use_lua_key(vadjust);
+use_lua_key(valign);
 use_lua_key(value);
+use_lua_key(variable);
 use_lua_key(vbox);
 use_lua_key(vcenter);
 use_lua_key(version);
 use_lua_key(vert_italic);
 use_lua_key(vert_variants);
-use_lua_key(vmode_par);
 use_lua_key(visiblefilename);
 use_lua_key(vlist);
+use_lua_key(vmode_par);
+use_lua_key(vmove);
+use_lua_key(vrule);
+use_lua_key(vskip);
 use_lua_key(vtop);
+use_lua_key(whatsit);
 use_lua_key(widowpenalty);
 use_lua_key(width);
+use_lua_key(word);
+use_lua_key(wordpenalty);
+use_lua_key(write);
+use_lua_key(writingmode);
 use_lua_key(x_height);
 use_lua_key(xadvance);
-use_lua_key(xformresources);
 use_lua_key(xformattributes);
+use_lua_key(xformresources);
+use_lua_key(xleaders);
+use_lua_key(xmath_given);
 use_lua_key(xoffset);
+use_lua_key(xray);
 use_lua_key(xres);
 use_lua_key(xsize);
+use_lua_key(xspaceskip);
+use_lua_key(xyz);
 use_lua_key(xyz_zoom);
 use_lua_key(yoffset);
 use_lua_key(yres);
 use_lua_key(ysize);
-use_lua_key(writingmode);
-use_lua_key(__index);
diff --git a/texk/web2c/luatexdir/lua/luatex-core.c b/texk/web2c/luatexdir/lua/luatex-core.c
index 6551b0bc4..5cb58af65 100644
--- a/texk/web2c/luatexdir/lua/luatex-core.c
+++ b/texk/web2c/luatexdir/lua/luatex-core.c
@@ -17,7 +17,7 @@ int load_luatex_core_lua (lua_State * L)
     0x6f, 0x64, 0x75, 0x6c, 0x65, 0x73, 0x20, 0x5b, 0x27, 0x6c, 0x75, 0x61, 0x74, 0x65, 0x78, 0x2d,
     0x63, 0x6f, 0x72, 0x65, 0x27, 0x5d, 0x20, 0x3d, 0x20, 0x7b, 0x0a, 0x2d, 0x2d, 0x20, 0x20, 0x20,
     0x20, 0x20, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x20, 0x20, 0x20, 0x3d, 0x20, 0x31, 0x2e,
-    0x30, 0x30, 0x35, 0x2c, 0x0a, 0x2d, 0x2d, 0x20, 0x20, 0x20, 0x20, 0x20, 0x63, 0x6f, 0x6d, 0x6d,
+    0x30, 0x38, 0x30, 0x2c, 0x0a, 0x2d, 0x2d, 0x20, 0x20, 0x20, 0x20, 0x20, 0x63, 0x6f, 0x6d, 0x6d,
     0x65, 0x6e, 0x74, 0x20, 0x20, 0x20, 0x3d, 0x20, 0x27, 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x6e, 0x69,
     0x6f, 0x6e, 0x20, 0x74, 0x6f, 0x20, 0x6c, 0x75, 0x61, 0x74, 0x65, 0x78, 0x27, 0x2c, 0x0a, 0x2d,
     0x2d, 0x20, 0x20, 0x20, 0x20, 0x20, 0x61, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x20, 0x20, 0x20, 0x20,
@@ -27,536 +27,609 @@ int load_luatex_core_lua (lua_State * L)
     0x3d, 0x20, 0x27, 0x4c, 0x75, 0x61, 0x54, 0x65, 0x58, 0x20, 0x44, 0x65, 0x76, 0x65, 0x6c, 0x6f,
     0x70, 0x6d, 0x65, 0x6e, 0x74, 0x20, 0x54, 0x65, 0x61, 0x6d, 0x27, 0x2c, 0x0a, 0x2d, 0x2d, 0x20,
     0x7d, 0x0a, 0x0a, 0x4c, 0x55, 0x41, 0x54, 0x45, 0x58, 0x43, 0x4f, 0x52, 0x45, 0x56, 0x45, 0x52,
-    0x53, 0x49, 0x4f, 0x4e, 0x20, 0x3d, 0x20, 0x31, 0x2e, 0x30, 0x30, 0x35, 0x0a, 0x0a, 0x2d, 0x2d,
-    0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69, 0x6c, 0x65, 0x20, 0x6f, 0x76, 0x65, 0x72, 0x6c,
-    0x6f, 0x61, 0x64, 0x73, 0x20, 0x73, 0x6f, 0x6d, 0x65, 0x20, 0x4c, 0x75, 0x61, 0x20, 0x66, 0x75,
-    0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x20, 0x54, 0x68, 0x65, 0x20, 0x72, 0x65, 0x61,
-    0x64, 0x6c, 0x69, 0x6e, 0x65, 0x20, 0x76, 0x61, 0x72, 0x69, 0x61, 0x6e, 0x74, 0x73, 0x20, 0x70,
-    0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x61, 0x6d, 0x65, 0x0a,
-    0x2d, 0x2d, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x69, 0x74, 0x79,
-    0x20, 0x61, 0x73, 0x20, 0x4c, 0x75, 0x61, 0x54, 0x65, 0x58, 0x20, 0x3c, 0x3d, 0x20, 0x31, 0x2e,
-    0x30, 0x34, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x64, 0x6f, 0x69, 0x6e, 0x67, 0x20, 0x69, 0x74, 0x20,
-    0x74, 0x68, 0x69, 0x73, 0x20, 0x77, 0x61, 0x79, 0x20, 0x70, 0x65, 0x72, 0x6d, 0x69, 0x74, 0x73,
-    0x20, 0x75, 0x73, 0x20, 0x74, 0x6f, 0x20, 0x6b, 0x65, 0x65, 0x70, 0x20, 0x74, 0x68, 0x65, 0x0a,
-    0x2d, 0x2d, 0x20, 0x6f, 0x72, 0x69, 0x67, 0x69, 0x6e, 0x61, 0x6c, 0x20, 0x69, 0x6f, 0x20, 0x6c,
-    0x69, 0x62, 0x72, 0x61, 0x72, 0x69, 0x65, 0x73, 0x20, 0x63, 0x6c, 0x65, 0x61, 0x6e, 0x2e, 0x20,
-    0x50, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x6e, 0x63, 0x65, 0x20, 0x69, 0x73, 0x20, 0x70,
-    0x72, 0x6f, 0x62, 0x61, 0x62, 0x6c, 0x79, 0x20, 0x65, 0x76, 0x65, 0x6e, 0x20, 0x61, 0x20, 0x62,
-    0x69, 0x74, 0x20, 0x62, 0x65, 0x74, 0x74, 0x65, 0x72, 0x20, 0x6e, 0x6f, 0x77, 0x2e, 0x0a, 0x0a,
-    0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x20, 0x74, 0x79, 0x70, 0x65, 0x2c, 0x20, 0x6e, 0x65, 0x78, 0x74,
-    0x2c, 0x20, 0x67, 0x65, 0x74, 0x6d, 0x65, 0x74, 0x61, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x2c, 0x20,
-    0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x20, 0x3d, 0x20, 0x74, 0x79, 0x70, 0x65, 0x2c, 0x20,
-    0x6e, 0x65, 0x78, 0x74, 0x2c, 0x20, 0x67, 0x65, 0x74, 0x6d, 0x65, 0x74, 0x61, 0x74, 0x61, 0x62,
-    0x6c, 0x65, 0x2c, 0x20, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x0a, 0x6c, 0x6f, 0x63, 0x61,
-    0x6c, 0x20, 0x66, 0x69, 0x6e, 0x64, 0x2c, 0x20, 0x67, 0x73, 0x75, 0x62, 0x2c, 0x20, 0x66, 0x6f,
-    0x72, 0x6d, 0x61, 0x74, 0x20, 0x3d, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x2e, 0x66, 0x69,
-    0x6e, 0x64, 0x2c, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x2e, 0x67, 0x73, 0x75, 0x62, 0x2c,
-    0x20, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x2e, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x0a, 0x0a,
-    0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x20, 0x69, 0x6f, 0x5f, 0x6f, 0x70, 0x65, 0x6e, 0x20, 0x20, 0x20,
-    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3d, 0x20, 0x69, 0x6f, 0x2e, 0x6f,
-    0x70, 0x65, 0x6e, 0x0a, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x20, 0x69, 0x6f, 0x5f, 0x70, 0x6f, 0x70,
-    0x65, 0x6e, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3d, 0x20,
-    0x69, 0x6f, 0x2e, 0x70, 0x6f, 0x70, 0x65, 0x6e, 0x0a, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x20, 0x69,
-    0x6f, 0x5f, 0x6c, 0x69, 0x6e, 0x65, 0x73, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-    0x20, 0x20, 0x20, 0x3d, 0x20, 0x69, 0x6f, 0x2e, 0x6c, 0x69, 0x6e, 0x65, 0x73, 0x0a, 0x0a, 0x6c,
-    0x6f, 0x63, 0x61, 0x6c, 0x20, 0x66, 0x69, 0x6f, 0x5f, 0x72, 0x65, 0x61, 0x64, 0x6c, 0x69, 0x6e,
-    0x65, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3d, 0x20, 0x66, 0x69, 0x6f, 0x2e, 0x72,
-    0x65, 0x61, 0x64, 0x6c, 0x69, 0x6e, 0x65, 0x0a, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x20, 0x66, 0x69,
-    0x6f, 0x5f, 0x63, 0x68, 0x65, 0x63, 0x6b, 0x70, 0x65, 0x72, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f,
-    0x6e, 0x20, 0x3d, 0x20, 0x66, 0x69, 0x6f, 0x2e, 0x63, 0x68, 0x65, 0x63, 0x6b, 0x70, 0x65, 0x72,
-    0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x0a, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x20, 0x66, 0x69,
-    0x6f, 0x5f, 0x72, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x66, 0x69, 0x6c, 0x65, 0x6e, 0x61, 0x6d, 0x65,
-    0x20, 0x20, 0x3d, 0x20, 0x66, 0x69, 0x6f, 0x2e, 0x72, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x66, 0x69,
-    0x6c, 0x65, 0x6e, 0x61, 0x6d, 0x65, 0x0a, 0x0a, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x20, 0x6d, 0x74,
-    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-    0x20, 0x20, 0x3d, 0x20, 0x67, 0x65, 0x74, 0x6d, 0x65, 0x74, 0x61, 0x74, 0x61, 0x62, 0x6c, 0x65,
-    0x28, 0x69, 0x6f, 0x2e, 0x73, 0x74, 0x64, 0x65, 0x72, 0x72, 0x29, 0x0a, 0x6c, 0x6f, 0x63, 0x61,
-    0x6c, 0x20, 0x6d, 0x74, 0x5f, 0x6c, 0x69, 0x6e, 0x65, 0x73, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3d, 0x20, 0x6d, 0x74, 0x2e, 0x6c, 0x69, 0x6e, 0x65, 0x73,
-    0x0a, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x20, 0x73, 0x61, 0x66, 0x65, 0x72, 0x6f, 0x70, 0x74, 0x69,
-    0x6f, 0x6e, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3d, 0x20, 0x73, 0x74, 0x61,
-    0x74, 0x75, 0x73, 0x2e, 0x73, 0x61, 0x66, 0x65, 0x72, 0x5f, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e,
-    0x0a, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x20, 0x73, 0x68, 0x65, 0x6c, 0x6c, 0x65, 0x73, 0x63, 0x61,
-    0x70, 0x65, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3d, 0x20, 0x73, 0x74, 0x61,
-    0x74, 0x75, 0x73, 0x2e, 0x73, 0x68, 0x65, 0x6c, 0x6c, 0x5f, 0x65, 0x73, 0x63, 0x61, 0x70, 0x65,
-    0x20, 0x2d, 0x2d, 0x20, 0x30, 0x20, 0x28, 0x64, 0x69, 0x73, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x29,
-    0x20, 0x31, 0x20, 0x28, 0x61, 0x6e, 0x79, 0x74, 0x68, 0x69, 0x6e, 0x67, 0x29, 0x20, 0x32, 0x20,
-    0x28, 0x72, 0x65, 0x73, 0x74, 0x72, 0x69, 0x63, 0x74, 0x65, 0x64, 0x29, 0x0a, 0x6c, 0x6f, 0x63,
-    0x61, 0x6c, 0x20, 0x6b, 0x70, 0x73, 0x65, 0x75, 0x73, 0x65, 0x64, 0x20, 0x20, 0x20, 0x20, 0x20,
-    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3d, 0x20, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x2e,
-    0x6b, 0x70, 0x73, 0x65, 0x5f, 0x75, 0x73, 0x65, 0x64, 0x20, 0x20, 0x20, 0x20, 0x2d, 0x2d, 0x20,
-    0x30, 0x20, 0x31, 0x0a, 0x0a, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x20, 0x77, 0x72, 0x69, 0x74, 0x65,
-    0x5f, 0x6e, 0x6c, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3d,
-    0x20, 0x74, 0x65, 0x78, 0x69, 0x6f, 0x2e, 0x77, 0x72, 0x69, 0x74, 0x65, 0x5f, 0x6e, 0x6c, 0x0a,
-    0x0a, 0x69, 0x6f, 0x2e, 0x73, 0x61, 0x76, 0x65, 0x64, 0x5f, 0x6c, 0x69, 0x6e, 0x65, 0x73, 0x20,
-    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3d, 0x20, 0x69, 0x6f, 0x5f,
-    0x6c, 0x69, 0x6e, 0x65, 0x73, 0x20, 0x2d, 0x2d, 0x20, 0x61, 0x6c, 0x77, 0x61, 0x79, 0x73, 0x20,
-    0x72, 0x65, 0x61, 0x64, 0x6f, 0x6e, 0x6c, 0x79, 0x0a, 0x6d, 0x74, 0x2e, 0x73, 0x61, 0x76, 0x65,
-    0x64, 0x5f, 0x6c, 0x69, 0x6e, 0x65, 0x73, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-    0x20, 0x20, 0x20, 0x3d, 0x20, 0x6d, 0x74, 0x5f, 0x6c, 0x69, 0x6e, 0x65, 0x73, 0x20, 0x2d, 0x2d,
-    0x20, 0x61, 0x6c, 0x77, 0x61, 0x79, 0x73, 0x20, 0x72, 0x65, 0x61, 0x64, 0x6f, 0x6e, 0x6c, 0x79,
-    0x0a, 0x0a, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e,
-    0x20, 0x6c, 0x75, 0x61, 0x74, 0x65, 0x78, 0x5f, 0x69, 0x6f, 0x5f, 0x6f, 0x70, 0x65, 0x6e, 0x28,
-    0x6e, 0x61, 0x6d, 0x65, 0x2c, 0x68, 0x6f, 0x77, 0x29, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x69, 0x66,
-    0x20, 0x6e, 0x6f, 0x74, 0x20, 0x68, 0x6f, 0x77, 0x20, 0x74, 0x68, 0x65, 0x6e, 0x0a, 0x20, 0x20,
-    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x68, 0x6f, 0x77, 0x20, 0x3d, 0x20, 0x27, 0x72, 0x27, 0x0a,
-    0x20, 0x20, 0x20, 0x20, 0x65, 0x6e, 0x64, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x6c, 0x6f, 0x63, 0x61,
-    0x6c, 0x20, 0x66, 0x20, 0x3d, 0x20, 0x69, 0x6f, 0x5f, 0x6f, 0x70, 0x65, 0x6e, 0x28, 0x6e, 0x61,
-    0x6d, 0x65, 0x2c, 0x68, 0x6f, 0x77, 0x29, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x69, 0x66, 0x20, 0x66,
-    0x20, 0x74, 0x68, 0x65, 0x6e, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x69, 0x66,
-    0x20, 0x74, 0x79, 0x70, 0x65, 0x28, 0x68, 0x6f, 0x77, 0x29, 0x20, 0x3d, 0x3d, 0x20, 0x27, 0x73,
-    0x74, 0x72, 0x69, 0x6e, 0x67, 0x27, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x66, 0x69, 0x6e, 0x64, 0x28,
-    0x68, 0x6f, 0x77, 0x2c, 0x27, 0x77, 0x27, 0x29, 0x20, 0x74, 0x68, 0x65, 0x6e, 0x0a, 0x20, 0x20,
-    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x66, 0x69, 0x6f, 0x5f, 0x72, 0x65,
-    0x63, 0x6f, 0x72, 0x64, 0x66, 0x69, 0x6c, 0x65, 0x6e, 0x61, 0x6d, 0x65, 0x28, 0x6e, 0x61, 0x6d,
-    0x65, 0x2c, 0x27, 0x77, 0x27, 0x29, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x65,
-    0x6c, 0x73, 0x65, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-    0x66, 0x69, 0x6f, 0x5f, 0x72, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x66, 0x69, 0x6c, 0x65, 0x6e, 0x61,
-    0x6d, 0x65, 0x28, 0x6e, 0x61, 0x6d, 0x65, 0x2c, 0x27, 0x72, 0x27, 0x29, 0x0a, 0x20, 0x20, 0x20,
-    0x20, 0x20, 0x20, 0x20, 0x20, 0x65, 0x6e, 0x64, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x65, 0x6e, 0x64,
-    0x0a, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x66, 0x0a, 0x65, 0x6e,
-    0x64, 0x0a, 0x0a, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f,
-    0x6e, 0x20, 0x6c, 0x75, 0x61, 0x74, 0x65, 0x78, 0x5f, 0x69, 0x6f, 0x5f, 0x6f, 0x70, 0x65, 0x6e,
-    0x5f, 0x72, 0x65, 0x61, 0x64, 0x6f, 0x6e, 0x6c, 0x79, 0x28, 0x6e, 0x61, 0x6d, 0x65, 0x2c, 0x68,
-    0x6f, 0x77, 0x29, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x69, 0x66, 0x20, 0x68, 0x6f, 0x77, 0x20, 0x74,
-    0x68, 0x65, 0x6e, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x68, 0x6f, 0x77, 0x20,
-    0x3d, 0x20, 0x27, 0x72, 0x27, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x65, 0x6c, 0x73, 0x65, 0x0a, 0x20,
-    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x68, 0x6f, 0x77, 0x20, 0x3d, 0x20, 0x67, 0x73, 0x75,
-    0x62, 0x28, 0x68, 0x6f, 0x77, 0x2c, 0x27, 0x5b, 0x5e, 0x72, 0x62, 0x5d, 0x27, 0x2c, 0x27, 0x27,
-    0x29, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x69, 0x66, 0x20, 0x68, 0x6f, 0x77,
-    0x20, 0x3d, 0x3d, 0x20, 0x27, 0x27, 0x20, 0x74, 0x68, 0x65, 0x6e, 0x0a, 0x20, 0x20, 0x20, 0x20,
-    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x68, 0x6f, 0x77, 0x20, 0x3d, 0x20, 0x27, 0x72,
-    0x27, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x65, 0x6e, 0x64, 0x0a, 0x20, 0x20,
-    0x20, 0x20, 0x65, 0x6e, 0x64, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x20,
-    0x66, 0x20, 0x3d, 0x20, 0x69, 0x6f, 0x5f, 0x6f, 0x70, 0x65, 0x6e, 0x28, 0x6e, 0x61, 0x6d, 0x65,
-    0x2c, 0x68, 0x6f, 0x77, 0x29, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x69, 0x66, 0x20, 0x66, 0x20, 0x74,
-    0x68, 0x65, 0x6e, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x66, 0x69, 0x6f, 0x5f,
-    0x72, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x66, 0x69, 0x6c, 0x65, 0x6e, 0x61, 0x6d, 0x65, 0x28, 0x6e,
-    0x61, 0x6d, 0x65, 0x2c, 0x27, 0x72, 0x27, 0x29, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x65, 0x6e, 0x64,
-    0x0a, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x66, 0x0a, 0x65, 0x6e,
-    0x64, 0x0a, 0x0a, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f,
-    0x6e, 0x20, 0x6c, 0x75, 0x61, 0x74, 0x65, 0x78, 0x5f, 0x69, 0x6f, 0x5f, 0x70, 0x6f, 0x70, 0x65,
-    0x6e, 0x28, 0x6e, 0x61, 0x6d, 0x65, 0x2c, 0x2e, 0x2e, 0x2e, 0x29, 0x0a, 0x20, 0x20, 0x20, 0x20,
-    0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x20, 0x6f, 0x6b, 0x61, 0x79, 0x2c, 0x20, 0x66, 0x6f, 0x75, 0x6e,
-    0x64, 0x20, 0x3d, 0x20, 0x66, 0x69, 0x6f, 0x5f, 0x63, 0x68, 0x65, 0x63, 0x6b, 0x70, 0x65, 0x72,
-    0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x28, 0x6e, 0x61, 0x6d, 0x65, 0x29, 0x0a, 0x20, 0x20,
-    0x20, 0x20, 0x69, 0x66, 0x20, 0x6f, 0x6b, 0x61, 0x79, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x66, 0x6f,
-    0x75, 0x6e, 0x64, 0x20, 0x74, 0x68, 0x65, 0x6e, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-    0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x69, 0x6f, 0x5f, 0x70, 0x6f, 0x70, 0x65, 0x6e,
-    0x28, 0x66, 0x6f, 0x75, 0x6e, 0x64, 0x2c, 0x2e, 0x2e, 0x2e, 0x29, 0x0a, 0x20, 0x20, 0x20, 0x20,
-    0x65, 0x6e, 0x64, 0x0a, 0x65, 0x6e, 0x64, 0x0a, 0x0a, 0x2d, 0x2d, 0x20, 0x6c, 0x6f, 0x63, 0x61,
-    0x6c, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6c, 0x75, 0x61, 0x74, 0x65,
-    0x78, 0x5f, 0x69, 0x6f, 0x5f, 0x6c, 0x69, 0x6e, 0x65, 0x73, 0x28, 0x6e, 0x61, 0x6d, 0x65, 0x2c,
-    0x68, 0x6f, 0x77, 0x29, 0x0a, 0x2d, 0x2d, 0x20, 0x20, 0x20, 0x20, 0x20, 0x69, 0x66, 0x20, 0x6e,
-    0x61, 0x6d, 0x65, 0x20, 0x74, 0x68, 0x65, 0x6e, 0x0a, 0x2d, 0x2d, 0x20, 0x20, 0x20, 0x20, 0x20,
-    0x20, 0x20, 0x20, 0x20, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x20, 0x66, 0x20, 0x3d, 0x20, 0x69, 0x6f,
-    0x5f, 0x6f, 0x70, 0x65, 0x6e, 0x28, 0x6e, 0x61, 0x6d, 0x65, 0x2c, 0x68, 0x6f, 0x77, 0x20, 0x6f,
-    0x72, 0x20, 0x27, 0x72, 0x27, 0x29, 0x0a, 0x2d, 0x2d, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-    0x20, 0x20, 0x69, 0x66, 0x20, 0x66, 0x20, 0x74, 0x68, 0x65, 0x6e, 0x0a, 0x2d, 0x2d, 0x20, 0x20,
-    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72,
-    0x6e, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x29, 0x0a, 0x2d, 0x2d, 0x20,
-    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-    0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x66, 0x69, 0x6f, 0x5f, 0x72, 0x65, 0x61, 0x64, 0x6c,
-    0x69, 0x6e, 0x65, 0x28, 0x66, 0x29, 0x0a, 0x2d, 0x2d, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x65, 0x6e, 0x64, 0x0a, 0x2d, 0x2d, 0x20, 0x20, 0x20, 0x20,
-    0x20, 0x20, 0x20, 0x20, 0x20, 0x65, 0x6e, 0x64, 0x0a, 0x2d, 0x2d, 0x20, 0x20, 0x20, 0x20, 0x20,
-    0x65, 0x6c, 0x73, 0x65, 0x0a, 0x2d, 0x2d, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-    0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x69, 0x6f, 0x5f, 0x6c, 0x69, 0x6e, 0x65, 0x73, 0x28,
-    0x29, 0x0a, 0x2d, 0x2d, 0x20, 0x20, 0x20, 0x20, 0x20, 0x65, 0x6e, 0x64, 0x0a, 0x2d, 0x2d, 0x20,
-    0x65, 0x6e, 0x64, 0x0a, 0x0a, 0x2d, 0x2d, 0x20, 0x46, 0x6f, 0x72, 0x20, 0x73, 0x6f, 0x6d, 0x65,
-    0x20, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x67, 0x63, 0x20, 0x64,
-    0x6f, 0x65, 0x73, 0x6e, 0x27, 0x74, 0x20, 0x6b, 0x69, 0x63, 0x6b, 0x20, 0x69, 0x6e, 0x20, 0x73,
-    0x6f, 0x20, 0x77, 0x65, 0x20, 0x6e, 0x65, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20, 0x63, 0x6c, 0x6f,
-    0x73, 0x65, 0x20, 0x65, 0x78, 0x70, 0x6c, 0x69, 0x74, 0x6c, 0x79, 0x0a, 0x2d, 0x2d, 0x20, 0x73,
-    0x6f, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x68, 0x61, 0x6e, 0x64, 0x6c,
-    0x65, 0x20, 0x69, 0x73, 0x20, 0x66, 0x6c, 0x75, 0x73, 0x68, 0x65, 0x64, 0x2e, 0x0a, 0x0a, 0x6c,
-    0x6f, 0x63, 0x61, 0x6c, 0x20, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x2c, 0x20, 0x74, 0x79, 0x70, 0x65,
-    0x20, 0x3d, 0x20, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x2c, 0x20, 0x74, 0x79, 0x70, 0x65, 0x0a, 0x0a,
-    0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6c,
-    0x75, 0x61, 0x74, 0x65, 0x78, 0x5f, 0x69, 0x6f, 0x5f, 0x6c, 0x69, 0x6e, 0x65, 0x73, 0x28, 0x6e,
-    0x61, 0x6d, 0x65, 0x2c, 0x68, 0x6f, 0x77, 0x29, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x69, 0x66, 0x20,
-    0x74, 0x79, 0x70, 0x65, 0x28, 0x6e, 0x61, 0x6d, 0x65, 0x29, 0x20, 0x3d, 0x3d, 0x20, 0x22, 0x73,
-    0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x20, 0x74, 0x68, 0x65, 0x6e, 0x0a, 0x20, 0x20, 0x20, 0x20,
-    0x20, 0x20, 0x20, 0x20, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x20, 0x66, 0x20, 0x3d, 0x20, 0x69, 0x6f,
-    0x5f, 0x6f, 0x70, 0x65, 0x6e, 0x28, 0x6e, 0x61, 0x6d, 0x65, 0x2c, 0x68, 0x6f, 0x77, 0x20, 0x6f,
-    0x72, 0x20, 0x27, 0x72, 0x27, 0x29, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x69,
+    0x53, 0x49, 0x4f, 0x4e, 0x20, 0x3d, 0x20, 0x31, 0x2e, 0x30, 0x38, 0x30, 0x20, 0x2d, 0x2d, 0x20,
+    0x77, 0x65, 0x20, 0x72, 0x65, 0x66, 0x6c, 0x65, 0x63, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x6c,
+    0x75, 0x61, 0x74, 0x65, 0x78, 0x20, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x20, 0x77, 0x68,
+    0x65, 0x72, 0x65, 0x20, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x73, 0x20, 0x68, 0x61, 0x70, 0x70,
+    0x65, 0x6e, 0x65, 0x64, 0x0a, 0x0a, 0x2d, 0x2d, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x66, 0x69,
+    0x6c, 0x65, 0x20, 0x6f, 0x76, 0x65, 0x72, 0x6c, 0x6f, 0x61, 0x64, 0x73, 0x20, 0x73, 0x6f, 0x6d,
+    0x65, 0x20, 0x4c, 0x75, 0x61, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e,
+    0x20, 0x54, 0x68, 0x65, 0x20, 0x72, 0x65, 0x61, 0x64, 0x6c, 0x69, 0x6e, 0x65, 0x20, 0x76, 0x61,
+    0x72, 0x69, 0x61, 0x6e, 0x74, 0x73, 0x20, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x20, 0x74,
+    0x68, 0x65, 0x20, 0x73, 0x61, 0x6d, 0x65, 0x0a, 0x2d, 0x2d, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74,
+    0x69, 0x6f, 0x6e, 0x61, 0x6c, 0x69, 0x74, 0x79, 0x20, 0x61, 0x73, 0x20, 0x4c, 0x75, 0x61, 0x54,
+    0x65, 0x58, 0x20, 0x3c, 0x3d, 0x20, 0x31, 0x2e, 0x30, 0x34, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x64,
+    0x6f, 0x69, 0x6e, 0x67, 0x20, 0x69, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x77, 0x61, 0x79,
+    0x20, 0x70, 0x65, 0x72, 0x6d, 0x69, 0x74, 0x73, 0x20, 0x75, 0x73, 0x20, 0x74, 0x6f, 0x20, 0x6b,
+    0x65, 0x65, 0x70, 0x20, 0x74, 0x68, 0x65, 0x0a, 0x2d, 0x2d, 0x20, 0x6f, 0x72, 0x69, 0x67, 0x69,
+    0x6e, 0x61, 0x6c, 0x20, 0x69, 0x6f, 0x20, 0x6c, 0x69, 0x62, 0x72, 0x61, 0x72, 0x69, 0x65, 0x73,
+    0x20, 0x63, 0x6c, 0x65, 0x61, 0x6e, 0x2e, 0x20, 0x50, 0x65, 0x72, 0x66, 0x6f, 0x72, 0x6d, 0x61,
+    0x6e, 0x63, 0x65, 0x20, 0x69, 0x73, 0x20, 0x70, 0x72, 0x6f, 0x62, 0x61, 0x62, 0x6c, 0x79, 0x20,
+    0x65, 0x76, 0x65, 0x6e, 0x20, 0x61, 0x20, 0x62, 0x69, 0x74, 0x20, 0x62, 0x65, 0x74, 0x74, 0x65,
+    0x72, 0x20, 0x6e, 0x6f, 0x77, 0x2e, 0x0a, 0x0a, 0x2d, 0x2d, 0x20, 0x57, 0x65, 0x20, 0x74, 0x65,
+    0x73, 0x74, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73,
+    0x20, 0x61, 0x6c, 0x72, 0x65, 0x61, 0x64, 0x79, 0x20, 0x62, 0x65, 0x69, 0x6e, 0x67, 0x20, 0x64,
+    0x65, 0x66, 0x69, 0x6e, 0x65, 0x64, 0x20, 0x73, 0x6f, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x77,
+    0x65, 0x20, 0x64, 0x6f, 0x6e, 0x27, 0x74, 0x20, 0x6f, 0x76, 0x65, 0x72, 0x6c, 0x6f, 0x61, 0x64,
+    0x20, 0x6f, 0x6e, 0x65, 0x73, 0x20, 0x74, 0x68, 0x61, 0x74, 0x0a, 0x2d, 0x2d, 0x20, 0x61, 0x72,
+    0x65, 0x20, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x64, 0x20, 0x69, 0x6e, 0x20, 0x74, 0x68,
+    0x65, 0x20, 0x73, 0x74, 0x61, 0x72, 0x74, 0x75, 0x70, 0x20, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74,
+    0x2e, 0x0a, 0x0a, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x20, 0x74, 0x79, 0x70, 0x65, 0x2c, 0x20, 0x6e,
+    0x65, 0x78, 0x74, 0x2c, 0x20, 0x67, 0x65, 0x74, 0x6d, 0x65, 0x74, 0x61, 0x74, 0x61, 0x62, 0x6c,
+    0x65, 0x2c, 0x20, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x20, 0x3d, 0x20, 0x74, 0x79, 0x70,
+    0x65, 0x2c, 0x20, 0x6e, 0x65, 0x78, 0x74, 0x2c, 0x20, 0x67, 0x65, 0x74, 0x6d, 0x65, 0x74, 0x61,
+    0x74, 0x61, 0x62, 0x6c, 0x65, 0x2c, 0x20, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x0a, 0x6c,
+    0x6f, 0x63, 0x61, 0x6c, 0x20, 0x66, 0x69, 0x6e, 0x64, 0x2c, 0x20, 0x67, 0x73, 0x75, 0x62, 0x2c,
+    0x20, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x20, 0x3d, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67,
+    0x2e, 0x66, 0x69, 0x6e, 0x64, 0x2c, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x2e, 0x67, 0x73,
+    0x75, 0x62, 0x2c, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x2e, 0x66, 0x6f, 0x72, 0x6d, 0x61,
+    0x74, 0x0a, 0x0a, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x20, 0x69, 0x6f, 0x5f, 0x6f, 0x70, 0x65, 0x6e,
+    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3d, 0x20, 0x69,
+    0x6f, 0x2e, 0x6f, 0x70, 0x65, 0x6e, 0x0a, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x20, 0x69, 0x6f, 0x5f,
+    0x70, 0x6f, 0x70, 0x65, 0x6e, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+    0x20, 0x3d, 0x20, 0x69, 0x6f, 0x2e, 0x70, 0x6f, 0x70, 0x65, 0x6e, 0x0a, 0x6c, 0x6f, 0x63, 0x61,
+    0x6c, 0x20, 0x69, 0x6f, 0x5f, 0x6c, 0x69, 0x6e, 0x65, 0x73, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3d, 0x20, 0x69, 0x6f, 0x2e, 0x6c, 0x69, 0x6e, 0x65, 0x73,
+    0x0a, 0x0a, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x20, 0x66, 0x69, 0x6f, 0x5f, 0x72, 0x65, 0x61, 0x64,
+    0x6c, 0x69, 0x6e, 0x65, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3d, 0x20, 0x66, 0x69,
+    0x6f, 0x2e, 0x72, 0x65, 0x61, 0x64, 0x6c, 0x69, 0x6e, 0x65, 0x0a, 0x6c, 0x6f, 0x63, 0x61, 0x6c,
+    0x20, 0x66, 0x69, 0x6f, 0x5f, 0x63, 0x68, 0x65, 0x63, 0x6b, 0x70, 0x65, 0x72, 0x6d, 0x69, 0x73,
+    0x73, 0x69, 0x6f, 0x6e, 0x20, 0x3d, 0x20, 0x66, 0x69, 0x6f, 0x2e, 0x63, 0x68, 0x65, 0x63, 0x6b,
+    0x70, 0x65, 0x72, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x0a, 0x6c, 0x6f, 0x63, 0x61, 0x6c,
+    0x20, 0x66, 0x69, 0x6f, 0x5f, 0x72, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x66, 0x69, 0x6c, 0x65, 0x6e,
+    0x61, 0x6d, 0x65, 0x20, 0x20, 0x3d, 0x20, 0x66, 0x69, 0x6f, 0x2e, 0x72, 0x65, 0x63, 0x6f, 0x72,
+    0x64, 0x66, 0x69, 0x6c, 0x65, 0x6e, 0x61, 0x6d, 0x65, 0x0a, 0x0a, 0x6c, 0x6f, 0x63, 0x61, 0x6c,
+    0x20, 0x6d, 0x74, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+    0x20, 0x20, 0x20, 0x20, 0x20, 0x3d, 0x20, 0x67, 0x65, 0x74, 0x6d, 0x65, 0x74, 0x61, 0x74, 0x61,
+    0x62, 0x6c, 0x65, 0x28, 0x69, 0x6f, 0x2e, 0x73, 0x74, 0x64, 0x65, 0x72, 0x72, 0x29, 0x0a, 0x6c,
+    0x6f, 0x63, 0x61, 0x6c, 0x20, 0x6d, 0x74, 0x5f, 0x6c, 0x69, 0x6e, 0x65, 0x73, 0x20, 0x20, 0x20,
+    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3d, 0x20, 0x6d, 0x74, 0x2e, 0x6c, 0x69,
+    0x6e, 0x65, 0x73, 0x0a, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x20, 0x73, 0x61, 0x66, 0x65, 0x72, 0x6f,
+    0x70, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3d, 0x20,
+    0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x2e, 0x73, 0x61, 0x66, 0x65, 0x72, 0x5f, 0x6f, 0x70, 0x74,
+    0x69, 0x6f, 0x6e, 0x0a, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x20, 0x73, 0x68, 0x65, 0x6c, 0x6c, 0x65,
+    0x73, 0x63, 0x61, 0x70, 0x65, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3d, 0x20,
+    0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x2e, 0x73, 0x68, 0x65, 0x6c, 0x6c, 0x5f, 0x65, 0x73, 0x63,
+    0x61, 0x70, 0x65, 0x20, 0x2d, 0x2d, 0x20, 0x30, 0x20, 0x28, 0x64, 0x69, 0x73, 0x61, 0x62, 0x6c,
+    0x65, 0x64, 0x29, 0x20, 0x31, 0x20, 0x28, 0x61, 0x6e, 0x79, 0x74, 0x68, 0x69, 0x6e, 0x67, 0x29,
+    0x20, 0x32, 0x20, 0x28, 0x72, 0x65, 0x73, 0x74, 0x72, 0x69, 0x63, 0x74, 0x65, 0x64, 0x29, 0x0a,
+    0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x20, 0x6b, 0x70, 0x73, 0x65, 0x75, 0x73, 0x65, 0x64, 0x20, 0x20,
+    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3d, 0x20, 0x73, 0x74, 0x61, 0x74,
+    0x75, 0x73, 0x2e, 0x6b, 0x70, 0x73, 0x65, 0x5f, 0x75, 0x73, 0x65, 0x64, 0x20, 0x20, 0x20, 0x20,
+    0x2d, 0x2d, 0x20, 0x30, 0x20, 0x31, 0x0a, 0x0a, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x20, 0x77, 0x72,
+    0x69, 0x74, 0x65, 0x5f, 0x6e, 0x6c, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+    0x20, 0x20, 0x3d, 0x20, 0x74, 0x65, 0x78, 0x69, 0x6f, 0x2e, 0x77, 0x72, 0x69, 0x74, 0x65, 0x5f,
+    0x6e, 0x6c, 0x0a, 0x0a, 0x69, 0x6f, 0x2e, 0x73, 0x61, 0x76, 0x65, 0x64, 0x5f, 0x6c, 0x69, 0x6e,
+    0x65, 0x73, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3d, 0x20,
+    0x69, 0x6f, 0x5f, 0x6c, 0x69, 0x6e, 0x65, 0x73, 0x20, 0x2d, 0x2d, 0x20, 0x61, 0x6c, 0x77, 0x61,
+    0x79, 0x73, 0x20, 0x72, 0x65, 0x61, 0x64, 0x6f, 0x6e, 0x6c, 0x79, 0x0a, 0x6d, 0x74, 0x2e, 0x73,
+    0x61, 0x76, 0x65, 0x64, 0x5f, 0x6c, 0x69, 0x6e, 0x65, 0x73, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3d, 0x20, 0x6d, 0x74, 0x5f, 0x6c, 0x69, 0x6e, 0x65, 0x73,
+    0x20, 0x2d, 0x2d, 0x20, 0x61, 0x6c, 0x77, 0x61, 0x79, 0x73, 0x20, 0x72, 0x65, 0x61, 0x64, 0x6f,
+    0x6e, 0x6c, 0x79, 0x0a, 0x0a, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74,
+    0x69, 0x6f, 0x6e, 0x20, 0x6c, 0x75, 0x61, 0x74, 0x65, 0x78, 0x5f, 0x69, 0x6f, 0x5f, 0x6f, 0x70,
+    0x65, 0x6e, 0x28, 0x6e, 0x61, 0x6d, 0x65, 0x2c, 0x68, 0x6f, 0x77, 0x29, 0x0a, 0x20, 0x20, 0x20,
+    0x20, 0x69, 0x66, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x68, 0x6f, 0x77, 0x20, 0x74, 0x68, 0x65, 0x6e,
+    0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x68, 0x6f, 0x77, 0x20, 0x3d, 0x20, 0x27,
+    0x72, 0x27, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x65, 0x6e, 0x64, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x6c,
+    0x6f, 0x63, 0x61, 0x6c, 0x20, 0x66, 0x20, 0x3d, 0x20, 0x69, 0x6f, 0x5f, 0x6f, 0x70, 0x65, 0x6e,
+    0x28, 0x6e, 0x61, 0x6d, 0x65, 0x2c, 0x68, 0x6f, 0x77, 0x29, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x69,
     0x66, 0x20, 0x66, 0x20, 0x74, 0x68, 0x65, 0x6e, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-    0x20, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x66, 0x75, 0x6e, 0x63,
-    0x74, 0x69, 0x6f, 0x6e, 0x28, 0x29, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x20, 0x6c, 0x20, 0x3d,
-    0x20, 0x66, 0x69, 0x6f, 0x5f, 0x72, 0x65, 0x61, 0x64, 0x6c, 0x69, 0x6e, 0x65, 0x28, 0x66, 0x29,
-    0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-    0x20, 0x69, 0x66, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x6c, 0x20, 0x74, 0x68, 0x65, 0x6e, 0x0a, 0x20,
-    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-    0x20, 0x20, 0x20, 0x66, 0x3a, 0x63, 0x6c, 0x6f, 0x73, 0x65, 0x28, 0x29, 0x0a, 0x20, 0x20, 0x20,
-    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x65, 0x6e, 0x64,
-    0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-    0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x6c, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x65, 0x6e, 0x64, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+    0x20, 0x69, 0x66, 0x20, 0x74, 0x79, 0x70, 0x65, 0x28, 0x68, 0x6f, 0x77, 0x29, 0x20, 0x3d, 0x3d,
+    0x20, 0x27, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x27, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x66, 0x69,
+    0x6e, 0x64, 0x28, 0x68, 0x6f, 0x77, 0x2c, 0x27, 0x77, 0x27, 0x29, 0x20, 0x74, 0x68, 0x65, 0x6e,
+    0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x66, 0x69, 0x6f,
+    0x5f, 0x72, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x66, 0x69, 0x6c, 0x65, 0x6e, 0x61, 0x6d, 0x65, 0x28,
+    0x6e, 0x61, 0x6d, 0x65, 0x2c, 0x27, 0x77, 0x27, 0x29, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
     0x20, 0x20, 0x65, 0x6c, 0x73, 0x65, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-    0x20, 0x20, 0x20, 0x2d, 0x2d, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x6f, 0x73, 0x65, 0x20,
-    0x77, 0x68, 0x6f, 0x20, 0x6c, 0x69, 0x6b, 0x65, 0x20, 0x69, 0x74, 0x20, 0x74, 0x68, 0x69, 0x73,
-    0x20, 0x77, 0x61, 0x79, 0x3a, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-    0x20, 0x20, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x28, 0x22, 0x70, 0x61, 0x74, 0x63, 0x68, 0x65, 0x64,
-    0x20, 0x27, 0x69, 0x6f, 0x2e, 0x6c, 0x69, 0x6e, 0x65, 0x73, 0x27, 0x20, 0x63, 0x61, 0x6e, 0x27,
-    0x74, 0x20, 0x6f, 0x70, 0x65, 0x6e, 0x20, 0x27, 0x22, 0x20, 0x2e, 0x2e, 0x20, 0x6e, 0x61, 0x6d,
-    0x65, 0x20, 0x2e, 0x2e, 0x20, 0x22, 0x27, 0x22, 0x29, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-    0x20, 0x20, 0x65, 0x6e, 0x64, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x65, 0x6c, 0x73, 0x65, 0x0a, 0x20,
-    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x69, 0x6f,
-    0x5f, 0x6c, 0x69, 0x6e, 0x65, 0x73, 0x28, 0x29, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x65, 0x6e, 0x64,
+    0x20, 0x20, 0x20, 0x66, 0x69, 0x6f, 0x5f, 0x72, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x66, 0x69, 0x6c,
+    0x65, 0x6e, 0x61, 0x6d, 0x65, 0x28, 0x6e, 0x61, 0x6d, 0x65, 0x2c, 0x27, 0x72, 0x27, 0x29, 0x0a,
+    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x65, 0x6e, 0x64, 0x0a, 0x20, 0x20, 0x20, 0x20,
+    0x65, 0x6e, 0x64, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x66,
     0x0a, 0x65, 0x6e, 0x64, 0x0a, 0x0a, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x20, 0x66, 0x75, 0x6e, 0x63,
-    0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6c, 0x75, 0x61, 0x74, 0x65, 0x78, 0x5f, 0x69, 0x6f, 0x5f, 0x72,
-    0x65, 0x61, 0x64, 0x6c, 0x69, 0x6e, 0x65, 0x28, 0x66, 0x29, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x72,
-    0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x29,
-    0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20,
-    0x66, 0x69, 0x6f, 0x5f, 0x72, 0x65, 0x61, 0x64, 0x6c, 0x69, 0x6e, 0x65, 0x28, 0x66, 0x29, 0x0a,
-    0x20, 0x20, 0x20, 0x20, 0x65, 0x6e, 0x64, 0x0a, 0x65, 0x6e, 0x64, 0x0a, 0x0a, 0x69, 0x6f, 0x2e,
-    0x6c, 0x69, 0x6e, 0x65, 0x73, 0x20, 0x3d, 0x20, 0x6c, 0x75, 0x61, 0x74, 0x65, 0x78, 0x5f, 0x69,
-    0x6f, 0x5f, 0x6c, 0x69, 0x6e, 0x65, 0x73, 0x0a, 0x6d, 0x74, 0x2e, 0x6c, 0x69, 0x6e, 0x65, 0x73,
-    0x20, 0x3d, 0x20, 0x6c, 0x75, 0x61, 0x74, 0x65, 0x78, 0x5f, 0x69, 0x6f, 0x5f, 0x72, 0x65, 0x61,
-    0x64, 0x6c, 0x69, 0x6e, 0x65, 0x0a, 0x0a, 0x2d, 0x2d, 0x20, 0x57, 0x65, 0x20, 0x61, 0x73, 0x73,
-    0x75, 0x6d, 0x65, 0x20, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x20, 0x74,
-    0x6f, 0x20, 0x62, 0x65, 0x20, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x64, 0x20, 0x62, 0x79,
-    0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x65, 0x70, 0x6c, 0x61, 0x63, 0x65, 0x6d, 0x65, 0x6e, 0x74,
-    0x20, 0x6f, 0x66, 0x20, 0x6b, 0x70, 0x73, 0x65, 0x2e, 0x20, 0x54, 0x68, 0x69, 0x73, 0x20, 0x69,
-    0x73, 0x20, 0x74, 0x68, 0x65, 0x0a, 0x2d, 0x2d, 0x20, 0x63, 0x61, 0x73, 0x65, 0x20, 0x69, 0x6e,
-    0x20, 0x43, 0x6f, 0x6e, 0x54, 0x65, 0x58, 0x74, 0x2e, 0x0a, 0x0a, 0x69, 0x66, 0x20, 0x6b, 0x70,
-    0x73, 0x65, 0x75, 0x73, 0x65, 0x64, 0x20, 0x3d, 0x3d, 0x20, 0x31, 0x20, 0x74, 0x68, 0x65, 0x6e,
-    0x0a, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x69, 0x6f, 0x2e, 0x6f, 0x70, 0x65, 0x6e, 0x20, 0x20, 0x3d,
-    0x20, 0x6c, 0x75, 0x61, 0x74, 0x65, 0x78, 0x5f, 0x69, 0x6f, 0x5f, 0x6f, 0x70, 0x65, 0x6e, 0x0a,
-    0x20, 0x20, 0x20, 0x20, 0x69, 0x6f, 0x2e, 0x70, 0x6f, 0x70, 0x65, 0x6e, 0x20, 0x3d, 0x20, 0x6c,
-    0x75, 0x61, 0x74, 0x65, 0x78, 0x5f, 0x69, 0x6f, 0x5f, 0x70, 0x6f, 0x70, 0x65, 0x6e, 0x0a, 0x0a,
-    0x65, 0x6e, 0x64, 0x0a, 0x0a, 0x69, 0x66, 0x20, 0x73, 0x61, 0x66, 0x65, 0x72, 0x6f, 0x70, 0x74,
-    0x69, 0x6f, 0x6e, 0x20, 0x3d, 0x3d, 0x20, 0x31, 0x20, 0x74, 0x68, 0x65, 0x6e, 0x0a, 0x0a, 0x20,
-    0x20, 0x20, 0x20, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f,
-    0x6e, 0x20, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6c, 0x6c, 0x64, 0x75, 0x6d, 0x6d, 0x79, 0x28, 0x73,
-    0x74, 0x72, 0x2c, 0x66, 0x29, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x6c, 0x6f,
-    0x63, 0x61, 0x6c, 0x20, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x20, 0x3d, 0x20, 0x66,
-    0x61, 0x6c, 0x73, 0x65, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74,
-    0x75, 0x72, 0x6e, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x2e, 0x2e, 0x2e,
-    0x29, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x69, 0x66,
-    0x20, 0x6e, 0x6f, 0x74, 0x20, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x20, 0x74, 0x68,
-    0x65, 0x6e, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-    0x20, 0x20, 0x20, 0x77, 0x72, 0x69, 0x74, 0x65, 0x5f, 0x6e, 0x6c, 0x28, 0x66, 0x6f, 0x72, 0x6d,
-    0x61, 0x74, 0x28, 0x22, 0x73, 0x61, 0x66, 0x65, 0x72, 0x20, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e,
-    0x20, 0x73, 0x65, 0x74, 0x2c, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x25,
-    0x71, 0x20, 0x69, 0x73, 0x20, 0x25, 0x73, 0x22, 0x2c, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x73, 0x74,
-    0x72, 0x2c, 0x66, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x22, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x65, 0x64,
-    0x22, 0x20, 0x6f, 0x72, 0x20, 0x22, 0x64, 0x69, 0x73, 0x61, 0x62, 0x6c, 0x65, 0x64, 0x22, 0x29,
-    0x29, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-    0x20, 0x20, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x20, 0x3d, 0x20, 0x74, 0x72, 0x75,
-    0x65, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x65, 0x6e,
-    0x64, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x69, 0x66,
-    0x20, 0x66, 0x20, 0x74, 0x68, 0x65, 0x6e, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+    0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6c, 0x75, 0x61, 0x74, 0x65, 0x78, 0x5f, 0x69, 0x6f, 0x5f, 0x6f,
+    0x70, 0x65, 0x6e, 0x5f, 0x72, 0x65, 0x61, 0x64, 0x6f, 0x6e, 0x6c, 0x79, 0x28, 0x6e, 0x61, 0x6d,
+    0x65, 0x2c, 0x68, 0x6f, 0x77, 0x29, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x69, 0x66, 0x20, 0x68, 0x6f,
+    0x77, 0x20, 0x74, 0x68, 0x65, 0x6e, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x68,
+    0x6f, 0x77, 0x20, 0x3d, 0x20, 0x27, 0x72, 0x27, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x65, 0x6c, 0x73,
+    0x65, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x68, 0x6f, 0x77, 0x20, 0x3d, 0x20,
+    0x67, 0x73, 0x75, 0x62, 0x28, 0x68, 0x6f, 0x77, 0x2c, 0x27, 0x5b, 0x5e, 0x72, 0x62, 0x5d, 0x27,
+    0x2c, 0x27, 0x27, 0x29, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x69, 0x66, 0x20,
+    0x68, 0x6f, 0x77, 0x20, 0x3d, 0x3d, 0x20, 0x27, 0x27, 0x20, 0x74, 0x68, 0x65, 0x6e, 0x0a, 0x20,
+    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x68, 0x6f, 0x77, 0x20, 0x3d,
+    0x20, 0x27, 0x72, 0x27, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x65, 0x6e, 0x64,
+    0x0a, 0x20, 0x20, 0x20, 0x20, 0x65, 0x6e, 0x64, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x6c, 0x6f, 0x63,
+    0x61, 0x6c, 0x20, 0x66, 0x20, 0x3d, 0x20, 0x69, 0x6f, 0x5f, 0x6f, 0x70, 0x65, 0x6e, 0x28, 0x6e,
+    0x61, 0x6d, 0x65, 0x2c, 0x68, 0x6f, 0x77, 0x29, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x69, 0x66, 0x20,
+    0x66, 0x20, 0x74, 0x68, 0x65, 0x6e, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x66,
+    0x69, 0x6f, 0x5f, 0x72, 0x65, 0x63, 0x6f, 0x72, 0x64, 0x66, 0x69, 0x6c, 0x65, 0x6e, 0x61, 0x6d,
+    0x65, 0x28, 0x6e, 0x61, 0x6d, 0x65, 0x2c, 0x27, 0x72, 0x27, 0x29, 0x0a, 0x20, 0x20, 0x20, 0x20,
+    0x65, 0x6e, 0x64, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x66,
+    0x0a, 0x65, 0x6e, 0x64, 0x0a, 0x0a, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x20, 0x66, 0x75, 0x6e, 0x63,
+    0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6c, 0x75, 0x61, 0x74, 0x65, 0x78, 0x5f, 0x69, 0x6f, 0x5f, 0x70,
+    0x6f, 0x70, 0x65, 0x6e, 0x28, 0x6e, 0x61, 0x6d, 0x65, 0x2c, 0x2e, 0x2e, 0x2e, 0x29, 0x0a, 0x20,
+    0x20, 0x20, 0x20, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x20, 0x6f, 0x6b, 0x61, 0x79, 0x2c, 0x20, 0x66,
+    0x6f, 0x75, 0x6e, 0x64, 0x20, 0x3d, 0x20, 0x66, 0x69, 0x6f, 0x5f, 0x63, 0x68, 0x65, 0x63, 0x6b,
+    0x70, 0x65, 0x72, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6f, 0x6e, 0x28, 0x6e, 0x61, 0x6d, 0x65, 0x29,
+    0x0a, 0x20, 0x20, 0x20, 0x20, 0x69, 0x66, 0x20, 0x6f, 0x6b, 0x61, 0x79, 0x20, 0x61, 0x6e, 0x64,
+    0x20, 0x66, 0x6f, 0x75, 0x6e, 0x64, 0x20, 0x74, 0x68, 0x65, 0x6e, 0x0a, 0x20, 0x20, 0x20, 0x20,
+    0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x69, 0x6f, 0x5f, 0x70, 0x6f,
+    0x70, 0x65, 0x6e, 0x28, 0x66, 0x6f, 0x75, 0x6e, 0x64, 0x2c, 0x2e, 0x2e, 0x2e, 0x29, 0x0a, 0x20,
+    0x20, 0x20, 0x20, 0x65, 0x6e, 0x64, 0x0a, 0x65, 0x6e, 0x64, 0x0a, 0x0a, 0x2d, 0x2d, 0x20, 0x6c,
+    0x6f, 0x63, 0x61, 0x6c, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6c, 0x75,
+    0x61, 0x74, 0x65, 0x78, 0x5f, 0x69, 0x6f, 0x5f, 0x6c, 0x69, 0x6e, 0x65, 0x73, 0x28, 0x6e, 0x61,
+    0x6d, 0x65, 0x2c, 0x68, 0x6f, 0x77, 0x29, 0x0a, 0x2d, 0x2d, 0x20, 0x20, 0x20, 0x20, 0x20, 0x69,
+    0x66, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x20, 0x74, 0x68, 0x65, 0x6e, 0x0a, 0x2d, 0x2d, 0x20, 0x20,
+    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x20, 0x66, 0x20, 0x3d,
+    0x20, 0x69, 0x6f, 0x5f, 0x6f, 0x70, 0x65, 0x6e, 0x28, 0x6e, 0x61, 0x6d, 0x65, 0x2c, 0x68, 0x6f,
+    0x77, 0x20, 0x6f, 0x72, 0x20, 0x27, 0x72, 0x27, 0x29, 0x0a, 0x2d, 0x2d, 0x20, 0x20, 0x20, 0x20,
+    0x20, 0x20, 0x20, 0x20, 0x20, 0x69, 0x66, 0x20, 0x66, 0x20, 0x74, 0x68, 0x65, 0x6e, 0x0a, 0x2d,
+    0x2d, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65,
+    0x74, 0x75, 0x72, 0x6e, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x29, 0x0a,
+    0x2d, 0x2d, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+    0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x66, 0x69, 0x6f, 0x5f, 0x72, 0x65,
+    0x61, 0x64, 0x6c, 0x69, 0x6e, 0x65, 0x28, 0x66, 0x29, 0x0a, 0x2d, 0x2d, 0x20, 0x20, 0x20, 0x20,
+    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x65, 0x6e, 0x64, 0x0a, 0x2d, 0x2d, 0x20,
+    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x65, 0x6e, 0x64, 0x0a, 0x2d, 0x2d, 0x20, 0x20,
+    0x20, 0x20, 0x20, 0x65, 0x6c, 0x73, 0x65, 0x0a, 0x2d, 0x2d, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+    0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x69, 0x6f, 0x5f, 0x6c, 0x69, 0x6e,
+    0x65, 0x73, 0x28, 0x29, 0x0a, 0x2d, 0x2d, 0x20, 0x20, 0x20, 0x20, 0x20, 0x65, 0x6e, 0x64, 0x0a,
+    0x2d, 0x2d, 0x20, 0x65, 0x6e, 0x64, 0x0a, 0x0a, 0x2d, 0x2d, 0x20, 0x46, 0x6f, 0x72, 0x20, 0x73,
+    0x6f, 0x6d, 0x65, 0x20, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x67,
+    0x63, 0x20, 0x64, 0x6f, 0x65, 0x73, 0x6e, 0x27, 0x74, 0x20, 0x6b, 0x69, 0x63, 0x6b, 0x20, 0x69,
+    0x6e, 0x20, 0x73, 0x6f, 0x20, 0x77, 0x65, 0x20, 0x6e, 0x65, 0x65, 0x64, 0x20, 0x74, 0x6f, 0x20,
+    0x63, 0x6c, 0x6f, 0x73, 0x65, 0x20, 0x65, 0x78, 0x70, 0x6c, 0x69, 0x74, 0x6c, 0x79, 0x0a, 0x2d,
+    0x2d, 0x20, 0x73, 0x6f, 0x20, 0x74, 0x68, 0x61, 0x74, 0x20, 0x74, 0x68, 0x65, 0x20, 0x68, 0x61,
+    0x6e, 0x64, 0x6c, 0x65, 0x20, 0x69, 0x73, 0x20, 0x66, 0x6c, 0x75, 0x73, 0x68, 0x65, 0x64, 0x2e,
+    0x0a, 0x0a, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x20, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x2c, 0x20, 0x74,
+    0x79, 0x70, 0x65, 0x20, 0x3d, 0x20, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x2c, 0x20, 0x74, 0x79, 0x70,
+    0x65, 0x0a, 0x0a, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f,
+    0x6e, 0x20, 0x6c, 0x75, 0x61, 0x74, 0x65, 0x78, 0x5f, 0x69, 0x6f, 0x5f, 0x6c, 0x69, 0x6e, 0x65,
+    0x73, 0x28, 0x6e, 0x61, 0x6d, 0x65, 0x2c, 0x68, 0x6f, 0x77, 0x29, 0x0a, 0x20, 0x20, 0x20, 0x20,
+    0x69, 0x66, 0x20, 0x74, 0x79, 0x70, 0x65, 0x28, 0x6e, 0x61, 0x6d, 0x65, 0x29, 0x20, 0x3d, 0x3d,
+    0x20, 0x22, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x20, 0x74, 0x68, 0x65, 0x6e, 0x0a, 0x20,
+    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x20, 0x66, 0x20, 0x3d,
+    0x20, 0x69, 0x6f, 0x5f, 0x6f, 0x70, 0x65, 0x6e, 0x28, 0x6e, 0x61, 0x6d, 0x65, 0x2c, 0x68, 0x6f,
+    0x77, 0x20, 0x6f, 0x72, 0x20, 0x27, 0x72, 0x27, 0x29, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+    0x20, 0x20, 0x69, 0x66, 0x20, 0x66, 0x20, 0x74, 0x68, 0x65, 0x6e, 0x0a, 0x20, 0x20, 0x20, 0x20,
     0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x66,
-    0x28, 0x2e, 0x2e, 0x2e, 0x29, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-    0x20, 0x20, 0x65, 0x6e, 0x64, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x65, 0x6e,
-    0x64, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x65, 0x6e, 0x64, 0x0a, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x6c,
-    0x6f, 0x63, 0x61, 0x6c, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x6e,
-    0x73, 0x74, 0x61, 0x6c, 0x6c, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x28, 0x73, 0x74, 0x72, 0x2c, 0x66,
-    0x29, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x20,
-    0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x20, 0x3d, 0x20, 0x66, 0x61, 0x6c, 0x73, 0x65,
-    0x0a, 0x20, 0x20, 0x20, 0x20, 0x65, 0x6e, 0x64, 0x0a, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x6f, 0x73,
-    0x2e, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x65, 0x20, 0x3d, 0x20, 0x69, 0x6e, 0x73, 0x74, 0x61,
-    0x6c, 0x6c, 0x64, 0x75, 0x6d, 0x6d, 0x79, 0x28, 0x22, 0x6f, 0x73, 0x2e, 0x65, 0x78, 0x65, 0x63,
-    0x75, 0x74, 0x65, 0x22, 0x29, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x6f, 0x73, 0x2e, 0x73, 0x70, 0x61,
-    0x77, 0x6e, 0x20, 0x20, 0x20, 0x3d, 0x20, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6c, 0x6c, 0x64, 0x75,
-    0x6d, 0x6d, 0x79, 0x28, 0x22, 0x6f, 0x73, 0x2e, 0x73, 0x70, 0x61, 0x77, 0x6e, 0x22, 0x29, 0x0a,
-    0x20, 0x20, 0x20, 0x20, 0x6f, 0x73, 0x2e, 0x65, 0x78, 0x65, 0x63, 0x20, 0x20, 0x20, 0x20, 0x3d,
-    0x20, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6c, 0x6c, 0x64, 0x75, 0x6d, 0x6d, 0x79, 0x28, 0x22, 0x6f,
-    0x73, 0x2e, 0x65, 0x78, 0x65, 0x63, 0x22, 0x29, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x6f, 0x73, 0x2e,
-    0x73, 0x65, 0x74, 0x65, 0x6e, 0x76, 0x20, 0x20, 0x3d, 0x20, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6c,
-    0x6c, 0x64, 0x75, 0x6d, 0x6d, 0x79, 0x28, 0x22, 0x6f, 0x73, 0x2e, 0x73, 0x65, 0x74, 0x65, 0x6e,
-    0x76, 0x22, 0x29, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x6f, 0x73, 0x2e, 0x74, 0x65, 0x6d, 0x70, 0x64,
-    0x69, 0x72, 0x20, 0x3d, 0x20, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6c, 0x6c, 0x64, 0x75, 0x6d, 0x6d,
-    0x79, 0x28, 0x22, 0x6f, 0x73, 0x2e, 0x74, 0x65, 0x6d, 0x70, 0x64, 0x69, 0x72, 0x22, 0x29, 0x0a,
-    0x0a, 0x20, 0x20, 0x20, 0x20, 0x69, 0x6f, 0x2e, 0x70, 0x6f, 0x70, 0x65, 0x6e, 0x20, 0x20, 0x20,
-    0x3d, 0x20, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6c, 0x6c, 0x64, 0x75, 0x6d, 0x6d, 0x79, 0x28, 0x22,
-    0x69, 0x6f, 0x2e, 0x70, 0x6f, 0x70, 0x65, 0x6e, 0x22, 0x29, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x69,
-    0x6f, 0x2e, 0x6f, 0x70, 0x65, 0x6e, 0x20, 0x20, 0x20, 0x20, 0x3d, 0x20, 0x69, 0x6e, 0x73, 0x74,
-    0x61, 0x6c, 0x6c, 0x64, 0x75, 0x6d, 0x6d, 0x79, 0x28, 0x22, 0x69, 0x6f, 0x2e, 0x6f, 0x70, 0x65,
-    0x6e, 0x22, 0x2c, 0x6c, 0x75, 0x61, 0x74, 0x65, 0x78, 0x5f, 0x69, 0x6f, 0x5f, 0x6f, 0x70, 0x65,
-    0x6e, 0x5f, 0x72, 0x65, 0x61, 0x64, 0x6f, 0x6e, 0x6c, 0x79, 0x29, 0x0a, 0x0a, 0x20, 0x20, 0x20,
-    0x20, 0x6f, 0x73, 0x2e, 0x72, 0x65, 0x6e, 0x61, 0x6d, 0x65, 0x20, 0x20, 0x3d, 0x20, 0x69, 0x6e,
-    0x73, 0x74, 0x61, 0x6c, 0x6c, 0x64, 0x75, 0x6d, 0x6d, 0x79, 0x28, 0x22, 0x6f, 0x73, 0x2e, 0x72,
-    0x65, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x29, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x6f, 0x73, 0x2e, 0x72,
-    0x65, 0x6d, 0x6f, 0x76, 0x65, 0x20, 0x20, 0x3d, 0x20, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6c, 0x6c,
-    0x64, 0x75, 0x6d, 0x6d, 0x79, 0x28, 0x22, 0x6f, 0x73, 0x2e, 0x72, 0x65, 0x6d, 0x6f, 0x76, 0x65,
-    0x22, 0x29, 0x0a, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x69, 0x6f, 0x2e, 0x74, 0x6d, 0x70, 0x66, 0x69,
-    0x6c, 0x65, 0x20, 0x3d, 0x20, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6c, 0x6c, 0x64, 0x75, 0x6d, 0x6d,
-    0x79, 0x28, 0x22, 0x69, 0x6f, 0x2e, 0x74, 0x6d, 0x70, 0x66, 0x69, 0x6c, 0x65, 0x22, 0x29, 0x0a,
-    0x20, 0x20, 0x20, 0x20, 0x69, 0x6f, 0x2e, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x20, 0x20, 0x3d,
-    0x20, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6c, 0x6c, 0x64, 0x75, 0x6d, 0x6d, 0x79, 0x28, 0x22, 0x69,
-    0x6f, 0x2e, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x22, 0x29, 0x0a, 0x0a, 0x20, 0x20, 0x20, 0x20,
-    0x6c, 0x66, 0x73, 0x2e, 0x63, 0x68, 0x64, 0x69, 0x72, 0x20, 0x20, 0x3d, 0x20, 0x69, 0x6e, 0x73,
-    0x74, 0x61, 0x6c, 0x6c, 0x64, 0x75, 0x6d, 0x6d, 0x79, 0x28, 0x22, 0x6c, 0x66, 0x73, 0x2e, 0x63,
-    0x68, 0x64, 0x69, 0x72, 0x22, 0x29, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x6c, 0x66, 0x73, 0x2e, 0x6c,
-    0x6f, 0x63, 0x6b, 0x20, 0x20, 0x20, 0x3d, 0x20, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6c, 0x6c, 0x64,
-    0x75, 0x6d, 0x6d, 0x79, 0x28, 0x22, 0x6c, 0x66, 0x73, 0x2e, 0x6c, 0x6f, 0x63, 0x6b, 0x22, 0x29,
-    0x0a, 0x20, 0x20, 0x20, 0x20, 0x6c, 0x66, 0x73, 0x2e, 0x74, 0x6f, 0x75, 0x63, 0x68, 0x20, 0x20,
-    0x3d, 0x20, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6c, 0x6c, 0x64, 0x75, 0x6d, 0x6d, 0x79, 0x28, 0x22,
-    0x6c, 0x66, 0x73, 0x2e, 0x74, 0x6f, 0x75, 0x63, 0x68, 0x22, 0x29, 0x0a, 0x20, 0x20, 0x20, 0x20,
-    0x6c, 0x66, 0x73, 0x2e, 0x72, 0x6d, 0x64, 0x69, 0x72, 0x20, 0x20, 0x3d, 0x20, 0x69, 0x6e, 0x73,
-    0x74, 0x61, 0x6c, 0x6c, 0x64, 0x75, 0x6d, 0x6d, 0x79, 0x28, 0x22, 0x6c, 0x66, 0x73, 0x2e, 0x72,
-    0x6d, 0x64, 0x69, 0x72, 0x22, 0x29, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x6c, 0x66, 0x73, 0x2e, 0x6d,
-    0x6b, 0x64, 0x69, 0x72, 0x20, 0x20, 0x3d, 0x20, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6c, 0x6c, 0x64,
-    0x75, 0x6d, 0x6d, 0x79, 0x28, 0x22, 0x6c, 0x66, 0x73, 0x2e, 0x6d, 0x6b, 0x64, 0x69, 0x72, 0x22,
-    0x29, 0x0a, 0x0a, 0x65, 0x6e, 0x64, 0x0a, 0x0a, 0x69, 0x66, 0x20, 0x73, 0x61, 0x66, 0x65, 0x72,
-    0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x3d, 0x3d, 0x20, 0x31, 0x20, 0x6f, 0x72, 0x20, 0x73,
-    0x68, 0x65, 0x6c, 0x6c, 0x65, 0x73, 0x63, 0x61, 0x70, 0x65, 0x20, 0x7e, 0x3d, 0x20, 0x31, 0x20,
-    0x74, 0x68, 0x65, 0x6e, 0x0a, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x66, 0x66, 0x69, 0x20, 0x3d, 0x20,
-    0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x28, 0x27, 0x66, 0x66, 0x69, 0x27, 0x29, 0x0a, 0x20,
-    0x20, 0x20, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x6b, 0x2c, 0x20, 0x76, 0x20, 0x69, 0x6e, 0x20, 0x6e,
-    0x65, 0x78, 0x74, 0x2c, 0x20, 0x66, 0x66, 0x69, 0x20, 0x64, 0x6f, 0x0a, 0x20, 0x20, 0x20, 0x20,
-    0x20, 0x20, 0x20, 0x20, 0x69, 0x66, 0x20, 0x6b, 0x20, 0x7e, 0x3d, 0x20, 0x27, 0x67, 0x63, 0x27,
+    0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x29, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x20,
+    0x6c, 0x20, 0x3d, 0x20, 0x66, 0x69, 0x6f, 0x5f, 0x72, 0x65, 0x61, 0x64, 0x6c, 0x69, 0x6e, 0x65,
+    0x28, 0x66, 0x29, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+    0x20, 0x20, 0x20, 0x20, 0x69, 0x66, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x6c, 0x20, 0x74, 0x68, 0x65,
+    0x6e, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x66, 0x3a, 0x63, 0x6c, 0x6f, 0x73, 0x65, 0x28, 0x29, 0x0a,
+    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+    0x65, 0x6e, 0x64, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+    0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x6c, 0x0a, 0x20, 0x20, 0x20,
+    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x65, 0x6e, 0x64, 0x0a, 0x20, 0x20, 0x20,
+    0x20, 0x20, 0x20, 0x20, 0x20, 0x65, 0x6c, 0x73, 0x65, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x2d, 0x2d, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x6f,
+    0x73, 0x65, 0x20, 0x77, 0x68, 0x6f, 0x20, 0x6c, 0x69, 0x6b, 0x65, 0x20, 0x69, 0x74, 0x20, 0x74,
+    0x68, 0x69, 0x73, 0x20, 0x77, 0x61, 0x79, 0x3a, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+    0x20, 0x20, 0x20, 0x20, 0x20, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x28, 0x22, 0x70, 0x61, 0x74, 0x63,
+    0x68, 0x65, 0x64, 0x20, 0x27, 0x69, 0x6f, 0x2e, 0x6c, 0x69, 0x6e, 0x65, 0x73, 0x27, 0x20, 0x63,
+    0x61, 0x6e, 0x27, 0x74, 0x20, 0x6f, 0x70, 0x65, 0x6e, 0x20, 0x27, 0x22, 0x20, 0x2e, 0x2e, 0x20,
+    0x6e, 0x61, 0x6d, 0x65, 0x20, 0x2e, 0x2e, 0x20, 0x22, 0x27, 0x22, 0x29, 0x0a, 0x20, 0x20, 0x20,
+    0x20, 0x20, 0x20, 0x20, 0x20, 0x65, 0x6e, 0x64, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x65, 0x6c, 0x73,
+    0x65, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e,
+    0x20, 0x69, 0x6f, 0x5f, 0x6c, 0x69, 0x6e, 0x65, 0x73, 0x28, 0x29, 0x0a, 0x20, 0x20, 0x20, 0x20,
+    0x65, 0x6e, 0x64, 0x0a, 0x65, 0x6e, 0x64, 0x0a, 0x0a, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x20, 0x66,
+    0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6c, 0x75, 0x61, 0x74, 0x65, 0x78, 0x5f, 0x69,
+    0x6f, 0x5f, 0x72, 0x65, 0x61, 0x64, 0x6c, 0x69, 0x6e, 0x65, 0x28, 0x66, 0x29, 0x0a, 0x20, 0x20,
+    0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f,
+    0x6e, 0x28, 0x29, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75,
+    0x72, 0x6e, 0x20, 0x66, 0x69, 0x6f, 0x5f, 0x72, 0x65, 0x61, 0x64, 0x6c, 0x69, 0x6e, 0x65, 0x28,
+    0x66, 0x29, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x65, 0x6e, 0x64, 0x0a, 0x65, 0x6e, 0x64, 0x0a, 0x0a,
+    0x69, 0x6f, 0x2e, 0x6c, 0x69, 0x6e, 0x65, 0x73, 0x20, 0x3d, 0x20, 0x6c, 0x75, 0x61, 0x74, 0x65,
+    0x78, 0x5f, 0x69, 0x6f, 0x5f, 0x6c, 0x69, 0x6e, 0x65, 0x73, 0x0a, 0x6d, 0x74, 0x2e, 0x6c, 0x69,
+    0x6e, 0x65, 0x73, 0x20, 0x3d, 0x20, 0x6c, 0x75, 0x61, 0x74, 0x65, 0x78, 0x5f, 0x69, 0x6f, 0x5f,
+    0x72, 0x65, 0x61, 0x64, 0x6c, 0x69, 0x6e, 0x65, 0x0a, 0x0a, 0x2d, 0x2d, 0x20, 0x57, 0x65, 0x20,
+    0x61, 0x73, 0x73, 0x75, 0x6d, 0x65, 0x20, 0x6d, 0x61, 0x6e, 0x61, 0x67, 0x65, 0x6d, 0x65, 0x6e,
+    0x74, 0x20, 0x74, 0x6f, 0x20, 0x62, 0x65, 0x20, 0x70, 0x72, 0x6f, 0x76, 0x69, 0x64, 0x65, 0x64,
+    0x20, 0x62, 0x79, 0x20, 0x74, 0x68, 0x65, 0x20, 0x72, 0x65, 0x70, 0x6c, 0x61, 0x63, 0x65, 0x6d,
+    0x65, 0x6e, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x6b, 0x70, 0x73, 0x65, 0x2e, 0x20, 0x54, 0x68, 0x69,
+    0x73, 0x20, 0x69, 0x73, 0x20, 0x74, 0x68, 0x65, 0x0a, 0x2d, 0x2d, 0x20, 0x63, 0x61, 0x73, 0x65,
+    0x20, 0x69, 0x6e, 0x20, 0x43, 0x6f, 0x6e, 0x54, 0x65, 0x58, 0x74, 0x2e, 0x0a, 0x0a, 0x69, 0x66,
+    0x20, 0x6b, 0x70, 0x73, 0x65, 0x75, 0x73, 0x65, 0x64, 0x20, 0x3d, 0x3d, 0x20, 0x31, 0x20, 0x74,
+    0x68, 0x65, 0x6e, 0x0a, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x69, 0x6f, 0x2e, 0x6f, 0x70, 0x65, 0x6e,
+    0x20, 0x20, 0x3d, 0x20, 0x6c, 0x75, 0x61, 0x74, 0x65, 0x78, 0x5f, 0x69, 0x6f, 0x5f, 0x6f, 0x70,
+    0x65, 0x6e, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x69, 0x6f, 0x2e, 0x70, 0x6f, 0x70, 0x65, 0x6e, 0x20,
+    0x3d, 0x20, 0x6c, 0x75, 0x61, 0x74, 0x65, 0x78, 0x5f, 0x69, 0x6f, 0x5f, 0x70, 0x6f, 0x70, 0x65,
+    0x6e, 0x0a, 0x0a, 0x65, 0x6e, 0x64, 0x0a, 0x0a, 0x69, 0x66, 0x20, 0x73, 0x61, 0x66, 0x65, 0x72,
+    0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x3d, 0x3d, 0x20, 0x31, 0x20, 0x74, 0x68, 0x65, 0x6e,
+    0x0a, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x20, 0x66, 0x75, 0x6e, 0x63,
+    0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6c, 0x6c, 0x64, 0x75, 0x6d, 0x6d,
+    0x79, 0x28, 0x73, 0x74, 0x72, 0x2c, 0x66, 0x29, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+    0x20, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x20, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x20,
+    0x3d, 0x20, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+    0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28,
+    0x2e, 0x2e, 0x2e, 0x29, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+    0x20, 0x69, 0x66, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64,
     0x20, 0x74, 0x68, 0x65, 0x6e, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-    0x20, 0x20, 0x66, 0x66, 0x69, 0x5b, 0x6b, 0x5d, 0x20, 0x3d, 0x20, 0x6e, 0x69, 0x6c, 0x0a, 0x20,
-    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x65, 0x6e, 0x64, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x65,
-    0x6e, 0x64, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x66, 0x66, 0x69, 0x20, 0x3d, 0x20, 0x6e, 0x69, 0x6c,
-    0x0a, 0x0a, 0x65, 0x6e, 0x64, 0x0a, 0x0a, 0x2d, 0x2d, 0x20, 0x6f, 0x73, 0x2e, 0x5b, 0x65, 0x78,
-    0x65, 0x63, 0x75, 0x74, 0x65, 0x7c, 0x6f, 0x73, 0x2e, 0x73, 0x70, 0x61, 0x77, 0x6e, 0x7c, 0x6f,
-    0x73, 0x2e, 0x65, 0x78, 0x65, 0x63, 0x5d, 0x20, 0x61, 0x6c, 0x72, 0x65, 0x61, 0x64, 0x79, 0x20,
-    0x61, 0x72, 0x65, 0x20, 0x73, 0x68, 0x65, 0x6c, 0x6c, 0x65, 0x73, 0x63, 0x61, 0x70, 0x65, 0x20,
-    0x61, 0x77, 0x61, 0x72, 0x65, 0x29, 0x0a, 0x0a, 0x0a, 0x69, 0x66, 0x20, 0x6d, 0x64, 0x35, 0x20,
-    0x74, 0x68, 0x65, 0x6e, 0x0a, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x20,
-    0x73, 0x75, 0x6d, 0x20, 0x20, 0x20, 0x20, 0x3d, 0x20, 0x6d, 0x64, 0x35, 0x2e, 0x73, 0x75, 0x6d,
-    0x0a, 0x20, 0x20, 0x20, 0x20, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x20, 0x67, 0x73, 0x75, 0x62, 0x20,
-    0x20, 0x20, 0x3d, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x2e, 0x67, 0x73, 0x75, 0x62, 0x0a,
-    0x20, 0x20, 0x20, 0x20, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x20, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74,
-    0x20, 0x3d, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x2e, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74,
-    0x0a, 0x20, 0x20, 0x20, 0x20, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x20, 0x62, 0x79, 0x74, 0x65, 0x20,
-    0x20, 0x20, 0x3d, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x2e, 0x62, 0x79, 0x74, 0x65, 0x0a,
-    0x0a, 0x20, 0x20, 0x20, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6d, 0x64,
-    0x35, 0x2e, 0x73, 0x75, 0x6d, 0x68, 0x65, 0x78, 0x61, 0x28, 0x6b, 0x29, 0x0a, 0x20, 0x20, 0x20,
-    0x20, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x28, 0x67, 0x73, 0x75,
-    0x62, 0x28, 0x73, 0x75, 0x6d, 0x28, 0x6b, 0x29, 0x2c, 0x20, 0x22, 0x2e, 0x22, 0x2c, 0x20, 0x66,
-    0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x63, 0x29, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20,
-    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x66, 0x6f,
-    0x72, 0x6d, 0x61, 0x74, 0x28, 0x22, 0x25, 0x30, 0x32, 0x78, 0x22, 0x2c, 0x62, 0x79, 0x74, 0x65,
-    0x28, 0x63, 0x29, 0x29, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x65, 0x6e, 0x64,
-    0x29, 0x29, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x65, 0x6e, 0x64, 0x0a, 0x0a, 0x20, 0x20, 0x20, 0x20,
-    0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6d, 0x64, 0x35, 0x2e, 0x73, 0x75, 0x6d,
-    0x48, 0x45, 0x58, 0x41, 0x28, 0x6b, 0x29, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-    0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x28, 0x67, 0x73, 0x75, 0x62, 0x28, 0x73, 0x75, 0x6d,
-    0x28, 0x6b, 0x29, 0x2c, 0x20, 0x22, 0x2e, 0x22, 0x2c, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69,
-    0x6f, 0x6e, 0x28, 0x63, 0x29, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x77, 0x72, 0x69, 0x74, 0x65, 0x5f, 0x6e, 0x6c, 0x28, 0x66,
+    0x6f, 0x72, 0x6d, 0x61, 0x74, 0x28, 0x22, 0x73, 0x61, 0x66, 0x65, 0x72, 0x20, 0x6f, 0x70, 0x74,
+    0x69, 0x6f, 0x6e, 0x20, 0x73, 0x65, 0x74, 0x2c, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f,
+    0x6e, 0x20, 0x25, 0x71, 0x20, 0x69, 0x73, 0x20, 0x25, 0x73, 0x22, 0x2c, 0x0a, 0x20, 0x20, 0x20,
+    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+    0x20, 0x73, 0x74, 0x72, 0x2c, 0x66, 0x20, 0x61, 0x6e, 0x64, 0x20, 0x22, 0x6c, 0x69, 0x6d, 0x69,
+    0x74, 0x65, 0x64, 0x22, 0x20, 0x6f, 0x72, 0x20, 0x22, 0x64, 0x69, 0x73, 0x61, 0x62, 0x6c, 0x65,
+    0x64, 0x22, 0x29, 0x29, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+    0x20, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x20, 0x3d, 0x20,
+    0x74, 0x72, 0x75, 0x65, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+    0x20, 0x65, 0x6e, 0x64, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+    0x20, 0x69, 0x66, 0x20, 0x66, 0x20, 0x74, 0x68, 0x65, 0x6e, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20,
+    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72,
+    0x6e, 0x20, 0x66, 0x28, 0x2e, 0x2e, 0x2e, 0x29, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+    0x20, 0x20, 0x20, 0x20, 0x20, 0x65, 0x6e, 0x64, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+    0x20, 0x65, 0x6e, 0x64, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x65, 0x6e, 0x64, 0x0a, 0x0a, 0x20, 0x20,
+    0x20, 0x20, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e,
+    0x20, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6c, 0x6c, 0x6c, 0x69, 0x6d, 0x69, 0x74, 0x28, 0x73, 0x74,
+    0x72, 0x2c, 0x66, 0x29, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x6c, 0x6f, 0x63,
+    0x61, 0x6c, 0x20, 0x72, 0x65, 0x70, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x20, 0x3d, 0x20, 0x66, 0x61,
+    0x6c, 0x73, 0x65, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x65, 0x6e, 0x64, 0x0a, 0x0a, 0x20, 0x20, 0x20,
+    0x20, 0x6f, 0x73, 0x2e, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x65, 0x20, 0x3d, 0x20, 0x69, 0x6e,
+    0x73, 0x74, 0x61, 0x6c, 0x6c, 0x64, 0x75, 0x6d, 0x6d, 0x79, 0x28, 0x22, 0x6f, 0x73, 0x2e, 0x65,
+    0x78, 0x65, 0x63, 0x75, 0x74, 0x65, 0x22, 0x29, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x6f, 0x73, 0x2e,
+    0x73, 0x70, 0x61, 0x77, 0x6e, 0x20, 0x20, 0x20, 0x3d, 0x20, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6c,
+    0x6c, 0x64, 0x75, 0x6d, 0x6d, 0x79, 0x28, 0x22, 0x6f, 0x73, 0x2e, 0x73, 0x70, 0x61, 0x77, 0x6e,
+    0x22, 0x29, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x6f, 0x73, 0x2e, 0x65, 0x78, 0x65, 0x63, 0x20, 0x20,
+    0x20, 0x20, 0x3d, 0x20, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6c, 0x6c, 0x64, 0x75, 0x6d, 0x6d, 0x79,
+    0x28, 0x22, 0x6f, 0x73, 0x2e, 0x65, 0x78, 0x65, 0x63, 0x22, 0x29, 0x0a, 0x20, 0x20, 0x20, 0x20,
+    0x6f, 0x73, 0x2e, 0x73, 0x65, 0x74, 0x65, 0x6e, 0x76, 0x20, 0x20, 0x3d, 0x20, 0x69, 0x6e, 0x73,
+    0x74, 0x61, 0x6c, 0x6c, 0x64, 0x75, 0x6d, 0x6d, 0x79, 0x28, 0x22, 0x6f, 0x73, 0x2e, 0x73, 0x65,
+    0x74, 0x65, 0x6e, 0x76, 0x22, 0x29, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x6f, 0x73, 0x2e, 0x74, 0x65,
+    0x6d, 0x70, 0x64, 0x69, 0x72, 0x20, 0x3d, 0x20, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6c, 0x6c, 0x64,
+    0x75, 0x6d, 0x6d, 0x79, 0x28, 0x22, 0x6f, 0x73, 0x2e, 0x74, 0x65, 0x6d, 0x70, 0x64, 0x69, 0x72,
+    0x22, 0x29, 0x0a, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x69, 0x6f, 0x2e, 0x70, 0x6f, 0x70, 0x65, 0x6e,
+    0x20, 0x20, 0x20, 0x3d, 0x20, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6c, 0x6c, 0x64, 0x75, 0x6d, 0x6d,
+    0x79, 0x28, 0x22, 0x69, 0x6f, 0x2e, 0x70, 0x6f, 0x70, 0x65, 0x6e, 0x22, 0x29, 0x0a, 0x20, 0x20,
+    0x20, 0x20, 0x69, 0x6f, 0x2e, 0x6f, 0x70, 0x65, 0x6e, 0x20, 0x20, 0x20, 0x20, 0x3d, 0x20, 0x69,
+    0x6e, 0x73, 0x74, 0x61, 0x6c, 0x6c, 0x64, 0x75, 0x6d, 0x6d, 0x79, 0x28, 0x22, 0x69, 0x6f, 0x2e,
+    0x6f, 0x70, 0x65, 0x6e, 0x22, 0x2c, 0x6c, 0x75, 0x61, 0x74, 0x65, 0x78, 0x5f, 0x69, 0x6f, 0x5f,
+    0x6f, 0x70, 0x65, 0x6e, 0x5f, 0x72, 0x65, 0x61, 0x64, 0x6f, 0x6e, 0x6c, 0x79, 0x29, 0x0a, 0x0a,
+    0x20, 0x20, 0x20, 0x20, 0x6f, 0x73, 0x2e, 0x72, 0x65, 0x6e, 0x61, 0x6d, 0x65, 0x20, 0x20, 0x3d,
+    0x20, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6c, 0x6c, 0x64, 0x75, 0x6d, 0x6d, 0x79, 0x28, 0x22, 0x6f,
+    0x73, 0x2e, 0x72, 0x65, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x29, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x6f,
+    0x73, 0x2e, 0x72, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x20, 0x20, 0x3d, 0x20, 0x69, 0x6e, 0x73, 0x74,
+    0x61, 0x6c, 0x6c, 0x64, 0x75, 0x6d, 0x6d, 0x79, 0x28, 0x22, 0x6f, 0x73, 0x2e, 0x72, 0x65, 0x6d,
+    0x6f, 0x76, 0x65, 0x22, 0x29, 0x0a, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x69, 0x6f, 0x2e, 0x74, 0x6d,
+    0x70, 0x66, 0x69, 0x6c, 0x65, 0x20, 0x3d, 0x20, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6c, 0x6c, 0x64,
+    0x75, 0x6d, 0x6d, 0x79, 0x28, 0x22, 0x69, 0x6f, 0x2e, 0x74, 0x6d, 0x70, 0x66, 0x69, 0x6c, 0x65,
+    0x22, 0x29, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x69, 0x6f, 0x2e, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74,
+    0x20, 0x20, 0x3d, 0x20, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6c, 0x6c, 0x64, 0x75, 0x6d, 0x6d, 0x79,
+    0x28, 0x22, 0x69, 0x6f, 0x2e, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x22, 0x29, 0x0a, 0x0a, 0x20,
+    0x20, 0x20, 0x20, 0x6c, 0x66, 0x73, 0x2e, 0x63, 0x68, 0x64, 0x69, 0x72, 0x20, 0x20, 0x3d, 0x20,
+    0x69, 0x6e, 0x73, 0x74, 0x61, 0x6c, 0x6c, 0x64, 0x75, 0x6d, 0x6d, 0x79, 0x28, 0x22, 0x6c, 0x66,
+    0x73, 0x2e, 0x63, 0x68, 0x64, 0x69, 0x72, 0x22, 0x29, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x6c, 0x66,
+    0x73, 0x2e, 0x6c, 0x6f, 0x63, 0x6b, 0x20, 0x20, 0x20, 0x3d, 0x20, 0x69, 0x6e, 0x73, 0x74, 0x61,
+    0x6c, 0x6c, 0x64, 0x75, 0x6d, 0x6d, 0x79, 0x28, 0x22, 0x6c, 0x66, 0x73, 0x2e, 0x6c, 0x6f, 0x63,
+    0x6b, 0x22, 0x29, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x6c, 0x66, 0x73, 0x2e, 0x74, 0x6f, 0x75, 0x63,
+    0x68, 0x20, 0x20, 0x3d, 0x20, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6c, 0x6c, 0x64, 0x75, 0x6d, 0x6d,
+    0x79, 0x28, 0x22, 0x6c, 0x66, 0x73, 0x2e, 0x74, 0x6f, 0x75, 0x63, 0x68, 0x22, 0x29, 0x0a, 0x20,
+    0x20, 0x20, 0x20, 0x6c, 0x66, 0x73, 0x2e, 0x72, 0x6d, 0x64, 0x69, 0x72, 0x20, 0x20, 0x3d, 0x20,
+    0x69, 0x6e, 0x73, 0x74, 0x61, 0x6c, 0x6c, 0x64, 0x75, 0x6d, 0x6d, 0x79, 0x28, 0x22, 0x6c, 0x66,
+    0x73, 0x2e, 0x72, 0x6d, 0x64, 0x69, 0x72, 0x22, 0x29, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x6c, 0x66,
+    0x73, 0x2e, 0x6d, 0x6b, 0x64, 0x69, 0x72, 0x20, 0x20, 0x3d, 0x20, 0x69, 0x6e, 0x73, 0x74, 0x61,
+    0x6c, 0x6c, 0x64, 0x75, 0x6d, 0x6d, 0x79, 0x28, 0x22, 0x6c, 0x66, 0x73, 0x2e, 0x6d, 0x6b, 0x64,
+    0x69, 0x72, 0x22, 0x29, 0x0a, 0x0a, 0x65, 0x6e, 0x64, 0x0a, 0x0a, 0x69, 0x66, 0x20, 0x73, 0x61,
+    0x66, 0x65, 0x72, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x3d, 0x3d, 0x20, 0x31, 0x20, 0x6f,
+    0x72, 0x20, 0x73, 0x68, 0x65, 0x6c, 0x6c, 0x65, 0x73, 0x63, 0x61, 0x70, 0x65, 0x20, 0x7e, 0x3d,
+    0x20, 0x31, 0x20, 0x74, 0x68, 0x65, 0x6e, 0x0a, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x66, 0x66, 0x69,
+    0x20, 0x3d, 0x20, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x28, 0x27, 0x66, 0x66, 0x69, 0x27,
+    0x29, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x6b, 0x2c, 0x20, 0x76, 0x20, 0x69,
+    0x6e, 0x20, 0x6e, 0x65, 0x78, 0x74, 0x2c, 0x20, 0x66, 0x66, 0x69, 0x20, 0x64, 0x6f, 0x0a, 0x20,
+    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x69, 0x66, 0x20, 0x6b, 0x20, 0x7e, 0x3d, 0x20, 0x27,
+    0x67, 0x63, 0x27, 0x20, 0x74, 0x68, 0x65, 0x6e, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+    0x20, 0x20, 0x20, 0x20, 0x20, 0x66, 0x66, 0x69, 0x5b, 0x6b, 0x5d, 0x20, 0x3d, 0x20, 0x6e, 0x69,
+    0x6c, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x65, 0x6e, 0x64, 0x0a, 0x20, 0x20,
+    0x20, 0x20, 0x65, 0x6e, 0x64, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x66, 0x66, 0x69, 0x20, 0x3d, 0x20,
+    0x6e, 0x69, 0x6c, 0x0a, 0x0a, 0x65, 0x6e, 0x64, 0x0a, 0x0a, 0x2d, 0x2d, 0x20, 0x6f, 0x73, 0x2e,
+    0x5b, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x65, 0x7c, 0x6f, 0x73, 0x2e, 0x73, 0x70, 0x61, 0x77,
+    0x6e, 0x7c, 0x6f, 0x73, 0x2e, 0x65, 0x78, 0x65, 0x63, 0x5d, 0x20, 0x61, 0x6c, 0x72, 0x65, 0x61,
+    0x64, 0x79, 0x20, 0x61, 0x72, 0x65, 0x20, 0x73, 0x68, 0x65, 0x6c, 0x6c, 0x65, 0x73, 0x63, 0x61,
+    0x70, 0x65, 0x20, 0x61, 0x77, 0x61, 0x72, 0x65, 0x29, 0x0a, 0x0a, 0x0a, 0x69, 0x66, 0x20, 0x6d,
+    0x64, 0x35, 0x20, 0x74, 0x68, 0x65, 0x6e, 0x0a, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x6c, 0x6f, 0x63,
+    0x61, 0x6c, 0x20, 0x73, 0x75, 0x6d, 0x20, 0x20, 0x20, 0x20, 0x3d, 0x20, 0x6d, 0x64, 0x35, 0x2e,
+    0x73, 0x75, 0x6d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x20, 0x67, 0x73,
+    0x75, 0x62, 0x20, 0x20, 0x20, 0x3d, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x2e, 0x67, 0x73,
+    0x75, 0x62, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x20, 0x66, 0x6f, 0x72,
+    0x6d, 0x61, 0x74, 0x20, 0x3d, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x2e, 0x66, 0x6f, 0x72,
+    0x6d, 0x61, 0x74, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x20, 0x62, 0x79,
+    0x74, 0x65, 0x20, 0x20, 0x20, 0x3d, 0x20, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x2e, 0x62, 0x79,
+    0x74, 0x65, 0x0a, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x69, 0x66, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x6d,
+    0x64, 0x35, 0x2e, 0x73, 0x75, 0x6d, 0x68, 0x65, 0x78, 0x61, 0x20, 0x74, 0x68, 0x65, 0x6e, 0x0a,
+    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e,
+    0x20, 0x6d, 0x64, 0x35, 0x2e, 0x73, 0x75, 0x6d, 0x68, 0x65, 0x78, 0x61, 0x28, 0x6b, 0x29, 0x0a,
+    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75,
+    0x72, 0x6e, 0x20, 0x28, 0x67, 0x73, 0x75, 0x62, 0x28, 0x73, 0x75, 0x6d, 0x28, 0x6b, 0x29, 0x2c,
+    0x20, 0x22, 0x2e, 0x22, 0x2c, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x63,
+    0x29, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
     0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x28,
-    0x22, 0x25, 0x30, 0x32, 0x58, 0x22, 0x2c, 0x62, 0x79, 0x74, 0x65, 0x28, 0x63, 0x29, 0x29, 0x0a,
-    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x65, 0x6e, 0x64, 0x29, 0x29, 0x0a, 0x20, 0x20,
-    0x20, 0x20, 0x65, 0x6e, 0x64, 0x0a, 0x0a, 0x65, 0x6e, 0x64, 0x0a, 0x0a, 0x2d, 0x2d, 0x20, 0x63,
-    0x6f, 0x6d, 0x70, 0x61, 0x74, 0x69, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x3a, 0x20, 0x74, 0x68,
-    0x69, 0x73, 0x20, 0x6d, 0x69, 0x67, 0x68, 0x74, 0x20, 0x67, 0x6f, 0x20, 0x61, 0x77, 0x61, 0x79,
-    0x0a, 0x0a, 0x69, 0x66, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x75, 0x6e, 0x70, 0x61, 0x63, 0x6b, 0x20,
-    0x74, 0x68, 0x65, 0x6e, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x75, 0x6e, 0x70, 0x61, 0x63, 0x6b, 0x20,
-    0x3d, 0x20, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x2e, 0x75, 0x6e, 0x70, 0x61, 0x63, 0x6b, 0x0a, 0x65,
-    0x6e, 0x64, 0x0a, 0x0a, 0x69, 0x66, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x70, 0x61, 0x63, 0x6b, 0x61,
-    0x67, 0x65, 0x2e, 0x6c, 0x6f, 0x61, 0x64, 0x65, 0x72, 0x73, 0x20, 0x74, 0x68, 0x65, 0x6e, 0x0a,
-    0x20, 0x20, 0x20, 0x20, 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x2e, 0x6c, 0x6f, 0x61, 0x64,
-    0x65, 0x72, 0x73, 0x20, 0x3d, 0x20, 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x2e, 0x73, 0x65,
-    0x61, 0x72, 0x63, 0x68, 0x65, 0x72, 0x73, 0x0a, 0x65, 0x6e, 0x64, 0x0a, 0x0a, 0x69, 0x66, 0x20,
-    0x6e, 0x6f, 0x74, 0x20, 0x6c, 0x6f, 0x61, 0x64, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x20, 0x74,
-    0x68, 0x65, 0x6e, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x6c, 0x6f, 0x61, 0x64, 0x73, 0x74, 0x72, 0x69,
-    0x6e, 0x67, 0x20, 0x3d, 0x20, 0x6c, 0x6f, 0x61, 0x64, 0x0a, 0x65, 0x6e, 0x64, 0x0a, 0x0a, 0x2d,
+    0x22, 0x25, 0x30, 0x32, 0x78, 0x22, 0x2c, 0x62, 0x79, 0x74, 0x65, 0x28, 0x63, 0x29, 0x29, 0x0a,
+    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x65, 0x6e, 0x64, 0x29,
+    0x29, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x65, 0x6e, 0x64, 0x0a, 0x20, 0x20,
+    0x20, 0x20, 0x65, 0x6e, 0x64, 0x0a, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x69, 0x66, 0x20, 0x6e, 0x6f,
+    0x74, 0x20, 0x6d, 0x64, 0x35, 0x2e, 0x73, 0x75, 0x6d, 0x48, 0x45, 0x58, 0x41, 0x20, 0x74, 0x68,
+    0x65, 0x6e, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74,
+    0x69, 0x6f, 0x6e, 0x20, 0x6d, 0x64, 0x35, 0x2e, 0x73, 0x75, 0x6d, 0x48, 0x45, 0x58, 0x41, 0x28,
+    0x6b, 0x29, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x72,
+    0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x28, 0x67, 0x73, 0x75, 0x62, 0x28, 0x73, 0x75, 0x6d, 0x28,
+    0x6b, 0x29, 0x2c, 0x20, 0x22, 0x2e, 0x22, 0x2c, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f,
+    0x6e, 0x28, 0x63, 0x29, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+    0x20, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x66, 0x6f, 0x72, 0x6d,
+    0x61, 0x74, 0x28, 0x22, 0x25, 0x30, 0x32, 0x58, 0x22, 0x2c, 0x62, 0x79, 0x74, 0x65, 0x28, 0x63,
+    0x29, 0x29, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x65,
+    0x6e, 0x64, 0x29, 0x29, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x65, 0x6e, 0x64,
+    0x0a, 0x20, 0x20, 0x20, 0x20, 0x65, 0x6e, 0x64, 0x0a, 0x0a, 0x65, 0x6e, 0x64, 0x0a, 0x0a, 0x2d,
     0x2d, 0x20, 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x74, 0x69, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x79, 0x3a,
-    0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x6d, 0x69, 0x67, 0x68, 0x74, 0x20, 0x73, 0x74, 0x61, 0x79,
-    0x0a, 0x0a, 0x69, 0x66, 0x20, 0x62, 0x69, 0x74, 0x33, 0x32, 0x20, 0x74, 0x68, 0x65, 0x6e, 0x0a,
-    0x0a, 0x20, 0x20, 0x20, 0x20, 0x2d, 0x2d, 0x20, 0x6c, 0x75, 0x61, 0x20, 0x35, 0x2e, 0x32, 0x3a,
-    0x20, 0x77, 0x65, 0x27, 0x72, 0x65, 0x20, 0x6f, 0x6b, 0x61, 0x79, 0x0a, 0x0a, 0x65, 0x6c, 0x73,
-    0x65, 0x69, 0x66, 0x20, 0x75, 0x74, 0x66, 0x38, 0x20, 0x74, 0x68, 0x65, 0x6e, 0x0a, 0x0a, 0x20,
-    0x20, 0x20, 0x20, 0x2d, 0x2d, 0x20, 0x6c, 0x75, 0x61, 0x20, 0x35, 0x2e, 0x33, 0x3a, 0x20, 0x20,
-    0x62, 0x69, 0x74, 0x77, 0x69, 0x73, 0x65, 0x2e, 0x6c, 0x75, 0x61, 0x2c, 0x20, 0x76, 0x20, 0x31,
-    0x2e, 0x32, 0x34, 0x20, 0x32, 0x30, 0x31, 0x34, 0x2f, 0x31, 0x32, 0x2f, 0x32, 0x36, 0x20, 0x31,
-    0x37, 0x3a, 0x32, 0x30, 0x3a, 0x35, 0x33, 0x20, 0x72, 0x6f, 0x62, 0x65, 0x72, 0x74, 0x6f, 0x0a,
-    0x0a, 0x20, 0x20, 0x20, 0x20, 0x62, 0x69, 0x74, 0x33, 0x32, 0x20, 0x3d, 0x20, 0x6c, 0x6f, 0x61,
-    0x64, 0x20, 0x28, 0x20, 0x5b, 0x5b, 0x0a, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x20, 0x73, 0x65, 0x6c,
-    0x65, 0x63, 0x74, 0x20, 0x3d, 0x20, 0x73, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x20, 0x2d, 0x2d, 0x20,
-    0x69, 0x6e, 0x73, 0x74, 0x65, 0x61, 0x64, 0x20, 0x6f, 0x66, 0x3a, 0x20, 0x61, 0x72, 0x67, 0x20,
-    0x3d, 0x20, 0x7b, 0x20, 0x2e, 0x2e, 0x2e, 0x20, 0x7d, 0x0a, 0x0a, 0x62, 0x69, 0x74, 0x33, 0x32,
-    0x20, 0x3d, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x62, 0x6e, 0x6f, 0x74, 0x20, 0x3d, 0x20, 0x66, 0x75,
-    0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x28, 0x61, 0x29, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x72,
-    0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x7e, 0x61, 0x20, 0x26, 0x20, 0x30, 0x78, 0x46, 0x46, 0x46,
-    0x46, 0x46, 0x46, 0x46, 0x46, 0x0a, 0x20, 0x20, 0x65, 0x6e, 0x64, 0x2c, 0x0a, 0x20, 0x20, 0x62,
-    0x61, 0x6e, 0x64, 0x20, 0x3d, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x28,
-    0x78, 0x2c, 0x20, 0x79, 0x2c, 0x20, 0x7a, 0x2c, 0x20, 0x2e, 0x2e, 0x2e, 0x29, 0x0a, 0x20, 0x20,
-    0x20, 0x20, 0x69, 0x66, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x7a, 0x20, 0x74, 0x68, 0x65, 0x6e, 0x0a,
-    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x28, 0x28, 0x78,
-    0x20, 0x6f, 0x72, 0x20, 0x2d, 0x31, 0x29, 0x20, 0x26, 0x20, 0x28, 0x79, 0x20, 0x6f, 0x72, 0x20,
-    0x2d, 0x31, 0x29, 0x29, 0x20, 0x26, 0x20, 0x30, 0x78, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46,
-    0x46, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x65, 0x6c, 0x73, 0x65, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20,
-    0x20, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x20, 0x72, 0x65, 0x73, 0x20, 0x3d, 0x20, 0x78, 0x20, 0x26,
-    0x20, 0x79, 0x20, 0x26, 0x20, 0x7a, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x66, 0x6f, 0x72,
-    0x20, 0x69, 0x3d, 0x31, 0x2c, 0x73, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x28, 0x22, 0x23, 0x22, 0x2c,
-    0x2e, 0x2e, 0x2e, 0x29, 0x20, 0x64, 0x6f, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-    0x72, 0x65, 0x73, 0x20, 0x3d, 0x20, 0x72, 0x65, 0x73, 0x20, 0x26, 0x20, 0x73, 0x65, 0x6c, 0x65,
-    0x63, 0x74, 0x28, 0x69, 0x2c, 0x2e, 0x2e, 0x2e, 0x29, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-    0x65, 0x6e, 0x64, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e,
-    0x20, 0x72, 0x65, 0x73, 0x20, 0x26, 0x20, 0x30, 0x78, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46,
-    0x46, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x65, 0x6e, 0x64, 0x0a, 0x20, 0x20, 0x65, 0x6e, 0x64, 0x2c,
-    0x0a, 0x20, 0x20, 0x62, 0x6f, 0x72, 0x20, 0x3d, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f,
+    0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x6d, 0x69, 0x67, 0x68, 0x74, 0x20, 0x67, 0x6f, 0x20, 0x61,
+    0x77, 0x61, 0x79, 0x0a, 0x0a, 0x69, 0x66, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x75, 0x6e, 0x70, 0x61,
+    0x63, 0x6b, 0x20, 0x74, 0x68, 0x65, 0x6e, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x75, 0x6e, 0x70, 0x61,
+    0x63, 0x6b, 0x20, 0x3d, 0x20, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x2e, 0x75, 0x6e, 0x70, 0x61, 0x63,
+    0x6b, 0x0a, 0x65, 0x6e, 0x64, 0x0a, 0x0a, 0x69, 0x66, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x70, 0x61,
+    0x63, 0x6b, 0x61, 0x67, 0x65, 0x2e, 0x6c, 0x6f, 0x61, 0x64, 0x65, 0x72, 0x73, 0x20, 0x74, 0x68,
+    0x65, 0x6e, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x2e, 0x6c,
+    0x6f, 0x61, 0x64, 0x65, 0x72, 0x73, 0x20, 0x3d, 0x20, 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65,
+    0x2e, 0x73, 0x65, 0x61, 0x72, 0x63, 0x68, 0x65, 0x72, 0x73, 0x0a, 0x65, 0x6e, 0x64, 0x0a, 0x0a,
+    0x69, 0x66, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x6c, 0x6f, 0x61, 0x64, 0x73, 0x74, 0x72, 0x69, 0x6e,
+    0x67, 0x20, 0x74, 0x68, 0x65, 0x6e, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x6c, 0x6f, 0x61, 0x64, 0x73,
+    0x74, 0x72, 0x69, 0x6e, 0x67, 0x20, 0x3d, 0x20, 0x6c, 0x6f, 0x61, 0x64, 0x0a, 0x65, 0x6e, 0x64,
+    0x0a, 0x0a, 0x2d, 0x2d, 0x20, 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x74, 0x69, 0x62, 0x69, 0x6c, 0x69,
+    0x74, 0x79, 0x3a, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x6d, 0x69, 0x67, 0x68, 0x74, 0x20, 0x73,
+    0x74, 0x61, 0x79, 0x0a, 0x0a, 0x69, 0x66, 0x20, 0x62, 0x69, 0x74, 0x33, 0x32, 0x20, 0x74, 0x68,
+    0x65, 0x6e, 0x0a, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x2d, 0x2d, 0x20, 0x6c, 0x75, 0x61, 0x20, 0x35,
+    0x2e, 0x32, 0x3a, 0x20, 0x77, 0x65, 0x27, 0x72, 0x65, 0x20, 0x6f, 0x6b, 0x61, 0x79, 0x0a, 0x0a,
+    0x65, 0x6c, 0x73, 0x65, 0x69, 0x66, 0x20, 0x75, 0x74, 0x66, 0x38, 0x20, 0x74, 0x68, 0x65, 0x6e,
+    0x0a, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x2d, 0x2d, 0x20, 0x6c, 0x75, 0x61, 0x20, 0x35, 0x2e, 0x33,
+    0x3a, 0x20, 0x20, 0x62, 0x69, 0x74, 0x77, 0x69, 0x73, 0x65, 0x2e, 0x6c, 0x75, 0x61, 0x2c, 0x20,
+    0x76, 0x20, 0x31, 0x2e, 0x32, 0x34, 0x20, 0x32, 0x30, 0x31, 0x34, 0x2f, 0x31, 0x32, 0x2f, 0x32,
+    0x36, 0x20, 0x31, 0x37, 0x3a, 0x32, 0x30, 0x3a, 0x35, 0x33, 0x20, 0x72, 0x6f, 0x62, 0x65, 0x72,
+    0x74, 0x6f, 0x0a, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x62, 0x69, 0x74, 0x33, 0x32, 0x20, 0x3d, 0x20,
+    0x6c, 0x6f, 0x61, 0x64, 0x20, 0x28, 0x20, 0x5b, 0x5b, 0x0a, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x20,
+    0x73, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x20, 0x3d, 0x20, 0x73, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x20,
+    0x2d, 0x2d, 0x20, 0x69, 0x6e, 0x73, 0x74, 0x65, 0x61, 0x64, 0x20, 0x6f, 0x66, 0x3a, 0x20, 0x61,
+    0x72, 0x67, 0x20, 0x3d, 0x20, 0x7b, 0x20, 0x2e, 0x2e, 0x2e, 0x20, 0x7d, 0x0a, 0x0a, 0x62, 0x69,
+    0x74, 0x33, 0x32, 0x20, 0x3d, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x62, 0x6e, 0x6f, 0x74, 0x20, 0x3d,
+    0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x28, 0x61, 0x29, 0x0a, 0x20, 0x20,
+    0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x7e, 0x61, 0x20, 0x26, 0x20, 0x30, 0x78,
+    0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x0a, 0x20, 0x20, 0x65, 0x6e, 0x64, 0x2c, 0x0a,
+    0x20, 0x20, 0x62, 0x61, 0x6e, 0x64, 0x20, 0x3d, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f,
     0x6e, 0x20, 0x28, 0x78, 0x2c, 0x20, 0x79, 0x2c, 0x20, 0x7a, 0x2c, 0x20, 0x2e, 0x2e, 0x2e, 0x29,
     0x0a, 0x20, 0x20, 0x20, 0x20, 0x69, 0x66, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x7a, 0x20, 0x74, 0x68,
     0x65, 0x6e, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20,
-    0x28, 0x28, 0x78, 0x20, 0x6f, 0x72, 0x20, 0x30, 0x29, 0x20, 0x7c, 0x20, 0x28, 0x79, 0x20, 0x6f,
-    0x72, 0x20, 0x30, 0x29, 0x29, 0x20, 0x26, 0x20, 0x30, 0x78, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46,
-    0x46, 0x46, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x65, 0x6c, 0x73, 0x65, 0x0a, 0x20, 0x20, 0x20, 0x20,
-    0x20, 0x20, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x20, 0x72, 0x65, 0x73, 0x20, 0x3d, 0x20, 0x78, 0x20,
-    0x7c, 0x20, 0x79, 0x20, 0x7c, 0x20, 0x7a, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x66, 0x6f,
-    0x72, 0x20, 0x69, 0x3d, 0x31, 0x2c, 0x73, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x28, 0x22, 0x23, 0x22,
-    0x2c, 0x2e, 0x2e, 0x2e, 0x29, 0x20, 0x64, 0x6f, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-    0x20, 0x72, 0x65, 0x73, 0x20, 0x3d, 0x20, 0x72, 0x65, 0x73, 0x20, 0x7c, 0x20, 0x73, 0x65, 0x6c,
-    0x65, 0x63, 0x74, 0x28, 0x69, 0x2c, 0x2e, 0x2e, 0x2e, 0x29, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20,
-    0x20, 0x65, 0x6e, 0x64, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72,
-    0x6e, 0x20, 0x72, 0x65, 0x73, 0x20, 0x26, 0x20, 0x30, 0x78, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46,
-    0x46, 0x46, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x65, 0x6e, 0x64, 0x0a, 0x20, 0x20, 0x65, 0x6e, 0x64,
-    0x2c, 0x0a, 0x20, 0x20, 0x62, 0x78, 0x6f, 0x72, 0x20, 0x3d, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74,
-    0x69, 0x6f, 0x6e, 0x20, 0x28, 0x78, 0x2c, 0x20, 0x79, 0x2c, 0x20, 0x7a, 0x2c, 0x20, 0x2e, 0x2e,
-    0x2e, 0x29, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x69, 0x66, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x7a, 0x20,
-    0x74, 0x68, 0x65, 0x6e, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72,
-    0x6e, 0x20, 0x28, 0x28, 0x78, 0x20, 0x6f, 0x72, 0x20, 0x30, 0x29, 0x20, 0x7e, 0x20, 0x28, 0x79,
-    0x20, 0x6f, 0x72, 0x20, 0x30, 0x29, 0x29, 0x20, 0x26, 0x20, 0x30, 0x78, 0x46, 0x46, 0x46, 0x46,
+    0x28, 0x28, 0x78, 0x20, 0x6f, 0x72, 0x20, 0x2d, 0x31, 0x29, 0x20, 0x26, 0x20, 0x28, 0x79, 0x20,
+    0x6f, 0x72, 0x20, 0x2d, 0x31, 0x29, 0x29, 0x20, 0x26, 0x20, 0x30, 0x78, 0x46, 0x46, 0x46, 0x46,
     0x46, 0x46, 0x46, 0x46, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x65, 0x6c, 0x73, 0x65, 0x0a, 0x20, 0x20,
     0x20, 0x20, 0x20, 0x20, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x20, 0x72, 0x65, 0x73, 0x20, 0x3d, 0x20,
-    0x78, 0x20, 0x7e, 0x20, 0x79, 0x20, 0x7e, 0x20, 0x7a, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+    0x78, 0x20, 0x26, 0x20, 0x79, 0x20, 0x26, 0x20, 0x7a, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
     0x66, 0x6f, 0x72, 0x20, 0x69, 0x3d, 0x31, 0x2c, 0x73, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x28, 0x22,
     0x23, 0x22, 0x2c, 0x2e, 0x2e, 0x2e, 0x29, 0x20, 0x64, 0x6f, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20,
-    0x20, 0x20, 0x20, 0x72, 0x65, 0x73, 0x20, 0x3d, 0x20, 0x72, 0x65, 0x73, 0x20, 0x7e, 0x20, 0x73,
+    0x20, 0x20, 0x20, 0x72, 0x65, 0x73, 0x20, 0x3d, 0x20, 0x72, 0x65, 0x73, 0x20, 0x26, 0x20, 0x73,
     0x65, 0x6c, 0x65, 0x63, 0x74, 0x28, 0x69, 0x2c, 0x2e, 0x2e, 0x2e, 0x29, 0x0a, 0x20, 0x20, 0x20,
     0x20, 0x20, 0x20, 0x65, 0x6e, 0x64, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74,
     0x75, 0x72, 0x6e, 0x20, 0x72, 0x65, 0x73, 0x20, 0x26, 0x20, 0x30, 0x78, 0x46, 0x46, 0x46, 0x46,
     0x46, 0x46, 0x46, 0x46, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x65, 0x6e, 0x64, 0x0a, 0x20, 0x20, 0x65,
-    0x6e, 0x64, 0x2c, 0x0a, 0x20, 0x20, 0x62, 0x74, 0x65, 0x73, 0x74, 0x20, 0x3d, 0x20, 0x66, 0x75,
+    0x6e, 0x64, 0x2c, 0x0a, 0x20, 0x20, 0x62, 0x6f, 0x72, 0x20, 0x3d, 0x20, 0x66, 0x75, 0x6e, 0x63,
+    0x74, 0x69, 0x6f, 0x6e, 0x20, 0x28, 0x78, 0x2c, 0x20, 0x79, 0x2c, 0x20, 0x7a, 0x2c, 0x20, 0x2e,
+    0x2e, 0x2e, 0x29, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x69, 0x66, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x7a,
+    0x20, 0x74, 0x68, 0x65, 0x6e, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75,
+    0x72, 0x6e, 0x20, 0x28, 0x28, 0x78, 0x20, 0x6f, 0x72, 0x20, 0x30, 0x29, 0x20, 0x7c, 0x20, 0x28,
+    0x79, 0x20, 0x6f, 0x72, 0x20, 0x30, 0x29, 0x29, 0x20, 0x26, 0x20, 0x30, 0x78, 0x46, 0x46, 0x46,
+    0x46, 0x46, 0x46, 0x46, 0x46, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x65, 0x6c, 0x73, 0x65, 0x0a, 0x20,
+    0x20, 0x20, 0x20, 0x20, 0x20, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x20, 0x72, 0x65, 0x73, 0x20, 0x3d,
+    0x20, 0x78, 0x20, 0x7c, 0x20, 0x79, 0x20, 0x7c, 0x20, 0x7a, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20,
+    0x20, 0x66, 0x6f, 0x72, 0x20, 0x69, 0x3d, 0x31, 0x2c, 0x73, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x28,
+    0x22, 0x23, 0x22, 0x2c, 0x2e, 0x2e, 0x2e, 0x29, 0x20, 0x64, 0x6f, 0x0a, 0x20, 0x20, 0x20, 0x20,
+    0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x73, 0x20, 0x3d, 0x20, 0x72, 0x65, 0x73, 0x20, 0x7c, 0x20,
+    0x73, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x28, 0x69, 0x2c, 0x2e, 0x2e, 0x2e, 0x29, 0x0a, 0x20, 0x20,
+    0x20, 0x20, 0x20, 0x20, 0x65, 0x6e, 0x64, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65,
+    0x74, 0x75, 0x72, 0x6e, 0x20, 0x72, 0x65, 0x73, 0x20, 0x26, 0x20, 0x30, 0x78, 0x46, 0x46, 0x46,
+    0x46, 0x46, 0x46, 0x46, 0x46, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x65, 0x6e, 0x64, 0x0a, 0x20, 0x20,
+    0x65, 0x6e, 0x64, 0x2c, 0x0a, 0x20, 0x20, 0x62, 0x78, 0x6f, 0x72, 0x20, 0x3d, 0x20, 0x66, 0x75,
     0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x28, 0x78, 0x2c, 0x20, 0x79, 0x2c, 0x20, 0x7a, 0x2c,
     0x20, 0x2e, 0x2e, 0x2e, 0x29, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x69, 0x66, 0x20, 0x6e, 0x6f, 0x74,
     0x20, 0x7a, 0x20, 0x74, 0x68, 0x65, 0x6e, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65,
-    0x74, 0x75, 0x72, 0x6e, 0x20, 0x28, 0x28, 0x28, 0x78, 0x20, 0x6f, 0x72, 0x20, 0x2d, 0x31, 0x29,
-    0x20, 0x26, 0x20, 0x28, 0x79, 0x20, 0x6f, 0x72, 0x20, 0x2d, 0x31, 0x29, 0x29, 0x20, 0x26, 0x20,
-    0x30, 0x78, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x29, 0x20, 0x7e, 0x3d, 0x20, 0x30,
-    0x0a, 0x20, 0x20, 0x20, 0x20, 0x65, 0x6c, 0x73, 0x65, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-    0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x20, 0x72, 0x65, 0x73, 0x20, 0x3d, 0x20, 0x78, 0x20, 0x26, 0x20,
-    0x79, 0x20, 0x26, 0x20, 0x7a, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x66, 0x6f, 0x72, 0x20,
-    0x69, 0x3d, 0x31, 0x2c, 0x73, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x28, 0x22, 0x23, 0x22, 0x2c, 0x2e,
-    0x2e, 0x2e, 0x29, 0x20, 0x64, 0x6f, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-    0x20, 0x72, 0x65, 0x73, 0x20, 0x3d, 0x20, 0x72, 0x65, 0x73, 0x20, 0x26, 0x20, 0x73, 0x65, 0x6c,
-    0x65, 0x63, 0x74, 0x28, 0x69, 0x2c, 0x2e, 0x2e, 0x2e, 0x29, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20,
-    0x20, 0x65, 0x6e, 0x64, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72,
-    0x6e, 0x20, 0x28, 0x72, 0x65, 0x73, 0x20, 0x26, 0x20, 0x30, 0x78, 0x46, 0x46, 0x46, 0x46, 0x46,
-    0x46, 0x46, 0x46, 0x29, 0x20, 0x7e, 0x3d, 0x20, 0x30, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x65, 0x6e,
-    0x64, 0x0a, 0x20, 0x20, 0x65, 0x6e, 0x64, 0x2c, 0x0a, 0x20, 0x20, 0x6c, 0x73, 0x68, 0x69, 0x66,
-    0x74, 0x20, 0x3d, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x28, 0x61, 0x2c,
-    0x20, 0x62, 0x29, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x28,
-    0x28, 0x61, 0x20, 0x26, 0x20, 0x30, 0x78, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x29,
-    0x20, 0x3c, 0x3c, 0x20, 0x62, 0x29, 0x20, 0x26, 0x20, 0x30, 0x78, 0x46, 0x46, 0x46, 0x46, 0x46,
-    0x46, 0x46, 0x46, 0x0a, 0x20, 0x20, 0x65, 0x6e, 0x64, 0x2c, 0x0a, 0x20, 0x20, 0x72, 0x73, 0x68,
-    0x69, 0x66, 0x74, 0x20, 0x3d, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x28,
-    0x61, 0x2c, 0x20, 0x62, 0x29, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e,
-    0x20, 0x28, 0x28, 0x61, 0x20, 0x26, 0x20, 0x30, 0x78, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46,
-    0x46, 0x29, 0x20, 0x3e, 0x3e, 0x20, 0x62, 0x29, 0x20, 0x26, 0x20, 0x30, 0x78, 0x46, 0x46, 0x46,
-    0x46, 0x46, 0x46, 0x46, 0x46, 0x0a, 0x20, 0x20, 0x65, 0x6e, 0x64, 0x2c, 0x0a, 0x20, 0x20, 0x61,
+    0x74, 0x75, 0x72, 0x6e, 0x20, 0x28, 0x28, 0x78, 0x20, 0x6f, 0x72, 0x20, 0x30, 0x29, 0x20, 0x7e,
+    0x20, 0x28, 0x79, 0x20, 0x6f, 0x72, 0x20, 0x30, 0x29, 0x29, 0x20, 0x26, 0x20, 0x30, 0x78, 0x46,
+    0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x65, 0x6c, 0x73, 0x65,
+    0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x20, 0x72, 0x65, 0x73,
+    0x20, 0x3d, 0x20, 0x78, 0x20, 0x7e, 0x20, 0x79, 0x20, 0x7e, 0x20, 0x7a, 0x0a, 0x20, 0x20, 0x20,
+    0x20, 0x20, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x69, 0x3d, 0x31, 0x2c, 0x73, 0x65, 0x6c, 0x65, 0x63,
+    0x74, 0x28, 0x22, 0x23, 0x22, 0x2c, 0x2e, 0x2e, 0x2e, 0x29, 0x20, 0x64, 0x6f, 0x0a, 0x20, 0x20,
+    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x73, 0x20, 0x3d, 0x20, 0x72, 0x65, 0x73, 0x20,
+    0x7e, 0x20, 0x73, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x28, 0x69, 0x2c, 0x2e, 0x2e, 0x2e, 0x29, 0x0a,
+    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x65, 0x6e, 0x64, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+    0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x72, 0x65, 0x73, 0x20, 0x26, 0x20, 0x30, 0x78, 0x46,
+    0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x65, 0x6e, 0x64, 0x0a,
+    0x20, 0x20, 0x65, 0x6e, 0x64, 0x2c, 0x0a, 0x20, 0x20, 0x62, 0x74, 0x65, 0x73, 0x74, 0x20, 0x3d,
+    0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x28, 0x78, 0x2c, 0x20, 0x79, 0x2c,
+    0x20, 0x7a, 0x2c, 0x20, 0x2e, 0x2e, 0x2e, 0x29, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x69, 0x66, 0x20,
+    0x6e, 0x6f, 0x74, 0x20, 0x7a, 0x20, 0x74, 0x68, 0x65, 0x6e, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20,
+    0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x28, 0x28, 0x28, 0x78, 0x20, 0x6f, 0x72, 0x20,
+    0x2d, 0x31, 0x29, 0x20, 0x26, 0x20, 0x28, 0x79, 0x20, 0x6f, 0x72, 0x20, 0x2d, 0x31, 0x29, 0x29,
+    0x20, 0x26, 0x20, 0x30, 0x78, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x29, 0x20, 0x7e,
+    0x3d, 0x20, 0x30, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x65, 0x6c, 0x73, 0x65, 0x0a, 0x20, 0x20, 0x20,
+    0x20, 0x20, 0x20, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x20, 0x72, 0x65, 0x73, 0x20, 0x3d, 0x20, 0x78,
+    0x20, 0x26, 0x20, 0x79, 0x20, 0x26, 0x20, 0x7a, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x66,
+    0x6f, 0x72, 0x20, 0x69, 0x3d, 0x31, 0x2c, 0x73, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x28, 0x22, 0x23,
+    0x22, 0x2c, 0x2e, 0x2e, 0x2e, 0x29, 0x20, 0x64, 0x6f, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+    0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x73, 0x20, 0x3d, 0x20, 0x72, 0x65, 0x73, 0x20, 0x26, 0x20,
+    0x73, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x28, 0x69, 0x2c, 0x2e, 0x2e, 0x2e, 0x29, 0x0a, 0x20, 0x20,
+    0x20, 0x20, 0x20, 0x20, 0x65, 0x6e, 0x64, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65,
+    0x74, 0x75, 0x72, 0x6e, 0x20, 0x28, 0x72, 0x65, 0x73, 0x20, 0x26, 0x20, 0x30, 0x78, 0x46, 0x46,
+    0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x29, 0x20, 0x7e, 0x3d, 0x20, 0x30, 0x0a, 0x20, 0x20, 0x20,
+    0x20, 0x65, 0x6e, 0x64, 0x0a, 0x20, 0x20, 0x65, 0x6e, 0x64, 0x2c, 0x0a, 0x20, 0x20, 0x6c, 0x73,
+    0x68, 0x69, 0x66, 0x74, 0x20, 0x3d, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20,
+    0x28, 0x61, 0x2c, 0x20, 0x62, 0x29, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72,
+    0x6e, 0x20, 0x28, 0x28, 0x61, 0x20, 0x26, 0x20, 0x30, 0x78, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46,
+    0x46, 0x46, 0x29, 0x20, 0x3c, 0x3c, 0x20, 0x62, 0x29, 0x20, 0x26, 0x20, 0x30, 0x78, 0x46, 0x46,
+    0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x0a, 0x20, 0x20, 0x65, 0x6e, 0x64, 0x2c, 0x0a, 0x20, 0x20,
     0x72, 0x73, 0x68, 0x69, 0x66, 0x74, 0x20, 0x3d, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f,
-    0x6e, 0x20, 0x28, 0x61, 0x2c, 0x20, 0x62, 0x29, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x61, 0x20, 0x3d,
-    0x20, 0x61, 0x20, 0x26, 0x20, 0x30, 0x78, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x0a,
-    0x20, 0x20, 0x20, 0x20, 0x69, 0x66, 0x20, 0x62, 0x20, 0x3c, 0x3d, 0x20, 0x30, 0x20, 0x6f, 0x72,
-    0x20, 0x28, 0x61, 0x20, 0x26, 0x20, 0x30, 0x78, 0x38, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
-    0x29, 0x20, 0x3d, 0x3d, 0x20, 0x30, 0x20, 0x74, 0x68, 0x65, 0x6e, 0x0a, 0x20, 0x20, 0x20, 0x20,
-    0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x28, 0x61, 0x20, 0x3e, 0x3e, 0x20, 0x62,
-    0x29, 0x20, 0x26, 0x20, 0x30, 0x78, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x0a, 0x20,
-    0x20, 0x20, 0x20, 0x65, 0x6c, 0x73, 0x65, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65,
-    0x74, 0x75, 0x72, 0x6e, 0x20, 0x28, 0x28, 0x61, 0x20, 0x3e, 0x3e, 0x20, 0x62, 0x29, 0x20, 0x7c,
-    0x20, 0x7e, 0x28, 0x30, 0x78, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x20, 0x3e, 0x3e,
-    0x20, 0x62, 0x29, 0x29, 0x20, 0x26, 0x20, 0x30, 0x78, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46,
-    0x46, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x65, 0x6e, 0x64, 0x0a, 0x20, 0x20, 0x65, 0x6e, 0x64, 0x2c,
-    0x0a, 0x20, 0x20, 0x6c, 0x72, 0x6f, 0x74, 0x61, 0x74, 0x65, 0x20, 0x3d, 0x20, 0x66, 0x75, 0x6e,
-    0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x28, 0x61, 0x20, 0x2c, 0x62, 0x29, 0x0a, 0x20, 0x20, 0x20,
-    0x20, 0x62, 0x20, 0x3d, 0x20, 0x62, 0x20, 0x26, 0x20, 0x33, 0x31, 0x0a, 0x20, 0x20, 0x20, 0x20,
+    0x6e, 0x20, 0x28, 0x61, 0x2c, 0x20, 0x62, 0x29, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74,
+    0x75, 0x72, 0x6e, 0x20, 0x28, 0x28, 0x61, 0x20, 0x26, 0x20, 0x30, 0x78, 0x46, 0x46, 0x46, 0x46,
+    0x46, 0x46, 0x46, 0x46, 0x29, 0x20, 0x3e, 0x3e, 0x20, 0x62, 0x29, 0x20, 0x26, 0x20, 0x30, 0x78,
+    0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x0a, 0x20, 0x20, 0x65, 0x6e, 0x64, 0x2c, 0x0a,
+    0x20, 0x20, 0x61, 0x72, 0x73, 0x68, 0x69, 0x66, 0x74, 0x20, 0x3d, 0x20, 0x66, 0x75, 0x6e, 0x63,
+    0x74, 0x69, 0x6f, 0x6e, 0x20, 0x28, 0x61, 0x2c, 0x20, 0x62, 0x29, 0x0a, 0x20, 0x20, 0x20, 0x20,
     0x61, 0x20, 0x3d, 0x20, 0x61, 0x20, 0x26, 0x20, 0x30, 0x78, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46,
-    0x46, 0x46, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x61, 0x20, 0x3d, 0x20, 0x28, 0x61, 0x20, 0x3c, 0x3c,
-    0x20, 0x62, 0x29, 0x20, 0x7c, 0x20, 0x28, 0x61, 0x20, 0x3e, 0x3e, 0x20, 0x28, 0x33, 0x32, 0x20,
-    0x2d, 0x20, 0x62, 0x29, 0x29, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e,
-    0x20, 0x61, 0x20, 0x26, 0x20, 0x30, 0x78, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x0a,
-    0x20, 0x20, 0x65, 0x6e, 0x64, 0x2c, 0x0a, 0x20, 0x20, 0x72, 0x72, 0x6f, 0x74, 0x61, 0x74, 0x65,
-    0x20, 0x3d, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x28, 0x61, 0x2c, 0x20,
-    0x62, 0x29, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x62, 0x20, 0x3d, 0x20, 0x2d, 0x62, 0x20, 0x26, 0x20,
-    0x33, 0x31, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x61, 0x20, 0x3d, 0x20, 0x61, 0x20, 0x26, 0x20, 0x30,
-    0x78, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x61, 0x20,
-    0x3d, 0x20, 0x28, 0x61, 0x20, 0x3c, 0x3c, 0x20, 0x62, 0x29, 0x20, 0x7c, 0x20, 0x28, 0x61, 0x20,
-    0x3e, 0x3e, 0x20, 0x28, 0x33, 0x32, 0x20, 0x2d, 0x20, 0x62, 0x29, 0x29, 0x0a, 0x20, 0x20, 0x20,
-    0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x61, 0x20, 0x26, 0x20, 0x30, 0x78, 0x46, 0x46,
-    0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x0a, 0x20, 0x20, 0x65, 0x6e, 0x64, 0x2c, 0x0a, 0x20, 0x20,
-    0x65, 0x78, 0x74, 0x72, 0x61, 0x63, 0x74, 0x20, 0x3d, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69,
-    0x6f, 0x6e, 0x20, 0x28, 0x61, 0x2c, 0x20, 0x66, 0x2c, 0x20, 0x77, 0x29, 0x0a, 0x20, 0x20, 0x20,
-    0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x28, 0x61, 0x20, 0x3e, 0x3e, 0x20, 0x66, 0x29,
-    0x20, 0x26, 0x20, 0x7e, 0x28, 0x2d, 0x31, 0x20, 0x3c, 0x3c, 0x20, 0x28, 0x77, 0x20, 0x6f, 0x72,
-    0x20, 0x31, 0x29, 0x29, 0x0a, 0x20, 0x20, 0x65, 0x6e, 0x64, 0x2c, 0x0a, 0x20, 0x20, 0x72, 0x65,
-    0x70, 0x6c, 0x61, 0x63, 0x65, 0x20, 0x3d, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e,
-    0x20, 0x28, 0x61, 0x2c, 0x20, 0x76, 0x2c, 0x20, 0x66, 0x2c, 0x20, 0x77, 0x29, 0x0a, 0x20, 0x20,
-    0x20, 0x20, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x20, 0x6d, 0x61, 0x73, 0x6b, 0x20, 0x3d, 0x20, 0x7e,
-    0x28, 0x2d, 0x31, 0x20, 0x3c, 0x3c, 0x20, 0x28, 0x77, 0x20, 0x6f, 0x72, 0x20, 0x31, 0x29, 0x29,
-    0x0a, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x28, 0x28, 0x61, 0x20,
-    0x26, 0x20, 0x7e, 0x28, 0x6d, 0x61, 0x73, 0x6b, 0x20, 0x3c, 0x3c, 0x20, 0x66, 0x29, 0x29, 0x20,
-    0x7c, 0x20, 0x28, 0x28, 0x76, 0x20, 0x26, 0x20, 0x6d, 0x61, 0x73, 0x6b, 0x29, 0x20, 0x3c, 0x3c,
-    0x20, 0x66, 0x29, 0x29, 0x20, 0x26, 0x20, 0x30, 0x78, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46,
-    0x46, 0x0a, 0x20, 0x20, 0x65, 0x6e, 0x64, 0x2c, 0x0a, 0x7d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20,
-    0x20, 0x20, 0x20, 0x5d, 0x5d, 0x20, 0x29, 0x0a, 0x0a, 0x65, 0x6c, 0x73, 0x65, 0x69, 0x66, 0x20,
-    0x62, 0x69, 0x74, 0x20, 0x74, 0x68, 0x65, 0x6e, 0x0a, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x2d, 0x2d,
-    0x20, 0x6c, 0x75, 0x61, 0x6a, 0x69, 0x74, 0x20, 0x28, 0x66, 0x6f, 0x72, 0x20, 0x6e, 0x6f, 0x77,
-    0x29, 0x0a, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x62, 0x69, 0x74, 0x33, 0x32, 0x20, 0x3d, 0x20, 0x6c,
-    0x6f, 0x61, 0x64, 0x20, 0x28, 0x20, 0x5b, 0x5b, 0x0a, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x20, 0x62,
-    0x61, 0x6e, 0x64, 0x2c, 0x20, 0x62, 0x6e, 0x6f, 0x74, 0x2c, 0x20, 0x72, 0x73, 0x68, 0x69, 0x66,
-    0x74, 0x2c, 0x20, 0x6c, 0x73, 0x68, 0x69, 0x66, 0x74, 0x20, 0x3d, 0x20, 0x62, 0x69, 0x74, 0x2e,
-    0x62, 0x61, 0x6e, 0x64, 0x2c, 0x20, 0x62, 0x69, 0x74, 0x2e, 0x62, 0x6e, 0x6f, 0x74, 0x2c, 0x20,
-    0x62, 0x69, 0x74, 0x2e, 0x72, 0x73, 0x68, 0x69, 0x66, 0x74, 0x2c, 0x20, 0x62, 0x69, 0x74, 0x2e,
-    0x6c, 0x73, 0x68, 0x69, 0x66, 0x74, 0x0a, 0x0a, 0x62, 0x69, 0x74, 0x33, 0x32, 0x20, 0x3d, 0x20,
-    0x7b, 0x0a, 0x20, 0x20, 0x61, 0x72, 0x73, 0x68, 0x69, 0x66, 0x74, 0x20, 0x3d, 0x20, 0x62, 0x69,
-    0x74, 0x2e, 0x61, 0x72, 0x73, 0x68, 0x69, 0x66, 0x74, 0x2c, 0x0a, 0x20, 0x20, 0x62, 0x61, 0x6e,
-    0x64, 0x20, 0x20, 0x20, 0x20, 0x3d, 0x20, 0x62, 0x61, 0x6e, 0x64, 0x2c, 0x0a, 0x20, 0x20, 0x62,
-    0x6e, 0x6f, 0x74, 0x20, 0x20, 0x20, 0x20, 0x3d, 0x20, 0x62, 0x6e, 0x6f, 0x74, 0x2c, 0x0a, 0x20,
-    0x20, 0x62, 0x6f, 0x72, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3d, 0x20, 0x62, 0x69, 0x74, 0x2e, 0x62,
-    0x6f, 0x72, 0x2c, 0x0a, 0x20, 0x20, 0x62, 0x78, 0x6f, 0x72, 0x20, 0x20, 0x20, 0x20, 0x3d, 0x20,
-    0x62, 0x69, 0x74, 0x2e, 0x62, 0x78, 0x6f, 0x72, 0x2c, 0x0a, 0x20, 0x20, 0x62, 0x74, 0x65, 0x73,
-    0x74, 0x20, 0x20, 0x20, 0x3d, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x2e,
-    0x2e, 0x2e, 0x29, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x62,
-    0x61, 0x6e, 0x64, 0x28, 0x2e, 0x2e, 0x2e, 0x29, 0x20, 0x7e, 0x3d, 0x20, 0x30, 0x0a, 0x20, 0x20,
-    0x65, 0x6e, 0x64, 0x2c, 0x0a, 0x20, 0x20, 0x65, 0x78, 0x74, 0x72, 0x61, 0x63, 0x74, 0x20, 0x3d,
-    0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x61, 0x2c, 0x66, 0x2c, 0x77, 0x29,
-    0x0a, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x62, 0x61, 0x6e, 0x64,
-    0x28, 0x72, 0x73, 0x68, 0x69, 0x66, 0x74, 0x28, 0x61, 0x2c, 0x66, 0x29, 0x2c, 0x32, 0x5e, 0x28,
-    0x77, 0x20, 0x6f, 0x72, 0x20, 0x31, 0x29, 0x2d, 0x31, 0x29, 0x0a, 0x20, 0x20, 0x65, 0x6e, 0x64,
-    0x2c, 0x0a, 0x20, 0x20, 0x6c, 0x72, 0x6f, 0x74, 0x61, 0x74, 0x65, 0x20, 0x3d, 0x20, 0x62, 0x69,
-    0x74, 0x2e, 0x72, 0x6f, 0x6c, 0x2c, 0x0a, 0x20, 0x20, 0x6c, 0x73, 0x68, 0x69, 0x66, 0x74, 0x20,
-    0x20, 0x3d, 0x20, 0x6c, 0x73, 0x68, 0x69, 0x66, 0x74, 0x2c, 0x0a, 0x20, 0x20, 0x72, 0x65, 0x70,
-    0x6c, 0x61, 0x63, 0x65, 0x20, 0x3d, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28,
-    0x61, 0x2c, 0x76, 0x2c, 0x66, 0x2c, 0x77, 0x29, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x6c, 0x6f, 0x63,
-    0x61, 0x6c, 0x20, 0x6d, 0x61, 0x73, 0x6b, 0x20, 0x3d, 0x20, 0x32, 0x5e, 0x28, 0x77, 0x20, 0x6f,
-    0x72, 0x20, 0x31, 0x29, 0x2d, 0x31, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72,
-    0x6e, 0x20, 0x62, 0x61, 0x6e, 0x64, 0x28, 0x61, 0x2c, 0x62, 0x6e, 0x6f, 0x74, 0x28, 0x6c, 0x73,
-    0x68, 0x69, 0x66, 0x74, 0x28, 0x6d, 0x61, 0x73, 0x6b, 0x2c, 0x66, 0x29, 0x29, 0x29, 0x2b, 0x6c,
-    0x73, 0x68, 0x69, 0x66, 0x74, 0x28, 0x62, 0x61, 0x6e, 0x64, 0x28, 0x76, 0x2c, 0x6d, 0x61, 0x73,
-    0x6b, 0x29, 0x2c, 0x66, 0x29, 0x0a, 0x20, 0x20, 0x65, 0x6e, 0x64, 0x2c, 0x0a, 0x20, 0x20, 0x72,
-    0x72, 0x6f, 0x74, 0x61, 0x74, 0x65, 0x20, 0x3d, 0x20, 0x62, 0x69, 0x74, 0x2e, 0x72, 0x6f, 0x72,
-    0x2c, 0x0a, 0x20, 0x20, 0x72, 0x73, 0x68, 0x69, 0x66, 0x74, 0x20, 0x20, 0x3d, 0x20, 0x72, 0x73,
-    0x68, 0x69, 0x66, 0x74, 0x2c, 0x0a, 0x7d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-    0x5d, 0x5d, 0x20, 0x29, 0x0a, 0x0a, 0x65, 0x6c, 0x73, 0x65, 0x0a, 0x0a, 0x20, 0x20, 0x20, 0x20,
-    0x2d, 0x2d, 0x20, 0x68, 0x6f, 0x70, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74, 0x68, 0x65, 0x20,
-    0x62, 0x65, 0x73, 0x74, 0x20, 0x6f, 0x72, 0x20, 0x66, 0x61, 0x69, 0x6c, 0x0a, 0x0a, 0x20, 0x20,
-    0x20, 0x20, 0x62, 0x69, 0x74, 0x33, 0x32, 0x20, 0x3d, 0x20, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72,
-    0x65, 0x28, 0x22, 0x62, 0x69, 0x74, 0x33, 0x32, 0x22, 0x29, 0x0a, 0x0a, 0x65, 0x6e, 0x64, 0x0a,
-    0x0a, 0x2d, 0x2d, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, 0x6e, 0x65, 0x65, 0x64,
-    0x65, 0x64, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x67, 0x65, 0x74, 0x74, 0x69, 0x6e, 0x67, 0x20, 0x72,
-    0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x28, 0x22, 0x73, 0x6f, 0x63, 0x6b, 0x65, 0x74, 0x22, 0x29,
-    0x20, 0x72, 0x69, 0x67, 0x68, 0x74, 0x0a, 0x0a, 0x64, 0x6f, 0x0a, 0x0a, 0x20, 0x20, 0x20, 0x20,
-    0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x20, 0x6c, 0x6f, 0x61, 0x64, 0x65, 0x64, 0x20, 0x3d, 0x20, 0x70,
-    0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x2e, 0x6c, 0x6f, 0x61, 0x64, 0x65, 0x64, 0x0a, 0x0a, 0x20,
-    0x20, 0x20, 0x20, 0x69, 0x66, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x6c, 0x6f, 0x61, 0x64, 0x65, 0x64,
-    0x2e, 0x73, 0x6f, 0x63, 0x6b, 0x65, 0x74, 0x20, 0x74, 0x68, 0x65, 0x6e, 0x20, 0x6c, 0x6f, 0x61,
-    0x64, 0x65, 0x64, 0x2e, 0x73, 0x6f, 0x63, 0x6b, 0x65, 0x74, 0x20, 0x3d, 0x20, 0x6c, 0x6f, 0x61,
-    0x64, 0x65, 0x64, 0x5b, 0x22, 0x73, 0x6f, 0x63, 0x6b, 0x65, 0x74, 0x2e, 0x63, 0x6f, 0x72, 0x65,
-    0x22, 0x5d, 0x20, 0x65, 0x6e, 0x64, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x69, 0x66, 0x20, 0x6e, 0x6f,
-    0x74, 0x20, 0x6c, 0x6f, 0x61, 0x64, 0x65, 0x64, 0x2e, 0x6d, 0x69, 0x6d, 0x65, 0x20, 0x20, 0x20,
-    0x74, 0x68, 0x65, 0x6e, 0x20, 0x6c, 0x6f, 0x61, 0x64, 0x65, 0x64, 0x2e, 0x6d, 0x69, 0x6d, 0x65,
-    0x20, 0x20, 0x20, 0x3d, 0x20, 0x6c, 0x6f, 0x61, 0x64, 0x65, 0x64, 0x5b, 0x22, 0x6d, 0x69, 0x6d,
-    0x65, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x22, 0x5d, 0x20, 0x20, 0x20, 0x65, 0x6e, 0x64, 0x0a, 0x0a,
-    0x65, 0x6e, 0x64, 0x0a, 0x0a, 0x2d, 0x2d, 0x20, 0x73, 0x6f, 0x20, 0x66, 0x61, 0x72, 0x0a, 0x0a, 0x00
+    0x46, 0x46, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x69, 0x66, 0x20, 0x62, 0x20, 0x3c, 0x3d, 0x20, 0x30,
+    0x20, 0x6f, 0x72, 0x20, 0x28, 0x61, 0x20, 0x26, 0x20, 0x30, 0x78, 0x38, 0x30, 0x30, 0x30, 0x30,
+    0x30, 0x30, 0x30, 0x29, 0x20, 0x3d, 0x3d, 0x20, 0x30, 0x20, 0x74, 0x68, 0x65, 0x6e, 0x0a, 0x20,
+    0x20, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x28, 0x61, 0x20, 0x3e,
+    0x3e, 0x20, 0x62, 0x29, 0x20, 0x26, 0x20, 0x30, 0x78, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46,
+    0x46, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x65, 0x6c, 0x73, 0x65, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20,
+    0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x28, 0x28, 0x61, 0x20, 0x3e, 0x3e, 0x20, 0x62,
+    0x29, 0x20, 0x7c, 0x20, 0x7e, 0x28, 0x30, 0x78, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46,
+    0x20, 0x3e, 0x3e, 0x20, 0x62, 0x29, 0x29, 0x20, 0x26, 0x20, 0x30, 0x78, 0x46, 0x46, 0x46, 0x46,
+    0x46, 0x46, 0x46, 0x46, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x65, 0x6e, 0x64, 0x0a, 0x20, 0x20, 0x65,
+    0x6e, 0x64, 0x2c, 0x0a, 0x20, 0x20, 0x6c, 0x72, 0x6f, 0x74, 0x61, 0x74, 0x65, 0x20, 0x3d, 0x20,
+    0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x28, 0x61, 0x20, 0x2c, 0x62, 0x29, 0x0a,
+    0x20, 0x20, 0x20, 0x20, 0x62, 0x20, 0x3d, 0x20, 0x62, 0x20, 0x26, 0x20, 0x33, 0x31, 0x0a, 0x20,
+    0x20, 0x20, 0x20, 0x61, 0x20, 0x3d, 0x20, 0x61, 0x20, 0x26, 0x20, 0x30, 0x78, 0x46, 0x46, 0x46,
+    0x46, 0x46, 0x46, 0x46, 0x46, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x61, 0x20, 0x3d, 0x20, 0x28, 0x61,
+    0x20, 0x3c, 0x3c, 0x20, 0x62, 0x29, 0x20, 0x7c, 0x20, 0x28, 0x61, 0x20, 0x3e, 0x3e, 0x20, 0x28,
+    0x33, 0x32, 0x20, 0x2d, 0x20, 0x62, 0x29, 0x29, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74,
+    0x75, 0x72, 0x6e, 0x20, 0x61, 0x20, 0x26, 0x20, 0x30, 0x78, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46,
+    0x46, 0x46, 0x0a, 0x20, 0x20, 0x65, 0x6e, 0x64, 0x2c, 0x0a, 0x20, 0x20, 0x72, 0x72, 0x6f, 0x74,
+    0x61, 0x74, 0x65, 0x20, 0x3d, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x28,
+    0x61, 0x2c, 0x20, 0x62, 0x29, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x62, 0x20, 0x3d, 0x20, 0x2d, 0x62,
+    0x20, 0x26, 0x20, 0x33, 0x31, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x61, 0x20, 0x3d, 0x20, 0x61, 0x20,
+    0x26, 0x20, 0x30, 0x78, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x0a, 0x20, 0x20, 0x20,
+    0x20, 0x61, 0x20, 0x3d, 0x20, 0x28, 0x61, 0x20, 0x3c, 0x3c, 0x20, 0x62, 0x29, 0x20, 0x7c, 0x20,
+    0x28, 0x61, 0x20, 0x3e, 0x3e, 0x20, 0x28, 0x33, 0x32, 0x20, 0x2d, 0x20, 0x62, 0x29, 0x29, 0x0a,
+    0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x61, 0x20, 0x26, 0x20, 0x30,
+    0x78, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x46, 0x0a, 0x20, 0x20, 0x65, 0x6e, 0x64, 0x2c,
+    0x0a, 0x20, 0x20, 0x65, 0x78, 0x74, 0x72, 0x61, 0x63, 0x74, 0x20, 0x3d, 0x20, 0x66, 0x75, 0x6e,
+    0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x28, 0x61, 0x2c, 0x20, 0x66, 0x2c, 0x20, 0x77, 0x29, 0x0a,
+    0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x28, 0x61, 0x20, 0x3e, 0x3e,
+    0x20, 0x66, 0x29, 0x20, 0x26, 0x20, 0x7e, 0x28, 0x2d, 0x31, 0x20, 0x3c, 0x3c, 0x20, 0x28, 0x77,
+    0x20, 0x6f, 0x72, 0x20, 0x31, 0x29, 0x29, 0x0a, 0x20, 0x20, 0x65, 0x6e, 0x64, 0x2c, 0x0a, 0x20,
+    0x20, 0x72, 0x65, 0x70, 0x6c, 0x61, 0x63, 0x65, 0x20, 0x3d, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74,
+    0x69, 0x6f, 0x6e, 0x20, 0x28, 0x61, 0x2c, 0x20, 0x76, 0x2c, 0x20, 0x66, 0x2c, 0x20, 0x77, 0x29,
+    0x0a, 0x20, 0x20, 0x20, 0x20, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x20, 0x6d, 0x61, 0x73, 0x6b, 0x20,
+    0x3d, 0x20, 0x7e, 0x28, 0x2d, 0x31, 0x20, 0x3c, 0x3c, 0x20, 0x28, 0x77, 0x20, 0x6f, 0x72, 0x20,
+    0x31, 0x29, 0x29, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x28,
+    0x28, 0x61, 0x20, 0x26, 0x20, 0x7e, 0x28, 0x6d, 0x61, 0x73, 0x6b, 0x20, 0x3c, 0x3c, 0x20, 0x66,
+    0x29, 0x29, 0x20, 0x7c, 0x20, 0x28, 0x28, 0x76, 0x20, 0x26, 0x20, 0x6d, 0x61, 0x73, 0x6b, 0x29,
+    0x20, 0x3c, 0x3c, 0x20, 0x66, 0x29, 0x29, 0x20, 0x26, 0x20, 0x30, 0x78, 0x46, 0x46, 0x46, 0x46,
+    0x46, 0x46, 0x46, 0x46, 0x0a, 0x20, 0x20, 0x65, 0x6e, 0x64, 0x2c, 0x0a, 0x7d, 0x0a, 0x20, 0x20,
+    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x5d, 0x5d, 0x20, 0x29, 0x0a, 0x0a, 0x65, 0x6c, 0x73, 0x65,
+    0x69, 0x66, 0x20, 0x62, 0x69, 0x74, 0x20, 0x74, 0x68, 0x65, 0x6e, 0x0a, 0x0a, 0x20, 0x20, 0x20,
+    0x20, 0x2d, 0x2d, 0x20, 0x6c, 0x75, 0x61, 0x6a, 0x69, 0x74, 0x20, 0x28, 0x66, 0x6f, 0x72, 0x20,
+    0x6e, 0x6f, 0x77, 0x29, 0x0a, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x62, 0x69, 0x74, 0x33, 0x32, 0x20,
+    0x3d, 0x20, 0x6c, 0x6f, 0x61, 0x64, 0x20, 0x28, 0x20, 0x5b, 0x5b, 0x0a, 0x6c, 0x6f, 0x63, 0x61,
+    0x6c, 0x20, 0x62, 0x61, 0x6e, 0x64, 0x2c, 0x20, 0x62, 0x6e, 0x6f, 0x74, 0x2c, 0x20, 0x72, 0x73,
+    0x68, 0x69, 0x66, 0x74, 0x2c, 0x20, 0x6c, 0x73, 0x68, 0x69, 0x66, 0x74, 0x20, 0x3d, 0x20, 0x62,
+    0x69, 0x74, 0x2e, 0x62, 0x61, 0x6e, 0x64, 0x2c, 0x20, 0x62, 0x69, 0x74, 0x2e, 0x62, 0x6e, 0x6f,
+    0x74, 0x2c, 0x20, 0x62, 0x69, 0x74, 0x2e, 0x72, 0x73, 0x68, 0x69, 0x66, 0x74, 0x2c, 0x20, 0x62,
+    0x69, 0x74, 0x2e, 0x6c, 0x73, 0x68, 0x69, 0x66, 0x74, 0x0a, 0x0a, 0x62, 0x69, 0x74, 0x33, 0x32,
+    0x20, 0x3d, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x61, 0x72, 0x73, 0x68, 0x69, 0x66, 0x74, 0x20, 0x3d,
+    0x20, 0x62, 0x69, 0x74, 0x2e, 0x61, 0x72, 0x73, 0x68, 0x69, 0x66, 0x74, 0x2c, 0x0a, 0x20, 0x20,
+    0x62, 0x61, 0x6e, 0x64, 0x20, 0x20, 0x20, 0x20, 0x3d, 0x20, 0x62, 0x61, 0x6e, 0x64, 0x2c, 0x0a,
+    0x20, 0x20, 0x62, 0x6e, 0x6f, 0x74, 0x20, 0x20, 0x20, 0x20, 0x3d, 0x20, 0x62, 0x6e, 0x6f, 0x74,
+    0x2c, 0x0a, 0x20, 0x20, 0x62, 0x6f, 0x72, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3d, 0x20, 0x62, 0x69,
+    0x74, 0x2e, 0x62, 0x6f, 0x72, 0x2c, 0x0a, 0x20, 0x20, 0x62, 0x78, 0x6f, 0x72, 0x20, 0x20, 0x20,
+    0x20, 0x3d, 0x20, 0x62, 0x69, 0x74, 0x2e, 0x62, 0x78, 0x6f, 0x72, 0x2c, 0x0a, 0x20, 0x20, 0x62,
+    0x74, 0x65, 0x73, 0x74, 0x20, 0x20, 0x20, 0x3d, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f,
+    0x6e, 0x28, 0x2e, 0x2e, 0x2e, 0x29, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72,
+    0x6e, 0x20, 0x62, 0x61, 0x6e, 0x64, 0x28, 0x2e, 0x2e, 0x2e, 0x29, 0x20, 0x7e, 0x3d, 0x20, 0x30,
+    0x0a, 0x20, 0x20, 0x65, 0x6e, 0x64, 0x2c, 0x0a, 0x20, 0x20, 0x65, 0x78, 0x74, 0x72, 0x61, 0x63,
+    0x74, 0x20, 0x3d, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x28, 0x61, 0x2c, 0x66,
+    0x2c, 0x77, 0x29, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x62,
+    0x61, 0x6e, 0x64, 0x28, 0x72, 0x73, 0x68, 0x69, 0x66, 0x74, 0x28, 0x61, 0x2c, 0x66, 0x29, 0x2c,
+    0x32, 0x5e, 0x28, 0x77, 0x20, 0x6f, 0x72, 0x20, 0x31, 0x29, 0x2d, 0x31, 0x29, 0x0a, 0x20, 0x20,
+    0x65, 0x6e, 0x64, 0x2c, 0x0a, 0x20, 0x20, 0x6c, 0x72, 0x6f, 0x74, 0x61, 0x74, 0x65, 0x20, 0x3d,
+    0x20, 0x62, 0x69, 0x74, 0x2e, 0x72, 0x6f, 0x6c, 0x2c, 0x0a, 0x20, 0x20, 0x6c, 0x73, 0x68, 0x69,
+    0x66, 0x74, 0x20, 0x20, 0x3d, 0x20, 0x6c, 0x73, 0x68, 0x69, 0x66, 0x74, 0x2c, 0x0a, 0x20, 0x20,
+    0x72, 0x65, 0x70, 0x6c, 0x61, 0x63, 0x65, 0x20, 0x3d, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69,
+    0x6f, 0x6e, 0x28, 0x61, 0x2c, 0x76, 0x2c, 0x66, 0x2c, 0x77, 0x29, 0x0a, 0x20, 0x20, 0x20, 0x20,
+    0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x20, 0x6d, 0x61, 0x73, 0x6b, 0x20, 0x3d, 0x20, 0x32, 0x5e, 0x28,
+    0x77, 0x20, 0x6f, 0x72, 0x20, 0x31, 0x29, 0x2d, 0x31, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65,
+    0x74, 0x75, 0x72, 0x6e, 0x20, 0x62, 0x61, 0x6e, 0x64, 0x28, 0x61, 0x2c, 0x62, 0x6e, 0x6f, 0x74,
+    0x28, 0x6c, 0x73, 0x68, 0x69, 0x66, 0x74, 0x28, 0x6d, 0x61, 0x73, 0x6b, 0x2c, 0x66, 0x29, 0x29,
+    0x29, 0x2b, 0x6c, 0x73, 0x68, 0x69, 0x66, 0x74, 0x28, 0x62, 0x61, 0x6e, 0x64, 0x28, 0x76, 0x2c,
+    0x6d, 0x61, 0x73, 0x6b, 0x29, 0x2c, 0x66, 0x29, 0x0a, 0x20, 0x20, 0x65, 0x6e, 0x64, 0x2c, 0x0a,
+    0x20, 0x20, 0x72, 0x72, 0x6f, 0x74, 0x61, 0x74, 0x65, 0x20, 0x3d, 0x20, 0x62, 0x69, 0x74, 0x2e,
+    0x72, 0x6f, 0x72, 0x2c, 0x0a, 0x20, 0x20, 0x72, 0x73, 0x68, 0x69, 0x66, 0x74, 0x20, 0x20, 0x3d,
+    0x20, 0x72, 0x73, 0x68, 0x69, 0x66, 0x74, 0x2c, 0x0a, 0x7d, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20,
+    0x20, 0x20, 0x20, 0x5d, 0x5d, 0x20, 0x29, 0x0a, 0x0a, 0x65, 0x6c, 0x73, 0x65, 0x0a, 0x0a, 0x20,
+    0x20, 0x20, 0x20, 0x2d, 0x2d, 0x20, 0x68, 0x6f, 0x70, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x74,
+    0x68, 0x65, 0x20, 0x62, 0x65, 0x73, 0x74, 0x20, 0x6f, 0x72, 0x20, 0x66, 0x61, 0x69, 0x6c, 0x0a,
+    0x0a, 0x20, 0x20, 0x20, 0x20, 0x62, 0x69, 0x74, 0x33, 0x32, 0x20, 0x3d, 0x20, 0x72, 0x65, 0x71,
+    0x75, 0x69, 0x72, 0x65, 0x28, 0x22, 0x62, 0x69, 0x74, 0x33, 0x32, 0x22, 0x29, 0x0a, 0x0a, 0x65,
+    0x6e, 0x64, 0x0a, 0x0a, 0x2d, 0x2d, 0x20, 0x74, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, 0x6e,
+    0x65, 0x65, 0x64, 0x65, 0x64, 0x20, 0x66, 0x6f, 0x72, 0x20, 0x67, 0x65, 0x74, 0x74, 0x69, 0x6e,
+    0x67, 0x20, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x28, 0x22, 0x73, 0x6f, 0x63, 0x6b, 0x65,
+    0x74, 0x22, 0x29, 0x20, 0x72, 0x69, 0x67, 0x68, 0x74, 0x0a, 0x0a, 0x64, 0x6f, 0x0a, 0x0a, 0x20,
+    0x20, 0x20, 0x20, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x20, 0x6c, 0x6f, 0x61, 0x64, 0x65, 0x64, 0x20,
+    0x3d, 0x20, 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x2e, 0x6c, 0x6f, 0x61, 0x64, 0x65, 0x64,
+    0x0a, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x69, 0x66, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x6c, 0x6f, 0x61,
+    0x64, 0x65, 0x64, 0x2e, 0x73, 0x6f, 0x63, 0x6b, 0x65, 0x74, 0x20, 0x74, 0x68, 0x65, 0x6e, 0x20,
+    0x6c, 0x6f, 0x61, 0x64, 0x65, 0x64, 0x2e, 0x73, 0x6f, 0x63, 0x6b, 0x65, 0x74, 0x20, 0x3d, 0x20,
+    0x6c, 0x6f, 0x61, 0x64, 0x65, 0x64, 0x5b, 0x22, 0x73, 0x6f, 0x63, 0x6b, 0x65, 0x74, 0x2e, 0x63,
+    0x6f, 0x72, 0x65, 0x22, 0x5d, 0x20, 0x65, 0x6e, 0x64, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x69, 0x66,
+    0x20, 0x6e, 0x6f, 0x74, 0x20, 0x6c, 0x6f, 0x61, 0x64, 0x65, 0x64, 0x2e, 0x6d, 0x69, 0x6d, 0x65,
+    0x20, 0x20, 0x20, 0x74, 0x68, 0x65, 0x6e, 0x20, 0x6c, 0x6f, 0x61, 0x64, 0x65, 0x64, 0x2e, 0x6d,
+    0x69, 0x6d, 0x65, 0x20, 0x20, 0x20, 0x3d, 0x20, 0x6c, 0x6f, 0x61, 0x64, 0x65, 0x64, 0x5b, 0x22,
+    0x6d, 0x69, 0x6d, 0x65, 0x2e, 0x63, 0x6f, 0x72, 0x65, 0x22, 0x5d, 0x20, 0x20, 0x20, 0x65, 0x6e,
+    0x64, 0x0a, 0x0a, 0x65, 0x6e, 0x64, 0x0a, 0x0a, 0x64, 0x6f, 0x0a, 0x0a, 0x20, 0x20, 0x20, 0x20,
+    0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x20, 0x6c, 0x66, 0x73, 0x61, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75,
+    0x74, 0x65, 0x73, 0x20, 0x20, 0x20, 0x20, 0x20, 0x3d, 0x20, 0x6c, 0x66, 0x73, 0x2e, 0x61, 0x74,
+    0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x6c, 0x6f, 0x63,
+    0x61, 0x6c, 0x20, 0x73, 0x79, 0x6d, 0x6c, 0x69, 0x6e, 0x6b, 0x61, 0x74, 0x74, 0x72, 0x69, 0x62,
+    0x75, 0x74, 0x65, 0x73, 0x20, 0x3d, 0x20, 0x6c, 0x66, 0x73, 0x2e, 0x73, 0x79, 0x6d, 0x6c, 0x69,
+    0x6e, 0x6b, 0x61, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x0a, 0x0a, 0x20, 0x20,
+    0x20, 0x20, 0x2d, 0x2d, 0x20, 0x74, 0x68, 0x65, 0x73, 0x65, 0x20, 0x63, 0x61, 0x6e, 0x20, 0x6e,
+    0x6f, 0x77, 0x20, 0x62, 0x65, 0x20, 0x64, 0x6f, 0x6e, 0x65, 0x20, 0x75, 0x73, 0x69, 0x6e, 0x67,
+    0x20, 0x6c, 0x66, 0x73, 0x20, 0x28, 0x77, 0x61, 0x73, 0x20, 0x64, 0x65, 0x61, 0x64, 0x20, 0x73,
+    0x6c, 0x6f, 0x77, 0x20, 0x62, 0x65, 0x66, 0x6f, 0x72, 0x65, 0x29, 0x0a, 0x0a, 0x20, 0x20, 0x20,
+    0x20, 0x69, 0x66, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x6c, 0x66, 0x73, 0x2e, 0x69, 0x73, 0x66, 0x69,
+    0x6c, 0x65, 0x20, 0x74, 0x68, 0x65, 0x6e, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+    0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6c, 0x66, 0x73, 0x2e, 0x69, 0x73, 0x66,
+    0x69, 0x6c, 0x65, 0x28, 0x6e, 0x61, 0x6d, 0x65, 0x29, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x20, 0x6d, 0x20, 0x3d, 0x20,
+    0x6c, 0x66, 0x73, 0x61, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x28, 0x6e, 0x61,
+    0x6d, 0x65, 0x2c, 0x22, 0x6d, 0x6f, 0x64, 0x65, 0x22, 0x29, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20,
+    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x6d, 0x20,
+    0x3d, 0x3d, 0x20, 0x22, 0x66, 0x69, 0x6c, 0x65, 0x22, 0x20, 0x6f, 0x72, 0x20, 0x6d, 0x20, 0x3d,
+    0x3d, 0x20, 0x22, 0x6c, 0x69, 0x6e, 0x6b, 0x22, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+    0x20, 0x65, 0x6e, 0x64, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x65, 0x6e, 0x64, 0x0a, 0x0a, 0x20, 0x20,
+    0x20, 0x20, 0x69, 0x66, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x6c, 0x66, 0x73, 0x2e, 0x69, 0x73, 0x64,
+    0x69, 0x72, 0x20, 0x74, 0x68, 0x65, 0x6e, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+    0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6c, 0x66, 0x73, 0x2e, 0x69, 0x73, 0x64,
+    0x69, 0x72, 0x28, 0x6e, 0x61, 0x6d, 0x65, 0x29, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+    0x20, 0x20, 0x20, 0x20, 0x20, 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x20, 0x6d, 0x20, 0x3d, 0x20, 0x6c,
+    0x66, 0x73, 0x61, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x28, 0x6e, 0x61, 0x6d,
+    0x65, 0x2c, 0x22, 0x6d, 0x6f, 0x64, 0x65, 0x22, 0x29, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x6d, 0x20, 0x3d,
+    0x3d, 0x20, 0x22, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x79, 0x22, 0x0a, 0x20, 0x20,
+    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x65, 0x6e, 0x64, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x65, 0x6e,
+    0x64, 0x0a, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x2d, 0x2d, 0x20, 0x73, 0x68, 0x6f, 0x72, 0x74, 0x6e,
+    0x61, 0x6d, 0x65, 0x73, 0x20, 0x68, 0x61, 0x76, 0x65, 0x20, 0x61, 0x6c, 0x73, 0x6f, 0x20, 0x62,
+    0x65, 0x20, 0x73, 0x6f, 0x72, 0x74, 0x20, 0x6f, 0x66, 0x20, 0x64, 0x72, 0x6f, 0x70, 0x70, 0x65,
+    0x64, 0x20, 0x66, 0x72, 0x6f, 0x6d, 0x20, 0x6b, 0x70, 0x73, 0x65, 0x0a, 0x0a, 0x20, 0x20, 0x20,
+    0x20, 0x69, 0x66, 0x20, 0x6e, 0x6f, 0x74, 0x20, 0x6c, 0x66, 0x73, 0x2e, 0x73, 0x68, 0x6f, 0x72,
+    0x74, 0x6e, 0x61, 0x6d, 0x65, 0x20, 0x74, 0x68, 0x65, 0x6e, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20,
+    0x20, 0x20, 0x20, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6c, 0x66, 0x73, 0x2e,
+    0x73, 0x68, 0x6f, 0x72, 0x74, 0x6e, 0x61, 0x6d, 0x65, 0x28, 0x6e, 0x61, 0x6d, 0x65, 0x29, 0x0a,
+    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75,
+    0x72, 0x6e, 0x20, 0x6e, 0x61, 0x6d, 0x65, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+    0x65, 0x6e, 0x64, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x65, 0x6e, 0x64, 0x0a, 0x0a, 0x20, 0x20, 0x20,
+    0x20, 0x2d, 0x2d, 0x20, 0x6e, 0x6f, 0x77, 0x20, 0x74, 0x68, 0x65, 0x72, 0x65, 0x20, 0x69, 0x73,
+    0x20, 0x61, 0x20, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x20, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x2c,
+    0x20, 0x73, 0x6f, 0x20, 0x2e, 0x2e, 0x2e, 0x0a, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x69, 0x66, 0x20,
+    0x6e, 0x6f, 0x74, 0x20, 0x6c, 0x66, 0x73, 0x2e, 0x72, 0x65, 0x61, 0x64, 0x6c, 0x69, 0x6e, 0x6b,
+    0x20, 0x74, 0x68, 0x65, 0x6e, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x66, 0x75,
+    0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x6c, 0x66, 0x73, 0x2e, 0x72, 0x65, 0x61, 0x64, 0x6c,
+    0x69, 0x6e, 0x6b, 0x28, 0x6e, 0x61, 0x6d, 0x65, 0x29, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+    0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e, 0x20, 0x73, 0x79, 0x6d,
+    0x6c, 0x69, 0x6e, 0x6b, 0x61, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x28, 0x6e,
+    0x61, 0x6d, 0x65, 0x2c, 0x22, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x22, 0x29, 0x20, 0x6f, 0x72,
+    0x20, 0x6e, 0x69, 0x6c, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x65, 0x6e, 0x64,
+    0x0a, 0x20, 0x20, 0x20, 0x20, 0x65, 0x6e, 0x64, 0x0a, 0x0a, 0x65, 0x6e, 0x64, 0x0a, 0x0a, 0x2d,
+    0x2d, 0x20, 0x73, 0x6f, 0x20, 0x66, 0x61, 0x72, 0x0a, 0x0a, 0x00
   };
   return luaL_dostring(L, (const char*) luatex_core_lua);
 }
\ No newline at end of file
diff --git a/texk/web2c/luatexdir/lua/luatex-core.lua b/texk/web2c/luatexdir/lua/luatex-core.lua
index 35005d1c8..f2d55fd99 100644
--- a/texk/web2c/luatexdir/lua/luatex-core.lua
+++ b/texk/web2c/luatexdir/lua/luatex-core.lua
@@ -1,419 +1,465 @@
--- luatex-core security and io overloads ...........
-
--- if not modules then modules = { } end modules ['luatex-core'] = {
---     version   = 1.005,
---     comment   = 'companion to luatex',
---     author    = 'Hans Hagen & Luigi Scarso',
---     copyright = 'LuaTeX Development Team',
--- }
-
-LUATEXCOREVERSION = 1.005
-
--- This file overloads some Lua functions. The readline variants provide the same
--- functionality as LuaTeX <= 1.04 and doing it this way permits us to keep the
--- original io libraries clean. Performance is probably even a bit better now.
-
-local type, next, getmetatable, require = type, next, getmetatable, require
-local find, gsub, format = string.find, string.gsub, string.format
-
-local io_open             = io.open
-local io_popen            = io.popen
-local io_lines            = io.lines
-
-local fio_readline        = fio.readline
-local fio_checkpermission = fio.checkpermission
-local fio_recordfilename  = fio.recordfilename
-
-local mt                  = getmetatable(io.stderr)
-local mt_lines            = mt.lines
-local saferoption         = status.safer_option
-local shellescape         = status.shell_escape -- 0 (disabled) 1 (anything) 2 (restricted)
-local kpseused            = status.kpse_used    -- 0 1
-
-local write_nl            = texio.write_nl
-
-io.saved_lines            = io_lines -- always readonly
-mt.saved_lines            = mt_lines -- always readonly
-
-local function luatex_io_open(name,how)
-    if not how then
-        how = 'r'
-    end
-    local f = io_open(name,how)
-    if f then
-        if type(how) == 'string' and find(how,'w') then
-            fio_recordfilename(name,'w')
-        else
-            fio_recordfilename(name,'r')
-        end
-    end
-    return f
-end
-
-local function luatex_io_open_readonly(name,how)
-    if how then
-        how = 'r'
-    else
-        how = gsub(how,'[^rb]','')
-        if how == '' then
-            how = 'r'
-        end
-    end
-    local f = io_open(name,how)
-    if f then
-        fio_recordfilename(name,'r')
-    end
-    return f
-end
-
-local function luatex_io_popen(name,...)
-    local okay, found = fio_checkpermission(name)
-    if okay and found then
-        return io_popen(found,...)
-    end
-end
-
--- local function luatex_io_lines(name,how)
---     if name then
---         local f = io_open(name,how or 'r')
---         if f then
---             return function()
---                 return fio_readline(f)
---             end
---         end
---     else
---         return io_lines()
---     end
--- end
-
--- For some reason the gc doesn't kick in so we need to close explitly
--- so that the handle is flushed.
-
-local error, type = error, type
-
-local function luatex_io_lines(name,how)
-    if type(name) == "string" then
-        local f = io_open(name,how or 'r')
-        if f then
-            return function()
-                local l = fio_readline(f)
-                if not l then
-                    f:close()
-                end
-                return l
-            end
-        else
-            -- for those who like it this way:
-            error("patched 'io.lines' can't open '" .. name .. "'")
-        end
-    else
-        return io_lines()
-    end
-end
-
-local function luatex_io_readline(f)
-    return function()
-        return fio_readline(f)
-    end
-end
-
-io.lines = luatex_io_lines
-mt.lines = luatex_io_readline
-
--- We assume management to be provided by the replacement of kpse. This is the
--- case in ConTeXt.
-
-if kpseused == 1 then
-
-    io.open  = luatex_io_open
-    io.popen = luatex_io_popen
-
-end
-
-if saferoption == 1 then
-
-    local function installdummy(str,f)
-        local reported = false
-        return function(...)
-            if not reported then
-                write_nl(format("safer option set, function %q is %s",
-                    str,f and "limited" or "disabled"))
-                reported = true
-            end
-            if f then
-                return f(...)
-            end
-        end
-    end
-
-    local function installlimit(str,f)
-        local reported = false
-    end
-
-    os.execute = installdummy("os.execute")
-    os.spawn   = installdummy("os.spawn")
-    os.exec    = installdummy("os.exec")
-    os.setenv  = installdummy("os.setenv")
-    os.tempdir = installdummy("os.tempdir")
-
-    io.popen   = installdummy("io.popen")
-    io.open    = installdummy("io.open",luatex_io_open_readonly)
-
-    os.rename  = installdummy("os.rename")
-    os.remove  = installdummy("os.remove")
-
-    io.tmpfile = installdummy("io.tmpfile")
-    io.output  = installdummy("io.output")
-
-    lfs.chdir  = installdummy("lfs.chdir")
-    lfs.lock   = installdummy("lfs.lock")
-    lfs.touch  = installdummy("lfs.touch")
-    lfs.rmdir  = installdummy("lfs.rmdir")
-    lfs.mkdir  = installdummy("lfs.mkdir")
-
-end
-
-if saferoption == 1 or shellescape ~= 1 then
-
-    ffi = require('ffi')
-    for k, v in next, ffi do
-        if k ~= 'gc' then
-            ffi[k] = nil
-        end
-    end
-    ffi = nil
-
-end
-
--- os.[execute|os.spawn|os.exec] already are shellescape aware)
-
-
-if md5 then
-
-    local sum    = md5.sum
-    local gsub   = string.gsub
-    local format = string.format
-    local byte   = string.byte
-
-    function md5.sumhexa(k)
-        return (gsub(sum(k), ".", function(c)
-            return format("%02x",byte(c))
-        end))
-    end
-
-    function md5.sumHEXA(k)
-        return (gsub(sum(k), ".", function(c)
-            return format("%02X",byte(c))
-        end))
-    end
-
-end
-
--- compatibility: this might go away
-
-if not unpack then
-    unpack = table.unpack
-end
-
-if not package.loaders then
-    package.loaders = package.searchers
-end
-
-if not loadstring then
-    loadstring = load
-end
-
--- compatibility: this might stay
-
-if bit32 then
-
-    -- lua 5.2: we're okay
-
-elseif utf8 then
-
-    -- lua 5.3:  bitwise.lua, v 1.24 2014/12/26 17:20:53 roberto
-
-    bit32 = load ( [[
-local select = select -- instead of: arg = { ... }
-
-bit32 = {
-  bnot = function (a)
-    return ~a & 0xFFFFFFFF
-  end,
-  band = function (x, y, z, ...)
-    if not z then
-      return ((x or -1) & (y or -1)) & 0xFFFFFFFF
-    else
-      local res = x & y & z
-      for i=1,select("#",...) do
-        res = res & select(i,...)
-      end
-      return res & 0xFFFFFFFF
-    end
-  end,
-  bor = function (x, y, z, ...)
-    if not z then
-      return ((x or 0) | (y or 0)) & 0xFFFFFFFF
-    else
-      local res = x | y | z
-      for i=1,select("#",...) do
-        res = res | select(i,...)
-      end
-      return res & 0xFFFFFFFF
-    end
-  end,
-  bxor = function (x, y, z, ...)
-    if not z then
-      return ((x or 0) ~ (y or 0)) & 0xFFFFFFFF
-    else
-      local res = x ~ y ~ z
-      for i=1,select("#",...) do
-        res = res ~ select(i,...)
-      end
-      return res & 0xFFFFFFFF
-    end
-  end,
-  btest = function (x, y, z, ...)
-    if not z then
-      return (((x or -1) & (y or -1)) & 0xFFFFFFFF) ~= 0
-    else
-      local res = x & y & z
-      for i=1,select("#",...) do
-          res = res & select(i,...)
-      end
-      return (res & 0xFFFFFFFF) ~= 0
-    end
-  end,
-  lshift = function (a, b)
-    return ((a & 0xFFFFFFFF) << b) & 0xFFFFFFFF
-  end,
-  rshift = function (a, b)
-    return ((a & 0xFFFFFFFF) >> b) & 0xFFFFFFFF
-  end,
-  arshift = function (a, b)
-    a = a & 0xFFFFFFFF
-    if b <= 0 or (a & 0x80000000) == 0 then
-      return (a >> b) & 0xFFFFFFFF
-    else
-      return ((a >> b) | ~(0xFFFFFFFF >> b)) & 0xFFFFFFFF
-    end
-  end,
-  lrotate = function (a ,b)
-    b = b & 31
-    a = a & 0xFFFFFFFF
-    a = (a << b) | (a >> (32 - b))
-    return a & 0xFFFFFFFF
-  end,
-  rrotate = function (a, b)
-    b = -b & 31
-    a = a & 0xFFFFFFFF
-    a = (a << b) | (a >> (32 - b))
-    return a & 0xFFFFFFFF
-  end,
-  extract = function (a, f, w)
-    return (a >> f) & ~(-1 << (w or 1))
-  end,
-  replace = function (a, v, f, w)
-    local mask = ~(-1 << (w or 1))
-    return ((a & ~(mask << f)) | ((v & mask) << f)) & 0xFFFFFFFF
-  end,
-}
-        ]] )
-
-elseif bit then
-
-    -- luajit (for now)
-
-    bit32 = load ( [[
-local band, bnot, rshift, lshift = bit.band, bit.bnot, bit.rshift, bit.lshift
-
-bit32 = {
-  arshift = bit.arshift,
-  band    = band,
-  bnot    = bnot,
-  bor     = bit.bor,
-  bxor    = bit.bxor,
-  btest   = function(...)
-    return band(...) ~= 0
-  end,
-  extract = function(a,f,w)
-    return band(rshift(a,f),2^(w or 1)-1)
-  end,
-  lrotate = bit.rol,
-  lshift  = lshift,
-  replace = function(a,v,f,w)
-    local mask = 2^(w or 1)-1
-    return band(a,bnot(lshift(mask,f)))+lshift(band(v,mask),f)
-  end,
-  rrotate = bit.ror,
-  rshift  = rshift,
-}
-        ]] )
-
-else
-
-    -- hope for the best or fail
-
-    bit32 = require("bit32")
-
-end
-
--- this is needed for getting require("socket") right
-
-do
-
-    local loaded = package.loaded
-
-    if not loaded.socket then loaded.socket = loaded["socket.core"] end
-    if not loaded.mime   then loaded.mime   = loaded["mime.core"]   end
-
-end
-
--- so far
-
-if utilities and utilities.merger and utilities.merger.compact then
-
-    local byte, format, gmatch = string.byte, string.format, string.gmatch
-    local concat = table.concat
-
-    local data = gsub(io.loaddata('luatex-core.lua'),'if%s+utilities.*','')
-
-    local t = { }
-    local r = { }
-    local n = 0
-    local d = gsub(data,'\r\n','\n')      -- be nice for unix
-    local s = utilities.merger.compact(d) -- no comments and less spaces
-
-    t[#t+1] = '/* generated from and by luatex-core.lua */'
-    t[#t+1] = ''
- -- t[#t+1] = format('/*\n\n%s\n\n*/',d)
- -- t[#t+1] = ''
-    t[#t+1] = '#include "lua.h"'
-    t[#t+1] = '#include "lauxlib.h"'
-    t[#t+1] = ''
-    t[#t+1] = 'int load_luatex_core_lua (lua_State * L);'
-    t[#t+1] = ''
-    t[#t+1] = 'int load_luatex_core_lua (lua_State * L)'
-    t[#t+1] = '{'
-    t[#t+1] = '  static unsigned char luatex_core_lua[] = {'
-    for c in gmatch(d,'.') do
-        if n == 16 then
-            n = 1
-            t[#t+1] = '    ' .. concat(r,', ') .. ','
-        else
-            n = n + 1
-        end
-        r[n] = format('0x%02x',byte(c))
-    end
-    n = n + 1
-    r[n] = '0x00'
-    t[#t+1] = '    ' .. concat(r,', ',1,n)
-    t[#t+1] = '  };'
- -- t[#t+1] = format('unsigned int luatex_core_lua_len = 0x%x;',#d+1)
-    t[#t+1] = '  return luaL_dostring(L, (const char*) luatex_core_lua);'
-    t[#t+1] = '}'
-
-    io.savedata('luatex-core.c',concat(t,'\n'))
-    io.savedata('luatex-core-stripped.lua',s)
-
-end
+-- luatex-core security and io overloads ...........
+
+-- if not modules then modules = { } end modules ['luatex-core'] = {
+--     version   = 1.080,
+--     comment   = 'companion to luatex',
+--     author    = 'Hans Hagen & Luigi Scarso',
+--     copyright = 'LuaTeX Development Team',
+-- }
+
+LUATEXCOREVERSION = 1.080 -- we reflect the luatex version where changes happened
+
+-- This file overloads some Lua functions. The readline variants provide the same
+-- functionality as LuaTeX <= 1.04 and doing it this way permits us to keep the
+-- original io libraries clean. Performance is probably even a bit better now.
+
+-- We test for functions already being defined so that we don't overload ones that
+-- are provided in the startup script.
+
+local type, next, getmetatable, require = type, next, getmetatable, require
+local find, gsub, format = string.find, string.gsub, string.format
+
+local io_open             = io.open
+local io_popen            = io.popen
+local io_lines            = io.lines
+
+local fio_readline        = fio.readline
+local fio_checkpermission = fio.checkpermission
+local fio_recordfilename  = fio.recordfilename
+
+local mt                  = getmetatable(io.stderr)
+local mt_lines            = mt.lines
+local saferoption         = status.safer_option
+local shellescape         = status.shell_escape -- 0 (disabled) 1 (anything) 2 (restricted)
+local kpseused            = status.kpse_used    -- 0 1
+
+local write_nl            = texio.write_nl
+
+io.saved_lines            = io_lines -- always readonly
+mt.saved_lines            = mt_lines -- always readonly
+
+local function luatex_io_open(name,how)
+    if not how then
+        how = 'r'
+    end
+    local f = io_open(name,how)
+    if f then
+        if type(how) == 'string' and find(how,'w') then
+            fio_recordfilename(name,'w')
+        else
+            fio_recordfilename(name,'r')
+        end
+    end
+    return f
+end
+
+local function luatex_io_open_readonly(name,how)
+    if how then
+        how = 'r'
+    else
+        how = gsub(how,'[^rb]','')
+        if how == '' then
+            how = 'r'
+        end
+    end
+    local f = io_open(name,how)
+    if f then
+        fio_recordfilename(name,'r')
+    end
+    return f
+end
+
+local function luatex_io_popen(name,...)
+    local okay, found = fio_checkpermission(name)
+    if okay and found then
+        return io_popen(found,...)
+    end
+end
+
+-- local function luatex_io_lines(name,how)
+--     if name then
+--         local f = io_open(name,how or 'r')
+--         if f then
+--             return function()
+--                 return fio_readline(f)
+--             end
+--         end
+--     else
+--         return io_lines()
+--     end
+-- end
+
+-- For some reason the gc doesn't kick in so we need to close explitly
+-- so that the handle is flushed.
+
+local error, type = error, type
+
+local function luatex_io_lines(name,how)
+    if type(name) == "string" then
+        local f = io_open(name,how or 'r')
+        if f then
+            return function()
+                local l = fio_readline(f)
+                if not l then
+                    f:close()
+                end
+                return l
+            end
+        else
+            -- for those who like it this way:
+            error("patched 'io.lines' can't open '" .. name .. "'")
+        end
+    else
+        return io_lines()
+    end
+end
+
+local function luatex_io_readline(f)
+    return function()
+        return fio_readline(f)
+    end
+end
+
+io.lines = luatex_io_lines
+mt.lines = luatex_io_readline
+
+-- We assume management to be provided by the replacement of kpse. This is the
+-- case in ConTeXt.
+
+if kpseused == 1 then
+
+    io.open  = luatex_io_open
+    io.popen = luatex_io_popen
+
+end
+
+if saferoption == 1 then
+
+    local function installdummy(str,f)
+        local reported = false
+        return function(...)
+            if not reported then
+                write_nl(format("safer option set, function %q is %s",
+                    str,f and "limited" or "disabled"))
+                reported = true
+            end
+            if f then
+                return f(...)
+            end
+        end
+    end
+
+    local function installlimit(str,f)
+        local reported = false
+    end
+
+    os.execute = installdummy("os.execute")
+    os.spawn   = installdummy("os.spawn")
+    os.exec    = installdummy("os.exec")
+    os.setenv  = installdummy("os.setenv")
+    os.tempdir = installdummy("os.tempdir")
+
+    io.popen   = installdummy("io.popen")
+    io.open    = installdummy("io.open",luatex_io_open_readonly)
+
+    os.rename  = installdummy("os.rename")
+    os.remove  = installdummy("os.remove")
+
+    io.tmpfile = installdummy("io.tmpfile")
+    io.output  = installdummy("io.output")
+
+    lfs.chdir  = installdummy("lfs.chdir")
+    lfs.lock   = installdummy("lfs.lock")
+    lfs.touch  = installdummy("lfs.touch")
+    lfs.rmdir  = installdummy("lfs.rmdir")
+    lfs.mkdir  = installdummy("lfs.mkdir")
+
+end
+
+if saferoption == 1 or shellescape ~= 1 then
+
+    ffi = require('ffi')
+    for k, v in next, ffi do
+        if k ~= 'gc' then
+            ffi[k] = nil
+        end
+    end
+    ffi = nil
+
+end
+
+-- os.[execute|os.spawn|os.exec] already are shellescape aware)
+
+
+if md5 then
+
+    local sum    = md5.sum
+    local gsub   = string.gsub
+    local format = string.format
+    local byte   = string.byte
+
+    if not md5.sumhexa then
+        function md5.sumhexa(k)
+            return (gsub(sum(k), ".", function(c)
+                return format("%02x",byte(c))
+            end))
+        end
+    end
+
+    if not md5.sumHEXA then
+        function md5.sumHEXA(k)
+            return (gsub(sum(k), ".", function(c)
+                return format("%02X",byte(c))
+            end))
+        end
+    end
+
+end
+
+-- compatibility: this might go away
+
+if not unpack then
+    unpack = table.unpack
+end
+
+if not package.loaders then
+    package.loaders = package.searchers
+end
+
+if not loadstring then
+    loadstring = load
+end
+
+-- compatibility: this might stay
+
+if bit32 then
+
+    -- lua 5.2: we're okay
+
+elseif utf8 then
+
+    -- lua 5.3:  bitwise.lua, v 1.24 2014/12/26 17:20:53 roberto
+
+    bit32 = load ( [[
+local select = select -- instead of: arg = { ... }
+
+bit32 = {
+  bnot = function (a)
+    return ~a & 0xFFFFFFFF
+  end,
+  band = function (x, y, z, ...)
+    if not z then
+      return ((x or -1) & (y or -1)) & 0xFFFFFFFF
+    else
+      local res = x & y & z
+      for i=1,select("#",...) do
+        res = res & select(i,...)
+      end
+      return res & 0xFFFFFFFF
+    end
+  end,
+  bor = function (x, y, z, ...)
+    if not z then
+      return ((x or 0) | (y or 0)) & 0xFFFFFFFF
+    else
+      local res = x | y | z
+      for i=1,select("#",...) do
+        res = res | select(i,...)
+      end
+      return res & 0xFFFFFFFF
+    end
+  end,
+  bxor = function (x, y, z, ...)
+    if not z then
+      return ((x or 0) ~ (y or 0)) & 0xFFFFFFFF
+    else
+      local res = x ~ y ~ z
+      for i=1,select("#",...) do
+        res = res ~ select(i,...)
+      end
+      return res & 0xFFFFFFFF
+    end
+  end,
+  btest = function (x, y, z, ...)
+    if not z then
+      return (((x or -1) & (y or -1)) & 0xFFFFFFFF) ~= 0
+    else
+      local res = x & y & z
+      for i=1,select("#",...) do
+          res = res & select(i,...)
+      end
+      return (res & 0xFFFFFFFF) ~= 0
+    end
+  end,
+  lshift = function (a, b)
+    return ((a & 0xFFFFFFFF) << b) & 0xFFFFFFFF
+  end,
+  rshift = function (a, b)
+    return ((a & 0xFFFFFFFF) >> b) & 0xFFFFFFFF
+  end,
+  arshift = function (a, b)
+    a = a & 0xFFFFFFFF
+    if b <= 0 or (a & 0x80000000) == 0 then
+      return (a >> b) & 0xFFFFFFFF
+    else
+      return ((a >> b) | ~(0xFFFFFFFF >> b)) & 0xFFFFFFFF
+    end
+  end,
+  lrotate = function (a ,b)
+    b = b & 31
+    a = a & 0xFFFFFFFF
+    a = (a << b) | (a >> (32 - b))
+    return a & 0xFFFFFFFF
+  end,
+  rrotate = function (a, b)
+    b = -b & 31
+    a = a & 0xFFFFFFFF
+    a = (a << b) | (a >> (32 - b))
+    return a & 0xFFFFFFFF
+  end,
+  extract = function (a, f, w)
+    return (a >> f) & ~(-1 << (w or 1))
+  end,
+  replace = function (a, v, f, w)
+    local mask = ~(-1 << (w or 1))
+    return ((a & ~(mask << f)) | ((v & mask) << f)) & 0xFFFFFFFF
+  end,
+}
+        ]] )
+
+elseif bit then
+
+    -- luajit (for now)
+
+    bit32 = load ( [[
+local band, bnot, rshift, lshift = bit.band, bit.bnot, bit.rshift, bit.lshift
+
+bit32 = {
+  arshift = bit.arshift,
+  band    = band,
+  bnot    = bnot,
+  bor     = bit.bor,
+  bxor    = bit.bxor,
+  btest   = function(...)
+    return band(...) ~= 0
+  end,
+  extract = function(a,f,w)
+    return band(rshift(a,f),2^(w or 1)-1)
+  end,
+  lrotate = bit.rol,
+  lshift  = lshift,
+  replace = function(a,v,f,w)
+    local mask = 2^(w or 1)-1
+    return band(a,bnot(lshift(mask,f)))+lshift(band(v,mask),f)
+  end,
+  rrotate = bit.ror,
+  rshift  = rshift,
+}
+        ]] )
+
+else
+
+    -- hope for the best or fail
+
+    bit32 = require("bit32")
+
+end
+
+-- this is needed for getting require("socket") right
+
+do
+
+    local loaded = package.loaded
+
+    if not loaded.socket then loaded.socket = loaded["socket.core"] end
+    if not loaded.mime   then loaded.mime   = loaded["mime.core"]   end
+
+end
+
+do
+
+    local lfsattributes     = lfs.attributes
+    local symlinkattributes = lfs.symlinkattributes
+
+    -- these can now be done using lfs (was dead slow before)
+
+    if not lfs.isfile then
+        function lfs.isfile(name)
+            local m = lfsattributes(name,"mode")
+            return m == "file" or m == "link"
+        end
+    end
+
+    if not lfs.isdir then
+        function lfs.isdir(name)
+            local m = lfsattributes(name,"mode")
+            return m == "directory"
+        end
+    end
+
+    -- shortnames have also be sort of dropped from kpse
+
+    if not lfs.shortname then
+        function lfs.shortname(name)
+            return name
+        end
+    end
+
+    -- now there is a target field, so ...
+
+    if not lfs.readlink then
+        function lfs.readlink(name)
+            return symlinkattributes(name,"target") or nil
+        end
+    end
+
+end
+
+-- so far
+
+if utilities and utilities.merger and utilities.merger.compact then
+
+    local byte, format, gmatch = string.byte, string.format, string.gmatch
+    local concat = table.concat
+
+    local data = gsub(io.loaddata('luatex-core.lua'),'if%s+utilities.*','')
+
+    local t = { }
+    local r = { }
+    local n = 0
+    local d = gsub(data,'\r\n','\n')      -- be nice for unix
+    local s = utilities.merger.compact(d) -- no comments and less spaces
+
+    t[#t+1] = '/* generated from and by luatex-core.lua */'
+    t[#t+1] = ''
+ -- t[#t+1] = format('/*\n\n%s\n\n*/',d)
+ -- t[#t+1] = ''
+    t[#t+1] = '#include "lua.h"'
+    t[#t+1] = '#include "lauxlib.h"'
+    t[#t+1] = ''
+    t[#t+1] = 'int load_luatex_core_lua (lua_State * L);'
+    t[#t+1] = ''
+    t[#t+1] = 'int load_luatex_core_lua (lua_State * L)'
+    t[#t+1] = '{'
+    t[#t+1] = '  static unsigned char luatex_core_lua[] = {'
+    for c in gmatch(d,'.') do
+        if n == 16 then
+            n = 1
+            t[#t+1] = '    ' .. concat(r,', ') .. ','
+        else
+            n = n + 1
+        end
+        r[n] = format('0x%02x',byte(c))
+    end
+    n = n + 1
+    r[n] = '0x00'
+    t[#t+1] = '    ' .. concat(r,', ',1,n)
+    t[#t+1] = '  };'
+ -- t[#t+1] = format('unsigned int luatex_core_lua_len = 0x%x;',#d+1)
+    t[#t+1] = '  return luaL_dostring(L, (const char*) luatex_core_lua);'
+    t[#t+1] = '}'
+
+    io.savedata('luatex-core.c',concat(t,'\n'))
+    io.savedata('luatex-core-stripped.lua',s)
+
+end
diff --git a/texk/web2c/luatexdir/luafontloader/fontforge/fontforge/parsepfa.c b/texk/web2c/luatexdir/luafontloader/fontforge/fontforge/parsepfa.c
index 1cff6a485..df369b45e 100644
--- a/texk/web2c/luatexdir/luafontloader/fontforge/fontforge/parsepfa.c
+++ b/texk/web2c/luatexdir/luafontloader/fontforge/fontforge/parsepfa.c
@@ -2667,9 +2667,9 @@ static void FontInfoFree(struct fontinfo *fi) {
 void PSFontFree(FontDict *fd) {
     int i;
 
-    if ( fd->encoding!=NULL )
-	for ( i=0; i<256; ++i )
-	    free( fd->encoding[i]);
+    /*if ( fd->encoding!=NULL ): useless: fd->encoding is *char[256] */
+    for ( i=0; i<256; ++i )
+       free( fd->encoding[i]);
     free(fd->fontname);
     free(fd->cidfontname);
     free(fd->registry);
diff --git a/texk/web2c/luatexdir/luafontloader/src/luafflib.c b/texk/web2c/luatexdir/luafontloader/src/luafflib.c
index 8717fe8e3..434413b00 100644
--- a/texk/web2c/luatexdir/luafontloader/src/luafflib.c
+++ b/texk/web2c/luatexdir/luafontloader/src/luafflib.c
@@ -358,7 +358,7 @@ static void dump_intfield(lua_State * L, const char *name, long int field)
 {
     lua_checkstack(L, 2);
     lua_pushstring(L, name);
-    lua_pushnumber(L, field);
+    lua_pushinteger(L, field);
     lua_rawset(L, -3);
 }
 
@@ -366,7 +366,7 @@ static void dump_uintfield(lua_State * L, const char *name, unsigned int field)
 {
     lua_checkstack(L, 2);
     lua_pushstring(L, name);
-    lua_pushnumber(L, field);
+    lua_pushinteger(L, field);
     lua_rawset(L, -3);
 }
 
@@ -465,7 +465,7 @@ static void dump_subtable_name(lua_State * L, const char *name, struct lookup_su
     next = b; \
     while (next != NULL) { \
         lua_checkstack(L,2); \
-        lua_pushnumber(L,k); k++; \
+        lua_pushinteger(L,k); k++; \
         lua_createtable(L,0,c); \
         a(L, next); \
         lua_rawset(L,-3); \
@@ -478,7 +478,7 @@ static void dump_subtable_name(lua_State * L, const char *name, struct lookup_su
     next = b; \
     while (next != NULL) { \
         lua_checkstack(L,2); \
-        lua_pushnumber(L,k); k++; \
+        lua_pushinteger(L,k); k++; \
         lua_createtable(L,0,d); \
         if (a(L, next, c)) \
             lua_rawset(L,-3); \
@@ -498,7 +498,7 @@ static void do_handle_scriptlanglist(lua_State * L, struct scriptlanglist *sl)
     lua_newtable(L);
     for (k = 0; k < MAX_LANG; k++) {
         if (sl->langs[k] != 0) {
-            lua_pushnumber(L, (k + 1));
+            lua_pushinteger(L, (k + 1));
             lua_pushstring(L, make_tag_string(sl->langs[k]));
             lua_rawset(L, -3);
         }
@@ -506,7 +506,7 @@ static void do_handle_scriptlanglist(lua_State * L, struct scriptlanglist *sl)
 
     if (sl->lang_cnt >= MAX_LANG) {
         for (k = MAX_LANG; k < sl->lang_cnt; k++) {
-            lua_pushnumber(L, (k + 1));
+            lua_pushinteger(L, (k + 1));
             lua_pushstring(L, make_tag_string(sl->morelangs[k - MAX_LANG]));
             lua_rawset(L, -3);
         }
@@ -672,7 +672,7 @@ static void handle_splinecharlist(lua_State * L, struct splinecharlist *scl)
     lua_checkstack(L, 10);
     while (next != NULL) {
         if (next->sc != NULL) {
-            lua_pushnumber(L, k);
+            lua_pushinteger(L, k);
             k++;
             lua_pushstring(L, next->sc->name);
             lua_rawset(L, -3);
@@ -772,8 +772,8 @@ static void do_handle_generic_pst(lua_State * L, struct generic_pst *pst)
         }
     } else if (pst->type == pst_lcaret) {
         for (k = 0; k < pst->u.lcaret.cnt; k++) {
-            lua_pushnumber(L, (k + 1));
-            lua_pushnumber(L, pst->u.lcaret.carets[k]);
+            lua_pushinteger(L, (k + 1));
+            lua_pushinteger(L, pst->u.lcaret.carets[k]);
             lua_rawset(L, -3);
         }
     }
@@ -800,7 +800,7 @@ static void handle_generic_pst(lua_State * L, struct generic_pst *pst)
                 lua_getfield(L, -1, next->subtable->subtable_name);
             }
             k = lua_rawlen(L, -1) + 1;
-            lua_pushnumber(L, k);
+            lua_pushinteger(L, k);
             lua_createtable(L, 0, 4);
             do_handle_generic_pst(L, next);
             lua_rawset(L, -3);
@@ -808,7 +808,7 @@ static void handle_generic_pst(lua_State * L, struct generic_pst *pst)
             lua_pop(L, 1);      /* pop the subtable */
         } else {
             /* Found a pst without subtable, or without subtable name */
-            lua_pushnumber(L, l);
+            lua_pushinteger(L, l);
             l++;
             lua_createtable(L, 0, 4);
             do_handle_generic_pst(L, next);
@@ -970,17 +970,17 @@ static void handle_splinechar(lua_State * L, struct splinechar *glyph, int hasvm
     dump_stringfield(L, "name", glyph->name);
     dump_intfield(L, "unicode", glyph->unicodeenc);
     lua_createtable(L, 4, 0);
-    lua_pushnumber(L, 1);
-    lua_pushnumber(L, glyph->xmin);
+    lua_pushinteger(L, 1);
+    lua_pushinteger(L, glyph->xmin);
     lua_rawset(L, -3);
-    lua_pushnumber(L, 2);
-    lua_pushnumber(L, glyph->ymin);
+    lua_pushinteger(L, 2);
+    lua_pushinteger(L, glyph->ymin);
     lua_rawset(L, -3);
-    lua_pushnumber(L, 3);
-    lua_pushnumber(L, glyph->xmax);
+    lua_pushinteger(L, 3);
+    lua_pushinteger(L, glyph->xmax);
     lua_rawset(L, -3);
-    lua_pushnumber(L, 4);
-    lua_pushnumber(L, glyph->ymax);
+    lua_pushinteger(L, 4);
+    lua_pushinteger(L, glyph->ymax);
     lua_rawset(L, -3);
     lua_setfield(L, -2, "boundingbox");
     if (hasvmetrics) {
@@ -1260,21 +1260,21 @@ static void handle_pfminfo(lua_State * L, struct pfminfo pfm)
     dump_intfield(L, "os2_breakchar", pfm.os2_breakchar);
     if (pfm.hascodepages) {
         lua_newtable(L);
-        lua_pushnumber(L, pfm.codepages[0]);
+        lua_pushinteger(L, pfm.codepages[0]);
         lua_rawseti(L, -2, 1);
-        lua_pushnumber(L, pfm.codepages[1]);
+        lua_pushinteger(L, pfm.codepages[1]);
         lua_rawseti(L, -2, 2);
         lua_setfield(L, -2, "codepages");
     }
     if (pfm.hasunicoderanges) {
         lua_newtable(L);
-        lua_pushnumber(L, pfm.unicoderanges[0]);
+        lua_pushinteger(L, pfm.unicoderanges[0]);
         lua_rawseti(L, -2, 1);
-        lua_pushnumber(L, pfm.unicoderanges[1]);
+        lua_pushinteger(L, pfm.unicoderanges[1]);
         lua_rawseti(L, -2, 2);
-        lua_pushnumber(L, pfm.unicoderanges[2]);
+        lua_pushinteger(L, pfm.unicoderanges[2]);
         lua_rawseti(L, -2, 3);
-        lua_pushnumber(L, pfm.unicoderanges[3]);
+        lua_pushinteger(L, pfm.unicoderanges[3]);
         lua_rawseti(L, -2, 4);
         lua_setfield(L, -2, "unicoderanges");
     }
@@ -1292,8 +1292,8 @@ static char *do_handle_enc(lua_State * L, struct enc *enc)
     if (enc->char_cnt && enc->unicode != NULL) {
         lua_createtable(L, enc->char_cnt, 1);
         for (i = 0; i < enc->char_cnt; i++) {
-            lua_pushnumber(L, i);
-            lua_pushnumber(L, enc->unicode[i]);
+            lua_pushinteger(L, i);
+            lua_pushinteger(L, enc->unicode[i]);
             lua_rawset(L, -3);
         }
         lua_setfield(L, -2, "unicode");
@@ -1302,7 +1302,7 @@ static char *do_handle_enc(lua_State * L, struct enc *enc)
     if (enc->char_cnt && enc->psnames != NULL) {
         lua_createtable(L, enc->char_cnt, 1);
         for (i = 0; i < enc->char_cnt; i++) {
-            lua_pushnumber(L, i);
+            lua_pushinteger(L, i);
             lua_pushstring(L, enc->psnames[i]);
             lua_rawset(L, -3);
         }
@@ -1363,13 +1363,13 @@ static void handle_encmap(lua_State * L, struct encmap *map, int notdef_loc)
         for (i = 0; i < map->encmax; i++) {
             if (map->map[i] != -1) {
                 int l = map->map[i];
-                lua_pushnumber(L, i);
+                lua_pushinteger(L, i);
                 /*
                 if (l < notdef_loc)
-                    lua_pushnumber(L, (l + 1));
+                    lua_pushinteger(L, (l + 1));
                 else
                 */
-                    lua_pushnumber(L, l);
+                    lua_pushinteger(L, l);
                 lua_rawset(L, -3);
             }
         }
@@ -1382,11 +1382,11 @@ static void handle_encmap(lua_State * L, struct encmap *map, int notdef_loc)
             if (map->backmap[i] != -1) {
                 /*
                 if (i < notdef_loc)
-                    lua_pushnumber(L, (i + 1));
+                    lua_pushinteger(L, (i + 1));
                 else
                 */
-                    lua_pushnumber(L, i);
-                lua_pushnumber(L, map->backmap[i]);
+                    lua_pushinteger(L, i);
+                lua_pushinteger(L, map->backmap[i]);
                 lua_rawset(L, -3);
             }
         }
@@ -1488,7 +1488,7 @@ static int do_handle_kernclass(lua_State * L, struct kernclass *kerns, const cha
     lua_checkstack(L, 4);
     lua_createtable(L, kerns->first_cnt, 1);
     for (k = 0; k < kerns->first_cnt; k++) {
-        lua_pushnumber(L, (k + 1));
+        lua_pushinteger(L, (k + 1));
         lua_pushstring(L, kerns->firsts[k]);
         lua_rawset(L, -3);
     }
@@ -1496,7 +1496,7 @@ static int do_handle_kernclass(lua_State * L, struct kernclass *kerns, const cha
 
     lua_createtable(L, kerns->second_cnt, 1);
     for (k = 0; k < kerns->second_cnt; k++) {
-        lua_pushnumber(L, (k + 1));
+        lua_pushinteger(L, (k + 1));
         lua_pushstring(L, kerns->seconds[k]);
         lua_rawset(L, -3);
     }
@@ -1508,8 +1508,8 @@ static int do_handle_kernclass(lua_State * L, struct kernclass *kerns, const cha
     lua_createtable(L, kerns->second_cnt * kerns->first_cnt, 1);
     for (k = 0; k < (kerns->second_cnt * kerns->first_cnt); k++) {
         if (kerns->offsets[k] != 0) {
-            lua_pushnumber(L, (k + 1));
-            lua_pushnumber(L, kerns->offsets[k]);
+            lua_pushinteger(L, (k + 1));
+            lua_pushinteger(L, kerns->offsets[k]);
             lua_rawset(L, -3);
         }
     }
@@ -1529,8 +1529,8 @@ static void handle_kernclass(lua_State * L, struct kernclass *kerns, const char
       int kk;							\
       lua_newtable(L);					\
       for (kk=0;kk<cnt;kk++) {			\
-		lua_pushnumber(L,(kk+1));		\
-		lua_pushnumber(L,item[kk]);		\
+		lua_pushinteger(L,(kk+1));		\
+		lua_pushinteger(L,item[kk]);		\
 		lua_rawset(L,-3); }				\
       lua_setfield(L,-2,s); } }
 
@@ -1540,7 +1540,7 @@ static void handle_kernclass(lua_State * L, struct kernclass *kerns, const char
       int kk;							\
       lua_newtable(L);					\
       for (kk=0;kk<cnt;kk++) {			\
-		lua_pushnumber(L,(kk+1));		\
+		lua_pushinteger(L,(kk+1));		\
 		lua_pushstring(L,item[kk]);		\
 		lua_rawset(L,-3); }				\
       lua_setfield(L,-2,s); } }
@@ -1550,7 +1550,7 @@ static void handle_kernclass(lua_State * L, struct kernclass *kerns, const char
       int kk;								  \
       lua_newtable(L);						  \
       for (kk=0;kk<cnt;kk++) {				  \
-		lua_pushnumber(L,(kk));				  \
+		lua_pushinteger(L,(kk));				  \
 		lua_pushstring(L,item[kk]);			  \
 		lua_rawset(L,-3); }					  \
       lua_setfield(L,-2,s); } }
@@ -1609,7 +1609,7 @@ static void handle_fpst_rule(lua_State * L, struct fpst_rule *rule, int format)
     if (rule->lookup_cnt > 0) {
         lua_newtable(L);
         for (k = 0; k < rule->lookup_cnt; k++) {
-            lua_pushnumber(L, (rule->lookups[k].seq + 1));
+            lua_pushinteger(L, (rule->lookups[k].seq + 1));
             if (rule->lookups[k].lookup != NULL) {
                 lua_pushstring(L, rule->lookups[k].lookup->lookup_name);
             } else {
@@ -1650,7 +1650,7 @@ static void do_handle_generic_fpst(lua_State * L, struct generic_fpst *fpst)
     if (fpst->rule_cnt > 0) {
         lua_createtable(L, fpst->rule_cnt, 1);
         for (k = 0; k < fpst->rule_cnt; k++) {
-            lua_pushnumber(L, (k + 1));
+            lua_pushinteger(L, (k + 1));
             lua_newtable(L);
             handle_fpst_rule(L, &(fpst->rules[k]), fpst->format);
             lua_rawset(L, -3);
@@ -1668,7 +1668,7 @@ static void handle_generic_fpst(lua_State * L, struct generic_fpst *fpst)
     if (fpst->subtable != NULL && fpst->subtable->subtable_name != NULL) {
         lua_pushstring(L, fpst->subtable->subtable_name);
     } else {
-        lua_pushnumber(L, k);
+        lua_pushinteger(L, k);
         k++;
     }
     lua_createtable(L, 0, 10);
@@ -1680,7 +1680,7 @@ static void handle_generic_fpst(lua_State * L, struct generic_fpst *fpst)
         if (next->subtable != NULL && next->subtable->subtable_name != NULL) {
             lua_pushstring(L, next->subtable->subtable_name);
         } else {
-            lua_pushnumber(L, k);
+            lua_pushinteger(L, k);
             k++;
         }
         lua_createtable(L, 0, 10);
@@ -1801,9 +1801,9 @@ static void handle_base(lua_State * L, struct Base *Base)
             lua_newtable(L);
             for (i = 0; i < Base->baseline_cnt; i++) {
                 if (next->baseline_pos != NULL) /* default omitted */
-                    lua_pushnumber(L, next->baseline_pos[i]);
+                    lua_pushinteger(L, next->baseline_pos[i]);
                 else
-                    lua_pushnumber(L, 0);
+                    lua_pushinteger(L, 0);
                 lua_rawseti(L, -2, (i + 1));
             }
             lua_setfield(L, -2, "baseline");
@@ -1823,13 +1823,13 @@ static void handle_axismap(lua_State * L, struct axismap *am)
     lua_checkstack(L, 3);
     lua_newtable(L);
     for (i = 0; i < am->points; i++) {
-        lua_pushnumber(L, am->blends[i]);
+        lua_pushinteger(L, am->blends[i]);
         lua_rawseti(L, -2, (i + 1));
     }
     lua_setfield(L, -2, "blends");
     lua_newtable(L);
     for (i = 0; i < am->points; i++) {
-        lua_pushnumber(L, am->designs[i]);
+        lua_pushinteger(L, am->designs[i]);
         lua_rawseti(L, -2, (i + 1));
     }
     lua_setfield(L, -2, "designs");
@@ -1853,7 +1853,7 @@ static void handle_mmset(lua_State * L, struct mmset *mm)
     if (mm->instance_count > 0) {
         lua_newtable(L);
         for (i = 0; i < mm->instance_count * mm->axis_count; i++) {
-            lua_pushnumber(L, mm->positions[i]);
+            lua_pushinteger(L, mm->positions[i]);
             lua_rawseti(L, -2, (i + 1));
         }
         lua_setfield(L, -2, "positions");
@@ -1878,7 +1878,7 @@ static void handle_mmset(lua_State * L, struct mmset *mm)
 
         lua_newtable(L);
         for (i = 0; i < mm->instance_count; i++) {
-            lua_pushnumber(L, mm->defweights[i]);
+            lua_pushinteger(L, mm->defweights[i]);
             lua_rawseti(L, -2, (i + 1));
         }
         lua_setfield(L, -2, "defweights");
@@ -1980,14 +1980,14 @@ static void handle_splinefont(lua_State * L, struct splinefont *sf)
         }
         for (k = 0; k < l; k++) {
             if (sf->glyphs[k]) {
-                lua_pushnumber(L, (k + 1));
+                lua_pushinteger(L, (k + 1));
                 lua_createtable(L, 0, 12);
                 handle_splinechar(L, sf->glyphs[k], sf->hasvmetrics);
                 lua_rawset(L, -3);
             }
         }
         if (sf->glyphs != NULL && l < sf->glyphcnt) {
-            lua_pushnumber(L, 0);
+            lua_pushinteger(L, 0);
             if (sf->glyphs[l]) {
                 lua_createtable(L, 0, 12);
                 handle_splinechar(L, sf->glyphs[l], sf->hasvmetrics);
@@ -2000,7 +2000,7 @@ static void handle_splinefont(lua_State * L, struct splinefont *sf)
     if ((l + 1) < sf->glyphcnt) {
         for (k = (l + 1); k < sf->glyphcnt; k++) {
             if (sf->glyphs[k]) {
-                lua_pushnumber(L, k);
+                lua_pushinteger(L, k);
                 lua_createtable(L, 0, 12);
                 handle_splinechar(L, sf->glyphs[k], sf->hasvmetrics);
                 lua_rawset(L, -3);
@@ -2098,8 +2098,8 @@ static void handle_splinefont(lua_State * L, struct splinefont *sf)
         dump_enumfield(L, "type", sf->texdata.type, tex_type_enum);
         lua_newtable(L);
         for (k = 0; k < 22; k++) {
-            lua_pushnumber(L, k);
-            lua_pushnumber(L, sf->texdata.params[k]);
+            lua_pushinteger(L, k);
+            lua_pushinteger(L, sf->texdata.params[k]);
             lua_rawset(L, -3);
         }
         lua_setfield(L, -2, "params");
@@ -2590,7 +2590,7 @@ static int ff_glyph_index(lua_State * L)
             lua_pushstring(L, glyph->name);
             break;
         case GK_unicode:
-            lua_pushnumber(L, glyph->unicodeenc);
+            lua_pushinteger(L, glyph->unicodeenc);
             break;
         case GK_boundingbox:
             if (glyph->xmax == 0 && glyph->ymax == 0 && glyph->xmin == 0 && glyph->ymin == 0) {
@@ -2602,27 +2602,27 @@ static int ff_glyph_index(lua_State * L)
                 glyph->ymax = bb.maxy;
             }
             lua_createtable(L, 4, 0);
-            lua_pushnumber(L, 1);
-            lua_pushnumber(L, glyph->xmin);
+            lua_pushinteger(L, 1);
+            lua_pushinteger(L, glyph->xmin);
             lua_rawset(L, -3);
-            lua_pushnumber(L, 2);
-            lua_pushnumber(L, glyph->ymin);
+            lua_pushinteger(L, 2);
+            lua_pushinteger(L, glyph->ymin);
             lua_rawset(L, -3);
-            lua_pushnumber(L, 3);
-            lua_pushnumber(L, glyph->xmax);
+            lua_pushinteger(L, 3);
+            lua_pushinteger(L, glyph->xmax);
             lua_rawset(L, -3);
-            lua_pushnumber(L, 4);
-            lua_pushnumber(L, glyph->ymax);
+            lua_pushinteger(L, 4);
+            lua_pushinteger(L, glyph->ymax);
             lua_rawset(L, -3);
             break;
         case GK_vwidth:
-            lua_pushnumber(L, glyph->vwidth);
+            lua_pushinteger(L, glyph->vwidth);
             break;
         case GK_width:
-            lua_pushnumber(L, glyph->width);
+            lua_pushinteger(L, glyph->width);
             break;
         case GK_lsidebearing:
-            lua_pushnumber(L, glyph->lsidebearing);
+            lua_pushinteger(L, glyph->lsidebearing);
             break;
         case GK_class:
             if (glyph->glyph_class > 0) {
@@ -2692,31 +2692,31 @@ static int ff_glyph_index(lua_State * L)
             break;
         case GK_tex_height:
             if (glyph->tex_height != TEX_UNDEF) {
-                lua_pushnumber(L, glyph->tex_height);
+                lua_pushinteger(L, glyph->tex_height);
             } else {
                 lua_pushnil(L);
             }
             break;
         case GK_tex_depth:
             if (glyph->tex_height != TEX_UNDEF) {
-                lua_pushnumber(L, glyph->tex_depth);
+                lua_pushinteger(L, glyph->tex_depth);
             } else {
                 lua_pushnil(L);
             }
             break;
         case GK_is_extended_shape:
-            lua_pushnumber(L, glyph->is_extended_shape);
+            lua_pushinteger(L, glyph->is_extended_shape);
             break;
         case GK_italic_correction:
             if (glyph->italic_correction != TEX_UNDEF) {
-                lua_pushnumber(L, glyph->italic_correction);
+                lua_pushinteger(L, glyph->italic_correction);
             } else {
                 lua_pushnil(L);
             }
             break;
         case GK_top_accent:
             if (glyph->top_accent_horiz != TEX_UNDEF) {
-                lua_pushnumber(L, glyph->top_accent_horiz);
+                lua_pushinteger(L, glyph->top_accent_horiz);
             } else {
                 lua_pushnil(L);
             }
@@ -2794,38 +2794,38 @@ static int ff_index(lua_State * L)
             lua_pushstring(L, sf->version);
             break;
         case FK_italicangle:
-            lua_pushnumber(L, sf->italicangle);
+            lua_pushinteger(L, sf->italicangle);
             break;
         case FK_upos:
-            lua_pushnumber(L, sf->upos);
+            lua_pushinteger(L, sf->upos);
             break;
         case FK_uwidth:
-            lua_pushnumber(L, sf->uwidth);
+            lua_pushinteger(L, sf->uwidth);
             break;
         case FK_ascent:
-            lua_pushnumber(L, sf->ascent);
+            lua_pushinteger(L, sf->ascent);
             break;
         case FK_descent:
-            lua_pushnumber(L, sf->descent);
+            lua_pushinteger(L, sf->descent);
             break;
         case FK_uniqueid:
-            lua_pushnumber(L, sf->uniqueid);
+            lua_pushinteger(L, sf->uniqueid);
             break;
         case FK_glyphcnt:
             if (sf->glyphcnt > 0) {
-                lua_pushnumber(L, sf->glyphmax - sf->glyphmin + 1);
+                lua_pushinteger(L, sf->glyphmax - sf->glyphmin + 1);
             } else {
-                lua_pushnumber(L, 0);
+                lua_pushinteger(L, 0);
             }
             break;
         case FK_glyphmax:
-            lua_pushnumber(L, sf->glyphmax - 1);
+            lua_pushinteger(L, sf->glyphmax - 1);
             break;
         case FK_glyphmin:
-            lua_pushnumber(L, sf->glyphmin);
+            lua_pushinteger(L, sf->glyphmin);
             break;
         case FK_units_per_em:
-            lua_pushnumber(L, sf->units_per_em);
+            lua_pushinteger(L, sf->units_per_em);
             break;
         case FK_lookups:
             if (sf->possub != NULL) {
@@ -2844,34 +2844,34 @@ static int ff_index(lua_State * L)
             lua_setmetatable(L, -2);        /* assign the metatable */
             break;
         case FK_hasvmetrics:
-            lua_pushnumber(L, sf->hasvmetrics);
+            lua_pushinteger(L, sf->hasvmetrics);
             break;
         case FK_onlybitmaps:
-            lua_pushnumber(L, sf->onlybitmaps);
+            lua_pushinteger(L, sf->onlybitmaps);
             break;
         case FK_serifcheck:
-            lua_pushnumber(L, sf->serifcheck);
+            lua_pushinteger(L, sf->serifcheck);
             break;
         case FK_isserif:
-            lua_pushnumber(L, sf->isserif);
+            lua_pushinteger(L, sf->isserif);
             break;
         case FK_issans:
-            lua_pushnumber(L, sf->issans);
+            lua_pushinteger(L, sf->issans);
             break;
         case FK_encodingchanged:
-            lua_pushnumber(L, sf->encodingchanged);
+            lua_pushinteger(L, sf->encodingchanged);
             break;
         case FK_strokedfont:
-            lua_pushnumber(L, sf->strokedfont);
+            lua_pushinteger(L, sf->strokedfont);
             break;
         case FK_use_typo_metrics:
-            lua_pushnumber(L, sf->use_typo_metrics);
+            lua_pushinteger(L, sf->use_typo_metrics);
             break;
         case FK_weight_width_slope_only:
-            lua_pushnumber(L, sf->weight_width_slope_only);
+            lua_pushinteger(L, sf->weight_width_slope_only);
             break;
         case FK_head_optimized_for_cleartype:
-            lua_pushnumber(L, sf->head_optimized_for_cleartype);
+            lua_pushinteger(L, sf->head_optimized_for_cleartype);
             break;
         case FK_uni_interp:
             lua_pushstring(L, uni_interp_enum[(sf->uni_interp + 1)]);
@@ -2967,8 +2967,8 @@ static int ff_index(lua_State * L)
                 dump_enumfield(L, "type", sf->texdata.type, tex_type_enum);
                 lua_newtable(L);
                 for (k = 0; k < 22; k++) {
-                    lua_pushnumber(L, k);
-                    lua_pushnumber(L, sf->texdata.params[k]);
+                    lua_pushinteger(L, k);
+                    lua_pushinteger(L, sf->texdata.params[k]);
                     lua_rawset(L, -3);
                 }
                 lua_setfield(L, -2, "params");
@@ -3028,16 +3028,16 @@ static int ff_index(lua_State * L)
             lua_pushstring(L, sf->chosenname);
             break;
         case FK_macstyle:
-            lua_pushnumber(L, sf->macstyle);
+            lua_pushinteger(L, sf->macstyle);
             break;
         case FK_fondname:
             lua_pushstring(L, sf->fondname);
             break;
         case FK_design_size:
-            lua_pushnumber(L, sf->design_size);
+            lua_pushinteger(L, sf->design_size);
             break;
         case FK_fontstyle_id:
-            lua_pushnumber(L, sf->fontstyle_id);
+            lua_pushinteger(L, sf->fontstyle_id);
             break;
         case FK_fontstyle_name:
             if (sf->fontstyle_name != NULL) {
@@ -3048,13 +3048,13 @@ static int ff_index(lua_State * L)
             }
             break;
         case FK_design_range_bottom:
-            lua_pushnumber(L, sf->design_range_bottom);
+            lua_pushinteger(L, sf->design_range_bottom);
             break;
         case FK_design_range_top:
-            lua_pushnumber(L, sf->design_range_top);
+            lua_pushinteger(L, sf->design_range_top);
             break;
         case FK_strokewidth:
-            lua_pushnumber(L, sf->strokewidth);
+            lua_pushinteger(L, sf->strokewidth);
             break;
         case FK_mark_classes:
             if (sf->mark_class_cnt > 0) {
@@ -3071,16 +3071,16 @@ static int ff_index(lua_State * L)
             }
             break;
         case FK_creationtime:
-            lua_pushnumber(L, sf->creationtime);
+            lua_pushinteger(L, sf->creationtime);
             break;
         case FK_modificationtime:
-            lua_pushnumber(L, sf->modificationtime);
+            lua_pushinteger(L, sf->modificationtime);
             break;
         case FK_os2_version:
-            lua_pushnumber(L, sf->os2_version);
+            lua_pushinteger(L, sf->os2_version);
             break;
         case FK_sfd_version:
-            lua_pushnumber(L, sf->sfd_version);
+            lua_pushinteger(L, sf->sfd_version);
             break;
         case FK_math:
             if (sf->MATH != NULL) {
@@ -3157,7 +3157,7 @@ static int ff_index(lua_State * L)
             }
             break;
         case FK_extrema_bound:
-            lua_pushnumber(L, sf->extrema_bound);
+            lua_pushinteger(L, sf->extrema_bound);
             break;
         case FK_notdef_loc:
             lua_pushinteger(L, notdef_loc(sf));
diff --git a/texk/web2c/luatexdir/luamd5/md5lib.c b/texk/web2c/luatexdir/luamd5/md5lib.c
index 40fd2de38..dfbc0865a 100644
--- a/texk/web2c/luatexdir/luamd5/md5lib.c
+++ b/texk/web2c/luatexdir/luamd5/md5lib.c
@@ -5,7 +5,6 @@
 *  @author  Roberto Ierusalimschy
 */
 
-
 #include <stdlib.h>
 #include <string.h>
 #include <time.h>
@@ -15,22 +14,21 @@
 
 #include "luamd5.h"
 
-
 /**
 *  Hash function. Returns a hash for a given string.
 *  @param message: arbitrary binary string.
 *  @return  A 128-bit hash string.
 */
+
 static int lmd5 (lua_State *L) {
-  char buff[16];
-  size_t l;
-  const char *message = luaL_checklstring(L, 1, &l);
-  md5(message, l, buff);
-  lua_pushlstring(L, buff, 16L);
-  return 1;
+    char buff[16];
+    size_t l;
+    const char *message = luaL_checklstring(L, 1, &l);
+    md5(message, l, buff);
+    lua_pushlstring(L, buff, 16L);
+    return 1;
 }
 
-
 /**
 *  X-Or. Does a bit-a-bit exclusive-or of two strings.
 *  @param s1: arbitrary binary string.
@@ -38,78 +36,73 @@ static int lmd5 (lua_State *L) {
 *  @return  a binary string with same length as s1 and s2,
 *   where each bit is the exclusive-or of the corresponding bits in s1-s2.
 */
+
 static int ex_or (lua_State *L) {
-  size_t l1, l2;
-  const char *s1 = luaL_checklstring(L, 1, &l1);
-  const char *s2 = luaL_checklstring(L, 2, &l2);
-  luaL_Buffer b;
-  luaL_argcheck( L, l1 == l2, 2, "lengths must be equal" );
-  luaL_buffinit(L, &b);
-  while (l1--) luaL_addchar(&b, (*s1++)^(*s2++));
-  luaL_pushresult(&b);
-  return 1;
+    size_t l1, l2;
+    const char *s1 = luaL_checklstring(L, 1, &l1);
+    const char *s2 = luaL_checklstring(L, 2, &l2);
+    luaL_Buffer b;
+    luaL_argcheck( L, l1 == l2, 2, "lengths must be equal" );
+    luaL_buffinit(L, &b);
+    while (l1--)
+        luaL_addchar(&b, (*s1++)^(*s2++));
+    luaL_pushresult(&b);
+    return 1;
 }
 
-
 static void checkseed (lua_State *L) {
-  if (lua_isnone(L, 3)) {  /* no seed? */
-    time_t tm = time(NULL);  /* for `random' seed */
-    lua_pushlstring(L, (char *)&tm, sizeof(tm));
-  }
+    if (lua_isnone(L, 3)) {  /* no seed? */
+        time_t tm = time(NULL);  /* for `random' seed */
+        lua_pushlstring(L, (char *)&tm, sizeof(tm));
+    }
 }
 
-
-#define MAXKEY	256
-#define BLOCKSIZE	16
-
-
+#define MAXKEY    256
+#define BLOCKSIZE  16
 
 static int initblock (lua_State *L, const char *seed, int lseed, char *block) {
-  size_t lkey;
-  const char *key = luaL_checklstring(L, 2, &lkey);
-  if (lkey > MAXKEY)
-    luaL_error(L, "key too long (> %d)", MAXKEY);
-  memset(block, 0, BLOCKSIZE);
-  memcpy(block, seed, lseed);
-  memcpy(block+BLOCKSIZE, key, lkey);
-  return (int)lkey+BLOCKSIZE;
+    size_t lkey;
+    const char *key = luaL_checklstring(L, 2, &lkey);
+    if (lkey > MAXKEY)
+        luaL_error(L, "key too long (> %d)", MAXKEY);
+    memset(block, 0, BLOCKSIZE);
+    memcpy(block, seed, lseed);
+    memcpy(block+BLOCKSIZE, key, lkey);
+    return (int)lkey+BLOCKSIZE;
 }
 
-
 static void codestream (lua_State *L, const char *msg, size_t lmsg,
                                       char *block, int lblock) {
-  luaL_Buffer b;
-  luaL_buffinit(L, &b);
-  while (lmsg > 0) {
-    char code[BLOCKSIZE];
-    int i;
-    md5(block, lblock, code);
-    for (i=0; i<BLOCKSIZE && lmsg > 0; i++, lmsg--)
-      code[i] ^= *msg++;
-    luaL_addlstring(&b, code, i); 
-    memcpy(block, code, i); /* update seed */
-  }
-  luaL_pushresult(&b);
+    luaL_Buffer b;
+    luaL_buffinit(L, &b);
+    while (lmsg > 0) {
+        char code[BLOCKSIZE];
+        int i;
+        md5(block, lblock, code);
+        for (i=0; i<BLOCKSIZE && lmsg > 0; i++, lmsg--)
+            code[i] ^= *msg++;
+        luaL_addlstring(&b, code, i);
+        memcpy(block, code, i); /* update seed */
+    }
+    luaL_pushresult(&b);
 }
 
-
 static void decodestream (lua_State *L, const char *cypher, size_t lcypher,
                           char *block, int lblock) {
-  luaL_Buffer b;
-  luaL_buffinit(L, &b);
-  while (lcypher > 0) {
-    char code[BLOCKSIZE];
-    int i;
-    md5(block, lblock, code);  /* update seed */
-    for (i=0; i<BLOCKSIZE && lcypher > 0; i++, lcypher--)
-      code[i] ^= *cypher++;
-    luaL_addlstring(&b, code, i); 
-    memcpy(block, cypher-i, i);
-  }
-  luaL_pushresult(&b);
+    luaL_Buffer b;
+    luaL_buffinit(L, &b);
+    while (lcypher > 0) {
+        char code[BLOCKSIZE];
+        int i;
+        md5(block, lblock, code);  /* update seed */
+        for (i=0; i<BLOCKSIZE && lcypher > 0; i++, lcypher--)
+            code[i] ^= *cypher++;
+        luaL_addlstring(&b, code, i);
+        memcpy(block, cypher-i, i);
+    }
+    luaL_pushresult(&b);
 }
 
-
 /**
 *  Encrypts a string. Uses the hash function md5 in CFB (Cipher-feedback
 *  mode).
@@ -117,28 +110,29 @@ static void decodestream (lua_State *L, const char *cypher, size_t lcypher,
 *  @param key: arbitrary binary string to be used as a key.
 *  @param [seed]: optional arbitrary binary string to be used as a seed.
 *  if no seed is provided, the function uses the result of
-*  <code>time()</code> as a seed.  
+*  <code>time()</code> as a seed.
 *  @return  The cyphertext (as a binary string).
 */
+
 static int crypt (lua_State *L) {
-  size_t lmsg;
-  const char *msg = luaL_checklstring(L, 1, &lmsg);
-  size_t lseed;
-  const char *seed;
-  int lblock;
-  char block[BLOCKSIZE+MAXKEY];
-  checkseed(L);
-  seed = luaL_checklstring(L, 3, &lseed);
-  if (lseed > BLOCKSIZE)
-    luaL_error(L, "seed too long (> %d)", BLOCKSIZE);
-  /* put seed and seed length at the beginning of result */
-  block[0] = (char)lseed;
-  memcpy(block+1, seed, lseed);
-  lua_pushlstring(L, block, lseed+1);  /* to concat with result */
-  lblock = initblock(L, seed, lseed, block);
-  codestream(L, msg, lmsg, block, lblock);
-  lua_concat(L, 2);
-  return 1;
+    size_t lmsg;
+    const char *msg = luaL_checklstring(L, 1, &lmsg);
+    size_t lseed;
+    const char *seed;
+    int lblock;
+    char block[BLOCKSIZE+MAXKEY];
+    checkseed(L);
+    seed = luaL_checklstring(L, 3, &lseed);
+    if (lseed > BLOCKSIZE)
+        luaL_error(L, "seed too long (> %d)", BLOCKSIZE);
+      /* put seed and seed length at the beginning of result */
+    block[0] = (char)lseed;
+    memcpy(block+1, seed, lseed);
+    lua_pushlstring(L, block, lseed+1);  /* to concat with result */
+    lblock = initblock(L, seed, lseed, block);
+    codestream(L, msg, lmsg, block, lblock);
+    lua_concat(L, 2);
+    return 1;
 }
 
 
@@ -151,33 +145,104 @@ static int crypt (lua_State *L) {
 *  @return  The plaintext.
 */
 static int decrypt (lua_State *L) {
-  size_t lcyphertext;
-  const char *cyphertext = luaL_checklstring(L, 1, &lcyphertext);
-  size_t lseed = cyphertext[0];
-  const char *seed = cyphertext+1;
-  int lblock;
-  char block[BLOCKSIZE+MAXKEY];
-  luaL_argcheck(L, lcyphertext >= lseed+1 && lseed <= BLOCKSIZE, 1,
-                 "invalid cyphered string");
-  cyphertext += lseed+1;
-  lcyphertext -= lseed+1;
-  lblock = initblock(L, seed, lseed, block);
-  decodestream(L, cyphertext, lcyphertext, block, lblock);
-  return 1;
+    size_t lcyphertext;
+    const char *cyphertext = luaL_checklstring(L, 1, &lcyphertext);
+    size_t lseed = cyphertext[0];
+    const char *seed = cyphertext+1;
+    int lblock;
+    char block[BLOCKSIZE+MAXKEY];
+    luaL_argcheck(L, lcyphertext >= lseed+1 && lseed <= BLOCKSIZE, 1,
+        "invalid cyphered string");
+    cyphertext += lseed+1;
+    lcyphertext -= lseed+1;
+    lblock = initblock(L, seed, lseed, block);
+    decodestream(L, cyphertext, lcyphertext, block, lblock);
+    return 1;
+}
+
+/* not now .. doesn't compile anyway
+
+#include "../luapplib/util/utilmd5.h"
+
+static int pdfelib_md_5(lua_State * L)
+{
+    if (lua_type(L,1) == LUA_TSTRING) {
+        uint8_t result[16];
+        size_t size = 0;
+        const char *data = lua_tolstring(L,1,&size);
+        md5(data,size,result);
+        lua_pushlstring(L,(const char *)result,16);
+        return 1;
+    }
+    return 0;
 }
 
+*/
 
 static struct luaL_Reg md5lib[] = {
-  {"sum", lmd5},
-  {"exor", ex_or},
-  {"crypt", crypt},
-  {"decrypt", decrypt},
-  {NULL, NULL}
+    { "sum",     lmd5},
+    { "exor",    ex_or},
+    { "crypt",   crypt},
+    { "decrypt", decrypt},
+    { NULL,      NULL}
 };
 
+int luaopen_md5(lua_State *L) {
+    luaL_openlib(L, "md5",  md5lib,  0);
+    return 1;
+}
+
+/* We could use a different file but this is as easy. */
+
+#include "../luapplib/util/utilsha.h"
+
+static int sha2_256(lua_State * L)
+{
+    if (lua_type(L,1) == LUA_TSTRING) {
+        uint8_t result[SHA256_DIGEST_LENGTH];
+        size_t size = 0;
+        const char *data = lua_tolstring(L,1,&size);
+        sha256(data,size,result);
+        lua_pushlstring(L,(const char *)result,SHA256_DIGEST_LENGTH);
+        return 1;
+    }
+    return 0;
+}
+
+static int sha2_384(lua_State * L)
+{
+    if (lua_type(L,1) == LUA_TSTRING) {
+        size_t size = 0;
+        uint8_t result[SHA384_DIGEST_LENGTH];
+        const char *data = lua_tolstring(L,1,&size);
+        sha384(data,size,result);
+        lua_pushlstring(L,(const char *)result,SHA384_DIGEST_LENGTH);
+        return 1;
+    }
+    return 0;
+}
 
-int luaopen_md5 (lua_State *L) {
-  luaL_openlib(L, "md5", md5lib, 0);
-  return 1;
+static int sha2_512(lua_State * L)
+{
+    if (lua_type(L,1) == LUA_TSTRING) {
+        uint8_t result[SHA512_DIGEST_LENGTH];
+        size_t size = 0;
+        const char *data = lua_tolstring(L,1,&size);
+        sha512(data,size,result);
+        lua_pushlstring(L,(const char *)result,SHA512_DIGEST_LENGTH);
+        return 1;
+    }
+    return 0;
 }
 
+static struct luaL_Reg sha2lib[] = {
+    { "digest256", sha2_256 },
+    { "digest384", sha2_384 },
+    { "digest512", sha2_512 },
+    { NULL,        NULL}
+};
+
+int luaopen_sha2(lua_State *L) {
+    luaL_openlib(L, "sha2", sha2lib, 0);
+    return 1;
+}
diff --git a/texk/web2c/luatexdir/luasocket/src/lua_preload.c b/texk/web2c/luatexdir/luasocket/src/lua_preload.c
index e9433dfdb..838871c1d 100644
--- a/texk/web2c/luatexdir/luasocket/src/lua_preload.c
+++ b/texk/web2c/luatexdir/luasocket/src/lua_preload.c
@@ -15,6 +15,7 @@ int luatex_http_lua_open(lua_State*);
 int luatex_ftp_lua_open(lua_State*);
 
 
+extern void luatex_socketlua_open (lua_State *) ;
 #include "ftp_lua.c"
 #include "headers_lua.c" 
 #include "http_lua.c"
diff --git a/texk/web2c/luatexdir/luasocket/src/options.c b/texk/web2c/luatexdir/luasocket/src/options.c
index 20f4c2802..fabfe8ce3 100644
--- a/texk/web2c/luatexdir/luasocket/src/options.c
+++ b/texk/web2c/luatexdir/luasocket/src/options.c
@@ -37,7 +37,7 @@ int opt_meth_setoption(lua_State *L, p_opt opt, p_socket ps)
     while (opt->name && strcmp(name, opt->name))
         opt++;
     if (!opt->func) {
-        char msg[45];
+        char msg[57];
         sprintf(msg, "unsupported option `%.35s'", name);
         luaL_argerror(L, 2, msg);
     }
@@ -50,7 +50,7 @@ int opt_meth_getoption(lua_State *L, p_opt opt, p_socket ps)
     while (opt->name && strcmp(name, opt->name))
         opt++;
     if (!opt->func) {
-        char msg[45];
+        char msg[57];
         sprintf(msg, "unsupported option `%.35s'", name);
         luaL_argerror(L, 2, msg);
     }
diff --git a/texk/web2c/luatexdir/luasocket/src/serial.c b/texk/web2c/luatexdir/luasocket/src/serial.c
index f121bbf0a..b666e61f9 100644
--- a/texk/web2c/luatexdir/luasocket/src/serial.c
+++ b/texk/web2c/luatexdir/luasocket/src/serial.c
@@ -31,44 +31,44 @@ have only one object type.
 /*=========================================================================*\
 * Internal function prototypes
 \*=========================================================================*/
-static int global_create(lua_State *L);
-static int meth_send(lua_State *L);
-static int meth_receive(lua_State *L);
-static int meth_close(lua_State *L);
-static int meth_settimeout(lua_State *L);
-static int meth_getfd(lua_State *L);
-static int meth_setfd(lua_State *L);
-static int meth_dirty(lua_State *L);
-static int meth_getstats(lua_State *L);
-static int meth_setstats(lua_State *L);
+/*static int global_create(lua_State *L);*/
+/* static int meth_send(lua_State *L); */
+/* static int meth_receive(lua_State *L); */
+/* static int meth_close(lua_State *L); */
+/* static int meth_settimeout(lua_State *L); */
+/* static int meth_getfd(lua_State *L); */
+/* static int meth_setfd(lua_State *L); */
+/* static int meth_dirty(lua_State *L); */
+/* static int meth_getstats(lua_State *L); */
+/* static int meth_setstats(lua_State *L); */
 
 /* serial object methods */
-static luaL_Reg serial_methods[] = {
-    {"__gc",        meth_close},
-    {"__tostring",  auxiliar_tostring},
-    {"close",       meth_close},
-    {"dirty",       meth_dirty},
-    {"getfd",       meth_getfd},
-    {"getstats",    meth_getstats},
-    {"setstats",    meth_setstats},
-    {"receive",     meth_receive},
-    {"send",        meth_send},
-    {"setfd",       meth_setfd},
-    {"settimeout",  meth_settimeout},
-    {NULL,          NULL}
-};
+/* static luaL_Reg serial_methods[] = { */
+/*     {"__gc",        meth_close}, */
+/*     {"__tostring",  auxiliar_tostring}, */
+/*     {"close",       meth_close}, */
+/*     {"dirty",       meth_dirty}, */
+/*     {"getfd",       meth_getfd}, */
+/*     {"getstats",    meth_getstats}, */
+/*     {"setstats",    meth_setstats}, */
+/*     {"receive",     meth_receive}, */
+/*     {"send",        meth_send}, */
+/*     {"setfd",       meth_setfd}, */
+/*     {"settimeout",  meth_settimeout}, */
+/*     {NULL,          NULL} */
+/* }; */
 
 /*-------------------------------------------------------------------------*\
-* Initializes module
+* Initializes module (luatex extension, unused )
 \*-------------------------------------------------------------------------*/
-LUASOCKET_API int luaopen_socket_serial(lua_State *L) {
-    /* create classes */
-    auxiliar_newclass(L, "serial{client}", serial_methods);
-    /* create class groups */
-    auxiliar_add2group(L, "serial{client}", "serial{any}");
-    lua_pushcfunction(L, global_create);
-    return 1;
-}
+/* LUASOCKET_API int luaopen_socket_serial(lua_State *L) { */
+/*     /\* create classes *\/ */
+/*     auxiliar_newclass(L, "serial{client}", serial_methods); */
+/*     /\* create class groups *\/ */
+/*     auxiliar_add2group(L, "serial{client}", "serial{any}"); */
+/*     lua_pushcfunction(L, global_create); */
+/*     return 1; */
+/* } */
 
 /*=========================================================================*\
 * Lua methods
@@ -76,67 +76,67 @@ LUASOCKET_API int luaopen_socket_serial(lua_State *L) {
 /*-------------------------------------------------------------------------*\
 * Just call buffered IO methods
 \*-------------------------------------------------------------------------*/
-static int meth_send(lua_State *L) {
-    p_unix un = (p_unix) auxiliar_checkclass(L, "serial{client}", 1);
-    return buffer_meth_send(L, &un->buf);
-}
-
-static int meth_receive(lua_State *L) {
-    p_unix un = (p_unix) auxiliar_checkclass(L, "serial{client}", 1);
-    return buffer_meth_receive(L, &un->buf);
-}
-
-static int meth_getstats(lua_State *L) {
-    p_unix un = (p_unix) auxiliar_checkclass(L, "serial{client}", 1);
-    return buffer_meth_getstats(L, &un->buf);
-}
-
-static int meth_setstats(lua_State *L) {
-    p_unix un = (p_unix) auxiliar_checkclass(L, "serial{client}", 1);
-    return buffer_meth_setstats(L, &un->buf);
-}
+/* static int meth_send(lua_State *L) { */
+/*     p_unix un = (p_unix) auxiliar_checkclass(L, "serial{client}", 1); */
+/*     return buffer_meth_send(L, &un->buf); */
+/* } */
+
+/* static int meth_receive(lua_State *L) { */
+/*     p_unix un = (p_unix) auxiliar_checkclass(L, "serial{client}", 1); */
+/*     return buffer_meth_receive(L, &un->buf); */
+/* } */
+
+/* static int meth_getstats(lua_State *L) { */
+/*     p_unix un = (p_unix) auxiliar_checkclass(L, "serial{client}", 1); */
+/*     return buffer_meth_getstats(L, &un->buf); */
+/* } */
+
+/* static int meth_setstats(lua_State *L) { */
+/*     p_unix un = (p_unix) auxiliar_checkclass(L, "serial{client}", 1); */
+/*     return buffer_meth_setstats(L, &un->buf); */
+/* } */
 
 /*-------------------------------------------------------------------------*\
 * Select support methods
 \*-------------------------------------------------------------------------*/
-static int meth_getfd(lua_State *L) {
-    p_unix un = (p_unix) auxiliar_checkgroup(L, "serial{any}", 1);
-    lua_pushnumber(L, (int) un->sock);
-    return 1;
-}
-
-/* this is very dangerous, but can be handy for those that are brave enough */
-static int meth_setfd(lua_State *L) {
-    p_unix un = (p_unix) auxiliar_checkgroup(L, "serial{any}", 1);
-    un->sock = (t_socket) luaL_checknumber(L, 2);
-    return 0;
-}
-
-static int meth_dirty(lua_State *L) {
-    p_unix un = (p_unix) auxiliar_checkgroup(L, "serial{any}", 1);
-    lua_pushboolean(L, !buffer_isempty(&un->buf));
-    return 1;
-}
+/* static int meth_getfd(lua_State *L) { */
+/*     p_unix un = (p_unix) auxiliar_checkgroup(L, "serial{any}", 1); */
+/*     lua_pushnumber(L, (int) un->sock); */
+/*     return 1; */
+/* } */
+
+/* /\* this is very dangerous, but can be handy for those that are brave enough *\/ */
+/* static int meth_setfd(lua_State *L) { */
+/*     p_unix un = (p_unix) auxiliar_checkgroup(L, "serial{any}", 1); */
+/*     un->sock = (t_socket) luaL_checknumber(L, 2); */
+/*     return 0; */
+/* } */
+
+/* static int meth_dirty(lua_State *L) { */
+/*     p_unix un = (p_unix) auxiliar_checkgroup(L, "serial{any}", 1); */
+/*     lua_pushboolean(L, !buffer_isempty(&un->buf)); */
+/*     return 1; */
+/* } */
 
 /*-------------------------------------------------------------------------*\
 * Closes socket used by object
 \*-------------------------------------------------------------------------*/
-static int meth_close(lua_State *L)
-{
-    p_unix un = (p_unix) auxiliar_checkgroup(L, "serial{any}", 1);
-    socket_destroy(&un->sock);
-    lua_pushnumber(L, 1);
-    return 1;
-}
+/* static int meth_close(lua_State *L) */
+/* { */
+/*     p_unix un = (p_unix) auxiliar_checkgroup(L, "serial{any}", 1); */
+/*     socket_destroy(&un->sock); */
+/*     lua_pushnumber(L, 1); */
+/*     return 1; */
+/* } */
 
 
 /*-------------------------------------------------------------------------*\
 * Just call tm methods
 \*-------------------------------------------------------------------------*/
-static int meth_settimeout(lua_State *L) {
-    p_unix un = (p_unix) auxiliar_checkgroup(L, "serial{any}", 1);
-    return timeout_meth_settimeout(L, &un->tm);
-}
+/* static int meth_settimeout(lua_State *L) { */
+/*     p_unix un = (p_unix) auxiliar_checkgroup(L, "serial{any}", 1); */
+/*     return timeout_meth_settimeout(L, &un->tm); */
+/* } */
 
 /*=========================================================================*\
 * Library functions
@@ -146,35 +146,35 @@ static int meth_settimeout(lua_State *L) {
 /*-------------------------------------------------------------------------*\
 * Creates a serial object
 \*-------------------------------------------------------------------------*/
-static int global_create(lua_State *L) {
-    const char* path = luaL_checkstring(L, 1);
-
-    /* allocate unix object */
-    p_unix un = (p_unix) lua_newuserdata(L, sizeof(t_unix));
-
-    /* open serial device */
-#if defined(_WIN32)
-    t_socket sock = open(path, O_RDWR);
-#else
-    t_socket sock = open(path, O_NOCTTY|O_RDWR);
-#endif
-
-    /*printf("open %s on %d\n", path, sock);*/
-
-    if (sock < 0)  {
-        lua_pushnil(L);
-        lua_pushstring(L, socket_strerror(errno));
-        lua_pushnumber(L, errno);
-        return 3;
-    }
-    /* set its type as client object */
-    auxiliar_setclass(L, "serial{client}", -1);
-    /* initialize remaining structure fields */
-    socket_setnonblocking(&sock);
-    un->sock = sock;
-    io_init(&un->io, (p_send) socket_write, (p_recv) socket_read,
-            (p_error) socket_ioerror, &un->sock);
-    timeout_init(&un->tm, -1, -1);
-    buffer_init(&un->buf, &un->io, &un->tm);
-    return 1;
-}
+/* static int global_create(lua_State *L) { */
+/*     const char* path = luaL_checkstring(L, 1); */
+
+/*     /\* allocate unix object *\/ */
+/*     p_unix un = (p_unix) lua_newuserdata(L, sizeof(t_unix)); */
+
+/*     /\* open serial device *\/ */
+/* #if defined(_WIN32) */
+/*     t_socket sock = open(path, O_RDWR); */
+/* #else */
+/*     t_socket sock = open(path, O_NOCTTY|O_RDWR); */
+/* #endif */
+
+/*     /\*printf("open %s on %d\n", path, sock);*\/ */
+
+/*     if (sock < 0)  { */
+/*         lua_pushnil(L); */
+/*         lua_pushstring(L, socket_strerror(errno)); */
+/*         lua_pushnumber(L, errno); */
+/*         return 3; */
+/*     } */
+/*     /\* set its type as client object *\/ */
+/*     auxiliar_setclass(L, "serial{client}", -1); */
+/*     /\* initialize remaining structure fields *\/ */
+/*     socket_setnonblocking(&sock); */
+/*     un->sock = sock; */
+/*     io_init(&un->io, (p_send) socket_write, (p_recv) socket_read, */
+/*             (p_error) socket_ioerror, &un->sock); */
+/*     timeout_init(&un->tm, -1, -1); */
+/*     buffer_init(&un->buf, &un->io, &un->tm); */
+/*     return 1; */
+/* } */
diff --git a/texk/web2c/luatexdir/luatex.c b/texk/web2c/luatexdir/luatex.c
index 1c8694987..014d8bfd2 100644
--- a/texk/web2c/luatexdir/luatex.c
+++ b/texk/web2c/luatexdir/luatex.c
@@ -32,9 +32,9 @@
     stick to "0" upto "9" so users can expect a number represented as string.
 */
 
-int luatex_version = 107;
+int luatex_version = 109;
 int luatex_revision = '0';
-const char *luatex_version_string = "1.07.0";
+const char *luatex_version_string = "1.09.0";
 const char *engine_name = my_name;
 
 #include <kpathsea/c-ctype.h>
diff --git a/texk/web2c/luatexdir/luatex_svnversion.h b/texk/web2c/luatexdir/luatex_svnversion.h
index 770aabbeb..90d51ef70 100644
--- a/texk/web2c/luatexdir/luatex_svnversion.h
+++ b/texk/web2c/luatexdir/luatex_svnversion.h
@@ -1 +1 @@
-#define luatex_svn_revision 6686
+#define luatex_svn_revision 6924
diff --git a/texk/web2c/luatexdir/luatexcallbackids.h b/texk/web2c/luatexdir/luatexcallbackids.h
index 9cdef26c5..a345edf64 100644
--- a/texk/web2c/luatexdir/luatexcallbackids.h
+++ b/texk/web2c/luatexdir/luatexcallbackids.h
@@ -68,8 +68,13 @@ typedef enum {
     call_edit_callback,
     build_page_insert_callback,
     glyph_stream_provider_callback,
+    font_descriptor_objnum_provider_callback,
     finish_synctex_callback,
-    total_callbacks
+    wrapup_run_callback,
+    new_graf_callback,
+    page_objnum_provider_callback,
+    make_extensible_callback,
+    total_callbacks,
 } callback_callback_types;
 
 /* lcallbacklib.c */
@@ -96,7 +101,6 @@ extern void get_lua_boolean(const char *table, const char *name, boolean * targe
 extern void get_lua_number(const char *table, const char *name, int *target);
 extern void get_lua_string(const char *table, const char *name, char **target);
 
-extern int lua_reader_callback(int callback_id, pointer *buffloc);
 
 extern char *get_lua_name(int i);
 
diff --git a/texk/web2c/luatexdir/pdf/pdfgen.h b/texk/web2c/luatexdir/pdf/pdfgen.h
index 01b0e74cd..00df7f36e 100644
--- a/texk/web2c/luatexdir/pdf/pdfgen.h
+++ b/texk/web2c/luatexdir/pdf/pdfgen.h
@@ -114,6 +114,19 @@ printing ones but the output is going to PDF buffer. Subroutines with suffix
     pdf_out(pdf, '\n'); \
 } while (0)
 
+#define pdf_check_space(pdf) do { \
+    if (pdf->cave > 0) { \
+        pdf_out(pdf, ' '); \
+        pdf->cave = 0; \
+    } \
+} while (0)
+
+#define pdf_set_space(pdf) \
+    pdf->cave = 1;
+
+#define pdf_reset_space(pdf) \
+    pdf->cave = 0;
+
 extern __attribute__ ((format(printf, 2, 3)))
 void pdf_printf(PDF, const char *, ...);
 
@@ -125,6 +138,7 @@ extern void pdf_print_str(PDF, const char *);
 extern void pdf_add_null(PDF);
 extern void pdf_add_bool(PDF, int i);
 extern void pdf_add_int(PDF, int i);
+extern void pdf_add_real(PDF, double d);
 extern void pdf_add_longint(PDF, longinteger n);
 extern void pdf_add_ref(PDF, int num);
 extern void pdf_add_string(PDF, const char *s);
@@ -140,6 +154,18 @@ extern void pdf_dict_add_streaminfo(PDF);
 extern void pdf_begin_stream(PDF);
 extern void pdf_end_stream(PDF);
 
+typedef unsigned char BYTE;
+typedef unsigned long ULONG;
+
+typedef struct {
+    ULONG length;
+    BYTE *data;
+} pdf_obj;
+
+extern pdf_obj *pdf_new_stream(void);
+extern void pdf_add_stream(pdf_obj * stream, unsigned char *buf, long len);
+extern void pdf_release_obj(pdf_obj * stream);
+
 extern void pdf_add_bp(PDF, scaled);
 
 extern strbuf_s *new_strbuf(size_t size, size_t limit);
@@ -191,8 +217,6 @@ extern char *convertStringToPDFString(const char *in, int len);
 extern void initialize_start_time(PDF);
 extern char *getcreationdate(PDF);
 
-extern void check_o_mode(PDF pdf, const char *s, int o_mode, boolean errorflag);
-
 extern void set_job_id(PDF, int, int, int, int);
 extern char *get_resname_prefix(PDF);
 extern void pdf_begin_page(PDF pdf);
@@ -201,6 +225,10 @@ extern void print_pdf_table_string(PDF pdf, const char *s);
 extern const char *get_pdf_table_string(const char *s);
 extern int get_pdf_table_bool(PDF, const char *, int);
 
+extern void pdf_open_file(PDF pdf);
+extern void pdf_write_header(PDF pdf);
+extern void pdf_finish_file(PDF pdf, int fatal_error);
+
 extern void ensure_output_state(PDF pdf, output_state s);
 extern PDF init_pdf_struct(PDF pdf);
 
@@ -210,8 +238,18 @@ extern halfword pdf_catalog_openaction;
 extern halfword pdf_names_toks;         /* additional keys of Names dictionary */
 extern halfword pdf_trailer_toks;       /* additional keys of Trailer dictionary */
 extern void scan_pdfcatalog(PDF pdf);
-extern void finish_pdf_file(PDF pdf, int luatex_version, str_number luatex_revision);
 
 extern shipping_mode_e global_shipping_mode;
 
+extern void pdf_push_list(PDF pdf, scaledpos *saved_pos, int *saved_loc);
+extern void pdf_pop_list(PDF pdf, scaledpos *saved_pos, int *saved_loc);
+
+extern void pdf_set_reference_point(PDF pdf, posstructure *refpoint);
+
+/* not pdf specific */
+
+extern void check_o_mode(PDF pdf, const char *s, int o_mode, boolean errorflag);
+extern void ensure_output_file_open(PDF pdf, const char *ext);
+
+
 #endif
diff --git a/texk/web2c/luatexdir/pdf/pdflistout.h b/texk/web2c/luatexdir/pdf/pdflistout.h
index 76c1d552f..dd3775816 100644
--- a/texk/web2c/luatexdir/pdf/pdflistout.h
+++ b/texk/web2c/luatexdir/pdf/pdflistout.h
@@ -21,28 +21,12 @@
 #ifndef PDFLISTOUT_H
 #  define PDFLISTOUT_H
 
-#  define pos_right(A) pdf->posstruct->pos.h = pdf->posstruct->pos.h + (A)
-#  define pos_left(A)  pdf->posstruct->pos.h = pdf->posstruct->pos.h - (A)
-#  define pos_up(A)    pdf->posstruct->pos.v = pdf->posstruct->pos.v + (A)
-#  define pos_down(A)  pdf->posstruct->pos.v = pdf->posstruct->pos.v - (A)
-
-typedef void (*backend_function) (); /* variadic arguments  */
-
-typedef struct {
-    char *name;                    /* name of the backend */
-    backend_function *node_fu;     /* array of node output functions */
-    backend_function *whatsit_fu;  /* array of whatsit output functions */
-} backend_struct;
-
-extern pos_info_structure pos_info;
-
-extern backend_function *backend_out;
-extern backend_function *backend_out_whatsit;
-
-extern void init_backend_functionpointers(output_mode o_mode);
+#define pos_right(A) pdf->posstruct->pos.h = pdf->posstruct->pos.h + (A)
+#define pos_left(A)  pdf->posstruct->pos.h = pdf->posstruct->pos.h - (A)
+#define pos_up(A)    pdf->posstruct->pos.v = pdf->posstruct->pos.v + (A)
+#define pos_down(A)  pdf->posstruct->pos.v = pdf->posstruct->pos.v - (A)
 
 extern void hlist_out(PDF pdf, halfword this_box, int rule_callback_id);
 extern void vlist_out(PDF pdf, halfword this_box, int rule_callback_id);
-extern void out_what(PDF pdf, halfword p);
 
 #endif
diff --git a/texk/web2c/luatexdir/pdf/pdfobj.h b/texk/web2c/luatexdir/pdf/pdfobj.h
index f8fac35ee..f6e49450b 100644
--- a/texk/web2c/luatexdir/pdf/pdfobj.h
+++ b/texk/web2c/luatexdir/pdf/pdfobj.h
@@ -35,6 +35,7 @@
 
 #  define OBJ_FLAG_ISSTREAM              (1 << 0)
 #  define OBJ_FLAG_ISFILE                (1 << 1)
+#  define OBJ_FLAG_NOLENGTH              (1 << 2)
 
 #  define obj_obj_is_stream(pdf,A)       ((obj_obj_flags((pdf), (A)) & OBJ_FLAG_ISSTREAM) != 0)
 #  define set_obj_obj_is_stream(pdf,A)   ((obj_obj_flags((pdf), (A)) |= OBJ_FLAG_ISSTREAM))
@@ -44,6 +45,10 @@
 #  define set_obj_obj_is_file(pdf,A)     ((obj_obj_flags((pdf), (A)) |= OBJ_FLAG_ISFILE))
 #  define unset_obj_obj_is_file(pdf,A)   ((obj_obj_flags((pdf), (A)) &= ~OBJ_FLAG_ISFILE))
 
+#  define obj_obj_no_length(pdf,A)       ((obj_obj_flags((pdf), (A)) & OBJ_FLAG_NOLENGTH) != 0)
+#  define set_obj_obj_no_length(pdf,A)   ((obj_obj_flags((pdf), (A)) |= OBJ_FLAG_NOLENGTH))
+#  define unset_obj_obj_no_length(pdf,A) ((obj_obj_flags((pdf), (A)) &= ~OBJ_FLAG_NOLENGTH))
+
 extern void init_obj_obj(PDF pdf, int k);
 extern void pdf_write_obj(PDF pdf, int n);
 extern void scan_obj(PDF pdf);
diff --git a/texk/web2c/luatexdir/pdf/pdftables.h b/texk/web2c/luatexdir/pdf/pdftables.h
index e29c5603d..8aa7403c1 100644
--- a/texk/web2c/luatexdir/pdf/pdftables.h
+++ b/texk/web2c/luatexdir/pdf/pdftables.h
@@ -139,6 +139,8 @@ typedef enum {
     c_pdf_pk_fixed_dpi,
     c_pdf_suppress_optional_info,
     c_pdf_omit_cidset,
+    c_pdf_recompress,
+    c_pdf_omit_charset,
 } pdf_backend_counters ;
 
 typedef enum {
@@ -187,6 +189,8 @@ extern int pdf_cur_form;
 #  define pdf_pk_fixed_dpi              get_tex_extension_count_register(c_pdf_pk_fixed_dpi)
 #  define pdf_suppress_optional_info    get_tex_extension_count_register(c_pdf_suppress_optional_info)
 #  define pdf_omit_cidset               get_tex_extension_count_register(c_pdf_omit_cidset)
+#  define pdf_omit_charset              get_tex_extension_count_register(c_pdf_omit_charset)
+#  define pdf_recompress                get_tex_extension_count_register(c_pdf_recompress)
 
 #  define pdf_h_origin                  get_tex_extension_dimen_register(d_pdf_h_origin)
 #  define pdf_v_origin                  get_tex_extension_dimen_register(d_pdf_v_origin)
@@ -208,7 +212,9 @@ extern int pdf_cur_form;
 #  define set_pdf_compress_level(i)     set_tex_extension_count_register(c_pdf_compress_level,i)
 #  define set_pdf_obj_compress_level(i) set_tex_extension_count_register(c_pdf_obj_compress_level,i)
 #  define set_pdf_omit_cidset(i)        set_tex_extension_count_register(c_pdf_omit_cidset,i)
+#  define set_pdf_omit_charset(i)       set_tex_extension_count_register(c_pdf_omit_charset,i)
 #  define set_pdf_gen_tounicode(i)      set_tex_extension_count_register(c_pdf_gen_tounicode,i)
+#  define set_pdf_recompress(i)         set_tex_extension_count_register(c_pdf_recompress,i)
 
 #  define set_pdf_decimal_digits(i)     set_tex_extension_count_register(c_pdf_decimal_digits,i)
 #  define set_pdf_pk_resolution(i)      set_tex_extension_count_register(c_pdf_pk_resolution,i)
diff --git a/texk/web2c/luatexdir/pdf/pdftypes.h b/texk/web2c/luatexdir/pdf/pdftypes.h
index c5f0393cc..ef6a31e16 100644
--- a/texk/web2c/luatexdir/pdf/pdftypes.h
+++ b/texk/web2c/luatexdir/pdf/pdftypes.h
@@ -90,10 +90,7 @@ typedef struct {
 typedef struct scaledpos_ {
     int64_t h;
     int64_t v;
- } scaledpos;
-
-
-
+} scaledpos;
 
 typedef struct scaled_whd_ {
     scaled wd; /* TeX width */
@@ -106,11 +103,11 @@ typedef struct posstructure_ {
     int dir;       /* direction of stuff to be put onto the page */
 } posstructure;
 
-typedef struct {
-    scaledpos curpos;    /* \pdflastpos position */
-    posstructure boxpos; /* box dir and position of the box origin on the page */
-    scaled_whd boxdim;   /* box dimensions (in hlist/vlist coordinate system) */
-} pos_info_structure;
+/* typedef struct {         */
+/*     scaledpos curpos;    */ /* \pdflastpos position */
+/*     posstructure boxpos; */ /* box dir and position of the box origin on the page */
+/*     scaled_whd boxdim;   */ /* box dimensions (in hlist/vlist coordinate system) */
+/* } pos_info_structure;    */
 
 typedef enum {
     PMODE_NONE,
@@ -159,6 +156,10 @@ typedef struct {
     int need_tf;                /* flag whether Tf needs to be set */
     int need_tm;                /* flag whether Tm needs to be set */
     int cur_ex;                 /* the current glyph ex factor */
+    int need_width;
+    int need_mode;
+    int done_width;
+    int done_mode;
 } pdfstructure;
 
 typedef struct obj_entry_ {
@@ -292,9 +293,11 @@ typedef struct pdf_output_file_ {
     int decimal_digits;
     int gen_tounicode;
     int omit_cidset;
+    int omit_charset;
     int inclusion_copy_font;
     int major_version;          /* fixed major part of the PDF version */
     int minor_version;          /* fixed minor part of the PDF version */
+    int recompress;
     int compress_level;         /* level for zlib object stream compression */
     int objcompresslevel;       /* fixed level for activating PDF object streams */
     char *job_id_string;        /* the full job string */
@@ -351,6 +354,8 @@ typedef struct pdf_output_file_ {
     int xform_count;
     int ximage_count;
 
+    int force_file;
+
     pdf_resource_struct *page_resources;
 
     scaledpos page_size;        /* width and height of page being shipped */
diff --git a/texk/web2c/luatexdir/ptexlib.h b/texk/web2c/luatexdir/ptexlib.h
index 21bb9348c..f63f480b0 100644
--- a/texk/web2c/luatexdir/ptexlib.h
+++ b/texk/web2c/luatexdir/ptexlib.h
@@ -153,7 +153,8 @@ size_t          T##_limit
 #  include "tex/expand.h"
 #  include "tex/conditional.h"
 
-#  include "pdf/pdftypes.h" /* the backend data structure, shared between dvi and pdf */
+#  include "pdf/pdftypes.h" /* the backend data structure, shared between dvi and pdf (might move to |tex/backend| */
+#  include "tex/backend.h"  /* more backend data  */
 
 #  include "synctex.h"
 
@@ -254,7 +255,7 @@ int lua_appendtovlist_callback(
     halfword box, int location, halfword prev_depth, boolean is_mirrored,
     halfword * result, int * next_depth, boolean * prev_set);
 
-void lua_pdf_literal(PDF pdf, int i);
+void lua_pdf_literal(PDF pdf, int i, int noline);
 void copy_pdf_literal(pointer r, pointer p);
 void free_pdf_literal(pointer p);
 void show_pdf_literal(pointer p);
@@ -277,7 +278,7 @@ void undump_luac_registers(void);
 void luacstring_start(int n);
 void luacstring_close(int n);
 int luacstring_cattable(void);
-int luacstring_input(void);
+int luacstring_input(halfword *n);
 int luacstring_partial(void);
 int luacstring_final_line(void);
 
@@ -293,6 +294,7 @@ void flush_loggable_info(void);
 
 /* lua/luastuff.w  */
 void luafunctioncall(int slot);
+void luabytecodecall(int slot);
 
 /* lua/luastuff.c */
 void luatokencall(int p, int nameptr);
diff --git a/texk/web2c/luatexdir/tex/commands.h b/texk/web2c/luatexdir/tex/commands.h
index 8eabaa4e7..c3a3ca304 100644
--- a/texk/web2c/luatexdir/tex/commands.h
+++ b/texk/web2c/luatexdir/tex/commands.h
@@ -89,6 +89,7 @@ typedef enum {
     char_num_cmd,                         /* character specified numerically ( \.{\\char} ) */
     math_char_num_cmd,                    /* explicit math code ( \.{\\mathchar} ) */
     mark_cmd,                             /* mark definition ( \.{\\mark} ) */
+    node_cmd,
     xray_cmd,                             /* peek inside of \TeX\ ( \.{\\show}, \.{\\showbox}, etc.~) */
     make_box_cmd,                         /* make a box ( \.{\\box}, \.{\\copy}, \.{\\hbox}, etc.~) */
     hmove_cmd,                            /* horizontal motion ( \.{\\moveleft}, \.{\\moveright} ) */
@@ -134,6 +135,9 @@ typedef enum {
     normal_cmd,                           /* general extensions to \TeX\ that don't fit into a category */
     extension_cmd,                        /* extensions to \TeX\ ( \.{\\write}, \.{\\special}, etc.~) */
     option_cmd,
+    lua_function_call_cmd,
+    lua_bytecode_call_cmd,
+    lua_call_cmd,
     in_stream_cmd,                        /* files for reading ( \.{\\openin}, \.{\\closein} ) */
     begin_group_cmd,                      /* begin local grouping ( \.{\\begingroup} ) */
     end_group_cmd,                        /* end local grouping ( \.{\\endgroup} ) */
@@ -179,7 +183,9 @@ typedef enum {
     set_font_cmd,                         /* set current font ( font identifiers ) */
     def_font_cmd,                         /* define a font file ( \.{\\font} ) */
     register_cmd,                         /* internal register ( \.{\\count}, \.{\\dimen}, etc.~) */
+    assign_box_direction_cmd,             /* (\.{\\boxdirection}) */
     assign_box_dir_cmd,                   /* (\.{\\boxdir}) */
+    assign_direction_cmd,                 /* (\.{\\pagedirection}, \.{\\textdirection}) */
     assign_dir_cmd,                       /* (\.{\\pagedir}, \.{\\textdir}) */
 # define max_internal_cmd assign_dir_cmd  /* the largest code that can follow \.{\\the} */
     advance_cmd,                          /* advance a register or parameter ( \.{\\advance} ) */
@@ -188,6 +194,7 @@ typedef enum {
     prefix_cmd,                           /* qualify a definition ( \.{\\global}, \.{\\long}, \.{\\outer} ) */
     let_cmd,                              /* assign a command code ( \.{\\let}, \.{\\futurelet} ) */
     shorthand_def_cmd,                    /* code definition ( \.{\\chardef}, \.{\\countdef}, etc.~) */
+    def_lua_call_cmd,
     read_to_cs_cmd,                       /* read into a control sequence ( \.{\\read} ) */
     def_cmd,                              /* macro definition ( \.{\\def}, \.{\\gdef}, \.{\\xdef}, \.{\\edef} ) */
     set_box_cmd,                          /* set a box ( \.{\\setbox} ) */
@@ -201,6 +208,8 @@ typedef enum {
     expand_after_cmd,                     /* special expansion ( \.{\\expandafter} ) */
     no_expand_cmd,                        /* special nonexpansion ( \.{\\noexpand} ) */
     input_cmd,                            /* input a source file ( \.{\\input}, \.{\\endinput} or \.{\\scantokens} or \.{\\scantextokens} ) */
+    lua_expandable_call_cmd,
+    lua_local_call_cmd,
     if_test_cmd,                          /* conditional text ( \.{\\if}, \.{\\ifcase}, etc.~) */
     fi_or_else_cmd,                       /* delimiters for conditionals ( \.{\\else}, etc.~) */
     cs_name_cmd,                          /* make a control sequence from tokens ( \.{\\csname} ) */
@@ -236,9 +245,12 @@ typedef enum {
 
 typedef enum {
     number_code = 0,            /* command code for \.{\\number} */
-    lua_function_code,          /* command code for \.{\\luafunction} */
     lua_code,                   /* command code for \.{\\directlua} */
+    lua_function_code,          /* command code for \.{\\luafunction} */
+    lua_bytecode_code,          /* command code for \.{\\luabytecode} */
     expanded_code,              /* command code for \.{\\expanded} */
+    immediate_assignment_code,  /* command code for \.{\\immediateassignment} */
+    immediate_assigned_code,    /* command code for \.{\\assigned} */
     math_style_code,            /* command code for \.{\\mathstyle} */
     string_code,                /* command code for \.{\\string} */
     cs_string_code,             /* command code for \.{\\csstring} */
@@ -324,6 +336,7 @@ typedef enum {
     set_random_seed_code,
     save_pos_code,
     late_lua_code,
+    late_lua_call_code,
     expand_font_code,
 } normal_codes;
 
diff --git a/texk/web2c/luatexdir/tex/conditional.h b/texk/web2c/luatexdir/tex/conditional.h
index b6abe7578..483496eec 100644
--- a/texk/web2c/luatexdir/tex/conditional.h
+++ b/texk/web2c/luatexdir/tex/conditional.h
@@ -24,30 +24,31 @@
 #  define unless_code 32        /* amount added for `\.{\\unless}' prefix */
 
 typedef enum {
-    if_char_code      =  0, /* \.{\\if}          */
-    if_cat_code       =  1, /* \.{\\ifcat}       */
-    if_int_code       =  2, /* \.{\\ifnum}       */
-    if_dim_code       =  3, /* \.{\\ifdim}       */
-    if_odd_code       =  4, /* \.{\\ifodd}       */
-    if_vmode_code     =  5, /* \.{\\ifvmode}     */
-    if_hmode_code     =  6, /* \.{\\ifhmode}     */
-    if_mmode_code     =  7, /* \.{\\ifmmode}     */
-    if_inner_code     =  8, /* \.{\\ifinner}     */
-    if_void_code      =  9, /* \.{\\ifvoid}      */
-    if_hbox_code      = 10, /* \.{\\ifhbox}      */
-    if_vbox_code      = 11, /* \.{\\ifvbox}      */
-    ifx_code          = 12, /* \.{\\ifx}         */
-    if_eof_code       = 13, /* \.{\\ifeof}       */
-    if_true_code      = 14, /* \.{\\iftrue}      */
-    if_false_code     = 15, /* \.{\\iffalse}     */
-    if_case_code      = 16, /* \.{\\ifcase}      */
-    if_def_code       = 17, /* \.{\\ifdefined}   */
-    if_cs_code        = 18, /* \.{\\ifcsname}    */
-    if_font_char_code = 19, /* \.{\\iffontchar}  */
-    if_in_csname_code = 20, /* \.{\\ifincsname}  */
-    if_primitive_code = 21, /* \.{\\ifprimitive} */
-    if_abs_num_code   = 22, /* \.{\\ifabsnum}    */
-    if_abs_dim_code   = 23, /* \.{\\ifabsdim}    */
+    if_char_code       =  0, /* \.{\\if}          */
+    if_cat_code        =  1, /* \.{\\ifcat}       */
+    if_int_code        =  2, /* \.{\\ifnum}       */
+    if_dim_code        =  3, /* \.{\\ifdim}       */
+    if_odd_code        =  4, /* \.{\\ifodd}       */
+    if_vmode_code      =  5, /* \.{\\ifvmode}     */
+    if_hmode_code      =  6, /* \.{\\ifhmode}     */
+    if_mmode_code      =  7, /* \.{\\ifmmode}     */
+    if_inner_code      =  8, /* \.{\\ifinner}     */
+    if_void_code       =  9, /* \.{\\ifvoid}      */
+    if_hbox_code       = 10, /* \.{\\ifhbox}      */
+    if_vbox_code       = 11, /* \.{\\ifvbox}      */
+    if_x_code          = 12, /* \.{\\ifx}         */
+    if_eof_code        = 13, /* \.{\\ifeof}       */
+    if_true_code       = 14, /* \.{\\iftrue}      */
+    if_false_code      = 15, /* \.{\\iffalse}     */
+    if_case_code       = 16, /* \.{\\ifcase}      */
+    if_def_code        = 17, /* \.{\\ifdefined}   */
+    if_cs_code         = 18, /* \.{\\ifcsname}    */
+    if_font_char_code  = 19, /* \.{\\iffontchar}  */
+    if_in_csname_code  = 20, /* \.{\\ifincsname}  */
+    if_primitive_code  = 21, /* \.{\\ifprimitive} */
+    if_abs_num_code    = 22, /* \.{\\ifabsnum}    */
+    if_abs_dim_code    = 23, /* \.{\\ifabsdim}    */
+    if_condition_code  = 24, /* \.{\\ifcondition} */
 } if_type_codes;
 
 #  define if_limit_subtype(A) subtype((A)+1)
diff --git a/texk/web2c/luatexdir/tex/directions.h b/texk/web2c/luatexdir/tex/directions.h
index 7ab524a1e..92d6cc18f 100644
--- a/texk/web2c/luatexdir/tex/directions.h
+++ b/texk/web2c/luatexdir/tex/directions.h
@@ -22,43 +22,19 @@
 #  define DIRECTIONS_H
 
 /*
-    #  define dir_TLT  0
-    #  define dir_TRT  4
-    #  define dir_LTL  9
-    #  define dir_RTT  24
-
-    extern const char *dir_strings[128];
+#define dir_swap 4
 */
 
-extern const char *dir_strings[8];
-
-extern int dir_swap;
-
-/*
-#  define RETURN_DIR_VALUES(a)       \
-    if (s==luaS_##a##_ptr) {         \
-        return (dir_##a);            \
-    } else if (!absolute_only)  {    \
-        if (s==luaS_p##a##_ptr)      \
-            return (dir_##a);        \
-        else if (s==luaS_m##a##_ptr) \
-            return ((dir_##a)-4);    \
-    }
-*/
+#define dir_min_value 0
+#define dir_max_value 3
 
-#  define RETURN_DIR_VALUES(a)    \
-    if (s==lua_key(a)) {          \
-        return (dir_##a);         \
-    } else if (!absolute_only)  { \
-        if (s==lua_key_plus(a))        \
-            return (dir_##a);     \
-        else if (s==lua_key_minus(a))   \
-            return ((dir_##a)-4); \
-    }
+#define check_dir_value(d) \
+    if ((d < dir_min_value) || (d > dir_max_value)) \
+        d = dir_min_value;
 
-#  define is_mirrored(a) 0
+#define is_mirrored(a) 0
 
-#  define is_rotated(a) (a == dir_RTT)
+#define is_rotated(a) (a == dir_RTT)
 
 /*
 
@@ -90,10 +66,12 @@ extern int dir_swap;
         (a == dir_RTT && b == dir_TRT) \
     )
 
+    # define dir_TLT_or_TRT(a) (a == dir_TLT || a == dir_TRT)
+    # define dir_LTL_or_RTT(a) (a == dir_LTL || a == dir_RTT)
+
 */
 
-/* # define dir_TLT_or_TRT(a) (a == dir_TLT || a == dir_TRT) */
-/* # define dir_LTL_or_RTT(a) (a == dir_LTL || a == dir_RTT) */
+/* TLT TRT LTL RTT */
 
 # define dir_TLT_or_TRT(a) (a < 2)
 # define dir_LTL_or_RTT(a) (a > 1)
@@ -174,7 +152,8 @@ extern void initialize_directions(void);
 extern halfword new_dir(int s);
 
 extern const char *string_dir(int d);
-extern void print_dir(int d);
+extern void print_dir_par(int d);
+extern void print_dir_text(halfword d);
 
 extern void scan_direction(void);
 
diff --git a/texk/web2c/luatexdir/tex/equivalents.h b/texk/web2c/luatexdir/tex/equivalents.h
index f478b4a41..3ff9ac16d 100644
--- a/texk/web2c/luatexdir/tex/equivalents.h
+++ b/texk/web2c/luatexdir/tex/equivalents.h
@@ -38,10 +38,10 @@ distinction.
 #  define biggest_reg              65535  /* the largest allowed register number; must be |< max_quarterword| */
 #  define number_regs              65536  /* |biggest_reg+1| */
 #  define number_attrs             65536  /* total numbeer of attributes */
-#  define biggest_char           1114111  /* the largest allowed character number; must be |< max_halfword| */
-#  define too_big_char           1114112  /* |biggest_char+1| */
-#  define special_char           1114113  /* |biggest_char+2| */
-#  define number_chars           1114112  /* |biggest_char+1| */
+#  define biggest_char           1114111  /* 0x10FFFF, the largest allowed character number; must be |< max_halfword| */
+#  define too_big_char   (biggest_char+1) /* 1114112, |biggest_char+1| */
+#  define special_char   (biggest_char+2) /* 1114113, |biggest_char+2| */
+#  define number_chars   (biggest_char+3) /* 1114112, |biggest_char+1| */
 #  define number_fonts (5535-font_base+1)
 #  define biggest_lang             32767
 #  define too_big_lang             32768
@@ -292,15 +292,22 @@ the |number_regs| \.{\\dimen} registers.
 #  define automatic_hyphen_penalty_code 101
 #  define explicit_hyphen_penalty_code 102
 #  define automatic_hyphen_mode_code 103
-#  define break_after_dir_mode_code 104
-
-#  define pre_bin_op_penalty_code 105
-#  define pre_rel_penalty_code 106
-#  define math_penalties_mode_code 107
-#  define math_delimiters_mode_code 108
-#  define math_script_box_mode_code 109
-
-#  define suppress_primitive_error_code 110
+#  define compound_hyphen_mode_code 104
+#  define break_after_dir_mode_code 105
+#  define exception_penalty_code 106
+
+#  define pre_bin_op_penalty_code 107
+#  define pre_rel_penalty_code 108
+#  define math_penalties_mode_code 109
+#  define math_delimiters_mode_code 110
+#  define math_script_box_mode_code 111
+#  define math_script_char_mode_code 112
+#  define math_rule_thickness_mode_code 113
+#  define math_flatten_mode_code 114
+
+#  define copy_lua_input_nodes_code 115
+#  define suppress_primitive_error_code 116
+#  define fixup_boxes_code 117
 
 #  define math_option_code (suppress_primitive_error_code+1)
 
@@ -441,7 +448,8 @@ We use the notation |saved(k)| to stand for an item that appears in location
 #  define saved_boxspec 14
 #  define saved_boxdir 15
 #  define saved_boxattr 16
-#  define saved_boxpack 18
+#  define saved_boxpack 17
+#  define saved_attrlist 18
 #  define saved_eqtb 19
 
 extern void print_save_stack(void);
@@ -453,10 +461,9 @@ extern void print_save_stack(void);
 
 typedef enum {
     c_mathoption_old_code = 0,                  /* this one is stable */
-    c_mathoption_no_italic_compensation_code,   /* just for tracing, can change */
-    c_mathoption_no_char_italic_code,           /* just for tracing, can change */
-    c_mathoption_use_old_fraction_scaling_code, /* just for tracing, can change */
-    c_mathoption_umathcode_meaning_code,        /* this one is stable */
+    /*
+    c_mathoption_umathcode_meaning_code,
+    */
 } math_option_codes ;
 
 #  define mathoption_int_par(A) eqtb[mathoption_int_base+(A)].cint
@@ -525,7 +532,7 @@ typedef enum {
     cramped_script_script_style, /* |subtype| for \.{\\crampedscriptscriptstyle} */
 } math_style_subtypes;
 
-typedef enum {
+typedef enum { /* this could move to directions.h */
     dir_TLT = 0,
     dir_TRT,
     dir_LTL,
@@ -663,6 +670,9 @@ extern halfword last_cs_name;
 #define math_penalties_mode_par            int_par(math_penalties_mode_code)
 #define math_delimiters_mode_par           int_par(math_delimiters_mode_code)
 #define math_script_box_mode_par           int_par(math_script_box_mode_code)
+#define math_script_char_mode_par          int_par(math_script_char_mode_code)
+#define math_rule_thickness_mode_par       int_par(math_rule_thickness_mode_code)
+#define math_flatten_mode_par              int_par(math_flatten_mode_code)
 #define null_delimiter_space_par           dimen_par(null_delimiter_space_code)
 #define disable_lig_par                    int_par(disable_lig_code)
 #define disable_kern_par                   int_par(disable_kern_code)
@@ -757,12 +767,13 @@ extern halfword last_cs_name;
 #define suppress_ifcsname_error_par        int_par(suppress_ifcsname_error_code)
 #define suppress_primitive_error_par       int_par(suppress_primitive_error_code)
 #define error_context_lines_par            int_par(error_context_lines_code)
+#define copy_lua_input_nodes_par           int_par(copy_lua_input_nodes_code)
 
 #define math_old_par                       mathoption_int_par(c_mathoption_old_code)
-#define math_no_italic_compensation_par    mathoption_int_par(c_mathoption_no_italic_compensation_code)
-#define math_no_char_italic_par            mathoption_int_par(c_mathoption_no_char_italic_code)
-#define math_use_old_fraction_scaling_par  mathoption_int_par(c_mathoption_use_old_fraction_scaling_code)
+
+/*
 #define math_umathcode_meaning_par         mathoption_int_par(c_mathoption_umathcode_meaning_code)
+*/
 
 #define math_pre_display_gap_factor_par    int_par(math_pre_display_gap_factor_code)
 
@@ -790,11 +801,15 @@ extern halfword last_cs_name;
 #define automatic_hyphen_penalty_par       int_par(automatic_hyphen_penalty_code)
 #define explicit_hyphen_penalty_par        int_par(explicit_hyphen_penalty_code)
 #define automatic_hyphen_mode_par          int_par(automatic_hyphen_mode_code)
+#define compound_hyphen_mode_par           int_par(compound_hyphen_mode_code)
 #define break_after_dir_mode_par           int_par(break_after_dir_mode_code)
+#define exception_penalty_par              int_par(exception_penalty_code)
 
 #define cur_lang_par                       int_par(cur_lang_code)
 #define cur_font_par                       equiv(cur_font_loc)
 
+#define fixup_boxes_par                    int_par(fixup_boxes_code)
+
 /* */
 
 #define math_use_current_family_code 7
diff --git a/texk/web2c/luatexdir/tex/extensions.h b/texk/web2c/luatexdir/tex/extensions.h
index b68395344..5e22ddf26 100644
--- a/texk/web2c/luatexdir/tex/extensions.h
+++ b/texk/web2c/luatexdir/tex/extensions.h
@@ -136,9 +136,12 @@ typedef enum {
     use_box_resource_code,
     save_image_resource_code,
     use_image_resource_code,
+    end_local_code,
     /* backend */
     dvi_extension_code,
     pdf_extension_code,
 } extension_codes ;
 
+extern void wrapup_leader(halfword p);
+
 #endif
diff --git a/texk/web2c/luatexdir/tex/inputstack.h b/texk/web2c/luatexdir/tex/inputstack.h
index 378fabe24..8c139a833 100644
--- a/texk/web2c/luatexdir/tex/inputstack.h
+++ b/texk/web2c/luatexdir/tex/inputstack.h
@@ -306,6 +306,7 @@ typedef enum {
     mark_text = 14,             /* |token_type| code for \.{\\topmark}, etc. */
     every_eof_text = 15,        /* |token_type| code for \.{\\everyeof} */
     write_text = 16,            /* |token_type| code for \.{\\write} */
+    local_text = 17,            /* |token_type| code for special purposed */
 } token_types;
 
 extern pointer *param_stack;
diff --git a/texk/web2c/luatexdir/tex/linebreak.h b/texk/web2c/luatexdir/tex/linebreak.h
index 1f4927831..d1e1768f7 100644
--- a/texk/web2c/luatexdir/tex/linebreak.h
+++ b/texk/web2c/luatexdir/tex/linebreak.h
@@ -20,9 +20,6 @@
 #ifndef LINEBREAK_H
 #  define LINEBREAK_H
 
-#  define left_side 0
-#  define right_side 1
-
 extern halfword just_box;       /* the |hlist_node| for the last line of the new paragraph */
 
 extern void line_break(boolean d, int line_break_context);
diff --git a/texk/web2c/luatexdir/tex/mainbody.h b/texk/web2c/luatexdir/tex/mainbody.h
index 4a5cb93a1..245535120 100644
--- a/texk/web2c/luatexdir/tex/mainbody.h
+++ b/texk/web2c/luatexdir/tex/mainbody.h
@@ -139,6 +139,9 @@ extern int filelineerrorstylep;
 extern int haltonerrorp;
 extern boolean quoted_filename;
 
+extern int total_pages;
+extern int dead_cycles;
+
 /*
 In order to make efficient use of storage space, \TeX\ bases its major data
 structures on a |memory_word|, which contains either a (signed) integer,
diff --git a/texk/web2c/luatexdir/tex/maincontrol.h b/texk/web2c/luatexdir/tex/maincontrol.h
index 13e3c6ff3..04608c11e 100644
--- a/texk/web2c/luatexdir/tex/maincontrol.h
+++ b/texk/web2c/luatexdir/tex/maincontrol.h
@@ -151,6 +151,7 @@ extern void do_endv(void);
 extern void cs_error(void);
 extern void prefixed_command(void);
 extern void fixup_directions(void);
+extern void fixup_directions_only(void);
 
 
 /* Assignments from Lua need helpers. */
@@ -205,5 +206,12 @@ extern void show_whatever(void);
 
 extern void initialize(void);   /* this procedure gets things started properly */
 
+/*extern int local_level;*/
+
+extern void local_control(void);
+extern halfword local_scan_box(void);
+extern int current_local_level(void);
+extern void end_local_control(void);
+extern void local_control_message(const char *s);
 
 #endif
diff --git a/texk/web2c/luatexdir/tex/mlist.h b/texk/web2c/luatexdir/tex/mlist.h
index bd1562122..1a15afe3c 100644
--- a/texk/web2c/luatexdir/tex/mlist.h
+++ b/texk/web2c/luatexdir/tex/mlist.h
@@ -31,5 +31,6 @@ extern void fixup_math_parameters(int fam_id, int size_id, int f, int lvl);
 extern scaled get_math_quad_style(int a);
 extern scaled get_math_quad_size(int a);
 
+extern pointer make_extensible(internal_font_number fnt, halfword chr, scaled v, scaled min_overlap, int horizontal, halfword att);
 
 #endif
diff --git a/texk/web2c/luatexdir/tex/packaging.h b/texk/web2c/luatexdir/tex/packaging.h
index 6a0802e46..9353afeaf 100644
--- a/texk/web2c/luatexdir/tex/packaging.h
+++ b/texk/web2c/luatexdir/tex/packaging.h
@@ -143,7 +143,8 @@ latter two are used denote \.{\\vbox} and \.{\\hbox}, respectively.
 #  define global_box_flag     (box_flag+number_regs)        /* context code for `\.{\\global\\setbox0}' */
 #  define max_global_box_flag (global_box_flag+number_regs)
 #  define ship_out_flag       (max_global_box_flag+1)       /* context code for `\.{\\shipout}' */
-#  define leader_flag         ship_out_flag+1               /* context code for `\.{\\leaders}' */
+#  define lua_scan_flag       (max_global_box_flag+2)       /* context code for |scan_list| */
+#  define leader_flag         (max_global_box_flag+3)       /* context code for `\.{\\leaders}' */
 
 extern void begin_box(int box_context);
 
diff --git a/texk/web2c/luatexdir/tex/printing.h b/texk/web2c/luatexdir/tex/printing.h
index 1619c6072..79ca524ef 100644
--- a/texk/web2c/luatexdir/tex/printing.h
+++ b/texk/web2c/luatexdir/tex/printing.h
@@ -77,7 +77,7 @@ extern void print_esc(str_number s);
 extern void print_the_digs(eight_bits k);
 extern void print_int(longinteger n);
 extern void print_two(int n);
-extern void print_hex(int n);
+extern void print_qhex(int n);
 extern void print_roman_int(int n);
 extern void print_current_string(void);
 
diff --git a/texk/web2c/luatexdir/tex/scanning.h b/texk/web2c/luatexdir/tex/scanning.h
index f5f620c67..e4189a0f6 100644
--- a/texk/web2c/luatexdir/tex/scanning.h
+++ b/texk/web2c/luatexdir/tex/scanning.h
@@ -63,9 +63,13 @@ extern void scan_fifty_one_bit_int(void);
 #  define hex_token (other_token+'"')               /* double quote, indicates a hex constant */
 #  define alpha_token (other_token+'`')             /* reverse apostrophe, precedes alpha constants */
 #  define point_token (other_token+'.')             /* decimal point */
+#  define comma_token (other_token+',')             /* decimal comma */
+#  define plus_token (other_token + '+')
+#  define minus_token (other_token + '-')
 #  define continental_point_token (other_token+',') /* decimal point, Eurostyle */
 #  define infinity 017777777777                     /* the largest positive value that \TeX\ knows */
 #  define zero_token (other_token+'0')              /* zero, the smallest digit */
+#  define nine_token (other_token+'9')              /* zero, the smallest digit */
 #  define A_token (letter_token+'A')                /* the smallest special hex digit */
 #  define other_A_token (other_token+'A')           /* special hex digit of type |other_char| */
 extern int radix;
@@ -78,7 +82,6 @@ extern int cur_order;
 
 extern void scan_dimen(boolean mu, boolean inf, boolean shortcut);
 extern void scan_glue(int level);
-extern void scan_scaled(void);
 
 extern halfword the_toks(void);
 extern str_number the_scanned_result(void);
diff --git a/texk/web2c/luatexdir/tex/stringpool.h b/texk/web2c/luatexdir/tex/stringpool.h
index a969547e7..2ba156046 100644
--- a/texk/web2c/luatexdir/tex/stringpool.h
+++ b/texk/web2c/luatexdir/tex/stringpool.h
@@ -1,5 +1,5 @@
 /* stringpool.h
-   
+
    Copyright 2009 Taco Hoekwater <taco@luatex.org>
 
    This file is part of LuaTeX.
@@ -43,9 +43,10 @@ extern str_number init_str_ptr;
 
 #  define get_nullstr() STRING_OFFSET
 
-#  define biggest_char 1114111
-#  define number_chars 1114112
-#  define special_char 1114113  /* |biggest_char+2| */
+#  define biggest_char           1114111  /* 0x10FFFF, the largest allowed character number; must be |< max_halfword| */
+#  define too_big_char   (biggest_char+1) /* 1114112, |biggest_char+1| */
+#  define special_char   (biggest_char+2) /* 1114113, |biggest_char+2| */
+#  define number_chars   (biggest_char+3) /* 1114112, |biggest_char+1| */
 
 /*
   Several of the elementary string operations are performed using
diff --git a/texk/web2c/luatexdir/tex/texmath.h b/texk/web2c/luatexdir/tex/texmath.h
index 24bb34dc9..23fc5a0e4 100644
--- a/texk/web2c/luatexdir/tex/texmath.h
+++ b/texk/web2c/luatexdir/tex/texmath.h
@@ -38,22 +38,6 @@ extern halfword new_sub_box(halfword);
 
 #  define default_code 010000000000     /* denotes |default_rule_thickness| */
 
-typedef enum {
-    ord_noad_type = 0,
-    op_noad_type_normal,
-    op_noad_type_limits,
-    op_noad_type_no_limits,
-    bin_noad_type,
-    rel_noad_type,
-    open_noad_type,
-    close_noad_type,
-    punct_noad_type,
-    inner_noad_type,
-    under_noad_type,
-    over_noad_type,
-    vcenter_noad_type,
-} noad_types;
-
 extern void initialize_math(void);
 extern void initialize_math_spacing(void);
 extern halfword math_vcenter_group(halfword);
diff --git a/texk/web2c/luatexdir/tex/texnodes.h b/texk/web2c/luatexdir/tex/texnodes.h
index eb9b2da4a..e77e2916e 100644
--- a/texk/web2c/luatexdir/tex/texnodes.h
+++ b/texk/web2c/luatexdir/tex/texnodes.h
@@ -97,8 +97,30 @@ extern halfword do_set_attribute(halfword p, int i, int val);
 #  define list_offset 6
 
 typedef enum {
+    user_skip_glue,
+    line_skip_glue,
+    baseline_skip_glue,
+    par_skip_glue,
+    above_display_skip_glue,
+    below_display_skip_glue,
+    above_display_short_skip_glue,
+    below_display_short_skip_glue,
+    left_skip_glue,
+    right_skip_glue,
+    top_skip_glue,
+    split_top_skip_glue,
+    tab_skip_glue,
+    space_skip_glue,
+    xspace_skip_glue,
+    par_fill_skip_glue,
+    math_skip_glue,
+    thin_mu_skip_glue,
+    med_mu_skip_glue,
+    thick_mu_skip_glue,
+    /* math */
     cond_math_glue = 98,        /* special |subtype| to suppress glue in the next node */
     mu_glue,                    /* |subtype| for math glue */
+    /* leaders */
     a_leaders,                  /* |subtype| for aligned leaders */
     c_leaders,                  /* |subtype| for centered leaders */
     x_leaders,                  /* |subtype| for expanded leaders */
@@ -199,7 +221,7 @@ typedef enum {
 #  define disc_penalty(a)     vlink((a)+2)
 #  define pre_break(a)        vinfo((a)+3)
 #  define post_break(a)       vlink((a)+3)
-#  define no_break(a)         vlink((a)+4)
+#  define no_break(a)         vlink((a)+4) /* we have vinfo((a)+4) for later usage */
 
 #  define vlink_pre_break(a)  vlink(pre_break_head(a))
 #  define vlink_post_break(a) vlink(post_break_head(a))
@@ -264,14 +286,17 @@ typedef enum {
     math_under_rule,
     math_fraction_rule,
     math_radical_rule,
+    outline_rule,
 } rule_subtypes;
 
-#  define rule_node_size       8
+#  define rule_node_size       9
 #  define rule_dir(a)          vlink((a)+5)
 #  define rule_index(a)        vinfo((a)+6)
 #  define rule_transform(a)    vlink((a)+6)
-#  define synctex_tag_rule(a)  vinfo((a)+7)
-#  define synctex_line_rule(a) vlink((a)+7)
+#  define rule_left(a)         vinfo((a)+7)
+#  define rule_right(a)        vlink((a)+7)
+#  define synctex_tag_rule(a)  vinfo((a)+8)
+#  define synctex_line_rule(a) vlink((a)+8)
 
 #  define rule_math_size       rule_index
 #  define rule_math_font       rule_transform
@@ -292,7 +317,7 @@ typedef enum {
 #  define x_displace(a)         vinfo((a)+4)
 #  define y_displace(a)         vlink((a)+4)
 #  define ex_glyph(a)           vinfo((a)+5)  /* expansion factor (hz) */
-#  define x_advance(a)          vlink((a)+5)  /* obsolete, can become user field */
+#  define glyph_node_data(a)    vlink((a)+5)
 #  define synctex_tag_glyph(a)  vinfo((a)+6)
 #  define synctex_line_glyph(a) vlink((a)+6)
 
@@ -318,11 +343,15 @@ typedef enum {
 
 /*@# {|subtype| of marginal kerns}*/
 
-#  define left_side  0
-#  define right_side 1
+typedef enum {
+    left_side = 0,
+    right_side
+} margin_kern_subtypes ;
 
-#  define before     0 /* |subtype| for math node that introduces a formula */
-#  define after      1 /* |subtype| for math node that winds up a formula */
+typedef enum {
+    before = 0,
+    after
+} math_subtypes ;
 
 #  define math_node_size       7
 /* define width(a)             vinfo((a)+2) */
@@ -487,6 +516,24 @@ typedef enum {
 #  define noadextra3(a)  vlink((a)+7) /* see (!) below */
 #  define noadextra4(a)  vinfo((a)+7) /* used to store samesize */
 
+#  define noad_fam(a)    vlink((a)+6) /* noadextra1 */
+
+typedef enum {
+    ord_noad_type = 0,
+    op_noad_type_normal,
+    op_noad_type_limits,
+    op_noad_type_no_limits,
+    bin_noad_type,
+    rel_noad_type,
+    open_noad_type,
+    close_noad_type,
+    punct_noad_type,
+    inner_noad_type,
+    under_noad_type,
+    over_noad_type,
+    vcenter_noad_type,
+} noad_types;
+
 /* accent noads */
 
 #  define accent_noad_size      8
@@ -495,6 +542,13 @@ typedef enum {
 #  define overlay_accent_chr(a) vinfo((a)+7) /* the |overlay_accent_chr| field of an accent noad */
 #  define accentfraction(a)     vlink((a)+7)
 
+typedef enum {
+    bothflexible_accent,
+    fixedtop_accent,
+    fixedbottom_accent,
+    fixedboth_accent,
+} math_accent_subtypes ;
+
 /* left and right noads */
 
 #  define fence_noad_size      8            /* needs to match noad size */
@@ -540,22 +594,36 @@ typedef enum {
     noad_delimiter_mode_noshift = 0x01,
     noad_delimiter_mode_italics = 0x02,
     noad_delimiter_mode_ordinal = 0x04,
+    noad_delimiter_mode_samenos = 0x08,
+    noad_delimiter_mode_charnos = 0x10,
 } delimiter_modes ;
 
 #  define delimitermodenoshift ((math_delimiters_mode_par & noad_delimiter_mode_noshift) == noad_delimiter_mode_noshift)
 #  define delimitermodeitalics ((math_delimiters_mode_par & noad_delimiter_mode_italics) == noad_delimiter_mode_italics)
 #  define delimitermodeordinal ((math_delimiters_mode_par & noad_delimiter_mode_ordinal) == noad_delimiter_mode_ordinal)
+#  define delimitermodesamenos ((math_delimiters_mode_par & noad_delimiter_mode_samenos) == noad_delimiter_mode_samenos)
+#  define delimitermodecharnos ((math_delimiters_mode_par & noad_delimiter_mode_charnos) == noad_delimiter_mode_charnos)
 
 /* subtype of fence noads */
 
+/*
 #  define left_noad_side   1
 #  define middle_noad_side 2
 #  define right_noad_side  3
 #  define no_noad_side     4
+*/
+
+typedef enum {
+    unset_noad_side  = 0,
+    left_noad_side   = 1,
+    middle_noad_side = 2,
+    right_noad_side  = 3,
+    no_noad_side     = 4,
+} fence_subtypes ;
 
 /* fraction noads */
 
-#  define fraction_noad_size  7
+#  define fraction_noad_size  8
 #  define thickness(a)        vlink((a)+2) /* |thickness| field in a fraction noad */
 #  define numerator(a)        vlink((a)+3) /* |numerator| field in a fraction noad */
 #  define denominator(a)      vinfo((a)+3) /* |denominator| field in a fraction noad */
@@ -563,6 +631,7 @@ typedef enum {
 #  define right_delimiter(a)  vinfo((a)+5) /* second delimiter field of a fraction noad */
 #  define middle_delimiter(a) vlink((a)+6)
 #  define fractionoptions(a)  vinfo((a)+6)
+#  define fraction_fam(a)     vlink((a)+7)
 
 #  define fractionoptionset(a) ((fractionoptions(a) & noad_option_set    ) == noad_option_set    )
 #  define fractionexact(a)     ((fractionoptions(a) & noad_option_exact  ) == noad_option_exact  )
@@ -582,6 +651,16 @@ typedef enum {
 #  define radicalmiddle(a)    ((radicaloptions(a) & noad_option_middle) == noad_option_middle)
 #  define radicalright(a)     ((radicaloptions(a) & noad_option_right ) == noad_option_right)
 
+typedef enum {
+    radical_noad_type,
+    uradical_noad_type,
+    uroot_noad_type,
+    uunderdelimiter_noad_type,
+    uoverdelimiter_noad_type,
+    udelimiterunder_noad_type,
+    udelimiterover_noad_type,
+} radical_subtypes;
+
 /* accessors for the |nucleus|-style node fields */
 
 #  define math_kernel_node_size 3
@@ -659,6 +738,15 @@ typedef enum {
 #  define GLYPH_LEFT          (1 << 3)
 #  define GLYPH_RIGHT         (1 << 4)
 
+typedef enum {
+    glyph_unset     = 0,
+    glyph_character = GLYPH_CHARACTER,
+    glyph_ligature  = GLYPH_LIGATURE,
+    glyph_ghost     = GLYPH_GHOST,
+    glyph_left      = GLYPH_LEFT,
+    glyph_right     = GLYPH_RIGHT,
+} glyph_subtypes;
+
 #  define is_character(p)        ((subtype(p)) & GLYPH_CHARACTER)
 #  define is_ligature(p)         ((subtype(p)) & GLYPH_LIGATURE )
 #  define is_ghost(p)            ((subtype(p)) & GLYPH_GHOST    )
@@ -698,6 +786,11 @@ typedef enum {
 
 #  define special_node_size 3
 
+typedef enum {
+    normal_dir = 0,
+    cancel_dir,
+} dir_subtypes ;
+
 #  define dir_node_size 5
 #  define dir_dir(a)       vinfo((a)+2)
 #  define dir_level(a)     vlink((a)+2)
@@ -737,6 +830,7 @@ typedef enum {
 /* type of literal data */
 
 #  define lua_refid_literal 1 /* not a |normal| string */
+#  define lua_refid_call    2 /* not a |normal| string */
 
 /* begin of pdf backend nodes */
 
@@ -899,40 +993,60 @@ extern void print_short_node_contents(halfword n);
 extern void show_node_list(int i);
 extern pointer actual_box_width(pointer r, scaled base_width);
 
-/* from luanode.c */
+typedef struct _subtype_info {
+    int id;
+    const char *name;
+    int lua;
+} subtype_info;
+
+typedef struct _field_info {
+    const char *name;
+    int lua;
+} field_info;
 
 typedef struct _node_info {
     int id;
     int size;
-    const char **fields;
+    subtype_info *subtypes;
+    field_info *fields;
     const char *name;
     int etex;
+    int lua;
 } node_info;
 
 extern node_info node_data[];
 extern node_info whatsit_node_data[];
 
-extern const char *node_subtypes_glue[];
-extern const char *node_subtypes_mathglue[];
-extern const char *node_subtypes_leader[];
-extern const char *node_subtypes_fill[];
-extern const char *node_subtypes_boundary[];
-extern const char *node_subtypes_penalty[];
-extern const char *node_subtypes_kern[];
-extern const char *node_subtypes_rule[];
-extern const char *node_subtypes_glyph[];
-extern const char *node_subtypes_disc[];
-extern const char *node_subtypes_marginkern[];
-extern const char *node_subtypes_list[];
-extern const char *node_subtypes_adjust[];
-extern const char *node_subtypes_math[];
-extern const char *node_subtypes_noad[];
-extern const char *node_subtypes_radical[];
-extern const char *node_subtypes_accent[];
-extern const char *node_subtypes_fence[];
-
-extern const char *node_subtypes_pdf_destination[];
-extern const char *node_subtypes_pdf_literal[];
+extern subtype_info node_subtypes_dir[];
+extern subtype_info node_subtypes_glue[];
+extern subtype_info node_subtypes_mathglue[];
+extern subtype_info node_subtypes_leader[];
+extern subtype_info node_subtypes_boundary[];
+extern subtype_info node_subtypes_penalty[];
+extern subtype_info node_subtypes_kern[];
+extern subtype_info node_subtypes_rule[];
+extern subtype_info node_subtypes_glyph[];
+extern subtype_info node_subtypes_disc[];
+extern subtype_info node_subtypes_marginkern[];
+extern subtype_info node_subtypes_list[];
+extern subtype_info node_subtypes_adjust[];
+extern subtype_info node_subtypes_math[];
+extern subtype_info node_subtypes_noad[];
+extern subtype_info node_subtypes_radical[];
+extern subtype_info node_subtypes_accent[];
+extern subtype_info node_subtypes_fence[];
+
+extern subtype_info node_values_pdf_destination[];
+extern subtype_info node_values_pdf_literal[];
+extern subtype_info node_values_pdf_literal[];
+extern subtype_info node_values_pdf_action[];
+extern subtype_info node_values_pdf_window[];
+
+extern subtype_info node_values_fill[];
+extern subtype_info node_values_dir[];
+extern subtype_info node_values_color_stack[];
+
+extern subtype_info other_values_page_states[];
 
 extern halfword new_node(int i, int j);
 extern void flush_node_list(halfword);
@@ -958,7 +1072,7 @@ extern void show_node_wrapup_dvi(halfword);
 extern void show_node_wrapup_pdf(halfword);
 
 typedef enum {
-    normal_g = 0,
+    normal_g = 0, /* normal */
     sfi,
     fil,
     fill,
@@ -1037,5 +1151,8 @@ extern void synctex_set_no_files(int flag);
 extern int synctex_get_no_files(void);
 extern int synctex_get_line(void);
 
+extern void l_set_node_data(void) ;
+extern void l_set_whatsit_data(void) ;
+
 #endif
 
diff --git a/texk/web2c/luatexdir/tex/textoken.h b/texk/web2c/luatexdir/tex/textoken.h
index 4f46a48c8..4b33b099a 100644
--- a/texk/web2c/luatexdir/tex/textoken.h
+++ b/texk/web2c/luatexdir/tex/textoken.h
@@ -25,19 +25,19 @@
 #  define null 0
 #  define cs_token_flag 0x1FFFFFFF
 
-#  define left_brace_token 0x200000     /* $2^{21}\cdot|left_brace|$ */
-#  define right_brace_token 0x400000    /* $2^{21}\cdot|right_brace|$ */
-#  define left_brace_limit 0x400000     /* $2^{21}\cdot(|left_brace|+1)$ */
-#  define right_brace_limit 0x600000    /* $2^{21}\cdot(|right_brace|+1)$ */
-#  define math_shift_token 0x600000     /* $2^{21}\cdot|math_shift|$ */
-#  define tab_token 0x800000    /* $2^{21}\cdot|tab_mark|$ */
-#  define out_param_token 0xA00000      /* $2^{21}\cdot|out_param|$ */
-#  define space_token 0x1400020 /* $2^{21}\cdot|spacer|+|" "|$ */
-#  define letter_token 0x1600000        /* $2^{21}\cdot|letter|$ */
-#  define other_token 0x1800000 /* $2^{21}\cdot|other_char|$ */
-#  define match_token 0x1A00000 /* $2^{21}\cdot|match|$ */
-#  define end_match_token 0x1C00000     /* $2^{21}\cdot|end_match|$ */
-#  define protected_token 0x1C00001     /* $2^{21}\cdot|end_match|+1$ */
+#  define left_brace_token  0x0200000  /* $2^{21}\cdot|left_brace|$ */
+#  define right_brace_token 0x0400000  /* $2^{21}\cdot|right_brace|$ */
+#  define left_brace_limit  0x0400000  /* $2^{21}\cdot(|left_brace|+1)$ */
+#  define right_brace_limit 0x0600000  /* $2^{21}\cdot(|right_brace|+1)$ */
+#  define math_shift_token  0x0600000  /* $2^{21}\cdot|math_shift|$ */
+#  define tab_token         0x0800000  /* $2^{21}\cdot|tab_mark|$ */
+#  define out_param_token   0x0A00000  /* $2^{21}\cdot|out_param|$ */
+#  define space_token       0x1400020  /* $2^{21}\cdot|spacer|+|" "|$ */
+#  define letter_token      0x1600000  /* $2^{21}\cdot|letter|$ */
+#  define other_token       0x1800000  /* $2^{21}\cdot|other_char|$ */
+#  define match_token       0x1A00000  /* $2^{21}\cdot|match|$ */
+#  define end_match_token   0x1C00000  /* $2^{21}\cdot|end_match|$ */
+#  define protected_token   0x1C00001  /* $2^{21}\cdot|end_match|+1$ */
 
 #  include "tex/stringpool.h"
 
@@ -126,6 +126,7 @@ extern void make_token_table(lua_State * L, int cmd, int chr, int cs);
 extern void get_next(void);
 extern void check_outer_validity(void);
 extern boolean scan_keyword(const char *);
+extern boolean scan_keyword_case_sensitive(const char *);
 extern halfword active_to_cs(int, int);
 extern void get_token_lua(void);
 halfword string_to_toks(const char *);
@@ -183,4 +184,6 @@ extern void free_lstring(lstring * ls);
 #  define token_chr(A) ((A) & (STRING_OFFSET - 1))
 #  define token_val(A,B) (((A)<<STRING_OFFSET_BITS)+(B))
 
+extern void l_set_token_data(void) ;
+
 #endif
diff --git a/texk/web2c/luatexdir/unilib/gwwiconv.c b/texk/web2c/luatexdir/unilib/gwwiconv.c
index 3671116cf..57db98fc7 100644
--- a/texk/web2c/luatexdir/unilib/gwwiconv.c
+++ b/texk/web2c/luatexdir/unilib/gwwiconv.c
@@ -46,7 +46,8 @@ struct gww_iconv_t {
     enum encoding to;
 };
 
-enum extended_encoding { e_jisgbpk = e_encodingmax };
+/*enum extended_encoding { e_jisgbpk = e_encodingmax };*/
+#define e_jisgbpk e_encodingmax 
 
 static enum endian { end_big, end_little, end_unknown } endian = end_unknown;
 
diff --git a/texk/web2c/mplibdir/ChangeLog b/texk/web2c/mplibdir/ChangeLog
index 9f69e0665..e2c7244eb 100644
--- a/texk/web2c/mplibdir/ChangeLog
+++ b/texk/web2c/mplibdir/ChangeLog
@@ -1,3 +1,7 @@
+2018-08-27  Luigi Scarso  <luigi.scarso@gmail.com>
+	* separation of mpmathbinary from the the core
+
+
 2018-02-19  Luigi Scarso  <luigi.scarso@gmail.com>
 	* Small cleanup of the code
 	* Bump to version 2.0rc2: the current version is 2.00
diff --git a/texk/web2c/mplibdir/am/libmplib.am b/texk/web2c/mplibdir/am/libmplib.am
index 3d5723119..a4be39e68 100644
--- a/texk/web2c/mplibdir/am/libmplib.am
+++ b/texk/web2c/mplibdir/am/libmplib.am
@@ -5,15 +5,18 @@
 
 ## libmplib.a, used by MetaPost and luaTeX
 ##
-EXTRA_LIBRARIES += libmplibcore.a libmplibbackends.a 
+EXTRA_LIBRARIES += libmplibcore.a libmplibextramath.a libmplibbackends.a 
 
-libmplibcore_a_CPPFLAGS = $(MPFR_INCLUDES) $(GMP_INCLUDES) $(LIBPNG_INCLUDES) $(ZLIB_INCLUDES) $(AM_CPPFLAGS) -I$(srcdir)/mplibdir
+
+libmplibcore_a_CPPFLAGS =  $(LIBPNG_INCLUDES) $(ZLIB_INCLUDES) $(AM_CPPFLAGS) -I$(srcdir)/mplibdir
+libmplibextramath_a_CPPFLAGS = $(MPFR_INCLUDES) $(GMP_INCLUDES) -I${top_builddir}/../../libs   $(AM_CPPFLAGS) -I$(srcdir)/mplibdir
 libmplibbackends_a_CPPFLAGS = $(MPFR_INCLUDES) $(GMP_INCLUDES) $(CAIRO_INCLUDES) $(PIXMAN_INCLUDES) \
 	$(LIBPNG_INCLUDES) $(ZLIB_INCLUDES) $(AM_CPPFLAGS) -I$(srcdir)/mplibdir
 
-## libmplib C sources core + backends
-nodist_libmplibcore_a_SOURCES = tfmin.c $(mp_c_h) $(mpmath_c_h) $(mpmathbinary_c_h) $(mpmathdecimal_c_h) \
+## libmplib C sources core + extramath + backends
+nodist_libmplibcore_a_SOURCES = tfmin.c $(mp_c_h) $(mpmath_c_h) $(mpmathdecimal_c_h) \
 	$(mpmathdouble_c_h) $(mpstrings_c_h) $(psout_c_h) 
+nodist_libmplibextramath_a_SOURCES = $(mpmathbinary_c_h)
 nodist_libmplibbackends_a_SOURCES = $(pngout_c_h)  $(svgout_c_h)
 
 
@@ -84,15 +87,16 @@ libmplib_web += mplibdir/mpmath.w mplibdir/mpmathbinary.w mplibdir/mpmathdecimal
 libmplib_web += mplibdir/mpmathdouble.w mplibdir/mpstrings.w mplibdir/tfmin.w
 
 ## core need headers backends
-$(nodist_libmplibcore_a_SOURCES): $(svgout_c_h) $(pngout_c_h)
+$(nodist_libmplibcore_a_SOURCES): $(mpmathbinary_c_h) $(svgout_c_h) $(pngout_c_h)
 
-$(libmplibcore_a_OBJECTS): $(nodist_libmplibcore_a_SOURCES) $(KPATHSEA_DEPEND)  $(MPFR_DEPEND)
+$(libmplibcore_a_OBJECTS): $(nodist_libmplibcore_a_SOURCES) $(KPATHSEA_DEPEND)  
+$(libmplibextramath_a_OBJECTS): $(nodist_libmplibextramath_a_SOURCES) $(KPATHSEA_DEPEND)  $(MPFR_DEPEND)
 $(libmplibbackends_a_OBJECTS): $(nodist_libmplibbackends_a_SOURCES) $(KPATHSEA_DEPEND) $(CAIRO_DEPEND) $(MPFR_DEPEND)
 
 
 EXTRA_DIST += $(libmplib_web)
 
-DISTCLEANFILES += $(nodist_libmplibcore_a_SOURCES) $(nodist_libmplibbackends_a_SOURCES)	\
-	mp-tangle mpmath-tangle mpmathbinary-tangle mpmathdecimal-tangle mpmathdouble-tangle \
+DISTCLEANFILES += $(nodist_libmplibcore_a_SOURCES) $(nodist_libmplibextramath_a_SOURCES) $(nodist_libmplibbackends_a_SOURCES) \
+	mp-tangle mpmath-tangle mpmathdecimal-tangle mpmathdouble-tangle \
 	mpstrings-tangle psout-tangle svgout-tangle pngout-tangle
 
diff --git a/texk/web2c/mplibdir/am/mplib.am b/texk/web2c/mplibdir/am/mplib.am
index f58658de1..10b1fe4aa 100644
--- a/texk/web2c/mplibdir/am/mplib.am
+++ b/texk/web2c/mplibdir/am/mplib.am
@@ -18,9 +18,7 @@ endif MP
 EXTRA_PROGRAMS += mpost
 
 mpost_CPPFLAGS = $(AM_CPPFLAGS) $(ZLIB_INCLUDES) $(LIBPNG_INCLUDES) -I$(srcdir)/mplibdir
-#mpost_LDADD = libmplib.a $(KPATHSEA_LIBS) $(MPFR_LIBS) $(GMP_LIBS) \
-#	$(CAIRO_LIBS) $(PIXMAN_LIBS) $(LIBPNG_LIBS) $(ZLIB_LIBS) libmputil.a
-mpost_LDADD = libmplibcore.a libmplibbackends.a  $(KPATHSEA_LIBS) $(MPFR_LIBS) $(GMP_LIBS) \
+mpost_LDADD = libmplibcore.a libmplibextramath.a libmplibbackends.a  $(KPATHSEA_LIBS) $(MPFR_LIBS) $(GMP_LIBS) \
 	$(CAIRO_LIBS) $(PIXMAN_LIBS) $(LIBPNG_LIBS) $(ZLIB_LIBS) libmputil.a
 
 
@@ -60,7 +58,7 @@ mpxout-tangle: ctangle$(EXEEXT) mplibdir/mpxout.w tangle-sh
 mpost_web = mplibdir/mpost.w mplibdir/mpxout.w
 
 #$(mpost_OBJECTS): $(nodist_mpost_SOURCES) libmplib.a $(LIBPNG_DEPEND)
-$(mpost_OBJECTS): $(nodist_mpost_SOURCES) libmplibcore.a libmplibbackends.a $(LIBPNG_DEPEND)
+$(mpost_OBJECTS): $(nodist_mpost_SOURCES) libmplibcore.a libmplibextramath.a libmplibbackends.a $(LIBPNG_DEPEND)
 
 EXTRA_DIST += mplibdir/ChangeLog $(mpost_web)
 
diff --git a/texk/web2c/mplibdir/lmplib.c b/texk/web2c/mplibdir/lmplib.c
index d90482b88..eb8432bb5 100644
--- a/texk/web2c/mplibdir/lmplib.c
+++ b/texk/web2c/mplibdir/lmplib.c
@@ -15,7 +15,9 @@
    License for more details.
 
    You should have received a copy of the GNU Lesser General Public License along
-   with LuaTeX; if not, see <http://www.gnu.org/licenses/>. */
+   with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+
+*/
 
 #include <w2c/config.h>
 #include <stdlib.h>
@@ -23,7 +25,7 @@
 #ifdef HAVE_UNISTD_H
 #include <unistd.h>
 #endif
-#include <math.h> /* temporary */
+#include <math.h>
 
 #ifndef pdfTeX
 #  include <lua.h>
@@ -41,20 +43,23 @@
 #define luaL_reg luaL_Reg
 #endif
 
-
 #ifndef lua_objlen
 #define lua_objlen lua_rawlen
 #endif
 
-
 #include "mplib.h"
 #include "mplibps.h"
 #include "mplibsvg.h"
 #include "mplibpng.h"
 
-int luaopen_mplib(lua_State * L); /* forward */
+int luaopen_mplib(lua_State * L);
 
-/* metatable identifiers and tests */
+/*tex
+
+    We need a few metatable identifiers in order to access the metatables for the
+    main object and result userdata.
+
+*/
 
 #define MPLIB_METATABLE     "MPlib.meta"
 #define MPLIB_FIG_METATABLE "MPlib.fig"
@@ -64,25 +69,33 @@ int luaopen_mplib(lua_State * L); /* forward */
 #define is_fig(L,b) (struct mp_edge_object **)luaL_checkudata(L,b,MPLIB_FIG_METATABLE)
 #define is_gr_object(L,b) (struct mp_graphic_object **)luaL_checkudata(L,b,MPLIB_GR_METATABLE)
 
-/* Lua string pre-hashing */
+/*tex
 
-#define mplib_init_S(a) do {                                            \
-    lua_pushliteral(L,#a);                                              \
-    mplib_##a##_ptr = lua_tostring(L,-1);				\
-    mplib_##a##_index = luaL_ref (L,LUA_REGISTRYINDEX);                 \
-  } while (0)
+    We pre-hash the \LUA\ strings which is much faster. The approach is similar to the one
+    used at the \TEX\ end.
 
-#define mplib_push_S(a) do {                                    \
-    lua_rawgeti(L,LUA_REGISTRYINDEX,mplib_##a##_index);         \
-  } while (0)
+*/
+
+#define mplib_init_S(a) do {                            \
+    lua_pushliteral(L,#a);                              \
+    mplib_##a##_ptr = lua_tostring(L,-1);               \
+    mplib_##a##_index = luaL_ref (L,LUA_REGISTRYINDEX); \
+} while (0)
+
+#define mplib_push_S(a) do {                            \
+    lua_rawgeti(L,LUA_REGISTRYINDEX,mplib_##a##_index); \
+} while (0)
 
-#define mplib_is_S(a,i) (mplib_##a##_ptr==lua_tostring(L,i))
+#define mplib_is_S(a,i) \
+    (mplib_##a##_ptr==lua_tostring(L,i))
 
-#define mplib_make_S(a)                                                 \
-  static int mplib_##a##_index = 0;                                     \
-  static const char *mplib_##a##_ptr = NULL
+#define mplib_make_S(a)                     \
+    static int mplib_##a##_index = 0;         \
+    static const char *mplib_##a##_ptr = NULL
 
-static int mplib_type_Ses[mp_special_code + 1] = { 0 }; /* [0] is not used */
+/*tex In the next array entry 0 is not used */
+
+static int mplib_type_Ses[mp_special_code + 1] = { 0 };
 
 mplib_make_S(term);
 mplib_make_S(error);
@@ -94,6 +107,7 @@ mplib_make_S(memory);
 mplib_make_S(hash);
 mplib_make_S(params);
 mplib_make_S(open);
+mplib_make_S(cycle);
 
 mplib_make_S(offset);
 mplib_make_S(dashes);
@@ -153,6 +167,7 @@ static void mplib_init_Ses(lua_State * L)
     mplib_init_S(hash);
     mplib_init_S(params);
     mplib_init_S(open);
+    mplib_init_S(cycle);
 
     mplib_init_S(offset);
     mplib_init_S(dashes);
@@ -210,11 +225,15 @@ static void mplib_init_Ses(lua_State * L)
     mplib_init_S(elliptical);
 }
 
+/*tex
+
+    Here are some enumeration arrays to map MPlib enums to \LUA\ strings. If needed
+    we can also predefine keys here, as we do with nodes.
 
-/* Enumeration arrays to map MPlib enums to Lua strings */
+*/
 
 static const char *math_options[] =
-  { "scaled", "double", "binary", "decimal", NULL };
+    { "scaled", "double", "binary", "decimal", NULL };
 
 static const char *interaction_options[] =
     { "unknown", "batch", "nonstop", "scroll", "errorstop", NULL };
@@ -255,18 +274,34 @@ static const char *stop_clip_fields[] =
 static const char *no_fields[] =
     { NULL };
 
+/*tex
 
-/* The list of supported MPlib options (not all make sense) */
+    The list of supported MPlib options (not all make sense).
+
+*/
 
 typedef enum {
-    P_ERROR_LINE, P_MAX_LINE, P_RANDOM_SEED, P_MATH_MODE,
-    P_INTERACTION, P_INI_VERSION, P_MEM_NAME, P_JOB_NAME, P_FIND_FILE,
-    P_RUN_SCRIPT, P_MAKE_TEXT, P_SCRIPT_ERROR, P_EXTENSIONS,
-    P__SENTINEL } mplib_parm_idx;
+    P_ERROR_LINE,
+    P_MAX_LINE,
+    P_RANDOM_SEED,
+    P_MATH_MODE,
+    P_INTERACTION,
+    P_INI_VERSION,
+    P_MEM_NAME,
+    P_JOB_NAME,
+    P_FIND_FILE,
+    P_RUN_SCRIPT,
+    P_MAKE_TEXT,
+    P_SCRIPT_ERROR,
+    P_EXTENSIONS,
+    P__SENTINEL
+} mplib_parm_idx;
 
 typedef struct {
-    const char *name;           /* parameter name */
-    mplib_parm_idx idx;         /* parameter index */
+    /*tex parameter name */
+    const char *name;
+    /*tex parameter index */
+    mplib_parm_idx idx;
 } mplib_parm_struct;
 
 static mplib_parm_struct mplib_parms[] = {
@@ -284,10 +319,11 @@ static mplib_parm_struct mplib_parms[] = {
     {NULL,           P__SENTINEL    }
 };
 
+/*tex
 
-/* Start by defining the needed callback routines for the library  */
+    We start by defining the needed callback routines for the library.
 
-/* todo: make subtable in registry, beware, for all mp instances */
+*/
 
 static char *mplib_find_file(MP mp, const char *fname, const char *fmode, int ftype)
 {
@@ -300,7 +336,7 @@ static char *mplib_find_file(MP mp, const char *fname, const char *fmode, int ft
         lua_pushstring(L, fname);
         lua_pushstring(L, fmode);
         if (ftype >= mp_filetype_text) {
-          lua_pushnumber(L, (lua_Number)(ftype - mp_filetype_text));
+            lua_pushinteger(L, (ftype - mp_filetype_text));
         } else {
             lua_pushstring(L, mplib_filetype_names[ftype]);
         }
@@ -311,7 +347,8 @@ static char *mplib_find_file(MP mp, const char *fname, const char *fmode, int ft
         x = lua_tostring(L, -1);
         if (x != NULL)
             s = strdup(x);
-        lua_pop(L, 1);          /* pop the string */
+        /*tex pop the string */
+        lua_pop(L, 1);
         return s;
     } else {
         lua_pop(L, 1);
@@ -325,7 +362,8 @@ static char *mplib_find_file(MP mp, const char *fname, const char *fmode, int ft
 static int mplib_find_file_function(lua_State * L)
 {
     if (!(lua_isfunction(L, -1) || lua_isnil(L, -1))) {
-        return 1;               /* error */
+        /*tex An error. */
+        return 1;
     }
     lua_pushstring(L, "mplib.file_finder");
     lua_pushvalue(L, -2);
@@ -333,6 +371,11 @@ static int mplib_find_file_function(lua_State * L)
     return 0;
 }
 
+static void mplib_warning(const char *str)
+{
+    fprintf(stdout,"mplib warning: %s\n",str);
+}
+
 static void mplib_script_error(MP mp, const char *str)
 {
     lua_State *L = (lua_State *)mp_userdata(mp);
@@ -340,9 +383,10 @@ static void mplib_script_error(MP mp, const char *str)
     lua_getfield(L, LUA_REGISTRYINDEX, "mplib.script_error");
     if (lua_isfunction(L, -1)) {
         lua_pushstring(L, str);
-        lua_pcall(L, 1, 0, 0); /* assume the function is ok */
+        /*tex We assume that the function is okay. */
+        lua_pcall(L, 1, 0, 0);
     } else {
-        fprintf(stdout,"Error in script: %s\n",str);
+        mplib_warning(str);
         lua_pop(L, 1);
     }
 }
@@ -350,7 +394,8 @@ static void mplib_script_error(MP mp, const char *str)
 static int mplib_script_error_function(lua_State * L)
 {
     if (!(lua_isfunction(L, -1) || lua_isnil(L, -1))) {
-        return 1;               /* error */
+        /*tex An error. */
+        return 1;
     }
     lua_pushstring(L, "mplib.script_error");
     lua_pushvalue(L, -2);
@@ -368,13 +413,14 @@ static char *mplib_run_script(MP mp, const char *str)
         const char *x = NULL;
         lua_pushstring(L, str);
         if (lua_pcall(L, 1, 1, 0) != 0) {
-            mplib_script_error(mp, lua_tostring(L, -1));
+            fprintf(stdout,"mplib warning: error in script: %s\n",lua_tostring(L, -1));
             return NULL;
         }
         x = lua_tostring(L, -1);
         if (x != NULL)
             s = strdup(x);
-        lua_pop(L, 1);          /* pop the string */
+        /*tex Pop the string. */
+        lua_pop(L, 1);
         return s;
     } else {
         lua_pop(L, 1);
@@ -385,7 +431,7 @@ static char *mplib_run_script(MP mp, const char *str)
 static int mplib_run_script_function(lua_State * L)
 {
     if (!(lua_isfunction(L, -1) || lua_isnil(L, -1))) {
-        return 1;               /* error */
+        return 1; /* error */
     }
     lua_pushstring(L, "mplib.run_script");
     lua_pushvalue(L, -2);
@@ -410,7 +456,8 @@ static char *mplib_make_text(MP mp, const char *str, int mode)
         x = lua_tostring(L, -1);
         if (x != NULL)
             s = strdup(x);
-        lua_pop(L, 1);          /* pop the string */
+        /*tex Pop the string. */
+        lua_pop(L, 1);
         return s;
     } else {
         lua_pop(L, 1);
@@ -421,7 +468,8 @@ static char *mplib_make_text(MP mp, const char *str, int mode)
 static int mplib_make_text_function(lua_State * L)
 {
     if (!(lua_isfunction(L, -1) || lua_isnil(L, -1))) {
-        return 1;               /* error */
+        /*tex An error. */
+        return 1;
     }
     lua_pushstring(L, "mplib.make_text");
     lua_pushvalue(L, -2);
@@ -487,7 +535,8 @@ static int mplib_new(lua_State * L)
         int i;
         struct MP_options *options = mp_options();
         options->userdata = (void *) L;
-        options->noninteractive = 1;    /* required ! */
+        /*tex Required: */
+        options->noninteractive = 1;
         options->extensions = 0 ;
         options->find_file = mplib_find_file;
         options->run_script = mplib_run_script;
@@ -500,56 +549,59 @@ static int mplib_new(lua_State * L)
                 lua_getfield(L, 1, mplib_parms[i].name);
                 if (lua_isnil(L, -1)) {
                     lua_pop(L, 1);
-                    continue;   /* skip unset */
+                    continue;
                 }
                 switch (mplib_parms[i].idx) {
-                case P_ERROR_LINE:
-                  options->error_line = (int)lua_tointeger(L, -1);
-                    if (options->error_line<60) options->error_line =60;
-                    if (options->error_line>250) options->error_line = 250;
-                    options->half_error_line = (options->error_line/2)+10;
-                    break;
-                case P_MAX_LINE:
-                    options->max_print_line = (int)lua_tointeger(L, -1);
-                    if (options->max_print_line<60) options->max_print_line = 60;
-                    break;
-                case P_RANDOM_SEED:
-                    options->random_seed = (int)lua_tointeger(L, -1);
-                    break;
-                case P_INTERACTION:
-                    options->interaction = luaL_checkoption(L, -1, "errorstopmode", interaction_options);
-                    break;
-                case P_MATH_MODE:
-                    options->math_mode = luaL_checkoption(L, -1, "scaled", math_options);
-                    break;
-                case P_JOB_NAME:
-                    options->job_name = strdup(lua_tostring(L, -1));
-                    break;
-                case P_FIND_FILE:
-                    if (mplib_find_file_function(L)) {  /* error here */
-                        fprintf(stdout,"Invalid arguments to mp.new { find_file = ... }\n");
-                    }
-                    break;
-                case P_RUN_SCRIPT:
-                    if (mplib_run_script_function(L)) {  /* error here */
-                        fprintf(stdout,"Invalid arguments to mp.new { run_script = ... }\n");
-                    }
-                    break;
-                case P_MAKE_TEXT:
-                    if (mplib_make_text_function(L)) {  /* error here */
-                        fprintf(stdout,"Invalid arguments to mp.new { make_text = ... }\n");
-                    }
-                    break;
-                case P_SCRIPT_ERROR:
-                    if (mplib_script_error_function(L)) {  /* error here */
-                        fprintf(stdout,"Invalid arguments to mp.new { script_error = ... }\n");
-                    }
-                    break;
-                case P_EXTENSIONS:
-                    options->extensions = (int)lua_tointeger(L, -1);
-                    break;
-                default:
-                    break;
+                    case P_ERROR_LINE:
+                        options->error_line = (int)lua_tointeger(L, -1);
+                        if (options->error_line < 60)
+                            options->error_line = 60;
+                        if (options->error_line > 250)
+                            options->error_line = 250;
+                        options->half_error_line = (options->error_line/2)+10;
+                        break;
+                    case P_MAX_LINE:
+                        options->max_print_line = (int)lua_tointeger(L, -1);
+                        if (options->max_print_line < 60)
+                            options->max_print_line = 60;
+                        break;
+                    case P_RANDOM_SEED:
+                        options->random_seed = (int)lua_tointeger(L, -1);
+                        break;
+                    case P_INTERACTION:
+                        options->interaction = luaL_checkoption(L, -1, "errorstopmode", interaction_options);
+                        break;
+                    case P_MATH_MODE:
+                        options->math_mode = luaL_checkoption(L, -1, "scaled", math_options);
+                        break;
+                    case P_JOB_NAME:
+                        options->job_name = strdup(lua_tostring(L, -1));
+                        break;
+                    case P_FIND_FILE:
+                        if (mplib_find_file_function(L)) {
+                            mplib_warning("function expected for 'find_file'");
+                        }
+                        break;
+                    case P_RUN_SCRIPT:
+                        if (mplib_run_script_function(L)) {
+                            mplib_warning("function expected for 'run_script'");
+                        }
+                        break;
+                    case P_MAKE_TEXT:
+                        if (mplib_make_text_function(L)) {
+                            mplib_warning("function expected for 'make_text'");
+                        }
+                        break;
+                    case P_SCRIPT_ERROR:
+                        if (mplib_script_error_function(L)) {
+                            mplib_warning("function expected for 'script_error'");
+                        }
+                        break;
+                    case P_EXTENSIONS:
+                        options->extensions = (int)lua_tointeger(L, -1);
+                        break;
+                    default:
+                        break;
                 }
                 lua_pop(L, 1);
             }
@@ -626,7 +678,7 @@ static int mplib_wrapresults(lua_State * L, mp_run_data *res, int status)
         res->edges = NULL;
     }
     mplib_push_S(status);
-    lua_pushnumber(L, (lua_Number)status);
+    lua_pushinteger(L, status);
     lua_rawset(L,-3);
     return 1;
 }
@@ -716,16 +768,16 @@ static int mplib_statistics(lua_State * L)
     if (*mp_ptr != NULL) {
         lua_newtable(L);
         mplib_push_S(memory);
-        lua_pushnumber(L, (lua_Number)mp_memory_usage(*mp_ptr));
+        lua_pushinteger(L, mp_memory_usage(*mp_ptr));
         lua_rawset(L,-3);
         mplib_push_S(hash);
-        lua_pushnumber(L, (lua_Number)mp_hash_usage(*mp_ptr));
+        lua_pushinteger(L, mp_hash_usage(*mp_ptr));
         lua_rawset(L,-3);
         mplib_push_S(params);
-        lua_pushnumber(L, (lua_Number)mp_param_usage(*mp_ptr));
+        lua_pushinteger(L, mp_param_usage(*mp_ptr));
         lua_rawset(L,-3);
         mplib_push_S(open);
-        lua_pushnumber(L, (lua_Number)mp_open_usage(*mp_ptr));
+        lua_pushinteger(L, mp_open_usage(*mp_ptr));
         lua_rawset(L,-3);
     } else {
         lua_pushnil(L);
@@ -733,7 +785,6 @@ static int mplib_statistics(lua_State * L)
     return 1;
 }
 
-
 static int set_direction (lua_State * L, MP mp, mp_knot p) {
     double direction_x = 0, direction_y = 0;
     direction_x = (double)lua_tonumber(L,-1);
@@ -821,8 +872,8 @@ static int set_right_control (lua_State * L, MP mp, mp_knot p) {
     return 1;
 }
 
-
 #if 0
+
 #define ROUNDED_ZERO(v) (fabs((v))<0.00001 ? 0 : (v))
 #define PI 3.1415926535897932384626433832795028841971
 #define RADIANS(a) (mp_number_as_double(mp,(a)) / 16.0) * PI/180.0
@@ -915,6 +966,7 @@ void mp_dump_path (MP mp, mp_knot h) {
         printf("cycle");
     printf (";\n");
 }
+
 #endif
 
 static int mplib_solve_path(lua_State * L)
@@ -938,10 +990,8 @@ static int mplib_solve_path(lua_State * L)
     mp = *mp_ptr;
     cyclic = lua_toboolean(L,3);
     lua_pop(L,1);
-
-    /* build up the path */
+    /*tex We build up the path. */
     numpoints = lua_objlen(L,2);
-
     first = p = NULL;
     for (i=1;i<=numpoints;i++) {
         int left_set = 0, right_set = 0;
@@ -951,7 +1001,6 @@ static int mplib_solve_path(lua_State * L)
             errormsg = "Wrong argument types";
             goto BAD;
         }
-
         mplib_push_S(x_coord);
         lua_rawget(L,-2);
         if (!lua_isnumber(L,-1)) {
@@ -960,7 +1009,6 @@ static int mplib_solve_path(lua_State * L)
         }
         x_coord = (double)lua_tonumber(L,-1);
         lua_pop(L,1);
-
         mplib_push_S(y_coord);
         lua_rawget(L,-2);
         if (!lua_isnumber(L,-1)) {
@@ -969,11 +1017,14 @@ static int mplib_solve_path(lua_State * L)
         }
         y_coord = (double)lua_tonumber(L,-1);
         lua_pop(L,1);
-
         q = p;
         if (q!=NULL) {
-            /* we have to save the right_tension because |mp_append_knot| trashes
-               it, believing that it is as yet uninitialized */
+            /*tex
+
+                We have to save the right_tension because |mp_append_knot|
+                trashes it, believing that it is as yet uninitialized.
+
+            */
             double saved_tension = mp_number_as_double(mp, mp_knot_right_tension(mp,p));
             p = mp_append_knot(mp, p, x_coord, y_coord);
             if ( ! p ) {
@@ -988,10 +1039,8 @@ static int mplib_solve_path(lua_State * L)
                 goto BAD;
             }
         }
-
         if (first == NULL)
             first = p;
-
         mplib_push_S(left_curl);
         lua_rawget(L,-2);
         if (lua_isnumber(L,-1)) {
@@ -1001,9 +1050,9 @@ static int mplib_solve_path(lua_State * L)
             }
             left_set  = 1;
         } else {
-            lua_pop(L,1); /* a nil value */
+            /*tex A |nil| value. */
+            lua_pop(L,1);
         }
-
         mplib_push_S(left_tension);
         lua_rawget(L,-2);
         if (lua_isnumber(L,-1)) {
@@ -1018,9 +1067,9 @@ static int mplib_solve_path(lua_State * L)
                 left_set  = 1;
             }
         } else {
-            lua_pop(L,1); /* a nil value */
+            /*tex A |nil| value. */
+            lua_pop(L,1);
         }
-
         mplib_push_S(left_x);
         lua_rawget(L,-2);
         if (lua_isnumber(L,-1)) {
@@ -1036,7 +1085,6 @@ static int mplib_solve_path(lua_State * L)
         } else {
             lua_pop(L,1);
         }
-
         mplib_push_S(right_curl);
         lua_rawget(L,-2);
         if (lua_isnumber(L,-1)) {
@@ -1046,9 +1094,9 @@ static int mplib_solve_path(lua_State * L)
             }
             right_set  = 1;
         } else {
-            lua_pop(L,1); /* a nil value */
+            /*tex A |nil| value. */
+            lua_pop(L,1);
         }
-
         mplib_push_S(right_tension);
         lua_rawget(L,-2);
         if (lua_isnumber(L,-1)) {
@@ -1065,7 +1113,6 @@ static int mplib_solve_path(lua_State * L)
         } else {
             lua_pop(L,1);
         }
-
         mplib_push_S(right_x);
         lua_rawget(L,-2);
         if (lua_isnumber(L,-1)) {
@@ -1081,7 +1128,6 @@ static int mplib_solve_path(lua_State * L)
         } else {
             lua_pop(L,1);
         }
-
         mplib_push_S(direction_x);
         lua_rawget(L,-2);
         if (lua_isnumber(L,-1)) {
@@ -1090,12 +1136,12 @@ static int mplib_solve_path(lua_State * L)
                 goto BAD;
             }
         } else {
-            lua_pop(L,1); /* a nil value */
+            /*tex A |nil| value. */
+            lua_pop(L,1);
         }
-
-        lua_pop(L,1); /* done with this item */
+        /*tex Up the next item */
+        lua_pop(L,1);
     }
-
     if (cyclic) {
         mp_close_path_cycle (mp, p, first);
     } else {
@@ -1104,12 +1150,12 @@ static int mplib_solve_path(lua_State * L)
 #if 0
     mp_dump_path(mp,first);
 #endif
-    /* finished reading arguments */
+    /*tex We're finished reading arguments. */
     if (!mp_solve_path(mp,first)) {
         errormsg = "Failed to solve the path";
         goto BAD;
     }
-    /* squeeze the new values back into the table */
+    /*tex Squeeze the new values back into the table. */
     p = first;
     for (i=1;i<=numpoints;i++) {
         lua_rawgeti(L,-1, i);
@@ -1117,14 +1163,14 @@ static int mplib_solve_path(lua_State * L)
         mplib_push_S(left_y);  lua_pushnumber(L, mp_number_as_double(mp, mp_knot_left_y(mp, p)));  lua_rawset(L,-3);
         mplib_push_S(right_x); lua_pushnumber(L, mp_number_as_double(mp, mp_knot_right_x(mp, p))); lua_rawset(L,-3);
         mplib_push_S(right_y); lua_pushnumber(L, mp_number_as_double(mp, mp_knot_right_y(mp, p))); lua_rawset(L,-3);
-        /* is this really needed */
-            mplib_push_S(left_tension);  lua_pushnil(L); lua_rawset(L,-3);
-            mplib_push_S(right_tension); lua_pushnil(L); lua_rawset(L,-3);
-            mplib_push_S(left_curl);     lua_pushnil(L); lua_rawset(L,-3);
-            mplib_push_S(right_curl);    lua_pushnil(L); lua_rawset(L,-3);
-            mplib_push_S(direction_x);   lua_pushnil(L); lua_rawset(L,-3);
-            mplib_push_S(direction_y);   lua_pushnil(L); lua_rawset(L,-3);
-        /* till here */
+        /*tex This is a bit overkill \unknown */
+        mplib_push_S(left_tension);  lua_pushnil(L); lua_rawset(L,-3);
+        mplib_push_S(right_tension); lua_pushnil(L); lua_rawset(L,-3);
+        mplib_push_S(left_curl);     lua_pushnil(L); lua_rawset(L,-3);
+        mplib_push_S(right_curl);    lua_pushnil(L); lua_rawset(L,-3);
+        mplib_push_S(direction_x);   lua_pushnil(L); lua_rawset(L,-3);
+        mplib_push_S(direction_y);   lua_pushnil(L); lua_rawset(L,-3);
+        /*tex \unknown\ till here. */
         mplib_push_S(left_type);  lua_pushstring(L, knot_type_enum[mp_knot_left_type(mp, p)]);  lua_rawset(L, -3);
         mplib_push_S(right_type); lua_pushstring(L, knot_type_enum[mp_knot_right_type(mp, p)]); lua_rawset(L, -3);
         lua_pop(L,1);
@@ -1132,7 +1178,7 @@ static int mplib_solve_path(lua_State * L)
     }
     lua_pushboolean(L, 1);
     return 1;
-BAD:
+  BAD:
     if (p != NULL) {
         mp_close_path (mp, p, first);
         mp_free_path (mp, p);
@@ -1142,7 +1188,11 @@ BAD:
     return 2;
 }
 
-/* figure methods */
+/*tex
+
+    The next methods are for collecting the results from |fig|.
+
+*/
 
 static int mplib_fig_collect(lua_State * L)
 {
@@ -1171,7 +1221,8 @@ static int mplib_fig_body(lua_State * L)
         i++;
         p = p->next;
     }
-    (*hh)->body = NULL;         /* prevent double free */
+    /*tex Prevent a double free: */
+    (*hh)->body = NULL;
     return 1;
 }
 
@@ -1233,7 +1284,6 @@ static int mplib_fig_svg(lua_State * L)
     return 1;
 }
 
-
 static int mplib_fig_png(lua_State * L)
 {
     mp_run_data *res;
@@ -1316,8 +1366,6 @@ static int mplib_fig_charcode(lua_State * L)
     return 1;
 }
 
-
-
 static int mplib_fig_bb(lua_State * L)
 {
     struct mp_edge_object **hh = is_fig(L, 1);
@@ -1333,7 +1381,11 @@ static int mplib_fig_bb(lua_State * L)
     return 1;
 }
 
-/* object methods */
+/*tex
+
+    The methods for the figure objects plus a few helpers.
+
+*/
 
 static int mplib_gr_collect(lua_State * L)
 {
@@ -1413,7 +1465,6 @@ static double coord_range_y (mp_gr_knot h, double dz) {
     return (zhi - zlo <= dz ? aspect_bound : aspect_default);
 }
 
-
 static int mplib_gr_peninfo(lua_State * L) {
     double x_coord, y_coord, left_x, left_y, right_x, right_y;
     double wx, wy;
@@ -1481,6 +1532,13 @@ static int mplib_gr_peninfo(lua_State * L) {
     return 1;
 }
 
+/*tex
+
+    Here is a helper that reports the valid field names of the possible
+    objects.
+
+*/
+
 static int mplib_gr_fields(lua_State * L)
 {
     const char **fields;
@@ -1526,7 +1584,6 @@ static int mplib_gr_fields(lua_State * L)
     return 1;
 }
 
-
 #define mplib_push_number(L,x) lua_pushnumber(L,(lua_Number)(x))
 
 #define MPLIB_PATH 0
@@ -1534,7 +1591,7 @@ static int mplib_gr_fields(lua_State * L)
 
 static void mplib_push_path(lua_State * L, mp_gr_knot h, int is_pen)
 {
-    mp_gr_knot p;          /* for scanning the path */
+    mp_gr_knot p;
     int i = 1;
     p = h;
     if (p != NULL) {
@@ -1583,16 +1640,63 @@ static void mplib_push_path(lua_State * L, mp_gr_knot h, int is_pen)
     }
 }
 
-/* this assumes that the top of the stack is a table
-   or nil already in the case
+static int mplib_get_path(lua_State * L)
+{
+    MP *mp = is_mp(L, 1);
+    if (*mp != NULL) {
+        size_t l;
+        const char *s = lua_tolstring(L, 2, &l);
+        if (s != NULL) {
+            mp_knot p = mp_get_path_value(*mp,s,l) ;
+            if (p != NULL) {
+                int i = 1;
+                mp_knot h = p;
+                lua_newtable(L);
+                do {
+                    lua_createtable(L, 6, 1);
+                    mplib_push_number(L, mp_number_as_double(*mp,p->x_coord));
+                    lua_rawseti(L,-2,1);
+                    mplib_push_number(L, mp_number_as_double(*mp,p->y_coord));
+                    lua_rawseti(L,-2,2);
+                    mplib_push_number(L, mp_number_as_double(*mp,p->left_x));
+                    lua_rawseti(L,-2,3);
+                    mplib_push_number(L, mp_number_as_double(*mp,p->left_y));
+                    lua_rawseti(L,-2,4);
+                    mplib_push_number(L, mp_number_as_double(*mp,p->right_x));
+                    lua_rawseti(L,-2,5);
+                    mplib_push_number(L, mp_number_as_double(*mp,p->right_y));
+                    lua_rawseti(L,-2,6);
+                    lua_rawseti(L,-2, i);
+                    i++;
+                    if (p->data.types.right_type == mp_endpoint) {
+                        mplib_push_S(cycle);
+                        lua_pushboolean(L,0);
+                        lua_rawset(L,-3);
+                        return 1;
+                    }
+                    p = p->next;
+                } while (p != h);
+                mplib_push_S(cycle);
+                lua_pushboolean(L,1);
+                lua_rawset(L,-3);
+                return 1;
+            }
+        }
+    }
+    return 0;
+}
+
+/*tex
+
+    This assumes that the top of the stack is a table or nil already in the case.
 */
 
 static void mplib_push_pentype(lua_State * L, mp_gr_knot h)
 {
-    mp_gr_knot p;          /* for scanning the path */
+    mp_gr_knot p;
     p = h;
     if (p == NULL) {
-        /* do nothing */
+        /*tex Do nothing. */
     } else if (p == p->next) {
         mplib_push_S(type);
         mplib_push_S(elliptical);
@@ -1643,7 +1747,11 @@ static void mplib_push_color(lua_State * L, struct mp_graphic_object *p)
     }
 }
 
-/* the dash scale is not exported, the field has no external value */
+/*tex
+
+    The dash scale is not exported, the field has no external value.
+
+*/
 
 static void mplib_push_dash(lua_State * L, struct mp_stroked_object *h)
 {
@@ -1811,7 +1919,6 @@ static int mplib_gr_index(lua_State * L)
     struct mp_graphic_object **hh = is_gr_object(L, 1);
     if (*hh) {
         struct mp_graphic_object *h = *hh;
-
         if (mplib_is_S(type, 2)) {
             lua_rawgeti(L, LUA_REGISTRYINDEX, mplib_type_Ses[h->type]);
         } else {
@@ -1847,61 +1954,77 @@ static int mplib_gr_index(lua_State * L)
 }
 
 static const struct luaL_reg mplib_meta[] = {
-    {"__gc", mplib_collect},
-    {"__tostring", mplib_tostring},
-    {NULL, NULL} /* sentinel */
+    { "__gc",       mplib_collect },
+    { "__tostring", mplib_tostring },
+    /*tex sentinel */
+    { NULL,         NULL}
 };
 
 static const struct luaL_reg mplib_fig_meta[] = {
-    {"__gc",         mplib_fig_collect},
-    {"__tostring",   mplib_fig_tostring},
-    {"objects",      mplib_fig_body},
-    {"copy_objects", mplib_fig_copy_body},
-    {"filename",     mplib_fig_filename},
-    {"postscript",   mplib_fig_postscript},
-    {"png",          mplib_fig_png},
-    {"svg",          mplib_fig_svg},
-    {"boundingbox",  mplib_fig_bb},
-    {"width",        mplib_fig_width},
-    {"height",       mplib_fig_height},
-    {"depth",        mplib_fig_depth},
-    {"italcorr",     mplib_fig_italcorr},
-    {"charcode",     mplib_fig_charcode},
-    {NULL, NULL}                /* sentinel */
+    { "__gc",         mplib_fig_collect },
+    { "__tostring",   mplib_fig_tostring },
+    { "objects",      mplib_fig_body },
+    { "copy_objects", mplib_fig_copy_body },
+    { "filename",     mplib_fig_filename },
+    { "postscript",   mplib_fig_postscript },
+    { "png",          mplib_fig_png },
+    { "svg",          mplib_fig_svg },
+    { "boundingbox",  mplib_fig_bb },
+    { "width",        mplib_fig_width },
+    { "height",       mplib_fig_height },
+    { "depth",        mplib_fig_depth },
+    { "italcorr",     mplib_fig_italcorr },
+    { "charcode",     mplib_fig_charcode },
+    /*tex sentinel */
+    { NULL,           NULL}
 };
 
 static const struct luaL_reg mplib_gr_meta[] = {
-    {"__gc", mplib_gr_collect},
-    {"__tostring", mplib_gr_tostring},
-    {"__index", mplib_gr_index},
-    {NULL, NULL} /* sentinel */
+    { "__gc",       mplib_gr_collect},
+    { "__tostring", mplib_gr_tostring},
+    { "__index",    mplib_gr_index},
+    /*tex sentinel */
+    { NULL,         NULL}
 };
 
 static const struct luaL_reg mplib_d[] = {
-    {"execute", mplib_execute},
-    {"finish", mplib_finish},
-    {"char_width", mplib_charwidth},
-    {"char_height", mplib_charheight},
-    {"char_depth", mplib_chardepth},
-    {"statistics", mplib_statistics},
-    {"solve_path", mplib_solve_path},
-    {"get_numeric", mplib_get_numeric},
-    {"get_number", mplib_get_numeric},
-    {"get_boolean", mplib_get_boolean},
-    {"get_string", mplib_get_string},
-    {NULL, NULL} /* sentinel */
+    { "execute",     mplib_execute },
+    { "finish",      mplib_finish },
+    { "char_width",  mplib_charwidth },
+    { "char_height", mplib_charheight },
+    { "char_depth",  mplib_chardepth },
+    { "statistics",  mplib_statistics },
+    { "solve_path",  mplib_solve_path },
+    { "get_numeric", mplib_get_numeric },
+    { "get_number",  mplib_get_numeric },
+    { "get_boolean", mplib_get_boolean },
+    { "get_string",  mplib_get_string },
+    { "get_path",    mplib_get_path },
+    /*tex sentinel */
+    {NULL,           NULL }
 };
 
 static const struct luaL_reg mplib_m[] = {
-    {"new", mplib_new},
-    {"version",    mplib_version},
-    {"fields", mplib_gr_fields},
-    {"pen_info", mplib_gr_peninfo},
-    {"get_numeric", mplib_get_numeric},
-    {"get_number", mplib_get_numeric},
-    {"get_boolean", mplib_get_boolean},
-    {"get_string", mplib_get_string},
-    {NULL, NULL} /* sentinel */
+    { "new",         mplib_new },
+    { "version",     mplib_version },
+    { "fields",      mplib_gr_fields },
+    /* indirect */
+    { "execute",     mplib_execute },
+    { "finish",      mplib_finish },
+    { "char_width",  mplib_charwidth },
+    { "char_height", mplib_charheight },
+    { "char_depth",  mplib_chardepth },
+    { "statistics",  mplib_statistics },
+    { "solve_path",  mplib_solve_path },
+    /* helpers */
+    { "pen_info",    mplib_gr_peninfo },
+    { "get_numeric", mplib_get_numeric },
+    { "get_number",  mplib_get_numeric },
+    { "get_boolean", mplib_get_boolean },
+    { "get_string",  mplib_get_string },
+    { "get_path",    mplib_get_path },
+    /*tex sentinel */
+    { NULL,          NULL}
 };
 
 int luaopen_mplib(lua_State * L)
@@ -1909,22 +2032,23 @@ int luaopen_mplib(lua_State * L)
     mplib_init_Ses(L);
 
     luaL_newmetatable(L, MPLIB_GR_METATABLE);
-    lua_pushvalue(L, -1);                       /* push metatable */
-    lua_setfield(L, -2, "__index");             /* metatable.__index = metatable */
-    luaL_register(L, NULL, mplib_gr_meta);      /* object meta methods */
+    lua_pushvalue(L, -1);
+    lua_setfield(L, -2, "__index");
+    luaL_register(L, NULL, mplib_gr_meta);
     lua_pop(L, 1);
 
     luaL_newmetatable(L, MPLIB_FIG_METATABLE);
-    lua_pushvalue(L, -1);                       /* push metatable */
-    lua_setfield(L, -2, "__index");             /* metatable.__index = metatable */
-    luaL_register(L, NULL, mplib_fig_meta);     /* figure meta methods */
+    lua_pushvalue(L, -1);
+    lua_setfield(L, -2, "__index");
+    luaL_register(L, NULL, mplib_fig_meta);
     lua_pop(L, 1);
 
     luaL_newmetatable(L, MPLIB_METATABLE);
-    lua_pushvalue(L, -1);                       /* push metatable */
-    lua_setfield(L, -2, "__index");             /* metatable.__index = metatable */
-    luaL_register(L, NULL, mplib_meta);         /* meta methods */
-    luaL_register(L, NULL, mplib_d);            /* dict methods */
-    luaL_register(L, "mplib", mplib_m);         /* module functions */
+    lua_pushvalue(L, -1);
+    lua_setfield(L, -2, "__index");
+    luaL_register(L, NULL, mplib_meta);
+    luaL_register(L, NULL, mplib_d);
+    luaL_register(L, "mplib", mplib_m);
+
     return 1;
 }
diff --git a/texk/web2c/mplibdir/mp.w b/texk/web2c/mplibdir/mp.w
index 2c956ea5a..d52ad37ce 100644
--- a/texk/web2c/mplibdir/mp.w
+++ b/texk/web2c/mplibdir/mp.w
@@ -139,7 +139,7 @@ typedef struct MP_instance {
 
 @ @c
 /*\#define DEBUGENVELOPE */
-#ifdef DEBUGENVELOPE 
+#ifdef DEBUGENVELOPE
 static int DEBUGENVELOPECOUNTER=0;
 #define dbg_str(A)	  printf("\n--[==[%03d DEBUGENVELOPE ]==] %s",		   DEBUGENVELOPECOUNTER++, #A)
 #define dbg_n(A) 	  printf("\n--[==[%03d DEBUGENVELOPE ]==] ['%s']=%s, ",	   DEBUGENVELOPECOUNTER++, #A, number_tostring(A))
@@ -176,8 +176,8 @@ static int DEBUGENVELOPECOUNTER=0;
 #include <png.h>                /* for |PNG_LIBPNG_VER_STRING|, |png_libpng_ver| */
 /*\#include <pixman.h>*/             /* for |PIXMAN_VERSION_STRING|, |pixman_version_string()| */
 /*\#include <cairo.h>*/              /* for |CAIRO_VERSION_STRING|, |cairo_version_string()| */
-#include <gmp.h>                /* for |gmp_version| */
-#include <mpfr.h>               /* for |MPFR_VERSION_STRING|, |mpfr_get_version()| */
+/*\#include <gmp.h>*/                /* for |gmp_version| */
+/*\#include <mpfr.h>*/               /* for |MPFR_VERSION_STRING|, |mpfr_get_version()| */
 #include "mplib.h"
 #include "mplibps.h"            /* external header */
 /*\#include "mplibsvg.h" */          /* external header */
@@ -189,7 +189,7 @@ static int DEBUGENVELOPECOUNTER=0;
 #include "mpmath.h"             /* internal header */
 #include "mpmathdouble.h"       /* internal header */
 #include "mpmathdecimal.h"      /* internal header */
-#include "mpmathbinary.h"       /* internal header */
+/*#include "mpmathbinary.h"*/       /* internal header */
 #include "mpstrings.h"          /* internal header */
 /* BEGIN PATCH */
 mp_number dx_ap;    /* approximation of dx */
@@ -200,12 +200,19 @@ mp_number ueps_ap;  /* epsilon for above approximations */
 boolean is_dxdy, is_dxindyin;
 /* END PATCH */
 
-@ We move the {\tt cairo} and {\tt pixman} libraries outside {\tt mp.w}, 
+@ We move the {\tt cairo} and {\tt pixman} libraries outside {\tt mp.w},
 to minimize dependencies.
 
 @c
 extern const char *COMPILED_CAIRO_VERSION_STRING;
 extern const char* cairo_version_string (void);
+extern const char *COMPILED_MPFR_VERSION_STRING;
+extern const char* mpfr_get_version (void);
+extern void * mp_initialize_binary_math (MP mp) ;
+extern int COMPILED__GNU_MP_VERSION;
+extern int COMPILED__GNU_MP_VERSION_MINOR;
+extern int COMPILED__GNU_MP_VERSION_PATCHLEVEL;
+extern const char * const COMPILED_gmp_version;
 extern const char *COMPILED_PIXMAN_VERSION_STRING;
 extern const char* pixman_version_string (void);
 extern void mp_png_backend_initialize (MP mp);
@@ -2628,7 +2635,7 @@ void mp_new_randoms (MP mp) {
   mp->j_random = 54;
 }
 
-@ To consume a random fraction, the program below will say `|next_random|'. 
+@ To consume a random fraction, the program below will say `|next_random|'.
 Now each number system has its own implementation,
 true to the original as much as possibile.
 
@@ -2657,7 +2664,7 @@ As said before, now each number system has its own implementation.
 @c
 /*Unused.
 static void mp\_unif\_rand (MP mp, mp\_number *ret, mp\_number x\_orig) {
-  mp\_number y;     // trial value 
+  mp\_number y;     // trial value
   mp\_number x, abs\_x;
   mp\_number u;
   new\_fraction (y);
@@ -2896,7 +2903,7 @@ void *do_alloc_node (MP mp, size_t size) {
 
 @c
 void mp_xfree (void *x) {
-  if (x != NULL) 
+  if (x != NULL)
     free (x);
 }
 void *mp_xrealloc (MP mp, void *p, size_t nmem, size_t size) {
@@ -3235,8 +3242,7 @@ mp_random_seed, /* initialize random number generator (\&{randomseed}) */
 mp_message_command, /* communicate to user (\&{message}, \&{errmessage}) */
 mp_every_job_command, /* designate a starting token (\&{everyjob}) */
 mp_delimiters, /* define a pair of delimiters (\&{delimiters}) */
-mp_special_command, /* output special info (\&{special})
-                       or font map info (\&{fontmapfile}, \&{fontmapline}) */
+mp_special_command, /* output special info (\&{special}) or font map info (\&{fontmapfile}, \&{fontmapline}) */
 mp_write_command, /* write text to a file (\&{write}) */
 mp_type_name, /* declare a type (\&{numeric}, \&{pair}, etc.) */
 mp_left_delimiter, /* the left delimiter of a matching pair */
@@ -3275,15 +3281,13 @@ mp_left_bracket, /* the operator `\.[' */
 mp_right_bracket, /* the operator `\.]' */
 mp_right_brace, /* the operator `\.{\char`\}}' */
 mp_with_option, /* option for filling (\&{withpen}, \&{withweight}, etc.) */
-mp_thing_to_add,
-  /* variant of \&{addto} (\&{contour}, \&{doublepath}, \&{also}) */
+mp_thing_to_add, /* variant of \&{addto} (\&{contour}, \&{doublepath}, \&{also}) */
 mp_of_token, /* the operator `\&{of}' */
 mp_to_token, /* the operator `\&{to}' */
 mp_step_token, /* the operator `\&{step}' */
 mp_until_token, /* the operator `\&{until}' */
 mp_within_token, /* the operator `\&{within}' */
-mp_lig_kern_token,
-  /* the operators `\&{kern}' and `\.{=:}' and `\.{=:\char'174}', etc. */
+mp_lig_kern_token, /* the operators `\&{kern}' and `\.{=:}' and `\.{=:\char'174}', etc. */
 mp_assignment, /* the operator `\.{:=}' */
 mp_skip_to, /* the operation `\&{skipto}' */
 mp_bchar_label, /* the operator `\.{\char'174\char'174:}' */
@@ -4046,6 +4050,7 @@ enum mp_given_internal {
   mp_pausing,                   /* positive to display lines on the terminal before they are read */
   mp_showstopping,              /* positive to stop after each \&{show} command */
   mp_fontmaking,                /* positive if font metric output is to be produced */
+  mp_texscriptmode,             /* controls spacing in texmode */
   mp_linejoin,                  /* as in \ps: 0 for mitered, 1 for round, 2 for beveled */
   mp_linecap,                   /* as in \ps: 0 for butt, 1 for round, 2 for square */
   mp_miterlimit,                /* controls miter length as in \ps */
@@ -4196,6 +4201,8 @@ mp_primitive (mp, "showstopping", mp_internal_quantity, mp_showstopping);
 @:mp_showstopping_}{\&{showstopping} primitive@>;
 mp_primitive (mp, "fontmaking", mp_internal_quantity, mp_fontmaking);
 @:mp_fontmaking_}{\&{fontmaking} primitive@>;
+mp_primitive (mp, "texscriptmode", mp_internal_quantity, mp_texscriptmode);
+@:mp_texscriptmode_}{\&{texscriptmode} primitive@>;
 mp_primitive (mp, "linejoin", mp_internal_quantity, mp_linejoin);
 @:mp_linejoin_}{\&{linejoin} primitive@>;
 mp_primitive (mp, "linecap", mp_internal_quantity, mp_linecap);
@@ -4214,8 +4221,7 @@ mp_primitive (mp, "mpprocset", mp_internal_quantity, mp_procset);
 @:mp_procset_}{\&{mpprocset} primitive@>;
 mp_primitive (mp, "troffmode", mp_internal_quantity, mp_gtroffmode);
 @:troffmode_}{\&{troffmode} primitive@>;
-mp_primitive (mp, "defaultcolormodel", mp_internal_quantity,
-              mp_default_color_model);
+mp_primitive (mp, "defaultcolormodel", mp_internal_quantity, mp_default_color_model);
 @:mp_default_color_model_}{\&{defaultcolormodel} primitive@>;
 mp_primitive (mp, "restoreclipcolor", mp_internal_quantity, mp_restore_clip_color);
 @:mp_restore_clip_color_}{\&{restoreclipcolor} primitive@>;
@@ -4273,6 +4279,7 @@ set_internal_string (mp_output_format, mp_intern (mp, "eps"));
 set_internal_string (mp_output_format_options, mp_intern (mp, ""));
 set_internal_string (mp_number_system, mp_intern (mp, "scaled"));
 set_internal_from_number (mp_number_precision, precision_default);
+set_internal_from_number (mp_texscriptmode, unity_t);
 #if DEBUG
 number_clone (internal_value (mp_tracing_titles), three_t);
 number_clone (internal_value (mp_tracing_equations), three_t);
@@ -4320,6 +4327,7 @@ set_internal_name (mp_design_size, xstrdup ("designsize"));
 set_internal_name (mp_pausing, xstrdup ("pausing"));
 set_internal_name (mp_showstopping, xstrdup ("showstopping"));
 set_internal_name (mp_fontmaking, xstrdup ("fontmaking"));
+set_internal_name (mp_texscriptmode, xstrdup ("texscriptmode"));
 set_internal_name (mp_linejoin, xstrdup ("linejoin"));
 set_internal_name (mp_linecap, xstrdup ("linecap"));
 set_internal_name (mp_miterlimit, xstrdup ("miterlimit"));
@@ -4443,6 +4451,8 @@ class numbers in nonstandard extensions of \MP.
 @d invalid_class 20 /* bad character in the input */
 @d max_class 20 /* the largest class number */
 
+@d semicolon_class 6 /* the ; */
+
 @<Glob...@>=
 #define digit_class 0 /* the class number of \.{0123456789} */
 int char_class[256];    /* the class numbers */
@@ -4843,10 +4853,26 @@ char *mp_get_string_value (MP mp, const char *s, size_t l) {
    return NULL;
 }
 
+mp_knot mp_get_path_value (MP mp, const char *s, size_t l) {
+    char *ss = mp_xstrdup(mp,s);
+    if (ss) {
+        mp_sym sym = mp_id_lookup(mp,ss,l,false);
+        if (sym != NULL) {
+            if (mp_type(sym->v.data.node) == mp_path_type) {
+                mp_xfree (ss);
+                return (mp_knot) sym->v.data.node->data.p;
+            }
+        }
+    }
+    mp_xfree (ss);
+    return NULL;
+}
+
 @ @<Exported function headers@>=
 double mp_get_numeric_value(MP mp,const char *s,size_t l);
 int mp_get_boolean_value(MP mp,const char *s,size_t l);
 char *mp_get_string_value(MP mp,const char *s,size_t l);
+mp_knot mp_get_path_value(MP mp,const char *s,size_t l);
 
 @ We need to put \MP's ``primitive'' symbolic tokens into the hash
 table, together with their command code (which will be the |eq_type|)
@@ -13270,26 +13296,26 @@ static mp_knot mp_offset_prep (MP mp, mp_knot c, mp_knot h) {
   c0 = c;
   k_needed = 0;
 #ifdef DEBUGENVELOPE
-dbg_nl;dbg_str(--[==[BEGIN]==]);dbg_nl; 
-dbg_str(return {);dbg_nl; 
+dbg_nl;dbg_str(--[==[BEGIN]==]);dbg_nl;
+dbg_str(return {);dbg_nl;
 dbg_n(w0->x_coord);
 dbg_n(w0->y_coord);
 #endif
  do {
     q = mp_next_knot (p);
 #ifdef DEBUGENVELOPE
-dbg_nl;dbg_open_t;dbg_str(--[==[begin loop]==]);dbg_nl; 
+dbg_nl;dbg_open_t;dbg_str(--[==[begin loop]==]);dbg_nl;
 dbg_n(p->x_coord);dbg_n(p->y_coord);
 dbg_n(p->right_x);dbg_n(p->right_y);
 dbg_n(q->left_x);dbg_n(q->left_y);
 dbg_n(q->x_coord);dbg_n(q->y_coord);
 dbg_n(w0->x_coord);
 dbg_n(w0->y_coord);
-#endif 
+#endif
     @<Split the cubic between |p| and |q|, if necessary, into cubics
       associated with single offsets, after which |q| should
       point to the end of the final such cubic@>;
-#ifdef DEBUGENVELOPE   
+#ifdef DEBUGENVELOPE
 dbg_key(end Split the cubic between |p| and |q|);dbg_open_t;dbg_nl;
 dbg_n(w->x_coord);dbg_n(w->y_coord);
 dbg_n(w0->x_coord);dbg_n(w0->y_coord);
@@ -13301,7 +13327,7 @@ dbg_close_t; dbg_comma;dbg_nl;
 #ifdef DEBUGENVELOPE
 dbg_n(w0->x_coord);dbg_n(w0->y_coord);
 dbg_str(--[==[end loop]==]);dbg_nl; dbg_close_t;dbg_comma;dbg_nl;
-#endif 
+#endif
   } while (q != c);
 #ifdef DEBUGENVELOPE
  dbg_key(Fix the offset change);dbg_open_t;dbg_nl;
@@ -13312,7 +13338,7 @@ dbg_str(--[==[end loop]==]);dbg_nl; dbg_close_t;dbg_comma;dbg_nl;
 #endif
   @<Fix the offset change in |mp_knot_info(c)| and set |c| to the return value of
     |offset_prep|@>;
-#ifdef DEBUGENVELOPE  
+#ifdef DEBUGENVELOPE
 dbg_n(p->x_coord);dbg_n(p->y_coord);
 dbg_key_ival(info post,mp_knot_info(p));dbg_comma;dbg_nl;
 dbg_n(c->x_coord);dbg_n(c->y_coord);
@@ -13412,7 +13438,7 @@ the testcase reported by Bogus\l{}aw Jackowski in tracker id 267, case 52c
 on Sarovar.)
 
 @<Advance |p| to node |q|, removing any ``dead'' cubics...@>=
-#ifdef DEBUGENVELOPE 
+#ifdef DEBUGENVELOPE
 dbg_comment(Advance |p| to node |q|);dbg_nl;
 #endif
 q0 = q;
@@ -13437,11 +13463,11 @@ if ((q != q0) && (q != c || c == c0))
 
 @ @<Remove the cubic following |p| and update the data structures...@>=
 {
- #ifdef DEBUGENVELOPE 
+ #ifdef DEBUGENVELOPE
  dbg_key(Remove the cubic following p);dbg_open_t;dbg_nl;
  dbg_n(p->x_coord);dbg_n(p->y_coord);
  dbg_key_ival(pre info p,mp_knot_info(p));  dbg_close_t;dbg_comma;dbg_nl;
- #endif 
+ #endif
   k_needed = mp_knot_info (p) - zero_off;
   if (r == q) {
     q = p;
@@ -13459,11 +13485,11 @@ if ((q != q0) && (q != c || c == c0))
     mp->spec_p2 = p;
   r = p;
   mp_remove_cubic (mp, p);
-  #ifdef DEBUGENVELOPE 
+  #ifdef DEBUGENVELOPE
   dbg_key(Remove the cubic following p);dbg_open_t;dbg_nl;
   dbg_n(p->x_coord);dbg_n(p->y_coord);
   dbg_key_ival(post info p,mp_knot_info (p)); dbg_close_t;dbg_comma;dbg_nl;
-  #endif 
+  #endif
 }
 
 
@@ -13532,16 +13558,16 @@ We may have to split a cubic into many pieces before each
 piece corresponds to a unique offset.
 
 @<Split the cubic between |p| and |q|, if necessary, into cubics...@>=
-#ifdef DEBUGENVELOPE 
+#ifdef DEBUGENVELOPE
 dbg_comment(Split the cubic between |p| and |q|);dbg_nl;
 dbg_key(Split the cubic);dbg_open_t;dbg_nl;
 dbg_key_ival(pre info p,mp_knot_info(p));dbg_comma;
 dbg_n(w0->x_coord);dbg_n(w0->y_coord);
-#endif 
+#endif
 mp_knot_info (p) = zero_off + k_needed;
-#ifdef DEBUGENVELOPE 
+#ifdef DEBUGENVELOPE
 dbg_key_ival(post info p,mp_knot_info(p));dbg_close_t;dbg_comma; dbg_nl;
-#endif 
+#endif
 k_needed = 0;
 @<Prepare for derivative computations;
   |goto not_found| if the current cubic is dead@>;
@@ -13708,7 +13734,7 @@ void mp_fin_offset_prep (MP mp, mp_knot p, mp_knot w, mp_number
   new_number(t2);
   new_fraction(s);
   new_fraction(t);
-#ifdef DEBUGENVELOPE 
+#ifdef DEBUGENVELOPE
 dbg_key(mp_fin_offset_prep);dbg_open_t;dbg_nl;
 #endif
   while (1) {
@@ -13716,7 +13742,7 @@ dbg_key(mp_fin_offset_prep);dbg_open_t;dbg_nl;
       ww = mp_next_knot (w);    /* a pointer to $w\k$ */
     else
       ww = mp_prev_knot (w);    /* a pointer to $w_{k-1}$ */
-#ifdef DEBUGENVELOPE 
+#ifdef DEBUGENVELOPE
 dbg_comment(begin iteration);
 dbg_open_t;dbg_nl;
 dbg_n(w->x_coord);dbg_n(w->y_coord);
@@ -13727,11 +13753,11 @@ dbg_in(rise);
 #endif
     @<Compute test coefficients |(t0,t1,t2)|
       for $d(t)$ versus $d_k$ or $d_{k-1}$@>;
-#ifdef DEBUGENVELOPE 
+#ifdef DEBUGENVELOPE
 dbg_comment(crossing_point);
 #endif
     crossing_point (t, t0, t1, t2);
-#ifdef DEBUGENVELOPE 
+#ifdef DEBUGENVELOPE
 dbg_n(t);dbg_n(t0);dbg_n(t1);dbg_n(t2);
 dbg_in(number_greaterequal(t, fraction_one_t));
 dbg_in(turn_amt);
@@ -13743,18 +13769,18 @@ dbg_close_t; dbg_comma;dbg_nl;
       else
         goto RETURN;
     }
-#ifdef DEBUGENVELOPE 
+#ifdef DEBUGENVELOPE
 dbg_comment(Split the cubic at $t$ and split off another cubic if the derivative crosses back);
 #endif
     @<Split the cubic at $t$,
       and split off another cubic if the derivative crosses back@>;
     w = ww;
-#ifdef DEBUGENVELOPE 
+#ifdef DEBUGENVELOPE
 dbg_comment(end iteration);
 #endif
   }
 RETURN:
-#ifdef DEBUGENVELOPE 
+#ifdef DEBUGENVELOPE
 dbg_comment(RETURN);
 dbg_n(t);
 #endif
@@ -13766,7 +13792,7 @@ dbg_n(t);
   free_number (t0);
   free_number (t1);
   free_number (t2);
-#ifdef DEBUGENVELOPE 
+#ifdef DEBUGENVELOPE
 dbg_close_t; dbg_comma;dbg_nl;
 #endif
 }
@@ -13782,7 +13808,7 @@ begins to fail.
   mp_number abs_du, abs_dv;
   new_number (abs_du);
   new_number (abs_dv);
-#ifdef DEBUGENVELOPE 
+#ifdef DEBUGENVELOPE
 dbg_key(Compute test coefficients |(t0,t1,t2)| for $d(t)$ versus...);dbg_open_t;dbg_nl;
 #endif
   set_number_from_substraction(du, ww->x_coord, w->x_coord);
@@ -13791,7 +13817,7 @@ dbg_key(Compute test coefficients |(t0,t1,t2)| for $d(t)$ versus...);dbg_open_t;
   number_abs(abs_du);
   number_clone(abs_dv, dv);
   number_abs(abs_dv);
-#ifdef DEBUGENVELOPE 
+#ifdef DEBUGENVELOPE
 dbg_CUBIC;
 dbg_n(w->x_coord);dbg_n(w->y_coord);
 dbg_n(ww->x_coord);dbg_n(ww->y_coord);
@@ -13838,7 +13864,7 @@ dbg_in(number_greaterequal(abs_du, abs_dv));
   free_number (abs_dv);
   if (number_negative(t0))
     set_number_to_zero(t0); /* should be positive without rounding error */
-#ifdef DEBUGENVELOPE 
+#ifdef DEBUGENVELOPE
 dbg_n(t0);dbg_n(t1);dbg_n(t2);
 dbg_close_t; dbg_comma;dbg_nl;
 #endif
@@ -13981,19 +14007,19 @@ if (number_zero(dxin) && number_zero(dyin)) {
 #ifdef DEBUGENVELOPE
 dbg_key(dxin dyin before);dbg_open_t;dbg_nl;
 dbg_n(dxin);dbg_n(dyin);
-dbg_close_t;dbg_comma; 
+dbg_close_t;dbg_comma;
 #endif
 #ifdef DEBUGENVELOPE
 dbg_key(dxin dyin after);dbg_open_t;dbg_nl;
 dbg_n(dxin);dbg_n(dyin);
-dbg_close_t;dbg_comma; 
+dbg_close_t;dbg_comma;
 #endif
 /* BEGIN PATCH */
 #ifdef DEBUGENVELOPE
 dbg_key(dx dy dxin dyin after patch);dbg_open_t;dbg_nl;
 dbg_n(dx);dbg_n(dy);dbg_n(dx_ap);dbg_n(dy_ap);
 dbg_n(dxin);dbg_n(dyin);dbg_n(dxin_ap);dbg_n(dyin_ap);
-dbg_close_t;dbg_comma; 
+dbg_close_t;dbg_comma;
 #endif
 /* END PATCH ****/
 
@@ -14012,13 +14038,13 @@ right.) This code depends on |w0| being the offset for |(dxin,dyin)|.
 #ifdef DEBUGENVELOPE
 dbg_nl;
 dbg_comment(Update |mp_knot_info(p)|);dbg_nl;
-dbg_key(mp_get_turn_amt_dx_dy);dbg_open_t;dbg_str(--[==[call mp_get_turn_amt]==]);dbg_nl; 
+dbg_key(mp_get_turn_amt_dx_dy);dbg_open_t;dbg_str(--[==[call mp_get_turn_amt]==]);dbg_nl;
 dbg_n(w0->x_coord);dbg_n(w0->y_coord);dbg_n(dx);dbg_n(dy);dbg_in(number_nonnegative(ab_vs_cd));
 dbg_n(ab_vs_cd);
 #endif
  is_dxdy=true;
  turn_amt = mp_get_turn_amt (mp, w0, dx, dy, number_nonnegative(ab_vs_cd));
- is_dxdy=false; 
+ is_dxdy=false;
 #ifdef DEBUGENVELOPE
 dbg_dn(turn_amt);
 dbg_close_t;dbg_comma;
@@ -14078,20 +14104,20 @@ integer mp_get_turn_amt (MP mp, mp_knot w, mp_number dx, mp_number dy, boolean c
       ab_vs_cd (t, dy, arg1, dx, arg2);
 #ifdef DEBUGENVELOPE
      dbg_sp;
-     dbg_open_t;dbg_str(--[==[inside mp_get_turn_amt do loop ]==]);dbg_nl; 
+     dbg_open_t;dbg_str(--[==[inside mp_get_turn_amt do loop ]==]);dbg_nl;
      dbg_n(w->x_coord);dbg_n(w->y_coord);dbg_n(ww->x_coord);dbg_n(ww->y_coord);
      dbg_n(t);dbg_n(dy);dbg_n(arg1);dbg_n(dx);dbg_n(arg2);
      dbg_n(t_ap);dbg_n(dy_ap);dbg_n(dx_ap);dbg_n(dyin_ap);dbg_n(dxin_ap);
      dbg_close_t;dbg_comma;
      dbg_in(number_zero(dx) && number_zero(arg1) && number_positive(dy) && number_positive(arg2) && is_dxdy);
-     dbg_in(is_dxdy && number_zero(dx) && number_zero(arg1) && number_negative(dy) && number_negative(arg2)  && number_positive(dyin_ap)); 
+     dbg_in(is_dxdy && number_zero(dx) && number_zero(arg1) && number_negative(dy) && number_negative(arg2)  && number_positive(dyin_ap));
      dbg_in(is_dxindyin && number_zero(dx) && number_zero(arg1) && number_positive(dy) && number_positive(arg2) && number_negative(dyin_ap));
      dbg_in(number_zero(dy) && number_zero(arg2) && number_negative(dx) && number_negative(arg1));
      dbg_in(number_zero(dx) && number_zero(arg1) && number_negative(dy) && number_positive(arg2));
      dbg_in(number_zero(dy) && number_zero(arg2) && number_positive(dx) && number_negative(arg1));
      dbg_nl;
 #endif
-      if (number_negative(t)) 
+      if (number_negative(t))
         break;
       incr (s);
       w = ww;
@@ -14104,7 +14130,7 @@ integer mp_get_turn_amt (MP mp, mp_knot w, mp_number dx, mp_number dy, boolean c
     ab_vs_cd (t, dy, arg1, dx, arg2);
 #ifdef DEBUGENVELOPE
      dbg_sp;
-     dbg_open_t;dbg_str(--[==[outside mp_get_turn_amt do loop ]==]);dbg_nl; 
+     dbg_open_t;dbg_str(--[==[outside mp_get_turn_amt do loop ]==]);dbg_nl;
      dbg_n(w->x_coord);dbg_n(w->y_coord);dbg_n(ww->x_coord);dbg_n(ww->y_coord);
      dbg_n(t);dbg_n(dy);dbg_n(arg1);dbg_n(dx);dbg_n(arg2);
      dbg_n(t_ap);dbg_n(dy_ap);dbg_n(dx_ap);dbg_n(dyin_ap);dbg_n(dxin_ap);
@@ -14120,7 +14146,7 @@ integer mp_get_turn_amt (MP mp, mp_knot w, mp_number dx, mp_number dy, boolean c
       ab_vs_cd (t, dy, arg1, dx, arg2);
 #ifdef DEBUGENVELOPE
      dbg_sp;
-     dbg_open_t;dbg_str(--[==[inside mp_get_turn_amt do loop for t<0 ]==]);dbg_nl; 
+     dbg_open_t;dbg_str(--[==[inside mp_get_turn_amt do loop for t<0 ]==]);dbg_nl;
      dbg_n(w->x_coord);dbg_n(w->y_coord);dbg_n(ww->x_coord);dbg_n(ww->y_coord);
      dbg_n(t);dbg_n(dy);dbg_n(arg1);dbg_n(dx);dbg_n(arg2);
      dbg_n(t_ap);dbg_n(dy_ap);dbg_n(dx_ap);
@@ -14173,14 +14199,14 @@ with respect to $d_{k-1}$, and apply |fin_offset_prep| to each part.
 
 @<Complete the offset splitting process@>=
 ww = mp_prev_knot (w);
-#ifdef DEBUGENVELOPE 
+#ifdef DEBUGENVELOPE
 dbg_key(Complete the offset splitting process);dbg_open_t;dbg_nl;
 dbg_n(w->x_coord);dbg_n(w->y_coord);
 dbg_n(ww->x_coord);dbg_n(ww->y_coord);
 dbg_close_t; dbg_comma;dbg_nl;
 #endif
 @<Compute test coeff...@>;
-#ifdef DEBUGENVELOPE 
+#ifdef DEBUGENVELOPE
 dbg_key(after Compute test coeff);dbg_open_t;dbg_nl;
 dbg_n(w->x_coord);dbg_n(w->y_coord);
 dbg_n(ww->x_coord);dbg_n(ww->y_coord);
@@ -14189,7 +14215,7 @@ dbg_close_t; dbg_comma;dbg_nl;
 @<Find the first |t| where $d(t)$ crosses $d_{k-1}$ or set
   |t:=fraction_one+1|@>;
 if (number_greater(t, fraction_one_t)) {
-#ifdef DEBUGENVELOPE 
+#ifdef DEBUGENVELOPE
 dbg_key(t > fraction_one_t);dbg_open_t;dbg_nl;
 dbg_n(p->x_coord);dbg_n(p->y_coord);
 dbg_n(w->x_coord);dbg_n(w->y_coord);
@@ -14207,7 +14233,7 @@ dbg_close_t; dbg_comma;dbg_nl;
   set_number_from_of_the_way(y1a, t, y0, y1);
   set_number_from_of_the_way(y1,  t, y1, y2);
   set_number_from_of_the_way(y2a, t, y1a, y1);
-#ifdef DEBUGENVELOPE 
+#ifdef DEBUGENVELOPE
 dbg_key(t <= fraction_one_t);dbg_open_t;dbg_nl;
 dbg_n(p->x_coord);dbg_n(p->y_coord);
 dbg_n(t);
@@ -14245,7 +14271,7 @@ dbg_close_t; dbg_comma;dbg_nl;
     mp_fin_offset_prep (mp, r, ww, x0, x1, x2, y0, y1, y2, -1, (-1 - turn_amt));
   }
 }
-#ifdef DEBUGENVELOPE 
+#ifdef DEBUGENVELOPE
 dbg_key(end Complete the offset splitting process);dbg_open_t;dbg_nl;
 dbg_n(w->x_coord);dbg_n(w->y_coord);
 dbg_n(w0->x_coord);dbg_n(w0->y_coord);
@@ -14278,7 +14304,7 @@ crossing and the first crossing cannot be antiparallel.
 @<Find the first |t| where $d(t)$ crosses $d_{k-1}$ or set...@>=
 #ifdef DEBUGENVELOPE
 dbg_key(Find the first |t| where);dbg_open_t;dbg_nl;
-#endif 
+#endif
 crossing_point (t, t0, t1, t2);
 if (turn_amt >= 0) {
   if (number_negative(t2)) {
@@ -14316,7 +14342,7 @@ if (turn_amt >= 0) {
 #ifdef DEBUGENVELOPE
 dbg_n(t);
 dbg_close_t; dbg_comma;dbg_nl;
-#endif 
+#endif
 
 
 @ @<Other local variables for |offset_prep|@>=
@@ -19845,6 +19871,7 @@ is less than |loop_text|.
 @ @<Run a script@>=
 if (s != NULL) {
     int k ;
+    mp_value new_expr;
     size_t size = strlen(s);
     memset(&new_expr,0,sizeof(mp_value));
     new_number(new_expr.data.n);
@@ -19860,7 +19887,6 @@ if (s != NULL) {
     }
     limit = (halfword) k;
     (void) memcpy ((mp->buffer + mp->first), s, size);
-    free(s);
     mp->buffer[limit] = xord ('%');
     mp->first = (size_t) (limit + 1);
     loc = start;
@@ -19891,26 +19917,42 @@ if (s != NULL) {
     } else {
         mp_back_input (mp);
         if (cur_exp_str ()->len > 0) {
-            mp_value new_expr;
             char *s = mp->run_script(mp,(const char*) cur_exp_str()->str) ;
             @<Run a script@>
+            free(s);
         }
     }
 }
 
-@ @<Pass btex ... etex to script@>=
+@ The |texscriptmode| parameter controls how spaces and newlines get honoured in
+|btex| or |verbatimtex| ... |etex|. The default value is~1. Possible values are:
+0: no newlines, 1: newlines in |verbatimtex|, 2: newlines in |verbatimtex| and
+|etex|, 3: no leading and trailing strip in |verbatimtex|, 4: no leading and
+trailing strip in |verbatimtex| and |btex|. That way the Lua handler can do what
+it likes. An |etex| has to be followed by a space or |;| or be at the end of a
+line and preceded by a space or at the beginning of a line.
+
+@<Pass btex ... etex to script@>=
 {
-    int first ;
-    while ((loc < limit - 4) && (mp->buffer[loc] == ' ')) {
+    char *txt = NULL;
+    char *ptr = NULL;
+    int slin = line;
+    int size = 0;
+    int done = 0;
+    int mode = round_unscaled(internal_value(mp_texscriptmode)) ; /* default: 1 */
+    int verb = cur_mod() == verbatim_code;
+    int first;
+    /* we had a (mandate) trailing space */
+    if (loc <= limit && mp->char_class[mp->buffer[loc]] == space_class) {
         incr(loc);
+    } else {
+        /* maybe issue an error message and quit */
     }
-    first = loc ;
-    if (mp->buffer[loc-1] == ' ') {
-        decr(loc);
-    }
-    while (loc < limit - 5) {
-        if (mp->buffer[loc] == ' ') {
-            incr(loc);
+    /* we loop over lines */
+    first = loc;
+    while (1) {
+        /* we don't need to check when we have less than 4 characters left */
+        if (loc < limit - 4) {
             if (mp->buffer[loc] == 'e') {
                 incr(loc);
                 if (mp->buffer[loc] == 't') {
@@ -19918,39 +19960,135 @@ if (s != NULL) {
                     if (mp->buffer[loc] == 'e') {
                         incr(loc) ;
                         if (mp->buffer[loc] == 'x') {
-                            /* start action */
-                            char *s, *txt ;
-                            int size ;
-                            mp_value new_expr;
-                            size = loc - first + 1 - 4 ;
-                            if (size < 0) {
-                                size = 0 ;
-                            } else {
-                                while ((size > 1) && (mp->buffer[first+size-1] == ' ')) {
-                                    decr(size);
-                                }
+                            /* let's see if we have the right boundary */
+                            if (first == (loc - 3)) {
+                                /* when we're at the start of a line no leading space is required */
+                                done = 1;
+                            } else if (mp->char_class[mp->buffer[loc - 4]] == space_class) {
+                                /* when we're beyond the start of a line a leading space is required */
+                                done = 2;
                             }
-                            txt = malloc(size+1);
-                            if (size > 0) {
-                                (void) memcpy (txt, mp->buffer + first, size);
+                            if (done) {
+                                if ((loc + 1) <= limit) {
+                                    quarterword c = mp->char_class[mp->buffer[loc + 1]] ;
+                                    if (c != letter_class) {
+                                        incr(loc) ;
+                                        /* we're past the 'x' */
+                                        break;
+                                    } else {
+                                        /* this is no valid etex */
+                                        done = 0;
+                                    }
+                                } else {
+                                    /* when we're at the end of a line we're ok */
+                                    incr(loc) ;
+                                    /* we're past the 'x' */
+                                    break;
+                                }
                             }
-                            txt[size] = '\0';
-                            incr(loc);
-                            s = mp->make_text(mp,txt,(cur_mod() == verbatim_code)) ; /* we could pass the size */
-                            @<Run a script@>
-                            /* done */
-                            free(txt);
-                            break ;
-                        } else {
-                      //      decr(loc) ;
                         }
                     }
                 }
             }
+        }
+        /* no etex seen (yet) */
+        if (loc >= limit) {
+            if (size) {
+                txt = realloc(txt, size + limit - first + 1);
+            } else {
+                txt = malloc(limit - first + 1);
+            }
+            (void) memcpy (txt + size, mp->buffer + first, limit - first);
+            size += limit - first + 1;
+            if (mode <= 0) {
+                txt[size - 1] = ' ';
+            } else if (verb) {
+                /* modes >= 1 permit a newline in verbatimtex */
+                txt[size - 1] = '\n';
+            } else if (mode >= 2) {
+                /* modes >= 2 permit a newline in btex */
+                txt[size - 1] = '\n';
+            } else {
+                txt[size - 1] = ' ';
+            }
+            if (move_to_next_line(mp)) {
+                /* we abort the scanning */
+                goto FATAL_ERROR;
+            }
+            first = loc;
         } else {
             incr(loc);
         }
     }
+    if (done) {
+        /* we're past the 'x' */
+        int l = loc - 5 ; // 4
+        int n = l - first + 1 ;
+        /* we're before the 'etex' */
+        if (done == 2) {
+            /* we had ' etex' */
+            l -= 1;
+            n -= 1;
+            /* we're before the ' etex' */
+        }
+        if (size) {
+            txt = realloc(txt, size + n + 1);
+        } else {
+            txt = malloc(n + 1);
+        }
+        (void) memcpy (txt + size, mp->buffer + first, n); /* 0 */
+        size += n;
+        if (verb && mode >= 3) {
+            /* don't strip verbatimtex */
+            txt[size] = '\0';
+            ptr = txt;
+        } else if (mode >= 4) {
+            /* don't strip btex */
+            txt[size] = '\0';
+            ptr = txt;
+        } else {
+            /* strip trailing whitespace, we have a \0 so we're one off  */
+         /* while ((size > 1) && (mp->char_class[(ASCII_code) txt[size-2]] == space_class || txt[size-2] == '\n')) { */
+            while ((size > 1) && (mp->char_class[(ASCII_code) txt[size-1]] == space_class || txt[size-1] == '\n')) {
+                decr(size);
+            }
+            /* prune the string */
+            txt[size] = '\0';
+            /* strip leading whitespace */
+            ptr = txt;
+            while ((size > 1) && (mp->char_class[(ASCII_code) ptr[0]] == space_class || ptr[0] == '\n')) {
+                incr(ptr);
+                decr(size);
+            }
+        }
+        /* action */
+        {
+            char *s = mp->make_text(mp,ptr,verb) ;
+            @<Run a script@>
+            free(s);
+        }
+        free(txt);
+        /* really needed */
+        mp_get_next(mp);
+        return;
+    }
+    /*
+        we don't recover because in practice the graphic will be broken anyway and
+        we're not really interacting in mplib .. just fix the input
+    */
+    FATAL_ERROR:
+    {
+        /* line numbers are not always meaningfull so we can get a 0 reported */
+        char msg[256];
+        const char *hlp[] = { "An 'etex' is missing at this input level, nothing gets done.", NULL };
+        if (slin > 0) {
+            mp_snprintf(msg, 256, "No matching 'etex' for '%stex'.", verb ? "verbatim" : "b");
+        } else {
+            mp_snprintf(msg, 256, "No matching 'etex' for '%stex' in line %d.", verb ? "verbatim" : "b",slin);
+        }
+        mp_error (mp, msg, hlp, false);
+        free(txt);
+    }
 }
 
 @ @<Put a maketext result string into the input buffer@>=
@@ -19964,7 +20102,7 @@ if (s != NULL) {
         mp_value new_expr;
         const char *hlp[] = {
            "I'm going to flush this expression, since",
-           "makete should be followed by a known string.",
+           "maketext should be followed by a known string.",
            NULL };
         memset(&new_expr,0,sizeof(mp_value));
         new_number(new_expr.data.n);
@@ -19976,9 +20114,9 @@ if (s != NULL) {
     } else {
         mp_back_input (mp);
         if (cur_exp_str ()->len > 0) {
-            mp_value new_expr;
             char *s = mp->make_text(mp,(const char*) cur_exp_str()->str,0) ;
             @<Run a script@>
+            free(s);
         }
     }
 }
@@ -23295,7 +23433,7 @@ RESTART:
 
       q = mp_get_value_node (mp);
       mp_name_type (q) = mp_capsule;
-      if (cur_cmd() == mp_comma) { 
+      if (cur_cmd() == mp_comma) {
         mp_init_color_node (mp, q);
         r = value_node (q);
         mp_stash_in (mp, y_part (r));
@@ -23321,7 +23459,7 @@ RESTART:
         }
         mp_stash_in (mp, blue_part (r));
 
-        if (cur_cmd() == mp_comma) { 
+        if (cur_cmd() == mp_comma) {
           mp_node t;      /* a token */
           mp_init_cmykcolor_node (mp, q);
           t = value_node (q);
@@ -23337,13 +23475,13 @@ RESTART:
             set_dep_list (cyan_part(t),dep_list ((mp_value_node) red_part(r)));
             set_prev_dep (cyan_part(t),prev_dep ((mp_value_node) red_part(r)));
             set_mp_link (prev_dep (cyan_part(t)), (mp_node) cyan_part(t));
-          }		
+          }
 	  if ( ((mp_type (magenta_part (t))) != mp_independent) && ((mp_type (magenta_part (t))) != mp_known) ) {
      	     /* Copy the dep list */
             set_dep_list (magenta_part(t),dep_list ((mp_value_node) green_part(r)));
             set_prev_dep (magenta_part(t),prev_dep ((mp_value_node) green_part(r)));
             set_mp_link (prev_dep (magenta_part(t)), (mp_node) magenta_part(t));
-          }		
+          }
 	  if ( ((mp_type (yellow_part (t))) != mp_independent) && ((mp_type (yellow_part (t))) != mp_known)) {
      	     /* Copy the dep list */
             set_dep_list (yellow_part(t),dep_list ((mp_value_node) blue_part(r)));
@@ -28985,7 +29123,7 @@ static void mp_set_up_boundingpath (MP mp, mp_node p) {
   unsigned char ljoin, lcap;
   mp_number miterlim;
   mp_knot q = mp_copy_path (mp, cur_exp_knot ());       /* the original path */
-  mp_knot pen; 
+  mp_knot pen;
   mp_knot qq;
 
   new_number(miterlim);
@@ -30671,8 +30809,8 @@ void mp_show_library_versions (void) {
   fprintf(stdout, "Compiled with pixman %s; using %s\n",COMPILED_PIXMAN_VERSION_STRING, pixman_version_string());
   fprintf(stdout, "Compiled with libpng %s; using %s\n", PNG_LIBPNG_VER_STRING, png_libpng_ver);
   fprintf(stdout, "Compiled with zlib %s; using %s\n", ZLIB_VERSION, zlibVersion());
-  fprintf(stdout, "Compiled with mpfr %s; using %s\n", MPFR_VERSION_STRING, mpfr_get_version());
-  fprintf(stdout, "Compiled with gmp %d.%d.%d; using %s\n\n", __GNU_MP_VERSION, __GNU_MP_VERSION_MINOR, __GNU_MP_VERSION_PATCHLEVEL, gmp_version);
+  fprintf(stdout, "Compiled with mpfr %s; using %s\n", COMPILED_MPFR_VERSION_STRING, mpfr_get_version());
+  fprintf(stdout, "Compiled with gmp %d.%d.%d; using %s\n\n", COMPILED__GNU_MP_VERSION, COMPILED__GNU_MP_VERSION_MINOR, COMPILED__GNU_MP_VERSION_PATCHLEVEL, COMPILED_gmp_version);
 }
 
 @ @<Exported function headers@>=
@@ -33230,7 +33368,7 @@ We may need to cancel skips that span more than 127 lig/kern steps.
 
 
 @ The header could contain ASCII zeroes, so can't use |strdup|.
-The index |j| can be beyond the index |header_last|, hence we 
+The index |j| can be beyond the index |header_last|, hence we
 have to sure  to update the end of stream marker to reflect the
 actual position.
 
@@ -34555,8 +34693,9 @@ extreme cases so it may have to be shortened on some systems.
 
 @<Use |c| to compute the file extension |s|@>=
 {
-  s = xmalloc (7, 1);
-  mp_snprintf (s, 7, ".%i", (int) c);
+  s = xmalloc (12, 1);
+  mp_snprintf (s, 12, ".%i", (int) c);
+  s[7]='\0';
 }
 
 
diff --git a/texk/web2c/mplibdir/mpmath.w b/texk/web2c/mplibdir/mpmath.w
index 772f8042b..6c0ee6d00 100644
--- a/texk/web2c/mplibdir/mpmath.w
+++ b/texk/web2c/mplibdir/mpmath.w
@@ -1,4 +1,4 @@
-% $Id$
+% $Id: mpmath.w 2118 2017-02-15 17:49:54Z luigi $
 %
 % This file is part of MetaPost;
 % the MetaPost program is in the public domain.
diff --git a/texk/web2c/mplibdir/mpmathbinary.w b/texk/web2c/mplibdir/mpmathbinary.w
index c6df9ced4..f3d9ed947 100644
--- a/texk/web2c/mplibdir/mpmathbinary.w
+++ b/texk/web2c/mplibdir/mpmathbinary.w
@@ -39,6 +39,19 @@
 #include "mpmp.h" /* internal header */
 #include <gmp.h>
 #include <mpfr.h>
+
+#ifdef HAVE_CONFIG_H
+#include <gmp/config.h>
+const char * const COMPILED_gmp_version  = VERSION;
+#else
+const char * const COMPILED_gmp_version  = "unknown";
+#endif
+
+const char *COMPILED_MPFR_VERSION_STRING = MPFR_VERSION_STRING;
+int COMPILED__GNU_MP_VERSION = __GNU_MP_VERSION ;
+int COMPILED__GNU_MP_VERSION_MINOR = __GNU_MP_VERSION_MINOR ;
+int COMPILED__GNU_MP_VERSION_PATCHLEVEL = __GNU_MP_VERSION_PATCHLEVEL ;
+
 @<Internal library declarations@>;
 #endif
 
diff --git a/texk/web2c/mplibdir/mpmathdouble.w b/texk/web2c/mplibdir/mpmathdouble.w
index 4834876e5..cb1496936 100644
--- a/texk/web2c/mplibdir/mpmathdouble.w
+++ b/texk/web2c/mplibdir/mpmathdouble.w
@@ -1,4 +1,4 @@
-% $Id$
+% $Id: mpmathdouble.w 2118 2017-02-15 17:49:54Z luigi $
 %
 % This file is part of MetaPost;
 % the MetaPost program is in the public domain.
--- source/texk/web2c/pdftexdir/pdftoepdf.cc.orig	2020-11-07 13:23:37.163328041 +0100
+++ source/texk/web2c/pdftexdir/pdftoepdf.cc	2020-11-07 13:39:34.880565627 +0100
@@ -120,7 +120,7 @@
 
 static InObj *inObjList;
 static UsedEncoding *encodingList;
-static GBool isInit = gFalse;
+static bool isInit = false;
 
 // --------------------------------------------------------------------
 // Maintain list of open embedded PDF files
@@ -275,7 +275,7 @@
 
 static void copyObject(Object *);
 
-static void copyName(char *s)
+static void copyName(const char *s)
 {
     pdf_puts("/");
     for (; *s != 0; s++) {
@@ -292,7 +292,7 @@
     Object obj1;
     copyName(obj->dictGetKey(i));
     pdf_puts(" ");
-    obj1 = obj->dictGetValNF(i);
+    obj1 = obj->dictGetValNF(i).copy();
     copyObject(&obj1);
     pdf_puts("\n");
 }
@@ -310,7 +310,7 @@
 static void copyFontDict(Object * obj, InObj * r)
 {
     int i, l;
-    char *key;
+    const char *key;
     if (!obj->isDict())
         pdftex_fail("PDF inclusion: invalid dict type <%s>",
                     obj->getTypeName());
@@ -351,7 +351,7 @@
                     obj->getTypeName());
     pdf_puts("/ProcSet [ ");
     for (i = 0, l = obj->arrayGetLength(); i < l; ++i) {
-        procset = obj->arrayGetNF(i);
+        procset = obj->arrayGetNF(i).copy();
         if (!procset.isName())
             pdftex_fail("PDF inclusion: invalid ProcSet entry type <%s>",
                         procset.getTypeName());
@@ -382,7 +382,7 @@
     return false;
 }
 
-static void copyFont(char *tag, Object * fontRef)
+static void copyFont(const char *tag, Object * fontRef)
 {
     Object fontdict, subtype, basefont, fontdescRef, fontdesc, charset,
         stemV;
@@ -406,7 +406,7 @@
     if (fontdict.isDict()) {
         subtype = fontdict.dictLookup("Subtype");
         basefont = fontdict.dictLookup("BaseFont");
-        fontdescRef = fontdict.dictLookupNF("FontDescriptor");
+        fontdescRef = fontdict.dictLookupNF("FontDescriptor").copy();
         if (fontdescRef.isRef()) {
             fontdesc = fontdescRef.fetch(xref);
         }
@@ -427,7 +427,7 @@
         charset = fontdesc.dictLookup("CharSet");
         if (!charset.isNull() &&
             charset.isString() && is_subsetable(fontmap))
-            epdf_mark_glyphs(fd, charset.getString()->getCString());
+            epdf_mark_glyphs(fd, charset.getString()->c_str());
         else
             embed_whole_font(fd);
         addFontDesc(fontdescRef.getRef(), fd);
@@ -452,7 +452,7 @@
                     obj->getTypeName());
     pdf_puts("/Font << ");
     for (i = 0, l = obj->dictGetLength(); i < l; ++i) {
-        fontRef = obj->dictGetValNF(i);
+        fontRef = obj->dictGetValNF(i).copy();
         if (fontRef.isRef())
             copyFont(obj->dictGetKey(i), &fontRef);
         else if (fontRef.isDict()) {   // some programs generate pdf with embedded font object
@@ -467,7 +467,7 @@
     pdf_puts(">>\n");
 }
 
-static void copyOtherResources(Object * obj, char *key)
+static void copyOtherResources(Object * obj, const char *key)
 {
     // copies all other resources (write_epdf handles Fonts and ProcSets),
 
@@ -554,8 +554,8 @@
     Object obj1;
     int i, l, c;
     Ref ref;
-    char *p;
-    GString *s;
+    const char *p;
+    const GString *s;
     if (obj->isBool()) {
         pdf_printf("%s", obj->getBool()? "true" : "false");
     } else if (obj->isInt()) {
@@ -566,7 +566,7 @@
         pdf_printf("%s", convertNumToPDF(obj->getNum()));
     } else if (obj->isString()) {
         s = obj->getString();
-        p = s->getCString();
+        p = s->c_str();
         l = s->getLength();
         if (strlen(p) == (unsigned int) l) {
             pdf_puts("(");
@@ -595,7 +595,7 @@
     } else if (obj->isArray()) {
         pdf_puts("[");
         for (i = 0, l = obj->arrayGetLength(); i < l; ++i) {
-            obj1 = obj->arrayGetNF(i);
+            obj1 = obj->arrayGetNF(i).copy();
             if (!obj1.isName())
                 pdf_puts(" ");
             copyObject(&obj1);
@@ -664,7 +664,7 @@
                     ("PDF inclusion: CID fonts are not supported"
                      " (try to disable font replacement to fix this)");
             }
-            if ((s = ((Gfx8BitFont *) r->font)->getCharName(i)) != 0)
+            if ((s = (char *) ((Gfx8BitFont *) r->font)->getCharName(i)) != 0)
                 glyphNames[i] = s;
             else
                 glyphNames[i] = notdef;
@@ -683,7 +683,7 @@
 }
 
 // get the pagebox according to the pagebox_spec
-static PDFRectangle *get_pagebox(Page * page, int pagebox_spec)
+static const PDFRectangle *get_pagebox(Page * page, int pagebox_spec)
 {
     if (pagebox_spec == pdfboxspecmedia)
         return page->getMediaBox();
@@ -715,7 +715,7 @@
 {
     PdfDocument *pdf_doc;
     Page *page;
-    PDFRectangle *pagebox;
+    const PDFRectangle *pagebox;
 #ifdef POPPLER_VERSION
     int pdf_major_version_found, pdf_minor_version_found;
 #else
@@ -723,9 +723,9 @@
 #endif
     // initialize
     if (!isInit) {
-        globalParams = new GlobalParams();
-        globalParams->setErrQuiet(gFalse);
-        isInit = gTrue;
+        globalParams = std::unique_ptr<GlobalParams>(new GlobalParams());
+        globalParams->setErrQuiet(false);
+        isInit = true;
     }
     // open PDF file
     pdf_doc = find_add_document(image_name);
@@ -757,15 +757,14 @@
     if (page_name) {
         // get page by name
         GString name(page_name);
-        LinkDest *link = pdf_doc->doc->findDest(&name);
+        std::unique_ptr<LinkDest> link = pdf_doc->doc->findDest(&name);
         if (link == 0 || !link->isOk())
             pdftex_fail("PDF inclusion: invalid destination <%s>", page_name);
         Ref ref = link->getPageRef();
-        page_num = pdf_doc->doc->getCatalog()->findPage(ref.num, ref.gen);
+        page_num = pdf_doc->doc->getCatalog()->findPage(ref);
         if (page_num == 0)
             pdftex_fail("PDF inclusion: destination is not a page <%s>",
                         page_name);
-        delete link;
     } else {
         // get page by number
         if (page_num <= 0 || page_num > epdf_num_pages)
@@ -822,7 +821,7 @@
     Object groupDict;
     bool writeSepGroup = false;
     Object info;
-    char *key;
+    const char *key;
     char s[256];
     int i, l;
     int rotate;
@@ -849,7 +848,7 @@
     pageObj = xref->fetch(pageRef->num, pageRef->gen);
     pageDict = pageObj.getDict();
     rotate = page->getRotate();
-    PDFRectangle *pagebox;
+    const PDFRectangle *pagebox;
     // write the Page header
     pdf_puts("/Type /XObject\n");
     pdf_puts("/Subtype /Form\n");
@@ -921,13 +920,13 @@
     pdf_puts(stripzeros(s));
 
     // Metadata validity check (as a stream it must be indirect)
-    dictObj = pageDict->lookupNF("Metadata");
+    dictObj = pageDict->lookupNF("Metadata").copy();
     if (!dictObj.isNull() && !dictObj.isRef())
         pdftex_warn("PDF inclusion: /Metadata must be indirect object");
 
     // copy selected items in Page dictionary except Resources & Group
     for (i = 0; pageDictKeys[i] != NULL; i++) {
-        dictObj = pageDict->lookupNF(pageDictKeys[i]);
+        dictObj = pageDict->lookupNF(pageDictKeys[i]).copy();
         if (!dictObj.isNull()) {
             pdf_newline();
             pdf_printf("/%s ", pageDictKeys[i]);
@@ -936,7 +935,7 @@
     } 
 
     // handle page group
-    dictObj = pageDict->lookupNF("Group");
+    dictObj = pageDict->lookupNF("Group").copy();
     if (!dictObj.isNull()) {
         if (pdfpagegroupval == 0) { 
             // another pdf with page group was included earlier on the
@@ -977,8 +976,8 @@
             }
             l = dic1.getLength();
             for (i = 0; i < l; i++) {
-                groupDict.dictAdd(copyString(dic1.getKey(i)),
-                                  dic1.getValNF(i));
+                groupDict.dictAdd(dic1.getKey(i),
+                                  dic1.getValNF(i).copy());
             }
 // end modification
             pdf_printf("/Group %ld 0 R\n", (long)pdfpagegroupval);
@@ -1108,6 +1107,6 @@
             delete_document(p);
         }
         // see above for globalParams
-        delete globalParams;
+        globalParams.reset();
     }
 }
--- source/texk/web2c/pdftexdir/pdftosrc.cc.orig	2020-11-07 13:23:37.163328041 +0100
+++ source/texk/web2c/pdftexdir/pdftosrc.cc	2020-11-07 13:40:55.764601960 +0100
@@ -24,6 +24,15 @@
 POPPLER_VERSION should be defined.
 */
 
+#ifdef POPPLER_VERSION
+#include <poppler-config.h>
+#define xpdfVersion POPPLER_VERSION
+#define xpdfString "poppler"
+#else
+#include <xpdf/config.h>        /* just to get the xpdf version */
+#define xpdfString "xpdf"
+#endif
+
 #include <w2c/config.h>
 
 #include <stdlib.h>
@@ -79,7 +88,7 @@
         exit(1);
     }
     fileName = new GString(argv[1]);
-    globalParams = new GlobalParams();
+    globalParams = std::unique_ptr<GlobalParams>(new GlobalParams());
     doc = new PDFDoc(fileName);
     if (!doc->isOk()) {
         fprintf(stderr, "Invalid PDF file\n");
@@ -100,7 +109,7 @@
     if (objnum == 0) {
         srcStream = catalogDict.dictLookup("SourceObject");
         static char const_SourceFile[] = "SourceFile";
-        if (!srcStream.isStream(const_SourceFile)) {
+        if (!(srcStream.isStream() && srcStream.getDict()->is(const_SourceFile))) {
             fprintf(stderr, "No SourceObject found\n");
             exit(1);
         }
@@ -109,7 +118,7 @@
             fprintf(stderr, "No SourceName found\n");
             exit(1);
         }
-        outname = srcName.getString()->getCString();
+        outname = srcName.getString()->c_str();
         // We cannot free srcName, as objname shares its string.
         // srcName.free();
     } else if (objnum > 0) {
@@ -118,7 +127,7 @@
             fprintf(stderr, "Not a Stream object\n");
             exit(1);
         }
-        sprintf(buf, "%s", fileName->getCString());
+        sprintf(buf, "%s", fileName->c_str());
         if ((p = strrchr(buf, '.')) == 0)
             p = strchr(buf, 0);
         if (objgen == 0)
@@ -128,7 +137,7 @@
         outname = buf;
     } else {                    // objnum < 0 means we are extracting the XRef table
         extract_xref_table = true;
-        sprintf(buf, "%s", fileName->getCString());
+        sprintf(buf, "%s", fileName->c_str());
         if ((p = strrchr(buf, '.')) == 0)
             p = strchr(buf, 0);
         sprintf(p, ".xref");
@@ -156,12 +165,11 @@
                         (e->type == xrefEntryFree ? "f" : "n"));
             else {              // e->offset is the object number of the object stream
                 Stream *str;
-                Lexer *lexer;
                 Parser *parser;
                 Object objStr, obj1, obj2;
                 int nObjects, first, n;
                 int localOffset = 0;
-                Guint firstOffset;
+                unsigned int firstOffset;
 
                 objStr = xref->fetch(e->offset, 0);
                 assert(objStr.isStream());
@@ -173,9 +181,8 @@
 
                 // parse the header: object numbers and offsets
                 objStr.streamReset();
-                str = new EmbedStream(objStr.getStream(), Object(objNull), gTrue, first);
-                lexer = new Lexer(xref, str);
-                parser = new Parser(xref, lexer, gFalse);
+                str = new EmbedStream(objStr.getStream(), Object(objNull), true, first);
+                parser = new Parser(xref, str, false);
                 for (n = 0; n < nObjects; ++n) {
                     obj1 = parser->getObj();
                     obj2 = parser->getObj();
@@ -207,5 +214,5 @@
         fprintf(stderr, "Cross-reference table extracted to %s\n", outname);
     fclose(outfile);
     delete doc;
-    delete globalParams;
+    globalParams.reset();
 }
diff -up source/texk/web2c/pdftexdir/utils.c.me source/texk/web2c/pdftexdir/utils.c
--- source/texk/web2c/pdftexdir/utils.c.me	2020-11-06 17:34:13.775699638 +0100
+++ source/texk/web2c/pdftexdir/utils.c	2020-11-06 17:37:29.022637825 +0100
@@ -32,14 +32,6 @@ with this program.  If not, see <http://
 #include <zlib.h>
 #include "ptexlib.h"
 #include <png.h>
-#ifdef POPPLER_VERSION
-#include <poppler-config.h>
-#define xpdfVersion POPPLER_VERSION
-#define xpdfString "poppler"
-#else
-#include <xpdf/config.h>        /* just to get the xpdf version */
-#define xpdfString "xpdf"
-#endif
 
 #define check_nprintf(size_get, size_want) \
     if ((unsigned)(size_get) >= (unsigned)(size_want)) \
@@ -977,12 +969,10 @@ void initversionstring(char **versions)
 {
     const_string fmt =
                     "Compiled with libpng %s; using libpng %s\n"
-                    "Compiled with zlib %s; using zlib %s\n"
-                    "Compiled with %s version %s\n";
+                    "Compiled with zlib %s; using zlib %s\n";
     size_t len = strlen(fmt)
                     + strlen(PNG_LIBPNG_VER_STRING) + strlen(png_libpng_ver)
                     + strlen(ZLIB_VERSION) + strlen(zlib_version)
-                    + strlen(xpdfString) + strlen(xpdfVersion)
                     + 1;
 
     /* len will be more than enough, because of the placeholder chars in fmt
@@ -990,7 +980,7 @@ void initversionstring(char **versions)
     *versions = xmalloc(len);
     sprintf(*versions, fmt,
                     PNG_LIBPNG_VER_STRING, png_libpng_ver,
-                    ZLIB_VERSION, zlib_version, xpdfString, xpdfVersion);
+                    ZLIB_VERSION, zlib_version);
 }
 
 
diff -up source/texk/web2c/luatexdir/luamd5/md5lib.c.me source/texk/web2c/luatexdir/luamd5/md5lib.c
diff -up source/texk/web2c/mplibdir/mpmathbinary.w.me source/texk/web2c/mplibdir/mpmathbinary.w
--- source/texk/web2c/mplibdir/mpmathbinary.w.me	2020-11-07 13:48:29.165195061 +0100
+++ source/texk/web2c/mplibdir/mpmathbinary.w	2020-11-07 13:50:00.711463667 +0100
@@ -41,8 +41,9 @@
 #include <mpfr.h>
 
 #ifdef HAVE_CONFIG_H
-#include <gmp/config.h>
-const char * const COMPILED_gmp_version  = VERSION;
+#define MP_STR_HELPER(x) #x
+#define MP_STR(x) MP_STR_HELPER(x)
+const char * const COMPILED_gmp_version  = MP_STR(__GNU_MP_VERSION) "." MP_STR( __GNU_MP_VERSION_MINOR) "." MP_STR(__GNU_MP_VERSION_PATCHLEVEL);
 #else
 const char * const COMPILED_gmp_version  = "unknown";
 #endif
diff -up source/texk/web2c/pdftexdir/pdftoepdf.cc.me source/texk/web2c/pdftexdir/pdftoepdf.cc
--- source/texk/web2c/pdftexdir/pdftoepdf.cc.me	2020-11-07 13:52:29.288114063 +0100
+++ source/texk/web2c/pdftexdir/pdftoepdf.cc	2020-11-07 13:54:11.092270259 +0100
@@ -418,7 +418,7 @@ static void copyFont(const char *tag, Ob
         && fontdescRef.isRef()
         && fontdesc.isDict()
         && embeddableFont(&fontdesc)
-        && (fontmap = lookup_fontmap(basefont.getName())) != NULL) {
+        && (fontmap = lookup_fontmap((char *)basefont.getName())) != NULL) {
         // round /StemV value, since the PDF input is a float
         // (see Font Descriptors in PDF reference), but we only store an
         // integer, since we don't want to change the struct.
@@ -427,7 +427,7 @@ static void copyFont(const char *tag, Ob
         charset = fontdesc.dictLookup("CharSet");
         if (!charset.isNull() &&
             charset.isString() && is_subsetable(fontmap))
-            epdf_mark_glyphs(fd, charset.getString()->c_str());
+            epdf_mark_glyphs(fd, (char *)charset.getString()->c_str());
         else
             embed_whole_font(fd);
         addFontDesc(fontdescRef.getRef(), fd);
diff -up source/texk/web2c/pdftexdir/pdftosrc.cc.me source/texk/web2c/pdftexdir/pdftosrc.cc
--- source/texk/web2c/pdftexdir/pdftosrc.cc.me	2020-11-07 13:54:51.983680256 +0100
+++ source/texk/web2c/pdftexdir/pdftosrc.cc	2020-11-07 13:55:20.247155069 +0100
@@ -118,7 +118,7 @@ int main(int argc, char *argv[])
             fprintf(stderr, "No SourceName found\n");
             exit(1);
         }
-        outname = srcName.getString()->c_str();
+        outname = (char *)srcName.getString()->c_str();
         // We cannot free srcName, as objname shares its string.
         // srcName.free();
     } else if (objnum > 0) {
diff -up source/texk/web2c/xetexdir/pdfimage.cpp.me source/texk/web2c/xetexdir/pdfimage.cpp
--- source/texk/web2c/xetexdir/pdfimage.cpp.me	2020-11-07 19:05:23.805273334 +0100
+++ source/texk/web2c/xetexdir/pdfimage.cpp	2020-11-07 19:06:44.778390280 +0100
@@ -79,24 +79,26 @@ pdf_get_rect(char* filename, int page_nu
 	Page*		page = doc->getCatalog()->getPage(page_num);
 
 	PDFRectangle*	r;
+	const PDFRectangle*  cr;
 	switch (pdf_box) {
 		default:
 		case pdfbox_crop:
-			r = page->getCropBox();
+			cr = page->getCropBox();
 			break;
 		case pdfbox_media:
-			r = page->getMediaBox();
+			cr = page->getMediaBox();
 			break;
 		case pdfbox_bleed:
-			r = page->getBleedBox();
+			cr = page->getBleedBox();
 			break;
 		case pdfbox_trim:
-			r = page->getTrimBox();
+			cr = page->getTrimBox();
 			break;
 		case pdfbox_art:
-			r = page->getArtBox();
+			cr = page->getArtBox();
 			break;
 	}
+	r = new PDFRectangle (cr->x1, cr->y1, cr->x2, cr->y2);
 
 	int RotAngle = 0;
 	RotAngle = (int)page->getRotate() % 360;
diff -up source/texk/web2c/xetexdir/XeTeX_ext.c.me source/texk/web2c/xetexdir/XeTeX_ext.c
--- source/texk/web2c/xetexdir/XeTeX_ext.c.me	2020-11-07 19:03:59.638390812 +0100
+++ source/texk/web2c/xetexdir/XeTeX_ext.c	2020-11-07 19:05:05.683581239 +0100
@@ -38,7 +38,6 @@ authorization from the copyright holders
 
 #include <w2c/config.h>
 
-#include <poppler-config.h>
 #include <png.h>
 #include <zlib.h>
 #include <graphite2/Font.h>
commit 91d642115acc57be0abfabf36567fb905dd67f30
Author: Luigi Scarso <luigi.scarso@gmail.com>
Date:   Wed Sep 5 21:32:42 2018 +0000

    pplib for luatex
    
    git-svn-id: svn://tug.org/texlive/trunk/Build/source@48592 c570f23f-e606-0410-a88d-b1316a301751

diff --git a/texk/web2c/luatexdir/luapplib/ppapi.h b/texk/web2c/luatexdir/luapplib/ppapi.h
new file mode 100644
index 000000000..6d591ca05
--- /dev/null
+++ b/texk/web2c/luatexdir/luapplib/ppapi.h
@@ -0,0 +1,391 @@
+
+#ifndef PP_API_H
+#define PP_API_H
+
+#include <stdint.h>
+#include <stddef.h>
+#include <string.h>
+
+#include "ppconf.h"
+
+#define pplib_version "v0.97"
+#define pplib_author "p.jackowski@gust.org.pl"
+
+/* types */
+
+typedef int64_t ppint;
+typedef size_t ppuint; // machine word
+
+typedef double ppnum;
+typedef char * ppname;
+typedef char * ppstring;
+
+typedef struct {
+  size_t size;
+  int flags;
+} _ppname;
+
+typedef struct {
+  size_t size;
+  int flags;
+} _ppstring;
+
+typedef struct ppobj ppobj;
+typedef struct ppref ppref;
+
+
+#if defined __arm__ || defined __ARM__ || defined ARM || defined __ARM || defined __arm || defined __ARM_ARCH ||defined __aarch64__ 
+typedef struct {
+  ppobj *data;
+  size_t size;
+  ppnum PPARRAY_ALIGNMENT;
+} pparray;
+#else
+typedef struct {
+  ppobj *data;
+  size_t size;
+} pparray;
+#endif
+
+
+#if defined __arm__ || defined __ARM__ || defined ARM || defined __ARM || defined __arm || defined __ARM_ARCH ||defined __aarch64__ 
+typedef struct {
+  ppobj *data;
+	ppname *keys;
+  size_t size;
+  ppnum PPDICT_ALIGNMENT;
+} ppdict;
+
+#else
+typedef struct {
+  ppobj *data;
+	ppname *keys;
+  size_t size;
+} ppdict;
+#endif
+
+
+typedef struct {
+  ppdict *dict;
+  void *input, *I;
+  size_t offset;
+  size_t length;
+  ppstring cryptkey;
+  int flags;
+} ppstream;
+
+#define PPSTREAM_COMPRESSED (1<<0)
+#define PPSTREAM_ENCRYPTED_AES (1<<1)
+#define PPSTREAM_ENCRYPTED_RC4 (1<<2)
+#define PPSTREAM_ENCRYPTED (PPSTREAM_ENCRYPTED_AES|PPSTREAM_ENCRYPTED_RC4)
+#define PPSTREAM_ENCRYPTED_OWN (1<<3)
+
+#define ppstream_compressed(stream) ((stream)->flags & PPSTREAM_COMPRESSED)
+#define ppstream_encrypted(stream) ((stream)->flags & PPSTREAM_ENCRYPTED)
+
+typedef enum {
+  PPNONE = 0,
+  PPNULL,
+  PPBOOL,
+  PPINT,
+  PPNUM,
+  PPNAME,
+  PPSTRING,
+  PPARRAY,
+  PPDICT,
+  PPSTREAM,
+  PPREF
+} ppobjtp;
+
+PPDEF extern const char * ppobj_kind[];
+
+struct ppobj {
+  ppobjtp type;
+  union {
+    ppint integer;
+    ppnum number;
+    ppname name;
+    ppstring string;
+    pparray *array;
+    ppdict *dict;
+    ppstream *stream;
+    ppref *ref;
+    void *any;
+  };
+};
+
+typedef struct ppxref ppxref;
+
+struct ppref {
+  ppobj object;
+  ppuint number, version;
+  size_t offset;
+  size_t length;
+  ppxref *xref;
+};
+
+typedef struct ppdoc ppdoc;
+
+/* object */
+
+#define ppobj_get_null(o) ((o)->type == PPNULL ? 1 : 0)
+#define ppobj_get_bool(o, v) ((o)->type == PPBOOL ? ((v = ((o)->integer != 0)), 1) : 0)
+#define ppobj_get_int(o, v) ((o)->type == PPINT ? ((v = (o)->integer), 1) : 0)
+#define ppobj_get_uint(o, v) ((o)->type == PPINT && (o)->integer >= 0 ? ((v = (ppuint)((o)->integer)), 1) : 0)
+#define ppobj_get_num(o, v) ((o)->type == PPNUM ? ((v = (o)->number), 1) : (((o)->type == PPINT ? ((v = (ppnum)((o)->integer)), 1) : 0)))
+#define ppobj_get_name(o) ((o)->type == PPNAME ? (o)->name : NULL)
+#define ppobj_get_string(o) ((o)->type == PPSTRING ? (o)->string : NULL)
+#define ppobj_get_array(o) ((o)->type == PPARRAY ? (o)->array : NULL)
+#define ppobj_get_dict(o) ((o)->type == PPDICT ? (o)->dict : NULL)
+#define ppobj_get_stream(o) ((o)->type == PPSTREAM ? (o)->stream : NULL)
+#define ppobj_get_ref(o) ((o)->type == PPREF ? (o)->ref : NULL)
+
+#define ppobj_rget_obj(o) ((o)->type == PPREF ? ppref_obj((o)->ref) : o)
+#define ppobj_rget_null(o) ((o)->type == PPNULL ? 1 : ((o)->type == PPREF ? ppobj_get_null(ppref_obj((o)->ref)) : 0))
+#define ppobj_rget_bool(o, v) ((o)->type == PPBOOL ? ((v = ((o)->integer != 0)), 1) : ((o)->type == PPREF ? ppobj_get_bool(ppref_obj((o)->ref), v) : 0))
+#define ppobj_rget_int(o, v) ((o)->type == PPINT ? ((v = (o)->integer), 1) : ((o)->type == PPREF ? ppobj_get_int(ppref_obj((o)->ref), v) : 0))
+#define ppobj_rget_uint(o, v) ((o)->type == PPINT && (o)->integer >= 0 ? ((v = (ppuint)((o)->integer)), 1) : ((o)->type == PPREF ? ppobj_get_uint(ppref_obj((o)->ref), v) : 0))
+#define ppobj_rget_num(o, v) ((o)->type == PPNUM ? ((v = (o)->number), 1) : (((o)->type == PPINT ? ((v = (ppnum)((o)->integer)), 1) : ((o)->type == PPREF ? ppobj_get_num(ppref_obj((o)->ref), v) : 0))))
+#define ppobj_rget_name(o) ((o)->type == PPNAME ? (o)->name : ((o)->type == PPREF ? ppobj_get_name(ppref_obj((o)->ref)) : NULL))
+#define ppobj_rget_string(o) ((o)->type == PPSTRING ? (o)->string : ((o)->type == PPREF ? ppobj_get_string(ppref_obj((o)->ref)) : NULL))
+#define ppobj_rget_array(o) ((o)->type == PPARRAY ? (o)->array : ((o)->type == PPREF ? ppobj_get_array(ppref_obj((o)->ref)) : NULL))
+#define ppobj_rget_dict(o) ((o)->type == PPDICT ? (o)->dict : ((o)->type == PPREF ? ppobj_get_dict(ppref_obj((o)->ref)) : NULL))
+#define ppobj_rget_stream(o) ((o)->type == PPSTREAM ? (o)->stream : ((o)->type == PPREF ? ppobj_get_stream(ppref_obj((o)->ref)) : NULL))
+#define ppobj_rget_ref(o) ((o)->type == PPREF ? (o)->ref : ((o)->type == PPREF ? ppobj_get_ref(ppref_obj((o)->ref)) : NULL))
+
+#define ppobj_get_bool_value(o) ((o)->type == PPBOOL ? ((o)->integer != 0) : 0)
+#define ppobj_get_int_value(o) ((o)->type == PPINT ? (o)->integer : 0)
+#define ppobj_get_num_value(o) ((o)->type == PPNUM  ? (o)->number : ((o)->type == PPINT  ? (ppnum)((o)->integer) : 0.0))
+
+/* name */
+
+#define ppname_is(name, s) (memcmp(name, s, sizeof("" s) - 1) == 0)
+#define ppname_eq(name, n) (memcmp(name, s, ppname_size(name)) == 0)
+
+#if defined __arm__ || defined __ARM__ || defined ARM || defined __ARM || defined __arm || defined __ARM_ARCH ||defined __aarch64__ 
+#define _ppname_ghost(name) (((const _ppname *)((void *)name)) - 1)
+#else
+#define _ppname_ghost(name) (((const _ppname *)(name)) - 1)
+#endif
+
+#define ppname_size(name) (_ppname_ghost(name)->size)
+#define ppname_exec(name) (_ppname_ghost(name)->flags & PPNAME_EXEC)
+
+#define PPNAME_ENCODED (1 << 0)
+#define PPNAME_DECODED (1 << 1)
+#define PPNAME_EXEC (1 << 1)
+
+PPAPI ppname ppname_decoded (ppname name);
+PPAPI ppname ppname_encoded (ppname name);
+
+/* string */
+
+#if defined __arm__ || defined __ARM__ || defined ARM || defined __ARM || defined __arm || defined __ARM_ARCH ||defined __aarch64__ 
+#define _ppstring_ghost(string) (((const _ppstring *)((void *)string)) - 1)
+#else
+#define _ppstring_ghost(string) (((const _ppstring *)(string)) - 1)
+#endif
+
+#define ppstring_size(string) (_ppstring_ghost(string)->size)
+
+#define PPSTRING_ENCODED (1 << 0)
+#define PPSTRING_DECODED (1 << 1)
+//#define PPSTRING_EXEC (1 << 2) // postscript only
+#define PPSTRING_PLAIN 0
+#define PPSTRING_BASE16 (1 << 3)
+#define PPSTRING_BASE85 (1 << 4)
+#define PPSTRING_UTF16BE (1 << 5)
+#define PPSTRING_UTF16LE (1 << 6)
+
+#define ppstring_type(string) (_ppstring_ghost(string)->flags & (PPSTRING_BASE16|PPSTRING_BASE85))
+#define ppstring_hex(string) (_ppstring_ghost(string)->flags & PPSTRING_BASE16)
+#define ppstring_utf(string) (_ppstring_ghost(string)->flags & (PPSTRING_UTF16BE|PPSTRING_UTF16LE))
+
+PPAPI ppstring ppstring_decoded (ppstring string);
+PPAPI ppstring ppstring_encoded (ppstring string);
+
+/* array */
+
+#define pparray_size(array) ((array)->size)
+#define pparray_at(array, index) ((array)->data + index)
+
+#define pparray_first(array, index, obj) ((index) = 0, (obj) = pparray_at(array,  0))
+#define pparray_next(index, obj) (++(index), ++(obj))
+
+#define pparray_get(array, index) (index < (array)->size ? pparray_at(array, index) : NULL)
+
+PPAPI ppobj * pparray_get_obj (pparray *array, size_t index);
+PPAPI int pparray_get_bool (pparray *array, size_t index, int *v);
+PPAPI int pparray_get_int (pparray *array, size_t index, ppint *v);
+PPAPI int pparray_get_uint (pparray *array, size_t index, ppuint *v);
+PPAPI int pparray_get_num (pparray *array, size_t index, ppnum *v);
+PPAPI ppname pparray_get_name (pparray *array, size_t index);
+PPAPI ppstring pparray_get_string (pparray *array, size_t index);
+PPAPI pparray * pparray_get_array (pparray *array, size_t index);
+PPAPI ppdict * pparray_get_dict (pparray *array, size_t index);
+//PPAPI ppstream * pparray_get_stream (pparray *array, size_t index);
+PPAPI ppref * pparray_get_ref (pparray *array, size_t index);
+
+PPAPI ppobj * pparray_rget_obj (pparray *array, size_t index);
+PPAPI int pparray_rget_bool (pparray *array, size_t index, int *v);
+PPAPI int pparray_rget_int (pparray *array, size_t index, ppint *v);
+PPAPI int pparray_rget_uint (pparray *array, size_t index, ppuint *v);
+PPAPI int pparray_rget_num (pparray *array, size_t index, ppnum *v);
+PPAPI ppname pparray_rget_name (pparray *array, size_t index);
+PPAPI ppstring pparray_rget_string (pparray *array, size_t index);
+PPAPI pparray * pparray_rget_array (pparray *array, size_t index);
+PPAPI ppdict * pparray_rget_dict (pparray *array, size_t index);
+PPAPI ppstream * pparray_rget_stream (pparray *array, size_t index);
+PPAPI ppref * pparray_rget_ref (pparray *array, size_t index);
+
+/* dict */
+
+#define ppdict_size(dict) ((dict)->size)
+#define ppdict_at(dict, index) ((dict)->data + index)
+#define ppdict_key(dict, index) ((dict)->keys[index])
+
+PPAPI ppobj * ppdict_get_obj (ppdict *dict, const char *name);
+PPAPI int ppdict_get_bool (ppdict *dict, const char *name, int *v);
+PPAPI int ppdict_get_int (ppdict *dict, const char *name, ppint *v);
+PPAPI int ppdict_get_uint (ppdict *dict, const char *name, ppuint *v);
+PPAPI int ppdict_get_num (ppdict *dict, const char *name, ppnum *v);
+PPAPI ppname ppdict_get_name (ppdict *dict, const char *name);
+PPAPI ppstring ppdict_get_string (ppdict *dict, const char *name);
+PPAPI pparray * ppdict_get_array (ppdict *dict, const char *name);
+PPAPI ppdict * ppdict_get_dict (ppdict *dict, const char *name);
+//PPAPI ppstream * ppdict_get_stream (ppdict *dict, const char *name);
+PPAPI ppref * ppdict_get_ref (ppdict *dict, const char *name);
+
+PPAPI ppobj * ppdict_rget_obj (ppdict *dict, const char *name);
+PPAPI int ppdict_rget_bool (ppdict *dict, const char *name, int *v);
+PPAPI int ppdict_rget_int (ppdict *dict, const char *name, ppint *v);
+PPAPI int ppdict_rget_uint (ppdict *dict, const char *name, ppuint *v);
+PPAPI int ppdict_rget_num (ppdict *dict, const char *name, ppnum *v);
+PPAPI ppname ppdict_rget_name (ppdict *dict, const char *name);
+PPAPI ppstring ppdict_rget_string (ppdict *dict, const char *name);
+PPAPI pparray * ppdict_rget_array (ppdict *dict, const char *name);
+PPAPI ppdict * ppdict_rget_dict (ppdict *dict, const char *name);
+PPAPI ppstream * ppdict_rget_stream (ppdict *dict, const char *name);
+PPAPI ppref * ppdict_rget_ref (ppdict *dict, const char *name);
+
+#define ppdict_first(dict, pkey, obj) (pkey = (dict)->keys, obj = (dict)->data)
+#define ppdict_next(pkey, obj) (++(pkey), ++(obj))
+
+/* stream */
+
+#define ppstream_dict(stream) ((stream)->dict)
+
+PPAPI uint8_t * ppstream_first (ppstream *stream, size_t *size, int decode);
+PPAPI uint8_t * ppstream_next (ppstream *stream, size_t *size);
+PPAPI uint8_t * ppstream_all (ppstream *stream, size_t *size, int decode);
+PPAPI void ppstream_done (ppstream *stream);
+
+PPAPI void ppstream_init_buffers (void);
+PPAPI void ppstream_free_buffers (void);
+
+/* ref */
+
+#define ppref_obj(ref) (&(ref)->object)
+
+/* xref */
+
+PPAPI ppxref * ppdoc_xref (ppdoc *pdf);
+PPAPI ppxref * ppxref_prev (ppxref *xref);
+PPAPI ppdict * ppxref_trailer (ppxref *xref);
+PPAPI ppdict * ppxref_catalog (ppxref *xref);
+PPAPI ppdict * ppxref_info (ppxref *xref);
+PPAPI ppref * ppxref_pages (ppxref *xref);
+PPAPI ppref * ppxref_find (ppxref *xref, ppuint refnumber);
+
+/* doc */
+
+PPAPI ppdoc * ppdoc_load (const char *filename);
+PPAPI ppdoc * ppdoc_mem (const void *data, size_t size);
+PPAPI void ppdoc_free (ppdoc *pdf);
+
+#define ppdoc_trailer(pdf) ppxref_trailer(ppdoc_xref(pdf))
+#define ppdoc_catalog(pdf) ppxref_catalog(ppdoc_xref(pdf))
+#define ppdoc_info(pdf) ppxref_info(ppdoc_xref(pdf))
+#define ppdoc_pages(pdf) ppxref_pages(ppdoc_xref(pdf))
+
+PPAPI ppuint ppdoc_page_count (ppdoc *pdf);
+PPAPI ppref * ppdoc_page (ppdoc *pdf, ppuint index);
+PPAPI ppref *  ppdoc_first_page (ppdoc *pdf);
+PPAPI ppref * ppdoc_next_page (ppdoc *pdf);
+
+PPAPI ppstream * ppcontents_first (ppdict *dict);
+PPAPI ppstream * ppcontents_next (ppdict *dict, ppstream *stream);
+
+/* crypt */
+
+typedef enum {
+  PPCRYPT_NONE = 0,
+  PPCRYPT_DONE = 1,
+  PPCRYPT_FAIL = -1,
+  PPCRYPT_PASS = -2
+} ppcrypt_status;
+
+PPAPI ppcrypt_status ppdoc_crypt_status (ppdoc *pdf);
+PPAPI ppcrypt_status ppdoc_crypt_pass (ppdoc *pdf, const void *userpass, size_t userpasslength, const void *ownerpass, size_t ownerpasslength);
+
+/* permission flags, effect in Acrobat File -> Properties -> Security tab */
+
+PPAPI ppint ppdoc_permissions (ppdoc *pdf);
+
+#define PPDOC_ALLOW_PRINT (1<<2)        // printing
+#define PPDOC_ALLOW_MODIFY (1<<3)       // filling form fields, signing, creating template pages
+#define PPDOC_ALLOW_COPY (1<<4)         // copying, copying for accessibility
+#define PPDOC_ALLOW_ANNOTS (1<<5)       // filling form fields, copying, signing
+#define PPDOC_ALLOW_EXTRACT (1<<9)      // contents copying for accessibility
+#define PPDOC_ALLOW_ASSEMBLY (1<<10)    // (no effect)
+#define PPDOC_ALLOW_PRINT_HIRES (1<<11) // (no effect)
+
+/* context */
+
+typedef struct ppcontext ppcontext;
+
+PPAPI ppcontext * ppcontext_new (void);
+PPAPI void ppcontext_done (ppcontext *context);
+PPAPI void ppcontext_free (ppcontext *context);
+
+/* contents parser */
+
+PPAPI ppobj * ppcontents_first_op (ppcontext *context, ppstream *stream, size_t *psize, ppname *pname);
+PPAPI ppobj * ppcontents_next_op (ppcontext *context, ppstream *stream, size_t *psize, ppname *pname);
+PPAPI ppobj * ppcontents_parse (ppcontext *context, ppstream *stream, size_t *psize);
+
+/* boxes and transforms */
+
+typedef struct {
+  ppnum lx, ly, rx, ry;
+} pprect;
+
+PPAPI pprect * pparray_to_rect (pparray *array, pprect *rect);
+PPAPI pprect * ppdict_get_rect (ppdict *dict, const char *name, pprect *rect);
+PPAPI pprect * ppdict_get_box (ppdict *dict, const char *name, pprect *rect);
+
+typedef struct {
+  ppnum xx, xy, yx, yy, x, y;
+} ppmatrix;
+
+PPAPI ppmatrix * pparray_to_matrix (pparray *array, ppmatrix *matrix);
+PPAPI ppmatrix * ppdict_get_matrix (ppdict *dict, const char *name, ppmatrix *matrix);
+
+/* logger */
+
+typedef void (*pplogger_callback) (const char *message, void *alien);
+PPAPI void pplog_callback (pplogger_callback logger, void *alien);
+PPAPI int pplog_prefix (const char *prefix);
+
+/* version */
+
+PPAPI const char * ppdoc_version_string (ppdoc *pdf);
+PPAPI int ppdoc_version_number (ppdoc *pdf, int *minor);
+
+/* doc info */
+
+PPAPI size_t ppdoc_file_size (ppdoc *pdf);
+PPAPI ppuint ppdoc_objects (ppdoc *pdf);
+PPAPI size_t ppdoc_memory (ppdoc *pdf, size_t *waste);
+
+#endif
diff --git a/texk/web2c/luatexdir/luapplib/pparray.c b/texk/web2c/luatexdir/luapplib/pparray.c
new file mode 100644
index 000000000..25e8c4950
--- /dev/null
+++ b/texk/web2c/luatexdir/luapplib/pparray.c
@@ -0,0 +1,146 @@
+
+#include "pplib.h"
+
+pparray * pparray_create (const ppobj *stackpos, size_t size, ppheap **pheap)
+{
+	pparray *array;
+	ppobj *data;
+  array = (pparray *)ppheap_take(pheap, sizeof(pparray) + size * sizeof(ppobj));
+  array->size = size;
+  array->data = data = (ppobj *)(array + 1);
+  memcpy(data, stackpos, size * sizeof(ppobj));
+  return array;
+}
+
+ppobj * pparray_get_obj (pparray *array, size_t index)
+{
+  return pparray_get(array, index);
+}
+
+ppobj * pparray_rget_obj (pparray *array, size_t index)
+{
+  ppobj *obj;
+  return (obj = pparray_get(array, index)) != NULL ? ppobj_rget_obj(obj) : NULL;
+}
+
+int pparray_get_bool (pparray *array, size_t index, int *v)
+{
+  ppobj *obj;
+  return (obj = pparray_get(array, index)) != NULL ? ppobj_get_bool(obj, *v) : 0;
+}
+
+int pparray_rget_bool (pparray *array, size_t index, int *v)
+{
+  ppobj *obj;
+  return (obj = pparray_get(array, index)) != NULL ? ppobj_rget_bool(obj, *v) : 0;
+}
+
+int pparray_get_int (pparray *array, size_t index, ppint *v)
+{
+  ppobj *obj;
+  return (obj = pparray_get(array, index)) != NULL ? ppobj_get_int(obj, *v) : 0;
+}
+
+int pparray_rget_int (pparray *array, size_t index, ppint *v)
+{
+  ppobj *obj;
+  return (obj = pparray_get(array, index)) != NULL ? ppobj_rget_int(obj, *v) : 0;
+}
+
+int pparray_get_uint (pparray *array, size_t index, ppuint *v)
+{
+  ppobj *obj;
+  return (obj = pparray_get(array, index)) != NULL ? ppobj_get_uint(obj, *v) : 0;
+}
+
+int pparray_rget_uint (pparray *array, size_t index, ppuint *v)
+{
+  ppobj *obj;
+  return (obj = pparray_get(array, index)) != NULL ? ppobj_rget_uint(obj, *v) : 0;
+}
+
+int pparray_get_num (pparray *array, size_t index, ppnum *v)
+{
+  ppobj *obj;
+  return (obj = pparray_get(array, index)) != NULL ? ppobj_get_num(obj, *v) : 0;
+}
+
+int pparray_rget_num (pparray *array, size_t index, ppnum *v)
+{
+  ppobj *obj;
+  return (obj = pparray_get(array, index)) != NULL ? ppobj_rget_num(obj, *v) : 0;
+}
+
+ppname pparray_get_name (pparray *array, size_t index)
+{
+  ppobj *obj;
+  return (obj = pparray_get(array, index)) != NULL ? ppobj_get_name(obj) : NULL;
+}
+
+ppname pparray_rget_name (pparray *array, size_t index)
+{
+  ppobj *obj;
+  return (obj = pparray_get(array, index)) != NULL ? ppobj_rget_name(obj) : NULL;
+}
+
+ppstring pparray_get_string (pparray *array, size_t index)
+{
+  ppobj *obj;
+  return (obj = pparray_get(array, index)) != NULL ? ppobj_get_string(obj) : NULL;
+}
+
+ppstring pparray_rget_string (pparray *array, size_t index)
+{
+  ppobj *obj;
+  return (obj = pparray_get(array, index)) != NULL ? ppobj_rget_string(obj) : NULL;
+}
+
+pparray * pparray_get_array (pparray *array, size_t index)
+{
+  ppobj *obj;
+  return (obj = pparray_get(array, index)) != NULL ? ppobj_get_array(obj) : NULL;
+}
+
+pparray * pparray_rget_array (pparray *array, size_t index)
+{
+  ppobj *obj;
+  return (obj = pparray_get(array, index)) != NULL ? ppobj_rget_array(obj) : NULL;
+}
+
+ppdict * pparray_get_dict (pparray *array, size_t index)
+{
+  ppobj *obj;
+  return (obj = pparray_get(array, index)) != NULL ? ppobj_get_dict(obj) : NULL;
+}
+
+ppdict * pparray_rget_dict (pparray *array, size_t index)
+{
+  ppobj *obj;
+  return (obj = pparray_get(array, index)) != NULL ? ppobj_rget_dict(obj) : NULL;
+}
+
+/*
+ppstream * pparray_get_stream (pparray *array, size_t index)
+{
+  ppobj *obj;
+  return (obj = pparray_get(array, index)) != NULL ? ppobj_get_stream(obj) : NULL;
+}
+*/
+
+ppstream * pparray_rget_stream (pparray *array, size_t index)
+{
+  ppobj *obj;
+  return (obj = pparray_get(array, index)) != NULL ? ppobj_rget_stream(obj) : NULL;
+}
+
+ppref * pparray_get_ref (pparray *array, size_t index)
+{
+  ppobj *obj;
+  return (obj = pparray_get(array, index)) != NULL ? ppobj_get_ref(obj) : NULL;
+}
+
+ppref * pparray_rget_ref (pparray *array, size_t index)
+{
+  ppobj *obj;
+  return (obj = pparray_get(array, index)) != NULL ? ppobj_rget_ref(obj) : NULL;
+}
diff --git a/texk/web2c/luatexdir/luapplib/pparray.h b/texk/web2c/luatexdir/luapplib/pparray.h
new file mode 100644
index 000000000..6fdd8b814
--- /dev/null
+++ b/texk/web2c/luatexdir/luapplib/pparray.h
@@ -0,0 +1,7 @@
+
+#ifndef PP_ARRAY_H
+#define PP_ARRAY_H
+
+pparray * pparray_create (const ppobj *stack, size_t size, ppheap **pheap);
+
+#endif
\ No newline at end of file
diff --git a/texk/web2c/luatexdir/luapplib/ppconf.h b/texk/web2c/luatexdir/luapplib/ppconf.h
new file mode 100644
index 000000000..57edc205a
--- /dev/null
+++ b/texk/web2c/luatexdir/luapplib/ppconf.h
@@ -0,0 +1,76 @@
+
+#ifndef PP_CONF_H
+#define PP_CONF_H
+
+/*
+Aux flags:
+  PPDLL -- indicates a part of a shared library
+  PPEXE -- indicates a host program using shared library functions
+*/
+
+#if defined(_WIN32) || defined(_WIN64)
+#  ifdef PPDLL
+#    define PPAPI __declspec(dllexport)
+#    define PPDEF __declspec(dllexport)
+#  else
+#    ifdef PPEXE
+#      define PPAPI __declspec(dllimport)
+#      define PPDEF
+#    else
+#      define PPAPI
+#      define PPDEF
+#    endif
+#  endif
+#else
+#  define PPAPI
+#  define PPDEF
+#endif
+
+/* platform vs integers */
+
+#if defined(_WIN32) || defined(WIN32)
+#  ifdef _MSC_VER
+#    if defined(_M_64) || defined(_WIN64)
+#      define MSVC64
+#    else
+#      define MSVC32
+#    endif
+#  else
+#    if defined(__MINGW64__)
+#      define MINGW64
+#    else
+#      if defined(__MINGW32__)
+#        define MINGW32
+#      endif
+#    endif
+#  endif
+#endif
+
+#if defined(_WIN64) || defined(__MINGW32__)
+#  define PPINT64F "%I64d"
+#  define PPUINT64F "%I64u"
+#else
+#  define PPINT64F "%lld"
+#  define PPUINT64F "%llu"
+#endif
+
+#if defined(MSVC64)
+#  define PPINT(N) N##I64
+#  define PPUINT(N) N##UI64
+#  define PPINTF PPINT64F
+#  define PPUINTF PPUINT64F
+#elif defined(MINGW64)
+#  define PPINT(N) N##LL
+#  define PPUINT(N) N##ULL
+#  define PPINTF PPINT64F
+#  define PPUINTF PPUINT64F
+#else // 32bit or sane 64bit (LP64, where long is long indeed)
+#  define PPINT(N) N##L
+#  define PPUINT(N) N##UL
+#  define PPINTF "%ld"
+#  define PPUINTF "%lu"
+#endif
+
+#define PPSIZEF PPUINTF
+
+#endif
\ No newline at end of file
diff --git a/texk/web2c/luatexdir/luapplib/ppcrypt.c b/texk/web2c/luatexdir/luapplib/ppcrypt.c
new file mode 100644
index 000000000..780ec78be
--- /dev/null
+++ b/texk/web2c/luatexdir/luapplib/ppcrypt.c
@@ -0,0 +1,628 @@
+
+#include "utilmd5.h"
+#include "utilsha.h"
+
+#include "pplib.h"
+
+/* crypt struct */
+
+#define CRYPT_AES  (1<<0)
+#define CRYPT_RC4  (1<<1)
+#define CRYPT_MD   (1<<2)
+#define CRYPT_NOMD (1<<3)
+
+static ppcrypt * ppcrypt_create (ppheap **pheap)
+{
+  ppcrypt *crypt;
+  crypt = (ppcrypt *)ppheap_take(pheap, sizeof(ppcrypt));
+  memset(crypt, 0, sizeof(ppcrypt));
+  return crypt;
+}
+
+static int ppcrypt_type (ppcrypt *crypt, ppname cryptname, ppuint *length, int *cryptflags)
+{
+  ppdict *filterdict;
+  ppname filtertype;
+  int cryptmd = 0, default256 = 0;
+
+  if (crypt->map == NULL || (filterdict = ppdict_rget_dict(crypt->map, cryptname)) == NULL)
+    return 0;
+  if ((filtertype = ppdict_get_name(filterdict, "CFM")) == NULL)
+    return 0;
+  *cryptflags = 0;
+  if (ppname_is(filtertype, "V2"))
+    *cryptflags |= CRYPT_RC4;
+  else if (ppname_is(filtertype, "AESV2"))
+    *cryptflags |= CRYPT_AES;
+  else if (ppname_is(filtertype, "AESV3"))
+    *cryptflags |= CRYPT_AES, default256 = 1;
+  else
+    return 0;
+  /* pdf spec page. 134: /Length is said to be optional bit-length of the key, but it seems to be a mistake, as Acrobat
+     produces /Length key with bytes lengths, opposite to /Length key of the main encrypt dict. */
+  if (length != NULL)
+    if (!ppdict_get_uint(filterdict, "Length", length))
+      *length = (*cryptflags & CRYPT_RC4) ? 5 : (default256 ? 32 : 16);
+  /* one of metadata flags is set iff there is an explicit EncryptMetadata key */
+  if (ppdict_get_bool(filterdict, "EncryptMetadata", &cryptmd))
+    *cryptflags |= (cryptmd ? CRYPT_MD : CRYPT_NOMD);
+  return 1;
+}
+
+static const uint8_t padding_string[] = {
+  0x28, 0xBF, 0x4E, 0x5E, 0x4E, 0x75, 0x8A, 0x41, 0x64, 0x00, 0x4E, 0x56, 0xFF, 0xFA, 0x01, 0x08,
+  0x2E, 0x2E, 0x00, 0xB6, 0xD0, 0x68, 0x3E, 0x80, 0x2F, 0x0C, 0xA9, 0xFE, 0x64, 0x53, 0x69, 0x7A
+};
+
+static void ppcrypt_set_userpass (ppcrypt *crypt, const void *userpass, size_t userpasslength)
+{
+  crypt->userpasslength = userpasslength > 32 ? 32 : userpasslength;
+  memcpy(crypt->userpass, userpass, crypt->userpasslength);
+  memcpy(crypt->userpass + crypt->userpasslength, padding_string, 32 - crypt->userpasslength);
+  crypt->flags |= PPCRYPT_USER_PASSWORD;
+}
+
+static void ppcrypt_set_ownerpass (ppcrypt *crypt, const void *ownerpass, size_t ownerpasslength)
+{
+  crypt->ownerpasslength = ownerpasslength > 32 ? 32 : ownerpasslength;
+  memcpy(crypt->ownerpass, ownerpass, crypt->ownerpasslength);
+  memcpy(crypt->ownerpass + crypt->ownerpasslength, padding_string, 32 - crypt->ownerpasslength);
+  crypt->flags |= PPCRYPT_OWNER_PASSWORD;
+}
+
+/* retrieving user password from owner password and owner key (variant < 5) */
+
+static void ppcrypt_retrieve_userpass (ppcrypt *crypt, const void *ownerkey, size_t ownerkeysize)
+{
+  uint8_t temp[16], rc4key[32], rc4key2[32];
+  uint8_t i;
+  ppuint k;
+
+  md5init();
+  md5add(crypt->ownerpass, 32);
+  md5put(rc4key);
+  if (crypt->algorithm_revision >= 3)
+  {
+    for (i = 0; i < 50; ++i)
+    {
+      pplib_md5(rc4key, 16, temp);
+      memcpy(rc4key, temp, 16);
+    }
+  }
+  rc4_decode_data(ownerkey, ownerkeysize, crypt->userpass, rc4key, crypt->filekeylength);
+  if (crypt->algorithm_revision >= 3)
+  {
+    for (i = 1; i <= 19; ++i)
+    {
+      for (k = 0; k < crypt->filekeylength; ++k)
+        rc4key2[k] = rc4key[k] ^ i;
+      rc4_decode_data(crypt->userpass, 32, crypt->userpass, rc4key2, crypt->filekeylength);
+    }
+  }
+  //crypt->userpasslength = 32;
+  for (crypt->userpasslength = 0; crypt->userpasslength < 32; ++crypt->userpasslength)
+    if (memcmp(&crypt->userpass[crypt->userpasslength], padding_string, 32 - crypt->userpasslength) == 0)
+      break;
+  crypt->flags |= PPCRYPT_USER_PASSWORD;
+}
+
+/* generating file key; pdf spec p. 125 */
+
+static void ppcrypt_filekey (ppcrypt *crypt, const void *ownerkey, size_t ownerkeysize, const void *id, size_t idsize)
+{
+  uint32_t p;
+  uint8_t permissions[4], temp[16];
+  int i;
+
+  md5init();
+  md5add(crypt->userpass, 32);
+  md5add(ownerkey, ownerkeysize);
+  p = (uint32_t)crypt->permissions;
+  permissions[0] = get_byte1(p);
+  permissions[1] = get_byte2(p);
+  permissions[2] = get_byte3(p);
+  permissions[3] = get_byte4(p);
+  md5add(permissions, 4);
+  md5add(id, idsize);
+  if (crypt->algorithm_revision >= 4 && (crypt->flags & PPCRYPT_NO_METADATA))
+    md5add("\xFF\xFF\xFF\xFF", 4);
+  md5put(crypt->filekey);
+  if (crypt->algorithm_revision >= 3)
+  {
+    for (i = 0; i < 50; ++i)
+    {
+      pplib_md5(crypt->filekey, (size_t)crypt->filekeylength, temp);
+      memcpy(crypt->filekey, temp, 16);
+    }
+  }
+}
+
+/* generating userkey for comparison with /U; requires a general file key and id; pdf spec page 126-127 */
+
+static void ppcrypt_userkey (ppcrypt *crypt, const void *id, size_t idsize, uint8_t *password_hash)
+{
+  uint8_t rc4key2[32];
+  uint8_t i;
+  ppuint k;
+
+  if (crypt->algorithm_revision <= 2)
+  {
+    rc4_encode_data(padding_string, 32, password_hash, crypt->filekey, crypt->filekeylength);
+  }
+  else
+  {
+    md5init();
+    md5add(padding_string, 32);
+    md5add(id, idsize);
+    md5put(password_hash);
+    rc4_encode_data(password_hash, 16, password_hash, crypt->filekey, crypt->filekeylength);
+    for (i = 1; i <= 19; ++i)
+    {
+      for (k = 0; k < crypt->filekeylength; ++k)
+        rc4key2[k] = crypt->filekey[k] ^ i;
+      rc4_encode_data(password_hash, 16, password_hash, rc4key2, crypt->filekeylength);
+    }
+    for (i = 16; i < 32; ++i)
+      password_hash[i] = password_hash[i - 16] ^ i; /* arbitrary 16-bytes padding */
+  }
+}
+
+/* validating /Perms key (pdf 1.7, /V 5 /R 5 crypt) */
+
+static const uint8_t nulliv[16] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; /* AES-256 initialization vector */
+
+static ppcrypt_status ppcrypt_authenticate_perms (ppcrypt *crypt, ppstring perms)
+{ /* decode /Perms string overriding crypt setup (should match anyway) */
+  uint8_t permsdata[16];
+  //int64_t p;
+  //int i;
+
+  aes_decode_data(perms, ppstring_size(perms), permsdata, crypt->filekey, crypt->filekeylength, nulliv, AES_NULL_PADDING);
+
+  if (permsdata[9] != 'a' || permsdata[10] != 'd' || permsdata[11] != 'b')
+    return PPCRYPT_FAIL;
+
+  // do not update permissions flags; they seem to be different inside crypt string
+  //for (p = 0, i = 0; i < 8; ++i)
+  //  p = p + (permsdata[i] << (i << 3)); /* low order bytes first */
+  //crypt->permissions = (ppint)(int32_t)(p & 0x00000000FFFFFFFFLL); /* unset bits 33..64, treat as 32-bit signed int */
+
+  if (permsdata[8] == 'T')
+    crypt->flags &= ~PPCRYPT_NO_METADATA;
+  else if (permsdata[8] == 'F')
+    crypt->flags |= PPCRYPT_NO_METADATA;
+
+  return PPCRYPT_DONE;
+}
+
+ppcrypt_status ppdoc_crypt_init (ppdoc *pdf, const void *userpass, size_t userpasslength, const void *ownerpass, size_t ownerpasslength)
+{
+  ppcrypt *crypt;
+  ppdict *trailer, *encrypt;
+  ppobj *obj;
+  ppname name, *pkey;
+  ppstring userkey, ownerkey, userkey_e = NULL, ownerkey_e = NULL;
+  size_t hashlength;
+  pparray *idarray;
+  ppstring id = NULL, perms = NULL;
+  int cryptflags, encryptmd;
+  size_t strkeylength, stmkeylength;
+
+  uint8_t password_hash[32]; /* /U and /O are 48 bytes strings for AES-256, but here we use only 32 */
+  uint8_t *validation_salt, *key_salt;
+
+  /* Every xref could theoretically have a separate encryption info. Not clarified in pdf spec but it seems that the top
+     level xref encryption info is the one to be applied to all objects in all xrefs, including older. */
+  trailer = ppxref_trailer(pdf->xref);
+  if ((obj = ppdict_get_obj(trailer, "Encrypt")) == NULL)
+    return PPCRYPT_NONE;
+  /* Typically this is all done early, before loading body, so if /Encrypt is indirect reference, it points nothing. We have to load it here. */
+  obj = ppobj_preloaded(pdf, obj);
+  if (obj->type != PPDICT)
+    return PPCRYPT_FAIL;
+  encrypt = obj->dict;
+  for (ppdict_first(encrypt, pkey, obj); *pkey != NULL; ppdict_next(pkey, obj))
+    (void)ppobj_preloaded(pdf, obj);
+
+  if ((name = ppdict_get_name(encrypt, "Filter")) != NULL && !ppname_is(name, "Standard"))
+    return PPCRYPT_FAIL;
+
+  if ((crypt = pdf->crypt) == NULL)
+    crypt = pdf->crypt = ppcrypt_create(&pdf->heap);
+  if (!ppdict_get_uint(encrypt, "V", &crypt->algorithm_variant))
+    crypt->algorithm_variant = 0;
+  if (crypt->algorithm_variant < 1 || crypt->algorithm_variant > 5)
+    return PPCRYPT_FAIL;
+  if (!ppdict_get_uint(encrypt, "R", &crypt->algorithm_revision))
+    return PPCRYPT_FAIL;
+  if (crypt->algorithm_revision >= 3)
+    crypt->flags |= PPCRYPT_OBSCURITY;
+  if (!ppdict_get_int(encrypt, "P", &crypt->permissions))
+    return PPCRYPT_FAIL;
+  if ((userkey = ppdict_get_string(encrypt, "U")) == NULL || (ownerkey = ppdict_get_string(encrypt, "O")) == NULL)
+    return PPCRYPT_FAIL;
+  userkey = ppstring_decoded(userkey);
+  ownerkey = ppstring_decoded(ownerkey);
+  /* for some reason acrobat pads /O and /U to 127 bytes with NULL, so we don't check the exact length but ensure the minimal */
+  hashlength = crypt->algorithm_variant < 5 ? 32 : 48;
+  if (ppstring_size(userkey) < hashlength || ppstring_size(ownerkey) < hashlength)
+    return PPCRYPT_FAIL;
+  if (crypt->algorithm_variant < 5)
+  { // get first string from /ID (must not be ref)
+    if ((idarray = ppdict_get_array(trailer, "ID")) == NULL || (id = pparray_get_string(idarray, 0)) == NULL)
+      return PPCRYPT_FAIL;
+    id = ppstring_decoded(id);
+  }
+  else
+  {
+    if ((userkey_e = ppdict_get_string(encrypt, "UE")) == NULL || (ownerkey_e = ppdict_get_string(encrypt, "OE")) == NULL)
+      return PPCRYPT_FAIL;
+    userkey_e = ppstring_decoded(userkey_e);
+    ownerkey_e = ppstring_decoded(ownerkey_e);
+    if (ppstring_size(userkey_e) < 32 || ppstring_size(ownerkey_e) < 32)
+      return PPCRYPT_FAIL;
+    if ((perms = ppdict_get_string(encrypt, "Perms")) == NULL)
+      return PPCRYPT_FAIL;
+    perms = ppstring_decoded(perms);
+    if (ppstring_size(perms) != 16)
+      return PPCRYPT_FAIL;
+  }
+
+  switch (crypt->algorithm_revision)
+  {
+    case 1:
+      crypt->filekeylength = 5;
+      crypt->flags |= PPCRYPT_RC4;
+      break;
+    case 2: case 3:
+      if (ppdict_get_uint(encrypt, "Length", &crypt->filekeylength))
+        crypt->filekeylength >>= 3; /* 40..256 bits, 5..32 bytes*/
+      else
+        crypt->filekeylength = 5; /* 40 bits, 5 bytes */
+      crypt->flags |= PPCRYPT_RC4;
+      break;
+    case 4: case 5:
+      if ((crypt->map = ppdict_rget_dict(encrypt, "CF")) == NULL)
+        return PPCRYPT_FAIL;
+      for (ppdict_first(crypt->map, pkey, obj); *pkey != NULL; ppdict_next(pkey, obj))
+        (void)ppobj_preloaded(pdf, obj);
+      /* /EncryptMetadata relevant only for version >=4, may be also provided in crypt filter dictionary; which takes a precedence then?
+         we assume that if there is an explicit EncryptMetadata key, it overrides main encrypt dict flag or default flag (the default is true,
+         meaning that Metadata stream is encrypted as others) */
+      if (ppdict_get_bool(encrypt, "EncryptMetadata", &encryptmd) && !encryptmd)
+        crypt->flags |= PPCRYPT_NO_METADATA;
+
+      strkeylength = stmkeylength = 0;
+      /* streams filter */
+      if ((name = ppdict_get_name(encrypt, "StmF")) != NULL && ppcrypt_type(crypt, name, &stmkeylength, &cryptflags))
+      {
+        if (cryptflags & CRYPT_AES)
+          crypt->flags |= PPCRYPT_STREAM_AES;
+        else if (cryptflags & CRYPT_RC4)
+          crypt->flags |= PPCRYPT_STREAM_RC4;
+        if (cryptflags & CRYPT_NOMD)
+          crypt->flags |= PPCRYPT_NO_METADATA;
+        else if (cryptflags & CRYPT_MD)
+          crypt->flags &= ~PPCRYPT_NO_METADATA;
+      } /* else identity */
+      /* strings filter */
+      if ((name = ppdict_get_name(encrypt, "StrF")) != NULL && ppcrypt_type(crypt, name, &strkeylength, &cryptflags))
+      {
+        if (cryptflags & CRYPT_AES)
+          crypt->flags |= PPCRYPT_STRING_AES;
+        else if (cryptflags & CRYPT_RC4)
+          crypt->flags |= PPCRYPT_STRING_RC4;
+      } /* else identity */
+
+      /* /Length of encrypt dict is irrelevant here, theoretically every crypt filter may have own length... It means that we should
+         actually keep a different file key for streams and strings. But it leads to nonsense, as /U and /O entries refers to a single
+         keylength, without a distinction for strings/streams. So we have to assume /Length is consistent. To expose the limitation: */
+      if ((crypt->flags & PPCRYPT_STREAM) && (crypt->flags & PPCRYPT_STRING))
+        if (strkeylength != stmkeylength)
+          return PPCRYPT_FAIL;
+      crypt->filekeylength = stmkeylength ? stmkeylength : strkeylength;
+      if ((crypt->flags & PPCRYPT_STREAM) || (crypt->flags & PPCRYPT_STRING))
+        if (crypt->filekeylength == 0)
+          return PPCRYPT_FAIL;
+      break;
+    default:
+      return PPCRYPT_FAIL;
+  }
+
+  /* password */
+
+  if (userpass != NULL)
+  {
+    ppcrypt_set_userpass(crypt, userpass, userpasslength);
+  }
+  else if (ownerpass != NULL)
+  {
+    if (crypt->algorithm_variant < 5) // fetch user password from owner password
+      ppcrypt_retrieve_userpass(crypt, ownerkey, ppstring_size(ownerkey));
+    else                              // open the document using owner password
+      ppcrypt_set_ownerpass(crypt, ownerpass, ownerpasslength);
+  }
+  else
+  {
+    return PPCRYPT_FAIL;
+  }
+
+  if (crypt->algorithm_variant < 5)
+  { /* authenticate by comparing a generated vs present /U entry; depending on variant 16 or 32 bytes to compare */
+    ppcrypt_filekey(crypt, ownerkey, ppstring_size(ownerkey), id, ppstring_size(id));
+    ppcrypt_userkey(crypt, id, ppstring_size(id), password_hash); /* needs file key so comes after key generation */
+    if (memcmp(userkey, password_hash, (crypt->algorithm_revision >= 3 ? 16 : 32)) == 0)
+      return PPCRYPT_DONE;
+    return PPCRYPT_PASS;
+  }
+  if (crypt->flags & PPCRYPT_USER_PASSWORD)
+  {
+    validation_salt = (uint8_t *)userkey + 32;
+    key_salt = validation_salt + 8;
+    sha256init();
+    sha256add(crypt->userpass, crypt->userpasslength);
+    sha256add(validation_salt, 8);
+    sha256put(password_hash);
+    if (memcmp(userkey, password_hash, 32) != 0)
+      return PPCRYPT_PASS;
+    sha256init();
+    sha256add(crypt->userpass, crypt->userpasslength);
+    sha256add(key_salt, 8);
+    sha256put(password_hash);
+    aes_decode_data(userkey_e, 32, crypt->filekey, password_hash, 32, nulliv, AES_NULL_PADDING);
+    return ppcrypt_authenticate_perms(crypt, perms);
+  }
+  if (crypt->flags & PPCRYPT_OWNER_PASSWORD)
+  {
+    validation_salt = (uint8_t *)ownerkey + 32;
+    key_salt = validation_salt + 8;
+    sha256init();
+    sha256add(crypt->ownerpass, crypt->ownerpasslength);
+    sha256add(validation_salt, 8);
+    sha256add(userkey, 48);
+    sha256put(password_hash);
+    if (memcmp(ownerkey, password_hash, 32) != 0)
+      return PPCRYPT_PASS;
+    sha256init();
+    sha256add(crypt->ownerpass, crypt->ownerpasslength);
+    sha256add(key_salt, 8);
+    sha256add(userkey, 48);
+    sha256put(password_hash);
+    aes_decode_data(ownerkey_e, 32, crypt->filekey, password_hash, 32, nulliv, AES_NULL_PADDING);
+    return ppcrypt_authenticate_perms(crypt, perms);
+  }
+  return PPCRYPT_FAIL; // should never get here
+}
+
+/* decrypting strings */
+
+/*
+Since strings are generally rare, but might occur in mass (name trees). We generate decryption key when needed.
+All strings within the same reference are crypted with the same key. Both RC4 and AES algorithms expands
+the crypt key in some way and the result of expansion is the same for the same crypt key. Instead of recreating
+the ky for every string, we backup the initial decryption state.
+*/
+
+static void ppcrypt_strkey (ppcrypt *crypt, ppref *ref, int aes)
+{
+  if (crypt->cryptkeylength > 0)
+  { /* crypt key already generated, just reinitialize crypt states */
+    if (aes)
+    { /* aes codecs that works on c-strings do not modify aes_state flags at all, so we actually don't need to revitalize the state,
+         we only rewrite an initialization vector, which is modified during crypt procedure */
+    }
+    else
+    { /* rc4 crypt map is modified during crypt procedure, so here we reinitialize rc4 bytes map */
+      rc4_map_restore(&crypt->rc4state, &crypt->rc4copy);
+    }
+    return;
+  }
+
+  if (crypt->algorithm_variant < 5)
+  {
+    crypt->filekey[crypt->filekeylength + 0] = get_byte1(ref->number);
+    crypt->filekey[crypt->filekeylength + 1] = get_byte2(ref->number);
+    crypt->filekey[crypt->filekeylength + 2] = get_byte3(ref->number);
+    crypt->filekey[crypt->filekeylength + 3] = get_byte1(ref->version);
+    crypt->filekey[crypt->filekeylength + 4] = get_byte2(ref->version);
+
+    if (aes)
+    {
+      crypt->filekey[crypt->filekeylength + 5] = 0x73;
+      crypt->filekey[crypt->filekeylength + 6] = 0x41;
+      crypt->filekey[crypt->filekeylength + 7] = 0x6C;
+      crypt->filekey[crypt->filekeylength + 8] = 0x54;
+    }
+
+    pplib_md5(crypt->filekey, crypt->filekeylength + (aes ? 9 : 5), crypt->cryptkey);
+    crypt->cryptkeylength = crypt->filekeylength + 5 >= 16 ? 16 : crypt->filekeylength + 5;
+  }
+  else
+  {
+    memcpy(crypt->cryptkey, crypt->filekey, 32);
+    crypt->cryptkeylength = 32;
+  }
+
+  if (aes)
+  {
+    aes_decode_initialize(&crypt->aesstate, &crypt->aeskeyblock, crypt->cryptkey, crypt->cryptkeylength, NULL);
+    aes_pdf_mode(&crypt->aesstate);
+  }
+  else
+  {
+    rc4_state_initialize(&crypt->rc4state, &crypt->rc4map, crypt->cryptkey, crypt->cryptkeylength);
+    rc4_map_save(&crypt->rc4state, &crypt->rc4copy);
+  }
+}
+
+int ppstring_decrypt (ppcrypt *crypt, const void *input, size_t size, void *output, size_t *newsize)
+{
+  int aes, rc4;
+  aes = crypt->flags & PPCRYPT_STRING_AES;
+  rc4 = crypt->flags & PPCRYPT_STRING_RC4;
+  if (aes || rc4)
+  {
+    ppcrypt_strkey(crypt, crypt->ref, aes);
+    if (aes)
+      *newsize = aes_decode_state_data(&crypt->aesstate, input, size, output);
+    else // if (rc4)
+      *newsize = rc4_decode_state_data(&crypt->rc4state, input, size, output);
+    return 1;
+  }
+  return 0; // identity crypt
+}
+
+/* decrypting streams */
+
+/*
+Streams are decrypted everytime when accessing the stream data. We need to be able to get or make
+the key for decryption as long as the stream is alive. And to get the key we need the reference
+number and version, plus document crypt info. First thought was to keep the reference to which
+the stream belongs; stream->ref and accessing the crypt info stream->ref->xref->pdf->crypt.
+It would be ok as long as absolutelly nothing happens with ref and crypt. At some point pplib
+may drift into rewriting support, which would imply ref/xref/crypt/pdf structures modifications.
+So I feel better with generating a crypt key for every stream in encrypted document, paying a cost
+of pplib_md5() for all streams, not necessarily those actually read.
+
+Key generation is the same as for strings, but different for distinct encryption methods (rc4 vs aes).
+Since streams and strings might theoretically be encrypted with different filters. No reason to cacche
+decryption state here.
+*/
+
+static ppstring ppcrypt_stmkey (ppcrypt *crypt, ppref *ref, int aes, ppheap **pheap)
+{
+  ppstring cryptkeystring;
+  //if (crypt->cryptkeylength > 0)
+  //  return;
+
+  if (crypt->algorithm_variant < 5)
+  {
+    crypt->filekey[crypt->filekeylength + 0] = get_byte1(ref->number);
+    crypt->filekey[crypt->filekeylength + 1] = get_byte2(ref->number);
+    crypt->filekey[crypt->filekeylength + 2] = get_byte3(ref->number);
+    crypt->filekey[crypt->filekeylength + 3] = get_byte1(ref->version);
+    crypt->filekey[crypt->filekeylength + 4] = get_byte2(ref->version);
+
+    if (aes)
+    {
+      crypt->filekey[crypt->filekeylength + 5] = 0x73;
+      crypt->filekey[crypt->filekeylength + 6] = 0x41;
+      crypt->filekey[crypt->filekeylength + 7] = 0x6C;
+      crypt->filekey[crypt->filekeylength + 8] = 0x54;
+    }
+
+    pplib_md5(crypt->filekey, crypt->filekeylength + (aes ? 9 : 5), crypt->cryptkey);
+    crypt->cryptkeylength = crypt->filekeylength + 5 >= 16 ? 16 : crypt->filekeylength + 5; // how about 256bits AES??
+  }
+  else
+  { // we could actually generate this string once, but.. aes itself is way more expensive that we can earn here
+    memcpy(crypt->cryptkey, crypt->filekey, 32); // just for the record
+    crypt->cryptkeylength = 32;
+  }
+  cryptkeystring = ppstring_internal(crypt->cryptkey, crypt->cryptkeylength, pheap);
+  return ppstring_decoded(cryptkeystring);
+}
+
+void ppstream_info (ppstream *stream, ppdoc *pdf)
+{ // just after the stream creation
+  ppdict *dict;
+  ppobj *fobj, *pobj;
+  pparray *farray;
+  ppname fname, owncryptfilter, tname;
+  ppcrypt *crypt;
+  ppref *ref;
+  size_t i;
+  int owncrypt, cflags;
+
+  dict = stream->dict;
+	ppdict_rget_uint(dict, "Length", &stream->length);
+
+  if ((fobj = ppdict_get_obj(dict, "Filter")) != NULL)
+  {
+    fobj = ppobj_preloaded(pdf, fobj);
+    switch (fobj->type)
+    {
+      case PPNAME:
+        stream->flags |= PPSTREAM_COMPRESSED;
+        break;
+      case PPARRAY:
+        if (fobj->array->size > 0)
+          stream->flags |= PPSTREAM_COMPRESSED;
+        break;
+      default:
+        break;
+    }
+  }
+  if ((crypt = pdf->crypt) == NULL || (ref = crypt->ref) == NULL)
+    return;
+  owncrypt = 0;
+  owncryptfilter = NULL;
+  if (fobj != NULL)
+  {
+    if ((pobj = ppdict_get_obj(dict, "DecodeParms")) != NULL)
+      pobj = ppobj_preloaded(pdf, pobj);
+    switch (fobj->type)
+    {
+      case PPNAME:
+        if (ppname_is(fobj->name, "Crypt"))
+        {
+          owncrypt = 1;
+          if (pobj != NULL && pobj->type == PPDICT) // /Type /CryptFilterDecodeParms
+            owncryptfilter = ppdict_get_name(pobj->dict, "Name");
+        }
+        break;
+      case PPARRAY:
+        farray = fobj->array;
+        for (i = 0; i < farray->size; ++i)
+        {
+          if ((fname = pparray_get_name(farray, i)) != NULL && ppname_is(fname, "Crypt"))
+          {
+            owncrypt = 1;
+            if (pobj != NULL && pobj->type == PPARRAY && (pobj = pparray_get_obj(pobj->array, i)) != NULL)
+            {
+              pobj = ppobj_preloaded(pdf, pobj);
+              if (pobj != NULL && pobj->type == PPDICT) // /Type /CryptFilterDecodeParms
+                owncryptfilter = ppdict_get_name(pobj->dict, "Name");
+            }
+            break;
+          }
+        }
+        break;
+      default:
+        break;
+    }
+  }
+
+  if (owncrypt)
+  {
+    stream->flags |= PPSTREAM_ENCRYPTED_OWN;
+    /* Seems a common habit to use just /Crypt filter name with no params, which defaults to /Identity.
+       A real example with uncompressed metadata: <</Filter[/Crypt]/Length 4217/Subtype/XML/Type/Metadata>> */
+    if (owncryptfilter != NULL && !ppname_is(owncryptfilter, "Identity"))
+    {
+      if (crypt->map != NULL && ppcrypt_type(crypt, owncryptfilter, NULL, &cflags))
+      {
+        if (cflags & CRYPT_AES)
+          stream->flags |= PPSTREAM_ENCRYPTED_AES;
+        else if (cflags & CRYPT_RC4)
+          stream->flags |= PPSTREAM_ENCRYPTED_RC4;
+      }
+    }
+  }
+  else
+  {
+    if ((crypt->flags & PPCRYPT_NO_METADATA) && (tname = ppdict_get_name(dict, "Type")) != NULL && ppname_is(tname, "Metadata"))
+      ; /* special treatment of metadata stream; we assume that explicit /Filter /Crypt setup overrides document level setup of EncryptMetadata. */
+    else
+    {
+      if (crypt->flags & PPCRYPT_STREAM_RC4)
+        stream->flags |= PPSTREAM_ENCRYPTED_RC4;
+      else if (crypt->flags & PPCRYPT_STREAM_AES)
+        stream->flags |= PPSTREAM_ENCRYPTED_AES;
+    }
+  }
+
+  /* finally, if the stream is encrypted with non-identity crypt (implicit or explicit), make and save the crypt key */
+  if (stream->flags & PPSTREAM_ENCRYPTED)
+    stream->cryptkey = ppcrypt_stmkey(crypt, ref, ((stream->flags & PPSTREAM_ENCRYPTED_AES) != 0), &pdf->heap);
+}
diff --git a/texk/web2c/luatexdir/luapplib/ppcrypt.h b/texk/web2c/luatexdir/luapplib/ppcrypt.h
new file mode 100644
index 000000000..fc74cfe37
--- /dev/null
+++ b/texk/web2c/luatexdir/luapplib/ppcrypt.h
@@ -0,0 +1,61 @@
+
+#ifndef PP_CRYPT_H
+#define PP_CRYPT_H
+
+#include "ppfilter.h"
+#include "utilcrypt.h"
+#include "utilcryptdef.h"
+
+typedef struct {
+  ppuint algorithm_variant;  /* /V entry of encrypt dict */
+  ppuint algorithm_revision; /* /R entry of encrypt dict */
+  ppint permissions;         /* /P entry of encrypt dict */
+  ppdict *map;               /* /CF filters map of encrypt dict */
+  uint8_t userpass[32];      /* padded user password */
+  size_t userpasslength;     /* the length of unpadded user password */
+  uint8_t ownerpass[32];     /* padded owner password */
+  size_t ownerpasslength;    /* the length of unpadded owner password */
+  uint8_t filekey[32+5+4];   /* generated file key with extra space of 5..9 bytes for salt */
+  size_t filekeylength;      /* key length; usually 5, 16 or 32 bytes */
+  uint8_t cryptkey[32];      /* final crypt key for a given reference */
+  size_t cryptkeylength;     /* final crypt key length; usually keylength + 5 */
+  ppref *ref;                /* currently loaded ref (each ref may have a different key) */
+  union {                    /* cached crypt states for strings encrypted/decrypted with the same key */
+    struct {
+      rc4_state rc4state;
+      rc4_map rc4map;
+      rc4_map rc4copy;
+    };
+    struct {
+      aes_state aesstate;
+      aes_keyblock aeskeyblock;
+      uint8_t ivcopy[16];
+    };
+  };
+  int flags;
+} ppcrypt;
+
+#define PPCRYPT_NO_METADATA (1<<0)
+#define PPCRYPT_USER_PASSWORD (1<<1)
+#define PPCRYPT_OWNER_PASSWORD (1<<2)
+#define PPCRYPT_STREAM_RC4 (1<<3)
+#define PPCRYPT_STRING_RC4 (1<<4)
+#define PPCRYPT_STREAM_AES (1<<5)
+#define PPCRYPT_STRING_AES (1<<6)
+#define PPCRYPT_OBSCURITY  (1<<7)
+
+#define PPCRYPT_STREAM (PPCRYPT_STREAM_AES|PPCRYPT_STREAM_RC4)
+#define PPCRYPT_STRING (PPCRYPT_STRING_AES|PPCRYPT_STRING_RC4)
+#define PPCRYPT_RC4 (PPCRYPT_STREAM_RC4|PPCRYPT_STRING_RC4)
+#define PPCRYPT_AES (PPCRYPT_STREAM_AES|PPCRYPT_STRING_AES)
+
+ppcrypt_status ppdoc_crypt_init (ppdoc *pdf, const void *userpass, size_t userpasslength, const void *ownerpass, size_t ownerpasslength);
+int ppstring_decrypt (ppcrypt *crypt, const void *input, size_t size, void *output, size_t *newsize);
+
+#define ppcrypt_start_ref(crypt, r) ((crypt)->ref = r, (crypt)->cryptkeylength = 0)
+#define ppcrypt_end_ref(crypt) ((crypt)->ref = NULL, (crypt)->cryptkeylength = 0)
+#define ppcrypt_ref(pdf, crypt) ((crypt = (pdf)->crypt) != NULL && crypt->ref != NULL)
+
+void ppstream_info (ppstream *stream, ppdoc *pdf);
+
+#endif
\ No newline at end of file
diff --git a/texk/web2c/luatexdir/luapplib/ppdict.c b/texk/web2c/luatexdir/luapplib/ppdict.c
new file mode 100644
index 000000000..f04403d83
--- /dev/null
+++ b/texk/web2c/luatexdir/luapplib/ppdict.c
@@ -0,0 +1,163 @@
+
+#include "pplib.h"
+
+ppdict * ppdict_create (const ppobj *stackpos, size_t size, ppheap **pheap)
+{
+	ppdict *dict;
+	ppobj *data;
+	ppname *pkey;
+	size_t i;
+	size >>= 1;
+	dict = (ppdict *)ppheap_take(pheap, sizeof(ppdict) + size * sizeof(ppobj) + (size + 1) * sizeof(ppname *)); // ? + size * sizeof(ppdict_map_node)
+	dict->size = 0;
+	dict->data = data = (ppobj *)(dict + 1);
+	dict->keys = pkey = (ppname *)(dict->data + size);
+	for (i = 0; i < size; ++i, stackpos += 2)
+	{
+	  if (stackpos->type != PPNAME) // we need this check at lest for trailer hack
+	    continue;
+    *pkey = stackpos->name;
+    *data = *(stackpos + 1);
+    ++pkey, ++data, ++dict->size;
+	}
+	*pkey = NULL; // sentinel for convinient iteration
+	return dict;
+}
+
+ppobj * ppdict_get_obj (ppdict *dict, const char *name)
+{ // some lookup? will see
+  ppname *pkey;
+  ppobj *obj;
+  for (ppdict_first(dict, pkey, obj); *pkey != NULL; ppdict_next(pkey, obj))
+    if (strcmp(*pkey, name) == 0) // not ppname_eq() or ppname_is()!!
+      return obj;
+  return NULL;
+}
+
+ppobj * ppdict_rget_obj (ppdict *dict, const char *name)
+{
+	ppobj *obj;
+  return (obj = ppdict_get_obj(dict, name)) != NULL ? ppobj_rget_obj(obj) : NULL;
+}
+
+int ppdict_get_bool (ppdict *dict, const char *name, int *v)
+{
+  ppobj *obj;
+  return (obj = ppdict_get_obj(dict, name)) != NULL ? ppobj_get_bool(obj, *v) : 0;
+}
+
+int ppdict_rget_bool (ppdict *dict, const char *name, int *v)
+{
+  ppobj *obj;
+  return (obj = ppdict_get_obj(dict, name)) != NULL ? ppobj_rget_bool(obj, *v) : 0;
+}
+
+int ppdict_get_int (ppdict *dict, const char *name, ppint *v)
+{
+  ppobj *obj;
+  return (obj = ppdict_get_obj(dict, name)) != NULL ? ppobj_get_int(obj, *v) : 0;
+}
+
+int ppdict_rget_int (ppdict *dict, const char *name, ppint *v)
+{
+  ppobj *obj;
+  return (obj = ppdict_get_obj(dict, name)) != NULL ? ppobj_rget_int(obj, *v) : 0;
+}
+
+int ppdict_get_uint (ppdict *dict, const char *name, ppuint *v)
+{
+  ppobj *obj;
+  return (obj = ppdict_get_obj(dict, name)) != NULL ? ppobj_get_uint(obj, *v) : 0;
+}
+
+int ppdict_rget_uint (ppdict *dict, const char *name, ppuint *v)
+{
+  ppobj *obj;
+  return (obj = ppdict_get_obj(dict, name)) != NULL ? ppobj_rget_uint(obj, *v) : 0;
+}
+
+int ppdict_get_num (ppdict *dict, const char *name, ppnum *v)
+{
+  ppobj *obj;
+  return (obj = ppdict_get_obj(dict, name)) != NULL ? ppobj_get_num(obj, *v) : 0;
+}
+
+int ppdict_rget_num (ppdict *dict, const char *name, ppnum *v)
+{
+  ppobj *obj;
+  return (obj = ppdict_get_obj(dict, name)) != NULL ? ppobj_rget_num(obj, *v) : 0;
+}
+
+ppname ppdict_get_name (ppdict *dict, const char *name)
+{
+  ppobj *obj;
+  return (obj = ppdict_get_obj(dict, name)) != NULL ? ppobj_get_name(obj) : NULL;
+}
+
+ppname ppdict_rget_name (ppdict *dict, const char *name)
+{
+  ppobj *obj;
+  return (obj = ppdict_get_obj(dict, name)) != NULL ? ppobj_rget_name(obj) : NULL;
+}
+
+ppstring ppdict_get_string (ppdict *dict, const char *name)
+{
+  ppobj *obj;
+  return (obj = ppdict_get_obj(dict, name)) != NULL ? ppobj_get_string(obj) : NULL;
+}
+
+ppstring ppdict_rget_string (ppdict *dict, const char *name)
+{
+  ppobj *obj;
+  return (obj = ppdict_get_obj(dict, name)) != NULL ? ppobj_rget_string(obj) : NULL;
+}
+
+pparray * ppdict_get_array (ppdict *dict, const char *name)
+{
+  ppobj *obj;
+  return (obj = ppdict_get_obj(dict, name)) != NULL ? ppobj_get_array(obj) : NULL;
+}
+
+pparray * ppdict_rget_array (ppdict *dict, const char *name)
+{
+  ppobj *obj;
+  return (obj = ppdict_get_obj(dict, name)) != NULL ? ppobj_rget_array(obj) : NULL;
+}
+
+ppdict * ppdict_get_dict (ppdict *dict, const char *name)
+{
+  ppobj *obj;
+  return (obj = ppdict_get_obj(dict, name)) != NULL ? ppobj_get_dict(obj) : NULL;
+}
+
+ppdict * ppdict_rget_dict (ppdict *dict, const char *name)
+{
+  ppobj *obj;
+  return (obj = ppdict_get_obj(dict, name)) != NULL ? ppobj_rget_dict(obj) : NULL;
+}
+
+/*
+ppstream * ppdict_get_stream (ppdict *dict, const char *name)
+{
+  ppobj *obj;
+  return (obj = ppdict_get_obj(dict, name)) != NULL ? ppobj_get_stream(obj) : NULL;
+}
+*/
+
+ppstream * ppdict_rget_stream (ppdict *dict, const char *name)
+{
+  ppobj *obj;
+  return (obj = ppdict_get_obj(dict, name)) != NULL ? ppobj_rget_stream(obj) : NULL;
+}
+
+ppref * ppdict_get_ref (ppdict *dict, const char *name)
+{
+  ppobj *obj;
+  return (obj = ppdict_get_obj(dict, name)) != NULL ? ppobj_get_ref(obj) : NULL;
+}
+
+ppref * ppdict_rget_ref (ppdict *dict, const char *name)
+{
+  ppobj *obj;
+  return (obj = ppdict_get_obj(dict, name)) != NULL ? ppobj_rget_ref(obj) : NULL;
+}
diff --git a/texk/web2c/luatexdir/luapplib/ppdict.h b/texk/web2c/luatexdir/luapplib/ppdict.h
new file mode 100644
index 000000000..5a808b772
--- /dev/null
+++ b/texk/web2c/luatexdir/luapplib/ppdict.h
@@ -0,0 +1,7 @@
+
+#ifndef PP_DICT_H
+#define PP_DICT_H
+
+ppdict * ppdict_create (const ppobj *stack, size_t size, ppheap **pheap);
+
+#endif
\ No newline at end of file
diff --git a/texk/web2c/luatexdir/luapplib/ppfilter.h b/texk/web2c/luatexdir/luapplib/ppfilter.h
new file mode 100644
index 000000000..583aa8cf4
--- /dev/null
+++ b/texk/web2c/luatexdir/luapplib/ppfilter.h
@@ -0,0 +1,10 @@
+
+#ifndef PP_FILTER_H
+#define PP_FILTER_H
+
+#include "utilbasexx.h"
+#include "utilflate.h"
+#include "utillzw.h"
+#include "utilfpred.h"
+
+#endif
\ No newline at end of file
diff --git a/texk/web2c/luatexdir/luapplib/ppheap.c b/texk/web2c/luatexdir/luapplib/ppheap.c
new file mode 100644
index 000000000..f05e1b7a5
--- /dev/null
+++ b/texk/web2c/luatexdir/luapplib/ppheap.c
@@ -0,0 +1,424 @@
+
+#include "pplib.h"
+
+#define PPHEAP_BUFFER 0xFFFF
+#define PPHEAP_WASTE 0x00FF
+
+#define ppheap_head(heap) ((uint8_t *)((heap) + 1))
+
+
+#if defined __arm__ || defined __ARM__ || defined ARM || defined __ARM || defined __arm || defined __ARM_ARCH ||defined __aarch64__ 
+# define PPHEAP_ARCH_ARM
+# define PPHEAP_NEED_ALIGNMENT
+#endif
+
+
+ 
+#ifdef PPHEAP_NEED_ALIGNMENT 
+/* Tests has shown that long double seems to work: */
+/* for 32bit aligned_data has  algn: 64 as ppxref and ppref, */
+/* the other algns divide algn: 64, so it's ok.*/
+/* Hopefully it's ok for aarch64 too */
+
+/* These data are stored in ppheap.c.001t.tu */
+/* made with gcc -fdump-tree-all-fdump-tree-all */
+
+
+/* @2586   identifier_node  strg: ppxref   lngt: 6        */
+/* @2565   record_type      name: @2586    size: @679     algn: 64       */
+/*                          tag : struct   flds: @2587    */
+
+
+/* @2672   identifier_node  strg: ppxsec   lngt: 6        */
+/* @2648   type_decl        name: @2672    type: @2623    scpe: @221     */
+/*                          srcp: ppxref.h:16             chain: @2673    */
+/* @2623   record_type      name: @2648    unql: @2649    size: @593     */
+/*                          algn: 32       tag : struct   flds: @2650 */
+
+
+/* @2642   identifier_node  strg: ppstream lngt: 8 */
+/* @2615   type_decl        name: @2642    type: @2643    scpe: @221     */
+/*                          srcp: ppapi.h:54              chain: @2644    */
+/* @2643   record_type      name: @2615    unql: @2614    size: @634     */
+/*                          algn: 32       tag : struct   flds: @2641    */
+
+
+/* @2765   identifier_node  strg: ppkids   lngt: 6 */
+/* @2743   type_decl        name: @2765    type: @2766    scpe: @221     */
+/*                          srcp: ppload.h:16             chain: @2767    */
+/* @2766   record_type      name: @2743    unql: @2742    size: @19      */
+/*                          algn: 32       tag : struct   flds: @2764    */
+
+
+/* @2625   identifier_node  strg: ppdoc    lngt: 5        */
+/* @2605   record_type      name: @2625    size: @2626    algn: 32       */
+/*                          tag : struct   flds: @2627    */
+
+/* @2526   identifier_node  strg: ppref    lngt: 5        */
+/* @2513   record_type      name: @2526    size: @662     algn: 64       */
+/*                          tag : struct   flds: @2527    */
+
+
+/* @2595   identifier_node  strg: ppdict   lngt: 6 */
+/* @2576   type_decl        name: @2595    type: @2596    scpe: @221     */
+/*                          srcp: ppapi.h:45              chain: @2597    */
+/* @2596   record_type      name: @2576    unql: @2575    size: @593     */
+/*                          algn: 32       tag : struct   flds: @2594    */
+
+
+/* @2769   identifier_node  strg: ppcrypt_status          lngt: 14 */
+/* @2752   type_decl        name: @2769    type: @2770    scpe: @221     */
+/*                          srcp: ppapi.h:295             chain: @2771 */
+/* @2770   enumeral_type    name: @2752    unql: @2655    size: @5       */
+/*                          algn: 32       prec: 32       sign: signed   */
+/*                          min : @6       max : @7       csts: @2681    */
+
+
+/* @2558   identifier_node  strg: pparray  lngt: 7 */
+/* @2541   type_decl        name: @2558    type: @2559    scpe: @221     */
+/*                          srcp: ppapi.h:39              chain: @2560    */
+/* @2559   record_type      name: @2541    unql: @2540    size: @19      */
+/*                          algn: 32       tag : struct   flds: @2557 */
+
+
+/* @2817   identifier_node  strg: aligned_data */
+/* @2801   type_decl        name: @2817    type: @2818    scpe: @221     */
+/*                          srcp: ppheap.c:22             chain: @2819    */
+/* @2818   real_type        name: @2801    unql: @99      size: @19      */
+/*                          algn: 64       prec: 64       */
+
+
+typedef long double aligned_data;
+
+
+#define ALIGN_BUFF_BUCKET_SIZE  0x3000 /* heuristic value, found by running few tests */
+#ifdef __SIZEOF_POINTER__ 
+#define SIZE_OF_POINTER  __SIZEOF_POINTER__ 
+#else
+#define SIZE_OF_POINTER  (sizeof(void *))
+#endif 
+
+typedef struct _simplereg {
+  size_t bucket_pos;
+  size_t bucket_size;
+  size_t heap_instance;
+  aligned_data **align_data_set ;
+} simplereg;
+
+/* By default static vars are initialized to  NULL, but to be clear.. */
+static simplereg *align_set = NULL ; 
+
+static void align_init_set(void){
+   size_t size ;
+
+   if (align_set) {
+     align_set->heap_instance++;
+     return ;
+   }
+
+   align_set = malloc(sizeof(simplereg)); 
+   if (!align_set) {
+         fprintf(stderr,"! fatal error: unable to setup master register for  aligned pointers\n");
+         exit(EXIT_FAILURE);
+     }
+
+   size = SIZE_OF_POINTER*ALIGN_BUFF_BUCKET_SIZE;
+   align_set->align_data_set = malloc(size);
+   if (!align_set->align_data_set) {
+         fprintf(stderr,"! fatal error: unable to setup register for aligned pointers\n");
+         exit(EXIT_FAILURE);
+     }
+
+   align_set->bucket_pos = 0;
+   align_set->bucket_size = ALIGN_BUFF_BUCKET_SIZE;
+   align_set->heap_instance = 1;
+   memset(align_set->align_data_set, 0UL,size);
+}
+
+static void align_save_into_set(aligned_data *p){
+   if (align_set->bucket_pos >= align_set->bucket_size) {
+     size_t new_size;
+     aligned_data **align_data_set_new; 
+
+     if(!align_set->align_data_set){
+         fprintf(stderr,"! fatal error: unable to save aligned pointer,corrupted set\n");
+         exit(EXIT_FAILURE);
+     }
+     new_size = (ALIGN_BUFF_BUCKET_SIZE+align_set->bucket_size)*SIZE_OF_POINTER;
+     align_data_set_new = malloc(new_size);
+     if (!align_data_set_new) {
+         fprintf(stderr,"! fatal error: unable to save aligned pointer\n");
+         exit(EXIT_FAILURE);
+     }
+     memset(align_data_set_new,0,new_size);
+     memcpy(align_data_set_new, align_set->align_data_set, align_set->bucket_size*SIZE_OF_POINTER);
+     free(align_set->align_data_set);
+     align_set->align_data_set = align_data_set_new ;
+     align_set->bucket_size += ALIGN_BUFF_BUCKET_SIZE;
+   }
+   if (align_set->bucket_pos>align_set->bucket_size){
+     fprintf(stderr,"! fatal error: unable to save aligned pointer, wrong position\n");
+     exit(EXIT_FAILURE);
+   }
+   align_set->align_data_set[align_set->bucket_pos] = p ; 
+   align_set->bucket_pos++;
+
+}
+
+static void align_free_set(void){
+  /* We don't know what heap does with its data, so free here is not secure */
+
+  if(align_set){
+    if (align_set->heap_instance>1) {
+      align_set->heap_instance--;
+    } else if (align_set->heap_instance ==1) {
+      if (align_set->align_data_set){
+	size_t p;
+	for(p=1;p<align_set->bucket_pos;p++){
+	  if (align_set->align_data_set[p]) {
+	    free(align_set->align_data_set[p]);
+	  }
+	}
+	free(align_set->align_data_set);
+	align_set->align_data_set = NULL;
+      }
+      align_set->heap_instance=0;
+      free(align_set);
+      align_set = NULL ;
+    }
+  }
+}
+
+#endif /* PPHEAP_NEED_ALIGNMENT */
+
+
+static ppheap * ppheap_create (size_t size)
+{
+	ppheap *heap;
+	heap = (ppheap *)pp_malloc(sizeof(ppheap) + size * sizeof(uint8_t));
+	heap->size = size;
+	heap->space = size;
+	heap->data = ppheap_head(heap);
+	heap->prev = NULL;
+	return heap;
+}
+
+ppheap * ppheap_new (void)
+{
+#ifdef PPHEAP_NEED_ALIGNMENT
+        align_init_set();
+#endif  
+        return ppheap_create(PPHEAP_BUFFER);
+}
+
+void ppheap_free (ppheap *heap)
+{
+  ppheap *prev;
+  do
+  {
+    prev = heap->prev;
+    pp_free(heap);
+    heap = prev;
+  } while (heap != NULL);
+#ifdef PPHEAP_NEED_ALIGNMENT
+    align_free_set();
+#endif  
+
+}
+
+void ppheap_renew (ppheap *heap)
+{ // free all but first
+  ppheap *prev;
+  if ((prev = heap->prev) != NULL)
+  {
+    heap->prev = NULL;
+    ppheap_free(prev);
+  }
+  heap->size = heap->space;
+  heap->data = ppheap_head(heap);
+}
+
+static ppheap * ppheap_insert_top (ppheap **pheap, size_t size)
+{
+  ppheap *heap;
+  heap = ppheap_create(size);
+  heap->prev = (*pheap);
+  *pheap = heap;
+  return heap;
+}
+
+static ppheap * ppheap_insert_sub (ppheap **pheap, size_t size)
+{
+  ppheap *heap;
+  heap = ppheap_create(size);
+  heap->prev = (*pheap)->prev;
+  (*pheap)->prev = heap;
+  return heap;
+}
+
+void * ppheap_take (ppheap **pheap, size_t size)
+{
+	ppheap *heap;
+	uint8_t *data;
+#ifdef PPHEAP_NEED_ALIGNMENT
+	aligned_data *p_aligned_data;
+#endif  
+	heap = *pheap;
+	if (size <= heap->size)
+	  ;
+	else if (heap->size <= PPHEAP_WASTE && size <= (PPHEAP_BUFFER >> 1))
+	  heap = ppheap_insert_top(pheap, PPHEAP_BUFFER);
+	else
+        heap = ppheap_insert_sub(pheap, size);
+ 	data = heap->data;
+ 	heap->data += size;
+ 	heap->size -= size;
+#ifdef PPHEAP_NEED_ALIGNMENT
+	/* Todo: only if data%sizeof(aligned_data) != 0 */
+	p_aligned_data = malloc(size);
+	memcpy(p_aligned_data,data,size);
+	align_save_into_set(p_aligned_data);
+	return (void *)p_aligned_data;
+#else
+ 	return (void *)data;
+#endif  
+
+}
+
+
+/* iof buffer tied to a heap */
+
+static ppheap * ppheap_resize  (ppheap **pheap, size_t size)
+{
+  ppheap *heap;
+  heap = ppheap_create(size);
+  heap->prev = (*pheap)->prev;
+  memcpy(heap->data, (*pheap)->data, (*pheap)->space); // (*pheap)->size is irrelevant
+  pp_free(*pheap);
+  *pheap = heap;
+  return heap;
+}
+
+static size_t ppheap_buffer_handler (iof *O, iof_mode mode)
+{
+  ppheap **pheap, *heap;
+  size_t objectsize, buffersize, neededsize;
+  uint8_t *copyfrom;
+  switch (mode)
+  {
+    case IOFWRITE:
+      /* apparently more space needed then assumed initsize */
+      pheap = (ppheap **)O->link;
+      heap = *pheap;
+      objectsize = (size_t)(O->buf - heap->data);
+      buffersize = (size_t)(O->pos - O->buf);
+      neededsize = objectsize + (buffersize << 1);
+      if (ppheap_head(heap) < heap->data)
+      {
+        if (heap->size <= PPHEAP_WASTE && neededsize <= (PPHEAP_BUFFER >> 1))
+        {
+          heap = ppheap_insert_top(pheap, PPHEAP_BUFFER);
+          copyfrom = heap->prev->data;
+        }
+        else
+        {
+          heap = ppheap_insert_sub(pheap, neededsize);
+          copyfrom = (*pheap)->data;
+          O->link = (void *)(&(*pheap)->prev);
+        }
+        memcpy(heap->data, copyfrom, objectsize + buffersize);
+      }
+      else
+      { /* the buffer was (re)initialized from a new empty heap and occupies its entire space */
+        // ASSERT(ppheap_head(heap) == heap->data);
+        heap = ppheap_resize(pheap, neededsize);
+      }
+      O->buf = heap->data + objectsize;
+      O->pos = O->buf + buffersize;
+      O->end = heap->data + heap->size;
+      return (size_t)(O->end - O->pos);
+    case IOFFLUSH:
+      return 0;
+    case IOFCLOSE:
+      // O->buf = O->pos = O->end = NULL;
+      // O->link = NULL;
+      return 0;
+    default:
+      break;
+  }
+  return 0;
+}
+
+iof * ppheap_buffer (ppheap **pheap, size_t objectsize, size_t initsize)
+{
+  static iof ppheap_buffer_iof = IOF_WRITER_STRUCT(ppheap_buffer_handler, NULL, NULL, 0, 0);
+  ppheap *heap;
+  size_t size;
+  size = objectsize + initsize;
+  heap = *pheap;
+  if (size <= heap->size)
+    ;
+  else if (heap->size <= PPHEAP_WASTE && size <= (PPHEAP_BUFFER >> 1))
+  {
+    heap = ppheap_create(PPHEAP_BUFFER);
+    heap->prev = (*pheap);
+    *pheap = heap;
+  }
+  else
+  {
+    heap = ppheap_create(size);
+    heap->prev = (*pheap)->prev;
+    (*pheap)->prev = heap;
+    pheap = &(*pheap)->prev; // passed to ppheap_buffer_iof.link
+  }
+  ppheap_buffer_iof.buf = ppheap_buffer_iof.pos = heap->data + objectsize;
+  ppheap_buffer_iof.end = heap->data + heap->size;
+  ppheap_buffer_iof.link = pheap; // ASSERT(*pheap == heap)
+  return &ppheap_buffer_iof;
+}
+
+/*
+void * ppheap_buffer_data (iof *O, size_t *psize)
+{
+  ppheap *heap;
+  heap = *((ppheap **)(O->link));
+  *psize = ppheap_buffer_size(O, heap);
+  return heap->data;
+}
+*/
+
+void * ppheap_flush (iof *O, size_t *psize) // not from explicit ppheap ** !!!
+{
+  ppheap *heap;
+  uint8_t *data;
+  size_t size;
+#ifdef PPHEAP_NEED_ALIGNMENT
+  aligned_data *p_aligned_data;
+#endif  
+  heap = *((ppheap **)(O->link));
+  *psize = ppheap_buffer_size(O, heap);
+  size = *psize;
+  data = heap->data;
+/*  heap->data += *psize;
+  heap->size -= *psize;
+*/
+  heap->data += size;
+  heap->size -= size;
+  // O->buf = O->pos = O->end = NULL;
+  // O->link = NULL;
+  // iof_close(O);
+#ifdef PPHEAP_NEED_ALIGNMENT
+  /* Todo: only if data%sizeof(aligned_data) != 0 */
+  p_aligned_data = malloc(size);
+  memcpy(p_aligned_data,data,size);
+  align_save_into_set(p_aligned_data);
+  return (void *)p_aligned_data;
+#else
+  return data;
+
+#endif  
+
+
+}
+
+
diff --git a/texk/web2c/luatexdir/luapplib/ppheap.h b/texk/web2c/luatexdir/luapplib/ppheap.h
new file mode 100644
index 000000000..128f9c56d
--- /dev/null
+++ b/texk/web2c/luatexdir/luapplib/ppheap.h
@@ -0,0 +1,29 @@
+
+#ifndef PP_HEAP_H
+#define PP_HEAP_H
+
+#include "utilmem.h"
+
+#define pp_malloc util_malloc
+#define pp_callic util_calloc
+#define pprealloc util_realloc
+#define pp_free util_free
+
+typedef struct ppheap ppheap;
+struct ppheap {
+	size_t size;
+	size_t space;
+	uint8_t *data;
+	ppheap *prev;
+};
+
+ppheap * ppheap_new (void);
+void ppheap_free (ppheap *heap);
+void ppheap_renew (ppheap *heap);
+void * ppheap_take (ppheap **pheap, size_t size);
+iof * ppheap_buffer (ppheap **pheap, size_t objectsize, size_t initsize);
+#define ppheap_buffer_size(O, heap) (size_t)((O)->pos - (heap)->data) // == (size_t)(O->buf - heap->data) + (size_t)(O->pos - O->buf);
+//void * ppheap_buffer_data (iof *O, size_t *psize);
+void * ppheap_flush (iof *O, size_t *psize);
+
+#endif
\ No newline at end of file
diff --git a/texk/web2c/luatexdir/luapplib/pplib.h b/texk/web2c/luatexdir/luapplib/pplib.h
new file mode 100644
index 000000000..e753cfa05
--- /dev/null
+++ b/texk/web2c/luatexdir/luapplib/pplib.h
@@ -0,0 +1,22 @@
+
+#ifndef PP_LIB_H
+#define PP_LIB_H
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+
+#include "utiliof.h"
+#include "utillog.h"
+
+#include "ppapi.h"
+#include "ppheap.h"
+#include "ppdict.h"
+#include "ppstream.h"
+#include "pparray.h"
+#include "ppcrypt.h"
+#include "ppxref.h"
+#include "ppload.h"
+
+#endif
\ No newline at end of file
diff --git a/texk/web2c/luatexdir/luapplib/ppload.c b/texk/web2c/luatexdir/luapplib/ppload.c
new file mode 100644
index 000000000..0ad286e57
--- /dev/null
+++ b/texk/web2c/luatexdir/luapplib/ppload.c
@@ -0,0 +1,2590 @@
+
+#include <utilbasexx.h>
+
+#include "pplib.h"
+
+const char * ppobj_kind[] = { "none", "null", "bool", "integer", "number", "name", "string", "array", "dict", "stream", "ref" };
+
+#define ignored_char(c) (c == 0x20 || c == 0x0A || c == 0x0D || c == 0x09 || c == 0x00)
+#define newline_char(c) (c == 0x0A || c == 0x0D)
+#define IGNORED_CHAR_CASE 0x20: case 0x0A: case 0x0D: case 0x09: case 0x00
+#define NEWLINE_CHAR_CASE 0x0A: case 0x0D
+#define DIGIT_CHAR_CASE '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9'
+#define OCTAL_CHAR_CASE '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7'
+
+#define MAX_INT_DIGITS 32
+
+#define PP_LENGTH_UNKNOWN ((size_t)-1)
+
+static const char * ppref_str (ppuint refnumber, ppuint refversion)
+{
+	static char buffer[MAX_INT_DIGITS + 1 + MAX_INT_DIGITS + 1 + 1 + 1];
+#if defined(MSVC64)|| defined(MINGW64)
+	sprintf(buffer, PPUINTF " " PPUINTF " R", refnumber, refversion);
+#else
+	sprintf(buffer, PPUINTF " " PPUINTF " R", (unsigned long)(refnumber), (unsigned long)(refversion));
+#endif
+	return buffer;
+}
+
+/* name */
+
+// pdf name delimiters: 0..32, ()<>[]{}/%
+// # treated specially
+// .+- are valid part of name; keep in mind names such as -| | |- .notdef ABCDEF+Font etc.
+const char ppname_byte_lookup[] = {
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 1, 1, '#', 1, 0, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0,
+  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1,
+  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1,
+  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1,
+  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
+};
+
+#define PPNAME_INIT (8+1)
+
+#define ppname_flush(O, ghost, siz, flgs) \
+  (iof_put(O, '\0'), \
+   ghost = (_ppname *)ppheap_flush(O, &siz), \
+   ghost->flags = flgs, \
+   ghost->size = siz - sizeof(_ppname) - 1, \
+  (ppname)(ghost + 1))
+
+#define ppname_flush_with_ego(O, ghost, siz, flgs) \
+  (iof_put(O, '\0'), \
+   iof_ensure(O, sizeof(ppname *)), \
+   O->pos += sizeof(ppname *), \
+   ghost = (_ppname *)ppheap_flush(O, &siz), \
+   ghost->flags = flgs, \
+   ghost->size = siz - sizeof(_ppname) - 1 - sizeof(ppname *), \
+  (ppname)(ghost + 1))
+
+
+#if defined __arm__ || defined __ARM__ || defined ARM || defined __ARM || defined __arm || defined __ARM_ARCH ||defined __aarch64__ 
+#define ppname_set_alter_ego(name, ghost, ego) do {\
+    ppname temp;\
+    ppname *temp1;\
+    temp =  (name + (ghost)->size + 1) ; \
+    temp1 = (ppname *)((void*)temp); \
+    *temp1= ego; \
+    }while(0)
+#else
+#define ppname_set_alter_ego(name, ghost, ego) (*((ppname *)(name + (ghost)->size + 1)) = ego)
+#endif
+
+#if defined __arm__ || defined __ARM__ || defined ARM || defined __ARM || defined __arm || defined __ARM_ARCH ||defined __aarch64__ 
+#define ppname_get_alter_ego(name) (*((ppname *)( (void*)(name + ppname_size(name) + 1))))
+#else
+#define ppname_get_alter_ego(name) (*((ppname *)(name + ppname_size(name) + 1)))
+#endif
+
+
+
+
+
+static ppname ppscan_name (iof *I, ppheap **pheap)
+{
+  int c, decode;
+  iof *O;
+  _ppname *ghost1, *ghost2;
+  ppname encoded, decoded;
+  size_t size;
+  const char *p, *e;
+  uint8_t v1, v2;
+  O = ppheap_buffer(pheap, sizeof(_ppname), PPNAME_INIT);
+  for (decode = 0, c = iof_char(I); c >= 0 && ppname_byte_lookup[c]; c = iof_next(I))
+  {
+    if (c == '#')
+      decode = 1;
+    iof_put(O, c);
+  }
+  if (!decode)
+    return ppname_flush(O, ghost1, size, 0);
+  encoded = ppname_flush_with_ego(O, ghost1, size, 0|PPNAME_ENCODED);
+  O = ppheap_buffer(pheap, sizeof(_ppname), PPNAME_INIT);
+  for (p = encoded, e = encoded + ghost1->size; p < e; ++p)
+  {
+    if (*p == '#' && p + 2 < e ){
+      v1 = base16_value(p[1]);
+      v2 = base16_value(p[2]);
+      iof_put(O, ((v1<<4)+v2));
+    }else
+      iof_put(O, *p);
+  }
+  decoded = ppname_flush_with_ego(O, ghost2, size, 0|PPNAME_DECODED);
+  ppname_set_alter_ego(encoded, ghost1, decoded);
+  ppname_set_alter_ego(decoded, ghost2, encoded);
+  return encoded;
+}
+
+static ppname ppscan_exec (iof *I, ppheap **pheap, int first)
+{
+  int c, decode;
+  iof *O;
+  _ppname *ghost1, *ghost2;
+  ppname encoded, decoded;
+  size_t size;
+  const char *p, *e;
+  uint8_t v1, v2;
+
+  O = ppheap_buffer(pheap, sizeof(_ppname), PPNAME_INIT);
+  iof_put(O, first);
+  for (decode = 0, c = iof_char(I); c >= 0 && ppname_byte_lookup[c]; c = iof_next(I))
+  {
+    if (c == '#')
+      decode = 1;
+    iof_put(O, c);
+  }
+  if (!decode)
+    return ppname_flush(O, ghost1, size, PPNAME_EXEC);
+  encoded = ppname_flush_with_ego(O, ghost1, size, PPNAME_EXEC|PPNAME_ENCODED);
+  O = ppheap_buffer(pheap, sizeof(_ppname), PPNAME_INIT);
+  for (p = encoded, e = encoded + ghost1->size; p < e; ++p)
+  {
+    if (*p == '#' && p + 2 < e ){
+      v1 = base16_value(p[1]);
+      v2 = base16_value(p[2]);
+      iof_put(O, ((v1<<4)+v2));
+    }else
+      iof_put(O, *p);
+  }
+  decoded = ppname_flush_with_ego(O, ghost2, size, PPNAME_EXEC|PPNAME_DECODED);
+  ppname_set_alter_ego(encoded, ghost1, decoded);
+  ppname_set_alter_ego(decoded, ghost2, encoded);
+  return encoded;
+}
+
+static ppname ppexec_internal (const void *data, size_t size, ppheap **pheap)
+{ // used only for artificial 'EI' operator name
+  iof *O;
+  _ppname *ghost1;
+
+  O = ppheap_buffer(pheap, sizeof(_ppname), size);
+  iof_write(O, data, size);
+  return ppname_flush(O, ghost1, size, PPNAME_EXEC);
+}
+
+ppname ppname_decoded (ppname name)
+{
+  const _ppname *ghost;
+  ghost = _ppname_ghost(name);
+  return (ghost->flags & PPNAME_ENCODED) ? ppname_get_alter_ego(name) : name;
+}
+
+ppname ppname_encoded (ppname name)
+{
+  const _ppname *ghost;
+  ghost = _ppname_ghost(name);
+  return (ghost->flags & PPNAME_DECODED) ? ppname_get_alter_ego(name) : name;
+}
+
+/* string */
+
+#define PPSTRING_INIT (16+1)
+
+#define ppstring_flush(O, ghost, siz, flgs) \
+  (iof_put(O, '\0'), \
+   ghost = (_ppstring *)ppheap_flush(O, &siz), \
+   ghost->flags = flgs, \
+   ghost->size = siz - sizeof(_ppstring) - 1, \
+  (ppstring)(ghost + 1))
+
+#define ppstring_flush_with_ego(O, ghost, siz, flgs) \
+  (iof_put(O, '\0'), \
+   iof_ensure(O, sizeof(ppstring *)), \
+   O->pos += sizeof(ppstring *), \
+   ghost = (_ppstring *)ppheap_flush(O, &siz), \
+   ghost->flags = flgs, \
+   ghost->size = siz - sizeof(_ppstring) - 1 - sizeof(ppstring *), \
+  (ppstring)(ghost + 1))
+
+#define ppstring_utf16be_bom(decoded) (decoded[0] == ((char)0xFE) && decoded[1] == ((char)0xFF) )
+#define ppstring_utf16le_bom(decoded) (decoded[0] == ((char)0xFF) && decoded[1] == ((char)0xFE))
+
+#define ppstring_check_bom(decoded, ghost) ((void)\
+  (ghost->size >= 2 ? (ppstring_utf16be_bom(decoded) ? (ghost->flags |= PPSTRING_UTF16BE) : \
+                      (ppstring_utf16le_bom(decoded) ? (ghost->flags |= PPSTRING_UTF16LE) : 0)) : 0))
+
+#define ppstring_check_bom2(decoded, ghost1, ghost2) ((void)\
+  (ghost2->size >= 2 ? (ppstring_utf16be_bom(decoded) ? ((ghost1->flags |= PPSTRING_UTF16BE), (ghost2->flags |= PPSTRING_UTF16BE)) : \
+                       (ppstring_utf16le_bom(decoded) ? ((ghost1->flags |= PPSTRING_UTF16LE), (ghost2->flags |= PPSTRING_UTF16LE)) : 0)) : 0))
+
+
+
+#if defined __arm__ || defined __ARM__ || defined ARM || defined __ARM || defined __arm || defined __ARM_ARCH ||defined __aarch64__ 
+#define ppstring_set_alter_ego(string, ghost, ego) (*((ppstring *)((void *)(string + (ghost)->size + 1))) = ego)
+#else
+#define ppstring_set_alter_ego(string, ghost, ego) (*((ppstring *)(string + (ghost)->size + 1)) = ego)
+#endif
+
+
+#if defined __arm__ || defined __ARM__ || defined ARM || defined __ARM || defined __arm || defined __ARM_ARCH ||defined __aarch64__ 
+#define ppstring_get_alter_ego(string) (*((ppstring *)((void *)(string + ppstring_size(string) + 1))))
+#else
+#define ppstring_get_alter_ego(string) (*((ppstring *)(string + ppstring_size(string) + 1)))
+#endif
+
+
+
+
+static ppstring ppscan_string (iof *I, ppheap **pheap)
+{
+  int c, decode, balance;
+  iof *O;
+  _ppstring *ghost1, *ghost2;
+  uint8_t *p, *e;
+  ppstring encoded, decoded;
+  size_t size;
+  O = ppheap_buffer(pheap, sizeof(_ppstring), PPSTRING_INIT);
+  for (decode = 0, balance = 0, c = iof_char(I); c >= 0; )
+  {
+    switch (c)
+    {
+      case '\\':
+        decode = 1; // unescaping later
+        iof_put(O, '\\');
+        if ((c = iof_next(I)) >= 0)
+        {
+          iof_put(O, c);
+          c = iof_next(I);
+        }
+        break;
+      case '(': // may be unescaped if balanced
+        ++balance;
+        iof_put(O, '(');
+        c = iof_next(I);
+        break;
+      case ')':
+        if (balance == 0)
+        {
+          c = IOFEOF;
+          ++I->pos;
+          break;
+        }
+        --balance;
+        iof_put(O, ')');
+        c = iof_next(I);
+        break;
+      default:
+        iof_put(O, c);
+        c = iof_next(I);
+    }
+  }
+  if (!decode)
+  {
+    encoded = ppstring_flush(O, ghost1, size, 0);
+    ppstring_check_bom(encoded, ghost1); // any bytes can be there
+    return encoded;
+  }
+  encoded = ppstring_flush_with_ego(O, ghost1, size, 0|PPSTRING_ENCODED);
+  O = ppheap_buffer(pheap, sizeof(_ppstring), PPSTRING_INIT);
+  for (p = (uint8_t *)encoded, e = (uint8_t *)encoded + ghost1->size; p < e; ++p)
+  {
+    if (*p == '\\')
+    {
+      if (++p >= e)
+        break;
+      switch (*p)
+      {
+        case OCTAL_CHAR_CASE:
+          c = *p - '0';
+          if (++p < e && *p >= '0' && *p <= '7')
+          {
+            c = (c << 3) + *p - '0';
+            if (++p < e && *p >= '0' && *p <= '7')
+              c = (c << 3) + *p - '0';
+          }
+          iof_put(O, c);
+          break;
+        case 'n':
+          iof_put(O, '\n');
+          break;
+        case 'r':
+          iof_put(O, '\r');
+          break;
+        case 't':
+          iof_put(O, '\t');
+          break;
+        case 'b':
+          iof_put(O, '\b');
+          break;
+        case 'f':
+          iof_put(O, '\f');
+          break;
+        case NEWLINE_CHAR_CASE: // not a part of the string, ignore (pdf spec page 55)
+          break;
+        case '(': case ')': case '\\':
+        default: // for enything else backslash is ignored (pdf spec page 54)
+          iof_put(O, *p);
+          break;
+      }
+    }
+    else
+      iof_put(O, *p);
+  }
+  decoded = ppstring_flush_with_ego(O, ghost2, size, 0|PPSTRING_DECODED);
+  ppstring_check_bom2(decoded, ghost1, ghost2);
+  ppstring_set_alter_ego(encoded, ghost1, decoded);
+  ppstring_set_alter_ego(decoded, ghost2, encoded);
+  return encoded;
+}
+
+/* Hex string may contain white characters. If odd number of digits, the last assumed to be '0' */
+
+static ppstring ppscan_base16 (iof *I, ppheap **pheap)
+{
+  int c, v1, v2;
+  iof *O;
+  _ppstring *ghost1, *ghost2;
+  size_t size;
+  ppstring encoded, decoded;
+  uint8_t *p, *e;
+
+  O = ppheap_buffer(pheap, sizeof(_ppstring), PPSTRING_INIT);
+  for (c = iof_char(I); c >= 0 && (base16_digit(c) || ignored_char(c)); c = iof_next(I))
+    iof_put(O, c);
+  if (c == '>')
+    ++I->pos;
+  encoded = ppstring_flush_with_ego(O, ghost1, size, PPSTRING_BASE16|PPSTRING_ENCODED);
+  O = ppheap_buffer(pheap, sizeof(_ppstring), (ghost1->size >> 1) + 1);
+  for (p = (uint8_t *)encoded, e = (uint8_t *)encoded + ghost1->size; p < e; ++p)
+  {
+    if ((v1 = base16_value(*p)) < 0) // ignored
+      continue;
+    for (v2 = 0, ++p; p < e && (v2 = base16_value(*p)) < 0; ++p);
+    iof_put(O, (v1<<4)|v2);
+  }
+  decoded = ppstring_flush_with_ego(O, ghost2, size, 0|PPSTRING_DECODED);
+  ppstring_check_bom2(decoded, ghost1, ghost2);
+  ppstring_set_alter_ego(encoded, ghost1, decoded);
+  ppstring_set_alter_ego(decoded, ghost2, encoded);
+  return encoded;
+}
+
+/* internal use only; binary string */
+
+static ppstring ppstring_buffer (iof *O, ppheap **pheap)
+{
+   _ppstring *ghost1, *ghost2;
+   ppstring encoded, decoded;
+   uint8_t *p, *e;
+   size_t size;
+
+   decoded = ppstring_flush_with_ego(O, ghost2, size, 0|PPSTRING_DECODED);
+   O = ppheap_buffer(pheap, sizeof(_ppstring), (ghost2->size << 1) + 1);
+   for (p = (uint8_t *)decoded, e = (uint8_t *)decoded + ghost2->size; p < e; ++p)
+     iof_set2(O, base16_uc_alphabet[(*p)>>4], base16_uc_alphabet[(*p)&15]);
+   encoded = ppstring_flush_with_ego(O, ghost1, size, PPSTRING_BASE16|PPSTRING_ENCODED);
+   ppstring_set_alter_ego(encoded, ghost1, decoded);
+   ppstring_set_alter_ego(decoded, ghost2, encoded);
+   return encoded;
+}
+
+ppstring ppstring_internal (const void *data, size_t size, ppheap **pheap)
+{ // so far used only for crypt key
+  iof *O;
+
+  O = ppheap_buffer(pheap, sizeof(_ppstring), size);
+  iof_write(O, data, size);
+  return ppstring_buffer(O, pheap);
+}
+
+/* PDF spec says nothing about base85 strings, but streams might be (afair no leading '<~' but present trailing '~>') */
+
+static ppstring ppscan_base85 (iof *I, ppheap **pheap)
+{ // bawse85 alphabet is 33.117, adobe also hires 'z' and 'y' for compression
+  int c;
+  iof *O, B;
+  _ppstring *ghost1, *ghost2;
+  size_t size;
+  ppstring encoded, decoded;
+  O = ppheap_buffer(pheap, sizeof(_ppstring), PPSTRING_INIT);
+  for (c = iof_char(I); (c >= '!' && c <= 'u') || c == 'z' || c == 'y'; c = iof_next(I))
+    iof_put(O, c);
+  if (c == '~')
+    if ((c = iof_next(I)) == '>')
+      ++I->pos;
+  encoded = ppstring_flush_with_ego(O, ghost1, size, PPSTRING_BASE85|PPSTRING_ENCODED);
+  iof_string_reader(&B, encoded, ghost1->size);
+  O = ppheap_buffer(pheap, sizeof(_ppstring), (ghost1->size * 5 / 4) + 1);
+  base85_decode(&B, O);
+  decoded = ppstring_flush_with_ego(O, ghost2, size, 0|PPSTRING_DECODED);
+  ppstring_check_bom2(decoded, ghost1, ghost2);
+  ppstring_set_alter_ego(encoded, ghost1, decoded);
+  ppstring_set_alter_ego(decoded, ghost2, encoded);
+  return encoded;
+}
+
+/*
+Encrypted strings. In case of encrypted strings, we first need to decode the string (saving original form hardly makes sense),
+then decrypt the string, and encode it again.
+*/
+
+const char ppstring_byte_escape[] = { /* -1 escaped with octal, >0 escaped with \\, 0 left intact*/
+ -1,-1,-1,-1,-1,-1,-1,-1,'b','t','n',-1,'f','r',-1,-1,
+ -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+  0, 0, 0, 0, 0, 0, 0, 0,'(',')', 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,'\\', 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+ -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+ -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+ -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+ -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+ -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+ -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+ -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1
+};
+
+
+static ppstring ppscan_crypt_string (iof *I, ppcrypt *crypt, ppheap **pheap)
+{
+  int c, b, balance, encode;
+  iof *O;
+  _ppstring *ghost1, *ghost2;
+  ppstring encoded, decoded;
+  uint8_t *p, *e;
+  size_t size;
+
+  O = ppheap_buffer(pheap, sizeof(_ppstring), PPSTRING_INIT);
+  for (balance = 0, encode = 0, c = iof_char(I); c >= 0; )
+  {
+    switch (c)
+    {
+      case '\\':
+        if ((c = iof_next(I)) < 0)
+          break;
+        encode = 1;
+        switch (c)
+        {
+          case OCTAL_CHAR_CASE:
+            b = c - '0';
+            if ((c = iof_next(I)) >= 0 && c >= '0' && c <= '7')
+            {
+              b = (b << 3) + c - '0';
+              if ((c = iof_next(I)) >= 0 && c >= '0' && c <= '7')
+              {
+                b = (b << 3) + c - '0';
+                c = iof_next(I);
+              }
+            }
+            iof_put(O, b);
+            // c is set to the next char
+            break;
+          case 'n':
+            iof_put(O, '\n');
+            c = iof_next(I);
+            break;
+          case 'r':
+            iof_put(O, '\r');
+            c = iof_next(I);
+            break;
+          case 't':
+            iof_put(O, '\t');
+            c = iof_next(I);
+            break;
+          case 'b':
+            iof_put(O, '\b');
+            c = iof_next(I);
+            break;
+          case 'f':
+            iof_put(O, '\f');
+            c = iof_next(I);
+            break;
+          case NEWLINE_CHAR_CASE: // not a part of the string, ignore (pdf spec page 55)
+            c = iof_next(I);
+            break;
+          case '(': case ')': case '\\':
+          default: // for enything else backslash is ignored (pdf spec page 54)
+            iof_put(O, c);
+            c = iof_next(I);
+            break;
+        }
+        break;
+      case '(':
+        ++balance;
+        encode = 1;
+        iof_put(O, '(');
+        c = iof_next(I);
+        break;
+      case ')':
+        if (balance == 0)
+        {
+          c = IOFEOF;
+          ++I->pos;
+        }
+        else
+        {
+          --balance;
+          //encode = 1;
+          iof_put(O, ')');
+          c = iof_next(I);
+        }
+        break;
+      default:
+        if (ppstring_byte_escape[c] != 0)
+          encode = 1;
+        iof_put(O, c);
+        c = iof_next(I);
+    }
+  }
+  /* decrypt the buffer in place, update size */
+  if (ppstring_decrypt(crypt, O->buf, iof_size(O), O->buf, &size))
+    O->pos = O->buf + size;
+  /* make encoded counterpart */
+  if (!encode)
+  {
+    decoded = ppstring_flush(O, ghost2, size, 0);
+    ppstring_check_bom(decoded, ghost2);
+    return decoded;
+  }
+  decoded = ppstring_flush_with_ego(O, ghost2, size, PPSTRING_DECODED);
+  O = ppheap_buffer(pheap, sizeof(_ppstring), ghost2->size);
+  for (p = (uint8_t *)decoded, e = (uint8_t *)decoded + ghost2->size; p < e; ++p)
+  {
+    switch ((b = ppstring_byte_escape[*p]))
+    {
+      case 0:
+        iof_put(O, *p);
+        break;
+      case -1:
+        iof_put4(O, '\\', (c >> 6) + '0', ((c >> 3) & 7) + '0', (c & 7) + '0');
+        break;
+      default:
+        iof_put2(O, '\\', b);
+        break;
+    }
+  }
+  encoded = ppstring_flush_with_ego(O, ghost1, size, PPSTRING_ENCODED);
+  ppstring_check_bom2(decoded, ghost1, ghost2);
+  ppstring_set_alter_ego(encoded, ghost1, decoded);
+  ppstring_set_alter_ego(decoded, ghost2, encoded);
+  return encoded;
+}
+
+
+static ppstring ppscan_crypt_base16 (iof *I, ppcrypt *crypt, ppheap **pheap)
+{
+  int c, v1, v2;
+  iof *O;
+  _ppstring *ghost1, *ghost2;
+  ppstring encoded, decoded;
+  uint8_t *p, *e;
+  size_t size;
+
+  O = ppheap_buffer(pheap, sizeof(_ppstring), PPSTRING_INIT);
+  // base16_decode(I, O); // no info about the last char..
+  for (c = iof_char(I); c != '>' && c >= 0; )
+  {
+    if ((v1 = base16_value(c)) < 0)
+    {
+      if (ignored_char(c))
+      {
+        c = iof_next(I);
+        continue;
+      }
+      break;
+    }
+    do {
+      c = iof_next(I);
+      if ((v2 = base16_value(c)) >= 0)
+      {
+        c = iof_next(I);
+        break;
+      }
+      if (!ignored_char(c)) // c == '>' || c < 0 or some crap
+      {
+        v2 = 0;
+        break;
+      }
+    } while (1);
+    iof_put(O, (v1 << 4)|v2);
+  }
+  if (c == '>')
+    ++I->pos;
+  /* decrypt the buffer in place, update size */
+  if (ppstring_decrypt(crypt, O->buf, iof_size(O), O->buf, &size))
+    O->pos = O->buf + size;
+  decoded = ppstring_flush_with_ego(O, ghost2, size, PPSTRING_DECODED);
+  /* recreate an encoded form */
+  O = ppheap_buffer(pheap, sizeof(_ppstring), (ghost2->size << 1) + 1);
+  for (p = (uint8_t *)decoded, e = (uint8_t *)decoded + ghost2->size; p < e; ++p)
+    iof_set2(O, base16_uc_alphabet[(*p)>>4], base16_uc_alphabet[(*p)&15]);
+  encoded = ppstring_flush_with_ego(O, ghost1, size, PPSTRING_BASE16|PPSTRING_ENCODED);
+  ppstring_check_bom2(decoded, ghost1, ghost2);
+  ppstring_set_alter_ego(encoded, ghost1, decoded);
+  ppstring_set_alter_ego(decoded, ghost2, encoded);
+  return encoded;
+}
+
+/* ppstring alter ego switcher */
+
+ppstring ppstring_decoded (ppstring string)
+{
+  const _ppstring *ghost;
+  ghost = _ppstring_ghost(string);
+  return (ghost->flags & PPSTRING_ENCODED) ? ppstring_get_alter_ego(string) : string;
+}
+
+ppstring ppstring_encoded (ppstring string)
+{
+  const _ppstring *ghost;
+  ghost = _ppstring_ghost(string);
+  return (ghost->flags & PPSTRING_DECODED) ? ppstring_get_alter_ego(string) : string;
+}
+
+/* scanner stack */
+
+#define PPSTACK_BUFFER 512
+
+static void ppstack_init (ppstack *stack, ppheap **pheap)
+{
+  stack->buf = stack->pos = (ppobj *)pp_malloc(PPSTACK_BUFFER * sizeof(ppobj));
+  stack->size = 0;
+  stack->space = PPSTACK_BUFFER;
+  stack->pheap = pheap;
+}
+
+#define ppstack_free_buffer(stack) (pp_free((stack)->buf))
+
+static void ppstack_resize (ppstack *stack)
+{
+  ppobj *newbuffer;
+  stack->space <<= 1;
+  newbuffer = (ppobj *)pp_malloc(stack->space * sizeof(ppobj));
+  memcpy(newbuffer, stack->buf, stack->size * sizeof(ppobj));
+  ppstack_free_buffer(stack);
+  stack->buf = newbuffer;
+  stack->pos = newbuffer + stack->size;
+}
+
+#define ppstack_push(stack) ((void)((stack)->size < (stack)->space || (ppstack_resize(stack), 0)), ++(stack)->size, (stack)->pos++)
+#define ppstack_pop(stack, n) ((stack)->size -= (n), (stack)->pos -= (n))
+#define ppstack_at(stack, i) ((stack)->buf + i)
+#define ppstack_clear(stack) ((stack)->pos = (stack)->buf, (stack)->size = 0)
+
+/* scanner commons */
+
+#define ppscan_uint(I, u) iof_get_uintlw(I, u)
+#define ppread_uint(s, u) string_to_uintlw((const char *)(s), u)
+
+static ppobj * ppscan_numobj (iof *I, ppobj *obj, int negative)
+{
+  ppint integer;
+  ppnum number;
+  int exponent;
+  int c;
+  c = iof_char(I);
+  iof_scan_integer(I, c, integer);
+  switch(c)
+  {
+    case '.':
+    {
+      number = (ppnum)integer;
+      c = iof_next(I);
+      iof_scan_fraction(I, c, number, exponent);
+      double_negative_exp10(number, exponent);
+      obj->type = PPNUM, obj->number = negative ? -number : number;
+      break;
+    }
+    default:
+      obj->type = PPINT, obj->integer = negative ? -integer : integer;
+      break;
+  }
+  return obj;
+}
+
+static ppobj * ppscan_numobj_frac (iof *I, ppobj *obj, int negative)
+{
+  ppnum number;
+  int c, exponent;
+
+  number = 0.0;
+  c = iof_next(I);
+  iof_scan_fraction(I, c, number, exponent);
+  double_negative_exp10(number, exponent);
+  obj->type = PPNUM, obj->number = negative ? -number : number;
+  return obj;
+}
+
+static int ppscan_find (iof *I)
+{ // skips whitechars and comments
+  int c;
+  for (c = iof_char(I); ; c = iof_next(I))
+  {
+    switch (c)
+    {
+      case IGNORED_CHAR_CASE:
+        break;
+      case '%': {
+        do {
+          if ((c = iof_next(I)) < 0)
+            return c;
+        } while (!newline_char(c));
+        break;
+      }
+      default:
+        return c;
+    }
+  }
+  return c; // never reached
+}
+
+static int ppscan_keyword (iof *I, const char *keyword, size_t size)
+{
+  size_t i;
+  int c;
+  if (iof_left(I) >= size)
+  {
+    if (memcmp(I->pos, keyword, size) != 0)
+      return 0;
+    I->pos += size;
+    return 1;
+  }
+  // sticky case, we can't go back
+  for (i = 0, c = iof_char(I); i < size; ++i, ++keyword, c = iof_next(I))
+    if (i != c)
+      return 0;
+  return 1;
+}
+
+#define ppscan_key(I, literal) ppscan_keyword(I, "" literal, sizeof(literal) - 1)
+
+/* objects parser */
+
+static ppref * ppref_unresolved (ppheap **pheap, ppuint refnumber, ppuint refversion)
+{
+  ppref *ref = (ppref *)ppheap_take(pheap, sizeof(ppref));
+  memset(ref, 0, sizeof(ppref));
+  ref->object.type = PPNONE;
+  ref->number = refnumber;
+  ref->version = refversion;
+  return ref;
+}
+
+#define PPMARK PPNONE
+
+static ppobj * ppscan_obj (iof *I, ppdoc *pdf, ppxref *xref)
+{
+  int c;
+  ppobj *obj;
+  size_t mark, size;
+  ppuint refnumber, refversion;
+  ppref *ref;
+  ppstack *stack;
+  ppcrypt *crypt;
+
+  stack = &pdf->stack;
+  c = iof_char(I);
+  switch (c)
+  {
+    case DIGIT_CHAR_CASE:
+      return ppscan_numobj(I, ppstack_push(stack), 0);
+    case '.':
+      return ppscan_numobj_frac(I, ppstack_push(stack), 0);
+    case '+':
+      ++I->pos;
+      return ppscan_numobj(I, ppstack_push(stack), 0);
+    case '-':
+      ++I->pos;
+      return ppscan_numobj(I, ppstack_push(stack), 1);
+    case '/':
+      ++I->pos;
+      obj = ppstack_push(stack);
+      obj->type = PPNAME;
+      obj->name = ppscan_name(I, &pdf->heap);
+      return obj;
+    case '(':
+      ++I->pos;
+      obj = ppstack_push(stack);
+      obj->type = PPSTRING;
+      if (ppcrypt_ref(pdf, crypt))
+        obj->string = ppscan_crypt_string(I, crypt, &pdf->heap);
+      else
+        obj->string = ppscan_string(I, &pdf->heap);
+      return obj;
+    case '[':
+      mark = stack->size;
+      obj = ppstack_push(stack);
+      obj->type = PPMARK; // ppscan_obj() checks types backward for 'R', so set the type immediatelly (reserved for PPARRAY)
+      obj->any = NULL;
+      ++I->pos;
+      for (c = ppscan_find(I); c != ']'; c = ppscan_find(I))
+      {
+        if (ppscan_obj(I, pdf, xref) == NULL)
+        { // callers assume that NULL returns means nothing pushed
+          size = stack->size - mark; // pop items AND the obj reserved for array
+          ppstack_pop(stack, size);
+          return NULL;
+        }
+      }
+      ++I->pos;
+      size = stack->size - mark - 1;
+      obj = ppstack_at(stack, mark); // stack might have been realocated
+      obj->type = PPARRAY;
+      obj->array = pparray_create(ppstack_at(stack, mark + 1), size, &pdf->heap);
+      ppstack_pop(stack, size); // pop array items, leave the array on top
+      return obj;
+    case '<':
+      if ((c = iof_next(I)) == '<')
+      {
+        mark = stack->size;
+        obj = ppstack_push(stack);
+        obj->type = PPMARK;
+        obj->any = NULL;
+        ++I->pos;
+        for (c = ppscan_find(I); c != '>'; c = ppscan_find(I))
+        {
+          if (ppscan_obj(I, pdf, xref) == NULL)
+          {
+            size = stack->size - mark;
+            ppstack_pop(stack, size);
+            return NULL;
+          }
+        }
+        if (iof_next(I) == '>')
+          ++I->pos;
+        size = stack->size - mark - 1;
+        obj = ppstack_at(stack, mark);
+        obj->type = PPDICT;
+        obj->dict = ppdict_create(ppstack_at(stack, mark + 1), size, &pdf->heap);
+        ppstack_pop(stack, size);
+        return obj;
+      }
+      obj = ppstack_push(stack);
+      obj->type = PPSTRING;
+      if (ppcrypt_ref(pdf, crypt))
+        obj->string = ppscan_crypt_base16(I, crypt, &pdf->heap);
+      else
+        obj->string = ppscan_base16(I, &pdf->heap);
+      return obj;
+    case 'R':
+      if (stack->size >= 2 && stack->pos[-1].type == PPINT && stack->pos[-2].type == PPINT)
+      {
+        ++I->pos;
+        obj = &stack->pos[-2];
+        refnumber = (ppuint)obj->integer;
+        ppstack_pop(stack, 1); // pop version number, retype obj to a reference
+        if (xref == NULL || (ref = ppxref_find(xref, refnumber)) == NULL)
+        { /* pdf spec page 64: unresolvable reference is not an error, should just be treated as a reference to null.
+             we also need this to read trailer, where refs can't be resolved yet */
+          refversion = (obj + 1)->integer;
+          //if (xref != NULL)
+          //  loggerf("unresolved reference %s", ppref_str(refnumber, refversion));
+          ref = ppref_unresolved(stack->pheap, refnumber, refversion);
+        }
+        obj->type = PPREF;
+        obj->ref = ref;
+        return obj;
+      }
+      break;
+    case 't':
+      if (iof_next(I) == 'r' && iof_next(I) == 'u' && iof_next(I) == 'e')
+      {
+        ++I->pos;
+        obj = ppstack_push(stack);
+        obj->type = PPBOOL;
+        obj->integer = 1;
+        return obj;
+      }
+      break;
+    case 'f':
+      if (iof_next(I) == 'a' && iof_next(I) == 'l' && iof_next(I) == 's' && iof_next(I) == 'e')
+      {
+        ++I->pos;
+        obj = ppstack_push(stack);
+        obj->type = PPBOOL;
+        obj->integer = 0;
+        return obj;
+      }
+      break;
+    case 'n':
+      if (iof_next(I) == 'u' && iof_next(I) == 'l' && iof_next(I) == 'l')
+      {
+        ++I->pos;
+        obj = ppstack_push(stack);
+        obj->type = PPNULL;
+        obj->any = NULL;
+        return obj;
+      }
+      break;
+  }
+  return NULL;
+}
+
+/*
+A variant for contents streams (aka postscript); wise of operators, blind to references.
+We are still PDF, so we don't care about postscript specific stuff such as radix numbers
+and scientific numbers notation. It takes ppstack * as context (no ppdoc *) to be able
+to run contents parser beyond the scope of ppdoc heap.
+*/
+
+static ppstring ppstring_inline (iof *I, ppdict *imagedict, ppheap **pheap);
+
+static ppobj * ppscan_psobj (iof *I, ppstack *stack)
+{
+  int c;
+  ppobj *obj, *op;
+  size_t size, mark;
+  ppname exec;
+
+  c = iof_char(I);
+  switch (c)
+  {
+    case DIGIT_CHAR_CASE:
+      return ppscan_numobj(I, ppstack_push(stack), 0);
+    case '.':
+      return ppscan_numobj_frac(I, ppstack_push(stack), 0);
+    case '+':
+      c = iof_next(I);
+      if (base10_digit(c)) // '+.abc' is probably an executable name, but we are not in postscript
+        return ppscan_numobj(I, ppstack_push(stack), 0);
+      else if (c == '.')
+        return ppscan_numobj_frac(I, ppstack_push(stack), 0);
+      obj = ppstack_push(stack);
+      obj->type = PPNAME;
+      obj->name = ppscan_exec(I, stack->pheap, '+');
+      return obj;
+    case '-':
+      c = iof_next(I);
+      if (base10_digit(c)) // ditto, we would handle type1 '-|' '|-' operators though
+        return ppscan_numobj(I, ppstack_push(stack), 1);
+      else if (c == '.')
+        return ppscan_numobj_frac(I, ppstack_push(stack), 1);
+      obj = ppstack_push(stack);
+      obj->type = PPNAME;
+      obj->name = ppscan_exec(I, stack->pheap, '-');
+      return obj;
+    case '/':
+      ++I->pos;
+      obj = ppstack_push(stack);
+      obj->type = PPNAME;
+      obj->name = ppscan_name(I, stack->pheap);
+      return obj;
+    case '(':
+      ++I->pos;
+      obj = ppstack_push(stack);
+      obj->type = PPSTRING;
+      obj->string = ppscan_string(I, stack->pheap);
+      return obj;
+    case '[':
+      mark = stack->size;
+      obj = ppstack_push(stack);
+      obj->type = PPMARK;
+      obj->any = NULL;
+      ++I->pos;
+      for (c = ppscan_find(I); c != ']'; c = ppscan_find(I))
+      {
+        if (ppscan_psobj(I, stack) == NULL)
+        {
+          size = stack->size - mark;
+          ppstack_pop(stack, size);
+          return NULL;
+        }
+      }
+      ++I->pos;
+      size = stack->size - mark - 1;
+      obj = ppstack_at(stack, mark);
+      obj->type = PPARRAY;
+      obj->array = pparray_create(ppstack_at(stack, mark + 1), size, stack->pheap);
+      ppstack_pop(stack, size);
+      return obj;
+    case '<':
+      if ((c = iof_next(I)) == '<')
+      {
+        mark = stack->size;
+        obj = ppstack_push(stack);
+        obj->type = PPMARK;
+        obj->any = NULL;
+        ++I->pos;
+        for (c = ppscan_find(I); c != '>'; c = ppscan_find(I))
+        {
+          if (ppscan_psobj(I, stack) == NULL)
+          {
+            size = stack->size - mark;
+            ppstack_pop(stack, size);
+            return NULL;
+          }
+        }
+        if (iof_next(I) == '>')
+          ++I->pos;
+        size = stack->size - mark - 1;
+        obj = ppstack_at(stack, mark);
+        obj->type = PPDICT;
+        obj->dict = ppdict_create(ppstack_at(stack, mark + 1), size, stack->pheap);
+        ppstack_pop(stack, size);
+        return obj;
+      }
+      obj = ppstack_push(stack);
+      obj->type = PPSTRING;
+      if (c == '~')
+        ++I->pos, obj->string = ppscan_base85(I, stack->pheap);
+      else
+        obj->string = ppscan_base16(I, stack->pheap);
+      return obj;
+    default:
+      if (c < 0 || !ppname_byte_lookup[c])
+        break; // forbid empty names; dead loop otherwise
+      ++I->pos;
+      /* true false null practically don't occur in streams so it makes sense to assume that we get an operator name here.
+         If it happen to be a keyword we could give back those several bytes to the heap but.. heap buffer is tricky enough. */
+      exec = ppscan_exec(I, stack->pheap, c);
+      obj = ppstack_push(stack);
+      switch (exec[0])
+      {
+        case 't':
+          if (exec[1] == 'r' && exec[2] == 'u' && exec[3] == 'e' && exec[4] == '\0')
+          {
+            obj->type = PPBOOL;
+            obj->integer = 1;
+            // todo: drop exec
+            return obj;
+          }
+          break;
+        case 'f':
+          if (exec[1] == 'a' && exec[2] == 'l' && exec[3] == 's' && exec[4] == 'e' && exec[5] == '\0')
+          {
+            obj->type = PPBOOL;
+            obj->integer = 0;
+            // todo: drop exec
+            return obj;
+          }
+          break;
+        case 'n':
+          if (exec[1] == 'u' && exec[2] == 'l' && exec[3] == 'l' && exec[4] == '\0')
+          {
+            obj->type = PPNULL;
+            obj->any = NULL;
+            // todo: drop exec
+            return obj;
+          }
+          break;
+        case 'B':
+           /*
+           Inline images break rules of operand/operator syntax, so 'BI/ID' operators need to be treated as special syntactic keywords.
+
+             BI <keyval pairs> ID<whitechar?><imagedata><whitechar?>EI
+
+           We treat the image as a single syntactic token; BI starts collecting a dict, ID is the beginning of the data. Effectively EI
+           operator obtains two operands - dict and string. It is ok to put three items onto the stack, callers dont't assume there is just one.
+           */
+          if (exec[1] == 'I' && exec[2] == '\0')
+          {
+            ppdict *imagedict;
+            /* key val pairs -> dict */
+            mark = stack->size - 1;
+            obj->type = PPMARK;
+            obj->any = NULL;
+            for (c = ppscan_find(I); ; c = ppscan_find(I))
+            {
+              if ((op = ppscan_psobj(I, stack)) == NULL)
+              {
+                size = stack->size - mark;
+                ppstack_pop(stack, size);
+                return NULL;
+              }
+              if (op->type == PPNAME && ppname_exec(op->name))
+              {
+                if (!ppname_is(op->name, "ID"))
+                { // weird
+                  size = stack->size - mark;
+                  ppstack_pop(stack, size);
+                  return NULL;
+                }
+                break;
+              }
+            }
+            size = stack->size - mark - 1;
+            obj = ppstack_at(stack, mark);
+            obj->type = PPDICT;
+            obj->dict = imagedict = ppdict_create(ppstack_at(stack, mark + 1), size, stack->pheap);
+            ppstack_pop(stack, size);
+            /* put image data string */
+            obj = ppstack_push(stack);
+            obj->type = PPSTRING;
+            obj->string = ppstring_inline(I, imagedict, stack->pheap);;
+            /* put EI operator name */
+            obj = ppstack_push(stack);
+            obj->type = PPNAME;
+            obj->name = ppexec_internal("EI", 2, stack->pheap);
+            return obj;
+          }
+      }
+      obj->type = PPNAME;
+      obj->name = exec;
+      return obj;
+  }
+  return NULL;
+}
+
+/*
+We try to get the exact inline image length from its dict params. If cannot predict the length, we have to scan the input until 'EI'.
+I've checked on may examples that it gives the same results but one can never be sure, as 'EI' might happen to be a part of the data.
+Stripping white char is also very heuristic; \0 is a white char in PDF and very likely to be a data byte.. weak method.
+*/
+
+static size_t inline_image_length (ppdict *dict)
+{
+  ppuint w, h, bpc, colors;
+  ppname cs;
+
+  if (ppdict_get_uint(dict, "W", &w) && ppdict_get_uint(dict, "H", &h) && ppdict_get_uint(dict, "BPC", &bpc) && (cs = ppdict_get_name(dict, "CS")) != NULL)
+  {
+    if (ppname_is(cs, "DeviceGray"))
+      colors = 1;
+    else if (ppname_is(cs, "DeviceRGB"))
+      colors = 3;
+    else if (ppname_is(cs, "DeviceCMYK"))
+      colors = 4;
+    else
+      return PP_LENGTH_UNKNOWN;
+    return (w * h * bpc * colors + 7) >> 3;
+  }
+  return PP_LENGTH_UNKNOWN;
+}
+
+static ppstring ppstring_inline (iof *I, ppdict *imagedict, ppheap **pheap)
+{
+  iof *O;
+  int c, d, e;
+  size_t length, leftin, leftout, bytes;
+
+  O = ppheap_buffer(pheap, sizeof(_ppstring), PPSTRING_INIT);
+  c = iof_char(I);
+  if (ignored_char(c))
+    c = iof_next(I);
+
+  length = inline_image_length(imagedict);
+  if (length != PP_LENGTH_UNKNOWN)
+  {
+    while (length > 0 && iof_readable(I) && iof_writable(O))
+    {
+      leftin = iof_left(I);
+      leftout = iof_left(O);
+      bytes = length;
+      if (bytes > leftin) bytes = leftin;
+      if (bytes > leftout) bytes = leftout;
+      memcpy(O->pos, I->pos, bytes);
+      I->pos += bytes;
+      O->pos += bytes;
+      length -= bytes;
+    }
+    // gobble EI
+    if (ppscan_find(I) == 'E')
+      if (iof_next(I) == 'I')
+        ++I->pos;
+  }
+  else
+  {
+    while (c >= 0)
+    {
+      if (c == 'E')
+      {
+        d = iof_next(I);
+        if (d == 'I')
+        {
+          e = iof_next(I);
+          if (!ppname_byte_lookup[e])
+          { /* strip one newline from the end and stop */
+            if (O->pos - 2 >= O->buf) // sanity
+            {
+              c = *(O->pos - 1);
+              if (ignored_char(c))
+              {
+                if (c == 0x0A && *(O->pos - 2) == 0x0D)
+                  O->pos -= 2;
+                else
+                  O->pos -= 1;
+              }
+            }
+            break;
+          }
+          iof_put2(O, c, d);
+          c = e;
+        }
+        else
+        {
+          iof_put(O, c);
+          c = d;
+        }
+      }
+      else
+      {
+        iof_put(O, c);
+        c = iof_next(I);
+      }
+    }
+  }
+  return ppstring_buffer(O, pheap);
+}
+
+/* input reader */
+
+/*
+PDF input is a pseudo file that either keeps FILE * or data. Reader iof * is a proxy to input
+that provides byte-by-byte interface. Our iof structure is capable to link iof_file *input,
+but t avoid redundant checks on IOF_DATA flag, here we link iof *I directly to FILE * or mem buffer.
+When reading from file we need an internal buffer, which should be kept rather small, as it is
+only used to parse xrefs and objects (no streams). We allocate the buffer from a private heap
+(not static) to avoid conflicts when processing >1 pdfs at once. Besides, the input buffer may be
+needed after loading the document, eg. to access references raw data.
+*/
+
+#define PPDOC_BUFFER 0xFFF // keep that small, it is only used to parse body objects
+
+static void ppdoc_reader_init (ppdoc *pdf, iof_file *input)
+{
+  iof *I;
+  pdf->input = *input;
+  input = &pdf->input;
+  input->refcount = 1;
+  I = &pdf->reader;
+  if (input->flags & IOF_DATA)
+  {
+    pdf->buffer = NULL;            // input iof_file is the buffer
+    iof_string_reader(I, NULL, 0); // gets IOF_DATA flag
+  }
+  else
+  {
+    pdf->buffer = (uint8_t *)ppheap_take(&pdf->heap, PPDOC_BUFFER);
+    iof_setup_file_handle_reader(I, NULL, 0, iof_file_get_fh(input)); // gets IOF_FILE_HANDLE flag and FILE *
+    I->space = PPDOC_BUFFER; // used on refill
+  }
+}
+
+/*
+Whenever we need to read the input file, we fseek the to the given offset and fread to to the private buffer.
+The length we need is not always predictable, in which case PPDOC_BUFFER bytes are read (keep it small).
+I->buf = I->pos is set to the beginning, I->end set to the end (end is the first byte one shouldn't read).
+*/
+
+static iof * ppdoc_reader (ppdoc *pdf, size_t offset, size_t length)
+{
+  iof_file *input;
+  iof *I;
+  input = &pdf->input;
+  I = &pdf->reader;
+  if (iof_file_seek(input, offset, SEEK_SET) != 0)
+    return NULL;
+  I->flags &= ~IOF_STOPPED;
+  if (input->flags & IOF_DATA)
+  {
+    I->buf = I->pos = input->pos;
+    I->end = (length == PP_LENGTH_UNKNOWN || I->pos + length >= input->end) ? input->end : (I->pos + length);
+  }
+  else
+  {
+    I->buf = I->pos = pdf->buffer; // ->buf is actually permanently equal pdf->buffer but we might need some tricks
+    if (length == PP_LENGTH_UNKNOWN || length > PPDOC_BUFFER)
+      length = PPDOC_BUFFER;
+    length = fread(I->buf, 1, length, I->file);
+    I->end = I->buf + length;
+  }
+  return I;
+}
+
+/* The position from the beginning of input
+- for data buffer: (pdf->input.pos - pdf->input.buf) + (I->pos - I->buf)
+  I->buf == pdf->input.pos, so this resolves to (I->pos - pdf->input.buf), independent from I->buf
+- for file buffer: ftell(pdf->input.file) - (I->end - I->pos)
+*/
+
+#define ppdoc_reader_tell(pdf, I) ((size_t)(((pdf)->input.flags & IOF_DATA) ? ((I)->pos - (pdf)->input.buf) : (ftell(iof_file_get_fh(&(pdf)->input)) - ((I)->end - (I)->pos))))
+
+/* pdf */
+
+#define PPDOC_HEADER 10 // "%PDF-?.??\n"
+
+static int ppdoc_header (ppdoc *pdf, uint8_t header[PPDOC_HEADER])
+{
+  size_t i;
+  if (memcmp(header, "%PDF-", 5) != 0)
+    return 0;
+  for (i = 5; i < PPDOC_HEADER - 1 && !ignored_char(header[i]); ++i)
+    pdf->version[i - 5] = header[i];
+  pdf->version[i - 5] = '\0';
+  return 1;
+}
+
+static int ppdoc_tail (ppdoc *pdf, iof_file *input, size_t *pxrefoffset)
+{
+  int c;
+  uint8_t tail[4*10], *p, back, tailbytes;
+
+  if (iof_file_seek(input, 0, SEEK_END) != 0)
+    return 0;
+  pdf->filesize = (size_t)iof_file_tell(input);
+  // simple heuristic to avoif fgetc() / fseek(-2) hiccup: keep seeking back by len(startxref) + 1 == 10
+  // until a letter found (assuming liberal white characters and tail length)
+  for (back = 1, tailbytes = 0; ; ++back)
+  {
+    if (iof_file_seek(input, -10, SEEK_CUR) != 0)
+      return 0;
+    tailbytes += 10;
+    c = iof_file_getc(input);
+    tailbytes -= 1;
+    switch (c)
+    {
+      case IGNORED_CHAR_CASE:
+      case DIGIT_CHAR_CASE:
+      case '%': case 'E': case 'O': case 'F':
+        if (back > 4) // 2 should be enough
+          return 0;
+        continue;
+      case 's': case 't': case 'a': case 'r': case 'x': case 'e': case 'f':
+        if (iof_file_read(tail, 1, tailbytes, input) != tailbytes)
+          return 0;
+        tail[tailbytes] = '\0';
+        for (p = &tail[0]; ; ++p)
+        {
+          if (*p == '\0')
+            return 0;
+          if ((c = base10_value(*p)) >= 0)
+            break;
+        }
+        ppread_uint(p, pxrefoffset);
+        return 1;
+      default:
+        return 0;
+    }
+  }
+  return 0;
+}
+
+/* xref/body */
+
+static int ppscan_start_entry (iof *I, ppref *ref)
+{
+  ppuint u;
+  ppscan_find(I); if (!ppscan_uint(I, &u) || u != ref->number) return 0;
+  ppscan_find(I); if (!ppscan_uint(I, &u) || u != ref->version) return 0;
+  ppscan_find(I); if (!ppscan_key(I, "obj")) return 0;
+  ppscan_find(I);
+  return 1;
+}
+
+static int ppscan_skip_entry (iof *I)
+{
+  size_t u;
+  ppscan_find(I); if (!ppscan_uint(I, &u)) return 0;
+  ppscan_find(I); if (!ppscan_uint(I, &u)) return 0;
+  ppscan_find(I); if (!ppscan_key(I, "obj")) return 0;
+  ppscan_find(I);
+  return 1;
+}
+
+static int ppscan_start_stream (iof *I, ppdoc *pdf, size_t *streamoffset)
+{
+  int c;
+  ppscan_find(I);
+  if (ppscan_key(I, "stream"))
+  { // skip 1 or 2 whites (here we shouldn't just gobble all blanks)
+    c = iof_char(I);
+    if (ignored_char(c))
+    {
+      c = iof_next(I);
+      if (ignored_char(c))
+        ++I->pos;
+    }
+    *streamoffset = ppdoc_reader_tell(pdf, I);
+    return 1;
+  }
+  return 0;
+}
+
+static ppxref * ppxref_load (ppdoc *pdf, size_t xrefoffset);
+static ppxref * ppxref_load_chain (ppdoc *pdf, ppxref *xref);
+
+/* Parsing xref table
+
+  1 10               // first ref number and refs count
+  0000000000 00000 n // 10-digits offset, 5 digits version, type identifier
+  0000000000 00000 n // n states for normal I guess
+  0000000000 00000 f // f states for free (not used)
+  ...
+
+Free entries seem to be a relic of ancient times, completelly useless for us. To avoid parsing xref table twice,
+we waste some space on free entries by allocating one plane of refs for each section. Later on we slice sections,
+so that effectively free entries are not involved in map.
+
+Subsequent refs gets number, version and offset. Other fields initialized when parsing PDF body.
+
+Having xref table loaded, we sort sections for future binary search (xref with objects count == 0 is considered invalid).
+
+Then we have to deal with the trailer dict. In general, to load objects and resolve references we need a complete chain
+of xrefs (not only the top). To load the previous xref, we need its offset, which is given in trailer. So we have to
+parse the trailer ignoring references, which might be unresolvable at this point (objects parser makes a dummy check
+for xref != NULL on refs resolving ppscan_obj(), which irritates me but I don't want a separate parser for trailer..).
+The same applies to xref streams, in which we have parse the trailer not having xref map at all. So the procedure is:
+
+  - load xref map, initialize references, make it ready to search
+  - parse trailer ignoring references
+  - get /Prev xref offset and load older xref (linked list via ->prev)
+  - sort all refs in all xrefs by offset
+  - parse refs in order resolving references in contained objects
+  - fix trailer references
+
+First created xref becomes a pdf->xref (top xref). We link that early to control offsets already read (insane loops?).
+*/
+
+// Every xref table item "0000000000 00000 n" is said to be terminated with 2-byte EOL but we don't like relying on whites.
+#define xref_item_length (10+1+5+1+1)
+
+static ppxref * ppxref_load_table (iof *I, ppdoc *pdf, size_t xrefoffset)
+{
+  ppxref *xref;
+  ppxsec *xrefsection;
+  ppref *ref;
+  ppuint first, count, refindex;
+  uint8_t buffer[xref_item_length + 1];
+  const char *p;
+  const ppobj *obj;
+
+  buffer[xref_item_length] = '\0';
+  xref = ppxref_create(pdf, 0, xrefoffset);
+  if (pdf->xref == NULL) pdf->xref = xref;
+  for (ppscan_find(I); ppscan_uint(I, &first); ppscan_find(I))
+  {
+    ppscan_find(I);
+    if (!ppscan_uint(I, &count))
+      return NULL;
+    if (count == 0) // weird
+      continue;
+    xref->count += count;
+    xrefsection = NULL;
+    ref = (ppref *)ppheap_take(&pdf->heap, count * sizeof(ppref));
+    for (refindex = 0; refindex < count; ++refindex, ++ref)
+    {
+      ref->xref = xref;
+      ref->number = first + refindex;
+      ppscan_find(I);
+      iof_read(I, buffer, xref_item_length);
+      switch (buffer[xref_item_length - 1])
+      {
+        case 'n':
+          if (xrefsection == NULL)
+          {
+            xrefsection = ppxref_push_section(xref, &pdf->heap);
+            xrefsection->first = ref->number;
+            xrefsection->refs = ref;
+          }
+          xrefsection->last = ref->number;
+          for (p = (const char *)buffer; *p == '0'; ++p);
+          p = ppread_uint(p, &ref->offset);
+          for ( ; *p == ' ' || *p == '0'; ++p);
+          p = ppread_uint(p, &ref->version);
+          ref->object.type = PPNONE; // init for sanity
+          ref->object.any = NULL;
+          ref->length = 0;
+          break;
+        case 'f':
+        default:
+          --ref;
+          xrefsection = NULL;
+          --xref->count;
+      }
+    }
+  }
+  /* sort section */
+  if (!ppxref_sort(xref))
+    ; // case of xref->size == 0 handled by ppxref_load_chain()
+  /* get trailer ignoring refs */
+  if (!ppscan_key(I, "trailer"))
+    return NULL;
+  ppscan_find(I);
+  if ((obj = ppscan_obj(I, pdf, NULL)) == NULL)
+    return NULL;
+  ppstack_pop(&pdf->stack, 1);
+  if (obj->type != PPDICT)
+    return NULL;
+  xref->trailer = *obj;
+  return ppxref_load_chain(pdf, xref);
+}
+
+/* Parsing xref stream
+First we load the trailer, ignoring references. Dict defines sections and fields lengths:
+
+  /Size                                  % max ref number plus 1
+  /Index [ first count first count ... ] % a pair of numbers for every section, defaults to [0 Size]
+  /W [w1 w2 w3]                          % fields lengths, 0 states for omitted field
+
+xref stream data is a continuous stream of binary number triplets. First number is a type:
+
+  0 - free entry (as 'f' in xref table)
+  1 - normal entry, followed by offset an version (as 'n' in xref table)
+  2 - compressed entry, followed by parent object stream number and entry index
+
+0 and 1 are handled as 'n' and 'f' entries in xref table. For type 2 we normally initialize
+ref->number and ref->version (the later is implicitly 0). ref->offset is set to 0 (invalid offset),
+which is recognized by objects loader.
+*/
+
+#define XREF_STREAM_MAX_FIELD 4
+
+static ppxref * ppxref_load_stream (iof *I, ppdoc *pdf, size_t xrefoffset)
+{
+  ppxref *xref;
+  ppxsec *xrefsection;
+  ppref *ref;
+  ppobj *obj;
+  ppstream *xrefstream;
+  size_t streamoffset;
+  ppuint w1, w2, w3, w, bufferbytes;
+  uint8_t buffer[3 * XREF_STREAM_MAX_FIELD], *b;
+  ppuint first, count, f1, f2, f3;
+  pparray *fieldwidths, *sectionindices;
+  ppobj sectionmock[2], *sectionfirst, *sectioncount;
+  size_t sections, sectionindex, refindex;
+
+  if (!ppscan_skip_entry(I))
+    return NULL;
+  if ((obj = ppscan_obj(I, pdf, NULL)) == NULL)
+    return NULL;
+  ppstack_pop(&pdf->stack, 1);
+  if (obj->type != PPDICT || !ppscan_start_stream(I, pdf, &streamoffset))
+    return NULL;
+  xrefstream = ppstream_create(pdf, obj->dict, streamoffset);
+  /* All normal streams go through ppstream_info(), but it makes no sense for trailer stream (no crypt allowed, no refs yet).
+     So we just record the length and informative flag. Here we have to expect that /Length and /Filter are not indirects. */
+  if (!ppdict_get_uint(obj->dict, "Length", &xrefstream->length))
+    return NULL;
+  if (ppdict_get_obj(obj->dict, "Filter") != NULL)
+    xrefstream->flags |= PPSTREAM_COMPRESSED;
+  if ((fieldwidths = ppdict_get_array(xrefstream->dict, "W")) != NULL)
+  {
+    if (!pparray_get_uint(fieldwidths, 0, &w1)) w1 = 0;
+    if (!pparray_get_uint(fieldwidths, 1, &w2)) w2 = 0;
+    if (!pparray_get_uint(fieldwidths, 2, &w3)) w3 = 0;
+  }
+  else
+    w1 = w2 = w3 = 0;
+  if (w1 > XREF_STREAM_MAX_FIELD || w2 > XREF_STREAM_MAX_FIELD || w3 > XREF_STREAM_MAX_FIELD)
+    return NULL;
+  bufferbytes = w1 + w2 + w3;
+  if ((sectionindices = ppdict_get_array(xrefstream->dict, "Index")) != NULL)
+  {
+    sections = sectionindices->size >> 1;
+    sectionfirst = sectionindices->data;
+  }
+  else
+  {
+    sections = 1;
+    sectionmock[0].type = PPINT;
+    sectionmock[0].integer = 0;
+    sectionmock[1].type = PPINT;
+    if (!ppdict_get_int(xrefstream->dict, "Size", &sectionmock[1].integer))
+      sectionmock[1].integer = 0;
+    sectionfirst = &sectionmock[0];
+  }
+  if ((I = ppstream_read(xrefstream, 1, 0)) == NULL)
+    return NULL; // we fseek() so original I is useless anyway
+  xref = ppxref_create(pdf, sections, xrefoffset);
+  if (pdf->xref == NULL) pdf->xref = xref;
+  xref->trailer.type = PPSTREAM;
+  xref->trailer.stream = xrefstream;
+  for (sectionindex = 0; sectionindex < sections; ++sectionindex, sectionfirst += 2)
+  {
+    sectioncount = sectionfirst + 1;
+    if (!ppobj_get_uint(sectionfirst, first) || !ppobj_get_uint(sectioncount, count))
+      goto xref_stream_error;
+    if (count == 0)
+      continue;
+    xref->count += count;
+    xrefsection = NULL;
+    ref = (ppref *)ppheap_take(&pdf->heap, count * sizeof(ppref));
+    for (refindex = 0; refindex < count; ++refindex, ++ref)
+    {
+      ref->xref = xref;
+      ref->number = first + refindex;
+      if (iof_read(I, buffer, bufferbytes) != bufferbytes)
+        goto xref_stream_error;
+      b = buffer;
+      if (w1 == 0)
+        f1 = 1; // default type is 1
+      else
+        for (f1 = 0, w = 0; w < w1; f1 = (f1 << 8)|(*b), ++w, ++b);
+      for (f2 = 0, w = 0; w < w2; f2 = (f2 << 8)|(*b), ++w, ++b);
+      for (f3 = 0, w = 0; w < w3; f3 = (f3 << 8)|(*b), ++w, ++b);
+      switch (f1)
+      {
+        case 0:
+          //--ref;
+          xrefsection = NULL;
+          --xref->count;
+          break;
+        case 1:
+          if (xrefsection == NULL)
+          {
+            xrefsection = ppxref_push_section(xref, &pdf->heap);
+            xrefsection->first = ref->number;
+            xrefsection->refs = ref;
+          }
+          xrefsection->last = ref->number;
+          ref->offset = f2;
+          ref->version = f3;
+          ref->object.type = PPNONE;
+          ref->object.any = NULL;
+          ref->length = 0;
+          break;
+        case 2:
+          if (xrefsection == NULL)
+          {
+            xrefsection = ppxref_push_section(xref, &pdf->heap);
+            xrefsection->first = ref->number;
+            xrefsection->refs = ref;
+          }
+          xrefsection->last = ref->number;
+          ref->offset = 0; // f2 is parent objstm, f3 is index in parent, both useless
+          ref->version = 0; // compressed objects has implicit version == 0
+          ref->object.type = PPNONE;
+          ref->object.any = NULL;
+          ref->length = 0;
+          break;
+        default:
+          goto xref_stream_error;
+      }
+    }
+  }
+  /* sort sections */
+  if (!ppxref_sort(xref))
+    ; // case of xref->size == 0 handled by ppxref_load_chain()
+  /* close the stream _before_ loading prev xref */
+  ppstream_done(xrefstream);
+  /* load prev and return */
+  return ppxref_load_chain(pdf, xref);
+xref_stream_error:
+  ppstream_done(xrefstream);
+  return NULL;
+}
+
+/*
+The following procedure loads xref /Prev, links xref->prev and typically returns xref.
+Some docs contain empty xref (one section with zero objects) that is actually a proxy
+to xref stream referred as /XRefStm (genuine concept of xrefs old/new style xrefs in
+the same doc). In case of 0-length xref we ignore the proxy and return the target xref
+(otherwise we would need annoying sanity check for xref->size > 0 on every ref search).
+*/
+
+static ppxref * ppxref_load_chain (ppdoc *pdf, ppxref *xref)
+{
+  ppdict *trailer;
+  ppuint xrefoffset;
+  ppxref *prevxref, *nextxref;
+
+  trailer = ppxref_trailer(xref);
+  if (!ppdict_get_uint(trailer, "Prev", &xrefoffset)) // XRefStm is useless
+    return xref; // missing /Prev is obviously ok
+  for (nextxref = pdf->xref; nextxref != NULL; nextxref = nextxref->prev)
+    if (nextxref->offset == xrefoffset) // insane
+      return NULL;
+  if ((prevxref = ppxref_load(pdf, (size_t)xrefoffset)) == NULL)
+    return NULL;
+  if (xref->size > 0)
+  {
+    xref->prev = prevxref;
+    return xref;
+  }
+  if (pdf->xref == xref)
+    pdf->xref = prevxref;
+  return prevxref;
+}
+
+static ppxref * ppxref_load (ppdoc *pdf, size_t xrefoffset)
+{
+  iof *I;
+  if ((I = ppdoc_reader(pdf, xrefoffset, PP_LENGTH_UNKNOWN)) == NULL)
+    return NULL;
+  ppscan_find(I);
+  if (ppscan_key(I, "xref"))
+    return ppxref_load_table(I, pdf, xrefoffset);
+  return ppxref_load_stream(I, pdf, xrefoffset);
+  // iof_close(I) does nothing here
+}
+
+static void ppoffmap_sort (ppref **left, ppref **right)
+{
+  ppref **l, **r, *t;
+  ppuint pivot;
+  l = left, r = right;
+  pivot = (*(l + ((r - l) / 2)))->offset;
+  do
+  { // don't read from pointer!
+    while ((*l)->offset < pivot) ++l;
+    while ((*r)->offset > pivot) --r;
+    if (l <= r)
+    {
+      t = *l;
+      *l = *r;
+      *r = t;
+      ++l, --r;
+    }
+  } while (l <= r);
+  if (left < r)
+    ppoffmap_sort(left, r);
+  if (l < right)
+    ppoffmap_sort(l, right);
+}
+
+
+static void fix_trailer_references (ppdoc *pdf)
+{
+  ppxref *xref;
+  ppdict *trailer;
+  ppname *pkey;
+  ppobj *obj;
+  ppref *ref;
+  for (xref = pdf->xref; xref != NULL; xref = xref->prev)
+  {
+    if ((trailer = ppxref_trailer(xref)) == NULL)
+      continue;
+    for (ppdict_first(trailer, pkey, obj); *pkey != NULL; ppdict_next(pkey, obj))
+    { // no need to go deeper in structs, all items in trailer except info and root must be direct refs
+      if (obj->type != PPREF)
+        continue;
+      ref = obj->ref;
+      if (ref->offset == 0) // unresolved?
+        if ((ref = ppxref_find(xref, ref->number)) != NULL)
+          obj->ref = ref; // at this moment the reference still points nothing, but should be the one with the proper offset
+    }
+  }
+}
+
+/*
+Here comes a procedure that loads all entries from all document bodies. We resolve references while
+parsing objects and to make resolving correct, we need a complete chain of xref maps, and a knowledge
+about possible linearized dict (first offset). So loading refs sorted by offsets makes sense (not sure
+if it matters nowadays but we also avoid fseek() by large offsets).
+
+Here is the proc:
+
+  - create a list of all refs in all bodies
+  - sort the list by offsets
+  - for every ref from the sorted list:
+    - estimate object length to avoid fread-ing more than necessary (not perfect but enough)
+    - fseek() to the proper offset, fread() entry data or its part
+    - parse the object with ppscan_obj(I, pdf, xref), where xref is not necessarily top pdf->xref
+    - save the actual ref->length (not sure if we need that?)
+    - make a stream if a dict is followed by "stream" keyword, also save the stream offset
+  - free the list
+*/
+
+static int ppdoc_load_objstm (ppstream *stream, ppdoc *pdf, ppxref *xref);
+
+static void ppdoc_load_entries (ppdoc *pdf)
+{
+  size_t objects, sectionindex, refnumber, offindex;
+  ppnum linearized;
+  ppref **offmap, **pref, *ref;
+  ppxref *xref;
+  ppxsec *xsec;
+  ppobj *obj;
+  ppname type;
+  int redundant_indirection = 0;
+  ppcrypt *crypt;
+  ppstream *stream;
+
+  if ((objects = (size_t)ppdoc_objects(pdf)) == 0) // can't happen
+    return;
+  pref = offmap = (ppref **)pp_malloc(objects * sizeof(ppref *));
+  objects = 0; // recount refs with offset > 0
+  for (xref = pdf->xref; xref != NULL; xref = xref->prev)
+    for (sectionindex = 0, xsec = xref->sects; sectionindex < xref->size; ++sectionindex, ++xsec)
+      for (refnumber = xsec->first, ref = xsec->refs; refnumber <= xsec->last; ++refnumber, ++ref)
+        if (ref->offset > 0) // 0 means compressed or insane
+          *pref++ = ref, ++objects;
+  ppoffmap_sort(offmap, offmap + objects - 1);
+
+  crypt = pdf->crypt;
+  for (offindex = 0, pref = offmap; offindex < objects; )
+  {
+    ref = *pref;
+    ++pref;
+    ++offindex;
+    if (ref->object.type != PPNONE) // might be preloaded already (/Encrypt dict, stream filter dicts, stream /Length..)
+    	continue;
+    if (offindex < objects)
+      ref->length = (*pref)->offset - ref->offset;
+    else
+      ref->length = pdf->filesize > ref->offset ? pdf->filesize - ref->offset : 0;
+    if (crypt != NULL)
+    {
+      ppcrypt_start_ref(crypt, ref);
+      obj = ppdoc_load_entry(pdf, ref);
+      ppcrypt_end_ref(crypt);
+    }
+    else
+    {
+      obj = ppdoc_load_entry(pdf, ref);
+    }
+    switch (obj->type)
+    {
+      case PPDICT: /* Check if the object at first offset is linearized dict. We need that to resolve all references properly. */
+        if (offindex == 1 && ppdict_get_num(obj->dict, "Linearized", &linearized)) // /Linearized value is a version number, default 1.0
+          pdf->flags |= PPDOC_LINEARIZED;
+        break;
+      case PPREF:
+        redundant_indirection = 1;
+        break;
+      default:
+        break;
+    }
+    // if pdf->crypt crypt->ref = NULL
+  }
+
+  /* refs pointngs refs? cut. */
+  if (redundant_indirection)
+  {
+    for (offindex = 0, pref = offmap; offindex < objects; ++offindex)
+    {
+      ref = *pref++;
+      if (ref->object.type == PPREF)
+        ref->object = ref->object.ref->object; // doing for all effectively cuts all insane chains
+    }
+  }
+
+  /* now handle streams; update stream info (eg. /Length), load pdf 1.5 object streams
+     we could do earlier but then we would need to struggle with indirects */
+  for (offindex = 0, pref = offmap; offindex < objects; ++offindex)
+  {
+    ref = *pref++;
+    obj = &ref->object;
+    if (obj->type != PPSTREAM)
+      continue;
+    stream = obj->stream;
+    if (crypt != NULL)
+    {
+      ppcrypt_start_ref(crypt, ref);
+      ppstream_info(stream, pdf);
+      ppcrypt_end_ref(crypt);
+    }
+    else
+    {
+      ppstream_info(stream, pdf);
+    }
+    if (ref->xref->trailer.type == PPSTREAM && (type = ppdict_get_name(stream->dict, "Type")) != NULL && ppname_is(type, "ObjStm")) // somewhat dummy..
+      if (!ppdoc_load_objstm(stream, pdf, ref->xref))
+        loggerf("invalid objects stream %s at offset " PPSIZEF, ppref_str(ref->number, ref->version), ref->offset);
+  }
+  pp_free(offmap);
+}
+
+ppobj * ppdoc_load_entry (ppdoc *pdf, ppref *ref)
+{
+  iof *I;
+  size_t length;
+  ppxref *xref;
+  ppobj *obj;
+  ppstack *stack;
+  size_t streamoffset;
+  ppref *refref;
+  ppuint refnumber, refversion;
+
+  length = ref->length > 0 ? ref->length : PP_LENGTH_UNKNOWN; // estimated or unknown
+  if ((I = ppdoc_reader(pdf, ref->offset, length)) == NULL || !ppscan_start_entry(I, ref))
+  {
+    loggerf("invalid %s offset " PPSIZEF, ppref_str(ref->number, ref->version), ref->offset);
+    return &ref->object; // PPNONE
+  }
+  stack = &pdf->stack;
+  xref = ref->xref; // to resolve indirects properly
+  if ((obj = ppscan_obj(I, pdf, xref)) == NULL)
+  {
+    loggerf("invalid %s object at offset " PPSIZEF, ppref_str(ref->number, ref->version), ref->offset);
+    return &ref->object; // PPNONE
+  }
+  ref->object = *obj;
+  ppstack_pop(stack, 1);
+  obj = &ref->object;
+  ref->length = ppdoc_reader_tell(pdf, I) - ref->offset;
+  if (obj->type == PPDICT)
+  {
+    if (ppscan_start_stream(I, pdf, &streamoffset))
+    {
+      obj->type = PPSTREAM;
+      obj->stream = ppstream_create(pdf, obj->dict, streamoffset);
+    }
+  }
+  else if (obj->type == PPINT)
+  {
+    ppscan_find(I);
+    if (ppscan_uint(I, &refversion) && ppscan_find(I) == 'R')
+    {
+      refnumber = (ppuint)obj->integer;
+      if ((refref = ppxref_find(xref, refnumber)) != NULL)
+      {
+        obj->type = PPREF;
+        obj->ref = refref;
+      }
+      else
+      {
+        obj->type = PPNONE; // as ppref_unresolved()
+        obj->any = NULL;
+      }
+    }
+  }
+  return obj;
+}
+
+/* Loading entries from object stream
+
+  /N is the number of contained entries
+  /First is the offset of the first item
+
+The stream consists of N pairs of numbers <objnum> <offset> <objnum> <offset> ...
+Offsets are ascending (relative to the first), but ref numbers order is arbitrary.
+PDF spec says there might be some additional data between objects, so we should obey offsets.
+Which means we should basically load the stream at once (may be needed anyway to grab the stream [...]).
+*/
+
+static int ppdoc_load_objstm (ppstream *stream, ppdoc *pdf, ppxref *xref)
+{
+  ppdict *dict; // stream dict, actually still on stack
+  ppref *ref;
+  ppobj *obj;
+  ppuint items, firstoffset, offset, objnum, i, invalid = 0;
+  iof *I;
+  uint8_t *firstdata, *indexdata;
+  ppstack *stack;
+
+  dict = stream->dict;
+  if (!ppdict_rget_uint(dict, "N", &items) || !ppdict_rget_uint(dict, "First", &firstoffset))
+    return 0;
+  if ((I = ppstream_read(stream, 1, 1)) == NULL)
+    return 0;
+  firstdata = I->pos + firstoffset;
+  if (firstdata >= I->end)
+    goto invalid_objstm;
+  stack = &pdf->stack;
+  //if (pdf->crypt != NULL)
+  //  ppcrypt_end_ref(pdf->crypt); // objects are not encrypted, pdf->crypt->ref ensured NULL
+  for (i = 0; i < items; ++i)
+  {
+    ppscan_find(I);
+    if (!ppscan_uint(I, &objnum))
+      goto invalid_objstm;
+    ppscan_find(I);
+    if (!ppscan_uint(I, &offset))
+      goto invalid_objstm;
+    if ((ref = ppxref_find_local(xref, objnum)) == NULL || ref->object.type != PPNONE)
+    {
+      loggerf("invalid compressed object number " PPUINTF " at position " PPUINTF, objnum, i);
+      ++invalid;
+      continue;
+    }
+    if (firstdata + offset >= I->end)
+    {
+      loggerf("invalid compressed object offset " PPUINTF " at position " PPUINTF, offset, i);
+      ++invalid;
+      continue;
+    }
+    indexdata = I->pos; // save position
+    I->pos = firstdata + offset; // go to the object
+    ppscan_find(I);
+    if ((obj = ppscan_obj(I, pdf, xref)) != NULL)
+    {
+      ref->object = *obj;
+      ppstack_pop(stack, 1);
+      // nothing more needed, as obj can never be indirect ref or stream
+    }
+    else
+    {
+      ++invalid;
+      loggerf("invalid compressed object %s at stream offset " PPUINTF, ppref_str(objnum, 0), offset);
+    }
+    I->pos = indexdata; // restore position and read next from index
+  }
+  ppstream_done(stream);
+  return invalid == 0;
+invalid_objstm:
+  ppstream_done(stream);
+  return 0;
+}
+
+/* main PDF loader proc */
+
+ppcrypt_status ppdoc_crypt_pass (ppdoc *pdf, const void *userpass, size_t userpasslength, const void *ownerpass, size_t ownerpasslength)
+{
+  switch (pdf->cryptstatus)
+  {
+    case PPCRYPT_NONE:
+    case PPCRYPT_DONE:
+    case PPCRYPT_FAIL:
+      break;
+    case PPCRYPT_PASS: // initial status or really needs password
+      pdf->cryptstatus = ppdoc_crypt_init(pdf, userpass, userpasslength, ownerpass, ownerpasslength);
+      switch (pdf->cryptstatus)
+      {
+        case PPCRYPT_NONE:
+        case PPCRYPT_DONE:
+          ppdoc_load_entries(pdf);
+          break;
+        case PPCRYPT_PASS: // user needs to check ppdoc_crypt_status() and recall ppdoc_crypt_pass() with the proper password
+        case PPCRYPT_FAIL: // hopeless..
+          break;
+      }
+      break;
+  }
+  return pdf->cryptstatus;
+}
+
+static ppdoc * ppdoc_read (ppdoc *pdf, iof_file *input)
+{
+  uint8_t header[PPDOC_HEADER];
+  size_t xrefoffset;
+
+  input = &pdf->input;
+  if (iof_file_read(header, 1, PPDOC_HEADER, input) != PPDOC_HEADER || !ppdoc_header(pdf, header))
+    return NULL;
+  if (!ppdoc_tail(pdf, input, &xrefoffset))
+    return NULL;
+  if (ppxref_load(pdf, xrefoffset) == NULL)
+    return NULL;
+  fix_trailer_references(pdf); // after loading xrefs but before accessing trailer refs (/Encrypt might be a reference)
+  // check encryption, if any, try empty password
+  switch (ppdoc_crypt_pass(pdf, "", 0, NULL, 0))
+  {
+    case PPCRYPT_NONE: // no encryption
+    case PPCRYPT_DONE: // encryption with an empty password
+    case PPCRYPT_PASS: // the user needs to check ppdoc_crypt_status() and call ppdoc_crypt_pass()
+      break;
+    case PPCRYPT_FAIL: // hopeless
+      //loggerf("decryption failed");
+      //return NULL;
+      break;
+  }
+  return pdf;
+}
+
+static void ppdoc_pages_init (ppdoc *pdf);
+
+static ppdoc * ppdoc_create (iof_file *input)
+{
+  ppdoc *pdf;
+  ppheap *heap;
+
+  heap = ppheap_new();
+  pdf = (ppdoc *)ppheap_take(&heap, sizeof(ppdoc));
+  pdf->flags = 0;
+  pdf->heap = heap;
+  pdf->xref = NULL;
+  pdf->version[0] = '\0';
+  pdf->crypt = NULL;
+  pdf->cryptstatus = PPCRYPT_PASS; // force encryption check on ppdoc_read() -> ppdoc_crypt_pass()
+  ppstack_init(&pdf->stack, &pdf->heap);
+  ppdoc_reader_init(pdf, input);
+  ppdoc_pages_init(pdf);
+  if (ppdoc_read(pdf, &pdf->input) != NULL)
+    return pdf;
+  ppdoc_free(pdf);
+  return NULL;
+}
+
+ppdoc * ppdoc_load (const char *filename)
+{
+  FILE *file;
+  iof_file input;
+  if ((file = fopen(filename, "rb")) == NULL)
+    return NULL;
+  iof_file_init(&input, file);
+  input.flags |= IOF_CLOSE_FILE;
+  return ppdoc_create(&input);
+}
+
+ppdoc * ppdoc_mem (const void *data, size_t size)
+{
+	iof_file input;
+	iof_file_rdata_init(&input, data, size);
+	input.flags |= IOF_BUFFER_ALLOC; // todo: 3 modes: borrow, take over, copy?
+	return ppdoc_create(&input);
+}
+
+void ppdoc_free (ppdoc *pdf)
+{
+  //iof_file_free(&pdf->input);
+  iof_file_decref(&pdf->input);
+  ppstack_free_buffer(&pdf->stack);
+  ppheap_free(pdf->heap); // last!
+}
+
+ppcrypt_status ppdoc_crypt_status (ppdoc *pdf)
+{
+  return pdf->cryptstatus;
+}
+
+ppint ppdoc_permissions (ppdoc *pdf)
+{
+  return pdf->crypt != NULL ? pdf->crypt->permissions : (ppint)0xFFFFFFFFFFFFFFFF;
+}
+
+/* pages access */
+
+static pparray * pppage_node (ppdict *dict, ppuint *count, ppname *type)
+{
+  ppname *pkey, key;
+  ppobj *obj;
+  pparray *kids = NULL;
+  *count = 0;
+  *type = NULL;
+  for (ppdict_first(dict, pkey, obj); (key = *pkey) != NULL; ppdict_next(pkey, obj))
+  {
+    switch (key[0])
+    {
+      case 'T':
+        if (ppname_is(key, "Type"))
+          *type = ppobj_get_name(obj);
+        break;
+      case 'C':
+        if (ppname_is(key, "Count"))
+          ppobj_get_uint(obj, *count);
+        break;
+      case 'K':
+        if (ppname_is(key, "Kids"))
+          kids = ppobj_rget_array(obj);
+        break;
+    }
+  }
+  return kids;
+}
+
+#define ppname_is_page(type) (type != NULL && ppname_is(type, "Page"))
+
+ppuint ppdoc_page_count (ppdoc *pdf)
+{
+  ppref *ref;
+  ppname type;
+  ppuint count;
+  if ((ref = ppxref_pages(pdf->xref)) == NULL)
+    return 0;
+  if (pppage_node(ref->object.dict, &count, &type) == NULL)
+    return ppname_is_page(type) ? 1 : 0; // acrobat and ghostscript accept documents with root /Pages entry being a reference to a sole /Page object
+  return count;
+}
+
+ppref * ppdoc_page (ppdoc *pdf, ppuint index)
+{
+  ppdict *dict;
+  ppuint count;
+  pparray *kids;
+  size_t size, i;
+  ppobj *r, *o;
+  ppref *ref;
+  ppname type;
+
+
+  if ((ref = ppxref_pages(pdf->xref)) == NULL)
+    return NULL;
+  dict = ref->object.dict;
+  if ((kids = pppage_node(dict, &count, &type)) != NULL)
+  {
+    if (index < 1 || index > count)
+      return NULL;
+  }
+  else
+  {
+    return index == 1 && ppname_is_page(type) ? ref : NULL;
+  }
+scan_array:
+  if (index <= count / 2)
+  { // probably shorter way from the beginning
+    for (i = 0, size = kids->size, r = pparray_at(kids, 0); i < size; ++i, ++r)
+    {
+      if (r->type != PPREF)
+        return NULL;
+      o = &r->ref->object;
+      if (o->type != PPDICT)
+        return NULL;
+      dict = o->dict;
+      if ((kids = pppage_node(dict, &count, &type)) != NULL)
+      {
+        if (index <= count)
+          goto scan_array;
+        index -= count;
+        continue;
+      }
+      if (index == 1 && ppname_is_page(type))
+        return r->ref;
+      --index;
+    }
+  }
+  else if ((size = kids->size) > 0) // for safe (size-1)
+  { // probably shorter way from the end
+    index = count - index + 1;
+    for (i = 0, r = pparray_at(kids, size - 1); i < size; ++i, --r)
+    {
+      if (r->type != PPREF)
+        return NULL;
+      o = &r->ref->object;
+      if (o->type != PPDICT)
+        return NULL;
+      dict = o->dict;
+      if ((kids = pppage_node(dict, &count, &type)) != NULL)
+      {
+        if (index <= count)
+          goto scan_array;
+        index -= count;
+        continue;
+      }
+      if (index == 1 && ppname_is_page(type))
+        return r->ref;
+      --index;
+    }
+  }
+  return NULL;
+}
+
+/*
+Through pages iterator. Iterating over pages tree just on the base of /Kids and /Parent keys
+is ineffective, as to get next pageref we need to take parent, find the pageref in /Kids,
+take next (or go upper).. Annoying. We use a dedicated stack for pages iterator. This could
+actually be done with pdf->stack, but some operations may clear it, so safer to keep it independent
+Besides, its depth is constant (set on first use), so no need for allocs.
+*/
+
+static void ppdoc_pages_init (ppdoc *pdf)
+{
+  pppages *pages;
+  pages = &pdf->pages;
+  pages->root = pages->parent = pages->buffer;
+  pages->depth = 0;
+  pages->space = PPPAGES_STACK_DEPTH;
+}
+
+static ppkids * pppages_push (ppdoc *pdf, pparray *kids)
+{
+  ppkids *newroot, *bounds;
+  pppages *pages;
+  pages = &pdf->pages;
+  if (pages->depth == pages->space)
+  {
+    pages->space <<= 1;
+    newroot = (ppkids *)ppheap_take(&pdf->heap, pages->space * sizeof(ppkids));
+    memcpy(newroot, pages->root, pages->depth * sizeof(ppkids));
+    pages->root = newroot;
+  }
+  bounds = pages->parent = &pages->root[pages->depth++];
+  bounds->current = pparray_at(kids, 0);
+  bounds->sentinel = pparray_at(kids, kids->size);
+  return bounds;
+}
+
+#define pppages_pop(pages) (--((pages)->parent), --((pages)->depth))
+
+static ppref * ppdoc_pages_group_first (ppdoc *pdf, ppref *ref)
+{
+  ppdict *dict;
+  pparray *kids;
+  ppuint count;
+  ppname type;
+
+  dict = ref->object.dict; // typecheck made by callers
+  while ((kids = pppage_node(dict, &count, &type)) != NULL)
+  {
+    if ((ref = pparray_get_ref(kids, 0)) == NULL || ref->object.type != PPDICT)
+      return NULL;
+    pppages_push(pdf, kids);
+    dict = ref->object.dict;
+  }
+  return ppname_is_page(type) ? ref : NULL;
+}
+
+ppref * ppdoc_first_page (ppdoc *pdf)
+{
+  ppref *ref;
+  pppages *pages;
+  if ((ref = ppdoc_pages(pdf)) == NULL)
+    return NULL;
+  pages = &pdf->pages;
+  pages->parent = pages->root;
+  pages->depth = 0;
+  return ppdoc_pages_group_first(pdf, ref);
+}
+
+ppref * ppdoc_next_page (ppdoc *pdf)
+{
+  pppages *pages;
+  ppkids *bounds;
+  ppref *ref;
+  ppobj *obj;
+  pages = &pdf->pages;
+  while (pages->depth > 0)
+  {
+    bounds = pages->parent;
+    obj = ++bounds->current;
+    if (obj < bounds->sentinel)
+    {
+      if (obj->type != PPREF)
+        return NULL;
+      ref = obj->ref;
+      if (ref->object.type != PPDICT)
+        return NULL;
+      return ppdoc_pages_group_first(pdf, ref);
+    }
+    else
+    { // no next node, go upper
+      pppages_pop(pages);
+    }
+  }
+  return NULL;
+}
+
+/* context */
+
+ppcontext * ppcontext_new (void)
+{
+  ppheap *heap;
+  ppcontext *context;
+  heap = ppheap_new();
+  context = (ppcontext *)pp_malloc(sizeof(ppcontext)); // not from priv heap, as we delete it on renew
+  context->heap = heap;
+  ppstack_init(&context->stack, &context->heap);
+  return context;
+}
+
+void ppcontext_done (ppcontext *context)
+{
+  ppheap_renew(context->heap);
+  ppstack_clear(&context->stack);
+}
+
+void ppcontext_free (ppcontext *context)
+{
+  ppstack_free_buffer(&context->stack);
+  ppheap_free(context->heap);
+  pp_free(context);
+}
+
+/* page contents streams */
+
+//#define ppcontents_first_stream(array) pparray_rget_stream(array, 0)
+
+static ppstream * ppcontents_first_stream (pparray *array)
+{
+  size_t i;
+  ppobj *obj;
+  ppref *ref;
+  for (pparray_first(array, i, obj); i < array->size; pparray_next(i, obj))
+    if ((ref = ppobj_get_ref(obj)) != NULL && ref->object.type == PPSTREAM)
+      return ref->object.stream;
+  return NULL;
+}
+
+static ppstream * ppcontents_next_stream (pparray *array, ppstream *stream)
+{
+  size_t i;
+  ppobj *obj;
+  ppref *ref;
+  for (pparray_first(array, i, obj); i < array->size; pparray_next(i, obj))
+    if ((ref = ppobj_get_ref(obj)) != NULL && ref->object.type == PPSTREAM && ref->object.stream == stream)
+      if (++i < array->size && (ref = ppobj_get_ref(obj + 1)) != NULL && ref->object.type == PPSTREAM)
+        return ref->object.stream;
+  return NULL;
+}
+
+ppstream * ppcontents_first (ppdict *dict)
+{
+  ppobj *contentsobj;
+  if ((contentsobj = ppdict_rget_obj(dict, "Contents")) == NULL)
+    return NULL;
+  switch (contentsobj->type)
+  {
+    case PPARRAY:
+      return ppcontents_first_stream(contentsobj->array);
+    case PPSTREAM:
+      return contentsobj->stream;
+    default:
+      break;
+  }
+  return NULL;
+}
+
+ppstream * ppcontents_next (ppdict *dict, ppstream *stream)
+{
+  ppobj *contentsobj;
+  if ((contentsobj = ppdict_rget_obj(dict, "Contents")) == NULL)
+    return NULL;
+  switch (contentsobj->type)
+  {
+    case PPARRAY:
+      return ppcontents_next_stream(contentsobj->array, stream);
+    case PPSTREAM:
+      break;
+    default:
+      break;
+  }
+  return NULL;
+}
+
+static ppobj * ppcontents_op (iof *I, ppstack *stack, size_t *psize, ppname *pname)
+{
+  ppobj *obj;
+  ppstack_clear(stack);
+  do {
+    if (ppscan_find(I) < 0)
+      return NULL;
+    if ((obj = ppscan_psobj(I, stack)) == NULL)
+      return NULL;
+  } while (obj->type != PPNAME || !ppname_exec(obj->name));
+  *pname = obj->name;
+  *psize = stack->size - 1;
+  return stack->buf;
+}
+
+ppobj * ppcontents_first_op (ppcontext *context, ppstream *stream, size_t *psize, ppname *pname)
+{
+  iof *I;
+  if ((I = ppstream_read(stream, 1, 0)) == NULL)
+    return NULL;
+  return ppcontents_op(I, &context->stack, psize, pname);
+}
+
+ppobj * ppcontents_next_op (ppcontext *context, ppstream *stream, size_t *psize, ppname *pname)
+{
+  return ppcontents_op(ppstream_iof(stream), &context->stack, psize, pname);
+}
+
+ppobj * ppcontents_parse (ppcontext *context, ppstream *stream, size_t *psize)
+{
+  iof *I;
+  ppstack *stack;
+  ppobj *obj;
+  stack = &context->stack;
+  ppstack_clear(stack);
+  if ((I = ppstream_read(stream, 1, 0)) == NULL)
+    return NULL;
+  while (ppscan_find(I) >= 0)
+    if ((obj = ppscan_psobj(I, stack)) == NULL)
+      goto error;
+  *psize = stack->size;
+  ppstream_done(stream);
+  return stack->buf;
+error:
+  ppstream_done(stream);
+  return NULL;
+}
+
+/* boxes */
+
+pprect * pparray_to_rect (pparray *array, pprect *rect)
+{
+  ppobj *obj;
+  if (array->size != 4)
+    return NULL;
+  obj = pparray_at(array, 0);
+  if (!ppobj_get_num(obj, rect->lx)) return NULL;
+  obj = pparray_at(array, 1);
+  if (!ppobj_get_num(obj, rect->ly)) return NULL;
+  obj = pparray_at(array, 2);
+  if (!ppobj_get_num(obj, rect->rx)) return NULL;
+  obj = pparray_at(array, 3);
+  if (!ppobj_get_num(obj, rect->ry)) return NULL;
+  return rect;
+}
+
+pprect * ppdict_get_rect (ppdict *dict, const char *name, pprect *rect)
+{
+  pparray *array;
+  return (array = ppdict_rget_array(dict, name)) != NULL ? pparray_to_rect(array, rect) : NULL;
+}
+
+pprect * ppdict_get_box (ppdict *dict, const char *name, pprect *rect)
+{
+  do {
+    if (ppdict_get_rect(dict, name, rect) != NULL)
+      return rect;
+    dict = ppdict_rget_dict(dict, "Parent");
+  } while (dict != NULL);
+  return NULL;
+}
+
+ppmatrix * pparray_to_matrix (pparray *array, ppmatrix *matrix)
+{
+  ppobj *obj;
+  if (array->size != 6)
+    return NULL;
+  obj = pparray_at(array, 0);
+  if (!ppobj_get_num(obj, matrix->xx)) return NULL;
+  obj = pparray_at(array, 1);
+  if (!ppobj_get_num(obj, matrix->xy)) return NULL;
+  obj = pparray_at(array, 2);
+  if (!ppobj_get_num(obj, matrix->yx)) return NULL;
+  obj = pparray_at(array, 3);
+  if (!ppobj_get_num(obj, matrix->yy)) return NULL;
+  obj = pparray_at(array, 4);
+  if (!ppobj_get_num(obj, matrix->x)) return NULL;
+  obj = pparray_at(array, 5);
+  if (!ppobj_get_num(obj, matrix->y)) return NULL;
+  return matrix;
+}
+
+ppmatrix * ppdict_get_matrix (ppdict *dict, const char *name, ppmatrix *matrix)
+{
+  pparray *array;
+  return (array = ppdict_rget_array(dict, name)) != NULL ? pparray_to_matrix(array, matrix) : NULL;
+}
+
+/* logger */
+
+void pplog_callback (pplogger_callback logger, void *alien)
+{
+	logger_callback((logger_function)logger, alien);
+}
+
+int pplog_prefix (const char *prefix)
+{
+	return logger_prefix(prefix);
+}
+
+/* version */
+
+const char * ppdoc_version_string (ppdoc *pdf)
+{
+  return pdf->version;
+}
+
+int ppdoc_version_number (ppdoc *pdf, int *minor)
+{
+  *minor = pdf->version[2] - '0';
+  return pdf->version[0] - '0';
+}
+
+/* doc info */
+
+size_t ppdoc_file_size (ppdoc *pdf)
+{
+  return pdf->filesize;
+}
+
+ppuint ppdoc_objects (ppdoc *pdf)
+{
+  ppuint count;
+  ppxref *xref;
+  for (count = 0, xref = pdf->xref; xref != NULL; xref = xref->prev)
+    count += xref->count;
+  return count;
+}
+
+size_t ppdoc_memory (ppdoc *pdf, size_t *waste)
+{
+  size_t used;
+  ppheap *heap;
+  used = 0, *waste = 0;
+  for (heap = pdf->heap; heap != NULL; heap = heap->prev)
+  {
+    used += heap->space;
+    *waste += heap->size;
+  }
+  return used;
+}
diff --git a/texk/web2c/luatexdir/luapplib/ppload.h b/texk/web2c/luatexdir/luapplib/ppload.h
new file mode 100644
index 000000000..163928398
--- /dev/null
+++ b/texk/web2c/luatexdir/luapplib/ppload.h
@@ -0,0 +1,54 @@
+
+#ifndef PP_LOAD_H
+#define PP_LOAD_H
+
+typedef struct {
+  ppobj *buf;     // ppobjects buffer (allocated, not from our heap)
+  ppobj *pos;     // current ppobj *
+  size_t size;    // stack size
+  size_t space;   // available space
+  ppheap **pheap; // allocator (parent pdf->stack->pheap or own)
+} ppstack;
+
+typedef struct {
+  ppobj *current;
+  ppobj *sentinel;
+} ppkids;
+
+#define PPPAGES_STACK_DEPTH 4
+
+typedef struct {
+  ppkids buffer[PPPAGES_STACK_DEPTH];
+  ppkids *root;
+  ppkids *parent;
+  ppuint depth;
+  ppuint space;
+} pppages;
+
+struct ppdoc {
+  char version[5];
+  iof_file input;
+  iof reader;
+  uint8_t *buffer;
+  size_t filesize;
+  ppxref *xref;
+  ppheap *heap;
+  ppstack stack;
+  pppages pages;
+  int flags;
+  ppcrypt *crypt;
+  ppcrypt_status cryptstatus;
+};
+
+#define PPDOC_LINEARIZED (1 << 0)
+
+ppobj * ppdoc_load_entry (ppdoc *pdf, ppref *ref);
+#define ppobj_preloaded(pdf, obj) ((obj)->type != PPREF ? (obj) : ((obj)->ref->object.type == PPNONE ? ppdoc_load_entry(pdf, (obj)->ref) : &(obj)->ref->object))
+ppstring ppstring_internal (const void *data, size_t size, ppheap **pheap);
+
+struct ppcontext {
+  ppheap *heap;
+  ppstack stack;
+};
+
+#endif
\ No newline at end of file
diff --git a/texk/web2c/luatexdir/luapplib/ppstream.c b/texk/web2c/luatexdir/luapplib/ppstream.c
new file mode 100644
index 000000000..0e4be7b8e
--- /dev/null
+++ b/texk/web2c/luatexdir/luapplib/ppstream.c
@@ -0,0 +1,310 @@
+
+#include "ppfilter.h"
+#include "pplib.h"
+
+ppstream * ppstream_create (ppdoc *pdf, ppdict *dict, size_t offset)
+{
+	ppstream *stream;
+	stream = (ppstream *)ppheap_take(&pdf->heap, sizeof(ppstream));
+	stream->dict = dict;
+	stream->offset = offset;
+	//if (!ppdict_rget_uint(dict, "Length", &stream->length)) // may be indirect pointing PPNONE at this moment
+	//  stream->length = 0;
+	stream->length = 0;
+	stream->input = &pdf->input;
+	stream->I = NULL;
+	stream->cryptkey = NULL;
+	stream->flags = 0;
+	return stream;
+}
+
+/* codecs */
+
+enum {
+  PPSTREAM_UNKNOWN = -1,
+  PPSTREAM_BASE16 = 0,
+  PPSTREAM_BASE85,
+  PPSTREAM_RUNLENGTH,
+  PPSTREAM_FLATE,
+  PPSTREAM_LZW,
+  PPSTREAM_CCITT,
+  PPSTREAM_DCT,
+  PPSTREAM_JBIG2,
+  PPSTREAM_JPX,
+  PPSTREAM_CRYPT
+};
+
+static int ppstream_codec_type (ppname name)
+{ // one of those places where some hash wuld be nice..
+  switch (name[0])
+  {
+    case 'A':
+      if (ppname_is(name, "ASCIIHexDecode")) return PPSTREAM_BASE16;
+      if (ppname_is(name, "ASCII85Decode")) return PPSTREAM_BASE85;
+      break;
+    case 'R':
+      if (ppname_is(name, "RunLengthDecode")) return PPSTREAM_RUNLENGTH;
+      break;
+    case 'F':
+      if (ppname_is(name, "FlateDecode")) return PPSTREAM_FLATE;
+      break;
+    case 'L':
+      if (ppname_is(name, "LZWDecode")) return PPSTREAM_LZW;
+      break;
+    case 'D':
+      if (ppname_is(name, "DCTDecode")) return PPSTREAM_DCT;
+      break;
+    case 'C':
+      if (ppname_is(name, "CCITTFaxDecode")) return PPSTREAM_CCITT;
+      if (ppname_is(name, "Crypt")) return PPSTREAM_CRYPT;
+      break;
+    case 'J':
+      if (ppname_is(name, "JPXDecode")) return PPSTREAM_JPX;
+      if (ppname_is(name, "JBIG2Decode")) return PPSTREAM_JBIG2;
+      break;
+  }
+  return PPSTREAM_UNKNOWN;
+}
+
+static iof * ppstream_predictor (ppdict *params, iof *N)
+{
+  ppint predictor, rowsamples, components, samplebits;
+
+  if (!ppdict_get_int(params, "Predictor", &predictor) || predictor <= 1)
+    return N;
+  if (!ppdict_get_int(params, "Columns", &rowsamples) || rowsamples == 0) // sanity, filter probably expects >0
+    rowsamples = 1;;
+  if (!ppdict_get_int(params, "Colors", &components) || components == 0) // ditto
+    components = 1;
+  if (!ppdict_get_int(params, "BitsPerComponent", &samplebits) || samplebits == 0)
+    samplebits = 8;
+  return iof_filter_predictor_decoder(N, (int)predictor, (int)rowsamples, (int)components, (int)samplebits);
+}
+
+static iof * ppstream_decoder (ppstream *stream, int codectype, ppdict *params, iof *N)
+{
+  int flags;
+  iof *F, *P;
+  ppint earlychange;
+  ppstring cryptkey;
+
+  switch (codectype)
+  {
+    case PPSTREAM_BASE16:
+      return iof_filter_base16_decoder(N);
+    case PPSTREAM_BASE85:
+      return iof_filter_base85_decoder(N);
+    case PPSTREAM_RUNLENGTH:
+      return iof_filter_runlength_decoder(N);
+    case PPSTREAM_FLATE:
+      if ((F = iof_filter_flate_decoder(N)) != NULL)
+      {
+        if (params != NULL)
+        {
+          if ((P = ppstream_predictor(params, F)) != NULL)
+            return P;
+          iof_close(F);
+          break;
+        }
+        return F;
+      }
+      break;
+    case PPSTREAM_LZW:
+      flags = LZW_DECODER_DEFAULTS;
+      if (params != NULL && ppdict_get_int(params, "EarlyChange", &earlychange) && earlychange == 0) // integer, not boolean
+        flags &= ~LZW_EARLY_INDEX;
+      if ((F = iof_filter_lzw_decoder(N, flags)) != NULL)
+      {
+        if (params != NULL)
+        {
+          if ((P = ppstream_predictor(params, F)) != NULL)
+            return P;
+          iof_close(F);
+          break;
+        }
+        return F;
+      }
+      break;
+    case PPSTREAM_CRYPT:
+      if ((cryptkey = stream->cryptkey) == NULL)
+        return N; // /Identity crypt
+      if (stream->flags & PPSTREAM_ENCRYPTED_AES)
+        return iof_filter_aes_decoder(N, cryptkey, ppstring_size(cryptkey));
+      if (stream->flags & PPSTREAM_ENCRYPTED_RC4)
+        return iof_filter_rc4_decoder(N, cryptkey, ppstring_size(cryptkey));
+      return NULL; // if neither AES or RC4 but cryptkey present, something went wrong; see ppstream_info()
+    case PPSTREAM_CCITT:
+    case PPSTREAM_DCT:
+    case PPSTREAM_JBIG2:
+    case PPSTREAM_JPX:
+    case PPSTREAM_UNKNOWN:
+      break;
+  }
+  return NULL;
+}
+
+#define ppstream_image(type) (type == PPSTREAM_DCT || type == PPSTREAM_JBIG2 || PPSTREAM_JPX)
+
+#define ppstream_source(stream) iof_filter_stream_coreader((iof_file *)((stream)->input), (size_t)((stream)->offset), (size_t)((stream)->length))
+#define ppstream_auxsource(filename) iof_filter_file_reader(filename)
+
+static ppname ppstream_filter_name (ppobj *filterobj, size_t index)
+{
+  if (filterobj->type == PPNAME)
+    return index == 0 ? filterobj->name : NULL;
+  if (filterobj->type == PPARRAY)
+    return pparray_get_name(filterobj->array, index);
+  return NULL;
+}
+
+static ppdict * ppstream_filter_params (ppobj *paramsobj, size_t index)
+{
+  if (paramsobj->type == PPDICT)
+    return index == 0 ? paramsobj->dict : NULL;
+  if (paramsobj->type == PPARRAY)
+    return pparray_rget_dict(paramsobj->array, index);
+  return NULL;
+}
+
+static const char * ppstream_aux_filename (ppobj *filespec)
+{ // mockup, here we should decode the string
+  if (filespec->type == PPSTRING)
+  {
+    return (const char *)(filespec->string);
+  }
+  // else might be a dict - todo
+  return NULL;
+}
+
+iof * ppstream_read (ppstream *stream, int decode, int all)
+{
+  ppdict *dict;
+  iof *I, *F;
+  int codectype, external, owncrypt;
+  ppobj *filterobj, *paramsobj, *filespecobj;
+  ppname filter;
+  ppdict *params;
+  size_t index;
+  const char *filename;
+
+  if (ppstream_iof(stream) != NULL)
+    return NULL; // usage error
+
+  dict = stream->dict;
+  if ((filespecobj = ppdict_rget_obj(dict, "F")) != NULL)
+  {
+    filename = ppstream_aux_filename(filespecobj);
+    I = filename != NULL ? ppstream_auxsource(filename) : NULL;
+    external = 1;
+  }
+  else
+  {
+    I = ppstream_source(stream);
+    external = 0;
+  }
+  if (I == NULL)
+    return NULL;
+  /* If the stream is encrypted, decipher is the first to be applied */
+  owncrypt = (stream->flags & PPSTREAM_ENCRYPTED_OWN) != 0;
+  if (!owncrypt)
+  {
+    if (stream->cryptkey != NULL)
+    { /* implied global crypt */
+      if ((F = ppstream_decoder(stream, PPSTREAM_CRYPT, NULL, I)) == NULL)
+        goto stream_error;
+      I = F;
+    } /* otherwise no crypt at all or /Identity */
+  }
+  if (decode || owncrypt)
+  {
+    filterobj = ppdict_rget_obj(dict, external ? "FFilter" : "Filter");
+    if (filterobj != NULL)
+    {
+      paramsobj = ppdict_rget_obj(dict, external ? "FDecodeParms" : "DecodeParms");
+      for (index = 0, filter = ppstream_filter_name(filterobj, 0); filter != NULL; filter = ppstream_filter_name(filterobj, ++index))
+      {
+        params = paramsobj != NULL ? ppstream_filter_params(paramsobj, index) : NULL;
+        codectype = ppstream_codec_type(filter);
+        if ((F = ppstream_decoder(stream, codectype, params, I)) != NULL)
+        {
+          I = F;
+          if (owncrypt && !decode && codectype == PPSTREAM_CRYPT)
+            break; // /Crypt filter should always be first, so in practise we return decrypted but compressed
+          continue;
+        }
+        if (!ppstream_image(codectype)) // something unexpected
+          goto stream_error;
+        else // just treat image data (jpeg/jbig) as the target data
+          break;
+      }
+    }
+  }
+  if (all)
+    iof_load(I);
+  else
+    iof_input(I);
+  stream->I = I;
+  return I;
+stream_error:
+  iof_close(I);
+  return NULL;
+}
+
+uint8_t * ppstream_first (ppstream *stream, size_t *size, int decode)
+{
+  iof *I;
+  if ((I = ppstream_read(stream, decode, 0)) != NULL)
+  {
+    *size = (size_t)iof_left(I);
+    return I->pos;
+  }
+  *size = 0;
+  return NULL;
+}
+
+uint8_t * ppstream_next (ppstream *stream, size_t *size)
+{
+  iof *I;
+  if ((I = ppstream_iof(stream)) != NULL)
+  {
+    I->pos = I->end;
+    if ((*size = iof_input(I)) > 0)
+      return I->pos;
+  }
+  *size = 0;
+  return NULL;
+}
+
+uint8_t * ppstream_all (ppstream *stream, size_t *size, int decode)
+{
+  iof *I;
+  if ((I = ppstream_read(stream, decode, 1)) != NULL)
+  {
+    *size = (size_t)iof_left(I);
+    return I->pos;
+  }
+  *size = 0;
+  return NULL;
+}
+
+void ppstream_done (ppstream *stream)
+{
+  iof *I;
+  if ((I = ppstream_iof(stream)) != NULL)
+  {
+    iof_close(I);
+    stream->I = NULL;
+  }
+}
+
+/* */
+
+void ppstream_init_buffers (void)
+{
+	iof_filters_init();
+}
+
+void ppstream_free_buffers (void)
+{
+	iof_filters_free();
+}
diff --git a/texk/web2c/luatexdir/luapplib/ppstream.h b/texk/web2c/luatexdir/luapplib/ppstream.h
new file mode 100644
index 000000000..ae5c19cd9
--- /dev/null
+++ b/texk/web2c/luatexdir/luapplib/ppstream.h
@@ -0,0 +1,9 @@
+
+#ifndef PP_STREAM_H
+#define PP_STREAM_H
+
+ppstream * ppstream_create (ppdoc *pdf, ppdict *dict, size_t offset);
+iof * ppstream_read (ppstream *stream, int decode, int all);
+#define ppstream_iof(stream) ((iof *)((stream)->I))
+
+#endif
\ No newline at end of file
diff --git a/texk/web2c/luatexdir/luapplib/pptest1.c b/texk/web2c/luatexdir/luapplib/pptest1.c
new file mode 100644
index 000000000..4671849f5
--- /dev/null
+++ b/texk/web2c/luatexdir/luapplib/pptest1.c
@@ -0,0 +1,86 @@
+
+#include <stdio.h>
+#include "ppapi.h"
+
+static const char * sizenum (size_t s)
+{
+  static char buffer[32];
+  if (s < 1000)
+    sprintf(buffer, "%uB", (unsigned)s);
+  else if (s < 1000000)
+    sprintf(buffer, "%.2fkB", (double)(s) / 1000);
+  else
+    sprintf(buffer, "%.2fMB", (double)(s) / 1000000);
+  return buffer;
+}
+
+static const char * crypt_info (ppdoc *pdf)
+{
+	switch (ppdoc_crypt_status(pdf))
+	{
+		case PPCRYPT_NONE:
+			return "none";
+		case PPCRYPT_DONE:
+			return "empty password";
+		case PPCRYPT_PASS:
+			return "nonempty password";
+		default:
+			break;
+	}
+	return "this shouldn't happen";
+}
+
+static void print_info (ppdoc *pdf)
+{
+  ppdict *info;
+  ppstring creator, producer;
+  size_t memused, memwaste;
+
+  if ((info = ppdoc_info(pdf)) != NULL)
+  {
+    if ((creator = ppdict_rget_string(info, "Creator")) != NULL)
+      printf("  creator: %s\n", ppstring_decoded(creator));
+    if ((producer = ppdict_rget_string(info, "Producer")) != NULL)
+      printf("  producer: %s\n", ppstring_decoded(producer));
+  }
+  printf("  version: %s\n", ppdoc_version_string(pdf));
+  printf("  protection: %s\n", crypt_info(pdf));
+  printf("  filesize: %s\n", sizenum(ppdoc_file_size(pdf)));
+  printf("  objects: " PPUINTF "\n", ppdoc_objects(pdf));
+  printf("  pagecount: " PPUINTF "\n", ppdoc_page_count(pdf));
+  memused = ppdoc_memory(pdf, &memwaste);
+  printf("  memused: %s\n", sizenum(memused));
+  printf("  memwaste: %s\n", sizenum(memwaste));
+}
+
+static int usage (const char *argv0)
+{
+	printf("pplib " pplib_version ", " pplib_author "\n");
+	printf("usage: %s file1.pdf file2.pdf ...\n", argv0);
+	return 0;
+}
+
+int main (int argc, const char **argv)
+{
+  const char *filepath;
+  int a;
+  ppdoc *pdf;
+
+  if (argc < 2)
+    return usage(argv[0]);
+  for (a = 1; a < argc; ++a)
+  {
+    filepath = argv[a];
+    printf("loading %s... ", filepath);
+    pdf = ppdoc_load(filepath);
+    if (pdf == NULL)
+    {
+      printf("failed\n");
+      continue;
+    }
+    printf("done.\n");
+    print_info(pdf);
+    ppdoc_free(pdf);
+  }
+  return 0;
+}
diff --git a/texk/web2c/luatexdir/luapplib/pptest2.c b/texk/web2c/luatexdir/luapplib/pptest2.c
new file mode 100644
index 000000000..4b7f66a01
--- /dev/null
+++ b/texk/web2c/luatexdir/luapplib/pptest2.c
@@ -0,0 +1,139 @@
+
+#include <stdio.h>
+#include <assert.h>
+#include "ppapi.h"
+
+static const char * get_file_name (const char *path)
+{
+  const char *fn, *p;
+  for (fn = p = path; *p != '\0'; ++p)
+    if (*p == '\\' || *p == '/')
+      fn = p + 1;
+  return fn;
+}
+
+static void box_info (ppdict *pagedict, FILE *fh)
+{
+  const char *boxes[] = {"MediaBox", "CropBox", "BleedBox", "TrimBox", "ArtBox"};
+  pprect rect;
+  size_t i;
+  for (i = 0; i < sizeof(boxes) / sizeof(const char *); ++i)
+    if (ppdict_get_box(pagedict, boxes[i], &rect))
+      fprintf(fh, "%%%% %s [%f %f %f %f]\n", boxes[i], rect.lx, rect.ly, rect.rx, rect.ry);
+}
+
+static int usage (const char *argv0)
+{
+	printf("pplib " pplib_version ", " pplib_author "\n");
+	printf("usage: %s file1.pdf file2.pdf ...\n", argv0);
+	return 0;
+}
+
+#define OUTDIR "."
+
+static void log_callback (const char *message, void *alien)
+{
+	fprintf((FILE *)alien, "\nooops: %s\n", message);
+}
+
+int main (int argc, const char **argv)
+{
+  const char *filepath, *filename;
+  int a;
+  ppdoc *pdf;
+  ppref *pageref;
+  ppdict *pagedict;
+  int pageno;
+  char outname[1024];
+  FILE *fh;
+  ppstream *stream;
+  uint8_t *data;
+  size_t size;
+  ppcontext *context;
+  ppobj *obj;
+  ppname op;
+  size_t operators;
+
+  if (argc < 2)
+    return usage(argv[0]);
+  ppstream_init_buffers();
+  pplog_callback(log_callback, stderr);
+  context = ppcontext_new();
+  for (a = 1; a < argc; ++a)
+  {
+    filepath = argv[a];
+    printf("loading %s... ", filepath);
+    pdf = ppdoc_load(filepath);
+    if (pdf == NULL)
+    {
+      printf("failed\n");
+      continue;
+    }
+    printf("done.\n");
+    switch (ppdoc_crypt_status(pdf))
+    {
+    	case PPCRYPT_NONE:
+    	case PPCRYPT_DONE:
+    		break;
+    	case PPCRYPT_PASS:
+    		if (ppdoc_crypt_pass(pdf, "dummy", 5, NULL, 0) == PPCRYPT_DONE || ppdoc_crypt_pass(pdf, NULL, 0, "dummy", 5) == PPCRYPT_DONE)
+    		  break;
+        printf("sorry, password needed\n");
+        ppdoc_free(pdf);
+        continue;
+    	case PPCRYPT_FAIL:
+    		printf("sorry, encryption failed\n");
+    		ppdoc_free(pdf);
+    		continue;
+    }
+    filename = get_file_name(filepath);
+    sprintf(outname, OUTDIR "/%s.out", filename);
+    fh = fopen(outname, "wb");
+    if (fh == NULL)
+    {
+      printf("can't open %s for writing\n", outname);
+      continue;
+    }
+    for (pageref = ppdoc_first_page(pdf), pageno = 1;
+         pageref != NULL;
+         pageref = ppdoc_next_page(pdf), ++pageno)
+    {
+      pagedict = pageref->object.dict;
+      /* decompress contents data */
+      fprintf(fh, "%%%% PAGE %d\n", pageno);
+      box_info(pagedict, fh);
+      for (stream = ppcontents_first(pagedict);
+           stream != NULL;
+           stream = ppcontents_next(pagedict, stream))
+      {
+        for (data = ppstream_first(stream, &size, 1);
+             data != NULL;
+             data = ppstream_next(stream, &size))
+          fwrite(data, size, 1, fh);
+        ppstream_done(stream);
+      }
+      /* now parse contents */
+      for (stream = ppcontents_first(pagedict);
+           stream != NULL;
+           stream = ppcontents_next(pagedict, stream))
+      {
+        operators = 0;
+        for (obj = ppcontents_first_op(context, stream, &size, &op);
+             obj != NULL;
+             obj = ppcontents_next_op(context, stream, &size, &op))
+          ++operators;
+        fprintf(fh, "%%%% OPERATORS count " PPSIZEF "\n", operators);
+        ppstream_done(stream);
+        //obj = ppcontents_parse(context, stream, &size);
+        //fprintf(fh, "%%%% items count " PPSIZEF "\n", size);
+        fprintf(fh, "\n");
+      }
+      ppcontext_done(context);
+    }
+    fclose(fh);
+    ppdoc_free(pdf);
+  }
+  ppcontext_free(context);
+	ppstream_free_buffers();
+  return 0;
+}
diff --git a/texk/web2c/luatexdir/luapplib/ppxref.c b/texk/web2c/luatexdir/luapplib/ppxref.c
new file mode 100644
index 000000000..984f6cbe3
--- /dev/null
+++ b/texk/web2c/luatexdir/luapplib/ppxref.c
@@ -0,0 +1,162 @@
+
+#include "pplib.h"
+
+#define PPXREF_MAP_INIT 16 // number of xref sections
+
+ppxref * ppxref_create (ppdoc *pdf, size_t initsize, size_t xrefoffset)
+{
+  ppxref *xref;
+
+  if (initsize == 0) // unknown
+    initsize = PPXREF_MAP_INIT;
+  xref = (ppxref *)ppheap_take(&pdf->heap, sizeof(ppxref) + initsize * sizeof(ppxsec));
+  xref->sects = (ppxsec *)(xref + 1);
+  xref->size = 0;
+  xref->space = initsize;
+  xref->count = 0;
+  xref->trailer.type = PPNONE;
+  xref->trailer.dict = NULL;
+  xref->prev = NULL;
+  xref->pdf = pdf;
+  xref->offset = xrefoffset;
+  //xref->crypt = NULL;
+  return xref;
+}
+
+ppxsec * ppxref_push_section (ppxref *xref, ppheap **pheap)
+{
+  ppxsec *sects;
+  if (xref->size < xref->space)
+    return &xref->sects[xref->size++];
+  xref->space <<= 1;
+  sects = xref->sects;
+  xref->sects = (ppxsec *)ppheap_take(pheap, xref->space * sizeof(ppxsec)); // waste but rare
+  memcpy(xref->sects, sects, xref->size * sizeof(ppxsec));
+  return &xref->sects[xref->size++];
+}
+
+static void ppxref_sort_sects (ppxsec *left, ppxsec *right)
+{
+  ppxsec *l, *r, *m, t;
+  ppuint first, last;
+  l = left, r = right, m = l + ((r - l) / 2);
+  first = m->first, last = m->last;
+  do
+  { // don't take first/last from pointer
+    while (l->first < first) ++l;
+    while (r->first > last) --r;
+    if (l <= r)
+    {
+      t = *l;
+      *l = *r;
+      *r = t;
+      ++l, --r;
+    }
+  } while (l <= r);
+  if (l < right)
+    ppxref_sort_sects(l, right);
+  if (r > left)
+    ppxref_sort_sects(left, r);
+}
+
+int ppxref_sort (ppxref *xref)
+{
+  if (xref->size == 0)
+    return 0;
+  ppxref_sort_sects(xref->sects, xref->sects + xref->size - 1);
+  return 1;
+}
+
+ppref * ppxref_find_local (ppxref *xref, ppuint refnumber)
+{
+  ppxsec *left, *right, *mid;
+  //if (xref->size == 0) // we don't allow that
+  //  return NULL;
+  left = xref->sects;
+  right = xref->sects + xref->size - 1;
+  do
+  {
+    mid = left + ((right - left) / 2);
+    if (refnumber > mid->last)
+      left = mid + 1;
+    else if (refnumber < mid->first)
+      right = mid - 1;
+    else
+      return &mid->refs[refnumber - mid->first];
+  } while (left <= right);
+  return NULL;
+}
+
+ppref * ppxref_find (ppxref *xref, ppuint refnumber)
+{
+  ppref *ref;
+  ppxref *other;
+
+  if ((ref = ppxref_find_local(xref, refnumber)) != NULL)
+    return ref;
+  if (xref->pdf->flags & PPDOC_LINEARIZED)
+  {
+    for (other = xref->pdf->xref; other != NULL; other = other->prev)
+      if (other != xref && (ref = ppxref_find_local(other, refnumber)) != NULL)
+        return ref;
+  }
+  else
+  {
+    for (other = xref->prev; other != NULL; other = other->prev)
+      if ((ref = ppxref_find_local(other, refnumber)) != NULL)
+        return ref;
+    /* This shouldn't happen, but I've met documents that have no linearized dict,
+       but their xrefs are prepared as for linearized; with "older" xrefs referring
+       to "newer". */
+    for (other = xref->pdf->xref; other != NULL && other != xref; other = other->prev)
+      if ((ref = ppxref_find_local(other, refnumber)) != NULL)
+        return ref;
+  }
+  return NULL;
+}
+
+ppdict * ppxref_trailer (ppxref *xref)
+{
+  switch (xref->trailer.type)
+  {
+    case PPDICT:
+      return xref->trailer.dict;
+    case PPSTREAM:
+      return xref->trailer.stream->dict;
+    default:
+      break;
+  }
+  return NULL;
+}
+
+ppxref * ppdoc_xref (ppdoc *pdf)
+{
+	return pdf->xref;
+}
+
+ppxref * ppxref_prev (ppxref *xref)
+{
+	return xref->prev;
+}
+
+ppdict * ppxref_catalog (ppxref *xref)
+{
+	ppdict *trailer;
+	return (trailer = ppxref_trailer(xref)) != NULL ? ppdict_rget_dict(trailer, "Root") : NULL;
+}
+
+ppdict * ppxref_info (ppxref *xref)
+{
+	ppdict *trailer;
+	return (trailer = ppxref_trailer(xref)) != NULL ? ppdict_rget_dict(trailer, "Info") : NULL;
+}
+
+ppref * ppxref_pages (ppxref *xref)
+{
+  ppdict *dict;
+  ppref *ref;
+
+  if ((dict = ppxref_catalog(xref)) == NULL || (ref = ppdict_get_ref(dict, "Pages")) == NULL)
+    return NULL;
+  return ref->object.type == PPDICT ? ref : NULL;
+}
diff --git a/texk/web2c/luatexdir/luapplib/ppxref.h b/texk/web2c/luatexdir/luapplib/ppxref.h
new file mode 100644
index 000000000..86ab98a51
--- /dev/null
+++ b/texk/web2c/luatexdir/luapplib/ppxref.h
@@ -0,0 +1,35 @@
+
+#ifndef PP_XREF_H
+#define PP_XREF_H
+
+/*
+What we call xref is actually "xref section" in PDF spec and what we call section is "xref subsection".
+Our ppxref is a list of sections, sorted by xrefsection->first and xrefsection->last bounds. Every section
+keeps a list of ppref *refs, enumerated from xrefsection->first to xrefsection->last. To find a reference
+by number we make a binary search over sections bounds, then jump to the proper ppref *ref.
+*/
+
+typedef struct {
+  ppuint first;     // first reference number in section
+  ppuint last;      // last reference number in section
+  ppref *refs;      // references list
+} ppxsec;
+
+struct ppxref {
+  ppxsec *sects;    // subsections list
+  size_t size;      // actual sections size
+  size_t space;     // available sections space
+  ppobj trailer;    // trailer dict or stream
+  ppuint count;     // count of references in all sections
+  ppxref *prev;     // previous xref
+  ppdoc *pdf;       // parent pdf to access entries in linearized docs
+  size_t offset;    // file offset of xref
+  //ppcrypt *crypt;   // per xref encryption state? 
+};
+
+ppxref * ppxref_create (ppdoc *pdf, size_t initsize, size_t xrefoffset);
+ppxsec * ppxref_push_section (ppxref *xref, ppheap **pheap);
+int ppxref_sort (ppxref *xref);
+ppref * ppxref_find_local (ppxref *xref, ppuint refnumber);
+
+#endif
\ No newline at end of file
diff --git a/texk/web2c/luatexdir/luapplib/util/utilbasexx.c b/texk/web2c/luatexdir/luapplib/util/utilbasexx.c
new file mode 100644
index 000000000..6fdd6fb58
--- /dev/null
+++ b/texk/web2c/luatexdir/luapplib/util/utilbasexx.c
@@ -0,0 +1,2108 @@
+
+#include "utilnumber.h"
+#include "utilmem.h"
+#include "utilbasexx.h"
+
+/* filters state structs */
+
+struct basexx_state {
+  size_t line, maxline;
+  size_t left;
+  int tail[5];
+  int flush;
+};
+
+struct runlength_state {
+  int run;
+  int flush;
+  int c1, c2;
+  uint8_t *pos;
+};
+
+struct eexec_state {
+  int key;
+  int flush;
+  int binary;
+  int c1;
+  size_t line, maxline; /* ascii encoder only */
+  const char *initbytes;
+};
+
+/* config */
+
+#if defined(BASEXX_PDF)
+#  define ignored(c) (c == 0x20 || c == 0x0A || c == 0x0C || c == 0x0D || c == 0x09 || c == 0x00)
+#  define base16_eof(c) (c == '>' || c < 0)
+#  define base85_eof(c) (c == '~' || c < 0)
+#else
+#  define ignored(c) (c == 0x20 || c == 0x0A || c == 0x0D || c == 0x09)
+#  define base16_eof(c) (c < 0)
+#  define base85_eof(c) (c < 0)
+#endif
+
+#define base64_eof(c) (c == '=' || c < 0)
+
+#define basexx_nl '\x0A'
+#define put_nl(O, line, maxline, n) ((void)((line += n) > maxline && ((line = n), iof_set(O, basexx_nl))))
+
+/* tail macros */
+
+#define set_tail1(state, c1)             (state->left = 1, state->tail[0] = c1)
+#define set_tail2(state, c1, c2)         (state->left = 2, state->tail[0] = c1, state->tail[1] = c2)
+#define set_tail3(state, c1, c2, c3)     (state->left = 3, state->tail[0] = c1, state->tail[1] = c2, state->tail[2] = c3)
+#define set_tail4(state, c1, c2, c3, c4) (state->left = 4, state->tail[0] = c1, state->tail[1] = c2, state->tail[2] = c3, state->tail[3] = c4)
+#define set_tail5(state, c1, c2, c3, c4, c5) \
+  (state->left = 5, state->tail[0] = c1, state->tail[1] = c2, state->tail[2] = c3, state->tail[3] = c4, state->tail[4] = c5)
+
+#define get_tail1(state, c1)             (state->left = 0, c1 = state->tail[0])
+#define get_tail2(state, c1, c2)         (state->left = 0, c1 = state->tail[0], c2 = state->tail[1])
+#define get_tail3(state, c1, c2, c3)     (state->left = 0, c1 = state->tail[0], c2 = state->tail[1], c3 = state->tail[2])
+#define get_tail4(state, c1, c2, c3, c4) (state->left = 0, c1 = state->tail[0], c2 = state->tail[1], c3 = state->tail[2], c4 = state->tail[3])
+
+/* basexx state initialization */
+
+void basexx_state_init_ln (basexx_state *state, size_t line, size_t maxline)
+{
+  state->line = line;
+  state->maxline = maxline;
+  state->left = 0;
+  state->flush = 0;
+}
+
+/* base 16; xxxx|xxxx */
+
+iof_status base16_encoded_uc (const void *data, size_t size, iof *O)
+{
+  const uint8_t *s, *e;
+  for (s = (const uint8_t *)data, e = s + size; s < e; ++s)
+  {
+    if (!iof_ensure(O, 2))
+      return IOFFULL;
+    iof_set_uc_hex(O, *s);
+  }
+  return IOFEOF;
+}
+
+iof_status base16_encoded_lc (const void *data, size_t size, iof *O)
+{
+  const uint8_t *s, *e;
+  for (s = (const uint8_t *)data, e = s + size; s < e; ++s)
+  {
+    if (!iof_ensure(O, 2))
+      return IOFFULL;
+    iof_set_lc_hex(O, *s);
+  }
+  return IOFEOF;
+}
+
+iof_status base16_encoded_uc_ln (const void *data, size_t size, iof *O, size_t line, size_t maxline)
+{
+  const uint8_t *s, *e;
+  for (s = (const uint8_t *)data, e = s + size; s < e; ++s)
+  {
+    if (!iof_ensure(O, 3))
+      return IOFFULL;
+    put_nl(O, line, maxline, 2);
+    iof_set_uc_hex(O, *s);
+  }
+  return IOFFULL;
+}
+
+iof_status base16_encoded_lc_ln (const void *data, size_t size, iof *O, size_t line, size_t maxline)
+{
+  const uint8_t *s, *e;
+  for (s = (const uint8_t *)data, e = s + size; s < e; ++s)
+  {
+    if (!iof_ensure(O, 3))
+      return IOFFULL;
+    put_nl(O, line, maxline, 2);
+    iof_set_lc_hex(O, *s);
+  }
+  return IOFFULL;
+}
+
+iof_status base16_encode_uc (iof *I, iof *O)
+{
+  register int c;
+  while (iof_ensure(O, 2))
+  {
+    if ((c = iof_get(I)) < 0)
+      return IOFEOF;
+    iof_set_uc_hex(O, c);
+  }
+  return IOFFULL;
+}
+
+iof_status base16_encode_state_uc (iof *I, iof *O, basexx_state *state)
+{
+  register int c;
+  while (iof_ensure(O, 2))
+  {
+    if ((c = iof_get(I)) < 0)
+      return (state->flush ? IOFEOF : IOFEMPTY);
+    iof_set_uc_hex(O, c);
+  }
+  return IOFFULL;
+}
+
+iof_status base16_encode_lc (iof *I, iof *O)
+{
+  register int c;
+  while (iof_ensure(O, 2))
+  {
+    if ((c = iof_get(I)) < 0)
+      return IOFEOF;
+    iof_set_lc_hex(O, c);
+  }
+  return IOFFULL;
+}
+
+iof_status base16_encode_state_lc (iof *I, iof *O, basexx_state *state)
+{
+  register int c;
+  while (iof_ensure(O, 2))
+  {
+    if ((c = iof_get(I)) < 0)
+      return (state->flush ? IOFEOF : IOFEMPTY);
+    iof_set_lc_hex(O, c);
+  }
+  return IOFFULL;
+}
+
+iof_status base16_encode_uc_ln (iof *I, iof *O, size_t line, size_t maxline)
+{
+  register int c;
+  while (iof_ensure(O, 3))
+  {
+    if ((c = iof_get(I)) < 0)
+      return IOFEOF;
+    put_nl(O, line, maxline, 2);
+    iof_set_uc_hex(O, c);
+  }
+  return IOFFULL;
+}
+
+iof_status base16_encode_state_uc_ln (iof *I, iof *O, basexx_state *state)
+{
+  register int c;
+  while (iof_ensure(O, 3))
+  {
+    if ((c = iof_get(I)) < 0)
+      return (state->flush ? IOFEOF : IOFEMPTY);
+    put_nl(O, state->line, state->maxline, 2);
+    iof_set_uc_hex(O, c);
+  }
+  return IOFFULL;
+}
+
+iof_status base16_encode_lc_ln (iof *I, iof *O, size_t line, size_t maxline)
+{
+  register int c;
+  while (iof_ensure(O, 3))
+  {
+    if ((c = iof_get(I)) < 0)
+      return IOFEOF;
+    put_nl(O, line, maxline, 2);
+    iof_set_lc_hex(O, c);
+  }
+  return IOFFULL;
+}
+
+iof_status base16_encode_state_lc_ln (iof *I, iof *O, basexx_state *state)
+{
+  register int c;
+  while (iof_ensure(O, 3))
+  {
+    if ((c = iof_get(I)) < 0)
+      return (state->flush ? IOFEOF : IOFEMPTY);
+    put_nl(O, state->line, state->maxline, 2);
+    iof_set_lc_hex(O, c);
+  }
+  return IOFFULL;
+}
+
+int base16_getc (iof *I)
+{
+  register int c1, c2;
+  do { c1 = iof_get(I); } while (ignored(c1));
+  if (base16_eof(c1))
+    return IOFEOF;
+  do { c2 = iof_get(I); } while (ignored(c2));
+  if (base16_eof(c2))
+  {
+    if ((c1 = base16_lookup[c1]) == -1)
+      return IOFERR;
+    return c1<<4;
+  }
+  if ((c1 = base16_lookup[c1]) == -1 || (c2 = base16_lookup[c2]) == -1)
+    return IOFERR;
+  return (c1<<4)|c2;
+}
+
+int base16_lc_putc (iof *O, int c)
+{
+  if (iof_ensure(O, 2))
+    iof_set_lc_hex(O, c);
+  return IOFFULL;
+}
+
+int base16_uc_putc (iof *O, int c)
+{
+  if (iof_ensure(O, 2))
+    iof_set_uc_hex(O, c);
+  return IOFFULL;
+}
+
+
+iof_status base16_decode (iof *I, iof *O)
+{
+  register int c1, c2;
+  while (iof_ensure(O, 1))
+  {
+    do { c1 = iof_get(I); } while (ignored(c1));
+    if (base16_eof(c1))
+      return IOFEOF;
+    do { c2 = iof_get(I); } while (ignored(c2));
+    if (base16_eof(c2))
+    {
+      if ((c1 = base16_lookup[c1]) == -1)
+        return IOFERR;
+      iof_set(O, c1<<4); // c2 := '0'
+      return IOFEOF;
+    }
+    if ((c1 = base16_lookup[c1]) == -1 || (c2 = base16_lookup[c2]) == -1)
+      return IOFERR;
+    iof_set(O, (c1<<4)|c2);
+  }
+  return IOFFULL;
+}
+
+iof_status base16_decode_state (iof *I, iof *O, basexx_state *state)
+{
+  register int c1, c2, d1, d2;
+  if (!(iof_ensure(O, 1)))
+    return IOFFULL;
+  switch(state->left)
+  {
+    case 0: goto byte0;
+    case 1: get_tail1(state, c1); goto byte1;
+  }
+  while (iof_ensure(O, 1))
+  {
+    byte0:
+    do { c1 = iof_get(I); } while (ignored(c1));
+    if (base16_eof(c1))
+      return (state->flush ? IOFEOF : IOFEMPTY);
+    byte1:
+    do { c2 = iof_get(I); } while (ignored(c2));
+    if (base16_eof(c2))
+    {
+      set_tail1(state, c1); /* set tail to let the caller display invalid chars */
+      if (state->flush)
+      {
+        if ((c1 = base16_lookup[c1]) == -1)
+          return IOFERR;
+        iof_set(O, c1<<4); // c2 := '0'
+        return IOFEOF;
+      }
+      return IOFEMPTY;
+    }
+    if ((d1 = base16_lookup[c1]) == -1 || (d2 = base16_lookup[c2]) == -1)
+    {
+      set_tail2(state, c1, c2);
+      return IOFERR;
+    }
+    iof_set(O, (d1<<4)|d2);
+  }
+  return IOFFULL;
+}
+
+/* base 64; xxxxxx|xx xxxx|xxxx xx|xxxxxx */
+
+const char base64_alphabet[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+
+const int base64_lookup[] = {
+  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,62,-1,-1,-1,63,
+  52,53,54,55,56,57,58,59,60,61,-1,-1,-1,-1,-1,-1,
+  -1, 0, 1, 2, 3, 4, 5, 6, 7, 8,9 ,10,11,12,13,14,
+  15,16,17,18,19,20,21,22,23,24,25,-1,-1,-1,-1,-1,
+  -1,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,
+  41,42,43,44,45,46,47,48,49,50,51,-1,-1,-1,-1,-1,
+  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1
+};
+
+#define base64_digit1(c1)     base64_alphabet[c1>>2]
+#define base64_digit2(c1, c2) base64_alphabet[((c1&3)<<4)|(c2>>4)]
+#define base64_digit3(c2, c3) base64_alphabet[((c2&15)<<2)|(c3>>6)]
+#define base64_digit4(c3)     base64_alphabet[c3&63]
+
+#define base64_encode_word(O, c1, c2, c3) \
+  iof_set4(O, base64_digit1(c1), base64_digit2(c1, c2), base64_digit3(c2, c3), base64_digit4(c3))
+
+#define base64_encode_tail2(O, c1, c2) \
+  iof_set3(O, base64_digit1(c1), base64_digit2(c1, c2), base64_digit3(c2, 0))
+
+#define base64_encode_tail1(O, c1) \
+  iof_set2(O, base64_digit1(c1), base64_digit2(c1, 0))
+
+iof_status base64_encoded (const void *data, size_t size, iof *O)
+{
+  const uint8_t *s, *e;
+  uint8_t c1, c2, c3;
+  for (s = (const uint8_t *)data, e = s + size; s + 2 < e; )
+  {
+    if (!iof_ensure(O, 4))
+      return IOFFULL;
+    c1 = *s++;
+    c2 = *s++;
+    c3 = *s++;
+    base64_encode_word(O, c1, c2, c3);
+  }
+  switch (e - s)
+  {
+    case 0:
+      break;
+    case 1:
+      if (!iof_ensure(O, 2))
+        return IOFFULL;
+      c1 = *s;
+      base64_encode_tail1(O, c1);
+      break;
+    case 2:
+      if (!iof_ensure(O, 3))
+        return IOFFULL;
+      c1 = *s++;
+      c2 = *s;
+      base64_encode_tail2(O, c1, c2);
+      break;
+  }
+  return IOFEOF;
+}
+
+iof_status base64_encoded_ln (const void *data, size_t size, iof *O, size_t line, size_t maxline)
+{
+  const uint8_t *s, *e;
+  uint8_t c1, c2, c3;
+  for (s = (const uint8_t *)data, e = s + size; s + 2 < e; )
+  {
+    if (!iof_ensure(O, 5))
+      return IOFFULL;
+    c1 = *s++;
+    c2 = *s++;
+    c3 = *s++;
+    put_nl(O, line, maxline, 4);
+    base64_encode_word(O, c1, c2, c3);
+  }
+  switch (e - s)
+  {
+    case 0:
+      break;
+    case 1:
+      if (!iof_ensure(O, 3))
+        return IOFFULL;
+      c1 = *s;
+      put_nl(O, line, maxline, 2);
+      base64_encode_tail1(O, c1);
+      break;
+    case 2:
+      if (!iof_ensure(O, 4))
+        return IOFFULL;
+      c1 = *s++;
+      c2 = *s;
+      put_nl(O, line, maxline, 3);
+      base64_encode_tail2(O, c1, c2);
+      break;
+  }
+  return IOFEOF;
+}
+
+iof_status base64_encode (iof *I, iof *O)
+{
+  register int c1, c2, c3;
+  while(iof_ensure(O, 4))
+  {
+    if ((c1 = iof_get(I)) < 0)
+      return IOFEOF;
+    if ((c2 = iof_get(I)) < 0)
+    {
+      base64_encode_tail1(O, c1);
+      return IOFEOF;
+    }
+    if ((c3 = iof_get(I)) < 0)
+    {
+      base64_encode_tail2(O, c1, c2);
+      return IOFEOF;
+    }
+    base64_encode_word(O, c1, c2, c3);
+  }
+  return IOFFULL;
+}
+
+iof_status base64_encode_state (iof *I, iof *O, basexx_state *state)
+{
+  register int c1, c2, c3;
+  if (!(iof_ensure(O, 4)))
+    return IOFFULL;
+  switch(state->left)
+  {
+    case 0: goto byte0;
+    case 1: get_tail1(state, c1); goto byte1;
+    case 2: get_tail2(state, c1, c2); goto byte2;
+  }
+  while(iof_ensure(O, 4))
+  {
+    byte0:
+    if ((c1 = iof_get(I)) < 0)
+      return (state->flush ? IOFEOF : IOFEMPTY);
+    byte1:
+    if ((c2 = iof_get(I)) < 0)
+      return (state->flush ? (base64_encode_tail1(O, c1), IOFEOF) : (set_tail1(state, c1), IOFEMPTY));
+    byte2:
+    if ((c3 = iof_get(I)) < 0)
+      return (state->flush ? (base64_encode_tail2(O, c1, c2), IOFEOF) : (set_tail2(state, c1, c2), IOFEMPTY));
+    base64_encode_word(O, c1, c2, c3);
+  }
+  return IOFFULL;
+}
+
+iof_status base64_encode_ln (iof *I, iof *O, size_t line, size_t maxline)
+{
+  register int c1, c2, c3;
+  while(iof_ensure(O, 5))
+  {
+    if ((c1 = iof_get(I)) < 0)
+      return IOFEOF;
+    if ((c2 = iof_get(I)) < 0)
+    {
+      put_nl(O, line, maxline, 2);
+      base64_encode_tail1(O, c1);
+      return IOFEOF;
+    }
+    if ((c3 = iof_get(I)) < 0)
+    {
+      put_nl(O, line, maxline, 3);
+      base64_encode_tail2(O, c1, c2);
+      return IOFEOF;
+    }
+    put_nl(O, line, maxline, 4);
+    base64_encode_word(O, c1, c2, c3);
+  }
+  return IOFFULL;
+}
+
+iof_status base64_encode_state_ln (iof *I, iof *O, basexx_state *state)
+{
+  register int c1, c2, c3;
+  if (!(iof_ensure(O, 5)))
+    return IOFFULL;
+  switch(state->left)
+  {
+    case 0: goto byte0;
+    case 1: get_tail1(state, c1); goto byte1;
+    case 2: get_tail2(state, c1, c2); goto byte2;
+  }
+  while(iof_ensure(O, 5))
+  {
+    byte0:
+    if ((c1 = iof_get(I)) < 0)
+      return (state->flush ? IOFEOF : IOFEMPTY);
+    byte1:
+    if ((c2 = iof_get(I)) < 0)
+      return (state->flush ? (put_nl(O, state->line, state->maxline, 2), base64_encode_tail1(O, c1), IOFEOF) : (set_tail1(state, c1), IOFEMPTY));
+    byte2:
+    if ((c3 = iof_get(I)) < 0)
+      return (state->flush ? (put_nl(O, state->line, state->maxline, 3), base64_encode_tail2(O, c1, c2), IOFEOF) : (set_tail2(state, c1, c2), IOFEMPTY));
+    put_nl(O, state->line, state->maxline, 4);
+    base64_encode_word(O, c1, c2, c3);
+  }
+  return IOFFULL;
+}
+
+// #define base64_code(c1, c2, c3, c4) ((c1<<18)|(c2<<12)|(c3<<6)|c4)
+
+#define base64_decode_word(O, c1, c2, c3, c4) \
+  iof_set3(O, (c1<<2)|(c2>>4), ((c2&15)<<4)|(c3>>2), ((c3&3)<<6)|c4)
+
+#define base64_decode_tail3(O, c1, c2, c3) \
+  iof_set2(O, (c1<<2)|(c2>>4), ((c2&15)<<4)|(c3>>2))
+
+#define base64_decode_tail2(O, c1, c2) \
+  iof_set(O, (c1<<2)|(c2>>4))
+
+iof_status base64_decode (iof *I, iof *O)
+{
+  register int c1, c2, c3, c4;
+  while(iof_ensure(O, 3))
+  {
+    do { c1 = iof_get(I); } while (ignored(c1));
+    if (base64_eof(c1))
+      return IOFEOF;
+    do { c2 = iof_get(I); } while (ignored(c2));
+    if (base64_eof(c2))
+      return IOFERR;
+    do { c3 = iof_get(I); } while (ignored(c3));
+    if (base64_eof(c3))
+    {
+      if ((c1 = base64_lookup[c1]) == -1 || (c2 = base64_lookup[c2]) == -1)
+        return IOFERR;
+      base64_decode_tail2(O, c1, c2);
+      return IOFEOF;
+    }
+    do { c4 = iof_get(I); } while (ignored(c4));
+    if (base64_eof(c4))
+    {
+      if ((c1 = base64_lookup[c1]) == -1 || (c2 = base64_lookup[c2]) == -1 || (c3 = base64_lookup[c3]) == -1)
+        return IOFERR;
+      base64_decode_tail3(O, c1, c2, c3);
+      return IOFEOF;
+    }
+    if ((c1 = base64_lookup[c1]) == -1 || (c2 = base64_lookup[c2]) == -1 ||
+        (c3 = base64_lookup[c3]) == -1 || (c4 = base64_lookup[c4]) == -1)
+          return IOFERR;
+    base64_decode_word(O, c1, c2, c3, c4);
+  }
+  return IOFFULL;
+}
+
+iof_status base64_decode_state (iof *I, iof *O, basexx_state *state)
+{
+  register int c1, c2, c3, c4;
+  register int d1, d2, d3, d4;
+  switch(state->left)
+  {
+    case 0: goto byte0;
+    case 1: get_tail1(state, c1); goto byte1;
+    case 2: get_tail2(state, c1, c2); goto byte2;
+    case 3: get_tail3(state, c1, c2, c3); goto byte3;
+  }
+  while(iof_ensure(O, 3))
+  {
+    byte0:
+    do { c1 = iof_get(I); } while (ignored(c1));
+    if (base64_eof(c1))
+      return (state->flush ? IOFEOF : IOFEMPTY);
+    byte1:
+    do { c2 = iof_get(I); } while (ignored(c2));
+    if (base64_eof(c2))
+    {
+      set_tail1(state, c1); /* set tail to let the caller make padding or display invalid char in case of error */
+      return (state->flush ? IOFERR : IOFEMPTY); /* if state->flush then error; tail must have at least two bytes */
+    }
+    byte2:
+    do { c3 = iof_get(I); } while (ignored(c3));
+    if (base64_eof(c3))
+    {
+      set_tail2(state, c1, c2);
+      if (state->flush)
+      {
+        if ((c1 = base64_lookup[c1]) == -1 || (c2 = base64_lookup[c2]) == -1)
+          return IOFERR;
+        base64_decode_tail2(O, c1, c2);
+        return IOFEOF;
+      }
+      else
+        return IOFEMPTY;
+    }
+    byte3:
+    do { c4 = iof_get(I); } while (ignored(c4));
+    if (base64_eof(c4))
+    {
+      set_tail3(state, c1, c2, c3);
+      if (state->flush)
+      {
+        if ((c1 = base64_lookup[c1]) == -1 || (c2 = base64_lookup[c2]) == -1 || (c3 = base64_lookup[c3]) == -1)
+          return IOFERR;
+        base64_decode_tail3(O, c1, c2, c3);
+        return IOFEOF;
+      }
+      else
+        return IOFEMPTY;
+    }
+    if ((d1 = base64_lookup[c1]) == -1 || (d2 = base64_lookup[c2]) == -1 ||
+        (d3 = base64_lookup[c3]) == -1 || (d4 = base64_lookup[c4]) == -1)
+    {
+      set_tail4(state, c1, c2, c3, c4);
+      return IOFERR;
+    }
+    base64_decode_word(O, d1, d2, d3, d4);
+  }
+  return IOFFULL;
+}
+
+/* base85 */
+
+const char base85_alphabet[] = "!\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstu"; /* for completness, not used below */
+
+const int base85_lookup[] = {
+  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+  -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,
+  15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,
+  31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,
+  47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,
+  63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,
+  79,80,81,82,83,84,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1
+};
+
+#define base85_encode_word(O, code) \
+  (*(O->pos+4) = '!' + code%85, code /= 85, *(O->pos+3) = '!' + code%85, code /= 85, \
+   *(O->pos+2) = '!' + code%85, code /= 85, *(O->pos+1) = '!' + code%85, code /= 85, \
+   *(O->pos)   = '!' + code, \
+   O->pos += 5)
+
+#define base85_encode_tail3(O, code) \
+  (*(O->pos+3) = '!' + code%85, code /= 85, *(O->pos+2) = '!' + code%85, code /= 85, \
+   *(O->pos+1) = '!' + code%85, code /= 85, *(O->pos)   = '!' + code, \
+   O->pos += 4)
+
+#define base85_encode_tail2(O, code) \
+  (*(O->pos+2) = '!' + code%85, code /= 85, *(O->pos+1) = '!' + code%85, code /= 85, \
+   *(O->pos)   = '!' + code, \
+   O->pos += 3)
+
+#define base85_encode_tail1(O, code) \
+  (*(O->pos+1) = '!' + code%85, code /= 85, *(O->pos)   = '!' + code, \
+   O->pos += 2)
+
+iof_status base85_encoded (const void *data, size_t size, iof *O)
+{
+  unsigned int code;
+  const uint8_t *s, *e;
+  uint8_t c1, c2, c3, c4;
+  for (s = (const uint8_t *)data, e = s + size; s + 3 < e; )
+  {
+    if (!iof_ensure(O, 5))
+      return IOFFULL;
+    c1 = *s++;
+    c2 = *s++;
+    c3 = *s++;
+    c4 = *s++;
+    code = (c1<<24)|(c2<<16)|(c3<<8)|c4;
+    if (code == 0)
+    {
+      iof_set(O, 'z');
+      continue;
+    }
+    base85_encode_word(O, code);
+  }
+  switch (e - s)
+  {
+    case 0:
+      break;
+    case 1:
+      if (!iof_ensure(O, 2))
+        return IOFFULL;
+      c1 = *s;
+      code = (c1<<24)/85/85/85;
+      base85_encode_tail1(O, code);
+      break;
+    case 2:
+      if (!iof_ensure(O, 3))
+        return IOFFULL;
+      c1 = *s++;
+      c2 = *s;
+      code = ((c1<<24)|(c2<<16))/85/85;
+      base85_encode_tail2(O, code);
+      break;
+    case 3:
+      if (!iof_ensure(O, 4))
+        return IOFFULL;
+      c1 = *s++;
+      c2 = *s++;
+      c3 = *s;
+      code = ((c1<<24)|(c2<<16)|(c3<<8))/85;
+      base85_encode_tail3(O, code);
+      break;
+  }
+  return IOFEOF;
+}
+
+iof_status base85_encoded_ln (const void *data, size_t size, iof *O, size_t line, size_t maxline)
+{
+  unsigned int code;
+  const uint8_t *s, *e;
+  uint8_t c1, c2, c3, c4;
+  for (s = (const uint8_t *)data, e = s + size; s + 3 < e; )
+  {
+    if (!iof_ensure(O, 6))
+      return IOFFULL;
+    c1 = *s++;
+    c2 = *s++;
+    c3 = *s++;
+    c4 = *s++;
+    code = (c1<<24)|(c2<<16)|(c3<<8)|c4;
+    if (code == 0)
+    {
+      put_nl(O, line, maxline, 1);
+      iof_set(O, 'z');
+      continue;
+    }
+    put_nl(O, line, maxline, 5);
+    base85_encode_word(O, code);
+  }
+  switch (e - s)
+  {
+    case 0:
+      break;
+    case 1:
+      if (!iof_ensure(O, 3))
+        return IOFFULL;
+      c1 = *s;
+      code = (c1<<24)/85/85/85;
+      put_nl(O, line, maxline, 2);
+      base85_encode_tail1(O, code);
+      break;
+    case 2:
+      if (!iof_ensure(O, 4))
+        return IOFFULL;
+      c1 = *s++;
+      c2 = *s;
+      code = ((c1<<24)|(c2<<16))/85/85;
+      put_nl(O, line, maxline, 3);
+      base85_encode_tail2(O, code);
+      break;
+    case 3:
+      if (!iof_ensure(O, 5))
+        return IOFFULL;
+      c1 = *s++;
+      c2 = *s++;
+      c3 = *s;
+      code = ((c1<<24)|(c2<<16)|(c3<<8))/85;
+      put_nl(O, line, maxline, 4);
+      base85_encode_tail3(O, code);
+      break;
+  }
+  return IOFEOF;
+}
+
+iof_status base85_encode (iof *I, iof *O)
+{
+  register int c1, c2, c3, c4;
+  register unsigned int code;
+  while(iof_ensure(O, 5))
+  {
+    if ((c1 = iof_get(I)) < 0)
+      return IOFEOF;
+    if ((c2 = iof_get(I)) < 0)
+    {
+      code = (c1<<24)/85/85/85;
+      base85_encode_tail1(O, code);
+      return IOFEOF;
+    }
+    if ((c3 = iof_get(I)) < 0)
+    {
+      code = ((c1<<24)|(c2<<16))/85/85;
+      base85_encode_tail2(O, code);
+      return IOFEOF;
+    }
+    if ((c4 = iof_get(I)) < 0)
+    {
+      code = ((c1<<24)|(c2<<16)|(c3<<8))/85;
+      base85_encode_tail3(O, code);
+      return IOFEOF;
+    }
+    code = (c1<<24)|(c2<<16)|(c3<<8)|c4;
+    if (code == 0)
+    {
+      iof_set(O, 'z');
+      continue;
+    }
+    /* in btoa 'y' character stays for 0x20202020, but pdf does not support this */
+    /* if (code == 0x20202020)
+    {
+      iof_set(O, 'y');
+      continue;
+    } */
+    base85_encode_word(O, code);
+  }
+  return IOFFULL;
+}
+
+iof_status base85_encode_state (iof *I, iof *O, basexx_state *state)
+{
+  register int c1, c2, c3, c4;
+  register unsigned int code;
+  if (!(iof_ensure(O, 5)))
+    return IOFFULL;
+  switch(state->left)
+  {
+    case 0: goto byte0;
+    case 1: get_tail1(state, c1); goto byte1;
+    case 2: get_tail2(state, c1, c2); goto byte2;
+    case 3: get_tail3(state, c1, c2, c3); goto byte3;
+  }
+  while(iof_ensure(O, 5))
+  {
+    byte0:
+    if ((c1 = iof_get(I)) < 0)
+      return (state->flush ? IOFEOF : IOFEMPTY);
+    byte1:
+    if ((c2 = iof_get(I)) < 0)
+    {
+      set_tail1(state, c1);
+      if (state->flush)
+      {
+        code = (c1<<24)/85/85/85;
+        base85_encode_tail1(O, code);
+        return IOFEOF;
+      }
+      return IOFEMPTY;
+    }
+    byte2:
+    if ((c3 = iof_get(I)) < 0)
+    {
+      set_tail2(state, c1, c2);
+      if (state->flush)
+      {
+        code = ((c1<<24)|(c2<<16))/85/85;
+        base85_encode_tail2(O, code);
+        return IOFEOF;
+      }
+      return IOFEMPTY;
+    }
+    byte3:
+    if ((c4 = iof_get(I)) < 0)
+    {
+      set_tail3(state, c1, c2, c3);
+      if (state->flush)
+      {
+        code = ((c1<<24)|(c2<<16)|(c3<<8))/85;
+        base85_encode_tail3(O, code);
+        return IOFEOF;
+      }
+      return IOFEMPTY;
+    }
+    code = (c1<<24)|(c2<<16)|(c3<<8)|c4;
+    if (code == 0)
+    {
+      iof_set(O, 'z');
+      continue;
+    }
+    base85_encode_word(O, code);
+  }
+  return IOFFULL;
+}
+
+iof_status base85_encode_ln (iof *I, iof *O, size_t line, size_t maxline)
+{
+  register int c1, c2, c3, c4;
+  register unsigned int code;
+  while(iof_ensure(O, 6))
+  {
+    if ((c1 = iof_get(I)) < 0)
+      return IOFEOF;
+    if ((c2 = iof_get(I)) < 0)
+    {
+      code = (c1<<24)/85/85/85;
+      put_nl(O, line, maxline, 2);
+      base85_encode_tail1(O, code);
+      return IOFEOF;
+    }
+    if ((c3 = iof_get(I)) < 0)
+    {
+      code = ((c1<<24)|(c2<<16))/85/85;
+      put_nl(O, line, maxline, 3);
+      base85_encode_tail2(O, code);
+      return IOFEOF;
+    }
+    if ((c4 = iof_get(I)) < 0)
+    {
+      code = ((c1<<24)|(c2<<16)|(c3<<8))/85;
+      put_nl(O, line, maxline, 4);
+      base85_encode_tail3(O, code);
+      return IOFEOF;
+    }
+    code = (c1<<24)|(c2<<16)|(c3<<8)|c4;
+    if (code == 0)
+    {
+      put_nl(O, line, maxline, 1);
+      iof_set(O, 'z');
+      continue;
+    }
+    put_nl(O, line, maxline, 5);
+    base85_encode_word(O, code);
+  }
+  return IOFFULL;
+}
+
+iof_status base85_encode_state_ln (iof *I, iof *O, basexx_state *state)
+{
+  register int c1, c2, c3, c4;
+  register unsigned int code;
+  if (!(iof_ensure(O, 6)))
+    return IOFFULL;
+  switch(state->left)
+  {
+    case 0: goto byte0;
+    case 1: get_tail1(state, c1); goto byte1;
+    case 2: get_tail2(state, c1, c2); goto byte2;
+    case 3: get_tail3(state, c1, c2, c3); goto byte3;
+  }
+  while(iof_ensure(O, 6))
+  {
+    byte0:
+    if ((c1 = iof_get(I)) < 0)
+      return (state->flush ? IOFEOF : IOFEMPTY);
+    byte1:
+    if ((c2 = iof_get(I)) < 0)
+    {
+      set_tail1(state, c1);
+      if (state->flush)
+      {
+        code = (c1<<24)/85/85/85;
+        put_nl(O, state->line, state->maxline, 2);
+        base85_encode_tail1(O, code);
+        return IOFEOF;
+      }
+      return IOFEMPTY;
+    }
+    byte2:
+    if ((c3 = iof_get(I)) < 0)
+    {
+      set_tail2(state, c1, c2);
+      if (state->flush)
+      {
+        code = ((c1<<24)|(c2<<16))/85/85;
+        put_nl(O, state->line, state->maxline, 3);
+        base85_encode_tail2(O, code);
+        return IOFEOF;
+      }
+      return IOFEMPTY;
+    }
+    byte3:
+    if ((c4 = iof_get(I)) < 0)
+    {
+      set_tail3(state, c1, c2, c3);
+      if (state->flush)
+      {
+        code = ((c1<<24)|(c2<<16)|(c3<<8))/85;
+        put_nl(O, state->line, state->maxline, 4);
+        base85_encode_tail3(O, code);
+        return IOFEOF;
+      }
+      return IOFEMPTY;
+    }
+    code = (c1<<24)|(c2<<16)|(c3<<8)|c4;
+    if (code == 0)
+    {
+      put_nl(O, state->line, state->maxline, 1);
+      iof_set(O, 'z');
+      continue;
+    }
+    put_nl(O, state->line, state->maxline, 5);
+    base85_encode_word(O, code);
+  }
+  return IOFFULL;
+}
+
+#define base85_code(c1, c2, c3, c4, c5) ((((c1*85+c2)*85+c3)*85+c4)*85+c5)
+
+iof_status base85_decode (iof *I, iof *O)
+{
+  register int c1, c2, c3, c4, c5;
+  register unsigned int code;
+  while (iof_ensure(O, 4))
+  {
+    do { c1 = iof_get(I); } while (ignored(c1));
+    if (base85_eof(c1))
+      return IOFEOF;
+    switch (c1)
+    {
+      case 'z':
+        iof_set4(O, '\0', '\0', '\0', '\0');
+        continue;
+      case 'y':
+        iof_set4(O, ' ', ' ', ' ', ' ');
+        continue;
+    }
+    do { c2 = iof_get(I); } while (ignored(c2));
+    if (base85_eof(c2))
+      return IOFERR;
+    do { c3 = iof_get(I); } while (ignored(c3));
+    if (base85_eof(c3))
+    {
+      if ((c1 = base85_lookup[c1]) == -1 || (c2 = base85_lookup[c2]) == -1)
+        return IOFERR;
+      code = base85_code(c1, c2, 84, 84, 84); /* padding with 'u' (117); 117-33 = 84 */
+      iof_set(O, code>>24);
+      return IOFEOF;
+    }
+    do { c4 = iof_get(I); } while (ignored(c4));
+    if (base85_eof(c4))
+    {
+      if ((c1 = base85_lookup[c1]) == -1 || (c2 = base85_lookup[c2]) == -1 || (c3 = base85_lookup[c3]) == -1)
+        return IOFERR;
+      code = base85_code(c1, c2, c3, 84, 84);
+      iof_set2(O, code>>24, (code>>16)&255);
+      return IOFEOF;
+    }
+    do { c5 = iof_get(I); } while (ignored(c5));
+    if (base85_eof(c5))
+    {
+      if ((c1 = base85_lookup[c1]) == -1 || (c2 = base85_lookup[c2]) == -1 ||
+          (c3 = base85_lookup[c3]) == -1 || (c4 = base85_lookup[c4]) == -1)
+        return IOFERR;
+      code = base85_code(c1, c2, c3, c4, 84);
+      iof_set3(O, code>>24, (code>>16)&255, (code>>8)&255);
+      return IOFEOF;
+    }
+    if ((c1 = base85_lookup[c1]) == -1 || (c2 = base85_lookup[c2]) == -1 || (c3 = base85_lookup[c3]) == -1 ||
+        (c4 = base85_lookup[c4]) == -1 || (c5 = base85_lookup[c5]) == -1)
+      return IOFERR;
+    code = base85_code(c1, c2, c3, c4, c5);
+    iof_set4(O, code>>24, (code>>16)&255, (code>>8)&255, code&255);
+  }
+  return IOFFULL;
+}
+
+iof_status base85_decode_state (iof *I, iof *O, basexx_state *state)
+{
+  register int c1, c2, c3, c4, c5;
+  register int d1, d2, d3, d4, d5;
+  register unsigned int code;
+  if (!(iof_ensure(O, 4)))
+    return IOFFULL;
+  switch(state->left)
+  {
+    case 0: goto byte0;
+    case 1: get_tail1(state, c1); goto byte1;
+    case 2: get_tail2(state, c1, c2); goto byte2;
+    case 3: get_tail3(state, c1, c2, c3); goto byte3;
+    case 4: get_tail4(state, c1, c2, c3, c4); goto byte4;
+  }
+  while (iof_ensure(O, 4))
+  {
+    byte0:
+    do { c1 = iof_get(I); } while (ignored(c1));
+    if (base85_eof(c1))
+      return (state->flush ? IOFEOF : IOFEMPTY);
+    switch (c1)
+    {
+      case 'z':
+        iof_set4(O, '\0', '\0', '\0', '\0');
+        continue;
+      case 'y':
+        iof_set4(O, ' ', ' ', ' ', ' ');
+        continue;
+    }
+    byte1:
+    do { c2 = iof_get(I); } while (ignored(c2));
+    if (base85_eof(c2))
+    {
+      set_tail1(state, c1);
+      return (state->flush ? IOFERR : IOFEMPTY); /* if state->flush then error; tail must have at least two bytes */
+    }
+    byte2:
+    do { c3 = iof_get(I); } while (ignored(c3));
+    if (base85_eof(c3))
+    {
+      set_tail2(state, c1, c2);
+      if (state->flush)
+      {
+        if ((c1 = base85_lookup[c1]) == -1 || (c2 = base85_lookup[c2]) == -1)
+          return IOFERR;
+        code = base85_code(c1, c2, 84, 84, 84);
+        iof_set(O, code>>24);
+        return IOFEOF;
+      }
+      return IOFEMPTY;
+    }
+    byte3:
+    do { c4 = iof_get(I); } while (ignored(c4));
+    if (base85_eof(c4))
+    {
+      set_tail3(state, c1, c2, c3);
+      if (state->flush)
+      {
+        if ((c1 = base85_lookup[c1]) == -1 || (c2 = base85_lookup[c2]) == -1 || (c3 = base85_lookup[c3]) == -1)
+          return IOFERR;
+        code = base85_code(c1, c2, c3, 84, 84);
+        iof_set2(O, code>>24, (code>>16)&255);
+        return IOFEOF;
+      }
+      return IOFEMPTY;
+    }
+    byte4:
+    do { c5 = iof_get(I); } while (ignored(c5));
+    if (base85_eof(c5))
+    {
+      set_tail4(state, c1, c2, c3, c4);
+      if (state->flush)
+      {
+        if ((c1 = base85_lookup[c1]) == -1 || (c2 = base85_lookup[c2]) == -1 ||
+            (c3 = base85_lookup[c3]) == -1 || (c4 = base85_lookup[c4]) == -1)
+          return IOFERR;
+        code = base85_code(c1, c2, c3, c4, 84);
+        iof_set3(O, code>>24, (code>>16)&255, (code>>8)&255);
+        return IOFEOF;
+      }
+      return IOFEMPTY;
+    }
+    if ((d1 = base85_lookup[c1]) == -1 || (d2 = base85_lookup[c2]) == -1 || (d3 = base85_lookup[c3]) == -1 ||
+        (d4 = base85_lookup[c4]) == -1 || (d5 = base85_lookup[c5]) == -1)
+    {
+      set_tail5(state, c1, c2, c3, c4, c5);
+      return IOFERR;
+    }
+    code = base85_code(d1, d2, d3, d4, d5);
+    iof_set4(O, code>>24, (code>>16)&255, (code>>8)&255, code&255);
+  }
+  return IOFFULL;
+}
+
+/* postscript run length */
+
+void runlength_state_init (runlength_state *state)
+{
+  state->run = -1;
+  state->flush = 0;
+  state->c1 = 0;
+  state->c2 = 0;
+  state->pos = NULL;
+}
+
+iof_status runlength_encode (iof *I, iof *O)
+{
+  register int c1, c2, run = -1;
+  uint8_t *pos;
+  c1 = 0; /* avoid warning */
+  while (iof_ensure(O, 1+128+1))
+  { /* ensured space for single length byte, up to 128 bytes to be copied, possible eod marker */
+    pos = O->pos++;
+    switch (run)
+    {
+      case -1: /* initial state; get first byte */
+        if ((c1 = iof_get(I)) < 0)
+          return (*pos = 128, IOFEOF);
+        run = 0;
+        // fall through
+      case 0: /* `repeat' state; get another byte and compare */
+        if ((c2 = iof_get(I)) < 0)
+          return (*pos = 0, iof_set2(O, c1, 128), IOFEOF);
+        run = (c1 == c2 ? 257-2 : 0);
+        break;
+    }
+    if (run < 128)
+    { /* single length byte, up to 128 bytes to be copied, possible eod marker */
+      iof_set(O, c1);
+      for (c1 = c2, c2 = iof_char(I); c1 != c2 && run < 127; c1 = c2, c2 = iof_next(I))
+      {
+        if (c2 < 0) /* O->pos must not change until next call to calling encoder!!! */
+          return (*pos = (uint8_t)run+1, iof_set2(O, c1, 128), IOFEOF);
+        iof_set(O, c1);
+        ++run;
+      }
+    }
+    else // if run > 128
+    {
+      for (c2 = iof_get(I); c1 == c2 && run > 129; c2 = iof_get(I))
+        --run;
+      if (c2 < 0)
+        return (*pos = (uint8_t)run, iof_set2(O, c1, 128), IOFEOF);
+      iof_set(O, c1);
+    }
+    *pos = (uint8_t)run;
+    c1 = c2;
+    run = 0;
+  }
+  return IOFFULL;
+}
+
+iof_status runlength_encode_state (iof *I, iof *O, runlength_state *state)
+{
+  while (iof_ensure(O, 3)) /* single length byte, the byte to be repeated and eod */
+  {
+    state->pos = O->pos++;
+    switch (state->run)
+    {
+      case -1: /* initial state; get first byte */
+        if ((state->c1 = iof_get(I)) < 0)
+          return (state->flush ? (*state->pos = 128, IOFEOF) : IOFEMPTY);
+        state->run = 0;
+        // fall through
+      case 0: /* `repeat' state; get another byte and compare */
+        if ((state->c2 = iof_get(I)) < 0)
+          return (state->flush ? (*state->pos = 0, iof_set2(O, state->c1, 128), IOFEOF) : IOFEMPTY);
+        state->run = (state->c1 == state->c2 ? 257-2 : 0);
+        break;
+    }
+    if (state->run < 128)
+    { /* ensure space for single length byte, up to 128 bytes to be copied, plus possible eod marker, minus those already copied */
+      if (!iof_ensure(O, 1+128+1-state->run))
+        return IOFFULL;
+      iof_set(O, state->c1);
+      for (state->c1 = state->c2, state->c2 = iof_char(I);
+           state->c1 != state->c2 && state->run < 127;
+           state->c1 = state->c2, state->c2 = iof_next(I))
+      {
+        if (state->c2 < 0) /* O->pos must not change until next call to calling encoder!!! */
+          return (state->flush ? (*state->pos = (uint8_t)state->run+1, iof_set2(O, state->c1, 128), IOFEOF) : IOFEMPTY);
+        iof_set(O, state->c1);
+        ++state->run;
+      }
+    }
+    else // if run > 128
+    {
+      for (state->c2 = iof_get(I); state->c1 == state->c2 && state->run > 129; state->c2 = iof_get(I))
+        --state->run;
+      if (state->c2 < 0)
+        return (state->flush ? (*state->pos = (uint8_t)state->run, iof_set2(O, state->c1, 128), IOFEOF) : IOFEMPTY);
+      iof_set(O, state->c1);
+    }
+    *state->pos = (uint8_t)state->run;
+    state->c1 = state->c2;
+    state->run = 0;
+  }
+  return IOFFULL;
+}
+
+iof_status runlength_decode (iof *I, iof *O)
+{
+  register int c, run = -1;
+  while (1)
+  {
+    if (run == -1) /* initial state */
+    {
+      if ((run = iof_get(I)) < 0)
+      {
+        run = -1; /* don't assume IOFEOF == -1 */
+        return IOFEOF;
+      }
+    }
+    if (run < 128)
+    { /* copy (run + 1) following bytes */
+      while (run > -1)
+      {
+        if (iof_ensure(O, 1))
+        {
+          if ((c = iof_get(I)) < 0)
+            return IOFERR;
+          iof_set(O, c);
+          --run;
+          continue;
+        }
+        return IOFFULL;
+      }
+    }
+    else if (run > 128)
+    { /* replicate the following byte (257 - run) times */
+      if ((c = iof_get(I)) < 0) /* cf. state-wise version; don't change input position until we got this byte */
+        return IOFERR;
+      while (run < 257)
+      {
+        if (iof_ensure(O, 1))
+        {
+          iof_set(O, c);
+          ++run;
+          continue;
+        }
+        return IOFFULL;
+      }
+      run = -1;
+    }
+    else // c == 128
+      return IOFEOF;
+  }
+  // return IOFFULL;
+}
+
+iof_status runlength_decode_state (iof *I, iof *O, runlength_state *state)
+{
+  register int c;
+  while (1)
+  {
+    if (state->run == -1) /* initial state */
+    {
+      if ((state->run = iof_char(I)) < 0)
+      {
+        state->run = -1; /* don't assume IOFEOF == -1 */
+        return (state->flush ? IOFEOF : IOFEMPTY);
+      }
+      ++I->pos;
+    }
+    if (state->run < 128)
+    { /* copy (state->run + 1) following bytes */
+      while (state->run > -1)
+      {
+        if (iof_ensure(O, 1))
+        {
+          if ((c = iof_char(I)) < 0)
+            return (state->flush ? IOFERR : IOFEMPTY);
+          ++I->pos;
+          iof_set(O, c);
+          --state->run;
+          continue;
+        }
+        return IOFFULL;
+      }
+    }
+    else if (state->run > 128)
+    { /* replicate the following byte (257 - state->run) times */
+      if ((c = iof_char(I)) < 0)
+        return (state->flush ? IOFERR : IOFEMPTY);
+      ++I->pos;
+      while (state->run < 257)
+      {
+        if (iof_ensure(O, 1))
+        {
+          iof_set(O, c);
+          ++state->run;
+          continue;
+        }
+        return IOFFULL;
+      }
+      state->run = -1;
+    }
+    else // c == 128
+      return IOFEOF;
+  }
+  // return IOFFULL;
+}
+
+/* eexec stream filter, type1 fonts spec page 63 */
+
+void eexec_state_init_ln (eexec_state *state, size_t line, size_t maxline, const char *initbytes)
+{
+  state->key = -1;
+  state->flush = 0;
+  state->binary = maxline > 0;
+  state->c1 = -1;
+  state->line = line;
+  state->maxline = maxline;
+  state->initbytes = initbytes;
+}
+
+#define eexec_getc(I, c1) if ((c1 = iof_get(I)) < 0) return c1
+#define eexec_key(key, c1) (key = ((((c1) + key)*52845 + 22719) & 65535))
+#define eexec_decipher(key, c1, c) (c = ((c1)^(key>>8)), eexec_key(key, c1))
+#define eexec_encipher(key, c1, c) (c = ((c1)^(key>>8)), eexec_key(key, c))
+
+#ifndef lps_ignored_char
+#  define lps_ignored_char(c) (c == 0x20 || c == 0x0A || c == 0x0C || c == 0x0D || c == 0x09 || c == 0x00)
+#endif
+
+#define eexec_getx_(I, c) \
+  do { c = iof_get(I); } while (lps_ignored_char(c)); \
+  if (c < 0) return IOFEOF; \
+  if ((c = base16_lookup[c]) < 0) return IOFERR
+
+#define eexec_getx(I, c1, c2) eexec_getx_(I, c1); \
+  do { c2 = iof_get(I); } while (lps_ignored_char(c2)); \
+  if (c2 < 0) c2 = 0; else \
+  if ((c2 = base16_lookup[c2]) < 0) return IOFERR
+
+static int eexec_decode_init (iof *I, int *key, int *binary)
+{
+  int c1, c2, c3, c4;
+  *key = 55665;
+  eexec_getc(I, c1);
+  eexec_getc(I, c2);
+  eexec_getc(I, c3);
+  eexec_getc(I, c4); /* four head bytes */
+
+  /* eexec data has no explicit data termination. The caller of eexec_decode() should ensure that either
+  the input iof allows to read no more then necessary, or the output has no more space then 512 bytes,
+  to land safely somewhere in 512 bytes that probably follows eexec */
+
+  *binary = (base16_lookup[c1] < 0 || base16_lookup[c2] < 0 ||
+             base16_lookup[c3] < 0 || base16_lookup[c4] < 0);
+  if (*binary)
+  { /* gobble 4 random bytes keeping decipher key up-to-date */
+    eexec_key(*key, c1); eexec_key(*key, c2);
+    eexec_key(*key, c3); eexec_key(*key, c4);
+  }
+  else /* pfa/postscript only, pdf requires binary eexec form */
+  { /* gobble 4 random bytes (8 hex digits) keeping decipher key up-to-date */
+    c1 = base16_lookup[c1], c2 = base16_lookup[c2], c3 = base16_lookup[c3], c4 = base16_lookup[c4];
+    eexec_key(*key, (c1<<4)|c2); eexec_key(*key, (c3<<4)|c4); /* dummy bytes 1, 2 */
+    eexec_getx(I, c1, c2); eexec_getx(I, c3, c4);
+    eexec_key(*key, (c1<<4)|c2); eexec_key(*key, (c3<<4)|c4); /* dummy bytes 3, 4 */
+  }
+  return 0;
+}
+
+iof_status eexec_decode (iof *I, iof *O)
+{
+  int c, c1, c2, key, binary, status;
+  if ((status = eexec_decode_init(I, &key, &binary)) < 0)
+    return status;
+  if (binary)
+  {
+    while (iof_ensure(O, 1))
+    {
+      eexec_getc(I, c1);
+      eexec_decipher(key, c1, c);
+      iof_set(O, c);
+    }
+  }
+  else
+  {
+    while (iof_ensure(O, 1))
+    {
+      eexec_getx(I, c1, c2);
+      eexec_decipher(key, (c1<<4)|c2, c);
+      iof_set(O, c);
+    }
+  }
+  return IOFFULL;
+}
+
+iof_status eexec_decode_state (iof *I, iof *O, eexec_state *state)
+{
+  register int c, c1, c2, status;
+  if (state->key == -1) /* initial state */
+    if ((status = eexec_decode_init(I, &state->key, &state->binary)) < 0)
+      return status;
+  if (state->binary)
+  {
+    while (iof_ensure(O, 1))
+    {
+      if ((c1 = iof_get(I)) < 0)
+        return (state->flush ? IOFEOF : IOFEMPTY);
+      else if (c1 < 0)
+        return c1;
+      eexec_decipher(state->key, c1, c);
+      iof_set(O, c);
+    }
+  }
+  else
+  {
+    if (state->c1 > -1)
+    {
+      c1 = state->c1;
+      state->c1 = -1;
+      goto byte2;
+    }
+    while (iof_ensure(O, 1))
+    {
+      eexec_getx_(I, c1);
+      byte2:
+      do { c2 = iof_get(I); } while (lps_ignored_char(c2));
+      if (c2 < 0) // odd number of hex bytes? hmm... assume c2 is zero
+      {
+        if (state->flush)
+        {
+          eexec_decipher(state->key, (c1<<4), c);
+          iof_set(O, c);
+          return IOFEOF;
+        }
+        state->c1 = c1;
+        return IOFEMPTY;
+      }
+      else if (c2 < 0)
+        return c2;
+      if ((c2 = base16_lookup[c2]) < 0)
+        return IOFERR;
+      eexec_decipher(state->key, (c1<<4)|c2, c);
+      iof_set(O, c);
+    }
+  }
+  return IOFFULL;
+}
+
+#define EEXEC_INIT_BYTES ""
+
+iof_status eexec_encode (iof *I, iof *O, size_t line, size_t maxline)
+{
+  int c1, c, key;
+  const char *p;
+
+  key = 55665;
+  p = EEXEC_INIT_BYTES;
+  if (maxline == 0)
+  {
+    if (!iof_ensure(O, 4))
+      return IOFFULL;
+    eexec_encipher(key, p[0], c); iof_set(O, c);
+    eexec_encipher(key, p[1], c); iof_set(O, c);
+    eexec_encipher(key, p[2], c); iof_set(O, c);
+    eexec_encipher(key, p[3], c); iof_set(O, c);
+    while (iof_ensure(O, 1))
+    {
+      eexec_getc(I, c1);
+      eexec_encipher(key, c1, c);
+      iof_set(O, c);
+    }
+  }
+  else
+  {
+    if (!iof_ensure(O, 8 + 1))
+      return IOFFULL;
+    eexec_encipher(key, p[0], c); put_nl(O, line, maxline, 2); iof_set_uc_hex(O, c);
+    eexec_encipher(key, p[1], c); put_nl(O, line, maxline, 2); iof_set_uc_hex(O, c);
+    eexec_encipher(key, p[2], c); put_nl(O, line, maxline, 2); iof_set_uc_hex(O, c);
+    eexec_encipher(key, p[3], c); put_nl(O, line, maxline, 2); iof_set_uc_hex(O, c);
+    while (iof_ensure(O, 2 + 1))
+    {
+      eexec_getc(I, c1);
+      eexec_encipher(key, c1, c);
+      put_nl(O, line, maxline, 2);
+      iof_set_uc_hex(O, c);
+    }
+  }
+  return IOFFULL;
+}
+
+iof_status eexec_encode_state (iof *I, iof *O, eexec_state *state)
+{
+  int c, c1;
+  const char *p;
+
+  if (state->key == -1)
+  {
+    p = state->initbytes != NULL ? state->initbytes : EEXEC_INIT_BYTES;
+    if (state->binary)
+    {
+      if (!iof_ensure(O, 4))
+        return IOFFULL;
+      state->key = 55665;
+      eexec_encipher(state->key, p[0], c); iof_set(O, c);
+      eexec_encipher(state->key, p[1], c); iof_set(O, c);
+      eexec_encipher(state->key, p[2], c); iof_set(O, c);
+      eexec_encipher(state->key, p[3], c); iof_set(O, c);
+    }
+    else
+    {
+      if (!iof_ensure(O, 8 + 1))
+        return IOFFULL;
+      state->key = 55665;
+      eexec_encipher(state->key, p[0], c); put_nl(O, state->line, state->maxline, 2); iof_set_uc_hex(O, c);
+      eexec_encipher(state->key, p[1], c); put_nl(O, state->line, state->maxline, 2); iof_set_uc_hex(O, c);
+      eexec_encipher(state->key, p[2], c); put_nl(O, state->line, state->maxline, 2); iof_set_uc_hex(O, c);
+      eexec_encipher(state->key, p[3], c); put_nl(O, state->line, state->maxline, 2); iof_set_uc_hex(O, c);
+    }
+  }
+  if (state->binary)
+  {
+    while (iof_ensure(O, 1))
+    {
+      if ((c1 = iof_get(I)) < 0)
+        return c1 < 0 ? (state->flush ? IOFEOF : IOFEMPTY) : c1;
+      eexec_encipher(state->key, c1, c);
+      iof_set(O, c);
+    }
+  }
+  else
+  {
+    while (iof_ensure(O, 2 + 1))
+    {
+      if ((c1 = iof_get(I)) < 0)
+        return c1 < 0 ? (state->flush ? IOFEOF : IOFEMPTY) : c1;
+      eexec_encipher(state->key, c1, c);
+      put_nl(O, state->line, state->maxline, 2);
+      iof_set_uc_hex(O, c);
+    }
+  }
+  return IOFFULL;
+}
+
+/*
+Type1 charstrings are encoded/decoded in the same way, except that:
+- initial key is 4330
+- initbytes might be other then 4; /lenIV key in Private dict
+Type1 spec page 63. In practise we don't need iof interface here,
+we always apply the codec in place.
+*/
+
+#define type1chstr_key(key, c1) (key = ((((c1) + key)*52845 + 22719) & 65535))
+#define type1chstr_decipher(key, c1, c) (c = ((c1)^(key>>8)), type1chstr_key(key, c1))
+#define type1chstr_encipher(key, c1, c) (c = ((c1)^(key>>8)), type1chstr_key(key, c))
+
+int type1_charstring_decode (void *data, size_t size, void *outdata, uint8_t leniv)
+{ /* data and outdata may be the same, output size is always size - leniv */
+  uint8_t *input = (uint8_t *)data, *output = (uint8_t *)outdata;
+  size_t i;
+  int c, c1, key;
+
+  if (size < 4)
+    return 0;
+  key = 4330;
+  for (i = 0; i < leniv; ++i)
+  {
+    c1 = input[i];
+    type1chstr_key(key, c1);
+  }
+  for ( ; i < size; ++i)
+  {
+    c1 = input[i];
+    type1chstr_decipher(key, c1, c);
+    output[i - leniv] = c;
+  }
+  return 1;
+}
+
+#define TYPE1_CHSTR_INIT_BYTES EEXEC_INIT_BYTES
+
+int type1_charstring_encode (void *data, size_t size, void *outdata, uint8_t leniv)
+{ /* outdata may be data - leniv, output size is always size + leniv */
+  uint8_t *input = (uint8_t *)data, *output = (uint8_t *)outdata;
+  size_t i, j;
+  int c, c1, key;
+
+  key = 4330;
+  for (i = 0, j = 0; i < leniv; ++i)
+  {
+    c1 = TYPE1_CHSTR_INIT_BYTES[j];
+    //type1chstr_key(key, c1);
+    type1chstr_encipher(key, c1, c);
+    if (++j == 4)
+      j = 0;
+    output[i] = c;
+  }
+  for (i = 0; i < size; ++i)
+  {
+    c1 = input[i];
+    type1chstr_encipher(key, c1, c);
+    output[i + leniv] = c;
+  }
+  return 1;
+}
+
+/* filters */
+
+// base16 decoder function
+
+static size_t base16_decoder (iof *F, iof_mode mode)
+{
+  basexx_state *state;
+  iof_status status;
+  size_t tail;
+
+  switch(mode)
+  {
+    case IOFLOAD:
+    case IOFREAD:
+      if (F->flags & IOF_STOPPED)
+        return 0;
+      tail = iof_tail(F);
+      F->pos = F->buf + tail;
+      F->end = F->buf + F->space;
+      state = iof_filter_state(basexx_state *, F);
+      do {
+        status = base16_decode_state(F->next, F, state);
+      } while (mode == IOFLOAD && status == IOFFULL && iof_resize_buffer(F));
+      return iof_decoder_retval(F, "base16", status);
+    case IOFCLOSE:
+      iof_free(F);
+      return 0;
+    default:
+      break;
+  }
+  return 0;
+}
+
+// base16 encoder function
+
+static size_t base16_encoder (iof *F, iof_mode mode)
+{
+  basexx_state *state;
+  iof_status status;
+
+  state = iof_filter_state(basexx_state *, F);
+  switch (mode)
+  {
+    case IOFFLUSH:
+      state->flush = 1;
+      // fall through
+    case IOFWRITE:
+      F->end = F->pos;
+      F->pos = F->buf;
+      status = base16_encode_state_ln(F, F->next, state);
+      return iof_encoder_retval(F, "base16", status);
+    case IOFCLOSE:
+      if (!state->flush)
+        base16_encoder(F, IOFFLUSH);
+      iof_free(F);
+      return 0;
+    default:
+      break;
+  }
+  return 0;
+}
+
+// base64 decoder function
+
+static size_t base64_decoder (iof *F, iof_mode mode)
+{
+  basexx_state *state;
+  iof_status status;
+  size_t tail;
+
+  switch(mode)
+  {
+    case IOFLOAD:
+    case IOFREAD:
+      if (F->flags & IOF_STOPPED)
+        return 0;
+      tail = iof_tail(F);
+      F->pos = F->buf + tail;
+      F->end = F->buf + F->space;
+      state = iof_filter_state(basexx_state *, F);
+      do {
+        status = base64_decode_state(F->next, F, state);
+      } while (mode == IOFLOAD && status == IOFFULL && iof_resize_buffer(F));
+      return iof_decoder_retval(F, "base64", status);
+    case IOFCLOSE:
+      iof_free(F);
+      return 0;
+    default:
+      break;
+  }
+  return 0;
+}
+
+// base64 encoder function
+
+static size_t base64_encoder (iof *F, iof_mode mode)
+{
+  basexx_state *state;
+  iof_status status;
+
+  state = iof_filter_state(basexx_state *, F);
+  switch (mode)
+  {
+    case IOFFLUSH:
+      state->flush = 1;
+      // fall through
+    case IOFWRITE:
+      F->end = F->pos;
+      F->pos = F->buf;
+      status = base64_encode_state_ln(F, F->next, state);
+      return iof_encoder_retval(F, "base64", status);
+    case IOFCLOSE:
+      if (!state->flush)
+        base64_encoder(F, IOFFLUSH);
+      iof_free(F);
+      return 0;
+    default:
+      break;
+  }
+  return 0;
+}
+
+// base85 decoder function
+
+static size_t base85_decoder (iof *F, iof_mode mode)
+{
+  basexx_state *state;
+  iof_status status;
+  size_t tail;
+
+  switch(mode)
+  {
+    case IOFLOAD:
+    case IOFREAD:
+      if (F->flags & IOF_STOPPED)
+        return 0;
+      tail = iof_tail(F);
+      F->pos = F->buf + tail;
+      F->end = F->buf + F->space;
+      state = iof_filter_state(basexx_state *, F);
+      do {
+        status = base85_decode_state(F->next, F, state);
+      } while (mode == IOFLOAD && status == IOFFULL && iof_resize_buffer(F));
+      return iof_decoder_retval(F, "base85", status);
+    case IOFCLOSE:
+      iof_free(F);
+      return 0;
+    default:
+      break;
+  }
+  return 0;
+}
+
+// base85 encoder function
+
+static size_t base85_encoder (iof *F, iof_mode mode)
+{
+  basexx_state *state;
+  iof_status status;
+
+  state = iof_filter_state(basexx_state *, F);
+  switch (mode)
+  {
+    case IOFFLUSH:
+      state->flush = 1;
+      // fall through
+    case IOFWRITE:
+      F->end = F->pos;
+      F->pos = F->buf;
+      status = base85_encode_state_ln(F, F->next, state);
+      return iof_encoder_retval(F, "base85", status);
+    case IOFCLOSE:
+      if (!state->flush)
+        base85_encoder(F, IOFFLUSH);
+      iof_free(F);
+      return 0;
+    default:
+      break;
+  }
+  return 0;
+}
+
+// runlength decoder function
+
+static size_t runlength_decoder (iof *F, iof_mode mode)
+{
+  runlength_state *state;
+  iof_status status;
+  size_t tail;
+
+  switch(mode)
+  {
+    case IOFLOAD:
+    case IOFREAD:
+      if (F->flags & IOF_STOPPED)
+        return 0;
+      tail = iof_tail(F);
+      F->pos = F->buf + tail;
+      F->end = F->buf + F->space;
+      state = iof_filter_state(runlength_state *, F);
+      do {
+        status = runlength_decode_state(F->next, F, state);
+      } while (mode == IOFLOAD && status == IOFFULL && iof_resize_buffer(F));
+      return iof_decoder_retval(F, "runlength", status);
+    case IOFCLOSE:
+      iof_free(F);
+      return 0;
+    default:
+      break;
+  }
+  return 0;
+}
+
+// runlength encoder function
+
+static size_t runlength_encoder (iof *F, iof_mode mode)
+{
+  runlength_state *state;
+  iof_status status;
+
+  state = iof_filter_state(runlength_state *, F);
+  switch (mode)
+  {
+    case IOFFLUSH:
+      state->flush = 1;
+      // fall through
+    case IOFWRITE:
+      F->end = F->pos;
+      F->pos = F->buf;
+      status = runlength_encode_state(F, F->next, state);
+      return iof_encoder_retval(F, "runlength", status);
+    case IOFCLOSE:
+      if (!state->flush)
+        runlength_encoder(F, IOFFLUSH);
+      iof_free(F);
+      return 0;
+    default:
+      break;
+  }
+  return 0;
+}
+
+// eexec decoder function
+
+static size_t eexec_decoder (iof *F, iof_mode mode)
+{
+  eexec_state *state;
+  iof_status status;
+  size_t tail;
+
+  switch(mode)
+  {
+    case IOFLOAD:
+    case IOFREAD:
+      if (F->flags & IOF_STOPPED)
+        return 0;
+      tail = iof_tail(F);
+      F->pos = F->buf + tail;
+      F->end = F->buf + F->space;
+      state = iof_filter_state(eexec_state *, F);
+      do {
+        status = eexec_decode_state(F->next, F, state);
+      } while (mode == IOFLOAD && status == IOFFULL && iof_resize_buffer(F));
+      return iof_decoder_retval(F, "eexec", status);
+    case IOFCLOSE:
+      iof_free(F);
+      return 0;
+    default:
+      break;
+  }
+  return 0;
+}
+
+// eexec encoder function
+
+static size_t eexec_encoder (iof *F, iof_mode mode)
+{
+  eexec_state *state;
+  iof_status status;
+
+  state = iof_filter_state(eexec_state *, F);
+  switch (mode)
+  {
+    case IOFFLUSH:
+      state->flush = 1;
+      // fall through
+    case IOFWRITE:
+      F->end = F->pos;
+      F->pos = F->buf;
+      status = eexec_encode_state(F, F->next, state);
+      return iof_encoder_retval(F, "eexec", status);
+    case IOFCLOSE:
+      if (!state->flush)
+        eexec_encoder(F, IOFFLUSH);
+      iof_free(F);
+      return 0;
+    default:
+      break;
+  }
+  return 0;
+}
+
+//
+
+int iof_filter_basexx_encoder_ln (iof *F, size_t line, size_t maxline)
+{
+  basexx_state *state;
+  if (maxline > 8 && line < maxline)
+  {
+    state = iof_filter_state(basexx_state *, F);
+    state->line = line;
+    state->maxline = maxline;
+    return 1;
+  }
+  return 0;
+}
+
+/* base 16 */
+
+iof * iof_filter_base16_decoder (iof *N)
+{
+  iof *I;
+  basexx_state *state;
+  I = iof_filter_reader(base16_decoder, sizeof(basexx_state), &state);
+  iof_setup_next(I, N);
+  basexx_state_init(state);
+  state->flush = 1; // means N is supposed to be continuous input
+  return I;
+}
+
+iof * iof_filter_base16_encoder (iof *N)
+{
+  iof *O;
+  basexx_state *state;
+  O = iof_filter_writer(base16_encoder, sizeof(basexx_state), &state);
+  iof_setup_next(O, N);
+  basexx_state_init(state);
+  return O;
+}
+
+/* base 64 */
+
+iof * iof_filter_base64_decoder (iof *N)
+{
+  iof *I;
+  basexx_state *state;
+  I = iof_filter_reader(base64_decoder, sizeof(basexx_state), &state);
+  iof_setup_next(I, N);
+  basexx_state_init(state);
+  state->flush = 1;
+  return I;
+}
+
+iof * iof_filter_base64_encoder (iof *N)
+{
+  iof *O;
+  basexx_state *state;
+  O = iof_filter_writer(base64_encoder, sizeof(basexx_state), &state);
+  iof_setup_next(O, N);
+  basexx_state_init(state);
+  return O;
+}
+
+/* base 85 */
+
+iof * iof_filter_base85_decoder (iof *N)
+{
+  iof *I;
+  basexx_state *state;
+  I = iof_filter_reader(base85_decoder, sizeof(basexx_state), &state);
+  iof_setup_next(I, N);
+  basexx_state_init(state);
+  state->flush = 1;
+  return I;
+}
+
+iof * iof_filter_base85_encoder (iof *N)
+{
+  iof *O;
+  basexx_state *state;
+  O = iof_filter_writer(base85_encoder, sizeof(basexx_state), &state);
+  iof_setup_next(O, N);
+  basexx_state_init(state);
+  return O;
+}
+
+/* runlength stream filter */
+
+iof * iof_filter_runlength_decoder (iof *N)
+{
+  iof *I;
+  runlength_state *state;
+  I = iof_filter_reader(runlength_decoder, sizeof(runlength_state), &state);
+  iof_setup_next(I, N);
+  runlength_state_init(state);
+  state->flush = 1;
+  return I;
+}
+
+iof * iof_filter_runlength_encoder (iof *N)
+{
+  iof *O;
+  runlength_state *state;
+  O = iof_filter_writer(runlength_encoder, sizeof(runlength_state), &state);
+  iof_setup_next(O, N);
+  runlength_state_init(state);
+  return O;
+}
+
+/* eexec stream filter, type1 fonts spec p. 63 */
+
+iof * iof_filter_eexec_decoder (iof *N)
+{
+  iof *I;
+  eexec_state *state;
+  I = iof_filter_reader(eexec_decoder, sizeof(eexec_state), &state);
+  iof_setup_next(I, N);
+  eexec_state_init(state);
+  state->flush = 1;
+  return I;
+}
+
+iof * iof_filter_eexec_encoder (iof *N)
+{
+  iof *O;
+  eexec_state *state;
+  O = iof_filter_writer(eexec_encoder, sizeof(eexec_state), &state);
+  iof_setup_next(O, N);
+  eexec_state_init(state);
+  return O;
+}
diff --git a/texk/web2c/luatexdir/luapplib/util/utilbasexx.h b/texk/web2c/luatexdir/luapplib/util/utilbasexx.h
new file mode 100644
index 000000000..52aac3772
--- /dev/null
+++ b/texk/web2c/luatexdir/luapplib/util/utilbasexx.h
@@ -0,0 +1,133 @@
+
+/* base encodings */
+
+#ifndef UTIL_BASEXX_H
+#define UTIL_BASEXX_H
+
+#include "utiliof.h"
+
+/* base codecs state */
+
+typedef struct basexx_state basexx_state;
+
+#define BASEXX_MAXLINE 80
+#define BASEXX_PDF
+
+void basexx_state_init_ln (basexx_state *state, size_t line, size_t maxline);
+#define basexx_state_init(state) basexx_state_init_ln(state, 0, BASEXX_MAXLINE)
+
+/* base16 */
+
+int base16_getc (iof *I);
+int base16_uc_putc (iof *I, int c);
+int base16_lc_putc (iof *I, int c);
+#define base16_putc base16_uc_putc
+
+iof_status base16_encoded_uc (const void *data, size_t size, iof *O);
+iof_status base16_encoded_lc (const void *data, size_t size, iof *O);
+iof_status base16_encoded_uc_ln (const void *data, size_t size, iof *O, size_t line, size_t maxline);
+iof_status base16_encoded_lc_ln (const void *data, size_t size, iof *O, size_t line, size_t maxline);
+
+iof_status base16_encode_uc (iof *I, iof *O);
+iof_status base16_encode_lc (iof *I, iof *O);
+iof_status base16_encode_uc_ln (iof *I, iof *O, size_t line, size_t maxline);
+iof_status base16_encode_lc_ln (iof *I, iof *O, size_t line, size_t maxline);
+iof_status base16_decode (iof *I, iof *O);
+
+#define base16_encoded base16_encoded_uc
+#define base16_encoded_ln base16_encoded_uc_ln
+#define base16_encode base16_encode_uc
+#define base16_encode_ln base16_encode_uc_ln
+
+iof_status base16_encode_state_uc (iof *I, iof *O, basexx_state *state);
+iof_status base16_encode_state_lc (iof *I, iof *O, basexx_state *state);
+iof_status base16_encode_state_uc_ln (iof *I, iof *O, basexx_state *state);
+iof_status base16_encode_state_lc_ln (iof *I, iof *O, basexx_state *state);
+iof_status base16_decode_state (iof *I, iof *O, basexx_state *state);
+
+#define base16_encode_state base16_encode_state_uc
+#define base16_encode_state_ln base16_encode_state_uc_ln
+
+/* base64 */
+
+extern const char base64_alphabet[];
+extern const int base64_lookup[];
+
+iof_status base64_encoded (const void *data, size_t size, iof *O);
+iof_status base64_encoded_ln (const void *data, size_t size, iof *O, size_t line, size_t maxline);
+
+iof_status base64_encode (iof *I, iof *O);
+iof_status base64_encode_ln (iof *I, iof *O, size_t line, size_t maxline);
+iof_status base64_decode (iof *I, iof *O);
+
+iof_status base64_encode_state (iof *I, iof *O, basexx_state *state);
+iof_status base64_encode_state_ln (iof *I, iof *O, basexx_state *state);
+iof_status base64_decode_state (iof *I, iof *O, basexx_state *state);
+
+/* base85 */
+
+extern const char base85_alphabet[];
+extern const int base85_lookup[];
+
+iof_status base85_encoded (const void *data, size_t size, iof *O);
+iof_status base85_encoded_ln (const void *data, size_t size, iof *O, size_t line, size_t maxline);
+
+iof_status base85_encode (iof *I, iof *O);
+iof_status base85_encode_ln (iof *I, iof *O, size_t line, size_t maxline);
+iof_status base85_decode (iof *I, iof *O);
+
+iof_status base85_encode_state (iof *I, iof *O, basexx_state *state);
+iof_status base85_encode_state_ln (iof *I, iof *O, basexx_state *state);
+iof_status base85_decode_state (iof *I, iof *O, basexx_state *state);
+
+/* run length */
+
+typedef struct runlength_state runlength_state;
+
+void runlength_state_init (runlength_state *state);
+
+iof_status runlength_encode (iof *I, iof *O);
+iof_status runlength_encode_state (iof *I, iof *O, runlength_state *state);
+
+iof_status runlength_decode (iof *I, iof *O);
+iof_status runlength_decode_state (iof *I, iof *O, runlength_state *state);
+
+/* eexec */
+
+typedef struct eexec_state eexec_state;
+
+#define EEXEC_MAXLINE 80
+
+void eexec_state_init_ln (eexec_state *state, size_t line, size_t maxline, const char *initbytes);
+#define eexec_state_init(state) eexec_state_init_ln(state, 0, EEXEC_MAXLINE, NULL)
+
+iof_status eexec_decode (iof *I, iof *O);
+iof_status eexec_decode_state (iof *I, iof *O, eexec_state *state);
+
+iof_status eexec_encode (iof *I, iof *O, size_t line, size_t maxline);
+iof_status eexec_encode_state (iof *I, iof *O, eexec_state *state);
+
+iof_status type1_charstring_decode (void *data, size_t size, void *outdata, uint8_t leniv);
+iof_status type1_charstring_encode (void *data, size_t size, void *outdata, uint8_t leniv);
+
+/* filters */
+
+int iof_filter_basexx_encoder_ln (iof *N, size_t line, size_t maxline);
+
+iof * iof_filter_base16_decoder (iof *N);
+iof * iof_filter_base16_encoder (iof *N);
+
+iof * iof_filter_base64_decoder (iof *N);
+iof * iof_filter_base64_encoder (iof *N);
+
+iof * iof_filter_base85_decoder (iof *N);
+iof * iof_filter_base85_encoder (iof *N);
+
+iof * iof_filter_runlength_decoder (iof *N);
+iof * iof_filter_runlength_encoder (iof *N);
+
+iof * iof_filter_eexec_decoder (iof *N);
+iof * iof_filter_eexec_encoder (iof *N);
+
+
+#endif
diff --git a/texk/web2c/luatexdir/luapplib/util/utilcrypt.c b/texk/web2c/luatexdir/luapplib/util/utilcrypt.c
new file mode 100644
index 000000000..1750d01bd
--- /dev/null
+++ b/texk/web2c/luatexdir/luapplib/util/utilcrypt.c
@@ -0,0 +1,1191 @@
+
+#include "utilmem.h"
+#include "utilcrypt.h"
+#include "utilcryptdef.h"
+#include "utilmd5.h"
+
+/* rc4 */
+
+/*
+Initializer arguments:
+- state - crypt state
+- map - a space for rc4 bytes map; may be left NULL in which case will be allocated
+- vkey - crypt key; may be left NULL iff map is provided and properly initialized
+- keylength - the length of crypt key (from 5 to 16 bytes)
+*/
+
+rc4_state * rc4_state_initialize (rc4_state *state, rc4_map *map, const void *vkey, size_t keylength)
+{
+  int i, j;
+  uint8_t tmp;
+  const uint8_t *key;
+  key = (const uint8_t *)vkey;
+  if (keylength == 0 || keylength > 256)
+    return NULL;
+  state->flags = 0;
+  if (map != NULL)
+  {
+    state->map = map;
+  }
+  else
+  {
+    state->map = (rc4_map *)util_malloc(sizeof(rc4_map));
+    state->flags |= RC4_STATE_ALLOC;
+  }
+
+  if (key != NULL)
+  {
+    for (i = 0; i < 256; ++i)
+      state->smap[i] = (uint8_t)i;
+    for (i = 0, j = 0; i < 256; ++i)
+    {
+      j = (j + state->smap[i] + key[i % keylength]) & 255;
+      tmp = state->smap[i];
+      state->smap[i] = state->smap[j];
+      state->smap[j] = tmp;
+    }
+  }
+  state->i = 0;
+  state->j = 0;
+  state->flush = 0; /* caller is responsible to override if necessary */
+  return state;
+}
+
+void rc4_map_save (rc4_state *state, rc4_map *map)
+{
+  memcpy(map, state->map, sizeof(rc4_map));
+}
+
+void rc4_map_restore (rc4_state *state, rc4_map *map)
+{
+  memcpy(state->map, map, sizeof(rc4_map));
+  //state->flags = 0;
+  //state->flush = 0;
+  state->i = 0;
+  state->j = 0;
+}
+
+static uint8_t rc4_next_random_byte (rc4_state *state)
+{
+  uint8_t tmp;
+  state->i = (state->i + 1) & 255;
+  state->j = (state->j + state->smap[state->i]) & 255;
+  tmp = state->smap[state->i];
+  state->smap[state->i] = state->smap[state->j];
+  state->smap[state->j] = tmp;
+  return state->smap[(state->smap[state->i] + state->smap[state->j]) & 255];
+}
+
+iof_status rc4_crypt_state (iof *I, iof *O, rc4_state *state)
+{
+  uint8_t r;
+  int c;
+  while (iof_ensure(O, 1))
+  {
+    if ((c = iof_get(I)) < 0)
+      return c == IOFERR ? IOFERR : (state->flush ? IOFEOF : IOFEMPTY);
+    r = rc4_next_random_byte(state);
+    //r = r ^ ((uint8_t)c);
+    //iof_set(O, r);
+    iof_set(O, r ^ ((uint8_t)c));
+  }
+  return IOFFULL;
+}
+
+iof_status rc4_crypt (iof *I, iof *O, const void *key, size_t keylength)
+{
+  int ret;
+  rc4_state state;
+  rc4_map map;
+  if (rc4_state_initialize(&state, &map, key, keylength) == NULL)
+    return IOFERR;
+  state.flush = 1;
+  ret = rc4_crypt_state(I, O, &state);
+  rc4_state_close(&state);
+  return ret;
+}
+
+/*
+Variants that operates on c-strings can worn inplace, so output and input can be the same address.
+Variant that takes rc4_state pointer expects the state properly initialized. Keep in mind
+the crypt procedure modifies rc4 bytes map. All returns the size of encrypted/decrypted
+data, which is the same as input data length for rc4.
+*/
+
+size_t rc4_crypt_data (const void *input, size_t length, void *output, const void *key, size_t keylength)
+{
+  rc4_state state;
+  rc4_map map;
+  if (rc4_state_initialize(&state, &map, key, keylength) == NULL)
+    return 0;
+  return rc4_crypt_state_data(&state, input, length, output);
+  // no need to call rc4_state_close()
+}
+
+size_t rc4_crypt_state_data (rc4_state *state, const void *input, size_t length, void *output)
+{ /* state assumed to be initialized and with the proper state of smap */
+  const uint8_t *inp;
+  uint8_t r, *out;
+  size_t size;
+  inp = (const uint8_t *)input;
+  out = (uint8_t *)output;
+  for (size = 0; size < length; ++size, ++inp, ++out)
+  {
+    r = rc4_next_random_byte(state);
+    *out = r ^ *inp;
+  }
+  return length;
+}
+
+void rc4_state_close (rc4_state *state)
+{
+  if (state->smap != NULL && (state->flags & RC4_STATE_ALLOC))
+  {
+    util_free(state->smap);
+    state->smap = NULL;
+  }
+}
+
+/* aes; parts of code excerpted from https://github.com/kokke/tiny-AES128-C */
+
+static const uint8_t sbox[256] =   {
+  0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76,
+  0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0, 0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0,
+  0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15,
+  0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a, 0x07, 0x12, 0x80, 0xe2, 0xeb, 0x27, 0xb2, 0x75,
+  0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0, 0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84,
+  0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b, 0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf,
+  0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85, 0x45, 0xf9, 0x02, 0x7f, 0x50, 0x3c, 0x9f, 0xa8,
+  0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5, 0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2,
+  0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17, 0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73,
+  0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88, 0x46, 0xee, 0xb8, 0x14, 0xde, 0x5e, 0x0b, 0xdb,
+  0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c, 0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79,
+  0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9, 0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08,
+  0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 0xe8, 0xdd, 0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a,
+  0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e, 0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e,
+  0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf,
+  0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16 };
+
+static const uint8_t rsbox[256] =
+{ 0x52, 0x09, 0x6a, 0xd5, 0x30, 0x36, 0xa5, 0x38, 0xbf, 0x40, 0xa3, 0x9e, 0x81, 0xf3, 0xd7, 0xfb,
+  0x7c, 0xe3, 0x39, 0x82, 0x9b, 0x2f, 0xff, 0x87, 0x34, 0x8e, 0x43, 0x44, 0xc4, 0xde, 0xe9, 0xcb,
+  0x54, 0x7b, 0x94, 0x32, 0xa6, 0xc2, 0x23, 0x3d, 0xee, 0x4c, 0x95, 0x0b, 0x42, 0xfa, 0xc3, 0x4e,
+  0x08, 0x2e, 0xa1, 0x66, 0x28, 0xd9, 0x24, 0xb2, 0x76, 0x5b, 0xa2, 0x49, 0x6d, 0x8b, 0xd1, 0x25,
+  0x72, 0xf8, 0xf6, 0x64, 0x86, 0x68, 0x98, 0x16, 0xd4, 0xa4, 0x5c, 0xcc, 0x5d, 0x65, 0xb6, 0x92,
+  0x6c, 0x70, 0x48, 0x50, 0xfd, 0xed, 0xb9, 0xda, 0x5e, 0x15, 0x46, 0x57, 0xa7, 0x8d, 0x9d, 0x84,
+  0x90, 0xd8, 0xab, 0x00, 0x8c, 0xbc, 0xd3, 0x0a, 0xf7, 0xe4, 0x58, 0x05, 0xb8, 0xb3, 0x45, 0x06,
+  0xd0, 0x2c, 0x1e, 0x8f, 0xca, 0x3f, 0x0f, 0x02, 0xc1, 0xaf, 0xbd, 0x03, 0x01, 0x13, 0x8a, 0x6b,
+  0x3a, 0x91, 0x11, 0x41, 0x4f, 0x67, 0xdc, 0xea, 0x97, 0xf2, 0xcf, 0xce, 0xf0, 0xb4, 0xe6, 0x73,
+  0x96, 0xac, 0x74, 0x22, 0xe7, 0xad, 0x35, 0x85, 0xe2, 0xf9, 0x37, 0xe8, 0x1c, 0x75, 0xdf, 0x6e,
+  0x47, 0xf1, 0x1a, 0x71, 0x1d, 0x29, 0xc5, 0x89, 0x6f, 0xb7, 0x62, 0x0e, 0xaa, 0x18, 0xbe, 0x1b,
+  0xfc, 0x56, 0x3e, 0x4b, 0xc6, 0xd2, 0x79, 0x20, 0x9a, 0xdb, 0xc0, 0xfe, 0x78, 0xcd, 0x5a, 0xf4,
+  0x1f, 0xdd, 0xa8, 0x33, 0x88, 0x07, 0xc7, 0x31, 0xb1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xec, 0x5f,
+  0x60, 0x51, 0x7f, 0xa9, 0x19, 0xb5, 0x4a, 0x0d, 0x2d, 0xe5, 0x7a, 0x9f, 0x93, 0xc9, 0x9c, 0xef,
+  0xa0, 0xe0, 0x3b, 0x4d, 0xae, 0x2a, 0xf5, 0xb0, 0xc8, 0xeb, 0xbb, 0x3c, 0x83, 0x53, 0x99, 0x61,
+  0x17, 0x2b, 0x04, 0x7e, 0xba, 0x77, 0xd6, 0x26, 0xe1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0c, 0x7d };
+
+/*
+The round constant word array, rcon[i], contains the values given by
+x to th e power (i-1) being powers of x (x is denoted as {02}) in the field GF(2^8)
+Note that i starts at 1, not 0).
+*/
+
+static const uint8_t rcon[255] = {
+  0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a,
+  0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef, 0xc5, 0x91, 0x39,
+  0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a,
+  0x74, 0xe8, 0xcb, 0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8,
+  0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef,
+  0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc,
+  0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb, 0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b,
+  0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3,
+  0x7d, 0xfa, 0xef, 0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94,
+  0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb, 0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20,
+  0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35,
+  0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef, 0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f,
+  0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb, 0x8d, 0x01, 0x02, 0x04,
+  0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63,
+  0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef, 0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd,
+  0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb  };
+
+/* block copying */
+
+#define aes_copy_block(output, input) memcpy(output, input, 16)
+
+static void aes_copy_cbc (uint8_t *data, const uint8_t *input)
+{
+  uint8_t i;
+  for (i = 0; i < 16; ++i)
+    data[i] ^= input[i];
+}
+
+static void aes_copy_xor (uint8_t *data, const uint8_t *input, const uint8_t *iv)
+{
+  uint8_t i;
+  for (i = 0; i < 16; ++i)
+    data[i] = input[i] ^ iv[i];
+}
+
+/* key expansion */
+
+#define AES_COLUMNS 4 // constant in aes
+
+static void key_expansion (aes_state *state, const uint8_t *key)
+{
+  uint32_t i, j, k;
+  uint8_t t[4];
+  uint8_t *keydata, keywords, columns;
+
+  keywords = (uint8_t)(state->keylength >> 2);
+  keydata = (uint8_t *)state->keyblock;
+
+  /* the first round key is the key itself */
+  for(i = 0; i < keywords; ++i)
+  {
+    keydata[(i * 4) + 0] = key[(i * 4) + 0];
+    keydata[(i * 4) + 1] = key[(i * 4) + 1];
+    keydata[(i * 4) + 2] = key[(i * 4) + 2];
+    keydata[(i * 4) + 3] = key[(i * 4) + 3];
+  }
+
+  /* others derived from the first */
+
+  for(columns = AES_COLUMNS * (state->rounds + 1); i < columns; ++i)
+  {
+    for(j = 0; j < 4; ++j)
+      t[j] = keydata[(i - 1) * 4 + j];
+    if (i % keywords == 0)
+    {
+      /* rotate the 4 bytes in a word to the left once; [a0,a1,a2,a3] becomes [a1,a2,a3,a0] */
+      k = t[0];
+      t[0] = t[1];
+      t[1] = t[2];
+      t[2] = t[3];
+      t[3] = k;
+
+      /* take a four-byte input word and apply the S-box to each of the four bytes to produce an output word */
+      t[0] = sbox[t[0]];
+      t[1] = sbox[t[1]];
+      t[2] = sbox[t[2]];
+      t[3] = sbox[t[3]];
+
+      t[0] =  t[0] ^ rcon[i / keywords];
+    }
+    else if (keywords > 6 && i % keywords == 4)
+    {
+      t[0] = sbox[t[0]];
+      t[1] = sbox[t[1]];
+      t[2] = sbox[t[2]];
+      t[3] = sbox[t[3]];
+    }
+    keydata[i * 4 + 0] = keydata[(i - keywords) * 4 + 0] ^ t[0];
+    keydata[i * 4 + 1] = keydata[(i - keywords) * 4 + 1] ^ t[1];
+    keydata[i * 4 + 2] = keydata[(i - keywords) * 4 + 2] ^ t[2];
+    keydata[i * 4 + 3] = keydata[(i - keywords) * 4 + 3] ^ t[3];
+  }
+
+}
+
+/*
+An original implementation uses no private buffers except a keyblock. We need private buffers to
+keep a CBC vector between calls and to be able to read input data not necessarily in 16-bytes blocks.
+Encrypter would actually require only one such buffer, as CBC vector is applied on input data before
+the actual cipher procedure. And CBC for the next chunk is simply the output from the previous.
+Decrypter, however, applies the cipher first, then applies CBC to the output with a buffered init
+vector, and the vector for the next call is the row input before cipher. Hence we need two 16-bytes
+buffers for decrypter.
+*/
+
+/*
+aes_state * aes_state_initialize_ecb (aes_state *State, uint8_t *keyblock, const uint8_t *key)
+{
+  state->flags = 0;
+
+  state->flags |= AES_ECB_MODE;
+
+  if (keyblock == NULL)
+  {
+    keyblock = util_malloc(sizeof(aes_keyblock));
+    state->flags |= AES_STATE_ALLOC;
+  }
+  state->keyblock = keyblock;
+  key_expansion(state, key);
+  state->flush = 0;
+  return state;
+}
+*/
+
+void aes_pdf_mode (aes_state *state)
+{
+  state->flags |= AES_INLINE_IV;
+  state->flags &= ~AES_NULL_PADDING;
+}
+
+/*
+Initialize arguments:
+- state - crypt state
+- keyblock - a space for aes key expansion; can be left NULL in which case will be allocated
+- key - crypt key; can be left NULL iff keyblock is given and properly initialized
+- keylength - the length of the key (16 or 32 bytes)
+- iv - 16-bytes CBC initialization vector;
+  - if left NULL for encoder, one is generated and stored as state->iv
+  - can also be left NULL for decorer, but then AES_INLINE_IV must be set, as this informs decoder to take
+    an initialization vector from the beginning of the encrypted stream
+
+At the first approach, an initialization vector was copied to state block during initialization and encoders
+assumed that the state block is the current initialization vector. This simplifies encrypting procedure,
+as the output from every 16-bytes chunk encryption is an initialization vector for the next chunk. However,
+it makes api usage cumbersome, as the user has to know that iv may need to be copied to state block
+before each call.
+*/
+
+static int aes_key_length (aes_state *state, size_t keylength)
+{
+  state->keylength = keylength;
+  switch (keylength)
+  {
+    case 16:
+      state->rounds = 10;
+      break;
+    case 24:
+      state->rounds = 12;
+      break;
+    case 32:
+      state->rounds = 14;
+      break;
+    default:
+      return 0;
+  }
+  return 1;
+}
+
+aes_state * aes_encode_initialize (aes_state *state, aes_keyblock *keyblock, const void *key, size_t keylength, const void *iv)
+{
+  state->flags = 0;
+  if (!aes_key_length(state, keylength))
+    return NULL;
+  if (iv != NULL)
+    aes_copy_block(state->iv, iv);
+  else
+    aes_generate_iv(state->iv);
+  state->flags |= AES_HAS_IV;
+
+  if (keyblock == NULL)
+  {
+    keyblock = (aes_keyblock *)util_malloc(sizeof(aes_keyblock));
+    state->flags |= AES_STATE_ALLOC;
+  }
+  state->keyblock = keyblock;
+  if (key != NULL) /* if NULL we assume keyblock is given and already expanded */
+    key_expansion(state, (const uint8_t *)key);
+  state->flush = 0;
+  return state;
+}
+
+aes_state * aes_decode_initialize (aes_state *state, aes_keyblock *keyblock, const void *key, size_t keylength, const void *iv)
+{
+  state->flags = 0;
+  if (!aes_key_length(state, keylength))
+    return NULL;
+  if (iv != NULL)
+  {
+    aes_copy_block(state->iv, iv);
+    state->flags |= AES_HAS_IV;
+  }
+  /* else if AES_INLINE_IV flag is set will be read from input */
+
+  if (keyblock == NULL)
+  {
+    keyblock = (aes_keyblock *)util_malloc(sizeof(aes_keyblock));
+    state->flags |= AES_STATE_ALLOC;
+  }
+  state->keyblock = keyblock;
+  if (key != NULL) /* otherwise keyblock is assumed present and properly initialized */
+    key_expansion(state, (const uint8_t *)key);
+  state->flush = 0;
+  return state;
+}
+
+void aes_state_close (aes_state *state)
+{
+  if (state->keyblock != NULL && (state->flags & AES_STATE_ALLOC))
+    util_free(state->keyblock);
+}
+
+/* add round key */
+
+static void aes_round_key (aes_block block, aes_block keyblock)
+{
+  uint8_t i, j;
+  for(i = 0; i < 4; ++i)
+    for(j = 0; j < 4; ++j)
+      block[i][j] ^= keyblock[i][j];
+}
+
+#define aes_add_key(block, keyblock, round) aes_round_key(block, (*keyblock)[round])
+
+/* substitution */
+
+static void aes_encode_sub (aes_block block)
+{
+  uint8_t i, j, v;
+  for(i = 0; i < 4; ++i)
+    for(j = 0; j < 4; ++j)
+      v = block[i][j], block[i][j] = sbox[v];
+}
+
+/* rows shift; the row index is the shift offset, the first order is not shifted */
+
+static void aes_encode_shift (aes_block block)
+{
+  uint8_t tmp;
+
+  /* 1st row rotated once */
+  tmp = block[0][1];
+  block[0][1] = block[1][1];
+  block[1][1] = block[2][1];
+  block[2][1] = block[3][1];
+  block[3][1] = tmp;
+
+  /* 2nd row rotated twice */
+  tmp = block[0][2];
+  block[0][2] = block[2][2];
+  block[2][2] = tmp;
+  tmp = block[1][2];
+  block[1][2] = block[3][2];
+  block[3][2] = tmp;
+
+  /* 3rd row rotated 3 times */
+  tmp = block[0][3];
+  block[0][3] = block[3][3];
+  block[3][3] = block[2][3];
+  block[2][3] = block[1][3];
+  block[1][3] = tmp;
+}
+
+static uint8_t xtime (uint8_t x)
+{
+  return ((x << 1) ^ (((x >> 7) & 1) * 0x1b));
+}
+
+/* mix columns */
+
+static void aes_encode_mix (aes_block block)
+{
+  uint8_t i, tmp, tm, t;
+
+  for(i = 0; i < 4; ++i)
+  {
+    t   = block[i][0];
+    tmp = block[i][0] ^ block[i][1] ^ block[i][2] ^ block[i][3] ;
+    tm  = block[i][0] ^ block[i][1]; tm = xtime(tm); block[i][0] ^= tm ^ tmp;
+    tm  = block[i][1] ^ block[i][2]; tm = xtime(tm); block[i][1] ^= tm ^ tmp;
+    tm  = block[i][2] ^ block[i][3]; tm = xtime(tm); block[i][2] ^= tm ^ tmp;
+    tm  = block[i][3] ^ t ;          tm = xtime(tm); block[i][3] ^= tm ^ tmp;
+  }
+}
+
+/* multiply is used to multiply numbers in the field GF(2^8) */
+
+#define multiply(x, y)                                \
+      (  ((y & 1) * x) ^                              \
+      ((y>>1 & 1) * xtime(x)) ^                       \
+      ((y>>2 & 1) * xtime(xtime(x))) ^                \
+      ((y>>3 & 1) * xtime(xtime(xtime(x)))) ^         \
+      ((y>>4 & 1) * xtime(xtime(xtime(xtime(x))))))   \
+
+/* mix columns */
+
+static void aes_decode_mix (aes_block block)
+{
+  int i;
+  uint8_t a, b, c, d;
+
+  for(i = 0; i < 4; ++i)
+  {
+    a = block[i][0];
+    b = block[i][1];
+    c = block[i][2];
+    d = block[i][3];
+    block[i][0] = multiply(a, 0x0e) ^ multiply(b, 0x0b) ^ multiply(c, 0x0d) ^ multiply(d, 0x09);
+    block[i][1] = multiply(a, 0x09) ^ multiply(b, 0x0e) ^ multiply(c, 0x0b) ^ multiply(d, 0x0d);
+    block[i][2] = multiply(a, 0x0d) ^ multiply(b, 0x09) ^ multiply(c, 0x0e) ^ multiply(d, 0x0b);
+    block[i][3] = multiply(a, 0x0b) ^ multiply(b, 0x0d) ^ multiply(c, 0x09) ^ multiply(d, 0x0e);
+  }
+}
+
+/* inverse substitution */
+
+static void aes_decode_sub (aes_block block)
+{
+  uint8_t i, j, v;
+  for(i = 0; i < 4; ++i)
+    for(j = 0; j < 4; ++j)
+      v = block[i][j], block[i][j] = rsbox[v];
+}
+
+/* inverse shift rows */
+
+static void aes_decode_shift (aes_block block)
+{
+  uint8_t tmp;
+
+  /* 1st row rotated once right */
+  tmp = block[3][1];
+  block[3][1] = block[2][1];
+  block[2][1] = block[1][1];
+  block[1][1] = block[0][1];
+  block[0][1] = tmp;
+
+  /* 2st row rotated twice right */
+  tmp = block[0][2];
+  block[0][2] = block[2][2];
+  block[2][2] = tmp;
+  tmp = block[1][2];
+  block[1][2] = block[3][2];
+  block[3][2] = tmp;
+
+  /* 3rd row rotated 3 times right */
+  tmp = block[0][3];
+  block[0][3] = block[1][3];
+  block[1][3] = block[2][3];
+  block[2][3] = block[3][3];
+  block[3][3] = tmp;
+}
+
+/* aes block encoder */
+
+static void aes_encode_cipher (aes_state *state)
+{
+  uint8_t round;
+  aes_add_key(state->block, state->keyblock, 0);
+  for (round = 1; round < state->rounds; ++round)
+  {
+    aes_encode_sub(state->block);
+    aes_encode_shift(state->block);
+    aes_encode_mix(state->block);
+    aes_add_key(state->block, state->keyblock, round);
+  }
+  aes_encode_sub(state->block);
+  aes_encode_shift(state->block);
+  aes_add_key(state->block, state->keyblock, state->rounds);
+}
+
+/* aes block decoder */
+
+static void aes_decode_cipher (aes_state *state)
+{
+  uint8_t round;
+  aes_add_key(state->block, state->keyblock, state->rounds);
+  for(round = state->rounds - 1; round > 0; --round)
+  {
+    aes_decode_shift(state->block);
+    aes_decode_sub(state->block);
+    aes_add_key(state->block, state->keyblock, round);
+    aes_decode_mix(state->block);
+  }
+  aes_decode_shift(state->block);
+  aes_decode_sub(state->block);
+  aes_add_key(state->block, state->keyblock, 0);
+}
+
+/* tail block padding; RFC 2898, PKCS #5: Password-Based Cryptography Specification Version 2.0; pdf spec p. 119 */
+
+#define aes_padding(state) ((state->flags & AES_NULL_PADDING) == 0)
+
+static void aes_put_padding (aes_state *state, uint8_t length)
+{
+  uint8_t pad;
+  pad = (aes_padding(state)) ? 16 - length : 0;
+  for (; length < 16; ++length)
+    state->data[length] = state->iv[length] ^ pad;
+}
+
+static int aes_remove_padding (aes_state *state, uint8_t *data, uint8_t *length)
+{
+  uint8_t pad;
+  *length = 16; /* block length 16 means leave intact */
+  if (aes_padding(state))
+  {
+    pad = data[16 - 1];
+    if (pad > 16)
+      return IOFERR;
+    for ( ; *length > 16 - pad; --(*length))
+      if (data[*length - 1] != pad)
+        return IOFERR;
+  }
+  else
+  {
+    for ( ; *length > 0; --(*length))
+      if (data[*length - 1] != '\0')
+        break;
+  }
+  return IOFEOF;
+}
+
+/* aes codec */
+
+/* make the cipher on input xor-ed with iv, save the output as a new iv, write the output */
+#define aes_encode_output(state, output) \
+  (aes_encode_cipher(state), aes_copy_block(state->iv, state->data), aes_copy_block(output, state->data), output += 16)
+
+iof_status aes_encode_state (iof *I, iof *O, aes_state *state)
+{
+  int c;
+
+  if (!(state->flags & AES_HAS_IV)) // weird
+    return IOFERR;
+  if ((state->flags & AES_INLINE_IV) && !(state->flags & AES_CONTINUE))
+  { /* write iv at the beginning of encrypted data */
+    if (!iof_ensure(O, 16))
+      return IOFFULL;
+    aes_copy_block(O->pos, state->iv);
+    O->pos += 16;
+    state->flags |= AES_CONTINUE;
+  }
+  while (iof_ensure(O, 16))
+  {
+    while (state->buffered < 16)
+    {
+      if ((c = iof_get(I)) != IOFEOF)
+      { /* get input byte XORed with iv */
+        state->data[state->buffered] = state->iv[state->buffered] ^ ((uint8_t)c);
+        ++state->buffered;
+      }
+      else
+      {
+        if (state->flush)
+        {
+          if (state->buffered > 0 || aes_padding(state))
+          { /* pad the last input chunk; for input divisable by 16, add 16 bytes 0x0f */
+            aes_put_padding(state, state->buffered);
+            state->buffered = 16;
+            aes_encode_output(state, O->pos);
+          }
+          return IOFEOF;
+        }
+        else
+          return IOFEMPTY;
+      }
+    }
+    aes_encode_output(state, O->pos);
+    state->buffered = 0;
+  }
+  return IOFFULL;
+}
+
+/* write iv to the output, save the raw input just buffered as iv for the next chunk, make the cipher, write out xoring with iv */
+#define aes_decode_output(state, output) \
+  (aes_copy_block(output, state->iv), aes_copy_block(state->iv, state->data), aes_decode_cipher(state), aes_copy_cbc(output, state->data), output += 16)
+
+iof_status aes_decode_state (iof *I, iof *O, aes_state *state)
+{
+  int c, ret;
+  uint8_t lastlength;
+
+  if ((state->flags & AES_INLINE_IV) && !(state->flags & AES_CONTINUE))
+  {
+    while (state->buffered < 16)
+    {
+      if ((c = iof_get(I)) != IOFEOF)
+        state->iv[state->buffered++] = (uint8_t)c;
+      else
+        return state->flush ? IOFERR : IOFEMPTY;
+    }
+    state->flags |= AES_CONTINUE|AES_HAS_IV;
+    state->buffered = 0;
+  }
+  while (iof_ensure(O, 16))
+  {
+    while (state->buffered < 16)
+    {
+      if ((c = iof_get(I)) != IOFEOF)
+        state->data[state->buffered++] = (uint8_t)c;
+      else
+        return state->flush ? IOFERR : IOFEMPTY;
+    }
+    aes_decode_output(state, O->pos);
+    if (state->flush)
+    { /* we have to check for EOF here, to remove eventual padding */
+      if ((c = iof_get(I)) < 0)
+      { /* end of input at 16-bytes boundary; remove padding and quit */
+        ret = aes_remove_padding(state, O->pos - 16, &lastlength);
+        O->pos -= 16 - lastlength;
+        return ret;
+      }
+      else
+      { /* beginning of the next block */
+        state->buffered = 1;
+        state->data[0] = (uint8_t)c;
+      }
+    }
+    else
+      state->buffered = 0;
+  }
+  return IOFFULL;
+}
+
+/* variants that works on c-strings; can work inplace (output==input) except encoder in pdf flavour */
+
+/*
+Codecs operating on c-string can generally work inplace (output==input), except encoder with AES_INLINE_IV flag set,
+which outputs 16 bytes of initialization vector at the beginning of encrypted data. All return the size of encrypted/decrypted
+data. Encoders output is the original length padded to a complete 16 bytes (plus eventual 16 bytes of initialization
+vector, if AES_INLINE_IV is used). Default padding is unambiguously removed during decryption. AES_NULL_PADDING flag
+forces using (ambiguous) NULL-byte padding, only if input length module 16 is greater then zero.
+
+An input data is supposed to be a complete data to be encrypted or decrypted. It is possible, however, to use those
+codecs for scaterred data chunks by manipulating AES_INLINE_IV, AES_NULL_PADDING, AES_CONTINUE flags and data length.
+Caller may assume that c-string codecs do not modify state flags.
+
+Encoder could actually be optimized by writing an initialization vector to a state block once. After every chunk encryption,
+the output is the initialization vector for the next chunk. Since we use c-string codec variants on short strings,
+the gain is neglectable in comparison with the weight of the aes crypt procedure.
+*/
+
+size_t aes_encode_data (const void *input, size_t length, void *output, const void *key, size_t keylength, const void *iv, int flags)
+{
+  aes_state state;
+  aes_keyblock keyblock;
+
+  if (aes_encode_initialize(&state, &keyblock, key, keylength, iv) == NULL)
+    return 0;
+  state.flags |= flags;
+  return aes_encode_state_data(&state, input, length, output);
+  // aes_state_close(&state);
+}
+
+size_t aes_encode_state_data (aes_state *state, const void *input, size_t length, void *output)
+{
+  const uint8_t *inp;
+  uint8_t *out, tail, t;
+  size_t size;
+
+  inp = (const uint8_t *)input;
+  out = (uint8_t *)output;
+
+  if (!(state->flags & AES_HAS_IV))
+      return 0;
+  if ((state->flags & AES_INLINE_IV) && !(state->flags & AES_CONTINUE))
+  {
+    aes_copy_block(out, state->iv);
+    out += 16;
+  }
+  // state->flags |= AES_CONTINUE; // do not modify state flags
+
+  for (size = 0; size + 16 <= length; size += 16)
+  {
+    aes_copy_xor(state->data, inp, state->iv);
+    aes_encode_output(state, out);
+    inp += 16;
+  }
+
+  if ((tail = (length % 16)) > 0 || aes_padding(state))
+  {
+    for (t = 0; t < tail; ++t)
+      state->data[t] = inp[t] ^ state->iv[t];
+    aes_put_padding(state, tail);
+    aes_encode_output(state, out);
+    size += 16;
+  }
+  if (state->flags & AES_INLINE_IV)
+    size += 16; /* iv written at the beginning of encoded data */
+
+  return size;
+}
+
+size_t aes_decode_data (const void *input, size_t length, void *output, const void *key, size_t keylength, const void *iv, int flags)
+{
+  aes_state state;
+  aes_keyblock keyblock;
+
+  if (aes_decode_initialize(&state, &keyblock, key, keylength, iv) == NULL)
+    return 0;
+  state.flags |= flags;
+  return aes_decode_state_data(&state, input, length, output);
+  // aes_state_close(&state);
+}
+
+size_t aes_decode_state_data (aes_state *state, const void *input, size_t length, void *output)
+{
+  const uint8_t *inp;
+  uint8_t *out, lastlength;
+  size_t size;
+
+  inp = (const uint8_t *)input;
+  out = (uint8_t *)output;
+
+  if ((state->flags & AES_INLINE_IV) && !(state->flags & AES_CONTINUE))
+  {
+    aes_copy_block(state->iv, inp);
+    // state->flags |= AES_HAS_IV; // do not modify state flags
+    inp += 16;
+    length = length >= 16 ? length - 16 : 0;
+  }
+  else if (!(state->flags & AES_HAS_IV))
+    return 0;
+  // state->flags |= AES_CONTINUE; // do not modify state flags
+  for (size = 0; size + 16 <= length; size += 16)
+  {
+    aes_copy_block(state->data, inp);
+    aes_decode_output(state, out);
+    inp += 16;
+  }
+
+  if (size >= 16)
+  {
+    aes_remove_padding(state, out - 16, &lastlength);
+    size = size - 16 + lastlength;
+  }
+
+  return size;
+}
+
+/*
+pseudo-random bytes chain exceprted from eexec; not expected to have strong cryptographic properties
+we only expect that it is (reasonably) unique and different for each call (not only function call, but also
+a program call). A current trick with mangling pointer value gives satisfactory results, generally different
+for every function call and a programm call. Note that the pseudo-input bytes starts from some inner address
+bits, as they vary better; without that, the first byte tends to be "lazy".
+*/
+
+void random_bytes (uint8_t *output, size_t size)
+{
+  size_t i;
+  uint8_t p;
+  static uint16_t k = 55665;
+  for (i = 0; i < size; ++i)
+  {
+    p = ((uint8_t *)(&output))[(i + 2) % sizeof(uint8_t *)] ^ (uint8_t)size; // pseudo input byte ;)
+    k = (((p + k) * 52845 + 22719) & 65535); // xor-ed with pseudo-random sequence (kept between calls)
+    output[i] = p ^ (k >> 8);
+  }
+}
+
+void aes_generate_iv (uint8_t output[16])
+{
+  random_bytes(output, 16);
+}
+
+/* filters */
+
+// rc4 decoder function
+
+static size_t rc4_decoder (iof *F, iof_mode mode)
+{
+  rc4_state *state;
+  iof_status status;
+  size_t tail;
+
+  state = iof_filter_state(rc4_state *, F);
+  switch(mode)
+  {
+    case IOFLOAD:
+    case IOFREAD:
+      if (F->flags & IOF_STOPPED)
+        return 0;
+      tail = iof_tail(F);
+      F->pos = F->buf + tail;
+      F->end = F->buf + F->space;
+      do {
+        status = rc4_decode_state(F->next, F, state);
+      } while (mode == IOFLOAD && status == IOFFULL && iof_resize_buffer(F));
+      return iof_decoder_retval(F, "rc4", status);
+    case IOFCLOSE:
+      rc4_state_close(state);
+      iof_free(F);
+      return 0;
+    default:
+      break;
+  }
+  return 0;
+}
+
+// rc4 encoder function
+
+static size_t rc4_encoder (iof *F, iof_mode mode)
+{
+  rc4_state *state;
+  iof_status status;
+
+  state = iof_filter_state(rc4_state *, F);
+  switch (mode)
+  {
+    case IOFFLUSH:
+      state->flush = 1;
+      // fall through
+    case IOFWRITE:
+      F->end = F->pos;
+      F->pos = F->buf;
+      status = rc4_encode_state(F, F->next, state);
+      return iof_encoder_retval(F, "rc4", status);
+    case IOFCLOSE:
+      if (!state->flush)
+        rc4_encoder(F, IOFFLUSH);
+      rc4_state_close(state);
+      iof_free(F);
+      return 0;
+    default:
+      break;
+  }
+  return 0;
+}
+
+// aes decoder function
+
+static size_t aes_decoder (iof *F, iof_mode mode)
+{
+  aes_state *state;
+  iof_status status;
+  size_t tail;
+
+  state = iof_filter_state(aes_state *, F);
+  switch(mode)
+  {
+    case IOFLOAD:
+    case IOFREAD:
+      if (F->flags & IOF_STOPPED)
+        return 0;
+      tail = iof_tail(F);
+      F->pos = F->buf + tail;
+      F->end = F->buf + F->space;
+      do {
+        status = aes_decode_state(F->next, F, state);
+      } while (mode == IOFLOAD && status == IOFFULL && iof_resize_buffer(F));
+      return iof_decoder_retval(F, "aes", status);
+    case IOFCLOSE:
+      aes_state_close(state);
+      iof_free(F);
+      return 0;
+    default:
+      break;
+  }
+  return 0;
+}
+
+// aes encoder function
+
+static size_t aes_encoder (iof *F, iof_mode mode)
+{
+  aes_state *state;
+  iof_status status;
+
+  state = iof_filter_state(aes_state *, F);
+  switch (mode)
+  {
+    case IOFFLUSH:
+      state->flush = 1;
+      // fall through
+    case IOFWRITE:
+      F->end = F->pos;
+      F->pos = F->buf;
+      status = aes_encode_state(F, F->next, state);
+      return iof_encoder_retval(F, "aes", status);
+    case IOFCLOSE:
+      if (!state->flush)
+        aes_encoder(F, IOFFLUSH);
+      aes_state_close(state);
+      iof_free(F);
+      return 0;
+    default:
+      break;
+  }
+  return 0;
+}
+
+iof * iof_filter_rc4_decoder (iof *N, const void *key, size_t keylength)
+{
+  iof *I;
+  rc4_state *state;
+
+  I = iof_filter_reader(rc4_decoder, sizeof(rc4_state), &state);
+  iof_setup_next(I, N);
+  if (rc4_state_init(state, key, keylength) == NULL)
+  {
+    iof_discard(I);
+    return NULL;
+  }
+  state->flush = 1;
+  return I;
+}
+
+iof * iof_filter_rc4_encoder (iof *N, const void *key, size_t keylength)
+{
+  iof *O;
+  rc4_state *state;
+
+  O = iof_filter_writer(rc4_encoder, sizeof(rc4_state), &state);
+  iof_setup_next(O, N);
+  if (rc4_state_init(state, key, keylength) == NULL)
+  {
+    iof_discard(O);
+    return NULL;
+  }
+  // state->flush = 1;
+  return O;
+}
+
+/* aes crypt filters */
+
+iof * iof_filter_aes_decoder (iof *N, const void *key, size_t keylength)
+{
+  iof *I;
+  aes_state *state;
+
+  I = iof_filter_reader(aes_decoder, sizeof(aes_state), &state);
+  iof_setup_next(I, N);
+  if (aes_decode_init(state, key, keylength) == NULL)
+  {
+    iof_discard(I);
+    return NULL;
+  }
+  aes_pdf_mode(state);
+  state->flush = 1;
+  return I;
+}
+
+iof * iof_filter_aes_encoder (iof *N, const void *key, size_t keylength)
+{
+  iof *O;
+  aes_state *state;
+
+  O = iof_filter_writer(aes_encoder, sizeof(aes_state), &state);
+  iof_setup_next(O, N);
+  if (aes_encode_init(state, key, keylength) == NULL)
+  {
+    iof_discard(O);
+    return NULL;
+  }
+  aes_pdf_mode(state);
+  // state->flush = 1;
+  return O;
+}
+
+/* test */
+
+/*
+static void show (void *p, size_t size, uint8_t round, uint8_t sym)
+{
+  uint8_t i;
+  printf("%c%c:", round, sym);
+  for (i = 0; i < size; ++i)
+    printf("%02x", ((uint8_t *)p)[i]);
+  printf("\n");
+}
+
+void aes_test (void)
+{
+  const uint8_t key[] = { 0x2b, 0x7e, 0x15, 0x16, 0x28, 0xae, 0xd2, 0xa6, 0xab, 0xf7, 0x15, 0x88, 0x09, 0xcf, 0x4f, 0x3c };
+  const uint8_t iv[]  = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f };
+  const uint8_t inp[] = {
+    0x6b, 0xc1, 0xbe, 0xe2, 0x2e, 0x40, 0x9f, 0x96, 0xe9, 0x3d, 0x7e, 0x11, 0x73, 0x93, 0x17, 0x2a,
+    0xae, 0x2d, 0x8a, 0x57, 0x1e, 0x03, 0xac, 0x9c, 0x9e, 0xb7, 0x6f, 0xac, 0x45, 0xaf, 0x8e, 0x51,
+    0x30, 0xc8, 0x1c, 0x46, 0xa3, 0x5c, 0xe4, 0x11, 0xe5, 0xfb, 0xc1, 0x19, 0x1a, 0x0a, 0x52, 0xef,
+    0xf6, 0x9f, 0x24, 0x45, 0xdf, 0x4f, 0x9b, 0x17, 0xad, 0x2b, 0x41, 0x7b, 0xe6, 0x6c, 0x37, 0x10 };
+  const uint8_t out[]  = {
+    0x76, 0x49, 0xab, 0xac, 0x81, 0x19, 0xb2, 0x46, 0xce, 0xe9, 0x8e, 0x9b, 0x12, 0xe9, 0x19, 0x7d,
+    0x50, 0x86, 0xcb, 0x9b, 0x50, 0x72, 0x19, 0xee, 0x95, 0xdb, 0x11, 0x3a, 0x91, 0x76, 0x78, 0xb2,
+    0x73, 0xbe, 0xd6, 0xb8, 0xe3, 0xc1, 0x74, 0x3b, 0x71, 0x16, 0xe6, 0x9e, 0x22, 0x22, 0x95, 0x16,
+    0x3f, 0xf1, 0xca, 0xa1, 0x68, 0x1f, 0xac, 0x09, 0x12, 0x0e, 0xca, 0x30, 0x75, 0x86, 0xe1, 0xa7 };
+
+  uint8_t input[64], output[64];
+  size_t inpsize, outsize;
+  int flags = AES_NULL_PADDING;
+
+	////////////////////////////////////////////////////////////////////////////
+
+//#define ENCODETO output
+#define ENCODETO input // inplace
+
+  inpsize = 64;
+  memcpy(input, inp, inpsize);
+	show(input, inpsize, '>', '>');
+  outsize = aes_encode_data(input, inpsize, ENCODETO, key, 16, iv, flags);
+  show(ENCODETO, outsize, '<', '<');
+  if (outsize == inpsize && memcmp(ENCODETO, out, outsize) == 0)
+    printf("ENCODER SUCCESS\n");
+  else
+    printf("ENCODER FAILURE\n");
+
+	////////////////////////////////////////////////////////////////////////////
+
+//#define DECODETO input
+#define DECODETO output // in place
+
+  outsize = 64;
+  memcpy(output, out, outsize);
+  show(output, outsize, '<', '<');
+	inpsize = aes_decode_data(output, outsize, DECODETO, key, 16, iv, flags);
+  show(DECODETO, inpsize, '>', '>');
+  if (inpsize == outsize && memcmp(DECODETO, inp, inpsize) == 0)
+    printf("DECODER SUCCESS\n");
+  else
+    printf("DECODER FAILURE\n");
+}
+*/
+
+/*
+Some example vectors
+
+================================ AES ECB 128-bit encryption mode ================================
+
+Encryption key: 2b7e151628aed2a6abf7158809cf4f3c
+
+Test vector                      Cipher text
+6bc1bee22e409f96e93d7e117393172a 3ad77bb40d7a3660a89ecaf32466ef97
+ae2d8a571e03ac9c9eb76fac45af8e51 f5d3d58503b9699de785895a96fdbaaf
+30c81c46a35ce411e5fbc1191a0a52ef 43b1cd7f598ece23881b00e3ed030688
+f69f2445df4f9b17ad2b417be66c3710 7b0c785e27e8ad3f8223207104725dd4
+
+
+================================ AES ECB 192-bit encryption mode ================================
+
+Encryption key: 8e73b0f7da0e6452c810f32b809079e562f8ead2522c6b7b
+
+Test vector                       Cipher text
+6bc1bee22e409f96e93d7e117393172a  bd334f1d6e45f25ff712a214571fa5cc
+ae2d8a571e03ac9c9eb76fac45af8e51  974104846d0ad3ad7734ecb3ecee4eef
+30c81c46a35ce411e5fbc1191a0a52ef  ef7afd2270e2e60adce0ba2face6444e
+f69f2445df4f9b17ad2b417be66c3710  9a4b41ba738d6c72fb16691603c18e0e
+
+
+================================ AES ECB 256-bit encryption mode ================================
+
+Encryption key: 603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4
+
+Test vector                       Cipher text
+6bc1bee22e409f96e93d7e117393172a  f3eed1bdb5d2a03c064b5a7e3db181f8
+ae2d8a571e03ac9c9eb76fac45af8e51  591ccb10d410ed26dc5ba74a31362870
+30c81c46a35ce411e5fbc1191a0a52ef  b6ed21b99ca6f4f9f153e7b1beafed1d
+f69f2445df4f9b17ad2b417be66c3710  23304b7a39f9f3ff067d8d8f9e24ecc7
+
+================================ AES CBC 128-bit encryption mode ================================
+
+Encryption key: 2b7e151628aed2a6abf7158809cf4f3c
+
+Initialization vector             Test vector                       Cipher text
+000102030405060708090A0B0C0D0E0F  6bc1bee22e409f96e93d7e117393172a  7649abac8119b246cee98e9b12e9197d
+7649ABAC8119B246CEE98E9B12E9197D  ae2d8a571e03ac9c9eb76fac45af8e51  5086cb9b507219ee95db113a917678b2
+5086CB9B507219EE95DB113A917678B2  30c81c46a35ce411e5fbc1191a0a52ef  73bed6b8e3c1743b7116e69e22229516
+73BED6B8E3C1743B7116E69E22229516  f69f2445df4f9b17ad2b417be66c3710  3ff1caa1681fac09120eca307586e1a7
+
+================================ AES CBC 192-bit encryption mode ================================
+
+Encryption key: 8e73b0f7da0e6452c810f32b809079e562f8ead2522c6b7b
+
+Initialization vector             Test vector                       Cipher text
+000102030405060708090A0B0C0D0E0F  6bc1bee22e409f96e93d7e117393172a  4f021db243bc633d7178183a9fa071e8
+4F021DB243BC633D7178183A9FA071E8  ae2d8a571e03ac9c9eb76fac45af8e51  b4d9ada9ad7dedf4e5e738763f69145a
+B4D9ADA9AD7DEDF4E5E738763F69145A  30c81c46a35ce411e5fbc1191a0a52ef  571b242012fb7ae07fa9baac3df102e0
+571B242012FB7AE07FA9BAAC3DF102E0  f69f2445df4f9b17ad2b417be66c3710  08b0e27988598881d920a9e64f5615cd
+
+================================ AES CBC 256-bit encryption mode ================================
+
+Encryption key: 603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4
+
+Initialization vector             Test vector                       Cipher text
+000102030405060708090A0B0C0D0E0F  6bc1bee22e409f96e93d7e117393172a  f58c4c04d6e5f1ba779eabfb5f7bfbd6
+F58C4C04D6E5F1BA779EABFB5F7BFBD6  ae2d8a571e03ac9c9eb76fac45af8e51  9cfc4e967edb808d679f777bc6702c7d
+9CFC4E967EDB808D679F777BC6702C7D  30c81c46a35ce411e5fbc1191a0a52ef  39f23369a9d9bacfa530e26304231461
+39F23369A9D9BACFA530E26304231461  f69f2445df4f9b17ad2b417be66c3710  b2eb05e2c39be9fcda6c19078c6a9d1b
+*/
\ No newline at end of file
diff --git a/texk/web2c/luatexdir/luapplib/util/utilcrypt.h b/texk/web2c/luatexdir/luapplib/util/utilcrypt.h
new file mode 100644
index 000000000..e5bf53cc5
--- /dev/null
+++ b/texk/web2c/luatexdir/luapplib/util/utilcrypt.h
@@ -0,0 +1,90 @@
+#ifndef UTIL_CRYPT_H
+#define UTIL_CRYPT_H
+
+#include <stdint.h>
+#include <stddef.h>
+#include "utiliof.h"
+
+#ifndef UTIL_CRYPT_TIME
+#  define UTIL_CRYPT_TIME 0
+#endif
+
+/* RC4 */
+
+typedef uint8_t rc4_map[256];
+
+typedef struct rc4_state rc4_state;
+
+#define RC4_STATE_ALLOC (1<<0)
+
+UTILAPI rc4_state * rc4_state_initialize (rc4_state *state, rc4_map *map, const void *vkey, size_t keylength);
+#define rc4_state_init(state, vkey, keylength) rc4_state_initialize(state, NULL, vkey, keylength)
+UTILAPI void rc4_map_save (rc4_state *state, rc4_map *map);
+UTILAPI void rc4_map_restore (rc4_state *state, rc4_map *map);
+
+/* Codecs operating on iof */
+
+UTILAPI iof_status rc4_crypt_state (iof *I, iof *O, rc4_state *state);
+#define rc4_encode_state(I, O, state) rc4_crypt_state(I, O, state)
+#define rc4_decode_state(I, O, state) rc4_crypt_state(I, O, state)
+
+UTILAPI iof_status rc4_crypt (iof *I, iof *O, const void *key, size_t length);
+#define rc4_encode(I, O) rc4_crypt(I, O, key, length)
+#define rc4_decode(I, O) rc4_crypt(I, O, key, length)
+
+UTILAPI size_t rc4_crypt_data (const void *input, size_t length, void *output, const void *key, size_t keylength);
+UTILAPI size_t rc4_crypt_state_data (rc4_state *state, const void *input, size_t length, void *output);
+#define rc4_encode_data(input, length, output, key, keylength) rc4_crypt_data(input, length, output, key, keylength)
+#define rc4_decode_data(input, length, output, key, keylength) rc4_crypt_data(input, length, output, key, keylength)
+#define rc4_encode_state_data(state, input, length, output) rc4_crypt_state_data(state, input, length, output)
+#define rc4_decode_state_data(state, input, length, output) rc4_crypt_state_data(state, input, length, output)
+
+UTILAPI void rc4_state_close (rc4_state *state);
+
+/* AES */
+
+typedef uint8_t aes_block[4][4];
+typedef aes_block aes_keyblock[15]; // aes128 - 10+1, aes192 - 12+1, aes256 - 14+1
+
+typedef struct aes_state aes_state;
+
+#define AES_STATE_ALLOC (1<<0)
+//#define AES_ECB_MODE (1<<2)
+#define AES_HAS_IV (1<<3)
+#define AES_INLINE_IV (1<<4)
+#define AES_CONTINUE (1<<5)
+#define AES_NULL_PADDING (1<<6)
+
+UTILAPI void aes_pdf_mode (aes_state *state);
+//UTILAPI aes_state * aes_state_initialize_ecb (aes_state *State, uint8_t *roundkey, const uint8_t *key);
+UTILAPI aes_state * aes_encode_initialize (aes_state *state, aes_keyblock *keyblock, const void *key, size_t keylength, const void *iv);
+UTILAPI aes_state * aes_decode_initialize (aes_state *state, aes_keyblock *keyblock, const void *key, size_t keylength, const void *iv);
+#define aes_encode_init(state, key, keylength) aes_encode_initialize(state, NULL, key, keylength, NULL)
+#define aes_decode_init(state, key, keylength) aes_decode_initialize(state, NULL, key, keylength, NULL)
+
+UTILAPI void aes_state_close (aes_state *state);
+
+/* Codecs operating on iof */
+
+UTILAPI iof_status aes_encode_state (iof *I, iof *O, aes_state *state);
+UTILAPI iof_status aes_decode_state (iof *I, iof *O, aes_state *state);
+
+UTILAPI size_t aes_encode_data (const void *input, size_t length, void *output, const void *key, size_t keylength, const void *iv, int flags);
+UTILAPI size_t aes_encode_state_data (aes_state *state, const void *input, size_t length, void *output);
+UTILAPI size_t aes_decode_data (const void *input, size_t length, void *output, const void *key, size_t keylength, const void *iv, int flags);
+UTILAPI size_t aes_decode_state_data (aes_state *state, const void *input, size_t length, void *output);
+
+/* random bytes generator */
+
+UTILAPI void random_bytes (uint8_t *output, size_t size);
+UTILAPI void aes_generate_iv (uint8_t output[16]);
+
+/* filters */
+
+iof * iof_filter_rc4_decoder (iof *N, const void *key, size_t keylength);
+iof * iof_filter_rc4_encoder (iof *N, const void *key, size_t keylength);
+
+iof * iof_filter_aes_decoder (iof *N, const void *key, size_t keylength);
+iof * iof_filter_aes_encoder (iof *N, const void *key, size_t keylength);
+
+#endif
\ No newline at end of file
diff --git a/texk/web2c/luatexdir/luapplib/util/utilcryptdef.h b/texk/web2c/luatexdir/luapplib/util/utilcryptdef.h
new file mode 100644
index 000000000..02d70aa5e
--- /dev/null
+++ b/texk/web2c/luatexdir/luapplib/util/utilcryptdef.h
@@ -0,0 +1,30 @@
+
+#ifndef UTIL_CRYPTDEF_H
+#define UTIL_CRYPTDEF_H
+
+struct rc4_state {
+  union {
+    rc4_map *map;
+    uint8_t *smap;
+  };
+  int i, j;
+  int flush;
+  int flags;
+};
+
+struct aes_state {
+  size_t keylength;
+  int rounds;
+  //int keywords;
+  union {
+    aes_block block;
+    uint8_t data[16];
+  };
+  aes_keyblock *keyblock;
+  uint8_t iv[16];
+  uint8_t buffered;
+  int flush;
+  int flags;
+};
+
+#endif
\ No newline at end of file
diff --git a/texk/web2c/luatexdir/luapplib/util/utildecl.h b/texk/web2c/luatexdir/luapplib/util/utildecl.h
new file mode 100644
index 000000000..94ef73413
--- /dev/null
+++ b/texk/web2c/luatexdir/luapplib/util/utildecl.h
@@ -0,0 +1,28 @@
+
+#ifndef UTIL_DECL_H
+#define UTIL_DECL_H
+
+/*
+UTILDLL - when building .dll
+UTILEXE - when building .exe to import symbols from .dll
+*/
+
+#if defined (_WIN32) || defined(_WIN64)
+#  ifdef UTILDLL
+#    define UTILAPI __declspec(dllexport)
+#    define UTILDEF __declspec(dllexport) 
+#  else
+#    ifdef UTILEXE
+#      define UTILAPI __declspec(dllimport)
+#      define UTILDEF
+#    else
+#      define UTILAPI
+#      define UTILDEF
+#    endif
+#  endif
+#else
+#  define UTILAPI
+#  define UTILDEF
+#endif
+
+#endif
\ No newline at end of file
diff --git a/texk/web2c/luatexdir/luapplib/util/utilflate.c b/texk/web2c/luatexdir/luapplib/util/utilflate.c
new file mode 100644
index 000000000..8ecc240c9
--- /dev/null
+++ b/texk/web2c/luatexdir/luapplib/util/utilflate.c
@@ -0,0 +1,319 @@
+
+#include "utilmem.h"
+#include "utillog.h"
+#include "utilflate.h"
+#include <zlib.h>
+
+/* flate codec */
+
+/*
+Flate codec example provided at http://www.zlib.net/zpipe.c (http://www.zlib.net/zlib_how.html) uses the following scheme:
+- provide input data buffer
+- keep providing output until codec function uses it
+
+For encoder:
+
+  z->zalloc = z->zfree = z->zopaque = NULL;
+  deflateInit(z, compression_level);
+  do {
+    z->next_in = <input buffer>
+    z->avail_in = <input buffer bytes>
+    do {
+      z->next_out = <output buffer>
+      z->avail_out = <output buffer bytes>
+      deflate(z, flush);
+      // write obtained output from deflate
+    } while (z->avail_out == 0);
+    assert(z->avail_in == 0);
+  } while (flush != Z_FINISH);
+  deflateEnd(z);
+
+'z' is an internal codec state of type z_stream, 'flush' is either Z_NO_FLUSH or Z_FINISH at the end of data.
+deflate() ensures to consume the entire input if there are no obstackles to write an output. The inner loop
+provides an output space as long as it is used by deflate(). When deflate() wrote everything it could,
+it leaves z->avail_out > 0, which breaks the inner loop. At this point z->avail_in should also be zero.
+The example documentation claims that the return codes from deflate() doesn't really need to be checked,
+as checking z->avail_out for zero is enough.
+
+The scheme for decoder is pretty similar, but with substantial differences:
+- the end of stream is automatically found by decoder, so using Z_FINISH flag to indicate an end of stream
+  is not necessary, but if provided, it MUST be given only if the EOF marker actually occurs in the input chunk,
+  and subsequent calls to inflate() must consequently use Z_FINISH
+- calling inflate() as long as it uses the output buffer provided still works for decoder, but inflate()
+  does not ensure to consume the entire input, as it will read until end of stream marker
+- the return code from inflate() must be checked to ensure the proper reaction on invalid data stream and
+  end of stream signals
+- initialization must set an input buffer to NULL or to some existing chunk (the later helps zlib to perform
+  better on inflate(), but inflate() does the research on the first call anyway)
+
+  z->zalloc = z->zfree = z->zopaque = NULL;
+  z->next_in = NULL, z->avail_in = 0;
+  inflateInit(z);
+  do {
+    z->next_in = <input buffer>
+    z->avail_in = <input buffer bytes>
+    do {
+      z->next_out = <output buffer>
+      z->avail_out = <output buffer bytes>
+      status = inflate(z, flush);
+      // check return status
+      // write obtained output from inflate
+    } while (z->avail_out == 0);
+  } while (status != Z_STREAM_END);
+  inflateEnd(z);
+
+Our wrapper generally follows "prepare input, keep pomping output" scheme, but we need to support handler function
+breaks on IOFEMPTY and IOFFULL. For a consistent come back from those on subsequent calls to the handler function,
+we use 3 states:
+- FLATE_IN - get input, when got something then goto FALTE_OUT
+- FLATE_OUT - set z_stream buffers and keep writing output until enything to write, then goto FLATE_IN or FLATE_DONE
+- FLATE_DONE - we are done, no return from that state
+Distinction of FLATE_IN and FLATE_OUT states guarantees that we will not get more input until zlib consumes the stuff
+from the previous feed, possibly interrupted by IOFFULL return on filling the output buffer. This distinction is not
+critical, but makes the filter running according to the scheme described above. Note that we set zlib input buffer
+(z->next_in, z->avail_in) at the beginning of FLATE_OUT state. Also note that we always update our buffers according
+to updated avail_in / avail_out values, just after a call to inflate() / deflate(). So no matter what have happens
+between handler calls, zlib input buffer is in sync with ours.
+*/
+
+struct flate_state {
+  z_stream z;
+  int flush;
+  int status;
+  int level; /* encoder compression level -1..9 */
+};
+
+enum {
+  FLATE_IN,
+  FLATE_OUT,
+  FLATE_DONE
+};
+
+flate_state * flate_decoder_init (flate_state *state)
+{ /* initialize zlib */
+  z_stream *z = &state->z;
+  z->zalloc = Z_NULL;
+  z->zfree = Z_NULL;
+  z->opaque = Z_NULL;
+  z->avail_in = 0;     /* must be initialized before inflateInit() */
+  z->next_in = Z_NULL; /* ditto */
+  if (inflateInit(z) != Z_OK)
+    return NULL;
+  state->status = FLATE_IN;
+  return state;
+}
+
+flate_state * flate_encoder_init (flate_state *state)
+{
+  z_stream *z = &state->z;
+  z->zalloc = Z_NULL;
+  z->zfree = Z_NULL;
+  z->opaque = Z_NULL;
+  z->avail_in = 0;
+  z->next_in = Z_NULL;
+  state->level = Z_DEFAULT_COMPRESSION; // will probably be moved upward
+  if (deflateInit(z, state->level) != Z_OK)
+    return NULL;
+  state->status = FLATE_IN;
+  return state;
+}
+
+static const char * zmess (int zstatus)
+{
+  switch (zstatus)
+  {
+    case Z_OK:            return "ok";
+    case Z_STREAM_END:    return "end of stream";
+    case Z_BUF_ERROR:     return "buffer error";
+    case Z_STREAM_ERROR:  return "stream error";
+    case Z_NEED_DICT:     return "need dict";
+    case Z_DATA_ERROR:    return "data error";
+    case Z_MEM_ERROR:     return "memory error";
+    case Z_VERSION_ERROR: return "version error";
+    case Z_ERRNO:         return "io error";
+    default:
+      break;
+  }
+  return "unknown error";
+}
+
+iof_status flate_decode_state (iof *I, iof *O, flate_state *state)
+{
+  z_stream *z;
+  int zstatus = Z_OK;
+  z = &state->z;
+  while (state->status != FLATE_DONE)
+  {
+    if (state->status == FLATE_IN)
+    {
+      if (!iof_readable(I))
+        return state->flush ? IOFERR : IOFEMPTY;
+      state->status = FLATE_OUT;
+    }
+    z->next_in = (Bytef *)I->pos;
+    z->avail_in = (uInt)iof_left(I);
+    do {
+      if (!iof_writable(O))
+        return IOFFULL;
+      z->next_out = (Bytef *)O->pos;
+      z->avail_out = (uInt)iof_left(O);
+      zstatus = inflate(z, Z_NO_FLUSH);
+      I->pos += iof_left(I) - z->avail_in;
+      O->pos += iof_left(O) - z->avail_out;
+      switch (zstatus)
+      {
+        case Z_OK:
+        case Z_STREAM_END:
+          break;
+        default:
+          loggerf("flate decoder %s (%d)", zmess(zstatus), zstatus);
+          return IOFERR;
+      }
+    } while (z->avail_out == 0);
+    state->status = zstatus == Z_STREAM_END ? FLATE_DONE : FLATE_IN;
+  }
+  return IOFEOF;
+}
+
+iof_status flate_encode_state (iof *I, iof *O, flate_state *state)
+{
+  z_stream *z;
+  int zstatus;
+  z = &state->z;
+  while (state->status != FLATE_DONE)
+  {
+    if (state->status == FLATE_IN)
+    {
+      if (!iof_readable(I))
+        if (!state->flush)
+          return IOFEMPTY;
+      state->status = FLATE_OUT;
+    }
+    z->next_in = (Bytef *)I->pos;
+    z->avail_in = (uInt)iof_left(I);
+    do {
+      if (!iof_writable(O))
+        return IOFFULL;
+      z->next_out = (Bytef *)O->pos;
+      z->avail_out = (uInt)iof_left(O);
+      zstatus = deflate(z, state->flush ? Z_FINISH : Z_NO_FLUSH);
+      I->pos += iof_left(I) - z->avail_in;
+      O->pos += iof_left(O) - z->avail_out;
+      switch (zstatus)
+      {
+        case Z_OK:
+        case Z_STREAM_END:
+          break;
+        default:
+          loggerf("flate encoder %s (%d)", zmess(zstatus), zstatus);
+          return IOFERR;
+      }
+    } while (z->avail_out == 0);
+    state->status = state->flush ? FLATE_DONE : FLATE_IN;
+  }
+  return IOFEOF;
+}
+
+
+void flate_decoder_close (flate_state *state)
+{
+  inflateEnd(&state->z);
+}
+
+void flate_encoder_close (flate_state *state)
+{
+  deflateEnd(&state->z);
+}
+
+/* filter */
+
+// flate decoder function
+
+static size_t flate_decoder (iof *F, iof_mode mode)
+{
+  flate_state *state;
+  iof_status status;
+  size_t tail;
+
+  state = iof_filter_state(flate_state *, F);
+  switch(mode)
+  {
+    case IOFLOAD:
+    case IOFREAD:
+      if (F->flags & IOF_STOPPED)
+        return 0;
+      tail = iof_tail(F);
+      F->pos = F->buf + tail;
+      F->end = F->buf + F->space;
+      do {
+        status = flate_decode_state(F->next, F, state);
+      } while (mode == IOFLOAD && status == IOFFULL && iof_resize_buffer(F));
+      return iof_decoder_retval(F, "flate", status);
+    case IOFCLOSE:
+      flate_decoder_close(state);
+      iof_free(F);
+      return 0;
+    default:
+      break;
+  }
+  return 0;
+}
+
+// flate encoder function
+
+static size_t flate_encoder (iof *F, iof_mode mode)
+{
+  flate_state *state;
+  iof_status status;
+
+  state = iof_filter_state(flate_state *, F);
+  switch (mode)
+  {
+    case IOFFLUSH:
+      state->flush = 1;
+      // fall through
+    case IOFWRITE:
+      F->end = F->pos;
+      F->pos = F->buf;
+      status = flate_encode_state(F, F->next, state);
+      return iof_encoder_retval(F, "flate", status);
+    case IOFCLOSE:
+      if (!state->flush)
+        flate_encoder(F, IOFFLUSH);
+      flate_encoder_close(state);
+      iof_free(F);
+      return 0;
+    default:
+      break;
+  }
+  return 0;
+}
+
+iof * iof_filter_flate_decoder (iof *N)
+{
+  iof *I;
+  flate_state *state;
+  I = iof_filter_reader(flate_decoder, sizeof(flate_state), &state);
+  iof_setup_next(I, N);
+  if (flate_decoder_init(state) == NULL)
+  {
+    iof_discard(I);
+    return NULL;
+  }
+  state->flush = 1;
+  return I;
+}
+
+iof * iof_filter_flate_encoder (iof *N)
+{
+  iof *O;
+  flate_state *state;
+  O = iof_filter_writer(flate_encoder, sizeof(flate_state), &state);
+  iof_setup_next(O, N);
+  if (flate_encoder_init(state) == NULL)
+  {
+    iof_discard(O);
+    return NULL;
+  }
+  return O;
+}
diff --git a/texk/web2c/luatexdir/luapplib/util/utilflate.h b/texk/web2c/luatexdir/luapplib/util/utilflate.h
new file mode 100644
index 000000000..09bdd6661
--- /dev/null
+++ b/texk/web2c/luatexdir/luapplib/util/utilflate.h
@@ -0,0 +1,21 @@
+#ifndef UTIL_FLATE_H
+#define UTIL_FLATE_H
+
+#include "utiliof.h"
+
+typedef struct flate_state flate_state;
+
+flate_state * flate_decoder_init (flate_state *state);
+flate_state * flate_encoder_init (flate_state *state);
+
+iof_status flate_decode_state (iof *I, iof *O, flate_state *state);
+iof_status flate_encode_state (iof *I, iof *O, flate_state *state);
+
+void flate_decoder_close (flate_state *state);
+void flate_encoder_close (flate_state *state);
+
+iof * iof_filter_flate_decoder (iof *N);
+iof * iof_filter_flate_encoder (iof *N);
+
+
+#endif
\ No newline at end of file
diff --git a/texk/web2c/luatexdir/luapplib/util/utilfpred.c b/texk/web2c/luatexdir/luapplib/util/utilfpred.c
new file mode 100644
index 000000000..ce9c129e2
--- /dev/null
+++ b/texk/web2c/luatexdir/luapplib/util/utilfpred.c
@@ -0,0 +1,783 @@
+/* predictor filters; common for flate and lzw */
+
+#include "utilmem.h"
+#include "utillog.h"
+#include "utilfpred.h"
+
+/*
+Here we implement predictor filters used with flate and lzw compressions in PDF streams. The main idea of data prediction
+is to compute and output the differences between data records instead of this records. Adjacent pixels in images are usually
+similar, so differences between pixel values tends to be zero. And both Flate and LZW performs better when the input
+is rather smooth. Although a preliminary use of predictors is related to bitmap data, The actual need for predictor filter
+came from the fact that xref streams may also be predicted (usually with PNG up-predictor).
+
+PDF specification allows to use several predictor algorithms, specified by /Predictor key in /DecodeParms dictionary:
+
+   1 - no predictor (default)
+   2 - TIFF horizontal predictor
+  10 - PNG none predictor
+  11 - PNG sub predictor
+  12 - PNG up predictor
+  13 - PNG average predictor
+  14 - PNG paeth predictor
+
+All PNG predictors works on bytes, regardless the image color-depth. While encoding, every input data byte is decreased
+by the appropriate byte of the previous pixel. Even if the pixel does not fit a full byte, PNG predictors use an artificial
+pixel size rounded up to a full byte. PNG predictors utilizes previous (left) pixel, pixel above and previous to above
+pixel. In case of PNG, the type of the predictor is written on a dedicated byte on the beginning of every scanline. It
+means all predictor functions must maintain and information about left, above and left-above pixels.
+
+Despite the same differencing idea, TIFF predictors are different. The prediction process bases on pixel components,
+which are not necessarily bytes (component of a pixel is added/substracted from a relevant component of a previous
+pixel). In TIFF predictor 2, only the previous (the left) pixel is taken into account, there is no need to keep
+an information about other surrounding pixels. Also there is no expicit algorithm marker in data; the same prediction
+method is applied to all input rows.
+
+Not surprisingly, predictor encoders and decoders are pretty similar. Encoders take some input value and the previous
+input value (or 0 at the beginning of the scanline) and output a difference between them. Decoders takes an input value,
+previously decoded value (or zero) and outputs their sum. When encoding, the result is cast to the proper unsigned integer,
+when decoding, modulo 256 (or appropriate) is used, which makes encoding and decoding looseless.
+
+Some extra bits trickery is involved in TIFF predictor function, when components doesn't fit bytes boundary. In that case,
+an input is treated as an bits stream. Every input byte is "buffered" in a larger integer, as its lower bits (from right).
+Every output value is taken from its higher (left) bits. In a special case of bits-per-component equal 1, we buffer all
+pixel bits and use XOR to compute bits difference between pixels. I've excerpted that trick from poppler, but I'm not
+really sure if it works any better, especially when the number of components per pixel is 1. In that case we do a hard
+bit-by-bit work anyway.
+
+Predictor codecs state keeps a notion of surrounding pixels. PNG predictors uses left, up and upleft
+pixel data, while TIFF predictor (2) only needs the previous (left) pixel. Important to note that PNG
+predictors always work on bytes, no matter of color-depth (bits per component), while TIFF predictor
+works on pixel components, which not necessarily fits into a complete byte. However, for PNG predictor
+the size of a pixel still matters, because 'left' and 'upleft' refers to a corresponding pixel byte,
+not necessarily previous byte.
+
+In PNG prediction, we record every pixel byte (in decoded form) in state->rowsave. At the end of a scanline
+we copy state->rowsave to state->rowup, so that in the next scanline we can access up-pixel byte.
+Left pixel byte is accessed as state->rowsave (the byte recently stored or virtual left edge byte \0).
+Up-left pixel byte is accessed via state->rowup, but with state->pixelsize offset (same as left byte, possibly \0
+at the left edge of the row). Both state->rowup and state->rowsave has a safe span of pixelsize bytes on the left,
+that are permanently \0.
+*/
+
+#define predictor_component_t unsigned short
+#define predictor_pixel1b_t unsigned int
+
+typedef struct predictor_state {
+  int default_predictor;                      /* default predictor indicator */
+  int current_predictor;                      /* current predictor, possibly taken from algorithm marker in PNG data */
+  int rowsamples;                             /* number of pixels in a scanline (/DecodeParms << /Columns ... >>) */
+  int compbits;                               /* number of bits per component (/DecodeParms << /BitsPerComponent ... >>) */
+  int components;                             /* number of components (/DecodeParms << /Colors ... >>) */
+  uint8_t *buffer;                            /* temporary private buffer area */
+  uint8_t *rowin;                             /* an input row buffer position */
+  int rowsize;                                /* size of a current scanline in bytes (rounded up) */
+  int rowend;                                 /* an input buffer end position */
+  int rowindex;                               /* an output buffer position */
+  union {
+    struct {                                  /* used by PNG predictor codecs */
+      uint8_t *rowup, *rowsave;               /* previous scanline buffers */
+      int predictorbyte;                      /* flag indicating that algorithm byte is read/written */
+      int pixelsize;                          /* number of bytes per pixel (rounded up) */
+    };
+    struct {                                  /* used by TIFF predictor codecs */
+      union {
+        predictor_component_t *prevcomp;      /* an array of left pixel components */
+        predictor_pixel1b_t *prevpixel;       /* left pixel value stored on a single integer (for 1bit color-depth) */
+      };
+      int compin, compout;                    /* bit stream buffers */
+      int bitsin, bitsout;                    /* bit stream counters */
+      int sampleindex;                        /* pixel counter */
+      int compindex;                          /* component counter */
+      int pixbufsize;                         /* size of pixel buffer in bytes */
+    };
+  };
+  int flush;
+  int status;
+} predictor_state;
+
+enum {
+  STATUS_LAST = 0,
+  STATUS_CONTINUE = 1 // any value different then IOFEOF, IOFERR, ...
+};
+
+predictor_state * predictor_decoder_init (predictor_state *state, int predictor, int rowsamples, int components, int compbits)
+{
+  int rowsize, pixelsize;
+#define storage_pos(b, p, size) ((b = p), (p += size))
+  uint8_t *buffer, *p;
+  size_t buffersize;
+
+  pixelsize = (components * compbits + 7) >> 3; // to bytes, rounded up
+  rowsize = (rowsamples * components * compbits + 7) >> 3;
+
+  state->default_predictor = state->current_predictor = predictor;
+  state->rowsamples = rowsamples;
+  state->components = components;
+  state->compbits = compbits;
+
+  if (predictor == 2)
+  { /* tiff predictor */
+    size_t compbuf, pixbuf;
+    compbuf = state->components * sizeof(predictor_component_t);
+    pixbuf = 1 * sizeof(predictor_pixel1b_t);
+    state->pixbufsize = (int)(compbuf > pixbuf ? compbuf : pixbuf);
+    buffersize = rowsize + state->pixbufsize;
+    buffer = (uint8_t *)util_calloc(buffersize, 1);
+#if defined __arm__ || defined __ARM__ || defined ARM || defined __ARM || defined __arm || defined __ARM_ARCH ||defined __aarch64__ 
+    { /*memory leak */
+      predictor_component_t *c;
+      if (state->pixbufsize%(sizeof(predictor_component_t))) {
+       c = malloc(state->pixbufsize - state->pixbufsize%(sizeof(predictor_component_t)) + sizeof(predictor_component_t) );
+      } else {
+       c = malloc(state->pixbufsize); 
+      }
+      memcpy(c,(state->rowin + rowsize),state->pixbufsize);
+      if (state->prevcomp){
+	free(state->prevcomp);
+      }
+      state->prevcomp = c;
+    }
+#else
+    state->prevcomp = (predictor_component_t *)(state->rowin + rowsize);
+#endif			
+    state->sampleindex = state->compindex = 0;
+    state->bitsin = state->bitsout = 0;
+    state->compin = state->compout = 0;
+  }
+  else
+  { /* png predictors */
+    buffersize = (3 * rowsize + 2 * pixelsize + 1) * sizeof(uint8_t);
+    p = buffer = (uint8_t *)util_calloc(buffersize, 1);
+    storage_pos(state->rowin, p, 1 + rowsize); // one extra byte for prediction algorithm tag
+    p += pixelsize;                            // pixelsize extra bytes for virtual left pixel at the edge, eg. rowup[-1] (permanently \0)
+    storage_pos(state->rowup, p, rowsize);     // actual row byte
+    p += pixelsize;                            // ditto
+    storage_pos(state->rowsave, p, rowsize);
+    state->pixelsize = pixelsize;
+    state->predictorbyte = 0;
+  }
+  state->buffer = buffer;
+  state->rowsize = rowsize;
+  state->rowindex = 0;
+  state->rowend = 0;
+  state->status = STATUS_CONTINUE;
+  return state;
+}
+
+predictor_state * predictor_encoder_init (predictor_state *state, int predictor, int rowsamples, int components, int compbits)
+{
+  return predictor_decoder_init(state, predictor, rowsamples, components, compbits);
+}
+
+void predictor_decoder_close (predictor_state *state)
+{
+  util_free(state->buffer);
+}
+
+void predictor_encoder_close (predictor_state *state)
+{
+  util_free(state->buffer);
+}
+
+/*
+Predictor type identifiers (pdf spec 76). lpdf doesn't hire the codec if predictor is 1. Predictor 15 indicates
+that the type of PNG prediction algorithm may change in subsequent lines. We always check algorithm marker anyway.
+*/
+
+enum predictor_code {
+  NONE_PREDICTOR = 1,
+  TIFF_PREDICTOR = 2,
+  PNG_NONE_PREDICTOR = 10,
+  PNG_SUB_PREDICTOR = 11,
+  PNG_UP_PREDICTOR = 12,
+  PNG_AVERAGE_PREDICTOR = 13,
+  PNG_PAETH_PREDICTOR = 14,
+  PNG_OPTIMUM_PREDICTOR = 15
+};
+
+/*
+All predoctor codecs first read the entire data row into a buffer. This is not crucial for the process,
+but allows to separate read/write states. In particular, there is one place in which codec functions
+may return on EOD.
+*/
+
+#define start_row(state) (state->rowindex = 0, state->rowin = state->buffer)
+
+static int read_scanline (predictor_state *state, iof *I, int size)
+{
+  int rowtail, left;
+  while ((rowtail = size - state->rowend) > 0)
+  {
+    left = (int)iof_left(I);
+    if (left >= rowtail)
+    {
+      memcpy(state->buffer + state->rowend, I->pos, (size_t)rowtail);
+      state->rowend += rowtail;
+      I->pos += rowtail;
+      start_row(state);
+      break;
+    }
+    else
+    {
+      if ((rowtail = left) > 0)
+      {
+        memcpy(state->buffer + state->rowend, I->pos, (size_t)rowtail);
+        state->rowend += rowtail;
+        I->pos += rowtail;
+      }
+      if (iof_input(I) == 0)
+      {
+        if (state->rowend == 0) // no scanline to process, no more input
+          return state->flush ? IOFEOF : IOFEMPTY;
+        /* If we are here, there is an incomplete scanline in buffer:
+           - if there is a chance for more (state->flush == 0), than wait for more
+           - otherwise encode/decode the last incomplete line?
+           pdf spec p. 76 says that "A row occupies a whole number of bytes",
+           so this situation should be considered abnormal (not found so far).
+         */
+        if (!state->flush)
+          return IOFEMPTY;
+        loggerf("incomplete scanline in predictor filter");
+        //return IOFERR;
+        state->status = STATUS_LAST;
+        state->rowsize -= size - state->rowend;
+        start_row(state);
+        break;
+      }
+    }
+  }
+  return STATUS_CONTINUE;
+}
+
+#define read_row(state, I, size, status) if ((status = read_scanline(state, I, size)) != STATUS_CONTINUE) return status
+
+#define ensure_output_bytes(O, n) if (!iof_ensure(O, n)) return IOFFULL
+
+#define tobyte(c) ((unsigned char)(c))
+#define tocomp(c) ((unsigned short)(c))
+
+#define row_byte(state) (state->rowin[state->rowindex])
+
+#define up_pixel_byte(state)     (state->rowup[state->rowindex])
+#define upleft_pixel_byte(state) (state->rowup[state->rowindex - state->pixelsize])
+#define left_pixel_byte(state)   (state->rowsave[state->rowindex - state->pixelsize])
+
+#define save_pixel_byte(state, c) (state->rowsave[state->rowindex] = c)
+
+#define left_pixel_component(state) (state->prevcomp[state->compindex]) // tiff predictor with 2, 4, 8, 16 components
+#define left_pixel_value(state) (state->prevpixel[0])                   // tiff predictor with 1bit components
+
+#define save_pixel_component(state, c) ((void)\
+  ((state->prevcomp[state->compindex] = c), \
+   (++state->compindex < state->components || (state->compindex = 0))))
+
+#define save_pixel_value(state, c) (state->prevpixel[0] = c)
+
+/* Once the codec function is done with the scanline, we set imaginary left pixel data to zero, and reset row counters to
+zero in order to allow buffering another input scanline. */
+
+#define reset_row(state) state->rowend = 0
+
+#define reset_png_row(state) (memcpy(state->rowup, state->rowsave, state->rowsize), state->predictorbyte = 0, reset_row(state))
+
+#define reset_tiff_row(state) \
+  memset(state->prevcomp, 0, state->pixbufsize), \
+  state->bitsin = state->bitsout = 0, \
+  state->compin = state->compout = 0, \
+  reset_row(state), \
+  state->sampleindex = state->compindex = 0
+
+/* PNG paeth predictor function; http://www.libpng.org/pub/png/book/chapter09.html
+Compute the base value p := left + up - upleft, then choose that byte the closest
+(of the smallest absolute difference) to the base value. Left byte has a precedence. */
+
+
+static int paeth (predictor_state *state)
+{
+  int p, p1, p2, p3;
+  p = left_pixel_byte(state) + up_pixel_byte(state) - upleft_pixel_byte(state);
+  p1 = p >= left_pixel_byte(state)   ? (p - left_pixel_byte(state))   : (left_pixel_byte(state) - p);
+  p2 = p >= up_pixel_byte(state)     ? (p - up_pixel_byte(state))     : (up_pixel_byte(state) - p);
+  p3 = p >= upleft_pixel_byte(state) ? (p - upleft_pixel_byte(state)) : (upleft_pixel_byte(state) - p);
+  return (p1 <= p2 && p1 <= p3) ? left_pixel_byte(state) : (p2 <= p3 ? up_pixel_byte(state) : upleft_pixel_byte(state));
+}
+
+/* predictor decoder */
+
+iof_status predictor_decode_state (iof *I, iof *O, predictor_state *state)
+{
+  int status, c, d, outbytes;
+  while (state->status == STATUS_CONTINUE)
+  {
+    if (state->default_predictor >= 10) // PNG predictor?
+    {
+      read_row(state, I, state->rowsize + 1, status);
+      if (state->predictorbyte == 0)
+      { // we could actually check state->rowin <> state->buffer, but we need this flag for encoder anyway
+        state->current_predictor = row_byte(state) + 10;
+        state->predictorbyte = 1;
+        ++state->rowin;
+      }
+    }
+    else
+    {
+      read_row(state, I, state->rowsize, status);
+    }
+    switch (state->current_predictor)
+    {
+      case NONE_PREDICTOR:
+        for ( ; state->rowindex < state->rowsize; ++state->rowindex)
+        {
+          ensure_output_bytes(O, 1);
+          c = row_byte(state);
+          iof_set(O, c);
+        }
+        reset_row(state);
+        break;
+      case TIFF_PREDICTOR:
+        switch (state->compbits)
+        {
+          case 1:
+            outbytes = (state->components + 7) >> 3;
+            for ( ; state->sampleindex < state->rowsamples; ++state->sampleindex)
+            {
+              ensure_output_bytes(O, outbytes);
+              while (state->bitsin < state->components)
+              {
+                state->compin = (state->compin << 8) | row_byte(state);
+                state->bitsin += 8;
+                ++state->rowindex;
+              }
+              state->bitsin -= state->components;
+              d = state->compin >> state->bitsin;
+              state->compin &= (1 << state->bitsin) - 1;
+              c = d ^ left_pixel_value(state);
+              save_pixel_value(state, c);
+              state->compout = (state->compout << state->components) | c;
+              state->bitsout += state->components;
+              while (state->bitsout >= 8)
+              {
+                state->bitsout -= 8;
+                iof_set(O, state->compout >> state->bitsout);
+                state->compout &= (1 << state->bitsout) - 1;
+              }
+            }
+            if (state->bitsout > 0)
+            {
+              ensure_output_bytes(O, 1);
+              iof_set(O, state->compin << (8 - state->bitsout));
+            }
+            break;
+          case 2: case 4:
+            for ( ; state->sampleindex < state->rowsamples; ++state->sampleindex)
+            {
+              for ( ; state->compindex < state->components; ) // state->compindex is ++ed  by save_pixel_component()
+              {
+                ensure_output_bytes(O, 1);
+                if (state->bitsin < state->compbits)
+                {
+                  state->compin = (state->compin << 8) | row_byte(state);
+                  state->bitsin += 8;
+                  ++state->rowindex;
+                }
+                state->bitsin -= state->compbits;
+                d = state->compin >> state->bitsin;
+                state->compin &= (1 << state->bitsin) - 1;
+                c = (d + left_pixel_component(state)) & 0xff;
+                save_pixel_component(state, c);
+                state->compout = (state->compout << state->compbits) | c;
+                state->bitsout += state->compbits;
+                if (state->bitsout >= 8)
+                {
+                  state->bitsout -= 8;
+                  iof_set(O, state->compout >> state->bitsout);
+                  state->compout &= (1 << state->bitsout) - 1;
+                }
+              }
+            }
+            if (state->bitsout > 0)
+            {
+              ensure_output_bytes(O, 1);
+              iof_set(O, state->compin << (8 - state->bitsout));
+            }
+            break;
+          case 8:
+            for ( ; state->rowindex < state->rowsize; ++state->rowindex)
+            {
+              ensure_output_bytes(O, 1);
+              c = (row_byte(state) + left_pixel_component(state)) & 0xff;
+              save_pixel_component(state, c);
+              iof_set(O, c);
+            }
+            break;
+          case 16:
+            for ( ; state->rowindex < state->rowsize - 1; ++state->rowindex)
+            {
+              ensure_output_bytes(O, 2);
+              d = row_byte(state) << 8;
+              ++state->rowindex;
+              d |= row_byte(state);
+              c = (d + left_pixel_component(state)) & 0xff;
+              save_pixel_component(state, c);
+              iof_set2(O, c >> 8, c & 0xff);
+            }
+            break;
+          default:
+            return IOFERR;
+        }
+        reset_tiff_row(state);
+        break;
+      case PNG_NONE_PREDICTOR:
+        for ( ; state->rowindex < state->rowsize; ++state->rowindex)
+        {
+          ensure_output_bytes(O, 1);
+          c = row_byte(state);
+          save_pixel_byte(state, c); // next row may need it
+          iof_set(O, c);
+        }
+        reset_png_row(state);
+        break;
+      case PNG_SUB_PREDICTOR:
+        for ( ; state->rowindex < state->rowsize; ++state->rowindex)
+        {
+          ensure_output_bytes(O, 1);
+          c = (row_byte(state) + left_pixel_byte(state)) & 0xff;
+          save_pixel_byte(state, c);
+          iof_set(O, c);
+        }
+        reset_png_row(state);
+        break;
+      case PNG_UP_PREDICTOR:
+        for ( ; state->rowindex < state->rowsize; ++state->rowindex)
+        {
+          ensure_output_bytes(O, 1);
+          c = (row_byte(state) + up_pixel_byte(state)) & 0xff;
+          save_pixel_byte(state, c);
+          iof_set(O, c);
+        }
+        reset_png_row(state);
+        break;
+      case PNG_AVERAGE_PREDICTOR:
+        for ( ; state->rowindex < state->rowsize; ++state->rowindex)
+        {
+          ensure_output_bytes(O, 1);
+          c = (row_byte(state) + ((up_pixel_byte(state) + left_pixel_byte(state)) / 2)) & 0xff;
+          save_pixel_byte(state, c);
+          iof_set(O, c);
+        }
+        reset_png_row(state);
+        break;
+      case PNG_PAETH_PREDICTOR:
+        for ( ; state->rowindex < state->rowsize; ++state->rowindex)
+        {
+          ensure_output_bytes(O, 1);
+          c = (row_byte(state) + paeth(state)) & 0xff;
+          save_pixel_byte(state, c);
+          iof_set(O, c);
+        }
+        reset_png_row(state);
+        break;
+      //case PNG_OPTIMUM_PREDICTOR: // valid as default_redictor, but not as algorithm identifier byte
+      default:
+        return IOFERR;
+    }
+  }
+  return state->status == STATUS_LAST ? IOFERR : IOFEOF;
+}
+
+/* predictor encoder */
+
+iof_status predictor_encode_state (iof *I, iof *O, predictor_state *state)
+{
+  int status, c, d, outbytes;
+  while (state->status == STATUS_CONTINUE)
+  {
+    read_row(state, I, state->rowsize, status);
+    if (state->current_predictor >= 10 && state->predictorbyte == 0)
+    {
+      ensure_output_bytes(O, 1);
+      iof_set(O, state->current_predictor - 10);
+      state->predictorbyte = 1;
+    }
+    switch (state->current_predictor)
+    {
+      case NONE_PREDICTOR:
+        for ( ; state->rowindex < state->rowsize; ++state->rowindex)
+        {
+          ensure_output_bytes(O, 1);
+          c = row_byte(state);
+          iof_set(O, c);
+        }
+        reset_row(state);
+        break;
+      case TIFF_PREDICTOR:
+        switch (state->compbits)
+        {
+          case 1:
+            outbytes = (state->components + 7) >> 3;
+            for ( ; state->sampleindex < state->rowsamples; ++state->sampleindex)
+            {
+              ensure_output_bytes(O, outbytes);
+              while (state->bitsin < state->components)
+              {
+                state->compin = (state->compin << 8) | row_byte(state);
+                state->bitsin += 8;
+                ++state->rowindex;
+              }
+              state->bitsin -= state->components;
+              c = state->compin >> state->bitsin;
+              state->compin &= (1 << state->bitsin) - 1;
+              d = c ^ left_pixel_value(state);
+              save_pixel_value(state, c);
+              state->compout = (state->compout << state->components) | d;
+              state->bitsout += state->components;
+              while (state->bitsout >= 8)
+              {
+                state->bitsout -= 8;
+                iof_set(O, state->compout >> state->bitsout);
+                state->compout &= (1 << state->bitsout) - 1;
+              }
+            }
+            if (state->bitsout > 0)
+            {
+              ensure_output_bytes(O, 1);
+              iof_set(O, state->compin << (8 - state->bitsout));
+            }
+            break;
+          case 2: case 4:
+            for ( ; state->sampleindex < state->rowsamples; ++state->sampleindex)
+            {
+              for ( ; state->compindex < state->components; )
+              {
+                ensure_output_bytes(O, 1);
+                if (state->bitsin < state->compbits)
+                {
+                  state->compin = (state->compin << 8) | row_byte(state);
+                  state->bitsin += 8;
+                  ++state->rowindex;
+                }
+                state->bitsin -= state->compbits;
+                c = state->compin >> state->bitsin;
+                state->compin &= (1 << state->bitsin) - 1;
+                d = tocomp(c - left_pixel_component(state));
+                save_pixel_component(state, c);
+                state->compout = (state->compout << state->compbits) | d;
+                state->bitsout += state->compbits;
+                if (state->bitsout >= 8)
+                {
+                  state->bitsout -= 8;
+                  iof_set(O, state->compout >> state->bitsout);
+                  state->compout &= (1 << state->bitsout) - 1;
+                }
+              }
+            }
+            if (state->bitsout > 0)
+            {
+              ensure_output_bytes(O, 1);
+              iof_set(O, state->compin << (8 - state->bitsout));
+            }
+            break;
+          case 8:
+            for ( ; state->rowindex < state->rowsize; ++state->rowindex)
+            {
+              ensure_output_bytes(O, 1);
+              c = row_byte(state);
+              d = tobyte(c - left_pixel_component(state));
+              save_pixel_component(state, c);
+              iof_set(O, d);
+            }
+            break;
+          case 16:
+            for ( ; state->rowindex < state->rowsize - 1; ++state->rowindex)
+            {
+              ensure_output_bytes(O, 2);
+              c = row_byte(state) << 8;
+              ++state->rowindex;
+              c |= row_byte(state);
+              d = tocomp(c - left_pixel_component(state));
+              save_pixel_component(state, c);
+              iof_set2(O, d >> 8, d & 0xff);
+            }
+            break;
+          default:
+            return IOFERR;
+        }
+        reset_tiff_row(state);
+        break;
+      case PNG_NONE_PREDICTOR:
+        for ( ; state->rowindex < state->rowsize; ++state->rowindex)
+        {
+          ensure_output_bytes(O, 1);
+          c = row_byte(state);
+          save_pixel_byte(state, c); // next row may need it
+          iof_set(O, c);
+        }
+        reset_png_row(state);
+        break;
+      case PNG_SUB_PREDICTOR:
+        for ( ; state->rowindex < state->rowsize; ++state->rowindex)
+        {
+          ensure_output_bytes(O, 1);
+          c = row_byte(state);
+          d = tobyte(c - left_pixel_byte(state));
+          save_pixel_byte(state, c);
+          iof_set(O, d);
+        }
+        reset_png_row(state);
+        break;
+      case PNG_OPTIMUM_PREDICTOR: // not worthy to perform optimization
+      case PNG_UP_PREDICTOR:
+        for ( ; state->rowindex < state->rowsize; ++state->rowindex)
+        {
+          ensure_output_bytes(O, 1);
+          c = row_byte(state);
+          d = tobyte(c - up_pixel_byte(state));
+          save_pixel_byte(state, c);
+          iof_set(O, d);
+        }
+        reset_png_row(state);
+        break;
+      case PNG_AVERAGE_PREDICTOR:
+        for ( ; state->rowindex < state->rowsize; ++state->rowindex)
+        {
+          ensure_output_bytes(O, 1);
+          c = row_byte(state);
+          d = tobyte(c - ((up_pixel_byte(state) + left_pixel_byte(state)) >> 1));
+          save_pixel_byte(state, c);
+          iof_set(O, d);
+        }
+        reset_png_row(state);
+        break;
+      case PNG_PAETH_PREDICTOR:
+        for ( ; state->rowindex < state->rowsize; ++state->rowindex)
+        {
+          ensure_output_bytes(O, 1);
+          c = row_byte(state);
+          d = tobyte(c - paeth(state));
+          save_pixel_byte(state, c);
+          iof_set(O, d);
+        }
+        reset_png_row(state);
+        break;
+      default:
+        return IOFERR;
+    }
+  }
+  return state->status == STATUS_LAST ? IOFERR : IOFEOF;
+}
+
+iof_status predictor_decode (iof *I, iof *O, int predictor, int rowsamples, int components, int compbits)
+{
+  predictor_state state;
+  int ret;
+  predictor_decoder_init(&state, predictor, rowsamples, components, compbits);
+  state.flush = 1;
+  ret = predictor_decode_state(I, O, &state);
+  predictor_decoder_close(&state);
+  return ret;
+}
+
+iof_status predictor_encode (iof *I, iof *O, int predictor, int rowsamples, int components, int compbits)
+{
+  predictor_state state;
+  int ret;
+  predictor_encoder_init(&state, predictor, rowsamples, components, compbits);
+  state.flush = 1;
+  ret = predictor_encode_state(I, O, &state);
+  predictor_encoder_close(&state);
+  return ret;
+}
+
+/* filters */
+
+// predictor decoder function
+
+static size_t predictor_decoder (iof *F, iof_mode mode)
+{
+  predictor_state *state;
+  iof_status status;
+  size_t tail;
+
+  state = iof_filter_state(predictor_state *, F);
+  switch(mode)
+  {
+    case IOFLOAD:
+    case IOFREAD:
+      if (F->flags & IOF_STOPPED)
+        return 0;
+      tail = iof_tail(F);
+      F->pos = F->buf + tail;
+      F->end = F->buf + F->space;
+      do {
+        status = predictor_decode_state(F->next, F, state);
+      } while (mode == IOFLOAD && status == IOFFULL && iof_resize_buffer(F));
+      return iof_decoder_retval(F, "predictor", status);
+    case IOFCLOSE:
+      predictor_decoder_close(state);
+      iof_free(F);
+      return 0;
+    default:
+      break;
+  }
+  return 0;
+}
+
+// predictor encoder function
+
+static size_t predictor_encoder (iof *F, iof_mode mode)
+{
+  predictor_state *state;
+  iof_status status;
+
+  state = iof_filter_state(predictor_state *, F);
+  switch (mode)
+  {
+    case IOFFLUSH:
+      state->flush = 1;
+      // fall through
+    case IOFWRITE:
+      F->end = F->pos;
+      F->pos = F->buf;
+      status = predictor_encode_state(F, F->next, state);
+      return iof_encoder_retval(F, "predictor", status);
+    case IOFCLOSE:
+      if (!state->flush)
+        predictor_encoder(F, IOFFLUSH);
+      predictor_encoder_close(state);
+      iof_free(F);
+      return 0;
+    default:
+      break;
+  }
+  return 0;
+}
+
+iof * iof_filter_predictor_decoder (iof *N, int predictor, int rowsamples, int components, int compbits)
+{
+  iof *I;
+  predictor_state *state;
+  I = iof_filter_reader(predictor_decoder, sizeof(predictor_state), &state);
+  iof_setup_next(I, N);
+  if (predictor_decoder_init(state, predictor, rowsamples, components, compbits) == NULL)
+  {
+    iof_discard(I);
+    return NULL;
+  }
+  state->flush = 1;
+  return I;
+}
+
+iof * iof_filter_predictor_encoder (iof *N, int predictor, int rowsamples, int components, int compbits)
+{
+  iof *O;
+  predictor_state *state;
+  O = iof_filter_writer(predictor_encoder, sizeof(predictor_state), &state);
+  iof_setup_next(O, N);
+  if (predictor_encoder_init(state, predictor, rowsamples, components, compbits) == NULL)
+  {
+    iof_discard(O);
+    return NULL;
+  }
+  return O;
+}
diff --git a/texk/web2c/luatexdir/luapplib/util/utilfpred.h b/texk/web2c/luatexdir/luapplib/util/utilfpred.h
new file mode 100644
index 000000000..6ae2f8935
--- /dev/null
+++ b/texk/web2c/luatexdir/luapplib/util/utilfpred.h
@@ -0,0 +1,23 @@
+#ifndef UTIL_FILTER_PREDICTOR_H
+#define UTIL_FILTER_PREDICTOR_H
+
+#include "utiliof.h"
+
+typedef struct predictor_state predictor_state;
+
+predictor_state * predictor_decoder_init (predictor_state *state, int predictor, int rowsamples, int components, int compbits);
+predictor_state * predictor_encoder_init (predictor_state *state, int predictor, int rowsamples, int components, int compbits);
+
+void predictor_decoder_close (predictor_state *state);
+void predictor_encoder_close (predictor_state *state);
+
+iof_status predictor_decode_state (iof *I, iof *O, predictor_state *state);
+iof_status predictor_encode_state (iof *I, iof *O, predictor_state *state);
+
+iof_status predictor_decode (iof *I, iof *O, int predictor, int rowsamples, int components, int compbits);
+iof_status predictor_encode (iof *I, iof *O, int predictor, int rowsamples, int components, int compbits);
+
+iof * iof_filter_predictor_decoder (iof *N, int predictor, int rowsamples, int components, int compbits);
+iof * iof_filter_predictor_encoder (iof *N, int predictor, int rowsamples, int components, int compbits);
+
+#endif
\ No newline at end of file
diff --git a/texk/web2c/luatexdir/luapplib/util/utiliof.c b/texk/web2c/luatexdir/luapplib/util/utiliof.c
new file mode 100644
index 000000000..7d07cf12d
--- /dev/null
+++ b/texk/web2c/luatexdir/luapplib/util/utiliof.c
@@ -0,0 +1,2949 @@
+/* input/iutput stream */
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdarg.h>
+
+#include "utilmem.h"
+#include "utillog.h"
+#include "utiliof.h"
+
+/* commons */
+
+void * iof_copy_data (const void *data, size_t size)
+{
+  return memcpy(util_malloc(size), data, size);
+}
+
+uint8_t * iof_copy_file_data (const char *filename, size_t *psize)
+{
+  FILE *file;
+  size_t size;
+  uint8_t *data;
+  if ((file = fopen(filename, "rb")) == NULL)
+    return NULL;
+  fseek(file, 0, SEEK_END);
+  size = (size_t)ftell(file);
+  data = (uint8_t *)util_malloc(size);
+  fseek(file, 0, SEEK_SET);
+  if ((*psize = fread(data, 1, size, file)) != size)
+  {
+    util_free(data);
+    data = NULL;
+  }
+  fclose(file);
+  return data;
+}
+
+uint8_t * iof_copy_file_handle_data (FILE *file, size_t *psize)
+{
+  size_t size;
+  uint8_t *data;
+  //long offset = ftell(file); // keep offset intact?
+  fseek(file, 0, SEEK_END);
+  size = (size_t)ftell(file);
+  data = (uint8_t *)util_malloc(size);
+  fseek(file, 0, SEEK_SET);
+  if ((*psize = fread(data, 1, size, file)) != size)
+  {
+    util_free(data);
+    data = NULL;
+  }
+  //fseek(file, offset, SEEK_SET)
+  return data;
+}
+
+FILE * iof_get_file (iof *F)
+{
+  if (F->flags & IOF_FILE)
+    return iof_file_get_file(F->iofile);
+  if (F->flags & IOF_FILE_HANDLE)
+    return F->file;
+  return NULL;
+}
+
+const char * iof_status_kind (iof_status status)
+{
+  switch (status)
+  {
+    case IOFEOF:
+      return "IOFEOF";
+    case IOFERR:
+      return "IOFERR";
+    case IOFEMPTY:
+      return "IOFEMPTY";
+    case IOFFULL:
+      return "IOFFULL";
+    default:
+      break;
+  }
+  return "(unknown)";
+}
+
+/* shared pseudofile */
+
+#define IOF_FILE_DEFAULTS 0
+
+iof_file * iof_file_new (FILE *file)
+{
+  iof_file *iofile = (iof_file *)util_malloc(sizeof(iof_file));
+  iof_file_set_fh(iofile, file);
+  iofile->offset = NULL;
+  iofile->size = 0;
+  iofile->name = NULL;
+  iofile->refcount = 0;
+  iofile->flags = IOF_FILE_DEFAULTS|IOF_ALLOC;
+  return iofile;
+}
+
+iof_file * iof_file_init (iof_file *iofile, FILE *file)
+{
+  iof_file_set_fh(iofile, file);
+  iofile->offset = NULL;
+  iofile->size = 0;
+  iofile->name = NULL;
+  iofile->refcount = 0;
+  iofile->flags = IOF_FILE_DEFAULTS;
+  return iofile;
+}
+
+iof_file * iof_file_rdata (const void *data, size_t size)
+{
+  iof_file *iofile = (iof_file *)util_malloc(sizeof(iof_file));
+  iofile->rbuf = iofile->rpos = (const uint8_t *)data;
+  iofile->rend = iofile->rbuf + size;
+  iofile->offset = NULL;
+  iofile->size = 0;
+  iofile->name = NULL;
+  iofile->refcount = 0;
+  iofile->flags = IOF_FILE_DEFAULTS|IOF_ALLOC|IOF_DATA;
+  return iofile;
+}
+
+iof_file * iof_file_rdata_init (iof_file *iofile, const void *data, size_t size)
+{
+  iofile->rbuf = iofile->rpos = (const uint8_t *)data;
+  iofile->rend = iofile->rbuf + size;
+  iofile->offset = NULL;
+  iofile->size = 0; // letse keep it consequently set to zero (only for user disposal)
+  iofile->name = NULL;
+  iofile->refcount = 0;
+  iofile->flags = IOF_FILE_DEFAULTS|IOF_DATA;
+  return iofile;
+}
+
+iof_file * iof_file_wdata (void *data, size_t size)
+{
+  return iof_file_rdata((const void *)data, size);
+}
+
+iof_file * iof_file_wdata_init (iof_file *iofile, void *data, size_t size)
+{
+  return iof_file_rdata_init(iofile, (const void *)data, size);
+}
+
+/* typical uses so far */
+
+iof_file * iof_file_reader_from_file_handle (iof_file *iofile, const char *filename, FILE *file, int preload, int closefile)
+{
+  uint8_t *data;
+  size_t size;
+
+  if (preload)
+  {
+    if ((data = iof_copy_file_handle_data(file, &size)) == NULL)
+    {
+      if (closefile)
+        fclose(file);
+      return NULL;
+    }
+    if (iofile == NULL)
+      iofile = iof_file_rdata(data, size);
+    else
+      iof_file_rdata_init(iofile, data, size);
+    iofile->flags |= IOF_BUFFER_ALLOC;
+    if (closefile)
+      fclose(file);
+  }
+  else
+  {
+    if (iofile == NULL)
+      iofile = iof_file_new(file);
+    else
+      iof_file_init(iofile, file);
+    if (closefile)
+      iofile->flags |= IOF_CLOSE_FILE;
+  }
+  if (filename != NULL)
+    iof_file_set_name(iofile, filename);
+  return iofile;
+}
+
+iof_file * iof_file_reader_from_file (iof_file *iofile, const char *filename, int preload)
+{
+  FILE *file;
+  if ((file = fopen(filename, "rb")) == NULL)
+    return NULL;
+  return iof_file_reader_from_file_handle(iofile, filename, file, preload, 1);
+}
+
+iof_file * iof_file_reader_from_data (iof_file *iofile, const void *data, size_t size, int preload, int freedata)
+{
+  void *newdata;
+  if (data == NULL)
+    return NULL;
+  if (preload)
+  {
+    newdata = iof_copy_data(data, size);
+    if (iofile == NULL)
+      iofile = iof_file_rdata(newdata, size);
+    else
+      iof_file_rdata_init(iofile, newdata, size);
+    iofile->flags |= IOF_BUFFER_ALLOC;
+    //if (freedata) // hardly makes sense...  we can't free const void *
+    //  util_free((void *)data);
+  }
+  else
+  {
+    if (iofile == NULL)
+      iofile = iof_file_rdata(data, size);
+    else
+      iof_file_rdata_init(iofile, data, size);
+    if (freedata)
+      iofile->flags |= IOF_BUFFER_ALLOC;
+  }
+  return iofile;
+}
+
+/*
+iof_file * iof_file_writer_from_file (iof_file *iofile, const char *filename)
+{
+  FILE *file;
+  if ((file = fopen(filename, "wb")) == NULL)
+    return NULL;
+  if (iofile == NULL)
+    iofile = iof_file_new(file);
+  else
+    iof_file_init(iofile, file);
+  iofile->flags |= IOF_CLOSE_FILE;
+  iof_file_set_name(iofile, filename);
+  return iofile;
+}
+*/
+
+/*
+Because of limited number of FILE* handles available, we may need to close contained handle
+between accessing it. In applications so far (fonts, images) we typically need the source
+to parse the file on creation and to rewrite or reload the data on dump. All iof_file api
+functions assume that iofile has FILE* opened. Reopening it on every access (ftell, fseek,
+read/write) makes no sense, as we would effectively loose control. If the caller invalidates
+iofile by closing and nulling its file handle, it is also responsible to reopen when necessary.
+*/
+
+int iof_file_close_input (iof_file *iofile)
+{
+  FILE *file;
+  if (iofile->flags & IOF_DATA)
+    return 0;
+  if ((file = iof_file_get_fh(iofile)) == NULL)
+    return 0;
+  fclose(file);
+  iof_file_set_fh(iofile, NULL);
+  iofile->flags &= ~IOF_RECLOSE_FILE;
+  iofile->flags |= IOF_REOPEN_FILE;
+  return 1;
+}
+
+int iof_file_reopen_input (iof_file *iofile)
+{ // returns true if iofile readable
+  FILE *file;
+  const char *filename;
+  if (iofile->flags & IOF_DATA)
+    return 1;
+  if ((file = iof_file_get_fh(iofile)) != NULL)
+    return 1; // if present, assumed readable
+  if ((filename = iofile->name) == NULL || (file = fopen(filename, "rb")) == NULL)
+    return 0;
+  iof_file_set_fh(iofile, file);
+  iofile->flags &= ~IOF_REOPEN_FILE;
+  iofile->flags |= IOF_RECLOSE_FILE;
+  return 1;
+}
+
+/* freeing iof_file */
+
+void iof_file_free (iof_file *iofile)
+{
+  FILE *file;
+  if (iofile->flags & IOF_DATA)
+  {
+    if (iofile->flags & IOF_BUFFER_ALLOC)
+    {
+      iofile->flags &= ~IOF_BUFFER_ALLOC;
+      if (iofile->buf != NULL)
+      {
+        util_free(iofile->buf);
+        iofile->buf = iofile->pos = iofile->end = NULL;
+      }
+    }
+  }
+  else if ((file = iof_file_get_fh(iofile)) != NULL)
+  {
+    if (iofile->flags & IOF_CLOSE_FILE)
+     	fclose(file);
+    iof_file_set_fh(iofile, NULL);
+  }
+  iof_file_set_name(iofile, NULL);
+  if (iofile->flags & IOF_ALLOC)
+    util_free(iofile);
+}
+
+/* set filename for reopen */
+
+void iof_file_set_name (iof_file *iofile, const char *name)
+{
+  if (iofile->name != NULL)
+    util_free(iofile->name);
+  if (name != NULL)
+    iofile->name = iof_copy_data(name, strlen(name) + 1);
+  else
+    iofile->name = NULL;
+}
+
+/* seek */
+
+int iof_file_seek (iof_file *iofile, long offset, int whence)
+{
+  if (iofile->flags & IOF_DATA)
+  {
+    switch (whence)
+    {
+      case SEEK_SET:
+        if (offset >= 0 && iofile->buf + offset <= iofile->end)
+        {
+          iofile->pos = iofile->buf + offset;
+          return 0;
+        }
+        return -1;
+      case SEEK_CUR:
+        if ((offset >= 0 && iofile->pos + offset <= iofile->end) || (offset < 0 && iofile->pos + offset >= iofile->buf))
+        {
+          iofile->pos += offset;
+          return 0;
+        }
+        return -1;
+      case SEEK_END:
+        if (offset <= 0 && iofile->end + offset >= iofile->buf)
+        {
+          iofile->pos = iofile->end + offset;
+          return 0;
+        }
+        return -1;
+    }
+    return -1;
+  }
+  return fseek(iof_file_get_fh(iofile), offset, whence);
+}
+
+/* */
+
+long iof_file_tell (iof_file *iofile)
+{
+  return (iofile->flags & IOF_DATA) ? (long)(iofile->pos - iofile->buf) : ftell(iof_file_get_fh(iofile));
+}
+
+size_t iof_file_size (iof_file *iofile)
+{ 
+  long pos, size;
+  FILE *file;
+  if (iofile->flags & IOF_DATA)
+    return (size_t)iof_space(iofile);
+  file = iof_file_get_fh(iofile);
+  pos = ftell(file);
+  fseek(file, 0, SEEK_END);
+  size = ftell(file);
+  fseek(file, pos, SEEK_SET);
+  return size;
+}
+
+int iof_file_eof (iof_file *iofile)
+{
+  if (iofile->flags & IOF_DATA)
+    return iofile->pos == iofile->end ? -1 : 0;
+  return feof(iof_file_get_fh(iofile));
+}
+
+int iof_file_flush (iof_file *iofile)
+{
+  if (iofile->flags & IOF_DATA)
+    return 0;
+  return fflush(iof_file_get_fh(iofile));
+}
+
+size_t iof_file_read (void *ptr, size_t size, size_t items, iof_file *iofile)
+{
+  if (iofile->flags & IOF_DATA)
+  {
+    size_t bytes = size * items;
+    if (bytes > (size_t)iof_left(iofile))
+      bytes = (size_t)iof_left(iofile);
+    memcpy(ptr, iofile->pos, bytes);
+    iofile->pos += bytes;
+    return bytes / size; // number of elements read
+  }
+  return fread(ptr, size, items, iof_file_get_fh(iofile));
+}
+
+static size_t iof_file_data_resizeto (iof_file *iofile, size_t space)
+{
+  uint8_t *newbuf;
+  size_t size;
+  size = iof_size(iofile);
+  if (iofile->flags & IOF_BUFFER_ALLOC)
+  {
+    newbuf = (uint8_t *)util_realloc(iofile->buf, space);
+  }
+  else
+  {
+    newbuf = (uint8_t *)util_malloc(space);
+    if (size > 0)
+      memcpy(newbuf, iofile->buf, size);
+    iofile->flags |= IOF_BUFFER_ALLOC;
+  }
+  iofile->buf = newbuf;
+  iofile->pos = newbuf + size;
+  iofile->end = newbuf + space;
+  return space - size;
+}
+
+#define iof_file_data_resize(iofile) iof_file_data_resizeto(iofile, iof_space(iofile) << 1)
+
+size_t iof_file_write (const void *ptr, size_t size, size_t items, iof_file *iofile)
+{
+  if (iofile->flags & IOF_DATA)
+  {
+    size_t space, sizesofar, bytes;
+    bytes = size * items;
+    if (bytes > (size_t)iof_left(iofile))
+    {      
+      if ((space = iof_space(iofile)) == 0) // allow iofile->buf/end initially NULL
+        space = BUFSIZ;
+      for (sizesofar = iof_size(iofile), space <<= 1; sizesofar + bytes > space; space <<= 1)
+        ;
+      if (iof_file_data_resizeto(iofile, space) == 0)
+        return 0;
+    }
+    memcpy(iofile->pos, ptr, bytes);
+    iofile->pos += bytes;
+    return bytes / size;
+  }
+  return fwrite(ptr, size, items, iof_file_get_fh(iofile));
+}
+
+size_t iof_file_ensure (iof_file *iofile, size_t bytes)
+{
+  if (iofile->flags & IOF_DATA)
+  {
+    size_t space, sizesofar, left;
+    left = (size_t)iof_left(iofile);
+    if (bytes > left)
+    {      
+      if ((space = iof_space(iofile)) == 0) // allow iofile->buf/end initially NULL
+        space = BUFSIZ;
+      for (sizesofar = iof_size(iofile), space <<= 1; sizesofar + bytes > space; space <<= 1);
+      return iof_file_data_resizeto(iofile, space);
+    }
+    return left;  
+  }
+  return 0;
+}
+
+int iof_file_getc (iof_file *iofile)
+{
+  if (iofile->flags & IOF_DATA)
+    return iofile->pos < iofile->end ? *iofile->pos++ : IOFEOF;
+  return fgetc(iof_file_get_fh(iofile));
+}
+
+int iof_file_putc (iof_file *iofile, int c)
+{
+  if (iofile->flags & IOF_DATA)
+  {
+    if (iofile->pos >= iofile->end)
+      if (iof_file_data_resize(iofile) == 0)
+        return IOFEOF;
+    *iofile->pos++ = (uint8_t)c;
+    return c;
+  }
+  return fputc(c, iof_file_get_fh(iofile));
+}
+
+static int iof_file_sync (iof_file *iofile, size_t *offset)
+{
+  if (iofile->offset != offset)
+  {
+    if (iofile->offset != NULL)
+      *iofile->offset = iof_file_tell(iofile);
+    iofile->offset = offset;
+    if (offset) // let offset be NULL
+      return iof_file_seek(iofile, (long)*offset, SEEK_SET);
+  }
+  return 0;
+}
+
+//#define iof_file_unsync(iofile, poffset) (void)((iofile)->offset == poffset && (((iofile)->offset = NULL), 0))
+#define iof_file_unsync(iofile, poffset) ((void)poffset, (iofile)->offset = NULL)
+
+/* iof seek */
+
+#define iof_reader_reset(I) ((I)->pos = (I)->end = (I)->buf)
+#define iof_reader_reseek_file(I, offset, whence) (fseek((I)->file, offset, whence) == 0 ? (iof_reader_reset(I), 0) : -1)
+#define iof_reader_reseek_iofile(I, offset, whence) (iof_file_seek((I)->iofile, offset, whence) == 0 ? (iof_reader_reset(I), 0) : -1)
+
+#define iof_writer_reset(O) ((O)->pos = (O)->buf)
+#define iof_writer_reseek_file(O, offset, whence) (iof_flush(O), (fseek((O)->file, offset, whence) == 0 ? (iof_writer_reset(O), 0) : -1))
+#define iof_writer_reseek_iofile(O, offset, whence) (iof_flush(O), (iof_file_seek((O)->iofile, offset, whence) == 0 ? (iof_writer_reset(O), 0) : -1))
+
+static int iof_reader_seek_data (iof *I, long offset, int whence)
+{
+  switch (whence)
+  {
+    case SEEK_SET:
+      if (offset >= 0 && I->buf + offset <= I->end)
+      {
+        I->pos = I->buf + offset;
+        return 0;
+      }
+      return -1;
+    case SEEK_CUR:
+      if ((offset >= 0 && I->pos + offset <= I->end) || (offset < 0 && I->pos + offset >= I->buf))
+      {
+        I->pos += offset;
+        return 0;
+      }
+      return -1;
+    case SEEK_END:
+      if (offset <= 0 && I->end + offset >= I->buf)
+      {
+        I->pos = I->end + offset;
+        return 0;
+      }
+      return -1;
+  }
+  return -1;
+}
+
+static int iof_reader_seek_iofile (iof *I, long offset, int whence)
+{
+  long fileoffset;
+  switch (whence)
+  {
+    case SEEK_SET:
+      fileoffset = iof_file_tell(I->iofile);
+      if (offset <= fileoffset && offset >= fileoffset - iof_space(I))
+      {
+        I->pos = I->end - (fileoffset - offset);
+        return 0;
+      }
+      return iof_reader_reseek_iofile(I, offset, SEEK_SET);
+    case SEEK_CUR:
+      if ((offset >= 0 && I->pos + offset <= I->end) || (offset < 0 && I->pos + offset >= I->buf))
+      {
+        I->pos += offset;
+        return 0;
+      }
+      return iof_reader_reseek_iofile(I, offset, SEEK_CUR);
+    case SEEK_END:
+      return iof_reader_reseek_iofile(I, offset, SEEK_END); // can we do better?
+  }
+  return -1;
+}
+
+static int iof_reader_seek_file (iof *I, long offset, int whence)
+{
+  long fileoffset;
+  switch (whence)
+  {
+    case SEEK_SET:
+      fileoffset = ftell(I->file);
+      if (offset <= fileoffset && offset >= fileoffset - iof_space(I))
+      {
+        I->pos = I->end - (fileoffset - offset);
+        return 0;
+      }
+      return iof_reader_reseek_file(I, offset, SEEK_SET);
+    case SEEK_CUR:
+      if ((offset >= 0 && I->pos + offset <= I->end) || (offset < 0 && I->pos + offset >= I->buf))
+      {
+        I->pos += offset;
+        return 0;
+      }
+      return iof_reader_reseek_file(I, offset, SEEK_CUR);
+    case SEEK_END:
+      return iof_reader_reseek_file(I, offset, SEEK_END); // can we do better?
+  }
+  return -1;
+}
+
+int iof_reader_seek (iof *I, long offset, int whence)
+{
+  I->flags &= ~IOF_STOPPED;
+  if (I->flags & IOF_FILE)
+    return iof_reader_seek_iofile(I, offset, whence);
+  if (I->flags & IOF_FILE_HANDLE)
+    return iof_reader_seek_file(I, offset, whence);
+  if (I->flags & IOF_DATA)
+    return iof_reader_seek_data(I, offset, whence);
+  return -1;
+}
+
+int iof_reader_reseek (iof *I, long offset, int whence)
+{
+  I->flags &= ~IOF_STOPPED;
+  if (I->flags & IOF_FILE)
+    return iof_reader_reseek_iofile(I, offset, whence);
+  if (I->flags & IOF_FILE_HANDLE)
+    return iof_reader_reseek_file(I, offset, whence);
+  if (I->flags & IOF_DATA)
+    return iof_reader_seek_data(I, offset, whence);
+  return -1;
+}
+
+static int iof_writer_seek_data (iof *O, long offset, int whence)
+{
+  /*
+  fseek() allows to seek after the end of file. Seeking does not increase the output file.
+  No byte is written before fwirte(). It seems to fill the gap with zeros. Until we really need that,
+  no seeking out of bounds for writers.
+  */
+  O->flags &= ~IOF_STOPPED;
+  return iof_reader_seek_data(O, offset, whence);
+}
+
+static int iof_writer_seek_iofile (iof *O, long offset, int whence)
+{
+  long fileoffset;
+  switch (whence)
+  {
+    case SEEK_SET:
+      fileoffset = iof_file_tell(O->iofile);
+      if (offset >= fileoffset && offset <= fileoffset + iof_space(O))
+      {
+        O->pos = O->buf + (offset - fileoffset);
+        return 0;
+      }
+      return iof_writer_reseek_iofile(O, offset, SEEK_SET);
+    case SEEK_CUR:
+      if ((offset >=0 && O->pos + offset <= O->end) || (offset < 0 && O->pos + offset >= O->buf))
+      {
+        O->pos += offset;
+        return 0;
+      }
+      return iof_writer_reseek_iofile(O, offset, SEEK_CUR);
+    case SEEK_END:
+      return iof_writer_reseek_iofile(O, offset, SEEK_END);
+  }
+  return -1;
+}
+
+static int iof_writer_seek_file (iof *O, long offset, int whence)
+{
+  long fileoffset;
+  switch (whence)
+  {
+    case SEEK_SET:
+      fileoffset = ftell(O->file);
+      if (offset >= fileoffset && offset <= fileoffset + iof_space(O))
+      {
+        O->pos = O->buf + (offset - fileoffset);
+        return 0;
+      }
+      return iof_writer_reseek_file(O, offset, SEEK_SET);
+    case SEEK_CUR:
+      if ((offset >=0 && O->pos + offset <= O->end) || (offset < 0 && O->pos + offset >= O->buf))
+      {
+        O->pos += offset;
+        return 0;
+      }
+      return iof_writer_reseek_file(O, offset, SEEK_CUR);
+    case SEEK_END:
+      return iof_writer_reseek_file(O, offset, SEEK_END);
+  }
+  return -1;
+}
+
+int iof_writer_seek (iof *I, long offset, int whence)
+{
+  I->flags &= ~IOF_STOPPED;
+  if (I->flags & IOF_FILE)
+    return iof_writer_seek_iofile(I, offset, whence);
+  if (I->flags & IOF_FILE_HANDLE)
+    return iof_writer_seek_file(I, offset, whence);
+  if (I->flags & IOF_DATA)
+    return iof_writer_seek_data(I, offset, whence);
+  return -1;
+}
+
+int iof_writer_reseek (iof *I, long offset, int whence)
+{
+  I->flags &= ~IOF_STOPPED;
+  if (I->flags & IOF_FILE)
+    return iof_writer_reseek_iofile(I, offset, whence);
+  if (I->flags & IOF_FILE_HANDLE)
+    return iof_writer_reseek_file(I, offset, whence);
+  if (I->flags & IOF_DATA)
+    return iof_writer_seek_data(I, offset, whence);
+  return -1;
+}
+
+int iof_seek (iof *F, long offset, int whence)
+{
+  return (F->flags & IOF_WRITER) ? iof_writer_seek(F, offset, whence) : iof_reader_seek(F, offset, whence);
+}
+
+int iof_reseek (iof *F, long offset, int whence)
+{
+  return (F->flags & IOF_WRITER) ? iof_writer_reseek(F, offset, whence) : iof_reader_reseek(F, offset, whence);
+}
+
+/* tell */
+
+long iof_reader_tell (iof *I)
+{
+  if (I->flags & IOF_FILE)
+    return iof_file_tell(I->iofile) - (long)iof_left(I);
+  if (I->flags & IOF_FILE_HANDLE)
+    return ftell(I->file) - (long)iof_left(I);
+  //if (I->flags & IOF_DATA)
+  return (long)iof_size(I);
+}
+
+long iof_writer_tell (iof *O)
+{
+  if (O->flags & IOF_FILE)
+    return iof_file_tell(O->iofile) + (long)iof_size(O);
+  if (O->flags & IOF_FILE_HANDLE)
+    return ftell(O->file) + (long)iof_size(O);
+  //if (I->flags & IOF_DATA)
+  return (long)iof_size(O);
+}
+
+long iof_tell (iof *I)
+{
+  return (I->flags & IOF_WRITER) ? iof_writer_tell(I) : iof_reader_tell(I);
+}
+
+size_t iof_fsize (iof *I)
+{
+  size_t pos, size;
+  if (I->flags & IOF_FILE)
+    return iof_file_size(I->iofile);
+  if (I->flags & IOF_FILE_HANDLE)
+  {
+    pos = (size_t)ftell(I->file);
+    fseek(I->file, 0, SEEK_END);
+    size = (size_t)ftell(I->file);
+    fseek(I->file, (long)pos, SEEK_SET);
+    return size;
+  }
+  //if (I->flags & IOF_DATA)
+  return (size_t)iof_space(I);
+}
+
+/* save reader tail */
+
+size_t iof_save_tail (iof *I)
+{
+  size_t size, left;
+  size = iof_size(I);
+  left = iof_left(I);
+  if (size >= left)
+    memcpy(I->buf, I->pos, left);
+  else
+    memmove(I->buf, I->pos, left);
+  return left;
+}
+
+size_t iof_input_save_tail (iof *I, size_t back)
+{
+  size_t size;
+  I->flags |= IOF_TAIL;
+  I->pos -= back;
+  size = iof_input(I);
+  I->pos += back;
+  I->flags &= ~IOF_TAIL;
+  return size; // + back - back
+}
+
+/* read from file */
+
+/* iof free*/
+
+static size_t file_read (iof *I);
+static size_t file_load (iof *I);
+
+static size_t file_reader (iof *I, iof_mode mode)
+{
+  switch (mode)
+  {
+    case IOFREAD:
+      return file_read(I);
+    case IOFLOAD:
+      return file_load(I);
+    case IOFCLOSE:
+      iof_free(I);
+      return 0;
+    default:
+      return 0;
+  }
+}
+
+iof * iof_setup_file_handle_reader (iof *I, void *buffer, size_t space, FILE *f)
+{
+  if (I == NULL)
+    iof_setup_reader(I, buffer, space);
+  else
+    iof_reader_buffer(I, buffer, space);
+  iof_setup_file(I, f);
+  I->more = file_reader;
+  return I;
+}
+
+iof * iof_setup_file_reader (iof *I, void *buffer, size_t space, const char *filename)
+{
+  FILE *f;
+  if ((f = fopen(filename, "rb")) == NULL)
+    return NULL;
+  if (I == NULL)
+    iof_setup_reader(I, buffer, space);
+  else
+    iof_reader_buffer(I, buffer, space);
+  iof_setup_file(I, f);
+  I->flags |= IOF_CLOSE_FILE;
+  I->more = file_reader;
+  return I;
+}
+
+/* write to file */
+
+static size_t file_write (iof *O, int flush);
+
+static size_t file_writer (iof *O, iof_mode mode)
+{
+  switch (mode)
+  {
+    case IOFWRITE:
+      return file_write(O, 0);
+    case IOFFLUSH:
+      return file_write(O, 1);
+    case IOFCLOSE:
+      file_write(O, 1);
+      iof_free(O);
+      return 0;
+    default:
+      return 0;
+  }
+}
+
+iof * iof_setup_file_handle_writer (iof *O, void *buffer, size_t space, FILE *f)
+{
+  if (O == NULL)
+    iof_setup_writer(O, buffer, space);
+  else
+    iof_writer_buffer(O, buffer, space);
+  iof_setup_file(O, f);
+  O->more = file_writer;
+  return O;
+}
+
+iof * iof_setup_file_writer (iof *O, void *buffer, size_t space, const char *filename)
+{
+  FILE *f;
+  if ((f = fopen(filename, "wb")) == NULL)
+    return NULL;
+  if (O == NULL)
+    iof_setup_writer(O, buffer, space);
+  else
+    iof_writer_buffer(O, buffer, space);
+  iof_setup_file(O, f);
+  O->flags |= IOF_CLOSE_FILE;
+  O->more = file_writer;
+  return O;
+}
+
+/* a dedicated handler for stdout/stderr */
+
+static size_t stdout_writer (iof *O, iof_mode mode)
+{
+  switch(mode)
+  {
+    case IOFWRITE:
+    {
+      fwrite(O->buf, sizeof(uint8_t), iof_size(O), stdout);
+      O->pos = O->buf;
+      return O->space;
+    }
+    case IOFCLOSE:
+    case IOFFLUSH:
+    {
+      fwrite(O->buf, sizeof(uint8_t), iof_size(O), stdout);
+      fflush(stdout);
+      O->pos = O->buf;
+      return 0;
+    }
+    default:
+      break;
+  }
+  return 0;
+}
+
+static size_t stderr_writer (iof *O, iof_mode mode)
+{
+  switch(mode)
+  {
+    case IOFWRITE:
+    {
+      fwrite(O->buf, sizeof(uint8_t), iof_size(O), stderr);
+      O->pos = O->buf;
+      return O->space;
+    }
+    case IOFCLOSE:
+    case IOFFLUSH:
+    {
+      fwrite(O->buf, sizeof(uint8_t), iof_size(O), stderr);
+      fflush(stderr);
+      O->pos = O->buf;
+      return 0;
+    }
+    default:
+      break;
+  }
+  return 0;
+}
+
+static uint8_t iof_stdout_buffer[BUFSIZ];
+iof iof_stdout = IOF_WRITER_STRUCT(stdout_writer, NULL, iof_stdout_buffer, BUFSIZ, 0);
+
+static uint8_t iof_stderr_buffer[BUFSIZ];
+iof iof_stderr = IOF_WRITER_STRUCT(stderr_writer, NULL, iof_stderr_buffer, BUFSIZ, 0);
+
+/* read from somewhere */
+
+iof * iof_reader (iof *I, void *link, iof_handler reader, const void *m, size_t bytes)
+{
+  I->space = 0;
+  I->link = link;
+  I->more = reader;
+  I->flags = 0;
+  I->refcount = 0;
+  if (m != NULL)
+  {
+    I->rbuf = I->rpos = (const uint8_t *)m;
+    I->rend = (const uint8_t *)m + bytes;
+    return I;
+  }
+  return NULL;
+}
+
+iof * iof_string_reader (iof *I, const void *s, size_t bytes)
+{
+  I->space = 0;
+  I->link = NULL;
+  I->more = NULL;
+  I->flags = 0; // iof_string() sets IOF_DATA
+  I->refcount = 0;
+  if (s != NULL)
+    return iof_string(I, s, bytes);
+  return NULL;
+}
+
+/* write somewhere */
+
+iof * iof_writer (iof *O, void *link, iof_handler writer, void *m, size_t bytes)
+{
+  O->space = 0;
+  O->link = link;
+  O->more = writer;
+  O->flags = 0;
+  O->refcount = 0;
+  if (m != NULL && bytes > 0)
+  {
+    O->buf = O->pos = (uint8_t *)m;
+    O->end = (uint8_t *)m + bytes;
+    return O;
+  }
+  // return iof_null(O);
+  return NULL;
+}
+
+/* write to growing bytes buffer */
+
+static size_t iof_mem_handler (iof *O, iof_mode mode)
+{
+  switch(mode)
+  {
+    case IOFWRITE:
+      return iof_resize_buffer(O);
+    case IOFCLOSE:
+      iof_free(O);
+      return 0;
+    default:
+      return 0;
+  }
+}
+
+iof * iof_setup_buffer (iof *O, void *buffer, size_t space)
+{
+  if (O == NULL)
+    iof_setup_writer(O, buffer, space);
+  else
+    iof_writer_buffer(O, buffer, space);
+  O->link = NULL;
+  O->flags |= IOF_DATA;
+  O->more = iof_mem_handler;
+  return O;
+}
+
+iof * iof_setup_buffermin (iof *O, void *buffer, size_t space, size_t min)
+{
+  if ((O = iof_setup_buffer(O, buffer, space)) != NULL && space < min) // just allocate min now to avoid further rewriting
+  {
+    O->buf = O->pos = (uint8_t *)util_malloc(min);
+    O->flags |= IOF_BUFFER_ALLOC;
+    O->end = O->buf + min;
+  }
+  return O;
+}
+
+iof * iof_buffer_create (size_t space)
+{
+  uint8_t *buffer;
+  iof *O;
+  space += sizeof(iof);
+  buffer = util_malloc(space);
+  if ((O = iof_setup_buffer(NULL, buffer, space)) != NULL)
+    O->flags |= IOF_ALLOC;
+  return O;
+}
+
+/* set/get */
+
+int iof_getc (iof *I)
+{
+  if (iof_readable(I))
+    return *I->pos++;
+  return IOFEOF;
+}
+
+int iof_putc (iof *O, int u)
+{
+  if (iof_writable(O))
+  {
+    iof_set(O, u);
+    return (uint8_t)u;
+  }
+  return IOFFULL;
+}
+
+size_t iof_skip (iof *I, size_t bytes)
+{
+  while (bytes)
+  {
+    if (iof_readable(I))
+      ++I->pos;
+    else
+      break;
+    --bytes;
+  }
+  return bytes;
+}
+
+/* from iof to iof */
+
+iof_status iof_pass (iof *I, iof *O)
+{
+  size_t leftin, leftout;
+  if ((leftin = iof_left(I)) == 0)
+    leftin = iof_input(I);
+  while (leftin)
+  {
+    if ((leftout = iof_left(O)) == 0)
+      if ((leftout = iof_output(O)) == 0)
+        return IOFFULL;
+    while (leftin > leftout)
+    {
+      memcpy(O->pos, I->pos, leftout);
+      I->pos += leftout;
+      O->pos = O->end; /* eq. += leftout */
+      leftin -= leftout;
+      if ((leftout = iof_output(O)) == 0)
+        return IOFFULL;
+    }
+    if (leftin)
+    {
+      memcpy(O->pos, I->pos, leftin);
+      I->pos = I->end; /* eq. += leftin */
+      O->pos += leftin;
+    }
+    leftin = iof_input(I);
+  }
+  return IOFEOF;
+}
+
+/* read n-bytes */
+
+size_t iof_read (iof *I, void *to, size_t size)
+{
+  size_t leftin, done = 0;
+  char *s = (char *)to;
+  
+  if ((leftin = iof_left(I)) == 0)
+    if ((leftin = iof_input(I)) == 0)
+      return done;
+  while (size > leftin)
+  {
+    memcpy(s, I->pos, leftin * sizeof(uint8_t));
+    size -= leftin;
+    done += leftin;
+    s += leftin;
+    I->pos = I->end;
+    if ((leftin = iof_input(I)) == 0)
+      return done;
+  }
+  if (size)
+  {
+    memcpy(s, I->pos, size * sizeof(uint8_t));
+    I->pos += size;
+    done += size;
+  }
+  return done;
+}
+
+/* rewrite FILE content (use fseek if needed) */
+
+size_t iof_write_file_handle (iof *O, FILE *file)
+{
+  size_t leftout, size, readout;
+  if ((leftout = iof_left(O)) == 0)
+    if ((leftout = iof_output(O)) == 0)
+      return 0;
+  size = 0;
+  do {
+    readout = fread(O->pos, 1, leftout, file);    
+    O->pos += readout;
+    size += readout;
+  } while(readout == leftout && (leftout = iof_output(O)) > 0);
+  return size;
+}
+
+size_t iof_write_file (iof *O, const char *filename)
+{
+  FILE *file;
+  size_t size;
+  if ((file = fopen(filename, "rb")) == NULL)
+    return 0;
+  size = iof_write_file_handle(O, file);
+  fclose(file);
+  return size;
+}
+
+size_t iof_write_iofile (iof *O, iof_file *iofile, int savepos)
+{
+  long offset;
+  size_t size;
+  FILE *file;
+  if (iofile->flags & IOF_DATA)
+    return iof_write(O, iofile->pos, (size_t)(iofile->end - iofile->pos));
+  file = iof_file_get_fh(iofile);
+  if (savepos)
+  {
+    offset = ftell(file);  
+    size = iof_write_file_handle(O, file);
+    fseek(file, offset, SEEK_SET);
+    return size;
+  }
+  return iof_write_file_handle(O, file);
+}
+
+/* write n-bytes */
+
+size_t iof_write (iof *O, const void *data, size_t size)
+{
+  size_t leftout, done = 0;
+  const char *s = (const char *)data;
+  if ((leftout = iof_left(O)) == 0)
+    if ((leftout = iof_output(O)) == 0)
+      return done;
+  while (size > leftout)
+  {
+    memcpy(O->pos, s, leftout * sizeof(uint8_t));
+    size -= leftout;
+    done += leftout;
+    s += leftout;
+    O->pos = O->end;
+    if ((leftout = iof_output(O)) == 0)
+      return done;
+  }
+  if (size)
+  {
+    memcpy(O->pos, s, size * sizeof(uint8_t));
+    O->pos += size;
+    done += size;
+  }
+  return done;
+}
+
+/* write '\0'-terminated string */
+
+iof_status iof_puts (iof *O, const void *data)
+{
+  const char *s = (const char *)data;
+  while (*s)
+  {
+    if (iof_writable(O))
+      iof_set(O, *s++);
+    else
+      return IOFFULL;
+  }
+  return IOFEOF; // ?
+}
+
+size_t iof_put_string (iof *O, const void *data)
+{
+  const char *p, *s = (const char *)data;
+  for (p = s; *p != '\0' && iof_writable(O); iof_set(O, *p++));
+  return p - s;
+}
+
+/* write byte n-times */
+
+/*
+iof_status iof_repc (iof *O, char c, size_t bytes)
+{
+  while (bytes)
+  {
+    if (iof_writable(O))
+      iof_set(O, c);
+    else
+      return IOFFULL;
+    --bytes;
+  }
+  return IOFEOF; // ?
+}
+*/
+
+size_t iof_repc (iof *O, char c, size_t bytes)
+{
+  size_t leftout, todo = bytes;
+  if ((leftout = iof_left(O)) == 0)
+    if ((leftout = iof_output(O)) == 0)
+      return 0;
+  while (bytes > leftout)
+  {
+    memset(O->pos, c, leftout);
+    bytes -= leftout;
+    O->pos = O->end;
+    if ((leftout = iof_output(O)) == 0)
+      return todo - bytes;
+  }
+  if (bytes)
+  {
+    memset(O->pos, c, bytes);
+    O->pos += bytes;
+  }
+  return todo;
+}
+
+/* putfs */
+
+#define IOF_FMT_SIZE 1024
+
+size_t iof_putfs (iof *O, const char *format, ...)
+{
+  static char buffer[IOF_FMT_SIZE];
+  va_list args;
+  va_start(args, format);
+  if (vsnprintf(buffer, IOF_FMT_SIZE, format, args) > 0)
+  {
+    va_end(args);
+    return iof_put_string(O, buffer);
+  }
+  else
+  {
+    va_end(args);
+    return iof_write(O, buffer, IOF_FMT_SIZE);
+  }
+}
+
+/* integer from iof; return 1 on success, 0 otherwise */
+
+int iof_get_int32 (iof *I, int32_t *number)
+{
+  int sign, c = iof_char(I);
+  iof_scan_sign(I, c, sign);
+  if (!base10_digit(c)) return 0;
+  iof_read_integer(I, c, *number);
+  if (sign) *number = -*number;
+  return 1;
+}
+
+int iof_get_intlw (iof *I, intlw_t *number)
+{
+  int sign, c = iof_char(I);
+  iof_scan_sign(I, c, sign);
+  if (!base10_digit(c)) return 0;
+  iof_read_integer(I, c, *number);
+  if (sign) *number = -*number;
+  return 1;
+}
+
+int iof_get_int64 (iof *I, int64_t *number)
+{
+  int sign, c = iof_char(I);
+  iof_scan_sign(I, c, sign);
+  if (!base10_digit(c)) return 0;
+  iof_read_integer(I, c, *number);
+  if (sign) *number = -*number;
+  return 1;
+}
+
+int iof_get_uint32 (iof *I, uint32_t *number)
+{
+  int c = iof_char(I);
+  if (!base10_digit(c)) return 0;
+  iof_read_integer(I, c, *number);
+  return 1;
+}
+
+int iof_get_uintlw (iof *I, uintlw_t *number)
+{
+  int c = iof_char(I);
+  if (!base10_digit(c)) return 0;
+  iof_read_integer(I, c, *number);
+  return 1;
+}
+
+int iof_get_uint64 (iof *I, uint64_t *number)
+{
+  int c = iof_char(I);
+  if (!base10_digit(c)) return 0;
+  iof_read_integer(I, c, *number);
+  return 1;
+}
+
+int iof_get_int32_radix (iof *I, int32_t *number, int radix)
+{
+  int sign, c = iof_char(I);
+  iof_scan_sign(I, c, sign);
+  if (!base10_digit(c)) return 0;
+  iof_read_radix(I, c, *number, radix);
+  if (sign) *number = -*number;
+  return 1;
+
+}
+
+int iof_get_intlw_radix (iof *I, intlw_t *number, int radix)
+{
+  int sign, c = iof_char(I);
+  iof_scan_sign(I, c, sign);
+  if (!base10_digit(c)) return 0;
+  iof_read_radix(I, c, *number, radix);
+  if (sign) *number = -*number;
+  return 1;
+}
+
+int iof_get_int64_radix (iof *I, int64_t *number, int radix)
+{
+  int sign, c = iof_char(I);
+  iof_scan_sign(I, c, sign);
+  if (!base10_digit(c)) return 0;
+  iof_read_radix(I, c, *number, radix);
+  if (sign) *number = -*number;
+  return 1;
+}
+
+int iof_get_uint32_radix (iof *I, uint32_t *number, int radix)
+{
+  int c = iof_char(I);
+  if (!base10_digit(c)) return 0;
+  iof_read_radix(I, c, *number, radix);
+  return 1;
+}
+
+int iof_get_uintlw_radix (iof *I, uintlw_t *number, int radix)
+{
+  int c = iof_char(I);
+  if (!base10_digit(c)) return 0;
+  iof_read_radix(I, c, *number, radix);
+  return 1;
+}
+
+int iof_get_uint64_radix (iof *I, uint64_t *number, int radix)
+{
+  int c = iof_char(I);
+  if (!base10_digit(c)) return 0;
+  iof_read_radix(I, c, *number, radix);
+  return 1;
+}
+
+/* get roman to uint16_t, cf. roman_to_uint16() from utilnumber.c*/
+
+/* todo: some trick in place of this macro horror? */
+
+#define roman1000(c) (c == 'M' || c == 'm')
+#define roman500(c)  (c == 'D' || c == 'd')
+#define roman100(c)  (c == 'C' || c == 'c')
+#define roman50(c)   (c == 'L' || c == 'l')
+#define roman10(c)   (c == 'X' || c == 'x')
+#define roman5(c)    (c == 'V' || c == 'v')
+#define roman1(c)    (c == 'I' || c == 'i')
+
+#define roman100s(I, c) \
+  (roman100(c) ? (100 + ((c = iof_next(I), roman100(c)) ? (100 + ((c = iof_next(I), roman100(c)) ? (c = iof_next(I), 100) : 0)) : 0)) : 0)
+#define roman10s(I, c) \
+  (roman10(c) ? (10 + ((c = iof_next(I), roman10(c)) ? (10 + ((c = iof_next(I), roman10(c)) ? (c = iof_next(I), 10) : 0)) : 0)) : 0)
+#define roman1s(I, c) \
+  (roman1(c) ? (1 + ((c = iof_next(I), roman1(c)) ? (1 + ((c = iof_next(I), roman1(c)) ? (c = iof_next(I), 1) : 0)) : 0)) : 0)
+
+int iof_get_roman (iof *I, uint16_t *number)
+{
+  int c;
+  /* M */
+  for (*number = 0, c = iof_char(I); roman1000(c); *number += 1000, c = iof_next(I));
+  /* D C */
+  if (roman500(c))
+  {
+    c = iof_next(I);
+    *number += 500 + roman100s(I, c);
+  }
+  else if (roman100(c))
+  {
+    c = iof_next(I);
+    if (roman1000(c))
+    {
+      c = iof_next(I);
+      *number += 900;
+    }
+    else if (roman500(c))
+    {
+      c = iof_next(I);
+      *number += 400;
+    }
+    else
+      *number += 100 + roman100s(I, c);
+  }
+  /* L X */
+  if (roman50(c))
+  {
+    c = iof_next(I);
+    *number += 50 + roman10s(I, c);
+  }
+  else if (roman10(c))
+  {
+    c = iof_next(I);
+    if (roman100(c))
+    {
+      c = iof_next(I);
+      *number += 90;
+    }
+    else if (roman50(c))
+    {
+      c = iof_next(I);
+      *number += 40;
+    }
+    else
+      *number += 10 + roman10s(I, c);
+  }
+  /* V I */
+  if (roman5(c))
+  {
+    c = iof_next(I);
+    *number += 5 + roman1s(I, c);
+  }
+  else if (roman1(c))
+  {
+    c = iof_next(I);
+    if (roman10(c))
+    {
+      c = iof_next(I);
+      *number += 9;
+    }
+    else if (roman5(c))
+    {
+      c = iof_next(I);
+      *number += 4;
+    }
+    else
+      *number += 1 + roman1s(I, c);
+  }
+  return 1;
+}
+
+/* double from iof; return 1 on success */
+
+int iof_get_double (iof *I, double *number) // cf. string_to_double()
+{
+  int sign, exponent10, c = iof_char(I);
+  iof_scan_sign(I, c, sign);
+  iof_scan_decimal(I, c, *number);
+  if (c == '.')
+  {
+    c = iof_next(I);
+    iof_scan_fraction(I, c, *number, exponent10);
+  }
+  else
+    exponent10 = 0;
+  if (c == 'e' || c == 'E')
+  {
+    c = iof_next(I);
+    iof_scan_exponent10(I, c, exponent10);
+  }
+  double_exp10(*number, exponent10);
+  if (sign) *number = -*number;
+  return 1;
+}
+
+int iof_get_float (iof *I, float *number) // cf. string_to_float() in utilnumber.c
+{
+  int sign, exponent10, c = iof_char(I);
+  iof_scan_sign(I, c, sign);
+  iof_scan_decimal(I, c, *number);
+  if (c == '.')
+  {
+    c = iof_next(I);
+    iof_scan_fraction(I, c, *number, exponent10);
+  }
+  else
+    exponent10 = 0;
+  if (c == 'e' || c == 'E')
+  {
+    c = iof_next(I);
+    iof_scan_exponent10(I, c, exponent10);
+  }
+  float_exp10(*number, exponent10);
+  if (sign) *number = -*number;
+  return 1;
+}
+
+int iof_conv_double (iof *I, double *number) // cf. convert_to_double() in utilnumber.c
+{
+  int sign, exponent10, c = iof_char(I);
+  iof_scan_sign(I, c, sign);
+  iof_scan_decimal(I, c, *number);
+  if (c == '.' || c == ',')
+  {
+    c = iof_next(I);
+    iof_scan_fraction(I, c, *number, exponent10);
+    if (exponent10 < 0)
+      double_negative_exp10(*number, exponent10);
+  }
+  if (sign) *number = -*number;
+  return 1;
+}
+
+int iof_conv_float (iof *I, float *number) // cf. convert_to_float()
+{
+  int sign, exponent10, c = iof_char(I);
+  iof_scan_sign(I, c, sign);
+  iof_scan_decimal(I, c, *number);
+  if (c == '.' || c == ',')
+  {
+    c = iof_next(I);
+    iof_scan_fraction(I, c, *number, exponent10);
+    if (exponent10 < 0)
+      float_negative_exp10(*number, exponent10);
+  }
+  if (sign) *number = -*number;
+  return 1;
+}
+
+/* integer to iof; return a number of written bytes */
+
+#define iof_copy_number_buffer(O, s, p) for (p = s; *p && iof_writable(O); iof_set(O, *p), ++p)
+
+size_t iof_put_int32 (iof *O, int32_t number)
+{
+  const char *s, *p;
+  s = int32_to_string(number);
+  iof_copy_number_buffer(O, s, p);
+  return p - s;
+}
+
+size_t iof_put_intlw (iof *O, intlw_t number)
+{
+  const char *s, *p;
+  s = intlw_to_string(number);
+  iof_copy_number_buffer(O, s, p);
+  return p - s;
+}
+
+size_t iof_put_int64 (iof *O, int64_t number)
+{
+  const char *s, *p;
+  s = int64_to_string(number);
+  iof_copy_number_buffer(O, s, p);
+  return p - s;
+}
+
+size_t iof_put_uint32 (iof *O, uint32_t number)
+{
+  const char *s, *p;
+  s = uint32_to_string(number);
+  iof_copy_number_buffer(O, s, p);
+  return p - s;
+}
+
+size_t iof_put_uintlw (iof *O, uintlw_t number)
+{
+  const char *s, *p;
+  s = uintlw_to_string(number);
+  iof_copy_number_buffer(O, s, p);
+  return p - s;
+}
+
+size_t iof_put_uint64 (iof *O, uint64_t number)
+{
+  const char *s, *p;
+  s = uint64_to_string(number);
+  iof_copy_number_buffer(O, s, p);
+  return p - s;
+}
+
+size_t iof_put_int32_radix (iof *O, int32_t number, int radix)
+{
+  const char *s, *p;
+  s = int32_to_radix(number, radix);
+  iof_copy_number_buffer(O, s, p);
+  return p - s;
+}
+
+size_t iof_put_intlw_radix (iof *O, intlw_t number, int radix)
+{
+  const char *s, *p;
+  s = intlw_to_radix(number, radix);
+  iof_copy_number_buffer(O, s, p);
+  return p - s;
+}
+
+size_t iof_put_int64_radix (iof *O, int64_t number, int radix)
+{
+  const char *s, *p;
+  s = int64_to_radix(number, radix);
+  iof_copy_number_buffer(O, s, p);
+  return p - s;
+}
+
+size_t iof_put_uint32_radix (iof *O, uint32_t number, int radix)
+{
+  const char *s, *p;
+  s = uint32_to_radix(number, radix);
+  iof_copy_number_buffer(O, s, p);
+  return p - s;
+}
+
+size_t iof_put_uintlw_radix (iof *O, uintlw_t number, int radix)
+{
+  const char *s, *p;
+  s = uintlw_to_radix(number, radix);
+  iof_copy_number_buffer(O, s, p);
+  return p - s;
+}
+
+size_t iof_put_uint64_radix (iof *O, uint64_t number, int radix)
+{
+  const char *s, *p;
+  s = uint64_to_radix(number, radix);
+  iof_copy_number_buffer(O, s, p);
+  return p - s;
+}
+
+/* roman numerals */
+
+size_t iof_put_roman_uc (iof *O, uint16_t number)
+{
+  const char *s, *p;
+  s = uint16_to_roman_uc(number);
+  iof_copy_number_buffer(O, s, p);
+  return p - s;
+}
+
+size_t iof_put_roman_lc (iof *O, uint16_t number)
+{
+  const char *s, *p;
+  s = uint16_to_roman_lc(number);
+  iof_copy_number_buffer(O, s, p);
+  return p - s;
+}
+
+/* double/float to iof; return the number of written bytes */
+
+size_t iof_put_double (iof *O, double number, int digits)
+{
+  const char *s, *p;
+  s = double_to_string(number, digits);
+  iof_copy_number_buffer(O, s, p);
+  return p - s;
+}
+
+size_t iof_put_float (iof *O, float number, int digits)
+{
+  const char *s, *p;
+  s = float_to_string(number, digits);
+  iof_copy_number_buffer(O, s, p);
+  return p - s;
+}
+
+/* iof to binary integer; pretty common */
+
+int iof_get_be_uint2 (iof *I, uint32_t *pnumber)
+{
+  int c1, c2;
+  if ((c1 = iof_get(I)) < 0 || (c2 = iof_get(I)) < 0)
+    return 0;
+  *pnumber = (c1<<8)|c2;
+  return 1;
+}
+
+int iof_get_be_uint3 (iof *I, uint32_t *pnumber)
+{
+  int c1, c2, c3;
+  if ((c1 = iof_get(I)) < 0 || (c2 = iof_get(I)) < 0 || (c3 = iof_get(I)) < 0)
+    return 0;
+  *pnumber = (c1<<16)|(c2<<8)|c3;
+  return 1;
+}
+
+int iof_get_be_uint4 (iof *I, uint32_t *pnumber)
+{
+  int c1, c2, c3, c4;
+  if ((c1 = iof_get(I)) < 0 || (c2 = iof_get(I)) < 0 || (c3 = iof_get(I)) < 0 || (c4 = iof_get(I)) < 0)
+    return 0;
+  *pnumber = (c1<<24)|(c2<<16)|(c3<<8)|c4;
+  return 1;
+}
+
+int iof_get_le_uint2 (iof *I, uint32_t *pnumber)
+{
+  int c1, c2;
+  if ((c1 = iof_get(I)) < 0 || (c2 = iof_get(I)) < 0)
+    return 0;
+  *pnumber = (c2<<8)|c1;
+  return 1;
+}
+
+int iof_get_le_uint3 (iof *I, uint32_t *pnumber)
+{
+  int c1, c2, c3;
+  if ((c1 = iof_get(I)) < 0 || (c2 = iof_get(I)) < 0 || (c3 = iof_get(I)) < 0)
+    return 0;
+  *pnumber = (c3<<16)|(c2<<8)|c1;
+  return 1;
+}
+
+int iof_get_le_uint4 (iof *I, uint32_t *pnumber)
+{
+  int c1, c2, c3, c4;
+  if ((c1 = iof_get(I)) < 0 || (c2 = iof_get(I)) < 0 || (c3 = iof_get(I)) < 0 || (c4 = iof_get(I)) < 0)
+    return 0;
+  *pnumber = (c4<<24)|(c3<<16)|(c2<<8)|c1;
+  return 1;
+}
+
+/* iof input data */
+
+uint8_t * iof_file_input_data (iof_file *iofile, size_t *psize, int *isnew)
+{
+  uint8_t *data;
+  if (iofile->flags & IOF_DATA)
+  {
+    data = iofile->buf;
+    *psize = iofile->end - iofile->buf;
+    *isnew = 0;
+    return data;
+  }
+  if (iof_file_reopen(iofile))
+  {
+    data = iof_copy_file_handle_data(iof_file_get_fh(iofile), psize);
+    *isnew = 1;
+    iof_file_reclose(iofile);
+    return data;
+  }
+  return NULL;
+}
+
+/*
+uint8_t * iof_file_reader_data (iof_file *iofile, size_t *size)
+{
+  uint8_t *data;
+  if (!(iofile->flags & IOF_DATA) || iofile->pos == NULL || (*size = (size_t)iof_left(iofile)) == 0)
+    return NULL;  
+  if (iofile->flags & IOF_BUFFER_ALLOC)
+  {
+    data = iofile->buf; // iofile->pos; // returned must be freeable, makes sense when ->buf == ->pos
+    iofile->flags &= ~IOF_BUFFER_ALLOC;
+    iofile->buf = iofile->pos = iofile->end = NULL;
+    return data;
+  }
+  data = (uint8_t *)util_malloc(*size);
+  memcpy(data, iofile->buf, *size);
+  return data;
+}
+
+uint8_t * iof_file_writer_data (iof_file *iofile, size_t *size)
+{
+  uint8_t *data;
+  if (!(iofile->flags & IOF_DATA) || iofile->buf == NULL || (*size = (size_t)iof_size(iofile)) == 0)
+    return NULL;  
+  if (iofile->flags & IOF_BUFFER_ALLOC)
+  {
+    iofile->flags &= ~IOF_BUFFER_ALLOC;
+    data = iofile->buf;
+    iofile->buf = iofile->pos = iofile->end = NULL;
+    return data;
+  }
+  data = (uint8_t *)util_malloc(*size);
+  memcpy(data, iofile->buf, *size);
+  return data;
+}
+*/
+
+uint8_t * iof_reader_data (iof *I, size_t *psize)
+{
+  uint8_t *data;
+  *psize = (size_t)iof_left(I);
+  if (I->flags & IOF_BUFFER_ALLOC)
+  {
+    data = I->buf; // actually I->pos, but we have to return something freeable
+    I->flags &= ~IOF_BUFFER_ALLOC;
+    I->buf = NULL;
+  }
+  else
+  {
+    data = util_malloc(*psize);
+    memcpy(data, I->pos, *psize);
+  }
+  iof_close(I);
+  return data;
+}
+
+
+uint8_t * iof_writer_data (iof *O, size_t *psize)
+{
+  uint8_t *data;
+  *psize = (size_t)iof_size(O);
+  if (O->flags & IOF_BUFFER_ALLOC)
+  {
+    data = O->buf;
+    O->flags &= ~IOF_BUFFER_ALLOC;
+    O->buf = NULL;
+  }
+  else
+  {
+    data = util_malloc(*psize);
+    memcpy(data, O->buf, *psize);
+  }
+  iof_close(O);
+  return data;
+}
+
+size_t iof_reader_to_file_handle (iof *I, FILE *file)
+{
+  size_t size;
+  for (size = 0; iof_readable(I); I->pos = I->end)
+    size += fwrite(I->buf, sizeof(uint8_t), iof_left(I), file);
+  return size;
+}
+
+size_t iof_reader_to_file (iof *I, const char *filename)
+{
+  FILE *file;
+  size_t size;
+  if ((file = fopen(filename, "wb")) == NULL)
+    return 0;
+  for (size = 0; iof_readable(I); I->pos = I->end)
+    size += fwrite(I->buf, sizeof(uint8_t), iof_left(I), file);
+  fclose(file);
+  return size;
+}
+
+/* debug */
+
+size_t iof_data_to_file (const void *data, size_t size, const char *filename)
+{
+  FILE *fh;
+  if ((fh = fopen(filename, "wb")) == NULL)
+    return 0;
+  // size = fwrite(data, size, sizeof(uint8_t), fh); // WRONG, this always returns 1, as fwrite returns the number of elements successfully written out
+  size = fwrite(data, sizeof(uint8_t), size, fh);
+  fclose(fh);
+  return size;
+}
+
+size_t iof_result_to_file_handle (iof *F, FILE *file)
+{
+  const void *data;
+  size_t size;
+  data = iof_result(F, size);
+	return iof_data_to_file_handle(data, size, file);
+}
+
+size_t iof_result_to_file (iof *F, const char *filename)
+{
+  const void *data;
+  size_t size;
+  data = iof_result(F, size);
+  return iof_data_to_file(data, size, filename);
+}
+
+void iof_debug (iof *I, const char *filename)
+{
+  FILE *file = fopen(filename, "wb");
+  if (file != NULL)
+  {
+    fprintf(file, ">>> buf %p <<<\n", I->buf);
+    fwrite(I->buf, sizeof(uint8_t), iof_size(I), file);
+    fprintf(file, "\n>>> pos %p (%ld) <<<\n", I->pos, (long)iof_size(I));
+    fwrite(I->pos, sizeof(uint8_t), iof_left(I), file);
+    fprintf(file, "\n>>> end %p (%ld) <<<\n", I->end, (long)iof_left(I));
+    fwrite(I->end, sizeof(uint8_t), I->space - iof_space(I), file);
+    fprintf(file, "\n>>> end of buffer %p (%ld) <<<\n", I->buf + I->space, (long)(I->buf + I->space - I->end));
+    fclose(file);
+  }
+}
+
+/* common filters api */
+
+/* sizes of filter states on x64
+size of iof_filter: 640 (no longer used; sizeof(iof) + sizeof larger state)
+size of file_state: 16
+size of stream_state: 16
+size of flate_state: 104
+size of lzw_state: 56
+size of predictor_state: 104
+size of basexx_state: 48
+size of basexx_state: 48
+size of basexx_state: 48
+size of eexec_state: 40
+size of runlength_state: 24
+size of rc4_state: 24
+size of aes_state: 72
+size of img_state: 576
+size of img: 496
+*/
+
+typedef struct iof_heap iof_heap;
+
+struct iof_heap {
+  uint8_t *data, *pos;
+  size_t size, space;
+  iof_heap *next, *prev;
+  int refcount;
+};
+
+typedef struct {
+  iof_heap *heap;
+} iof_heap_ghost;
+
+static iof_heap * iof_buffers_heap = NULL;
+static iof_heap * iof_filters_heap = NULL;
+
+#define IOF_HEAP_FILTERS_COUNT 4
+#define IOF_BUFFER_SIZE 262144 // (1<<18)
+#define IOF_FILTER_SIZE 1024
+// sizeof(iof_filter) on x64 is now 640, img_state 576, img 496, others 16-104
+#define IOF_BUFFER_HEAP_SIZE (IOF_HEAP_FILTERS_COUNT * (IOF_BUFFER_SIZE + sizeof(iof_heap_ghost)))
+#define IOF_FILTER_HEAP_SIZE (IOF_HEAP_FILTERS_COUNT * (IOF_FILTER_SIZE + sizeof(iof_heap_ghost)))
+
+static iof_heap * iof_heap_new (size_t space)
+{
+  iof_heap *iofheap;
+  iofheap = (iof_heap *)util_malloc(sizeof(iof_heap) + space);
+  iofheap->data = iofheap->pos = (uint8_t *)(iofheap + 1);
+  iofheap->size = iofheap->space = space;
+  iofheap->next = NULL;
+  iofheap->prev = NULL;
+  iofheap->refcount = 0;
+  return iofheap;
+}
+
+#define iof_heap_free(iofheap) util_free(iofheap)
+
+void iof_filters_init (void)
+{
+  if (iof_buffers_heap == NULL)
+    iof_buffers_heap = iof_heap_new(IOF_BUFFER_HEAP_SIZE);
+  if (iof_filters_heap == NULL)
+    iof_filters_heap = iof_heap_new(IOF_FILTER_HEAP_SIZE);
+}
+
+void iof_filters_free (void)
+{
+  iof_heap *heap, *next;
+  for (heap = iof_buffers_heap; heap != NULL; heap = next)
+  {
+    next = heap->next;
+    if (heap->refcount != 0)
+      loggerf("not closed iof filters left (%d)", heap->refcount);
+    if (next != NULL)
+      loggerf("iof filters heap left");
+    iof_heap_free(heap);
+  }
+  iof_buffers_heap = NULL;
+  for (heap = iof_filters_heap; heap != NULL; heap = next)
+  {
+    next = heap->next;
+    if (heap->refcount != 0)
+      loggerf("not closed iof buffers left (%d)", heap->refcount);
+    if (next != NULL)
+      loggerf("iof buffers heap left");
+    iof_heap_free(heap);
+  }
+  iof_filters_heap = NULL;
+}
+
+#if defined __arm__ || defined __ARM__ || defined ARM || defined __ARM || defined __arm || defined __ARM_ARCH ||defined __aarch64__ 
+#define iof_heap_get(hp, ghost, data, siz) \
+ (ghost = (iof_heap_ghost *)((void*)((hp)->pos)), \
+  ghost->heap = hp, \
+  data = (uint8_t *)(ghost + 1), \
+  (hp)->pos += siz, \
+  (hp)->size -= siz, \
+  ++(hp)->refcount)
+#else
+#define iof_heap_get(hp, ghost, data, siz) \
+ (ghost = (iof_heap_ghost *)((hp)->pos), \
+  ghost->heap = hp, \
+  data = (uint8_t *)(ghost + 1), \
+  (hp)->pos += siz, \
+  (hp)->size -= siz, \
+  ++(hp)->refcount)
+
+#endif
+
+
+static void * iof_heap_take (iof_heap **pheap, size_t size)
+{
+  uint8_t *data;
+  iof_heap_ghost *ghost;
+  iof_heap *heap, *newheap, *next;
+
+  heap = *pheap;
+  size += sizeof(iof_heap_ghost);
+  if (heap->size >= size)
+  { /* take cheap mem from main heap */
+    iof_heap_get(heap, ghost, data, size);
+    return data;
+  }
+  if (size <= heap->space >> 1)
+  { /* make new cheap heap, make it front */
+    *pheap = newheap = iof_heap_new(heap->space);
+    newheap->next = heap;
+    heap->prev = newheap;
+    iof_heap_get(newheap, ghost, data, size);
+    return data;
+  }
+  /* size much larger than expected? should not happen.
+     make a single-item heap, keep the front heap intact. */
+  newheap = iof_heap_new(size);
+  if ((next = heap->next) != NULL)
+  {
+    newheap->next = next;
+    next->prev = newheap;
+  }
+  heap->next = newheap;
+  newheap->prev = heap;
+  iof_heap_get(newheap, ghost, data, size);
+  return data;
+}
+
+void iof_heap_back (void *data)
+{
+  iof_heap_ghost *ghost;
+  iof_heap *heap, *next, *prev;
+
+  ghost = ((iof_heap_ghost *)data) - 1;
+  heap = ghost->heap;
+  if (heap->refcount == 0)
+    loggerf("invalid use of iof heap, refcount < 0");
+  if (--heap->refcount <= 0)
+  {
+    if ((prev = heap->prev) != NULL)
+    { /* free the heap */
+      if ((next = heap->next) != NULL)
+        prev->next = next, next->prev = prev;
+      else
+        prev->next = NULL;
+      iof_heap_free(heap);
+    }
+    else
+    { /* this is the front heap, just reset */
+      heap->pos = heap->data;
+      heap->size = heap->space;
+    }
+  }
+}
+
+void * iof_filter_new (size_t size)
+{ // to be removed
+  void *data;
+
+  iof_filters_init();
+  data = iof_heap_take(&iof_filters_heap, size);
+  return memset(data, 0, size);
+}
+
+static uint8_t * iof_filter_buffer_new (size_t *psize)
+{
+  iof_filters_init();
+  *psize = IOF_BUFFER_SIZE;
+  return iof_heap_take(&iof_buffers_heap, IOF_BUFFER_SIZE);
+}
+
+iof * iof_filter_reader_new (iof_handler handler, size_t statesize, void **pstate)
+{
+  iof *F;
+  void *filter;
+  uint8_t *buffer;
+  size_t buffersize;
+
+  iof_filters_init();
+  filter = iof_heap_take(&iof_filters_heap, sizeof(iof) + statesize);
+  F = (iof *)memset(filter, 0, sizeof(iof) + statesize);
+  buffer = iof_filter_buffer_new(&buffersize);
+  iof_reader_buffer(F, buffer, buffersize);
+  F->flags |= IOF_HEAP|IOF_BUFFER_HEAP;
+  F->more = handler;
+  *pstate = (F + 1);
+  return F;
+}
+
+iof * iof_filter_reader_with_buffer_new (iof_handler handler, size_t statesize, void **pstate, void *buffer, size_t buffersize)
+{ // for filters that has own buffer (string, some image filters)
+  iof *F;
+  void *filter;
+  iof_filters_init();
+  filter = iof_heap_take(&iof_filters_heap, sizeof(iof) + statesize);
+  F = (iof *)memset(filter, 0, sizeof(iof) + statesize);
+  iof_reader_buffer(F, buffer, buffersize);
+  F->flags |= IOF_HEAP;
+  F->more = handler;
+  *pstate = (F + 1);
+  return F;
+}
+
+iof * iof_filter_writer_new (iof_handler handler, size_t statesize, void **pstate)
+{
+  iof *F;
+  void *filter;
+  uint8_t *buffer;
+  size_t buffersize;
+
+  iof_filters_init();
+  filter = iof_heap_take(&iof_filters_heap, sizeof(iof) + statesize);
+  F = (iof *)memset(filter, 0, sizeof(iof) + statesize);
+  buffer = iof_filter_buffer_new(&buffersize);
+  iof_writer_buffer(F, buffer, buffersize);
+  F->flags |= IOF_HEAP|IOF_BUFFER_HEAP;
+  F->more = handler;
+  *pstate = (F + 1);
+  return F;
+}
+
+iof * iof_filter_writer_with_buffer_new (iof_handler handler, size_t statesize, void **pstate, void *buffer, size_t size)
+{
+  iof *F;
+  void *filter;
+  size_t buffersize;
+
+  iof_filters_init();
+  filter = iof_heap_take(&iof_filters_heap, sizeof(iof) + statesize);
+  F = (iof *)memset(filter, 0, sizeof(iof) + statesize);
+  buffer = iof_filter_buffer_new(&buffersize);
+  iof_writer_buffer(F, buffer, buffersize);
+  F->flags |= IOF_HEAP;
+  F->more = handler;
+  *pstate = (F + 1);
+  return F;
+}
+
+/* close */
+
+#define iof_close_next(F) ((void)(iof_decref((F)->next), (F)->next = NULL, 0))
+/* when filter creation fails, we should take care to destroy the filter but leave ->next intact */
+#define iof_clear_next(F) ((void)(iof_unref((F)->next), (F)->next = NULL, 0))
+
+#define iof_close_buffer(F) ((void)\
+  ((F)->buf != NULL ? \
+      ((F->flags & IOF_BUFFER_ALLOC) ? (util_free((F)->buf), (F)->buf = NULL, 0) : \
+      ((F->flags & IOF_BUFFER_HEAP) ? (iof_filter_buffer_free((F)->buf), (F)->buf = NULL, 0) : ((F)->buf = NULL, 0))) : 0))
+
+/* closing underlying file handle */
+
+static void iof_close_file (iof *F)
+{
+  FILE *file;
+  //if (F->flags & IOF_FILE_HANDLE)
+  //{
+    if ((file = F->file) != NULL)
+    {
+      if (F->flags & IOF_CLOSE_FILE)
+        fclose(F->file);
+      F->file = NULL;
+    }
+  //}
+}
+
+/* a very special variant for reader filters initiated with iof_file_reopen(). It also calls
+   iof_file_reclose(), which takes an effect only if previously reopened, but better to keep
+   all this thin ice separated. Used in filters: iofile_reader, iofile_stream_reader, image
+   decoders. */
+
+static void iof_close_iofile (iof *F)
+{
+  iof_file *iofile;
+  //if (F->flags & IOF_FILE)
+  //{
+    if ((iofile = F->iofile) != NULL)
+    {
+      iof_file_unsync(iofile, NULL);
+      iof_file_reclose(iofile); // takes an effect iff prevoiusly reopened
+      iof_file_decref(iofile);
+      F->iofile = NULL;
+    }
+  //}
+}
+
+void iof_free (iof *F)
+{
+  if (F->flags & IOF_FILE_HANDLE)
+    iof_close_file(F);
+  else if (F->flags & IOF_FILE)
+    iof_close_iofile(F);
+  else if (F->flags & IOF_NEXT)
+    iof_close_next(F);
+  iof_close_buffer(F);
+  if (F->flags & IOF_HEAP)
+    iof_filter_free(F);
+  else if (F->flags & IOF_ALLOC)
+    util_free(F);
+}
+
+void iof_discard (iof *F)
+{ // so far used only on failed filters creation; as iof_free() but don't dare to release ->next
+  if (F->flags & IOF_FILE_HANDLE)
+    iof_close_file(F);
+  else if (F->flags & IOF_FILE)
+    iof_close_iofile(F);
+  else if (F->flags & IOF_NEXT)
+    iof_close_next(F);
+  iof_close_buffer(F);
+  if (F->flags & IOF_HEAP)
+    iof_filter_free(F);
+  else if (F->flags & IOF_ALLOC)
+    util_free(F);
+}
+
+/* resizing buffer */
+
+size_t iof_resize_buffer_to (iof *O, size_t space)
+{
+  uint8_t *buf;
+
+  if (O->flags & IOF_BUFFER_ALLOC)
+  {
+    buf = (uint8_t *)util_realloc(O->buf, space);
+  }
+  else
+  {
+    buf = (uint8_t *)util_malloc(space);
+    memcpy(buf, O->buf, iof_size(O));
+    if (O->flags & IOF_BUFFER_HEAP)
+    {
+      iof_filter_buffer_free(O->buf);
+      O->flags &= ~IOF_BUFFER_HEAP;
+    }
+    O->flags |= IOF_BUFFER_ALLOC;
+
+  }
+  O->pos = buf + iof_size(O);
+  O->end = buf + space;
+  O->buf = buf;
+  O->space = space;
+  return iof_left(O);
+}
+
+/* */
+
+size_t iof_decoder_retval (iof *I, const char *type, iof_status status)
+{
+  switch (status)
+  {
+    case IOFERR:
+    case IOFEMPTY:             // should never happen as we set state.flush = 1 on decoders init
+      loggerf("%s decoder error (%d, %s)", type, status, iof_status_kind(status));
+      I->flags |= IOF_STOPPED;
+      return 0;
+    case IOFEOF:               // this is the last chunk,
+      I->flags |= IOF_STOPPED; // so stop it and fall
+    case IOFFULL:              // prepare pointers to read from I->buf
+      I->end = I->pos;
+      I->pos = I->buf;
+      return I->end - I->buf;
+  }
+  loggerf("%s decoder bug, invalid retval %d", type, status);
+  return 0;
+}
+
+size_t iof_encoder_retval (iof *O, const char *type, iof_status status)
+{
+  switch (status)
+  {
+    case IOFERR:
+    case IOFFULL:
+      loggerf("%s encoder error (%d, %s)", type, status, iof_status_kind(status));
+      return 0;
+    case IOFEMPTY:
+      O->pos = O->buf;
+      O->end = O->buf + O->space;
+      return O->space;
+    case IOFEOF:
+      return 0;
+  }
+  loggerf("%s encoder bug, invalid retval %d", type, status);
+  return 0;
+}
+
+/* file/stream state */
+
+typedef struct {
+  size_t length;
+  size_t offset;
+} file_state;
+
+
+#define file_state_init(state, off, len) ((state)->offset = off, (state)->length = len)
+
+typedef struct {
+  size_t length;
+  size_t offset;
+} stream_state;
+
+#define stream_state_init(state, off, len) ((state)->offset = off, (state)->length = len)
+
+static size_t file_read (iof *I)
+{
+  size_t bytes, tail;
+  if (I->flags & IOF_STOPPED)
+    return 0;
+  tail = iof_tail(I);
+  if ((bytes = tail + fread(I->buf + tail, sizeof(uint8_t), I->space - tail, I->file)) < I->space)
+    I->flags |= IOF_STOPPED;
+  I->pos = I->buf;
+  I->end = I->buf + bytes;
+  return bytes;
+}
+
+static size_t iofile_read (iof *I, size_t *poffset)
+{
+  size_t bytes, tail;
+  if (I->flags & IOF_STOPPED)
+    return 0;
+  iof_file_sync(I->iofile, poffset);
+  tail = iof_tail(I);
+  if ((bytes = tail + iof_file_read(I->buf + tail, sizeof(uint8_t), I->space - tail, I->iofile)) < I->space)
+  {
+    I->flags |= IOF_STOPPED;
+    iof_file_unsync(I->iofile, poffset);
+  }
+  I->pos = I->buf;
+  I->end = I->buf + bytes;
+  return bytes;
+}
+
+static size_t file_load (iof *I)
+{
+  size_t bytes, left, tail;
+  if (I->flags & IOF_STOPPED)
+    return 0;
+  tail = iof_tail(I);
+  I->pos = I->buf + tail;
+  I->end = I->buf + I->space; /* don't assume its done when initializing the filter */
+  left = I->space - tail;
+  do {
+    bytes = fread(I->pos, sizeof(uint8_t), left, I->file);
+    I->pos += bytes;
+  } while (bytes == left && (left = iof_resize_buffer(I)) > 0);
+  I->flags |= IOF_STOPPED;
+  return iof_loaded(I);
+}
+
+static size_t iofile_load (iof *I, size_t *poffset)
+{
+  size_t bytes, left, tail;
+  if (I->flags & IOF_STOPPED)
+    return 0;
+  tail = iof_tail(I);
+  I->pos = I->buf + tail;
+  I->end = I->buf + I->space; /* don't assume its done when initializing the filter */
+  left = I->space - tail;
+  iof_file_sync(I->iofile, poffset);
+  do {
+    bytes = iof_file_read(I->pos, sizeof(uint8_t), left, I->iofile);
+    I->pos += bytes;
+  } while (bytes == left && (left = iof_resize_buffer(I)) > 0);
+  I->flags |= IOF_STOPPED;
+  iof_file_unsync(I->iofile, poffset);
+  return iof_loaded(I);
+}
+
+static size_t filter_file_reader (iof *I, iof_mode mode)
+{
+  switch (mode)
+  {
+    case IOFREAD:
+      return file_read(I);
+    case IOFLOAD:
+      return file_load(I);
+    case IOFCLOSE:
+      iof_free(I);
+      return 0;
+    default:
+      return 0;
+  }
+}
+
+static size_t filter_iofile_reader (iof *I, iof_mode mode)
+{
+  file_state *state;
+  state = iof_filter_state(file_state *, I);
+  switch (mode)
+  {
+    case IOFREAD:
+      return iofile_read(I, &state->offset);
+    case IOFLOAD:
+      return iofile_load(I, &state->offset);
+    case IOFCLOSE:
+      iof_free(I);
+      return 0;
+    default:
+      return 0;
+  }
+}
+
+static size_t file_write (iof *O, int flush)
+{
+  size_t bytes;
+  if ((bytes = iof_size(O)) > 0)
+    if (bytes != fwrite(O->buf, sizeof(uint8_t), bytes, O->file))
+      return 0;
+  if (flush)
+    fflush(O->file);
+  O->end = O->buf + O->space; // remains intact actually
+  O->pos = O->buf;
+  return O->space;
+}
+
+static size_t iofile_write (iof *O, size_t *poffset, int flush)
+{
+  size_t bytes;
+  iof_file_sync(O->iofile, poffset);
+  if ((bytes = iof_size(O)) > 0)
+  {
+    if (bytes != iof_file_write(O->buf, sizeof(uint8_t), bytes, O->iofile))
+    {
+      iof_file_unsync(O->iofile, poffset);
+      return 0;
+    }
+  }
+  if (flush)
+    iof_file_flush(O->iofile);
+  O->end = O->buf + O->space; // remains intact actually
+  O->pos = O->buf;
+  return O->space;
+}
+
+static size_t filter_file_writer (iof *O, iof_mode mode)
+{
+  switch (mode)
+  {
+    case IOFWRITE:
+      return file_write(O, 0);
+    case IOFFLUSH:
+      return file_write(O, 1);
+    case IOFCLOSE:
+      file_write(O, 1);
+      iof_free(O);
+      return 0;
+    default:
+      return 0;
+  }
+}
+
+static size_t filter_iofile_writer (iof *O, iof_mode mode)
+{
+  file_state *state;
+  state = iof_filter_state(file_state *, O);
+  switch (mode)
+  {
+    case IOFWRITE:
+      return iofile_write(O, &state->offset, 0);
+    case IOFFLUSH:
+      return iofile_write(O, &state->offset, 1);
+    case IOFCLOSE:
+      iofile_write(O, &state->offset, 1);
+      iof_free(O);
+      return 0;
+    default:
+      return 0;
+  }
+}
+
+/* filter from FILE* */
+
+iof * iof_filter_file_handle_reader (FILE *file)
+{
+  iof *I;
+  file_state *state;
+  if (file == NULL)
+    return NULL;
+  I = iof_filter_reader(filter_file_reader, sizeof(file_state), &state);
+  iof_setup_file(I, file);
+  file_state_init(state, 0, 0);
+  return I;
+}
+
+iof * iof_filter_file_handle_writer (FILE *file)
+{
+  iof *O;
+  file_state *state;
+  if (file == NULL)
+    return NULL;
+  O = iof_filter_writer(filter_file_writer, sizeof(file_state), &state);
+  iof_setup_file(O, file);
+  file_state_init(state, 0, 0);
+  return O;
+}
+
+/* filter from iof_file * */
+
+iof * iof_filter_iofile_reader (iof_file *iofile, size_t offset)
+{
+  iof *I;
+  file_state *state;
+  if (!iof_file_reopen(iofile))
+    return NULL;
+  I = iof_filter_reader(filter_iofile_reader, sizeof(file_state), &state);
+  iof_setup_iofile(I, iofile);
+  file_state_init(state, offset, 0);
+  return I;
+}
+
+iof * iof_filter_iofile_writer (iof_file *iofile, size_t offset)
+{
+  iof *O;
+  file_state *state;
+  O = iof_filter_writer(filter_iofile_writer, sizeof(file_state), &state);
+  iof_setup_iofile(O, iofile);
+  file_state_init(state, offset, 0);
+  return O;
+}
+
+/* filter from filename */
+
+iof * iof_filter_file_reader (const char *filename)
+{
+  iof *I;
+  file_state *state;
+  FILE *file;
+  if ((file = fopen(filename, "rb")) == NULL)
+    return NULL;
+  I = iof_filter_reader(filter_file_reader, sizeof(file_state), &state);
+  iof_setup_file(I, file);
+  file_state_init(state, 0, 0);
+  I->flags |= IOF_CLOSE_FILE;
+  return I;
+}
+
+iof * iof_filter_file_writer (const char *filename)
+{
+  iof *O;
+  file_state *state;
+  FILE *file;
+  if ((file = fopen(filename, "wb")) == NULL)
+    return NULL;
+  O = iof_filter_writer(filter_file_writer, sizeof(file_state), &state);
+  iof_setup_file(O, file);
+  file_state_init(state, 0, 0);
+  O->flags |= IOF_CLOSE_FILE;
+  return O;
+}
+
+/* from string */
+
+static size_t dummy_handler (iof *I, iof_mode mode)
+{
+  switch (mode)
+  {
+    case IOFCLOSE:
+      iof_free(I);
+      return 0;
+    default:
+      return 0;
+  }
+}
+
+iof * iof_filter_string_reader (const void *s, size_t length)
+{
+  iof *I;
+  void *dummy;
+  I = iof_filter_reader_with_buffer(dummy_handler, 0, &dummy, NULL, 0);
+  I->rbuf = I->rpos = (const uint8_t *)s;
+  I->rend = (const uint8_t *)s + length;
+  // I->space = length;
+  return I;
+}
+
+iof * iof_filter_string_writer (const void *s, size_t length)
+{
+  iof *O;
+  void *dummy;
+  O = iof_filter_reader_with_buffer(dummy_handler, 0, &dummy, NULL, 0);
+  O->rbuf = O->rpos = (const uint8_t *)s;
+  O->rend = (const uint8_t *)s + length;
+  // O->space = length;
+  return O;
+}
+
+iof * iof_filter_buffer_writer (size_t size)
+{ // filter alternative of iof_buffer_create()
+  iof *O;
+  void *dummy;
+  uint8_t *buffer;
+  if (size > IOF_BUFFER_SIZE)
+  {
+    buffer = (uint8_t *)util_malloc(size);
+    O = iof_filter_writer_with_buffer(iof_mem_handler, 0, &dummy, buffer, size);
+    O->flags |= IOF_BUFFER_ALLOC;
+    return O;
+  }
+	return iof_filter_writer(iof_mem_handler, 0, &dummy);
+}
+
+/* stream */
+
+static size_t file_stream_read (iof *I, size_t *plength)
+{
+  size_t bytes, tail;
+  if (I->flags & IOF_STOPPED || *plength == 0)
+    return 0;
+  tail = iof_tail(I);
+  if (I->space - tail >= *plength)
+  {
+    bytes = tail + fread(I->buf + tail, sizeof(uint8_t), *plength, I->file);
+    I->flags |= IOF_STOPPED;
+    *plength = 0;
+  }
+  else
+  {
+    bytes = tail + fread(I->buf + tail, sizeof(uint8_t), I->space - tail, I->file);
+    *plength -= bytes - tail;
+  }
+  I->pos = I->buf;
+  I->end = I->buf + bytes;
+  return bytes;
+}
+
+static size_t iofile_stream_read (iof *I, size_t *plength, size_t *poffset)
+{
+  size_t bytes, tail;
+  if (I->flags & IOF_STOPPED || *plength == 0)
+    return 0;
+  tail = iof_tail(I);
+  iof_file_sync(I->iofile, poffset);
+  if (I->space - tail >= *plength)
+  {
+    bytes = tail + iof_file_read(I->buf + tail, sizeof(uint8_t), *plength, I->iofile);
+    iof_file_unsync(I->iofile, poffset);
+    I->flags |= IOF_STOPPED;
+    *plength = 0;
+  }
+  else
+  {
+    bytes = tail + iof_file_read(I->buf + tail, sizeof(uint8_t), I->space - tail, I->iofile);
+    *plength -= bytes - tail;
+  }
+  I->pos = I->buf;
+  I->end = I->buf + bytes;
+  return bytes;
+}
+
+static size_t file_stream_load (iof *I, size_t *plength)
+{
+  size_t bytes, tail;
+  if (I->flags & IOF_STOPPED || *plength == 0)
+    return 0;
+  tail = iof_tail(I);
+  if (I->space - tail < *plength)
+    if (iof_resize_buffer_to(I, tail + *plength) == 0)
+      return 0;
+  bytes = tail + fread(I->buf + tail, sizeof(uint8_t), *plength, I->file);
+  I->flags |= IOF_STOPPED;
+  *plength = 0;
+  I->pos = I->buf;
+  I->end = I->buf + bytes;
+  return bytes;
+}
+
+static size_t iofile_stream_load (iof *I, size_t *plength, size_t *poffset)
+{
+  size_t bytes, tail;
+  if (I->flags & IOF_STOPPED || *plength == 0)
+    return 0;
+  iof_file_sync(I->iofile, poffset);
+  tail = iof_tail(I);
+  if (I->space - tail < *plength)
+    if (iof_resize_buffer_to(I, tail + *plength) == 0)
+      return 0;
+  bytes = tail + iof_file_read(I->buf + tail, sizeof(uint8_t), *plength, I->iofile);
+  iof_file_unsync(I->iofile, poffset);
+  I->flags |= IOF_STOPPED;
+  *plength = 0;
+  I->pos = I->buf;
+  I->end = I->buf + bytes;
+  return bytes;
+}
+
+static size_t filter_file_stream_reader (iof *I, iof_mode mode)
+{
+  stream_state *state;
+  state = iof_filter_state(stream_state *, I);
+  switch(mode)
+  {
+    case IOFREAD:
+      return file_stream_read(I, &state->length);
+    case IOFLOAD:
+      return file_stream_load(I, &state->length);
+    case IOFCLOSE:
+      iof_free(I);
+      return 0;
+    default:
+      return 0;
+  }
+}
+
+static size_t filter_iofile_stream_reader (iof *I, iof_mode mode)
+{
+  stream_state *state;
+  state = iof_filter_state(stream_state *, I);
+  switch(mode)
+  {
+    case IOFREAD:
+      return iofile_stream_read(I, &state->length, &state->offset);
+    case IOFLOAD:
+      return iofile_stream_load(I, &state->length, &state->offset);
+    case IOFCLOSE:
+      iof_free(I);
+      return 0;
+    default:
+      return 0;
+  }
+}
+
+iof * iof_filter_stream_reader (FILE *file, size_t offset, size_t length)
+{
+  iof *I;
+  stream_state *state;
+  I = iof_filter_reader(filter_file_stream_reader, sizeof(stream_state), &state);
+  iof_setup_file(I, file);
+  stream_state_init(state, offset, length);
+  fseek(file, (long)offset, SEEK_SET); // or perhaps it should be call in file_stream_read(), like iof_file_sync()?
+  return I;
+}
+
+iof * iof_filter_stream_coreader (iof_file *iofile, size_t offset, size_t length)
+{
+  iof *I;
+  stream_state *state;
+  if (!iof_file_reopen(iofile))
+    return NULL;
+  I = iof_filter_reader(filter_iofile_stream_reader, sizeof(stream_state), &state);
+  iof_setup_iofile(I, iofile);
+  stream_state_init(state, offset, length);
+  return I;
+}
+
+static size_t file_stream_write (iof *O, size_t *plength, int flush)
+{
+  size_t bytes;
+  if ((bytes = iof_size(O)) > 0)
+  {
+    if (bytes != fwrite(O->buf, sizeof(uint8_t), bytes, O->file))
+    {
+      *plength += bytes;
+      return 0;
+    }
+  }
+  if (flush)
+    fflush(O->file);
+  *plength += bytes;
+  O->end = O->buf + O->space; // remains intact
+  O->pos = O->buf;
+  return O->space;
+}
+
+static size_t iofile_stream_write (iof *O, size_t *plength, size_t *poffset, int flush)
+{
+  size_t bytes;
+  if ((bytes = iof_size(O)) > 0)
+  {
+    iof_file_sync(O->iofile, poffset);
+    if (bytes != iof_file_write(O->buf, sizeof(uint8_t), bytes, O->iofile))
+    {
+      *plength += bytes;
+      iof_file_unsync(O->iofile, poffset);
+      return 0;
+    }
+  }
+  if (flush)
+    iof_file_flush(O->iofile);
+  *plength += bytes;
+  O->end = O->buf + O->space; // remains intact
+  O->pos = O->buf;
+  return O->space;
+}
+
+static size_t filter_file_stream_writer (iof *O, iof_mode mode)
+{
+  stream_state *state;
+  state = iof_filter_state(stream_state *, O);
+  switch (mode)
+  {
+    case IOFWRITE:
+      return file_stream_write(O, &state->length, 0);
+    case IOFFLUSH:
+      return file_stream_write(O, &state->length, 1);
+    case IOFCLOSE:
+      file_stream_write(O, &state->length, 1);
+      iof_free(O);
+      return 0;
+    default:
+      return 0;
+  }
+}
+
+static size_t filter_iofile_stream_writer (iof *O, iof_mode mode)
+{
+  stream_state *state;
+  state = iof_filter_state(stream_state *, O);
+  switch (mode)
+  {
+    case IOFWRITE:
+      return iofile_stream_write(O, &state->length, &state->offset, 0);
+    case IOFFLUSH:
+      return iofile_stream_write(O, &state->length, &state->offset, 1);
+    case IOFCLOSE:
+      iofile_stream_write(O, &state->length, &state->offset, 1);
+      iof_free(O);
+      return 0;
+    default:
+      return 0;
+  }
+}
+
+iof * iof_filter_stream_writer (FILE *file)
+{
+  iof *O;
+  stream_state *state;
+  O = iof_filter_writer(filter_file_stream_writer, sizeof(stream_state), &state);
+  iof_setup_file(O, file);
+  stream_state_init(state, 0, 0);
+  return O;
+}
+
+iof * iof_filter_stream_cowriter (iof_file *iofile, size_t offset)
+{
+  iof *O;
+  stream_state *state;
+  O = iof_filter_writer(filter_iofile_stream_writer, sizeof(stream_state), &state);
+  iof_setup_iofile(O, iofile);
+  stream_state_init(state, offset, 0);
+  return O;
+}
+
+/* very specific for images; get input from already created strem filter, exchange the filter but keep the buffer */
+
+FILE * iof_filter_file_reader_source (iof *I, size_t *poffset, size_t *plength)
+{
+  stream_state *sstate;
+  file_state *fstate;
+  if (I->more == filter_file_stream_reader) // I is the result of iof_filter_stream_reader()
+  {
+    sstate = iof_filter_state(stream_state *, I);
+    *poffset = sstate->offset;
+    *plength = sstate->length; // might be 0 but it is ok for file readers
+    return I->file;
+  }
+  if (I->more == filter_file_reader)
+  {
+    fstate = iof_filter_state(file_state *, I);
+    *poffset = fstate->offset;
+    *plength = fstate->length; // might be 0 but it is ok for file readers
+    return I->file;
+  }
+  return NULL;
+}
+
+iof_file * iof_filter_file_coreader_source (iof *I, size_t *poffset, size_t *plength)
+{
+  stream_state *sstate;
+  file_state *fstate;
+  if (I->more == filter_iofile_stream_reader) // I is the result of iof_filter_stream_coreader()
+  {
+    sstate = iof_filter_state(stream_state *, I);
+    *poffset = sstate->offset;
+    *plength = sstate->length;
+    return I->iofile;
+  }
+  if (I->more == filter_iofile_reader)
+  {
+    fstate = iof_filter_state(file_state *, I);
+    *poffset = fstate->offset;
+    *plength = fstate->length;
+    return I->iofile;
+  }
+  return NULL;
+}
+
+iof * iof_filter_reader_replacement (iof *P, iof_handler handler, size_t statesize, void **pstate)
+{ // called after iof_filter_file_reader_source(), no need to check if F is filter from iof heap and if has buffer from iof heap
+  iof *F;
+  F = iof_filter_reader_with_buffer(handler, statesize, pstate, P->buf, P->space);
+  F->flags |= IOF_BUFFER_HEAP;
+  //iof_reader_buffer(P, NULL, 0);
+  //P->flags &= ~IOF_BUFFER_HEAP;
+  iof_filter_free(P);
+  return F;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/texk/web2c/luatexdir/luapplib/util/utiliof.h b/texk/web2c/luatexdir/luapplib/util/utiliof.h
new file mode 100644
index 000000000..853a9ae52
--- /dev/null
+++ b/texk/web2c/luatexdir/luapplib/util/utiliof.h
@@ -0,0 +1,669 @@
+
+#ifndef UTIL_IOF_H
+#define UTIL_IOF_H
+
+#include <stdio.h>  // for FILE *
+#include <errno.h>  // for errno
+#include <string.h> // for strerror()
+#include <stdint.h> // for uintN_t
+
+#include "utildecl.h"
+#include "utilnumber.h"
+
+/* handler call modes */
+
+typedef enum {
+  IOFREAD  = 0, /* read to buffer */
+  IOFLOAD  = 1, /* read all to buffer */
+  IOFWRITE = 2, /* write buffer to the output */
+  IOFFLUSH = 3, /* flush buffer to the output */
+  IOFCLOSE = 4  /* (flush and) close */
+} iof_mode;
+
+/* return statuses */
+
+typedef enum {
+  IOFEOF   = -1, /* end of input */
+  IOFEMPTY = -2, /* end of input buffer*/
+  IOFFULL  = -3, /* end of output buffer */
+  IOFERR   = -4  /* error */
+} iof_status;
+
+const char * iof_status_kind (iof_status status);
+
+/* iof_file */
+
+typedef struct iof_file {
+  union {
+    FILE *iofh; // access via iof_file_get_fh / iof_file_set_fh (below)
+    union {
+    	struct { uint8_t *buf, *pos, *end; };
+    	struct { const uint8_t *rbuf, *rpos, *rend; }; // to trick compiler warnings about cast discarding const
+    };
+  };
+  size_t *offset;
+  char *name;
+  size_t size;
+  int refcount;
+  int flags;
+} iof_file;
+
+/* iof handler function */
+
+typedef struct iof iof;
+typedef size_t (*iof_handler) (iof *I, iof_mode mode);
+
+/* iof structure */
+
+#define IOF_MEMBERS \
+  union { \
+    struct { uint8_t *buf, *pos, *end; }; \
+    struct { uint16_t *hbuf, *hpos, *hend; }; \
+    struct { uint32_t *ibuf, *ipos, *iend; }; \
+    struct { const uint8_t *rbuf, *rpos, *rend; }; \
+  }; \
+  size_t space; \
+  iof_handler more; \
+  union { iof *next; FILE *file; iof_file *iofile; void *link; }; \
+  int flags; \
+  int refcount
+
+/*
+  buf -- the beginning of buffer
+  pos -- the current position
+  end -- the end of buffer
+  space -- private space size, not always eq. (end - buf)
+  more -- handler function
+  next/file/iofile/link -- reader source or writer target
+  source -- source filter
+  flags -- private filter info
+  refcount -- refcount
+*/
+
+struct iof {
+  IOF_MEMBERS;
+};
+
+typedef void (*iof_dump_function) (const void *value, iof *O);
+
+/* flags */
+
+#define IOF_ALLOC          (1<<0) // iof is allocated
+#define IOF_HEAP           (1<<1) // iof taken from iof heap
+#define IOF_BUFFER_ALLOC   (1<<2) // buffer allocated
+#define IOF_BUFFER_HEAP    (1<<3) // buffer taken from iof heap
+
+#define IOF_SHORT          (1<<4) // buffer uses 16bit integers
+#define IOF_LONG           (1<<5) // buffer uses 32bit integers
+
+#define IOF_TAIL           (1<<6) // preserve reader tail
+#define IOF_READER         (1<<7) // is reader
+#define IOF_WRITER         (1<<8) // is writer
+
+#define IOF_DATA           (1<<9)  // binds some memory
+#define IOF_FILE_HANDLE    (1<<10) // links FILE *
+#define IOF_FILE           (1<<11) // links iof_file *
+#define IOF_NEXT           (1<<12) // links next iof *
+#define IOF_CLOSE_FILE     (1<<13) // close FILE * on free
+#define IOF_REOPEN_FILE    (1<<14) // close/reopen mode for iof_file
+#define IOF_RECLOSE_FILE   (1<<15) // ditto
+
+#define IOF_STOPPED        (1<<16) // stopped
+
+// #define IOF_CUSTOM         (1<<17) // first custom flag
+
+#define IOF_BUFSIZ (sizeof(iof) + BUFSIZ*sizeof(uint8_t))
+
+/*
+reading buffer -- all of buf, pos, end pointers are initialized to the beginning of the private buffer,
+  next call to a handler function moves the end pointer to bufer+space
+writer -- buf and pos pointers initialized to the beginning of the buffer, end initialized to bufer+space
+
+Every call to handler returns size_t number of bytes
+available (to write/read) or 0 if there is no more space.
+
+We usually align the data buffer just after the iof structure.
+This is convenient, especially when a memory for the structure
+and its buffer is to be allocated. In the case of growing output
+buffers we used to check if the memory of the buffer is allocated
+by the handler function using test (O->buf != (O+1)). We don't use
+it any longer not to rely on little secrets. Now there is an explicit
+IOF_BUFFER_ALLOC flag for that. IOF_ALLOC tells if the structure
+itself is taken from malloc (not used so far). Assuming the buffer size
+is way larger the sizeof(iof)
+*/
+
+/* initializers */
+
+#define IOF_READER_STRUCT(handler, file, buffer, size, flags) \
+  { {{ (uint8_t *)(buffer), (uint8_t *)(buffer), (uint8_t *)(buffer) }}, size, handler, { file }, flags|IOF_READER, 0 }
+
+#define IOF_WRITER_STRUCT(handler, file, buffer, size, flags) \
+  { {{ (uint8_t *)(buffer), (uint8_t *)(buffer), (uint8_t *)(buffer) + size }}, size, handler, { file }, flags|IOF_WRITER, 0 }
+
+#define IOF_STRING_STRUCT(buffer, size) \
+  { {{ (uint8_t *)(buffer), (uint8_t *)(buffer), (uint8_t *)(buffer) + size }}, size, NULL, { NULL }, 0|IOF_READER|IOF_DATA, 0 }
+
+#define IOF_STRING() IOF_STRING_STRUCT(0, 0)
+
+/* refcount */
+
+#define iof_incref(I) (++(I)->refcount)
+#define iof_decref(I) ((void)(--(I)->refcount <= 0 && iof_close(I)))
+#define iof_unref(I) (--(I)->refcount)
+
+/* setting up iof and buffer from mem buffer of a given size */
+
+#define iof_setup_reader(I, buffer, size) \
+  ((I) = (iof *)(buffer), iof_reader_buffer(I, (I)+1, size - sizeof(iof)))
+
+#define iof_setup_writer(O, buffer, size) \
+  ((O) = (iof *)buffer, iof_writer_buffer(O, (O)+1, size - sizeof(iof)))
+
+/* binding buffer of a given size */
+
+#define iof_reader_buffer(I, buffer, size) \
+  ((I)->buf = (I)->pos = (I)->end = (uint8_t *)(buffer), \
+   (I)->space = size, (I)->flags = 0|IOF_READER, (I)->refcount = 0)
+
+#define iof_writer_buffer(O, buffer, size) \
+  ((O)->buf = (O)->pos = (uint8_t *)(buffer), \
+   (O)->end = (uint8_t *)(buffer) + size, \
+   (O)->space = size, (O)->flags = 0|IOF_WRITER, (O)->refcount = 0)
+
+/* basics */
+
+#define iof_space(I) ((I)->end - (I)->buf)
+#define iof_left(I)  ((I)->end - (I)->pos)
+#define iof_size(I)  ((I)->pos - (I)->buf)
+
+#define iof_input(I)  ((I)->more ? (I)->more((I), IOFREAD) : 0lu)
+#define iof_load(I)   ((I)->more ? (I)->more((I), IOFLOAD) : 0lu)
+
+#define iof_output(O) ((O)->more ? (O)->more((O), IOFWRITE) : 0lu)
+//#define iof_flush(O)  ((O)->pos > (O)->buf && (O)->more ? (O)->more(O, IOFFLUSH) : 0lu)
+// flush should be unconditional, because encoders emits EOD markers only on flush
+#define iof_flush(O) ((O)->more ? (O)->more(O, IOFFLUSH) : 0lu)
+#define iof_close(O)  ((O)->more ? (O)->more(O, IOFCLOSE) : 0lu)
+
+#define iof_stop(F) ((void)(F->pos = F->end = F->buf, F->flags |= IOF_STOPPED))
+
+/*
+Rewriting reader tail to the beginning of new data portion; readers reacting on IOFREAD
+mode must be aware of some not yet read data, but treat it necessary only if IOF_TAIL flag is set.
+Parsers using iof input may protect not yet read data when there may be a need to put bytes
+back to the stream. This is trivial when I->pos > I->buf, as we can make a move by --I->pos.
+But when there is a need to put back more then one byte, we can protect the data tail, so that
+realoder will rewrite it to the beginning of new data chunk. 
+
+  iof_tail(I) - internal, used by iof handlers at IOFREAD mode
+  iof_protect_tail(I) - used by parsers to ensure some bytes chunk in one piece
+
+*/
+
+size_t iof_save_tail (iof *I);
+#define iof_tail(I) (((I)->flags & IOF_TAIL) && (I)->pos < (I)->end ? iof_save_tail(I) : 0)
+
+size_t iof_input_save_tail (iof *I, size_t back);
+#define iof_protect_tail(I, back, length) ((iof_left(I) >= (length) - (back)) ? 1 : (iof_input_save_tail(I, back) >= length - back))
+
+//uint8_t * iof_tail_data (iof *I, size_t *ptail);
+//#define iof_tail_free(data) util_free(data)
+
+/* panic */
+
+// #define iof_panic(mess) return 0
+#ifndef iof_panic
+  #define iof_panic(mess) (fputs(mess, stderr), abort())
+#endif
+//#define iof_memory_error() iof_panic(strerror(errno))
+#define iof_fwrite_error() iof_panic(strerror(errno))
+
+/* generic helpers */
+
+UTILAPI uint8_t * iof_copy_file_data (const char *filename, size_t *psize);
+UTILAPI uint8_t * iof_copy_file_handle_data (FILE *file, size_t *psize);
+
+/* In the future we may need releasing file handle and restoring it from iofile->name, so access file handle via macros */
+
+#define iof_file_get_fh(iofile) ((iofile)->iofh)
+#define iof_file_set_fh(iofile, fh) ((iofile)->iofh = fh)
+#define iof_file_get_file(iofile) (((iofile)->flags & IOF_DATA) ? NULL : iof_file_get_fh(iofile))
+FILE * iof_get_file (iof *F);
+
+/* basic iof_file interface */
+
+iof_file * iof_file_new (FILE *file);
+iof_file * iof_file_init (iof_file *iofile, FILE *file);
+
+iof_file * iof_file_rdata (const void *data, size_t size);
+iof_file * iof_file_wdata (void *data, size_t size);
+
+iof_file * iof_file_rdata_init (iof_file *iofile, const void *data, size_t size);
+iof_file * iof_file_wdata_init (iof_file *iofile, void *data, size_t size);
+
+iof_file * iof_file_reader_from_file_handle (iof_file *iofile, const char *filename, FILE *file, int preload, int closefile);
+iof_file * iof_file_reader_from_file (iof_file *iofile, const char *filename, int preload);
+iof_file * iof_file_reader_from_data (iof_file *iofile, const void *data, size_t size, int preload, int freedata);
+//iof_file * iof_file_writer_from_file (iof_file *iofile, const char *filename);
+
+void * iof_copy_data (const void *data, size_t size);
+#define iof_data_free(data) util_free(data)
+#define iof_file_wdata_copy(data, size) iof_file_wdata(iof_copy_data(data, size), size)
+#define iof_file_rdata_copy(data, size) iof_file_rdata(iof_copy_data(data, size), size)
+
+void iof_file_free (iof_file *iofile);
+
+#define iof_file_get_name(iofile) ((iofile)->name)
+void iof_file_set_name (iof_file *iofile, const char *name);
+
+#define iof_file_incref(iofile) (++(iofile)->refcount)
+#define iof_file_decref(iofile) ((void)(--(iofile)->refcount <= 0 && (iof_file_free(iofile), 0)))
+
+int iof_file_seek (iof_file *iofile, long offset, int whence);
+long iof_file_tell (iof_file *iofile);
+size_t iof_file_size (iof_file *iofile);
+int iof_file_eof (iof_file *iofile);
+
+size_t iof_file_read (void *ptr, size_t size, size_t items, iof_file *iofile);
+size_t iof_file_write (const void *ptr, size_t size, size_t items, iof_file *iofile);
+size_t iof_file_ensure (iof_file *iofile, size_t bytes);
+int iof_file_flush (iof_file *iofile);
+
+int iof_file_getc (iof_file *iofile);
+int iof_file_putc (iof_file *iofile, int c);
+
+int iof_file_close_input (iof_file *iofile);
+int iof_file_reopen_input (iof_file *iofile);
+
+#define iof_file_reopen(iofile) (((iofile)->flags & IOF_REOPEN_FILE) ? iof_file_reopen_input(iofile) : 1)
+#define iof_file_reclose(iofile) (void)(((iofile)->flags & IOF_RECLOSE_FILE) ? iof_file_close_input(iofile) : 0)
+
+/* wrappers of basic operations for iof */
+
+int iof_reader_seek (iof *I, long offset, int whence);
+int iof_reader_reseek (iof *I, long offset, int whence);
+int iof_writer_seek (iof *I, long offset, int whence);
+int iof_writer_reseek (iof *I, long offset, int whence);
+
+int iof_seek (iof *I, long offset, int whence);
+int iof_reseek (iof *I, long offset, int whence);
+
+long iof_reader_tell (iof *I);
+long iof_writer_tell (iof *I);
+long iof_tell (iof *I);
+size_t iof_fsize (iof *I);
+
+#define iof_setup_iofile(I, f) (iof_file_incref(f), (I)->iofile = f, (I)->flags |= IOF_FILE)
+#define iof_setup_file(I, fh) ((I)->file = fh, (I)->flags |= IOF_FILE_HANDLE)
+#define iof_setup_next(I, N) ((I)->next = N, iof_incref(N), (I)->flags |= IOF_NEXT)
+
+/* file handler reader and writer */
+
+UTILAPI iof * iof_setup_file_handle_reader (iof *I, void *buffer, size_t space, FILE *f);
+UTILAPI iof * iof_setup_file_handle_writer (iof *O, void *buffer, size_t space, FILE *f);
+
+#define iof_get_file_handle_reader(buffer, space, fh) iof_setup_file_handle_reader(NULL, buffer, space, fh)
+#define iof_get_file_handle_writer(buffer, space, fh) iof_setup_file_handle_writer(NULL, buffer, space, fh)
+
+/* file reader and writer */
+
+UTILAPI iof * iof_setup_file_reader (iof *I, void *buffer, size_t space, const char *filename);
+UTILAPI iof * iof_setup_file_writer (iof *O, void *buffer, size_t space, const char *filename);
+
+#define iof_get_file_reader(buffer, space, filename) iof_setup_file_reader(NULL, buffer, space, filename)
+#define iof_get_file_writer(buffer, space, filename) iof_setup_file_writer(NULL, buffer, space, filename)
+
+/* mem writer */
+
+UTILAPI iof * iof_setup_buffer (iof *O, void *buffer, size_t space);
+UTILAPI iof * iof_setup_buffermin (iof *O, void *buffer, size_t space, size_t min);
+
+#define iof_buffer(buffer, space) iof_setup_buffer(NULL, buffer, space)
+#define iof_buffermin(buffer, space, min) iof_setup_buffermin(NULL, buffer, space, min)
+
+UTILAPI iof * iof_buffer_create (size_t space);
+#define iof_buffer_new() iof_buffer_create(BUFSIZ)
+
+/* custom handler */
+
+UTILAPI iof * iof_reader (iof *I, void *link, iof_handler reader, const void *s, size_t bytes);
+UTILAPI iof * iof_writer (iof *O, void *link, iof_handler writer,       void *s, size_t bytes);
+
+/* stdout wrapper */
+
+extern UTILAPI iof iof_stdout;
+extern UTILAPI iof iof_stderr;
+
+/* simple string reader */
+
+UTILAPI iof * iof_string_reader (iof *I, const void *s, size_t bytes);
+
+#define iof_string(I, s, bytes) \
+  (((I)->rbuf = (I)->rpos = (const uint8_t *)s), ((I)->rend = (I)->rbuf + (bytes)), ((I)->flags |= IOF_DATA), (I))
+
+/* dummies */
+
+UTILAPI iof * iof_dummy (void *buffer, size_t space);
+UTILAPI iof * iof_null (void *buffer, size_t space);
+
+/* checking available space */
+
+#define iof_loadable(I) ((I)->pos < (I)->end || iof_load(I))
+#define iof_readable(I) ((I)->pos < (I)->end || iof_input(I))
+#define iof_writable(O) ((O)->pos < (O)->end || iof_output(O))
+
+#define iof_hloadable iof_loadable
+#define iof_iloadable iof_loadable
+
+#define iof_hreadable iof_readable
+#define iof_ireadable iof_readable
+
+#define iof_hwritable iof_writable
+#define iof_iwritable iof_writable
+
+/* ensure space to write several bytes (several means less then I->space) */
+
+#define iof_ensure(O, n) ((O)->pos+(n)-1 < (O)->end || iof_output(O)) // iof_ensure(O, 1) eq iof_writable(O)
+#define iof_hensure(O, n) ((O)->hpos+(n)-1 < (O)->hend || iof_output(O))
+#define iof_iensure(O, n) ((O)->ipos+(n)-1 < (O)->iend || iof_output(O))
+
+/* reading */
+
+UTILAPI int iof_getc (iof *I);
+UTILAPI int iof_hgetc (iof *I);
+UTILAPI int iof_igetc (iof *I);
+
+// UTILAPI int iof_cmp (iof *I, const char *s);
+// UTILAPI int iof_cmpn (iof *I, const char *s, size_t bytes);
+
+UTILAPI iof_status iof_pass (iof *I, iof *O);
+#define iof_hpass iof_pass
+#define iof_ipass iof_pass
+
+/* readers helpers */
+
+UTILAPI size_t iof_read (iof *I, void *s, size_t bytes);
+UTILAPI size_t iof_hread (iof *I, void *s, size_t bytes);
+UTILAPI size_t iof_iread (iof *I, void *s, size_t bytes);
+
+UTILAPI size_t iof_skip (iof *I, size_t bytes);
+UTILAPI size_t iof_hskip (iof *I, size_t bytes);
+UTILAPI size_t iof_iskip (iof *I, size_t bytes);
+
+/* get */
+
+#define iof_pos(I)  (*(I)->pos++)
+#define iof_hpos(I) (*(I)->hpos++)
+#define iof_ipos(I) (*(I)->ipos++)
+
+#define iof_get(I)  (iof_readable(I)  ? (int)(*(I)->pos++)  : IOFEOF)
+#define iof_hget(I) (iof_hreadable(I) ? (int)(*(I)->hpos++) : IOFEOF)
+#define iof_iget(I) (iof_ireadable(I) ? (int)(*(I)->ipos++) : IOFEOF)
+
+#define iof_char(I)  (iof_readable(I)  ? (int)(*(I)->pos) : IOFEOF)
+#define iof_hcurr(I) (iof_hreadable(I) ? (int)(*(I)->hpos) : IOFEOF)
+#define iof_icurr(I) (iof_ireadable(I) ? (int)(*(I)->ipos) : IOFEOF)
+
+#define iof_next(I)  (++(I)->pos, iof_char(I))
+#define iof_hnext(I) (++(I)->hpos, iof_hcurr(I))
+#define iof_inext(I) (++(I)->ipos, iof_icurr(I))
+
+/* unget */
+
+/*
+If possible, we just move the position backward. If it is not possible to
+move backward, we call iof_backup(I, c) that sets all pointers to the end of
+a private backup space, then moves buf AND pos pointers backward and set c at
+pos (==buf). We can backup characters as long as there is a private space. If
+several calls to iof_backup() are followed by iof_get(), pos pointer
+increases in normal way and so the use of another iof_unget() works just fine
+by moving the position. Once we swallow all backup characters (when
+pos==end), backup handler restores the previous pointers.
+
+Obviously we assume that the character provided to iof_unget() is always the
+character just obtained from iof_get(). We CAN'T just overwrite the character
+at a given position as the space we read may not be writable.
+
+When backup is in use, we can only get bytes until automatically restored.
+*/
+
+/* backup */
+
+/*
+#define iof_uses_backup(I) ((I)->more == iof_unget_handler)
+
+#define iof_save(I, B) \
+  ((B)->buf = (I)->buf, (B)->pos = (I)->pos, (B)->end = (I)->end, (B)->space = (I)->space, \
+   (B)->link = I->link, (B)->more = (I)->more, (B)->flags = (I)->flags)
+#define iof_restore(B, I) iof_save(I, B)
+
+#define iof_unget(I, c) \
+  ((void)(c == (uint8_t)c ? ((I)->pos > (I)->buf ? --(I)->pos : iof_backup(I, c)) : 0)
+int iof_backup (iof *I, int c);
+*/
+
+/* writing */
+
+UTILAPI size_t iof_write_file_handle (iof *O, FILE *file);
+UTILAPI size_t iof_write_file (iof *O, const char *filename);
+UTILAPI size_t iof_write_iofile (iof *O, iof_file *iofile, int savepos);
+
+UTILAPI int iof_putc (iof *O, int u);
+UTILAPI int iof_hputc (iof *O, int u);
+UTILAPI int iof_iputc (iof *O, int u);
+
+UTILAPI size_t iof_write (iof *O, const void *data, size_t size);
+UTILAPI size_t iof_hwrite (iof *O, const void *data, size_t size);
+UTILAPI size_t iof_iwrite (iof *O, const void *data, size_t size);
+
+UTILAPI iof_status iof_puts (iof *O, const void *data);
+UTILAPI size_t iof_put_string (iof *O, const void *data);
+UTILAPI size_t iof_putfs (iof *O, const char *format, ...);
+UTILAPI size_t iof_repc (iof *O, char c, size_t bytes);
+
+#define iof_putl(O, s) iof_write(O, "" s, sizeof(s)-1)
+//#define iof_putl iof_puts
+
+#define iof_set(O, c)               (*(O)->pos++ = (uint8_t)(c))
+#define iof_set2(O, c1, c2)         (iof_set(O, c1), iof_set(O, c2))
+#define iof_set3(O, c1, c2, c3)     (iof_set(O, c1), iof_set(O, c2), iof_set(O, c3))
+#define iof_set4(O, c1, c2, c3, c4) (iof_set(O, c1), iof_set(O, c2), iof_set(O, c3), iof_set(O, c4))
+#define iof_set5(O, c1, c2, c3, c4, c5) (iof_set(O, c1), iof_set(O, c2), iof_set(O, c3), iof_set(O, c4), iof_set(O, c5))
+
+#define iof_hset(O, c)              (*(O)->hpos++ = (uint16_t)(c))
+#define iof_iset(O, c)              (*(O)->ipos++ = (uint32_t)(c))
+
+#define iof_put(O, c)               ((void)iof_ensure(O, 1), iof_set(O, c))
+#define iof_put2(O, c1, c2)         ((void)iof_ensure(O, 2), iof_set2(O, c1, c2))
+#define iof_put3(O, c1, c2, c3)     ((void)iof_ensure(O, 3), iof_set3(O, c1, c2, c3))
+#define iof_put4(O, c1, c2, c3, c4) ((void)iof_ensure(O, 4), iof_set4(O, c1, c2, c3, c4))
+#define iof_put5(O, c1, c2, c3, c4, c5) ((void)iof_ensure(O, 5), iof_set5(O, c1, c2, c3, c4, c5))
+
+#define iof_hput(O, c)               ((void)iof_hensure(O, 1), iof_hset(O, c))
+#define iof_iput(O, c)               ((void)iof_iensure(O, 1), iof_iset(O, c))
+
+#define iof_put_uc_hex(O, c) iof_put2(O, base16_uc_digit1(c), base16_uc_digit2(c))
+#define iof_put_lc_hex(O, c) iof_put2(O, base16_lc_digit1(c), base16_lc_digit2(c))
+#define iof_set_uc_hex(O, c) iof_set2(O, base16_uc_digit1(c), base16_uc_digit2(c))
+#define iof_set_lc_hex(O, c) iof_set2(O, base16_lc_digit1(c), base16_lc_digit2(c))
+#define iof_put_hex iof_put_uc_hex
+#define iof_set_hex iof_set_uc_hex
+
+/* number from iof; return 1 on success, 0 otherwise */
+
+#define iof_scan_sign(I, c, sign) _scan_sign(c, sign, iof_next(I))
+#define iof_scan_integer(I, c, number) _scan_integer(c, number, iof_next(I))
+#define iof_scan_radix(I, c, number, radix) _scan_radix(c, number, radix, iof_next(I))
+#define iof_read_integer(I, c, number) _read_integer(c, number, iof_next(I))
+#define iof_read_radix(I, c, number, radix) _read_radix(c, number, radix, iof_next(I))
+
+#define iof_scan_decimal(I, c, number) _scan_decimal(c, number, iof_next(I))
+#define iof_scan_fraction(I, c, number, exponent10) _scan_fraction(c, number, exponent10, iof_next(I))
+#define iof_scan_exponent10(I, c, exponent10) _scan_exponent10(c, exponent10, iof_next(I))
+
+UTILAPI int iof_get_int32 (iof *I, int32_t *number);
+UTILAPI int iof_get_intlw (iof *I, intlw_t *number);
+UTILAPI int iof_get_int64 (iof *I, int64_t *number);
+
+UTILAPI int iof_get_uint32 (iof *I, uint32_t *number);
+UTILAPI int iof_get_uintlw (iof *I, uintlw_t *number);
+UTILAPI int iof_get_uint64 (iof *I, uint64_t *number);
+
+UTILAPI int iof_get_int32_radix (iof *I, int32_t *number, int radix);
+UTILAPI int iof_get_intlw_radix (iof *I, intlw_t *number, int radix);
+UTILAPI int iof_get_int64_radix (iof *I, int64_t *number, int radix);
+
+UTILAPI int iof_get_uint32_radix (iof *I, uint32_t *number, int radix);
+UTILAPI int iof_get_uintlw_radix (iof *I, uintlw_t *number, int radix);
+UTILAPI int iof_get_uint64_radix (iof *I, uint64_t *number, int radix);
+
+UTILAPI int iof_get_roman (iof *I, unsigned short int *number);
+
+UTILAPI int iof_get_double (iof *I, double *number);
+UTILAPI int iof_get_float (iof *I, float *number);
+
+UTILAPI int iof_conv_double (iof *I, double *number);
+UTILAPI int iof_conv_float (iof *I, float *number);
+
+/* number to iof; return a number of written bytes */
+
+UTILAPI size_t iof_put_int32 (iof *O, int32_t number);
+UTILAPI size_t iof_put_intlw (iof *O, intlw_t number);
+UTILAPI size_t iof_put_int64 (iof *O, int64_t number);
+
+UTILAPI size_t iof_put_uint32 (iof *O, uint32_t number);
+UTILAPI size_t iof_put_uintlw (iof *O, uintlw_t number);
+UTILAPI size_t iof_put_uint64 (iof *O, uint64_t number);
+
+UTILAPI size_t iof_put_int32_radix (iof *O, int32_t number, int radix);
+UTILAPI size_t iof_put_intlw_radix (iof *O, intlw_t number, int radix);
+UTILAPI size_t iof_put_int64_radix (iof *O, int64_t number, int radix);
+
+UTILAPI size_t iof_put_uint32_radix (iof *O, uint32_t number, int radix);
+UTILAPI size_t iof_put_uintlw_radix (iof *O, uintlw_t number, int radix);
+UTILAPI size_t iof_put_uint64_radix (iof *O, uint64_t number, int radix);
+
+UTILAPI size_t iof_put_roman_uc (iof *O, uint16_t number);
+UTILAPI size_t iof_put_roman_lc (iof *O, uint16_t number);
+#define iof_put_roman(I, number) iof_put_roman_uc(I, number)
+
+UTILAPI size_t iof_put_double(iof *O, double number, int digits);
+UTILAPI size_t iof_put_float(iof *O, float number, int digits);
+
+/* common stuff for binary integers */
+
+UTILAPI int iof_get_be_uint2 (iof *I, uint32_t *pnumber);
+UTILAPI int iof_get_be_uint3 (iof *I, uint32_t *pnumber);
+UTILAPI int iof_get_be_uint4 (iof *I, uint32_t *pnumber);
+
+UTILAPI int iof_get_le_uint2 (iof *I, uint32_t *pnumber);
+UTILAPI int iof_get_le_uint3 (iof *I, uint32_t *pnumber);
+UTILAPI int iof_get_le_uint4 (iof *I, uint32_t *pnumber);
+
+// iof_set() and iof_put() suite casts arguments to uint8_t, so we don't need &0xff mask
+
+#define iof_set_be_uint1(O, u) iof_set(O, u)
+#define iof_set_be_uint2(O, u) iof_set2(O, (u)>>8, u)
+#define iof_set_be_uint3(O, u) iof_set3(O, (u)>>16, (u)>>8, u)
+#define iof_set_be_uint4(O, u) iof_set4(O, (u)>>24, (u)>>16, (u)>>8, u)
+
+#define iof_set_le_uint1(O, u) iof_set(O, u)
+#define iof_set_le_uint2(O, u) iof_set2(O, u, (u)>>8)
+#define iof_set_le_uint3(O, u) iof_set3(O, u, (u)>>8, (u)>>16)
+#define iof_set_le_uint4(O, u) iof_set4(O, u, (u)>>8, (u)>>16, (u)>>24)
+
+#define iof_put_be_uint1(O, u) iof_put(O, u)
+#define iof_put_be_uint2(O, u) iof_put2(O, (u)>>8, u)
+#define iof_put_be_uint3(O, u) iof_put3(O, (u)>>16, (u)>>8, u)
+#define iof_put_be_uint4(O, u) iof_put4(O, (u)>>24, (u)>>16, (u)>>8, u)
+
+#define iof_put_le_uint1(O, u) iof_put(O, u)
+#define iof_put_le_uint2(O, u) iof_put2(O, u, (u)>>8)
+#define iof_put_le_uint3(O, u) iof_put3(O, u, (u)>>8, (u)>>16)
+#define iof_put_le_uint4(O, u) iof_put4(O, u, (u)>>8, (u)>>16, (u)>>24)
+
+/* buffer results */
+
+#define iof_reader_result(I, size) ((size = iof_left(I)), (I)->pos)
+#define iof_writer_result(I, size) ((size = iof_size(I)), (I)->buf)
+#define iof_result(I, size) (((I)->flags & IOF_READER) ? iof_reader_result(I, size) : iof_writer_result(I, size))
+
+uint8_t * iof_file_input_data (iof_file *iofile, size_t *psize, int *isnew);
+//uint8_t * iof_file_reader_data (iof_file *iofile, size_t *size);
+//uint8_t * iof_file_writer_data (iof_file *iofile, size_t *size);
+
+uint8_t * iof_reader_data (iof *I, size_t *psize);
+uint8_t * iof_writer_data (iof *O, size_t *psize);
+size_t iof_reader_to_file_handle (iof *I, FILE *file);
+size_t iof_reader_to_file (iof *I, const char *filename);
+
+#define iof_loaded(I) ((I)->end = (I)->pos, (I)->pos = (I)->buf, iof_left(I))
+
+#define iof_data_to_file_handle(data, size, file) fwrite(data, sizeof(uint8_t), size, file)
+UTILAPI size_t iof_data_to_file (const void *data, size_t size, const char *filename);
+
+UTILAPI size_t iof_result_to_file_handle (iof *F, FILE *file);
+UTILAPI size_t iof_result_to_file (iof *F, const char *filename);
+UTILAPI void iof_debug (iof *I, const char *filename);
+
+/* common filters allocator */
+
+void iof_filters_init (void);
+void iof_filters_free (void);
+
+void * iof_filter_new (size_t size);
+void iof_heap_back (void *data);
+#define iof_filter_free(F) iof_heap_back(F)
+#define iof_filter_buffer_free(data) iof_heap_back(data)
+
+// &((void *)pstate
+
+iof * iof_filter_reader_new (iof_handler handler, size_t statesize, void **pstate);
+#define iof_filter_reader(handler, statesize, pstate) iof_filter_reader_new(handler, statesize, (void **)(pstate))
+iof * iof_filter_reader_with_buffer_new (iof_handler handler, size_t statesize, void **pstate, void *buffer, size_t buffersize);
+#define iof_filter_reader_with_buffer(handler, statesize, pstate, buffer, buffersize) iof_filter_reader_with_buffer_new(handler, statesize, (void **)(pstate), buffer, buffersize)
+iof * iof_filter_writer_new (iof_handler handler, size_t statesize, void **pstate);
+#define iof_filter_writer(handler, statesize, pstate) iof_filter_writer_new(handler, statesize, (void **)(pstate))
+iof * iof_filter_writer_with_buffer_new (iof_handler handler, size_t statesize, void **pstate, void *buffer, size_t buffersize);
+#define iof_filter_writer_with_buffer(handler, statesize, pstate, buffer, buffersize) iof_filter_writer_with_buffer_new(handler, statesize, (void **)(pstate), buffer, buffersize)
+
+#define iof_filter_state(statetype, F) (statetype)((F) + 1)
+
+void iof_free (iof *F);
+void iof_discard (iof *F);
+
+size_t iof_resize_buffer_to (iof *O, size_t space);
+#define iof_resize_buffer(O) iof_resize_buffer_to(O, (O)->space << 1)
+
+size_t iof_decoder_retval (iof *I, const char *type, iof_status status);
+size_t iof_encoder_retval (iof *O, const char *type, iof_status status);
+
+/* filters */
+
+iof * iof_filter_file_handle_reader (FILE *file);
+iof * iof_filter_file_handle_writer (FILE *file);
+
+iof * iof_filter_iofile_reader (iof_file *iofile, size_t offset);
+iof * iof_filter_iofile_writer (iof_file *iofile, size_t offset);
+
+iof * iof_filter_file_reader (const char *filename);
+iof * iof_filter_file_writer (const char *filename);
+
+iof * iof_filter_string_reader (const void *s, size_t length);
+iof * iof_filter_string_writer (const void *s, size_t length);
+
+iof * iof_filter_buffer_writer (size_t size);
+
+iof * iof_filter_stream_reader (FILE *file, size_t offset, size_t length);
+iof * iof_filter_stream_coreader (iof_file *iofile, size_t offset, size_t length);
+
+iof * iof_filter_stream_writer (FILE *file);
+iof * iof_filter_stream_cowriter (iof_file *iofile, size_t offset);
+
+FILE * iof_filter_file_reader_source (iof *I, size_t *poffset, size_t *plength);
+iof_file * iof_filter_file_coreader_source (iof *I, size_t *poffset, size_t *plength);
+iof * iof_filter_reader_replacement (iof *P, iof_handler handler, size_t statesize, void **pstate);
+#define iof_filter_reader_replace(P, handler, statesize, pstate) iof_filter_reader_replacement(P, handler, statesize, (void **)(pstate))
+
+#endif
\ No newline at end of file
diff --git a/texk/web2c/luatexdir/luapplib/util/utillog.c b/texk/web2c/luatexdir/luapplib/util/utillog.c
new file mode 100644
index 000000000..1b38f7467
--- /dev/null
+++ b/texk/web2c/luatexdir/luapplib/util/utillog.c
@@ -0,0 +1,60 @@
+
+#include <stdio.h>
+#include <string.h> // strlen
+#include <stdarg.h>
+#include "utillog.h"
+
+#define LOGGER_BUFFER_SIZE 256
+#define LOGGER_PREFIX_SIZE 32
+
+typedef struct {
+  logger_function callback;
+  void *context;
+  size_t pfxlen;
+} logger_struct;
+
+static logger_struct logger = { 0, NULL, 0 };
+
+static char logger_buffer[LOGGER_BUFFER_SIZE+LOGGER_PREFIX_SIZE];
+
+void loggerf (const char *format, ...)
+{
+  va_list args;
+  int length;
+  
+  va_start(args, format);  
+  length = vsnprintf(logger_buffer + logger.pfxlen, LOGGER_BUFFER_SIZE, format, args);
+	if (length > 0)
+	{
+		if (length > LOGGER_BUFFER_SIZE)
+			length = LOGGER_BUFFER_SIZE;
+	}
+	else
+	{
+		loggerf("logger encoding error '%s'", format);
+		length = (int)strlen(logger_buffer);
+	}
+	length += (int)logger.pfxlen;
+	if (logger.callback)
+		logger.callback(logger_buffer, logger.context);
+  else
+		printf("\n%s\n", logger_buffer);
+	va_end(args);
+}
+
+void logger_callback (logger_function callback, void *context)
+{
+	logger.callback = callback;
+	logger.context = context;
+}
+
+int logger_prefix (const char *prefix)
+{
+	size_t pfxlen;
+	pfxlen = strlen(prefix);
+	if (pfxlen > LOGGER_PREFIX_SIZE)
+		return 0;
+	memcpy(logger_buffer, prefix, pfxlen);
+	logger.pfxlen = pfxlen;
+	return 1;
+}
diff --git a/texk/web2c/luatexdir/luapplib/util/utillog.h b/texk/web2c/luatexdir/luapplib/util/utillog.h
new file mode 100644
index 000000000..c30e0ff0f
--- /dev/null
+++ b/texk/web2c/luatexdir/luapplib/util/utillog.h
@@ -0,0 +1,10 @@
+
+#ifndef UTIL_LOG_H
+#define UTIL_LOG_H
+
+typedef void (*logger_function) (const char *message, void *alien);
+void loggerf (const char *format, ...);
+void logger_callback (logger_function callback, void *context);
+int logger_prefix (const char *prefix);
+
+#endif
\ No newline at end of file
diff --git a/texk/web2c/luatexdir/luapplib/util/utillzw.c b/texk/web2c/luatexdir/luapplib/util/utillzw.c
new file mode 100644
index 000000000..4cd221214
--- /dev/null
+++ b/texk/web2c/luatexdir/luapplib/util/utillzw.c
@@ -0,0 +1,701 @@
+/* lzw implementation for postscript/pdf filters
+# Notes on LZW
+
+# Encoder
+
+Initially the table contains 256 entires for single bytes. Encoder consumes
+input bytes trying to find the longest sequence stored so far in the table.
+Once it finds a sequence that is not present in the table, it outputs the table
+index of the longest sequence found (accumulated bytes except the last
+consumed) and pushes the new sequence (accumulated bytes including the last
+one) on the top of the table. The last taken byte is not yet written to the
+output, it becomes the beginning of the new sequence to accumulate. Initially,
+encoder outputs 9-bit codes. While the table grows, the number of bits for each
+code increases up to 12. In example, after adding a table entry of index 511 it
+is high time to switch to 10-bit bytes. /EarlyChange=true parameter in stream
+dictionary (both postscript and pdf) informs to increase the number of bits one
+code earlier then necessary. Looks pretty much like an early days bug that
+became a specification :) I have never found a PDF having /EarlyChange key
+specified anyway.
+
+Once the table becomes full (or when encoder decides it is worthy),
+a clear-table marker (code 256) purges the table and restores codes length to
+9. End-of-data marker (code 257) ends the stream. Conventionally, the beginning
+of the stream starts with clear-table marker.
+
+Postscript allows to provide a /UnitLength which determines the bit length of
+codes. The above description assumes UnitLength=8 (default). Allowed values are
+from 3 to 8. Different UnitLength also affects markers; clear-table is then
+2^UnitLength and end-of-data marker is 2^UnitLenth+1.
+
+Encoder outputs 9-12bit codes that are packed into bytes using high-bits-first
+scheme (default) or low-bits-scheme.
+
+PDF spec p. 73 (PS spec p. 135 gives an mistaken output sequence and so
+mistaken output bytes)
+
+Input character sequence (decimal)
+45 45 45 45 45 65 45 45 45 66
+
+Output 9bit codes (decimal)
+256 45 258 258 65 259 66 257
+
+Output 9bit codes (binary)
+100000000 000101101 100000010 100000010 001000001 100000011 001000010 100000001
+
+Output bytes (LowBitsFirst=false); eight high-order bits of code becomes
+the first byte, remaining low-order bit of code becomes the high-order bit of the
+next byte;
+10000000 00001011 01100000 01010000 00100010 00001100 00001100 10000101 00000001
+-> 80 0B 60 50 22 0C 0C 85 01
+
+Output bytes (binary, LowBitsFirst=true); eight low-order bits of code becomes
+the first byte, remaining high-order bit of code becomes low-order bit of the
+next byte;
+00000000 01011011 00001000 00010100 00011000 01100100 10100000 10000000 10010000
+-> 00 5B 08 14 18 64 A0 80 90
+
+# Decoder
+
+Decoder consumes input bytes transforming them to 9 to 12 bit codes. Initially
+it starts with 9bit codes and the table of 258 fixed codes (same as encoder).
+Basically, it interprets incoming codes as table indices (except 256 and 257
+markers) and it outputs byte sequences stored at given indices. It also
+upbuilds the table and changes the number of bits of codes when necessary. The
+key point on lzw is that both encoder and decoder builds the table
+synchronously.
+
+However, decoder needs some "knowledge" about how encoder works to be able to
+interpret a table index that it doesn't have so far. Look that the output from
+encoder in the example above. The first output code is conventional clear-table
+(256). Then comes a code 45. So far so good, decoder interprets code 45 as
+a (fixed) entry of the table, emitting byte 45. The next code is 258, which is
+should be interpreted as an index in the table. Oops, encoder doesn't have one
+yet. If that occurs, it means that encoder was able to output the new entry
+code just after adding it to a table. It means that
+
+  sequence_before + next_byte == next_byte + sequence_after
+
+This may happen not only for sequences like 45 45 45, but also symmetric series
+such as abcbabcba; abcb + a == a + bcba. Decoder must be aware of that and if
+it gets a code one larger than the top table index, it should create one on-fly
+by appending last entry sequence by the first by of the last entry.
+
+# UnitLength
+
+Postscript specification mentions about UnitLength parameter that can be used
+in LZW decoder (not allowed in encoder), with possible values from 3 to 8. This
+parameter determines the number of bits per code; form UnitLength + 1 to 12. It
+also determines which codes are used for clear-table marker (2^UnitLength) and
+end-of-data marker ((2^UnitLength)+1). Postscript specification says (page 134):
+
+"Initially, the code length is (UnitLength + 1) bits and the table contains only
+entries for the (2^UnitLength + 2) fixed codes. As encoding proceeds, entries are
+appended to the table, associating new codes with longer and longer input character
+sequences. The encoding and decoding filters maintain identical copies of
+this table."
+
+Later on page 136 Postscript specification says:
+
+"Data that has been LZW-encoded with a UnitLength less than 8 consists only of
+codes in the range 0 to 2^UnitLength - 1; consequently, the LZWDecode filter produces
+only codes in that range when read. UnitLength also affects the encoded
+representation, as described above."
+
+UnitLength (Postscript only) and LowBitsFirst are used only by decoder.
+EarlyChange should obviously be respected by both encoder and decoder. When
+table index reaches current bit length boundary (511, 1023, ...) it must react
+by increasing the number of bits of input code. But if the index reaches it
+maximum value (when the table is full), decoder is NOT supposed to clear the
+table. When the table is full, encoder must emit clear-table marker and it
+emits this code using 12 bits and reinitialize code bits after that. It means
+that, when the table is full, decoder should get one more 12-bit code (which
+should be clear-table marker) and actually clear the table and reinitialize
+code bits after that.
+
+# Clear-table vs last entry track (after tries and checks)
+
+It is also not quite clear what should actually happen when encoder gets a full
+table and it is supposed to emit clear-table marker. When it gets full, it
+means that it has just appended another entry to the table. And that happens
+only the input sequence collected so far plus the last byte is not present in
+the table. Encoder is supposed to output the table index of the present
+sequence and set the recent byte as a starting index of the new sequence to be
+collected. Even if it is time to clear the table, encoder is still supposed to
+keep the track of the last table entry. Decoder, however, must drop the track of the
+last code on clear-table.
+
+# Decoder table vs encoder table
+
+While decoding we need query lzw table by (subsequent) numeric codes and output
+character sequences stored in the table. While encoding we need to query the
+table on every input byte and fetch indices pointing to character sequences.
+Note that we never need to query the entire table for the longest sequence
+found so far. The encoder table do not need to access the longest character
+sequence at one piece. It is enough to keep the track of the current table
+index and the very next byte. We organize an encoder table into a search tree,
+where every node contains its table index (value) and last byte (key). Except
+initial tree content, every node is created on the base of the previous node
+and it conceptually point the sequence represented by that nodo consists of the
+previous node sequence plus the next byte.
+
+Every new node is a descendant of the node it has been derived from. Every node
+has a map (a search subtree) indexed by suffix byte value, pointing to
+descendants nodes. Every node also has binary tentackles (left/right fields)
+necessary to search the map (except initials, every node lives in a map of some
+ancestor node). The key point is that on every input byte we don't search the
+entire tree, but only the map of the current node children. The map tree is
+a simple binary tree with no balancing mechanism (not worthy to optimize an
+ephemeric structure that may be upbuilt more often then queried).
+
+In our implementation, decoder table requires  4069 entries (topmost index 4095).
+Encoder table, however, needs 4097 entries to handle the case when EarlyIndex
+parameter is 0 (I have never a chance to test that in practise). The node of index
+4096 might be added to a search tree, but its code is never emitted; the lookup
+is purged just after adding that node.
+
+todo:
+- support for LowBitsFirst encoding
+*/
+
+#include "utilmem.h"
+#include "utillzw.h"
+
+/* filter state struct */
+
+typedef struct lzw_entry {
+  union {
+    const char *rdata; // to be able to init with string literal
+    char *data;
+  };
+  int size;
+} lzw_entry;
+
+#define lzw_index short
+
+typedef struct lzw_node lzw_node;
+
+struct lzw_node {
+  lzw_index index;
+  unsigned char suffix;
+  lzw_node *left;
+  lzw_node *right;
+  lzw_node *map;
+};
+
+struct lzw_state {
+  union {
+    lzw_node *lookup;                 /* encoder table */
+    lzw_entry *table;                 /* decoder table */
+  };
+  lzw_index index;                    /* table index */
+  union {
+    lzw_node *lastnode;               /* previous encoder table node */
+    struct {
+      lzw_entry *lastentry;           /* previous decoder table entry */
+      int tailbytes;                  /* num of bytes of lastentry not yet written out */
+    };
+  };
+  int basebits;                       /* /UnitLength parameter (8) */
+  int codebits;                       /* current code bits */
+  int lastbyte;                       /* previosly read byte */
+  int tailbits;                       /* lastbyte bits not yet consumed */
+  int flush;                          /* encoder */
+  int flags;                          /* options */
+};
+
+/* macros */
+
+#define LZW_MIN_BITS 3
+#define LZW_MAX_BITS 12
+#define LZW_TABLE_SIZE (1 << LZW_MAX_BITS)
+#define LZW_LOOKUP_SIZE (LZW_TABLE_SIZE + 1)
+
+#define lzw_bit_range(bits) (bits >= LZW_MIN_BITS && bits <= LZW_BASE_BITS)
+#define lzw_base_bits(flags) (flags & ((1 << 4) - 1)) // 4 low bits of flags is basebits (UnitLength)
+
+#define lzw_initial_codes(state) (1 << state->basebits)
+#define lzw_clear_code(state)    lzw_initial_codes(state)
+#define lzw_eod_code(state)      (lzw_initial_codes(state) + 1)
+#define lzw_initial_index(state) (lzw_initial_codes(state) + 2)
+
+#define lzw_max_index(state) ((1 << state->codebits) - ((state->flags & LZW_EARLY_INDEX) ? 1 : 0))
+#define lzw_check_bits(state) ((void)(state->index == lzw_max_index(state) && state->codebits < LZW_MAX_BITS && ++state->codebits))
+
+#define lzw_malloc util_malloc
+#define lzw_free util_free
+
+/* decoder */
+
+static struct lzw_entry lzw_initial_table[] = {
+  {{"\x00"}, 1}, {{"\x01"}, 1}, {{"\x02"}, 1}, {{"\x03"}, 1}, {{"\x04"}, 1}, {{"\x05"}, 1}, {{"\x06"}, 1}, {{"\x07"}, 1}, {{"\x08"}, 1}, {{"\x09"}, 1}, {{"\x0A"}, 1}, {{"\x0B"}, 1}, {{"\x0C"}, 1}, {{"\x0D"}, 1}, {{"\x0E"}, 1}, {{"\x0F"}, 1},
+  {{"\x10"}, 1}, {{"\x11"}, 1}, {{"\x12"}, 1}, {{"\x13"}, 1}, {{"\x14"}, 1}, {{"\x15"}, 1}, {{"\x16"}, 1}, {{"\x17"}, 1}, {{"\x18"}, 1}, {{"\x19"}, 1}, {{"\x1A"}, 1}, {{"\x1B"}, 1}, {{"\x1C"}, 1}, {{"\x1D"}, 1}, {{"\x1E"}, 1}, {{"\x1F"}, 1},
+  {{"\x20"}, 1}, {{"\x21"}, 1}, {{"\x22"}, 1}, {{"\x23"}, 1}, {{"\x24"}, 1}, {{"\x25"}, 1}, {{"\x26"}, 1}, {{"\x27"}, 1}, {{"\x28"}, 1}, {{"\x29"}, 1}, {{"\x2A"}, 1}, {{"\x2B"}, 1}, {{"\x2C"}, 1}, {{"\x2D"}, 1}, {{"\x2E"}, 1}, {{"\x2F"}, 1},
+  {{"\x30"}, 1}, {{"\x31"}, 1}, {{"\x32"}, 1}, {{"\x33"}, 1}, {{"\x34"}, 1}, {{"\x35"}, 1}, {{"\x36"}, 1}, {{"\x37"}, 1}, {{"\x38"}, 1}, {{"\x39"}, 1}, {{"\x3A"}, 1}, {{"\x3B"}, 1}, {{"\x3C"}, 1}, {{"\x3D"}, 1}, {{"\x3E"}, 1}, {{"\x3F"}, 1},
+  {{"\x40"}, 1}, {{"\x41"}, 1}, {{"\x42"}, 1}, {{"\x43"}, 1}, {{"\x44"}, 1}, {{"\x45"}, 1}, {{"\x46"}, 1}, {{"\x47"}, 1}, {{"\x48"}, 1}, {{"\x49"}, 1}, {{"\x4A"}, 1}, {{"\x4B"}, 1}, {{"\x4C"}, 1}, {{"\x4D"}, 1}, {{"\x4E"}, 1}, {{"\x4F"}, 1},
+  {{"\x50"}, 1}, {{"\x51"}, 1}, {{"\x52"}, 1}, {{"\x53"}, 1}, {{"\x54"}, 1}, {{"\x55"}, 1}, {{"\x56"}, 1}, {{"\x57"}, 1}, {{"\x58"}, 1}, {{"\x59"}, 1}, {{"\x5A"}, 1}, {{"\x5B"}, 1}, {{"\x5C"}, 1}, {{"\x5D"}, 1}, {{"\x5E"}, 1}, {{"\x5F"}, 1},
+  {{"\x60"}, 1}, {{"\x61"}, 1}, {{"\x62"}, 1}, {{"\x63"}, 1}, {{"\x64"}, 1}, {{"\x65"}, 1}, {{"\x66"}, 1}, {{"\x67"}, 1}, {{"\x68"}, 1}, {{"\x69"}, 1}, {{"\x6A"}, 1}, {{"\x6B"}, 1}, {{"\x6C"}, 1}, {{"\x6D"}, 1}, {{"\x6E"}, 1}, {{"\x6F"}, 1},
+  {{"\x70"}, 1}, {{"\x71"}, 1}, {{"\x72"}, 1}, {{"\x73"}, 1}, {{"\x74"}, 1}, {{"\x75"}, 1}, {{"\x76"}, 1}, {{"\x77"}, 1}, {{"\x78"}, 1}, {{"\x79"}, 1}, {{"\x7A"}, 1}, {{"\x7B"}, 1}, {{"\x7C"}, 1}, {{"\x7D"}, 1}, {{"\x7E"}, 1}, {{"\x7F"}, 1},
+  {{"\x80"}, 1}, {{"\x81"}, 1}, {{"\x82"}, 1}, {{"\x83"}, 1}, {{"\x84"}, 1}, {{"\x85"}, 1}, {{"\x86"}, 1}, {{"\x87"}, 1}, {{"\x88"}, 1}, {{"\x89"}, 1}, {{"\x8A"}, 1}, {{"\x8B"}, 1}, {{"\x8C"}, 1}, {{"\x8D"}, 1}, {{"\x8E"}, 1}, {{"\x8F"}, 1},
+  {{"\x90"}, 1}, {{"\x91"}, 1}, {{"\x92"}, 1}, {{"\x93"}, 1}, {{"\x94"}, 1}, {{"\x95"}, 1}, {{"\x96"}, 1}, {{"\x97"}, 1}, {{"\x98"}, 1}, {{"\x99"}, 1}, {{"\x9A"}, 1}, {{"\x9B"}, 1}, {{"\x9C"}, 1}, {{"\x9D"}, 1}, {{"\x9E"}, 1}, {{"\x9F"}, 1},
+  {{"\xA0"}, 1}, {{"\xA1"}, 1}, {{"\xA2"}, 1}, {{"\xA3"}, 1}, {{"\xA4"}, 1}, {{"\xA5"}, 1}, {{"\xA6"}, 1}, {{"\xA7"}, 1}, {{"\xA8"}, 1}, {{"\xA9"}, 1}, {{"\xAA"}, 1}, {{"\xAB"}, 1}, {{"\xAC"}, 1}, {{"\xAD"}, 1}, {{"\xAE"}, 1}, {{"\xAF"}, 1},
+  {{"\xB0"}, 1}, {{"\xB1"}, 1}, {{"\xB2"}, 1}, {{"\xB3"}, 1}, {{"\xB4"}, 1}, {{"\xB5"}, 1}, {{"\xB6"}, 1}, {{"\xB7"}, 1}, {{"\xB8"}, 1}, {{"\xB9"}, 1}, {{"\xBA"}, 1}, {{"\xBB"}, 1}, {{"\xBC"}, 1}, {{"\xBD"}, 1}, {{"\xBE"}, 1}, {{"\xBF"}, 1},
+  {{"\xC0"}, 1}, {{"\xC1"}, 1}, {{"\xC2"}, 1}, {{"\xC3"}, 1}, {{"\xC4"}, 1}, {{"\xC5"}, 1}, {{"\xC6"}, 1}, {{"\xC7"}, 1}, {{"\xC8"}, 1}, {{"\xC9"}, 1}, {{"\xCA"}, 1}, {{"\xCB"}, 1}, {{"\xCC"}, 1}, {{"\xCD"}, 1}, {{"\xCE"}, 1}, {{"\xCF"}, 1},
+  {{"\xD0"}, 1}, {{"\xD1"}, 1}, {{"\xD2"}, 1}, {{"\xD3"}, 1}, {{"\xD4"}, 1}, {{"\xD5"}, 1}, {{"\xD6"}, 1}, {{"\xD7"}, 1}, {{"\xD8"}, 1}, {{"\xD9"}, 1}, {{"\xDA"}, 1}, {{"\xDB"}, 1}, {{"\xDC"}, 1}, {{"\xDD"}, 1}, {{"\xDE"}, 1}, {{"\xDF"}, 1},
+  {{"\xE0"}, 1}, {{"\xE1"}, 1}, {{"\xE2"}, 1}, {{"\xE3"}, 1}, {{"\xE4"}, 1}, {{"\xE5"}, 1}, {{"\xE6"}, 1}, {{"\xE7"}, 1}, {{"\xE8"}, 1}, {{"\xE9"}, 1}, {{"\xEA"}, 1}, {{"\xEB"}, 1}, {{"\xEC"}, 1}, {{"\xED"}, 1}, {{"\xEE"}, 1}, {{"\xEF"}, 1},
+  {{"\xF0"}, 1}, {{"\xF1"}, 1}, {{"\xF2"}, 1}, {{"\xF3"}, 1}, {{"\xF4"}, 1}, {{"\xF5"}, 1}, {{"\xF6"}, 1}, {{"\xF7"}, 1}, {{"\xF8"}, 1}, {{"\xF9"}, 1}, {{"\xFA"}, 1}, {{"\xFB"}, 1}, {{"\xFC"}, 1}, {{"\xFD"}, 1}, {{"\xFE"}, 1}, {{"\xFF"}, 1}
+};
+
+#define lzw_entry_at(state, index) (&state->table[index])
+
+static lzw_state * lzw_decoder_init_table (lzw_state *state, lzw_entry *table, int flags)
+{
+  state->basebits = lzw_base_bits(flags); // first four bits or flags
+  if (!lzw_bit_range(state->basebits))
+    return NULL;
+  state->flags = flags;
+  if ((state->table = table) == NULL)
+  {
+    state->table = (lzw_entry *)lzw_malloc(LZW_TABLE_SIZE * sizeof(lzw_entry));
+    state->flags |= LZW_TABLE_ALLOC;
+  }
+  memcpy(state->table, lzw_initial_table, (size_t)lzw_initial_codes(state)*sizeof(lzw_entry));
+  // memset(&state->table[lzw_initial_codes(state)], 0, 2*sizeof(lzw_entry)); // eod and clear entries never accessed
+  state->codebits = state->basebits + 1;
+  state->index = lzw_initial_index(state);
+  state->lastentry = NULL;
+  state->tailbytes = 0;
+  state->lastbyte = 0;
+  state->tailbits = 0;
+  return state;
+}
+
+lzw_state * lzw_decoder_init (lzw_state *state, int flags)
+{
+  return lzw_decoder_init_table(state, NULL, flags);
+}
+
+static void lzw_decoder_clear (lzw_state *state)
+{
+  lzw_entry *entry;
+  lzw_index initindex = lzw_initial_index(state);
+  while (state->index > initindex)
+  {
+    entry = lzw_entry_at(state, --state->index);
+    lzw_free(entry->data);
+    // entry->data = NULL;
+    // entry->size = 0;
+  }
+  state->lastentry = NULL;
+  state->tailbytes = 0;
+  state->codebits = state->basebits + 1;
+}
+
+void lzw_decoder_close (lzw_state *state)
+{
+  lzw_decoder_clear(state);
+  if (state->flags & LZW_TABLE_ALLOC)
+    lzw_free(state->table);
+}
+
+static int lzw_next_entry (lzw_state *state, lzw_entry *nextentry)
+{
+  lzw_entry *lastentry, *newentry;
+  if ((lastentry = state->lastentry) == NULL)
+    return 1; /* its ok */
+  if (state->index == LZW_TABLE_SIZE)
+    return 0; /* invalid input; eod marker expected earlier */
+  /* put the new entry on the top of the table */
+  newentry = lzw_entry_at(state, state->index++);
+  /* its size is the last entrtyy size plus 1 */
+  newentry->size = lastentry->size + 1;
+  /* its content is the content of the last entry, */
+  newentry->data = (char *)lzw_malloc((size_t)newentry->size);
+  memcpy(newentry->data, lastentry->data, lastentry->size);
+  /* plus the first byte of the new entry (usually fixed code entry) */
+  newentry->data[newentry->size - 1] = nextentry->data[0];
+  return 1;
+}
+
+#define lzw_write_bytes(O, state) ((state->tailbytes -= (int)iof_write(O, state->lastentry->data, (size_t)state->tailbytes)) == 0)
+
+iof_status lzw_decode_state (iof *I, iof *O, lzw_state *state)
+{
+  const lzw_index clear = lzw_clear_code(state), eod = lzw_eod_code(state);
+  lzw_index code;
+  lzw_entry *entry;
+  if (state->lastentry != NULL)
+  { /* write out the tail from the last call */
+    if (state->tailbytes > 0 && !lzw_write_bytes(O, state))
+      return IOFFULL;
+    /* do what we normally do at the end of the loop body below */
+    lzw_check_bits(state);
+  }
+  // if (state->flags & LZW_LOW_BITS_FIRST)
+  //   return IOFERR;
+  while (1)
+  {
+    /* get input code of length state->codebits */
+    code = (state->lastbyte & ((1 << state->tailbits) - 1)) << (state->codebits - state->tailbits);
+    for (state->tailbits -= state->codebits; state->tailbits < 0; )
+    {
+      get_code:
+      if ((state->lastbyte = iof_get(I)) < 0)
+        return state->flush ? IOFEOF : state->lastbyte;
+      state->tailbits += 8;
+      if (state->tailbits < 0)
+      {
+        code |= (state->lastbyte << (-state->tailbits));
+        goto get_code;
+      }
+      else
+      {
+        code |= (state->lastbyte >> state->tailbits);
+        break;
+      }
+    }
+    /* interpret the code */
+    if (code < state->index)
+    { /* single byte code or special marker */
+      if (code == clear)
+      {
+        lzw_decoder_clear(state);
+        continue;
+      }
+      if (code == eod)
+        return IOFEOF;
+      entry = lzw_entry_at(state, code);
+      if (!lzw_next_entry(state, entry))
+        return IOFERR;
+    }
+    else if (code == state->index)
+    { /* apparently encoder has emitted the code of the key just created (see notes) */
+      if (!lzw_next_entry(state, state->lastentry))
+        return IOFERR;
+      entry = lzw_entry_at(state, state->index - 1);
+    }
+    else
+    { /* invalid input code */
+      return IOFERR;
+    }
+    /* record the entry found */
+    state->lastentry = entry;
+    /* emit the sequence pointed by that entry */
+    state->tailbytes = entry->size;
+    if (!lzw_write_bytes(O, state))
+      return IOFFULL;
+    /* check and update code bits */
+    lzw_check_bits(state);
+  }
+  return state->lastbyte; // never reached
+}
+
+/* encoder */
+
+#define lzw_node_at(state, index) (&state->lookup[index])
+
+#define lzw_node_init(node, i, c) (node->index = i, node->suffix = c, node->left = NULL, node->right = NULL, node->map = NULL)
+
+static lzw_state * lzw_encoder_init_table (lzw_state *state, lzw_node *lookup, int flags)
+{
+  lzw_index index;
+  lzw_node *node;
+  state->basebits = lzw_base_bits(flags); // first four bits of flags is base bits of code (default 8)
+  if (!lzw_bit_range(state->basebits))
+    return NULL;
+  state->flags = flags;
+  if ((state->lookup = lookup) == NULL)
+  {
+    state->lookup = lzw_malloc(LZW_LOOKUP_SIZE*sizeof(lzw_node));
+    state->flags |= LZW_TABLE_ALLOC;
+  }
+  state->index = lzw_initial_index(state);
+  for (index = 0; index < lzw_initial_codes(state); ++index)
+  {
+    node = lzw_node_at(state, index);
+    lzw_node_init(node, index, (unsigned char)index);
+  }
+  state->codebits = state->basebits + 1;
+  state->lastnode = NULL;
+  state->lastbyte = 0;
+  state->tailbits = 0;
+  return state;
+}
+
+lzw_state * lzw_encoder_init (lzw_state *state, int flags)
+{
+  return lzw_encoder_init_table(state, NULL, flags);
+}
+
+void lzw_encoder_close (lzw_state *state)
+{
+  if (state->flags & LZW_TABLE_ALLOC)
+    lzw_free(state->lookup);
+}
+
+static void lzw_encoder_clear (lzw_state *state)
+{
+  lzw_node *node;
+  lzw_index index;
+  /* clear fixed nodes */
+  for (index = 0; index < lzw_initial_codes(state); ++index)
+  {
+    node = lzw_node_at(state, index);
+    lzw_node_init(node, index, (unsigned char)index);
+  }
+  /* reset table index */
+  state->index = lzw_initial_index(state);
+  /* reset code bits */
+  state->codebits = state->basebits + 1;
+}
+
+static void lzw_put_code (iof *O, lzw_state *state, lzw_index code, int todobits)
+{
+  int leftbits, rightbits;
+  do
+  {
+    leftbits = 8 - state->tailbits;
+    rightbits = todobits - leftbits;
+    if (rightbits >= 0)
+    {
+      state->lastbyte |= (code >> rightbits);
+      iof_put(O, state->lastbyte);
+      code = code & ((1 << rightbits) - 1);
+      todobits -= leftbits;
+      state->lastbyte = 0;
+      state->tailbits = 0;
+    }
+    else
+    {
+      state->lastbyte |= (code << (-rightbits));
+      state->tailbits += todobits;
+      return;
+    }
+  } while (1);
+}
+
+static iof_status lzw_encode_last (iof *O, lzw_state *state)
+{
+  if (state->flush)
+  {
+    /* put the last code if any */
+    if (state->lastnode != NULL)
+      lzw_put_code(O, state, state->lastnode->index, state->codebits);
+    /* put eod marker, */
+    lzw_put_code(O, state, lzw_eod_code(state), state->codebits);
+    /* with tail bits set to 0 */
+    if (state->tailbits > 0)
+      lzw_put_code(O, state, 0, 8 - state->tailbits);
+    return IOFEOF;
+  }
+  return IOFEMPTY;
+}
+
+static lzw_node * lzw_node_push (lzw_state *state, unsigned char suffix)
+{
+  lzw_node *node;
+  node = lzw_node_at(state, state->index);
+  lzw_node_init(node, state->index, suffix);
+  ++state->index;
+  return node;
+}
+
+static int lzw_next_node (lzw_state *state, unsigned char suffix)
+{
+  lzw_node *node;
+  if ((node = state->lastnode->map) == NULL)
+  {
+    state->lastnode->map = lzw_node_push(state, suffix);
+    return 0;
+  }
+  while (1)
+  {
+    if (suffix < node->suffix)
+    {
+      if (node->left == NULL)
+      {
+        node->left = lzw_node_push(state, suffix);
+        return 0;
+      }
+      node = node->left;
+    }
+    else if (suffix > node->suffix)
+    {
+      if (node->right == NULL)
+      {
+        node->right = lzw_node_push(state, suffix);
+        return 0;
+      }
+      node = node->right;
+    }
+    else
+    {
+      state->lastnode = node;
+      return 1;
+    }
+  }
+  return 0; // never reached
+}
+
+iof_status lzw_encode_state (iof *I, iof *O, lzw_state *state)
+{
+  int byte;
+  if (state->lastnode == NULL)
+  { /* first call only; following convention, put clear-table marker */
+    if (!iof_ensure(O, 2))
+      return IOFFULL;
+    lzw_put_code(O, state, lzw_clear_code(state), state->codebits);
+    /* get the first input byte and initialize the current table entry */
+    if ((byte = iof_get(I)) < 0)
+      return lzw_encode_last(O, state);
+    state->lastnode = lzw_node_at(state, byte);
+  }
+  while (iof_ensure(O, 2))
+  { /* we need to write at most 2 bytes on each iteration */
+    if ((byte = iof_get(I)) < 0)
+      return lzw_encode_last(O, state);
+    if (lzw_next_node(state, (unsigned char)byte) == 0)
+    { /* means that the key hasn't been found and the new entry has just been created */
+      /* output the code pointing the longest sequence so far */
+      lzw_put_code(O, state, state->lastnode->index, state->codebits);
+      /* update code bits */
+      if (state->index == lzw_max_index(state) + 1)
+      {
+        if (state->codebits < LZW_MAX_BITS)
+          ++state->codebits;
+        else
+        {
+          /* put clear-table marker */
+          lzw_put_code(O, state, lzw_clear_code(state), state->codebits);
+          /* reset the table */
+          lzw_encoder_clear(state);
+        }
+      }
+      /* in any case, recent byte becomes the current table code */
+      state->lastnode = lzw_node_at(state, byte);
+    }
+    /* otherwise no new entry is appended and state->lastnode points the longer sequence just found */
+  }
+  return IOFFULL;
+}
+
+/* single call codecs */
+
+iof_status lzw_decode (iof *I, iof *O, int flags)
+{
+  lzw_state state = { { 0 } }; // shut overactive warnings
+  lzw_entry table[LZW_TABLE_SIZE];
+  int ret;
+  lzw_decoder_init_table(&state, table, flags);
+  state.flush = 1;
+  ret = lzw_decode_state(I, O, &state);
+  // iof_flush(O); // ?
+  lzw_decoder_close(&state);
+  return ret;
+}
+
+iof_status lzw_encode (iof *I, iof *O, int flags)
+{
+  lzw_state state;
+  lzw_node lookup[LZW_LOOKUP_SIZE];
+  int ret;
+  lzw_encoder_init_table(&state, lookup, flags);
+  state.flush = 1;
+  ret = lzw_encode_state(I, O, &state);
+  // iof_flush(O); // ?
+  lzw_encoder_close(&state);
+  return ret;
+}
+
+/* filters */
+
+// lzw decoder function
+
+static size_t lzw_decoder (iof *F, iof_mode mode)
+{
+  lzw_state *state;
+  iof_status status;
+  size_t tail;
+
+  state = iof_filter_state(lzw_state *, F);
+  switch(mode)
+  {
+    case IOFLOAD:
+    case IOFREAD:
+      if (F->flags & IOF_STOPPED)
+        return 0;
+      tail = iof_tail(F);
+      F->pos = F->buf + tail;
+      F->end = F->buf + F->space;
+      do {
+        status = lzw_decode_state(F->next, F, state);
+      } while (mode == IOFLOAD && status == IOFFULL && iof_resize_buffer(F));
+      return iof_decoder_retval(F, "lzw", status);
+    case IOFCLOSE:
+      lzw_decoder_close(state);
+      iof_free(F);
+      return 0;
+    default:
+      break;
+  }
+  return 0;
+}
+
+// lzw encoder function
+
+static size_t lzw_encoder (iof *F, iof_mode mode)
+{
+  lzw_state *state;
+  iof_status status;
+
+  state = iof_filter_state(lzw_state *, F);
+  switch (mode)
+  {
+    case IOFFLUSH:
+      state->flush = 1;
+      // fall through
+    case IOFWRITE:
+      F->end = F->pos;
+      F->pos = F->buf;
+      status = lzw_encode_state(F, F->next, state);
+      return iof_encoder_retval(F, "lzw", status);
+    case IOFCLOSE:
+      if (!state->flush)
+        lzw_encoder(F, IOFFLUSH);
+      lzw_encoder_close(state);
+      iof_free(F);
+      return 0;
+    default:
+      break;
+  }
+  return 0;
+}
+
+iof * iof_filter_lzw_decoder (iof *N, int flags)
+{
+  iof *I;
+  lzw_state *state;
+  I = iof_filter_reader(lzw_decoder, sizeof(lzw_state), &state);
+  iof_setup_next(I, N);
+  if (lzw_decoder_init(state, flags) == NULL)
+  {
+    iof_discard(I);
+    return NULL;
+  }
+  state->flush = 1;
+  return I;
+}
+
+iof * iof_filter_lzw_encoder (iof *N, int flags)
+{
+  iof *O;
+  lzw_state *state;
+  O = iof_filter_writer(lzw_encoder, sizeof(lzw_state), &state);
+  iof_setup_next(O, N);
+  if (lzw_encoder_init(state, flags) == NULL)
+  {
+    iof_discard(O);
+    return NULL;
+  }
+  return O;
+}
diff --git a/texk/web2c/luatexdir/luapplib/util/utillzw.h b/texk/web2c/luatexdir/luapplib/util/utillzw.h
new file mode 100644
index 000000000..9e3a085d4
--- /dev/null
+++ b/texk/web2c/luatexdir/luapplib/util/utillzw.h
@@ -0,0 +1,30 @@
+#ifndef UTIL_LZW_H
+#define UTIL_LZW_H
+
+#include "utiliof.h"
+
+typedef struct lzw_state lzw_state;
+
+#define LZW_BASE_BITS 8
+#define LZW_TABLE_ALLOC (1<<4)
+#define LZW_EARLY_INDEX (1<<5)
+//#define LZW_LOW_BITS_FIRST (1<<6)
+#define LZW_DECODER_DEFAULTS (LZW_BASE_BITS|LZW_EARLY_INDEX|0)
+#define LZW_ENCODER_DEFAULTS (LZW_BASE_BITS|LZW_EARLY_INDEX|0)
+
+lzw_state * lzw_decoder_init (lzw_state *state, int flags);
+lzw_state * lzw_encoder_init (lzw_state *state, int flags);
+
+void lzw_decoder_close (lzw_state *state);
+void lzw_encoder_close (lzw_state *state);
+
+iof_status lzw_encode_state (iof *I, iof *O, lzw_state *state);
+iof_status lzw_decode_state (iof *I, iof *O, lzw_state *state);
+
+iof_status lzw_encode (iof *I, iof *O, int flags);
+iof_status lzw_decode (iof *I, iof *O, int flags);
+
+iof * iof_filter_lzw_decoder (iof *N, int flags);
+iof * iof_filter_lzw_encoder (iof *N, int flags);
+
+#endif
\ No newline at end of file
diff --git a/texk/web2c/luatexdir/luapplib/util/utilmd5.c b/texk/web2c/luatexdir/luapplib/util/utilmd5.c
new file mode 100644
index 000000000..a2926b0aa
--- /dev/null
+++ b/texk/web2c/luatexdir/luapplib/util/utilmd5.c
@@ -0,0 +1,413 @@
+/* md5 implementation by Peter Deutsch (ghost@aladdin.com) with some convenience shorthands  */
+
+/* begin of md5.c */
+
+/*
+  Copyright (C) 1999, 2000, 2002 Aladdin Enterprises.  All rights reserved.
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+
+  L. Peter Deutsch
+  ghost@aladdin.com
+
+ */
+/* $Id: md5.c,v 1.6 2002/04/13 19:20:28 lpd Exp $ */
+/*
+  Independent implementation of MD5 (RFC 1321).
+
+  This code implements the MD5 Algorithm defined in RFC 1321, whose
+  text is available at
+	http://www.ietf.org/rfc/rfc1321.txt
+  The code is derived from the text of the RFC, including the test suite
+  (section A.5) but excluding the rest of Appendix A.  It does not include
+  any code or documentation that is identified in the RFC as being
+  copyrighted.
+
+  The original and principal author of md5.c is L. Peter Deutsch
+  <ghost@aladdin.com>.  Other authors are noted in the change history
+  that follows (in reverse chronological order):
+
+  2002-04-13 lpd Clarified derivation from RFC 1321; now handles byte order
+	either statically or dynamically; added missing #include <string.h>
+	in library.
+  2002-03-11 lpd Corrected argument list for main(), and added int return
+	type, in test program and T value program.
+  2002-02-21 lpd Added missing #include <stdio.h> in test program.
+  2000-07-03 lpd Patched to eliminate warnings about "constant is
+	unsigned in ANSI C, signed in traditional"; made test program
+	self-checking.
+  1999-11-04 lpd Edited comments slightly for automatic TOC extraction.
+  1999-10-18 lpd Fixed typo in header comment (ansi2knr rather than md5).
+  1999-05-03 lpd Original version.
+ */
+
+//#include "md5.h"
+#include "utilmd5.h"
+#include <string.h>
+
+#undef BYTE_ORDER	/* 1 = big-endian, -1 = little-endian, 0 = unknown */
+#ifdef ARCH_IS_BIG_ENDIAN
+#  define BYTE_ORDER (ARCH_IS_BIG_ENDIAN ? 1 : -1)
+#else
+#  define BYTE_ORDER 0
+#endif
+
+#define T_MASK ((uint32_t)~0)
+#define T1 /* 0xd76aa478 */ (T_MASK ^ 0x28955b87)
+#define T2 /* 0xe8c7b756 */ (T_MASK ^ 0x173848a9)
+#define T3    0x242070db
+#define T4 /* 0xc1bdceee */ (T_MASK ^ 0x3e423111)
+#define T5 /* 0xf57c0faf */ (T_MASK ^ 0x0a83f050)
+#define T6    0x4787c62a
+#define T7 /* 0xa8304613 */ (T_MASK ^ 0x57cfb9ec)
+#define T8 /* 0xfd469501 */ (T_MASK ^ 0x02b96afe)
+#define T9    0x698098d8
+#define T10 /* 0x8b44f7af */ (T_MASK ^ 0x74bb0850)
+#define T11 /* 0xffff5bb1 */ (T_MASK ^ 0x0000a44e)
+#define T12 /* 0x895cd7be */ (T_MASK ^ 0x76a32841)
+#define T13    0x6b901122
+#define T14 /* 0xfd987193 */ (T_MASK ^ 0x02678e6c)
+#define T15 /* 0xa679438e */ (T_MASK ^ 0x5986bc71)
+#define T16    0x49b40821
+#define T17 /* 0xf61e2562 */ (T_MASK ^ 0x09e1da9d)
+#define T18 /* 0xc040b340 */ (T_MASK ^ 0x3fbf4cbf)
+#define T19    0x265e5a51
+#define T20 /* 0xe9b6c7aa */ (T_MASK ^ 0x16493855)
+#define T21 /* 0xd62f105d */ (T_MASK ^ 0x29d0efa2)
+#define T22    0x02441453
+#define T23 /* 0xd8a1e681 */ (T_MASK ^ 0x275e197e)
+#define T24 /* 0xe7d3fbc8 */ (T_MASK ^ 0x182c0437)
+#define T25    0x21e1cde6
+#define T26 /* 0xc33707d6 */ (T_MASK ^ 0x3cc8f829)
+#define T27 /* 0xf4d50d87 */ (T_MASK ^ 0x0b2af278)
+#define T28    0x455a14ed
+#define T29 /* 0xa9e3e905 */ (T_MASK ^ 0x561c16fa)
+#define T30 /* 0xfcefa3f8 */ (T_MASK ^ 0x03105c07)
+#define T31    0x676f02d9
+#define T32 /* 0x8d2a4c8a */ (T_MASK ^ 0x72d5b375)
+#define T33 /* 0xfffa3942 */ (T_MASK ^ 0x0005c6bd)
+#define T34 /* 0x8771f681 */ (T_MASK ^ 0x788e097e)
+#define T35    0x6d9d6122
+#define T36 /* 0xfde5380c */ (T_MASK ^ 0x021ac7f3)
+#define T37 /* 0xa4beea44 */ (T_MASK ^ 0x5b4115bb)
+#define T38    0x4bdecfa9
+#define T39 /* 0xf6bb4b60 */ (T_MASK ^ 0x0944b49f)
+#define T40 /* 0xbebfbc70 */ (T_MASK ^ 0x4140438f)
+#define T41    0x289b7ec6
+#define T42 /* 0xeaa127fa */ (T_MASK ^ 0x155ed805)
+#define T43 /* 0xd4ef3085 */ (T_MASK ^ 0x2b10cf7a)
+#define T44    0x04881d05
+#define T45 /* 0xd9d4d039 */ (T_MASK ^ 0x262b2fc6)
+#define T46 /* 0xe6db99e5 */ (T_MASK ^ 0x1924661a)
+#define T47    0x1fa27cf8
+#define T48 /* 0xc4ac5665 */ (T_MASK ^ 0x3b53a99a)
+#define T49 /* 0xf4292244 */ (T_MASK ^ 0x0bd6ddbb)
+#define T50    0x432aff97
+#define T51 /* 0xab9423a7 */ (T_MASK ^ 0x546bdc58)
+#define T52 /* 0xfc93a039 */ (T_MASK ^ 0x036c5fc6)
+#define T53    0x655b59c3
+#define T54 /* 0x8f0ccc92 */ (T_MASK ^ 0x70f3336d)
+#define T55 /* 0xffeff47d */ (T_MASK ^ 0x00100b82)
+#define T56 /* 0x85845dd1 */ (T_MASK ^ 0x7a7ba22e)
+#define T57    0x6fa87e4f
+#define T58 /* 0xfe2ce6e0 */ (T_MASK ^ 0x01d3191f)
+#define T59 /* 0xa3014314 */ (T_MASK ^ 0x5cfebceb)
+#define T60    0x4e0811a1
+#define T61 /* 0xf7537e82 */ (T_MASK ^ 0x08ac817d)
+#define T62 /* 0xbd3af235 */ (T_MASK ^ 0x42c50dca)
+#define T63    0x2ad7d2bb
+#define T64 /* 0xeb86d391 */ (T_MASK ^ 0x14792c6e)
+
+
+static void
+md5_process(md5_state_t *pms, const uint8_t *data /*[64]*/)
+{
+    uint32_t
+	a = pms->abcd[0], b = pms->abcd[1],
+	c = pms->abcd[2], d = pms->abcd[3];
+    uint32_t t;
+#if BYTE_ORDER > 0
+    /* Define storage only for big-endian CPUs. */
+    uint32_t X[16];
+#else
+    /* Define storage for little-endian or both types of CPUs. */
+    uint32_t xbuf[16];
+    const uint32_t *X;
+#endif
+
+    {
+#if BYTE_ORDER == 0
+	/*
+	 * Determine dynamically whether this is a big-endian or
+	 * little-endian machine, since we can use a more efficient
+	 * algorithm on the latter.
+	 */
+	static const int w = 1;
+
+	if (*((const uint8_t *)&w)) /* dynamic little-endian */
+#endif
+#if BYTE_ORDER <= 0		/* little-endian */
+	{
+	    /*
+	     * On little-endian machines, we can process properly aligned
+	     * data without copying it.
+	     */
+	    if (!((data - (const uint8_t *)0) & 3)) {
+		/* data are properly aligned */
+		X = (const uint32_t *)data;
+	    } else {
+		/* not aligned */
+		memcpy(xbuf, data, 64);
+		X = xbuf;
+	    }
+	}
+#endif
+#if BYTE_ORDER == 0
+	else			/* dynamic big-endian */
+#endif
+#if BYTE_ORDER >= 0		/* big-endian */
+	{
+	    /*
+	     * On big-endian machines, we must arrange the bytes in the
+	     * right order.
+	     */
+	    const uint8_t *xp = data;
+	    int i;
+
+#  if BYTE_ORDER == 0
+	    X = xbuf;		/* (dynamic only) */
+#  else
+#    define xbuf X		/* (static only) */
+#  endif
+	    for (i = 0; i < 16; ++i, xp += 4)
+		xbuf[i] = xp[0] + (xp[1] << 8) + (xp[2] << 16) + (xp[3] << 24);
+	}
+#endif
+    }
+
+#define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
+
+    /* Round 1. */
+    /* Let [abcd k s i] denote the operation
+       a = b + ((a + F(b,c,d) + X[k] + T[i]) <<< s). */
+#define F(x, y, z) (((x) & (y)) | (~(x) & (z)))
+#define SET(a, b, c, d, k, s, Ti)\
+  t = a + F(b,c,d) + X[k] + Ti;\
+  a = ROTATE_LEFT(t, s) + b
+    /* Do the following 16 operations. */
+    SET(a, b, c, d,  0,  7,  T1);
+    SET(d, a, b, c,  1, 12,  T2);
+    SET(c, d, a, b,  2, 17,  T3);
+    SET(b, c, d, a,  3, 22,  T4);
+    SET(a, b, c, d,  4,  7,  T5);
+    SET(d, a, b, c,  5, 12,  T6);
+    SET(c, d, a, b,  6, 17,  T7);
+    SET(b, c, d, a,  7, 22,  T8);
+    SET(a, b, c, d,  8,  7,  T9);
+    SET(d, a, b, c,  9, 12, T10);
+    SET(c, d, a, b, 10, 17, T11);
+    SET(b, c, d, a, 11, 22, T12);
+    SET(a, b, c, d, 12,  7, T13);
+    SET(d, a, b, c, 13, 12, T14);
+    SET(c, d, a, b, 14, 17, T15);
+    SET(b, c, d, a, 15, 22, T16);
+#undef SET
+
+     /* Round 2. */
+     /* Let [abcd k s i] denote the operation
+          a = b + ((a + G(b,c,d) + X[k] + T[i]) <<< s). */
+#define G(x, y, z) (((x) & (z)) | ((y) & ~(z)))
+#define SET(a, b, c, d, k, s, Ti)\
+  t = a + G(b,c,d) + X[k] + Ti;\
+  a = ROTATE_LEFT(t, s) + b
+     /* Do the following 16 operations. */
+    SET(a, b, c, d,  1,  5, T17);
+    SET(d, a, b, c,  6,  9, T18);
+    SET(c, d, a, b, 11, 14, T19);
+    SET(b, c, d, a,  0, 20, T20);
+    SET(a, b, c, d,  5,  5, T21);
+    SET(d, a, b, c, 10,  9, T22);
+    SET(c, d, a, b, 15, 14, T23);
+    SET(b, c, d, a,  4, 20, T24);
+    SET(a, b, c, d,  9,  5, T25);
+    SET(d, a, b, c, 14,  9, T26);
+    SET(c, d, a, b,  3, 14, T27);
+    SET(b, c, d, a,  8, 20, T28);
+    SET(a, b, c, d, 13,  5, T29);
+    SET(d, a, b, c,  2,  9, T30);
+    SET(c, d, a, b,  7, 14, T31);
+    SET(b, c, d, a, 12, 20, T32);
+#undef SET
+
+     /* Round 3. */
+     /* Let [abcd k s t] denote the operation
+          a = b + ((a + H(b,c,d) + X[k] + T[i]) <<< s). */
+#define H(x, y, z) ((x) ^ (y) ^ (z))
+#define SET(a, b, c, d, k, s, Ti)\
+  t = a + H(b,c,d) + X[k] + Ti;\
+  a = ROTATE_LEFT(t, s) + b
+     /* Do the following 16 operations. */
+    SET(a, b, c, d,  5,  4, T33);
+    SET(d, a, b, c,  8, 11, T34);
+    SET(c, d, a, b, 11, 16, T35);
+    SET(b, c, d, a, 14, 23, T36);
+    SET(a, b, c, d,  1,  4, T37);
+    SET(d, a, b, c,  4, 11, T38);
+    SET(c, d, a, b,  7, 16, T39);
+    SET(b, c, d, a, 10, 23, T40);
+    SET(a, b, c, d, 13,  4, T41);
+    SET(d, a, b, c,  0, 11, T42);
+    SET(c, d, a, b,  3, 16, T43);
+    SET(b, c, d, a,  6, 23, T44);
+    SET(a, b, c, d,  9,  4, T45);
+    SET(d, a, b, c, 12, 11, T46);
+    SET(c, d, a, b, 15, 16, T47);
+    SET(b, c, d, a,  2, 23, T48);
+#undef SET
+
+     /* Round 4. */
+     /* Let [abcd k s t] denote the operation
+          a = b + ((a + I(b,c,d) + X[k] + T[i]) <<< s). */
+#define I(x, y, z) ((y) ^ ((x) | ~(z)))
+#define SET(a, b, c, d, k, s, Ti)\
+  t = a + I(b,c,d) + X[k] + Ti;\
+  a = ROTATE_LEFT(t, s) + b
+     /* Do the following 16 operations. */
+    SET(a, b, c, d,  0,  6, T49);
+    SET(d, a, b, c,  7, 10, T50);
+    SET(c, d, a, b, 14, 15, T51);
+    SET(b, c, d, a,  5, 21, T52);
+    SET(a, b, c, d, 12,  6, T53);
+    SET(d, a, b, c,  3, 10, T54);
+    SET(c, d, a, b, 10, 15, T55);
+    SET(b, c, d, a,  1, 21, T56);
+    SET(a, b, c, d,  8,  6, T57);
+    SET(d, a, b, c, 15, 10, T58);
+    SET(c, d, a, b,  6, 15, T59);
+    SET(b, c, d, a, 13, 21, T60);
+    SET(a, b, c, d,  4,  6, T61);
+    SET(d, a, b, c, 11, 10, T62);
+    SET(c, d, a, b,  2, 15, T63);
+    SET(b, c, d, a,  9, 21, T64);
+#undef SET
+
+     /* Then perform the following additions. (That is increment each
+        of the four registers by the value it had before this block
+        was started.) */
+    pms->abcd[0] += a;
+    pms->abcd[1] += b;
+    pms->abcd[2] += c;
+    pms->abcd[3] += d;
+}
+
+void
+pplib_md5_init(md5_state_t *pms)
+{
+    pms->count[0] = pms->count[1] = 0;
+    pms->abcd[0] = 0x67452301;
+    pms->abcd[1] = /*0xefcdab89*/ T_MASK ^ 0x10325476;
+    pms->abcd[2] = /*0x98badcfe*/ T_MASK ^ 0x67452301;
+    pms->abcd[3] = 0x10325476;
+}
+
+void
+md5_add(md5_state_t *pms, const void *input, size_t size)
+{
+    const uint8_t *p = (const uint8_t *)input;
+    int nbytes = (int)size; // PJ
+    int left = nbytes;
+    int offset = (pms->count[0] >> 3) & 63;
+    uint32_t nbits = (uint32_t)(nbytes << 3);
+
+    if (nbytes <= 0)
+	return;
+
+    /* Update the message length. */
+    pms->count[1] += nbytes >> 29;
+    pms->count[0] += nbits;
+    if (pms->count[0] < nbits)
+	pms->count[1]++;
+
+    /* Process an initial partial block. */
+    if (offset) {
+	int copy = (offset + nbytes > 64 ? 64 - offset : nbytes);
+
+	memcpy(pms->buf + offset, p, copy);
+	if (offset + copy < 64)
+	    return;
+	p += copy;
+	left -= copy;
+	md5_process(pms, pms->buf);
+    }
+
+    /* Process full blocks. */
+    for (; left >= 64; p += 64, left -= 64)
+	md5_process(pms, p);
+
+    /* Process a final partial block. */
+    if (left)
+	memcpy(pms->buf, p, left);
+}
+
+void
+md5_put(md5_state_t *pms, uint8_t digest[16])
+{
+    static const uint8_t pad[64] = {
+	0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
+    };
+    uint8_t data[8];
+    int i;
+
+    /* Save the length before padding. */
+    for (i = 0; i < 8; ++i)
+	data[i] = (uint8_t)(pms->count[i >> 2] >> ((i & 3) << 3));
+    /* Pad to 56 bytes mod 64. */
+    md5_add(pms, pad, ((55 - (pms->count[0] >> 3)) & 63) + 1);
+    /* Append the length. */
+    md5_add(pms, data, 8);
+    for (i = 0; i < 16; ++i)
+	digest[i] = (uint8_t)(pms->abcd[i >> 2] >> ((i & 3) << 3));
+}
+
+/* end of md5.h */
+
+static md5_state_t state;
+
+void pplib_md5 (const void *input, size_t length, uint8_t output[16])
+{
+  pplib_md5_init(&state);
+  md5_add(&state, input, length);
+  md5_put(&state, output);
+}
+
+void md5init (void)
+{
+  pplib_md5_init(&state);
+}
+
+void md5add (const void *input, size_t length)
+{
+  md5_add(&state, input, length);
+}
+
+void md5put (uint8_t output[16])
+{
+  md5_put(&state, output);
+}
diff --git a/texk/web2c/luatexdir/luapplib/util/utilmd5.h b/texk/web2c/luatexdir/luapplib/util/utilmd5.h
new file mode 100644
index 000000000..2fb4bc58d
--- /dev/null
+++ b/texk/web2c/luatexdir/luapplib/util/utilmd5.h
@@ -0,0 +1,115 @@
+#ifndef UTIL_MD5_H
+#define UTIL_MD5_H
+
+#include <stdint.h> // for uintX8_t
+#include <stddef.h> // for size_t
+#include "utildecl.h"
+
+/* begin of md5.h */
+
+/*
+  Copyright (C) 1999, 2002 Aladdin Enterprises.  All rights reserved.
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+
+  L. Peter Deutsch
+  ghost@aladdin.com
+
+ */
+/* $Id: md5.h,v 1.4 2002/04/13 19:20:28 lpd Exp $ */
+/*
+  Independent implementation of MD5 (RFC 1321).
+
+  This code implements the MD5 Algorithm defined in RFC 1321, whose
+  text is available at
+	http://www.ietf.org/rfc/rfc1321.txt
+  The code is derived from the text of the RFC, including the test suite
+  (section A.5) but excluding the rest of Appendix A.  It does not include
+  any code or documentation that is identified in the RFC as being
+  copyrighted.
+
+  The original and principal author of md5.h is L. Peter Deutsch
+  <ghost@aladdin.com>.  Other authors are noted in the change history
+  that follows (in reverse chronological order):
+
+  2002-04-13 lpd Removed support for non-ANSI compilers; removed
+	references to Ghostscript; clarified derivation from RFC 1321;
+	now handles byte order either statically or dynamically.
+  1999-11-04 lpd Edited comments slightly for automatic TOC extraction.
+  1999-10-18 lpd Fixed typo in header comment (ansi2knr rather than md5);
+	added conditionalization for C++ compilation from Martin
+	Purschke <purschke@bnl.gov>.
+  1999-05-03 lpd Original version.
+ */
+
+//#ifndef md5_INCLUDED
+//#  define md5_INCLUDED
+
+/*
+ * This package supports both compile-time and run-time determination of CPU
+ * byte order.  If ARCH_IS_BIG_ENDIAN is defined as 0, the code will be
+ * compiled to run only on little-endian CPUs; if ARCH_IS_BIG_ENDIAN is
+ * defined as non-zero, the code will be compiled to run only on big-endian
+ * CPUs; if ARCH_IS_BIG_ENDIAN is not defined, the code will be compiled to
+ * run on either big- or little-endian CPUs, but will run slightly less
+ * efficiently on either one than if ARCH_IS_BIG_ENDIAN is defined.
+ */
+
+// PJ: replaced with uint8_t and uint32_t
+//typedef unsigned char md5_byte_t; /* 8-bit byte */
+//typedef unsigned int md5_word_t; /* 32-bit word */
+
+/* Define the state of the MD5 Algorithm. */
+typedef struct md5_state_s {
+    uint32_t count[2];	/* message length in bits, lsw first */
+    uint32_t abcd[4];		/* digest buffer */
+    uint8_t buf[64];		/* accumulate block */
+} md5_state_t;
+
+#ifdef __cplusplus
+extern "C" 
+{
+#endif
+
+/* Initialize the algorithm. */
+UTILAPI void pplib_md5_init (md5_state_t *pms);
+
+/* Append a string to the message. */
+//void md5_add(md5_state_t *pms, const uint8_t *data, int nbytes); // PJ
+UTILAPI void md5_add (md5_state_t *pms, const void *input, size_t size);
+
+/* Finish the message and return the digest. */
+//void md5_finish(md5_state_t *pms, uint8_t digest[16]); // PJ
+UTILAPI void md5_put (md5_state_t *pms, uint8_t digest[16]);
+
+#ifdef __cplusplus
+}  /* end extern "C" */
+#endif
+
+//#endif /* md5_INCLUDED */
+
+/* end of md5.h */
+
+#define md5_state md5_state_t
+
+UTILAPI void md5init (void);
+UTILAPI void md5add (const void *input, size_t length);
+UTILAPI void md5put (uint8_t output[16]);
+
+UTILAPI void pplib_md5 (const void *input, size_t length, uint8_t output[16]);
+
+#endif
\ No newline at end of file
diff --git a/texk/web2c/luatexdir/luapplib/util/utilmem.c b/texk/web2c/luatexdir/luapplib/util/utilmem.c
new file mode 100644
index 000000000..1fa00a0c1
--- /dev/null
+++ b/texk/web2c/luatexdir/luapplib/util/utilmem.c
@@ -0,0 +1,68 @@
+
+#include <string.h> // for memcpy
+
+#include "utilmem.h"
+#include "utillog.h"
+
+#ifndef util_memerr
+#  if defined(_WIN64) || defined(__MINGW32__)
+#    define util_memerr(size) { loggerf("ooops, not enough memory (%I64u)", ((unsigned long long)(size))); abort(); }
+#  else
+#    define util_memerr(size) { loggerf("ooops, not enough memory (%llu)", ((unsigned long long)(size))); abort(); }
+#  endif
+#endif
+
+void * util_malloc (size_t size)
+{
+  void *m;
+  if ((m = malloc(size)) == NULL)
+    util_memerr(size);
+  return m;
+}
+
+void * util_calloc (size_t num, size_t size)
+{
+  void *m;
+  if ((m = calloc(num, size)) == NULL)
+    util_memerr(size);
+  return m;
+}
+
+void * util_realloc (void *m, size_t size)
+{
+  if ((m = realloc(m, size)) == NULL)
+    util_memerr(size);
+  return m;
+}
+
+/* common array resizer
+
+data -- the beginning of array
+unit -- sizeof array element
+size -- current array size
+extra -- requested extra size
+space -- pointer to available space
+allocated -- flag indicating if *data has been allocated (with malloc)
+
+*/
+
+void util_resize (void **data, size_t unit, size_t size, size_t extra, size_t *space, int allocated)
+{
+  if (*space == 0)
+    *space = 4; // ... better keep *space non-zero to avoid it
+  do { *space <<= 1; }
+  while (size + extra > *space);
+
+  if (allocated)
+  {
+    *data = util_realloc(*data, *space * unit);
+  }
+  else
+  {
+    void *newdata = util_malloc(*space * unit);
+    if (*data != NULL)
+      memcpy(newdata, *data, size * unit);
+    *data = newdata;
+  }
+}
+
diff --git a/texk/web2c/luatexdir/luapplib/util/utilmem.h b/texk/web2c/luatexdir/luapplib/util/utilmem.h
new file mode 100644
index 000000000..e2d128618
--- /dev/null
+++ b/texk/web2c/luatexdir/luapplib/util/utilmem.h
@@ -0,0 +1,59 @@
+
+#ifndef UTIL_MEM_H
+#define UTIL_MEM_H
+
+#include <stdlib.h> // for size_t and alloc functions
+#include "utildecl.h"
+
+UTILAPI void * util_malloc (size_t size);
+UTILAPI void * util_calloc (size_t num, size_t size);
+UTILAPI void * util_realloc (void *m, size_t size);
+
+#define util_free free // not a call
+
+/* arrays */
+
+#define array_header(element_type, integer_type) \
+    element_type *data; integer_type size; integer_type space
+
+#define array_of(element_type) array_header(element_type, size_t)
+
+#define array_data_is_allocated(array) ((array)->data != (void *)((array) + 1))
+
+#define array_create(array, array_type, element_type, init) \
+  (array = (array_type *)util_malloc(sizeof(array_type) + ((init) > 0 ? ((init) * sizeof(element_type)) : 1)), \
+   array_init(array, element_type, init))
+
+#define array_init(array, element_type, init) \
+  ((array)->data = (element_type *)((array) + 1), (array)->size = 0, (array)->space = init)
+
+#define array_init_data(array, element_type, init) \
+  ((array)->data = (element_type *)util_malloc((init) * sizeof(element_type)), (array)->size = 0, (array)->space = init)
+
+#define array_free_data(array) \
+  ((void)(array_data_is_allocated(array) && (util_free((array)->data), 0)))
+
+#define array_free(array) \
+  ((void)(array_free_data(array), (util_free(array), 0)))
+
+void util_resize (void **data, size_t unit, size_t size, size_t extra, size_t *space, int allocated);
+
+#define array_ensure(array, unit, extra) \
+  ((void)((array)->size + (extra) > (array)->space && \
+         (util_resize((void **)(&(array)->data), unit, (array)->size, extra, &(array)->space, array_data_is_allocated(array)), 0)))
+
+#define array_ensure_alloc(array, unit, extra, isalloc) \
+  ((void)((array)->size + (extra) > (array)->space && \
+         (util_resize((void **)(&(array)->data), unit, (array)->size, extra, &(array)->space, isalloc), 0)))
+
+#define array_at(array, index) ((array)->data + index)
+#define array_index(array, index) (index < (array)->size ? array_at(array, index) : NULL)
+#define array_top(array) ((array)->data + (array)->size - 1)
+
+#define array_from_bottom(array, index) array_at(array, index - 1)
+#define array_from_top(array, negindex) array_at(array, (array)->size + (negindex))
+
+#define array_push(array) ((array)->data + ((array)->size)++)
+#define array_pop(array) ((array)->data + --((array)->size))
+
+#endif
diff --git a/texk/web2c/luatexdir/luapplib/util/utilnumber.c b/texk/web2c/luatexdir/luapplib/util/utilnumber.c
new file mode 100644
index 000000000..c87261e15
--- /dev/null
+++ b/texk/web2c/luatexdir/luapplib/util/utilnumber.c
@@ -0,0 +1,1325 @@
+
+#include <math.h> /* for log10() and floor() */
+#include <stdio.h> /* for printf() */
+
+#include "utilnumber.h"
+
+const int base10_lookup[] = {
+  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+   0, 1, 2, 3, 4, 5, 6, 7, 8, 9,-1,-1,-1,-1,-1,-1,
+  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1
+};
+
+const int base16_lookup[] = {
+  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+   0, 1, 2, 3, 4, 5, 6, 7, 8, 9,-1,-1,-1,-1,-1,-1,
+  -1,10,11,12,13,14,15,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+  -1,10,11,12,13,14,15,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1
+};
+
+const int base26_lookup[] = {
+  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+  -1, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15,
+  16,17,18,19,20,21,22,23,24,25,26,-1,-1,-1,-1,-1,
+  -1, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15,
+  16,17,18,19,20,21,22,23,24,25,26,-1,-1,-1,-1,-1,
+  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1
+};
+
+const int base36_lookup[] = {
+  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+   0, 1, 2, 3, 4, 5, 6, 7, 8, 9,-1,-1,-1,-1,-1,-1,
+  -1,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,
+  25,26,27,28,29,30,31,32,33,34,35,-1,-1,-1,-1,-1,
+  -1,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,
+  25,26,27,28,29,30,31,32,33,34,35,-1,-1,-1,-1,-1,
+  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+  -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1
+};
+
+/* integer from string; return a pointer to character next to the last digit */
+
+#define string_scan_sign(s, c, sign) _scan_sign(c, sign, *++s)
+#define string_scan_integer(s, c, number) _scan_integer(c, number, *++s)
+#define string_scan_radix(s, c, number, radix) _scan_radix(c, number, radix, *++s)
+#define string_read_integer(s, c, number) _read_integer(c, number, *++s)
+#define string_read_radix(s, c, number, radix) _read_radix(c, number, radix, *++s)
+
+const char * string_to_int32 (const char *s, int32_t *number)
+{
+  int sign, c = *s;
+  string_scan_sign(s, c, sign);
+  string_scan_integer(s, c, *number);
+  if (sign) *number = -*number;
+  return s;
+}
+
+const char * string_to_intlw (const char *s, intlw_t *number)
+{
+  int sign, c = *s;
+  string_scan_sign(s, c, sign);
+  string_scan_integer(s, c, *number);
+  if (sign) *number = -*number;
+  return s;
+}
+
+const char * string_to_int64 (const char *s, int64_t *number)
+{
+  int sign, c = *s;
+  string_scan_sign(s, c, sign);
+  string_scan_integer(s, c, *number);
+  if (sign) *number = -*number;
+  return s;
+}
+
+const char * string_to_uint32 (const char *s, uint32_t *number)
+{
+  int c = *s;
+  string_scan_integer(s, c, *number);
+  return s;
+}
+
+const char * string_to_uintlw (const char *s, uintlw_t *number)
+{
+  int c = *s;
+  string_scan_integer(s, c, *number);
+  return s;
+}
+
+const char * string_to_uint64 (const char *s, uint64_t *number)
+{
+  int c = *s;
+  string_scan_integer(s, c, *number);
+  return s;
+}
+
+const char * radix_to_int32 (const char *s, int32_t *number, int radix)
+{
+  int sign, c = *s;
+  string_scan_sign(s, c, sign);
+  string_scan_radix(s, c, *number, radix);
+  if (sign) *number = -*number;
+  return s;
+}
+
+const char * radix_to_intlw (const char *s, intlw_t *number, int radix)
+{
+  int sign, c = *s;
+  string_scan_sign(s, c, sign);
+  string_scan_radix(s, c, *number, radix);
+  if (sign) *number = -*number;
+  return s;
+}
+
+const char * radix_to_int64 (const char *s, int64_t *number, int radix)
+{
+  int sign, c = *s;
+  string_scan_sign(s, c, sign);
+  string_scan_radix(s, c, *number, radix);
+  if (sign) *number = -*number;
+  return s;
+}
+
+const char * radix_to_uint32 (const char *s, uint32_t *number, int radix)
+{
+  int c = *s;
+  string_scan_radix(s, c, *number, radix);
+  return s;
+}
+
+const char * radix_to_uintlw (const char *s, uintlw_t *number, int radix)
+{
+  int c = *s;
+  string_scan_radix(s, c, *number, radix);
+  return s;
+}
+
+const char * radix_to_uint64 (const char *s, uint64_t *number, int radix)
+{
+  int c = *s;
+  string_scan_radix(s, c, *number, radix);
+  return s;
+}
+
+/* roman to uint16_t */
+
+#define roman1000(c) (c == 'M' || c == 'm')
+#define roman500(c)  (c == 'D' || c == 'd')
+#define roman100(c)  (c == 'C' || c == 'c')
+#define roman50(c)   (c == 'L' || c == 'l')
+#define roman10(c)   (c == 'X' || c == 'x')
+#define roman5(c)    (c == 'V' || c == 'v')
+#define roman1(c)    (c == 'I' || c == 'i')
+
+#define roman100s(p) (roman100(*p) ? (100 + ((++p, roman100(*p)) ? (100 + ((++p, roman100(*p)) ? (++p, 100) : 0)) : 0)) : 0)
+#define roman10s(p) (roman10(*p) ? (10 + ((++p, roman10(*p)) ? (10 + ((++p, roman10(*p)) ? (++p, 10) : 0)) : 0)) : 0)
+#define roman1s(p) (roman1(*p) ? (1 + ((++p, roman1(*p)) ? (1 + ((++p, roman1(*p)) ? (++p, 1) : 0)) : 0)) : 0)
+
+const char * roman_to_uint16 (const char *s, uint16_t *number)
+{
+  const char *p;
+  /* M */
+  for (*number = 0, p = s; roman1000(*p); *number += 1000, ++p);
+  /* D C */
+  if (roman500(*p))
+  {
+    ++p;
+    *number += 500 + roman100s(p);
+  }
+  else if (roman100(*p))
+  {
+    ++p;
+    if (roman1000(*p))
+    {
+      ++p;
+      *number += 900;
+    }
+    else if (roman500(*p))
+    {
+      ++p;
+      *number += 400;
+    }
+    else
+      *number += 100 + roman100s(p);
+  }
+  /* L X */
+  if (roman50(*p))
+  {
+    ++p;
+    *number += 50 + roman10s(p);
+  }
+  else if (roman10(*p))
+  {
+    ++p;
+    if (roman100(*p))
+    {
+      ++p;
+      *number += 90;
+    }
+    else if (roman50(*p))
+    {
+      ++p;
+      *number += 40;
+    }
+    else
+      *number += 10 + roman10s(p);
+  }
+  /* V I */
+  if (roman5(*p))
+  {
+    ++p;
+    *number += 5 + roman1s(p);
+  }
+  else if (roman1(*p))
+  {
+    ++p;
+    if (roman10(*p))
+    {
+      ++p;
+      *number += 9;
+    }
+    else if (roman5(*p))
+    {
+      ++p;
+      *number += 4;
+    }
+    else
+      *number += 1 + roman1s(p);
+  }
+  return p;
+}
+
+/* integer to string; return a pointer to null-terminated static const string */
+
+static char integer_buffer[MAX_INTEGER_DIGITS] = {'\0'};
+#define end_of_integer_buffer (integer_buffer + MAX_INTEGER_DIGITS - 1)
+
+/* writing integers */
+
+#define number_printrev_signed(p, number, quotient) \
+  do { \
+    quotient = number; number /= 10; \
+    *--p = base10_palindrome[9 + (quotient - number*10)]; \
+  } while (number); \
+  if (quotient < 0) *--p = '-'
+
+#define number_printrev_unsigned(p, number, quotient) \
+  do { \
+    quotient = number; number /= 10; \
+    *--p = (char)(quotient - integer_multiplied10(number)) + '0'; \
+  } while (number)
+
+char * int32_as_string (int32_t number, char **e)
+{
+  char *p;
+  int quotient;
+  p = end_of_integer_buffer; *p = '\0';
+  if (e != NULL) *e = p;
+  number_printrev_signed(p, number, quotient);
+  return p;
+}
+
+char * intlw_as_string (intlw_t number, char **e)
+{
+  char *p;
+  intlw_t quotient;
+  p = end_of_integer_buffer; *p = '\0';
+  if (e != NULL) *e = p;
+  number_printrev_signed(p, number, quotient);
+  return p;
+}
+
+char * int64_as_string (int64_t number, char **e)
+{
+  char *p;
+  int64_t quotient;
+  p = end_of_integer_buffer; *p = '\0';
+  if (e != NULL) *e = p;
+  number_printrev_signed(p, number, quotient);
+  return p;
+}
+
+char * uint32_as_string (uint32_t number, char **e)
+{
+  char *p;
+  uint32_t quotient;
+  p = end_of_integer_buffer; *p = '\0';
+  if (e != NULL) *e = p;
+  number_printrev_unsigned(p, number, quotient);
+  return p;
+}
+
+char * uintlw_as_string (uintlw_t number, char **e)
+{
+  char *p;
+  uintlw_t quotient;
+  p = end_of_integer_buffer; *p = '\0';
+  if (e != NULL) *e = p;
+  number_printrev_unsigned(p, number, quotient);
+  return p;
+}
+
+char * uint64_as_string (uint64_t number, char **e)
+{
+  char *p;
+  uint64_t quotient;
+  p = end_of_integer_buffer; *p = '\0';
+  if (e != NULL) *e = p;
+  number_printrev_unsigned(p, number, quotient);
+  return p;
+}
+
+/* radix variant */
+
+#define number_printrev_signed_radix_uc(p, number, radix, quotient) \
+  do { \
+    quotient = number; number /= radix; \
+    *--p = base36_uc_palindrome[MAX_RADIX - 1 + (quotient - number*radix)]; \
+  } while (number)
+
+#define number_printrev_signed_radix_lc(p, number, radix, quotient) \
+  do { \
+    quotient = number; number /= radix; \
+    *--p = base36_lc_palindrome[MAX_RADIX - 1 + (quotient - number*radix)]; \
+  } while (number)
+
+#define number_printrev_signed_radix(p, number, radix, quotient) \
+  do { \
+    if (radix > 0) { number_printrev_signed_radix_uc(p, number, radix, quotient); } \
+    else { radix = -radix; number_printrev_signed_radix_lc(p, number, radix, quotient); } \
+    if (quotient < 0) *--p = '-'; \
+  } while (0)
+
+#define number_printrev_unsigned_radix_uc(p, number, radix, quotient) \
+  do { \
+    quotient = number; number /= radix; \
+    *--p = base36_uc_alphabet[quotient % radix]; \
+  } while (number)
+
+#define number_printrev_unsigned_radix_lc(p, number, radix, quotient) \
+  do { \
+    quotient = number; number /= radix; \
+    *--p = base36_lc_alphabet[quotient % radix]; \
+  } while (number)
+
+#define number_printrev_unsigned_radix(p, number, radix, quotient) \
+  do { \
+    if (radix > 0) { number_printrev_unsigned_radix_uc(p, number, radix, quotient); } \
+    else { radix = -radix; number_printrev_unsigned_radix_lc(p, number, radix, quotient); } \
+  } while (0)
+
+char * int32_as_radix (int number, int radix, char **e)
+{
+  char *p;
+  int quotient;
+  p = end_of_integer_buffer; *p = '\0';
+  if (e != NULL) *e = p;
+  number_printrev_signed_radix(p, number, radix, quotient);
+  return p;
+}
+
+char * intlw_as_radix (intlw_t number, int radix, char **e)
+{
+  char *p;
+  intlw_t quotient;
+  p = end_of_integer_buffer; *p = '\0';
+  if (e != NULL) *e = p;
+  number_printrev_signed_radix(p, number, radix, quotient);
+  return p;
+}
+
+char * int64_as_radix (int64_t number, int radix, char **e)
+{
+  char *p;
+  int64_t quotient;
+  p = end_of_integer_buffer; *p = '\0';
+  if (e != NULL) *e = p;
+  number_printrev_signed_radix(p, number, radix, quotient);
+  return p;
+}
+
+char * uint32_as_radix (uint32_t number, int radix, char **e)
+{
+  char *p;
+  uint32_t quotient;
+  p = end_of_integer_buffer; *p = '\0';
+  if (e != NULL) *e = p;
+  number_printrev_unsigned_radix(p, number, radix, quotient);
+  return p;
+}
+
+char * uintlw_as_radix (uintlw_t number, int radix, char **e)
+{
+  char *p;
+  uintlw_t quotient;
+  p = end_of_integer_buffer; *p = '\0';
+  if (e != NULL) *e = p;
+  number_printrev_unsigned_radix(p, number, radix, quotient);
+  return p;
+}
+
+char * uint64_as_radix (uint64_t number, int radix, char **e)
+{
+  char *p;
+  uint64_t quotient;
+  p = end_of_integer_buffer; *p = '\0';
+  if (e != NULL) *e = p;
+  number_printrev_unsigned_radix(p, number, radix, quotient);
+  return p;
+}
+
+/* aaa, aab, aac, ...; unsigned only. 0 gives empty string */
+
+#define string_scan_alpha(s, c, number, radix) \
+  for (number = 0, c = *s; (c = base26_value(c)) > 0; number = number * radix + c, c = *++s)
+
+const char * alpha_to_uint32 (const char *s, uint32_t *number)
+{
+  int c;
+  string_scan_alpha(s, c, *number, 26);
+  return s;
+}
+
+const char * alpha_to_uintlw (const char *s, uintlw_t *number)
+{
+  int c;
+  string_scan_alpha(s, c, *number, 26);
+  return s;
+}
+
+const char * alpha_to_uint64 (const char *s, uint64_t *number)
+{
+  int c;
+  string_scan_alpha(s, c, *number, 26);
+  return s;
+}
+
+#define number_printrev_unsigned_alpha_uc(p, number, radix, quotient) \
+  while (number > 0) { \
+    quotient = --number; number /= radix; \
+    *--p = base26_uc_alphabet[quotient % radix]; \
+  }
+
+#define number_printrev_unsigned_alpha_lc(p, number, radix, quotient) \
+  while (number > 0) { \
+    quotient = --number; number /= radix; \
+    *--p = base26_lc_alphabet[quotient % radix]; \
+  }
+
+char * uint32_as_alpha_uc (uint32_t number, char **e)
+{
+  char *p;
+  uint32_t quotient;
+  p = end_of_integer_buffer; *p = '\0';
+  if (e != NULL) *e = p;
+  number_printrev_unsigned_alpha_uc(p, number, 26, quotient);
+  return p;
+}
+
+char * uint32_as_alpha_lc (uint32_t number, char **e)
+{
+  char *p;
+  uint32_t quotient;
+  p = end_of_integer_buffer; *p = '\0';
+  if (e != NULL) *e = p;
+  number_printrev_unsigned_alpha_lc(p, number, 26, quotient);
+  return p;
+}
+
+char * uintlw_as_alpha_uc (uintlw_t number, char **e)
+{
+  char *p;
+  uintlw_t quotient;
+  p = end_of_integer_buffer; *p = '\0';
+  if (e != NULL) *e = p;
+  number_printrev_unsigned_alpha_uc(p, number, 26, quotient);
+  return p;
+}
+
+char * uintlw_as_alpha_lc (uintlw_t number, char **e)
+{
+  char *p;
+  uintlw_t quotient;
+  p = end_of_integer_buffer; *p = '\0';
+  if (e != NULL) *e = p;
+  number_printrev_unsigned_alpha_lc(p, number, 26, quotient);
+  return p;
+}
+
+char * uint64_as_alpha_uc (uint64_t number, char **e)
+{
+  char *p;
+  uint64_t quotient;
+  p = end_of_integer_buffer; *p = '\0';
+  if (e != NULL) *e = p;
+  number_printrev_unsigned_alpha_uc(p, number, 26, quotient);
+  return p;
+}
+
+char * uint64_as_alpha_lc (uint64_t number, char **e)
+{
+  char *p;
+  uint64_t quotient;
+  p = end_of_integer_buffer; *p = '\0';
+  if (e != NULL) *e = p;
+  number_printrev_unsigned_alpha_lc(p, number, 26, quotient);
+  return p;
+}
+
+/* a variant of alphabetic, a, b, c, ..., z, aa, bb, cc, ..., zz (eg. pdf page labelling) */
+
+#define string_scan_alphan(s, c, number, radix) \
+  do { \
+    number = 0; \
+    if ((c = base26_value(*s)) > 0) { \
+      number = c; \
+      while (c == base26_value(*++s)) number += radix; \
+    }  \
+  } while (0)
+
+const char * alphan_to_uint32 (const char *s, uint32_t *number)
+{
+  int c;
+  string_scan_alphan(s, c, *number, 26);
+  return s;
+}
+
+const char * alphan_to_uintlw (const char *s, uintlw_t *number)
+{
+  int c;
+  string_scan_alphan(s, c, *number, 26);
+  return s;
+}
+
+const char * alphan_to_uint64 (const char *s, uintlw_t *number)
+{
+  int c;
+  string_scan_alphan(s, c, *number, 26);
+  return s;
+}
+
+#define number_print_alphan_uc(s, c, number, radix) \
+  if (number > 0) { \
+    for (c = (--number) % radix, number -= c; ; number -= radix) { \
+      *s++ = base26_uc_alphabet[c]; \
+       if (number == 0 || p >= end_of_integer_buffer) break; \
+    } \
+  }
+
+#define number_print_alphan_lc(s, c, number, radix) \
+  if (number > 0) { \
+    for (c = (--number) % radix, number -= c; ; number -= radix) { \
+      *s++ = base26_lc_alphabet[c]; \
+       if (number == 0 || p >= end_of_integer_buffer) break; \
+    } \
+  }
+
+char * uint32_as_alphan_uc (uint32_t number, char **e)
+{
+  char *p;
+  uint8_t c;
+  p = integer_buffer;
+  number_print_alphan_uc(p, c, number, 26);
+  *p = '\0'; if (e != NULL) *e = p;
+  return integer_buffer;
+}
+
+char * uint32_as_alphan_lc (uint32_t number, char **e)
+{
+  char *p;
+  uint8_t c;
+  p = integer_buffer;
+  number_print_alphan_lc(p, c, number, 26);
+  *p = '\0'; if (e != NULL) *e = p;
+  return integer_buffer;
+}
+
+char * uintlw_as_alphan_uc (uintlw_t number, char **e)
+{
+  char *p;
+  uint8_t c;
+  p = integer_buffer;
+  number_print_alphan_uc(p, c, number, 26);
+  *p = '\0'; if (e != NULL) *e = p;
+  return integer_buffer;
+}
+
+char * uintlw_as_alphan_lc (uintlw_t number, char **e)
+{
+  char *p;
+  uint8_t c;
+  p = integer_buffer;
+  number_print_alphan_lc(p, c, number, 26);
+  *p = '\0'; if (e != NULL) *e = p;
+  return integer_buffer;
+}
+
+char * uint64_as_alphan_uc (uint64_t number, char **e)
+{
+  char *p;
+  uint8_t c;
+  p = integer_buffer;
+  number_print_alphan_uc(p, c, number, 26);
+  *p = '\0'; if (e != NULL) *e = p;
+  return integer_buffer;
+}
+
+char * uint64_as_alphan_lc (uint64_t number, char **e)
+{
+  char *p;
+  uint8_t c;
+  p = integer_buffer;
+  number_print_alphan_lc(p, c, number, 26);
+  *p = '\0'; if (e != NULL) *e = p;
+  return integer_buffer;
+}
+
+/* roman numeral */
+
+/* todo: large roman numerals? http://mathforum.org/library/drmath/view/57569.html */
+
+#define base_roman_uc_alphabet "MDCLXVI"
+#define base_roman_lc_alphabet "mdclxvi"
+
+static const uint32_t base_roman_values[] = { 1000, 500, 100, 50, 10, 5, 1 };
+
+#define integer_to_roman(p, number, alphabet) \
+  { \
+    uint32_t k, j, v, u; \
+    for (j = 0, v = base_roman_values[0]; number > 0; ) \
+    { \
+      if (number >= v) \
+      { \
+       *p++ = alphabet[j]; \
+       number -= v; \
+       continue; \
+      } \
+      if (j & 1) \
+        k = j + 1; \
+      else \
+        k = j + 2; \
+      u = base_roman_values[k]; \
+      if (number + u >= v) \
+      { \
+        *p++ = alphabet[k]; \
+        number += u; \
+      } \
+      else \
+        v = base_roman_values[++j]; \
+    } \
+  }
+
+char * uint16_as_roman_uc (uint16_t number, char **e)
+{
+  char *p = integer_buffer;
+  integer_to_roman(p, number, base_roman_uc_alphabet);
+  if (e != NULL)
+    *e = p;
+  *p = '\0';
+  return integer_buffer;
+}
+
+char * uint16_as_roman_lc (uint16_t number, char **e)
+{
+  char *p = integer_buffer;
+  integer_to_roman(p, number, base_roman_lc_alphabet);
+  if (e != NULL)
+    *e = p;
+  *p = '\0';
+  return integer_buffer;
+}
+
+/* IEEE-754 */
+
+#define BINARY_MODF    1
+
+#define NOT_A_NUMBER_STRING "NaN"
+#define INFINITY_STRING "INF"
+#define SIGNED_INFINITY 1
+#define SIGNED_ZERO 0
+#define SIGNED_NOT_A_NUMBER 0
+#define RADIX_CHAR '.'
+
+/* double/float to decimal */
+
+typedef struct ieee_double {
+  union {
+    double number;
+    uint64_t bits;
+  };
+  uint64_t fraction;
+  int exponent, sign;
+} ieee_double;
+
+typedef struct ieee_float {
+  union {
+    float number;
+    uint32_t bits;
+  };
+  uint32_t fraction;
+  int exponent, sign;
+} ieee_float;
+
+#define IEEE_DOUBLE_BIAS           1023
+#define IEEE_DOUBLE_MIN_EXPONENT  -1023
+#define IEEE_DOUBLE_MAX_EXPONENT  (0x7ff - IEEE_DOUBLE_BIAS)
+
+#define IEEE_FLOAT_BIAS            127
+#define IEEE_FLOAT_MIN_EXPONENT   -127
+#define IEEE_FLOAT_MAX_EXPONENT   (0xff - IEEE_FLOAT_BIAS)
+
+#define ieee_double_fraction(i) (i & 0x000fffffffffffffull)
+#define ieee_double_exponent(i) ((0x7ff & (i >> 52)) - IEEE_DOUBLE_BIAS)
+#define ieee_double_sign(ieee_number) ((void)((ieee_number.sign = ieee_number.bits >> 63) && (ieee_number.number = -ieee_number.number)))
+#define ieee_double_init(ieee_number, number) \
+  ieee_number.number = number, \
+  ieee_number.fraction = ieee_double_fraction(ieee_number.bits), \
+  ieee_number.exponent = ieee_double_exponent(ieee_number.bits)
+
+#define ieee_float_fraction(i) (i & 0x007fffff)
+#define ieee_float_exponent(i) ((0xff & (i >> 23)) - IEEE_FLOAT_BIAS)
+#define ieee_float_sign(ieee_number) ((void)((ieee_number.sign = ieee_number.bits >> 31) && (ieee_number.number = -ieee_number.number)))
+#define ieee_float_init(ieee_number, number) \
+  ieee_number.number = number, \
+  ieee_number.fraction = ieee_float_fraction(ieee_number.bits), \
+  ieee_number.exponent = ieee_float_exponent(ieee_number.bits)
+
+/* special cases  */
+
+#define ieee_double_is_zero(ieee_number) (ieee_number.number == 0) // || ieee_double_too_small(ieee_number) ?
+#define ieee_double_too_small(ieee_number) (ieee_number.exponent == 0 && ieee_number.fraction != 0) // denormalized, implicit fracion bit not set
+
+#define ieee_float_is_zero(ieee_number) (ieee_number.number == 0) // || ieee_float_too_small(ieee_number) ?
+#define ieee_float_too_small(ieee_number) (ieee_number.exponent == 0 && ieee_number.fraction != 0)
+
+#define ieee_double_zero_string(ieee_number) (SIGNED_ZERO && ieee_number.sign ? "-0" : "0")
+#define ieee_double_infinity_string(ieee_number) (SIGNED_INFINITY && ieee_number.sign ? "-" INFINITY_STRING : INFINITY_STRING)
+
+#define ieee_float_zero_string ieee_double_zero_string
+#define ieee_float_infinity_string ieee_double_infinity_string
+
+#define ieee_double_special_case(ieee_number) (ieee_number.exponent == IEEE_DOUBLE_MAX_EXPONENT)
+#define ieee_double_special_string(ieee_number) (ieee_number.fraction ? NOT_A_NUMBER_STRING : ieee_double_infinity_string(ieee_number))
+
+#define ieee_float_special_case(ieee_number) (ieee_number.exponent == IEEE_FLOAT_MAX_EXPONENT)
+#define ieee_float_special_string(ieee_number) (ieee_number.fraction ? NOT_A_NUMBER_STRING : ieee_float_infinity_string(ieee_number))
+
+#if 0
+
+const double double_binary_power10[] =
+{
+  1.0e1, 1.0e2, 1.0e4, 1.0e8, 1.0e16, 1.0e32, 1.0e64, 1.0e128, 1.0e256
+};
+
+const float float_binary_power10[] =
+{
+  1.0e1, 1.0e2, 1.0e4, 1.0e8, 1.0e16, 1.0e32
+};
+
+const double double_binary_negpower10[] =
+{
+  1.0e-1, 1.0e-2, 1.0e-4, 1.0e-8, 1.0e-16, 1.0e-32
+};
+
+const float float_binary_negpower10[] =
+{
+  1.0e-1, 1.0e-2, 1.0e-4, 1.0e-8, 1.0e-16, 1.0e-32
+};
+
+#else
+
+const double double_decimal_power10[] = {
+    1.0e0,   1.0e1,   1.0e2,   1.0e3,   1.0e4,   1.0e5,   1.0e6,   1.0e7,   1.0e8,   1.0e9,
+   1.0e10,  1.0e11,  1.0e12,  1.0e13,  1.0e14,  1.0e15,  1.0e16,  1.0e17,  1.0e18,  1.0e19,
+   1.0e20,  1.0e21,  1.0e22,  1.0e23,  1.0e24,  1.0e25,  1.0e26,  1.0e27,  1.0e28,  1.0e29,
+   1.0e30,  1.0e31,  1.0e32,  1.0e33,  1.0e34,  1.0e35,  1.0e36,  1.0e37,  1.0e38,  1.0e39,
+   1.0e40,  1.0e41,  1.0e42,  1.0e43,  1.0e44,  1.0e45,  1.0e46,  1.0e47,  1.0e48,  1.0e49,
+   1.0e50,  1.0e51,  1.0e52,  1.0e53,  1.0e54,  1.0e55,  1.0e56,  1.0e57,  1.0e58,  1.0e59,
+   1.0e60,  1.0e61,  1.0e62,  1.0e63,  1.0e64,  1.0e65,  1.0e66,  1.0e67,  1.0e68,  1.0e69,
+   1.0e70,  1.0e71,  1.0e72,  1.0e73,  1.0e74,  1.0e75,  1.0e76,  1.0e77,  1.0e78,  1.0e79,
+   1.0e80,  1.0e81,  1.0e82,  1.0e83,  1.0e84,  1.0e85,  1.0e86,  1.0e87,  1.0e88,  1.0e89,
+   1.0e90,  1.0e91,  1.0e92,  1.0e93,  1.0e94,  1.0e95,  1.0e96,  1.0e97,  1.0e98,  1.0e99,
+  1.0e100, 1.0e101, 1.0e102, 1.0e103, 1.0e104, 1.0e105, 1.0e106, 1.0e107, 1.0e108, 1.0e109,
+  1.0e110, 1.0e111, 1.0e112, 1.0e113, 1.0e114, 1.0e115, 1.0e116, 1.0e117, 1.0e118, 1.0e119,
+  1.0e120, 1.0e121, 1.0e122, 1.0e123, 1.0e124, 1.0e125, 1.0e126, 1.0e127, 1.0e128, 1.0e129,
+  1.0e130, 1.0e131, 1.0e132, 1.0e133, 1.0e134, 1.0e135, 1.0e136, 1.0e137, 1.0e138, 1.0e139,
+  1.0e140, 1.0e141, 1.0e142, 1.0e143, 1.0e144, 1.0e145, 1.0e146, 1.0e147, 1.0e148, 1.0e149,
+  1.0e150, 1.0e151, 1.0e152, 1.0e153, 1.0e154, 1.0e155, 1.0e156, 1.0e157, 1.0e158, 1.0e159,
+  1.0e160, 1.0e161, 1.0e162, 1.0e163, 1.0e164, 1.0e165, 1.0e166, 1.0e167, 1.0e168, 1.0e169,
+  1.0e170, 1.0e171, 1.0e172, 1.0e173, 1.0e174, 1.0e175, 1.0e176, 1.0e177, 1.0e178, 1.0e179,
+  1.0e180, 1.0e181, 1.0e182, 1.0e183, 1.0e184, 1.0e185, 1.0e186, 1.0e187, 1.0e188, 1.0e189,
+  1.0e190, 1.0e191, 1.0e192, 1.0e193, 1.0e194, 1.0e195, 1.0e196, 1.0e197, 1.0e198, 1.0e199,
+  1.0e200, 1.0e201, 1.0e202, 1.0e203, 1.0e204, 1.0e205, 1.0e206, 1.0e207, 1.0e208, 1.0e209,
+  1.0e210, 1.0e211, 1.0e212, 1.0e213, 1.0e214, 1.0e215, 1.0e216, 1.0e217, 1.0e218, 1.0e219,
+  1.0e220, 1.0e221, 1.0e222, 1.0e223, 1.0e224, 1.0e225, 1.0e226, 1.0e227, 1.0e228, 1.0e229,
+  1.0e230, 1.0e231, 1.0e232, 1.0e233, 1.0e234, 1.0e235, 1.0e236, 1.0e237, 1.0e238, 1.0e239,
+  1.0e240, 1.0e241, 1.0e242, 1.0e243, 1.0e244, 1.0e245, 1.0e246, 1.0e247, 1.0e248, 1.0e249,
+  1.0e250, 1.0e251, 1.0e252, 1.0e253, 1.0e254, 1.0e255, 1.0e256, 1.0e257, 1.0e258, 1.0e259,
+  1.0e260, 1.0e261, 1.0e262, 1.0e263, 1.0e264, 1.0e265, 1.0e266, 1.0e267, 1.0e268, 1.0e269,
+  1.0e270, 1.0e271, 1.0e272, 1.0e273, 1.0e274, 1.0e275, 1.0e276, 1.0e277, 1.0e278, 1.0e279,
+  1.0e280, 1.0e281, 1.0e282, 1.0e283, 1.0e284, 1.0e285, 1.0e286, 1.0e287, 1.0e288, 1.0e289,
+  1.0e290, 1.0e291, 1.0e292, 1.0e293, 1.0e294, 1.0e295, 1.0e296, 1.0e297, 1.0e298, 1.0e299,
+  1.0e300, 1.0e301, 1.0e302, 1.0e303, 1.0e304, 1.0e305, 1.0e306, 1.0e307, 1.0e308
+};
+
+const float float_decimal_power10[] = {
+    1.0e0f,   1.0e1f,   1.0e2f,   1.0e3f,   1.0e4f,   1.0e5f,   1.0e6f,   1.0e7f,   1.0e8f,   1.0e9f,
+   1.0e10f,  1.0e11f,  1.0e12f,  1.0e13f,  1.0e14f,  1.0e15f,  1.0e16f,  1.0e17f,  1.0e18f,  1.0e19f,
+   1.0e20f,  1.0e21f,  1.0e22f,  1.0e23f,  1.0e24f,  1.0e25f,  1.0e26f,  1.0e27f,  1.0e28f,  1.0e29f,
+   1.0e30f,  1.0e31f,  1.0e32f,  1.0e33f,  1.0e34f,  1.0e35f,  1.0e36f,  1.0e37f,  1.0e38f
+};
+
+const double double_decimal_negpower10[] = {
+    1.0e0,   1.0e-1,   1.0e-2,   1.0e-3,   1.0e-4,   1.0e-5,   1.0e-6,   1.0e-7,   1.0e-8,   1.0e-9,
+   1.0e-10,  1.0e-11,  1.0e-12,  1.0e-13,  1.0e-14,  1.0e-15,  1.0e-16,  1.0e-17,  1.0e-18,  1.0e-19,
+   1.0e-20,  1.0e-21,  1.0e-22,  1.0e-23,  1.0e-24,  1.0e-25,  1.0e-26,  1.0e-27,  1.0e-28,  1.0e-29,
+   1.0e-30,  1.0e-31,  1.0e-32,  1.0e-33,  1.0e-34,  1.0e-35,  1.0e-36,  1.0e-37,  1.0e-38,  1.0e-39,
+   1.0e-40,  1.0e-41,  1.0e-42,  1.0e-43,  1.0e-44,  1.0e-45,  1.0e-46,  1.0e-47,  1.0e-48,  1.0e-49,
+   1.0e-50,  1.0e-51,  1.0e-52,  1.0e-53,  1.0e-54,  1.0e-55,  1.0e-56,  1.0e-57,  1.0e-58,  1.0e-59,
+   1.0e-60,  1.0e-61,  1.0e-62,  1.0e-63,  1.0e-64,  1.0e-65,  1.0e-66,  1.0e-67,  1.0e-68,  1.0e-69,
+   1.0e-70,  1.0e-71,  1.0e-72,  1.0e-73,  1.0e-74,  1.0e-75,  1.0e-76,  1.0e-77,  1.0e-78,  1.0e-79,
+   1.0e-80,  1.0e-81,  1.0e-82,  1.0e-83,  1.0e-84,  1.0e-85,  1.0e-86,  1.0e-87,  1.0e-88,  1.0e-89,
+   1.0e-90,  1.0e-91,  1.0e-92,  1.0e-93,  1.0e-94,  1.0e-95,  1.0e-96,  1.0e-97,  1.0e-98,  1.0e-99,
+  1.0e-100, 1.0e-101, 1.0e-102, 1.0e-103, 1.0e-104, 1.0e-105, 1.0e-106, 1.0e-107, 1.0e-108, 1.0e-109,
+  1.0e-110, 1.0e-111, 1.0e-112, 1.0e-113, 1.0e-114, 1.0e-115, 1.0e-116, 1.0e-117, 1.0e-118, 1.0e-119,
+  1.0e-120, 1.0e-121, 1.0e-122, 1.0e-123, 1.0e-124, 1.0e-125, 1.0e-126, 1.0e-127, 1.0e-128, 1.0e-129,
+  1.0e-130, 1.0e-131, 1.0e-132, 1.0e-133, 1.0e-134, 1.0e-135, 1.0e-136, 1.0e-137, 1.0e-138, 1.0e-139,
+  1.0e-140, 1.0e-141, 1.0e-142, 1.0e-143, 1.0e-144, 1.0e-145, 1.0e-146, 1.0e-147, 1.0e-148, 1.0e-149,
+  1.0e-150, 1.0e-151, 1.0e-152, 1.0e-153, 1.0e-154, 1.0e-155, 1.0e-156, 1.0e-157, 1.0e-158, 1.0e-159,
+  1.0e-160, 1.0e-161, 1.0e-162, 1.0e-163, 1.0e-164, 1.0e-165, 1.0e-166, 1.0e-167, 1.0e-168, 1.0e-169,
+  1.0e-170, 1.0e-171, 1.0e-172, 1.0e-173, 1.0e-174, 1.0e-175, 1.0e-176, 1.0e-177, 1.0e-178, 1.0e-179,
+  1.0e-180, 1.0e-181, 1.0e-182, 1.0e-183, 1.0e-184, 1.0e-185, 1.0e-186, 1.0e-187, 1.0e-188, 1.0e-189,
+  1.0e-190, 1.0e-191, 1.0e-192, 1.0e-193, 1.0e-194, 1.0e-195, 1.0e-196, 1.0e-197, 1.0e-198, 1.0e-199,
+  1.0e-200, 1.0e-201, 1.0e-202, 1.0e-203, 1.0e-204, 1.0e-205, 1.0e-206, 1.0e-207, 1.0e-208, 1.0e-209,
+  1.0e-210, 1.0e-211, 1.0e-212, 1.0e-213, 1.0e-214, 1.0e-215, 1.0e-216, 1.0e-217, 1.0e-218, 1.0e-219,
+  1.0e-220, 1.0e-221, 1.0e-222, 1.0e-223, 1.0e-224, 1.0e-225, 1.0e-226, 1.0e-227, 1.0e-228, 1.0e-229,
+  1.0e-230, 1.0e-231, 1.0e-232, 1.0e-233, 1.0e-234, 1.0e-235, 1.0e-236, 1.0e-237, 1.0e-238, 1.0e-239,
+  1.0e-240, 1.0e-241, 1.0e-242, 1.0e-243, 1.0e-244, 1.0e-245, 1.0e-246, 1.0e-247, 1.0e-248, 1.0e-249,
+  1.0e-250, 1.0e-251, 1.0e-252, 1.0e-253, 1.0e-254, 1.0e-255, 1.0e-256, 1.0e-257, 1.0e-258, 1.0e-259,
+  1.0e-260, 1.0e-261, 1.0e-262, 1.0e-263, 1.0e-264, 1.0e-265, 1.0e-266, 1.0e-267, 1.0e-268, 1.0e-269,
+  1.0e-270, 1.0e-271, 1.0e-272, 1.0e-273, 1.0e-274, 1.0e-275, 1.0e-276, 1.0e-277, 1.0e-278, 1.0e-279,
+  1.0e-280, 1.0e-281, 1.0e-282, 1.0e-283, 1.0e-284, 1.0e-285, 1.0e-286, 1.0e-287, 1.0e-288, 1.0e-289,
+  1.0e-290, 1.0e-291, 1.0e-292, 1.0e-293, 1.0e-294, 1.0e-295, 1.0e-296, 1.0e-297, 1.0e-298, 1.0e-299,
+  1.0e-300, 1.0e-301, 1.0e-302, 1.0e-303, 1.0e-304, 1.0e-305, 1.0e-306, 1.0e-307, 1.0e-308
+};
+
+const float float_decimal_negpower10[] = {
+     1.0e0f,   1.0e-1f,   1.0e-2f,   1.0e-3f,   1.0e-4f,   1.0e-5f,   1.0e-6f,   1.0e-7f,   1.0e-8f,   1.0e-9f,
+   1.0e-10f,  1.0e-11f,  1.0e-12f,  1.0e-13f,  1.0e-14f,  1.0e-15f,  1.0e-16f,  1.0e-17f,  1.0e-18f,  1.0e-19f,
+   1.0e-20f,  1.0e-21f,  1.0e-22f,  1.0e-23f,  1.0e-24f,  1.0e-25f,  1.0e-26f,  1.0e-27f,  1.0e-28f,  1.0e-29f,
+   1.0e-30f,  1.0e-31f,  1.0e-32f,  1.0e-33f,  1.0e-34f,  1.0e-35f,  1.0e-36f,  1.0e-37f,  1.0e-38f
+};
+
+#endif
+
+/* scale number by floor(log10(number)) + 1 so that the result is in range [0.1, 1) */
+
+#define ieee_double_exponent10(ieee_number) ((int)floor(log10(ieee_number.number)) + 1)
+#define ieee_float_exponent10(ieee_number) ((int)floorf(log10f(ieee_number.number)) + 1) // floorf, log10f ?
+
+#define ieee_double_exp10(ieee_number, exponent10) \
+  exponent10 = ieee_double_exponent10(ieee_number); \
+  if (exponent10 > 0) { \
+    double_negative_exp10(ieee_number.number, -exponent10); \
+    ieee_number.fraction = ieee_double_fraction(ieee_number.bits); \
+    ieee_number.exponent = ieee_double_exponent(ieee_number.bits); \
+  } else if (exponent10 < 0) { \
+    double_positive_exp10(ieee_number.number, -exponent10); \
+    ieee_number.fraction = ieee_double_fraction(ieee_number.bits); \
+    ieee_number.exponent = ieee_double_exponent(ieee_number.bits); \
+  }
+
+#define ieee_float_exp10(ieee_number, exponent10) \
+  exponent10 = ieee_float_exponent10(ieee_number); \
+  if (exponent10 > 0) { \
+    float_negative_exp10(ieee_number.number, -exponent10); \
+    ieee_number.fraction = ieee_float_fraction(ieee_number.bits); \
+    ieee_number.exponent = ieee_float_exponent(ieee_number.bits); \
+  } else if (exponent10 < 0) { \
+    float_positive_exp10(ieee_number.number, -exponent10); \
+    ieee_number.fraction = ieee_float_fraction(ieee_number.bits); \
+    ieee_number.exponent = ieee_float_exponent(ieee_number.bits); \
+  }
+
+#if BINARY_MODF
+
+/* unhide implicit bit 53, produce 56-bit denormalised fraction (binary exponent already in range [-4, -1]) */
+
+#define ieee_double_denormalize(ieee_number) \
+  (ieee_number.exponent == IEEE_DOUBLE_MIN_EXPONENT ? (++ieee_number.exponent, 0) : (ieee_number.fraction |= (1ull<<52))), \
+  ieee_number.fraction <<= (ieee_number.exponent + 4)
+
+/* unhide implicit bit 24, produce 27-bit denormalized fraction (binary exponent already in range [-4, -1]) */
+
+#define ieee_float_denormalize(ieee_number) \
+  (ieee_number.exponent == IEEE_FLOAT_MIN_EXPONENT ? (++ieee_number.exponent, 0) : (ieee_number.fraction |= (1<<23))), \
+  ieee_number.fraction <<= (ieee_number.exponent + 4)
+
+/* turn off significant bits over 56 (integer part), multiply by 10, return new integer part (subsequent decimal digit) */
+
+#define ieee_double_binary_fraction(ieee_number) \
+  (ieee_number.fraction &= ((1ull<<56) - 1), \
+   ieee_number.fraction = (ieee_number.fraction << 1) + (ieee_number.fraction << 3), \
+   ieee_number.fraction >> 56)
+
+/* turn off significant bits over 27 (integer part), multiply by 10, return the integer part (subsequent decimal digit) */
+
+#define ieee_float_binary_fraction(ieee_number) \
+  (ieee_number.fraction &= ((1<<27) - 1), \
+   ieee_number.fraction = (ieee_number.fraction << 1) + (ieee_number.fraction << 3), \
+   ieee_number.fraction >> 27)
+
+#define ieee_double_decimal(ieee_number, exponent10, digits, p) \
+  ieee_number_decimal(ieee_double_binary_fraction, ieee_number, exponent10, digits, p)
+#define ieee_float_decimal(ieee_number, exponent10, digits, p) \
+  ieee_number_decimal(ieee_float_binary_fraction, ieee_number, exponent10, digits, p)
+#define ieee_double_decimal_dot(ieee_number, exponent10, digits, p, dot) \
+  ieee_number_decimal_dot(ieee_double_binary_fraction, ieee_number, exponent10, digits, p, dot)
+#define ieee_float_decimal_dot(ieee_number, exponent10, digits, p, dot) \
+  ieee_number_decimal_dot(ieee_float_binary_fraction, ieee_number, exponent10, digits, p, dot)
+
+#else
+
+/* generic method */
+
+#define ieee_double_decimal_fraction(ieee_number, i) (ieee_number.number = modf(10*ieee_number.number, &i), i)
+#define ieee_float_decimal_fraction(ieee_number, i) (ieee_number.number = (float)modf(10*ieee_number.number, &i), i) // ???
+
+#define ieee_double_decimal(ieee_number, exponent10, digits, p) \
+  ieee_number_decimal(ieee_double_decimal_fraction, ieee_number, exponent10, digits, p)
+#define ieee_float_decimal(ieee_number, exponent10, digits, p) \
+  ieee_number_decimal(ieee_float_decimal_fraction, ieee_number, exponent10, digits, p)
+#define ieee_double_decimal_dot(ieee_number, exponent10, digits, p, dot) \
+  ieee_number_decimal_dot(ieee_double_decimal_fraction, ieee_number, exponent10, digits, p, dot)
+#define ieee_float_decimal_dot(ieee_number, exponent10, digits, p, dot) \
+  ieee_number_decimal_dot(ieee_float_decimal_fraction, ieee_number, exponent10, digits, p, dot)
+
+#endif
+
+#define ieee_number_decimal(method, ieee_number, exponent10, digits, p) \
+  ieee_double_denormalize(ieee_number); \
+  if (ieee_number.sign) *p++ = '-'; \
+  if (exponent10 <= 0) \
+    for (*p++ = '0', *p++ = RADIX_CHAR; exponent10 && digits; *p++ = '0', ++exponent10, --digits); \
+  else \
+  { \
+    do { *p++ = '0' + (char)method(ieee_number); } while (--exponent10); \
+    *p++ = RADIX_CHAR; \
+  } \
+  for  ( ; digits && ieee_number.fraction; --digits) \
+    *p++ = '0' + (char)method(ieee_number)
+
+#define ieee_number_decimal_dot(method, ieee_number, exponent10, digits, p, dot) \
+  ieee_double_denormalize(ieee_number); \
+  if (ieee_number.sign) *p++ = '-'; \
+  if (exponent10 <= 0) \
+  { \
+    *p++ = '0'; \
+    if (dot != NULL) *dot = p; \
+    for (*p++ = RADIX_CHAR; exponent10 && digits; *p++ = '0', ++exponent10, --digits); \
+  } \
+  else \
+  { \
+    do { *p++ = '0' + (char)method(ieee_number); } while (--exponent10); \
+    if (dot != NULL) *dot = p; \
+    *p++ = RADIX_CHAR; \
+  } \
+  for  ( ; digits && ieee_number.fraction; --digits) \
+    *p++ = '0' + (char)method(ieee_number)
+
+/* rounding to nearest integer */
+
+#if BINARY_MODF
+/* check if the mantissa has the most significant bit set, means >= 0.5 */
+#  define ieee_double_half(ieee_number) (ieee_number.fraction & (1ull<<55))
+#  define ieee_float_half(ieee_number) (ieee_number.fraction & (1<<26))
+#else
+#  define ieee_double_half(ieee_number) (ieee_number.number >= 0.5)
+#  define ieee_float_half(ieee_number) (ieee_number.number >= 0.5)
+#endif
+
+/* rounding to nearest integer */
+
+#define buffer_ceil(s, p, sign) \
+  { \
+    while (*--p == '9'); \
+    if (*p != RADIX_CHAR) ++*p++; \
+    else { \
+      char *q; \
+      for (q = p - 1; ; --q) { \
+        if (*q < '9') { ++*q; break; } \
+        *q = '0'; \
+        if (q == s) \
+          *--s = '1'; \
+        else if (sign && q - 1 == s) \
+          *s = '1', *--s = '-'; \
+      } \
+    } \
+  }
+
+#define buffer_remove_trailing_zeros(s, p, sign) \
+  { \
+    while (*--p == '0'); \
+    if (*p != RADIX_CHAR) \
+      ++p; \
+    else if (!SIGNED_ZERO && sign && p - 2 == s && *(p - 1) == '0') \
+      p -= 2, *p++ = '0'; \
+  }
+
+// if digits parameter was initially less then exponent10, then exponent10 > 0 and ieee_double_half(ieee_number) is irrelevant
+#define ieee_double_round(ieee_number, exponent10, s, p) \
+  if (exponent10 == 0 && ieee_double_half(ieee_number)) \
+    { buffer_ceil(s, p, ieee_number.sign); } \
+  else \
+    { buffer_remove_trailing_zeros(s, p, ieee_number.sign); }
+
+#define ieee_float_round(ieee_number, exponent10, s, p) \
+  if (exponent10 == 0 && ieee_float_half(ieee_number)) \
+    { buffer_ceil(s, p, ieee_number.sign); } \
+  else \
+    { buffer_remove_trailing_zeros(s, p, ieee_number.sign); }
+
+/* double to decimal */
+
+static char number_buffer[512];
+
+#define ieee_copy_special_string(special, p, _p) \
+  for (p = (char *)number_buffer, _p = special; ; ++p, ++_p) { \
+    if ((*p = *_p) == '\0') break; \
+  }
+
+#define ieee_copy_special_string_re(special, p, _p, r, e) \
+  for (p = (char *)number_buffer, _p = special; ; ++p, ++_p) { \
+    if ((*p = *_p) == '\0') { \
+    	if (r != NULL) *r = NULL; \
+    	if (e != NULL) *e = p; \
+      break; \
+    } \
+  }
+
+char * double_to_string (double number, int digits)
+{
+  ieee_double ieee_number;
+  int exponent10;
+  char *s, *p; const char *_p;
+  ieee_double_init(ieee_number, number);
+  ieee_double_sign(ieee_number);
+  if (ieee_double_is_zero(ieee_number)) // to avoid crash on log10(number)
+  {
+    ieee_copy_special_string(ieee_double_zero_string(ieee_number), p, _p);
+    return (char *)number_buffer;
+  }
+  if (ieee_double_special_case(ieee_number))
+  {
+    ieee_copy_special_string(ieee_double_special_string(ieee_number), p, _p);
+    return (char *)number_buffer;
+  }
+  s = p = number_buffer + 1;
+  ieee_double_exp10(ieee_number, exponent10);
+  ieee_double_decimal(ieee_number, exponent10, digits, p);
+  ieee_double_round(ieee_number, exponent10, s, p);
+  *p = '\0';
+  return s;
+}
+
+char * double_as_string (double number, int digits, char **r, char **e)
+{
+  ieee_double ieee_number;
+  int exponent10;
+  char *s, *p; const char *_p;
+  s = p = number_buffer + 1;
+  ieee_double_init(ieee_number, number);
+  ieee_double_sign(ieee_number);
+  if (ieee_double_is_zero(ieee_number)) // to avoid crash on log10(number)
+  {
+    ieee_copy_special_string_re(ieee_double_zero_string(ieee_number), p, _p, r, e);
+    return (char *)number_buffer;
+  }
+  if (ieee_double_special_case(ieee_number))
+  {
+    ieee_copy_special_string_re(ieee_double_special_string(ieee_number), p, _p, r, e);
+    return (char *)number_buffer;
+  }
+  ieee_double_exp10(ieee_number, exponent10);
+  ieee_double_decimal_dot(ieee_number, exponent10, digits, p, r);
+  ieee_double_round(ieee_number, exponent10, s, p);
+  if (e != NULL) *e = p;
+  *p = '\0';
+  return s;
+}
+
+/* float to decimal */
+
+char * float_to_string (float number, int digits)
+{
+  ieee_float ieee_number;
+  int exponent10;
+  char *s, *p; const char *_p;
+  ieee_float_init(ieee_number, number);
+  ieee_float_sign(ieee_number);
+  if (ieee_float_is_zero(ieee_number))
+  {
+    ieee_copy_special_string(ieee_float_zero_string(ieee_number), p, _p);
+    return (char *)number_buffer;
+  }
+  if (ieee_float_special_case(ieee_number))
+  {
+    ieee_copy_special_string(ieee_float_special_string(ieee_number), p, _p);
+    return (char *)number_buffer;
+  }
+  s = p = number_buffer + 1;
+  ieee_float_exp10(ieee_number, exponent10);
+  ieee_float_decimal(ieee_number, exponent10, digits, p);
+  ieee_float_round(ieee_number, exponent10, s, p);
+  *p = '\0';
+  return s;
+}
+
+char * float_as_string (float number, int digits, char **r, char **e)
+{
+  ieee_float ieee_number;
+  int exponent10;
+  char *s, *p; const char *_p;
+  s = p = number_buffer + 1;
+  ieee_float_init(ieee_number, number);
+  ieee_float_sign(ieee_number);
+  if (ieee_float_is_zero(ieee_number))
+  {
+    ieee_copy_special_string_re(ieee_float_zero_string(ieee_number), p, _p, r, e);
+    return (char *)number_buffer;
+  }
+  if (ieee_float_special_case(ieee_number))
+  {
+    ieee_copy_special_string_re(ieee_float_special_string(ieee_number), p, _p, r, e);
+    return (char *)number_buffer;
+  }
+  ieee_float_exp10(ieee_number, exponent10);
+  ieee_float_decimal_dot(ieee_number, exponent10, digits, p, r);
+  ieee_float_round(ieee_number, exponent10, s, p);
+  if (e != NULL) *e = p;
+  *p = '\0';
+  return s;
+}
+
+/* decimal string to double/float */
+
+#define string_scan_decimal(s, c, number) _scan_decimal(c, number, *++s)
+#define string_scan_fraction(s, c, number, exponent10) _scan_fraction(c, number, exponent10, *++s)
+#define string_scan_exponent10(s, c, exponent10) _scan_exponent10(c, exponent10, *++s)
+
+const char * string_to_double (const char *s, double *number)
+{
+  int sign, exponent10, c = *s;
+  string_scan_sign(s, c, sign);
+  string_scan_decimal(s, c, *number);
+  if (c == '.')
+  {
+    c = *++s;
+    string_scan_fraction(s, c, *number, exponent10);
+  }
+  else
+    exponent10 = 0;
+  if (c == 'e' || c == 'E')
+  {
+    c = *++s;
+    string_scan_exponent10(s, c, exponent10);
+  }
+  double_exp10(*number, exponent10);
+  if (sign) *number = -*number;
+  return s;
+}
+
+const char * string_to_float (const char *s, float *number)
+{
+  int sign, exponent10, c = *s;
+  string_scan_sign(s, c, sign);
+  string_scan_decimal(s, c, *number);
+  if (c == '.')
+  {
+    c = *++s;
+    string_scan_fraction(s, c, *number, exponent10);
+  }
+  else
+    exponent10 = 0;
+  if (c == 'e' || c == 'E')
+  {
+    c = *++s;
+    string_scan_exponent10(s, c, exponent10);
+  }
+  float_exp10(*number, exponent10);
+  if (sign) *number = -*number;
+  return s;
+}
+
+/* conventional form */
+
+const char * convert_to_double (const char *s, double *number)
+{
+  int sign, c = *s;
+  string_scan_sign(s, c, sign);
+  string_scan_decimal(s, c, *number);
+  if (c == '.' || c == ',')
+  {
+    int exponent10;
+    c = *++s;
+    string_scan_fraction(s, c, *number, exponent10);
+    if (exponent10 < 0)
+      double_negative_exp10(*number, exponent10);
+  }
+  if (sign) *number = -*number;
+  return s;
+}
+
+const char * convert_to_float (const char *s, float *number)
+{
+  int sign, c = *s;
+  string_scan_sign(s, c, sign);
+  string_scan_decimal(s, c, *number);
+  if (c == '.' || c == ',')
+  {
+    int exponent10;
+    c = *++s;
+    string_scan_fraction(s, c, *number, exponent10);
+    if (exponent10 < 0)
+      float_negative_exp10(*number, exponent10);
+  }
+  if (sign) *number = -*number;
+  return s;
+}
+
+/* pretty common stuff */
+
+size_t bytes_to_hex_lc (const void *input, size_t size, unsigned char *output)
+{
+  size_t i;
+  const unsigned char *p;
+  for (i = 0, p = (const unsigned char *)input; i < size; ++i, ++p)
+  {
+    *output++ = base16_lc_digit1(*p);
+    *output++ = base16_lc_digit2(*p);
+  }
+  *output = '\0';
+  return 2*size + 1;
+}
+
+size_t bytes_to_hex_uc (const void *input, size_t size, unsigned char *output)
+{
+  size_t i;
+  const unsigned char *p;
+  for (i = 0, p = (const unsigned char *)input; i < size; ++i, ++p)           
+  {
+    *output++ = base16_uc_digit1(*p);
+    *output++ = base16_uc_digit2(*p);
+  }
+  *output = '\0';
+  return 2*size + 1;
+}
+
+size_t hex_to_bytes (const void *input, size_t size, unsigned char *output)
+{
+  size_t i;
+  int c1, c2;
+  const unsigned char *p;
+  for (i = 1, p = (const unsigned char *)input; i < size; i += 2)
+  {
+    c1 = base16_value(*p);
+    ++p;
+    c2 = base16_value(*p);
+    ++p;
+    if (c1 >= 0 && c2 >= 0)
+      *output++ = (unsigned char)((c1<<4)|c2);
+    else
+      break;
+  }
+  return i >> 1;
+}
+
+void print_as_hex (const void *input, size_t bytes)
+{
+  const unsigned char *p;
+  for (p = (const unsigned char *)input; bytes > 0; --bytes, ++p)
+    printf("%02x", *p);
+}
\ No newline at end of file
diff --git a/texk/web2c/luatexdir/luapplib/util/utilnumber.h b/texk/web2c/luatexdir/luapplib/util/utilnumber.h
new file mode 100644
index 000000000..3c96571b5
--- /dev/null
+++ b/texk/web2c/luatexdir/luapplib/util/utilnumber.h
@@ -0,0 +1,354 @@
+#ifndef UTIL_NUMBER_H
+#define UTIL_NUMBER_H
+
+#include <stddef.h> // for size_t
+
+#include "utilplat.h"
+#include "utildecl.h"
+
+/* since 'long' isn't long for msvc64/mingw64, we need a type for machine word */
+
+#if !defined(__cplusplus) || !defined(_MSC_VER)
+#  include <stdint.h> // int*_t types are in standard in msvc++
+#endif
+
+//#if defined(MSVC64) || defined(__MINGW64__) || defined(__x86_64__) || UINTPTR_MAX > 0xffffffff
+//#  define BIT64
+//#else
+//#  define BIT64
+//#endif
+
+#if defined(_WIN64) || defined(__MINGW32__)
+#  define INT64F "%I64d"
+#  define UINT64F "%I64u"
+#else
+#  define INT64F "%lld"
+#  define UINT64F "%llu"
+#endif
+
+#if defined(MSVC64)
+#  define intlw_t int64_t
+#  define uintlw_t uint64_t
+#  define INTLW(N) N##I64
+#  define UINTLW(N) N##UI64
+#  define INTLWF INT64F
+#  define UINTLWF UINT64F
+#elif defined(__MINGW64__)
+#  define intlw_t int64_t
+#  define uintlw_t uint64_t
+#  define INTLW(N) N##LL
+#  define UINTLW(N) N##ULL
+#  define INTLWF INT64F
+#  define UINTLWF UINT64F
+#else // 32bit or sane 64bit (LP64)
+#  define intlw_t long
+#  define uintlw_t size_t /*unsigned long*/
+#  define INTLW(N) N##L
+#  define UINTLW(N) N##UL
+#  define INTLWF "%ld"
+#  define UINTLWF "%lu"
+#endif
+
+/* basic constants */
+
+#define MAX_RADIX 36
+// #define MAX_INTEGER_DIGITS 65 /* 64-bit number in binary form plus '\0' */
+#define MAX_INTEGER_DIGITS 128 // to handle romannumeral of short int
+
+#define base36_uc_alphabet "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+#define base36_lc_alphabet "0123456789abcdefghijklmnopqrstuvwxyz"
+
+#define base26_uc_alphabet "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+#define base26_lc_alphabet "abcdefghijklmnopqrstuvwxyz"
+extern const int base26_lookup[];
+
+#define base36_lc_palindrome "zyxwvutsrqponmlkjihgfedcba9876543210123456789abcdefghijklmnopqrstuvwxyz"
+#define base36_uc_palindrome "ZYXWVUTSRQPONMLKJIHGFEDCBA9876543210123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+
+extern const int base36_lookup[];
+
+#define base10_palindrome "9876543210123456789"
+#define base10_alphabet "0123456789"
+extern const int base10_lookup[];
+
+#define base16_uc_alphabet "0123456789ABCDEF"
+#define base16_lc_alphabet "0123456789abcdef"
+extern const int base16_lookup[];
+
+#define base16_uc_digit1(c) base16_uc_alphabet[(c)>>4]
+#define base16_uc_digit2(c) base16_uc_alphabet[(c)&15]
+#define base16_lc_digit1(c) base16_lc_alphabet[(c)>>4]
+#define base16_lc_digit2(c) base16_lc_alphabet[(c)&15]
+
+#define base8_digit(c)  ((unsigned)(c - '0') <= (unsigned)('7' - '0'))
+#define base8_value(c)  (base8_digit(c) ? (c) - '0' : -1)
+
+#define base10_digit(c) ((unsigned)(c - '0') <= (unsigned)('9' - '0'))
+#define base10_value(c) (base10_lookup[(uint8_t)c])              
+
+#define base16_digit(c) (base16_lookup[(uint8_t)c] >= 0)
+#define base16_value(c) (base16_lookup[(uint8_t)c])
+
+#define base26_digit(c) (base26_lookup[(uint8_t)c] >= 0)
+#define base26_value(c) (base26_lookup[(uint8_t)c])
+
+#define base36_digit(c) (base36_lookup[(uint8_t)c] >= 0)
+#define base36_value(c) (base36_lookup[(uint8_t)c])
+
+//#define base_digit(c, radix) ((unsigned)(base36_lookup[c]) < (unsigned)(radix))
+//#define base_value(c, radix) (base_digit(c, radix) ? base36_lookup[c] : -1)
+
+/* integer from string; return a pointer to character next to the last digit */
+
+UTILAPI const char * string_to_int32 (const char *s, int32_t *number);
+UTILAPI const char * string_to_intlw (const char *s, intlw_t *number);
+UTILAPI const char * string_to_int64 (const char *s, int64_t *number);
+
+UTILAPI const char * string_to_uint32 (const char *s, uint32_t *number);
+UTILAPI const char * string_to_uintlw (const char *s, uintlw_t *number);
+UTILAPI const char * string_to_uint64 (const char *s, uint64_t *number);
+
+UTILAPI const char * radix_to_int32 (const char *s, int32_t *number, int radix);
+UTILAPI const char * radix_to_intlw (const char *s, intlw_t *number, int radix);
+UTILAPI const char * radix_to_int64 (const char *s, int64_t *number, int radix);
+
+UTILAPI const char * radix_to_uint32 (const char *s, uint32_t *number, int radix);
+UTILAPI const char * radix_to_uintlw (const char *s, uintlw_t *number, int radix);
+UTILAPI const char * radix_to_uint64 (const char *s, uint64_t *number, int radix);
+
+UTILAPI const char * roman_to_uint16 (const char *s, uint16_t *number);
+
+UTILAPI const char * alpha_to_uint32 (const char *s, uint32_t *number);
+UTILAPI const char * alpha_to_uintlw (const char *s, uintlw_t *number);
+UTILAPI const char * alpha_to_uint64 (const char *s, uint64_t *number);
+
+UTILAPI const char * alphan_to_uint32 (const char *s, uint32_t *number);
+UTILAPI const char * alphan_to_uintlw (const char *s, uintlw_t *number);
+UTILAPI const char * alphan_to_uint64 (const char *s, uintlw_t *number);
+
+/*
+integer to string; return a pointer to null-terminated static const string
+same but also stores pointer to trailing null (to be used for firther formatting)
+*/
+
+UTILAPI char * int32_as_string (int32_t number, char **e);
+UTILAPI char * intlw_as_string (intlw_t number, char **e);
+UTILAPI char * int64_as_string (int64_t number, char **e);
+
+UTILAPI char * uint32_as_string (uint32_t number, char **e);
+UTILAPI char * uintlw_as_string (uintlw_t number, char **e);
+UTILAPI char * uint64_as_string (uint64_t number, char **e);
+
+#define int32_to_string(number) int32_as_string(number, NULL)
+#define intlw_to_string(number) intlw_as_string(number, NULL)
+#define int64_to_string(number) int64_as_string(number, NULL)
+
+#define uint32_to_string(number) uint32_as_string(number, NULL)
+#define uintlw_to_string(number) uintlw_as_string(number, NULL)
+#define uint64_to_string(number) uint64_as_string(number, NULL)
+
+UTILAPI char * int32_as_radix (int32_t number, int radix, char **e);
+UTILAPI char * intlw_as_radix (intlw_t number, int radix, char **e);
+UTILAPI char * int64_as_radix (int64_t number, int radix, char **e);
+
+UTILAPI char * uint32_as_radix (uint32_t number, int radix, char **e);
+UTILAPI char * uintlw_as_radix (uintlw_t number, int radix, char **e);
+UTILAPI char * uint64_as_radix (uint64_t number, int radix, char **e);
+
+#define int32_to_radix(number, radix) int32_as_radix(number, radix, NULL)
+#define intlw_to_radix(number, radix) intlw_as_radix(number, radix, NULL)
+#define int64_to_radix(number, radix) int64_as_radix(number, radix, NULL)
+
+#define uint32_to_radix(number, radix) uint32_as_radix(number, radix, NULL)
+#define uintlw_to_radix(number, radix) uintlw_as_radix(number, radix, NULL)
+#define uint64_to_radix(number, radix) uint64_as_radix(number, radix, NULL)
+
+UTILAPI char * uint32_as_alpha_uc (uint32_t number, char **e);
+UTILAPI char * uint32_as_alpha_lc (uint32_t number, char **e);
+UTILAPI char * uintlw_as_alpha_uc (uintlw_t number, char **e);
+UTILAPI char * uintlw_as_alpha_lc (uintlw_t number, char **e);
+UTILAPI char * uint64_as_alpha_uc (uint64_t number, char **e);
+UTILAPI char * uint64_as_alpha_lc (uint64_t number, char **e);
+
+#define uint32_to_alpha_uc(number) uint32_as_alpha_uc(number, NULL)
+#define uint32_to_alpha_lc(number) uint32_as_alpha_lc(number, NULL)
+#define uintlw_to_alpha_uc(number) uintlw_as_alpha_uc(number, NULL)
+#define uintlw_to_alpha_lc(number) uintlw_as_alpha_lc(number, NULL)
+#define uint64_to_alpha_uc(number) uint64_as_alpha_uc(number, NULL)
+#define uint64_to_alpha_lc(number) uint64_as_alpha_lc(number, NULL)
+
+UTILAPI char * uint32_as_alphan_uc (uint32_t number, char **e);
+UTILAPI char * uint32_as_alphan_lc (uint32_t number, char **e);
+UTILAPI char * uintlw_as_alphan_uc (uintlw_t number, char **e);
+UTILAPI char * uintlw_as_alphan_lc (uintlw_t number, char **e);
+UTILAPI char * uint64_as_alphan_uc (uint64_t number, char **e);
+UTILAPI char * uint64_as_alphan_lc (uint64_t number, char **e);
+
+#define uint32_to_alphan_uc(number) uint32_as_alpha_uc(number, NULL)
+#define uint32_to_alphan_lc(number) uint32_as_alpha_lc(number, NULL)
+#define uintlw_to_alphan_uc(number) uintlw_as_alpha_uc(number, NULL)
+#define uintlw_to_alphan_lc(number) uintlw_as_alpha_lc(number, NULL)
+#define uint64_to_alphan_uc(number) uint64_as_alpha_uc(number, NULL)
+#define uint64_to_alphan_lc(number) uint64_as_alpha_lc(number, NULL)
+
+/* roman numeral (limited to uint16_t) */
+
+UTILAPI char * uint16_as_roman_uc (uint16_t number, char **e);
+UTILAPI char * uint16_as_roman_lc (uint16_t number, char **e);
+
+#define uint16_to_roman_uc(number) uint16_as_roman_uc(number, NULL)
+#define uint16_to_roman_lc(number) uint16_as_roman_lc(number, NULL)
+
+#define uint16_as_roman(number) uint16_as_roman_uc(number)
+#define uint16_to_roman(number) uint16_to_roman_uc(number)
+
+/* double/float  to string */
+
+UTILAPI char * double_to_string (double number, int digits);
+UTILAPI char * float_to_string (float number, int digits);
+
+UTILAPI char * double_as_string (double number, int digits, char **r, char **e);
+UTILAPI char * float_as_string (float number, int digits, char **r, char **e);
+
+/* string to double/float */
+
+UTILAPI const char * string_to_double (const char *s, double *number);
+UTILAPI const char * string_to_float  (const char *s, float *number);
+
+/* convenience form accepting comma among a dot, with not exp notation (eg. pdf) */
+
+UTILAPI const char * convert_to_double (const char *s, double *number);
+UTILAPI const char * convert_to_float  (const char *s, float *number);
+
+/* binary data parsers helpers */
+
+#define get_byte1(i) ((i)&255)
+#define get_byte2(i) (((i)>>8)&255)
+#define get_byte3(i) (((i)>>16)&255)
+#define get_byte4(i) (((i)>>24)&255)
+
+#define read_uint16be_as(s, int_type) ((int_type)((s[0]<<8)|s[1]))
+#define read_uint32be_as(s, int_type) ((int_type)((s[0]<<24)|(s[1]<<16)|(s[2]<<8)|s[3]))
+
+#define read_uint16le_as(s, int_type) ((int_type)((s[1]<<8)|s[0]))
+#define read_uint32le_as(s, int_type) ((int_type)((s[3]<<24)|(s[2]<<16)|(s[1]<<8)|s[0]))
+
+#define read_uint16_native(s) (*((uint16_t *)(s)))
+#define read_uint32_native(s) (*((uint32_t *)(s)))
+#define read_int16_native(s)  (*((int16_t *)(s)))
+#define read_int32_native(s)  (*((int32_t *)(s)))
+
+#define scan_uint16be_as(s, int_type) (s += 2, (int_type)((s[-2]<<8)|s[-1]))
+#define scan_uint32be_as(s, int_type) (s += 4, (int_type)((s[-4]<<24)|(s[-3]<<16)|(s[-2]<<8)|s[-1]))
+
+#define scan_uint16le_as(s, int_type) (s += 2, (int_type)((s[-1]<<8)|s[-2]))
+#define scan_uint32le_as(s, int_type) (s += 4, (int_type)((s[-1]<<24)|(s[-2]<<16)|(s[-3]<<8)|s[-4]))
+
+#define scan_uint16_native(s) (s += 2, read_uint16_native(s-2))
+#define scan_uint32_native(s) (s += 4, read_uint32_native(s-4))
+#define scan_int16_native(s)  (s += 2, read_int16_native(s-2))
+#define scan_int32_native(s)  (s += 4, read_int32_native(s-4))
+
+#define read_fixed16_16_as(s, float_type)  (((float_type)read_uint32be_as(s, signed int))/(1<<16))
+#define read_fixed2_14_as(s, float_type)  (((float_type)read_uint16be_as(s, signed short))/(1<<14))
+
+#define scan_fixed16_16_as(s, float_type) (((float_type)scan_uint32be_as(s, signed int))/(1<<16))
+#define scan_fixed2_14_as(s, float_type) (((float_type)scan_uint16be_as(s, signed short))/(1<<14))
+
+/* internal procedures */
+
+#define _scan_sign(c, sign, next) \
+  do { if (c == '-') { sign = 1; c = next; } else if (c == '+') { sign = 0; c = next; } else sign = 0; } while (0)
+
+#define integer_multiplied10(number) (((number) << 1) + ((number) << 3))
+
+#define _scan_integer(c, number, next) \
+  for (number = 0; base10_digit(c); number = integer_multiplied10(number) + (c - '0'), c = next)
+#define _scan_radix(c, number, radix, next) \
+  for (number = 0; (c = base36_value(c)) >= 0 && c < radix; number = number * radix + c, c = next)
+
+#define _read_integer(c, number, next) \
+  for (number = c - '0', c = next; base10_digit(c); number = integer_multiplied10(number) + (c - '0'), c = next)
+#define _read_radix(c, number, radix, next) \
+  for (number = c - '0', c = next; (c = base36_value(c)) >= 0 && c < radix; number = number * radix + c, c = next)
+
+/* rationals */
+
+#define _scan_decimal(c, number, next) \
+  for (number = 0; base10_digit(c); number = number*10 + (c - '0'), c = next)
+#define _scan_fraction(c, number, exponent10, next) \
+  for (exponent10 = 0; base10_digit(c); --exponent10, number = number*10 + (c - '0'), c = next)
+
+#define _scan_exponent10(c, exponent10, next) \
+  do { \
+    int eexponent10, eexpsign; \
+    _scan_sign(c, eexpsign, next); \
+    _scan_integer(c, eexponent10, next); \
+    if (eexpsign) \
+      exponent10 -= eexponent10; \
+    else \
+      exponent10 += eexponent10; \
+  } while(0)
+
+#if 0
+
+// kept just for sentiment ;)
+
+extern const double double_binary_power10[];
+extern const float float_binary_power10[];
+extern const double double_binary_negpower10[];
+extern const float float_binary_negpower10[];
+
+#define double_negative_exp10(number, exponent) \
+{ const double *bp10; int e = ((exponent) < 511 ? 511 : -(exponent)); \
+  for (bp10 = double_binary_negpower10; e > 0; e >>= 1, ++bp10) \
+    if (e & 1) number *= *bp10; }
+
+#define float_negative_exp10(number, exponent) \
+{ const float *bp10; int e = ((exponent) < 64 ? 64 : -(exponent)); \
+  for (bp10 = float_binary_negpower10; e > 0; e >>= 1, ++bp10) \
+    if (e & 1) number *= *bp10; }
+
+#define double_positive_exp10(number, exponent) \
+{ const double *bp10; int e = ((exponent) > 511 ? 511 : (exponent)); \
+  for (bp10 = double_binary_power10; e > 0; e >>= 1, ++bp10) \
+    if (e & 1) number *= *bp10; }
+
+#define float_positive_exp10(number, exponent) \
+{ const float *bp10; int e = ((exponent) > 64 ? 64 : (exponent)); \
+  for (bp10 = double_binary_power10; e > 0; e >>= 1, ++bp10) \
+    if (e & 1) number *= *bp10; }
+
+#define double_exp10(number, exponent) \
+  if ((exponent) < 0) double_negative_exp10(number, exponent) else if ((exponent) > 0) double_positive_exp10(number, exponent)
+
+#define float_exp10(number, exponent) \
+  if ((exponent) < 0) float_negative_exp10(number, exponent) else if ((exponent) > 0) float_positive_exp10(number, exponent)
+
+#else
+
+extern const double double_decimal_power10[];
+extern const float float_decimal_power10[];
+extern const double double_decimal_negpower10[];
+extern const float float_decimal_negpower10[];
+
+#define double_negative_exp10(number, exponent) ((number) *= double_decimal_negpower10[(exponent) < -308 ? 308 : -(exponent)])
+#define double_positive_exp10(number, exponent) ((number) *= double_decimal_power10[(exponent) > 308 ? 308 : (exponent)])
+
+#define float_negative_exp10(number, exponent) ((number) *= float_decimal_negpower10[(exponent) < -38 ? 38 : -(exponent)])
+#define float_positive_exp10(number, exponent) ((number) *= float_decimal_power10[(exponent) > 38 ? 38 : (exponent)])
+
+#define double_exp10(number, exponent) ((void)(((exponent) < 0 && double_negative_exp10(number, exponent)) || (((exponent) > 0 && double_positive_exp10(number, exponent)))))
+#define float_exp10(number, exponent) ((void)(((exponent) < 0 && float_negative_exp10(number, exponent)) || (((exponent) > 0 && float_positive_exp10(number, exponent)))))
+
+#endif
+
+/* pretty common stuff */
+
+#define bytes_to_hex(input, size, output) bytes_to_hex_lc(input, size, output)
+UTILAPI size_t bytes_to_hex_lc (const void *input, size_t size, uint8_t *output);
+UTILAPI size_t bytes_to_hex_uc (const void *input, size_t size, uint8_t *output);
+UTILAPI size_t hex_to_bytes (const void *input, size_t size, uint8_t *output);
+UTILAPI void print_as_hex (const void *input, size_t bytes);
+
+#endif
\ No newline at end of file
diff --git a/texk/web2c/luatexdir/luapplib/util/utilplat.h b/texk/web2c/luatexdir/luapplib/util/utilplat.h
new file mode 100644
index 000000000..037a1e231
--- /dev/null
+++ b/texk/web2c/luatexdir/luapplib/util/utilplat.h
@@ -0,0 +1,23 @@
+
+#ifndef UTIL_PLAT_H
+#define UTIL_PLAT_H
+
+#if defined(_WIN32) || defined(WIN32)
+#  ifdef _MSC_VER
+#    if defined(_M_64) || defined(_WIN64)
+#      define MSVC64
+#    else
+#      define MSVC32
+#    endif
+#  else
+#    if defined(__MINGW64__)
+#      define MINGW64
+#    else
+#      if defined(__MINGW32__)
+#        define MINGW32
+#      endif
+#    endif
+#  endif
+#endif
+
+#endif
\ No newline at end of file
diff --git a/texk/web2c/luatexdir/luapplib/util/utilsha.c b/texk/web2c/luatexdir/luapplib/util/utilsha.c
new file mode 100644
index 000000000..665320730
--- /dev/null
+++ b/texk/web2c/luatexdir/luapplib/util/utilsha.c
@@ -0,0 +1,1290 @@
+/* sha2 implementation by Aaron D. Gifford (http://www.aarongifford.com) */
+
+#if defined __arm__ || defined __ARM__ || defined ARM || defined __ARM || defined __arm || defined __ARM_ARCH ||defined __aarch64__ 
+#include <stdlib.h>
+#endif
+
+#ifndef BYTE_ORDER
+#define BYTE_ORDER LITTLE_ENDIAN
+#endif
+/* begin of sha2.c */
+
+/*
+ * FILE:	sha2.c
+ * AUTHOR:	Aaron D. Gifford - http://www.aarongifford.com/
+ *
+ * Copyright (c) 2000-2001, Aaron D. Gifford
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the copyright holder nor the names of contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTOR(S) ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTOR(S) BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * $Id: sha2.c,v 1.1 2001/11/08 00:01:51 adg Exp adg $
+ */
+
+#include <string.h>	/* memcpy()/memset() or bcopy()/bzero() */
+#if defined __arm__ || defined __ARM__ || defined ARM || defined __ARM || defined __arm || defined __ARM_ARCH ||defined __aarch64__ 
+#include <stdlib.h>
+#endif
+#include <assert.h>	/* assert() */
+//#include "sha2.h"
+#include "utilsha.h"
+
+/*
+ * ASSERT NOTE:
+ * Some sanity checking code is included using assert().  On my FreeBSD
+ * system, this additional code can be removed by compiling with NDEBUG
+ * defined.  Check your own systems manpage on assert() to see how to
+ * compile WITHOUT the sanity checking code on your system.
+ *
+ * UNROLLED TRANSFORM LOOP NOTE:
+ * You can define SHA2_UNROLL_TRANSFORM to use the unrolled transform
+ * loop version for the hash transform rounds (defined using macros
+ * later in this file).  Either define on the command line, for example:
+ *
+ *   cc -DSHA2_UNROLL_TRANSFORM -o sha2 sha2.c sha2prog.c
+ *
+ * or define below:
+ *
+ *   #define SHA2_UNROLL_TRANSFORM
+ *
+ */
+
+
+/*** SHA-256/384/512 Machine Architecture Definitions *****************/
+/*
+ * BYTE_ORDER NOTE:
+ *
+ * Please make sure that your system defines BYTE_ORDER.  If your
+ * architecture is little-endian, make sure it also defines
+ * LITTLE_ENDIAN and that the two (BYTE_ORDER and LITTLE_ENDIAN) are
+ * equivilent.
+ *
+ * If your system does not define the above, then you can do so by
+ * hand like this:
+ *
+ *   #define LITTLE_ENDIAN 1234
+ *   #define BIG_ENDIAN    4321
+ *
+ * And for little-endian machines, add:
+ *
+ *   #define BYTE_ORDER LITTLE_ENDIAN
+ *
+ * Or for big-endian machines:
+ *
+ *   #define BYTE_ORDER BIG_ENDIAN
+ *
+ * The FreeBSD machine this was written on defines BYTE_ORDER
+ * appropriately by including <sys/types.h> (which in turn includes
+ * <machine/endian.h> where the appropriate definitions are actually
+ * made).
+ */
+#if !defined(BYTE_ORDER) || (BYTE_ORDER != LITTLE_ENDIAN && BYTE_ORDER != BIG_ENDIAN)
+#error Define BYTE_ORDER to be equal to either LITTLE_ENDIAN or BIG_ENDIAN
+#endif
+
+/*
+ * Define the followingsha2_* types to types of the correct length on
+ * the native archtecture.   Most BSD systems and Linux define u_intXX_t
+ * types.  Machines with very recent ANSI C headers, can use the
+ * uintXX_t definintions from inttypes.h by defining SHA2_USE_INTTYPES_H
+ * during compile or in the sha.h header file.
+ *
+ * Machines that support neither u_intXX_t nor inttypes.h's uintXX_t
+ * will need to define these three typedefs below (and the appropriate
+ * ones in sha.h too) by hand according to their system architecture.
+ *
+ * Thank you, Jun-ichiro itojun Hagino, for suggesting using u_intXX_t
+ * types and pointing out recent ANSI C support for uintXX_t in inttypes.h.
+ *
+ * PJ: replace by uintX_t
+ */
+
+//typedef uint8_t  sha2_byte;	/* Exactly 1 byte */
+//typedef uint32_t sha2_word32;	/* Exactly 4 bytes */
+//typedef uint64_t sha2_word64;	/* Exactly 8 bytes */
+
+/*** SHA-256/384/512 Various Length Definitions ***********************/
+/* NOTE: Most of these are in sha2.h */
+#define SHA256_SHORT_BLOCK_LENGTH	(SHA256_BLOCK_LENGTH - 8)
+#define SHA384_SHORT_BLOCK_LENGTH	(SHA384_BLOCK_LENGTH - 16)
+#define SHA512_SHORT_BLOCK_LENGTH	(SHA512_BLOCK_LENGTH - 16)
+
+
+/*** ENDIAN REVERSAL MACROS *******************************************/
+#if BYTE_ORDER == LITTLE_ENDIAN
+#define REVERSE32(w,x)	{ \
+	uint32_t tmp = (w); \
+	tmp = (tmp >> 16) | (tmp << 16); \
+	(x) = ((tmp & 0xff00ff00UL) >> 8) | ((tmp & 0x00ff00ffUL) << 8); \
+}
+#define REVERSE64(w,x)	{ \
+	uint64_t tmp = (w); \
+	tmp = (tmp >> 32) | (tmp << 32); \
+	tmp = ((tmp & 0xff00ff00ff00ff00ULL) >> 8) | \
+	      ((tmp & 0x00ff00ff00ff00ffULL) << 8); \
+	(x) = ((tmp & 0xffff0000ffff0000ULL) >> 16) | \
+	      ((tmp & 0x0000ffff0000ffffULL) << 16); \
+}
+#endif /* BYTE_ORDER == LITTLE_ENDIAN */
+
+/*
+ * Macro for incrementally adding the unsigned 64-bit integer n to the
+ * unsigned 128-bit integer (represented using a two-element array of
+ * 64-bit words):
+ */
+#define ADDINC128(w,n)	{ \
+	(w)[0] += (uint64_t)(n); \
+	if ((w)[0] < (n)) { \
+		(w)[1]++; \
+	} \
+}
+
+/*
+ * Macros for copying blocks of memory and for zeroing out ranges
+ * of memory.  Using these macros makes it easy to switch from
+ * using memset()/memcpy() and using bzero()/bcopy().
+ *
+ * Please define either SHA2_USE_MEMSET_MEMCPY or define
+ * SHA2_USE_BZERO_BCOPY depending on which function set you
+ * choose to use:
+ */
+#if !defined(SHA2_USE_MEMSET_MEMCPY) && !defined(SHA2_USE_BZERO_BCOPY)
+/* Default to memset()/memcpy() if no option is specified */
+#define	SHA2_USE_MEMSET_MEMCPY	1
+#endif
+#if defined(SHA2_USE_MEMSET_MEMCPY) && defined(SHA2_USE_BZERO_BCOPY)
+/* Abort with an error if BOTH options are defined */
+#error Define either SHA2_USE_MEMSET_MEMCPY or SHA2_USE_BZERO_BCOPY, not both!
+#endif
+
+#ifdef SHA2_USE_MEMSET_MEMCPY
+#define MEMSET_BZERO(p,l)	memset((p), 0, (l))
+#define MEMCPY_BCOPY(d,s,l)	memcpy((d), (s), (l))
+#endif
+#ifdef SHA2_USE_BZERO_BCOPY
+#define MEMSET_BZERO(p,l)	bzero((p), (l))
+#define MEMCPY_BCOPY(d,s,l)	bcopy((s), (d), (l))
+#endif
+
+
+/*** THE SIX LOGICAL FUNCTIONS ****************************************/
+/*
+ * Bit shifting and rotation (used by the six SHA-XYZ logical functions:
+ *
+ *   NOTE:  The naming of R and S appears backwards here (R is a SHIFT and
+ *   S is a ROTATION) because the SHA-256/384/512 description document
+ *   (see http://csrc.nist.gov/cryptval/shs/sha256-384-512.pdf) uses this
+ *   same "backwards" definition.
+ */
+/* Shift-right (used in SHA-256, SHA-384, and SHA-512): */
+#define R(b,x) 		((x) >> (b))
+/* 32-bit Rotate-right (used in SHA-256): */
+#define S32(b,x)	(((x) >> (b)) | ((x) << (32 - (b))))
+/* 64-bit Rotate-right (used in SHA-384 and SHA-512): */
+#define S64(b,x)	(((x) >> (b)) | ((x) << (64 - (b))))
+
+/* Two of six logical functions used in SHA-256, SHA-384, and SHA-512: */
+#define Ch(x,y,z)	(((x) & (y)) ^ ((~(x)) & (z)))
+#define Maj(x,y,z)	(((x) & (y)) ^ ((x) & (z)) ^ ((y) & (z)))
+
+/* Four of six logical functions used in SHA-256: */
+#define Sigma0_256(x)	(S32(2,  (x)) ^ S32(13, (x)) ^ S32(22, (x)))
+#define Sigma1_256(x)	(S32(6,  (x)) ^ S32(11, (x)) ^ S32(25, (x)))
+#define sigma0_256(x)	(S32(7,  (x)) ^ S32(18, (x)) ^ R(3 ,   (x)))
+#define sigma1_256(x)	(S32(17, (x)) ^ S32(19, (x)) ^ R(10,   (x)))
+
+/* Four of six logical functions used in SHA-384 and SHA-512: */
+#define Sigma0_512(x)	(S64(28, (x)) ^ S64(34, (x)) ^ S64(39, (x)))
+#define Sigma1_512(x)	(S64(14, (x)) ^ S64(18, (x)) ^ S64(41, (x)))
+#define sigma0_512(x)	(S64( 1, (x)) ^ S64( 8, (x)) ^ R( 7,   (x)))
+#define sigma1_512(x)	(S64(19, (x)) ^ S64(61, (x)) ^ R( 6,   (x)))
+
+/*** INTERNAL FUNCTION PROTOTYPES *************************************/
+/* NOTE: These should not be accessed directly from outside this
+ * library -- they are intended for private internal visibility/use
+ * only.
+ */
+static void SHA512_Last(SHA512_CTX*);
+static void SHA256_Transform(SHA256_CTX*, const uint32_t*);
+static void SHA512_Transform(SHA512_CTX*, const uint64_t*);
+
+
+/*** SHA-XYZ INITIAL HASH VALUES AND CONSTANTS ************************/
+/* Hash constant words K for SHA-256: */
+static const uint32_t K256[64] = {
+	0x428a2f98UL, 0x71374491UL, 0xb5c0fbcfUL, 0xe9b5dba5UL,
+	0x3956c25bUL, 0x59f111f1UL, 0x923f82a4UL, 0xab1c5ed5UL,
+	0xd807aa98UL, 0x12835b01UL, 0x243185beUL, 0x550c7dc3UL,
+	0x72be5d74UL, 0x80deb1feUL, 0x9bdc06a7UL, 0xc19bf174UL,
+	0xe49b69c1UL, 0xefbe4786UL, 0x0fc19dc6UL, 0x240ca1ccUL,
+	0x2de92c6fUL, 0x4a7484aaUL, 0x5cb0a9dcUL, 0x76f988daUL,
+	0x983e5152UL, 0xa831c66dUL, 0xb00327c8UL, 0xbf597fc7UL,
+	0xc6e00bf3UL, 0xd5a79147UL, 0x06ca6351UL, 0x14292967UL,
+	0x27b70a85UL, 0x2e1b2138UL, 0x4d2c6dfcUL, 0x53380d13UL,
+	0x650a7354UL, 0x766a0abbUL, 0x81c2c92eUL, 0x92722c85UL,
+	0xa2bfe8a1UL, 0xa81a664bUL, 0xc24b8b70UL, 0xc76c51a3UL,
+	0xd192e819UL, 0xd6990624UL, 0xf40e3585UL, 0x106aa070UL,
+	0x19a4c116UL, 0x1e376c08UL, 0x2748774cUL, 0x34b0bcb5UL,
+	0x391c0cb3UL, 0x4ed8aa4aUL, 0x5b9cca4fUL, 0x682e6ff3UL,
+	0x748f82eeUL, 0x78a5636fUL, 0x84c87814UL, 0x8cc70208UL,
+	0x90befffaUL, 0xa4506cebUL, 0xbef9a3f7UL, 0xc67178f2UL
+};
+
+/* Initial hash value H for SHA-256: */
+static const uint32_t sha256_initial_hash_value[8] = {
+	0x6a09e667UL,
+	0xbb67ae85UL,
+	0x3c6ef372UL,
+	0xa54ff53aUL,
+	0x510e527fUL,
+	0x9b05688cUL,
+	0x1f83d9abUL,
+	0x5be0cd19UL
+};
+
+/* Hash constant words K for SHA-384 and SHA-512: */
+static const uint64_t K512[80] = {
+	0x428a2f98d728ae22ULL, 0x7137449123ef65cdULL,
+	0xb5c0fbcfec4d3b2fULL, 0xe9b5dba58189dbbcULL,
+	0x3956c25bf348b538ULL, 0x59f111f1b605d019ULL,
+	0x923f82a4af194f9bULL, 0xab1c5ed5da6d8118ULL,
+	0xd807aa98a3030242ULL, 0x12835b0145706fbeULL,
+	0x243185be4ee4b28cULL, 0x550c7dc3d5ffb4e2ULL,
+	0x72be5d74f27b896fULL, 0x80deb1fe3b1696b1ULL,
+	0x9bdc06a725c71235ULL, 0xc19bf174cf692694ULL,
+	0xe49b69c19ef14ad2ULL, 0xefbe4786384f25e3ULL,
+	0x0fc19dc68b8cd5b5ULL, 0x240ca1cc77ac9c65ULL,
+	0x2de92c6f592b0275ULL, 0x4a7484aa6ea6e483ULL,
+	0x5cb0a9dcbd41fbd4ULL, 0x76f988da831153b5ULL,
+	0x983e5152ee66dfabULL, 0xa831c66d2db43210ULL,
+	0xb00327c898fb213fULL, 0xbf597fc7beef0ee4ULL,
+	0xc6e00bf33da88fc2ULL, 0xd5a79147930aa725ULL,
+	0x06ca6351e003826fULL, 0x142929670a0e6e70ULL,
+	0x27b70a8546d22ffcULL, 0x2e1b21385c26c926ULL,
+	0x4d2c6dfc5ac42aedULL, 0x53380d139d95b3dfULL,
+	0x650a73548baf63deULL, 0x766a0abb3c77b2a8ULL,
+	0x81c2c92e47edaee6ULL, 0x92722c851482353bULL,
+	0xa2bfe8a14cf10364ULL, 0xa81a664bbc423001ULL,
+	0xc24b8b70d0f89791ULL, 0xc76c51a30654be30ULL,
+	0xd192e819d6ef5218ULL, 0xd69906245565a910ULL,
+	0xf40e35855771202aULL, 0x106aa07032bbd1b8ULL,
+	0x19a4c116b8d2d0c8ULL, 0x1e376c085141ab53ULL,
+	0x2748774cdf8eeb99ULL, 0x34b0bcb5e19b48a8ULL,
+	0x391c0cb3c5c95a63ULL, 0x4ed8aa4ae3418acbULL,
+	0x5b9cca4f7763e373ULL, 0x682e6ff3d6b2b8a3ULL,
+	0x748f82ee5defb2fcULL, 0x78a5636f43172f60ULL,
+	0x84c87814a1f0ab72ULL, 0x8cc702081a6439ecULL,
+	0x90befffa23631e28ULL, 0xa4506cebde82bde9ULL,
+	0xbef9a3f7b2c67915ULL, 0xc67178f2e372532bULL,
+	0xca273eceea26619cULL, 0xd186b8c721c0c207ULL,
+	0xeada7dd6cde0eb1eULL, 0xf57d4f7fee6ed178ULL,
+	0x06f067aa72176fbaULL, 0x0a637dc5a2c898a6ULL,
+	0x113f9804bef90daeULL, 0x1b710b35131c471bULL,
+	0x28db77f523047d84ULL, 0x32caab7b40c72493ULL,
+	0x3c9ebe0a15c9bebcULL, 0x431d67c49c100d4cULL,
+	0x4cc5d4becb3e42b6ULL, 0x597f299cfc657e2aULL,
+	0x5fcb6fab3ad6faecULL, 0x6c44198c4a475817ULL
+};
+
+/* Initial hash value H for SHA-384 */
+static const uint64_t sha384_initial_hash_value[8] = {
+	0xcbbb9d5dc1059ed8ULL,
+	0x629a292a367cd507ULL,
+	0x9159015a3070dd17ULL,
+	0x152fecd8f70e5939ULL,
+	0x67332667ffc00b31ULL,
+	0x8eb44a8768581511ULL,
+	0xdb0c2e0d64f98fa7ULL,
+	0x47b5481dbefa4fa4ULL
+};
+
+/* Initial hash value H for SHA-512 */
+static const uint64_t sha512_initial_hash_value[8] = {
+	0x6a09e667f3bcc908ULL,
+	0xbb67ae8584caa73bULL,
+	0x3c6ef372fe94f82bULL,
+	0xa54ff53a5f1d36f1ULL,
+	0x510e527fade682d1ULL,
+	0x9b05688c2b3e6c1fULL,
+	0x1f83d9abfb41bd6bULL,
+	0x5be0cd19137e2179ULL
+};
+
+/*
+ * Constant used by SHA256/384/512_End() functions for converting the
+ * digest to a readable hexadecimal character string:
+ */
+
+//static const char *sha2_hex_digits = "0123456789abcdef"; // PJ
+
+
+/*** SHA-256: *********************************************************/
+static void SHA256_Init(SHA256_CTX* context) {
+	if (context == (SHA256_CTX*)0) {
+		return;
+	}
+	MEMCPY_BCOPY(context->state, sha256_initial_hash_value, SHA256_DIGEST_LENGTH);
+	MEMSET_BZERO(context->buffer, SHA256_BLOCK_LENGTH);
+	context->bitcount = 0;
+}
+
+#ifdef SHA2_UNROLL_TRANSFORM
+
+/* Unrolled SHA-256 round macros: */
+
+#if BYTE_ORDER == LITTLE_ENDIAN
+
+#define ROUND256_0_TO_15(a,b,c,d,e,f,g,h)	\
+	REVERSE32(*data++, W256[j]); \
+	T1 = (h) + Sigma1_256(e) + Ch((e), (f), (g)) + \
+             K256[j] + W256[j]; \
+	(d) += T1; \
+	(h) = T1 + Sigma0_256(a) + Maj((a), (b), (c)); \
+	j++
+
+
+#else /* BYTE_ORDER == LITTLE_ENDIAN */
+
+#define ROUND256_0_TO_15(a,b,c,d,e,f,g,h)	\
+	T1 = (h) + Sigma1_256(e) + Ch((e), (f), (g)) + \
+	     K256[j] + (W256[j] = *data++); \
+	(d) += T1; \
+	(h) = T1 + Sigma0_256(a) + Maj((a), (b), (c)); \
+	j++
+
+#endif /* BYTE_ORDER == LITTLE_ENDIAN */
+
+#define ROUND256(a,b,c,d,e,f,g,h)	\
+	s0 = W256[(j+1)&0x0f]; \
+	s0 = sigma0_256(s0); \
+	s1 = W256[(j+14)&0x0f]; \
+	s1 = sigma1_256(s1); \
+	T1 = (h) + Sigma1_256(e) + Ch((e), (f), (g)) + K256[j] + \
+	     (W256[j&0x0f] += s1 + W256[(j+9)&0x0f] + s0); \
+	(d) += T1; \
+	(h) = T1 + Sigma0_256(a) + Maj((a), (b), (c)); \
+	j++
+
+void SHA256_Transform(SHA256_CTX* context, const uint32_t* data) {
+	uint32_t	a, b, c, d, e, f, g, h, s0, s1;
+	uint32_t	T1, *W256;
+	int		j;
+
+	W256 = (uint32_t*)context->buffer;
+
+	/* Initialize registers with the prev. intermediate value */
+	a = context->state[0];
+	b = context->state[1];
+	c = context->state[2];
+	d = context->state[3];
+	e = context->state[4];
+	f = context->state[5];
+	g = context->state[6];
+	h = context->state[7];
+
+	j = 0;
+	do {
+		/* Rounds 0 to 15 (unrolled): */
+		ROUND256_0_TO_15(a,b,c,d,e,f,g,h);
+		ROUND256_0_TO_15(h,a,b,c,d,e,f,g);
+		ROUND256_0_TO_15(g,h,a,b,c,d,e,f);
+		ROUND256_0_TO_15(f,g,h,a,b,c,d,e);
+		ROUND256_0_TO_15(e,f,g,h,a,b,c,d);
+		ROUND256_0_TO_15(d,e,f,g,h,a,b,c);
+		ROUND256_0_TO_15(c,d,e,f,g,h,a,b);
+		ROUND256_0_TO_15(b,c,d,e,f,g,h,a);
+	} while (j < 16);
+
+	/* Now for the remaining rounds to 64: */
+	do {
+		ROUND256(a,b,c,d,e,f,g,h);
+		ROUND256(h,a,b,c,d,e,f,g);
+		ROUND256(g,h,a,b,c,d,e,f);
+		ROUND256(f,g,h,a,b,c,d,e);
+		ROUND256(e,f,g,h,a,b,c,d);
+		ROUND256(d,e,f,g,h,a,b,c);
+		ROUND256(c,d,e,f,g,h,a,b);
+		ROUND256(b,c,d,e,f,g,h,a);
+	} while (j < 64);
+
+	/* Compute the current intermediate hash value */
+	context->state[0] += a;
+	context->state[1] += b;
+	context->state[2] += c;
+	context->state[3] += d;
+	context->state[4] += e;
+	context->state[5] += f;
+	context->state[6] += g;
+	context->state[7] += h;
+
+	/* Clean up */
+	a = b = c = d = e = f = g = h = T1 = 0;
+}
+
+#else /* SHA2_UNROLL_TRANSFORM */
+
+static void SHA256_Transform(SHA256_CTX* context, const uint32_t* data) {
+	uint32_t	a, b, c, d, e, f, g, h, s0, s1;
+	uint32_t	T1, T2, *W256;
+	int		j;
+
+#if defined __arm__ || defined __ARM__ || defined ARM || defined __ARM || defined __arm || defined __ARM_ARCH ||defined __aarch64__ 
+	W256 = (uint32_t*)((void *)context->buffer);
+#else
+	W256 = (uint32_t*)context->buffer;
+#endif
+
+
+	/* Initialize registers with the prev. intermediate value */
+	a = context->state[0];
+	b = context->state[1];
+	c = context->state[2];
+	d = context->state[3];
+	e = context->state[4];
+	f = context->state[5];
+	g = context->state[6];
+	h = context->state[7];
+
+	j = 0;
+	do {
+#if BYTE_ORDER == LITTLE_ENDIAN
+		/* Copy data while converting to host byte order */
+		REVERSE32(*data++,W256[j]);
+		/* Apply the SHA-256 compression function to update a..h */
+		T1 = h + Sigma1_256(e) + Ch(e, f, g) + K256[j] + W256[j];
+#else /* BYTE_ORDER == LITTLE_ENDIAN */
+		/* Apply the SHA-256 compression function to update a..h with copy */
+		T1 = h + Sigma1_256(e) + Ch(e, f, g) + K256[j] + (W256[j] = *data++);
+#endif /* BYTE_ORDER == LITTLE_ENDIAN */
+		T2 = Sigma0_256(a) + Maj(a, b, c);
+		h = g;
+		g = f;
+		f = e;
+		e = d + T1;
+		d = c;
+		c = b;
+		b = a;
+		a = T1 + T2;
+
+		j++;
+	} while (j < 16);
+
+	do {
+		/* Part of the message block expansion: */
+		s0 = W256[(j+1)&0x0f];
+		s0 = sigma0_256(s0);
+		s1 = W256[(j+14)&0x0f];
+		s1 = sigma1_256(s1);
+
+		/* Apply the SHA-256 compression function to update a..h */
+		T1 = h + Sigma1_256(e) + Ch(e, f, g) + K256[j] +
+		     (W256[j&0x0f] += s1 + W256[(j+9)&0x0f] + s0);
+		T2 = Sigma0_256(a) + Maj(a, b, c);
+		h = g;
+		g = f;
+		f = e;
+		e = d + T1;
+		d = c;
+		c = b;
+		b = a;
+		a = T1 + T2;
+
+		j++;
+	} while (j < 64);
+
+	/* Compute the current intermediate hash value */
+	context->state[0] += a;
+	context->state[1] += b;
+	context->state[2] += c;
+	context->state[3] += d;
+	context->state[4] += e;
+	context->state[5] += f;
+	context->state[6] += g;
+	context->state[7] += h;
+
+	/* Clean up */
+	a = b = c = d = e = f = g = h = T1 = T2 = 0;
+}
+
+#endif /* SHA2_UNROLL_TRANSFORM */
+
+static void SHA256_Update(SHA256_CTX* context, const uint8_t *data, size_t len) {
+	unsigned int	freespace, usedspace;
+
+	if (len == 0) {
+		/* Calling with no data is valid - we do nothing */
+		return;
+	}
+
+	/* Sanity check: */
+	assert(context != (SHA256_CTX*)0 && data != (uint8_t*)0);
+
+	usedspace = (context->bitcount >> 3) % SHA256_BLOCK_LENGTH;
+	if (usedspace > 0) {
+		/* Calculate how much free space is available in the buffer */
+		freespace = SHA256_BLOCK_LENGTH - usedspace;
+
+		if (len >= freespace) {
+			/* Fill the buffer completely and process it */
+			MEMCPY_BCOPY(&context->buffer[usedspace], data, freespace);
+			context->bitcount += freespace << 3;
+			len -= freespace;
+			data += freespace;
+#if defined __arm__ || defined __ARM__ || defined ARM || defined __ARM || defined __arm || defined __ARM_ARCH ||defined __aarch64__ 
+			SHA256_Transform(context, (uint32_t*)((void *)context->buffer));
+#else
+			SHA256_Transform(context, (uint32_t*)context->buffer);
+#endif
+
+		} else {
+			/* The buffer is not yet full */
+			MEMCPY_BCOPY(&context->buffer[usedspace], data, len);
+			context->bitcount += len << 3;
+			/* Clean up: */
+			usedspace = freespace = 0;
+			return;
+		}
+	}
+	while (len >= SHA256_BLOCK_LENGTH) {
+		/* Process as many complete blocks as we can */
+#if defined __arm__ || defined __ARM__ || defined ARM || defined __ARM || defined __arm || defined __ARM_ARCH ||defined __aarch64__ 
+  	        SHA256_Transform(context, (const uint32_t*)(const void *)(data));
+#else
+		SHA256_Transform(context, (const uint32_t*)data);
+#endif
+
+		context->bitcount += SHA256_BLOCK_LENGTH << 3;
+		len -= SHA256_BLOCK_LENGTH;
+		data += SHA256_BLOCK_LENGTH;
+	}
+	if (len > 0) {
+		/* There's left-overs, so save 'em */
+		MEMCPY_BCOPY(context->buffer, data, len);
+		context->bitcount += len << 3;
+	}
+	/* Clean up: */
+	usedspace = freespace = 0;
+}
+
+static void SHA256_Final(uint8_t digest[], SHA256_CTX* context) {
+#if defined __arm__ || defined __ARM__ || defined ARM || defined __ARM || defined __arm || defined __ARM_ARCH ||defined __aarch64__ 
+        uint32_t	*d ;
+#else
+        uint32_t	*d = (uint32_t*)digest;
+
+#endif
+	unsigned int	usedspace;
+
+	/* Sanity check: */
+	assert(context != (SHA256_CTX*)0);
+#if defined __arm__ || defined __ARM__ || defined ARM || defined __ARM || defined __arm || defined __ARM_ARCH ||defined __aarch64__ 
+        d = malloc(sizeof(uint32_t)*8); /* why  8 ?  see below for loop */
+        assert(d);		   
+#endif
+	
+	/* If no digest buffer is passed, we don't bother doing this: */
+	if (digest != (uint8_t*)0) {
+		usedspace = (context->bitcount >> 3) % SHA256_BLOCK_LENGTH;
+#if BYTE_ORDER == LITTLE_ENDIAN
+		/* Convert FROM host byte order */
+		REVERSE64(context->bitcount,context->bitcount);
+#endif
+		if (usedspace > 0) {
+			/* Begin padding with a 1 bit: */
+			context->buffer[usedspace++] = 0x80;
+
+			if (usedspace <= SHA256_SHORT_BLOCK_LENGTH) {
+				/* Set-up for the last transform: */
+				MEMSET_BZERO(&context->buffer[usedspace], SHA256_SHORT_BLOCK_LENGTH - usedspace);
+			} else {
+				if (usedspace < SHA256_BLOCK_LENGTH) {
+					MEMSET_BZERO(&context->buffer[usedspace], SHA256_BLOCK_LENGTH - usedspace);
+				}
+				/* Do second-to-last transform: */
+#if defined __arm__ || defined __ARM__ || defined ARM || defined __ARM || defined __arm || defined __ARM_ARCH ||defined __aarch64__ 
+				SHA256_Transform(context, (uint32_t*)(void *)(context->buffer));
+#else
+				SHA256_Transform(context, (uint32_t*)context->buffer);
+#endif
+
+
+				/* And set-up for the last transform: */
+				MEMSET_BZERO(context->buffer, SHA256_SHORT_BLOCK_LENGTH);
+			}
+		} else {
+			/* Set-up for the last transform: */
+			MEMSET_BZERO(context->buffer, SHA256_SHORT_BLOCK_LENGTH);
+
+			/* Begin padding with a 1 bit: */
+			*context->buffer = 0x80;
+		}
+		/* Set the bit count: */
+		//*(uint64_t*)&context->buffer[SHA256_SHORT_BLOCK_LENGTH] = context->bitcount; // aliasing violation warning
+    context->buffer64[SHA256_SHORT_BLOCK_LENGTH / sizeof(uint64_t)] = context->bitcount;
+
+		/* Final transform: */
+#if defined __arm__ || defined __ARM__ || defined ARM || defined __ARM || defined __arm || defined __ARM_ARCH ||defined __aarch64__ 
+                SHA256_Transform(context, (uint32_t*)((void *)(context->buffer)));
+
+#else
+		SHA256_Transform(context, (uint32_t*)context->buffer);
+
+#endif
+
+#if BYTE_ORDER == LITTLE_ENDIAN
+		{
+			/* Convert TO host byte order */
+			int	j;
+			for (j = 0; j < 8; j++) {
+				REVERSE32(context->state[j],context->state[j]);
+				*d++ = context->state[j];
+			}
+		}
+#else
+		MEMCPY_BCOPY(d, context->state, SHA256_DIGEST_LENGTH);
+#endif
+	}
+
+#if defined __arm__ || defined __ARM__ || defined ARM || defined __ARM || defined __arm || defined __ARM_ARCH ||defined __aarch64__ 
+        memcpy(digest,d,SHA256_DIGEST_LENGTH);
+        free(d);		   
+#endif
+	
+	/* Clean up state data: */
+	MEMSET_BZERO(context, sizeof(*context));
+	usedspace = 0;
+}
+
+/*
+static char *SHA256_End(SHA256_CTX* context, char buffer[]) {
+	uint8_t	digest[SHA256_DIGEST_LENGTH], *d = digest;
+	int		i;
+
+	/ * Sanity check: * /
+	assert(context != (SHA256_CTX*)0);
+
+	if (buffer != (char*)0) {
+		SHA256_Final(digest, context);
+
+		for (i = 0; i < SHA256_DIGEST_LENGTH; i++) {
+			*buffer++ = sha2_hex_digits[(*d & 0xf0) >> 4];
+			*buffer++ = sha2_hex_digits[*d & 0x0f];
+			d++;
+		}
+		*buffer = (char)0;
+	} else {
+		MEMSET_BZERO(context, sizeof(context));
+	}
+	MEMSET_BZERO(digest, SHA256_DIGEST_LENGTH);
+	return buffer;
+}
+
+static char* SHA256_Data(const uint8_t* data, size_t len, char digest[SHA256_DIGEST_STRING_LENGTH]) {
+	SHA256_CTX	context;
+
+	SHA256_Init(&context);
+	SHA256_Update(&context, data, len);
+	return SHA256_End(&context, digest);
+}
+*/
+
+
+/*** SHA-512: *********************************************************/
+static void SHA512_Init(SHA512_CTX* context) {
+	if (context == (SHA512_CTX*)0) {
+		return;
+	}
+	MEMCPY_BCOPY(context->state, sha512_initial_hash_value, SHA512_DIGEST_LENGTH);
+	MEMSET_BZERO(context->buffer, SHA512_BLOCK_LENGTH);
+	context->bitcount[0] = context->bitcount[1] =  0;
+}
+
+#ifdef SHA2_UNROLL_TRANSFORM
+
+/* Unrolled SHA-512 round macros: */
+#if BYTE_ORDER == LITTLE_ENDIAN
+
+#define ROUND512_0_TO_15(a,b,c,d,e,f,g,h)	\
+	REVERSE64(*data++, W512[j]); \
+	T1 = (h) + Sigma1_512(e) + Ch((e), (f), (g)) + \
+             K512[j] + W512[j]; \
+	(d) += T1, \
+	(h) = T1 + Sigma0_512(a) + Maj((a), (b), (c)), \
+	j++
+
+
+#else /* BYTE_ORDER == LITTLE_ENDIAN */
+
+#define ROUND512_0_TO_15(a,b,c,d,e,f,g,h)	\
+	T1 = (h) + Sigma1_512(e) + Ch((e), (f), (g)) + \
+             K512[j] + (W512[j] = *data++); \
+	(d) += T1; \
+	(h) = T1 + Sigma0_512(a) + Maj((a), (b), (c)); \
+	j++
+
+#endif /* BYTE_ORDER == LITTLE_ENDIAN */
+
+#define ROUND512(a,b,c,d,e,f,g,h)	\
+	s0 = W512[(j+1)&0x0f]; \
+	s0 = sigma0_512(s0); \
+	s1 = W512[(j+14)&0x0f]; \
+	s1 = sigma1_512(s1); \
+	T1 = (h) + Sigma1_512(e) + Ch((e), (f), (g)) + K512[j] + \
+             (W512[j&0x0f] += s1 + W512[(j+9)&0x0f] + s0); \
+	(d) += T1; \
+	(h) = T1 + Sigma0_512(a) + Maj((a), (b), (c)); \
+	j++
+
+static void SHA512_Transform(SHA512_CTX* context, const uint64_t* data) {
+	uint64_t	a, b, c, d, e, f, g, h, s0, s1;
+	uint64_t	T1, *W512 = (uint64_t*)context->buffer;
+	int		j;
+
+	/* Initialize registers with the prev. intermediate value */
+	a = context->state[0];
+	b = context->state[1];
+	c = context->state[2];
+	d = context->state[3];
+	e = context->state[4];
+	f = context->state[5];
+	g = context->state[6];
+	h = context->state[7];
+
+	j = 0;
+	do {
+		ROUND512_0_TO_15(a,b,c,d,e,f,g,h);
+		ROUND512_0_TO_15(h,a,b,c,d,e,f,g);
+		ROUND512_0_TO_15(g,h,a,b,c,d,e,f);
+		ROUND512_0_TO_15(f,g,h,a,b,c,d,e);
+		ROUND512_0_TO_15(e,f,g,h,a,b,c,d);
+		ROUND512_0_TO_15(d,e,f,g,h,a,b,c);
+		ROUND512_0_TO_15(c,d,e,f,g,h,a,b);
+		ROUND512_0_TO_15(b,c,d,e,f,g,h,a);
+	} while (j < 16);
+
+	/* Now for the remaining rounds up to 79: */
+	do {
+		ROUND512(a,b,c,d,e,f,g,h);
+		ROUND512(h,a,b,c,d,e,f,g);
+		ROUND512(g,h,a,b,c,d,e,f);
+		ROUND512(f,g,h,a,b,c,d,e);
+		ROUND512(e,f,g,h,a,b,c,d);
+		ROUND512(d,e,f,g,h,a,b,c);
+		ROUND512(c,d,e,f,g,h,a,b);
+		ROUND512(b,c,d,e,f,g,h,a);
+	} while (j < 80);
+
+	/* Compute the current intermediate hash value */
+	context->state[0] += a;
+	context->state[1] += b;
+	context->state[2] += c;
+	context->state[3] += d;
+	context->state[4] += e;
+	context->state[5] += f;
+	context->state[6] += g;
+	context->state[7] += h;
+
+	/* Clean up */
+	a = b = c = d = e = f = g = h = T1 = 0;
+}
+
+#else /* SHA2_UNROLL_TRANSFORM */
+
+static void SHA512_Transform(SHA512_CTX* context, const uint64_t* data) {
+	uint64_t	a, b, c, d, e, f, g, h, s0, s1;
+	uint64_t	T1, T2, *W512 = (uint64_t*)((void *)context->buffer);
+	int		j;
+
+	/* Initialize registers with the prev. intermediate value */
+	a = context->state[0];
+	b = context->state[1];
+	c = context->state[2];
+	d = context->state[3];
+	e = context->state[4];
+	f = context->state[5];
+	g = context->state[6];
+	h = context->state[7];
+
+	j = 0;
+	do {
+#if BYTE_ORDER == LITTLE_ENDIAN
+		/* Convert TO host byte order */
+		REVERSE64(*data++, W512[j]);
+		/* Apply the SHA-512 compression function to update a..h */
+		T1 = h + Sigma1_512(e) + Ch(e, f, g) + K512[j] + W512[j];
+#else /* BYTE_ORDER == LITTLE_ENDIAN */
+		/* Apply the SHA-512 compression function to update a..h with copy */
+		T1 = h + Sigma1_512(e) + Ch(e, f, g) + K512[j] + (W512[j] = *data++);
+#endif /* BYTE_ORDER == LITTLE_ENDIAN */
+		T2 = Sigma0_512(a) + Maj(a, b, c);
+		h = g;
+		g = f;
+		f = e;
+		e = d + T1;
+		d = c;
+		c = b;
+		b = a;
+		a = T1 + T2;
+
+		j++;
+	} while (j < 16);
+
+	do {
+		/* Part of the message block expansion: */
+		s0 = W512[(j+1)&0x0f];
+		s0 = sigma0_512(s0);
+		s1 = W512[(j+14)&0x0f];
+		s1 =  sigma1_512(s1);
+
+		/* Apply the SHA-512 compression function to update a..h */
+		T1 = h + Sigma1_512(e) + Ch(e, f, g) + K512[j] +
+		     (W512[j&0x0f] += s1 + W512[(j+9)&0x0f] + s0);
+		T2 = Sigma0_512(a) + Maj(a, b, c);
+		h = g;
+		g = f;
+		f = e;
+		e = d + T1;
+		d = c;
+		c = b;
+		b = a;
+		a = T1 + T2;
+
+		j++;
+	} while (j < 80);
+
+	/* Compute the current intermediate hash value */
+	context->state[0] += a;
+	context->state[1] += b;
+	context->state[2] += c;
+	context->state[3] += d;
+	context->state[4] += e;
+	context->state[5] += f;
+	context->state[6] += g;
+	context->state[7] += h;
+
+	/* Clean up */
+	a = b = c = d = e = f = g = h = T1 = T2 = 0;
+}
+
+#endif /* SHA2_UNROLL_TRANSFORM */
+
+static void SHA512_Update(SHA512_CTX* context, const uint8_t *data, size_t len) {
+	unsigned int	freespace, usedspace;
+
+	if (len == 0) {
+		/* Calling with no data is valid - we do nothing */
+		return;
+	}
+
+	/* Sanity check: */
+	assert(context != (SHA512_CTX*)0 && data != (uint8_t*)0);
+
+	usedspace = (context->bitcount[0] >> 3) % SHA512_BLOCK_LENGTH;
+	if (usedspace > 0) {
+		/* Calculate how much free space is available in the buffer */
+		freespace = SHA512_BLOCK_LENGTH - usedspace;
+
+		if (len >= freespace) {
+			/* Fill the buffer completely and process it */
+			MEMCPY_BCOPY(&context->buffer[usedspace], data, freespace);
+			ADDINC128(context->bitcount, freespace << 3);
+			len -= freespace;
+			data += freespace;
+#if defined __arm__ || defined __ARM__ || defined ARM || defined __ARM || defined __arm || defined __ARM_ARCH ||defined __aarch64__ 
+			SHA512_Transform(context, (uint64_t*)((void *)context->buffer));
+#else
+			SHA512_Transform(context, (uint64_t*)context->buffer);
+#endif
+		} else {
+			/* The buffer is not yet full */
+			MEMCPY_BCOPY(&context->buffer[usedspace], data, len);
+			ADDINC128(context->bitcount, len << 3);
+			/* Clean up: */
+			usedspace = freespace = 0;
+			return;
+		}
+	}
+	while (len >= SHA512_BLOCK_LENGTH) {
+		/* Process as many complete blocks as we can */
+#if defined __arm__ || defined __ARM__ || defined ARM || defined __ARM || defined __arm || defined __ARM_ARCH ||defined __aarch64__ 
+  	                SHA512_Transform(context, (uint64_t*)((void *)context->buffer));
+#else
+			SHA512_Transform(context, (uint64_t*)context->buffer);
+#endif
+		ADDINC128(context->bitcount, SHA512_BLOCK_LENGTH << 3);
+		len -= SHA512_BLOCK_LENGTH;
+		data += SHA512_BLOCK_LENGTH;
+	}
+	if (len > 0) {
+		/* There's left-overs, so save 'em */
+		MEMCPY_BCOPY(context->buffer, data, len);
+		ADDINC128(context->bitcount, len << 3);
+	}
+	/* Clean up: */
+	usedspace = freespace = 0;
+}
+
+static void SHA512_Last(SHA512_CTX* context) {
+	unsigned int	usedspace;
+
+	usedspace = (context->bitcount[0] >> 3) % SHA512_BLOCK_LENGTH;
+#if BYTE_ORDER == LITTLE_ENDIAN
+	/* Convert FROM host byte order */
+	REVERSE64(context->bitcount[0],context->bitcount[0]);
+	REVERSE64(context->bitcount[1],context->bitcount[1]);
+#endif
+	if (usedspace > 0) {
+		/* Begin padding with a 1 bit: */
+		context->buffer[usedspace++] = 0x80;
+
+		if (usedspace <= SHA512_SHORT_BLOCK_LENGTH) {
+			/* Set-up for the last transform: */
+			MEMSET_BZERO(&context->buffer[usedspace], SHA512_SHORT_BLOCK_LENGTH - usedspace);
+		} else {
+			if (usedspace < SHA512_BLOCK_LENGTH) {
+				MEMSET_BZERO(&context->buffer[usedspace], SHA512_BLOCK_LENGTH - usedspace);
+			}
+			/* Do second-to-last transform: */
+#if defined __arm__ || defined __ARM__ || defined ARM || defined __ARM || defined __arm || defined __ARM_ARCH ||defined __aarch64__ 
+			SHA512_Transform(context, (uint64_t*)((void *)context->buffer));
+#else
+			SHA512_Transform(context, (uint64_t*)context->buffer);
+#endif
+
+
+			/* And set-up for the last transform: */
+			MEMSET_BZERO(context->buffer, SHA512_BLOCK_LENGTH - 2);
+		}
+	} else {
+		/* Prepare for final transform: */
+		MEMSET_BZERO(context->buffer, SHA512_SHORT_BLOCK_LENGTH);
+
+		/* Begin padding with a 1 bit: */
+		*context->buffer = 0x80;
+	}
+	/* Store the length of input data (in bits): */
+	//*(uint64_t*)&context->buffer[SHA512_SHORT_BLOCK_LENGTH] = context->bitcount[1]; // aliasing violation warning
+	//*(uint64_t*)&context->buffer[SHA512_SHORT_BLOCK_LENGTH+8] = context->bitcount[0];
+  context->buffer64[SHA512_SHORT_BLOCK_LENGTH / sizeof(uint64_t)] = context->bitcount[1];
+  context->buffer64[SHA512_SHORT_BLOCK_LENGTH / sizeof(uint64_t) + 1] = context->bitcount[0];
+
+	/* Final transform: */
+#if defined __arm__ || defined __ARM__ || defined ARM || defined __ARM || defined __arm || defined __ARM_ARCH ||defined __aarch64__ 
+        SHA512_Transform(context, (uint64_t*)((void *)context->buffer));
+#else
+	SHA512_Transform(context, (uint64_t*)context->buffer);
+#endif
+
+}
+
+static void SHA512_Final(uint8_t digest[], SHA512_CTX* context) {
+#if defined __arm__ || defined __ARM__ || defined ARM || defined __ARM || defined __arm || defined __ARM_ARCH ||defined __aarch64__ 
+        uint64_t	*d ;
+#else
+        uint64_t	*d = (uint64_t*)digest;
+
+#endif
+
+	/* Sanity check: */
+	assert(context != (SHA512_CTX*)0);
+#if defined __arm__ || defined __ARM__ || defined ARM || defined __ARM || defined __arm || defined __ARM_ARCH ||defined __aarch64__ 
+        d = malloc(sizeof(uint64_t)*8); /* why  8 ?  see below for loop */
+        assert(d);		   
+#endif
+
+	/* If no digest buffer is passed, we don't bother doing this: */
+	if (digest != (uint8_t*)0) {
+		SHA512_Last(context);
+
+		/* Save the hash data for output: */
+#if BYTE_ORDER == LITTLE_ENDIAN
+		{
+			/* Convert TO host byte order */
+			int	j;
+			for (j = 0; j < 8; j++) {
+				REVERSE64(context->state[j],context->state[j]);
+				*d++ = context->state[j];
+			}
+		}
+#else
+		MEMCPY_BCOPY(d, context->state, SHA512_DIGEST_LENGTH);
+#endif
+	}
+#if defined __arm__ || defined __ARM__ || defined ARM || defined __ARM || defined __arm || defined __ARM_ARCH ||defined __aarch64__ 
+        memcpy(digest,d,SHA512_DIGEST_LENGTH);
+        free(d);		   
+#endif
+
+	/* Zero out state data */
+	MEMSET_BZERO(context, sizeof(*context));
+}
+
+/*
+static char *SHA512_End(SHA512_CTX* context, char buffer[]) {
+	uint8_t	digest[SHA512_DIGEST_LENGTH], *d = digest;
+	int		i;
+
+	/ * Sanity check: * /
+	assert(context != (SHA512_CTX*)0);
+
+	if (buffer != (char*)0) {
+		SHA512_Final(digest, context);
+
+		for (i = 0; i < SHA512_DIGEST_LENGTH; i++) {
+			*buffer++ = sha2_hex_digits[(*d & 0xf0) >> 4];
+			*buffer++ = sha2_hex_digits[*d & 0x0f];
+			d++;
+		}
+		*buffer = (char)0;
+	} else {
+		MEMSET_BZERO(context, sizeof(context));
+	}
+	MEMSET_BZERO(digest, SHA512_DIGEST_LENGTH);
+	return buffer;
+}
+
+static char* SHA512_Data(const uint8_t* data, size_t len, char digest[SHA512_DIGEST_STRING_LENGTH]) {
+	SHA512_CTX	context;
+
+	SHA512_Init(&context);
+	SHA512_Update(&context, data, len);
+	return SHA512_End(&context, digest);
+}
+*/
+
+/*** SHA-384: *********************************************************/
+static void SHA384_Init(SHA384_CTX* context) {
+	if (context == (SHA384_CTX*)0) {
+		return;
+	}
+	MEMCPY_BCOPY(context->state, sha384_initial_hash_value, SHA512_DIGEST_LENGTH);
+	MEMSET_BZERO(context->buffer, SHA384_BLOCK_LENGTH);
+	context->bitcount[0] = context->bitcount[1] = 0;
+}
+
+static void SHA384_Update(SHA384_CTX* context, const uint8_t* data, size_t len) {
+	SHA512_Update((SHA512_CTX*)context, data, len);
+}
+
+static void SHA384_Final(uint8_t digest[], SHA384_CTX* context) {
+#if defined __arm__ || defined __ARM__ || defined ARM || defined __ARM || defined __arm || defined __ARM_ARCH ||defined __aarch64__ 
+        uint64_t	*d;
+#else
+        uint64_t	*d = (uint64_t*)digest;
+#endif
+
+
+
+	/* Sanity check: */
+	assert(context != (SHA384_CTX*)0);
+#if defined __arm__ || defined __ARM__ || defined ARM || defined __ARM || defined __arm || defined __ARM_ARCH ||defined __aarch64__ 
+        d = malloc(sizeof(uint64_t)*6); /* why  6 ?  see below for loop */
+        assert(d);		   
+#endif
+
+	/* If no digest buffer is passed, we don't bother doing this: */
+	if (digest != (uint8_t*)0) {
+		SHA512_Last((SHA512_CTX*)context);
+
+		/* Save the hash data for output: */
+#if BYTE_ORDER == LITTLE_ENDIAN
+		{
+			/* Convert TO host byte order */
+			int	j;
+			for (j = 0; j < 6; j++) {
+				REVERSE64(context->state[j],context->state[j]);
+				*d++ = context->state[j];
+			}
+		}
+#else
+		MEMCPY_BCOPY(d, context->state, SHA384_DIGEST_LENGTH);
+#endif
+	}
+#if defined __arm__ || defined __ARM__ || defined ARM || defined __ARM || defined __arm || defined __ARM_ARCH ||defined __aarch64__ 
+        memcpy(digest,d,SHA384_DIGEST_LENGTH);
+        free(d);		   
+#endif
+	/* Zero out state data */
+	MEMSET_BZERO(context, sizeof(*context));
+}
+
+/*
+static char *SHA384_End(SHA384_CTX* context, char buffer[]) {
+	uint8_t	digest[SHA384_DIGEST_LENGTH], *d = digest;
+	int		i;
+
+	/ * Sanity check: * /
+	assert(context != (SHA384_CTX*)0);
+
+	if (buffer != (char*)0) {
+		SHA384_Final(digest, context);
+
+		for (i = 0; i < SHA384_DIGEST_LENGTH; i++) {
+			*buffer++ = sha2_hex_digits[(*d & 0xf0) >> 4];
+			*buffer++ = sha2_hex_digits[*d & 0x0f];
+			d++;
+		}
+		*buffer = (char)0;
+	} else {
+		MEMSET_BZERO(context, sizeof(context));
+	}
+	MEMSET_BZERO(digest, SHA384_DIGEST_LENGTH);
+	return buffer;
+}
+
+static char* SHA384_Data(const uint8_t* data, size_t len, char digest[SHA384_DIGEST_STRING_LENGTH]) {
+	SHA384_CTX	context;
+
+	SHA384_Init(&context);
+	SHA384_Update(&context, data, len);
+	return SHA384_End(&context, digest);
+}
+*/
+
+/* end of sha2.c */
+
+void sha256_init (sha256_state *state)
+{
+  SHA256_Init(state);
+}
+
+void sha384_init (sha384_state *state)
+{
+  SHA384_Init(state);
+}
+
+void sha512_init (sha512_state *state)
+{
+  SHA512_Init(state);
+}
+
+
+void sha256_add (sha256_state *state, const void *data, size_t size)
+{
+  SHA256_Update(state, (const uint8_t *)data, size);
+}
+
+void sha384_add (sha384_state *state, const void *data, size_t size)
+{
+  SHA384_Update(state, (const uint8_t *)data, size);
+}
+
+void sha512_add (sha512_state *state, const void *data, size_t size)
+{
+  SHA512_Update(state, (const uint8_t *)data, size);
+}
+
+
+void sha256_put (sha256_state *state, uint8_t digest[SHA256_DIGEST_LENGTH])
+{
+  SHA256_Final(digest, state);
+}
+
+void sha384_put (sha384_state *state, uint8_t digest[SHA384_DIGEST_LENGTH])
+{
+  SHA384_Final(digest, state);
+}
+
+void sha512_put (sha384_state *state, uint8_t digest[SHA512_DIGEST_LENGTH])
+{
+  SHA512_Final(digest, state);
+}
+
+
+void sha256 (const void *data, size_t size, uint8_t digest[SHA256_DIGEST_LENGTH])
+{
+  sha256_state state;
+  SHA256_Init(&state);
+  SHA256_Update(&state, (const uint8_t *)data, size);
+  SHA256_Final(digest, &state);
+}
+
+void sha384 (const void *data, size_t size, uint8_t digest[SHA384_DIGEST_LENGTH])
+{
+  sha384_state state;
+  SHA384_Init(&state);
+  SHA384_Update(&state, (const uint8_t *)data, size);
+  SHA384_Final(digest, &state);
+}
+
+void sha512 (const void *data, size_t size, uint8_t digest[SHA512_DIGEST_LENGTH])
+{
+  sha512_state state;
+  SHA512_Init(&state);
+  SHA512_Update(&state, (const uint8_t *)data, size);
+  SHA512_Final(digest, &state);
+}
+
+static sha256_state sha256state;
+static sha384_state sha384state;
+static sha512_state sha512state;
+
+
+void sha256init (void)
+{
+  SHA256_Init(&sha256state);
+}
+
+void sha384init (void)
+{
+  SHA384_Init(&sha384state);
+}
+
+void sha512init (void)
+{
+  SHA512_Init(&sha512state);
+}
+
+
+void sha256add (const void *data, size_t size)
+{
+  SHA256_Update(&sha256state, (const uint8_t *)data, size);
+}
+
+void sha384add (const void *data, size_t size)
+{
+  SHA384_Update(&sha384state, (const uint8_t *)data, size);
+}
+
+void sha512add (const void *data, size_t size)
+{
+  SHA512_Update(&sha512state, (const uint8_t *)data, size);
+}
+
+
+void sha256put (uint8_t digest[SHA256_DIGEST_LENGTH])
+{
+  SHA256_Final(digest, &sha256state);
+}
+
+void sha384put (uint8_t digest[SHA384_DIGEST_LENGTH])
+{
+  SHA384_Final(digest, &sha384state);
+}
+
+void sha512put (uint8_t digest[SHA512_DIGEST_LENGTH])
+{
+  SHA512_Final(digest, &sha512state);
+}
diff --git a/texk/web2c/luatexdir/luapplib/util/utilsha.h b/texk/web2c/luatexdir/luapplib/util/utilsha.h
new file mode 100644
index 000000000..53f354581
--- /dev/null
+++ b/texk/web2c/luatexdir/luapplib/util/utilsha.h
@@ -0,0 +1,134 @@
+/* sha2 implementation by Aaron D. Gifford (http://www.aarongifford.com) */
+
+#ifndef UTIL_SHA_H
+#define UTIL_SHA_H
+
+#include <stddef.h>
+#include <stdint.h>
+#include "utildecl.h"
+
+/* begin of sha2.h */
+
+/*
+ * FILE:  sha2.h
+ * AUTHOR:  Aaron D. Gifford - http://www.aarongifford.com/
+ *
+ * Copyright (c) 2000-2001, Aaron D. Gifford
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the copyright holder nor the names of contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTOR(S) ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTOR(S) BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * $Id: sha2.h,v 1.1 2001/11/08 00:02:01 adg Exp adg $
+ */
+
+/*** SHA-256/384/512 Various Length Definitions ***********************/
+
+#define SHA256_BLOCK_LENGTH   64
+#define SHA256_DIGEST_LENGTH    32
+#define SHA256_DIGEST_STRING_LENGTH (SHA256_DIGEST_LENGTH * 2 + 1)
+#define SHA384_BLOCK_LENGTH   128
+#define SHA384_DIGEST_LENGTH    48
+#define SHA384_DIGEST_STRING_LENGTH (SHA384_DIGEST_LENGTH * 2 + 1)
+#define SHA512_BLOCK_LENGTH   128
+#define SHA512_DIGEST_LENGTH    64
+#define SHA512_DIGEST_STRING_LENGTH (SHA512_DIGEST_LENGTH * 2 + 1)
+
+typedef struct _SHA256_CTX {
+  uint32_t  state[8];
+  uint64_t  bitcount;
+  union {
+    uint8_t buffer[SHA256_BLOCK_LENGTH];
+    uint64_t buffer64[SHA256_BLOCK_LENGTH / sizeof(uint64_t)]; // to avoid warnings about violating aliasing rules
+  };
+} SHA256_CTX;
+
+typedef struct _SHA512_CTX {
+  uint64_t  state[8];
+  uint64_t  bitcount[2];
+  union {
+    uint8_t buffer[SHA512_BLOCK_LENGTH];
+    uint64_t buffer64[SHA512_BLOCK_LENGTH / sizeof(uint64_t)];
+  };
+} SHA512_CTX;
+
+typedef SHA512_CTX SHA384_CTX;
+
+/*** SHA-256/384/512 Function Prototypes ******************************/
+
+/*
+void SHA256_Init(SHA256_CTX *);
+void SHA256_Update(SHA256_CTX*, const u_int8_t*, size_t);
+void SHA256_Final(u_int8_t[SHA256_DIGEST_LENGTH], SHA256_CTX*);
+char* SHA256_End(SHA256_CTX*, char[SHA256_DIGEST_STRING_LENGTH]);
+char* SHA256_Data(const u_int8_t*, size_t, char[SHA256_DIGEST_STRING_LENGTH]);
+
+void SHA384_Init(SHA384_CTX*);
+void SHA384_Update(SHA384_CTX*, const u_int8_t*, size_t);
+void SHA384_Final(u_int8_t[SHA384_DIGEST_LENGTH], SHA384_CTX*);
+char* SHA384_End(SHA384_CTX*, char[SHA384_DIGEST_STRING_LENGTH]);
+char* SHA384_Data(const u_int8_t*, size_t, char[SHA384_DIGEST_STRING_LENGTH]);
+
+void SHA512_Init(SHA512_CTX*);
+void SHA512_Update(SHA512_CTX*, const u_int8_t*, size_t);
+void SHA512_Final(u_int8_t[SHA512_DIGEST_LENGTH], SHA512_CTX*);
+char* SHA512_End(SHA512_CTX*, char[SHA512_DIGEST_STRING_LENGTH]);
+char* SHA512_Data(const u_int8_t*, size_t, char[SHA512_DIGEST_STRING_LENGTH]);
+*/
+
+/* end of sha2.h */
+
+#define sha256_state SHA256_CTX
+#define sha384_state SHA384_CTX
+#define sha512_state SHA512_CTX
+
+UTILAPI void sha256_init (sha256_state *state);
+UTILAPI void sha384_init (sha384_state *state);
+UTILAPI void sha512_init (sha512_state *state);
+
+UTILAPI void sha256_add (sha256_state *state, const void *data, size_t size);
+UTILAPI void sha384_add (sha384_state *state, const void *data, size_t size);
+UTILAPI void sha512_add (sha512_state *state, const void *data, size_t size);
+
+UTILAPI void sha256_put (sha256_state *state, uint8_t digest[SHA256_DIGEST_LENGTH]);
+UTILAPI void sha384_put (sha384_state *state, uint8_t digest[SHA384_DIGEST_LENGTH]);
+UTILAPI void sha512_put (sha512_state *state, uint8_t digest[SHA512_DIGEST_LENGTH]);
+
+UTILAPI void sha256 (const void *data, size_t size, uint8_t digest[SHA256_DIGEST_LENGTH]);
+UTILAPI void sha384 (const void *data, size_t size, uint8_t digest[SHA384_DIGEST_LENGTH]);
+UTILAPI void sha512 (const void *data, size_t size, uint8_t digest[SHA512_DIGEST_LENGTH]);
+
+UTILAPI void sha256init (void);
+UTILAPI void sha384init (void);
+UTILAPI void sha512init (void);
+
+UTILAPI void sha256add (const void *data, size_t size);
+UTILAPI void sha384add (const void *data, size_t size);
+UTILAPI void sha512add (const void *data, size_t size);
+
+UTILAPI void sha256put (uint8_t digest[SHA256_DIGEST_LENGTH]);
+UTILAPI void sha384put (uint8_t digest[SHA384_DIGEST_LENGTH]);
+UTILAPI void sha512put (uint8_t digest[SHA512_DIGEST_LENGTH]);
+
+#endif
\ No newline at end of file
diff --git a/texk/web2c/luatexdir/luapplib/zlib/zconf.h b/texk/web2c/luatexdir/luapplib/zlib/zconf.h
new file mode 100644
index 000000000..02ce56c43
--- /dev/null
+++ b/texk/web2c/luatexdir/luapplib/zlib/zconf.h
@@ -0,0 +1,428 @@
+/* zconf.h -- configuration of the zlib compression library
+ * Copyright (C) 1995-2010 Jean-loup Gailly.
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/* @(#) $Id$ */
+
+#ifndef ZCONF_H
+#define ZCONF_H
+
+/*
+ * If you *really* need a unique prefix for all types and library functions,
+ * compile with -DZ_PREFIX. The "standard" zlib should be compiled without it.
+ * Even better than compiling with -DZ_PREFIX would be to use configure to set
+ * this permanently in zconf.h using "./configure --zprefix".
+ */
+#ifdef Z_PREFIX     /* may be set to #if 1 by ./configure */
+
+/* all linked symbols */
+#  define _dist_code            z__dist_code
+#  define _length_code          z__length_code
+#  define _tr_align             z__tr_align
+#  define _tr_flush_block       z__tr_flush_block
+#  define _tr_init              z__tr_init
+#  define _tr_stored_block      z__tr_stored_block
+#  define _tr_tally             z__tr_tally
+#  define adler32               z_adler32
+#  define adler32_combine       z_adler32_combine
+#  define adler32_combine64     z_adler32_combine64
+#  define compress              z_compress
+#  define compress2             z_compress2
+#  define compressBound         z_compressBound
+#  define crc32                 z_crc32
+#  define crc32_combine         z_crc32_combine
+#  define crc32_combine64       z_crc32_combine64
+#  define deflate               z_deflate
+#  define deflateBound          z_deflateBound
+#  define deflateCopy           z_deflateCopy
+#  define deflateEnd            z_deflateEnd
+#  define deflateInit2_         z_deflateInit2_
+#  define deflateInit_          z_deflateInit_
+#  define deflateParams         z_deflateParams
+#  define deflatePrime          z_deflatePrime
+#  define deflateReset          z_deflateReset
+#  define deflateSetDictionary  z_deflateSetDictionary
+#  define deflateSetHeader      z_deflateSetHeader
+#  define deflateTune           z_deflateTune
+#  define deflate_copyright     z_deflate_copyright
+#  define get_crc_table         z_get_crc_table
+#  define gz_error              z_gz_error
+#  define gz_intmax             z_gz_intmax
+#  define gz_strwinerror        z_gz_strwinerror
+#  define gzbuffer              z_gzbuffer
+#  define gzclearerr            z_gzclearerr
+#  define gzclose               z_gzclose
+#  define gzclose_r             z_gzclose_r
+#  define gzclose_w             z_gzclose_w
+#  define gzdirect              z_gzdirect
+#  define gzdopen               z_gzdopen
+#  define gzeof                 z_gzeof
+#  define gzerror               z_gzerror
+#  define gzflush               z_gzflush
+#  define gzgetc                z_gzgetc
+#  define gzgets                z_gzgets
+#  define gzoffset              z_gzoffset
+#  define gzoffset64            z_gzoffset64
+#  define gzopen                z_gzopen
+#  define gzopen64              z_gzopen64
+#  define gzprintf              z_gzprintf
+#  define gzputc                z_gzputc
+#  define gzputs                z_gzputs
+#  define gzread                z_gzread
+#  define gzrewind              z_gzrewind
+#  define gzseek                z_gzseek
+#  define gzseek64              z_gzseek64
+#  define gzsetparams           z_gzsetparams
+#  define gztell                z_gztell
+#  define gztell64              z_gztell64
+#  define gzungetc              z_gzungetc
+#  define gzwrite               z_gzwrite
+#  define inflate               z_inflate
+#  define inflateBack           z_inflateBack
+#  define inflateBackEnd        z_inflateBackEnd
+#  define inflateBackInit_      z_inflateBackInit_
+#  define inflateCopy           z_inflateCopy
+#  define inflateEnd            z_inflateEnd
+#  define inflateGetHeader      z_inflateGetHeader
+#  define inflateInit2_         z_inflateInit2_
+#  define inflateInit_          z_inflateInit_
+#  define inflateMark           z_inflateMark
+#  define inflatePrime          z_inflatePrime
+#  define inflateReset          z_inflateReset
+#  define inflateReset2         z_inflateReset2
+#  define inflateSetDictionary  z_inflateSetDictionary
+#  define inflateSync           z_inflateSync
+#  define inflateSyncPoint      z_inflateSyncPoint
+#  define inflateUndermine      z_inflateUndermine
+#  define inflate_copyright     z_inflate_copyright
+#  define inflate_fast          z_inflate_fast
+#  define inflate_table         z_inflate_table
+#  define uncompress            z_uncompress
+#  define zError                z_zError
+#  define zcalloc               z_zcalloc
+#  define zcfree                z_zcfree
+#  define zlibCompileFlags      z_zlibCompileFlags
+#  define zlibVersion           z_zlibVersion
+
+/* all zlib typedefs in zlib.h and zconf.h */
+#  define Byte                  z_Byte
+#  define Bytef                 z_Bytef
+#  define alloc_func            z_alloc_func
+#  define charf                 z_charf
+#  define free_func             z_free_func
+#  define gzFile                z_gzFile
+#  define gz_header             z_gz_header
+#  define gz_headerp            z_gz_headerp
+#  define in_func               z_in_func
+#  define intf                  z_intf
+#  define out_func              z_out_func
+#  define uInt                  z_uInt
+#  define uIntf                 z_uIntf
+#  define uLong                 z_uLong
+#  define uLongf                z_uLongf
+#  define voidp                 z_voidp
+#  define voidpc                z_voidpc
+#  define voidpf                z_voidpf
+
+/* all zlib structs in zlib.h and zconf.h */
+#  define gz_header_s           z_gz_header_s
+#  define internal_state        z_internal_state
+
+#endif
+
+#if defined(__MSDOS__) && !defined(MSDOS)
+#  define MSDOS
+#endif
+#if (defined(OS_2) || defined(__OS2__)) && !defined(OS2)
+#  define OS2
+#endif
+#if defined(_WINDOWS) && !defined(WINDOWS)
+#  define WINDOWS
+#endif
+#if defined(_WIN32) || defined(_WIN32_WCE) || defined(__WIN32__)
+#  ifndef WIN32
+#    define WIN32
+#  endif
+#endif
+#if (defined(MSDOS) || defined(OS2) || defined(WINDOWS)) && !defined(WIN32)
+#  if !defined(__GNUC__) && !defined(__FLAT__) && !defined(__386__)
+#    ifndef SYS16BIT
+#      define SYS16BIT
+#    endif
+#  endif
+#endif
+
+/*
+ * Compile with -DMAXSEG_64K if the alloc function cannot allocate more
+ * than 64k bytes at a time (needed on systems with 16-bit int).
+ */
+#ifdef SYS16BIT
+#  define MAXSEG_64K
+#endif
+#ifdef MSDOS
+#  define UNALIGNED_OK
+#endif
+
+#ifdef __STDC_VERSION__
+#  ifndef STDC
+#    define STDC
+#  endif
+#  if __STDC_VERSION__ >= 199901L
+#    ifndef STDC99
+#      define STDC99
+#    endif
+#  endif
+#endif
+#if !defined(STDC) && (defined(__STDC__) || defined(__cplusplus))
+#  define STDC
+#endif
+#if !defined(STDC) && (defined(__GNUC__) || defined(__BORLANDC__))
+#  define STDC
+#endif
+#if !defined(STDC) && (defined(MSDOS) || defined(WINDOWS) || defined(WIN32))
+#  define STDC
+#endif
+#if !defined(STDC) && (defined(OS2) || defined(__HOS_AIX__))
+#  define STDC
+#endif
+
+#if defined(__OS400__) && !defined(STDC)    /* iSeries (formerly AS/400). */
+#  define STDC
+#endif
+
+#ifndef STDC
+#  ifndef const /* cannot use !defined(STDC) && !defined(const) on Mac */
+#    define const       /* note: need a more gentle solution here */
+#  endif
+#endif
+
+/* Some Mac compilers merge all .h files incorrectly: */
+#if defined(__MWERKS__)||defined(applec)||defined(THINK_C)||defined(__SC__)
+#  define NO_DUMMY_DECL
+#endif
+
+/* Maximum value for memLevel in deflateInit2 */
+#ifndef MAX_MEM_LEVEL
+#  ifdef MAXSEG_64K
+#    define MAX_MEM_LEVEL 8
+#  else
+#    define MAX_MEM_LEVEL 9
+#  endif
+#endif
+
+/* Maximum value for windowBits in deflateInit2 and inflateInit2.
+ * WARNING: reducing MAX_WBITS makes minigzip unable to extract .gz files
+ * created by gzip. (Files created by minigzip can still be extracted by
+ * gzip.)
+ */
+#ifndef MAX_WBITS
+#  define MAX_WBITS   15 /* 32K LZ77 window */
+#endif
+
+/* The memory requirements for deflate are (in bytes):
+            (1 << (windowBits+2)) +  (1 << (memLevel+9))
+ that is: 128K for windowBits=15  +  128K for memLevel = 8  (default values)
+ plus a few kilobytes for small objects. For example, if you want to reduce
+ the default memory requirements from 256K to 128K, compile with
+     make CFLAGS="-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7"
+ Of course this will generally degrade compression (there's no free lunch).
+
+   The memory requirements for inflate are (in bytes) 1 << windowBits
+ that is, 32K for windowBits=15 (default value) plus a few kilobytes
+ for small objects.
+*/
+
+                        /* Type declarations */
+
+#ifndef OF /* function prototypes */
+#  ifdef STDC
+#    define OF(args)  args
+#  else
+#    define OF(args)  ()
+#  endif
+#endif
+
+/* The following definitions for FAR are needed only for MSDOS mixed
+ * model programming (small or medium model with some far allocations).
+ * This was tested only with MSC; for other MSDOS compilers you may have
+ * to define NO_MEMCPY in zutil.h.  If you don't need the mixed model,
+ * just define FAR to be empty.
+ */
+#ifdef SYS16BIT
+#  if defined(M_I86SM) || defined(M_I86MM)
+     /* MSC small or medium model */
+#    define SMALL_MEDIUM
+#    ifdef _MSC_VER
+#      define FAR _far
+#    else
+#      define FAR far
+#    endif
+#  endif
+#  if (defined(__SMALL__) || defined(__MEDIUM__))
+     /* Turbo C small or medium model */
+#    define SMALL_MEDIUM
+#    ifdef __BORLANDC__
+#      define FAR _far
+#    else
+#      define FAR far
+#    endif
+#  endif
+#endif
+
+#if defined(WINDOWS) || defined(WIN32)
+   /* If building or using zlib as a DLL, define ZLIB_DLL.
+    * This is not mandatory, but it offers a little performance increase.
+    */
+#  ifdef ZLIB_DLL
+#    if defined(WIN32) && (!defined(__BORLANDC__) || (__BORLANDC__ >= 0x500))
+#      ifdef ZLIB_INTERNAL
+#        define ZEXTERN extern __declspec(dllexport)
+#      else
+#        define ZEXTERN extern __declspec(dllimport)
+#      endif
+#    endif
+#  endif  /* ZLIB_DLL */
+   /* If building or using zlib with the WINAPI/WINAPIV calling convention,
+    * define ZLIB_WINAPI.
+    * Caution: the standard ZLIB1.DLL is NOT compiled using ZLIB_WINAPI.
+    */
+#  ifdef ZLIB_WINAPI
+#    ifdef FAR
+#      undef FAR
+#    endif
+#    include <windows.h>
+     /* No need for _export, use ZLIB.DEF instead. */
+     /* For complete Windows compatibility, use WINAPI, not __stdcall. */
+#    define ZEXPORT WINAPI
+#    ifdef WIN32
+#      define ZEXPORTVA WINAPIV
+#    else
+#      define ZEXPORTVA FAR CDECL
+#    endif
+#  endif
+#endif
+
+#if defined (__BEOS__)
+#  ifdef ZLIB_DLL
+#    ifdef ZLIB_INTERNAL
+#      define ZEXPORT   __declspec(dllexport)
+#      define ZEXPORTVA __declspec(dllexport)
+#    else
+#      define ZEXPORT   __declspec(dllimport)
+#      define ZEXPORTVA __declspec(dllimport)
+#    endif
+#  endif
+#endif
+
+#ifndef ZEXTERN
+#  define ZEXTERN extern
+#endif
+#ifndef ZEXPORT
+#  define ZEXPORT
+#endif
+#ifndef ZEXPORTVA
+#  define ZEXPORTVA
+#endif
+
+#ifndef FAR
+#  define FAR
+#endif
+
+#if !defined(__MACTYPES__)
+typedef unsigned char  Byte;  /* 8 bits */
+#endif
+typedef unsigned int   uInt;  /* 16 bits or more */
+typedef unsigned long  uLong; /* 32 bits or more */
+
+#ifdef SMALL_MEDIUM
+   /* Borland C/C++ and some old MSC versions ignore FAR inside typedef */
+#  define Bytef Byte FAR
+#else
+   typedef Byte  FAR Bytef;
+#endif
+typedef char  FAR charf;
+typedef int   FAR intf;
+typedef uInt  FAR uIntf;
+typedef uLong FAR uLongf;
+
+#ifdef STDC
+   typedef void const *voidpc;
+   typedef void FAR   *voidpf;
+   typedef void       *voidp;
+#else
+   typedef Byte const *voidpc;
+   typedef Byte FAR   *voidpf;
+   typedef Byte       *voidp;
+#endif
+
+#ifdef HAVE_UNISTD_H    /* may be set to #if 1 by ./configure */
+#  define Z_HAVE_UNISTD_H
+#endif
+
+#ifdef STDC
+#  include <sys/types.h>    /* for off_t */
+#endif
+
+/* a little trick to accommodate both "#define _LARGEFILE64_SOURCE" and
+ * "#define _LARGEFILE64_SOURCE 1" as requesting 64-bit operations, (even
+ * though the former does not conform to the LFS document), but considering
+ * both "#undef _LARGEFILE64_SOURCE" and "#define _LARGEFILE64_SOURCE 0" as
+ * equivalently requesting no 64-bit operations
+ */
+#if -_LARGEFILE64_SOURCE - -1 == 1
+#  undef _LARGEFILE64_SOURCE
+#endif
+
+#if defined(Z_HAVE_UNISTD_H) || defined(_LARGEFILE64_SOURCE)
+#  include <unistd.h>       /* for SEEK_* and off_t */
+#  ifdef VMS
+#    include <unixio.h>     /* for off_t */
+#  endif
+#  ifndef z_off_t
+#    define z_off_t off_t
+#  endif
+#endif
+
+#ifndef SEEK_SET
+#  define SEEK_SET        0       /* Seek from beginning of file.  */
+#  define SEEK_CUR        1       /* Seek from current position.  */
+#  define SEEK_END        2       /* Set file pointer to EOF plus "offset" */
+#endif
+
+#ifndef z_off_t
+#  define z_off_t long
+#endif
+
+#if defined(_LARGEFILE64_SOURCE) && _LFS64_LARGEFILE-0
+#  define z_off64_t off64_t
+#else
+#  define z_off64_t z_off_t
+#endif
+
+#if defined(__OS400__)
+#  define NO_vsnprintf
+#endif
+
+#if defined(__MVS__)
+#  define NO_vsnprintf
+#endif
+
+/* MVS linker does not support external names larger than 8 bytes */
+#if defined(__MVS__)
+  #pragma map(deflateInit_,"DEIN")
+  #pragma map(deflateInit2_,"DEIN2")
+  #pragma map(deflateEnd,"DEEND")
+  #pragma map(deflateBound,"DEBND")
+  #pragma map(inflateInit_,"ININ")
+  #pragma map(inflateInit2_,"ININ2")
+  #pragma map(inflateEnd,"INEND")
+  #pragma map(inflateSync,"INSY")
+  #pragma map(inflateSetDictionary,"INSEDI")
+  #pragma map(compressBound,"CMBND")
+  #pragma map(inflate_table,"INTABL")
+  #pragma map(inflate_fast,"INFA")
+  #pragma map(inflate_copyright,"INCOPY")
+#endif
+
+#endif /* ZCONF_H */
diff --git a/texk/web2c/luatexdir/luapplib/zlib/zlib.h b/texk/web2c/luatexdir/luapplib/zlib/zlib.h
new file mode 100644
index 000000000..bfbba83e8
--- /dev/null
+++ b/texk/web2c/luatexdir/luapplib/zlib/zlib.h
@@ -0,0 +1,1613 @@
+/* zlib.h -- interface of the 'zlib' general purpose compression library
+  version 1.2.5, April 19th, 2010
+
+  Copyright (C) 1995-2010 Jean-loup Gailly and Mark Adler
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+
+  Jean-loup Gailly        Mark Adler
+  jloup@gzip.org          madler@alumni.caltech.edu
+
+
+  The data format used by the zlib library is described by RFCs (Request for
+  Comments) 1950 to 1952 in the files http://www.ietf.org/rfc/rfc1950.txt
+  (zlib format), rfc1951.txt (deflate format) and rfc1952.txt (gzip format).
+*/
+
+#ifndef ZLIB_H
+#define ZLIB_H
+
+#include "zconf.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define ZLIB_VERSION "1.2.5"
+#define ZLIB_VERNUM 0x1250
+#define ZLIB_VER_MAJOR 1
+#define ZLIB_VER_MINOR 2
+#define ZLIB_VER_REVISION 5
+#define ZLIB_VER_SUBREVISION 0
+
+/*
+    The 'zlib' compression library provides in-memory compression and
+  decompression functions, including integrity checks of the uncompressed data.
+  This version of the library supports only one compression method (deflation)
+  but other algorithms will be added later and will have the same stream
+  interface.
+
+    Compression can be done in a single step if the buffers are large enough,
+  or can be done by repeated calls of the compression function.  In the latter
+  case, the application must provide more input and/or consume the output
+  (providing more output space) before each call.
+
+    The compressed data format used by default by the in-memory functions is
+  the zlib format, which is a zlib wrapper documented in RFC 1950, wrapped
+  around a deflate stream, which is itself documented in RFC 1951.
+
+    The library also supports reading and writing files in gzip (.gz) format
+  with an interface similar to that of stdio using the functions that start
+  with "gz".  The gzip format is different from the zlib format.  gzip is a
+  gzip wrapper, documented in RFC 1952, wrapped around a deflate stream.
+
+    This library can optionally read and write gzip streams in memory as well.
+
+    The zlib format was designed to be compact and fast for use in memory
+  and on communications channels.  The gzip format was designed for single-
+  file compression on file systems, has a larger header than zlib to maintain
+  directory information, and uses a different, slower check method than zlib.
+
+    The library does not install any signal handler.  The decoder checks
+  the consistency of the compressed data, so the library should never crash
+  even in case of corrupted input.
+*/
+
+typedef voidpf (*alloc_func) OF((voidpf opaque, uInt items, uInt size));
+typedef void   (*free_func)  OF((voidpf opaque, voidpf address));
+
+struct internal_state;
+
+typedef struct z_stream_s {
+    Bytef    *next_in;  /* next input byte */
+    uInt     avail_in;  /* number of bytes available at next_in */
+    uLong    total_in;  /* total nb of input bytes read so far */
+
+    Bytef    *next_out; /* next output byte should be put there */
+    uInt     avail_out; /* remaining free space at next_out */
+    uLong    total_out; /* total nb of bytes output so far */
+
+    char     *msg;      /* last error message, NULL if no error */
+    struct internal_state FAR *state; /* not visible by applications */
+
+    alloc_func zalloc;  /* used to allocate the internal state */
+    free_func  zfree;   /* used to free the internal state */
+    voidpf     opaque;  /* private data object passed to zalloc and zfree */
+
+    int     data_type;  /* best guess about the data type: binary or text */
+    uLong   adler;      /* adler32 value of the uncompressed data */
+    uLong   reserved;   /* reserved for future use */
+} z_stream;
+
+typedef z_stream FAR *z_streamp;
+
+/*
+     gzip header information passed to and from zlib routines.  See RFC 1952
+  for more details on the meanings of these fields.
+*/
+typedef struct gz_header_s {
+    int     text;       /* true if compressed data believed to be text */
+    uLong   time;       /* modification time */
+    int     xflags;     /* extra flags (not used when writing a gzip file) */
+    int     os;         /* operating system */
+    Bytef   *extra;     /* pointer to extra field or Z_NULL if none */
+    uInt    extra_len;  /* extra field length (valid if extra != Z_NULL) */
+    uInt    extra_max;  /* space at extra (only when reading header) */
+    Bytef   *name;      /* pointer to zero-terminated file name or Z_NULL */
+    uInt    name_max;   /* space at name (only when reading header) */
+    Bytef   *comment;   /* pointer to zero-terminated comment or Z_NULL */
+    uInt    comm_max;   /* space at comment (only when reading header) */
+    int     hcrc;       /* true if there was or will be a header crc */
+    int     done;       /* true when done reading gzip header (not used
+                           when writing a gzip file) */
+} gz_header;
+
+typedef gz_header FAR *gz_headerp;
+
+/*
+     The application must update next_in and avail_in when avail_in has dropped
+   to zero.  It must update next_out and avail_out when avail_out has dropped
+   to zero.  The application must initialize zalloc, zfree and opaque before
+   calling the init function.  All other fields are set by the compression
+   library and must not be updated by the application.
+
+     The opaque value provided by the application will be passed as the first
+   parameter for calls of zalloc and zfree.  This can be useful for custom
+   memory management.  The compression library attaches no meaning to the
+   opaque value.
+
+     zalloc must return Z_NULL if there is not enough memory for the object.
+   If zlib is used in a multi-threaded application, zalloc and zfree must be
+   thread safe.
+
+     On 16-bit systems, the functions zalloc and zfree must be able to allocate
+   exactly 65536 bytes, but will not be required to allocate more than this if
+   the symbol MAXSEG_64K is defined (see zconf.h).  WARNING: On MSDOS, pointers
+   returned by zalloc for objects of exactly 65536 bytes *must* have their
+   offset normalized to zero.  The default allocation function provided by this
+   library ensures this (see zutil.c).  To reduce memory requirements and avoid
+   any allocation of 64K objects, at the expense of compression ratio, compile
+   the library with -DMAX_WBITS=14 (see zconf.h).
+
+     The fields total_in and total_out can be used for statistics or progress
+   reports.  After compression, total_in holds the total size of the
+   uncompressed data and may be saved for use in the decompressor (particularly
+   if the decompressor wants to decompress everything in a single step).
+*/
+
+                        /* constants */
+
+#define Z_NO_FLUSH      0
+#define Z_PARTIAL_FLUSH 1
+#define Z_SYNC_FLUSH    2
+#define Z_FULL_FLUSH    3
+#define Z_FINISH        4
+#define Z_BLOCK         5
+#define Z_TREES         6
+/* Allowed flush values; see deflate() and inflate() below for details */
+
+#define Z_OK            0
+#define Z_STREAM_END    1
+#define Z_NEED_DICT     2
+#define Z_ERRNO        (-1)
+#define Z_STREAM_ERROR (-2)
+#define Z_DATA_ERROR   (-3)
+#define Z_MEM_ERROR    (-4)
+#define Z_BUF_ERROR    (-5)
+#define Z_VERSION_ERROR (-6)
+/* Return codes for the compression/decompression functions. Negative values
+ * are errors, positive values are used for special but normal events.
+ */
+
+#define Z_NO_COMPRESSION         0
+#define Z_BEST_SPEED             1
+#define Z_BEST_COMPRESSION       9
+#define Z_DEFAULT_COMPRESSION  (-1)
+/* compression levels */
+
+#define Z_FILTERED            1
+#define Z_HUFFMAN_ONLY        2
+#define Z_RLE                 3
+#define Z_FIXED               4
+#define Z_DEFAULT_STRATEGY    0
+/* compression strategy; see deflateInit2() below for details */
+
+#define Z_BINARY   0
+#define Z_TEXT     1
+#define Z_ASCII    Z_TEXT   /* for compatibility with 1.2.2 and earlier */
+#define Z_UNKNOWN  2
+/* Possible values of the data_type field (though see inflate()) */
+
+#define Z_DEFLATED   8
+/* The deflate compression method (the only one supported in this version) */
+
+#define Z_NULL  0  /* for initializing zalloc, zfree, opaque */
+
+#define zlib_version zlibVersion()
+/* for compatibility with versions < 1.0.2 */
+
+
+                        /* basic functions */
+
+ZEXTERN const char * ZEXPORT zlibVersion OF((void));
+/* The application can compare zlibVersion and ZLIB_VERSION for consistency.
+   If the first character differs, the library code actually used is not
+   compatible with the zlib.h header file used by the application.  This check
+   is automatically made by deflateInit and inflateInit.
+ */
+
+/*
+ZEXTERN int ZEXPORT deflateInit OF((z_streamp strm, int level));
+
+     Initializes the internal stream state for compression.  The fields
+   zalloc, zfree and opaque must be initialized before by the caller.  If
+   zalloc and zfree are set to Z_NULL, deflateInit updates them to use default
+   allocation functions.
+
+     The compression level must be Z_DEFAULT_COMPRESSION, or between 0 and 9:
+   1 gives best speed, 9 gives best compression, 0 gives no compression at all
+   (the input data is simply copied a block at a time).  Z_DEFAULT_COMPRESSION
+   requests a default compromise between speed and compression (currently
+   equivalent to level 6).
+
+     deflateInit returns Z_OK if success, Z_MEM_ERROR if there was not enough
+   memory, Z_STREAM_ERROR if level is not a valid compression level, or
+   Z_VERSION_ERROR if the zlib library version (zlib_version) is incompatible
+   with the version assumed by the caller (ZLIB_VERSION).  msg is set to null
+   if there is no error message.  deflateInit does not perform any compression:
+   this will be done by deflate().
+*/
+
+
+ZEXTERN int ZEXPORT deflate OF((z_streamp strm, int flush));
+/*
+    deflate compresses as much data as possible, and stops when the input
+  buffer becomes empty or the output buffer becomes full.  It may introduce
+  some output latency (reading input without producing any output) except when
+  forced to flush.
+
+    The detailed semantics are as follows.  deflate performs one or both of the
+  following actions:
+
+  - Compress more input starting at next_in and update next_in and avail_in
+    accordingly.  If not all input can be processed (because there is not
+    enough room in the output buffer), next_in and avail_in are updated and
+    processing will resume at this point for the next call of deflate().
+
+  - Provide more output starting at next_out and update next_out and avail_out
+    accordingly.  This action is forced if the parameter flush is non zero.
+    Forcing flush frequently degrades the compression ratio, so this parameter
+    should be set only when necessary (in interactive applications).  Some
+    output may be provided even if flush is not set.
+
+    Before the call of deflate(), the application should ensure that at least
+  one of the actions is possible, by providing more input and/or consuming more
+  output, and updating avail_in or avail_out accordingly; avail_out should
+  never be zero before the call.  The application can consume the compressed
+  output when it wants, for example when the output buffer is full (avail_out
+  == 0), or after each call of deflate().  If deflate returns Z_OK and with
+  zero avail_out, it must be called again after making room in the output
+  buffer because there might be more output pending.
+
+    Normally the parameter flush is set to Z_NO_FLUSH, which allows deflate to
+  decide how much data to accumulate before producing output, in order to
+  maximize compression.
+
+    If the parameter flush is set to Z_SYNC_FLUSH, all pending output is
+  flushed to the output buffer and the output is aligned on a byte boundary, so
+  that the decompressor can get all input data available so far.  (In
+  particular avail_in is zero after the call if enough output space has been
+  provided before the call.) Flushing may degrade compression for some
+  compression algorithms and so it should be used only when necessary.  This
+  completes the current deflate block and follows it with an empty stored block
+  that is three bits plus filler bits to the next byte, followed by four bytes
+  (00 00 ff ff).
+
+    If flush is set to Z_PARTIAL_FLUSH, all pending output is flushed to the
+  output buffer, but the output is not aligned to a byte boundary.  All of the
+  input data so far will be available to the decompressor, as for Z_SYNC_FLUSH.
+  This completes the current deflate block and follows it with an empty fixed
+  codes block that is 10 bits long.  This assures that enough bytes are output
+  in order for the decompressor to finish the block before the empty fixed code
+  block.
+
+    If flush is set to Z_BLOCK, a deflate block is completed and emitted, as
+  for Z_SYNC_FLUSH, but the output is not aligned on a byte boundary, and up to
+  seven bits of the current block are held to be written as the next byte after
+  the next deflate block is completed.  In this case, the decompressor may not
+  be provided enough bits at this point in order to complete decompression of
+  the data provided so far to the compressor.  It may need to wait for the next
+  block to be emitted.  This is for advanced applications that need to control
+  the emission of deflate blocks.
+
+    If flush is set to Z_FULL_FLUSH, all output is flushed as with
+  Z_SYNC_FLUSH, and the compression state is reset so that decompression can
+  restart from this point if previous compressed data has been damaged or if
+  random access is desired.  Using Z_FULL_FLUSH too often can seriously degrade
+  compression.
+
+    If deflate returns with avail_out == 0, this function must be called again
+  with the same value of the flush parameter and more output space (updated
+  avail_out), until the flush is complete (deflate returns with non-zero
+  avail_out).  In the case of a Z_FULL_FLUSH or Z_SYNC_FLUSH, make sure that
+  avail_out is greater than six to avoid repeated flush markers due to
+  avail_out == 0 on return.
+
+    If the parameter flush is set to Z_FINISH, pending input is processed,
+  pending output is flushed and deflate returns with Z_STREAM_END if there was
+  enough output space; if deflate returns with Z_OK, this function must be
+  called again with Z_FINISH and more output space (updated avail_out) but no
+  more input data, until it returns with Z_STREAM_END or an error.  After
+  deflate has returned Z_STREAM_END, the only possible operations on the stream
+  are deflateReset or deflateEnd.
+
+    Z_FINISH can be used immediately after deflateInit if all the compression
+  is to be done in a single step.  In this case, avail_out must be at least the
+  value returned by deflateBound (see below).  If deflate does not return
+  Z_STREAM_END, then it must be called again as described above.
+
+    deflate() sets strm->adler to the adler32 checksum of all input read
+  so far (that is, total_in bytes).
+
+    deflate() may update strm->data_type if it can make a good guess about
+  the input data type (Z_BINARY or Z_TEXT).  In doubt, the data is considered
+  binary.  This field is only for information purposes and does not affect the
+  compression algorithm in any manner.
+
+    deflate() returns Z_OK if some progress has been made (more input
+  processed or more output produced), Z_STREAM_END if all input has been
+  consumed and all output has been produced (only when flush is set to
+  Z_FINISH), Z_STREAM_ERROR if the stream state was inconsistent (for example
+  if next_in or next_out was Z_NULL), Z_BUF_ERROR if no progress is possible
+  (for example avail_in or avail_out was zero).  Note that Z_BUF_ERROR is not
+  fatal, and deflate() can be called again with more input and more output
+  space to continue compressing.
+*/
+
+
+ZEXTERN int ZEXPORT deflateEnd OF((z_streamp strm));
+/*
+     All dynamically allocated data structures for this stream are freed.
+   This function discards any unprocessed input and does not flush any pending
+   output.
+
+     deflateEnd returns Z_OK if success, Z_STREAM_ERROR if the
+   stream state was inconsistent, Z_DATA_ERROR if the stream was freed
+   prematurely (some input or output was discarded).  In the error case, msg
+   may be set but then points to a static string (which must not be
+   deallocated).
+*/
+
+
+/*
+ZEXTERN int ZEXPORT inflateInit OF((z_streamp strm));
+
+     Initializes the internal stream state for decompression.  The fields
+   next_in, avail_in, zalloc, zfree and opaque must be initialized before by
+   the caller.  If next_in is not Z_NULL and avail_in is large enough (the
+   exact value depends on the compression method), inflateInit determines the
+   compression method from the zlib header and allocates all data structures
+   accordingly; otherwise the allocation will be deferred to the first call of
+   inflate.  If zalloc and zfree are set to Z_NULL, inflateInit updates them to
+   use default allocation functions.
+
+     inflateInit returns Z_OK if success, Z_MEM_ERROR if there was not enough
+   memory, Z_VERSION_ERROR if the zlib library version is incompatible with the
+   version assumed by the caller, or Z_STREAM_ERROR if the parameters are
+   invalid, such as a null pointer to the structure.  msg is set to null if
+   there is no error message.  inflateInit does not perform any decompression
+   apart from possibly reading the zlib header if present: actual decompression
+   will be done by inflate().  (So next_in and avail_in may be modified, but
+   next_out and avail_out are unused and unchanged.) The current implementation
+   of inflateInit() does not process any header information -- that is deferred
+   until inflate() is called.
+*/
+
+
+ZEXTERN int ZEXPORT inflate OF((z_streamp strm, int flush));
+/*
+    inflate decompresses as much data as possible, and stops when the input
+  buffer becomes empty or the output buffer becomes full.  It may introduce
+  some output latency (reading input without producing any output) except when
+  forced to flush.
+
+  The detailed semantics are as follows.  inflate performs one or both of the
+  following actions:
+
+  - Decompress more input starting at next_in and update next_in and avail_in
+    accordingly.  If not all input can be processed (because there is not
+    enough room in the output buffer), next_in is updated and processing will
+    resume at this point for the next call of inflate().
+
+  - Provide more output starting at next_out and update next_out and avail_out
+    accordingly.  inflate() provides as much output as possible, until there is
+    no more input data or no more space in the output buffer (see below about
+    the flush parameter).
+
+    Before the call of inflate(), the application should ensure that at least
+  one of the actions is possible, by providing more input and/or consuming more
+  output, and updating the next_* and avail_* values accordingly.  The
+  application can consume the uncompressed output when it wants, for example
+  when the output buffer is full (avail_out == 0), or after each call of
+  inflate().  If inflate returns Z_OK and with zero avail_out, it must be
+  called again after making room in the output buffer because there might be
+  more output pending.
+
+    The flush parameter of inflate() can be Z_NO_FLUSH, Z_SYNC_FLUSH, Z_FINISH,
+  Z_BLOCK, or Z_TREES.  Z_SYNC_FLUSH requests that inflate() flush as much
+  output as possible to the output buffer.  Z_BLOCK requests that inflate()
+  stop if and when it gets to the next deflate block boundary.  When decoding
+  the zlib or gzip format, this will cause inflate() to return immediately
+  after the header and before the first block.  When doing a raw inflate,
+  inflate() will go ahead and process the first block, and will return when it
+  gets to the end of that block, or when it runs out of data.
+
+    The Z_BLOCK option assists in appending to or combining deflate streams.
+  Also to assist in this, on return inflate() will set strm->data_type to the
+  number of unused bits in the last byte taken from strm->next_in, plus 64 if
+  inflate() is currently decoding the last block in the deflate stream, plus
+  128 if inflate() returned immediately after decoding an end-of-block code or
+  decoding the complete header up to just before the first byte of the deflate
+  stream.  The end-of-block will not be indicated until all of the uncompressed
+  data from that block has been written to strm->next_out.  The number of
+  unused bits may in general be greater than seven, except when bit 7 of
+  data_type is set, in which case the number of unused bits will be less than
+  eight.  data_type is set as noted here every time inflate() returns for all
+  flush options, and so can be used to determine the amount of currently
+  consumed input in bits.
+
+    The Z_TREES option behaves as Z_BLOCK does, but it also returns when the
+  end of each deflate block header is reached, before any actual data in that
+  block is decoded.  This allows the caller to determine the length of the
+  deflate block header for later use in random access within a deflate block.
+  256 is added to the value of strm->data_type when inflate() returns
+  immediately after reaching the end of the deflate block header.
+
+    inflate() should normally be called until it returns Z_STREAM_END or an
+  error.  However if all decompression is to be performed in a single step (a
+  single call of inflate), the parameter flush should be set to Z_FINISH.  In
+  this case all pending input is processed and all pending output is flushed;
+  avail_out must be large enough to hold all the uncompressed data.  (The size
+  of the uncompressed data may have been saved by the compressor for this
+  purpose.) The next operation on this stream must be inflateEnd to deallocate
+  the decompression state.  The use of Z_FINISH is never required, but can be
+  used to inform inflate that a faster approach may be used for the single
+  inflate() call.
+
+     In this implementation, inflate() always flushes as much output as
+  possible to the output buffer, and always uses the faster approach on the
+  first call.  So the only effect of the flush parameter in this implementation
+  is on the return value of inflate(), as noted below, or when it returns early
+  because Z_BLOCK or Z_TREES is used.
+
+     If a preset dictionary is needed after this call (see inflateSetDictionary
+  below), inflate sets strm->adler to the adler32 checksum of the dictionary
+  chosen by the compressor and returns Z_NEED_DICT; otherwise it sets
+  strm->adler to the adler32 checksum of all output produced so far (that is,
+  total_out bytes) and returns Z_OK, Z_STREAM_END or an error code as described
+  below.  At the end of the stream, inflate() checks that its computed adler32
+  checksum is equal to that saved by the compressor and returns Z_STREAM_END
+  only if the checksum is correct.
+
+    inflate() can decompress and check either zlib-wrapped or gzip-wrapped
+  deflate data.  The header type is detected automatically, if requested when
+  initializing with inflateInit2().  Any information contained in the gzip
+  header is not retained, so applications that need that information should
+  instead use raw inflate, see inflateInit2() below, or inflateBack() and
+  perform their own processing of the gzip header and trailer.
+
+    inflate() returns Z_OK if some progress has been made (more input processed
+  or more output produced), Z_STREAM_END if the end of the compressed data has
+  been reached and all uncompressed output has been produced, Z_NEED_DICT if a
+  preset dictionary is needed at this point, Z_DATA_ERROR if the input data was
+  corrupted (input stream not conforming to the zlib format or incorrect check
+  value), Z_STREAM_ERROR if the stream structure was inconsistent (for example
+  next_in or next_out was Z_NULL), Z_MEM_ERROR if there was not enough memory,
+  Z_BUF_ERROR if no progress is possible or if there was not enough room in the
+  output buffer when Z_FINISH is used.  Note that Z_BUF_ERROR is not fatal, and
+  inflate() can be called again with more input and more output space to
+  continue decompressing.  If Z_DATA_ERROR is returned, the application may
+  then call inflateSync() to look for a good compression block if a partial
+  recovery of the data is desired.
+*/
+
+
+ZEXTERN int ZEXPORT inflateEnd OF((z_streamp strm));
+/*
+     All dynamically allocated data structures for this stream are freed.
+   This function discards any unprocessed input and does not flush any pending
+   output.
+
+     inflateEnd returns Z_OK if success, Z_STREAM_ERROR if the stream state
+   was inconsistent.  In the error case, msg may be set but then points to a
+   static string (which must not be deallocated).
+*/
+
+
+                        /* Advanced functions */
+
+/*
+    The following functions are needed only in some special applications.
+*/
+
+/*
+ZEXTERN int ZEXPORT deflateInit2 OF((z_streamp strm,
+                                     int  level,
+                                     int  method,
+                                     int  windowBits,
+                                     int  memLevel,
+                                     int  strategy));
+
+     This is another version of deflateInit with more compression options.  The
+   fields next_in, zalloc, zfree and opaque must be initialized before by the
+   caller.
+
+     The method parameter is the compression method.  It must be Z_DEFLATED in
+   this version of the library.
+
+     The windowBits parameter is the base two logarithm of the window size
+   (the size of the history buffer).  It should be in the range 8..15 for this
+   version of the library.  Larger values of this parameter result in better
+   compression at the expense of memory usage.  The default value is 15 if
+   deflateInit is used instead.
+
+     windowBits can also be -8..-15 for raw deflate.  In this case, -windowBits
+   determines the window size.  deflate() will then generate raw deflate data
+   with no zlib header or trailer, and will not compute an adler32 check value.
+
+     windowBits can also be greater than 15 for optional gzip encoding.  Add
+   16 to windowBits to write a simple gzip header and trailer around the
+   compressed data instead of a zlib wrapper.  The gzip header will have no
+   file name, no extra data, no comment, no modification time (set to zero), no
+   header crc, and the operating system will be set to 255 (unknown).  If a
+   gzip stream is being written, strm->adler is a crc32 instead of an adler32.
+
+     The memLevel parameter specifies how much memory should be allocated
+   for the internal compression state.  memLevel=1 uses minimum memory but is
+   slow and reduces compression ratio; memLevel=9 uses maximum memory for
+   optimal speed.  The default value is 8.  See zconf.h for total memory usage
+   as a function of windowBits and memLevel.
+
+     The strategy parameter is used to tune the compression algorithm.  Use the
+   value Z_DEFAULT_STRATEGY for normal data, Z_FILTERED for data produced by a
+   filter (or predictor), Z_HUFFMAN_ONLY to force Huffman encoding only (no
+   string match), or Z_RLE to limit match distances to one (run-length
+   encoding).  Filtered data consists mostly of small values with a somewhat
+   random distribution.  In this case, the compression algorithm is tuned to
+   compress them better.  The effect of Z_FILTERED is to force more Huffman
+   coding and less string matching; it is somewhat intermediate between
+   Z_DEFAULT_STRATEGY and Z_HUFFMAN_ONLY.  Z_RLE is designed to be almost as
+   fast as Z_HUFFMAN_ONLY, but give better compression for PNG image data.  The
+   strategy parameter only affects the compression ratio but not the
+   correctness of the compressed output even if it is not set appropriately.
+   Z_FIXED prevents the use of dynamic Huffman codes, allowing for a simpler
+   decoder for special applications.
+
+     deflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
+   memory, Z_STREAM_ERROR if any parameter is invalid (such as an invalid
+   method), or Z_VERSION_ERROR if the zlib library version (zlib_version) is
+   incompatible with the version assumed by the caller (ZLIB_VERSION).  msg is
+   set to null if there is no error message.  deflateInit2 does not perform any
+   compression: this will be done by deflate().
+*/
+
+ZEXTERN int ZEXPORT deflateSetDictionary OF((z_streamp strm,
+                                             const Bytef *dictionary,
+                                             uInt  dictLength));
+/*
+     Initializes the compression dictionary from the given byte sequence
+   without producing any compressed output.  This function must be called
+   immediately after deflateInit, deflateInit2 or deflateReset, before any call
+   of deflate.  The compressor and decompressor must use exactly the same
+   dictionary (see inflateSetDictionary).
+
+     The dictionary should consist of strings (byte sequences) that are likely
+   to be encountered later in the data to be compressed, with the most commonly
+   used strings preferably put towards the end of the dictionary.  Using a
+   dictionary is most useful when the data to be compressed is short and can be
+   predicted with good accuracy; the data can then be compressed better than
+   with the default empty dictionary.
+
+     Depending on the size of the compression data structures selected by
+   deflateInit or deflateInit2, a part of the dictionary may in effect be
+   discarded, for example if the dictionary is larger than the window size
+   provided in deflateInit or deflateInit2.  Thus the strings most likely to be
+   useful should be put at the end of the dictionary, not at the front.  In
+   addition, the current implementation of deflate will use at most the window
+   size minus 262 bytes of the provided dictionary.
+
+     Upon return of this function, strm->adler is set to the adler32 value
+   of the dictionary; the decompressor may later use this value to determine
+   which dictionary has been used by the compressor.  (The adler32 value
+   applies to the whole dictionary even if only a subset of the dictionary is
+   actually used by the compressor.) If a raw deflate was requested, then the
+   adler32 value is not computed and strm->adler is not set.
+
+     deflateSetDictionary returns Z_OK if success, or Z_STREAM_ERROR if a
+   parameter is invalid (e.g.  dictionary being Z_NULL) or the stream state is
+   inconsistent (for example if deflate has already been called for this stream
+   or if the compression method is bsort).  deflateSetDictionary does not
+   perform any compression: this will be done by deflate().
+*/
+
+ZEXTERN int ZEXPORT deflateCopy OF((z_streamp dest,
+                                    z_streamp source));
+/*
+     Sets the destination stream as a complete copy of the source stream.
+
+     This function can be useful when several compression strategies will be
+   tried, for example when there are several ways of pre-processing the input
+   data with a filter.  The streams that will be discarded should then be freed
+   by calling deflateEnd.  Note that deflateCopy duplicates the internal
+   compression state which can be quite large, so this strategy is slow and can
+   consume lots of memory.
+
+     deflateCopy returns Z_OK if success, Z_MEM_ERROR if there was not
+   enough memory, Z_STREAM_ERROR if the source stream state was inconsistent
+   (such as zalloc being Z_NULL).  msg is left unchanged in both source and
+   destination.
+*/
+
+ZEXTERN int ZEXPORT deflateReset OF((z_streamp strm));
+/*
+     This function is equivalent to deflateEnd followed by deflateInit,
+   but does not free and reallocate all the internal compression state.  The
+   stream will keep the same compression level and any other attributes that
+   may have been set by deflateInit2.
+
+     deflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source
+   stream state was inconsistent (such as zalloc or state being Z_NULL).
+*/
+
+ZEXTERN int ZEXPORT deflateParams OF((z_streamp strm,
+                                      int level,
+                                      int strategy));
+/*
+     Dynamically update the compression level and compression strategy.  The
+   interpretation of level and strategy is as in deflateInit2.  This can be
+   used to switch between compression and straight copy of the input data, or
+   to switch to a different kind of input data requiring a different strategy.
+   If the compression level is changed, the input available so far is
+   compressed with the old level (and may be flushed); the new level will take
+   effect only at the next call of deflate().
+
+     Before the call of deflateParams, the stream state must be set as for
+   a call of deflate(), since the currently available input may have to be
+   compressed and flushed.  In particular, strm->avail_out must be non-zero.
+
+     deflateParams returns Z_OK if success, Z_STREAM_ERROR if the source
+   stream state was inconsistent or if a parameter was invalid, Z_BUF_ERROR if
+   strm->avail_out was zero.
+*/
+
+ZEXTERN int ZEXPORT deflateTune OF((z_streamp strm,
+                                    int good_length,
+                                    int max_lazy,
+                                    int nice_length,
+                                    int max_chain));
+/*
+     Fine tune deflate's internal compression parameters.  This should only be
+   used by someone who understands the algorithm used by zlib's deflate for
+   searching for the best matching string, and even then only by the most
+   fanatic optimizer trying to squeeze out the last compressed bit for their
+   specific input data.  Read the deflate.c source code for the meaning of the
+   max_lazy, good_length, nice_length, and max_chain parameters.
+
+     deflateTune() can be called after deflateInit() or deflateInit2(), and
+   returns Z_OK on success, or Z_STREAM_ERROR for an invalid deflate stream.
+ */
+
+ZEXTERN uLong ZEXPORT deflateBound OF((z_streamp strm,
+                                       uLong sourceLen));
+/*
+     deflateBound() returns an upper bound on the compressed size after
+   deflation of sourceLen bytes.  It must be called after deflateInit() or
+   deflateInit2(), and after deflateSetHeader(), if used.  This would be used
+   to allocate an output buffer for deflation in a single pass, and so would be
+   called before deflate().
+*/
+
+ZEXTERN int ZEXPORT deflatePrime OF((z_streamp strm,
+                                     int bits,
+                                     int value));
+/*
+     deflatePrime() inserts bits in the deflate output stream.  The intent
+   is that this function is used to start off the deflate output with the bits
+   leftover from a previous deflate stream when appending to it.  As such, this
+   function can only be used for raw deflate, and must be used before the first
+   deflate() call after a deflateInit2() or deflateReset().  bits must be less
+   than or equal to 16, and that many of the least significant bits of value
+   will be inserted in the output.
+
+     deflatePrime returns Z_OK if success, or Z_STREAM_ERROR if the source
+   stream state was inconsistent.
+*/
+
+ZEXTERN int ZEXPORT deflateSetHeader OF((z_streamp strm,
+                                         gz_headerp head));
+/*
+     deflateSetHeader() provides gzip header information for when a gzip
+   stream is requested by deflateInit2().  deflateSetHeader() may be called
+   after deflateInit2() or deflateReset() and before the first call of
+   deflate().  The text, time, os, extra field, name, and comment information
+   in the provided gz_header structure are written to the gzip header (xflag is
+   ignored -- the extra flags are set according to the compression level).  The
+   caller must assure that, if not Z_NULL, name and comment are terminated with
+   a zero byte, and that if extra is not Z_NULL, that extra_len bytes are
+   available there.  If hcrc is true, a gzip header crc is included.  Note that
+   the current versions of the command-line version of gzip (up through version
+   1.3.x) do not support header crc's, and will report that it is a "multi-part
+   gzip file" and give up.
+
+     If deflateSetHeader is not used, the default gzip header has text false,
+   the time set to zero, and os set to 255, with no extra, name, or comment
+   fields.  The gzip header is returned to the default state by deflateReset().
+
+     deflateSetHeader returns Z_OK if success, or Z_STREAM_ERROR if the source
+   stream state was inconsistent.
+*/
+
+/*
+ZEXTERN int ZEXPORT inflateInit2 OF((z_streamp strm,
+                                     int  windowBits));
+
+     This is another version of inflateInit with an extra parameter.  The
+   fields next_in, avail_in, zalloc, zfree and opaque must be initialized
+   before by the caller.
+
+     The windowBits parameter is the base two logarithm of the maximum window
+   size (the size of the history buffer).  It should be in the range 8..15 for
+   this version of the library.  The default value is 15 if inflateInit is used
+   instead.  windowBits must be greater than or equal to the windowBits value
+   provided to deflateInit2() while compressing, or it must be equal to 15 if
+   deflateInit2() was not used.  If a compressed stream with a larger window
+   size is given as input, inflate() will return with the error code
+   Z_DATA_ERROR instead of trying to allocate a larger window.
+
+     windowBits can also be zero to request that inflate use the window size in
+   the zlib header of the compressed stream.
+
+     windowBits can also be -8..-15 for raw inflate.  In this case, -windowBits
+   determines the window size.  inflate() will then process raw deflate data,
+   not looking for a zlib or gzip header, not generating a check value, and not
+   looking for any check values for comparison at the end of the stream.  This
+   is for use with other formats that use the deflate compressed data format
+   such as zip.  Those formats provide their own check values.  If a custom
+   format is developed using the raw deflate format for compressed data, it is
+   recommended that a check value such as an adler32 or a crc32 be applied to
+   the uncompressed data as is done in the zlib, gzip, and zip formats.  For
+   most applications, the zlib format should be used as is.  Note that comments
+   above on the use in deflateInit2() applies to the magnitude of windowBits.
+
+     windowBits can also be greater than 15 for optional gzip decoding.  Add
+   32 to windowBits to enable zlib and gzip decoding with automatic header
+   detection, or add 16 to decode only the gzip format (the zlib format will
+   return a Z_DATA_ERROR).  If a gzip stream is being decoded, strm->adler is a
+   crc32 instead of an adler32.
+
+     inflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
+   memory, Z_VERSION_ERROR if the zlib library version is incompatible with the
+   version assumed by the caller, or Z_STREAM_ERROR if the parameters are
+   invalid, such as a null pointer to the structure.  msg is set to null if
+   there is no error message.  inflateInit2 does not perform any decompression
+   apart from possibly reading the zlib header if present: actual decompression
+   will be done by inflate().  (So next_in and avail_in may be modified, but
+   next_out and avail_out are unused and unchanged.) The current implementation
+   of inflateInit2() does not process any header information -- that is
+   deferred until inflate() is called.
+*/
+
+ZEXTERN int ZEXPORT inflateSetDictionary OF((z_streamp strm,
+                                             const Bytef *dictionary,
+                                             uInt  dictLength));
+/*
+     Initializes the decompression dictionary from the given uncompressed byte
+   sequence.  This function must be called immediately after a call of inflate,
+   if that call returned Z_NEED_DICT.  The dictionary chosen by the compressor
+   can be determined from the adler32 value returned by that call of inflate.
+   The compressor and decompressor must use exactly the same dictionary (see
+   deflateSetDictionary).  For raw inflate, this function can be called
+   immediately after inflateInit2() or inflateReset() and before any call of
+   inflate() to set the dictionary.  The application must insure that the
+   dictionary that was used for compression is provided.
+
+     inflateSetDictionary returns Z_OK if success, Z_STREAM_ERROR if a
+   parameter is invalid (e.g.  dictionary being Z_NULL) or the stream state is
+   inconsistent, Z_DATA_ERROR if the given dictionary doesn't match the
+   expected one (incorrect adler32 value).  inflateSetDictionary does not
+   perform any decompression: this will be done by subsequent calls of
+   inflate().
+*/
+
+ZEXTERN int ZEXPORT inflateSync OF((z_streamp strm));
+/*
+     Skips invalid compressed data until a full flush point (see above the
+   description of deflate with Z_FULL_FLUSH) can be found, or until all
+   available input is skipped.  No output is provided.
+
+     inflateSync returns Z_OK if a full flush point has been found, Z_BUF_ERROR
+   if no more input was provided, Z_DATA_ERROR if no flush point has been
+   found, or Z_STREAM_ERROR if the stream structure was inconsistent.  In the
+   success case, the application may save the current current value of total_in
+   which indicates where valid compressed data was found.  In the error case,
+   the application may repeatedly call inflateSync, providing more input each
+   time, until success or end of the input data.
+*/
+
+ZEXTERN int ZEXPORT inflateCopy OF((z_streamp dest,
+                                    z_streamp source));
+/*
+     Sets the destination stream as a complete copy of the source stream.
+
+     This function can be useful when randomly accessing a large stream.  The
+   first pass through the stream can periodically record the inflate state,
+   allowing restarting inflate at those points when randomly accessing the
+   stream.
+
+     inflateCopy returns Z_OK if success, Z_MEM_ERROR if there was not
+   enough memory, Z_STREAM_ERROR if the source stream state was inconsistent
+   (such as zalloc being Z_NULL).  msg is left unchanged in both source and
+   destination.
+*/
+
+ZEXTERN int ZEXPORT inflateReset OF((z_streamp strm));
+/*
+     This function is equivalent to inflateEnd followed by inflateInit,
+   but does not free and reallocate all the internal decompression state.  The
+   stream will keep attributes that may have been set by inflateInit2.
+
+     inflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source
+   stream state was inconsistent (such as zalloc or state being Z_NULL).
+*/
+
+ZEXTERN int ZEXPORT inflateReset2 OF((z_streamp strm,
+                                      int windowBits));
+/*
+     This function is the same as inflateReset, but it also permits changing
+   the wrap and window size requests.  The windowBits parameter is interpreted
+   the same as it is for inflateInit2.
+
+     inflateReset2 returns Z_OK if success, or Z_STREAM_ERROR if the source
+   stream state was inconsistent (such as zalloc or state being Z_NULL), or if
+   the windowBits parameter is invalid.
+*/
+
+ZEXTERN int ZEXPORT inflatePrime OF((z_streamp strm,
+                                     int bits,
+                                     int value));
+/*
+     This function inserts bits in the inflate input stream.  The intent is
+   that this function is used to start inflating at a bit position in the
+   middle of a byte.  The provided bits will be used before any bytes are used
+   from next_in.  This function should only be used with raw inflate, and
+   should be used before the first inflate() call after inflateInit2() or
+   inflateReset().  bits must be less than or equal to 16, and that many of the
+   least significant bits of value will be inserted in the input.
+
+     If bits is negative, then the input stream bit buffer is emptied.  Then
+   inflatePrime() can be called again to put bits in the buffer.  This is used
+   to clear out bits leftover after feeding inflate a block description prior
+   to feeding inflate codes.
+
+     inflatePrime returns Z_OK if success, or Z_STREAM_ERROR if the source
+   stream state was inconsistent.
+*/
+
+ZEXTERN long ZEXPORT inflateMark OF((z_streamp strm));
+/*
+     This function returns two values, one in the lower 16 bits of the return
+   value, and the other in the remaining upper bits, obtained by shifting the
+   return value down 16 bits.  If the upper value is -1 and the lower value is
+   zero, then inflate() is currently decoding information outside of a block.
+   If the upper value is -1 and the lower value is non-zero, then inflate is in
+   the middle of a stored block, with the lower value equaling the number of
+   bytes from the input remaining to copy.  If the upper value is not -1, then
+   it is the number of bits back from the current bit position in the input of
+   the code (literal or length/distance pair) currently being processed.  In
+   that case the lower value is the number of bytes already emitted for that
+   code.
+
+     A code is being processed if inflate is waiting for more input to complete
+   decoding of the code, or if it has completed decoding but is waiting for
+   more output space to write the literal or match data.
+
+     inflateMark() is used to mark locations in the input data for random
+   access, which may be at bit positions, and to note those cases where the
+   output of a code may span boundaries of random access blocks.  The current
+   location in the input stream can be determined from avail_in and data_type
+   as noted in the description for the Z_BLOCK flush parameter for inflate.
+
+     inflateMark returns the value noted above or -1 << 16 if the provided
+   source stream state was inconsistent.
+*/
+
+ZEXTERN int ZEXPORT inflateGetHeader OF((z_streamp strm,
+                                         gz_headerp head));
+/*
+     inflateGetHeader() requests that gzip header information be stored in the
+   provided gz_header structure.  inflateGetHeader() may be called after
+   inflateInit2() or inflateReset(), and before the first call of inflate().
+   As inflate() processes the gzip stream, head->done is zero until the header
+   is completed, at which time head->done is set to one.  If a zlib stream is
+   being decoded, then head->done is set to -1 to indicate that there will be
+   no gzip header information forthcoming.  Note that Z_BLOCK or Z_TREES can be
+   used to force inflate() to return immediately after header processing is
+   complete and before any actual data is decompressed.
+
+     The text, time, xflags, and os fields are filled in with the gzip header
+   contents.  hcrc is set to true if there is a header CRC.  (The header CRC
+   was valid if done is set to one.) If extra is not Z_NULL, then extra_max
+   contains the maximum number of bytes to write to extra.  Once done is true,
+   extra_len contains the actual extra field length, and extra contains the
+   extra field, or that field truncated if extra_max is less than extra_len.
+   If name is not Z_NULL, then up to name_max characters are written there,
+   terminated with a zero unless the length is greater than name_max.  If
+   comment is not Z_NULL, then up to comm_max characters are written there,
+   terminated with a zero unless the length is greater than comm_max.  When any
+   of extra, name, or comment are not Z_NULL and the respective field is not
+   present in the header, then that field is set to Z_NULL to signal its
+   absence.  This allows the use of deflateSetHeader() with the returned
+   structure to duplicate the header.  However if those fields are set to
+   allocated memory, then the application will need to save those pointers
+   elsewhere so that they can be eventually freed.
+
+     If inflateGetHeader is not used, then the header information is simply
+   discarded.  The header is always checked for validity, including the header
+   CRC if present.  inflateReset() will reset the process to discard the header
+   information.  The application would need to call inflateGetHeader() again to
+   retrieve the header from the next gzip stream.
+
+     inflateGetHeader returns Z_OK if success, or Z_STREAM_ERROR if the source
+   stream state was inconsistent.
+*/
+
+/*
+ZEXTERN int ZEXPORT inflateBackInit OF((z_streamp strm, int windowBits,
+                                        unsigned char FAR *window));
+
+     Initialize the internal stream state for decompression using inflateBack()
+   calls.  The fields zalloc, zfree and opaque in strm must be initialized
+   before the call.  If zalloc and zfree are Z_NULL, then the default library-
+   derived memory allocation routines are used.  windowBits is the base two
+   logarithm of the window size, in the range 8..15.  window is a caller
+   supplied buffer of that size.  Except for special applications where it is
+   assured that deflate was used with small window sizes, windowBits must be 15
+   and a 32K byte window must be supplied to be able to decompress general
+   deflate streams.
+
+     See inflateBack() for the usage of these routines.
+
+     inflateBackInit will return Z_OK on success, Z_STREAM_ERROR if any of
+   the paramaters are invalid, Z_MEM_ERROR if the internal state could not be
+   allocated, or Z_VERSION_ERROR if the version of the library does not match
+   the version of the header file.
+*/
+
+typedef unsigned (*in_func) OF((void FAR *, unsigned char FAR * FAR *));
+typedef int (*out_func) OF((void FAR *, unsigned char FAR *, unsigned));
+
+ZEXTERN int ZEXPORT inflateBack OF((z_streamp strm,
+                                    in_func in, void FAR *in_desc,
+                                    out_func out, void FAR *out_desc));
+/*
+     inflateBack() does a raw inflate with a single call using a call-back
+   interface for input and output.  This is more efficient than inflate() for
+   file i/o applications in that it avoids copying between the output and the
+   sliding window by simply making the window itself the output buffer.  This
+   function trusts the application to not change the output buffer passed by
+   the output function, at least until inflateBack() returns.
+
+     inflateBackInit() must be called first to allocate the internal state
+   and to initialize the state with the user-provided window buffer.
+   inflateBack() may then be used multiple times to inflate a complete, raw
+   deflate stream with each call.  inflateBackEnd() is then called to free the
+   allocated state.
+
+     A raw deflate stream is one with no zlib or gzip header or trailer.
+   This routine would normally be used in a utility that reads zip or gzip
+   files and writes out uncompressed files.  The utility would decode the
+   header and process the trailer on its own, hence this routine expects only
+   the raw deflate stream to decompress.  This is different from the normal
+   behavior of inflate(), which expects either a zlib or gzip header and
+   trailer around the deflate stream.
+
+     inflateBack() uses two subroutines supplied by the caller that are then
+   called by inflateBack() for input and output.  inflateBack() calls those
+   routines until it reads a complete deflate stream and writes out all of the
+   uncompressed data, or until it encounters an error.  The function's
+   parameters and return types are defined above in the in_func and out_func
+   typedefs.  inflateBack() will call in(in_desc, &buf) which should return the
+   number of bytes of provided input, and a pointer to that input in buf.  If
+   there is no input available, in() must return zero--buf is ignored in that
+   case--and inflateBack() will return a buffer error.  inflateBack() will call
+   out(out_desc, buf, len) to write the uncompressed data buf[0..len-1].  out()
+   should return zero on success, or non-zero on failure.  If out() returns
+   non-zero, inflateBack() will return with an error.  Neither in() nor out()
+   are permitted to change the contents of the window provided to
+   inflateBackInit(), which is also the buffer that out() uses to write from.
+   The length written by out() will be at most the window size.  Any non-zero
+   amount of input may be provided by in().
+
+     For convenience, inflateBack() can be provided input on the first call by
+   setting strm->next_in and strm->avail_in.  If that input is exhausted, then
+   in() will be called.  Therefore strm->next_in must be initialized before
+   calling inflateBack().  If strm->next_in is Z_NULL, then in() will be called
+   immediately for input.  If strm->next_in is not Z_NULL, then strm->avail_in
+   must also be initialized, and then if strm->avail_in is not zero, input will
+   initially be taken from strm->next_in[0 ..  strm->avail_in - 1].
+
+     The in_desc and out_desc parameters of inflateBack() is passed as the
+   first parameter of in() and out() respectively when they are called.  These
+   descriptors can be optionally used to pass any information that the caller-
+   supplied in() and out() functions need to do their job.
+
+     On return, inflateBack() will set strm->next_in and strm->avail_in to
+   pass back any unused input that was provided by the last in() call.  The
+   return values of inflateBack() can be Z_STREAM_END on success, Z_BUF_ERROR
+   if in() or out() returned an error, Z_DATA_ERROR if there was a format error
+   in the deflate stream (in which case strm->msg is set to indicate the nature
+   of the error), or Z_STREAM_ERROR if the stream was not properly initialized.
+   In the case of Z_BUF_ERROR, an input or output error can be distinguished
+   using strm->next_in which will be Z_NULL only if in() returned an error.  If
+   strm->next_in is not Z_NULL, then the Z_BUF_ERROR was due to out() returning
+   non-zero.  (in() will always be called before out(), so strm->next_in is
+   assured to be defined if out() returns non-zero.) Note that inflateBack()
+   cannot return Z_OK.
+*/
+
+ZEXTERN int ZEXPORT inflateBackEnd OF((z_streamp strm));
+/*
+     All memory allocated by inflateBackInit() is freed.
+
+     inflateBackEnd() returns Z_OK on success, or Z_STREAM_ERROR if the stream
+   state was inconsistent.
+*/
+
+ZEXTERN uLong ZEXPORT zlibCompileFlags OF((void));
+/* Return flags indicating compile-time options.
+
+    Type sizes, two bits each, 00 = 16 bits, 01 = 32, 10 = 64, 11 = other:
+     1.0: size of uInt
+     3.2: size of uLong
+     5.4: size of voidpf (pointer)
+     7.6: size of z_off_t
+
+    Compiler, assembler, and debug options:
+     8: DEBUG
+     9: ASMV or ASMINF -- use ASM code
+     10: ZLIB_WINAPI -- exported functions use the WINAPI calling convention
+     11: 0 (reserved)
+
+    One-time table building (smaller code, but not thread-safe if true):
+     12: BUILDFIXED -- build static block decoding tables when needed
+     13: DYNAMIC_CRC_TABLE -- build CRC calculation tables when needed
+     14,15: 0 (reserved)
+
+    Library content (indicates missing functionality):
+     16: NO_GZCOMPRESS -- gz* functions cannot compress (to avoid linking
+                          deflate code when not needed)
+     17: NO_GZIP -- deflate can't write gzip streams, and inflate can't detect
+                    and decode gzip streams (to avoid linking crc code)
+     18-19: 0 (reserved)
+
+    Operation variations (changes in library functionality):
+     20: PKZIP_BUG_WORKAROUND -- slightly more permissive inflate
+     21: FASTEST -- deflate algorithm with only one, lowest compression level
+     22,23: 0 (reserved)
+
+    The sprintf variant used by gzprintf (zero is best):
+     24: 0 = vs*, 1 = s* -- 1 means limited to 20 arguments after the format
+     25: 0 = *nprintf, 1 = *printf -- 1 means gzprintf() not secure!
+     26: 0 = returns value, 1 = void -- 1 means inferred string length returned
+
+    Remainder:
+     27-31: 0 (reserved)
+ */
+
+
+                        /* utility functions */
+
+/*
+     The following utility functions are implemented on top of the basic
+   stream-oriented functions.  To simplify the interface, some default options
+   are assumed (compression level and memory usage, standard memory allocation
+   functions).  The source code of these utility functions can be modified if
+   you need special options.
+*/
+
+ZEXTERN int ZEXPORT compress OF((Bytef *dest,   uLongf *destLen,
+                                 const Bytef *source, uLong sourceLen));
+/*
+     Compresses the source buffer into the destination buffer.  sourceLen is
+   the byte length of the source buffer.  Upon entry, destLen is the total size
+   of the destination buffer, which must be at least the value returned by
+   compressBound(sourceLen).  Upon exit, destLen is the actual size of the
+   compressed buffer.
+
+     compress returns Z_OK if success, Z_MEM_ERROR if there was not
+   enough memory, Z_BUF_ERROR if there was not enough room in the output
+   buffer.
+*/
+
+ZEXTERN int ZEXPORT compress2 OF((Bytef *dest,   uLongf *destLen,
+                                  const Bytef *source, uLong sourceLen,
+                                  int level));
+/*
+     Compresses the source buffer into the destination buffer.  The level
+   parameter has the same meaning as in deflateInit.  sourceLen is the byte
+   length of the source buffer.  Upon entry, destLen is the total size of the
+   destination buffer, which must be at least the value returned by
+   compressBound(sourceLen).  Upon exit, destLen is the actual size of the
+   compressed buffer.
+
+     compress2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
+   memory, Z_BUF_ERROR if there was not enough room in the output buffer,
+   Z_STREAM_ERROR if the level parameter is invalid.
+*/
+
+ZEXTERN uLong ZEXPORT compressBound OF((uLong sourceLen));
+/*
+     compressBound() returns an upper bound on the compressed size after
+   compress() or compress2() on sourceLen bytes.  It would be used before a
+   compress() or compress2() call to allocate the destination buffer.
+*/
+
+ZEXTERN int ZEXPORT uncompress OF((Bytef *dest,   uLongf *destLen,
+                                   const Bytef *source, uLong sourceLen));
+/*
+     Decompresses the source buffer into the destination buffer.  sourceLen is
+   the byte length of the source buffer.  Upon entry, destLen is the total size
+   of the destination buffer, which must be large enough to hold the entire
+   uncompressed data.  (The size of the uncompressed data must have been saved
+   previously by the compressor and transmitted to the decompressor by some
+   mechanism outside the scope of this compression library.) Upon exit, destLen
+   is the actual size of the uncompressed buffer.
+
+     uncompress returns Z_OK if success, Z_MEM_ERROR if there was not
+   enough memory, Z_BUF_ERROR if there was not enough room in the output
+   buffer, or Z_DATA_ERROR if the input data was corrupted or incomplete.
+*/
+
+
+                        /* gzip file access functions */
+
+/*
+     This library supports reading and writing files in gzip (.gz) format with
+   an interface similar to that of stdio, using the functions that start with
+   "gz".  The gzip format is different from the zlib format.  gzip is a gzip
+   wrapper, documented in RFC 1952, wrapped around a deflate stream.
+*/
+
+typedef voidp gzFile;       /* opaque gzip file descriptor */
+
+/*
+ZEXTERN gzFile ZEXPORT gzopen OF((const char *path, const char *mode));
+
+     Opens a gzip (.gz) file for reading or writing.  The mode parameter is as
+   in fopen ("rb" or "wb") but can also include a compression level ("wb9") or
+   a strategy: 'f' for filtered data as in "wb6f", 'h' for Huffman-only
+   compression as in "wb1h", 'R' for run-length encoding as in "wb1R", or 'F'
+   for fixed code compression as in "wb9F".  (See the description of
+   deflateInit2 for more information about the strategy parameter.) Also "a"
+   can be used instead of "w" to request that the gzip stream that will be
+   written be appended to the file.  "+" will result in an error, since reading
+   and writing to the same gzip file is not supported.
+
+     gzopen can be used to read a file which is not in gzip format; in this
+   case gzread will directly read from the file without decompression.
+
+     gzopen returns NULL if the file could not be opened, if there was
+   insufficient memory to allocate the gzFile state, or if an invalid mode was
+   specified (an 'r', 'w', or 'a' was not provided, or '+' was provided).
+   errno can be checked to determine if the reason gzopen failed was that the
+   file could not be opened.
+*/
+
+ZEXTERN gzFile ZEXPORT gzdopen OF((int fd, const char *mode));
+/*
+     gzdopen associates a gzFile with the file descriptor fd.  File descriptors
+   are obtained from calls like open, dup, creat, pipe or fileno (if the file
+   has been previously opened with fopen).  The mode parameter is as in gzopen.
+
+     The next call of gzclose on the returned gzFile will also close the file
+   descriptor fd, just like fclose(fdopen(fd, mode)) closes the file descriptor
+   fd.  If you want to keep fd open, use fd = dup(fd_keep); gz = gzdopen(fd,
+   mode);.  The duplicated descriptor should be saved to avoid a leak, since
+   gzdopen does not close fd if it fails.
+
+     gzdopen returns NULL if there was insufficient memory to allocate the
+   gzFile state, if an invalid mode was specified (an 'r', 'w', or 'a' was not
+   provided, or '+' was provided), or if fd is -1.  The file descriptor is not
+   used until the next gz* read, write, seek, or close operation, so gzdopen
+   will not detect if fd is invalid (unless fd is -1).
+*/
+
+ZEXTERN int ZEXPORT gzbuffer OF((gzFile file, unsigned size));
+/*
+     Set the internal buffer size used by this library's functions.  The
+   default buffer size is 8192 bytes.  This function must be called after
+   gzopen() or gzdopen(), and before any other calls that read or write the
+   file.  The buffer memory allocation is always deferred to the first read or
+   write.  Two buffers are allocated, either both of the specified size when
+   writing, or one of the specified size and the other twice that size when
+   reading.  A larger buffer size of, for example, 64K or 128K bytes will
+   noticeably increase the speed of decompression (reading).
+
+     The new buffer size also affects the maximum length for gzprintf().
+
+     gzbuffer() returns 0 on success, or -1 on failure, such as being called
+   too late.
+*/
+
+ZEXTERN int ZEXPORT gzsetparams OF((gzFile file, int level, int strategy));
+/*
+     Dynamically update the compression level or strategy.  See the description
+   of deflateInit2 for the meaning of these parameters.
+
+     gzsetparams returns Z_OK if success, or Z_STREAM_ERROR if the file was not
+   opened for writing.
+*/
+
+ZEXTERN int ZEXPORT gzread OF((gzFile file, voidp buf, unsigned len));
+/*
+     Reads the given number of uncompressed bytes from the compressed file.  If
+   the input file was not in gzip format, gzread copies the given number of
+   bytes into the buffer.
+
+     After reaching the end of a gzip stream in the input, gzread will continue
+   to read, looking for another gzip stream, or failing that, reading the rest
+   of the input file directly without decompression.  The entire input file
+   will be read if gzread is called until it returns less than the requested
+   len.
+
+     gzread returns the number of uncompressed bytes actually read, less than
+   len for end of file, or -1 for error.
+*/
+
+ZEXTERN int ZEXPORT gzwrite OF((gzFile file,
+                                voidpc buf, unsigned len));
+/*
+     Writes the given number of uncompressed bytes into the compressed file.
+   gzwrite returns the number of uncompressed bytes written or 0 in case of
+   error.
+*/
+
+ZEXTERN int ZEXPORTVA gzprintf OF((gzFile file, const char *format, ...));
+/*
+     Converts, formats, and writes the arguments to the compressed file under
+   control of the format string, as in fprintf.  gzprintf returns the number of
+   uncompressed bytes actually written, or 0 in case of error.  The number of
+   uncompressed bytes written is limited to 8191, or one less than the buffer
+   size given to gzbuffer().  The caller should assure that this limit is not
+   exceeded.  If it is exceeded, then gzprintf() will return an error (0) with
+   nothing written.  In this case, there may also be a buffer overflow with
+   unpredictable consequences, which is possible only if zlib was compiled with
+   the insecure functions sprintf() or vsprintf() because the secure snprintf()
+   or vsnprintf() functions were not available.  This can be determined using
+   zlibCompileFlags().
+*/
+
+ZEXTERN int ZEXPORT gzputs OF((gzFile file, const char *s));
+/*
+     Writes the given null-terminated string to the compressed file, excluding
+   the terminating null character.
+
+     gzputs returns the number of characters written, or -1 in case of error.
+*/
+
+ZEXTERN char * ZEXPORT gzgets OF((gzFile file, char *buf, int len));
+/*
+     Reads bytes from the compressed file until len-1 characters are read, or a
+   newline character is read and transferred to buf, or an end-of-file
+   condition is encountered.  If any characters are read or if len == 1, the
+   string is terminated with a null character.  If no characters are read due
+   to an end-of-file or len < 1, then the buffer is left untouched.
+
+     gzgets returns buf which is a null-terminated string, or it returns NULL
+   for end-of-file or in case of error.  If there was an error, the contents at
+   buf are indeterminate.
+*/
+
+ZEXTERN int ZEXPORT gzputc OF((gzFile file, int c));
+/*
+     Writes c, converted to an unsigned char, into the compressed file.  gzputc
+   returns the value that was written, or -1 in case of error.
+*/
+
+ZEXTERN int ZEXPORT gzgetc OF((gzFile file));
+/*
+     Reads one byte from the compressed file.  gzgetc returns this byte or -1
+   in case of end of file or error.
+*/
+
+ZEXTERN int ZEXPORT gzungetc OF((int c, gzFile file));
+/*
+     Push one character back onto the stream to be read as the first character
+   on the next read.  At least one character of push-back is allowed.
+   gzungetc() returns the character pushed, or -1 on failure.  gzungetc() will
+   fail if c is -1, and may fail if a character has been pushed but not read
+   yet.  If gzungetc is used immediately after gzopen or gzdopen, at least the
+   output buffer size of pushed characters is allowed.  (See gzbuffer above.)
+   The pushed character will be discarded if the stream is repositioned with
+   gzseek() or gzrewind().
+*/
+
+ZEXTERN int ZEXPORT gzflush OF((gzFile file, int flush));
+/*
+     Flushes all pending output into the compressed file.  The parameter flush
+   is as in the deflate() function.  The return value is the zlib error number
+   (see function gzerror below).  gzflush is only permitted when writing.
+
+     If the flush parameter is Z_FINISH, the remaining data is written and the
+   gzip stream is completed in the output.  If gzwrite() is called again, a new
+   gzip stream will be started in the output.  gzread() is able to read such
+   concatented gzip streams.
+
+     gzflush should be called only when strictly necessary because it will
+   degrade compression if called too often.
+*/
+
+/*
+ZEXTERN z_off_t ZEXPORT gzseek OF((gzFile file,
+                                   z_off_t offset, int whence));
+
+     Sets the starting position for the next gzread or gzwrite on the given
+   compressed file.  The offset represents a number of bytes in the
+   uncompressed data stream.  The whence parameter is defined as in lseek(2);
+   the value SEEK_END is not supported.
+
+     If the file is opened for reading, this function is emulated but can be
+   extremely slow.  If the file is opened for writing, only forward seeks are
+   supported; gzseek then compresses a sequence of zeroes up to the new
+   starting position.
+
+     gzseek returns the resulting offset location as measured in bytes from
+   the beginning of the uncompressed stream, or -1 in case of error, in
+   particular if the file is opened for writing and the new starting position
+   would be before the current position.
+*/
+
+ZEXTERN int ZEXPORT    gzrewind OF((gzFile file));
+/*
+     Rewinds the given file. This function is supported only for reading.
+
+     gzrewind(file) is equivalent to (int)gzseek(file, 0L, SEEK_SET)
+*/
+
+/*
+ZEXTERN z_off_t ZEXPORT    gztell OF((gzFile file));
+
+     Returns the starting position for the next gzread or gzwrite on the given
+   compressed file.  This position represents a number of bytes in the
+   uncompressed data stream, and is zero when starting, even if appending or
+   reading a gzip stream from the middle of a file using gzdopen().
+
+     gztell(file) is equivalent to gzseek(file, 0L, SEEK_CUR)
+*/
+
+/*
+ZEXTERN z_off_t ZEXPORT gzoffset OF((gzFile file));
+
+     Returns the current offset in the file being read or written.  This offset
+   includes the count of bytes that precede the gzip stream, for example when
+   appending or when using gzdopen() for reading.  When reading, the offset
+   does not include as yet unused buffered input.  This information can be used
+   for a progress indicator.  On error, gzoffset() returns -1.
+*/
+
+ZEXTERN int ZEXPORT gzeof OF((gzFile file));
+/*
+     Returns true (1) if the end-of-file indicator has been set while reading,
+   false (0) otherwise.  Note that the end-of-file indicator is set only if the
+   read tried to go past the end of the input, but came up short.  Therefore,
+   just like feof(), gzeof() may return false even if there is no more data to
+   read, in the event that the last read request was for the exact number of
+   bytes remaining in the input file.  This will happen if the input file size
+   is an exact multiple of the buffer size.
+
+     If gzeof() returns true, then the read functions will return no more data,
+   unless the end-of-file indicator is reset by gzclearerr() and the input file
+   has grown since the previous end of file was detected.
+*/
+
+ZEXTERN int ZEXPORT gzdirect OF((gzFile file));
+/*
+     Returns true (1) if file is being copied directly while reading, or false
+   (0) if file is a gzip stream being decompressed.  This state can change from
+   false to true while reading the input file if the end of a gzip stream is
+   reached, but is followed by data that is not another gzip stream.
+
+     If the input file is empty, gzdirect() will return true, since the input
+   does not contain a gzip stream.
+
+     If gzdirect() is used immediately after gzopen() or gzdopen() it will
+   cause buffers to be allocated to allow reading the file to determine if it
+   is a gzip file.  Therefore if gzbuffer() is used, it should be called before
+   gzdirect().
+*/
+
+ZEXTERN int ZEXPORT    gzclose OF((gzFile file));
+/*
+     Flushes all pending output if necessary, closes the compressed file and
+   deallocates the (de)compression state.  Note that once file is closed, you
+   cannot call gzerror with file, since its structures have been deallocated.
+   gzclose must not be called more than once on the same file, just as free
+   must not be called more than once on the same allocation.
+
+     gzclose will return Z_STREAM_ERROR if file is not valid, Z_ERRNO on a
+   file operation error, or Z_OK on success.
+*/
+
+ZEXTERN int ZEXPORT gzclose_r OF((gzFile file));
+ZEXTERN int ZEXPORT gzclose_w OF((gzFile file));
+/*
+     Same as gzclose(), but gzclose_r() is only for use when reading, and
+   gzclose_w() is only for use when writing or appending.  The advantage to
+   using these instead of gzclose() is that they avoid linking in zlib
+   compression or decompression code that is not used when only reading or only
+   writing respectively.  If gzclose() is used, then both compression and
+   decompression code will be included the application when linking to a static
+   zlib library.
+*/
+
+ZEXTERN const char * ZEXPORT gzerror OF((gzFile file, int *errnum));
+/*
+     Returns the error message for the last error which occurred on the given
+   compressed file.  errnum is set to zlib error number.  If an error occurred
+   in the file system and not in the compression library, errnum is set to
+   Z_ERRNO and the application may consult errno to get the exact error code.
+
+     The application must not modify the returned string.  Future calls to
+   this function may invalidate the previously returned string.  If file is
+   closed, then the string previously returned by gzerror will no longer be
+   available.
+
+     gzerror() should be used to distinguish errors from end-of-file for those
+   functions above that do not distinguish those cases in their return values.
+*/
+
+ZEXTERN void ZEXPORT gzclearerr OF((gzFile file));
+/*
+     Clears the error and end-of-file flags for file.  This is analogous to the
+   clearerr() function in stdio.  This is useful for continuing to read a gzip
+   file that is being written concurrently.
+*/
+
+
+                        /* checksum functions */
+
+/*
+     These functions are not related to compression but are exported
+   anyway because they might be useful in applications using the compression
+   library.
+*/
+
+ZEXTERN uLong ZEXPORT adler32 OF((uLong adler, const Bytef *buf, uInt len));
+/*
+     Update a running Adler-32 checksum with the bytes buf[0..len-1] and
+   return the updated checksum.  If buf is Z_NULL, this function returns the
+   required initial value for the checksum.
+
+     An Adler-32 checksum is almost as reliable as a CRC32 but can be computed
+   much faster.
+
+   Usage example:
+
+     uLong adler = adler32(0L, Z_NULL, 0);
+
+     while (read_buffer(buffer, length) != EOF) {
+       adler = adler32(adler, buffer, length);
+     }
+     if (adler != original_adler) error();
+*/
+
+/*
+ZEXTERN uLong ZEXPORT adler32_combine OF((uLong adler1, uLong adler2,
+                                          z_off_t len2));
+
+     Combine two Adler-32 checksums into one.  For two sequences of bytes, seq1
+   and seq2 with lengths len1 and len2, Adler-32 checksums were calculated for
+   each, adler1 and adler2.  adler32_combine() returns the Adler-32 checksum of
+   seq1 and seq2 concatenated, requiring only adler1, adler2, and len2.
+*/
+
+ZEXTERN uLong ZEXPORT crc32   OF((uLong crc, const Bytef *buf, uInt len));
+/*
+     Update a running CRC-32 with the bytes buf[0..len-1] and return the
+   updated CRC-32.  If buf is Z_NULL, this function returns the required
+   initial value for the for the crc.  Pre- and post-conditioning (one's
+   complement) is performed within this function so it shouldn't be done by the
+   application.
+
+   Usage example:
+
+     uLong crc = crc32(0L, Z_NULL, 0);
+
+     while (read_buffer(buffer, length) != EOF) {
+       crc = crc32(crc, buffer, length);
+     }
+     if (crc != original_crc) error();
+*/
+
+/*
+ZEXTERN uLong ZEXPORT crc32_combine OF((uLong crc1, uLong crc2, z_off_t len2));
+
+     Combine two CRC-32 check values into one.  For two sequences of bytes,
+   seq1 and seq2 with lengths len1 and len2, CRC-32 check values were
+   calculated for each, crc1 and crc2.  crc32_combine() returns the CRC-32
+   check value of seq1 and seq2 concatenated, requiring only crc1, crc2, and
+   len2.
+*/
+
+
+                        /* various hacks, don't look :) */
+
+/* deflateInit and inflateInit are macros to allow checking the zlib version
+ * and the compiler's view of z_stream:
+ */
+ZEXTERN int ZEXPORT deflateInit_ OF((z_streamp strm, int level,
+                                     const char *version, int stream_size));
+ZEXTERN int ZEXPORT inflateInit_ OF((z_streamp strm,
+                                     const char *version, int stream_size));
+ZEXTERN int ZEXPORT deflateInit2_ OF((z_streamp strm, int  level, int  method,
+                                      int windowBits, int memLevel,
+                                      int strategy, const char *version,
+                                      int stream_size));
+ZEXTERN int ZEXPORT inflateInit2_ OF((z_streamp strm, int  windowBits,
+                                      const char *version, int stream_size));
+ZEXTERN int ZEXPORT inflateBackInit_ OF((z_streamp strm, int windowBits,
+                                         unsigned char FAR *window,
+                                         const char *version,
+                                         int stream_size));
+#define deflateInit(strm, level) \
+        deflateInit_((strm), (level),       ZLIB_VERSION, sizeof(z_stream))
+#define inflateInit(strm) \
+        inflateInit_((strm),                ZLIB_VERSION, sizeof(z_stream))
+#define deflateInit2(strm, level, method, windowBits, memLevel, strategy) \
+        deflateInit2_((strm),(level),(method),(windowBits),(memLevel),\
+                      (strategy),           ZLIB_VERSION, sizeof(z_stream))
+#define inflateInit2(strm, windowBits) \
+        inflateInit2_((strm), (windowBits), ZLIB_VERSION, sizeof(z_stream))
+#define inflateBackInit(strm, windowBits, window) \
+        inflateBackInit_((strm), (windowBits), (window), \
+                                            ZLIB_VERSION, sizeof(z_stream))
+
+/* provide 64-bit offset functions if _LARGEFILE64_SOURCE defined, and/or
+ * change the regular functions to 64 bits if _FILE_OFFSET_BITS is 64 (if
+ * both are true, the application gets the *64 functions, and the regular
+ * functions are changed to 64 bits) -- in case these are set on systems
+ * without large file support, _LFS64_LARGEFILE must also be true
+ */
+#if defined(_LARGEFILE64_SOURCE) && _LFS64_LARGEFILE-0
+   ZEXTERN gzFile ZEXPORT gzopen64 OF((const char *, const char *));
+   ZEXTERN z_off64_t ZEXPORT gzseek64 OF((gzFile, z_off64_t, int));
+   ZEXTERN z_off64_t ZEXPORT gztell64 OF((gzFile));
+   ZEXTERN z_off64_t ZEXPORT gzoffset64 OF((gzFile));
+   ZEXTERN uLong ZEXPORT adler32_combine64 OF((uLong, uLong, z_off64_t));
+   ZEXTERN uLong ZEXPORT crc32_combine64 OF((uLong, uLong, z_off64_t));
+#endif
+
+#if !defined(ZLIB_INTERNAL) && _FILE_OFFSET_BITS-0 == 64 && _LFS64_LARGEFILE-0
+#  define gzopen gzopen64
+#  define gzseek gzseek64
+#  define gztell gztell64
+#  define gzoffset gzoffset64
+#  define adler32_combine adler32_combine64
+#  define crc32_combine crc32_combine64
+#  ifdef _LARGEFILE64_SOURCE
+     ZEXTERN gzFile ZEXPORT gzopen64 OF((const char *, const char *));
+     ZEXTERN z_off_t ZEXPORT gzseek64 OF((gzFile, z_off_t, int));
+     ZEXTERN z_off_t ZEXPORT gztell64 OF((gzFile));
+     ZEXTERN z_off_t ZEXPORT gzoffset64 OF((gzFile));
+     ZEXTERN uLong ZEXPORT adler32_combine64 OF((uLong, uLong, z_off_t));
+     ZEXTERN uLong ZEXPORT crc32_combine64 OF((uLong, uLong, z_off_t));
+#  endif
+#else
+   ZEXTERN gzFile ZEXPORT gzopen OF((const char *, const char *));
+   ZEXTERN z_off_t ZEXPORT gzseek OF((gzFile, z_off_t, int));
+   ZEXTERN z_off_t ZEXPORT gztell OF((gzFile));
+   ZEXTERN z_off_t ZEXPORT gzoffset OF((gzFile));
+   ZEXTERN uLong ZEXPORT adler32_combine OF((uLong, uLong, z_off_t));
+   ZEXTERN uLong ZEXPORT crc32_combine OF((uLong, uLong, z_off_t));
+#endif
+
+/* hack for buggy compilers */
+#if !defined(ZUTIL_H) && !defined(NO_DUMMY_DECL)
+    struct internal_state {int dummy;};
+#endif
+
+/* undocumented functions */
+ZEXTERN const char   * ZEXPORT zError           OF((int));
+ZEXTERN int            ZEXPORT inflateSyncPoint OF((z_streamp));
+ZEXTERN const uLongf * ZEXPORT get_crc_table    OF((void));
+ZEXTERN int            ZEXPORT inflateUndermine OF((z_streamp, int));
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* ZLIB_H */
commit d35e544671d94a9e6ebf87ff5f7d747fda616f27
Author: Luigi Scarso <luigi.scarso@gmail.com>
Date:   Wed Sep 5 21:57:30 2018 +0000

    luatex: correct  automake file for pplib; replaced cweb files with c files.
    
    git-svn-id: svn://tug.org/texlive/trunk/Build/source@48594 c570f23f-e606-0410-a88d-b1316a301751

diff --git a/texk/web2c/luatexdir/am/luapplib.am b/texk/web2c/luatexdir/am/luapplib.am
new file mode 100644
index 000000000..513062325
--- /dev/null
+++ b/texk/web2c/luatexdir/am/luapplib.am
@@ -0,0 +1,86 @@
+## texk/web2c/luatexdir/am/luapplib.am: Makefile fragment for libluapplib.
+##
+## Copyright (C) 2018 Luigi Scarso <tex-live@tug.org>
+## You may freely use, modify and/or distribute this file.
+
+## luapplib
+##
+EXTRA_LIBRARIES += libluapplib.a liblua53pplib.a libluajitpplib.a
+
+libluapplib_a_DEPENDENCIES = $(ZLIB_DEPEND)
+liblua53pplib_a_DEPENDENCIES = $(ZLIB_DEPEND)
+libluajitpplib_a_DEPENDENCIES = $(ZLIB_DEPEND)
+
+$(libluapplib_a_OBJECTS): $(LUA_DEPEND)
+$(liblua53pplib_a_OBJECTS): $(LUA_DEPEND)
+$(libluajitpplib_a_OBJECTS): $(LUAJIT_DEPEND)
+
+## replace -I../../libs/zlib/include $(ZLIB_INCLUDES)
+
+libluapplib_a_CPPFLAGS = \
+	-I$(top_srcdir)/luatexdir/luapplib -I$(top_srcdir)/luatexdir/luapplib/util $(ZLIB_INCLUDES) $(LUA_INCLUDES)
+
+liblua53pplib_a_CPPFLAGS = \
+	-I$(top_srcdir)/luatexdir/luapplib -I$(top_srcdir)/luatexdir/luapplib/util $(ZLIB_INCLUDES) $(LUA_LUA53_INCLUDES)
+
+libluajitpplib_a_CPPFLAGS = \
+	-I$(top_srcdir)/luatexdir/luapplib -I$(top_srcdir)/luatexdir/luapplib/util $(ZLIB_INCLUDES) $(LUAJIT_INCLUDES)
+
+libluapplib_a_CFLAGS = # $(WARNING_CFLAGS)
+libluajitpplib_a_CFLAGS = # $(WARNING_CFLAGS)
+
+nodist_libluapplib_a_SOURCES = $(libluapplib_sources)
+nodist_liblua53pplib_a_SOURCES = $(libluapplib_sources)
+nodist_libluajitpplib_a_SOURCES = $(libluapplib_sources)
+
+libluapplib_sources = \
+	luatexdir/luapplib/ppapi.h \
+	luatexdir/luapplib/pparray.c \
+	luatexdir/luapplib/pparray.h \
+	luatexdir/luapplib/ppconf.h \
+	luatexdir/luapplib/ppcrypt.c \
+	luatexdir/luapplib/ppcrypt.h \
+	luatexdir/luapplib/ppdict.c \
+	luatexdir/luapplib/ppdict.h \
+	luatexdir/luapplib/ppfilter.h \
+	luatexdir/luapplib/ppheap.c \
+	luatexdir/luapplib/ppheap.h \
+	luatexdir/luapplib/pplib.h \
+	luatexdir/luapplib/ppload.c \
+	luatexdir/luapplib/ppload.h \
+	luatexdir/luapplib/ppstream.c \
+	luatexdir/luapplib/ppstream.h \
+	luatexdir/luapplib/ppxref.c \
+	luatexdir/luapplib/ppxref.h \
+	luatexdir/luapplib/util/utilbasexx.c \
+	luatexdir/luapplib/util/utilbasexx.h \
+	luatexdir/luapplib/util/utilcrypt.c \
+	luatexdir/luapplib/util/utilcrypt.h \
+	luatexdir/luapplib/util/utilcryptdef.h \
+	luatexdir/luapplib/util/utildecl.h \
+	luatexdir/luapplib/util/utilflate.c \
+	luatexdir/luapplib/util/utilflate.h \
+	luatexdir/luapplib/util/utilfpred.c \
+	luatexdir/luapplib/util/utilfpred.h \
+	luatexdir/luapplib/util/utiliof.c \
+	luatexdir/luapplib/util/utiliof.h \
+	luatexdir/luapplib/util/utillog.c \
+	luatexdir/luapplib/util/utillog.h \
+	luatexdir/luapplib/util/utillzw.c \
+	luatexdir/luapplib/util/utillzw.h \
+	luatexdir/luapplib/util/utilmd5.c \
+	luatexdir/luapplib/util/utilmd5.h \
+	luatexdir/luapplib/util/utilmem.c \
+	luatexdir/luapplib/util/utilmem.h \
+	luatexdir/luapplib/util/utilnumber.c \
+	luatexdir/luapplib/util/utilnumber.h \
+	luatexdir/luapplib/util/utilplat.h \
+	luatexdir/luapplib/util/utilsha.c \
+	luatexdir/luapplib/util/utilsha.h \
+	luatexdir/luapplib/zlib/zconf.h \
+	luatexdir/luapplib/zlib/zlib.h 
+
+
+
+liblua53pplib_sources = $(libluapplib_sources)
+libluajitpplib_sources = $(libluapplib_sources)
diff --git a/texk/web2c/luatexdir/dvi/dvigen.c b/texk/web2c/luatexdir/dvi/dvigen.c
new file mode 100644
index 000000000..8e285917a
--- /dev/null
+++ b/texk/web2c/luatexdir/dvi/dvigen.c
@@ -0,0 +1,1558 @@
+/*
+
+dvigen.w
+
+Copyright 2009-2013 Taco Hoekwater <taco@luatex.org>
+
+This file is part of LuaTeX.
+
+LuaTeX is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 2 of the License, or (at your
+option) any later version.
+
+LuaTeX is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+License for more details.
+
+You should have received a copy of the GNU General Public License along
+with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#include "ptexlib.h"
+
+#undef write_dvi
+
+/*tex This is the current mode: */
+
+#define mode cur_list.mode_field
+
+/*tex
+
+The most important output produced by a run of \TeX\ is the ``device
+independent'' (\.{DVI}) file that specifies where characters and rules are to
+appear on printed pages. The form of these files was designed by David R. Fuchs
+in 1979. Almost any reasonable typesetting device can be driven by a program that
+takes \.{DVI} files as input, and dozens of such \.{DVI}-to-whatever programs
+have been written. Thus, it is possible to print the output of \TeX\ on many
+different kinds of equipment, using \TeX\ as a device-independent ``front end.''
+
+A \.{DVI} file is a stream of 8-bit bytes, which may be regarded as a series of
+commands in a machine-like language. The first byte of each command is the
+operation code, and this code is followed by zero or more bytes that provide
+parameters to the command. The parameters themselves may consist of several
+consecutive bytes; for example, the `|set_rule|' command has two parameters, each
+of which is four bytes long. Parameters are usually regarded as nonnegative
+integers; but four-byte-long parameters, and shorter parameters that denote
+distances, can be either positive or negative. Such parameters are given in two's
+complement notation. For example, a two-byte-long distance parameter has a value
+between $-2^{15}$ and $2^{15}-1$. As in \.{TFM} files, numbers that occupy more
+than one byte position appear in BigEndian order.
+
+A \.{DVI} file consists of a ``preamble,'' followed by a sequence of one or more
+``pages,'' followed by a ``postamble.'' The preamble is simply a |pre| command,
+with its parameters that define the dimensions used in the file; this must come
+first. Each ``page'' consists of a |bop| command, followed by any number of other
+commands that tell where characters are to be placed on a physical page, followed
+by an |eop| command. The pages appear in the order that \TeX\ generated them. If
+we ignore |nop| commands and \\{fnt\_def} commands (which are allowed between any
+two commands in the file), each |eop| command is immediately followed by a |bop|
+command, or by a |post| command; in the latter case, there are no more pages in
+the file, and the remaining bytes form the postamble. Further details about the
+postamble will be explained later.
+
+Some parameters in \.{DVI} commands are ``pointers.'' These are four-byte
+quantities that give the location number of some other byte in the file; the
+first byte is number~0, then comes number~1, and so on. For example, one of the
+parameters of a |bop| command points to the previous |bop|; this makes it
+feasible to read the pages in backwards order, in case the results are being
+directed to a device that stacks its output face up. Suppose the preamble of a
+\.{DVI} file occupies bytes 0 to 99. Now if the first page occupies bytes 100 to
+999, say, and if the second page occupies bytes 1000 to 1999, then the |bop| that
+starts in byte 1000 points to 100 and the |bop| that starts in byte 2000 points
+to 1000. (The very first |bop|, i.e., the one starting in byte 100, has a pointer
+of~$-1$.)
+
+The \.{DVI} format is intended to be both compact and easily interpreted by a
+machine. Compactness is achieved by making most of the information implicit
+instead of explicit. When a \.{DVI}-reading program reads the commands for a
+page, it keeps track of several quantities: (a)~The current font |f| is an
+integer; this value is changed only by \\{fnt} and \\{fnt\_num} commands. (b)~The
+current position on the page is given by two numbers called the horizontal and
+vertical coordinates, |h| and |v|. Both coordinates are zero at the upper left
+corner of the page; moving to the right corresponds to increasing the horizontal
+coordinate, and moving down corresponds to increasing the vertical coordinate.
+Thus, the coordinates are essentially Cartesian, except that vertical directions
+are flipped; the Cartesian version of |(h,v)| would be |(h,-v)|. (c)~The current
+spacing amounts are given by four numbers |w|, |x|, |y|, and |z|, where |w|
+and~|x| are used for horizontal spacing and where |y| and~|z| are used for
+vertical spacing. (d)~There is a stack containing |(h,v,w,x,y,z)| values; the
+\.{DVI} commands |push| and |pop| are used to change the current level of
+operation. Note that the current font~|f| is not pushed and popped; the stack
+contains only information about positioning.
+
+The values of |h|, |v|, |w|, |x|, |y|, and |z| are signed integers having up to
+32 bits, including the sign. Since they represent physical distances, there is a
+small unit of measurement such that increasing |h| by~1 means moving a certain
+tiny distance to the right. The actual unit of measurement is variable, as
+explained below; \TeX\ sets things up so that its \.{DVI} output is in sp units,
+i.e., scaled points, in agreement with all the |scaled| dimensions in \TeX's data
+structures.
+
+Here is a list of all the commands that may appear in a \.{DVI} file. Each
+command is specified by its symbolic name (e.g., |bop|), its opcode byte (e.g.,
+139), and its parameters (if any). The parameters are followed by a bracketed
+number telling how many bytes they occupy; for example, `|p[4]|' means that
+parameter |p| is four bytes long.
+
+\startitemize
+
+\startitem
+    |set_char_0| 0. Typeset character number~0 from font~|f| such that the
+    reference point of the character is at |(h,v)|. Then increase |h| by the
+    width of that character. Note that a character may have zero or negative
+    width, so one cannot be sure that |h| will advance after this command; but
+    |h| usually does increase.
+\stopitem
+
+\startitem
+    \\{set\_char\_1} through \\{set\_char\_127} (opcodes 1 to 127).
+    Do the operations of |set_char_0|; but use the character whose number
+    matches the opcode, instead of character~0.
+\stopitem
+
+\startitem
+    |set1| 128 |c[1]|. Same as |set_char_0|, except that character number~|c| is
+    typeset. \TeX82 uses this command for characters in the range |128<=c<256|.
+\stopitem
+
+\startitem
+    |set2| 129 |c[2]|. Same as |set1|, except that |c|~is two bytes long, so it
+    is in the range |0<=c<65536|. \TeX82 never uses this command, but it should
+    come in handy for extensions of \TeX\ that deal with oriental languages.
+\stopitem
+
+\startitem
+    |set3| 130 |c[3]|. Same as |set1|, except that |c|~is three bytes long, so it
+    can be as large as $2^{24}-1$. Not even the Chinese language has this many
+    characters, but this command might prove useful in some yet unforeseen
+    extension.
+\stopitem
+
+\startitem
+    |set4| 131 |c[4]|. Same as |set1|, except that |c|~is four bytes long.
+    Imagine that.
+\stopitem
+
+\startitem
+    |set_rule| 132 |a[4]| |b[4]|. Typeset a solid black rectangle of height~|a|
+    and width~|b|, with its bottom left corner at |(h,v)|. Then set |h:=h+b|. If
+    either |a<=0| or |b<=0|, nothing should be typeset. Note that if |b<0|, the
+    value of |h| will decrease even though nothing else happens. See below for
+    details about how to typeset rules so that consistency with \MF\ is
+    guaranteed.
+\stopitem
+
+\startitem
+    |put1| 133 |c[1]|. Typeset character number~|c| from font~|f| such that the
+    reference point of the character is at |(h,v)|. (The `put' commands are
+    exactly like the `set' commands, except that they simply put out a character
+    or a rule without moving the reference point afterwards.)
+\stopitem
+
+\startitem
+    |put2| 134 |c[2]|. Same as |set2|, except that |h| is not changed.
+\stopitem
+
+\startitem
+    |put3| 135 |c[3]|. Same as |set3|, except that |h| is not changed.
+\stopitem
+
+\startitem
+    |put4| 136 |c[4]|. Same as |set4|, except that |h| is not changed.
+\stopitem
+
+\startitem
+    |put_rule| 137 |a[4]| |b[4]|. Same as |set_rule|, except that |h| is not
+    changed.
+\stopitem
+
+\startitem
+    |nop| 138. No operation, do nothing. Any number of |nop|'s may occur between
+    \.{DVI} commands, but a |nop| cannot be inserted between a command and its
+    parameters or between two parameters.
+\stopitem
+
+\startitem
+    |bop| 139 $c_0[4]$ $c_1[4]$ $\ldots$ $c_9[4]$ $p[4]$. Beginning of a page:
+    Set |(h,v,w,x,y,z):=(0,0,0,0,0,0)| and set the stack empty. Set the current
+    font |f| to an undefined value. The ten $c_i$ parameters hold the values of
+    \.{\\count0} $\ldots$ \.{\\count9} in \TeX\ at the time \.{\\shipout} was
+    invoked for this page; they can be used to identify pages, if a user wants to
+    print only part of a \.{DVI} file. The parameter |p| points to the previous
+    |bop| in the file; the first |bop| has $p=-1$.
+\stopitem
+
+\startitem
+    |eop| 140. End of page: Print what you have read since the previous |bop|. At
+    this point the stack should be empty. (The \.{DVI}-reading programs that
+    drive most output devices will have kept a buffer of the material that
+    appears on the page that has just ended. This material is largely, but not
+    entirely, in order by |v| coordinate and (for fixed |v|) by |h|~coordinate;
+    so it usually needs to be sorted into some order that is appropriate for the
+    device in question.)
+\stopitem
+
+\startitem
+    |push| 141. Push the current values of |(h,v,w,x,y,z)| onto the top of the
+    stack; do not change any of these values. Note that |f| is not pushed.
+\stopitem
+
+\startitem
+    |pop| 142. Pop the top six values off of the stack and assign them
+    respectively to |(h,v,w,x,y,z)|. The number of pops should never exceed the
+    number of pushes, since it would be highly embarrassing if the stack were
+    empty at the time of a |pop| command.
+
+\startitem
+    |right1| 143 |b[1]|. Set |h:=h+b|, i.e., move right |b| units. The parameter
+    is a signed number in two's complement notation, |-128<=b<128|; if |b<0|, the
+    reference point moves left.
+\stopitem
+
+\startitem
+    |right2| 144 |b[2]|. Same as |right1|, except that |b| is a two-byte quantity
+    in the range |-32768<=b<32768|.
+\stopitem
+
+\startitem
+    |right3| 145 |b[3]|. Same as |right1|, except that |b| is a three-byte
+    quantity in the range |@t$-2^{23}$@><=b<@t$2^{23}$@>|.
+\stopitem
+
+\startitem
+    |right4| 146 |b[4]|. Same as |right1|, except that |b| is a four-byte
+    quantity in the range |@t$-2^{31}$@><=b<@t$2^{31}$@>|.
+\stopitem
+
+\startitem
+    |w0| 147. Set |h:=h+w|; i.e., move right |w| units. With luck, this
+    parameterless command will usually suffice, because the same kind of motion
+    will occur several times in succession; the following commands explain how
+    |w| gets particular values.
+\stopitem
+
+\startitem
+    |w1| 148 |b[1]|. Set |w:=b| and |h:=h+b|. The value of |b| is a signed
+    quantity in two's complement notation, |-128<=b<128|. This command changes
+    the current |w|~spacing and moves right by |b|.
+\stopitem
+
+\startitem
+    |w2| 149 |b[2]|. Same as |w1|, but |b| is two bytes long, |-32768<=b<32768|.
+\stopitem
+
+\startitem
+    |w3| 150 |b[3]|. Same as |w1|, but |b| is three bytes long,
+    |@t$-2^{23}$@><=b<@t$2^{23}$@>|.
+\stopitem
+
+\startitem
+    |w4| 151 |b[4]|. Same as |w1|, but |b| is four bytes long,
+    |@t$-2^{31}$@><=b<@t$2^{31}$@>|.
+\stopitem
+
+\startitem
+    |x0| 152. Set |h:=h+x|; i.e., move right |x| units. The `|x|' commands are
+    like the `|w|' commands except that they involve |x| instead of |w|.
+\stopitem
+
+\startitem
+    |x1| 153 |b[1]|. Set |x:=b| and |h:=h+b|. The value of |b| is a signed
+    quantity in two's complement notation, |-128<=b<128|. This command changes
+    the current |x|~spacing and moves right by |b|.
+\stopitem
+
+\startitem
+    |x2| 154 |b[2]|. Same as |x1|, but |b| is two bytes long, |-32768<=b<32768|.
+\stopitem
+
+\startitem
+    |x3| 155 |b[3]|. Same as |x1|, but |b| is three bytes long,
+    |@t$-2^{23}$@><=b<@t$2^{23}$@>|.
+\stopitem
+
+\startitem
+    |x4| 156 |b[4]|. Same as |x1|, but |b| is four bytes long,
+    |@t$-2^{31}$@><=b<@t$2^{31}$@>|.
+\stopitem
+
+\startitem
+    |down1| 157 |a[1]|. Set |v:=v+a|, i.e., move down |a| units. The parameter is
+    a signed number in two's complement notation, |-128<=a<128|; if |a<0|, the
+    reference point moves up.
+\stopitem
+
+\startitem
+    |down2| 158 |a[2]|. Same as |down1|, except that |a| is a two-byte quantity
+    in the range |-32768<=a<32768|.
+\stopitem
+
+\startitem
+    |down3| 159 |a[3]|. Same as |down1|, except that |a| is a three-byte quantity
+    in the range |@t$-2^{23}$@><=a<@t$2^{23}$@>|.
+\stopitem
+
+\startitem
+    |down4| 160 |a[4]|. Same as |down1|, except that |a| is a four-byte quantity
+    in the range |@t$-2^{31}$@><=a<@t$2^{31}$@>|.
+\stopitem
+
+\startitem
+    |y0| 161. Set |v:=v+y|; i.e., move down |y| units. With luck, this
+    parameterless command will usually suffice, because the same kind of motion
+    will occur several times in succession; the following commands explain how
+    |y| gets particular values.
+\stopitem
+
+\startitem
+    |y1| 162 |a[1]|. Set |y:=a| and |v:=v+a|. The value of |a| is a signed
+    quantity in two's complement notation, |-128<=a<128|. This command changes
+    the current |y|~spacing and moves down by |a|.
+\stopitem
+
+\startitem
+    |y2| 163 |a[2]|. Same as |y1|, but |a| is two bytes long, |-32768<=a<32768|.
+\stopitem
+
+\startitem
+    |y3| 164 |a[3]|. Same as |y1|, but |a| is three bytes long,
+    |@t$-2^{23}$@><=a<@t$2^{23}$@>|.
+\stopitem
+
+\startitem
+    |y4| 165 |a[4]|. Same as |y1|, but |a| is four bytes long,
+    |@t$-2^{31}$@><=a<@t$2^{31}$@>|.
+\stopitem
+
+\startitem
+    |z0| 166. Set |v:=v+z|; i.e., move down |z| units. The `|z|' commands are
+    like the `|y|' commands except that they involve |z| instead of |y|.
+\stopitem
+
+\startitem
+    |z1| 167 |a[1]|. Set |z:=a| and |v:=v+a|. The value of |a| is a signed
+    quantity in two's complement notation, |-128<=a<128|. This command changes
+    the current |z|~spacing and moves down by |a|.
+\stopitem
+
+\startitem
+    |z2| 168 |a[2]|. Same as |z1|, but |a| is two bytes long, |-32768<=a<32768|.
+\stopitem
+
+\startitem
+    |z3| 169 |a[3]|. Same as |z1|, but |a| is three bytes long,
+    |@t$-2^{23}$@><=a<@t$2^{23}$@>|.
+\stopitem
+
+\startitem
+    |z4| 170 |a[4]|. Same as |z1|, but |a| is four bytes long,
+    |@t$-2^{31}$@><=a<@t$2^{31}$@>|.
+\stopitem
+
+\startitem
+    |fnt_num_0| 171. Set |f:=0|. Font 0 must previously have been defined by a
+    \\{fnt\_def} instruction, as explained below.
+\stopitem
+
+\startitem
+    \\{fnt\_num\_1} through \\{fnt\_num\_63} (opcodes 172 to 234). Set |f:=1|,
+    \dots, \hbox{|f:=63|}, respectively.
+\stopitem
+
+\startitem
+    |fnt1| 235 |k[1]|. Set |f:=k|. \TeX82 uses this command for font numbers in
+    the range |64<=k<256|.
+\stopitem
+
+\startitem
+    |fnt2| 236 |k[2]|. Same as |fnt1|, except that |k|~is two bytes long, so it
+    is in the range |0<=k<65536|. \TeX82 never generates this command, but large
+    font numbers may prove useful for specifications of color or texture, or they
+    may be used for special fonts that have fixed numbers in some external coding
+    scheme.
+\stopitem
+
+\startitem
+    |fnt3| 237 |k[3]|. Same as |fnt1|, except that |k|~is three bytes long, so it
+    can be as large as $2^{24}-1$.
+\stopitem
+
+\startitem
+    |fnt4| 238 |k[4]|. Same as |fnt1|, except that |k|~is four bytes long; this
+    is for the really big font numbers (and for the negative ones).
+\stopitem
+
+\startitem
+    |xxx1| 239 |k[1]| |x[k]|. This command is undefined in general; it functions
+    as a $(k+2)$-byte |nop| unless special \.{DVI}-reading programs are being
+    used. \TeX82 generates |xxx1| when a short enough \.{\\special} appears,
+    setting |k| to the number of bytes being sent. It is recommended that |x| be
+    a string having the form of a keyword followed by possible parameters
+    relevant to that keyword.
+\stopitem
+
+\startitem
+    |xxx2| 240 |k[2]| |x[k]|. Like |xxx1|, but |0<=k<65536|.
+\stopitem
+
+\startitem
+    |xxx3| 241 |k[3]| |x[k]|. Like |xxx1|, but |0<=k<@t$2^{24}$@>|.
+\stopitem
+
+\startitem
+    |xxx4| 242 |k[4]| |x[k]|. Like |xxx1|, but |k| can be ridiculously large.
+    \TeX82 uses |xxx4| when sending a string of length 256 or more.
+\stopitem
+
+\startitem
+    |fnt_def1| 243 |k[1]| |c[4]| |s[4]| |d[4]| |a[1]| |l[1]| |n[a+l]|. Define
+    font |k|, where |0<=k<256|; font definitions will be explained shortly.
+\stopitem
+
+\startitem
+    |fnt_def2| 244 |k[2]| |c[4]| |s[4]| |d[4]| |a[1]| |l[1]| |n[a+l]|. Define
+    font |k|, where |0<=k<65536|.
+\stopitem
+
+\startitem
+    |fnt_def3| 245 |k[3]| |c[4]| |s[4]| |d[4]| |a[1]| |l[1]| |n[a+l]|. Define
+    font |k|, where |0<=k<@t$2^{24}$@>|.
+\stopitem
+
+\startitem
+    |fnt_def4| 246 |k[4]| |c[4]| |s[4]| |d[4]| |a[1]| |l[1]| |n[a+l]|. Define
+    font |k|, where |@t$-2^{31}$@><=k<@t$2^{31}$@>|.
+\stopitem
+
+\startitem
+    |pre| 247 |i[1]| |num[4]| |den[4]| |mag[4]| |k[1]| |x[k]|. Beginning of the
+    preamble; this must come at the very beginning of the file. Parameters |i|,
+    |num|, |den|, |mag|, |k|, and |x| are explained below.
+\stopitem
+
+\startitem
+    |post| 248. Beginning of the postamble, see below.
+\stopitem
+
+\startitem
+    |post_post| 249. Ending of the postamble, see below.
+\stopitem
+
+\startitem
+    Commands 250--255 are undefined at the present time.
+\stopitem
+
+*/
+
+#define set_char_0  0           /* typeset character 0 and move right */
+#define set1  128               /* typeset a character and move right */
+#define set_rule  132           /* typeset a rule and move right */
+#define put1    133             /* typeset a character without moving */
+#define put_rule  137           /* typeset a rule */
+#define nop  138                /* no operation */
+#define bop  139                /* beginning of page */
+#define eop  140                /* ending of page */
+#define push  141               /* save the current positions */
+#define pop  142                /* restore previous positions */
+#define right1    143           /* move right */
+#define right4    146           /* move right, 4 bytes */
+#define w0  147                 /* move right by |w| */
+#define w1  148                 /* move right and set |w| */
+#define x0  152                 /* move right by |x| */
+#define x1  153                 /* move right and set |x| */
+#define down1  157              /* move down */
+#define down4  160              /* move down, 4 bytes */
+#define y0  161                 /* move down by |y| */
+#define y1  162                 /* move down and set |y| */
+#define z0  166                 /* move down by |z| */
+#define z1  167                 /* move down and set |z| */
+#define fnt_num_0  171          /* set current font to 0 */
+#define fnt1  235               /* set current font */
+#define xxx1  239               /* extension to \.{DVI} primitives */
+#define xxx4  242               /* potentially long extension to \.{DVI} primitives */
+#define fnt_def1  243           /* define the meaning of a font number */
+#define pre  247                /* preamble */
+#define post  248               /* postamble beginning */
+#define post_post  249          /* postamble ending */
+
+/*tex
+
+The preamble contains basic information about the file as a whole. As stated
+above, there are six parameters: $$\hbox{|i[1]| |num[4]| |den[4]|
+|mag[4]| |k[1]| |x[k]|.}$$ The |i| byte identifies \.{DVI} format;
+currently this byte is always set to~2. (The value |i=3| is currently used for an
+extended format that allows a mixture of right-to-left and left-to-right
+typesetting. Some day we will set |i=4|, when \.{DVI} format makes another
+incompatible change---perhaps in the year 2048.)
+
+The next two parameters, |num| and |den|, are positive integers that define the
+units of measurement; they are the numerator and denominator of a fraction by
+which all dimensions in the \.{DVI} file could be multiplied in order to get
+lengths in units of $10^{-7}$ meters. Since $\rm 7227{pt} = 254{cm}$, and since
+\TeX\ works with scaled points where there are $2^{16}$ sp in a point, \TeX\ sets
+$|num|/|den|=(254\cdot10^5)/(7227\cdot2^{16})=25400000/473628672$.
+
+The |mag| parameter is what \TeX\ calls \.{\\mag}, i.e., 1000 times the desired
+magnification. The actual fraction by which dimensions are multiplied is
+therefore $|mag|\cdot|num|/1000|den|$. Note that if a \TeX\ source document does
+not call for any `\.{true}' dimensions, and if you change it only by specifying a
+different \.{\\mag} setting, the \.{DVI} file that \TeX\ creates will be
+completely unchanged except for the value of |mag| in the preamble and postamble.
+(Fancy \.{DVI}-reading programs allow users to override the |mag|~setting when a
+\.{DVI} file is being printed.)
+
+Finally, |k| and |x| allow the \.{DVI} writer to include a comment, which is not
+interpreted further. The length of comment |x| is |k|, where |0<=k<256|.
+
+The next macro identifies the kind of \.{DVI} files described here.
+
+*/
+
+#define id_byte 2
+
+/*tex
+
+Font definitions for a given font number |k| contain further parameters
+$$\hbox{|c[4]| |s[4]| |d[4]| |a[1]| |l[1]| |n[a+l]|.}$$ The four-byte value |c|
+is the check sum that \TeX\ found in the \.{TFM} file for this font; |c| should
+match the check sum of the font found by programs that read this \.{DVI} file.
+
+Parameter |s| contains a fixed-point scale factor that is applied to the
+character widths in font |k|; font dimensions in \.{TFM} files and other font
+files are relative to this quantity, which is called the ``at size'' elsewhere in
+this documentation. The value of |s| is always positive and less than $2^{27}$.
+It is given in the same units as the other \.{DVI} dimensions, i.e., in sp when
+\TeX82 has made the file. Parameter |d| is similar to |s|; it is the ``design
+size,'' and (like~|s|) it is given in \.{DVI} units. Thus, font |k| is to be used
+at $|mag|\cdot s/1000d$ times its normal size.
+
+The remaining part of a font definition gives the external name of the font,
+which is an ASCII string of length |a+l|. The number |a| is the length of the
+``area'' or directory, and |l| is the length of the font name itself; the
+standard local system font area is supposed to be used when |a=0|. The |n| field
+contains the area in its first |a| bytes.
+
+Font definitions must appear before the first use of a particular font number.
+Once font |k| is defined, it must not be defined again; however, we
+shall see below that font definitions appear in the postamble as well as
+in the pages, so in this sense each font number is defined exactly twice,
+if at all. Like |nop| commands, font definitions can
+appear before the first |bop|, or between an |eop| and a |bop|.
+
+Sometimes it is desirable to make horizontal or vertical rules line up precisely
+with certain features in characters of a font. It is possible to guarantee the
+correct matching between \.{DVI} output and the characters generated by \MF\ by
+adhering to the following principles: (1)~The \MF\ characters should be
+positioned so that a bottom edge or left edge that is supposed to line up with
+the bottom or left edge of a rule appears at the reference point, i.e., in row~0
+and column~0 of the \MF\ raster. This ensures that the position of the rule will
+not be rounded differently when the pixel size is not a perfect multiple of the
+units of measurement in the \.{DVI} file. (2)~A typeset rule of height $a>0$ and
+width $b>0$ should be equivalent to a \MF-generated character having black pixels
+in precisely those raster positions whose \MF\ coordinates satisfy
+|0<=x<@t$\alpha$@>b| and |0<=y<@t$\alpha$@>a|, where $\alpha$ is the number of
+pixels per \.{DVI} unit.
+
+The last page in a \.{DVI} file is followed by `|post|'; this command introduces
+the postamble, which summarizes important facts that \TeX\ has accumulated about
+the file, making it possible to print subsets of the data with reasonable
+efficiency. The postamble has the form
+
+$$\vbox{\halign{\hbox{#\hfil}\cr
+  |post| |p[4]| |num[4]| |den[4]| |mag[4]| |l[4]| |u[4]| |s[2]| |t[2]|\cr
+  $\langle\,$font definitions$\,\rangle$\cr
+  |post_post| |q[4]| |i[1]| 223's$[{\G}4]$\cr}}$$
+
+Here |p| is a pointer to the final |bop| in the file. The next three parameters,
+|num|, |den|, and |mag|, are duplicates of the quantities that appeared in the
+preamble.
+
+Parameters |l| and |u| give respectively the height-plus-depth of the tallest
+page and the width of the widest page, in the same units as other dimensions of
+the file. These numbers might be used by a \.{DVI}-reading program to position
+individual ``pages'' on large sheets of film or paper; however, the standard
+convention for output on normal size paper is to position each page so that the
+upper left-hand corner is exactly one inch from the left and the top. Experience
+has shown that it is unwise to design \.{DVI}-to-printer software that attempts
+cleverly to center the output; a fixed position of the upper left corner is
+easiest for users to understand and to work with. Therefore |l| and~|u| are often
+ignored. Parameter |s| is the maximum stack depth (i.e., the largest excess of
+
+|push| commands over |pop| commands) needed to process this file. Then comes |t|,
+the total number of pages (|bop| commands) present.
+
+The postamble continues with font definitions, which are any number of
+\\{fnt\_def} commands as described above, possibly interspersed with |nop|
+commands. Each font number that is used in the \.{DVI} file must be defined
+exactly twice: Once before it is first selected by a \\{fnt} command, and once in
+the postamble.
+
+The last part of the postamble, following the |post_post| byte that signifies the
+end of the font definitions, contains |q|, a pointer to the |post| command that
+started the postamble. An identification byte, |i|, comes next; this currently
+equals~2, as in the preamble.
+
+The |i| byte is followed by four or more bytes that are all equal to the decimal
+number 223 (i.e., '337 in octal). \TeX\ puts out four to seven of these trailing
+bytes, until the total length of the file is a multiple of four bytes, since this
+works out best on machines that pack four bytes per word; but any number of 223's
+is allowed, as long as there are at least four of them. In effect, 223 is a sort
+of signature that is added at the very end.
+
+This curious way to finish off a \.{DVI} file makes it feasible for
+\.{DVI}-reading programs to find the postamble first, on most computers, even
+though \TeX\ wants to write the postamble last. Most operating systems permit
+random access to individual words or bytes of a file, so the \.{DVI} reader can
+start at the end and skip backwards over the 223's until finding the
+identification byte. Then it can back up four bytes, read |q|, and move to byte
+|q| of the file. This byte should, of course, contain the value 248 (|post|); now
+the postamble can be read, so the \.{DVI} reader can discover all the information
+needed for typesetting the pages. Note that it is also possible to skip through
+the \.{DVI} file at reasonably high speed to locate a particular page, if that
+proves desirable. This saves a lot of time, since \.{DVI} files used in
+production jobs tend to be large.
+
+Unfortunately, however, standard \PASCAL\ does not include the ability to access
+a random position in a file, or even to determine the length of a file. Almost
+all systems nowadays provide the necessary capabilities, so \.{DVI} format has
+been designed to work most efficiently with modern operating systems. But if
+\.{DVI} files have to be processed under the restrictions of standard \PASCAL,
+one can simply read them from front to back, since the necessary header
+information is present in the preamble and in the font definitions. (The |l| and
+|u| and |s| and |t| parameters, which appear only in the postamble, are
+``frills'' that are handy but not absolutely necessary.)
+
+After considering \TeX's eyes and stomach, we come now to the bowels.
+
+The |ship_out| procedure is given a pointer to a box; its mission is to describe
+that box in \.{DVI} form, outputting a ``page'' to |dvi_file|. The \.{DVI}
+coordinates $(h,v)=(0,0)$ should correspond to the upper left corner of the box
+being shipped.
+
+Since boxes can be inside of boxes inside of boxes, the main work of |ship_out|
+is done by two mutually recursive routines, |hlist_out| and |vlist_out|, which
+traverse the hlists and vlists inside of horizontal and vertical boxes.
+
+As individual pages are being processed, we need to accumulate information about
+the entire set of pages, since such statistics must be reported in the postamble.
+The global variables |total_pages|, |max_v|, |max_h|, |max_push|, and |last_bop|
+are used to record this information.
+
+The variable |doing_leaders| is |true| while leaders are being output. The
+variable |dead_cycles| contains the number of times an output routine has been
+initiated since the last |ship_out|.
+
+A few additional global variables are also defined here for use in |vlist_out|
+and |hlist_out|. They could have been local variables, but that would waste stack
+space when boxes are deeply nested, since the values of these variables are not
+needed during recursive calls.
+
+*/
+
+/* Some global variables are defined in |backend| module. */
+
+static int max_push = 0;  /* deepest nesting of |push| commands encountered so far */
+static int last_bop = -1; /* location of previous |bop| in the \.{DVI} output */
+static int oval, ocmd;    /* used by |out_cmd| for generating |set|, |fnt| and |fnt_def| commands */
+pointer g;                /* current glue specification */
+
+/*tex
+
+The \.{DVI} bytes are output to a buffer instead of being written directly to the
+output file. This makes it possible to reduce the overhead of subroutine calls,
+thereby measurably speeding up the computation, since output of \.{DVI} bytes is
+part of \TeX's inner loop. And it has another advantage as well, since we can
+change instructions in the buffer in order to make the output more compact. For
+example, a `|down2|' command can be changed to a `|y2|', thereby making a
+subsequent `|y0|' command possible, saving two bytes.
+
+The output buffer is divided into two parts of equal size; the bytes found in
+|dvi_buf[0..half_buf-1]| constitute the first half, and those in
+|dvi_buf[half_buf..dvi_buf_size-1]| constitute the second. The global variable
+|dvi_ptr| points to the position that will receive the next output byte. When
+|dvi_ptr| reaches |dvi_limit|, which is always equal to one of the two values
+|half_buf| or |dvi_buf_size|, the half buffer that is about to be invaded next is
+sent to the output and |dvi_limit| is changed to its other value. Thus, there is
+always at least a half buffer's worth of information present, except at the very
+beginning of the job.
+
+Bytes of the \.{DVI} file are numbered sequentially starting with 0; the next
+byte to be generated will be number |dvi_offset+dvi_ptr|. A byte is present in
+the buffer only if its number is |>=dvi_gone|.
+
+Some systems may find it more efficient to make |dvi_buf| a |packed| array, since
+output of four bytes at once may be facilitated.
+
+Initially the buffer is all in one piece; we will output half of it only after it
+first fills up.
+
+*/
+
+int dvi_buf_size = 800;     /* size of the output buffer; must be a multiple of 8 */
+eight_bits *dvi_buf;        /* buffer for \.{DVI} output */
+static int half_buf = 0;    /* half of |dvi_buf_size| */
+static int dvi_limit = 0;   /* end of the current half buffer */
+static int dvi_ptr = 0;     /* the next available buffer address */
+static int dvi_offset = 0;  /* |dvi_buf_size| times the number of times the output buffer has been fully emptied */
+static int dvi_gone = 0;    /* the number of bytes already output to |dvi_file| */
+
+/*
+To put a byte in the buffer without paying the cost of invoking a procedure
+each time, we use the macro |dvi_out|.
+*/
+
+#define dvi_out(A) do {                 \
+	dvi_buf[dvi_ptr++]=(eight_bits)(A);	\
+    if (dvi_ptr==dvi_limit) dvi_swap(); \
+} while (0)
+
+#define dvi_set(A,B) do {                       \
+    oval=A; ocmd=set1; out_cmd(); dvi.h += (B); \
+} while (0)
+
+#define dvi_put(A)  do {          \
+    oval=A; ocmd=put1; out_cmd(); \
+} while (0)
+
+/*
+The |vinfo| fields in the entries of the down stack or the right stack
+have six possible settings: |y_here| or |z_here| mean that the \.{DVI}
+command refers to |y| or |z|, respectively (or to |w| or |x|, in the
+case of horizontal motion); |yz_OK| means that the \.{DVI} command is
+\\{down} (or \\{right}) but can be changed to either |y| or |z| (or
+to either |w| or |x|); |y_OK| means that it is \\{down} and can be changed
+to |y| but not |z|; |z_OK| is similar; and |d_fixed| means it must stay
+\\{down}.
+
+The four settings |yz_OK|, |y_OK|, |z_OK|, |d_fixed| would not need to
+be distinguished from each other if we were simply solving the
+digit-subscripting problem mentioned above. But in \TeX's case there is
+a complication because of the nested structure of |push| and |pop|
+commands. Suppose we add parentheses to the digit-subscripting problem,
+redefining hits so that $\delta_y\ldots \delta_y$ is a hit if all $y$'s between
+the $\delta$'s are enclosed in properly nested parentheses, and if the
+parenthesis level of the right-hand $\delta_y$ is deeper than or equal to
+that of the left-hand one. Thus, `(' and `)' correspond to `|push|'
+and `|pop|'. Now if we want to assign a subscript to the final 1 in the
+sequence
+$$2_y\,7_d\,1_d\,(\,8_z\,2_y\,8_z\,)\,1$$
+we cannot change the previous $1_d$ to $1_y$, since that would invalidate
+the $2_y\ldots2_y$ hit. But we can change it to $1_z$, scoring a hit
+since the intervening $8_z$'s are enclosed in parentheses.
+*/
+
+typedef enum {
+    y_here = 1,                 /* |vinfo| when the movement entry points to a |y| command */
+    z_here = 2,                 /* |vinfo| when the movement entry points to a |z| command */
+    yz_OK = 3,                  /* |vinfo| corresponding to an unconstrained \\{down} command */
+    y_OK = 4,                   /* |vinfo| corresponding to a \\{down} that can't become a |z| */
+    z_OK = 5,                   /* |vinfo| corresponding to a \\{down} that can't become a |y| */
+    d_fixed = 6,                /* |vinfo| corresponding to a \\{down} that can't change */
+} movement_codes;
+
+/* As we search through the stack, we are in one of three states,
+   |y_seen|, |z_seen|, or |none_seen|, depending on whether we have
+   encountered |y_here| or |z_here| nodes. These states are encoded as
+   multiples of 6, so that they can be added to the |info| fields for quick
+   decision-making. */
+
+#  define none_seen 0           /* no |y_here| or |z_here| nodes have been encountered yet */
+#  define y_seen 6              /* we have seen |y_here| but not |z_here| */
+#  define z_seen 12             /* we have seen |z_here| but not |y_here| */
+
+void movement(scaled w, eight_bits o);
+
+/*
+extern void prune_movements(int l);
+*/
+
+/*
+The actual distances by which we want to move might be computed as the
+sum of several separate movements. For example, there might be several
+glue nodes in succession, or we might want to move right by the width of
+some box plus some amount of glue. More importantly, the baselineskip
+distances are computed in terms of glue together with the depth and
+height of adjacent boxes, and we want the \.{DVI} file to lump these
+three quantities together into a single motion.
+
+Therefore, \TeX\ maintains two pairs of global variables: |dvi.h| and |dvi.v|
+are the |h| and |v| coordinates corresponding to the commands actually
+output to the \.{DVI} file, while |cur.h| and |cur.v| are the coordinates
+corresponding to the current state of the output routines. Coordinate
+changes will accumulate in |cur.h| and |cur.v| without being reflected
+in the output, until such a change becomes necessary or desirable; we
+can call the |movement| procedure whenever we want to make |dvi.h=pos.h|
+or |dvi.v=pos.v|.
+
+The current font reflected in the \.{DVI} output is called |dvi_f|;
+there is no need for a `\\{cur\_f}' variable.
+
+The depth of nesting of |hlist_out| and |vlist_out| is called |cur_s|;
+this is essentially the depth of |push| commands in the \.{DVI} output.
+*/
+
+/*tex A \.{DVI} position in page coordinates, in sync with DVI file: */
+
+static scaledpos dvi;
+
+#  define synch_h(p) do {            \
+    if (p.h != dvi.h) {              \
+      movement(p.h - dvi.h, right1); \
+      dvi.h = p.h;                   \
+    }                                \
+  } while (0)
+
+#  define synch_v(p) do {            \
+    if (p.v != dvi.v) {              \
+      movement(dvi.v - p.v, down1);  \
+      dvi.v = p.v;                   \
+    }                                \
+  } while (0)
+
+#  define synch_dvi_with_pos(p) do {synch_h(p); synch_v(p); } while (0)
+
+/*tex
+
+The actual output of |dvi_buf[a..b]| to |dvi_file| is performed by calling
+|write_dvi(a,b)|. For best results, this procedure should be optimized to run as
+fast as possible on each particular system, since it is part of \TeX's inner
+loop. It is safe to assume that |a| and |b+1| will both be multiples of 4 when
+|write_dvi(a,b)| is called; therefore it is possible on many machines to use
+efficient methods to pack four bytes per word and to output an array of words
+with one system call.
+
+*/
+
+static void write_dvi(int a, int b)
+{
+    int k;
+    for (k = a; k <= b; k++)
+        fputc(dvi_buf[k], static_pdf->file);
+}
+
+/*tex This outputs half of the buffer: */
+
+static void dvi_swap(void)
+{
+    if (dvi_limit == dvi_buf_size) {
+        write_dvi(0, half_buf - 1);
+        dvi_limit = half_buf;
+        dvi_offset = dvi_offset + dvi_buf_size;
+        dvi_ptr = 0;
+    } else {
+        write_dvi(half_buf, dvi_buf_size - 1);
+        dvi_limit = dvi_buf_size;
+    }
+    dvi_gone = dvi_gone + half_buf;
+}
+
+/*tex
+
+The |dvi_four| procedure outputs four bytes in two's complement notation, without
+risking arithmetic overflow.
+
+*/
+
+static void dvi_four(int x)
+{
+    if (x >= 0) {
+        dvi_out(x / 0100000000);
+    } else {
+        x = x + 010000000000;
+        x = x + 010000000000;
+        dvi_out((x / 0100000000) + 128);
+    }
+    x = x % 0100000000;
+    dvi_out(x / 0200000);
+    x = x % 0200000;
+    dvi_out(x / 0400);
+    dvi_out(x % 0400);
+}
+
+/*tex
+
+A mild optimization of the output is performed by the |dvi_pop| routine, which
+issues a |pop| unless it is possible to cancel a `|push| |pop|' pair. The
+parameter to |dvi_pop| is the byte address following the old |push| that matches
+the new |pop|.
+
+*/
+
+static void dvi_push(void)
+{
+    dvi_out(push);
+}
+
+static void dvi_pop(int l)
+{
+    if ((l == dvi_offset + dvi_ptr) && (dvi_ptr > 0))
+        decr(dvi_ptr);
+    else
+        dvi_out(pop);
+}
+
+/*tex
+
+Here's a procedure that outputs a font definition. $\Omega$ allows more than 256
+different fonts per job, so the right font definition command must be selected.
+
+*/
+
+static void out_cmd(void)
+{
+    if ((oval < 0x100) && (oval >= 0)) {
+        if ((ocmd != set1) || (oval > 127)) {
+            if ((ocmd == fnt1) && (oval < 64))
+                oval += fnt_num_0;
+            else
+                dvi_out(ocmd);
+        }
+    } else {
+        if ((oval < 0x10000) && (oval >= 0)) {
+            dvi_out(ocmd + 1);
+        } else {
+            if ((oval < 0x1000000) && (oval >= 0)) {
+                dvi_out(ocmd + 2);
+            } else {
+                dvi_out(ocmd + 3);
+                if (oval >= 0) {
+                    dvi_out(oval / 0x1000000);
+                } else {
+                    oval += 0x40000000;
+                    oval += 0x40000000;
+                    dvi_out((oval / 0x1000000) + 128);
+                    oval = oval % 0x1000000;
+                }
+                dvi_out(oval / 0x10000);
+                oval = oval % 0x10000;
+            }
+            dvi_out(oval / 0x10000);
+            oval = oval % 0x10000;
+        }
+        dvi_out(oval / 0x100);
+        oval = oval % 0x100;
+    }
+    dvi_out(oval);
+}
+
+static void dvi_font_def(internal_font_number f)
+{
+    char *fa;
+    oval = f - 1;
+    ocmd = fnt_def1;
+    out_cmd();
+    dvi_out(font_check_0(f));
+    dvi_out(font_check_1(f));
+    dvi_out(font_check_2(f));
+    dvi_out(font_check_3(f));
+    dvi_four(font_size(f));
+    dvi_four(font_dsize(f));
+    dvi_out(0);                 /* |font_area(f)| is unused */
+    dvi_out(strlen(font_name(f)));
+    /* Output the font name whose internal number is |f| */
+    fa = font_name(f);
+    while (*fa != '\0') {
+        dvi_out(*fa++);
+    }
+}
+
+/*tex
+
+Versions of \TeX\ intended for small computers might well choose to omit the
+ideas in the next few parts of this program, since it is not really necessary to
+optimize the \.{DVI} code by making use of the |w0|, |x0|, |y0|, and |z0|
+commands. Furthermore, the algorithm that we are about to describe does not
+pretend to give an optimum reduction in the length of the \.{DVI} code; after
+all, speed is more important than compactness. But the method is surprisingly
+effective, and it takes comparatively little time.
+
+We can best understand the basic idea by first considering a simpler problem that
+has the same essential characteristics. Given a sequence of digits, say
+$3\,1\,4\,1\,5\,9\,2\,6\,5\,3\,5\,8\,9$, we want to assign subscripts $d$, $y$,
+or $z$ to each digit so as to maximize the number of ``$y$-hits'' and
+``$z$-hits''; a $y$-hit is an instance of two appearances of the same digit with
+the subscript $y$, where no $y$'s intervene between the two appearances, and a
+$z$-hit is defined similarly. For example, the sequence above could be decorated
+with subscripts as follows:
+$$3_z\,1_y\,4_d\,1_y\,5_y\,9_d\,2_d\,6_d\,5_y\,3_z\,5_y\,8_d\,9_d.$$ There are
+three $y$-hits ($1_y\ldots1_y$ and $5_y\ldots5_y\ldots5_y$) and one $z$-hit
+($3_z\ldots3_z$); there are no $d$-hits, since the two appearances of $9_d$ have
+$d$'s between them, but we don't count $d$-hits so it doesn't matter how many
+there are. These subscripts are analogous to the \.{DVI} commands called
+\\{down}, $y$, and $z$, and the digits are analogous to different amounts of
+vertical motion; a $y$-hit or $z$-hit corresponds to the opportunity to use the
+one-byte commands |y0| or |z0| in a \.{DVI} file.
+
+\TeX's method of assigning subscripts works like this: Append a new digit, say
+$\delta$, to the right of the sequence. Now look back through the sequence until
+one of the following things happens: (a)~You see $\delta_y$ or $\delta_z$, and
+this was the first time you encountered a $y$ or $z$ subscript, respectively.
+Then assign $y$ or $z$ to the new $\delta$; you have scored a hit. (b)~You see
+$\delta_d$, and no $y$ subscripts have been encountered so far during this
+search. Then change the previous $\delta_d$ to $\delta_y$ (this corresponds to
+changing a command in the output buffer), and assign $y$ to the new $\delta$;
+it's another hit. (c)~You see $\delta_d$, and a $y$ subscript has been seen but
+not a $z$. Change the previous $\delta_d$ to $\delta_z$ and assign $z$ to the new
+$\delta$. (d)~You encounter both $y$ and $z$ subscripts before encountering a
+suitable $\delta$, or you scan all the way to the front of the sequence. Assign
+$d$ to the new $\delta$; this assignment may be changed later.
+
+The subscripts $3_z\,1_y\,4_d\ldots\,$ in the example above were, in fact,
+produced by this procedure, as the reader can verify. (Go ahead and try it.)
+
+In order to implement such an idea, \TeX\ maintains a stack of pointers to the
+\\{down}, $y$, and $z$ commands that have been generated for the current page.
+And there is a similar stack for \\{right}, |w|, and |x| commands. These stacks
+are called the down stack and right stack, and their top elements are maintained
+in the variables |down_ptr| and |right_ptr|.
+
+Each entry in these stacks contains four fields: The |width| field is the amount
+of motion down or to the right; the |location| field is the byte number of the
+\.{DVI} command in question (including the appropriate |dvi_offset|); the |vlink|
+field points to the next item below this one on the stack; and the |vinfo| field
+encodes the options for possible change in the \.{DVI} command.
+
+*/
+
+/*tex The \.{DVI} byte number for a movement command: */
+
+#define location(A) varmem[(A)+1].cint
+
+/*tex The heads of the down and right stacks: */
+
+static halfword down_ptr = null;
+static halfword right_ptr = null;
+
+/*tex
+
+Here is a subroutine that produces a \.{DVI} command for some specified downward
+or rightward motion. It has two parameters: |w| is the amount of motion, and |o|
+is either |down1| or |right1|. We use the fact that the command codes have
+convenient arithmetic properties: |y1-down1=w1-right1| and |z1-down1=x1-right1|.
+
+*/
+
+void movement(scaled w, eight_bits o)
+{
+    small_number mstate;        /* have we seen a |y| or |z|? */
+    halfword p, q;              /* current and top nodes on the stack */
+    int k;                      /* index into |dvi_buf|, modulo |dvi_buf_size| */
+    /*tex something todo? */
+    if (false) {
+        /*tex new node for the top of the stack */
+        q = new_node(movement_node, 0);
+        width(q) = w;
+        location(q) = dvi_offset + dvi_ptr;
+        if (o == down1) {
+            vlink(q) = down_ptr;
+            down_ptr = q;
+        } else {
+            vlink(q) = right_ptr;
+            right_ptr = q;
+        }
+        /*tex
+
+            Look at the other stack entries until deciding what sort of \.{DVI}
+            command to generate; |goto found| if node |p| is a ``hit''.
+        */
+        p = vlink(q);
+        mstate = none_seen;
+        while (p != null) {
+            if (width(p) == w) {
+                /*
+                    Consider a node with matching width;|goto found| if it's a
+                    hit. We might find a valid hit in a |y| or |z| byte that is
+                    already gone from the buffer. But we can't change bytes that
+                    are gone forever; ``the moving finger writes, $\ldots\,\,$.''
+                */
+                switch (mstate + vinfo(p)) {
+                    case none_seen + yz_OK:
+                    case none_seen + y_OK:
+                    case z_seen + yz_OK:
+                    case z_seen + y_OK:
+                        if (location(p) < dvi_gone) {
+                            goto NOT_FOUND;
+                        } else {
+                            /* Change buffered instruction to |y| or |w| and |goto found| */
+                            k = location(p) - dvi_offset;
+                            if (k < 0)
+                                k = k + dvi_buf_size;
+                            dvi_buf[k] = (eight_bits) (dvi_buf[k] + y1 - down1);
+                            vinfo(p) = y_here;
+                            goto FOUND;
+                        }
+                        break;
+                    case none_seen + z_OK:
+                    case y_seen + yz_OK:
+                    case y_seen + z_OK:
+                        if (location(p) < dvi_gone) {
+                            goto NOT_FOUND;
+                        } else {
+                            /* Change buffered instruction to |z| or |x| and |goto found| */
+                            k = location(p) - dvi_offset;
+                            if (k < 0)
+                                k = k + dvi_buf_size;
+                            dvi_buf[k] = (eight_bits) (dvi_buf[k] + z1 - down1);
+                            vinfo(p) = z_here;
+                            goto FOUND;
+                        }
+                        break;
+                    case none_seen + y_here:
+                    case none_seen + z_here:
+                    case y_seen + z_here:
+                    case z_seen + y_here:
+                        goto FOUND;
+                        break;
+                    default:
+                        break;
+                }
+            } else {
+                switch (mstate + vinfo(p)) {
+                    case none_seen + y_here:
+                        mstate = y_seen;
+                        break;
+                    case none_seen + z_here:
+                        mstate = z_seen;
+                        break;
+                    case y_seen + z_here:
+                    case z_seen + y_here:
+                        goto NOT_FOUND;
+                        break;
+                    default:
+                        break;
+                }
+            }
+            p = vlink(p);
+        }
+    }
+  NOT_FOUND:
+    /*tex
+        Generate a |down| or |right| command for |w| and |return|:
+    */
+    if (abs(w) >= 040000000) {
+        /*tex |down4| or |right4| */
+        dvi_out(o + 3);
+        dvi_four(w);
+        return;
+    }
+    if (abs(w) >= 0100000) {
+        /*tex |down3| or |right3| */
+        dvi_out(o + 2);
+        if (w < 0)
+            w = w + 0100000000;
+        dvi_out(w / 0200000);
+        w = w % 0200000;
+        goto TWO;
+    }
+    if (abs(w) >= 0200) {
+        /*tex |down2| or |right2| */
+        dvi_out(o + 1);
+        if (w < 0)
+            w = w + 0200000;
+        goto TWO;
+    }
+    /*tex |down1| or |right1| */
+    dvi_out(o);
+    if (w < 0)
+        w = w + 0400;
+    goto ONE;
+  TWO:
+    dvi_out(w / 0400);
+  ONE:
+    dvi_out(w % 0400);
+    return;
+  FOUND:
+    /*tex
+
+        Generate a |y0| or |z0| command in order to reuse a previous appearance
+        of~|w|.
+
+        The program below removes movement nodes that are introduced after a
+        |push|, before it outputs the corresponding |pop|.
+
+        When the |movement| procedure gets to the label |found|, the value of
+        |vinfo(p)| will be either |y_here| or |z_here|. If it is, say, |y_here|,
+        the procedure generates a |y0| command (or a |w0| command), and marks all
+        |vinfo| fields between |q| and |p| so that |y| is not OK in that range.
+
+     */
+    vinfo(q) = vinfo(p);
+    if (vinfo(q) == y_here) {
+        /*tex |y0| or |w0| */
+        dvi_out(o + y0 - down1);
+        while (vlink(q) != p) {
+            q = vlink(q);
+            switch (vinfo(q)) {
+            case yz_OK:
+                vinfo(q) = z_OK;
+                break;
+            case y_OK:
+                vinfo(q) = d_fixed;
+                break;
+            default:
+                break;
+            }
+        }
+    } else {
+        /*tex |z0| or |x0| */
+        dvi_out(o + z0 - down1);
+        while (vlink(q) != p) {
+            q = vlink(q);
+            switch (vinfo(q)) {
+            case yz_OK:
+                vinfo(q) = y_OK;
+                break;
+            case z_OK:
+                vinfo(q) = d_fixed;
+                break;
+            default:
+                break;
+            }
+        }
+    }
+}
+
+/*tex
+
+In case you are wondering when all the movement nodes are removed from \TeX's
+memory, the answer is that they are recycled just before |hlist_out| and
+|vlist_out| finish outputting a box. This restores the down and right stacks to
+the state they were in before the box was output, except that some |vinfo|'s may
+have become more restrictive.
+
+Here we delete movement nodes with |location>=l|:
+
+*/
+
+static void prune_movements(int l)
+{
+    pointer p;
+    while (down_ptr != null) {
+        if (location(down_ptr) < l)
+            break;
+        p = down_ptr;
+        down_ptr = vlink(p);
+        flush_node(p);
+    }
+    while (right_ptr != null) {
+        if (location(right_ptr) < l)
+            return;
+        p = right_ptr;
+        right_ptr = vlink(p);
+        flush_node(p);
+    }
+}
+
+/*tex
+
+When |hlist_out| is called, its duty is to output the box represented by the
+|hlist_node| pointed to by |temp_ptr|. The reference point of that box has
+coordinates |(cur.h,cur.v)|.
+
+Similarly, when |vlist_out| is called, its duty is to output the box represented
+by the |vlist_node| pointed to by |temp_ptr|. The reference point of that box has
+coordinates |(cur.h,cur.v)|.
+
+The recursive procedures |hlist_out| and |vlist_out| each have a local variable
+|save_dvi| to hold the value of |dvi| just before entering a new level of
+recursion. In effect, the value of |save_dvi| on \TeX's run-time stack
+corresponds to the values of |h| and |v| that a \.{DVI}-reading program will push
+onto its coordinate stack.
+
+*/
+
+void dvi_place_rule(PDF pdf, halfword q, scaledpos size)
+{
+    synch_dvi_with_pos(pdf->posstruct->pos);
+    if ((subtype(q) >= box_rule) && (subtype(q) <= user_rule)) {
+        /*tex place nothing, only take space */
+        if (textdir_is_L(pdf->posstruct->dir))
+            dvi.h += size.h;
+    } else {
+        /*tex normal_rule or >= 100 being a leader rule */
+        if (textdir_is_L(pdf->posstruct->dir)) {
+            /*tex movement optimization for |dir_*L*| */
+            dvi_out(set_rule);
+            dvi.h += size.h;
+        } else
+            dvi_out(put_rule);
+    }
+    dvi_four(size.v);
+    dvi_four(size.h);
+}
+
+void dvi_place_glyph(PDF pdf, internal_font_number f, int c, int ex)
+{
+    scaled_whd ci;
+    synch_dvi_with_pos(pdf->posstruct->pos);
+    if (f != pdf->f_cur) {
+        /*tex Change font |f_cur| to |f| */
+        if (!font_used(f)) {
+            dvi_font_def(f);
+            set_font_used(f, true);
+        }
+        oval = f - 1;
+        ocmd = fnt1;
+        out_cmd();
+        pdf->f_cur = f;
+    }
+    if (textdir_is_L(pdf->posstruct->dir)) {
+        ci = get_charinfo_whd(f, c);
+        /*tex movement optimization for |dir_*L*| */
+        dvi_set(c, ci.wd);
+    } else {
+        dvi_put(c);
+    }
+}
+
+void dvi_special(PDF pdf, halfword p)
+{
+    /*tex holds print |selector| */
+    int old_setting;
+    /*tex index into |cur_string| */
+    unsigned k;
+    synch_dvi_with_pos(pdf->posstruct->pos);
+    old_setting = selector;
+    selector = new_string;
+    show_token_list(token_link(write_tokens(p)), null, -1);
+    selector = old_setting;
+    if (cur_length < 256) {
+        dvi_out(xxx1);
+        dvi_out(cur_length);
+    } else {
+        dvi_out(xxx4);
+        dvi_four((int) cur_length);
+    }
+    for (k = 0; k < cur_length; k++) {
+        dvi_out(cur_string[k]);
+    }
+    /*tex erase the string */
+    cur_length = 0;
+}
+
+/*tex
+
+Here's an example of how these conventions are used. Whenever it is time to ship
+out a box of stuff, we shall use the macro |ensure_dvi_open|.
+
+*/
+
+void dvi_write_header(PDF pdf)
+{
+    unsigned l;
+    /*tex index into |str_pool| */
+    unsigned s;
+    /*tex saved |selector| setting */
+    int old_setting;
+    if (half_buf == 0) {
+        half_buf = dvi_buf_size / 2;
+        dvi_limit = dvi_buf_size;
+    }
+    dvi_out(pre);
+    /*tex output the preamble */
+    dvi_out(id_byte);
+    dvi_four(25400000);
+    /*tex conversion ratio for sp */
+    dvi_four(473628672);
+    prepare_mag();
+    /*tex magnification factor is frozen */
+    dvi_four(mag_par);
+    if (output_comment) {
+        l = (unsigned) strlen(output_comment);
+        dvi_out(l);
+        for (s = 0; s < l; s++) {
+            dvi_out(output_comment[s]);
+        }
+    } else {
+        /*tex the default code is unchanged */
+        old_setting = selector;
+        selector = new_string;
+        tprint(" LuaTeX output ");
+        print_int(year_par);
+        print_char('.');
+        print_two(month_par);
+        print_char('.');
+        print_two(day_par);
+        print_char(':');
+        print_two(time_par / 60);
+        print_two(time_par % 60);
+        selector = old_setting;
+        dvi_out(cur_length);
+        for (s = 0; s < cur_length; s++)
+            dvi_out(cur_string[s]);
+        cur_length = 0;
+    }
+}
+
+void dvi_begin_page(PDF pdf)
+{
+    int k;
+    /*tex location of the current |bop| */
+    int page_loc;
+    ensure_output_state(pdf, ST_HEADER_WRITTEN);
+    /*tex Initialize variables as |ship_out| begins */
+    page_loc = dvi_offset + dvi_ptr;
+    dvi_out(bop);
+    for (k = 0; k <= 9; k++)
+        dvi_four(count(k));
+    dvi_four(last_bop);
+    last_bop = page_loc;
+}
+
+void dvi_end_page(PDF pdf)
+{
+    (void) pdf;
+    dvi_out(eop);
+}
+
+/*tex
+
+At the end of the program, we must finish things off by writing the post\-amble.
+If |total_pages=0|, the \.{DVI} file was never opened. If |total_pages>=65536|,
+the \.{DVI} file will lie. And if |max_push>=65536|, the user deserves whatever
+chaos might ensue.
+
+*/
+
+void dvi_open_file(PDF pdf) {
+    ensure_output_file_open(pdf, ".dvi");
+}
+
+void dvi_finish_file(PDF pdf, int fatal_error)
+{
+    int k;
+    int callback_id = callback_defined(stop_run_callback);
+    if (fatal_error) {
+        print_err(" ==> Fatal error occurred, bad output DVI file produced!");
+    }
+    while (cur_s > -1) {
+        if (cur_s > 0) {
+            dvi_out(pop);
+        } else {
+            dvi_out(eop);
+            incr(total_pages);
+        }
+        decr(cur_s);
+    }
+    if (total_pages == 0) {
+        if (callback_id == 0) {
+            tprint_nl("No pages of output.");
+            print_ln();
+        } else if (callback_id > 0) {
+            run_callback(callback_id, "->");
+        }
+    } else {
+        /*tex beginning of the postamble */
+        dvi_out(post);
+        dvi_four(last_bop);
+        last_bop = dvi_offset + dvi_ptr - 5;
+        /*tex |post| location */
+        dvi_four(25400000);
+        /*tex conversion ratio for sp */
+        dvi_four(473628672);
+        prepare_mag();
+        /*tex magnification factor */
+        dvi_four(mag_par);
+        dvi_four(max_v);
+        dvi_four(max_h);
+        dvi_out(max_push / 256);
+        dvi_out(max_push % 256);
+        dvi_out((total_pages / 256) % 256);
+        dvi_out(total_pages % 256);
+        /*tex Output the font definitions for all fonts that were used */
+        k = max_font_id();
+        while (k > 0) {
+            if (font_used(k)) {
+                dvi_font_def(k);
+            }
+            decr(k);
+        }
+        dvi_out(post_post);
+        dvi_four(last_bop);
+        dvi_out(id_byte);
+        /*tex the number of 223's */
+#ifndef IPC
+        k = 4 + ((dvi_buf_size - dvi_ptr) % 4);
+#else
+        k = 7 - ((3 + dvi_offset + dvi_ptr) % 4);
+#endif
+        while (k > 0) {
+            dvi_out(223);
+            decr(k);
+        }
+        /*tex
+            Here is how we clean out the buffer when \TeX\ is all through;
+            |dvi_ptr| will be a multiple of~4.
+        */
+        if (dvi_limit == half_buf)
+            write_dvi(half_buf, dvi_buf_size - 1);
+        if (dvi_ptr > 0)
+            write_dvi(0, dvi_ptr - 1);
+        if (callback_id == 0) {
+            tprint_nl("Output written on ");
+            tprint(pdf->file_name);
+            tprint(" (");
+            print_int(total_pages);
+            tprint(" page");
+            if (total_pages != 1)
+                print_char('s');
+            tprint(", ");
+            print_int(dvi_offset + dvi_ptr);
+            tprint(" bytes).");
+        } else if (callback_id > 0) {
+            run_callback(callback_id, "->");
+        }
+        close_file(pdf->file);
+    }
+}
+
+void dvi_push_list(PDF pdf, scaledpos *saved_pos, int *saved_loc)
+{
+    if (cur_s > max_push) {
+        max_push = cur_s;
+    }
+    if (cur_s > 0) {
+        dvi_push();
+        *saved_pos = dvi;
+    }
+    *saved_loc = dvi_offset + dvi_ptr;
+}
+
+void dvi_pop_list(PDF pdf, scaledpos *saved_pos, int *saved_loc)
+{
+    prune_movements(*saved_loc);
+    if (cur_s > 0) {
+        dvi_pop(*saved_loc);
+        dvi = *saved_pos;
+    }
+}
+
+void dvi_set_reference_point(PDF pdf, posstructure *refpoint)
+{
+    refpoint->pos.h = one_true_inch;
+    refpoint->pos.v = pdf->page_size.v - one_true_inch;
+    dvi = refpoint->pos;
+}
+
+int dvi_get_status_ptr(PDF pdf)
+{
+    return dvi_ptr;
+}
+
+int dvi_get_status_gone(PDF pdf)
+{
+    return dvi_gone;
+}
diff --git a/texk/web2c/luatexdir/dvi/dvigen.w b/texk/web2c/luatexdir/dvi/dvigen.w
deleted file mode 100644
index d991445a5..000000000
--- a/texk/web2c/luatexdir/dvi/dvigen.w
+++ /dev/null
@@ -1,1258 +0,0 @@
-% dvigen.w
-%
-% Copyright 2009-2013 Taco Hoekwater <taco@@luatex.org>
-%
-% This file is part of LuaTeX.
-%
-% LuaTeX is free software; you can redistribute it and/or modify it under
-% the terms of the GNU General Public License as published by the Free
-% Software Foundation; either version 2 of the License, or (at your
-% option) any later version.
-%
-% LuaTeX is distributed in the hope that it will be useful, but WITHOUT
-% ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-% FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
-% License for more details.
-%
-% You should have received a copy of the GNU General Public License along
-% with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
-
-\def\MF{MetaFont}
-\def\MP{MetaPost}
-\def\PASCAL{Pascal}
-\def\[#1]{#1}
-\pdfoutput=1
-\pdfmapline{cmtex10 < cmtex10.pfb}
-\pdfmapfile{pdftex.map}
-
-\title{: generation of DVI output}
-
-@ Initial identification of this file, and the needed headers.
-@c
-#include "ptexlib.h"
-
-@ Here is the start of the actual C file.
-@c
-#undef write_dvi
-
-/* todo: move macros to api */
-
-#define mode cur_list.mode_field        /* current mode */
-
-@ The most important output produced by a run of \TeX\ is the ``device
-independent'' (\.{DVI}) file that specifies where characters and rules
-are to appear on printed pages. The form of these files was designed by
-David R. Fuchs in 1979. Almost any reasonable typesetting device can be
-@^Fuchs, David Raymond@>
-@:DVI_files}{\.{DVI} files@>
-driven by a program that takes \.{DVI} files as input, and dozens of such
-\.{DVI}-to-whatever programs have been written. Thus, it is possible to
-print the output of \TeX\ on many different kinds of equipment, using \TeX\
-as a device-independent ``front end.''
-
-A \.{DVI} file is a stream of 8-bit bytes, which may be regarded as a
-series of commands in a machine-like language. The first byte of each command
-is the operation code, and this code is followed by zero or more bytes
-that provide parameters to the command. The parameters themselves may consist
-of several consecutive bytes; for example, the `|set_rule|' command has two
-parameters, each of which is four bytes long. Parameters are usually
-regarded as nonnegative integers; but four-byte-long parameters,
-and shorter parameters that denote distances, can be
-either positive or negative. Such parameters are given in two's complement
-notation. For example, a two-byte-long distance parameter has a value between
-$-2^{15}$ and $2^{15}-1$. As in \.{TFM} files, numbers that occupy
-more than one byte position appear in BigEndian order.
-
-A \.{DVI} file consists of a ``preamble,'' followed by a sequence of one
-or more ``pages,'' followed by a ``postamble.'' The preamble is simply a
-|pre| command, with its parameters that define the dimensions used in the
-file; this must come first.  Each ``page'' consists of a |bop| command,
-followed by any number of other commands that tell where characters are to
-be placed on a physical page, followed by an |eop| command. The pages
-appear in the order that \TeX\ generated them. If we ignore |nop| commands
-and \\{fnt\_def} commands (which are allowed between any two commands in
-the file), each |eop| command is immediately followed by a |bop| command,
-or by a |post| command; in the latter case, there are no more pages in the
-file, and the remaining bytes form the postamble.  Further details about
-the postamble will be explained later.
-
-Some parameters in \.{DVI} commands are ``pointers.'' These are four-byte
-quantities that give the location number of some other byte in the file;
-the first byte is number~0, then comes number~1, and so on. For example,
-one of the parameters of a |bop| command points to the previous |bop|;
-this makes it feasible to read the pages in backwards order, in case the
-results are being directed to a device that stacks its output face up.
-Suppose the preamble of a \.{DVI} file occupies bytes 0 to 99. Now if the
-first page occupies bytes 100 to 999, say, and if the second
-page occupies bytes 1000 to 1999, then the |bop| that starts in byte 1000
-points to 100 and the |bop| that starts in byte 2000 points to 1000. (The
-very first |bop|, i.e., the one starting in byte 100, has a pointer of~$-1$.)
-
-@ The \.{DVI} format is intended to be both compact and easily interpreted
-by a machine. Compactness is achieved by making most of the information
-implicit instead of explicit. When a \.{DVI}-reading program reads the
-commands for a page, it keeps track of several quantities: (a)~The current
-font |f| is an integer; this value is changed only
-by \\{fnt} and \\{fnt\_num} commands. (b)~The current position on the page
-is given by two numbers called the horizontal and vertical coordinates,
-|h| and |v|. Both coordinates are zero at the upper left corner of the page;
-moving to the right corresponds to increasing the horizontal coordinate, and
-moving down corresponds to increasing the vertical coordinate. Thus, the
-coordinates are essentially Cartesian, except that vertical directions are
-flipped; the Cartesian version of |(h,v)| would be |(h,-v)|.  (c)~The
-current spacing amounts are given by four numbers |w|, |x|, |y|, and |z|,
-where |w| and~|x| are used for horizontal spacing and where |y| and~|z|
-are used for vertical spacing. (d)~There is a stack containing
-|(h,v,w,x,y,z)| values; the \.{DVI} commands |push| and |pop| are used to
-change the current level of operation. Note that the current font~|f| is
-not pushed and popped; the stack contains only information about
-positioning.
-
-The values of |h|, |v|, |w|, |x|, |y|, and |z| are signed integers having up
-to 32 bits, including the sign. Since they represent physical distances,
-there is a small unit of measurement such that increasing |h| by~1 means
-moving a certain tiny distance to the right. The actual unit of
-measurement is variable, as explained below; \TeX\ sets things up so that
-its \.{DVI} output is in sp units, i.e., scaled points, in agreement with
-all the |scaled| dimensions in \TeX's data structures.
-
-@ Here is a list of all the commands that may appear in a \.{DVI} file. Each
-command is specified by its symbolic name (e.g., |bop|), its opcode byte
-(e.g., 139), and its parameters (if any). The parameters are followed
-by a bracketed number telling how many bytes they occupy; for example,
-`|p[4]|' means that parameter |p| is four bytes long.
-
-\yskip\hang|set_char_0| 0. Typeset character number~0 from font~|f|
-such that the reference point of the character is at |(h,v)|. Then
-increase |h| by the width of that character. Note that a character may
-have zero or negative width, so one cannot be sure that |h| will advance
-after this command; but |h| usually does increase.
-
-\yskip\hang\\{set\_char\_1} through \\{set\_char\_127} (opcodes 1 to 127).
-Do the operations of |set_char_0|; but use the character whose number
-matches the opcode, instead of character~0.
-
-\yskip\hang|set1| 128 |c[1]|. Same as |set_char_0|, except that character
-number~|c| is typeset. \TeX82 uses this command for characters in the
-range |128<=c<256|.
-
-\yskip\hang|@!set2| 129 |c[2]|. Same as |set1|, except that |c|~is two
-bytes long, so it is in the range |0<=c<65536|. \TeX82 never uses this
-command, but it should come in handy for extensions of \TeX\ that deal
-with oriental languages.
-@^oriental characters@>@^Chinese characters@>@^Japanese characters@>
-
-\yskip\hang|@!set3| 130 |c[3]|. Same as |set1|, except that |c|~is three
-bytes long, so it can be as large as $2^{24}-1$. Not even the Chinese
-language has this many characters, but this command might prove useful
-in some yet unforeseen extension.
-
-\yskip\hang|@!set4| 131 |c[4]|. Same as |set1|, except that |c|~is four
-bytes long. Imagine that.
-
-\yskip\hang|set_rule| 132 |a[4]| |b[4]|. Typeset a solid black rectangle
-of height~|a| and width~|b|, with its bottom left corner at |(h,v)|. Then
-set |h:=h+b|. If either |a<=0| or |b<=0|, nothing should be typeset. Note
-that if |b<0|, the value of |h| will decrease even though nothing else happens.
-See below for details about how to typeset rules so that consistency with
-\MF\ is guaranteed.
-
-\yskip\hang|@!put1| 133 |c[1]|. Typeset character number~|c| from font~|f|
-such that the reference point of the character is at |(h,v)|. (The `put'
-commands are exactly like the `set' commands, except that they simply put out a
-character or a rule without moving the reference point afterwards.)
-
-\yskip\hang|@!put2| 134 |c[2]|. Same as |set2|, except that |h| is not changed.
-
-\yskip\hang|@!put3| 135 |c[3]|. Same as |set3|, except that |h| is not changed.
-
-\yskip\hang|@!put4| 136 |c[4]|. Same as |set4|, except that |h| is not changed.
-
-\yskip\hang|put_rule| 137 |a[4]| |b[4]|. Same as |set_rule|, except that
-|h| is not changed.
-
-\yskip\hang|nop| 138. No operation, do nothing. Any number of |nop|'s
-may occur between \.{DVI} commands, but a |nop| cannot be inserted between
-a command and its parameters or between two parameters.
-
-\yskip\hang|bop| 139 $c_0[4]$ $c_1[4]$ $\ldots$ $c_9[4]$ $p[4]$. Beginning
-of a page: Set |(h,v,w,x,y,z):=(0,0,0,0,0,0)| and set the stack empty. Set
-the current font |f| to an undefined value.  The ten $c_i$ parameters hold
-the values of \.{\\count0} $\ldots$ \.{\\count9} in \TeX\ at the time
-\.{\\shipout} was invoked for this page; they can be used to identify
-pages, if a user wants to print only part of a \.{DVI} file. The parameter
-|p| points to the previous |bop| in the file; the first
-|bop| has $p=-1$.
-
-\yskip\hang|eop| 140.  End of page: Print what you have read since the
-previous |bop|. At this point the stack should be empty. (The \.{DVI}-reading
-programs that drive most output devices will have kept a buffer of the
-material that appears on the page that has just ended. This material is
-largely, but not entirely, in order by |v| coordinate and (for fixed |v|) by
-|h|~coordinate; so it usually needs to be sorted into some order that is
-appropriate for the device in question.)
-
-\yskip\hang|push| 141. Push the current values of |(h,v,w,x,y,z)| onto the
-top of the stack; do not change any of these values. Note that |f| is
-not pushed.
-
-\yskip\hang|pop| 142. Pop the top six values off of the stack and assign
-them respectively to |(h,v,w,x,y,z)|. The number of pops should never
-exceed the number of pushes, since it would be highly embarrassing if the
-stack were empty at the time of a |pop| command.
-
-\yskip\hang|right1| 143 |b[1]|. Set |h:=h+b|, i.e., move right |b| units.
-The parameter is a signed number in two's complement notation, |-128<=b<128|;
-if |b<0|, the reference point moves left.
-
-\yskip\hang|right2| 144 |b[2]|. Same as |right1|, except that |b| is a
-two-byte quantity in the range |-32768<=b<32768|.
-
-\yskip\hang|right3| 145 |b[3]|. Same as |right1|, except that |b| is a
-three-byte quantity in the range |@t$-2^{23}$@><=b<@t$2^{23}$@>|.
-
-\yskip\hang|right4| 146 |b[4]|. Same as |right1|, except that |b| is a
-four-byte quantity in the range |@t$-2^{31}$@><=b<@t$2^{31}$@>|.
-
-\yskip\hang|w0| 147. Set |h:=h+w|; i.e., move right |w| units. With luck,
-this parameterless command will usually suffice, because the same kind of motion
-will occur several times in succession; the following commands explain how
-|w| gets particular values.
-
-\yskip\hang|w1| 148 |b[1]|. Set |w:=b| and |h:=h+b|. The value of |b| is a
-signed quantity in two's complement notation, |-128<=b<128|. This command
-changes the current |w|~spacing and moves right by |b|.
-
-\yskip\hang|@!w2| 149 |b[2]|. Same as |w1|, but |b| is two bytes long,
-|-32768<=b<32768|.
-
-\yskip\hang|@!w3| 150 |b[3]|. Same as |w1|, but |b| is three bytes long,
-|@t$-2^{23}$@><=b<@t$2^{23}$@>|.
-
-\yskip\hang|@!w4| 151 |b[4]|. Same as |w1|, but |b| is four bytes long,
-|@t$-2^{31}$@><=b<@t$2^{31}$@>|.
-
-\yskip\hang|x0| 152. Set |h:=h+x|; i.e., move right |x| units. The `|x|'
-commands are like the `|w|' commands except that they involve |x| instead
-of |w|.
-
-\yskip\hang|x1| 153 |b[1]|. Set |x:=b| and |h:=h+b|. The value of |b| is a
-signed quantity in two's complement notation, |-128<=b<128|. This command
-changes the current |x|~spacing and moves right by |b|.
-
-\yskip\hang|@!x2| 154 |b[2]|. Same as |x1|, but |b| is two bytes long,
-|-32768<=b<32768|.
-
-\yskip\hang|@!x3| 155 |b[3]|. Same as |x1|, but |b| is three bytes long,
-|@t$-2^{23}$@><=b<@t$2^{23}$@>|.
-
-\yskip\hang|@!x4| 156 |b[4]|. Same as |x1|, but |b| is four bytes long,
-|@t$-2^{31}$@><=b<@t$2^{31}$@>|.
-
-\yskip\hang|down1| 157 |a[1]|. Set |v:=v+a|, i.e., move down |a| units.
-The parameter is a signed number in two's complement notation, |-128<=a<128|;
-if |a<0|, the reference point moves up.
-
-\yskip\hang|@!down2| 158 |a[2]|. Same as |down1|, except that |a| is a
-two-byte quantity in the range |-32768<=a<32768|.
-
-\yskip\hang|@!down3| 159 |a[3]|. Same as |down1|, except that |a| is a
-three-byte quantity in the range |@t$-2^{23}$@><=a<@t$2^{23}$@>|.
-
-\yskip\hang|@!down4| 160 |a[4]|. Same as |down1|, except that |a| is a
-four-byte quantity in the range |@t$-2^{31}$@><=a<@t$2^{31}$@>|.
-
-\yskip\hang|y0| 161. Set |v:=v+y|; i.e., move down |y| units. With luck,
-this parameterless command will usually suffice, because the same kind of motion
-will occur several times in succession; the following commands explain how
-|y| gets particular values.
-
-\yskip\hang|y1| 162 |a[1]|. Set |y:=a| and |v:=v+a|. The value of |a| is a
-signed quantity in two's complement notation, |-128<=a<128|. This command
-changes the current |y|~spacing and moves down by |a|.
-
-\yskip\hang|@!y2| 163 |a[2]|. Same as |y1|, but |a| is two bytes long,
-|-32768<=a<32768|.
-
-\yskip\hang|@!y3| 164 |a[3]|. Same as |y1|, but |a| is three bytes long,
-|@t$-2^{23}$@><=a<@t$2^{23}$@>|.
-
-\yskip\hang|@!y4| 165 |a[4]|. Same as |y1|, but |a| is four bytes long,
-|@t$-2^{31}$@><=a<@t$2^{31}$@>|.
-
-\yskip\hang|z0| 166. Set |v:=v+z|; i.e., move down |z| units. The `|z|' commands
-are like the `|y|' commands except that they involve |z| instead of |y|.
-
-\yskip\hang|z1| 167 |a[1]|. Set |z:=a| and |v:=v+a|. The value of |a| is a
-signed quantity in two's complement notation, |-128<=a<128|. This command
-changes the current |z|~spacing and moves down by |a|.
-
-\yskip\hang|@!z2| 168 |a[2]|. Same as |z1|, but |a| is two bytes long,
-|-32768<=a<32768|.
-
-\yskip\hang|@!z3| 169 |a[3]|. Same as |z1|, but |a| is three bytes long,
-|@t$-2^{23}$@><=a<@t$2^{23}$@>|.
-
-\yskip\hang|@!z4| 170 |a[4]|. Same as |z1|, but |a| is four bytes long,
-|@t$-2^{31}$@><=a<@t$2^{31}$@>|.
-
-\yskip\hang|fnt_num_0| 171. Set |f:=0|. Font 0 must previously have been
-defined by a \\{fnt\_def} instruction, as explained below.
-
-\yskip\hang\\{fnt\_num\_1} through \\{fnt\_num\_63} (opcodes 172 to 234). Set
-|f:=1|, \dots, \hbox{|f:=63|}, respectively.
-
-\yskip\hang|fnt1| 235 |k[1]|. Set |f:=k|. \TeX82 uses this command for font
-numbers in the range |64<=k<256|.
-
-\yskip\hang|@!fnt2| 236 |k[2]|. Same as |fnt1|, except that |k|~is two
-bytes long, so it is in the range |0<=k<65536|. \TeX82 never generates this
-command, but large font numbers may prove useful for specifications of
-color or texture, or they may be used for special fonts that have fixed
-numbers in some external coding scheme.
-
-\yskip\hang|@!fnt3| 237 |k[3]|. Same as |fnt1|, except that |k|~is three
-bytes long, so it can be as large as $2^{24}-1$.
-
-\yskip\hang|@!fnt4| 238 |k[4]|. Same as |fnt1|, except that |k|~is four
-bytes long; this is for the really big font numbers (and for the negative ones).
-
-\yskip\hang|xxx1| 239 |k[1]| |x[k]|. This command is undefined in
-general; it functions as a $(k+2)$-byte |nop| unless special \.{DVI}-reading
-programs are being used. \TeX82 generates |xxx1| when a short enough
-\.{\\special} appears, setting |k| to the number of bytes being sent. It
-is recommended that |x| be a string having the form of a keyword followed
-by possible parameters relevant to that keyword.
-
-\yskip\hang|@!xxx2| 240 |k[2]| |x[k]|. Like |xxx1|, but |0<=k<65536|.
-
-\yskip\hang|@!xxx3| 241 |k[3]| |x[k]|. Like |xxx1|, but |0<=k<@t$2^{24}$@>|.
-
-\yskip\hang|xxx4| 242 |k[4]| |x[k]|. Like |xxx1|, but |k| can be ridiculously
-large. \TeX82 uses |xxx4| when sending a string of length 256 or more.
-
-\yskip\hang|fnt_def1| 243 |k[1]| |c[4]| |s[4]| |d[4]| |a[1]| |l[1]| |n[a+l]|.
-Define font |k|, where |0<=k<256|; font definitions will be explained shortly.
-
-\yskip\hang|@!fnt_def2| 244 |k[2]| |c[4]| |s[4]| |d[4]| |a[1]| |l[1]| |n[a+l]|.
-Define font |k|, where |0<=k<65536|.
-
-\yskip\hang|@!fnt_def3| 245 |k[3]| |c[4]| |s[4]| |d[4]| |a[1]| |l[1]| |n[a+l]|.
-Define font |k|, where |0<=k<@t$2^{24}$@>|.
-
-\yskip\hang|@!fnt_def4| 246 |k[4]| |c[4]| |s[4]| |d[4]| |a[1]| |l[1]| |n[a+l]|.
-Define font |k|, where |@t$-2^{31}$@><=k<@t$2^{31}$@>|.
-
-\yskip\hang|pre| 247 |i[1]| |num[4]| |den[4]| |mag[4]| |k[1]| |x[k]|.
-Beginning of the preamble; this must come at the very beginning of the
-file. Parameters |i|, |num|, |den|, |mag|, |k|, and |x| are explained below.
-
-\yskip\hang|post| 248. Beginning of the postamble, see below.
-
-\yskip\hang|post_post| 249. Ending of the postamble, see below.
-
-\yskip\noindent Commands 250--255 are undefined at the present time.
-
-@c
-#define set_char_0  0           /* typeset character 0 and move right */
-#define set1  128               /* typeset a character and move right */
-#define set_rule  132           /* typeset a rule and move right */
-#define put1    133             /* typeset a character without moving */
-#define put_rule  137           /* typeset a rule */
-#define nop  138                /* no operation */
-#define bop  139                /* beginning of page */
-#define eop  140                /* ending of page */
-#define push  141               /* save the current positions */
-#define pop  142                /* restore previous positions */
-#define right1    143           /* move right */
-#define right4    146           /* move right, 4 bytes */
-#define w0  147                 /* move right by |w| */
-#define w1  148                 /* move right and set |w| */
-#define x0  152                 /* move right by |x| */
-#define x1  153                 /* move right and set |x| */
-#define down1  157              /* move down */
-#define down4  160              /* move down, 4 bytes */
-#define y0  161                 /* move down by |y| */
-#define y1  162                 /* move down and set |y| */
-#define z0  166                 /* move down by |z| */
-#define z1  167                 /* move down and set |z| */
-#define fnt_num_0  171          /* set current font to 0 */
-#define fnt1  235               /* set current font */
-#define xxx1  239               /* extension to \.{DVI} primitives */
-#define xxx4  242               /* potentially long extension to \.{DVI} primitives */
-#define fnt_def1  243           /* define the meaning of a font number */
-#define pre  247                /* preamble */
-#define post  248               /* postamble beginning */
-#define post_post  249          /* postamble ending */
-
-@ The preamble contains basic information about the file as a whole. As
-stated above, there are six parameters:
-$$\hbox{|@!i[1]| |@!num[4]| |@!den[4]| |@!mag[4]| |@!k[1]| |@!x[k]|.}$$
-The |i| byte identifies \.{DVI} format; currently this byte is always set
-to~2. (The value |i=3| is currently used for an extended format that
-allows a mixture of right-to-left and left-to-right typesetting.
-Some day we will set |i=4|, when \.{DVI} format makes another
-incompatible change---perhaps in the year 2048.)
-
-The next two parameters, |num| and |den|, are positive integers that define
-the units of measurement; they are the numerator and denominator of a
-fraction by which all dimensions in the \.{DVI} file could be multiplied
-in order to get lengths in units of $10^{-7}$ meters. Since $\rm 7227{pt} =
-254{cm}$, and since \TeX\ works with scaled points where there are $2^{16}$
-sp in a point, \TeX\ sets
-$|num|/|den|=(254\cdot10^5)/(7227\cdot2^{16})=25400000/473628672$.
-@^sp@>
-
-The |mag| parameter is what \TeX\ calls \.{\\mag}, i.e., 1000 times the
-desired magnification. The actual fraction by which dimensions are
-multiplied is therefore $|mag|\cdot|num|/1000|den|$. Note that if a \TeX\
-source document does not call for any `\.{true}' dimensions, and if you
-change it only by specifying a different \.{\\mag} setting, the \.{DVI}
-file that \TeX\ creates will be completely unchanged except for the value
-of |mag| in the preamble and postamble. (Fancy \.{DVI}-reading programs allow
-users to override the |mag|~setting when a \.{DVI} file is being printed.)
-
-Finally, |k| and |x| allow the \.{DVI} writer to include a comment, which is not
-interpreted further. The length of comment |x| is |k|, where |0<=k<256|.
-
-
-@c
-#define id_byte 2               /* identifies the kind of \.{DVI} files described here */
-
-@ Font definitions for a given font number |k| contain further parameters
-$$\hbox{|c[4]| |s[4]| |d[4]| |a[1]| |l[1]| |n[a+l]|.}$$
-The four-byte value |c| is the check sum that \TeX\ found in the \.{TFM}
-file for this font; |c| should match the check sum of the font found by
-programs that read this \.{DVI} file.
-@^check sum@>
-
-Parameter |s| contains a fixed-point scale factor that is applied to
-the character widths in font |k|; font dimensions in \.{TFM} files and
-other font files are relative to this quantity, which is called the
-``at size'' elsewhere in this documentation. The value of |s| is
-always positive and less than $2^{27}$. It is given in the same units
-as the other \.{DVI} dimensions, i.e., in sp when \TeX82 has made the
-file.  Parameter |d| is similar to |s|; it is the ``design size,'' and
-(like~|s|) it is given in \.{DVI} units. Thus, font |k| is to be used
-at $|mag|\cdot s/1000d$ times its normal size.
-
-The remaining part of a font definition gives the external name of the font,
-which is an ASCII string of length |a+l|. The number |a| is the length
-of the ``area'' or directory, and |l| is the length of the font name itself;
-the standard local system font area is supposed to be used when |a=0|.
-The |n| field contains the area in its first |a| bytes.
-
-Font definitions must appear before the first use of a particular font number.
-Once font |k| is defined, it must not be defined again; however, we
-shall see below that font definitions appear in the postamble as well as
-in the pages, so in this sense each font number is defined exactly twice,
-if at all. Like |nop| commands, font definitions can
-appear before the first |bop|, or between an |eop| and a |bop|.
-
-@ Sometimes it is desirable to make horizontal or vertical rules line up
-precisely with certain features in characters of a font. It is possible to
-guarantee the correct matching between \.{DVI} output and the characters
-generated by \MF\ by adhering to the following principles: (1)~The \MF\
-characters should be positioned so that a bottom edge or left edge that is
-supposed to line up with the bottom or left edge of a rule appears at the
-reference point, i.e., in row~0 and column~0 of the \MF\ raster. This
-ensures that the position of the rule will not be rounded differently when
-the pixel size is not a perfect multiple of the units of measurement in
-the \.{DVI} file. (2)~A typeset rule of height $a>0$ and width $b>0$
-should be equivalent to a \MF-generated character having black pixels in
-precisely those raster positions whose \MF\ coordinates satisfy
-|0<=x<@t$\alpha$@>b| and |0<=y<@t$\alpha$@>a|, where $\alpha$ is the number
-of pixels per \.{DVI} unit.
-@:METAFONT}{\MF@>
-@^alignment of rules with characters@>
-@^rules aligning with characters@>
-
-@ The last page in a \.{DVI} file is followed by `|post|'; this command
-introduces the postamble, which summarizes important facts that \TeX\ has
-accumulated about the file, making it possible to print subsets of the data
-with reasonable efficiency. The postamble has the form
-$$\vbox{\halign{\hbox{#\hfil}\cr
-  |post| |p[4]| |num[4]| |den[4]| |mag[4]| |l[4]| |u[4]| |s[2]| |t[2]|\cr
-  $\langle\,$font definitions$\,\rangle$\cr
-  |post_post| |q[4]| |i[1]| 223's$[{\G}4]$\cr}}$$
-Here |p| is a pointer to the final |bop| in the file. The next three
-parameters, |num|, |den|, and |mag|, are duplicates of the quantities that
-appeared in the preamble.
-
-Parameters |l| and |u| give respectively the height-plus-depth of the tallest
-page and the width of the widest page, in the same units as other dimensions
-of the file. These numbers might be used by a \.{DVI}-reading program to
-position individual ``pages'' on large sheets of film or paper; however,
-the standard convention for output on normal size paper is to position each
-page so that the upper left-hand corner is exactly one inch from the left
-and the top. Experience has shown that it is unwise to design \.{DVI}-to-printer
-software that attempts cleverly to center the output; a fixed position of
-the upper left corner is easiest for users to understand and to work with.
-Therefore |l| and~|u| are often ignored.
-
-Parameter |s| is the maximum stack depth (i.e., the largest excess of
-|push| commands over |pop| commands) needed to process this file. Then
-comes |t|, the total number of pages (|bop| commands) present.
-
-The postamble continues with font definitions, which are any number of
-\\{fnt\_def} commands as described above, possibly interspersed with |nop|
-commands. Each font number that is used in the \.{DVI} file must be defined
-exactly twice: Once before it is first selected by a \\{fnt} command, and once
-in the postamble.
-
-@ The last part of the postamble, following the |post_post| byte that
-signifies the end of the font definitions, contains |q|, a pointer to the
-|post| command that started the postamble.  An identification byte, |i|,
-comes next; this currently equals~2, as in the preamble.
-
-The |i| byte is followed by four or more bytes that are all equal to
-the decimal number 223 (i.e., '337 in octal). \TeX\ puts out four to seven of
-these trailing bytes, until the total length of the file is a multiple of
-four bytes, since this works out best on machines that pack four bytes per
-word; but any number of 223's is allowed, as long as there are at least four
-of them. In effect, 223 is a sort of signature that is added at the very end.
-@^Fuchs, David Raymond@>
-
-This curious way to finish off a \.{DVI} file makes it feasible for
-\.{DVI}-reading programs to find the postamble first, on most computers,
-even though \TeX\ wants to write the postamble last. Most operating
-systems permit random access to individual words or bytes of a file, so
-the \.{DVI} reader can start at the end and skip backwards over the 223's
-until finding the identification byte. Then it can back up four bytes, read
-|q|, and move to byte |q| of the file. This byte should, of course,
-contain the value 248 (|post|); now the postamble can be read, so the
-\.{DVI} reader can discover all the information needed for typesetting the
-pages. Note that it is also possible to skip through the \.{DVI} file at
-reasonably high speed to locate a particular page, if that proves
-desirable. This saves a lot of time, since \.{DVI} files used in production
-jobs tend to be large.
-
-Unfortunately, however, standard \PASCAL\ does not include the ability to
-@^system dependencies@>
-access a random position in a file, or even to determine the length of a file.
-Almost all systems nowadays provide the necessary capabilities, so \.{DVI}
-format has been designed to work most efficiently with modern operating systems.
-But if \.{DVI} files have to be processed under the restrictions of standard
-\PASCAL, one can simply read them from front to back, since the necessary
-header information is present in the preamble and in the font definitions.
-(The |l| and |u| and |s| and |t| parameters, which appear only in the
-postamble, are ``frills'' that are handy but not absolutely necessary.)
-
-
-@* \[32] Shipping pages out.
-After considering \TeX's eyes and stomach, we come now to the bowels.
-@^bowels@>
-
-The |ship_out| procedure is given a pointer to a box; its mission is
-to describe that box in \.{DVI} form, outputting a ``page'' to |dvi_file|.
-The \.{DVI} coordinates $(h,v)=(0,0)$ should correspond to the upper left
-corner of the box being shipped.
-
-Since boxes can be inside of boxes inside of boxes, the main work of
-|ship_out| is done by two mutually recursive routines, |hlist_out|
-and |vlist_out|, which traverse the hlists and vlists inside of horizontal
-and vertical boxes.
-
-As individual pages are being processed, we need to accumulate
-information about the entire set of pages, since such statistics must be
-reported in the postamble. The global variables |total_pages|, |max_v|,
-|max_h|, |max_push|, and |last_bop| are used to record this information.
-
-The variable |doing_leaders| is |true| while leaders are being output.
-The variable |dead_cycles| contains the number of times an output routine
-has been initiated since the last |ship_out|.
-
-A few additional global variables are also defined here for use in
-|vlist_out| and |hlist_out|. They could have been local variables, but
-that would waste stack space when boxes are deeply nested, since the
-values of these variables are not needed during recursive calls.
-@^recursion@>
-
-@c
-int total_pages = 0;            /* the number of pages that have been shipped out */
-scaled max_v = 0;               /* maximum height-plus-depth of pages shipped so far */
-scaled max_h = 0;               /* maximum width of pages shipped so far */
-int max_push = 0;               /* deepest nesting of |push| commands encountered so far */
-int last_bop = -1;              /* location of previous |bop| in the \.{DVI} output */
-int dead_cycles = 0;            /* recent outputs that didn't ship anything out */
-boolean doing_leaders = false;  /* are we inside a leader box? */
-int oval, ocmd;                 /* used by |out_cmd| for generating |set|, |fnt| and |fnt_def| commands */
-pointer g;                      /* current glue specification */
-int lq, lr;                     /* quantities used in calculations for leaders */
-int cur_s = -1;                 /* current depth of output box nesting, initially $-1$ */
-
-@ The \.{DVI} bytes are output to a buffer instead of being written directly
-to the output file. This makes it possible to reduce the overhead of
-subroutine calls, thereby measurably speeding up the computation, since
-output of \.{DVI} bytes is part of \TeX's inner loop. And it has another
-advantage as well, since we can change instructions in the buffer in order to
-make the output more compact. For example, a `|down2|' command can be
-changed to a `|y2|', thereby making a subsequent `|y0|' command possible,
-saving two bytes.
-
-The output buffer is divided into two parts of equal size; the bytes found
-in |dvi_buf[0..half_buf-1]| constitute the first half, and those in
-|dvi_buf[half_buf..dvi_buf_size-1]| constitute the second. The global
-variable |dvi_ptr| points to the position that will receive the next
-output byte. When |dvi_ptr| reaches |dvi_limit|, which is always equal
-to one of the two values |half_buf| or |dvi_buf_size|, the half buffer that
-is about to be invaded next is sent to the output and |dvi_limit| is
-changed to its other value. Thus, there is always at least a half buffer's
-worth of information present, except at the very beginning of the job.
-
-Bytes of the \.{DVI} file are numbered sequentially starting with 0;
-the next byte to be generated will be number |dvi_offset+dvi_ptr|.
-A byte is present in the buffer only if its number is |>=dvi_gone|.
-
-Some systems may find it more efficient to make |dvi_buf| a |packed|
-array, since output of four bytes at once may be facilitated.
-@^system dependencies@>
-
-
-@ Initially the buffer is all in one piece; we will output half of it only
-after it first fills up.
-
-@c
-int dvi_buf_size = 800;         /* size of the output buffer; must be a multiple of 8 */
-eight_bits *dvi_buf;            /* buffer for \.{DVI} output */
-dvi_index half_buf = 0;         /* half of |dvi_buf_size| */
-dvi_index dvi_limit = 0;        /* end of the current half buffer */
-dvi_index dvi_ptr = 0;          /* the next available buffer address */
-int dvi_offset = 0;             /* |dvi_buf_size| times the number of times the output buffer has been fully emptied */
-int dvi_gone = 0;               /* the number of bytes already output to |dvi_file| */
-
-@ The actual output of |dvi_buf[a..b]| to |dvi_file| is performed by calling
-|write_dvi(a,b)|. For best results, this procedure should be optimized to
-run as fast as possible on each particular system, since it is part of
-\TeX's inner loop. It is safe to assume that |a| and |b+1| will both be
-multiples of 4 when |write_dvi(a,b)| is called; therefore it is possible on
-many machines to use efficient methods to pack four bytes per word and to
-output an array of words with one system call.
-@^system dependencies@>
-@^inner loop@>
-@^defecation@>
-
-@c
-static void write_dvi(dvi_index a, dvi_index b)
-{
-    dvi_index k;
-    for (k = a; k <= b; k++)
-        fputc(dvi_buf[k], static_pdf->file);
-}
-
-/* outputs half of the buffer */
-void dvi_swap(void)
-{
-    if (dvi_limit == dvi_buf_size) {
-        write_dvi(0, half_buf - 1);
-        dvi_limit = half_buf;
-        dvi_offset = dvi_offset + dvi_buf_size;
-        dvi_ptr = 0;
-    } else {
-        write_dvi(half_buf, dvi_buf_size - 1);
-        dvi_limit = dvi_buf_size;
-    }
-    dvi_gone = dvi_gone + half_buf;
-}
-
-@ The |dvi_four| procedure outputs four bytes in two's complement notation,
-without risking arithmetic overflow.
-
-@c
-void dvi_four(int x)
-{
-    if (x >= 0) {
-        dvi_out(x / 0100000000);
-    } else {
-        x = x + 010000000000;
-        x = x + 010000000000;
-        dvi_out((x / 0100000000) + 128);
-    }
-    x = x % 0100000000;
-    dvi_out(x / 0200000);
-    x = x % 0200000;
-    dvi_out(x / 0400);
-    dvi_out(x % 0400);
-}
-
-@
-A mild optimization of the output is performed by the |dvi_pop|
-routine, which issues a |pop| unless it is possible to cancel a
-`|push| |pop|' pair. The parameter to |dvi_pop| is the byte address
-following the old |push| that matches the new |pop|.
-
-
-@c
-void dvi_push(void)
-{
-    dvi_out(push);
-}
-
-void dvi_pop(int l)
-{
-    if ((l == dvi_offset + dvi_ptr) && (dvi_ptr > 0))
-        decr(dvi_ptr);
-    else
-        dvi_out(pop);
-}
-
-@ Here's a procedure that outputs a font definition. $\Omega$ allows
-more than 256 different fonts per job, so the right font definition
-command must be selected.
-
-@c
-void out_cmd(void)
-{
-    if ((oval < 0x100) && (oval >= 0)) {
-        if ((ocmd != set1) || (oval > 127)) {
-            if ((ocmd == fnt1) && (oval < 64))
-                oval += fnt_num_0;
-            else
-                dvi_out(ocmd);
-        }
-    } else {
-        if ((oval < 0x10000) && (oval >= 0)) {
-            dvi_out(ocmd + 1);
-        } else {
-            if ((oval < 0x1000000) && (oval >= 0)) {
-                dvi_out(ocmd + 2);
-            } else {
-                dvi_out(ocmd + 3);
-                if (oval >= 0) {
-                    dvi_out(oval / 0x1000000);
-                } else {
-                    oval += 0x40000000;
-                    oval += 0x40000000;
-                    dvi_out((oval / 0x1000000) + 128);
-                    oval = oval % 0x1000000;
-                }
-                dvi_out(oval / 0x10000);
-                oval = oval % 0x10000;
-            }
-            dvi_out(oval / 0x10000);
-            oval = oval % 0x10000;
-        }
-        dvi_out(oval / 0x100);
-        oval = oval % 0x100;
-    }
-    dvi_out(oval);
-}
-
-void dvi_font_def(internal_font_number f)
-{
-    char *fa;
-    oval = f - 1;
-    ocmd = fnt_def1;
-    out_cmd();
-    dvi_out(font_check_0(f));
-    dvi_out(font_check_1(f));
-    dvi_out(font_check_2(f));
-    dvi_out(font_check_3(f));
-    dvi_four(font_size(f));
-    dvi_four(font_dsize(f));
-    dvi_out(0);                 /* |font_area(f)| is unused */
-    dvi_out(strlen(font_name(f)));
-    /* Output the font name whose internal number is |f| */
-    fa = font_name(f);
-    while (*fa != '\0') {
-        dvi_out(*fa++);
-    }
-}
-
-@ Versions of \TeX\ intended for small computers might well choose to omit
-the ideas in the next few parts of this program, since it is not really
-necessary to optimize the \.{DVI} code by making use of the |w0|, |x0|,
-|y0|, and |z0| commands. Furthermore, the algorithm that we are about to
-describe does not pretend to give an optimum reduction in the length
-of the \.{DVI} code; after all, speed is more important than compactness.
-But the method is surprisingly effective, and it takes comparatively little
-time.
-
-We can best understand the basic idea by first considering a simpler problem
-that has the same essential characteristics. Given a sequence of digits,
-say $3\,1\,4\,1\,5\,9\,2\,6\,5\,3\,5\,8\,9$, we want to assign subscripts
-$d$, $y$, or $z$ to each digit so as to maximize the number of ``$y$-hits''
-and ``$z$-hits''; a $y$-hit is an instance of two appearances of the same
-digit with the subscript $y$, where no $y$'s intervene between the two
-appearances, and a $z$-hit is defined similarly. For example, the sequence
-above could be decorated with subscripts as follows:
-$$3_z\,1_y\,4_d\,1_y\,5_y\,9_d\,2_d\,6_d\,5_y\,3_z\,5_y\,8_d\,9_d.$$
-There are three $y$-hits ($1_y\ldots1_y$ and $5_y\ldots5_y\ldots5_y$) and
-one $z$-hit ($3_z\ldots3_z$); there are no $d$-hits, since the two appearances
-of $9_d$ have $d$'s between them, but we don't count $d$-hits so it doesn't
-matter how many there are. These subscripts are analogous to the \.{DVI}
-commands called \\{down}, $y$, and $z$, and the digits are analogous to
-different amounts of vertical motion; a $y$-hit or $z$-hit corresponds to
-the opportunity to use the one-byte commands |y0| or |z0| in a \.{DVI} file.
-
-\TeX's method of assigning subscripts works like this: Append a new digit,
-say $\delta$, to the right of the sequence. Now look back through the
-sequence until one of the following things happens: (a)~You see
-$\delta_y$ or $\delta_z$, and this was the first time you encountered a
-$y$ or $z$ subscript, respectively.  Then assign $y$ or $z$ to the new
-$\delta$; you have scored a hit. (b)~You see $\delta_d$, and no $y$
-subscripts have been encountered so far during this search.  Then change
-the previous $\delta_d$ to $\delta_y$ (this corresponds to changing a
-command in the output buffer), and assign $y$ to the new $\delta$; it's
-another hit.  (c)~You see $\delta_d$, and a $y$ subscript has been seen
-but not a $z$.  Change the previous $\delta_d$ to $\delta_z$ and assign
-$z$ to the new $\delta$. (d)~You encounter both $y$ and $z$ subscripts
-before encountering a suitable $\delta$, or you scan all the way to the
-front of the sequence. Assign $d$ to the new $\delta$; this assignment may
-be changed later.
-
-The subscripts $3_z\,1_y\,4_d\ldots\,$ in the example above were, in fact,
-produced by this procedure, as the reader can verify. (Go ahead and try it.)
-
-@ In order to implement such an idea, \TeX\ maintains a stack of pointers
-to the \\{down}, $y$, and $z$ commands that have been generated for the
-current page. And there is a similar stack for \\{right}, |w|, and |x|
-commands. These stacks are called the down stack and right stack, and their
-top elements are maintained in the variables |down_ptr| and |right_ptr|.
-
-Each entry in these stacks contains four fields: The |width| field is
-the amount of motion down or to the right; the |location| field is the
-byte number of the \.{DVI} command in question (including the appropriate
-|dvi_offset|); the |vlink| field points to the next item below this one
-on the stack; and the |vinfo| field encodes the options for possible change
-in the \.{DVI} command.
-
-@c
-#define location(A) varmem[(A)+1].cint  /* \.{DVI} byte number for a movement command */
-
-halfword down_ptr = null, right_ptr = null;     /* heads of the down and right stacks */
-
-@ Here is a subroutine that produces a \.{DVI} command for some specified
-downward or rightward motion. It has two parameters: |w| is the amount
-of motion, and |o| is either |down1| or |right1|. We use the fact that
-the command codes have convenient arithmetic properties: |y1-down1=w1-right1|
-and |z1-down1=x1-right1|.
-
-@c
-void movement(scaled w, eight_bits o)
-{
-    small_number mstate;        /* have we seen a |y| or |z|? */
-    halfword p, q;              /* current and top nodes on the stack */
-    int k;                      /* index into |dvi_buf|, modulo |dvi_buf_size| */
-    if (false) {                /* TODO: HUH? */
-        q = new_node(movement_node, 0); /* new node for the top of the stack */
-        width(q) = w;
-        location(q) = dvi_offset + dvi_ptr;
-        if (o == down1) {
-            vlink(q) = down_ptr;
-            down_ptr = q;
-        } else {
-            vlink(q) = right_ptr;
-            right_ptr = q;
-        }
-        /* Look at the other stack entries until deciding what sort of \.{DVI} command
-           to generate; |goto found| if node |p| is a ``hit'' */
-        p = vlink(q);
-        mstate = none_seen;
-        while (p != null) {
-            if (width(p) == w) {
-                /* Consider a node with matching width;|goto found| if it's a hit */
-                /* We might find a valid hit in a |y| or |z| byte that is already gone
-                   from the buffer. But we can't change bytes that are gone forever; ``the
-                   moving finger writes, $\ldots\,\,$.'' */
-
-                switch (mstate + vinfo(p)) {
-                case none_seen + yz_OK:
-                case none_seen + y_OK:
-                case z_seen + yz_OK:
-                case z_seen + y_OK:
-                    if (location(p) < dvi_gone) {
-                        goto NOT_FOUND;
-                    } else {
-                        /* Change buffered instruction to |y| or |w| and |goto found| */
-                        k = location(p) - dvi_offset;
-                        if (k < 0)
-                            k = k + dvi_buf_size;
-                        dvi_buf[k] = (eight_bits) (dvi_buf[k] + y1 - down1);
-                        vinfo(p) = y_here;
-                        goto FOUND;
-                    }
-                    break;
-                case none_seen + z_OK:
-                case y_seen + yz_OK:
-                case y_seen + z_OK:
-                    if (location(p) < dvi_gone) {
-                        goto NOT_FOUND;
-                    } else {
-                        /* Change buffered instruction to |z| or |x| and |goto found| */
-                        k = location(p) - dvi_offset;
-                        if (k < 0)
-                            k = k + dvi_buf_size;
-                        dvi_buf[k] = (eight_bits) (dvi_buf[k] + z1 - down1);
-                        vinfo(p) = z_here;
-                        goto FOUND;
-                    }
-                    break;
-                case none_seen + y_here:
-                case none_seen + z_here:
-                case y_seen + z_here:
-                case z_seen + y_here:
-                    goto FOUND;
-                    break;
-                default:
-                    break;
-                }
-            } else {
-                switch (mstate + vinfo(p)) {
-                case none_seen + y_here:
-                    mstate = y_seen;
-                    break;
-                case none_seen + z_here:
-                    mstate = z_seen;
-                    break;
-                case y_seen + z_here:
-                case z_seen + y_here:
-                    goto NOT_FOUND;
-                    break;
-                default:
-                    break;
-                }
-            }
-            p = vlink(p);
-        }
-    }
-  NOT_FOUND:
-    /* Generate a |down| or |right| command for |w| and |return| */
-    if (abs(w) >= 040000000) {
-        dvi_out(o + 3);         /* |down4| or |right4| */
-        dvi_four(w);
-        return;
-    }
-    if (abs(w) >= 0100000) {
-        dvi_out(o + 2);         /* |down3| or |right3| */
-        if (w < 0)
-            w = w + 0100000000;
-        dvi_out(w / 0200000);
-        w = w % 0200000;
-        goto TWO;
-    }
-    if (abs(w) >= 0200) {
-        dvi_out(o + 1);         /* |down2| or |right2| */
-        if (w < 0)
-            w = w + 0200000;
-        goto TWO;
-    }
-    dvi_out(o);                 /* |down1| or |right1| */
-    if (w < 0)
-        w = w + 0400;
-    goto ONE;
-  TWO:
-    dvi_out(w / 0400);
-  ONE:
-    dvi_out(w % 0400);
-    return;
-  FOUND:
-    /* Generate a |y0| or |z0| command in order to reuse a previous appearance of~|w| */
-    /* The program below removes movement nodes that are introduced after a |push|,
-       before it outputs the corresponding |pop|. */
-    /*
-       When the |movement| procedure gets to the label |found|, the value of
-       |vinfo(p)| will be either |y_here| or |z_here|. If it is, say, |y_here|,
-       the procedure generates a |y0| command (or a |w0| command), and marks
-       all |vinfo| fields between |q| and |p| so that |y| is not OK in that range.
-     */
-    vinfo(q) = vinfo(p);
-    if (vinfo(q) == y_here) {
-        dvi_out(o + y0 - down1);        /* |y0| or |w0| */
-        while (vlink(q) != p) {
-            q = vlink(q);
-            switch (vinfo(q)) {
-            case yz_OK:
-                vinfo(q) = z_OK;
-                break;
-            case y_OK:
-                vinfo(q) = d_fixed;
-                break;
-            default:
-                break;
-            }
-        }
-    } else {
-        dvi_out(o + z0 - down1);        /* |z0| or |x0| */
-        while (vlink(q) != p) {
-            q = vlink(q);
-            switch (vinfo(q)) {
-            case yz_OK:
-                vinfo(q) = y_OK;
-                break;
-            case z_OK:
-                vinfo(q) = d_fixed;
-                break;
-            default:
-                break;
-            }
-        }
-    }
-}
-
-@ In case you are wondering when all the movement nodes are removed from
-\TeX's memory, the answer is that they are recycled just before
-|hlist_out| and |vlist_out| finish outputting a box. This restores the
-down and right stacks to the state they were in before the box was output,
-except that some |vinfo|'s may have become more restrictive.
-
-
-@c
-/* delete movement nodes with |location>=l| */
-void prune_movements(int l)
-{
-    pointer p;                  /* node being deleted */
-    while (down_ptr != null) {
-        if (location(down_ptr) < l)
-            break;
-        p = down_ptr;
-        down_ptr = vlink(p);
-        flush_node(p);
-    }
-    while (right_ptr != null) {
-        if (location(right_ptr) < l)
-            return;
-        p = right_ptr;
-        right_ptr = vlink(p);
-        flush_node(p);
-    }
-}
-
-scaledpos dvi;                  /* a \.{DVI} position in page coordinates, in sync with DVI file */
-
-@ When |hlist_out| is called, its duty is to output the box represented
-by the |hlist_node| pointed to by |temp_ptr|. The reference point of that
-box has coordinates |(cur.h,cur.v)|.
-
-Similarly, when |vlist_out| is called, its duty is to output the box represented
-by the |vlist_node| pointed to by |temp_ptr|. The reference point of that
-box has coordinates |(cur.h,cur.v)|.
-@^recursion@>
-
-@ The recursive procedures |hlist_out| and |vlist_out| each have a local variable
-|save_dvi| to hold the value of |dvi| just before
-entering a new level of recursion.  In effect, the value of |save_dvi|
-on \TeX's run-time stack corresponds to the values of |h| and |v|
-that a \.{DVI}-reading program will push onto its coordinate stack.
-
-@c
-void dvi_place_rule(PDF pdf, halfword q, scaledpos size)
-{
-    synch_dvi_with_pos(pdf->posstruct->pos);
-    if ((subtype(q) >= box_rule) && (subtype(q) <= user_rule)) {
-        /* place nothing, only take space */
-        if (textdir_is_L(pdf->posstruct->dir))
-            dvi.h += size.h;
-    } else {
-        /* normal_rule or >= 100 being a leader rule */
-        if (textdir_is_L(pdf->posstruct->dir)) {
-            dvi_out(set_rule);      /* movement optimization for |dir_*L*| */
-            dvi.h += size.h;
-        } else
-            dvi_out(put_rule);
-    }
-    dvi_four(size.v);
-    dvi_four(size.h);
-}
-
-void dvi_place_glyph(PDF pdf, internal_font_number f, int c, int ex)
-{
-    /* TODO: do something on ex, select font (if possible) */
-    scaled_whd ci;
-    synch_dvi_with_pos(pdf->posstruct->pos);
-    if (f != pdf->f_cur) {
-        /* Change font |f_cur| to |f| */
-        if (!font_used(f)) {
-            dvi_font_def(f);
-            set_font_used(f, true);
-        }
-        oval = f - 1;
-        ocmd = fnt1;
-        out_cmd();
-        pdf->f_cur = f;
-    }
-    if (textdir_is_L(pdf->posstruct->dir)) {
-        ci = get_charinfo_whd(f, c);
-        dvi_set(c, ci.wd);      /* movement optimization for |dir_*L*| */
-    } else
-        dvi_put(c);
-}
-
-void dvi_special(PDF pdf, halfword p)
-{
-    int old_setting;            /* holds print |selector| */
-    unsigned k;                 /* index into |cur_string| */
-    synch_dvi_with_pos(pdf->posstruct->pos);
-    old_setting = selector;
-    selector = new_string;
-    show_token_list(token_link(write_tokens(p)), null, -1);
-    selector = old_setting;
-    if (cur_length < 256) {
-        dvi_out(xxx1);
-        dvi_out(cur_length);
-    } else {
-        dvi_out(xxx4);
-        dvi_four((int) cur_length);
-    }
-    for (k = 0; k < cur_length; k++)
-        dvi_out(cur_string[k]);
-    cur_length = 0;             /* erase the string */
-}
-
-@ Here's an example of how these conventions are used. Whenever it is time to
-ship out a box of stuff, we shall use the macro |ensure_dvi_open|.
-
-@c
-void ensure_dvi_header_written(PDF pdf)
-{
-    unsigned l;
-    unsigned s;                 /* index into |str_pool| */
-    int old_setting;            /* saved |selector| setting */
-    assert(output_mode_used == OMODE_DVI);
-    assert(pdf->o_state == ST_FILE_OPEN);
-
-    if (half_buf == 0) {
-        half_buf = dvi_buf_size / 2;
-        dvi_limit = dvi_buf_size;
-    }
-
-    dvi_out(pre);
-    dvi_out(id_byte);           /* output the preamble */
-    dvi_four(25400000);
-    dvi_four(473628672);        /* conversion ratio for sp */
-    prepare_mag();
-    dvi_four(mag_par);          /* magnification factor is frozen */
-    if (output_comment) {
-        l = (unsigned) strlen(output_comment);
-        dvi_out(l);
-        for (s = 0; s < l; s++)
-            dvi_out(output_comment[s]);
-    } else {                    /* the default code is unchanged */
-        old_setting = selector;
-        selector = new_string;
-        tprint(" LuaTeX output ");
-        print_int(year_par);
-        print_char('.');
-        print_two(month_par);
-        print_char('.');
-        print_two(day_par);
-        print_char(':');
-        print_two(time_par / 60);
-        print_two(time_par % 60);
-        selector = old_setting;
-        dvi_out(cur_length);
-        for (s = 0; s < cur_length; s++)
-            dvi_out(cur_string[s]);
-        cur_length = 0;
-    }
-}
-
-void dvi_begin_page(PDF pdf)
-{
-    int k;
-    int page_loc;               /* location of the current |bop| */
-    ensure_output_state(pdf, ST_HEADER_WRITTEN);
-    /* Initialize variables as |ship_out| begins */
-    page_loc = dvi_offset + dvi_ptr;
-    dvi_out(bop);
-    for (k = 0; k <= 9; k++)
-        dvi_four(count(k));
-    dvi_four(last_bop);
-    last_bop = page_loc;
-}
-
-void dvi_end_page(PDF pdf)
-{
-    (void) pdf;
-    dvi_out(eop);
-}
-
-@ At the end of the program, we must finish things off by writing the
-post\-amble. If |total_pages=0|, the \.{DVI} file was never opened.
-If |total_pages>=65536|, the \.{DVI} file will lie. And if
-|max_push>=65536|, the user deserves whatever chaos might ensue.
-
-@c
-void finish_dvi_file(PDF pdf, int version, int revision)
-{
-    int k;
-    int callback_id = callback_defined(stop_run_callback);
-    (void) version;
-    (void) revision;
-    while (cur_s > -1) {
-        if (cur_s > 0) {
-            dvi_out(pop);
-        } else {
-            dvi_out(eop);
-            incr(total_pages);
-        }
-        decr(cur_s);
-    }
-    if (total_pages == 0) {
-        if (callback_id == 0) {
-            tprint_nl("No pages of output.");
-            print_ln();
-        } else if (callback_id > 0) {
-            run_callback(callback_id, "->");
-        }
-    } else {
-        dvi_out(post);          /* beginning of the postamble */
-        dvi_four(last_bop);
-        last_bop = dvi_offset + dvi_ptr - 5;    /* |post| location */
-        dvi_four(25400000);
-        dvi_four(473628672);    /* conversion ratio for sp */
-        prepare_mag();
-        dvi_four(mag_par);      /* magnification factor */
-        dvi_four(max_v);
-        dvi_four(max_h);
-        dvi_out(max_push / 256);
-        dvi_out(max_push % 256);
-        dvi_out((total_pages / 256) % 256);
-        dvi_out(total_pages % 256);
-        /* Output the font definitions for all fonts that were used */
-        k = max_font_id();
-        while (k > 0) {
-            if (font_used(k)) {
-                dvi_font_def(k);
-            }
-            decr(k);
-        }
-
-        dvi_out(post_post);
-        dvi_four(last_bop);
-        dvi_out(id_byte);
-#ifndef IPC
-        k = 4 + ((dvi_buf_size - dvi_ptr) % 4); /* the number of 223's */
-#else
-        k = 7 - ((3 + dvi_offset + dvi_ptr) % 4);       /* the number of 223's */
-#endif
-
-        while (k > 0) {
-            dvi_out(223);
-            decr(k);
-        }
-        /* Empty the last bytes out of |dvi_buf| */
-        /* Here is how we clean out the buffer when \TeX\ is all through; |dvi_ptr|
-           will be a multiple of~4. */
-        if (dvi_limit == half_buf)
-            write_dvi(half_buf, dvi_buf_size - 1);
-        if (dvi_ptr > 0)
-            write_dvi(0, dvi_ptr - 1);
-
-        if (callback_id == 0) {
-            tprint_nl("Output written on ");
-            tprint(pdf->file_name);
-            tprint(" (");
-            print_int(total_pages);
-            tprint(" page");
-            if (total_pages != 1)
-                print_char('s');
-            tprint(", ");
-            print_int(dvi_offset + dvi_ptr);
-            tprint(" bytes).");
-        } else if (callback_id > 0) {
-            run_callback(callback_id, "->");
-        }
-        close_file(pdf->file);
-    }
-}
diff --git a/texk/web2c/luatexdir/font/dofont.w b/texk/web2c/luatexdir/font/dofont.c
similarity index 63%
rename from texk/web2c/luatexdir/font/dofont.w
rename to texk/web2c/luatexdir/font/dofont.c
index b91bec106..b23368d83 100644
--- a/texk/web2c/luatexdir/font/dofont.w
+++ b/texk/web2c/luatexdir/font/dofont.c
@@ -1,42 +1,42 @@
-% dofont.w
-%
-% Copyright 2006-2010 Taco Hoekwater <taco@@luatex.org>
-%
-% This file is part of LuaTeX.
-%
-% LuaTeX is free software; you can redistribute it and/or modify it under
-% the terms of the GNU General Public License as published by the Free
-% Software Foundation; either version 2 of the License, or (at your
-% option) any later version.
-%
-% LuaTeX is distributed in the hope that it will be useful, but WITHOUT
-% ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-% FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
-% License for more details.
-%
-% You should have received a copy of the GNU General Public License along
-% with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
-
-@ @c
+/*
 
+Copyright 2006-2010 Taco Hoekwater <taco@luatex.org>
+
+This file is part of LuaTeX.
+
+LuaTeX is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 2 of the License, or (at your
+option) any later version.
+
+LuaTeX is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+License for more details.
+
+You should have received a copy of the GNU General Public License along
+with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+
+*/
 
 #include "ptexlib.h"
 #include "lua/luatex-api.h"
 
-@ a bit more interfacing is needed for proper error reporting
+/*tex
+
+    A bit more interfacing is needed for proper error reporting.
+
+*/
 
-@c
 static char *font_error_message(pointer u, char *nom, scaled s)
 {
     char *str = xmalloc(256);
     char *c = makecstring(cs_text(u));
     const char *extra = "metric data not found or bad";
     if (s >= 0) {
-        snprintf(str, 255, "Font \\%s=%s at %gpt not loadable: %s", c, nom,
-                 (double) s / 65536, extra);
+        snprintf(str, 255, "Font \\%s=%s at %gpt not loadable: %s", c, nom, (double) s / 65536, extra);
     } else if (s != -1000) {
-        snprintf(str, 255, "Font \\%s=%s scaled %d not loadable: %s", c, nom,
-                 (int) (-s), extra);
+        snprintf(str, 255, "Font \\%s=%s scaled %d not loadable: %s", c, nom, (int) (-s), extra);
     } else {
         snprintf(str, 255, "Font \\%s=%s not loadable: %s", c, nom, extra);
     }
@@ -46,26 +46,22 @@ static char *font_error_message(pointer u, char *nom, scaled s)
 
 static int do_define_font(int f, const char *cnom, scaled s, int natural_dir)
 {
-
-    boolean res;                /* was the callback successful? */
-    int callback_id;
+    boolean res = 0;
     char *cnam;
     int r, t;
-    res = 0;
-
-    callback_id = callback_defined(define_font_callback);
+    int callback_id = callback_defined(define_font_callback);
     if (callback_id > 0) {
         cnam = xstrdup(cnom);
         callback_id = run_and_save_callback(callback_id, "Sdd->", cnam, s, f);
         free(cnam);
-        if (callback_id > 0) {  /* success */
+        if (callback_id > 0) {
+            /*tex Success. */
             luaL_checkstack(Luas, 1, "out of stack space");
             lua_rawgeti(Luas, LUA_REGISTRYINDEX, callback_id);
             t = lua_type(Luas, -1);
             if (t == LUA_TTABLE) {
                 res = font_from_lua(Luas, f);
                 destroy_saved_callback(callback_id);
-                /* |lua_pop(Luas, 1);| *//* done by |font_from_lua| */
             } else if (t == LUA_TNUMBER) {
                 r = (int) lua_tointeger(Luas, -1);
                 destroy_saved_callback(callback_id);
@@ -86,12 +82,16 @@ static int do_define_font(int f, const char *cnom, scaled s, int natural_dir)
         }
     }
     if (font_name(f) && strlen(font_name(f)) > 255) {
-        /* the font name has to fit in the dvi file's single byte storage */
-        /* no need to test area, as we are never using it */
+        /*tex
+
+            The font name has to fit in the dvi file's single byte storage. There
+            is no need to test area, as we are never using it.
+        */
         res = 0;
     }
     if (res) {
-        if (font_type(f) != virtual_font_type) {        /* implies lua */
+        if (font_type(f) != virtual_font_type) {
+            /*tex This implies \LUA. */
             do_vf(f);
             set_font_natural_dir(f, natural_dir);
         }
@@ -112,8 +112,8 @@ int read_font_info(pointer u, char *cnom, scaled s, int natural_dir)
     if ((f = do_define_font(f, cnom, s, natural_dir))) {
         return f;
     } else {
-        const char *help[] =
-            { "I wasn't able to read the size data for this font,",
+        const char *help[] = {
+            "I wasn't able to read the size data for this font,",
             "so I will ignore the font specification.",
             "[Wizards can fix TFM files using TFtoPL/PLtoTF.]",
             "You might try inserting a different font spec;",
@@ -129,10 +129,6 @@ int read_font_info(pointer u, char *cnom, scaled s, int natural_dir)
     }
 }
 
-@ TODO This function is a placeholder. There can easily appears holes in
-   the |font_tables| array, and we could attempt to reuse those
-
-@c
 int find_font_id(const char *nom, scaled s)
 {
     int f;
diff --git a/texk/web2c/luatexdir/font/mapfile.c b/texk/web2c/luatexdir/font/mapfile.c
new file mode 100644
index 000000000..5ea1e7ca0
--- /dev/null
+++ b/texk/web2c/luatexdir/font/mapfile.c
@@ -0,0 +1,770 @@
+/*
+
+Copyright 1996-2006 Han The Thanh <thanh@pdftex.org>
+Copyright 2006-2010 Taco Hoekwater <taco@luatex.org>
+
+This file is part of LuaTeX.
+
+LuaTeX is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 2 of the License, or (at your
+option) any later version.
+
+LuaTeX is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+License for more details.
+
+You should have received a copy of the GNU General Public License along
+with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#include "ptexlib.h"
+#include <math.h>
+#include <kpathsea/c-auto.h>
+#include <kpathsea/c-memstr.h>
+#include <string.h>
+
+#define FM_BUF_SIZE 1024
+
+static FILE *fm_file;
+
+static unsigned char *fm_buffer = NULL;
+static int fm_size = 0;
+static int fm_curbyte = 0;
+
+#define fm_open(a)        (fm_file = fopen((char *)(a), FOPEN_RBIN_MODE))
+#define fm_read_file()    readbinfile(fm_file,&fm_buffer,&fm_size)
+#define fm_close()        xfclose(fm_file, cur_file_name)
+#define fm_getchar()      fm_buffer[fm_curbyte++]
+#define fm_eof()          (fm_curbyte>fm_size)
+#define is_cfg_comment(c) (c == 10 || c == '*' || c == '#' || c == ';' || c == '%')
+
+typedef enum { FM_DUPIGNORE, FM_REPLACE, FM_DELETE } updatemode;
+
+typedef struct mitem {
+    /*tex |FM_DUPIGNORE| or |FM_REPLACE| or |FM_DELETE| */
+    updatemode mode;
+    /*tex map file or map line */
+    maptype type;
+    /*tex pointer to map file name or map line */
+    char *line;
+    /*tex line number in map file */
+    int lineno;
+} mapitem;
+
+mapitem *mitem = NULL;
+
+#define read_field(r, q, buf) do { \
+    q = buf;                       \
+    while (*r != ' ' && *r != '<' && *r != '"' && *r != '\0') \
+        *q++ = *r++;               \
+    *q = '\0';                     \
+    skip_char(r, ' ');             \
+} while (0)
+
+#define set_field(F) do {     \
+    if (q > buf)              \
+        fm->F = xstrdup(buf); \
+    if (*r == '\0')           \
+        goto done;            \
+} while (0)
+
+fm_entry *new_fm_entry(void)
+{
+    fm_entry *fm;
+    fm = xtalloc(1, fm_entry);
+    fm->tfm_name = NULL;
+    fm->ps_name = NULL;
+    fm->fd_flags = FD_FLAGS_NOT_SET_IN_MAPLINE;
+    fm->ff_name = NULL;
+    fm->encname = NULL;
+    fm->type = 0;
+    fm->slant = 0;
+    fm->extend = 1000;
+    unset_slantset(fm);
+    unset_extendset(fm);
+    unset_inuse(fm);
+    return fm;
+}
+
+void delete_fm_entry(fm_entry * fm)
+{
+    xfree(fm->tfm_name);
+    xfree(fm->ps_name);
+    xfree(fm->ff_name);
+    xfree(fm);
+}
+
+static ff_entry *new_ff_entry(void)
+{
+    ff_entry *ff;
+    ff = xtalloc(1, ff_entry);
+    ff->ff_name = NULL;
+    ff->ff_path = NULL;
+    return ff;
+}
+
+static void delete_ff_entry(ff_entry * ff)
+{
+    xfree(ff->ff_name);
+    xfree(ff->ff_path);
+    xfree(ff);
+}
+
+static struct avl_table *tfm_tree = NULL;
+static struct avl_table *ff_tree = NULL;
+static struct avl_table *encname_tree = NULL;
+
+/*tex
+
+    We sort |fm_entry| into |tfm_tree| by |tfm_name|:
+
+*/
+
+static int comp_fm_entry_tfm(const void *pa, const void *pb, void *p)
+{
+    (void) p;
+    return strcmp(((const fm_entry *) pa)->tfm_name, ((const fm_entry *) pb)->tfm_name);
+}
+
+/* We sort |ff_entry| into |ff_tree| by |ff_name|: */
+
+static int comp_ff_entry(const void *pa, const void *pb, void *p)
+{
+    (void) p;
+    return strcmp(((const ff_entry *) pa)->ff_name, ((const ff_entry *) pb)->ff_name);
+}
+
+static void create_avl_trees(void)
+{
+    tfm_tree = avl_create(comp_fm_entry_tfm, NULL, &avl_xallocator);
+    ff_tree = avl_create(comp_ff_entry, NULL, &avl_xallocator);
+    encname_tree = avl_create(comp_string_entry, NULL, &avl_xallocator);
+}
+
+int avl_do_entry(fm_entry * fm, int mode)
+{
+    fm_entry *p;
+    void *a;
+    void **aa;
+    int delete_new = 0;
+    if (tfm_tree == NULL)
+        create_avl_trees();
+    p = (fm_entry *) avl_find(tfm_tree, fm);
+    if (p != NULL) {
+        switch (mode) {
+            case FM_DUPIGNORE:
+                formatted_warning("map file", "entry for '%s' already exists, duplicates ignored", fm->tfm_name);
+                delete_new = 1;
+                break;
+            case FM_REPLACE:
+            case FM_DELETE:
+                if (is_inuse(p)) {
+                    formatted_warning("map file", "entry for '%s' has been used, replace/delete not allowed", fm->tfm_name);
+                    delete_new = 1;
+                } else {
+                    a = avl_delete(tfm_tree, p);
+                    assert(a != NULL);
+                    delete_fm_entry(p);
+                }
+                break;
+            default:
+                formatted_error("map file", "something bad happened",0);
+        }
+    }
+    if ((mode == FM_DUPIGNORE || mode == FM_REPLACE) && delete_new == 0) {
+        aa = avl_probe(tfm_tree, fm);
+        if (aa == NULL) {
+            /*tex Is this a problem? */
+        }
+    } else
+        delete_new = 1;
+    return delete_new;
+}
+
+/*tex
+
+    Add the encoding name to an AVL tree. This has nothing to do with |writeenc.c|.
+
+*/
+
+static char *add_encname(char *s)
+{
+    char *p;
+    void **aa;
+    if ((p = (char *) avl_find(encname_tree, s)) == NULL) {
+        /*tex The encoding name has not yet been registered. */
+        p = xstrdup(s);
+        aa = avl_probe(encname_tree, p);
+        if (aa == NULL) {
+            /*tex Is this a problem? */
+        }
+    }
+    return p;
+}
+
+/*tex
+
+    A consistency check for map entry, with warn flag.
+
+*/
+
+static int check_fm_entry(fm_entry * fm, boolean warn)
+{
+    int a = 0;
+    if (is_fontfile(fm) && !is_included(fm)) {
+        if (warn)
+            formatted_warning("map file",
+                "ambiguous entry for '%s': font file present but not included, "
+                "will be treated as font file not present", fm->tfm_name);
+        xfree(fm->ff_name);
+        /*tex Do not set variable |a| as this entry will be still accepted. */
+    }
+    /*tex If both ps_name and font file are missing, drop this entry. */
+    if (fm->ps_name == NULL && !is_fontfile(fm)) {
+        if (warn)
+            formatted_warning("map file", "invalid entry for '%s': both ps_name and font file missing", fm->tfm_name);
+        a += 1;
+    }
+    /*tex \TRUETYPE\ fonts cannot be reencoded without subsetting. */
+    if (is_truetype(fm) && is_reencoded(fm) && !is_subsetted(fm)) {
+        if (warn)
+            formatted_warning("map file", "invalid entry for '%s': only subsetted TrueType font can be reencoded", fm->tfm_name);
+        a += 2;
+    }
+    /*tex The value of |SlantFont| and |ExtendFont| must be reasonable. */
+    if (fm->slant < FONT_SLANT_MIN || fm->slant > FONT_SLANT_MAX) {
+        if (warn)
+            formatted_warning("map file", "invalid entry for '%s': value '%g' is to large for SlantFont",
+                 fm->tfm_name, fm->slant / 1000.0);
+        a += 8;
+    }
+    if (fm->extend < FONT_EXTEND_MIN || fm->extend > FONT_EXTEND_MAX) {
+        if (warn)
+            formatted_warning("map file", "invalid entry for '%s': value '%g' is too large for ExtendFont",
+                 fm->tfm_name, fm->extend / 1000.0);
+        a += 16;
+    }
+    return a;
+}
+
+/*tex
+
+    Returns the font number if s is one of the 14 std. font names, -1 otherwise.
+    A bit speed trimmed. Using these base fonts is oldfashioned and doesn't
+    happen in a decent \LUATEX\ produced file.
+
+*/
+
+int check_std_t1font(char *s)
+{
+    static const char *std_t1font_names[] = {
+        "Courier",               /* 0:7 */
+        "Courier-Bold",          /* 1:12 */
+        "Courier-Oblique",       /* 2:15 */
+        "Courier-BoldOblique",   /* 3:19 */
+        "Helvetica",             /* 4:9 */
+        "Helvetica-Bold",        /* 5:14 */
+        "Helvetica-Oblique",     /* 6:17 */
+        "Helvetica-BoldOblique", /* 7:21 */
+        "Symbol",                /* 8:6 */
+        "Times-Roman",           /* 9:11 */
+        "Times-Bold",            /* 10:10 */
+        "Times-Italic",          /* 11:12 */
+        "Times-BoldItalic",      /* 12:16 */
+        "ZapfDingbats"           /* 13:12 */
+    };
+    static const int index[] = {
+        -1, -1, -1, -1, -1, -1, 8,  0, -1,  4, 10,
+         9, -1, -1,  5,  2, 12, 6, -1,  3, -1,  7
+    };
+    size_t n;
+    int k = -1;
+    n = strlen(s);
+    if (n > 21)
+        return -1;
+    if (n == 12) {
+        /*tex three names have length 12 */
+        switch (*s) {
+            case 'C':
+                /*tex Courier-Bold */
+                k = 1;
+                break;
+            case 'T':
+                /*tex Times-Italic */
+                k = 11;
+                break;
+            case 'Z':
+                /*tex ZapfDingbats */
+                k = 13;
+                break;
+            default:
+                return -1;
+        }
+    } else
+        k = index[n];
+    if (k > -1 && !strcmp(std_t1font_names[k], s))
+        return k;
+    return -1;
+}
+
+static void fm_scan_line(void)
+{
+    int a, b, c, j, u = 0, v = 0;
+    char cc;
+    float d;
+    fm_entry *fm;
+    char fm_line[FM_BUF_SIZE], buf[FM_BUF_SIZE];
+    char *p, *q, *s;
+    char *r = NULL;
+    switch (mitem->type) {
+        case MAPFILE:
+            p = fm_line;
+            while (!fm_eof()) {
+                if (fm_curbyte == fm_size) {
+                    fm_curbyte++;
+                    cc = 10;
+                } else {
+                    cc = (char) fm_getchar();
+                }
+                append_char_to_buf(cc, p, fm_line, FM_BUF_SIZE);
+                if (cc == 10)
+                    break;
+            }
+            *(--p) = '\0';
+            r = fm_line;
+            break;
+        case MAPLINE:
+            /*tex Work on a string from |makecstring|. */
+            r = mitem->line;
+            break;
+        default:
+            assert(0);
+    }
+    if (*r == '\0' || is_cfg_comment(*r))
+        return;
+    fm = new_fm_entry();
+    read_field(r, q, buf);
+    set_field(tfm_name);
+    if (!isdigit((unsigned char)*r)) {
+        /*tex The 2nd field |ps_name| may not start with a digit. */
+        read_field(r, q, buf);
+        set_field(ps_name);
+    }
+    if (isdigit((unsigned char)*r)) {
+        /*tex Is the font descriptor |/Flags| given? */
+        for (s = r; isdigit((unsigned char)*s); s++);
+        if (*s == ' ' || *s == '"' || *s == '<' || *s == '\0') {
+            /*tex not e.g.\ |8r.enc| */
+            fm->fd_flags = atoi(r);
+            while (isdigit((unsigned char)*r))
+                r++;
+        }
+    }
+    /*tex Loop through specials, encoding, font file:*/
+    while (1) {
+        skip_char(r, ' ');
+        switch (*r) {
+            case '\0':
+                goto done;
+            case '"':
+                /*tex The pening quote. */
+                r++;
+                u = v = 0;
+                do {
+                    skip_char(r, ' ');
+                    if (sscanf(r, "%f %n", &d, &j) > 0) {
+                        /*tex Jump behind number, eat also blanks, if any. */
+                        s = r + j;
+                        if (*(s - 1) == 'E' || *(s - 1) == 'e') {
+                            /*tex  e.g.\ |0.5ExtendFont|: |%f = 0.5E| */
+                            s--;
+                        }
+                        if (str_prefix(s, "SlantFont")) {
+                            /*tex Correct rounding also for negative numbers. */
+                            d *= (float) 1000.0;
+                            fm->slant = (int) (d > 0 ? d + 0.5 : d - 0.5);
+                            set_slantset(fm);
+                            r = s + strlen("SlantFont");
+                        } else if (str_prefix(s, "ExtendFont")) {
+                            d *= (float) 1000.0;
+                            fm->extend = (int) (d > 0 ? d + 0.5 : d - 0.5);
+                            set_extendset(fm);
+                            r = s + strlen("ExtendFont");
+                        } else {
+                            /*tex unknown name, jump over it */
+                            for (r = s; *r != ' ' && *r != '"' && *r != '\0'; r++);
+                            c = *r;
+                            *r = '\0';
+                            formatted_warning("map file", "invalid entry for '%s': unknown name '%s' ignored", fm->tfm_name, s);
+                            *r = (char) c;
+                        }
+                    } else
+                        for (; *r != ' ' && *r != '"' && *r != '\0'; r++);
+                }
+                while (*r == ' ');
+                if (*r == '"') {
+                    /*tex The closing quote. */
+                    r++;
+                } else {
+                    formatted_warning("map file", "invalid entry for '%s': closing quote missing", fm->tfm_name);
+                    goto bad_line;
+                }
+                break;
+            case 'P':
+                /*tex Handle cases for sub fonts like |PidEid=3,1| */
+                formatted_warning("map file", "invalid entry for '%s': subfonts are not supported", fm->tfm_name);
+                goto bad_line;
+                break;
+            default:
+                /*tex Encoding or font file specification. */
+                a = b = 0;
+                if (*r == '<') {
+                    a = *r++;
+                    if (*r == '<' || *r == '[')
+                        b = *r++;
+                }
+                read_field(r, q, buf);
+                /*tex Encoding, Formats: |8r.enc| or |<8r.enc| or |<[8r.enc| */
+                if (strlen(buf) > 4 && strcasecmp(strend(buf) - 4, ".enc") == 0) {
+                    /*tex |u|, |v| used if intervening blank: |<< foo| */
+                    fm->encname = add_encname(buf);
+                    u = v = 0;
+                } else if (strlen(buf) > 0) {
+                    /*tex
+
+                        We get the file name given where possible formats are:
+
+                        \starttabulate[|||]
+                        \NC subsetting    \NC \tpe {<cmr10.pfa}  \NC \NR
+                        \NC no subsetting \NC \tpe {<<cmr10.pfa} \NC \NR
+                        \NC no embedding  \NC \tpe {cmr10.pfa}   \NC \NR
+                        \stoptabulate
+
+                    */
+                    if (a == '<' || u == '<') {
+                        set_included(fm);
+                        if ((a == '<' && b == 0) || (a == 0 && v == 0)) {
+                            set_subsetted(fm);
+                        } else {
+                            /*tex
+
+                                Otherwise |b| equals |<| or |[| which means that we have no subsetting.
+                            */
+                        }
+                    }
+                    set_field(ff_name);
+                    u = v = 0;
+                } else {
+                    u = a;
+                    v = b;
+                }
+        }
+    }
+  done:
+    if (fm->ps_name != NULL && (check_std_t1font(fm->ps_name) >= 0))
+        set_std_t1font(fm);
+    if (is_fontfile(fm) && strlen(fm_fontfile(fm)) > 3) {
+        if (strcasecmp(strend(fm_fontfile(fm)) - 4, ".ttf") == 0)
+            set_truetype(fm);
+        else if (strcasecmp(strend(fm_fontfile(fm)) - 4, ".ttc") == 0)
+            set_truetype(fm);
+        else if (strcasecmp(strend(fm_fontfile(fm)) - 4, ".otf") == 0)
+            set_opentype(fm);
+        else
+            set_type1(fm);
+    } else {
+        /*tex Assume a builtin font is \TYPEONE\: */
+        set_type1(fm);
+    }
+    if (check_fm_entry(fm, true) != 0)
+        goto bad_line;
+    /*tex
+
+       Until here the map line has been completely scanned without errors; |fm|
+       points to a valid, freshly filled-out |fm_entry| structure. Now follows
+       the actual work of registering or deleting.
+
+    */
+    if (avl_do_entry(fm, mitem->mode) == 0)
+        return;
+  bad_line:
+    delete_fm_entry(fm);
+}
+
+static void fm_read_info(void)
+{
+    int callback_id;
+    int file_opened = 0;
+
+    if (tfm_tree == NULL)
+        create_avl_trees();
+    if (mitem->line == NULL) {
+        /*tex There is nothing to do. */
+        return;
+    }
+    mitem->lineno = 1;
+    switch (mitem->type) {
+    case MAPFILE:
+        xfree(fm_buffer);
+        fm_curbyte = 0;
+        fm_size = 0;
+        cur_file_name = luatex_find_file(mitem->line, find_map_file_callback);
+        if (cur_file_name) {
+            callback_id = callback_defined(read_map_file_callback);
+            if (callback_id > 0) {
+                if (run_callback(callback_id, "S->bSd", cur_file_name,
+                                 &file_opened, &fm_buffer, &fm_size)) {
+                    if (file_opened) {
+                        if (fm_size > 0) {
+                            report_start_file(filetype_map,cur_file_name);
+                            while (!fm_eof()) {
+                                fm_scan_line();
+                                mitem->lineno++;
+                            }
+                            report_stop_file(filetype_map);
+                            fm_file = NULL;
+                        }
+                    } else {
+                        formatted_warning("map file", "cannot open font map file '%s'", cur_file_name);
+                    }
+                } else {
+                    formatted_warning("map file", "cannot open font map file '%s'", cur_file_name);
+                }
+            } else {
+                if (!fm_open(cur_file_name)) {
+                    formatted_warning("map file", "cannot open font map file '%s'", cur_file_name);
+                } else {
+                    fm_read_file();
+                    report_start_file(filetype_map,cur_file_name);
+                    while (!fm_eof()) {
+                        fm_scan_line();
+                        mitem->lineno++;
+                    }
+                    fm_close();
+                    report_stop_file(filetype_map);
+                    fm_file = NULL;
+                }
+            }
+            cur_file_name = NULL;
+        }
+        break;
+    case MAPLINE:
+        cur_file_name = NULL;
+        fm_scan_line();
+        break;
+    default:
+        assert(0);
+    }
+    /*tex Done with this line: */
+    mitem->line = NULL;
+    cur_file_name = NULL;
+    return;
+}
+
+fm_entry *getfontmap(char *tfm_name)
+{
+    fm_entry *fm;
+    fm_entry tmp;
+    if (tfm_name == NULL) {
+        /*tex Wide \LUA\ loaded fonts may not have a name. */
+        return NULL;
+    }
+    if (tfm_tree == NULL) {
+        /*tex Only read the default map file. */
+        fm_read_info();
+    }
+    /*tex Look up the name. */
+    tmp.tfm_name = tfm_name;
+    fm = (fm_entry *) avl_find(tfm_tree, &tmp);
+    if (fm == NULL)
+        return NULL;
+    set_inuse(fm);
+    return fm;
+}
+
+/*tex
+
+    Process map file given by its name or map line contents. Items not beginning
+    with [+-=] flush default map file, if it has not yet been read. Leading
+    blanks and blanks immediately following [+-=] are ignored.
+
+*/
+
+void process_map_item(char *s, int type)
+{
+    char *p;
+    int mode;
+    if (*s == ' ') {
+        /*tex Ignore leading blanks: */
+        s++;
+    }
+    switch (*s) {
+        case '+':
+            /* +mapfile.map, +mapline: insert an entry, if it is not duplicate */
+            mode = FM_DUPIGNORE;
+            s++;
+            break;
+        case '=':
+            /* =mapfile.map, =mapline: try to replace an existing entry */
+            mode = FM_REPLACE;
+            s++;
+            break;
+        case '-':
+            /* -mapfile.map, -mapline: try to delete an entry */
+            mode = FM_DELETE;
+            s++;
+            break;
+        default:
+            /* like +, but also: flush the default map file name */
+            mode = FM_DUPIGNORE;
+            mitem->line = NULL;
+    }
+    if (*s == ' ') {
+        /*tex Ignore a blank after |[+-=]| */
+        s++;
+    }
+    /*tex The map item starts here. */
+    p = s;
+    switch (type) {
+        case MAPFILE:
+            /*tex Remove blank at the end. */
+            while (*p != '\0' && *p != ' ')
+                p++;
+            *p = '\0';
+            break;
+        case MAPLINE:
+            /*tex A blank at end is allowed. */
+            break;
+        default:
+            assert(0);
+    }
+    if (mitem->line != NULL) {
+        /*tex Read default map file first */
+        fm_read_info();
+    }
+    if (*s != '\0') {
+        /*tex Only if real item to process. */
+        mitem->mode = mode;
+        mitem->type = type;
+        mitem->line = s;
+        fm_read_info();
+    }
+}
+
+void pdfmapfile(int t)
+{
+    char *s = tokenlist_to_cstring(t, true, NULL);
+    process_map_item(s, MAPFILE);
+    free(s);
+}
+
+void pdfmapline(int t)
+{
+    char *s = tokenlist_to_cstring(t, true, NULL);
+    process_map_item(s, MAPLINE);
+    free(s);
+}
+
+void pdf_init_map_file(const char *map_name)
+{
+    assert(mitem == NULL);
+    mitem = xtalloc(1, mapitem);
+    mitem->mode = FM_DUPIGNORE;
+    mitem->type = MAPFILE;
+    mitem->line = xstrdup(map_name);
+}
+
+/*tex
+
+    An early check whether a font file exists. Search tree |ff_tree| is used in
+    1st instance, as it may be faster than the |kpse_find_file|, and
+    |kpse_find_file| is called only once per font file name plus expansion
+    parameter. This might help keeping speed, if many \PDF\ pages with same fonts
+    are to be embedded (not that we deal with that fragile approach any longer in
+    \LUATEX).
+
+    The |ff_tree| contains only font files, which are actually needed, so this tree
+    typically is much smaller than the tfm_tree.
+
+*/
+
+ff_entry *check_ff_exist(char *ff_name, boolean is_tt)
+{
+    ff_entry *ff;
+    ff_entry tmp;
+    void **aa;
+    int callback_id;
+    char *filepath = NULL;
+    tmp.ff_name = ff_name;
+    ff = (ff_entry *) avl_find(ff_tree, &tmp);
+    if (ff == NULL) {
+        /*tex The name is not yet in the database. */
+        ff = new_ff_entry();
+        ff->ff_name = xstrdup(ff_name);
+        if (is_tt) {
+            callback_id = callback_defined(find_truetype_file_callback);
+            if (callback_id > 0) {
+                run_callback(callback_id, "S->S", ff_name, &filepath);
+                if (filepath && strlen(filepath) == 0)
+                    filepath = NULL;
+                ff->ff_path = filepath;
+            } else {
+                ff->ff_path = kpse_find_file(ff_name, kpse_truetype_format, 0);
+            }
+        } else {
+            callback_id = callback_defined(find_type1_file_callback);
+            if (callback_id > 0) {
+                run_callback(callback_id, "S->S", ff_name, &filepath);
+                if (filepath && strlen(filepath) == 0)
+                    filepath = NULL;
+                ff->ff_path = filepath;
+            } else {
+                ff->ff_path = kpse_find_file(ff_name, kpse_type1_format, 0);
+            }
+        }
+        aa = avl_probe(ff_tree, ff);
+        if (aa == NULL) {
+            /*tex Is this a problem? */
+        }
+    }
+    return ff;
+}
+
+int is_subsetable(fm_entry * fm)
+{
+    assert(is_included(fm));
+    return is_subsetted(fm);
+}
+
+/*tex Cleaning up: */
+
+static void destroy_fm_entry_tfm(void *pa, void *pb)
+{
+    fm_entry *fm;
+    (void) pb;
+    fm = (fm_entry *) pa;
+    delete_fm_entry(fm);
+}
+
+static void destroy_ff_entry(void *pa, void *pb)
+{
+    ff_entry *ff;
+    (void) pb;
+    ff = (ff_entry *) pa;
+    delete_ff_entry(ff);
+}
+
+void fm_free(void)
+{
+    if (tfm_tree != NULL) {
+        avl_destroy(tfm_tree, destroy_fm_entry_tfm);
+        tfm_tree = NULL;
+    }
+    if (ff_tree != NULL) {
+        avl_destroy(ff_tree, destroy_ff_entry);
+        ff_tree = NULL;
+    }
+}
diff --git a/texk/web2c/luatexdir/font/mapfile.w b/texk/web2c/luatexdir/font/mapfile.w
deleted file mode 100644
index f47c5b504..000000000
--- a/texk/web2c/luatexdir/font/mapfile.w
+++ /dev/null
@@ -1,715 +0,0 @@
-% mapfile.w
-%
-% Copyright 1996-2006 Han The Thanh <thanh@@pdftex.org>
-% Copyright 2006-2010 Taco Hoekwater <taco@@luatex.org>
-%
-% This file is part of LuaTeX.
-%
-% LuaTeX is free software; you can redistribute it and/or modify it under
-% the terms of the GNU General Public License as published by the Free
-% Software Foundation; either version 2 of the License, or (at your
-% option) any later version.
-%
-% LuaTeX is distributed in the hope that it will be useful, but WITHOUT
-% ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-% FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
-% License for more details.
-%
-% You should have received a copy of the GNU General Public License along
-% with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
-
-@ @c
-
-
-#include "ptexlib.h"
-#include <math.h>
-#include <kpathsea/c-auto.h>
-#include <kpathsea/c-memstr.h>
-#include <string.h>
-
-#define FM_BUF_SIZE     1024
-
-static FILE *fm_file;
-
-static unsigned char *fm_buffer = NULL;
-static int fm_size = 0;
-static int fm_curbyte = 0;
-
-#define fm_open(a)      (fm_file = fopen((char *)(a), FOPEN_RBIN_MODE))
-#define fm_read_file()  readbinfile(fm_file,&fm_buffer,&fm_size)
-#define fm_close()      xfclose(fm_file, cur_file_name)
-#define fm_getchar()    fm_buffer[fm_curbyte++]
-#define fm_eof()        (fm_curbyte>fm_size)
-#define is_cfg_comment(c) \
-    (c == 10 || c == '*' || c == '#' || c == ';' || c == '%')
-
-typedef enum { FM_DUPIGNORE, FM_REPLACE, FM_DELETE } updatemode;
-
-typedef struct mitem {
-    updatemode mode;            /* FM_DUPIGNORE or FM_REPLACE or FM_DELETE */
-    maptype type;               /* map file or map line */
-    char *line;                 /* pointer to map file name or map line */
-    int lineno;                 /* line number in map file */
-} mapitem;
-mapitem *mitem = NULL;
-
-#define read_field(r, q, buf) do {  \
-    q = buf;                        \
-    while (*r != ' ' && *r != '<' && *r != '"' && *r != '\0') \
-        *q++ = *r++;                \
-    *q = '\0';                      \
-    skip_char(r, ' ');                  \
-} while (0)
-
-#define set_field(F) do {           \
-    if (q > buf)                    \
-        fm->F = xstrdup(buf);       \
-    if (*r == '\0')                 \
-        goto done;                  \
-} while (0)
-
-fm_entry *new_fm_entry(void)
-{
-    fm_entry *fm;
-    fm = xtalloc(1, fm_entry);
-    fm->tfm_name = NULL;
-    fm->ps_name = NULL;
-    fm->fd_flags = FD_FLAGS_NOT_SET_IN_MAPLINE;
-    fm->ff_name = NULL;
-    fm->encname = NULL;
-    fm->type = 0;
-    fm->slant = 0;
-    fm->extend = 1000;
-    unset_slantset(fm);
-    unset_extendset(fm);
-    unset_inuse(fm);
-    return fm;
-}
-
-void delete_fm_entry(fm_entry * fm)
-{
-    xfree(fm->tfm_name);
-    xfree(fm->ps_name);
-    xfree(fm->ff_name);
-    xfree(fm);
-}
-
-static ff_entry *new_ff_entry(void)
-{
-    ff_entry *ff;
-    ff = xtalloc(1, ff_entry);
-    ff->ff_name = NULL;
-    ff->ff_path = NULL;
-    return ff;
-}
-
-static void delete_ff_entry(ff_entry * ff)
-{
-    xfree(ff->ff_name);
-    xfree(ff->ff_path);
-    xfree(ff);
-}
-
-/**********************************************************************/
-
-static struct avl_table *tfm_tree = NULL;
-static struct avl_table *ff_tree = NULL;
-static struct avl_table *encname_tree = NULL;
-
-/* AVL sort fm_entry into tfm_tree by tfm_name */
-
-static int comp_fm_entry_tfm(const void *pa, const void *pb, void *p)
-{
-    (void) p;
-    return strcmp(((const fm_entry *) pa)->tfm_name,
-                  ((const fm_entry *) pb)->tfm_name);
-}
-
-/* AVL sort ff_entry into ff_tree by ff_name */
-
-static int comp_ff_entry(const void *pa, const void *pb, void *p)
-{
-    (void) p;
-    return strcmp(((const ff_entry *) pa)->ff_name,
-                  ((const ff_entry *) pb)->ff_name);
-}
-
-static void create_avl_trees(void)
-{
-    assert(tfm_tree == NULL);
-    tfm_tree = avl_create(comp_fm_entry_tfm, NULL, &avl_xallocator);
-    assert(tfm_tree != NULL);
-    assert(ff_tree == NULL);
-    ff_tree = avl_create(comp_ff_entry, NULL, &avl_xallocator);
-    assert(ff_tree != NULL);
-    assert(encname_tree == NULL);
-    encname_tree = avl_create(comp_string_entry, NULL, &avl_xallocator);
-    assert(encname_tree != NULL);
-}
-
-int avl_do_entry(fm_entry * fm, int mode)
-{
-    fm_entry *p;
-    void *a;
-    void **aa;
-    int delete_new = 0;
-    if (tfm_tree == NULL)
-        create_avl_trees();
-    p = (fm_entry *) avl_find(tfm_tree, fm);
-    if (p != NULL) {
-        switch (mode) {
-        case FM_DUPIGNORE:
-            formatted_warning("map file", "entry for '%s' already exists, duplicates ignored", fm->tfm_name);
-            delete_new = 1;
-            break;
-        case FM_REPLACE:
-        case FM_DELETE:
-            if (is_inuse(p)) {
-                formatted_warning("map file", "entry for '%s' has been used, replace/delete not allowed", fm->tfm_name);
-                delete_new = 1;
-            } else {
-                a = avl_delete(tfm_tree, p);
-                assert(a != NULL);
-                delete_fm_entry(p);
-            }
-            break;
-        default:
-            assert(0);
-        }
-    }
-    if ((mode == FM_DUPIGNORE || mode == FM_REPLACE) && delete_new == 0) {
-        aa = avl_probe(tfm_tree, fm);
-        assert(aa != NULL);
-    } else
-        delete_new = 1;
-    return delete_new;
-}
-
-/* add the encoding name to an AVL tree. this has nothing to do with writeenc.c */
-
-static char *add_encname(char *s)
-{
-    char *p;
-    void **aa;
-    assert(s != NULL);
-    assert(encname_tree != NULL);
-    if ((p = (char *) avl_find(encname_tree, s)) == NULL) {     /* encoding name not yet registered */
-        p = xstrdup(s);
-        aa = avl_probe(encname_tree, p);
-        assert(aa != NULL);
-    }
-    return p;
-}
-
-/**********************************************************************/
-/* consistency check for map entry, with warn flag */
-
-static int check_fm_entry(fm_entry * fm, boolean warn)
-{
-    int a = 0;
-    assert(fm != NULL);
-
-    if (is_fontfile(fm) && !is_included(fm)) {
-        if (warn)
-            formatted_warning("map file",
-                 "ambiguous entry for '%s': font file present but not included, "
-                 "will be treated as font file not present", fm->tfm_name);
-        xfree(fm->ff_name);
-        /* do not set variable |a| as this entry will be still accepted */
-    }
-
-    /* if both ps_name and font file are missing, drop this entry */
-    if (fm->ps_name == NULL && !is_fontfile(fm)) {
-        if (warn)
-            formatted_warning("map file", "invalid entry for '%s': both ps_name and font file missing", fm->tfm_name);
-        a += 1;
-    }
-
-    /* TrueType fonts cannot be reencoded without subsetting */
-    if (is_truetype(fm) && is_reencoded(fm) && !is_subsetted(fm)) {
-        if (warn)
-            formatted_warning("map file", "invalid entry for '%s': only subsetted TrueType font can be reencoded", fm->tfm_name);
-        a += 2;
-    }
-
-    /* the value of SlantFont and ExtendFont must be reasonable */
-    if (fm->slant < FONT_SLANT_MIN || fm->slant > FONT_SLANT_MAX) {
-        if (warn)
-            formatted_warning("map file", "invalid entry for '%s': value '%g' is to large for SlantFont",
-                 fm->tfm_name, fm->slant / 1000.0);
-        a += 8;
-    }
-    if (fm->extend < FONT_EXTEND_MIN || fm->extend > FONT_EXTEND_MAX) {
-        if (warn)
-            formatted_warning("map file", "invalid entry for '%s': value '%g' is too large for ExtendFont",
-                 fm->tfm_name, fm->extend / 1000.0);
-        a += 16;
-    }
-
-    return a;
-}
-
-/**********************************************************************/
-/* returns the font number if s is one of the 14 std. font names, -1 otherwise; speed-trimmed. */
-
-int check_std_t1font(char *s)
-{
-    static const char *std_t1font_names[] = {
-        "Courier",              /* 0:7 */
-        "Courier-Bold",         /* 1:12 */
-        "Courier-Oblique",      /* 2:15 */
-        "Courier-BoldOblique",  /* 3:19 */
-        "Helvetica",            /* 4:9 */
-        "Helvetica-Bold",       /* 5:14 */
-        "Helvetica-Oblique",    /* 6:17 */
-        "Helvetica-BoldOblique",        /* 7:21 */
-        "Symbol",               /* 8:6 */
-        "Times-Roman",          /* 9:11 */
-        "Times-Bold",           /* 10:10 */
-        "Times-Italic",         /* 11:12 */
-        "Times-BoldItalic",     /* 12:16 */
-        "ZapfDingbats"          /* 13:12 */
-    };
-    static const int index[] =
-        { -1, -1, -1, -1, -1, -1, 8, 0, -1, 4, 10, 9, -1, -1, 5, 2, 12, 6, -1,
-        3, -1, 7
-    };
-    size_t n;
-    int k = -1;
-    assert(s != NULL);
-    n = strlen(s);
-    if (n > 21)
-        return -1;
-    if (n == 12) {              /* three names have length 12 */
-        switch (*s) {
-        case 'C':
-            k = 1;              /* Courier-Bold */
-            break;
-        case 'T':
-            k = 11;             /* Times-Italic */
-            break;
-        case 'Z':
-            k = 13;             /* ZapfDingbats */
-            break;
-        default:
-            return -1;
-        }
-    } else
-        k = index[n];
-    if (k > -1 && !strcmp(std_t1font_names[k], s))
-        return k;
-    return -1;
-}
-
-/**********************************************************************/
-
-static void fm_scan_line(void)
-{
-    int a, b, c, j, u = 0, v = 0;
-    char cc;
-    float d;
-    fm_entry *fm;
-    char fm_line[FM_BUF_SIZE], buf[FM_BUF_SIZE];
-    char *p, *q, *s;
-    char *r = NULL;
-    switch (mitem->type) {
-    case MAPFILE:
-        p = fm_line;
-        while (!fm_eof()) {
-            if (fm_curbyte == fm_size) {
-                fm_curbyte++;
-                cc = 10;
-            } else {
-                cc = (char) fm_getchar();
-            }
-            append_char_to_buf(cc, p, fm_line, FM_BUF_SIZE);
-            if (cc == 10)
-                break;
-        }
-        *(--p) = '\0';
-        r = fm_line;
-        break;
-    case MAPLINE:
-        r = mitem->line;        /* work on string from makecstring() */
-        break;
-    default:
-        assert(0);
-    }
-    if (*r == '\0' || is_cfg_comment(*r))
-        return;
-    fm = new_fm_entry();
-    read_field(r, q, buf);
-    set_field(tfm_name);
-    if (!isdigit((unsigned char)*r)) {         /* 2nd field ps_name may not start with a digit */
-        read_field(r, q, buf);
-        set_field(ps_name);
-    }
-    if (isdigit((unsigned char)*r)) {          /* font descriptor /Flags given? */
-        for (s = r; isdigit((unsigned char)*s); s++);
-        if (*s == ' ' || *s == '"' || *s == '<' || *s == '\0') {        /* not e. g. 8r.enc */
-            fm->fd_flags = atoi(r);
-            while (isdigit((unsigned char)*r))
-                r++;
-        }
-    }
-    while (1) {                 /* loop through "specials", encoding, font file */
-        skip_char(r, ' ');
-        switch (*r) {
-        case '\0':
-            goto done;
-        case '"':              /* opening quote */
-            r++;
-            u = v = 0;
-            do {
-                skip_char(r, ' ');
-                if (sscanf(r, "%f %n", &d, &j) > 0) {
-                    s = r + j;  /* jump behind number, eat also blanks, if any */
-                    if (*(s - 1) == 'E' || *(s - 1) == 'e')
-                        s--;    /* e. g. 0.5ExtendFont: %f = 0.5E */
-                    if (str_prefix(s, "SlantFont")) {
-                        d *= (float) 1000.0;    /* correct rounding also for neg. numbers */
-                        fm->slant = (int) (d > 0 ? d + 0.5 : d - 0.5);
-                        set_slantset(fm);
-                        r = s + strlen("SlantFont");
-                    } else if (str_prefix(s, "ExtendFont")) {
-                        d *= (float) 1000.0;
-                        fm->extend = (int) (d > 0 ? d + 0.5 : d - 0.5);
-                        set_extendset(fm);
-                        r = s + strlen("ExtendFont");
-                    } else {    /* unknown name */
-                        for (r = s; *r != ' ' && *r != '"' && *r != '\0'; r++); /* jump over name */
-                        c = *r; /* remember char for temporary end of string */
-                        *r = '\0';
-                        formatted_warning("map file", "invalid entry for '%s': unknown name '%s' ignored", fm->tfm_name, s);
-                        *r = (char) c;
-                    }
-                } else
-                    for (; *r != ' ' && *r != '"' && *r != '\0'; r++);
-            }
-            while (*r == ' ');
-            if (*r == '"')      /* closing quote */
-                r++;
-            else {
-                formatted_warning("map file", "invalid entry for '%s': closing quote missing", fm->tfm_name);
-                goto bad_line;
-            }
-            break;
-        case 'P':              /* handle cases for sub fonts like 'PidEid=3,1' */
-            formatted_warning("map file", "invalid entry for '%s': subfonts are not supported", fm->tfm_name);
-            goto bad_line;
-            break;
-        default:               /* encoding or font file specification */
-            a = b = 0;
-            if (*r == '<') {
-                a = *r++;
-                if (*r == '<' || *r == '[')
-                    b = *r++;
-            }
-            read_field(r, q, buf);
-            /* encoding, formats: '8r.enc' or '<8r.enc' or '<[8r.enc' */
-            if (strlen(buf) > 4 && strcasecmp(strend(buf) - 4, ".enc") == 0) {
-                fm->encname = add_encname(buf);
-                u = v = 0;      /* u, v used if intervening blank: "<< foo" */
-            } else if (strlen(buf) > 0) {       /* file name given */
-                /* font file, formats:
-                 * subsetting:    '<cmr10.pfa'
-                 * no subsetting: '<<cmr10.pfa'
-                 * no embedding:  'cmr10.pfa'
-                 */
-                if (a == '<' || u == '<') {
-                    set_included(fm);
-                    if ((a == '<' && b == 0) || (a == 0 && v == 0))
-                        set_subsetted(fm);
-                    /* otherwise b == '<' (or '[') => no subsetting */
-                }
-                set_field(ff_name);
-                u = v = 0;
-            } else {
-                u = a;
-                v = b;
-            }
-        }
-    }
-  done:
-    if (fm->ps_name != NULL && (check_std_t1font(fm->ps_name) >= 0))
-        set_std_t1font(fm);
-    if (is_fontfile(fm) && strlen(fm_fontfile(fm)) > 3) {
-        if (strcasecmp(strend(fm_fontfile(fm)) - 4, ".ttf") == 0)
-            set_truetype(fm);
-        else if (strcasecmp(strend(fm_fontfile(fm)) - 4, ".ttc") == 0)
-            set_truetype(fm);
-        else if (strcasecmp(strend(fm_fontfile(fm)) - 4, ".otf") == 0)
-            set_opentype(fm);
-        else
-            set_type1(fm);
-    } else
-        set_type1(fm);          /* assume a builtin font is Type1 */
-    if (check_fm_entry(fm, true) != 0)
-        goto bad_line;
-    /*
-       Until here the map line has been completely scanned without errors;
-       fm points to a valid, freshly filled-out fm_entry structure.
-       Now follows the actual work of registering/deleting.
-     */
-    if (avl_do_entry(fm, mitem->mode) == 0)
-        return;
-  bad_line:
-    delete_fm_entry(fm);
-}
-
-/**********************************************************************/
-
-static void fm_read_info(void)
-{
-    int callback_id;
-    int file_opened = 0;
-
-    if (tfm_tree == NULL)
-        create_avl_trees();
-    if (mitem->line == NULL)    /* nothing to do */
-        return;
-    mitem->lineno = 1;
-    switch (mitem->type) {
-    case MAPFILE:
-        xfree(fm_buffer);
-        fm_curbyte = 0;
-        fm_size = 0;
-        cur_file_name = luatex_find_file(mitem->line, find_map_file_callback);
-        if (cur_file_name) {
-            callback_id = callback_defined(read_map_file_callback);
-            if (callback_id > 0) {
-                if (run_callback(callback_id, "S->bSd", cur_file_name,
-                                 &file_opened, &fm_buffer, &fm_size)) {
-                    if (file_opened) {
-                        if (fm_size > 0) {
-                            report_start_file(filetype_map,cur_file_name);
-                            while (!fm_eof()) {
-                                fm_scan_line();
-                                mitem->lineno++;
-                            }
-                            report_stop_file(filetype_map);
-                            fm_file = NULL;
-                        }
-                    } else {
-                        formatted_warning("map file", "cannot open font map file '%s'", cur_file_name);
-                    }
-                } else {
-                    formatted_warning("map file", "cannot open font map file '%s'", cur_file_name);
-                }
-            } else {
-                if (!fm_open(cur_file_name)) {
-                    formatted_warning("map file", "cannot open font map file '%s'", cur_file_name);
-                } else {
-                    fm_read_file();
-                    report_start_file(filetype_map,cur_file_name);
-                    while (!fm_eof()) {
-                        fm_scan_line();
-                        mitem->lineno++;
-                    }
-                    fm_close();
-                    report_stop_file(filetype_map);
-                    fm_file = NULL;
-                }
-            }
-            cur_file_name = NULL;
-        }
-        break;
-    case MAPLINE:
-        cur_file_name = NULL;
-        fm_scan_line();
-        break;
-    default:
-        assert(0);
-    }
-    mitem->line = NULL;         /* done with this line */
-    cur_file_name = NULL;
-    return;
-}
-
-/**********************************************************************/
-
-fm_entry *getfontmap(char *tfm_name)
-{
-    fm_entry *fm;
-    fm_entry tmp;
-    if (tfm_name == NULL)       /* wide, lua loaded fonts may not have a name */
-        return NULL;
-    if (tfm_tree == NULL)
-        fm_read_info();         /* only to read default map file */
-    tmp.tfm_name = tfm_name;    /* Look up for tfmname */
-    fm = (fm_entry *) avl_find(tfm_tree, &tmp);
-    if (fm == NULL)
-        return NULL;
-    set_inuse(fm);
-    return fm;
-}
-
-/**********************************************************************/
-/*
- * Process map file given by its name or map line contents. Items not
- * beginning with [+-=] flush default map file, if it has not yet been
- * read. Leading blanks and blanks immediately following [+-=] are
- * ignored.
- */
-
-void process_map_item(char *s, int type)
-{
-    char *p;
-    int mode;
-    if (*s == ' ')
-        s++;                    /* ignore leading blank */
-    switch (*s) {
-    case '+':                  /* +mapfile.map, +mapline */
-        mode = FM_DUPIGNORE;    /* insert entry, if it is not duplicate */
-        s++;
-        break;
-    case '=':                  /* =mapfile.map, =mapline */
-        mode = FM_REPLACE;      /* try to replace earlier entry */
-        s++;
-        break;
-    case '-':                  /* -mapfile.map, -mapline */
-        mode = FM_DELETE;       /* try to delete entry */
-        s++;
-        break;
-    default:
-        mode = FM_DUPIGNORE;    /* like +, but also: */
-        mitem->line = NULL;     /* flush default map file name */
-    }
-    if (*s == ' ')
-        s++;                    /* ignore blank after [+-=] */
-    p = s;                      /* map item starts here */
-    switch (type) {
-    case MAPFILE:              /* remove blank at end */
-        while (*p != '\0' && *p != ' ')
-            p++;
-        *p = '\0';
-        break;
-    case MAPLINE:              /* blank at end allowed */
-        break;
-    default:
-        assert(0);
-    }
-    if (mitem->line != NULL)    /* read default map file first */
-        fm_read_info();
-    if (*s != '\0') {           /* only if real item to process */
-        mitem->mode = mode;
-        mitem->type = type;
-        mitem->line = s;
-        fm_read_info();
-    }
-}
-
-void pdfmapfile(int t)
-{
-    char *s = tokenlist_to_cstring(t, true, NULL);
-    process_map_item(s, MAPFILE);
-    free(s);
-}
-
-void pdfmapline(int t)
-{
-    char *s = tokenlist_to_cstring(t, true, NULL);
-    process_map_item(s, MAPLINE);
-    free(s);
-}
-
-void pdf_init_map_file(const char *map_name)
-{
-    assert(mitem == NULL);
-    mitem = xtalloc(1, mapitem);
-    mitem->mode = FM_DUPIGNORE;
-    mitem->type = MAPFILE;
-    mitem->line = xstrdup(map_name);
-}
-
-/**********************************************************************/
-/*
- * Early check whether a font file exists. Search tree ff_tree is used
- * in 1st instance, as it may be faster than the kpse_find_file(), and
- * kpse_find_file() is called only once per font file name + expansion
- * parameter. This might help keeping speed, if many PDF pages with
- * same fonts are to be embedded.
- *
- * The ff_tree contains only font files, which are actually needed,
- * so this tree typically is much smaller than the tfm_tree.
- */
-
-ff_entry *check_ff_exist(char *ff_name, boolean is_tt)
-{
-    ff_entry *ff;
-    ff_entry tmp;
-    void **aa;
-    int callback_id;
-    char *filepath = NULL;
-
-    assert(ff_name != NULL);
-    tmp.ff_name = ff_name;
-    ff = (ff_entry *) avl_find(ff_tree, &tmp);
-    if (ff == NULL) {           /* not yet in database */
-        ff = new_ff_entry();
-        ff->ff_name = xstrdup(ff_name);
-        if (is_tt) {
-            callback_id = callback_defined(find_truetype_file_callback);
-            if (callback_id > 0) {
-                run_callback(callback_id, "S->S", ff_name, &filepath);
-                if (filepath && strlen(filepath) == 0)
-                    filepath = NULL;
-                ff->ff_path = filepath;
-            } else {
-                ff->ff_path = kpse_find_file(ff_name, kpse_truetype_format, 0);
-            }
-        } else {
-            callback_id = callback_defined(find_type1_file_callback);
-            if (callback_id > 0) {
-                run_callback(callback_id, "S->S", ff_name, &filepath);
-                if (filepath && strlen(filepath) == 0)
-                    filepath = NULL;
-                ff->ff_path = filepath;
-            } else {
-                ff->ff_path = kpse_find_file(ff_name, kpse_type1_format, 0);
-            }
-        }
-        aa = avl_probe(ff_tree, ff);
-        assert(aa != NULL);
-    }
-    return ff;
-}
-
-/**********************************************************************/
-
-int is_subsetable(fm_entry * fm)
-{
-    assert(is_included(fm));
-    return is_subsetted(fm);
-}
-
-/**********************************************************************/
-/* cleaning up... */
-
-static void destroy_fm_entry_tfm(void *pa, void *pb)
-{
-    fm_entry *fm;
-    (void) pb;
-    fm = (fm_entry *) pa;
-    delete_fm_entry(fm);
-}
-
-static void destroy_ff_entry(void *pa, void *pb)
-{
-    ff_entry *ff;
-    (void) pb;
-    ff = (ff_entry *) pa;
-    delete_ff_entry(ff);
-}
-
-void fm_free(void)
-{
-    if (tfm_tree != NULL) {
-        avl_destroy(tfm_tree, destroy_fm_entry_tfm);
-        tfm_tree = NULL;
-    }
-    if (ff_tree != NULL) {
-        avl_destroy(ff_tree, destroy_ff_entry);
-        ff_tree = NULL;
-    }
-}
diff --git a/texk/web2c/luatexdir/font/pkin.w b/texk/web2c/luatexdir/font/pkin.c
similarity index 55%
rename from texk/web2c/luatexdir/font/pkin.w
rename to texk/web2c/luatexdir/font/pkin.c
index a5d3eb4bc..afebdef33 100644
--- a/texk/web2c/luatexdir/font/pkin.w
+++ b/texk/web2c/luatexdir/font/pkin.c
@@ -1,63 +1,56 @@
-% pkin.w
-%
-% Copyright 1996-2006 Han The Thanh <thanh@@pdftex.org>
-% Copyright 2006-2008 Taco Hoekwater <taco@@luatex.org>
-%
-% This file is part of LuaTeX.
-%
-% LuaTeX is free software; you can redistribute it and/or modify it under
-% the terms of the GNU General Public License as published by the Free
-% Software Foundation; either version 2 of the License, or (at your
-% option) any later version.
-%
-% LuaTeX is distributed in the hope that it will be useful, but WITHOUT
-% ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-% FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
-% License for more details.
-%
-% You should have received a copy of the GNU General Public License along
-% with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+/*
 
-@
-NAME
+Copyright 1996-2006 Han The Thanh <thanh@pdftex.org>
+Copyright 2006-2008 Taco Hoekwater <taco@luatex.org>
 
-pkin.c - implementation of readchar()
+This file is part of LuaTeX.
 
-DESCRIPTION
+LuaTeX is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 2 of the License, or (at your
+option) any later version.
 
-This implementation of readchar() uses parts of the program dvips
-written by Tomas Rokicki--the inventor of the pkformat--(loadfont.c,
-download.c and unpack.c). Dvips in turn is derived from pktype.
-Pktype(TeX) is described in debt in ``The PKtype processor'',
-which is available as pktype.weave as part of the METAFONTware.
-What was needed to implement readchar() is rearranged in pkfile.c to
-get more modularity in the style of MODULA2.
+LuaTeX is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+License for more details.
 
-BUGFIXES
+You should have received a copy of the GNU General Public License along
+with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
 
-May 1997: Eric Delaunay <delaunay@@lix.polytechnique.fr> reports a
-problem with huge fonts (greater than 1008 DPI). The code for
-handling PK characters in `extended format' was wrongly derived
-from dvips. Made some minor improvements regarding error handling.
+*/
 
-REDESIGN
+/*tex
 
-Piet Tutelaers <rcpt@@urc.tue.nl>
+This implementation of readchar() uses parts of the program dvips written by
+Tomas Rokicki--the inventor of the pkformat--(loadfont.c, download.c and
+unpack.c). Dvips in turn is derived from pktype. Pktype(TeX) is described in debt
+in ``The PKtype processor'', which is available as pktype.weave as part of the
+METAFONTware. What was needed to implement readchar() is rearranged in pkfile.c
+to get more modularity in the style of MODULA2.
 
-Modified for use with pdftex by Han The Thanh <thanh@@fi.muni.cz>.
+May 1997: Eric Delaunay <delaunay@lix.polytechnique.fr> reports a problem with
+huge fonts (greater than 1008 DPI). The code for handling PK characters in
+`extended format' was wrongly derived from dvips. Made some minor improvements
+regarding error handling.
 
-@c
+At some point Piet Tutelaers <rcpt@urc.tue.nl> redesigned the code and later Han
+The Thanh <thanh@fi.muni.cz> again modified the code to suite \PDFTEX. Of course
+in \LUATEX\ again we adapted the code.
 
+*/
 
 #include "ptexlib.h"
 
 typedef short shalfword;
 
-@
-Now we have some routines to get stuff from the pk file.  pkbyte returns
-the next byte from the pk file.
+/*tex
+
+Now we have some routines to get stuff from the \PK\ file. |pkbyte| returns the
+next byte from the \PK\ file.
+
+*/
 
-@c
 static shalfword pkbyte(void)
 {
     register shalfword i;
@@ -70,7 +63,6 @@ static shalfword pkbyte(void)
 static int pkduo(void)
 {
     register int i;
-
     i = pkbyte();
     if (i > 127)
         i -= 256;
@@ -81,7 +73,6 @@ static int pkduo(void)
 static int pktrio(void)
 {
     register int i;
-
     i = pkbyte();
     if (i > 127)
         i -= 256;
@@ -93,7 +84,6 @@ static int pktrio(void)
 static int pkquad(void)
 {
     register int i;
-
     i = pkbyte();
     if (i > 127)
         i -= 256;
@@ -103,14 +93,13 @@ static int pkquad(void)
     return (i);
 }
 
+/*tex
 
+    The next part is devoted to unpacking the character data. We need procedures
+    to get a nybble, bit, and packed word from the packed data structure.
 
-@  The next part is devoted to unpacking the character data.
-
-@  We need procedures to get a nybble, bit, and packed word from the
-packed data structure.
+*/
 
-@c
 static halfword inputbyte, flagbyte;
 static halfword bitweight;
 static halfword dynf;
@@ -154,10 +143,10 @@ static halfword pkpackednum(void)
             i++;
         } while (!(j != 0));
         if (i > 3) {
-/*
-    Damn, we got a huge count!  We {\it fake} it by giving an artificially
-    large repeat count.
- */
+            /*tex
+                Hm, we got a huge count! We {\em fake} it by giving an
+                artificially large repeat count.
+            */
             return (handlehuge(i, j));
         } else {
             while (i > 0) {
@@ -175,9 +164,6 @@ static halfword pkpackednum(void)
             repeatcount = pkpackednum();
         else
             repeatcount = 1;
-#ifdef DEBUG
-        printf("[%d]", (int) repeatcount);
-#endif
         return ((*realfunc) ());
     }
 }
@@ -185,7 +171,6 @@ static halfword pkpackednum(void)
 static halfword rest(void)
 {
     halfword i;
-
     if (pk_remainder < 0) {
         pk_remainder = -pk_remainder;
         return (0);
@@ -202,13 +187,12 @@ static halfword rest(void)
     } else {
         normal_error("type 3","pk issue that shouldn't happen");
         return 0;
-     /*NOTREACHED*/}
+    }
 }
 
 static halfword handlehuge(halfword i, halfword k)
 {
     register long j = k;
-
     while (i) {
         j = (j << 4L) + getnyb();
         i--;
@@ -219,11 +203,16 @@ static halfword handlehuge(halfword i, halfword k)
 }
 
 
-@  And now we have our unpacking routine.
+/*tex
+
+    And now we have our unpacking routine.
+
+*/
 
-@c
-static halfword gpower[17] = { 0, 1, 3, 7, 15, 31, 63, 127,
-    255, 511, 1023, 2047, 4095, 8191, 16383, 32767, 65535
+static halfword gpower[17] = {
+        0,   1,    3,    7,   15,   31,    63,   127,
+      255, 511, 1023, 2047, 4095, 8191, 16383, 32767,
+    65535
 };
 
 static void unpack(chardesc * cd)
@@ -236,7 +225,6 @@ static void unpack(chardesc * cd)
     shalfword hbit;
     halfword count;
     shalfword wordwidth;
-
     wordwidth = (shalfword) ((cd->cwidth + 15) / 16);
     i = (int) (2 * cd->cheight * (long) wordwidth);
     if (i <= 0)
@@ -317,80 +305,89 @@ static void unpack(chardesc * cd)
     }
 }
 
-@
-|readchar()|: the main routine
-check pk preamble if necessary,
-Reads the character definition of character `c' into `cd' if available,
-return FALSE (0) otherwise.
+/*tex
+
+    The main routine check pk preamble if necessary. It reads the character
+    definition of character |c| into |cd| if available or return |FALSE|
+    otherwise.
+
+*/
 
-@c
 int readchar(boolean check_preamble, chardesc * cd)
 {
     register shalfword i;
     register int k;
     register int length = 0;
-
-/*
-    Check the preamble of the pkfile
- */
+    /*tex Check the preamble of the \PK\ file. */
     if (check_preamble) {
         if (pkbyte() != 247)
             normal_error("type 3","bad pk file, expected pre");
         if (pkbyte() != 89)
             normal_error("type 3","bad version of pk file");
-        for (i = pkbyte(); i > 0; i--)  /* creator of pkfile */
+        /*tex The creator of the file: */
+        for (i = pkbyte(); i > 0; i--)
             (void) pkbyte();
-        (void) pkquad();        /* design size */
-        k = pkquad();           /* checksum    */
-        k = pkquad();           /* hppp        */
-        k = pkquad();           /* vppp   */
+        /*tex The design size: */
+        (void) pkquad();
+        /*tex The checksum: */
+        k = pkquad();
+        /*tex The hppp: */
+        k = pkquad();
+        /*tex The vppp: */
+        k = pkquad();
     }
-/*
-    Now we skip to the desired character definition
- */
+    /*tex
+        We also skip to the desired character definition.
+    */
     while ((flagbyte = pkbyte()) != 245) {
         if (flagbyte < 240) {
             switch (flagbyte & 7) {
-            case 0:
-            case 1:
-            case 2:
-            case 3:
-                length = (flagbyte & 7) * 256 + pkbyte() - 3;
-                cd->charcode = pkbyte();
-                (void) pktrio();        /* TFMwidth */
-                cd->xescape = pkbyte(); /* pixel width */
-                cd->cwidth = pkbyte();
-                cd->cheight = pkbyte();
-                cd->xoff = pkbyte();
-                cd->yoff = pkbyte();
-                if (cd->xoff > 127)
-                    cd->xoff -= 256;
-                if (cd->yoff > 127)
-                    cd->yoff -= 256;
-                break;
-            case 4:
-            case 5:
-            case 6:
-                length = (int) ((flagbyte & 3) * 65536L + pkbyte() * 256L);
-                length = (int) (length + pkbyte() - 4L);
-                cd->charcode = pkbyte();
-                (void) pktrio();        /* TFMwidth */
-                cd->xescape = pkduo();  /* pixelwidth */
-                cd->cwidth = pkduo();
-                cd->cheight = pkduo();
-                cd->xoff = pkduo();
-                cd->yoff = pkduo();
-                break;
-            case 7:
-                length = (int) (pkquad() - 9L);
-                cd->charcode = pkquad();
-                (void) pkquad();        /* TFMwidth */
-                cd->xescape = pkquad(); /* pixelwidth */
-                k = pkquad();
-                cd->cwidth = pkquad();
-                cd->cheight = pkquad();
-                cd->xoff = pkquad();
-                cd->yoff = pkquad();
+                case 0:
+                case 1:
+                case 2:
+                case 3:
+                    length = (flagbyte & 7) * 256 + pkbyte() - 3;
+                    cd->charcode = pkbyte();
+                    /*tex The \TFM\ width: */
+                    (void) pktrio();
+                    /*tex the pixel width: */
+                    cd->xescape = pkbyte();
+                    cd->cwidth = pkbyte();
+                    cd->cheight = pkbyte();
+                    cd->xoff = pkbyte();
+                    cd->yoff = pkbyte();
+                    if (cd->xoff > 127)
+                        cd->xoff -= 256;
+                    if (cd->yoff > 127)
+                        cd->yoff -= 256;
+                    break;
+                case 4:
+                case 5:
+                case 6:
+                    length = (int) ((flagbyte & 3) * 65536L + pkbyte() * 256L);
+                    length = (int) (length + pkbyte() - 4L);
+                    cd->charcode = pkbyte();
+                    /*tex The \TFM\ width: */
+                    (void) pktrio();
+                    /*tex the pixel width: */
+                    cd->xescape = pkduo();
+                    cd->cwidth = pkduo();
+                    cd->cheight = pkduo();
+                    cd->xoff = pkduo();
+                    cd->yoff = pkduo();
+                    break;
+                case 7:
+                    length = (int) (pkquad() - 9L);
+                    cd->charcode = pkquad();
+                    /*tex The \TFM\ width: */
+                    (void) pkquad();
+                    /*tex the pixel width: */
+                    cd->xescape = pkquad();
+                    k = pkquad();
+                    cd->cwidth = pkquad();
+                    cd->cheight = pkquad();
+                    cd->xoff = pkquad();
+                    cd->yoff = pkquad();
             }
             if (length <= 0)
                 formatted_error("type 3","pk packet length '%i' too small", (int) length);
@@ -399,28 +396,29 @@ int readchar(boolean check_preamble, chardesc * cd)
         } else {
             k = 0;
             switch (flagbyte) {
-            case 243:
-                k = pkbyte();
-                if (k > 127)
-                    k -= 256;
-            case 242:
-                k = k * 256 + pkbyte();
-            case 241:
-                k = k * 256 + pkbyte();
-            case 240:
-                k = k * 256 + pkbyte();
-                while (k-- > 0)
-                    i = pkbyte();
-                break;
-            case 244:
-                k = pkquad();
-                break;
-            case 246:
-                break;
-            default:
-                formatted_error("type 3","unexpected pk command '%i'", (int) flagbyte);
+                case 243:
+                    k = pkbyte();
+                    if (k > 127)
+                        k -= 256;
+                case 242:
+                    k = k * 256 + pkbyte();
+                case 241:
+                    k = k * 256 + pkbyte();
+                case 240:
+                    k = k * 256 + pkbyte();
+                    while (k-- > 0)
+                        i = pkbyte();
+                    break;
+                case 244:
+                    k = pkquad();
+                    break;
+                case 246:
+                    break;
+                default:
+                    formatted_error("type 3","unexpected pk command '%i'", (int) flagbyte);
             }
         }
     }
-    return 0;                   /* character not found */
+    /*tex Character not found: */
+    return 0;
 }
diff --git a/texk/web2c/luatexdir/font/sfnt.w b/texk/web2c/luatexdir/font/sfnt.c
similarity index 79%
rename from texk/web2c/luatexdir/font/sfnt.w
rename to texk/web2c/luatexdir/font/sfnt.c
index 83e38990d..c7f4723c4 100644
--- a/texk/web2c/luatexdir/font/sfnt.w
+++ b/texk/web2c/luatexdir/font/sfnt.c
@@ -1,53 +1,58 @@
-% sfnt.w
-%
-% Copyright 2002 by Jin-Hwan Cho and Shunsaku Hirata,
-% the dvipdfmx project team <dvipdfmx@@project.ktug.or.kr>
-% Copyright 2006-2008 Taco Hoekwater <taco@@luatex.org>
-%
-% This file is part of LuaTeX.
-%
-% LuaTeX is free software; you can redistribute it and/or modify it under
-% the terms of the GNU General Public License as published by the Free
-% Software Foundation; either version 2 of the License, or (at your
-% option) any later version.
-%
-% LuaTeX is distributed in the hope that it will be useful, but WITHOUT
-% ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-% FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
-% License for more details.
-%
-% You should have received a copy of the GNU General Public License along
-% with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
-
-@ Based on dvipdfmx-0.13.2c
-@c
+/*
 
+Copyright 2002 by Jin-Hwan Cho and Shunsaku Hirata,
+the dvipdfmx project team <dvipdfmx@@project.ktug.or.kr>
+Copyright 2006-2008 Taco Hoekwater <taco@@luatex.org>
+
+This file is part of LuaTeX.
+
+LuaTeX is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 2 of the License, or (at your
+option) any later version.
+
+LuaTeX is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+License for more details.
+
+You should have received a copy of the GNU General Public License along
+with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+
+*/
+
+/*tex
+
+    The code below is originally based on |dvipdfmx-0.13.2c|:
+
+*/
 
 #include "ptexlib.h"
 
-#if  HAVE_CONFIG_H
+#if HAVE_CONFIG_H
 #  include <w2c/config.h>
-#endif                          /* |HAVE_CONFIG_H_| */
+#endif
 
 #include <string.h>
 
 #include "font/sfnt.h"
 
-@ type:
-
- `true' (0x74727565): TrueType (Mac)
-
- `typ1' (0x74797031) (Mac): PostScript font housed in a sfnt wrapper
+/*tex
 
- 0x00010000: TrueType (Win)/OpenType
+    Types:
 
- `OTTO': PostScript CFF font with OpenType wrapper
+    \starttabulate[||||]
+    \NC \type {true} \NC 0x74727565 \NC (Mac) TrueType  \NC \NR
+    \NC \type {typ1| \NC 0x74797031 \NC (Mac) PostScript font housed in a sfnt wrapper \NC \NR
+    \NC              \NC 0x00010000 \NC TrueType (Win)/OpenType \NC \NR
+    \NC \type {OTTO} \NC            \NC PostScript CFF font with OpenType wrapper \NC \NR
+    \NC \type {ttcf} \NC            \NC TrueType Collection \NC \NR
+    \stoptabulate
 
- `ttcf': TrueType Collection
+*/
 
-@c
 #define SFNT_TRUETYPE   0x00010000UL
-#define SFNT_MAC_TRUE 0x74727565UL
+#define SFNT_MAC_TRUE   0x74727565UL
 #define SFNT_OPENTYPE   0x00010000UL
 #define SFNT_POSTSCRIPT 0x4f54544fUL
 #define SFNT_TTC        0x74746366UL
@@ -56,14 +61,11 @@ sfnt *sfnt_open(unsigned char *buff, int buflen)
 {
     sfnt *sfont;
     ULONG type;
-
     sfont = xmalloc(sizeof(sfnt));
     sfont->loc = 0;
     sfont->buffer = buff;
     sfont->buflen = buflen;
-
     type = sfnt_get_ulong(sfont);
-
     if (type == SFNT_TRUETYPE || type == SFNT_MAC_TRUE) {
         sfont->type = SFNT_TYPE_TRUETYPE;
     } else if (type == SFNT_OPENTYPE) {
@@ -73,7 +75,6 @@ sfnt *sfnt_open(unsigned char *buff, int buflen)
     } else if (type == SFNT_TTC) {
         sfont->type = SFNT_TYPE_TTC;
     }
-
     sfont->loc = 0;
     sfont->directory = NULL;
     return sfont;
@@ -82,7 +83,6 @@ sfnt *sfnt_open(unsigned char *buff, int buflen)
 static void release_directory(struct sfnt_table_directory *td)
 {
     long i;
-
     if (td) {
         if (td->tables) {
             for (i = 0; i < td->num_tables; i++) {
@@ -95,19 +95,16 @@ static void release_directory(struct sfnt_table_directory *td)
             RELEASE(td->flags);
         RELEASE(td);
     }
-
     return;
 }
 
 void sfnt_close(sfnt * sfont)
 {
-
     if (sfont) {
         if (sfont->directory)
             release_directory(sfont->directory);
         RELEASE(sfont);
     }
-
     return;
 }
 
@@ -115,70 +112,67 @@ int put_big_endian(void *s, LONG q, int n)
 {
     int i;
     char *p;
-
     p = (char *) s;
     for (i = n - 1; i >= 0; i--) {
         p[i] = (char) (q & 0xff);
         q >>= 8;
     }
-
     return n;
 }
 
-@ Convert four-byte number to big endianess in a machine independent way.
+/*tex
+
+    Convert four-byte number to big endianess in a machine independent way.
+
+*/
 
-@c
 static void convert_tag(char *tag, unsigned long u_tag)
 {
     int i;
-
     for (i = 3; i >= 0; i--) {
         tag[i] = (char) (u_tag % 256);
         u_tag /= 256;
     }
-
     return;
 }
 
+/*tex
 
-@ Computes the max power of 2 <= n
+    Computes the max power of $|2 <= n$:
+
+*/
 
-@c
 static unsigned max2floor(unsigned n)
 {
     int val = 1;
-
     while (n > 1) {
         n /= 2;
         val *= 2;
     }
-
     return (unsigned) val;
 }
 
+/*tex
 
-@ Computes the log2 of the max power of 2 <= n
+    Computes the log2 of the max power of $2 <= n$
+
+*/
 
-@c
 static unsigned log2floor(unsigned n)
 {
     unsigned val = 0;
-
     while (n > 1) {
         n /= 2;
         val++;
     }
-
     return val;
 }
 
-@ @c
 static ULONG sfnt_calc_checksum(void *data, ULONG length)
 {
     ULONG chksum = 0;
     BYTE *p, *endptr;
     ULONG count = 0;
-
     p = (BYTE *) data;
     endptr = p + length;
     while (p < endptr) {
@@ -186,61 +180,45 @@ static ULONG sfnt_calc_checksum(void *data, ULONG length)
         count = ((count + 1) & 3);
         p++;
     }
-
     return chksum;
 }
 
-@ @c
 static int find_table_index(struct sfnt_table_directory *td, const char *tag)
 {
     int idx;
-
     if (!td)
         return -1;
-
     for (idx = 0; idx < td->num_tables; idx++) {
         if (!memcmp(td->tables[idx].tag, tag, 4))
             return idx;
     }
-
     return -1;
 }
 
-@ @c
 void sfnt_set_table(sfnt * sfont, const char *tag, void *data, ULONG length)
 {
     struct sfnt_table_directory *td;
     int idx;
-
-    ASSERT(sfont);
-
     td = sfont->directory;
     idx = find_table_index(td, tag);
-
     if (idx < 0) {
         idx = td->num_tables;
         td->num_tables++;
         td->tables = RENEW(td->tables, td->num_tables, struct sfnt_table);
         memcpy(td->tables[idx].tag, tag, 4);
     }
-
     td->tables[idx].check_sum = sfnt_calc_checksum(data, length);
     td->tables[idx].offset = 0L;
     td->tables[idx].length = length;
     td->tables[idx].data = data;
-
     return;
 }
 
-@ @c
 ULONG sfnt_find_table_len(sfnt * sfont, const char *tag)
 {
     ULONG length;
     struct sfnt_table_directory *td;
     int idx;
-
-    ASSERT(sfont && tag);
-
     td = sfont->directory;
     idx = find_table_index(td, tag);
     if (idx < 0)
@@ -248,19 +226,14 @@ ULONG sfnt_find_table_len(sfnt * sfont, const char *tag)
     else {
         length = td->tables[idx].length;
     }
-
     return length;
 }
 
-@ @c
 ULONG sfnt_find_table_pos(sfnt * sfont, const char *tag)
 {
     ULONG offset;
     struct sfnt_table_directory *td;
     int idx;
-
-    ASSERT(sfont && tag);
-
     td = sfont->directory;
     idx = find_table_index(td, tag);
     if (idx < 0)
@@ -268,75 +241,51 @@ ULONG sfnt_find_table_pos(sfnt * sfont, const char *tag)
     else {
         offset = td->tables[idx].offset;
     }
-
     return offset;
 }
 
-@ @c
 ULONG sfnt_locate_table(sfnt * sfont, const char *tag)
 {
     ULONG offset;
-
-    ASSERT(sfont && tag);
-
     offset = sfnt_find_table_pos(sfont, tag);
     if (offset == 0)
         normal_error("ttf","sfnt table not found");
-
     sfnt_seek_set(sfont, (long) offset);
-
     return offset;
 }
 
-@ @c
 int sfnt_read_table_directory(sfnt * sfont, ULONG offset)
 {
     struct sfnt_table_directory *td;
     unsigned long i, u_tag;
-
-    ASSERT(sfont);
-
     if (sfont->directory)
         release_directory(sfont->directory);
     sfont->directory = td = NEW(1, struct sfnt_table_directory);
-
-    ASSERT(sfont->buffer);
     sfnt_seek_set(sfont, (long) offset);
-
     td->version = sfnt_get_ulong(sfont);
     td->num_tables = sfnt_get_ushort(sfont);
     td->search_range = sfnt_get_ushort(sfont);
     td->entry_selector = sfnt_get_ushort(sfont);
     td->range_shift = sfnt_get_ushort(sfont);
-
     td->flags = NEW(td->num_tables, char);
     td->tables = NEW(td->num_tables, struct sfnt_table);
-
     for (i = 0; i < td->num_tables; i++) {
         u_tag = sfnt_get_ulong(sfont);
-
         convert_tag(td->tables[i].tag, u_tag);
         td->tables[i].check_sum = sfnt_get_ulong(sfont);
         td->tables[i].offset = sfnt_get_ulong(sfont);
         td->tables[i].length = sfnt_get_ulong(sfont);
         td->tables[i].data = NULL;
-
         td->flags[i] = 0;
     }
-
     td->num_kept_tables = 0;
-
     return 0;
 }
 
-@ @c
 int sfnt_require_table(sfnt * sfont, const char *tag, int must_exist)
 {
     struct sfnt_table_directory *td;
     int idx;
-
-    ASSERT(sfont && sfont->directory);
-
     td = sfont->directory;
     idx = find_table_index(td, tag);
     if (idx < 0) {
@@ -346,22 +295,19 @@ int sfnt_require_table(sfnt * sfont, const char *tag, int must_exist)
         td->flags[idx] |= SFNT_TABLE_REQUIRED;
         td->num_kept_tables++;
     }
-
     return 0;
 }
 
+/*tex
 
+    All tables begin on four byte boundries, and pad any remaining space between
+    tables with zeros. Entries in the Table Directory must be sorted in ascending
+    order by tag The head table contains checksum of the whole font file. To
+    compute: first set it to 0, sum the entire font as ULONG, then store
+    0xB1B0AFBA - sum.
 
-@ All tables begin on four byte boundries, and pad any remaining space
-  between tables with zeros
-
-  Entries in the Table Directory must be sorted in ascending order by tag
-
-  The head table contains checksum of the whole font file.
-  To compute:  first set it to 0, sum the entire font as ULONG,
-  then store 0xB1B0AFBA - sum.
+*/
 
-@c
 #  include "font/luatexfont.h"
 #  undef MIN
 #  define MIN(a, b) (((a) < (b)) ? (a) : (b))
@@ -376,14 +322,8 @@ pdf_obj *sfnt_create_FontFile_stream(sfnt * sfont)
     long offset, nb_read, length;
     int i, sr;
     char *p;
-
-    ASSERT(sfont && sfont->directory);
-
     stream = pdf_new_stream(STREAM_COMPRESS);
-
     td = sfont->directory;
-
-    /* Header */
     p = (char *) wbuf;
     p += sfnt_put_ulong(p, (LONG) td->version);
     p += sfnt_put_ushort(p, td->num_kept_tables);
@@ -391,20 +331,15 @@ pdf_obj *sfnt_create_FontFile_stream(sfnt * sfont)
     p += sfnt_put_ushort(p, sr);
     p += sfnt_put_ushort(p, log2floor(td->num_kept_tables));
     p += sfnt_put_ushort(p, td->num_kept_tables * 16 - sr);
-
     pdf_add_stream(stream, wbuf, 12);
-
-    /*
-     Compute start of actual tables (after headers).
-     */
+    /*tex Compute start of actual tables (after headers). */
     offset = 12 + 16 * td->num_kept_tables;
     for (i = 0; i < td->num_tables; i++) {
-        /* This table must exist in FontFile */
+        /*tex This table must exist in |FontFile|: */
         if (td->flags[i] & SFNT_TABLE_REQUIRED) {
             if ((offset % 4) != 0) {
                 offset += 4 - (offset % 4);
             }
-
             p = (char *) wbuf;
             memcpy(p, td->tables[i].tag, 4);
             p += 4;
@@ -412,11 +347,9 @@ pdf_obj *sfnt_create_FontFile_stream(sfnt * sfont)
             p += sfnt_put_ulong(p, offset);
             p += sfnt_put_ulong(p, (LONG) td->tables[i].length);
             pdf_add_stream(stream, wbuf, 16);
-
             offset = (long) (offset + (long) td->tables[i].length);
         }
     }
-
     offset = 12 + 16 * td->num_kept_tables;
     for (i = 0; i < td->num_tables; i++) {
         if (td->flags[i] & SFNT_TABLE_REQUIRED) {
@@ -426,13 +359,11 @@ pdf_obj *sfnt_create_FontFile_stream(sfnt * sfont)
                 offset += length;
             }
             if (!td->tables[i].data) {
-                if (!sfont->buffer)
-                {
+                if (!sfont->buffer) {
                     pdf_release_obj(stream);
                     normal_error("ttf","file not opened or already closed");
                     return NULL;
                 }
-
                 length = (long) td->tables[i].length;
                 sfnt_seek_set(sfont, (long) td->tables[i].offset);
                 while (length > 0) {
@@ -453,10 +384,9 @@ pdf_obj *sfnt_create_FontFile_stream(sfnt * sfont)
                 RELEASE(td->tables[i].data);
                 td->tables[i].data = NULL;
             }
-            /* Set offset for next table */
+            /*tex Set offset for next table. */
             offset = (long) (offset + (long) td->tables[i].length);
         }
     }
-
     return stream;
 }
diff --git a/texk/web2c/luatexdir/font/subfont.w b/texk/web2c/luatexdir/font/subfont.c
similarity index 69%
rename from texk/web2c/luatexdir/font/subfont.w
rename to texk/web2c/luatexdir/font/subfont.c
index 0616bdad4..d2f5f8d2f 100644
--- a/texk/web2c/luatexdir/font/subfont.w
+++ b/texk/web2c/luatexdir/font/subfont.c
@@ -1,30 +1,28 @@
-% subfont.w
-%
-% Copyright 2005-2006 Han The Thanh <thanh@@pdftex.org>
-% Copyright 2006-2008 Taco Hoekwater <taco@@luatex.org>
-%
-% This file is part of LuaTeX.
-%
-% LuaTeX is free software; you can redistribute it and/or modify it under
-% the terms of the GNU General Public License as published by the Free
-% Software Foundation; either version 2 of the License, or (at your
-% option) any later version.
-%
-% LuaTeX is distributed in the hope that it will be useful, but WITHOUT
-% ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-% FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
-% License for more details.
-%
-% You should have received a copy of the GNU General Public License along
-% with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+/*
 
-@ @c
+Copyright 2005-2006 Han The Thanh <thanh@pdftex.org>
+Copyright 2006-2008 Taco Hoekwater <taco@luatex.org>
 
+This file is part of LuaTeX.
+
+LuaTeX is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 2 of the License, or (at your
+option) any later version.
+
+LuaTeX is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+License for more details.
+
+You should have received a copy of the GNU General Public License along
+with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+
+*/
 
 #include "ptexlib.h"
 #include <string.h>
 
-@ @c
 static struct avl_table *sfd_tree = NULL;
 
 static unsigned char *sfd_buffer = NULL;
@@ -34,12 +32,11 @@ static int sfd_curbyte = 0;
 #define SFD_BUF_SIZE    SMALL_BUF_SIZE
 
 #define sfd_close()     xfclose(sfd_file, cur_file_name)
-#define sfd_open(a)      (sfd_file = fopen((char *)(a), FOPEN_RBIN_MODE))
+#define sfd_open(a)     (sfd_file = fopen((char *)(a), FOPEN_RBIN_MODE))
 
 #define sfd_read_file() readbinfile(sfd_file,&sfd_buffer,&sfd_size)
 #define sfd_getchar()   sfd_buffer[sfd_curbyte++]
-#define sfd_eof()      (sfd_curbyte>=sfd_size)
-
+#define sfd_eof()       (sfd_curbyte>=sfd_size)
 
 static FILE *sfd_file;
 static char sfd_line[SFD_BUF_SIZE];
@@ -50,8 +47,10 @@ static subfont_entry *new_subfont_entry(void)
     subfont_entry *subfont;
     subfont = xtalloc(1, subfont_entry);
     subfont->infix = NULL;
-    for (i = 0; i < 256; ++i)
-        subfont->charcodes[i] = -1;     /* unassigned */
+    for (i = 0; i < 256; ++i) {
+        /*tex Unassigned: */
+        subfont->charcodes[i] = -1;
+    }
     subfont->next = NULL;
     return subfont;
 }
@@ -84,8 +83,7 @@ static void destroy_sfd_entry(void *pa, void *pb)
 static int comp_sfd_entry(const void *pa, const void *pb, void *p)
 {
     (void) p;
-    return strcmp(((const sfd_entry *) pa)->name,
-                  ((const sfd_entry *) pb)->name);
+    return strcmp(((const sfd_entry *) pa)->name, ((const sfd_entry *) pb)->name);
 }
 
 void sfd_free(void)
@@ -117,19 +115,17 @@ static void sfd_getline(boolean expect_eof)
         goto restart;
 }
 
-@ @c
 static sfd_entry *read_sfd(char *sfd_name)
 {
     void **aa;
     sfd_entry *sfd, tmp_sfd;
     subfont_entry *sf;
-
     char buf[SMALL_BUF_SIZE], *p;
     long int i, j, k;
     int n;
     int callback_id = 0;
     int file_opened = 0;
-    /* check whether this sfd has been read */
+    /*tex Check whether this |sfd| has been read: */
     tmp_sfd.name = sfd_name;
     if (sfd_tree == NULL) {
         sfd_tree = avl_create(comp_sfd_entry, NULL, &avl_xallocator);
@@ -141,7 +137,6 @@ static sfd_entry *read_sfd(char *sfd_name)
     xfree(sfd_buffer);
     sfd_curbyte = 0;
     sfd_size = 0;
-
     cur_file_name = luatex_find_file(sfd_name, find_sfd_file_callback);
     if (cur_file_name) {
         callback_id = callback_defined(read_sfd_file_callback);
@@ -168,30 +163,38 @@ static sfd_entry *read_sfd(char *sfd_name)
     sfd->name = xstrdup(sfd_name);
     while (!sfd_eof()) {
         sfd_getline(true);
-        if (*sfd_line == 10)    /* empty line indicating eof */
+        if (*sfd_line == 10) {
+            /*tex An empty line indicates |EOF|. */
             break;
+        }
         sf = new_subfont_entry();
         sf->next = sfd->subfont;
         sfd->subfont = sf;
         sscanf(sfd_line, "%s %n", buf, &n);
         sf->infix = xstrdup(buf);
-        p = sfd_line + n;       /* skip to the next word */
+        /*tex Skip to the next word: */
+        p = sfd_line + n;
         k = 0;
       read_ranges:
         for (;;) {
-            if (*p == '\\') {   /* continue on next line */
+            if (*p == '\\') {
+                /*tex Continue on the next line: */
                 sfd_getline(false);
                 p = sfd_line;
                 goto read_ranges;
-            } else if (*p == 0) /* end of subfont */
+            } else if (*p == 0) {
+                /*tex End of subfont. */
                 break;
+            }
             if (sscanf(p, " %li %n", &i, &n) == 0)
                 formatted_error("sub font","invalid token: %s", p);
             p += n;
-            if (*p == ':') {    /* offset */
+            if (*p == ':') {
+                /*tex Variant: offset */
                 k = i;
                 p++;
-            } else if (*p == '_') {     /* range */
+            } else if (*p == '_') {
+                /*tex Variant: range */
                 if (sscanf(p + 1, " %li %n", &j, &n) == 0)
                     formatted_error("sub font","invalid token: %s", p);
                 if (i > j || k + (j - i) > 255)
@@ -199,8 +202,10 @@ static sfd_entry *read_sfd(char *sfd_name)
                 while (i <= j)
                     sf->charcodes[k++] = i++;
                 p += n + 1;
-            } else              /* codepoint */
+            } else {
+                /*tex Variant: codepoint */
                 sf->charcodes[k++] = i;
+            }
         }
     }
     tex_printf("}");
@@ -209,7 +214,6 @@ static sfd_entry *read_sfd(char *sfd_name)
     return sfd;
 }
 
-@ @c
 boolean handle_subfont_fm(fm_entry * fm, int mode)
 {
     size_t l;
@@ -220,16 +224,20 @@ boolean handle_subfont_fm(fm_entry * fm, int mode)
     char buf[SMALL_BUF_SIZE];
     assert(fm->tfm_name != NULL);
     p = fm->tfm_name;
-    q = strchr(p, '@@');         /* search for the first '@@' */
+    /*tex Search for the first |@|. */
+    q = strchr(p, '@');
     if (q == NULL)
         return false;
-    r = strchr(q + 1, '@@');     /* search for the second '@@' */
+    /*tex Search for the second |@|: */
+    r = strchr(q + 1, '@');
     if (r == NULL)
         return false;
-    if (q <= p || r <= q + 1    /* prefix or sfd name is empty */
-        || r - p != (int) strlen(p) - 1)        /* or the second '@@' is not the last char yet */
+    /*tex Check if prefix or sfd name is empty or the second |@| is not the last char yet. */
+    if (q <= p || r <= q + 1 || r - p != (int) strlen(p) - 1) {
         return false;
-    l = (size_t) (r - (q + 1)); /* length of sfd name */
+    }
+    /*tex The length of sfd name: */
+    l = (size_t) (r - (q + 1));
     strncpy(buf, q + 1, l);
     buf[l] = 0;
     check_buf(strlen(buf) + 4, SMALL_BUF_SIZE);
@@ -237,15 +245,16 @@ boolean handle_subfont_fm(fm_entry * fm, int mode)
     sfd = read_sfd(buf);
     if (sfd == NULL)
         return false;
-    /* at this point we know fm is a subfont */
+    /*tex At this point we know fm is a subfont. */
     set_subfont(fm);
     xfree(fm->ps_name);
-    /* set default values for PidEid */
+    /*tex Set default values for |Pid| and |Eid|: */
     if (fm->pid == -1) {
         fm->pid = 3;
         fm->eid = 1;
     }
-    l = (size_t) (q - p);       /* length of base tfm name (prefix) */
+    /*tex Calculate the length of base tfm name (prefix). */
+    l = (size_t) (q - p);
     for (sf = sfd->subfont; sf != NULL; sf = sf->next) {
         strncpy(buf, p, l);
         buf[l] = 0;
@@ -257,8 +266,11 @@ boolean handle_subfont_fm(fm_entry * fm, int mode)
         fm2->pid = fm->pid;
         fm2->eid = fm->eid;
         fm2->subfont = sf;
-        if (avl_do_entry(fm2, mode) != 0)       /* try to insert the entry */
-            delete_fm_entry(fm2);       /* delete it if failed */
+        /*tex Try to insert the entry. */
+        if (avl_do_entry(fm2, mode) != 0) {
+            /*tex And delete it if we failed. */
+            delete_fm_entry(fm2);
+        }
     }
     delete_fm_entry(fm);
     return true;
diff --git a/texk/web2c/luatexdir/font/texfont.w b/texk/web2c/luatexdir/font/texfont.c
similarity index 89%
rename from texk/web2c/luatexdir/font/texfont.w
rename to texk/web2c/luatexdir/font/texfont.c
index ce463326a..332a8a344 100644
--- a/texk/web2c/luatexdir/font/texfont.w
+++ b/texk/web2c/luatexdir/font/texfont.c
@@ -1,41 +1,52 @@
-% texfont.w
-%
-% Copyright 2006-2013 Taco Hoekwater <taco@@luatex.org>
-%
-% This file is part of LuaTeX.
-%
-% LuaTeX is free software; you can redistribute it and/or modify it under
-% the terms of the GNU General Public License as published by the Free
-% Software Foundation; either version 2 of the License, or (at your
-% option) any later version.
-%
-% LuaTeX is distributed in the hope that it will be useful, but WITHOUT
-% ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-% FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
-% License for more details.
-%
-% You should have received a copy of the GNU General Public License along
-% with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
-
-@* Main font API implementation for the original pascal parts.
-
-Stuff to watch out for:
-
-\item{} Knuth had a |'null_character'| that was used when a character could
-not be found by the |fetch()| routine, to signal an error. This has
-been deleted, but it may mean that the output of luatex is
-incompatible with TeX after |fetch()| has detected an error condition.
-
-\item{} Knuth also had a |font_glue()| optimization. I've removed that
-because it was a bit of dirty programming and it also was
-problematic |if 0 != null|.
-
-@c
+/*
+
+Copyright 2006-2013 Taco Hoekwater <taco@luatex.org>
+
+This file is part of LuaTeX.
+
+LuaTeX is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 2 of the License, or (at your
+option) any later version.
+
+LuaTeX is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+License for more details.
+
+You should have received a copy of the GNU General Public License along
+with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+
+*/
+
+/*tex
+
+    Here is the main font API implementation for the original pascal parts. Stuff
+    to watch out for:
+
+    \startitemize
+
+        \startitem
+            Knuth had a |'null_character'| that was used when a character could
+            not be found by the |fetch()| routine, to signal an error. This has
+            been deleted, but it may mean that the output of luatex is
+            incompatible with TeX after |fetch()| has detected an error
+            condition.
+        \stopitem
+
+        \startitem
+            Knuth also had a |font_glue()| optimization. I've removed that
+            because it was a bit of dirty programming and it also was problematic
+            |if 0 != null|.
+        \stopitem
+
+    \stopitemize
+
+*/
 
 #include "ptexlib.h"
 #include "lua/luatex-api.h"
 
-@ @c
 #define noDEBUG
 
 #define proper_char_index(c) (c<=font_ec(f) && c>=font_bc(f))
@@ -46,7 +57,6 @@ texfont **font_tables = NULL;
 static int font_arr_max = 0;
 static int font_id_maxval = 0;
 
-@ @c
 static void grow_font_table(int id)
 {
     int j;
@@ -89,7 +99,6 @@ void set_max_font_id(int i)
     font_id_maxval = i;
 }
 
-@ @c
 int new_font(void)
 {
     int k;
@@ -98,7 +107,7 @@ int new_font(void)
     sa_tree_item sa_value = { 0 };
     id = new_font_id();
     font_bytes += (int) sizeof(texfont);
-    /* most stuff is zero */
+    /*tex Most stuff is zero */
     font_tables[id] = xcalloc(1, sizeof(texfont));
     font_tables[id]->_font_name = NULL;
     font_tables[id]->_font_area = NULL;
@@ -112,43 +121,44 @@ int new_font(void)
     font_tables[id]->_right_boundary = NULL;
     font_tables[id]->_param_base = NULL;
     font_tables[id]->_math_param_base = NULL;
-
-    set_font_bc(id, 1);          /* ec = 0 */
+    /*tex |ec = 0| */
+    set_font_bc(id, 1);
     set_font_writingmode(id, 0);
     set_font_identity(id, 0);
     set_hyphen_char(id, '-');
     set_skew_char(id, -1);
-    font_slant(id) = 0;          /* vertical */
-    font_extend(id) = 1000;      /* normal width */
-
-    /* allocate eight values including 0 */
+    /*tex vertical */
+    font_slant(id) = 0;
+    /*tex normal width */
+    font_extend(id) = 1000;
+    /*tex normal height */
+    font_squeeze(id) = 1000;
+    font_width(id) = 0;
+    font_mode(id) = 0;
+    /*tex allocate eight values including 0 */
     set_font_params(id, 7);
     for (k = 0; k <= 7; k++) {
         set_font_param(id, k, 0);
     }
-    /* character info zero is reserved for notdef */
-    font_tables[id]->characters = new_sa_tree(1, 1, sa_value);    /* stack size 1, default item value 0 */
+    /*tex character info zero is reserved for |notdef|. The stack size 1, default item value 0. */
+    font_tables[id]->characters = new_sa_tree(1, 1, sa_value);
     ci = xcalloc(1, sizeof(charinfo));
     set_charinfo_name(ci, xstrdup(".notdef"));
     font_tables[id]->charinfo = ci;
     font_tables[id]->charinfo_size = 1;
     font_tables[id]->charinfo_cache = NULL;
-
     return id;
 }
 
-@ @c
 void font_malloc_charinfo(internal_font_number f, int num)
 {
     int glyph = font_tables[f]->charinfo_size;
     font_bytes += (int) (num * (int) sizeof(charinfo));
     do_realloc(font_tables[f]->charinfo, (unsigned) (glyph + num), charinfo);
-    memset(&(font_tables[f]->charinfo[glyph]), 0,
-           (size_t) (num * (int) sizeof(charinfo)));
+    memset(&(font_tables[f]->charinfo[glyph]), 0, (size_t) (num * (int) sizeof(charinfo)));
     font_tables[f]->charinfo_size += num;
 }
 
-@ @c
 #define find_charinfo_id(f,c) (get_sa_item(font_tables[f]->characters,c).int_value)
 
 charinfo *get_charinfo(internal_font_number f, int c)
@@ -163,9 +173,10 @@ charinfo *get_charinfo(internal_font_number f, int c)
             if (tglyph >= font_tables[f]->charinfo_size) {
                 font_malloc_charinfo(f, 256);
             }
-            font_tables[f]->charinfo[tglyph].ef = 1000; /* init */
+            font_tables[f]->charinfo[tglyph].ef = 1000;
             sa_value.int_value = tglyph;
-            set_sa_item(font_tables[f]->characters, c, sa_value, 1); /* 1 = global */
+            /*tex 1 means global */
+            set_sa_item(font_tables[f]->characters, c, sa_value, 1);
             glyph = tglyph;
         }
         return &(font_tables[f]->charinfo[glyph]);
@@ -187,7 +198,6 @@ charinfo *get_charinfo(internal_font_number f, int c)
     return &(font_tables[f]->charinfo[0]);
 }
 
-@ @c
 static void set_charinfo(internal_font_number f, int c, charinfo * ci)
 {
     int glyph;
@@ -205,7 +215,6 @@ static void set_charinfo(internal_font_number f, int c, charinfo * ci)
     }
 }
 
-@ @c
 charinfo *copy_charinfo(charinfo * ci)
 {
     int x, k;
@@ -231,7 +240,7 @@ charinfo *copy_charinfo(charinfo * ci)
     if (ci->tounicode != NULL) {
         co->tounicode = xstrdup(ci->tounicode);
     }
-    /* kerns */
+    /*tex Kerns */
     if ((kern = get_charinfo_kerns(ci)) != NULL) {
         x = 0;
         while (!kern_end(kern[x])) {
@@ -241,7 +250,7 @@ charinfo *copy_charinfo(charinfo * ci)
         co->kerns = xmalloc((unsigned) (x * (int) sizeof(kerninfo)));
         memcpy(co->kerns, ci->kerns, (size_t) (x * (int) sizeof(kerninfo)));
     }
-    /* ligs */
+    /*tex Ligatures */
     if ((lig = get_charinfo_ligatures(ci)) != NULL) {
         x = 0;
         while (!lig_end(lig[x])) {
@@ -252,14 +261,13 @@ charinfo *copy_charinfo(charinfo * ci)
         memcpy(co->ligatures, ci->ligatures,
                (size_t) (x * (int) sizeof(liginfo)));
     }
-    /* packets */
+    /*tex Packets */
     if ((packet = get_charinfo_packets(ci)) != NULL) {
         x = vf_packet_bytes(ci);
         co->packets = xmalloc((unsigned) x);
         memcpy(co->packets, ci->packets, (size_t) x);
     }
-
-    /* horizontal and vertical extenders */
+    /*tex Horizontal and vertical extenders */
     if (get_charinfo_vert_variants(ci) != NULL) {
         set_charinfo_vert_variants(co, copy_variants(get_charinfo_vert_variants(ci)));
     }
@@ -320,7 +328,6 @@ charinfo *char_info(internal_font_number f, int c)
     return &(font_tables[f]->charinfo[0]);
 }
 
-@ @c
 scaled_whd get_charinfo_whd(internal_font_number f, int c)
 {
     scaled_whd s;
@@ -332,7 +339,6 @@ scaled_whd get_charinfo_whd(internal_font_number f, int c)
     return s;
 }
 
-@ @c
 int char_exists(internal_font_number f, int c)
 {
     if (f > font_id_maxval)
@@ -347,35 +353,35 @@ int char_exists(internal_font_number f, int c)
     return 0;
 }
 
-@ @c
 int lua_glyph_not_found_callback(internal_font_number f, int c)
 {
     int callback_id;
     int ret = 0;
+    int top, i;
     callback_id = callback_defined(glyph_not_found_callback);
     if (callback_id != 0) {
+        top = lua_gettop(Luas);
         if (!get_callback(Luas, callback_id)) {
-            lua_pop(Luas, 2);
+            lua_settop(Luas, top);
             return 0;
         }
         lua_pushinteger(Luas, f);
         lua_pushinteger(Luas, c);
-        if (lua_pcall(Luas, 2, 1, 0) != 0) {       /* two args, 1 result */
-            fprintf(stdout, "error: %s\n", lua_tostring(Luas, -1));
-            lua_pop(Luas, 2);
-            error();
+        if ((i=lua_pcall(Luas, 2, 1, 0)) != 0) {
+            formatted_warning   ("glyph not found", "error: %s", lua_tostring(Luas, -1));
+            lua_settop(Luas, top);
+            luatex_error(Luas, (i == LUA_ERRRUN ? 0 : 1));
         } else {
             ret = lua_toboolean(Luas, -1);
         }
+        lua_settop(Luas, top);
     } else {
         char_warning(f,c);
     }
     return ret;
 }
 
-@ @c
-extinfo *new_variant(int glyph, int startconnect, int endconnect,
-                     int advance, int repeater)
+extinfo *new_variant(int glyph, int startconnect, int endconnect, int advance, int repeater)
 {
     extinfo *ext;
     ext = xmalloc(sizeof(extinfo));
@@ -388,8 +394,6 @@ extinfo *new_variant(int glyph, int startconnect, int endconnect,
     return ext;
 }
 
-
-@ @c
 static extinfo *copy_variant(extinfo * old)
 {
     extinfo *ext;
@@ -403,7 +407,6 @@ static extinfo *copy_variant(extinfo * old)
     return ext;
 }
 
-@ @c
 static void dump_variant(extinfo * ext)
 {
     dump_int(ext->glyph);
@@ -414,8 +417,6 @@ static void dump_variant(extinfo * ext)
     return;
 }
 
-
-@ @c
 static extinfo *undump_variant(void)
 {
     int x;
@@ -437,7 +438,6 @@ static extinfo *undump_variant(void)
     return ext;
 }
 
-@ @c
 void add_charinfo_vert_variant(charinfo * ci, extinfo * ext)
 {
     if (ci->vert_variants == NULL) {
@@ -451,7 +451,6 @@ void add_charinfo_vert_variant(charinfo * ci, extinfo * ext)
 
 }
 
-@ @c
 void add_charinfo_hor_variant(charinfo * ci, extinfo * ext)
 {
     if (ci->hor_variants == NULL) {
@@ -465,7 +464,6 @@ void add_charinfo_hor_variant(charinfo * ci, extinfo * ext)
 
 }
 
-@ @c
 extinfo *copy_variants(extinfo * o)
 {
     extinfo *c, *t = NULL, *h = NULL;
@@ -482,7 +480,6 @@ extinfo *copy_variants(extinfo * o)
     return h;
 }
 
-@ @c
 static void dump_charinfo_variants(extinfo * o)
 {
     while (o != NULL) {
@@ -493,7 +490,6 @@ static void dump_charinfo_variants(extinfo * o)
     return;
 }
 
-@ @c
 static extinfo *undump_charinfo_variants(void)
 {
     extinfo *c, *t = NULL, *h = NULL;
@@ -510,9 +506,12 @@ static extinfo *undump_charinfo_variants(void)
 }
 
 
-@ Note that mant more small things like this are implemented
-as macros in the header file.
-@c
+/*tex
+
+    Note that many more small things like this are implemented as macros in the
+    header file.
+*/
+
 void set_charinfo_width(charinfo * ci, scaled val)
 {
     ci->width = val;
@@ -610,7 +609,6 @@ void set_charinfo_rp(charinfo * ci, scaled val)
     ci->rp = val;
 }
 
-@ @c
 void set_charinfo_vert_variants(charinfo * ci, extinfo * ext)
 {
     extinfo *c, *lst;
@@ -625,7 +623,6 @@ void set_charinfo_vert_variants(charinfo * ci, extinfo * ext)
     ci->vert_variants = ext;
 }
 
-@ @c
 void set_charinfo_hor_variants(charinfo * ci, extinfo * ext)
 {
     extinfo *c, *lst;
@@ -641,11 +638,10 @@ void set_charinfo_hor_variants(charinfo * ci, extinfo * ext)
 
 }
 
-@ @c
 int get_charinfo_math_kerns(charinfo * ci, int id)
 {
-
-    int k = 0;                  /* all callers check for |result>0| */
+    /*tex All callers check for |result>0|. */
+    int k = 0;
     if (id == top_left_kern) {
         k = ci->top_left_math_kerns;
     } else if (id == bottom_left_kern) {
@@ -660,7 +656,6 @@ int get_charinfo_math_kerns(charinfo * ci, int id)
     return k;
 }
 
-@ @c
 void add_charinfo_math_kern(charinfo * ci, int id, scaled ht, scaled krn)
 {
     int k;
@@ -693,8 +688,6 @@ void add_charinfo_math_kern(charinfo * ci, int id, scaled ht, scaled krn)
     }
 }
 
-
-@ @c
 static void dump_math_kerns(charinfo * ci)
 {
     int k, l;
@@ -724,11 +717,9 @@ static void dump_math_kerns(charinfo * ci)
     }
 }
 
-@ @c
 static void undump_math_kerns(charinfo * ci)
 {
-    int k;
-    int x;
+    int k, x;
     undump_int(x);
     ci->top_left_math_kerns = x;
     if (x > 0)
@@ -771,21 +762,23 @@ static void undump_math_kerns(charinfo * ci)
     }
 }
 
+/*tex
 
-@ In TeX, extensibles were fairly simple things.
-   This function squeezes a TFM extensible into the vertical extender structures.
-   |advance==0| is a special case for TFM fonts, because finding the proper
-   advance width during tfm reading can be tricky
+    In TeX, extensibles were fairly simple things. This function squeezes a TFM
+    extensible into the vertical extender structures. |advance==0| is a special
+    case for TFM fonts, because finding the proper advance width during tfm
+    reading can be tricky.
 
+    A small complication arises if |rep| is the only non-zero: it needs to be
+    doubled as a non-repeatable to avoid mayhem.
 
-  a small complication arises if |rep| is the only non-zero: it needs to be
-  doubled as a non-repeatable to avoid mayhem */
+*/
 
-@c
 void set_charinfo_extensible(charinfo * ci, int top, int bot, int mid, int rep)
 {
     extinfo *ext;
-    set_charinfo_vert_variants(ci, NULL);       /* clear old */
+    /*tex Clear old data: */
+    set_charinfo_vert_variants(ci, NULL);
     if (bot == 0 && top == 0 && mid == 0 && rep != 0) {
         ext = new_variant(rep, 0, 0, 0, EXT_NORMAL);
         add_charinfo_vert_variant(ci, ext);
@@ -815,10 +808,13 @@ void set_charinfo_extensible(charinfo * ci, int top, int bot, int mid, int rep)
     }
 }
 
-@ Note that many more simple things like this are implemented as macros
-in the header file.
+/*tex
+
+    Note that many more simple things like this are implemented as macros in the
+    header file.
+
+*/
 
-@c
 scaled get_charinfo_width(charinfo * ci)
 {
     return ci->width;
@@ -987,7 +983,6 @@ scaled char_bot_accent(internal_font_number f, int c)
     return get_charinfo_bot_accent(ci);
 }
 
-
 int char_remainder(internal_font_number f, int c)
 {
     charinfo *ci = char_info(f, c);
@@ -1036,7 +1031,6 @@ eight_bits *char_packets(internal_font_number f, int c)
     return get_charinfo_packets(ci);
 }
 
-@ @c
 void set_font_params(internal_font_number f, int b)
 {
     int i;
@@ -1055,7 +1049,6 @@ void set_font_params(internal_font_number f, int b)
     }
 }
 
-@ @c
 void set_font_math_params(internal_font_number f, int b)
 {
     int i;
@@ -1074,13 +1067,11 @@ void set_font_math_params(internal_font_number f, int b)
     }
 }
 
-@ @c
 int copy_font(int f)
 {
     int i, ci_cnt, ci_size;
     charinfo *ci;
     int k = new_font();
-
     {
         ci = font_tables[k]->charinfo;
         ci_cnt = font_tables[k]->charinfo_count;
@@ -1090,12 +1081,10 @@ int copy_font(int f)
         font_tables[k]->charinfo_count = ci_cnt;
         font_tables[k]->charinfo_size = ci_size;
     }
-
     font_malloc_charinfo(k, font_tables[f]->charinfo_count);
     set_font_cache_id(k, 0);
     set_font_used(k, 0);
     set_font_touched(k, 0);
-
     font_tables[k]->_font_name = NULL;
     font_tables[k]->_font_filename = NULL;
     font_tables[k]->_font_fullname = NULL;
@@ -1106,7 +1095,6 @@ int copy_font(int f)
     font_tables[k]->_font_cidordering = NULL;
     font_tables[k]->_left_boundary = NULL;
     font_tables[k]->_right_boundary = NULL;
-
     set_font_name(k, xstrdup(font_name(f)));
     if (font_filename(f) != NULL)
         set_font_filename(k, xstrdup(font_filename(f)));
@@ -1122,12 +1110,10 @@ int copy_font(int f)
         set_font_cidregistry(k, xstrdup(font_cidregistry(f)));
     if (font_cidordering(f) != NULL)
         set_font_cidordering(k, xstrdup(font_cidordering(f)));
-
     i = (int) (sizeof(*param_base(f)) * (unsigned) (font_params(f)+1));
     font_bytes += i;
     param_base(k) = xmalloc((unsigned) (i+1));
     memcpy(param_base(k), param_base(f), (size_t) (i));
-
     if (font_math_params(f) > 0) {
         i = (int) (sizeof(*math_param_base(f)) *
                    (unsigned) font_math_params(f));
@@ -1135,27 +1121,23 @@ int copy_font(int f)
         math_param_base(k) = xmalloc((unsigned) i);
         memcpy(math_param_base(k), math_param_base(f), (size_t) i);
     }
-
     for (i = 0; i <= font_tables[f]->charinfo_count; i++) {
         ci = copy_charinfo(&font_tables[f]->charinfo[i]);
         font_tables[k]->charinfo[i] = *ci;
     }
-
     if (left_boundary(f) != NULL) {
         ci = copy_charinfo(left_boundary(f));
         set_charinfo(k, left_boundarychar, ci);
     }
-
     if (right_boundary(f) != NULL) {
         ci = copy_charinfo(right_boundary(f));
         set_charinfo(k, right_boundarychar, ci);
     }
-    /* not updated yet: */
+    /*tex Not updated yet: */
     font_tables[k]->charinfo_count = font_tables[f]->charinfo_count;
     return k;
 }
 
-@ @c
 void delete_font(int f)
 {
     int i;
@@ -1172,7 +1154,6 @@ void delete_font(int f)
         set_font_cidordering(f, NULL);
         set_left_boundary(f, NULL);
         set_right_boundary(f, NULL);
-
         for (i = font_bc(f); i <= font_ec(f); i++) {
             if (quick_char_exists(f, i)) {
                 co = char_info(f, i);
@@ -1185,24 +1166,21 @@ void delete_font(int f)
                 set_charinfo_hor_variants(co, NULL);
             }
         }
-        /* free .notdef */
+        /*tex free |notdef| */
         set_charinfo_name(font_tables[f]->charinfo + 0, NULL);
         free(font_tables[f]->charinfo);
         destroy_sa_tree(font_tables[f]->characters);
-
         free(param_base(f));
         if (math_param_base(f) != NULL)
             free(math_param_base(f));
         free(font_tables[f]);
         font_tables[f] = NULL;
-
         if (font_id_maxval == f) {
             font_id_maxval--;
         }
     }
 }
 
-@ @c
 void create_null_font(void)
 {
     int i = new_font();
@@ -1212,7 +1190,6 @@ void create_null_font(void)
     set_font_touched(i, 1);
 }
 
-@ @c
 boolean is_valid_font(int id)
 {
     int ret = 0;
@@ -1221,7 +1198,6 @@ boolean is_valid_font(int id)
     return ret;
 }
 
-@ @c
 boolean cmp_font_area(int id, str_number t)
 {
     char *tt = NULL;
@@ -1241,9 +1217,13 @@ boolean cmp_font_area(int id, str_number t)
     return 1;
 }
 
-@ Here come some subroutines to deal with expanded fonts for HZ-algorithm.
-return 1 == identical
-@c
+/*tex
+
+    Here come some subroutines to deal with expanded fonts for HZ-algorithm.
+    returning 1 means that they are identical.
+
+*/
+
 static boolean cmp_font_name(int id, char *tt)
 {
     char *tid;
@@ -1257,18 +1237,16 @@ static boolean cmp_font_name(int id, char *tt)
     return 1;
 }
 
-@ @c
 int test_no_ligatures(internal_font_number f)
 {
     int c;
     for (c = font_bc(f); c <= font_ec(f); c++) {
-        if (has_lig(f, c))      /* |char_exists(f,c)| */
+        if (has_lig(f, c))
             return 0;
     }
     return 1;
 }
 
-@ @c
 int get_tag_code(internal_font_number f, int c)
 {
     small_number i;
@@ -1286,7 +1264,6 @@ int get_tag_code(internal_font_number f, int c)
     return -1;
 }
 
-@ @c
 int get_lp_code(internal_font_number f, int c)
 {
     charinfo *ci = char_info(f, c);
@@ -1305,13 +1282,11 @@ int get_ef_code(internal_font_number f, int c)
     return get_charinfo_ef(ci);
 }
 
-@ @c
 void set_tag_code(internal_font_number f, int c, int i)
 {
     int fixedi;
     charinfo *co;
     if (char_exists(f, c)) {
-        /* |abs(fix_int(i-7,0))| */
         fixedi = -(i < -7 ? -7 : (i > 0 ? 0 : i));
         co = char_info(f, c);
         if (fixedi >= 4) {
@@ -1333,7 +1308,6 @@ void set_tag_code(internal_font_number f, int c, int i)
     }
 }
 
-@ @c
 void set_lp_code(internal_font_number f, int c, int i)
 {
     charinfo *co;
@@ -1361,7 +1335,6 @@ void set_ef_code(internal_font_number f, int c, int i)
     }
 }
 
-@ @c
 void set_no_ligatures(internal_font_number f)
 {
     int c;
@@ -1370,7 +1343,7 @@ void set_no_ligatures(internal_font_number f)
         return;
     co = char_info(f, left_boundarychar);
     set_charinfo_ligatures(co, NULL);
-    co = char_info(f, right_boundarychar);      /* this is weird */
+    co = char_info(f, right_boundarychar);
     set_charinfo_ligatures(co, NULL);
     for (c = 0; c < font_tables[f]->charinfo_count; c++) {
         co = font_tables[f]->charinfo + c;
@@ -1379,7 +1352,6 @@ void set_no_ligatures(internal_font_number f)
     font_tables[f]->ligatures_disabled = 1;
 }
 
-@ @c
 liginfo get_ligature(internal_font_number f, int lc, int rc)
 {
     int k = 0;
@@ -1407,7 +1379,6 @@ liginfo get_ligature(internal_font_number f, int lc, int rc)
     return t;
 }
 
-@ @c
 scaled raw_get_kern(internal_font_number f, int lc, int rc)
 {
     int k = 0;
@@ -1431,7 +1402,6 @@ scaled raw_get_kern(internal_font_number f, int lc, int rc)
     return 0;
 }
 
-@ @c
 scaled get_kern(internal_font_number f, int lc, int rc)
 {
     if (lc == non_boundarychar || rc == non_boundarychar || (!has_kern(f, lc)))
@@ -1440,15 +1410,14 @@ scaled get_kern(internal_font_number f, int lc, int rc)
 }
 
 
-@ dumping and undumping fonts
+/*tex Dumping and undumping fonts. */
 
-@c
-#define dump_string(a)			\
-    if (a!=NULL) {			\
-      x = (int)(strlen(a)+1);		\
-      dump_int(x);  dump_things(*a, x);	\
-    } else {				\
-	x = 0; dump_int(x);		\
+#define dump_string(a)                    \
+    if (a!=NULL) {                        \
+        x = (int)(strlen(a)+1);           \
+        dump_int(x);  dump_things(*a, x); \
+    } else {                              \
+        x = 0; dump_int(x);               \
     }
 
 static void dump_charinfo(int f, int c)
@@ -1476,8 +1445,7 @@ static void dump_charinfo(int f, int c)
     dump_int(get_charinfo_index(co));
     dump_string(get_charinfo_name(co));
     dump_string(get_charinfo_tounicode(co));
-
-    /* ligatures */
+    /*tex Ligatures */
     x = 0;
     if ((lig = get_charinfo_ligatures(co)) != NULL) {
         while (!lig_end(lig[x])) {
@@ -1489,7 +1457,7 @@ static void dump_charinfo(int f, int c)
     } else {
         dump_int(x);
     }
-    /* kerns */
+    /*tex Kerns */
     x = 0;
     if ((kern = get_charinfo_kerns(co)) != NULL) {
         while (!kern_end(kern[x])) {
@@ -1501,13 +1469,12 @@ static void dump_charinfo(int f, int c)
     } else {
         dump_int(x);
     }
-    /* packets */
+    /*tex Packets */
     x = vf_packet_bytes(co);
     dump_int(x);
     if (x > 0) {
         dump_things(*get_charinfo_packets(co), x);
     }
-
     if (get_charinfo_tag(co) == ext_tag) {
         dump_charinfo_variants(get_charinfo_vert_variants(co));
         dump_charinfo_variants(get_charinfo_hor_variants(co));
@@ -1532,6 +1499,9 @@ static void dump_font_entry(texfont * f)
     dump_int(f->_font_oldmath);
     dump_int(f->_font_slant);
     dump_int(f->_font_extend);
+    dump_int(f->_font_squeeze);
+    dump_int(f->_font_mode);
+    dump_int(f->_font_width);
     dump_int(f->font_max_shrink);
     dump_int(f->font_max_stretch);
     dump_int(f->_font_step);
@@ -1556,7 +1526,6 @@ static void dump_font_entry(texfont * f)
 void dump_font(int f)
 {
     int i, x;
-
     set_font_used(f, 0);
     font_tables[f]->charinfo_cache = NULL;
     dump_font_entry(font_tables[f]);
@@ -1568,9 +1537,7 @@ void dump_font(int f)
     dump_string(font_encodingname(f));
     dump_string(font_cidregistry(f));
     dump_string(font_cidordering(f));
-
     dump_things(*param_base(f), (font_params(f) + 1));
-
     if (font_math_params(f) > 0) {
         dump_things(*math_param_base(f), (font_math_params(f) + 1 ));
     }
@@ -1586,7 +1553,6 @@ void dump_font(int f)
     } else {
         dump_int(0);
     }
-
     for (i = font_bc(f); i <= font_ec(f); i++) {
         if (quick_char_exists(f, i)) {
             dump_charinfo(f, i);
@@ -1594,7 +1560,6 @@ void dump_font(int f)
     }
 }
 
-@ @c
 static int undump_charinfo(int f)
 {
     charinfo *co;
@@ -1603,7 +1568,6 @@ static int undump_charinfo(int f)
     liginfo *lig = NULL;
     kerninfo *kern = NULL;
     eight_bits *packet = NULL;
-
     undump_int(i);
     co = get_charinfo(f, i);
     undump_int(x);
@@ -1634,8 +1598,7 @@ static int undump_charinfo(int f)
     set_charinfo_used(co, x);
     undump_int(x);
     set_charinfo_index(co, x);
-
-    /* name */
+    /*tex Name */
     undump_int(x);
     if (x > 0) {
         font_bytes += x;
@@ -1643,7 +1606,7 @@ static int undump_charinfo(int f)
         undump_things(*s, x);
     }
     set_charinfo_name(co, s);
-    /* tounicode */
+    /*tex Tounicode */
     undump_int(x);
     if (x > 0) {
         font_bytes += x;
@@ -1651,7 +1614,7 @@ static int undump_charinfo(int f)
         undump_things(*s, x);
     }
     set_charinfo_tounicode(co, s);
-    /* ligatures */
+    /*tex Ligatures */
     undump_int(x);
     if (x > 0) {
         font_bytes += (int) ((unsigned) x * sizeof(liginfo));
@@ -1659,7 +1622,7 @@ static int undump_charinfo(int f)
         undump_things(*lig, x);
     }
     set_charinfo_ligatures(co, lig);
-    /* kerns */
+    /*tex Kerns */
     undump_int(x);
     if (x > 0) {
         font_bytes += (int) ((unsigned) x * sizeof(kerninfo));
@@ -1668,7 +1631,7 @@ static int undump_charinfo(int f)
     }
     set_charinfo_kerns(co, kern);
 
-    /* packets */
+    /*tex Packets */
     undump_int(x);
     if (x > 0) {
         font_bytes += x;
@@ -1676,7 +1639,6 @@ static int undump_charinfo(int f)
         undump_things(*packet, x);
     }
     set_charinfo_packets(co, packet);
-
     if (get_charinfo_tag(co) == ext_tag) {
         set_charinfo_vert_variants(co, undump_charinfo_variants());
         set_charinfo_hor_variants(co, undump_charinfo_variants());
@@ -1685,19 +1647,18 @@ static int undump_charinfo(int f)
     return i;
 }
 
-#define undump_font_string(a) \
-    undump_int (x); \
-    if (x>0) { \
-        font_bytes += x; \
+#define undump_font_string(a)     \
+    undump_int (x);               \
+    if (x>0) {                    \
+        font_bytes += x;          \
         s = xmalloc((unsigned)x); \
-        undump_things(*s,x); \
-        a(f,s); \
+        undump_things(*s,x);      \
+        a(f,s);                   \
     }
 
 static void undump_font_entry(texfont * f)
 {
     int x = 0;
-    /* *INDENT-OFF* */
     undump_int(x); f->_font_size = x;
     undump_int(x); f->_font_dsize = x;
     undump_int(x); f->_font_cidversion = x;
@@ -1711,6 +1672,9 @@ static void undump_font_entry(texfont * f)
     undump_int(x); f->_font_oldmath = x;
     undump_int(x); f->_font_slant = x;
     undump_int(x); f->_font_extend = x;
+    undump_int(x); f->_font_squeeze = x;
+    undump_int(x); f->_font_mode = x;
+    undump_int(x); f->_font_width = x;
     undump_int(x); f->font_max_shrink = x;
     undump_int(x); f->font_max_stretch = x;
     undump_int(x); f->_font_step = x;
@@ -1730,7 +1694,6 @@ static void undump_font_entry(texfont * f)
     undump_int(x); f->ligatures_disabled = x;
     undump_int(x); f->_pdf_font_num = x;
     undump_int(x); f->_pdf_font_attr = x;
-    /* *INDENT-ON* */
 }
 
 void undump_font(int f)
@@ -1746,7 +1709,6 @@ void undump_font(int f)
     font_bytes += (int) sizeof(texfont);
     undump_font_entry(tt);
     font_tables[f] = tt;
-
     undump_font_string(set_font_name);
     undump_font_string(set_font_area);
     undump_font_string(set_font_filename);
@@ -1755,12 +1717,10 @@ void undump_font(int f)
     undump_font_string(set_font_encodingname);
     undump_font_string(set_font_cidregistry);
     undump_font_string(set_font_cidordering);
-
     i = (int) (sizeof(*param_base(f)) * ((unsigned) font_params(f) + 1));
     font_bytes += i;
     param_base(f) = xmalloc((unsigned) i);
     undump_things(*param_base(f), (font_params(f) + 1));
-
     if (font_math_params(f) > 0) {
         i = (int) (sizeof(*math_param_base(f)) *
                    ((unsigned) font_math_params(f) + 1));
@@ -1768,35 +1728,40 @@ void undump_font(int f)
         math_param_base(f) = xmalloc((unsigned) i);
         undump_things(*math_param_base(f), (font_math_params(f) + 1));
     }
-
-    /* stack size 1, default item value 0 */
+    /*tex stack size 1, default item value 0 */
     font_tables[f]->characters = new_sa_tree(1, 1, sa_value);
     ci = xcalloc(1, sizeof(charinfo));
     set_charinfo_name(ci, xstrdup(".notdef"));
     font_tables[f]->charinfo = ci;
     undump_int(x);
     if (x) {
-        i = undump_charinfo(f); /* left boundary */
+        /*tex left boundary */
+        i = undump_charinfo(f);
     }
     undump_int(x);
     if (x) {
-        i = undump_charinfo(f); /* right boundary */
+        /*tex right boundary */
+        i = undump_charinfo(f);
     }
-
     i = font_bc(f);
     while (i < font_ec(f)) {
         i = undump_charinfo(f);
     }
 }
 
-/* moved from pdffont.w */
+/* The \PK\ pixel density value from |texmf.cnf| */
+
+int pk_dpi;
 
-@ @c
-int pk_dpi; /* PK pixel density value from \.{texmf.cnf} */
+/*tex
+
+    This one looks up the font for a \TFM\ with name |s| loaded at |fs| size and
+    if found then flushes |s|.
+
+*/
 
-@ @c
 internal_font_number tfm_lookup(char *s, scaled fs)
-{   /* looks up for a TFM with name |s| loaded at |fs| size; if found then flushes |s| */
+{
     internal_font_number k;
     if (fs != 0) {
         for (k = 1; k <= max_font_id(); k++) {
@@ -1814,9 +1779,14 @@ internal_font_number tfm_lookup(char *s, scaled fs)
     return null_font;
 }
 
-@ @c
+/*tex
+
+    This returns the multiple of |font_step(f)| that is nearest to |e|.
+
+*/
+
 int fix_expand_value(internal_font_number f, int e)
-{                               /* return the multiple of |font_step(f)| that is nearest to |e| */
+{
     int step;
     int max_expand;
     boolean neg;
@@ -1842,7 +1812,6 @@ int fix_expand_value(internal_font_number f, int e)
     return e;
 }
 
-@ @c
 void set_expand_params(internal_font_number f, int stretch_limit, int shrink_limit, int font_step)
 {
     set_font_step(f, font_step);
@@ -1850,19 +1819,20 @@ void set_expand_params(internal_font_number f, int stretch_limit, int shrink_lim
     set_font_max_stretch(f, stretch_limit);
 }
 
-@ @c
+/*tex
+
+    This reads font expansion spec and load expanded font.
+
+*/
+
 void read_expand_font(void)
-{                               /* read font expansion spec and load expanded font */
+{
     int shrink_limit, stretch_limit, font_step;
     internal_font_number f;
-    /* read font expansion parameters */
     scan_font_ident();
     f = cur_val;
     if (f == null_font)
         normal_error("font expansion", "invalid font identifier");
-    /*if (pdf_font_blink(f) != null_font)*/
-    /*    normal_error("font expansion",*/
-    /*              "\\fontexpand cannot be used this way (the base font has been expanded)");*/
     scan_optional_equals();
     scan_int();
     stretch_limit = fix_int(cur_val, 0, 1000);
@@ -1882,24 +1852,21 @@ void read_expand_font(void)
         normal_error("font expansion", "invalid limit(s)");
     if (scan_keyword("autoexpand")) {
         normal_warning("font expansion", "autoexpand not supported");
-        /* Scan an optional space */
+        /*tex scan an optional space */
         get_x_token();
         if (cur_cmd != spacer_cmd)
             back_input();
     }
     if (font_step(f) != 0) {
-        /* this font has been expanded, ensure the expansion parameters are identical */
+        /*tex This font has been expanded, ensure the expansion parameters are identical. */
         if (font_step(f) != font_step)
             normal_error("font expansion","font has been expanded with different expansion step");
-
         if (((font_max_stretch(f) == 0) && (stretch_limit != 0)) ||
-            ((font_max_stretch(f) > 0)
-             && (font_max_stretch(f) != stretch_limit)))
+            ((font_max_stretch(f) > 0) && (font_max_stretch(f) != stretch_limit)))
             normal_error("font expansion","font has been expanded with different stretch limit");
 
         if (((font_max_shrink(f) == 0) && (shrink_limit != 0)) ||
-            ((font_max_shrink(f) > 0)
-             && (font_max_shrink(f) != shrink_limit)))
+            ((font_max_shrink(f) > 0) && (font_max_shrink(f) != shrink_limit)))
             normal_error("font expansion","font has been expanded with different shrink limit");
     } else {
         if (font_used(f))
@@ -1908,11 +1875,17 @@ void read_expand_font(void)
     }
 }
 
-@ @c
+/*tex
+
+    Here's an old (sort of obsolete) letterspace-a-font helper. It does so by by
+    creating a virtual font.
+
+*/
+
 void new_letterspaced_font(small_number a)
-{                               /* letter-space a font by creating a virtual font */
-    pointer u;                  /* user's font identifier */
-    str_number t;               /* name for the frozen font identifier */
+{
+    pointer u;
+    str_number t;
     internal_font_number f, k;
     boolean nolig = false;
     get_r_token();
@@ -1934,11 +1907,17 @@ void new_letterspaced_font(small_number a)
     font_id_text(f) = t;
 }
 
-@ @c
+/*tex
+
+    This makes a font copy for further use with font expansion. Again a
+    traditional font related helper.
+
+*/
+
 void make_font_copy(small_number a)
-{                               /* make a font copy for further use with font expansion */
-    pointer u;                  /* user's font identifier */
-    str_number t;               /* name for the frozen font identifier */
+{
+    pointer u;
+    str_number t;
     internal_font_number f, k;
     get_r_token();
     u = cur_cs;
@@ -1956,7 +1935,6 @@ void make_font_copy(small_number a)
     font_id_text(f) = t;
 }
 
-@ @c
 void glyph_to_unicode(void)
 {
     str_number s1, s2;
diff --git a/texk/web2c/luatexdir/font/tfmofm.c b/texk/web2c/luatexdir/font/tfmofm.c
new file mode 100644
index 000000000..f5d8c2e92
--- /dev/null
+++ b/texk/web2c/luatexdir/font/tfmofm.c
@@ -0,0 +1,1186 @@
+/*
+
+Copyright 2006-2012 Taco Hoekwater <taco@@luatex.org>
+
+This file is part of LuaTeX.
+
+LuaTeX is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 2 of the License, or (at your
+option) any later version.
+
+LuaTeX is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+License for more details.
+
+You should have received a copy of the GNU General Public License along
+with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#include "ptexlib.h"
+
+/*tex Here are some macros that help process ligatures and kerns */
+
+#define lig_kern_start(f,c)   char_remainder(f,c)
+
+/*tex A value indicating |STOP| in a lig/kern program: */
+
+#define stop_flag 128
+
+/*tex The op code for a kern step: */
+
+#define kern_flag 128
+
+#define skip_byte(z)        lig_kerns[z].b0
+#define next_char(z)        lig_kerns[z].b1
+#define op_byte(z)          lig_kerns[z].b2
+#define rem_byte(z)         lig_kerns[z].b3
+#define lig_kern_restart(c) (256*op_byte(c)+rem_byte(c))
+
+
+/*tex
+
+    The information in a \TFM\file appears in a sequence of 8-bit bytes. Since
+    the number of bytes is always a multiple of 4, we could also regard the file
+    as a sequence of 32-bit words, but \TeX\ uses the byte interpretation. The
+    format of \TFM\files was designed by Lyle Ramshaw in 1980. The intent is
+    to convey a lot of different kinds of information in a compact but useful
+    form.
+
+    $\Omega$ is capable of reading not only \TFM\files, but also \.{OFM}
+    files, which can describe fonts with up to 65536 characters and with huge
+    lig/kern tables. These fonts will often be virtual fonts built up from real
+    fonts with 256 characters, but $\Omega$ is not aware of this.
+
+    The documentation below describes \TFM\files, with slight additions to
+    show where \.{OFM} files differ.
+
+    The first 24 bytes (6 words) of a \TFM\file contain twelve 16-bit integers
+    that give the lengths of the various subsequent portions of the file. These
+    twelve integers are, in order:
+
+    \starttabulate
+        \NC \type {lf| \NC length of the entire file, in words \NC \NR
+        \NC \type {lh| \NC length of the header data, in words \NC \NR
+        \NC \type {bc| \NC smallest character code in the font \NC \NR
+        \NC \type {ec| \NC largest character code in the font \NC \NR
+        \NC \type {nw| \NC number of words in the width table \NC \NR
+        \NC \type {nh| \NC number of words in the height table \NC \NR
+        \NC \type {nd| \NC number of words in the depth table \NC \NR
+        \NC \type {ni| \NC number of words in the italic correction table \NC \NR
+        \NC \type {nl| \NC number of words in the lig/kern table \NC \NR
+        \NC \type {nk| \NC number of words in the kern table \NC \NR
+        \NC \type {ne| \NC number of words in the extensible character table \NC \NR
+        \NC \type {np| \NC number of font parameter words \NC \NR
+    \stoptabulate
+
+    They are all nonnegative and less than $2^{15}$. We must have
+    |bc-1<=ec<=255|, and $|lf=6+lh+(ec-bc+1)+nw+nh+nd+ni+nl+nk+ne+np|$. Note that
+    a \TFM\font may contain as many as 256 characters (if |bc=0| and
+    |ec=255|), and as few as 0 characters (if |bc=ec+1|).
+
+    Incidentally, when two or more 8-bit bytes are combined to form an integer of
+    16 or more bits, the most significant bytes appear first in the file. This is
+    called BigEndian order.
+
+    The first 52 bytes (13 words) of an \.{OFM} file contains thirteen 32-bit
+    integers that give the lengths of the various subsequent portions of the
+    file. The first word is 0 (future versions of \.{OFM} files could have
+    different values; what is important is that the first two bytes be 0 to
+    differentiate \TFM\and \.{OFM} files). The next twelve integers are as
+    above, all nonegative and less than~$2^{31}$. We must have |bc-1<=ec<=65535|,
+    and $$\hbox{|lf=13+lh+2*(ec-bc+1)+nw+nh+nd+ni+nl+nk+ne+np|.}$$ Note that an
+    \.{OFM} font may contain as many as 65536 characters (if |bc=0| and
+    |ec=65535|), and as few as 0 characters (if |bc=ec+1|).
+
+    The rest of the \TFM\file may be regarded as a sequence of ten data arrays
+    having the informal specification
+
+    \starttabulate
+    \NC \type {header}     \NC \type {[0..lh-1]} \NC \type {stuff} \NC \NR
+    \NC \type {char\_info} \NC \type {[bc..ec]}  \NC \type {char_info_word} \NC \NR
+    \NC \type {width}      \NC \type {[0..nw-1]} \NC \type {fix_word} \NC \NR
+    \NC \type {height}     \NC \type {[0..nh-1]} \NC \type {fix_word} \NC \NR
+    \NC \type {depth}      \NC \type {[0..nd-1]} \NC \type {fix_word} \NC \NR
+    \NC \type {italic}     \NC \type {[0..ni-1]} \NC \type {fix_word} \NC \NR
+    \NC \type {lig\_kern}  \NC \type {[0..nl-1]} \NC \type {lig_kern_command} \NC \NR
+    \NC \type {kern}       \NC \type {[0..nk-1]} \NC \type {fix_word} \NC \NR
+    \NC \type {exten}      \NC \type {[0..ne-1]} \NC \type {extensible_recipe} \NC \NR
+    \NC \type {param}      \NC \type {[1..np]}   \NC \type {fix_word} \NC \NR
+    \stoptabulate
+
+    The most important data type used here is a |@!fix_word|, which is a 32-bit
+    representation of a binary fraction. A |fix_word| is a signed quantity, with
+    the two's complement of the entire word used to represent negation. Of the 32
+    bits in a |fix_word|, exactly 12 are to the left of the binary point; thus,
+    the largest |fix_word| value is $2048-2^{-20}$, and the smallest is $-2048$.
+    We will see below, however, that all but two of the |fix_word| values must
+    lie between $-16$ and $+16$.
+
+    The first data array is a block of header information, which contains general
+    facts about the font. The header must contain at least two words, |header[0]|
+    and |header[1]|, whose meaning is explained below. Additional header
+    information of use to other software routines might also be included, but
+    \TeX82 does not need to know about such details. For example, 16 more words
+    of header information are in use at the Xerox Palo Alto Research Center; the
+    first ten specify the character coding scheme used (e.g., `\.{XEROX text}' or
+    `\.{TeX math symbols}'), the next five give the font identifier (e.g.,
+    `\.{HELVETICA}' or `\.{CMSY}'), and the last gives the ``face byte.'' The
+    program that converts \.{DVI} files to Xerox printing format gets this
+    information by looking at the \TFM\file, which it needs to read anyway
+    because of other information that is not explicitly repeated in
+    \.{DVI}~format.
+
+    \startitemize
+
+        \startitem
+            |header[0]| is a 32-bit check sum that \TeX\ will copy into the
+            \.{DVI} output file. Later on when the \.{DVI} file is printed,
+            possibly on another computer, the actual font that gets used is
+            supposed to have a check sum that agrees with the one in the \TFM\
+            file used by \TeX. In this way, users will be warned about potential
+            incompatibilities. (However, if the check sum is zero in either the
+            font file or the \TFM\file, no check is made.) The actual relation
+            between this check sum and the rest of the \TFM\file is not
+            important; the check sum is simply an identification number with the
+            property that incompatible fonts almost always have distinct check
+            sums.
+        \stopitem
+
+        \startitem
+            |header[1]| is a |fix_word| containing the design size of the font,
+            in units of \TeX\ points. This number must be at least 1.0; it is
+            fairly arbitrary, but usually the design size is 10.0 for a ``10
+            point'' font, i.e., a font that was designed to look best at a
+            10-point size, whatever that really means. When a \TeX\ user asks for
+            a font `\.{at} $\delta$ \.{pt}', the effect is to override the design
+            size and replace it by $\delta$, and to multiply the $x$ and~$y$
+            coordinates of the points in the font image by a factor of $\delta$
+            divided by the design size. {\sl All other dimensions in the\/
+            \TFM\file are |fix_word|\kern-1pt\ numbers in design-size units},
+            with the exception of |param[1]| (which denotes the slant ratio).
+            Thus, for example, the value of |param[6]|, which defines the \.{em}
+            unit, is often the |fix_word| value $2^{20}=1.0$, since many fonts
+            have a design size equal to one em. The other dimensions must be less
+            than 16 design-size units in absolute value; thus, |header[1]| and
+            |param[1]| are the only |fix_word| entries in the whole \TFM\file
+            whose first byte might be something besides 0 or 255.
+        \stopitem
+
+    \stopitemize
+
+    Next comes the |char_info| array, which contains one |@!char_info_word| per
+    character. Each word in this part of a \TFM\file contains six fields
+    packed into four bytes as follows.
+
+    \startitemize
+        \startitem
+            first byte: |width_index| (8 bits)
+        \stopitem
+        \startitem
+            second byte: |height_index| (4 bits) times 16, plus |depth_index|
+            (4~bits)
+        \stopitem
+        \startitem
+            third byte: |italic_index| (6 bits) times 4, plus |tag| (2~bits)
+        \stopitem
+        \startitem
+            fourth byte: |remainder| (8 bits)
+        \stopitem
+    \stopitemize
+
+    The actual width of a character is \\{width}|[width_index]|, in design-size
+    units; this is a device for compressing information, since many characters
+    have the same width. Since it is quite common for many characters to have the
+    same height, depth, or italic correction, the \TFM\format imposes a limit
+    of 16 different heights, 16 different depths, and 64 different italic
+    corrections.
+
+    For \.{OFM} files, two words (eight bytes) are used. The arrangement is as
+    follows.
+
+    \startitemize
+        \startitem
+            first and second bytes: |width_index| (16 bits)
+        \stopitem
+            \startitem third byte: |height_index| (8 bits)
+        \stopitem
+        \startitem
+            fourth byte: |depth_index| (8~bits)
+        \stopitem
+        \startitem
+            fifth and sixth bytes: |italic_index| (14 bits) times 4, plus |tag|
+            (2~bits)
+        \startitem
+            seventh and eighth bytes: |remainder| (16 bits)
+        \stopitem
+    \stopitemize
+
+    Therefore the \.{OFM} format imposes a limit of 256 different heights, 256
+    different depths, and 16384 different italic corrections.
+
+    The italic correction of a character has two different uses. (a)~In ordinary
+    text, the italic correction is added to the width only if the \TeX\ user
+    specifies `\.{\\/}' after the character. (b)~In math formulas, the italic
+    correction is always added to the width, except with respect to the
+    positioning of subscripts.
+
+    Incidentally, the relation $\\{width}[0]=\\{height}[0]=\\{depth}[0]=
+    \\{italic}[0]=0$ should always hold, so that an index of zero implies a value
+    of zero. The |width_index| should never be zero unless the character does not
+    exist in the font, since a character is valid if and only if it lies between
+    |bc| and |ec| and has a nonzero |width_index|.
+
+    \TeX\ checks the information of a \TFM\file for validity as the file is
+    being read in, so that no further checks will be needed when typesetting is
+    going on. The somewhat tedious subroutine that does this is called
+    |read_font_info|. It has four parameters: the user font identifier~|u|, the
+    file name and area strings |nom| and |aire|, and the ``at'' size~|s|. If
+    |s|~is negative, it's the negative of a scale factor to be applied to the
+    design size; |s=-1000| is the normal case. Otherwise |s| will be substituted
+    for the design size; in this case, |s| must be positive and less than
+    $2048\rm\,pt$ (i.e., it must be less than $2^{27}$ when considered as an
+    integer).
+
+    The subroutine opens and closes a global file variable called |tfm_file|. It
+    returns the value of the internal font number that was just loaded. If an
+    error is detected, an error message is issued and no font information is
+    stored; |null_font| is returned in this case.
+
+    The |tag| field in a |char_info_word| has four values that explain how to
+    interpret the |remainder| field.
+
+    \startitemize
+        \startitem
+            |tag=0| (|no_tag|) means that |remainder| is unused.
+        \stopitem
+        \startitem
+            |tag=1| (|lig_tag|) means that this character has a ligature/kerning
+            program starting at position |remainder| in the |lig_kern| array
+        \stopitem
+        \startitem
+            |tag=2| (|list_tag|) means that this character is part of a chain of
+            characters of ascending sizes, and not the largest in the chain. The
+            |remainder| field gives the character code of the next larger
+            character
+        \stopitem
+        \startitem
+            |tag=3| (|ext_tag|) means that this character code represents an
+            extensible character, i.e., a character that is built up of smaller
+            pieces so that it can be made arbitrarily large. The pieces are
+            specified in |exten[remainder]|
+        \stopitem
+    \stopitemize
+
+    Characters with |tag=2| and |tag=3| are treated as characters with |tag=0|
+    unless they are used in special circumstances in math formulas. For example,
+    the \.{\\sum} operation looks for a |list_tag|, and the \.{\\left} operation
+    looks for both |list_tag| and |ext_tag|.
+
+    The |lig_kern| array contains instructions in a simple programming language
+    that explains what to do for special letter pairs. Each word in this array,
+    in a \TFM\file, is a |@!lig_kern_command| of four bytes.
+
+    \startitemize
+        \startitem
+            first byte: |skip_byte|, indicates that this is the final program
+            step if the byte is 128 or more, otherwise the next step is obtained
+            by skipping this number of intervening steps
+        \stopitem
+        \startitem
+            second byte: |next_char|, if |next_char| follows the current
+            character, then perform the operation and stop, otherwise
+            continue
+        \stopitem
+        \startitem
+            third byte: |op_byte|, indicates a ligature step if less than~128, a
+            kern step otherwise
+        \stopitem
+        \startitem
+            fourth byte: |remainder|
+        \stopitem
+    \stopitemize
+
+    In an \.{OFM} file, eight bytes are used, two bytes for each field.
+
+    In a kern step, an additional space equal to |kern[256 * (op_byte-128) +
+    remainder]| is inserted between the current character and |next_char|. This
+    amount is often negative, so that the characters are brought closer together
+    by kerning; but it might be positive.
+
+    There are eight kinds of ligature steps, having |op_byte| codes $4a+2b+c$
+    where $0\le a\le b+c$ and $0\le b,c\le1$. The character whose code is
+    |remainder| is inserted between the current character and |next_char|; then
+    the current character is deleted if $b=0$, and |next_char| is deleted if
+    $c=0$; then we pass over $a$~characters to reach the next current character
+    (which may have a ligature/kerning program of its own).
+
+    If the very first instruction of the |lig_kern| array has |skip_byte=255|,
+    the |next_char| byte is the so-called right boundary character of this font;
+    the value of |next_char| need not lie between |bc| and~|ec|. If the very last
+    instruction of the |lig_kern| array has |skip_byte=255|, there is a special
+    ligature/kerning program for a left boundary character, beginning at location
+    |256*op_byte+remainder|. The interpretation is that \TeX\ puts implicit
+    boundary characters before and after each consecutive string of characters
+    from the same font. These implicit characters do not appear in the output,
+    but they can affect ligatures and kerning.
+
+    If the very first instruction of a character's |lig_kern| program has
+    |skip_byte>128|, the program actually begins in location
+    |256*op_byte+remainder|. This feature allows access to large |lig_kern|
+    arrays, because the first instruction must otherwise appear in a location
+    |<=255| in a \TFM\file, |<=65535| in an \.{OFM} file.
+
+    Any instruction with |skip_byte>128| in the |lig_kern| array must satisfy the
+    condition $$\hbox{|256*op_byte+remainder<nl|.}$$ If such an instruction is
+    encountered during normal program execution, it denotes an unconditional
+    halt; no ligature or kerning command is performed.
+
+    Extensible characters are specified by an |@!extensible_recipe|, which
+    consists of four bytes in a \TFM\file, called |@!top|, |@!mid|, |@!bot|,
+    and |@!rep| (in this order). In an \.{OFM} file, each field takes two bytes,
+    for eight in total. These bytes are the character codes of individual pieces
+    used to build up a large symbol. If |top|, |mid|, or |bot| are zero, they are
+    not present in the built-up result. For example, an extensible vertical line
+    is like an extensible bracket, except that the top and bottom pieces are
+    missing.
+
+    Let $T$, $M$, $B$, and $R$ denote the respective pieces, or an empty box if
+    the piece isn't present. Then the extensible characters have the form
+    $TR^kMR^kB$ from top to bottom, for some |k>=0|, unless $M$ is absent; in the
+    latter case we can have $TR^kB$ for both even and odd values of~|k|. The
+    width of the extensible character is the width of $R$; and the
+    height-plus-depth is the sum of the individual height-plus-depths of the
+    components used, since the pieces are butted together in a vertical list.
+
+    The final portion of a \TFM\file is the |param| array, which is another
+    sequence of |fix_word| values.
+
+    \startitemize
+
+    \startitem
+        |param[1]=slant| is the amount of italic slant, which is used to help
+        position accents. For example, |slant=.25| means that when you go up one
+        unit, you also go .25 units to the right. The |slant| is a pure number;
+        it's the only |fix_word| other than the design size itself that is not
+        scaled by the design size.
+    \stopitem
+
+    \startitem
+        |param[2]=space| is the normal spacing between words in text. Note that
+        character |" "| in the font need not have anything to do with blank
+        spaces.
+    \stopitem
+
+    \startitem
+        |param[3]=space_stretch| is the amount of glue stretching between words.
+    \stopitem
+
+    \startitem
+        |param[4]=space_shrink| is the amount of glue shrinking between words.
+    \stopitem
+
+    \startitem
+        |param[5]=x_height| is the size of one ex in the font; it is also the
+        height of letters for which accents don't have to be raised or lowered.
+    \stopitem
+
+    \startitem
+        |param[6]=quad| is the size of one em in the font.
+    \stopitem
+
+    \startitem
+        |param[7]=extra_space| is the amount added to |param[2]| at the ends of
+        sentences.
+    \stopitem
+
+
+    If fewer than seven parameters are present, \TeX\ sets the missing parameters
+    to zero. Fonts used for math symbols are required to have additional
+    parameter information, which is explained later.
+
+
+    There are programs called \.{TFtoPL} and \.{PLtoTF} that convert between the
+    \TFM\format and a symbolic property-list format that can be easily edited.
+    These programs contain extensive diagnostic information, so \TeX\ does not
+    have to bother giving precise details about why it rejects a particular
+    \TFM\file.
+
+*/
+
+#define tfm_abort {                    \
+    font_tables[f]->_font_name = NULL; \
+    font_tables[f]->_font_area = NULL; \
+    xfree(tfm_buffer); xfree(kerns);   \
+    xfree(widths);                     \
+    xfree(heights);                    \
+    xfree(depths);                     \
+    xfree(italics);                    \
+    xfree(extens);                     \
+    xfree(lig_kerns);                  \
+    xfree(xligs);                      \
+    xfree(xkerns);                     \
+    return 0;                          \
+}
+
+#define tfm_success {  \
+    xfree(tfm_buffer); \
+    xfree(kerns);      \
+    xfree(widths);     \
+    xfree(heights);    \
+    xfree(depths);     \
+    xfree(italics);    \
+    xfree(extens);     \
+    xfree(lig_kerns);  \
+    xfree(xligs);      \
+    xfree(xkerns);     \
+    return 1;          \
+}
+
+static int open_tfm_file(const char *nom, unsigned char **tfm_buf, int *tfm_siz)
+{
+    /*tex Was the callback successful? */
+    boolean res;
+    /*tex Was |tfm_file| successfully opened? */
+    boolean opened;
+    int callback_id;
+    FILE *tfm_file;
+    char *fname = luatex_find_file(nom, find_font_file_callback);
+    if (!fname)
+        return -1;
+    callback_id = callback_defined(read_font_file_callback);
+    if (callback_id > 0) {
+        res = run_callback(callback_id, "S->bSd", fname, &opened, tfm_buf, tfm_siz);
+        if (res && opened && (*tfm_siz > 0)) {
+            return 1;
+        }
+        if (!opened)
+            return -1;
+    } else {
+        if (luatex_open_input(&(tfm_file), fname, kpse_ofm_format, FOPEN_RBIN_MODE, true)) {
+            res = read_tfm_file(tfm_file, tfm_buf, tfm_siz);
+            close_file(tfm_file);
+            if (res) {
+                return 1;
+            }
+        } else {
+            return -1;
+        }
+    }
+    return 0;
+}
+
+/*tex
+
+  Note: A malformed \TFM\file might be shorter than it claims to be; thus
+  |eof(tfm_file)| might be true when |read_font_info| refers to |tfm_file^| or
+  when it says |get(tfm_file)|. If such circumstances cause system error
+  messages, you will have to defeat them somehow, for example by defining |fget|
+  to be `\ignorespaces|begin get(tfm_file);| |if eof(tfm_file) then abort;
+  end|'.
+
+*/
+
+#define fget  tfm_byte++
+#define fbyte tfm_buffer[tfm_byte]
+
+#define read_sixteen(a) {           \
+    a=tfm_buffer[tfm_byte++];       \
+    if (a>127) { tfm_abort; }       \
+    a=(a*256)+tfm_buffer[tfm_byte]; \
+}
+
+#define read_sixteen_unsigned(a) {  \
+    a=tfm_buffer[tfm_byte++];       \
+    a=(a*256)+tfm_buffer[tfm_byte]; \
+}
+
+#define read_thirtytwo(a) {           \
+    a=tfm_buffer[++tfm_byte];         \
+    if (a>127) { tfm_abort; }         \
+    a=(a*256)+tfm_buffer[++tfm_byte]; \
+    a=(a*256)+tfm_buffer[++tfm_byte]; \
+    a=(a*256)+tfm_buffer[++tfm_byte]; \
+}
+
+#define store_four_bytes(z) {         \
+    a=tfm_buffer[++tfm_byte];         \
+    a=(a*256)+tfm_buffer[++tfm_byte]; \
+    a=(a*256)+tfm_buffer[++tfm_byte]; \
+    a=(a*256)+tfm_buffer[++tfm_byte]; \
+    z = a;                            \
+}
+
+#define store_char_info(z) {            \
+    if (font_level!=-1) {               \
+        fget; read_sixteen_unsigned(a); \
+        ci._width_index=a;              \
+        fget; read_sixteen_unsigned(b); \
+        ci._height_index=b>>8;          \
+        ci._depth_index=b%256;          \
+        fget; read_sixteen_unsigned(c); \
+        ci._italic_index=c>>8;          \
+        ci._tag=(unsigned char)(c%4);   \
+        fget; read_sixteen_unsigned(d); \
+        ci._remainder=d;                \
+    } else {                            \
+          a=tfm_buffer[++tfm_byte];     \
+          ci._width_index=a;            \
+          b=tfm_buffer[++tfm_byte];     \
+          ci._height_index=b>>4;        \
+          ci._depth_index=b%16;         \
+          c=tfm_buffer[++tfm_byte];     \
+          ci._italic_index=c>>2;        \
+          ci._tag=(unsigned char)(c%4); \
+          d=tfm_buffer[++tfm_byte];     \
+          ci._remainder=d;              \
+    }                                   \
+}
+
+#define read_four_quarters(q) {                              \
+    if (font_level!=-1) {                                    \
+        fget; read_sixteen_unsigned(a); q.b0=(quarterword)a; \
+        fget; read_sixteen_unsigned(b); q.b1=(quarterword)b; \
+        fget; read_sixteen_unsigned(c); q.b2=(quarterword)c; \
+        fget; read_sixteen_unsigned(d); q.b3=(quarterword)d; \
+    } else {                                                 \
+          a=tfm_buffer[++tfm_byte]; q.b0=(quarterword)a;     \
+          b=tfm_buffer[++tfm_byte]; q.b1=(quarterword)b;     \
+          c=tfm_buffer[++tfm_byte]; q.b2=(quarterword)c;     \
+          d=tfm_buffer[++tfm_byte]; q.b3=(quarterword)d;     \
+    }                                                        \
+}
+
+#define check_byte_range(z) { if ((z<bc)||(z>ec)) tfm_abort ; }
+
+/*
+
+    A |fix_word| whose four bytes are $(a,b,c,d)$ from left to right represents
+    the number $$x=\left\{\vcenter{\halign{$#$,\hfil\qquad&if $#$\hfil\cr
+    b\cdot2^{-4}+c\cdot2^{-12}+d\cdot2^{-20}&a=0;\cr
+    -16+b\cdot2^{-4}+c\cdot2^{-12}+d\cdot2^{-20}&a=255.\cr}}\right.$$ (No other
+    choices of |a| are allowed, since the magnitude of a number in design-size
+    units must be less than 16.) We want to multiply this quantity by the
+    integer~|z|, which is known to be less than $2^{27}$. If $|z|<2^{23}$, the
+    individual multiplications $b\cdot z$, $c\cdot z$, $d\cdot z$ cannot
+    overflow; otherwise we will divide |z| by 2, 4, 8, or 16, to obtain a
+    multiplier less than $2^{23}$, and we can compensate for this later. If |z|
+    has thereby been replaced by $|z|^\prime=|z|/2^e$, let $\beta=2^{4-e}$; we
+    shall compute $$\lfloor (b + c \cdot2^{-8} + d \cdot2^{-16}) \, z^\prime /
+    \beta \rfloor$$ if $a=0$, or the same quantity minus $\alpha=2^{4+e}z^\prime$
+    if $a=255$. This calculation must be done exactly, in order to guarantee
+    portability of \TeX\ between computers.
+
+*/
+
+#define store_scaled(zz) {                       \
+    fget;                                        \
+    a = fbyte;                                   \
+    fget;                                        \
+    b = fbyte;                                   \
+    fget;                                        \
+    c = fbyte;                                   \
+    fget;                                        \
+    d = fbyte;                                   \
+    sw = (((((d*z)>>8)+(c*z))>>8)+(b*z)) / beta; \
+    if (a == 0) {                                \
+        zz = sw;                                 \
+    } else if (a == 255) {                       \
+        zz = sw-alpha;                           \
+    } else {                                     \
+        tfm_abort;                               \
+    }                                            \
+}
+
+scaled store_scaled_f(scaled sq, scaled z_in)
+{
+    eight_bits a, b, c, d;
+    scaled sw;
+    /*tex Here beta: runs from 1 upto 16 */
+    static int alpha, beta;
+    static scaled z, z_prev = 0;
+    /*tex Replace |z| by $|z|^\prime$ and compute $\alpha,\beta$ */
+    if (z_in != z_prev || z_prev == 0) {
+        z = z_prev = z_in;
+        alpha = 16;
+        while (z >= 0x800000) {
+            z /= 2;
+            alpha += alpha;
+        }
+        beta = 256 / alpha;
+        alpha *= z;
+    };
+    if (sq >= 0) {
+        d = (eight_bits) (sq % 256);
+        sq = sq / 256;
+        c = (eight_bits) (sq % 256);
+        sq = sq / 256;
+        b = (eight_bits) (sq % 256);
+        sq = sq / 256;
+        a = (eight_bits) (sq % 256);
+    } else {
+        sq = (sq + 1073741824) + 1073741824;
+        d = (eight_bits) (sq % 256);
+        sq = sq / 256;
+        c = (eight_bits) (sq % 256);
+        sq = sq / 256;
+        b = (eight_bits) (sq % 256);
+        sq = sq / 256;
+        a = (eight_bits) ((sq + 128) % 256);
+    }
+    if (beta==0)
+        normal_error("vf", "vf scaling");
+    sw = (((((d * z) >> 8) + (c * z)) >> 8) + (b * z)) / beta;
+    if (a == 0)
+        return sw;
+    else if (a == 255)
+        return (sw - alpha);
+    else
+        normal_error("vf", "vf scaling");
+    return sw;
+}
+
+#define check_existence(z) { \
+    check_byte_range(z);     \
+    if (!char_exists(f,z)) { \
+        tfm_abort;           \
+    }                        \
+}
+
+typedef struct tfmcharacterinfo {
+    int _kern_index;
+    int _lig_index;
+    int _width_index;
+    int _height_index;
+    int _depth_index;
+    int _italic_index;
+    int _remainder;
+    unsigned char _tag;
+} tfmcharacterinfo;
+
+int read_tfm_info(internal_font_number f, const char *cnom, scaled s)
+{
+    /*tex index into |font_info| */
+    int k;
+    /*tex sizes of subfiles */
+    halfword lf, lh, bc, ec, nw, nh, nd, ni, nl, nk, ne, np, slh;
+    scaled *widths, *heights, *depths, *italics, *kerns;
+    halfword font_dir;
+    /*tex byte variables */
+    int a, b, c=0, d=0;
+    /*tex counter */
+    int i;
+    int font_level, header_length;
+    int ncw, nlw, neew;
+    tfmcharacterinfo ci;
+    charinfo *co;
+    four_quarters qw;
+    four_quarters *lig_kerns, *extens;
+    /*tex accumulators */
+    scaled sw;
+    /*tex left boundary start location, or infinity */
+    int bch_label;
+    /*tex 0..too_big_char; right boundary character, or |too_big_char| */
+    int bchar;
+    int first_two;
+    /*tex the design size or the ``at'' size */
+    scaled z;
+    int alpha;
+    /*tex 1..16 */
+    char beta;
+    /*tex aux. for ligkern processing */
+    int *xligs, *xkerns;
+    liginfo *cligs;
+    kerninfo *ckerns;
+    int fligs, fkerns;
+    char *tmpnam;
+    /*tex index into |tfm_buffer| */
+    int tfm_byte = 0;
+    /*tex saved index into |tfm_buffer| */
+    int saved_tfm_byte = 0;
+    /*tex byte buffer for tfm files */
+    unsigned char *tfm_buffer = NULL;
+    /*tex total size of the tfm file */
+    int tfm_size = 0;
+    int tmp;
+    widths = NULL;
+    heights = NULL;
+    depths = NULL;
+    italics = NULL;
+    kerns = NULL;
+    lig_kerns = NULL;
+    extens = NULL;
+    xkerns = NULL;
+    ckerns = NULL;
+    xligs = NULL;
+    cligs = NULL;
+    font_dir = 0;
+    memset(&ci, 0, sizeof(tfmcharacterinfo));
+    if (open_tfm_file(cnom, &tfm_buffer, &tfm_size) != 1)
+        tfm_abort;
+    /*tex When |cnom| is an absolute filename |xbasename| fixes that. */
+    tmpnam = strdup(xbasename(cnom));
+    if (strcmp(tmpnam + strlen(tmpnam) - 4, ".tfm") == 0 || strcmp(tmpnam + strlen(tmpnam) - 4, ".ofm") == 0) {
+        *(tmpnam + strlen(tmpnam) - 4) = 0;
+    }
+    set_font_name(f, tmpnam);
+    set_font_area(f, NULL);
+    /*tex Read the \TFM\ size fields. */
+    ncw = 0;
+    read_sixteen(first_two);
+    if (first_two != 0) {
+        font_level = -1;
+        lf = first_two;
+        fget;
+        read_sixteen(lh);
+        fget;
+        read_sixteen(bc);
+        fget;
+        read_sixteen(ec);
+        if ((bc > ec + 1) || (ec > 255))
+            tfm_abort;
+        if (bc > 255) {
+            /*tex |bc=256| and |ec=255| */
+            bc = 1;
+            ec = 0;
+        };
+        fget;
+        read_sixteen(nw);
+        fget;
+        read_sixteen(nh);
+        fget;
+        read_sixteen(nd);
+        fget;
+        read_sixteen(ni);
+        fget;
+        read_sixteen(nl);
+        fget;
+        read_sixteen(nk);
+        fget;
+        read_sixteen(ne);
+        fget;
+        read_sixteen(np);
+        header_length = 6;
+        ncw = (ec - bc + 1);
+        nlw = nl;
+        neew = ne;
+    } else {
+        fget;
+        read_sixteen(font_level);
+        if (font_level != 0)
+            tfm_abort;
+        read_thirtytwo(lf);
+        read_thirtytwo(lh);
+        read_thirtytwo(bc);
+        read_thirtytwo(ec);
+        if ((bc > ec + 1) || (ec > 65535))
+            tfm_abort;
+        if (bc > 65535) {
+            /*tex |bc=65536| and |ec=65535| */
+            bc = 1;
+            ec = 0;
+        };
+        read_thirtytwo(nw);
+        read_thirtytwo(nh);
+        read_thirtytwo(nd);
+        read_thirtytwo(ni);
+        read_thirtytwo(nl);
+        read_thirtytwo(nk);
+        read_thirtytwo(ne);
+        read_thirtytwo(np);
+        /*tex Some junk: */
+        read_thirtytwo(font_dir);
+        nlw = 2 * nl;
+        neew = 2 * ne;
+        header_length = 14;
+        ncw = 2 * (ec - bc + 1);
+    };
+    if (lf !=
+        (header_length + lh + ncw + nw + nh + nd + ni + nlw + nk + neew + np))
+        tfm_abort;
+    if ((nw == 0) || (nh == 0) || (nd == 0) || (ni == 0))
+        tfm_abort;
+    /*tex
+        We check to see that the \TFM\ file doesn't end prematurely; but no
+        error message is given for files having more than |lf| words.
+     */
+    if (lf * 4 > tfm_size)
+        tfm_abort;
+    /*tex Use size fields to allocate font information. */
+    set_font_natural_dir(f, font_dir);
+    set_font_bc(f, bc);
+    set_font_ec(f, ec);
+    /*tex Read the arrays first. */
+    widths = xmalloc((unsigned) ((unsigned) nw * sizeof(scaled)));
+    heights = xmalloc((unsigned) ((unsigned) nh * sizeof(scaled)));
+    depths = xmalloc((unsigned) ((unsigned) nd * sizeof(scaled)));
+    italics = xmalloc((unsigned) ((unsigned) ni * sizeof(scaled)));
+    extens = xmalloc((unsigned) ((unsigned) ne * sizeof(four_quarters)));
+    lig_kerns = xmalloc((unsigned) ((unsigned) nl * sizeof(four_quarters)));
+    kerns = xmalloc((unsigned) ((unsigned) nk * sizeof(scaled)));
+    /*
+        Read the \TFM\ header. Only the first two words of the header are needed
+        by \TeX82.
+    */
+    slh = lh;
+    if (lh < 2)
+        tfm_abort;
+    store_four_bytes(tmp);
+    font_checksum(f) = (unsigned) tmp;
+    fget;
+    /*tex This rejects a negative design size. */
+    read_sixteen(z);
+    fget;
+    z = z * 256 + fbyte;
+    fget;
+    z = (z * 16) + (fbyte >> 4);
+    if (z < unity)
+        tfm_abort;
+    while (lh > 2) {
+        fget;
+        fget;
+        fget;
+        fget;
+        /*tex Ignore the rest of the header. */
+        lh--;
+    };
+    /*tex Read the arrays before the character info. */
+    set_font_dsize(f, z);
+    if (s != -1000) {
+        z = (s >= 0 ? s : xn_over_d(z, -s, 1000));
+    }
+    set_font_size(f, z);
+    if (np > 7) {
+        set_font_params(f, np);
+    }
+    saved_tfm_byte = tfm_byte;
+    tfm_byte = (header_length + slh + ncw) * 4 - 1;
+    /*tex Replace |z| by $|z|^\prime$ and compute $\alpha,\beta$ */
+    alpha = 16;
+    while (z >= 040000000) {
+        z = z >> 1;
+        alpha = alpha + alpha;
+    };
+    beta = (char) (256 / alpha);
+    /*tex |beta| cannot be zero. */
+    if (beta==0)
+       normal_error("vf", "vf reading");
+    alpha = alpha * z;
+    /*tex Read box dimensions. */
+    for (k = 0; k < nw; k++) {
+        store_scaled(sw);
+        widths[k] = sw;
+    }
+    /*tex |width[0]| must be zero */
+    if (widths[0] != 0)
+        tfm_abort;
+    for (k = 0; k < nh; k++) {
+        store_scaled(sw);
+        heights[k] = sw;
+    }
+    /*tex |height[0]| must be zero */
+    if (heights[0] != 0)
+        tfm_abort;
+    for (k = 0; k < nd; k++) {
+        store_scaled(sw);
+        depths[k] = sw;
+    }
+    /*tex |depth[0]| must be zero */
+    if (depths[0] != 0)
+        tfm_abort;
+    for (k = 0; k < ni; k++) {
+        store_scaled(sw);
+        italics[k] = sw;
+    }
+    /*tex |italic[0]| must be zero */
+    if (italics[0] != 0)
+        tfm_abort;
+    /*tex Read ligature and kern programs */
+    bch_label = nl;
+    bchar = 65536;
+    if (nl > 0) {
+        for (k = 0; k < nl; k++) {
+            read_four_quarters(qw);
+            lig_kerns[k] = qw;
+            if (a > 128) {
+                if (256 * c + d >= nl)
+                    tfm_abort;
+                if (a == 255 && k == 0)
+                    bchar = b;
+            } else {
+                if (c < 128) {
+                    /*tex Do nothing. */
+                } else if (256 * (c - 128) + d >= nk) {
+                    /*tex Check kern. */
+                    tfm_abort;
+                }
+                if ((a < 128) && (k - 0 + a + 1 >= nl))
+                    tfm_abort;
+            };
+        };
+        if (a == 255)
+            bch_label = 256 * c + d;
+    };
+    /*tex The actual kerns */
+    for (k = 0; k < nk; k++) {
+        store_scaled(sw);
+        kerns[k] = sw;
+    }
+    /*tex Read extensible character recipes */
+    for (k = 0; k < ne; k++) {
+        read_four_quarters(qw);
+        extens[k] = qw;
+    }
+    /*tex Read font parameters. */
+    if (np > 7) {
+        set_font_params(f, np);
+    }
+    for (k = 1; k <= np; k++) {
+        if (k == 1) {
+            /*tex The |slant| parameter is a pure number. */
+            fget;
+            sw = fbyte;
+            if (sw > 127)
+                sw = sw - 256;
+            fget;
+            sw = sw * 256 + fbyte;
+            fget;
+            sw = sw * 256 + fbyte;
+            fget;
+            sw = (sw * 16) + (fbyte >> 4);
+            set_font_param(f, k, sw);
+        } else {
+            store_scaled(font_param(f, k));
+        }
+    }
+    tfm_byte = saved_tfm_byte;
+    /*tex Fix up the left boundary character. */
+    fligs = 0;
+    fkerns = 0;
+    if (bch_label != nl) {
+        k = bch_label;
+        while (1) {
+            if (skip_byte(k) <= stop_flag) {
+                if (op_byte(k) >= kern_flag) {
+                    fkerns++;
+                } else {
+                    fligs++;
+                }
+            }
+            if (skip_byte(k) == 0) {
+                k++;
+            } else {
+                if (skip_byte(k) >= stop_flag)
+                    break;
+                k += skip_byte(k) + 1;
+            }
+        }
+    }
+    if (fkerns > 0 || fligs > 0) {
+        if (fligs > 0)
+            cligs = xcalloc((unsigned) (fligs + 1), sizeof(liginfo));
+        if (fkerns > 0)
+            ckerns = xcalloc((unsigned) (fkerns + 1), sizeof(kerninfo));
+        fligs = 0;
+        fkerns = 0;
+        k = bch_label;
+        while (1) {
+            if (skip_byte(k) <= stop_flag) {
+                if (op_byte(k) >= kern_flag) {
+                    set_kern_item(ckerns[fkerns], next_char(k), kerns[256 * (op_byte(k) - 128) + rem_byte(k)]);
+                    fkerns++;
+                } else {
+                    set_ligature_item(cligs[fligs], (char) (op_byte(k) * 2 + 1), next_char(k), rem_byte(k));
+                    fligs++;
+                }
+            }
+            if (skip_byte(k) == 0) {
+                k++;
+            } else {
+                if (skip_byte(k) >= stop_flag)
+                    break;
+                k += skip_byte(k) + 1;
+            }
+        }
+        if (fkerns > 0 || fligs > 0) {
+            co = get_charinfo(f, left_boundarychar);
+            if (fkerns > 0) {
+                set_kern_item(ckerns[fkerns], end_kern, 0);
+                fkerns++;
+                set_charinfo_kerns(co, ckerns);
+            }
+            if (fligs > 0) {
+                set_ligature_item(cligs[fligs], 0, end_ligature, 0);
+                fligs++;
+                set_charinfo_ligatures(co, cligs);
+            }
+            set_charinfo_remainder(co, 0);
+        }
+    }
+    /*tex Read character data. */
+    for (k = bc; k <= ec; k++) {
+        store_char_info(k);
+        if (ci._width_index == 0)
+            continue;
+        if (ci._width_index >= nw || ci._height_index >= nh ||
+            ci._depth_index >= nd || ci._italic_index >= ni)
+            tfm_abort;
+        d = ci._remainder;
+        switch (ci._tag) {
+        case lig_tag:
+            if (d >= nl)
+                tfm_abort;
+            break;
+        case ext_tag:
+            if (d >= ne)
+                tfm_abort;
+            break;
+        case list_tag:
+            /*tex
+
+                We want to make sure that there is no cycle of characters linked
+                together by |list_tag| entries, since such a cycle would get
+                \TEX\ into an endless loop. If such a cycle exists, the routine
+                here detects it when processing the largest character code in the
+                cycle.
+
+             */
+            check_byte_range(d);
+            while (d < k) {
+                /* |current_character == k| */
+                if (char_tag(f, d) != list_tag) {
+                    /*tex Not a cycle. */
+                    goto NOT_FOUND;
+                }
+                /*tex Goto the next character on the list. */
+                d = char_remainder(f, d);
+            };
+            if (d == k) {
+                /*tex Yes, there's a cycle! */
+                tfm_abort;
+            }
+          NOT_FOUND:
+            break;
+        }
+        /*tex Put it in the actual font. */
+        co = get_charinfo(f, k);
+        set_charinfo_index(co, k);
+        set_charinfo_tag(co, ci._tag);
+        if (ci._tag == ext_tag) {
+            /*tex top, bot, mid, rep */
+            set_charinfo_extensible(co,
+                extens[ci._remainder].b0,
+                extens[ci._remainder].b2,
+                extens[ci._remainder].b1,
+                extens[ci._remainder].b3);
+            set_charinfo_remainder(co, 0);
+        } else {
+            set_charinfo_remainder(co, ci._remainder);
+        }
+        set_charinfo_width(co, widths[ci._width_index]);
+        set_charinfo_height(co, heights[ci._height_index]);
+        set_charinfo_depth(co, depths[ci._depth_index]);
+        set_charinfo_italic(co, italics[ci._italic_index]);
+    };
+    /*tex We now know the number of ligatures and kerns. */
+    xligs = xcalloc((unsigned) (ec + 1), sizeof(int));
+    xkerns = xcalloc((unsigned) (ec + 1), sizeof(int));
+    for (i = bc; i <= ec; i++) {
+        if (char_tag(f, i) == lig_tag) {
+            k = lig_kern_start(f, i);
+            if (skip_byte(k) > stop_flag)
+                k = lig_kern_restart(k);
+            /*tex Now k is the start index. */
+            while (1) {
+                if (skip_byte(k) <= stop_flag) {
+                    if (op_byte(k) >= kern_flag) {
+                        xkerns[i]++;
+                        if (next_char(k) == bchar)
+                            xkerns[i]++;
+                    } else {
+                        xligs[i]++;
+                        if (next_char(k) == bchar)
+                            xligs[i]++;
+                    }
+                }
+                if (skip_byte(k) == 0) {
+                    k++;
+                } else {
+                    if (skip_byte(k) >= stop_flag)
+                        break;
+                    k += skip_byte(k) + 1;
+                }
+            }
+        }
+    }
+    cligs = NULL;
+    ckerns = NULL;
+    for (i = bc; i <= ec; i++) {
+        fligs = 0;
+        fkerns = 0;
+        if (char_tag(f, i) == lig_tag) {
+            k = lig_kern_start(f, i);
+            if (skip_byte(k) > stop_flag)
+                k = lig_kern_restart(k);
+            /*tex Now k is the start index. */
+            if (xligs[i] > 0)
+                cligs = xcalloc((unsigned) (xligs[i] + 1), sizeof(liginfo));
+            if (xkerns[i] > 0)
+                ckerns = xcalloc((unsigned) (xkerns[i] + 1), sizeof(kerninfo));
+            while (1) {
+                if (skip_byte(k) <= stop_flag) {
+                    if (op_byte(k) >= kern_flag) {
+                        if (next_char(k) == bchar) {
+                            set_kern_item(ckerns[fkerns], right_boundarychar, kerns[256 * (op_byte(k) - 128) + rem_byte(k)]);
+                            fkerns++;
+                        }
+                        set_kern_item(ckerns[fkerns], next_char(k), kerns[256 * (op_byte(k) - 128) + rem_byte(k)]);
+                        fkerns++;
+                    } else {    /* lig */
+                        if (next_char(k) == bchar) {
+                            set_ligature_item(cligs[fligs], (char) (op_byte(k) * 2 + 1), right_boundarychar, rem_byte(k));
+                            fligs++;
+                        }
+                        set_ligature_item(cligs[fligs], (char) (op_byte(k) * 2 + 1), next_char(k), rem_byte(k));
+                        fligs++;
+                    }
+                }
+                if (skip_byte(k) == 0) {
+                    k++;
+                } else {
+                    if (skip_byte(k) >= stop_flag)
+                        break;
+                    k += skip_byte(k) + 1;
+                }
+            }
+            if (fkerns > 0 || fligs > 0) {
+                co = get_charinfo(f, i);
+                if (fkerns > 0) {
+                    set_kern_item(ckerns[fkerns], end_kern, 0);
+                    fkerns++;
+                    set_charinfo_kerns(co, ckerns);
+                }
+                if (fligs > 0) {
+                    set_ligature_item(cligs[fligs], 0, end_ligature, 0);
+                    fligs++;
+                    set_charinfo_ligatures(co, cligs);
+                }
+                set_charinfo_remainder(co, 0);
+            }
+        }
+    }
+    /*tex
+
+        Now it's time to wrap it up, we have checked all the necessary things
+        about the \TFM\file, and all we need to do is put the finishing
+        touches on the data for the new font.
+
+    */
+    if (bchar != 65536) {
+        co = copy_charinfo(char_info(f, bchar));
+        set_right_boundary(f, co);
+    }
+    tfm_success;
+}
diff --git a/texk/web2c/luatexdir/font/tounicode.w b/texk/web2c/luatexdir/font/tounicode.c
similarity index 64%
rename from texk/web2c/luatexdir/font/tounicode.w
rename to texk/web2c/luatexdir/font/tounicode.c
index 441a10dd5..f0449aff9 100644
--- a/texk/web2c/luatexdir/font/tounicode.w
+++ b/texk/web2c/luatexdir/font/tounicode.c
@@ -1,41 +1,46 @@
-% tounicode.w
-%
-% Copyright 2006 Han The Thanh, <thanh@@pdftex.org>
-% Copyright 2006-2010 Taco Hoekwater <taco@@luatex.org>
-%
-% This file is part of LuaTeX.
-%
-% LuaTeX is free software; you can redistribute it and/or modify it under
-% the terms of the GNU General Public License as published by the Free
-% Software Foundation; either version 2 of the License, or (at your
-% option) any later version.
-%
-% LuaTeX is distributed in the hope that it will be useful, but WITHOUT
-% ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-% FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
-% License for more details.
-%
-% You should have received a copy of the GNU General Public License along
-% with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+/*
 
-@ @c
+Copyright 2006 Han The Thanh, <thanh@pdftex.org>
+Copyright 2006-2010 Taco Hoekwater <taco@luatex.org>
 
+This file is part of LuaTeX.
+
+LuaTeX is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 2 of the License, or (at your
+option) any later version.
+
+LuaTeX is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+License for more details.
+
+You should have received a copy of the GNU General Public License along
+with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+
+*/
 
 #include "ptexlib.h"
 
-@ @c
 #define isXdigit(c) (isdigit(c) || ('A' <= (c) && (c) <= 'F'))
-#define UNI_UNDEF          -1
-#define UNI_STRING         -2   /* string allocated by |def_tounicode()| */
-#define UNI_EXTRA_STRING   -3   /* string allocated by |set_glyph_unicode()| */
+
+/*tex
+
+    |UNIC_STRING| is a string allocated by |def_tounicode| while
+    |UNI_EXTRA_STRING| is one allocated by |set_glyph_unicode|.
+
+*/
+
+#define UNI_UNDEF        -1
+#define UNI_STRING       -2
+#define UNI_EXTRA_STRING -3
 
 static struct avl_table *glyph_unicode_tree = NULL;
 
 static int comp_glyph_unicode_entry(const void *pa, const void *pb, void *p)
 {
     (void) p;
-    return strcmp(((const glyph_unicode_entry *) pa)->name,
-                  ((const glyph_unicode_entry *) pb)->name);
+    return strcmp(((const glyph_unicode_entry *) pa)->name, ((const glyph_unicode_entry *) pb)->name);
 }
 
 static glyph_unicode_entry *new_glyph_unicode_entry(void)
@@ -54,7 +59,6 @@ static void destroy_glyph_unicode_entry(void *pa, void *pb)
     (void) pb;
     xfree(e->name);
     if (e->code == UNI_STRING) {
-        assert(e->unicode_seq != NULL);
         xfree(e->unicode_seq);
     }
 }
@@ -65,31 +69,34 @@ void glyph_unicode_free(void)
         avl_destroy(glyph_unicode_tree, destroy_glyph_unicode_entry);
 }
 
-@ @c
 void def_tounicode(str_number glyph, str_number unistr)
 {
     char buf[SMALL_BUF_SIZE], *p, *ph;
     char buf2[SMALL_BUF_SIZE], *q;
-    int valid_unistr;           /* 0: invalid; 1: unicode value; 2: string */
+    /*tex |0| is invalid, |1| an \UNICODE\ value and |2| a string */
+    int valid_unistr;
     int i, l;
     glyph_unicode_entry *gu, t;
     void **aa;
-
     p = makecstring(glyph);
     assert(strlen(p) < SMALL_BUF_SIZE);
     strcpy(buf, p);
     free(p);
     p = makecstring(unistr);
     ph = p;
+    /*tex Ignore leading spaces. */
     while (*p == ' ')
-        p++;                    /* ignore leading spaces */
+        p++;
     l = (int) strlen(p);
+    /*tex Ignore traling spaces. */
     while (l > 0 && p[l - 1] == ' ')
-        l--;                    /* ignore traling spaces */
-    valid_unistr = 1;           /* a unicode value is the most common case */
+        l--;
+    /*tex A \UNICODE\ value is the most common case. */
+    valid_unistr = 1;
     for (i = 0; i < l; i++) {
+        /*tex If a space occurs we treat this entry as a string. */
         if (p[i] == ' ')
-            valid_unistr = 2;   /* if a space occurs we treat this entry as a string */
+            valid_unistr = 2;
         else if (!isXdigit((unsigned char)p[i])) {
             valid_unistr = 0;
             break;
@@ -100,23 +107,21 @@ void def_tounicode(str_number glyph, str_number unistr)
         return;
     }
     if (glyph_unicode_tree == NULL) {
-        glyph_unicode_tree =
-            avl_create(comp_glyph_unicode_entry, NULL, &avl_xallocator);
-        assert(glyph_unicode_tree != NULL);
+        glyph_unicode_tree = avl_create(comp_glyph_unicode_entry, NULL, &avl_xallocator);
     }
     t.name = buf;
-    /* allow overriding existing entries */
+    /*tex Allow overriding existing entries. */
     if ((gu = (glyph_unicode_entry *) avl_find(glyph_unicode_tree, &t)) != NULL) {
         if (gu->code == UNI_STRING) {
-            assert(gu->unicode_seq != NULL);
             xfree(gu->unicode_seq);
         }
-    } else {                    /* make new entry */
+    } else {
+        /*tex Make a new entry. */
         gu = new_glyph_unicode_entry();
         gu->name = xstrdup(buf);
     }
-    if (valid_unistr == 2) {    /* a string with space(s) */
-        /* copy p to buf2, ignoring spaces */
+    if (valid_unistr == 2) {
+        /*tex A string can have space(s) that we ignore by copying |p| to |buf2|. */
         for (q = buf2; *p != 0; p++)
             if (*p != ' ')
                 *q++ = *p;
@@ -125,28 +130,24 @@ void def_tounicode(str_number glyph, str_number unistr)
         gu->unicode_seq = xstrdup(buf2);
     } else {
         i = sscanf(p, "%lX", &(gu->code));
-        assert(i == 1);
     }
     aa = avl_probe(glyph_unicode_tree, gu);
     assert(aa != NULL);
     free(ph);
 }
 
-
-@ @c
 static long check_unicode_value(char *s, boolean multiple_value)
 {
     int l = (int) strlen(s);
     int i;
-    long code = 0; /* anything that is not |UNI_UNDEF| will do */
-
+    /*tex Anything that is not |UNI_UNDEF| will do: */
+    long code = 0;
     if (l == 0)
         return UNI_UNDEF;
     if (multiple_value && l % 4 != 0)
         return UNI_UNDEF;
     if (!multiple_value && !(4 <= l && l <= 6))
         return UNI_UNDEF;
-
     for (i = 0; i < l; i++) {
         if (!isXdigit((unsigned char)s[i]))
             return UNI_UNDEF;
@@ -171,33 +172,33 @@ static long check_unicode_value(char *s, boolean multiple_value)
     return code;
 }
 
-@ This function set proper values to |*gp| based on |s|; in case it returns
- |gp->code == UNI_EXTRA_STRING| then the caller is responsible for freeing
- |gp->unicode_seq| too.
-@c
+/*
+
+    This function set proper values to |*gp| based on |s|; in case it returns
+    |gp->code == UNI_EXTRA_STRING| then the caller is responsible for freeing
+    |gp->unicode_seq| too.
+
+*/
+
 static void set_glyph_unicode(char *s, glyph_unicode_entry * gp)
 {
     char buf[SMALL_BUF_SIZE], buf2[SMALL_BUF_SIZE], *p;
     long code;
     boolean last_component;
     glyph_unicode_entry tmp, *ptmp;
-
-    /* skip dummy entries */
+    /*tex Skip dummy entries. */
     if (s == NULL || s == notdef)
         return;
-
-    /* strip everything after the first dot */
+    /*tex Strip everything after the first dot. */
     p = strchr(s, '.');
     if (p != NULL) {
         *buf = 0;
         strncat(buf, s, (size_t) (p - s));
         s = buf;
     }
-
     if (strlen(s) == 0)
         return;
-
-    /* check for case of multiple components separated by |'_'| */
+    /*tex Check for case of multiple components separated by |_|. */
     p = strchr(s, '_');
     if (p != NULL) {
         assert(strlen(s) < sizeof(buf));
@@ -213,20 +214,26 @@ static void set_glyph_unicode(char *s, glyph_unicode_entry * gp)
             tmp.code = UNI_UNDEF;
             set_glyph_unicode(s, &tmp);
             switch (tmp.code) {
-            case UNI_UNDEF:    /* not found, do nothing */
+            case UNI_UNDEF:
+                /*tex Not found, do nothing. */
                 break;
-            case UNI_STRING:   /* s matched an entry with string value in the database */
+            case UNI_STRING:
+                /*tex |s| matched an entry with string value in the database. */
                 assert(tmp.unicode_seq != NULL);
                 assert(strlen(buf2) + strlen(tmp.unicode_seq) < sizeof(buf2));
                 strcat(buf2, tmp.unicode_seq);
                 break;
-            case UNI_EXTRA_STRING:     /* s is a multiple value of form "uniXXXX" */
+            case UNI_EXTRA_STRING:
+                /*tex |s| is a multiple value of form "uniXXXX" */
                 assert(strlen(buf2) + strlen(tmp.unicode_seq) < sizeof(buf2));
                 strcat(buf2, tmp.unicode_seq);
                 xfree(tmp.unicode_seq);
                 break;
-            default:           /* s matched an entry with numeric value in the
-                                   database, or a value derived from "uXXXX" */
+            default:
+                /*tex
+                    |s| matched an entry with numeric value in the database, or a
+                    value derived from |uXXXX|.
+                */
                 assert(tmp.code >= 0);
                 strcat(buf2, utf16be_str(tmp.code));
             }
@@ -243,8 +250,7 @@ static void set_glyph_unicode(char *s, glyph_unicode_entry * gp)
         gp->unicode_seq = xstrdup(buf2);
         return;
     }
-
-    /* lookup for glyph name in the database */
+    /*tex Lookup glyph name in the database. */
     tmp.name = s;
     tmp.code = UNI_UNDEF;
     ptmp = (glyph_unicode_entry *) avl_find(glyph_unicode_tree, &tmp);
@@ -253,23 +259,24 @@ static void set_glyph_unicode(char *s, glyph_unicode_entry * gp)
         gp->unicode_seq = ptmp->unicode_seq;
         return;
     }
-
-    /* check for case of "uniXXXX" (multiple 4-hex-digit values allowed) */
+    /*tex Check for case of |uniXXXX|, multiple 4-hex-digit values allowed. */
     if (str_prefix(s, "uni")) {
         p = s + strlen("uni");
         code = check_unicode_value(p, true);
         if (code != UNI_UNDEF) {
-            if (strlen(p) == 4) /* single value */
+            if (strlen(p) == 4) {
+                /*tex Single value: */
                 gp->code = code;
-            else {              /* multiple value */
+            } else {
+                /*tex Multiple value: */
                 gp->code = UNI_EXTRA_STRING;
                 gp->unicode_seq = xstrdup(p);
             }
         }
-        return;                 /* since the last case cannot happen */
+        /*tex Since the last case cannot happen: */
+        return;
     }
-
-    /* check for case of "uXXXX" (single value up to 6 hex digits) */
+    /*tex Check for case of |uXXXX|, a single value up to 6 hex digits. */
     if (str_prefix(s, "u")) {
         p = s + strlen("u");
         code = check_unicode_value(p, false);
@@ -280,9 +287,7 @@ static void set_glyph_unicode(char *s, glyph_unicode_entry * gp)
     }
 }
 
-@ @c
-static void set_cid_glyph_unicode(long index, glyph_unicode_entry * gp,
-                                  internal_font_number f)
+static void set_cid_glyph_unicode(long index, glyph_unicode_entry * gp, internal_font_number f)
 {
     char *s;
     if (font_tounicode(f)) {
@@ -290,15 +295,14 @@ static void set_cid_glyph_unicode(long index, glyph_unicode_entry * gp,
             gp->code = UNI_EXTRA_STRING;
             gp->unicode_seq = xstrdup(s);
         } else {
-            /* no fallback as we're providing them ourselves */
+            /*tex No fall back as we're providing them ourselves. */
         }
     } else {
-        /* fallback */
+        /*tex Fall back. */
         gp->code = index;
     }
 }
 
-@ @c
 int write_tounicode(PDF pdf, char **glyph_names, char *name)
 {
     char buf[SMALL_BUF_SIZE], *p;
@@ -314,64 +318,75 @@ int write_tounicode(PDF pdf, char **glyph_names, char *name)
         return 0;
     }
     strcpy(buf, name);
-    if ((p = strrchr(buf, '.')) != NULL && strcmp(p, ".enc") == 0)
-        *p = 0;                 /* strip ".enc" from encoding name */
-    else
-        strcat(buf, builtin_suffix);    /* ".enc" not present, this is a builtin
-                                           encoding so the name is eg "cmr10-builtin" */
+    if ((p = strrchr(buf, '.')) != NULL && strcmp(p, ".enc") == 0) {
+        /*tex
+            Strip |.enc| from encoding name.
+        */
+        *p = 0;
+    } else {
+        /*
+            The suffix |.enc| is not present so this is a builtin encoding so the
+            name becomes e.g. |cmr10-builtin|.
+        */
+        strcat(buf, builtin_suffix);
+    }
     objnum = pdf_create_obj(pdf, obj_type_others, 0);
     pdf_begin_obj(pdf, objnum, OBJSTM_NEVER);
     pdf_begin_dict(pdf);
     pdf_dict_add_streaminfo(pdf);
     pdf_end_dict(pdf);
     pdf_begin_stream(pdf);
-    pdf_printf(pdf, "%%!PS-Adobe-3.0 Resource-CMap\n"@/
-               "%%%%DocumentNeededResources: ProcSet (CIDInit)\n"@/
-               "%%%%IncludeResource: ProcSet (CIDInit)\n"@/
-               "%%%%BeginResource: CMap (TeX-%s-0)\n"@/
-               "%%%%Title: (TeX-%s-0 TeX %s 0)\n"@/
-               "%%%%Version: 1.000\n"@/
-               "%%%%EndComments\n"@/
-               "/CIDInit /ProcSet findresource begin\n"@/
-               "12 dict begin\n"@/
-               "begincmap\n"@/
-               "/CIDSystemInfo\n"@/
-               "<< /Registry (TeX)\n"@/
-               "/Ordering (%s)\n"@/
-               "/Supplement 0\n"@/
-               ">> def\n"@/
-               "/CMapName /TeX-%s-0 def\n"@/
-               "/CMapType 2 def\n"@/
-               "1 begincodespacerange\n"@/
-               "<00> <FF>\n" "endcodespacerange\n", buf, buf, buf, buf, buf);
-
-    /* set gtab */
+    pdf_printf(pdf,
+        "%%!PS-Adobe-3.0 Resource-CMap\n"
+        "%%%%DocumentNeededResources: ProcSet (CIDInit)\n"
+        "%%%%IncludeResource: ProcSet (CIDInit)\n"
+        "%%%%BeginResource: CMap (TeX-%s-0)\n"
+        "%%%%Title: (TeX-%s-0 TeX %s 0)\n"
+        "%%%%Version: 1.000\n"
+        "%%%%EndComments\n"
+        "/CIDInit /ProcSet findresource begin\n"
+        "12 dict begin\n"
+        "begincmap\n"
+        "/CIDSystemInfo\n"
+        "<< /Registry (TeX)\n"
+        "/Ordering (%s)\n"
+        "/Supplement 0\n"
+        ">> def\n"
+        "/CMapName /TeX-%s-0 def\n"
+        "/CMapType 2 def\n"
+        "1 begincodespacerange\n"
+        "<00> <FF>\n" "endcodespacerange\n",
+        buf, buf, buf, buf, buf);
+    /*tex Set gtab: */
     for (i = 0; i < 256; ++i) {
         gtab[i].code = UNI_UNDEF;
         set_glyph_unicode(glyph_names[i], &gtab[i]);
     }
     gtab[256].code = UNI_UNDEF;
-
-    /* set |range_size| */
+    /*tex Set |range_size|: */
     for (i = 0; i < 256;) {
         if (gtab[i].code == UNI_STRING || gtab[i].code == UNI_EXTRA_STRING) {
-            range_size[i] = 1;  /* single entry */
+            /*tex Single entry: */
+            range_size[i] = 1;
             i++;
         } else if (gtab[i].code == UNI_UNDEF) {
-            range_size[i] = 0;  /* no entry */
+            /*tex No entry: */
+            range_size[i] = 0;
             i++;
-        } else {                /* gtab[i].code >= 0 */
+        } else {
+            /*tex |gtab[i].code >= 0| */
             j = i;
-            while (i < 256 && gtab[i + 1].code >= 0 &&
-                   gtab[i].code + 1 == gtab[i + 1].code)
+            while (i < 256 && gtab[i + 1].code >= 0 && gtab[i].code + 1 == gtab[i + 1].code)
                 i++;
-            /* at this point i is the last entry of the subrange */
-            i++;                /* move i to the next entry */
+            /*tex
+                At this point |i| is the last entry of the subrange so we move |i| to
+                the next entry.
+            */
+            i++;
             range_size[j] = (short) (i - j);
         }
     }
-
-    /* calculate |bfrange_count| and |bfchar_count| */
+    /*tex Calculate |bfrange_count| and |bfchar_count|. */
     bfrange_count = 0;
     bfchar_count = 0;
     for (i = 0; i < 256;) {
@@ -384,8 +399,7 @@ int write_tounicode(PDF pdf, char **glyph_names, char *name)
         } else
             i++;
     }
-
-    /* write out bfrange */
+    /*tex Write out |bfrange|. */
     i = 0;
   write_bfrange:
     if (bfrange_count > 100)
@@ -405,8 +419,7 @@ int write_tounicode(PDF pdf, char **glyph_names, char *name)
     pdf_printf(pdf, "endbfrange\n");
     if (bfrange_count > 0)
         goto write_bfrange;
-
-    /* write out bfchar */
+    /*tex Write out |bfchar|. */
     i = 0;
   write_bfchar:
     if (bfchar_count > 100)
@@ -421,7 +434,7 @@ int write_tounicode(PDF pdf, char **glyph_names, char *name)
                 i += range_size[i];
             else if (range_size[i] == 0)
                 i++;
-            else                /* |range_size[i] == 1| */
+            else
                 break;
         }
         assert(i < 256 && gtab[i].code != UNI_UNDEF);
@@ -435,66 +448,63 @@ int write_tounicode(PDF pdf, char **glyph_names, char *name)
     pdf_printf(pdf, "endbfchar\n");
     if (bfchar_count > 0)
         goto write_bfchar;
-
-    /* free strings allocated by |set_glyph_unicode()| */
+    /*tex Free strings allocated by |set_glyph_unicode|. */
     for (i = 0; i < 256; ++i) {
         if (gtab[i].code == UNI_EXTRA_STRING)
             xfree(gtab[i].unicode_seq);
     }
-
-    pdf_printf(pdf, "endcmap\n"
-               "CMapName currentdict /CMap defineresource pop\n"
-               "end\n" "end\n" "%%%%EndResource\n" "%%%%EOF\n");
+    pdf_printf(pdf,
+        "endcmap\n"
+        "CMapName currentdict /CMap defineresource pop\n"
+        "end\n"
+        "end\n"
+        "%%%%EndResource\n"
+        "%%%%EOF\n");
     pdf_end_stream(pdf);
     pdf_end_obj(pdf);
     return objnum;
 }
 
-@ @c
 int write_cid_tounicode(PDF pdf, fo_entry * fo, internal_font_number f)
 {
-
     static int range_size[65537];
     static glyph_unicode_entry gtab[65537];
     int objnum;
     int i, j, k;
     int bfchar_count, bfrange_count, subrange_count;
     char *buf;
-
-    assert(fo->fd->fontname);
     buf = xmalloc((unsigned) (strlen(fo->fd->fontname) + 8));
-    sprintf(buf, "%s-%s",
-            (fo->fd->subset_tag != NULL ? fo->fd->subset_tag : "UCS"),
-            fo->fd->fontname);
-
+    sprintf(buf, "%s-%s", (fo->fd->subset_tag != NULL ? fo->fd->subset_tag : "UCS"), fo->fd->fontname);
     objnum = pdf_create_obj(pdf, obj_type_others, 0);
     pdf_begin_obj(pdf, objnum, OBJSTM_NEVER);
     pdf_begin_dict(pdf);
     pdf_dict_add_streaminfo(pdf);
     pdf_end_dict(pdf);
     pdf_begin_stream(pdf);
-    pdf_printf(pdf, "%%!PS-Adobe-3.0 Resource-CMap\n"@/
-               "%%%%DocumentNeededResources: ProcSet (CIDInit)\n"@/
-               "%%%%IncludeResource: ProcSet (CIDInit)\n"@/
-               "%%%%BeginResource: CMap (TeX-%s-0)\n"@/
-               "%%%%Title: (TeX-%s-0 TeX %s 0)\n"@/
-               "%%%%Version: 1.000\n"@/
-               "%%%%EndComments\n"@/
-               "/CIDInit /ProcSet findresource begin\n"@/
-               "12 dict begin\n"@/
-               "begincmap\n"@/
-               "/CIDSystemInfo\n"@/
-               "<< /Registry (TeX)\n"@/
-               "/Ordering (%s)\n"@/
-               "/Supplement 0\n"@/
-               ">> def\n"@/
-               "/CMapName /TeX-Identity-%s def\n"@/
-               "/CMapType 2 def\n"@/
-               "1 begincodespacerange\n"@/
-               "<0000> <FFFF>\n"@/
-               "endcodespacerange\n", buf, buf, buf, buf, buf);
+    pdf_printf(pdf,
+        "%%!PS-Adobe-3.0 Resource-CMap\n"
+        "%%%%DocumentNeededResources: ProcSet (CIDInit)\n"
+        "%%%%IncludeResource: ProcSet (CIDInit)\n"
+        "%%%%BeginResource: CMap (TeX-%s-0)\n"
+        "%%%%Title: (TeX-%s-0 TeX %s 0)\n"
+        "%%%%Version: 1.000\n"
+        "%%%%EndComments\n"
+        "/CIDInit /ProcSet findresource begin\n"
+        "12 dict begin\n"
+        "begincmap\n"
+        "/CIDSystemInfo\n"
+        "<< /Registry (TeX)\n"
+        "/Ordering (%s)\n"
+        "/Supplement 0\n"
+        ">> def\n"
+        "/CMapName /TeX-Identity-%s def\n"
+        "/CMapType 2 def\n"
+        "1 begincodespacerange\n"
+        "<0000> <FFFF>\n"
+        "endcodespacerange\n",
+        buf, buf, buf, buf, buf);
     xfree(buf);
-    /* set up gtab */
+    /*tex Set up |gtab|: */
     for (i = 0; i < 65537; ++i) {
         gtab[i].code = UNI_UNDEF;
     }
@@ -510,29 +520,33 @@ int write_cid_tounicode(PDF pdf, fo_entry * fo, internal_font_number f)
             }
         }
     }
-
-    /* set |range_size| */
+    /*tex Set |range_size|: */
     for (i = 0; i < 65536;) {
         if (gtab[i].code == UNI_STRING || gtab[i].code == UNI_EXTRA_STRING) {
-            range_size[i] = 1;  /* single entry */
+            /*tex Single entry. */
+            range_size[i] = 1;
             i++;
         } else if (gtab[i].code == UNI_UNDEF) {
-            range_size[i] = 0;  /* no entry */
+            /*tex No entry. */
+            range_size[i] = 0;
             i++;
-        } else {                /* |gtab[i].code >= 0| */
+        } else {
+            /*tex |gtab[i].code >= 0| */
             j = i;
             k = i % 256;
             while (i < 65536 && k<255 && gtab[i + 1].code >= 0 &&
                    gtab[i].code + 1 == gtab[i + 1].code) {
                 i++; k++;
             }
-            /* at this point i is the last entry of the subrange */
-            i++;                /* move i to the next entry */
+            /* tex
+                At this point |i| is the last entry of the subrange so we move
+                |i| to the next entry
+            */
+            i++;
             range_size[j] = i - j;
         }
     }
-
-    /* calculate |bfrange_count| and |bfchar_count| */
+    /*tex Calculate |bfrange_count| and |bfchar_count|. */
     bfrange_count = 0;
     bfchar_count = 0;
     for (i = 0; i < 65536;) {
@@ -545,8 +559,7 @@ int write_cid_tounicode(PDF pdf, fo_entry * fo, internal_font_number f)
         } else
             i++;
     }
-
-    /* write out bfrange */
+    /*tex Write out |bfrange|. */
     i = 0;
   write_bfrange:
     if (bfrange_count > 100)
@@ -558,16 +571,13 @@ int write_cid_tounicode(PDF pdf, fo_entry * fo, internal_font_number f)
     for (j = 0; j < subrange_count; j++) {
         while (range_size[i] <= 1 && i < 65536)
             i++;
-        assert(i < 65536);
-        pdf_printf(pdf, "<%04X> <%04X> <%s>\n", i, i + range_size[i] - 1,
-                   utf16be_str(gtab[i].code));
+        pdf_printf(pdf, "<%04X> <%04X> <%s>\n", i, i + range_size[i] - 1, utf16be_str(gtab[i].code));
         i += range_size[i];
     }
     pdf_printf(pdf, "endbfrange\n");
     if (bfrange_count > 0)
         goto write_bfrange;
-
-    /* write out bfchar */
+    /*tex Write out |bfchar| */
     i = 0;
   write_bfchar:
     if (bfchar_count > 100)
@@ -582,12 +592,12 @@ int write_cid_tounicode(PDF pdf, fo_entry * fo, internal_font_number f)
                 i += range_size[i];
             else if (range_size[i] == 0)
                 i++;
-            else                /* |range_size[i] == 1| */
+            else
+                /* |range_size[i] == 1| */
                 break;
         }
         assert(i < 65536 && gtab[i].code != UNI_UNDEF);
         if (gtab[i].code == UNI_STRING || gtab[i].code == UNI_EXTRA_STRING) {
-            assert(gtab[i].unicode_seq != NULL);
             pdf_printf(pdf, "<%04X> <%s>\n", i, gtab[i].unicode_seq);
         } else
             pdf_printf(pdf, "<%04X> <%s>\n", i, utf16be_str(gtab[i].code));
@@ -596,16 +606,18 @@ int write_cid_tounicode(PDF pdf, fo_entry * fo, internal_font_number f)
     pdf_printf(pdf, "endbfchar\n");
     if (bfchar_count > 0)
         goto write_bfchar;
-
-    /* free strings allocated by |set_glyph_unicode()| */
+    /*tex Free strings allocated by |set_glyph_unicode|: */
     for (i = 0; i < 65536; ++i) {
         if (gtab[i].code == UNI_EXTRA_STRING)
             xfree(gtab[i].unicode_seq);
     }
-
-    pdf_printf(pdf, "endcmap\n"
-               "CMapName currentdict /CMap defineresource pop\n"
-               "end\n" "end\n" "%%%%EndResource\n" "%%%%EOF\n");
+    pdf_printf(pdf,
+        "endcmap\n"
+        "CMapName currentdict /CMap defineresource pop\n"
+        "end\n"
+        "end\n"
+        "%%%%EndResource\n"
+        "%%%%EOF\n");
     pdf_end_stream(pdf);
     pdf_end_obj(pdf);
     return objnum;
diff --git a/texk/web2c/luatexdir/font/tt_glyf.w b/texk/web2c/luatexdir/font/tt_glyf.c
similarity index 76%
rename from texk/web2c/luatexdir/font/tt_glyf.w
rename to texk/web2c/luatexdir/font/tt_glyf.c
index c0f17e5ab..750e126aa 100644
--- a/texk/web2c/luatexdir/font/tt_glyf.w
+++ b/texk/web2c/luatexdir/font/tt_glyf.c
@@ -1,28 +1,25 @@
-% tt_glyf.w
-%
-% Copyright 2002 by Jin-Hwan Cho and Shunsaku Hirata,
-% the dvipdfmx project team <dvipdfmx@@project.ktug.or.kr>
-% Copyright 2006-2012 Taco Hoekwater <taco@@luatex.org>
-%
-% This file is part of LuaTeX.
-%
-% LuaTeX is free software; you can redistribute it and/or modify it under
-% the terms of the GNU General Public License as published by the Free
-% Software Foundation; either version 2 of the License, or (at your
-% option) any later version.
-%
-% LuaTeX is distributed in the hope that it will be useful, but WITHOUT
-% ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-% FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
-% License for more details.
-%
-% You should have received a copy of the GNU General Public License along
-% with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+/*
 
-@* Subsetting glyf, updating loca, hmtx, etc.
+Copyright 2002 by Jin-Hwan Cho and Shunsaku Hirata,
+the dvipdfmx project team <dvipdfmx@project.ktug.or.kr>
+Copyright 2006-2012 Taco Hoekwater <taco@luatex.org>
 
-@ @c
+This file is part of LuaTeX.
 
+LuaTeX is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 2 of the License, or (at your
+option) any later version.
+
+LuaTeX is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+License for more details.
+
+You should have received a copy of the GNU General Public License along
+with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+
+*/
 
 #include "ptexlib.h"
 
@@ -31,7 +28,6 @@
 #include "font/tt_glyf.h"
 #include "font/writettf.h"
 
-@ @c
 #define NUM_GLYPH_LIMIT        65534
 #define TABLE_DATA_ALLOC_SIZE  40960
 #define GLYPH_ARRAY_ALLOC_SIZE 256
@@ -39,55 +35,41 @@
 static USHORT find_empty_slot(struct tt_glyphs *g)
 {
     USHORT gid;
-
-    ASSERT(g);
-
     for (gid = 0; gid < NUM_GLYPH_LIMIT; gid++) {
         if (!(g->used_slot[gid / 8] & (1 << (7 - (gid % 8)))))
             break;
     }
     if (gid == NUM_GLYPH_LIMIT)
         normal_error("ttf","no empty glyph slot available.");
-
     return gid;
 }
 
 USHORT tt_find_glyph(struct tt_glyphs * g, USHORT gid)
 {
     USHORT idx, new_gid = 0;
-
-    ASSERT(g);
-
     for (idx = 0; idx < g->num_glyphs; idx++) {
         if (gid == g->gd[idx].ogid) {
             new_gid = g->gd[idx].gid;
             break;
         }
     }
-
     return new_gid;
 }
 
 USHORT tt_get_index(struct tt_glyphs * g, USHORT gid)
 {
     USHORT idx;
-
-    ASSERT(g);
-
     for (idx = 0; idx < g->num_glyphs; idx++) {
         if (gid == g->gd[idx].gid)
             break;
     }
     if (idx == g->num_glyphs)
         idx = 0;
-
     return idx;
 }
 
 USHORT tt_add_glyph(struct tt_glyphs * g, USHORT gid, USHORT new_gid)
 {
-    ASSERT(g);
-
     if (g->used_slot[new_gid / 8] & (1 << (7 - (new_gid % 8)))) {
         formatted_warning("ttf","slot %u already used", new_gid);
     } else {
@@ -102,28 +84,21 @@ USHORT tt_add_glyph(struct tt_glyphs * g, USHORT gid, USHORT new_gid)
         g->gd[g->num_glyphs].ogid = gid;
         g->gd[g->num_glyphs].length = 0;
         g->gd[g->num_glyphs].data = NULL;
-        g->used_slot[new_gid / 8] =
-            (unsigned char) (g->used_slot[new_gid /
-                                          8] | (1 << (7 - (new_gid % 8))));
+        g->used_slot[new_gid / 8] = (unsigned char) (g->used_slot[new_gid / 8] | (1 << (7 - (new_gid % 8))));
         g->num_glyphs++;
     }
-
     if (new_gid > g->last_gid) {
         g->last_gid = new_gid;
     }
-
     return new_gid;
 }
 
+/*tex Initialization */
 
-@ Initialization
-@c
 struct tt_glyphs *tt_build_init(void)
 {
     struct tt_glyphs *g;
-
     g = NEW(1, struct tt_glyphs);
-
     g->num_glyphs = 0;
     g->max_glyphs = 0;
     g->last_gid = 0;
@@ -134,7 +109,6 @@ struct tt_glyphs *tt_build_init(void)
     g->used_slot = NEW(8192, unsigned char);
     memset(g->used_slot, 0, 8192);
     tt_add_glyph(g, 0, 0);
-
     return g;
 }
 
@@ -159,37 +133,33 @@ static int glyf_cmp(const void *v1, const void *v2)
 {
     int cmp = 0;
     const struct tt_glyph_desc *sv1, *sv2;
-
     sv1 = (const struct tt_glyph_desc *) v1;
     sv2 = (const struct tt_glyph_desc *) v2;
-
     if (sv1->gid == sv2->gid)
         cmp = 0;
     else if (sv1->gid < sv2->gid)
         cmp = -1;
     else
         cmp = 1;
-
     return cmp;
 }
 
-@ @c
 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, glyf_table_used;
-    /* some information available from other TrueType table */
+    /*tex Some information available from other \TRUETYPE\ table. */
     struct tt_head_table *head = NULL;
     struct tt_hhea_table *hhea = NULL;
     struct tt_maxp_table *maxp = NULL;
     struct tt_longMetrics *hmtx, *vmtx = NULL;
     struct tt_os2__table *os2;
-    /* temp */
+    /*tex Something temporary: */
     ULONG *location, offset;
     long i;
-    USHORT *w_stat;             /* Estimate most frequently appeared width */
-
+    /*tex Estimate the most frequently appeared width. */
+    USHORT *w_stat;
     int tex_font = fd->tex_font;
     int streamprovider = 0;
     int callback_id = 0 ;
@@ -197,60 +167,35 @@ int tt_build_tables(sfnt * sfont, struct tt_glyphs *g, fd_entry * fd)
         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)
         normal_error("ttf","invalid font type");
-
     if (g->num_glyphs > NUM_GLYPH_LIMIT)
         normal_error("ttf","too many glyphs");
-
-    /*
-     Read head, hhea, maxp, loca:
-
-     unitsPerEm       --> head
-
-     numHMetrics      --> hhea
-
-     indexToLocFormat --> head
-
-     numGlyphs        --> maxp
-     */
     head = tt_read_head_table(sfont);
     hhea = tt_read_hhea_table(sfont);
     maxp = tt_read_maxp_table(sfont);
-
     if (hhea->metricDataFormat != 0)
         normal_error("ttf","unknown metricDataFormat");
-
     g->emsize = head->unitsPerEm;
-
     sfnt_locate_table(sfont, "hmtx");
     hmtx = tt_read_longMetrics(sfont, maxp->numGlyphs, hhea->numberOfHMetrics);
-
     os2 = tt_read_os2__table(sfont);
     if (os2) {
         g->default_advh = (USHORT) (os2->sTypoAscender - os2->sTypoDescender);
         g->default_tsb = (SHORT) (g->default_advh - os2->sTypoAscender);
-
-        /* dvipdfmx does this elsewhere! */
+        /*tex |dvipdfmx| does this elsewhere! */
         fd_cur->font_dim[STEMV_CODE].val =
             (os2->usWeightClass / 65) * (os2->usWeightClass / 65) + 50;
     }
-
     if (sfnt_find_table_pos(sfont, "vmtx") > 0) {
         struct tt_vhea_table *vhea;
         vhea = tt_read_vhea_table(sfont);
         sfnt_locate_table(sfont, "vmtx");
-        vmtx =
-            tt_read_longMetrics(sfont, maxp->numGlyphs,
-                                vhea->numOfLongVerMetrics);
+        vmtx = tt_read_longMetrics(sfont, maxp->numGlyphs, vhea->numOfLongVerMetrics);
         RELEASE(vhea);
     } else {
         vmtx = NULL;
     }
-
     sfnt_locate_table(sfont, "loca");
     location = NEW(maxp->numGlyphs + 1, ULONG);
     if (head->indexToLocFormat == 0) {
@@ -262,34 +207,27 @@ int tt_build_tables(sfnt * sfont, struct tt_glyphs *g, fd_entry * fd)
     } else {
         normal_error("ttf","unknown IndexToLocFormat");
     }
-
     w_stat = NEW(g->emsize + 2, USHORT);
-    memset(w_stat, 0,
-           (size_t) (sizeof(USHORT) * ((long unsigned) g->emsize + 2)));
-    /*
-     * Read glyf table.
-     */
+    memset(w_stat, 0, (size_t) (sizeof(USHORT) * ((long unsigned) g->emsize + 2)));
     offset = sfnt_locate_table(sfont, "glyf");
-    /*
-     The |num_glyphs| may grow when composite glyph is found.
-     A component of glyph refered by a composite glyph is appended
-     to |used_glyphs| if it is not already registered in |used_glyphs|.
-     Glyph programs of composite glyphs are modified so that it
-     correctly refer to new gid of their components.
-     */
+    /*tex
+
+        The |num_glyphs| may grow when composite glyph is found. A component of
+        glyph refered by a composite glyph is appended to |used_glyphs| if it is
+        not already registered in |used_glyphs|. Glyph programs of composite
+        glyphs are modified so that it correctly refer to new gid of their
+        components.
+    */
     for (i = 0; i < NUM_GLYPH_LIMIT; i++) {
-        USHORT gid;             /* old gid */
+        USHORT gid;
         ULONG loc, len;
         BYTE *p, *endptr;
         SHORT number_of_contours;
-
-        if (i >= g->num_glyphs) /* finished */
+        if (i >= g->num_glyphs)
             break;
-
         gid = g->gd[i].ogid;
         if (gid >= maxp->numGlyphs)
             formatted_error("ttf","invalid glyph index (gid %u)", gid);
-
         loc = location[gid];
         len = location[gid + 1] - loc;
         g->gd[i].advw = hmtx[gid].advance;
@@ -306,52 +244,43 @@ int tt_build_tables(sfnt * sfont, struct tt_glyphs *g, fd_entry * fd)
         if (g->gd[i].advw <= g->emsize) {
             w_stat[g->gd[i].advw]++;
         } else {
-            w_stat[g->emsize + 1]++;    /* larger than em */
+            /*tex It's larger than em. */
+            w_stat[g->emsize + 1]++;
         }
 
-        if (len == 0) {         /* Does not contains any data. */
+        if (len == 0) {
+            /*tex Does not contain any data. */
             continue;
         } else if (len < 10) {
             formatted_error("ttf","invalid glyph data (gid %u)", gid);
         }
-
-/* todo: no need for this */
+        /*tex There is no real need for this. */
         g->gd[i].data = p = NEW(len, BYTE);
         endptr = p + len;
-
         sfnt_seek_set(sfont, (long) (offset + loc));
         number_of_contours = sfnt_get_short(sfont);
         p += sfnt_put_short(p, number_of_contours);
-
         /* BoundingBox: FWord x 4 */
         g->gd[i].llx = sfnt_get_short(sfont);
         g->gd[i].lly = sfnt_get_short(sfont);
         g->gd[i].urx = sfnt_get_short(sfont);
         g->gd[i].ury = sfnt_get_short(sfont);
-        /* |_FIXME_| */
-#if  1
-        if (!vmtx)              /* |vertOriginY == sTypeAscender| */
-            g->gd[i].tsb =
-                (SHORT) (g->default_advh - g->default_tsb - g->gd[i].ury);
-#endif
+        if (!vmtx) {
+            /*tex A fix: |vertOriginY == sTypeAscender| */
+            g->gd[i].tsb = (SHORT) (g->default_advh - g->default_tsb - g->gd[i].ury);
+        }
         p += sfnt_put_short(p, g->gd[i].llx);
         p += sfnt_put_short(p, g->gd[i].lly);
         p += sfnt_put_short(p, g->gd[i].urx);
         p += sfnt_put_short(p, g->gd[i].ury);
-
-        /* Read evrything else. */
+        /*tex Read evrything else. */
         sfnt_read(p, (int) len - 10, sfont);
-        /*
-         Fix GIDs of composite glyphs.
-         */
+        /*tex Fix GIDs of composite glyphs. */
         if (number_of_contours < 0) {
-            USHORT flags, cgid, new_gid;        /* flag, gid of a component */
+            USHORT flags, cgid, new_gid;
             do {
                 if (p >= endptr)
                     formatted_error("ttf","invalid glyph data (gid %u): %u bytes", gid, (unsigned int) len);
-                /*
-                 * Flags and gid of component glyph are both USHORT.
-                 */
                 flags = (USHORT) (((*p) << 8) | *(p + 1));
                 p += 2;
                 cgid = (USHORT) (((*p) << 8) | *(p + 1));
@@ -363,34 +292,38 @@ int tt_build_tables(sfnt * sfont, struct tt_glyphs *g, fd_entry * fd)
                     new_gid = tt_add_glyph(g, cgid, find_empty_slot(g));
                 }
                 p += sfnt_put_ushort(p, new_gid);
-                /*
-                 * Just skip remaining part.
-                 */
+                /*tex Just skip remaining part. */
                 p += (flags & ARG_1_AND_2_ARE_WORDS) ? 4 : 2;
-                if (flags & WE_HAVE_A_SCALE)    /* F2Dot14 */
+                if (flags & WE_HAVE_A_SCALE) {
+                    /*tex |F2Dot14| */
                     p += 2;
-                else if (flags & WE_HAVE_AN_X_AND_Y_SCALE)      /* F2Dot14 x 2 */
+                } else if (flags & WE_HAVE_AN_X_AND_Y_SCALE) {
+                    /*tex two times |F2Dot14| */
                     p += 4;
-                else if (flags & WE_HAVE_A_TWO_BY_TWO)  /* F2Dot14 x 4 */
+                } else if (flags & WE_HAVE_A_TWO_BY_TWO) {
+                    /*tex four times |F2Dot14| */
                     p += 8;
+                }
             } while (flags & MORE_COMPONENTS);
-            /*
-             TrueType instructions comes here:
+            /*tex
+
+                TrueType instructions comes here. The call pattern is:
 
-             |length_of_instruction| (|ushort|)
+                \starttyping
+                |length_of_instruction| (|ushort|)
+                instruction (|byte * length_of_instruction|)
+                \stoptyping
 
-             instruction (|byte * length_of_instruction|)
              */
         }
     }
     RELEASE(location);
     RELEASE(hmtx);
-    if (vmtx)
+    if (vmtx) {
         RELEASE(vmtx);
-
+    }
     {
         int max_count = -1;
-
         g->dw = g->gd[0].advw;
         for (i = 0; i < g->emsize + 1; i++) {
             if (w_stat[i] > max_count) {
@@ -400,13 +333,11 @@ int tt_build_tables(sfnt * sfont, struct tt_glyphs *g, fd_entry * fd)
         }
     }
     RELEASE(w_stat);
-
     qsort(g->gd, g->num_glyphs, sizeof(struct tt_glyph_desc), glyf_cmp);
     {
         USHORT prev, last_advw;
         char *p, *q;
         int padlen, num_hm_known;
-
         glyf_table_size = 0UL;
         num_hm_known = 0;
         last_advw = g->gd[g->num_glyphs - 1].advw;
@@ -419,17 +350,17 @@ int tt_build_tables(sfnt * sfont, struct tt_glyphs *g, fd_entry * fd)
                 num_hm_known = 1;
             }
         }
-        /* All advance widths are same. */
+        /*tex All advance widths are the same. */
         if (!num_hm_known) {
             hhea->numberOfHMetrics = 1;
         }
-        hmtx_table_size =
-            (ULONG) (hhea->numberOfHMetrics * 2 + (g->last_gid + 1) * 2);
+        hmtx_table_size = (ULONG) (hhea->numberOfHMetrics * 2 + (g->last_gid + 1) * 2);
+        /*tex
+
+            Choosing short format does not always give good result when
+            compressed. Sometimes increases size.
 
-        /*
-         Choosing short format does not always give good result
-         when compressed. Sometimes increases size.
-         */
+        */
         if (glyf_table_size < 0x20000UL) {
             head->indexToLocFormat = 0;
             loca_table_size = (ULONG) ((g->last_gid + 2) * 2);
@@ -437,12 +368,10 @@ int tt_build_tables(sfnt * sfont, struct tt_glyphs *g, fd_entry * fd)
             head->indexToLocFormat = 1;
             loca_table_size = (ULONG) ((g->last_gid + 2) * 4);
         }
-
         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;
         for (i = 0; i < g->num_glyphs; i++) {
@@ -470,12 +399,10 @@ int tt_build_tables(sfnt * sfont, struct tt_glyphs *g, fd_entry * fd)
             } else {
                 q += sfnt_put_ulong(q, (LONG) offset);
             }
-
             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 */
+                run_callback(callback_id, "ddd->L", tex_font, g->gd[i].gid, streamprovider, &result);
                 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) {
@@ -487,18 +414,15 @@ int tt_build_tables(sfnt * sfont, struct tt_glyphs *g, fd_entry * fd)
                 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 */
+            /*tex We free data here since it consume much memory. */
             g->gd[i].length = 0;
             g->gd[i].data = NULL;
         }
@@ -507,7 +431,6 @@ int tt_build_tables(sfnt * sfont, struct tt_glyphs *g, fd_entry * fd)
         } else {
             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);
         if (callback_id > 0) {
@@ -515,20 +438,17 @@ int tt_build_tables(sfnt * sfont, struct tt_glyphs *g, fd_entry * fd)
         }
         sfnt_set_table(sfont, "glyf", (char *) glyf_table_data, glyf_table_size);
     }
-
     head->checkSumAdjustment = 0;
     maxp->numGlyphs = (USHORT) (g->last_gid + 1);
-
-    /* TODO */
     sfnt_set_table(sfont, "maxp", tt_pack_maxp_table(maxp), TT_MAXP_TABLE_SIZE);
     sfnt_set_table(sfont, "hhea", tt_pack_hhea_table(hhea), TT_HHEA_TABLE_SIZE);
     sfnt_set_table(sfont, "head", tt_pack_head_table(head), TT_HEAD_TABLE_SIZE);
     RELEASE(maxp);
     RELEASE(hhea);
     RELEASE(head);
-    if (os2)
+    if (os2) {
         RELEASE(os2);
-
+    }
     return 0;
 }
 
@@ -539,66 +459,33 @@ int tt_get_metrics(sfnt * sfont, struct tt_glyphs *g)
     struct tt_maxp_table *maxp = NULL;
     struct tt_longMetrics *hmtx, *vmtx = NULL;
     struct tt_os2__table *os2;
-    /* temp */
     ULONG *location, offset;
     long i;
     USHORT *w_stat;
-
-    ASSERT(g);
-
-    if (sfont == NULL ||
-#ifdef XETEX
-        sfont->ft_face == NULL
-#elif defined(pdfTeX)
-        sfont->buffer == NULL
-#else
-        sfont->stream == NULL
-#endif
-        )
+    if (sfont == NULL || sfont->buffer == NULL)
         normal_error("ttf","file not opened");
-
     if (sfont->type != SFNT_TYPE_TRUETYPE && sfont->type != SFNT_TYPE_TTC)
         normal_error("ttf","invalid font type");
-
-    /*
-     Read head, hhea, maxp, loca:
-
-     unitsPerEm       --> head
-
-     numHMetrics      --> hhea
-
-     indexToLocFormat --> head
-
-     numGlyphs        --> maxp
-     */
     head = tt_read_head_table(sfont);
     hhea = tt_read_hhea_table(sfont);
     maxp = tt_read_maxp_table(sfont);
-
     if (hhea->metricDataFormat != 0)
         normal_error("ttf","unknown metricDataFormat");
-
     g->emsize = head->unitsPerEm;
-
     sfnt_locate_table(sfont, "hmtx");
     hmtx = tt_read_longMetrics(sfont, maxp->numGlyphs, hhea->numberOfHMetrics);
-
     os2 = tt_read_os2__table(sfont);
     g->default_advh = (USHORT) (os2->sTypoAscender - os2->sTypoDescender);
     g->default_tsb = (SHORT) (g->default_advh - os2->sTypoAscender);
-
     if (sfnt_find_table_pos(sfont, "vmtx") > 0) {
         struct tt_vhea_table *vhea;
         vhea = tt_read_vhea_table(sfont);
         sfnt_locate_table(sfont, "vmtx");
-        vmtx =
-            tt_read_longMetrics(sfont, maxp->numGlyphs,
-                                vhea->numOfLongVerMetrics);
+        vmtx = tt_read_longMetrics(sfont, maxp->numGlyphs, vhea->numOfLongVerMetrics);
         RELEASE(vhea);
     } else {
         vmtx = NULL;
     }
-
     sfnt_locate_table(sfont, "loca");
     location = NEW(maxp->numGlyphs + 1, ULONG);
     if (head->indexToLocFormat == 0) {
@@ -610,22 +497,16 @@ int tt_get_metrics(sfnt * sfont, struct tt_glyphs *g)
     } else {
         normal_error("ttf","inknown IndexToLocFormat");
     }
-
     w_stat = NEW(g->emsize + 2, USHORT);
     memset(w_stat, 0, (size_t) ((int) sizeof(USHORT) * (g->emsize + 2)));
-    /*
-     Read glyf table.
-     */
+    /*tex Read glyf table. */
     offset = sfnt_locate_table(sfont, "glyf");
     for (i = 0; i < g->num_glyphs; i++) {
-        USHORT gid;             /* old gid */
+        USHORT gid;
         ULONG loc, len;
-        /*SHORT number_of_contours;*/
-
         gid = g->gd[i].ogid;
         if (gid >= maxp->numGlyphs)
             formatted_error("ttf","invalid glyph index (gid %u)", gid);
-
         loc = location[gid];
         len = location[gid + 1] - loc;
         g->gd[i].advw = hmtx[gid].advance;
@@ -639,33 +520,30 @@ int tt_get_metrics(sfnt * sfont, struct tt_glyphs *g)
         }
         g->gd[i].length = len;
         g->gd[i].data = NULL;
-
         if (g->gd[i].advw <= g->emsize) {
             w_stat[g->gd[i].advw]++;
         } else {
-            w_stat[g->emsize + 1]++;    /* larger than em */
+            /*tex It's larger than em: */
+            w_stat[g->emsize + 1]++;
         }
-
-        if (len == 0) {         /* Does not contains any data. */
+        if (len == 0) {
+            /*tex No data. */
             continue;
         } else if (len < 10) {
             formatted_error("ttf","invalid glyph data (gid %u)", gid);
         }
-
         sfnt_seek_set(sfont, (long) (offset + loc));
-        /*number_of_contours = */(void)sfnt_get_short(sfont);
-
-        /* BoundingBox: FWord x 4 */
+        /*tex Skip the number of contours */
+        (void)sfnt_get_short(sfont);
+        /*tex Fetch the BoundingBox. */
         g->gd[i].llx = sfnt_get_short(sfont);
         g->gd[i].lly = sfnt_get_short(sfont);
         g->gd[i].urx = sfnt_get_short(sfont);
         g->gd[i].ury = sfnt_get_short(sfont);
-        /* |_FIXME_| */
-#if  1
-        if (!vmtx)              /* |vertOriginY == sTypeAscender| */
-            g->gd[i].tsb =
-                (SHORT) (g->default_advh - g->default_tsb - g->gd[i].ury);
-#endif
+        if (!vmtx) {
+            /*tex We fix |vertOriginY == sTypeAscender|. */
+            g->gd[i].tsb = (SHORT) (g->default_advh - g->default_tsb - g->gd[i].ury);
+        }
     }
     RELEASE(location);
     RELEASE(hmtx);
@@ -673,13 +551,11 @@ int tt_get_metrics(sfnt * sfont, struct tt_glyphs *g)
     RELEASE(hhea);
     RELEASE(head);
     RELEASE(os2);
-
-    if (vmtx)
+    if (vmtx) {
         RELEASE(vmtx);
-
+    }
     {
         int max_count = -1;
-
         g->dw = g->gd[0].advw;
         for (i = 0; i < g->emsize + 1; i++) {
             if (w_stat[i] > max_count) {
@@ -689,7 +565,5 @@ int tt_get_metrics(sfnt * sfont, struct tt_glyphs *g)
         }
     }
     RELEASE(w_stat);
-
-
     return 0;
 }
diff --git a/texk/web2c/luatexdir/font/tt_table.w b/texk/web2c/luatexdir/font/tt_table.c
similarity index 86%
rename from texk/web2c/luatexdir/font/tt_table.w
rename to texk/web2c/luatexdir/font/tt_table.c
index a4164f39d..dfcd4d650 100644
--- a/texk/web2c/luatexdir/font/tt_table.w
+++ b/texk/web2c/luatexdir/font/tt_table.c
@@ -1,52 +1,41 @@
-% tt_table.w
-%
-% Copyright 2002 by Jin-Hwan Cho and Shunsaku Hirata,
-% the dvipdfmx project team <dvipdfmx@@project.ktug.or.kr>
-% Copyright 2006-2010 Taco Hoekwater <taco@@luatex.org>
-%
-% This file is part of LuaTeX.
-%
-% LuaTeX is free software; you can redistribute it and/or modify it under
-% the terms of the GNU General Public License as published by the Free
-% Software Foundation; either version 2 of the License, or (at your
-% option) any later version.
-%
-% LuaTeX is distributed in the hope that it will be useful, but WITHOUT
-% ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-% FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
-% License for more details.
-%
-% You should have received a copy of the GNU General Public License along
-% with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+/*
 
-@ @c
+Copyright 2002 by Jin-Hwan Cho and Shunsaku Hirata, the dvipdfmx project
+    team <dvipdfmx@project.ktug.or.kr>
+Copyright 2006-2010 Taco Hoekwater <taco@luatex.org>
 
+This file is part of LuaTeX.
 
-#include "ptexlib.h"
+LuaTeX is free software; you can redistribute it and/or modify it under the terms
+of the GNU General Public License as published by the Free Software Foundation;
+either version 2 of the License, or (at your option) any later version.
+
+LuaTeX is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU General Public License along with
+LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+
+*/
 
+#include "ptexlib.h"
 #include <stdio.h>
 #include "font/sfnt.h"
 #include "font/tt_table.h"
 
-@ tables contains information refered by other tables
-
-  |maxp->numGlyphs, etc --> loca, etc|
-
-  |hhea->numberOfHMetrics --> hmtx|
+/*tex
 
-  |head->indexToLocFormat --> loca|
+    Tables contain information referred by other tables.
 
-  |head->glyphDataFormat --> glyf|
+*/
 
-@c
 char *tt_pack_head_table(struct tt_head_table *table)
 {
     int i;
     char *p, *data;
-
     if (table == NULL)
         normal_error("ttf","passed NULL pointer");
-
     p = data = NEW(TT_HEAD_TABLE_SIZE, char);
     p += sfnt_put_ulong(p, (LONG) table->version);
     p += sfnt_put_ulong(p, (LONG) table->fontRevision);
@@ -69,7 +58,6 @@ char *tt_pack_head_table(struct tt_head_table *table)
     p += sfnt_put_short(p, table->fontDirectionHint);
     p += sfnt_put_short(p, table->indexToLocFormat);
     p += sfnt_put_short(p, table->glyphDataFormat);
-
     return data;
 }
 
@@ -77,11 +65,8 @@ struct tt_head_table *tt_read_head_table(sfnt * sfont)
 {
     int i;
     struct tt_head_table *table = NULL;
-
     table = NEW(1, struct tt_head_table);
-
     sfnt_locate_table(sfont, "head");
-
     table->version = sfnt_get_ulong(sfont);
     table->fontRevision = sfnt_get_ulong(sfont);
     table->checkSumAdjustment = sfnt_get_ulong(sfont);
@@ -103,14 +88,12 @@ struct tt_head_table *tt_read_head_table(sfnt * sfont)
     table->fontDirectionHint = sfnt_get_short(sfont);
     table->indexToLocFormat = sfnt_get_short(sfont);
     table->glyphDataFormat = sfnt_get_short(sfont);
-
     return table;
 }
 
 char *tt_pack_maxp_table(struct tt_maxp_table *table)
 {
     char *p, *data;
-
     p = data = NEW(TT_MAXP_TABLE_SIZE, char);
     p += sfnt_put_ulong(p, (LONG) table->version);
     p += sfnt_put_ushort(p, table->numGlyphs);
@@ -127,16 +110,13 @@ char *tt_pack_maxp_table(struct tt_maxp_table *table)
     p += sfnt_put_ushort(p, table->maxSizeOfInstructions);
     p += sfnt_put_ushort(p, table->maxComponentElements);
     p += sfnt_put_ushort(p, table->maxComponentDepth);
-
     return data;
 }
 
 struct tt_maxp_table *tt_read_maxp_table(sfnt * sfont)
 {
     struct tt_maxp_table *table = NULL;
-
     table = NEW(1, struct tt_maxp_table);
-
     sfnt_locate_table(sfont, "maxp");
     table->version = sfnt_get_ulong(sfont);
     table->numGlyphs = sfnt_get_ushort(sfont);
@@ -153,7 +133,6 @@ struct tt_maxp_table *tt_read_maxp_table(sfnt * sfont)
     table->maxSizeOfInstructions = sfnt_get_ushort(sfont);
     table->maxComponentElements = sfnt_get_ushort(sfont);
     table->maxComponentDepth = sfnt_get_ushort(sfont);
-
     return table;
 }
 
@@ -161,7 +140,6 @@ char *tt_pack_hhea_table(struct tt_hhea_table *table)
 {
     int i;
     char *p, *data;
-
     p = data = NEW(TT_HHEA_TABLE_SIZE, char);
     p += sfnt_put_ulong(p, (LONG) table->version);
     p += sfnt_put_short(p, table->Ascender);
@@ -178,7 +156,6 @@ char *tt_pack_hhea_table(struct tt_hhea_table *table)
     }
     p += sfnt_put_short(p, table->metricDataFormat);
     p += sfnt_put_ushort(p, table->numberOfHMetrics);
-
     return data;
 }
 
@@ -186,9 +163,7 @@ struct tt_hhea_table *tt_read_hhea_table(sfnt * sfont)
 {
     int i;
     struct tt_hhea_table *table = NULL;
-
     table = NEW(1, struct tt_hhea_table);
-
     sfnt_locate_table(sfont, "hhea");
     table->version = sfnt_get_ulong(sfont);
     table->Ascender = sfnt_get_short(sfont);
@@ -207,23 +182,19 @@ struct tt_hhea_table *tt_read_hhea_table(sfnt * sfont)
     if (table->metricDataFormat != 0)
         normal_error("ttf","unknown metricDaraFormat");
     table->numberOfHMetrics = sfnt_get_ushort(sfont);
-
     return table;
 }
 
-@ vhea
-@c
 char *tt_pack_vhea_table(struct tt_vhea_table *table)
 {
     int i;
     char *p, *data;
-
     p = data = NEW(TT_VHEA_TABLE_SIZE, char);
     p += sfnt_put_ulong(p, (LONG) table->version);
     p += sfnt_put_short(p, table->vertTypoAscender);
     p += sfnt_put_short(p, table->vertTypoDescender);
     p += sfnt_put_short(p, table->vertTypoLineGap);
-    p += sfnt_put_short(p, table->advanceHeightMax);    /* ushort ? */
+    p += sfnt_put_short(p, table->advanceHeightMax);
     p += sfnt_put_short(p, table->minTopSideBearing);
     p += sfnt_put_short(p, table->minBottomSideBearing);
     p += sfnt_put_short(p, table->yMaxExtent);
@@ -234,7 +205,6 @@ char *tt_pack_vhea_table(struct tt_vhea_table *table)
         p += sfnt_put_short(p, table->reserved[i]);
     }
     p += sfnt_put_ushort(p, table->numOfLongVerMetrics);
-
     return data;
 }
 
@@ -242,15 +212,13 @@ struct tt_vhea_table *tt_read_vhea_table(sfnt * sfont)
 {
     int i;
     struct tt_vhea_table *table = NULL;
-
     table = NEW(1, struct tt_vhea_table);
-
     sfnt_locate_table(sfont, "vhea");
     table->version = sfnt_get_ulong(sfont);
     table->vertTypoAscender = sfnt_get_short(sfont);
     table->vertTypoDescender = sfnt_get_short(sfont);
     table->vertTypoLineGap = sfnt_get_short(sfont);
-    table->advanceHeightMax = sfnt_get_short(sfont);    /* ushort ? */
+    table->advanceHeightMax = sfnt_get_short(sfont);
     table->minTopSideBearing = sfnt_get_short(sfont);
     table->minBottomSideBearing = sfnt_get_short(sfont);
     table->yMaxExtent = sfnt_get_short(sfont);
@@ -261,34 +229,26 @@ struct tt_vhea_table *tt_read_vhea_table(sfnt * sfont)
         (table->reserved)[i] = sfnt_get_short(sfont);
     }
     table->numOfLongVerMetrics = sfnt_get_ushort(sfont);
-
     return table;
 }
 
-
 struct tt_VORG_table *tt_read_VORG_table(sfnt * sfont)
 {
     struct tt_VORG_table *vorg;
     ULONG offset;
     USHORT i;
-
     offset = sfnt_find_table_pos(sfont, "VORG");
-
     if (offset > 0) {
         vorg = NEW(1, struct tt_VORG_table);
-
         sfnt_locate_table(sfont, "VORG");
         if (sfnt_get_ushort(sfont) != 1 || sfnt_get_ushort(sfont) != 0)
             normal_error("ttf","unsupported VORG version");
-
         vorg->defaultVertOriginY = sfnt_get_short(sfont);
         vorg->numVertOriginYMetrics = sfnt_get_ushort(sfont);
-        vorg->vertOriginYMetrics = NEW(vorg->numVertOriginYMetrics,
-                                       struct tt_vertOriginYMetrics);
-        /*
-         * The vertOriginYMetrics array must be sorted in increasing
-         * glyphIndex order.
-         */
+        vorg->vertOriginYMetrics = NEW(vorg->numVertOriginYMetrics, struct tt_vertOriginYMetrics);
+        /*tex
+            The |vertOriginYMetrics| array must be sorted in increasing |glyphIndex| order.
+        */
         for (i = 0; i < vorg->numVertOriginYMetrics; i++) {
             vorg->vertOriginYMetrics[i].glyphIndex = sfnt_get_ushort(sfont);
             vorg->vertOriginYMetrics[i].vertOriginY = sfnt_get_short(sfont);
@@ -296,22 +256,20 @@ struct tt_VORG_table *tt_read_VORG_table(sfnt * sfont)
     } else {
         vorg = NULL;
     }
-
     return vorg;
 }
 
+/*tex
 
-@ hmtx and vmtx
+    Reading and writing |hmtx| and |vmtx| depends on other tables, like |maxp|,
+    |hhea| and |vhea|.
 
-Reading/writing hmtx and vmtx depend on other tables, maxp and hhea/vhea.
+*/
 
-@c
-struct tt_longMetrics *tt_read_longMetrics(sfnt * sfont, USHORT numGlyphs,
-                                           USHORT numLongMetrics)
+struct tt_longMetrics *tt_read_longMetrics(sfnt * sfont, USHORT numGlyphs, USHORT numLongMetrics)
 {
     struct tt_longMetrics *m;
     USHORT gid, last_adv = 0;
-
     m = NEW(numGlyphs, struct tt_longMetrics);
     for (gid = 0; gid < numGlyphs; gid++) {
         if (gid < numLongMetrics)
@@ -319,26 +277,23 @@ struct tt_longMetrics *tt_read_longMetrics(sfnt * sfont, USHORT numGlyphs,
         m[gid].sideBearing = sfnt_get_short(sfont);
         m[gid].advance = last_adv;
     }
-
     return m;
 }
 
-@ OS/2 table
+/*tex
+
+    The |OS/2| table may not exist.
+
+*/
 
-this table may not exist
-@c
 struct tt_os2__table *tt_read_os2__table(sfnt * sfont)
 {
     struct tt_os2__table *table = NULL;
     int i;
-
     if (sfnt_find_table_pos(sfont, "OS/2") == 0)
         return NULL;
-
     sfnt_locate_table(sfont, "OS/2");
-
     table = NEW(1, struct tt_os2__table);
-
     table->version = sfnt_get_ushort(sfont);
     table->xAvgCharWidth = sfnt_get_short(sfont);
     table->usWeightClass = sfnt_get_ushort(sfont);
@@ -382,37 +337,31 @@ struct tt_os2__table *tt_read_os2__table(sfnt * sfont)
         table->usBreakChar = sfnt_get_ushort(sfont);
         table->usMaxContext = sfnt_get_ushort(sfont);
     }
-
     return table;
 }
 
-USHORT
-tt_get_name(sfnt * sfont, char *dest, USHORT destlen,
+USHORT tt_get_name(sfnt * sfont, char *dest, USHORT destlen,
             USHORT plat_id, USHORT enco_id, USHORT lang_id, USHORT name_id)
 {
     USHORT length = 0;
     USHORT num_names, string_offset;
     ULONG name_offset;
     int i;
-
     name_offset = sfnt_locate_table(sfont, "name");
-
     if (sfnt_get_ushort(sfont))
         normal_error("ttf","expecting zero");
-
     num_names = sfnt_get_ushort(sfont);
     string_offset = sfnt_get_ushort(sfont);
     for (i = 0; i < num_names; i++) {
         USHORT p_id, e_id, n_id, l_id;
         USHORT offset;
-
         p_id = sfnt_get_ushort(sfont);
         e_id = sfnt_get_ushort(sfont);
         l_id = sfnt_get_ushort(sfont);
         n_id = sfnt_get_ushort(sfont);
         length = sfnt_get_ushort(sfont);
         offset = sfnt_get_ushort(sfont);
-        /* language ID value 0xffffu for `accept any language ID' */
+        /*tex The language |ID| value |0xffffu| stands for ``accept any language ID''. */
         if ((p_id == plat_id) && (e_id == enco_id) &&
             (lang_id == 0xffffu || l_id == lang_id) && (n_id == name_id)) {
             if (length > destlen - 1) {
@@ -428,33 +377,28 @@ tt_get_name(sfnt * sfont, char *dest, USHORT destlen,
     if (i == num_names) {
         length = 0;
     }
-
     return length;
 }
 
 USHORT tt_get_ps_fontname(sfnt * sfont, char *dest, USHORT destlen)
 {
     USHORT namelen = 0;
-
-    /* First try Mac-Roman PS name and then Win-Unicode PS name */
+    /*tex First try Mac-Roman PS name and then Win-Unicode PS name. */
     if ((namelen = tt_get_name(sfont, dest, destlen, 1, 0, 0, 6)) != 0 ||
         (namelen = tt_get_name(sfont, dest, destlen, 3, 1, 0x409u, 6)) != 0 ||
         (namelen = tt_get_name(sfont, dest, destlen, 3, 5, 0x412u, 6)) != 0)
         return namelen;
-
     normal_warning("ttf","no valid PostScript name available");
-    /*
-       Wrokaround for some bad TTfonts:
-       Language ID value 0xffffu for `accept any language ID'
-     */
+    /*tex
+        This is a workaround for some bad TTfonts: the language ID value |0xffffu|
+        indicates ``accept any language ID''.
+    */
     if ((namelen = tt_get_name(sfont, dest, destlen, 1, 0, 0xffffu, 6)) == 0) {
-        /*
-           Finally falling back to Mac Roman name field.
-           Warning: Some bad Japanese TTfonts using SJIS encoded string in the
-           Mac Roman name field.
-         */
+        /*tex
+            Finally we're falling back to Mac Roman name field. Some bad Japanese TTfonts
+            using SJIS encoded string in the Mac Roman name field.
+        */
         namelen = tt_get_name(sfont, dest, destlen, 1, 0, 0, 1);
     }
-
     return namelen;
 }
diff --git a/texk/web2c/luatexdir/font/vfovf.c b/texk/web2c/luatexdir/font/vfovf.c
new file mode 100644
index 000000000..e1fdb903e
--- /dev/null
+++ b/texk/web2c/luatexdir/font/vfovf.c
@@ -0,0 +1,1444 @@
+/*
+
+Copyright 1996-2006 Han The Thanh <thanh@pdftex.org>
+Copyright 2006-2013 Taco Hoekwater <taco@luatex.org>
+
+This file is part of LuaTeX.
+
+LuaTeX is free software; you can redistribute it and/or modify it under the terms
+of the GNU General Public License as published by the Free Software Foundation;
+either version 2 of the License, or (at your option) any later version.
+
+LuaTeX is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU General Public License along
+with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#include "ptexlib.h"
+
+#define font_max 5000
+
+/* The instruction set: */
+
+#define set_char_0 0   /* typeset character 0 and move right */
+#define set1 128       /* typeset a character and move right */
+#define set2 129       /* typeset a character and move right */
+#define set3 130       /* typeset a character and move right */
+#define set4 131       /* typeset a character and move right */
+#define set_rule 132   /* typeset a rule and move right */
+#define put1  133      /* typeset a character without moving */
+#define put2  134      /* typeset a character without moving */
+#define put3  135      /* typeset a character without moving */
+#define put4  136      /* typeset a character without moving */
+#define put_rule 137   /* typeset a rule */
+#define nop 138        /* no operation */
+#define bop 139        /* beginning of page */
+#define eop 140        /* ending of page */
+#define push 141       /* save the current positions */
+#define pop 142        /* restore previous positions */
+#define right1  143    /* move right */
+#define right2  144    /* move right */
+#define right3  145    /* move right */
+#define right4  146    /* move right, 4 bytes */
+#define w0 147         /* move right by |w| */
+#define w1 148         /* move right and set |w| */
+#define w2 149         /* move right and set |w| */
+#define w3 150         /* move right and set |w| */
+#define w4 151         /* move right and set |w| */
+#define x0 152         /* move right by |x| */
+#define x1 153         /* move right and set |x| */
+#define x2 154         /* move right and set |x| */
+#define x3 155         /* move right and set |x| */
+#define x4 156         /* move right and set |x| */
+#define down1 157      /* move down */
+#define down2 158      /* move down */
+#define down3 159      /* move down */
+#define down4 160      /* move down, 4 bytes */
+#define y0 161         /* move down by |y| */
+#define y1 162         /* move down and set |y| */
+#define y2 163         /* move down and set |y| */
+#define y3 164         /* move down and set |y| */
+#define y4 165         /* move down and set |y| */
+#define z0 166         /* move down by |z| */
+#define z1 167         /* move down and set |z| */
+#define z2 168         /* move down and set |z| */
+#define z3 169         /* move down and set |z| */
+#define z4 170         /* move down and set |z| */
+#define fnt_num_0 171  /* set current font to 0 */
+#define fnt1 235       /* set current font */
+#define fnt2 236       /* set current font */
+#define fnt3 237       /* set current font */
+#define fnt4 238       /* set current font */
+#define xxx1 239       /* extension to DVI  primitives */
+#define xxx2 240       /* extension to DVI  primitives */
+#define xxx3 241       /* extension to DVI  primitives */
+#define xxx4 242       /* potentially long extension to DVI primitives */
+#define fnt_def1 243   /* define the meaning of a font number */
+#define pre 247        /* preamble */
+#define post 248       /* postamble beginning */
+#define post_post 249  /* postamble ending */
+#define yyy1 250       /* PDF literal text */
+#define yyy2 251       /* PDF literal text */
+#define yyy3 252       /* PDF literal text */
+#define yyy4 253       /* PDF literal text */
+
+#define null_font 0
+
+#define long_char 242  /* |VF| command for general character packet */
+
+#define vf_id 202      /* identifies \VF\ files */
+
+/*tex
+
+    Quit |VF| processing with an error message.
+
+*/
+
+#define bad_vf(a) { \
+    xfree(vf_buffer); \
+    print_nlp(); \
+    formatted_warning("virtual font","file '%s', %s, font will be ignored",font_name(f),a); \
+    print_ln(); \
+    return; \
+}
+
+#define lua_bad_vf(a) { \
+    xfree(vf_buffer); \
+    lua_settop(L,s_top); \
+    lua_pushnil(L); \
+    lua_pushstring(L,a); \
+    return 2; \
+}
+
+#define tmp_b0  tmp_w.qqqq.b0
+#define tmp_b1  tmp_w.qqqq.b1
+#define tmp_b2  tmp_w.qqqq.b2
+#define tmp_b3  tmp_w.qqqq.b3
+#define tmp_int tmp_w.cint
+
+/*tex \DVI\ files shouldn't |push| beyond this depth: */
+
+#define vf_stack_size 100
+
+/*tex An index into the stack: */
+
+typedef unsigned char vf_stack_index;
+
+typedef struct vf_stack_record {
+    scaled stack_w, stack_x, stack_y, stack_z;
+} vf_stack_record;
+
+/*tex Get a byte from the \VF\ file: */
+
+#define vf_byte(a)                                     \
+{                                                      \
+  eight_bits vf_tmp_b;                                 \
+    if (vf_cur >= vf_size) {                           \
+        normal_error("virtual font","unexpected eof"); \
+    }                                                  \
+    vf_tmp_b = vf_buffer[vf_cur++];                    \
+    a = vf_tmp_b;                                      \
+}
+
+#define vf_replace_z()                          \
+{                                               \
+    vf_alpha = 16;                              \
+    while (vf_z >= 040000000) {                 \
+        vf_z = vf_z / 2;                        \
+        vf_alpha += vf_alpha;                   \
+    }                                           \
+    /*tex |vf_beta = (char)(256 / vf_alpha)| */ \
+    vf_alpha = (vf_alpha * vf_z);               \
+}
+
+/*tex
+
+    Read |k| bytes as an integer from \VF\ file. Beware: the |vf_read| macro
+    differs from |vf_read| in |vftovp.web| for 1 upto 3 byte words.
+
+*/
+
+#define vf_read(k, l)                        \
+{                                            \
+    int itmp = 0, dtmp = (int)(k), jtmp = 0; \
+    while (dtmp > 0) {                       \
+        vf_byte(jtmp);                       \
+        if ((dtmp == (int) k) && jtmp > 127) \
+            jtmp = jtmp - 256;               \
+        itmp = itmp * 256 + jtmp;            \
+        decr(dtmp);                          \
+    }                                        \
+    l = itmp;                                \
+}
+
+#define vf_read_u(k, l)              \
+{                                    \
+    int dtmp = (int)(k);             \
+    unsigned int itmp = 0, jtmp = 0; \
+    while (dtmp-- > 0) {             \
+        vf_byte(jtmp);               \
+        itmp = itmp * 256 + jtmp;    \
+    }                                \
+    l = itmp;                        \
+}
+
+void pdf_check_vf(internal_font_number f)
+{
+    if (font_type(f) == virtual_font_type)
+        normal_error("font", "command cannot be used with virtual font");
+}
+
+static void vf_local_font_warning(internal_font_number f, internal_font_number k, const char *s, int a, int b)
+{
+    print_nlp();
+    tprint(s);
+    tprint(" in local font ");
+    tprint(font_name(k));
+    tprint(" (");
+    print_int(b);
+    tprint(" != ");
+    print_int(a);
+    tprint(") in virtual font ");
+    tprint(font_name(f));
+    tprint(".vf ignored.");
+}
+
+/*tex Process a local font in the \VF\ file. */
+
+int level = 0;
+
+static internal_font_number vf_def_font(internal_font_number f, unsigned char *vf_buffer, int *vf_cr)
+{
+    internal_font_number k;
+    str_number s;
+    char *st;
+    scaled ds, fs;
+    four_quarters cs;
+    /*tex The accumulator: */
+    memory_word tmp_w;
+    int junk;
+    unsigned int checksum;
+    cs.b0 = vf_buffer[(*vf_cr)];
+    cs.b1 = vf_buffer[(*vf_cr) + 1];
+    cs.b2 = vf_buffer[(*vf_cr) + 2];
+    cs.b3 = vf_buffer[(*vf_cr) + 3];
+    (*vf_cr) += 4;
+    checksum = (unsigned) (cs.b0 * 256 * 256 * 256 + cs.b1 * 256 * 256 + cs.b2 * 256 + cs.b3);
+    k = vf_buffer[(*vf_cr)];
+    (*vf_cr)++;
+    if (k > 127)
+        k -= 256;
+    k = k * 256 + vf_buffer[(*vf_cr)];
+    (*vf_cr)++;
+    k = k * 256 + vf_buffer[(*vf_cr)];
+    (*vf_cr)++;
+    k = k * 256 + vf_buffer[(*vf_cr)];
+    (*vf_cr)++;
+    fs = store_scaled_f(k, font_size(f));
+    k = vf_buffer[(*vf_cr)];
+    (*vf_cr)++;
+    if (k > 127)
+        k -= 256;
+    k = k * 256 + vf_buffer[(*vf_cr)];
+    (*vf_cr)++;
+    k = k * 256 + vf_buffer[(*vf_cr)];
+    (*vf_cr)++;
+    k = k * 256 + vf_buffer[(*vf_cr)];
+    (*vf_cr)++;
+    ds = k / 16;
+    tmp_b0 = vf_buffer[(*vf_cr)];
+    (*vf_cr)++;
+    tmp_b1 = vf_buffer[(*vf_cr)];
+    (*vf_cr)++;
+    while (tmp_b0 > 0) {
+        /*tex Skip the font path. */
+        tmp_b0--;
+        (*vf_cr)++;
+    }
+    str_room((unsigned) tmp_b1);
+    while (tmp_b1 > 0) {
+        tmp_b1--;
+        junk = vf_buffer[(*vf_cr)];
+        (*vf_cr)++;
+        append_char(junk);
+    }
+    if (level > 5) {
+        normal_warning("vf","quitting at recurse depth > 5");
+        k = f ;
+    } else if ((level > 1) && (fs > 65536*1024)) {
+        normal_warning("vf","quitting when recursing at size > 65536*1024");
+        k = f ;
+    } else {
+        level += 1 ;
+        s = make_string();
+        st = makecstring(s);
+        k = tfm_lookup(st, fs);
+        if (k == null_font)
+            k = read_font_info(null_cs, st, fs, -1);
+        free(st);
+        level -= 1 ;
+        if (k != null_font) {
+            if (checksum != 0 && font_checksum(k) != 0
+                && checksum != font_checksum(k))
+                vf_local_font_warning(f, k, "checksum mismatch", (int) checksum, (int) font_checksum(k));
+            if (ds != font_dsize(k))
+                vf_local_font_warning(f, k, "design size mismatch", ds, font_dsize(k));
+        }
+    }
+    return k;
+}
+
+static int open_vf_file(const char *fn, unsigned char **vbuffer, int *vsize)
+{
+    /*tex Was the callback successful? */
+    boolean res;
+    int callback_id;
+    /*tex Was |vf_file| successfully read? */
+    boolean file_read = false;
+    FILE *vf_file;
+    const char *fname = luatex_find_file(fn, find_vf_file_callback);
+    if (fname == NULL || strlen(fname) == 0) {
+       return 0;
+    }
+
+    callback_id = callback_defined(read_vf_file_callback);
+    if (callback_id > 0) {
+        res = run_callback(callback_id, "S->bSd", fname,
+                           &file_read, vbuffer, vsize);
+        if (res && file_read && (*vsize > 0)) {
+            return 1;
+        }
+        if (!file_read)
+            return 0;
+    } else {
+        if (luatex_open_input
+            (&(vf_file), fname, kpse_ovf_format, FOPEN_RBIN_MODE, false)
+            || luatex_open_input(&(vf_file), fname, kpse_vf_format, FOPEN_RBIN_MODE, false)) {
+                res = read_vf_file(vf_file, vbuffer, vsize);
+                close_file(vf_file);
+                if (res) {
+                    return 1;
+            }
+        } else {
+            return 0;
+        }
+    }
+    return 0;
+}
+
+/*tex
+
+    The |do_vf| procedure attempts to read the \VF\ file for a font, and sets
+    |font_type()| to |real_font_type| if the \VF\ file could not be found or
+    loaded, otherwise sets |font_type()| to |virtual_font_type|. At this time,
+    |tmp_f| is the internal font number of the current \TFM\ font. To process
+    font definitions in virtual font we call |vf_def_font|.
+
+*/
+
+#define append_packet(k) vpackets[vf_np++] = (eight_bits)(k)
+
+/*tex
+
+    Life is easier if all internal font commands are |fnt4| and all character
+    commands are |set4| or |put4|.
+
+*/
+
+#define append_fnt_set(k)            \
+{                                    \
+    assert(k > 0);                   \
+    append_packet(packet_font_code); \
+    append_four(k);                  \
+}
+
+#define append_four(k)                     \
+{                                          \
+    append_packet((k & 0xFF000000) >> 24); \
+    append_packet((k & 0x00FF0000) >> 16); \
+    append_packet((k & 0x0000FF00) >> 8);  \
+    append_packet((k & 0x000000FF));       \
+}
+
+/*tex Some of these things happen twice, adding a define is simplest. */
+
+#define test_checksum()  { vf_byte(tmp_b0); vf_byte(tmp_b1); \
+    vf_byte(tmp_b2); vf_byte(tmp_b3); \
+    if (((tmp_b0 != 0) || (tmp_b1 != 0) || (tmp_b2 != 0) || (tmp_b3 != 0)) && \
+  ((font_check_0(f) != 0) || (font_check_1(f) != 0) || \
+   (font_check_2(f) != 0) || (font_check_3(f) != 0)) && \
+  ((tmp_b0 != font_check_0(f)) || (tmp_b1 != font_check_1(f)) ||  \
+   (tmp_b2 != font_check_2(f)) || (tmp_b3 != font_check_3(f)))) { \
+      print_nlp(); \
+      tprint("checksum mismatch in font "); \
+      tprint(font_name(f)); \
+      tprint(".vf ignored "); } }
+
+#define test_dsize()                             \
+{                                                \
+    int read_tmp;                                \
+    vf_read(4, read_tmp);                        \
+    if ((read_tmp / 16) != font_dsize(f)) {      \
+        print_nlp();                             \
+        tprint("design size mismatch in font "); \
+        tprint(font_name(f));                    \
+        tprint(".vf ignored");                   \
+    }                                            \
+}
+
+static int count_packet_bytes(eight_bits * vf_buf, int cur_bute, int count)
+{
+    unsigned k = 0;
+    int ff = 0;
+    int acc = 0;
+    unsigned int cmd = 0;
+    unsigned int d = 0;
+    while (k < (unsigned) count) {
+        cmd = vf_buf[cur_bute + (int) k];
+        k++;
+        if (cmd < set1) {
+            if (ff == 0) {
+                ff = 1;
+                acc += 5;
+            }
+            acc += 5;
+        } else if ((fnt_num_0 <= cmd) && (cmd <= fnt_num_0 + 63)) {
+            ff = 1;
+            acc += 5;
+        } else {
+            switch (cmd) {
+                case fnt1:
+                    acc += 5;
+                    k += 1;
+                    ff = 1;
+                    break;
+                case fnt2:
+                    acc += 5;
+                    k += 2;
+                    ff = 1;
+                    break;
+                case fnt3:
+                    acc += 5;
+                    k += 3;
+                    ff = 1;
+                    break;
+                case fnt4:
+                    acc += 5;
+                    k += 4;
+                    ff = 1;
+                    break;
+                case set_rule:
+                    acc += 9;
+                    k += 8;
+                    break;
+                case put_rule:
+                    acc += 11;
+                    k += 8;
+                    break;
+                case set1:
+                    acc += 5;
+                    k += 1;
+                    if (ff == 0) {
+                        ff = 1;
+                        acc += 5;
+                    }
+                    break;
+                case set2:
+                    acc += 5;
+                    k += 2;
+                    if (ff == 0) {
+                        ff = 1;
+                        acc += 5;
+                    }
+                    break;
+                case set3:
+                    acc += 5;
+                    k += 3;
+                    if (ff == 0) {
+                        ff = 1;
+                        acc += 5;
+                    }
+                    break;
+                case set4:
+                    acc += 5;
+                    k += 4;
+                    if (ff == 0) {
+                        ff = 1;
+                        acc += 5;
+                    }
+                    break;
+                case put1:
+                    acc += 7;
+                    k += 1;
+                    if (ff == 0) {
+                        ff = 1;
+                        acc += 5;
+                    }
+                    break;
+                case put2:
+                    acc += 7;
+                    k += 2;
+                    if (ff == 0) {
+                        ff = 1;
+                        acc += 5;
+                    }
+                    break;
+                case put3:
+                    acc += 7;
+                    k += 3;
+                    if (ff == 0) {
+                        ff = 1;
+                        acc += 5;
+                    }
+                    break;
+                case put4:
+                    acc += 7;
+                    k += 4;
+                    if (ff == 0) {
+                        ff = 1;
+                        acc += 5;
+                    }
+                    break;
+                case right1:
+                    acc += 5;
+                    k += 1;
+                    break;
+                case right2:
+                    acc += 5;
+                    k += 2;
+                    break;
+                case right3:
+                    acc += 5;
+                    k += 3;
+                    break;
+                case right4:
+                    acc += 5;
+                    k += 4;
+                    break;
+                case w1:
+                    acc += 5;
+                    k += 1;
+                    break;
+                case w2:
+                    acc += 5;
+                    k += 2;
+                    break;
+                case w3:
+                    acc += 5;
+                    k += 3;
+                    break;
+                case w4:
+                    acc += 5;
+                    k += 4;
+                    break;
+                case x1:
+                    acc += 5;
+                    k += 1;
+                    break;
+                case x2:
+                    acc += 5;
+                    k += 2;
+                    break;
+                case x3:
+                    acc += 5;
+                    k += 3;
+                    break;
+                case x4:
+                    acc += 5;
+                    k += 4;
+                    break;
+                case down1:
+                    acc += 5;
+                    k += 1;
+                    break;
+                case down2:
+                    acc += 5;
+                    k += 2;
+                    break;
+                case down3:
+                    acc += 5;
+                    k += 3;
+                    break;
+                case down4:
+                    acc += 5;
+                    k += 4;
+                    break;
+                case y1:
+                    acc += 5;
+                    k += 1;
+                    break;
+                case y2:
+                    acc += 5;
+                    k += 2;
+                    break;
+                case y3:
+                    acc += 5;
+                    k += 3;
+                    break;
+                case y4:
+                    acc += 5;
+                    k += 4;
+                    break;
+                case z1:
+                    acc += 5;
+                    k += 1;
+                    break;
+                case z2:
+                    acc += 5;
+                    k += 2;
+                    break;
+                case z3:
+                    acc += 5;
+                    k += 3;
+                    break;
+                case z4:
+                    acc += 5;
+                    k += 4;
+                    break;
+                case xxx1:
+                    d = vf_buf[cur_bute + (int) k];
+                    k++;
+                    k += d;
+                    acc += 5 + (int) d;
+                    break;
+                case xxx2:
+                    d = vf_buf[cur_bute + (int) k];
+                    k++;
+                    d = d * 256 + vf_buf[cur_bute + (int) k];
+                    k++;
+                    k += d;
+                    acc += 5 + (int) d;
+                    break;
+                case xxx3:
+                    d = vf_buf[cur_bute + (int) k];
+                    k++;
+                    d = d * 256 + vf_buf[cur_bute + (int) k];
+                    k++;
+                    d = d * 256 + vf_buf[cur_bute + (int) k];
+                    k++;
+                    k += d;
+                    acc += 5 + (int) d;
+                    break;
+                case xxx4:
+                    d = vf_buf[cur_bute + (int) k];
+                    k++;
+                    d = d * 256 + vf_buf[cur_bute + (int) k];
+                    k++;
+                    d = d * 256 + vf_buf[cur_bute + (int) k];
+                    k++;
+                    d = d * 256 + vf_buf[cur_bute + (int) k];
+                    k++;
+                    k += d;
+                    acc += 5 + (int) d;
+                    break;
+                case w0:
+                    acc += 5;
+                    break;
+                case x0:
+                    acc += 5;
+                    break;
+                case y0:
+                    acc += 5;
+                    break;
+                case z0:
+                    acc += 5;
+                    break;
+                case nop:
+                    break;
+                case push:
+                    acc += 1;
+                    break;
+                case pop:
+                    acc += 1;
+                    break;
+            }
+        }
+    }
+    return (acc + 1);
+}
+
+void do_vf(internal_font_number f)
+{
+    int k, i;
+    unsigned cmd, n;
+    scaled x, y, w, z, h, v;
+    int cc, cmd_length;
+    unsigned packet_length;
+    charinfo *co;
+    scaled tfm_width;
+    int save_cur_byte;
+    vf_stack_index stack_level;
+    /*tex multiplier */
+    int vf_z;
+    /*tex correction for negative values */
+    int vf_alpha;
+    int vf_np;
+    eight_bits *vpackets;
+    /*tex accumulator */
+    memory_word tmp_w;
+    vf_stack_record vf_stack[256];
+    int junk;
+    unsigned utmp;
+    unsigned char *vf_buffer;
+    int vf_size;
+    int vf_cur;
+    /*tex external font ids */
+    unsigned *vf_local_fnts = NULL;
+    /*tex internal font ids */
+    unsigned *vf_real_fnts = NULL;
+    /*tex local font counter */
+    unsigned vf_nf = 0;
+    if (font_type(f) != unknown_font_type)
+        return;
+    set_font_type(f, real_font_type);
+    stack_level = 0;
+    /*tex Open |vf_file|, return if not found */
+    vf_cur = 0;
+    vf_buffer = NULL;
+    vf_size = 0;
+    if (!open_vf_file(font_name(f), &vf_buffer, &vf_size))
+        return;
+    /*tex Process the preamble */
+    set_font_type(f, virtual_font_type);
+    vf_byte(k);
+    if (k != pre)
+        bad_vf("PRE command expected");
+    vf_byte(k);
+    if (k != vf_id)
+        bad_vf("wrong id byte");
+    vf_byte(cmd_length);
+    for (k = 1; k <= cmd_length; k++)
+        vf_byte(junk);
+    test_checksum();
+    test_dsize();
+    vf_z = font_size(f);
+    vf_replace_z();
+    /*tex Process the font definitions; scan forward to find the number of internal fonts. */
+    vf_nf = 0;
+    save_cur_byte = vf_cur;
+    vf_byte(cmd);
+    while ((cmd >= fnt_def1) && (cmd <= (fnt_def1 + 3))) {
+        vf_read_u((cmd - fnt_def1 + 1), utmp);
+        vf_read(4, junk);
+        vf_read(4, junk);
+        vf_read(4, junk);
+        vf_byte(k);
+        vf_byte(junk);
+        k += junk;
+        while (k-- > 0) {
+            vf_byte(junk);
+        }
+        incr(vf_nf);
+        vf_byte(cmd);
+    }
+    vf_cur = save_cur_byte;
+    vf_byte(cmd);
+    /*tex Do a |malloc| and fill the local font arrays. */
+    if (vf_nf > 0) {
+        unsigned ii = (unsigned) ((unsigned) vf_nf * sizeof(int));
+        vf_local_fnts = xmalloc(ii);
+        memset(vf_local_fnts, 0, ii);
+        vf_real_fnts = xmalloc(ii);
+        memset(vf_real_fnts, 0, ii);
+        vf_nf = 0;
+        while ((cmd >= fnt_def1) && (cmd <= (fnt_def1 + 3))) {
+            vf_read_u((cmd - fnt_def1 + 1), vf_local_fnts[vf_nf]);
+            vf_real_fnts[vf_nf] = (unsigned) vf_def_font(f, vf_buffer, &vf_cur);
+            incr(vf_nf);
+            vf_byte(cmd);
+        }
+    }
+    while (cmd <= long_char) {
+        /*tex Build a character packet. */
+        vf_np = 0;
+        if (cmd == long_char) {
+            vf_read_u(4, packet_length);
+            vf_read_u(4, utmp);
+            cc = (int) utmp;
+            if (!char_exists(f, cc)) {
+                bad_vf("invalid character code");
+            }
+            vf_read(4, k);
+            tfm_width = store_scaled_f(k, font_size(f));
+        } else {
+            packet_length = cmd;
+            vf_byte(cc);
+            if (!char_exists(f, cc)) {
+                bad_vf("invalid character code");
+            }
+            vf_read_u(3, utmp);
+            /*tex cf. |vftovp.web|, line 1028 */
+            k = (int) utmp;
+            tfm_width = store_scaled_f(k, font_size(f));
+        }
+        if (tfm_width != char_width(f, cc)) {
+            if (tfm_width != char_width(f, cc)) {
+                print_nlp();
+                tprint("character width mismatch in font ");
+                tprint(font_name(f));
+                tprint(".vf ignored");
+            }
+        }
+        k = count_packet_bytes(vf_buffer, vf_cur, (int) packet_length);
+        /*tex We need one extra extra for |packet_end|. */
+        vpackets = xmalloc((unsigned) (k + 1));
+        co = get_charinfo(f, cc);
+        k = 0;
+        w = 0;
+        x = 0;
+        y = 0;
+        z = 0;
+        while (packet_length > 0) {
+            vf_byte(cmd);
+            decr(packet_length);
+            if (cmd < set1) {
+                if (k == 0) {
+                    k = (int) vf_real_fnts[0];
+                    append_fnt_set(k);
+                }
+                append_packet(packet_char_code);
+                append_four(cmd);
+                cmd_length = 0;
+                cmd = nop;
+            } else if (((fnt_num_0 <= cmd) && (cmd <= fnt_num_0 + 63)) ||
+                       ((fnt1 <= cmd) && (cmd <= fnt1 + 3))) {
+                if (cmd >= fnt1) {
+                    vf_read_u((cmd - fnt1 + 1), utmp);
+                    k = (int) utmp;
+                    packet_length -= (cmd - fnt1 + 1);
+                } else {
+                    k = (int) cmd - fnt_num_0;
+                }
+                /*tex Change from local to external font id. */
+                n = 0;
+                while ((n < vf_nf) && (vf_local_fnts[n] != (unsigned) k))
+                    n++;
+                if (n == vf_nf)
+                    bad_vf("undefined local font");
+                k = (int) vf_real_fnts[n];
+                append_fnt_set(k);
+                cmd_length = 0;
+                cmd = nop;
+            } else {
+                switch (cmd) {
+                    case set_rule:
+                        vf_read(4, h);
+                        vf_read(4, v);
+                        append_packet(packet_rule_code);
+                        append_four(h);
+                        append_four(v);
+                        packet_length -= 8;
+                        break;
+                    case put_rule:
+                        vf_read(4, h);
+                        vf_read(4, v);
+                        append_packet(packet_push_code);
+                        append_packet(packet_rule_code);
+                        append_four(h);
+                        append_four(v);
+                        append_packet(packet_pop_code);
+                        packet_length -= 8;
+                        break;
+                    case set1:
+                    case set2:
+                    case set3:
+                    case set4:
+                        if (k == 0) {
+                            k = (int) vf_real_fnts[0];
+                            append_fnt_set(k);
+                        }
+                        vf_read_u((cmd - set1 + 1), utmp);
+                        i = (int) utmp;
+                        append_packet(packet_char_code);
+                        append_four(i);
+                        packet_length -= (cmd - set1 + 1);
+                        break;
+                    case put1:
+                    case put2:
+                    case put3:
+                    case put4:
+                        if (k == 0) {
+                            k = (int) vf_real_fnts[0];
+                            append_fnt_set(k);
+                        }
+                        vf_read_u((cmd - put1 + 1), utmp);
+                        i = (int) utmp;
+                        append_packet(packet_push_code);
+                        append_packet(packet_char_code);
+                        append_four(i);
+                        append_packet(packet_pop_code);
+                        packet_length -= (cmd - put1 + 1);
+                        break;
+                    case right1:
+                    case right2:
+                    case right3:
+                    case right4:
+                        vf_read((cmd - right1 + 1), i);
+                        append_packet(packet_right_code);
+                        append_four(i);
+                        packet_length -= (cmd - right1 + 1);
+                        break;
+                    case w1:
+                    case w2:
+                    case w3:
+                    case w4:
+                        vf_read((cmd - w1 + 1), w);
+                        append_packet(packet_right_code);
+                        append_four(w);
+                        packet_length -= (cmd - w1 + 1);
+                        break;
+                    case x1:
+                    case x2:
+                    case x3:
+                    case x4:
+                        vf_read((cmd - x1 + 1), x);
+                        append_packet(packet_right_code);
+                        append_four(x);
+                        packet_length -= (cmd - x1 + 1);
+                        break;
+                    case down1:
+                    case down2:
+                    case down3:
+                    case down4:
+                        vf_read((cmd - down1 + 1), i);
+                        append_packet(packet_down_code);
+                        append_four(i);
+                        packet_length -= (cmd - down1 + 1);
+                        break;
+                    case y1:
+                    case y2:
+                    case y3:
+                    case y4:
+                        vf_read((cmd - y1 + 1), y);
+                        append_packet(packet_down_code);
+                        append_four(y);
+                        packet_length -= (cmd - y1 + 1);
+                        break;
+                    case z1:
+                    case z2:
+                    case z3:
+                    case z4:
+                        vf_read((cmd - z1 + 1), z);
+                        append_packet(packet_down_code);
+                        append_four(z);
+                        packet_length -= (cmd - z1 + 1);
+                        break;
+                    case xxx1:
+                    case xxx2:
+                    case xxx3:
+                    case xxx4:
+                        vf_read_u((cmd - xxx1 + 1), utmp);
+                        cmd_length = (int) utmp;
+                        packet_length -= (cmd - xxx1 + 1);
+                        if (cmd_length <= 0)
+                            bad_vf("special of negative length");
+                        packet_length -= (unsigned) cmd_length;
+                        append_packet(packet_special_code);
+                        append_four(cmd_length);
+                        while (cmd_length > 0) {
+                            cmd_length--;
+                            vf_byte(i);
+                            append_packet(i);
+                        }
+                        break;
+                    case w0:
+                        append_packet(packet_right_code);
+                        append_four(w);
+                        break;
+                    case x0:
+                        append_packet(packet_right_code);
+                        append_four(x);
+                        break;
+                    case y0:
+                        append_packet(packet_down_code);
+                        append_four(y);
+                        break;
+                    case z0:
+                        append_packet(packet_down_code);
+                        append_four(z);
+                        break;
+                    case nop:
+                        break;
+                    case push:
+                        if (stack_level == vf_stack_size) {
+                            overflow("virtual font stack size", vf_stack_size);
+                        } else {
+                            vf_stack[stack_level].stack_w = w;
+                            vf_stack[stack_level].stack_x = x;
+                            vf_stack[stack_level].stack_y = y;
+                            vf_stack[stack_level].stack_z = z;
+                            incr(stack_level);
+                            append_packet(packet_push_code);
+                        }
+                        break;
+                    case pop:
+                        if (stack_level == 0) {
+                            bad_vf("more POPs than PUSHs in character");
+                        } else {
+                            decr(stack_level);
+                            w = vf_stack[stack_level].stack_w;
+                            x = vf_stack[stack_level].stack_x;
+                            y = vf_stack[stack_level].stack_y;
+                            z = vf_stack[stack_level].stack_z;
+                            append_packet(packet_pop_code);
+                        }
+                        break;
+                    default:
+                        bad_vf("improver DVI command");
+                }
+            }
+        }
+        /*tex Signal end of packet. */
+        append_packet(packet_end_code);
+        if (stack_level != 0)
+            bad_vf("more PUSHs than POPs in character packet");
+        if (packet_length != 0)
+            bad_vf("invalid packet length or DVI command in packet");
+        /*tex Store the packet being built. */
+        set_charinfo_packets(co, vpackets);
+        vf_byte(cmd);
+    }
+    if (cmd != post)
+        bad_vf("POST command expected");
+
+    xfree(vf_buffer);
+}
+
+#define make_command0(N,K) { \
+    lua_newtable(L);         \
+    lua_pushstring(L, N);    \
+    lua_rawseti(L,-2, 1);    \
+    lua_rawseti(L,-2, K);    \
+    K++; }
+
+#define make_command1(N,V,K) { \
+    lua_newtable(L);           \
+    lua_pushstring(L, N);      \
+    lua_rawseti(L,-2, 1);      \
+    lua_pushinteger(L, V);     \
+    lua_rawseti(L,-2, 2);      \
+    lua_rawseti(L,-2, K);      \
+    K++; }
+
+#define make_command2(N,V,W,K) { \
+    lua_newtable(L);             \
+    lua_pushstring(L, N);        \
+    lua_rawseti(L,-2, 1);        \
+    lua_pushinteger(L, V);       \
+    lua_rawseti(L,-2, 2);        \
+    lua_pushinteger(L, W);       \
+    lua_rawseti(L,-2, 3);        \
+    lua_rawseti(L,-2, K);        \
+    K++; }
+
+#define make_commands(N,S,V,K) { \
+    lua_newtable(L);             \
+    lua_pushstring(L, N);        \
+    lua_rawseti(L,-2, 1);        \
+    lua_pushlstring(L, S, V);    \
+    lua_rawseti(L,-2, 2);        \
+    lua_rawseti(L,-2, K);        \
+    K++; }
+
+int make_vf_table(lua_State * L, const char *cnom, scaled atsize)
+{
+    int cmd, k, i;
+    int cc;
+    unsigned cmd_length, packet_length;
+    scaled tfm_width;
+    vf_stack_index stack_level;
+    /*tex multiplier */
+    int vf_z;
+    /*tex correction for negative values */
+    int vf_alpha;
+    eight_bits *s;
+    scaled h, v;
+    scaled w, x, y, z;
+    /*tex \LUA\ stack */
+    int s_top;
+    /*tex local font counter */
+    int vf_nf;
+    scaled ds, fs;
+    four_quarters cs;
+    /*tex accumulator */
+    memory_word tmp_w;
+    vf_stack_record vf_stack[256];
+    unsigned char *vf_buffer;
+    int vf_size;
+    int vf_cur;
+    unsigned utmp;
+    stack_level = 0;
+    /*tex Open |vf_file|, return if not found. */
+    vf_cur = 0;
+    vf_buffer = NULL;
+    vf_size = 0;
+    if (!open_vf_file(cnom, &vf_buffer, &vf_size)) {
+        lua_pushnil(L);
+        return 1;
+    }
+    /*tex Start by creating a table. */
+    s_top = lua_gettop(L);
+    lua_newtable(L);
+    /*tex Process the preamble. */
+    vf_byte(k);
+    if (k != pre)
+        lua_bad_vf("PRE command expected");
+    vf_byte(k);
+    if (k != vf_id)
+        lua_bad_vf("wrong id byte");
+    vf_byte(cmd_length);
+    s = xmalloc(cmd_length);
+    for (k = 1; k <= (int) cmd_length; k++)
+        vf_byte(s[(k - 1)]);
+    lua_pushlstring(L, (char *) s, (size_t) cmd_length);
+    free(s);
+    lua_setfield(L, -2, "header");
+    vf_byte(cs.b0);
+    vf_byte(cs.b1);
+    vf_byte(cs.b2);
+    vf_byte(cs.b3);
+    lua_pushinteger(L,  (lua_Number) ((cs.b0 << 24) + (cs.b1 << 16) + (cs.b2 << 8) + cs.b3));
+    lua_setfield(L, -2, "checksum");
+    vf_read(4, k);
+    ds = k / 16;
+    lua_pushinteger(L, ds);
+    lua_setfield(L, -2, "designsize");
+    lua_pushstring(L, cnom);
+    lua_setfield(L, -2, "name");
+    lua_pushinteger(L, atsize);
+    lua_setfield(L, -2, "size");
+    vf_z = atsize;
+    vf_replace_z();
+    /*tex Process the font definitions. */
+    vf_byte(cmd);
+    lua_newtable(L);
+    i = 1;
+    while ((cmd >= fnt_def1) && (cmd <= fnt_def1 + 3)) {
+        lua_newtable(L);
+        vf_read_u((cmd - fnt_def1 + 1), utmp);
+        vf_nf = (int) utmp;
+        vf_nf++;
+        /*tex Add a checksum. */
+        vf_byte(cs.b0);
+        vf_byte(cs.b1);
+        vf_byte(cs.b2);
+        vf_byte(cs.b3);
+        vf_read(4, k);
+        fs = store_scaled_f(k, atsize);
+        lua_pushstring(L, "size");
+        lua_pushinteger(L, fs);
+        lua_rawset(L, -3);
+        vf_read(4, k);
+        /*tex |dsize| is not used */
+        ds = k / 16;
+        vf_byte(tmp_b0);
+        vf_byte(tmp_b1);
+        /*tex Skip the font path. */
+        while (tmp_b0 > 0) {
+            tmp_b0--;
+            vf_byte(k);
+        }
+        s = xmalloc((unsigned) (tmp_b1 + 1));
+        k = 0;
+        while (tmp_b1-- > 0)
+            vf_byte(s[k++]);
+        s[k] = 0;
+        lua_pushstring(L, "name");
+        lua_pushstring(L, xstrdup((char *) s));
+        free(s);
+        lua_rawset(L, -3);
+        lua_rawseti(L, -2, vf_nf);
+        i++;
+        vf_byte(cmd);
+    }
+    if (i > 1) {
+        lua_setfield(L, -2, "fonts");
+    } else {
+        lua_pop(L, 1);
+    }
+    /*tex The table; with characters comes next. */
+    lua_newtable(L);
+    while (cmd <= long_char) {
+        /*tex Build a character packet. */
+        if (cmd == long_char) {
+            vf_read_u(4, packet_length);
+            vf_read_u(4, utmp);
+            cc = (int) utmp;
+            vf_read(4, tfm_width);
+        } else {
+            packet_length = (unsigned) cmd;
+            vf_byte(cc);
+            vf_read_u(3, utmp);
+            tfm_width = (int) utmp;
+        }
+        /*tex For this character entry. */
+        lua_newtable(L);
+        lua_pushinteger(L, tfm_width);
+        lua_setfield(L, -2, "width");
+        /*tex for |commands|: */
+        lua_newtable(L);
+        k = 1;
+        vf_nf = 0;
+        w = 0;
+        x = 0;
+        y = 0;
+        z = 0;
+        while (packet_length > 0) {
+            vf_byte(cmd);
+            decr(packet_length);
+            if ((cmd >= set_char_0) && (cmd < set1)) {
+                if (vf_nf == 0) {
+                    vf_nf = 1;
+                    make_command1("font", vf_nf, k);
+                }
+                make_command1("char", cmd, k);
+            } else if (((fnt_num_0 <= cmd) && (cmd <= fnt_num_0 + 63)) || ((fnt1 <= cmd) && (cmd <= fnt1 + 3))) {
+                if (cmd >= fnt1) {
+                    vf_read_u((cmd - fnt1 + 1), utmp);
+                    vf_nf = (int) utmp;
+                    vf_nf++;
+                    packet_length -= (unsigned) (cmd - fnt1 + 1);
+                } else {
+                    vf_nf = cmd - fnt_num_0 + 1;
+                }
+                make_command1("font", vf_nf, k);
+            } else {
+                switch (cmd) {
+                    case set_rule:
+                        vf_read(4, h);
+                        vf_read(4, v);
+                        make_command2("rule", store_scaled_f(h, atsize),
+                                      store_scaled_f(v, atsize), k);
+                        packet_length -= 8;
+                        break;
+                    case put_rule:
+                        vf_read(4, h);
+                        vf_read(4, v);
+                        make_command0("push", k);
+                        make_command2("rule", store_scaled_f(h, atsize),
+                                      store_scaled_f(v, atsize), k);
+                        make_command0("pop", k);
+                        packet_length -= 8;
+                        break;
+                    case set1:
+                    case set2:
+                    case set3:
+                    case set4:
+                        if (vf_nf == 0) {
+                            vf_nf = 1;
+                            make_command1("font", vf_nf, k);
+                        }
+                        vf_read_u((cmd - set1 + 1), utmp);
+                        i = (int) utmp;
+                        make_command1("char", i, k);
+                        packet_length -= (unsigned) (cmd - set1 + 1);
+                        break;
+                    case put1:
+                    case put2:
+                    case put3:
+                    case put4:
+                        if (vf_nf == 0) {
+                            vf_nf = 1;
+                            make_command1("font", vf_nf, k);
+                        }
+                        vf_read_u((cmd - put1 + 1), utmp);
+                        i = (int) utmp;
+                        make_command0("push", k);
+                        make_command1("char", i, k);
+                        make_command0("pop", k);
+                        packet_length -= (unsigned) (cmd - put1 + 1);
+                        break;
+                    case right1:
+                    case right2:
+                    case right3:
+                    case right4:
+                        vf_read((cmd - right1 + 1), i);
+                        make_command1("right", store_scaled_f(i, atsize), k);
+                        packet_length -= (unsigned) (cmd - right1 + 1);
+                        break;
+                    case w1:
+                    case w2:
+                    case w3:
+                    case w4:
+                        vf_read((cmd - w1 + 1), w);
+                        make_command1("right", store_scaled_f(w, atsize), k);
+                        packet_length -= (unsigned) (cmd - w1 + 1);
+                        break;
+                    case x1:
+                    case x2:
+                    case x3:
+                    case x4:
+                        vf_read((cmd - x1 + 1), x);
+                        make_command1("right", store_scaled_f(x, atsize), k);
+                        packet_length -= (unsigned) (cmd - x1 + 1);
+                        break;
+                    case down1:
+                    case down2:
+                    case down3:
+                    case down4:
+                        vf_read((cmd - down1 + 1), i);
+                        make_command1("down", store_scaled_f(i, atsize), k);
+                        packet_length -= (unsigned) (cmd - down1 + 1);
+                        break;
+                    case y1:
+                    case y2:
+                    case y3:
+                    case y4:
+                        vf_read((cmd - y1 + 1), y);
+                        make_command1("down", store_scaled_f(y, atsize), k);
+                        packet_length -= (unsigned) (cmd - y1 + 1);
+                        break;
+                    case z1:
+                    case z2:
+                    case z3:
+                    case z4:
+                        vf_read((cmd - z1 + 1), z);
+                        make_command1("down", store_scaled_f(z, atsize), k);
+                        packet_length -= (unsigned) (cmd - z1 + 1);
+                        break;
+                    case xxx1:
+                    case xxx2:
+                    case xxx3:
+                    case xxx4:
+                        vf_read_u((cmd - xxx1 + 1), cmd_length);
+                        packet_length -= (unsigned) (cmd - xxx1 + 1);
+                        if (cmd_length <= 0)
+                            lua_bad_vf("special of negative length");
+                        packet_length -= cmd_length;
+                        s = xmalloc((cmd_length + 1));
+                        i = 0;
+                        while (cmd_length > 0) {
+                            cmd_length--;
+                            vf_byte(s[i]);
+                            i++;
+                        }
+                        s[i] = 0;
+                        make_commands("special", xstrdup((char *) s), (size_t) i, k);
+                        free(s);
+                        break;
+                    case w0:
+                        make_command1("right", store_scaled_f(w, atsize), k);
+                        break;
+                    case x0:
+                        make_command1("right", store_scaled_f(x, atsize), k);
+                        break;
+                    case y0:
+                        make_command1("down", store_scaled_f(y, atsize), k);
+                        break;
+                    case z0:
+                        make_command1("down", store_scaled_f(z, atsize), k);
+                        break;
+                    case nop:
+                        break;
+                    case push:
+                        if (stack_level == vf_stack_size) {
+                            overflow("virtual font stack size", vf_stack_size);
+                        } else {
+                            vf_stack[stack_level].stack_w = w;
+                            vf_stack[stack_level].stack_x = x;
+                            vf_stack[stack_level].stack_y = y;
+                            vf_stack[stack_level].stack_z = z;
+                            incr(stack_level);
+                            make_command0("push", k);
+                        }
+                        break;
+                    case pop:
+                        if (stack_level == 0) {
+                            lua_bad_vf("more POPs than PUSHs in character");
+                        } else {
+                            decr(stack_level);
+                            w = vf_stack[stack_level].stack_w;
+                            x = vf_stack[stack_level].stack_x;
+                            y = vf_stack[stack_level].stack_y;
+                            z = vf_stack[stack_level].stack_z;
+                            make_command0("pop", k);
+                        }
+                        break;
+                    default:
+                        lua_bad_vf("improver DVI command");
+                }
+            }
+        }
+        /*tex Signal end of packet. */
+        lua_setfield(L, -2, "commands");
+        if (stack_level != 0)
+            lua_bad_vf("more PUSHs than POPs in character packet");
+        if (packet_length != 0)
+            lua_bad_vf("invalid packet length or DVI command in packet");
+        lua_rawseti(L, -2, cc);
+        vf_byte(cmd);
+    }
+    lua_setfield(L, -2, "characters");
+    if (cmd != post)
+        lua_bad_vf("POST command expected");
+    xfree(vf_buffer);
+    return 1;
+}
+
+internal_font_number letter_space_font(internal_font_number f, int e, boolean nolig)
+{
+    internal_font_number k;
+    scaled w;
+    int c;
+    charinfo *co;
+    char *new_font_name;
+    /*tex Read a new font and expand the character widths. */
+    k = copy_font(f);
+    if (nolig) {
+        /*tex Disable ligatures for letter-spaced fonts. */
+        set_no_ligatures(k);
+    }
+    /*tex append e.g. |+100ls| to font name; |abs(e) <= 1000|. */
+    new_font_name = xmalloc((unsigned) (strlen(font_name(k)) + 8));
+    if (e > 0) {
+        sprintf(new_font_name, "%s+%ils", font_name(k), (int) e);
+    } else {
+        /*tex Minus from |%i|: */
+        sprintf(new_font_name, "%s%ils", font_name(k), (int) e);
+    }
+    set_font_name(k, new_font_name);
+    /* Create the corresponding virtual font. */
+    set_font_type(k, virtual_font_type);
+    for (c=font_bc(k);c<=font_ec(k);c++) {
+       if (quick_char_exists(k, c)) {
+           int half_w;
+           int vf_np = 0;
+           eight_bits *vpackets = xmalloc((unsigned) (10+10+1));
+           if (e<0) {
+             half_w = -round_xn_over_d(quad(k), -e, 2000);
+           } else {
+             half_w  = round_xn_over_d(quad(k), e, 2000);
+           }
+           co = get_charinfo(k, c);
+           w = char_width(k, c)+2*half_w;
+           set_charinfo_width(co, w);
+           append_packet(packet_right_code);
+           append_four(half_w);
+           append_fnt_set(f);
+           append_packet(packet_char_code);
+           append_four(c);
+           append_packet(packet_right_code);
+           append_four(half_w);
+           append_packet(packet_end_code);
+           set_charinfo_packets(co, vpackets);
+       }
+    }
+    /*tex Now patch the quad size. Ok, not in order to remain compatible with \PDFTEX: */
+#if 0
+    if (e<0) {
+       set_font_param(k, quad_code, -round_xn_over_d(quad(k), 1000-e, 1000));
+    } else {
+       set_font_param(k, quad_code, round_xn_over_d(quad(k), 1000+e, 1000));
+    }
+#endif
+    return k;
+}
+
+internal_font_number copy_font_info(internal_font_number f)
+{
+    return copy_font(f);
+}
diff --git a/texk/web2c/luatexdir/font/vfpacket.c b/texk/web2c/luatexdir/font/vfpacket.c
new file mode 100644
index 000000000..41132c54a
--- /dev/null
+++ b/texk/web2c/luatexdir/font/vfpacket.c
@@ -0,0 +1,445 @@
+/*
+
+Copyright 1996-2006 Han The Thanh <thanh@pdftex.org>
+Copyright 2006-2013 Taco Hoekwater <taco@luatex.org>
+
+This file is part of LuaTeX.
+
+LuaTeX is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 2 of the License, or (at your
+option) any later version.
+
+LuaTeX is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+License for more details.
+
+You should have received a copy of the GNU General Public License along
+with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#include "ptexlib.h"
+#include "lua/luatex-api.h"
+
+/*tex
+
+    Some macros for processing character packets.
+
+*/
+
+#define packet_number(fw) {    \
+    fw = *(vfp++);             \
+    fw = fw * 256 + *(vfp++);  \
+    fw = fw * 256 + *(vfp++);  \
+    fw = fw * 256 + *(vfp++);  \
+}
+
+#define packet_scaled(a, fs) {  \
+    int fw;                     \
+    fw = *(vfp++);              \
+    if (fw > 127)               \
+        fw = fw - 256;          \
+    fw = fw * 256 + *(vfp++);   \
+    fw = fw * 256 + *(vfp++);   \
+    fw = fw * 256 + *(vfp++);   \
+    a = store_scaled_f(fw, fs); \
+}
+
+vf_struct *new_vfstruct(void)
+{
+    vf_struct *vp = (vf_struct *) xmalloc(sizeof(vf_struct));
+    vp->packet_stack_level = vp->packet_stack_minlevel = 0;
+    vp->packet_stack = (packet_stack_record *) xmalloc(packet_stack_size * sizeof(packet_stack_record));
+    vp->lf = 0;
+    vp->fs_f = 0;
+    vp->packet_cur_s = 0;
+    vp->refpos = NULL;
+    vp->vflua = false;
+    return vp;
+}
+
+/*tex
+
+     Count the number of bytes in a command packet.
+*/
+
+int vf_packet_bytes(charinfo * co)
+{
+    eight_bits *vf_packets, *vfp;
+    unsigned k;
+    int cmd;
+    vfp = vf_packets = get_charinfo_packets(co);
+    if (vf_packets == NULL) {
+        return 0;
+    }
+    while ((cmd = *(vfp++)) != packet_end_code) {
+        switch (cmd) {
+        case packet_nop_code:
+        case packet_pop_code:
+        case packet_push_code:
+            break;
+        case packet_char_code:
+        case packet_down_code:
+        case packet_font_code:
+        case packet_image_code:
+        case packet_node_code:
+        case packet_right_code:
+            vfp += 4;
+            break;
+        case packet_rule_code:
+            vfp += 8;
+            break;
+        case packet_pdf_mode:
+            vfp += 4;
+            break;
+        case packet_pdf_code:
+            vfp += 4;
+            /*tex Plus a string so we fall through: */
+        case packet_special_code:
+            /*tex |+4| */
+            packet_number(k);
+            vfp += (int) k;
+            break;
+        default:
+            normal_error("vf", "invalid DVI command (1)");
+        }
+    };
+    return (vfp - vf_packets);
+}
+
+/*tex
+
+    Typeset the \.{DVI} commands in the character packet for character |c| in
+    current font |f|.
+*/
+
+const char *packet_command_names[] = {
+    /*tex |slot| maps to |char| and |font| */
+    "char",
+    "font",
+    "pop",
+    "push",
+    "special",
+    "image",
+    "right",
+    "down",
+    "rule",
+    "node",
+    "nop",
+    "end",
+    /*tex the next one is not (yet) supported */
+    "scale",
+    "lua",
+    "pdf",
+    NULL
+};
+
+static float packet_float(eight_bits ** vfpp)
+{
+    unsigned int i;
+    union U {
+        float a;
+        eight_bits b[sizeof(float)];
+    } u;
+    eight_bits *vfp = *vfpp;
+    for (i = 0; i < sizeof(float); i++)
+        u.b[i] = *(vfp++);
+    *vfpp = vfp;
+    return u.a;
+}
+
+/*tex
+
+    The |do_vf_packet| procedure is called in order to interpret the character
+    packet for a virtual character. Such a packet may contain the instruction to
+    typeset a character from the same or an other virtual font; in such cases
+    |do_vf_packet| calls itself recursively. The recursion level, i.e., the
+    number of times this has happened, is kept in the global variable
+    |packet_cur_s| and should not exceed |packet_max_recursion|.
+*/
+
+void do_vf_packet(PDF pdf, internal_font_number vf_f, int c, int ex_glyph)
+{
+    eight_bits *vfp;
+    posstructure *save_posstruct, localpos;
+    vf_struct *save_vfstruct, localvfstruct, *vp;
+    int cmd, w, mode;
+    unsigned k;
+    scaledpos size;
+    scaled i;
+    str_number s;
+    float f;
+    packet_stack_record *mat_p;
+    vfp = get_charinfo_packets(get_charinfo(vf_f, c));
+    save_posstruct = pdf->posstruct;
+    /*tex use local structure for recursion */
+    pdf->posstruct = &localpos;
+    localpos.pos = save_posstruct->pos;
+    /*tex invariably for vf */
+    localpos.dir = dir_TLT;
+    save_vfstruct = pdf->vfstruct;
+    vp = pdf->vfstruct = &localvfstruct;
+    localvfstruct = *save_vfstruct;
+    vp->packet_stack_minlevel = ++(vp->packet_stack_level);
+    vp->lf = 0;
+    vp->fs_f = font_size(vf_f);
+    vp->ex_glyph = ex_glyph;
+    vp->packet_cur_s++;
+    if (vp->packet_cur_s == packet_max_recursion)
+        overflow("max level recursion of virtual fonts", packet_max_recursion);
+    vp->refpos = save_posstruct;
+    vp->vflua = false;
+    mat_p = &(vp->packet_stack[vp->packet_stack_level]);
+    mat_p->c0 = 1.0;
+    mat_p->c1 = 0.0;
+    mat_p->c2 = 0.0;
+    mat_p->c3 = 1.0;
+    mat_p->pos.h = 0;
+    mat_p->pos.v = 0;
+    while ((cmd = *(vfp++)) != packet_end_code) {
+        switch (cmd) {
+            case packet_font_code:
+                packet_number(vp->lf);
+                break;
+            case packet_push_code:
+                vp->packet_stack_level++;
+                if (vp->packet_stack_level == packet_stack_size)
+                    normal_error("vf", "packet_stack_level overflow");
+                vp->packet_stack[vp->packet_stack_level] = *mat_p;
+                mat_p = &(vp->packet_stack[vp->packet_stack_level]);
+                break;
+            case packet_pop_code:
+                if (vp->packet_stack_level == vp->packet_stack_minlevel)
+                    normal_error("vf", "packet_stack_level underflow");
+                vp->packet_stack_level--;
+                mat_p = &(vp->packet_stack[vp->packet_stack_level]);
+                break;
+            case packet_char_code:
+                packet_number(k);
+                /*tex We also check if |c == k| and |font(c) == font(k)| */
+                if (!char_exists(vp->lf, (int) k)) {
+                    char_warning(vp->lf, (int) k);
+                } else if (! ((c == k && vp->lf == vf_f)) && (has_packet(vp->lf, (int) k))) {
+                    do_vf_packet(pdf, vp->lf, (int) k, ex_glyph);
+                } else {
+                    backend_out[glyph_node] (pdf, vp->lf, (int) k, ex_glyph);
+                }
+                w = char_width(vp->lf, (int) k);
+                if (ex_glyph != 0 && w != 0)
+                    w = round_xn_over_d(w, 1000 + ex_glyph, 1000);
+                mat_p->pos.h += w;
+                break;
+            case packet_rule_code:
+                packet_scaled(size.v, vp->fs_f);
+                packet_scaled(size.h, vp->fs_f);
+                if (ex_glyph != 0 && size.h > 0)
+                    size.h = round_xn_over_d(size.h, 1000 + ex_glyph, 1000);
+                if (size.h > 0 && size.v > 0)
+                    backend_out[rule_node](pdf, 0, size);
+                mat_p->pos.h += size.h;
+                break;
+            case packet_right_code:
+                packet_scaled(i, vp->fs_f);
+                if (ex_glyph != 0 && i != 0)
+                    i = round_xn_over_d(i, 1000 + ex_glyph, 1000);
+                mat_p->pos.h += i;
+                break;
+            case packet_down_code:
+                packet_scaled(i, vp->fs_f);
+                mat_p->pos.v += i;
+                break;
+            case packet_pdf_code:
+                packet_number(mode);
+                packet_number(k);
+                str_room(k);
+                while (k > 0) {
+                    k--;
+                    append_char(*(vfp++));
+                }
+                s = make_string();
+                pdf_literal(pdf, s, mode, false);
+                flush_str(s);
+                break;
+            case packet_pdf_mode:
+                packet_number(mode);
+                pdf_literal_set_mode(pdf, mode);
+                break;
+            case packet_special_code:
+                packet_number(k);
+                str_room(k);
+                while (k > 0) {
+                    k--;
+                    append_char(*(vfp++));
+                }
+                s = make_string();
+                pdf_literal(pdf, s, scan_special, false);
+                flush_str(s);
+                break;
+            case packet_lua_code:
+                packet_number(k);
+                vp->vflua = true;
+                luacall_vf(k, vf_f, c);
+                /*tex
+
+                    We don't release as we (can ) flush multiple times, so no:
+
+                    \starttyping
+                    luaL_unref(Luas, LUA_REGISTRYINDEX, k);
+                    \stoptyping
+
+                    here!
+
+                */
+                vp->vflua = false;
+                break;
+            case packet_image_code:
+                packet_number(k);
+                vf_out_image(pdf, k);
+                break;
+            case packet_node_code:
+                packet_number(k);
+                hlist_out(pdf, (halfword) k, 0);
+                break;
+            case packet_nop_code:
+                break;
+            case packet_scale_code:
+                /*tex This is not yet supported in the backend. */
+                f = packet_float(&vfp);
+                mat_p->c0 = mat_p->c0 * f;
+                mat_p->c3 = mat_p->c3 * f;
+                /* pdf->pstruct->scale = f; */
+                pdf->pstruct->need_tm = true;
+                pdf->pstruct->need_tf = true;
+                break;
+            default:
+                normal_error("vf", "invalid DVI command (2)");
+        }
+        /*tex The trivial case, always |TLT|. */
+        synch_pos_with_cur(&localpos, save_posstruct, mat_p->pos);
+    }
+    pdf->posstruct = save_posstruct;
+    pdf->vfstruct = save_vfstruct;
+}
+
+int *packet_local_fonts(internal_font_number f, int *num)
+{
+    int c, cmd, lf, k, l, i;
+    int localfonts[256] = { 0 };
+    int *lfs;
+    charinfo *co;
+    eight_bits *vf_packets, *vfp;
+    k = 0;
+    for (c = font_bc(f); c <= font_ec(f); c++) {
+        if (quick_char_exists(f, c)) {
+            co = get_charinfo(f, c);
+            vfp = vf_packets = get_charinfo_packets(co);
+            if (vf_packets == NULL)
+                continue;
+            while ((cmd = *(vfp++)) != packet_end_code) {
+                switch (cmd) {
+                    case packet_font_code:
+                        packet_number(lf);
+                        for (l = 0; l < k; l++) {
+                            if (localfonts[l] == lf) {
+                                break;
+                            }
+                        }
+                        if (l == k) {
+                            localfonts[k++] = lf;
+                        }
+                        break;
+                    case packet_nop_code:
+                    case packet_pop_code:
+                    case packet_push_code:
+                        break;
+                    case packet_char_code:
+                    case packet_down_code:
+                    case packet_image_code:
+                    case packet_node_code:
+                    case packet_right_code:
+                        vfp += 4;
+                        break;
+                    case packet_rule_code:
+                        vfp += 8;
+                        break;
+                    case packet_special_code:
+                        packet_number(i);
+                        vfp += i;
+                        break;
+                    default:
+                        normal_error("vf", "invalid DVI command (3)");
+                }
+            }
+        }
+    }
+    *num = k;
+    if (k > 0) {
+        lfs = xmalloc((unsigned) ((unsigned) k * sizeof(int)));
+        memcpy(lfs, localfonts, (size_t) ((unsigned) k * sizeof(int)));
+        return lfs;
+    }
+    return NULL;
+}
+
+void replace_packet_fonts(internal_font_number f, int *old_fontid, int *new_fontid, int count)
+{
+    int c, cmd, lf, k, l;
+    charinfo *co;
+    eight_bits *vf_packets, *vfp;
+    for (c = font_bc(f); c <= font_ec(f); c++) {
+        if (quick_char_exists(f, c)) {
+            co = get_charinfo(f, c);
+            vfp = vf_packets = get_charinfo_packets(co);
+            if (vf_packets == NULL)
+                continue;
+            while ((cmd = *(vfp++)) != packet_end_code) {
+                switch (cmd) {
+                    case packet_font_code:
+                        packet_number(lf);
+                        for (l = 0; l < count; l++) {
+                            if (old_fontid[l] == lf) {
+                                break;
+                            }
+                        }
+                        if (l < count) {
+                            k = new_fontid[l];
+                            *(vfp - 4) = (eight_bits)
+                                ((k & 0xFF000000) >> 24);
+                            *(vfp - 3) = (eight_bits)
+                                ((k & 0x00FF0000) >> 16);
+                            *(vfp - 2) = (eight_bits)
+                                ((k & 0x0000FF00) >> 8);
+                            *(vfp - 1) = (eight_bits) (k & 0x000000FF);
+                        }
+                        break;
+                    case packet_nop_code:
+                    case packet_pop_code:
+                    case packet_push_code:
+                        break;
+                    case packet_char_code:
+                    case packet_down_code:
+                    case packet_image_code:
+                    case packet_node_code:
+                    case packet_right_code:
+                    case packet_rule_code:
+                        vfp += 8;
+                        break;
+                    case packet_pdf_mode:
+                        vfp += 4;
+                        break;
+                    case packet_pdf_code:
+                        vfp += 4;
+                        /*tex Plus a string so we fall through. */
+                    case packet_special_code:
+                        packet_number(k);
+                        vfp += k;
+                        break;
+                    default:
+                        normal_error("vf", "invalid DVI command (4)");
+                }
+            }
+        }
+    }
+}
diff --git a/texk/web2c/luatexdir/font/vfpacket.w b/texk/web2c/luatexdir/font/vfpacket.w
deleted file mode 100644
index d2329916a..000000000
--- a/texk/web2c/luatexdir/font/vfpacket.w
+++ /dev/null
@@ -1,424 +0,0 @@
-% vfpacket.w
-%
-% Copyright 1996-2006 Han The Thanh <thanh@@pdftex.org>
-% Copyright 2006-2013 Taco Hoekwater <taco@@luatex.org>
-%
-% This file is part of LuaTeX.
-%
-% LuaTeX is free software; you can redistribute it and/or modify it under
-% the terms of the GNU General Public License as published by the Free
-% Software Foundation; either version 2 of the License, or (at your
-% option) any later version.
-%
-% LuaTeX is distributed in the hope that it will be useful, but WITHOUT
-% ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-% FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
-% License for more details.
-%
-% You should have received a copy of the GNU General Public License along
-% with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
-
-@ @c
-
-
-#include "ptexlib.h"
-
-@ Some macros for processing character packets.
-@c
-#define packet_number(fw) {    \
-    fw = *(vfp++);             \
-    fw = fw * 256 + *(vfp++);  \
-    fw = fw * 256 + *(vfp++);  \
-    fw = fw * 256 + *(vfp++);  \
-}
-
-#define packet_scaled(a, fs) {  \
-    int fw;                     \
-    fw = *(vfp++);              \
-    if (fw > 127)               \
-        fw = fw - 256;          \
-    fw = fw * 256 + *(vfp++);   \
-    fw = fw * 256 + *(vfp++);   \
-    fw = fw * 256 + *(vfp++);   \
-    a = store_scaled_f(fw, fs); \
-}
-
-@ @c
-vf_struct *new_vfstruct(void)
-{
-    vf_struct *vp = (vf_struct *) xmalloc(sizeof(vf_struct));
-    vp->packet_stack_level = vp->packet_stack_minlevel = 0;
-    vp->packet_stack =
-        (packet_stack_record *) xmalloc(packet_stack_size *
-                                        sizeof(packet_stack_record));
-    vp->lf = 0;
-    vp->fs_f = 0;
-    vp->packet_cur_s = 0;
-    vp->refpos = NULL;
-    vp->vflua = false;
-    return vp;
-}
-
-@ Count the number of bytes in a command packet.
-@c
-int vf_packet_bytes(charinfo * co)
-{
-    eight_bits *vf_packets, *vfp;
-    unsigned k;
-    int cmd;
-
-    vfp = vf_packets = get_charinfo_packets(co);
-    if (vf_packets == NULL) {
-        return 0;
-    }
-    while ((cmd = *(vfp++)) != packet_end_code) {
-        switch (cmd) {
-        case packet_nop_code:
-        case packet_pop_code:
-        case packet_push_code:
-            break;
-        case packet_char_code:
-        case packet_down_code:
-        case packet_font_code:
-        case packet_image_code:
-        case packet_node_code:
-        case packet_right_code:
-        case packet_rule_code:
-            vfp += 8;
-            break;
-        case packet_pdf_mode:
-            vfp += 4;
-            break;
-        case packet_pdf_code:
-            vfp += 4;
-            /* plus a string so we fall through */
-        case packet_special_code:
-            packet_number(k);   /* +4 */
-            vfp += (int) k;
-            break;
-        default:
-            normal_error("vf", "invalid DVI command (1)");
-        }
-    };
-    return (vfp - vf_packets);
-}
-
-@ Typeset the \.{DVI} commands in the character packet
-  for character |c| in current font |f|.
-@c
-const char *packet_command_names[] = {
-    "char", "font", "pop", "push", "special", "image",
-    "right", "down", "rule", "node", "nop", "end", "scale", "lua", "pdf", NULL
-};
-
-@ @c
-static float packet_float(eight_bits ** vfpp)
-{
-    unsigned int i;
-    union U {
-        float a;
-        eight_bits b[sizeof(float)];
-    } u;
-    eight_bits *vfp = *vfpp;
-    for (i = 0; i < sizeof(float); i++)
-        u.b[i] = *(vfp++);
-    *vfpp = vfp;
-    return u.a;
-}
-
-@ The |do_vf_packet| procedure is called in order to interpret the
-  character packet for a virtual character. Such a packet may contain
-  the instruction to typeset a character from the same or an other
-  virtual font; in such cases |do_vf_packet| calls itself
-  recursively. The recursion level, i.e., the number of times this has
-  happened, is kept in the global variable |packet_cur_s| and should
-  not exceed |packet_max_recursion|.
-@c
-void do_vf_packet(PDF pdf, internal_font_number vf_f, int c, int ex_glyph)
-{
-    eight_bits *vfp;
-    posstructure *save_posstruct, localpos;
-    vf_struct *save_vfstruct, localvfstruct, *vp;
-    int cmd, w, mode;
-    unsigned k;
-    scaledpos size;
-    scaled i;
-    str_number s;
-    float f;
-    packet_stack_record *mat_p;
-
-    vfp = get_charinfo_packets(get_charinfo(vf_f, c));
-    assert(vfp != NULL);
-
-    save_posstruct = pdf->posstruct;
-    pdf->posstruct = &localpos; /* use local structure for recursion */
-    localpos.pos = save_posstruct->pos;
-    localpos.dir = dir_TLT;     /* invariably for vf */
-
-    save_vfstruct = pdf->vfstruct;
-    vp = pdf->vfstruct = &localvfstruct;
-    localvfstruct = *save_vfstruct;
-
-    vp->packet_stack_minlevel = ++(vp->packet_stack_level);
-    vp->lf = 0;
-    vp->fs_f = font_size(vf_f);
-    vp->ex_glyph = ex_glyph;
-    vp->packet_cur_s++;
-    if (vp->packet_cur_s == packet_max_recursion)
-        overflow("max level recursion of virtual fonts", packet_max_recursion);
-    vp->refpos = save_posstruct;
-    vp->vflua = false;
-
-    mat_p = &(vp->packet_stack[vp->packet_stack_level]);
-    mat_p->c0 = 1.0;
-    mat_p->c1 = 0.0;
-    mat_p->c2 = 0.0;
-    mat_p->c3 = 1.0;
-    mat_p->pos.h = 0;
-    mat_p->pos.v = 0;
-
-    while ((cmd = *(vfp++)) != packet_end_code) {
-#ifdef DEBUG
-        if (cmd > packet_end_code) {
-            fprintf(stdout, "do_vf_packet(%i,%i) command code = illegal \n",
-                    vf_f, c);
-        } else {
-            fprintf(stdout, "do_vf_packet(%i,%i) command code = %s\n", vf_f, c,
-                    packet_command_names[cmd]);
-        }
-#endif
-        switch (cmd) {
-        case packet_font_code:
-            packet_number(vp->lf);
-            break;
-        case packet_push_code:
-            vp->packet_stack_level++;
-            if (vp->packet_stack_level == packet_stack_size)
-                normal_error("vf", "packet_stack_level overflow");
-            vp->packet_stack[vp->packet_stack_level] = *mat_p;
-            mat_p = &(vp->packet_stack[vp->packet_stack_level]);
-            break;
-        case packet_pop_code:
-            if (vp->packet_stack_level == vp->packet_stack_minlevel)
-                normal_error("vf", "packet_stack_level underflow");
-            vp->packet_stack_level--;
-            mat_p = &(vp->packet_stack[vp->packet_stack_level]);
-            break;
-        case packet_char_code:
-            packet_number(k);
-            /* we also check if c == k and font(c) == font)k) */
-            if (!char_exists(vp->lf, (int) k)) {
-                char_warning(vp->lf, (int) k);
-            } else if (! ((c == k && vp->lf == vf_f)) && (has_packet(vp->lf, (int) k))) {
-                do_vf_packet(pdf, vp->lf, (int) k, ex_glyph);
-            } else {
-                backend_out[glyph_node] (pdf, vp->lf, (int) k, ex_glyph);
-            }
-            w = char_width(vp->lf, (int) k);
-            mat_p->pos.h += round_xn_over_d(w, 1000 + ex_glyph, 1000);
-            break;
-        case packet_rule_code:
-            packet_scaled(size.v, vp->fs_f);    /* height (where is depth?) */
-            packet_scaled(size.h, vp->fs_f);
-            if (size.h > 0 && size.v > 0)
-                backend_out[rule_node](pdf, 0, size);  /* the 0 is unused */
-            mat_p->pos.h += size.h;
-            break;
-        case packet_right_code:
-            packet_scaled(i, vp->fs_f);
-            mat_p->pos.h += i;
-            break;
-        case packet_down_code:
-            packet_scaled(i, vp->fs_f);
-            mat_p->pos.v += i;
-            break;
-        case packet_pdf_code:
-            packet_number(mode);
-            packet_number(k);
-            str_room(k);
-            while (k > 0) {
-                k--;
-                append_char(*(vfp++));
-            }
-            s = make_string();
-            pdf_literal(pdf, s, mode, false);
-            flush_str(s);
-            break;
-        case packet_pdf_mode:
-            packet_number(mode);
-            pdf_literal_set_mode(pdf, mode);
-            break;
-        case packet_special_code:
-            packet_number(k);
-            str_room(k);
-            while (k > 0) {
-                k--;
-                append_char(*(vfp++));
-            }
-            s = make_string();
-            pdf_literal(pdf, s, scan_special, false);
-            flush_str(s);
-            break;
-        case packet_lua_code:
-            packet_number(k);
-            vp->vflua = true;
-            if (luaL_loadbuffer
-                (Luas, (const char *) vfp, (size_t) k, "packet_lua_code")
-                || lua_pcall(Luas, 0, LUA_MULTRET, 0))
-                lua_error(Luas);
-            vp->vflua = false;
-            vfp += k;
-            break;
-        case packet_image_code:
-            packet_number(k);
-            vf_out_image(pdf, k);
-            break;
-        case packet_node_code:
-            packet_number(k);
-            hlist_out(pdf, (halfword) k, 0);
-            break;
-        case packet_nop_code:
-            break;
-        case packet_scale_code:
-            f = packet_float(&vfp);
-            mat_p->c0 = mat_p->c0 * f;
-            mat_p->c3 = mat_p->c3 * f;
-            /* pdf->pstruct->scale = f; *//* scale is still NOP */
-            pdf->pstruct->need_tm = true;
-            pdf->pstruct->need_tf = true;
-            break;
-        default:
-            normal_error("vf", "invalid DVI command (2)");
-        }
-        synch_pos_with_cur(&localpos, save_posstruct, mat_p->pos);      /* trivial case, always TLT */
-    }
-    pdf->posstruct = save_posstruct;
-    pdf->vfstruct = save_vfstruct;
-}
-
-@ @c
-int *packet_local_fonts(internal_font_number f, int *num)
-{
-    int c, cmd, lf, k, l, i;
-    int localfonts[256] = { 0 };
-    int *lfs;
-    charinfo *co;
-
-    eight_bits *vf_packets, *vfp;
-    k = 0;
-    for (c = font_bc(f); c <= font_ec(f); c++) {
-        if (quick_char_exists(f, c)) {
-            co = get_charinfo(f, c);
-            vfp = vf_packets = get_charinfo_packets(co);
-            if (vf_packets == NULL)
-                continue;
-            while ((cmd = *(vfp++)) != packet_end_code) {
-                switch (cmd) {
-                case packet_font_code:
-                    packet_number(lf);
-                    for (l = 0; l < k; l++) {
-                        if (localfonts[l] == lf) {
-                            break;
-                        }
-                    }
-                    if (l == k) {
-                        localfonts[k++] = lf;
-                    }
-                    break;
-                case packet_nop_code:
-                case packet_pop_code:
-                case packet_push_code:
-                    break;
-                case packet_char_code:
-                case packet_down_code:
-                case packet_image_code:
-                case packet_node_code:
-                case packet_right_code:
-                    vfp += 4;
-                    break;
-                case packet_rule_code:
-                    vfp += 8;
-                    break;
-                case packet_special_code:
-                    packet_number(i);
-                    vfp += i;
-                    break;
-                default:
-                    normal_error("vf", "invalid DVI command (3)");
-                }
-            }
-        }
-    }
-    *num = k;
-    if (k > 0) {
-        lfs = xmalloc((unsigned) ((unsigned) k * sizeof(int)));
-        memcpy(lfs, localfonts, (size_t) ((unsigned) k * sizeof(int)));
-        return lfs;
-    }
-    return NULL;
-}
-
-@ @c
-void
-replace_packet_fonts(internal_font_number f, int *old_fontid,
-                     int *new_fontid, int count)
-{
-    int c, cmd, lf, k, l;
-    charinfo *co;
-    eight_bits *vf_packets, *vfp;
-
-    for (c = font_bc(f); c <= font_ec(f); c++) {
-        if (quick_char_exists(f, c)) {
-            co = get_charinfo(f, c);
-            vfp = vf_packets = get_charinfo_packets(co);
-            if (vf_packets == NULL)
-                continue;
-            while ((cmd = *(vfp++)) != packet_end_code) {
-                switch (cmd) {
-                case packet_font_code:
-                    packet_number(lf);
-                    for (l = 0; l < count; l++) {
-                        if (old_fontid[l] == lf) {
-                            break;
-                        }
-                    }
-                    if (l < count) {
-                        k = new_fontid[l];
-                        *(vfp - 4) = (eight_bits)
-                            ((k & 0xFF000000) >> 24);
-                        *(vfp - 3) = (eight_bits)
-                            ((k & 0x00FF0000) >> 16);
-                        *(vfp - 2) = (eight_bits)
-                            ((k & 0x0000FF00) >> 8);
-                        *(vfp - 1) = (eight_bits) (k & 0x000000FF);
-                    }
-                    break;
-                case packet_nop_code:
-                case packet_pop_code:
-                case packet_push_code:
-                    break;
-                case packet_char_code:
-                case packet_down_code:
-                case packet_image_code:
-                case packet_node_code:
-                case packet_right_code:
-                case packet_rule_code:
-                    vfp += 8;
-                    break;
-                case packet_pdf_mode:
-                    vfp += 4;
-                    break;
-                case packet_pdf_code:
-                    vfp += 4;
-                    /* plus a string so we fall through */
-                case packet_special_code:
-                    packet_number(k);
-                    vfp += k;
-                    break;
-                default:
-                    normal_error("vf", "invalid DVI command (4)");
-                }
-            }
-        }
-    }
-}
diff --git a/texk/web2c/luatexdir/font/writeenc.w b/texk/web2c/luatexdir/font/writeenc.c
similarity index 71%
rename from texk/web2c/luatexdir/font/writeenc.w
rename to texk/web2c/luatexdir/font/writeenc.c
index 1a7ed3891..554c246a5 100644
--- a/texk/web2c/luatexdir/font/writeenc.w
+++ b/texk/web2c/luatexdir/font/writeenc.c
@@ -1,34 +1,37 @@
-% writeenc.w
-%
-% Copyright 1996-2006 Han The Thanh <thanh@@pdftex.org>
-% Copyright 2006-2011 Taco Hoekwater <taco@@luatex.org>
-%
-% This file is part of LuaTeX.
-%
-% LuaTeX is free software; you can redistribute it and/or modify it under
-% the terms of the GNU General Public License as published by the Free
-% Software Foundation; either version 2 of the License, or (at your
-% option) any later version.
-%
-% LuaTeX is distributed in the hope that it will be useful, but WITHOUT
-% ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-% FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
-% License for more details.
-%
-% You should have received a copy of the GNU General Public License along
-% with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
-
-@ @c
+/*
 
+Copyright 1996-2006 Han The Thanh <thanh@pdftex.org>
+Copyright 2006-2011 Taco Hoekwater <taco@luatex.org>
+
+This file is part of LuaTeX.
+
+LuaTeX is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 2 of the License, or (at your
+option) any later version.
+
+LuaTeX is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+License for more details.
+
+You should have received a copy of the GNU General Public License along
+with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+
+*/
 
 #include "ptexlib.h"
 
-@ All encoding entries go into AVL tree for fast search by name.
-@c
+/*tex
+
+    All encoding entries go into AVL tree for fast search by name.
+
+*/
+
 struct avl_table *fe_tree = NULL;
 
-@ AVL sort |fe_entry| into |fe_tree| by name
-@c
+/* The AVL sort |fe_entry| into |fe_tree| by name. */
+
 static int comp_fe_entry(const void *pa, const void *pb, void *p)
 {
     (void) p;
@@ -41,7 +44,8 @@ static fe_entry *new_fe_entry(void)
     fe = xtalloc(1, fe_entry);
     fe->name = NULL;
     fe->fe_objnum = 0;
-    fe->glyph_names = NULL;     /* encoding file not yet read in */
+    /*tex The encoding file is not yet read in. */
+    fe->glyph_names = NULL;
     fe->tx_tree = NULL;
     return fe;
 }
@@ -67,7 +71,8 @@ static void register_fe_entry(fe_entry * fe)
     }
     assert(fe != NULL);
     assert(fe->name != NULL);
-    assert(lookup_fe_entry(fe->name) == NULL);  /* encoding not yet registered */
+    /*tex The encoding is not yet registered. */
+    assert(lookup_fe_entry(fe->name) == NULL);
     aa = avl_probe(fe_tree, fe);
     assert(aa != NULL);
 }
@@ -85,9 +90,7 @@ fe_entry *get_fe_entry(char *s)
     return fe;
 }
 
-@ @c
-static void write_enc(PDF pdf, char **glyph_names, struct avl_table *tx_tree,
-                      int fe_objnum)
+static void write_enc(PDF pdf, char **glyph_names, struct avl_table *tx_tree, int fe_objnum)
 {
     int i_old, *p;
     struct avl_traverser t;
@@ -102,9 +105,9 @@ static void write_enc(PDF pdf, char **glyph_names, struct avl_table *tx_tree,
     avl_t_init(&t, tx_tree);
     for (i_old = -2, p = (int *) avl_t_first(&t, tx_tree); p != NULL;
          p = (int *) avl_t_next(&t)) {
-        if (*p == i_old + 1)    /* consecutive */
+        if (*p == i_old + 1) {
             pdf_add_name(pdf, glyph_names[*p]);
-        else {
+        } else {
             pdf_add_int(pdf, *p);
             pdf_add_name(pdf, glyph_names[*p]);
         }
@@ -134,8 +137,7 @@ void write_fontencodings(PDF pdf)
             write_fontencoding(pdf, fe);
 }
 
-@ cleaning up...
-@c
+/*tex Cleaning up \unknown */
 
 static void destroy_fe_entry(void *pa, void *pb)
 {
diff --git a/texk/web2c/luatexdir/font/writefont.w b/texk/web2c/luatexdir/font/writefont.c
similarity index 65%
rename from texk/web2c/luatexdir/font/writefont.w
rename to texk/web2c/luatexdir/font/writefont.c
index 2ba81d617..5d75ef80c 100644
--- a/texk/web2c/luatexdir/font/writefont.w
+++ b/texk/web2c/luatexdir/font/writefont.c
@@ -1,69 +1,69 @@
-% writefont.w
-%
-% Copyright 1996-2006 Han The Thanh <thanh@@pdftex.org>
-% Copyright 2006-2010 Taco Hoekwater <taco@@luatex.org>
-%
-% This file is part of LuaTeX.
-%
-% LuaTeX is free software; you can redistribute it and/or modify it under
-% the terms of the GNU General Public License as published by the Free
-% Software Foundation; either version 2 of the License, or (at your
-% option) any later version.
-%
-% LuaTeX is distributed in the hope that it will be useful, but WITHOUT
-% ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-% FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
-% License for more details.
-%
-% You should have received a copy of the GNU General Public License along
-% with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
-
-@ @c
+/*
+
+Copyright 1996-2006 Han The Thanh <thanh@pdftex.org>
+Copyright 2006-2010 Taco Hoekwater <taco@luatex.org>
+
+This file is part of LuaTeX.
+
+LuaTeX is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 2 of the License, or (at your
+option) any later version.
+
+LuaTeX is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+License for more details.
 
+You should have received a copy of the GNU General Public License along
+with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+
+*/
 
 #include "ptexlib.h"
 #include "lua/luatex-api.h"
 
 void write_cid_fontdictionary(PDF pdf, fo_entry * fo, internal_font_number f);
+
 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 },
+    { "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 }
+    { "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 */
+/*tex A tree of font dictionaries: */
+
+struct avl_table *fo_tree = NULL;
+
+/*tex A tree of font descriptor objects: */
+
+struct avl_table *fd_tree = NULL;
 
 static int comp_fo_entry(const void *pa, const void *pb, void *p)
 {
     (void) p;
-    return strcmp(((const fo_entry *) pa)->fm->tfm_name,
-                  ((const fo_entry *) pb)->fm->tfm_name);
+    return strcmp(((const fo_entry *) pa)->fm->tfm_name, ((const fo_entry *) pb)->fm->tfm_name);
 }
 
 static int comp_fd_entry(const void *pa, const void *pb, void *p)
 {
     const fd_entry *p1 = (const fd_entry *) pa, *p2 = (const fd_entry *) pb;
     (void) p;
-    assert(p1->fm != NULL && is_fontfile(p1->fm) &&
-           p2->fm != NULL && is_fontfile(p2->fm));
     return strcmp(p1->fm->ff_name, p2->fm->ff_name);
 }
 
-@ initialize data structure for /Type /Font
-@c
+/*tex We initialize data structure for |/Type| |/Font|: */
+
 static fo_entry *new_fo_entry(void)
 {
     fo_entry *fo;
@@ -81,8 +81,8 @@ static fo_entry *new_fo_entry(void)
     return fo;
 }
 
-@ initialize data structure for /Type /FontDescriptor
-@c
+/*tex We initialize data structure for |/Type| |/FontDescriptor|: */
+
 fd_entry *new_fd_entry(internal_font_number f)
 {
     fd_entry *fd;
@@ -108,12 +108,14 @@ fd_entry *new_fd_entry(internal_font_number f)
     return fd;
 }
 
-@
-Only fallback values of font metrics are taken from the TFM info
-of |f| by |preset_fontmetrics|. During reading of the font file,
-these values are replaced by metrics from the font, if available.
+/*tex
+
+    Only fallback values of font metrics are taken from the TFM info of |f| by
+    |preset_fontmetrics|. During reading of the font file, these values are
+    replaced by metrics from the font, if available.
+
+*/
 
-@c
 static void preset_fontmetrics(fd_entry * fd, internal_font_number f)
 {
     int i;
@@ -143,9 +145,7 @@ static void fix_fontmetrics(fd_entry * fd)
 {
     int i;
     intparm *p = (intparm *) fd->font_dim;
-    assert(p[FONTBBOX1_CODE].set && p[FONTBBOX2_CODE].set
-           && p[FONTBBOX3_CODE].set && p[FONTBBOX4_CODE].set);
-    /* make sure there is a rectangle */
+    /*tex Make sure there is a rectangle. */
     if (p[FONTBBOX3_CODE].val < p[FONTBBOX1_CODE].val) {
         i = p[FONTBBOX3_CODE].val;
         p[FONTBBOX3_CODE].val = p[FONTBBOX1_CODE].val;
@@ -178,34 +178,41 @@ static void write_fontmetrics(PDF pdf, fd_entry * fd)
     fix_fontmetrics(fd);
     pdf_add_name(pdf, font_key[FONTBBOX1_CODE].pdfname);
     pdf_begin_array(pdf);
-    pdf_printf(pdf, "%i %i %i %i", (int) fd->font_dim[FONTBBOX1_CODE].val,
-               (int) fd->font_dim[FONTBBOX2_CODE].val,
-               (int) fd->font_dim[FONTBBOX3_CODE].val,
-               (int) fd->font_dim[FONTBBOX4_CODE].val);
+    /*
+    pdf_check_space;
+    pdf_printf(pdf, "%i %i %i %i",
+        (int) fd->font_dim[FONTBBOX1_CODE].val,
+        (int) fd->font_dim[FONTBBOX2_CODE].val,
+        (int) fd->font_dim[FONTBBOX3_CODE].val,
+        (int) fd->font_dim[FONTBBOX4_CODE].val);
+    */
+    pdf_add_int(pdf,(int) fd->font_dim[FONTBBOX1_CODE].val);
+    pdf_add_int(pdf,(int) fd->font_dim[FONTBBOX2_CODE].val);
+    pdf_add_int(pdf,(int) fd->font_dim[FONTBBOX3_CODE].val);
+    pdf_add_int(pdf,(int) fd->font_dim[FONTBBOX4_CODE].val);
+    /* */
     pdf_end_array(pdf);
     for (i = 0; i < GEN_KEY_NUM; i++)
         if (fd->font_dim[i].set)
             pdf_dict_add_int(pdf, font_key[i].pdfname, fd->font_dim[i].val);
 }
 
-@
-@c
 static void preset_fontname(fo_entry * fo, internal_font_number f)
 {
-    if (fo->fm->ps_name != NULL)
-        fo->fd->fontname = xstrdup(fo->fm->ps_name);    /* just fallback */
-    else if (font_fullname(f) != NULL)
+    if (fo->fm->ps_name != NULL) {
+        /*tex We just fallback. */
+        fo->fd->fontname = xstrdup(fo->fm->ps_name);
+    } else if (font_fullname(f) != NULL) {
         fo->fd->fontname = xstrdup(font_fullname(f));
-    else
+    } else {
         fo->fd->fontname = xstrdup(fo->fm->tfm_name);
+    }
 }
 
 static void pdf_dict_add_fontname(PDF pdf, const char *key, fd_entry * fd)
 {
     char *s;
     size_t l1 = 0, l2;
-    assert(fd->fontname != NULL);
-    assert(key != NULL);
     if (fd->subset_tag != NULL)
         l1 = strlen(fd->subset_tag);
     l2 = strlen(fd->fontname);
@@ -218,27 +225,20 @@ static void pdf_dict_add_fontname(PDF pdf, const char *key, fd_entry * fd)
     xfree(s);
 }
 
-@
-@c
 fd_entry *lookup_fd_entry(char *s)
 {
     fd_entry fd;
     fm_entry fm;
-    assert(s != NULL);
     fm.ff_name = s;
     fd.fm = &fm;
     if (fd_tree == NULL) {
         fd_tree = avl_create(comp_fd_entry, NULL, &avl_xallocator);
-        assert(fd_tree != NULL);
     }
     return (fd_entry *) avl_find(fd_tree, &fd);
 }
 
 static fd_entry *lookup_fontdescriptor(fo_entry * fo)
 {
-    assert(fo != NULL);
-    assert(fo->fm != NULL);
-    assert(is_fontfile(fo->fm));
     return lookup_fd_entry(fo->fm->ff_name);
 }
 
@@ -247,66 +247,72 @@ void register_fd_entry(fd_entry * fd)
     void **aa;
     if (fd_tree == NULL) {
         fd_tree = avl_create(comp_fd_entry, NULL, &avl_xallocator);
-        assert(fd_tree != NULL);
     }
-    assert(fd != NULL && fd->fm != NULL && is_fontfile(fd->fm));
-    /* font descriptor not yet registered: */
-    assert(lookup_fd_entry(fd->fm->ff_name) == NULL);
+    /*tex The font descriptor is not yet registered: */
+    if (lookup_fd_entry(fd->fm->ff_name) == NULL) {
+        /*tex Is this a problem? */
+    } else {
+        /*tex The lookup also can create */
+    }
     aa = avl_probe(fd_tree, fd);
-    assert(aa != NULL);
+    if (aa == NULL) {
+        /*tex Is this a problem? */
+    }
 }
 
 static void create_fontdescriptor(fo_entry * fo, internal_font_number f)
 {
-    assert(fo != NULL);
-    assert(fo->fm != NULL);
-    assert(fo->fd == NULL);
     fo->fd = new_fd_entry(f);
     preset_fontname(fo, f);
     preset_fontmetrics(fo->fd, f);
-    /* encoding needed by TrueType writing: */
+    /*tex An encoding is needed for \TRUETYPE\ writing: */
     fo->fd->fe = fo->fe;
-    /* map entry needed by TrueType writing: */
+    /*tex A map entry is needed for \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);
 }
 
-@
-For all used characters of \TeX font |f|, get corresponding glyph names
-from external reencoding (.enc) file and collect these in the glyph
-tree |gl_tree| of font descriptor |fd| referenced by font dictionary |fo|.
+/*tex
+
+    For all used characters of \TeX font |f|, get corresponding glyph names from
+    external reencoding (.enc) file and collect these in the glyph tree |gl_tree|
+    of font descriptor |fd| referenced by font dictionary |fo|.
+
+*/
 
-@c
 static void mark_reenc_glyphs(fo_entry * fo, internal_font_number f)
 {
     int i;
     char **g;
     void **aa;
-    assert(fo->fe != NULL);
     if (is_subsetted(fo->fm)) {
-        assert(is_included(fo->fm));
-        /* mark glyphs from TeX (externally reencoded characters) */
+        /*tex 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
                 && (char *) avl_find(fo->fd->gl_tree, g[i]) == NULL) {
                 aa = avl_probe(fo->fd->gl_tree, xstrdup(g[i]));
-                assert(aa != NULL);
+                if (aa == NULL) {
+                    /*tex Is this a problem? */
+                }
             }
         }
     }
 }
 
-@
-Function |mark_chars| has 2 uses:
-\item 1. Mark characters as chars on \TeX\ level.
-\item 2. Mark encoding pairs used by \TeX\ to optimize encoding vector.
+/*tex
+
+    Function |mark_chars| has 2 uses:
 
-@c
-static struct avl_table *mark_chars(fo_entry * fo, struct avl_table *tx_tree,
-     internal_font_number f)
+    \startitemize[n]
+        \startitem Mark characters as chars on \TeX\ level. \stopitem
+        \startitem Mark encoding pairs used by \TeX\ to optimize encoding vector. \stopitem
+    \stopitemize
+
+*/
+
+static struct avl_table *mark_chars(fo_entry * fo, struct avl_table *tx_tree, internal_font_number f)
 {
     int i, *j;
     void **aa;
@@ -319,19 +325,19 @@ static struct avl_table *mark_chars(fo_entry * fo, struct avl_table *tx_tree,
             j = xtalloc(1, int);
             *j = i;
             aa = avl_probe(tx_tree, j);
-            assert(aa != NULL);
+            if (aa == NULL) {
+                /*tex Is this a problem? */
+            }
         }
     }
     return tx_tree;
 }
 
-@
-@c
 static void get_char_range(fo_entry * fo, internal_font_number f)
 {
     int i;
     assert(fo != NULL);
-    /* search for |first_char| and |last_char| */
+    /*tex Search for |first_char| and |last_char|. */
     for (i = font_bc(f); i <= font_ec(f); i++)
         if (pdf_char_marked(f, i))
             break;
@@ -341,7 +347,7 @@ static void get_char_range(fo_entry * fo, internal_font_number f)
             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 */
+        /*tex No character has been used from this font. */
         fo->last_char = 0;
         fo->first_char = fo->last_char + 1;
     }
@@ -350,7 +356,7 @@ static void get_char_range(fo_entry * fo, internal_font_number f)
 static int font_has_subset(internal_font_number f)
 {
     int i, s;
-    /* search for |first_char| and |last_char| */
+    /*tex Search for |first_char| and |last_char|. */
     for (i = font_bc(f); i <= font_ec(f); i++)
         if (pdf_char_marked(f, i))
             break;
@@ -364,19 +370,14 @@ static int font_has_subset(internal_font_number f)
         return 1;
 }
 
-@
-@c
 static void write_charwidth_array(PDF pdf, fo_entry * fo, internal_font_number f)
 {
     int i, j, *ip, *fip;
     struct avl_traverser t;
-    assert(fo->tx_tree != NULL);
-    assert(fo->cw_objnum == 0);
     fo->cw_objnum = pdf_create_obj(pdf, obj_type_others, 0);
     pdf_begin_obj(pdf, fo->cw_objnum, OBJSTM_ALWAYS);
     avl_t_init(&t, fo->tx_tree);
     fip = (int *) avl_t_first(&t, fo->tx_tree);
-    assert(fip != NULL);
     pdf_begin_array(pdf);
     for (ip = fip, j = *ip; ip != NULL; ip = (int *) avl_t_next(&t)) {
         if (ip != fip)
@@ -393,19 +394,21 @@ static void write_charwidth_array(PDF pdf, fo_entry * fo, internal_font_number f
     pdf_end_obj(pdf);
 }
 
-@ Remark: Font objects from embedded PDF files are never registered
-into |fo_tree|; they are individually written out.
-@c
+/*tex
+
+    Remark: Font objects from embedded PDF files are never registered into
+    |fo_tree|; they are individually written out.
+
+*/
+
 static fo_entry *lookup_fo_entry(char *s)
 {
     fo_entry fo;
     fm_entry fm;
-    assert(s != NULL);
     fm.tfm_name = s;
     fo.fm = &fm;
     if (fo_tree == NULL) {
         fo_tree = avl_create(comp_fo_entry, NULL, &avl_xallocator);
-        assert(fo_tree != NULL);
     }
     return (fo_entry *) avl_find(fo_tree, &fo);
 }
@@ -415,60 +418,63 @@ static void register_fo_entry(fo_entry * fo)
     void **aa;
     if (fo_tree == NULL) {
         fo_tree = avl_create(comp_fo_entry, NULL, &avl_xallocator);
-        assert(fo_tree != NULL);
     }
-    assert(fo != NULL);
-    assert(fo->fm != NULL);
-    assert(fo->fm->tfm_name != NULL);
-    assert(lookup_fo_entry(fo->fm->tfm_name) == NULL);
+    if (lookup_fo_entry(fo->fm->tfm_name) == NULL) {
+        /*tex Is this a problem? */
+    } else {
+        /*tex The lookup also can create */
+    }
     aa = avl_probe(fo_tree, fo);
-    assert(aa != NULL);
+    if (aa == NULL) {
+        /*tex Is this a problem? */
+    }
 }
 
-@
-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
+/*tex
+
+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.
+
+*/
+
 static void write_fontfile(PDF pdf, fd_entry * fd)
 {
-    assert(is_included(fd->fm));
     if (is_cidkeyed(fd->fm)) {
         if (is_opentype(fd->fm)) {
             writetype0(pdf, fd);
-	} else if (is_truetype(fd->fm)) {
+        } else if (is_truetype(fd->fm)) {
             if (!writetype2(pdf, fd)) {
                 writetype0(pdf,fd);
-	        fd->fm->type |= F_OTF; fd->fm->type ^= F_TRUETYPE;
+                fd->fm->type |= F_OTF; fd->fm->type ^= F_TRUETYPE;
             }
-	} else if (is_type1(fd->fm))
-	    writetype1w(pdf, fd);
-	else
-	    assert(0);
+        } else if (is_type1(fd->fm)) {
+            writetype1w(pdf, fd);
+        } else {
+            normal_error("fonts","there is a problem writing the font file (1)");
+        }
     } else {
-	if (is_type1(fd->fm))
-	    writet1(pdf, fd);
-        else if (is_truetype(fd->fm))
+        if (is_type1(fd->fm)) {
+            writet1(pdf, fd);
+        } else if (is_truetype(fd->fm)) {
             writettf(pdf, fd);
-        else if (is_opentype(fd->fm))
+        } else if (is_opentype(fd->fm)) {
             writeotf(pdf, fd);
-        else
-            assert(0);
+        } else {
+            normal_error("fonts","there is a problem writing the font file (2)");
+        }
     }
     if (!fd->ff_found)
         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 */
+    /*tex The font file stream: */
+    pdf_begin_obj(pdf, fd->ff_objnum, OBJSTM_NEVER);
     pdf_begin_dict(pdf);
     if (is_cidkeyed(fd->fm)) {
-        /* No subtype is used for TrueType-based OpenType fonts */
-        if (is_opentype(fd->fm) || is_type1(fd->fm))
+        /*tex No subtype is used for |TRUETYPE\ based \OPENTYPE\ fonts. */
+        if (is_opentype(fd->fm) || is_type1(fd->fm)) {
             pdf_dict_add_name(pdf, "Subtype", "CIDFontType0C");
-#if 0
-        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);
@@ -478,7 +484,7 @@ static void write_fontfile(PDF pdf, fd_entry * fd)
     } else if (is_opentype(fd->fm)) {
         pdf_dict_add_name(pdf, "Subtype", "Type1C");
     } else {
-        assert(0); /* todo: error messages */
+        normal_error("fonts","there is a problem writing the font file (3)");
     }
     pdf_dict_add_streaminfo(pdf);
     pdf_end_dict(pdf);
@@ -488,17 +494,11 @@ static void write_fontfile(PDF pdf, fd_entry * fd)
     pdf_end_obj(pdf);
 }
 
-@
-@c
 int cidset = 0;
+
 static void write_fontdescriptor(PDF pdf, fd_entry * fd)
 {
     static const int std_flags[] = {
-        /*
-            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 */
@@ -513,31 +513,37 @@ static void write_fontdescriptor(PDF pdf, fd_entry * fd)
             2 + (1 << 5) + (1 << 6),             /* Times-Italic */
             2 + (1 << 5) + (1 << 6) + (1 << 18), /* Times-BoldItalic */
               4                                  /* ZapfDingbats */
-        /* *INDENT-ON* */
     };
     char *glyph;
     struct avl_traverser t;
     int fd_flags;
-    assert(fd != NULL && fd->fm != NULL);
-    cidset = 0; /* possibly updated by |write_fontfile| */
+    /*tex Possibly updated by |write_fontfile|: */
+    cidset = 0;
+    if (fd->fd_objnum == 0) {
+        int n = 0;
+        int callback_id = callback_defined(font_descriptor_objnum_provider_callback);
+        if (callback_id) {
+            run_callback(callback_id, "S->d", fd->fontname, &n);
+        }
+        if (!n) {
+           n = pdf_create_obj(pdf, obj_type_others, 0);
+        }
+        fd->fd_objnum = n;
+    }
     if (is_fontfile(fd->fm) && is_included(fd->fm)) {
-        /* this will set |fd->ff_found| if font file is found */
+        /*tex 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);
     pdf_begin_dict(pdf);
     pdf_dict_add_name(pdf, "Type", "FontDescriptor");
     pdf_dict_add_fontname(pdf, "FontName", fd);
-    if (fd->fm->fd_flags != FD_FLAGS_NOT_SET_IN_MAPLINE)
+    if (fd->fm->fd_flags != FD_FLAGS_NOT_SET_IN_MAPLINE) {
         fd_flags = (int) fd->fm->fd_flags;
-    else if (fd->ff_found)
+    } else if (fd->ff_found) {
         fd_flags = FD_FLAGS_DEFAULT_EMBED;
-    else {
-        fd_flags = is_std_t1font(fd->fm)
-            ? std_flags[check_std_t1font(fd->fm->ps_name)]
-            : FD_FLAGS_DEFAULT_NON_EMBED;
+    } else {
+        fd_flags = is_std_t1font(fd->fm) ? std_flags[check_std_t1font(fd->fm->ps_name)] : FD_FLAGS_DEFAULT_NON_EMBED;
         formatted_warning("map file",
              "No flags specified for non-embedded font '%s' (%s), I'm using %i, fix your map entry",
              fd->fm->ps_name != NULL ? fd->fm->ps_name : "No name given",
@@ -554,19 +560,20 @@ static void write_fontdescriptor(PDF pdf, fd_entry * fd)
             else if (is_opentype(fd->fm))
                 pdf_dict_add_ref(pdf, "FontFile3", (int) fd->ff_objnum);
             else
-                assert(0);
+                normal_error("fonts","there is a problem writing the font file (4)");
         } else {
             if (is_subsetted(fd->fm) && is_type1(fd->fm)) {
-                /* /CharSet is optional; names may appear in any order */
-                assert(fd->gl_tree != NULL);
-                avl_t_init(&t, fd->gl_tree);
-                pdf_add_name(pdf, "CharSet");
-                pdf_out(pdf, '(');
-                for (glyph = (char *) avl_t_first(&t, fd->gl_tree);
-                     glyph != NULL; glyph = (char *) avl_t_next(&t))
-                    pdf_add_name(pdf, glyph);
-                pdf_out(pdf, ')');
-                pdf->cave = 0;
+                /*tex |/CharSet| is optional; names may appear in any order */
+                if ((! pdf->omit_charset) && (pdf->major_version == 1)) {
+                    avl_t_init(&t, fd->gl_tree);
+                    pdf_add_name(pdf, "CharSet");
+                    pdf_out(pdf, '(');
+                    for (glyph = (char *) avl_t_first(&t, fd->gl_tree); glyph != NULL; glyph = (char *) avl_t_next(&t)) {
+                        pdf_add_name(pdf, glyph);
+                    }
+                    pdf_out(pdf, ')');
+                    pdf_set_space(pdf);
+                }
             }
             if (is_type1(fd->fm))
                 pdf_dict_add_ref(pdf, "FontFile", (int) fd->ff_objnum);
@@ -575,16 +582,15 @@ static void write_fontdescriptor(PDF pdf, fd_entry * fd)
             else if (is_opentype(fd->fm))
                 pdf_dict_add_ref(pdf, "FontFile3", (int) fd->ff_objnum);
             else
-                assert(0);
+                normal_error("fonts","there is a problem writing the font file (5)");
         }
     }
     if ((! pdf->omit_cidset) && (pdf->major_version == 1) && (cidset != 0) ) {
         pdf_dict_add_ref(pdf, "CIDSet", cidset);
     }
-    /*
-        Currently we don't export the optional keys for CID fonts like
-        \.{/Style << /Panose <12-byte string> >>} and we probably never
-        will.
+    /*tex
+        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);
@@ -601,21 +607,13 @@ static void write_fontdescriptors(PDF pdf)
         write_fontdescriptor(pdf, fd);
 }
 
-@
-@c
 static void write_fontdictionary(PDF pdf, fo_entry * fo)
 {
-    assert(fo != NULL);
-    assert(fo->fm != NULL);
-    /* reserved as |pdf_font_num(f)| elsewhere: */
-    assert(fo->fo_objnum != 0);
-
-    /* write ToUnicode entry if needed */
+    /*tex Write the |/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);
         } 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);
         }
     }
@@ -629,11 +627,9 @@ static void write_fontdictionary(PDF pdf, fo_entry * fo)
     else if (is_opentype(fo->fm))
         pdf_dict_add_name(pdf, "Subtype", "Type1");
     else
-        assert(0);
-    assert(fo->fd != NULL && fo->fd->fd_objnum != 0);
+        normal_error("fonts","there is a problem writing the font file (6)");
     pdf_dict_add_fontname(pdf, "BaseFont", fo->fd);
     pdf_dict_add_ref(pdf, "FontDescriptor", (int) fo->fd->fd_objnum);
-    assert(fo->cw_objnum != 0);
     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);
@@ -642,8 +638,9 @@ static void write_fontdictionary(PDF pdf, fo_entry * fo)
     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) {
+        pdf_check_space(pdf);
         pdf_print(pdf, pdf_font_attr(fo->tex_font));
-        pdf_out(pdf, '\n');
+        pdf_set_space(pdf);
     }
     pdf_end_dict(pdf);
     pdf_end_obj(pdf);
@@ -656,49 +653,53 @@ static void write_fontdictionaries(PDF pdf)
     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
-@c
+/*tex
+
+    Final flush of all font related stuff by call from \.{Output fonts
+    definitions} elsewhere.
+
+*/
+
 void write_fontstuff(PDF pdf)
 {
     write_fontdescriptors(pdf);
-    write_fontencodings(pdf);   /* see \.{writeenc.w} */
+    write_fontencodings(pdf);
     write_fontdictionaries(pdf);
 }
 
-@
-@c
 static void create_fontdictionary(PDF pdf, internal_font_number f)
 {
     fo_entry *fo = new_fo_entry();
     fm_entry *fm = font_map(f);
-    /* set |fo->first_char| and |fo->last_char| from |f| */
+    /*tex set |fo->first_char| and |fo->last_char| from |f| */
     get_char_range(fo, f);
     if (fo->last_char > 255)
         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)) {
-        /*
+        /*tex
             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. */
+            /*tex We don't end up here for truetype fonts. */
+            if (fo->fe->fe_objnum == 0) {
+                /*tex It will be written out */
+                fo->fe->fe_objnum = pdf_create_obj(pdf, obj_type_others, 0);
+            }
+            /*tex Mark encoding pairs used by TeX to optimize encoding vector. */
             fo->fe->tx_tree = mark_chars(fo, fo->fe->tx_tree, f);
         }
     }
-    /* for |write_charwidth_array|: */
+    /*tex 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)) {
@@ -713,7 +714,7 @@ static void create_fontdictionary(PDF pdf, internal_font_number f)
         if (fo->fe != NULL) {
             mark_reenc_glyphs(fo, f);
             if (!is_type1(fo->fm)) {
-                /* mark reencoded characters as chars on TeX level */
+                /*tex 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)) {
@@ -721,16 +722,17 @@ static void create_fontdictionary(PDF pdf, internal_font_number f)
                 }
             }
         } else {
-            /* mark non-reencoded characters as chars on TeX level */
+            /*tex 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)) {
             write_fontdescriptor(pdf, fo->fd);
         }
     } else {
-        /*
-            Builtin fonts still need the /Widths array and /FontDescriptor
-            (to avoid error 'font FOO contains bad /BBox').
+        /*tex
+            Builtin fonts still need the \type {/Widths} array and \type
+            {/FontDescriptor} (to avoid error \quotation {font FOO contains bad
+            \type {/BBox}}).
         */
         create_fontdescriptor(fo, f);
         write_fontdescriptor(pdf, fo->fd);
@@ -745,8 +747,6 @@ static void create_fontdictionary(PDF pdf, internal_font_number f)
     }
 }
 
-@
-@c
 static int has_ttf_outlines(fm_entry * fm)
 {
     FILE *f = fopen(fm->ff_name, "rb");
@@ -767,38 +767,39 @@ void do_pdf_font(PDF pdf, internal_font_number f)
 {
     int del_file = 0;
     fm_entry *fm;
-    /*
-        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.
+    /*tex
+        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.
+        /*tex
+            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 */
-        else
-            fm->ps_name = font_fullname(f); /* the true name */
+        /*tex Set this to a name or whatever, not a real \TFM\ anyway: */
+        fm->tfm_name = font_name(f);
+        /*tex The actual file: */
+        fm->ff_name = font_filename(f);
+        /*tex The true (used) name: */
+        if (font_psname(f) != NULL) {
+            fm->ps_name = font_psname(f);
+        } else {
+            fm->ps_name = font_fullname(f);
+        }
         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.
-
-                Support for dfonts will be removed at some point anyhow.
-             */
+            /*tex
+
+                In case of a .dfont (an obsolete format), 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.
+            */
             char *s = FindResourceTtfFont(fm->ff_name, fm->ps_name);
             if (s != NULL) {
                 fm->ff_name = s;
@@ -807,35 +808,34 @@ void do_pdf_font(PDF pdf, internal_font_number f)
                 formatted_error("font","file '%s' does not contain font '%s'",fm->ff_name, fm->ps_name);
             }
         }
-        /* Needed for the CIDSystemInfo: */
+        /*tex Needed for the CIDSystemInfo: */
         fm->encname = font_encodingname(f);
         fm->slant = font_slant(f);
         set_slantset(fm);
         fm->extend = font_extend(f);
         set_extendset(fm);
-        /* Flags can perhaps be done better. */
+        /*tex Flags can perhaps be done better. */
         fm->fd_flags = 4;
         set_inuse(fm);
-
         switch (font_format(f)) {
-        case opentype_format:
-            if (has_ttf_outlines(fm)) {
+            case opentype_format:
+                if (has_ttf_outlines(fm)) {
+                    set_truetype(fm);
+                } else {
+                    set_opentype(fm);
+                }
+                break;
+            case truetype_format:
                 set_truetype(fm);
-            } else {
-                set_opentype(fm);
-            }
-            break;
-        case truetype_format:
-            set_truetype(fm);
-            break;
-        case type1_format:
-            set_type1(fm);
-            break;
-        default:
-            formatted_error("font","file format '%s' for '%s' is incompatible with wide characters",
-                font_format_name(f), font_name(f));
+                break;
+            case type1_format:
+                set_type1(fm);
+                break;
+            default:
+                formatted_error("font","file format '%s' for '%s' is incompatible with wide characters",
+                    font_format_name(f), font_name(f));
         }
-        /* This makes "unknown" default to subsetted inclusion */
+        /*tex This makes \quotation {unknown} default to subsetted inclusion. */
         if (font_embedding(f) != no_embedding) {
             set_included(fm);
             if (font_embedding(f) != full_embedding) {
@@ -844,37 +844,33 @@ void do_pdf_font(PDF pdf, internal_font_number f)
         }
         set_cidkeyed(fm);
         create_cid_fontdictionary(pdf, f);
-
         if (del_file)
             unlink(fm->ff_name);
-
     } else {
-        /*
-            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))
+        /*tex 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);
         else
             create_fontdictionary(pdf, f);
     }
 }
 
-@ 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.
+/*tex
+
+    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.
 
-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.
+    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
-                   __attribute__ ((unused)))
+    __attribute__ ((unused)))
 {
     unsigned short i, j;
-
     i = (unsigned short) (*(const glw_entry *) pa).id;
     j = (unsigned short) (*(const glw_entry *) pb).id;
     cmp_return(i, j);
@@ -883,59 +879,24 @@ static int comp_glw_entry(const void *pa, const void *pb, void *p
 
 static void create_cid_fontdescriptor(fo_entry * fo, internal_font_number f)
 {
-    assert(fo != NULL);
-    assert(fo->fm != NULL);
-    assert(fo->fd == NULL);
     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 */
+    /*tex Encoding needed by \TRUETYPE\ writing: */
+    fo->fd->fe = fo->fe;
+    /*tex Map entry needed by \TRUETYPE\ writing */
+    fo->fd->fm = fo->fm;
     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.
+/*tex
 
-@c
-/*
-    This is old code ... it fails when the order of using the same font at
-    different extends changes. Probably because widths get overwritten or
-    set wrong. The loop also looks kind of weird (why a loop).
-*/
+    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.
 
-/*
-static void mark_cid_subset_glyphs(fo_entry * fo, internal_font_number f)
-{
-    int i, k, l;
-    glw_entry *j;
-    void *aa;
-    for (k = 1; k <= max_font_id(); k++) {
-        if (k == f || -f == pdf_font_num(k)) {
-            l = font_size(k);
-            for (i = font_bc(k); i <= font_ec(k); i++) {
-                if (quick_char_exists(k, i) && char_used(k, i)) {
-                    j = xtalloc(1, glw_entry);
-                    j->id = (unsigned) char_index(k, i);
-                    j->wd = divide_scaled_n(char_width(k, i), l, 10000.0);
-                    if ((glw_entry *) avl_find(fo->fd->gl_tree, j) == NULL) {
-                        aa = avl_probe(fo->fd->gl_tree, j);
-                        assert(aa != NULL);
-                    } else {
-                        xfree(j);
-                    }
-                }
-            }
-        }
-    }
-}
-*/
-
-/*
-    So, let's try the following.
 */
 
 static void mark_cid_subset_glyphs(fo_entry * fo, internal_font_number f)
@@ -951,7 +912,9 @@ static void mark_cid_subset_glyphs(fo_entry * fo, internal_font_number f)
             j->wd = divide_scaled_n(char_width(f, i), l, 10000.0);
             if ((glw_entry *) avl_find(fo->fd->gl_tree, j) == NULL) {
                 aa = avl_probe(fo->fd->gl_tree, j);
-                assert(aa != NULL);
+                if (aa == NULL) {
+                    /*tex Is this a problem? */
+                }
             } else {
                 xfree(j);
             }
@@ -959,30 +922,29 @@ static void mark_cid_subset_glyphs(fo_entry * fo, internal_font_number f)
     }
 }
 
-@ 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.
+/*tex
+
+    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)
 {
     int i, j;
     glw_entry *glyph;
     struct avl_traverser t;
-
-    assert(fo->cw_objnum == 0);
     fo->cw_objnum = pdf_create_obj(pdf, obj_type_others, 0);
     pdf_begin_obj(pdf, fo->cw_objnum, OBJSTM_ALWAYS);
     avl_t_init(&t, fo->fd->gl_tree);
     glyph = (glw_entry *) avl_t_first(&t, fo->fd->gl_tree);
-    assert(glyph != NULL);
     i = (int) glyph->id;
     pdf_begin_array(pdf);
     pdf_add_int(pdf, i);
@@ -995,19 +957,16 @@ static void write_cid_charwidth_array(PDF pdf, fo_entry * fo)
             pdf_begin_array(pdf);
             j = glyph->wd;
         }
-        if (glyph->id == (unsigned) (i + 1))
-            pdf_out(pdf, ' ');
-
+        pdf_check_space(pdf);
         if (j < 0) {
             pdf_out(pdf, '-');
             j = -j;
         }
-
         pdf_printf(pdf, "%i", (j / 10));
         if ((j % 10) != 0)
             pdf_printf(pdf, ".%i", (j % 10));
-
         i = (int) glyph->id;
+        pdf_set_space(pdf);
     }
     pdf_end_array(pdf);
     pdf_end_array(pdf);
@@ -1026,15 +985,15 @@ static void create_cid_fontdictionary(PDF pdf, internal_font_number f)
 {
     fm_entry *fm = font_map(f);
     fo_entry *fo = new_fo_entry();
-    get_char_range(fo, f);      /* set |fo->first_char| and |fo->last_char| from |f| */
-    assert(fo->last_char >= fo->first_char);
+    /*tex set |fo->first_char| and |fo->last_char| from |f| */
+    get_char_range(fo, f);
     fo->fm = fm;
     fo->fo_objnum = pdf_font_num(f);
     fo->tex_font = f;
     create_cid_fontdescriptor(fo, f);
     mark_cid_subset_glyphs(fo, f);
     if (is_subsetted(fo->fm)) {
-        /*
+        /*tex
            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.
@@ -1043,24 +1002,20 @@ static void create_cid_fontdictionary(PDF pdf, internal_font_number f)
     }
     write_cid_charwidth_array(pdf, fo);
     write_fontdescriptor(pdf, fo->fd);
-
     write_cid_fontdictionary(pdf, fo, f);
     if (fo->fd) {
-      if (fo->fd->gl_tree){
-	avl_destroy(fo->fd->gl_tree,destroy_glw_cid_entry);
-      }
-      xfree(fo->fd);
+        if (fo->fd->gl_tree) {
+            avl_destroy(fo->fd->gl_tree,destroy_glw_cid_entry);
+        }
+        xfree(fo->fd);
     }
     xfree(fo);
 }
 
-@ @c
 void write_cid_fontdictionary(PDF pdf, fo_entry * fo, internal_font_number f)
 {
     int i;
-
     fo->tounicode_objnum = write_cid_tounicode(pdf, fo, f);
-
     pdf_begin_obj(pdf, fo->fo_objnum, OBJSTM_ALWAYS);
     pdf_begin_dict(pdf);
     pdf_dict_add_name(pdf, "Type", "Font");
@@ -1076,12 +1031,10 @@ void write_cid_fontdictionary(PDF pdf, fo_entry * fo, internal_font_number f)
     pdf_begin_array(pdf);
     pdf_add_ref(pdf, i);
     pdf_end_array(pdf);
-    /* todo: the ToUnicode CMap */
     if (fo->tounicode_objnum != 0)
         pdf_dict_add_ref(pdf, "ToUnicode", (int) fo->tounicode_objnum);
     pdf_end_dict(pdf);
     pdf_end_obj(pdf);
-
     pdf_begin_obj(pdf, i, OBJSTM_ALWAYS);
     pdf_begin_dict(pdf);
     pdf_dict_add_name(pdf, "Type", "Font");
@@ -1100,17 +1053,17 @@ void write_cid_fontdictionary(PDF pdf, fo_entry * fo, internal_font_number f)
     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');
-        pdf_print(pdf_font_attr(fo->tex_font));
-        pdf_out(pdf, '\n');
-    }
-#endif
-
+    /*tex
+        I doubt there is anything useful that could be written here so for now we
+        comment this.
+    */
+    /*
+        if (pdf_font_attr(fo->tex_font) != get_nullstr()) {
+            pdf_out(pdf, '\n');
+            pdf_print(pdf_font_attr(fo->tex_font));
+            pdf_out(pdf, '\n');
+        }
+    */
     pdf_end_dict(pdf);
     pdf_end_obj(pdf);
 }
diff --git a/texk/web2c/luatexdir/font/writet3.w b/texk/web2c/luatexdir/font/writet3.c
similarity index 90%
rename from texk/web2c/luatexdir/font/writet3.w
rename to texk/web2c/luatexdir/font/writet3.c
index 879cef8d5..6121c24a1 100644
--- a/texk/web2c/luatexdir/font/writet3.w
+++ b/texk/web2c/luatexdir/font/writet3.c
@@ -1,25 +1,24 @@
-% writet3.w
-%
-% Copyright 1996-2006 Han The Thanh <thanh@@pdftex.org>
-% Copyright 2006-2011 Taco Hoekwater <taco@@luatex.org>
-%
-% This file is part of LuaTeX.
-%
-% LuaTeX is free software; you can redistribute it and/or modify it under
-% the terms of the GNU General Public License as published by the Free
-% Software Foundation; either version 2 of the License, or (at your
-% option) any later version.
-%
-% LuaTeX is distributed in the hope that it will be useful, but WITHOUT
-% ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-% FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
-% License for more details.
-%
-% You should have received a copy of the GNU General Public License along
-% with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+/*
 
-@ @c
+Copyright 1996-2006 Han The Thanh <thanh@pdftex.org>
+Copyright 2006-2011 Taco Hoekwater <taco@luatex.org>
 
+This file is part of LuaTeX.
+
+LuaTeX is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 2 of the License, or (at your
+option) any later version.
+
+LuaTeX is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+License for more details.
+
+You should have received a copy of the GNU General Public License along
+with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+
+*/
 
 #include "ptexlib.h"
 #include <kpathsea/tex-glyph.h>
@@ -41,7 +40,8 @@ static float t3_font_scale;
 static int t3_b0, t3_b1, t3_b2, t3_b3;
 static boolean is_pk_font;
 
-/* not static because used by pkin.c  */
+/*tex Not static because used elsewhere. */
+
 unsigned char *t3_buffer = NULL;
 int t3_size = 0;
 int t3_curbyte = 0;
@@ -50,8 +50,6 @@ int t3_curbyte = 0;
     if (t3_eof()) \
         normal_error("type 3","unexpected end of file");
 
-@
-@c
 static void update_bbox(int llx, int lly, int urx, int ury, boolean is_first_glyph)
 {
     if (is_first_glyph) {
@@ -71,7 +69,7 @@ static void update_bbox(int llx, int lly, int urx, int ury, boolean is_first_gly
     }
 }
 
-/* fixed precision 3 (+5 in pdfgen.w)*/
+/*tex Fixed precision 3 (+5 in |pdfgen.c|)*/
 
 #define get_pk_font_scale(pdf,f,scale_factor) \
     divide_scaled(scale_factor, divide_scaled(font_size(f),one_hundred_bp,pk_decimal_digits(pdf,2)), 0)
@@ -79,8 +77,6 @@ static void update_bbox(int llx, int lly, int urx, int ury, boolean is_first_gly
 #define pk_char_width(pdf,f,w,scale_factor) \
     divide_scaled(divide_scaled(w,font_size(f),pk_decimal_digits(pdf,4)), get_pk_font_scale(pdf,f,scale_factor), 0)
 
-@
-@c
 static boolean writepk(PDF pdf, internal_font_number f)
 {
     kpse_glyph_file_type font_ret;
@@ -98,17 +94,14 @@ static boolean writepk(PDF pdf, internal_font_number f)
     xfree(t3_buffer);
     t3_curbyte = 0;
     t3_size = 0;
-
     callback_id = callback_defined(find_pk_file_callback);
-
     if (pdf->pk_fixed_dpi) {
         newdpi = pdf->pk_resolution;
     } else {
         newdpi = dpi;
     }
-
     if (callback_id > 0) {
-        /* <base>.dpi/<fontname>.<tdpi>pk */
+        /*tex |<base>.dpi/<fontname>.<tdpi>pk| */
         dpi = round((float) pdf->pk_resolution * (((float) font_size(f)) / (float) font_dsize(f)));
         cur_file_name = font_name(f);
         run_callback(callback_id, "Sd->S", cur_file_name, (int) newdpi, &name);
@@ -213,8 +206,6 @@ static boolean writepk(PDF pdf, internal_font_number f)
     return true;
 }
 
-@
-@c
 void writet3(PDF pdf, internal_font_number f)
 {
     int i;
@@ -224,7 +215,6 @@ void writet3(PDF pdf, internal_font_number f)
     int pk_font_scale;
     pdffloat pf;
     boolean is_notdef;
-
     t3_glyph_num = 0;
     t3_image_used = false;
     for (i = 0; i < 256; i++) {
@@ -232,7 +222,6 @@ void writet3(PDF pdf, internal_font_number f)
         t3_char_widths[i] = 0;
     }
     is_pk_font = false;
-
     xfree(t3_buffer);
     t3_curbyte = 0;
     t3_size = 0;
@@ -246,8 +235,7 @@ void writet3(PDF pdf, internal_font_number f)
         if (pdf_char_marked(f, i))
             break;
     last_char = i;
-
-    /* Type 3 font dictionary */
+    /*tex We create a |Type3| font dictionary: */
     pdf_begin_obj(pdf, pdf_font_num(f), OBJSTM_ALWAYS);
     pdf_begin_dict(pdf);
     pdf_dict_add_name(pdf, "Type", "Font");
@@ -302,8 +290,7 @@ void writet3(PDF pdf, internal_font_number f)
     pdf_dict_add_ref(pdf, "CharProcs", (int) cptr);
     pdf_end_dict(pdf);
     pdf_end_obj(pdf);
-
-    /* chars width array */
+    /*tex The |Widths| array: */
     pdf_begin_obj(pdf, wptr, OBJSTM_ALWAYS);
     pdf_begin_array(pdf);
     if (is_pk_font) {
@@ -319,8 +306,7 @@ void writet3(PDF pdf, internal_font_number f)
     }
     pdf_end_array(pdf);
     pdf_end_obj(pdf);
-
-    /* encoding dictionary */
+    /*tex The |Encoding| dictionary: */
     pdf_begin_obj(pdf, eptr, OBJSTM_ALWAYS);
     pdf_begin_dict(pdf);
     pdf_dict_add_name(pdf, "Type", "Encoding");
@@ -354,8 +340,7 @@ void writet3(PDF pdf, internal_font_number f)
     pdf_end_array(pdf);
     pdf_end_dict(pdf);
     pdf_end_obj(pdf);
-
-    /* CharProcs dictionary */
+    /*tex The |CharProcs| dictionary: */
     pdf_begin_obj(pdf, cptr, OBJSTM_ALWAYS);
     pdf_begin_dict(pdf);
     for (i = first_char; i <= last_char; i++) {
diff --git a/texk/web2c/luatexdir/font/writettf.w b/texk/web2c/luatexdir/font/writettf.c
similarity index 65%
rename from texk/web2c/luatexdir/font/writettf.w
rename to texk/web2c/luatexdir/font/writettf.c
index 4a016cbe4..cf034e98d 100644
--- a/texk/web2c/luatexdir/font/writettf.w
+++ b/texk/web2c/luatexdir/font/writettf.c
@@ -1,32 +1,31 @@
-% writettf.w
-%
-% Copyright 1996-2006 Han The Thanh <thanh@@pdftex.org>
-% Copyright 2006-2010 Taco Hoekwater <taco@@luatex.org>
-%
-% This file is part of LuaTeX.
-%
-% LuaTeX is free software; you can redistribute it and/or modify it under
-% the terms of the GNU General Public License as published by the Free
-% Software Foundation; either version 2 of the License, or (at your
-% option) any later version.
-%
-% LuaTeX is distributed in the hope that it will be useful, but WITHOUT
-% ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-% FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
-% License for more details.
-%
-% You should have received a copy of the GNU General Public License along
-% with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
-
-@ @c
+/*
 
+Copyright 1996-2006 Han The Thanh <thanh@pdftex.org>
+Copyright 2006-2010 Taco Hoekwater <taco@luatex.org>
+
+This file is part of LuaTeX.
+
+LuaTeX is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 2 of the License, or (at your
+option) any later version.
+
+LuaTeX is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+License for more details.
+
+You should have received a copy of the GNU General Public License along
+with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+
+*/
 
 #include "ptexlib.h"
 #include "font/writettf.h"
 #include <string.h>
 
 #define DEFAULT_NTABS       14
-#define NEW_CMAP_SIZE       2
+#define NEW_CMAP_SIZE        2
 
 #define ttf_putchar(A)     strbuf_putchar(pdf->fb, (A))
 #define ttf_offset()       strbuf_offset(pdf->fb)
@@ -37,8 +36,10 @@ int ttf_size = 0;
 int ttf_curbyte = 0;
 
 typedef struct {
-    char *name;                 /* name of glyph */
-    long newindex;              /* new index of glyph in output file */
+    /*tex the name of glyph */
+    char *name;
+    /*tex the new index of glyph in output file */
+    long newindex;
 
 } ttfenc_entry;
 
@@ -87,303 +88,88 @@ static TTF_ULONG checkSumAdjustment_offset;
 FILE *ttf_file;
 static ttfenc_entry ttfenc_tab[256];
 
-fd_entry *fd_cur;               /* pointer to the current font descriptor */
+/*tex A pointer to the current font descriptor: */
+
+fd_entry *fd_cur;
 
 static struct avl_table *ttf_cmap_tree = NULL;
 
 int ttf_length;
 
-@ This used to be macnames.c
-
-@c
 char notdef[] = ".notdef";
 
 const char *mac_glyph_names[] = {
-/* 0x00 */
-    notdef,
-    ".null",
-    "CR",
-    "space",
-    "exclam",
-    "quotedbl",
-    "numbersign",
-    "dollar",
-    "percent",
-    "ampersand",
-    "quotesingle",
-    "parenleft",
-    "parenright",
-    "asterisk",
-    "plus",
-    "comma",
-/* 0x10 */
-    "hyphen",
-    "period",
-    "slash",
-    "zero",
-    "one",
-    "two",
-    "three",
-    "four",
-    "five",
-    "six",
-    "seven",
-    "eight",
-    "nine",
-    "colon",
-    "semicolon",
-    "less",
-/* 0x20 */
-    "equal",
-    "greater",
-    "question",
-    "at",
-    "A",
-    "B",
-    "C",
-    "D",
-    "E",
-    "F",
-    "G",
-    "H",
-    "I",
-    "J",
-    "K",
-    "L",
-/* 0x30 */
-    "M",
-    "N",
-    "O",
-    "P",
-    "Q",
-    "R",
-    "S",
-    "T",
-    "U",
-    "V",
-    "W",
-    "X",
-    "Y",
-    "Z",
-    "bracketleft",
-    "backslash",
-/* 0x40 */
-    "bracketright",
-    "asciicircum",
-    "underscore",
-    "grave",
-    "a",
-    "b",
-    "c",
-    "d",
-    "e",
-    "f",
-    "g",
-    "h",
-    "i",
-    "j",
-    "k",
-    "l",
-/* 0x50 */
-    "m",
-    "n",
-    "o",
-    "p",
-    "q",
-    "r",
-    "s",
-    "t",
-    "u",
-    "v",
-    "w",
-    "x",
-    "y",
-    "z",
-    "braceleft",
-    "bar",
-/* 0x60 */
-    "braceright",
-    "asciitilde",
-    "Adieresis",
-    "Aring",
-    "Ccedilla",
-    "Eacute",
-    "Ntilde",
-    "Odieresis",
-    "Udieresis",
-    "aacute",
-    "agrave",
-    "acircumflex",
-    "adieresis",
-    "atilde",
-    "aring",
-    "ccedilla",
-/* 0x70 */
-    "eacute",
-    "egrave",
-    "ecircumflex",
-    "edieresis",
-    "iacute",
-    "igrave",
-    "icircumflex",
-    "idieresis",
-    "ntilde",
-    "oacute",
-    "ograve",
-    "ocircumflex",
-    "odieresis",
-    "otilde",
-    "uacute",
-    "ugrave",
-/* 0x80 */
-    "ucircumflex",
-    "udieresis",
-    "dagger",
-    "degree",
-    "cent",
-    "sterling",
-    "section",
-    "bullet",
-    "paragraph",
-    "germandbls",
-    "registered",
-    "copyright",
-    "trademark",
-    "acute",
-    "dieresis",
-    "notequal",
-/* 0x90 */
-    "AE",
-    "Oslash",
-    "infinity",
-    "plusminus",
-    "lessequal",
-    "greaterequal",
-    "yen",
-    "mu",
-    "partialdiff",
-    "Sigma",
-    "Pi",
-    "pi",
-    "integral",
-    "ordfeminine",
-    "ordmasculine",
-    "Omega",
-/* 0xa0 */
-    "ae",
-    "oslash",
-    "questiondown",
-    "exclamdown",
-    "logicalnot",
-    "radical",
-    "florin",
-    "approxequal",
-    "Delta",
-    "guillemotleft",
-    "guillemotright",
-    "ellipsis",
-    "nbspace",
-    "Agrave",
-    "Atilde",
-    "Otilde",
-/* 0xb0 */
-    "OE",
-    "oe",
-    "endash",
-    "emdash",
-    "quotedblleft",
-    "quotedblright",
-    "quoteleft",
-    "quoteright",
-    "divide",
-    "lozenge",
-    "ydieresis",
-    "Ydieresis",
-    "fraction",
-    "currency",
-    "guilsinglleft",
-    "guilsinglright",
-/* 0xc0 */
-    "fi",
-    "fl",
-    "daggerdbl",
-    "periodcentered",
-    "quotesinglbase",
-    "quotedblbase",
-    "perthousand",
-    "Acircumflex",
-    "Ecircumflex",
-    "Aacute",
-    "Edieresis",
-    "Egrave",
-    "Iacute",
-    "Icircumflex",
-    "Idieresis",
-    "Igrave",
-/* 0xd0 */
-    "Oacute",
-    "Ocircumflex",
-    "applelogo",
-    "Ograve",
-    "Uacute",
-    "Ucircumflex",
-    "Ugrave",
-    "dotlessi",
-    "circumflex",
-    "tilde",
-    "macron",
-    "breve",
-    "dotaccent",
-    "ring",
-    "cedilla",
-    "hungarumlaut",
-/* 0xe0 */
-    "ogonek",
-    "caron",
-    "Lslash",
-    "lslash",
-    "Scaron",
-    "scaron",
-    "Zcaron",
-    "zcaron",
-    "brokenbar",
-    "Eth",
-    "eth",
-    "Yacute",
-    "yacute",
-    "Thorn",
-    "thorn",
+    /* 0x00 */
+    notdef, ".null", "CR", "space", "exclam", "quotedbl", "numbersign", "dollar",
+    "percent", "ampersand", "quotesingle", "parenleft", "parenright", "asterisk",
+    "plus", "comma",
+    /* 0x10 */
+    "hyphen", "period", "slash", "zero", "one", "two", "three", "four", "five",
+    "six", "seven", "eight", "nine", "colon", "semicolon", "less",
+    /* 0x20 */
+    "equal", "greater", "question", "at", "A", "B", "C", "D", "E", "F", "G", "H",
+    "I", "J", "K", "L",
+    /* 0x30 */
+    "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z",
+    "bracketleft", "backslash",
+    /* 0x40 */
+    "bracketright", "asciicircum", "underscore", "grave", "a", "b", "c", "d",
+    "e", "f", "g", "h", "i", "j", "k", "l",
+    /* 0x50 */
+    "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z",
+    "braceleft", "bar",
+    /* 0x60 */
+    "braceright", "asciitilde", "Adieresis", "Aring", "Ccedilla", "Eacute",
+    "Ntilde", "Odieresis", "Udieresis", "aacute", "agrave", "acircumflex",
+    "adieresis", "atilde", "aring", "ccedilla",
+    /* 0x70 */
+    "eacute", "egrave", "ecircumflex", "edieresis", "iacute", "igrave",
+    "icircumflex", "idieresis", "ntilde", "oacute", "ograve", "ocircumflex",
+    "odieresis", "otilde", "uacute", "ugrave",
+    /* 0x80 */
+    "ucircumflex", "udieresis", "dagger", "degree", "cent", "sterling",
+    "section", "bullet", "paragraph", "germandbls", "registered", "copyright",
+    "trademark", "acute", "dieresis", "notequal",
+    /* 0x90 */
+    "AE", "Oslash", "infinity", "plusminus", "lessequal", "greaterequal", "yen",
+    "mu", "partialdiff", "Sigma", "Pi", "pi", "integral", "ordfeminine",
+    "ordmasculine", "Omega",
+    /* 0xa0 */
+    "ae", "oslash", "questiondown", "exclamdown", "logicalnot", "radical",
+    "florin", "approxequal", "Delta", "guillemotleft", "guillemotright",
+    "ellipsis", "nbspace", "Agrave", "Atilde", "Otilde",
+    /* 0xb0 */
+    "OE", "oe", "endash", "emdash", "quotedblleft", "quotedblright", "quoteleft",
+    "quoteright", "divide", "lozenge", "ydieresis", "Ydieresis", "fraction",
+    "currency", "guilsinglleft", "guilsinglright",
+    /* 0xc0 */
+    "fi", "fl", "daggerdbl", "periodcentered", "quotesinglbase", "quotedblbase",
+    "perthousand", "Acircumflex", "Ecircumflex", "Aacute", "Edieresis", "Egrave",
+    "Iacute", "Icircumflex", "Idieresis", "Igrave",
+    /* 0xd0 */
+    "Oacute", "Ocircumflex", "applelogo", "Ograve", "Uacute", "Ucircumflex",
+    "Ugrave", "dotlessi", "circumflex", "tilde", "macron", "breve", "dotaccent",
+    "ring", "cedilla", "hungarumlaut",
+    /* 0xe0 */
+    "ogonek", "caron", "Lslash", "lslash", "Scaron", "scaron", "Zcaron",
+    "zcaron", "brokenbar", "Eth", "eth", "Yacute", "yacute", "Thorn", "thorn",
     "minus",
-/* 0xf0 */
-    "multiply",
-    "onesuperior",
-    "twosuperior",
-    "threesuperior",
-    "onehalf",
-    "onequarter",
-    "threequarters",
-    "franc",
-    "Gbreve",
-    "gbreve",
-    "Idot",
-    "Scedilla",
-    "scedilla",
-    "Cacute",
-    "cacute",
-    "Ccaron",
-/* 0x100 */
-    "ccaron",
-    "dmacron"
+    /* 0xf0 */
+    "multiply", "onesuperior", "twosuperior", "threesuperior", "onehalf",
+    "onequarter", "threequarters", "franc", "Gbreve", "gbreve", "Idot",
+    "Scedilla", "scedilla", "Cacute", "cacute", "Ccaron",
+    /* 0x100 */
+    "ccaron", "dmacron"
 };
 
 const char *ambiguous_names[] = {
-    "Delta",                    /*   increment   */
-    "Omega",                    /*   Ohm         */
-    "Pi",                       /*   product     */
-    "Sigma",                    /*   summation   */
-    "dmacron",                  /*   dslash      */
-    "macron",                   /*   overscore   */
-    "periodcentered",           /*   middot      */
+    "Delta",          /* increment */
+    "Omega",          /* Ohm       */
+    "Pi",             /* product   */
+    "Sigma",          /* summation */
+    "dmacron",        /* dslash    */
+    "macron",         /* overscore */
+    "periodcentered", /* middot    */
     NULL
 };
 
@@ -404,9 +190,8 @@ static const char *newtabnames[] = {
     "prep"
 };
 
-@ Back to code. Low-level helpers first.
+/* Back to code. Low-level helpers first. */
 
-@c
 static ttf_cmap_entry *new_ttf_cmap_entry(void)
 {
     ttf_cmap_entry *e;
@@ -438,7 +223,6 @@ static int comp_ttf_cmap_entry(const void *pa, const void *pb, void *p)
         *p2 = (const ttf_cmap_entry *) pb;
     int i;
     (void) p;
-    assert(p1->ttf_name != NULL && p2->ttf_name != NULL);
     if ((i = strcmp(p1->ttf_name, p2->ttf_name)) != 0)
         return i;
     cmp_return(p1->pid, p2->pid);
@@ -459,8 +243,10 @@ static unsigned char ttf_addchksm(unsigned char b)
 
 static TTF_ULONG ttf_getchksm(PDF pdf)
 {
-    while (tab_length % 4 != 0)
-        ttf_putchar(ttf_addchksm(0));   /* |ttf_addchksm| updates |tab_length| */
+    while (tab_length % 4 != 0) {
+        /*tex |ttf_addchksm| updates |tab_length| */
+        ttf_putchar(ttf_addchksm(0));
+    }
     return checksum;
 }
 
@@ -539,48 +325,34 @@ static void ttf_copy_encoding(void)
     int i, *q;
     void **aa;
     char **glyph_names;
-    /*long *charcodes;*/
-    /*static char buf[SMALL_BUF_SIZE];*/
     struct avl_traverser t;
-    /*ttfenc_entry *e = ttfenc_tab;*/
-
-    assert(fd_cur->tx_tree != NULL);    /* this must be set in |create_fontdictionary| */
-
     if (fd_cur->fe != NULL) {
         glyph_names = fd_cur->fe->glyph_names;
-        assert(glyph_names != NULL);
-
         for (i = 0; i < 256; i++)
             ttfenc_tab[i].name = (char *) notdef;
-
-        /* a workaround for a bug of AcroReader 4.0 */
+        /*tex This is a workaround for a bug of AcroReader 4.0: */
         if (strcmp(glyph_names[97], "a") == 0) {
             q = xtalloc(1, int);
             *q = 'a';
             aa = avl_probe(fd_cur->tx_tree, q);
-            assert(aa != NULL);
+            if (aa == NULL) {
+                /*tex Is this a problem? */
+            }
         }
-        /* end of workaround */
-
-        /* take over collected characters from \TeX, reencode them */
+        /*tex Take over collected characters from \TeX, reencode them. */
         avl_t_init(&t, fd_cur->tx_tree);
-        for (q = (int *) avl_t_first(&t, fd_cur->tx_tree); q != NULL;
-             q = (int *) avl_t_next(&t)) {
-            assert(*q >= 0 && *q < 256);
+        for (q = (int *) avl_t_first(&t, fd_cur->tx_tree); q != NULL; q = (int *) avl_t_next(&t)) {
             ttfenc_tab[*q].name = glyph_names[*q];
         }
         make_subset_tag(fd_cur);
-    } else
-        assert(0);
+    }
 }
 
-@
-@c
-#define ttf_append_byte(B)\
-do {\
-    if (name_tab[i].platform_id == 3)\
-        *q++ = 0;\
-    *q++ = B;\
+#define ttf_append_byte(B) do {         \
+    if (name_tab[i].platform_id == 3) { \
+        *q++ = 0;                       \
+    }                                   \
+    *q++ = B;                           \
 } while (0)
 
 static char *strip_spaces_and_delims(char *s, int l)
@@ -588,9 +360,6 @@ static char *strip_spaces_and_delims(char *s, int l)
     static char buf[SMALL_BUF_SIZE];
     char *p = buf;
     int i;
-
-    assert(l >= 0 && l < (int) sizeof(buf));
-
     for (i = 0; i < l; s++, i++) {
         if (*s == '(' || *s == ')' || *s == '<' || *s == '>' ||
             *s == '[' || *s == ']' || *s == '{' || *s == '}' ||
@@ -609,9 +378,7 @@ static void ttf_read_name(void)
     char *p, buf[SMALL_BUF_SIZE];
     name_record_num = get_ushort();
     name_tab = xtalloc((unsigned) name_record_num, name_record);
-    name_buf_size = (int) ((unsigned) tab->length -
-                           (3 * TTF_USHORT_SIZE +
-                            (TTF_ULONG) name_record_num * 6 * TTF_USHORT_SIZE));
+    name_buf_size = (int) ((unsigned) tab->length - (3 * TTF_USHORT_SIZE + (TTF_ULONG) name_record_num * 6 * TTF_USHORT_SIZE));
     name_buf = xtalloc((unsigned) name_buf_size, char);
     ttf_skip(TTF_USHORT_SIZE);
     for (i = 0; i < name_record_num; i++) {
@@ -624,14 +391,12 @@ static void ttf_read_name(void)
     }
     for (p = name_buf; p - name_buf < name_buf_size; p++)
         *p = get_char();
-    /* look for PS font name */
+    /*tex Look for the \POSTSCRIPT\ font name. */
     for (i = 0; i < name_record_num; i++) {
         if (name_tab[i].platform_id == 1 &&
             name_tab[i].encoding_id == 0 && name_tab[i].name_id == 6) {
             xfree(fd_cur->fontname);
-            fd_cur->fontname =
-                xstrdup(strip_spaces_and_delims(name_buf + name_tab[i].offset,
-                                                name_tab[i].length));
+            fd_cur->fontname = xstrdup(strip_spaces_and_delims(name_buf + name_tab[i].offset, name_tab[i].length));
             fd_cur->font_dim[FONTNAME_CODE].set = true;
             break;
         }
@@ -639,15 +404,14 @@ static void ttf_read_name(void)
     if (!fd_cur->font_dim[FONTNAME_CODE].set) {
         for (i = 0; i < name_record_num; i++) {
             if (name_tab[i].platform_id == 3 &&
-                (name_tab[i].encoding_id == 0 || name_tab[i].encoding_id == 1)
-                && name_tab[i].name_id == 6) {
+                    (name_tab[i].encoding_id == 0 || name_tab[i].encoding_id == 1)
+                    && name_tab[i].name_id == 6) {
                 xfree(fd_cur->fontname);
                 assert(name_tab[i].length < sizeof(buf));
                 for (j = 0, p = buf; j < name_tab[i].length; j += 2)
                     *p++ = name_buf[name_tab[i].offset + j + 1];
                 *p = 0;
-                fd_cur->fontname =
-                    xstrdup(strip_spaces_and_delims(buf, (int) strlen(buf)));
+                fd_cur->fontname = xstrdup(strip_spaces_and_delims(buf, (int) strlen(buf)));
                 fd_cur->font_dim[FONTNAME_CODE].set = true;
                 break;
             }
@@ -659,8 +423,7 @@ static void ttf_read_mapx(void)
 {
     glyph_entry *glyph;
     ttf_seek_tab("maxp", TTF_FIXED_SIZE);
-    glyph_tab =
-        xtalloc((unsigned) (1 + (glyphs_count = get_ushort())), glyph_entry);
+    glyph_tab = xtalloc((unsigned) (1 + (glyphs_count = get_ushort())), glyph_entry);
     for (glyph = glyph_tab; glyph - glyph_tab < glyphs_count; glyph++) {
         glyph->newindex = -1;
         glyph->newoffset = 0;
@@ -668,14 +431,15 @@ static void ttf_read_mapx(void)
         glyph->name = (char *) notdef;
     }
     glyph_index = xtalloc((unsigned) (glyphs_count + 1), long);
-    glyph_index[0] = 0;         /* index of ".notdef" glyph */
-    glyph_index[1] = 1;         /* index of ".null" glyph */
+    /*tex index of the |.notdef| glyph */
+    glyph_index[0] = 0;
+    /*tex index of the |.null| glyph */
+    glyph_index[1] = 1;
 }
 
 void ttf_read_head(void)
 {
-    ttf_seek_tab("head",
-                 2 * TTF_FIXED_SIZE + 2 * TTF_ULONG_SIZE + TTF_USHORT_SIZE);
+    ttf_seek_tab("head", 2 * TTF_FIXED_SIZE + 2 * TTF_ULONG_SIZE + TTF_USHORT_SIZE);
     upem = get_ushort();
     ttf_skip(16);
     fd_cur->font_dim[FONTBBOX1_CODE].val = (int) ttf_funit(get_fword());
@@ -697,8 +461,7 @@ void ttf_read_hhea(void)
     fd_cur->font_dim[DESCENT_CODE].val = (int) ttf_funit(get_fword());
     fd_cur->font_dim[ASCENT_CODE].set = true;
     fd_cur->font_dim[DESCENT_CODE].set = true;
-    ttf_skip(TTF_FWORD_SIZE + TTF_UFWORD_SIZE + 3 * TTF_FWORD_SIZE +
-             8 * TTF_SHORT_SIZE);
+    ttf_skip(TTF_FWORD_SIZE + TTF_UFWORD_SIZE + 3 * TTF_FWORD_SIZE + 8 * TTF_SHORT_SIZE);
     nhmtxs = get_ushort();
 }
 
@@ -745,55 +508,57 @@ void ttf_read_post(void)
     post_format = get_fixed();
     italic_angle = get_fixed();
     int_part = (long) (italic_angle >> 16);
-    if (int_part > 0x7FFF) {    /* a negative number */
+    if (int_part > 0x7FFF) {
+        /*tex a negative number */
         int_part = 0x10000 - int_part;
         sign = -1;
     }
     frac_part = (long) (italic_angle % 0x10000);
-    fd_cur->font_dim[ITALIC_ANGLE_CODE].val =
-        (int) (sign * ((double) int_part + (double) frac_part * 1.0 / 0x10000));
+    fd_cur->font_dim[ITALIC_ANGLE_CODE].val = (int) (sign * ((double) int_part + (double) frac_part * 1.0 / 0x10000));
     fd_cur->font_dim[ITALIC_ANGLE_CODE].set = true;
-    if (glyph_tab == NULL)
-        return;                 /* being called from writeotf() */
+    if (glyph_tab == NULL) {
+        /*tex We were being called from |writeotf|. */
+        return;
+    }
     ttf_skip(2 * TTF_FWORD_SIZE + 5 * TTF_ULONG_SIZE);
     switch (post_format) {
-    case 0x10000:
-        for (glyph = glyph_tab; glyph - glyph_tab < NMACGLYPHS; glyph++) {
-            glyph->name = (const char *) mac_glyph_names[glyph - glyph_tab];
-            glyph->name_index = (TTF_USHORT) (glyph - glyph_tab);
-        }
-        break;
-    case 0x20000:
-        nnames = get_ushort();  /* some fonts have this value different from nglyphs */
-        for (glyph = glyph_tab; glyph - glyph_tab < nnames; glyph++)
-            glyph->name_index = get_ushort();
-        length =
-            (long) ((long) tab->length -
-                    (long) ((long) ttf_curbyte - (long) tab->offset));
-        glyph_name_buf = xtalloc((unsigned) length, char);
-        for (p = glyph_name_buf; p - glyph_name_buf < length;) {
-            for (k = get_byte(); k > 0; k--)
-                *p++ = get_char();
-            *p++ = 0;
-        }
-        for (glyph = glyph_tab; glyph - glyph_tab < nnames; glyph++) {
-            if (glyph->name_index < NMACGLYPHS)
-                glyph->name = mac_glyph_names[glyph->name_index];
-            else {
-                p = glyph_name_buf;
-                k = glyph->name_index - NMACGLYPHS;
-                for (; k > 0; k--)
-                    p = strend(p) + 1;
-                glyph->name = p;
+        case 0x10000:
+            for (glyph = glyph_tab; glyph - glyph_tab < NMACGLYPHS; glyph++) {
+                glyph->name = (const char *) mac_glyph_names[glyph - glyph_tab];
+                glyph->name_index = (TTF_USHORT) (glyph - glyph_tab);
+            }
+            break;
+        case 0x20000:
+            /*tex Some fonts have this value different from |nglyphs|: */
+            nnames = get_ushort();
+            for (glyph = glyph_tab; glyph - glyph_tab < nnames; glyph++) {
+                glyph->name_index = get_ushort();
+            }
+            length = (long) ((long) tab->length - (long) ((long) ttf_curbyte - (long) tab->offset));
+            glyph_name_buf = xtalloc((unsigned) length, char);
+            for (p = glyph_name_buf; p - glyph_name_buf < length;) {
+                for (k = get_byte(); k > 0; k--)
+                    *p++ = get_char();
+                *p++ = 0;
+            }
+            for (glyph = glyph_tab; glyph - glyph_tab < nnames; glyph++) {
+                if (glyph->name_index < NMACGLYPHS)
+                    glyph->name = mac_glyph_names[glyph->name_index];
+                else {
+                    p = glyph_name_buf;
+                    k = glyph->name_index - NMACGLYPHS;
+                    for (; k > 0; k--)
+                        p = strend(p) + 1;
+                    glyph->name = p;
+                }
+            }
+            break;
+        default:
+            formatted_warning("ttf font", "unsupported format '%.8X' of 'post' table, assuming 3.0", (unsigned int) post_format);
+        case 0x00030000:
+            for (glyph = glyph_tab; glyph - glyph_tab < NMACGLYPHS; glyph++) {
+                glyph->name_index = (TTF_USHORT) (glyph - glyph_tab);
             }
-        }
-        break;
-    default:
-        formatted_warning("ttf font", "unsupported format '%.8X' of 'post' table, assuming 3.0", (unsigned int) post_format);
-    case 0x00030000:
-        for (glyph = glyph_tab; glyph - glyph_tab < NMACGLYPHS; glyph++) {
-            glyph->name_index = (TTF_USHORT) (glyph - glyph_tab);
-        }
     }
 }
 
@@ -813,14 +578,17 @@ void otc_read_tabdir(int index)
 {
     unsigned long i, num, rem=0;
     dirtab_entry *tab;
-    ttf_skip(TTF_FIXED_SIZE);   /* ignore TTCTag 'ttcf' */
-    ttf_skip(TTF_ULONG_SIZE);   /* ignorethe version number */
+    /*tex Ignore the tag |ttcf|. */
+    ttf_skip(TTF_FIXED_SIZE);
+    /*tex Ignore the version number. */
+    ttf_skip(TTF_ULONG_SIZE);
     num = get_ulong();
     for (i = 0; i < num; i++)  {
         if (i==index) rem = get_ulong(); else ttf_skip(TTF_ULONG_SIZE);
     }
     ttf_skip(rem - TTF_FIXED_SIZE - (num+2)*TTF_ULONG_SIZE);
-    ttf_skip(TTF_FIXED_SIZE);   /* ignore the sfnt number */
+    /*tex Ignore the |sfnt| number. */
+    ttf_skip(TTF_FIXED_SIZE);
     dir_tab = xtalloc(ntabs = get_ushort(), dirtab_entry);
     ttf_skip(3 * TTF_USHORT_SIZE);
     for (tab = dir_tab; tab - dir_tab < ntabs; tab++) {
@@ -836,7 +604,8 @@ void ttf_read_tabdir(void)
 {
     int i;
     dirtab_entry *tab;
-    ttf_skip(TTF_FIXED_SIZE);   /* ignore the sfnt number */
+    /*tex Ignore the |sfnt| number. */
+    ttf_skip(TTF_FIXED_SIZE);
     dir_tab = xtalloc(ntabs = get_ushort(), dirtab_entry);
     ttf_skip(3 * TTF_USHORT_SIZE);
     for (tab = dir_tab; tab - dir_tab < ntabs; tab++) {
@@ -848,8 +617,7 @@ void ttf_read_tabdir(void)
     }
 }
 
-static ttf_cmap_entry *ttf_read_cmap(char *ttf_name, int pid, int eid,
-                                     boolean warn)
+static ttf_cmap_entry *ttf_read_cmap(char *ttf_name, int pid, int eid, boolean warn)
 {
     seg_entry *seg_tab, *s;
     TTF_USHORT *glyphId, format, segCount;
@@ -858,8 +626,7 @@ static ttf_cmap_entry *ttf_read_cmap(char *ttf_name, int pid, int eid,
     long n, i, k, length, index;
     ttf_cmap_entry tmp_e, *p;
     void **aa;
-
-    /* look up in |ttf_cmap_tree| first, return if found */
+    /*tex Look up in |ttf_cmap_tree| first, return if found. */
     tmp_e.ttf_name = ttf_name;
     tmp_e.pid = (TTF_USHORT) pid;
     tmp_e.eid = (TTF_USHORT) eid;
@@ -870,9 +637,8 @@ static ttf_cmap_entry *ttf_read_cmap(char *ttf_name, int pid, int eid,
     p = (ttf_cmap_entry *) avl_find(ttf_cmap_tree, &tmp_e);
     if (p != NULL)
         return p;
-
-    /* not found, have to read it */
-    ttf_seek_tab("cmap", TTF_USHORT_SIZE);      /* skip the table version number (=0) */
+    /*tex It's not found so we have to read it. We skip the table version number (0). */
+    ttf_seek_tab("cmap", TTF_USHORT_SIZE);
     ncmapsubtabs = get_ushort();
     cmap_offset = (TTF_ULONG) (ttf_curbyte - 2 * TTF_USHORT_SIZE);
     cmap_tab = xtalloc(ncmapsubtabs, cmap_entry);
@@ -886,36 +652,46 @@ static ttf_cmap_entry *ttf_read_cmap(char *ttf_name, int pid, int eid,
             if (format == 4)
                 goto read_cmap_format_4;
             else {
-                if (warn)
+                if (warn) {
                     formatted_warning("ttf font", "cmap format %i unsupported", format);
+                }
                 return NULL;
             }
         }
     }
-    if (warn)
+    if (warn) {
         formatted_warning("ttf font", "cannot find cmap subtable for (pid,eid) = (%i,%i)", pid, eid);
+    }
     return NULL;
+    /*tex We jump here: */
   read_cmap_format_4:
-    /* initialize the new entry */
+    /*tex Initialize the new entry. */
     p = new_ttf_cmap_entry();
     p->ttf_name = xstrdup(ttf_name);
     p->pid = (TTF_USHORT) pid;
     p->eid = (TTF_USHORT) eid;
     p->table = xtalloc(0x10000, long);
-    for (i = 0; i < 0x10000; ++i)
-        p->table[i] = -1;       /* unassigned yet */
-
-    /* read the subtable */
-    length = get_ushort();      /* length of subtable */
-    (void) get_ushort();        /* skip the version number */
+    for (i = 0; i < 0x10000; ++i) {
+        /*tex Yet unassigned: */
+        p->table[i] = -1;
+    }
+    /*tex Read the subtable. */
+    /*tex length of subtable */
+    length = get_ushort();
+    /*tex skip the version number */
+    (void) get_ushort();
     segCount = get_ushort() / 2;
-    (void) get_ushort();        /* skip searchRange */
-    (void) get_ushort();        /* skip entrySelector */
-    (void) get_ushort();        /* skip rangeShift */
+    /*tex skip searchRange */
+    (void) get_ushort();
+    /*tex skip entrySelector */
+    (void) get_ushort();
+    /*tex skip rangeShift */
+    (void) get_ushort();
     seg_tab = xtalloc(segCount, seg_entry);
     for (s = seg_tab; s - seg_tab < segCount; s++)
         s->endCode = get_ushort();
-    (void) get_ushort();        /* skip reversedPad */
+    /*tex skip reversedPad */
+    (void) get_ushort();
     for (s = seg_tab; s - seg_tab < segCount; s++)
         s->startCode = get_ushort();
     for (s = seg_tab; s - seg_tab < segCount; s++)
@@ -923,7 +699,8 @@ static ttf_cmap_entry *ttf_read_cmap(char *ttf_name, int pid, int eid,
     for (s = seg_tab; s - seg_tab < segCount; s++)
         s->idRangeOffset = get_ushort();
     length -= 8 * TTF_USHORT_SIZE + 4 * segCount * TTF_USHORT_SIZE;
-    n = length / TTF_USHORT_SIZE;       /* number of glyphID's */
+    /*tex number of glyphID's */
+    n = length / TTF_USHORT_SIZE;
     glyphId = xtalloc((unsigned) n, TTF_USHORT);
     for (i = 0; i < n; i++)
         glyphId[i] = get_ushort();
@@ -935,9 +712,7 @@ static ttf_cmap_entry *ttf_read_cmap(char *ttf_name, int pid, int eid,
                 if (s->idRangeOffset == 0)
                     index = (s->idDelta + i) & 0xFFFF;
                 else {
-                    k = (i - s->startCode) + s->idRangeOffset / 2 +
-                        (s - seg_tab) - segCount;
-                    assert(k >= 0 && k < n);
+                    k = (i - s->startCode) + s->idRangeOffset / 2 + (s - seg_tab) - segCount;
                     index = glyphId[k];
                     if (index != 0)
                         index = (index + s->idDelta) & 0xFFFF;
@@ -958,12 +733,12 @@ static ttf_cmap_entry *ttf_read_cmap(char *ttf_name, int pid, int eid,
     xfree(seg_tab);
     xfree(glyphId);
     aa = avl_probe(ttf_cmap_tree, p);
-    assert(aa != NULL);
+    if (aa == NULL) {
+        /*tex Is this a problem? */
+    }
     return p;
 }
 
-@
-@c
 static void ttf_read_font(void)
 {
     ttf_read_tabdir();
@@ -995,7 +770,6 @@ static void ttf_reset_chksm(PDF pdf, dirtab_entry * tab)
         formatted_warning("ttf font","offset of `%4.4s' is not a multiple of 4", tab->tag);
 }
 
-
 static void ttf_set_chksm(PDF pdf, dirtab_entry * tab)
 {
     tab->length = (TTF_ULONG) ttf_offset() - tab->offset;
@@ -1012,17 +786,17 @@ static void ttf_copytab(PDF pdf, const char *name)
     ttf_set_chksm(pdf, tab);
 }
 
-@
-@c
-#define BYTE_ENCODING_LENGTH  \
-    ((256)*TTF_BYTE_SIZE + 3*TTF_USHORT_SIZE)
+#define BYTE_ENCODING_LENGTH ((256)*TTF_BYTE_SIZE + 3*TTF_USHORT_SIZE)
 
 static void ttf_byte_encoding(PDF pdf)
 {
     ttfenc_entry *e;
-    (void) put_ushort(0);       /* format number (0: byte encoding table) */
-    (void) put_ushort(BYTE_ENCODING_LENGTH);    /* length of table */
-    (void) put_ushort(0);       /* version number */
+    /*tex Format number (0: byte encoding table) */
+    (void) put_ushort(0);
+    /*tex The length of the table */
+    (void) put_ushort(BYTE_ENCODING_LENGTH);
+    /*tex The version number */
+    (void) put_ushort(0);
     for (e = ttfenc_tab; e - ttfenc_tab < 256; e++)
         if (e->newindex < 256) {
             put_byte(e->newindex);
@@ -1031,67 +805,87 @@ static void ttf_byte_encoding(PDF pdf)
                 formatted_warning("ttf font",
                     "glyph '%s' has been mapped to '%s' in 'ttf_byte_encoding' cmap table",
                     e->name, notdef);
-            put_byte(0);        /* notdef */
+            /*tex |.notdef|: */
+            put_byte(0);
         }
 }
 
-@
-@c
 #define TRIMMED_TABLE_MAP_LENGTH (TTF_USHORT_SIZE*(5 + (256)))
 
 static void ttf_trimmed_table_map(PDF pdf)
 {
     ttfenc_entry *e;
-    (void) put_ushort(6);       /* format number (6): trimmed table mapping */
+    /*tex format number 6: trimmed table mapping */
+    (void) put_ushort(6);
     (void) put_ushort(TRIMMED_TABLE_MAP_LENGTH);
-    (void) put_ushort(0);       /* version number (0) */
-    (void) put_ushort(0);       /* first character code */
-    (void) put_ushort(256);     /* number of character code in table */
-    for (e = ttfenc_tab; e - ttfenc_tab < 256; e++)
+    /*tex version number 0 */
+    (void) put_ushort(0);
+    /*tex first character code */
+    (void) put_ushort(0);
+    /*tex number of character code in table: */
+    (void) put_ushort(256);
+    for (e = ttfenc_tab; e - ttfenc_tab < 256; e++) {
         (void) put_ushort(e->newindex);
+    }
 }
 
-@
-@c
 #define SEG_MAP_DELTA_LENGTH ((16 + (256))*TTF_USHORT_SIZE)
 
 static void ttf_seg_map_delta(PDF pdf)
 {
     ttfenc_entry *e;
-    (void) put_ushort(4);       /* format number (4: segment mapping to delta values) */
+    /*tex format number (4: segment mapping to delta values) */
+    (void) put_ushort(4);
     (void) put_ushort(SEG_MAP_DELTA_LENGTH);
-    (void) put_ushort(0);       /* version number */
-    (void) put_ushort(4);       /* 2*segCount */
-    (void) put_ushort(4);       /* searchRange */
-    (void) put_ushort(1);       /* entrySelector */
-    (void) put_ushort(0);       /* rangeShift */
-    (void) put_ushort(0xF0FF);  /* endCount[0] */
-    (void) put_ushort(0xFFFF);  /* endCount[1] */
-    (void) put_ushort(0);       /* reversedPad */
-    (void) put_ushort(0xF000);  /* startCount[0] */
-    (void) put_ushort(0xFFFF);  /* startCount[1] */
-    (void) put_ushort(0);       /* idDelta[0] */
-    (void) put_ushort(1);       /* idDelta[1] */
-    (void) put_ushort(2 * TTF_USHORT_SIZE);     /* idRangeOffset[0] */
-    (void) put_ushort(0);       /* idRangeOffset[1] */
-    for (e = ttfenc_tab; e - ttfenc_tab < 256; e++)
+    /*tex version number */
+    (void) put_ushort(0);
+    /*tex 2*segCount */
+    (void) put_ushort(4);
+    /*tex searchRange */
+    (void) put_ushort(4);
+    /*tex entrySelector */
+    (void) put_ushort(1);
+    /*tex rangeShift */
+    (void) put_ushort(0);
+    /*tex endCount[0] */
+    (void) put_ushort(0xF0FF);
+    /*tex endCount[1] */
+    (void) put_ushort(0xFFFF);
+    /*tex reversedPad */
+    (void) put_ushort(0);
+    /*tex startCount[0] */
+    (void) put_ushort(0xF000);
+    /*tex startCount[1] */
+    (void) put_ushort(0xFFFF);
+    /*tex idDelta[0] */
+    (void) put_ushort(0);
+    /*tex idDelta[1] */
+    (void) put_ushort(1);
+    /*tex idRangeOffset[0] */
+    (void) put_ushort(2 * TTF_USHORT_SIZE);
+    /*tex idRangeOffset[1] */
+    (void) put_ushort(0);
+    for (e = ttfenc_tab; e - ttfenc_tab < 256; e++) {
         (void) put_ushort(e->newindex);
+    }
 }
 
-@
-@c
 #define CMAP_ENTRY_LENGTH (2*TTF_USHORT_SIZE + TTF_ULONG_SIZE)
 
 static void ttf_select_cmap(void)
 {
-    assert(sizeof(new_cmap_tab) <= NEW_CMAP_SIZE * sizeof(cmap_entry));
-    new_cmap_tab[0].platform_id = 1;    /* Macintosh */
-    new_cmap_tab[0].encoding_id = 0;    /* Symbol; ignore code page */
-    new_cmap_tab[0].format = (TTF_USHORT) (new_glyphs_count < 256 ? 0   /* byte encoding */
-                                           : 6);        /* trimmed table mapping */
-    new_cmap_tab[1].platform_id = 3;    /* Microsoft */
-    new_cmap_tab[1].encoding_id = 0;    /* Symbol; ignore code page */
-    new_cmap_tab[1].format = 4; /* segment mapping to delta */
+    /*tex Macintosh */
+    new_cmap_tab[0].platform_id = 1;
+    /*tex Symbol; ignore code page */
+    new_cmap_tab[0].encoding_id = 0;
+    /*tex byte encoding (0) or trimmed table mapping (6) */
+    new_cmap_tab[0].format = (TTF_USHORT) (new_glyphs_count < 256 ? 0 : 6);
+    /*tex Microsoft */
+    new_cmap_tab[1].platform_id = 3;
+    /*tex Symbol; ignore code page */
+    new_cmap_tab[1].encoding_id = 0;
+    /*tex segment mapping to delta */
+    new_cmap_tab[1].format = 4;
 }
 
 static void ttf_write_cmap(PDF pdf)
@@ -1101,23 +895,25 @@ static void ttf_write_cmap(PDF pdf)
     dirtab_entry *tab = ttf_name_lookup("cmap", true);
     ttf_select_cmap();
     ttf_reset_chksm(pdf, tab);
-    (void) put_ushort(0);       /* table version number (0) */
-    (void) put_ushort(NEW_CMAP_SIZE);   /* number of encoding tables */
+    /*tex Table version number 0. */
+    (void) put_ushort(0);
+    /*tex Number of encoding tables. */
+    (void) put_ushort(NEW_CMAP_SIZE);
     offset = 2 * TTF_USHORT_SIZE + NEW_CMAP_SIZE * CMAP_ENTRY_LENGTH;
     for (ce = new_cmap_tab; ce - new_cmap_tab < NEW_CMAP_SIZE; ce++) {
         ce->offset = (TTF_ULONG) offset;
         switch (ce->format) {
-        case 0:
-            offset += BYTE_ENCODING_LENGTH;
-            break;
-        case 4:
-            offset += SEG_MAP_DELTA_LENGTH;
-            break;
-        case 6:
-            offset += TRIMMED_TABLE_MAP_LENGTH;
-            break;
-        default:
-            normal_error("ttf font","invalid format (it should not have happened)");
+            case 0:
+                offset += BYTE_ENCODING_LENGTH;
+                break;
+            case 4:
+                offset += SEG_MAP_DELTA_LENGTH;
+                break;
+            case 6:
+                offset += TRIMMED_TABLE_MAP_LENGTH;
+                break;
+            default:
+                normal_error("ttf font","invalid format (it should not have happened)");
         }
         (void) put_ushort(ce->platform_id);
         (void) put_ushort(ce->encoding_id);
@@ -1125,27 +921,24 @@ static void ttf_write_cmap(PDF pdf)
     }
     for (ce = new_cmap_tab; ce - new_cmap_tab < NEW_CMAP_SIZE; ce++) {
         switch (ce->format) {
-        case 0:
-            ttf_byte_encoding(pdf);
-            break;
-        case 4:
-            ttf_seg_map_delta(pdf);
-            break;
-        case 6:
-            ttf_trimmed_table_map(pdf);
-            break;
-        }
+            case 0:
+                ttf_byte_encoding(pdf);
+                break;
+            case 4:
+                ttf_seg_map_delta(pdf);
+                break;
+            case 6:
+                ttf_trimmed_table_map(pdf);
+                break;
+            }
     }
     ttf_set_chksm(pdf, tab);
 }
 
-@
-@c
 static int prepend_subset_tags(int index, char *p)
 {
     boolean is_unicode;
     int i;
-    assert(index >= 0 && index < name_record_num && fd_cur->subset_tag != NULL);
     is_unicode = (name_tab[index].platform_id == 3);
     if (is_unicode) {
         for (i = 0; i < 6; ++i) {
@@ -1174,10 +967,12 @@ static void ttf_write_name(PDF pdf)
     dirtab_entry *tab = ttf_name_lookup("name", true);
     if (is_subsetted(fd_cur->fm)) {
         l = 0;
-        for (i = 0; i < name_record_num; i++)
-            l += name_tab[i].length + 14;       /* maximum lengh of new stogare area */
+        for (i = 0; i < name_record_num; i++) {
+            /*tex Maximum lengh of new stogare area. */
+            l += name_tab[i].length + 14;
+        }
         new_name_buf = xtalloc((unsigned) l, char);
-        /* additional space for subset tags */
+        /*tex Additional space for subset tags. */
         p = new_name_buf;
         for (i = 0; i < name_record_num; i++) {
             n = name_tab + i;
@@ -1201,10 +996,10 @@ static void ttf_write_name(PDF pdf)
         new_name_buf_size = name_buf_size;
     }
     ttf_reset_chksm(pdf, tab);
-    (void) put_ushort(0);       /* Format selector */
+    (void) put_ushort(0);
+    /*tex Format selector. */
     (void) put_ushort(name_record_num);
-    (void) put_ushort(3 * TTF_USHORT_SIZE +
-                      name_record_num * 6 * TTF_USHORT_SIZE);
+    (void) put_ushort(3 * TTF_USHORT_SIZE + name_record_num * 6 * TTF_USHORT_SIZE);
     for (i = 0; i < name_record_num; i++) {
         (void) put_ushort(name_tab[i].platform_id);
         (void) put_ushort(name_tab[i].encoding_id);
@@ -1220,8 +1015,6 @@ static void ttf_write_name(PDF pdf)
         xfree(new_name_buf);
 }
 
-@
-@c
 static void ttf_write_dirtab(PDF pdf)
 {
     dirtab_entry *tab;
@@ -1249,7 +1042,7 @@ static void ttf_write_dirtab(PDF pdf)
             put_ulong((long) tab->length);
         }
     }
-    /* adjust checkSumAdjustment */
+    /*tex adjust |checkSumAdjustment| */
     tmp_ulong = 0;
     checksum = 0;
     for (p = (char *) pdf->fb->data, i = 0; i < (unsigned) save_offset;) {
@@ -1270,8 +1063,6 @@ static void ttf_write_dirtab(PDF pdf)
     ttf_seek_outbuf(save_offset);
 }
 
-@
-@c
 static void ttf_write_glyf(PDF pdf)
 {
     long *id, k;
@@ -1294,9 +1085,9 @@ static void ttf_write_glyf(PDF pdf)
                     if (glyph_tab[idx].newindex < 0) {
                         glyph_tab[idx].newindex = (TTF_SHORT) new_glyphs_count;
                         glyph_index[new_glyphs_count++] = idx;
-                        /*
-                           N.B.: Here we change |new_glyphs_count|,
-                           which appears in the condition of the |for| loop
+                        /*tex
+                           Here we change |new_glyphs_count|, which appears in
+                           the condition of the |for| loop.
                          */
                     }
                     (void) put_ushort(glyph_tab[idx].newindex);
@@ -1314,21 +1105,22 @@ static void ttf_write_glyf(PDF pdf)
                 if (flags & WE_HAVE_INSTRUCTIONS)
                     ttf_ncopy(pdf, copy_ushort());
             } else
-                ttf_ncopy(pdf, (int)
-                          (glyph_tab[*id + 1].offset - glyph_tab[*id].offset -
-                           TTF_USHORT_SIZE - 4 * TTF_FWORD_SIZE));
+                ttf_ncopy(pdf, (int) (glyph_tab[*id + 1].offset - glyph_tab[*id].offset - TTF_USHORT_SIZE - 4 * TTF_FWORD_SIZE));
         }
     }
     last_glyf_offset = (TTF_ULONG) ttf_offset() - (TTF_ULONG) new_glyf_offset;
     ttf_set_chksm(pdf, tab);
 }
 
-@ Reindexing glyphs: we append index of used glyphs to |glyph_index|
- while going through |ttfenc_tab|. After appending a new entry to
- |glyph_index| we set field |newindex| of corresponding entries in both
- |glyph_tab| and |ttfenc_tab| to the newly created index.
+/*tex
+
+    Reindexing glyphs: we append index of used glyphs to |glyph_index| while
+    going through |ttfenc_tab|. After appending a new entry to |glyph_index| we
+    set field |newindex| of corresponding entries in both |glyph_tab| and
+    |ttfenc_tab| to the newly created index.
+
+*/
 
-@c
 static void ttf_reindex_glyphs(void)
 {
     ttfenc_entry *e;
@@ -1337,14 +1129,13 @@ static void ttf_reindex_glyphs(void)
     long *t;
     ttf_cmap_entry *cmap = NULL;
     boolean cmap_not_found = false;
-
     for (e = ttfenc_tab; e - ttfenc_tab < 256; e++) {
-        e->newindex = 0;        /* index of ".notdef" glyph */
-
-        /* handle case of reencoded fonts */
+        /*tex The index of the |.notdef| glyph */
+        e->newindex = 0;
+        /*tex Handle the case of reencoded fonts. */
         if (e->name == notdef)
             continue;
-        /* scan form `index123' */
+        /*tex Scan form |index123|. */
         if (sscanf(e->name, GLYPH_PREFIX_INDEX "%i", &index) == 1) {
             if (index >= glyphs_count) {
                 formatted_warning("ttf font","'%s' out of valid range [0..%i)", e->name, glyphs_count);
@@ -1353,22 +1144,22 @@ static void ttf_reindex_glyphs(void)
             glyph = glyph_tab + index;
             goto append_new_glyph;
         }
-        /* scan form `uniABCD' */
+        /*tex Scan form |uniABCD|. */
         if (sscanf(e->name, GLYPH_PREFIX_UNICODE "%X", &index) == 1) {
             if (cmap == NULL && !cmap_not_found) {
-                /* need to read the unicode mapping, ie (pid,eid) = (3,1) or (0,3) */
+                /*tex Need to read the \UNICODE\ mapping, i.e. |(pid,eid) = (3,1) or (0,3)|. */
                 cmap = ttf_read_cmap(fd_cur->fm->ff_name, 3, 1, false);
                 if (cmap == NULL)
                     cmap = ttf_read_cmap(fd_cur->fm->ff_name, 0, 3, false);
                 if (cmap == NULL) {
+                    /*tex Once only. */
                     normal_warning("ttf font", "no unicode mapping found, all 'uniXXXX' names will be ignored");
-                    cmap_not_found = true;      /* once only */
+                    cmap_not_found = true;
                 }
             }
             if (cmap == NULL)
                 continue;
             t = cmap->table;
-            assert(t != NULL);
             if (t[index] != -1) {
                 if (t[index] >= glyphs_count) {
                     formatted_warning("ttf font", "'%s' is mapped to index %li which is out of valid range [0..%i)",
@@ -1382,7 +1173,7 @@ static void ttf_reindex_glyphs(void)
                 continue;
             }
         }
-        /* look up by name */
+        /*tex Look up by name: */
         for (glyph = glyph_tab; glyph - glyph_tab < glyphs_count; glyph++)
             if (glyph->name != notdef && strcmp(glyph->name, e->name) == 0)
                 break;
@@ -1391,7 +1182,6 @@ static void ttf_reindex_glyphs(void)
             continue;
         }
       append_new_glyph:
-        assert(glyph > glyph_tab && glyph - glyph_tab < glyphs_count);
         if (glyph->newindex < 0) {
             glyph_index[new_glyphs_count] = (short) (glyph - glyph_tab);
             glyph->newindex = (TTF_SHORT) new_glyphs_count;
@@ -1401,28 +1191,42 @@ static void ttf_reindex_glyphs(void)
     }
 }
 
-@  To calculate the checkSum for the 'head' table which itself includes the
-   checkSumAdjustment entry for the entire font, do the following:
+/*tex
+
+    To calculate the checkSum for the 'head' table which itself includes the
+    checkSumAdjustment entry for the entire font, do the following:
+
+    \startitemize
+        \startitem
+            Set the checkSumAdjustment to 0.
+        \stopitem
+        \startitem
+            Calculate the checksum for all the tables including the |head| table
+            and enter that value into the table directory.
+        \stopitem
+        \startitem
+            Calculate the checksum for the entire font.
+        \stopitem
+        \startitem
+            Subtract that value from the hex value B1B0AFBA.
+        \stopitem
+        \startitem
+            Store the result in checkSumAdjustment.
+        \stopitem
+    \startitemize
+
+    The checkSum for the 'head table which includes the checkSumAdjustment entry
+    for the entire font is now incorrect. That is not a problem. Do not change
+    it. An application attempting to verify that the 'head' table has not changed
+    should calculate the checkSum for that table by not including the
+    checkSumAdjustment value, and compare the result with the entry in the table
+    directory.
+
+    The table directory also includes the offset of the associated tagged table
+    from the beginning of the font file and the length of that table.
+
+*/
 
-     \item Set the checkSumAdjustment to 0.
-     \item  Calculate the checksum for all the tables including the 'head' table
-       and enter that value into the table directory.
-     \item  Calculate the checksum for the entire font.
-     \item  Subtract that value from the hex value B1B0AFBA.
-     \item  Store the result in checkSumAdjustment.
-
-   The checkSum for the 'head table which includes the checkSumAdjustment
-   entry for the entire font is now incorrect. That is not a problem. Do not
-   change it. An application attempting to verify that the 'head' table has
-   not changed should calculate the checkSum for that table by not including
-   the checkSumAdjustment value, and compare the result with the entry in the
-   table directory.
-
-   The table directory also includes the offset of the associated tagged
-   table from the beginning of the font file and the length of that table.
-
-
-@c
 static void ttf_write_head(PDF pdf)
 {
     dirtab_entry *tab;
@@ -1431,9 +1235,9 @@ static void ttf_write_head(PDF pdf)
     ttf_ncopy(pdf, 2 * TTF_FIXED_SIZE);
     checkSumAdjustment_offset = (TTF_ULONG) ttf_offset();
     put_ulong(0);
-    ttf_skip(TTF_ULONG_SIZE);   /* skip checkSumAdjustment */
-    ttf_ncopy(pdf, TTF_ULONG_SIZE + 2 * TTF_USHORT_SIZE + 16 +
-              4 * TTF_FWORD_SIZE + 2 * TTF_USHORT_SIZE + TTF_SHORT_SIZE);
+    /*tex skip |checkSumAdjustment| */
+    ttf_skip(TTF_ULONG_SIZE);
+    ttf_ncopy(pdf, TTF_ULONG_SIZE + 2 * TTF_USHORT_SIZE + 16 + 4 * TTF_FWORD_SIZE + 2 * TTF_USHORT_SIZE + TTF_SHORT_SIZE);
     if (is_subsetted(fd_cur->fm)) {
         (void) put_short(loca_format);
         (void) put_short(0);
@@ -1442,21 +1246,16 @@ static void ttf_write_head(PDF pdf)
     ttf_set_chksm(pdf, tab);
 }
 
-@
-@c
 static void ttf_write_hhea(PDF pdf)
 {
     dirtab_entry *tab;
     tab = ttf_seek_tab("hhea", 0);
     ttf_reset_chksm(pdf, tab);
-    ttf_ncopy(pdf, TTF_FIXED_SIZE + 3 * TTF_FWORD_SIZE + TTF_UFWORD_SIZE +
-              3 * TTF_FWORD_SIZE + 8 * TTF_SHORT_SIZE);
+    ttf_ncopy(pdf, TTF_FIXED_SIZE + 3 * TTF_FWORD_SIZE + TTF_UFWORD_SIZE + 3 * TTF_FWORD_SIZE + 8 * TTF_SHORT_SIZE);
     (void) put_ushort(new_glyphs_count);
     ttf_set_chksm(pdf, tab);
 }
 
-@
-@c
 static void ttf_write_htmx(PDF pdf)
 {
     long *id;
@@ -1469,8 +1268,6 @@ static void ttf_write_htmx(PDF pdf)
     ttf_set_chksm(pdf, tab);
 }
 
-@
-@c
 static void ttf_write_loca(PDF pdf)
 {
     long *id;
@@ -1497,8 +1294,6 @@ static void ttf_write_loca(PDF pdf)
     ttf_set_chksm(pdf, tab);
 }
 
-@
-@c
 static void ttf_write_mapx(PDF pdf)
 {
     dirtab_entry *tab = ttf_seek_tab("maxp", TTF_FIXED_SIZE + TTF_USHORT_SIZE);
@@ -1509,37 +1304,41 @@ static void ttf_write_mapx(PDF pdf)
     ttf_set_chksm(pdf, tab);
 }
 
-@
-@c
 static void ttf_write_OS2(PDF pdf)
 {
     dirtab_entry *tab = ttf_seek_tab("OS/2", 0);
     TTF_USHORT version;
     ttf_reset_chksm(pdf, tab);
     version = get_ushort();
-    if (version > 3)
+    if (version > 3) {
         formatted_error("ttf font","unknown version '%.4X' of OS/2 table", version);
-    (void) put_ushort(0x0001);  /* fix version to 1 */
-    ttf_ncopy(pdf,
-              2 * TTF_USHORT_SIZE + 13 * TTF_SHORT_SIZE + 10 * TTF_BYTE_SIZE);
-    ttf_skip(4 * TTF_ULONG_SIZE);       /* ulUnicodeRange 1--4 */
-    put_ulong(0x00000003);      /* Basic Latin + Latin-1 Supplement (0x0000--0x00FF) */
-    put_ulong(0x10000000);      /* Private Use (0xE000--0xF8FF) */
+    }
+    /*tex fix version to 1 */
+    (void) put_ushort(0x0001);
+    ttf_ncopy(pdf,2 * TTF_USHORT_SIZE + 13 * TTF_SHORT_SIZE + 10 * TTF_BYTE_SIZE);
+    /*tex |ulUnicodeRange| 1--4 */
+    ttf_skip(4 * TTF_ULONG_SIZE);
+    /*tex Basic Latin + Latin-1 Supplement (0x0000--0x00FF) */
+    put_ulong(0x00000003);
+    /*tex Private Use (0xE000--0xF8FF) */
+    put_ulong(0x10000000);
     put_ulong(0x00000000);
     put_ulong(0x00000000);
-    ttf_ncopy(pdf, 4 * TTF_CHAR_SIZE + TTF_USHORT_SIZE);        /* achVendID + fsSelection */
+    /*tex |achVendID| + |fsSelection| */
+    ttf_ncopy(pdf, 4 * TTF_CHAR_SIZE + TTF_USHORT_SIZE);
     ttf_skip(2 * TTF_USHORT_SIZE);
-    (void) put_ushort(0x0000);  /* usFirstCharIndex */
-    (void) put_ushort(0xF0FF);  /* usLastCharIndex */
+    /*tex |usFirstCharIndex| */
+    (void) put_ushort(0x0000);
+    /*tex |usLastCharIndex| */
+    (void) put_ushort(0xF0FF);
     ttf_ncopy(pdf, 5 * TTF_USHORT_SIZE);
-    /* for version 0 the OS/2 table ends here, the rest is for version 1 */
-    put_ulong(0x80000000);      /* Symbol Character Set---don't use any code page */
+    /*tex For version 0 the OS/2 table ends here, the rest is for version 1. */
+    /*tex Symbol Character Set: don't use any code page */
+    put_ulong(0x80000000);
     put_ulong(0x00000000);
     ttf_set_chksm(pdf, tab);
 }
 
-@
-@c
 static boolean unsafe_name(const char *s)
 {
     const char **p;
@@ -1559,12 +1358,10 @@ static void ttf_write_post(PDF pdf)
     ttf_reset_chksm(pdf, tab);
     if (!fd_cur->write_ttf_glyph_names || post_format == 0x00030000) {
         put_fixed(0x00030000);
-        ttf_ncopy(pdf,
-                  TTF_FIXED_SIZE + 2 * TTF_FWORD_SIZE + 5 * TTF_ULONG_SIZE);
+        ttf_ncopy(pdf, TTF_FIXED_SIZE + 2 * TTF_FWORD_SIZE + 5 * TTF_ULONG_SIZE);
     } else {
         put_fixed(0x00020000);
-        ttf_ncopy(pdf,
-                  TTF_FIXED_SIZE + 2 * TTF_FWORD_SIZE + 5 * TTF_ULONG_SIZE);
+        ttf_ncopy(pdf, TTF_FIXED_SIZE + 2 * TTF_FWORD_SIZE + 5 * TTF_ULONG_SIZE);
         (void) put_ushort(new_glyphs_count);
         k = 0;
         for (id = glyph_index; id - glyph_index < new_glyphs_count; id++) {
@@ -1587,22 +1384,23 @@ static void ttf_write_post(PDF pdf)
     ttf_set_chksm(pdf, tab);
 }
 
-@
-@c
 static void ttf_init_font(PDF pdf, int n)
 {
     int i, k;
     for (i = 1, k = 0; i <= n; i <<= 1, k++);
-    put_fixed(0x00010000);      /* font version */
-    (void) put_ushort(n);       /* number of tables */
-    (void) put_ushort(i << 3);  /* search range */
-    (void) put_ushort(k - 1);   /* entry selector */
-    (void) put_ushort((n << 4) - (i << 3));     /* range shift */
+    /*tex font version */
+    put_fixed(0x00010000);
+    /*tex number of tables */
+    (void) put_ushort(n);
+    /*tex search range */
+    (void) put_ushort(i << 3);
+    /*tex entry selector */
+    (void) put_ushort(k - 1);
+    /*tex range shift */
+    (void) put_ushort((n << 4) - (i << 3));
     ttf_seek_outbuf(TABDIR_OFF + n * 4 * TTF_ULONG_SIZE);
 }
 
-@
-@c
 static void ttf_subset_font(PDF pdf)
 {
     ttf_init_font(pdf, new_ntabs);
@@ -1628,8 +1426,6 @@ static void ttf_subset_font(PDF pdf)
     ttf_write_dirtab(pdf);
 }
 
-@
-@c
 static void ttf_copy_font(PDF pdf)
 {
     dirtab_entry *tab;
@@ -1643,33 +1439,25 @@ static void ttf_copy_font(PDF pdf)
     ttf_write_dirtab(pdf);
 }
 
-@
-@c
 void writettf(PDF pdf, fd_entry * fd)
 {
     int callback_id;
     int file_opened = 0;
-    fd_cur = fd;                /* |fd_cur| is global inside \.{writettf.w} */
-    assert(fd_cur->fm != NULL);
-    assert(is_truetype(fd_cur->fm));
-    assert(is_included(fd_cur->fm));
-
+    /* The next one is global inside |writettf.c| */
+    fd_cur = fd;
     if (is_subsetted(fd_cur->fm) && (fd_cur->fe == NULL)) {
         normal_error("ttf font","subset must be a reencoded font");
     }
     ttf_curbyte = 0;
     ttf_size = 0;
-
-    cur_file_name =
-        luatex_find_file(fd_cur->fm->ff_name, find_truetype_file_callback);
+    cur_file_name = luatex_find_file(fd_cur->fm->ff_name, find_truetype_file_callback);
     if (cur_file_name == NULL) {
         formatted_error("ttf font","cannot find font file for reading '%s'", fd_cur->fm->ff_name);
     }
     callback_id = callback_defined(read_truetype_file_callback);
     if (callback_id > 0) {
-        if (run_callback(callback_id, "S->bSd", cur_file_name,
-                         &file_opened, &ttf_buffer, &ttf_size) &&
-            file_opened && ttf_size > 0) {
+        if (run_callback(callback_id, "S->bSd", cur_file_name, &file_opened, &ttf_buffer, &ttf_size) && file_opened && ttf_size > 0) {
+            /* We're okay. */
         } else {
             formatted_error("ttf font","cannot open font file for reading '%s'", cur_file_name);
         }
@@ -1696,7 +1484,6 @@ void writettf(PDF pdf, fd_entry * fd)
     name_tab = NULL;
     name_buf = NULL;
     ttf_read_font();
-
     pdf_save_offset(pdf);
     pdf_flush(pdf);
     if (is_subsetted(fd_cur->fm)) {
@@ -1705,7 +1492,6 @@ void writettf(PDF pdf, fd_entry * fd)
     } else
         ttf_copy_font(pdf);
     ttf_length = ttf_offset();
-
     xfree(dir_tab);
     xfree(glyph_tab);
     xfree(glyph_index);
@@ -1732,7 +1518,7 @@ static void do_writeotf(PDF pdf, fd_entry * fd)
     if (tracefilenames)
         tex_printf("<<%s", cur_file_name);
     ttf_read_tabdir();
-    /* read font parameters */
+    /*tex Read teh font parameters. */
     if (ttf_name_lookup("head", false) != NULL)
         ttf_read_head();
     if (ttf_name_lookup("hhea", false) != NULL)
@@ -1741,10 +1527,10 @@ static void do_writeotf(PDF pdf, fd_entry * fd)
         ttf_read_pclt();
     if (ttf_name_lookup("post", false) != NULL)
         ttf_read_post();
-    /* copy font file */
-    if (ttf_name_lookup("CFF2", false) != NULL)      /* HH */
-        tab = ttf_seek_tab("CFF2", 0);               /* HH */
-    else                                             /* HH */
+    /*tex Copy the font file: */
+    if (ttf_name_lookup("CFF2", false) != NULL)
+        tab = ttf_seek_tab("CFF2", 0);
+    else
         tab = ttf_seek_tab("CFF ", 0);
     for (i = (long) tab->length; i > 0; i--) {
         copy_char();
@@ -1754,30 +1540,21 @@ static void do_writeotf(PDF pdf, fd_entry * fd)
         tex_printf(">>");
 }
 
-@
-@c
 void writeotf(PDF pdf, fd_entry * fd)
 {
     int callback_id;
     int file_opened = 0;
-
     fd_cur = fd;
-    assert(fd_cur->fm != NULL);
-    assert(is_opentype(fd_cur->fm));
-    assert(is_included(fd_cur->fm));
-
     ttf_curbyte = 0;
     ttf_size = 0;
-    cur_file_name =
-        luatex_find_file(fd_cur->fm->ff_name, find_opentype_file_callback);
+    cur_file_name = luatex_find_file(fd_cur->fm->ff_name, find_opentype_file_callback);
     if (cur_file_name == NULL) {
         formatted_error("otf font","cannot find font file for reading '%s'", fd_cur->fm->ff_name);
     }
     callback_id = callback_defined(read_opentype_file_callback);
     if (callback_id > 0) {
-        if (run_callback(callback_id, "S->bSd", cur_file_name,
-                         &file_opened, &ttf_buffer, &ttf_size) &&
-            file_opened && ttf_size > 0) {
+        if (run_callback(callback_id, "S->bSd", cur_file_name, &file_opened, &ttf_buffer, &ttf_size) && file_opened && ttf_size > 0) {
+            /*tex We're okay. */
         } else {
             formatted_error("otf font","cannot open font file for reading '%s'", cur_file_name);
         }
@@ -1788,7 +1565,6 @@ void writeotf(PDF pdf, fd_entry * fd)
         ttf_read_file();
         ttf_close();
     }
-
     fd_cur->ff_found = true;
     do_writeotf(pdf, fd);
     xfree(ttf_buffer);
diff --git a/texk/web2c/luatexdir/font/writetype0.w b/texk/web2c/luatexdir/font/writetype0.c
similarity index 69%
rename from texk/web2c/luatexdir/font/writetype0.w
rename to texk/web2c/luatexdir/font/writetype0.c
index ebf4be667..7a81d58c9 100644
--- a/texk/web2c/luatexdir/font/writetype0.w
+++ b/texk/web2c/luatexdir/font/writetype0.c
@@ -1,29 +1,34 @@
-% writetype0.w
-%
-% Copyright 2006-2008 Taco Hoekwater <taco@@luatex.org>
-%
-% This file is part of LuaTeX.
-%
-% LuaTeX is free software; you can redistribute it and/or modify it under
-% the terms of the GNU General Public License as published by the Free
-% Software Foundation; either version 2 of the License, or (at your
-% option) any later version.
-%
-% LuaTeX is distributed in the hope that it will be useful, but WITHOUT
-% ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-% FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
-% License for more details.
-%
-% You should have received a copy of the GNU General Public License along
-% with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+/*
 
-@ @c
+Copyright 2006-2008 Taco Hoekwater <taco@luatex.org>
+
+This file is part of LuaTeX.
+
+LuaTeX is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 2 of the License, or (at your
+option) any later version.
+
+LuaTeX is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+License for more details.
+
+You should have received a copy of the GNU General Public License along
+with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+
+*/
 
 #include "ptexlib.h"
 #include "font/writettf.h"
 #include "font/writecff.h"
 
-@ @c
+/*tex
+
+    Here we also support the newer CFF2 specification,
+
+*/
+
 extern unsigned char *ttf_buffer;
 
 void writetype0(PDF pdf, fd_entry * fd)
@@ -34,15 +39,13 @@ void writetype0(PDF pdf, fd_entry * fd)
     dirtab_entry *tab;
     cff_font *cff;
     sfnt *sfont;
-
     dir_tab = NULL;
     glyph_tab = NULL;
-
-    fd_cur = fd;                /* |fd_cur| is global inside \.{writettf.w} */
+    /*tex |fd_cur| is global inside |writettf.c| */
+    fd_cur = fd;
     assert(fd_cur->fm != NULL);
     assert(is_opentype(fd_cur->fm) || is_truetype(fd_cur->fm));
     assert(is_included(fd_cur->fm));
-
     ttf_curbyte = 0;
     ttf_size = 0;
     cur_file_name =
@@ -69,9 +72,7 @@ void writetype0(PDF pdf, fd_entry * fd)
         ttf_read_file();
         ttf_close();
     }
-
     fd_cur->ff_found = true;
-
     sfont = sfnt_open(ttf_buffer, ttf_size);
     if (sfont->type == SFNT_TYPE_TTC)
         i = ff_get_ttc_index(fd->fm->ff_name, fd->fm->ps_name);
@@ -86,7 +87,7 @@ void writetype0(PDF pdf, fd_entry * fd)
     else ttf_read_tabdir();
     sfnt_close(sfont);
 
-    /* read font parameters */
+    /*tex Read font parameters: */
     if (ttf_name_lookup("head", false) != NULL)
         ttf_read_head();
     if (ttf_name_lookup("hhea", false) != NULL)
@@ -95,32 +96,25 @@ void writetype0(PDF pdf, fd_entry * fd)
         ttf_read_pclt();
     if (ttf_name_lookup("post", false) != NULL)
         ttf_read_post();
-
-    /* copy font file */
-    if (ttf_name_lookup("CFF2", false) != NULL)      /* HH */
-        tab = ttf_seek_tab("CFF2", 0);               /* HH */
-    else                                             /* HH */
+    /*tex Copy font file, including the newer variant: */
+    if (ttf_name_lookup("CFF2", false) != NULL)
+        tab = ttf_seek_tab("CFF2", 0);
+    else
         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);
     if (!is_subsetted(fd_cur->fm)) {
-        /* not subsetted, just do a copy */
+        /*tex not subsetted, copy: */
         for (i = (long) tab->length; i > 0; i--)
             strbuf_putchar(pdf->fb, (unsigned char) ttf_getnum(1));
     } else {
         if (cff != NULL) {
             if (cff_is_cidfont(cff)) {
                 write_cid_cff(pdf, cff, fd_cur);
-#if 0
-                for (i = tab->length; i > 0; i--)
-                    strbuf_putchar(pdf->fb, (unsigned char) ttf_getnum(1));
-#endif
             } else {
                 write_cff(pdf, cff, fd_cur);
             }
         } else {
-            /* not understood, just do a copy */
+            /*tex Just copy: */
             for (i = (long) tab->length; i > 0; i--)
                 strbuf_putchar(pdf->fb, (unsigned char) ttf_getnum(1));
         }
diff --git a/texk/web2c/luatexdir/font/writetype2.w b/texk/web2c/luatexdir/font/writetype2.c
similarity index 65%
rename from texk/web2c/luatexdir/font/writetype2.w
rename to texk/web2c/luatexdir/font/writetype2.c
index 81aefb1fb..b8a746090 100644
--- a/texk/web2c/luatexdir/font/writetype2.w
+++ b/texk/web2c/luatexdir/font/writetype2.c
@@ -1,24 +1,23 @@
-% writetype2.w
-%
-% Copyright 2006-2012 Taco Hoekwater <taco@@luatex.org>
-%
-% This file is part of LuaTeX.
-%
-% LuaTeX is free software; you can redistribute it and/or modify it under
-% the terms of the GNU General Public License as published by the Free
-% Software Foundation; either version 2 of the License, or (at your
-% option) any later version.
-%
-% LuaTeX is distributed in the hope that it will be useful, but WITHOUT
-% ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-% FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
-% License for more details.
-%
-% You should have received a copy of the GNU General Public License along
-% with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
-
-@ @c
+/*
 
+Copyright 2006-2012 Taco Hoekwater <taco@luatex.org>
+
+This file is part of LuaTeX.
+
+LuaTeX is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 2 of the License, or (at your
+option) any later version.
+
+LuaTeX is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+License for more details.
+
+You should have received a copy of the GNU General Public License along
+with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+
+*/
 
 #include "ptexlib.h"
 #include "font/writettf.h"
@@ -28,15 +27,22 @@
 #include "font/sfnt.h"
 #include "font/tt_glyf.h"
 
-@ forward declaration
-@c
+/*tex
+
+    Forward declarations
+
+*/
+
 boolean make_tt_subset(PDF pdf, fd_entry * fd, unsigned char *buff, int buflen);
 
-@ @c
 unsigned long cidtogid_obj = 0;
 
-@ low-level helpers
-@c
+/*tex
+
+    Low-level helpers (a weird place):
+
+*/
+
 #define test_loc(l) \
     if ((f->loc + l) > f->buflen) { \
         normal_error("type 2","the file ended prematurely"); \
@@ -96,55 +102,23 @@ int do_sfnt_read(unsigned char *dest, int len, sfnt * f)
     return len;
 }
 
-pdf_obj *pdf_new_stream(void)
-{
-    pdf_obj *stream = xmalloc(sizeof(pdf_obj));
-    stream->length = 0;
-    stream->data = NULL;
-    return stream;
-}
+/*tex
 
-void pdf_add_stream(pdf_obj * stream, unsigned char *buf, long len)
-{
-    int i;
-    assert(stream != NULL);
-    if (stream->data == NULL) {
-        stream->data = xmalloc((unsigned) len);
-    } else {
-        stream->data =
-            xrealloc(stream->data, (unsigned) len + (unsigned) stream->length);
-    }
-    for (i = 0; i < len; i++) {
-        *(stream->data + stream->length + i) = *(buf + i);
-    }
-    stream->length += (unsigned) len;
-}
+    The main function:
 
-void pdf_release_obj(pdf_obj * stream)
-{
-    if (stream != NULL) {
-        if (stream->data != NULL) {
-            xfree(stream->data);
-        }
-        xfree(stream);
-    }
-}
+*/
 
-@ The main function.
-@c
 boolean writetype2(PDF pdf, fd_entry * fd)
 {
     int callback_id;
     int file_opened = 0;
     boolean ret;
-
     glyph_tab = NULL;
-
-    fd_cur = fd;                /* |fd_cur| is global inside \.{writettf.w} */
+    /*tex |fd_cur| is global inside |writettf.c| */
+    fd_cur = fd;
     assert(fd_cur->fm != NULL);
     assert(is_truetype(fd_cur->fm));
     assert(is_included(fd_cur->fm));
-
     ttf_curbyte = 0;
     ttf_size = 0;
     cur_file_name =
@@ -167,20 +141,13 @@ boolean writetype2(PDF pdf, fd_entry * fd)
         ttf_read_file();
         ttf_close();
     }
-
     fd_cur->ff_found = true;
-
     if (is_subsetted(fd_cur->fm))
         report_start_file(filetype_subset,cur_file_name);
      else
         report_start_file(filetype_font,cur_file_name);
-
-    /* here is the real work */
-
+    /*tex Here is the real work done: */
     ret = make_tt_subset(pdf, fd, ttf_buffer, ttf_size);
-#if 0
-    xfree (dir_tab);
-#endif
     xfree(ttf_buffer);
     if (is_subsetted(fd_cur->fm))
         report_stop_file(filetype_subset);
@@ -190,72 +157,69 @@ boolean writetype2(PDF pdf, fd_entry * fd)
     return ret;
 }
 
-@ PDF viewer applications use following tables (CIDFontType 2)
-
-\.{head, hhea, loca, maxp, glyf, hmtx, fpgm, cvt\_, prep}
-
-\rightline{from PDF Ref. v.1.3, 2nd ed.}
+/*tex
 
- The \.{fpgm}, \.{cvt\_} and \.{prep} tables appears only when TrueType instructions
- requires them. Those tables must be preserved if they exist.
- We use |must_exist| flag to indicate `preserve it if present'
- and to make sure not to cause an error when it does not exist.
+    The \PDF\ viewer applications use following tables for CIDFontType 2: |head|,
+    |hhea|, |loca|, |maxp|, |glyf|, |hmtx|, |fpgm|, |cvt| and |prep|. According
+    to PDF Ref. v.1.3, 2nd ed. The |fpgm\, |cvt| and |prep| tables appears only
+    when TrueType instructions requires them. Those tables must be preserved if
+    they exist. We use |must_exist| flag to indicate `preserve it if present' and
+    to make sure not to cause an error when it does not exist. The |post\ and
+    |name| tables must exist in ordinary TrueType font file, but when a TrueType
+    font is converted to CIDFontType 2 font, those tables are no longer required.
+    The |OS/2| table (required for TrueType font for Windows and OS/2) contains
+    liscencing information, but PDF viewers seems not using them. The |name|
+    table as been added added too (see comments in |writettf.c|.
 
- \.{post} and \.{name} table must exist in ordinary TrueType font file,
- but when a TrueType font is converted to CIDFontType 2 font, those tables
- are no longer required.
+*/
 
- The OS/2 table (required for TrueType font for Windows and OS/2) contains
- liscencing information, but PDF viewers seems not using them.
-
- The \.{name} table added. See comments in \.{writettf.w}.
-
-@c
 static struct {
     const char *name;
     int must_exist;
-} required_table[] = {
-    {
-    "OS/2", 0}, {
-    "cmap", 0}, {
-    "head", 1}, {
-    "hhea", 1}, {
-    "loca", 1}, {
-    "maxp", 0}, {
-    "name", 1}, {
-    "glyf", 1}, {
-    "hmtx", 1}, {
-    "fpgm", 0}, {
-    "cvt ", 0}, {
-    "prep", 0}, {
-    NULL, 0}
-};
+}
 
+required_table[] = {
+    { "OS/2", 0 },
+    { "cmap", 0 },
+    { "head", 1 },
+    { "hhea", 1 },
+    { "loca", 1 },
+    { "maxp", 0 },
+    { "name", 1 },
+    { "glyf", 1 },
+    { "hmtx", 1 },
+    { "fpgm", 0 },
+    { "cvt ", 0 },
+    { "prep", 0 },
+    { NULL,   0 }
+};
 
 unsigned long ttc_read_offset(sfnt * sfont, int ttc_idx, fd_entry * fd)
 {
-    /*ULONG version;*/
     unsigned long offset = 0;
     unsigned long num_dirs = 0;
-
-    sfnt_seek_set(sfont, 4);    /* skip version tag */
-
-    /*version = */(void)sfnt_get_ulong(sfont);
+    /*tex Skip the |ULONG| version tag: */
+    sfnt_seek_set(sfont, 4);
+    /* version = */ (void)sfnt_get_ulong(sfont);
     num_dirs = sfnt_get_ulong(sfont);
     if (ttc_idx < 0 || ttc_idx > (int) (num_dirs - 1)) {
-        formatted_error("type 2","invalid TTC index number %i (0..%i), using index 0 for font %s",
+        formatted_error("type 2",
+            "invalid TTC index number %i (0..%i), using index 0 for font %s",
             ttc_idx,(int) (num_dirs - 1),(fd->fm->ps_name ? fd->fm->ps_name : ""));
         return 0 ;
     }
     sfnt_seek_set(sfont, 12 + ttc_idx * 4);
     offset = sfnt_get_ulong(sfont);
-
     return offset;
 }
 
-@ Creating the subset.
-@c
+/*tex
+
+    Creating the subset.
+*/
+
 extern int cidset;
+
 boolean make_tt_subset(PDF pdf, fd_entry * fd, unsigned char *buff, int buflen)
 {
 
@@ -270,48 +234,38 @@ boolean make_tt_subset(PDF pdf, fd_entry * fd, unsigned char *buff, int buflen)
     sfnt *sfont;
     pdf_obj *fontfile;
     int error = 0;
-
     cidtogidmap = NULL;
-
     sfont = sfnt_open(buff, buflen);
-
     if (sfont->type == SFNT_TYPE_TTC) {
         i = ff_get_ttc_index(fd->fm->ff_name, fd->fm->ps_name);
         error = sfnt_read_table_directory(sfont, ttc_read_offset(sfont, (int) i, fd));
     } else {
         error = sfnt_read_table_directory(sfont, 0);
     }
-
     if (error < 0) {
         normal_error("type 2","parsing the TTF directory fails");
     }
-
     if (sfont->type == SFNT_TYPE_TTC && sfnt_find_table_pos(sfont, "CFF ")) {
         sfnt_close(sfont);
-	return false;
+        return false;
     }
-
     if (is_subsetted(fd->fm)) {
-        /* rebuild the glyph tables and create a fresh cidmap */
+        /*tex Rebuild the glyph tables and create a fresh cidmap :*/
         glyphs = tt_build_init();
-
         last_cid = 0;
-
         avl_t_init(&t, fd->gl_tree);
         for (found = (glw_entry *) avl_t_first(&t, fd->gl_tree);
              found != NULL; found = (glw_entry *) avl_t_next(&t)) {
             if (found->id > last_cid)
                 last_cid = found->id;
         }
-
 #ifndef NO_GHOSTSCRIPT_BUG
         cidtogidmap = NULL;
 #else
         cidtogidmap = xmalloc(((last_cid + 1) * 2) * sizeof(unsigned char));
         memset(cidtogidmap, 0, (last_cid + 1) * 2);
 #endif
-
-        /* fill |used_chars| */
+        /*tex Fill |used_chars|: */
         used_chars = xmalloc((last_cid + 1) * sizeof(char));
         memset(used_chars, 0, (last_cid + 1));
         avl_t_init(&t, fd->gl_tree);
@@ -319,56 +273,44 @@ boolean make_tt_subset(PDF pdf, fd_entry * fd, unsigned char *buff, int buflen)
              found != NULL; found = (glw_entry *) avl_t_next(&t)) {
             used_chars[found->id] = 1;
         }
-
-        /* Map CIDs to GIDs. */
-
-        num_glyphs = 1;         /* \.{.notdef} */
+        /*tex Map CIDs to GIDs, with |.notdef| in slot zero: */
+        num_glyphs = 1;
         for (cid = 1; cid <= (long) last_cid; cid++) {
             if (used_chars[cid] == 0)
                 continue;
             gid = (short unsigned) cid;
-
-
 #ifndef NO_GHOSTSCRIPT_BUG
             gid = tt_add_glyph(glyphs, (USHORT) gid, (USHORT) cid);
 #else
             gid = tt_add_glyph(glyphs, (USHORT) gid, (USHORT) num_glyphs);
             cidtogidmap[2 * cid] = gid >> 8;
             cidtogidmap[2 * cid + 1] = gid & 0xff;
-#endif                          /* |!NO_GHOSTSCRIPT_BUG| */
-
+#endif
             num_glyphs++;
         }
 
         if (num_glyphs == 1) {
             normal_error("type 2","there are no glyphs in the subset");
         }
-
         if (tt_build_tables(sfont, glyphs, fd) < 0) {
             normal_error("type 2","the TTF buffer can't be parsed");
         }
-
         tt_build_finish(glyphs);
     }
-
-    /* Create font file */
-
+    /*tex Create the font file: */
     for (i = 0; required_table[i].name; i++) {
         if (sfnt_require_table(sfont,required_table[i].name, required_table[i].must_exist) < 0) {
             normal_error("type 2","some required TrueType table does not exist");
         }
     }
-
     fontfile = sfnt_create_FontFile_stream(sfont);
-
-    /* squeeze in the cidgidmap */
+    /*tex The |cidgidmap|: */
     if (cidtogidmap != NULL) {
         cidtogid_obj = (unsigned long) pdf_create_obj(pdf, obj_type_others, 0);
         pdf_begin_obj(pdf, (int) cidtogid_obj, OBJSTM_NEVER);
         pdf_begin_dict(pdf);
         pdf_dict_add_int(pdf, "Length", ((last_cid + 1) * 2));
         pdf_end_dict(pdf);
-        assert(0);              /* code unused */
         pdf_begin_stream(pdf);
         pdf_room(pdf, (int) ((last_cid + 1) * 2));
         for (i = 0; i < ((int) (last_cid + 1) * 2); i++) {
@@ -377,15 +319,14 @@ boolean make_tt_subset(PDF pdf, fd_entry * fd, unsigned char *buff, int buflen)
         pdf_end_stream(pdf);
         pdf_end_obj(pdf);
     }
-
-    /* the tff subset */
+    /*tex The tff subset: */
     for (i = 0; i < (int) (fontfile->length); i++)
         strbuf_putchar(pdf->fb, fontfile->data[i]);
-
     pdf_release_obj(fontfile);
-
-    /* CIDSet: a table of bits indexed by cid, bytes with high order bit first,
-       each (set) bit is a (present) CID. */
+    /*tex
+        |CIDSet| is a table of bits indexed by cid, bytes with high order bit
+        first, each (set) bit is a (present) CID.
+    */
     if (is_subsetted(fd->fm)) {
         if ((! pdf->omit_cidset) && (pdf->major_version == 1)) {
             cidset = pdf_create_obj(pdf, obj_type_others, 0);
@@ -409,23 +350,6 @@ boolean make_tt_subset(PDF pdf, fd_entry * fd, unsigned char *buff, int buflen)
             }
         }
     }
-
-    /* TODO other stuff that needs fixing: */
-
-    /* DW, W, DW2, and W2 */
-#if 0
-    if (opt_flags & CIDFONT_FORCE_FIXEDPITCH) {
-        pdf_add_dict(font->fontdict,
-                     pdf_new_name("DW"), pdf_new_number(1000.0));
-    } else {
-        add_TTCIDHMetrics(font->fontdict, glyphs, used_chars, cidtogidmap,
-                          last_cid);
-        if (v_used_chars)
-            add_TTCIDVMetrics(font->fontdict, glyphs, used_chars, cidtogidmap,
-                              last_cid);
-    }
-#endif
-
     xfree(used_chars);
     sfnt_close(sfont);
     return true;
diff --git a/texk/web2c/luatexdir/image/pdftoepdf.c b/texk/web2c/luatexdir/image/pdftoepdf.c
new file mode 100644
index 000000000..b29493b07
--- /dev/null
+++ b/texk/web2c/luatexdir/image/pdftoepdf.c
@@ -0,0 +1,1049 @@
+/*
+pdftoepdf.w
+
+Copyright 1996-2006 Han The Thanh <thanh@pdftex.org>
+Copyright 2006-2015 Taco Hoekwater <taco@luatex.org>
+
+This file is part of LuaTeX.
+
+LuaTeX is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 2 of the License, or (at your
+option) any later version.
+
+LuaTeX is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+License for more details.
+
+You should have received a copy of the GNU General Public License along
+with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+*/
+
+#define __STDC_FORMAT_MACROS /* for PRId64 etc.  */
+
+#include "image/epdf.h"
+
+/* Conflict with pdfgen.h */
+
+#ifndef pdf_out
+
+#define pdf_out(pdf, A) do { pdf_room(pdf, 1); *(pdf->buf->p++) = A; } while (0)
+
+#define pdf_check_space(pdf) do { \
+    if (pdf->cave > 0) { \
+        pdf_out(pdf, ' '); \
+        pdf->cave = 0; \
+    } \
+} while (0)
+
+#define pdf_set_space(pdf) \
+    pdf->cave = 1;
+
+#define pdf_reset_space(pdf) \
+    pdf->cave = 0;
+
+#endif
+
+/* Maintain AVL tree of all PDF files for embedding */
+
+static avl_table *PdfDocumentTree = NULL;
+
+/* AVL sort PdfDocument into PdfDocumentTree by file_path */
+
+static int CompPdfDocument(const void *pa, const void *pb, void *p )
+{
+    return strcmp(((const PdfDocument *) pa)->file_path, ((const PdfDocument *) pb)->file_path);
+}
+
+/* Returns pointer to PdfDocument structure for PDF file. */
+
+static PdfDocument *findPdfDocument(char *file_path)
+{
+    PdfDocument *pdf_doc, tmp;
+    if (file_path == NULL) {
+        normal_error("pdf backend","empty filename when loading pdf file");
+    } else if (PdfDocumentTree == NULL) {
+        return NULL;
+    }
+    tmp.file_path = file_path;
+    pdf_doc = (PdfDocument *) avl_find(PdfDocumentTree, &tmp);
+    return pdf_doc;
+}
+
+#define PDF_CHECKSUM_SIZE 32
+
+static char *get_file_checksum(const char *a, file_error_mode fe)
+{
+    struct stat finfo;
+    char *ck = NULL;
+    if (stat(a, &finfo) == 0) {
+        off_t size = finfo.st_size;
+        time_t mtime = finfo.st_mtime;
+        ck = (char *) malloc(PDF_CHECKSUM_SIZE);
+        if (ck == NULL)
+            formatted_error("pdf inclusion","out of memory while processing '%s'", a);
+        snprintf(ck, PDF_CHECKSUM_SIZE, "%" PRIu64 "_%" PRIu64, (uint64_t) size,(uint64_t) mtime);
+    } else {
+        switch (fe) {
+            case FE_FAIL:
+                formatted_error("pdf inclusion","could not stat() file '%s'", a);
+                break;
+            case FE_RETURN_NULL:
+                if (ck != NULL)
+                    free(ck);
+                ck = NULL;
+                break;
+            default:
+                assert(0);
+        }
+    }
+    return ck;
+}
+
+static char *get_stream_checksum (const char *str, unsigned long long str_size){
+    /* http://www.cse.yorku.ca/~oz/hash.html */
+    /* djb2                                  */
+    unsigned long hash ;
+    char *ck = NULL;
+    unsigned int i;
+    hash = 5381;
+    ck = (char *) malloc(STRSTREAM_CHECKSUM_SIZE+1);
+    if (ck == NULL)
+        normal_error("pdf inclusion","out of memory while processing a memstream");
+    for(i=0; i<(unsigned int)(str_size); i++) {
+        hash = ((hash << 5) + hash) + str[i]; /* hash * 33 + str[i] */
+    }
+    snprintf(ck,STRSTREAM_CHECKSUM_SIZE+1,"%lx",hash);
+    ck[STRSTREAM_CHECKSUM_SIZE]='\0';
+    return ck;
+}
+
+/*
+    Returns pointer to PdfDocument structure for PDF file.
+    Creates a new PdfDocument structure if it doesn't exist yet.
+    When fe = FE_RETURN_NULL, the function returns NULL in error case.
+*/
+
+PdfDocument *refPdfDocument(const char *file_path, file_error_mode fe, const char *userpassword, const char *ownerpassword)
+{
+    char *checksum, *path_copy;
+    PdfDocument *pdf_doc;
+    ppdoc *pdfe = NULL;
+    int new_flag = 0;
+    if ((checksum = get_file_checksum(file_path, fe)) == NULL) {
+        return (PdfDocument *) NULL;
+    }
+    path_copy = xstrdup(file_path);
+    if ((pdf_doc = findPdfDocument(path_copy)) == NULL) {
+        new_flag = 1;
+        pdf_doc = (PdfDocument*) xmalloc(sizeof( PdfDocument));
+        pdf_doc->file_path = path_copy;
+        pdf_doc->checksum = checksum;
+        pdf_doc->pdfe = NULL;
+        pdf_doc->inObjList = NULL;
+        pdf_doc->ObjMapTree = NULL;
+        pdf_doc->occurences = 0; /* 0 = unreferenced */
+        pdf_doc->pc = 0;
+        pdf_doc->is_mem = 0;
+    } else {
+        if (strncmp(pdf_doc->checksum, checksum, PDF_CHECKSUM_SIZE) != 0) {
+            formatted_error("pdf inclusion","file has changed '%s'", file_path);
+        }
+        free(checksum);
+        free(path_copy);
+    }
+    if (pdf_doc->pdfe == NULL) {
+        pdfe = ppdoc_load(file_path);
+        pdf_doc->pc++;
+        /* todo: check if we might print the document */
+        if (pdfe == NULL) {
+            switch (fe) {
+                case FE_FAIL:
+                    normal_error("pdf inclusion","reading image failed");
+                    break;
+                case FE_RETURN_NULL:
+                    if (pdf_doc->pdfe != NULL) {
+                        ppdoc_free(pdfe);
+                        pdf_doc->pdfe = NULL;
+                    }
+                    /* delete docName */
+                    if (new_flag == 1) {
+                        if (pdf_doc->file_path != NULL)
+                            free(pdf_doc->file_path);
+                        if (pdf_doc->checksum != NULL)
+                            free(pdf_doc->checksum);
+                        free(pdf_doc);
+                    }
+                    return (PdfDocument *) NULL;
+                    break;
+                default:
+                    assert(0);
+            }
+        }
+        if (pdfe != NULL) {
+            if (ppdoc_crypt_status(pdfe) < 0) {
+                ppdoc_crypt_pass(pdfe,userpassword,strlen(userpassword),NULL,0);
+            }
+            if (ppdoc_crypt_status(pdfe) < 0) {
+                ppdoc_crypt_pass(pdfe,NULL,0,ownerpassword,strlen(ownerpassword));
+            }
+            if (ppdoc_crypt_status(pdfe) < 0) {
+                formatted_error("pdf inclusion","the pdf file '%s' is encrypted, provide proper passwords",file_path);
+            }
+        }
+        pdf_doc->pdfe = pdfe;
+    }
+    /* PDF file could be opened without problems, checksum ok. */
+    if (PdfDocumentTree == NULL)
+        PdfDocumentTree = avl_create(CompPdfDocument, NULL, &avl_xallocator);
+    if ((PdfDocument *) avl_find(PdfDocumentTree, pdf_doc) == NULL) {
+        avl_probe(PdfDocumentTree, pdf_doc);
+    }
+    pdf_doc->occurences++;
+    return pdf_doc;
+}
+
+/*
+    Returns pointer to PdfDocument structure for a PDF stream in memory of streamsize
+    dimension. As before, creates a new PdfDocument structure if it doesn't exist yet
+    with file_path = file_id
+*/
+
+PdfDocument *refMemStreamPdfDocument(char *docstream, unsigned long long streamsize,const char *file_id)
+{
+    char *checksum;
+    char *file_path;
+    PdfDocument *pdf_doc;
+    ppdoc *pdfe = NULL;
+    size_t  cnt = 0;
+    checksum = get_stream_checksum(docstream, streamsize);
+    cnt = strlen(file_id);
+    file_path = (char *) malloc(cnt+STREAM_URI_LEN+STRSTREAM_CHECKSUM_SIZE+1); /* 1 for \0 */
+    strcpy(file_path,STREAM_URI);
+    strcat(file_path,file_id);
+    strcat(file_path,checksum);
+    file_path[cnt+STREAM_URI_LEN+STRSTREAM_CHECKSUM_SIZE]='\0';
+    if ((pdf_doc = findPdfDocument(file_path)) == NULL) {
+        /*new_flag = 1;*/
+        pdf_doc = (PdfDocument*) xmalloc(sizeof( PdfDocument));
+        pdf_doc->file_path = file_path;
+        pdf_doc->checksum = checksum;
+        pdf_doc->pdfe = NULL;
+        pdf_doc->inObjList = NULL;
+        pdf_doc->ObjMapTree = NULL;
+        pdf_doc->occurences = 0; /* 0 = unreferenced */
+        pdf_doc->pc = 0;
+        pdf_doc->is_mem = 1;
+        pdf_doc->memstream = docstream;
+    } else {
+        /* As is now, checksum is in file_path, so this check should be useless. */
+        if (strncmp(pdf_doc->checksum, checksum, STRSTREAM_CHECKSUM_SIZE) != 0) {
+            formatted_error("pdf inclusion","stream has changed '%s'", file_path);
+        }
+        free(file_path);
+        free(checksum);
+    }
+    if (pdf_doc->pdfe == NULL) {
+        pdfe = ppdoc_mem(docstream, streamsize);
+        pdf_doc->pc++;
+        if (pdfe == NULL) {
+            normal_error("pdf inclusion","reading pdf Stream failed");
+        }
+        pdf_doc->pdfe = pdfe;
+    }
+    /* PDF file could be opened without problems, checksum ok. */
+    if (PdfDocumentTree == NULL)
+        PdfDocumentTree = avl_create(CompPdfDocument, NULL, &avl_xallocator);
+    if ((PdfDocument *) avl_find(PdfDocumentTree, pdf_doc) == NULL) {
+        avl_probe(PdfDocumentTree, pdf_doc);
+    }
+    pdf_doc->occurences++;
+    return pdf_doc;
+}
+
+/*
+    AVL sort ObjMap into ObjMapTree by object number and generation keep the ObjMap
+    struct small, as these are accumulated until the end
+*/
+
+typedef struct ObjMap ObjMap ;
+
+struct ObjMap {
+    ppref * in;
+    int out_num;
+};
+
+static int CompObjMap(const void *pa, const void *pb, void *p)
+{
+    const ppref *a = (((const ObjMap *) pa)->in);
+    const ppref *b = (((const ObjMap *) pb)->in);
+    if (a->number > b->number)
+        return 1;
+    else if (a->number < b->number)
+        return -1;
+    else if (a->version == b->version)
+        return 0;
+    else if (a->version < b->version)
+        return -1;
+    return 1;
+}
+
+static ObjMap *findObjMap(PdfDocument * pdf_doc, ppref * in)
+{
+    ObjMap *obj_map, tmp;
+    if (pdf_doc->ObjMapTree == NULL)
+        return NULL;
+    tmp.in = in;
+    obj_map = (ObjMap *) avl_find(pdf_doc->ObjMapTree, &tmp);
+    return obj_map;
+}
+
+static void addObjMap(PdfDocument * pdf_doc, ppref * in, int out_num)
+{
+    ObjMap *obj_map = NULL;
+    if (pdf_doc->ObjMapTree == NULL)
+        pdf_doc->ObjMapTree = avl_create(CompObjMap, NULL, &avl_xallocator);
+    obj_map = (ObjMap*)xmalloc(sizeof(ObjMap));
+    obj_map->in = in;
+    obj_map->out_num = out_num;
+    avl_probe(pdf_doc->ObjMapTree, obj_map);
+}
+
+/*
+    When copying the Resources of the selected page, all objects are
+    copied recursively top-down.  The findObjMap() function checks if an
+    object has already been copied; if so, instead of copying just the
+    new object number will be referenced.  The ObjMapTree guarantees,
+    that during the entire LuaTeX run any object from any embedded PDF
+    file will end up max. once in the output PDF file.  Indirect objects
+    are not fetched during copying, but get a new object number from
+    LuaTeX and then will be appended into a linked list.
+*/
+
+static int addInObj(PDF pdf, PdfDocument * pdf_doc, ppref * ref)
+{
+    ObjMap *obj_map;
+    InObj *p, *q, *n;
+    if (ref->number == 0) {
+        normal_error("pdf inclusion","reference to invalid object (broken pdf)");
+    }
+    if ((obj_map = findObjMap(pdf_doc, ref)) != NULL) {
+        return obj_map->out_num;
+    }
+    n = (InObj*)xmalloc(sizeof(InObj));
+    n->ref = ref;
+    n->next = NULL;
+    n->num = pdf_create_obj(pdf, obj_type_others, 0);
+    addObjMap(pdf_doc, ref, n->num);
+    if (pdf_doc->inObjList == NULL) {
+        pdf_doc->inObjList = n;
+    } else {
+        /*
+            It is important to add new objects at the end of the list,
+            because new objects are being added while the list is being
+            written out by writeRefs().
+        */
+        for (p = pdf_doc->inObjList; p != NULL; p = p->next)
+            q = p;
+        q->next = n;
+    }
+    return n->num;
+}
+
+static void copyObject(PDF, PdfDocument *, ppobj *);
+
+static void copyString(PDF pdf, ppstring str)
+{
+    pdf_check_space(pdf);
+    switch (ppstring_type((void *)(str))) {
+        case PPSTRING_PLAIN:
+            pdf_out(pdf, '(');
+            pdf_out_block(pdf, (const char *) str, ppstring_size((void *)(str)));
+            pdf_out(pdf, ')');
+            break;
+        case PPSTRING_BASE16:
+            pdf_out(pdf, '<');
+            pdf_out_block(pdf, (const char *) str, ppstring_size((void *)(str)));
+            pdf_out(pdf, '>');
+            break;
+        case PPSTRING_BASE85:
+            pdf_out(pdf, '<');
+            pdf_out(pdf, '~');
+            pdf_out_block(pdf, (const char *) str, ppstring_size((void *)(str)));
+            pdf_out(pdf, '~');
+            pdf_out(pdf, '>');
+            break;
+    }
+    pdf_set_space(pdf);
+}
+
+/*
+static void copyName(PDF pdf, ppname *name)
+{
+    pdf_add_name(pdf, (const char *) name);
+}
+*/
+
+static void copyArray(PDF pdf, PdfDocument * pdf_doc, pparray * array)
+{
+    int i;
+    int n = array->size;
+    pdf_begin_array(pdf);
+    for (i=0; i<n; ++i) {
+        copyObject(pdf, pdf_doc, pparray_at(array,i));
+    }
+    pdf_end_array(pdf);
+}
+
+static void copyDict(PDF pdf, PdfDocument * pdf_doc, ppdict *dict)
+{
+    int i;
+    int n = dict->size;
+    pdf_begin_dict(pdf);
+    for (i=0; i<n; ++i) {
+        pdf_add_name(pdf, (const char *) ppdict_key(dict,i));
+        copyObject(pdf, pdf_doc, ppdict_at(dict,i));
+    }
+    pdf_end_dict(pdf);
+}
+
+static void copyStreamStream(PDF pdf, ppstream * stream, int decode)
+{
+    uint8_t *data = NULL;
+    size_t size = 0;
+    if (0) {
+        for (data = ppstream_first(stream, &size, decode); data != NULL; data = ppstream_next(stream, &size)) {
+            pdf_out_block(pdf, (const char *) data, size);
+        }
+    } else {
+        data = ppstream_all(stream,&size,decode);
+        if (data != NULL) {
+            pdf_out_block(pdf, (const char *) data, size);
+        }
+    }
+    ppstream_done(stream);
+}
+
+static void copyStream(PDF pdf, PdfDocument * pdf_doc, ppstream * stream)
+{
+    ppdict *dict = stream->dict; /* bug in: stream_dict(stream) */
+    if (pdf->compress_level == 0 || pdf->recompress) {
+        const char *ignoredkeys[] = {
+            "Filter", "Decode", "Length", "DL", NULL
+        };
+        int i;
+        int n = dict->size;
+        pdf_begin_dict(pdf);
+        for (i=0; i<n; ++i) {
+            const char *key = ppdict_key(dict,i);
+            int okay = 1;
+            int k;
+            for (k = 0; ignoredkeys[k] != NULL; k++) {
+                if (strcmp(key,ignoredkeys[k]) == 0) {
+                    okay = 0;
+                    break;
+                }
+            }
+            if (okay) {
+                pdf_add_name(pdf, key);
+                copyObject(pdf, pdf_doc, ppdict_at(dict,i));
+            }
+        }
+        pdf_dict_add_streaminfo(pdf);
+        pdf_end_dict(pdf);
+        pdf_begin_stream(pdf);
+        copyStreamStream(pdf, stream, 1);
+        pdf_end_stream(pdf);
+    } else {
+        copyDict(pdf, pdf_doc, dict);
+        pdf_begin_stream(pdf);
+        copyStreamStream(pdf, stream, 0);
+        pdf_end_stream(pdf);
+    }
+}
+
+static void copyObject(PDF pdf, PdfDocument * pdf_doc, ppobj * obj)
+{
+    switch (obj->type) {
+        case PPNULL:
+            pdf_add_null(pdf);
+            break;
+        case PPBOOL:
+            pdf_add_bool(pdf,obj->integer);                     /* ppobj_get_bool_value(obj) */
+            break;
+        case PPINT:
+            pdf_add_int(pdf,obj->integer);                      /* ppobj_get_int_value(obj) */
+            break;
+        case PPNUM:
+            pdf_add_real(pdf,obj->number);                      /* ppobj_get_num_value(obj) */
+            break;
+        case PPNAME:
+            pdf_add_name(pdf, (const char *) obj->name);        /* ppobj_get_name(obj) */
+            break;
+        case PPSTRING:
+            copyString(pdf, obj->string);                       /* ppobj_get_string(obj) */
+            break;
+        case PPARRAY:
+            copyArray(pdf, pdf_doc, obj->array);                /* ppobj_get_array(obj) */
+            break;
+        case PPDICT:
+            copyDict(pdf, pdf_doc, obj->dict);                  /* ppobj_get_dict(obj) */
+            break;
+        case PPSTREAM:
+            copyStream(pdf, pdf_doc, obj->stream);              /* ppobj_get_stream(obj) */
+            break;
+        case PPREF:
+            pdf_add_ref(pdf, addInObj(pdf, pdf_doc, obj->ref)); /* ppobj_get_ref(obj) */
+            break;
+        default:
+            break;
+    }
+}
+
+static void writeRefs(PDF pdf, PdfDocument * pdf_doc)
+{
+    InObj *r, *n;
+    ppobj * obj;
+    for (r = pdf_doc->inObjList; r != NULL;) {
+        obj = ppref_obj(r->ref);
+        if (obj->type == PPSTREAM)
+            pdf_begin_obj(pdf, r->num, OBJSTM_NEVER);
+        else
+            pdf_begin_obj(pdf, r->num, 2);
+        copyObject(pdf, pdf_doc, obj);
+        pdf_end_obj(pdf);
+        n = r->next;
+        free(r);
+        r = n;
+        pdf_doc->inObjList = n;
+    }
+}
+
+/* get the pagebox coordinates according to the pagebox_spec */
+
+static void somebox(ppdict *page, const char * key, pprect * box)
+{
+    pprect * r = ppdict_get_box(page, key, box);
+    if (r != NULL) {
+        box->lx = r->lx;
+        box->ly = r->ly;
+        box->rx = r->rx;
+        box->ry = r->ry;
+    }
+}
+
+static void get_pagebox(ppdict * page, int pagebox_spec, pprect * box)
+{
+    box->lx = box->rx = box->ly = box->ry = 0;
+    somebox(page,"MediaBox",box);
+    if (pagebox_spec == PDF_BOX_SPEC_MEDIA) {
+        return;
+    }
+    somebox(page,"CropBox",box);
+    if (pagebox_spec == PDF_BOX_SPEC_CROP) {
+        return;
+    }
+    switch (pagebox_spec) {
+        case PDF_BOX_SPEC_BLEED:
+            somebox(page,"BleedBox",box);
+            break;
+        case PDF_BOX_SPEC_TRIM:
+            somebox(page,"TrimBox",box);
+            break;
+        case PDF_BOX_SPEC_ART:
+            somebox(page,"ArtBox",box);
+            break;
+        default:
+            break;
+    }
+}
+
+/*
+    Reads various information about the PDF and sets it up for later inclusion.
+    This will fail if the PDF version of the PDF is higher than minor_pdf_version_wanted
+    or page_name is given and can not be found. It makes no sense to give page_name and
+    page_num. Returns the page number.
+*/
+
+static ppdict * get_pdf_page_dict(ppdoc *pdfe, int n)
+{
+    ppref *r;
+    int i;
+    for (r=ppdoc_first_page(pdfe), i=1; r != NULL; r = ppdoc_next_page(pdfe), ++i) {
+        if (i == n) {
+            return ppref_obj(r)->dict;
+        }
+    }
+    return NULL;
+}
+
+// static ppdict * get_pdf_page_dict(ppdoc *pdfe, int n)
+// {
+//     return ppref_obj(ppdoc_page(pdfe,n))->dict;
+// }
+
+void read_pdf_info(image_dict * idict)
+{
+    PdfDocument *pdf_doc = NULL;
+    ppdoc * pdfe = NULL;
+    ppdict *pageDict, *groupDict;
+    pprect pagebox;
+    ppint rotate = 0;
+    int pdf_major_version_found = 1;
+    int pdf_minor_version_found = 3;
+    float xsize, ysize, xorig, yorig;
+    if (img_type(idict) == IMG_TYPE_PDF) {
+        pdf_doc = refPdfDocument(img_filepath(idict), FE_FAIL, img_userpassword(idict), img_ownerpassword(idict));
+    } else if (img_type(idict) == IMG_TYPE_PDFMEMSTREAM) {
+        pdf_doc = findPdfDocument(img_filepath(idict)) ;
+        if (pdf_doc == NULL )
+           normal_error("pdf inclusion", "memstream not initialized");
+        if (pdf_doc->pdfe == NULL)
+           normal_error("pdf inclusion", "memstream document is empty");
+        pdf_doc->occurences++;
+    } else {
+        normal_error("pdf inclusion","unknown document");
+    }
+    pdfe = pdf_doc->pdfe;
+    /*
+        Check PDF version. This works only for PDF 1.x but since any versions of
+        PDF newer than 1.x will not be backwards compatible to PDF 1.x, we will
+        then have to changed drastically anyway.
+    */
+    pdf_major_version_found = ppdoc_version_number(pdfe,&pdf_minor_version_found);
+    if ((100 * pdf_major_version_found + pdf_major_version_found) > (100 * img_pdfmajorversion(idict) + img_pdfminorversion(idict))) {
+        const char *msg = "PDF inclusion: found PDF version '%d.%d', but at most version '%d.%d' allowed";
+        if (img_errorlevel(idict) > 0) {
+            formatted_error("pdf inclusion",msg, pdf_major_version_found, pdf_minor_version_found, img_pdfmajorversion(idict), img_pdfminorversion(idict));
+        } else {
+            formatted_warning("pdf inclusion",msg, pdf_major_version_found, pdf_minor_version_found, img_pdfmajorversion(idict), img_pdfminorversion(idict));
+        }
+    }
+    img_totalpages(idict) = ppdoc_page_count(pdfe);
+    if (img_pagename(idict)) {
+        /*
+            get page by name is obsolete
+        */
+        normal_error("pdf inclusion","named pages are not supported");
+    } else {
+        /*
+            get page by number
+        */
+        if (img_pagenum(idict) <= 0
+            || img_pagenum(idict) > img_totalpages(idict))
+            formatted_error("pdf inclusion","required page '%i' does not exist",(int) img_pagenum(idict));
+    }
+    /*
+        get the required page
+    */
+    pageDict = get_pdf_page_dict(pdfe,img_pagenum(idict));
+    /*
+        get the pagebox coordinates (media, crop,...) to use
+    */
+    get_pagebox(pageDict, img_pagebox(idict), &pagebox);
+    if (pagebox.rx > pagebox.lx) {
+        xorig = pagebox.lx;
+        xsize = pagebox.rx - pagebox.lx;
+    } else {
+        xorig = pagebox.rx;
+        xsize = pagebox.lx - pagebox.rx;
+    }
+    if (pagebox.ry > pagebox.ly) {
+        yorig = pagebox.ly;
+        ysize = pagebox.ry - pagebox.ly;
+    } else {
+        yorig = pagebox.ry;
+        ysize = pagebox.ly - pagebox.ry;
+    }
+    /*
+        The following 4 parameters are raw. Do _not_ modify by /Rotate!
+    */
+    img_xsize(idict) = bp2sp(xsize);
+    img_ysize(idict) = bp2sp(ysize);
+    img_xorig(idict) = bp2sp(xorig);
+    img_yorig(idict) = bp2sp(yorig);
+    /*
+        Handle /Rotate parameter. Only multiples of 90 deg. are allowed (PDF Ref. v1.3,
+        p. 78). We also accept negative angles. Beware: PDF counts clockwise!
+    */
+    if (ppdict_get_int(pageDict, "Rotate", &rotate)) {
+        switch ((((int)rotate % 360) + 360) % 360) {
+            case 0:
+                img_rotation(idict) = 0;
+                break;
+            case 90:
+                img_rotation(idict) = 3;
+                break;
+            case 180:
+                img_rotation(idict) = 2;
+                break;
+            case 270:
+                img_rotation(idict) = 1;
+                break;
+            default:
+                formatted_warning("pdf inclusion","/Rotate parameter in PDF file not multiple of 90 degrees");
+        }
+    }
+    /*
+        currently unused info whether PDF contains a /Group
+    */
+    groupDict = ppdict_get_dict(pageDict, "Group");
+    if (groupDict != NULL) {
+         img_set_group(idict);
+    }
+    /*
+        LuaTeX pre 0.85 versions did this:
+
+        if (readtype == IMG_CLOSEINBETWEEN) {
+            unrefPdfDocument(img_filepath(idict));
+        }
+
+        and also unref'd in the finalizer so we got an extra unrefs when garbage was
+        collected. However it is more efficient to keep the file open so we do that
+        now. The (slower) alternative is to unref here (which in most cases forcing a
+        close of the file) but then we must not call flush_pdf_info.
+
+        A close (unref) can be forced by nilling the dict object at the lua end and
+        forcing a collectgarbage("collect") after that.
+
+    */
+    if (! img_keepopen(idict)) {
+        unrefPdfDocument(img_filepath(idict));
+    }
+}
+
+void flush_pdf_info(image_dict * idict)
+{
+    if (img_keepopen(idict)) {
+        unrefPdfDocument(img_filepath(idict));
+    }
+}
+
+/*
+    Write the current epf_doc. Here the included PDF is copied, so most errors
+    that can happen during PDF inclusion will arise here.
+*/
+
+void write_epdf(PDF pdf, image_dict * idict, int suppress_optional_info)
+{
+    PdfDocument *pdf_doc = NULL;
+    ppdoc *pdfe = NULL;
+    ppdict *pageDict, *infoDict;
+    ppobj *obj, *content, *resources;
+    pprect pagebox;
+    int i;
+    double bbox[4];
+    const char *pagedictkeys[] = {
+        "Group", "LastModified", "Metadata", "PieceInfo", "SeparationInfo", NULL
+    };
+    /*
+        open PDF file
+    */
+    if (img_type(idict) == IMG_TYPE_PDF) {
+        pdf_doc = refPdfDocument(img_filepath(idict), FE_FAIL, img_userpassword(idict), img_ownerpassword(idict));
+    } else if (img_type(idict) == IMG_TYPE_PDFMEMSTREAM) {
+        pdf_doc = findPdfDocument(img_filepath(idict)) ;
+        pdf_doc->occurences++;
+    } else {
+        normal_error("pdf inclusion","unknown document");
+    }
+    pdfe = pdf_doc->pdfe;
+    pageDict = get_pdf_page_dict(pdfe,img_pagenum(idict));
+    /*
+        write the Page header
+    */
+    pdf_begin_obj(pdf, img_objnum(idict), OBJSTM_NEVER);
+    pdf_begin_dict(pdf);
+    pdf_dict_add_name(pdf, "Type", "XObject");
+    pdf_dict_add_name(pdf, "Subtype", "Form");
+    pdf_dict_add_int(pdf, "FormType", 1);
+    /*
+        write additional information
+    */
+    pdf_dict_add_img_filename(pdf, idict);
+    if ((suppress_optional_info & 4) == 0) {
+        pdf_dict_add_int(pdf, "PTEX.PageNumber", (int) img_pagenum(idict));
+    }
+    if ((suppress_optional_info & 8) == 0) {
+        infoDict = ppdoc_info(pdfe);
+        if (infoDict != NULL) {
+            /* todo : check this
+                pdf_dict_add_ref(pdf, "PTEX.InfoDict", addInObj(pdf, pdf_doc, infoDict));
+            */
+            pdf_add_name(pdf, "PTEX.InfoDict");
+            copyDict(pdf, pdf_doc, infoDict);
+        }
+    }
+    if (img_is_bbox(idict)) {
+        bbox[0] = sp2bp(img_bbox(idict)[0]);
+        bbox[1] = sp2bp(img_bbox(idict)[1]);
+        bbox[2] = sp2bp(img_bbox(idict)[2]);
+        bbox[3] = sp2bp(img_bbox(idict)[3]);
+    } else {
+        /*
+            get the pagebox coordinates (media, crop,...) to use.
+        */
+        get_pagebox(pageDict, img_pagebox(idict), &pagebox);
+        bbox[0] = pagebox.lx;
+        bbox[1] = pagebox.ly;
+        bbox[2] = pagebox.rx;
+        bbox[3] = pagebox.ry;
+    }
+    pdf_add_name(pdf, "BBox");
+    pdf_begin_array(pdf);
+    pdf_add_real(pdf, bbox[0]);
+    pdf_add_real(pdf, bbox[1]);
+    pdf_add_real(pdf, bbox[2]);
+    pdf_add_real(pdf, bbox[3]);
+    pdf_end_array(pdf);
+    /*
+        Now all relevant parts of the Page dictionary are copied. Metadata validity
+        check is needed(as a stream it must be indirect).
+    */
+    obj = ppdict_get_obj(pageDict, "Metadata");
+    if (obj != NULL && obj->type != PPREF) {
+        formatted_warning("pdf inclusion","/Metadata must be indirect object");
+    }
+    /*
+        copy selected items in Page dictionary
+    */
+    for (i = 0; pagedictkeys[i] != NULL; i++) {
+        obj = ppdict_rget_obj(pageDict, pagedictkeys[i]);
+        if (obj != NULL) {
+            pdf_add_name(pdf, pagedictkeys[i]);
+            /*
+                preserves indirection
+            */
+            copyObject(pdf, pdf_doc, obj);
+        }
+    }
+    resources = ppdict_rget_obj(pageDict, "Resources");
+    if (resources == NULL) {
+        /*
+            If there are no Resources in the Page dict of the embedded page,
+            try to inherit the Resources from the Pages tree of the embedded
+            PDF file, climbing up the tree until the Resources are found.
+            (This fixes a problem with Scribus 1.3.3.14.)
+        */
+            obj = ppdict_rget_obj(pageDict, "Parent");
+            while (obj != NULL && obj->type == PPDICT) {
+                resources = ppdict_rget_obj(obj->dict, "Resources");
+                if (resources != NULL) {
+                    break;
+                }
+                obj = ppdict_get_obj(obj->dict, "Parent");
+            }
+    }
+    if (resources != NULL) {
+        pdf_add_name(pdf, "Resources");
+        copyObject(pdf, pdf_doc, resources);
+    } else {
+        formatted_warning("pdf inclusion","Page /Resources missing");
+    }
+    /*
+        User supplied entries.
+    */
+    if (img_attr(idict) != NULL && strlen(img_attr(idict)) > 0) {
+        pdf_printf(pdf, "\n%s\n", img_attr(idict));
+    }
+    /*
+        Write the Page contents.
+    */
+    content = ppdict_rget_obj(pageDict, "Contents");
+    if (content->type == PPSTREAM) {
+        if (pdf->compress_level == 0 || pdf->recompress) {
+            pdf_dict_add_streaminfo(pdf);
+            pdf_end_dict(pdf);
+            pdf_begin_stream(pdf);
+            copyStreamStream(pdf, content->stream,1); /* decompress */
+        } else {
+            /* copies compressed stream */
+            ppstream * stream = content->stream;
+            ppdict *streamDict = stream->dict; /* */
+            obj = ppdict_rget_obj(streamDict, "Length");
+            if (obj != NULL) {
+                pdf_add_name(pdf, "Length");
+                copyObject(pdf, pdf_doc, obj);
+                obj = ppdict_rget_obj(streamDict, "Filter");
+                if (obj != NULL) {
+                    pdf_add_name(pdf, "Filter");
+                    copyObject(pdf, pdf_doc, obj);
+                    /* the next one is irrelevant, only for inline images: */
+                    /*
+                    obj = ppdict_rget_obj(streamDict, "DecodeParms");
+                    if (obj != NULL) {
+                        pdf_add_name(pdf, "DecodeParms");
+                        copyObject(pdf, pdf_doc, obj);
+                    }
+                    */
+                }
+               pdf_end_dict(pdf);
+                pdf_begin_stream(pdf);
+                copyStreamStream(pdf, stream,0);
+            } else {
+                pdf_dict_add_streaminfo(pdf);
+                pdf_end_dict(pdf);
+                pdf_begin_stream(pdf);
+                copyStreamStream(pdf, stream,1);
+            }
+        }
+        pdf_end_stream(pdf);
+    } else if (content->type == PPARRAY) {
+        /* listens to compresslevel */
+        pdf_dict_add_streaminfo(pdf);
+        pdf_end_dict(pdf);
+        pdf_begin_stream(pdf);
+        {
+            int i;
+            int b = 0;
+            int n = content->array->size;
+            for (i=0; i<n; ++i) {
+                ppobj *o = pparray_at(content->array,i);
+                while (o != NULL && o->type == PPREF) {
+                    o = ppref_obj((ppref *) o->ref);
+                }
+                if (o != NULL && o->type == PPSTREAM) {
+                    if (b) {
+                        /*
+                            Put a space between streams to be on the safe side (streams
+                            should have a trailing space here, but one never knows)
+                        */
+                        pdf_out(pdf, ' ');
+                    } else {
+                        b = 1;
+                    }
+                    copyStreamStream(pdf, (ppstream *) o->stream,1);
+                }
+            }
+        }
+        pdf_end_stream(pdf);
+    } else {
+        /*
+            the contents are optional, but we need to include an empty stream
+        */
+        pdf_dict_add_streaminfo(pdf);
+        pdf_end_dict(pdf);
+        pdf_begin_stream(pdf);
+        pdf_end_stream(pdf);
+    }
+    pdf_end_obj(pdf);
+    /*
+        write out all indirect objects
+    */
+    writeRefs(pdf, pdf_doc);
+    /*
+        unrefPdfDocument() must come after freeing whatever is used
+
+    */
+    if (! img_keepopen(idict)) {
+        unrefPdfDocument(img_filepath(idict));
+    }
+}
+
+/* a special simple case of inclusion, e.g. an appearance stream */
+
+int write_epdf_object(PDF pdf, image_dict * idict, int n)
+{
+    int num = 0 ;
+    if (img_type(idict) != IMG_TYPE_PDF) {
+        normal_error("pdf inclusion","unknown document");
+    } else {
+        PdfDocument * pdf_doc = refPdfDocument(img_filepath(idict), FE_FAIL, img_userpassword(idict), img_ownerpassword(idict));
+        ppdoc * pdfe = pdf_doc->pdfe;
+        ppref * ref = ppxref_find(ppdoc_xref(pdfe), (ppuint) n);
+        if (ref != NULL) {
+            ppobj *obj;
+            num = pdf->obj_count++;
+            obj = ppref_obj(ref);
+            if (obj->type == PPSTREAM) {
+                pdf_begin_obj(pdf, num, OBJSTM_NEVER);
+            } else {
+                pdf_begin_obj(pdf, num, 2);
+            }
+            copyObject(pdf, pdf_doc, obj);
+            pdf_end_obj(pdf);
+            writeRefs(pdf, pdf_doc);
+        }
+        if (! img_keepopen(idict)) {
+            unrefPdfDocument(img_filepath(idict));
+        }
+    }
+    return num;
+}
+
+/* Deallocate a PdfDocument with all its resources. */
+
+static void deletePdfDocumentPdfDoc(PdfDocument * pdf_doc)
+{
+    InObj *r, *n;
+    /* this may be probably needed for an emergency destroyPdfDocument() */
+    for (r = pdf_doc->inObjList; r != NULL; r = n) {
+        n = r->next;
+        free(r);
+    }
+    if (pdf_doc->pdfe != NULL) {
+        ppdoc_free(pdf_doc->pdfe);
+        pdf_doc->pdfe = NULL;
+    }
+    if (pdf_doc->memstream != NULL) {
+     /* pplib does this: free(pdf_doc->memstream); */
+        pdf_doc->memstream = NULL;
+    }
+ /* pdf_doc->pc++; */
+    pdf_doc->pc = 0;
+}
+
+static void destroyPdfDocument(void *pa, void * p)
+{
+    PdfDocument *pdf_doc = (PdfDocument *) pa;
+    deletePdfDocumentPdfDoc(pdf_doc);
+    /* TODO: delete rest of pdf_doc */
+}
+
+/*
+    Called when an image has been written and its resources in image_tab are
+    freed and it's not referenced anymore.
+*/
+
+void unrefPdfDocument(char *file_path)
+{
+    PdfDocument *pdf_doc = findPdfDocument(file_path);
+    if (pdf_doc == NULL) {
+        /* we're ok */
+    } else if (pdf_doc->occurences > 0) {
+        pdf_doc->occurences--;
+        if (pdf_doc->occurences == 0) {
+            deletePdfDocumentPdfDoc(pdf_doc);
+        }
+    } else {
+        /*
+            We either have a mismatch in ref and unref or we're somehow out of sync
+            which can happen when we mess with the same file in lua and tex.
+        */
+        formatted_warning("pdf inclusion","there can be a mismatch in opening and closing file '%s'",file_path);
+    }
+}
+
+/*
+    For completeness, but it isn't currently used (unreferencing is done by mean
+    of file_path.
+*/
+
+void unrefMemStreamPdfDocument(char *file_id)
+{
+  (void) unrefPdfDocument(file_id);
+
+}
+
+/*
+    Called when PDF embedding system is finalized.  We now deallocate all remaining
+    PdfDocuments.
+*/
+
+void epdf_free(void)
+{
+    if (PdfDocumentTree != NULL)
+        avl_destroy(PdfDocumentTree, destroyPdfDocument);
+    PdfDocumentTree = NULL;
+}
diff --git a/texk/web2c/luatexdir/image/pdftoepdf.w b/texk/web2c/luatexdir/image/pdftoepdf.w
deleted file mode 100644
index d69795926..000000000
--- a/texk/web2c/luatexdir/image/pdftoepdf.w
+++ /dev/null
@@ -1,972 +0,0 @@
-% pdftoepdf.w
-%
-% Copyright 1996-2006 Han The Thanh <thanh@@pdftex.org>
-% Copyright 2006-2015 Taco Hoekwater <taco@@luatex.org>
-%
-% This file is part of LuaTeX.
-%
-% LuaTeX is free software; you can redistribute it and/or modify it under
-% the terms of the GNU General Public License as published by the Free
-% Software Foundation; either version 2 of the License, or (at your
-% option) any later version.
-%
-% LuaTeX is distributed in the hope that it will be useful, but WITHOUT
-% ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-% FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
-% License for more details.
-%
-% You should have received a copy of the GNU General Public License along
-% with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
-
-@ @c
-
-#define __STDC_FORMAT_MACROS /* for PRId64 etc.  */
-
-#include "image/epdf.h"
-
-/*
-    This file is mostly C and not very much C++; it's just used to interface
-    the functions of poppler, which happens to be written in C++.
-    Patches for the new poppler 0.59 from
-    https://www.mail-archive.com/arch-commits@archlinux.org/msg357548.html
-    with some modifications to comply the poppler API.
-
-*/
-
-extern void md5(Guchar *msg, int msgLen, Guchar *digest);
-
-static GBool isInit = gFalse;
-
-/* Maintain AVL tree of all PDF files for embedding */
-
-static avl_table *PdfDocumentTree = NULL;
-
-/* AVL sort PdfDocument into PdfDocumentTree by file_path */
-
-static int CompPdfDocument(const void *pa, const void *pb, void * /*p */ )
-{
-    return strcmp(((const PdfDocument *) pa)->file_path, ((const PdfDocument *) pb)->file_path);
-}
-
-/* Returns pointer to PdfDocument structure for PDF file. */
-
-static PdfDocument *findPdfDocument(char *file_path)
-{
-    PdfDocument *pdf_doc, tmp;
-    if (file_path == NULL) {
-        normal_error("pdf backend","empty filename when loading pdf file");
-    } else if (PdfDocumentTree == NULL) {
-        return NULL;
-    }
-    tmp.file_path = file_path;
-    pdf_doc = (PdfDocument *) avl_find(PdfDocumentTree, &tmp);
-    return pdf_doc;
-}
-
-#define PDF_CHECKSUM_SIZE 32
-
-static char *get_file_checksum(const char *a, file_error_mode fe)
-{
-    struct stat finfo;
-    char *ck = NULL;
-    if (stat(a, &finfo) == 0) {
-        off_t size = finfo.st_size;
-        time_t mtime = finfo.st_mtime;
-        ck = (char *) malloc(PDF_CHECKSUM_SIZE);
-        if (ck == NULL)
-            formatted_error("pdf inclusion","out of memory while processing '%s'", a);
-        snprintf(ck, PDF_CHECKSUM_SIZE, "%"@= @>PRIu64@= @>"_%"@=  @>PRIu64, (uint64_t) size,(uint64_t) mtime);
-   } else {
-        switch (fe) {
-            case FE_FAIL:
-                formatted_error("pdf inclusion","could not stat() file '%s'", a);
-                break;
-            case FE_RETURN_NULL:
-                if (ck != NULL)
-                    free(ck);
-                ck = NULL;
-                break;
-            default:
-                assert(0);
-        }
-    }
-    return ck;
-}
-
-
-static char *get_stream_checksum (const char *str, unsigned long long str_size){
-    /* http://www.cse.yorku.ca/~oz/hash.html */
-    /* djb2                                  */
-    unsigned long hash ;
-    char *ck = NULL;
-    unsigned int i;
-    hash = 5381;
-    ck = (char *) malloc(STRSTREAM_CHECKSUM_SIZE+1);
-    if (ck == NULL)
-        normal_error("pdf inclusion","out of memory while processing a memstream");
-    for(i=0; i<(unsigned int)(str_size); i++) {
-        hash = ((hash << 5) + hash) + str[i]; /* hash * 33 + str[i] */
-    }
-    snprintf(ck,STRSTREAM_CHECKSUM_SIZE+1,"%lx",hash);
-    ck[STRSTREAM_CHECKSUM_SIZE]='\0';
-    return ck;
-}
-
-/*
-    Returns pointer to PdfDocument structure for PDF file.
-    Creates a new PdfDocument structure if it doesn't exist yet.
-    When fe = FE_RETURN_NULL, the function returns NULL in error case.
-*/
-
-PdfDocument *refPdfDocument(const char *file_path, file_error_mode fe)
-{
-    char *checksum, *path_copy;
-    PdfDocument *pdf_doc;
-    PDFDoc *doc = NULL;
-    GooString *docName = NULL;
-    int new_flag = 0;
-    if ((checksum = get_file_checksum(file_path, fe)) == NULL) {
-        return (PdfDocument *) NULL;
-    }
-    path_copy = xstrdup(file_path);
-    if ((pdf_doc = findPdfDocument(path_copy)) == NULL) {
-        new_flag = 1;
-        pdf_doc = new PdfDocument;
-        pdf_doc->file_path = path_copy;
-        pdf_doc->checksum = checksum;
-        pdf_doc->doc = NULL;
-        pdf_doc->inObjList = NULL;
-        pdf_doc->ObjMapTree = NULL;
-        pdf_doc->occurences = 0; /* 0 = unreferenced */
-        pdf_doc->pc = 0;
-    } else {
-        if (strncmp(pdf_doc->checksum, checksum, PDF_CHECKSUM_SIZE) != 0) {
-            formatted_error("pdf inclusion","file has changed '%s'", file_path);
-        }
-        free(checksum);
-        free(path_copy);
-    }
-    if (pdf_doc->doc == NULL) {
-        docName = new GooString(file_path);
-        doc = new PDFDoc(docName); /* takes ownership of docName */
-        pdf_doc->pc++;
-
-        if (!doc->isOk() || !doc->okToPrint()) {
-            switch (fe) {
-            case FE_FAIL:
-                normal_error("pdf inclusion","reading image failed");
-                break;
-            case FE_RETURN_NULL:
-                delete doc;
-                /* delete docName */
-                if (new_flag == 1) {
-                    if (pdf_doc->file_path != NULL)
-                        free(pdf_doc->file_path);
-                    if (pdf_doc->checksum != NULL)
-                        free(pdf_doc->checksum);
-                    delete pdf_doc;
-                }
-                return (PdfDocument *) NULL;
-                break;
-            default:
-                assert(0);
-            }
-        }
-        pdf_doc->doc = doc;
-    }
-    /* PDF file could be opened without problems, checksum ok. */
-    if (PdfDocumentTree == NULL)
-        PdfDocumentTree = avl_create(CompPdfDocument, NULL, &avl_xallocator);
-    if ((PdfDocument *) avl_find(PdfDocumentTree, pdf_doc) == NULL) {
-        avl_probe(PdfDocumentTree, pdf_doc);
-    }
-    pdf_doc->occurences++;
-    return pdf_doc;
-}
-
-/*
-    Returns pointer to PdfDocument structure for a PDF stream in memory of streamsize
-    dimension. As before, creates a new PdfDocument structure if it doesn't exist yet
-    with file_path = file_id
-*/
-
-PdfDocument *refMemStreamPdfDocument(char *docstream, unsigned long long streamsize,const char *file_id)
-{
-    char *checksum;
-    char *file_path;
-    PdfDocument *pdf_doc;
-    PDFDoc *doc = NULL;
-    Object obj;
-    MemStream *docmemstream = NULL;
-    /*int new_flag = 0;*/
-    size_t  cnt = 0;
-    checksum = get_stream_checksum(docstream, streamsize);
-    cnt = strlen(file_id);
-    assert(cnt>0 && cnt <STREAM_FILE_ID_LEN);
-    file_path = (char *) malloc(cnt+STREAM_URI_LEN+STRSTREAM_CHECKSUM_SIZE+1); /* 1 for \0 */
-    assert(file_path != NULL);
-    strcpy(file_path,STREAM_URI);
-    strcat(file_path,file_id);
-    strcat(file_path,checksum);
-    file_path[cnt+STREAM_URI_LEN+STRSTREAM_CHECKSUM_SIZE]='\0';
-    if ((pdf_doc = findPdfDocument(file_path)) == NULL) {
-        /*new_flag = 1;*/
-        pdf_doc = new PdfDocument;
-        pdf_doc->file_path = file_path;
-        pdf_doc->checksum = checksum;
-        pdf_doc->doc = NULL;
-        pdf_doc->inObjList = NULL;
-        pdf_doc->ObjMapTree = NULL;
-        pdf_doc->occurences = 0; /* 0 = unreferenced */
-        pdf_doc->pc = 0;
-    } else {
-        /* As is now, checksum is in file_path, so this check should be useless. */
-        if (strncmp(pdf_doc->checksum, checksum, STRSTREAM_CHECKSUM_SIZE) != 0) {
-            formatted_error("pdf inclusion","stream has changed '%s'", file_path);
-        }
-        free(file_path);
-        free(checksum);
-    }
-    if (pdf_doc->doc == NULL) {
-        docmemstream = new MemStream( docstream,0,streamsize, Object(objNull) );
-        doc = new PDFDoc(docmemstream); /* takes ownership of docmemstream */
-        pdf_doc->pc++;
-        if (!doc->isOk() || !doc->okToPrint()) {
-            normal_error("pdf inclusion","reading pdf Stream failed");
-    }
-        pdf_doc->doc = doc;
-    }
-    /* PDF file could be opened without problems, checksum ok. */
-    if (PdfDocumentTree == NULL)
-        PdfDocumentTree = avl_create(CompPdfDocument, NULL, &avl_xallocator);
-    if ((PdfDocument *) avl_find(PdfDocumentTree, pdf_doc) == NULL) {
-        avl_probe(PdfDocumentTree, pdf_doc);
-    }
-    pdf_doc->occurences++;
-    return pdf_doc;
-}
-
-/*
-    AVL sort ObjMap into ObjMapTree by object number and generation keep the ObjMap
-    struct small, as these are accumulated until the end
-*/
-
-struct ObjMap {
-    Ref in;
-    int out_num;
-};
-
-static int CompObjMap(const void *pa, const void *pb, void * /*p */ )
-{
-    const Ref *a = &(((const ObjMap *) pa)->in);
-    const Ref *b = &(((const ObjMap *) pb)->in);
-    if (a->num > b->num)
-        return 1;
-    else if (a->num < b->num)
-        return -1;
-    else if (a->gen == b->gen)
-        return 0;
-    else if (a->gen < b->gen)
-        return -1;
-    return 1;
-}
-
-static ObjMap *findObjMap(PdfDocument * pdf_doc, Ref in)
-{
-    ObjMap *obj_map, tmp;
-    if (pdf_doc->ObjMapTree == NULL)
-        return NULL;
-    tmp.in = in;
-    obj_map = (ObjMap *) avl_find(pdf_doc->ObjMapTree, &tmp);
-    return obj_map;
-}
-
-static void addObjMap(PdfDocument * pdf_doc, Ref in, int out_num)
-{
-    ObjMap *obj_map = NULL;
-    if (pdf_doc->ObjMapTree == NULL)
-        pdf_doc->ObjMapTree = avl_create(CompObjMap, NULL, &avl_xallocator);
-    obj_map = new ObjMap;
-    obj_map->in = in;
-    obj_map->out_num = out_num;
-    avl_probe(pdf_doc->ObjMapTree, obj_map);
-}
-
-/*
-    When copying the Resources of the selected page, all objects are
-    copied recursively top-down.  The findObjMap() function checks if an
-    object has already been copied; if so, instead of copying just the
-    new object number will be referenced.  The ObjMapTree guarantees,
-    that during the entire LuaTeX run any object from any embedded PDF
-    file will end up max. once in the output PDF file.  Indirect objects
-    are not fetched during copying, but get a new object number from
-    LuaTeX and then will be appended into a linked list.
-*/
-
-static int addInObj(PDF pdf, PdfDocument * pdf_doc, Ref ref)
-{
-    ObjMap *obj_map;
-    InObj *p, *q, *n;
-    if (ref.num == 0) {
-        normal_error("pdf inclusion","reference to invalid object (broken pdf)");
-    }
-    if ((obj_map = findObjMap(pdf_doc, ref)) != NULL)
-        return obj_map->out_num;
-    n = new InObj;
-    n->ref = ref;
-    n->next = NULL;
-    n->num = pdf_create_obj(pdf, obj_type_others, 0);
-    addObjMap(pdf_doc, ref, n->num);
-    if (pdf_doc->inObjList == NULL) {
-        pdf_doc->inObjList = n;
-    } else {
-        /*
-            It is important to add new objects at the end of the list,
-            because new objects are being added while the list is being
-            written out by writeRefs().
-        */
-        for (p = pdf_doc->inObjList; p != NULL; p = p->next)
-            q = p;
-        q->next = n;
-    }
-    return n->num;
-}
-
-/*
-    Function converts double to pdffloat; very small and very large numbers
-    are NOT converted to scientific notation. Here n must be a number or real
-    conforming to the implementation limits of PDF as specified in appendix C.1
-    of the PDF Ref. These are:
-
-    maximum value of ints is +2^32
-    maximum value of reals is +2^15
-    smalles values of reals is 1/(2^16)
-*/
-
-static pdffloat conv_double_to_pdffloat(double n)
-{
-    pdffloat a;
-    a.e = 6;
-    a.m = i64round(n * ten_pow[a.e]);
-    return a;
-}
-
-static void copyObject(PDF, PdfDocument *, Object *);
-
-void copyReal(PDF pdf, double d)
-{
-    if (pdf->cave)
-        pdf_out(pdf, ' ');
-    print_pdffloat(pdf, conv_double_to_pdffloat(d));
-    pdf->cave = true;
-}
-
-static void copyString(PDF pdf, GooString * string)
-{
-    char *p;
-    unsigned char c;
-    size_t i, l;
-    p = string->getCString();
-    l = (size_t) string->getLength();
-    if (pdf->cave)
-        pdf_out(pdf, ' ');
-    if (strlen(p) == l) {
-        pdf_out(pdf, '(');
-        for (; *p != 0; p++) {
-            c = (unsigned char) *p;
-            if (c == '(' || c == ')' || c == '\\')
-                pdf_printf(pdf, "\\%c", c);
-            else if (c < 0x20 || c > 0x7F)
-                pdf_printf(pdf, "\\%03o", (int) c);
-            else
-                pdf_out(pdf, c);
-        }
-        pdf_out(pdf, ')');
-    } else {
-        pdf_out(pdf, '<');
-        for (i = 0; i < l; i++) {
-            c = (unsigned char) string->getChar(i);
-            pdf_printf(pdf, "%.2x", (int) c);
-        }
-        pdf_out(pdf, '>');
-    }
-    pdf->cave = true;
-}
-
-static void copyName(PDF pdf, char *s)
-{
-    pdf_out(pdf, '/');
-    for (; *s != 0; s++) {
-        if (isdigit(*s) || isupper(*s) || islower(*s) || *s == '_' ||
-            *s == '.' || *s == '-' || *s == '+')
-            pdf_out(pdf, *s);
-        else
-            pdf_printf(pdf, "#%.2X", *s & 0xFF);
-    }
-    pdf->cave = true;
-}
-
-static void copyArray(PDF pdf, PdfDocument * pdf_doc, Array * array)
-{
-    int i, l;
-    Object obj1;
-    pdf_begin_array(pdf);
-    for (i = 0, l = array->getLength(); i < l; ++i) {
-        obj1 = array->getNF(i);
-        copyObject(pdf, pdf_doc, &obj1);
-    }
-    pdf_end_array(pdf);
-}
-
-static void copyDict(PDF pdf, PdfDocument * pdf_doc, Dict * dict)
-{
-    int i, l;
-    Object obj1;
-    pdf_begin_dict(pdf);
-    for (i = 0, l = dict->getLength(); i < l; ++i) {
-        copyName(pdf, dict->getKey(i));
-        obj1 = dict->getValNF(i);
-        copyObject(pdf, pdf_doc, &obj1);
-    }
-    pdf_end_dict(pdf);
-}
-
-static void copyStreamStream(PDF pdf, Stream * str)
-{
-    int c, i, len = 1024;
-    str->reset();
-    i = len;
-    while ((c = str->getChar()) != EOF) {
-        if (i == len) {
-            pdf_room(pdf, len);
-            i = 0;
-        }
-        pdf_quick_out(pdf, c);
-        i++;
-    }
-}
-
-static void copyStream(PDF pdf, PdfDocument * pdf_doc, Stream * stream)
-{
-    copyDict(pdf, pdf_doc, stream->getDict());
-    pdf_begin_stream(pdf);
-    copyStreamStream(pdf, stream->getUndecodedStream());
-    pdf_end_stream(pdf);
-}
-
-static void copyObject(PDF pdf, PdfDocument * pdf_doc, Object * obj)
-{
-    switch (obj->getType()) {
-    case objBool:
-        pdf_add_bool(pdf, (int) obj->getBool());
-        break;
-    case objInt:
-        pdf_add_int(pdf, obj->getInt());
-        break;
-    case objReal:
-        copyReal(pdf, obj->getReal());
-        break;
-    /*
-    case objNum:
-        GBool isNum() { return type == objInt || type == objReal; }
-        break;
-    */
-    case objString:
-        copyString(pdf, (GooString *)obj->getString());
-        break;
-    case objName:
-        copyName(pdf, (char *)obj->getName());
-        break;
-    case objNull:
-        pdf_add_null(pdf);
-        break;
-    case objArray:
-        copyArray(pdf, pdf_doc, obj->getArray());
-        break;
-    case objDict:
-        copyDict(pdf, pdf_doc, obj->getDict());
-        break;
-    case objStream:
-        copyStream(pdf, pdf_doc, obj->getStream());
-        break;
-    case objRef:
-        pdf_add_ref(pdf, addInObj(pdf, pdf_doc, obj->getRef()));
-        break;
-    case objCmd:
-    case objError:
-    case objEOF:
-    case objNone:
-        formatted_error("pdf inclusion","type '%s' cannot be copied", obj->getTypeName());
-        break;
-    default:
-        /* poppler doesn't have any other types */
-        assert(0);
-    }
-}
-
-static void writeRefs(PDF pdf, PdfDocument * pdf_doc)
-{
-    InObj *r, *n;
-    Object obj1;
-    XRef *xref;
-    PDFDoc *doc = pdf_doc->doc;
-    xref = doc->getXRef();
-    for (r = pdf_doc->inObjList; r != NULL;) {
-        obj1 = xref->fetch(r->ref.num, r->ref.gen);
-        if (obj1.isStream())
-            pdf_begin_obj(pdf, r->num, OBJSTM_NEVER);
-        else
-            pdf_begin_obj(pdf, r->num, 2);
-        copyObject(pdf, pdf_doc, &obj1);
-        pdf_end_obj(pdf);
-        n = r->next;
-        delete r;
-        pdf_doc->inObjList = r = n;
-    }
-}
-
-/* get the pagebox coordinates according to the pagebox_spec */
-
-static PDFRectangle *get_pagebox(Page * page, int pagebox_spec)
-{
-    switch (pagebox_spec) {
-        case PDF_BOX_SPEC_MEDIA:
-            return page->getMediaBox();
-            break;
-        case PDF_BOX_SPEC_CROP:
-            return page->getCropBox();
-            break;
-        case PDF_BOX_SPEC_BLEED:
-            return page->getBleedBox();
-            break;
-        case PDF_BOX_SPEC_TRIM:
-            return page->getTrimBox();
-            break;
-        case PDF_BOX_SPEC_ART:
-            return page->getArtBox();
-            break;
-        default:
-            return page->getMediaBox();
-            break;
-    }
-}
-
-/*
-    Reads various information about the PDF and sets it up for later inclusion.
-    This will fail if the PDF version of the PDF is higher than minor_pdf_version_wanted
-    or page_name is given and can not be found. It makes no sense to give page_name and
-    page_num. Returns the page number.
-*/
-
-void flush_pdf_info(image_dict * idict)
-{
-    if (img_keepopen(idict)) {
-        unrefPdfDocument(img_filepath(idict));
-    }
-}
-
-/*
-    void flush_pdfstream_info(image_dict * idict)
-    {
-        if (img_pdfstream_ptr(idict) != NULL) {
-            xfree(img_pdfstream_stream(idict));
-            xfree(img_pdfstream_ptr(idict));
-            img_pdfstream_stream(idict) = NULL;
-            img_pdfstream_ptr(idict) = NULL;
-        }
-    }
-*/
-
-void read_pdf_info(image_dict * idict)
-{
-    PdfDocument *pdf_doc = NULL;
-    PDFDoc *doc = NULL;
-    Catalog *catalog;
-    Page *page;
-    int rotate;
-    PDFRectangle *pagebox;
-    int pdf_major_version_found, pdf_minor_version_found;
-    float xsize, ysize, xorig, yorig;
-    if (isInit == gFalse) {
-        if (!(globalParams))
-            globalParams = new GlobalParams();
-        globalParams->setErrQuiet(gFalse);
-        isInit = gTrue;
-    }
-    if (img_type(idict) == IMG_TYPE_PDF)
-        pdf_doc = refPdfDocument(img_filepath(idict), FE_FAIL);
-    else if (img_type(idict) == IMG_TYPE_PDFMEMSTREAM) {
-        pdf_doc = findPdfDocument(img_filepath(idict)) ;
-        if (pdf_doc == NULL )
-           normal_error("pdf inclusion", "memstream not initialized");
-        if (pdf_doc->doc == NULL)
-           normal_error("pdf inclusion", "memstream document is empty");
-        pdf_doc->occurences++;
-    } else {
-        normal_error("pdf inclusion","unknown document");
-    }
-    doc = pdf_doc->doc;
-    catalog = doc->getCatalog();
-    /*
-        Check PDF version. This works only for PDF 1.x but since any versions of
-        PDF newer than 1.x will not be backwards compatible to PDF 1.x, we will
-        then have to changed drastically anyway.
-    */
-    pdf_major_version_found = doc->getPDFMajorVersion();
-    pdf_minor_version_found = doc->getPDFMinorVersion();
-    if ((100 * pdf_major_version_found + pdf_major_version_found) > (100 * img_pdfmajorversion(idict) + img_pdfminorversion(idict))) {
-        const char *msg = "PDF inclusion: found PDF version '%d.%d', but at most version '%d.%d' allowed";
-        if (img_errorlevel(idict) > 0) {
-            formatted_error("pdf inclusion",msg, pdf_major_version_found, pdf_minor_version_found, img_pdfmajorversion(idict), img_pdfminorversion(idict));
-        } else {
-            formatted_warning("pdf inclusion",msg, pdf_major_version_found, pdf_minor_version_found, img_pdfmajorversion(idict), img_pdfminorversion(idict));
-        }
-    }
-    img_totalpages(idict) = catalog->getNumPages();
-    if (img_pagename(idict)) {
-        /* get page by name */
-        GooString name(img_pagename(idict));
-        LinkDest *link = doc->findDest(&name);
-        if (link == NULL || !link->isOk())
-            formatted_error("pdf inclusion","invalid destination '%s'",img_pagename(idict));
-        Ref ref = link->getPageRef();
-        img_pagenum(idict) = catalog->findPage(ref.num, ref.gen);
-        if (img_pagenum(idict) == 0)
-            formatted_error("pdf inclusion","destination is not a page '%s'",img_pagename(idict));
-        delete link;
-    } else {
-        /* get page by number */
-        if (img_pagenum(idict) <= 0
-            || img_pagenum(idict) > img_totalpages(idict))
-            formatted_error("pdf inclusion","required page '%i' does not exist",(int) img_pagenum(idict));
-    }
-    /* get the required page */
-    page = catalog->getPage(img_pagenum(idict));
-    /* get the pagebox coordinates (media, crop,...) to use. */
-    pagebox = get_pagebox(page, img_pagebox(idict));
-    if (pagebox->x2 > pagebox->x1) {
-        xorig = pagebox->x1;
-        xsize = pagebox->x2 - pagebox->x1;
-    } else {
-        xorig = pagebox->x2;
-        xsize = pagebox->x1 - pagebox->x2;
-    }
-    if (pagebox->y2 > pagebox->y1) {
-        yorig = pagebox->y1;
-        ysize = pagebox->y2 - pagebox->y1;
-    } else {
-        yorig = pagebox->y2;
-        ysize = pagebox->y1 - pagebox->y2;
-    }
-    /* The following 4 parameters are raw. Do _not_ modify by /Rotate! */
-    img_xsize(idict) = bp2sp(xsize);
-    img_ysize(idict) = bp2sp(ysize);
-    img_xorig(idict) = bp2sp(xorig);
-    img_yorig(idict) = bp2sp(yorig);
-    /*
-        Handle /Rotate parameter. Only multiples of 90 deg. are allowed (PDF Ref. v1.3,
-        p. 78). We also accept negative angles. Beware: PDF counts clockwise! */
-    rotate = page->getRotate();
-    switch (((rotate % 360) + 360) % 360) {
-        case 0:
-            img_rotation(idict) = 0;
-            break;
-        case 90:
-            img_rotation(idict) = 3;
-            break;
-        case 180:
-            img_rotation(idict) = 2;
-            break;
-        case 270:
-            img_rotation(idict) = 1;
-            break;
-        default:
-            formatted_warning("pdf inclusion","/Rotate parameter in PDF file not multiple of 90 degrees");
-    }
-    /* currently unused info whether PDF contains a /Group */
-    if (page->getGroup() != NULL)
-        img_set_group(idict);
-    /*
-        LuaTeX pre 0.85 versions did this:
-
-        if (readtype == IMG_CLOSEINBETWEEN) {
-            unrefPdfDocument(img_filepath(idict));
-        }
-
-        and also unref'd in the finalizer so we got an extra unrefs when garbage was
-        collected. However it is more efficient to keep the file open so we do that
-        now. The (slower) alternative is to unref here (which in most cases forcing a
-        close of the file) but then we must not call flush_pdf_info.
-
-        A close (unref) can be forced by nilling the dict object at the lua end and
-        forcing a collectgarbage("collect") after that.
-
-    */
-    if (! img_keepopen(idict)) {
-        unrefPdfDocument(img_filepath(idict));
-    }
-}
-
-/*
-    Write the current epf_doc. Here the included PDF is copied, so most errors
-    that can happen during PDF inclusion will arise here.
-*/
-
-void write_epdf(PDF pdf, image_dict * idict, int suppress_optional_info)
-{
-    PdfDocument *pdf_doc = NULL;
-    PDFDoc *doc = NULL;
-    Catalog *catalog;
-    Page *page;
-    Ref *pageref;
-    Dict *pageDict;
-    Object obj1, contents, pageobj, pagesobj1, pagesobj2, *op1, *op2, *optmp;
-    PDFRectangle *pagebox;
-    int i, l;
-    double bbox[4];
-    /* char s[256]; */
-    const char *pagedictkeys[] = {
-        "Group", "LastModified", "Metadata", "PieceInfo", "Resources", "SeparationInfo", NULL
-    };
-    /* open PDF file */
-    if (img_type(idict) == IMG_TYPE_PDF) {
-        pdf_doc = refPdfDocument(img_filepath(idict), FE_FAIL);
-    } else if (img_type(idict) == IMG_TYPE_PDFMEMSTREAM) {
-        pdf_doc = findPdfDocument(img_filepath(idict)) ;
-        pdf_doc->occurences++;
-    } else {
-        normal_error("pdf inclusion","unknown document");
-    }
-    doc = pdf_doc->doc;
-    catalog = doc->getCatalog();
-    page = catalog->getPage(img_pagenum(idict));
-    pageref = catalog->getPageRef(img_pagenum(idict));
-    pageobj = doc->getXRef()->fetch(pageref->num, pageref->gen);
-    pageDict = pageobj.getDict();
-    /* write the Page header */
-    pdf_begin_obj(pdf, img_objnum(idict), OBJSTM_NEVER);
-    pdf_begin_dict(pdf);
-    pdf_dict_add_name(pdf, "Type", "XObject");
-    pdf_dict_add_name(pdf, "Subtype", "Form");
-    if (img_attr(idict) != NULL && strlen(img_attr(idict)) > 0) {
-        pdf_printf(pdf, "\n%s\n", img_attr(idict));
-    }
-    pdf_dict_add_int(pdf, "FormType", 1);
-    /* write additional information */
-    pdf_dict_add_img_filename(pdf, idict);
-    if ((suppress_optional_info & 4) == 0) {
-        pdf_dict_add_int(pdf, "PTEX.PageNumber", (int) img_pagenum(idict));
-    }
-    if ((suppress_optional_info & 8) == 0) {
-        obj1 = doc->getDocInfoNF();
-        if (obj1.isRef()) {
-            /* the info dict must be indirect (PDF Ref p. 61) */
-            pdf_dict_add_ref(pdf, "PTEX.InfoDict", addInObj(pdf, pdf_doc, obj1.getRef()));
-        }
-    }
-    if (img_is_bbox(idict)) {
-        bbox[0] = sp2bp(img_bbox(idict)[0]);
-        bbox[1] = sp2bp(img_bbox(idict)[1]);
-        bbox[2] = sp2bp(img_bbox(idict)[2]);
-        bbox[3] = sp2bp(img_bbox(idict)[3]);
-    } else {
-        /* get the pagebox coordinates (media, crop,...) to use. */
-        pagebox = get_pagebox(page, img_pagebox(idict));
-        bbox[0] = pagebox->x1;
-        bbox[1] = pagebox->y1;
-        bbox[2] = pagebox->x2;
-        bbox[3] = pagebox->y2;
-    }
-    pdf_add_name(pdf, "BBox");
-    pdf_begin_array(pdf);
-    copyReal(pdf, bbox[0]);
-    copyReal(pdf, bbox[1]);
-    copyReal(pdf, bbox[2]);
-    copyReal(pdf, bbox[3]);
-    pdf_end_array(pdf);
-    /*
-        Now all relevant parts of the Page dictionary are copied. Metadata validity
-        check is needed(as a stream it must be indirect).
-    */
-    obj1 = pageDict->lookupNF("Metadata");
-    if (!obj1.isNull() && !obj1.isRef())
-        formatted_warning("pdf inclusion","/Metadata must be indirect object");
-    /* copy selected items in Page dictionary */
-    for (i = 0; pagedictkeys[i] != NULL; i++) {
-        obj1 = pageDict->lookupNF(pagedictkeys[i]);
-        if (!obj1.isNull()) {
-            pdf_add_name(pdf, pagedictkeys[i]);
-            /* preserves indirection */
-            copyObject(pdf, pdf_doc, &obj1);
-        }
-    }
-    /*
-        If there are no Resources in the Page dict of the embedded page,
-        try to inherit the Resources from the Pages tree of the embedded
-        PDF file, climbing up the tree until the Resources are found.
-        (This fixes a problem with Scribus 1.3.3.14.)
-    */
-    obj1 = pageDict->lookupNF("Resources");
-    if (obj1.isNull()) {
-        op1 = &pagesobj1;
-        op2 = &pagesobj2;
-        *op1 = pageDict->lookup("Parent");
-        while (op1->isDict()) {
-            obj1 = op1->dictLookupNF("Resources");
-            if (!obj1.isNull()) {
-                pdf_add_name(pdf, "Resources");
-                copyObject(pdf, pdf_doc, &obj1);
-                break;
-            }
-            *op2 = op1->dictLookup("Parent");
-            optmp = op1;
-            op1 = op2;
-            op2 = optmp;
-        };
-        if (!op1->isDict())
-            formatted_warning("pdf inclusion","Page /Resources missing");
-    }
-    /* Write the Page contents. */
-    contents = page->getContents();
-    if (contents.isStream()) {
-        /*
-            Variant A: get stream and recompress under control of \pdfcompresslevel
-
-            pdf_begin_stream();
-            copyStreamStream(contents->getStream());
-            pdf_end_stream();
-
-            Variant B: copy stream without recompressing
-        */
-        obj1 = contents.streamGetDict()->lookup("F");
-        if (!obj1.isNull()) {
-            normal_error("pdf inclusion","unsupported external stream");
-        }
-        obj1 = contents.streamGetDict()->lookup("Length");
-        pdf_add_name(pdf, "Length");
-        copyObject(pdf, pdf_doc, &obj1);
-        obj1 = contents.streamGetDict()->lookup("Filter");
-        if (!obj1.isNull()) {
-            pdf_add_name(pdf, "Filter");
-            copyObject(pdf, pdf_doc, &obj1);
-            obj1 = contents.streamGetDict()->lookup("DecodeParms");
-            if (!obj1.isNull()) {
-                pdf_add_name(pdf, "DecodeParms");
-                copyObject(pdf, pdf_doc, &obj1);
-            }
-        }
-        pdf_end_dict(pdf);
-        pdf_begin_stream(pdf);
-        copyStreamStream(pdf, contents.getStream()->getUndecodedStream());
-        pdf_end_stream(pdf);
-        pdf_end_obj(pdf);
-    } else if (contents.isArray()) {
-        pdf_dict_add_streaminfo(pdf);
-        pdf_end_dict(pdf);
-        pdf_begin_stream(pdf);
-        for (i = 0, l = contents.arrayGetLength(); i < l; ++i) {
-            obj1 = contents.arrayGet(i);
-            copyStreamStream(pdf, obj1.getStream());
-            if (i < (l - 1)) {
-                /*
-                    Put a space between streams to be on the safe side (streams
-                    should have a trailing space here, but one never knows)
-                */
-                pdf_out(pdf, ' ');
-            }
-        }
-        pdf_end_stream(pdf);
-        pdf_end_obj(pdf);
-    } else {
-        /* the contents are optional, but we need to include an empty stream */
-        pdf_dict_add_streaminfo(pdf);
-        pdf_end_dict(pdf);
-        pdf_begin_stream(pdf);
-        pdf_end_stream(pdf);
-        pdf_end_obj(pdf);
-    }
-    /* write out all indirect objects */
-    writeRefs(pdf, pdf_doc);
-    /*
-        unrefPdfDocument() must come after contents.free() and pageobj.free()!
-        TH: The next line makes repeated pdf inclusion unacceptably slow
-
-        unrefPdfDocument(img_filepath(idict));
-    */
-
-if (! img_keepopen(idict)) {
-    unrefPdfDocument(img_filepath(idict));
-}
-
-
-}
-
-/* Deallocate a PdfDocument with all its resources. */
-
-static void deletePdfDocumentPdfDoc(PdfDocument * pdf_doc)
-{
-    InObj *r, *n;
-    /* this may be probably needed for an emergency destroyPdfDocument() */
-    for (r = pdf_doc->inObjList; r != NULL; r = n) {
-        n = r->next;
-        delete r;
-    }
-    delete pdf_doc->doc;
-    pdf_doc->doc = NULL;
-    pdf_doc->pc++;
-}
-
-static void destroyPdfDocument(void *pa, void * /*pb */ )
-{
-    PdfDocument *pdf_doc = (PdfDocument *) pa;
-    deletePdfDocumentPdfDoc(pdf_doc);
-    /* TODO: delete rest of pdf_doc */
-}
-
-/*
-    Called when an image has been written and its resources in image_tab are
-    freed and it's not referenced anymore.
-*/
-
-void unrefPdfDocument(char *file_path)
-{
-    PdfDocument *pdf_doc = findPdfDocument(file_path);
-    if (pdf_doc->occurences > 0) {
-        pdf_doc->occurences--;
-        if (pdf_doc->occurences == 0) {
-            deletePdfDocumentPdfDoc(pdf_doc);
-        }
-    } else {
-        /*
-            We either have a mismatch in ref and unref or we're somehow out of sync
-            which can happen when we mess with the same file in lua and tex.
-        */
-        formatted_warning("pdf inclusion","there can be a mismatch in opening and closing file '%s'",file_path);
-    }
-}
-
-/*
-    For completeness, but it isn't currently used (unreferencing is done by mean
-    of file_path.
-*/
-
-void unrefMemStreamPdfDocument(char *file_id)
-{
-  (void) unrefPdfDocument(file_id);
-
-}
-
-/*
-    Called when PDF embedding system is finalized.  We now deallocate all remaining
-    PdfDocuments.
-*/
-
-void epdf_free()
-{
-    if (PdfDocumentTree != NULL)
-        avl_destroy(PdfDocumentTree, destroyPdfDocument);
-    PdfDocumentTree = NULL;
-    if (isInit == gTrue)
-        delete globalParams;
-    isInit = gFalse;
-}
diff --git a/texk/web2c/luatexdir/image/writeimg.w b/texk/web2c/luatexdir/image/writeimg.c
similarity index 70%
rename from texk/web2c/luatexdir/image/writeimg.w
rename to texk/web2c/luatexdir/image/writeimg.c
index ef414d5d4..e3e3f608f 100644
--- a/texk/web2c/luatexdir/image/writeimg.w
+++ b/texk/web2c/luatexdir/image/writeimg.c
@@ -1,109 +1,82 @@
-% writeimg.w
-%
-% Copyright 1996-2006 Han The Thanh <thanh@@pdftex.org>
-% Copyright 2006-2012 Taco Hoekwater <taco@@luatex.org>
-%
-% This file is part of LuaTeX.
-%
-% LuaTeX is free software; you can redistribute it and/or modify it under
-% the terms of the GNU General Public License as published by the Free
-% Software Foundation; either version 2 of the License, or (at your
-% option) any later version.
-%
-% LuaTeX is distributed in the hope that it will be useful, but WITHOUT
-% ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-% FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
-% License for more details.
-%
-% You should have received a copy of the GNU General Public License along
-% with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
-
-@* Image inclusion.
-
-@ @c
+/*
+
+writeimg.c
+
+Copyright 1996-2006 Han The Thanh <thanh@pdftex.org>
+Copyright 2006-2012 Taco Hoekwater <taco@luatex.org>
+
+This file is part of LuaTeX.
+
+LuaTeX is free software; you can redistribute it and/or modify it under the terms
+of the GNU General Public License as published by the Free Software Foundation;
+either version 2 of the License, or (at your option) any later version.
+
+LuaTeX is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU General Public License along with
+LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+
+*/
+
 #include "ptexlib.h"
 #include <kpathsea/c-auto.h>
 #include <kpathsea/c-memstr.h>
 
-@ @c
 #include "image/image.h"
 #include "image/writejpg.h"
 #include "image/writejp2.h"
 #include "image/writepng.h"
 #include "image/writejbig2.h"
 
-#include "lua.h"          /* for |LUA_NOREF| */
+#include "lua.h"
 #include "lauxlib.h"
 
-@* Patch ImageTypeDetection 2003/02/08 by Heiko Oberdiek.
+/*tex
 
-Function |readimage| performs some basic initializations. Then it looks at the
-file extension to determine the image type and calls specific code/functions. The
-main disadvantage is that standard file extensions have to be used, otherwise
+The function |readimage| performs some basic initializations. Then it looks at
+the file extension to determine the image type and calls specific code/functions.
+The main disadvantage is that standard file extensions have to be used, otherwise
 pdfTeX is not able to detect the correct image type. The patch now looks at the
 file header first regardless of the file extension. This is implemented in
 function |check_type_by_header|. If this check fails, the traditional test of
 standard file extension is tried, done in function |check_type_by_extension|.
 
-Magic headers:
-
-* "PNG (Portable Network Graphics) Specification", Version 1.2
-  (http://www.libpng.org/pub/png):
-
-   3.1. PNG file signature
-
-      The first eight bytes of a PNG file always contain the following
-      (decimal) values: 137 80 78 71 13 10 26 10
-
-Translation to C: |"\x89PNG\r\n\x1A\n"|
-
-* "JPEG File Interchange Format", Version 1.02:
-
-  * you can identify a JFIF file by looking for the following sequence:
-    X'FF', SOI X'FF', APP0, <2 bytes to be skipped>, "JFIF", X'00'.
-
-Function |check_type_by_header| only looks at the first two bytes: |"\xFF\xD8"|
-
-* ISO/IEC JTC 1/SC 29/WG 1
-  (ITU-T SG8)
-  Coding of Still Pictures
-  Title: 14492 FCD
-  Source: JBIG Committee
-  Project: JTC 1.29.10
-  Status: Final Committee Draft
-
- D.4.1, ID string
-
- This is an 8-byte sequence containing 0x97 0x4A 0x42 0x32 0x0D 0x0A 0x1A 0x0A.
-
-* "PDF Reference", third edition:
-
-  * The first line should contain \%PDF-1.0 -- \%PDF-1.4 (section 3.4.1 "File Header").
-  * The "implementation notes" say:
-
-   3.4.1,  File Header
-     12. Acrobat viewers require only that the header appear somewhere within the
-         first 1024 bytes of the file.
-     13. Acrobat viewers will also accept a header of the form \%!PS-Adobe-N.n PDF-M.m
-
-The check in function |check_type_by_header| only implements the first issue. The
-implementation notes are not considered. Therefore files with garbage at start of
-file must have the standard extension.
+The magic headers are as follows:
+
+\startitemize
+    \startitem
+        \type {png}: 89 50 4E 47 0D 0A 1A 0A or |"\137PNG\013\010\026\010"|
+    \stopitem
+    \startitem
+        \type {jpg}: FF D8 FF or |"\255\216\255"|.
+    \stopitem
+    \startitem
+        \type {jp2}: 00 00 00 0C 6A 50 20 20 0D 0A or |"\000\000\000\012\106\080\032\032\013\010"|
+    \stopitem
+    \startitem
+        \type {pdf}: |"%PDF"| somewhere in the beginning
+    \stopitem
+\stopitemize
 
 Functions |check_type_by_header| and |check_type_by_extension|: |img_type(img)|
 is set to |IMG_TYPE_NONE| by |new_image_dict()|. Both functions try to detect a
 type and set |img_type(img)|. Thus a value other than |IMG_TYPE_NONE| indicates
 that a type has been found.
 
-@c
-#define HEADER_JPG "\xFF\xD8"
-#define HEADER_PNG "\x89PNG\r\n\x1A\n"
+*/
+
+#define HEADER_JPG   "\xFF\xD8"
+#define HEADER_PNG   "\x89PNG\r\n\x1A\n"
 #define HEADER_JBIG2 "\x97\x4A\x42\x32\x0D\x0A\x1A\x0A"
-#define HEADER_JP2 "\x6A\x50\x20\x20"
-#define HEADER_PDF "%PDF-"
+#define HEADER_JP2   "\x6A\x50\x20\x20"
+#define HEADER_PDF   "%PDF-"
+
 #define MAX_HEADER (sizeof(HEADER_PNG)-1)
-#define HEADER_PDF_MEMSTREAM "data:application/pdf," /* see epdf.h */
-#define LEN_PDF_MEMSTREAM 21 /* see epdf.h */
+
+#define HEADER_PDF_MEMSTREAM "data:application/pdf,"
+#define LEN_PDF_MEMSTREAM 21
 
 static void check_type_by_header(image_dict * idict)
 {
@@ -115,13 +88,13 @@ static void check_type_by_header(image_dict * idict)
         return;
     if (img_type(idict) != IMG_TYPE_NONE)
         return;
-    /* here we read the and also check for a memstream object */
+    /*tex Here we read the and also check for a memstream object. */
     if (!img_filepath(idict) || !FOPEN_RBIN_MODE) {
         normal_error("pdf backend","reading image file failed");
     }
     file = fopen(img_filepath(idict), FOPEN_RBIN_MODE);
     if (file == NULL) {
-        /* check the prefix of img_filepath(idict) */
+        /*tex We check the prefix of img_filepath(idict). */
         for (i = 0; (unsigned) i < LEN_PDF_MEMSTREAM; i++) {
             prefix[i] = (char) (img_filepath(idict)[i]);
         }
@@ -133,7 +106,7 @@ static void check_type_by_header(image_dict * idict)
             formatted_error("pdf backend","reading image file '%s' failed",img_filepath(idict));
         }
     }
-    /* a valid file, but perhaps unsupported */
+    /*tex Do we have a valid file but perhaps unsupported? */
     for (i = 0; (unsigned) i < MAX_HEADER; i++) {
         header[i] = (char) xgetc(file);
         if (feof(file)) {
@@ -141,7 +114,7 @@ static void check_type_by_header(image_dict * idict)
         }
     }
     xfclose(file, img_filepath(idict));
-    /* tests */
+    /*tex Further tests: */
     if (strncmp(header, HEADER_JPG, sizeof(HEADER_JPG) - 1) == 0)
         img_type(idict) = IMG_TYPE_JPG;
     else if (strncmp(header + 4, HEADER_JP2, sizeof(HEADER_JP2) - 1) == 0)
@@ -154,15 +127,13 @@ static void check_type_by_header(image_dict * idict)
         img_type(idict) = IMG_TYPE_PDF;
 }
 
-@ @c
 static void check_type_by_extension(image_dict * idict)
 {
     char *image_suffix;
     if (idict != NULL)
         return;
-    if (img_type(idict) != IMG_TYPE_NONE)       /* nothing to do */
+    if (img_type(idict) != IMG_TYPE_NONE)
         return;
-    /* tests */
     if ((image_suffix = strrchr(img_filename(idict), '.')) == 0)
         img_type(idict) = IMG_TYPE_NONE;
     else if (strcasecmp(image_suffix, ".png") == 0)
@@ -179,14 +150,13 @@ static void check_type_by_extension(image_dict * idict)
         img_type(idict) = IMG_TYPE_PDF;
 }
 
-@ @c
 void new_img_pdfstream_struct(image_dict * p)
 {
     img_pdfstream_ptr(p) = xtalloc(1, pdf_stream_struct);
     img_pdfstream_stream(p) = NULL;
+    img_pdfstream_size(p) = 0;
 }
 
-@ @c
 image *new_image(void)
 {
     image *p = xtalloc(1, image);
@@ -199,7 +169,6 @@ image *new_image(void)
     return p;
 }
 
-@ @c
 image_dict *new_image_dict(void)
 {
     image_dict *p = xtalloc(1, image_dict);
@@ -214,7 +183,8 @@ image_dict *new_image_dict(void)
     img_unset_bbox(p);
     img_unset_group(p);
     img_state(p) = DICT_NEW;
-    img_index(p) = -1; /* -1 = unused, used count from 0 */
+    /*tex A value of -1 means unused while the used counts from 0 */
+    img_index(p) = -1;
     img_luaref(p) = 0;
     img_errorlevel(p) = pdf_inclusion_errorlevel;
     fix_pdf_version(static_pdf);
@@ -223,7 +193,6 @@ image_dict *new_image_dict(void)
     return p;
 }
 
-@ @c
 static void free_dict_strings(image_dict * p)
 {
     xfree(img_filename(p));
@@ -232,12 +201,13 @@ static void free_dict_strings(image_dict * p)
     xfree(img_pagename(p));
 }
 
-@ @c
 void free_image_dict(image_dict * p)
 {
-    if (ini_version)
-        return;                 /* The image may be \.{\\dump}ed to a format */
-    /* called from limglib.c */
+    if (ini_version) {
+         /*tex The image may be \.{\\dump}ed to a format. */
+        return;
+    }
+    /*tex Called from limglib.c. */
     switch (img_type(p)) {
         case IMG_TYPE_PDFMEMSTREAM:
         case IMG_TYPE_PDF:
@@ -256,7 +226,6 @@ void free_image_dict(image_dict * p)
             flush_jbig2_info(p);
             break;
         case IMG_TYPE_PDFSTREAM:
-            /* flush_pdfstream_info(p); */
             if (img_pdfstream_ptr(p) != NULL) {
                 xfree(img_pdfstream_stream(p));
                 xfree(img_pdfstream_ptr(p));
@@ -271,7 +240,6 @@ void free_image_dict(image_dict * p)
     xfree(p);
 }
 
-@ @c
 void read_img(image_dict * idict)
 {
     char *filepath = NULL;
@@ -282,7 +250,7 @@ void read_img(image_dict * idict)
     callback_id = callback_defined(find_image_file_callback);
     if (img_filepath(idict) == NULL) {
         if (callback_id > 0) {
-            /* we always callback, also for a mem stream */
+            /*tex We always callback, also for a mem stream. */
             if (run_callback(callback_id, "S->S", img_filename(idict),&filepath)) {
                 if (filepath && (strlen(filepath) > 0)) {
                     img_filepath(idict) = strdup(filepath);
@@ -290,22 +258,22 @@ void read_img(image_dict * idict)
             }
         }
         if (img_filepath(idict) == NULL && (strstr(img_filename(idict),"data:application/pdf,") != NULL)) {
-            /* we need to check here for a pdf memstream */
+            /*tex We need to check here for a pdf memstream. */
             img_filepath(idict) = strdup(img_filename(idict));
         } else if (callback_id == 0) {
-            /* otherwise we use kpse but only when we don't callback  */
+            /*tex Otherwise we use kpse but only when we don't callback. */
             img_filepath(idict) = kpse_find_file(img_filename(idict), kpse_tex_format, true);
         }
         if (img_filepath(idict) == NULL) {
-            /* in any case we need a name */
+            /*tex In any case we need a name. */
             formatted_error("pdf backend","cannot find image file '%s'", img_filename(idict));
         }
     }
     recorder_record_input(img_filepath(idict));
-    /* type checks */
+    /*tex A few type checks. */
     check_type_by_header(idict);
     check_type_by_extension(idict);
-    /* read image */
+    /*tex Now we're ready to read the image. */
     switch (img_type(idict)) {
         case IMG_TYPE_PDFMEMSTREAM:
         case IMG_TYPE_PDF:
@@ -340,8 +308,7 @@ void read_img(image_dict * idict)
     }
 }
 
-@ @c
-static image_dict *read_image(char *file_name, int page_num, char *page_name, int colorspace, int page_box)
+static image_dict *read_image(char *file_name, int page_num, char *page_name, int colorspace, int page_box, char *user_password, char *owner_password, char *visible_filename)
 {
     image *a = new_image();
     image_dict *idict = img_dict(a) = new_image_dict();
@@ -353,6 +320,9 @@ static image_dict *read_image(char *file_name, int page_num, char *page_name, in
     img_colorspace(idict) = colorspace;
     img_pagenum(idict) = page_num;
     img_pagename(idict) = page_name;
+    img_userpassword(idict) = user_password;
+    img_ownerpassword(idict) = owner_password;
+    img_visiblefilename(idict) = visible_filename;
     if (file_name == NULL) {
         normal_error("pdf backend","no image filename given");
     }
@@ -363,8 +333,12 @@ static image_dict *read_image(char *file_name, int page_num, char *page_name, in
     return idict;
 }
 
-@ scans PDF pagebox specification
-@c
+/*tex
+
+    There can be several page boxes. Normally the cropbox is used.
+
+*/
+
 static pdfboxspec_e scan_pdf_box_spec(void)
 {
     if (scan_keyword("mediabox"))
@@ -381,14 +355,13 @@ static pdfboxspec_e scan_pdf_box_spec(void)
         return PDF_BOX_SPEC_NONE;
 }
 
-@ @c
-void scan_pdfximage(PDF pdf) /* static_pdf */
+void scan_pdfximage(PDF pdf)
 {
     scaled_whd alt_rule;
     image_dict *idict;
     int transform = 0, page = 1, pagebox, colorspace = 0;
-    char *named = NULL, *attr = NULL, *file_name = NULL;
-    alt_rule = scan_alt_rule(); /* scans |<rule spec>| to |alt_rule| */
+    char *named = NULL, *attr = NULL, *file_name = NULL, *user = NULL, *owner = NULL, *visible = NULL;
+    alt_rule = scan_alt_rule();
     if (scan_keyword("attr")) {
         scan_toks(false, true);
         attr = tokenlist_to_cstring(def_ref, true, NULL);
@@ -396,13 +369,33 @@ void scan_pdfximage(PDF pdf) /* static_pdf */
     }
     if (scan_keyword("named")) {
         scan_toks(false, true);
-        named = tokenlist_to_cstring(def_ref, true, NULL);
+        if (0) {
+            named = tokenlist_to_cstring(def_ref, true, NULL);
+            page = 0;
+        } else {
+            normal_warning("pdf backend","named pages are not supported, using page 1");
+            page = 1;
+        }
         delete_token_ref(def_ref);
-        page = 0;
     } else if (scan_keyword("page")) {
         scan_int();
         page = cur_val;
     }
+    if (scan_keyword("userpassword")) {
+        scan_toks(false, true);
+        user = tokenlist_to_cstring(def_ref, true, NULL);
+        delete_token_ref(def_ref);
+    }
+    if (scan_keyword("ownerpassword")) {
+        scan_toks(false, true);
+        owner = tokenlist_to_cstring(def_ref, true, NULL);
+        delete_token_ref(def_ref);
+    }
+    if (scan_keyword("visiblefilename")) {
+        scan_toks(false, true);
+        visible = tokenlist_to_cstring(def_ref, true, NULL);
+        delete_token_ref(def_ref);
+    }
     if (scan_keyword("colorspace")) {
         scan_int();
         colorspace = cur_val;
@@ -419,7 +412,7 @@ void scan_pdfximage(PDF pdf) /* static_pdf */
         normal_error("pdf backend","no image filename given");
     }
     delete_token_ref(def_ref);
-    idict = read_image(file_name, page, named, colorspace, pagebox);
+    idict = read_image(file_name, page, named, colorspace, pagebox, user, owner, visible);
     img_attr(idict) = attr;
     img_dimen(idict) = alt_rule;
     img_transform(idict) = transform;
@@ -427,33 +420,32 @@ void scan_pdfximage(PDF pdf) /* static_pdf */
     last_saved_image_pages = img_totalpages(idict);
 }
 
-@ @c
 void scan_pdfrefximage(PDF pdf)
 {
-    /* one could scan transform as well */
+    /*tex One could scan transform as well. */
     int transform = 0;
-    /* begin of experiment */
+    /*tex Begin of experiment. */
     int open = 0;
-    /* end of experiment */
+    /*tex End of experiment. */
     image_dict *idict;
-    /* scans |<rule spec>| to |alt_rule| */
+    /*tex This scans |<rule spec>| to |alt_rule|. */
     scaled_whd alt_rule, dim;
     alt_rule = scan_alt_rule();
-    /* begin of experiment */
+    /*tex Begin of experiment. */
     if (scan_keyword("keepopen")) {
         open = 1;
     }
-    /* end of experiment */
+    /*tex End of experiment. */
     scan_int();
     check_obj_type(pdf, obj_type_ximage, cur_val);
     tail_append(new_rule(image_rule));
     idict = idict_array[obj_data_ptr(pdf, cur_val)];
-    /* begin of experiment */
+    /*tex Begin of experiment, */
     if (open) {
-        /* so we keep the original value when no close is given */
+        /*tex So we keep the original value when no close is given. */
         idict->keepopen = 1;
     }
-    /* end of experiment */
+    /*tex End of experiment. */
     if (img_state(idict) == DICT_NEW) {
         normal_warning("image","don't rely on the image data to be okay");
         width(tail_par) = 0;
@@ -473,38 +465,41 @@ void scan_pdfrefximage(PDF pdf)
     }
 }
 
-@ |tex_scale()| sequence of decisions:
-
-{\obeylines\obeyspaces\tt
-wd ht dp : res = tex;
-wd ht --
-wd -- dp
-wd -- --
--- ht dp
--- ht --
--- -- dp
--- -- -- : res = nat;
-}
+/*
+    The |tex_scale| function follows a sequence of decisions:
+
+    \starttyping
+    wd ht dp : res = tex;
+    wd ht --
+    wd -- dp
+    wd -- --
+    -- ht dp
+    -- ht --
+    -- -- dp
+    -- -- -- : res = nat;
+    \stoptyping
+
+*/
 
-@c
 scaled_whd tex_scale(scaled_whd nat, scaled_whd tex)
 {
     scaled_whd res;
     if (!is_running(tex.wd) && !is_running(tex.ht) && !is_running(tex.dp)) {
-        /* width, height, and depth specified */
+        /*tex width, height, and depth specified */
         res = tex;
-    } else /* max. 2 dimensions are specified */ if (!is_running(tex.wd)) {
+    } else if (!is_running(tex.wd)) {
+        /*tex max. 2 dimensions are specified */
         res.wd = tex.wd;
         if (!is_running(tex.ht)) {
             res.ht = tex.ht;
-            /* width and height specified */
+            /*tex width and height specified */
             res.dp = ext_xn_over_d(tex.ht, nat.dp, nat.ht);
         } else if (!is_running(tex.dp)) {
             res.dp = tex.dp;
-            /* width and depth specified */
+            /*tex width and depth specified */
             res.ht = ext_xn_over_d(tex.wd, nat.ht + nat.dp, nat.wd) - tex.dp;
         } else {
-            /* only width specified */
+            /*tex only width specified */
             res.ht = ext_xn_over_d(tex.wd, nat.ht, nat.wd);
             res.dp = ext_xn_over_d(tex.wd, nat.dp, nat.wd);
         }
@@ -512,44 +507,50 @@ scaled_whd tex_scale(scaled_whd nat, scaled_whd tex)
         res.ht = tex.ht;
         if (!is_running(tex.dp)) {
             res.dp = tex.dp;
-            /* height and depth specified */
+            /*tex height and depth specified */
             res.wd = ext_xn_over_d(tex.ht + tex.dp, nat.wd, nat.ht + nat.dp);
         } else {
-            /* only height specified */
+            /*tex only height specified */
             res.wd = ext_xn_over_d(tex.ht, nat.wd, nat.ht);
             res.dp = ext_xn_over_d(tex.ht, nat.dp, nat.ht);
         }
     } else if (!is_running(tex.dp)) {
         res.dp = tex.dp;
-        /* only depth specified */
+        /*tex only depth specified */
         res.ht = nat.ht - (tex.dp - nat.dp);
         res.wd = nat.wd;
     } else {
-        /* nothing specified */
+        /*tex nothing specified */
         res = nat;
     }
     return res;
 }
 
-@ Within |scale_img()| only image width and height matter;
-the offsets and positioning are not interesting here.
-But one needs rotation info to swap width and height.
-|img_rotation()| comes from the optional /Rotate key in the PDF file.
+/*tex
+
+Within |scale_img| only image width and height matter; the offsets and
+positioning are not interesting here. But one needs rotation info to swap width
+and height. |img_rotation| comes from the optional |/Rotate| key in the PDF file.
+
+*/
 
-@c
 scaled_whd scale_img(image_dict * idict, scaled_whd alt_rule, int transform)
 {
-    int x, y, xr, yr, tmp;      /* size and resolution of image */
-    scaled_whd nat;             /* natural size corresponding to image resolution */
+    /*tex size and resolution of image */
+    int x, y, xr, yr, tmp;
+    /*tex natural size corresponding to image resolution */
+    scaled_whd nat;
     int default_res;
     if ((img_type(idict) == IMG_TYPE_PDF || img_type(idict) == IMG_TYPE_PDFMEMSTREAM
          || img_type(idict) == IMG_TYPE_PDFSTREAM) && img_is_bbox(idict)) {
-        x = img_xsize(idict) = img_bbox(idict)[2] - img_bbox(idict)[0]; /* dimensions from image.bbox */
+        /*tex dimensions from image.bbox */
+        x = img_xsize(idict) = img_bbox(idict)[2] - img_bbox(idict)[0];
         y = img_ysize(idict) = img_bbox(idict)[3] - img_bbox(idict)[1];
         img_xorig(idict) = img_bbox(idict)[0];
         img_yorig(idict) = img_bbox(idict)[1];
     } else {
-        x = img_xsize(idict);   /* dimensions, resolutions from image file */
+        /*tex dimensions, resolutions from image file */
+        x = img_xsize(idict);
         y = img_ysize(idict);
     }
     xr = img_xres(idict);
@@ -569,7 +570,8 @@ scaled_whd scale_img(image_dict * idict, scaled_whd alt_rule, int transform)
         xr = yr;
         yr = tmp;
     }
-    nat.dp = 0;                 /* always for images */
+    /*tex always for images */
+    nat.dp = 0;
     if (img_type(idict) == IMG_TYPE_PDF || img_type(idict) == IMG_TYPE_PDFMEMSTREAM
         || img_type(idict) == IMG_TYPE_PDFSTREAM) {
         nat.wd = x;
@@ -591,7 +593,6 @@ scaled_whd scale_img(image_dict * idict, scaled_whd alt_rule, int transform)
     return tex_scale(nat, alt_rule);
 }
 
-@ @c
 void write_img(PDF pdf, image_dict * idict)
 {
     if (img_state(idict) < DICT_WRITTEN) {
@@ -628,15 +629,17 @@ void write_img(PDF pdf, image_dict * idict)
         img_state(idict) = DICT_WRITTEN;
 }
 
-@ write an image
-@c
+int write_img_object(PDF pdf, image_dict * idict, int n)
+{
+    return write_epdf_object(pdf, idict, n);
+}
+
 void pdf_write_image(PDF pdf, int n)
 {
     if (pdf->draftmode == 0)
         write_img(pdf, idict_array[obj_data_ptr(pdf, n)]);
 }
 
-@ @c
 void check_pdfstream_dict(image_dict * idict)
 {
     if (!img_is_bbox(idict))
@@ -645,40 +648,43 @@ void check_pdfstream_dict(image_dict * idict)
         img_state(idict) = DICT_FILESCANNED;
 }
 
-@ @c
 void write_pdfstream(PDF pdf, image_dict * idict)
 {
     pdf_begin_obj(pdf, img_objnum(idict), OBJSTM_NEVER);
     pdf_begin_dict(pdf);
     pdf_dict_add_name(pdf, "Type", "XObject");
     pdf_dict_add_name(pdf, "Subtype", "Form");
-    if (img_attr(idict) != NULL && strlen(img_attr(idict)) > 0)
-        pdf_printf(pdf, "\n%s\n", img_attr(idict));
     pdf_dict_add_int(pdf, "FormType", 1);
     pdf_add_name(pdf, "BBox");
     pdf_begin_array(pdf);
-    copyReal(pdf, sp2bp(img_bbox(idict)[0]));
-    copyReal(pdf, sp2bp(img_bbox(idict)[1]));
-    copyReal(pdf, sp2bp(img_bbox(idict)[2]));
-    copyReal(pdf, sp2bp(img_bbox(idict)[3]));
+    pdf_add_real(pdf, sp2bp(img_bbox(idict)[0]));
+    pdf_add_real(pdf, sp2bp(img_bbox(idict)[1]));
+    pdf_add_real(pdf, sp2bp(img_bbox(idict)[2]));
+    pdf_add_real(pdf, sp2bp(img_bbox(idict)[3]));
     pdf_end_array(pdf);
-    pdf_dict_add_streaminfo(pdf);
+    if (img_attr(idict) != NULL && strlen(img_attr(idict)) > 0) {
+        pdf_printf(pdf, "\n%s\n", img_attr(idict));
+    }
+    if (!img_nolength(idict)) {
+        pdf_dict_add_streaminfo(pdf);
+    }
     pdf_end_dict(pdf);
     pdf_begin_stream(pdf);
-    if (img_pdfstream_stream(idict) != NULL)
-        pdf_puts(pdf, img_pdfstream_stream(idict));
+    if (img_pdfstream_stream(idict) != NULL) {
+        pdf_out_block(pdf, (const char *) img_pdfstream_stream(idict), img_pdfstream_size(idict));
+    }
     pdf_end_stream(pdf);
     pdf_end_obj(pdf);
 }
 
-@ @c
 idict_entry *idict_ptr, *idict_array = NULL;
 size_t idict_limit;
 
 void idict_to_array(image_dict * idict)
 {
-    if (idict_ptr - idict_array == 0) { /* align to count from 1 */
-        alloc_array(idict, 1, SMALL_BUF_SIZE);  /* /Im0 unused */
+    if (idict_ptr - idict_array == 0) {
+        /*tex align to count from 1 */
+        alloc_array(idict, 1, SMALL_BUF_SIZE);
         idict_ptr++;
     }
     alloc_array(idict, 1, SMALL_BUF_SIZE);
@@ -690,53 +696,60 @@ void pdf_dict_add_img_filename(PDF pdf, image_dict * idict)
 {
     char *p;
     if ((pdf_image_addfilename > 0) && ((pdf_suppress_optional_info & 2) == 0)) {
-        /* for now PTEX.FileName only for PDF, but prepared for JPG, PNG, ... */
+        /*tex
+            For now |PTEX.FileName| is only used for \PDF, but we're prepared
+            for \JPG, \PNG, ...
+        */
         if (! ( (img_type(idict) == IMG_TYPE_PDF) || (img_type(idict) == IMG_TYPE_PDFMEMSTREAM) ))
             return;
         if (img_visiblefilename(idict) != NULL) {
             if (strlen(img_visiblefilename(idict)) == 0) {
-                return; /* empty string blocks PTEX.FileName output */
+                /*tex empty string blocks PTEX.FileName output */
+                return;
             } else {
                 p = img_visiblefilename(idict);
             }
         } else {
-            /* unset so let's use the default */
+            /*tex unset so let's use the default */
             p = img_filepath(idict);
         }
-        // write additional information
+        /*tex write additional information */
         pdf_add_name(pdf, "PTEX.FileName");
         pdf_printf(pdf, " (%s)", convertStringToPDFString(p, strlen(p)));
     }
 }
 
-/* hh: why store images in the format ... let's get rid of this */
+/*tex
 
-@ To allow the use of box resources inside saved boxes in -ini mode,
-the information in the array has to be (un)dumped with the format.
-The next two routines take care of that.
+To allow the use of box resources inside saved boxes in -ini mode, the
+information in the array has to be (un)dumped with the format. The next two
+routines take care of that.
 
-Most of the work involved in setting up the images is simply
-executed again. This solves the many possible errors resulting from
-the split in two separate runs.
+Most of the work involved in setting up the images is simply executed again. This
+solves the many possible errors resulting from the split in two separate runs.
 
-There was only one problem remaining: The pdfversion and
-pdfinclusionerrorlevel can have changed inbetween the call to
-|readimage()| and dump time.
+There was only one problem remaining: The |pdfversion| and
+|pdfinclusionerrorlevel| can have changed inbetween the call to |readimage| and
+dump time.
 
-some of the dumped values are really type int, not integer,
-but since the macro falls back to |generic_dump| anyway, that
-does not matter.
+Some of the dumped values are really type int, not integer,but since the macro
+falls back to |generic_dump| anyway, that does not matter.
+
+We might drop this feature as it makes no sense to store images in the format.
+
+*/
 
-@c
 #define dumpinteger generic_dump
 #define undumpinteger generic_undump
 
-@ (un)dumping a string means dumping the allocation size, followed
- by the bytes. The trailing \.{\\0} is dumped as well, because that
- makes the code simpler.
+/*tex
+
+(Un)dumping a string means dumping the allocation size, followed by the bytes.
+The trailing \.{\\0} is dumped as well, because that makes the code simpler. The
+rule specification ends up in |alt_rule|.
+
+*/
 
-@ scan rule spec to |alt_rule|
-@c
 scaled_whd scan_alt_rule(void)
 {
     boolean loop;
@@ -763,8 +776,12 @@ scaled_whd scan_alt_rule(void)
     return alt_rule;
 }
 
-@ copy file of arbitrary size to PDF buffer and flush as needed
-@c
+/*tex
+
+    This copy a file of arbitrary size to the buffer and flushed as needed.
+
+*/
+
 size_t read_file_to_buf(PDF pdf, FILE * f, size_t len)
 {
     size_t i, j, k = 0;
diff --git a/texk/web2c/luatexdir/image/writejbig2.w b/texk/web2c/luatexdir/image/writejbig2.c
similarity index 80%
rename from texk/web2c/luatexdir/image/writejbig2.w
rename to texk/web2c/luatexdir/image/writejbig2.c
index a58313ce8..77a1ddb07 100644
--- a/texk/web2c/luatexdir/image/writejbig2.w
+++ b/texk/web2c/luatexdir/image/writejbig2.c
@@ -1,27 +1,30 @@
-% writejbig2.w
-%
-% Copyright 1996-2006 Han The Thanh <thanh@@pdftex.org>
-% Copyright 2006-2013 Taco Hoekwater <taco@@luatex.org>
-% Copyright 2003-2013 Hartmut Henkel <hartmut@@luatex.org>
-%
-% This file is part of LuaTeX.
-%
-% LuaTeX is free software; you can redistribute it and/or modify it under
-% the terms of the GNU General Public License as published by the Free
-% Software Foundation; either version 2 of the License, or (at your
-% option) any later version.
-%
-% LuaTeX is distributed in the hope that it will be useful, but WITHOUT
-% ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-% FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
-% License for more details.
-%
-% You should have received a copy of the GNU General Public License along
-% with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
-
-@
-This is experimental JBIG2 image support to pdfTeX. JBIG2 image decoding
-is part of Adobe PDF-1.4, and requires Acroread 5.0 or later.
+/*
+
+writejbig2.c
+
+Copyright 1996-2006 Han The Thanh <thanh@pdftex.org>
+Copyright 2006-2013 Taco Hoekwater <taco@luatex.org>
+Copyright 2003-2013 Hartmut Henkel <hartmut@luatex.org>
+
+This file is part of LuaTeX.
+
+LuaTeX is free software; you can redistribute it and/or modify it under the terms
+of the GNU General Public License as published by the Free Software Foundation;
+either version 2 of the License, or (at your option) any later version.
+
+LuaTeX is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU General Public License along with
+LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+
+*/
+
+/*tex
+
+This is experimental JBIG2 image support to pdfTeX. JBIG2 image decoding is part
+of Adobe PDF-1.4, and requires Acroread 5.0 or later.
 
 References
 ==========
@@ -78,7 +81,8 @@ object exists, reference it. Else create fresh one.
 
 09 Dec. 2002: JBIG2 seg. page numbers > 0 are now set to 1, see PDF Ref.
 
-@ @c
+*/
+
 #undef DEBUG
 
 #include "ptexlib.h"
@@ -87,8 +91,8 @@ object exists, reference it. Else create fresh one.
 #include <assert.h>
 #include "image/image.h"
 
-@ @c
-/* 7.3 Segment types */
+/*tex Table 7.3: Segment types */
+
 #define M_SymbolDictionary 0
 #define M_IntermediateTextRegion 4
 #define M_ImmediateTextRegion 6
@@ -111,13 +115,12 @@ object exists, reference it. Else create fresh one.
 #define M_Tables 53
 #define M_Extension 62
 
-@ @c
 typedef enum { INITIAL, HAVEINFO, WRITEPDF } PHASE;
 
 typedef struct _LITEM {
     struct _LITEM *prev;
     struct _LITEM *next;
-    void *d; /* data */
+    void *d;
 } LITEM;
 
 typedef struct _LIST {
@@ -130,26 +133,28 @@ typedef struct _SEGINFO {
     unsigned long segnum;
     boolean isrefered;
     boolean refers;
-    unsigned int seghdrflags;    /* set by readseghdr() */
-    boolean pageassocsizeflag;   /* set by readseghdr() */
-    unsigned int reftosegcount;  /* set by readseghdr() */
-    unsigned int countofrefered; /* set by readseghdr() */
-    unsigned int fieldlen;       /* set by readseghdr() */
-    unsigned int segnumwidth;    /* set by readseghdr() */
-    long segpage;                /* set by readseghdr() */
-    unsigned long segdatalen;    /* set by readseghdr() */
-    unsigned long hdrstart;      /* set by readseghdr() */
-    unsigned long hdrend;        /* set by readseghdr() */
+    /*tex Set by |readseghdr|: */
+    unsigned int seghdrflags;
+    boolean pageassocsizeflag;
+    unsigned int reftosegcount;
+    unsigned int countofrefered;
+    unsigned int fieldlen;
+    unsigned int segnumwidth;
+    long segpage;
+    unsigned long segdatalen;
+    unsigned long hdrstart;
+    unsigned long hdrend;
     unsigned long datastart;
     unsigned long dataend;
-    boolean endofstripeflag;     /* set by checkseghdrflags() */
-    boolean endofpageflag;       /* set by checkseghdrflags() */
-    boolean pageinfoflag;        /* set by checkseghdrflags() */
-    boolean endoffileflag;       /* set by checkseghdrflags() */
+    /*tex Set by |checkseghdrflags|: */
+    boolean endofstripeflag;
+    boolean endofpageflag;
+    boolean pageinfoflag;
+    boolean endoffileflag;
 } SEGINFO;
 
 typedef struct _PAGEINFO {
-    LIST segments;               /* segments associated with page */
+    LIST segments;
     unsigned long pagenum;
     unsigned int width;
     unsigned int height;
@@ -164,17 +169,19 @@ typedef struct _FILEINFO {
     FILE *file;
     char *filepath;
     long filesize;
-    LIST pages;                  /* not including page0 */
+    /*tex Not including |page0|: */
+    LIST pages;
     LIST page0;
-    unsigned int filehdrflags;   /* set by readfilehdr() */
-    boolean sequentialaccess;    /* set by readfilehdr() */
-    unsigned long numofpages;    /* set by readfilehdr() */
-    unsigned long streamstart;   /* set by |get_jbig2_info()| */
+    /*tex Set by |readfilehdr| */
+    unsigned int filehdrflags;
+    boolean sequentialaccess;
+    unsigned long numofpages;
+    /*tex Set by |get_jbig2_info| */
+    unsigned long streamstart;
     unsigned long pdfpage0objnum;
     PHASE phase;
 } FILEINFO;
 
-@ @c
 static struct avl_table *file_tree = NULL;
 
 static int comp_file_entry(const void *pa, const void *pb, void *p)
@@ -195,7 +202,6 @@ static int comp_segment_entry(const void *pa, const void *pb, void *p)
     return (int) (((const SEGINFO *) pa)->segnum - ((const SEGINFO *) pb)->segnum);
 }
 
-@ @c
 static int ygetc(FILE * stream)
 {
     int c = getc(stream);
@@ -208,7 +214,6 @@ static int ygetc(FILE * stream)
     return c;
 }
 
-@ @c
 static void initlinkedlist(LIST * lp)
 {
     lp->first = NULL;
@@ -233,7 +238,6 @@ static LIST *litem_append(LIST * lp)
     return lp;
 }
 
-@ @c
 static FILEINFO *new_fileinfo(void)
 {
     FILEINFO *fip;
@@ -252,7 +256,6 @@ static FILEINFO *new_fileinfo(void)
     return fip;
 }
 
-@ @c
 static PAGEINFO *new_pageinfo(void)
 {
     PAGEINFO *pip;
@@ -269,7 +272,6 @@ static PAGEINFO *new_pageinfo(void)
     return pip;
 }
 
-@ @c
 static void init_seginfo(SEGINFO * sip)
 {
     sip->segnum = 0;
@@ -293,7 +295,6 @@ static void init_seginfo(SEGINFO * sip)
     sip->endoffileflag = false;
 }
 
-@ @c
 static void pages_maketree(LIST * plp)
 {
     LITEM *ip;
@@ -307,7 +308,6 @@ static void pages_maketree(LIST * plp)
     }
 }
 
-@ @c
 static void segments_maketree(LIST * slp)
 {
     LITEM *ip;
@@ -321,7 +321,6 @@ static void segments_maketree(LIST * slp)
     }
 }
 
-@ @c
 static PAGEINFO *find_pageinfo(LIST * plp, unsigned long pagenum)
 {
     PAGEINFO tmp;
@@ -330,7 +329,6 @@ static PAGEINFO *find_pageinfo(LIST * plp, unsigned long pagenum)
     return (PAGEINFO *) avl_find(plp->tree, &tmp);
 }
 
-@ @c
 static SEGINFO *find_seginfo(LIST * slp, unsigned long segnum)
 {
     SEGINFO tmp;
@@ -339,21 +337,18 @@ static SEGINFO *find_seginfo(LIST * slp, unsigned long segnum)
     return (SEGINFO *) avl_find(slp->tree, &tmp);
 }
 
-@ @c
 unsigned int read2bytes(FILE * f)
 {
     unsigned int c = (unsigned int) ygetc(f);
     return (c << 8) + (unsigned int) ygetc(f);
 }
 
-@ @c
 unsigned int read4bytes(FILE * f)
 {
     unsigned int l = read2bytes(f);
     return (l << 16) + read2bytes(f);
 }
 
-@ @c
 static unsigned long getstreamlen(LITEM * slip, boolean refer)
 {
     SEGINFO *sip;
@@ -366,39 +361,40 @@ static unsigned long getstreamlen(LITEM * slip, boolean refer)
     return len;
 }
 
-@ @c
 static void readfilehdr(FILEINFO * fip)
 {
     unsigned int i;
-    /* Annex D.4 File header syntax */
-    /* Annex D.4.1 ID string */
+    /*tex Annex D.4: File header syntax */
+    /*tex Annex D.4.1: ID string */
     unsigned char jbig2_id[] = { 0x97, 'J', 'B', '2', 0x0d, 0x0a, 0x1a, 0x0a };
     xfseek(fip->file, 0, SEEK_SET, fip->filepath);
     for (i = 0; i < 8; i++)
         if (ygetc(fip->file) != jbig2_id[i])
             normal_error("readjbig2","ID string missing");
-    /* Annex D.4.2 File header flags */
+    /*tex Annex D.4.2: File header flags */
     fip->filehdrflags = (unsigned int) ygetc(fip->file);
     fip->sequentialaccess = (fip->filehdrflags & 0x01) ? true : false;
-    if (fip->sequentialaccess) {        /* Annex D.1 vs. Annex D.2 */
+    if (fip->sequentialaccess) {
+        /*tex Annex D.1 vs. Annex D.2 */
         xfseek(fip->file, 0, SEEK_END, fip->filepath);
         fip->filesize = (long) xftello(fip->file, fip->filepath);
         xfseek(fip->file, 9, SEEK_SET, fip->filepath);
     }
-    /* Annex D.4.3 Number of pages */
-    if (!(fip->filehdrflags >> 1) & 0x01)       /* known number of pages */
+    /*tex Annex D.4.3: Number of pages */
+    if (( !(fip->filehdrflags >> 1)) & 0x01) {
+        /*tex The known number of pages: */
         fip->numofpages = read4bytes(fip->file);
-    /* --- at end of file header --- */
+    }
+    /*tex End of file header */
 }
 
-@ @c
 static void checkseghdrflags(SEGINFO * sip)
 {
     sip->endofstripeflag = false;
     sip->endofpageflag = false;
     sip->pageinfoflag = false;
     sip->endoffileflag = false;
-    /* 7.3 Segment types */
+    /*tex Table 7.3: Segment types */
     switch (sip->seghdrflags & 0x3f) {
         case M_SymbolDictionary:
         case M_IntermediateTextRegion:
@@ -437,24 +433,34 @@ static void checkseghdrflags(SEGINFO * sip)
     }
 }
 
-@ for first reading of file; return value tells if header been read
+/*tex
+
+    For first reading of file; return value tells if header been read.
+
+*/
 
-@c
 static boolean readseghdr(FILEINFO * fip, SEGINFO * sip)
 {
     unsigned int i;
     sip->hdrstart = xftell(fip->file, fip->filepath);
-    if (fip->sequentialaccess && sip->hdrstart == (unsigned) fip->filesize)
-        return false;           /* no endoffileflag is ok for sequentialaccess */
-    /* 7.2.2 Segment number */
+    if (fip->sequentialaccess && sip->hdrstart == (unsigned) fip->filesize) {
+        /*tex No endoffileflag is ok for sequential access. */
+        return false;
+    }
+    /*tex Table 7.2.2: Segment number */
     sip->segnum = read4bytes(fip->file);
-    /* 7.2.3 Segment header flags */
+    /*tex Table 7.2.3: Segment header flags */
     sip->seghdrflags = (unsigned int) ygetc(fip->file);
     checkseghdrflags(sip);
-    if (fip->sequentialaccess && sip->endoffileflag)    /* accept shorter segment, */
-        return true;            /* makes it compliant with Example 3.4 of PDFRef. 5th ed. */
+    if (fip->sequentialaccess && sip->endoffileflag) {
+        /*
+            Accept shorter segment, makes it compliant with Example 3.4 of
+            PDFRef. 5th ed.
+        */
+        return true;
+    }
     sip->pageassocsizeflag = ((sip->seghdrflags >> 6) & 0x01) ? true : false;
-    /* 7.2.4 Referred-to segment count and retention flags */
+    /*tex Table 7.2.4: Referred-to segment count and retention flags */
     sip->reftosegcount = (unsigned int) ygetc(fip->file);
     sip->countofrefered = sip->reftosegcount >> 5;
     if (sip->countofrefered < 5)
@@ -463,7 +469,7 @@ static boolean readseghdr(FILEINFO * fip, SEGINFO * sip)
         sip->fieldlen = 5 + sip->countofrefered / 8;
         xfseek(fip->file, sip->fieldlen - 1, SEEK_CUR, fip->filepath);
     }
-    /* 7.2.5 Referred-to segment numbers */
+    /*tex Table 7.2.5: Referred-to segment numbers */
     if (sip->segnum <= 256)
         sip->segnumwidth = 1;
     else if (sip->segnum <= 65536)
@@ -483,19 +489,18 @@ static boolean readseghdr(FILEINFO * fip, SEGINFO * sip)
                 break;
         }
     }
-    /* 7.2.6 Segment page association */
+    /*tex Table 7.2.6: Segment page association */
     if (sip->pageassocsizeflag)
         sip->segpage = read4bytes(fip->file);
     else
         sip->segpage = ygetc(fip->file);
-    /* 7.2.7 Segment data length */
+    /*tex Table 7.2.7: Segment data length */
     sip->segdatalen = read4bytes(fip->file);
     sip->hdrend = (unsigned long) xftello(fip->file, fip->filepath);
-    /* ---- at end of segment header ---- */
+    /*tex End of segment header. */
     return true;
 }
 
-@ @c
 static void checkseghdr(FILEINFO * fip, SEGINFO * sip);
 
 static void markpage0seg(FILEINFO * fip, unsigned long referedseg)
@@ -511,19 +516,23 @@ static void markpage0seg(FILEINFO * fip, unsigned long referedseg)
     }
 }
 
-@ for writing, marks refered page0 segments, sets segpage > 0 to 1
+/*tex
+
+    For writing, marks refered page0 segments, sets segpage larger than
+    zero to one.
+
+*/
 
-@c
 static void writeseghdr(PDF pdf, FILEINFO * fip, SEGINFO * sip)
 {
     unsigned int i;
     unsigned long referedseg = 0;
-    /* 7.2.2 Segment number */
-    /* 7.2.3 Segment header flags */
-    /* 7.2.4 Referred-to segment count and retention flags */
+    /*tex Table 7.2.2: Segment number */
+    /*tex Table 7.2.3: Segment header flags */
+    /*tex Table 7.2.4: Referred-to segment count and retention flags */
     for (i = 0; i < 5 + sip->fieldlen; i++)
         pdf_out(pdf, ygetc(fip->file));
-    /* 7.2.5 Referred-to segment numbers */
+    /*tex Table 7.2.5: Referred-to segment numbers */
     for (i = 0; i < sip->countofrefered; i++) {
         switch (sip->segnumwidth) {
             case 1:
@@ -548,7 +557,7 @@ static void writeseghdr(PDF pdf, FILEINFO * fip, SEGINFO * sip)
     }
     if (sip->countofrefered > 0)
         sip->refers = true;
-    /* 7.2.6 Segment page association */
+    /*tex Table 7.2.6: Segment page association */
     if (sip->pageassocsizeflag)
         for (i = 0; i < 3; i++) {
             (void) ygetc(fip->file);
@@ -556,23 +565,27 @@ static void writeseghdr(PDF pdf, FILEINFO * fip, SEGINFO * sip)
         }
     (void) ygetc(fip->file);
     pdf_out(pdf, (unsigned char) ((sip->segpage > 0) ? 1 : 0));
-    /* 7.2.7 Segment data length */
+    /*tex Table 7.2.7: Segment data length */
     for (i = 0; i < 4; i++)
         pdf_out(pdf, ygetc(fip->file));
-    /* ---- at end of segment header ---- */
+    /* End of segment header. */
 }
 
-@ for recursive marking of refered page0 segments
-@c
+/*tex
+
+    For recursive marking of refered page0 segments:
+
+*/
+
 static void checkseghdr(FILEINFO * fip, SEGINFO * sip)
 {
     unsigned int i;
     unsigned long referedseg = 0;
-    /* 7.2.2 Segment number */
-    /* 7.2.3 Segment header flags */
-    /* 7.2.4 Referred-to segment count and retention flags */
+    /*tex Table 7.2.2: Segment number */
+    /*tex Table 7.2.3: Segment header flags */
+    /*tex Table 7.2.4: Referred-to segment count and retention flags */
     xfseek(fip->file, 5 + sip->fieldlen, SEEK_CUR, fip->filepath);
-    /* 7.2.5 Referred-to segment numbers */
+    /*tex Table 7.2.5: Referred-to segment numbers */
     for (i = 0; i < sip->countofrefered; i++) {
         switch (sip->segnumwidth) {
             case 1:
@@ -590,33 +603,34 @@ static void checkseghdr(FILEINFO * fip, SEGINFO * sip)
     }
     if (sip->countofrefered > 0)
         sip->refers = true;
-    /* 7.2.6 Segment page association */
-    /* 7.2.7 Segment data length */
+    /*tex Table 7.2.6: Segment page association */
+    /*tex Table 7.2.7: Segment data length */
     if (sip->pageassocsizeflag)
         xfseek(fip->file, 8, SEEK_CUR, fip->filepath);
     else
         xfseek(fip->file, 5, SEEK_CUR, fip->filepath);
-    /* ---- at end of segment header ---- */
+    /*tex End of segment header. */
 }
 
-@ @c
 static unsigned long findstreamstart(FILEINFO * fip)
 {
     SEGINFO tmp;
-    assert(!fip->sequentialaccess);   /* D.2 Random-access organisation */
-    do                                /* find random-access stream start */
+    /*tex Table D.2: Random-access organisation */
+    do {
+        /*tex Find random-access stream start. */
         (void) readseghdr(fip, &tmp);
-    while (!tmp.endoffileflag);
+    } while (!tmp.endoffileflag);
     fip->streamstart = tmp.hdrend;
     readfilehdr(fip);
     return fip->streamstart;
 }
 
-@ @c
 static void rd_jbig2_info(FILEINFO * fip)
 {
-    unsigned long seekdist = 0;    /* for sequential-access only */
-    unsigned long streampos = 0;   /* for random-access only */
+    /*tex For sequential-access only: */
+    unsigned long seekdist = 0;
+    /*tex For random-access only: */
+    unsigned long streampos = 0;
     unsigned long currentpage = 0;
     boolean sipavail = false;
     PAGEINFO *pip;
@@ -624,9 +638,12 @@ static void rd_jbig2_info(FILEINFO * fip)
     LIST *plp, *slp;
     fip->file = xfopen(fip->filepath, FOPEN_RBIN_MODE);
     readfilehdr(fip);
-    if (!fip->sequentialaccess) /* D.2 Random-access organisation */
+    if (!fip->sequentialaccess) {
+        /*tex Table D.2: Random-access organisation */
         streampos = findstreamstart(fip);
-    while (true) {              /* loop over segments */
+    }
+    while (true) {
+        /*tex Loop over segments: */
         if (!sipavail) {
             sip = xtalloc(1, SEGINFO);
             sipavail = true;
@@ -658,11 +675,10 @@ static void rd_jbig2_info(FILEINFO * fip)
         else
             sip->datastart = sip->hdrend;
         sip->dataend = sip->datastart + sip->segdatalen;
-        if (!fip->sequentialaccess
-            && (sip->pageinfoflag || sip->endofstripeflag))
+        if (!fip->sequentialaccess && (sip->pageinfoflag || sip->endofstripeflag))
             xfseeko(fip->file, (off_t) sip->datastart, SEEK_SET, fip->filepath);
         seekdist = sip->segdatalen;
-        /* 7.4.8 Page information segment syntax */
+        /*tex Table 7.4.8: Page information segment syntax */
         if (sip->pageinfoflag) {
             pip->pagenum = (unsigned long) sip->segpage;
             pip->width = read4bytes(fip->file);
@@ -670,7 +686,7 @@ static void rd_jbig2_info(FILEINFO * fip)
             pip->xres = read4bytes(fip->file);
             pip->yres = read4bytes(fip->file);
             pip->pagesegmentflags = (unsigned) ygetc(fip->file);
-            /* 7.4.8.6 Page striping information */
+            /*tex Table 7.4.8.6: Page striping information */
             pip->stripinginfo = read2bytes(fip->file);
             seekdist -= 19;
         }
@@ -694,9 +710,7 @@ static void rd_jbig2_info(FILEINFO * fip)
     xfclose(fip->file, fip->filepath);
 }
 
-@ @c
-static void wr_jbig2(PDF pdf, image_dict * idict, FILEINFO * fip,
-                     unsigned long page)
+static void wr_jbig2(PDF pdf, image_dict * idict, FILEINFO * fip, unsigned long page)
 {
     LITEM *slip;
     PAGEINFO *pip;
@@ -743,11 +757,12 @@ static void wr_jbig2(PDF pdf, image_dict * idict, FILEINFO * fip,
     }
     pdf_begin_stream(pdf);
     fip->file = xfopen(fip->filepath, FOPEN_RBIN_MODE);
-    for (slip = pip->segments.first; slip != NULL; slip = slip->next) { /* loop over page segments */
+    for (slip = pip->segments.first; slip != NULL; slip = slip->next) {
+        /*tex Loop over page segments. */
         sip = slip->d;
         if (sip->isrefered || page > 0) {
             xfseeko(fip->file, (off_t) sip->hdrstart, SEEK_SET, fip->filepath);
-            /* mark refered-to page 0 segments, change segpages > 1 to 1 */
+            /*tex Mark refered-to page 0 segments, change segpages > 1 to 1. */
             writeseghdr(pdf, fip, sip);
             xfseeko(fip->file, (off_t) sip->datastart, SEEK_SET, fip->filepath);
             for (i = sip->datastart; i < sip->dataend; i++)
@@ -759,7 +774,6 @@ static void wr_jbig2(PDF pdf, image_dict * idict, FILEINFO * fip,
     xfclose(fip->file, fip->filepath);
 }
 
-@ @c
 boolean supported_jbig2(image_dict * idict)
 {
     if (img_pdfmajorversion(idict) < 2 && img_pdfminorversion(idict) < 4) {
@@ -770,20 +784,19 @@ boolean supported_jbig2(image_dict * idict)
     }
 }
 
-@ @c
 void flush_jbig2_info(image_dict * idict)
 {
-    /* todo */
+    /*tex Todo (or not). */
 }
 
-@ @c
 void read_jbig2_info(image_dict * idict)
 {
     FILEINFO *fip, tmp;
     PAGEINFO *pip;
-    img_type(idict) = IMG_TYPE_JBIG2; /* already set probably, see other read_... */
+    /*tex Already set probably, see other |read_|. */
+    img_type(idict) = IMG_TYPE_JBIG2;
     if (! supported_jbig2(idict)) {
-        /* already an error done */
+        /*tex Already an error seen? */
     }
     if (img_pagenum(idict) < 1) {
         normal_error("readjbig2","page must be > 0");
@@ -819,24 +832,19 @@ void read_jbig2_info(image_dict * idict)
     img_colordepth(idict) = 1;
 }
 
-@ @c
 void write_jbig2(PDF pdf, image_dict * idict)
 {
     FILEINFO *fip, tmp;
     PAGEINFO *pip;
-    assert(idict != NULL);
-    assert(file_tree != NULL);
     tmp.filepath = img_filepath(idict);
     fip = (FILEINFO *) avl_find(file_tree, &tmp);
-    assert(fip != NULL);
-    assert(fip->phase == HAVEINFO);     /* don't write before |rd_jbig2_info()| call */
+    /*tex Don't write before |rd_jbig2_info()| call. */
     pip = find_pageinfo(&(fip->pages), (unsigned long) img_pagenum(idict));
     assert(pip != NULL);
     wr_jbig2(pdf, idict, fip, pip->pagenum);
     img_file(idict) = NULL;
 }
 
-@ @c
 void flush_jbig2_page0_objects(PDF pdf)
 {
     FILEINFO *fip;
@@ -846,7 +854,8 @@ void flush_jbig2_page0_objects(PDF pdf)
         for (fip = avl_t_first(&t, file_tree); fip != NULL;
              fip = avl_t_next(&t)) {
             if (fip->page0.last != NULL)
-                wr_jbig2(pdf, NULL, fip, 0);    /* NULL: page0 */
+                /*tex |NULL|: page0 */
+                wr_jbig2(pdf, NULL, fip, 0);
         }
     }
 }
diff --git a/texk/web2c/luatexdir/image/writejp2.w b/texk/web2c/luatexdir/image/writejp2.c
similarity index 82%
rename from texk/web2c/luatexdir/image/writejp2.w
rename to texk/web2c/luatexdir/image/writejp2.c
index cb317e119..0ea001708 100644
--- a/texk/web2c/luatexdir/image/writejp2.w
+++ b/texk/web2c/luatexdir/image/writejp2.c
@@ -1,38 +1,42 @@
-% writejp2.w
-%
-% Copyright 2011-2013 Taco Hoekwater <taco@@luatex.org>
-% Copyright 2011-2013 Hartmut Henkel <hartmut@@luatex.org>
-%
-% This file is part of LuaTeX.
-%
-% LuaTeX is free software; you can redistribute it and/or modify it under
-% the terms of the GNU General Public License as published by the Free
-% Software Foundation; either version 2 of the License, or (at your
-% option) any later version.
-%
-% LuaTeX is distributed in the hope that it will be useful, but WITHOUT
-% ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-% FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
-% License for more details.
-%
-% You should have received a copy of the GNU General Public License along
-% with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+/*
 
-@ @c
+writejp2.c
 
-@ Basic JPEG~2000 image support. Section and Table references below:
-Information technology --- JPEG~2000 image coding system: Core coding system.
-ISO/IEC 15444-1, Second edition, 2004-09-15, file |15444-1annexi.pdf|.
+Copyright 2011-2013 Taco Hoekwater <taco@luatex.org>
+Copyright 2011-2013 Hartmut Henkel <hartmut@luatex.org>
+
+This file is part of LuaTeX.
+
+LuaTeX is free software; you can redistribute it and/or modify it under the terms
+of the GNU General Public License as published by the Free Software Foundation;
+either version 2 of the License, or (at your option) any later version.
+
+LuaTeX is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU General Public License along with
+LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+
+*/
+
+/*tex
+
+    Basic JPEG~2000 image support. Section and Table references below:
+    Information technology --- JPEG~2000 image coding system: Core coding system.
+    ISO/IEC 15444-1, Second edition, 2004-09-15, file |15444-1annexi.pdf|.
+
+*/
 
-@c
 #include "ptexlib.h"
 #include <math.h>
 #include <assert.h>
 #include "image/image.h"
 #include "image/writejp2.h"
-#include "image/writejbig2.h"   /* read2bytes(), read4bytes() */
+#include "image/writejbig2.h"
+
+/*tex Table 1.2: Defined boxes */
 
-/* Table 1.2 -- Defined boxes */
 #define BOX_JP   0x6A502020
 #define BOX_FTYP 0x66747970
 #define BOX_JP2H 0x6a703268
@@ -45,7 +49,8 @@ ISO/IEC 15444-1, Second edition, 2004-09-15, file |15444-1annexi.pdf|.
 #define BOX_RESD 0x72657364
 #define BOX_JP2C 0x6A703263
 
-/* 1.4 Box definition */
+/*tex Table 1.4: Box definition */
+
 typedef struct {
     uint64_t lbox;
     unsigned int tbox;
@@ -71,7 +76,8 @@ static hdr_struct read_boxhdr(image_dict * idict)
     return hdr;
 }
 
-/* 1.5.3.1 Image Header box */
+/*tex Table 1.5.3.1: Image Header box */
+
 static void scan_ihdr(image_dict * idict)
 {
     unsigned int height, width;
@@ -88,8 +94,9 @@ static void scan_ihdr(image_dict * idict)
     (void) xgetc(img_file(idict));      /* ipr */
 }
 
-/* 1.5.3.7.1 Capture Resolution box */
-/* 1.5.3.7.2 Default Display Resolution box */
+/*tex Table 1.5.3.7.1: Capture Resolution box */
+
+/*tex Table 1.5.3.7.2: Default Display Resolution box */
 
 static void scan_resc_resd(image_dict * idict)
 {
@@ -108,7 +115,7 @@ static void scan_resc_resd(image_dict * idict)
     img_yres(idict) = (int) (vr_ + 0.5);
 }
 
-/* 1.5.3.7 Resolution box (superbox) */
+/*tex Table 1.5.3.7: Resolution box (superbox) */
 
 static void scan_res(image_dict * idict, uint64_t epos_s)
 {
@@ -121,7 +128,7 @@ static void scan_res(image_dict * idict, uint64_t epos_s)
         epos = spos + hdr.lbox;
         switch (hdr.tbox) {
             case (BOX_RESC):
-                /* arbitrarily: let BOX_RESD have precedence */
+                /*tex arbitrary: let BOX_RESD have precedence */
                 if (img_xres(idict) == 0 && img_yres(idict) == 0) {
                     scan_resc_resd(idict);
                     if (xftell(img_file(idict), img_filepath(idict)) != (long)epos)
@@ -143,7 +150,7 @@ static void scan_res(image_dict * idict, uint64_t epos_s)
     }
 }
 
-/* 1.5.3 JP2 Header box (superbox) */
+/*tex Table 1.5.3: JP2 Header box (superbox) */
 
 static boolean scan_jp2h(image_dict * idict, uint64_t epos_s)
 {
@@ -178,7 +185,7 @@ static boolean scan_jp2h(image_dict * idict, uint64_t epos_s)
 
 static void close_and_cleanup_jp2(image_dict * idict)
 {
-    /* if one of then is not NULL we already cleaned up */
+    /*tex If one of then is not NULL we already cleaned up. */
     if (img_file(idict) != NULL) {
         xfclose(img_file(idict), img_filepath(idict));
         img_file(idict) = NULL;
@@ -216,11 +223,11 @@ void read_jp2_info(image_dict * idict)
         normal_error("readjp2","size problem");
     }
     spos = epos = 0;
-    /* 1.5.1 JPEG 2000 Signature box */
+    /*tex Table 1.5.1: JPEG 2000 Signature box */
     hdr = read_boxhdr(idict);
     epos = spos + hdr.lbox;
     xfseek(img_file(idict), (long) epos, SEEK_SET, img_filepath(idict));
-    /* 1.5.2 File Type box */
+    /*tex Table 1.5.2: File Type box */
     spos = epos;
     hdr = read_boxhdr(idict);
     if (hdr.tbox != BOX_FTYP) {
@@ -256,9 +263,7 @@ static void reopen_jp2(image_dict * idict)
     height = img_ysize(idict);
     xres = img_xres(idict);
     yres = img_yres(idict);
-    /*
-        we need to make sure that the file kept open
-    */
+    /*tex We need to make sure that the file kept open. */
     img_keepopen(idict) = 1;
     read_jp2_info(idict);
     if (width != img_xsize(idict) || height != img_ysize(idict)
@@ -292,6 +297,6 @@ void write_jp2(PDF pdf, image_dict * idict)
         normal_error("writejp2","fread failed");
     pdf_end_stream(pdf);
     pdf_end_obj(pdf);
-    /* always */
+    /*tex We always:*/
     close_and_cleanup_jp2(idict);
 }
diff --git a/texk/web2c/luatexdir/image/writejpg.w b/texk/web2c/luatexdir/image/writejpg.c
similarity index 76%
rename from texk/web2c/luatexdir/image/writejpg.w
rename to texk/web2c/luatexdir/image/writejpg.c
index 54ed47f0f..f58dc2aa6 100644
--- a/texk/web2c/luatexdir/image/writejpg.w
+++ b/texk/web2c/luatexdir/image/writejpg.c
@@ -1,31 +1,30 @@
-% writejpg.w
-%
-% Copyright 1996-2006 Han The Thanh <thanh@@pdftex.org>
-% Copyright 2006-2011 Taco Hoekwater <taco@@luatex.org>
-%
-% This file is part of LuaTeX.
-%
-% LuaTeX is free software; you can redistribute it and/or modify it under
-% the terms of the GNU General Public License as published by the Free
-% Software Foundation; either version 2 of the License, or (at your
-% option) any later version.
-%
-% LuaTeX is distributed in the hope that it will be useful, but WITHOUT
-% ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-% FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
-% License for more details.
-%
-% You should have received a copy of the GNU General Public License along
-% with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
-
-@ @c
+/*
+
+writejpg.w
+
+Copyright 1996-2006 Han The Thanh <thanh@pdftex.org>
+Copyright 2006-2011 Taco Hoekwater <taco@luatex.org>
+
+This file is part of LuaTeX.
+
+LuaTeX is free software; you can redistribute it and/or modify it under the terms
+of the GNU General Public License as published by the Free Software Foundation;
+either version 2 of the License, or (at your option) any later version.
+
+LuaTeX is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU General Public License along with
+LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+
+*/
 
 #include "ptexlib.h"
 #include <assert.h>
 #include "image/image.h"
 #include "image/writejpg.h"
 
-@ @c
 #define JPG_GRAY  1  /* Gray color space, use /DeviceGray    */
 #define JPG_RGB   3  /* RGB color space, use /DeviceRGB      */
 #define JPG_CMYK  4  /* CMYK color space, use /DeviceCMYK    */
@@ -97,7 +96,6 @@ typedef enum {
     M_ERROR = 0x100  /* dummy marker, internal use only      */
 } JPEG_MARKER;
 
-@ @c
 static unsigned int read_exif_bytes(unsigned char **p, int n, int b)
 {
     unsigned int rval = 0;
@@ -128,28 +126,31 @@ static unsigned int read_exif_bytes(unsigned char **p, int n, int b)
     return rval;
 }
 
-@ The Exif block can contain the data on the resolution in two forms:
-XResolution, YResolution and ResolutionUnit (tag 282, 283 and 296)
-as well as PixelPerUnitX, PixelPerUnitY and PixelUnit (tag 0x5111,
-0x5112 and 0x5110). Tags 282, 293 and 296 have the priority,
-with ResolutionUnit set to inch by default, then
-tag 0x5110, 0x5111 and 0x5112, where the only valid value for PixelUnit is 0.0254,
-and finally the given value xx and yy,
-choosen if the Exif x and y resolution are not strictly positive.
+/*tex
+
+    The Exif block can contain the data on the resolution in two forms:
+    XResolution, YResolution and ResolutionUnit (tag 282, 283 and 296) as well as
+    PixelPerUnitX, PixelPerUnitY and PixelUnit (tag 0x5111, 0x5112 and 0x5110).
+    Tags 282, 293 and 296 have the priority, with ResolutionUnit set to inch by
+    default, then tag 0x5110, 0x5111 and 0x5112, where the only valid value for
+    PixelUnit is 0.0254, and finally the given value xx and yy, choosen if the
+    Exif x and y resolution are not strictly positive.
 
+    The next one doesn't save the data, just reads the tags we need based on info
+    from \typ {http://www.exif.org/Exif2-2.PDF}.
+
+*/
 
-@ @c
 static void read_APP1_Exif (FILE *fp, unsigned short length, int *xx, int *yy, int *or)
 {
-    /* this doesn't save the data, just reads the tags we need */
-    /* based on info from http://www.exif.org/Exif2-2.PDF */
     unsigned char *buffer = (unsigned char *)xmalloc(length);
     unsigned char *p, *rp;
     unsigned char *tiff_header;
     char bigendian;
     int i;
     int num_fields, tag, type;
-    int value = 0;/* silence uninitialized warnings */
+    /*tex silence uninitialized warnings */
+    int value = 0;
     unsigned int num = 0;
     unsigned int den = 0;
     boolean found_x = false;
@@ -165,7 +166,6 @@ static void read_APP1_Exif (FILE *fp, unsigned short length, int *xx, int *yy, i
     boolean found_x_ms = false;
     boolean found_y_ms = false;
     boolean found_res= false;
-
     int orientation = 1;
     size_t ret_len;
     ret_len = fread(buffer, length, 1, fp);
@@ -193,52 +193,65 @@ static void read_APP1_Exif (FILE *fp, unsigned short length, int *xx, int *yy, i
         type = read_exif_bytes(&p, 2, bigendian);
         read_exif_bytes(&p, 4, bigendian);
         switch (type) {
-            case 1: /* byte */
+            case 1:
+                /*tex byte */
                 value = *p++;
                 p += 3;
                 break;
-            case 3: /* unsigned short */
-            case 8: /* signed short */
+            case 3:
+                /*tex unsigned short */
+            case 8:
+                /*tex signed short */
                 value = read_exif_bytes(&p, 2, bigendian);
                 p += 2;
                 break;
-            case 4: /* unsigned long */
-            case 9: /* signed long */
+            case 4:
+                /*tex unsigned long */
+            case 9:
+                /*tex signed long */
                 value = read_exif_bytes(&p, 4, bigendian);
                 break;
-            case 5: /* rational */
-            case 10: /* srational */
+            case 5:
+                /*tex rational */
+            case 10:
+                /*tex srational */
                 value = read_exif_bytes(&p, 4, bigendian);
                 rp = tiff_header + value;
                 num = read_exif_bytes(&rp, 4, bigendian);
                 den = read_exif_bytes(&rp, 4, bigendian);
                 break;
-            case 7: /* undefined */
+            case 7:
+                /*tex undefined */
                 value = *p++;
                 p += 3;
                 break;
-            case 2: /* ascii */
+            case 2:
+                /*tex ascii */
             default:
                 p += 4;
                 break;
         }
         switch (tag) {
-            case 274: /* orientation */
+            case 274:
+                /*tex orientation */
                 orientation = value;
                 break;
-            case 282: /* x res */
+            case 282:
+                /*tex x res */
                 if (den != 0) {
                     xres = num / den;
                     found_x = true;
-		}
+                }
                 break;
-            case 283: /* y res */
+            case 283:
+                /*tex y res */
                 if (den != 0) {
                     yres = num / den;
                     found_y = true ;
-		}
+                }
                 break;
-            case 296: /* res unit */
+            case 296:
+                /*tex res unit */
                 switch (value) {
                     case 2:
                         res_unit = 1.0;
@@ -250,69 +263,69 @@ static void read_APP1_Exif (FILE *fp, unsigned short length, int *xx, int *yy, i
                         res_unit = 0;
                         break;
                 }
-	   case 0x5110: /* PixelUnit */
-	        switch (value) {
+                break;
+            case 0x5110:
+                /*tex PixelUnit */
+                switch (value) {
                     case 1:
-		        res_unit_ms = 0.0254; /* Unit is meter */
-			break;
-		    default:
-  		        res_unit_ms = 0;
-		}
-	   case 0x5111: /* PixelPerUnitX */
+                        res_unit_ms = 0.0254; /* Unit is meter */
+                        break;
+                    default:
+                        res_unit_ms = 0;
+                }
+                break;
+           case 0x5111:
+               /*tex PixelPerUnitX */
                 found_x_ms = true ;
-	   	xres_ms = value;
-		break;
-	   case 0x5112: /* PixelPerUnitY */
+                xres_ms = value;
+                break;
+           case 0x5112:
+               /*tex PixelPerUnitY */
                 found_y_ms = true ;
-		yres_ms = value ;
-		break;
-           }
-
-
+                yres_ms = value ;
+                break;
+        }
     }
     if (found_x && found_y && res_unit>0) {
-     found_res = true;
-     tempx = (int)(xres * res_unit+0.5);
-     tempy = (int)(yres * res_unit+0.5);
+        found_res = true;
+        tempx = (int)(xres * res_unit+0.5);
+        tempy = (int)(yres * res_unit+0.5);
     } else if (found_x_ms && found_y_ms && res_unit_ms==0.0254) {
-     found_res = true;
-     tempx = (int)(xres_ms * res_unit_ms+0.5);
-     tempy = (int)(yres_ms * res_unit_ms+0.5);
+        found_res = true;
+        tempx = (int)(xres_ms * res_unit_ms+0.5);
+        tempy = (int)(yres_ms * res_unit_ms+0.5);
     }
     if (found_res) {
-      if (tempx>0 && tempy>0) {
-       if ((tempx!=(*xx) || tempy!=(*yy)) && (*xx!=0 && (*yy!=0) )  ) {
-        formatted_warning("readjpg","Exif resolution  %ddpi x %ddpi differs from the input resolution %ddpi x %ddpi",tempx,tempy,*xx,*yy);
-       }
-       if (tempx==1 || tempy==1) {
-        formatted_warning("readjpg","Exif resolution %ddpi x %ddpi looks weird", tempx, tempy);
-       }
-       *xx = tempx;
-       *yy = tempy;
-     }else {
-       formatted_warning("readjpg","Bad Exif resolution  %ddpi x %ddpi (zero or negative value of a signed integer)",tempx,tempy);
-     }
+        if (tempx>0 && tempy>0) {
+            if ((tempx!=(*xx) || tempy!=(*yy)) && (*xx!=0 && (*yy!=0) )  ) {
+                formatted_warning("readjpg","Exif resolution %ddpi x %ddpi differs from the input resolution %ddpi x %ddpi",tempx,tempy,*xx,*yy);
+            }
+            if (tempx==1 || tempy==1) {
+                formatted_warning("readjpg","Exif resolution %ddpi x %ddpi looks weird", tempx, tempy);
+            }
+            *xx = tempx;
+            *yy = tempy;
+        } else {
+            formatted_warning("readjpg","Bad Exif resolution %ddpi x %ddpi (zero or negative value of a signed integer)",tempx,tempy);
+        }
     }
-
     *or = orientation;
-
 err:
     free(buffer);
     return;
 }
 
-/*
+/*tex
 
-    Contrary to pdf where several parallel usage can happen (epdf, tex, lua) with
-    bitmaps we care less about keeping files open. So, we can keep files open in
-    the img lib but then they are closed after inclusion anyway.
+    Contrary to \PDF\ where several parallel usage can happen (\PDF, |TEX, \LUA)
+    with bitmaps we care less about keeping files open. So, we can keep files
+    open in the img lib but then they are closed after inclusion anyway.
 
 */
 
-@ @c
 static void close_and_cleanup_jpg(image_dict * idict)
 {
-    /* if one of then is not NULL we already cleaned up */
+    /*tex if one of then is not NULL we already cleaned up */
     if (img_file(idict) != NULL) {
         xfclose(img_file(idict), img_filepath(idict));
         img_file(idict) = NULL;
@@ -322,19 +335,21 @@ static void close_and_cleanup_jpg(image_dict * idict)
     }
 }
 
-@ @c
 void flush_jpg_info(image_dict * idict)
 {
     close_and_cleanup_jpg(idict);
 }
 
-@ The jpeg images are scanned for resolution, colorspace, depth, dimensions and
-orientation. We need to look at the exif blob for that. The original version did
-a quick test for jfif and exif but there can be more blobs later on. The current
-approach is to run over the linked list of blobs which is somewhat less efficient
-but not noticeable.
+/*tex
+
+    The jpeg images are scanned for resolution, colorspace, depth, dimensions and
+    orientation. We need to look at the exif blob for that. The original version
+    did a quick test for jfif and exif but there can be more blobs later on. The
+    current approach is to run over the linked list of blobs which is somewhat
+    less efficient but not noticeable.
+
+*/
 
-@ @c
 void read_jpg_info(image_dict * idict)
 {
     int i, position, units = 0;
@@ -381,16 +396,20 @@ void read_jpg_info(image_dict * idict)
         position = ftell(fp);
         length = 0 ;
         switch (i) {
-            case M_SOF3:  /* lossless */
+            case M_SOF3:
+                /*tex lossless */
             case M_SOF5:
             case M_SOF6:
-            case M_SOF7:  /* lossless */
+            case M_SOF7:
+                /*tex lossless */
             case M_SOF9:
             case M_SOF10:
-            case M_SOF11: /* lossless */
+            case M_SOF11:
+                /*tex lossless */
             case M_SOF13:
             case M_SOF14:
-            case M_SOF15: /* lossless */
+            case M_SOF15:
+                /*tex lossless */
                 formatted_error("readjpg","unsupported compression SOF_%d", i - M_SOF0);
                 break;
             case M_SOF2:
@@ -399,7 +418,8 @@ void read_jpg_info(image_dict * idict)
                 }
             case M_SOF0:
             case M_SOF1:
-                length = (int) read2bytes(fp); /* read segment length  */
+                /*tex read segment length  */
+                length = (int) read2bytes(fp);
                 img_colordepth(idict) = xgetc(fp);
                 img_ysize(idict) = (int) read2bytes(fp);
                 img_xsize(idict) = (int) read2bytes(fp);
@@ -427,19 +447,20 @@ void read_jpg_info(image_dict * idict)
                         if (fread(app_sig, sizeof(char), 5, fp) != 5)
                             return;
                         if (!memcmp(app_sig, "JFIF\000", 5)) {
-                            units = (int) read2bytes(fp);    /*skip two bytes, compiler is also happy*/
+                            /*tex skip two bytes, compiler is also happy*/
+                            units = (int) read2bytes(fp);
                             units = xgetc(fp);
                             img_xres(idict) = (int) read2bytes(fp);
                             img_yres(idict) = (int) read2bytes(fp);
                             switch (units) {
                                 case 1:
-                                    /* pixels per inch */
+                                    /*tex pixels per inch */
                                     if ((img_xres(idict) == 1) || (img_yres(idict) == 1)) {
                                         formatted_warning("readjpg","unusual resolution of %ddpi by %ddpi", img_xres(idict), img_yres(idict));
                                     }
                                     break;
                                 case 2:
-                                    /* pixels per cm */
+                                    /*tex pixels per cm */
                                     img_xres(idict) = (int) ((double) img_xres(idict) * 2.54);
                                     img_yres(idict) = (int) ((double) img_yres(idict) * 2.54);
                                     break;
@@ -448,7 +469,10 @@ void read_jpg_info(image_dict * idict)
                                     break;
                                 }
                             }
-                        /* if either xres or yres is 0 but the other isn't, set it to the value of the other */
+                        /*tex
+                            If either xres or yres is 0 but the other isn't, set
+                            it to the value of the other.
+                        */
                     }
                 }
                 break;
@@ -471,7 +495,7 @@ void read_jpg_info(image_dict * idict)
                     }
                 }
                 break;
-            /* ignore markers without parameters */
+            /*tex ignore markers without parameters */
             case M_SOI:
             case M_EOI:
             case M_TEM:
@@ -485,23 +509,18 @@ void read_jpg_info(image_dict * idict)
             case M_RST7:
                 break;
             default:
-                /* skip variable length markers */
+                /*tex skip variable length markers */
                 length = (int) read2bytes(fp);
                 break;
         }
-        /*
-            printf("marker %X : %i %i\n",i,position,length);
-        */
         if (length > 0) {
             xfseek(fp, position + length, SEEK_SET, img_filepath(idict));
         }
     }
-    /* moved */
     xfseek(fp, 0, SEEK_SET, img_filepath(idict));
     if (! img_keepopen(idict)) {
         close_and_cleanup_jpg(idict);
     }
-    /* */
     if (okay){
         if ((img_xres(idict) == 0) && (img_yres(idict) != 0)) {
             img_xres(idict) = img_yres(idict);
@@ -514,14 +533,13 @@ void read_jpg_info(image_dict * idict)
     }
 }
 
-@ @c
 static void reopen_jpg(image_dict * idict)
 {
     int width = img_xsize(idict);
     int height = img_ysize(idict);
     int xres = img_xres(idict);
     int yres = img_yres(idict);
-    /*
+    /*tex
         we need to make sure that the file kept open
     */
     img_keepopen(idict) = 1;
@@ -531,7 +549,6 @@ static void reopen_jpg(image_dict * idict)
     }
 }
 
-@ @c
 void write_jpg(PDF pdf, image_dict * idict)
 {
     size_t l;
@@ -588,6 +605,5 @@ void write_jpg(PDF pdf, image_dict * idict)
     }
     pdf_end_stream(pdf);
     pdf_end_obj(pdf);
-    /* always */
     close_and_cleanup_jpg(idict);
 }
diff --git a/texk/web2c/luatexdir/image/writepng.w b/texk/web2c/luatexdir/image/writepng.c
similarity index 85%
rename from texk/web2c/luatexdir/image/writepng.w
rename to texk/web2c/luatexdir/image/writepng.c
index 412000c42..165e202f4 100644
--- a/texk/web2c/luatexdir/image/writepng.w
+++ b/texk/web2c/luatexdir/image/writepng.c
@@ -1,36 +1,32 @@
-% writepng.w
-%
-% Copyright 1996-2006 Han The Thanh <thanh@@pdftex.org>
-% Copyright 2006-2013 Taco Hoekwater <taco@@luatex.org>
-%
-% This file is part of LuaTeX.
-%
-% LuaTeX is free software; you can redistribute it and/or modify it under
-% the terms of the GNU General Public License as published by the Free
-% Software Foundation; either version 2 of the License, or (at your
-% option) any later version.
-%
-% LuaTeX is distributed in the hope that it will be useful, but WITHOUT
-% ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-% FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
-% License for more details.
-%
-% You should have received a copy of the GNU General Public License along
-% with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
-
-@ @c
+/*
+
+writepng.c
+
+Copyright 1996-2006 Han The Thanh <thanh@pdftex.org>
+Copyright 2006-2013 Taco Hoekwater <taco@luatex.org>
+
+This file is part of LuaTeX.
+
+LuaTeX is free software; you can redistribute it and/or modify it under the terms
+of the GNU General Public License as published by the Free Software Foundation;
+either version 2 of the License, or (at your option) any later version.
+
+LuaTeX is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU General Public License along with
+LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+
+*/
 
 #include "ptexlib.h"
 #include <assert.h>
 #include "image/image.h"
 #include "image/writepng.h"
 
-@ @c
-static int transparent_page_group = -1;
-
 static void close_and_cleanup_png(image_dict * idict)
 {
-    /* if one of then is not NULL we already cleaned up */
     if (img_file(idict) != NULL) {
         xfclose(img_file(idict), img_filepath(idict));
         img_file(idict) = NULL;
@@ -41,16 +37,16 @@ static void close_and_cleanup_png(image_dict * idict)
     }
 }
 
-@ @c
 void flush_png_info(image_dict * idict)
 {
     close_and_cleanup_png(idict);
 }
 
-@ @c
+/*tex A dummy function: */
+
 static void warn(png_structp png_ptr, png_const_charp msg)
 {
-    (void)png_ptr; (void)msg; /* Make compiler happy */
+    (void)png_ptr; (void)msg;
 }
 
 void read_png_info(image_dict * idict)
@@ -80,12 +76,12 @@ void read_png_info(image_dict * idict)
         normal_error("readpng","internal error");
     }
 #if PNG_LIBPNG_VER >= 10603
-    /* ignore possibly incorrect CMF bytes */
+    /*tex ignore possibly incorrect CMF bytes */
     png_set_option(png_p, PNG_MAXIMUM_INFLATE_WINDOW, PNG_OPTION_ON);
 #endif
     png_init_io(png_p, img_file(idict));
     png_read_info(png_p, info_p);
-    /* resolution support */
+    /*tex resolution support */
     img_xsize(idict) = (int) png_get_image_width(png_p, info_p);
     img_ysize(idict) = (int) png_get_image_height(png_p, info_p);
     if (png_get_valid(png_p, info_p, PNG_INFO_pHYs)) {
@@ -108,15 +104,12 @@ void read_png_info(image_dict * idict)
         formatted_error("readpng","unsupported type of color_type '%i'",(int) png_get_color_type(png_p, info_p));
     }
     img_colordepth(idict) = png_get_bit_depth(png_p, info_p);
-    /*
-        So we can optionally keep open a file in img.
-    */
+    /*tex So we can optionally keep open a file in |img|. */
     if (! img_keepopen(idict)) {
         close_and_cleanup_png(idict);
     }
 }
 
-@ @c
 #define write_gray_pixel_16(r)       \
     if (j % 4 == 0 || j % 4 == 1)    \
         pdf_quick_out(pdf, *r++);    \
@@ -173,7 +166,6 @@ void read_png_info(image_dict * idict)
         xfree(rows[i]);                                               \
     }
 
-@ @c
 static void write_palette_streamobj(PDF pdf, int palette_objnum, png_colorp palette, int num_palette)
 {
     int i;
@@ -195,7 +187,6 @@ static void write_palette_streamobj(PDF pdf, int palette_objnum, png_colorp pale
     pdf_end_obj(pdf);
 }
 
-@ @c
 static void write_smask_streamobj(PDF pdf, image_dict * idict, int smask_objnum, png_bytep smask, int smask_size)
 {
     int i;
@@ -227,7 +218,6 @@ static void write_smask_streamobj(PDF pdf, image_dict * idict, int smask_objnum,
     pdf_end_obj(pdf);
 }
 
-@ @c
 static void write_png_gray(PDF pdf, image_dict * idict)
 {
     int i;
@@ -258,7 +248,6 @@ static void write_png_gray(PDF pdf, image_dict * idict)
     pdf_end_obj(pdf);
 }
 
-@ @c
 static void write_png_gray_alpha(PDF pdf, image_dict * idict)
 {
     int i;
@@ -307,7 +296,6 @@ static void write_png_gray_alpha(PDF pdf, image_dict * idict)
     xfree(smask);
 }
 
-@ @c
 static void write_png_rgb_alpha(PDF pdf, image_dict * idict)
 {
     int i;
@@ -356,20 +344,21 @@ static void write_png_rgb_alpha(PDF pdf, image_dict * idict)
     xfree(smask);
 }
 
-@ The |copy_png| code is cheerfully gleaned from Thomas Merz' PDFlib,
-file |p_png.c| ``SPNG - Simple PNG''.
-The goal is to use pdf's native FlateDecode support, if that is possible.
-Only a subset of the png files allows this, but for these it greatly
-improves inclusion speed.
+/*tex
 
-In the ``PNG Copy'' mode only the IDAT chunks are copied;
-all other chunks from the PNG file are discarded.
-If there are any other chunks in the PNG file,
-which might influence the visual appearance of the image,
-or if image processing like gamma change is requested,
-the ``PNG Copy'' function must be skipped; therefore the lengthy tests.
+The |copy_png| code is cheerfully gleaned from Thomas Merz' PDFlib, file
+|p_png.c| ``SPNG - Simple PNG''. The goal is to use pdf's native FlateDecode
+support, if that is possible. Only a subset of the png files allows this, but for
+these it greatly improves inclusion speed.
+
+In the ``PNG Copy'' mode only the IDAT chunks are copied; all other chunks from
+the PNG file are discarded. If there are any other chunks in the PNG file, which
+might influence the visual appearance of the image, or if image processing like
+gamma change is requested, the ``PNG Copy'' function must be skipped; therefore
+the lengthy tests.
+
+*/
 
-@c
 static int spng_getint(FILE * f)
 {
     unsigned char buf[4];
@@ -394,7 +383,7 @@ static void copy_png(PDF pdf, image_dict * idict)
     png_p = img_png_png_ptr(idict);
     info_p = img_png_info_ptr(idict);
     f = (FILE *) png_get_io_ptr(png_p);
-    /* 1st pass to find overall stream /Length */
+    /*tex 1st pass to find overall stream /Length */
     if (fseek(f, 8, SEEK_SET) != 0)
         normal_error("writepng", "fseek in file failed");
     do {
@@ -423,8 +412,7 @@ static void copy_png(PDF pdf, image_dict * idict)
     pdf_end_dict(pdf);
     pdf_end_dict(pdf);
     pdf_begin_stream(pdf);
-    assert(pdf->zip_write_state == NO_ZIP); /* the PNG stream is already compressed */
-    /* 2nd pass to copy data */
+    /*tex 2nd pass to copy data */
     endflag = false;
     if (fseek(f, 8, SEEK_SET) != 0)
         normal_error("writepng", "fseek in file failed");
@@ -433,7 +421,7 @@ static void copy_png(PDF pdf, image_dict * idict)
         type = spng_getint(f);
         switch (type) {
         case SPNG_CHUNK_IDAT:
-            /* do copy */
+            /*tex do copy */
             if (idat == 2) {
                 normal_error("writepng", "IDAT chunk sequence broken");
             }
@@ -445,7 +433,7 @@ static void copy_png(PDF pdf, image_dict * idict)
             }
             break;
         case SPNG_CHUNK_IEND:
-            /* done */
+            /*tex done */
             endflag = true;
             break;
         default:
@@ -459,17 +447,15 @@ static void copy_png(PDF pdf, image_dict * idict)
     pdf_end_obj(pdf);
 }
 
-@ @c
 static void reopen_png(image_dict * idict)
 {
     int width, height, xres, yres;
-    width = img_xsize(idict);   /* do consistency check */
+    /*tex A consistency check: */
+    width = img_xsize(idict);
     height = img_ysize(idict);
     xres = img_xres(idict);
     yres = img_yres(idict);
-    /*
-        we need to ake sure that the file kept open
-    */
+    /*tex We need to ake sure that the file kept open. */
     img_keepopen(idict) = 1;
     read_png_info(idict);
     if (width != img_xsize(idict) || height != img_ysize(idict) || xres != img_xres(idict) || yres != img_yres(idict)) {
@@ -477,13 +463,10 @@ static void reopen_png(image_dict * idict)
     }
 }
 
-@ @c
-static boolean last_png_needs_page_group;
-
 void write_png(PDF pdf, image_dict * idict)
 {
 #ifndef PNG_FP_1
-    /* for libpng < 1.5.0 */
+    /*tex for libpng < 1.5.0 */
 #  define PNG_FP_1    100000
 #endif
     int num_palette, palette_objnum = 0;
@@ -494,31 +477,30 @@ void write_png(PDF pdf, image_dict * idict)
     png_infop info_p;
     png_colorp palette;
     assert(idict != NULL);
-    last_png_needs_page_group = false;
     if (img_file(idict) == NULL)
         reopen_png(idict);
     assert(img_png_ptr(idict) != NULL);
     png_p = img_png_png_ptr(idict);
     info_p = img_png_info_ptr(idict);
-    /* simple transparency support */
+    /*tex simple transparency support */
     if (png_get_valid(png_p, info_p, PNG_INFO_tRNS)) {
         png_set_tRNS_to_alpha(png_p);
         png_copy = false;
     }
-    /* alpha channel support */
+    /*tex alpha channel support */
     if (pdf->minor_version < 4
         && png_get_color_type(png_p, info_p) | PNG_COLOR_MASK_ALPHA) {
         png_set_strip_alpha(png_p);
         png_copy = false;
     }
-    /* 16 bit depth support */
+    /*tex 16 bit depth support */
     if (pdf->minor_version < 5)
         pdf->image_hicolor = 0;
     if ((png_get_bit_depth(png_p, info_p) == 16) && (pdf->image_hicolor == 0)) {
         png_set_strip_16(png_p);
         png_copy = false;
     }
-    /* gamma support */
+    /*tex gamma support */
     if (png_get_valid(png_p, info_p, PNG_INFO_gAMA)) {
         png_get_gAMA(png_p, info_p, &gamma);
         png_get_gAMA_fixed(png_p, info_p, &int_file_gamma);
@@ -527,11 +509,10 @@ void write_png(PDF pdf, image_dict * idict)
         if (png_get_valid(png_p, info_p, PNG_INFO_gAMA))
             png_set_gamma(png_p, (pdf->gamma / 1000.0), gamma);
         else
-            png_set_gamma(png_p, (pdf->gamma / 1000.0),
-                          (1000.0 / pdf->image_gamma));
+            png_set_gamma(png_p, (pdf->gamma / 1000.0), (1000.0 / pdf->image_gamma));
         png_copy = false;
     }
-    /* reset structure */
+    /*tex reset structure */
     (void) png_set_interlace_handling(png_p);
     png_read_update_info(png_p, info_p);
     pdf_begin_obj(pdf, img_objnum(idict), OBJSTM_NEVER);
@@ -555,9 +536,11 @@ void write_png(PDF pdf, image_dict * idict)
                 pdf_add_name(pdf, "ColorSpace");
                 pdf_begin_array(pdf);
                 pdf_add_name(pdf, "Indexed");
-                pdf_add_name(pdf, "DeviceRGB");     /* base; PDFRef. 4.5.5 */
-                pdf_add_int(pdf, (int) (num_palette - 1));  /* hival */
-                pdf_add_ref(pdf, (int) palette_objnum);     /* lookup */
+                pdf_add_name(pdf, "DeviceRGB");
+                /*tex hival */
+                pdf_add_int(pdf, (int) (num_palette - 1));
+                /*tex lookup */
+                pdf_add_ref(pdf, (int) palette_objnum);
                 pdf_end_array(pdf);
                 break;
             case PNG_COLOR_TYPE_GRAY:
@@ -629,14 +612,12 @@ void write_png(PDF pdf, image_dict * idict)
             case PNG_COLOR_TYPE_GRAY_ALPHA:
                 if (pdf->minor_version >= 4) {
                     write_png_gray_alpha(pdf, idict);
-                    last_png_needs_page_group = true;
                 } else
                     write_png_gray(pdf, idict);
                 break;
             case PNG_COLOR_TYPE_RGB_ALPHA:
                 if (pdf->minor_version >= 4) {
                     write_png_rgb_alpha(pdf, idict);
-                    last_png_needs_page_group = true;
                 } else
                     write_png_gray(pdf, idict);
                 break;
@@ -645,42 +626,20 @@ void write_png(PDF pdf, image_dict * idict)
         }
     }
     write_palette_streamobj(pdf, palette_objnum, palette, num_palette);
-    /* always */
+    /*tex always */
     close_and_cleanup_png(idict);
 }
 
-@ @c
-static boolean transparent_page_group_was_written = false;
 
-@ Called after the xobject generated by |write_png| has been finished; used to
-write out additional objects
+/*tex
+
+    Called after the xobject generated by |write_png| has been finished; used to
+    write out additional objects.
+
+*/
 
-@c
 void write_additional_png_objects(PDF pdf)
 {
     (void) pdf;
-    (void) transparent_page_group;
-    (void) transparent_page_group_was_written;
     return;
-    /* this interferes with current macro-based usage and cannot be configured */
-#if 0
-    if (last_png_needs_page_group) {
-        if (!transparent_page_group_was_written && transparent_page_group > 1) {
-            /* create new group object */
-            transparent_page_group_was_written = true;
-            pdf_begin_obj(pdf, transparent_page_group, 2);
-            if (pdf->compress_level == 0) {
-                pdf_puts(pdf, "%PTEX Group needed for transparent pngs\n");
-            }
-            pdf_begin_dict(pdf);
-            pdf_dict_add_name(pdf, "Type", "Group");
-            pdf_dict_add_name(pdf, "S", "Transparency");
-            pdf_dict_add_name(pdf, "CS", "DeviceRGB");
-            pdf_dict_add_bool(pdf, "I", 1);
-            pdf_dict_add_bool(pdf, "K", 1);
-            pdf_end_dict(pdf);
-            pdf_end_obj(pdf);
-        }
-    }
-#endif
 }
diff --git a/texk/web2c/luatexdir/lang/hnjalloc.c b/texk/web2c/luatexdir/lang/hnjalloc.c
new file mode 100644
index 000000000..3ebeee9e4
--- /dev/null
+++ b/texk/web2c/luatexdir/lang/hnjalloc.c
@@ -0,0 +1,65 @@
+/*
+
+hnjalloc.w
+
+LibHnj is dual licensed under LGPL and MPL. Boilerplate for both licenses
+follows.
+
+LibHnj - a library for high quality hyphenation and justification Copyright (C)
+1998 Raph Levien, (C) 2001 ALTLinux, Moscow
+
+This library is free software; you can redistribute it and/or modify it under the
+terms of the GNU Library General Public License as published by the Free Software
+Foundation; either version 2 of the License, or (at your option) any later
+version.
+
+This library is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+PARTICULAR PURPOSE. See the GNU Library General Public License for more details.
+
+You should have received a copy of the GNU Library General Public License along
+with this library; if not, write to the Free Software Foundation, Inc., 59 Temple
+Place - Suite 330, Boston, MA 02111-1307 USA.
+
+The contents of this file are subject to the Mozilla Public License Version 1.0
+(the "MPL"); you may not use this file except in compliance with the MPL. You may
+obtain a copy of the MPL at http://www.mozilla.org/MPL/
+
+Software distributed under the MPL is distributed on an "AS IS" basis, WITHOUT
+WARRANTY OF ANY KIND, either express or implied. See the MPL for the specific
+language governing rights and limitations under the MPL.
+
+*/
+
+/*tex The wrappers for malloc */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include "lang/hnjalloc.h"
+
+void *hnj_malloc(int size)
+{
+    void *p;
+
+    p = malloc((size_t) size);
+    if (p == NULL) {
+        fprintf(stderr, "can't allocate %d bytes\n", size);
+        exit(1);
+    }
+    return p;
+}
+
+void *hnj_realloc(void *p, int size)
+{
+    p = realloc(p, (size_t) size);
+    if (p == NULL) {
+        fprintf(stderr, "can't allocate %d bytes\n", size);
+        exit(1);
+    }
+    return p;
+}
+
+void hnj_free(void *p)
+{
+    free(p);
+}
diff --git a/texk/web2c/luatexdir/lang/hnjalloc.w b/texk/web2c/luatexdir/lang/hnjalloc.w
deleted file mode 100644
index 91fefec9e..000000000
--- a/texk/web2c/luatexdir/lang/hnjalloc.w
+++ /dev/null
@@ -1,69 +0,0 @@
-% hnjalloc.w
-%
-% LibHnj is dual licensed under LGPL and MPL. Boilerplate for both
-% licenses follows.
-%
-%
-% LibHnj - a library for high quality hyphenation and justification
-% Copyright (C) 1998 Raph Levien, (C) 2001 ALTLinux, Moscow
-%
-% This library is free software; you can redistribute it and/or
-% modify it under the terms of the GNU Library General Public
-% License as published by the Free Software Foundation; either
-% version 2 of the License, or (at your option) any later version.
-%
-% This library is distributed in the hope that it will be useful,
-% but WITHOUT ANY WARRANTY; without even the implied warranty of
-% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-% Library General Public License for more details.
-%
-% You should have received a copy of the GNU Library General Public
-% License along with this library; if not, write to the
-% Free Software Foundation, Inc., 59 Temple Place - Suite 330,
-% Boston, MA  02111-1307  USA.
-%
-%
-%
-% The contents of this file are subject to the Mozilla Public License
-% Version 1.0 (the "MPL"); you may not use this file except in
-% compliance with the MPL.  You may obtain a copy of the MPL at
-% http://www.mozilla.org/MPL/
-%
-% Software distributed under the MPL is distributed on an "AS IS" basis,
-% WITHOUT WARRANTY OF ANY KIND, either express or implied. See the MPL
-% for the specific language governing rights and limitations under the
-% MPL.
-
-@ wrappers for malloc
-@c
-
-#include <stdlib.h>
-#include <stdio.h>
-#include "lang/hnjalloc.h"
-
-void *hnj_malloc(int size)
-{
-    void *p;
-
-    p = malloc((size_t) size);
-    if (p == NULL) {
-        fprintf(stderr, "can't allocate %d bytes\n", size);
-        exit(1);
-    }
-    return p;
-}
-
-void *hnj_realloc(void *p, int size)
-{
-    p = realloc(p, (size_t) size);
-    if (p == NULL) {
-        fprintf(stderr, "can't allocate %d bytes\n", size);
-        exit(1);
-    }
-    return p;
-}
-
-void hnj_free(void *p)
-{
-    free(p);
-}
diff --git a/texk/web2c/luatexdir/lang/hyphen.w b/texk/web2c/luatexdir/lang/hyphen.c
similarity index 61%
rename from texk/web2c/luatexdir/lang/hyphen.w
rename to texk/web2c/luatexdir/lang/hyphen.c
index 35befb743..3a96f195b 100644
--- a/texk/web2c/luatexdir/lang/hyphen.w
+++ b/texk/web2c/luatexdir/lang/hyphen.c
@@ -1,57 +1,51 @@
-% hyphen.w
-%
-% Libhnj is dual licensed under LGPL and MPL. Boilerplate for both
-% licenses follows.
-%
-%
-% LibHnj - a library for high quality hyphenation and justification
-% Copyright (C) 1998 Raph Levien,
-% 	     (C) 2001 ALTLinux, Moscow (http://www.alt-linux.org),
-%           (C) 2001 Peter Novodvorsky (nidd@@cs.msu.su)
-%
-% This library is free software; you can redistribute it and/or
-% modify it under the terms of the GNU Library General Public
-% License as published by the Free Software Foundation; either
-% version 2 of the License, or (at your option) any later version.
-%
-% This library is distributed in the hope that it will be useful,
-% but WITHOUT ANY WARRANTY; without even the implied warranty of
-% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-% Library General Public License for more details.
-%
-% You should have received a copy of the GNU Library General Public
-% License along with this library; if not, write to the
-% Free Software Foundation, Inc., 59 Temple Place - Suite 330,
-% Boston, MA  02111-1307  USA.
-%
-%
-%
-% The contents of this file are subject to the Mozilla Public License
-% Version 1.0 (the "MPL"); you may not use this file except in
-% compliance with the MPL.  You may obtain a copy of the MPL at
-% http://www.mozilla.org/MPL/
-%
-% Software distributed under the MPL is distributed on an "AS IS" basis,
-% WITHOUT WARRANTY OF ANY KIND, either express or implied. See the MPL
-% for the specific language governing rights and limitations under the
-% MPL.
-
-
-@ @c
+/*
 
+hyphen.c
+
+This file is derived from libhnj which is is dual licensed under LGPL and MPL.
+Boilerplate for both licenses follows.
+
+LibHnj - a library for high quality hyphenation and justification
+
+(C) 1998 Raph Levien,
+(C) 2001 ALTLinux, Moscow (http://www.alt-linux.org),
+(C) 2001 Peter Novodvorsky (nidd@cs.msu.su)
+
+This library is free software; you can redistribute it and/or modify it under the
+terms of the GNU Library General Public License as published by the Free Software
+Foundation; either version 2 of the License, or (at your option) any later
+version.
+
+This library is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+PARTICULAR PURPOSE. See the GNU Library General Public License for more details.
+
+You should have received a copy of the GNU Library General Public License along
+with this library; if not, write to the Free Software Foundation, Inc., 59 Temple
+Place - Suite 330, Boston, MA 02111-1307 USA.
+
+The contents of this file are subject to the Mozilla Public License Version 1.0
+(the "MPL"); you may not use this file except in compliance with the MPL. You may
+obtain a copy of the MPL at http://www.mozilla.org/MPL/
+
+Software distributed under the MPL is distributed on an "AS IS" basis, WITHOUT
+WARRANTY OF ANY KIND, either express or implied. See the MPL for the specific
+language governing rights and limitations under the MPL.
+
+*/
 
 #include "ptexlib.h"
 #include "lua/luatex-api.h"
 
-#include <stdlib.h>             /* for NULL, malloc */
-#include <stdio.h>              /* for fprintf */
-#include <string.h>             /* for strdup */
-#include <stdlib.h>             /* for malloc used by substring inclusion */
+#include <stdlib.h>   /* for NULL, malloc */
+#include <stdio.h>    /* for fprintf */
+#include <string.h>   /* for strdup */
+#include <stdlib.h>   /* for malloc used by substring inclusion */
 
 #define MAXPATHS 40960
 
 #ifdef UNX
-#  include <unistd.h>           /* for exit */
+#  include <unistd.h> /* for exit */
 #endif
 
 #include <kpathsea/c-ctype.h>
@@ -60,9 +54,8 @@
 
 #include "lang/hnjalloc.h"
 
-@ TODO: should be moved to separate library
+/*tex This could be moved to separate library. */
 
-@c
 static unsigned char *hnj_strdup(const unsigned char *s)
 {
     unsigned char *new;
@@ -75,18 +68,20 @@ static unsigned char *hnj_strdup(const unsigned char *s)
     return new;
 }
 
-@* Type definitions.
+/*tex
 
-@ a little bit of a hash table implementation. This simply maps strings
-   to state numbers
+    First some type definitions and a little bit of a hash table implementation.
+    This simply maps strings to state numbers
 
-@c
-typedef struct _HashTab HashTab;
+*/
+
+typedef struct _HashTab   HashTab;
 typedef struct _HashEntry HashEntry;
-typedef struct _HashIter HashIter;
-typedef union _HashVal HashVal;
+typedef struct _HashIter  HashIter;
+typedef union  _HashVal   HashVal;
+
+/*tex A cheap, but effective, hack. */
 
-/* A cheap, but effective, hack. */
 #define HASH_SIZE 31627
 
 struct _HashTab {
@@ -110,13 +105,13 @@ struct _HashIter {
     int ndx;
 };
 
-@ State machine
+/* The state state machine. */
 
-@c
 typedef struct _HyphenState HyphenState;
 typedef struct _HyphenTrans HyphenTrans;
+
 #define MAX_CHARS 256
-#define MAX_NAME 20
+#define MAX_NAME   20
 
 struct _HyphenDict {
     int num_states;
@@ -130,9 +125,14 @@ struct _HyphenDict {
 
 struct _HyphenState {
     char *match;
-    /*char *repl; */
-    /*signed char replindex; */
-    /*signed char replcut; */
+    /*tex Removed:
+
+        \starttyping
+        char *repl;
+        signed char replindex;
+        signed char replcut;
+        \stoptyping
+    */
     int fallback_state;
     int num_trans;
     HyphenTrans *trans;
@@ -143,20 +143,21 @@ struct _HyphenTrans {
     int new_state;
 };
 
+/*tex
+
+    Combine two right-aligned number patterns, 04000 + 020 becomes 04020. This
+    works also for utf8 sequences because the substring is identical to the last
+    substring-length bytes of expr except for the (single byte) hyphenation
+    encoders
 
-@ Combine two right-aligned number patterns, 04000 + 020 becomes 04020
+*/
 
-@c
 static char *combine(char *expr, const char *subexpr)
 {
     size_t l1 = strlen(expr);
     size_t l2 = strlen(subexpr);
     size_t off = l1 - l2;
     unsigned j;
-    /* this works also for utf8 sequences because the substring is identical
-     to the last substring-length bytes of expr except for the (single byte)
-     hyphenation encoders
-     */
     for (j = 0; j < l2; j++) {
         if (expr[off + j] < subexpr[j])
             expr[off + j] = subexpr[j];
@@ -164,9 +165,8 @@ static char *combine(char *expr, const char *subexpr)
     return expr;
 }
 
+/*tex Some original code: */
 
-@ ORIGINAL CODE
-@c
 static HashIter *new_HashIter(HashTab * h)
 {
     HashIter *i = hnj_malloc(sizeof(HashIter));
@@ -176,7 +176,6 @@ static HashIter *new_HashIter(HashTab * h)
     return i;
 }
 
-
 static int nextHashStealPattern(HashIter * i, unsigned char **word, char **pattern)
 {
     while (i->cur == NULL) {
@@ -204,7 +203,6 @@ static int nextHash(HashIter * i, unsigned char **word)
     return 1;
 }
 
-
 static int eachHash(HashIter * i, unsigned char **word, char **pattern)
 {
     while (i->cur == NULL) {
@@ -218,16 +216,17 @@ static int eachHash(HashIter * i, unsigned char **word, char **pattern)
     return 1;
 }
 
-
 static void delete_HashIter(HashIter * i)
 {
     hnj_free(i);
 }
 
+/*tex
 
-@ a |char*| hash function from ASU - adapted from Gtk+
+A |char*| hash function from ASU, adapted from |Gtk+|:
+
+*/
 
-@c
 static unsigned int hnj_string_hash(const unsigned char *s)
 {
     const unsigned char *p;
@@ -240,18 +239,15 @@ static unsigned int hnj_string_hash(const unsigned char *s)
             h = h ^ g;
         }
     }
-    return h /* \% M */ ;
+    return h;
 }
 
+/*tex This assumes that key is not already present! */
 
-@ assumes that key is not already present!
-
-@c
 static void state_insert(HashTab * hashtab, unsigned char *key, int state)
 {
     int i;
     HashEntry *e;
-
     i = (int) (hnj_string_hash(key) % HASH_SIZE);
     e = hnj_malloc(sizeof(HashEntry));
     e->next = hashtab->entries[i];
@@ -260,23 +256,18 @@ static void state_insert(HashTab * hashtab, unsigned char *key, int state)
     hashtab->entries[i] = e;
 }
 
+/*tex This also assumes that key is not already present! */
 
-@ assumes that key is not already present!
-
-@c
 static void hyppat_insert(HashTab * hashtab, unsigned char *key, char *hyppat)
 {
     int i;
     HashEntry *e;
-
     i = (int) (hnj_string_hash(key) % HASH_SIZE);
     for (e = hashtab->entries[i]; e; e = e->next) {
         if (strcmp((char *) e->key, (char *) key) == 0) {
             if (e->u.hyppat) {
-                if (hyppat
-                    && strcmp((char *) e->u.hyppat, (char *) hyppat) != 0) {
-                    print_err("Conflicting pattern ignored");
-                    error();
+                if (hyppat && strcmp((char *) e->u.hyppat, (char *) hyppat) != 0) {
+                    normal_warning("hyphenation","a conflicting pattern has been ignored");
                 }
                 hnj_free(e->u.hyppat);
             }
@@ -292,15 +283,12 @@ static void hyppat_insert(HashTab * hashtab, unsigned char *key, char *hyppat)
     hashtab->entries[i] = e;
 }
 
+/*tex We return |state| if found, otherwise |-1|. */
 
-@ return state if found, otherwise $-1$
-
-@c
 static int state_lookup(HashTab * hashtab, const unsigned char *key)
 {
     int i;
     HashEntry *e;
-
     i = (int) (hnj_string_hash(key) % HASH_SIZE);
     for (e = hashtab->entries[i]; e; e = e->next) {
         if (!strcmp((const char *) key, (const char *) e->key)) {
@@ -310,15 +298,14 @@ static int state_lookup(HashTab * hashtab, const unsigned char *key)
     return -1;
 }
 
+/*tex We return |state| if found, otherwise |-1|. */
 
-@ return state if found, otherwise $-1$
-
-@c
 static char *hyppat_lookup(HashTab * hashtab, const unsigned char *chars, int l)
 {
     int i;
     HashEntry *e;
-    unsigned char key[256];     /* should be ample */
+    /*tex The 256 should be enough. */
+    unsigned char key[256];
     strncpy((char *) key, (const char *) chars, (size_t) l);
     key[l] = 0;
     i = (int) (hnj_string_hash(key) % HASH_SIZE);
@@ -330,24 +317,18 @@ static char *hyppat_lookup(HashTab * hashtab, const unsigned char *chars, int l)
     return NULL;
 }
 
+/*tex Get the state number, allocating a new state if necessary. */
 
-@ Get the state number, allocating a new state if necessary.
-
-@c
-static int hnj_get_state(HyphenDict * dict,
-                         const unsigned char *str, int *state_num)
+static int hnj_get_state(HyphenDict * dict, const unsigned char *str, int *state_num)
 {
     *state_num = state_lookup(dict->state_num, str);
-
     if (*state_num >= 0)
         return *state_num;
-
     state_insert(dict->state_num, hnj_strdup(str), dict->num_states);
-    /* predicate is true if |dict->num_states| is a power of two */
+    /*tex The predicate is true if |dict->num_states| is a power of two: */
     if (!(dict->num_states & (dict->num_states - 1))) {
         dict->states = hnj_realloc(dict->states,
-                                   (int) ((dict->num_states << 1) *
-                                          (int) sizeof(HyphenState)));
+           (int) ((dict->num_states << 1) * (int) sizeof(HyphenState)));
     }
     dict->states[dict->num_states].match = NULL;
     dict->states[dict->num_states].fallback_state = -1;
@@ -356,70 +337,59 @@ static int hnj_get_state(HyphenDict * dict,
     return dict->num_states++;
 }
 
+/*tex
 
-@ Add a transition from state1 to state2 through ch - assumes that the
-   transition does not already exist
+    Add a transition from state1 to state2 through ch - assumes that the
+    transition does not already exist.
+
+*/
 
-@c
 static void hnj_add_trans(HyphenDict * dict, int state1, int state2, int uni_ch)
 {
     int num_trans;
-    /* TH: this test was a bit too strict, it is quite normal for old
-       patterns to have chars in the range 0-31 or 127-159 (inclusive).
-       To ease the transition, let's only disallow NUL for now
-       (this is probably a requirement of the code anyway).
-     */
+    /*
+        TH: this test was a bit too strict, it is quite normal for old patterns
+        to have chars in the range 0-31 or 127-159 (inclusive). To ease the
+        transition, let's only disallow |NUL| for now, which probably is a
+        requirement of the code anyway.
+    */
     if (uni_ch == 0) {
-        char errmsg[256]; /* temp hack ... we will have a formatted error */
-        snprintf(errmsg, 255, "character out of bounds: u%04x", uni_ch);
-        errmsg[255] = '\0';
-        normal_error("hyphenation",errmsg); /* todo */
+        formatted_error("hyphenation","a character is out of bounds: u%04x", uni_ch);
     }
     num_trans = dict->states[state1].num_trans;
     if (num_trans == 0) {
         dict->states[state1].trans = hnj_malloc(sizeof(HyphenTrans));
     } else {
-        /* TH: The old version did
-           } else if (!(num_trans & (num_trans - 1))) {
-             ... hnj_realloc(dict->states[state1].trans,
-                                                 (int) ((num_trans << 1) *
-                                                        sizeof(HyphenTrans)));
-           but that is incredibly nasty when adding patters one-at-a-time.
-           Controlled growth would be nicer than the current +1, but if
-           noone complains, this is good enough ;)
-         */
+        /*
+            TH: The old version did:
+
+            \starttyping
+            } else if (!(num_trans & (num_trans - 1))) {
+                ... =hnj_realloc(dict->states[state1].trans,
+                    (int) ((num_trans << 1) * sizeof(HyphenTrans)));
+            \stoptyping
+
+            but that is incredibly nasty when adding patters one-at-a-time.
+            Controlled growth would be nicer than the current +1, but if no one
+            complains, and no one did in a decade, this is good enough.
+
+        */
         dict->states[state1].trans = hnj_realloc(dict->states[state1].trans,
-                                                 (int) ((num_trans + 1) *
-                                                        sizeof(HyphenTrans)));
+            (int) ((num_trans + 1) * sizeof(HyphenTrans)));
     }
     dict->states[state1].trans[num_trans].uni_ch = uni_ch;
     dict->states[state1].trans[num_trans].new_state = state2;
     dict->states[state1].num_trans++;
 }
 
+/*tex
 
-#ifdef VERBOSE
-
-static unsigned char *get_state_str(int state)
-{
-    int i;
-    HashEntry *e;
-
-    for (i = 0; i < HASH_SIZE; i++)
-        for (e = global->entries[i]; e; e = e->next)
-            if (e->u.state == state)
-                return e->key;
-    return NULL;
-}
-#endif
+    We did change the semantics a bit here: |hnj_hyphen_load| used to operate on
+    a file, but now the argument is a string buffer.
 
+*/
 
-@ I've changed the semantics a bit here: |hnj_hyphen_load| used to
-   operate on a file, but now the argument is a string buffer.
-
-@c
-static const unsigned char *next_pattern(size_t * length,
-                                         const unsigned char **buf)
+static const unsigned char *next_pattern(size_t * length, const unsigned char **buf)
 {
     const unsigned char *here, *rover = *buf;
     while (*rover && isspace(*rover))
@@ -435,25 +405,28 @@ static const unsigned char *next_pattern(size_t * length,
     }
     *length = (size_t) (rover - here);
     *buf = rover;
-    return *length ? here : NULL;       /* zero sensed */
+    /*tex Zero sensed: */
+    return *length ? here : NULL;
 }
 
 static void init_hash(HashTab ** h)
 {
     int i;
-    if (*h)
+    if (*h) {
         return;
+    }
     *h = hnj_malloc(sizeof(HashTab));
-    for (i = 0; i < HASH_SIZE; i++)
+    for (i = 0; i < HASH_SIZE; i++) {
         (*h)->entries[i] = NULL;
+    }
 }
 
-
 static void clear_state_hash(HashTab ** h)
 {
     int i;
-    if (*h == NULL)
+    if (*h == NULL) {
         return;
+    }
     for (i = 0; i < HASH_SIZE; i++) {
         HashEntry *e, *next;
         for (e = (*h)->entries[i]; e; e = next) {
@@ -466,19 +439,20 @@ static void clear_state_hash(HashTab ** h)
     *h = NULL;
 }
 
-
 static void clear_hyppat_hash(HashTab ** h)
 {
     int i;
-    if (*h == NULL)
+    if (*h == NULL) {
         return;
+    }
     for (i = 0; i < HASH_SIZE; i++) {
         HashEntry *e, *next;
         for (e = (*h)->entries[i]; e; e = next) {
             next = e->next;
             hnj_free(e->key);
-            if (e->u.hyppat)
+            if (e->u.hyppat) {
                 hnj_free(e->u.hyppat);
+            }
             hnj_free(e);
         }
     }
@@ -486,7 +460,6 @@ static void clear_hyppat_hash(HashTab ** h)
     *h = NULL;
 }
 
-
 static void init_dict(HyphenDict * dict)
 {
     dict->num_states = 1;
@@ -502,7 +475,6 @@ static void init_dict(HyphenDict * dict)
     init_hash(&dict->patterns);
 }
 
-
 static void clear_dict(HyphenDict * dict)
 {
     int state_num;
@@ -519,8 +491,6 @@ static void clear_dict(HyphenDict * dict)
     clear_state_hash(&dict->state_num);
 }
 
-
-
 HyphenDict *hnj_hyphen_new(void)
 {
     HyphenDict *dict = hnj_malloc(sizeof(HyphenDict));
@@ -528,14 +498,12 @@ HyphenDict *hnj_hyphen_new(void)
     return dict;
 }
 
-
 void hnj_hyphen_clear(HyphenDict * dict)
 {
     clear_dict(dict);
     init_dict(dict);
 }
 
-
 void hnj_hyphen_free(HyphenDict * dict)
 {
     clear_dict(dict);
@@ -568,29 +536,30 @@ unsigned char *hnj_serialize(HyphenDict * dict)
     return buf;
 }
 
-
 void hnj_free_serialize(unsigned char *c)
 {
     hnj_free(c);
 }
 
+/*tex
 
-@ hyphenation pattern:
-
-signed bytes
-
-0 indicates end (actually any negative number)
+    In hyphenation patterns we use signed bytes where |0|, or actually any
+    negative number, indicates end:
 
-: prio(1+),startpos,length,len1,[replace],len2,[replace]
+    \starttyping
+    prio(1+),startpos,length,len1,[replace],len2,[replace]
+    \starttyping
 
-most basic example is:
+    A basic example is:
 
-p n 0 0 0
+    \starttyping
+    p n 0 0 0
+    \starttyping
 
-for a hyphenation point between characters
+    for a hyphenation point between characters.
 
+*/
 
-@c
 void hnj_hyphen_load(HyphenDict * dict, const unsigned char *f)
 {
     int state_num, last_state;
@@ -601,7 +570,6 @@ void hnj_hyphen_load(HyphenDict * dict, const unsigned char *f)
     unsigned char *word;
     char *pattern;
     size_t l = 0;
-
     const unsigned char *format;
     const unsigned char *begin = f;
     unsigned char *pat;
@@ -609,46 +577,23 @@ void hnj_hyphen_load(HyphenDict * dict, const unsigned char *f)
     while ((format = next_pattern(&l, &f)) != NULL) {
         int i, j, e1;
         if (l>=255) {
-           help1("Individual patterns should not be longer than 254 bytes total.");
-           print_err("Pattern of enormous length ignored");
-           error();
+           normal_warning("hyphenation","a pattern of more than 254 bytes ignored");
            continue;
         }
-#if 0
-           printf("%s\n",format);
-           char* repl = strnchr(format, '/',l);
-           int replindex = 0;
-           int replcut = 0;
-           if (repl) {
-           int clen = l-(repl-format);
-           l = repl-format;
-           char * index = strnchr(repl + 1, ',',clen);
-           if (index) {
-           char * index2 = strnchr(index + 1, ',',clen-(index-repl));
-           if (index2) {
-           replindex = (signed char) atoi(index + 1) - 1;
-           replcut = (signed char) atoi(index2 + 1);
-           }
-           } else {
-           hnj_strchomp(repl + 1);
-           replindex = 0;
-           replcut = strlen(buf);
-           }
-           repl = hnj_strdup(repl + 1);
-           }
-#endif
         for (i = 0, j = 0, e1 = 0; (unsigned) i < l; i++) {
             if (format[i] >= '0' && format[i] <= '9')
                 j++;
             if (is_utf8_follow(format[i]))
                 e1++;
         }
-        /* |l-e1|   => number of {\it characters} not {\it bytes} */
-        /* |l-j|   => number of pattern bytes */
-        /* |l-e1-j| => number of pattern characters */
+        /*tex
+            Here |l-e1| is the number of {\em characters} not {\em bytes}, |l-j|
+            the number of pattern bytes and |l-e1-j| the number of pattern
+            characters.
+        */
         pat = (unsigned char *) malloc((1 + l - (size_t) j));
         org = (char *) malloc((size_t) (2 + l - (size_t) e1 - (size_t) j));
-        /* remove hyphenation encoders (digits) from pat */
+        /*tex Remove hyphenation encoders (digits) from pat. */
         org[0] = '0';
         for (i = 0, j = 0, e1 = 0; (unsigned) i < l; i++) {
             unsigned char c = format[i];
@@ -665,20 +610,25 @@ void hnj_hyphen_load(HyphenDict * dict, const unsigned char *f)
         org[j + 1] = 0;
         hyppat_insert(dict->patterns, pat, org);
     }
-    dict->pat_length += (int) ((f - begin) + 2);        /* 2 for spurious spaces */
+    /*tex We add 2 bytes for spurious spaces. */
+    dict->pat_length += (int) ((f - begin) + 2);
     init_hash(&dict->merged);
     v = new_HashIter(dict->patterns);
     while (nextHash(v, &word)) {
         int wordsize = (int) strlen((char *) word);
         int j1, l1;
         for (l1 = 1; l1 <= wordsize; l1++) {
-            if (is_utf8_follow(word[l1]))
-                continue;       /* Do not clip an utf8 sequence */
+            if (is_utf8_follow(word[l1])) {
+                /*tex Do not clip an utf8 sequence. */
+                continue;
+            }
             for (j1 = 1; j1 <= l1; j1++) {
                 char *subpat_pat;
                 int i1 = l1 - j1;
-                if (is_utf8_follow(word[i1]))
-                    continue;   /* Do not start halfway an utf8 sequence */
+                if (is_utf8_follow(word[i1])) {
+                    /*tex Do not start halfway an utf8 sequence. */
+                    continue;
+                }
                 if ((subpat_pat =
                      hyppat_lookup(dict->patterns, word + i1, j1)) != NULL) {
                     char *newpat_pat;
@@ -694,7 +644,8 @@ void hnj_hyphen_load(HyphenDict * dict, const unsigned char *f)
                             if (is_utf8_follow(newword[i1]))
                                 e1++;
                         neworg = malloc((size_t) (l1 + 2 - e1));
-                        sprintf(neworg, "%0*d", l1 + 1 - e1, 0);  /* fill with right amount of '0' */
+                        /*tex Fill with right amount of zeros: */
+                        sprintf(neworg, "%0*d", l1 + 1 - e1, 0);
                         hyppat_insert(dict->merged, newword, combine(neworg, subpat_pat));
                     } else {
                         combine(newpat_pat, subpat_pat);
@@ -704,20 +655,15 @@ void hnj_hyphen_load(HyphenDict * dict, const unsigned char *f)
         }
     }
     delete_HashIter(v);
-
     init_hash(&dict->state_num);
     state_insert(dict->state_num, hnj_strdup((const unsigned char *) ""), 0);
     v = new_HashIter(dict->merged);
     while (nextHashStealPattern(v, &word, &pattern)) {
         static unsigned char mask[] = { 0x3F, 0x1F, 0xF, 0x7 };
         int j1 = (int) strlen((char *) word);
-#ifdef VERBOSE
-        printf("word %s pattern %s, j = %d\n", word, pattern, j1);
-#endif
         state_num = hnj_get_state(dict, word, &found);
         dict->states[state_num].match = pattern;
-
-        /* now, put in the prefix transitions */
+        /*tex Now, put in the prefix transitions. */
         while (found < 0) {
             j1--;
             last_state = state_num;
@@ -741,71 +687,48 @@ void hnj_hyphen_load(HyphenDict * dict, const unsigned char *f)
     }
     delete_HashIter(v);
     clear_hyppat_hash(&dict->merged);
-
-    /* put in the fallback states */
+    /*tex Put in the fallback states. */
     {
-    int i, j = 0;
-    for (i = 0; i < HASH_SIZE; i++) {
-        for (e = dict->state_num->entries[i]; e; e = e->next) {
-            /* do not do state==0 otherwise things get confused */
-            if (e->u.state) {
-                for (j = 1; 1; j++) {
-                    state_num = state_lookup(dict->state_num, e->key + j);
-                    if (state_num >= 0)
-                        break;
+        int i, j = 0;
+        for (i = 0; i < HASH_SIZE; i++) {
+            for (e = dict->state_num->entries[i]; e; e = e->next) {
+                /*tex Do not do |state==0| otherwise things get confused. */
+                if (e->u.state) {
+                    for (j = 1; 1; j++) {
+                        state_num = state_lookup(dict->state_num, e->key + j);
+                        if (state_num >= 0)
+                            break;
+                    }
+                    dict->states[e->u.state].fallback_state = state_num;
                 }
-                dict->states[e->u.state].fallback_state = state_num;
             }
         }
     }
-#ifdef VERBOSE
-    for (i = 0; i < HASH_SIZE; i++) {
-        for (e = dict->state_num->entries[i]; e; e = e->next) {
-            printf("%d string %s state %d, fallback=%d\n",
-                i, e->key, e->u.state, dict->states[e->u.state].fallback_state);
-            for (j = 0; j < dict->states[e->u.state].num_trans; j++) {
-                printf(" u%4x->%d\n",
-                   (int) dict->states[e->u.state].trans[j].uni_ch,
-                   dict->states[e->u.state].trans[j].new_state);
-            }
-        }
-    }
-#endif
-    }
     clear_state_hash(&dict->state_num);
 }
 
-@ @c
 extern halfword insert_syllable_discretionary(halfword t, lang_variables * lan);
 
-void hnj_hyphen_hyphenate(HyphenDict * dict,
-                          halfword first1,
-                          halfword last1,
-                          int length,
-                          halfword left, halfword right, lang_variables * lan)
+void hnj_hyphen_hyphenate(HyphenDict * dict, halfword first1, halfword last1,
+    int length, halfword left, halfword right, lang_variables * lan)
 {
     int char_num;
     halfword here;
     int state = 0;
-    /* +2 for dots at each end, +1 for points /outside/ characters */
+    /*tex +2 for dots at each end, +1 for points outside characters. */
     int ext_word_len = length + 2;
     int hyphen_len = ext_word_len + 1;
     char *hyphens = hnj_malloc(hyphen_len + 1);
-
-    /* Add a '.' to beginning and end to facilitate matching */
+    /*tex Add a '.' to beginning and end to facilitate matching. */
     vlink(begin_point) = first1;
     vlink(end_point) = vlink(last1);
     vlink(last1) = end_point;
-
     for (char_num = 0; char_num < hyphen_len; char_num++) {
         hyphens[char_num] = '0';
     }
     hyphens[hyphen_len] = 0;
-
-    /* now, run the finite state machine */
-    for (char_num = 0, here = begin_point; here != vlink(end_point);
-         here = vlink(here)) {
-
+    /*tex Now, run the finite state machine. */
+    for (char_num = 0, here = begin_point; here != vlink(end_point); here = vlink(here)) {
         int ch;
         if (here == begin_point || here == end_point) {
             ch = '.';
@@ -816,28 +739,20 @@ void hnj_hyphen_hyphenate(HyphenDict * dict,
             }
         }
         while (state != -1) {
-#if 0
-            printf("%*s%s%c",char_num-strlen(get_state_str(state)),"",get_state_str(state),(char)ch);
-#endif
             HyphenState *hstate = &dict->states[state];
             int k;
             for (k = 0; k < hstate->num_trans; k++) {
                 if (hstate->trans[k].uni_ch == ch) {
                     char *match;
                     state = hstate->trans[k].new_state;
-#if 0
-                    printf(" state %d\n",state);
-#endif
                     match = dict->states[state].match;
                     if (match) {
-                        /* +2 because:
-                         1 string length is one bigger than offset
-                         1 hyphenation starts before first character
-                         */
+                        /*tex
+
+                            We add +2 because 1 string length is one bigger than offset
+                            and 1 hyphenation starts before first character.
+                        */
                         int offset = (int) (char_num + 2 - (int) strlen(match));
-#if 0
-                        printf("%*s%s\n", offset,"", match);
-#endif
                         int m;
                         for (m = 0; match[m]; m++) {
                             if (hyphens[offset + m] < match[m])
@@ -848,21 +763,19 @@ void hnj_hyphen_hyphenate(HyphenDict * dict,
                 }
             }
             state = hstate->fallback_state;
-#if 0
-            printf(" back to %d\n", state);
-#endif
         }
-        /* nothing worked, let's go to the next character */
+        /*tex Nothing worked, let's go to the next character. */
         state = 0;
-      try_next_letter:;
+    try_next_letter:;
         char_num++;
     }
-
-    /* restore the correct pointers */
+    /*tex Restore the correct pointers. */
     vlink(last1) = vlink(end_point);
+    /*tex
 
-    /* pattern is \.{\^.\^w\^o\^r\^d\^.\^}   |word_len|=4, |ext_word_len|=6, |hyphens|=7
-     * check      \.{    \^ \^ \^    }   so drop first two and stop after |word_len-1|
+        Pattern is \.{\^.\^w\^o\^r\^d\^.\^} and |word_len|=4, |ext_word_len|=6,
+        |hyphens|=7; check \.{ \^ \^ \^ } and therefore drop first two and stop
+        after |word_len-1|
      */
     for (here = first1, char_num = 2; here != left; here = vlink(here))
         char_num++;
diff --git a/texk/web2c/luatexdir/lang/texlang.w b/texk/web2c/luatexdir/lang/texlang.c
similarity index 59%
rename from texk/web2c/luatexdir/lang/texlang.w
rename to texk/web2c/luatexdir/lang/texlang.c
index 337d2eca5..04f96660f 100644
--- a/texk/web2c/luatexdir/lang/texlang.w
+++ b/texk/web2c/luatexdir/lang/texlang.c
@@ -1,31 +1,32 @@
-% texlang.w
-%
-% Copyright 2006-2012 Taco Hoekwater <taco@@luatex.org>
-%
-% This file is part of LuaTeX.
-%
-% LuaTeX is free software; you can redistribute it and/or modify it under
-% the terms of the GNU General Public License as published by the Free
-% Software Foundation; either version 2 of the License, or (at your
-% option) any later version.
-%
-% LuaTeX is distributed in the hope that it will be useful, but WITHOUT
-% ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-% FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
-% License for more details.
-%
-% You should have received a copy of the GNU General Public License along
-% with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
-
-@ @c
+/*
+
+texlang.w
+
+Copyright 2006-2012 Taco Hoekwater <taco@luatex.org>
+
+This file is part of LuaTeX.
+
+LuaTeX is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 2 of the License, or (at your
+option) any later version.
+
+LuaTeX is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+License for more details.
+
+You should have received a copy of the GNU General Public License along
+with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+
+*/
 
 #include "ptexlib.h"
 #include <string.h>
 #include "lua/luatex-api.h"
 
-@ Low-level helpers
+/*tex Low-level helpers */
 
-@ @c
 #define unVERBOSE
 
 #define MAX_TEX_LANGUAGES  16384
@@ -60,7 +61,9 @@ struct tex_language *new_language(int n)
         lang->post_exhyphen_char = 0;
         lang->hyphenation_min = -1;
         if (saving_hyph_codes_par) {
-            /* for now, we might just use specific value for whatever task */
+            /*tex
+                For now, we might just use specific value for whatever task.
+            */
             hj_codes_from_lc_codes(l);
         }
         return lang;
@@ -82,7 +85,6 @@ struct tex_language *get_language(int n)
     }
 }
 
-@ @c
 void set_pre_hyphen_char(int n, int v)
 {
     struct tex_language *l = get_language((int) n);
@@ -183,7 +185,6 @@ void load_tex_patterns(int curlang, halfword head)
     load_patterns(get_language(curlang), (unsigned char *) s);
 }
 
-@ @c
 #define STORE_CHAR(l,x) do { \
     unsigned xx = get_hj_code(l,x); \
     if (!xx || xx <= 32) { \
@@ -192,17 +193,24 @@ void load_tex_patterns(int curlang, halfword head)
     uindex = uni2string(uindex, xx); \
 } while (0)
 
-@ Cleans one word which is returned in |cleaned|, returns the new offset into
-|buffer|
+/*
+
+    This cleans one word which is returned in |cleaned|, returns the new offset
+    into |buffer|.
+
+*/
 
-@c
 const char *clean_hyphenation(int id, const char *buff, char **cleaned)
 {
     int items = 0;
-    unsigned char word[MAX_WORD_LEN + 1];     /* work buffer for bytes */
-    unsigned uword[MAX_WORD_LEN + 1] = { 0 }; /* work buffer for unicode */
-    int u = 0;                                /* unicode buffer value */
-    int i = 0;                                /* index into buffer */
+    /*tex Work buffer for bytes: */
+    unsigned char word[MAX_WORD_LEN + 1];
+    /*tex Work buffer for \UNICODE: */
+    unsigned uword[MAX_WORD_LEN + 1] = { 0 };
+    /*tex The \UNICODE\ buffer value: */
+    int u = 0;
+    /*tex The index into buffer: */
+    int i = 0;
     char *uindex = (char *)word;
     const char *s = buff;
 
@@ -210,21 +218,21 @@ const char *clean_hyphenation(int id, const char *buff, char **cleaned)
         word[i++] = (unsigned)*s;
         s++;
         if ((s-buff)>MAX_WORD_LEN) {
-            /* todo: this is too strict, should count unicode, not bytes */
+            /*tex Todo: this is too strict, should count \UNICODE, not bytes. */
             *cleaned = NULL;
             tex_error("exception too long", NULL);
             return s;
         }
     }
-    /* now convert the input to unicode */
+    /*tex Now convert the input to \UNICODE. */
     word[i] = '\0';
     utf2uni_strcpy(uword, (const char *)word);
-    /* build the new word string */
+    /*tex Build the new word string. */
     i = 0;
     while (uword[i]>0) {
         u = uword[i++];
         if (u == '-') {
-            /* skip */
+            /*tex Skip. */
         } else if (u == '=') {
             STORE_CHAR(id,'-');
         } else if (u == '{') {
@@ -259,6 +267,9 @@ const char *clean_hyphenation(int id, const char *buff, char **cleaned)
                 tex_error("exception syntax error", NULL);
                 return s;
             }
+            if (uword[i] == '[' && uword[i+1] >= '0' && uword[i+1] <= '9' && uword[i+2] == ']') {
+                i += 3;
+            }
         } else {
             STORE_CHAR(id,u);
         }
@@ -268,7 +279,6 @@ const char *clean_hyphenation(int id, const char *buff, char **cleaned)
     return s;
 }
 
-@ @c
 void load_hyphenation(struct tex_language *lang, const unsigned char *buff)
 {
     const char *s;
@@ -322,7 +332,6 @@ void load_tex_hyphenation(int curlang, halfword head)
     load_hyphenation(get_language(curlang), (unsigned char *) s);
 }
 
-@ @c
 static halfword insert_discretionary(halfword t, halfword pre, halfword post, halfword replace, int penalty)
 {
     halfword g;
@@ -331,21 +340,21 @@ static halfword insert_discretionary(halfword t, halfword pre, halfword post, ha
     int attr = node_attr(t) ;
     disc_penalty(d) = penalty;
     if (t == replace) {
-        /* prev disc next-next */
+        /*tex We have |prev disc next-next|. */
         try_couple_nodes(d, vlink(t));
         try_couple_nodes(alink(t), d);
         alink(t) = null;
         vlink(t) = null;
         replace = t ;
     } else {
-        /* prev disc next */
+        /*tex We have |prev disc next|. */
         try_couple_nodes(d, vlink(t));
         couple_nodes(t, d);
     }
     if (replace != null) {
         f = font(replace);
     } else {
-        /* For compound words following explicit hyphens. */
+        /*tex For compound words following explicit hyphens. */
         f = get_cur_font();
     }
     for (g = pre; g != null; g = vlink(g)) {
@@ -406,7 +415,6 @@ halfword insert_syllable_discretionary(halfword t, lang_variables * lan)
         }
         set_disc_field(pre_break(n), g);
     }
-
     if (lan->post_hyphen_char > 0) {
         t = vlink(n);
         g = raw_glyph_node();
@@ -423,7 +431,6 @@ halfword insert_syllable_discretionary(halfword t, lang_variables * lan)
     return n;
 }
 
-@ @c
 static halfword insert_character(halfword t, int c)
 {
     halfword p;
@@ -456,12 +463,12 @@ static halfword compound_word_break(halfword t, int clang)
     return disc;
 }
 
-@ @c
 void set_disc_field(halfword f, halfword t)
 {
     if (t != null) {
-        /*
-            couple_nodes(f, t); // better not expose f as prev pointer
+        /*tex
+            No |couple_nodes(f, t);| as we can better not expose |f| as |prev|
+            pointer.
         */
         vlink(f) = t ;
         alink(t) = null ;
@@ -472,14 +479,14 @@ void set_disc_field(halfword f, halfword t)
     }
 }
 
-@ @c
 static char *hyphenation_exception(int exceptions, char *w)
 {
     char *ret = NULL;
     lua_checkstack(Luas, 2);
     lua_rawgeti(Luas, LUA_REGISTRYINDEX, exceptions);
-    if (lua_istable(Luas, -1)) {   /* ?? */
-        lua_pushstring(Luas, w);   /* word table */
+    if (lua_istable(Luas, -1)) {
+        /*tex Word table: */
+        lua_pushstring(Luas, w);
         lua_rawget(Luas, -2);
         if (lua_type(Luas, -1) == LUA_TSTRING) {
             ret = xstrdup(lua_tostring(Luas, -1));
@@ -491,7 +498,6 @@ static char *hyphenation_exception(int exceptions, char *w)
     return ret;
 }
 
-@ @c
 char *exception_strings(struct tex_language *lang)
 {
     const char *value;
@@ -503,8 +509,8 @@ char *exception_strings(struct tex_language *lang)
     lua_checkstack(Luas, 2);
     lua_rawgeti(Luas, LUA_REGISTRYINDEX, lang->exceptions);
     if (lua_istable(Luas, -1)) {
-        /* iterate and join */
-        lua_pushnil(Luas);         /* first key */
+        /*tex Iterate and join. */
+        lua_pushnil(Luas);
         while (lua_next(Luas, -2) != 0) {
             value = lua_tolstring(Luas, -1, &l);
             if (current + 2 + l > size) {
@@ -520,15 +526,19 @@ char *exception_strings(struct tex_language *lang)
     return ret;
 }
 
-@ the sequence from |wordstart| to |r| can contain only normal characters it
-could be faster to modify a halfword pointer and return an integer
+/*tex
+
+    The sequence from |wordstart| to |r| can contain only normal characters it
+    could be faster to modify a halfword pointer and return an integer
+
+*/
 
-@c
 static halfword find_exception_part(unsigned int *j, unsigned int *uword, int len)
 {
     halfword g = null, gg = null;
     register unsigned i = *j;
-    i++;                        /* this puts uword[i] on the |{| */
+    /*tex This puts uword[i] on the |{|. */
+    i++;
     while (i < (unsigned) len && uword[i + 1] != '}') {
         if (g == null) {
             gg = new_char(0, (int) uword[i + 1]);
@@ -548,7 +558,8 @@ static int count_exception_part(unsigned int *j, unsigned int *uword, int len)
 {
     int ret = 0;
     register unsigned i = *j;
-    i++;                        /* this puts uword[i] on the |{| */
+    /*tex This puts uword[i] on the |{|. */
+    i++;
     while (i < (unsigned) len && uword[i + 1] != '}') {
         ret++;
         i++;
@@ -557,22 +568,23 @@ static int count_exception_part(unsigned int *j, unsigned int *uword, int len)
     return ret;
 }
 
-@ @c
 static const char *PAT_ERROR[] = {
     "Exception discretionaries should contain three pairs of braced items.",
     "No intervening spaces are allowed.",
     NULL
 };
 
-/*
+/*tex
+
     The exceptions are taken as-is: no min values are taken into account. One can
     add normal patterns on-the-fly if needed.
+
 */
 
 static void do_exception(halfword wordstart, halfword r, char *replacement)
 {
     unsigned i;
-    halfword t;
+    halfword t, pen;
     unsigned len;
     int clang;
     lang_variables langdata;
@@ -584,126 +596,191 @@ static void do_exception(halfword wordstart, halfword r, char *replacement)
     clang = char_lang(wordstart);
     langdata.pre_hyphen_char = get_pre_hyphen_char(clang);
     langdata.post_hyphen_char = get_post_hyphen_char(clang);
-
     for (i = 0; i < len; i++) {
-        if (uword[i + 1] == '-') {      /* a hyphen follows */
-            while (vlink(t) != r && (type(t) != glyph_node || !is_simple_character(t)))
-                t = vlink(t);
+        if (uword[i + 1] == 0 ) {
+            /*tex We ran out of the exception pattern. */
+            break;
+        } else if (uword[i + 1] == '-') {
+            /*tex A hyphen follows. */
             if (vlink(t) == r)
                 break;
             insert_syllable_discretionary(t, &langdata);
             t = vlink(t);       /* skip the new disc */
         } else if (uword[i + 1] == '=') {
-            /* do nothing ? */
+            /*tex We skip a disc. */
             t = vlink(t);
         } else if (uword[i + 1] == '{') {
+            /*tex We ran into an exception |{}{}{}| or |{}{}{}[]|. */
             halfword gg, hh, replace = null;
             int repl;
+            /*tex |pre| */
             gg = find_exception_part(&i, uword, (int) len);
             if (i == len || uword[i + 1] != '{') {
                 tex_error("broken pattern 1", PAT_ERROR);
             }
+            /*tex |post| */
             hh = find_exception_part(&i, uword, (int) len);
             if (i == len || uword[i + 1] != '{') {
                 tex_error("broken pattern 2", PAT_ERROR);
             }
+            /*tex |replace| */
             repl = count_exception_part(&i, uword, (int) len);
             if (i == len) {
                 tex_error("broken pattern 3", PAT_ERROR);
             }
-            /*i++;  *//* jump over the last right brace */
+            /*tex Play safe. */
             if (vlink(t) == r)
                 break;
+            /*tex Let's deal with an (optional) replacement. */
             if (repl > 0) {
+                /*tex Assemble the replace stream. */
                 halfword q = t;
                 replace = vlink(q);
                 while (repl > 0 && q != null) {
                     q = vlink(q);
-                    if (type(q) == glyph_node) {
+                    if (type(q) == glyph_node || type(q) == disc_node) {
                         repl--;
+                    } else {
+                        break ;
                     }
                 }
+                /*tex Remove it from the main stream */
                 try_couple_nodes(t, vlink(q));
+                /*tex and finish it in the replace. */
                 vlink(q) = null;
+                /*tex Sanitize the replace stream (we could use the flattener instead). */
+                q = replace ;
+                while (q != null) {
+                    halfword n = vlink(q);
+                    if (type(q) == disc_node) {
+                        /*tex Beware: the replacement starts after the no_break pointer. */
+                        halfword r = vlink(no_break(q));
+                        vlink(no_break(q)) = null;
+                        alink(r) = null ;
+                        /*tex Insert the replacement glyph. */
+                        if (q == replace) {
+                            replace = r;
+                        } else {
+                            try_couple_nodes(alink(q),r);
+                        }
+                        /*tex Append the glyph (one). */
+                        try_couple_nodes(r,n);
+                        /*tex Flush the disc. */
+                        flush_node(q);
+                    }
+                    q = n ;
+                }
+            }
+            /*tex Let's check if we have a penalty spec. */
+            if (((i+3) < len) && uword[i+1] == '[' && uword[i+2] >= '0' && uword[i+2] <= '9' && uword[i+3] == ']') {
+                if (exception_penalty_par > 0) {
+                    if (exception_penalty_par > 100000) {
+                        pen = (uword[i+2] - '0') * exception_penalty_par ;
+                    } else {
+                        pen = exception_penalty_par;
+                    }
+                } else {
+                    pen = hyphen_penalty_par;
+                }
+                i += 3;
+            } else {
+                pen = hyphen_penalty_par;
+            }
+            /*tex And now we insert a disc node. */
+            t = insert_discretionary(t, gg, hh, replace, pen);
+            /*tex We skip the new disc node. */
+            t = vlink(t);
+            /*tex check if we have two exceptions in a row */
+            if (uword[i + 1] == '{') {
+                i--;
             }
-            t = insert_discretionary(t, gg, hh, replace, hyphen_penalty_par);
-            t = vlink(t);       /* skip the new disc */
         } else {
             t = vlink(t);
         }
+        /*tex Again we play safe. */
+        if (t == null || vlink(t) == r) {
+            break;
+        }
     }
 }
 
-@ This is a documentation section from the pascal web file. It is not true any
-more, but I do not have time right now to rewrite it -- Taco
-
-When the line-breaking routine is unable to find a feasible sequence of
-breakpoints, it makes a second pass over the paragraph, attempting to hyphenate
-the hyphenatable words. The goal of hyphenation is to insert discretionary
-material into the paragraph so that there are more potential places to break.
-
-The general rules for hyphenation are somewhat complex and technical, because we
-want to be able to hyphenate words that are preceded or followed by punctuation
-marks, and because we want the rules to work for languages other than English. We
-also must contend with the fact that hyphens might radically alter the ligature
-and kerning structure of a word.
-
-A sequence of characters will be considered for hyphenation only if it belongs to
-a ``potentially hyphenatable part'' of the current paragraph. This is a sequence
-of nodes $p_0p_1\ldots p_m$ where $p_0$ is a glue node, $p_1\ldots p_{m-1}$ are
-either character or ligature or whatsit or implicit kern nodes, and $p_m$ is a
-glue or penalty or insertion or adjust or mark or whatsit or explicit kern node.
-(Therefore hyphenation is disabled by boxes, math formulas, and discretionary
-nodes already inserted by the user.) The ligature nodes among $p_1\ldots p_{m-1}$
-are effectively expanded into the original non-ligature characters; the kern
-nodes and whatsits are ignored. Each character |c| is now classified as either a
-nonletter (if |lc_code(c)=0|), a lowercase letter (if |lc_code(c)=c|), or an
-uppercase letter (otherwise); an uppercase letter is treated as if it were
-|lc_code(c)| for purposes of hyphenation. The characters generated by $p_1\ldots
-p_{m-1}$ may begin with nonletters; let $c_1$ be the first letter that is not in
-the middle of a ligature. Whatsit nodes preceding $c_1$ are ignored; a whatsit
-found after $c_1$ will be the terminating node $p_m$. All characters that do not
-have the same font as $c_1$ will be treated as nonletters. The |hyphen_char| for
-that font must be between 0 and 255, otherwise hyphenation will not be attempted.
-\TeX\ looks ahead for as many consecutive letters $c_1\ldots c_n$ as possible;
-however, |n| must be less than 64, so a character that would otherwise be
-$c_{64}$ is effectively not a letter. Furthermore $c_n$ must not be in the middle
-of a ligature. In this way we obtain a string of letters $c_1\ldots c_n$ that are
-generated by nodes $p_a\ldots p_b$, where |1<=a<=b+1<=m|. If |n>=l_hyf+r_hyf|,
-this string qualifies for hyphenation; however, |uc_hyph| must be positive, if
-$c_1$ is uppercase.
-
-The hyphenation process takes place in three stages. First, the candidate
-sequence $c_1\ldots c_n$ is found; then potential positions for hyphens are
-determined by referring to hyphenation tables; and finally, the nodes $p_a\ldots
-p_b$ are replaced by a new sequence of nodes that includes the discretionary
-breaks found.
-
-Fortunately, we do not have to do all this calculation very often, because of the
-way it has been taken out of \TeX's inner loop. For example, when the second
-edition of the author's 700-page book {\sl Seminumerical Algorithms} was typeset
-by \TeX, only about 1.2 hyphenations needed to be @^Knuth, Donald Ervin@> tried
-per paragraph, since the line breaking algorithm needed to use two passes on only
-about 5 per cent of the paragraphs.
-
-When a word been set up to contain a candidate for hyphenation, \TeX\ first looks
-to see if it is in the user's exception dictionary. If not, hyphens are inserted
-based on patterns that appear within the given word, using an algorithm due to
-Frank~M. Liang. @^Liang, Franklin Mark@>
-
-@ This is incompatible with TEX because the first word of a paragraph can be
-hyphenated, but most european users seem to agree that prohibiting hyphenation
-there was not the best idea ever.
-
-@c
-/*
-    More strict: \hyphenationbounds
-
-    0 = not strict
-    1 = strict start
-    2 = strict end
-    3 = strict start and strict end
-
+/*tex
+
+    This is a documentation section from the pascal web file. It is not true any
+    more, but I (Taco) do not have time right now to rewrite it.
+
+    When the line-breaking routine is unable to find a feasible sequence of
+    breakpoints, it makes a second pass over the paragraph, attempting to
+    hyphenate the hyphenatable words. The goal of hyphenation is to insert
+    discretionary material into the paragraph so that there are more potential
+    places to break.
+
+    The general rules for hyphenation are somewhat complex and technical, because
+    we want to be able to hyphenate words that are preceded or followed by
+    punctuation marks, and because we want the rules to work for languages other
+    than English. We also must contend with the fact that hyphens might radically
+    alter the ligature and kerning structure of a word.
+
+    A sequence of characters will be considered for hyphenation only if it
+    belongs to a ``potentially hyphenatable part'' of the current paragraph. This
+    is a sequence of nodes $p_0p_1\ldots p_m$ where $p_0$ is a glue node,
+    $p_1\ldots p_{m-1}$ are either character or ligature or whatsit or implicit
+    kern nodes, and $p_m$ is a glue or penalty or insertion or adjust or mark or
+    whatsit or explicit kern node. (Therefore hyphenation is disabled by boxes,
+    math formulas, and discretionary nodes already inserted by the user.) The
+    ligature nodes among $p_1\ldots p_{m-1}$ are effectively expanded into the
+    original non-ligature characters; the kern nodes and whatsits are ignored.
+    Each character |c| is now classified as either a nonletter (if
+    |lc_code(c)=0|), a lowercase letter (if |lc_code(c)=c|), or an uppercase
+    letter (otherwise); an uppercase letter is treated as if it were |lc_code(c)|
+    for purposes of hyphenation. The characters generated by $p_1\ldots p_{m-1}$
+    may begin with nonletters; let $c_1$ be the first letter that is not in the
+    middle of a ligature. Whatsit nodes preceding $c_1$ are ignored; a whatsit
+    found after $c_1$ will be the terminating node $p_m$. All characters that do
+    not have the same font as $c_1$ will be treated as nonletters. The
+    |hyphen_char| for that font must be between 0 and 255, otherwise hyphenation
+    will not be attempted. \TeX\ looks ahead for as many consecutive letters
+    $c_1\ldots c_n$ as possible; however, |n| must be less than 64, so a
+    character that would otherwise be $c_{64}$ is effectively not a letter.
+    Furthermore $c_n$ must not be in the middle of a ligature. In this way we
+    obtain a string of letters $c_1\ldots c_n$ that are generated by nodes
+    $p_a\ldots p_b$, where |1<=a<=b+1<=m|. If |n>=l_hyf+r_hyf|, this string
+    qualifies for hyphenation; however, |uc_hyph| must be positive, if $c_1$ is
+    uppercase.
+
+    The hyphenation process takes place in three stages. First, the candidate
+    sequence $c_1\ldots c_n$ is found; then potential positions for hyphens are
+    determined by referring to hyphenation tables; and finally, the nodes
+    $p_a\ldots p_b$ are replaced by a new sequence of nodes that includes the
+    discretionary breaks found.
+
+    Fortunately, we do not have to do all this calculation very often, because of
+    the way it has been taken out of \TeX's inner loop. For example, when the
+    second edition of the author's 700-page book {\sl Seminumerical Algorithms}
+    was typeset by \TeX, only about 1.2 hyphenations needed to be tried per
+    paragraph, since the line breaking algorithm needed to use two passes on only
+    about 5 per cent of the paragraphs.
+
+    When a word been set up to contain a candidate for hyphenation, \TeX\ first
+    looks to see if it is in the user's exception dictionary. If not, hyphens are
+    inserted based on patterns that appear within the given word, using an
+    algorithm due to Frank~M. Liang.
+
+    This is incompatible with \TEX\ because the first word of a paragraph can be
+    hyphenated, but most European users seem to agree that prohibiting
+    hyphenation there was not the best idea ever.
+
+    We have some variants available that are controlled by the paremeter
+    \type {\hyphenationbounds}:
+
+    \starttabulate
+    \NC \type {0} \NC not strict \NC \NR
+    \NC \type {1} \NC strict start \NC \NR
+    \NC \type {2} \NC strict end \NC \NR
+    \NC \type {3} \NC strict start and strict end \NC \NR
+    \stoptabulate
+
+    \startbuffer
     \parindent0pt \hsize=1.1cm
     12-34-56 \par
     12-34-\hbox{56} \par
@@ -716,20 +793,24 @@ there was not the best idea ever.
     12-34-\vrule width 1em height 1.5ex \par
     12-\hbox{34}-56 \par
     12-\vrule width 1em height 1.5ex-56 \par
+    \stopbuffer
 
-*/
+    \typebuffer
 
-/*
-    We only accept an explicit hyphen when there is a preceding glyph and we skip a sequence of
-    explicit hyphens as that normally indicates a -- or --- ligature in which case we can in a
-    worse case usage get bad node lists later on due to messed up ligature building as these
-    dashes are ligatures in base fonts. This is a side effect of the separating the hyphenation,
-    ligaturing and kerning steps. A test is cmr with ------.
+    \startpacked \getbuffer \stopbuffer
+
+    We only accept an explicit hyphen when there is a preceding glyph and we skip
+    a sequence of explicit hyphens as that normally indicates a \type {--} or
+    \type {---} ligature in which case we can in a worse case usage get bad node
+    lists later on due to messed up ligature building as these dashes are
+    ligatures in base fonts. This is a side effect of the separating the
+    hyphenation, ligaturing and kerning steps. A test is cmr with \type {------}.
 
-    A font handler can collapse successive hyphens but it's not nice to put the burden there. A
-    somewhat messy border case is ---- but in LuaTeX we don't treat -- and --- special. Also,
-    traditional TeX will break a line at -foo but this can be disabled by setting the automatic
-    mode to 1.
+    A font handler can collapse successive hyphens but it's not nice to put the
+    burden there. A somewhat messy border case is \type {----} but in \LUATEX\ we
+    don't treat \type {--} and \type {---} special. Also, traditional \TEX\ will
+    break a line at \type {-foo} but this can be disabled by setting the
+    automatic mode to \type {1}.
 
 */
 
@@ -742,79 +823,78 @@ static halfword find_next_wordstart(halfword r, halfword first_language, halfwor
     halfword t ;
     while (r != null) {
         switch (type(r)) {
-        case boundary_node:
-            if (subtype(r) == word_boundary) {
+            case boundary_node:
+                if (subtype(r) == word_boundary) {
+                    start_ok = 1;
+                }
+                break;
+            case hlist_node:
+            case vlist_node:
+            case rule_node:
+            case dir_node:
+            case whatsit_node:
+                if (strict_bound == 1 || strict_bound == 3) {
+                    start_ok = 0;
+                }
+                break;
+            case glue_node:
                 start_ok = 1;
-            }
-            break;
-        case hlist_node: /* new > 0.95 */
-        case vlist_node: /* new > 0.95 */
-        case rule_node:  /* new > 0.95 */
-        case dir_node:
-        case whatsit_node:
-            if (strict_bound == 1 || strict_bound == 3) {
-                start_ok = 0;
-            }
-            break;
-        case glue_node:
-            start_ok = 1;
-            break;
-        case math_node:
-            while (mathlevel > 0) {
-                r = vlink(r);
-                if (r == null)
-                    return r;
-                if (type(r) == math_node) {
-                    if (subtype(r) == before) {
-                        mathlevel++;
-                    } else {
-                        mathlevel--;
+                break;
+            case math_node:
+                while (mathlevel > 0) {
+                    r = vlink(r);
+                    if (r == null)
+                        return r;
+                    if (type(r) == math_node) {
+                        if (subtype(r) == before) {
+                            mathlevel++;
+                        } else {
+                            mathlevel--;
+                        }
                     }
                 }
-            }
-            break;
-        case glyph_node:
-            if (is_simple_character(r)) {
-                chr = character(r) ;
-                if (chr == ex_hyphen_char_par) {
-                    t = vlink(r) ;
-                    if ((automatic_hyphen_mode_par == 0) && (t != null) && (type(t) == glyph_node) && (character(t) != ex_hyphen_char_par)) {
-                        /* we have no word yet and the next character is a non hyphen */
-                        r = compound_word_break(r, char_lang(r));
-                    } else {
-                        /* we jump over the sequence of hyphens */
-                        while ((t != null) && (type(t) == glyph_node) && (character(t) == ex_hyphen_char_par)) {
-                            r = t ;
-                            t = vlink(r) ;
+                break;
+            case glyph_node:
+                if (is_simple_character(r)) {
+                    chr = character(r) ;
+                    if (chr == ex_hyphen_char_par) {
+                        t = vlink(r) ;
+                        if ((automatic_hyphen_mode_par == 0) && (t != null) && (type(t) == glyph_node) && (character(t) != ex_hyphen_char_par)) {
+                            /*tex We have no word yet and the next character is a non hyphen. */
+                            r = compound_word_break(r, char_lang(r));
+                        } else {
+                            /*tex We jump over the sequence of hyphens. */
+                            while ((t != null) && (type(t) == glyph_node) && (character(t) == ex_hyphen_char_par)) {
+                                r = t ;
+                                t = vlink(r) ;
+                            }
+                            if (t == null) {
+                                /*tex We reached the end of the list so we have no word start. */
+                                return null;
+                            }
                         }
-                        if (t == null) {
-                            /* we reached the end of the list so we have no word start */
-                            return null;
+                        /*tex We need a restart. */
+                        start_ok = 0;
+                    } else if (start_ok && (char_lang(r)>=first_language) && ((l = get_hj_code(char_lang(r),chr)) > 0)) {
+                        if (char_uchyph(r) || l == chr || l <= 32) {
+                            return r;
+                        } else {
+                            start_ok = 0;
                         }
-                    }
-                    /* we need a restart */
-                    start_ok = 0;
-                } else if (start_ok && (char_lang(r)>=first_language) && ((l = get_hj_code(char_lang(r),chr)) > 0)) {
-                    if (char_uchyph(r) || l == chr || l <= 32) {
-                        return r;
                     } else {
-                        start_ok = 0;
+                        /*tex We go on. */
                     }
-                } else {
-                    /* go on */
                 }
-            }
-            break;
-        default:
-            start_ok = 0;
-            break;
+                break;
+            default:
+                start_ok = 0;
+                break;
         }
         r = vlink(r);
     }
     return r;
 }
 
-@ @c
 static int valid_wordend(halfword s, halfword strict_bound)
 {
     register halfword r = s;
@@ -831,16 +911,16 @@ static int valid_wordend(halfword s, halfword strict_bound)
     if (r == null || (type(r) == glyph_node && is_simple_character(r) && clang != char_lang(r))
                   ||  type(r) == glue_node
                   ||  type(r) == penalty_node
-                  || (type(r) == kern_node && (subtype(r) == explicit_kern || /* so why not italic correction ? */
+                  || (type(r) == kern_node && (subtype(r) == explicit_kern ||
                                                subtype(r) == italic_kern   ||
                                                subtype(r) == accent_kern   ))
-                  ||  ((type(r) == hlist_node   || /* new > 0.95 */
-                        type(r) == vlist_node   || /* new > 0.95 */
-                        type(r) == rule_node    || /* new > 0.95 */
-                        type(r) == dir_node     || /* new > 0.97 */
+                  ||  ((type(r) == hlist_node   ||
+                        type(r) == vlist_node   ||
+                        type(r) == rule_node    ||
+                        type(r) == dir_node     ||
                         type(r) == whatsit_node ||
-                        type(r) == ins_node     || /* yes or no strict test */
-                        type(r) == adjust_node     /* yes or no strict test */
+                        type(r) == ins_node     ||
+                        type(r) == adjust_node
                        ) && ! (strict_bound == 2 || strict_bound == 3))
                   ||  type(r) == boundary_node
         )
@@ -848,7 +928,6 @@ static int valid_wordend(halfword s, halfword strict_bound)
     return 0;
 }
 
-@ @c
 void hnj_hyphenation(halfword head, halfword tail)
 {
     int lchar, i;
@@ -859,37 +938,43 @@ void hnj_hyphenation(halfword head, halfword tail)
     char *hy = utf8word;
     char *replacement = NULL;
     boolean explicit_hyphen = false;
+    boolean valid_word = false;
     halfword first_language = first_valid_language_par;
     halfword strict_bound = hyphenation_bounds_par;
     halfword s, r = head, wordstart = null, save_tail1 = null, left = null, right = null;
-
-    /*
+    halfword expstart = null;
+    boolean compound_hyphen = compound_hyphen_mode_par;
+    /*tex
         This first movement assures two things:
 
-        \item{a)} that we won't waste lots of time on something that has been handled already
-        (in that case, none of the glyphs match |simple_character|).
-
-        \item{b)} that the first word can be hyphenated. if the movement was not explicit,
-        then the indentation at the start of a paragraph list would make |find_next_wordstart()|
-        look too far ahead.
+        \startitemize
+            \startitem
+                That we won't waste lots of time on something that has been
+                handled already (in that case, none of the glyphs match
+                |simple_character|).
+            \stopitem
+            \startitem
+                That the first word can be hyphenated. if the movement was not
+                explicit, then the indentation at the start of a paragraph list
+                would make |find_next_wordstart()| look too far ahead.
+            \stopitem
+        \stopitemize
     */
-
     while (r != null && (type(r) != glyph_node || !is_simple_character(r))) {
         r = vlink(r);
     }
-    /*
+    /*tex
         This will make |r| a glyph node with subtype character.
     */
     r = find_next_wordstart(r,first_language,strict_bound);
     if (r == null)
         return;
-
     assert(tail != null);
     save_tail1 = vlink(tail);
     s = new_penalty(0,word_penalty);
     couple_nodes(tail, s);
-
-    while (r != null) { /* could be while(1), but let's be paranoid */
+    while (r != null) {
+        /*tex This could be |while(1)|, but let's be paranoid: */
         int clang, lhmin, rhmin, hmin;
         halfword hyf_font;
         halfword end_word = r;
@@ -897,7 +982,7 @@ void hnj_hyphenation(halfword head, halfword tail)
         assert(is_simple_character(wordstart));
         hyf_font = font(wordstart);
         if (hyphen_char(hyf_font) < 0) {
-            /* For backward compatibility: */
+            /*tex For backward compatibility we set: */
             hyf_font = 0;
         }
         clang = char_lang(wordstart);
@@ -947,19 +1032,28 @@ void hnj_hyphenation(halfword head, halfword tail)
             r = vlink(r);
         }
         if (explicit_hyphen == true) {
-            /* we are not at the start, so we only need to look ahead */
+            /*tex we are not at the start, so we only need to look ahead */
             halfword t = vlink(r) ;
             if ((automatic_hyphen_mode_par == 0 || automatic_hyphen_mode_par == 1) && (t != null) && ((type(t) == glyph_node) && (character(t) != ex_hyphen_char_par))) {
-                /* we have a word already but the next character may not be a hyphen too */
+                /*tex we have a word already but the next character may not be a hyphen too */
                 r = compound_word_break(r, char_lang(r));
+                if (compound_hyphen) {
+                    if (expstart == null) {
+                        expstart = wordstart;
+                    }
+                    explicit_hyphen = false;
+                    hy = uni2string(hy, '-');
+                    r = t;
+                    continue;
+                }
             } else {
-                /* we jump over the sequence of hyphens */
-                while ((t != null) && (type(t) == glyph_node) && (character(t) == ex_hyphen_char_par)) {
+                /*tex we jump over the sequence of hyphens */
+               while ((t != null) && (type(t) == glyph_node) && (character(t) == ex_hyphen_char_par)) {
                     r = t ;
                     t = vlink(r) ;
                 }
                 if (t == null) {
-                    /* we reached the end of the list and will quit the loop later */
+                    /*tex we reached the end of the list and will quit the loop later */
                     r = null;
                 }
             }
@@ -971,32 +1065,67 @@ void hnj_hyphenation(halfword head, halfword tail)
               && (lang = tex_languages[clang]) != NULL
            ) {
             *hy = 0;
+            /*tex
+                this is messy and nasty: we can have a word with a - in it which
+                is why we have two branches
+            */
             if (lang->exceptions != 0 && (replacement = hyphenation_exception(lang->exceptions, utf8word)) != NULL) {
-                /* handle the exception and go on to the next word */
-                do_exception(wordstart, r, replacement);
+                /*tex handle the exception and go on to the next word */
+                if (expstart == null) {
+                    do_exception(wordstart, r, replacement);
+                } else {
+                    do_exception(expstart,r,replacement);
+                }
                 free(replacement);
+            } else if (expstart != null) {
+                /*tex We're done already */
             } else if (lang->patterns != NULL) {
+                /*tex A safeguard, not needed but doesn't hurt either: */
+                valid_word = true;
                 left = wordstart;
                 for (i = lhmin; i > 1; i--) {
                     left = vlink(left);
+                    if (left == null) {
+                        valid_word = false;
+                        break ;
+                    }
                     while (!is_simple_character(left)) {
                         left = vlink(left);
+                        if (left == null) {
+                            valid_word = false;
+                            break ;
+                        }
                     }
-                    /* if (!left) break; */
-                    /* what is left overruns right .. a bit messy */
                 }
-                right = r;
-                for (i = rhmin; i > 0; i--) {
-                    right = alink(right);
-                    while (!is_simple_character(right)) {
+                if (valid_word) {
+                    right = r;
+                    if (right == left) {
+                        valid_word = false;
+                        break ;
+                    }
+                    for (i = rhmin; i > 0; i--) {
                         right = alink(right);
+                        if (right == null || right == left) {
+                            valid_word = false;
+                            break ;
+                        }
+                        while (!is_simple_character(right)) {
+                            right = alink(right);
+                            if (right == null || right == left) {
+                                valid_word = false;
+                                break ;
+                            }
+                        }
+                    }
+                    if (valid_word && expstart == null) {
+                        (void) hnj_hyphen_hyphenate(lang->patterns, wordstart, end_word, wordlen, left, right, &langdata);
+                    } else {
+                        /*tex nothing yet */
                     }
-                    /* if (!right) break; */
-                    /* what is right overruns left .. a bit messy */
                 }
-                (void) hnj_hyphen_hyphenate(lang->patterns, wordstart, end_word, wordlen, left, right, &langdata);
             }
         }
+        expstart = null ;
         explicit_hyphen = false;
         wordlen = 0;
         hy = utf8word;
@@ -1008,36 +1137,40 @@ void hnj_hyphenation(halfword head, halfword tail)
     vlink(tail) = save_tail1;
 }
 
-@ @c
 void new_hyphenation(halfword head, halfword tail)
 {
+    int i, top;
     register int callback_id = 0;
     if (head == null || vlink(head) == null)
         return;
     fix_node_list(head);
     callback_id = callback_defined(hyphenate_callback);
     if (callback_id > 0) {
+        top = lua_gettop(Luas);
         if (!get_callback(Luas, callback_id)) {
-            lua_pop(Luas, 2);
+            lua_settop(Luas, top);
             return;
         }
         nodelist_to_lua(Luas, head);
         nodelist_to_lua(Luas, tail);
-        if (lua_pcall(Luas, 2, 0, 0) != 0) {
+        if ((i=lua_pcall(Luas, 2, 0, 0)) != 0) {
             formatted_warning("hyphenation","bad specification: %s",lua_tostring(Luas, -1));
-            lua_pop(Luas, 2);
-            lua_error(Luas);
+            lua_settop(Luas, top);
+            luatex_error(Luas, (i == LUA_ERRRUN ? 0 : 1));
             return;
         }
-        lua_pop(Luas, 1);
+        lua_settop(Luas, top);
     } else if (callback_id == 0) {
         hnj_hyphenation(head, tail);
     }
 }
 
-@ Dumping and undumping languages.
+/*tex
+
+    Dumping and undumping languages:
+
+*/
 
-@c
 #define dump_string(a)                \
   if (a!=NULL) {                      \
       x = (int)strlen(a)+1;           \
@@ -1106,7 +1239,7 @@ static void undump_one_language(int i)
     lang->post_exhyphen_char = x;
     undump_int(x);
     lang->hyphenation_min = x;
-    /* patterns */
+    /*tex patterns */
     undump_int(x);
     if (x > 0) {
         s = xmalloc((unsigned) x);
@@ -1114,7 +1247,7 @@ static void undump_one_language(int i)
         load_patterns(lang, (unsigned char *) s);
         free(s);
     }
-    /* exceptions */
+    /*tex exceptions */
     undump_int(x);
     if (x > 0) {
         s = xmalloc((unsigned) x);
@@ -1137,21 +1270,26 @@ void undump_language_data(void)
     }
 }
 
-@ When \TeX\ has scanned `\.{\\hyphenation}', it calls on a procedure named
-|new_hyph_exceptions| to do the right thing.
+/*tex
+
+    When \TeX\ has scanned `\.{\\hyphenation}', it calls on a procedure named
+    |new_hyph_exceptions| to do the right thing.
+
+*/
 
-@c
 void new_hyph_exceptions(void)
-{                               /* enters new exceptions */
+{
     (void) scan_toks(false, true);
     load_tex_hyphenation(language_par, def_ref);
     flush_list(def_ref);
 }
 
-@ Similarly, when \TeX\ has scanned `\.{\\patterns}', it calls on a procedure named
-|new_patterns|.
+/*
+    Similarly, when \TeX\ has scanned `\.{\\patterns}', it calls on a procedure
+    named |new_patterns|.
+
+*/
 
-@c
 void new_patterns(void)
 {
     (void) scan_toks(false, true);
@@ -1159,10 +1297,14 @@ void new_patterns(void)
     flush_list(def_ref);
 }
 
-@ `\.{\\prehyphenchar}', sets the |pre_break| character, and `\.{\\posthyphenchar}' the
-|post_break| character. Their respective defaults are ascii hyphen ("-") and zero (nul).
+/*tex
+
+    `\.{\\prehyphenchar}', sets the |pre_break| character, and
+    `\.{\\posthyphenchar}' the |post_break| character. Their respective defaults
+    are ascii hyphen ("-") and zero (nul).
+
+*/
 
-@c
 void new_pre_hyphen_char(void)
 {
     scan_optional_equals();
@@ -1177,10 +1319,14 @@ void new_post_hyphen_char(void)
     set_post_hyphen_char(language_par, cur_val);
 }
 
-@ `\.{\\preexhyphenchar}', sets the |pre_break| character, and `\.{\\postexhyphenchar}' the
-|post_break| character. Their defaults are both zero (nul).
+/*tex
+
+    `\.{\\preexhyphenchar}', sets the |pre_break| character, and
+    `\.{\\postexhyphenchar}' the |post_break| character. Their defaults are both
+    zero (nul).
+
+*/
 
-@c
 void new_pre_exhyphen_char(void)
 {
     scan_optional_equals();
diff --git a/texk/web2c/luatexdir/lua/helpers.c b/texk/web2c/luatexdir/lua/helpers.c
new file mode 100644
index 000000000..e7be7a2c2
--- /dev/null
+++ b/texk/web2c/luatexdir/lua/helpers.c
@@ -0,0 +1,29 @@
+/*
+
+helpers.w
+
+Copyright 2017 LuaTeX team <bugs@@luatex.org>
+
+This file is part of LuaTeX.
+
+LuaTeX is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 2 of the License, or (at your
+option) any later version.
+
+LuaTeX is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+License for more details.
+
+You should have received a copy of the GNU General Public License along
+with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+
+*/
+
+/*tex
+
+We might move here some helpers common to code that are now in weird places,
+probably organized in texhelpers, luahelpers, pdfhelpers.
+
+*/
diff --git a/texk/web2c/luatexdir/lua/helpers.w b/texk/web2c/luatexdir/lua/helpers.w
deleted file mode 100644
index d12e47690..000000000
--- a/texk/web2c/luatexdir/lua/helpers.w
+++ /dev/null
@@ -1,26 +0,0 @@
-% helpers.w
-%
-% Copyright 2017 LuaTeX team <bugs@@luatex.org>
-%
-% This file is part of LuaTeX.
-%
-% LuaTeX is free software; you can redistribute it and/or modify it under
-% the terms of the GNU General Public License as published by the Free
-% Software Foundation; either version 2 of the License, or (at your
-% option) any later version.
-%
-% LuaTeX is distributed in the hope that it will be useful, but WITHOUT
-% ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-% FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
-% License for more details.
-%
-% You should have received a copy of the GNU General Public License along
-% with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
-
-@ We will move here some helpers common to code that are now in weird places,
-probably organized in texhelpers, luahelpers, pdfhelpers.
-
-
-
-@c
-/* to fill... */
diff --git a/texk/web2c/luatexdir/lua/llfslibext.c b/texk/web2c/luatexdir/lua/llfslibext.c
deleted file mode 100644
index eba5778df..000000000
--- a/texk/web2c/luatexdir/lua/llfslibext.c
+++ /dev/null
@@ -1,171 +0,0 @@
-/* llfslibext.c
-   
-   Copyright 2010-2011 Taco Hoekwater <taco@luatex.org>
-
-   This file is part of LuaTeX.
-
-   LuaTeX is free software; you can redistribute it and/or modify it under
-   the terms of the GNU General Public License as published by the Free
-   Software Foundation; either version 2 of the License, or (at your
-   option) any later version.
-
-   LuaTeX is distributed in the hope that it will be useful, but WITHOUT
-   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-   FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
-   License for more details.
-
-   You should have received a copy of the GNU General Public License along
-   with LuaTeX; if not, see <http://www.gnu.org/licenses/>. */
-
-#include "ptexlib.h"
-#include "lua/luatex-api.h"
-
-#include <kpathsea/c-stat.h>
-#include <kpathsea/c-dir.h>
-#include <time.h>
-
-
-#ifdef _WIN32
-#  include <windows.h>
-#else
-#endif
-
-#ifdef _WIN32
-
-static int get_short_name(lua_State * L)
-{
-    long length = 0;
-    TCHAR *buffer = NULL;
-    const char *lpszPath = luaL_checkstring(L, 1);
-    length = GetShortPathName(lpszPath, NULL, 0);
-    if (length == 0) {
-        lua_pushnil(L);
-        lua_pushfstring(L, "operating system error: %d", (int) GetLastError());
-        return 2;
-    }
-    buffer = (TCHAR *) xmalloc(length * sizeof(TCHAR));
-    length = GetShortPathName(lpszPath, buffer, length);
-    if (length == 0) {
-        lua_pushnil(L);
-        lua_pushfstring(L, "operating system error: %d", (int) GetLastError());
-        return 2;
-    }
-    lua_pushlstring(L, (const char *) buffer, (size_t) length);
-    return 1;
-}
-
-static int read_link(lua_State * L)
-{
-    lua_pushboolean(L, 0);
-    lua_pushliteral(L, "readlink not supported on this platform");
-    return 2;
-}
-
-#else
-
-static int pusherror(lua_State * L, const char *info)
-{
-    lua_pushnil(L);
-    if (info == NULL)
-        lua_pushstring(L, strerror(errno));
-    else
-        lua_pushfstring(L, "%s: %s", info, strerror(errno));
-    lua_pushinteger(L, errno);
-    return 3;
-}
-
-static int Preadlink(lua_State * L)
-{
-/** readlink(path) */
-    const char *path = luaL_checkstring(L, 1);
-    char *b = NULL;
-    int allocated = 128;
-    int n;
-    while (1) {
-        b = malloc(allocated);
-        if (!b)
-            return pusherror(L, path);
-        n = readlink(path, b, allocated);
-        if (n == -1) {
-            free(b);
-            return pusherror(L, path);
-        }
-        if (n < allocated)
-            break;
-        /* Not enough room, try bigger */
-        allocated *= 2;
-        free(b);
-    }
-    lua_pushlstring(L, b, n);
-    free(b);
-    return 1;
-}
-
-
-static int read_link(lua_State * L)
-{
-    return Preadlink(L);
-}
-
-static int get_short_name(lua_State * L __attribute__ ((unused)))
-{
-    /* simply do nothing */
-    return 1;
-}
-#endif
-
-
-/*
-** Get file information
-*/
-static int file_is_directory(lua_State * L)
-{
-    struct stat info;
-    const char *file = luaL_checkstring(L, 1);
-
-    if (stat(file, &info)) {
-        lua_pushnil(L);
-        lua_pushfstring(L, "cannot obtain information from file `%s'", file);
-        return 2;
-    }
-    if (S_ISDIR(info.st_mode))
-        lua_pushboolean(L, 1);
-    else
-        lua_pushboolean(L, 0);
-
-    return 1;
-}
-
-static int file_is_file(lua_State * L)
-{
-    struct stat info;
-    const char *file = luaL_checkstring(L, 1);
-
-    if (stat(file, &info)) {
-        lua_pushnil(L);
-        lua_pushfstring(L, "cannot obtain information from file `%s'", file);
-        return 2;
-    }
-    if (S_ISREG(info.st_mode))
-        lua_pushboolean(L, 1);
-    else
-        lua_pushboolean(L, 0);
-
-    return 1;
-}
-
-
-void open_lfslibext(lua_State * L)
-{
-
-    lua_getglobal(L, "lfs");
-    lua_pushcfunction(L, file_is_directory);
-    lua_setfield(L, -2, "isdir");
-    lua_pushcfunction(L, file_is_file);
-    lua_setfield(L, -2, "isfile");
-    lua_pushcfunction(L, read_link);
-    lua_setfield(L, -2, "readlink");
-    lua_pushcfunction(L, get_short_name);
-    lua_setfield(L, -2, "shortname");
-    lua_pop(L, 1);              /* pop the table */
-}
diff --git a/texk/web2c/luatexdir/lua/lpdfelib.c b/texk/web2c/luatexdir/lua/lpdfelib.c
new file mode 100644
index 000000000..31fad9f63
--- /dev/null
+++ b/texk/web2c/luatexdir/lua/lpdfelib.c
@@ -0,0 +1,1666 @@
+/*tex
+
+    This file will host the encapsulated \PDF\ support code used for inclusion
+    and access from \LUA.
+
+*/
+
+#include "ptexlib.h"
+
+/*tex
+
+    We need to avoid collision with some defines in |cpascal.h|.
+
+*/
+
+#undef lpdfelib_orig_input
+#undef lpdfelib_orig_output
+
+#ifdef input
+#define lpdfelib_orig_input input
+#undef input
+#endif
+
+#ifdef output
+#define lpdfelib_orig_output output
+#undef output
+#endif
+
+#include "luapplib/pplib.h"
+
+#include "image/epdf.h"
+
+#ifdef lpdfelib_orig_input
+#define input  lpdfelib_orig_input
+#undef lpdfelib_orig_input
+#endif
+
+#ifdef lpdfelib_orig_output
+#define output  lpdfelib_orig_output
+#undef lpdfelib_orig_output
+#endif
+
+#include "lua/luatex-api.h"
+
+/*tex
+
+    We start with some housekeeping. Dictionaries, arrays, streams and references
+    get userdata, while strings, names, integers, floats and booleans become regular
+    \LUA\ objects. We need to define a few metatable identifiers too.
+
+*/
+
+#define PDFE_METATABLE            "luatex.pdfe"
+#define PDFE_METATABLE_DICTIONARY "luatex.pdfe.dictionary"
+#define PDFE_METATABLE_ARRAY      "luatex.pdfe.array"
+#define PDFE_METATABLE_STREAM     "luatex.pdfe.stream"
+#define PDFE_METATABLE_REFERENCE  "luatex.pdfe.reference"
+
+typedef struct {
+    ppdoc *document;
+    boolean open;
+    boolean isfile;
+    char *memstream;
+    int pages;
+    int index;
+} pdfe_document ;
+
+typedef struct {
+    ppdict *dictionary;
+    ppref *ref;
+} pdfe_dictionary;
+
+typedef struct {
+    pparray *array;
+    ppref *ref;
+} pdfe_array;
+
+typedef struct {
+    ppstream *stream;
+    ppref *ref;
+    int decode;
+    int open;
+} pdfe_stream;
+
+typedef struct {
+    ppref *reference;
+} pdfe_reference;
+
+/*tex
+
+    We need to check if we have the right userdata. A similar warning is issued
+    when encounter a problem. We don't exit.
+
+*/
+
+static void pdfe_invalid_object_warning(const char * detail)
+{
+    formatted_warning("pdfe lib","lua <pdfe %s> expected",detail);
+}
+
+static pdfe_document *check_isdocument(lua_State * L, int n)
+{
+    pdfe_document *p = (pdfe_document *)lua_touserdata(L, n);
+    if (p != NULL && lua_getmetatable(L, n)) {
+        lua_get_metatablelua(luatex_pdfe);
+        if (!lua_rawequal(L, -1, -2)) {
+            p = NULL;
+        }
+        lua_pop(L, 2);
+        if (p != NULL) {
+            return p;
+        }
+    }
+    pdfe_invalid_object_warning("document");
+    return NULL;
+}
+
+static pdfe_dictionary *check_isdictionary(lua_State * L, int n)
+{
+    pdfe_dictionary *p = (pdfe_dictionary *)lua_touserdata(L, n);
+    if (p != NULL && lua_getmetatable(L, n)) {
+        lua_get_metatablelua(luatex_pdfe_dictionary);
+        if (!lua_rawequal(L, -1, -2)) {
+            p = NULL;
+        }
+        lua_pop(L, 2);
+        if (p != NULL) {
+            return p;
+        }
+    }
+    pdfe_invalid_object_warning("dictionary");
+    return NULL;
+}
+
+static pdfe_array *check_isarray(lua_State * L, int n)
+{
+    pdfe_array *p = (pdfe_array *)lua_touserdata(L, n);
+    if (p != NULL && lua_getmetatable(L, n)) {
+        lua_get_metatablelua(luatex_pdfe_array);
+        if (!lua_rawequal(L, -1, -2)) {
+            p = NULL;
+        }
+        lua_pop(L, 2);
+        if (p != NULL) {
+            return p;
+        }
+    }
+    pdfe_invalid_object_warning("array");
+    return NULL;
+}
+
+static pdfe_stream *check_isstream(lua_State * L, int n)
+{
+    pdfe_stream *p = (pdfe_stream *)lua_touserdata(L, n);
+    if (p != NULL && lua_getmetatable(L, n)) {
+        lua_get_metatablelua(luatex_pdfe_stream);
+        if (!lua_rawequal(L, -1, -2)) {
+            p = NULL;
+        }
+        lua_pop(L, 2);
+        if (p != NULL) {
+            return p;
+        }
+    }
+    pdfe_invalid_object_warning("stream");
+    return NULL;
+}
+
+static pdfe_reference *check_isreference(lua_State * L, int n)
+{
+    pdfe_reference *p = (pdfe_reference *)lua_touserdata(L, n);
+    if (p != NULL && lua_getmetatable(L, n)) {
+        lua_get_metatablelua(luatex_pdfe_reference);
+        if (!lua_rawequal(L, -1, -2)) {
+            p = NULL;
+        }
+        lua_pop(L, 2);
+        if (p != NULL) {
+            return p;
+        }
+    }
+    pdfe_invalid_object_warning("reference");
+    return NULL;
+}
+
+/*tex
+
+    Reporting the type of a userdata is just a sequence of tests till we find the
+    right one. We return nothing is it is no pdfe type.
+
+    \starttyping
+    t = pdfe.type(<pdfe document|dictionary|array|reference|stream>)
+    \stoptyping
+
+*/
+
+#define check_type(field,meta,name) do { \
+    lua_get_metatablelua(luatex_##meta); \
+    if (lua_rawequal(L, -1, -2)) { \
+        lua_pushstring(L,name); \
+        return 1; \
+    } \
+    lua_pop(L, 1); \
+} while (0)
+
+static int pdfelib_type(lua_State * L)
+{
+    void *p = lua_touserdata(L, 1);
+    if (p != NULL && lua_getmetatable(L, 1)) {
+        check_type(document,  pdfe,           "pdfe");
+        check_type(dictionary,pdfe_dictionary,"pdfe.dictionary");
+        check_type(array,     pdfe_array,     "pdfe.array");
+        check_type(reference, pdfe_reference, "pdfe.reference");
+        check_type(stream,    pdfe_stream,    "pdfe.stream");
+    }
+    return 0;
+}
+
+/*tex
+
+    The \type {tostring} metamethods are similar and report a pdfe type plus a
+    pointer value, as is rather usual in \LUA.
+
+*/
+
+#define define_to_string(field,what) \
+static int pdfelib_tostring_##field(lua_State * L) { \
+    pdfe_##field *p = check_is##field(L, 1); \
+    if (p != NULL) { \
+        lua_pushfstring(L, "<" what " %p>", (ppdoc *) p->field); \
+        return 1; \
+    } \
+    return 0; \
+}
+
+define_to_string(document,  "pdfe")
+define_to_string(dictionary,"pdfe.dictionary")
+define_to_string(array,     "pdfe.array")
+define_to_string(reference, "pdfe.reference")
+define_to_string(stream,    "pdfe.stream")
+
+/*tex
+
+    The pushers look rather similar. We have two variants, one that just pushes
+    the object, and another that also pushes some extra information.
+
+*/
+
+#define pdfe_push_dictionary do { \
+    pdfe_dictionary *d = (pdfe_dictionary *)lua_newuserdata(L, sizeof(pdfe_dictionary));	\
+    luaL_getmetatable(L, PDFE_METATABLE_DICTIONARY); \
+    lua_setmetatable(L, -2); \
+    d->dictionary = dictionary; \
+} while(0)
+
+static int pushdictionary(lua_State * L, ppdict *dictionary)
+{
+    if (dictionary != NULL) {
+        pdfe_push_dictionary;
+        lua_pushinteger(L,dictionary->size);
+        return 2;
+    }
+    return 0;
+}
+
+static int pushdictionaryonly(lua_State * L, ppdict *dictionary)
+{
+    if (dictionary != NULL) {
+        pdfe_push_dictionary;
+        return 1;
+    }
+    return 0;
+}
+
+#define pdfe_push_array do { \
+    pdfe_array *a = (pdfe_array *)lua_newuserdata(L, sizeof(pdfe_array));	\
+    luaL_getmetatable(L, PDFE_METATABLE_ARRAY); \
+    lua_setmetatable(L, -2); \
+    a->array = array; \
+  } while (0)
+
+static int pusharray(lua_State * L, pparray * array)
+{
+    if (array != NULL) {
+        pdfe_push_array;
+        lua_pushinteger(L,array->size);
+        return 2;
+    }
+    return 0;
+}
+
+static int pusharrayonly(lua_State * L, pparray * array)
+{
+    if (array != NULL) {
+        pdfe_push_array;
+        return 1;
+    }
+    return 0;
+}
+
+#define pdfe_push_stream do { \
+    pdfe_stream *s = (pdfe_stream *)lua_newuserdata(L, sizeof(pdfe_stream));	\
+    luaL_getmetatable(L, PDFE_METATABLE_STREAM); \
+    lua_setmetatable(L, -2); \
+    s->stream = stream; \
+    s->open = 0; \
+    s->decode = 0; \
+} while(0)
+
+static int pushstream(lua_State * L, ppstream * stream)
+{
+    if (stream != NULL) {
+        pdfe_push_stream;
+        if (pushdictionary(L, stream->dict) > 0)
+            return 3;
+        else
+            return 1;
+    }
+    return 0;
+}
+
+static int pushstreamonly(lua_State * L, ppstream * stream)
+{
+    if (stream != NULL) {
+        pdfe_push_stream;
+        if (pushdictionaryonly(L, stream->dict) > 0)
+            return 2;
+        else
+            return 1;
+    }
+    return 0;
+}
+
+#define pdfe_push_reference do { \
+    pdfe_reference *r = (pdfe_reference *)lua_newuserdata(L, sizeof(pdfe_reference));	\
+    luaL_getmetatable(L, PDFE_METATABLE_REFERENCE); \
+    lua_setmetatable(L, -2); \
+    r->reference = reference; \
+  } while (0)
+
+static int pushreference(lua_State * L, ppref * reference)
+{
+    if (reference != NULL) {
+        pdfe_push_reference;
+        lua_pushinteger(L,reference->number);
+        return 2;
+    }
+    return 0;
+}
+
+/*tex
+
+    The next function checks for the type and then pushes the matching data on
+    the stack.
+
+    \starttabulate[|c|l|l|l|]
+    \BC type       \BC meaning    \BC value            \BC detail \NC \NR
+    \NC \type {0}  \NC none       \NC nil              \NC \NC \NR
+    \NC \type {1}  \NC null       \NC nil              \NC \NC \NR
+    \NC \type {2}  \NC boolean    \NC boolean          \NC \NC \NR
+    \NC \type {3}  \NC boolean    \NC integer          \NC \NC \NR
+    \NC \type {4}  \NC number     \NC float            \NC \NC \NR
+    \NC \type {5}  \NC name       \NC string           \NC \NC \NR
+    \NC \type {6}  \NC string     \NC string           \NC type \NC \NR
+    \NC \type {7}  \NC array      \NC arrayobject      \NC size \NC \NR
+    \NC \type {8}  \NC dictionary \NC dictionaryobject \NC size \NC \NR
+    \NC \type {9}  \NC stream     \NC streamobject     \NC dictionary size \NC \NR
+    \NC \type {10} \NC reference  \NC integer          \NC \NC \NR
+    \LL
+    \stoptabulate
+
+    A name and string can be distinguished by the extra type value that a string
+    has.
+
+*/
+
+static int pushvalue(lua_State * L, ppobj *object)
+{
+    switch (object->type) {
+        case PPNONE:
+        case PPNULL:
+            lua_pushnil(L);
+            return 1;
+            break;
+        case PPBOOL:
+            lua_pushboolean(L,object->integer);
+            return 1;
+            break;
+        case PPINT:
+            lua_pushinteger(L, object-> integer);
+            return 1;
+            break;
+        case PPNUM:
+            lua_pushnumber(L, object->number);
+            return 1;
+            break;
+        case PPNAME:
+            lua_pushstring(L, (const char *) ppname_decoded(object->name));
+            return 1;
+            break;
+        case PPSTRING:
+            lua_pushlstring(L,(const char *) object->string, ppstring_size((void *)object->string));
+            lua_pushboolean(L, ppstring_hex((void *)object->string));
+            return 2;
+            break;
+        case PPARRAY:
+            return pusharray(L, object->array);
+            break;
+        case PPDICT:
+            return pushdictionary(L, object->dict);
+            break;
+        case PPSTREAM:
+            return pushstream(L, object->stream);
+            break;
+        case PPREF:
+            return pushreference(L, object->ref);
+            break;
+    }
+    return 0;
+}
+
+/*tex
+
+    We need to start someplace when we traverse a document's tree. There are
+    three places:
+
+    \starttyping
+    catalogdictionary = getcatalog(documentobject)
+    trailerdictionary = gettrailer(documentobject)
+    infodictionary    = getinfo   (documentobject)
+    \stoptyping
+
+*/
+
+static int pdfelib_getcatalog(lua_State * L)
+{
+    pdfe_document *p = check_isdocument(L, 1);
+    if (p == NULL)
+        return 0;
+    return pushdictionaryonly(L,ppdoc_catalog(p->document));
+}
+
+static int pdfelib_gettrailer(lua_State * L)
+{
+    pdfe_document *p = check_isdocument(L, 1);
+    if (p == NULL)
+        return 0;
+    return pushdictionaryonly(L,ppdoc_trailer(p->document));
+}
+
+static int pdfelib_getinfo(lua_State * L)
+{
+    pdfe_document *p = check_isdocument(L, 1);
+    if (p == NULL)
+        return 0;
+    return pushdictionaryonly(L,ppdoc_info(p->document));
+}
+
+/*tex
+
+    We have three more helpers.
+
+    \starttyping
+    [key,] type, value, detail = getfromdictionary(dictionaryobject,name|index)
+           type, value, detail = getfromarray     (arrayobject,index)
+    [key,] type, value, detail = getfromstream    (streamobject,name|index)
+    \stoptyping
+
+*/
+
+static int pdfelib_getfromarray(lua_State * L)
+{
+    pdfe_array *a = check_isarray(L, 1);
+    if (a != NULL) {
+        int index = luaL_checkint(L, 2) - 1;
+        if (index < a->array->size) {
+            ppobj *object = pparray_at(a->array,index);
+            lua_pushinteger(L,(int) object->type);
+            return 1 + pushvalue(L,object);
+        }
+    }
+    return 0;
+}
+
+static int pdfelib_getfromdictionary(lua_State * L)
+{
+    pdfe_dictionary *d = check_isdictionary(L, 1);
+    if (d != NULL) {
+        if (lua_type(L,2) == LUA_TSTRING) {
+            const char *name = luaL_checkstring(L, 2);
+            ppobj *object = ppdict_get_obj(d->dictionary,name);
+            if (object != NULL) {
+                lua_pushinteger(L,(int) object->type);
+                return 1 + pushvalue(L,object);
+            }
+        } else {
+            int index = luaL_checkint(L, 2) - 1;
+            if (index < d->dictionary->size) {
+                ppobj *object = ppdict_at(d->dictionary,index);
+                ppname key = ppdict_key(d->dictionary,index);
+                lua_pushstring(L,(const char *) key);
+                lua_pushinteger(L,(int) object->type);
+                return 2 + pushvalue(L,object);
+            }
+        }
+    }
+    return 0;
+}
+
+static int pdfelib_getfromstream(lua_State * L)
+{
+    pdfe_stream *s = (pdfe_stream *)lua_touserdata(L, 1);
+    if (s != NULL) {
+        ppdict *d = s->stream->dict;
+        if (lua_type(L,2) == LUA_TSTRING) {
+            const char *name = luaL_checkstring(L, 2);
+            ppobj *object = ppdict_get_obj(d,name);
+            if (object != NULL) {
+                lua_pushinteger(L,(int) object->type);
+                return 1 + pushvalue(L,object);
+            }
+        } else {
+            int index = luaL_checkint(L, 2) - 1;
+            if (index < d->size) {
+                ppobj *object = ppdict_at(d,index);
+                ppname key = ppdict_key(d,index);
+                lua_pushstring(L,(const char *) key);
+                lua_pushinteger(L,(int) object->type);
+                return 2 + pushvalue(L,object);
+            }
+        }
+    }
+    return 0;
+}
+
+/*tex
+
+    An indexed table with all entries in an array can be fetched with::
+
+    \starttyping
+    t = arraytotable(arrayobject)
+    \stoptyping
+
+    An hashed table with all entries in an dictionary can be fetched with::
+
+    \starttyping
+    t = dictionarytotable(arrayobject)
+    \stoptyping
+
+*/
+
+static void pdfelib_totable(lua_State * L, ppobj * object, int flat)
+{
+    int n = pushvalue(L,object);
+    if (flat && n < 2) {
+        return;
+    }
+    /* [value] [extra] [more] */
+    lua_createtable(L,n+1,0);
+    if (n == 1) {
+        /* value { nil, nil } */
+        lua_insert(L,-2);
+        /* { nil, nil } value */
+        lua_rawseti(L,-2,2);
+        /* { nil , value } */
+    } else if (n == 2) {
+        /* value extra { nil, nil, nil } */
+        lua_insert(L,-3);
+        /* { nil, nil, nil } value extra */
+        lua_rawseti(L,-3,3);
+        /* { nil, nil, extra } value */
+        lua_rawseti(L,-2,2);
+        /* { nil, value, extra } */
+    } else if (n == 3) {
+        /* value extra more { nil, nil, nil, nil } */
+        lua_insert(L,-4);
+        /* { nil, nil, nil, nil, nil } value extra more */
+        lua_rawseti(L,-4,4);
+        /* { nil, nil, nil, more } value extra */
+        lua_rawseti(L,-3,3);
+        /* { nil, nil, extra, more } value */
+        lua_rawseti(L,-2,2);
+        /* { nil, value, extra, more } */
+    }
+    lua_pushinteger(L,(int) object->type);
+    /* { nil, [value], [extra], [more] } type */
+    lua_rawseti(L,-2,1);
+    /* { type, [value], [extra], [more] } */
+    return;
+}
+
+static int pdfelib_arraytotable(lua_State * L)
+{
+    pdfe_array *a = check_isarray(L, 1);
+    if (a != NULL) {
+        int flat = lua_isboolean(L,2);
+        int i = 0;
+        lua_createtable(L,i,0);
+        /* table */
+        for (i=0;i<a->array->size;i++) {
+            ppobj *object = pparray_at(a->array,i);
+            pdfelib_totable(L,object,flat);
+            /* table { type, [value], [extra], [more] } */
+            lua_rawseti(L,-2,i+1);
+            /* table[i] = { type, [value], [extra], [more] } */
+        }
+        return 1;
+    }
+    return 0;
+}
+
+static int pdfelib_dictionarytotable(lua_State * L)
+{
+    pdfe_dictionary *d = check_isdictionary(L, 1);
+    if (d != NULL) {
+        int flat = lua_isboolean(L,2);
+        int i = 0;
+        lua_createtable(L,0,i);
+        /* table */
+        for (i=0;i<d->dictionary->size;i++) {
+            ppobj *object = ppdict_at(d->dictionary,i);
+            ppname key = ppdict_key(d->dictionary,i);
+            lua_pushstring(L,(const char *) key);
+            /* table key */
+            pdfelib_totable(L,object,flat);
+            /* table key { type, [value], [extra], [more] } */
+            lua_rawset(L,-3);
+            /* table[key] = { type, [value], [extra] } */
+        }
+        return 1;
+    }
+    return 0;
+}
+
+/*tex
+
+    All pages are collected with:
+
+    \starttyping
+    { { dict, size, objnum }, ... } = pagestotable(document)
+    \stoptyping
+
+*/
+
+static int pdfelib_pagestotable(lua_State * L)
+{
+    pdfe_document *p = check_isdocument(L, 1);
+    if (p != NULL) {
+        ppdoc *d = p->document;
+        ppref *r = NULL;
+        int i = 0;
+        lua_createtable(L,ppdoc_page_count(d),0);
+        /* pages[1..n] */
+        for (r = ppdoc_first_page(d), i = 1; r != NULL; r = ppdoc_next_page(d), ++i) {
+            lua_createtable(L,3,0);
+            pushdictionary(L,ppref_obj(r)->dict);
+            /* table dictionary n */
+            lua_rawseti(L,-3,2);
+            /* table dictionary */
+            lua_rawseti(L,-2,1);
+            /* table */
+            lua_pushinteger(L,r->number);
+            /* table reference */
+            lua_rawseti(L,-2,3);
+            /* table */
+            lua_rawseti(L,-2,i);
+            /* pages[i] = { dictionary, size, objnum } */
+        }
+        return 1;
+    }
+    return 0;
+}
+
+/*tex
+
+    Streams can be fetched on one go:
+
+    \starttyping
+    string, n = readwholestream(streamobject,decode)
+    \stoptyping
+
+*/
+
+static int pdfelib_readwholestream(lua_State * L)
+{
+    pdfe_stream *s = check_isstream(L, 1);
+    if (s != NULL) {
+        uint8_t *b = NULL;
+        int decode = 0;
+        size_t n = 0;
+        if (s->open > 0) {
+            ppstream_done(s->stream);
+            s->open = 0;
+            s->decode = 0;
+        }
+        if (lua_gettop(L) > 1 && lua_isboolean(L, 2)) {
+            decode = lua_toboolean(L, 2);
+        }
+        b = ppstream_all(s->stream,&n,decode);
+        lua_pushlstring(L, (const char *) b, n);
+        lua_pushinteger(L, (int) n);
+        ppstream_done(s->stream);
+        return 2;
+    }
+    return 0;
+}
+
+/*tex
+
+    Alternatively streams can be fetched stepwise:
+
+    okay = openstream(streamobject,[decode])
+    string, n = readfromstream(streamobject)
+    closestream(streamobject)
+
+*/
+
+static int pdfelib_openstream(lua_State * L)
+{
+    pdfe_stream *s = check_isstream(L, 1);
+    if (s != NULL) {
+        if (s->open == 0) {
+            if (lua_gettop(L) > 1) {
+                s->decode = lua_isboolean(L, 2);
+            }
+            s->open = 1;
+        }
+        lua_pushboolean(L,1);
+        return 1;
+    }
+    return 0;
+}
+
+static int pdfelib_closestream(lua_State * L)
+{
+    pdfe_stream *s = check_isstream(L, 1);
+    if (s != NULL) {
+        if (s->open >0) {
+            ppstream_done(s->stream);
+            s->open = 0;
+            s->decode = 0;
+        }
+    }
+    return 0;
+}
+
+static int pdfelib_readfromstream(lua_State * L)
+{
+    pdfe_stream *s = check_isstream(L, 1);
+    if (s != NULL) {
+        size_t n = 0;
+        uint8_t *d = NULL;
+        if (s->open == 1) {
+            d = ppstream_first(s->stream,&n,s->decode);
+            s->open = 2;
+        } else if (s->open == 2) {
+            d = ppstream_next(s->stream,&n);
+        } else {
+            return 0;
+        }
+        lua_pushlstring(L, (const char *) d, n);
+        lua_pushinteger(L, (int) n);
+        return 2;
+    }
+    return 0;
+}
+
+/*tex
+
+    There are two methods for opening a document: files and strings.
+
+    \starttyping
+    documentobject = open(filename)
+    documentobject = new(string,length)
+    \stoptyping
+
+    Closing happens with:
+
+    \starttyping
+    close(documentobject)
+    \stoptyping
+
+    When the \type {new} function gets a peudo filename as third argument,
+    no user data will be created but the stream is accessible as image.
+
+*/
+
+static int pdfelib_open(lua_State * L)
+{
+    const char *filename = luaL_checkstring(L, 1);
+    ppdoc *d = ppdoc_load(filename);
+    if (d == NULL) {
+        formatted_warning("pdfe lib","no valid pdf file '%s'",filename);
+    } else {
+        pdfe_document *p = (pdfe_document *) lua_newuserdata(L, sizeof(pdfe_document));
+        luaL_getmetatable(L, PDFE_METATABLE);
+        lua_setmetatable(L, -2);
+        p->document = d;
+        p->open = true;
+        p->isfile = true;
+        p->memstream = NULL;
+        return 1;
+    }
+    return 0;
+}
+
+static int pdfelib_new(lua_State * L)
+{
+    const char *docstream = NULL;
+    char *memstream = NULL ;
+    unsigned long long streamsize;
+    switch (lua_type(L, 1)) {
+        case LUA_TSTRING:
+            /* stream as Lua string */
+            docstream = luaL_checkstring(L, 1);
+            break;
+        case LUA_TLIGHTUSERDATA:
+            /* stream as sequence of bytes */
+            docstream = (const char *) lua_touserdata(L, 1);
+            break;
+        default:
+            luaL_error(L, "bad <pdfe> argument: string or lightuserdata expected");
+            break;
+    }
+    if (docstream == NULL) {
+        luaL_error(L, "bad <pdfe> document");
+    }
+    /* size of the stream */
+    streamsize = (unsigned long long) luaL_checkint(L, 2);
+    memstream = xmalloc((unsigned) (streamsize + 1));
+    if (! memstream) {
+        luaL_error(L, "no room for <pdfe> stream");
+    }
+    memcpy(memstream, docstream, (streamsize + 1));
+    memstream[streamsize]='\0';
+    if (lua_gettop(L) == 2) {
+        /* we stay at the lua end */
+        ppdoc *d = ppdoc_mem(memstream, streamsize);
+        if (d == NULL) {
+            normal_warning("pdfe lib","no valid pdf mem stream");
+        } else {
+            pdfe_document *p = (pdfe_document *) lua_newuserdata(L, sizeof(pdfe_document));
+            luaL_getmetatable(L, PDFE_METATABLE);
+            lua_setmetatable(L, -2);
+            p->document = d;
+            p->open = true;
+            p->isfile = false;
+            p->memstream = memstream;
+            return 1;
+        }
+    } else {
+        /* pseudo file name */
+        PdfDocument *pdf_doc;
+        const char *file_id = luaL_checkstring(L, 3);
+        if (file_id == NULL) {
+            luaL_error(L, "<pdfe> stream has an invalid id");
+        }
+        if (strlen(file_id) > STREAM_FILE_ID_LEN ) {
+            /* a limit to the length of the string */
+            luaL_error(L, "<pdfe> stream has a too long id");
+        }
+        pdf_doc = refMemStreamPdfDocument(memstream, streamsize, file_id);
+        if (pdf_doc != NULL) {
+            lua_pushstring(L,pdf_doc->file_path);
+            return 1;
+        } else {
+            /* pplib does this: xfree(memstream); */
+        }
+    }
+    return 0;
+}
+
+/*
+
+    There is no garbage collection needed as the library itself manages the
+    objects. Normally objects don't take much space. Streams use buffers so (I
+    assume) that they are not persistent. The only collector is in the parent
+    object (the document).
+
+*/
+
+static int pdfelib_free(lua_State * L)
+{
+    pdfe_document *p = check_isdocument(L, 1);
+    if (p != NULL && p->open) {
+        if (p->document != NULL) {
+            ppdoc_free(p->document);
+            p->document = NULL;
+        }
+        if (p->memstream != NULL) {
+         /* pplib does this: xfree(p->memstream); */
+            p->memstream = NULL;
+        }
+        p->open = false;
+    }
+    return 0;
+}
+
+static int pdfelib_close(lua_State * L)
+{
+    return pdfelib_free(L);
+}
+
+/*tex
+
+    A document is can be uncrypted with:
+
+    \starttyping
+    status = unencrypt(documentobject,user,owner)
+    \stoptyping
+
+    Instead of a password \type {nil} can be passed, so there are three possible
+    useful combinations.
+
+*/
+
+static int pdfelib_unencrypt(lua_State * L)
+{
+    pdfe_document *p = check_isdocument(L, 1);
+    if (p != NULL) {
+        size_t u = 0;
+        size_t o = 0;
+        const char* user = NULL;
+        const char* owner = NULL;
+        int top = lua_gettop(L);
+        if (top > 1) {
+            if (lua_type(L,2) == LUA_TSTRING) {
+                user = lua_tolstring(L, 2, &u);
+            } else {
+                /*tex we're not too picky but normally it will be nil or false */
+            }
+            if (top > 2) {
+                if (lua_type(L,3) == LUA_TSTRING) {
+                    owner = lua_tolstring(L, 3, &o);
+                } else {
+                    /*tex we're not too picky but normally it will be nil or false */
+                }
+            }
+            lua_pushinteger(L, (int) ppdoc_crypt_pass(p->document,user,u,owner,o));
+            return 1;
+        }
+    }
+    lua_pushinteger(L, (int) PPCRYPT_FAIL);
+    return 1;
+}
+
+/*tex
+
+    There are a couple of ways to get information about the document:
+
+    \starttyping
+    n             = getsize       (documentobject)
+    major, minor  = getversion    (documentobject)
+    status        = getstatus     (documentobject)
+    n             = getnofobjects (documentobject)
+    n             = getnofpages   (documentobject)
+    bytes, waste  = getmemoryusage(documentobject)
+    \stoptyping
+
+*/
+
+static int pdfelib_getsize(lua_State * L)
+{
+    pdfe_document *p = check_isdocument(L, 1);
+    if (p == NULL)
+        return 0;
+    lua_pushinteger(L,(int) ppdoc_file_size(p->document));
+    return 1;
+}
+
+
+static int pdfelib_getversion(lua_State * L)
+{
+    pdfe_document *p = check_isdocument(L, 1);
+    if (p == NULL) {
+        return 0;
+    } else {
+        int minor;
+        int major = ppdoc_version_number(p->document, &minor);
+        lua_pushinteger(L,(int) major);
+        lua_pushinteger(L,(int) minor);
+        return 2;
+    }
+}
+
+static int pdfelib_getstatus(lua_State * L)
+{
+    pdfe_document *p = check_isdocument(L, 1);
+    if (p == NULL)
+        return 0;
+    lua_pushinteger(L,(int) ppdoc_crypt_status(p->document));
+    return 1;
+}
+
+static int pdfelib_getnofobjects(lua_State * L)
+{
+    pdfe_document *p = check_isdocument(L, 1);
+    if (p == NULL)
+        return 0;
+    lua_pushinteger(L,(int) ppdoc_objects(p->document));
+    return 1;
+}
+
+static int pdfelib_getnofpages(lua_State * L)
+{
+    pdfe_document *p = check_isdocument(L, 1);
+    if (p == NULL)
+        return 0;
+    lua_pushinteger(L,(int) ppdoc_page_count(p->document));
+    return 1;
+}
+
+static int pdfelib_getmemoryusage(lua_State * L)
+{
+    pdfe_document *p = check_isdocument(L, 1);
+    if (p != NULL) {
+        size_t w = 0;
+        size_t m = ppdoc_memory(p->document,&w);
+        lua_pushinteger(L,(int) m);
+        lua_pushinteger(L,(int) w);
+        return 2;
+    }
+    return 0;
+}
+
+/*
+    A specific page dictionary can be filtered with the next command. So, there
+    is no need to parse the document page tree (with these \type {kids} arrays).
+
+    \starttyping
+    dictionaryobject = getpage(documentobject,pagenumber)
+    \stoptyping
+
+*/
+
+static int pushpage(lua_State * L, ppdoc * d, int page)
+{
+    if (page <= 0 || page > ppdoc_page_count(d)) {
+        return 0;
+    } else {
+        ppref *pp = ppdoc_page(d,page);
+        return pushdictionaryonly(L, ppref_obj(pp)->dict);
+    }
+}
+
+static int pdfelib_getpage(lua_State * L)
+{
+    pdfe_document *p = check_isdocument(L, 1);
+    if (p == NULL) {
+        return 0;
+    } else {
+        return pushpage(L, p->document, luaL_checkint(L, 2));
+    }
+}
+
+static int pushpages(lua_State * L, ppdoc * d)
+{
+    int i = 0;
+    ppref *r;
+    lua_createtable(L,ppdoc_page_count(d),0);
+    /* pages[1..n] */
+    for (r = ppdoc_first_page(d), i = 1; r != NULL; r = ppdoc_next_page(d), ++i) {
+        pushdictionaryonly(L,ppref_obj(r)->dict);
+        lua_rawseti(L,-2,i);
+    }
+    return 1 ;
+}
+
+static int pdfelib_getpages(lua_State * L)
+{
+    pdfe_document *p = check_isdocument(L, 1);
+    if (p == NULL) {
+        return 0;
+    } else {
+        return pushpages(L, p->document);
+    }
+}
+
+/*tex
+
+    The boundingbox (\type {MediaBox) and similar boxes can be available in a
+    (page) doctionary but also in a parent object. Therefore a helper is
+    available that does the (backtracked) lookup.
+
+    \starttyping
+    { lx, ly, rx, ry } = getbox(dictionaryobject)
+    \stoptyping
+
+*/
+
+static int pdfelib_getbox(lua_State * L)
+{
+    if (lua_gettop(L) > 1 && lua_type(L,2) == LUA_TSTRING) {
+        pdfe_dictionary *p = check_isdictionary(L, 1);
+        if (p != NULL) {
+            const char *key = lua_tostring(L,2);
+            pprect box;
+            pprect *r;
+            box.lx = box.rx = box.ly = box.ry = 0;
+            r = ppdict_get_box(p->dictionary,key,&box);
+            if (r != NULL) {
+                lua_createtable(L,4,0);
+                lua_pushnumber(L,r->lx);
+                lua_rawseti(L,-2,1);
+                lua_pushnumber(L,r->ly);
+                lua_rawseti(L,-2,2);
+                lua_pushnumber(L,r->rx);
+                lua_rawseti(L,-2,3);
+                lua_pushnumber(L,r->ry);
+                lua_rawseti(L,-2,4);
+                return 1;
+            }
+        }
+    }
+    return 0;
+}
+
+/*tex
+
+    This one is needed when you use the detailed getters and run into an
+    object reference. The regular getters resolve this automatically.
+
+    \starttyping
+    [dictionary|array|stream]object = getfromreference(referenceobject)
+    \stoptyping
+
+*/
+
+static int pdfelib_getfromreference(lua_State * L)
+{
+    pdfe_reference *r = check_isreference(L, 1);
+    if (r != NULL) {
+        ppobj *o = ppref_obj(r->reference);
+        lua_pushinteger(L,o->type);
+        return 1 + pushvalue(L,o);
+    }
+    return 0;
+}
+
+/*tex
+
+    Here are some convenient getters:
+
+    \starttyping
+    <string>         = getstring    (array|dict|ref,index|key)
+    <integer>        = getinteger   (array|dict|ref,index|key)
+    <number>         = getnumber    (array|dict|ref,index|key)
+    <boolan>         = getboolean   (array|dict|ref,index|key)
+    <string>         = getname      (array|dict|ref,index|key)
+    <dictionary>     = getdictionary(array|dict|ref,index|key)
+    <array>          = getarray     (array|dict|ref,index|key)
+    <stream>, <dict> = getstream    (array|dict|ref,index|key)
+    \stoptyping
+
+    We report issues when reasonable but are silent when it makes sense. We don't
+    error on this because we expect the user code to act reasonable on a return
+    value.
+
+*/
+
+#define pdfelib_get_value_check_1 do { \
+    if (p == NULL) { \
+        if (t == LUA_TSTRING) { \
+            normal_warning("pdfe lib","lua <pdfe dictionary> expected"); \
+        } else if (t == LUA_TNUMBER) { \
+            normal_warning("pdfe lib","lua <pdfe array> expected"); \
+        } else { \
+          normal_warning("pdfe lib","invalid arguments"); \
+        } \
+        return 0; \
+    } else if (! lua_getmetatable(L, 1)) { \
+        normal_warning("pdfe lib","first argument should be a <pde array> or <pde dictionary>"); \
+    } \
+} while (0)
+
+#define pdfelib_get_value_check_2 \
+    normal_warning("pdfe lib","second argument should be integer or string");
+
+/*tex
+
+    The direct fetcher returns the result or |NULL| when there is nothing
+    found.
+
+*/
+
+#define pdfelib_get_value_direct(get_d,get_a) do {                      \
+    int t = lua_type(L,2);                                              \
+    void *p = lua_touserdata(L, 1);                                     \
+    pdfelib_get_value_check_1;                                          \
+    if (t == LUA_TSTRING) {                                             \
+        const char *key = lua_tostring(L,-2);                           \
+        lua_get_metatablelua(luatex_pdfe_dictionary);                   \
+        if (lua_rawequal(L, -1, -2)) {                                  \
+            value = get_d(((pdfe_dictionary *) p)->dictionary, key);    \
+        } else {                                                        \
+            lua_pop(L,1);                                               \
+            lua_get_metatablelua(luatex_pdfe_reference);                \
+            if (lua_rawequal(L, -1, -2)) {                              \
+                ppobj * o = ppref_obj((ppref *) (((pdfe_reference *) p)->reference)); \
+                if (o != NULL && o->type == PPDICT) {                   \
+                    value = get_d((ppdict *)o->dict, key);              \
+                }                                                       \
+            }                                                           \
+        }                                                               \
+    } else if (t == LUA_TNUMBER) {                                      \
+        size_t index = lua_tointeger(L,-2);                             \
+        lua_get_metatablelua(luatex_pdfe_array);                        \
+        if (lua_rawequal(L, -1, -2)) {                                  \
+            value = get_a(((pdfe_array *) p)->array, index);            \
+        } else {                                                        \
+            lua_pop(L,1);                                               \
+            lua_get_metatablelua(luatex_pdfe_reference);                \
+            if (lua_rawequal(L, -1, -2)) {                              \
+                ppobj * o = ppref_obj((ppref *) (((pdfe_reference *) p)->reference)); \
+                if (o != NULL && o->type == PPARRAY) {                  \
+                    value = get_a((pparray *) o->array, index);         \
+                }                                                       \
+            }                                                           \
+        }                                                               \
+    } else {                                                            \
+        pdfelib_get_value_check_2;                                      \
+    }                                                                   \
+} while (0)
+
+/*tex
+
+    The indirect fetcher passes a pointer to the target variable and returns
+    success state.
+
+*/
+
+#define pdfelib_get_value_indirect(get_d,get_a) do {                        \
+    int t = lua_type(L,2);                                                  \
+    void *p = lua_touserdata(L, 1);                                         \
+    pdfelib_get_value_check_1;                                              \
+    if (t == LUA_TSTRING) {                                                 \
+        const char *key = lua_tostring(L,-2);                               \
+        lua_get_metatablelua(luatex_pdfe_dictionary);                       \
+        if (lua_rawequal(L, -1, -2)) {                                      \
+            okay = get_d(((pdfe_dictionary *) p)->dictionary, key, &value); \
+        } else {                                                            \
+            lua_pop(L,1);                                                   \
+            lua_get_metatablelua(luatex_pdfe_reference);                    \
+            if (lua_rawequal(L, -1, -2)) {                                  \
+                ppobj * o = ppref_obj((ppref *) (((pdfe_reference *) p)->reference)); \
+                if (o != NULL && o->type == PPDICT)                         \
+                    okay = get_d(o->dict, key, &value);                     \
+            }                                                               \
+        }                                                                   \
+    } else if (t == LUA_TNUMBER) {                                          \
+        size_t index = lua_tointeger(L,-2);                                 \
+        lua_get_metatablelua(luatex_pdfe_array);                            \
+        if (lua_rawequal(L, -1, -2)) {                                      \
+            okay = get_a(((pdfe_array *) p)->array, index, &value);         \
+        } else {                                                            \
+            lua_pop(L,1);                                                   \
+            lua_get_metatablelua(luatex_pdfe_reference);                    \
+            if (lua_rawequal(L, -1, -2)) {                                  \
+                ppobj * o = ppref_obj((ppref *) (((pdfe_reference *) p)->reference)); \
+                if (o != NULL && o->type == PPARRAY)                        \
+                    okay = get_a(o->array, index, &value);                  \
+            }                                                               \
+        }                                                                   \
+    } else {                                                                \
+        pdfelib_get_value_check_2;                                          \
+    }                                                                       \
+} while (0)
+
+static int pdfelib_getstring(lua_State * L)
+{
+    if (lua_gettop(L) > 1) {
+        ppstring value = NULL;
+        pdfelib_get_value_direct(ppdict_rget_string,pparray_rget_string);
+        if (value != NULL) {
+            lua_pushstring(L,(const char *) value);
+            return 1;
+        }
+    }
+    return 0;
+}
+
+static int pdfelib_getinteger(lua_State * L)
+{
+    if (lua_gettop(L) > 1) {
+        ppint value = 0;
+        int okay = 0;
+        pdfelib_get_value_indirect(ppdict_rget_int,pparray_rget_int);
+        if (okay) {
+            lua_pushinteger(L,(int) value);
+            return 1;
+        }
+    }
+    return 0;
+}
+
+static int pdfelib_getnumber(lua_State * L)
+{
+    if (lua_gettop(L) > 1) {
+        ppnum value = 0;
+        int okay = 0;
+        pdfelib_get_value_indirect(ppdict_rget_num,pparray_rget_num);
+        if (okay) {
+            lua_pushnumber(L,value);
+            return 1;
+        }
+    }
+    return 0;
+}
+
+static int pdfelib_getboolean(lua_State * L)
+{
+    if (lua_gettop(L) > 1) {
+        int value = 0;
+        int okay = 0;
+        pdfelib_get_value_indirect(ppdict_rget_bool,pparray_rget_bool);
+        if (okay) {
+            lua_pushboolean(L,value);
+            return 1;
+        }
+    }
+    return 0;
+}
+
+static int pdfelib_getname(lua_State * L)
+{
+    if (lua_gettop(L) > 1) {
+        ppname value = NULL;
+        pdfelib_get_value_direct(ppdict_rget_name,pparray_rget_name);
+        if (value != NULL) {
+            lua_pushstring(L,(const char *) ppname_decoded(value));
+            return 1;
+        }
+    }
+    return 0;
+}
+
+static int pdfelib_getdictionary(lua_State * L)
+{
+    if (lua_gettop(L) > 1) {
+        ppdict * value = NULL;
+        pdfelib_get_value_direct(ppdict_rget_dict,pparray_rget_dict);
+        if (value != NULL) {
+            return pushdictionaryonly(L,value);
+        }
+    }
+    return 0;
+}
+
+static int pdfelib_getarray(lua_State * L)
+{
+    if (lua_gettop(L) > 1) {
+        pparray * value = NULL;
+        pdfelib_get_value_direct(ppdict_rget_array,pparray_rget_array);
+        if (value != NULL) {
+            return pusharrayonly(L,value);
+        }
+    }
+    return 0;
+}
+
+static int pdfelib_getstream(lua_State * L)
+{
+    if (lua_gettop(L) > 1) {
+        ppobj * value = NULL;
+        pdfelib_get_value_direct(ppdict_rget_obj,pparray_rget_obj);
+        if (value != NULL && value->type == PPSTREAM) {
+            return pushstreamonly(L,(ppstream *) value->stream);
+        }
+    }
+    return 0;
+}
+
+/*tex
+
+    The generic pushed that does a similar job as the previous getters acts upon
+    the type.
+
+*/
+
+static int pdfelib_pushvalue(lua_State * L, ppobj *object)
+{
+    switch (object->type) {
+        case PPNONE:
+        case PPNULL:
+            lua_pushnil(L);
+            break;
+        case PPBOOL:
+            lua_pushboolean(L, object->integer);
+            break;
+        case PPINT:
+            lua_pushinteger(L, object->integer);
+            break;
+        case PPNUM:
+            lua_pushnumber(L, object->number);
+            break;
+        case PPNAME:
+            lua_pushstring(L, (const char *) ppname_decoded(object->name));
+            break;
+        case PPSTRING:
+            lua_pushlstring(L,(const char *) object->string, ppstring_size((void *)object->string));
+            break;
+        case PPARRAY:
+            return pusharrayonly(L, object->array);
+            break;
+        case PPDICT:
+            return pushdictionary(L, object->dict);
+            break;
+        case PPSTREAM:
+            return pushstream(L, object->stream);
+            break;
+        case PPREF:
+            pushreference(L, object->ref);
+            break;
+        default:
+            lua_pushnil(L);
+            break;
+    }
+    return 1;
+}
+
+/*tex
+
+    Finally we arrived at the acessors for the userdata objects. The use
+    previously defined helpers.
+
+*/
+
+static int pdfelib_access(lua_State * L)
+{
+    if (lua_type(L,2) == LUA_TSTRING) {
+        pdfe_document *p = (pdfe_document *)lua_touserdata(L, 1);
+        const char *s = lua_tostring(L,2);
+        if (lua_key_eq(s,catalog) || lua_key_eq(s,Catalog)) {
+            return pushdictionaryonly(L,ppdoc_catalog(p->document));
+        } else if (lua_key_eq(s,info) || lua_key_eq(s,Info)) {
+            return pushdictionaryonly(L,ppdoc_info(p->document));
+        } else if (lua_key_eq(s,trailer) || lua_key_eq(s,Trailer)) {
+            return pushdictionaryonly(L,ppdoc_trailer(p->document));
+        } else if (lua_key_eq(s,pages) || lua_key_eq(s,Pages)) {
+            return pushpages(L,p->document);
+        }
+    }
+    return 0;
+}
+
+static int pdfelib_array_access(lua_State * L)
+{
+    if (lua_type(L,2) == LUA_TNUMBER) {
+        pdfe_array *p = (pdfe_array *)lua_touserdata(L, 1);
+        ppint index = lua_tointeger(L,2) - 1;
+        ppobj *o = pparray_rget_obj(p->array,index);
+        if (o != NULL) {
+            return pdfelib_pushvalue(L,o);
+        }
+    }
+    return 0;
+}
+
+static int pdfelib_dictionary_access(lua_State * L)
+{
+    pdfe_dictionary *p = (pdfe_dictionary *)lua_touserdata(L, 1);
+    if (lua_type(L,2) == LUA_TSTRING) {
+        const char *key = lua_tostring(L,2);
+        ppobj *o = ppdict_rget_obj(p->dictionary,key);
+        if (o != NULL) {
+            return pdfelib_pushvalue(L,o);
+        }
+    } else if (lua_type(L,2) == LUA_TNUMBER) {
+        ppint index = lua_tointeger(L,2) - 1;
+        ppobj *o = ppdict_at(p->dictionary,index);
+        if (o != NULL) {
+            return pdfelib_pushvalue(L,o);
+        }
+    }
+    return 0;
+}
+
+static int pdfelib_stream_access(lua_State * L)
+{
+    pdfe_stream *p = (pdfe_stream *)lua_touserdata(L, 1);
+    if (lua_type(L,2) == LUA_TSTRING) {
+        const char *key = lua_tostring(L,2);
+        ppobj *o = ppdict_rget_obj(p->stream->dict,key);
+        if (o != NULL) {
+            return pdfelib_pushvalue(L,o);
+        }
+    } else if (lua_type(L,2) == LUA_TNUMBER) {
+        ppint index = lua_tointeger(L,2) - 1;
+        ppobj *o = ppdict_at(p->stream->dict,index);
+        if (o != NULL) {
+            return pdfelib_pushvalue(L,o);
+        }
+    }
+    return 0;
+}
+
+/*tex
+
+    The length metamethods are defined last.
+
+*/
+
+static int pdfelib_array_size(lua_State * L)
+{
+    pdfe_array *p = (pdfe_array *)lua_touserdata(L, 1);
+    lua_pushinteger(L,p->array->size);
+    return 1;
+}
+
+static int pdfelib_dictionary_size(lua_State * L)
+{
+    pdfe_dictionary *p = (pdfe_dictionary *)lua_touserdata(L, 1);
+    lua_pushinteger(L,p->dictionary->size);
+    return 1;
+}
+
+static int pdfelib_stream_size(lua_State * L)
+{
+    pdfe_stream *p = (pdfe_stream *)lua_touserdata(L, 1);
+    lua_pushinteger(L,p->stream->dict->size);
+    return 1;
+}
+
+/*tex
+
+    We now initialize the main interface. We might aa few more
+    informational helpers but this is it.
+
+*/
+
+static const struct luaL_Reg pdfelib[] = {
+    /* management */
+    { "type",                    pdfelib_type },
+    { "open",                    pdfelib_open },
+    { "new",                     pdfelib_new },
+    { "close",                   pdfelib_close },
+    { "unencrypt",               pdfelib_unencrypt },
+    /* statistics */
+    { "getversion",              pdfelib_getversion },
+    { "getstatus",               pdfelib_getstatus },
+    { "getsize",                 pdfelib_getsize },
+    { "getnofobjects",           pdfelib_getnofobjects },
+    { "getnofpages",             pdfelib_getnofpages },
+    { "getmemoryusage",          pdfelib_getmemoryusage },
+    /* getters */
+    { "getcatalog",              pdfelib_getcatalog },
+    { "gettrailer",              pdfelib_gettrailer },
+    { "getinfo",                 pdfelib_getinfo },
+    { "getpage",                 pdfelib_getpage },
+    { "getpages",                pdfelib_getpages },
+    { "getbox",                  pdfelib_getbox },
+    { "getfromreference",        pdfelib_getfromreference },
+    { "getfromdictionary",       pdfelib_getfromdictionary },
+    { "getfromarray",            pdfelib_getfromarray },
+    { "getfromstream",           pdfelib_getfromstream },
+    /* collectors */
+    { "dictionarytotable",       pdfelib_dictionarytotable },
+    { "arraytotable",            pdfelib_arraytotable },
+    { "pagestotable",            pdfelib_pagestotable },
+    /* more getters */
+    { "getstring",               pdfelib_getstring },
+    { "getinteger",              pdfelib_getinteger },
+    { "getnumber",               pdfelib_getnumber },
+    { "getboolean",              pdfelib_getboolean },
+    { "getname",                 pdfelib_getname },
+    { "getdictionary",           pdfelib_getdictionary },
+    { "getarray",                pdfelib_getarray },
+    { "getstream",               pdfelib_getstream },
+    /* streams */
+    { "readwholestream",         pdfelib_readwholestream },
+    /* not really needed */
+    { "openstream",              pdfelib_openstream },
+    { "readfromstream",          pdfelib_readfromstream },
+    { "closestream",             pdfelib_closestream },
+    /* done */
+    { NULL,                      NULL}
+};
+
+/*tex
+
+    The user data metatables are defined as follows. Watch how only the
+    document needs a garbage collector.
+
+*/
+
+static const struct luaL_Reg pdfelib_m[] = {
+    { "__tostring", pdfelib_tostring_document },
+    { "__gc",       pdfelib_free },
+    { "__index",    pdfelib_access },
+    { NULL,         NULL}
+};
+
+static const struct luaL_Reg pdfelib_m_dictionary[] = {
+    { "__tostring", pdfelib_tostring_dictionary },
+    { "__index",    pdfelib_dictionary_access },
+    { "__len",      pdfelib_dictionary_size },
+    { NULL,         NULL}
+};
+
+static const struct luaL_Reg pdfelib_m_array[] = {
+    { "__tostring", pdfelib_tostring_array },
+    { "__index",    pdfelib_array_access },
+    { "__len",      pdfelib_array_size },
+    { NULL,         NULL}
+};
+
+static const struct luaL_Reg pdfelib_m_stream[] = {
+    { "__tostring", pdfelib_tostring_stream },
+    { "__index",    pdfelib_stream_access },
+    { "__len",      pdfelib_stream_size },
+    { "__call",     pdfelib_readwholestream },
+    { NULL,         NULL}
+};
+
+static const struct luaL_Reg pdfelib_m_reference[] = {
+    { "__tostring", pdfelib_tostring_reference },
+    { NULL,         NULL}
+};
+
+/*tex
+
+    Finally we hav earrived at the main initialiser that will be called as part
+    of \LUATEX's initializer.
+
+*/
+
+/*tex
+
+    Here we hook in the error handler.
+
+*/
+
+static void pdfelib_message(const char *message, void *alien)
+{
+    normal_warning("pdfe",message);
+}
+
+int luaopen_pdfe(lua_State * L)
+{
+    /*tex First the four userdata object get their metatables defined. */
+
+    luaL_newmetatable(L, PDFE_METATABLE_DICTIONARY);
+    luaL_openlib(L, NULL, pdfelib_m_dictionary, 0);
+
+    luaL_newmetatable(L, PDFE_METATABLE_ARRAY);
+    luaL_openlib(L, NULL, pdfelib_m_array, 0);
+
+    luaL_newmetatable(L, PDFE_METATABLE_STREAM);
+    luaL_openlib(L, NULL, pdfelib_m_stream, 0);
+
+    luaL_newmetatable(L, PDFE_METATABLE_REFERENCE);
+    luaL_openlib(L, NULL, pdfelib_m_reference, 0);
+
+    /*tex Then comes the main (document) metatable: */
+
+    luaL_newmetatable(L, PDFE_METATABLE);
+    luaL_openlib(L, NULL, pdfelib_m, 0);
+
+    /*tex Last the library opens up itself to the world. */
+
+    luaL_openlib(L, "pdfe", pdfelib, 0);
+
+    pplog_callback(pdfelib_message, stderr);
+
+    return 1;
+}
diff --git a/texk/web2c/luatexdir/lua/lpdfscannerlib.c b/texk/web2c/luatexdir/lua/lpdfscannerlib.c
new file mode 100644
index 000000000..6c3bc8876
--- /dev/null
+++ b/texk/web2c/luatexdir/lua/lpdfscannerlib.c
@@ -0,0 +1,1110 @@
+/* lpdfscannerlib.c
+
+   Copyright 2013 Taco Hoekwater <taco@luatex.org>
+
+   This file is part of LuaTeX.
+
+   LuaTeX is free software; you can redistribute it and/or modify it under
+   the terms of the GNU General Public License as published by the Free
+   Software Foundation; either version 2 of the License, or (at your
+   option) any later version.
+
+   LuaTeX is distributed in the hope that it will be useful, but WITHOUT
+   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+   FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+   License for more details.
+
+   You should have received a copy of the GNU General Public License along
+   with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+
+*/
+
+/*tex
+
+    The scanner can read from a string or stream. Streams can be given directly as
+    |ppstream| object or as a |pparray| of streams. Here is an example of usage:
+
+    \starttyping
+    local operatortable = { }
+
+    operatortable.Do = function(scanner,info)
+        local resources = info.resources
+        if resources then
+            local val     = scanner:pop()
+            local name    = val[2]
+            local xobject = resources.XObject
+            print(info.space .. "Uses XObject " .. name)
+            local resources = xobject.Resources
+            if resources then
+                local newinfo =  {
+                    space     = info.space .. "  ",
+                    resources = resources,
+                }
+                pdfscanner.scan(entry, operatortable, newinfo)
+            end
+        end
+    end
+
+    local function Analyze(filename)
+        local doc = pdfe.open(filename)
+        if doc then
+            local pages = doc.Pages
+            for i=1,#pages do
+                local page = pages[i]
+                local info = {
+                  space     = "  " ,
+                  resources = page.Resources,
+                }
+                print("Page " .. i)
+                pdfscanner.scan(page.Contents,operatortable,info)
+                pdfscanner.scan(page.Contents(),operatortable,info)
+            end
+        end
+    end
+
+    Analyze("foo.pdf")
+    \stoptyping
+
+*/
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <string.h>
+#include <assert.h>
+#include <math.h>
+
+#include <lua.h>
+#include <lauxlib.h>
+#include <lualib.h>
+
+#include "luapplib/pplib.h"
+
+#include <lua/luatex-api.h>
+
+#define SCANNER "pdfscanner"
+
+#define MAXOPERANDS 1000
+
+typedef enum {
+    pdf_integer = 1,
+    pdf_real,
+    pdf_boolean,
+    pdf_name,
+    pdf_operator,
+    pdf_string,
+    pdf_startarray,
+    pdf_stoparray,
+    pdf_startdict,
+    pdf_stopdict,
+} pdf_token_type;
+
+typedef struct Token {
+    pdf_token_type type;
+    double value;
+    char *string;
+} Token;
+
+typedef struct ObjectList {
+    struct ObjectList *next;
+    ppstream *stream;
+} ObjectList;
+
+typedef struct scannerdata {
+    int _ininlineimage;
+    int _nextoperand;
+    Token **_operandstack;
+    ppstream *_stream;
+    ObjectList *_streams;
+    const char *buffer;
+    size_t position;
+    size_t size;
+    int uses_stream;
+} scannerdata;
+
+#define PDFE_METATABLE_ARRAY  "luatex.pdfe.array"
+#define PDFE_METATABLE_STREAM "luatex.pdfe.stream"
+
+typedef struct {
+    void *d;
+    /*tex reference to |PdfDocument|, or |NULL| */
+    void *pd;
+    /*tex counter to detect |PDFDoc| change */
+    unsigned long pc;
+} udstruct;
+
+static void clear_operand_stack(scannerdata * self, int from);
+static Token *_parseToken(scannerdata * self, int c);
+static void push_token(lua_State * L, scannerdata * self);
+
+static void *priv_xmalloc(size_t size)
+{
+    void *new_mem = (void *) malloc(size);
+    if (new_mem == NULL) {
+        luaL_error(Luas, "no room for <pdfscanned> stream");
+    }
+    return new_mem;
+}
+
+static void *priv_xrealloc(void *old_ptr, size_t size)
+{
+    void *new_mem = (void *) realloc(old_ptr, size);
+    if (new_mem == NULL) {
+        luaL_error(Luas, "no room for <pdfscanned> stream");
+    }
+    return new_mem;
+}
+
+#define xreallocarray(ptr,type,size) ((type*)priv_xrealloc(ptr,(size+1)*sizeof(type)))
+
+#define INITBUFSIZE 64
+
+#define define_buffer(a) \
+  char *a = (char *)priv_xmalloc (INITBUFSIZE); \
+  int a##_size = INITBUFSIZE; \
+  int a##index = 0; \
+  memset (a,0,INITBUFSIZE)
+
+#define check_overflow(a, wsize) do { \
+    if (wsize >= a##_size) { \
+        int nsize = a##_size + a##_size / 4; \
+        a = (char *) xreallocarray(a, char, (unsigned) nsize); \
+        memset (a+a##_size, 0, a##_size / 4); \
+        a##_size = nsize; \
+    } \
+} while (0)
+
+
+static scannerdata *scanner_push(lua_State * L)
+{
+    scannerdata *a = (scannerdata *) lua_newuserdata(L, sizeof(scannerdata));
+    luaL_getmetatable(L, SCANNER);
+    lua_setmetatable(L, -2);
+    return a;
+}
+
+static scannerdata *scanner_check(lua_State * L, int index)
+{
+    scannerdata *bar;
+    luaL_checktype(L, index, LUA_TUSERDATA);
+    bar = (scannerdata *) luaL_checkudata(L, index, SCANNER);
+    if (bar == NULL)
+        luaL_argerror(L, index, SCANNER " expected");
+    return bar;
+}
+
+static void free_token(Token * token)
+{
+    if (token->string) {
+        free(token->string);
+    }
+    free(token);
+}
+
+static void clear_operand_stack(scannerdata * self, int from)
+{
+    int i = self->_nextoperand - 1;
+    while (i >= from) {
+        if (self->_operandstack[i]) {
+            free_token(self->_operandstack[i]);
+            self->_operandstack[i] = NULL;
+        }
+        i--;
+    }
+    self->_nextoperand = from;
+}
+
+static void push_operand(scannerdata * self, Token * token)
+{
+    if (self->_nextoperand + 1 > MAXOPERANDS) {
+        fprintf(stderr, "out of operand stack space");
+        exit(1);
+    }
+    self->_operandstack[self->_nextoperand++] = token;
+}
+
+static Token *new_operand(pdf_token_type c)
+{
+    Token *token = (Token *) priv_xmalloc(sizeof(Token));
+    memset(token, 0, sizeof(Token));
+    token->type = c;
+    return token;
+}
+
+static void _nextStream(scannerdata * self)
+{
+    ObjectList *rover = NULL;
+    if (self->uses_stream && self->buffer != NULL) {
+        if (self->uses_stream) {
+            ppstream_done(self->_stream);
+        } else {
+            free(self->_stream);
+        }
+    }
+    rover = self->_streams;
+    self->_stream = rover->stream;
+    if (self->uses_stream) {
+        self->buffer = (const char *) ppstream_all(self->_stream, &self->size, 1);
+    }
+    self->position = 0;
+    self->_streams = rover->next;
+    free(rover);
+}
+
+static int streamGetChar(scannerdata * self)
+{
+    int i = EOF;
+    if (self->position < self->size) {
+        const char c = self->buffer[self->position];
+        ++self->position;
+        i = (int) c;
+    }
+    if (i < 0 && self->_streams) {
+        _nextStream(self);
+        i = streamGetChar(self);
+    }
+    return i;
+}
+
+static int streamLookChar(scannerdata * self)
+{
+    int i = EOF;
+    if (self->position < self->size) {
+        const char c = self->buffer[self->position];
+        /*not |++self->position;| */
+        i = (int) c;
+    }
+    if (i < 0 && self->_streams) {
+        _nextStream(self);
+        i = streamGetChar(self);
+    }
+    return i;
+}
+
+static void streamReset(scannerdata * self)
+{
+    if (self->uses_stream) {
+        self->buffer = (const char *) ppstream_all(self->_stream, &self->size, 1);
+    }
+    self->position = 0;
+}
+
+static void streamClose(scannerdata * self)
+{
+    if (self->uses_stream) {
+        ppstream_done(self->_stream);
+    } else {
+        free(self->_stream);
+    }
+    self->buffer = NULL;
+    self->_stream = NULL;
+}
+
+/*tex end of stream interface */
+
+static Token *_parseSpace(scannerdata * self)
+{
+    return _parseToken(self, streamGetChar(self));
+}
+
+static Token *_parseString(scannerdata * self, int c)
+{
+    int level;
+    Token *token = NULL;
+    define_buffer(found);
+    level = 1;
+    while (1) {
+        c = streamGetChar(self);
+        if (c == '(') {
+            level = level + 1;
+        } else if (c == ')') {
+            level = level - 1;
+            if (level < 1)
+            break;
+        } else if (c == '\\') {
+            int next = streamGetChar(self);
+            if (next == '(' || next == ')' || next == '\\') {
+                c = next;
+            } else if (next == '\n' || next == '\r') {
+                c = '\0';
+            } else if (next == 'n') {
+                c = '\n';
+            } else if (next == 'r') {
+                c = '\r';
+            } else if (next == 't') {
+                c = '\t';
+            } else if (next == 'b') {
+                c = '\b';
+            } else if (next == 'f') {
+                c = '\f';
+            } else if (next >= '0' && next <= '7') {
+                int next2;
+                next = next - '0';
+                next2 = streamLookChar(self);
+                if (next2 >= '0' && next2 <= '7') {
+                    int next3;
+                    next2 = streamGetChar(self);
+                    next2 = next2 - '0';
+                    next3 = streamLookChar(self);
+                    if (next3 >= '0' && next3 <= '7') {
+                    next3 = streamGetChar(self);
+                    next3 = next3 - '0';
+                    c = (next * 64 + next2 * 8 + next3);
+                    } else {
+                    c = (next * 8 + next2);
+                    }
+                } else {
+                    c = next;
+                }
+            } else {
+                c = next;
+            }
+        }
+        check_overflow(found, foundindex);
+        if (c >= 0) {
+            found[foundindex++] = c;
+        }
+    }
+    token = new_operand(pdf_string);
+    token->value = foundindex;
+    token->string = found;
+    return token;
+}
+
+static Token *_parseNumber(scannerdata * self, int c)
+{
+    double value = 0;
+    pdf_token_type type = pdf_integer;
+    int isfraction = 0;
+    int isnegative = 0;
+    int i = 0;
+    Token *token = NULL;
+    if (c == '-') {
+        isnegative = 1;
+        c = streamGetChar(self);
+    }
+    if (c == '.') {
+        type = pdf_real;
+        isfraction = 1;
+    } else {
+        value = c - '0';
+    }
+    c = streamLookChar(self);
+    if ((c >= '0' && c <= '9') || c == '.') {
+    c = streamGetChar(self);
+    while (1) {
+        if (c == '.') {
+            type = pdf_real;
+            isfraction = 1;
+        } else {
+            i = c - '0';
+            if (isfraction > 0) {
+                value = value + (i / (pow(10.0, isfraction)));
+                isfraction = isfraction + 1;
+            } else {
+                value = (value * 10) + i;
+            }
+        }
+        c = streamLookChar(self);
+        if (!((c >= '0' && c <= '9') || c == '.'))
+            break;
+        c = streamGetChar(self);
+    }
+    }
+    if (isnegative) {
+        value = -value;
+    }
+    token = new_operand(type);
+    token->value = value;
+    return token;
+}
+
+static Token *_parseName(scannerdata * self, int c)
+{
+    Token *token = NULL;
+    define_buffer(found);
+    c = streamGetChar(self);
+    while (1) {
+        check_overflow(found, foundindex);
+        found[foundindex++] = c;
+        c = streamLookChar(self);
+        if (c == ' ' || c == '\n' || c == '\r' || c == '\t' ||
+            c == '/' || c == '[' || c == '(' || c == '<')
+            break;
+        c = streamGetChar(self);
+    }
+    token = new_operand(pdf_name);
+    token->string = found;
+    token->value = strlen(found);
+    return token;
+}
+
+#define hexdigit(c)	\
+  (c>= '0' && c<= '9') ? (c - '0') : ((c>= 'A' && c<= 'F') ? (c - 'A' + 10) : (c - 'a' + 10))
+
+static Token *_parseHexstring(scannerdata * self, int c)
+{
+    int isodd = 1;
+    int hexval = 0;
+    Token *token = NULL;
+    define_buffer(found);
+    while (c != '>') {
+    if ((c >= '0' && c <= '9') || (c >= 'A' && c <= 'F') || (c >= 'a' && c <= 'f')) {
+        if (isodd == 1) {
+            int v = hexdigit(c);
+            hexval = 16 * v;
+        } else {
+            hexval += hexdigit(c);
+            check_overflow(found, foundindex);
+            found[foundindex++] = hexval;
+        }
+        isodd = (isodd == 1 ? 0 : 1);
+    }
+        c = streamGetChar(self);
+    }
+    token = new_operand(pdf_string);
+    token->value = foundindex;
+    token->string = found;
+    return token;
+}
+
+#define pdf_isspace(a) (a == '\0' || a == ' ' || a == '\n' || a == '\r' || a == '\t' || a == '\v')
+
+/*tex this is rather horrible */
+
+static Token *_parseInlineImage(scannerdata * self, int c)
+{
+    Token *token = NULL;
+    define_buffer(found);
+    if (c == ' ') {
+        /*tex first space can be ignored */
+        c = streamGetChar(self);
+    }
+    check_overflow(found, foundindex);
+    found[foundindex++] = c;
+    while (1) {
+        c = streamLookChar(self);
+        if (c == 'E'
+            && (found[foundindex - 1] == '\n'
+            || found[foundindex - 1] == '\r')) {
+            c = streamGetChar(self);
+            check_overflow(found, foundindex);
+            found[foundindex++] = c;
+            c = streamLookChar(self);
+            if (c == 'I') {
+                c = streamGetChar(self);
+                check_overflow(found, foundindex);
+                found[foundindex++] = c;
+                c = streamLookChar(self);
+                if (pdf_isspace(c)) {
+                    /*tex |I| */
+                    found[--foundindex] = '\0';
+                    /*tex |E| */
+                    found[--foundindex] = '\0';
+                    /*tex remove end-of-line before |EI| */
+                    if (found[foundindex - 1] == '\n') {
+                        found[--foundindex] = '\0';
+                    }
+                    if (found[foundindex - 1] == '\r') {
+                        found[--foundindex] = '\0';
+                    }
+                    break;
+                } else {
+                    c = streamGetChar(self);
+                    check_overflow(found, foundindex);
+                    found[foundindex++] = c;
+                }
+            } else {
+                c = streamGetChar(self);
+                check_overflow(found, foundindex);
+                found[foundindex++] = c;
+            }
+        } else {
+            c = streamGetChar(self);
+            check_overflow(found, foundindex);
+            found[foundindex++] = c;
+        }
+    }
+    token = new_operand(pdf_string);
+    token->value = foundindex;
+    token->string = found;
+    return token;
+}
+
+static Token *_parseOperator(scannerdata * self, int c)
+{
+    define_buffer(found);
+    while (1) {
+        check_overflow(found, foundindex);
+        found[foundindex++] = c;
+        c = streamLookChar(self);
+        if ((c < 0) || (c == ' ' || c == '\n' || c == '\r' || c == '\t' ||
+                c == '/' || c == '[' || c == '(' || c == '<'))
+            break;
+        c = streamGetChar(self);
+    }
+    /*tex |print| (found) */
+    if (strcmp(found, "ID") == 0) {
+        self->_ininlineimage = 1;
+    }
+    if (strcmp(found, "false") == 0) {
+        Token *token = new_operand(pdf_boolean);
+        token->value = 0;
+        free(found);
+        return token;
+    } else if (strcmp(found, "true") == 0) {
+        Token *token = new_operand(pdf_boolean);
+        token->value = 1.0;
+        free(found);
+        return token;
+    } else {
+        Token *token = new_operand(pdf_operator);
+        token->string = found;
+        return token;
+    }
+}
+
+static Token *_parseComment(scannerdata * self, int c)
+{
+    do {
+        c = streamGetChar(self);
+    } while (c != '\n' && c != '\r' && c != -1);
+    return _parseToken(self, streamGetChar(self));
+}
+
+static Token *_parseLt(scannerdata * self, int c)
+{
+    c = streamGetChar(self);
+    if (c == '<') {
+        return new_operand(pdf_startdict);
+    } else {
+        return _parseHexstring(self, c);
+    }
+}
+
+static Token *_parseGt(scannerdata * self, int c)
+{
+    c = streamGetChar(self);
+    if (c == '>') {
+        return new_operand(pdf_stopdict);
+    } else {
+        fprintf(stderr, "stray > in stream");
+        return NULL;
+    }
+}
+
+static Token *_parseError(int c)
+{
+    fprintf(stderr, "stray %c [%d] in stream", c, c);
+    return NULL;
+}
+
+static Token *_parseStartarray(void)
+{
+    return new_operand(pdf_startarray);
+}
+
+static Token *_parseStoparray(void)
+{
+    return new_operand(pdf_stoparray);
+}
+
+static Token *_parseToken(scannerdata * self, int c)
+{
+    if (self->_ininlineimage == 1) {
+        self->_ininlineimage = 2;
+        return _parseInlineImage(self, c);
+    } else if (self->_ininlineimage == 2) {
+        Token *token = NULL;
+        self->_ininlineimage = 0;
+        token = new_operand(pdf_operator);
+        token->string = strdup("EI");
+        return token;
+    }
+    if (c < 0)
+        return NULL;
+    switch (c) {
+        case '(':
+            return _parseString(self, c);
+            break;
+        case ')':
+            return _parseError(c);
+            break;
+        case '[':
+            return _parseStartarray();
+            break;
+        case ']':
+            return _parseStoparray();
+            break;
+        case '/':
+            return _parseName(self, c);
+            break;
+        case '<':
+            return _parseLt(self, c);
+            break;
+        case '>':
+            return _parseGt(self, c);
+            break;
+        case '%':
+            return _parseComment(self, c);
+            break;
+        case ' ':
+        case '\r':
+        case '\n':
+        case '\t':
+            return _parseSpace(self);
+            break;
+        case '0':
+        case '1':
+        case '2':
+        case '3':
+        case '4':
+        case '5':
+        case '6':
+        case '7':
+        case '8':
+        case '9':
+        case '-':
+        case '.':
+            return _parseNumber(self, c);
+            break;
+        default:
+            if (c <= 127) {
+                return _parseOperator(self, c);
+            } else {
+                return _parseError(c);
+            }
+    }
+}
+
+static int scanner_scan(lua_State * L)
+{
+    Token *token;
+    scannerdata *self;
+    if (lua_gettop(L) != 3) {
+        return 0;
+    }
+    luaL_checktype(L, 2, LUA_TTABLE);
+    luaL_checktype(L, 3, LUA_TTABLE);
+    self = scanner_push(L);
+    memset(self, 0, sizeof(scannerdata));
+    self->_operandstack = (Token **) priv_xmalloc(MAXOPERANDS * sizeof(Token));
+    memset(self->_operandstack, 0, (MAXOPERANDS * sizeof(Token)));
+    /*tex stack slot 4 = self */
+    self->uses_stream = 1;
+    if (lua_type(L, 1) == LUA_TSTRING) {
+      /*tex
+            We could make a temporary copy on the stack (or in the registry)
+            which saves memory.
+      */
+      char *buf = NULL;
+      const char *s = lua_tolstring(L, 1, &self->size);
+      if (s==NULL){
+	fprintf(stderr,"fatal: cannot convert the token to string.");
+	exit(1);
+      }
+      buf = priv_xmalloc(self->size+1);
+      buf[self->size]='\0';
+      self->uses_stream = 0;
+      memcpy(buf,s,self->size);
+      self->buffer = buf;
+    } else if (lua_type(L, 1) == LUA_TTABLE) {
+        udstruct *uin;
+        void *ud;
+        int i = 1;
+        while (1) {
+            lua_rawgeti(L, 1, i);
+            if (lua_type(L, -1) == LUA_TUSERDATA) {
+                ud = luaL_checkudata(L, -1, PDFE_METATABLE_STREAM);
+                if (ud != NULL) {
+                    ObjectList *rover = NULL;
+                    ObjectList *item = NULL;
+                    uin = (udstruct *) ud;
+                    rover = self->_streams;
+                    item = (ObjectList *) priv_xmalloc(sizeof(ObjectList));
+                    item->stream = ((ppstream *) uin->d);
+                    item->next = NULL;
+                    if (!rover) {
+                        rover = item;
+                        self->_streams = rover;
+                    } else {
+                        while (rover->next)
+                            rover = rover->next;
+                        rover->next = item;
+                    }
+                }
+            } else {
+                ObjectList *rover = self->_streams;
+                self->_stream = rover->stream;
+                self->_streams = rover->next;
+                free(rover);
+                lua_pop(L, 1);
+                break;
+            }
+            lua_pop(L, 1);
+            i++;
+        }
+    } else {
+        udstruct *uin;
+        void *ud;
+        luaL_checktype(L, 1, LUA_TUSERDATA);
+        ud = luaL_checkudata(L, 1, PDFE_METATABLE_STREAM);
+        if (ud != NULL) {
+            uin = (udstruct *) ud;
+            self->_stream = ((ppstream *) uin->d);
+        } else {
+            ud = luaL_checkudata(L, 1, PDFE_METATABLE_ARRAY);
+            if (ud != NULL) {
+            ObjectList *rover = NULL;
+            pparray *array = NULL;
+            int count;
+            int i;
+            uin = (udstruct *) ud;
+            array = (pparray *) uin->d;
+            count = array->size;
+            for (i = 0; i < count; i++) {
+                ppobj *obj = pparray_at(array, i);
+                if (obj->type == PPSTREAM) {
+                    ObjectList *rover = self->_streams;
+                    ObjectList *item =
+                        (ObjectList *)
+                        priv_xmalloc(sizeof(ObjectList));
+                    item->stream = obj->stream;
+                    item->next = NULL;
+                    if (!rover) {
+                        rover = item;
+                        self->_streams = rover;
+                    } else {
+                        while (rover->next)
+                        rover = rover->next;
+                        rover->next = item;
+                    }
+                }
+            }
+            rover = self->_streams;
+            self->_stream = rover->stream;
+            self->_streams = rover->next;
+            }
+        }
+    }
+    streamReset(self);
+    token = _parseToken(self, streamGetChar(self));
+    while (token) {
+        if (token->type == pdf_operator) {
+            lua_pushstring(L, token->string);
+            free_token(token);
+            /*tex fetch operator table */
+            lua_rawget(L, 2);
+            if (lua_isfunction(L, -1)) {
+                lua_pushvalue(L, 4);
+                lua_pushvalue(L, 3);
+                (void) lua_call(L, 2, 0);
+            } else {
+                /*tex nil */
+                lua_pop(L, 1);
+            }
+            clear_operand_stack(self, 0);
+        } else {
+            push_operand(self, token);
+        }
+        if (self->uses_stream) {
+            if (!self->_stream) {
+                break;
+            }
+        } else {
+            if (self->buffer == NULL) {
+                break;
+            }
+        }
+        token = _parseToken(self, streamGetChar(self));
+    }
+    /*tex wrap up */
+    if (self->_stream) {
+        streamClose(self);
+    }
+    clear_operand_stack(self, 0);
+    free(self->_operandstack);
+    return 0;
+}
+
+static int scanner_done(lua_State * L)
+{
+    int c;
+    scannerdata *self = scanner_check(L, 1);
+    while ((c = streamGetChar(self)) >= 0);
+    return 0;
+}
+
+/*tex here are the stack popping functions, and their helpers */
+
+static void operandstack_backup(scannerdata * self)
+{
+    int i = self->_nextoperand - 1;
+    int balance = 0;
+    int backupstart = 0;
+    int backupstop = self->_operandstack[i]->type;
+    if (backupstop == pdf_stopdict) {
+        backupstart = pdf_startdict;
+    } else if (backupstop == pdf_stoparray) {
+        backupstart = pdf_startarray;
+    } else {
+        return;
+    }
+    for (; i >= 0; i--) {
+        if (self->_operandstack[i]->type == backupstop) {
+            balance++;
+        } else if (self->_operandstack[i]->type == backupstart) {
+            balance--;
+        }
+        if (balance == 0) {
+            break;
+        }
+    }
+    self->_nextoperand = i + 1;
+}
+
+static void push_array(lua_State * L, scannerdata * self)
+{
+    /*tex nesting tracking */
+    int balance = 1;
+    /*tex \LUA\ array index */
+    int index = 1;
+    Token *token = self->_operandstack[self->_nextoperand++];
+    lua_newtable(L);
+    while (token) {
+    if (token->type == pdf_stoparray)
+        balance--;
+    if (token->type == pdf_startarray)
+        balance++;
+    if (!balance) {
+        break;
+    } else {
+        push_token(L, self);
+        lua_rawseti(L, -2, index++);
+    }
+    token = self->_operandstack[self->_nextoperand++];
+    }
+}
+
+
+static void push_dict(lua_State * L, scannerdata * self)
+{
+    /*tex nesting tracking */
+    int balance = 1;
+    /*tex toggle between \LUA\ value and \LUA\ key */
+    int needskey = 1;
+    Token *token = self->_operandstack[self->_nextoperand++];
+    lua_newtable(L);
+    while (token) {
+    if (token->type == pdf_stopdict)
+        balance--;
+    if (token->type == pdf_startdict)
+        balance++;
+    if (!balance) {
+        break;
+    } else if (needskey) {
+        lua_pushlstring(L, token->string, token->value);
+        needskey = 0;
+    } else {
+        push_token(L, self);
+        needskey = 1;
+        lua_rawset(L, -3);
+    }
+    token = self->_operandstack[self->_nextoperand++];
+    }
+}
+
+const char *typenames[pdf_stopdict + 1] = {
+    "unknown", "integer", "real", "boolean", "name", "operator",
+    "string", "array", "array", "dict", "dict"
+};
+
+static void push_token(lua_State * L, scannerdata * self)
+{
+    Token *token = self->_operandstack[self->_nextoperand - 1];
+    lua_createtable(L, 2, 0);
+    lua_pushstring(L, typenames[token->type]);
+    lua_rawseti(L, -2, 1);
+    if (token->type == pdf_string || token->type == pdf_name) {
+        lua_pushlstring(L, token->string, token->value);
+    } else if (token->type == pdf_real || token->type == pdf_integer) {
+        /*tex This is an integer or float. */
+        lua_pushnumber(L, token->value);
+    } else if (token->type == pdf_boolean) {
+        lua_pushboolean(L, (int) token->value);
+    } else if (token->type == pdf_startarray) {
+        push_array(L, self);
+    } else if (token->type == pdf_startdict) {
+        push_dict(L, self);
+    } else {
+        lua_pushnil(L);
+    }
+    lua_rawseti(L, -2, 2);
+}
+
+static int scanner_popsingular(lua_State * L, int token_type)
+{
+    Token *token = NULL;
+    /*tex this keeps track of how much of the operand stack needs deleting: */
+    int clear = 0;
+    scannerdata *self = scanner_check(L, 1);
+    if (self->_nextoperand == 0) {
+        return 0;
+    }
+    clear = self->_nextoperand - 1;
+    token = self->_operandstack[self->_nextoperand - 1];
+    if (token == NULL || (token->type != token_type)) {
+        return 0;
+    }
+    /*tex
+        The simple cases can be written out directly, but dicts and
+        arrays are better done via the recursive function.
+    */
+    if (token_type == pdf_stoparray || token_type == pdf_stopdict) {
+        operandstack_backup(self);
+        clear = self->_nextoperand - 1;
+        push_token(L, self);
+        lua_rawgeti(L, -1, 2);
+    } else if (token_type == pdf_real || token_type == pdf_integer) {
+        /*tex the number can be an integer or float */
+        lua_pushnumber(L, token->value);
+    } else if (token_type == pdf_boolean) {
+        lua_pushboolean(L, (int) token->value);
+    } else if (token_type == pdf_name || token_type == pdf_string) {
+        lua_pushlstring(L, token->string, token->value);
+    } else {
+        return 0;
+    }
+    clear_operand_stack(self, clear);
+    return 1;
+}
+
+static int scanner_popanything(lua_State * L)
+{
+    Token *token = NULL;
+    /*tex how much of the operand stack needs deleting: */
+    int clear = 0;
+    int token_type;
+    scannerdata *self = scanner_check(L, 1);
+    if (self->_nextoperand == 0) {
+        return 0;
+    }
+    clear = self->_nextoperand - 1;
+    token = self->_operandstack[self->_nextoperand - 1];
+    if (token == NULL) {
+        return 0;
+    }
+    token_type = token->type;
+    /*tex
+        The simple cases can be written out directly, but dicts and
+        arrays are better done via the recursive function.
+    */
+    if (token_type == pdf_stoparray || token_type == pdf_stopdict) {
+        operandstack_backup(self);
+        clear = self->_nextoperand - 1;
+        push_token(L, self);
+    } else {
+        push_token(L, self);
+    }
+    clear_operand_stack(self, clear);
+    return 1;
+}
+
+static int scanner_popnumber(lua_State * L)
+{
+    if (scanner_popsingular(L, pdf_real))
+        return 1;
+    if (scanner_popsingular(L, pdf_integer))
+        return 1;
+    lua_pushnil(L);
+    return 1;
+}
+
+static int scanner_popboolean(lua_State * L)
+{
+    if (scanner_popsingular(L, pdf_boolean))
+        return 1;
+    lua_pushnil(L);
+    return 1;
+}
+
+static int scanner_popstring(lua_State * L)
+{
+    if (scanner_popsingular(L, pdf_string))
+        return 1;
+    lua_pushnil(L);
+    return 1;
+}
+
+static int scanner_popname(lua_State * L)
+{
+    if (scanner_popsingular(L, pdf_name))
+        return 1;
+    lua_pushnil(L);
+    return 1;
+}
+
+static int scanner_poparray(lua_State * L)
+{
+    if (scanner_popsingular(L, pdf_stoparray))
+        return 1;
+    lua_pushnil(L);
+    return 1;
+}
+
+static int scanner_popdictionary(lua_State * L)
+{
+    if (scanner_popsingular(L, pdf_stopdict))
+        return 1;
+    lua_pushnil(L);
+    return 1;
+}
+
+static int scanner_popany(lua_State * L)
+{
+    if (scanner_popanything(L))
+        return 1;
+    lua_pushnil(L);
+    return 1;
+}
+
+static const luaL_Reg scannerlib_meta[] = {
+    {0, 0}
+};
+
+static const struct luaL_Reg scannerlib_m[] = {
+    { "done",          scanner_done },
+    { "pop",           scanner_popany },
+    { "popnumber",     scanner_popnumber },
+    { "popname",       scanner_popname },
+    { "popstring",     scanner_popstring },
+    { "poparray",      scanner_poparray },
+    { "popdictionary", scanner_popdictionary },
+    { "popboolean",    scanner_popboolean },
+    /*tex For old times sake: */
+    { "popNumber",     scanner_popnumber },
+    { "popName",       scanner_popname },
+    { "popString",     scanner_popstring },
+    { "popArray",      scanner_poparray },
+    { "popDict",       scanner_popdictionary },
+    { "popBool",       scanner_popboolean },
+    /*tex Sentinel: */
+    { NULL,            NULL }
+};
+
+static const luaL_Reg scannerlib[] = {
+    { "scan", scanner_scan },
+    /*tex Sentinel: */
+    { NULL,   NULL }
+};
+
+LUALIB_API int luaopen_pdfscanner(lua_State * L)
+{
+    luaL_newmetatable(L, SCANNER);
+    luaL_openlib(L, 0, scannerlib_meta, 0);
+    lua_pushvalue(L, -1);
+    lua_setfield(L, -2, "__index");
+    luaL_openlib(L, NULL, scannerlib_m, 0);
+    luaL_openlib(L, "pdfscanner", scannerlib, 0);
+    return 1;
+}
diff --git a/texk/web2c/luatexdir/lua/luainit.w b/texk/web2c/luatexdir/lua/luainit.c
similarity index 76%
rename from texk/web2c/luatexdir/lua/luainit.w
rename to texk/web2c/luatexdir/lua/luainit.c
index dec76b021..60c654aa0 100644
--- a/texk/web2c/luatexdir/lua/luainit.w
+++ b/texk/web2c/luatexdir/lua/luainit.c
@@ -1,23 +1,25 @@
-% luainit.w
-%
-% Copyright 2006-2018 Taco Hoekwater <taco@@luatex.org>
-%
-% This file is part of LuaTeX.
-%
-% LuaTeX is free software; you can redistribute it and/or modify it under
-% the terms of the GNU General Public License as published by the Free
-% Software Foundation; either version 2 of the License, or (at your
-% option) any later version.
-%
-% LuaTeX is distributed in the hope that it will be useful, but WITHOUT
-% ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-% FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
-% License for more details.
-%
-% You should have received a copy of the GNU General Public License along
-% with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
-
-@ @c
+/*
+
+luainit.w
+
+Copyright 2006-2018 Taco Hoekwater <taco@@luatex.org>
+
+This file is part of LuaTeX.
+
+LuaTeX is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 2 of the License, or (at your
+option) any later version.
+
+LuaTeX is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+License for more details.
+
+You should have received a copy of the GNU General Public License along
+with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+
+*/
 
 #include "ptexlib.h"
 
@@ -29,27 +31,23 @@
 
 extern int load_luatex_core_lua (lua_State * L);
 
-/* internalized strings: see luatex-api.h */
-set_make_keys;
+/*tex internalized strings: see luatex-api.h */
 
-@
-This file is getting a bit messy, but it is not simple to fix unilaterally.
+set_make_keys;
 
-Better to wait until Karl has some time (after texlive 2008) so we can
-synchronize with kpathsea. One problem, for instance, is that I would
-like to resolve the full executable path.  |kpse_set_program_name()| does
-that, indirectly (by setting SELFAUTOLOC in the environment), but it
-does much more, making it hard to use for our purpose.
+/*tex
 
-In fact, it sets three C variables:
+This file is getting a bit messy, but it is not simple to fix unilaterally. In
+fact, it sets three C variables:
 
-  |kpse_invocation_name|  |kpse_invocation_short_name|  |kpse->program_name|
+  |kpse_invocation_name| |kpse_invocation_short_name| |kpse->program_name|
 
 and five environment variables:
 
-  SELFAUTOLOC  SELFAUTODIR  SELFAUTOPARENT  SELFAUTOGRANDPARENT  progname
+  |SELFAUTOLOC| |SELFAUTODIR| |SELFAUTOPARENT| |SELFAUTOGRANDPARENT| |progname|
+
+*/
 
-@c
 const_string LUATEX_IHELP[] = {
     "Usage: " my_name " --lua=FILE [OPTION]... [TEXNAME[.tex]] [COMMANDS]",
     "   or: " my_name " --lua=FILE [OPTION]... \\FIRST-LINE",
@@ -109,9 +107,13 @@ const_string LUATEX_IHELP[] = {
     NULL
 };
 
-@ Later we will put on environment |LC_CTYPE|, |LC_COLLATE| and
-|LC_NUMERIC| set to |C|, so we need a place where to store the old values.
-@c
+/*tex
+
+Later we will put on environment |LC_CTYPE|, |LC_COLLATE| and |LC_NUMERIC| set to
+|C|, so we need a place where to store the old values.
+
+*/
+
 const char *lc_ctype;
 const char *lc_collate;
 const char *lc_numeric;
@@ -126,26 +128,28 @@ const char *lc_numeric;
     "   --translate-file=FILE         ignored, input is assumed to be in UTF-8 encoding",
 */
 
-@ The return value will be the directory of the executable, e.g.: \.{c:/TeX/bin}
-@c
+/*tex
+
+The return value will be the directory of the executable, e.g.: \.{c:/TeX/bin}
+
+*/
+
 static char *ex_selfdir(char *argv0)
 {
 #if defined(WIN32)
 #if defined(__MINGW32__)
     char path[PATH_MAX], *fp;
-
-    /* SearchPath() always gives back an absolute directory */
+    /*tex SearchPath() always gives back an absolute directory */
     if (SearchPath(NULL, argv0, ".exe", PATH_MAX, path, NULL) == 0)
         FATAL1("Can't determine where the executable %s is.\n", argv0);
-    /* slashify the dirname */
+    /*tex slashify the dirname */
     for (fp = path; fp && *fp; fp++)
         if (IS_DIR_SEP(*fp))
             *fp = DIR_SEP;
 #else /* __MINGW32__ */
 #define PATH_MAX 512
     char short_path[PATH_MAX], path[PATH_MAX], *fp;
-
-    /* SearchPath() always gives back an absolute directory */
+    /*tex SearchPath() always gives back an absolute directory */
     if (SearchPath(NULL, argv0, ".exe", PATH_MAX, short_path, &fp) == 0)
         FATAL1("Can't determine where the executable %s is.\n", argv0);
     if (getlongpath(path, short_path, sizeof(path)) == 0) {
@@ -158,7 +162,6 @@ static char *ex_selfdir(char *argv0)
 #endif
 }
 
-@ @c
 static void prepare_cmdline(lua_State * L, char **av, int ac, int zero_offset)
 {
     int i;
@@ -178,11 +181,8 @@ static void prepare_cmdline(lua_State * L, char **av, int ac, int zero_offset)
     return;
 }
 
-
-@ @c
 int kpse_init = -1;
 
-@ @c
 string input_name = NULL;
 
 static string user_progname = NULL;
@@ -201,22 +201,20 @@ int safer_option = 0;
 int nosocket_option = 0;
 int utc_option = 0;
 
-@ Reading the options.
+/*tex
 
-@ Test whether getopt found an option ``A''.
-Assumes the option index is in the variable |option_index|, and the
-option table in a variable |long_options|.
+Test whether getopt found an option ``A''. Assumes the option index is in the
+variable |option_index|, and the option table in a variable |long_options|.
 
-@c
-#define ARGUMENT_IS(a) STREQ (long_options[option_index].name, a)
-
-/*
-    SunOS cc can't initialize automatic structs, so make this static.
 */
 
-/*
+#define ARGUMENT_IS(a) STREQ (long_options[option_index].name, a)
+
+/*tex
     Nota Bene: we still intercept some options that other engines handle
     so that existing scripted usage will not fail.
+
+    SunOS cc can't initialize automatic structs, so make this static.
 */
 
 static struct option long_options[] = {
@@ -253,9 +251,7 @@ static struct option long_options[] = {
     {"debug-format", 0, &debug_format_file, 1},
     {"file-line-error-style", 0, &filelineerrorstylep, 1},
     {"no-file-line-error-style", 0, &filelineerrorstylep, -1},
-
-    /* Shorter option names for the above. */
-
+    /*tex Shorter option names for the above. */
     {"file-line-error", 0, &filelineerrorstylep, 1},
     {"no-file-line-error", 0, &filelineerrorstylep, -1},
     {"jobname", 1, 0, 0},
@@ -266,18 +262,16 @@ static struct option long_options[] = {
     {"8bit", 0, 0, 0},
     {"mktex", 1, 0, 0},
     {"no-mktex", 1, 0, 0},
-
-    /* Synchronization: just like "interaction" above */
-
+    /*tex Synchronization: just like ``interaction'' above */
     {"synctex", 1, 0, 0},
     {0, 0, 0, 0}
 };
 
-@ @c
 int lua_numeric_field_by_index(lua_State * L, int name_index, int dflt)
 {
     register int i = dflt;
-    lua_rawgeti(L, LUA_REGISTRYINDEX, name_index);      /* fetch the stringptr */
+    /*tex fetch the stringptr */
+    lua_rawgeti(L, LUA_REGISTRYINDEX, name_index);
     lua_rawget(L, -2);
     if (lua_type(L, -1) == LUA_TNUMBER) {
         i = lua_roundnumber(L, -1);
@@ -286,11 +280,11 @@ int lua_numeric_field_by_index(lua_State * L, int name_index, int dflt)
     return i;
 }
 
-@ @c
 unsigned int lua_unsigned_numeric_field_by_index(lua_State * L, int name_index, int dflt)
 {
     register unsigned int i = dflt;
-    lua_rawgeti(L, LUA_REGISTRYINDEX, name_index);      /* fetch the stringptr */
+    /*tex fetch the stringptr */
+    lua_rawgeti(L, LUA_REGISTRYINDEX, name_index);
     lua_rawget(L, -2);
     if (lua_type(L, -1) == LUA_TNUMBER) {
         i = lua_uroundnumber(L, -1);
@@ -299,20 +293,21 @@ unsigned int lua_unsigned_numeric_field_by_index(lua_State * L, int name_index,
     return i;
 }
 
-@ @c
 static int recorderoption = 0;
 
 static void parse_options(int ac, char **av)
 {
 #ifdef WIN32
-/* save argc and argv */
+    /*tex We save |argc| and |argv|. */
     int sargc = argc;
     char **sargv = argv;
 #endif
-    int g;                      /* `getopt' return code.  */
+     /*tex The `getopt' return code. */
+    int g;
     int option_index;
     char *firstfile = NULL;
-    opterr = 0;                 /* dont whine */
+    /*tex Dont whine. */
+    opterr = 0;
 #ifdef LuajitTeX
     if ((strstr(argv[0], "luajittexlua") != NULL) ||
         (strstr(argv[0], "texluajit") != NULL)) {
@@ -326,37 +321,39 @@ static void parse_options(int ac, char **av)
 
     for (;;) {
         g = getopt_long_only(ac, av, "+", long_options, &option_index);
-        if (g == -1)            /* End of arguments, exit the loop.  */
+        if (g == -1) {
+            /*tex End of arguments, exit the loop. */
             break;
-        if (g == '?')  {         /* Unknown option.  */
-          if (!luainit)
-            fprintf(stderr,"%s: unrecognized option '%s'\n", argv[0], argv[optind-1]);
-          continue;
         }
-
-        assert(g == 0);         /* We have no short option names.  */
-
+        if (g == '?')  {
+            /*tex Unknown option. */
+            if (!luainit)
+                fprintf(stderr,"%s: unrecognized option '%s'\n", argv[0], argv[optind-1]);
+            continue;
+        }
+        /* We have no short option names. */
+        assert(g == 0);
         if (ARGUMENT_IS("luaonly")) {
             lua_only = 1;
             lua_offset = optind;
             luainit = 1;
         } else if (ARGUMENT_IS("lua")) {
-            startup_filename = xstrdup(optarg);
+            startup_filename = optarg;
             lua_offset = (optind - 1);
             luainit = 1;
 #ifdef LuajitTeX
         } else if (ARGUMENT_IS("jiton")) {
             luajiton = 1;
         } else if (ARGUMENT_IS("jithash")) {
-        size_t len = strlen(optarg);
-        if (len<16) {
-            jithash_hashname = optarg;
-        } else {
-            WARNING2("hash name truncated to 15 characters from %d. (%s)", (int) len, optarg);
-            jithash_hashname = (string) xmalloc(16);
-            strncpy(jithash_hashname, optarg, 15);
-            jithash_hashname[15] = 0;
-      }
+            size_t len = strlen(optarg);
+            if (len<16) {
+                jithash_hashname = optarg;
+            } else {
+                WARNING2("hash name truncated to 15 characters from %d. (%s)", (int) len, optarg);
+                jithash_hashname = (string) xmalloc(16);
+                strncpy(jithash_hashname, optarg, 15);
+                jithash_hashname[15] = 0;
+            }
 #endif
         } else if (ARGUMENT_IS("luahashchars")) {
             show_luahashchars = 1;
@@ -414,7 +411,7 @@ static void parse_options(int ac, char **av)
                 WARNING1("Ignoring unknown argument `%s' to --interaction", optarg);
             }
         } else if (ARGUMENT_IS("synctex")) {
-            /* Synchronize TeXnology: catching the command line option as a long  */
+            /*tex Synchronize TeXnology: catching the command line option as a long  */
             synctexoption = (int) strtol(optarg, NULL, 0);
         } else if (ARGUMENT_IS("recorder")) {
             recorderoption = 1 ;
@@ -445,8 +442,8 @@ static void parse_options(int ac, char **av)
                  "pdftex    : Han The Thanh and friends\n"
                  "kpathsea  : Karl Berry, Olaf Weber and others\n"
                  "lua       : Roberto Ierusalimschy, Waldemar Celes and Luiz Henrique de Figueiredo\n"
-                 "metapost  : John Hobby, Taco Hoekwater and friends\n"
-                 "poppler   : Derek Noonburg, Kristian Hogsberg (partial)\n"
+                 "metapost  : John Hobby, Taco Hoekwater, Luigi Scarso, Hans Hagen and friends\n"
+                 "pplib     : Paweł Jackowski\n"
                  "fontforge : George Williams (partial)\n"
                  "luajit    : Mike Pall (used in LuajitTeX)\n");
             /* *INDENT-ON* */
@@ -454,7 +451,7 @@ static void parse_options(int ac, char **av)
             uexit(0);
         }
     }
-    /* attempt to find |input_name| / |dump_name| */
+    /*tex attempt to find |input_name| and |dump_name| */
     if (lua_only) {
         if (argv[optind]) {
             startup_filename = xstrdup(argv[optind]);
@@ -502,20 +499,23 @@ static void parse_options(int ac, char **av)
         return;
 #endif
     }
-    if (safer_option)           /* --safer implies --nosocket */
+    /*tex |--safer| implies |--nosocket| */
+    if (safer_option)
         nosocket_option = 1;
-    /* Finalize the input filename. */
+    /*tex Finalize the input filename. */
     if (input_name != NULL) {
         argv[optind] = normalize_quotes(input_name, "argument");
     }
 }
 
-@ test for readability
-@c
-#define is_readable(a) (stat(a,&finfo)==0) && S_ISREG(finfo.st_mode) &&  \
-  (f=fopen(a,"r")) != NULL && !fclose(f)
+/*tex
+    Test for readability.
+*/
+
+#define is_readable(a) (stat(a,&finfo)==0) \
+    && S_ISREG(finfo.st_mode) \
+    && (f=fopen(a,"r")) != NULL && !fclose(f)
 
-@ @c
 static char *find_filename(char *name, const char *envkey)
 {
     struct stat finfo;
@@ -543,8 +543,6 @@ static char *find_filename(char *name, const char *envkey)
     return NULL;
 }
 
-@ @c
-
 static void init_kpse(void)
 {
     if (!user_progname) {
@@ -576,11 +574,10 @@ static void init_kpse(void)
             user_progname = dump_name;
         }
     }
-    kpse_set_program_enabled(kpse_fmt_format, MAKE_TEX_FMT_BY_DEFAULT,
-                             kpse_src_compile);
-
+    kpse_set_program_enabled(kpse_fmt_format, MAKE_TEX_FMT_BY_DEFAULT, kpse_src_compile);
     kpse_set_program_name(argv[0], user_progname);
-    init_shell_escape();        /* set up 'restrictedshell' */
+    /*tex set up 'restrictedshell' */
+    init_shell_escape();
     init_start_time();
     program_name_set = 1 ;
     if (recorderoption) {
@@ -588,19 +585,18 @@ static void init_kpse(void)
     }
 }
 
-@ @c
 static void fix_dumpname(void)
 {
     int dist;
     if (dump_name) {
-        /* adjust array for Pascal and provide extension, if needed */
+        /*tex Adjust array for Pascal and provide extension, if needed. */
         dist = (int) (strlen(dump_name) - strlen(DUMP_EXT));
         if (strstr(dump_name, DUMP_EXT) == dump_name + dist)
             TEX_format_default = dump_name;
         else
             TEX_format_default = concat(dump_name, DUMP_EXT);
     } else {
-        /* For |dump_name| to be NULL is a bug.  */
+        /*tex For |dump_name| to be NULL is a bug. */
         if (!ini_version) {
           fprintf(stdout, "no format given, quitting\n");
           exit(1);
@@ -608,17 +604,17 @@ static void fix_dumpname(void)
     }
 }
 
-@ lua require patch
-
-@ Auxiliary function for kpse search
+/*tex
+    Auxiliary function for kpse search.
+*/
 
-@c
 static const char *luatex_kpse_find_aux(lua_State *L, const char *name,
-        kpse_file_format_type format, const char *errname)
+    kpse_file_format_type format, const char *errname)
 {
     const char *filename;
     const char *altname;
-    altname = luaL_gsub(L, name, ".", "/"); /* Lua convention */
+    /*tex Lua convention */
+    altname = luaL_gsub(L, name, ".", "/");
     filename = kpse_find_file(altname, format, false);
     if (filename == NULL) {
         filename = kpse_find_file(name, format, false);
@@ -629,16 +625,17 @@ static const char *luatex_kpse_find_aux(lua_State *L, const char *name,
     return filename;
 }
 
-@ The lua search function.
+/*tex
+
+    Here comes the \LUA\ search function. When kpathsea is not initialized, then it
+    runs the normal \LUA\ function that is saved in the registry, otherwise it uses
+    kpathsea.
 
-When kpathsea is not initialized, then it runs the
-normal lua function that is saved in the registry, otherwise
-it uses kpathsea.
+    Two registry ref variables are needed: one for the actual \LUA\ function, the
+    other for its environment .
 
-two registry ref variables are needed: one for the actual lua
-function, the other for its environment .
+*/
 
-@c
 static int lua_loader_function = 0;
 
 static int luatex_kpse_lua_find(lua_State * L)
@@ -653,16 +650,18 @@ static int luatex_kpse_lua_find(lua_State * L)
         return 1;
     }
     filename = luatex_kpse_find_aux(L, name, kpse_lua_format, "lua");
-    if (filename == NULL)
-        return 1;               /* library not found in this path */
+    if (filename == NULL) {
+        /*tex library not found in this path */
+        return 1;
+    }
     if (luaL_loadfile(L, filename) != 0) {
         luaL_error(L, "error loading module %s from file %s:\n\t%s",
-                   lua_tostring(L, 1), filename, lua_tostring(L, -1));
+            lua_tostring(L, 1), filename, lua_tostring(L, -1));
     }
-    return 1;                   /* library loaded successfully */
+    /*tex library loaded successfully */
+    return 1;
 }
 
-@ @c
 static int clua_loader_function = 0;
 extern int searcher_C_luatex (lua_State *L, const char *name, const char *filename);
 
@@ -671,8 +670,9 @@ static int luatex_kpse_clua_find(lua_State * L)
     const char *filename;
     const char *name;
     if (safer_option) {
+        /*tex library not found in this path */
         lua_pushliteral(L, "\n\t[C searcher disabled in safer mode]");
-        return 1;               /* library not found in this path */
+        return 1;
     }
     name = luaL_checkstring(L, 1);
     if (program_name_set == 0) {
@@ -687,12 +687,16 @@ static int luatex_kpse_clua_find(lua_State * L)
         char *temp_name;
         int j;
         filename = luatex_kpse_find_aux(L, name, kpse_clua_format, "C");
-        if (filename == NULL)
-           return 1;               /* library not found in this path */
+        if (filename == NULL) {
+            /*tex library not found in this path */
+            return 1;
+        }
         extensionless = strdup(filename);
-        if (!extensionless)
-            return 1;  /* allocation failure */
-        /* Fix Issue 850: replace '.' with LUA_DIRSEP */
+        if (!extensionless) {
+            /*tex allocation failure */
+            return 1;
+        }
+        /*tex Replace '.' with |LUA_DIRSEP| */
         temp_name = strdup(name);
         for(j=0; ; j++){
           if ((unsigned char)temp_name[j]=='\0') {
@@ -703,33 +707,44 @@ static int luatex_kpse_clua_find(lua_State * L)
           }
         }
         p = strstr(extensionless, temp_name);
-        if (!p) return 1;  /* this would be exceedingly weird */
+        if (!p) {
+            /*tex this would be exceedingly weird */
+            return 1;
+        }
         *p = '\0';
         prefix = strdup(extensionless);
-        if (!prefix) return 1;  /* allocation failure */
+        if (!prefix) {
+            /*tex allocation failure */
+            return 1;
+        }
         postfix = strdup(p+strlen(name));
-        if (!postfix) return 1;  /* allocation failure */
+        if (!postfix) {
+            /*tex allocation failure */
+            return 1;
+        }
         total = malloc(strlen(prefix)+strlen(postfix)+2);
         if (!total) return 1;  /* allocation failure */
         snprintf(total,strlen(prefix)+strlen(postfix)+2, "%s?%s", prefix, postfix);
-        /* save package.path */
+        /*tex save package.path */
         lua_getglobal(L,"package");
         lua_getfield(L,-1,"cpath");
         path_saved = lua_tostring(L,-1);
         lua_pop(L,1);
-        /* set package.path = "?" */
+        /*tex set package.path = "?" */
         lua_pushstring(L,total);
         lua_setfield(L,-2,"cpath");
-        lua_pop(L,1); /* pop "package" */
-        /* run function */
+        /*tex pop ``package'' */
+        lua_pop(L,1);
+        /*tex run function */
         lua_rawgeti(L, LUA_REGISTRYINDEX, clua_loader_function);
         lua_pushstring(L, name);
         lua_call(L, 1, 1);
-        /* restore package.path */
+        /*tex restore package.path */
         lua_getglobal(L,"package");
         lua_pushstring(L,path_saved);
         lua_setfield(L,-2,"cpath");
-        lua_pop(L,1); /* pop "package" */
+        /*tex pop ``package'' */
+        lua_pop(L,1);
         free(extensionless);
         free(total);
         free(temp_name);
@@ -737,12 +752,13 @@ static int luatex_kpse_clua_find(lua_State * L)
     }
 }
 
-@ Setting up the new search functions.
+/*tex
+
+    Setting up the new search functions. This replaces package.searchers[2] and
+    package.searchers[3] with the functions defined above.
 
-This replaces package.searchers[2] and package.searchers[3] with the
-functions defined above.
+*/
 
-@c
 static void setup_lua_path(lua_State * L)
 {
     lua_getglobal(L, "package");
@@ -751,46 +767,45 @@ static void setup_lua_path(lua_State * L)
 #else
     lua_getfield(L, -1, "searchers");
 #endif
-    lua_rawgeti(L, -1, 2);      /* package.searchers[2] */
+    /*tex package.searchers[2] */
+    lua_rawgeti(L, -1, 2);
     lua_loader_function = luaL_ref(L, LUA_REGISTRYINDEX);
     lua_pushcfunction(L, luatex_kpse_lua_find);
-    lua_rawseti(L, -2, 2);      /* replace the normal lua loader */
-
-    lua_rawgeti(L, -1, 3);      /* package.searchers[3] */
+    /*tex replace the normal lua loader */
+    lua_rawseti(L, -2, 2);
+    /*tex package.searchers[3] */
+    lua_rawgeti(L, -1, 3);
     clua_loader_function = luaL_ref(L, LUA_REGISTRYINDEX);
     lua_pushcfunction(L, luatex_kpse_clua_find);
-    lua_rawseti(L, -2, 3);      /* replace the normal lua lib loader */
-
-    lua_pop(L, 2);              /* pop the array and table */
+    /*tex replace the normal lua lib loader */
+    lua_rawseti(L, -2, 3);
+    /*tex pop the array and table */
+    lua_pop(L, 2);
 }
 
-@ helper variables for the safe keeping of table ids
+/*tex
+
+    Helper variables for the safe keeping of table ids.
 
-@c
-/*
-int tex_table_id;
-int pdf_table_id;
-int token_table_id;
-int node_table_id;
 */
 
-@ @c
 int l_pack_type_index       [PACK_TYPE_SIZE] ;
 int l_group_code_index      [GROUP_CODE_SIZE];
 int l_local_par_index       [LOCAL_PAR_SIZE];
 int l_math_style_name_index [MATH_STYLE_NAME_SIZE];
 int l_dir_par_index         [DIR_PAR_SIZE];
-int l_dir_text_index        [DIR_TEXT_SIZE];
+int l_dir_text_index_normal [DIR_TEXT_SIZE];
+int l_dir_text_index_cancel [DIR_TEXT_SIZE];
 
 int img_parms               [img_parms_max];
 int img_pageboxes           [img_pageboxes_max];
 
-int lua_show_valid_list(lua_State *L, const char **list, int max)
+int lua_show_valid_list(lua_State *L, const char **list, int offset, int max)
 {
     int i;
     lua_newtable(L);
     for (i = 0; i < max; i++) {
-        lua_pushinteger(L,i+1);
+        lua_pushinteger(L,i+offset);
         lua_pushstring(L, list[i]);
         lua_settable(L, -3);
     }
@@ -812,28 +827,31 @@ int lua_show_valid_keys(lua_State *L, int *list, int max)
 #if defined(WIN32) || defined(__MINGW32__) || defined(__CYGWIN__)
 char **suffixlist;
 
-#  define EXE_SUFFIXES ".com;.exe;.bat;.cmd;.vbs;.vbe;.js;.jse;.wsf;.wsh;.ws;.tcl;.py;.pyw"
+/* Why do we add script stuff to this weird incomplete. Let's go more minimal. */
+
+/*
+    #define EXE_SUFFIXES ".com;.exe;.bat;.cmd;.vbs;.vbe;.js;.jse;.wsf;.wsh;.ws;.tcl;.py;.pyw"
+*/
+
+#define EXE_SUFFIXES ".com;.exe;.bat;.cmd"
 
-@ @c
 static void mk_suffixlist(void)
 {
     char **p;
     char *q, *r, *v;
     int n;
-
 #  if defined(__CYGWIN__)
     v = xstrdup(EXE_SUFFIXES);
 #  else
     v = (char *) getenv("PATHEXT");
-    if (v)                      /* strlwr() exists also in MingW */
+    /*tex strlwr() exists also in MingW */
+    if (v)
         v = (char *) strlwr(xstrdup(v));
     else
         v = xstrdup(EXE_SUFFIXES);
 #  endif
-
     q = v;
     n = 0;
-
     while ((r = strchr(q, ';')) != NULL) {
         n++;
         r++;
@@ -862,12 +880,10 @@ static void mk_suffixlist(void)
 }
 #endif
 
-@ @c
 void lua_initialize(int ac, char **av)
 {
     char *given_file = NULL;
     char *banner;
-    /*int kpse_init;*/
     size_t len;
     int starttime;
     int utc;
@@ -878,7 +894,7 @@ void lua_initialize(int ac, char **av)
     char *old_locale = NULL;
     char *env_locale = NULL;
     char *tmp = NULL;
-    /* Save to pass along to topenin.  */
+    /*tex Save to pass along to topenin. */
     const char *fmt = "This is " MyName ", Version %s" WEB2CVERSION;
     argc = ac;
     argv = av;
@@ -887,8 +903,7 @@ void lua_initialize(int ac, char **av)
     sprintf(banner, fmt, luatex_version_string);
     luatex_banner = banner;
     kpse_invocation_name = kpse_program_basename(argv[0]);
-
-    /* be 'luac' */
+    /*tex be `luac' */
     if (argc >1) {
 #ifdef LuajitTeX
         if (FILESTRCASEEQ(kpse_invocation_name, "texluajitc"))
@@ -911,106 +926,104 @@ void lua_initialize(int ac, char **av)
 #if defined(WIN32) || defined(__MINGW32__) || defined(__CYGWIN__)
     mk_suffixlist();
 #endif
-
-    /* Must be initialized before options are parsed.  */
+    /*tex Must be initialized before options are parsed.  */
     interactionoption = 4;
     dump_name = NULL;
-
-    /* 0 means "disable Synchronize TeXnology".
-     synctexoption is a *.web variable.
-     We initialize it to a weird value to catch the -synctex command line flag
-     At runtime, if synctexoption is not |INT_MAX|, then it contains the command line option provided,
-     otherwise no such option was given by the user. */
+    /*tex
+        In the next option 0 means ``disable Synchronize TeXnology''. The
+        |synctexoption| is a *.web variable. We initialize it to a weird value to
+        catch the -synctex command line flag At runtime, if synctexoption is not
+        |INT_MAX|, then it contains the command line option provided, otherwise
+        no such option was given by the user.
+    */
 #define SYNCTEX_NO_OPTION INT_MAX
     synctexoption = SYNCTEX_NO_OPTION;
-
-    /* parse commandline */
+    /*tex parse commandline */
     parse_options(ac, av);
     if (lua_only) {
-        /* Shell has no restrictions. */
+        /*tex Shell has no restrictions. */
         shellenabledp = true;
         restrictedshell = false;
         safer_option = 0;
     }
-    /* Get the current locale (it should be C )          */
-    /* and save LC_CTYPE, LC_COLLATE and LC_NUMERIC.     */
-    /* Later luainterpreter() will consciously use them. */
+    /*tex
+        Get the current locale (it should be |C|) and save |LC_CTYPE|, |LC_COLLATE|
+        and |LC_NUMERIC|. Later |luainterpreter()| will consciously use them.
+    */
     old_locale = xstrdup(setlocale (LC_ALL, NULL));
     lc_ctype = NULL;
     lc_collate = NULL;
     lc_numeric = NULL;
     if (old_locale) {
-        /* If setlocale fails here, then the state   */
-        /* could be compromised, and we exit.        */
+        /*tex
+            If |setlocale| fails here, then the state could be compromised, and
+            we exit.
+        */
         env_locale = setlocale (LC_ALL, "");
-	if (!env_locale && !lua_only) {
-	  fprintf(stderr,"Unable to read environment locale: exit now.\n");
-	  exit(1);
-	}
+        if (!env_locale && !lua_only) {
+            fprintf(stderr,"Unable to read environment locale: exit now.\n");
+            exit(1);
+        }
         tmp = setlocale (LC_CTYPE, NULL);
-	if (tmp) {
-	  lc_ctype = xstrdup(tmp);
+        if (tmp) {
+            lc_ctype = xstrdup(tmp);
         }
-	tmp = setlocale (LC_COLLATE, NULL);
-	if (tmp){
-	  lc_collate = xstrdup(tmp);
+        tmp = setlocale (LC_COLLATE, NULL);
+        if (tmp) {
+            lc_collate = xstrdup(tmp);
         }
-	tmp = setlocale (LC_NUMERIC, NULL);
-	if (tmp){
-	  lc_numeric = xstrdup(tmp);
+        tmp = setlocale (LC_NUMERIC, NULL);
+        if (tmp) {
+            lc_numeric = xstrdup(tmp);
+        }
+        /*tex
+            Return to the previous locale if possible, otherwise it's a serious
+            error and we exit: we can't ensure a 'sane' locale for lua.
+        */
+        env_locale = setlocale (LC_ALL, old_locale);
+        if (!env_locale) {
+          fprintf(stderr,"Unable to restore original locale %s: exit now.\n",old_locale);
+          exit(1);
         }
-	/* Back to the previous locale if possible,   */
-	/* otherwise it's a serious error and we exit:*/
-	/* we can't ensure a 'sane' locale for lua.   */
-	env_locale = setlocale (LC_ALL, old_locale);
-	if (!env_locale) {
-	  fprintf(stderr,"Unable to restore original locale %s: exit now.\n",old_locale);
-	  exit(1);
-	}
         xfree(old_locale);
     } else {
        fprintf(stderr,"Unable to store environment locale.\n");
     }
-
-    /* make sure that the locale is 'sane' (for lua) */
+    /*tex make sure that the locale is 'sane' (for lua) */
     putenv(LC_CTYPE_C);
     putenv(LC_COLLATE_C);
     putenv(LC_NUMERIC_C);
-
-    /* this is sometimes needed */
+    /*tex this is sometimes needed */
     putenv(engine_luatex);
-
     luainterpreter();
-
-    /* init internalized strings */
+    /*tex init internalized strings */
     set_init_keys;
-
     lua_pushstring(Luas,"lua.functions");
     lua_newtable(Luas);
     lua_settable(Luas,LUA_REGISTRYINDEX);
-
-    /* here start the key definitions */
+    /*tex here start the key definitions */
     set_l_pack_type_index;
     set_l_group_code_index;
     set_l_local_par_index;
     set_l_math_style_name_index;
     set_l_dir_par_index;
     set_l_dir_text_index;
-
+    l_set_node_data();
+    l_set_whatsit_data();
+    l_set_token_data();
     set_l_img_keys_index;
     set_l_img_pageboxes_index;
-
-    prepare_cmdline(Luas, argv, argc, lua_offset);      /* collect arguments */
+    /*tex collect arguments */
+    prepare_cmdline(Luas, argv, argc, lua_offset);
     setup_lua_path(Luas);
-
     if (startup_filename != NULL) {
         given_file = xstrdup(startup_filename);
         if (lua_only) {
-          xfree(startup_filename);
+            xfree(startup_filename);
         }
         startup_filename = find_filename(given_file, "LUATEXDIR");
     }
-    /* now run the file */
+    /*tex now run the file */
     if (startup_filename != NULL) {
         char *v1;
         int tex_table_id = hide_lua_table(Luas, "tex");
@@ -1018,7 +1031,7 @@ void lua_initialize(int ac, char **av)
         int node_table_id = hide_lua_table(Luas, "node");
         int pdf_table_id = hide_lua_table(Luas, "pdf");
         if (lua_only) {
-            /* hide the 'tex' and 'pdf' table */
+            /*tex hide the 'tex' and 'pdf' table */
             if (load_luatex_core_lua(Luas)) {
                 fprintf(stderr, "Error in execution of luatex-core.lua .\n");
             }
@@ -1026,20 +1039,20 @@ void lua_initialize(int ac, char **av)
                 fprintf(stdout, "%s\n", lua_tostring(Luas, -1));
                 exit(1);
             }
-            init_tex_table(Luas); /* needed ? */
+            init_tex_table(Luas);
             if (lua_pcall(Luas, 0, 0, 0)) {
                 fprintf(stdout, "%s\n", lua_tostring(Luas, -1));
                 lua_traceback(Luas);
-             /* lua_close(Luas); */
+             /*tex lua_close(Luas); */
                 exit(1);
             } else {
                 if (given_file)
                     free(given_file);
-             /* lua_close(Luas); */
+                /*tex lua_close(Luas); */
                 exit(0);
             }
         }
-        /* a normal tex run */
+        /*tex a normal tex run */
         init_tex_table(Luas);
         unhide_lua_table(Luas, "tex", tex_table_id);
         unhide_lua_table(Luas, "pdf", pdf_table_id);
@@ -1060,28 +1073,25 @@ void lua_initialize(int ac, char **av)
         if (!dump_name) {
             get_lua_string("texconfig", "formatname", &dump_name);
         }
-        /* |kpse_init| */
         kpse_init = -1;
         get_lua_boolean("texconfig", "kpse_init", &kpse_init);
 
         if (kpse_init != 0) {
-            luainit = 0;        /* re-enable loading of texmf.cnf values, see luatex.ch */
+            /*tex re-enable loading of texmf.cnf values, see luatex.ch */
+            luainit = 0;
             init_kpse();
             kpse_init = 1;
         }
-        /* |prohibit_file_trace| (boolean) */
+        /*tex |prohibit_file_trace| (boolean) */
         tracefilenames = 1;
         get_lua_boolean("texconfig", "trace_file_names", &tracefilenames);
-
-        /* |file_line_error| */
+        /*tex |file_line_error| */
         filelineerrorstylep = false;
         get_lua_boolean("texconfig", "file_line_error", &filelineerrorstylep);
-
-        /* |halt_on_error| */
+        /*tex |halt_on_error| */
         haltonerrorp = false;
         get_lua_boolean("texconfig", "halt_on_error", &haltonerrorp);
-
-        /* |restrictedshell| */
+        /*tex |restrictedshell| */
         v1 = NULL;
         get_lua_string("texconfig", "shell_escape", &v1);
         if (v1) {
@@ -1093,7 +1103,7 @@ void lua_initialize(int ac, char **av)
             }
             free(v1);
         }
-        /* If shell escapes are restricted, get allowed cmds from cnf.  */
+        /*tex If shell escapes are restricted, get allowed cmds from cnf.  */
         if (shellenabledp && restrictedshell == 1) {
             v1 = NULL;
             get_lua_string("texconfig", "shell_escape_commands", &v1);
@@ -1102,11 +1112,10 @@ void lua_initialize(int ac, char **av)
             free(v1);
             }
         }
-
         starttime = -1 ;
         get_lua_number("texconfig", "start_time", &starttime);
         if (starttime < 0) {
-            /*
+            /*tex
                 We provide this one for compatibility reasons and therefore also in
                 uppercase.
             */
@@ -1115,38 +1124,32 @@ void lua_initialize(int ac, char **av)
         if (starttime >= 0) {
             set_start_time(starttime);
         }
-
         utc = -1 ;
         get_lua_boolean("texconfig", "use_utc_time", &utc);
         if (utc >= 0 && utc <= 1) {
             utc_option = utc;
         }
-
         fix_dumpname();
-    } else {
-        if (luainit) {
-            if (given_file) {
-                fprintf(stdout, "%s file %s not found\n", (lua_only ? "Script" : "Configuration"), given_file);
-                free(given_file);
-            } else {
-                fprintf(stdout, "No %s file given\n", (lua_only ? "script" : "configuration"));
-            }
-            exit(1);
+    } else if (luainit) {
+        if (given_file) {
+            fprintf(stdout, "%s file %s not found\n", (lua_only ? "Script" : "Configuration"), given_file);
+            free(given_file);
         } else {
-            /* init */
-            init_kpse();
-            kpse_init = 1;
-            fix_dumpname();
+            fprintf(stdout, "No %s file given\n", (lua_only ? "script" : "configuration"));
         }
+        exit(1);
+    } else {
+        /* init */
+        init_kpse();
+        kpse_init = 1;
+        fix_dumpname();
+    }
+    /*tex Here we load luatex-core.lua which takes care of some protection on demand. */
+    if (load_luatex_core_lua(Luas)) {
+        fprintf(stderr, "Error in execution of luatex-core.lua .\n");
     }
-
-    /* Here we load luatex-core.lua which takes care of some protection on demand. */
-    if (load_luatex_core_lua(Luas))
-      fprintf(stderr, "Error in execution of luatex-core.lua .\n");
-    /* Done. */
 }
 
-@ @c
 void check_texconfig_init(void)
 {
     if (Luas != NULL) {
@@ -1156,7 +1159,10 @@ void check_texconfig_init(void)
             if (lua_isfunction(Luas, -1)) {
                 int i = lua_pcall(Luas, 0, 0, 0);
                 if (i != 0) {
-                    /* Can't be more precise here, called before TeX initialization  */
+                    /*tex
+                        We can't be more precise hereas it's called before \TEX\
+                        initialization happens.
+                    */
                     fprintf(stderr, "This went wrong: %s\n", lua_tostring(Luas, -1));
                     error();
                 }
diff --git a/texk/web2c/luatexdir/lua/luanode.w b/texk/web2c/luatexdir/lua/luanode.c
similarity index 64%
rename from texk/web2c/luatexdir/lua/luanode.w
rename to texk/web2c/luatexdir/lua/luanode.c
index ef2f0b926..3182b6097 100644
--- a/texk/web2c/luatexdir/lua/luanode.w
+++ b/texk/web2c/luatexdir/lua/luanode.c
@@ -1,33 +1,32 @@
-% luanode.w
-%
-% Copyright 2006-2008 Taco Hoekwater <taco@@luatex.org>
-%
-% This file is part of LuaTeX.
-%
-% LuaTeX is free software; you can redistribute it and/or modify it under
-% the terms of the GNU General Public License as published by the Free
-% Software Foundation; either version 2 of the License, or (at your
-% option) any later version.
-%
-% LuaTeX is distributed in the hope that it will be useful, but WITHOUT
-% ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-% FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
-% License for more details.
-%
-% You should have received a copy of the GNU General Public License along
-% with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+/*
 
-/* hh-ls: we make sure that lua never sees prev of head but also that when
-nodes are removed or inserted, temp nodes don't interfere */
+luanode.w
 
-@ @c
+Copyright 2006-2008 Taco Hoekwater <taco@@luatex.org>
+
+This file is part of LuaTeX.
+
+LuaTeX is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 2 of the License, or (at your
+option) any later version.
+
+LuaTeX is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+License for more details.
+
+You should have received a copy of the GNU General Public License along
+with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+
+*/
 
 #include "ptexlib.h"
 #include "lua/luatex-api.h"
 
-@ @c
 void lua_node_filter_s(int filterid, int extrainfo)
 {
+    int i;
     int callback_id = callback_defined(filterid);
     int s_top = lua_gettop(Luas);
     if (callback_id <= 0) {
@@ -38,20 +37,20 @@ void lua_node_filter_s(int filterid, int extrainfo)
         lua_settop(Luas, s_top);
         return;
     }
-    lua_push_string_by_index(Luas,extrainfo); /* arg 1 */
-    if (lua_pcall(Luas, 1, 0, 0) != 0) {
-        fprintf(stdout, "error: %s\n", lua_tostring(Luas, -1));
+    lua_push_string_by_index(Luas,extrainfo);
+    if ((i=lua_pcall(Luas, 1, 0, 0)) != 0) {
+        formatted_warning("node filter","error: %s", lua_tostring(Luas, -1));
         lua_settop(Luas, s_top);
-        error();
+        luatex_error(Luas, (i == LUA_ERRRUN ? 0 : 1));
         return;
     }
     lua_settop(Luas, s_top);
     return;
 }
 
-@ @c
 void lua_node_filter(int filterid, int extrainfo, halfword head_node, halfword * tail_node)
 {
+    int i;
     halfword start_node, start_done, last_node;
     int s_top = lua_gettop(Luas);
     int callback_id = callback_defined(filterid);
@@ -59,45 +58,45 @@ void lua_node_filter(int filterid, int extrainfo, halfword head_node, halfword *
         lua_settop(Luas, s_top);
         return;
     }
-    /* we start after head */
+    /*tex We start after head. */
     start_node = vlink(head_node);
     if (start_node == null || !get_callback(Luas, callback_id)) {
         lua_settop(Luas, s_top);
         return;
     }
-    /* we make sure we have no prev */
+    /*tex We make sure we have no prev */
     alink(start_node) = null ;
-    /* the action */
+    /*tex the action */
     nodelist_to_lua(Luas, start_node);
     lua_push_group_code(Luas,extrainfo);
-    if (lua_pcall(Luas, 2, 1, 0) != 0) {
-        fprintf(stdout, "error: %s\n", lua_tostring(Luas, -1));
+    if ((i=lua_pcall(Luas, 2, 1, 0)) != 0) {
+        formatted_warning("node filter", "error: %s\n", lua_tostring(Luas, -1));
         lua_settop(Luas, s_top);
-        error();
+        luatex_error(Luas, (i == LUA_ERRRUN ? 0 : 1));
         return;
     }
-    /* the result */
+    /*tex the result */
     if (lua_isboolean(Luas, -1)) {
         if (lua_toboolean(Luas, -1) != 1) {
-            /* discard */
+            /*tex discard */
             flush_node_list(start_node);
             vlink(head_node) = null;
         } else {
-            /* keep */
+            /*tex keep */
         }
     } else {
-        /* append to old head */
-        start_done = nodelist_from_lua(Luas);
+        /*tex append to old head */
+        start_done = nodelist_from_lua(Luas,-1);
         try_couple_nodes(head_node,start_done);
     }
-    /* redundant as we set top anyway */
+    /*tex redundant as we set top anyway */
     lua_pop(Luas, 2);
-    /* find tail in order to update tail */
+    /*tex find tail in order to update tail */
     start_node = vlink(head_node);
     if (start_node != null) {
-        /* maybe just always slide (harmless and fast) */
+        /*tex maybe just always slide (harmless and fast) */
         if (fix_node_lists) {
-            /* slides and returns last node */
+            /*tex slides and returns last node */
             *tail_node = fix_node_list(start_node);
         } else {
             last_node = vlink(start_node);
@@ -105,24 +104,23 @@ void lua_node_filter(int filterid, int extrainfo, halfword head_node, halfword *
                 start_node = last_node;
                 last_node = vlink(start_node);
             }
-            /* we're at the end now */
+            /*tex we're at the end now */
             *tail_node = start_node;
         }
     } else {
-        /* we're already at the end */
+        /*tex we're already at the end */
         *tail_node = head_node;
     }
-    /* clean up */
+    /*tex clean up */
     lua_settop(Luas, s_top);
     return;
 }
 
-@ @c
 int lua_linebreak_callback(int is_broken, halfword head_node, halfword * new_head)
 {
-    int a;
+    int a, i;
     register halfword *p;
-    int ret = 0;                /* failure */
+    int ret = 0;
     int s_top = lua_gettop(Luas);
     int callback_id = callback_defined(linebreak_filter_callback);
     if (head_node == null || vlink(head_node) == null || callback_id <= 0) {
@@ -130,32 +128,33 @@ int lua_linebreak_callback(int is_broken, halfword head_node, halfword * new_hea
         return ret;
     }
     if (!get_callback(Luas, callback_id)) {
-       lua_settop(Luas, s_top);
+        lua_settop(Luas, s_top);
         return ret;
     }
-    alink(vlink(head_node)) = null ; /* hh-ls */
-    nodelist_to_lua(Luas, vlink(head_node));       /* arg 1 */
-    lua_pushboolean(Luas, is_broken);      /* arg 2 */
-    if (lua_pcall(Luas, 2, 1, 0) != 0) {   /* no arg, 1 result */
-        fprintf(stdout, "error: %s\n", lua_tostring(Luas, -1));
+    alink(vlink(head_node)) = null ;
+    nodelist_to_lua(Luas, vlink(head_node));
+    lua_pushboolean(Luas, is_broken);
+    if ((i=lua_pcall(Luas, 2, 1, 0)) != 0) {
+        formatted_warning("linebreak", "error: %s", lua_tostring(Luas, -1));
         lua_settop(Luas, s_top);
-        error();
+        luatex_error(Luas, (i == LUA_ERRRUN ? 0 : 1));
         return ret;
     }
+    lua_settop(Luas, s_top);
     p = lua_touserdata(Luas, -1);
     if (p != NULL) {
-        a = nodelist_from_lua(Luas);
+        a = nodelist_from_lua(Luas,-1);
         try_couple_nodes(*new_head,a);
         ret = 1;
     }
-    lua_settop(Luas, s_top);
     return ret;
 }
 
-@ @c
-int lua_appendtovlist_callback(halfword box, int location, halfword prev_depth, boolean is_mirrored, halfword * result, int * next_depth, boolean * prev_set)
+int lua_appendtovlist_callback(halfword box, int location, halfword prev_depth,
+    boolean is_mirrored, halfword * result, int * next_depth, boolean * prev_set)
 {
     register halfword *p;
+    int i;
     int s_top = lua_gettop(Luas);
     int callback_id = callback_defined(append_to_vlist_filter_callback);
     if (box == null || callback_id <= 0) {
@@ -170,10 +169,10 @@ int lua_appendtovlist_callback(halfword box, int location, halfword prev_depth,
     lua_push_string_by_index(Luas,location);
     lua_pushinteger(Luas, (int) prev_depth);
     lua_pushboolean(Luas, is_mirrored);
-    if (lua_pcall(Luas, 4, 2, 0) != 0) {
-        fprintf(stdout, "error: %s\n", lua_tostring(Luas, -1));
+    if ((i=lua_pcall(Luas, 4, 2, 0)) != 0) {
+        formatted_warning("append to vlist","error: %s", lua_tostring(Luas, -1));
         lua_settop(Luas, s_top);
-        error();
+        luatex_error(Luas, (i == LUA_ERRRUN ? 0 : 1));
         return 0;
     }
     if (lua_type(Luas,-1) == LUA_TNUMBER) {
@@ -187,13 +186,13 @@ int lua_appendtovlist_callback(halfword box, int location, halfword prev_depth,
         p = check_isnode(Luas, -1);
         *result = *p;
     }
-    lua_settop(Luas, s_top);
     return 1;
 }
 
-@ @c
-halfword lua_hpack_filter(halfword head_node, scaled size, int pack_type, int extrainfo, int pack_direction, halfword attr)
+halfword lua_hpack_filter(halfword head_node, scaled size, int pack_type, int extrainfo,
+    int pack_direction, halfword attr)
 {
+    int i;
     halfword ret;
     int s_top = lua_gettop(Luas);
     int callback_id = callback_defined(hpack_filter_callback);
@@ -205,7 +204,7 @@ halfword lua_hpack_filter(halfword head_node, scaled size, int pack_type, int ex
         lua_settop(Luas, s_top);
         return head_node;
     }
-    alink(head_node) = null ; /* hh-ls */
+    alink(head_node) = null ;
     nodelist_to_lua(Luas, head_node);
     lua_push_group_code(Luas,extrainfo);
     lua_pushinteger(Luas, size);
@@ -220,10 +219,10 @@ halfword lua_hpack_filter(halfword head_node, scaled size, int pack_type, int ex
     } else {
         lua_pushnil(Luas);
     }
-    if (lua_pcall(Luas, 6, 1, 0) != 0) {
-        fprintf(stdout, "error: %s\n", lua_tostring(Luas, -1));
+    if ((i=lua_pcall(Luas, 6, 1, 0)) != 0) {
+        formatted_warning("hpack filter", "error: %s\n", lua_tostring(Luas, -1));
         lua_settop(Luas, s_top);
-        error();
+        luatex_error(Luas, (i == LUA_ERRRUN ? 0 : 1));
         return head_node;
     }
     ret = head_node;
@@ -233,29 +232,26 @@ halfword lua_hpack_filter(halfword head_node, scaled size, int pack_type, int ex
             ret = null;
         }
     } else {
-        ret = nodelist_from_lua(Luas);
+        ret = nodelist_from_lua(Luas,-1);
     }
     lua_settop(Luas, s_top);
-#if 0
-    lua_gc(Luas,LUA_GCSTEP, LUA_GC_STEP_SIZE);
-#endif
     if (fix_node_lists)
         fix_node_list(ret);
     return ret;
 }
 
-@ @c
 halfword lua_vpack_filter(halfword head_node, scaled size, int pack_type, scaled maxd,
-                 int extrainfo, int pack_direction, halfword attr)
+    int extrainfo, int pack_direction, halfword attr)
 {
     halfword ret;
+    int i;
     int callback_id;
     int s_top = lua_gettop(Luas);
     if (head_node == null) {
         lua_settop(Luas, s_top);
         return head_node;
     }
-    if  (extrainfo == 8)  { /* output */
+    if  (extrainfo == 8)  {
         callback_id = callback_defined(pre_output_filter_callback);
     } else {
         callback_id = callback_defined(vpack_filter_callback);
@@ -268,7 +264,7 @@ halfword lua_vpack_filter(halfword head_node, scaled size, int pack_type, scaled
         lua_settop(Luas, s_top);
         return head_node;
     }
-    alink(head_node) = null ; /* hh-ls */
+    alink(head_node) = null ;
     nodelist_to_lua(Luas, head_node);
     lua_push_group_code(Luas, extrainfo);
     lua_pushinteger(Luas, size);
@@ -284,10 +280,10 @@ halfword lua_vpack_filter(halfword head_node, scaled size, int pack_type, scaled
     } else {
         lua_pushnil(Luas);
     }
-    if (lua_pcall(Luas, 7, 1, 0) != 0) {
-        fprintf(stdout, "error: %s\n", lua_tostring(Luas, -1));
+    if ((i=lua_pcall(Luas, 7, 1, 0)) != 0) {
+        formatted_warning("vpack filter", "error: %s", lua_tostring(Luas, -1));
         lua_settop(Luas, s_top);
-        error();
+        luatex_error(Luas, (i == LUA_ERRRUN ? 0 : 1));
         return head_node;
     }
     ret = head_node;
@@ -297,76 +293,84 @@ halfword lua_vpack_filter(halfword head_node, scaled size, int pack_type, scaled
             ret = null;
         }
     } else {
-        ret = nodelist_from_lua(Luas);
+        ret = nodelist_from_lua(Luas,-1);
     }
     lua_settop(Luas, s_top);
-#if 0
-    lua_gc(Luas,LUA_GCSTEP, LUA_GC_STEP_SIZE);
-#endif
     if (fix_node_lists)
         fix_node_list(ret);
     return ret;
 }
 
-@ This is a quick hack to fix etex's \.{\\lastnodetype} now that
-  there are many more visible node types. TODO: check the
-  eTeX manual for the expected return values.
+/*tex
+
+    This is a quick hack to fix \ETEX's \.{\\lastnodetype} now that there are many
+    more visible node types.
+
+*/
 
-@c
 int visible_last_node_type(int n)
 {
     int i = type(n);
     if (i != glyph_node) {
         return get_etex_code(i);
     } else if (is_ligature(n)) {
-        return 7; /* old ligature value */
+        /*tex old ligature value */
+        return 7;
     } else {
-        return 0; /* old character value */
+        /*tex old character value */
+        return 0;
     }
 }
 
-@ @c
-void lua_pdf_literal(PDF pdf, int i)
+void lua_pdf_literal(PDF pdf, int i, int noline)
 {
     const char *s = NULL;
     size_t l = 0;
     lua_rawgeti(Luas, LUA_REGISTRYINDEX, i);
     s = lua_tolstring(Luas, -1, &l);
-    pdf_out_block(pdf, s, l);
-    pdf_out(pdf, 10);           /* |pdf_print_nl| */
+    if (noline) {
+        pdf_check_space(pdf);
+        pdf_out_block(pdf, s, l);
+        pdf_set_space(pdf);
+    } else {
+        pdf_out_block(pdf, s, l);
+        pdf_out(pdf, 10);
+    }
     lua_pop(Luas, 1);
 }
 
-@ @c
 void copy_pdf_literal(pointer r, pointer p)
 {
-    pdf_literal_type(r) = pdf_literal_type(p);
+    int t = pdf_literal_type(p);
+    pdf_literal_type(r) = t;
     pdf_literal_mode(r) = pdf_literal_mode(p);
-    if (pdf_literal_type(p) == normal) {
+    if (t == normal) {
         pdf_literal_data(r) = pdf_literal_data(p);
         add_token_ref(pdf_literal_data(p));
-    } else {
+    } else if (t == lua_refid_literal) {
         lua_rawgeti(Luas, LUA_REGISTRYINDEX, pdf_literal_data(p));
         pdf_literal_data(r) = luaL_ref(Luas, LUA_REGISTRYINDEX);
+    } else {
+        /* maybe something user, we don't support a call here but best keep it sane anyway. */
+        pdf_literal_data(r) = pdf_literal_data(p);
     }
 }
 
-@ @c
 void copy_late_lua(pointer r, pointer p)
 {
-    late_lua_type(r) = late_lua_type(p);
+    int t = late_lua_type(p);
+    late_lua_type(r) = t;
     if (late_lua_name(p) > 0)
         add_token_ref(late_lua_name(p));
-    if (late_lua_type(p) == normal) {
+    if (t == normal) {
         late_lua_data(r) = late_lua_data(p);
         add_token_ref(late_lua_data(p));
-    } else {
+    } else if (t == lua_refid_literal) {
         lua_rawgeti(Luas, LUA_REGISTRYINDEX, late_lua_data(p));
         late_lua_data(r) = luaL_ref(Luas, LUA_REGISTRYINDEX);
     }
 }
 
-@ @c
 void copy_user_lua(pointer r, pointer p)
 {
     if (user_node_value(p) != 0) {
@@ -375,28 +379,28 @@ void copy_user_lua(pointer r, pointer p)
     }
 }
 
-@ @c
 void free_pdf_literal(pointer p)
 {
-    if (pdf_literal_type(p) == normal) {
+    int t = pdf_literal_type(p);
+    if (t == normal) {
         delete_token_ref(pdf_literal_data(p));
-    } else {
+    } else if (t == lua_refid_literal) {
         luaL_unref(Luas, LUA_REGISTRYINDEX, pdf_literal_data(p));
     }
 }
 
 void free_late_lua(pointer p)
 {
+    int t = late_lua_type(p);
     if (late_lua_name(p) > 0)
         delete_token_ref(late_lua_name(p));
-    if (late_lua_type(p) == normal) {
+    if (t == normal) {
         delete_token_ref(late_lua_data(p));
-    } else {
+    } else if (t == lua_refid_literal) {
         luaL_unref(Luas, LUA_REGISTRYINDEX, late_lua_data(p));
     }
 }
 
-@ @c
 void free_user_lua(pointer p)
 {
     if (user_node_value(p) != 0) {
@@ -404,9 +408,9 @@ void free_user_lua(pointer p)
     }
 }
 
-@ @c
 void show_pdf_literal(pointer p)
 {
+    int t = pdf_literal_type(p);
     tprint_esc("pdfliteral");
     switch (pdf_literal_mode(p)) {
         case set_origin:
@@ -422,30 +426,36 @@ void show_pdf_literal(pointer p)
             tprint(" raw");
             break;
         default:
-            confusion("literal2");
+            tprint(" <invalid mode>");
             break;
     }
-    if (pdf_literal_type(p) == normal) {
+    if (t == normal) {
         print_mark(pdf_literal_data(p));
+    } else if (t == lua_refid_literal) {
+        tprint(" <lua data reference ");
+        print_int(pdf_literal_data(p));
+        tprint(">");
     } else {
-        lua_rawgeti(Luas, LUA_REGISTRYINDEX, pdf_literal_data(p));
-        tprint("\"");
-        tprint(lua_tostring(Luas, -1));
-        tprint("\"");
-        lua_pop(Luas, 1);
+        tprint(" <invalid data>");
     }
 }
 
-@ @c
 void show_late_lua(pointer p)
 {
+    int t = late_lua_type(p);
     tprint_esc("latelua");
     print_int(late_lua_reg(p));
-    if (late_lua_type(p) == normal) {
+    if (t == normal) {
         print_mark(late_lua_data(p));
-    } else {
-        tprint(" <function ");
+    } else if (t == lua_refid_literal) {
+        tprint(" <function reference ");
         print_int(late_lua_data(p));
         tprint(">");
+    } else if (t == lua_refid_call) {
+        tprint(" <functioncall reference ");
+        print_int(late_lua_data(p));
+        tprint(">");
+    } else {
+        tprint(" <invalid data>");
     }
 }
diff --git a/texk/web2c/luatexdir/lua/luastuff.w b/texk/web2c/luatexdir/lua/luastuff.c
similarity index 56%
rename from texk/web2c/luatexdir/lua/luastuff.w
rename to texk/web2c/luatexdir/lua/luastuff.c
index a2b1dd143..0d9342223 100644
--- a/texk/web2c/luatexdir/lua/luastuff.w
+++ b/texk/web2c/luatexdir/lua/luastuff.c
@@ -1,30 +1,32 @@
-% luastuff.w
-%
-% Copyright 2006-2013 Taco Hoekwater <taco@@luatex.org>
-%
-% This file is part of LuaTeX.
-%
-% LuaTeX is free software; you can redistribute it and/or modify it under
-% the terms of the GNU General Public License as published by the Free
-% Software Foundation; either version 2 of the License, or (at your
-% option) any later version.
-%
-% LuaTeX is distributed in the hope that it will be useful, but WITHOUT
-% ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-% FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
-% License for more details.
-%
-% You should have received a copy of the GNU General Public License along
-% with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
-
-@ @c
+/*
+
+luastuff.w
+
+Copyright 2006-2013 Taco Hoekwater <taco@@luatex.org>
+
+This file is part of LuaTeX.
+
+LuaTeX is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 2 of the License, or (at your
+option) any later version.
+
+LuaTeX is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+License for more details.
+
+You should have received a copy of the GNU General Public License along
+with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+
+*/
+
 #include "ptexlib.h"
 #include "lua/luatex-api.h"
 #ifdef LuajitTeX
 #include "lua/lauxlib_bridge.h"
 #endif
 
-@ @c
 lua_State *Luas = NULL;
 
 int luastate_bytes = 0;
@@ -45,31 +47,44 @@ int lua_active = 0;
     lua_pop(L, 1);
 #endif
 
-@ @c
 void make_table(lua_State * L, const char *tab, const char *mttab, const char *getfunc, const char *setfunc)
 {
-    /* make the table *//* |[{<tex>}]| */
-    lua_pushstring(L, tab);           /* |[{<tex>},"dimen"]| */
-    lua_newtable(L);                  /* |[{<tex>},"dimen",{}]| */
-    lua_settable(L, -3);              /* |[{<tex>}]| */
-    /* fetch it back */
-    lua_pushstring(L, tab);           /* |[{<tex>},"dimen"]| */
-    lua_gettable(L, -2);              /* |[{<tex>},{<dimen>}]| */
-    /* make the meta entries */
-    luaL_newmetatable(L, mttab);      /* |[{<tex>},{<dimen>},{<dimen_m>}]| */
-    lua_pushstring(L, "__index");     /* |[{<tex>},{<dimen>},{<dimen_m>},"__index"]| */
-    lua_pushstring(L, getfunc);       /* |[{<tex>},{<dimen>},{<dimen_m>},"__index","getdimen"]| */
-    lua_gettable(L, -5);              /* |[{<tex>},{<dimen>},{<dimen_m>},"__index",<tex.getdimen>]| */
-    lua_settable(L, -3);              /* |[{<tex>},{<dimen>},{<dimen_m>}]|  */
-    lua_pushstring(L, "__newindex");  /* |[{<tex>},{<dimen>},{<dimen_m>},"__newindex"]| */
-    lua_pushstring(L, setfunc);       /* |[{<tex>},{<dimen>},{<dimen_m>},"__newindex","setdimen"]| */
-    lua_gettable(L, -5);              /* |[{<tex>},{<dimen>},{<dimen_m>},"__newindex",<tex.setdimen>]| */
-    lua_settable(L, -3);              /* |[{<tex>},{<dimen>},{<dimen_m>}]| */
-    lua_setmetatable(L, -2);          /* |[{<tex>},{<dimen>}]| : assign the metatable */
-    lua_pop(L, 1);                    /* |[{<tex>}]| : clean the stack */
+    /*tex make the table *//* |[{<tex>}]| */
+    /*tex |[{<tex>},"dimen"]| */
+    lua_pushstring(L, tab);
+    /*tex |[{<tex>},"dimen",{}]| */
+    lua_newtable(L);
+    /*tex |[{<tex>}]| */
+    lua_settable(L, -3);
+    /*tex fetch it back */
+    /*tex |[{<tex>},"dimen"]| */
+    lua_pushstring(L, tab);
+    /*tex |[{<tex>},{<dimen>}]| */
+    lua_gettable(L, -2);
+    /*tex make the meta entries */
+    /*tex |[{<tex>},{<dimen>},{<dimen_m>}]| */
+    luaL_newmetatable(L, mttab);
+    /*tex |[{<tex>},{<dimen>},{<dimen_m>},"__index"]| */
+    lua_pushstring(L, "__index");
+    /*tex |[{<tex>},{<dimen>},{<dimen_m>},"__index","getdimen"]| */
+    lua_pushstring(L, getfunc);
+    /*tex |[{<tex>},{<dimen>},{<dimen_m>},"__index",<tex.getdimen>]| */
+    lua_gettable(L, -5);
+    /*tex |[{<tex>},{<dimen>},{<dimen_m>}]|  */
+    lua_settable(L, -3);
+    lua_pushstring(L, "__newindex");  /*tex |[{<tex>},{<dimen>},{<dimen_m>},"__newindex"]| */
+    /*tex |[{<tex>},{<dimen>},{<dimen_m>},"__newindex","setdimen"]| */
+    lua_pushstring(L, setfunc);
+    /*tex |[{<tex>},{<dimen>},{<dimen_m>},"__newindex",<tex.setdimen>]| */
+    lua_gettable(L, -5);
+    /*tex |[{<tex>},{<dimen>},{<dimen_m>}]| */
+    lua_settable(L, -3);
+    /*tex |[{<tex>},{<dimen>}]| : assign the metatable */
+    lua_setmetatable(L, -2);
+    /*tex |[{<tex>}]| : clean the stack */
+    lua_pop(L, 1);
 }
 
-@ @c
 static const char *getS(lua_State * L, void *ud, size_t * size)
 {
     LoadS *ls = (LoadS *) ud;
@@ -81,18 +96,19 @@ static const char *getS(lua_State * L, void *ud, size_t * size)
     return ls->s;
 }
 
-@ @c
 #ifdef LuajitTeX
-    /* Luatex has its own memory allocator, LuajitTeX uses the */
-    /* standard one from the stock. We left this space as      */
-    /* reference, but be careful: memory allocator is a key    */
-    /* component in luajit, it's easy to get sub-optimal       */
-    /* performances.                                           */
+    /*
+        \LUATEX\ has its own memory allocator, \LUAJIITEX\ uses the standard one
+        from the stock. We left this space as reference, but be careful: memory
+        allocator is a key component in \LUAJIT, it's easy to get sub-optimal
+        performances.
+    */
 #else
 static void *my_luaalloc(void *ud, void *ptr, size_t osize, size_t nsize)
 {
     void *ret = NULL;
-    (void) ud; /* for -Wunused */
+    /*tex define |ud| for -Wunused */
+    (void) ud;
     if (nsize == 0)
         free(ptr);
     else
@@ -102,15 +118,14 @@ static void *my_luaalloc(void *ud, void *ptr, size_t osize, size_t nsize)
 }
 #endif
 
-@ @c
 static int my_luapanic(lua_State * L)
 {
-    (void) L;  /* to avoid warnings */
+    /*tex define |L| to avoid warnings */
+    (void) L;
     fprintf(stderr, "PANIC: unprotected error in call to Lua API (%s)\n", lua_tostring(L, -1));
     return 0;
 }
 
-@ @c
 void luafunctioncall(int slot)
 {
     int i ;
@@ -120,12 +135,17 @@ void luafunctioncall(int slot)
     lua_gettable(Luas, LUA_REGISTRYINDEX);
     lua_rawgeti(Luas, -1,slot);
     if (lua_isfunction(Luas,-1)) {
-        int base = lua_gettop(Luas); /* function index */
+        /*tex function index */
+        int base = lua_gettop(Luas);
         lua_pushinteger(Luas, slot);
-        lua_pushcfunction(Luas, lua_traceback); /* push traceback function */
-        lua_insert(Luas, base); /* put it under chunk  */
+        /* push traceback function */
+        lua_pushcfunction(Luas, lua_traceback);
+        /*tex put it under chunk  */
+        lua_insert(Luas, base);
+        ++function_callback_count;
         i = lua_pcall(Luas, 1, 0, base);
-        lua_remove(Luas, base); /* remove traceback function */
+        /*tex remove traceback function */
+        lua_remove(Luas, base);
         if (i != 0) {
             lua_gc(Luas, LUA_GCCOLLECT, 0);
             Luas = luatex_error(Luas, (i == LUA_ERRRUN ? 0 : 1));
@@ -135,9 +155,8 @@ void luafunctioncall(int slot)
     lua_active--;
 }
 
-@ @c
 static const luaL_Reg lualibs[] = {
-    /* standard lua libraries */
+    /*tex standard \LUA\ libraries */
     { "_G",        luaopen_base },
     { "package",   luaopen_package },
     { "table",     luaopen_table },
@@ -149,32 +168,30 @@ static const luaL_Reg lualibs[] = {
     { "lpeg",      luaopen_lpeg },
     { "bit32",     luaopen_bit32 },
 #ifdef LuajitTeX
-    /* bit is only in luajit,               */
-    /* coroutine is loaded in a special way */
-    { "bit",	   luaopen_bit },
+    /*tex |bit| is only in \LUAJIT */
+    /*tex |coroutine| is loaded in a special way */
+    { "bit",       luaopen_bit },
 #else
 #if LUA_VERSION_NUM == 503
     { "utf8",      luaopen_utf8 },
 #endif
     { "coroutine", luaopen_coroutine },
 #endif
-    /* additional (public) libraries */
+    /*tex additional (public) libraries */
     { "unicode",   luaopen_unicode },
     { "zip",       luaopen_zip },
     { "md5",       luaopen_md5 },
+    { "sha2",      luaopen_sha2 },
     { "lfs",       luaopen_lfs },
-    /* extra standard lua libraries */
+    /*tex extra standard lua libraries */
 #ifdef LuajitTeX
     { "jit",       luaopen_jit },
 #endif
     { "ffi",       luaopen_ffi },
-    /* obsolete, undocumented and for oru own testing only */
-    /*{ "profiler",  luaopen_profiler }, */
-    /* more libraries will be loaded later */
+    /*tex more libraries will be loaded later */
     { NULL,        NULL }
 };
 
-@ @c
 static void do_openlibs(lua_State * L)
 {
     const luaL_Reg *lib = lualibs;
@@ -183,22 +200,23 @@ static void do_openlibs(lua_State * L)
     }
 }
 
-@ @c
 #ifdef LuajitTeX
-    /* in luajit load_aux is not used.*/
+    /*tex in \LUAJIT\ |load_aux| is not used.*/
 #else
 static int load_aux (lua_State *L, int status) {
-    if (status == 0)  /* OK? */
+    if (status == 0)
+        /*tex okay */
         return 1;
     else {
+        /*tex return nil plus error message */
         lua_pushnil(L);
-        lua_insert(L, -2);  /* put before error message */
-        return 2;  /* return nil plus error message */
+        /*tex put before error message */
+        lua_insert(L, -2);
+        return 2;
     }
 }
 #endif
 
-@ @c
 static int luatex_loadfile (lua_State *L) {
     int status = 0;
     const char *fname = luaL_optstring(L, 1, NULL);
@@ -206,12 +224,14 @@ static int luatex_loadfile (lua_State *L) {
 #ifdef LuajitTeX
     /* 5.1 */
 #else
-    int env = !lua_isnone(L, 3);  /* 'env' parameter? */
+    /*tex the |env| parameter */
+    int env = !lua_isnone(L, 3);
 #endif
     if (!lua_only && !fname && interaction == batch_mode) {
+        /*tex return |nil| plus error message */
         lua_pushnil(L);
         lua_pushstring(L, "reading from stdin is disabled in batch mode");
-        return 2;  /* return nil plus error message */
+        return 2;
     }
     status = luaL_loadfilex(L, fname, mode);
     if (status == LUA_OK) {
@@ -219,9 +239,11 @@ static int luatex_loadfile (lua_State *L) {
 #ifdef LuajitTeX
     /* 5.1 */
 #else
-        if (env) {  /* 'env' parameter? */
+        if (env) {
+            /*tex the |env| parameter */
             lua_pushvalue(L, 3);
-            lua_setupvalue(L, -2, 1);  /* set it as 1st upvalue of loaded chunk */
+            /*tex set it as first upvalue of loaded chunk */
+            lua_setupvalue(L, -2, 1);
         }
 #endif
     }
@@ -232,15 +254,15 @@ static int luatex_loadfile (lua_State *L) {
 #endif
 }
 
-@ @c
 static int luatex_dofile (lua_State *L) {
     const char *fname = luaL_optstring(L, 1, NULL);
     int n = lua_gettop(L);
     if (!lua_only && !fname) {
         if (interaction == batch_mode) {
+            /*tex return |nil| plus error message */
             lua_pushnil(L);
             lua_pushstring(L, "reading from stdin is disabled in batch mode");
-            return 2;  /* return nil plus error message */
+            return 2;
         } else {
             tprint_nl("lua> ");
         }
@@ -252,13 +274,12 @@ static int luatex_dofile (lua_State *L) {
     return lua_gettop(L) - n;
 }
 
-@ @c
 void luainterpreter(void)
 {
     lua_State *L;
 #ifdef LuajitTeX
     if (jithash_hashname == NULL) {
-        /* default lua51 */
+        /*tex default lua51 */
         luajittex_choose_hash_function = 0;
         jithash_hashname = (char *) xmalloc(strlen("lua51") + 1);
         jithash_hashname = strcpy ( jithash_hashname, "lua51");
@@ -267,7 +288,7 @@ void luainterpreter(void)
     } else if (strcmp((const char*)jithash_hashname,"luajit20") == 0) {
         luajittex_choose_hash_function = 1;
     } else {
-        /* default lua51 */
+        /*tex default lua51 */
         luajittex_choose_hash_function = 0;
         jithash_hashname = strcpy ( jithash_hashname, "lua51");
     }
@@ -280,8 +301,8 @@ void luainterpreter(void)
         return;
     }
     lua_atpanic(L, &my_luapanic);
-
-    do_openlibs(L);             /* does all the 'simple' libraries */
+    /*tex This initializes all the `simple' libraries: */
+    do_openlibs(L);
 #ifdef LuajitTeX
     if (luajiton){
        luaJIT_setmode(L, 0, LUAJIT_MODE_ENGINE|LUAJIT_MODE_ON);
@@ -290,22 +311,17 @@ void luainterpreter(void)
        luaJIT_setmode(L, 0, LUAJIT_MODE_ENGINE|LUAJIT_MODE_OFF);
     }
 #endif
-
     lua_pushcfunction(L,luatex_dofile);
     lua_setglobal(L, "dofile");
     lua_pushcfunction(L,luatex_loadfile);
     lua_setglobal(L, "loadfile");
-
     open_oslibext(L);
     open_strlibext(L);
-    open_lfslibext(L);
-
-    /*
-        The socket and mime libraries are a bit tricky to open because they use a load-time
-        dependency that has to be worked around for luatex, where the C module is loaded
-        way before the lua module.
+    /*tex
+        The socket and mime libraries are a bit tricky to open because they use a
+        load-time dependency that has to be worked around for luatex, where the C
+        module is loaded way before the lua module.
     */
-
     if (!nosocket_option) {
         /* todo: move this to common */
         lua_getglobal(L, "package");
@@ -315,28 +331,26 @@ void luainterpreter(void)
             lua_setfield(L, -2, "loaded");
             lua_getfield(L, -1, "loaded");
         }
+        /*tex |package.loaded.socket = nil| */
         luaopen_socket_core(L);
         lua_setfield(L, -2, "socket.core");
         lua_pushnil(L);
-        lua_setfield(L, -2, "socket");  /* package.loaded.socket = nil */
-
+        lua_setfield(L, -2, "socket");
+        /*tex |package.loaded.mime = nil| */
         luaopen_mime_core(L);
         lua_setfield(L, -2, "mime.core");
         lua_pushnil(L);
-        lua_setfield(L, -2, "mime");    /* package.loaded.mime = nil */
-        lua_pop(L, 2);                  /* pop the tables */
-
-        luatex_socketlua_open(L);       /* preload the pure lua modules */
+        lua_setfield(L, -2, "mime");
+        /*tex pop the tables */
+        lua_pop(L, 2);
+        /*tex preload the pure \LUA\ modules */
+        luatex_socketlua_open(L);
     }
-
-    /* zlib. slightly odd calling convention */
+    /*tex |zlib|'s slightly odd calling convention */
     luaopen_zlib(L);
     lua_setglobal(L, "zlib");
-
     luaopen_gzip(L);
-
-    /* our own libraries register themselves */
-
+    /*tex our own libraries register themselves */
     luaopen_fio(L);
     luaopen_ff(L);
     luaopen_tex(L);
@@ -345,29 +359,25 @@ void luainterpreter(void)
     luaopen_texio(L);
     luaopen_kpse(L);
     luaopen_callback(L);
-
+    /*tex now we plug in extra \LUA\ startup code */
     luaopen_lua(L, startup_filename);
-
+    /*tex and open some \TEX\ ones */
     luaopen_stats(L);
     luaopen_font(L);
     luaopen_lang(L);
     luaopen_mplib(L);
     luaopen_vf(L);
     luaopen_pdf(L);
-    luaopen_epdf(L);
+    luaopen_pdfe(L);
     luaopen_pdfscanner(L);
-
     if (!lua_only) {
         luaopen_img(L);
     }
-
     lua_createtable(L, 0, 0);
     lua_setglobal(L, "texconfig");
-
     Luas = L;
 }
 
-@ @c
 int hide_lua_table(lua_State * L, const char *name)
 {
     int r = 0;
@@ -380,7 +390,6 @@ int hide_lua_table(lua_State * L, const char *name)
     return r;
 }
 
-@ @c
 void unhide_lua_table(lua_State * L, const char *name, int r)
 {
     lua_rawgeti(L, LUA_REGISTRYINDEX, r);
@@ -388,7 +397,6 @@ void unhide_lua_table(lua_State * L, const char *name, int r)
     luaL_unref(L, LUA_REGISTRYINDEX, r);
 }
 
-@ @c
 int hide_lua_value(lua_State * L, const char *name, const char *item)
 {
     int r = 0;
@@ -402,7 +410,6 @@ int hide_lua_value(lua_State * L, const char *name, const char *item)
     return r;
 }
 
-@ @c
 void unhide_lua_value(lua_State * L, const char *name, const char *item, int r)
 {
     lua_getglobal(L, name);
@@ -413,7 +420,6 @@ void unhide_lua_value(lua_State * L, const char *name, const char *item, int r)
     }
 }
 
-@ @c
 int lua_traceback(lua_State * L)
 {
     lua_getglobal(L, "debug");
@@ -426,21 +432,23 @@ int lua_traceback(lua_State * L)
         lua_pop(L, 2);
         return 1;
     }
-    lua_pushvalue(L, 1);        /* pass error message */
-    lua_pushinteger(L, 2);      /* skip this function and traceback */
-    lua_call(L, 2, 1);          /* call debug.traceback */
+    /*tex pass error message */
+    lua_pushvalue(L, 1);
+    /*tex skip this function and traceback */
+    lua_pushinteger(L, 2);
+    /*tex call |debug.traceback| */
+    lua_call(L, 2, 1);
     return 1;
 }
 
-@ @c
-static void luacall(int p, int nameptr, boolean is_string) /* hh-ls: optimized lua_id resolving */
+static void luacall(int p, int nameptr, boolean is_string)
 {
     LoadS ls;
     int i;
     size_t ll = 0;
     char *lua_id;
     char *s = NULL;
-
+    int stacktop = lua_gettop(Luas);
     if (Luas == NULL) {
         luainterpreter();
     }
@@ -449,16 +457,22 @@ static void luacall(int p, int nameptr, boolean is_string) /* hh-ls: optimized l
         const char *ss = NULL;
         lua_rawgeti(Luas, LUA_REGISTRYINDEX, p);
         if (lua_isfunction(Luas,-1)) {
-            int base = lua_gettop(Luas);        /* function index */
+            /*tex function index */
+            int base = lua_gettop(Luas);
             lua_checkstack(Luas, 1);
-            lua_pushcfunction(Luas, lua_traceback);     /* push traceback function */
-            lua_insert(Luas, base);     /* put it under chunk  */
+            /*tex push traceback function */
+            lua_pushcfunction(Luas, lua_traceback);
+            /*tex put it under chunk  */
+            lua_insert(Luas, base);
+            ++late_callback_count;
             i = lua_pcall(Luas, 0, 0, base);
-            lua_remove(Luas, base);     /* remove traceback function */
+            /*tex remove traceback function */
+            lua_remove(Luas, base);
             if (i != 0) {
                 lua_gc(Luas, LUA_GCCOLLECT, 0);
                 Luas = luatex_error(Luas, (i == LUA_ERRRUN ? 0 : 1));
             }
+            lua_settop(Luas,stacktop);
             lua_active--;
             return ;
         }
@@ -475,7 +489,8 @@ static void luacall(int p, int nameptr, boolean is_string) /* hh-ls: optimized l
     ls.size = ll;
     if (ls.size > 0) {
         if (nameptr > 0) {
-            int l = 0; /* not used */
+            /*tex |l| is not used */
+            int l = 0;
             lua_id = tokenlist_to_cstring(nameptr, 1, &l);
             i = Luas_load(Luas, getS, &ls, lua_id);
             xfree(lua_id);
@@ -492,12 +507,17 @@ static void luacall(int p, int nameptr, boolean is_string) /* hh-ls: optimized l
         if (i != 0) {
             Luas = luatex_error(Luas, (i == LUA_ERRSYNTAX ? 0 : 1));
         } else {
-            int base = lua_gettop(Luas);        /* function index */
+            /*tex function index */
+            int base = lua_gettop(Luas);
             lua_checkstack(Luas, 1);
-            lua_pushcfunction(Luas, lua_traceback);     /* push traceback function */
-            lua_insert(Luas, base);     /* put it under chunk  */
+            /*tex push traceback function */
+            lua_pushcfunction(Luas, lua_traceback);
+            /*tex put it under chunk  */
+            lua_insert(Luas, base);
+            ++late_callback_count;
             i = lua_pcall(Luas, 0, 0, base);
-            lua_remove(Luas, base);     /* remove traceback function */
+            /*tex remove traceback function */
+            lua_remove(Luas, base);
             if (i != 0) {
                 lua_gc(Luas, LUA_GCCOLLECT, 0);
                 Luas = luatex_error(Luas, (i == LUA_ERRRUN ? 0 : 1));
@@ -505,31 +525,99 @@ static void luacall(int p, int nameptr, boolean is_string) /* hh-ls: optimized l
         }
         xfree(ls.s);
     }
+    lua_settop(Luas,stacktop);
+    lua_active--;
+}
+
+void luacall_vf(int p, int f, int c)
+{
+    int i;
+    int stacktop = lua_gettop(Luas);
+    if (Luas == NULL) {
+        luainterpreter();
+    }
+    lua_active++;
+    lua_rawgeti(Luas, LUA_REGISTRYINDEX, p);
+    if (lua_isfunction(Luas,-1)) {
+        /*tex function index */
+        int base = lua_gettop(Luas);
+        lua_checkstack(Luas, 1);
+        /*tex push traceback function */
+        lua_pushcfunction(Luas, lua_traceback);
+        /*tex put it under chunk  */
+        lua_insert(Luas, base);
+        lua_pushinteger(Luas, f);
+        lua_pushinteger(Luas, c);
+        ++late_callback_count;
+        i = lua_pcall(Luas, 2, 0, base);
+        /*tex remove traceback function */
+        lua_remove(Luas, base);
+        if (i != 0) {
+            lua_gc(Luas, LUA_GCCOLLECT, 0);
+            Luas = luatex_error(Luas, (i == LUA_ERRRUN ? 0 : 1));
+        }
+    } else {
+        LoadS ls;
+        size_t ll = 0;
+        char *s = NULL;
+        const char *ss = NULL;
+        ss = lua_tolstring(Luas, -1, &ll);
+        s = xmalloc(ll+1);
+        memcpy(s,ss,ll+1);
+        lua_pop(Luas,1);
+        ls.s = s;
+        ls.size = ll;
+        if (ls.size > 0) {
+            i = Luas_load(Luas, getS, &ls, "=[vf command]");
+            if (i != 0) {
+                Luas = luatex_error(Luas, (i == LUA_ERRSYNTAX ? 0 : 1));
+            } else {
+                int base = lua_gettop(Luas);        /* function index */
+                lua_checkstack(Luas, 1);
+                lua_pushcfunction(Luas, lua_traceback);     /* push traceback function */
+                lua_insert(Luas, base);     /* put it under chunk  */
+                ++late_callback_count;
+                i = lua_pcall(Luas, 0, 0, base);
+                lua_remove(Luas, base);     /* remove traceback function */
+                if (i != 0) {
+                    lua_gc(Luas, LUA_GCCOLLECT, 0);
+                    Luas = luatex_error(Luas, (i == LUA_ERRRUN ? 0 : 1));
+                }
+            }
+            xfree(ls.s);
+        }
+    }
+    lua_settop(Luas,stacktop);
     lua_active--;
 }
 
-@ @c
 void late_lua(PDF pdf, halfword p)
 {
+    halfword t;
     (void) pdf;
-    if (late_lua_type(p)==normal) {
-        expand_macros_in_tokenlist(p);      /* sets |def_ref| */
+    t = late_lua_type(p);
+    if (t == normal) {
+        /*tex sets |def_ref| */
+        expand_macros_in_tokenlist(p);
         luacall(def_ref, late_lua_name(p), false);
         flush_list(def_ref);
-    } else {
+    } else if (t == lua_refid_call) {
+        luafunctioncall(late_lua_data(p));
+    } else if (t == lua_refid_literal) {
         luacall(late_lua_data(p), late_lua_name(p), true);
+    } else {
+        /*tex Let's just ignore it, could be some user specific thing. */
     }
 }
 
-@ @c
-void luatokencall(int p, int nameptr) /* hh-ls: optimized lua_id resolving */
+void luatokencall(int p, int nameptr)
 {
     LoadS ls;
-    int i, l;
+    int i;
+    int l = 0;
     char *s = NULL;
     char *lua_id;
-    assert(Luas);
-    l = 0;
+    int stacktop = lua_gettop(Luas);
     lua_active++;
     s = tokenlist_to_cstring(p, 1, &l);
     ls.s = s;
@@ -538,7 +626,7 @@ void luatokencall(int p, int nameptr) /* hh-ls: optimized lua_id resolving */
         if (nameptr > 0) {
             lua_id = tokenlist_to_cstring(nameptr, 1, &l);
             i = Luas_load(Luas, getS, &ls, lua_id);
-	    xfree(lua_id);
+            xfree(lua_id);
         } else if (nameptr < 0) {
             lua_id = get_lua_name((nameptr + 65536));
             if (lua_id != NULL) {
@@ -553,40 +641,53 @@ void luatokencall(int p, int nameptr) /* hh-ls: optimized lua_id resolving */
         if (i != 0) {
             Luas = luatex_error(Luas, (i == LUA_ERRSYNTAX ? 0 : 1));
         } else {
-            int base = lua_gettop(Luas);        /* function index */
+            /*tex function index */
+            int base = lua_gettop(Luas);
             lua_checkstack(Luas, 1);
-            lua_pushcfunction(Luas, lua_traceback);     /* push traceback function */
-            lua_insert(Luas, base);     /* put it under chunk  */
+            /*tex push traceback function */
+            lua_pushcfunction(Luas, lua_traceback);
+            /*tex put it under chunk  */
+            lua_insert(Luas, base);
+            ++direct_callback_count;
             i = lua_pcall(Luas, 0, 0, base);
-            lua_remove(Luas, base);     /* remove traceback function */
+            /*tex remove traceback function */
+            lua_remove(Luas, base);
             if (i != 0) {
                 lua_gc(Luas, LUA_GCCOLLECT, 0);
                 Luas = luatex_error(Luas, (i == LUA_ERRRUN ? 0 : 1));
             }
         }
     }
+    lua_settop(Luas,stacktop);
     lua_active--;
 }
 
-@ @c
 lua_State *luatex_error(lua_State * L, int is_fatal)
 {
-
     const_lstring luaerr;
     char *err = NULL;
     if (lua_type(L, -1) == LUA_TSTRING) {
         luaerr.s = lua_tolstring(L, -1, &luaerr.l);
-        /* free last one ? */
+        /*tex
+            Free the last one.
+        */
         err = (char *) xmalloc((unsigned) (luaerr.l + 1));
         snprintf(err, (luaerr.l + 1), "%s", luaerr.s);
-        last_lua_error = err; /* hm, what if we have several .. not freed */
+        /*tex
+            What if we have several .. not freed?
+        */
+        last_lua_error = err;
     }
     if (is_fatal > 0) {
-        /* Normally a memory error from lua.
-           The pool may overflow during the |maketexlstring()|, but we
-           are crashing anyway so we may as well abort on the pool size */
+        /*
+            Normally a memory error from lua. The pool may overflow during the
+            |maketexlstring()|, but we are crashing anyway so we may as well
+            abort on the pool size
+        */
         normal_error("lua",err);
-        /* never reached */
+        /*tex
+            This is never reached.
+        */
         lua_close(L);
         return (lua_State *) NULL;
     } else {
@@ -595,35 +696,41 @@ lua_State *luatex_error(lua_State * L, int is_fatal)
     }
 }
 
-@ @c
 void preset_environment(lua_State * L, const parm_struct * p, const char *s)
 {
     int i;
     assert(L != NULL);
-    /* double call with same s gives assert(0) */
-    lua_pushstring(L, s);       /* s */
-    lua_gettable(L, LUA_REGISTRYINDEX); /* t */
+    /*tex double call with same s gives assert(0) */
+    lua_pushstring(L, s);
+    /*tex state: s */
+    lua_gettable(L, LUA_REGISTRYINDEX);
+    /*tex state: t */
     assert(lua_isnil(L, -1));
-    lua_pop(L, 1);              /* - */
-    lua_pushstring(L, s);       /* s */
-    lua_newtable(L);            /* t s */
+    lua_pop(L, 1);
+    /*tex state: - */
+    lua_pushstring(L, s);
+    /*tex state: s */
+    lua_newtable(L);
+    /*tex state: t s */
     for (i = 1, ++p; p->name != NULL; i++, p++) {
         assert(i == p->idx);
-        lua_pushstring(L, p->name);     /* k t s */
-        lua_pushinteger(L, p->idx);     /* v k t s */
-        lua_settable(L, -3);    /* t s */
+        lua_pushstring(L, p->name);
+        /*tex state: k t s */
+        lua_pushinteger(L, p->idx);
+        /*tex state: v k t s */
+        lua_settable(L, -3);
+        /*tex state: t s */
     }
-    lua_settable(L, LUA_REGISTRYINDEX); /* - */
+    lua_settable(L, LUA_REGISTRYINDEX);
+    /* tex state: - */
 }
 
-
-@ @c
-/*
-    luajit compatibility layer for luatex lua5.2
+/*tex
+    Here comes a \LUAJIT\ compatibility layer for \LUATEX\ \LUA5.2:
 */
+
 #ifdef LuajitTeX
 
-@ @c
 LUALIB_API char *luaL_prepbuffsize (luaL_Buffer *B, size_t sz) {
     lua_State *L = B->L;
     if (sz > LUAL_BUFFERSIZE )
@@ -631,24 +738,22 @@ LUALIB_API char *luaL_prepbuffsize (luaL_Buffer *B, size_t sz) {
     return luaL_prepbuffer(B) ;
 }
 
-@ @c
 LUA_API int lua_compare (lua_State *L, int o1, int o2, int op) {
     /*StkId o1, o2;*/
     int i = 0;
     lua_lock(L);  /* may call tag method */
     /* o1 = index2addr(L, index1); */
     /* o2 = index2addr(L, index2); */
-    /*if (isvalid(o1) && isvalid(o2)) {*/
+    /* if (isvalid(o1) && isvalid(o2)) {*/
     switch (op) {
         case LUA_OPEQ: i = lua_equal(L, o1, o2); break;
         case LUA_OPLT: i = lua_lessthan(L, o1, o2); break;
         case LUA_OPLE: i = (lua_lessthan(L, o1, o2) || lua_equal(L, o1, o2)) ; break;
         default: luaL_error(L, "invalid option");
     }
-    /*}*/
+    /* } */
     lua_unlock(L);
     return i;
 }
 
-@ @c
 #endif
diff --git a/texk/web2c/luatexdir/lua/luatoken.c b/texk/web2c/luatexdir/lua/luatoken.c
new file mode 100644
index 000000000..fb197b68f
--- /dev/null
+++ b/texk/web2c/luatexdir/lua/luatoken.c
@@ -0,0 +1,585 @@
+/*
+
+luatoken.w
+
+Copyright 2006-2012 Taco Hoekwater <taco@@luatex.org>
+
+This file is part of LuaTeX.
+
+LuaTeX is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 2 of the License, or (at your
+option) any later version.
+
+LuaTeX is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+License for more details.
+
+You should have received a copy of the GNU General Public License along
+with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#include "ptexlib.h"
+#include "lua/luatex-api.h"
+
+command_item command_names[] = {
+    { relax_cmd,                NULL, 0},
+    { left_brace_cmd,           NULL, 0},
+    { right_brace_cmd,          NULL, 0},
+    { math_shift_cmd,           NULL, 0},
+    { tab_mark_cmd,             NULL, 0},
+    { car_ret_cmd,              NULL, 0},
+    { mac_param_cmd,            NULL, 0},
+    { sup_mark_cmd,             NULL, 0},
+    { sub_mark_cmd,             NULL, 0},
+    { endv_cmd,                 NULL, 0},
+    { spacer_cmd,               NULL, 0},
+    { letter_cmd,               NULL, 0},
+    { other_char_cmd,           NULL, 0},
+    { par_end_cmd,              NULL, 0},
+    { stop_cmd,                 NULL, 0},
+    { delim_num_cmd,            NULL, 0},
+    { char_num_cmd,             NULL, 0},
+    { math_char_num_cmd,        NULL, 0},
+    { mark_cmd,                 NULL, 0},
+    { node_cmd,                 NULL, 0},
+    { xray_cmd,                 NULL, 0},
+    { make_box_cmd,             NULL, 0},
+    { hmove_cmd,                NULL, 0},
+    { vmove_cmd,                NULL, 0},
+    { un_hbox_cmd,              NULL, 0},
+    { un_vbox_cmd,              NULL, 0},
+    { remove_item_cmd,          NULL, 0},
+    { hskip_cmd,                NULL, 0},
+    { vskip_cmd,                NULL, 0},
+    { mskip_cmd,                NULL, 0},
+    { kern_cmd,                 NULL, 0},
+    { mkern_cmd,                NULL, 0},
+    { leader_ship_cmd,          NULL, 0},
+    { halign_cmd,               NULL, 0},
+    { valign_cmd,               NULL, 0},
+    { no_align_cmd,             NULL, 0},
+    { no_vrule_cmd,             NULL, 0},
+    { no_hrule_cmd,             NULL, 0},
+    { vrule_cmd,                NULL, 0},
+    { hrule_cmd,                NULL, 0},
+    { insert_cmd,               NULL, 0},
+    { vadjust_cmd,              NULL, 0},
+    { ignore_spaces_cmd,        NULL, 0},
+    { after_assignment_cmd,     NULL, 0},
+    { after_group_cmd,          NULL, 0},
+    { break_penalty_cmd,        NULL, 0},
+    { start_par_cmd,            NULL, 0},
+    { ital_corr_cmd,            NULL, 0},
+    { accent_cmd,               NULL, 0},
+    { math_accent_cmd,          NULL, 0},
+    { discretionary_cmd,        NULL, 0},
+    { eq_no_cmd,                NULL, 0},
+    { left_right_cmd,           NULL, 0},
+    { math_comp_cmd,            NULL, 0},
+    { limit_switch_cmd,         NULL, 0},
+    { above_cmd,                NULL, 0},
+    { math_style_cmd,           NULL, 0},
+    { math_choice_cmd,          NULL, 0},
+    { non_script_cmd,           NULL, 0},
+    { vcenter_cmd,              NULL, 0},
+    { case_shift_cmd,           NULL, 0},
+    { message_cmd,              NULL, 0},
+    { normal_cmd,               NULL, 0},
+    { extension_cmd,            NULL, 0},
+    { option_cmd,               NULL, 0},
+    { lua_function_call_cmd,    NULL, 0},
+    { lua_bytecode_call_cmd,    NULL, 0},
+    { lua_call_cmd,             NULL, 0},
+    { in_stream_cmd,            NULL, 0},
+    { begin_group_cmd,          NULL, 0},
+    { end_group_cmd,            NULL, 0},
+    { omit_cmd,                 NULL, 0},
+    { ex_space_cmd,             NULL, 0},
+    { boundary_cmd,             NULL, 0},
+    { radical_cmd,              NULL, 0},
+    { super_sub_script_cmd,     NULL, 0},
+    { no_super_sub_script_cmd,  NULL, 0},
+    { math_shift_cs_cmd,        NULL, 0},
+    { end_cs_name_cmd,          NULL, 0},
+    { char_ghost_cmd,           NULL, 0},
+    { assign_local_box_cmd,     NULL, 0},
+    { char_given_cmd,           NULL, 0},
+    { math_given_cmd,           NULL, 0},
+    { xmath_given_cmd,          NULL, 0},
+    { last_item_cmd,            NULL, 0},
+    { toks_register_cmd,        NULL, 0},
+    { assign_toks_cmd,          NULL, 0},
+    { assign_int_cmd,           NULL, 0},
+    { assign_attr_cmd,          NULL, 0},
+    { assign_dimen_cmd,         NULL, 0},
+    { assign_glue_cmd,          NULL, 0},
+    { assign_mu_glue_cmd,       NULL, 0},
+    { assign_font_dimen_cmd,    NULL, 0},
+    { assign_font_int_cmd,      NULL, 0},
+    { assign_hang_indent_cmd,   NULL, 0},
+    { set_aux_cmd,              NULL, 0},
+    { set_prev_graf_cmd,        NULL, 0},
+    { set_page_dimen_cmd,       NULL, 0},
+    { set_page_int_cmd,         NULL, 0},
+    { set_box_dimen_cmd,        NULL, 0},
+    { set_tex_shape_cmd,        NULL, 0},
+    { set_etex_shape_cmd,       NULL, 0},
+    { def_char_code_cmd,        NULL, 0},
+    { def_del_code_cmd,         NULL, 0},
+    { extdef_math_code_cmd,     NULL, 0},
+    { extdef_del_code_cmd,      NULL, 0},
+    { def_family_cmd,           NULL, 0},
+    { set_math_param_cmd,       NULL, 0},
+    { set_font_cmd,             NULL, 0},
+    { def_font_cmd,             NULL, 0},
+    { register_cmd,             NULL, 0},
+    { assign_box_direction_cmd, NULL, 0},
+    { assign_box_dir_cmd,       NULL, 0},
+    { assign_direction_cmd,     NULL, 0},
+    { assign_dir_cmd,           NULL, 0},
+    { advance_cmd,              NULL, 0},
+    { multiply_cmd,             NULL, 0},
+    { divide_cmd,               NULL, 0},
+    { prefix_cmd,               NULL, 0},
+    { let_cmd,                  NULL, 0},
+    { shorthand_def_cmd,        NULL, 0},
+    { def_lua_call_cmd,         NULL, 0},
+    { read_to_cs_cmd,           NULL, 0},
+    { def_cmd,                  NULL, 0},
+    { set_box_cmd,              NULL, 0},
+    { hyph_data_cmd,            NULL, 0},
+    { set_interaction_cmd,      NULL, 0},
+    { letterspace_font_cmd,     NULL, 0},
+    { expand_font_cmd,          NULL, 0},
+    { copy_font_cmd,            NULL, 0},
+    { set_font_id_cmd,          NULL, 0},
+    { undefined_cs_cmd,         NULL, 0},
+    { expand_after_cmd,         NULL, 0},
+    { no_expand_cmd,            NULL, 0},
+    { input_cmd,                NULL, 0},
+    { lua_expandable_call_cmd,  NULL, 0},
+    { lua_local_call_cmd,       NULL, 0},
+    { if_test_cmd,              NULL, 0},
+    { fi_or_else_cmd,           NULL, 0},
+    { cs_name_cmd,              NULL, 0},
+    { convert_cmd,              NULL, 0},
+    { variable_cmd,             NULL, 0},
+    { feedback_cmd,             NULL, 0},
+    { the_cmd,                  NULL, 0},
+    { combine_toks_cmd,         NULL, 0},
+    { top_bot_mark_cmd,         NULL, 0},
+    { call_cmd,                 NULL, 0},
+    { long_call_cmd,            NULL, 0},
+    { outer_call_cmd,           NULL, 0},
+    { long_outer_call_cmd,      NULL, 0},
+    { end_template_cmd,         NULL, 0},
+    { dont_expand_cmd,          NULL, 0},
+    { glue_ref_cmd,             NULL, 0},
+    { shape_ref_cmd,            NULL, 0},
+    { box_ref_cmd,              NULL, 0},
+    { data_cmd,                 NULL, 0},
+    { -1,                       NULL, 0}
+};
+
+# define init_token_key(target,n,key) \
+    target[n].lua  = luaS_##key##_index; \
+    target[n].name = luaS_##key##_ptr;
+
+void l_set_token_data(void)
+{
+    init_token_key(command_names, relax_cmd,                relax);
+    init_token_key(command_names, left_brace_cmd,           left_brace);
+    init_token_key(command_names, right_brace_cmd,          right_brace);
+    init_token_key(command_names, math_shift_cmd,           math_shift);
+    init_token_key(command_names, tab_mark_cmd,             tab_mark);
+    init_token_key(command_names, car_ret_cmd,              car_ret);
+    init_token_key(command_names, mac_param_cmd,            mac_param);
+    init_token_key(command_names, sup_mark_cmd,             sup_mark);
+    init_token_key(command_names, sub_mark_cmd,             sub_mark);
+    init_token_key(command_names, endv_cmd,                 endv);
+    init_token_key(command_names, spacer_cmd,               spacer);
+    init_token_key(command_names, letter_cmd,               letter);
+    init_token_key(command_names, other_char_cmd,           other_char);
+    init_token_key(command_names, par_end_cmd,              par_end);
+    init_token_key(command_names, stop_cmd,                 stop);
+    init_token_key(command_names, delim_num_cmd,            delim_num);
+    init_token_key(command_names, char_num_cmd,             char_num);
+    init_token_key(command_names, math_char_num_cmd,        math_char_num);
+    init_token_key(command_names, mark_cmd,                 mark);
+    init_token_key(command_names, node_cmd,                 node);
+    init_token_key(command_names, xray_cmd,                 xray);
+    init_token_key(command_names, make_box_cmd,             make_box);
+    init_token_key(command_names, hmove_cmd,                hmove);
+    init_token_key(command_names, vmove_cmd,                vmove);
+    init_token_key(command_names, un_hbox_cmd,              un_hbox);
+    init_token_key(command_names, un_vbox_cmd,              un_vbox);
+    init_token_key(command_names, remove_item_cmd,          remove_item);
+    init_token_key(command_names, hskip_cmd,                hskip);
+    init_token_key(command_names, vskip_cmd,                vskip);
+    init_token_key(command_names, mskip_cmd,                mskip);
+    init_token_key(command_names, kern_cmd,                 kern);
+    init_token_key(command_names, mkern_cmd,                mkern);
+    init_token_key(command_names, leader_ship_cmd,          leader_ship);
+    init_token_key(command_names, halign_cmd,               halign);
+    init_token_key(command_names, valign_cmd,               valign);
+    init_token_key(command_names, no_align_cmd,             no_align);
+    init_token_key(command_names, vrule_cmd,                vrule);
+    init_token_key(command_names, hrule_cmd,                hrule);
+    init_token_key(command_names, no_vrule_cmd,             novrule);
+    init_token_key(command_names, no_hrule_cmd,             nohrule);
+    init_token_key(command_names, insert_cmd,               insert);
+    init_token_key(command_names, vadjust_cmd,              vadjust);
+    init_token_key(command_names, ignore_spaces_cmd,        ignore_spaces);
+    init_token_key(command_names, after_assignment_cmd,     after_assignment);
+    init_token_key(command_names, after_group_cmd,          after_group);
+    init_token_key(command_names, break_penalty_cmd,        break_penalty);
+    init_token_key(command_names, start_par_cmd,            start_par);
+    init_token_key(command_names, ital_corr_cmd,            ital_corr);
+    init_token_key(command_names, accent_cmd,               accent);
+    init_token_key(command_names, math_accent_cmd,          math_accent);
+    init_token_key(command_names, discretionary_cmd,        discretionary);
+    init_token_key(command_names, eq_no_cmd,                eq_no);
+    init_token_key(command_names, left_right_cmd,           left_right);
+    init_token_key(command_names, math_comp_cmd,            math_comp);
+    init_token_key(command_names, limit_switch_cmd,         limit_switch);
+    init_token_key(command_names, above_cmd,                above);
+    init_token_key(command_names, math_style_cmd,           math_style);
+    init_token_key(command_names, math_choice_cmd,          math_choice);
+    init_token_key(command_names, non_script_cmd,           non_script);
+    init_token_key(command_names, vcenter_cmd,              vcenter);
+    init_token_key(command_names, case_shift_cmd,           case_shift);
+    init_token_key(command_names, message_cmd,              message);
+    init_token_key(command_names, normal_cmd,               normal);
+    init_token_key(command_names, extension_cmd,            extension);
+    init_token_key(command_names, option_cmd,               option);
+    init_token_key(command_names, lua_function_call_cmd,    lua_function_call);
+    init_token_key(command_names, lua_bytecode_call_cmd,    lua_bytecode_call);
+    init_token_key(command_names, lua_call_cmd,             lua_call);
+    init_token_key(command_names, in_stream_cmd,            in_stream);
+    init_token_key(command_names, begin_group_cmd,          begin_group);
+    init_token_key(command_names, end_group_cmd,            end_group);
+    init_token_key(command_names, omit_cmd,                 omit);
+    init_token_key(command_names, ex_space_cmd,             ex_space);
+    init_token_key(command_names, boundary_cmd,             boundary);
+    init_token_key(command_names, radical_cmd,              radical);
+    init_token_key(command_names, super_sub_script_cmd,     super_sub_script);
+    init_token_key(command_names, no_super_sub_script_cmd,  no_super_sub_script);
+    init_token_key(command_names, math_shift_cs_cmd,        math_shift_cs);
+    init_token_key(command_names, end_cs_name_cmd,          end_cs_name);
+    init_token_key(command_names, char_ghost_cmd,           char_ghost);
+    init_token_key(command_names, assign_local_box_cmd,     assign_local_box);
+    init_token_key(command_names, char_given_cmd,           char_given);
+    init_token_key(command_names, math_given_cmd,           math_given);
+    init_token_key(command_names, xmath_given_cmd,          xmath_given);
+    init_token_key(command_names, last_item_cmd,            last_item);
+    init_token_key(command_names, toks_register_cmd,        toks_register);
+    init_token_key(command_names, assign_toks_cmd,          assign_toks);
+    init_token_key(command_names, assign_int_cmd,           assign_int);
+    init_token_key(command_names, assign_attr_cmd,          assign_attr);
+    init_token_key(command_names, assign_dimen_cmd,         assign_dimen);
+    init_token_key(command_names, assign_glue_cmd,          assign_glue);
+    init_token_key(command_names, assign_mu_glue_cmd,       assign_mu_glue);
+    init_token_key(command_names, assign_font_dimen_cmd,    assign_font_dimen);
+    init_token_key(command_names, assign_font_int_cmd,      assign_font_int);
+    init_token_key(command_names, assign_hang_indent_cmd,   assign_hang_indent);
+    init_token_key(command_names, set_aux_cmd,              set_aux);
+    init_token_key(command_names, set_prev_graf_cmd,        set_prev_graf);
+    init_token_key(command_names, set_page_dimen_cmd,       set_page_dimen);
+    init_token_key(command_names, set_page_int_cmd,         set_page_int);
+    init_token_key(command_names, set_box_dimen_cmd,        set_box_dimen);
+    init_token_key(command_names, set_tex_shape_cmd,        set_tex_shape);
+    init_token_key(command_names, set_etex_shape_cmd,       set_etex_shape);
+    init_token_key(command_names, def_char_code_cmd,        def_char_code);
+    init_token_key(command_names, def_del_code_cmd,         def_del_code);
+    init_token_key(command_names, extdef_math_code_cmd,     extdef_math_code);
+    init_token_key(command_names, extdef_del_code_cmd,      extdef_del_code);
+    init_token_key(command_names, def_family_cmd,           def_family);
+    init_token_key(command_names, set_math_param_cmd,       set_math_param);
+    init_token_key(command_names, set_font_cmd,             set_font);
+    init_token_key(command_names, def_font_cmd,             def_font);
+    init_token_key(command_names, def_lua_call_cmd,         def_lua_call);
+    init_token_key(command_names, register_cmd,             register);
+    init_token_key(command_names, assign_box_direction_cmd, assign_box_direction);
+    init_token_key(command_names, assign_box_dir_cmd,       assign_box_dir);
+    init_token_key(command_names, assign_direction_cmd,     assign_direction);
+    init_token_key(command_names, assign_dir_cmd,           assign_dir);
+    init_token_key(command_names, advance_cmd,              advance);
+    init_token_key(command_names, multiply_cmd,             multiply);
+    init_token_key(command_names, divide_cmd,               divide);
+    init_token_key(command_names, prefix_cmd,               prefix);
+    init_token_key(command_names, let_cmd,                  let);
+    init_token_key(command_names, shorthand_def_cmd,        shorthand_def);
+    init_token_key(command_names, read_to_cs_cmd,           read_to_cs);
+    init_token_key(command_names, def_cmd,                  def);
+    init_token_key(command_names, set_box_cmd,              set_box);
+    init_token_key(command_names, hyph_data_cmd,            hyph_data);
+    init_token_key(command_names, set_interaction_cmd,      set_interaction);
+    init_token_key(command_names, letterspace_font_cmd,     letterspace_font);
+    init_token_key(command_names, expand_font_cmd,          expand_font);
+    init_token_key(command_names, copy_font_cmd,            copy_font);
+    init_token_key(command_names, set_font_id_cmd,          set_font_id);
+    init_token_key(command_names, undefined_cs_cmd,         undefined_cs);
+    init_token_key(command_names, expand_after_cmd,         expand_after);
+    init_token_key(command_names, no_expand_cmd,            no_expand);
+    init_token_key(command_names, input_cmd,                input);
+    init_token_key(command_names, lua_expandable_call_cmd,  lua_expandable_call);
+    init_token_key(command_names, lua_local_call_cmd,       lua_local_call);
+    init_token_key(command_names, if_test_cmd,              if_test);
+    init_token_key(command_names, fi_or_else_cmd,           fi_or_else);
+    init_token_key(command_names, cs_name_cmd,              cs_name);
+    init_token_key(command_names, convert_cmd,              convert);
+    init_token_key(command_names, variable_cmd,             variable);
+    init_token_key(command_names, feedback_cmd,             feedback);
+    init_token_key(command_names, the_cmd,                  the);
+    init_token_key(command_names, combine_toks_cmd,         combinetoks);
+    init_token_key(command_names, top_bot_mark_cmd,         top_bot_mark);
+    init_token_key(command_names, call_cmd,                 call);
+    init_token_key(command_names, long_call_cmd,            long_call);
+    init_token_key(command_names, outer_call_cmd,           outer_call);
+    init_token_key(command_names, long_outer_call_cmd,      long_outer_call);
+    init_token_key(command_names, end_template_cmd,         end_template);
+    init_token_key(command_names, dont_expand_cmd,          dont_expand);
+    init_token_key(command_names, glue_ref_cmd,             glue_ref);
+    init_token_key(command_names, shape_ref_cmd,            shape_ref);
+    init_token_key(command_names, box_ref_cmd,              box_ref);
+    init_token_key(command_names, data_cmd,                 data);
+}
+
+int get_command_id(const char *s)
+{
+    int i;
+    for (i = 0; command_names[i].id != -1; i++) {
+        if (s == command_names[i].name)
+            return i;
+    }
+    return -1;
+}
+
+/*
+static int get_cur_cmd(lua_State * L)
+{
+    int r = 0;
+    size_t len = lua_rawlen(L, -1);
+    cur_cs = 0;
+    if (len == 3 || len == 2) {
+        r = 1;
+        lua_rawgeti(L, -1, 1);
+        cur_cmd = (int) lua_tointeger(L, -1);
+        lua_rawgeti(L, -2, 2);
+        cur_chr = (halfword) lua_tointeger(L, -1);
+        if (len == 3) {
+            lua_rawgeti(L, -3, 3);
+            cur_cs = (halfword) lua_tointeger(L, -1);
+        }
+        lua_pop(L, (int) len);
+        if (cur_cs == 0)
+            cur_tok = token_val(cur_cmd, cur_chr);
+        else
+            cur_tok = cs_token_flag + cur_cs;
+    }
+    return r;
+}
+*/
+
+static int token_from_lua(lua_State * L)
+{
+    int cmd, chr;
+    int cs = 0;
+    size_t len = lua_rawlen(L, -1);
+    if (len == 3 || len == 2) {
+        lua_rawgeti(L, -1, 1);
+        cmd = (int) lua_tointeger(L, -1);
+        lua_rawgeti(L, -2, 2);
+        chr = (int) lua_tointeger(L, -1);
+        if (len == 3) {
+            lua_rawgeti(L, -3, 3);
+            cs = (int) lua_tointeger(L, -1);
+        }
+        lua_pop(L, (int) len);
+        if (cs == 0) {
+            return token_val(cmd, chr);
+        } else {
+            return cs_token_flag + cs;
+        }
+    }
+    return -1;
+}
+
+/*
+static int get_cur_cs(lua_State * L)
+{
+    const char *s;
+    unsigned j;
+    size_t l;
+    int cs;
+    int save_nncs;
+    int ret;
+    ret = 0;
+    cur_cs = 0;
+    lua_getfield(L, -1, "name");
+    if (lua_type(L, -1) == LUA_TSTRING) {
+        s = lua_tolstring(L, -1, &l);
+        if (l > 0) {
+            if ((last + (int) l) > buf_size)
+                check_buffer_overflow((last + (int) l));
+            for (j = 0; j < l; j++) {
+                buffer[(unsigned) last + 1 + j] = (packed_ASCII_code) * s++;
+            }
+            save_nncs = no_new_control_sequence;
+            no_new_control_sequence = false;
+            cs = id_lookup((last + 1), (int) l);
+            cur_tok = cs_token_flag + cs;
+            cur_cmd = eq_type(cs);
+            cur_chr = equiv(cs);
+            no_new_control_sequence = save_nncs;
+            ret = 1;
+        }
+    }
+    lua_pop(L, 1);
+    return ret;
+}
+*/
+
+void tokenlist_to_lua(lua_State * L, int p)
+{
+    int cmd, chr, cs;
+    int v;
+    int i = 1;
+    v = p;
+    while (v != null && v < (int) fix_mem_end) {
+        i++;
+        v = token_link(v);
+    }
+    i = 1;
+    lua_createtable(L, i, 0);
+    while (p != null && p < (int) fix_mem_end) {
+        if (token_info(p) >= cs_token_flag) {
+            cs = token_info(p) - cs_token_flag;
+            cmd = eq_type(cs);
+            chr = equiv(cs);
+            make_token_table(L, cmd, chr, cs);
+        } else {
+            cmd = token_cmd(token_info(p));
+            chr = token_chr(token_info(p));
+            make_token_table(L, cmd, chr, 0);
+        }
+        lua_rawseti(L, -2, i++);
+        p = token_link(p);
+    }
+}
+
+void tokenlist_to_luastring(lua_State * L, int p)
+{
+    int l;
+    char *s;
+    s = tokenlist_to_cstring(p, 1, &l);
+    lua_pushlstring(L, s, (size_t) l);
+    free(s);
+}
+
+int tokenlist_from_lua(lua_State * L)
+{
+    const char *s;
+    int tok, t;
+    size_t i, j;
+    halfword p, q, r;
+    r = get_avail();
+    token_info(r) = 0;
+    token_link(r) = null;
+    p = r;
+    t = lua_type(L, -1);
+    if (t == LUA_TTABLE) {
+        j = lua_rawlen(L, -1);
+        if (j > 0) {
+            for (i = 1; i <= j; i++) {
+                lua_rawgeti(L, -1, (int) i);
+                tok = token_from_lua(L);
+                if (tok >= 0) {
+                    store_new_token(tok);
+                }
+                lua_pop(L, 1);
+            };
+        }
+        return r;
+    } else if (t == LUA_TSTRING) {
+        s = lua_tolstring(L, -1, &j);
+        for (i = 0; i < j; i++) {
+            if (s[i] == 32) {
+                tok = token_val(10, s[i]);
+            } else {
+                int j1 = (int) str2uni((const unsigned char *) (s + i));
+                i = i + (size_t) (utf8_size(j1) - 1);
+                tok = token_val(12, j1);
+            }
+            store_new_token(tok);
+        }
+        return r;
+    } else {
+        free_avail(r);
+        return null;
+    }
+}
+
+/*
+static void do_get_token_lua(int callback_id)
+{
+    while (1) {
+        if (!get_callback(Luas, callback_id)) {
+            get_next();
+            lua_pop(Luas, 2);
+            break;
+        }
+        if (lua_pcall(Luas, 0, 1, 0) != 0) {
+            tex_error(lua_tostring(Luas, -1), NULL);
+            lua_pop(Luas, 2);
+            break;
+        }
+        if (lua_istable(Luas, -1)) {
+            lua_rawgeti(Luas, -1, 1);
+            if (lua_istable(Luas, -1)) {
+                int p, q, r;
+                size_t i, j;
+                lua_pop(Luas, 1);
+                r = get_avail();
+                p = r;
+                j = lua_rawlen(Luas, -1);
+                if (j > 0) {
+                    for (i = 1; i <= j; i++) {
+                        lua_rawgeti(Luas, -1, (int) i);
+                        if (get_cur_cmd(Luas) || get_cur_cs(Luas)) {
+                            store_new_token(cur_tok);
+                        }
+                        lua_pop(Luas, 1);
+                    }
+                }
+                if (p != r) {
+                    p = token_link(r);
+                    free_avail(r);
+                    begin_token_list(p, inserted);
+                    cur_input.nofilter_field = true;
+                    get_next();
+                } else {
+                    tex_error("error: illegal or empty token list returned", NULL);
+                }
+                lua_pop(Luas, 2);
+                break;
+            } else {
+                lua_pop(Luas, 1);
+                if (get_cur_cmd(Luas) || get_cur_cs(Luas)) {
+                    lua_pop(Luas, 2);
+                    break;
+                } else {
+                    lua_pop(Luas, 2);
+                    continue;
+                }
+            }
+        } else {
+            lua_pop(Luas, 2);
+        }
+    }
+    return;
+}
+*/
diff --git a/texk/web2c/luatexdir/lua/luatoken.w b/texk/web2c/luatexdir/lua/luatoken.w
deleted file mode 100644
index e9740ffc6..000000000
--- a/texk/web2c/luatexdir/lua/luatoken.w
+++ /dev/null
@@ -1,424 +0,0 @@
-% luatoken.w
-%
-% Copyright 2006-2012 Taco Hoekwater <taco@@luatex.org>
-%
-% This file is part of LuaTeX.
-%
-% LuaTeX is free software; you can redistribute it and/or modify it under
-% the terms of the GNU General Public License as published by the Free
-% Software Foundation; either version 2 of the License, or (at your
-% option) any later version.
-%
-% LuaTeX is distributed in the hope that it will be useful, but WITHOUT
-% ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-% FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
-% License for more details.
-%
-% You should have received a copy of the GNU General Public License along
-% with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
-
-@ @c
-
-#include "ptexlib.h"
-#include "lua/luatex-api.h"
-
-@ @c
-command_item command_names[] = {
-    {"relax", relax_cmd, NULL},
-    {"left_brace", left_brace_cmd, NULL},
-    {"right_brace", right_brace_cmd, NULL},
-    {"math_shift", math_shift_cmd, NULL},
-    {"tab_mark", tab_mark_cmd, NULL},
-    {"car_ret", car_ret_cmd, NULL},
-    {"mac_param", mac_param_cmd, NULL},
-    {"sup_mark", sup_mark_cmd, NULL},
-    {"sub_mark", sub_mark_cmd, NULL},
-    {"endv", endv_cmd, NULL},
-    {"spacer", spacer_cmd, NULL},
-    {"letter", letter_cmd, NULL},
-    {"other_char", other_char_cmd, NULL},
-    {"par_end", par_end_cmd, NULL},
-    {"stop", stop_cmd, NULL},
-    {"delim_num", delim_num_cmd, NULL},
-    {"char_num", char_num_cmd, NULL},
-    {"math_char_num", math_char_num_cmd, NULL},
-    {"mark", mark_cmd, NULL},
-    {"xray", xray_cmd, NULL},
-    {"make_box", make_box_cmd, NULL},
-    {"hmove", hmove_cmd, NULL},
-    {"vmove", vmove_cmd, NULL},
-    {"un_hbox", un_hbox_cmd, NULL},
-    {"un_vbox", un_vbox_cmd, NULL},
-    {"remove_item", remove_item_cmd, NULL},
-    {"hskip", hskip_cmd, NULL},
-    {"vskip", vskip_cmd, NULL},
-    {"mskip", mskip_cmd, NULL},
-    {"kern", kern_cmd, NULL},
-    {"mkern", mkern_cmd, NULL},
-    {"leader_ship", leader_ship_cmd, NULL},
-    {"halign", halign_cmd, NULL},
-    {"valign", valign_cmd, NULL},
-    {"no_align", no_align_cmd, NULL},
-    {"novrule", no_vrule_cmd, NULL},
-    {"nohrule", no_hrule_cmd, NULL},
-    {"vrule", vrule_cmd, NULL},
-    {"hrule", hrule_cmd, NULL},
-    {"insert", insert_cmd, NULL},
-    {"vadjust", vadjust_cmd, NULL},
-    {"ignore_spaces", ignore_spaces_cmd, NULL},
-    {"after_assignment", after_assignment_cmd, NULL},
-    {"after_group", after_group_cmd, NULL},
-    {"break_penalty", break_penalty_cmd, NULL},
-    {"start_par", start_par_cmd, NULL},
-    {"ital_corr", ital_corr_cmd, NULL},
-    {"accent", accent_cmd, NULL},
-    {"math_accent", math_accent_cmd, NULL},
-    {"discretionary", discretionary_cmd, NULL},
-    {"eq_no", eq_no_cmd, NULL},
-    {"left_right", left_right_cmd, NULL},
-    {"math_comp", math_comp_cmd, NULL},
-    {"limit_switch", limit_switch_cmd, NULL},
-    {"above", above_cmd, NULL},
-    {"math_style", math_style_cmd, NULL},
-    {"math_choice", math_choice_cmd, NULL},
-    {"non_script", non_script_cmd, NULL},
-    {"vcenter", vcenter_cmd, NULL},
-    {"case_shift", case_shift_cmd, NULL},
-    {"message", message_cmd, NULL},
-    {"normal", normal_cmd, NULL},
-    {"extension", extension_cmd, NULL},
-    {"option", option_cmd, NULL},
-    {"in_stream", in_stream_cmd, NULL},
-    {"begin_group", begin_group_cmd, NULL},
-    {"end_group", end_group_cmd, NULL},
-    {"omit", omit_cmd, NULL},
-    {"ex_space", ex_space_cmd, NULL},
-    {"boundary", boundary_cmd, NULL},
-    {"radical", radical_cmd, NULL},
-    {"super_sub_script", super_sub_script_cmd, NULL},
-    {"no_super_sub_script", no_super_sub_script_cmd, NULL},
-    {"math_shift_cs", math_shift_cs_cmd, NULL},
-    {"end_cs_name", end_cs_name_cmd, NULL},
-    {"char_ghost", char_ghost_cmd, NULL},
-    {"assign_local_box", assign_local_box_cmd, NULL},
-    {"char_given", char_given_cmd, NULL},
-    {"math_given", math_given_cmd, NULL},
-    {"xmath_given", xmath_given_cmd, NULL},
-    {"last_item", last_item_cmd, NULL},
-    {"toks_register", toks_register_cmd, NULL},
-    {"assign_toks", assign_toks_cmd, NULL},
-    {"assign_int", assign_int_cmd, NULL},
-    {"assign_attr", assign_attr_cmd, NULL},
-    {"assign_dimen", assign_dimen_cmd, NULL},
-    {"assign_glue", assign_glue_cmd, NULL},
-    {"assign_mu_glue", assign_mu_glue_cmd, NULL},
-    {"assign_font_dimen", assign_font_dimen_cmd, NULL},
-    {"assign_font_int", assign_font_int_cmd, NULL},
-    {"assign_hang_indent", assign_hang_indent_cmd, NULL},
-    {"set_aux", set_aux_cmd, NULL},
-    {"set_prev_graf", set_prev_graf_cmd, NULL},
-    {"set_page_dimen", set_page_dimen_cmd, NULL},
-    {"set_page_int", set_page_int_cmd, NULL},
-    {"set_box_dimen", set_box_dimen_cmd, NULL},
-    {"set_tex_shape", set_tex_shape_cmd, NULL},
-    {"set_etex_shape", set_etex_shape_cmd, NULL},
-    {"def_char_code", def_char_code_cmd, NULL},
-    {"def_del_code", def_del_code_cmd, NULL},
-    {"extdef_math_code", extdef_math_code_cmd, NULL},
-    {"extdef_del_code", extdef_del_code_cmd, NULL},
-    {"def_family", def_family_cmd, NULL},
-    {"set_math_param", set_math_param_cmd, NULL},
-    {"set_font", set_font_cmd, NULL},
-    {"def_font", def_font_cmd, NULL},
-    {"register", register_cmd, NULL},
-    {"assign_box_dir", assign_box_dir_cmd, NULL},
-    {"assign_dir", assign_dir_cmd, NULL},
-    {"advance", advance_cmd, NULL},
-    {"multiply", multiply_cmd, NULL},
-    {"divide", divide_cmd, NULL},
-    {"prefix", prefix_cmd, NULL},
-    {"let", let_cmd, NULL},
-    {"shorthand_def", shorthand_def_cmd, NULL},
-    {"read_to_cs", read_to_cs_cmd, NULL},
-    {"def", def_cmd, NULL},
-    {"set_box", set_box_cmd, NULL},
-    {"hyph_data", hyph_data_cmd, NULL},
-    {"set_interaction", set_interaction_cmd, NULL},
-    {"letterspace_font", letterspace_font_cmd, NULL},
-    {"expand_font",expand_font_cmd, NULL},
-    {"copy_font", copy_font_cmd, NULL},
-    {"set_font_id", set_font_id_cmd, NULL},
-    {"undefined_cs", undefined_cs_cmd, NULL},
-    {"expand_after", expand_after_cmd, NULL},
-    {"no_expand", no_expand_cmd, NULL},
-    {"input", input_cmd, NULL},
-    {"if_test", if_test_cmd, NULL},
-    {"fi_or_else", fi_or_else_cmd, NULL},
-    {"cs_name", cs_name_cmd, NULL},
-    {"convert", convert_cmd, NULL},
-    {"variable", variable_cmd, NULL},
-    {"feedback", feedback_cmd, NULL},
-    {"the", the_cmd, NULL},
-    {"combinetoks", combine_toks_cmd, NULL},
-    {"top_bot_mark", top_bot_mark_cmd, NULL},
-    {"call", call_cmd, NULL},
-    {"long_call", long_call_cmd, NULL},
-    {"outer_call", outer_call_cmd, NULL},
-    {"long_outer_call", long_outer_call_cmd, NULL},
-    {"end_template", end_template_cmd, NULL},
-    {"dont_expand", dont_expand_cmd, NULL},
-    {"glue_ref", glue_ref_cmd, NULL},
-    {"shape_ref", shape_ref_cmd, NULL},
-    {"box_ref", box_ref_cmd, NULL},
-    {"data", data_cmd, NULL},
-    {NULL, 0, NULL}
-};
-
-
-@ @c
-int get_command_id(const char *s)
-{
-    int i;
-    int cmd = -1;
-    for (i = 0; command_names[i].cmd_name != NULL; i++) {
-        if (strcmp(s, command_names[i].cmd_name) == 0)
-            break;
-    }
-    if (command_names[i].cmd_name != NULL) {
-        cmd = i;
-    }
-    return cmd;
-}
-
-/*
-static int get_cur_cmd(lua_State * L)
-{
-    int r = 0;
-    size_t len = lua_rawlen(L, -1);
-    cur_cs = 0;
-    if (len == 3 || len == 2) {
-        r = 1;
-        lua_rawgeti(L, -1, 1);
-        cur_cmd = (int) lua_tointeger(L, -1);
-        lua_rawgeti(L, -2, 2);
-        cur_chr = (halfword) lua_tointeger(L, -1);
-        if (len == 3) {
-            lua_rawgeti(L, -3, 3);
-            cur_cs = (halfword) lua_tointeger(L, -1);
-        }
-        lua_pop(L, (int) len);
-        if (cur_cs == 0)
-            cur_tok = token_val(cur_cmd, cur_chr);
-        else
-            cur_tok = cs_token_flag + cur_cs;
-    }
-    return r;
-}
-*/
-
-@ @c
-static int token_from_lua(lua_State * L)
-{
-    int cmd, chr;
-    int cs = 0;
-    size_t len = lua_rawlen(L, -1);
-    if (len == 3 || len == 2) {
-        lua_rawgeti(L, -1, 1);
-        cmd = (int) lua_tointeger(L, -1);
-        lua_rawgeti(L, -2, 2);
-        chr = (int) lua_tointeger(L, -1);
-        if (len == 3) {
-            lua_rawgeti(L, -3, 3);
-            cs = (int) lua_tointeger(L, -1);
-        }
-        lua_pop(L, (int) len);
-        if (cs == 0) {
-            return token_val(cmd, chr);
-        } else {
-            return cs_token_flag + cs;
-        }
-    }
-    return -1;
-}
-
-/*
-static int get_cur_cs(lua_State * L)
-{
-    const char *s;
-    unsigned j;
-    size_t l;
-    int cs;
-    int save_nncs;
-    int ret;
-    ret = 0;
-    cur_cs = 0;
-    lua_getfield(L, -1, "name");
-    if (lua_type(L, -1) == LUA_TSTRING) {
-        s = lua_tolstring(L, -1, &l);
-        if (l > 0) {
-            if ((last + (int) l) > buf_size)
-                check_buffer_overflow((last + (int) l));
-            for (j = 0; j < l; j++) {
-                buffer[(unsigned) last + 1 + j] = (packed_ASCII_code) * s++;
-            }
-            save_nncs = no_new_control_sequence;
-            no_new_control_sequence = false;
-            cs = id_lookup((last + 1), (int) l);
-            cur_tok = cs_token_flag + cs;
-            cur_cmd = eq_type(cs);
-            cur_chr = equiv(cs);
-            no_new_control_sequence = save_nncs;
-            ret = 1;
-        }
-    }
-    lua_pop(L, 1);
-    return ret;
-}
-*/
-
-@ @c
-void tokenlist_to_lua(lua_State * L, int p)
-{
-    int cmd, chr, cs;
-    int v;
-    int i = 1;
-    v = p;
-    while (v != null && v < (int) fix_mem_end) {
-        i++;
-        v = token_link(v);
-    }
-    i = 1;
-    lua_createtable(L, i, 0);
-    while (p != null && p < (int) fix_mem_end) {
-        if (token_info(p) >= cs_token_flag) {
-            cs = token_info(p) - cs_token_flag;
-            cmd = eq_type(cs);
-            chr = equiv(cs);
-            make_token_table(L, cmd, chr, cs);
-        } else {
-            cmd = token_cmd(token_info(p));
-            chr = token_chr(token_info(p));
-            make_token_table(L, cmd, chr, 0);
-        }
-        lua_rawseti(L, -2, i++);
-        p = token_link(p);
-    }
-}
-
-@ @c
-void tokenlist_to_luastring(lua_State * L, int p)
-{
-    int l;
-    char *s;
-    s = tokenlist_to_cstring(p, 1, &l);
-    lua_pushlstring(L, s, (size_t) l);
-    free(s);
-}
-
-
-@ @c
-int tokenlist_from_lua(lua_State * L)
-{
-    const char *s;
-    int tok, t;
-    size_t i, j;
-    halfword p, q, r;
-    r = get_avail();
-    token_info(r) = 0;          /* ref count */
-    token_link(r) = null;
-    p = r;
-    t = lua_type(L, -1);
-    if (t == LUA_TTABLE) {
-        j = lua_rawlen(L, -1);
-        if (j > 0) {
-            for (i = 1; i <= j; i++) {
-                lua_rawgeti(L, -1, (int) i);
-                tok = token_from_lua(L);
-                if (tok >= 0) {
-                    store_new_token(tok);
-                }
-                lua_pop(L, 1);
-            };
-        }
-        return r;
-    } else if (t == LUA_TSTRING) {
-        s = lua_tolstring(L, -1, &j);
-        for (i = 0; i < j; i++) {
-            if (s[i] == 32) {
-                tok = token_val(10, s[i]);
-            } else {
-                int j1 = (int) str2uni((const unsigned char *) (s + i));
-                i = i + (size_t) (utf8_size(j1) - 1);
-                tok = token_val(12, j1);
-            }
-            store_new_token(tok);
-        }
-        return r;
-    } else {
-        free_avail(r);
-        return null;
-    }
-}
-
-/*
-
-static void do_get_token_lua(int callback_id)
-{
-    while (1) {
-        if (!get_callback(Luas, callback_id)) {
-            get_next();
-            lua_pop(Luas, 2);
-            break;
-        }
-        if (lua_pcall(Luas, 0, 1, 0) != 0) {
-            tex_error(lua_tostring(Luas, -1), NULL);
-            lua_pop(Luas, 2);
-            break;
-        }
-        if (lua_istable(Luas, -1)) {
-            lua_rawgeti(Luas, -1, 1);
-            if (lua_istable(Luas, -1)) {
-                int p, q, r;
-                size_t i, j;
-                lua_pop(Luas, 1);
-                r = get_avail();
-                p = r;
-                j = lua_rawlen(Luas, -1);
-                if (j > 0) {
-                    for (i = 1; i <= j; i++) {
-                        lua_rawgeti(Luas, -1, (int) i);
-                        if (get_cur_cmd(Luas) || get_cur_cs(Luas)) {
-                            store_new_token(cur_tok);
-                        }
-                        lua_pop(Luas, 1);
-                    }
-                }
-                if (p != r) {
-                    p = token_link(r);
-                    free_avail(r);
-                    begin_token_list(p, inserted);
-                    cur_input.nofilter_field = true;
-                    get_next();
-                } else {
-                    tex_error("error: illegal or empty token list returned", NULL);
-                }
-                lua_pop(Luas, 2);
-                break;
-            } else {
-                lua_pop(Luas, 1);
-                if (get_cur_cmd(Luas) || get_cur_cs(Luas)) {
-                    lua_pop(Luas, 2);
-                    break;
-                } else {
-                    lua_pop(Luas, 2);
-                    continue;
-                }
-            }
-        } else {
-            lua_pop(Luas, 2);
-        }
-    }
-    return;
-}
-
-*/
diff --git a/texk/web2c/luatexdir/lua/mplibstuff.c b/texk/web2c/luatexdir/lua/mplibstuff.c
new file mode 100644
index 000000000..f1713ae0e
--- /dev/null
+++ b/texk/web2c/luatexdir/lua/mplibstuff.c
@@ -0,0 +1,115 @@
+/*
+
+mplibstuff.w
+
+Copyright 2017 LuaTeX team <bugs@@luatex.org>
+
+This file is part of LuaTeX.
+
+LuaTeX is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 2 of the License, or (at your
+option) any later version.
+
+LuaTeX is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+License for more details.
+
+You should have received a copy of the GNU General Public License along
+with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+
+*/
+
+/*tex
+
+The \PNG\ and \SVG\ backends are not available in \LUATEX, because it's complex
+to manage the math formulas at run time. In this respect \POSTSCRIPT\ and the
+highlevel |objects| are better, and they are the standard way. Another problem is
+how to emit the warning: the |normal_warning| function is not available when
+\LUATEX\ is called as \LUA\ only.
+
+*/
+
+#include <stdio.h>
+
+extern void normal_warning(const char *t, const char *p);
+
+extern int lua_only;
+
+#define mplibstuff_message(MSG) do { \
+    if (lua_only) { \
+        fprintf(stdout,"mplib: " #MSG " not available.\n"); \
+    } else { \
+        normal_warning("mplib",  #MSG " not available."); \
+    } \
+} while (0)
+
+void mp_png_backend_initialize (void *mp);
+void mp_png_backend_free (void *mp);
+int mp_png_gr_ship_out (void *hh, void *options, int standalone);
+int mp_png_ship_out (void *hh, const char *options);
+
+void mp_svg_backend_initialize (void *mp);
+void mp_svg_backend_free (void *mp);
+int mp_svg_ship_out (void *hh, int prologues);
+int mp_svg_gr_ship_out (void *hh, int qprologues, int standalone);
+
+void *mp_initialize_binary_math(void *mp);
+
+
+void mp_png_backend_initialize (void *mp)                         { return; }
+void mp_png_backend_free (void *mp)                               { return; }
+int mp_png_gr_ship_out (void *hh, void *options, int standalone)  { mplibstuff_message(png backend); return 1; }
+int mp_png_ship_out (void *hh, const char *options)               { mplibstuff_message(png backend); return 1; }
+
+void mp_svg_backend_initialize (void *mp)                         { return; }
+void mp_svg_backend_free (void *mp)                               { return; }
+int mp_svg_ship_out (void *hh, int prologues)                     { mplibstuff_message(svg bakend); return 1; }
+int mp_svg_gr_ship_out (void *hh, int qprologues, int standalone) { mplibstuff_message(svg backend); return 1; }
+
+
+void *mp_initialize_binary_math(void *mp)                         {mplibstuff_message(math binary);return NULL; }
+
+const char* cairo_version_string (void);
+const char* mpfr_get_version(void);
+const char* pixman_version_string (void);
+
+
+#define CAIRO_VERSION_STRING "CAIRO NOT AVAILABLE"
+const char *COMPILED_CAIRO_VERSION_STRING = CAIRO_VERSION_STRING;
+
+#define MPFR_VERSION_STRING "MPFR NOT AVAILABLE"
+const char *COMPILED_MPFR_VERSION_STRING = MPFR_VERSION_STRING;
+
+
+#define __GNU_MP_VERSION -1
+#define __GNU_MP_VERSION_MINOR -1
+#define __GNU_MP_VERSION_PATCHLEVEL -1 
+int COMPILED__GNU_MP_VERSION = __GNU_MP_VERSION ;
+int COMPILED__GNU_MP_VERSION_MINOR = __GNU_MP_VERSION_MINOR ;
+int COMPILED__GNU_MP_VERSION_PATCHLEVEL = __GNU_MP_VERSION_PATCHLEVEL ;
+const char * const COMPILED_gmp_version="GMP NOT AVAILABLE";
+
+#define PIXMAN_VERSION_STRING "PIXMAN NOT AVAILABLE"
+const char *COMPILED_PIXMAN_VERSION_STRING = PIXMAN_VERSION_STRING;
+
+const char* cairo_version_string (void)
+{
+    return CAIRO_VERSION_STRING;
+}
+
+const char* mpfr_get_version(void)
+{
+    return MPFR_VERSION_STRING;
+}
+
+const char* pixman_version_string (void)
+{
+    return PIXMAN_VERSION_STRING;
+}
+
+char png_libpng_ver[] = "PNG NOT AVAILABLE";
+
+
+
diff --git a/texk/web2c/luatexdir/lua/mplibstuff.w b/texk/web2c/luatexdir/lua/mplibstuff.w
deleted file mode 100644
index 3104a2870..000000000
--- a/texk/web2c/luatexdir/lua/mplibstuff.w
+++ /dev/null
@@ -1,93 +0,0 @@
-% mplibstuff.w
-%
-% Copyright 2017 LuaTeX team <bugs@@luatex.org>
-%
-% This file is part of LuaTeX.
-%
-% LuaTeX is free software; you can redistribute it and/or modify it under
-% the terms of the GNU General Public License as published by the Free
-% Software Foundation; either version 2 of the License, or (at your
-% option) any later version.
-%
-% LuaTeX is distributed in the hope that it will be useful, but WITHOUT
-% ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-% FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
-% License for more details.
-%
-% You should have received a copy of the GNU General Public License along
-% with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
-
-@ PNG and SVG backends are not available in \LuaTeX, because it's complex
-to manage the math formulas at run time. In this respect |PostScript| and the highlevel |objects|
-are better, and they are the standard way. Another problem is how to emit the warning:
-the |normal\_warning| function is not available when \LuaTeX\ is called as LUA only. 
-
-
-
-@c
-#include <stdio.h>
-
-extern void normal_warning(const char *t, const char *p);
-extern int lua_only;
-#define mplibstuff_message(BACKEND)  do {                          \
- if (lua_only) {                                                   \
-   fprintf(stdout,"mplib: " #BACKEND " backend not available.\n"); \
- } else {                                                          \
-   normal_warning("mplib",  #BACKEND " backend not available.");   \
- }                                                                 \
-} while (0)
-
- 
-@ @c
-void mp_png_backend_initialize (void *mp);
-void mp_png_backend_free (void *mp);
-int mp_png_gr_ship_out (void *hh, void *options, int standalone);
-int mp_png_ship_out (void *hh, const char *options);
-
-@ @c
-void mp_svg_backend_initialize (void *mp);
-void mp_svg_backend_free (void *mp);
-int mp_svg_ship_out (void *hh, int prologues);
-int mp_svg_gr_ship_out (void *hh, int qprologues, int standalone);
-
-@ @c
-void mp_png_backend_initialize (void *mp)                         {return; }  /*{mplibstuff_message(1png);return;}*/
-void mp_png_backend_free (void *mp)                               {return; }   /*{mplibstuff_message(png);return;}*/
-int mp_png_gr_ship_out (void *hh, void *options, int standalone)  {mplibstuff_message(png);return 1;}
-int mp_png_ship_out (void *hh, const char *options)               {mplibstuff_message(png);return 1;}
-
-@ @c
-void mp_svg_backend_initialize (void *mp)                         {return;}   /*{mplibstuff_message(svg);return;}*/
-void mp_svg_backend_free (void *mp)                               {return;}   /*{mplibstuff_message(svg);return;}*/
-int mp_svg_ship_out (void *hh, int prologues)                     {mplibstuff_message(svg);return 1;}
-int mp_svg_gr_ship_out (void *hh, int qprologues, int standalone) {mplibstuff_message(svg);return 1;}
-
-@ @c
-const char*
-cairo_version_string (void);
-const char*
-pixman_version_string (void);
-#define CAIRO_VERSION_STRING "CAIRO NOT AVAILABLE"
-const char *COMPILED_CAIRO_VERSION_STRING = CAIRO_VERSION_STRING;
-#define PIXMAN_VERSION_STRING "PIXMAN NOT AVAILABLE"
-const char *COMPILED_PIXMAN_VERSION_STRING = PIXMAN_VERSION_STRING;
-
-const char*
-cairo_version_string (void)
-{
- return CAIRO_VERSION_STRING;
-}
-
-const char*
-pixman_version_string (void)
-{
- return PIXMAN_VERSION_STRING;
-}
-
-
-
-
-
-@ @c
-char png_libpng_ver[] =      "PNG NOT AVAILABLE";
-
diff --git a/texk/web2c/luatexdir/lua/texluac.c b/texk/web2c/luatexdir/lua/texluac.c
new file mode 100644
index 000000000..61016cfdb
--- /dev/null
+++ b/texk/web2c/luatexdir/lua/texluac.c
@@ -0,0 +1,532 @@
+/*
+
+texluac.w
+
+Copyright (C) 1994-2007 Lua.org, PUC-Rio.  All rights reserved.
+Copyright 2006-2013 Taco Hoekwater <taco@@luatex.org>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+This file is part of LuaTeX.
+
+*/
+
+#include <ctype.h>
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define luac_c
+#define LUA_CORE
+
+#include "lua.h"
+#include "lauxlib.h"
+
+#include "ldebug.h"
+#include "ldo.h"
+#include "lfunc.h"
+#include "lmem.h"
+#include "lobject.h"
+#include "lopcodes.h"
+#include "lstring.h"
+#include "lundump.h"
+
+#include "lua/luatex-api.h"
+
+static void PrintFunction(const Proto* f, int full);
+
+#define luaU_print PrintFunction
+
+/*tex A fix for non-gcc compilation: */
+
+#if !defined(__GNUC__) || (__GNUC__ < 2)
+# define __attribute__(x)
+#endif
+
+/*tex default program name */
+
+#define PROGNAME "texluac"
+
+/*tex default output file */
+
+#define OUTPUT PROGNAME ".out"
+
+/*tex list bytecodes? */
+
+static int listing = 0;
+
+/*tex dump bytecodes? */
+
+static int dumping = 1;
+
+/*tex strip debug information? */
+
+static int stripping = 0;
+
+/*tex default output file name */
+
+static char Output[] = { OUTPUT };
+
+/*tex actual output file name */
+
+static const char *output = Output;
+
+/*tex actual program name */
+
+static const char *progname = PROGNAME;
+
+__attribute__ ((noreturn))
+static void fatal(const char *message) {
+    fprintf(stderr,"%s: %s\n",progname,message);
+    exit(EXIT_FAILURE);
+}
+
+__attribute__ ((noreturn))
+static void cannot(const char *what) {
+    fprintf(stderr,"%s: cannot %s %s: %s\n",progname,what,output,strerror(errno));
+    exit(EXIT_FAILURE);
+}
+
+__attribute__ ((noreturn))
+static void usage(const char* message)
+{
+    if (*message=='-')
+        fprintf(stderr,"%s: unrecognized option " LUA_QS "\n",progname,message);
+    else
+        fprintf(stderr,"%s: %s\n",progname,message);
+    fprintf(stderr,
+        "usage: %s [options] [filenames]\n"
+        "Available options are:\n"
+        "  -l       list (use -l -l for full listing)\n"
+        "  -o name  output to file " LUA_QL("name") " (default is \"%s\")\n"
+        "  -p       parse only\n"
+        "  -s       strip debug information\n"
+        "  -v       show version information\n"
+        "  --       stop handling options\n"
+        "  -        stop handling options and process stdin\n"
+        ,progname,Output);
+    exit(EXIT_FAILURE);
+}
+
+#define IS(s) (strcmp(argv[i],s)==0)
+
+static int doargs(int argc, char* argv[])
+{
+    int i;
+    int version=0;
+    if (argv[0]!=NULL && *argv[0]!=0)
+        progname=argv[0];
+    for (i=1; i<argc; i++) {
+        if (*argv[i]!='-') {
+            /* end of options; keep it */
+            break;
+        } else if (IS("--")) {
+            /* end of options; skip it */
+            ++i;
+            if (version) ++version;
+                break;
+        } else if (IS("-")) {
+            /* end of options; use stdin */
+            break;
+        } else if (IS("-l")) {
+            /* list */
+            ++listing;
+        } else if (IS("-o")) {
+            /* output file */
+            output=argv[++i];
+            if (output==NULL || *output==0 || (*output=='-' && output[1]!=0))
+                usage(LUA_QL("-o") " needs argument");
+            if (IS("-"))
+                output=NULL;
+        } else if (IS("-p")) {
+            /* parse only */
+            dumping=0;
+        } else if (IS("-s")) {
+            /* strip debug information */
+            stripping=1;
+        } else if (IS("-v")) {
+            /* show version */
+            ++version;
+        } else {
+            /* unknown option */
+            usage(argv[i]);
+        }
+    }
+    if (i==argc && (listing || !dumping)) {
+        dumping=0;
+        argv[--i]=Output;
+    }
+    if (version) {
+        printf("%s\n",LUA_COPYRIGHT);
+        if (version==argc-1)
+            exit(EXIT_SUCCESS);
+    }
+    return i;
+}
+
+#define FUNCTION "(function()end)();"
+
+static const char* reader(lua_State *L, void *ud, size_t *size)
+{
+    UNUSED(L);
+    if ((*(int*)ud)--) {
+        *size=sizeof(FUNCTION)-1;
+        return FUNCTION;
+    } else {
+        *size=0;
+        return NULL;
+    }
+}
+
+#define toproto(L,i) getproto(L->top+(i))
+
+static const Proto* combine(lua_State* L, int n)
+{
+    if (n==1) {
+        return toproto(L,-1);
+    } else {
+        Proto* f;
+        int i=n;
+        if (lua_load(L,reader,&i,"=(" PROGNAME ")",NULL)!=LUA_OK)
+            fatal(lua_tostring(L,-1));
+        f=toproto(L,-1);
+        for (i=0; i<n; i++) {
+            f->p[i]=toproto(L,i-n-1);
+            if (f->p[i]->sizeupvalues>0)
+                f->p[i]->upvalues[0].instack=0;
+        }
+        f->sizelineinfo=0;
+        return f;
+    }
+}
+
+static int writer(lua_State* L, const void* p, size_t size, void* u)
+{
+    UNUSED(L);
+    return (fwrite(p,size,1,(FILE*)u)!=1) && (size!=0);
+}
+
+static int pmain(lua_State* L)
+{
+    int argc=(int)lua_tointeger(L,1);
+    char** argv=(char**)lua_touserdata(L,2);
+    const Proto* f;
+    int i;
+    if (!lua_checkstack(L,argc))
+        fatal("too many input files");
+    /*tex
+        Open standard libraries: we need to to this to keep the symbol
+        |luaL_openlibs|.
+    */
+    luaL_checkversion(L);
+    /*tex stop collector during initialization */
+    lua_gc(L, LUA_GCSTOP, 0);
+    /*tex open libraries */
+    luaL_openlibs(L);
+    lua_gc(L, LUA_GCRESTART, 0);
+    for (i=0; i<argc; i++) {
+        const char* filename=IS("-") ? NULL : argv[i];
+    if (luaL_loadfile(L,filename)!=LUA_OK)
+        fatal(lua_tostring(L,-1));
+    }
+    f=combine(L,argc);
+    if (listing)
+        luaU_print(f,listing>1);
+    if (dumping) {
+        FILE* D= (output==NULL) ? stdout : fopen(output,"wb");
+        if (D==NULL)
+                cannot("open");
+        lua_lock(L);
+        luaU_dump(L,f,writer,D,stripping);
+        lua_unlock(L);
+        if (ferror(D))
+            cannot("write");
+        if (fclose(D))
+            cannot("close");
+    }
+    return 0;
+}
+
+int luac_main(int ac, char *av[])
+{
+    lua_State *L;
+    int i = doargs(ac, av);
+    ac -= i;
+    av += i;
+    if (ac <= 0)
+        usage("no input files given");
+    L=luaL_newstate();
+    if (L == NULL)
+        fatal("not enough memory for state");
+    lua_pushcfunction(L,&pmain);
+    lua_pushinteger(L,ac);
+    lua_pushlightuserdata(L,av);
+    if (lua_pcall(L,2,0,0)!=LUA_OK)
+      fatal(lua_tostring(L,-1));
+    lua_close(L);
+    return EXIT_SUCCESS;
+}
+
+/*
+    See Copyright Notice in |lua.h|.
+*/
+
+#define VOID(p)		((const void*)(p))
+
+#if (defined(LuajitTeX)) || (LUA_VERSION_NUM == 502)
+#define TSVALUE(o) rawtsvalue(o)
+#endif
+#if (LUA_VERSION_NUM == 503)
+#define TSVALUE(o) tsvalue(o)
+#endif
+
+static void PrintString(const TString* ts)
+{
+    const char* s=getstr(ts);
+    size_t i,n;
+#if (defined(LuajitTeX)) || (LUA_VERSION_NUM == 502)
+    n=ts->tsv.len;
+#endif
+#if (LUA_VERSION_NUM == 503)
+    n=(ts->tt == LUA_TSHRSTR ? ts->shrlen : ts->u.lnglen);
+#endif
+    printf("%c",'"');
+    for (i=0; i<n; i++) {
+        int c=(int)(unsigned char)s[i];
+        switch (c) {
+            case '"':
+                printf("\\\"");
+                break;
+            case '\\':
+                printf("\\\\");
+                break;
+            case '\a':
+                printf("\\a");
+            break;
+            case '\b':
+                printf("\\b");
+                break;
+            case '\f':
+                printf("\\f");
+                break;
+            case '\n':
+                printf("\\n");
+                break;
+            case '\r':
+                printf("\\r");
+                break;
+            case '\t':
+                printf("\\t");
+                break;
+            case '\v':
+                printf("\\v");
+                break;
+            default  :
+                if (isprint(c))
+                    printf("%c",c);
+                else
+                    printf("\\%03d",c);
+                break;
+        }
+    }
+    printf("%c",'"');
+}
+
+static void PrintConstant(const Proto* f, int i)
+{
+    const TValue* o=&f->k[i];
+    switch (ttype(o)) {
+        case LUA_TNIL:
+            printf("nil");
+            break;
+        case LUA_TBOOLEAN:
+            printf(bvalue(o) ? "true" : "false");
+            break;
+        case LUA_TNUMBER:
+            printf(LUA_NUMBER_FMT,nvalue(o));
+            break;
+        case LUA_TSTRING:
+            PrintString(TSVALUE(o));
+            break;
+        default:
+            /*tex This cannot happen. */
+            printf("? type=%d",ttype(o));
+            break;
+    }
+}
+
+#define UPVALNAME(x) ((f->upvalues[x].name) ? getstr(f->upvalues[x].name) : "-")
+#define MYK(x) (-1-(x))
+
+static void PrintCode(const Proto* f)
+{
+    const Instruction* code=f->code;
+    int pc,n=f->sizecode;
+    for (pc=0; pc<n; pc++) {
+        Instruction i=code[pc];
+        OpCode o=GET_OPCODE(i);
+        int a=GETARG_A(i);
+        int b=GETARG_B(i);
+        int c=GETARG_C(i);
+        int ax=GETARG_Ax(i);
+        int bx=GETARG_Bx(i);
+        int sbx=GETARG_sBx(i);
+        int line=getfuncline(f,pc);
+        printf("\t%d\t",pc+1);
+        if (line>0)
+            printf("[%d]\t",line);
+        else
+            printf("[-]\t");
+        printf("%-9s\t",luaP_opnames[o]);
+        switch (getOpMode(o)) {
+            case iABC:
+                printf("%d",a);
+                if (getBMode(o)!=OpArgN) printf(" %d",ISK(b) ? (MYK(INDEXK(b))) : b);
+                if (getCMode(o)!=OpArgN) printf(" %d",ISK(c) ? (MYK(INDEXK(c))) : c);
+                break;
+            case iABx:
+                printf("%d",a);
+                if (getBMode(o)==OpArgK) printf(" %d",MYK(bx));
+                if (getBMode(o)==OpArgU) printf(" %d",bx);
+                break;
+            case iAsBx:
+                printf("%d %d",a,sbx);
+                break;
+            case iAx:
+                printf("%d",MYK(ax));
+                break;
+        }
+        switch (o) {
+            case OP_LOADK:
+                printf("\t; "); PrintConstant(f,bx);
+                break;
+            case OP_GETUPVAL:
+            case OP_SETUPVAL:
+                printf("\t; %s",UPVALNAME(b));
+                break;
+            case OP_GETTABUP:
+                printf("\t; %s",UPVALNAME(b));
+                if (ISK(c)) { printf(" "); PrintConstant(f,INDEXK(c)); }
+                break;
+            case OP_SETTABUP:
+                printf("\t; %s",UPVALNAME(a));
+                if (ISK(b)) { printf(" "); PrintConstant(f,INDEXK(b)); }
+                if (ISK(c)) { printf(" "); PrintConstant(f,INDEXK(c)); }
+                break;
+            case OP_GETTABLE:
+            case OP_SELF:
+                if (ISK(c)) { printf("\t; "); PrintConstant(f,INDEXK(c)); }
+                break;
+            case OP_SETTABLE:
+            case OP_ADD:
+            case OP_SUB:
+            case OP_MUL:
+            case OP_DIV:
+            case OP_POW:
+            case OP_EQ:
+            case OP_LT:
+            case OP_LE:
+                if (ISK(b) || ISK(c)) {
+                    printf("\t; ");
+                    if (ISK(b)) PrintConstant(f,INDEXK(b)); else printf("-");
+                    printf(" ");
+                    if (ISK(c)) PrintConstant(f,INDEXK(c)); else printf("-");
+                }
+                break;
+            case OP_JMP:
+            case OP_FORLOOP:
+            case OP_FORPREP:
+            case OP_TFORLOOP:
+                printf("\t; to %d",sbx+pc+2);
+                break;
+            case OP_CLOSURE:
+                printf("\t; %p",VOID(f->p[bx]));
+                break;
+            case OP_SETLIST:
+                if (c==0) printf("\t; %d",(int)code[++pc]); else printf("\t; %d",c);
+                break;
+            case OP_EXTRAARG:
+                printf("\t; "); PrintConstant(f,ax);
+                break;
+            default:
+                break;
+        }
+        printf("\n");
+    }
+}
+
+#define SS(x) ((x==1)?"":"s")
+#define S(x)  (int)(x),SS(x)
+
+static void PrintHeader(const Proto* f)
+{
+    const char* s=f->source ? getstr(f->source) : "=?";
+    if (*s=='@' || *s=='=')
+        s++;
+    else if (*s==LUA_SIGNATURE[0])
+        s="(bstring)";
+    else
+        s="(string)";
+    printf("\n%s <%s:%d,%d> (%d instruction%s at %p)\n",
+        (f->linedefined==0)?"main":"function",s,
+        f->linedefined,f->lastlinedefined,
+        S(f->sizecode),VOID(f));
+    printf("%d%s param%s, %d slot%s, %d upvalue%s, ",
+        (int)(f->numparams),f->is_vararg?"+":"",SS(f->numparams),
+        S(f->maxstacksize),S(f->sizeupvalues));
+    printf("%d local%s, %d constant%s, %d function%s\n",
+        S(f->sizelocvars),S(f->sizek),S(f->sizep));
+}
+
+static void PrintDebug(const Proto* f)
+{
+    int i,n;
+    n=f->sizek;
+    printf("constants (%d) for %p:\n",n,VOID(f));
+    for (i=0; i<n; i++) {
+        printf("\t%d\t",i+1);
+        PrintConstant(f,i);
+        printf("\n");
+    }
+    n=f->sizelocvars;
+    printf("locals (%d) for %p:\n",n,VOID(f));
+    for (i=0; i<n; i++) {
+        printf("\t%d\t%s\t%d\t%d\n",
+        i,getstr(f->locvars[i].varname),f->locvars[i].startpc+1,f->locvars[i].endpc+1);
+    }
+    n=f->sizeupvalues;
+    printf("upvalues (%d) for %p:\n",n,VOID(f));
+    for (i=0; i<n; i++) {
+        printf("\t%d\t%s\t%d\t%d\n",
+        i,UPVALNAME(i),f->upvalues[i].instack,f->upvalues[i].idx);
+    }
+}
+
+static void PrintFunction(const Proto* f, int full)
+{
+    int i,n=f->sizep;
+    PrintHeader(f);
+    PrintCode(f);
+    if (full)
+        PrintDebug(f);
+    for (i=0; i<n; i++)
+        PrintFunction(f->p[i],full);
+}
diff --git a/texk/web2c/luatexdir/lua/texluac.w b/texk/web2c/luatexdir/lua/texluac.w
deleted file mode 100644
index 424c74c77..000000000
--- a/texk/web2c/luatexdir/lua/texluac.w
+++ /dev/null
@@ -1,495 +0,0 @@
-% texluac.w
-%
-% Copyright (C) 1994-2007 Lua.org, PUC-Rio.  All rights reserved.
-% Copyright 2006-2013 Taco Hoekwater <taco@@luatex.org>
-%
-% Permission is hereby granted, free of charge, to any person obtaining
-% a copy of this software and associated documentation files (the
-% "Software"), to deal in the Software without restriction, including
-% without limitation the rights to use, copy, modify, merge, publish,
-% distribute, sublicense, and/or sell copies of the Software, and to
-% permit persons to whom the Software is furnished to do so, subject to
-% the following conditions:
-%
-% The above copyright notice and this permission notice shall be
-% included in all copies or substantial portions of the Software.
-%
-% THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-% EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-% MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
-% IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-% CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
-% TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
-% SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-%
-% This file is part of LuaTeX.
-
-@ @c
-
-
-#include <ctype.h>
-#include <errno.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#define luac_c
-#define LUA_CORE
-
-#include "lua.h"
-#include "lauxlib.h"
-
-#include "ldebug.h"
-#include "ldo.h"
-#include "lfunc.h"
-#include "lmem.h"
-#include "lobject.h"
-#include "lopcodes.h"
-#include "lstring.h"
-#include "lundump.h"
-
-#include "lua/luatex-api.h"
-
-static void PrintFunction(const Proto* f, int full);
-#define luaU_print	PrintFunction
-
-@ @c
-/*  fix for non-gcc compilation: */
-#if !defined(__GNUC__) || (__GNUC__ < 2) 
-# define __attribute__(x)
-#endif /* !defined(__GNUC__) || (__GNUC__ < 2) */
-
-@ @c
-#define PROGNAME        "texluac"       /* default program name */
-#define OUTPUT          PROGNAME ".out" /* default output file */
-
-static int listing=0;			/* list bytecodes? */
-static int dumping = 1;         /* dump bytecodes? */
-static int stripping = 0;       /* strip debug information? */
-static char Output[] = { OUTPUT };      /* default output file name */
-
-static const char *output = Output;     /* actual output file name */
-static const char *progname = PROGNAME; /* actual program name */
-
-@ @c
-__attribute__ ((noreturn))
-static void fatal(const char *message)
-{
- fprintf(stderr,"%s: %s\n",progname,message);
- exit(EXIT_FAILURE);
-}
-
-@ @c
-__attribute__ ((noreturn))
-static void cannot(const char *what)
-{
- fprintf(stderr,"%s: cannot %s %s: %s\n",progname,what,output,strerror(errno));
- exit(EXIT_FAILURE);
-}
-
-@ @c
-__attribute__ ((noreturn))
-static void usage(const char* message)
-{
- if (*message=='-')
-  fprintf(stderr,"%s: unrecognized option " LUA_QS "\n",progname,message);
- else
-  fprintf(stderr,"%s: %s\n",progname,message);
- fprintf(stderr,
-  "usage: %s [options] [filenames]\n"
-  "Available options are:\n"
-  "  -l       list (use -l -l for full listing)\n"
-  "  -o name  output to file " LUA_QL("name") " (default is \"%s\")\n"
-  "  -p       parse only\n"
-  "  -s       strip debug information\n"
-  "  -v       show version information\n"
-  "  --       stop handling options\n"
-  "  -        stop handling options and process stdin\n"
-  ,progname,Output);
- exit(EXIT_FAILURE);
-}
-
-@ @c
-#define IS(s)   (strcmp(argv[i],s)==0)
-
-static int doargs(int argc, char* argv[])
-{
- int i;
- int version=0;
- if (argv[0]!=NULL && *argv[0]!=0) progname=argv[0];
- for (i=1; i<argc; i++)
- {
-  if (*argv[i]!='-')			/* end of options; keep it */
-   break;
-  else if (IS("--"))			/* end of options; skip it */
-  {
-   ++i;
-   if (version) ++version;
-   break;
-  }
-  else if (IS("-"))			/* end of options; use stdin */
-   break;
-  else if (IS("-l"))			/* list */
-   ++listing;
-  else if (IS("-o"))			/* output file */
-  {
-   output=argv[++i];
-   if (output==NULL || *output==0 || (*output=='-' && output[1]!=0))
-    usage(LUA_QL("-o") " needs argument");
-   if (IS("-")) output=NULL;
-  }
-  else if (IS("-p"))			/* parse only */
-   dumping=0;
-  else if (IS("-s"))			/* strip debug information */
-   stripping=1;
-  else if (IS("-v"))			/* show version */
-   ++version;
-  else					/* unknown option */
-   usage(argv[i]);
- }
- if (i==argc && (listing || !dumping))
- {
-  dumping=0;
-  argv[--i]=Output;
- }
- if (version)
- {
-  printf("%s\n",LUA_COPYRIGHT);
-  if (version==argc-1) exit(EXIT_SUCCESS);
- }
- return i;
-}
-
-@ @c
-#define FUNCTION "(function()end)();"
-
-static const char* reader(lua_State *L, void *ud, size_t *size)
-{
- UNUSED(L);
- if ((*(int*)ud)--)
- {
-  *size=sizeof(FUNCTION)-1;
-  return FUNCTION;
- }
- else
- {
-  *size=0;
-  return NULL;
- }
-}
-
-#define toproto(L,i) getproto(L->top+(i))
-
-static const Proto* combine(lua_State* L, int n)
-{
- if (n==1)
-  return toproto(L,-1);
- else
- {
-  Proto* f;
-  int i=n;
-  if (lua_load(L,reader,&i,"=(" PROGNAME ")",NULL)!=LUA_OK) fatal(lua_tostring(L,-1));
-  f=toproto(L,-1);
-  for (i=0; i<n; i++)
-  {
-   f->p[i]=toproto(L,i-n-1);
-   if (f->p[i]->sizeupvalues>0) f->p[i]->upvalues[0].instack=0;
-  }
-  f->sizelineinfo=0;
-  return f;
- }
-}
-
-@ @c
-static int writer(lua_State* L, const void* p, size_t size, void* u)
-{
- UNUSED(L);
- return (fwrite(p,size,1,(FILE*)u)!=1) && (size!=0);
-}
-
-static int pmain(lua_State* L)
-{
- int argc=(int)lua_tointeger(L,1);
- char** argv=(char**)lua_touserdata(L,2);
- const Proto* f;
- int i;
- if (!lua_checkstack(L,argc)) fatal("too many input files");
- /* open standard libraries:    */
- /* we need to to this to keep */
- /* the symbol luaL_openlibs   */ 
- luaL_checkversion(L);
- lua_gc(L, LUA_GCSTOP, 0);  /* stop collector during initialization */
- luaL_openlibs(L);  /* open libraries */
- lua_gc(L, LUA_GCRESTART, 0);
- for (i=0; i<argc; i++)
- {
-  const char* filename=IS("-") ? NULL : argv[i];
-  if (luaL_loadfile(L,filename)!=LUA_OK) fatal(lua_tostring(L,-1));
- }
- f=combine(L,argc);
- if (listing) luaU_print(f,listing>1);
- if (dumping)
- {
-  FILE* D= (output==NULL) ? stdout : fopen(output,"wb");
-  if (D==NULL) cannot("open");
-  lua_lock(L);
-  luaU_dump(L,f,writer,D,stripping);
-  lua_unlock(L);
-  if (ferror(D)) cannot("write");
-  if (fclose(D)) cannot("close");
- }
- return 0;
-}
-
-@ @c
-int luac_main(int ac, char *av[])
-{
-    lua_State *L;
-    int i = doargs(ac, av);
-    ac -= i;
-    av += i;
-    if (ac <= 0)
-        usage("no input files given");
-    L=luaL_newstate();
-    if (L == NULL)
-        fatal("not enough memory for state");
-    lua_pushcfunction(L,&pmain);
-    lua_pushinteger(L,ac);
-    lua_pushlightuserdata(L,av);
-    if (lua_pcall(L,2,0,0)!=LUA_OK) 
-      fatal(lua_tostring(L,-1));
-    lua_close(L);
-    return EXIT_SUCCESS;
-}
-
-/*
-** print bytecodes
-** See Copyright Notice in lua.h
-*/
-
-#define VOID(p)		((const void*)(p))
-
-#if (defined(LuajitTeX)) || (LUA_VERSION_NUM == 502) 
-#define TSVALUE(o) rawtsvalue(o)
-#endif
-#if (LUA_VERSION_NUM == 503) 
-#define TSVALUE(o) tsvalue(o)
-#endif
-
-
-static void PrintString(const TString* ts)
-{
- const char* s=getstr(ts);
- size_t i,n;
-#if (defined(LuajitTeX)) || (LUA_VERSION_NUM == 502) 
-  n=ts->tsv.len;
-#endif
-#if (LUA_VERSION_NUM == 503) 
-  n=(ts->tt == LUA_TSHRSTR ? ts->shrlen : ts->u.lnglen);
-#endif
- printf("%c",'"');
- for (i=0; i<n; i++)
- {
-  int c=(int)(unsigned char)s[i];
-  switch (c)
-  {
-   case '"':  printf("\\\""); break;
-   case '\\': printf("\\\\"); break;
-   case '\a': printf("\\a"); break;
-   case '\b': printf("\\b"); break;
-   case '\f': printf("\\f"); break;
-   case '\n': printf("\\n"); break;
-   case '\r': printf("\\r"); break;
-   case '\t': printf("\\t"); break;
-   case '\v': printf("\\v"); break;
-   default:	if (isprint(c))
-   			printf("%c",c);
-		else
-			printf("\\%03d",c);
-  }
- }
- printf("%c",'"');
-}
-
-static void PrintConstant(const Proto* f, int i)
-{
- const TValue* o=&f->k[i];
- switch (ttype(o))
- {
-  case LUA_TNIL:
-	printf("nil");
-	break;
-  case LUA_TBOOLEAN:
-	printf(bvalue(o) ? "true" : "false");
-	break;
-  case LUA_TNUMBER:
-	printf(LUA_NUMBER_FMT,nvalue(o));
-	break;
-  case LUA_TSTRING:
-        PrintString(TSVALUE(o));
-	break;
-  default:				/* cannot happen */
-	printf("? type=%d",ttype(o));
-	break;
- }
-}
-
-#define UPVALNAME(x) ((f->upvalues[x].name) ? getstr(f->upvalues[x].name) : "-")
-#define MYK(x)		(-1-(x))
-
-static void PrintCode(const Proto* f)
-{
- const Instruction* code=f->code;
- int pc,n=f->sizecode;
- for (pc=0; pc<n; pc++)
- {
-  Instruction i=code[pc];
-  OpCode o=GET_OPCODE(i);
-  int a=GETARG_A(i);
-  int b=GETARG_B(i);
-  int c=GETARG_C(i);
-  int ax=GETARG_Ax(i);
-  int bx=GETARG_Bx(i);
-  int sbx=GETARG_sBx(i);
-  int line=getfuncline(f,pc);
-  printf("\t%d\t",pc+1);
-  if (line>0) printf("[%d]\t",line); else printf("[-]\t");
-  printf("%-9s\t",luaP_opnames[o]);
-  switch (getOpMode(o))
-  {
-   case iABC:
-    printf("%d",a);
-    if (getBMode(o)!=OpArgN) printf(" %d",ISK(b) ? (MYK(INDEXK(b))) : b);
-    if (getCMode(o)!=OpArgN) printf(" %d",ISK(c) ? (MYK(INDEXK(c))) : c);
-    break;
-   case iABx:
-    printf("%d",a);
-    if (getBMode(o)==OpArgK) printf(" %d",MYK(bx));
-    if (getBMode(o)==OpArgU) printf(" %d",bx);
-    break;
-   case iAsBx:
-    printf("%d %d",a,sbx);
-    break;
-   case iAx:
-    printf("%d",MYK(ax));
-    break;
-  }
-  switch (o)
-  {
-   case OP_LOADK:
-    printf("\t; "); PrintConstant(f,bx);
-    break;
-   case OP_GETUPVAL:
-   case OP_SETUPVAL:
-    printf("\t; %s",UPVALNAME(b));
-    break;
-   case OP_GETTABUP:
-    printf("\t; %s",UPVALNAME(b));
-    if (ISK(c)) { printf(" "); PrintConstant(f,INDEXK(c)); }
-    break;
-   case OP_SETTABUP:
-    printf("\t; %s",UPVALNAME(a));
-    if (ISK(b)) { printf(" "); PrintConstant(f,INDEXK(b)); }
-    if (ISK(c)) { printf(" "); PrintConstant(f,INDEXK(c)); }
-    break;
-   case OP_GETTABLE:
-   case OP_SELF:
-    if (ISK(c)) { printf("\t; "); PrintConstant(f,INDEXK(c)); }
-    break;
-   case OP_SETTABLE:
-   case OP_ADD:
-   case OP_SUB:
-   case OP_MUL:
-   case OP_DIV:
-   case OP_POW:
-   case OP_EQ:
-   case OP_LT:
-   case OP_LE:
-    if (ISK(b) || ISK(c))
-    {
-     printf("\t; ");
-     if (ISK(b)) PrintConstant(f,INDEXK(b)); else printf("-");
-     printf(" ");
-     if (ISK(c)) PrintConstant(f,INDEXK(c)); else printf("-");
-    }
-    break;
-   case OP_JMP:
-   case OP_FORLOOP:
-   case OP_FORPREP:
-   case OP_TFORLOOP:
-    printf("\t; to %d",sbx+pc+2);
-    break;
-   case OP_CLOSURE:
-    printf("\t; %p",VOID(f->p[bx]));
-    break;
-   case OP_SETLIST:
-    if (c==0) printf("\t; %d",(int)code[++pc]); else printf("\t; %d",c);
-    break;
-   case OP_EXTRAARG:
-    printf("\t; "); PrintConstant(f,ax);
-    break;
-   default:
-    break;
-  }
-  printf("\n");
- }
-}
-
-#define SS(x)	((x==1)?"":"s")
-#define S(x)	(int)(x),SS(x)
-
-static void PrintHeader(const Proto* f)
-{
- const char* s=f->source ? getstr(f->source) : "=?";
- if (*s=='@@' || *s=='=')
-  s++;
- else if (*s==LUA_SIGNATURE[0])
-  s="(bstring)";
- else
-  s="(string)";
- printf("\n%s <%s:%d,%d> (%d instruction%s at %p)\n",
- 	(f->linedefined==0)?"main":"function",s,
-	f->linedefined,f->lastlinedefined,
-	S(f->sizecode),VOID(f));
- printf("%d%s param%s, %d slot%s, %d upvalue%s, ",
-	(int)(f->numparams),f->is_vararg?"+":"",SS(f->numparams),
-	S(f->maxstacksize),S(f->sizeupvalues));
- printf("%d local%s, %d constant%s, %d function%s\n",
-	S(f->sizelocvars),S(f->sizek),S(f->sizep));
-}
-
-static void PrintDebug(const Proto* f)
-{
- int i,n;
- n=f->sizek;
- printf("constants (%d) for %p:\n",n,VOID(f));
- for (i=0; i<n; i++)
- {
-  printf("\t%d\t",i+1);
-  PrintConstant(f,i);
-  printf("\n");
- }
- n=f->sizelocvars;
- printf("locals (%d) for %p:\n",n,VOID(f));
- for (i=0; i<n; i++)
- {
-  printf("\t%d\t%s\t%d\t%d\n",
-  i,getstr(f->locvars[i].varname),f->locvars[i].startpc+1,f->locvars[i].endpc+1);
- }
- n=f->sizeupvalues;
- printf("upvalues (%d) for %p:\n",n,VOID(f));
- for (i=0; i<n; i++)
- {
-  printf("\t%d\t%s\t%d\t%d\n",
-  i,UPVALNAME(i),f->upvalues[i].instack,f->upvalues[i].idx);
- }
-}
-
-static void PrintFunction(const Proto* f, int full)
-{
- int i,n=f->sizep;
- PrintHeader(f);
- PrintCode(f);
- if (full) PrintDebug(f);
- for (i=0; i<n; i++) PrintFunction(f->p[i],full);
-}
diff --git a/texk/web2c/luatexdir/lua/texluajitc.c b/texk/web2c/luatexdir/lua/texluajitc.c
new file mode 100644
index 000000000..5cac5d65a
--- /dev/null
+++ b/texk/web2c/luatexdir/lua/texluajitc.c
@@ -0,0 +1,650 @@
+/*
+
+    LuaJIT frontend. Runs commands, scripts, read-eval-print (REPL) etc.
+    Copyright (C) 2005-2012 Mike Pall. See Copyright Notice in luajit.h
+
+    Major portions taken verbatim or adapted from the Lua interpreter.
+    Copyright (C) 1994-2008 Lua.org, PUC-Rio. See Copyright Notice in lua.h
+
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define luajit_c
+
+#include "lua.h"
+#include "lauxlib.h"
+#include "lualib.h"
+#include "luajit.h"
+
+#include "lj_arch.h"
+
+#if LJ_TARGET_POSIX
+#include <unistd.h>
+#define lua_stdin_is_tty()	isatty(0)
+#elif LJ_TARGET_WINDOWS
+#include <io.h>
+#ifdef __BORLANDC__
+#define lua_stdin_is_tty()	isatty(_fileno(stdin))
+#else
+#define lua_stdin_is_tty()	_isatty(_fileno(stdin))
+#endif
+#else
+#define lua_stdin_is_tty()	1
+#endif
+
+#if !LJ_TARGET_CONSOLE
+#include <signal.h>
+#endif
+
+#include "lua/luatex-api.h"
+
+static lua_State *globalL = NULL;
+static const char *progname = LUA_PROGNAME;
+
+#if !LJ_TARGET_CONSOLE
+
+static void lstop(lua_State *L, lua_Debug *ar)
+{
+  /*tex Unused arg. */
+  (void)ar;
+  lua_sethook(L, NULL, 0, 0);
+  /*tex Avoid luaL_error -- a C hook doesn't add an extra frame. */
+  luaL_where(L, 0);
+  lua_pushfstring(L, "%sinterrupted!", lua_tostring(L, -1));
+  lua_error(L);
+}
+
+/*tex if another SIGINT happens before lstop, terminate process (default action) */
+
+static void laction(int i)
+{
+  signal(i, SIG_DFL);
+  lua_sethook(globalL, lstop, LUA_MASKCALL | LUA_MASKRET | LUA_MASKCOUNT, 1);
+}
+
+#endif
+
+static void print_usage(void)
+{
+    fprintf(stderr,
+    "usage: %s [options]... [script [args]...].\n"
+    "Available options are:\n"
+    "  -e chunk  Execute string " LUA_QL("chunk") ".\n"
+    "  -l name   Require library " LUA_QL("name") ".\n"
+    "  -b ...    Save or list bytecode.\n"
+    "  -j cmd    Perform LuaJIT control command.\n"
+    "  -O[opt]   Control LuaJIT optimizations.\n"
+    "  -i        Enter interactive mode after executing " LUA_QL("script") ".\n"
+    "  -v        Show version information.\n"
+    "  -E        Ignore environment variables.\n"
+    "  --        Stop handling options.\n"
+    "  -         Execute stdin and stop handling options.\n"
+    ,
+    progname);
+    fflush(stderr);
+}
+
+static void l_message(const char *pname, const char *msg)
+{
+    if (pname) fprintf(stderr, "%s: ", pname);
+    fprintf(stderr, "%s\n", msg);
+    fflush(stderr);
+}
+
+static int report(lua_State *L, int status)
+{
+    if (status && !lua_isnil(L, -1)) {
+        const char *msg = lua_tostring(L, -1);
+        if (msg == NULL)
+            msg = "(error object is not a string)";
+        l_message(progname, msg);
+        lua_pop(L, 1);
+    }
+    return status;
+}
+
+static int traceback(lua_State *L)
+{
+    if (!lua_isstring(L, 1)) {
+        /*tex Non-string error object? Try metamethod. */
+        if (lua_isnoneornil(L, 1) || !luaL_callmeta(L, 1, "__tostring") || !lua_isstring(L, -1)) {
+            /*tex Return non-string error object. */
+            return 1;
+        }
+        /*tex Replace object by result of __tostring metamethod. */
+        lua_remove(L, 1);
+    }
+    luaL_traceback(L, L, lua_tostring(L, 1), 1);
+    return 1;
+}
+
+static int docall(lua_State *L, int narg, int clear)
+{
+    int status;
+    /*tex function index */
+    int base = lua_gettop(L) - narg;
+    /*tex push traceback function */
+    lua_pushcfunction(L, traceback);
+    /*tex put it under chunk and args */
+    lua_insert(L, base);
+#if !LJ_TARGET_CONSOLE
+    signal(SIGINT, laction);
+#endif
+    status = lua_pcall(L, narg, (clear ? 0 : LUA_MULTRET), base);
+#if !LJ_TARGET_CONSOLE
+    signal(SIGINT, SIG_DFL);
+#endif
+    /*tex remove traceback function */
+    lua_remove(L, base);
+    /*tex force a complete garbage collection in case of errors */
+    if (status != 0)
+        lua_gc(L, LUA_GCCOLLECT, 0);
+    return status;
+}
+
+static void print_version(void)
+{
+    fputs(LUAJIT_VERSION " -- " LUAJIT_COPYRIGHT ". " LUAJIT_URL "\n", stdout);
+}
+
+static void print_jit_status(lua_State *L)
+{
+    int n;
+    const char *s;
+    lua_getfield(L, LUA_REGISTRYINDEX, "_LOADED");
+    /*tex Get jit.* module table. */
+    lua_getfield(L, -1, "jit");
+    lua_remove(L, -2);
+    lua_getfield(L, -1, "status");
+    lua_remove(L, -2);
+    n = lua_gettop(L);
+    lua_call(L, 0, LUA_MULTRET);
+    fputs(lua_toboolean(L, n) ? "JIT: ON" : "JIT: OFF", stdout);
+    for (n++; (s = lua_tostring(L, n)); n++) {
+        putc(' ', stdout);
+        fputs(s, stdout);
+    }
+    putc('\n', stdout);
+}
+
+static int getargs(lua_State *L, char **argv, int n)
+{
+    int narg = 0;
+    int i;
+    /*tex count total number of arguments */
+    while (argv[argc]) argc++;
+    /*tex number of arguments to the script */
+    narg = argc - (n + 1);
+    luaL_checkstack(L, narg + 3, "too many arguments to script");
+    for (i = n+1; i < argc; i++) {
+        lua_pushstring(L, argv[i]);
+    }
+    lua_createtable(L, narg, n + 1);
+    for (i = 0; i < argc; i++) {
+        lua_pushstring(L, argv[i]);
+        lua_rawseti(L, -2, i - n);
+    }
+    return narg;
+}
+
+static int dofile(lua_State *L, const char *name)
+{
+    int status = luaL_loadfile(L, name) || docall(L, 0, 1);
+    return report(L, status);
+}
+
+static int dostring(lua_State *L, const char *s, const char *name)
+{
+    int status = luaL_loadbuffer(L, s, strlen(s), name) || docall(L, 0, 1);
+    return report(L, status);
+}
+
+static int dolibrary(lua_State *L, const char *name)
+{
+    lua_getglobal(L, "require");
+    lua_pushstring(L, name);
+    return report(L, docall(L, 1, 1));
+}
+
+static void write_prompt(lua_State *L, int firstline)
+{
+    const char *p;
+    lua_getfield(L, LUA_GLOBALSINDEX, firstline ? "_PROMPT" : "_PROMPT2");
+    p = lua_tostring(L, -1);
+    if (p == NULL) p = firstline ? LUA_PROMPT : LUA_PROMPT2;
+    fputs(p, stdout);
+    fflush(stdout);
+    /*tex remove global */
+    lua_pop(L, 1);
+}
+
+static int incomplete(lua_State *L, int status)
+{
+    if (status == LUA_ERRSYNTAX) {
+        size_t lmsg;
+        const char *msg = lua_tolstring(L, -1, &lmsg);
+        const char *tp = msg + lmsg - (sizeof(LUA_QL("<eof>")) - 1);
+        if (strstr(msg, LUA_QL("<eof>")) == tp) {
+            lua_pop(L, 1);
+            return 1;
+        }
+    }
+    return 0;
+}
+
+static int pushline(lua_State *L, int firstline)
+{
+    char buf[LUA_MAXINPUT];
+    write_prompt(L, firstline);
+    if (fgets(buf, LUA_MAXINPUT, stdin)) {
+        size_t len = strlen(buf);
+        if (len > 0 && buf[len-1] == '\n')
+            buf[len-1] = '\0';
+        if (firstline && buf[0] == '=')
+            lua_pushfstring(L, "return %s", buf+1);
+        else
+            lua_pushstring(L, buf);
+        return 1;
+    }
+    return 0;
+}
+
+static int loadline(lua_State *L)
+{
+    int status;
+    lua_settop(L, 0);
+    if (!pushline(L, 1)) {
+        /*tex no input */
+        return -1;
+    }
+    for (;;) {
+        /*tex repeat until gets a complete line */
+        status = luaL_loadbuffer(L, lua_tostring(L, 1), lua_strlen(L, 1), "=stdin");
+        /*tex cannot try to add lines? */
+        if (!incomplete(L, status)) 
+            break;
+        /*tex no more input? */
+        if (!pushline(L, 0))
+            return -1;
+        /*tex add a new line... */
+        lua_pushliteral(L, "\n");
+        /*tex ...between the two lines */
+        lua_insert(L, -2);
+        /*tex join them */
+        lua_concat(L, 3);
+    }
+    /*tex remove line */
+    lua_remove(L, 1);
+    return status;
+}
+
+static void dotty(lua_State *L)
+{
+    int status;
+    const char *oldprogname = progname;
+    progname = NULL;
+    while ((status = loadline(L)) != -1) {
+        if (status == 0)
+            status = docall(L, 0, 0);
+        report(L, status);
+        if (status == 0 && lua_gettop(L) > 0) {
+            /*tex any result to print? */
+            lua_getglobal(L, "print");
+            lua_insert(L, 1);
+            if (lua_pcall(L, lua_gettop(L)-1, 0, 0) != 0)
+                l_message(progname,
+            lua_pushfstring(L, "error calling " LUA_QL("print") " (%s)",
+            lua_tostring(L, -1)));
+        }
+    }
+    /*tex clear stack */
+    lua_settop(L, 0);
+    fputs("\n", stdout);
+    fflush(stdout);
+    progname = oldprogname;
+}
+
+static int handle_script(lua_State *L, char **argv, int n)
+{
+    int status;
+    const char *fname;
+    /*tex collect arguments */
+    int narg = getargs(L, argv, n);
+    lua_setglobal(L, "arg");
+    fname = argv[n];
+    if (strcmp(fname, "-") == 0 && strcmp(argv[n-1], "--") != 0) {
+        /*tex use stdin */
+        fname = NULL;
+    }
+    status = luaL_loadfile(L, fname);
+    lua_insert(L, -(narg+1));
+    if (status == 0)
+        status = docall(L, narg, 0);
+    else
+        lua_pop(L, narg);
+    return report(L, status);
+}
+
+/*tex Load add-on module. */
+
+static int loadjitmodule(lua_State *L)
+{
+    lua_getglobal(L, "require");
+    lua_pushliteral(L, "jit.");
+    lua_pushvalue(L, -3);
+    lua_concat(L, 2);
+    if (lua_pcall(L, 1, 1, 0)) {
+        const char *msg = lua_tostring(L, -1);
+        if (msg && !strncmp(msg, "module ", 7)) {
+          err:
+            l_message(progname,
+            "unknown luaJIT command or jit.* modules not installed");
+            return 1;
+        } else {
+            return report(L, 1);
+        }
+    }
+    lua_getfield(L, -1, "start");
+    if (lua_isnil(L, -1))
+        goto err;
+    /*tex Drop module table. */
+    lua_remove(L, -2);
+    return 0;
+}
+
+/*tex Run command with options. */
+
+static int runcmdopt(lua_State *L, const char *opt)
+{
+    int narg = 0;
+    if (opt && *opt) {
+        /*tex Split arguments. */
+        for (;;) {
+            const char *p = strchr(opt, ',');
+            narg++;
+            if (!p)
+                break;
+            if (p == opt)
+                lua_pushnil(L);
+            else
+                lua_pushlstring(L, opt, (size_t)(p - opt));
+            opt = p + 1;
+        }
+        if (*opt)
+            lua_pushstring(L, opt);
+        else
+            lua_pushnil(L);
+    }
+    return report(L, lua_pcall(L, narg, 0, 0));
+}
+
+/*tex JIT engine control command: try jit library first or load add-on module. */
+
+static int dojitcmd(lua_State *L, const char *cmd)
+{
+    const char *opt = strchr(cmd, '=');
+    lua_pushlstring(L, cmd, opt ? (size_t)(opt - cmd) : strlen(cmd));
+    lua_getfield(L, LUA_REGISTRYINDEX, "_LOADED");
+    /*tex Get jit.* module table. */
+    lua_getfield(L, -1, "jit");
+    lua_remove(L, -2);
+    /*tex Lookup library function. */
+    lua_pushvalue(L, -2);
+    lua_gettable(L, -2);
+    if (!lua_isfunction(L, -1)) {
+        /*tex Drop non-function and jit.* table, keep module name. */
+        lua_pop(L, 2);
+        if (loadjitmodule(L))
+            return 1;
+    } else {
+        /*tex Drop jit.* table. */
+        lua_remove(L, -2);
+    }
+    /*tex Drop module name. */
+    lua_remove(L, -2);
+    return runcmdopt(L, opt ? opt+1 : opt);
+}
+
+/*tex Optimization flags. */
+
+static int dojitopt(lua_State *L, const char *opt)
+{
+    lua_getfield(L, LUA_REGISTRYINDEX, "_LOADED");
+    lua_getfield(L, -1, "jit.opt");
+    lua_remove(L, -2);
+    lua_getfield(L, -1, "start");
+    lua_remove(L, -2);
+    return runcmdopt(L, opt);
+}
+
+/*tex Save or list bytecode. */
+
+static int dobytecode(lua_State *L, char **argv)
+{
+    int narg = 0;
+    lua_pushliteral(L, "bcsave");
+    if (loadjitmodule(L))
+        return 1;
+    if (argv[0][2]) {
+        narg++;
+        argv[0][1] = '-';
+        lua_pushstring(L, argv[0]+1);
+    }
+    for (argv++; *argv != NULL; narg++, argv++)
+        lua_pushstring(L, *argv);
+    return report(L, lua_pcall(L, narg, 0, 0));
+}
+
+/*tex Check that argument has no extra characters at the end */
+
+#define notail(x)	{if ((x)[2] != '\0') return -1;}
+
+#define FLAGS_INTERACTIVE  1
+#define FLAGS_VERSION      2
+#define FLAGS_EXEC         4
+#define FLAGS_OPTION       8
+#define FLAGS_NOENV       16
+
+static int collectargs(char **argv, int *flags)
+{
+    int i;
+    for (i = 1; argv[i] != NULL; i++) {
+        /*tex Not an option? */
+        if (argv[i][0] != '-')
+            return i;
+        /*tex Check option. */
+        switch (argv[i][1]) {
+            case '-':
+                notail(argv[i]);
+                return (argv[i+1] != NULL ? i+1 : 0);
+            case '\0':
+                return i;
+            case 'i':
+                notail(argv[i]);
+                *flags |= FLAGS_INTERACTIVE;
+                /*tex fallthrough */
+            case 'v':
+                notail(argv[i]);
+                *flags |= FLAGS_VERSION;
+                break;
+            case 'e':
+                *flags |= FLAGS_EXEC;
+            case 'j':
+                /*tex LuaJIT extension */
+            case 'l':
+                *flags |= FLAGS_OPTION;
+                if (argv[i][2] == '\0') {
+                    i++;
+                    if (argv[i] == NULL)
+                        return -1;
+                }
+                break;
+            case 'O':
+                /*tex LuaJIT extension */
+                break;
+            case 'b':
+                /*tex LuaJIT extension */
+                if (*flags) return -1;
+                    *flags |= FLAGS_EXEC;
+                return 0;
+            case 'E':
+                *flags |= FLAGS_NOENV;
+                break;
+            default:
+                /*tex invalid option */
+                return -1;
+        }
+    }
+    return 0;
+}
+
+static int runargs(lua_State *L, char **argv, int n)
+{
+    int i;
+    for (i = 1; i < n; i++) {
+        if (argv[i] == NULL)
+            continue;
+        lua_assert(argv[i][0] == '-');
+        switch (argv[i][1]) {
+            /*tex Options */
+            case 'e': {
+                const char *chunk = argv[i] + 2;
+                if (*chunk == '\0')
+                    chunk = argv[++i];
+                lua_assert(chunk != NULL);
+                if (dostring(L, chunk, "=(command line)") != 0)
+                    return 1;
+                break;
+            }
+            case 'l': {
+                const char *filename = argv[i] + 2;
+                if (*filename == '\0')
+                    filename = argv[++i];
+                lua_assert(filename != NULL);
+                if (dolibrary(L, filename)) {
+                    /*tex stop if file fails */
+                    return 1;
+                }
+                break;
+            }
+            case 'j': {
+                /*tex LuaJIT extension */
+                const char *cmd = argv[i] + 2;
+                if (*cmd == '\0')
+                    cmd = argv[++i];
+                lua_assert(cmd != NULL);
+                if (dojitcmd(L, cmd))
+                    return 1;
+                break;
+            }
+            case 'O':
+                /*tex LuaJIT extension */
+                if (dojitopt(L, argv[i] + 2))
+                    return 1;
+                break;
+            case 'b':
+                /*tex LuaJIT extension */
+                return dobytecode(L, argv+i);
+                default: break;
+            }
+    }
+    return 0;
+}
+
+static int handle_luainit(lua_State *L)
+{
+#if LJ_TARGET_CONSOLE
+    const char *init = NULL;
+#else
+    const char *init = getenv(LUA_INIT);
+#endif
+    if (init == NULL) {
+        /*tex status OK */
+        return 0;
+    } else if (init[0] == 64) {
+        return dofile(L, init+1);
+    } else {
+        return dostring(L, init, "=" LUA_INIT);
+    }
+}
+
+struct Smain {
+    char **argv;
+    int argc;
+    int status;
+};
+
+static int pmain(lua_State *L)
+{
+    struct Smain *s = (struct Smain *)lua_touserdata(L, 1);
+    char **argv = s->argv;
+    int script;
+    int flags = 0;
+    globalL = L;
+    if (argv[0] && argv[0][0])
+        progname = argv[0];
+    /*tex linker-enforced version check */
+    LUAJIT_VERSION_SYM();
+    script = collectargs(argv, &flags);
+    if (script < 0) {
+        /*tex invalid args? */
+        print_usage();
+        s->status = 1;
+        return 0;
+    }
+    if ((flags & FLAGS_NOENV)) {
+        lua_pushboolean(L, 1);
+        lua_setfield(L, LUA_REGISTRYINDEX, "LUA_NOENV");
+    }
+    /*tex stop collector during initialization */
+    lua_gc(L, LUA_GCSTOP, 0);
+    /*tex open libraries */
+    luaL_openlibs(L);
+    lua_gc(L, LUA_GCRESTART, -1);
+    if (!(flags & FLAGS_NOENV)) {
+        s->status = handle_luainit(L);
+        if (s->status != 0) return 0;
+    }
+    if ((flags & FLAGS_VERSION)) print_version();
+    s->status = runargs(L, argv, (script > 0) ? script : s->argc);
+    if (s->status != 0) return 0;
+    if (script) {
+        s->status = handle_script(L, argv, script);
+        if (s->status != 0) return 0;
+    }
+    if ((flags & FLAGS_INTERACTIVE)) {
+        print_jit_status(L);
+        dotty(L);
+    } else if (script == 0 && !(flags & (FLAGS_EXEC|FLAGS_VERSION))) {
+        if (lua_stdin_is_tty()) {
+            print_version();
+            print_jit_status(L);
+            dotty(L);
+        } else {
+            /*tex executes stdin as a file */
+            dofile(L, NULL);
+        }
+    }
+    return 0;
+}
+
+int luac_main(int argc, char **argv)
+{
+    int status;
+    struct Smain s;
+    lua_State *L = lua_open();  /* create state */
+    if (L == NULL) {
+        l_message(argv[0], "cannot create state: not enough memory");
+        return EXIT_FAILURE;
+    }
+    s.argc = argc;
+    s.argv = argv;
+    status = lua_cpcall(L, pmain, &s);
+    report(L, status);
+    lua_close(L);
+    return (status || s.status) ? EXIT_FAILURE : EXIT_SUCCESS;
+}
+
diff --git a/texk/web2c/luatexdir/lua/texluajitc.w b/texk/web2c/luatexdir/lua/texluajitc.w
deleted file mode 100644
index f54f9c8d4..000000000
--- a/texk/web2c/luatexdir/lua/texluajitc.w
+++ /dev/null
@@ -1,575 +0,0 @@
-/*
-** LuaJIT frontend. Runs commands, scripts, read-eval-print (REPL) etc.
-** Copyright (C) 2005-2012 Mike Pall. See Copyright Notice in luajit.h
-**
-** Major portions taken verbatim or adapted from the Lua interpreter.
-** Copyright (C) 1994-2008 Lua.org, PUC-Rio. See Copyright Notice in lua.h
-*/
-
-@ @c
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#define luajit_c
-
-#include "lua.h"
-#include "lauxlib.h"
-#include "lualib.h"
-#include "luajit.h"
-
-#include "lj_arch.h"
-
-#if LJ_TARGET_POSIX
-#include <unistd.h>
-#define lua_stdin_is_tty()	isatty(0)
-#elif LJ_TARGET_WINDOWS
-#include <io.h>
-#ifdef __BORLANDC__
-#define lua_stdin_is_tty()	isatty(_fileno(stdin))
-#else
-#define lua_stdin_is_tty()	_isatty(_fileno(stdin))
-#endif
-#else
-#define lua_stdin_is_tty()	1
-#endif
-
-#if !LJ_TARGET_CONSOLE
-#include <signal.h>
-#endif
-
-#include "lua/luatex-api.h"
-
-static lua_State *globalL = NULL;
-static const char *progname = LUA_PROGNAME;
-
-#if !LJ_TARGET_CONSOLE
-static void lstop(lua_State *L, lua_Debug *ar)
-{
-  (void)ar;  /* unused arg. */
-  lua_sethook(L, NULL, 0, 0);
-  /* Avoid luaL_error -- a C hook doesn't add an extra frame. */
-  luaL_where(L, 0);
-  lua_pushfstring(L, "%sinterrupted!", lua_tostring(L, -1));
-  lua_error(L);
-}
-
-static void laction(int i)
-{
-  signal(i, SIG_DFL); /* if another SIGINT happens before lstop,
-			 terminate process (default action) */
-  lua_sethook(globalL, lstop, LUA_MASKCALL | LUA_MASKRET | LUA_MASKCOUNT, 1);
-}
-#endif
-
-static void print_usage(void)
-{
-  fprintf(stderr,
-  "usage: %s [options]... [script [args]...].\n"
-  "Available options are:\n"
-  "  -e chunk  Execute string " LUA_QL("chunk") ".\n"
-  "  -l name   Require library " LUA_QL("name") ".\n"
-  "  -b ...    Save or list bytecode.\n"
-  "  -j cmd    Perform LuaJIT control command.\n"
-  "  -O[opt]   Control LuaJIT optimizations.\n"
-  "  -i        Enter interactive mode after executing " LUA_QL("script") ".\n"
-  "  -v        Show version information.\n"
-  "  -E        Ignore environment variables.\n"
-  "  --        Stop handling options.\n"
-  "  -         Execute stdin and stop handling options.\n"
-  ,
-  progname);
-  fflush(stderr);
-}
-
-static void l_message(const char *pname, const char *msg)
-{
-  if (pname) fprintf(stderr, "%s: ", pname);
-  fprintf(stderr, "%s\n", msg);
-  fflush(stderr);
-}
-
-static int report(lua_State *L, int status)
-{
-  if (status && !lua_isnil(L, -1)) {
-    const char *msg = lua_tostring(L, -1);
-    if (msg == NULL) msg = "(error object is not a string)";
-    l_message(progname, msg);
-    lua_pop(L, 1);
-  }
-  return status;
-}
-
-static int traceback(lua_State *L)
-{
-  if (!lua_isstring(L, 1)) { /* Non-string error object? Try metamethod. */
-    if (lua_isnoneornil(L, 1) ||
-	!luaL_callmeta(L, 1, "__tostring") ||
-	!lua_isstring(L, -1))
-      return 1;  /* Return non-string error object. */
-    lua_remove(L, 1);  /* Replace object by result of __tostring metamethod. */
-  }
-  luaL_traceback(L, L, lua_tostring(L, 1), 1);
-  return 1;
-}
-
-static int docall(lua_State *L, int narg, int clear)
-{
-  int status;
-  int base = lua_gettop(L) - narg;  /* function index */
-  lua_pushcfunction(L, traceback);  /* push traceback function */
-  lua_insert(L, base);  /* put it under chunk and args */
-#if !LJ_TARGET_CONSOLE
-  signal(SIGINT, laction);
-#endif
-  status = lua_pcall(L, narg, (clear ? 0 : LUA_MULTRET), base);
-#if !LJ_TARGET_CONSOLE
-  signal(SIGINT, SIG_DFL);
-#endif
-  lua_remove(L, base);  /* remove traceback function */
-  /* force a complete garbage collection in case of errors */
-  if (status != 0) lua_gc(L, LUA_GCCOLLECT, 0);
-  return status;
-}
-
-static void print_version(void)
-{
-  fputs(LUAJIT_VERSION " -- " LUAJIT_COPYRIGHT ". " LUAJIT_URL "\n", stdout);
-}
-
-static void print_jit_status(lua_State *L)
-{
-  int n;
-  const char *s;
-  lua_getfield(L, LUA_REGISTRYINDEX, "_LOADED");
-  lua_getfield(L, -1, "jit");  /* Get jit.* module table. */
-  lua_remove(L, -2);
-  lua_getfield(L, -1, "status");
-  lua_remove(L, -2);
-  n = lua_gettop(L);
-  lua_call(L, 0, LUA_MULTRET);
-  fputs(lua_toboolean(L, n) ? "JIT: ON" : "JIT: OFF", stdout);
-  for (n++; (s = lua_tostring(L, n)); n++) {
-    putc(' ', stdout);
-    fputs(s, stdout);
-  }
-  putc('\n', stdout);
-}
-
-static int getargs(lua_State *L, char **argv, int n)
-{
-  int narg;
-  int i;
-  int argc = 0;
-  while (argv[argc]) argc++;  /* count total number of arguments */
-  narg = argc - (n + 1);  /* number of arguments to the script */
-  luaL_checkstack(L, narg + 3, "too many arguments to script");
-  for (i = n+1; i < argc; i++)
-    lua_pushstring(L, argv[i]);
-  lua_createtable(L, narg, n + 1);
-  for (i = 0; i < argc; i++) {
-    lua_pushstring(L, argv[i]);
-    lua_rawseti(L, -2, i - n);
-  }
-  return narg;
-}
-
-static int dofile(lua_State *L, const char *name)
-{
-  int status = luaL_loadfile(L, name) || docall(L, 0, 1);
-  return report(L, status);
-}
-
-static int dostring(lua_State *L, const char *s, const char *name)
-{
-  int status = luaL_loadbuffer(L, s, strlen(s), name) || docall(L, 0, 1);
-  return report(L, status);
-}
-
-static int dolibrary(lua_State *L, const char *name)
-{
-  lua_getglobal(L, "require");
-  lua_pushstring(L, name);
-  return report(L, docall(L, 1, 1));
-}
-
-static void write_prompt(lua_State *L, int firstline)
-{
-  const char *p;
-  lua_getfield(L, LUA_GLOBALSINDEX, firstline ? "_PROMPT" : "_PROMPT2");
-  p = lua_tostring(L, -1);
-  if (p == NULL) p = firstline ? LUA_PROMPT : LUA_PROMPT2;
-  fputs(p, stdout);
-  fflush(stdout);
-  lua_pop(L, 1);  /* remove global */
-}
-
-static int incomplete(lua_State *L, int status)
-{
-  if (status == LUA_ERRSYNTAX) {
-    size_t lmsg;
-    const char *msg = lua_tolstring(L, -1, &lmsg);
-    const char *tp = msg + lmsg - (sizeof(LUA_QL("<eof>")) - 1);
-    if (strstr(msg, LUA_QL("<eof>")) == tp) {
-      lua_pop(L, 1);
-      return 1;
-    }
-  }
-  return 0;  /* else... */
-}
-
-static int pushline(lua_State *L, int firstline)
-{
-  char buf[LUA_MAXINPUT];
-  write_prompt(L, firstline);
-  if (fgets(buf, LUA_MAXINPUT, stdin)) {
-    size_t len = strlen(buf);
-    if (len > 0 && buf[len-1] == '\n')
-      buf[len-1] = '\0';
-    if (firstline && buf[0] == '=')
-      lua_pushfstring(L, "return %s", buf+1);
-    else
-      lua_pushstring(L, buf);
-    return 1;
-  }
-  return 0;
-}
-
-static int loadline(lua_State *L)
-{
-  int status;
-  lua_settop(L, 0);
-  if (!pushline(L, 1))
-    return -1;  /* no input */
-  for (;;) {  /* repeat until gets a complete line */
-    status = luaL_loadbuffer(L, lua_tostring(L, 1), lua_strlen(L, 1), "=stdin");
-    if (!incomplete(L, status)) break;  /* cannot try to add lines? */
-    if (!pushline(L, 0))  /* no more input? */
-      return -1;
-    lua_pushliteral(L, "\n");  /* add a new line... */
-    lua_insert(L, -2);  /* ...between the two lines */
-    lua_concat(L, 3);  /* join them */
-  }
-  lua_remove(L, 1);  /* remove line */
-  return status;
-}
-
-static void dotty(lua_State *L)
-{
-  int status;
-  const char *oldprogname = progname;
-  progname = NULL;
-  while ((status = loadline(L)) != -1) {
-    if (status == 0) status = docall(L, 0, 0);
-    report(L, status);
-    if (status == 0 && lua_gettop(L) > 0) {  /* any result to print? */
-      lua_getglobal(L, "print");
-      lua_insert(L, 1);
-      if (lua_pcall(L, lua_gettop(L)-1, 0, 0) != 0)
-	l_message(progname,
-	  lua_pushfstring(L, "error calling " LUA_QL("print") " (%s)",
-			      lua_tostring(L, -1)));
-    }
-  }
-  lua_settop(L, 0);  /* clear stack */
-  fputs("\n", stdout);
-  fflush(stdout);
-  progname = oldprogname;
-}
-
-static int handle_script(lua_State *L, char **argv, int n)
-{
-  int status;
-  const char *fname;
-  int narg = getargs(L, argv, n);  /* collect arguments */
-  lua_setglobal(L, "arg");
-  fname = argv[n];
-  if (strcmp(fname, "-") == 0 && strcmp(argv[n-1], "--") != 0)
-    fname = NULL;  /* stdin */
-  status = luaL_loadfile(L, fname);
-  lua_insert(L, -(narg+1));
-  if (status == 0)
-    status = docall(L, narg, 0);
-  else
-    lua_pop(L, narg);
-  return report(L, status);
-}
-
-/* Load add-on module. */
-static int loadjitmodule(lua_State *L)
-{
-  lua_getglobal(L, "require");
-  lua_pushliteral(L, "jit.");
-  lua_pushvalue(L, -3);
-  lua_concat(L, 2);
-  if (lua_pcall(L, 1, 1, 0)) {
-    const char *msg = lua_tostring(L, -1);
-    if (msg && !strncmp(msg, "module ", 7)) {
-    err:
-      l_message(progname,
-		"unknown luaJIT command or jit.* modules not installed");
-      return 1;
-    } else {
-      return report(L, 1);
-    }
-  }
-  lua_getfield(L, -1, "start");
-  if (lua_isnil(L, -1)) goto err;
-  lua_remove(L, -2);  /* Drop module table. */
-  return 0;
-}
-
-/* Run command with options. */
-static int runcmdopt(lua_State *L, const char *opt)
-{
-  int narg = 0;
-  if (opt && *opt) {
-    for (;;) {  /* Split arguments. */
-      const char *p = strchr(opt, ',');
-      narg++;
-      if (!p) break;
-      if (p == opt)
-	lua_pushnil(L);
-      else
-	lua_pushlstring(L, opt, (size_t)(p - opt));
-      opt = p + 1;
-    }
-    if (*opt)
-      lua_pushstring(L, opt);
-    else
-      lua_pushnil(L);
-  }
-  return report(L, lua_pcall(L, narg, 0, 0));
-}
-
-/* JIT engine control command: try jit library first or load add-on module. */
-static int dojitcmd(lua_State *L, const char *cmd)
-{
-  const char *opt = strchr(cmd, '=');
-  lua_pushlstring(L, cmd, opt ? (size_t)(opt - cmd) : strlen(cmd));
-  lua_getfield(L, LUA_REGISTRYINDEX, "_LOADED");
-  lua_getfield(L, -1, "jit");  /* Get jit.* module table. */
-  lua_remove(L, -2);
-  lua_pushvalue(L, -2);
-  lua_gettable(L, -2);  /* Lookup library function. */
-  if (!lua_isfunction(L, -1)) {
-    lua_pop(L, 2);  /* Drop non-function and jit.* table, keep module name. */
-    if (loadjitmodule(L))
-      return 1;
-  } else {
-    lua_remove(L, -2);  /* Drop jit.* table. */
-  }
-  lua_remove(L, -2);  /* Drop module name. */
-  return runcmdopt(L, opt ? opt+1 : opt);
-}
-
-/* Optimization flags. */
-static int dojitopt(lua_State *L, const char *opt)
-{
-  lua_getfield(L, LUA_REGISTRYINDEX, "_LOADED");
-  lua_getfield(L, -1, "jit.opt");  /* Get jit.opt.* module table. */
-  lua_remove(L, -2);
-  lua_getfield(L, -1, "start");
-  lua_remove(L, -2);
-  return runcmdopt(L, opt);
-}
-
-/* Save or list bytecode. */
-static int dobytecode(lua_State *L, char **argv)
-{
-  int narg = 0;
-  lua_pushliteral(L, "bcsave");
-  if (loadjitmodule(L))
-    return 1;
-  if (argv[0][2]) {
-    narg++;
-    argv[0][1] = '-';
-    lua_pushstring(L, argv[0]+1);
-  }
-  for (argv++; *argv != NULL; narg++, argv++)
-    lua_pushstring(L, *argv);
-  return report(L, lua_pcall(L, narg, 0, 0));
-}
-
-/* check that argument has no extra characters at the end */
-#define notail(x)	{if ((x)[2] != '\0') return -1;}
-
-#define FLAGS_INTERACTIVE	1
-#define FLAGS_VERSION		2
-#define FLAGS_EXEC		4
-#define FLAGS_OPTION		8
-#define FLAGS_NOENV		16
-
-static int collectargs(char **argv, int *flags)
-{
-  int i;
-  for (i = 1; argv[i] != NULL; i++) {
-    if (argv[i][0] != '-')  /* Not an option? */
-      return i;
-    switch (argv[i][1]) {  /* Check option. */
-    case '-':
-      notail(argv[i]);
-      return (argv[i+1] != NULL ? i+1 : 0);
-    case '\0':
-      return i;
-    case 'i':
-      notail(argv[i]);
-      *flags |= FLAGS_INTERACTIVE;
-      /* fallthrough */
-    case 'v':
-      notail(argv[i]);
-      *flags |= FLAGS_VERSION;
-      break;
-    case 'e':
-      *flags |= FLAGS_EXEC;
-    case 'j':  /* LuaJIT extension */
-    case 'l':
-      *flags |= FLAGS_OPTION;
-      if (argv[i][2] == '\0') {
-	i++;
-	if (argv[i] == NULL) return -1;
-      }
-      break;
-    case 'O': break;  /* LuaJIT extension */
-    case 'b':  /* LuaJIT extension */
-      if (*flags) return -1;
-      *flags |= FLAGS_EXEC;
-      return 0;
-    case 'E':
-      *flags |= FLAGS_NOENV;
-      break;
-    default: return -1;  /* invalid option */
-    }
-  }
-  return 0;
-}
-
-static int runargs(lua_State *L, char **argv, int n)
-{
-  int i;
-  for (i = 1; i < n; i++) {
-    if (argv[i] == NULL) continue;
-    lua_assert(argv[i][0] == '-');
-    switch (argv[i][1]) {  /* option */
-    case 'e': {
-      const char *chunk = argv[i] + 2;
-      if (*chunk == '\0') chunk = argv[++i];
-      lua_assert(chunk != NULL);
-      if (dostring(L, chunk, "=(command line)") != 0)
-	return 1;
-      break;
-      }
-    case 'l': {
-      const char *filename = argv[i] + 2;
-      if (*filename == '\0') filename = argv[++i];
-      lua_assert(filename != NULL);
-      if (dolibrary(L, filename))
-	return 1;  /* stop if file fails */
-      break;
-      }
-    case 'j': {  /* LuaJIT extension */
-      const char *cmd = argv[i] + 2;
-      if (*cmd == '\0') cmd = argv[++i];
-      lua_assert(cmd != NULL);
-      if (dojitcmd(L, cmd))
-	return 1;
-      break;
-      }
-    case 'O':  /* LuaJIT extension */
-      if (dojitopt(L, argv[i] + 2))
-	return 1;
-      break;
-    case 'b':  /* LuaJIT extension */
-      return dobytecode(L, argv+i);
-    default: break;
-    }
-  }
-  return 0;
-}
-
-static int handle_luainit(lua_State *L)
-{
-#if LJ_TARGET_CONSOLE
-  const char *init = NULL;
-#else
-  const char *init = getenv(LUA_INIT);
-#endif
-  if (init == NULL)
-    return 0;  /* status OK */
-  else if (init[0] == 64)
-    return dofile(L, init+1);
-  else
-    return dostring(L, init, "=" LUA_INIT);
-}
-
-struct Smain {
-  char **argv;
-  int argc;
-  int status;
-};
-
-static int pmain(lua_State *L)
-{
-  struct Smain *s = (struct Smain *)lua_touserdata(L, 1);
-  char **argv = s->argv;
-  int script;
-  int flags = 0;
-  globalL = L;
-  if (argv[0] && argv[0][0]) progname = argv[0];
-  LUAJIT_VERSION_SYM();  /* linker-enforced version check */
-  script = collectargs(argv, &flags);
-  if (script < 0) {  /* invalid args? */
-    print_usage();
-    s->status = 1;
-    return 0;
-  }
-  if ((flags & FLAGS_NOENV)) {
-    lua_pushboolean(L, 1);
-    lua_setfield(L, LUA_REGISTRYINDEX, "LUA_NOENV");
-  }
-  lua_gc(L, LUA_GCSTOP, 0);  /* stop collector during initialization */
-  luaL_openlibs(L);  /* open libraries */
-  lua_gc(L, LUA_GCRESTART, -1);
-  if (!(flags & FLAGS_NOENV)) {
-    s->status = handle_luainit(L);
-    if (s->status != 0) return 0;
-  }
-  if ((flags & FLAGS_VERSION)) print_version();
-  s->status = runargs(L, argv, (script > 0) ? script : s->argc);
-  if (s->status != 0) return 0;
-  if (script) {
-    s->status = handle_script(L, argv, script);
-    if (s->status != 0) return 0;
-  }
-  if ((flags & FLAGS_INTERACTIVE)) {
-    print_jit_status(L);
-    dotty(L);
-  } else if (script == 0 && !(flags & (FLAGS_EXEC|FLAGS_VERSION))) {
-    if (lua_stdin_is_tty()) {
-      print_version();
-      print_jit_status(L);
-      dotty(L);
-    } else {
-      dofile(L, NULL);  /* executes stdin as a file */
-    }
-  }
-  return 0;
-}
-
-int luac_main(int argc, char **argv)
-{
-  int status;
-  struct Smain s;
-  lua_State *L = lua_open();  /* create state */
-  if (L == NULL) {
-    l_message(argv[0], "cannot create state: not enough memory");
-    return EXIT_FAILURE;
-  }
-  s.argc = argc;
-  s.argv = argv;
-  status = lua_cpcall(L, pmain, &s);
-  report(L, status);
-  lua_close(L);
-  return (status || s.status) ? EXIT_FAILURE : EXIT_SUCCESS;
-}
-
diff --git a/texk/web2c/luatexdir/pdf/pdfaction.w b/texk/web2c/luatexdir/pdf/pdfaction.c
similarity index 85%
rename from texk/web2c/luatexdir/pdf/pdfaction.w
rename to texk/web2c/luatexdir/pdf/pdfaction.c
index bb0d6e06d..2909ac6ad 100644
--- a/texk/web2c/luatexdir/pdf/pdfaction.w
+++ b/texk/web2c/luatexdir/pdf/pdfaction.c
@@ -1,29 +1,29 @@
-% pdfaction.w
-%
-% Copyright 2009-2011 Taco Hoekwater <taco@@luatex.org>
-%
-% This file is part of LuaTeX.
-%
-% LuaTeX is free software; you can redistribute it and/or modify it under
-% the terms of the GNU General Public License as published by the Free
-% Software Foundation; either version 2 of the License, or (at your
-% option) any later version.
-%
-% LuaTeX is distributed in the hope that it will be useful, but WITHOUT
-% ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-% FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
-% License for more details.
-%
-% You should have received a copy of the GNU General Public License along
-% with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+/*
 
-@ @c
+Copyright 2009-2011 Taco Hoekwater <taco@luatex.org>
+
+This file is part of LuaTeX.
+
+LuaTeX is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 2 of the License, or (at your
+option) any later version.
+
+LuaTeX is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+License for more details.
+
+You should have received a copy of the GNU General Public License along
+with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+
+*/
 
 #include "ptexlib.h"
 
-@ read an action specification
+/*tex Read an action specification. */
 
-@c halfword scan_action(PDF pdf)
+halfword scan_action(PDF pdf)
 {
     int p = new_node(whatsit_node, pdf_action_node);
     (void) pdf;
@@ -73,13 +73,13 @@
     }
     if (scan_keyword("newwindow")) {
         set_pdf_action_new_window(p, pdf_window_new);
-        /* Scan an optional space */
+        /*tex Scan an optional space. */
         get_x_token();
         if (cur_cmd != spacer_cmd)
             back_input();
     } else if (scan_keyword("nonewwindow")) {
         set_pdf_action_new_window(p, pdf_window_nonew);
-        /* Scan an optional space */
+        /*tex Scan an optional space. */
         get_x_token();
         if (cur_cmd != spacer_cmd)
             back_input();
@@ -94,9 +94,9 @@
     return p;
 }
 
-@ write an action specification
+/*tex Write an action specification. */
 
-@c void write_action(PDF pdf, halfword p)
+void write_action(PDF pdf, halfword p)
 {
     char *s;
     int d = 0;
diff --git a/texk/web2c/luatexdir/pdf/pdfannot.w b/texk/web2c/luatexdir/pdf/pdfannot.c
similarity index 66%
rename from texk/web2c/luatexdir/pdf/pdfannot.w
rename to texk/web2c/luatexdir/pdf/pdfannot.c
index 43ee3692b..e501947c7 100644
--- a/texk/web2c/luatexdir/pdf/pdfannot.w
+++ b/texk/web2c/luatexdir/pdf/pdfannot.c
@@ -1,27 +1,26 @@
-% pdfannot.w
-%
-% Copyright 2009-2011 Taco Hoekwater <taco@@luatex.org>
-%
-% This file is part of LuaTeX.
-%
-% LuaTeX is free software; you can redistribute it and/or modify it under
-% the terms of the GNU General Public License as published by the Free
-% Software Foundation; either version 2 of the License, or (at your
-% option) any later version.
-%
-% LuaTeX is distributed in the hope that it will be useful, but WITHOUT
-% ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-% FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
-% License for more details.
-%
-% You should have received a copy of the GNU General Public License along
-% with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+/*
 
-@ @c
+Copyright 2009-2011 Taco Hoekwater <taco@luatex.org>
+
+This file is part of LuaTeX.
+
+LuaTeX is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 2 of the License, or (at your
+option) any later version.
+
+LuaTeX is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+License for more details.
+
+You should have received a copy of the GNU General Public License along
+with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+
+*/
 
 #include "ptexlib.h"
 
-@ @c
 void do_annot(PDF pdf, halfword p, halfword parent_box, scaledpos cur)
 {
     scaled_whd alt_rule;
@@ -43,13 +42,13 @@ void do_annot(PDF pdf, halfword p, halfword parent_box, scaledpos cur)
     addto_page_resources(pdf, obj_type_annot, pdf_annot_objnum(p));
 }
 
-@ create a new whatsit node for annotation
+/*tex Create a new whatsit node for annotation. */
 
-@c void new_annot_whatsit(small_number w)
+void new_annot_whatsit(small_number w)
 {
     scaled_whd alt_rule;
     new_whatsit(w);
-    alt_rule = scan_alt_rule(); /* scans |<rule spec>| to |alt_rule| */
+    alt_rule = scan_alt_rule();
     set_width(tail_par, alt_rule.wd);
     set_height(tail_par, alt_rule.ht);
     set_depth(tail_par, alt_rule.dp);
@@ -63,14 +62,14 @@ void do_annot(PDF pdf, halfword p, halfword parent_box, scaledpos cur)
     }
 }
 
-@ scanning at the \TeX\ end
+/*tex Scanning at the \TEX\ end: */
 
-@c void scan_annot(PDF pdf)
+void scan_annot(PDF pdf)
 {
     int k;
     if (scan_keyword("reserveobjnum")) {
         k = pdf_create_obj(pdf, obj_type_annot, 0);
-        /* Scan an optional space */
+        /*tex Scan an optional space. */
         get_x_token();
         if (cur_cmd != spacer_cmd)
             back_input();
diff --git a/texk/web2c/luatexdir/pdf/pdfcolorstack.w b/texk/web2c/luatexdir/pdf/pdfcolorstack.c
similarity index 79%
rename from texk/web2c/luatexdir/pdf/pdfcolorstack.w
rename to texk/web2c/luatexdir/pdf/pdfcolorstack.c
index ac117d6ba..fbb88692f 100644
--- a/texk/web2c/luatexdir/pdf/pdfcolorstack.w
+++ b/texk/web2c/luatexdir/pdf/pdfcolorstack.c
@@ -1,43 +1,53 @@
-% pdfcolorstack.w
-%
-% Copyright 2009-2011 Taco Hoekwater <taco@@luatex.org>
-%
-% This file is part of LuaTeX.
-%
-% LuaTeX is free software; you can redistribute it and/or modify it under
-% the terms of the GNU General Public License as published by the Free
-% Software Foundation; either version 2 of the License, or (at your
-% option) any later version.
-%
-% LuaTeX is distributed in the hope that it will be useful, but WITHOUT
-% ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-% FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
-% License for more details.
-%
-% You should have received a copy of the GNU General Public License along
-% with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
-
-@ @c
+/*
 
-#include "ptexlib.h"
+Copyright 2009-2011 Taco Hoekwater <taco@luatex.org>
+
+This file is part of LuaTeX.
+
+LuaTeX is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 2 of the License, or (at your
+option) any later version.
 
-@* Color Stack and Matrix Transformation Support.
+LuaTeX is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+License for more details.
 
-@ In the following array and especially stack data structures are used.
+You should have received a copy of the GNU General Public License along
+with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
 
-They have the following properties:
+*/
+
+#include "ptexlib.h"
 
-\item{-} They automatically grow dynamically.
-\item{-} The size never decreases.
-\item{-} The variable with name ending in "size" contains the number how many
-    entries the data structure can hold.
-\item{-} The variable with name ending in "used" contains the number of
-    actually used entries.
-\item{-} Memory of strings in stack entries must be allocated and
-    freed if the stack is cleared.
+/*tex
+
+    This module implements color stack support. The following array and
+    especially stack data structures are used.
+
+    \startitemize
+        \startitem
+            They automatically grow dynamically.
+        \stopitem
+        \startitem
+            The size never decreases.
+        \stopitem
+        \startitem
+            The variable with name ending in "size" contains the number how many
+            entries the data structure can hold.
+        \stopitem
+        \startitem
+            The variable with name ending in "used" contains the number of
+            actually used entries.
+        \stopitem
+        \startitem
+            Memory of strings in stack entries must be allocated and freed if the
+            stack is cleared.
+        \stopitem
+    \stopitemize
 
-@ Color Stack
-@c
+*/
 
 #define MAX_COLORSTACKS 32768
 
@@ -66,10 +76,13 @@ static colstack_type *colstacks = NULL;
 static int colstacks_size = 0;
 static int colstacks_used = 0;
 
-@ Initialization is done, if the color stacks are used, |init_colorstacks()| is defined
-as macro to avoid unnecessary procedure calls.
+/*tex
+
+    Initialization is done, if the color stacks are used, |init_colorstacks()| is
+    defined as macro to avoid unnecessary procedure calls.
+
+*/
 
-@c
 #define init_colorstacks() if (colstacks_size == 0) colstacks_first_init();
 
 static void colstacks_first_init(void)
@@ -90,38 +103,40 @@ static void colstacks_first_init(void)
     colstacks[0].page_start = true;
 }
 
-@ @c
 int colorstackused(void)
 {
     init_colorstacks();
     return colstacks_used;
 }
 
-@   A new color stack is setup with the given parameters. The stack number is returned
-or -1 in case of error (no room).
+/*tex
+
+    A new color stack is setup with the given parameters. The stack number is
+    returned or -1 in case of error (no room).
+
+*/
 
-@c
 int newcolorstack(const char *str, int literal_mode, boolean page_start)
 {
     colstack_type *colstack;
     int colstack_num;
     init_colorstacks();
-    /* make room */
+    /*tex Make room: */
     if (colstacks_used == MAX_COLORSTACKS) {
         return -1;
     }
     if (colstacks_used == colstacks_size) {
         colstacks_size += STACK_INCREMENT;
-        /*
+        /*tex
             If |(MAX_COLORSTACKS mod STACK_INCREMENT = 0)| then we don't
             need to check the case that size overruns |MAX_COLORSTACKS|.
         */
         colstacks = xreallocarray(colstacks, colstack_type, (unsigned) colstacks_size);
     }
-    /* claim new color stack */
+    /*tex Claim new color stack. */
     colstack_num = colstacks_used++;
     colstack = &colstacks[colstack_num];
-    /* configure the new color stack */
+    /*tex Configure the new color stack. */
     colstack->page_stack = NULL;
     colstack->form_stack = NULL;
     colstack->page_size = 0;
@@ -141,12 +156,11 @@ int newcolorstack(const char *str, int literal_mode, boolean page_start)
     return colstack_num;
 }
 
-@ @c
 #define get_colstack(n) (&colstacks[n])
 
-@ Puts a string on top of the string pool and updates |pool_ptr|.
+/*tex Put a string on top of the string pool and updates |pool_ptr|. */
 
-@c static void put_cstring_on_str_pool(char *str)
+static void put_cstring_on_str_pool(char *str)
 {
     int save_selector = selector;
     selector = new_string;
@@ -157,7 +171,6 @@ int newcolorstack(const char *str, int literal_mode, boolean page_start)
     selector = save_selector;
 }
 
-@ @c
 static int colorstackset(int colstack_no, str_number s)
 {
     colstack_type *colstack = get_colstack(colstack_no);
@@ -172,7 +185,6 @@ static int colorstackset(int colstack_no, str_number s)
     return colstack->literal_mode;
 }
 
-@ @c
 int colorstackcurrent(int colstack_no)
 {
     colstack_type *colstack = get_colstack(colstack_no);
@@ -185,7 +197,6 @@ int colorstackcurrent(int colstack_no)
     return colstack->literal_mode;
 }
 
-@ @c
 static int colorstackpush(int colstack_no, str_number s)
 {
     colstack_type *colstack = get_colstack(colstack_no);
@@ -220,7 +231,6 @@ static int colorstackpush(int colstack_no, str_number s)
     return colstack->literal_mode;
 }
 
-@ @c
 int colorstackpop(int colstack_no)
 {
     colstack_type *colstack = get_colstack(colstack_no);
@@ -244,16 +254,13 @@ int colorstackpop(int colstack_no)
     return colstack->literal_mode;
 }
 
-@ @c
 void colorstackpagestart(void)
 {
     int i, j;
     colstack_type *colstack;
     if (global_shipping_mode == SHIPPING_PAGE) {
-        /* see procedure |pdf_out_colorstack_startpage| */
         return;
     }
-
     for (i = 0; i < colstacks_used; i++) {
         colstack = &colstacks[i];
         for (j = 0; j < colstack->form_used; j++) {
@@ -269,7 +276,6 @@ void colorstackpagestart(void)
     }
 }
 
-@ @c
 int colorstackskippagestart(int colstack_no)
 {
     colstack_type *colstack = get_colstack(colstack_no);
@@ -285,8 +291,6 @@ int colorstackskippagestart(int colstack_no)
     return 0;
 }
 
-
-@ @c
 void pdf_out_colorstack(PDF pdf, halfword p)
 {
     int old_setting;
@@ -295,11 +299,7 @@ void pdf_out_colorstack(PDF pdf, halfword p)
     int stack_no = pdf_colorstack_stack(p);
     int literal_mode = 0;
     if (stack_no >= colorstackused()) {
-        tprint_nl("");
-        tprint("Color stack ");
-        print_int(stack_no);
-        tprint(" is not initialized for use!");
-        tprint_nl("");
+        formatted_warning("pdf backend","color stack %u is not initialized",(unsigned int) stack_no);
         return;
     }
     switch (cmd) {
@@ -335,7 +335,6 @@ void pdf_out_colorstack(PDF pdf, halfword p)
     }
 }
 
-@ @c
 void pdf_out_colorstack_startpage(PDF pdf)
 {
     int start_status;
diff --git a/texk/web2c/luatexdir/pdf/pdfdest.w b/texk/web2c/luatexdir/pdf/pdfdest.c
similarity index 83%
rename from texk/web2c/luatexdir/pdf/pdfdest.w
rename to texk/web2c/luatexdir/pdf/pdfdest.c
index 74e8e4b1f..346cd26e0 100644
--- a/texk/web2c/luatexdir/pdf/pdfdest.w
+++ b/texk/web2c/luatexdir/pdf/pdfdest.c
@@ -1,37 +1,40 @@
-% pdfdest.w
-%
-% Copyright 2009-2011 Taco Hoekwater <taco@@luatex.org>
-%
-% This file is part of LuaTeX.
-%
-% LuaTeX is free software; you can redistribute it and/or modify it under
-% the terms of the GNU General Public License as published by the Free
-% Software Foundation; either version 2 of the License, or (at your
-% option) any later version.
-%
-% LuaTeX is distributed in the hope that it will be useful, but WITHOUT
-% ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-% FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
-% License for more details.
-%
-% You should have received a copy of the GNU General Public License along
-% with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+/*
 
-@ @c
+Copyright 2009-2011 Taco Hoekwater <taco@luatex.org>
+
+This file is part of LuaTeX.
+
+LuaTeX is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 2 of the License, or (at your
+option) any later version.
+
+LuaTeX is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+License for more details.
+
+You should have received a copy of the GNU General Public License along
+with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+
+*/
 
 #include "ptexlib.h"
 
-@ Here we implement subroutines for work with objects and related things. Some of
-them are used in former parts too, so we need to declare them forward.
+/*tex
+
+    Here we implement subroutines for work with objects and related things. Some
+    of them are used in former parts too, so we need to declare them forward.
+    Memory will grow dynamically.
+
+*/
 
-@c
 void init_dest_names(PDF pdf)
 {
     pdf->dest_names_size = inf_dest_names_size;
-    pdf->dest_names = xmallocarray(dest_name_entry, inf_dest_names_size); /* will grow dynamically */
+    pdf->dest_names = xmallocarray(dest_name_entry, inf_dest_names_size);
 }
 
-@ @c
 void append_dest_name(PDF pdf, char *s, int n)
 {
     int a;
@@ -50,10 +53,13 @@ void append_dest_name(PDF pdf, char *s, int n)
     pdf->dest_names_ptr++;
 }
 
-@ When a destination is created we need to check whether another destination
-with the same identifier already exists and give a warning if needed.
+/*tex
+
+    When a destination is created we need to check whether another destination
+    with the same identifier already exists and give a warning if needed.
+
+*/
 
-@c
 static void warn_dest_dup(int id, small_number byname)
 {
     if (byname > 0) {
@@ -62,10 +68,8 @@ static void warn_dest_dup(int id, small_number byname)
     } else {
         formatted_warning("pdf backend", "ignoring duplicate destination with the num '%d'",id);
     }
-    /* no longer the annoying context */
 }
 
-@ @c
 void do_dest(PDF pdf, halfword p, halfword parent_box, scaledpos cur)
 {
     scaledpos pos = pdf->posstruct->pos;
@@ -85,7 +89,10 @@ void do_dest(PDF pdf, halfword p, halfword parent_box, scaledpos cur)
     alt_rule.wd = width(p);
     alt_rule.ht = height(p);
     alt_rule.dp = depth(p);
-    /* the different branches for matrixused is somewhat strange and should always be used  */
+    /*tex
+        The different branches for matrixused is somewhat strange and should
+        always be used
+    */
     switch (pdf_dest_type(p)) {
     case pdf_dest_xyz:
         if (matrixused())
@@ -117,7 +124,6 @@ void do_dest(PDF pdf, halfword p, halfword parent_box, scaledpos cur)
     }
 }
 
-@ @c
 void write_out_pdf_mark_destinations(PDF pdf)
 {
     pdf_object_list *k;
@@ -143,12 +149,11 @@ void write_out_pdf_mark_destinations(PDF pdf)
                         if (pdf_dest_xyz_zoom(i) == null) {
                             pdf_add_null(pdf);
                         } else {
-                            if (pdf->cave == 1)
-                                pdf_out(pdf, ' ');
+                            pdf_check_space(pdf);
                             pdf_print_int(pdf, pdf_dest_xyz_zoom(i) / 1000);
                             pdf_out(pdf, '.');
                             pdf_print_int(pdf, (pdf_dest_xyz_zoom(i) % 1000));
-                            pdf->cave = 1;
+                            pdf_set_space(pdf);
                         }
                         break;
                     case pdf_dest_fit:
@@ -191,7 +196,6 @@ void write_out_pdf_mark_destinations(PDF pdf)
     }
 }
 
-@ @c
 void scan_pdfdest(PDF pdf)
 {
     halfword q;
@@ -242,13 +246,12 @@ void scan_pdfdest(PDF pdf)
     } else {
         normal_error("pdf backend", "destination type missing");
     }
-    /* Scan an optional space */
+    /*tex Scan an optional space. */
     get_x_token();
     if (cur_cmd != spacer_cmd)
         back_input();
-
     if (pdf_dest_type(cur_list.tail_field) == pdf_dest_fitr) {
-        alt_rule = scan_alt_rule();     /* scans |<rule spec>| to |alt_rule| */
+        alt_rule = scan_alt_rule();
         set_width(cur_list.tail_field, alt_rule.wd);
         set_height(cur_list.tail_field, alt_rule.ht);
         set_depth(cur_list.tail_field, alt_rule.dp);
@@ -268,8 +271,8 @@ void scan_pdfdest(PDF pdf)
     }
 }
 
-@ sorts |dest_names| by names
-@c
+/*tex Sort |dest_names| by names: */
+
 static int dest_cmp(const void *a, const void *b)
 {
     dest_name_entry aa = *(const dest_name_entry *) a;
@@ -277,24 +280,30 @@ static int dest_cmp(const void *a, const void *b)
     return strcmp(aa.objname, bb.objname);
 }
 
-@ @c
 void sort_dest_names(PDF pdf)
 {
     qsort(pdf->dest_names, (size_t) pdf->dest_names_ptr, sizeof(dest_name_entry), dest_cmp);
 }
 
-@ Output the name tree. The tree nature of the destination list forces the
-storing of intermediate data in |obj_info| and |obj_aux| fields, which
-is further uglified by the fact that |obj_tab| entries do not accept char
-pointers.
+/*tex
+
+    Output the name tree. The tree nature of the destination list forces the
+    storing of intermediate data in |obj_info| and |obj_aux| fields, which is
+    further uglified by the fact that |obj_tab| entries do not accept char
+    pointers.
+
+*/
 
-@c
 int output_name_tree(PDF pdf)
 {
-    boolean is_names = true;    /* flag for name tree output: is it Names or Kids? */
-    int k = 0;                  /* index of current child of |l|; if |k < pdf_dest_names_ptr|
-                                   then this is pointer to |dest_names| array;
-                                   otherwise it is the pointer to |obj_tab| (object number) */
+    /*tex A flag for name tree output: is it |/Names| or |/Kids|: */
+    boolean is_names = true;
+    /*tex
+        The index of current child of |l|; if |k < pdf_dest_names_ptr| then this
+        is pointer to |dest_names| array; otherwise it is the pointer to
+        |obj_tab| (object number).
+    */
+    int k = 0;
     int b = 0;
     int m, j, l;
     int dests = 0;
@@ -306,9 +315,12 @@ int output_name_tree(PDF pdf)
     sort_dest_names(pdf);
     while (true) {
         do {
-            l = pdf_create_obj(pdf, obj_type_others, 0);        /* create a new node */
-            if (b == 0)
-                b = l;          /* first in this level */
+            /*tex Create a new node: */
+            l = pdf_create_obj(pdf, obj_type_others, 0);
+            if (b == 0) {
+                /*tex First in this level: */
+                b = l;
+            }
             if (names_head == 0) {
                 names_head = l;
                 names_tail = l;
@@ -317,7 +329,7 @@ int output_name_tree(PDF pdf)
                 names_tail = l;
             }
             set_obj_link(pdf, names_tail, 0);
-            /* Output the current node in this level */
+            /*tex Output the current node in this level. */
             pdf_begin_obj(pdf, l, OBJSTM_ALWAYS);
             pdf_begin_dict(pdf);
             j = 0;
@@ -332,13 +344,13 @@ int output_name_tree(PDF pdf)
                     k++;
                 } while (j != name_tree_kids_max && k != pdf->dest_names_ptr);
                 pdf_end_array(pdf);
-                set_obj_stop(pdf, l, pdf->dest_names[k - 1].objname);   /* for later */
+                /*tex For later use: */
+                set_obj_stop(pdf, l, pdf->dest_names[k - 1].objname);
                 if (k == pdf->dest_names_ptr) {
                     is_names = false;
                     k = names_head;
                     b = 0;
                 }
-
             } else {
                 set_obj_start(pdf, l, obj_start(pdf, k));
                 pdf_add_name(pdf, "Kids");
@@ -362,7 +374,6 @@ int output_name_tree(PDF pdf)
             pdf_end_dict(pdf);
             pdf_end_obj(pdf);
         } while (b != 0);
-
         if (k == l) {
             dests = l;
             goto DONE;
diff --git a/texk/web2c/luatexdir/pdf/pdffont.w b/texk/web2c/luatexdir/pdf/pdffont.c
similarity index 51%
rename from texk/web2c/luatexdir/pdf/pdffont.w
rename to texk/web2c/luatexdir/pdf/pdffont.c
index 278efa9d6..1e1f0f8d9 100644
--- a/texk/web2c/luatexdir/pdf/pdffont.w
+++ b/texk/web2c/luatexdir/pdf/pdffont.c
@@ -1,48 +1,50 @@
-% pdffont.w
-%
-% Copyright 2009-2014 Taco Hoekwater <taco@@luatex.org>
-%
-% This file is part of LuaTeX.
-%
-% LuaTeX is free software; you can redistribute it and/or modify it under
-% the terms of the GNU General Public License as published by the Free
-% Software Foundation; either version 2 of the License, or (at your
-% option) any later version.
-%
-% LuaTeX is distributed in the hope that it will be useful, but WITHOUT
-% ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-% FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
-% License for more details.
-%
-% You should have received a copy of the GNU General Public License along
-% with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
-
-\def\pdfTeX{pdf\TeX}
-
-@ @c
+/*
+
+Copyright 2009-2014 Taco Hoekwater <taco@luatex.org>
+
+This file is part of LuaTeX.
+
+LuaTeX is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 2 of the License, or (at your
+option) any later version.
+
+LuaTeX is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+License for more details.
+
+You should have received a copy of the GNU General Public License along
+with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+
+*/
 
 #include "ptexlib.h"
 
-@ As \pdfTeX{} should also act as a back-end driver, it needs to support virtual
-fonts too. Information about virtual fonts can be found in the source of some
-\.{DVI}-related programs.
+/*tex
 
-Whenever we want to write out a character in a font to PDF output, we
-should check whether the used character is a virtual or real character.
-The |has_packet()| C macro checks for this condition.
+    As \LUATEX\ should also act as a back-end driver, it needs to support virtual
+    fonts too. Information about virtual fonts can be found in the source of some
+    \DVI-related programs.
 
-@ The following code typesets a character to PDF output
+    Whenever we want to write out a character in a font to \PDF\ output, we
+    should check whether the used character is a virtual or real character. The
+    |has_packet| C macro checks for this condition.
+
+    The following code typesets a character to \PDF\ output
+
+*/
 
-@c
 scaled_whd output_one_char(PDF pdf, halfword p)
 {
     internal_font_number f = font(p);
     int c = character(p);
     int ex_glyph = ex_glyph(p)/1000;
-    scaled_whd ci = get_charinfo_whd(f, c); /* the real width, height and depth of the character */
+    /*tex The real width, height and depth of the character: */
+    scaled_whd ci = get_charinfo_whd(f, c);
     if (!(char_exists(f,c))) {
         lua_glyph_not_found_callback(f,c);
-        /* char_warning(f,c); */
+        /*tex Not here |char_warning(f,c);| */
         return ci;
     }
     ci.wd = ext_xn_over_d(ci.wd, 1000000 + ex_glyph(p), 1000000);
@@ -66,14 +68,18 @@ scaled_whd output_one_char(PDF pdf, halfword p)
     if (has_packet(f, c)) {
         do_vf_packet(pdf, f, c, ex_glyph);
     } else {
-        /* |pdf_place_glyph(pdf, f, c, ex_glyph);| */
         backend_out[glyph_node] (pdf, f, c, ex_glyph);
     }
     return ci;
 }
 
-@ Mark |f| as a used font; set |font_used(f)|, |font_size(f)| and |pdf_font_num(f)|
-@c
+/*tex
+
+    Mark |f| as a used font; set |font_used(f)|, |font_size(f)| and
+    |pdf_font_num(f)|.
+
+*/
+
 static void pdf_use_font(internal_font_number f, int fontnum)
 {
     set_font_used(f, true);
@@ -84,19 +90,24 @@ static void pdf_use_font(internal_font_number f, int fontnum)
     }
 }
 
-@ To set PDF font we need to find out fonts with the same name, because \TeX\ can
-load the same font several times for various sizes. For such fonts we define only
-one font resource. The array |pdf_font_num| holds the object number of font
-resource. A negative value of an entry of |pdf_font_num| indicates that the
-corresponding font shares the font resource with the font
+/*tex
+
+    To set PDF font we need to find out fonts with the same name, because \TeX\
+    can load the same font several times for various sizes. For such fonts we
+    define only one font resource. The array |pdf_font_num| holds the object
+    number of font resource. A negative value of an entry of |pdf_font_num|
+    indicates that the corresponding font shares the font resource with the font.
+
+*/
 
-@c
 #define same(n,f,k) (n(f) != NULL && n(k) != NULL && strcmp(n(f), n(k)) == 0)
 
-/*
-    For some lua-loaded (for instance AFM) fonts, it is normal to have
-    a zero cidregistry,  and such fonts do not have a fontmap entry yet
-    at this point, so the test should use the other branch
+/*tex
+
+    For some \LUA-loaded (for instance \AFM) fonts, it is normal to have a zero
+    cidregistry, and such fonts do not have a fontmap entry yet at this point, so
+    the test should use the other branch.
+
 */
 
 static boolean font_shareable(internal_font_number f, internal_font_number k)
@@ -111,8 +122,21 @@ static boolean font_shareable(internal_font_number f, internal_font_number k)
     return 0;
 }
 
-@ create a font object
-@c
+/*tex
+
+    We will create a font object. We check whether |f| can share the font object
+    with some |k|: we have 2 cases here: |f| and |k| have the same tfm name, so
+    they have been loaded at different sizes, eg 'cmr10' and 'cmr10 at 11pt'.
+
+    We optionally take over slant and extend from map entry, if not already set;
+    this should also be the only place where getfontmap() may be called.
+
+    Beware, \LUATEX\ is different from \PDFTEX\ in dealing with expanded and
+    slanted fonts and expansion and protrusion as it will use the same font but a
+    different transformation which is way more efficient and also cleaner.
+
+*/
+
 void pdf_init_font(PDF pdf, internal_font_number f)
 {
     internal_font_number k;
@@ -121,15 +145,6 @@ void pdf_init_font(PDF pdf, internal_font_number f)
     if (font_used(f)) {
         formatted_error("pdf backend","font %i gets initialized twice",(int) f);
     }
-    /*
-        check whether |f| can share the font object with some |k|: we have 2 cases
-        here: 1) |f| and |k| have the same tfm name (so they have been loaded at
-        different sizes, eg 'cmr10' and 'cmr10 at 11pt'); 2) |f| has been auto
-        expanded from |k|
-
-        take over slant and extend from map entry, if not already set;
-        this should also be the only place where getfontmap() may be called.
-    */
     fm = getfontmap(font_name(f));
     if (font_map(f) == NULL && fm != NULL) {
         font_map(f) = fm;
@@ -150,38 +165,42 @@ void pdf_init_font(PDF pdf, internal_font_number f)
         }
         i = obj_link(pdf, i);
     }
-    /* create a new font object for |f| */
+    /*tex Create a new font object for |f|: */
     l = pdf_create_obj(pdf, obj_type_font, f);
     pdf_use_font(f, l);
 }
 
-@ set the actual font on PDF page; sets |ff| to the tfm number of the base font
-sharing the font object with |f|; |ff| is either |f| itself (then it is its own
-base font), or some font with the same tfm name at different size and/or
-expansion.
+/*tex
+
+    Set the actual font on PDF page; sets |ff| to the tfm number of the base font
+    sharing the font object with |f|; |ff| is either |f| itself (then it is its
+    own base font), or some font with the same tfm name at different size and/or
+    expansion.
+
+*/
 
-@c
 internal_font_number pdf_set_font(PDF pdf, internal_font_number f)
 {
-    int ff; /* for use with |set_ff| */
+    /*tex For use with |set_ff|: */
+    int ff;
     if (!font_used(f))
         pdf_init_font(pdf, f);
-    ff = pdf_font_num(f) < 0 ? -pdf_font_num(f) : f; /* aka |set_ff(f)| */
+    /*tex Also known as |set_ff(f)|: */
+    ff = pdf_font_num(f) < 0 ? -pdf_font_num(f) : f;
     addto_page_resources(pdf, obj_type_font, pdf_font_num(ff));
     return ff;
 }
 
-@ @c
 void pdf_include_chars(PDF pdf)
 {
     str_number s;
-    unsigned char *k, *j; /* running index */
+    unsigned char *k, *j;
     internal_font_number f;
     scan_font_ident();
     f = cur_val;
     if (f == null_font)
         normal_error("pdf backend", "invalid font identifier for 'includechars'");
-    pdf_check_vf(cur_val);
+ /* pdf_check_vf(c); */
     if (!font_used(f))
         pdf_init_font(pdf, f);
     scan_toks(false, true);
diff --git a/texk/web2c/luatexdir/pdf/pdfgen.w b/texk/web2c/luatexdir/pdf/pdfgen.c
similarity index 61%
rename from texk/web2c/luatexdir/pdf/pdfgen.w
rename to texk/web2c/luatexdir/pdf/pdfgen.c
index 26b7112ed..0409dbc33 100644
--- a/texk/web2c/luatexdir/pdf/pdfgen.w
+++ b/texk/web2c/luatexdir/pdf/pdfgen.c
@@ -1,26 +1,26 @@
-% pdfgen.w
-%
-% Copyright 2009-2013 Taco Hoekwater <taco@@luatex.org>
-%
-% This file is part of LuaTeX.
-%
-% LuaTeX is free software; you can redistribute it and/or modify it under
-% the terms of the GNU General Public License as published by the Free
-% Software Foundation; either version 2 of the License, or (at your
-% option) any later version.
-%
-% LuaTeX is distributed in the hope that it will be useful, but WITHOUT
-% ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-% FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
-% License for more details.
-%
-% You should have received a copy of the GNU General Public License along
-% with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
-
-@ @c
+/*
+
+Copyright 2009-2013 Taco Hoekwater <taco@luatex.org>
+
+This file is part of LuaTeX.
+
+LuaTeX is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 2 of the License, or (at your
+option) any later version.
+
+LuaTeX is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+License for more details.
+
+You should have received a copy of the GNU General Public License along
+with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+
+*/
+
 #include "ptexlib.h"
 
-@ @c
 #include <kpathsea/c-dir.h>
 #include <kpathsea/c-ctype.h>
 #include "lua/luatex-api.h"
@@ -32,43 +32,60 @@
 
 PDF static_pdf = NULL;
 
-@ commandline interface
+/*tex The commandline interface: */
 
-@c
 int output_mode_used;
 int output_mode_option;
 int output_mode_value;
 int draft_mode_option;
 int draft_mode_value;
 
-halfword pdf_info_toks;                              /* additional keys of Info dictionary */
-halfword pdf_catalog_toks;                           /* additional keys of Catalog dictionary */
+/*tex Additional keys of the |/Info| dictionary: */
+
+halfword pdf_info_toks;
+
+/*tex Additional keys of the |/Catalog| and its |/OpenAction| dictionary: */
+
+halfword pdf_catalog_toks;
+
 halfword pdf_catalog_openaction;
-halfword pdf_names_toks;                             /* additional keys of Names dictionary */
-halfword pdf_trailer_toks;                           /* additional keys of Trailer dictionary */
-shipping_mode_e global_shipping_mode = NOT_SHIPPING; /* set to |shipping_mode| when |ship_out| starts */
 
+/*tex Additional keys of the |/Names| dictionary: */
+
+halfword pdf_names_toks;
+
+/*tex Additional keys of the |/Trailer| dictionary" */
+
+halfword pdf_trailer_toks;
+
+/*tex Set to |shipping_mode| when |ship_out| starts */
+
+shipping_mode_e global_shipping_mode = NOT_SHIPPING;
+
+/*tex
+
+    Create a new buffer |strbuf_s| of size |size| and maximum allowed size
+    |limit|. Initialize it and set |p| to begin of data.
 
-@ Create a new buffer |strbuf_s| of size |size| and maximum allowed size |limit|.
-Initialize it and set |p| to begin of data.
+*/
 
-@c
 strbuf_s *new_strbuf(size_t size, size_t limit)
 {
     strbuf_s *b;
     b = xtalloc(1, strbuf_s);
     b->size = size;
     b->limit = limit;
-    if (size > 0)
+    if (size > 0) {
         b->p = b->data = xtalloc(b->size, unsigned char);
-    else
-        b->p = b->data = NULL; /* for other alloc */
+    } else {
+        /*tex For other alloc: */
+        b->p = b->data = NULL;
+    }
     return b;
 }
 
-@ Check that |n| bytes more fit into buffer; increase it if required.
+/*tex Check that |n| bytes more fit into buffer; increase it if required. */
 
-@c
 static void strbuf_room(strbuf_s * b, size_t n)
 {
     unsigned int a;
@@ -88,25 +105,22 @@ static void strbuf_room(strbuf_s * b, size_t n)
     }
 }
 
-@ Seek to position |offset| within buffer. Position must be valid.
+/*tex Seek to position |offset| within buffer. Position must be valid. */
 
-@c
 void strbuf_seek(strbuf_s * b, off_t offset)
 {
     b->p = b->data + offset;
 }
 
-@ Get the current buffer fill level, the number of characters.
+/*tex Get the current buffer fill level, the number of characters.*/
 
-@c
 size_t strbuf_offset(strbuf_s * b)
 {
     return (size_t) (b->p - b->data);
 }
 
-@ Put one character into buffer. Make room before if needed.
+/*tex Put one character into buffer. Make room before if needed. */
 
-@c
 void strbuf_putchar(strbuf_s * b, unsigned char c)
 {
     if ((size_t) (b->p - b->data + 1) > b->size)
@@ -114,81 +128,71 @@ void strbuf_putchar(strbuf_s * b, unsigned char c)
     *b->p++ = c;
 }
 
-@ Dump filled buffer part to PDF.
+/*tex Dump filled buffer part to the \PDF\ file. */
 
-@c
 void strbuf_flush(PDF pdf, strbuf_s * b)
 {
     pdf_out_block(pdf, (const char *) b->data, strbuf_offset(b));
     strbuf_seek(b, 0);
 }
 
-@ Free all dynamically allocated buffer structures.
+/*tex We free all dynamically allocated buffer structures. */
 
-@c
 void strbuf_free(strbuf_s * b)
 {
     xfree(b->data);
     xfree(b);
 }
 
-@ |init_pdf_struct()| is called early, only once, from maincontrol.w
+/*tex This |init_pdf_struct| is called early and only once. */
 
-@c
 PDF init_pdf_struct(PDF pdf)
 {
     os_struct *os;
     pdf = xtalloc(1, pdf_output_file);
     memset(pdf, 0, sizeof(pdf_output_file));
     pdf->job_name = makecstring(job_name);
-
-    output_mode_used = OMODE_NONE;  /* will be set by |fix_o_mode()| */
-    pdf->o_mode = output_mode_used; /* used by synctex, we need to use output_mode_used there */
+    /*tex This will be set by |fix_o_mode|: */
+    output_mode_used = OMODE_NONE;
+    /*tex Used by synctex, we need to use output_mode_used there. */
+    pdf->o_mode = output_mode_used;
     pdf->o_state = ST_INITIAL;
-
-    /* init PDF and object stream writing */
+    /*tex Initialize \PDF\ and object stream writing */
     pdf->os = os = xtalloc(1, os_struct);
     memset(pdf->os, 0, sizeof(os_struct));
     os->buf[PDFOUT_BUF] = new_strbuf(inf_pdfout_buf_size, sup_pdfout_buf_size);
     os->buf[OBJSTM_BUF] = new_strbuf(inf_objstm_buf_size, sup_objstm_buf_size);
     os->obj = xtalloc(PDF_OS_MAX_OBJS, os_obj_data);
     os->cur_objstm = 0;
-
     os->curbuf = PDFOUT_BUF;
     pdf->buf = os->buf[os->curbuf];
-    /*
-        Later  ttf_seek_outbuf(TABDIR_OFF + n * 4 * TTF_ULONG_SIZE); in ttf_init_font
-        we need 236 bytes, so we start with 256 bytes as in pdftex.
+    /*tex
+        Later ttf_seek_outbuf(TABDIR_OFF + n * 4 * TTF_ULONG_SIZE); in
+        ttf_init_font we need 236 bytes, so we start with 256 bytes as in \PDFTEX.
     */
     pdf->fb = new_strbuf(256, 100000000);
-
     pdf->stream_deflate = false;
     pdf->stream_writing = false;
-
-    /*
+    /*tex
         Sometimes it is neccesary to allocate memory for PDF output that cannot be
         deallocated then, so we use |mem| for this purpose.
     */
     pdf->mem_size = inf_pdf_mem_size;
     pdf->mem = xtalloc(pdf->mem_size, int);
-    /*
+    /*tex
         The first word is not used so we can use zero as a value for testing
         whether a pointer to |mem| is valid.
     */
     pdf->mem_ptr = 1;
-
     pdf->pstruct = NULL;
-
     pdf->posstruct = xtalloc(1, posstructure);
     pdf->posstruct->pos.h = 0;
     pdf->posstruct->pos.v = 0;
     pdf->posstruct->dir = dir_TLT;
-
-    /* allocated size of |obj_tab| array */
+    /*tex Allocated size of |obj_tab| array> */
     pdf->obj_tab_size = (unsigned) inf_obj_tab_size;
     pdf->obj_tab = xtalloc(pdf->obj_tab_size + 1, obj_entry);
     memset(pdf->obj_tab, 0, sizeof(obj_entry));
-
     pdf->minor_version = -1;
     pdf->major_version = -1;
     pdf->decimal_digits = 4;
@@ -198,25 +202,22 @@ PDF init_pdf_struct(PDF pdf)
     pdf->image_apply_gamma = 0;
     pdf->objcompresslevel = 0;
     pdf->compress_level = 0;
+    pdf->force_file = 0;
+    pdf->recompress = 0;
     pdf->draftmode = 0;
     pdf->inclusion_copy_font = 1;
     pdf->pk_resolution = 0;
     pdf->pk_fixed_dpi = 0;
     pdf->pk_scale_factor = 0;
-
     init_dest_names(pdf);
     pdf->page_resources = NULL;
-
     init_pdf_pagecalculations(pdf);
-
     pdf->vfstruct = new_vfstruct();
-
     return pdf;
 }
 
-@  We use |pdf_get_mem| to allocate memory in |mem|.
+/*tex We use |pdf_get_mem| to allocate memory in |mem|. */
 
-@c
 int pdf_get_mem(PDF pdf, int s)
 {
     int a;
@@ -239,39 +240,19 @@ int pdf_get_mem(PDF pdf, int s)
     return ret;
 }
 
-@ there are defined in |luatex-api.h|, so we need |luatex-api.c|:
-
-@c
-output_mode get_o_mode(void)
-{
-    output_mode o_mode;
-    if (output_mode_par > 0) {
-        o_mode = OMODE_PDF;
-    } else
-        o_mode = OMODE_DVI;
-    return o_mode;
-}
+/*tex
 
-void fix_o_mode(void)
-{
-    output_mode o_mode = get_o_mode();
-    if (output_mode_used == OMODE_NONE) {
-        output_mode_used = o_mode;
-        static_pdf->o_mode = output_mode_used; /* used by synctex, we need to use output_mode_used there */
-    } else if (output_mode_used != o_mode) {
-        normal_error("pdf backend", "\\outputmode can only be changed before anything is written to the output");
-    }
-}
+    This ensures that |pdfmajorversion| and |pdfminorversion| are set only before
+    any bytes have been written to the generated \PDF\ file. Here also all
+    variables for \PDF\ output are initialized, the \PDF\ file is opened by
+    |ensure_pdf_open|, and the \PDF\ header is written.
 
-@ This ensures that |pdfmajorversion| and |pdfminorversion| are set only before any
-bytes have been written to the generated \.{PDF} file. Here also all variables for
-\.{PDF} output are initialized, the \.{PDF} file is opened by |ensure_pdf_open|, and
-the \.{PDF} header is written.
+*/
 
-@c
 void fix_pdf_version(PDF pdf)
 {
-    if (pdf->major_version < 0) { /* unset */
+    if (pdf->major_version < 0) {
+        /*tex It is unset. */
         if (pdf_major_version == 0) {
             normal_warning("pdf backend","unset major version, using 1 instead");
             pdf->major_version = 1;
@@ -284,7 +265,8 @@ void fix_pdf_version(PDF pdf)
     } else if (pdf->major_version != pdf_major_version) {
         normal_warning("pdf backend", "the major version cannot be changed after data is written to the PDF file");
     }
-    if (pdf->minor_version < 0) { /* unset */
+    if (pdf->minor_version < 0) {
+        /*tex It is unset. */
         if ((pdf_minor_version < 0) || (pdf_minor_version > 9)) {
             formatted_warning("pdf backend","illegal minor version %d, using 4 instead",pdf_minor_version);
             pdf->minor_version = 4;
@@ -301,19 +283,18 @@ static void fix_pdf_draftmode(PDF pdf)
     if (pdf->draftmode != draft_mode_par)
         normal_warning("pdf backend", "draftmode cannot be changed after data is written to the PDF file");
     if (pdf->draftmode != 0) {
-        pdf->compress_level = 0;        /* re-fix it, might have been changed inbetween */
+        /*tex Fix these as they might have been changed in between. */
+        pdf->compress_level = 0;
         pdf->objcompresslevel = 0;
     }
 }
 
-@ @c
 #define ZIP_BUF_SIZE  32768
 
 #define check_err(f, fn) \
     if (f != Z_OK) \
         formatted_error("pdf backend","zlib %s() failed (error code %d)", fn, f)
 
-@ @c
 static void write_zip(PDF pdf)
 {
     int flush, err = Z_OK;
@@ -363,7 +344,6 @@ static void write_zip(PDF pdf)
     pdf->stream_length = (off_t) s->total_out;
 }
 
-@ @c
 void zip_free(PDF pdf)
 {
     if (pdf->zipbuf != NULL) {
@@ -373,7 +353,6 @@ void zip_free(PDF pdf)
     xfree(pdf->c_stream);
 }
 
-@ @c
 static void write_nozip(PDF pdf)
 {
     strbuf_s *buf = pdf->buf;
@@ -385,12 +364,15 @@ static void write_nozip(PDF pdf)
     pdf->last_byte = *(buf->p - 1);
 }
 
-@ The PDF buffer is flushed by calling |pdf_flush|, which checks the
-variable |zip_write_state| and will compress the buffer before flushing if
-neccesary. We call |pdf_begin_stream| to begin a stream  and |pdf_end_stream|
-to finish it. The stream contents will be compressed if compression is turn on.
+/*tex
+
+    The PDF buffer is flushed by calling |pdf_flush|, which checks the variable
+    |zip_write_state| and will compress the buffer before flushing if neccesary.
+    We call |pdf_begin_stream| to begin a stream and |pdf_end_stream| to finish
+    it. The stream contents will be compressed if compression is turn on.
+
+*/
 
-@c
 void pdf_flush(PDF pdf)
 {
     os_struct *os = pdf->os;
@@ -422,20 +404,25 @@ void pdf_flush(PDF pdf)
     }
 }
 
-@ @c
 static void pdf_buffer_select(PDF pdf, buffer_e buf)
 {
     os_struct *os = pdf->os;
-    if (pdf->os_enable && buf == OBJSTM_BUF)
-        os->curbuf = OBJSTM_BUF; /* switch to object stream */
-    else
-        os->curbuf = PDFOUT_BUF; /* switch to PDF stream */
+    if (pdf->os_enable && buf == OBJSTM_BUF) {
+        /*tex Switch to object stream: */
+        os->curbuf = OBJSTM_BUF;
+    } else {
+        /*tex Switch to \PDF\ stream: */
+        os->curbuf = PDFOUT_BUF;
+    }
     pdf->buf = os->buf[pdf->os->curbuf];
 }
 
-@ create new \.{/ObjStm} object if required, and set up cross reference info
+/*tex
+
+    We create new |/ObjStm| object if required, and set up cross reference info.
+
+*/
 
-@c
 static void pdf_prepare_obj(PDF pdf, int k, int pdf_os_threshold)
 {
     os_struct *os = pdf->os;
@@ -447,15 +434,18 @@ static void pdf_prepare_obj(PDF pdf, int k, int pdf_os_threshold)
     switch (os->curbuf) {
         case PDFOUT_BUF:
             obj_offset(pdf, k) = pdf_offset(pdf);
-            obj_os_idx(pdf, k) = PDF_OS_MAX_OBJS;   /* mark it as not included in any ObjStm */
+            /*tex Mark it as not included in any |ObjStm|. */
+            obj_os_idx(pdf, k) = PDF_OS_MAX_OBJS;
             break;
         case OBJSTM_BUF:
             if (os->cur_objstm == 0) {
                 os->cur_objstm =
                     (unsigned int) pdf_create_obj(pdf, obj_type_objstm, 0);
                 os->idx = 0;
-                obuf->p = obuf->data;       /* start fresh object stream */
-                os->ostm_ctr++;     /* only for statistics */
+                /*tex Start a fresh object stream. */
+                obuf->p = obuf->data;
+                /*tex Keep some statistics. */
+                os->ostm_ctr++;
             }
             obj_os_idx(pdf, k) = (int) os->idx;
             obj_os_objnum(pdf, k) = (int) os->cur_objstm;
@@ -467,12 +457,13 @@ static void pdf_prepare_obj(PDF pdf, int k, int pdf_os_threshold)
     }
 }
 
-@* Low-level buffer checkers.
+/*tex
+
+    We set the active buffer pointer and make sure that there are at least |n|
+    bytes free in that buffer, flushing happens if needed.
 
-@ Set the active buffer pointer. Make sure that there are at least |n| bytes free
-in that buffer, flush if needed.
+*/
 
-@c
 inline void pdf_room(PDF pdf, int n)
 {
     strbuf_s *buf = pdf->buf;
@@ -490,7 +481,6 @@ inline void pdf_room(PDF pdf, int n)
     }
 }
 
-@ @c
 void pdf_out_block(PDF pdf, const char *s, size_t n)
 {
     size_t l;
@@ -507,7 +497,6 @@ void pdf_out_block(PDF pdf, const char *s, size_t n)
     } while (n > 0);
 }
 
-@ @c
 __attribute__ ((format(printf, 2, 3)))
 void pdf_printf(PDF pdf, const char *fmt, ...)
 {
@@ -521,9 +510,6 @@ void pdf_printf(PDF pdf, const char *fmt, ...)
     va_end(args);
 }
 
-@ print out a string to PDF buffer
-
-@c
 void pdf_print(PDF pdf, str_number s)
 {
     const char *ss;
@@ -537,9 +523,6 @@ void pdf_print(PDF pdf, str_number s)
     }
 }
 
-@ print out a integer to PDF buffer
-
-@c
 void pdf_print_int(PDF pdf, longinteger n)
 {
     char s[24];
@@ -549,33 +532,6 @@ void pdf_print_int(PDF pdf, longinteger n)
     pdf_out_block(pdf, (const char *) s, (size_t) w);
 }
 
-@ @c
-/*
-void print_pdffloat(PDF pdf, pdffloat f)
-{
-    char a[24];
-    int e = f.e, i, l;
-    int64_t m = f.m;
-    if (m < 0) {
-        pdf_out(pdf, '-');
-        m *= -1;
-    }
-    l = m / ten_pow[e];
-    pdf_print_int(pdf, l);
-    l = m % ten_pow[e];
-    if (l != 0) {
-        pdf_out(pdf, '.');
-        snprintf(a, 23, "%d", l + ten_pow[e]);
-        for (i = e; i > 0; i--) {
-            if (a[i] != '0')
-                break;
-            a[i] = '\0';
-        }
-        pdf_puts(pdf, (a + 1));
-    }
-}
-*/
-
 void print_pdffloat(PDF pdf, pdffloat f)
 {
     int64_t m = f.m;
@@ -584,7 +540,7 @@ void print_pdffloat(PDF pdf, pdffloat f)
     } else {
         int e = f.e;
         if (e == 0) {
-            /* division by ten_pow[0] == 1 */
+            /*tex division by |ten_pow[0] == 1| */
             if (m == 1) {
                 pdf_out(pdf, '1');
             } else {
@@ -622,18 +578,19 @@ void print_pdffloat(PDF pdf, pdffloat f)
     }
 }
 
-@ print out |s| as string in PDF output
-
-@c
 void pdf_print_str(PDF pdf, const char *s)
 {
     const char *orig = s;
-    int l = (int) strlen(s) - 1; /* last string index */
+    /*tex This initializes at the last string index. */
+    int l = (int) strlen(s) - 1;
     if (l < 0) {
         pdf_puts(pdf, "()");
         return;
     }
-    /* the next is not really safe, the string could be "(a)xx(b)" */
+    /*tex
+        The next might not really be safe as the string could be ``(a)xx(b)'' but
+        so far we never had an issue.
+    */
     if ((s[0] == '(') && (s[l] == ')')) {
         pdf_puts(pdf, s);
         return;
@@ -653,12 +610,11 @@ void pdf_print_str(PDF pdf, const char *s)
         pdf_out(pdf, ')');
         return;
     }
-    pdf_puts(pdf, orig); /* it was a hex string after all  */
+    pdf_puts(pdf, orig);
 }
 
-@ begin a stream (needs to have a stream dictionary also)
+/*tex A stream needs to have a stream dictionary also. */
 
-@c
 void pdf_begin_stream(PDF pdf)
 {
     pdf_puts(pdf, "\nstream\n");
@@ -672,9 +628,6 @@ void pdf_begin_stream(PDF pdf)
     pdf->last_byte = 0;
 }
 
-@ end a stream
-
-@c
 void pdf_end_stream(PDF pdf)
 {
     os_struct *os = pdf->os;
@@ -682,7 +635,8 @@ void pdf_end_stream(PDF pdf)
         case PDFOUT_BUF:
             if (pdf->zip_write_state == ZIP_WRITING)
                 pdf->zip_write_state = ZIP_FINISH;
-            pdf_flush(pdf);         /* sets pdf->last_byte */
+            /*tex This sets| pdf->last_byte|. */
+            pdf_flush(pdf);
             break;
         case OBJSTM_BUF:
             normal_error("pdf backend", "bad buffer in end stream, case 1");
@@ -692,43 +646,71 @@ void pdf_end_stream(PDF pdf)
     }
     pdf->stream_deflate = false;
     pdf->stream_writing = false;
-    pdf_out(pdf, '\n');     /* doesn't really belong to the stream */
+    /*tex This doesn't really belong to the stream: */
+    pdf_out(pdf, '\n');
     pdf_puts(pdf, "endstream");
-    /* write stream /Length */
+    /*tex Write the stream |/Length|. */
+
     if (pdf->seek_write_length && pdf->draftmode == 0) {
+        xfseeko(pdf->file, (off_t)pdf->stream_length_offset+12, SEEK_SET, pdf->job_name);
+        fprintf(pdf->file, "  ");
         xfseeko(pdf->file, (off_t)pdf->stream_length_offset, SEEK_SET, pdf->job_name);
-        fprintf(pdf->file, "%" LONGINTEGER_PRI "i", (LONGINTEGER_TYPE) pdf->stream_length);
+        fprintf(pdf->file, "%" LONGINTEGER_PRI "i >>", (LONGINTEGER_TYPE) pdf->stream_length);
         xfseeko(pdf->file, 0, SEEK_END, pdf->job_name);
     }
     pdf->seek_write_length = false;
 }
 
-@ To print |scaled| value to PDF output we need some subroutines to ensure
-accurary.
+/*tex
+
+    To print |scaled| value to \PDF\ output we need some subroutines to ensure
+    accurary.
 
-@c
-#define max_integer 0x7FFFFFFF  /* $2^{31}-1$ */
+*/
 
-scaled one_hundred_inch =  7227 * 65536;             /* scaled value corresponds to 100in, exact, 473628672 */
-scaled one_inch         = (7227 * 65536 + 50) / 100; /* scaled value corresponds to 1in (rounded to 4736287) */
-scaled one_true_inch    = (7227 * 65536 + 50) / 100; /* scaled value corresponds to 1truein (rounded!) */
-scaled one_hundred_bp   = (7227 * 65536)      /  72; /* scaled value corresponds to 100bp */
-scaled one_bp           = 65781;                     /* scaled value corresponds to 1bp (rounded to 65782) */
 
-/*
-    one_bp is changed on 20110411 to be exactly 65781, as in tex itself, because this value
-    is also used for \pdfpxdimen
+/*tex We max out at $2^{31}-1$. */
+
+#define max_integer 0x7FFFFFFF
+
+/*tex scaled value corresponds to 100in, exact, 473628672 */
+
+scaled one_hundred_inch = 7227 * 65536;
+
+/*tex scaled value corresponds to 1in (rounded to 4736287) */
+
+scaled one_inch = (7227 * 65536 + 50) / 100;
+
+/*tex scaled value corresponds to 1truein (rounded!) */
+
+scaled one_true_inch = (7227 * 65536 + 50) / 100;
+
+/*tex scaled value corresponds to 100bp */
+
+scaled one_hundred_bp = (7227 * 65536)      /  72;
+
+/*tex scaled value corresponds to 1bp (rounded to 65782) */
+
+scaled one_bp = 65781;
+
+/*tex
+
+    One basepoint is set to exactly 65781, as in \TEX\ itself, because this value
+    is also used for |\pdfpxdimen|.
+
 */
 
 int ten_pow[10] = {
     1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000, 1000000000 /* $10^0..10^9$ */
 };
 
-@ The function |divide_scaled| divides |s| by |m| using |dd| decimal
-digits of precision. It is defined in C because it is a good candidate
-for optimizations that are not possible in pascal.
+/*tex
+
+    The function |divide_scaled| divides |s| by |m| using |dd| decimal digits of
+    precision.
+
+*/
 
-@c
 scaled round_xn_over_d(scaled x, int n, unsigned int d)
 {
     boolean positive = true;
@@ -757,28 +739,22 @@ scaled round_xn_over_d(scaled x, int n, unsigned int d)
         return (-(scaled) u);
 }
 
-@ @c
 void pdf_add_bp(PDF pdf, scaled s)
 {
     pdffloat a;
     pdfstructure *p = pdf->pstruct;
     a.m = i64round(s * p->k1);
     a.e = pdf->decimal_digits;
-    if (pdf->cave > 0)
-        pdf_out(pdf, ' ');
+    pdf_check_space(pdf);
     print_pdffloat(pdf, a);
-    pdf->cave = 1;
+    pdf_set_space(pdf);
 }
 
-@* handling page resources.
-
-@c
 typedef struct {
     int obj_type;
     pdf_object_list *list;
 } pr_entry;
 
-@ @c
 static int comp_page_resources(const void *pa, const void *pb, void *p)
 {
     int a = ((const pr_entry *) pa)->obj_type;
@@ -791,7 +767,6 @@ static int comp_page_resources(const void *pa, const void *pb, void *p)
     return 0;
 }
 
-@ @c
 void addto_page_resources(PDF pdf, pdf_obj_type t, int k)
 {
     pdf_resource_struct *re;
@@ -819,8 +794,10 @@ void addto_page_resources(PDF pdf, pdf_obj_type t, int k)
         item->link = NULL;
         item->info = k;
         pr->list = item;
-        if (obj_type(pdf, k) == (int)t)
-            set_obj_scheduled(pdf, k);  /* k is an object number */
+        if (obj_type(pdf, k) == (int)t) {
+            /*tex |k| is an object number. */
+            set_obj_scheduled(pdf, k);
+        }
     } else {
         for (p = pr->list; p->info != k && p->link != NULL; p = p->link);
         if (p->info != k) {
@@ -834,7 +811,6 @@ void addto_page_resources(PDF pdf, pdf_obj_type t, int k)
     }
 }
 
-@ @c
 pdf_object_list *get_page_resources_list(PDF pdf, pdf_obj_type t)
 {
     pdf_resource_struct *re = pdf->page_resources;
@@ -848,7 +824,6 @@ pdf_object_list *get_page_resources_list(PDF pdf, pdf_obj_type t)
     return pr->list;
 }
 
-@ @c
 static void reset_page_resources(PDF pdf)
 {
     pdf_resource_struct *re = pdf->page_resources;
@@ -864,19 +839,18 @@ static void reset_page_resources(PDF pdf)
                 l2 = l1->link;
                 free(l1);
             }
-            p->list = NULL;     /* but the AVL tree remains */
+            /*tex We reset but the AVL tree remains! */
+            p->list = NULL;
         }
     }
 }
 
-@ @c
 static void destroy_pg_res_tree(void *pa, void *param)
 {
     (void) param;
     xfree(pa);
 }
 
-@ @c
 static void destroy_page_resources_tree(PDF pdf)
 {
     pdf_resource_struct *re = pdf->page_resources;
@@ -886,11 +860,6 @@ static void destroy_page_resources_tree(PDF pdf)
     re->resources_tree = NULL;
 }
 
-@* Subroutines to print out various PDF objects.
-
-@ print out an integer |n| with fixed width |w|; used for outputting cross-reference table. The
-specification says that an offset must take 10 bytes.
-@c
 static void pdf_print_fw_int(PDF pdf, longinteger n)
 {
     unsigned char digits[11];
@@ -901,20 +870,26 @@ static void pdf_print_fw_int(PDF pdf, longinteger n)
         digits[k] = (unsigned char) ('0' + (n % 10));
         n /= 10;
     } while (k != 0);
-    if (n!=0)
-      /* the absolute  value of $n$ is greater than 9999999999 */
-      normal_error("pdf backend", "offset exceeds 10 bytes, try enabling object compression.");
+    if (n!=0) {
+        /*tex The absolute value of $n$ is greater than 9999999999. */
+        normal_error("pdf backend", "offset exceeds 10 bytes, try enabling object compression.");
+    }
     digits[10]='\0';
     pdf_puts(pdf, (const char *) digits);
 }
 
-@ print out an integer |n| as a fixed number |w| of bytes; used for outputting \.{/XRef} cross-reference stream
-@c
+/*tex
+
+    We print out an integer |n| as a fixed number |w| of bytes,. This is used in
+    the |XRef| cross-reference stream creator.
+
+*/
+
 static void pdf_out_bytes(PDF pdf, longinteger n, size_t w)
 {
-    int k;
-    unsigned char bytes[8];     /* digits in a number being output */
-    k = (int) w;
+    /*tex The number of digits in a number being output. */
+    unsigned char bytes[8];
+    int k = (int) w;
     do {
         k--;
         bytes[k] = (unsigned char) (n % 256);
@@ -923,32 +898,24 @@ static void pdf_out_bytes(PDF pdf, longinteger n, size_t w)
     pdf_out_block(pdf, (const char *) bytes, w);
 }
 
-@ print out |s| as string in PDF output
-
-@c
 void pdf_print_str_ln(PDF pdf, const char *s)
 {
     pdf_print_str(pdf, s);
     pdf_out(pdf, '\n');
 }
 
-@ @c
 void pdf_print_toks(PDF pdf, halfword p)
 {
     int len = 0;
     char *s = tokenlist_to_cstring(p, true, &len);
     if (len > 0) {
-        if (pdf->cave > 0)
-            pdf_out(pdf, ' ');
+        pdf_check_space(pdf);
         pdf_puts(pdf, s);
-        pdf->cave = 1;
+        pdf_set_space(pdf);
     }
     xfree(s);
 }
 
-@ prints a rect spec
-
-@c
 void pdf_add_rect_spec(PDF pdf, halfword r)
 {
     pdf_add_bp(pdf, pdf_ann_left(r));
@@ -957,9 +924,6 @@ void pdf_add_rect_spec(PDF pdf, halfword r)
     pdf_add_bp(pdf, pdf_ann_top(r));
 }
 
-@ output a rectangle specification to PDF file
-
-@c
 void pdf_rectangle(PDF pdf, halfword r)
 {
     pdf_add_name(pdf, "Rect");
@@ -968,7 +932,6 @@ void pdf_rectangle(PDF pdf, halfword r)
     pdf_end_array(pdf);
 }
 
-@ @c
 static void init_pdf_outputparameters(PDF pdf)
 {
     int pk_mode;
@@ -980,6 +943,7 @@ static void init_pdf_outputparameters(PDF pdf)
     pdf->image_hicolor = fix_int(pdf_image_hicolor, 0, 1);
     pdf->image_apply_gamma = fix_int(pdf_image_apply_gamma, 0, 1);
     pdf->objcompresslevel = fix_int(pdf_obj_compress_level, 0, MAX_OBJ_COMPRESS_LEVEL);
+    pdf->recompress = fix_int(pdf_recompress, 0, 1);
     pdf->inclusion_copy_font = fix_int(pdf_inclusion_copy_font, 0, 1);
     pdf->pk_resolution = fix_int(pdf_pk_resolution, 72, 8000);
     pdf->pk_fixed_dpi = fix_int(pdf_pk_fixed_dpi, 0, 1);
@@ -992,19 +956,19 @@ static void init_pdf_outputparameters(PDF pdf)
         }
         pdf->os_enable = false;
     }
-    if (pdf->pk_resolution == 0)        /* if not set from format file or by user */
-        pdf->pk_resolution = pk_dpi;    /* take it from \.{texmf.cnf} */
+    if (pdf->pk_resolution == 0) {
+        /*tex If not set from format file or by user take it from \.{texmf.cnf}. */
+        pdf->pk_resolution = pk_dpi;
+    }
     pdf->pk_scale_factor = divide_scaled(72, pdf->pk_resolution, pk_decimal_digits(pdf,5));
     if (!callback_defined(read_pk_file_callback)) {
-        pk_mode = pdf_pk_mode; /* lookup once */
+        pk_mode = pdf_pk_mode;
         if (pk_mode != null) {
             char *s = tokenlist_to_cstring(pk_mode, true, NULL);
-            /* This will become LUATEX in 1.0. */
-            kpse_init_prog("PDFTEX", (unsigned) pdf->pk_resolution, s, nil);
+            kpse_init_prog("LUATEX", (unsigned) pdf->pk_resolution, s, nil);
             xfree(s);
         } else {
-            /* This will become LUATEX in 1.0. */
-            kpse_init_prog("PDFTEX", (unsigned) pdf->pk_resolution, nil, nil);
+            kpse_init_prog("LUATEX", (unsigned) pdf->pk_resolution, nil, nil);
         }
         if (!kpse_var_value("MKTEXPK"))
             kpse_set_program_enabled(kpse_pk_format, 1, kpse_src_cmdline);
@@ -1014,75 +978,54 @@ static void init_pdf_outputparameters(PDF pdf)
         pdf->resname_prefix = get_resname_prefix(pdf);
 }
 
-@ Checks that we have a name for the generated PDF file and that it's open.
+/*tex
 
-@c
-static void ensure_output_file_open(PDF pdf, const char *ext)
-{
-    char *fn;
-    if (pdf->file_name != NULL)
-        return;
-    if (job_name == 0)
-        open_log_file();
-    fn = pack_job_name(ext);
-    if (pdf->draftmode == 0 || output_mode_used == OMODE_DVI) {
-        while (!lua_b_open_out(&pdf->file, fn))
-            fn = prompt_file_name("file name for output", ext);
-    }
-    pdf->file_name = fn;
-}
+    This checks that we have a name for the generated PDF file and that it's
+    open.
 
-@ @c
-static void ensure_pdf_header_written(PDF pdf)
+*/
+
+void pdf_write_header(PDF pdf)
 {
-    /* Initialize variables for \.{PDF} output */
+    /*tex Initialize variables for \PDF\ output. */
     fix_pdf_version(pdf);
     init_pdf_outputparameters(pdf);
     fix_pdf_draftmode(pdf);
-    /* Write \.{PDF} header */
+    /*tex Write \PDF\ header */
     pdf_printf(pdf, "%%PDF-%d.%d\n", pdf->major_version, pdf->minor_version);
-    /* The next blob will be removed 1.0. */
+    /* Some binary crap. */
     pdf_out(pdf, '%');
-    pdf_out(pdf, 'P' + 128);
+    pdf_out(pdf, 'L' + 128);
+    pdf_out(pdf, 'U' + 128);
+    pdf_out(pdf, 'A' + 128);
     pdf_out(pdf, 'T' + 128);
     pdf_out(pdf, 'E' + 128);
     pdf_out(pdf, 'X' + 128);
+    pdf_out(pdf, 'P' + 128);
+    pdf_out(pdf, 'D' + 128);
+    pdf_out(pdf, 'F' + 128);
     pdf_out(pdf, '\n');
 }
 
-@ @c
+void pdf_open_file(PDF pdf) {
+    ensure_output_file_open(pdf, ".pdf");
+}
+
 void ensure_output_state(PDF pdf, output_state s)
 {
     if (pdf->o_state < s) {
-        if (s > ST_INITIAL)
+        if (s > ST_INITIAL) {
             ensure_output_state(pdf, s - 1);
+        }
         switch (s - 1) {
             case ST_INITIAL:
                 fix_o_mode();
                 break;
             case ST_OMODE_FIX:
-                switch (output_mode_used) {
-                    case OMODE_DVI:
-                        ensure_output_file_open(pdf, ".dvi");
-                        break;
-                    case OMODE_PDF:
-                        ensure_output_file_open(pdf, ".pdf");
-                        break;
-                    default:
-                        normal_error("pdf backend","weird output state");
-                }
+                backend_out_control[backend_control_open_file](pdf);
                 break;
             case ST_FILE_OPEN:
-                switch (output_mode_used) {
-                    case OMODE_DVI:
-                        ensure_dvi_header_written(pdf);
-                        break;
-                    case OMODE_PDF:
-                        ensure_pdf_header_written(pdf);
-                        break;
-                    default:
-                        normal_error("pdf backend","weird output state");
-                }
+                backend_out_control[backend_control_write_header](pdf);
                 break;
             case ST_HEADER_WRITTEN:
                 break;
@@ -1095,29 +1038,37 @@ void ensure_output_state(PDF pdf, output_state s)
     }
 }
 
-@ Write out an accumulated object stream.
+/*tex
 
-First the object number and byte offset pairs are generated and appended to the
-ready buffered object stream. By this the value of \.{/First} can be calculated.
-Then a new \.{/ObjStm} object is generated, and everything is copied to the PDF
-output buffer, where also compression is done. When calling this procedure,
-|pdf_os_mode| must be |true|.
+    Write out an accumulated object stream. The object number and byte offset
+    pairs are generated and appended to the ready buffered object stream. By this
+    the value of \.{/First} can be calculated. Then a new \.{/ObjStm} object is
+    generated, and everything is copied to the PDF output buffer, where also
+    compression is done. When calling this procedure, |pdf_os_mode| must be
+    |true|.
+
+*/
 
-@c
 static void pdf_os_write_objstream(PDF pdf)
 {
     os_struct *os = pdf->os;
-    unsigned int i, j, n1, n2;  /* n1, n2: ObjStm buffer may be reallocated! */
+    /*tex |n1|, |n2|: |ObjStm| buffer may be reallocated! */
+    unsigned int i, j, n1, n2;
     strbuf_s *obuf = os->buf[OBJSTM_BUF];
-    if (os->cur_objstm == 0)    /* no object stream started */
+    if (os->cur_objstm == 0) {
+        /*tex No object stream started. */
         return;
-    n1 = (unsigned int) strbuf_offset(obuf);    /* remember end of collected object stream contents */
-    /* this is needed here to calculate /First for the ObjStm dict */
-    for (i = 0, j = 0; i < os->idx; i++) {      /* add object-number/byte-offset list to buffer */
+    }
+    /*tex Remember end of collected object stream contents. */
+    n1 = (unsigned int) strbuf_offset(obuf);
+    /*tex This is needed here to calculate |/First| for the |ObjStm| dict */
+    for (i = 0, j = 0; i < os->idx; i++) {
+        /*tex Add object-number/byte-offset list to buffer. */
         pdf_print_int(pdf, (int) os->obj[i].num);
         pdf_out(pdf, ' ');
         pdf_print_int(pdf, (int) os->obj[i].off);
-        if (j == 9 || i == os->idx - 1) {       /* print out in groups of ten for better readability */
+        if (j == 9 || i == os->idx - 1) {
+            /*tex Print out in groups of ten for better readability. */
             pdf_out(pdf, '\n');
             j = 0;
         } else {
@@ -1125,192 +1076,168 @@ static void pdf_os_write_objstream(PDF pdf)
             j++;
         }
     }
-    n2 = (unsigned int) strbuf_offset(obuf);    /* remember current buffer end */
-    pdf_begin_obj(pdf, (int) os->cur_objstm, OBJSTM_NEVER);     /* switch to PDF stream writing */
+    /*tex Remember current buffer end. */
+    n2 = (unsigned int) strbuf_offset(obuf);
+    /*tex Switch to \PDF\ stream writing. */
+    pdf_begin_obj(pdf, (int) os->cur_objstm, OBJSTM_NEVER);
     pdf_begin_dict(pdf);
     pdf_dict_add_name(pdf, "Type", "ObjStm");
-    pdf_dict_add_int(pdf, "N", (int) os->idx);  /* number of objects in ObjStm */
+    /*tex The number of objects in |ObjStm|. */
+    pdf_dict_add_int(pdf, "N", (int) os->idx);
     pdf_dict_add_int(pdf, "First", (int) (n2 - n1));
     pdf_dict_add_streaminfo(pdf);
     pdf_end_dict(pdf);
     pdf_begin_stream(pdf);
-    /* write object-number/byte-offset list */
+    /*tex Write object-number/byte-offset list. */
     pdf_out_block(pdf, (const char *) (obuf->data + n1), (size_t) (n2 - n1));
-    /* write collected object stream contents */
+    /*tex Write collected object stream contents. */
     pdf_out_block(pdf, (const char *) obuf->data, (size_t) n1);
     pdf_end_stream(pdf);
     pdf_end_obj(pdf);
-    os->cur_objstm = 0;         /* to force object stream generation next time */
+    /*tex We force object stream generation next time. */
+    os->cur_objstm = 0;
 }
 
-@ begin a PDF dictionary
+/*tex Here comes a bunch of flushers: */
 
-@c
 void pdf_begin_dict(PDF pdf)
 {
+    pdf_check_space(pdf);
     pdf_puts(pdf, "<<");
-    pdf->cave = 0;
+    pdf_set_space(pdf);
 }
 
-@ end a PDF dictionary
-
-@c
 void pdf_end_dict(PDF pdf)
 {
+    pdf_check_space(pdf);
     pdf_puts(pdf, ">>");
-    pdf->cave = 0;
+    pdf_set_space(pdf);
 }
 
-@ add integer object to dict
-
-@c
 void pdf_dict_add_bool(PDF pdf, const char *key, int i)
 {
     pdf_add_name(pdf, key);
     pdf_add_bool(pdf, i);
 }
 
-@ add integer object to dict
-
-@c
 void pdf_dict_add_int(PDF pdf, const char *key, int i)
 {
     pdf_add_name(pdf, key);
     pdf_add_int(pdf, i);
 }
 
-@ add name object to dict
-
-@c
 void pdf_dict_add_name(PDF pdf, const char *key, const char *val)
 {
     pdf_add_name(pdf, key);
     pdf_add_name(pdf, val);
 }
 
-@ add string object to dict
-
-@c
 void pdf_dict_add_string(PDF pdf, const char *key, const char *val)
 {
     if (val == NULL)
         return;
     pdf_add_name(pdf, key);
-    if (pdf->cave > 0)
-        pdf_out(pdf, ' ');
-    pdf->cave = 0;
+    pdf_check_space(pdf);
     pdf_print_str(pdf, val);
+    pdf_set_space(pdf);
 }
 
-@ add name reference to dict
-
-@c
 void pdf_dict_add_ref(PDF pdf, const char *key, int num)
 {
     pdf_add_name(pdf, key);
     pdf_add_ref(pdf, num);
 }
 
-@ add objects of different types
-
-@c
 void pdf_add_null(PDF pdf)
 {
-    if (pdf->cave > 0)
-        pdf_out(pdf, ' ');
+    pdf_check_space(pdf);
     pdf_puts(pdf, "null");
-    pdf->cave = 1;
+    pdf_set_space(pdf);
 }
 
 void pdf_add_bool(PDF pdf, int i)
 {
-    if (pdf->cave > 0)
-        pdf_out(pdf, ' ');
+    pdf_check_space(pdf);
     if (i == 0)
         pdf_puts(pdf, "false");
     else
         pdf_puts(pdf, "true");
-    pdf->cave = 1;
+    pdf_set_space(pdf);
 }
 
 void pdf_add_int(PDF pdf, int i)
 {
-    if (pdf->cave > 0)
-        pdf_out(pdf, ' ');
+    pdf_check_space(pdf);
     pdf_print_int(pdf, i);
-    pdf->cave = 1;
+    pdf_set_space(pdf);
 }
 
 void pdf_add_longint(PDF pdf, longinteger n)
 {
-    if (pdf->cave > 0)
-        pdf_out(pdf, ' ');
+    pdf_check_space(pdf);
     pdf_print_int(pdf, n);
-    pdf->cave = 1;
+    pdf_set_space(pdf);
 }
 
 void pdf_add_string(PDF pdf, const char *s)
 {
-    if (pdf->cave > 0)
-        pdf_out(pdf, ' ');
+    pdf_check_space(pdf);
     pdf_print_str(pdf, s);
-    pdf->cave = 1;
+    pdf_set_space(pdf);
 }
 
 void pdf_add_name(PDF pdf, const char *name)
 {
+    pdf_check_space(pdf);
     pdf_out(pdf, '/');
     pdf_puts(pdf, name);
-    pdf->cave = 1;
+    pdf_set_space(pdf);
 }
 
 void pdf_add_ref(PDF pdf, int num)
 {
-    if (pdf->cave > 0)
-        pdf_out(pdf, ' ');
+    pdf_check_space(pdf);
     pdf_print_int(pdf, num);
     pdf_puts(pdf, " 0 R");
-    pdf->cave = 1;
+    pdf_set_space(pdf);
 }
 
-@ add stream length and filter entries to a stream dictionary,
-remember file position for seek
+/*tex
+
+    When we add the stream length and filter entries to a stream dictionary,
+    remember file position for seek.
+
+*/
 
-@c
 void pdf_dict_add_streaminfo(PDF pdf)
 {
-    pdf_add_name(pdf, "Length");
-    pdf->stream_length_offset = pdf_offset(pdf) + 1;
-    pdf->seek_write_length = true; /* fill in length at |pdf_end_stream| call */
-    pdf_puts(pdf, " x         ");  /* space for 10 decimal digits */
-    pdf->cave = 1;
     if (pdf->compress_level > 0) {
         pdf_dict_add_name(pdf, "Filter", "FlateDecode");
         pdf->stream_deflate = true;
     }
+    pdf_add_name(pdf, "Length");
+    pdf->stream_length_offset = pdf_offset(pdf) + 1;
+    /*tex Fill in length at |pdf_end_stream| call. */
+    pdf->seek_write_length = true;
+    /*tex We reserve space for 10 decimal digits plus space. */
+    pdf_puts(pdf, " x          ");
+    pdf_set_space(pdf);
 }
 
-@ begin a PDF array
-
-@c
 void pdf_begin_array(PDF pdf)
 {
+    pdf_check_space(pdf);
     pdf_out(pdf, '[');
-    pdf->cave = 0;
+    pdf_set_space(pdf);
 }
 
-@ end a PDF array
-
-@c
 void pdf_end_array(PDF pdf)
 {
+    pdf_check_space(pdf);
     pdf_out(pdf, ']');
-    pdf->cave = 0;
+    pdf_set_space(pdf);
 }
 
-@ begin a PDF object
-
-@c
 void pdf_begin_obj(PDF pdf, int i, int pdf_os_threshold)
 {
     os_struct *os = pdf->os;
@@ -1321,45 +1248,90 @@ void pdf_begin_obj(PDF pdf, int i, int pdf_os_threshold)
             pdf_printf(pdf, "%d 0 obj\n", (int) i);
             break;
         case OBJSTM_BUF:
-            if (pdf->compress_level == 0)
-                pdf_printf(pdf, "%% %d 0 obj\n", (int) i);  /* debugging help */
+            if (pdf->compress_level == 0) {
+                /*tex Some debugging help. */
+                pdf_printf(pdf, "%% %d 0 obj\n", (int) i);
+            }
             break;
         default:
             normal_error("pdf backend","weird begin object");
     }
-    pdf->cave = 0;
+    pdf_reset_space(pdf);
 }
 
-@ end a PDF object
-
-@c
 void pdf_end_obj(PDF pdf)
 {
     os_struct *os = pdf->os;
     switch (os->curbuf) {
         case PDFOUT_BUF:
-            pdf_puts(pdf, "\nendobj\n"); /* end a PDF object */
+            /*tex End a \PDF\ object. */
+            pdf_puts(pdf, "\nendobj\n");
             break;
         case OBJSTM_BUF:
-            os->idx++;   /* = number of objects collected so far in ObjStm */
-            os->o_ctr++; /* only for statistics */
-            if (os->idx == PDF_OS_MAX_OBJS)
+            /*tex Tthe number of objects collected so far in ObjStm: */
+            os->idx++;
+            /*tex Only for statistics: */
+            os->o_ctr++;
+            if (os->idx == PDF_OS_MAX_OBJS) {
                 pdf_os_write_objstream(pdf);
-            else
-                pdf_out(pdf, '\n'); /* Adobe Reader seems to need this */
+            } else {
+                /*tex Adobe Reader seems to need this. */
+                pdf_out(pdf, '\n');
+            }
             break;
         default:
             normal_error("pdf backend","weird end object");
     }
 }
 
-@ Converts any string given in in in an allowed PDF string which can be
- handled by printf et.al.: \.{\\} is escaped to \.{\\\\}, parenthesis are escaped and
- control characters are octal encoded.
- This assumes that the string does not contain any already escaped
- characters!
+/*
+    Needed for embedding fonts.
+
+*/
+
+pdf_obj *pdf_new_stream(void)
+{
+    pdf_obj *stream = xmalloc(sizeof(pdf_obj));
+    stream->length = 0;
+    stream->data = NULL;
+    return stream;
+}
+
+void pdf_add_stream(pdf_obj * stream, unsigned char *buf, long len)
+{
+    int i;
+    assert(stream != NULL);
+    if (stream->data == NULL) {
+        stream->data = xmalloc((unsigned) len);
+    } else {
+        stream->data =
+            xrealloc(stream->data, (unsigned) len + (unsigned) stream->length);
+    }
+    for (i = 0; i < len; i++) {
+        *(stream->data + stream->length + i) = *(buf + i);
+    }
+    stream->length += (unsigned) len;
+}
+
+void pdf_release_obj(pdf_obj * stream)
+{
+    if (stream != NULL) {
+        if (stream->data != NULL) {
+            xfree(stream->data);
+        }
+        xfree(stream);
+    }
+}
+
+/*
+
+    This one converts any string given in in in an allowed PDF string which can
+    be handled by printf et.al.: \.{\\} is escaped to \.{\\\\}, parenthesis are
+    escaped and control characters are octal encoded. This assumes that the
+    string does not contain any already escaped characters!
+
+*/
 
-@c
 char *convertStringToPDFString(const char *in, int len)
 {
     static char pstrbuf[MAX_PSTRING_LEN];
@@ -1370,7 +1342,7 @@ char *convertStringToPDFString(const char *in, int len)
     for (i = 0; i < len; i++) {
         check_buf((unsigned) j + sizeof(buf), MAX_PSTRING_LEN);
         if (((unsigned char) in[i] < '!') || ((unsigned char) in[i] > '~')) {
-            /* convert control characters into oct */
+            /*tex Convert control characters into octal. */
             k = snprintf(buf, sizeof(buf), "\\%03o", (unsigned int) (unsigned char) in[i]);
             check_nprintf(k, sizeof(buf));
             out[j++] = buf[0];
@@ -1378,15 +1350,15 @@ char *convertStringToPDFString(const char *in, int len)
             out[j++] = buf[2];
             out[j++] = buf[3];
         } else if ((in[i] == '(') || (in[i] == ')')) {
-            /* escape paranthesis */
+            /*tex Escape parenthesis: */
             out[j++] = '\\';
             out[j++] = in[i];
         } else if (in[i] == '\\') {
-            /* escape backslash */
+            /*tex Escape backslash: */
             out[j++] = '\\';
             out[j++] = '\\';
         } else {
-            /* copy char :-) */
+            /* Copy char : */
             out[j++] = in[i];
         }
     }
@@ -1394,10 +1366,13 @@ char *convertStringToPDFString(const char *in, int len)
     return pstrbuf;
 }
 
-@ Converts any string given in in in an allowed PDF string which is hexadecimal
-encoded; |sizeof(out)| should be at least $|lin|*2+1$.
+/*tex
+
+    This one converts any string given in in in an allowed PDF string which is
+    hexadecimal encoded; |sizeof(out)| should be at least $|lin|*2+1$.
+
+*/
 
-@c
 static void convertStringToHexString(const char *in, char *out, int lin)
 {
     int i, k;
@@ -1412,40 +1387,18 @@ static void convertStringToHexString(const char *in, char *out, int lin)
     out[j] = '\0';
 }
 
-@ Compute the ID string as per PDF1.4 9.3:
-
-File identifers are defined by the optional ID entry in a PDF file's trailer
-dictionary (see Section 3.4.4, "File Trailer"; see also implementation note 105
-in Appendix H). The value of this entry is an array of two strings. The first
-string is a permanent identifier based on the contents of the file at the time it
-was originally created, and does not change when the file is incrementally
-updated. The second string is a changing identifier based on the file's contents
-at the time it was last updated. When a file is first written, both identifiers
-are set to the same value. If both identifiers match when a file reference is
-resolved, it is very likely that the correct file has been found; if only the
-first identifier matches, then a different version of the correct file has been
-found. To help ensure the uniqueness of file identifiers, it is recommend that
-they be computed using a message digest algorithm such as MD5 (described in
-Internet RFC 1321, The MD5 Message-Digest Algorithm; see the Bibliography), using
-the following information (see implementation note 106 in Appendix H): - The
-current time
-
-- A string representation of the file's location, usually a pathname
-- The size of the file in bytes
-- The values of all entries in the file's document information
-  dictionary (see Section 9.2.1,  Document Information Dictionary )
-
-This stipulates only that the two IDs must be identical when the file is created
-and that they should be reasonably unique. Since it's difficult to get the file
-size at this point in the execution of pdfTeX and scanning the info dict is also
-difficult, we start with a simpler implementation using just the first two items.
+/*tex
 
+    We compute the ID string as per PDF specification 1.4 9.3 that stipulates
+    only that the two IDs must be identical when the file is created and that
+    they should be reasonably unique. Since it's difficult to get the file size
+    at this point in the execution of pdfTeX and scanning the info dict is also
+    difficult, we start with a simpler implementation using just the first two
+    items.
 
-@c
-
-/*
     A user supplied trailerid had better be an array! So maybe we need to check
-    for [] and error otherwise.
+    for |[]| and error otherwise.
+
 */
 
 static void print_ID(PDF pdf)
@@ -1457,10 +1410,10 @@ static void print_ID(PDF pdf)
         if (p && strlen(p) > 0) {
             pdf_puts(pdf,p);
         } else if (pdf_trailer_id != 0) {
-            /* user provided one */
+            /*tex The user provided one: */
             pdf_print_toks(pdf, pdf_trailer_id);
         } else {
-            /* system provided one */
+            /*tex The system provided one: */
             time_t t;
             size_t size;
             char time_str[32];
@@ -1468,13 +1421,10 @@ static void print_ID(PDF pdf)
             md5_byte_t digest[16];
             char id[64];
             char pwd[4096];
-            /* start md5 */
             md5_init(&state);
-            /* get the time */
             t = pdf->start_time;
             size = strftime(time_str, sizeof(time_str), "%Y%m%dT%H%M%SZ", gmtime(&t));
             md5_append(&state, (const md5_byte_t *) time_str, (int) size);
-            /* get the file name */
             if (getcwd(pwd, sizeof(pwd)) == NULL) {
                 formatted_error("pdf backend","getcwd() failed (%s), (path too long?)", strerror(errno));
             }
@@ -1492,63 +1442,27 @@ static void print_ID(PDF pdf)
             md5_append(&state, (const md5_byte_t *) pwd, (int) strlen(pwd));
             md5_append(&state, (const md5_byte_t *) "/", 1);
             md5_append(&state, (const md5_byte_t *) pdf->file_name, (int) strlen(pdf->file_name));
-            /* finish md5 */
             md5_finish(&state, digest);
-            /* write the IDs */
             convertStringToHexString((char *) digest, id, 16);
             pdf_begin_array(pdf);
+            pdf_check_space(pdf);
             pdf_printf(pdf, "<%s> <%s>", id, id);
+            pdf_set_space(pdf);
             pdf_end_array(pdf);
         }
     }
 }
 
-@ Print the /CreationDate entry.
-
-PDF Reference, third edition says about the expected date format:
-
-3.8.2 Dates
-
-PDF defines a standard date format, which closely follows that of the
-international standard ASN.1 (Abstract Syntax Notation One), defined in ISO/IEC
-8824 (see the Bibliography). A date is a string of the form
-
-(D:YYYYMMDDHHmmSSOHH'mm')
-
-where
-
-YYYY  is the year
-MM    is the month
-DD    is the day (01-31)
-HH    is the hour (00-23)
-mm    is the minute (00-59)
-SS    is the second (00-59)
-O     is the relationship of local time to Universal Time (UT), denoted by one
-      of the characters +, -, or Z (see below)
-HH    followed by ' is the absolute value of the offset from UT in hours (00-23)
-mm    followed by ' is the absolute value of the offset from UT in minutes (00-59)
-
-The apostrophe character (') after HH and mm is part of the syntax. All fields
-after the year are optional. (The prefix D:, although also optional, is strongly
-recommended.) The default values for MM and DD are both 01; all other numerical
-fields default to zero values. A plus sign (+) as the value of the O field
-signifies that local time is later than UT, a minus sign (-) that local time is
-earlier than UT, and the letter Z that local time is equal to UT. If no UT
-information is specified, the relationship of the specified time to UT is
-considered to be unknown. Whether or not the time zone is known, the rest of the
-date should be specified in local time.
+/*tex
 
-For example, December 23, 1998, at 7:52 PM, U.S. Pacific Standard Time, is
-represented by the string
+    Here we print the |/CreationDate| entry in the form
+    |(D:YYYYMMDDHHmmSSOHH'mm')|. The main difficulty is get the time zone offset.
+    |strftime()| does this in ISO C99 (e.g. newer glibc) with \%z, but we have to
+    work with other systems (e.g. Solaris 2.5).
 
-D:199812231952-08'00'
-
-The main difficulty is get the time zone offset. |strftime()| does this in ISO
-C99 (e.g. newer glibc) with \%z, but we have to work with other systems (e.g.
-Solaris 2.5).
+*/
 
-@c
-#define TIME_STR_SIZE 30 /* minimum size for |time_str| is 24: |"D:YYYYmmddHHMMSS+HH'MM'"| */
+#define TIME_STR_SIZE 30
 
 static void makepdftime(PDF pdf)
 {
@@ -1557,32 +1471,31 @@ static void makepdftime(PDF pdf)
     int i, off, off_hours, off_mins;
     time_t t = pdf->start_time;
     char *time_str = pdf->start_time_str;
-    /* get the time */
+    /*tex Get the time. */
     if (utc_option) {
         lt = *gmtime(&t);
     } else {
         lt = *localtime(&t);
     }
     size = strftime(time_str, TIME_STR_SIZE, "D:%Y%m%d%H%M%S", &lt);
-    /* expected format: "YYYYmmddHHMMSS" */
+    /*tex Expected format: |YYYYmmddHHMMSS|. */
     if (size == 0) {
-        /* unexpected, contents of |time_str| is undefined */
+        /*tex Unexpected, contents of |time_str| is undefined .*/
         time_str[0] = '\0';
         return;
     }
-    /*
-       correction for seconds: \%S can be in range 00..61, the PDF reference
-       expects 00..59, therefore we map "60" and "61" to "59"
+    /*tex
+       A correction for seconds. the PDF reference expects 00..59, therefore we
+       map 60 and 61 to 59.
     */
     if (time_str[14] == '6') {
         time_str[14] = '5';
         time_str[15] = '9';
-        /* for safety */
+        /*tex For safety: */
         time_str[16] = '\0';
     }
-    /* get the time zone offset */
+    /*tex Get the time zone offset. */
     gmt = *gmtime(&t);
-    /* this calculation method was found in exim's tod.c */
     off = 60 * (lt.tm_hour - gmt.tm_hour) + lt.tm_min - gmt.tm_min;
     if (lt.tm_year != gmt.tm_year) {
         off += (lt.tm_year > gmt.tm_year) ? 1440 : -1440;
@@ -1601,7 +1514,6 @@ static void makepdftime(PDF pdf)
     pdf->start_time = t;
 }
 
-@ @c
 void initialize_start_time(PDF pdf)
 {
     if (pdf->start_time == 0) {
@@ -1611,14 +1523,12 @@ void initialize_start_time(PDF pdf)
     }
 }
 
-@ @c
 char *getcreationdate(PDF pdf)
 {
     initialize_start_time(pdf);
     return pdf->start_time_str;
 }
 
-@ @c
 void remove_pdffile(PDF pdf)
 {
     if (pdf != NULL) {
@@ -1629,10 +1539,9 @@ void remove_pdffile(PDF pdf)
     }
 }
 
-@ Use |check_o_mode()| in the backend-specific "Implement..." chunks
+/*tex We use this checker in other modules. It is not pdf specific. */
 
-@c
-void check_o_mode(PDF pdf, const char *s, int o_mode_bitpattern, boolean strict) /* s ignored now */
+void check_o_mode(PDF pdf, const char *s, int o_mode_bitpattern, boolean strict)
 {
 
     output_mode o_mode;
@@ -1641,16 +1550,13 @@ void check_o_mode(PDF pdf, const char *s, int o_mode_bitpattern, boolean strict)
         normal_error("lua only","no backend present, needed for what you asked for");
         return ;
     }
-    /*
-        in warn mode (strict == false): only check, don't do |fix_o_mode()| here! |output_mode_used|
-        is left in possibly wrong state until real output, ok.
-    */
     if (output_mode_used == OMODE_NONE)
         o_mode = get_o_mode();
     else
         o_mode = output_mode_used;
-    pdf->o_mode = output_mode_used; /* used by synctex, we need to use output_mode_used there */
-    if (!((1 << o_mode) & o_mode_bitpattern)) { /* warning or error */
+    /*tex This is used by synctex, we need to use output_mode_used there. */
+    pdf->o_mode = output_mode_used;
+    if (!((1 << o_mode) & o_mode_bitpattern)) {
         switch (o_mode) {
             case OMODE_DVI:
                 m = "DVI";
@@ -1669,7 +1575,23 @@ void check_o_mode(PDF pdf, const char *s, int o_mode_bitpattern, boolean strict)
         ensure_output_state(pdf, ST_HEADER_WRITTEN);
 }
 
-@ @c
+void ensure_output_file_open(PDF pdf, const char *ext)
+{
+    char *fn;
+    if (pdf->file_name != NULL)
+        return;
+    if (job_name == 0)
+        open_log_file();
+    fn = pack_job_name(ext);
+    if (pdf->draftmode == 0 || output_mode_used == OMODE_DVI) {
+        while (!lua_b_open_out(&pdf->file, fn))
+            fn = prompt_file_name("file name for output", ext);
+    }
+    pdf->file_name = fn;
+}
+
+/*tex till here */
+
 void set_job_id(PDF pdf, int year, int month, int day, int time)
 {
     char *name_string, *format_string, *s;
@@ -1681,7 +1603,7 @@ void set_job_id(PDF pdf, int year, int month, int day, int time)
     format_string = makecstring(format_ident);
     slen = SMALL_BUF_SIZE + strlen(name_string) + strlen(format_string) + strlen(luatex_banner);
     s = xtalloc(slen, char);
-    /* The Web2c version string starts with a space.  */
+    /*tex The \WEBC\ version string starts with a space. (Really?) */
     i = snprintf(s, slen, "%.4d/%.2d/%.2d %.2d:%.2d %s %s %s", year, month, day, time / 60, time % 60, name_string, format_string, luatex_banner);
     check_nprintf(i, slen);
     pdf->job_id_string = xstrdup(s);
@@ -1690,11 +1612,11 @@ void set_job_id(PDF pdf, int year, int month, int day, int time)
     xfree(format_string);
 }
 
-@ @c
 char *get_resname_prefix(PDF pdf)
 {
     static char name_str[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
-    static char prefix[7]; /* make a tag of 6 chars long */
+    /*tex We make a tag of 6 characters long. */
+    static char prefix[7];
     short i;
     size_t base = strlen(name_str);
     unsigned long crc = crc32(0L, Z_NULL, 0);
@@ -1707,12 +1629,11 @@ char *get_resname_prefix(PDF pdf)
     return prefix;
 }
 
-@ @c
 void pdf_begin_page(PDF pdf)
 {
     int xform_attributes;
     int xform_type = 0;
-    scaled form_margin = pdf_xform_margin; /* was one_bp until SVN4066 */
+    scaled form_margin = pdf_xform_margin;
     ensure_output_state(pdf, ST_HEADER_WRITTEN);
     init_pdf_pagecalculations(pdf);
     if (pdf->page_resources == NULL) {
@@ -1724,7 +1645,8 @@ void pdf_begin_page(PDF pdf)
 
     if (global_shipping_mode == SHIPPING_PAGE) {
         pdf->last_page = pdf_get_obj(pdf, obj_type_page, total_pages + 1, 0);
-        set_obj_aux(pdf, pdf->last_page, 1);    /* mark that this page has been created */
+        /*tex Mark that this page has been created. */
+        set_obj_aux(pdf, pdf->last_page, 1);
         pdf->last_stream = pdf_create_obj(pdf, obj_type_pagestream, 0);
         pdf_begin_obj(pdf, pdf->last_stream, OBJSTM_NEVER);
         pdf->last_thread = null;
@@ -1733,15 +1655,16 @@ void pdf_begin_page(PDF pdf)
         xform_type = obj_xform_type(pdf, pdf_cur_form) ;
         pdf_begin_obj(pdf, pdf_cur_form, OBJSTM_NEVER);
         pdf->last_stream = pdf_cur_form;
-        /* Write out Form stream header */
+        /*tex Write out the |Form| stream header */
         pdf_begin_dict(pdf);
         if (xform_type == 0) {
             pdf_dict_add_name(pdf, "Type", "XObject");
             pdf_dict_add_name(pdf, "Subtype", "Form");
             pdf_dict_add_int(pdf, "FormType", 1);
         }
-        xform_attributes = pdf_xform_attr; /* lookup once */
-        form_margin = obj_xform_margin(pdf, pdf_cur_form); /* now stored in object */
+        xform_attributes = pdf_xform_attr;
+        /*tex Now stored in the object: */
+        form_margin = obj_xform_margin(pdf, pdf_cur_form);
         if (xform_attributes != null)
             pdf_print_toks(pdf, xform_attributes);
         if (obj_xform_attr(pdf, pdf_cur_form) != null) {
@@ -1750,7 +1673,7 @@ void pdf_begin_page(PDF pdf)
             set_obj_xform_attr(pdf, pdf_cur_form, null);
         }
         if (obj_xform_attr_str(pdf, pdf_cur_form) != null) {
-            lua_pdf_literal(pdf, obj_xform_attr_str(pdf, pdf_cur_form));
+            lua_pdf_literal(pdf, obj_xform_attr_str(pdf, pdf_cur_form),1);
             luaL_unref(Luas, LUA_REGISTRYINDEX, obj_xform_attr_str(pdf, pdf_cur_form));
             set_obj_xform_attr_str(pdf, pdf_cur_form, null);
         }
@@ -1776,11 +1699,12 @@ void pdf_begin_page(PDF pdf)
         }
         pdf_dict_add_ref(pdf, "Resources", pdf->page_resources->last_resources);
     }
-    /* Start stream of page/form contents */
+    /*tex Start a stream of page or form contents: */
     pdf_dict_add_streaminfo(pdf);
     pdf_end_dict(pdf);
     pdf_begin_stream(pdf);
-    pos_stack_used = 0; /* start with empty stack */
+    /*tex Start with an empty stack: */
+    pos_stack_used = 0;
     if (global_shipping_mode == SHIPPING_PAGE) {
         colorstackpagestart();
     }
@@ -1788,40 +1712,37 @@ void pdf_begin_page(PDF pdf)
         pdf_out_colorstack_startpage(pdf);
 }
 
-@ @c
 void print_pdf_table_string(PDF pdf, const char *s)
 {
     size_t len;
     const char *ls;
     lua_rawgeti(Luas, LUA_REGISTRYINDEX, lua_key_index(pdf_data));
     lua_rawget(Luas, LUA_REGISTRYINDEX);
-    lua_pushstring(Luas, s);                  /* s t ... */
-    lua_rawget(Luas, -2);                     /* s? t ... */
-    if (lua_type(Luas, -1) == LUA_TSTRING) {  /* s t ... */
+    lua_pushstring(Luas, s);
+    lua_rawget(Luas, -2);
+    if (lua_type(Luas, -1) == LUA_TSTRING) {
         ls = lua_tolstring(Luas, -1, &len);
         if (len > 0) {
-            if (pdf->cave == 1)
-                pdf_out(pdf, ' ');
+            pdf_check_space(pdf);
             pdf_out_block(pdf, ls, len);
-            pdf->cave = 1;
+            pdf_set_space(pdf);
         }
     }
     lua_pop(Luas, 2);
 }
 
-@ @c
 const char *get_pdf_table_string(const char *s)
 {
     const_lstring ls;
     lua_rawgeti(Luas, LUA_REGISTRYINDEX, lua_key_index(pdf_data));
     lua_rawget(Luas, LUA_REGISTRYINDEX);
-    lua_pushstring(Luas, s);                   /* s t ... */
-    lua_rawget(Luas, -2);                      /* s? t ... */
-    if (lua_type(Luas, -1) == LUA_TSTRING) {   /* s t ... */
+    lua_pushstring(Luas, s);
+    lua_rawget(Luas, -2);
+    if (lua_type(Luas, -1) == LUA_TSTRING) {
         ls.s = lua_tolstring(Luas, -1, &ls.l);
-        /*
-            s is supposed to be anchored (e.g in the registry)
-            so it's not garbage collected
+        /*tex
+            Here |s| is supposed to be anchored (e.g.\ in the registry) so it's
+            not garbage collected.
         */
         lua_pop(Luas, 2);
         return ls.s;
@@ -1830,7 +1751,6 @@ const char *get_pdf_table_string(const char *s)
     return NULL ;
 }
 
-@ @c
 void pdf_end_page(PDF pdf)
 {
     char s[64], *p;
@@ -1838,12 +1758,14 @@ void pdf_end_page(PDF pdf)
     pdf_resource_struct *res_p = pdf->page_resources;
     pdf_resource_struct local_page_resources;
     pdf_object_list *annot_list, *bead_list, *link_list, *ol, *ol1;
-    scaledpos save_cur_page_size; /* to save |pdf->page_size| during flushing pending forms */
+    /*tex We save |pdf->page_size| during flushing pending forms: */
+    scaledpos save_cur_page_size;
     shipping_mode_e save_shipping_mode;
+    int save_pdf_cur_form;
     int xform_resources;
     int page_resources, page_attributes;
     int procset = PROCSET_PDF;
-    /* Finish stream of page/form contents */
+    /*tex Finish the stream of page or form contents: */
     pdf_goto_pagemode(pdf);
     if (pos_stack_used > 0) {
         formatted_error("pdf backend","%u unmatched 'save' after %s shipout", (unsigned int) pos_stack_used,
@@ -1856,7 +1778,7 @@ void pdf_end_page(PDF pdf)
       run_callback(callback_id, "b->",(global_shipping_mode == SHIPPING_PAGE));
     if (global_shipping_mode == SHIPPING_PAGE) {
         pdf->last_pages = pdf_do_page_divert(pdf, pdf->last_page, 0);
-        /* Write out /Page object */
+        /*tex  Write out the |/Page| object. */
         pdf_begin_obj(pdf, pdf->last_page, OBJSTM_ALWAYS);
         pdf_begin_dict(pdf);
         pdf_dict_add_name(pdf, "Type", "Page");
@@ -1869,7 +1791,7 @@ void pdf_end_page(PDF pdf)
         pdf_add_bp(pdf, pdf->page_size.h);
         pdf_add_bp(pdf, pdf->page_size.v);
         pdf_end_array(pdf);
-        page_attributes = pdf_page_attr ; /* lookup once */
+        page_attributes = pdf_page_attr ;
         if (page_attributes != null)
             pdf_print_toks(pdf, page_attributes);
         print_pdf_table_string(pdf, "pageattributes");
@@ -1891,7 +1813,7 @@ void pdf_end_page(PDF pdf)
         pdf_end_dict(pdf);
         pdf_end_obj(pdf);
         pdf->img_page_group_val = 0;
-        /* Generate array of annotations or beads in page */
+        /*tex Generate an array of annotations or beads in page. */
         if (annot_list != NULL || link_list != NULL) {
             pdf_begin_obj(pdf, annots, OBJSTM_ALWAYS);
             pdf_begin_array(pdf);
@@ -1917,37 +1839,38 @@ void pdf_end_page(PDF pdf)
             pdf_end_obj(pdf);
         }
     }
-    /* Write out resource lists and pending raw objects */
+    /*tex Write out the resource lists and pending raw objects. */
     ol = get_page_resources_list(pdf, obj_type_obj);
     while (ol != NULL) {
         if (!is_obj_written(pdf, ol->info))
             pdf_write_obj(pdf, ol->info);
         ol = ol->link;
     }
-
-    /*
+    /*tex
         When flushing pending forms we need to save and restore resource lists
         which are also used by page shipping. Saving and restoring
-        |pdf->page_size| is needed for proper writing out pending PDF marks.
+        |pdf->page_size| is needed for proper writing out pending \PDF\ marks.
     */
     ol = get_page_resources_list(pdf, obj_type_xform);
     while (ol != NULL) {
         if (!is_obj_written(pdf, ol->info)) {
+            save_pdf_cur_form = pdf_cur_form;
             pdf_cur_form = ol->info;
             save_cur_page_size = pdf->page_size;
             save_shipping_mode = global_shipping_mode;
             pdf->page_resources = &local_page_resources;
             local_page_resources.resources_tree = NULL;
             ship_out(pdf, obj_xform_box(pdf, pdf_cur_form), SHIPPING_FORM);
-            /* Restore page size and page resources */
+            /*tex Restore the page size and page resources. */
             pdf->page_size = save_cur_page_size;
             global_shipping_mode = save_shipping_mode;
             destroy_page_resources_tree(pdf);
             pdf->page_resources = res_p;
+            pdf_cur_form = save_pdf_cur_form;
         }
         ol = ol->link;
     }
-    /* Write out pending images */
+    /*tex Write out pending images. */
     ol = get_page_resources_list(pdf, obj_type_ximage);
     while (ol != NULL) {
         if (!is_obj_written(pdf, ol->info))
@@ -1955,11 +1878,12 @@ void pdf_end_page(PDF pdf)
         ol = ol->link;
     }
     if (global_shipping_mode == SHIPPING_PAGE) {
-        /* Write out pending PDF marks and annotations */
+        /*tex Write out pending \PDF\ marks and annotations. */
         ol = get_page_resources_list(pdf, obj_type_annot);
         while (ol != NULL) {
             if (ol->info > 0 && obj_type(pdf, ol->info) == obj_type_annot) {
-                j = obj_annot_ptr(pdf, ol->info); /* |j| points to |pdf_annot_node| */
+                /*tex Here |j| points to |pdf_annot_node|: */
+                j = obj_annot_ptr(pdf, ol->info);
                 pdf_begin_obj(pdf, ol->info, OBJSTM_ALWAYS);
                 pdf_begin_dict(pdf);
                 pdf_dict_add_name(pdf, "Type", "Annot");
@@ -1970,7 +1894,7 @@ void pdf_end_page(PDF pdf)
             }
             ol = ol->link;
         }
-        /* Write out PDF link annotations */
+        /*tex Write out PDF link annotations. */
         if ((ol = get_page_resources_list(pdf, obj_type_link)) != NULL) {
             while (ol != NULL) {
                 j = obj_annot_ptr(pdf, ol->info);
@@ -1989,49 +1913,52 @@ void pdf_end_page(PDF pdf)
                 pdf_end_obj(pdf);
                 ol = ol->link;
             }
-            /* Flush |pdf_start_link_node|'s created by |append_link| */
+            /*tex Flush |pdf_start_link_node|'s created by |append_link|. */
             ol = get_page_resources_list(pdf, obj_type_link);
             while (ol != NULL) {
                 j = obj_annot_ptr(pdf, ol->info);
-                /*
-                    nodes with |subtype = pdf_link_data_node| were created by |append_link| and
-                    must be flushed here, as they are not linked in any list
+                /*tex
+                    Nodes with |subtype = pdf_link_data_node| were created by
+                    |append_link| and must be flushed here, as they are not
+                    linked in any list.
                 */
                 if (subtype(j) == pdf_link_data_node)
                     flush_node(j);
                 ol = ol->link;
             }
         }
-        /* Write out PDF mark destinations */
+        /*tex Write out \PDF\ mark destinations. */
         write_out_pdf_mark_destinations(pdf);
-        /* Write out PDF bead rectangle specifications */
+        /*tex Write out \PDF\ bead rectangle specifications. */
         print_bead_rectangles(pdf);
     }
-    /* Write out resources dictionary */
+    /*tex Write out resources dictionary. */
     pdf_begin_obj(pdf, res_p->last_resources, OBJSTM_ALWAYS);
     pdf_begin_dict(pdf);
-    /* Print additional resources */
+    /*tex Print additional resources. */
     if (global_shipping_mode == SHIPPING_PAGE) {
-        page_resources = pdf_page_resources; /* lookup once */
-        if (page_resources != null)
+        page_resources = pdf_page_resources;
+        if (page_resources != null) {
             pdf_print_toks(pdf, page_resources);
+        }
         print_pdf_table_string(pdf, "pageresources");
     } else {
-        xform_resources = pdf_xform_resources; /* lookup once */
-        if (xform_resources != null)
+        xform_resources = pdf_xform_resources;
+        if (xform_resources != null) {
             pdf_print_toks(pdf, xform_resources);
+        }
         if (obj_xform_resources(pdf, pdf_cur_form) != null) {
             pdf_print_toks(pdf, obj_xform_resources(pdf, pdf_cur_form));
             delete_token_ref(obj_xform_resources(pdf, pdf_cur_form));
             set_obj_xform_resources(pdf, pdf_cur_form, null);
         }
         if (obj_xform_resources_str(pdf, pdf_cur_form) != null) {
-            lua_pdf_literal(pdf, obj_xform_resources_str(pdf, pdf_cur_form));
+            lua_pdf_literal(pdf, obj_xform_resources_str(pdf, pdf_cur_form),1);
             luaL_unref(Luas, LUA_REGISTRYINDEX, obj_xform_resources_str(pdf, pdf_cur_form));
             set_obj_xform_resources_str(pdf, pdf_cur_form, null);
         }
     }
-    /* Generate font resources */
+    /*tex Generate font resources. */
     if ((ol = get_page_resources_list(pdf, obj_type_font)) != NULL) {
         pdf_add_name(pdf, "Font");
         pdf_begin_dict(pdf);
@@ -2046,7 +1973,7 @@ void pdf_end_page(PDF pdf)
         pdf_end_dict(pdf);
         procset |= PROCSET_TEXT;
     }
-    /* Generate XObject resources */
+    /*tex Generate |XObject| resources. */
     ol = get_page_resources_list(pdf, obj_type_xform);
     ol1 = get_page_resources_list(pdf, obj_type_ximage);
     if (ol != NULL || ol1 != NULL) {
@@ -2071,7 +1998,7 @@ void pdf_end_page(PDF pdf)
         }
         pdf_end_dict(pdf);
     }
-    /* Generate ProcSet */
+    /*tex Generate |ProcSet| in version 1.*/
     if (pdf->major_version == 1) {
         pdf_add_name(pdf, "ProcSet");
         pdf_begin_array(pdf);
@@ -2091,13 +2018,15 @@ void pdf_end_page(PDF pdf)
     pdf_end_obj(pdf);
 }
 
-@* Finishing the PDF output file.
+/*tex
 
-@ Destinations that have been referenced but don't exists have
-|obj_dest_ptr=null|. Leaving them undefined might cause troubles for PDF
-browsers, so we need to fix them; they point to the last page.
+    We're now ready to wrap up the output file. Destinations that have been
+    referenced but don't exists have |obj_dest_ptr=null|. Leaving them undefined
+    might cause troubles for PDF browsers, so we need to fix them; they point to
+    the last page.
+
+*/
 
-@c
 static void check_nonexisting_destinations(PDF pdf)
 {
     int k;
@@ -2120,25 +2049,27 @@ static void check_nonexisting_destinations(PDF pdf)
     }
 }
 
-@ @c
 static void check_nonexisting_pages(PDF pdf)
 {
     struct avl_traverser t;
     oentry *p;
     struct avl_table *page_tree = pdf->obj_tree[obj_type_page];
     avl_t_init(&t, page_tree);
-    /* search from the end backward until the last real page is found */
+    /*tex Search from the end backward until the last real page is found. */
     for (p = avl_t_last(&t, page_tree); p != NULL && obj_aux(pdf, p->objptr) == 0; p = avl_t_prev(&t)) {
         formatted_warning("pdf backend", "page %d has been referenced but does not exist",obj_info(pdf, p->objptr));
     }
 }
 
-@ If the same keys in a dictionary are given several times, then it is not
-defined which value is choosen by an application. Therefore the keys |/Producer|
-and |/Creator| are only set if the token list |pdf_info_toks| converted to a
-string does not contain these key strings.
+/*tex
+
+    If the same keys in a dictionary are given several times, then it is not
+    defined which value is choosen by an application. Therefore the keys
+    |/Producer| and |/Creator| are only set if the token list |pdf_info_toks|
+    converted to a string does not contain these key strings.
+
+*/
 
-@c
 static boolean substr_of_str(const char *s, const char *t)
 {
     if (strstr(t, s) == NULL)
@@ -2146,9 +2077,8 @@ static boolean substr_of_str(const char *s, const char *t)
     return true;
 }
 
-static int pdf_print_info(PDF pdf, int luatexversion,
-                          str_number luatexrevision)
-{                               /* print info object */
+static int pdf_print_info(PDF pdf, int luatexversion, str_number luatexrevision)
+{
     boolean creator_given = false;
     boolean producer_given = false;
     boolean creationdate_given = false;
@@ -2158,7 +2088,7 @@ static int pdf_print_info(PDF pdf, int luatexversion,
     const char *p = NULL;
     int k, len = 0;
     k = pdf_create_obj(pdf, obj_type_info, 0);
-    pdf_begin_obj(pdf, k, 3);   /* keep Info readable unless explicitely forced */
+    pdf_begin_obj(pdf, k, 3);
     pdf_begin_dict(pdf);
     if (pdf_info_toks != 0) {
         s = tokenlist_to_cstring(pdf_info_toks, true, &len);
@@ -2178,18 +2108,18 @@ static int pdf_print_info(PDF pdf, int luatexversion,
     }
     if (pdf_info_toks != null) {
         if (len > 0) {
-            pdf_out(pdf, '\n');
+            pdf_check_space(pdf);
             pdf_puts(pdf, s);
-            pdf_out(pdf, '\n');
+            pdf_set_space(pdf);
             xfree(s);
         }
         delete_token_ref(pdf_info_toks);
         pdf_info_toks = null;
     }
     if (p && strlen(p) > 0) {
-        pdf_out(pdf, '\n');
-        pdf_puts(pdf, p); /* no free, pointer */
-        pdf_out(pdf, '\n');
+        pdf_check_space(pdf);
+        pdf_puts(pdf, p);
+        pdf_set_space(pdf);
     }
     if ((pdf_suppress_optional_info & 128) == 0 && !producer_given) {
         pdf_add_name(pdf, "Producer");
@@ -2223,7 +2153,8 @@ static void build_free_object_list(PDF pdf)
 {
     int k;
     int l = 0;
-    set_obj_fresh(pdf, l);      /* null object at begin of list of free objects */
+    /*tex A |null| object at the begin of a list of free objects. */
+    set_obj_fresh(pdf, l);
     for (k = 1; k <= pdf->obj_ptr; k++) {
         if (!is_obj_written(pdf, k)) {
             set_obj_link(pdf, l, k);
@@ -2233,272 +2164,297 @@ static void build_free_object_list(PDF pdf)
     set_obj_link(pdf, l, 0);
 }
 
-@ Now the finish of PDF output file. At this moment all Page objects
-are already written completely to PDF output file.
+/*tex
 
-@c
-void finish_pdf_file(PDF pdf, int luatexversion, str_number luatexrevision)
-{
-    int i, j, k;
-    int root, info, xref_stm = 0, outlines, threads, names_tree;
-    size_t xref_offset_width;
-    int callback_id = callback_defined(stop_run_callback);
-    int callback_id1 = callback_defined(finish_pdffile_callback);
-    if (total_pages == 0) {
-        if (callback_id == 0) {
-            normal_warning("pdf backend","no pages of output.");
-        } else if (callback_id > 0) {
-            run_callback(callback_id, "->");
-        }
-        if (pdf->gone > 0)
-            normal_error("pdf backend","dangling objects discarded, no output file produced.");
+    Now we can the finish of \PDF\ output file. At this moment all |/Page|
+    objects are already written completely to \PDF\ output file.
+
+*/
+
+void pdf_finish_file(PDF pdf, int fatal_error) {
+    if (fatal_error) {
+        remove_pdffile(static_pdf); /* will become remove_output_file */
+        print_err(" ==> Fatal error occurred, no output PDF file produced!");
     } else {
-        if (pdf->draftmode == 0) {
-            pdf_flush(pdf); /* to make sure that the output file name has been already created */
-            flush_jbig2_page0_objects(pdf); /* flush page 0 objects from JBIG2 images, if any */
-            if (callback_id1 > 0)
-                run_callback(callback_id1, "->");
-            check_nonexisting_pages(pdf);
-            check_nonexisting_destinations(pdf);
-            /* Output fonts definition */
-            for (k = 1; k <= max_font_id(); k++) {
-                if (font_used(k) && (pdf_font_num(k) < 0)) {
-                    i = -pdf_font_num(k);
-                    for (j = font_bc(k); j <= font_ec(k); j++)
-                        if (quick_char_exists(k, j) && pdf_char_marked(k, j))
-                            pdf_mark_char(i, j);
-                    if ((pdf_font_attr(i) == 0) && (pdf_font_attr(k) != 0)) {
-                        set_pdf_font_attr(i, pdf_font_attr(k));
-                    } else if ((pdf_font_attr(k) == 0) && (pdf_font_attr(i) != 0)) {
-                        set_pdf_font_attr(k, pdf_font_attr(i));
-                    } else if ((pdf_font_attr(i) != 0) && (pdf_font_attr(k) != 0) && (!str_eq_str(pdf_font_attr(i), pdf_font_attr(k)))) {
-                        formatted_warning("pdf backend","fontattr of font %d and %d are conflicting, %k is used",i,k,i);
-                    }
-                }
+        int i, j, k;
+        int root, info;
+        int xref_stm = 0;
+        int outlines = 0;
+        int threads = 0;
+        int names_tree = 0;
+        size_t xref_offset_width;
+        int luatexversion = luatex_version;
+        str_number luatexrevision = get_luatexrevision();
+        int callback_id = callback_defined(stop_run_callback);
+        int callback_id1 = callback_defined(finish_pdffile_callback);
+        if (total_pages == 0 && !pdf->force_file) {
+            if (callback_id == 0) {
+                normal_warning("pdf backend","no pages of output.");
+            } else if (callback_id > 0) {
+                run_callback(callback_id, "->");
             }
-            pdf->gen_tounicode = pdf_gen_tounicode;
-            pdf->omit_cidset = pdf_omit_cidset;
-            k = pdf->head_tab[obj_type_font];
-            while (k != 0) {
-                int f = obj_info(pdf, k);
-                do_pdf_font(pdf, f);
-                k = obj_link(pdf, k);
+            if (pdf->gone > 0) {
+                /* number of bytes gone */
+                normal_error("pdf backend","already written content discarded, no output file produced.");
             }
-            write_fontstuff(pdf);
-            pdf->last_pages = output_pages_tree(pdf);
-            /* Output outlines */
-            outlines = print_outlines(pdf);
-            /*
-                Output name tree. The name tree is very similiar to Pages tree so
-                its construction should be certain from Pages tree construction.
-                For intermediate node |obj_info| will be the first name and
-                |obj_link| will be the last name in \.{\\Limits} array. Note that
-                |pdf_dest_names_ptr| will be less than |obj_ptr|, so we test if
-                |k < pdf_dest_names_ptr| then |k| is index of leaf in
-                |dest_names|; else |k| will be index in |obj_tab| of some
-                intermediate node.
-             */
-            names_tree = output_name_tree(pdf);
-
-            /* Output article threads */
-            if (pdf->head_tab[obj_type_thread] != 0) {
-                threads = pdf_create_obj(pdf, obj_type_others, 0);
-                pdf_begin_obj(pdf, threads, OBJSTM_ALWAYS);
-                pdf_begin_array(pdf);
-                k = pdf->head_tab[obj_type_thread];
-                while (k != 0) {
-                    pdf_add_ref(pdf, k);
-                    k = obj_link(pdf, k);
+        } else {
+            if (pdf->draftmode == 0) {
+                /*tex We make sure that the output file name has been already created. */
+                pdf_flush(pdf);
+                /*tex Flush page 0 objects from JBIG2 images, if any. */
+                flush_jbig2_page0_objects(pdf);
+                if (callback_id1 > 0) {
+                    run_callback(callback_id1, "->");
                 }
-                pdf_end_array(pdf);
-                pdf_end_obj(pdf);
-                k = pdf->head_tab[obj_type_thread];
+                if (total_pages > 0) {
+                    check_nonexisting_pages(pdf);
+                    check_nonexisting_destinations(pdf);
+                }
+                /*tex Output fonts definition. */
+                for (k = 1; k <= max_font_id(); k++) {
+                    if (font_used(k) && (pdf_font_num(k) < 0)) {
+                        i = -pdf_font_num(k);
+                        for (j = font_bc(k); j <= font_ec(k); j++)
+                            if (quick_char_exists(k, j) && pdf_char_marked(k, j))
+                                pdf_mark_char(i, j);
+                        if ((pdf_font_attr(i) == 0) && (pdf_font_attr(k) != 0)) {
+                            set_pdf_font_attr(i, pdf_font_attr(k));
+                        } else if ((pdf_font_attr(k) == 0) && (pdf_font_attr(i) != 0)) {
+                            set_pdf_font_attr(k, pdf_font_attr(i));
+                        } else if ((pdf_font_attr(i) != 0) && (pdf_font_attr(k) != 0) && (!str_eq_str(pdf_font_attr(i), pdf_font_attr(k)))) {
+                            formatted_warning("pdf backend","fontattr of font %d and %d are conflicting, %k is used",i,k,i);
+                        }
+                    }
+                }
+                pdf->gen_tounicode = pdf_gen_tounicode;
+                pdf->omit_cidset = pdf_omit_cidset;
+                pdf->omit_charset = pdf_omit_charset;
+                k = pdf->head_tab[obj_type_font];
                 while (k != 0) {
-                    out_thread(pdf, k);
+                    int f = obj_info(pdf, k);
+                    do_pdf_font(pdf, f);
                     k = obj_link(pdf, k);
                 }
-            } else {
-                threads = 0;
-            }
-            /* Output the /Catalog object */
-            root = pdf_create_obj(pdf, obj_type_catalog, 0);
-            pdf_begin_obj(pdf, root, OBJSTM_ALWAYS);
-            pdf_begin_dict(pdf);
-            pdf_dict_add_name(pdf, "Type", "Catalog");
-            pdf_dict_add_ref(pdf, "Pages", pdf->last_pages);
-            if (threads != 0)
-                pdf_dict_add_ref(pdf, "Threads", threads);
-            if (outlines != 0)
-                pdf_dict_add_ref(pdf, "Outlines", outlines);
-            if (names_tree != 0)
-                pdf_dict_add_ref(pdf, "Names", names_tree);
-            if (pdf_catalog_toks != null) {
-                pdf_print_toks(pdf, pdf_catalog_toks);
-                delete_token_ref(pdf_catalog_toks);
-                pdf_catalog_toks = null;
-            }
-            print_pdf_table_string(pdf, "catalog");
-            if (pdf_catalog_openaction != 0)
-                pdf_dict_add_ref(pdf, "OpenAction", pdf_catalog_openaction);
-            pdf_end_dict(pdf);
-            pdf_end_obj(pdf);
-            /* last candidate for object stream */
-            info = pdf_print_info(pdf, luatexversion, luatexrevision);
-            /* final object for pdf->os_enable == false */
-            if (pdf->os_enable) {
-                pdf_buffer_select(pdf, OBJSTM_BUF);
-                pdf_os_write_objstream(pdf);
-                pdf_flush(pdf);
-                pdf_buffer_select(pdf, PDFOUT_BUF);
-                /* Output the cross-reference stream dictionary */
-                xref_stm = pdf_create_obj(pdf, obj_type_others, 0);
-                pdf_begin_obj(pdf, xref_stm, OBJSTM_NEVER);     /* final object for pdf->os_enable == true */
-                if ((obj_offset(pdf, pdf->obj_ptr) / 256) > 16777215)
-                    xref_offset_width = 5;
-                else if (obj_offset(pdf, pdf->obj_ptr) > 16777215)
-                    xref_offset_width = 4;
-                else if (obj_offset(pdf, pdf->obj_ptr) > 65535)
-                    xref_offset_width = 3;
-                else
-                    xref_offset_width = 2;
-                /* Build a linked list of free objects */
-                build_free_object_list(pdf);
+                write_fontstuff(pdf);
+                if (total_pages > 0) {
+                    pdf->last_pages = output_pages_tree(pdf);
+                    /*tex Output outlines. */
+                    outlines = print_outlines(pdf);
+                    /*tex
+                        The name tree is very similiar to Pages tree so its construction
+                        should be certain from Pages tree construction. For intermediate
+                        node |obj_info| will be the first name and |obj_link| will be the
+                        last name in \.{\\Limits} array. Note that |pdf_dest_names_ptr|
+                        will be less than |obj_ptr|, so we test if |k <
+                        pdf_dest_names_ptr| then |k| is index of leaf in |dest_names|;
+                        else |k| will be index in |obj_tab| of some intermediate node.
+                     */
+                    names_tree = output_name_tree(pdf);
+                    /*tex Output article threads. */
+                    if (pdf->head_tab[obj_type_thread] != 0) {
+                        threads = pdf_create_obj(pdf, obj_type_others, 0);
+                        pdf_begin_obj(pdf, threads, OBJSTM_ALWAYS);
+                        pdf_begin_array(pdf);
+                        k = pdf->head_tab[obj_type_thread];
+                        while (k != 0) {
+                            pdf_add_ref(pdf, k);
+                            k = obj_link(pdf, k);
+                        }
+                        pdf_end_array(pdf);
+                        pdf_end_obj(pdf);
+                        k = pdf->head_tab[obj_type_thread];
+                        while (k != 0) {
+                            out_thread(pdf, k);
+                            k = obj_link(pdf, k);
+                        }
+                    } else {
+                        threads = 0;
+                    }
+                }
+                /*tex Output the |/Catalog| object. */
+                root = pdf_create_obj(pdf, obj_type_catalog, 0);
+                pdf_begin_obj(pdf, root, OBJSTM_ALWAYS);
                 pdf_begin_dict(pdf);
-                pdf_dict_add_name(pdf, "Type", "XRef");
-                pdf_add_name(pdf, "Index");
-                pdf_begin_array(pdf);
-                pdf_add_int(pdf, 0);
-                pdf_add_int(pdf, pdf->obj_ptr + 1);
-                pdf_end_array(pdf);
-                pdf_dict_add_int(pdf, "Size", pdf->obj_ptr + 1);
-                pdf_add_name(pdf, "W");
-                pdf_begin_array(pdf);
-                pdf_add_int(pdf, 1);
-                pdf_add_int(pdf, (int) xref_offset_width);
-                pdf_add_int(pdf, 1);
-                pdf_end_array(pdf);
-                pdf_dict_add_ref(pdf, "Root", root);
-                pdf_dict_add_ref(pdf, "Info", info);
-                if (pdf_trailer_toks != null) {
-                    pdf_print_toks(pdf, pdf_trailer_toks);
-                    delete_token_ref(pdf_trailer_toks);
-                    pdf_trailer_toks = null;
+                pdf_dict_add_name(pdf, "Type", "Catalog");
+                if (total_pages > 0) {
+                    pdf_dict_add_ref(pdf, "Pages", pdf->last_pages);
+                    if (threads != 0) {
+                        pdf_dict_add_ref(pdf, "Threads", threads);
+                    }
+                    if (outlines != 0) {
+                        pdf_dict_add_ref(pdf, "Outlines", outlines);
+                    }
+                    if (names_tree != 0) {
+                        pdf_dict_add_ref(pdf, "Names", names_tree);
+                    }
+                    if (pdf_catalog_toks != null) {
+                        pdf_print_toks(pdf, pdf_catalog_toks);
+                        delete_token_ref(pdf_catalog_toks);
+                        pdf_catalog_toks = null;
+                    }
                 }
-                print_pdf_table_string(pdf, "trailer");
-                print_ID(pdf);
-                pdf_dict_add_streaminfo(pdf);
+                if (pdf_catalog_openaction != 0) {
+                    pdf_dict_add_ref(pdf, "OpenAction", pdf_catalog_openaction);
+                }
+                print_pdf_table_string(pdf, "catalog");
                 pdf_end_dict(pdf);
-                pdf_begin_stream(pdf);
-                for (k = 0; k <= pdf->obj_ptr; k++) {
-                    if (!is_obj_written(pdf, k)) {      /* a free object */
-                        pdf_out(pdf, 0);
-                        pdf_out_bytes(pdf, obj_link(pdf, k), xref_offset_width);
-                        pdf_out(pdf, 255);
-                    } else if (obj_os_idx(pdf, k) == PDF_OS_MAX_OBJS) { /* object not in object stream */
-                        pdf_out(pdf, 1);
-                        pdf_out_bytes(pdf, obj_offset(pdf, k),
-                                      xref_offset_width);
-                        pdf_out(pdf, 0);
-                    } else {    /* object in object stream */
-                        pdf_out(pdf, 2);
-                        pdf_out_bytes(pdf, obj_offset(pdf, k),
-                                      xref_offset_width);
-                        pdf_out(pdf, obj_os_idx(pdf, k));
+                pdf_end_obj(pdf);
+                info = pdf_print_info(pdf, luatexversion, luatexrevision);
+                if (pdf->os_enable) {
+                    pdf_buffer_select(pdf, OBJSTM_BUF);
+                    pdf_os_write_objstream(pdf);
+                    pdf_flush(pdf);
+                    pdf_buffer_select(pdf, PDFOUT_BUF);
+                    /*tex Output the cross-reference stream dictionary. */
+                    xref_stm = pdf_create_obj(pdf, obj_type_others, 0);
+                    pdf_begin_obj(pdf, xref_stm, OBJSTM_NEVER);
+                    if ((obj_offset(pdf, pdf->obj_ptr) / 256) > 16777215)
+                        xref_offset_width = 5;
+                    else if (obj_offset(pdf, pdf->obj_ptr) > 16777215)
+                        xref_offset_width = 4;
+                    else if (obj_offset(pdf, pdf->obj_ptr) > 65535)
+                        xref_offset_width = 3;
+                    else
+                        xref_offset_width = 2;
+                    /*tex Build a linked list of free objects. */
+                    build_free_object_list(pdf);
+                    pdf_begin_dict(pdf);
+                    pdf_dict_add_name(pdf, "Type", "XRef");
+                    pdf_add_name(pdf, "Index");
+                    pdf_begin_array(pdf);
+                    pdf_add_int(pdf, 0);
+                    pdf_add_int(pdf, pdf->obj_ptr + 1);
+                    pdf_end_array(pdf);
+                    pdf_dict_add_int(pdf, "Size", pdf->obj_ptr + 1);
+                    pdf_add_name(pdf, "W");
+                    pdf_begin_array(pdf);
+                    pdf_add_int(pdf, 1);
+                    pdf_add_int(pdf, (int) xref_offset_width);
+                    pdf_add_int(pdf, 1);
+                    pdf_end_array(pdf);
+                    pdf_dict_add_ref(pdf, "Root", root);
+                    pdf_dict_add_ref(pdf, "Info", info);
+                    if (pdf_trailer_toks != null) {
+                        pdf_print_toks(pdf, pdf_trailer_toks);
+                        delete_token_ref(pdf_trailer_toks);
+                        pdf_trailer_toks = null;
+                    }
+                    print_pdf_table_string(pdf, "trailer");
+                    print_ID(pdf);
+                    pdf_dict_add_streaminfo(pdf);
+                    pdf_end_dict(pdf);
+                    pdf_begin_stream(pdf);
+                    for (k = 0; k <= pdf->obj_ptr; k++) {
+                        if (!is_obj_written(pdf, k)) {
+                            /*tex A free object: */
+                            pdf_out(pdf, 0);
+                            pdf_out_bytes(pdf, obj_link(pdf, k), xref_offset_width);
+                            pdf_out(pdf, 255);
+                        } else if (obj_os_idx(pdf, k) == PDF_OS_MAX_OBJS) {
+                            /*tex  An object not in object stream: */
+                            pdf_out(pdf, 1);
+                            pdf_out_bytes(pdf, obj_offset(pdf, k), xref_offset_width);
+                            pdf_out(pdf, 0);
+                        } else {
+                            /*tex An object in object stream: */
+                            pdf_out(pdf, 2);
+                            pdf_out_bytes(pdf, obj_offset(pdf, k), xref_offset_width);
+                            pdf_out(pdf, obj_os_idx(pdf, k));
+                        }
+                    }
+                    pdf_end_stream(pdf);
+                    pdf_end_obj(pdf);
+                    pdf_flush(pdf);
+                } else {
+                    /*tex Output the |obj_tab| and build a linked list of free objects. */
+                    build_free_object_list(pdf);
+                    pdf_save_offset(pdf);
+                    pdf_puts(pdf, "xref\n");
+                    pdf_puts(pdf, "0 ");
+                    pdf_print_int_ln(pdf, pdf->obj_ptr + 1);
+                    pdf_print_fw_int(pdf, obj_link(pdf, 0));
+                    pdf_puts(pdf, " 65535 f \n");
+                    for (k = 1; k <= pdf->obj_ptr; k++) {
+                        if (!is_obj_written(pdf, k)) {
+                            pdf_print_fw_int(pdf, obj_link(pdf, k));
+                            pdf_puts(pdf, " 00000 f \n");
+                        } else {
+                            pdf_print_fw_int(pdf, obj_offset(pdf, k));
+                            pdf_puts(pdf, " 00000 n \n");
+                        }
                     }
                 }
-                pdf_end_stream(pdf);
-                pdf_end_obj(pdf);
-                pdf_flush(pdf);
-            } else {
-                /* Output the |obj_tab| and build a linked list of free objects */
-                build_free_object_list(pdf);
-                pdf_save_offset(pdf);
-                pdf_puts(pdf, "xref\n");
-                pdf_puts(pdf, "0 ");
-                pdf_print_int_ln(pdf, pdf->obj_ptr + 1);
-                pdf_print_fw_int(pdf, obj_link(pdf, 0));
-                pdf_puts(pdf, " 65535 f \n");
-                for (k = 1; k <= pdf->obj_ptr; k++) {
-                    if (!is_obj_written(pdf, k)) {
-                        pdf_print_fw_int(pdf, obj_link(pdf, k));
-                        pdf_puts(pdf, " 00000 f \n");
-                    } else {
-                        pdf_print_fw_int(pdf, obj_offset(pdf, k));
-                        pdf_puts(pdf, " 00000 n \n");
+                /*tex Output the trailer. */
+                if (!pdf->os_enable) {
+                    pdf_puts(pdf, "trailer\n");
+                    pdf_reset_space(pdf);
+                    pdf_begin_dict(pdf);
+                    pdf_dict_add_int(pdf, "Size", pdf->obj_ptr + 1);
+                    pdf_dict_add_ref(pdf, "Root", root);
+                    pdf_dict_add_ref(pdf, "Info", info);
+                    if (pdf_trailer_toks != null) {
+                        pdf_print_toks(pdf, pdf_trailer_toks);
+                        delete_token_ref(pdf_trailer_toks);
+                        pdf_trailer_toks = null;
                     }
+                    print_ID(pdf);
+                    pdf_end_dict(pdf);
+                    pdf_out(pdf, '\n');
                 }
-            }
-            /* Output the trailer */
-            if (!pdf->os_enable) {
-                pdf_puts(pdf, "trailer\n");
-                pdf_begin_dict(pdf);
-                pdf_dict_add_int(pdf, "Size", pdf->obj_ptr + 1);
-                pdf_dict_add_ref(pdf, "Root", root);
-                pdf_dict_add_ref(pdf, "Info", info);
-                if (pdf_trailer_toks != null) {
-                    pdf_print_toks(pdf, pdf_trailer_toks);
-                    delete_token_ref(pdf_trailer_toks);
-                    pdf_trailer_toks = null;
+                pdf_puts(pdf, "startxref\n");
+                pdf_reset_space(pdf);
+                if (pdf->os_enable)
+                    pdf_add_longint(pdf, (longinteger) obj_offset(pdf, xref_stm));
+                else
+                    pdf_add_longint(pdf, (longinteger) pdf->save_offset);
+                pdf_puts(pdf, "\n%%EOF\n");
+                pdf_flush(pdf);
+                if (callback_id == 0) {
+                    tprint_nl("Output written on ");
+                    tprint(pdf->file_name);
+                    tprint(" (");
+                    print_int(total_pages);
+                    tprint(" page");
+                    if (total_pages != 1)
+                        print_char('s');
+                    tprint(", ");
+                    print_int(pdf_offset(pdf));
+                    tprint(" bytes).");
+                    print_ln();
+                } else if (callback_id > 0) {
+                    run_callback(callback_id, "->");
                 }
-                print_ID(pdf);
-                pdf_end_dict(pdf);
-                pdf_out(pdf, '\n');
-            }
-            pdf_puts(pdf, "startxref\n");
-            pdf->cave = 0;
-            if (pdf->os_enable)
-                pdf_add_longint(pdf, (longinteger) obj_offset(pdf, xref_stm));
-            else
-                pdf_add_longint(pdf, (longinteger) pdf->save_offset);
-            pdf_puts(pdf, "\n%%EOF\n");
-            pdf_flush(pdf);
-            if (callback_id == 0) {
-                tprint_nl("Output written on ");
-                tprint(pdf->file_name);
-                tprint(" (");
-                print_int(total_pages);
-                tprint(" page");
-                if (total_pages != 1)
-                    print_char('s');
-                tprint(", ");
-                print_int(pdf_offset(pdf));
-                tprint(" bytes).");
-                print_ln();
-            } else if (callback_id > 0) {
-                run_callback(callback_id, "->");
-            }
-        } else {
-            if (callback_id > 0) {
-                run_callback(callback_id, "->");
+                libpdffinish(pdf);
+                close_file(pdf->file);
+            } else {
+                if (callback_id > 0) {
+                    run_callback(callback_id, "->");
+                }
+                libpdffinish(pdf);
+                normal_warning("pdf backend","draftmode enabled, not changing output pdf");
             }
         }
-        libpdffinish(pdf);
-        if (pdf->draftmode == 0)
-            close_file(pdf->file);
-        else
-            normal_warning("pdf backend","draftmode enabled, not changing output pdf");
-    }
-    if (callback_id == 0) {
-        if (log_opened_global) {
-            fprintf(log_file, "\nPDF statistics: %d PDF objects out of %d (max. %d)\n",
-                (int) pdf->obj_ptr, (int) pdf->obj_tab_size,
-                (int) sup_obj_tab_size);
-            if (pdf->os->ostm_ctr > 0) {
-                fprintf(log_file, " %d compressed objects within %d object stream%s\n",
-                    (int) pdf->os->o_ctr, (int) pdf->os->ostm_ctr,
-                    (pdf->os->ostm_ctr > 1 ? "s" : ""));
+        if (callback_id == 0) {
+            if (log_opened_global) {
+                fprintf(log_file, "\nPDF statistics: %d PDF objects out of %d (max. %d)\n",
+                    (int) pdf->obj_ptr, (int) pdf->obj_tab_size,
+                    (int) sup_obj_tab_size);
+                if (pdf->os->ostm_ctr > 0) {
+                    fprintf(log_file, " %d compressed objects within %d object stream%s\n",
+                        (int) pdf->os->o_ctr, (int) pdf->os->ostm_ctr,
+                        (pdf->os->ostm_ctr > 1 ? "s" : ""));
+                }
+                fprintf(log_file, " %d named destinations out of %d (max. %d)\n",
+                    (int) pdf->dest_names_ptr, (int) pdf->dest_names_size,
+                    (int) sup_dest_names_size);
+                fprintf(log_file, " %d words of extra memory for PDF output out of %d (max. %d)\n",
+                    (int) pdf->mem_ptr, (int) pdf->mem_size,
+                    (int) sup_pdf_mem_size);
             }
-            fprintf(log_file, " %d named destinations out of %d (max. %d)\n",
-                (int) pdf->dest_names_ptr, (int) pdf->dest_names_size,
-                (int) sup_dest_names_size);
-            fprintf(log_file, " %d words of extra memory for PDF output out of %d (max. %d)\n",
-                (int) pdf->mem_ptr, (int) pdf->mem_size,
-                (int) sup_pdf_mem_size);
         }
     }
 }
 
-@ @c
 void scan_pdfcatalog(PDF pdf)
 {
     halfword p;
@@ -2518,3 +2474,43 @@ void scan_pdfcatalog(PDF pdf)
         }
     }
 }
+
+/*tex
+
+    This function converts double to pdffloat; very small and very large numbers
+    are {\em not} converted to scientific notation. Here n must be a number or
+    real conforming to the implementation limits of \PDF\ as specified in
+    appendix C.1 of the \PDF\ standard. The maximum value of ints is |+2^32|, the
+    maximum value of reals is |+2^15| and the smallest values of reals is
+    |1/(2^16)|.
+
+*/
+
+static pdffloat conv_double_to_pdffloat(double n)
+{
+    pdffloat a;
+    a.e = 6;
+    a.m = i64round(n * ten_pow[a.e]);
+    return a;
+}
+
+void pdf_add_real(PDF pdf, double d)
+{
+    pdf_check_space(pdf);
+    print_pdffloat(pdf, conv_double_to_pdffloat(d));
+    pdf_set_space(pdf);
+}
+
+void pdf_push_list(PDF pdf, scaledpos *saved_pos, int *saved_loc) {
+    /* nothing */
+}
+
+void pdf_pop_list(PDF pdf, scaledpos *saved_pos, int *saved_loc) {
+    /* nothing */
+}
+
+extern void pdf_set_reference_point(PDF pdf, posstructure *refpoint)
+{
+    refpoint->pos.h = pdf_h_origin;
+    refpoint->pos.v = pdf->page_size.v - pdf_v_origin;
+}
diff --git a/texk/web2c/luatexdir/pdf/pdfglyph.w b/texk/web2c/luatexdir/pdf/pdfglyph.c
similarity index 63%
rename from texk/web2c/luatexdir/pdf/pdfglyph.w
rename to texk/web2c/luatexdir/pdf/pdfglyph.c
index 0703beed2..c7cf04392 100644
--- a/texk/web2c/luatexdir/pdf/pdfglyph.w
+++ b/texk/web2c/luatexdir/pdf/pdfglyph.c
@@ -1,40 +1,47 @@
-% pdfglyph.w
-%
-% Copyright 2009-2011 Taco Hoekwater <taco@@luatex.org>
-%
-% This file is part of LuaTeX.
-%
-% LuaTeX is free software; you can redistribute it and/or modify it under
-% the terms of the GNU General Public License as published by the Free
-% Software Foundation; either version 2 of the License, or (at your
-% option) any later version.
-%
-% LuaTeX is distributed in the hope that it will be useful, but WITHOUT
-% ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-% FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
-% License for more details.
-%
-% You should have received a copy of the GNU General Public License along
-% with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
-
-@ @c
+/*
+
+Copyright 2009-2011 Taco Hoekwater <taco@luatex.org>
+
+This file is part of LuaTeX.
+
+LuaTeX is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 2 of the License, or (at your
+option) any later version.
+
+LuaTeX is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+License for more details.
+
+You should have received a copy of the GNU General Public License along
+with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+
+*/
 
 #include "ptexlib.h"
 #include "pdf/pdfpage.h"
 
-@ eternal constants
+/*tex
 
-@c
-#define e_tj 3 /* must be 3; movements in []TJ are in fontsize/$10^3$ units */
+    The |e_tj| step must be 3 because movements in |[]TJ| are in fontsize/$10^3$
+    units.
+
+*/
+
+#define e_tj 3
+
+/*tex
+
+    Use exactly this formula also for calculating the |/Width| array values.
+
+*/
 
-@ @c
 static int64_t pdf_char_width(pdfstructure * p, internal_font_number f, int i)
 {
-    /* use exactly this formula also for calculating the /Width array values */
     return i64round((double) char_width(f, i) / font_size(f) * ten_pow[e_tj + p->cw.e]);
 }
 
-@ @c
 void pdf_print_charwidth(PDF pdf, internal_font_number f, int i)
 {
     pdffloat cw;
@@ -44,13 +51,11 @@ void pdf_print_charwidth(PDF pdf, internal_font_number f, int i)
     print_pdffloat(pdf, cw);
 }
 
-@ @c
 static void setup_fontparameters(PDF pdf, internal_font_number f, int ex_glyph)
 {
-    float slant, extend, expand, scale = 1.0;
+    float slant, extend, squeeze, expand, scale = 1.0;
     float u = 1.0;
     pdfstructure *p = pdf->pstruct;
-    /* fix mantis bug \# 0000200 (acroread "feature") */
     if ((font_format(f) == opentype_format || (font_format(f) == type1_format && font_encodingbytes(f) == 2))  && font_units_per_em(f) > 0)
         u = font_units_per_em(f) / 1000.0;
     pdf->f_cur = f;
@@ -58,35 +63,55 @@ static void setup_fontparameters(PDF pdf, internal_font_number f, int ex_glyph)
     p->fs.m = i64round(font_size(f) / u / by_one_bp * ten_pow[p->fs.e]);
     slant = font_slant(f) / 1000.0;
     extend = font_extend(f) / 1000.0;
+    squeeze = font_squeeze(f) / 1000.0;
     expand = 1.0 + (ex_glyph/1) / 1000.0;
-    p->tj_delta.e = p->cw.e - 1;        /* "- 1" makes less corrections inside []TJ */
-    /* no need to be more precise than TeX (1sp) */
-    while (p->tj_delta.e > 0 && (double) font_size(f) / ten_pow[p->tj_delta.e + e_tj] < 0.5)
-        p->tj_delta.e--;        /* happens for very tiny fonts */
+    /*tex The |-1| makes less corrections inside |[]TJ|: */
+    p->tj_delta.e = p->cw.e - 1;
+    /*tex There is no need to be more precise than \TEX\ (1sp). */
+    while (p->tj_delta.e > 0 && (double) font_size(f) / ten_pow[p->tj_delta.e + e_tj] < 0.5) {
+        /*tex This happens for very tiny fonts. */
+        p->tj_delta.e--;
+    }
     p->tm[0].m = i64round(scale * expand * extend * ten_pow[p->tm[0].e]);
     p->tm[2].m = i64round(slant * ten_pow[p->tm[2].e]);
-    p->tm[3].m = i64round(scale * ten_pow[p->tm[3].e]);
+    p->tm[3].m = i64round(scale * squeeze * ten_pow[p->tm[3].e]);
     p->k2 = ten_pow[e_tj + p->cw.e] * scale / (ten_pow[p->pdf.h.e] * pdf2double(p->fs) * pdf2double(p->tm[0]));
-    p->cur_ex = ex_glyph ;  /* we keep track of the state of ex */
+    /*tex We keep track of the state of ex. */
+    p->cur_ex = ex_glyph ;
+    p->need_width = font_width(f);
+    p->need_mode = font_mode(f);
 }
 
-
-@ @c
 static void set_font(PDF pdf)
 {
     pdfstructure *p = pdf->pstruct;
+
+    if (p->need_width != 0) {
+        pdf_printf(pdf, "%0.3f w\n",((7227.0/7200.0)/1000.0) * p->need_width );
+        p->done_width = 1;
+    } else if (p->done_width) {
+        pdf_puts(pdf, "0 w\n");
+        p->done_width = 0;
+    }
+    if (p->need_mode != 0) {
+        pdf_printf(pdf, "%d Tr\n", (int) p->need_mode);
+        p->done_mode = 1;
+    } else if (p->done_mode) {
+        pdf_puts(pdf, "0 Tr\n");
+        p->done_mode = 0;
+    }
     pdf_printf(pdf, "/F%d", (int) p->f_pdf);
     pdf_print_resname_prefix(pdf);
     pdf_out(pdf, ' ');
     print_pdffloat(pdf, p->fs);
-    pdf_puts(pdf, " Tf ");
+    pdf_puts(pdf, " Tf\n");
     p->f_pdf_cur = p->f_pdf;
     p->fs_cur.m = p->fs.m;
     p->need_tf = false;
-    p->need_tm = true; /* always follow Tf by Tm */
+    /*tex Always follow |Tf| by |Tm|: */
+    p->need_tm = true;
 }
 
-@ @c
 static void set_textmatrix(PDF pdf, scaledpos pos)
 {
     boolean move;
@@ -97,24 +122,27 @@ static void set_textmatrix(PDF pdf, scaledpos pos)
     if (p->need_tm || move) {
         print_pdf_matrix(pdf, p->tm);
         pdf_puts(pdf, " Tm ");
-        p->pdf.h.m = p->pdf_bt_pos.h.m + p->tm[4].m; /* Tm replaces */
+        /*tex |Tm| replaces */
+        p->pdf.h.m = p->pdf_bt_pos.h.m + p->tm[4].m;
         p->pdf.v.m = p->pdf_bt_pos.v.m + p->tm[5].m;
         p->need_tm = false;
     }
     p->tm0_cur.m = p->tm[0].m;
 }
 
-@ Print out a character to PDF buffer; the character will be printed in octal
-form in the following cases: chars <= 32, backslash (92), left parenthesis
-(40), and right parenthesis (41).
+/*tex
+
+    Print out a character to PDF buffer; the character will be printed in octal
+    form in the following cases: chars <= 32, backslash (92), left parenthesis
+    (40), and right parenthesis (41).
+
+*/
 
-@c
 static void pdf_print_char(PDF pdf, int c)
 {
-    if (c > 255)
+    if (c > 255) {
         return;
-    /* pdf_print_escaped(c) */
-    if (c <= 32 || c == '\\' || c == '(' || c == ')' || c > 127) {
+    } else if (c <= 32 || c == '\\' || c == '(' || c == ')' || c > 127) {
         pdf_room(pdf, 4);
         pdf_quick_out(pdf, '\\');
         pdf_quick_out(pdf, (unsigned char) ('0' + ((c >> 6) & 0x3)));
@@ -131,7 +159,6 @@ static void pdf_print_wide_char(PDF pdf, int c)
     pdf_out_block(pdf, (const char *) hex, 4);
 }
 
-@ @c
 static void begin_charmode(PDF pdf, internal_font_number f, pdfstructure * p)
 {
     if (!is_chararraymode(p))
@@ -146,7 +173,6 @@ static void begin_charmode(PDF pdf, internal_font_number f, pdfstructure * p)
     p->mode = PMODE_CHAR;
 }
 
-@ @c
 void end_charmode(PDF pdf)
 {
     pdfstructure *p = pdf->pstruct;
@@ -161,7 +187,6 @@ void end_charmode(PDF pdf)
     p->mode = PMODE_CHARARRAY;
 }
 
-@ @c
 static void begin_chararray(PDF pdf)
 {
     pdfstructure *p = pdf->pstruct;
@@ -173,7 +198,6 @@ static void begin_chararray(PDF pdf)
     p->mode = PMODE_CHARARRAY;
 }
 
-@ @c
 void end_chararray(PDF pdf)
 {
     pdfstructure *p = pdf->pstruct;
@@ -184,23 +208,32 @@ void end_chararray(PDF pdf)
     p->mode = PMODE_TEXT;
 }
 
-@ We need to adapt the tm when a font changes. A change can be a change in id
-(frontend) or pdf reference (backend, as we share font resources). At such a
-change we also need to adapt to the slant and extend. Initially we also need to
-take the exfactor of a glyph into account. When the font is unchanged, we still
-need to check each glyph for a change in exfactor. We store the current one on
-the state record so that we can minimize testing.
+/*tex
+
+    We need to adapt the tm when a font changes. A change can be a change in id
+    (frontend) or pdf reference (backend, as we share font resources). At such a
+    change we also need to adapt to the slant and extend. Initially we also need
+    to take the exfactor of a glyph into account. When the font is unchanged, we
+    still need to check each glyph for a change in exfactor. We store the current
+    one on the state record so that we can minimize testing.
+
+*/
 
-@c
 void pdf_place_glyph(PDF pdf, internal_font_number f, int c, int ex)
 {
     boolean move;
     pdfstructure *p = pdf->pstruct;
     scaledpos pos = pdf->posstruct->pos;
-    /* already done:
+    /*tex
+
+        This is already done:
+
+        \startyping
         if (!char_exists(f, c)) {
             return;
         }
+        \stoptyping
+
     */
     if (font_writingmode(f) == vertical_writingmode) {
         if (p->wmode != WMODE_V) {
@@ -221,8 +254,8 @@ void pdf_place_glyph(PDF pdf, internal_font_number f, int c, int ex)
          setup_fontparameters(pdf, f, ex);
          p->need_tm = true;
     }
-    /* all movements */
-    move = calc_pdfpos(p, pos); /* within text or chararray or char mode */
+    /*tex All movements within text or chararray or char mode: */
+    move = calc_pdfpos(p, pos);
     if (move || p->need_tm) {
         if (p->need_tm
         || (p->wmode == WMODE_H && (p->pdf_bt_pos.v.m + p->tm[5].m) != p->pdf.v.m)
@@ -231,7 +264,8 @@ void pdf_place_glyph(PDF pdf, internal_font_number f, int c, int ex)
             pdf_goto_textmode(pdf);
             set_textmatrix(pdf, pos);
             begin_chararray(pdf);
-            move = calc_pdfpos(p, pos); /* for fine adjustment */
+            /*tex For fine adjustment: */
+            move = calc_pdfpos(p, pos);
         }
         if (move) {
             if (is_charmode(p))
@@ -240,7 +274,7 @@ void pdf_place_glyph(PDF pdf, internal_font_number f, int c, int ex)
             p->cw.m -= p->tj_delta.m * ten_pow[p->cw.e - p->tj_delta.e];
         }
     }
-    /* glyph output */
+    /*tex Glyph output: */
     if (is_chararraymode(p))
         begin_charmode(pdf, f, p);
     else if (!is_charmode(p))
@@ -250,5 +284,6 @@ void pdf_place_glyph(PDF pdf, internal_font_number f, int c, int ex)
         pdf_print_wide_char(pdf, char_index(f, c));
     else
         pdf_print_char(pdf, c);
-    p->cw.m += pdf_char_width(p, p->f_pdf, c);  /* aka |adv_char_width()| */
+    /*tex Also known as |adv_char_width()|: */
+    p->cw.m += pdf_char_width(p, p->f_pdf, c);
 }
diff --git a/texk/web2c/luatexdir/pdf/pdfimage.w b/texk/web2c/luatexdir/pdf/pdfimage.c
similarity index 50%
rename from texk/web2c/luatexdir/pdf/pdfimage.w
rename to texk/web2c/luatexdir/pdf/pdfimage.c
index fd3642438..a8cffb0c8 100644
--- a/texk/web2c/luatexdir/pdf/pdfimage.w
+++ b/texk/web2c/luatexdir/pdf/pdfimage.c
@@ -1,38 +1,39 @@
-% pdfimage.w
-%
-% Copyright 2009-2010 Taco Hoekwater <taco@@luatex.org>
-%
-% This file is part of LuaTeX.
-%
-% LuaTeX is free software; you can redistribute it and/or modify it under
-% the terms of the GNU General Public License as published by the Free
-% Software Foundation; either version 2 of the License, or (at your
-% option) any later version.
-%
-% LuaTeX is distributed in the hope that it will be useful, but WITHOUT
-% ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-% FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
-% License for more details.
-%
-% You should have received a copy of the GNU General Public License along
-% with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+/*
 
-@ @c
+Copyright 2009-2010 Taco Hoekwater <taco@luatex.org>
+
+This file is part of LuaTeX.
+
+LuaTeX is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 2 of the License, or (at your
+option) any later version.
+
+LuaTeX is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+License for more details.
+
+You should have received a copy of the GNU General Public License along
+with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+
+*/
 
 #include "ptexlib.h"
 
-@ @c
 void place_img(PDF pdf, image_dict * idict, scaled_whd dim, int transform)
 {
-    float a[6];                 /* transformation matrix */
+    /*tex A transformation matrix: */
+    float a[6];
     float xoff, yoff, tmp;
     pdfstructure *p = pdf->pstruct;
     scaledpos pos = pdf->posstruct->pos;
-    int r;                      /* number of digits after the decimal point */
+    /*tex The number of digits after the decimal point: */
+    int r;
     int k;
     scaledpos tmppos;
     pdffloat cm[6];
-    int groupref;               /* added from web for 1.40.8 */
+    int groupref;
     a[0] = a[3] = 1.0e6;
     a[1] = a[2] = 0;
     if (img_type(idict) == IMG_TYPE_PDF || img_type(idict) == IMG_TYPE_PDFMEMSTREAM
@@ -43,48 +44,51 @@ void place_img(PDF pdf, image_dict * idict, scaled_whd dim, int transform)
         yoff = (float) img_yorig(idict) / (float) img_ysize(idict);
         r = 6;
     } else {
-        /* added from web for 1.40.8 */
         if (img_type(idict) == IMG_TYPE_PNG) {
             groupref = img_group_ref(idict);
             if ((groupref > 0) && (pdf->img_page_group_val == 0))
                 pdf->img_page_group_val = groupref;
         }
-        /* /added from web */
         a[0] /= (float) one_hundred_bp;
         a[3] = a[0];
         xoff = yoff = 0;
         r = 4;
     }
-    if ((transform & 7) > 3) { /* mirror cases */
+    if ((transform & 7) > 3) {
+        /*tex Mirror cases: */
         a[0] *= -1;
         xoff *= -1;
     }
     switch ((transform + img_rotation(idict)) & 3) {
-    case 0:                    /* no transform */
-        break;
-    case 1:                    /* rot. 90 deg. (counterclockwise) */
-        a[1] = a[0];
-        a[2] = -a[3];
-        a[3] = a[0] = 0;
-        tmp = yoff;
-        yoff = xoff;
-        xoff = -tmp;
-        break;
-    case 2:                    /* rot. 180 deg. (counterclockwise) */
-        a[0] *= -1;
-        a[3] *= -1;
-        xoff *= -1;
-        yoff *= -1;
-        break;
-    case 3:                    /* rot. 270 deg. (counterclockwise) */
-        a[1] = -a[0];
-        a[2] = a[3];
-        a[3] = a[0] = 0;
-        tmp = yoff;
-        yoff = -xoff;
-        xoff = tmp;
-        break;
-    default:;
+        case 0:
+            /*tex No transform. */
+            break;
+        case 1:
+            /*tex rotation over 90 degrees (counterclockwise) */
+            a[1] = a[0];
+            a[2] = -a[3];
+            a[3] = a[0] = 0;
+            tmp = yoff;
+            yoff = xoff;
+            xoff = -tmp;
+            break;
+        case 2:
+            /*tex rotation over 180 degrees (counterclockwise) */
+            a[0] *= -1;
+            a[3] *= -1;
+            xoff *= -1;
+            yoff *= -1;
+            break;
+        case 3:
+            /*tex rotation over 270 degrees (counterclockwise) */
+            a[1] = -a[0];
+            a[2] = a[3];
+            a[3] = a[0] = 0;
+            tmp = yoff;
+            yoff = -xoff;
+            xoff = tmp;
+            break;
+        default:;
     }
     xoff *= (float) dim.wd;
     yoff *= (float) (dim.ht + dim.dp);
@@ -98,21 +102,24 @@ void place_img(PDF pdf, image_dict * idict, scaled_whd dim, int transform)
     if ((transform & 7) > 3)
         k++;
     switch (k & 3) {
-    case 0:                    /* no transform */
-        break;
-    case 1:                    /* rot. 90 deg. (counterclockwise) */
-        a[4] += (float) dim.wd;
-        break;
-    case 2:                    /* rot. 180 deg. */
-        a[4] += (float) dim.wd;
-        a[5] += (float) (dim.ht + dim.dp);
-        break;
-    case 3:                    /* rot. 270 deg. */
-        a[5] += (float) (dim.ht + dim.dp);
-        break;
-    default:;
+        case 0:
+            /*tex No transform */
+            break;
+        case 1:
+            /*tex rotation over 90 degrees (counterclockwise) */
+            a[4] += (float) dim.wd;
+            break;
+        case 2:
+            /*tex rotation over 180 degrees (counterclockwise) */
+            a[4] += (float) dim.wd;
+            a[5] += (float) (dim.ht + dim.dp);
+            break;
+        case 3:
+            /*tex rotation over 270 degrees (counterclockwise) */
+            a[5] += (float) (dim.ht + dim.dp);
+            break;
+        default:;
     }
-    /* the following is a kludge, TODO: use pdfpage.c functions */
     setpdffloat(cm[0], i64round(a[0]), r);
     setpdffloat(cm[1], i64round(a[1]), r);
     setpdffloat(cm[2], i64round(a[2]), r);
@@ -124,7 +131,7 @@ void place_img(PDF pdf, image_dict * idict, scaled_whd dim, int transform)
     cm[4] = p->cm[4];
     cm[5] = p->cm[5];
     if (pdf->img_page_group_val == 0)
-        pdf->img_page_group_val = img_group_ref(idict); /* added from web for 1.40.8 */
+        pdf->img_page_group_val = img_group_ref(idict);
     pdf_puts(pdf, "q\n");
     pdf_print_cm(pdf, cm);
     pdf_puts(pdf, "/Im");
@@ -136,9 +143,8 @@ void place_img(PDF pdf, image_dict * idict, scaled_whd dim, int transform)
         img_state(idict) = DICT_OUTIMG;
 }
 
-@ for normal output, see \.{pdflistout.w}
+/*tex For normal output see |pdflistout.c|: */
 
-@c
 void pdf_place_image(PDF pdf, halfword p)
 {
     scaled_whd dim;
diff --git a/texk/web2c/luatexdir/pdf/pdflink.w b/texk/web2c/luatexdir/pdf/pdflink.c
similarity index 69%
rename from texk/web2c/luatexdir/pdf/pdflink.w
rename to texk/web2c/luatexdir/pdf/pdflink.c
index b21d0774e..55521b176 100644
--- a/texk/web2c/luatexdir/pdf/pdflink.w
+++ b/texk/web2c/luatexdir/pdf/pdflink.c
@@ -1,31 +1,34 @@
-% pdflink.w
-%
-% Copyright 2009-2012 Taco Hoekwater <taco@@luatex.org>
-%
-% This file is part of LuaTeX.
-%
-% LuaTeX is free software; you can redistribute it and/or modify it under
-% the terms of the GNU General Public License as published by the Free
-% Software Foundation; either version 2 of the License, or (at your
-% option) any later version.
-%
-% LuaTeX is distributed in the hope that it will be useful, but WITHOUT
-% ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-% FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
-% License for more details.
-%
-% You should have received a copy of the GNU General Public License along
-% with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
-
-@ @c
+/*
+
+Copyright 2009-2012 Taco Hoekwater <taco@@luatex.org>
+
+This file is part of LuaTeX.
+
+LuaTeX is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 2 of the License, or (at your
+option) any later version.
+
+LuaTeX is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+License for more details.
+
+You should have received a copy of the GNU General Public License along
+with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+
+*/
 
 #include "ptexlib.h"
 
-@ To implement nested link annotations, we need a stack to hold copy of
-|pdf_start_link_node|'s that are being written out, together with their box
-nesting level.
+/*tex
+
+    To implement nested link annotations, we need a stack to hold copy of
+    |pdf_start_link_node|'s that are being written out, together with their box
+    nesting level.
+
+*/
 
-@c
 void push_link_level(PDF pdf, halfword p)
 {
     if (pdf->link_stack_ptr >= pdf_max_link_level)
@@ -36,14 +39,12 @@ void push_link_level(PDF pdf, halfword p)
     pdf->link_stack[pdf->link_stack_ptr].ref_link_node = p;
 }
 
-@ @c
 void pop_link_level(PDF pdf)
 {
     flush_node_list(pdf->link_stack[pdf->link_stack_ptr].link_node);
     pdf->link_stack_ptr--;
 }
 
-@ @c
 void do_link(PDF pdf, halfword p, halfword parent_box, scaledpos cur)
 {
     scaled_whd alt_rule;
@@ -59,13 +60,13 @@ void do_link(PDF pdf, halfword p, halfword parent_box, scaledpos cur)
     alt_rule.ht = height(p);
     alt_rule.dp = depth(p);
     set_rect_dimens(pdf, p, parent_box, cur, alt_rule, pdf_link_margin);
-    obj_annot_ptr(pdf, pdf_link_objnum(p)) = p; /* the reference for the pdf annot object must be set here */
+    /*tex The reference for the annot object must be set here. */
+    obj_annot_ptr(pdf, pdf_link_objnum(p)) = p;
     k = pdf_link_objnum(p);
     set_obj_scheduled(pdf, pdf_link_objnum(p));
     addto_page_resources(pdf, obj_type_link, k);
 }
 
-@ @c
 void end_link(PDF pdf, halfword p)
 {
     halfword q;
@@ -76,10 +77,10 @@ void end_link(PDF pdf, halfword p)
         normal_error("pdf backend","pdf link_stack empty, 'endlink' used without 'startlink'");
     if (pdf->link_stack[pdf->link_stack_ptr].nesting_level != cur_s)
         normal_error("pdf backend","'endlink' ended up in different nesting level than 'startlink'");
-    /*
-        NOTA BENE: test for running link must be done on |link_node| and not
+    /*tex
+        The test for running link must be done on |link_node| and not
         |ref_link_node|, as |ref_link_node| can be set by |do_link| or
-        |append_link| already
+        |append_link| already.
     */
     if (is_running(width(pdf->link_stack[pdf->link_stack_ptr].link_node))) {
         q = pdf->link_stack[pdf->link_stack_ptr].ref_link_node;
@@ -110,15 +111,16 @@ void end_link(PDF pdf, halfword p)
     pop_link_level(pdf);
 }
 
-@ For ``running'' annotations we must append a new node when the end of
-annotation is in other box than its start. The new created node is identical to
-corresponding whatsit node representing the start of annotation, but its |info|
-field is |max_halfword|. We set |info| field just before destroying the node, in
-order to use |flush_node_list| to do the job.
+/*tex
+
+    For ``running'' annotations we must append a new node when the end of
+    annotation is in other box than its start. The new created node is identical
+    to corresponding whatsit node representing the start of annotation, but its
+    |info| field is |max_halfword|. We set |info| field just before destroying
+    the node, in order to use |flush_node_list| to do the job.
 
-@ Append a new pdf annot to |pdf_link_list|.
+*/
 
-@c
 void append_link(PDF pdf, halfword parent_box, scaledpos cur, small_number i)
 {
     halfword p;
@@ -126,7 +128,8 @@ void append_link(PDF pdf, halfword parent_box, scaledpos cur, small_number i)
     scaled_whd alt_rule;
     p = copy_node(pdf->link_stack[(int) i].link_node);
     pdf->link_stack[(int) i].ref_link_node = p;
-    subtype(p) = pdf_link_data_node;    /* this node is not a normal link node */
+    /*tex This node is not a normal link node. */
+    subtype(p) = pdf_link_data_node;
     alt_rule.wd = width(p);
     alt_rule.ht = height(p);
     alt_rule.dp = depth(p);
@@ -137,7 +140,6 @@ void append_link(PDF pdf, halfword parent_box, scaledpos cur, small_number i)
     addto_page_resources(pdf, obj_type_link, k);
 }
 
-@ @c
 void scan_startlink(PDF pdf)
 {
     int k;
@@ -155,10 +157,9 @@ void scan_startlink(PDF pdf)
     set_pdf_link_action(cur_list.tail_field, r);
     set_pdf_link_objnum(cur_list.tail_field, k);
     pdf_last_link = k;
-    /*
-        NOTA BENE: although it is possible to set |obj_annot_ptr(k) := tail|
-        here, it is not safe if nodes are later copied/destroyed/moved; a better
-        place to do this is inside |do_link|, when the whatsit node is written
-        out
+    /*tex
+        Although it is possible to set |obj_annot_ptr(k) := tail| here, it is not
+        safe if nodes are later copied/destroyed/moved; a better place to do this
+        is inside |do_link|, when the whatsit node is written out.
     */
 }
diff --git a/texk/web2c/luatexdir/pdf/pdflistout.w b/texk/web2c/luatexdir/pdf/pdflistout.c
similarity index 66%
rename from texk/web2c/luatexdir/pdf/pdflistout.w
rename to texk/web2c/luatexdir/pdf/pdflistout.c
index 53ed24af6..9dbdaeefa 100644
--- a/texk/web2c/luatexdir/pdf/pdflistout.w
+++ b/texk/web2c/luatexdir/pdf/pdflistout.c
@@ -1,120 +1,48 @@
-% pdflistout.w
-%
-% Copyright 2009-2010 Taco Hoekwater <taco@@luatex.org>
-%
-% This file is part of LuaTeX.
-%
-% LuaTeX is free software; you can redistribute it and/or modify it under
-% the terms of the GNU General Public License as published by the Free
-% Software Foundation; either version 2 of the License, or (at your
-% option) any later version.
-%
-% LuaTeX is distributed in the hope that it will be useful, but WITHOUT
-% ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-% FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
-% License for more details.
-%
-% You should have received a copy of the GNU General Public License along
-% with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+/*
 
-\def\pdfTeX{pdf\TeX}
+Copyright 2009-2010 Taco Hoekwater <taco@luatex.org>
 
-@ @c
-#include "ptexlib.h"
+This file is part of LuaTeX.
 
-@ @c
-#define kern_width(q) width(q) + ex_kern(q)
+LuaTeX is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 2 of the License, or (at your
+option) any later version.
 
-/*
-    ext_xn_over_d(width(q), 1000000+ex_kern(q), 1000000);
-*/
+LuaTeX is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+License for more details.
 
-@ @c
-pos_info_structure pos_info; /* to be accessed from Lua */
+You should have received a copy of the GNU General Public License along
+with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
 
-static backend_struct *backend = NULL;
-backend_function *backend_out, *backend_out_whatsit;
+*/
 
-@ @c
-static void missing_backend_function(PDF pdf, halfword p)
-{
-    const char *n = get_node_name(type(p), subtype(p));
-    if (type(p) == whatsit_node)
-        formatted_error("pdf backend","no output function for whatsit %s",n);
-    else
-        formatted_error("pdf backend","no output function for node %s",n);
-}
+#include "ptexlib.h"
 
-@ @c
-static void init_none_backend_functions(void)
-{
-    backend_struct *p = &backend[OMODE_NONE];
-    p->name = strdup("(None)");
-}
+#define kern_width(q) width(q) + ex_kern(q)
 
-@ @c
-static void init_pdf_backend_functions(void)
-{
-    backend_struct *p = &backend[OMODE_PDF];
-    p->name = strdup("PDF");
-    p->node_fu[rule_node] = &pdf_place_rule;
-    p->node_fu[glyph_node] = &pdf_place_glyph;
-    p->whatsit_fu[special_node] = &pdf_special;
-    p->whatsit_fu[pdf_literal_node] = &pdf_out_literal;
-    p->whatsit_fu[pdf_refobj_node] = &pdf_ref_obj;
-    p->whatsit_fu[pdf_annot_node] = &do_annot;
-    p->whatsit_fu[pdf_start_link_node] = &do_link;
-    p->whatsit_fu[pdf_end_link_node] = &end_link;
-    p->whatsit_fu[pdf_dest_node] = &do_dest;
-    p->whatsit_fu[pdf_thread_node] = &do_thread;
-    p->whatsit_fu[pdf_end_thread_node] = &end_thread;
-    p->whatsit_fu[late_lua_node] = &late_lua;
-    p->whatsit_fu[pdf_colorstack_node] = &pdf_out_colorstack;
-    p->whatsit_fu[pdf_setmatrix_node] = &pdf_out_setmatrix;
-    p->whatsit_fu[pdf_save_node] = &pdf_out_save;
-    p->whatsit_fu[pdf_restore_node] = &pdf_out_restore;
-}
+#define billion 1000000000.0
 
-@ @c
-static void init_dvi_backend_functions(void)
-{
-    backend_struct *p = &backend[OMODE_DVI];
-    p->name = strdup("DVI");
-    p->node_fu[rule_node] = &dvi_place_rule;
-    p->node_fu[glyph_node] = &dvi_place_glyph;
-    p->whatsit_fu[special_node] = &dvi_special;
-    p->whatsit_fu[late_lua_node] = &late_lua;
-}
+#define vet_glue(A) do {         \
+    glue_temp=A;                 \
+    if (glue_temp>billion)       \
+      glue_temp=billion;         \
+    else if (glue_temp<-billion) \
+      glue_temp=-billion;        \
+  } while (0)
 
-@ @c
-void init_backend_functionpointers(output_mode o_mode)
-{
-    int i, j;
-    if (backend == NULL) {
-        backend = xmalloc((MAX_OMODE + 1) * sizeof(backend_struct));
-        for (i = 0; i <= MAX_OMODE; i++) {
-            backend[i].node_fu = xmalloc((MAX_NODE_TYPE + 1) * sizeof(backend_function));
-            backend[i].whatsit_fu = xmalloc((MAX_WHATSIT_TYPE + 1) * sizeof(backend_function));
-            for (j = 0; j < MAX_NODE_TYPE + 1; j++)
-                backend[i].node_fu[j] = &missing_backend_function;
-            for (j = 0; j < MAX_WHATSIT_TYPE + 1; j++)
-                backend[i].whatsit_fu[j] = &missing_backend_function;
-        }
-        init_none_backend_functions();
-        init_dvi_backend_functions();
-        init_pdf_backend_functions();
-    }
-    backend_out = backend[o_mode].node_fu;
-    backend_out_whatsit = backend[o_mode].whatsit_fu;
-}
+/*tex
+
+    This code scans forward to the ending |dir_node| while keeping track of the
+    needed width in |w|. When it finds the node that will end this segment, it
+    stores the accumulated with in the |dir_dvi_h| field of that end node, so
+    that when that node is found later in the processing, the correct glue
+    correction can be applied (obsolete).
 
-@ This code scans forward to the ending |dir_node| while keeping
-track of the needed width in |w|. When it finds the node that will end
-this segment, it stores the accumulated with in the |dir_dvi_h| field
-of that end node, so that when that node is found later in the
-processing, the correct glue correction can be applied (obsolete).
+*/
 
-@c
 static scaled simple_advance_width(halfword p)
 {
     halfword q = p;
@@ -124,8 +52,6 @@ static scaled simple_advance_width(halfword p)
         switch (type(q)) {
             case glyph_node:
                 w += glyph_width(q);
-/* experimental */
-w += x_advance(q);
                 break;
             case hlist_node:
             case vlist_node:
@@ -134,11 +60,11 @@ w += x_advance(q);
                 w += width(q);
                 break;
             case kern_node:
-                /* officially we should check the subtype */
+                /*tex Officially we should check the subtype. */
                 w += kern_width(q);
                 break;
             case disc_node:
-                /* hh: the frontend should append already */
+                /* (HH): The frontend should append already. */
                 if (vlink(no_break(q)) != null)
                     w += simple_advance_width(no_break(q));
             default:
@@ -148,13 +74,13 @@ w += x_advance(q);
     return w;
 }
 
-@ @c
 static halfword calculate_width_to_enddir(halfword p, real cur_glue, scaled cur_g, halfword this_box)
 {
     int dir_nest = 1;
     halfword q = p, enddir_ptr = p;
     scaled w = 0;
-    real glue_temp; /* glue value before rounding */
+    /*tex The glue value before rounding: */
+    real glue_temp;
     int g_sign = glue_sign(this_box);
     int g_order = glue_order(this_box);
     while ((q != null) && (vlink(q) != null)) {
@@ -172,18 +98,18 @@ static halfword calculate_width_to_enddir(halfword p, real cur_glue, scaled cur_
                     w += width(q);
                     break;
                 case kern_node:
-                    /* officially we should check the subtype */
+                    /*tex Officially we should check the subtype. */
                     w += kern_width(q);
                     break;
                 case math_node:
-                    /* begin mathskip code */
+                    /*tex Begin of |mathskip| code. */
                     if (glue_is_zero(q)) {
                         w += surround(q);
                         break;
                     } else {
-                        /* fall through: mathskip */
+                        /*tex Fall through |mathskip|. */
                     }
-                    /* end mathskip code */
+                    /*tex End of |mathskip| code. */
                 case glue_node:
                     w += width(q) - cur_g;
                     if (g_sign != normal) {
@@ -202,12 +128,12 @@ static halfword calculate_width_to_enddir(halfword p, real cur_glue, scaled cur_
                     w += cur_g;
                     break;
                 case disc_node:
-                    /* hh: the frontend should append already */
+                    /* (HH): The frontend should append already. */
                     if (vlink(no_break(q)) != null)
                         w += simple_advance_width(no_break(q));
                     break;
                 case dir_node:
-                    if (dir_dir(q) >= 0)
+                    if (subtype(q) == normal_dir)
                         dir_nest++;
                     else
                         dir_nest--;
@@ -223,123 +149,115 @@ static halfword calculate_width_to_enddir(halfword p, real cur_glue, scaled cur_
         }
     }
     if (enddir_ptr == p)
-        /* no enddir found, just transport w by begindir */
+        /*tex No enddir found, just transport |w| by |begindir|. */
         dir_cur_h(enddir_ptr) = w;
     return enddir_ptr;
 }
 
-@ The |out_what| procedure takes care of outputting the whatsit nodes for
-|vlist_out| and |hlist_out|, which are similar for either case.
+/*tex
+
+    The |out_what| procedure takes care of outputting the whatsit nodes for
+    |vlist_out| and |hlist_out|, which are similar for either case.
 
-We don't implement \.{\\write} inside of leaders. (The reason is that
-the number of times a leader box appears might be different in different
-implementations, due to machine-dependent rounding in the glue calculations.)
-@^leaders@>
+    We don't implement \.{\\write} inside of leaders. (The reason is that the
+    number of times a leader box appears might be different in different
+    implementations, due to machine-dependent rounding in the glue calculations.)
+
+*/
 
-@c
-void out_what(PDF pdf, halfword p)
+static void handle_backend_whatsit(PDF pdf, halfword p, halfword parent_box, scaledpos cur)
 {
-    switch (subtype(p)) {
-        case special_node:         /* |pdf_special(pdf, p)|; */
-        case late_lua_node:        /* |late_lua(pdf, p)|; */
-        case pdf_save_node:        /* |pdf_out_save(pdf, p)|; */
-        case pdf_restore_node:     /* |pdf_out_restore(pdf, p)|; */
-        case pdf_end_link_node:    /* |end_link(pdf, p)|; */
-        case pdf_end_thread_node:  /* |end_thread(pdf, p)|; */
-        case pdf_literal_node:     /* |pdf_out_literal(pdf, p)|; */
-        case pdf_colorstack_node:  /* |pdf_out_colorstack(pdf, p)|; */
-        case pdf_setmatrix_node:   /* |pdf_out_setmatrix(pdf, p)|; */
-        case pdf_refobj_node:      /* |pdf_ref_obj(pdf, p)| */
-            backend_out_whatsit[subtype(p)] (pdf, p);
-            break;
-        case open_node:
-        case write_node:
-        case close_node:
-            /* do some work that has been queued up for \.{\\write} */
-            if (!doing_leaders) {
-                int j = write_stream(p);
-                if (subtype(p) == write_node) {
-                    write_out(p);
-                } else if (subtype(p) == close_node) {
-                    close_write_file(j);
-                } else if (valid_write_file(j)) {
-                    char *fn;
-                    close_write_file(j);
-                    cur_name = open_name(p);
-                    cur_area = open_area(p);
-                    cur_ext = open_ext(p);
-                    if (cur_ext == get_nullstr())
-                        cur_ext = maketexstring(".tex");
-                    fn = pack_file_name(cur_name, cur_area, cur_ext);
-                    while (! open_write_file(j,fn)) {
-                        fn = prompt_file_name("output file name", ".tex");
-                    }
-                }
-            }
-            break;
-        case user_defined_node:
-            break;
-        default:
-            /* this should give an error about missing whatsit backend function */
-            backend_out_whatsit[subtype(p)] (pdf, p);
+    if (output_mode_used == OMODE_PDF) {
+        switch (subtype(p)) {
+            case pdf_literal_node:
+            case pdf_save_node:
+            case pdf_restore_node:
+            case pdf_setmatrix_node:
+            case pdf_colorstack_node:
+            case pdf_refobj_node:
+            case pdf_end_link_node:
+            case pdf_end_thread_node:
+                backend_out_whatsit[subtype(p)](pdf, p);
+                break;
+            case pdf_annot_node:
+            case pdf_start_link_node:
+            case pdf_dest_node:
+            case pdf_start_thread_node:
+            case pdf_thread_node:
+                backend_out_whatsit[subtype(p)](pdf, p, parent_box, cur);
+                break;
+            default:
+                /*tex We ignore bad ones. */
+                break;
+        }
     }
 }
 
-@ @c
 void hlist_out(PDF pdf, halfword this_box, int rule_callback_id)
 {
-    posstructure localpos;      /* the position structure local within this function */
-    posstructure *refpos;       /* the list origin pos. on the page, provided by the caller */
+    /*tex the position structure local within this function */
+    posstructure localpos;
+    /*tex the list origin pos. on the page, provided by the caller */
+    posstructure *refpos;
+    /*tex A few status variables. */
     scaledpos cur = { 0, 0 }, tmpcur, basepoint;
-    scaledpos size = { 0, 0 };  /* rule dimensions */
+    /*tex rule dimensions */
+    scaledpos size = { 0, 0 };
     scaled effective_horizontal;
-    scaled save_h;              /* what |cur.h| should pop to */
-    scaled edge;                /* right edge of sub-box or leader space */
-    halfword enddir_ptr;        /* temporary pointer to enddir node */
-    int g_order;                /* applicable order of infinity for glue */
-    int g_sign;                 /* selects type of glue */
-    halfword p, q;              /* current position in the hlist */
-    halfword leader_box;        /* the leader box being replicated */
-    scaled leader_wd;           /* width of leader box being replicated */
-    scaled lx;                  /* extra space between leader boxes */
-    boolean outer_doing_leaders;        /* were we doing leaders? */
-    real glue_temp;             /* glue value before rounding */
-    real cur_glue = 0.0;        /* glue seen so far */
-    scaled cur_g = 0;           /* rounded equivalent of |cur_glue| times the glue ratio */
+    /*tex what |cur.h| should pop to */
+    scaled save_h;
+    /*tex right edge of sub-box or leader space */
+    scaled edge;
+    /*tex temporary pointer to enddir node */
+    halfword enddir_ptr;
+    /*tex applicable order of infinity for glue */
+    int g_order;
+    /*tex selects type of glue */
+    int g_sign;
+    /*tex glue variables */
+    int lq, lr;
+    /*tex current position in the hlist */
+    halfword p, q;
+    /*tex the leader box being replicated */
+    halfword leader_box;
+    /*tex width of leader box being replicated */
+    scaled leader_wd;
+    /*tex extra space between leader boxes */
+    scaled lx;
+    /*tex were we doing leaders? */
+    boolean outer_doing_leaders;
+    /*tex glue value before rounding */
+    real glue_temp;
+    /*tex glue seen so far */
+    real cur_glue = 0.0;
+    /*tex rounded equivalent of |cur_glue| times the glue ratio */
+    scaled cur_g = 0;
     scaled_whd rule, ci;
-    int i;                      /* index to scan |pdf_link_stack| */
-    int save_loc = 0;           /* DVI! \.{DVI} byte location upon entry */
-    scaledpos save_dvi = { 0, 0 };      /* DVI! what |dvi| should pop to */
+    /*tex index to scan |pdf_link_stack| */
+    int i;
+    /*tex DVI! \.{DVI} byte location upon entry */
+    int saved_loc = 0;
+    /*tex DVI! what |dvi| should pop to */
+    scaledpos saved_pos = { 0, 0 };
     int synctex = synctex_par ;
-
+    scaled rleft, rright;
     g_order = glue_order(this_box);
     g_sign = glue_sign(this_box);
     p = list_ptr(this_box);
-
     refpos = pdf->posstruct;
-    pdf->posstruct = &localpos; /* use local structure for recursion */
+    /*tex use local structure for recursion */
+    pdf->posstruct = &localpos;
     localpos.pos = refpos->pos;
     localpos.dir = box_dir(this_box);
-
     cur_s++;
-    if (cur_s > max_push)
-        max_push = cur_s;
-
-    if (output_mode_used == OMODE_DVI) {
-        if (cur_s > 0) {
-            dvi_push();
-            save_dvi = dvi;
-        }
-        save_loc = dvi_offset + dvi_ptr;
-    }
-
+    backend_out_control[backend_control_push_list](pdf,&saved_pos,&saved_loc);
     for (i = 1; i <= pdf->link_stack_ptr; i++) {
         if (pdf->link_stack[i].nesting_level == cur_s)
             append_link(pdf, this_box, cur, (small_number) i);
     }
-
-    if (synctex)
+    if (synctex) {
         synctexhlist(this_box);
+    }
     while (p != null) {
         if (is_char_node(p)) {
             do {
@@ -351,8 +269,6 @@ void hlist_out(PDF pdf, halfword this_box, int rule_callback_id)
                 ci = output_one_char(pdf, p);
                 if (textdir_parallel(localpos.dir, dir_TLT)) {
                     cur.h += ci.wd;
-/* experimental */
-cur.h += x_advance(p);
                 } else {
                     cur.h += ci.ht + ci.dp;
                 }
@@ -362,7 +278,10 @@ cur.h += x_advance(p);
             if (synctex)
                 synctexcurrent();
         } else {
-            /* output the non-|char_node| |p| for |hlist_out| and move to the next node */
+            /*tex
+                Output the non-|char_node| |p| for |hlist_out| and move to the
+                next node.
+            */
             switch (type(p)) {
                 case hlist_node:
                 case vlist_node:
@@ -387,26 +306,36 @@ cur.h += x_advance(p);
                                 basepoint.h = height(p);
                         }
                         if (is_rotated(localpos.dir)) {
-                            if (partextdir_eq(localpos.dir, box_dir(p)))
-                                basepoint.v = -width(p) / 2; /* up */
-                            else
-                                basepoint.v = width(p) / 2;  /* down */
+                            if (partextdir_eq(localpos.dir, box_dir(p))) {
+                                /*tex up */
+                                basepoint.v = -width(p) / 2;
+                            } else {
+                                /*tex down */
+                                basepoint.v = width(p) / 2;
+                            }
                         } else if (is_mirrored(localpos.dir)) {
-                            if (partextdir_eq(localpos.dir, box_dir(p)))
+                            if (partextdir_eq(localpos.dir, box_dir(p))) {
                                 basepoint.v = 0;
-                            else
-                                basepoint.v = width(p);      /* down */
+                            } else {
+                                /*tex down */
+                                basepoint.v = width(p);
+                            }
                         } else {
-                            if (partextdir_eq(localpos.dir, box_dir(p)))
-                                basepoint.v = -width(p);     /* up */
-                            else
+                            if (partextdir_eq(localpos.dir, box_dir(p))) {
+                                /*tex up */
+                                basepoint.v = -width(p);
+                            } else {
                                 basepoint.v = 0;
+                            }
                         }
                     }
-                    if (!is_mirrored(localpos.dir))
-                        basepoint.v = basepoint.v + shift_amount(p); /* shift the box down */
-                    else
-                        basepoint.v = basepoint.v - shift_amount(p); /* shift the box up */
+                    if (!is_mirrored(localpos.dir)) {
+                        /*tex Shift the box down. */
+                        basepoint.v = basepoint.v + shift_amount(p);
+                    } else {
+                        /*tex Shift the box up. */
+                        basepoint.v = basepoint.v - shift_amount(p);
+                    }
                     if (list_ptr(p) == null) {
                         if (synctex) {
                             if (type(p) == vlist_node)
@@ -426,10 +355,11 @@ cur.h += x_advance(p);
                     cur.h += effective_horizontal;
                     break;
                 case disc_node:
-                    /* hh: the frontend should append already */
+                    /*tex (HH): the frontend should append already */
                     if (vlink(no_break(p)) != null) {
                         if (subtype(p) != select_disc) {
-                            q = tail_of_list(vlink(no_break(p))); /* this could be a tlink */
+                            /*tex This could be a |tlink|. */
+                            q = tail_of_list(vlink(no_break(p)));
                             vlink(q) = vlink(p);
                             q = vlink(no_break(p));
                             vlink(no_break(p)) = null;
@@ -441,17 +371,20 @@ cur.h += x_advance(p);
                     if (synctex) {
                         synctexmath(p, this_box);
                     }
-                    /* begin mathskip code */
+                    /*tex Begin |mathskip| code. */
                     if (glue_is_zero(p)) {
                         cur.h += surround(p);
                         break;
                     } else {
-                        /* fall through: mathskip */
+                        /*tex Fall through |mathskip|. */
                     }
-                    /* end mathskip code */
+                    /*tex End |mathskip| code. */
                 case glue_node:
                     {
-                        /* move right or output leaders, we use real multiplication */
+                        /*tex
+                            Move right or output leaders, we use real
+                            multiplication.
+                        */
                         rule.wd = width(p) - cur_g;
                         if (g_sign != normal) {
                             if (g_sign == stretching) {
@@ -468,11 +401,16 @@ cur.h += x_advance(p);
                     }
                     rule.wd = rule.wd + cur_g;
                     if (subtype(p) >= a_leaders) {
-                        /* output leaders in an hlist, |goto fin_rule| if a rule or to |next_p| if done */
+                        /*tex
+                            Output leaders in an hlist, |goto fin_rule| if a rule
+                            or to |next_p| if done.
+                        */
                         leader_box = leader_ptr(p);
                         if (type(leader_box) == rule_node) {
                             rule.ht = height(leader_box);
                             rule.dp = depth(leader_box);
+                            rleft = 0;
+                            rright = 0;
                             goto FIN_RULE;
                         }
                         if (textdir_parallel(box_dir(leader_box), localpos.dir))
@@ -480,12 +418,14 @@ cur.h += x_advance(p);
                         else
                             leader_wd = height(leader_box) + depth(leader_box);
                         if ((leader_wd > 0) && (rule.wd > 0)) {
-                            rule.wd = rule.wd + 10; /* compensate for floating-point rounding */
+                            /*tex Compensate for floating-point rounding. */
+                            rule.wd = rule.wd + 10;
                             edge = cur.h + rule.wd;
                             lx = 0;
-                            /*
-                                let |cur.h| be the position of the first box, and set |leader_wd+lx|
-                                to the spacing between corresponding parts of boxes
+                            /*tex
+                                Let |cur.h| be the position of the first box, and
+                                set |leader_wd+lx| to the spacing between
+                                corresponding parts of boxes.
                             */
                             if (subtype(p) == g_leaders) {
                                 save_h = cur.h;
@@ -522,8 +462,10 @@ cur.h += x_advance(p);
                                 if (cur.h < save_h)
                                     cur.h += leader_wd;
                             } else {
-                                lq = rule.wd / leader_wd; /* the number of box copies */
-                                lr = rule.wd % leader_wd; /* the remaining space */
+                                /*tex The number of box copies: */
+                                lq = rule.wd / leader_wd;
+                                /*tex The remaining space: */
+                                lr = rule.wd % leader_wd;
                                 if (subtype(p) == c_leaders) {
                                     cur.h += lr / 2;
                                 } else {
@@ -532,7 +474,10 @@ cur.h += x_advance(p);
                                 }
                             }
                             while (cur.h + leader_wd <= edge) {
-                                /* output a leader box at |cur.h|, then advance |cur.h| by |leader_wd+lx| */
+                                /*tex
+                                    Output a leader box at |cur.h|, then advance
+                                    |cur.h| by |leader_wd+lx|.
+                                */
                                 if (pardir_parallel(box_dir(leader_box), localpos.dir)) {
                                     basepoint.v = 0;
                                     if (textdir_opposite(box_dir(leader_box), localpos.dir))
@@ -582,7 +527,7 @@ cur.h += x_advance(p);
                 case kern_node:
                     if (synctex)
                         synctexkern(p, this_box);
-                    /* officially we should check the subtype */
+                    /*tex officially we should check the subtype */
                     cur.h += kern_width(p);
                     break;
                 case rule_node:
@@ -597,14 +542,18 @@ cur.h += x_advance(p);
                         rule.dp = width(p) / 2;
                         rule.wd = height(p) + depth(p);
                     }
+                    rleft = rule_left(p);
+                    rright = rule_right(p);
                     goto FIN_RULE;
                     break;
                 case dir_node:
-                    /* output a reflection instruction if the direction has changed */
-                    if (dir_dir(p) >= 0) {
-                        /*
+                    /*tex
+                        Output a reflection instruction if the direction has changed.
+                    */
+                    if (subtype(p) == normal_dir) {
+                        /*tex
                             Calculate the needed width to the matching |enddir|, return the
-                            |enddir| node, with width info
+                            |enddir| node, with width info.
                         */
                         enddir_ptr = calculate_width_to_enddir(p, cur_glue, cur_g, this_box);
                         if (textdir_parallel(dir_dir(p), localpos.dir)) {
@@ -614,14 +563,14 @@ cur.h += x_advance(p);
                         } else
                             dir_cur_h(enddir_ptr) = cur.h;
                         if (enddir_ptr != p) {
-                            /* only if it is an enddir */
+                            /*tex Only if it is an |enddir|. */
                             dir_cur_v(enddir_ptr) = cur.v;
                             dir_refpos_h(enddir_ptr) = refpos->pos.h;
                             dir_refpos_v(enddir_ptr) = refpos->pos.v;
-                            /* negative: mark it as |enddir| */
-                            dir_dir(enddir_ptr) = localpos.dir - dir_swap;
+                            /*tex Negative: mark it as |enddir|. */
+                            dir_dir(enddir_ptr) = localpos.dir;
                         }
-                        /* fake a nested |hlist_out| */
+                        /*tex fake a nested |hlist_out|. */
                         synch_pos_with_cur(pdf->posstruct, refpos, cur);
                         refpos->pos = pdf->posstruct->pos;
                         localpos.dir = dir_dir(p);
@@ -630,32 +579,44 @@ cur.h += x_advance(p);
                     } else {
                         refpos->pos.h = dir_refpos_h(p);
                         refpos->pos.v = dir_refpos_v(p);
-                        localpos.dir = dir_dir(p) + dir_swap;
+                        localpos.dir = dir_dir(p);
                         cur.h = dir_cur_h(p);
                         cur.v = dir_cur_v(p);
                     }
                     break;
                 case whatsit_node:
-                    /* output the whatsit node |p| in |hlist_out| */
-                    switch (subtype(p)) {
-                        case save_pos_node:
-                            last_position = pdf->posstruct->pos;
-                            pos_info.curpos = pdf->posstruct->pos;
-                            pos_info.boxpos.pos = refpos->pos;
-                            pos_info.boxpos.dir = localpos.dir;
-                            pos_info.boxdim.wd = width(this_box);
-                            pos_info.boxdim.ht = height(this_box);
-                            pos_info.boxdim.dp = depth(this_box);
-                            break;
-                        case pdf_annot_node:
-                        case pdf_start_link_node:
-                        case pdf_dest_node:
-                        case pdf_start_thread_node:
-                        case pdf_thread_node:
-                            backend_out_whatsit[subtype(p)] (pdf, p, this_box, cur);
-                            break;
-                        default:
-                            out_what(pdf, p);
+                    /*tex Output the whatsit node |p| in |hlist_out|. */
+                    if (subtype(p) <= last_common_whatsit) {
+                        switch (subtype(p)) {
+                            case save_pos_node:
+                                last_position = pdf->posstruct->pos;
+                                /*
+                                pos_info.curpos = pdf->posstruct->pos;
+                                pos_info.boxpos.pos = refpos->pos;
+                                pos_info.boxpos.dir = localpos.dir;
+                                pos_info.boxdim.wd = width(this_box);
+                                pos_info.boxdim.ht = height(this_box);
+                                pos_info.boxdim.dp = depth(this_box);
+                                */
+                                break;
+                            case user_defined_node:
+                                break;
+                            case open_node:
+                            case write_node:
+                            case close_node:
+                                wrapup_leader(p);
+                                break;
+                            case special_node:
+                                /*tex |pdf_special(pdf, p)| */
+                            case late_lua_node:
+                                /*tex |late_lua(pdf, p)| */
+                                backend_out_whatsit[subtype(p)] (pdf, p);
+                                break;
+                            default:
+                                break;
+                        }
+                    } else {
+                        handle_backend_whatsit(pdf, p, this_box, cur);
                     }
                     break;
                 case margin_kern_node:
@@ -666,12 +627,21 @@ cur.h += x_advance(p);
             }
             goto NEXTP;
           FIN_RULE:
-            /* output a rule in an hlist */
-            if (is_running(rule.ht))
+            /*tex Output a rule in an hlist. */
+            if (is_running(rule.ht)) {
                 rule.ht = height(this_box);
-            if (is_running(rule.dp))
+            }
+            if (rleft != 0) {
+                rule.ht -= rleft;
+                pos_down(-rleft);
+            }
+            if (is_running(rule.dp)) {
                 rule.dp = depth(this_box);
-            /* we don't output empty rules */
+            }
+            if (rright != 0) {
+                rule.dp -= rright;
+            }
+            /*tex We don't output empty rules. */
             if ((rule.ht + rule.dp) > 0 && rule.wd > 0) {
                 switch (localpos.dir) {
                     case dir_TLT:
@@ -725,92 +695,85 @@ cur.h += x_advance(p);
             synch_pos_with_cur(pdf->posstruct, refpos, cur);
         }
     }
-    if (synctex)
+    if (synctex) {
         synctextsilh(this_box);
-    if (output_mode_used == OMODE_DVI) {
-        prune_movements(save_loc);
-        if (cur_s > 0) {
-            dvi_pop(save_loc);
-            dvi = save_dvi;
-        }
     }
+    backend_out_control[backend_control_pop_list](pdf,&saved_pos,&saved_loc);
     cur_s--;
     pdf->posstruct = refpos;
 }
 
-@ @c
 void vlist_out(PDF pdf, halfword this_box, int rule_callback_id)
 {
-    posstructure localpos; /* the position structure local within this function */
-    posstructure *refpos;  /* the list origin pos. on the page, provided by the caller */
-
+    /*tex The position structure local within this function: */
+    posstructure localpos;
+    /*tex The list origin pos. on the page, provided by the caller: */
+    posstructure *refpos;
+    /*tex a few status variables */
     scaledpos cur, tmpcur, basepoint;
-    scaledpos size = { 0, 0 };     /* rule dimensions */
+    /*tex rule dimensions */
+    scaledpos size = { 0, 0 };
     scaled effective_vertical;
-    scaled save_v;                 /* what |cur.v| should pop to */
-    scaled top_edge;               /* the top coordinate for this box */
-    scaled edge;                   /* bottom boundary of leader space */
-    glue_ord g_order;              /* applicable order of infinity for glue */
-    int g_sign;                    /* selects type of glue */
-    halfword p;                    /* current position in the vlist */
-    halfword q;                    /* temp */
-    halfword leader_box;           /* the leader box being replicated */
-    scaled leader_ht;              /* height of leader box being replicated */
-    scaled lx;                     /* extra space between leader boxes */
-    boolean outer_doing_leaders;   /* were we doing leaders? */
-    real glue_temp;                /* glue value before rounding */
-    real cur_glue = 0.0;           /* glue seen so far */
-    scaled cur_g = 0;              /* rounded equivalent of |cur_glue| times the glue ratio */
+    /*tex what |cur.v| should pop to */
+    scaled save_v;
+    /*tex the top coordinate for this box */
+    scaled top_edge;
+    /*tex bottom boundary of leader space */
+    scaled edge;
+    /*tex applicable order of infinity for glue */
+    glue_ord g_order;
+    /*tex selects type of glue */
+    int g_sign;
+    /*tex glue variables */
+    int lq, lr;
+    /*tex current position in the vlist */
+    halfword p;
+    /*tex temp */
+    halfword q;
+    /*tex the leader box being replicated */
+    halfword leader_box;
+    /*tex height of leader box being replicated */
+    scaled leader_ht;
+    /*tex extra space between leader boxes */
+    scaled lx;
+    /*tex were we doing leaders? */
+    boolean outer_doing_leaders;
+    /*tex glue value before rounding */
+    real glue_temp;
+    /*tex glue seen so far */
+    real cur_glue = 0.0;
+    /*tex rounded equivalent of |cur_glue| times the glue ratio */
+    scaled cur_g = 0;
     scaled_whd rule;
-    int save_loc = 0;              /* DVI byte location upon entry */
-    scaledpos save_dvi = { 0, 0 }; /* DVI! what |dvi| should pop to */
+    /*tex \DVI\ byte location upon entry */
+    int saved_loc = 0;
+    /*tex \DVI\ what |dvi| should pop to */
+    scaledpos saved_pos = { 0, 0 };
     int synctex = synctex_par ;
-
+    int rleft, rright;
     g_order = (glue_ord) glue_order(this_box);
     g_sign = glue_sign(this_box);
     p = list_ptr(this_box);
-
     cur.h = 0;
     cur.v = -height(this_box);
     top_edge = cur.v;
-
     refpos = pdf->posstruct;
-    pdf->posstruct = &localpos; /* use local structure for recursion */
+    /*tex Use local structure for recursion. */
+    pdf->posstruct = &localpos;
     localpos.dir = box_dir(this_box);
     synch_pos_with_cur(pdf->posstruct, refpos, cur);
-
     cur_s++;
-    if (cur_s > max_push)
-        max_push = cur_s;
-
-    if (output_mode_used == OMODE_DVI) {
-        if (cur_s > 0) {
-            dvi_push();
-            save_dvi = dvi;
-        }
-        save_loc = dvi_offset + dvi_ptr;
-    }
-
-    if (synctex)
+    backend_out_control[backend_control_push_list](pdf,&saved_pos,&saved_loc);
+    if (synctex) {
         synctexvlist(this_box);
-
-    /* create thread for the current vbox if needed */
+    }
+    /*tex Create thread for the current vbox if needed. */
     check_running_thread(pdf, this_box, cur);
-
     while (p != null) {
         switch (type(p)) {
             case hlist_node:
             case vlist_node:
-                /*
-                    output a box in a vlist:
-
-                    todo: the direct test to switch between |width(p)| and |-width(p)|
-                    is definately wrong, because it does not nest properly. But at least
-                    it fixes a very obvious problem that otherwise occured with
-                    \.{\\pardir TLT} in a document with \.{\\bodydir TRT}, and so it
-                    will have to do for now. (hh: is this still true?)
-
-                */
+                /*tex Output a box in a vlist. */
                 if (pardir_parallel(box_dir(p), localpos.dir)) {
                     effective_vertical = height(p) + depth(p);
                     if ((type(p) == hlist_node) && is_mirrored(box_dir(p)))
@@ -839,7 +802,8 @@ void vlist_out(PDF pdf, halfword this_box, int rule_callback_id)
                     else
                         basepoint.v = width(p);
                 }
-                basepoint.h = basepoint.h + shift_amount(p); /* shift the box right */
+                /*tex Shift the box right. */
+                basepoint.h = basepoint.h + shift_amount(p);
                 if (list_ptr(p) == null) {
                     cur.v += effective_vertical;
                     if (synctex) {
@@ -872,11 +836,15 @@ void vlist_out(PDF pdf, halfword this_box, int rule_callback_id)
                     rule.dp = width(p) / 2;
                     rule.wd = height(p) + depth(p);
                 }
+                rleft = rule_left(p);
+                rright = rule_right(p);
                 goto FIN_RULE;
                 break;
             case glue_node:
                 {
-                    /* move down or output leaders, we use real multiplication */
+                    /*tex
+                        Move down or output leaders, we use real multiplication.
+                    */
                     rule.ht = width(p) - cur_g;
                     if (g_sign != normal) {
                         if (g_sign == stretching) {
@@ -893,25 +861,38 @@ void vlist_out(PDF pdf, halfword this_box, int rule_callback_id)
                 }
                 rule.ht = rule.ht + cur_g;
                 if (subtype(p) >= a_leaders) {
-                    /* output leaders in a vlist, |goto fin_rulefin_rule| if a rule or to |next_p| if done */
+                    /*tex
+                        Output leaders in a vlist, |goto fin_rulefin_rule| if a
+                        rule or to |next_p| if done.
+                    */
                     leader_box = leader_ptr(p);
                     if (type(leader_box) == rule_node) {
                         rule.wd = width(leader_box);
                         rule.dp = 0;
+                        rleft = 0;
+                        rright = 0;
                         goto FIN_RULE;
                     }
                     leader_ht = height(leader_box) + depth(leader_box);
                     if ((leader_ht > 0) && (rule.ht > 0)) {
-                        rule.ht = rule.ht + 10; /* compensate for floating-point rounding */
+                        /*tex Compensate for floating-point rounding: */
+                        rule.ht = rule.ht + 10;
                         edge = cur.v + rule.ht;
                         lx = 0;
-                        /*
-                            let |cur.v| be the position of the first box, and set |leader_ht+lx|
-                            to the spacing between corresponding parts of boxes
+                        /*tex
+                            Let |cur.v| be the position of the first box, and set
+                            |leader_ht+lx| to the spacing between corresponding
+                            parts of boxes.
                         */
                         if (subtype(p) == g_leaders) {
                             save_v = cur.v;
                             switch (localpos.dir) {
+                                case dir_TLT:
+                                case dir_TRT:
+                                    cur.v = refpos->pos.v - shipbox_refpos.v - cur.v;
+                                    cur.v = leader_ht * (cur.v / leader_ht);
+                                    cur.v = refpos->pos.v - shipbox_refpos.v - cur.v;
+                                    break;
                                 case dir_LTL:
                                     cur.v += refpos->pos.h - shipbox_refpos.h;
                                     cur.v = leader_ht * (cur.v / leader_ht);
@@ -922,12 +903,6 @@ void vlist_out(PDF pdf, halfword this_box, int rule_callback_id)
                                     cur.v = leader_ht * (cur.v / leader_ht);
                                     cur.v = refpos->pos.h - shipbox_refpos.h - cur.v;
                                     break;
-                                case dir_TLT:
-                                case dir_TRT:
-                                    cur.v = refpos->pos.v - shipbox_refpos.v - cur.v;
-                                    cur.v = leader_ht * (cur.v / leader_ht);
-                                    cur.v = refpos->pos.v - shipbox_refpos.v - cur.v;
-                                    break;
                                 default:
                                     formatted_warning("pdf backend","forcing bad dir %i to TLT in vlist case 1",localpos.dir);
                                     localpos.dir = dir_TLT;
@@ -944,8 +919,10 @@ void vlist_out(PDF pdf, halfword this_box, int rule_callback_id)
                             if (cur.v < save_v)
                                 cur.v += leader_ht;
                         } else {
-                            lq = rule.ht / leader_ht; /* the number of box copies */
-                            lr = rule.ht % leader_ht; /* the remaining space */
+                            /*tex The number of box copies. */
+                            lq = rule.ht / leader_ht;
+                            /*tex The remaining space. */
+                            lr = rule.ht % leader_ht;
                             if (subtype(p) == c_leaders) {
                                 cur.v += lr / 2;
                             } else {
@@ -953,9 +930,11 @@ void vlist_out(PDF pdf, halfword this_box, int rule_callback_id)
                                 cur.v += (lr - (lq - 1) * lx) / 2;
                             }
                         }
-
                         while (cur.v + leader_ht <= edge) {
-                            /* output a leader box at |cur.v|, then advance |cur.v| by |leader_ht+lx| */
+                            /*tex
+                                Output a leader box at |cur.v|, then advance
+                                |cur.v| by |leader_ht+lx|.
+                            */
                             tmpcur.h = shift_amount(leader_box);
                             tmpcur.v = cur.v + height(leader_box);
                             synch_pos_with_cur(pdf->posstruct, refpos, tmpcur);
@@ -979,41 +958,62 @@ void vlist_out(PDF pdf, halfword this_box, int rule_callback_id)
                 cur.v += width(p);
                 break;
             case whatsit_node:
-                /* output the whatsit node |p| in |vlist_out| */
-                switch (subtype(p)) {
-                    case save_pos_node:
-                        last_position = pdf->posstruct->pos;
-                        pos_info.curpos = pdf->posstruct->pos;
-                        pos_info.boxpos.pos = refpos->pos;
-                        pos_info.boxpos.dir = localpos.dir;
-                        pos_info.boxdim.wd = width(this_box);
-                        pos_info.boxdim.ht = height(this_box);
-                        pos_info.boxdim.dp = depth(this_box);
-                        break;
-                    case pdf_annot_node:
-                    case pdf_start_link_node:
-                    case pdf_dest_node:
-                    case pdf_start_thread_node:
-                    case pdf_thread_node:
-                        backend_out_whatsit[subtype(p)] (pdf, p, this_box, cur);
-                        break;
-                    default:
-                        out_what(pdf, p);
+                /*tex Output the whatsit node |p| in |vlist_out|. */
+                if (subtype(p) <= last_common_whatsit) {
+                    switch (subtype(p)) {
+                        case save_pos_node:
+                            last_position = pdf->posstruct->pos;
+                            /*
+                            pos_info.curpos = pdf->posstruct->pos;
+                            pos_info.boxpos.pos = refpos->pos;
+                            pos_info.boxpos.dir = localpos.dir;
+                            pos_info.boxdim.wd = width(this_box);
+                            pos_info.boxdim.ht = height(this_box);
+                            pos_info.boxdim.dp = depth(this_box);
+                            */
+                            break;
+                        case user_defined_node:
+                            break;
+                        case open_node:
+                        case write_node:
+                        case close_node:
+                            wrapup_leader(p);
+                            break;
+                        case special_node:
+                            /*tex |pdf_special(pdf, p)|; */
+                        case late_lua_node:
+                            /*tex |late_lua(pdf, p)|; */
+                            backend_out_whatsit[subtype(p)] (pdf, p);
+                            break;
+                        default:
+                            break;
+                    }
+                } else {
+                    handle_backend_whatsit(pdf, p, this_box, cur);
                 }
                 break;
             case glyph_node:
             case disc_node:
-                confusion("vlistout"); /* this can't happen */
+                /*tex This can't happen unless one messes up in \LUA. */
+                confusion("vlistout");
                 break;
             default:
                 break;
         }
         goto NEXTP;
       FIN_RULE:
-        /* output a rule in a vlist, |goto next_p| */
-        if (is_running(rule.wd))
+        /*tex Output a rule in a vlist and |goto next_p|. */
+        if (is_running(rule.wd)) {
             rule.wd = width(this_box);
-        /* we don't output empty rules */
+        }
+        if (rleft != 0) {
+            rule.wd -= rleft;
+            pos_left(-rleft);
+        }
+        if (rright != 0) {
+            rule.wd -= rright;
+        }
+        /*tex We don't output empty rules. */
         if ((rule.ht + rule.dp) > 0 && rule.wd > 0) {
             switch (localpos.dir) {
                 case dir_TLT:
@@ -1063,16 +1063,10 @@ void vlist_out(PDF pdf, halfword this_box, int rule_callback_id)
         p = vlink(p);
         synch_pos_with_cur(pdf->posstruct, refpos, cur);
     }
-    if (synctex)
+    if (synctex) {
         synctextsilv(this_box);
-
-    if (output_mode_used == OMODE_DVI) {
-        prune_movements(save_loc);
-        if (cur_s > 0) {
-            dvi_pop(save_loc);
-            dvi = save_dvi;
-        }
     }
+    backend_out_control[backend_control_pop_list](pdf,&saved_pos,&saved_loc);
     cur_s--;
     pdf->posstruct = refpos;
 }
diff --git a/texk/web2c/luatexdir/pdf/pdfliteral.w b/texk/web2c/luatexdir/pdf/pdfliteral.c
similarity index 64%
rename from texk/web2c/luatexdir/pdf/pdfliteral.w
rename to texk/web2c/luatexdir/pdf/pdfliteral.c
index 94bb2c93c..e8b00a64e 100644
--- a/texk/web2c/luatexdir/pdf/pdfliteral.w
+++ b/texk/web2c/luatexdir/pdf/pdfliteral.c
@@ -1,27 +1,26 @@
-% pdfliteral.w
-%
-% Copyright 2009-2010 Taco Hoekwater <taco@@luatex.org>
-%
-% This file is part of LuaTeX.
-%
-% LuaTeX is free software; you can redistribute it and/or modify it under
-% the terms of the GNU General Public License as published by the Free
-% Software Foundation; either version 2 of the License, or (at your
-% option) any later version.
-%
-% LuaTeX is distributed in the hope that it will be useful, but WITHOUT
-% ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-% FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
-% License for more details.
-%
-% You should have received a copy of the GNU General Public License along
-% with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
-
-@ @c
+/*
+
+Copyright 2009-2010 Taco Hoekwater <taco@luatex.org>
+
+This file is part of LuaTeX.
+
+LuaTeX is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 2 of the License, or (at your
+option) any later version.
+
+LuaTeX is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+License for more details.
+
+You should have received a copy of the GNU General Public License along
+with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+
+*/
 
 #include "ptexlib.h"
 
-@ @c
 void pdf_special(PDF pdf, halfword p)
 {
     int old_setting = selector;
@@ -34,18 +33,22 @@ void pdf_special(PDF pdf, halfword p)
     flush_str(s);
 }
 
-@ To ship out a \TeX\ box to PDF page description we need to implement
-|hlist_out|, |vlist_out| and |ship_out|, which are equivalent to the \TeX'
-original |hlist_out|, |vlist_out| and |ship_out| resp. But first we need to
-declare some procedures needed in |hlist_out| and |vlist_out|.
+/*tex
+
+    To ship out a \TeX\ box to PDF page description we need to implement
+    |hlist_out|, |vlist_out| and |ship_out|, which are equivalent to the \TeX'
+    original |hlist_out|, |vlist_out| and |ship_out| resp. But first we need to
+    declare some procedures needed in |hlist_out| and |vlist_out|.
+
+*/
 
-@c
 void pdf_out_literal(PDF pdf, halfword p)
 {
-    int old_setting;            /* holds print |selector| */
+    int old_setting;
     str_number s;
+    int t = pdf_literal_type(p);
     pdfstructure *ps = pdf->pstruct;
-    if (pdf_literal_type(p) == normal) {
+    if (t == normal) {
         old_setting = selector;
         selector = new_string;
         show_token_list(token_link(pdf_literal_data(p)), null, -1);
@@ -53,7 +56,7 @@ void pdf_out_literal(PDF pdf, halfword p)
         s = make_string();
         pdf_literal(pdf, s, pdf_literal_mode(p), false);
         flush_str(s);
-    } else {
+    } else if (t == lua_refid_literal) {
         switch (pdf_literal_mode(p)) {
             case set_origin:
                 pdf_goto_pagemode(pdf);
@@ -79,12 +82,12 @@ void pdf_out_literal(PDF pdf, halfword p)
                 normal_error("pdf backend","bad literal mode");
                 break;
         }
-        lua_pdf_literal(pdf, pdf_literal_data(p));
+        lua_pdf_literal(pdf, pdf_literal_data(p), 0);
     }
 }
 
-@ test equality of start of strings
-@c
+/*tex Test equality of start of strings: */
+
 static boolean str_in_cstr(str_number s, const char *r, unsigned i)
 {
     const unsigned char *k, *l;
@@ -99,38 +102,50 @@ static boolean str_in_cstr(str_number s, const char *r, unsigned i)
     return true;
 }
 
-@ @c
 void pdf_literal(PDF pdf, str_number s, int literal_mode, boolean warn)
 {
     unsigned char *ss;
     size_t l;
-    pool_pointer j = 0;         /* current character code position, initialized to make the compiler happy */
+    /*tex
+        The current character code position, initialized to make the compiler
+        happy:
+    */
+    pool_pointer j = 0;
     pdfstructure *p = pdf->pstruct;
     if (s >= STRING_OFFSET) {
-        /* needed for |out_save| */
+        /*tex Needed for |out_save|: */
         j = 0;
-        /* unfortunately we always go through this when we have vf specials (and also via temp strings) */
+        /*tex
+            Unfortunately we always go through this when we have vf specials (and
+            also via temp strings):
+        */
         if (literal_mode == scan_special) {
             if (!(str_in_cstr(s, "pdf:", 0) || str_in_cstr(s, "PDF:", 0))) {
                 if (warn && ((!(str_in_cstr(s, "src:", 0) || str_in_cstr(s, "SRC:", 0))) || (str_length(s) == 0)))
                     tprint_nl("Non-PDF special ignored!");
                 return;
             }
-            j = j + (pool_pointer) 4;                   /* strlen("PDF:") */
-            if (str_in_cstr(s, "direct:", 4)) {         /* strlen("PDF:") */
-                j = j + (pool_pointer) 7;               /* strlen("direct:") */
+            /*tex |strlen("PDF:")| */
+            j = j + (pool_pointer) 4;
+            if (str_in_cstr(s, "direct:", 4)) {
+                /*tex |strlen("direct:")| */
+                j = j + (pool_pointer) 7;
                 literal_mode = direct_always;
-            } else if (str_in_cstr(s, "page:", 4)) {    /* strlen("PDF:") */
-                j = j + (pool_pointer) 5;               /* strlen("page:") */
+            } else if (str_in_cstr(s, "page:", 4)) {
+                /*tex |strlen("page:")| */
+                j = j + (pool_pointer) 5;
                 literal_mode = direct_page;
-            } else if (str_in_cstr(s, "text:", 4)) {    /* strlen("PDF:") */
-                j = j + (pool_pointer) 5;               /* strlen("text:") */
+            } else if (str_in_cstr(s, "text:", 4)) {
+                /*tex |strlen("text:")| */
+                j = j + (pool_pointer) 5;
                 literal_mode = direct_text;
-            } else if (str_in_cstr(s, "raw:", 4)) {     /* strlen("PDF:") */
-                j = j + (pool_pointer) 4;               /* strlen("raw:") */
+            } else if (str_in_cstr(s, "raw:", 4)) {
+                /*tex |strlen("raw:")| */
+                j = j + (pool_pointer) 4;
                 literal_mode = direct_raw;
-            } else if (str_in_cstr(s, "origin:", 4)) {  /* strlen("PDF:") */
-                j = j + (pool_pointer) 7;               /* strlen("origin:") */
+            } else if (str_in_cstr(s, "origin:", 4)) {
+                /*tex |strlen("origin:")| */
+                j = j + (pool_pointer) 7;
                 literal_mode = set_origin;
             } else {
                 literal_mode = set_origin;
@@ -147,7 +162,7 @@ void pdf_literal(PDF pdf, str_number s, int literal_mode, boolean warn)
             break;
         case direct_text:
             pdf_goto_fontmode(pdf);
-//            pdf_goto_textmode(pdf);
+            /*tex not: |pdf_goto_textmode(pdf);| */
             break;
         case direct_always:
             pdf_end_string_nl(pdf);
diff --git a/texk/web2c/luatexdir/pdf/pdfobj.w b/texk/web2c/luatexdir/pdf/pdfobj.c
similarity index 72%
rename from texk/web2c/luatexdir/pdf/pdfobj.w
rename to texk/web2c/luatexdir/pdf/pdfobj.c
index e5ca09de6..71d6a943f 100644
--- a/texk/web2c/luatexdir/pdf/pdfobj.w
+++ b/texk/web2c/luatexdir/pdf/pdfobj.c
@@ -1,44 +1,48 @@
-% pdfobj.w
-%
-% Copyright 2009-2011 Taco Hoekwater <taco@@luatex.org>
-%
-% This file is part of LuaTeX.
-%
-% LuaTeX is free software; you can redistribute it and/or modify it under
-% the terms of the GNU General Public License as published by the Free
-% Software Foundation; either version 2 of the License, or (at your
-% option) any later version.
-%
-% LuaTeX is distributed in the hope that it will be useful, but WITHOUT
-% ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-% FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
-% License for more details.
-%
-% You should have received a copy of the GNU General Public License along
-% with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
-
-@ @c
+/*
+
+Copyright 2009-2011 Taco Hoekwater <taco@luatex.org>
+
+This file is part of LuaTeX.
+
+LuaTeX is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 2 of the License, or (at your
+option) any later version.
+
+LuaTeX is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+License for more details.
+
+You should have received a copy of the GNU General Public License along
+with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+
+*/
+
 #include "ptexlib.h"
 #include "lua/luatex-api.h"
 
-@ write a raw PDF object
+/*tex Write a raw \PDF\ object: */
 
-@c
 void pdf_write_obj(PDF pdf, int k)
 {
     lstring data;
     const_lstring st;
-    size_t li;                  /* index into |data.s| */
+    /*tex The index into |data.s|: */
+    size_t li;
     int saved_compress_level ;
-    int os_threshold = OBJSTM_ALWAYS;   /* gives compressed objects for \.{\\pdfvariable objcompresslevel} >= |OBJSTM_ALWAYS| */
-    int l = 0;                          /* possibly a lua registry reference */
+    /*tex Gives compressed objects for |\pdfvariable objcompresslevel| >= |OBJSTM_ALWAYS|: */
+    int os_threshold = OBJSTM_ALWAYS;
+    /*tex Possibly a \LUA\ registry reference: */
+    int l = 0;
     int ll = 0;
     data.s = NULL;
-    /* we can have an immediate object before we are initialized */
+    /*tex We can have an immediate object before we are initialized. */
     ensure_output_state(pdf, ST_HEADER_WRITTEN);
     saved_compress_level = pdf->compress_level;
-    /* end of ugly hack */
-    if (obj_obj_pdfcompresslevel(pdf, k) > -1) { /* -1 = "unset" */
+    /*tex End of a ugly hack. */
+    if (obj_obj_pdfcompresslevel(pdf, k) > -1) {
+        /*tex A value of |-1| means ``unset''. */
         pdf->compress_level = obj_obj_pdfcompresslevel(pdf, k);
         if (pdf->compress_level == 0) {
             pdf->objcompresslevel = 0;
@@ -56,9 +60,10 @@ void pdf_write_obj(PDF pdf, int k)
                 normal_error("pdf backend","invalid object");
             st.s = lua_tolstring(Luas, -1, &li);
             st.l = li;
+            lua_pop(Luas,1);
+            pdf_check_space(pdf);
             pdf_out_block(pdf, st.s, st.l);
-            if (st.s[st.l - 1] != '\n')
-                pdf_out(pdf, '\n');
+            pdf_set_space(pdf);
             luaL_unref(Luas, LUA_REGISTRYINDEX, l);
             obj_obj_stream_attr(pdf, k) = LUA_NOREF;
         }
@@ -75,10 +80,12 @@ void pdf_write_obj(PDF pdf, int k)
     st.l = li;
     lua_pop(Luas, 1);
     if (obj_obj_is_file(pdf, k)) {
-        boolean res = false;      /* callback status value */
-        const char *fnam = NULL;  /* callback found filename */
+        /*tex The callback status value: */
+        boolean res = false;
+        /*tex The callback found filename: */
+        const char *fnam = NULL;
         int callback_id;
-        /* st.s is also |\0|-terminated, even as lstring */
+        /*tex |st.s| is also |\0|-terminated, even as |lstring| */
         fnam = luatex_find_file(st.s, find_data_file_callback);
         callback_id = callback_defined(read_data_file_callback);
         if (fnam && callback_id > 0) {
@@ -88,7 +95,8 @@ void pdf_write_obj(PDF pdf, int k)
             if (!file_opened)
                 normal_error("pdf backend", "cannot open file for embedding");
         } else {
-            byte_file f;        /* the data file's FILE* */
+            /*tex The data file's |FILE*|: */
+            byte_file f;
             if (!fnam)
                 fnam = st.s;
             if (!luatex_open_input(&f, fnam, kpse_tex_format, FOPEN_RBIN_MODE, true))
@@ -112,32 +120,37 @@ void pdf_write_obj(PDF pdf, int k)
     if (obj_obj_is_stream(pdf, k)) {
         pdf_end_stream(pdf);
         pdf_end_obj(pdf);
-    } else /* here we do the \n */
+    } else {
+        /*tex Here we do the |\n|. */
         pdf_end_obj(pdf);
+    }
     luaL_unref(Luas, LUA_REGISTRYINDEX, l);
     obj_obj_data(pdf, k) = LUA_NOREF;
     pdf->compress_level = saved_compress_level;
 }
 
-@ @c
 void init_obj_obj(PDF pdf, int k)
 {
     obj_obj_stream_attr(pdf, k) = LUA_NOREF;
     obj_obj_data(pdf, k) = LUA_NOREF;
     unset_obj_obj_is_stream(pdf, k);
     unset_obj_obj_is_file(pdf, k);
+    unset_obj_obj_no_length(pdf, k);
     obj_obj_pdfcompresslevel(pdf, k) = -1; /* unset */
     obj_obj_objstm_threshold(pdf, k) = OBJSTM_UNSET; /* unset */
 }
 
-@ The \.{\\pdfextension obj} primitive is used to create a ``raw'' object in the
-PDF output file. The object contents will be hold in memory and will be written
-out only when the object is referenced by \.{\\pdfextension refobj}. When
-\.{\\pdfextension obj} is used with \.{\\immediate}, the object contents will be
-written out immediately. Objects referenced in the current page are appended into
-|pdf_obj_list|.
+/*tex
+
+    The |\pdfextension obj| primitive is used to create a ``raw'' object in
+    the PDF output file. The object contents will be hold in memory and will be
+    written out only when the object is referenced by |\pdfextension refobj|.
+    When |\pdfextension obj| is used with |\immediate|, the object contents
+    will be written out immediately. Objects referenced in the current page are
+    appended into |pdf_obj_list|.
+
+*/
 
-@c
 void scan_obj(PDF pdf)
 {
     int k;
@@ -154,7 +167,7 @@ void scan_obj(PDF pdf)
             k = cur_val;
             check_obj_type(pdf, obj_type_obj, k);
             if (is_obj_scheduled(pdf, k) || obj_data_ptr(pdf, k) != 0)
-                luaL_error(Luas, "object in use");
+                normal_error("pdf backend", "scheduled object is already used");
         } else {
             pdf->obj_count++;
             k = pdf_create_obj(pdf, obj_type_obj, 0);
@@ -190,7 +203,6 @@ void scan_obj(PDF pdf)
     pdf_last_obj = k;
 }
 
-@ @c
 void scan_refobj(PDF pdf)
 {
     scan_int();
@@ -206,14 +218,12 @@ void scan_refobj_lua(PDF pdf, int k)
     pdf_obj_objnum(tail_par) = k;
 }
 
-@ @c
 void pdf_ref_obj(PDF pdf, halfword p)
 {
     if (!is_obj_scheduled(pdf, pdf_obj_objnum(p)))
         addto_page_resources(pdf, obj_type_obj, pdf_obj_objnum(p));
 }
 
-@ @c
 void pdf_ref_obj_lua(PDF pdf, int k)
 {
     if (!is_obj_scheduled(pdf, k))
diff --git a/texk/web2c/luatexdir/pdf/pdfoutline.w b/texk/web2c/luatexdir/pdf/pdfoutline.c
similarity index 82%
rename from texk/web2c/luatexdir/pdf/pdfoutline.w
rename to texk/web2c/luatexdir/pdf/pdfoutline.c
index 6c0a30a88..ae17e29da 100644
--- a/texk/web2c/luatexdir/pdf/pdfoutline.w
+++ b/texk/web2c/luatexdir/pdf/pdfoutline.c
@@ -1,36 +1,46 @@
-% pdfoutline.w
-%
-% Copyright 2009-2011 Taco Hoekwater <taco@@luatex.org>
-%
-% This file is part of LuaTeX.
-%
-% LuaTeX is free software; you can redistribute it and/or modify it under
-% the terms of the GNU General Public License as published by the Free
-% Software Foundation; either version 2 of the License, or (at your
-% option) any later version.
-%
-% LuaTeX is distributed in the hope that it will be useful, but WITHOUT
-% ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-% FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
-% License for more details.
-%
-% You should have received a copy of the GNU General Public License along
-% with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
-
-@ @c
+/*
+
+Copyright 2009-2011 Taco Hoekwater <taco@@luatex.org>
+
+This file is part of LuaTeX.
+
+LuaTeX is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 2 of the License, or (at your
+option) any later version.
+
+LuaTeX is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+License for more details.
+
+You should have received a copy of the GNU General Public License along
+with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+
+*/
 
 #include "ptexlib.h"
 
-@ Data structure of outlines; it's not able to write out outline entries before
-all outline entries are defined, so memory allocated for outline entries can't
-not be deallocated and will stay in memory. For this reason we will store data of
-outline entries in |pdf->mem| instead of |mem|
+/*tex
+
+    Data structure of outlines; it's not able to write out outline entries before
+    all outline entries are defined, so memory allocated for outline entries
+    can't not be deallocated and will stay in memory. For this reason we will
+    store data of outline entries in |pdf->mem| instead of |mem|.
+
+*/
 
-@c
-#define pdfmem_outline_size 8 /* size of memory in |pdf->mem| which |obj_outline_ptr| points to */
+/*tex The size of memory in |pdf->mem| which |obj_outline_ptr| points to: */
 
-#define obj_outline_count                obj_info      /* count of all opened children */
-#define obj_outline_ptr                  obj_aux       /* pointer to |pdf->mem| */
+#define pdfmem_outline_size 8
+
+/*tex The count of all opened children: */
+
+#define obj_outline_count                obj_info
+
+/*tex The pointer to |pdf->mem|: */
+
+#define obj_outline_ptr                  obj_aux
 
 #define obj_outline_title(pdf,A)         pdf->mem[obj_outline_ptr(pdf,A)]
 #define obj_outline_parent(pdf,A)        pdf->mem[obj_outline_ptr(pdf,A) + 1]
@@ -38,7 +48,7 @@ outline entries in |pdf->mem| instead of |mem|
 #define obj_outline_next(pdf,A)          pdf->mem[obj_outline_ptr(pdf,A) + 3]
 #define obj_outline_first(pdf,A)         pdf->mem[obj_outline_ptr(pdf,A) + 4]
 #define obj_outline_last(pdf,A)          pdf->mem[obj_outline_ptr(pdf,A) + 5]
-#define obj_outline_action_objnum(pdf,A) pdf->mem[obj_outline_ptr(pdf,A) + 6]  /* object number of action */
+#define obj_outline_action_objnum(pdf,A) pdf->mem[obj_outline_ptr(pdf,A) + 6]
 #define obj_outline_attr(pdf,A)          pdf->mem[obj_outline_ptr(pdf,A) + 7]
 
 #define set_obj_outline_count(pdf,A,B)         obj_outline_count(pdf,A)=B
@@ -52,7 +62,6 @@ outline entries in |pdf->mem| instead of |mem|
 #define set_obj_outline_parent(pdf,A,B)        obj_outline_parent(pdf,A)=B
 #define set_obj_outline_attr(pdf,A,B)          obj_outline_attr(pdf,A)=B
 
-@ @c
 static int open_subentries(PDF pdf, halfword p)
 {
     int c, l, r;
@@ -78,9 +87,8 @@ static int open_subentries(PDF pdf, halfword p)
     return k;
 }
 
-@ return number of outline entries in the same level with |p|
+/*tex Return the number of outline entries in the same level with |p|: */
 
-@c
 static int outline_list_count(PDF pdf, pointer p)
 {
     int k = 1;
@@ -91,7 +99,6 @@ static int outline_list_count(PDF pdf, pointer p)
     return k;
 }
 
-@ @c
 void scan_pdfoutline(PDF pdf)
 {
     halfword q, r;
@@ -178,10 +185,13 @@ void scan_pdfoutline(PDF pdf)
     }
 }
 
-@ In the end we must flush PDF objects that cannot be written out immediately
-after shipping out pages.
+/*tex
+
+    In the end we must flush \PDF\F objects that cannot be written out
+    immediately after shipping out pages.
+
+*/
 
-@c
 int print_outlines(PDF pdf)
 {
     int k, l, a;
@@ -206,8 +216,7 @@ int print_outlines(PDF pdf)
         pdf_dict_add_int(pdf, "Count", k);
         pdf_end_dict(pdf);
         pdf_end_obj(pdf);
-        /* Output PDF outline entries */
-
+        /*tex Output \PDF\ outline entries. */
         k = pdf->head_tab[obj_type_outline];
         while (k != 0) {
             if (obj_outline_parent(pdf, k) == pdf->parent_outline) {
@@ -243,7 +252,6 @@ int print_outlines(PDF pdf)
             pdf_end_obj(pdf);
             k = obj_link(pdf, k);
         }
-
     } else {
         outlines = 0;
     }
diff --git a/texk/web2c/luatexdir/pdf/pdfpage.w b/texk/web2c/luatexdir/pdf/pdfpage.c
similarity index 74%
rename from texk/web2c/luatexdir/pdf/pdfpage.w
rename to texk/web2c/luatexdir/pdf/pdfpage.c
index ecc51ddfd..211248a02 100644
--- a/texk/web2c/luatexdir/pdf/pdfpage.w
+++ b/texk/web2c/luatexdir/pdf/pdfpage.c
@@ -1,23 +1,23 @@
-% pdfpage.w
-%
-% Copyright 2006-2012 Taco Hoekwater <taco@@luatex.org>
-%
-% This file is part of LuaTeX.
-%
-% LuaTeX is free software; you can redistribute it and/or modify it under
-% the terms of the GNU General Public License as published by the Free
-% Software Foundation; either version 2 of the License, or (at your
-% option) any later version.
-%
-% LuaTeX is distributed in the hope that it will be useful, but WITHOUT
-% ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-% FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
-% License for more details.
-%
-% You should have received a copy of the GNU General Public License along
-% with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+/*
 
-@ @c
+Copyright 2006-2012 Taco Hoekwater <taco@luatex.org>
+
+This file is part of LuaTeX.
+
+LuaTeX is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 2 of the License, or (at your
+option) any later version.
+
+LuaTeX is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+License for more details.
+
+You should have received a copy of the GNU General Public License along
+with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+
+*/
 
 #include "ptexlib.h"
 
@@ -26,7 +26,6 @@
 #include <assert.h>
 #include <math.h>
 
-@ @c
 void init_pdf_pagecalculations(PDF pdf)
 {
     pdfstructure *p;
@@ -37,23 +36,30 @@ void init_pdf_pagecalculations(PDF pdf)
     setpdffloat(p->pdf.h, 0, decimal_digits);
     setpdffloat(p->pdf.v, 0, decimal_digits);
     p->cw.e = 1;
-    p->fs_cur.e = p->fs.e = (decimal_digits < 4 ? 5 : 6); /* "+ 2" makes less corrections inside []TJ */
-    /* for placement outside BT...ET */
+    /*tex |+ 2| makes less corrections inside []TJ */
+    p->fs_cur.e = p->fs.e = (decimal_digits < 4 ? 5 : 6);
+    /*tex for placement outside BT...ET */
     setpdffloat(p->cm[0], 1, 0);
     setpdffloat(p->cm[1], 0, 0);
     setpdffloat(p->cm[2], 0, 0);
     setpdffloat(p->cm[3], 1, 0);
-    setpdffloat(p->cm[4], 0, decimal_digits);   /* horizontal movement on page */
-    setpdffloat(p->cm[5], 0, decimal_digits);   /* vertical movement on page */
-    /* for placement inside BT...ET */
-    setpdffloat(p->tm0_cur, 0, 6);              /* mantissa holds HZ expand * ExtendFont */
-    setpdffloat(p->tm[0], ten_pow[6], 6);       /* mantissa holds HZ expand * ExtendFont */
+    /*tex horizontal movement on page */
+    setpdffloat(p->cm[4], 0, decimal_digits);
+    /*tex vertical movement on page */
+    setpdffloat(p->cm[5], 0, decimal_digits);
+    /*tex for placement inside BT...ET */
+    /*tex mantissa holds HZ expand * ExtendFont */
+    setpdffloat(p->tm0_cur, 0, 6);
+    /*tex mantissa holds HZ expand * ExtendFont */
+    setpdffloat(p->tm[0], ten_pow[6], 6);
     setpdffloat(p->tm[1], 0, 0);
-    setpdffloat(p->tm[2], 0, 3);                /* mantissa holds SlantFont, 0 = default */
+    /*tex mantissa holds SlantFont, 0 = default */
+    setpdffloat(p->tm[2], 0, 3);
     setpdffloat(p->tm[3], ten_pow[6], 6);
-    setpdffloat(p->tm[4], 0, decimal_digits);   /* mantissa holds delta from |pdf_bt_pos.h| */
-    setpdffloat(p->tm[5], 0, decimal_digits);   /* mantissa holds delta from |pdf_bt_pos.v| */
-    /*  */
+    /*tex mantissa holds delta from |pdf_bt_pos.h| */
+    setpdffloat(p->tm[4], 0, decimal_digits);
+    /*tex mantissa holds delta from |pdf_bt_pos.v| */
+    setpdffloat(p->tm[5], 0, decimal_digits);
     p->f_pdf_cur = p->f_pdf = null_font;
     p->fs_cur.m = p->fs.m = 0;
     p->wmode = WMODE_H;
@@ -61,10 +67,11 @@ void init_pdf_pagecalculations(PDF pdf)
     p->ishex = 0;
     p->need_tf = false;
     p->need_tm = false;
+    p->done_width = false;
+    p->done_mode = false;
     p->k1 = ten_pow[p->pdf.h.e] / by_one_bp;
 }
 
-@ @c
 void synch_pos_with_cur(posstructure * pos, posstructure * refpos, scaledpos cur)
 {
     switch (pos->dir) {
@@ -93,7 +100,6 @@ void synch_pos_with_cur(posstructure * pos, posstructure * refpos, scaledpos cur
     }
 }
 
-@ @c
 boolean calc_pdfpos(pdfstructure * p, scaledpos pos)
 {
     scaledpos new;
@@ -102,7 +108,8 @@ boolean calc_pdfpos(pdfstructure * p, scaledpos pos)
         case PMODE_PAGE:
             new.h = i64round(pos.h * p->k1);
             new.v = i64round(pos.v * p->k1);
-            p->cm[4].m = new.h - p->pdf.h.m;        /* cm is concatenated */
+            /*tex cm is concatenated */
+            p->cm[4].m = new.h - p->pdf.h.m;
             p->cm[5].m = new.v - p->pdf.v.m;
             if (new.h != p->pdf.h.m || new.v != p->pdf.v.m)
                 move_pdfpos = true;
@@ -110,7 +117,8 @@ boolean calc_pdfpos(pdfstructure * p, scaledpos pos)
         case PMODE_TEXT:
             new.h = i64round(pos.h * p->k1);
             new.v = i64round(pos.v * p->k1);
-            p->tm[4].m = new.h - p->pdf_bt_pos.h.m; /* Tm replaces */
+            /*tex Tm replaces */
+            p->tm[4].m = new.h - p->pdf_bt_pos.h.m;
             p->tm[5].m = new.v - p->pdf_bt_pos.v.m;
             if (new.h != p->pdf.h.m || new.v != p->pdf.v.m)
                 move_pdfpos = true;
@@ -122,14 +130,16 @@ boolean calc_pdfpos(pdfstructure * p, scaledpos pos)
                     new.h = i64round((pos.h * p->k1 - (double) p->pdf_tj_pos.h.m) * p->k2);
                     new.v = i64round(pos.v * p->k1);
                     p->tj_delta.m = -i64round((double) ((new.h - p->cw.m) / ten_pow[p->cw.e - p->tj_delta.e]));
-                    p->tm[5].m = new.v - p->pdf_bt_pos.v.m;     /* p->tm[4] is meaningless */
+                    /*tex p->tm[4] is meaningless */
+                    p->tm[5].m = new.v - p->pdf_bt_pos.v.m;
                     if (p->tj_delta.m != 0 || new.v != p->pdf.v.m)
                         move_pdfpos = true;
                     break;
                 case WMODE_V:
                     new.h = i64round(pos.h * p->k1);
                     new.v = i64round(((double) p->pdf_tj_pos.v.m - pos.v * p->k1) * p->k2);
-                    p->tm[4].m = new.h - p->pdf_bt_pos.h.m;     /* p->tm[5] is meaningless */
+                    /*tex p->tm[5] is meaningless */
+                    p->tm[4].m = new.h - p->pdf_bt_pos.h.m;
                     p->tj_delta.m = -i64round((double) ((new.v - p->cw.m) / ten_pow[p->cw.e - p->tj_delta.e]));
                     if (p->tj_delta.m != 0 || new.h != p->pdf.h.m)
                         move_pdfpos = true;
@@ -145,7 +155,6 @@ boolean calc_pdfpos(pdfstructure * p, scaledpos pos)
     return move_pdfpos;
 }
 
-@ @c
 void print_pdf_matrix(PDF pdf, pdffloat * tm)
 {
     int i;
@@ -156,14 +165,12 @@ void print_pdf_matrix(PDF pdf, pdffloat * tm)
     print_pdffloat(pdf, tm[i]);
 }
 
-@ @c
 void pdf_print_cm(PDF pdf, pdffloat * cm)
 {
     print_pdf_matrix(pdf, cm);
     pdf_puts(pdf, " cm\n");
 }
 
-@ @c
 void pdf_set_pos(PDF pdf, scaledpos pos)
 {
     boolean move;
@@ -178,7 +185,6 @@ void pdf_set_pos(PDF pdf, scaledpos pos)
     }
 }
 
-@ @c
 void pdf_set_pos_temp(PDF pdf, scaledpos pos)
 {
     boolean move;
@@ -191,7 +197,6 @@ void pdf_set_pos_temp(PDF pdf, scaledpos pos)
     }
 }
 
-@ @c
 static void begin_text(PDF pdf)
 {
     pdfstructure *p = pdf->pstruct;
@@ -201,6 +206,8 @@ static void begin_text(PDF pdf)
     pdf_puts(pdf, "BT\n");
     p->mode = PMODE_TEXT;
     p->need_tf = true;
+    p->need_width = 0;
+    p->need_mode = 0;
 }
 
 static void end_text(PDF pdf)
@@ -208,6 +215,16 @@ static void end_text(PDF pdf)
     pdfstructure *p = pdf->pstruct;
     if (!is_textmode(p))
         normal_error("pdf backend","text mode expected in end_text");
+
+    if (p->done_width != 0) {
+        pdf_puts(pdf, "0 w\n");
+        p->done_width = 0;
+    }
+    if (p->done_mode != 0) {
+        pdf_puts(pdf, "0 Tr\n");
+        p->done_mode = 0;
+    }
+
     pdf_puts(pdf, "ET\n");
     p->pdf = p->pdf_bt_pos;
     p->mode = PMODE_PAGE;
@@ -222,7 +239,6 @@ void pdf_end_string_nl(PDF pdf)
         end_chararray(pdf);
 }
 
-@ @c
 void pdf_goto_pagemode(PDF pdf)
 {
     pdfstructure *p = pdf->pstruct;
@@ -245,7 +261,7 @@ void pdf_goto_textmode(PDF pdf)
         0, 0
     };
     if (is_pagemode(p)) {
-        /* reset to page origin */
+        /*tex Reset to the page origin: */
         pdf_set_pos(pdf, origin);
         begin_text(pdf);
     } else if (!is_textmode(p)) {
diff --git a/texk/web2c/luatexdir/pdf/pdfpagetree.w b/texk/web2c/luatexdir/pdf/pdfpagetree.c
similarity index 56%
rename from texk/web2c/luatexdir/pdf/pdfpagetree.w
rename to texk/web2c/luatexdir/pdf/pdfpagetree.c
index 76d008c43..4fcd48e34 100644
--- a/texk/web2c/luatexdir/pdf/pdfpagetree.w
+++ b/texk/web2c/luatexdir/pdf/pdfpagetree.c
@@ -1,38 +1,39 @@
-% pdfpagetree.w
-%
-% Copyright 2006-2011 Taco Hoekwater <taco@@luatex.org>
-%
-% This file is part of LuaTeX.
-%
-% LuaTeX is free software; you can redistribute it and/or modify it under
-% the terms of the GNU General Public License as published by the Free
-% Software Foundation; either version 2 of the License, or (at your
-% option) any later version.
-%
-% LuaTeX is distributed in the hope that it will be useful, but WITHOUT
-% ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-% FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
-% License for more details.
-%
-% You should have received a copy of the GNU General Public License along
-% with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
-
-@ @c
+/*
 
-#include "ptexlib.h"
+Copyright 2006-2011 Taco Hoekwater <taco@luatex.org>
+
+This file is part of LuaTeX.
+
+LuaTeX is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 2 of the License, or (at your
+option) any later version.
+
+LuaTeX is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+License for more details.
 
-@* Page diversions.
+You should have received a copy of the GNU General Public License along
+with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
 
-@ @c
-# define PAGES_TREE_KIDSMAX 10
+*/
+
+#include "ptexlib.h"
+
+#define PAGES_TREE_KIDSMAX 10
 
 static struct avl_table *divert_list_tree = NULL;
 
 typedef struct pages_entry_ {
-    int objnum;                   /* object number of this /Pages object */
-    int number_of_pages;          /* total number of all pages below */
-    int number_of_kids;           /* number of direct kid objects */
-    int kids[PAGES_TREE_KIDSMAX]; /* array of kid object numbers */
+    /*tex The object number of this |/Pages| object. */
+    int objnum;
+    /*tex The total number of all pages below. */
+    int number_of_pages;
+    /*tex The number of direct kid objects. */
+    int number_of_kids;
+    /*tex The array of kid object numbers. */
+    int kids[PAGES_TREE_KIDSMAX];
     struct pages_entry_ *next;
 } pages_entry;
 
@@ -52,7 +53,6 @@ static int comp_divert_list_entry(const void *pa, const void *pb, void *p)
     return 0;
 }
 
-@ @c
 static pages_entry *new_pages_entry(PDF pdf)
 {
     int i;
@@ -65,7 +65,6 @@ static pages_entry *new_pages_entry(PDF pdf)
     return p;
 }
 
-@ @c
 static divert_list_entry *new_divert_list_entry(void)
 {
     divert_list_entry *d;
@@ -74,7 +73,6 @@ static divert_list_entry *new_divert_list_entry(void)
     return d;
 }
 
-@ @c
 static void ensure_list_tree(void)
 {
     if (divert_list_tree == NULL) {
@@ -82,7 +80,6 @@ static void ensure_list_tree(void)
     }
 }
 
-@ @c
 static divert_list_entry *get_divert_list(int divnum)
 {
     divert_list_entry *d, tmp;
@@ -92,7 +89,7 @@ static divert_list_entry *get_divert_list(int divnum)
     if (d == NULL) {
         d = new_divert_list_entry();
         d->divnum = divnum;
-        /* the next bit of code can actually be removed */
+        /*tex The next bit of code can actually be removed. */
         aa = avl_probe(divert_list_tree, d);
         if (aa==NULL) {
             normal_error("pdf backend","page list lookup error");
@@ -101,18 +98,18 @@ static divert_list_entry *get_divert_list(int divnum)
     return d;
 }
 
-@ |pdf_do_page_divert()| returns the current /Parent object number
-@c
+/*tex |pdf_do_page_divert| returns the current |/Parent| object number. */
+
 int pdf_do_page_divert(PDF pdf, int objnum, int divnum)
 {
     divert_list_entry *d;
     pages_entry *p;
-    /* initialize the tree */
+    /*tex Initialize the tree. */
     ensure_list_tree();
-    /* make sure we have a list for this diversion */
+    /*tex Make sure we have a list for this diversion. */
     d = get_divert_list(divnum);
     if (d->first == NULL || d->last->number_of_kids == PAGES_TREE_KIDSMAX) {
-        /* append a new |pages_entry| */
+        /*tex Append a new |pages_entry|. */
         p = new_pages_entry(pdf);
         if (d->first == NULL)
             d->first = p;
@@ -126,33 +123,32 @@ int pdf_do_page_divert(PDF pdf, int objnum, int divnum)
     return p->objnum;
 }
 
-@ @c
 static void movelist(divert_list_entry * d, divert_list_entry * dto)
 {
     if (d != NULL && d->first != NULL && d->divnum != dto->divnum) {
-        /* no undivert of empty list or into self */
+        /*tex No undivert of empty list or into self. */
         if (dto->first == NULL)
             dto->first = d->first;
         else
             dto->last->next = d->first;
         dto->last = d->last;
-        /* one could as well remove this |divert_list_entry| */
+        /*tex One could as well remove this |divert_list_entry|. */
         d->first = d->last = NULL;
     }
 }
 
-@ undivert from diversion |divnum| into diversion |curdivnum|
-@c
+/*tex Undivert from diversion |divnum| into diversion |curdivnum|. */
+
 void pdf_do_page_undivert(int divnum, int curdivnum)
 {
     divert_list_entry *d, *dto, tmp;
     struct avl_traverser t;
-    /*  initialize the tree */
+    /*tex Initialize the tree. */
     ensure_list_tree();
-    /* find the diversion |curdivnum| list where diversion |divnum| should go */
+    /*tex Find the diversion |curdivnum| list where diversion |divnum| should go. */
     dto = get_divert_list(curdivnum);
     if (divnum == 0) {
-        /* 0 = special case: undivert {\it all\/} lists */
+        /*tex Zero is a special case: undivert {\em all} lists. */
         avl_t_init(&t, divert_list_tree);
         for (d = avl_t_first(&t, divert_list_tree); d != NULL;
              d = avl_t_next(&t))
@@ -164,10 +160,9 @@ void pdf_do_page_undivert(int divnum, int curdivnum)
     }
 }
 
-@ write a /Pages object
-@c
+/*tex Write a |/Pages| object. */
 
-static void write_pages(PDF pdf, pages_entry * p, int parent)
+static void write_pages(PDF pdf, pages_entry * p, int parent, int callback_id)
 {
     int i;
     int pages_attributes ;
@@ -175,39 +170,57 @@ static void write_pages(PDF pdf, pages_entry * p, int parent)
     pdf_begin_dict(pdf);
     pdf_dict_add_name(pdf, "Type", "Pages");
     if (parent == 0) {
-        /* it's root */
-        pages_attributes = pdf_pages_attr; /* lookup once */
+        /*tex It's root. Lookup the attributes once. */
+        pages_attributes = pdf_pages_attr;
         if (pages_attributes != null) {
             pdf_print_toks(pdf, pages_attributes);
             pdf_out(pdf, ' ');
         }
         print_pdf_table_string(pdf, "pagesattributes");
         pdf_out(pdf, ' ');
-    } else
+    } else {
         pdf_dict_add_ref(pdf, "Parent", parent);
+    }
     pdf_dict_add_int(pdf, "Count", (int) p->number_of_pages);
     pdf_add_name(pdf, "Kids");
     pdf_begin_array(pdf);
-    for (i = 0; i < p->number_of_kids; i++)
-        pdf_add_ref(pdf, (int) p->kids[i]);
+    for (i = 0; i < p->number_of_kids; i++) {
+        if (callback_id) {
+            /* new */
+            int objnum = (int) p->kids[i];
+            if (obj_type(pdf, objnum) == obj_type_page) {
+                run_callback(callback_id, "d->d", objnum, &objnum);
+                check_obj_exists(pdf, objnum);
+                pdf_add_ref(pdf, (int) objnum);
+            } else {
+                pdf_add_ref(pdf, (int) p->kids[i]);
+            }
+        } else {
+            pdf_add_ref(pdf, (int) p->kids[i]);
+        }
+    }
     pdf_end_array(pdf);
     pdf_end_dict(pdf);
     pdf_end_obj(pdf);
 }
 
-@ loop over all /Pages objects, output them, create their parents,
-recursing bottom up, return the /Pages root object number
+/*tex
+
+    Loop over all |/Pages| objects, output them, create their parents, recursing
+    bottom up, return the |/Pages| root object number.
+
+*/
 
-@c
-static int output_pages_list(PDF pdf, pages_entry * pe)
+static int output_pages_list(PDF pdf, pages_entry * pe, int callback_id)
 {
     pages_entry *p, *q, *r;
     if (pe->next == NULL) {
-        /* everything fits into one |pages_entry| */
-        write_pages(pdf, pe, 0); /* /Pages root found */
+        /*tex Everything fits into one |pages_entry|. */
+        write_pages(pdf, pe, 0, callback_id);
         return pe->objnum;
     }
-    q = r = new_pages_entry(pdf); /* one level higher needed */
+    /*tex One level higher needed. */
+    q = r = new_pages_entry(pdf);
     for (p = pe; p != NULL; p = p->next) {
         if (q->number_of_kids == PAGES_TREE_KIDSMAX) {
             q->next = new_pages_entry(pdf);
@@ -215,16 +228,19 @@ static int output_pages_list(PDF pdf, pages_entry * pe)
         }
         q->kids[q->number_of_kids++] = p->objnum;
         q->number_of_pages += p->number_of_pages;
-        write_pages(pdf, p, q->objnum);
+        write_pages(pdf, p, q->objnum, callback_id);
     }
-    return output_pages_list(pdf, r); /* recurse through next higher level */
+    /*tex Recurse through next higher level. */
+    return output_pages_list(pdf, r, callback_id);
 }
 
-@ @c
 int output_pages_tree(PDF pdf)
 {
+    int callback_id = callback_defined(page_objnum_provider_callback);
     divert_list_entry *d;
-    pdf_do_page_undivert(0, 0); /* concatenate all diversions into diversion 0 */
-    d = get_divert_list(0);     /* get diversion 0 */
-    return output_pages_list(pdf, d->first);
+    /*tex Concatenate all diversions into diversion 0. */
+    pdf_do_page_undivert(0, 0);
+    /*tex Get diversion 0. */
+    d = get_divert_list(0);
+    return output_pages_list(pdf, d->first, callback_id);
 }
diff --git a/texk/web2c/luatexdir/pdf/pdfrule.w b/texk/web2c/luatexdir/pdf/pdfrule.c
similarity index 56%
rename from texk/web2c/luatexdir/pdf/pdfrule.w
rename to texk/web2c/luatexdir/pdf/pdfrule.c
index df4979088..de689a147 100644
--- a/texk/web2c/luatexdir/pdf/pdfrule.w
+++ b/texk/web2c/luatexdir/pdf/pdfrule.c
@@ -1,29 +1,26 @@
-% pdfrule.w
-%
-% Copyright 2010-2011 Taco Hoekwater <taco@@luatex.org>
-%
-% This file is part of LuaTeX.
-%
-% LuaTeX is free software; you can redistribute it and/or modify it under
-% the terms of the GNU General Public License as published by the Free
-% Software Foundation; either version 2 of the License, or (at your
-% option) any later version.
-%
-% LuaTeX is distributed in the hope that it will be useful, but WITHOUT
-% ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-% FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
-% License for more details.
-%
-% You should have received a copy of the GNU General Public License along
-% with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+/*
 
-@ @c
-#include "ptexlib.h"
-#include "pdf/pdfpage.h"
+Copyright 2010-2011 Taco Hoekwater <taco@luatex.org>
+
+This file is part of LuaTeX.
+
+LuaTeX is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 2 of the License, or (at your
+option) any later version.
 
-@ @c
+LuaTeX is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+License for more details.
 
-/* maybe we should have an extra callback on normal rules or on any rule in 2.0+ */
+You should have received a copy of the GNU General Public License along
+with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#include "ptexlib.h"
+#include "pdf/pdfpage.h"
 
 void pdf_place_rule(PDF pdf, halfword q, scaledpos size, int callback_id)
 {
@@ -31,7 +28,6 @@ void pdf_place_rule(PDF pdf, halfword q, scaledpos size, int callback_id)
     pdfstructure *p = pdf->pstruct;
     scaledpos pos = pdf->posstruct->pos;
     halfword s = subtype(q);
-    /*  (void) q; */
     if (s >= math_over_rule && s <= math_radical_rule) {
         if (callback_id == 0) {
             s = normal_rule;
@@ -44,7 +40,7 @@ void pdf_place_rule(PDF pdf, halfword q, scaledpos size, int callback_id)
     } else if (s == image_rule) {
         pdf_place_image(pdf,q);
     } else if (s == empty_rule) {
-        /* place nothing, only take space */
+        /*tex Place nothing, only take space. */
     } else if (s == user_rule) {
         if (callback_id != 0) {
             pdf_goto_pagemode(pdf);
@@ -54,7 +50,7 @@ void pdf_place_rule(PDF pdf, halfword q, scaledpos size, int callback_id)
             pdf_puts(pdf, "\nQ\n");
         }
     } else {
-        /* normal_rule or >= 100 being a leader rule */
+        /*tex |normal_rule| or >= 100 being a leader rule */
         pdf_goto_pagemode(pdf);
         dim.h.m = i64round(size.h * p->k1);
         dim.h.e = p->pdf.h.e;
@@ -64,7 +60,7 @@ void pdf_place_rule(PDF pdf, halfword q, scaledpos size, int callback_id)
         if (size.v <= one_bp) {
             pos.v += i64round(0.5 * size.v);
             pdf_set_pos_temp(pdf, pos);
-            pdf_puts(pdf, "[]0 d 0 J ");
+            pdf_puts(pdf, "[] 0 d 0 J ");
             print_pdffloat(pdf, dim.v);
             pdf_puts(pdf, " w 0 0 m ");
             print_pdffloat(pdf, dim.h);
@@ -72,18 +68,32 @@ void pdf_place_rule(PDF pdf, halfword q, scaledpos size, int callback_id)
         } else if (size.h <= one_bp) {
             pos.h += i64round(0.5 * size.h);
             pdf_set_pos_temp(pdf, pos);
-            pdf_puts(pdf, "[]0 d 0 J ");
+            pdf_puts(pdf, "[] 0 d 0 J ");
             print_pdffloat(pdf, dim.h);
             pdf_puts(pdf, " w 0 0 m 0 ");
             print_pdffloat(pdf, dim.v);
             pdf_puts(pdf, " l S\n");
         } else {
             pdf_set_pos_temp(pdf, pos);
+            if (s == outline_rule) {
+                pdf_puts(pdf, "[] 0 d 0 J ");
+                if (rule_transform(q) > 0) {
+                    pdfpos temp ;
+                    temp.h.m = i64round(rule_transform(q) * p->k1);
+                    temp.h.e = p->pdf.h.e;
+                    print_pdffloat(pdf, temp.h);
+                    pdf_puts(pdf, " w ");
+                }
+            }
             pdf_puts(pdf, "0 0 ");
             print_pdffloat(pdf, dim.h);
             pdf_out(pdf, ' ');
             print_pdffloat(pdf, dim.v);
-            pdf_puts(pdf, " re f\n");
+            if (s == outline_rule) {
+                pdf_puts(pdf, " re S\n");
+            } else {
+                pdf_puts(pdf, " re f\n");
+            }
         }
         pdf_puts(pdf, "Q\n");
     }
diff --git a/texk/web2c/luatexdir/pdf/pdfsaverestore.w b/texk/web2c/luatexdir/pdf/pdfsaverestore.c
similarity index 63%
rename from texk/web2c/luatexdir/pdf/pdfsaverestore.w
rename to texk/web2c/luatexdir/pdf/pdfsaverestore.c
index 0d91de544..abfb48142 100644
--- a/texk/web2c/luatexdir/pdf/pdfsaverestore.w
+++ b/texk/web2c/luatexdir/pdf/pdfsaverestore.c
@@ -1,32 +1,30 @@
-% pdfsaverestore.w
-%
-% Copyright 2010 Taco Hoekwater <taco@@luatex.org>
-%
-% This file is part of LuaTeX.
-%
-% LuaTeX is free software; you can redistribute it and/or modify it under
-% the terms of the GNU General Public License as published by the Free
-% Software Foundation; either version 2 of the License, or (at your
-% option) any later version.
-%
-% LuaTeX is distributed in the hope that it will be useful, but WITHOUT
-% ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-% FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
-% License for more details.
-%
-% You should have received a copy of the GNU General Public License along
-% with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+/*
 
-@ @c
+Copyright 2010 Taco Hoekwater <taco@luatex.org>
+
+This file is part of LuaTeX.
+
+LuaTeX is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 2 of the License, or (at your
+option) any later version.
+
+LuaTeX is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+License for more details.
+
+You should have received a copy of the GNU General Public License along
+with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+
+*/
 
 #include "ptexlib.h"
 
-@ @c
-pos_entry *pos_stack = 0; /* the stack */
-int pos_stack_size = 0;   /* initially empty */
-int pos_stack_used = 0;   /* used entries */
+pos_entry *pos_stack = 0;
+int pos_stack_size = 0;
+int pos_stack_used = 0;
 
-@ @c
 static void checkpdfsave(scaledpos pos)
 {
     pos_entry *new_stack;
@@ -45,7 +43,6 @@ static void checkpdfsave(scaledpos pos)
     pos_stack_used++;
 }
 
-@ @c
 static void checkpdfrestore(scaledpos pos)
 {
     scaledpos diff;
@@ -64,7 +61,6 @@ static void checkpdfrestore(scaledpos pos)
     }
 }
 
-@ @c
 void pdf_out_save(PDF pdf, halfword p)
 {
     (void) p;
@@ -72,7 +68,6 @@ void pdf_out_save(PDF pdf, halfword p)
     pdf_literal(pdf, 'q', set_origin, false);
 }
 
-@ @c
 void pdf_out_restore(PDF pdf, halfword p)
 {
     (void) p;
diff --git a/texk/web2c/luatexdir/pdf/pdfsetmatrix.w b/texk/web2c/luatexdir/pdf/pdfsetmatrix.c
similarity index 65%
rename from texk/web2c/luatexdir/pdf/pdfsetmatrix.w
rename to texk/web2c/luatexdir/pdf/pdfsetmatrix.c
index b107033b9..f19c1721d 100644
--- a/texk/web2c/luatexdir/pdf/pdfsetmatrix.w
+++ b/texk/web2c/luatexdir/pdf/pdfsetmatrix.c
@@ -1,34 +1,36 @@
-% pdfsetmatrix.w
-%
-% Copyright 2009 Taco Hoekwater <taco@@luatex.org>
-%
-% This file is part of LuaTeX.
-%
-% LuaTeX is free software; you can redistribute it and/or modify it under
-% the terms of the GNU General Public License as published by the Free
-% Software Foundation; either version 2 of the License, or (at your
-% option) any later version.
-%
-% LuaTeX is distributed in the hope that it will be useful, but WITHOUT
-% ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-% FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
-% License for more details.
-%
-% You should have received a copy of the GNU General Public License along
-% with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
-
-@ @c
+/*
+
+Copyright 2009 Taco Hoekwater <taco@luatex.org>
+
+This file is part of LuaTeX.
+
+LuaTeX is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 2 of the License, or (at your
+option) any later version.
+
+LuaTeX is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+License for more details.
+
+You should have received a copy of the GNU General Public License along
+with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+
+*/
 
 #include "ptexlib.h"
 
-@ stack for \.{\\pdfextension setmatrix}
+/*tex
+
+    We keep a stack for |pdfextension setmatrix|:
+
+*/
 
-@c
 matrix_entry *matrix_stack = NULL;
 int matrix_stack_size = 0;
 int matrix_stack_used = 0;
 
-@ @c
 boolean matrixused(void)
 {
     return matrix_stack_used > 0;
@@ -46,40 +48,40 @@ static void matrix_stack_room(void)
     }
 }
 
-@ \.{\\pdfextension setmatrix{a b c d}}
-
-|e| := pos.h
+/*tex
 
-|f| := pos.v
+    The matrix specification has four entries and gets translated to |e| being
+    |pos.h and |f| being pos.v. The current active matrix at the top of the
+    matrix stack is kept in |M_top|.
 
-|M_top|: current active matrix at the top of the matrix stack
+    The origin of \.{\\pdfextension setmatrix} is the current point. The
+    annotation coordinate system is the original page coordinate system. When
+    pdfTeX calculates annotation rectangles it does not take into account this
+    transformations, it uses the original coordinate system. To get the corrected
+    values, first we go back to the origin, perform the transformation and go
+    back:
 
-The origin of \.{\\pdfextension setmatrix} is the current point. The annotation
-coordinate system is the original page coordinate system. When pdfTeX calculates
-annotation rectangles it does not take into account this transformations, it uses
-the original coordinate system. To get the corrected values, first we go back to
-the origin, perform the transformation and go back:
+    \starttyping
+      (  1   0  0 )   ( a b 0 )   ( 1 0 0 )
+      (  0   1  0 ) x ( c d 0 ) x ( 0 1 0 ) x M\_top
+      ( -e  -f  1 )   ( 0 0 1 )   ( e f 1 )
 
-{\obeylines\obeyspaces\tt
-    (  1   0  0 )   ( a b 0 )   ( 1 0 0 )
-    (  0   1  0 ) x ( c d 0 ) x ( 0 1 0 ) x M\_top
-    ( -e  -f  1 )   ( 0 0 1 )   ( e f 1 )
+      ( 1  0  0 )   (  a  b 0 )
+    = ( 0  1  0 ) x (  c  d 0 ) x M\_top
+      ( e  f  1 )   ( -e -f 1 )
 
-    ( 1  0  0 )   (  a  b 0 )
-  = ( 0  1  0 ) x (  c  d 0 ) x M\_top
-    ( e  f  1 )   ( -e -f 1 )
+      ( a         b         0 )
+    = ( c         d         0 ) x M\_top
+      ( e(1-a)-fc f(1-d)-eb 1 )
+    \stoptyping
 
-    ( a         b         0 )
-  = ( c         d         0 ) x M\_top
-    ( e(1-a)-fc f(1-d)-eb 1 )
-}
+*/
 
-@c
 static void pdfsetmatrix(const char *in, scaledpos pos)
 {
-    /*
-        Argument of \.{\\pdfextension setmatrix} starts with |str_pool[in]| and ends
-        before |str_pool[pool_ptr]|.
+    /*tex
+        The argument of |pdfextension setmatrix| starts with |str_pool[in]|
+        and ends before |str_pool[pool_ptr]|.
     */
     matrix_entry x, *y, *z;
     if (global_shipping_mode == SHIPPING_PAGE) {
@@ -87,7 +89,7 @@ static void pdfsetmatrix(const char *in, scaledpos pos)
             formatted_warning("pdf backend","unrecognized format of setmatrix: %s", in);
             return;
         }
-        /* calculate this transformation matrix */
+        /*tex Calculate this transformation matrix. */
         x.e = (double) pos.h * (1.0 - x.a) - (double) pos.v * x.c;
         x.f = (double) pos.v * (1.0 - x.d) - (double) pos.h * x.b;
         matrix_stack_room();
@@ -112,19 +114,21 @@ static void pdfsetmatrix(const char *in, scaledpos pos)
     }
 }
 
-@ Apply matrix to point (x,y)
+/*tex
 
-{\obeylines\obeyspaces\tt
-               ( a b 0 )
-   ( x y 1 ) x ( c d 0 ) = ( xa+yc+e xb+yd+f 1 )
-               ( e f 1 )
-}
+    Apply matrix to point (x,y)
+
+    \starttyping
+                ( a b 0 )
+    ( x y 1 ) x ( c d 0 ) = ( xa+yc+e xb+yd+f 1 )
+                ( e f 1 )
+    \stoptyping
 
-If \.{\\pdfextension setmatrix} wasn't used, then return the value unchanged.
+    If \.{\\pdfextension setmatrix} wasn't used, then return the value unchanged.
+    The return values for matrix tranform functions are:
 
-@ Return values for matrix tranform functions:
+*/
 
-@c
 static scaled ret_llx;
 static scaled ret_lly;
 static scaled ret_urx;
@@ -150,7 +154,6 @@ scaled getury(void)
     return ret_ury;
 }
 
-@ @c
 static int last_llx;
 static int last_lly;
 static int last_urx;
@@ -210,11 +213,10 @@ void matrixrecalculate(scaled urx)
     matrixtransformrect(last_llx, last_lly, urx, last_ury);
 }
 
-@ @c
 void pdf_out_setmatrix(PDF pdf, halfword p)
 {
     scaledpos pos = pdf->posstruct->pos;
-    int old_setting;            /* holds print |selector| */
+    int old_setting;
     str_number s;
     old_setting = selector;
     selector = new_string;
diff --git a/texk/web2c/luatexdir/pdf/pdfshipout.w b/texk/web2c/luatexdir/pdf/pdfshipout.c
similarity index 75%
rename from texk/web2c/luatexdir/pdf/pdfshipout.w
rename to texk/web2c/luatexdir/pdf/pdfshipout.c
index 8665f685e..084efc086 100644
--- a/texk/web2c/luatexdir/pdf/pdfshipout.w
+++ b/texk/web2c/luatexdir/pdf/pdfshipout.c
@@ -1,51 +1,55 @@
-% pdfshipout.w
-%
-% Copyright 2010-2012 Taco Hoekwater <taco@@luatex.org>
-%
-% This file is part of LuaTeX.
-%
-% LuaTeX is free software; you can redistribute it and/or modify it under
-% the terms of the GNU General Public License as published by the Free
-% Software Foundation; either version 2 of the License, or (at your
-% option) any later version.
-%
-% LuaTeX is distributed in the hope that it will be useful, but WITHOUT
-% ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-% FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
-% License for more details.
-%
-% You should have received a copy of the GNU General Public License along
-% with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+/*
 
-@ @c
+Copyright 2010-2012 Taco Hoekwater <taco@luatex.org>
+
+This file is part of LuaTeX.
+
+LuaTeX is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 2 of the License, or (at your
+option) any later version.
+
+LuaTeX is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+License for more details.
+
+You should have received a copy of the GNU General Public License along
+with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+
+*/
 
 #include "ptexlib.h"
 
-@ @c
 scaledpos shipbox_refpos;
 
-@ |ship_out| is used to shipout a box to PDF or DVI mode. If |shipping_mode| is
-set to |SHIPPING_FORM| then the output will be a Form object (only PDF), and if
-it is set to |SHIPPING_PAGE| it will be a Page object.
+/*tex
+
+    |ship_out| is used to shipout a box to PDF or DVI mode. If |shipping_mode| is
+    set to |SHIPPING_FORM| then the output will be a |Form| object (only PDF), and
+    if it is set to |SHIPPING_PAGE| it will be a |Page| object.
+
+*/
 
-@c
 void ship_out(PDF pdf, halfword p, shipping_mode_e shipping_mode)
 {
-    int j, k;              /* indices to first ten count registers */
+    /*tex Indices to first ten count registers: */
+    int j, k;
     int post_callback_id;
     int pre_callback_id;
-    posstructure refpoint; /* the origin pos. on the page */
+    /*tex The origin position on the page: */
+    posstructure refpoint;
     int rule_callback_id = 0;
     scaledpos cur = { 0, 0 };
     refpoint.pos.h = 0;
     refpoint.pos.v = 0;
     ensure_output_state(pdf, ST_HEADER_WRITTEN);
-    fix_o_mode(); /* this is only for complaining if \.{\\outputmode} has changed */
-    init_backend_functionpointers(output_mode_used);
+    /*tex This is only for complaining if \.{\\outputmode} has changed: */
+    fix_o_mode();
     pdf->f_cur = null_font;
-    /*
-        Start sheet {\sl Sync\TeX} information record; we assume that |pdf_output| is
-        properly set up.
+    /*tex
+        Start sheet {\sl Sync\TeX} information record. We assume that
+        |pdf_output| is properly set up.
     */
     if (synctex_par) {
         if (output_mode_used == OMODE_DVI) {
@@ -82,16 +86,18 @@ void ship_out(PDF pdf, halfword p, shipping_mode_e shipping_mode)
         }
     }
     if ((tracing_output_par > 0) && shipping_mode == SHIPPING_PAGE) {
-        print_char(']');
+        if (pre_callback_id == 0) {
+            print_char(']');
+        }
         update_terminal();
         begin_diagnostic();
         show_box(p);
         end_diagnostic(true);
     }
-    /* Ship box |p| out */
+    /*tex Ship out box |p|:*/
     if (shipping_mode == SHIPPING_PAGE && box_dir(p) != page_direction_par)
         normal_warning("backend","pagedir differs from bodydir, the output may be placed wrongly on the page");
-    /*
+    /*tex
         Update the values of |max_h| and |max_v|; but if the page is too large,
         |goto done|. Sometimes the user will generate a huge page because other
         error messages are being ignored. Such pages are not output to the
@@ -116,7 +122,7 @@ void ship_out(PDF pdf, halfword p, shipping_mode_e shipping_mode)
         max_v = height(p) + depth(p) + v_offset_par;
     if (width(p) + h_offset_par > max_h)
         max_h = width(p) + h_offset_par;
-    /* Calculate page dimensions and margins */
+    /*tex Calculate page dimensions and margins. */
     if (global_shipping_mode == SHIPPING_PAGE) {
         if (page_width_par > 0)
             pdf->page_size.h = page_width_par;
@@ -156,28 +162,14 @@ void ship_out(PDF pdf, halfword p, shipping_mode_e shipping_mode)
                     normal_warning("pdf backend","bad page direction, assuming TLT, case 2");
                 }
         }
-        /*
+        /*tex
             Think in upright page/paper coordinates (page origin = lower left edge).
             First preset |refpoint.pos| to the DVI origin (near upper left page edge).
         */
-        switch (output_mode_used) {
-            case OMODE_DVI:
-                /* hh: how can we end up here? */
-                refpoint.pos.h = one_true_inch;
-                refpoint.pos.v = pdf->page_size.v - one_true_inch;
-                dvi = refpoint.pos;
-                break;
-            case OMODE_PDF:
-                refpoint.pos.h = pdf_h_origin;
-                refpoint.pos.v = pdf->page_size.v - pdf_v_origin;
-                break;
-            default:
-                normal_error("pdf backend", "unknown output mode");
-        }
-
-        /*
+        backend_out_control[backend_control_set_reference_point](pdf,&refpoint);
+        /*tex
             Then shift |refpoint.pos| of the DVI origin depending on the
-            |page_direction| within the upright (TLT) page coordinate system
+            |page_direction| within the upright (TLT) page coordinate system.
         */
         switch (page_direction_par) {
             case dir_TLT:
@@ -195,7 +187,7 @@ void ship_out(PDF pdf, halfword p, shipping_mode_e shipping_mode)
                 refpoint.pos.v -= v_offset_par;
                 normal_warning("pdf backend","bad page direction, assuming TLT, case 3");
         }
-        /*
+        /*tex
             Then switch to page box coordinate system; do |height(p)| movement,
             to get the location of the box origin.
         */
@@ -204,7 +196,7 @@ void ship_out(PDF pdf, halfword p, shipping_mode_e shipping_mode)
         cur.v = height(p);
         synch_pos_with_cur(pdf->posstruct, &refpoint, cur);
     } else {
-        /* shipping a /Form */
+        /*tex We're shipping out a |/Form|. */
         pdf->posstruct->dir = box_dir(p);
         switch (pdf->posstruct->dir) {
             case dir_TLT:
@@ -245,18 +237,12 @@ void ship_out(PDF pdf, halfword p, shipping_mode_e shipping_mode)
                 normal_warning("pdf backend","bad page direction, assuming TLT, case 5");
         }
     }
-    /* Now we are at the point on the page where the origin of the page box should go. */
-    shipbox_refpos = pdf->posstruct->pos; /* for \.{\\gleaders} */
-    switch (output_mode_used) {
-        case OMODE_DVI:
-            dvi_begin_page(pdf);
-            break;
-        case OMODE_PDF:
-            pdf_begin_page(pdf);
-            break;
-        default:
-            normal_error("pdf backend", "unknown output mode");
-    }
+    /*tex
+        Now we are at the point on the page where the origin of the page box
+        should go. First we register the poisition for \.{\\gleaders}.
+    */
+    shipbox_refpos = pdf->posstruct->pos;
+    backend_out_control[backend_control_begin_page](pdf);
     rule_callback_id = callback_defined(process_rule_callback);
     switch (type(p)) {
         case vlist_node:
@@ -271,24 +257,15 @@ void ship_out(PDF pdf, halfword p, shipping_mode_e shipping_mode)
     if (shipping_mode == SHIPPING_PAGE)
         total_pages++;
     cur_s = -1;
-    /* Finish shipping */
-    switch (output_mode_used) {
-        case OMODE_DVI:
-            dvi_end_page(pdf);
-            break;
-        case OMODE_PDF:
-            pdf_end_page(pdf);
-            break;
-        default:
-            normal_error("pdf backend", "unknown output mode");
-    }
+    /*tex Finish shipping */
+    backend_out_control[backend_control_end_page](pdf);
   DONE:
     if ((tracing_output_par <= 0) && (post_callback_id == 0) && shipping_mode == SHIPPING_PAGE) {
         print_char(']');
         update_terminal();
     }
     dead_cycles = 0;
-    /* Flush the box from memory, showing statistics if requested */
+    /*tex Flush the box from memory, showing statistics if requested. */
     if ((tracing_stats_par > 1) && (pre_callback_id == 0)) {
         tprint_nl("Memory usage before: ");
         print_int(var_used);
@@ -306,7 +283,7 @@ void ship_out(PDF pdf, halfword p, shipping_mode_e shipping_mode)
     }
     if (shipping_mode == SHIPPING_PAGE && (post_callback_id > 0))
         (void) run_callback(post_callback_id, "->");
-    /* Finish sheet {\sl Sync\TeX} information record */
+    /*tex Finish sheet {\sl Sync\TeX} information record. */
     if (synctex_par)
         synctexteehs();
     global_shipping_mode = NOT_SHIPPING;
diff --git a/texk/web2c/luatexdir/pdf/pdftables.w b/texk/web2c/luatexdir/pdf/pdftables.c
similarity index 79%
rename from texk/web2c/luatexdir/pdf/pdftables.w
rename to texk/web2c/luatexdir/pdf/pdftables.c
index 31fc2c9ad..180c23234 100644
--- a/texk/web2c/luatexdir/pdf/pdftables.w
+++ b/texk/web2c/luatexdir/pdf/pdftables.c
@@ -1,27 +1,26 @@
-% pdftables.w
-%
-% Copyright 2009-2010 Taco Hoekwater <taco@@luatex.org>
-%
-% This file is part of LuaTeX.
-%
-% LuaTeX is free software; you can redistribute it and/or modify it under
-% the terms of the GNU General Public License as published by the Free
-% Software Foundation; either version 2 of the License, or (at your
-% option) any later version.
-%
-% LuaTeX is distributed in the hope that it will be useful, but WITHOUT
-% ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-% FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
-% License for more details.
-%
-% You should have received a copy of the GNU General Public License along
-% with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+/*
 
-@ @c
+Copyright 2009-2010 Taco Hoekwater <taco@luatex.org>
+
+This file is part of LuaTeX.
+
+LuaTeX is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 2 of the License, or (at your
+option) any later version.
+
+LuaTeX is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+License for more details.
+
+You should have received a copy of the GNU General Public License along
+with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+
+*/
 
 #include "ptexlib.h"
 
-@ @c
 const char *pdf_obj_typenames[PDF_OBJ_TYPE_MAX + 1] = {
     "font", "outline", "dest", "obj", "xform", "ximage", "thread",
     "pagestream", "page", "pages", "catalog", "info", "link", "annot", "annots",
@@ -31,21 +30,26 @@ const char *pdf_obj_typenames[PDF_OBJ_TYPE_MAX + 1] = {
 int pdf_last_annot;
 int pdf_last_link;
 int pdf_last_obj;
-int pdf_retval;                 /* global multi-purpose return value */
-int pdf_cur_form;               /* the form being output */
+int pdf_retval;
+int pdf_cur_form;
+
+/*tex
+
+    AVL sort entry into |avl_table[]|.
+*/
 
-@ AVL sort entry into |avl_table[]|
-@c
 static int compare_info(const void *pa, const void *pb, void *param)
 {
     const oentry *a = (const oentry *) pa;
     const oentry *b = (const oentry *) pb;
     (void) param;
     if (a->u_type == b->u_type) {
-        if (a->u_type == union_type_int)
+        if (a->u_type == union_type_int) {
             return ((a->u.int0 < b->u.int0 ? -1 : (a->u.int0 > b->u.int0 ? 1 : 0)));
-        else /* string type */
+        } else {
+            /*tex String type: */
             return strcmp(a->u.str0, b->u.str0);
+        }
     } else if (a->u_type == union_type_int) {
         return -1;
     } else {
@@ -78,7 +82,8 @@ static void avl_put_int_obj(PDF pdf, int int0, int objptr, int t)
 static void avl_put_str_obj(PDF pdf, char *str0, int objptr, int t)
 {
     oentry *oe = xtalloc(1, oentry);
-    oe->u.str0 = str0;          /* no xstrdup() here */
+    /*tex No |xstrdup| here! */
+    oe->u.str0 = str0;
     oe->u_type = union_type_cstring;
     oe->objptr = objptr;
     avl_put_obj(pdf, t, oe);
@@ -112,9 +117,8 @@ static int avl_find_str_obj(PDF pdf, int t, char *s)
     return p->objptr;
 }
 
-@ Create an object with type |t| and identifier |i|
+/*tex Create an object with type |t| and identifier |i|: */
 
-@c
 int pdf_create_obj(PDF pdf, int t, int i)
 {
     int a;
@@ -148,7 +152,6 @@ int pdf_create_obj(PDF pdf, int t, int i)
     return pdf->obj_ptr;
 }
 
-@ @c
 int find_obj(PDF pdf, int t, int i, boolean byname)
 {
     char *ss = NULL;
@@ -163,14 +166,17 @@ int find_obj(PDF pdf, int t, int i, boolean byname)
     return ret;
 }
 
-@ The following function finds an object with identifier |i| and type |t|.
-Identifier |i| is either an integer or a token list index. If no such object
-exists then it will be created. This function is used mainly to find destination
-for link annotations and outlines; however it is also used in |ship_out| (to
-check whether a Page object already exists) so we need to declare it together
-with subroutines needed in |hlist_out| and |vlist_out|.
+/*tex
+
+    The following function finds an object with identifier |i| and type |t|.
+    Identifier |i| is either an integer or a token list index. If no such object
+    exists then it will be created. This function is used mainly to find
+    destination for link annotations and outlines; however it is also used in
+    |ship_out| (to check whether a Page object already exists) so we need to
+    declare it together with subroutines needed in |hlist_out| and |vlist_out|.
+
+*/
 
-@c
 int pdf_get_obj(PDF pdf, int t, int i, boolean byname)
 {
     int r;
@@ -197,8 +203,8 @@ int pdf_get_obj(PDF pdf, int t, int i, boolean byname)
     return r;
 }
 
-@ object checking
-@c
+/*tex Some object checking: */
+
 void check_obj_exists(PDF pdf, int objnum)
 {
     if (objnum < 0 || objnum > pdf->obj_ptr)
@@ -216,14 +222,15 @@ void check_obj_type(PDF pdf, int t, int objnum)
     }
 }
 
-@ @c
 void set_rect_dimens(PDF pdf, halfword p, halfword parent_box, scaledpos cur, scaled_whd alt_rule, scaled margin)
 {
-    scaledpos ll, ur; /* positions relative to cur */
+    /*tex The positions relative to cur: */
+    scaledpos ll, ur;
     scaledpos pos_ll, pos_ur, tmp;
     posstructure localpos;
     localpos.dir = pdf->posstruct->dir;
-    ll.h = 0; /* pdf contains current point on page */
+    /*tex |pdf| contains current point on page: */
+    ll.h = 0;
     if (is_running(alt_rule.dp))
         ll.v = depth(parent_box) - cur.v;
     else
@@ -263,7 +270,6 @@ void set_rect_dimens(PDF pdf, halfword p, halfword parent_box, scaledpos cur, sc
     pdf_ann_top(p) = pos_ur.v + margin;
 }
 
-@ @c
 void libpdffinish(PDF pdf)
 {
     strbuf_free(pdf->fb);
diff --git a/texk/web2c/luatexdir/pdf/pdfthread.w b/texk/web2c/luatexdir/pdf/pdfthread.c
similarity index 88%
rename from texk/web2c/luatexdir/pdf/pdfthread.w
rename to texk/web2c/luatexdir/pdf/pdfthread.c
index 6b3dd4b94..20cc7bf0a 100644
--- a/texk/web2c/luatexdir/pdf/pdfthread.w
+++ b/texk/web2c/luatexdir/pdf/pdfthread.c
@@ -1,28 +1,32 @@
-% pdfthread.w
-%
-% Copyright 2009-2012 Taco Hoekwater <taco@@luatex.org>
-%
-% This file is part of LuaTeX.
-%
-% LuaTeX is free software; you can redistribute it and/or modify it under
-% the terms of the GNU General Public License as published by the Free
-% Software Foundation; either version 2 of the License, or (at your
-% option) any later version.
-%
-% LuaTeX is distributed in the hope that it will be useful, but WITHOUT
-% ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-% FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
-% License for more details.
-%
-% You should have received a copy of the GNU General Public License along
-% with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+/*
 
-@ @c
+Copyright 2009-2012 Taco Hoekwater <taco@@luatex.org>
+
+This file is part of LuaTeX.
+
+LuaTeX is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 2 of the License, or (at your
+option) any later version.
+
+LuaTeX is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+License for more details.
+
+You should have received a copy of the GNU General Public License along
+with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+
+*/
 
 #include "ptexlib.h"
 
-@ Threads are handled in similar way as link annotations
-@c
+/*tex
+
+    Threads are handled in similar way as link annotations.
+
+*/
+
 void append_bead(PDF pdf, halfword p)
 {
     int a, b, c, t;
@@ -52,7 +56,6 @@ void append_bead(PDF pdf, halfword p)
     addto_page_resources(pdf, obj_type_bead, b);
 }
 
-@ @c
 void do_thread(PDF pdf, halfword p, halfword parent_box, scaledpos cur)
 {
     scaled_whd alt_rule;
@@ -78,7 +81,6 @@ void do_thread(PDF pdf, halfword p, halfword parent_box, scaledpos cur)
     pdf->last_thread = p;
 }
 
-@ @c
 void append_thread(PDF pdf, halfword parent_box, scaledpos cur)
 {
     scaled_whd alt_rule;
@@ -102,7 +104,6 @@ void append_thread(PDF pdf, halfword parent_box, scaledpos cur)
     pdf->last_thread = p;
 }
 
-@ @c
 void end_thread(PDF pdf, halfword p)
 {
     scaledpos pos = pdf->posstruct->pos;
@@ -131,8 +132,8 @@ void end_thread(PDF pdf, halfword p)
     pdf->last_thread = null;
 }
 
-@ The following function are needed for outputing article thread.
-@c
+/*tex The following function are needed for outputing article thread. */
+
 void thread_title(PDF pdf, int t)
 {
     pdf_add_name(pdf, "Title");
@@ -224,7 +225,6 @@ void out_thread(PDF pdf, int t)
     } while (a != b);
 }
 
-@ @c
 void scan_thread_id(void)
 {
     if (scan_keyword("num")) {
@@ -251,7 +251,6 @@ void check_running_thread(PDF pdf, halfword this_box, scaledpos cur)
         append_thread(pdf, this_box, cur);
 }
 
-@ @c
 void print_bead_rectangles(PDF pdf)
 {
     halfword i;
@@ -262,13 +261,15 @@ void print_bead_rectangles(PDF pdf)
             l = pdf_create_obj(pdf, obj_type_others, 0);
             pdf_begin_obj(pdf, l, OBJSTM_ALWAYS);
             pdf_begin_array(pdf);
-            i = obj_bead_data(pdf, k->info); /* pointer to a whatsit or whatsit-like node */
+            /*tex A pointer to a whatsit or whatsit-like node: */
+            i = obj_bead_data(pdf, k->info);
             pdf_add_rect_spec(pdf, i);
             if (subtype(i) == pdf_thread_data_node)
                 flush_node(i);
             pdf_end_array(pdf);
             pdf_end_obj(pdf);
-            set_obj_bead_rect(pdf, k->info, l); /* rewrite |obj_bead_data| */
+            /*tex Rewrite |obj_bead_data|: */
+            set_obj_bead_rect(pdf, k->info, l);
             k = k->link;
         }
     }
diff --git a/texk/web2c/luatexdir/pdf/pdfxform.w b/texk/web2c/luatexdir/pdf/pdfxform.c
similarity index 74%
rename from texk/web2c/luatexdir/pdf/pdfxform.w
rename to texk/web2c/luatexdir/pdf/pdfxform.c
index 731dc2290..7fd4eef1d 100644
--- a/texk/web2c/luatexdir/pdf/pdfxform.w
+++ b/texk/web2c/luatexdir/pdf/pdfxform.c
@@ -1,28 +1,30 @@
-% pdfxform.w
-%
-% Copyright 2009-2011 Taco Hoekwater <taco@@luatex.org>
-%
-% This file is part of LuaTeX.
-%
-% LuaTeX is free software; you can redistribute it and/or modify it under
-% the terms of the GNU General Public License as published by the Free
-% Software Foundation; either version 2 of the License, or (at your
-% option) any later version.
-%
-% LuaTeX is distributed in the hope that it will be useful, but WITHOUT
-% ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-% FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
-% License for more details.
-%
-% You should have received a copy of the GNU General Public License along
-% with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+/*
+
+Copyright 2009-2011 Taco Hoekwater <taco@luatex.org>
+
+This file is part of LuaTeX.
+
+LuaTeX is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 2 of the License, or (at your
+option) any later version.
+
+LuaTeX is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+License for more details.
+
+You should have received a copy of the GNU General Public License along
+with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+
+*/
 
-@ @c
 #include "ptexlib.h"
 #include "pdf/pdfpage.h"
 
-@ @c
-int pdf_cur_form;               /* the form being output */
+/*tex The form being output: */
+
+int pdf_cur_form;
 
 void pdf_place_form(PDF pdf, halfword p)
 {
@@ -35,7 +37,7 @@ void pdf_place_form(PDF pdf, halfword p)
     nat.wd = obj_xform_width(pdf, objnum);
     nat.ht = obj_xform_height(pdf, objnum);
     nat.dp = obj_xform_depth(pdf, objnum);
-    /* no transform yet */
+    /*tex No transform yet: */
     tex.wd = width(p);
     tex.ht = height(p);
     tex.dp = depth(p);
@@ -60,9 +62,8 @@ void pdf_place_form(PDF pdf, halfword p)
     addto_page_resources(pdf, obj_type_xform, objnum);
 }
 
-/* we will store token lists as strings too */
+/*tex We will store token lists as strings too. */
 
-@ @c
 void scan_pdfxform(PDF pdf)
 {
     int k;
@@ -100,7 +101,8 @@ void scan_pdfxform(PDF pdf)
     p = box(cur_val);
     if (p == null)
         normal_error("pdf backend", "xforms cannot be used with a void box");
-    set_obj_xform_box(pdf, k, p);       /* save pointer to the box */
+    /*tex Save the pointer to the box: */
+    set_obj_xform_box(pdf, k, p);
     set_obj_xform_width(pdf, k, width(p));
     set_obj_xform_height(pdf, k, height(p));
     set_obj_xform_depth(pdf, k, depth(p));
@@ -108,11 +110,10 @@ void scan_pdfxform(PDF pdf)
     last_saved_box_index = k;
 }
 
-@ @c
 void scan_pdfrefxform(PDF pdf)
 {
     scaled_whd alt_rule, dim, nat;
-    alt_rule = scan_alt_rule(); /* scans |<rule spec>| to |alt_rule| */
+    alt_rule = scan_alt_rule();
     scan_int();
     check_obj_type(pdf, obj_type_xform, cur_val);
     tail_append(new_rule(box_rule));
diff --git a/texk/web2c/luatexdir/tex/align.c b/texk/web2c/luatexdir/tex/align.c
new file mode 100644
index 000000000..b2384cc62
--- /dev/null
+++ b/texk/web2c/luatexdir/tex/align.c
@@ -0,0 +1,1297 @@
+/*
+
+Copyright 2009-2010 Taco Hoekwater <taco@luatex.org>
+
+This file is part of LuaTeX.
+
+LuaTeX is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 2 of the License, or (at your
+option) any later version.
+
+LuaTeX is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+License for more details.
+
+You should have received a copy of the GNU General Public License along
+with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#include "ptexlib.h"
+
+void fin_align(void);
+void init_row(void);
+void init_col(void);
+
+#define noDEBUG
+
+/*tex
+
+    It's sort of a miracle whenever \.{\\halign} and \.{\\valign} work, because
+    they cut across so many of the control structures of \TeX. Therefore the
+    present page is probably not the best place for a beginner to start reading
+    this program; it is better to master everything else first.
+
+    Let us focus our thoughts on an example of what the input might be, in order
+    to get some idea about how the alignment miracle happens. The example doesn't
+    do anything useful, but it is sufficiently general to indicate all of the
+    special cases that must be dealt with; please do not be disturbed by its
+    apparent complexity and meaninglessness.
+
+    \starttyping
+    \tabskip 2pt plus 3pt
+    \halign to 300pt{u1#v1&
+    \hskip 50pt \tabskip 1pt plus 1fil u2#v2&
+    \hskip 50pt u3#v3\cr
+    \hskip 25pt a1&\omit a2&\vrule\cr
+    \hskip 25pt \noalign\{\vskip 3pt}
+    \hskip 25pt b1\span b2\cr
+    \hskip 25pt \omit&c2\span\omit\cr}
+    \stoptyping
+
+    Here's what happens:
+
+    \startitemize
+
+        \startitem
+            When `\.{\\halign to 300pt\{}' is scanned, the |scan_spec| routine
+            places the 300pt dimension onto the |save_stack|, and an
+            |align_group| code is placed above it. This will make it possible to
+            complete the alignment when the matching `\.\}' is found.
+        \stopitem
+
+        \startitem
+            The preamble is scanned next. Macros in the preamble are not
+            expanded, except as part of a tabskip specification. For example, if
+            \.{u2} had been a macro in the preamble above, it would have been
+            expanded, since \TeX\ must look for `\.{minus...}' as part of the
+            tabskip glue. A ``preamble list'' is constructed based on the user's
+            preamble; in our case it contains the following seven items:
+
+            \starttabulate
+            \NC \type{\glue 2pt plus 3pt}              \NC the tabskip preceding column 1      \NC \NR
+            \NC \type{\alignrecord} of width $-\infty$ \NC preamble info for column 1          \NC \NR
+            \NC \type{\glue 2pt plus 3pt}              \NC the tabskip between columns 1 and 2 \NC \NR
+            \NC \type{\alignrecord} of width $-\infty$ \NC preamble info for column 2          \NC \NR
+            \NC \type{\glue 1pt plus 1fil}             \NC the tabskip between columns 2 and 3 \NC \NR
+            \NC \type{\alignrecord} of width $-\infty$ \NC preamble info for column 3          \NC \NR
+            \NC \type{\glue 1pt plus 1fil}             \NC the tabskip following column 3      \NC \NR
+            \stoptabulate
+
+            These ``alignrecord'' entries have the same size as an |unset_node|,
+            since they will later be converted into such nodes. These alignrecord
+            nodes have no |depth| field; this is split into |u_part| and
+            |v_part|, and they point to token lists for the templates of the
+            alignment. For example, the |u_part| field in the first alignrecord
+            points to the token list `\.{u1}', i.e., the template preceding the
+            `\.\#' for column~1. Furthermore, They have a |span_ptr| instead of a
+            |node_attr| field, and these |span_ptr| fields are initially set to
+            the value |end_span|, for reasons explained below.
+        \stopitem
+
+        \startitem
+            \TeX\ now looks at what follows the \.{\\cr} that ended the preamble.
+            It is not `\.{\\noalign}' or `\.{\\omit}', so this input is put back
+            to be read again, and the template `\.{u1}' is fed to the scanner.
+            Just before reading `\.{u1}', \TeX\ goes into restricted horizontal
+            mode. Just after reading `\.{u1}', \TeX\ will see `\.{a1}', and then
+            (when the {\.\&} is sensed) \TeX\ will see `\.{v1}'. Then \TeX\ scans
+            an |endv| token, indicating the end of a column. At this point an
+            |unset_node| is created, containing the contents of the current hlist
+            (i.e., `\.{u1a1v1}'). The natural width of this unset node replaces
+            the |width| field of the alignrecord for column~1; in general, the
+            alignrecords will record the maximum natural width that has occurred
+            so far in a given column.
+        \stopitem
+
+        \startitem
+            Since `\.{\\omit}' follows the `\.\&', the templates for column~2 are
+            now bypassed. Again \TeX\ goes into restricted horizontal mode and
+            makes an |unset_node| from the resulting hlist; but this time the
+            hlist contains simply `\.{a2}'. The natural width of the new unset
+            box is remembered in the |width| field of the alignrecord for
+            column~2.
+        \stopitem
+
+        \startitem
+            A third |unset_node| is created for column 3, using essentially the
+            mechanism that worked for column~1; this unset box contains
+            `\.{u3\\vrule v3}'. The vertical rule in this case has running
+            dimensions that will later extend to the height and depth of the
+            whole first row, since each |unset_node| in a row will eventually
+            inherit the height and depth of its enclosing box.
+        \stopitem
+
+        \startitem
+            The first row has now ended; it is made into a single unset box
+            comprising the following seven items:
+
+            \starttyping
+            \glue 2pt plus 3pt
+            \unsetbox for 1 column: u1a1v1
+            \glue 2pt plus 3pt
+            \unsetbox for 1 column: a2
+            \glue 1pt plus 1fil
+            \unsetbox for 1 column: u3\vrule v3
+            \glue 1pt plus 1fil
+            \stoptyping
+
+            The width of this unset row is unimportant, but it has the correct
+            height and depth, so the correct baselineskip glue will be computed
+            as the row is inserted into a vertical list.
+        \stopitem
+
+        \startitem
+            Since `\.{\\noalign}' follows the current \.{\\cr}, \TeX\ appends
+            additional material (in this case \.{\\vskip 3pt}) to the vertical
+            list. While processing this material, \TeX\ will be in internal
+            vertical mode, and |no_align_group| will be on |save_stack|.
+        \stopitem
+
+        \startitem
+            The next row produces an unset box that looks like this:
+
+            \starttyping
+            \glue 2pt plus 3pt
+            \unsetbox for 2 columns: u1b1v1u2b2v2
+            \glue 1pt plus 1fil
+            \unsetbox for 1 column: {(empty)}
+            \glue 1pt plus 1fil
+            \stoptyping
+
+            The natural width of the unset box that spans columns 1~and~2 is
+            stored in a ``span node,'' which we will explain later; the
+            |span_ptr| field of the alignrecord for column~1 now points to the
+            new span node, and the |span_ptr| of the span node points to
+            |end_span|.
+        \stopitem
+
+        \startitem
+
+            The final row produces the unset box
+
+            \starttyping
+            \glue 2pt plus 3pt\cr
+            \unsetbox for 1 column: {(empty)}
+            \glue 2pt plus 3pt\cr
+            \unsetbox for 2 columns: u2c2v2
+            \glue 1pt plus 1fil
+            \stoptyping
+
+            A new span node is attached to the alignrecord for column 2.
+        \stopitem
+
+        \startitem
+            The last step is to compute the true column widths and to change all
+            the unset boxes to hboxes, appending the whole works to the vertical
+            list that encloses the \.{\\halign}. The rules for deciding on the
+            final widths of each unset column box will be explained below.
+        \stopitem
+
+    \stopitemize
+
+    Note that as \.{\\halign} is being processed, we fearlessly give up control
+    to the rest of \TeX. At critical junctures, an alignment routine is called
+    upon to step in and do some little action, but most of the time these
+    routines just lurk in the background. It's something like post-hypnotic
+    suggestion.
+
+    We have mentioned that alignrecords contain no |height| or |depth| fields.
+    Their |glue_sign| and |glue_order| are pre-empted as well, since it is
+    necessary to store information about what to do when a template ends. This
+    information is called the |extra_info| field.
+
+*/
+
+/*tex The pointer to \<u_j> token list: */
+
+#define u_part(A)     vlink((A)+depth_offset)
+
+/*tex The pointer to \<v_j> token list */
+
+#define v_part(A)     vinfo((A)+depth_offset)
+
+/*tex A column spanning list */
+
+#define span_ptr(A)   vinfo((A)+1)
+
+/*tex Info to remember during template */
+
+#define extra_info(A) vinfo((A)+list_offset)
+
+/*tex
+
+    Alignments can occur within alignments, so a small stack is used to access
+    the alignrecord information. At each level we have a |preamble| pointer,
+    indicating the beginning of the preamble list; a |cur_align| pointer,
+    indicating the current position in the preamble list; a |cur_span| pointer,
+    indicating the value of |cur_align| at the beginning of a sequence of spanned
+    columns; a |cur_loop| pointer, indicating the tabskip glue before an
+    alignrecord that should be copied next if the current list is extended; and
+    the |align_state| variable, which indicates the nesting of braces so that
+    \.{\\cr} and \.{\\span} and tab marks are properly intercepted. There also
+    are pointers |cur_head| and |cur_tail| to the head and tail of a list of
+    adjustments being moved out from horizontal mode to vertical~mode, and alike
+    |cur_pre_head| and |cur_pre_tail| for pre-adjust lists.
+
+    The current values of these nine quantities appear in global variables; when
+    they have to be pushed down, they are stored in 6-word nodes, and |align_ptr|
+    points to the topmost such node.
+
+*/
+
+/*tex This could be in |texnodes.h| but it's documented here. */
+
+/*tex The current preamble list: */
+
+#define preamble vlink(align_head)
+
+/*tex The current position in the preamble list: */
+
+pointer cur_align = null;
+
+/*tex The start of the currently spanned columns in the preamble list: */
+
+pointer cur_span = null;
+
+/*tex A place to copy when extending a periodic preamble: */
+
+pointer cur_loop = null;
+
+/*tex The most recently pushed-down alignment stack node: */
+
+pointer align_ptr = null;
+
+/*tex Adjustment list pointers: */
+
+pointer cur_head = null, cur_tail = null;
+
+/*tex Pre-adjustment list pointers: */
+
+pointer cur_pre_head = null, cur_pre_tail = null;
+
+/*tex
+
+    The |align_state| and |preamble| variables are initialized elsewhere.
+
+    Alignment stack maintenance is handled by a pair of trivial routines called
+    |push_alignment| and |pop_alignment|.
+
+    (HH:) It makes not much sense to add support for an \.{attr} keyword to
+    \.{\\halign} and \.{\\valign} because then we need to decide if we tag rows
+    or cells or both or come up with \.{cellattr} and \.{rowattr} and such. But
+    then it even makes sense to have explicit commands (in addition to the
+    seperator) to tags individual cells. Too muss hassle for now and the
+    advantages are not that large.
+
+*/
+
+static void push_alignment(void)
+{
+    /*tex The new alignment stack node: */
+    pointer p;
+    p = new_node(align_stack_node, 0);
+    vinfo(p + 1) = align_ptr;
+    vlink(p + 1) = cur_align;
+    vinfo(p + 2) = preamble;
+    vlink(p + 2) = cur_span;
+    vinfo(p + 3) = cur_loop;
+    vlink(p + 3) = align_state;
+    vinfo(p + 4) = cur_head;
+    vlink(p + 4) = cur_tail;
+    vinfo(p + 5) = cur_pre_head;
+    vlink(p + 5) = cur_pre_tail;
+    align_ptr = p;
+    cur_head = new_node(temp_node, 0);
+    cur_pre_head = new_node(temp_node, 0);
+}
+
+static void pop_alignment(void)
+{
+    /*tex The top alignment stack node: */
+    pointer p;
+    flush_node(cur_head);
+    flush_node(cur_pre_head);
+    p = align_ptr;
+    cur_pre_tail = vlink(p + 5);
+    cur_pre_head = vinfo(p + 5);
+    cur_tail = vlink(p + 4);
+    cur_head = vinfo(p + 4);
+    align_state = vlink(p + 3);
+    cur_loop = vinfo(p + 3);
+    cur_span = vlink(p + 2);
+    preamble = vinfo(p + 2);
+    cur_align = vlink(p + 1);
+    align_ptr = vinfo(p + 1);
+    flush_node(p);
+}
+
+/*tex
+
+    \TeX\ has eight procedures that govern alignments: |init_align| and
+    |fin_align| are used at the very beginning and the very end; |init_row| and
+    |fin_row| are used at the beginning and end of individual rows; |init_span|
+    is used at the beginning of a sequence of spanned columns (possibly involving
+    only one column); |init_col| and |fin_col| are used at the beginning and end
+    of individual columns; and |align_peek| is used after \.{\\cr} to see whether
+    the next item is \.{\\noalign}.
+
+    We shall consider these routines in the order they are first used during the
+    course of a complete \.{\\halign}, namely |init_align|, |align_peek|,
+    |init_row|, |init_span|, |init_col|, |fin_col|, |fin_row|, |fin_align|.
+
+    The preamble is copied directly, except that \.{\\tabskip} causes a change to
+    the tabskip glue, thereby possibly expanding macros that immediately follow
+    it. An appearance of \.{\\span} also causes such an expansion.
+
+    Note that if the preamble contains `\.{\\global\\tabskip}', the
+    `\.{\\global}' token survives in the preamble and the `\.{\\tabskip}' defines
+    new tabskip glue (locally).
+
+*/
+
+static void get_preamble_token(void)
+{
+  RESTART:
+    get_token();
+    while ((cur_chr == span_code) && (cur_cmd == tab_mark_cmd)) {
+        /*tex This token will be expanded once. */
+        get_token();
+        if (cur_cmd > max_command_cmd) {
+            expand();
+            get_token();
+        }
+    }
+    if (cur_cmd == endv_cmd)
+        fatal_error("(interwoven alignment preambles are not allowed)");
+    if ((cur_cmd == assign_glue_cmd)
+        && (cur_chr == glue_base + tab_skip_code)) {
+        scan_optional_equals();
+        scan_glue(glue_val_level);
+        if (global_defs_par > 0)
+            geq_define(glue_base + tab_skip_code, glue_ref_cmd, cur_val);
+        else
+            eq_define(glue_base + tab_skip_code, glue_ref_cmd, cur_val);
+        goto RESTART;
+    }
+}
+
+/*tex
+
+    When \.{\\halign} or \.{\\valign} has been scanned in an appropriate mode,
+    \TeX\ calls |init_align|, whose task is to get everything off to a good
+    start. This mostly involves scanning the preamble and putting its information
+    into the preamble list.
+
+*/
+
+void init_align(void)
+{
+    /*tex |warning_index| value for error messages */
+    pointer save_cs_ptr;
+    /*tex for short-term temporary use */
+    pointer p, r;
+    /*tex \.{\\halign} or \.{\\valign}, usually */
+    save_cs_ptr = cur_cs;
+    push_alignment();
+    /*tex enter a new alignment level */
+    align_state = -1000000;
+    /*tex
+
+        When \.{\\halign} is used as a displayed formula, there should be no
+        other pieces of mlists present.
+
+    */
+    if ((cur_list.mode_field == mmode) && ((cur_list.tail_field != cur_list.head_field) || (incompleat_noad_par != null))) {
+        const char *hlp[] = {
+            "Displays can use special alignments (like \\eqalignno)",
+            "only if nothing but the alignment itself is between $$'s.",
+            "So I've deleted the formulas that preceded this alignment.",
+            NULL
+        };
+        tex_error("Improper \\halign inside $$'s", hlp);
+        flush_math();
+    }
+    /*tex Enter a new semantic level. */
+    push_nest();
+    /*tex
+
+        In vertical modes, |prev_depth| already has the correct value. But if we
+        are in |mmode| (displayed formula mode), we reach out to the enclosing
+        vertical mode for the |prev_depth| value that produces the correct
+        baseline calculations.
+    */
+    if (cur_list.mode_field == mmode) {
+        cur_list.mode_field = -vmode;
+        prev_depth_par = nest[nest_ptr - 2].prev_depth_field;
+    } else if (cur_list.mode_field > 0) {
+        cur_list.mode_field = -(cur_list.mode_field);
+    }
+    scan_spec(align_group);
+    /*tex Scan the preamble. */
+    preamble = null;
+    cur_align = align_head;
+    cur_loop = null;
+    scanner_status = aligning;
+    warning_index = save_cs_ptr;
+    align_state = -1000000;
+    /*tex At this point, |cur_cmd=left_brace|. */
+    while (true) {
+        /*tex Append the current tabskip glue to the preamble list. */
+        r = new_param_glue(tab_skip_code);
+        vlink(cur_align) = r;
+        cur_align = vlink(cur_align);
+        if (cur_cmd == car_ret_cmd) {
+            /*tex \.{\\cr} ends the preamble. */
+            break;
+        }
+        /*tex
+
+            Scan preamble text until |cur_cmd| is |tab_mark| or |car_ret| and
+            then scan the template \<u_j>, putting the resulting token list in
+            |hold_token_head|. Spaces are eliminated from the beginning of a
+            template.
+
+        */
+        p = hold_token_head;
+        token_link(p) = null;
+        while (1) {
+            get_preamble_token();
+            if (cur_cmd == mac_param_cmd)
+                break;
+            if ((cur_cmd <= car_ret_cmd) && (cur_cmd >= tab_mark_cmd)
+                && (align_state == -1000000)) {
+                if ((p == hold_token_head) && (cur_loop == null) && (cur_cmd == tab_mark_cmd)) {
+                    cur_loop = cur_align;
+                } else {
+                    const char *hlp[] = {
+                        "There should be exactly one # between &'s, when an",
+                        "\\halign or \\valign is being set up. In this case you had",
+                        "none, so I've put one in; maybe that will work.",
+                        NULL
+                    };
+                    back_input();
+                    tex_error("Missing # inserted in alignment preamble", hlp);
+                    break;
+                }
+            } else if ((cur_cmd != spacer_cmd) || (p != hold_token_head)) {
+                r = get_avail();
+                token_link(p) = r;
+                p = token_link(p);
+                token_info(p) = cur_tok;
+            }
+        }
+        r = new_node(align_record_node, 0);
+        vlink(cur_align) = r;
+        /*tex A new align record: */
+        cur_align = vlink(cur_align);
+        span_ptr(cur_align) = end_span;
+        width(cur_align) = null_flag;
+        u_part(cur_align) = token_link(hold_token_head);
+        /*tex
+
+            Scan the template \<v_j>, putting the resulting token list in
+            |hold_token_head|.
+
+        */
+        p = hold_token_head;
+        token_link(p) = null;
+        while (1) {
+          CONTINUE:
+            get_preamble_token();
+            if ((cur_cmd <= car_ret_cmd) && (cur_cmd >= tab_mark_cmd) && (align_state == -1000000))
+                break;
+            if (cur_cmd == mac_param_cmd) {
+                const char *hlp[] = {
+                    "There should be exactly one # between &'s, when an",
+                    "\\halign or \\valign is being set up. In this case you had",
+                    "more than one, so I'm ignoring all but the first.",
+                    NULL
+                };
+                tex_error("Only one # is allowed per tab", hlp);
+                goto CONTINUE;
+            }
+            r = get_avail();
+            token_link(p) = r;
+            p = token_link(p);
+            token_info(p) = cur_tok;
+        }
+        r = get_avail();
+        token_link(p) = r;
+        p = token_link(p);
+        /*tex Put \.{\\endtemplate} at the end: */
+        token_info(p) = end_template_token;
+        v_part(cur_align) = token_link(hold_token_head);
+    }
+    scanner_status = normal;
+    new_save_level(align_group);
+    if (every_cr_par != null)
+        begin_token_list(every_cr_par, every_cr_text);
+    /*tex Look for \.{\\noalign} or \.{\\omit}. */
+    align_peek();
+}
+
+/*tex
+
+    The tricky part about alignments is getting the templates into the scanner at
+    the right time, and recovering control when a row or column is finished.
+
+    We usually begin a row after each \.{\\cr} has been sensed, unless that
+    \.{\\cr} is followed by \.{\\noalign} or by the right brace that terminates
+    the alignment. The |align_peek| routine is used to look ahead and do the
+    right thing; it either gets a new row started, or gets a \.{\\noalign}
+    started, or finishes off the alignment.
+
+*/
+
+void align_peek(void)
+{
+  RESTART:
+    align_state = 1000000;
+    do {
+        get_x_or_protected();
+    } while (cur_cmd == spacer_cmd);
+    if (cur_cmd == no_align_cmd) {
+        scan_left_brace();
+        new_save_level(no_align_group);
+        if (cur_list.mode_field == -vmode)
+            normal_paragraph();
+    } else if (cur_cmd == right_brace_cmd) {
+        fin_align();
+    } else if ((cur_cmd == car_ret_cmd) && (cur_chr == cr_cr_code)) {
+        /*tex Ignore \.{\\crcr}. */
+        goto RESTART;
+    } else {
+        /*tex Start a new row. */
+        init_row();
+        /*tex Start a new column and replace what we peeked at. */
+        init_col();
+    }
+}
+
+
+/*tex
+
+    The parameter to |init_span| is a pointer to the alignrecord where the next
+    column or group of columns will begin. A new semantic level is entered, so
+    that the columns will generate a list for subsequent packaging.
+
+*/
+
+static void init_span(pointer p)
+{
+    push_nest();
+    if (cur_list.mode_field == -hmode) {
+        space_factor_par = 1000;
+    } else {
+        prev_depth_par = ignore_depth;
+        normal_paragraph();
+    }
+    cur_span = p;
+}
+
+/*tex
+
+    To start a row (i.e., a `row' that rhymes with `dough' but not with `bough'),
+    we enter a new semantic level, copy the first tabskip glue, and change from
+    internal vertical mode to restricted horizontal mode or vice versa. The
+    |space_factor| and |prev_depth| are not used on this semantic level, but we
+    clear them to zero just to be tidy.
+
+*/
+
+void init_row(void)
+{
+    push_nest();
+    cur_list.mode_field = (-hmode - vmode) - cur_list.mode_field;
+    if (cur_list.mode_field == -hmode)
+        space_factor_par = 0;
+    else
+        prev_depth_par = 0;
+    tail_append(new_glue(preamble));
+    subtype(cur_list.tail_field) = tab_skip_code + 1;
+    cur_align = vlink(preamble);
+    cur_tail = cur_head;
+    cur_pre_tail = cur_pre_head;
+    init_span(cur_align);
+}
+
+/*tex
+
+    When a column begins, we assume that |cur_cmd| is either |omit| or else the
+    current token should be put back into the input until the \<u_j> template has
+    been scanned. (Note that |cur_cmd| might be |tab_mark| or |car_ret|.) We also
+    assume that |align_state| is approximately 1000000 at this time. We remain in
+    the same mode, and start the template if it is called for.
+
+*/
+
+void init_col(void)
+{
+    extra_info(cur_align) = cur_cmd;
+    if (cur_cmd == omit_cmd)
+        align_state = 0;
+    else {
+        back_input();
+        begin_token_list(u_part(cur_align), u_template);
+    }
+    /*tex now |align_state=1000000| */
+}
+
+
+/*tex
+
+    The scanner sets |align_state| to zero when the \<u_j> template ends. When a
+    subsequent \.{\\cr} or \.{\\span} or tab mark occurs with |align_state=0|,
+    the scanner activates the following code, which fires up the \<v_j> template.
+    We need to remember the |cur_chr|, which is either |cr_cr_code|, |cr_code|,
+    |span_code|, or a character code, depending on how the column text has ended.
+
+    This part of the program had better not be activated when the preamble to
+    another alignment is being scanned, or when no alignment preamble is active.
+
+*/
+
+void insert_vj_template(void)
+{
+    if ((scanner_status == aligning) || (cur_align == null))
+        fatal_error("(interwoven alignment preambles are not allowed)");
+    cur_cmd = extra_info(cur_align);
+    extra_info(cur_align) = cur_chr;
+    if (cur_cmd == omit_cmd)
+        begin_token_list(omit_template, v_template);
+    else
+        begin_token_list(v_part(cur_align), v_template);
+    align_state = 1000000;
+}
+
+/*tex Determine the stretch order */
+
+#define determine_stretch_order() do {             \
+    if      (total_stretch[filll]!= 0)  o = filll; \
+    else if (total_stretch[fill] != 0)  o = fill;  \
+    else if (total_stretch[fil]  != 0)  o = fil;   \
+    else if (total_stretch[sfi]  != 0)  o = sfi;   \
+    else o=normal;                                 \
+} while (0)
+
+/*tex Determine the shrink order */
+
+#define determine_shrink_order() do {             \
+    if      (total_shrink[filll] != 0) o = filll; \
+    else if (total_shrink[fill]  != 0) o = fill;  \
+    else if (total_shrink[fil]   != 0) o = fil;   \
+    else if (total_shrink[sfi]   != 0) o = sfi;   \
+    else o=normal;                                \
+} while (0)
+
+/*tex
+
+    When the |endv| command at the end of a \<v_j> template comes through the
+    scanner, things really start to happen; and it is the |fin_col| routine that
+    makes them happen. This routine returns |true| if a row as well as a column
+    has been finished.
+
+*/
+
+boolean fin_col(void)
+{
+    /*tex the alignrecord after the current one */
+    pointer p;
+    /*tex temporary pointers for list manipulation */
+    pointer q, r;
+    /*tex a new span node */
+    pointer s;
+    /*tex a new unset box */
+    pointer u;
+    /*tex natural width */
+    scaled w;
+    /*tex order of infinity */
+    unsigned char o;
+    /*tex span counter */
+    halfword n;
+    if (cur_align == null)
+        confusion("endv");
+    q = vlink(cur_align);
+    if (q == null)
+        confusion("endv");
+    if (align_state < 500000)
+        fatal_error("(interwoven alignment preambles are not allowed)");
+    p = vlink(q);
+    /*tex If the preamble list has been traversed, check that the row has ended. */
+    if ((p == null) && (extra_info(cur_align) < cr_code)) {
+        if (cur_loop != null) {
+            /*tex Lengthen the preamble periodically: */
+            r = new_node(align_record_node, 0);
+            vlink(q) = r;
+            /*tex A new align record: */
+            p = vlink(q);
+            span_ptr(p) = end_span;
+            width(p) = null_flag;
+            cur_loop = vlink(cur_loop);
+            /*tex Copy the templates from node |cur_loop| into node |p|. */
+            q = hold_token_head;
+            r = u_part(cur_loop);
+            while (r != null) {
+                s = get_avail();
+                token_link(q) = s;
+                q = token_link(q);
+                token_info(q) = token_info(r);
+                r = token_link(r);
+            }
+            token_link(q) = null;
+            u_part(p) = token_link(hold_token_head);
+            q = hold_token_head;
+            r = v_part(cur_loop);
+            while (r != null) {
+                s = get_avail();
+                token_link(q) = s;
+                q = token_link(q);
+                token_info(q) = token_info(r);
+                r = token_link(r);
+            }
+            token_link(q) = null;
+            v_part(p) = token_link(hold_token_head);
+            cur_loop = vlink(cur_loop);
+            r = new_glue(cur_loop);
+            vlink(p) = r;
+        } else {
+            const char *hlp[] = {
+                "You have given more \\span or & marks than there were",
+                "in the preamble to the \\halign or \\valign now in progress.",
+                "So I'll assume that you meant to type \\cr instead.",
+                NULL
+            };
+            extra_info(cur_align) = cr_code;
+            tex_error("Extra alignment tab has been changed to \\cr", hlp);
+        }
+    }
+    if (extra_info(cur_align) != span_code) {
+        unsave();
+        new_save_level(align_group);
+        /*tex Package an unset box for the current column and record its width. */
+        if (cur_list.mode_field == -hmode) {
+            adjust_tail = cur_tail;
+            pre_adjust_tail = cur_pre_tail;
+            u = filtered_hpack(cur_list.head_field, cur_list.tail_field, 0, additional, align_set_group, -1, 0, 0);
+            w = width(u);
+            cur_tail = adjust_tail;
+            adjust_tail = null;
+            cur_pre_tail = pre_adjust_tail;
+            pre_adjust_tail = null;
+        } else {
+            u = filtered_vpackage(vlink(cur_list.head_field), 0, additional, 0, align_set_group, -1, 0, 0);
+            w = height(u);
+        }
+        /*tex This represents a span count of 1: */
+        n = min_quarterword;
+        if (cur_span != cur_align) {
+            /*tex Update width entry for spanned columns. */
+            q = cur_span;
+            do {
+                incr(n);
+                q = vlink(vlink(q));
+            } while (q != cur_align);
+            if (n > max_quarterword) {
+                /*tex This can happen, but won't. */
+                confusion("too many spans");
+            }
+            q = cur_span;
+            while (span_span(span_ptr(q)) < n) {
+                q = span_ptr(q);
+            }
+            if (span_span(span_ptr(q)) > n) {
+                s = new_span_node(span_ptr(q), n, w);
+                span_ptr(q) = s;
+            } else if (width(span_ptr(q)) < w) {
+                width(span_ptr(q)) = w;
+            }
+        } else if (w > width(cur_align)) {
+            width(cur_align) = w;
+        }
+        type(u) = unset_node;
+        span_count(u) = (quarterword) n;
+        determine_stretch_order();
+        glue_order(u) = o;
+        glue_stretch(u) = total_stretch[o];
+        determine_shrink_order();
+        glue_sign(u) = o;
+        glue_shrink(u) = total_shrink[o];
+        pop_nest();
+        vlink(cur_list.tail_field) = u;
+        cur_list.tail_field = u;
+        /*tex Copy the tabskip glue between columns. */
+        tail_append(new_glue(vlink(cur_align)));
+        subtype(cur_list.tail_field) = tab_skip_code + 1;
+        if (extra_info(cur_align) >= cr_code) {
+            return true;
+        }
+        init_span(p);
+    }
+    align_state = 1000000;
+    do {
+        get_x_or_protected();
+    } while (cur_cmd == spacer_cmd);
+    cur_align = p;
+    init_col();
+    return false;
+}
+
+/*tex
+
+    A span node is a 3-word record containing |width|, |span_span|, and
+    |span_ptr| fields. The |span_span| field indicates the number of spanned
+    columns; the |span_ptr| field points to a span node for the same starting
+    column, having a greater extent of spanning, or to |end_span|, which has the
+    largest possible |span_span| field; the |width| field holds the largest
+    natural width corresponding to a particular set of spanned columns.
+
+    A list of the maximum widths so far, for spanned columns starting at a given
+    column, begins with the |span_ptr| field of the alignrecord for that column.
+    The code has to make sure that there is room for |span_ptr| in both the
+    alignrecord and the span nodes, which is why |span_ptr| replaces |node_attr|.
+
+    The |new_span_node| function is defined in |texnodes.c|.
+
+*/
+
+/*tex This is normally |alink|: */
+
+#ifndef span_span
+#  define span_span(A) vlink((A)+1)
+#endif
+
+/*tex
+
+    At the end of a row, we append an unset box to the current vlist (for
+    \.{\\halign}) or the current hlist (for \.{\\valign}). This unset box
+    contains the unset boxes for the columns, separated by the tabskip glue.
+    Everything will be set later.
+
+*/
+
+void fin_row(void)
+{
+    /*tex The new unset box: */
+    pointer p;
+    if (cur_list.mode_field == -hmode) {
+        p = filtered_hpack(cur_list.head_field, cur_list.tail_field, 0,
+                           additional, fin_row_group, -1, 0, 0);
+        pop_nest();
+        if (cur_pre_head != cur_pre_tail)
+            append_list(cur_pre_head, cur_pre_tail);
+        append_to_vlist(p,lua_key_index(alignment));
+        if (cur_head != cur_tail)
+            append_list(cur_head, cur_tail);
+    } else {
+        p = filtered_vpackage(vlink(cur_list.head_field),
+            0, additional, max_depth_par, fin_row_group, -1, 0, 0);
+        pop_nest();
+        vlink(cur_list.tail_field) = p;
+        cur_list.tail_field = p;
+        space_factor_par = 1000;
+    }
+    type(p) = unset_node;
+    glue_stretch(p) = 0;
+    if (every_cr_par != null)
+        begin_token_list(every_cr_par, every_cr_text);
+    align_peek();
+    /*tex Note that |glue_shrink(p)=0| since |glue_shrink==shift_amount|. */
+}
+
+/*tex
+
+    Finally, we will reach the end of the alignment, and we can breathe a sigh of
+    relief that memory hasn't overflowed. All the unset boxes will now be set so
+    that the columns line up, taking due account of spanned columns.
+
+*/
+
+void fin_align(void)
+{
+    /*tex registers for the list operations */
+    pointer p, q, r, s, u, rr;
+    /*tex width of column */
+    scaled t, w;
+    /*tex shift offset for unset boxes */
+    scaled o;
+    /*tex matching span amount */
+    halfword n;
+    /*tex temporary storage for |overfull_rule| */
+    scaled rule_save;
+    /*tex temporary storage for |prev_depth| */
+    halfword pd;
+    /*tex temporary storage for |new_glue| */
+    halfword ng;
+    /*tex The |align_group| was for individual entries: */
+    if (cur_group != align_group)
+        confusion("align1");
+    unsave();
+    /*tex The |align_group| was for the whole alignment: */
+    if (cur_group != align_group)
+        confusion("align0");
+    unsave();
+    if (nest[nest_ptr - 1].mode_field == mmode) {
+        o = display_indent_par;
+    } else {
+        o = 0;
+    }
+    /*tex
+
+        Go through the preamble list, determining the column widths and
+        changing the alignrecords to dummy unset boxes.
+
+        It's time now to dismantle the preamble list and to compute the
+        column widths. Let $w_{ij}$ be the maximum of the natural widths of
+        all entries that span columns $i$ through $j$, inclusive. The
+        alignrecord for column~$i$ contains $w_{ii}$ in its |width| field,
+        and there is also a linked list of the nonzero $w_{ij}$ for
+        increasing $j$, accessible via the |info| field; these span nodes
+        contain the value $j-i+|min_quarterword|$ in their |link| fields. The
+        values of $w_{ii}$ were initialized to |null_flag|, which we regard
+        as $-\infty$.
+
+        The final column widths are defined by the formula $$w_j=\max_{1\L
+        i\L j}\biggl( w_{ij}-\sum_{i\L k<j}(t_k+w_k)\biggr),$$ where $t_k$ is
+        the natural width of the tabskip glue between columns $k$ and~$k+1$.
+        However, if $w_{ij}=-\infty$ for all |i| in the range |1<=i<=j|
+        (i.e., if every entry that involved column~|j| also involved
+        column~|j+1|), we let $w_j=0$, and we zero out the tabskip glue after
+        column~|j|.
+
+        \TeX\ computes these values by using the following scheme: First
+        $w_1=w_{11}$. Then replace $w_{2j}$ by $\max(w_{2j},w_{1j}-t_1-w_1)$,
+        for all $j>1$. Then $w_2=w_{22}$. Then replace $w_{3j}$ by
+        $\max(w_{3j},w_{2j}-t_2-w_2)$ for all $j>2$; and so on. If any $w_j$
+        turns out to be $-\infty$, its value is changed to zero and so is the
+        next tabskip.
+
+    */
+    q = vlink(preamble);
+    do {
+        flush_list(u_part(q));
+        flush_list(v_part(q));
+        p = vlink(vlink(q));
+        if (width(q) == null_flag) {
+            /*tex Nullify |width(q)| and the tabskip glue following this column. */
+            width(q) = 0;
+            r = vlink(q);
+            reset_glue_to_zero(r);
+        }
+        if (span_ptr(q) != end_span) {
+            /*tex
+
+                Merge the widths in the span nodes of |q| with those of |p|,
+                destroying the span nodes of |q|.
+
+                Merging of two span-node lists is a typical exercise in the
+                manipulation of linearly linked data structures. The essential
+                invariant in the following |repeat| loop is that we want to
+                dispense with node |r|, in |q|'s list, and |u| is its successor;
+                all nodes of |p|'s list up to and including |s| have been
+                processed, and the successor of |s| matches |r| or precedes |r|
+                or follows |r|, according as |link(r)=n| or |link(r)>n| or
+                |link(r)<n|.
+
+            */
+            t = width(q) + width(vlink(q));
+            r = span_ptr(q);
+            s = end_span;
+            span_ptr(s) = p;
+            n = min_quarterword + 1;
+            do {
+                width(r) = width(r) - t;
+                u = span_ptr(r);
+                while (span_span(r) > n) {
+                    s = span_ptr(s);
+                    n = span_span(span_ptr(s)) + 1;
+                }
+                if (span_span(r) < n) {
+                    span_ptr(r) = span_ptr(s);
+                    span_ptr(s) = r;
+                    decr(span_span(r));
+                    s = r;
+                } else {
+                    if (width(r) > width(span_ptr(s)))
+                        width(span_ptr(s)) = width(r);
+                    flush_node(r);
+                }
+                r = u;
+            } while (r != end_span);
+        }
+        type(q) = unset_node;
+        span_count(q) = min_quarterword;
+        height(q) = 0;
+        depth(q) = 0;
+        glue_order(q) = normal;
+        glue_sign(q) = normal;
+        glue_stretch(q) = 0;
+        glue_shrink(q) = 0;
+        q = p;
+    } while (q != null);
+    /*tex
+
+        Package the preamble list, to determine the actual tabskip glue amounts,
+        and let |p| point to this prototype box.
+
+        Now the preamble list has been converted to a list of alternating unset
+        boxes and tabskip glue, where the box widths are equal to the final
+        column sizes. In case of \.{\\valign}, we change the widths to heights,
+        so that a correct error message will be produced if the alignment is
+        overfull or underfull.
+
+    */
+    decr(save_ptr);
+    pack_begin_line = -cur_list.ml_field;
+    if (cur_list.mode_field == -vmode) {
+        rule_save = overfull_rule_par;
+        /*tex Prevent the rule from being packaged. */
+        overfull_rule_par = 0;
+        p = hpack(preamble, saved_value(0), saved_level(0), -1);
+        overfull_rule_par = rule_save;
+    } else {
+        q = vlink(preamble);
+        do {
+            height(q) = width(q);
+            width(q) = 0;
+            q = vlink(vlink(q));
+        } while (q != null);
+        p = filtered_vpackage(preamble,
+            saved_value(0), saved_level(0), max_depth_par, preamble_group, -1, 0, 0);
+        q = vlink(preamble);
+        do {
+            width(q) = height(q);
+            height(q) = 0;
+            q = vlink(vlink(q));
+        } while (q != null);
+    }
+    pack_begin_line = 0;
+    /*tex Set the glue in all the unset boxes of the current list. */
+    q = vlink(cur_list.head_field);
+    s = cur_list.head_field;
+    while (q != null) {
+        if (!is_char_node(q)) {
+            if (type(q) == unset_node) {
+                /*tex
+
+                    We set the unset box |q| and the unset boxes in it. The unset
+                    box |q| represents a row that contains one or more unset
+                    boxes, depending on how soon \.{\\cr} occurred in that row.
+
+                */
+                if (cur_list.mode_field == -vmode) {
+                    type(q) = hlist_node;
+                    subtype(q) = align_row_list;
+                    width(q) = width(p);
+                } else {
+                    type(q) = vlist_node;
+                    subtype(q) = align_row_list;
+                    height(q) = height(p);
+                }
+                glue_order(q) = glue_order(p);
+                glue_sign(q) = glue_sign(p);
+                glue_set(q) = glue_set(p);
+                shift_amount(q) = o;
+                r = vlink(list_ptr(q));
+                assert (type(r) == unset_node);
+                s = vlink(list_ptr(p));
+                do {
+                    /*tex
+
+                        We set the glue in node |r| and change it from an unset
+                        node. A box made from spanned columns will be followed by
+                        tabskip glue nodes and by empty boxes as if there were no
+                        spanning. This permits perfect alignment of subsequent
+                        entries, and it prevents values that depend on floating
+                        point arithmetic from entering into the dimensions of any
+                        boxes.
+
+                    */
+                    n = span_count(r);
+                    t = width(s);
+                    w = t;
+                    u = hold_head;
+                    while (n > min_quarterword) {
+                        decr(n);
+                        /*tex
+
+                            Append tabskip glue and an empty box to list |u|, and
+                            update |s| and |t| as the prototype nodes are passed.
+
+                        */
+                        s = vlink(s);
+                        ng = new_glue(s);
+                        vlink(u) = ng;
+                        u = vlink(u);
+                        subtype(u) = tab_skip_code + 1;
+                        t = t + width(s);
+                        if (glue_sign(p) == stretching) {
+                            if (stretch_order(s) == glue_order(p))
+                                t = t + round(float_cast(glue_set(p)) * float_cast(stretch(s)));
+                        } else if (glue_sign(p) == shrinking) {
+                            if (shrink_order(s) == glue_order(p))
+                                t = t - round(float_cast(glue_set(p)) * float_cast(shrink(s)));
+                        }
+                        s = vlink(s);
+                        rr = new_null_box();
+                        vlink(u) = rr;
+                        u = vlink(u);
+                        t = t + width(s);
+                        subtype(u) = align_cell_list;
+                        if (cur_list.mode_field == -vmode) {
+                            width(u) = width(s);
+                        } else {
+                            type(u) = vlist_node;
+                            height(u) = width(s);
+                        }
+                    }
+                    if (cur_list.mode_field == -vmode) {
+                        /*tex
+
+                            Make the unset node |r| into an |hlist_node| of width
+                            |w|, setting the glue as if the width were |t|.
+
+                        */
+                        height(r) = height(q);
+                        depth(r) = depth(q);
+                        if (t == width(r)) {
+                            glue_sign(r) = normal;
+                            glue_order(r) = normal;
+                            set_glue_ratio_zero(glue_set(r));
+                        } else if (t > width(r)) {
+                            glue_sign(r) = stretching;
+                            if (glue_stretch(r) == 0)
+                                set_glue_ratio_zero(glue_set(r));
+                            else
+                                glue_set(r) = unfloat((double) (t - width(r)) / glue_stretch(r));
+                        } else {
+                            glue_order(r) = glue_sign(r);
+                            glue_sign(r) = shrinking;
+                            if (glue_shrink(r) == 0)
+                                set_glue_ratio_zero(glue_set(r));
+                            else if ((glue_order(r) == normal) && (width(r) - t > glue_shrink(r)))
+                                set_glue_ratio_one(glue_set(r));
+                            else
+                                glue_set(r) = unfloat((double) (width(r) - t) / glue_shrink(r));
+                        }
+                        width(r) = w;
+                        type(r) = hlist_node;
+                        subtype(r) = align_cell_list;
+
+                    } else {
+                        /*tex
+
+                            Make the unset node |r| into a |vlist_node| of height
+                            |w|, setting the glue as if the height were |t|.
+
+                        */
+                        width(r) = width(q);
+                        if (t == height(r)) {
+                            glue_sign(r) = normal;
+                            glue_order(r) = normal;
+                            set_glue_ratio_zero(glue_set(r));
+                        } else if (t > height(r)) {
+                            glue_sign(r) = stretching;
+                            if (glue_stretch(r) == 0)
+                                set_glue_ratio_zero(glue_set(r));
+                            else
+                                glue_set(r) = unfloat((t - height(r)) / glue_stretch(r));
+                        } else {
+                            glue_order(r) = glue_sign(r);
+                            glue_sign(r) = shrinking;
+                            if (glue_shrink(r) == 0)
+                                set_glue_ratio_zero(glue_set(r));
+                            else if ((glue_order(r) == normal) && (height(r) - t > glue_shrink(r)))
+                                set_glue_ratio_one(glue_set(r));
+                            else
+                                glue_set(r) = unfloat((height(r) - t) / glue_shrink(r));
+                        }
+                        height(r) = w;
+                        type(r) = vlist_node;
+                        subtype(r) = align_cell_list;
+                    }
+                    shift_amount(r) = 0;
+                    if (u != hold_head) {
+                        /*tex Append blank boxes to account for spanned nodes. */
+                        vlink(u) = vlink(r);
+                        vlink(r) = vlink(hold_head);
+                        r = u;
+                    }
+
+                    r = vlink(vlink(r));
+                    s = vlink(vlink(s));
+                } while (r != null);
+
+            } else if (type(q) == rule_node) {
+                /*tex
+
+                    Make the running dimensions in rule |q| extend to the
+                    boundaries of the alignment.
+
+                */
+                if (is_running(width(q)))
+                    width(q) = width(p);
+                if (is_running(height(q)))
+                    height(q) = height(p);
+                if (is_running(depth(q)))
+                    depth(q) = depth(p);
+                if (o != 0) {
+                    r = vlink(q);
+                    vlink(q) = null;
+                    q = hpack(q, 0, additional, -1);
+                    shift_amount(q) = o;
+                    subtype(q) = align_cell_list;
+                    vlink(q) = r;
+                    vlink(s) = q;
+                }
+            }
+        }
+        s = q;
+        q = vlink(q);
+    }
+    flush_node_list(p);
+    pop_alignment();
+    /*tex
+
+        We now have a completed alignment, in the list that starts at
+        |cur_list.head_field| and ends at |cur_list.tail_field|. This list will
+        be merged with the one that encloses it. (In case the enclosing mode is
+        |mmode|, for displayed formulas, we will need to insert glue before and
+        after the display; that part of the program will be deferred until we're
+        more familiar with such operations.)
+
+    */
+    pd = prev_depth_par;
+    p = vlink(cur_list.head_field);
+    q = cur_list.tail_field;
+    pop_nest();
+    if (cur_list.mode_field == mmode) {
+        finish_display_alignment(p, q, pd);
+    } else {
+        prev_depth_par = pd;
+        vlink(cur_list.tail_field) = p;
+        if (p != null)
+            cur_list.tail_field = q;
+        if (cur_list.mode_field == vmode) {
+            if (!output_active)
+                lua_node_filter_s(buildpage_filter_callback,lua_key_index(alignment));
+            build_page();
+        }
+    }
+}
+
+/*tex
+
+    The token list |omit_template| just referred to is a constant token list that
+    contains the special control sequence \.{\\endtemplate} only.
+
+*/
+
+void initialize_alignments(void)
+{
+    token_info(omit_template) = end_template_token;
+    span_span(end_span) = max_quarterword + 1;
+    span_ptr(end_span) = null;
+}
diff --git a/texk/web2c/luatexdir/tex/align.w b/texk/web2c/luatexdir/tex/align.w
deleted file mode 100644
index dd0ed1033..000000000
--- a/texk/web2c/luatexdir/tex/align.w
+++ /dev/null
@@ -1,1144 +0,0 @@
-% align.w
-%
-% Copyright 2009-2010 Taco Hoekwater <taco@@luatex.org>
-%
-% This file is part of LuaTeX.
-%
-% LuaTeX is free software; you can redistribute it and/or modify it under
-% the terms of the GNU General Public License as published by the Free
-% Software Foundation; either version 2 of the License, or (at your
-% option) any later version.
-%
-% LuaTeX is distributed in the hope that it will be useful, but WITHOUT
-% ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-% FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
-% License for more details.
-%
-% You should have received a copy of the GNU General Public License along
-% with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
-
-\def\<#1>{$#1$}
-
-@ @c
-
-
-#include "ptexlib.h"
-
-@ @c
-void fin_align(void);
-void init_row(void);
-void init_col(void);
-
-#define noDEBUG
-
-@ It's sort of a miracle whenever \.{\\halign} and \.{\\valign} work, because
-they cut across so many of the control structures of \TeX.
-
-Therefore the present page is probably not the best place for a beginner to
-start reading this program; it is better to master everything else first.
-
-Let us focus our thoughts on an example of what the input might be, in order
-to get some idea about how the alignment miracle happens. The example doesn't
-do anything useful, but it is sufficiently general to indicate all of the
-special cases that must be dealt with; please do not be disturbed by its
-apparent complexity and meaninglessness.
-$$\vbox{\halign{\.{#}\hfil\cr
-{}\\tabskip 2pt plus 3pt\cr
-{}\\halign to 300pt\{u1\#v1\&\cr
-\hskip 50pt\\tabskip 1pt plus 1fil u2\#v2\&\cr
-\hskip 50pt u3\#v3\\cr\cr
-\hskip 25pt a1\&\\omit a2\&\\vrule\\cr\cr
-\hskip 25pt \\noalign\{\\vskip 3pt\}\cr
-\hskip 25pt b1\\span b2\\cr\cr
-\hskip 25pt \\omit\&c2\\span\\omit\\cr\}\cr}}$$
-Here's what happens:
-
-\yskip
-(0) When `\.{\\halign to 300pt\{}' is scanned, the |scan_spec| routine
-places the 300pt dimension onto the |save_stack|, and an |align_group|
-code is placed above it. This will make it possible to complete the alignment
-when the matching `\.\}' is found.
-
-(1) The preamble is scanned next. Macros in the preamble are not expanded,
-@^preamble@>
-except as part of a tabskip specification. For example, if \.{u2} had been
-a macro in the preamble above, it would have been expanded, since \TeX\
-must look for `\.{minus...}' as part of the tabskip glue. A ``preamble list''
-is constructed based on the user's preamble; in our case it contains the
-following seven items:
-$$\vbox{\halign{\.{#}\hfil\qquad&(#)\hfil\cr
-{}\\glue 2pt plus 3pt&the tabskip preceding column 1\cr
-{}\\alignrecord, width $-\infty$&preamble info for column 1\cr
-{}\\glue 2pt plus 3pt&the tabskip between columns 1 and 2\cr
-{}\\alignrecord, width $-\infty$&preamble info for column 2\cr
-{}\\glue 1pt plus 1fil&the tabskip between columns 2 and 3\cr
-{}\\alignrecord, width $-\infty$&preamble info for column 3\cr
-{}\\glue 1pt plus 1fil&the tabskip following column 3\cr}}$$
-These ``alignrecord'' entries have the same size as an |unset_node|,
-since they will later be converted into such nodes. These alignrecord
-nodes have no |depth| field; this is split into |u_part| and |v_part|,
-and they point to token lists for the templates of the alignment. For
-example, the |u_part| field in the first alignrecord points to the
-token list `\.{u1}', i.e., the template preceding the `\.\#' for
-column~1.  Furthermore, They have a |span_ptr| instead of a |node_attr|
-field, and these |span_ptr| fields are initially set to the value
-|end_span|, for reasons explained below.
-
-(2) \TeX\ now looks at what follows the \.{\\cr} that ended the preamble.
-It is not `\.{\\noalign}' or `\.{\\omit}', so this input is put back to
-be read again, and the template `\.{u1}' is fed to the scanner. Just
-before reading `\.{u1}', \TeX\ goes into restricted horizontal mode.
-Just after reading `\.{u1}', \TeX\ will see `\.{a1}', and then (when the
-{\.\&} is sensed) \TeX\ will see `\.{v1}'. Then \TeX\ scans an |endv|
-token, indicating the end of a column. At this point an |unset_node| is
-created, containing the contents of the current hlist (i.e., `\.{u1a1v1}').
-The natural width of this unset node replaces the |width| field of the
-alignrecord for column~1; in general, the alignrecords will record the
-maximum natural width that has occurred so far in a given column.
-
-(3) Since `\.{\\omit}' follows the `\.\&', the templates for column~2
-are now bypassed. Again \TeX\ goes into restricted horizontal mode and
-makes an |unset_node| from the resulting hlist; but this time the
-hlist contains simply `\.{a2}'. The natural width of the new unset box
-is remembered in the |width| field of the alignrecord for column~2.
-
-(4) A third |unset_node| is created for column 3, using essentially the
-mechanism that worked for column~1; this unset box contains `\.{u3\\vrule
-v3}'. The vertical rule in this case has running dimensions that will later
-extend to the height and depth of the whole first row, since each |unset_node|
-in a row will eventually inherit the height and depth of its enclosing box.
-
-(5) The first row has now ended; it is made into a single unset box
-comprising the following seven items:
-$$\vbox{\halign{\hbox to 325pt{\qquad\.{#}\hfil}\cr
-{}\\glue 2pt plus 3pt\cr
-{}\\unsetbox for 1 column: u1a1v1\cr
-{}\\glue 2pt plus 3pt\cr
-{}\\unsetbox for 1 column: a2\cr
-{}\\glue 1pt plus 1fil\cr
-{}\\unsetbox for 1 column: u3\\vrule v3\cr
-{}\\glue 1pt plus 1fil\cr}}$$
-The width of this unset row is unimportant, but it has the correct height
-and depth, so the correct baselineskip glue will be computed as the row
-is inserted into a vertical list.
-
-(6) Since `\.{\\noalign}' follows the current \.{\\cr}, \TeX\ appends
-additional material (in this case \.{\\vskip 3pt}) to the vertical list.
-While processing this material, \TeX\ will be in internal vertical
-mode, and |no_align_group| will be on |save_stack|.
-
-(7) The next row produces an unset box that looks like this:
-$$\vbox{\halign{\hbox to 325pt{\qquad\.{#}\hfil}\cr
-{}\\glue 2pt plus 3pt\cr
-{}\\unsetbox for 2 columns: u1b1v1u2b2v2\cr
-{}\\glue 1pt plus 1fil\cr
-{}\\unsetbox for 1 column: {\rm(empty)}\cr
-{}\\glue 1pt plus 1fil\cr}}$$
-The natural width of the unset box that spans columns 1~and~2 is stored
-in a ``span node,'' which we will explain later; the |span_ptr| field of the
-alignrecord for column~1 now points to the new span node, and the |span_ptr|
-of the span node points to |end_span|.
-
-(8) The final row produces the unset box
-$$\vbox{\halign{\hbox to 325pt{\qquad\.{#}\hfil}\cr
-{}\\glue 2pt plus 3pt\cr
-{}\\unsetbox for 1 column: {\rm(empty)}\cr
-{}\\glue 2pt plus 3pt\cr
-{}\\unsetbox for 2 columns: u2c2v2\cr
-{}\\glue 1pt plus 1fil\cr}}$$
-A new span node is attached to the alignrecord for column 2.
-
-(9) The last step is to compute the true column widths and to change all the
-unset boxes to hboxes, appending the whole works to the vertical list that
-encloses the \.{\\halign}. The rules for deciding on the final widths of
-each unset column box will be explained below.
-
-\yskip\noindent
-Note that as \.{\\halign} is being processed, we fearlessly give up control
-to the rest of \TeX. At critical junctures, an alignment routine is
-called upon to step in and do some little action, but most of the time
-these routines just lurk in the background. It's something like
-post-hypnotic suggestion.
-
-@ We have mentioned that alignrecords contain no |height| or |depth| fields.
-Their |glue_sign| and |glue_order| are pre-empted as well, since it
-is necessary to store information about what to do when a template ends.
-This information is called the |extra_info| field.
-
-@c
-/* could be in texnodes.h, but documented here*/
-
-#define u_part(A)     vlink((A)+depth_offset) /* pointer to \<u_j> token list */
-#define v_part(A)     vinfo((A)+depth_offset) /* pointer to \<v_j> token list */
-#define span_ptr(A)   vinfo((A)+1)            /* column spanning list */
-#define extra_info(A) vinfo((A)+list_offset)  /* info to remember during template */
-
-@ Alignments can occur within alignments, so a small stack is used to access
-the alignrecord information. At each level we have a |preamble| pointer,
-indicating the beginning of the preamble list; a |cur_align| pointer,
-indicating the current position in the preamble list; a |cur_span| pointer,
-indicating the value of |cur_align| at the beginning of a sequence of
-spanned columns; a |cur_loop| pointer, indicating the tabskip glue before
-an alignrecord that should be copied next if the current list is extended;
-and the |align_state| variable, which indicates the nesting of braces so
-that \.{\\cr} and \.{\\span} and tab marks are properly intercepted.
-There also are pointers |cur_head| and |cur_tail| to the head and tail
-of a list of adjustments being moved out from horizontal mode to
-vertical~mode, and alike |cur_pre_head| and |cur_pre_tail| for pre-adjust
-lists.
-
-The current values of these nine quantities appear in global variables;
-when they have to be pushed down, they are stored in 6-word nodes, and
-|align_ptr| points to the topmost such node.
-
-@c
-/* could be in texnodes.h but documented here*/
-
-#define preamble vlink(align_head)      /* the current preamble list */
-
-pointer cur_align = null;       /* current position in preamble list */
-pointer cur_span = null;        /* start of currently spanned columns in preamble list */
-pointer cur_loop = null;        /* place to copy when extending a periodic preamble */
-pointer align_ptr = null;       /* most recently pushed-down alignment stack node */
-pointer cur_head = null, cur_tail = null;       /* adjustment list pointers */
-pointer cur_pre_head = null, cur_pre_tail = null;       /* pre-adjustment list pointers */
-
-/* The |align_state| and |preamble| variables are initialized elsewhere. */
-
-@ Alignment stack maintenance is handled by a pair of trivial routines
-called |push_alignment| and |pop_alignment|.
-
-(HH:) It makes not much sense to add support for an \.{attr} keyword to
-\.{\\halign} and \.{\\valign} because then we need to decide if we tag
-rows or cells or both or come up with \.{cellattr} and \.{rowattr} and
-such. But then it even makes sense to have explicit commands (in addition
-to the seperator) to tags individual cells. Too muss hassle for now and the
-advantages are not that large.
-
-@c
-static void push_alignment(void)
-{
-    pointer p;                  /* the new alignment stack node */
-    p = new_node(align_stack_node, 0);
-    vinfo(p + 1) = align_ptr;
-    vlink(p + 1) = cur_align;
-    vinfo(p + 2) = preamble;
-    vlink(p + 2) = cur_span;
-    vinfo(p + 3) = cur_loop;
-    vlink(p + 3) = align_state;
-    vinfo(p + 4) = cur_head;
-    vlink(p + 4) = cur_tail;
-    vinfo(p + 5) = cur_pre_head;
-    vlink(p + 5) = cur_pre_tail;
-    align_ptr = p;
-    cur_head = new_node(temp_node, 0);
-    cur_pre_head = new_node(temp_node, 0);
-}
-
-static void pop_alignment(void)
-{
-    pointer p;                  /* the top alignment stack node */
-    flush_node(cur_head);
-    flush_node(cur_pre_head);
-    p = align_ptr;
-    cur_pre_tail = vlink(p + 5);
-    cur_pre_head = vinfo(p + 5);
-    cur_tail = vlink(p + 4);
-    cur_head = vinfo(p + 4);
-    align_state = vlink(p + 3);
-    cur_loop = vinfo(p + 3);
-    cur_span = vlink(p + 2);
-    preamble = vinfo(p + 2);
-    cur_align = vlink(p + 1);
-    align_ptr = vinfo(p + 1);
-    flush_node(p);
-}
-
-
-@ \TeX\ has eight procedures that govern alignments: |init_align| and
-|fin_align| are used at the very beginning and the very end; |init_row| and
-|fin_row| are used at the beginning and end of individual rows; |init_span|
-is used at the beginning of a sequence of spanned columns (possibly involving
-only one column); |init_col| and |fin_col| are used at the beginning and
-end of individual columns; and |align_peek| is used after \.{\\cr} to see
-whether the next item is \.{\\noalign}.
-
-We shall consider these routines in the order they are first used during
-the course of a complete \.{\\halign}, namely |init_align|, |align_peek|,
-|init_row|, |init_span|, |init_col|, |fin_col|, |fin_row|, |fin_align|.
-
-
-@ The preamble is copied directly, except that \.{\\tabskip} causes a change
-to the tabskip glue, thereby possibly expanding macros that immediately
-follow it. An appearance of \.{\\span} also causes such an expansion.
-
-Note that if the preamble contains `\.{\\global\\tabskip}', the `\.{\\global}'
-token survives in the preamble and the `\.{\\tabskip}' defines new
-tabskip glue (locally).
-
-@c
-static void get_preamble_token(void)
-{
-  RESTART:
-    get_token();
-    while ((cur_chr == span_code) && (cur_cmd == tab_mark_cmd)) {
-        get_token();            /* this token will be expanded once */
-        if (cur_cmd > max_command_cmd) {
-            expand();
-            get_token();
-        }
-    }
-    if (cur_cmd == endv_cmd)
-        fatal_error("(interwoven alignment preambles are not allowed)");
-    if ((cur_cmd == assign_glue_cmd)
-        && (cur_chr == glue_base + tab_skip_code)) {
-        scan_optional_equals();
-        scan_glue(glue_val_level);
-        if (global_defs_par > 0)
-            geq_define(glue_base + tab_skip_code, glue_ref_cmd, cur_val);
-        else
-            eq_define(glue_base + tab_skip_code, glue_ref_cmd, cur_val);
-        goto RESTART;
-    }
-}
-
-
-
-@ When \.{\\halign} or \.{\\valign} has been scanned in an appropriate
-mode, \TeX\ calls |init_align|, whose task is to get everything off to a
-good start. This mostly involves scanning the preamble and putting its
-information into the preamble list.
-@^preamble@>
-
-@c
-void init_align(void)
-{
-    /* label done, done1, done2, continue; */
-    pointer save_cs_ptr;        /* |warning_index| value for error messages */
-    pointer p, r;               /* for short-term temporary use */
-    save_cs_ptr = cur_cs;       /* \.{\\halign} or \.{\\valign}, usually */
-    push_alignment();
-    align_state = -1000000;     /* enter a new alignment level */
-
-    /* When \.{\\halign} is used as a displayed formula, there should be
-       no other pieces of mlists present. */
-
-    if ((cur_list.mode_field == mmode)
-        && ((cur_list.tail_field != cur_list.head_field)
-            || (incompleat_noad_par != null))) {
-        const char *hlp[] =
-            { "Displays can use special alignments (like \\eqalignno)",
-            "only if nothing but the alignment itself is between $$'s.",
-            "So I've deleted the formulas that preceded this alignment.",
-            NULL
-        };
-        tex_error("Improper \\halign inside $$'s", hlp);
-        flush_math();
-    }
-    push_nest();                /* enter a new semantic level */
-    /* In vertical modes, |prev_depth| already has the correct value. But
-       if we are in |mmode| (displayed formula mode), we reach out to the
-       enclosing vertical mode for the |prev_depth| value that produces the
-       correct baseline calculations. */
-    if (cur_list.mode_field == mmode) {
-        cur_list.mode_field = -vmode;
-        prev_depth_par = nest[nest_ptr - 2].prev_depth_field;
-    } else if (cur_list.mode_field > 0) {
-        cur_list.mode_field = -(cur_list.mode_field);
-    }
-    scan_spec(align_group);
-    /* Scan the preamble */
-    preamble = null;
-    cur_align = align_head;
-    cur_loop = null;
-    scanner_status = aligning;
-    warning_index = save_cs_ptr;
-    align_state = -1000000;
-    /* at this point, |cur_cmd=left_brace| */
-    while (true) {
-        /* Append the current tabskip glue to the preamble list */
-        r = new_param_glue(tab_skip_code);
-        vlink(cur_align) = r;
-        cur_align = vlink(cur_align);
-
-        if (cur_cmd == car_ret_cmd)
-            break;              /* \.{\\cr} ends the preamble */
-
-        /* Scan preamble text until |cur_cmd| is |tab_mark| or |car_ret| */
-        /* Scan the template \<u_j>, putting the resulting token list in |hold_token_head| */
-        /* Spaces are eliminated from the beginning of a template. */
-
-        p = hold_token_head;
-        token_link(p) = null;
-        while (1) {
-            get_preamble_token();
-            if (cur_cmd == mac_param_cmd)
-                break;
-            if ((cur_cmd <= car_ret_cmd) && (cur_cmd >= tab_mark_cmd)
-                && (align_state == -1000000)) {
-                if ((p == hold_token_head) && (cur_loop == null)
-                    && (cur_cmd == tab_mark_cmd)) {
-                    cur_loop = cur_align;
-                } else {
-                    const char *hlp[] =
-                        { "There should be exactly one # between &'s, when an",
-                        "\\halign or \\valign is being set up. In this case you had",
-                        "none, so I've put one in; maybe that will work.",
-                        NULL
-                    };
-                    back_input();
-                    tex_error("Missing # inserted in alignment preamble", hlp);
-                    break;
-                }
-            } else if ((cur_cmd != spacer_cmd) || (p != hold_token_head)) {
-                r = get_avail();
-                token_link(p) = r;
-                p = token_link(p);
-                token_info(p) = cur_tok;
-            }
-        }
-        r = new_node(align_record_node, 0);
-        vlink(cur_align) = r;
-        cur_align = vlink(cur_align);   /* a new alignrecord */
-        span_ptr(cur_align) = end_span;
-        width(cur_align) = null_flag;
-        u_part(cur_align) = token_link(hold_token_head);
-        /* Scan the template \<v_j>, putting the resulting token list in |hold_token_head| */
-
-        p = hold_token_head;
-        token_link(p) = null;
-        while (1) {
-          CONTINUE:
-            get_preamble_token();
-            if ((cur_cmd <= car_ret_cmd) && (cur_cmd >= tab_mark_cmd)
-                && (align_state == -1000000))
-                break;
-            if (cur_cmd == mac_param_cmd) {
-                const char *hlp[] =
-                    { "There should be exactly one # between &'s, when an",
-                    "\\halign or \\valign is being set up. In this case you had",
-                    "more than one, so I'm ignoring all but the first.",
-                    NULL
-                };
-                tex_error("Only one # is allowed per tab", hlp);
-                goto CONTINUE;
-            }
-            r = get_avail();
-            token_link(p) = r;
-            p = token_link(p);
-            token_info(p) = cur_tok;
-        }
-        r = get_avail();
-        token_link(p) = r;
-        p = token_link(p);
-        token_info(p) = end_template_token;     /* put \.{\\endtemplate} at the end */
-
-        v_part(cur_align) = token_link(hold_token_head);
-    }
-    scanner_status = normal;
-
-    new_save_level(align_group);
-    if (every_cr_par != null)
-        begin_token_list(every_cr_par, every_cr_text);
-    align_peek();               /* look for \.{\\noalign} or \.{\\omit} */
-}
-
-
-@ The tricky part about alignments is getting the templates into the
-scanner at the right time, and recovering control when a row or column
-is finished.
-
-We usually begin a row after each \.{\\cr} has been sensed, unless that
-\.{\\cr} is followed by \.{\\noalign} or by the right brace that terminates
-the alignment. The |align_peek| routine is used to look ahead and do
-the right thing; it either gets a new row started, or gets a \.{\\noalign}
-started, or finishes off the alignment.
-
-@c
-void align_peek(void)
-{
-  RESTART:
-    align_state = 1000000;
-    do {
-        get_x_or_protected();
-    } while (cur_cmd == spacer_cmd);
-    if (cur_cmd == no_align_cmd) {
-        scan_left_brace();
-        new_save_level(no_align_group);
-        if (cur_list.mode_field == -vmode)
-            normal_paragraph();
-    } else if (cur_cmd == right_brace_cmd) {
-        fin_align();
-    } else if ((cur_cmd == car_ret_cmd) && (cur_chr == cr_cr_code)) {
-        goto RESTART;           /* ignore \.{\\crcr} */
-    } else {
-        init_row();             /* start a new row */
-        init_col();             /* start a new column and replace what we peeked at */
-    }
-}
-
-
-@ The parameter to |init_span| is a pointer to the alignrecord where the
-next column or group of columns will begin. A new semantic level is
-entered, so that the columns will generate a list for subsequent packaging.
-
-@c
-static void init_span(pointer p)
-{
-    push_nest();
-    if (cur_list.mode_field == -hmode) {
-        space_factor_par = 1000;
-    } else {
-        prev_depth_par = ignore_depth;
-        normal_paragraph();
-    }
-    cur_span = p;
-}
-
-
-@ To start a row (i.e., a `row' that rhymes with `dough' but not with `bough'),
-we enter a new semantic level, copy the first tabskip glue, and change
-from internal vertical mode to restricted horizontal mode or vice versa.
-The |space_factor| and |prev_depth| are not used on this semantic level,
-but we clear them to zero just to be tidy.
-
-@c
-void init_row(void)
-{
-    push_nest();
-    cur_list.mode_field = (-hmode - vmode) - cur_list.mode_field;
-    if (cur_list.mode_field == -hmode)
-        space_factor_par = 0;
-    else
-        prev_depth_par = 0;
-    tail_append(new_glue(preamble));
-    subtype(cur_list.tail_field) = tab_skip_code + 1;
-    cur_align = vlink(preamble);
-    cur_tail = cur_head;
-    cur_pre_tail = cur_pre_head;
-    init_span(cur_align);
-}
-
-
-@ When a column begins, we assume that |cur_cmd| is either |omit| or else
-the current token should be put back into the input until the \<u_j>
-template has been scanned.  (Note that |cur_cmd| might be |tab_mark| or
-|car_ret|.)  We also assume that |align_state| is approximately 1000000 at
-this time.  We remain in the same mode, and start the template if it is
-called for.
-
-@c
-void init_col(void)
-{
-    extra_info(cur_align) = cur_cmd;
-    if (cur_cmd == omit_cmd)
-        align_state = 0;
-    else {
-        back_input();
-        begin_token_list(u_part(cur_align), u_template);
-    }                           /* now |align_state=1000000| */
-}
-
-
-@ The scanner sets |align_state| to zero when the \<u_j> template ends. When
-a subsequent \.{\\cr} or \.{\\span} or tab mark occurs with |align_state=0|,
-the scanner activates the following code, which fires up the \<v_j> template.
-We need to remember the |cur_chr|, which is either |cr_cr_code|, |cr_code|,
-|span_code|, or a character code, depending on how the column text has ended.
-
-This part of the program had better not be activated when the preamble
-to another alignment is being scanned, or when no alignment preamble is active.
-
-@c
-void insert_vj_template(void)
-{
-    if ((scanner_status == aligning) || (cur_align == null))
-        fatal_error("(interwoven alignment preambles are not allowed)");
-    cur_cmd = extra_info(cur_align);
-    extra_info(cur_align) = cur_chr;
-    if (cur_cmd == omit_cmd)
-        begin_token_list(omit_template, v_template);
-    else
-        begin_token_list(v_part(cur_align), v_template);
-    align_state = 1000000;
-}
-
-/* Determine the stretch order */
-#define determine_stretch_order() do {              \
-        if (total_stretch[filll]!=0)  o=filll;      \
-        else if (total_stretch[fill]!=0)  o=fill;   \
-        else if (total_stretch[fil]!=0)  o=fil;     \
-        else if (total_stretch[sfi]!=0)  o=sfi;     \
-        else o=normal;                              \
-    } while (0)
-
-
-/* Determine the shrink order */
-#define determine_shrink_order() do {              \
-        if (total_shrink[filll]!=0)  o=filll;      \
-        else if (total_shrink[fill]!=0)  o=fill;   \
-        else if (total_shrink[fil]!=0)  o=fil;     \
-        else if (total_shrink[sfi]!=0)  o=sfi;     \
-        else o=normal;                              \
-    } while (0)
-
-
-
-@ When the |endv| command at the end of a \<v_j> template comes through the
-scanner, things really start to happen; and it is the |fin_col| routine
-that makes them happen. This routine returns |true| if a row as well as a
-column has been finished.
-
-@c
-boolean fin_col(void)
-{
-    pointer p;                  /* the alignrecord after the current one */
-    pointer q, r;               /* temporary pointers for list manipulation */
-    pointer s;                  /* a new span node */
-    pointer u;                  /* a new unset box */
-    scaled w;                   /* natural width */
-    unsigned char o;            /* order of infinity */
-    halfword n;                 /* span counter */
-    if (cur_align == null)
-        confusion("endv");
-    q = vlink(cur_align);
-    if (q == null)
-        confusion("endv");
-    if (align_state < 500000)
-        fatal_error("(interwoven alignment preambles are not allowed)");
-    p = vlink(q);
-    /* If the preamble list has been traversed, check that the row has ended */
-    if ((p == null) && (extra_info(cur_align) < cr_code)) {
-        if (cur_loop != null) {
-            /* Lengthen the preamble periodically */
-            r = new_node(align_record_node, 0);
-            vlink(q) = r;
-            p = vlink(q);       /* a new alignrecord */
-            span_ptr(p) = end_span;
-            width(p) = null_flag;
-            cur_loop = vlink(cur_loop);
-
-            /* Copy the templates from node |cur_loop| into node |p| */
-            q = hold_token_head;
-            r = u_part(cur_loop);
-            while (r != null) {
-                s = get_avail();
-                token_link(q) = s;
-                q = token_link(q);
-                token_info(q) = token_info(r);
-                r = token_link(r);
-            }
-            token_link(q) = null;
-            u_part(p) = token_link(hold_token_head);
-            q = hold_token_head;
-            r = v_part(cur_loop);
-            while (r != null) {
-                s = get_avail();
-                token_link(q) = s;
-                q = token_link(q);
-                token_info(q) = token_info(r);
-                r = token_link(r);
-            }
-            token_link(q) = null;
-            v_part(p) = token_link(hold_token_head);
-
-            cur_loop = vlink(cur_loop);
-            r = new_glue(cur_loop);
-            vlink(p) = r;
-        } else {
-            const char *hlp[] =
-                { "You have given more \\span or & marks than there were",
-                "in the preamble to the \\halign or \\valign now in progress.",
-                "So I'll assume that you meant to type \\cr instead.",
-                NULL
-            };
-            extra_info(cur_align) = cr_code;
-            tex_error("Extra alignment tab has been changed to \\cr", hlp);
-        }
-    }
-    if (extra_info(cur_align) != span_code) {
-        unsave();
-        new_save_level(align_group);
-        /* Package an unset box for the current column and record its width */
-        if (cur_list.mode_field == -hmode) {
-            adjust_tail = cur_tail;
-            pre_adjust_tail = cur_pre_tail;
-            u = filtered_hpack(cur_list.head_field, cur_list.tail_field, 0,
-                               additional, align_set_group, -1, 0, 0);
-            w = width(u);
-            cur_tail = adjust_tail;
-            adjust_tail = null;
-            cur_pre_tail = pre_adjust_tail;
-            pre_adjust_tail = null;
-        } else {
-            u = filtered_vpackage(vlink(cur_list.head_field),
-                0, additional, 0, align_set_group, -1, 0, 0);
-            w = height(u);
-        }
-        n = min_quarterword;    /* this represents a span count of 1 */
-        if (cur_span != cur_align) {
-            /* Update width entry for spanned columns */
-            q = cur_span;
-            do {
-                incr(n);
-                q = vlink(vlink(q));
-            } while (q != cur_align);
-            if (n > max_quarterword)
-                confusion("too many spans");    /* this can happen, but won't */
-            q = cur_span;
-            while (span_span(span_ptr(q)) < n) {
-                q = span_ptr(q);
-            }
-            if (span_span(span_ptr(q)) > n) {
-                s = new_span_node(span_ptr(q), n, w);
-                span_ptr(q) = s;
-            } else if (width(span_ptr(q)) < w) {
-                width(span_ptr(q)) = w;
-            }
-
-        } else if (w > width(cur_align)) {
-            width(cur_align) = w;
-        }
-        type(u) = unset_node;
-        span_count(u) = (quarterword) n;
-        determine_stretch_order();
-        glue_order(u) = o;
-        glue_stretch(u) = total_stretch[o];
-        determine_shrink_order();
-        glue_sign(u) = o;
-        glue_shrink(u) = total_shrink[o];
-        pop_nest();
-        vlink(cur_list.tail_field) = u;
-        cur_list.tail_field = u;
-
-        /* Copy the tabskip glue between columns */
-        tail_append(new_glue(vlink(cur_align)));
-        subtype(cur_list.tail_field) = tab_skip_code + 1;
-
-        if (extra_info(cur_align) >= cr_code) {
-            return true;
-        }
-        init_span(p);
-    }
-    align_state = 1000000;
-    do {
-        get_x_or_protected();
-    } while (cur_cmd == spacer_cmd);
-    cur_align = p;
-    init_col();
-    return false;
-}
-
-
-
-@ A span node is a 3-word record containing |width|, |span_span|, and
-|span_ptr| fields. The |span_span| field indicates the number of
-spanned columns; the |span_ptr| field points to a span node for the same
-starting column, having a greater extent of spanning, or to
-|end_span|, which has the largest possible |span_span| field; the |width|
-field holds the largest natural width corresponding to a particular
-set of spanned columns.
-
-A list of the maximum widths so far, for spanned columns starting at a
-given column, begins with the |span_ptr| field of the alignrecord for
-that column. The code has to make sure that there is room for
-|span_ptr| in both the alignrecord and the span nodes, which is why
-|span_ptr| replaces |node_attr|.
-@^data structure assumptions@>
-
-The |new_span_node| function is defined in |texnodes.c|.
-
-@c
-#ifndef span_span
-#  define span_span(A) vlink((A)+1)     /* that is normally |alink| */
-#endif
-
-
-@ At the end of a row, we append an unset box to the current vlist (for
-\.{\\halign}) or the current hlist (for \.{\\valign}). This unset box
-contains the unset boxes for the columns, separated by the tabskip glue.
-Everything will be set later.
-
-@c
-void fin_row(void)
-{
-    pointer p;                  /* the new unset box */
-    if (cur_list.mode_field == -hmode) {
-        p = filtered_hpack(cur_list.head_field, cur_list.tail_field, 0,
-                           additional, fin_row_group, -1, 0, 0);
-        pop_nest();
-        if (cur_pre_head != cur_pre_tail)
-            append_list(cur_pre_head, cur_pre_tail);
-        append_to_vlist(p,lua_key_index(alignment));
-        if (cur_head != cur_tail)
-            append_list(cur_head, cur_tail);
-    } else {
-        p = filtered_vpackage(vlink(cur_list.head_field),
-            0, additional, max_depth_par, fin_row_group, -1, 0, 0);
-        pop_nest();
-        vlink(cur_list.tail_field) = p;
-        cur_list.tail_field = p;
-        space_factor_par = 1000;
-    }
-    type(p) = unset_node;
-    glue_stretch(p) = 0;
-    if (every_cr_par != null)
-        begin_token_list(every_cr_par, every_cr_text);
-    align_peek();
-    /* note that |glue_shrink(p)=0| since |glue_shrink==shift_amount| */
-}
-
-
-@ Finally, we will reach the end of the alignment, and we can breathe a
-sigh of relief that memory hasn't overflowed. All the unset boxes will now be
-set so that the columns line up, taking due account of spanned columns.
-
-@c
-void fin_align(void)
-{
-    pointer p, q, r, s, u, rr;  /* registers for the list operations */
-    scaled t, w;                /* width of column */
-    scaled o;                   /* shift offset for unset boxes */
-    halfword n;                 /* matching span amount */
-    scaled rule_save;           /* temporary storage for |overfull_rule| */
-    halfword pd;                /* temporary storage for |prev_depth| */
-    halfword ng;                /*  temporary storage for |new_glue| */
-    if (cur_group != align_group)
-        confusion("align1");
-    unsave();                   /* that |align_group| was for individual entries */
-    if (cur_group != align_group)
-        confusion("align0");
-    unsave();                   /* that |align_group| was for the whole alignment */
-    if (nest[nest_ptr - 1].mode_field == mmode)
-        o = display_indent_par;
-    else
-        o = 0;
-    /* Go through the preamble list, determining the column widths and
-     * changing the alignrecords to dummy unset boxes
-     */
-
-/* It's time now to dismantle the preamble list and to compute the column
-widths. Let $w_{ij}$ be the maximum of the natural widths of all entries
-that span columns $i$ through $j$, inclusive. The alignrecord for column~$i$
-contains $w_{ii}$ in its |width| field, and there is also a linked list of
-the nonzero $w_{ij}$ for increasing $j$, accessible via the |info| field;
-these span nodes contain the value $j-i+|min_quarterword|$ in their
-|link| fields. The values of $w_{ii}$ were initialized to |null_flag|, which
-we regard as $-\infty$.
-
-The final column widths are defined by the formula
-$$w_j=\max_{1\L i\L j}\biggl( w_{ij}-\sum_{i\L k<j}(t_k+w_k)\biggr),$$
-where $t_k$ is the natural width of the tabskip glue between columns
-$k$ and~$k+1$. However, if $w_{ij}=-\infty$ for all |i| in the range
-|1<=i<=j| (i.e., if every entry that involved column~|j| also involved
-column~|j+1|), we let $w_j=0$, and we zero out the tabskip glue after
-column~|j|.
-
-\TeX\ computes these values by using the following scheme: First $w_1=w_{11}$.
-Then replace $w_{2j}$ by $\max(w_{2j},w_{1j}-t_1-w_1)$, for all $j>1$.
-Then $w_2=w_{22}$. Then replace $w_{3j}$ by $\max(w_{3j},w_{2j}-t_2-w_2)$
-for all $j>2$; and so on. If any $w_j$ turns out to be $-\infty$, its
-value is changed to zero and so is the next tabskip.
-*/
-    q = vlink(preamble);
-    do {
-        flush_list(u_part(q));
-        flush_list(v_part(q));
-        p = vlink(vlink(q));
-        if (width(q) == null_flag) {
-            /* Nullify |width(q)| and the tabskip glue following this column */
-            width(q) = 0;
-            r = vlink(q);
-            reset_glue_to_zero(r); /* is a lready copy */
-        }
-        if (span_ptr(q) != end_span) {
-            /* Merge the widths in the span nodes of |q| with those of |p|,
-               destroying the span nodes of |q| */
-            /*
-               Merging of two span-node lists is a typical exercise in the manipulation of
-               linearly linked data structures. The essential invariant in the following
-               |repeat| loop is that we want to dispense with node |r|, in |q|'s list,
-               and |u| is its successor; all nodes of |p|'s list up to and including |s|
-               have been processed, and the successor of |s| matches |r| or precedes |r|
-               or follows |r|, according as |link(r)=n| or |link(r)>n| or |link(r)<n|.
-             */
-            t = width(q) + width(vlink(q));
-            r = span_ptr(q);
-            s = end_span;
-            span_ptr(s) = p;
-            n = min_quarterword + 1;
-            do {
-                width(r) = width(r) - t;
-                u = span_ptr(r);
-                while (span_span(r) > n) {
-                    s = span_ptr(s);
-                    n = span_span(span_ptr(s)) + 1;
-                }
-                if (span_span(r) < n) {
-                    span_ptr(r) = span_ptr(s);
-                    span_ptr(s) = r;
-                    decr(span_span(r));
-                    s = r;
-                } else {
-                    if (width(r) > width(span_ptr(s)))
-                        width(span_ptr(s)) = width(r);
-                    flush_node(r);
-                }
-                r = u;
-            } while (r != end_span);
-        }
-        type(q) = unset_node;
-        span_count(q) = min_quarterword;
-        height(q) = 0;
-        depth(q) = 0;
-        glue_order(q) = normal;
-        glue_sign(q) = normal;
-        glue_stretch(q) = 0;
-        glue_shrink(q) = 0;
-        q = p;
-    } while (q != null);
-
-    /* Package the preamble list, to determine the actual tabskip glue amounts,
-       and let |p| point to this prototype box */
-    /* Now the preamble list has been converted to a list of alternating unset
-       boxes and tabskip glue, where the box widths are equal to the final
-       column sizes. In case of \.{\\valign}, we change the widths to heights,
-       so that a correct error message will be produced if the alignment is
-       overfull or underfull.
-     */
-
-    decr(save_ptr);
-    pack_begin_line = -cur_list.ml_field;
-    if (cur_list.mode_field == -vmode) {
-        rule_save = overfull_rule_par;
-        overfull_rule_par = 0;      /* prevent rule from being packaged */
-        p = hpack(preamble, saved_value(0), saved_level(0), -1);
-        overfull_rule_par = rule_save;
-    } else {
-        q = vlink(preamble);
-        do {
-            height(q) = width(q);
-            width(q) = 0;
-            q = vlink(vlink(q));
-        } while (q != null);
-        p = filtered_vpackage(preamble,
-            saved_value(0), saved_level(0), max_depth_par, preamble_group, -1, 0, 0);
-        q = vlink(preamble);
-        do {
-            width(q) = height(q);
-            height(q) = 0;
-            q = vlink(vlink(q));
-        } while (q != null);
-    }
-    pack_begin_line = 0;
-
-    /* Set the glue in all the unset boxes of the current list */
-    q = vlink(cur_list.head_field);
-    s = cur_list.head_field;
-    while (q != null) {
-        if (!is_char_node(q)) {
-            if (type(q) == unset_node) {
-                /* Set the unset box |q| and the unset boxes in it */
-                /* The unset box |q| represents a row that contains one or more unset boxes,
-                   depending on how soon \.{\\cr} occurred in that row. */
-
-                if (cur_list.mode_field == -vmode) {
-                    type(q) = hlist_node;
-                    subtype(q) = align_row_list;
-                    width(q) = width(p);
-                } else {
-                    type(q) = vlist_node;
-                    subtype(q) = align_row_list;
-                    height(q) = height(p);
-                }
-                glue_order(q) = glue_order(p);
-                glue_sign(q) = glue_sign(p);
-                glue_set(q) = glue_set(p);
-                shift_amount(q) = o;
-                r = vlink(list_ptr(q));
-                assert (type(r) == unset_node);
-                s = vlink(list_ptr(p));
-                do {
-                    /* Set the glue in node |r| and change it from an unset node */
-                    /* A box made from spanned columns will be followed by tabskip glue nodes and
-                       by empty boxes as if there were no spanning. This permits perfect alignment
-                       of subsequent entries, and it prevents values that depend on floating point
-                       arithmetic from entering into the dimensions of any boxes.
-                     */
-                    n = span_count(r);
-                    t = width(s);
-                    w = t;
-                    u = hold_head;
-                    while (n > min_quarterword) {
-                        decr(n);
-                        /* Append tabskip glue and an empty box to list |u|,
-                           and update |s| and |t| as the prototype nodes are passed */
-
-                        s = vlink(s);
-                        ng = new_glue(s);
-                        vlink(u) = ng;
-                        u = vlink(u);
-                        subtype(u) = tab_skip_code + 1;
-                        t = t + width(s);
-                        if (glue_sign(p) == stretching) {
-                            if (stretch_order(s) == glue_order(p))
-                                t = t + round(float_cast(glue_set(p)) * float_cast(stretch(s)));
-                        } else if (glue_sign(p) == shrinking) {
-                            if (shrink_order(s) == glue_order(p))
-                                t = t - round(float_cast(glue_set(p)) * float_cast(shrink(s)));
-                        }
-                        s = vlink(s);
-                        rr = new_null_box();
-                        vlink(u) = rr;
-                        u = vlink(u);
-                        t = t + width(s);
-                        subtype(u) = align_cell_list;
-                        if (cur_list.mode_field == -vmode) {
-                            width(u) = width(s);
-                        } else {
-                            type(u) = vlist_node;
-                            height(u) = width(s);
-                        }
-
-                    }
-                    if (cur_list.mode_field == -vmode) {
-                        /* Make the unset node |r| into an |hlist_node| of width |w|,
-                           setting the glue as if the width were |t| */
-
-                        height(r) = height(q);
-                        depth(r) = depth(q);
-                        if (t == width(r)) {
-                            glue_sign(r) = normal;
-                            glue_order(r) = normal;
-                            set_glue_ratio_zero(glue_set(r));
-                        } else if (t > width(r)) {
-                            glue_sign(r) = stretching;
-                            if (glue_stretch(r) == 0)
-                                set_glue_ratio_zero(glue_set(r));
-                            else
-                                glue_set(r) =
-                                    unfloat((double) (t - width(r)) /
-                                            glue_stretch(r));
-                        } else {
-                            glue_order(r) = glue_sign(r);
-                            glue_sign(r) = shrinking;
-                            if (glue_shrink(r) == 0)
-                                set_glue_ratio_zero(glue_set(r));
-                            else if ((glue_order(r) == normal)
-                                     && (width(r) - t > glue_shrink(r)))
-                                set_glue_ratio_one(glue_set(r));
-                            else
-                                glue_set(r) =
-                                    unfloat((double) (width(r) - t) /
-                                            glue_shrink(r));
-                        }
-                        width(r) = w;
-                        type(r) = hlist_node;
-                        subtype(r) = align_cell_list;
-
-                    } else {
-                        /* Make the unset node |r| into a |vlist_node| of height |w|,
-                           setting the glue as if the height were |t| */
-
-                        width(r) = width(q);
-                        if (t == height(r)) {
-                            glue_sign(r) = normal;
-                            glue_order(r) = normal;
-                            set_glue_ratio_zero(glue_set(r));
-                        } else if (t > height(r)) {
-                            glue_sign(r) = stretching;
-                            if (glue_stretch(r) == 0)
-                                set_glue_ratio_zero(glue_set(r));
-                            else
-                                glue_set(r) =
-                                    unfloat((t - height(r)) / glue_stretch(r));
-                        } else {
-                            glue_order(r) = glue_sign(r);
-                            glue_sign(r) = shrinking;
-                            if (glue_shrink(r) == 0)
-                                set_glue_ratio_zero(glue_set(r));
-                            else if ((glue_order(r) == normal)
-                                     && (height(r) - t > glue_shrink(r)))
-                                set_glue_ratio_one(glue_set(r));
-                            else
-                                glue_set(r) =
-                                    unfloat((height(r) - t) / glue_shrink(r));
-                        }
-                        height(r) = w;
-                        type(r) = vlist_node;
-                        subtype(r) = align_cell_list;
-
-                    }
-                    /* subtype(r) = 0; */
-                    shift_amount(r) = 0;
-                    if (u != hold_head) {       /* append blank boxes to account for spanned nodes */
-                        vlink(u) = vlink(r);
-                        vlink(r) = vlink(hold_head);
-                        r = u;
-                    }
-
-                    r = vlink(vlink(r));
-                    s = vlink(vlink(s));
-                } while (r != null);
-
-            } else if (type(q) == rule_node) {
-                /* Make the running dimensions in rule |q| extend to the
-                   boundaries of the alignment */
-                if (is_running(width(q)))
-                    width(q) = width(p);
-                if (is_running(height(q)))
-                    height(q) = height(p);
-                if (is_running(depth(q)))
-                    depth(q) = depth(p);
-                if (o != 0) {
-                    r = vlink(q);
-                    vlink(q) = null;
-                    q = hpack(q, 0, additional, -1);
-                    shift_amount(q) = o;
-                    subtype(q) = align_cell_list;
-                    vlink(q) = r;
-                    vlink(s) = q;
-                }
-            }
-        }
-        s = q;
-        q = vlink(q);
-    }
-    flush_node_list(p);
-    pop_alignment();
-    /* Insert the current list into its environment */
-    /* We now have a completed alignment, in the list that starts at |cur_list.head_field|
-       and ends at |cur_list.tail_field|. This list will be merged with the one that encloses
-       it. (In case the enclosing mode is |mmode|, for displayed formulas,
-       we will need to insert glue before and after the display; that part of the
-       program will be deferred until we're more familiar with such operations.)
-     */
-    pd = prev_depth_par;
-    p = vlink(cur_list.head_field);
-    q = cur_list.tail_field;
-    pop_nest();
-    if (cur_list.mode_field == mmode) {
-        finish_display_alignment(p, q, pd);
-    } else {
-        prev_depth_par = pd; /* aux:=aux_save; */
-        vlink(cur_list.tail_field) = p;
-        if (p != null)
-            cur_list.tail_field = q;
-        if (cur_list.mode_field == vmode) {
-            if (!output_active)
-                lua_node_filter_s(buildpage_filter_callback,lua_key_index(alignment));
-            build_page();
-        }
-    }
-}
-
-@ The token list |omit_template| just referred to is a constant token
-list that contains the special control sequence \.{\\endtemplate} only.
-
-@c
-void initialize_alignments(void)
-{
-    token_info(omit_template) = end_template_token;     /* |link(omit_template)=null| */
-    span_span(end_span) = max_quarterword + 1;
-    span_ptr(end_span) = null;
-}
diff --git a/texk/web2c/luatexdir/tex/arithmetic.c b/texk/web2c/luatexdir/tex/arithmetic.c
new file mode 100644
index 000000000..2782c2534
--- /dev/null
+++ b/texk/web2c/luatexdir/tex/arithmetic.c
@@ -0,0 +1,815 @@
+/*
+
+arithmetic.w
+
+Copyright 2009-2010 Taco Hoekwater <taco@@luatex.org>
+
+This file is part of LuaTeX.
+
+LuaTeX is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 2 of the License, or (at your
+option) any later version.
+
+LuaTeX is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+License for more details.
+
+You should have received a copy of the GNU General Public License along
+with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#include "ptexlib.h"
+
+/*tex
+
+The principal computations performed by \TeX\ are done entirely in terms of
+integers less than $2^{31}$ in magnitude; and divisions are done only when both
+dividend and divisor are nonnegative. Thus, the arithmetic specified in this
+program can be carried out in exactly the same way on a wide variety of
+computers, including some small ones. Why? Because the arithmetic calculations
+need to be spelled out precisely in order to guarantee that \TeX\ will produce
+identical output on different machines. If some quantities were rounded
+differently in different implementations, we would find that line breaks and even
+page breaks might occur in different places. Hence the arithmetic of \TeX\ has
+been designed with care, and systems that claim to be implementations of \TeX82
+should follow precisely the @:TeX82}{\TeX82@> calculations as they appear in the
+present program.
+
+Actually there are three places where \TeX\ uses |div| with a possibly negative
+numerator. These are harmless; see |div| in the index. Also if the user sets the
+\.{\\time} or the \.{\\year} to a negative value, some diagnostic information
+will involve negative-numerator division. The same remarks apply for |mod| as
+well as for |div|.
+
+Here is a routine that calculates half of an integer, using an unambiguous
+convention with respect to signed odd numbers.
+
+*/
+
+int half(int x)
+{
+    if (odd(x))
+        return ((x + 1) / 2);
+    else
+        return (x / 2);
+}
+
+/*tex
+
+The following function is used to create a scaled integer from a given decimal
+fraction $(.d_0d_1\ldots d_{k-1})$, where |0<=k<=17|. The digit $d_i$ is
+given in |dig[i]|, and the calculation produces a correctly rounded result.
+
+*/
+
+scaled round_decimals(int k)
+{
+    int a = 0;
+    while (k-- > 0) {
+        a = (a + dig[k] * two) / 10;
+    }
+    return ((a + 1) / 2);
+}
+
+/*tex
+
+Conversely, here is a procedure analogous to |print_int|. If the output of this
+procedure is subsequently read by \TeX\ and converted by the |round_decimals|
+routine above, it turns out that the original value will be reproduced exactly;
+the ``simplest'' such decimal number is output, but there is always at least one
+digit following the decimal point.
+
+The invariant relation in the \&{repeat} loop is that a sequence of decimal
+digits yet to be printed will yield the original number if and only if they form
+a fraction~$f$ in the range $s-\delta\L10\cdot2^{16}f<s$. We can stop if and only
+if $f=0$ satisfies this condition; the loop will terminate before $s$ can
+possibly become zero.
+
+The next one prints a scaled real, rounded to five digits.
+
+*/
+
+void print_scaled(scaled s)
+{
+    /*tex The amount of allowable inaccuracy: */
+    scaled delta;
+    char buffer[20];
+    int i = 0;
+    if (s < 0) {
+        /*tex Print the sign, if negative. */
+        print_char('-');
+        negate(s);
+    }
+    /*tex Print the integer part. */
+    print_int(s / unity);
+    buffer[i++] = '.';
+    s = 10 * (s % unity) + 5;
+    delta = 10;
+    do {
+        if (delta > unity) {
+            /*tex Round the last digit. */
+            s = s + 0100000 - 50000;
+        }
+        buffer[i++] = '0' + (s / unity);
+        s = 10 * (s % unity);
+        delta = delta * 10;
+    } while (s > delta);
+    buffer[i++] = '\0';
+    tprint(buffer);
+}
+
+/*tex
+
+Physical sizes that a \TeX\ user specifies for portions of documents are
+represented internally as scaled points. Thus, if we define an `sp' (scaled
+@^sp@> point) as a unit equal to $2^{-16}$ printer's points, every dimension
+inside of \TeX\ is an integer number of sp. There are exactly 4,736,286.72 sp per
+inch. Users are not allowed to specify dimensions larger than $2^{30}-1$ sp,
+which is a distance of about 18.892 feet (5.7583 meters); two such quantities can
+be added without overflow on a 32-bit computer.
+
+The present implementation of \TeX\ does not check for overflow when @^overflow
+in arithmetic@> dimensions are added or subtracted. This could be done by
+inserting a few dozen tests of the form `\ignorespaces|if x>=010000000000 then
+@t\\{report\_overflow}@>|', but the chance of overflow is so remote that such
+tests do not seem worthwhile.
+
+\TeX\ needs to do only a few arithmetic operations on scaled quantities, other
+than addition and subtraction, and the following subroutines do most of the work.
+A single computation might use several subroutine calls, and it is desirable to
+avoid producing multiple error messages in case of arithmetic overflow; so the
+routines set the global variable |arith_error| to |true| instead of reporting
+errors directly to the user. Another global variable, |tex_remainder|, holds the
+remainder after a division.
+
+*/
+
+/*tex Has arithmetic overflow occurred recently? */
+
+boolean arith_error;
+
+/*tex The amount subtracted to get an exact division. */
+
+scaled tex_remainder;
+
+/*tex
+
+ The first arithmetical subroutine we need computes $nx+y$, where |x|
+and~|y| are |scaled| and |n| is an integer. We will also use it to
+multiply integers.
+
+*/
+
+scaled mult_and_add(int n, scaled x, scaled y, scaled max_answer)
+{
+    if (n == 0)
+        return y;
+    if (n < 0) {
+        negate(x);
+        negate(n);
+    }
+    if (((x <= (max_answer - y) / n) && (-x <= (max_answer + y) / n))) {
+        return (n * x + y);
+    } else {
+        arith_error = true;
+        return 0;
+    }
+}
+
+/*tex
+
+We also need to divide scaled dimensions by integers.
+
+*/
+
+scaled x_over_n(scaled x, int n)
+{
+    /*tex Should |tex_remainder| be negated? */
+    boolean negative = false;
+    if (n == 0) {
+        arith_error = true;
+        tex_remainder = x;
+        return 0;
+    } else {
+        if (n < 0) {
+            negate(x);
+            negate(n);
+            negative = true;
+        }
+        if (x >= 0) {
+            tex_remainder = x % n;
+            if (negative)
+                negate(tex_remainder);
+            return (x / n);
+        } else {
+            tex_remainder = -((-x) % n);
+            if (negative)
+                negate(tex_remainder);
+            return (-((-x) / n));
+        }
+    }
+}
+
+/*tex
+
+Then comes the multiplication of a scaled number by a fraction |n/d|, where |n|
+and |d| are nonnegative integers |<=@t$2^{16}$@>| and |d| is positive. It would
+be too dangerous to multiply by~|n| and then divide by~|d|, in separate
+operations, since overflow might well occur; and it would be too inaccurate to
+divide by |d| and then multiply by |n|. Hence this subroutine simulates
+1.5-precision arithmetic.
+
+*/
+
+scaled xn_over_d(scaled x, int n, int d)
+{
+    nonnegative_integer t, u, v, xx, dd;
+    boolean positive = true;
+    if (x < 0) {
+        negate(x);
+        positive = false;
+    }
+    xx = (nonnegative_integer) x;
+    dd = (nonnegative_integer) d;
+    t = ((xx % 0100000) * (nonnegative_integer) n);
+    u = ((xx / 0100000) * (nonnegative_integer) n + (t / 0100000));
+    v = (u % dd) * 0100000 + (t % 0100000);
+    if (u / dd >= 0100000)
+        arith_error = true;
+    else
+        u = 0100000 * (u / dd) + (v / dd);
+    if (positive) {
+        tex_remainder = (int) (v % dd);
+        return (scaled) u;
+    } else {
+        /*tex The casts are for ms cl. */
+        tex_remainder = -(int) (v % dd);
+        return -(scaled) (u);
+    }
+}
+
+/*tex
+
+The next subroutine is used to compute the ``badness'' of glue, when a total~|t|
+is supposed to be made from amounts that sum to~|s|. According to {\sl The \TeX
+book}, the badness of this situation is $100(t/s)^3$; however, badness is simply
+a heuristic, so we need not squeeze out the last drop of accuracy when computing
+it. All we really want is an approximation that has similar properties.
+@:TeXbook}{\sl The \TeX book@>
+
+The actual method used to compute the badness is easier to read from the program
+than to describe in words. It produces an integer value that is a reasonably
+close approximation to $100(t/s)^3$, and all implementations of \TeX\ should use
+precisely this method. Any badness of $2^{13}$ or more is treated as infinitely
+bad, and represented by 10000.
+
+It is not difficult to prove that $$\hbox{|badness(t+1,s)>=badness(t,s)
+>= badness(t,s+1)|}.$$ The badness function defined here is capable of computing
+at most 1095 distinct values, but that is plenty.
+
+*/
+
+halfword badness(scaled t, scaled s)
+{
+    /*tex Approximation to $\alpha t/s$, where $\alpha^3\approx 100\cdot2^{18}$ */
+    int r;
+    if (t == 0) {
+        return 0;
+    } else if (s <= 0) {
+        return inf_bad;
+    } else {
+        /*tex $297^3=99.94\times2^{18}$ */
+        if (t <= 7230584) {
+            r = (t * 297) / s;
+        } else if (s >= 1663497) {
+            r = t / (s / 297);
+        } else {
+            r = t;
+        }
+        if (r > 1290) {
+            /*tex $1290^3<2^{31}<1291^3$ */
+            return inf_bad;
+        } else {
+            /*tex This is $r^3/2^{18}$, rounded to the nearest integer. */
+            return ((r * r * r + 0400000) / 01000000);
+        }
+    }
+}
+
+/*tex
+
+When \TeX\ ``packages'' a list into a box, it needs to calculate the
+proportionality ratio by which the glue inside the box should stretch or shrink.
+This calculation does not affect \TeX's decision making, so the precise details
+of rounding, etc., in the glue calculation are not of critical importance for the
+consistency of results on different computers.
+
+We shall use the type |glue_ratio| for such proportionality ratios. A glue ratio
+should take the same amount of memory as an |integer| (usually 32 bits) if it is
+to blend smoothly with \TeX's other data structures. Thus |glue_ratio| should be
+equivalent to |short_real| in some implementations of PASCAL. Alternatively, it
+is possible to deal with glue ratios using nothing but fixed-point arithmetic;
+see {\sl TUGboat \bf3},1 (March 1982), 10--27. (But the routines cited there must
+be modified to allow negative glue ratios.) @^system dependencies@>
+
+*/
+
+/*
+
+This section is (almost) straight from MetaPost. I (Taco) had to change the types
+(use |integer| instead of |fraction|), but that should not have any influence on
+the actual calculations (the original comments refer to quantities like
+|fraction_four| ($2^{30}$), and that is the same as the numeric representation of
+|max_dimen|).
+
+I've copied the low-level variables and routines that are needed, but only those
+(e.g. |m_log|), not the accompanying ones like |m_exp|. Most of the following
+low-level numeric routines are only needed within the calculation of |norm_rand|.
+I've been forced to rename |make_fraction| to |make_frac| because TeX already has
+a routine by that name with a wholly different function (it creates a
+|fraction_noad| for math typesetting)
+
+And now let's complete our collection of numeric utility routines by considering
+random number generation. \MP{} generates pseudo-random numbers with the additive
+scheme recommended in Section 3.6 of {\sl The Art of Computer Programming};
+however, the results are random fractions between 0 and |fraction_one-1|,
+inclusive.
+
+There's an auxiliary array |randoms| that contains 55 pseudo-random fractions.
+Using the recurrence $x_n=(x_{n-55}-x_{n-31})\bmod 2^{28}$, we generate batches
+of 55 new $x_n$'s at a time by calling |new_randoms|. The global variable
+|j_random| tells which element has most recently been consumed.
+
+*/
+
+/*tex The last 55 random values generated: */
+
+static int randoms[55];
+
+/*tex The number of unused |randoms|: */
+
+static int j_random;
+
+/*tex The default random seed: */
+
+scaled random_seed;
+
+/*tex A small bit of \METAPOST\ is needed. */
+
+#define fraction_half  01000000000  /* $2^{27}  $, represents 0.50000000 */
+#define fraction_one   02000000000  /* $2^{28}  $, represents 1.00000000 */
+#define fraction_four 010000000000  /* $2^{30}  $, represents 4.00000000 */
+#define el_gordo      017777777777  /* $2^{31}-1$, the largest value that \MP\ likes */
+
+/*tex
+
+The |make_frac| routine produces the |fraction| equivalent of |p/q|, given
+integers |p| and~|q|; it computes the integer
+$f=\lfloor2^{28}p/q+{1\over2}\rfloor$, when $p$ and $q$ are positive. If |p| and
+|q| are both of the same scaled type |t|, the ``type relation''
+|make_frac(t,t)=fraction| is valid; and it's also possible to use the subroutine
+``backwards,'' using the relation |make_frac(t,fraction)=t| between scaled types.
+
+If the result would have magnitude $2^{31}$ or more, |make_frac| sets
+|arith_error:=true|. Most of \MP's internal computations have been designed to
+avoid this sort of error.
+
+If this subroutine were programmed in assembly language on a typical machine, we
+could simply compute |(@t$2^{28}$@>*p)div q|, since a double-precision product
+can often be input to a fixed-point division instruction. But when we are
+restricted to PASCAL arithmetic it is necessary either to resort to
+multiple-precision maneuvering or to use a simple but slow iteration. The
+multiple-precision technique would be about three times faster than the code
+adopted here, but it would be comparatively long and tricky, involving about
+sixteen additional multiplications and divisions.
+
+This operation is part of \MP's ``inner loop''; indeed, it will consume nearly
+10\%! of the running time (exclusive of input and output) if the code below is
+left unchanged. A machine-dependent recoding will therefore make \MP\ run faster.
+The present implementation is highly portable, but slow; it avoids multiplication
+and division except in the initial stage. System wizards should be careful to
+replace it with a routine that is guaranteed to produce identical results in all
+cases. @^system dependencies@>
+
+As noted below, a few more routines should also be replaced by machine-dependent
+code, for efficiency. But when a procedure is not part of the ``inner loop,''
+such changes aren't advisable; simplicity and robustness are preferable to
+trickery, unless the cost is too high.
+
+*/
+
+static int make_frac(int p, int q)
+{
+    /*tex The fraction bits, with a leading 1 bit: */
+    int f;
+    /*tex The integer part of $\vert p/q\vert$: */
+    int n;
+    /*tex Disables certain compiler optimizations: */
+    register int be_careful;
+    /*tex Should the result be negated? */
+    boolean negative = false;
+    if (p < 0) {
+        negate(p);
+        negative = true;
+    }
+    if (q <= 0) {
+        negate(q);
+        negative = !negative;
+    }
+    n = p / q;
+    p = p % q;
+    if (n >= 8) {
+        arith_error = true;
+        if (negative)
+            return (-el_gordo);
+        else
+            return el_gordo;
+    } else {
+        n = (n - 1) * fraction_one;
+        /*tex_remainder
+
+            Compute $f=\lfloor 2^{28}(1+p/q)+{1\over2}\rfloor$. The |repeat| loop
+            here preserves the following invariant relations between |f|, |p|,
+            and~|q|: (i)~|0<=p<q|; (ii)~$fq+p=2^k(q+p_0)$, where $k$ is an
+            integer and $p_0$ is the original value of~$p$.
+
+            Notice that the computation specifies |(p-q)+p| instead of |(p+p)-q|,
+            because the latter could overflow. Let us hope that optimizing
+            compilers do not miss this point; a special variable |be_careful| is
+            used to emphasize the necessary order of computation. Optimizing
+            compilers should keep |be_careful| in a register, not store it in
+            memory.
+
+        */
+        f = 1;
+        do {
+            be_careful = p - q;
+            p = be_careful + p;
+            if (p >= 0)
+                f = f + f + 1;
+            else {
+                f += f;
+                p = p + q;
+            }
+        } while (f < fraction_one);
+        be_careful = p - q;
+        if (be_careful + p >= 0)
+            incr(f);
+
+        if (negative)
+            return (-(f + n));
+        else
+            return (f + n);
+    }
+}
+
+static int take_frac(int q, int f)
+{
+    /*tex The fraction so far: */
+    int p;
+    /*tex Additional multiple of $q$: */
+    int n;
+    /*tex Disables certain compiler optimizations. */
+    register int be_careful;
+    /*tex Should the result be negated? */
+    boolean negative = false;
+    /*tex Reduce to the case that |f>=0| and |q>0|. */
+    if (f < 0) {
+        negate(f);
+        negative = true;
+    }
+    if (q < 0) {
+        negate(q);
+        negative = !negative;
+    }
+    if (f < fraction_one) {
+        n = 0;
+    } else {
+        n = f / fraction_one;
+        f = f % fraction_one;
+        if (q <= el_gordo / n) {
+            n = n * q;
+        } else {
+            arith_error = true;
+            n = el_gordo;
+        }
+    }
+    f = f + fraction_one;
+    /*tex
+
+        Compute $p=\lfloor qf/2^{28}+{1\over2}\rfloor-q$. The invariant relations
+        in this case are (i)~$\lfloor(qf+p)/2^k\rfloor =\lfloor
+        qf_0/2^{28}+{1\over2}\rfloor$, where $k$ is an integer and $f_0$ is the
+        original value of~$f$; (ii)~$2^k\L f<2^{k+1}$.
+
+        Here |p| becomes $2^{27}$; the invariants hold now with $k=28$:
+
+    */
+    p = fraction_half;
+    if (q < fraction_four) {
+        do {
+            if (odd(f))
+                p = halfp(p + q);
+            else
+                p = halfp(p);
+            f = halfp(f);
+        } while (f != 1);
+    } else {
+        do {
+            if (odd(f))
+                p = p + halfp(q - p);
+            else
+                p = halfp(p);
+            f = halfp(f);
+        } while (f != 1);
+    }
+    be_careful = n - el_gordo;
+    if (be_careful + p > 0) {
+        arith_error = true;
+        n = el_gordo - p;
+    }
+    if (negative)
+        return (-(n + p));
+    else
+        return (n + p);
+}
+
+/*tex
+
+The subroutines for logarithm and exponential involve two tables. The first is
+simple: |two_to_the[k]| equals $2^k$. The second involves a bit more calculation,
+which the author claims to have done correctly: |spec_log[k]| is $2^{27}$ times
+$\ln\bigl(1/(1-2^{-k})\bigr)= 2^{-k}+{1\over2}2^{-2k}+{1\over3}2^{-3k}+\cdots\,$,
+rounded to the nearest integer.
+
+*/
+
+/*tex The powers of two: */
+
+static int two_to_the[31];
+
+/*tex Special logarithms: */
+
+static int spec_log[29];
+
+void initialize_arithmetic(void)
+{
+    int k;
+    two_to_the[0] = 1;
+    for (k = 1; k <= 30; k++) {
+        two_to_the[k] = 2 * two_to_the[k - 1];
+    }
+    spec_log [1] = 93032640;
+    spec_log [2] = 38612034;
+    spec_log [3] = 17922280;
+    spec_log [4] =  8662214;
+    spec_log [5] =  4261238;
+    spec_log [6] =  2113709;
+    spec_log [7] =  1052693;
+    spec_log [8] =   525315;
+    spec_log [9] =   262400;
+    spec_log[10] =   131136;
+    spec_log[11] =    65552;
+    spec_log[12] =    32772;
+    spec_log[13] =    16385;
+    for (k = 14; k <= 27; k++) {
+        spec_log[k] = two_to_the[27 - k];
+    }
+    spec_log[28] = 1;
+}
+
+static int m_log(int x)
+{
+    /*tex Auxiliary registers: */
+    int y, z;
+    /*tex Iteration counter: */
+    int k;
+    if (x <= 0) {
+        /*tex Handle non-positive logarithm. */
+        print_err("Logarithm of ");
+        print_scaled(x);
+        tprint(" has been replaced by 0");
+        help2(
+            "Since I don't take logs of non-positive numbers,",
+            "I'm zeroing this one. Proceed, with fingers crossed."
+        );
+        error();
+        return 0;
+    } else {
+        /*tex $14\times2^{27}\ln2\approx1302456956.421063$ */
+        y = 1302456956 + 4 - 100;
+        /*tex $2^{16}\times .421063\approx 27595$ */
+        z = 27595 + 6553600;
+        while (x < fraction_four) {
+            x += x;
+            /*tex $2^{27}\ln2\approx 93032639.74436163$ */
+            y = y - 93032639;
+            /*tex $2^{16}\times.74436163\approx 48782$ */
+            z = z - 48782;
+        }
+
+        y = y + (z / unity);
+        k = 2;
+        while (x > fraction_four + 4) {
+            /*tex
+                Increase |k| until |x| can be multiplied by a factor of $2^{-k}$,
+                and adjust $y$ accordingly. Here $z=\lceil x/2^k\rceil$.
+            */
+            z = ((x - 1) / two_to_the[k]) + 1;
+            while (x < fraction_four + z) {
+                z = halfp(z + 1);
+                k = k + 1;
+            }
+            y = y + spec_log[k];
+            x = x - z;
+        }
+        return (y / 8);
+    }
+}
+
+/*tex
+
+The following somewhat different subroutine tests rigorously if $ab$ is greater
+than, equal to, or less than~$cd$, given integers $(a,b,c,d)$. In most cases a
+quick decision is reached. The result is $+1$, 0, or~$-1$ in the three respective
+cases.
+
+*/
+
+static int ab_vs_cd(int a, int b, int c, int d)
+{
+    int q, r;
+    /*tex Reduce to the case that |a,c>=0| and |b,d>0|. */
+    if (a < 0) {
+        negate(a);
+        negate(b);
+    }
+    if (c < 0) {
+        negate(c);
+        negate(d);
+    }
+    if (d <= 0) {
+        if (b >= 0)
+            return (((a == 0 || b == 0) && (c == 0 || d == 0)) ? 0 : 1);
+        if (d == 0)
+            return (a == 0 ? 0 : -1);
+        q = a;
+        a = c;
+        c = q;
+        q = -b;
+        b = -d;
+        d = q;
+    } else if (b <= 0) {
+        if (b < 0 && a > 0)
+            return -1;
+        return (c == 0 ? 0 : -1);
+    }
+    while (1) {
+        q = a / d;
+        r = c / b;
+        if (q != r)
+            return (q > r ? 1 : -1);
+        q = a % d;
+        r = c % b;
+        if (r == 0)
+            return (q == 0 ? 0 : 1);
+        if (q == 0)
+            return -1;
+        a = b;
+        b = q;
+        c = d;
+        d = r;
+        /*tex Now |a>d>0| and |c>b>0|. */
+    }
+}
+
+/*tex
+
+To consume a random integer, the program below will say `|next_random|' and then
+it will fetch |randoms[j_random]|.
+
+*/
+
+#define next_random() do { \
+    if (j_random==0) \
+        new_randoms(); \
+    else \
+        decr(j_random); \
+} while (0)
+
+static void new_randoms(void)
+{
+    /*tex The index into |randoms|. */
+    int k;
+    /*tex The accumulator. */
+    int x;
+    for (k = 0; k <= 23; k++) {
+        x = randoms[k] - randoms[k + 31];
+        if (x < 0)
+            x = x + fraction_one;
+        randoms[k] = x;
+    }
+    for (k = 24; k <= 54; k++) {
+        x = randoms[k] - randoms[k - 24];
+        if (x < 0)
+            x = x + fraction_one;
+        randoms[k] = x;
+    }
+    j_random = 54;
+}
+
+/*tex
+
+To initialize the |randoms| table, we call the following routine.
+
+*/
+
+void init_randoms(int seed)
+{
+    /*tex Three more or less random integers. */
+    int j, jj, k;
+    /*tex The index into |randoms|. */
+    int i;
+    j = abs(seed);
+    while (j >= fraction_one)
+        j = halfp(j);
+    k = 1;
+    for (i = 0; i <= 54; i++) {
+        jj = k;
+        k = j - k;
+        j = jj;
+        if (k < 0)
+            k = k + fraction_one;
+        randoms[(i * 21) % 55] = j;
+    }
+    /*tex We ``warm up'' the array. */
+    new_randoms();
+    new_randoms();
+    new_randoms();
+}
+
+/*tex
+
+To produce a uniform random number in the range |0<=u<x| or |0>=u>x| or |0=u=x|,
+given a |scaled| value~|x|, we proceed as shown here.
+
+Note that the call of |take_frac| will produce the values 0 and~|x| with about
+half the probability that it will produce any other particular values between 0
+and~|x|, because it rounds its answers.
+
+*/
+
+int unif_rand(int x)
+{
+    int y;
+    next_random();
+    y = take_frac(abs(x), randoms[j_random]);
+    if (y == abs(x))
+        return 0;
+    else if (x > 0)
+        return y;
+    else
+        return -y;
+}
+
+/*tex
+
+Finally, a normal deviate with mean zero and unit standard deviation can readily
+be obtained with the ratio method (Algorithm 3.4.1R in {\sl The Art of Computer
+Programming\/}.
+
+*/
+
+int norm_rand(void)
+{
+    /*tex What the book would call $2^{16}X$, $2^{28}U$, and $-2^{24}\ln U$. */
+    int x, u, l;
+    do {
+        do {
+            next_random();
+            x = take_frac(112429, randoms[j_random] - fraction_half);
+            /*tex Which is $2^{16}\sqrt{8/e}\approx 112428.82793$. */
+            next_random();
+            u = randoms[j_random];
+        } while (abs(x) >= u);
+        x = make_frac(x, u);
+        /*tex More fuzzyness: $2^{24}\cdot12\ln2\approx139548959.6165$. */
+        l = 139548960 - m_log(u);
+    } while (ab_vs_cd(1024, l, x, x) < 0);
+    return x;
+}
+
+/*tex
+
+This function could also be expressed as a macro, but it is a useful breakpoint
+for debugging.
+
+*/
+
+int fix_int(int val, int min, int max)
+{
+    return (val < min ? min : (val > max ? max : val));
+}
diff --git a/texk/web2c/luatexdir/tex/arithmetic.w b/texk/web2c/luatexdir/tex/arithmetic.w
deleted file mode 100644
index 56fb9568a..000000000
--- a/texk/web2c/luatexdir/tex/arithmetic.w
+++ /dev/null
@@ -1,735 +0,0 @@
-% arithmetic.w
-%
-% Copyright 2009-2010 Taco Hoekwater <taco@@luatex.org>
-%
-% This file is part of LuaTeX.
-%
-% LuaTeX is free software; you can redistribute it and/or modify it under
-% the terms of the GNU General Public License as published by the Free
-% Software Foundation; either version 2 of the License, or (at your
-% option) any later version.
-%
-% LuaTeX is distributed in the hope that it will be useful, but WITHOUT
-% ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-% FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
-% License for more details.
-%
-% You should have received a copy of the GNU General Public License along
-% with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
-
-\def\MP{MetaPost}
-
-@ @c
-
-
-#include "ptexlib.h"
-
-@ The principal computations performed by \TeX\ are done entirely in terms of
-integers less than $2^{31}$ in magnitude; and divisions are done only when both
-dividend and divisor are nonnegative. Thus, the arithmetic specified in this
-program can be carried out in exactly the same way on a wide variety of
-computers, including some small ones. Why? Because the arithmetic
-calculations need to be spelled out precisely in order to guarantee that
-\TeX\ will produce identical output on different machines. If some
-quantities were rounded differently in different implementations, we would
-find that line breaks and even page breaks might occur in different places.
-Hence the arithmetic of \TeX\ has been designed with care, and systems that
-claim to be implementations of \TeX82 should follow precisely the
-@:TeX82}{\TeX82@>
-calculations as they appear in the present program.
-
-(Actually there are three places where \TeX\ uses |div| with a possibly negative
-numerator. These are harmless; see |div| in the index. Also if the user
-sets the \.{\\time} or the \.{\\year} to a negative value, some diagnostic
-information will involve negative-numerator division. The same remarks
-apply for |mod| as well as for |div|.)
-
-Here is a routine that calculates half of an integer, using an
-unambiguous convention with respect to signed odd numbers.
-
-@c
-int half(int x)
-{
-    if (odd(x))
-        return ((x + 1) / 2);
-    else
-        return (x / 2);
-}
-
-
-@ The following function is used to create a scaled integer from a given decimal
-fraction $(.d_0d_1\ldots d_{k-1})$, where |0<=k<=17|. The digit $d_i$ is
-given in |dig[i]|, and the calculation produces a correctly rounded result.
-
-@c
-scaled round_decimals(int k)
-{                               /* converts a decimal fraction */
-    int a;                      /* the accumulator */
-    a = 0;
-    while (k-- > 0) {
-        a = (a + dig[k] * two) / 10;
-    }
-    return ((a + 1) / 2);
-}
-
-
-@ Conversely, here is a procedure analogous to |print_int|. If the output
-of this procedure is subsequently read by \TeX\ and converted by the
-|round_decimals| routine above, it turns out that the original value will
-be reproduced exactly; the ``simplest'' such decimal number is output,
-but there is always at least one digit following the decimal point.
-
-The invariant relation in the \&{repeat} loop is that a sequence of
-decimal digits yet to be printed will yield the original number if and only if
-they form a fraction~$f$ in the range $s-\delta\L10\cdot2^{16}f<s$.
-We can stop if and only if $f=0$ satisfies this condition; the loop will
-terminate before $s$ can possibly become zero.
-
-@c
-void print_scaled(scaled s)
-{                               /* prints scaled real, rounded to five digits */
-    scaled delta;               /* amount of allowable inaccuracy */
-    char buffer[20];
-    int i = 0;
-    if (s < 0) {
-        print_char('-');
-        negate(s);              /* print the sign, if negative */
-    }
-    print_int(s / unity);       /* print the integer part */
-    buffer[i++] = '.';
-    s = 10 * (s % unity) + 5;
-    delta = 10;
-    do {
-        if (delta > unity)
-            s = s + 0100000 - 50000;    /* round the last digit */
-        buffer[i++] = '0' + (s / unity);
-        s = 10 * (s % unity);
-        delta = delta * 10;
-    } while (s > delta);
-    buffer[i++] = '\0';
-    tprint(buffer);
-}
-
-@ Physical sizes that a \TeX\ user specifies for portions of documents are
-represented internally as scaled points. Thus, if we define an `sp' (scaled
-@^sp@>
-point) as a unit equal to $2^{-16}$ printer's points, every dimension
-inside of \TeX\ is an integer number of sp. There are exactly
-4,736,286.72 sp per inch.  Users are not allowed to specify dimensions
-larger than $2^{30}-1$ sp, which is a distance of about 18.892 feet (5.7583
-meters); two such quantities can be added without overflow on a 32-bit
-computer.
-
-The present implementation of \TeX\ does not check for overflow when
-@^overflow in arithmetic@>
-dimensions are added or subtracted. This could be done by inserting a
-few dozen tests of the form `\ignorespaces|if x>=010000000000 then
-@t\\{report\_overflow}@>|', but the chance of overflow is so remote that
-such tests do not seem worthwhile.
-
-\TeX\ needs to do only a few arithmetic operations on scaled quantities,
-other than addition and subtraction, and the following subroutines do most of
-the work. A single computation might use several subroutine calls, and it is
-desirable to avoid producing multiple error messages in case of arithmetic
-overflow; so the routines set the global variable |arith_error| to |true|
-instead of reporting errors directly to the user. Another global variable,
-|tex_remainder|, holds the remainder after a division.
-
-@c
-boolean arith_error;            /* has arithmetic overflow occurred recently? */
-scaled tex_remainder;           /* amount subtracted to get an exact division */
-
-
-@ The first arithmetical subroutine we need computes $nx+y$, where |x|
-and~|y| are |scaled| and |n| is an integer. We will also use it to
-multiply integers.
-
-@c
-scaled mult_and_add(int n, scaled x, scaled y, scaled max_answer)
-{
-    if (n == 0)
-        return y;
-    if (n < 0) {
-        negate(x);
-        negate(n);
-    }
-    if (((x <= (max_answer - y) / n) && (-x <= (max_answer + y) / n))) {
-        return (n * x + y);
-    } else {
-        arith_error = true;
-        return 0;
-    }
-}
-
-@ We also need to divide scaled dimensions by integers. 
-@c
-scaled x_over_n(scaled x, int n)
-{
-    boolean negative;           /* should |tex_remainder| be negated? */
-    negative = false;
-    if (n == 0) {
-        arith_error = true;
-        tex_remainder = x;
-        return 0;
-    } else {
-        if (n < 0) {
-            negate(x);
-            negate(n);
-            negative = true;
-        }
-        if (x >= 0) {
-            tex_remainder = x % n;
-            if (negative)
-                negate(tex_remainder);
-            return (x / n);
-        } else {
-            tex_remainder = -((-x) % n);
-            if (negative)
-                negate(tex_remainder);
-            return (-((-x) / n));
-        }
-    }
-}
-
-
-@ Then comes the multiplication of a scaled number by a fraction |n/d|,
-where |n| and |d| are nonnegative integers |<=@t$2^{16}$@>| and |d| is
-positive. It would be too dangerous to multiply by~|n| and then divide
-by~|d|, in separate operations, since overflow might well occur; and it
-would be too inaccurate to divide by |d| and then multiply by |n|. Hence
-this subroutine simulates 1.5-precision arithmetic.
-
-@c
-scaled xn_over_d(scaled x, int n, int d)
-{
-    nonnegative_integer t, u, v, xx, dd;        /* intermediate quantities */
-    boolean positive = true;    /* was |x>=0|? */
-    if (x < 0) {
-        negate(x);
-        positive = false;
-    }
-    xx = (nonnegative_integer) x;
-    dd = (nonnegative_integer) d;
-    t = ((xx % 0100000) * (nonnegative_integer) n);
-    u = ((xx / 0100000) * (nonnegative_integer) n + (t / 0100000));
-    v = (u % dd) * 0100000 + (t % 0100000);
-    if (u / dd >= 0100000)
-        arith_error = true;
-    else
-        u = 0100000 * (u / dd) + (v / dd);
-    if (positive) {
-        tex_remainder = (int) (v % dd);
-        return (scaled) u;
-    } else {
-        /* casts are for ms cl */
-        tex_remainder = -(int) (v % dd);
-        return -(scaled) (u);
-    }
-}
-
-
-@ The next subroutine is used to compute the ``badness'' of glue, when a
-total~|t| is supposed to be made from amounts that sum to~|s|.  According
-to {\sl The \TeX book}, the badness of this situation is $100(t/s)^3$;
-however, badness is simply a heuristic, so we need not squeeze out the
-last drop of accuracy when computing it. All we really want is an
-approximation that has similar properties.
-@:TeXbook}{\sl The \TeX book@>
-
-The actual method used to compute the badness is easier to read from the
-program than to describe in words. It produces an integer value that is a
-reasonably close approximation to $100(t/s)^3$, and all implementations
-of \TeX\ should use precisely this method. Any badness of $2^{13}$ or more is
-treated as infinitely bad, and represented by 10000.
-
-It is not difficult to prove that $$\hbox{|badness(t+1,s)>=badness(t,s)
->=badness(t,s+1)|}.$$ The badness function defined here is capable of
-computing at most 1095 distinct values, but that is plenty.
-
-@c
-halfword badness(scaled t, scaled s)
-{                               /* compute badness, given |t>=0| */
-    int r;                      /* approximation to $\alpha t/s$, where $\alpha^3\approx
-                                   100\cdot2^{18}$ */
-    if (t == 0) {
-        return 0;
-    } else if (s <= 0) {
-        return inf_bad;
-    } else {
-        if (t <= 7230584)
-            r = (t * 297) / s;  /* $297^3=99.94\times2^{18}$ */
-        else if (s >= 1663497)
-            r = t / (s / 297);
-        else
-            r = t;
-        if (r > 1290)
-            return inf_bad;     /* $1290^3<2^{31}<1291^3$ */
-        else
-            return ((r * r * r + 0400000) / 01000000);
-        /* that was $r^3/2^{18}$, rounded to the nearest integer */
-    }
-}
-
-
-@ When \TeX\ ``packages'' a list into a box, it needs to calculate the
-proportionality ratio by which the glue inside the box should stretch
-or shrink. This calculation does not affect \TeX's decision making,
-so the precise details of rounding, etc., in the glue calculation are not
-of critical importance for the consistency of results on different computers.
-
-We shall use the type |glue_ratio| for such proportionality ratios.
-A glue ratio should take the same amount of memory as an
-|integer| (usually 32 bits) if it is to blend smoothly with \TeX's
-other data structures. Thus |glue_ratio| should be equivalent to
-|short_real| in some implementations of PASCAL. Alternatively,
-it is possible to deal with glue ratios using nothing but fixed-point
-arithmetic; see {\sl TUGboat \bf3},1 (March 1982), 10--27. (But the
-routines cited there must be modified to allow negative glue ratios.)
-@^system dependencies@>
-
-
-@ This section is (almost) straight from MetaPost. I had to change
-the types (use |integer| instead of |fraction|), but that should
-not have any influence on the actual calculations (the original
-comments refer to quantities like |fraction_four| ($2^{30}$), and
-that is the same as the numeric representation of |max_dimen|).
-
-I've copied the low-level variables and routines that are needed, but
-only those (e.g. |m_log|), not the accompanying ones like |m_exp|. Most
-of the following low-level numeric routines are only needed within the
-calculation of |norm_rand|. I've been forced to rename |make_fraction|
-to |make_frac| because TeX already has a routine by that name with
-a wholly different function (it creates a |fraction_noad| for math
-typesetting) -- Taco
-
-And now let's complete our collection of numeric utility routines
-by considering random number generation.
-\MP{} generates pseudo-random numbers with the additive scheme recommended
-in Section 3.6 of {\sl The Art of Computer Programming}; however, the
-results are random fractions between 0 and |fraction_one-1|, inclusive.
-
-There's an auxiliary array |randoms| that contains 55 pseudo-random
-fractions. Using the recurrence $x_n=(x_{n-55}-x_{n-31})\bmod 2^{28}$,
-we generate batches of 55 new $x_n$'s at a time by calling |new_randoms|.
-The global variable |j_random| tells which element has most recently
-been consumed.
-
-@c
-static int randoms[55];         /* the last 55 random values generated */
-static int j_random;            /* the number of unused |randoms| */
-scaled random_seed;             /* the default random seed */
-
-@ A small bit of metafont is needed. 
-
-@c
-#define fraction_half 01000000000       /* $2^{27}$, represents 0.50000000 */
-#define fraction_one 02000000000        /* $2^{28}$, represents 1.00000000 */
-#define fraction_four 010000000000      /* $2^{30}$, represents 4.00000000 */
-#define el_gordo 017777777777   /* $2^{31}-1$, the largest value that \MP\ likes */
-
-@ The |make_frac| routine produces the |fraction| equivalent of
-|p/q|, given integers |p| and~|q|; it computes the integer
-$f=\lfloor2^{28}p/q+{1\over2}\rfloor$, when $p$ and $q$ are
-positive. If |p| and |q| are both of the same scaled type |t|,
-the ``type relation'' |make_frac(t,t)=fraction| is valid;
-and it's also possible to use the subroutine ``backwards,'' using
-the relation |make_frac(t,fraction)=t| between scaled types.
-
-If the result would have magnitude $2^{31}$ or more, |make_frac|
-sets |arith_error:=true|. Most of \MP's internal computations have
-been designed to avoid this sort of error.
-
-If this subroutine were programmed in assembly language on a typical
-machine, we could simply compute |(@t$2^{28}$@>*p)div q|, since a
-double-precision product can often be input to a fixed-point division
-instruction. But when we are restricted to PASCAL arithmetic it
-is necessary either to resort to multiple-precision maneuvering
-or to use a simple but slow iteration. The multiple-precision technique
-would be about three times faster than the code adopted here, but it
-would be comparatively long and tricky, involving about sixteen
-additional multiplications and divisions.
-
-This operation is part of \MP's ``inner loop''; indeed, it will
-consume nearly 10\%! of the running time (exclusive of input and output)
-if the code below is left unchanged. A machine-dependent recoding
-will therefore make \MP\ run faster. The present implementation
-is highly portable, but slow; it avoids multiplication and division
-except in the initial stage. System wizards should be careful to
-replace it with a routine that is guaranteed to produce identical
-results in all cases.
-@^system dependencies@>
-
-As noted below, a few more routines should also be replaced by machine-dependent
-code, for efficiency. But when a procedure is not part of the ``inner loop,''
-such changes aren't advisable; simplicity and robustness are
-preferable to trickery, unless the cost is too high.
-
-@c
-static int make_frac(int p, int q)
-{
-    int f;                      /* the fraction bits, with a leading 1 bit */
-    int n;                      /* the integer part of $\vert p/q\vert$ */
-    register int be_careful;    /* disables certain compiler optimizations */
-    boolean negative = false;   /* should the result be negated? */
-    if (p < 0) {
-        negate(p);
-        negative = true;
-    }
-    if (q <= 0) {
-#ifdef DEBUG
-        if (q == 0)
-            confusion("/");
-#endif
-        negate(q);
-        negative = !negative;
-    }
-    n = p / q;
-    p = p % q;
-    if (n >= 8) {
-        arith_error = true;
-        if (negative)
-            return (-el_gordo);
-        else
-            return el_gordo;
-    } else {
-        n = (n - 1) * fraction_one;
-        /* Compute $f=\lfloor 2^{28}(1+p/q)+{1\over2}\rfloor$ */
-        /* The |repeat| loop here preserves the following invariant relations
-           between |f|, |p|, and~|q|:
-           (i)~|0<=p<q|; (ii)~$fq+p=2^k(q+p_0)$, where $k$ is an integer and
-           $p_0$ is the original value of~$p$.
-
-           Notice that the computation specifies
-           |(p-q)+p| instead of |(p+p)-q|, because the latter could overflow.
-           Let us hope that optimizing compilers do not miss this point; a
-           special variable |be_careful| is used to emphasize the necessary
-           order of computation. Optimizing compilers should keep |be_careful|
-           in a register, not store it in memory.
-         */
-        f = 1;
-        do {
-            be_careful = p - q;
-            p = be_careful + p;
-            if (p >= 0)
-                f = f + f + 1;
-            else {
-                f += f;
-                p = p + q;
-            }
-        } while (f < fraction_one);
-        be_careful = p - q;
-        if (be_careful + p >= 0)
-            incr(f);
-
-        if (negative)
-            return (-(f + n));
-        else
-            return (f + n);
-    }
-}
-
-@ @c
-static int take_frac(int q, int f)
-{
-    int p;                      /* the fraction so far */
-    int n;                      /* additional multiple of $q$ */
-    register int be_careful;    /* disables certain compiler optimizations */
-    boolean negative = false;   /* should the result be negated? */
-    /* Reduce to the case that |f>=0| and |q>0| */
-    if (f < 0) {
-        negate(f);
-        negative = true;
-    }
-    if (q < 0) {
-        negate(q);
-        negative = !negative;
-    }
-
-    if (f < fraction_one) {
-        n = 0;
-    } else {
-        n = f / fraction_one;
-        f = f % fraction_one;
-        if (q <= el_gordo / n) {
-            n = n * q;
-        } else {
-            arith_error = true;
-            n = el_gordo;
-        }
-    }
-    f = f + fraction_one;
-    /* Compute $p=\lfloor qf/2^{28}+{1\over2}\rfloor-q$ */
-    /* The invariant relations in this case are (i)~$\lfloor(qf+p)/2^k\rfloor
-       =\lfloor qf_0/2^{28}+{1\over2}\rfloor$, where $k$ is an integer and
-       $f_0$ is the original value of~$f$; (ii)~$2^k\L f<2^{k+1}$. 
-     */
-    p = fraction_half;          /* that's $2^{27}$; the invariants hold now with $k=28$ */
-    if (q < fraction_four) {
-        do {
-            if (odd(f))
-                p = halfp(p + q);
-            else
-                p = halfp(p);
-            f = halfp(f);
-        } while (f != 1);
-    } else {
-        do {
-            if (odd(f))
-                p = p + halfp(q - p);
-            else
-                p = halfp(p);
-            f = halfp(f);
-        } while (f != 1);
-    }
-
-    be_careful = n - el_gordo;
-    if (be_careful + p > 0) {
-        arith_error = true;
-        n = el_gordo - p;
-    }
-    if (negative)
-        return (-(n + p));
-    else
-        return (n + p);
-}
-
-
-
-@ The subroutines for logarithm and exponential involve two tables.
-The first is simple: |two_to_the[k]| equals $2^k$. The second involves
-a bit more calculation, which the author claims to have done correctly:
-|spec_log[k]| is $2^{27}$ times $\ln\bigl(1/(1-2^{-k})\bigr)=
-2^{-k}+{1\over2}2^{-2k}+{1\over3}2^{-3k}+\cdots\,$, rounded to the
-nearest integer.
-
-@c
-static int two_to_the[31];      /* powers of two */
-static int spec_log[29];        /* special logarithms */
-
-@ @c
-void initialize_arithmetic(void)
-{
-    int k;
-    two_to_the[0] = 1;
-    for (k = 1; k <= 30; k++)
-        two_to_the[k] = 2 * two_to_the[k - 1];
-    spec_log[1] = 93032640;
-    spec_log[2] = 38612034;
-    spec_log[3] = 17922280;
-    spec_log[4] = 8662214;
-    spec_log[5] = 4261238;
-    spec_log[6] = 2113709;
-    spec_log[7] = 1052693;
-    spec_log[8] = 525315;
-    spec_log[9] = 262400;
-    spec_log[10] = 131136;
-    spec_log[11] = 65552;
-    spec_log[12] = 32772;
-    spec_log[13] = 16385;
-    for (k = 14; k <= 27; k++)
-        spec_log[k] = two_to_the[27 - k];
-    spec_log[28] = 1;
-}
-
-@ @c
-static int m_log(int x)
-{
-    int y, z;                   /* auxiliary registers */
-    int k;                      /* iteration counter */
-    if (x <= 0) {
-        /* Handle non-positive logarithm */
-        print_err("Logarithm of ");
-        print_scaled(x);
-        tprint(" has been replaced by 0");
-        help2("Since I don't take logs of non-positive numbers,",
-              "I'm zeroing this one. Proceed, with fingers crossed.");
-        error();
-        return 0;
-    } else {
-        y = 1302456956 + 4 - 100;       /* $14\times2^{27}\ln2\approx1302456956.421063$ */
-        z = 27595 + 6553600;    /* and $2^{16}\times .421063\approx 27595$ */
-        while (x < fraction_four) {
-            x += x;
-            y = y - 93032639;
-            z = z - 48782;
-        }                       /* $2^{27}\ln2\approx 93032639.74436163$
-                                   and $2^{16}\times.74436163\approx 48782$ */
-        y = y + (z / unity);
-        k = 2;
-        while (x > fraction_four + 4) {
-            /* Increase |k| until |x| can be multiplied by a
-               factor of $2^{-k}$, and adjust $y$ accordingly */
-            z = ((x - 1) / two_to_the[k]) + 1;  /* $z=\lceil x/2^k\rceil$ */
-            while (x < fraction_four + z) {
-                z = halfp(z + 1);
-                k = k + 1;
-            }
-            y = y + spec_log[k];
-            x = x - z;
-        }
-        return (y / 8);
-    }
-}
-
-
-
-@ The following somewhat different subroutine tests rigorously if $ab$ is
-greater than, equal to, or less than~$cd$,
-given integers $(a,b,c,d)$. In most cases a quick decision is reached.
-The result is $+1$, 0, or~$-1$ in the three respective cases.
-
-@c
-static int ab_vs_cd(int a, int b, int c, int d)
-{
-    int q, r;                   /* temporary registers */
-    /* Reduce to the case that |a,c>=0|, |b,d>0| */
-    if (a < 0) {
-        negate(a);
-        negate(b);
-    }
-    if (c < 0) {
-        negate(c);
-        negate(d);
-    }
-    if (d <= 0) {
-        if (b >= 0)
-            return (((a == 0 || b == 0) && (c == 0 || d == 0)) ? 0 : 1);
-        if (d == 0)
-            return (a == 0 ? 0 : -1);
-        q = a;
-        a = c;
-        c = q;
-        q = -b;
-        b = -d;
-        d = q;
-    } else if (b <= 0) {
-        if (b < 0 && a > 0)
-            return -1;
-        return (c == 0 ? 0 : -1);
-    }
-
-    while (1) {
-        q = a / d;
-        r = c / b;
-        if (q != r)
-            return (q > r ? 1 : -1);
-        q = a % d;
-        r = c % b;
-        if (r == 0)
-            return (q == 0 ? 0 : 1);
-        if (q == 0)
-            return -1;
-        a = b;
-        b = q;
-        c = d;
-        d = r;                  /* now |a>d>0| and |c>b>0| */
-    }
-}
-
-
-
-@ To consume a random integer, the program below will say `|next_random|'
-and then it will fetch |randoms[j_random]|.
-
-@c
-#define next_random() do {					\
-	if (j_random==0) new_randoms(); else decr(j_random);	\
-    } while (0)
-
-static void new_randoms(void)
-{
-    int k;                      /* index into |randoms| */
-    int x;                      /* accumulator */
-    for (k = 0; k <= 23; k++) {
-        x = randoms[k] - randoms[k + 31];
-        if (x < 0)
-            x = x + fraction_one;
-        randoms[k] = x;
-    }
-    for (k = 24; k <= 54; k++) {
-        x = randoms[k] - randoms[k - 24];
-        if (x < 0)
-            x = x + fraction_one;
-        randoms[k] = x;
-    }
-    j_random = 54;
-}
-
-
-@ To initialize the |randoms| table, we call the following routine. 
-
-@c
-void init_randoms(int seed)
-{
-    int j, jj, k;               /* more or less random integers */
-    int i;                      /* index into |randoms| */
-    j = abs(seed);
-    while (j >= fraction_one)
-        j = halfp(j);
-    k = 1;
-    for (i = 0; i <= 54; i++) {
-        jj = k;
-        k = j - k;
-        j = jj;
-        if (k < 0)
-            k = k + fraction_one;
-        randoms[(i * 21) % 55] = j;
-    }
-    new_randoms();
-    new_randoms();
-    new_randoms();              /* ``warm up'' the array */
-}
-
-
-@ To produce a uniform random number in the range |0<=u<x| or |0>=u>x|
-or |0=u=x|, given a |scaled| value~|x|, we proceed as shown here.
-
-Note that the call of |take_frac| will produce the values 0 and~|x|
-with about half the probability that it will produce any other particular
-values between 0 and~|x|, because it rounds its answers.
-
-@c
-int unif_rand(int x)
-{
-    int y;                      /* trial value */
-    next_random();
-    y = take_frac(abs(x), randoms[j_random]);
-    if (y == abs(x))
-        return 0;
-    else if (x > 0)
-        return y;
-    else
-        return -y;
-}
-
-
-@ Finally, a normal deviate with mean zero and unit standard deviation
-can readily be obtained with the ratio method (Algorithm 3.4.1R in
-{\sl The Art of Computer Programming\/}).
-
-@c
-int norm_rand(void)
-{
-    int x, u, l;                /* what the book would call $2^{16}X$, $2^{28}U$, and $-2^{24}\ln U$ */
-    do {
-        do {
-            next_random();
-            x = take_frac(112429, randoms[j_random] - fraction_half);
-            /* $2^{16}\sqrt{8/e}\approx 112428.82793$ */
-            next_random();
-            u = randoms[j_random];
-        } while (abs(x) >= u);
-        x = make_frac(x, u);
-        l = 139548960 - m_log(u);       /* $2^{24}\cdot12\ln2\approx139548959.6165$ */
-    } while (ab_vs_cd(1024, l, x, x) < 0);
-    return x;
-}
-
-@ This function could also be expressed as a macro, but it is a useful
-   breakpoint for debugging.
-
-@c
-int fix_int(int val, int min, int max)
-{
-    return (val < min ? min : (val > max ? max : val));
-}
diff --git a/texk/web2c/luatexdir/tex/backend.c b/texk/web2c/luatexdir/tex/backend.c
new file mode 100644
index 000000000..d8c7daed2
--- /dev/null
+++ b/texk/web2c/luatexdir/tex/backend.c
@@ -0,0 +1,123 @@
+/* to fill */
+
+#include "ptexlib.h"
+
+scaled max_v = 0;               /* maximum height-plus-depth of pages shipped so far */
+scaled max_h = 0;               /* maximum width of pages shipped so far */
+boolean doing_leaders = false;  /* are we inside a leader box? */
+int cur_s = -1;                 /* current depth of output box nesting, initially $-1$ */
+
+static backend_struct *backend = NULL;
+backend_function *backend_out, *backend_out_whatsit, *backend_out_control;
+
+static void missing_backend_function(PDF pdf, halfword p)
+{
+    const char *n = get_node_name(type(p), subtype(p));
+    if (type(p) == whatsit_node)
+        formatted_error("pdf backend","no output function for whatsit %s",n);
+    else
+        formatted_error("pdf backend","no output function for node %s",n);
+}
+
+static void init_none_backend_functions(void)
+{
+    backend_struct *p = &backend[OMODE_NONE];
+    p->name = strdup("NONE");
+}
+
+static void init_pdf_backend_functions(void)
+{
+    backend_struct *p = &backend[OMODE_PDF];
+    p->name = strdup("PDF");
+    p->node_fu[rule_node] = &pdf_place_rule;
+    p->node_fu[glyph_node] = &pdf_place_glyph;
+    p->whatsit_fu[special_node] = &pdf_special;
+    p->whatsit_fu[pdf_literal_node] = &pdf_out_literal;
+    p->whatsit_fu[pdf_refobj_node] = &pdf_ref_obj;
+    p->whatsit_fu[pdf_annot_node] = &do_annot;
+    p->whatsit_fu[pdf_start_link_node] = &do_link;
+    p->whatsit_fu[pdf_end_link_node] = &end_link;
+    p->whatsit_fu[pdf_dest_node] = &do_dest;
+    p->whatsit_fu[pdf_thread_node] = &do_thread;
+    p->whatsit_fu[pdf_end_thread_node] = &end_thread;
+    p->whatsit_fu[late_lua_node] = &late_lua;
+    p->whatsit_fu[pdf_colorstack_node] = &pdf_out_colorstack;
+    p->whatsit_fu[pdf_setmatrix_node] = &pdf_out_setmatrix;
+    p->whatsit_fu[pdf_save_node] = &pdf_out_save;
+    p->whatsit_fu[pdf_restore_node] = &pdf_out_restore;
+    p->control_fu[backend_control_push_list] = &pdf_push_list;
+    p->control_fu[backend_control_pop_list] = &pdf_pop_list;
+    p->control_fu[backend_control_begin_page] = &pdf_begin_page;
+    p->control_fu[backend_control_end_page] = &pdf_end_page;
+    p->control_fu[backend_control_open_file] = &pdf_open_file;
+    p->control_fu[backend_control_write_header] = &pdf_write_header;
+    p->control_fu[backend_control_finish_file] = &pdf_finish_file;
+    p->control_fu[backend_control_set_reference_point] = &pdf_set_reference_point;
+}
+
+static void init_dvi_backend_functions(void)
+{
+    backend_struct *p = &backend[OMODE_DVI];
+    p->name = strdup("DVI");
+    p->node_fu[rule_node] = &dvi_place_rule;
+    p->node_fu[glyph_node] = &dvi_place_glyph;
+    p->whatsit_fu[special_node] = &dvi_special;
+    p->whatsit_fu[late_lua_node] = &late_lua;
+    p->control_fu[backend_control_push_list] = &dvi_push_list;
+    p->control_fu[backend_control_pop_list] = &dvi_pop_list;
+    p->control_fu[backend_control_begin_page] = &dvi_begin_page;
+    p->control_fu[backend_control_end_page] = &dvi_end_page;
+    p->control_fu[backend_control_open_file] = &dvi_open_file;
+    p->control_fu[backend_control_write_header] = &dvi_write_header;
+    p->control_fu[backend_control_finish_file] = &dvi_finish_file;
+    p->control_fu[backend_control_set_reference_point] = &dvi_set_reference_point;
+}
+
+
+void init_backend_functionpointers(output_mode o_mode)
+{
+    int i, j;
+    if (backend == NULL) {
+        backend = xmalloc((MAX_OMODE + 1) * sizeof(backend_struct));
+        for (i = 0; i <= MAX_OMODE; i++) {
+            backend[i].node_fu = xmalloc((MAX_NODE_TYPE + 1) * sizeof(backend_function));
+            backend[i].whatsit_fu = xmalloc((MAX_WHATSIT_TYPE + 1) * sizeof(backend_function));
+            backend[i].control_fu = xmalloc((MAX_CONTROL_TYPE + 1) * sizeof(backend_function));
+            for (j = 0; j < MAX_NODE_TYPE + 1; j++)
+                backend[i].node_fu[j] = &missing_backend_function;
+            for (j = 0; j < MAX_WHATSIT_TYPE + 1; j++)
+                backend[i].whatsit_fu[j] = &missing_backend_function;
+            for (j = 0; j < MAX_CONTROL_TYPE + 1; j++)
+                backend[i].control_fu[j] = &missing_backend_function;
+        }
+        init_none_backend_functions();
+        init_dvi_backend_functions();
+        init_pdf_backend_functions();
+    }
+    backend_out = backend[o_mode].node_fu;
+    backend_out_whatsit = backend[o_mode].whatsit_fu;
+    backend_out_control = backend[o_mode].control_fu;
+}
+
+output_mode get_o_mode(void)
+{
+    output_mode o_mode;
+    if (output_mode_par > 0) {
+        o_mode = OMODE_PDF;
+    } else
+        o_mode = OMODE_DVI;
+    return o_mode;
+}
+
+void fix_o_mode(void)
+{
+    output_mode o_mode = get_o_mode();
+    if (output_mode_used == OMODE_NONE) {
+        output_mode_used = o_mode;
+        /*tex Used by synctex, we need to use output_mode_used there: */
+        static_pdf->o_mode = output_mode_used;
+    } else if (output_mode_used != o_mode) {
+        normal_error("pdf backend", "\\outputmode can only be changed before anything is written to the output");
+    }
+    init_backend_functionpointers(output_mode_used);
+}
diff --git a/texk/web2c/luatexdir/tex/backend.h b/texk/web2c/luatexdir/tex/backend.h
new file mode 100644
index 000000000..5cfbd06fb
--- /dev/null
+++ b/texk/web2c/luatexdir/tex/backend.h
@@ -0,0 +1,54 @@
+/* to fill */
+
+#ifndef BACKEND_H
+#  define BACKEND_H
+
+#include "ptexlib.h"
+
+extern scaled max_v;
+extern scaled max_h;
+extern boolean doing_leaders;
+extern int cur_s;
+
+# define MAX_CONTROL_TYPE 7
+
+typedef enum {
+    backend_control_push_list = 0,
+    backend_control_pop_list,
+    backend_control_begin_page,
+    backend_control_end_page,
+    backend_control_open_file,
+    backend_control_write_header,
+    backend_control_finish_file,
+    backend_control_set_reference_point
+} backend_control_types ;
+
+typedef void (*backend_function) (); /* variadic arguments  */
+
+typedef struct {
+    char *name;                    /* name of the backend */
+    backend_function *node_fu;     /* array of node output functions */
+    backend_function *whatsit_fu;  /* array of whatsit output functions */
+    backend_function *control_fu;  /* array of whatsit output functions */
+} backend_struct;
+
+/* extern pos_info_structure pos_info; */
+
+extern backend_function *backend_out;
+extern backend_function *backend_out_whatsit;
+extern backend_function *backend_out_control;
+
+/* get_o_mode translates from output_mode to output_mode_used */
+/* fix_o_mode freezes output_mode as soon as anything goes through the backend */
+
+/*
+    extern void check_o_mode(PDF pdf, const char *s, int o_mode, boolean errorflag);
+    extern void ensure_output_file_open(PDF pdf, const char *ext);
+*/
+
+extern void fix_o_mode(void);
+extern output_mode get_o_mode(void);
+
+extern void init_backend_functionpointers(output_mode o_mode);
+
+#endif
diff --git a/texk/web2c/luatexdir/tex/buildpage.c b/texk/web2c/luatexdir/tex/buildpage.c
new file mode 100644
index 000000000..81e69dc3b
--- /dev/null
+++ b/texk/web2c/luatexdir/tex/buildpage.c
@@ -0,0 +1,1164 @@
+/*
+
+Copyright 2009-2010 Taco Hoekwater <taco@luatex.org>
+
+This file is part of LuaTeX.
+
+LuaTeX is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 2 of the License, or (at your
+option) any later version.
+
+LuaTeX is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+License for more details.
+
+You should have received a copy of the GNU General Public License along
+with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#include "ptexlib.h"
+
+
+#define mode mode_par
+#define head head_par
+#define tail tail_par
+
+/*tex
+
+    When \TeX\ appends new material to its main vlist in vertical mode, it uses a
+    method something like |vsplit| to decide where a page ends, except that the
+    calculations are done ``on line'' as new items come in. The main complication
+    in this process is that insertions must be put into their boxes and removed
+    from the vlist, in a more-or-less optimum manner.
+
+    We shall use the term ``current page'' for that part of the main vlist that
+    is being considered as a candidate for being broken off and sent to the
+    user's output routine. The current page starts at |vlink(page_head)|, and it
+    ends at |page_tail|. We have |page_head=page_tail| if this list is empty.
+
+    Utter chaos would reign if the user kept changing page specifications while a
+    page is being constructed, so the page builder keeps the pertinent
+    specifications frozen as soon as the page receives its first box or
+    insertion. The global variable |page_contents| is |empty| when the current
+    page contains only mark nodes and content-less whatsit nodes; it is
+    |inserts_only| if the page contains only insertion nodes in addition to marks
+    and whatsits. Glue nodes, kern nodes, and penalty nodes are discarded until a
+    box or rule node appears, at which time |page_contents| changes to
+    |box_there|. As soon as |page_contents| becomes non-|empty|, the current
+    |vsize| and |max_depth| are squirreled away into |page_goal| and
+    |page_max_depth|; the latter values will be used until the page has been
+    forwarded to the user's output routine. The \.{\\topskip} adjustment is made
+    when |page_contents| changes to |box_there|.
+
+    Although |page_goal| starts out equal to |vsize|, it is decreased by the
+    scaled natural height-plus-depth of the insertions considered so far, and by
+    the \.{\\skip} corrections for those insertions. Therefore it represents the
+    size into which the non-inserted material should fit, assuming that all
+    insertions in the current page have been made.
+
+    The global variables |best_page_break| and |least_page_cost| correspond
+    respectively to the local variables |best_place| and |least_cost| in the
+    |vert_break| routine that we have already studied; i.e., they record the
+    location and value of the best place currently known for breaking the current
+    page. The value of |page_goal| at the time of the best break is stored in
+    |best_size|.
+
+*/
+
+/*tex the final node on the current page */
+
+halfword page_tail;
+
+/*tex what is on the current page so far? */
+
+int page_contents;
+
+/*tex maximum box depth on page being built */
+
+scaled page_max_depth;
+
+/*tex break here to get the best page known so far */
+
+halfword best_page_break;
+
+/*tex the score for this currently best page */
+
+int least_page_cost;
+
+/*tex its |page_goal| */
+
+scaled best_size;
+
+/*tex
+
+    The page builder has another data structure to keep track of insertions. This
+    is a list of four-word nodes, starting and ending at |page_ins_head|. That
+    is, the first element of the list is node |t$_1$=vlink(page_ins_head)|;
+    node $r_j$ is followed by |t$_{j+1}$=vlink(t$_j$)|; and if there are
+    |n| items we have |$_{n+1}$>=page_ins_head|. The |subtype| field of each
+    node in this list refers to an insertion number; for example, `\.{\\insert
+    250}' would correspond to a node whose |subtype| is |qi(250)| (the same as
+    the |subtype| field of the relevant |ins_node|). These |subtype| fields are
+    in increasing order, and |subtype(page_ins_head)=65535|, so |page_ins_head|
+    serves as a convenient sentinel at the end of the list. A record is present
+    for each insertion number that appears in the current page.
+
+    The |type| field in these nodes distinguishes two possibilities that might
+    occur as we look ahead before deciding on the optimum page break. If
+    |type(r)=inserting_node|, then |height(r)| contains the total of the
+    height-plus-depth dimensions of the box and all its inserts seen so far.
+    |type(r)=split_up_node|, then no more insertions will be made into this box,
+    because at least one previous insertion was too big to fit on the current
+    page; |broken_ptr(r)| points to the node where that insertion will be split,
+    if \TeX\ decides to split it, |broken_ins(r)| points to the insertion node
+    that was tentatively split, and |height(r)| includes also the natural height
+    plus depth of the part that would be split off.
+
+    In both cases, |last_ins_ptr(r)| points to the last |ins_node| encountered
+    for box |qo(subtype(r))| that would be at least partially inserted on the
+    next page; and |best_ins_ptr(r)| points to the last such |ins_node| that
+    should actually be inserted, to get the page with minimum badness among all
+    page breaks considered so far. We have |best_ins_ptr(r)=null| if and only if
+    no insertion for this box should be made to produce this optimum page.
+
+    Pages are built by appending nodes to the current list in \TeX's vertical
+    mode, which is at the outermost level of the semantic nest. This vlist is
+    split into two parts; the ``current page'' that we have been talking so much
+    about already, and the ``contribution list'' that receives new nodes as they
+    are created. The current page contains everything that the page builder has
+    accounted for in its data structures, as described above, while the
+    contribution list contains other things that have been generated by other
+    parts of \TeX\ but have not yet been seen by the page builder. The
+    contribution list starts at |vlink(contrib_head)|, and it ends at the current
+    node in \TeX's vertical mode.
+
+    When \TeX\ has appended new material in vertical mode, it calls the procedure
+    |build_page|, which tries to catch up by moving nodes from the contribution
+    list to the current page. This procedure will succeed in its goal of emptying
+    the contribution list, unless a page break is discovered, i.e., unless the
+    current page has grown to the point where the optimum next page break has
+    been determined. In the latter case, the nodes after the optimum break will
+    go back onto the contribution list, and control will effectively pass to the
+    user's output routine.
+
+    We make |type(page_head)=glue_node|, so that an initial glue node on the
+    current page will not be considered a valid breakpoint.
+
+*/
+
+void initialize_buildpage(void)
+{
+    subtype(page_ins_head) = 65535;
+    type(page_ins_head) = split_up_node;
+    vlink(page_ins_head) = page_ins_head;
+
+    type(page_head) = glue_node;
+    subtype(page_head) = normal;
+}
+
+/*tex
+
+    An array |page_so_far| records the heights and depths of everything on the
+    current page. This array contains six |scaled| numbers, like the similar
+    arrays already considered in |line_break| and |vert_break|; and it also
+    contains |page_goal| and |page_depth|, since these values are all accessible
+    to the user via |set_page_dimen| commands. The value of |page_so_far[1]| is
+    also called |page_total|. The stretch and shrink components of the \.{\\skip}
+    corrections for each insertion are included in |page_so_far|, but the natural
+    space components of these corrections are not, since they have been
+    subtracted from |page_goal|.
+
+    The variable |page_depth| records the depth of the current page; it has been
+    adjusted so that it is at most |page_max_depth|. The variable |last_glue|
+    points to the glue specification of the most recent node contributed from the
+    contribution list, if this was a glue node; otherwise
+    |last_glue=max_halfword|. (If the contribution list is nonempty, however, the
+    value of |last_glue| is not necessarily accurate.) The variables
+    |last_penalty|, |last_kern|, and |last_node_type| are similar. And finally,
+    |insert_penalties| holds the sum of the penalties associated with all split
+    and floating insertions.
+
+*/
+
+/*tex height and glue of the current page */
+
+scaled page_so_far[8];
+
+/*tex used to implement \.{\\lastskip} */
+
+halfword last_glue;
+
+/*tex used to implement \.{\\lastpenalty} */
+
+int last_penalty;
+
+/*tex used to implement \.{\\lastkern} */
+
+scaled last_kern;
+
+/*tex used to implement \.{\\lastnodetype} */
+
+int last_node_type;
+
+/*tex sum of the penalties for held-over insertions */
+
+int insert_penalties;
+
+#define print_plus(A,B) do { \
+    if (page_so_far[(A)]!=0) { \
+        tprint(" plus "); \
+        print_scaled(page_so_far[(A)]); \
+        tprint((B)); \
+    } \
+} while (0)
+
+void print_totals(void)
+{
+    print_scaled(page_total);
+    print_plus(2, "");
+    print_plus(3, "fil");
+    print_plus(4, "fill");
+    print_plus(5, "filll");
+    if (page_shrink != 0) {
+        tprint(" minus ");
+        print_scaled(page_shrink);
+    }
+}
+
+/*tex
+
+    Here is a procedure that is called when the |page_contents| is changing from
+    |empty| to |inserts_only| or |box_there|.
+
+*/
+
+#define do_all_six(A) A(1);A(2);A(3);A(4);A(5);A(6);A(7)
+#define set_page_so_far_zero(A) page_so_far[(A)]=0
+
+void freeze_page_specs(int s)
+{
+    page_contents = s;
+    page_goal = vsize_par;
+    page_max_depth = max_depth_par;
+    page_depth = 0;
+    do_all_six(set_page_so_far_zero);
+    least_page_cost = awful_bad;
+    if (tracing_pages_par > 0) {
+        begin_diagnostic();
+        tprint_nl("%% goal height=");
+        print_scaled(page_goal);
+        tprint(", max depth=");
+        print_scaled(page_max_depth);
+        end_diagnostic(false);
+    }
+}
+
+/*tex
+
+    The global variable |output_active| is true during the time the user's output
+    routine is driving \TeX.
+
+*/
+
+/*tex Are we in the midst of an output routine? */
+
+boolean output_active;
+
+/*tex
+
+    The page builder is ready to start a fresh page if we initialize the
+    following state variables. (However, the page insertion list is initialized
+    elsewhere.)
+
+*/
+
+void start_new_page(void)
+{
+    page_contents = empty;
+    page_tail = page_head;
+    vlink(page_head) = null;
+    last_glue = max_halfword;
+    last_penalty = 0;
+    last_kern = 0;
+    last_node_type = -1;
+    page_depth = 0;
+    page_max_depth = 0;
+}
+
+/*tex
+
+    At certain times box \.{\\outputbox} is supposed to be void (i.e., |null|),
+    or an insertion box is supposed to be ready to accept a vertical list. If
+    not, an error message is printed, and the following subroutine flushes the
+    unwanted contents, reporting them to the user.
+
+*/
+
+static void box_error(int n)
+{
+    error();
+    begin_diagnostic();
+    tprint_nl("The following box has been deleted:");
+    show_box(box(n));
+    end_diagnostic(true);
+    flush_node_list(box(n));
+    box(n) = null;
+}
+
+/*tex
+
+    The following procedure guarantees that a given box register does not contain
+    an \.{\\hbox}.
+
+*/
+
+static void ensure_vbox(int n)
+{
+    halfword p = box(n);
+    if (p != null && type(p) == hlist_node) {
+        print_err("Insertions can only be added to a vbox");
+        help3(
+            "Tut tut: You're trying to \\insert into a",
+            "\\box register that now contains an \\hbox.",
+            "Proceed, and I'll discard its present contents."
+        );
+        box_error(n);
+    }
+}
+
+/*tex
+
+    \TeX\ is not always in vertical mode at the time |build_page| is called; the
+    current mode reflects what \TeX\ should return to, after the contribution
+    list has been emptied. A call on |build_page| should be immediately followed
+    by `|goto big_switch|', which is \TeX's central control point.
+
+*/
+
+/*tex Append contributions to the current page. */
+
+void build_page(void)
+{
+    /*tex the node being appended */
+    halfword p;
+    /*tex nodes being examined */
+    halfword q, r;
+    /*tex badness and cost of current page */
+    int b, c;
+    /*tex penalty to be added to the badness */
+    int pi = 0;
+    /*tex insertion box number */
+    int n;
+    /*tex sizes used for insertion calculations */
+    scaled delta, h, w;
+    int id, sk, i;
+    if ((vlink(contrib_head) == null) || output_active)
+        return;
+    do {
+      CONTINUE:
+        p = vlink(contrib_head);
+        /*tex Update the values of |last_glue|, |last_penalty|, and |last_kern|. */
+        if (last_glue != max_halfword) {
+            flush_node(last_glue);
+            last_glue = max_halfword;
+        }
+        last_penalty = 0;
+        last_kern = 0;
+        last_node_type = type(p) + 1;
+        if (type(p) == glue_node) {
+            last_glue = new_glue(p);
+        } else if (type(p) == penalty_node) {
+            last_penalty = penalty(p);
+        } else if (type(p) == kern_node) {
+            last_kern = width(p);
+        }
+        /*tex
+
+            Move node |p| to the current page; if it is time for a page break,
+            put the nodes following the break back onto the contribution list,
+            and |return| to the users output routine if there is one.
+
+            The code here is an example of a many-way switch into routines that
+            merge together in different places. Some people call this
+            unstructured programming, but the author doesn't see much wrong with
+            it, as long as the various labels have a well-understood meaning.
+
+            If the current page is empty and node |p| is to be deleted, |goto
+            done1|; otherwise use node |p| to update the state of the current
+            page; if this node is an insertion, |goto contribute|; otherwise if
+            this node is not a legal breakpoint, |goto contribute| or
+            |update_heights|; otherwise set |pi| to the penalty associated with
+            this breakpoint.
+
+            The title of this section is already so long, it seems best to avoid
+            making it more accurate but still longer, by mentioning the fact that
+            a kern node at the end of the contribution list will not be
+            contributed until we know its successor.
+
+        */
+        switch (type(p)) {
+            case hlist_node:
+            case vlist_node:
+            case rule_node:
+                if (page_contents < box_there) {
+                    /*tex
+
+                        Initialize the current page, insert the \.{\\topskip}
+                        glue ahead of |p|, and |goto continue|.
+
+                    */
+                    if (page_contents == empty)
+                        freeze_page_specs(box_there);
+                    else
+                        page_contents = box_there;
+                    q = new_skip_param(top_skip_code);
+                    if ((type(p) == hlist_node) && is_mirrored(body_direction_par)) {
+                        if (width(q) > depth(p))
+                            width(q) = width(q) - depth(p);
+                        else
+                            width(q) = 0;
+                    } else {
+                        if (width(q) > height(p))
+                            width(q) = width(q) - height(p);
+                        else
+                            width(q) = 0;
+                    }
+                    couple_nodes(q, p);
+                    couple_nodes(contrib_head, q);
+                    goto CONTINUE;
+                } else {
+                    /*tex
+
+                        Prepare to move a box or rule node to the current page,
+                        then |goto contribute|.
+
+                    */
+                    if ((type(p) == hlist_node) && is_mirrored(body_direction_par)) {
+                        page_total = page_total + page_depth + depth(p);
+                        page_depth = height(p);
+                    } else {
+                        page_total = page_total + page_depth + height(p);
+                        page_depth = depth(p);
+                    }
+                    goto CONTRIBUTE;
+
+                }
+                break;
+            case boundary_node:
+            case whatsit_node:
+                goto CONTRIBUTE;
+                break;
+            case glue_node:
+                if (page_contents < box_there)
+                    goto DONE1;
+                else if (precedes_break(page_tail))
+                    pi = 0;
+                else
+                    goto UPDATE_HEIGHTS;
+                break;
+            case kern_node:
+                if (page_contents < box_there)
+                    goto DONE1;
+                else if (vlink(p) == null)
+                    goto EXIT;
+                else if (type(vlink(p)) == glue_node)
+                    pi = 0;
+                else
+                    goto UPDATE_HEIGHTS;
+                break;
+            case penalty_node:
+                if (page_contents < box_there)
+                    goto DONE1;
+                else
+                    pi = penalty(p);
+                break;
+            case mark_node:
+                goto CONTRIBUTE;
+                break;
+            case ins_node:
+                /*tex Append an insertion to the current page and |goto contribute|. */
+                if (page_contents == empty)
+                    freeze_page_specs(inserts_only);
+                n = subtype(p);
+                r = page_ins_head;
+                i = 1 ;
+                while (n >= subtype(vlink(r))) {
+                    r = vlink(r);
+                    i = i + 1 ;
+                }
+                if (subtype(r) != n) {
+                    /*tex
+
+                        Create a page insertion node with |subtype(r)=qi(n)|, and
+                        include the glue correction for box |n| in the current
+                        page state.
+
+                        We take note of the value of \.{\\skip} |n| and the
+                        height plus depth of \.{\\box}~|n| only when the first
+                        \.{\\insert}~|n| node is encountered for a new page. A
+                        user who changes the contents of \.{\\box}~|n| after that
+                        first \.{\\insert}~|n| had better be either extremely
+                        careful or extremely lucky, or both.
+
+                    */
+                    id = callback_defined(build_page_insert_callback);
+                    if (id != 0) {
+                        run_callback(id, "dd->d",n,i,&sk);
+                    } else {
+                        sk = n;
+                    }
+                    q = new_node(inserting_node, n);
+                    try_couple_nodes(q, vlink(r));
+                    couple_nodes(r, q);
+                    r = q;
+                    ensure_vbox(n);
+                    if (box(n) == null)
+                        height(r) = 0;
+                    else
+                        height(r) = height(box(n)) + depth(box(n));
+                    best_ins_ptr(r) = null;
+                    q = skip(sk);
+                    if (count(n) == 1000)
+                        h = height(r);
+                    else
+                        h = x_over_n(height(r), 1000) * count(n);
+                    page_goal = page_goal - h - width(q);
+                    if (stretch_order(q) > 1)
+                        page_so_far[1 + stretch_order(q)] = page_so_far[1 + stretch_order(q)] + stretch(q);
+                    else
+                        page_so_far[2 + stretch_order(q)] = page_so_far[2 + stretch_order(q)] + stretch(q);
+                    page_shrink = page_shrink + shrink(q);
+                    if ((shrink_order(q) != normal) && (shrink(q) != 0)) {
+                        print_err("Infinite glue shrinkage inserted from \\skip");
+                        print_int(n);
+                        help3(
+                            "The correction glue for page breaking with insertions",
+                            "must have finite shrinkability. But you may proceed,",
+                            "since the offensive shrinkability has been made finite."
+                        );
+                        error();
+                    }
+
+                }
+                if (type(r) == split_up_node) {
+                    insert_penalties = insert_penalties + float_cost(p);
+                } else {
+                    last_ins_ptr(r) = p;
+                    delta = page_goal - page_total - page_depth + page_shrink;
+                    /*tex This much room is left if we shrink the maximum. */
+                    if (count(n) == 1000) {
+                        h = height(p);
+                    } else {
+                        /*tex This much room is needed. */
+                        h = x_over_n(height(p), 1000) * count(n);
+                    }
+                    if (((h <= 0) || (h <= delta))
+                        && (height(p) + height(r) <= dimen(n))) {
+                        page_goal = page_goal - h;
+                        height(r) = height(r) + height(p);
+                    } else {
+                        /*tex
+
+                            Find the best way to split the insertion, and change
+                            |type(r)| to |split_up_node|.
+
+                            Here is the code that will split a long footnote
+                            between pages, in an emergency. The current situation
+                            deserves to be recapitulated: Node |p| is an
+                            insertion into box |n|; the insertion will not fit,
+                            in its entirety, either because it would make the
+                            total contents of box |n| greater than \.{\\dimen}
+                            |n|, or because it would make the incremental amount
+                            of growth |h| greater than the available space
+                            |delta|, or both. (This amount |h| has been weighted
+                            by the insertion scaling factor, i.e., by \.{\\count}
+                            |n| over 1000.) Now we will choose the best way to
+                            break the vlist of the insertion, using the same
+                            criteria as in the \.{\\vsplit} operation.
+
+                        */
+                        if (count(n) <= 0) {
+                            w = max_dimen;
+                        } else {
+                            w = page_goal - page_total - page_depth;
+                            if (count(n) != 1000)
+                                w = x_over_n(w, count(n)) * 1000;
+                        }
+                        if (w > dimen(n) - height(r))
+                            w = dimen(n) - height(r);
+                        q = vert_break(ins_ptr(p), w, depth(p));
+                        height(r) = height(r) + best_height_plus_depth;
+                        if (tracing_pages_par > 0) {
+                            /*tex Display the insertion split cost. */
+                            begin_diagnostic();
+                            tprint_nl("% split");
+                            print_int(n);
+                            tprint(" to ");
+                            print_scaled(w);
+                            print_char(',');
+                            print_scaled(best_height_plus_depth);
+                            tprint(" p=");
+                            if (q == null)
+                                print_int(eject_penalty);
+                            else if (type(q) == penalty_node)
+                                print_int(penalty(q));
+                            else
+                                print_char('0');
+                            end_diagnostic(false);
+                        }
+                        if (count(n) != 1000)
+                            best_height_plus_depth = x_over_n(best_height_plus_depth, 1000) * count(n);
+                        page_goal = page_goal - best_height_plus_depth;
+                        type(r) = split_up_node;
+                        broken_ptr(r) = q;
+                        broken_ins(r) = p;
+                        if (q == null)
+                            insert_penalties = insert_penalties + eject_penalty;
+                        else if (type(q) == penalty_node)
+                            insert_penalties = insert_penalties + penalty(q);
+                    }
+                }
+                goto CONTRIBUTE;
+
+                break;
+            default:
+                formatted_error("pagebuilder","invalid node of type %d in vertical mode", type(p));
+                break;
+        }
+        /*tex
+
+            Check if node |p| is a new champion breakpoint; then if it is time
+            for a page break, prepare for output, and either fire up the users
+            output routine and |return| or ship out the page and |goto done|.
+
+        */
+        if (pi < inf_penalty) {
+            /*tex
+
+                Compute the badness, |b|, of the current page, using |awful_bad|
+                if the box is too full.
+
+            */
+            if (page_total < page_goal) {
+                if ((page_so_far[3] != 0) || (page_so_far[4] != 0) ||
+                    (page_so_far[5] != 0))
+                    b = 0;
+                else
+                    b = badness(page_goal - page_total, page_so_far[2]);
+            } else if (page_total - page_goal > page_shrink) {
+                b = awful_bad;
+            } else {
+                b = badness(page_total - page_goal, page_shrink);
+            }
+            if (b < awful_bad) {
+                if (pi <= eject_penalty)
+                    c = pi;
+                else if (b < inf_bad)
+                    c = b + pi + insert_penalties;
+                else
+                    c = deplorable;
+            } else {
+                c = b;
+            }
+            if (insert_penalties >= 10000)
+                c = awful_bad;
+            if (tracing_pages_par > 0) {
+                /*tex Display the page break cost. */
+                begin_diagnostic();
+                tprint_nl("%");
+                tprint(" t=");
+                print_totals();
+                tprint(" g=");
+                print_scaled(page_goal);
+                tprint(" b=");
+                if (b == awful_bad)
+                    print_char('*');
+                else
+                    print_int(b);
+                tprint(" p=");
+                print_int(pi);
+                tprint(" c=");
+                if (c == awful_bad)
+                    print_char('*');
+                else
+                    print_int(c);
+                if (c <= least_page_cost)
+                    print_char('#');
+                end_diagnostic(false);
+            }
+            if (c <= least_page_cost) {
+                best_page_break = p;
+                best_size = page_goal;
+                least_page_cost = c;
+                r = vlink(page_ins_head);
+                while (r != page_ins_head) {
+                    best_ins_ptr(r) = last_ins_ptr(r);
+                    r = vlink(r);
+                }
+            }
+            if ((c == awful_bad) || (pi <= eject_penalty)) {
+                /*tex Output the current page at the best place. */
+                fire_up(p);
+                if (output_active) {
+                    /*tex User's output routine will act. */
+                    goto EXIT;
+                }
+                /*tex The page has been shipped out by default output routine. */
+                goto DONE;
+            }
+        }
+        if ((type(p) < glue_node) || (type(p) > kern_node))
+            goto CONTRIBUTE;
+      UPDATE_HEIGHTS:
+        /*tex
+
+            Go here to record glue in the |active_height| table. Update the
+            current page measurements with respect to the glue or kern specified
+            by node~|p|.
+
+        */
+        if (type(p) != kern_node) {
+            if (stretch_order(p) > 1)
+                page_so_far[1 + stretch_order(p)] = page_so_far[1 + stretch_order(p)] + stretch(p);
+            else
+                page_so_far[2 + stretch_order(p)] = page_so_far[2 + stretch_order(p)] + stretch(p);
+            page_shrink = page_shrink + shrink(p);
+            if ((shrink_order(p) != normal) && (shrink(p) != 0)) {
+                print_err("Infinite glue shrinkage found on current page");
+                help4(
+                    "The page about to be output contains some infinitely",
+                    "shrinkable glue, e.g., `\\vss' or `\\vskip 0pt minus 1fil'.",
+                    "Such glue doesn't belong there; but you can safely proceed,",
+                    "since the offensive shrinkability has been made finite."
+                );
+                error();
+                reset_glue_to_zero(p);
+                shrink_order(p) = normal;
+            }
+        }
+        page_total = page_total + page_depth + width(p);
+        page_depth = 0;
+      CONTRIBUTE:
+        /*tex
+
+            Go here to link a node into the current page. Make sure that
+            |page_max_depth| is not exceeded.
+
+        */
+        if (page_depth > page_max_depth) {
+            page_total = page_total + page_depth - page_max_depth;
+            page_depth = page_max_depth;
+        }
+        /*tex Link node |p| into the current page and |goto done|. */
+        couple_nodes(page_tail, p);
+        page_tail = p;
+        try_couple_nodes(contrib_head,vlink(p));
+        vlink(p) = null;
+        goto DONE;
+      DONE1:
+        /*tex Recycle node |p|. */
+        try_couple_nodes(contrib_head,vlink(p));
+        vlink(p) = null;
+        if (saving_vdiscards_par > 0) {
+            if (page_disc == null) {
+                page_disc = p;
+            } else {
+                couple_nodes(tail_page_disc, p);
+            }
+            tail_page_disc = p;
+        } else {
+            flush_node_list(p);
+        }
+      DONE:
+        ;
+    } while (vlink(contrib_head) != null);
+    /*tex Make the contribution list empty by setting its tail to |contrib_head|. */
+    contrib_tail = contrib_head;
+  EXIT:
+    ;
+}
+
+/*tex
+
+    When the page builder has looked at as much material as could appear before
+    the next page break, it makes its decision. The break that gave minimum
+    badness will be used to put a completed ``page'' into box \.{\\outputbox},
+    with insertions appended to their other boxes.
+
+    We also set the values of |top_mark|, |first_mark|, and |bot_mark|. The
+    program uses the fact that |bot_mark(x)<>null| implies |first_mark(x)<>null|;
+    it also knows that |bot_mark(x)=null| implies
+    |top_mark(x)=first_mark(x)=null|.
+
+    The |fire_up| subroutine prepares to output the current page at the best
+    place; then it fires up the user's output routine, if there is one, or it
+    simply ships out the page. There is one parameter, |c|, which represents the
+    node that was being contributed to the page when the decision to force an
+    output was made.
+
+*/
+
+void fire_up(halfword c)
+{
+    /*tex nodes being examined and/or changed */
+    halfword p, q, r, s;
+    /*tex predecessor of |p| */
+    halfword prev_p;
+    /*tex insertion box number */
+    int n;
+    /*tex should the present insertion be held over? */
+    boolean wait;
+    /*tex saved value of |vbadness| */
+    int save_vbadness;
+    /*tex saved value of |vfuzz| */
+    scaled save_vfuzz;
+    /*tex saved value of |split_top_skip| */
+    halfword save_split_top_skip;
+    /*tex for looping through the marks */
+    halfword i;
+    /*tex Set the value of |output_penalty|. */
+    if (type(best_page_break) == penalty_node) {
+        geq_word_define(int_base + output_penalty_code,
+                        penalty(best_page_break));
+        penalty(best_page_break) = inf_penalty;
+    } else {
+        geq_word_define(int_base + output_penalty_code, inf_penalty);
+    }
+
+    for (i = 0; i <= biggest_used_mark; i++) {
+        if (bot_mark(i) != null) {
+            if (top_mark(i) != null)
+                delete_token_ref(top_mark(i));
+            set_top_mark(i, bot_mark(i));
+            add_token_ref(top_mark(i));
+            delete_first_mark(i);
+        }
+    }
+    /*tex
+
+        Put the optimal current page into box |output_box|, update |first_mark|
+        and |bot_mark|, append insertions to their boxes, and put the remaining
+        nodes back on the contribution list.
+
+        As the page is finally being prepared for output, pointer |p| runs
+        through the vlist, with |prev_p| trailing behind; pointer |q| is the tail
+        of a list of insertions that are being held over for a subsequent page.
+
+    */
+    if (c == best_page_break) {
+        /*tex |c| not yet linked in */
+        best_page_break = null;
+    }
+    /*tex Ensure that box |output_box| is empty before output. */
+    if (box(output_box_par) != null) {
+        print_err("\\box");
+        print_int(output_box_par);
+        tprint(" is not void");
+        help2(
+            "You shouldn't use \\box\\outputbox except in \\output routines.",
+            "Proceed, and I'll discard its present contents."
+        );
+        box_error(output_box_par);
+    }
+    /*tex This will count the number of insertions held over. */
+    insert_penalties = 0;
+    save_split_top_skip = split_top_skip_par;
+    if (holding_inserts_par <= 0) {
+        /*tex
+
+            Prepare all the boxes involved in insertions to act as queues. If
+            many insertions are supposed to go into the same box, we want to know
+            the position of the last node in that box, so that we don't need to
+            waste time when linking further information into it. The
+            |last_ins_ptr| fields of the page insertion nodes are therefore used
+            for this purpose during the packaging phase.
+
+        */
+        r = vlink(page_ins_head);
+        while (r != page_ins_head) {
+            if (best_ins_ptr(r) != null) {
+                n = subtype(r);
+                ensure_vbox(n);
+                if (box(n) == null)
+                    box(n) = new_null_box();
+                p = box(n) + list_offset;
+                while (vlink(p) != null)
+                    p = vlink(p);
+                last_ins_ptr(r) = p;
+            }
+            r = vlink(r);
+        }
+
+    }
+    q = hold_head;
+    vlink(q) = null;
+    prev_p = page_head;
+    p = vlink(prev_p);
+    while (p != best_page_break) {
+        if (type(p) == ins_node) {
+            if (holding_inserts_par <= 0) {
+                /*tex
+
+                    Either insert the material specified by node |p| into the
+                    appropriate box, or hold it for the next page; also delete
+                    node |p| from the current page.
+
+                    We will set |best_ins_ptr:=null| and package the box
+                    corresponding to insertion node~|r|, just after making the
+                    final insertion into that box. If this final insertion is
+                    `|split_up_node|', the remainder after splitting and pruning
+                    (if any) will be carried over to the next page.
+
+                */
+                r = vlink(page_ins_head);
+                while (subtype(r) != subtype(p))
+                    r = vlink(r);
+                if (best_ins_ptr(r) == null) {
+                    wait = true;
+                } else {
+                    wait = false;
+                    s = last_ins_ptr(r);
+                    vlink(s) = ins_ptr(p);
+                    if (best_ins_ptr(r) == p) {
+                        halfword t;
+                        /*tex
+
+                            Wrap up the box specified by node |r|, splitting node
+                            |p| if called for; set |wait:=true| if node |p| holds
+                            a remainder after splitting.
+
+                        */
+                        if (type(r) == split_up_node) {
+                            if ((broken_ins(r) == p) && (broken_ptr(r) != null)) {
+                                while (vlink(s) != broken_ptr(r))
+                                    s = vlink(s);
+                                vlink(s) = null;
+                                split_top_skip_par = split_top_ptr(p);
+                                ins_ptr(p) =
+                                    prune_page_top(broken_ptr(r), false);
+                                if (ins_ptr(p) != null) {
+                                    t = vpack(ins_ptr(p), 0, additional, -1);
+                                    height(p) = height(t) + depth(t);
+                                    list_ptr(t) = null;
+                                    flush_node(t);
+                                    wait = true;
+                                }
+                            }
+                        }
+                        best_ins_ptr(r) = null;
+                        n = subtype(r);
+                        t = list_ptr(box(n));
+                        list_ptr(box(n)) = null;
+                        flush_node(box(n));
+                        box(n) = vpack(t, 0, additional, body_direction_par);
+
+                    } else {
+                        while (vlink(s) != null)
+                            s = vlink(s);
+                        last_ins_ptr(r) = s;
+                    }
+                }
+                /*tex
+
+                    Either append the insertion node |p| after node |q|, and
+                    remove it from the current page, or delete |node(p)|.
+
+                */
+                try_couple_nodes(prev_p, vlink(p));
+                vlink(p) = null;
+                if (wait) {
+                    couple_nodes(q, p);
+                    q = p;
+                    incr(insert_penalties);
+                } else {
+                    ins_ptr(p) = null;
+                    flush_node(p);
+                }
+                p = prev_p;
+
+            }
+        } else if (type(p) == mark_node) {
+            /*tex Update the values of |first_mark| and |bot_mark|. */
+            if (first_mark(mark_class(p)) == null) {
+                set_first_mark(mark_class(p), mark_ptr(p));
+                add_token_ref(first_mark(mark_class(p)));
+            }
+            if (bot_mark(mark_class(p)) != null)
+                delete_token_ref(bot_mark(mark_class(p)));
+            set_bot_mark(mark_class(p), mark_ptr(p));
+            add_token_ref(bot_mark(mark_class(p)));
+
+        }
+        prev_p = p;
+        p = vlink(prev_p);
+    }
+    split_top_skip_par = save_split_top_skip;
+    /*tex
+
+        Break the current page at node |p|, put it in box~|output_box|, and put
+        the remaining nodes on the contribution list.
+
+        When the following code is executed, the current page runs from node
+        |vlink(page_head)| to node |prev_p|, and the nodes from |p| to
+        |page_tail| are to be placed back at the front of the contribution list.
+        Furthermore the heldover insertions appear in a list from
+        |vlink(hold_head)| to |q|; we will put them into the current page list
+        for safekeeping while the user's output routine is active. We might have
+        |q=hold_head|; and |p=null| if and only if |prev_p=page_tail|. Error
+        messages are suppressed within |vpackage|, since the box might appear to
+        be overfull or underfull simply because the stretch and shrink from the
+        \.{\\skip} registers for inserts are not actually present in the box.
+
+    */
+    if (p != null) {
+        if (vlink(contrib_head) == null) {
+            contrib_tail = page_tail;
+        }
+        couple_nodes(page_tail,vlink(contrib_head));
+        couple_nodes(contrib_head, p);
+        vlink(prev_p) = null;
+    }
+    save_vbadness = vbadness_par;
+    vbadness_par = inf_bad;
+    save_vfuzz = vfuzz_par;
+    /*tex Inhibit error messages. */
+    vfuzz_par = max_dimen;
+    box(output_box_par) = filtered_vpackage(vlink(page_head),
+        best_size, exactly, page_max_depth, output_group, body_direction_par, 0, 0);
+    vbadness_par = save_vbadness;
+    vfuzz_par = save_vfuzz;
+    if (last_glue != max_halfword)
+        flush_node(last_glue);
+    /*tex Start a new current page. This sets |last_glue:=max_halfword|. */
+    start_new_page();
+    if (q != hold_head) {
+        vlink(page_head) = vlink(hold_head);
+        page_tail = q;
+    }
+    /*tex Delete the page-insertion nodes. */
+    r = vlink(page_ins_head);
+    while (r != page_ins_head) {
+	    /*tex Todo: couple. */
+        q = vlink(r);
+        flush_node(r);
+        r = q;
+    }
+    vlink(page_ins_head) = page_ins_head;
+    for (i = 0; i <= biggest_used_mark; i++) {
+        if ((top_mark(i) != null) && (first_mark(i) == null)) {
+            set_first_mark(i, top_mark(i));
+            add_token_ref(top_mark(i));
+        }
+    }
+    if (output_routine_par != null) {
+        if (dead_cycles >= max_dead_cycles_par) {
+            /*tex Explain that too many dead cycles have occurred in a row. */
+            print_err("Output loop---");
+            print_int(dead_cycles);
+            tprint(" consecutive dead cycles");
+            help3(
+                "I've concluded that your \\output is awry; it never does a",
+                "\\shipout, so I'm shipping \\box\\outputbox out myself. Next time",
+                "increase \\maxdeadcycles if you want me to be more patient!"
+            );
+            error();
+        } else {
+            /*tex Fire up the users output routine and |return|. */
+            output_active = true;
+            incr(dead_cycles);
+            push_nest();
+            mode = -vmode;
+            prev_depth_par = ignore_depth;
+            mode_line_par = -line;
+            begin_token_list(output_routine_par, output_text);
+            new_save_level(output_group);
+            normal_paragraph();
+            scan_left_brace();
+            return;
+        }
+    }
+    /*tex
+
+        Perform the default output routine. The list of heldover insertions,
+        running from |vlink(page_head)| to |page_tail|, must be moved to the
+        contribution list when the user has specified no output routine.
+
+    */
+    if (vlink(page_head) != null) {
+        if (vlink(contrib_head) == null) {
+            contrib_tail = page_tail;
+        } else {
+            vlink(page_tail) = vlink(contrib_head);
+        }
+        vlink(contrib_head) = vlink(page_head);
+        vlink(page_head) = null;
+        page_tail = page_head;
+    }
+    flush_node_list(page_disc);
+    page_disc = null;
+    ship_out(static_pdf, box(output_box_par), SHIPPING_PAGE);
+    box(output_box_par) = null;
+}
+
+/*tex
+
+    When the user's output routine finishes, it has constructed a vlist in
+    internal vertical mode, and \TeX\ will do the following:
+
+*/
+
+void resume_after_output(void)
+{
+    if ((iloc != null) || ((token_type != output_text) && (token_type != backed_up))) {
+        /*tex Recover from an unbalanced output routine */
+        print_err("Unbalanced output routine");
+        help2(
+            "Your sneaky output routine has problematic {'s and/or }'s.",
+            "I can't handle that very well; good luck."
+        );
+        error();
+        /*tex Loops forever if reading from a file, since |null=min_halfword<=0|. */
+        do {
+            get_token();
+        } while (iloc != null);
+    }
+    /*tex Conserve stack space in case more outputs are triggered. */
+    end_token_list();
+    end_graf(bottom_level);
+    unsave();
+    output_active = false;
+    insert_penalties = 0;
+    /*tex Ensure that box |output_box| is empty after output. */
+    if (box(output_box_par) != null) {
+        print_err("Output routine didn't use all of \\box");
+        print_int(output_box_par);
+        help3(
+            "Your \\output commands should empty \\box\\outputbox,",
+            "e.g., by saying `\\shipout\\box\\outputbox'.",
+            "Proceed; I'll discard its present contents."
+        );
+        box_error(output_box_par);
+    }
+    if (tail != head) {
+        /*tex Current list goes after heldover insertions. */
+        try_couple_nodes(page_tail, vlink(head));
+        page_tail = tail;
+    }
+    if (vlink(page_head) != null) {
+        /* Both go before heldover contributions. */
+        if (vlink(contrib_head) == null)
+            contrib_tail = page_tail;
+        try_couple_nodes(page_tail, vlink(contrib_head));
+        try_couple_nodes(contrib_head, vlink(page_head));
+        vlink(page_head) = null;
+        page_tail = page_head;
+    }
+    flush_node_list(page_disc);
+    page_disc = null;
+    pop_nest();
+    normal_page_filter(after_output);
+    build_page();
+}
diff --git a/texk/web2c/luatexdir/tex/buildpage.w b/texk/web2c/luatexdir/tex/buildpage.w
deleted file mode 100644
index cba07cbf6..000000000
--- a/texk/web2c/luatexdir/tex/buildpage.w
+++ /dev/null
@@ -1,1013 +0,0 @@
-% buildpage.w
-%
-% Copyright 2009-2010 Taco Hoekwater <taco@@luatex.org>
-%
-% This file is part of LuaTeX.
-%
-% LuaTeX is free software; you can redistribute it and/or modify it under
-% the terms of the GNU General Public License as published by the Free
-% Software Foundation; either version 2 of the License, or (at your
-% option) any later version.
-%
-% LuaTeX is distributed in the hope that it will be useful, but WITHOUT
-% ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-% FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
-% License for more details.
-%
-% You should have received a copy of the GNU General Public License along
-% with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
-
-@ @c
-
-#include "ptexlib.h"
-
-@ @c
-#define mode mode_par
-#define head head_par
-#define tail tail_par
-
-@ When \TeX\ appends new material to its main vlist in vertical mode, it uses
-a method something like |vsplit| to decide where a page ends, except that
-the calculations are done ``on line'' as new items come in.
-The main complication in this process is that insertions must be put
-into their boxes and removed from the vlist, in a more-or-less optimum manner.
-
-We shall use the term ``current page'' for that part of the main vlist that
-is being considered as a candidate for being broken off and sent to the
-user's output routine. The current page starts at |vlink(page_head)|, and
-it ends at |page_tail|.  We have |page_head=page_tail| if this list is empty.
-@^current page@>
-
-Utter chaos would reign if the user kept changing page specifications
-while a page is being constructed, so the page builder keeps the pertinent
-specifications frozen as soon as the page receives its first box or
-insertion.  The global variable |page_contents| is |empty| when the
-current page contains only mark nodes and content-less whatsit nodes; it
-is |inserts_only| if the page contains only insertion nodes in addition to
-marks and whatsits.  Glue nodes, kern nodes, and penalty nodes are
-discarded until a box or rule node appears, at which time |page_contents|
-changes to |box_there|.  As soon as |page_contents| becomes non-|empty|,
-the current |vsize| and |max_depth| are squirreled away into |page_goal|
-and |page_max_depth|; the latter values will be used until the page has
-been forwarded to the user's output routine. The \.{\\topskip} adjustment
-is made when |page_contents| changes to |box_there|.
-
-Although |page_goal| starts out equal to |vsize|, it is decreased by the
-scaled natural height-plus-depth of the insertions considered so far, and by
-the \.{\\skip} corrections for those insertions. Therefore it represents
-the size into which the non-inserted material should fit, assuming that
-all insertions in the current page have been made.
-
-The global variables |best_page_break| and |least_page_cost| correspond
-respectively to the local variables |best_place| and |least_cost| in the
-|vert_break| routine that we have already studied; i.e., they record the
-location and value of the best place currently known for breaking the
-current page. The value of |page_goal| at the time of the best break is
-stored in |best_size|.
-
-@c
-halfword page_tail;             /* the final node on the current page */
-int page_contents;              /* what is on the current page so far? */
-scaled page_max_depth;          /* maximum box depth on page being built */
-halfword best_page_break;       /* break here to get the best page known so far */
-int least_page_cost;            /* the score for this currently best page */
-scaled best_size;               /* its |page_goal| */
-
-@ The page builder has another data structure to keep track of insertions.
-This is a list of four-word nodes, starting and ending at |page_ins_head|.
-That is, the first element of the list is node |r@t$_1$@>=vlink(page_ins_head)|;
-node $r_j$ is followed by |r@t$_{j+1}$@>=vlink(r@t$_j$@>)|; and if there are
-|n| items we have |r@t$_{n+1}$@>=page_ins_head|. The |subtype| field of
-each node in this list refers to an insertion number; for example, `\.{\\insert
-250}' would correspond to a node whose |subtype| is |qi(250)|
-(the same as the |subtype| field of the relevant |ins_node|). These |subtype|
-fields are in increasing order, and |subtype(page_ins_head)=65535|, so
-|page_ins_head| serves as a convenient sentinel
-at the end of the list. A record is present for each insertion number that
-appears in the current page.
-
-The |type| field in these nodes distinguishes two possibilities that
-might occur as we look ahead before deciding on the optimum page break.
-If |type(r)=inserting_node|, then |height(r)| contains the total of the
-height-plus-depth dimensions of the box and all its inserts seen so far.
- |type(r)=split_up_node|, then no more insertions will be made into this box,
-because at least one previous insertion was too big to fit on the current
-page; |broken_ptr(r)| points to the node where that insertion will be
-split, if \TeX\ decides to split it, |broken_ins(r)| points to the
-insertion node that was tentatively split, and |height(r)| includes also the
-natural height plus depth of the part that would be split off.
-
-In both cases, |last_ins_ptr(r)| points to the last |ins_node|
-encountered for box |qo(subtype(r))| that would be at least partially
-inserted on the next page; and |best_ins_ptr(r)| points to the last
-such |ins_node| that should actually be inserted, to get the page with
-minimum badness among all page breaks considered so far. We have
-|best_ins_ptr(r)=null| if and only if no insertion for this box should
-be made to produce this optimum page.
-
-@ Pages are built by appending nodes to the current list in \TeX's
-vertical mode, which is at the outermost level of the semantic nest. This
-vlist is split into two parts; the ``current page'' that we have been
-talking so much about already, and the ``contribution list'' that receives
-new nodes as they are created.  The current page contains everything that
-the page builder has accounted for in its data structures, as described
-above, while the contribution list contains other things that have been
-generated by other parts of \TeX\ but have not yet been
-seen by the page builder.
-The contribution list starts at |vlink(contrib_head)|, and it ends at the
-current node in \TeX's vertical mode.
-
-When \TeX\ has appended new material in vertical mode, it calls the procedure
-|build_page|, which tries to catch up by moving nodes from the contribution
-list to the current page. This procedure will succeed in its goal of
-emptying the contribution list, unless a page break is discovered, i.e.,
-unless the current page has grown to the point where the optimum next
-page break has been determined. In the latter case, the nodes after the
-optimum break will go back onto the contribution list, and control will
-effectively pass to the user's output routine.
-
-We make |type(page_head)=glue_node|, so that an initial glue node on
-the current page will not be considered a valid breakpoint.
-
-@c
-void initialize_buildpage(void)
-{
-    subtype(page_ins_head) = 65535;
-    type(page_ins_head) = split_up_node;
-    vlink(page_ins_head) = page_ins_head;
-
-    type(page_head) = glue_node;
-    subtype(page_head) = normal;
-}
-
-
-@ An array |page_so_far| records the heights and depths of everything
-on the current page. This array contains six |scaled| numbers, like the
-similar arrays already considered in |line_break| and |vert_break|; and it
-also contains |page_goal| and |page_depth|, since these values are
-all accessible to the user via |set_page_dimen| commands. The
-value of |page_so_far[1]| is also called |page_total|.  The stretch
-and shrink components of the \.{\\skip} corrections for each insertion are
-included in |page_so_far|, but the natural space components of these
-corrections are not, since they have been subtracted from |page_goal|.
-
-The variable |page_depth| records the depth of the current page; it has been
-adjusted so that it is at most |page_max_depth|. The variable
-|last_glue| points to the glue specification of the most recent node
-contributed from the contribution list, if this was a glue node; otherwise
-|last_glue=max_halfword|. (If the contribution list is nonempty,
-however, the value of |last_glue| is not necessarily accurate.)
-The variables |last_penalty|, |last_kern|, and |last_node_type|
-are similar.  And
-finally, |insert_penalties| holds the sum of the penalties associated with
-all split and floating insertions.
-
-@c
-scaled page_so_far[8];          /* height and glue of the current page */
-halfword last_glue;             /* used to implement \.{\\lastskip} */
-int last_penalty;               /* used to implement \.{\\lastpenalty} */
-scaled last_kern;               /* used to implement \.{\\lastkern} */
-int last_node_type;             /* used to implement \.{\\lastnodetype} */
-int insert_penalties;           /* sum of the penalties for held-over insertions */
-
-#define print_plus(A,B) do { \
-    if (page_so_far[(A)]!=0) { \
-        tprint(" plus "); \
-        print_scaled(page_so_far[(A)]); \
-        tprint((B)); \
-    } \
-} while (0)
-
-void print_totals(void)
-{
-    print_scaled(page_total);
-    print_plus(2, "");
-    print_plus(3, "fil");
-    print_plus(4, "fill");
-    print_plus(5, "filll");
-    if (page_shrink != 0) {
-        tprint(" minus ");
-        print_scaled(page_shrink);
-    }
-}
-
-@ Here is a procedure that is called when the |page_contents| is changing
-from |empty| to |inserts_only| or |box_there|.
-
-@c
-#define do_all_six(A) A(1);A(2);A(3);A(4);A(5);A(6);A(7)
-#define set_page_so_far_zero(A) page_so_far[(A)]=0
-
-void freeze_page_specs(int s)
-{
-    page_contents = s;
-    page_goal = vsize_par;
-    page_max_depth = max_depth_par;
-    page_depth = 0;
-    do_all_six(set_page_so_far_zero);
-    least_page_cost = awful_bad;
-    if (tracing_pages_par > 0) {
-        begin_diagnostic();
-        tprint_nl("%% goal height=");
-        print_scaled(page_goal);
-        tprint(", max depth=");
-        print_scaled(page_max_depth);
-        end_diagnostic(false);
-    }
-}
-
-@ The global variable |output_active| is true during the time the
-user's output routine is driving \TeX.
-
-@c
-boolean output_active;          /* are we in the midst of an output routine? */
-
-@ The page builder is ready to start a fresh page if we initialize
-the following state variables. (However, the page insertion list is initialized
-elsewhere.)
-
-@c
-void start_new_page(void)
-{
-    page_contents = empty;
-    page_tail = page_head;
-    vlink(page_head) = null;
-    last_glue = max_halfword;
-    last_penalty = 0;
-    last_kern = 0;
-    last_node_type = -1;
-    page_depth = 0;
-    page_max_depth = 0;
-}
-
-@ At certain times box \.{\\outputbox} is supposed to be void (i.e., |null|),
-or an insertion box is supposed to be ready to accept a vertical list.
-If not, an error message is printed, and the following subroutine
-flushes the unwanted contents, reporting them to the user.
-
-@c
-static void box_error(int n)
-{
-    error();
-    begin_diagnostic();
-    tprint_nl("The following box has been deleted:");
-    show_box(box(n));
-    end_diagnostic(true);
-    flush_node_list(box(n));
-    box(n) = null;
-}
-
-@ The following procedure guarantees that a given box register
-does not contain an \.{\\hbox}.
-
-@c
-static void ensure_vbox(int n)
-{
-    halfword p;                 /* the box register contents */
-    p = box(n);
-    if (p != null && type(p) == hlist_node) {
-        print_err("Insertions can only be added to a vbox");
-        help3("Tut tut: You're trying to \\insert into a",
-              "\\box register that now contains an \\hbox.",
-              "Proceed, and I'll discard its present contents.");
-        box_error(n);
-    }
-}
-
-@ \TeX\ is not always in vertical mode at the time |build_page|
-is called; the current mode reflects what \TeX\ should return to, after
-the contribution list has been emptied. A call on |build_page| should
-be immediately followed by `|goto big_switch|', which is \TeX's central
-control point.
-
-@c
-void build_page(void)
-{                               /* append contributions to the current page */
-    halfword p;                 /* the node being appended */
-    halfword q, r;              /* nodes being examined */
-    int b, c;                   /* badness and cost of current page */
-    int pi = 0;                 /* penalty to be added to the badness */
-    int n;                      /* insertion box number */
-    scaled delta, h, w;         /* sizes used for insertion calculations */
-    int id, sk, i;
-    if ((vlink(contrib_head) == null) || output_active)
-        return;
-    do {
-      CONTINUE:
-        p = vlink(contrib_head);
-        /* Update the values of |last_glue|, |last_penalty|, and |last_kern| */
-        if (last_glue != max_halfword) {
-            flush_node(last_glue);
-            last_glue = max_halfword;
-        }
-        last_penalty = 0;
-        last_kern = 0;
-        last_node_type = type(p) + 1;
-        if (type(p) == glue_node) {
-            last_glue = new_glue(p);
-        } else if (type(p) == penalty_node) {
-            last_penalty = penalty(p);
-        } else if (type(p) == kern_node) {
-            last_kern = width(p);
-        }
-
-        /* Move node |p| to the current page; if it is time for a page break,
-           put the nodes following the break back onto the contribution list,
-           and |return| to the users output routine if there is one */
-
-        /* The code here is an example of a many-way switch into routines that
-           merge together in different places. Some people call this unstructured
-           programming, but the author doesn't see much wrong with it, as long as
-           the various labels have a well-understood meaning.
-         */
-        /* If the current page is empty and node |p| is to be deleted, |goto done1|;
-           otherwise use node |p| to update the state of the current page;
-           if this node is an insertion, |goto contribute|; otherwise if this node
-           is not a legal breakpoint, |goto contribute| or |update_heights|;
-           otherwise set |pi| to the penalty associated with this breakpoint */
-        /* The title of this section is already so long, it seems best to avoid
-           making it more accurate but still longer, by mentioning the fact that a
-           kern node at the end of the contribution list will not be contributed until
-           we know its successor. */
-        switch (type(p)) {
-        case hlist_node:
-        case vlist_node:
-        case rule_node:
-            if (page_contents < box_there) {
-                /* Initialize the current page, insert the \.{\\topskip} glue
-                   ahead of |p|, and |goto continue| */
-                if (page_contents == empty)
-                    freeze_page_specs(box_there);
-                else
-                    page_contents = box_there;
-                q = new_skip_param(top_skip_code);
-                if ((type(p) == hlist_node) && is_mirrored(body_direction_par)) {
-                    if (width(q) > depth(p))
-                        width(q) = width(q) - depth(p);
-                    else
-                        width(q) = 0;
-                } else {
-                    if (width(q) > height(p))
-                        width(q) = width(q) - height(p);
-                    else
-                        width(q) = 0;
-                }
-                couple_nodes(q, p);
-                couple_nodes(contrib_head, q);
-                goto CONTINUE;
-
-            } else {
-                /* Prepare to move a box or rule node to the current page,
-                   then |goto contribute| */
-                if ((type(p) == hlist_node) && is_mirrored(body_direction_par)) {
-                    page_total = page_total + page_depth + depth(p);
-                    page_depth = height(p);
-                } else {
-                    page_total = page_total + page_depth + height(p);
-                    page_depth = depth(p);
-                }
-                goto CONTRIBUTE;
-
-            }
-            break;
-        case boundary_node:
-        case whatsit_node:
-            goto CONTRIBUTE;
-            break;
-        case glue_node:
-            if (page_contents < box_there)
-                goto DONE1;
-            else if (precedes_break(page_tail))
-                pi = 0;
-            else
-                goto UPDATE_HEIGHTS;
-            break;
-        case kern_node:
-            if (page_contents < box_there)
-                goto DONE1;
-            else if (vlink(p) == null)
-                goto EXIT;
-            else if (type(vlink(p)) == glue_node)
-                pi = 0;
-            else
-                goto UPDATE_HEIGHTS;
-            break;
-        case penalty_node:
-            if (page_contents < box_there)
-                goto DONE1;
-            else
-                pi = penalty(p);
-            break;
-        case mark_node:
-            goto CONTRIBUTE;
-            break;
-        case ins_node:
-            /* Append an insertion to the current page and |goto contribute| */
-            if (page_contents == empty)
-                freeze_page_specs(inserts_only);
-            n = subtype(p);
-            r = page_ins_head;
-            i = 1 ;
-            while (n >= subtype(vlink(r))) {
-                r = vlink(r);
-                i = i + 1 ;
-            }
-            if (subtype(r) != n) {
-                /* Create a page insertion node with |subtype(r)=qi(n)|, and
-                   include the glue correction for box |n| in the
-                   current page state */
-                /* We take note of the value of \.{\\skip} |n| and the height plus depth
-                   of \.{\\box}~|n| only when the first \.{\\insert}~|n| node is
-                   encountered for a new page. A user who changes the contents of \.{\\box}~|n|
-                   after that first \.{\\insert}~|n| had better be either extremely careful
-                   or extremely lucky, or both. */
-id = callback_defined(build_page_insert_callback);
-if (id != 0) {
-    run_callback(id, "dd->d",n,i,&sk);
-} else {
-    sk = n;
-}
-                q = new_node(inserting_node, n);
-                try_couple_nodes(q, vlink(r));
-                couple_nodes(r, q);
-                r = q;
-                ensure_vbox(n);
-                if (box(n) == null)
-                    height(r) = 0;
-                else
-                    height(r) = height(box(n)) + depth(box(n));
-                best_ins_ptr(r) = null;
-            /*  q = skip(n); */
-q = skip(sk);
-                if (count(n) == 1000)
-                    h = height(r);
-                else
-                    h = x_over_n(height(r), 1000) * count(n);
-                page_goal = page_goal - h - width(q);
-                if (stretch_order(q) > 1)
-                    page_so_far[1 + stretch_order(q)] = page_so_far[1 + stretch_order(q)] + stretch(q);
-                else
-                    page_so_far[2 + stretch_order(q)] = page_so_far[2 + stretch_order(q)] + stretch(q);
-                page_shrink = page_shrink + shrink(q);
-                if ((shrink_order(q) != normal) && (shrink(q) != 0)) {
-                    print_err("Infinite glue shrinkage inserted from \\skip");
-                    print_int(n);
-                    help3
-                        ("The correction glue for page breaking with insertions",
-                         "must have finite shrinkability. But you may proceed,",
-                         "since the offensive shrinkability has been made finite.");
-                    error();
-                }
-
-            }
-            if (type(r) == split_up_node) {
-                insert_penalties = insert_penalties + float_cost(p);
-            } else {
-                last_ins_ptr(r) = p;
-                delta = page_goal - page_total - page_depth + page_shrink;
-                /* this much room is left if we shrink the maximum */
-                if (count(n) == 1000)
-                    h = height(p);
-                else
-                    h = x_over_n(height(p), 1000) * count(n);   /* this much room is needed */
-                if (((h <= 0) || (h <= delta))
-                    && (height(p) + height(r) <= dimen(n))) {
-                    page_goal = page_goal - h;
-                    height(r) = height(r) + height(p);
-                } else {
-                    /* Find the best way to split the insertion, and change
-                       |type(r)| to |split_up_node| */
-                    /* Here is the code that will split a long footnote between pages, in an
-                       emergency. The current situation deserves to be recapitulated: Node |p|
-                       is an insertion into box |n|; the insertion will not fit, in its entirety,
-                       either because it would make the total contents of box |n| greater than
-                       \.{\\dimen} |n|, or because it would make the incremental amount of growth
-                       |h| greater than the available space |delta|, or both. (This amount |h| has
-                       been weighted by the insertion scaling factor, i.e., by \.{\\count} |n|
-                       over 1000.) Now we will choose the best way to break the vlist of the
-                       insertion, using the same criteria as in the \.{\\vsplit} operation.
-                     */
-                    if (count(n) <= 0) {
-                        w = max_dimen;
-                    } else {
-                        w = page_goal - page_total - page_depth;
-                        if (count(n) != 1000)
-                            w = x_over_n(w, count(n)) * 1000;
-                    }
-                    if (w > dimen(n) - height(r))
-                        w = dimen(n) - height(r);
-                    q = vert_break(ins_ptr(p), w, depth(p));
-                    height(r) = height(r) + best_height_plus_depth;
-                    if (tracing_pages_par > 0) {
-                        /* Display the insertion split cost */
-                        begin_diagnostic();
-                        tprint_nl("% split");
-                        print_int(n);
-                        tprint(" to ");
-                        print_scaled(w);
-                        print_char(',');
-                        print_scaled(best_height_plus_depth);
-                        tprint(" p=");
-                        if (q == null)
-                            print_int(eject_penalty);
-                        else if (type(q) == penalty_node)
-                            print_int(penalty(q));
-                        else
-                            print_char('0');
-                        end_diagnostic(false);
-
-                    }
-                    if (count(n) != 1000)
-                        best_height_plus_depth =
-                            x_over_n(best_height_plus_depth, 1000) * count(n);
-                    page_goal = page_goal - best_height_plus_depth;
-                    type(r) = split_up_node;
-                    broken_ptr(r) = q;
-                    broken_ins(r) = p;
-                    if (q == null)
-                        insert_penalties = insert_penalties + eject_penalty;
-                    else if (type(q) == penalty_node)
-                        insert_penalties = insert_penalties + penalty(q);
-                }
-            }
-            goto CONTRIBUTE;
-
-            break;
-        default:
-            fprintf(stderr, "type(p)=%d\n", type(p));
-            confusion("page");
-            break;
-        }
-
-        /* Check if node |p| is a new champion breakpoint; then if it is time for
-           a page break, prepare for output, and either fire up the users
-           output routine and |return| or ship out the page and |goto done| */
-
-        if (pi < inf_penalty) {
-            /* Compute the badness, |b|, of the current page,
-               using |awful_bad| if the box is too full */
-            if (page_total < page_goal) {
-                if ((page_so_far[3] != 0) || (page_so_far[4] != 0) ||
-                    (page_so_far[5] != 0))
-                    b = 0;
-                else
-                    b = badness(page_goal - page_total, page_so_far[2]);
-            } else if (page_total - page_goal > page_shrink) {
-                b = awful_bad;
-            } else {
-                b = badness(page_total - page_goal, page_shrink);
-            }
-
-            if (b < awful_bad) {
-                if (pi <= eject_penalty)
-                    c = pi;
-                else if (b < inf_bad)
-                    c = b + pi + insert_penalties;
-                else
-                    c = deplorable;
-            } else {
-                c = b;
-            }
-            if (insert_penalties >= 10000)
-                c = awful_bad;
-            if (tracing_pages_par > 0) {
-                /* Display the page break cost */
-                begin_diagnostic();
-                tprint_nl("%");
-                tprint(" t=");
-                print_totals();
-                tprint(" g=");
-                print_scaled(page_goal);
-                tprint(" b=");
-                if (b == awful_bad)
-                    print_char('*');
-                else
-                    print_int(b);
-                tprint(" p=");
-                print_int(pi);
-                tprint(" c=");
-                if (c == awful_bad)
-                    print_char('*');
-                else
-                    print_int(c);
-                if (c <= least_page_cost)
-                    print_char('#');
-                end_diagnostic(false);
-
-            }
-            if (c <= least_page_cost) {
-                best_page_break = p;
-                best_size = page_goal;
-                least_page_cost = c;
-                r = vlink(page_ins_head);
-                while (r != page_ins_head) {
-                    best_ins_ptr(r) = last_ins_ptr(r);
-                    r = vlink(r);
-                }
-            }
-            if ((c == awful_bad) || (pi <= eject_penalty)) {
-                fire_up(p);     /* output the current page at the best place */
-                if (output_active)
-                    goto EXIT;  /* user's output routine will act */
-                goto DONE;      /* the page has been shipped out by default output routine */
-            }
-        }
-
-        if ((type(p) < glue_node) || (type(p) > kern_node))
-            goto CONTRIBUTE;
-
-      UPDATE_HEIGHTS:          /* go here to record glue in the |active_height| table */
-
-        /* Update the current page measurements with respect to the
-           glue or kern specified by node~|p| */
-        if (type(p) != kern_node) {
-            if (stretch_order(p) > 1)
-                page_so_far[1 + stretch_order(p)] = page_so_far[1 + stretch_order(p)] + stretch(p);
-            else
-                page_so_far[2 + stretch_order(p)] = page_so_far[2 + stretch_order(p)] + stretch(p);
-            page_shrink = page_shrink + shrink(p);
-            if ((shrink_order(p) != normal) && (shrink(p) != 0)) {
-                print_err("Infinite glue shrinkage found on current page");
-                help4("The page about to be output contains some infinitely",
-                      "shrinkable glue, e.g., `\\vss' or `\\vskip 0pt minus 1fil'.",
-                      "Such glue doesn't belong there; but you can safely proceed,",
-                      "since the offensive shrinkability has been made finite.");
-                error();
-                reset_glue_to_zero(p);
-                shrink_order(p) = normal;
-            }
-        }
-        page_total = page_total + page_depth + width(p);
-        page_depth = 0;
-
-      CONTRIBUTE:              /* go here to link a node into the current page */
-
-        /* Make sure that |page_max_depth| is not exceeded */
-        if (page_depth > page_max_depth) {
-            page_total = page_total + page_depth - page_max_depth;
-            page_depth = page_max_depth;
-        }
-
-        /* Link node |p| into the current page and |goto done| */
-        couple_nodes(page_tail, p);
-        page_tail = p;
-        try_couple_nodes(contrib_head,vlink(p));
-        vlink(p) = null;
-        goto DONE;
-      DONE1:
-        /* Recycle node |p| */
-        try_couple_nodes(contrib_head,vlink(p));
-        vlink(p) = null;
-        if (saving_vdiscards_par > 0) {
-            if (page_disc == null) {
-                page_disc = p;
-            } else {
-                couple_nodes(tail_page_disc, p);
-            }
-            tail_page_disc = p;
-        } else {
-            flush_node_list(p);
-        }
-      DONE:
-        ;
-    } while (vlink(contrib_head) != null);
-    /* Make the contribution list empty by setting its tail to |contrib_head| */
-    contrib_tail = contrib_head;
-  EXIT:
-    ;
-}
-
-@ When the page builder has looked at as much material as could appear before
-the next page break, it makes its decision. The break that gave minimum
-badness will be used to put a completed ``page'' into box \.{\\outputbox}, with insertions
-appended to their other boxes.
-
-We also set the values of |top_mark|, |first_mark|, and |bot_mark|. The
-program uses the fact that |bot_mark(x)<>null| implies |first_mark(x)<>null|;
-it also knows that |bot_mark(x)=null| implies |top_mark(x)=first_mark(x)=null|.
-
-The |fire_up| subroutine prepares to output the current page at the best
-place; then it fires up the user's output routine, if there is one,
-or it simply ships out the page. There is one parameter, |c|, which represents
-the node that was being contributed to the page when the decision to
-force an output was made.
-
-@c
-void fire_up(halfword c)
-{
-    halfword p, q, r, s;        /* nodes being examined and/or changed */
-    halfword prev_p;            /* predecessor of |p| */
-    int n;                      /* insertion box number */
-    boolean wait;               /* should the present insertion be held over? */
-    int save_vbadness;          /* saved value of |vbadness| */
-    scaled save_vfuzz;          /* saved value of |vfuzz| */
-    halfword save_split_top_skip;       /* saved value of |split_top_skip| */
-    halfword i;                 /* for looping through the marks */
-
-    /* Set the value of |output_penalty| */
-    if (type(best_page_break) == penalty_node) {
-        geq_word_define(int_base + output_penalty_code,
-                        penalty(best_page_break));
-        penalty(best_page_break) = inf_penalty;
-    } else {
-        geq_word_define(int_base + output_penalty_code, inf_penalty);
-    }
-
-    for (i = 0; i <= biggest_used_mark; i++) {
-        if (bot_mark(i) != null) {
-            if (top_mark(i) != null)
-                delete_token_ref(top_mark(i));
-            set_top_mark(i, bot_mark(i));
-            add_token_ref(top_mark(i));
-            delete_first_mark(i);
-        }
-    }
-    /* Put the optimal current page into box |output_box|, update |first_mark| and
-       |bot_mark|, append insertions to their boxes, and put the
-       remaining nodes back on the contribution list; */
-
-    /* As the page is finally being prepared for output,
-       pointer |p| runs through the vlist, with |prev_p| trailing behind;
-       pointer |q| is the tail of a list of insertions that
-       are being held over for a subsequent page. */
-
-    if (c == best_page_break)
-        best_page_break = null; /* |c| not yet linked in */
-    /* Ensure that box |output_box| is empty before output */
-    if (box(output_box_par) != null) {
-        print_err("\\box");
-        print_int(output_box_par);
-        tprint(" is not void");
-        help2("You shouldn't use \\box\\outputbox except in \\output routines.",
-              "Proceed, and I'll discard its present contents.");
-        box_error(output_box_par);
-    }
-
-    insert_penalties = 0;       /* this will count the number of insertions held over */
-    save_split_top_skip = split_top_skip_par;
-    if (holding_inserts_par <= 0) {
-        /* Prepare all the boxes involved in insertions to act as queues */
-        /* If many insertions are supposed to go into the same box, we want to know
-           the position of the last node in that box, so that we don't need to waste time
-           when linking further information into it. The |last_ins_ptr| fields of the
-           page insertion nodes are therefore used for this purpose during the
-           packaging phase. */
-
-        r = vlink(page_ins_head);
-        while (r != page_ins_head) {
-            if (best_ins_ptr(r) != null) {
-                n = subtype(r);
-                ensure_vbox(n);
-                if (box(n) == null)
-                    box(n) = new_null_box();
-                p = box(n) + list_offset;
-                while (vlink(p) != null)
-                    p = vlink(p);
-                last_ins_ptr(r) = p;
-            }
-            r = vlink(r);
-        }
-
-    }
-    q = hold_head;
-    vlink(q) = null;
-    prev_p = page_head;
-    p = vlink(prev_p);
-    while (p != best_page_break) {
-        if (type(p) == ins_node) {
-            if (holding_inserts_par <= 0) {
-                /* Either insert the material specified by node |p| into the
-                   appropriate box, or hold it for the next page;
-                   also delete node |p| from the current page */
-                /* We will set |best_ins_ptr:=null| and package the box corresponding to
-                   insertion node~|r|, just after making the final insertion into that box.
-                   If this final insertion is `|split_up_node|', the remainder after splitting
-                   and pruning (if any) will be carried over to the next page. */
-                r = vlink(page_ins_head);
-                while (subtype(r) != subtype(p))
-                    r = vlink(r);
-                if (best_ins_ptr(r) == null) {
-                    wait = true;
-                } else {
-                    wait = false;
-                    s = last_ins_ptr(r);
-                    vlink(s) = ins_ptr(p);
-                    if (best_ins_ptr(r) == p) {
-                        halfword t; /* was a global temp_ptr */
-                        /* Wrap up the box specified by node |r|, splitting node |p| if
-                           called for; set |wait:=true| if node |p| holds a remainder after
-                           splitting */
-                        if (type(r) == split_up_node) {
-                            if ((broken_ins(r) == p) && (broken_ptr(r) != null)) {
-                                while (vlink(s) != broken_ptr(r))
-                                    s = vlink(s);
-                                vlink(s) = null;
-                                split_top_skip_par = split_top_ptr(p);
-                                ins_ptr(p) =
-                                    prune_page_top(broken_ptr(r), false);
-                                if (ins_ptr(p) != null) {
-                                    t = vpack(ins_ptr(p), 0, additional, -1);
-                                    height(p) = height(t) + depth(t);
-                                    list_ptr(t) = null;
-                                    flush_node(t);
-                                    wait = true;
-                                }
-                            }
-                        }
-                        best_ins_ptr(r) = null;
-                        n = subtype(r);
-                        t = list_ptr(box(n));
-                        list_ptr(box(n)) = null;
-                        flush_node(box(n));
-                        box(n) = vpack(t, 0, additional, body_direction_par);
-
-                    } else {
-                        while (vlink(s) != null)
-                            s = vlink(s);
-                        last_ins_ptr(r) = s;
-                    }
-                }
-                /* Either append the insertion node |p| after node |q|, and remove it
-                   from the current page, or delete |node(p)| */
-                try_couple_nodes(prev_p, vlink(p));
-                vlink(p) = null;
-                if (wait) {
-                    couple_nodes(q, p);
-                    q = p;
-                    incr(insert_penalties);
-                } else {
-                    ins_ptr(p) = null;
-                    flush_node(p);
-                }
-                p = prev_p;
-
-            }
-        } else if (type(p) == mark_node) {
-            /* Update the values of |first_mark| and |bot_mark| */
-            if (first_mark(mark_class(p)) == null) {
-                set_first_mark(mark_class(p), mark_ptr(p));
-                add_token_ref(first_mark(mark_class(p)));
-            }
-            if (bot_mark(mark_class(p)) != null)
-                delete_token_ref(bot_mark(mark_class(p)));
-            set_bot_mark(mark_class(p), mark_ptr(p));
-            add_token_ref(bot_mark(mark_class(p)));
-
-        }
-        prev_p = p;
-        p = vlink(prev_p);
-    }
-    split_top_skip_par = save_split_top_skip;
-    /* Break the current page at node |p|, put it in box~|output_box|,
-       and put the remaining nodes on the contribution list */
-    /* When the following code is executed, the current page runs from node
-       |vlink(page_head)| to node |prev_p|, and the nodes from |p| to |page_tail|
-       are to be placed back at the front of the contribution list. Furthermore
-       the heldover insertions appear in a list from |vlink(hold_head)| to |q|; we
-       will put them into the current page list for safekeeping while the user's
-       output routine is active.  We might have |q=hold_head|; and |p=null| if
-       and only if |prev_p=page_tail|. Error messages are suppressed within
-       |vpackage|, since the box might appear to be overfull or underfull simply
-       because the stretch and shrink from the \.{\\skip} registers for inserts
-       are not actually present in the box. */
-
-    if (p != null) {
-        if (vlink(contrib_head) == null) {
-            contrib_tail = page_tail;
-        }
-        couple_nodes(page_tail,vlink(contrib_head));
-        couple_nodes(contrib_head, p);
-        vlink(prev_p) = null;
-    }
-    save_vbadness = vbadness_par;
-    vbadness_par = inf_bad;
-    save_vfuzz = vfuzz_par;
-    vfuzz_par = max_dimen;          /* inhibit error messages */
-    box(output_box_par) = filtered_vpackage(vlink(page_head),
-        best_size, exactly, page_max_depth, output_group, body_direction_par, 0, 0);
-    vbadness_par = save_vbadness;
-    vfuzz_par = save_vfuzz;
-    if (last_glue != max_halfword)
-        flush_node(last_glue);
-    /* Start a new current page */
-    start_new_page();           /* this sets |last_glue:=max_halfword| */
-    if (q != hold_head) {
-        vlink(page_head) = vlink(hold_head);
-        page_tail = q;
-    }
-
-    /* Delete the page-insertion nodes */
-    r = vlink(page_ins_head);
-    while (r != page_ins_head) {
-	    /* todo: couple */
-        q = vlink(r);
-        flush_node(r);
-        r = q;
-    }
-    vlink(page_ins_head) = page_ins_head;
-
-    for (i = 0; i <= biggest_used_mark; i++) {
-        if ((top_mark(i) != null) && (first_mark(i) == null)) {
-            set_first_mark(i, top_mark(i));
-            add_token_ref(top_mark(i));
-        }
-    }
-    if (output_routine_par != null) {
-        if (dead_cycles >= max_dead_cycles_par) {
-            /* Explain that too many dead cycles have occurred in a row */
-            print_err("Output loop---");
-            print_int(dead_cycles);
-            tprint(" consecutive dead cycles");
-            help3("I've concluded that your \\output is awry; it never does a",
-                  "\\shipout, so I'm shipping \\box\\outputbox out myself. Next time",
-                  "increase \\maxdeadcycles if you want me to be more patient!");
-            error();
-
-        } else {
-            /* Fire up the users output routine and |return| */
-            output_active = true;
-            incr(dead_cycles);
-            push_nest();
-            mode = -vmode;
-            prev_depth_par = ignore_depth;
-            mode_line_par = -line;
-            begin_token_list(output_routine_par, output_text);
-            new_save_level(output_group);
-            normal_paragraph();
-            scan_left_brace();
-            return;
-
-        }
-    }
-    /* Perform the default output routine */
-    /* The list of heldover insertions, running from |vlink(page_head)| to
-       |page_tail|, must be moved to the contribution list when the user has
-       specified no output routine. */
-    if (vlink(page_head) != null) {
-        if (vlink(contrib_head) == null) {
-            contrib_tail = page_tail;
-        } else {
-            vlink(page_tail) = vlink(contrib_head);
-        }
-        vlink(contrib_head) = vlink(page_head);
-        vlink(page_head) = null;
-        page_tail = page_head;
-    }
-    flush_node_list(page_disc);
-    page_disc = null;
-    ship_out(static_pdf, box(output_box_par), SHIPPING_PAGE);
-    box(output_box_par) = null;
-}
-
-@ When the user's output routine finishes, it has constructed a vlist
-in internal vertical mode, and \TeX\ will do the following:
-
-@c
-void resume_after_output(void)
-{
-    if ((iloc != null)
-        || ((token_type != output_text) && (token_type != backed_up))) {
-        /* Recover from an unbalanced output routine */
-        print_err("Unbalanced output routine");
-        help2("Your sneaky output routine has problematic {'s and/or }'s.",
-              "I can't handle that very well; good luck.");
-        error();
-        do {
-            get_token();
-        } while (iloc != null);
-        /* loops forever if reading from a file, since |null=min_halfword<=0| */
-
-    }
-    end_token_list();           /* conserve stack space in case more outputs are triggered */
-    end_graf(bottom_level);
-    unsave();
-    output_active = false;
-    insert_penalties = 0;
-    /* Ensure that box |output_box| is empty after output */
-    if (box(output_box_par) != null) {
-        print_err("Output routine didn't use all of \\box");
-        print_int(output_box_par);
-        help3("Your \\output commands should empty \\box\\outputbox,",
-              "e.g., by saying `\\shipout\\box\\outputbox'.",
-              "Proceed; I'll discard its present contents.");
-        box_error(output_box_par);
-    }
-
-    if (tail != head) {         /* current list goes after heldover insertions */
-        try_couple_nodes(page_tail, vlink(head));
-        page_tail = tail;
-    }
-    if (vlink(page_head) != null) {     /* and both go before heldover contributions */
-        if (vlink(contrib_head) == null)
-            contrib_tail = page_tail;
-        try_couple_nodes(page_tail, vlink(contrib_head));
-        try_couple_nodes(contrib_head, vlink(page_head));
-        vlink(page_head) = null;
-        page_tail = page_head;
-    }
-    flush_node_list(page_disc);
-    page_disc = null;
-    pop_nest();
-    normal_page_filter(after_output);
-    build_page();
-}
diff --git a/texk/web2c/luatexdir/tex/commands.w b/texk/web2c/luatexdir/tex/commands.c
similarity index 92%
rename from texk/web2c/luatexdir/tex/commands.w
rename to texk/web2c/luatexdir/tex/commands.c
index 38975eb16..aceb0eb09 100644
--- a/texk/web2c/luatexdir/tex/commands.w
+++ b/texk/web2c/luatexdir/tex/commands.c
@@ -1,34 +1,36 @@
-% commands.w
-%
-% Copyright 2009-2010 Taco Hoekwater <taco@@luatex.org>
-%
-% This file is part of LuaTeX.
-%
-% LuaTeX is free software; you can redistribute it and/or modify it under
-% the terms of the GNU General Public License as published by the Free
-% Software Foundation; either version 2 of the License, or (at your
-% option) any later version.
-%
-% LuaTeX is distributed in the hope that it will be useful, but WITHOUT
-% ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-% FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
-% License for more details.
-%
-% You should have received a copy of the GNU General Public License along
-% with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
-
-\def\eTeX{e-\TeX}
-
-@ @c
+/*
 
+commands.w
+
+Copyright 2009-2010 Taco Hoekwater <taco@@luatex.org>
+
+This file is part of LuaTeX.
+
+LuaTeX is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 2 of the License, or (at your
+option) any later version.
+
+LuaTeX is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+License for more details.
+
+You should have received a copy of the GNU General Public License along
+with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+
+*/
 
 #include "ptexlib.h"
 
-@ The symbolic names for glue parameters are put into \TeX's hash table
-by using the routine called |primitive|, defined below. Let us enter them
-now, so that we don't have to list all those parameter names anywhere else.
+/*tex
+
+The symbolic names for glue parameters are put into \TeX's hash table by using
+the routine called |primitive|, defined below. Let us enter them now, so that we
+don't have to list all those parameter names anywhere else.
+
+*/
 
-@c
 void initialize_commands(void)
 {
 
@@ -53,6 +55,9 @@ void initialize_commands(void)
     primitive_luatex("mathsurroundskip", assign_glue_cmd, glue_base + math_skip_code, glue_base);
     primitive_luatex("mathsurroundmode", assign_int_cmd, int_base + math_skip_mode_code, int_base);
     primitive_luatex("mathscriptboxmode", assign_int_cmd, int_base + math_script_box_mode_code, int_base);
+    primitive_luatex("mathscriptcharmode", assign_int_cmd, int_base + math_script_char_mode_code, int_base);
+    primitive_luatex("mathrulethicknessmode", assign_int_cmd, int_base + math_rule_thickness_mode_code, int_base);
+    primitive_luatex("mathflattenmode", assign_int_cmd, int_base + math_flatten_mode_code, int_base);
     primitive_tex("output", assign_toks_cmd, output_routine_loc, local_base);
     primitive_tex("everypar", assign_toks_cmd, every_par_loc, local_base);
     primitive_tex("everymath", assign_toks_cmd, every_math_loc, local_base);
@@ -63,7 +68,7 @@ void initialize_commands(void)
     primitive_tex("everycr", assign_toks_cmd, every_cr_loc, local_base);
     primitive_tex("errhelp", assign_toks_cmd, err_help_loc, local_base);
 
-    /* The integer parameter names must be entered into the hash table */
+    /*tex The integer parameter names must be entered into the hash table */
 
     primitive_tex("pretolerance", assign_int_cmd, int_base + pretolerance_code, int_base);
     primitive_tex("tolerance", assign_int_cmd, int_base + tolerance_code, int_base);
@@ -166,11 +171,18 @@ void initialize_commands(void)
     primitive_luatex("automatichyphenpenalty", assign_int_cmd, int_base + automatic_hyphen_penalty_code, int_base);
     primitive_luatex("explicithyphenpenalty", assign_int_cmd, int_base + explicit_hyphen_penalty_code, int_base);
     primitive_luatex("automatichyphenmode", assign_int_cmd, int_base + automatic_hyphen_mode_code, int_base);
+    primitive_luatex("compoundhyphenmode", assign_int_cmd, int_base + compound_hyphen_mode_code, int_base);
     primitive_luatex("breakafterdirmode", assign_int_cmd, int_base + break_after_dir_mode_code, int_base);
+    primitive_luatex("exceptionpenalty", assign_int_cmd, int_base + exception_penalty_code, int_base);
+    primitive_luatex("fixupboxesmode", assign_int_cmd, int_base + fixup_boxes_code, int_base);
+
+    /*tex
+
+    Many of \TeX's primitives need no |equiv|, since they are identifiable by
+    their |eq_type| alone. These primitives are loaded into the hash table as
+    follows:
 
-    /* Many of \TeX's primitives need no |equiv|, since they are identifiable
-       by their |eq_type| alone. These primitives are loaded into the hash table
-       as follows: */
+    */
 
     primitive_tex(" ", ex_space_cmd, 0, 0);
     primitive_tex("/", ital_corr_cmd, 0, 0);
@@ -240,29 +252,27 @@ void initialize_commands(void)
     primitive_tex("setbox", set_box_cmd, 0, 0);
     primitive_tex("the", the_cmd, 0, 0);
     primitive_luatex("toksapp", combine_toks_cmd, 0, 0);
-    primitive_luatex("tokspre", combine_toks_cmd, 1, 0);
-    primitive_luatex("etoksapp", combine_toks_cmd, 2, 0);
+    primitive_luatex("etoksapp", combine_toks_cmd, 1, 0);
+    primitive_luatex("tokspre", combine_toks_cmd, 2, 0);
     primitive_luatex("etokspre", combine_toks_cmd, 3, 0);
+    primitive_luatex("gtoksapp", combine_toks_cmd, 4, 0);
+    primitive_luatex("xtoksapp", combine_toks_cmd, 5, 0);
+    primitive_luatex("gtokspre", combine_toks_cmd, 6, 0);
+    primitive_luatex("xtokspre", combine_toks_cmd, 7, 0);
     primitive_tex("toks", toks_register_cmd, 0, 0);
     primitive_tex("vadjust", vadjust_cmd, 0, 0);
     primitive_tex("valign", valign_cmd, 0, 0);
     primitive_tex("vcenter", vcenter_cmd, 0, 0);
     primitive_tex("vrule", vrule_cmd, 0, 0);
     primitive_luatex("novrule", no_vrule_cmd, 0, 0);
-    primitive_tex("par", par_end_cmd, too_big_char, too_big_char);      /* cf.\ |scan_file_name| */
+    primitive_luatex("luafunctioncall", lua_function_call_cmd, 0, 0);
+    primitive_luatex("luabytecodecall", lua_bytecode_call_cmd, 0, 0);
+    primitive_luatex("luadef", def_lua_call_cmd, 0, 0);
+    primitive_tex("par", par_end_cmd, too_big_char, too_big_char);
     par_loc = cur_val;
     par_token = cs_token_flag + par_loc;
-    @<Create a bunch of primitives@>;
-    @<Create the math param primitives@>;
-    @<Create another bunch of primitives@>;
-}
-
 
-@ These are in a separate module due to a CWEAVE limitation.
-
-@<Create a bunch of primitives@>=
-
-    /*
+    /*tex
         The processing of \.{\\input} involves the |start_input| subroutine,
         which will be declared later; the processing of \.{\\endinput} is trivial.
     */
@@ -318,7 +328,7 @@ void initialize_commands(void)
     primitive_tex("number", convert_cmd, number_code, 0);
     primitive_tex("romannumeral", convert_cmd, roman_numeral_code, 0);
     primitive_tex("string", convert_cmd, string_code, 0);
-    primitive_tex("csstring", convert_cmd, cs_string_code, 0);
+    primitive_luatex("csstring", convert_cmd, cs_string_code, 0);
     primitive_tex("meaning", convert_cmd, meaning_code, 0);
     primitive_etex("eTeXVersion", convert_cmd, etex_code, 0);
     primitive_tex("fontname", convert_cmd, font_name_code, 0);
@@ -331,9 +341,12 @@ void initialize_commands(void)
     primitive_luatex("normaldeviate", convert_cmd, normal_deviate_code, 0);
     primitive_core("directlua", convert_cmd, lua_code, 0);
     primitive_luatex("luafunction", convert_cmd, lua_function_code, 0);
+    primitive_luatex("luabytecode", convert_cmd, lua_bytecode_code, 0);
     primitive_luatex("luaescapestring", convert_cmd, lua_escape_string_code, 0);
     primitive_luatex("mathstyle", convert_cmd, math_style_code, 0);
     primitive_luatex("expanded", convert_cmd, expanded_code, 0);
+    primitive_luatex("immediateassignment", convert_cmd, immediate_assignment_code, 0);
+    primitive_luatex("immediateassigned", convert_cmd, immediate_assigned_code, 0);
     primitive_tex("jobname", convert_cmd, job_name_code, 0);
     primitive_luatex("formatname", convert_cmd, format_name_code, 0);
     primitive_luatex("Uchar", convert_cmd, uchar_code, 0);
@@ -352,15 +365,15 @@ void initialize_commands(void)
     primitive_tex("ifmmode", if_test_cmd, if_mmode_code, 0);
     primitive_tex("ifinner", if_test_cmd, if_inner_code, 0);
     primitive_tex("ifvoid", if_test_cmd, if_void_code, 0);
-
     primitive_tex("ifhbox", if_test_cmd, if_hbox_code, 0);
     primitive_tex("ifvbox", if_test_cmd, if_vbox_code, 0);
-    primitive_tex("ifx", if_test_cmd, ifx_code, 0);
+    primitive_tex("ifx", if_test_cmd, if_x_code, 0);
     primitive_tex("ifeof", if_test_cmd, if_eof_code, 0);
     primitive_tex("iftrue", if_test_cmd, if_true_code, 0);
     primitive_tex("iffalse", if_test_cmd, if_false_code, 0);
     primitive_tex("ifcase", if_test_cmd, if_case_code, 0);
     primitive_luatex("ifprimitive", if_test_cmd, if_primitive_code, 0);
+    primitive_luatex("ifcondition", if_test_cmd, if_condition_code, 0);
     primitive_tex("fi", fi_or_else_cmd, fi_code, 0);
     cs_text(frozen_fi) = maketexstring("fi");
     eqtb[frozen_fi] = eqtb[cur_val];
@@ -435,12 +448,13 @@ void initialize_commands(void)
     primitive_tex("vtop", make_box_cmd, vtop_code, 0);
     primitive_tex("vbox", make_box_cmd, vtop_code + vmode, 0);
     primitive_tex("hbox", make_box_cmd, vtop_code + hmode, 0);
-    primitive_tex("shipout", leader_ship_cmd, a_leaders - 1, 0);        /* |ship_out_flag=leader_flag-1| */
+    primitive_tex("shipout", leader_ship_cmd, a_leaders - 2, 0);        /* |ship_out_flag=leader_flag-2| */
     primitive_tex("leaders", leader_ship_cmd, a_leaders, 0);
     primitive_tex("cleaders", leader_ship_cmd, c_leaders, 0);
     primitive_tex("xleaders", leader_ship_cmd, x_leaders, 0);
     primitive_luatex("gleaders", leader_ship_cmd, g_leaders, 0);
     primitive_luatex("boxdir", assign_box_dir_cmd, 0, 0);
+    primitive_luatex("boxdirection", assign_box_direction_cmd, 0, 0);
     primitive_tex("indent", start_par_cmd, 1, 0);
     primitive_tex("noindent", start_par_cmd, 0, 0);
     primitive_luatex("quitvmode", start_par_cmd, 2, 0);
@@ -514,9 +528,10 @@ void initialize_commands(void)
     primitive_tex("gdef", def_cmd, 1, 0);
     primitive_tex("edef", def_cmd, 2, 0);
     primitive_tex("xdef", def_cmd, 3, 0);
-    primitive_tex("let", let_cmd, normal, 0);
-    primitive_tex("futurelet", let_cmd, normal + 1, 0);
-    primitive_luatex("letcharcode", let_cmd, normal + 2, 0);
+    primitive_tex("glet", let_cmd, 0, 0);
+    primitive_tex("let", let_cmd, 1, 0);
+    primitive_tex("futurelet", let_cmd, 2, 0);
+    primitive_luatex("letcharcode", let_cmd, 3, 0);
     primitive_tex("chardef", shorthand_def_cmd, char_def_code, 0);
     primitive_tex("mathchardef", shorthand_def_cmd, math_char_def_code, 0);
     primitive_luatex("Umathchardef", shorthand_def_cmd, xmath_char_def_code, 0);
@@ -539,9 +554,6 @@ void initialize_commands(void)
     primitive_luatex("Umathquad", set_math_param_cmd, math_param_quad, 0);
     primitive_luatex("Umathaxis", set_math_param_cmd, math_param_axis, 0);
 
-@ These are in a separate module due to a CWEAVE limitation.
-
-@<Create the math param primitives@>=
     primitive_luatex("Umathoperatorsize", set_math_param_cmd, math_param_operator_size, 0);
     primitive_luatex("Umathoverbarkern", set_math_param_cmd, math_param_overbar_kern, 0);
     primitive_luatex("Umathoverbarrule", set_math_param_cmd, math_param_overbar_rule, 0);
@@ -654,9 +666,6 @@ void initialize_commands(void)
     primitive_luatex("Umathinnerpunctspacing", set_math_param_cmd, math_param_inner_punct_spacing, 0);
     primitive_luatex("Umathinnerinnerspacing", set_math_param_cmd, math_param_inner_inner_spacing, 0);
 
-@ These are in a separate module due to a CWEAVE limitation.
-
-@<Create another bunch of primitives@>=
     primitive_luatex("Umathcode", extdef_math_code_cmd, math_code_base, math_code_base);
     primitive_luatex("Udelcode", extdef_del_code_cmd, del_code_base, del_code_base);
     primitive_luatex("Umathcodenum", extdef_math_code_cmd, math_code_base + 1, math_code_base);
@@ -695,6 +704,7 @@ void initialize_commands(void)
     primitive_tex("write", extension_cmd, write_code, 0);
     write_loc = cur_val;
     primitive_tex("closeout", extension_cmd, close_code, 0);
+    primitive_luatex("endlocalcontrol", extension_cmd, end_local_code, 0);
     primitive_tex("special", extension_cmd, special_code, 0);
     cs_text(frozen_special) = maketexstring("special");
     eqtb[frozen_special] = eqtb[cur_val];
@@ -720,6 +730,7 @@ void initialize_commands(void)
     primitive_luatex("initcatcodetable", normal_cmd, init_cat_code_table_code, 0);
     primitive_luatex("setrandomseed", normal_cmd, set_random_seed_code, 0);
     primitive_luatex("latelua", normal_cmd, late_lua_code, 0);
+    primitive_luatex("lateluafunction", normal_cmd, late_lua_call_code, 0);
     primitive_luatex("insertht", convert_cmd, insert_ht_code, 0);
     primitive_luatex("dviextension", extension_cmd, dvi_extension_code, 0);
     primitive_luatex("dvifeedback", feedback_cmd, dvi_feedback_code, 0);
@@ -729,6 +740,15 @@ void initialize_commands(void)
     primitive_luatex("pdfvariable", variable_cmd, pdf_variable_code, 0);
     primitive_luatex("mathoption", option_cmd, math_option_code, 0);
 
+    primitive_luatex("luacopyinputnodes", assign_int_cmd, int_base + copy_lua_input_nodes_code, int_base);
+
+    primitive_luatex("pagedirection", assign_direction_cmd, int_base + page_direction_code, dir_base);
+    primitive_luatex("bodydirection", assign_direction_cmd, int_base + body_direction_code, dir_base);
+    primitive_luatex("pardirection",  assign_direction_cmd, int_base + par_direction_code,  dir_base);
+    primitive_luatex("textdirection", assign_direction_cmd, int_base + text_direction_code, dir_base);
+    primitive_luatex("mathdirection", assign_direction_cmd, int_base + math_direction_code, dir_base);
+    primitive_luatex("linedirection", assign_direction_cmd, int_base + line_direction_code, dir_base);
+
     /*
         some of the internal integer parameters are not associated with actual
         primitives at all.
@@ -737,8 +757,8 @@ void initialize_commands(void)
     primitive_no("nolocalwhatsits", assign_int_cmd, int_base + no_local_whatsits_code, int_base);
     primitive_no("nolocaldirs", assign_int_cmd, int_base + no_local_dirs_code, int_base);
 
+}
 
-@ @c
 void initialize_etex_commands(void)
 {
     primitive_etex("lastnodetype", last_item_cmd, last_node_type_code, 0);
@@ -746,8 +766,10 @@ void initialize_etex_commands(void)
     primitive_etex("eTeXminorversion", last_item_cmd, eTeX_minor_version_code, 0);
     primitive_etex("eTeXrevision", convert_cmd, eTeX_revision_code, 0);
 
-    /*
-        First we implement the additional \eTeX\ parameters in the table of equivalents.
+    /*tex
+
+        First we implement the additional \eTeX\ parameters in the table of
+        equivalents.
     */
 
     primitive_etex("everyeof", assign_toks_cmd, every_eof_loc, local_base);
@@ -795,39 +817,48 @@ void initialize_etex_commands(void)
 
     primitive_etex("showgroups", xray_cmd, show_groups, 0);
 
-    /*
+    /*tex
+
         The \.{\\showtokens} command displays a token list.
+
     */
 
     primitive_etex("showtokens", xray_cmd, show_tokens, 0);
 
-    /*
-        The \.{\\unexpanded} primitive prevents expansion of tokens much as
-        the result from \.{\\the} applied to a token variable.  The
-        \.{\\detokenize} primitive converts a token list into a list of
-        character tokens much as if the token list were written to a file.  We
-        use the fact that the command modifiers for \.{\\unexpanded} and
-        \.{\\detokenize} are odd whereas those for \.{\\the} and \.{\\showthe}
-        are even.
+    /*tex
+
+        The \.{\\unexpanded} primitive prevents expansion of tokens much as the
+        result from \.{\\the} applied to a token variable. The \.{\\detokenize}
+        primitive converts a token list into a list of character tokens much as
+        if the token list were written to a file. We use the fact that the
+        command modifiers for \.{\\unexpanded} and \.{\\detokenize} are odd
+        whereas those for \.{\\the} and \.{\\showthe} are even.
+
     */
 
     primitive_etex("unexpanded", the_cmd, 1, 0);
     primitive_etex("detokenize", the_cmd, show_tokens, 0);
 
-    /*
+    /*tex
+
         The \.{\\showifs} command displays all currently active conditionals.
+
     */
 
     primitive_etex("showifs", xray_cmd, show_ifs, 0);
 
-    /*
+    /*tex
+
         The \.{\\interactionmode} primitive allows to query and set the interaction mode.
+
     */
 
     primitive_etex("interactionmode", set_page_int_cmd, 2, 0);
 
-    /*
+    /*tex
+
         The |scan_tokens| feature of \eTeX\ defines the \.{\\scantokens} primitive.
+
     */
 
     primitive_etex("scantokens", input_cmd, 2, 0);
@@ -843,7 +874,8 @@ void initialize_etex_commands(void)
     primitive_luatex("ifabsnum", if_test_cmd, if_abs_num_code, 0);
     primitive_luatex("ifabsdim", if_test_cmd, if_abs_dim_code, 0);
 
-    /*
+    /*tex
+
         The |protected| feature of \eTeX\ defines the \.{\\protected} prefix
         command for macro definitions.  Such macros are protected against
         expansions when lists of expanded tokens are built, e.g., for \.{\\edef}
@@ -852,8 +884,10 @@ void initialize_etex_commands(void)
 
     primitive_etex("protected", prefix_cmd, 8, 0);
 
-    /*
+    /*tex
+
         Here are the additional \eTeX\ primitives for expressions.
+
     */
 
     primitive_etex("numexpr", last_item_cmd, eTeX_expr - int_val_level + int_val_level, 0);
@@ -869,21 +903,25 @@ void initialize_etex_commands(void)
     primitive_etex("mutoglue", last_item_cmd, mu_to_glue_code, 0);
     primitive_etex("gluetomu", last_item_cmd, glue_to_mu_code, 0);
 
-    /*
-        The \.{\\pagediscards} and \.{\\splitdiscards} commands share the
-        command code |un_vbox| with \.{\\unvbox} and \.{\\unvcopy}, they are
+    /*tex
+
+        The \.{\\pagediscards} and \.{\\splitdiscards} commands share the command
+        code |un_vbox| with \.{\\unvbox} and \.{\\unvcopy}, they are
         distinguished by their |chr_code| values |last_box_code| and
-        |vsplit_code|.  These |chr_code| values are larger than |box_code| and
+        |vsplit_code|. These |chr_code| values are larger than |box_code| and
         |copy_code|.
+
     */
 
     primitive_etex("pagediscards", un_vbox_cmd, last_box_code, 0);
     primitive_etex("splitdiscards", un_vbox_cmd, vsplit_code, 0);
 
-    /*
+    /*tex
+
         The \.{\\interlinepenalties}, \.{\\clubpenalties}, \.{\\widowpenalties},
         and \.{\\displaywidowpenalties} commands allow to define arrays of
         penalty values to be used instead of the corresponding single values.
+
     */
 
     primitive_etex("interlinepenalties", set_etex_shape_cmd, inter_line_penalties_loc, etex_pen_base);
diff --git a/texk/web2c/luatexdir/tex/conditional.w b/texk/web2c/luatexdir/tex/conditional.c
similarity index 61%
rename from texk/web2c/luatexdir/tex/conditional.w
rename to texk/web2c/luatexdir/tex/conditional.c
index 318775141..948db5803 100644
--- a/texk/web2c/luatexdir/tex/conditional.w
+++ b/texk/web2c/luatexdir/tex/conditional.c
@@ -1,67 +1,73 @@
-% conditional.w
-%
-% Copyright 2009-2010 Taco Hoekwater <taco@@luatex.org>
-%
-% This file is part of LuaTeX.
-%
-% LuaTeX is free software; you can redistribute it and/or modify it under
-% the terms of the GNU General Public License as published by the Free
-% Software Foundation; either version 2 of the License, or (at your
-% option) any later version.
-%
-% LuaTeX is distributed in the hope that it will be useful, but WITHOUT
-% ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-% FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
-% License for more details.
-%
-% You should have received a copy of the GNU General Public License along
-% with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
-
-@ @c
+/*
+
+conditional.w
+
+Copyright 2009-2010 Taco Hoekwater <taco@@luatex.org>
+
+This file is part of LuaTeX.
+
+LuaTeX is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 2 of the License, or (at your
+option) any later version.
+
+LuaTeX is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+License for more details.
+
+You should have received a copy of the GNU General Public License along
+with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+
+*/
 
 #include "ptexlib.h"
 
+/*tex
+
 @* We consider now the way \TeX\ handles various kinds of \.{\\if} commands.
 
-@ Conditions can be inside conditions, and this nesting has a stack
-that is independent of the |save_stack|.
-
-Four global variables represent the top of the condition stack:
-|cond_ptr| points to pushed-down entries, if any; |if_limit| specifies
-the largest code of a |fi_or_else| command that is syntactically legal;
-|cur_if| is the name of the current type of conditional; and |if_line|
-is the line number at which it began.
-
-If no conditions are currently in progress, the condition stack has the
-special state |cond_ptr=null|, |if_limit=normal|, |cur_if=0|, |if_line=0|.
-Otherwise |cond_ptr| points to a two-word node; the |type|, |subtype|, and
-|link| fields of the first word contain |if_limit|, |cur_if|, and
-|cond_ptr| at the next level, and the second word contains the
-corresponding |if_line|.
-
-@c
-halfword cond_ptr;              /* top of the condition stack */
-int if_limit;                   /* upper bound on |fi_or_else| codes */
-int cur_if;                     /* type of conditional being worked on */
-int if_line;                    /* line where that conditional began */
-
-@ When we skip conditional text, we keep track of the line number
-where skipping began, for use in error messages.
-
-@c
-int skip_line;                  /* skipping began here */
-
-@ Here is a procedure that ignores text until coming to an \.{\\or},
-\.{\\else}, or \.{\\fi} at level zero of $\.{\\if}\ldots\.{\\fi}$
-nesting. After it has acted, |cur_chr| will indicate the token that
-was found, but |cur_tok| will not be set (because this makes the
-procedure run faster).
-
-@c
+Conditions can be inside conditions, and this nesting has a stack that is
+independent of the |save_stack|.
+
+Four global variables represent the top of the condition stack: |cond_ptr| points
+to pushed-down entries, if any; |if_limit| specifies the largest code of a
+|fi_or_else| command that is syntactically legal; |cur_if| is the name of the
+current type of conditional; and |if_line| is the line number at which it began.
+
+If no conditions are currently in progress, the condition stack has the special
+state |cond_ptr=null|, |if_limit=normal|, |cur_if=0|, |if_line=0|. Otherwise
+|cond_ptr| points to a two-word node; the |type|, |subtype|, and |link| fields of
+the first word contain |if_limit|, |cur_if|, and |cond_ptr| at the next level,
+and the second word contains the corresponding |if_line|.
+
+In |cond_ptr| we keep track of the top of the condition stack while |if_limit|
+holds the upper bound on |fi_or_else| codes. The type of conditional being worked
+on is stored in cur_if and |if_line| keeps track of the line where that
+conditional began. When we skip conditional text, |skip_line| keeps track of the
+line number where skipping began, for use in error messages.
+
+*/
+
+halfword cond_ptr;
+int if_limit, cur_if, if_line, skip_line;
+
+/*tex
+
+Here is a procedure that ignores text until coming to an \.{\\or}, \.{\\else}, or
+\.{\\fi} at level zero of $\.{\\if}\ldots\.{\\fi}$ nesting. After it has acted,
+|cur_chr| will indicate the token that was found, but |cur_tok| will not be set
+(because this makes the procedure run faster).
+
+With |l| we keep track of the level of $\.{\\if}\ldots\.{\\fi}$ nesting and
+|scanner_status| let us return to the entry status.
+
+*/
+
 void pass_text(void)
 {
-    int l = 0;                                /* level of $\.{\\if}\ldots\.{\\fi}$ nesting */
-    int save_scanner_status = scanner_status; /* |scanner_status| upon entry */
+    int l = 0;
+    int save_scanner_status = scanner_status;
     scanner_status = skipping;
     skip_line = line;
     while (1) {
@@ -80,13 +86,16 @@ void pass_text(void)
         show_cur_cmd_chr();
 }
 
-@ When we begin to process a new \.{\\if}, we set |if_limit:=if_code|; then
-if\/ \.{\\or} or \.{\\else} or \.{\\fi} occurs before the current \.{\\if}
-condition has been evaluated, \.{\\relax} will be inserted.
-For example, a sequence of commands like `\.{\\ifvoid1\\else...\\fi}'
-would otherwise require something after the `\.1'.
+/*tex
+
+When we begin to process a new \.{\\if}, we set |if_limit:=if_code|; then if\/
+\.{\\or} or \.{\\else} or \.{\\fi} occurs before the current \.{\\if} condition
+has been evaluated, \.{\\relax} will be inserted. For example, a sequence of
+commands like `\.{\\ifvoid1\\else...\\fi}' would otherwise require something
+after the `\.1'.
+
+*/
 
-@c
 void push_condition_stack(void)
 {
     halfword p = new_node(if_node, 0);
@@ -103,9 +112,10 @@ void push_condition_stack(void)
 void pop_condition_stack(void)
 {
     halfword p;
-    if (if_stack[in_open] == cond_ptr)
+    if (if_stack[in_open] == cond_ptr) {
+        /*tex Conditionals are possibly not properly nested with files. */
         if_warning();
-    /* conditionals possibly not properly nested with files */
+    }
     p = cond_ptr;
     if_line = if_line_field(p);
     cur_if = if_limit_subtype(p);
@@ -114,14 +124,16 @@ void pop_condition_stack(void)
     flush_node(p);
 }
 
-@ Here's a procedure that changes the |if_limit| code corresponding to
-a given value of |cond_ptr|.
+/*tex
+
+Here's a procedure that changes the |if_limit| code corresponding to a given
+value of |cond_ptr|.
+
+*/
 
-@c
 void change_if_limit(int l, halfword p)
 {
     if (p == cond_ptr) {
-        /* that's the easy case */
         if_limit = l;
     } else {
         halfword q = cond_ptr;
@@ -137,22 +149,29 @@ void change_if_limit(int l, halfword p)
     }
 }
 
-@ The conditional \.{\\ifcsname} is equivalent to \.{\\expandafter}
-\.{\\expandafter} \.{\\ifdefined} \.{\\csname}, except that no new
-control sequence will be entered into the hash table (once all tokens
-preceding the mandatory \.{\\endcsname} have been expanded).
+/*tex
+
+The conditional \.{\\ifcsname} is equivalent to \.{\\expandafter}
+\.{\\expandafter} \.{\\ifdefined} \.{\\csname}, except that no new control
+sequence will be entered into the hash table (once all tokens preceding the
+mandatory \.{\\endcsname} have been expanded).
+
+*/
 
-@c
 static halfword last_tested_cs ;
 
 static boolean test_for_cs(void)
 {
-    boolean b = false;          /*is the condition true? */
-    int m, s;                   /*to be tested against the second operand */
-    halfword q;                 /*for traversing token lists in \.{\\ifx} tests */
+    /*tex Is the condition true? */
+    boolean b = false;
+    /*tex To be tested against the second operand: */
+    int m, s;
+    /*tex For traversing token lists in \.{\\ifx} tests: */
+    halfword q;
     halfword n = get_avail();
-    halfword p = n;             /*head of the list of characters */
-is_in_csname += 1;
+    /*tex Head of the list of characters: */
+    halfword p = n;
+    is_in_csname += 1;
     while (1) {
         get_x_token();
         if (cur_cs != 0)
@@ -166,13 +185,13 @@ is_in_csname += 1;
                 get_x_token();
             } while (cur_cmd != end_cs_name_cmd);
             flush_list(n);
-is_in_csname -= 1;
+            is_in_csname -= 1;
             return b;
         } else {
             complain_missing_csname();
         }
     }
-    /* Look up the characters of list |n| in the hash table, and set |cur_cs| */
+    /*tex Look up the characters of list |n| in the hash table, and set |cur_cs|. */
     m = first;
     p = token_link(n);
     while (p != null) {
@@ -200,21 +219,26 @@ is_in_csname -= 1;
         p = token_link(p);
     }
     if (m > first) {
-        cur_cs = id_lookup(first, m - first);  /* |no_new_control_sequence| is |true| */
+        /*tex |no_new_control_sequence| is |true| */
+        cur_cs = id_lookup(first, m - first);
     } else if (m == first) {
-        cur_cs = null_cs;                      /* the list is empty */
+        /*tex the list is empty */
+        cur_cs = null_cs;
     }
     b = (eq_type(cur_cs) != undefined_cs_cmd);
     flush_list(n);
     last_cs_name = cur_cs;
-is_in_csname -= 1;
+    is_in_csname -= 1;
     return b;
 }
 
-@ An active character will be treated as category 13 following
-\.{\\if\\noexpand} or following \.{\\ifcat\\noexpand}.
+/*tex
+
+An active character will be treated as category 13 following \.{\\if\\noexpand}
+or following \.{\\ifcat\\noexpand}.
+
+*/
 
-@c
 #define get_x_token_or_active_char() do { \
     get_x_token(); \
     if (cur_cmd==relax_cmd && cur_chr==no_expand_flag) { \
@@ -225,36 +249,47 @@ is_in_csname -= 1;
     } \
 } while (0)
 
-@ A condition is started when the |expand| procedure encounters
-an |if_test| command; in that case |expand| reduces to |conditional|,
-which is a recursive procedure.
-@^recursion@>
+/*tex
+
+A condition is started when the |expand| procedure encounters an |if_test|
+command; in that case |expand| reduces to |conditional|, which is a recursive
+procedure. @^recursion@>
+
+*/
 
-@c
 void conditional(void)
 {
-    boolean b = false;          /*is the condition true? */
-    int r;                      /*relation to be evaluated */
-    int m, n;                   /*to be tested against the second operand */
-    halfword p, q;              /*for traversing token lists in \.{\\ifx} tests */
-    int save_scanner_status;    /*|scanner_status| upon entry */
-    halfword save_cond_ptr;     /*|cond_ptr| corresponding to this conditional */
-    int this_if;                /*type of this conditional */
-    boolean is_unless;          /*was this if preceded by `\.{\\unless}' ? */
-    if ((tracing_ifs_par > 0) && (tracing_commands_par <= 1))
+    /*tex Is the condition true? */
+    boolean b = false;
+    /*tex The relation to be evaluated: */
+    int r;
+    /*tex To be tested against the second operand: */
+    int m, n;
+    /*tex For traversing token lists in \.{\\ifx} tests: */
+    halfword p, q;
+    /*tex The |scanner_status| upon entry: */
+    int save_scanner_status;
+    /*tex The |cond_ptr| corresponding to this conditional: */
+    halfword save_cond_ptr;
+    /*tex The type of this conditional: */
+    int this_if;
+    /*tex Was this \.{\\if} preceded by \.{\\unless}? */
+    boolean is_unless;
+    if ((tracing_ifs_par > 0) && (tracing_commands_par <= 1)) {
         show_cur_cmd_chr();
+    }
     push_condition_stack();
     save_cond_ptr = cond_ptr;
     is_unless = (cur_chr >= unless_code);
     this_if = cur_chr % unless_code;
-    /* Either process \.{\\ifcase} or set |b| to the value of a boolean condition */
+    /*tex Either process \.{\\ifcase} or set |b| to the value of a boolean condition. */
     switch (this_if) {
         case if_char_code:
         case if_cat_code:
-            /* Test if two characters match */
+            /*tex Test if two characters match. */
             get_x_token_or_active_char();
             if ((cur_cmd > active_char_cmd) || (cur_chr > biggest_char)) {
-                /*not a character */
+                /*tex It's not a character. */
                 m = relax_cmd;
                 n = too_big_char;
             } else {
@@ -275,8 +310,10 @@ void conditional(void)
         case if_dim_code:
         case if_abs_dim_code:
         case if_abs_num_code:
-            /* Test relation between integers or dimensions */
-            /* Here we use the fact that |"<"|, |"="|, and |">"| are consecutive ASCII codes. */
+            /*tex
+                Test the relation between integers or dimensions. Here we use the fact
+                that |<|, |=|, and |>| are consecutive ASCII codes.
+            */
             if (this_if == if_int_code || this_if == if_abs_num_code)
                 scan_int();
             else
@@ -284,15 +321,10 @@ void conditional(void)
             n = cur_val;
             if ((n < 0) && (this_if == if_abs_dim_code || this_if == if_abs_num_code))
                 negate(n);
-            /* Get the next non-blank non-call... */
+            /*tex Get the next non-blank non-call... */
             do {
                 get_x_token();
             } while (cur_cmd == spacer_cmd);
-            /*
-            if ((cur_tok >= other_token + '<') && (cur_tok <= other_token + '>')) {
-               r = cur_tok - other_token;
-            } else {
-            */
             r = cur_tok - other_token;
             if ((r < '<') || (r > '>')) {
                 print_err("Missing = inserted for ");
@@ -318,13 +350,13 @@ void conditional(void)
                     b = (n > cur_val);
                     break;
                 default:
-                    /* can't happen */
+                    /*tex This can't happen. */
                     b = false;
                     break;
             }
             break;
         case if_odd_code:
-            /* Test if an integer is odd */
+            /*tex Test if an integer is odd. */
             scan_int();
             b = odd(cur_val);
             break;
@@ -340,22 +372,6 @@ void conditional(void)
         case if_inner_code:
             b = (cur_list.mode_field < 0);
             break;
-        /*
-        case if_void_code:
-        case if_hbox_code:
-        case if_vbox_code:
-            scan_register_num();
-            p = box(cur_val);
-            if (this_if == if_void_code)
-                b = (p == null);
-            else if (p == null)
-                b = false;
-            else if (this_if == if_hbox_code)
-                b = (type(p) == hlist_node);
-            else
-                b = (type(p) == vlist_node);
-            break;
-        */
         case if_void_code:
             scan_register_num();
             p = box(cur_val);
@@ -371,16 +387,15 @@ void conditional(void)
             p = box(cur_val);
             b = (p != null) && (type(p) == vlist_node);
             break;
-        case ifx_code:
-            /*
-                Test if two tokens match
-
-                Note that `\.{\\ifx}' will declare two macros different if one is \\{long}
-                or \\{outer} and the other isn't, even though the texts of the macros are
-                the same.
+        case if_x_code:
+            /*tex
+                Test if two tokens match. Note that `\.{\\ifx}' will declare two
+                macros different if one is \\{long} or \\{outer} and the other
+                isn't, even though the texts of the macros are the same.
 
-                We need to reset |scanner_status|, since \.{\\outer} control sequences
-                are allowed, but we might be scanning a macro definition or preamble.
+                We need to reset |scanner_status|, since \.{\\outer} control
+                sequences are allowed, but we might be scanning a macro
+                definition or preamble.
              */
             save_scanner_status = scanner_status;
             scanner_status = normal;
@@ -394,11 +409,10 @@ void conditional(void)
             } else if (cur_cmd < call_cmd) {
                 b = (cur_chr == q);
             } else {
-                /*
-                    Test if two macro texts match
-
-                    Note also that `\.{\\ifx}' decides that macros \.{\\a} and \.{\\b} are
-                    different in examples like this:
+                /*tex
+                    Test if two macro texts match. Note also that `\.{\\ifx}'
+                    decides that macros \.{\\a} and \.{\\b} are different in
+                    examples like this:
 
                     $$\vbox{\halign{\.{#}\hfil&\qquad\.{#}\hfil\cr
                     {}\\def\\a\{\\c\}&
@@ -407,7 +421,7 @@ void conditional(void)
                     {}\\def\\d\{\}\cr}}$$
                 */
                 p = token_link(cur_chr);
-                /*omit reference counts */
+                /*tex Omit reference counts. */
                 q = token_link(equiv(n));
                 if (p == q) {
                     b = true;
@@ -437,9 +451,9 @@ void conditional(void)
             b = false;
             break;
         case if_case_code:
-            /* Select the appropriate case and |return| or |goto common_ending| */
+            /*tex Select the appropriate case and |return| or |goto common_ending|. */
             scan_int();
-            /* |n| is the number of cases to pass */
+            /*tex |n| is the number of cases to pass. */
             n = cur_val;
             if (tracing_commands_par > 1) {
                 begin_diagnostic();
@@ -460,7 +474,7 @@ void conditional(void)
                 }
             }
             change_if_limit(or_code, save_cond_ptr);
-            /*wait for \.{\\or}, \.{\\else}, or \.{\\fi} */
+            /*tex Wait for \.{\\or}, \.{\\else}, or \.{\\fi}. */
             return;
             break;
         case if_primitive_code:
@@ -475,10 +489,11 @@ void conditional(void)
                  (cur_chr == get_prim_equiv(m)));
             break;
         case if_def_code:
-            /*
-                The conditional \.{\\ifdefined} tests if a control sequence is defined.
-                We need to reset |scanner_status|, since \.{\\outer} control sequences
-                are allowed, but we might be scanning a macro definition or preamble.
+            /*tex
+                The conditional \.{\\ifdefined} tests if a control sequence is
+                defined. We need to reset |scanner_status|, since \.{\\outer}
+                control sequences are allowed, but we might be scanning a macro
+                definition or preamble.
             */
             save_scanner_status = scanner_status;
             scanner_status = normal;
@@ -493,9 +508,9 @@ void conditional(void)
             b = is_in_csname;
             break;
         case if_font_char_code:
-            /*
-                The conditional \.{\\iffontchar} tests the existence of a character in
-                a font.
+            /*tex
+                The conditional \.{\\iffontchar} tests the existence of a
+                character in a font.
             */
             scan_font_ident();
             n = cur_val;
@@ -503,13 +518,13 @@ void conditional(void)
             b = char_exists(n, cur_val);
             break;
         default:
-            /* there are no other cases, but for -Wall: */
+            /*tex there are no other cases, but we need to please |-Wall|. */
             b = false;
     }
     if (is_unless)
         b = !b;
     if (tracing_commands_par > 1) {
-        /* Display the value of |b| */
+        /*tex Display the value of |b|. */
         begin_diagnostic();
         if (b)
             tprint("{true}");
@@ -519,16 +534,15 @@ void conditional(void)
     }
     if (b) {
         change_if_limit(else_code, save_cond_ptr);
-        /*wait for \.{\\else} or \.{\\fi} */
+        /*tex Wait for \.{\\else} or \.{\\fi}. */
         return;
     }
-    /*
-        Skip to \.{\\else} or \.{\\fi}, then |goto common_ending|
-
-        In a construction like `\.{\\if\\iftrue abc\\else d\\fi}', the first
+    /*tex
+        Skip to \.{\\else} or \.{\\fi}, then |goto common_ending|. In a
+        construction like `\.{\\if\\iftrue abc\\else d\\fi}', the first
         \.{\\else} that we come to after learning that the \.{\\if} is false is
-        not the \.{\\else} we're looking for. Hence the following curious
-        logic is needed.
+        not the \.{\\else} we're looking for. Hence the following curious logic
+        is needed.
      */
     while (1) {
         pass_text();
@@ -536,7 +550,9 @@ void conditional(void)
             if (cur_chr != or_code)
                 goto COMMON_ENDING;
             print_err("Extra \\or");
-            help1("I'm ignoring this; it doesn't match any \\if.");
+            help1(
+                "I'm ignoring this; it doesn't match any \\if."
+            );
             error();
         } else if (cur_chr == fi_code) {
             pop_condition_stack();
@@ -546,7 +562,7 @@ void conditional(void)
     if (cur_chr == fi_code) {
         pop_condition_stack();
     } else {
-        /*wait for \.{\\fi} */
+        /*tex Wait for \.{\\fi}. */
         if_limit = fi_code;
     }
 }
diff --git a/texk/web2c/luatexdir/tex/directions.w b/texk/web2c/luatexdir/tex/directions.c
similarity index 61%
rename from texk/web2c/luatexdir/tex/directions.w
rename to texk/web2c/luatexdir/tex/directions.c
index c844e934c..59b2f7dcd 100644
--- a/texk/web2c/luatexdir/tex/directions.w
+++ b/texk/web2c/luatexdir/tex/directions.c
@@ -1,27 +1,28 @@
-% directions.w
-%
-% Copyright 2009-2014 Taco Hoekwater <taco@@luatex.org>
-%
-% This file is part of LuaTeX.
-%
-% LuaTeX is free software; you can redistribute it and/or modify it under
-% the terms of the GNU General Public License as published by the Free
-% Software Foundation; either version 2 of the License, or (at your
-% option) any later version.
-%
-% LuaTeX is distributed in the hope that it will be useful, but WITHOUT
-% ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-% FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
-% License for more details.
-%
-% You should have received a copy of the GNU General Public License along
-% with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
-
-@ @c
+/*
+
+directions.w
+
+Copyright 2009-2014 Taco Hoekwater <taco@@luatex.org>
+
+This file is part of LuaTeX.
+
+LuaTeX is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 2 of the License, or (at your
+option) any later version.
+
+LuaTeX is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+License for more details.
+
+You should have received a copy of the GNU General Public License along
+with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+
+*/
 
 #include "ptexlib.h"
 
-@ @c
 void scan_direction(void)
 {
     int save_cur_cmd = cur_cmd;
@@ -53,9 +54,12 @@ void scan_direction(void)
     cur_chr = save_cur_chr;
 }
 
-@ the next two are used by postlinebreak.c
+/*tex
+
+    The next two are used by |postlinebreak.c|:
+
+*/
 
-@c
 halfword do_push_dir_node(halfword p, halfword a)
 {
     halfword n = copy_node(a);
@@ -70,18 +74,14 @@ halfword do_pop_dir_node(halfword p)
     return n;
 }
 
-@ @c
 halfword dir_ptr;
-
 halfword text_dir_ptr;
 
-@ There is no need to do anything here at the moment.
-@c
 void initialize_directions(void)
 {
+    /*tex There is no need to do anything here at the moment. */
 }
 
-@ @c
 halfword new_dir(int s)
 {
     halfword p = new_node(dir_node, 0);
@@ -90,55 +90,32 @@ halfword new_dir(int s)
     return p;
 }
 
-@ The global static array variable  |dir_strings| is also used
-by the lua nodelib interface, so it cannot be static. Putting
-it here instead of there avoid the nodelib having to know
-about the actual values of |dir_TRT| etc.
-
-@c
-
-/*
-const char *dir_strings[128] = {
-  "-TLT","???", "???", "???", "-TRT","???", "???", "???",
-  "???", "-LTL","???", "???", "???", "???", "???", "???",
-  "???", "???", "???", "???", "???", "???", "???", "???",
-  "-RTT","???", "???", "???", "???", "???", "???", "???",
-  "???", "???", "???", "???", "???", "???", "???", "???",
-  "???", "???", "???", "???", "???", "???", "???", "???",
-  "???", "???", "???", "???", "???", "???", "???", "???",
-  "???", "???", "???", "???", "???", "???", "???", "???",
-  "+TLT","???", "???", "???", "+TRT","???", "???", "???",
-  "???", "+LTL","???", "???", "???", "???", "???", "???",
-  "???", "???", "???", "???", "???", "???", "???", "???",
-  "+RTT","???", "???", "???", "???", "???", "???", "???",
-  "???", "???", "???", "???", "???", "???", "???", "???",
-  "???", "???", "???", "???", "???", "???", "???", "???",
-  "???", "???", "???", "???", "???", "???", "???", "???",
-  "???", "???", "???", "???", "???", "???", "???", "???"
+const char *dir_strings_par[4] = { [0] =
+  "TLT","TRT","LTL","RTT",
 };
 
-int dir_swap = 64;
-*/
-
-const char *dir_strings[8] = {
-  "-TLT","-TRT","-LTL","-RTT",
+const char *dir_strings_text_normal[4] = { [0] =
   "+TLT","+TRT","+LTL","+RTT",
 };
 
-int dir_swap = 4;
+const char *dir_strings_text_cancel[4] = { [0] =
+  "-TLT","-TRT","-LTL","-RTT",
+};
 
-const char *string_dir(int d)
+void print_dir_par(int d)
 {
-    return (dir_strings[d+dir_swap]+1);
+    tprint(dir_strings_par[d]);
 }
 
-@ @c
-void print_dir(int d)
+void print_dir_text(halfword d)
 {
-    tprint(string_dir(d));
+    if (subtype(d) == cancel_dir) {
+        tprint(dir_strings_text_cancel[dir_dir(d)]);
+    } else {
+        tprint(dir_strings_text_normal[dir_dir(d)]);
+    }
 }
 
-@ @c
 scaled pack_width(int curdir, int pdir, halfword p, boolean isglyph)
 {
     scaled wd = 0;
@@ -153,9 +130,7 @@ scaled pack_width(int curdir, int pdir, halfword p, boolean isglyph)
         } else {
             wd = glyph_depth(p) + glyph_height(p);
         }
-/* experimental */
-wd += x_advance(p);
-    } else {                    /* hlist, vlist, image, form, rule */
+    } else {
         if (textdir_parallel(pdir, curdir))
             wd = width(p);
         else
@@ -164,7 +139,6 @@ wd += x_advance(p);
     return wd;
 }
 
-@ @c
 scaled_whd pack_width_height_depth(int curdir, int pdir, halfword p, boolean isglyph)
 {
     scaled_whd whd = { 0, 0, 0 };
@@ -208,7 +182,6 @@ scaled_whd pack_width_height_depth(int curdir, int pdir, halfword p, boolean isg
     return whd;
 }
 
-@ @c
 void update_text_dir_ptr(int val)
 {
     if (dir_level(text_dir_ptr) == cur_level) {
diff --git a/texk/web2c/luatexdir/tex/dumpdata.w b/texk/web2c/luatexdir/tex/dumpdata.c
similarity index 56%
rename from texk/web2c/luatexdir/tex/dumpdata.w
rename to texk/web2c/luatexdir/tex/dumpdata.c
index 9d06f1c8e..0091685fb 100644
--- a/texk/web2c/luatexdir/tex/dumpdata.w
+++ b/texk/web2c/luatexdir/tex/dumpdata.c
@@ -1,84 +1,97 @@
-% dumpdata.w
-%
-% Copyright 2009-2010 Taco Hoekwater <taco@@luatex.org>
-%
-% This file is part of LuaTeX.
-%
-% LuaTeX is free software; you can redistribute it and/or modify it under
-% the terms of the GNU General Public License as published by the Free
-% Software Foundation; either version 2 of the License, or (at your
-% option) any later version.
-%
-% LuaTeX is distributed in the hope that it will be useful, but WITHOUT
-% ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-% FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
-% License for more details.
-%
-% You should have received a copy of the GNU General Public License along
-% with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
-
-@ @c
+/*
+
+dumpdata.w
+
+Copyright 2009-2010 Taco Hoekwater <taco@@luatex.org>
+
+This file is part of LuaTeX.
+
+LuaTeX is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 2 of the License, or (at your
+option) any later version.
+
+LuaTeX is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+License for more details.
+
+You should have received a copy of the GNU General Public License along
+with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+
+*/
 
 #include "ptexlib.h"
 
-/* we start with 907: the sum of the values of the bytes of "don knuth" */
+/*tex
+
+    We use a magic number to register the version of the format. Normally this
+    number only increments when we add a new primitive of change command codes.
+    We start with 907 which is the sum of the values of the bytes of \quote
+    {don knuth}.
 
-#define FORMAT_ID (907+37)
+*/
+
+#define FORMAT_ID (907+48)
 #if ((FORMAT_ID>=0) && (FORMAT_ID<=256))
 #error Wrong value for FORMAT_ID.
 #endif
 
+/*tex
+
+After \.{INITEX} has seen a collection of fonts and macros, it can write all the
+necessary information on an auxiliary file so that production versions of \TeX\
+are able to initialize their memory at high speed. The present section of the
+program takes care of such output and input. We shall consider simultaneously the
+processes of storing and restoring, so that the inverse relation between them is
+clear. @.INITEX@>
+
+The global variable |format_ident| is a string that is printed right after the
+|banner| line when \TeX\ is ready to start. For \.{INITEX} this string says
+simply `\.{(INITEX)}'; for other versions of \TeX\ it says, for example,
+`\.{(preloaded format=plain 1982.11.19)}', showing the year, month, and day that
+the format file was created. We have |format_ident=0| before \TeX's tables are
+loaded. |FORMAT_ID| is a new field of type int suitable for the identification of
+a format: values between 0 and 256 (included) can not be used because in the
+previous format they are used for the length of the name of the engine.
+
+*/
 
-@ After \.{INITEX} has seen a collection of fonts and macros, it
-can write all the necessary information on an auxiliary file so
-that production versions of \TeX\ are able to initialize their
-memory at high speed. The present section of the program takes
-care of such output and input. We shall consider simultaneously
-the processes of storing and restoring,
-so that the inverse relation between them is clear.
-@.INITEX@>
-
-The global variable |format_ident| is a string that is printed right
-after the |banner| line when \TeX\ is ready to start. For \.{INITEX} this
-string says simply `\.{(INITEX)}'; for other versions of \TeX\ it says,
-for example, `\.{(preloaded format=plain 1982.11.19)}', showing the year,
-month, and day that the format file was created. We have |format_ident=0|
-before \TeX's tables are loaded. |FORMAT_ID| is a new field of type int
-suitable for the identification of a format: values between 0 and 256
-(included) can not be used because in the previous format they are used
-for the length of  the name of the engine.
-@c
 str_number format_ident;
-str_number format_name;         /* principal file name */
+str_number format_name;
 
 
-@ Format files consist of |memory_word| items, and we use the following
-macros to dump words of different types:
+/*tex
 
-@c
-FILE *fmt_file;                 /* for input or output of format information */
+Format files consist of |memory_word| items, and we use the following macros to
+dump words of different types:
+
+*/
+
+FILE *fmt_file;
 
-@ @c
 void store_fmt_file(void)
 {
-    int j, k, l;                /* all-purpose indices */
-    halfword p;                 /* all-purpose pointer */
-    int x;                      /* something to dump */
+    int j, k, l, x;
+    halfword p;
     char *format_engine;
-    int callback_id;            /* |pre_dump| callback */
+    int callback_id;
     char *fmtname = NULL;
-    /* If dumping is not allowed, abort */
-    /* The user is not allowed to dump a format file unless |save_ptr=0|.
-       This condition implies that |cur_level=level_one|, hence
-       the |xeq_level| array is constant and it need not be dumped. */
+    /*tex
+        If dumping is not allowed, abort. The user is not allowed to dump a
+        format file unless |save_ptr=0|. This condition implies that
+        |cur_level=level_one|, hence the |xeq_level| array is constant and it
+        need not be dumped.
+    */
     if (save_ptr != 0) {
         print_err("You can't dump inside a group");
         help1("`{...\\dump}' is a no-no.");
         succumb();
     }
-
-    /* Create the |format_ident|, open the format file, and inform the user
-       that dumping has begun */
+    /*tex
+        Create the |format_ident|, open the format file, and inform the user that
+        dumping has begun.
+    */
     callback_id = callback_defined(pre_dump_callback);
     if (callback_id > 0) {
         (void) run_callback(callback_id, "->");
@@ -97,11 +110,11 @@ void store_fmt_file(void)
     format_ident = make_string();
     print(job_name);
     format_name = make_string();
-    if (interaction == batch_mode)
+    if (interaction == batch_mode) {
         selector = log_only;
-    else
+    } else {
         selector = term_and_log;
-
+    }
     fmtname = pack_job_name(format_extension);
     while (!zopen_w_output(&fmt_file, fmtname, FOPEN_WBIN_MODE)) {
         fmtname = prompt_file_name("format file name", format_extension);
@@ -111,15 +124,16 @@ void store_fmt_file(void)
     free(fmtname);
     tprint_nl("");
     print(format_ident);
-
-    /* Dump constants for consistency check */
-    /* The next few sections of the program should make it clear how we use the
-       dump/undump macros. */
-
-    dump_int(0x57325458);       /* Web2C \TeX's magic constant: "W2TX" */
+    /*tex
+        Dump constants for consistency check. The next few sections of the
+        program should make it clear how we use the dump/undump macros. First
+        comes Web2C \TeX's magic constant: "W2TX"
+    */
+    dump_int(0x57325458);
     dump_int(FORMAT_ID);
-
-    /* Align engine to 4 bytes with one or more trailing NUL */
+    /*tex
+        We align |engine_name| to 4 bytes with one or more trailing |NUL|.
+    */
     x = (int) strlen(engine_name);
     format_engine = xmalloc((unsigned) (x + 4));
     strcpy(format_engine, engine_name);
@@ -129,28 +143,26 @@ void store_fmt_file(void)
     dump_int(x);
     dump_things(format_engine[0], x);
     xfree(format_engine);
-    dump_int(0x57325458);       /* TODO HM, what checksum would make sense? */
+    dump_int(0x57325458);
     dump_int(max_halfword);
     dump_int(hash_high);
     dump_int(eqtb_size);
     dump_int(hash_prime);
-
-    /* Dump the string pool */
+    /*tex Dump the string pool. */
     k = dump_string_pool();
     print_ln();
     print_int(k);
     tprint(" strings using ");
     print_int((longinteger) pool_size);
     tprint(" bytes");
-
-    /* Dump the dynamic memory */
-    /* By sorting the list of available spaces in the variable-size portion of
-       |mem|, we are usually able to get by without having to dump very much
-       of the dynamic memory.
-
-       We recompute |var_used| and |dyn_used|, so that \.{INITEX} dumps valid
-       information even when it has not been gathering statistics.
-     */
+    /*tex
+        Dump the dynamic memory. By sorting the list of available spaces in the
+        variable-size portion of |mem|, we are usually able to get by without
+        having to dump very much of the dynamic memory.
+
+        We recompute |var_used| and |dyn_used|, so that \.{INITEX} dumps valid
+        information even when it has not been gathering statistics.
+    */
     dump_node_mem();
     dump_int(temp_token_head);
     dump_int(hold_token_head);
@@ -180,14 +192,13 @@ void store_fmt_file(void)
     print_int(var_used);
     print_char('&');
     print_int(dyn_used);
-
-    /* Dump the table of equivalents */
-    /* Dump regions 1 to 4 of |eqtb| */
-    /*The table of equivalents usually contains repeated information, so we dump it
-       in compressed form: The sequence of $n+2$ values $(n,x_1,\ldots,x_n,m)$ in the
-       format file represents $n+m$ consecutive entries of |eqtb|, with |m| extra
-       copies of $x_n$, namely $(x_1,\ldots,x_n,x_n,\ldots,x_n)$.
-     */
+    /*tex
+        Dump regions 1 to 4 of |eqtb|, the table of equivalents. The table of
+        equivalents usually contains repeated information, so we dump it in
+        compressed form: The sequence of $n+2$ values $(n,x_1,\ldots,x_n,m)$ in
+        the format file represents $n+m$ consecutive entries of |eqtb|, with |m|
+        extra copies of $x_n$, namely $(x_1,\ldots,x_n,x_n,\ldots,x_n)$.
+    */
     k = null_cs;
     do {
         j = k;
@@ -198,7 +209,8 @@ void store_fmt_file(void)
             incr(j);
         }
         l = int_base;
-        goto DONE1;             /* |j=int_base-1| */
+        /*tex |j=int_base-1| */
+        goto DONE1;
       FOUND1:
         incr(j);
         l = j;
@@ -214,8 +226,7 @@ void store_fmt_file(void)
         k = j + 1;
         dump_int(k - l);
     } while (k != int_base);
-
-    /* Dump regions 5 and 6 of |eqtb| */
+    /*tex Dump regions 5 and 6 of |eqtb|. */
     do {
         j = k;
         while (j < eqtb_size) {
@@ -224,7 +235,8 @@ void store_fmt_file(void)
             incr(j);
         }
         l = eqtb_size + 1;
-        goto DONE2;             /* |j=eqtb_size| */
+        /*tex |j=eqtb_size| */
+        goto DONE2;
       FOUND2:
         incr(j);
         l = j;
@@ -239,18 +251,20 @@ void store_fmt_file(void)
         k = j + 1;
         dump_int(k - l);
     } while (k <= eqtb_size);
-    if (hash_high > 0)
-        dump_things(eqtb[eqtb_size + 1], hash_high);    /* dump |hash_extra| part */
-
+    if (hash_high > 0) {
+        /*tex Dump the |hash_extra| part: */
+        dump_things(eqtb[eqtb_size + 1], hash_high);
+    }
     dump_int(par_loc);
     dump_int(write_loc);
     dump_math_codes();
     dump_text_codes();
-    /* Dump the hash table */
-    /* A different scheme is used to compress the hash table, since its lower
-       region is usually sparse. When |text(p)<>0| for |p<=hash_used|, we output
-       two words, |p| and |hash[p]|. The hash table is, of course, densely packed
-       for |p>=hash_used|, so the remaining entries are output in a~block.
+    /*tex
+        Dump the hash table, A different scheme is used to compress the hash
+        table, since its lower region is usually sparse. When |text(p)<>0| for
+        |p<=hash_used|, we output two words, |p| and |hash[p]|. The hash table
+        is, of course, densely packed for |p>=hash_used|, so the remaining
+        entries are output in a~block.
      */
     dump_primitives();
     dump_int(hash_used);
@@ -262,19 +276,18 @@ void store_fmt_file(void)
             incr(cs_count);
         }
     }
-    dump_things(hash[hash_used + 1],
-                undefined_control_sequence - 1 - hash_used);
-    if (hash_high > 0)
+    dump_things(hash[hash_used + 1],undefined_control_sequence - 1 - hash_used);
+    if (hash_high > 0) {
         dump_things(hash[eqtb_size + 1], hash_high);
+    }
     dump_int(cs_count);
     print_ln();
     print_int(cs_count);
     tprint(" multiletter control sequences");
-
-    /* Dump the font information */
+    /*tex Dump the font information. */
     dump_int(max_font_id());
     for (k = 0; k <= max_font_id(); k++) {
-        /* Dump the array info for internal font number |k| */
+        /*tex Dump the array info for internal font number |k|. */
         dump_font(k);
         tprint_nl("\\font");
         print_esc(font_id_text(k));
@@ -293,73 +306,78 @@ void store_fmt_file(void)
     if (max_font_id() != 1)
         print_char('s');
     dump_math_data();
-
-    /* Dump the hyphenation tables */
+    /*tex Dump the hyphenation tables. */
     dump_language_data();
-
-    /* Dump a couple more things and the closing check word */
+    /*tex Dump a couple more things and the closing check word. */
     dump_int(interaction);
     dump_int(format_ident);
     dump_int(format_name);
     dump_int(69069);
-    /* We have already printed a lot of statistics, so we set |tracing_stats:=0|
-       to prevent them from appearing again. */
+    /*tex
+        We have already printed a lot of statistics, so we set |tracing_stats:=0|
+        to prevent them from appearing again.
+    */
     tracing_stats_par = 0;
-
-    /* Dump the lua bytecodes */
+    /*tex Dump the \LUA\ bytecodes. */
     dump_luac_registers();
-
-    /* Close the format file */
+    /*tex Close the format file. */
     zwclose(fmt_file);
 }
 
-@ Corresponding to the procedure that dumps a format file, we have a function
-that reads one in. The function returns |false| if the dumped format is
-incompatible with the present \TeX\ table sizes, etc.
-
-@c
-#define too_small(A) do {					\
-	wake_up_terminal();					\
-	wterm_cr();						\
-	fprintf(term_out,"---! Must increase the %s",(A));	\
-	goto BAD_FMT;						\
-    } while (0)
-
-@ The inverse macros are slightly more complicated, since we need to check
-the range of the values we are reading in. We say `|undump(a)(b)(x)|' to
-read an integer value |x| that is supposed to be in the range |a<=x<=b|.
-
-@c
-#define undump(A,B,C) do {						\
-	undump_int(x);							\
-	if (x<(A) || x>(B)) goto BAD_FMT;				\
-	else (C) = x;							\
-    } while (0)
-
-
-#define format_debug(A,B) do {					\
-	if (debug_format_file) {				\
-	    fprintf (stderr, "fmtdebug: %s=%d", (A), (int)(B));	\
-	}							\
-    } while (0)
-
-#define undump_size(A,B,C,D) do {					\
-	undump_int(x);							\
-	if (x<(A))  goto BAD_FMT;					\
-	if (x>(B))  too_small(C);					\
-	else format_debug (C,x);					\
-	(D) = x;							\
-    } while (0)
-
-
-@ @c
+/*tex
+
+Corresponding to the procedure that dumps a format file, we have a function that
+reads one in. The function returns |false| if the dumped format is incompatible
+with the present \TeX\ table sizes, etc.
+
+*/
+
+#define too_small(A) do { \
+    wake_up_terminal(); \
+    wterm_cr(); \
+    fprintf(term_out,"---! Must increase the %s",(A)); \
+    goto BAD_FMT; \
+} while (0)
+
+/*tex
+
+    The inverse macros are slightly more complicated, since we need to check the
+    range of the values we are reading in. We say `|undump(a)(b)(x)|' to read an
+    integer value |x| that is supposed to be in the range |a<=x<=b|.
+
+*/
+
+#define undump(A,B,C) do { \
+    undump_int(x); \
+    if (x<(A) || x>(B)) \
+        goto BAD_FMT; \
+    else \
+        (C) = x; \
+} while (0)
+
+#define format_debug(A,B) do { \
+    if (debug_format_file) { \
+        fprintf (stderr, "fmtdebug: %s=%d", (A), (int)(B)); \
+    } \
+} while (0)
+
+#define undump_size(A,B,C,D) do { \
+    undump_int(x); \
+    if (x<(A)) \
+        goto BAD_FMT; \
+    if (x>(B)) \
+        too_small(C); \
+    else \
+        format_debug (C,x); \
+    (D) = x; \
+} while (0)
+
 boolean load_fmt_file(const char *fmtname)
 {
-    int j, k;                   /* all-purpose indices */
-    halfword p;                 /* all-purpose pointer */
-    int x;                      /* something undumped */
+    int j, k, x;
+    halfword p;
     char *format_engine;
-    /* Undump constants for consistency check */
+    /*tex Undump constants for consistency check .*/
     if (ini_version) {
         libcfree(hash);
         libcfree(eqtb);
@@ -368,22 +386,25 @@ boolean load_fmt_file(const char *fmtname)
     }
     undump_int(x);
     format_debug("format magic number", x);
-    if (x != 0x57325458)
-        goto BAD_FMT;           /* not a format file */
-
+    if (x != 0x57325458) {
+        /*tex it's not a format file. */
+        goto BAD_FMT;
+    }
     undump_int(x);
     format_debug("format id", x);
-    if (x != FORMAT_ID)
-        goto BAD_FMT;           /* FORMAT_ID mismatch */
-
+    if (x != FORMAT_ID) {
+        /*tex We have a |FORMAT_ID| mismatch. */
+        goto BAD_FMT;
+    }
     undump_int(x);
     format_debug("engine name size", x);
-    if ((x < 0) || (x > 256))
-        goto BAD_FMT;           /* corrupted format file */
-
+    if ((x < 0) || (x > 256)) {
+       /*tex The format file is corrupt. */
+        goto BAD_FMT;
+    }
     format_engine = xmalloc((unsigned) x);
     undump_things(format_engine[0], x);
-    format_engine[x - 1] = 0;   /* force string termination, just in case */
+    format_engine[x - 1] = 0;
     if (strcmp(engine_name, format_engine)) {
         wake_up_terminal();
         wterm_cr();
@@ -394,7 +415,7 @@ boolean load_fmt_file(const char *fmtname)
     xfree(format_engine);
     undump_int(x);
     format_debug("string pool checksum", x);
-    if (x != 0x57325458) {      /* todo: @@\$ *//* check that strings are the same */
+    if (x != 0x57325458) {
         wake_up_terminal();
         wterm_cr();
         fprintf(term_out, "---! %s was written by a different version",
@@ -403,7 +424,7 @@ boolean load_fmt_file(const char *fmtname)
     }
     undump_int(x);
     if (x != max_halfword)
-        goto BAD_FMT;           /* check |max_halfword| */
+        goto BAD_FMT;
     undump_int(hash_high);
     if ((hash_high < 0) || (hash_high > sup_hash_extra))
         goto BAD_FMT;
@@ -428,10 +449,9 @@ boolean load_fmt_file(const char *fmtname)
     undump_int(x);
     if (x != hash_prime)
         goto BAD_FMT;
-
-    /* Undump the string pool */
+    /*tex Undump the string pool */
     str_ptr = undump_string_pool();
-    /* Undump the dynamic memory */
+    /*tex Undump the dynamic memory */
     undump_node_mem();
     undump_int(temp_token_head);
     undump_int(hold_token_head);
@@ -447,9 +467,7 @@ boolean load_fmt_file(const char *fmtname)
     undump_int(avail);
     undump_things(fixmem[fix_mem_min], fix_mem_end - fix_mem_min + 1);
     undump_int(dyn_used);
-
-    /* Undump the table of equivalents */
-    /* Undump regions 1 to 6 of |eqtb| */
+    /*tex Undump regions 1 to 6 of the table of equivalents |eqtb|. */
     k = null_cs;
     do {
         undump_int(x);
@@ -464,15 +482,16 @@ boolean load_fmt_file(const char *fmtname)
             eqtb[j] = eqtb[k - 1];
         k = k + x;
     } while (k <= eqtb_size);
-    if (hash_high > 0)          /* undump |hash_extra| part */
+    if (hash_high > 0) {
+        /*tex undump |hash_extra| part */
         undump_things(eqtb[eqtb_size + 1], hash_high);
-
+    }
     undump(hash_base, hash_top, par_loc);
     par_token = cs_token_flag + par_loc;
     undump(hash_base, hash_top, write_loc);
     undump_math_codes();
     undump_text_codes();
-    /* Undump the hash table */
+    /*tex Undump the hash table */
     undump_primitives();
     undump(hash_base, frozen_control_sequence, hash_used);
     p = hash_base - 1;
@@ -480,8 +499,7 @@ boolean load_fmt_file(const char *fmtname)
         undump(p + 1, hash_used, p);
         undump_hh(hash[p]);
     } while (p != hash_used);
-    undump_things(hash[hash_used + 1],
-                  undefined_control_sequence - 1 - hash_used);
+    undump_things(hash[hash_used + 1], undefined_control_sequence - 1 - hash_used);
     if (debug_format_file)
         print_csnames(hash_base, undefined_control_sequence - 1);
     if (hash_high > 0) {
@@ -490,20 +508,17 @@ boolean load_fmt_file(const char *fmtname)
             print_csnames(eqtb_size + 1, hash_high - (eqtb_size + 1));
     }
     undump_int(cs_count);
-
-    /* Undump the font information */
+    /*tex Undump the font information */
     undump_int(x);
     set_max_font_id(x);
     for (k = 0; k <= max_font_id(); k++) {
-        /* Undump the array info for internal font number |k| */
+        /*tex Undump the array info for internal font number |k| */
         undump_font(k);
     }
     undump_math_data();
-
-    /* Undump the hyphenation tables */
+    /*tex Undump the hyphenation tables */
     undump_language_data();
-
-    /* Undump a couple more things and the closing check word */
+    /*tex Undump a couple more things and the closing check word */
     undump(batch_mode, error_stop_mode, interaction);
     if (interactionoption != unspecified_mode)
         interaction = interactionoption;
@@ -512,12 +527,10 @@ boolean load_fmt_file(const char *fmtname)
     undump_int(x);
     if (x != 69069)
         goto BAD_FMT;
-
-    /* Undump the lua bytecodes */
+    /*tex Undump the lua bytecodes. */
     undump_luac_registers();
-
     prev_depth_par = ignore_depth;
-    return true;                /* it worked! */
+    return true;
   BAD_FMT:
     wake_up_terminal();
     wterm_cr();
diff --git a/texk/web2c/luatexdir/tex/equivalents.w b/texk/web2c/luatexdir/tex/equivalents.c
similarity index 57%
rename from texk/web2c/luatexdir/tex/equivalents.w
rename to texk/web2c/luatexdir/tex/equivalents.c
index 271fc67ff..3d260d5c5 100644
--- a/texk/web2c/luatexdir/tex/equivalents.w
+++ b/texk/web2c/luatexdir/tex/equivalents.c
@@ -1,29 +1,31 @@
-% equivalents.w
-%
-% Copyright 2009-2010 Taco Hoekwater <taco@@luatex.org>
-%
-% This file is part of LuaTeX.
-%
-% LuaTeX is free software; you can redistribute it and/or modify it under
-% the terms of the GNU General Public License as published by the Free
-% Software Foundation; either version 2 of the License, or (at your
-% option) any later version.
-%
-% LuaTeX is distributed in the hope that it will be useful, but WITHOUT
-% ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-% FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
-% License for more details.
-%
-% You should have received a copy of the GNU General Public License along
-% with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
-
-@ @c
+/*
+
+equivalents.w
+
+Copyright 2009-2010 Taco Hoekwater <taco@@luatex.org>
+
+This file is part of LuaTeX.
+
+LuaTeX is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 2 of the License, or (at your
+option) any later version.
+
+LuaTeX is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+License for more details.
+
+You should have received a copy of the GNU General Public License along
+with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+
+*/
 
 #include "ptexlib.h"
 
 halfword last_cs_name = null_cs;
 
-/* |eqtb[p]| has just been restored or retained */
+/*tex |eqtb[p]| has just been restored or retained. */
 
 static void diagnostic_trace(halfword p, const char *s)
 {
@@ -36,60 +38,54 @@ static void diagnostic_trace(halfword p, const char *s)
     end_diagnostic(false);
 }
 
-@ @c
-void show_eqtb_meaning(halfword n);     /* forward */
+void show_eqtb_meaning(halfword n);
+
+/*tex
+
+Now that we have studied the data structures for \TeX's semantic routines, we
+ought to consider the data structures used by its syntactic routines. In other
+words, our next concern will be the tables that \TeX\ looks at when it is
+scanning what the user has written.
 
-@ Now that we have studied the data structures for \TeX's semantic routines,
-we ought to consider the data structures used by its syntactic routines. In
-other words, our next concern will be
-the tables that \TeX\ looks at when it is scanning
-what the user has written.
+The biggest and most important such table is called |eqtb|. It holds the current
+``equivalents'' of things; i.e., it explains what things mean or what their
+current values are, for all quantities that are subject to the nesting structure
+provided by \TeX's grouping mechanism. There are six parts to |eqtb|:
 
-The biggest and most important such table is called |eqtb|. It holds the
-current ``equivalents'' of things; i.e., it explains what things mean
-or what their current values are, for all quantities that are subject to
-the nesting structure provided by \TeX's grouping mechanism. There are six
-parts to |eqtb|:
+1) |eqtb[null_cs]| holds the current equivalent of the zero-length control
+sequence.
 
-\yskip\hang 1) |eqtb[null_cs]| holds the current equivalent of the
-zero-length control sequence.
+2) |eqtb[hash_base..(glue_base-1)]| holds the current equivalents of single- and
+multiletter control sequences.
 
-\yskip\hang 2) |eqtb[hash_base..(glue_base-1)]| holds the current
-equivalents of single- and multiletter control sequences.
+3) |eqtb[glue_base..(local_base-1)]| holds the current equivalents of glue
+parameters like the current baselineskip.
 
-\yskip\hang 3) |eqtb[glue_base..(local_base-1)]| holds the current
-equivalents of glue parameters like the current baselineskip.
+4) |eqtb[local_base..(int_base-1)]| holds the current equivalents of local
+halfword quantities like the current box registers, the current ``catcodes,'' the
+current font, and a pointer to the current paragraph shape.
 
-\yskip\hang 4) |eqtb[local_base..(int_base-1)]| holds the current
-equivalents of local halfword quantities like the current box registers,
-the current ``catcodes,'' the current font, and a pointer to the current
-paragraph shape.
+5) |eqtb[int_base..(dimen_base-1)]| holds the current equivalents of fullword
+integer parameters like the current hyphenation penalty.
 
-\yskip\hang 5) |eqtb[int_base..(dimen_base-1)]| holds the current
-equivalents of fullword integer parameters like the current hyphenation
-penalty.
+6) |eqtb[dimen_base..eqtb_size]| holds the current equivalents of fullword
+dimension parameters like the current hsize or amount of hanging indentation.
 
-\yskip\hang 6) |eqtb[dimen_base..eqtb_size]| holds the current equivalents
-of fullword dimension parameters like the current hsize or amount of
-hanging indentation.
+Note that, for example, the current amount of baselineskip glue is determined by
+the setting of a particular location in region~3 of |eqtb|, while the current
+meaning of the control sequence `\.{\\baselineskip}' (which might have been
+changed by \.{\\def} or \.{\\let}) appears in region~2.
 
-\yskip\noindent Note that, for example, the current amount of
-baselineskip glue is determined by the setting of a particular location
-in region~3 of |eqtb|, while the current meaning of the control sequence
-`\.{\\baselineskip}' (which might have been changed by \.{\\def} or
-\.{\\let}) appears in region~2.
+The last two regions of |eqtb| have fullword values instead of the three fields
+|eq_level|, |eq_type|, and |equiv|. An |eq_type| is unnecessary, but \TeX\ needs
+to store the |eq_level| information in another array called |xeq_level|.
 
-@ The last two regions of |eqtb| have fullword values instead of the
-three fields |eq_level|, |eq_type|, and |equiv|. An |eq_type| is unnecessary,
-but \TeX\ needs to store the |eq_level| information in another array
-called |xeq_level|.
+*/
 
-@c
 memory_word *eqtb;
-halfword eqtb_top;              /* maximum of the |eqtb| */
+halfword eqtb_top;
 quarterword xeq_level[(eqtb_size + 1)];
 
-@ @c
 void initialize_equivalents(void)
 {
     int k;
@@ -97,48 +93,45 @@ void initialize_equivalents(void)
         xeq_level[k] = level_one;
 }
 
-@ The nested structure provided by `$\.{\char'173}\ldots\.{\char'175}$' groups
-in \TeX\ means that |eqtb| entries valid in outer groups should be saved
-and restored later if they are overridden inside the braces. When a new |eqtb|
-value is being assigned, the program therefore checks to see if the previous
-entry belongs to an outer level. In such a case, the old value is placed
-on the |save_stack| just before the new value enters |eqtb|. At the
-end of a grouping level, i.e., when the right brace is sensed, the
-|save_stack| is used to restore the outer values, and the inner ones are
-destroyed.
-
-Entries on the |save_stack| are of type |save_record|. The top item on
-this stack is |save_stack[p]|, where |p=save_ptr-1|; it contains three
-fields called |save_type|, |save_level|, and |save_value|, and it is
-interpreted in one of four ways:
-
-\yskip\hang 1) If |save_type(p)=restore_old_value|, then
-|save_value(p)| is a location in |eqtb| whose current value should
-be destroyed at the end of the current group and replaced by |save_word(p-1)|
-(|save_type(p-1)==saved_eqtb|).
-Furthermore if |save_value(p)>=int_base|, then |save_level(p)| should
-replace the corresponding entry in |xeq_level| (if |save_value(p)<int_base|,
-then the level is part of |save_word(p-1)|).
-
-\yskip\hang 2) If |save_type(p)=restore_zero|, then |save_value(p)|
-is a location in |eqtb| whose current value should be destroyed at the end
-of the current group, when it should be
-replaced by the current value of |eqtb[undefined_control_sequence]|.
-
-\yskip\hang 3) If |save_type(p)=insert_token|, then |save_value(p)|
-is a token that should be inserted into \TeX's input when the current
-group ends.
-
-\yskip\hang 4) If |save_type(p)=level_boundary|, then |save_level(p)|
-is a code explaining what kind of group we were previously in, and
-|save_value(p)| points to the level boundary word at the bottom of
-the entries for that group. Furthermore, |save_value(p-1)| contains the
-source line number at which the current level of grouping was entered,
-this field has itself a type: |save_type(p-1)==saved_line|.
-
-Besides this `official' use, various subroutines push temporary
-variables on the save stack when it is handy to do so. These all have
-an explicit |save_type|, and they are:
+/*tex
+
+The nested structure provided by `$\.{\char'173}\ldots\.{\char'175}$' groups in
+\TeX\ means that |eqtb| entries valid in outer groups should be saved and
+restored later if they are overridden inside the braces. When a new |eqtb| value
+is being assigned, the program therefore checks to see if the previous entry
+belongs to an outer level. In such a case, the old value is placed on the
+|save_stack| just before the new value enters |eqtb|. At the end of a grouping
+level, i.e., when the right brace is sensed, the |save_stack| is used to restore
+the outer values, and the inner ones are destroyed.
+
+Entries on the |save_stack| are of type |save_record|. The top item on this stack
+is |save_stack[p]|, where |p=save_ptr-1|; it contains three fields called
+|save_type|, |save_level|, and |save_value|, and it is interpreted in one of four
+ways:
+
+1) If |save_type(p)=restore_old_value|, then |save_value(p)| is a location in
+|eqtb| whose current value should be destroyed at the end of the current group
+and replaced by |save_word(p-1)| (|save_type(p-1)==saved_eqtb|). Furthermore if
+|save_value(p)>=int_base|, then |save_level(p)| should replace the corresponding
+entry in |xeq_level| (if |save_value(p)<int_base|, then the level is part of
+|save_word(p-1)|).
+
+2) If |save_type(p)=restore_zero|, then |save_value(p)| is a location in |eqtb|
+whose current value should be destroyed at the end of the current group, when it
+should be replaced by the current value of |eqtb[undefined_control_sequence]|.
+
+3) If |save_type(p)=insert_token|, then |save_value(p)| is a token that should be
+inserted into \TeX's input when the current group ends.
+
+4) If |save_type(p)=level_boundary|, then |save_level(p)| is a code explaining
+what kind of group we were previously in, and |save_value(p)| points to the level
+boundary word at the bottom of the entries for that group. Furthermore,
+|save_value(p-1)| contains the source line number at which the current level of
+grouping was entered, this field has itself a type: |save_type(p-1)==saved_line|.
+
+Besides this `official' use, various subroutines push temporary variables on the
+save stack when it is handy to do so. These all have an explicit |save_type|, and
+they are:
 
 |saved_adjust| signifies an adjustment is beging scanned,
 |saved_insert| an insertion is being scanned,
@@ -154,32 +147,34 @@ an explicit |save_type|, and they are:
 |saved_boxattr| the box \.{attr} specification,
 |saved_boxpack| the box \.{pack} specification.
 
-@ The global variable |cur_group| keeps track of what sort of group we are
-currently in. Another global variable, |cur_boundary|, points to the
-topmost |level_boundary| word.  And |cur_level| is the current depth of
-nesting. The routines are designed to preserve the condition that no entry
-in the |save_stack| or in |eqtb| ever has a level greater than |cur_level|.
+The global variable |cur_group| keeps track of what sort of group we are
+currently in. Another global variable, |cur_boundary|, points to the topmost
+|level_boundary| word. And |cur_level| is the current depth of nesting. The
+routines are designed to preserve the condition that no entry in the |save_stack|
+or in |eqtb| ever has a level greater than |cur_level|.
+
+*/
 
-@c
 save_record *save_stack;
-int save_ptr;                        /* first unused entry on |save_stack| */
+int save_ptr;                        /* first unused entry on the save stack */
 int max_save_stack;                  /* maximum usage of save stack */
 quarterword cur_level = level_one;   /* current nesting level for groups */
 group_code cur_group = bottom_level; /* current group type */
 int cur_boundary;                    /* where the current level begins */
 
-@ At this time it might be a good idea for the reader to review the introduction
-to |eqtb| that was given above just before the long lists of parameter names.
-Recall that the ``outer level'' of the program is |level_one|, since
-undefined control sequences are assumed to be ``defined'' at |level_zero|.
+/*tex
 
+At this time it might be a good idea for the reader to review the introduction to
+|eqtb| that was given above just before the long lists of parameter names. Recall
+that the ``outer level'' of the program is |level_one|, since undefined control
+sequences are assumed to be ``defined'' at |level_zero|.
 
+The following macro is used to test if there is room for up to eight more entries
+on |save_stack|. By making a conservative test like this, we can get by with
+testing for overflow in only a few places.
 
-@ The following macro is used to test if there is room for up to eight more
-entries on |save_stack|. By making a conservative test like this, we can
-get by with testing for overflow in only a few places.
+*/
 
-@c
 #define check_full_save_stack() do { \
     if (save_ptr>max_save_stack) { \
         max_save_stack=save_ptr; \
@@ -188,30 +183,32 @@ get by with testing for overflow in only a few places.
     } \
 } while (0)
 
-@ Procedure |new_save_level| is called when a group begins. The
-argument is a group identification code like `|hbox_group|'. After
-calling this routine, it is safe to put six more entries on |save_stack|.
+/*tex
+
+Procedure |new_save_level| is called when a group begins. The argument is a group
+identification code like `|hbox_group|'. After calling this routine, it is safe
+to put six more entries on |save_stack|.
 
-In some cases integer-valued items are placed onto the
-|save_stack| just below a |level_boundary| word, because this is a
-convenient place to keep information that is supposed to ``pop up'' just
-when the group has finished.
-For example, when `\.{\\hbox to 100pt}' is being treated, the 100pt
-dimension is stored on |save_stack| just before |new_save_level| is
-called.
+In some cases integer-valued items are placed onto the |save_stack| just below a
+|level_boundary| word, because this is a convenient place to keep information
+that is supposed to ``pop up'' just when the group has finished. For example,
+when `\.{\\hbox to 100pt}' is being treated, the 100pt dimension is stored on
+|save_stack| just before |new_save_level| is called.
+
+*/
 
-@c
 void new_save_level(group_code c)
-{   /* begin a new level of grouping */
+{   /*tex We begin a new level of grouping. */
     check_full_save_stack();
     set_saved_record(0, saved_line, 0, line);
     incr(save_ptr);
     save_type(save_ptr) = level_boundary;
     save_level(save_ptr) = cur_group;
     save_value(save_ptr) = cur_boundary;
-    if (cur_level == max_quarterword)
+    if (cur_level == max_quarterword) {
         overflow("grouping levels", max_quarterword - min_quarterword);
-    /* quit if |(cur_level+1)| is too big to be stored in |eqtb| */
+    }
+    /*tex We quit if |(cur_level+1)| is too big to be stored in |eqtb|. */
     cur_boundary = save_ptr;
     cur_group = c;
     if (tracing_groups_par > 0)
@@ -220,7 +217,6 @@ void new_save_level(group_code c)
     incr(save_ptr);
 }
 
-@ @c
 static const char *save_stack_type(int v)
 {
     const char *s = "";
@@ -243,13 +239,13 @@ static const char *save_stack_type(int v)
         case saved_boxdir:      s = "saved_boxdir";      break;
         case saved_boxattr:     s = "saved_boxattr";     break;
         case saved_boxpack:     s = "saved_boxpack";     break;
+        case saved_attrlist:    s = "saved_attrlist";    break;
         case saved_eqtb:        s = "saved_eqtb";        break;
         default: break;
     }
     return s;
 }
 
-@ @c
 void print_save_stack(void)
 {
     int i;
@@ -274,7 +270,7 @@ void print_save_stack(void)
                     print_int(save_word(i - 1).cint);
                 } else {
                     print_int(eq_type_field(save_word(i - 1)));
-                    print_char(',');        /* |print_int(eq_level_field(save_word(i-1)));| */
+                    print_char(',');
                     print_int(equiv_field(save_word(i - 1)));
                 }
                 i--;
@@ -303,17 +299,21 @@ void print_save_stack(void)
                 break;
             case saved_adjust:
                 tprint(", ");
-                print_int(save_level(i));   /* vadjust vs vadjust pre */
+                /*tex vadjust vs vadjust pre */
+                print_int(save_level(i));
                 break;
             case saved_insert:
                 tprint(", ");
-                print_int(save_value(i));   /* insert number */
+                /*tex insert number */
+                print_int(save_value(i));
                 break;
-            case saved_boxtype:    /* \.{\\localleftbox} vs \.{\\localrightbox} */
+            case saved_boxtype:
+                /*tex \.{\\localleftbox} vs \.{\\localrightbox} */
                 tprint(", ");
                 print_int(save_value(i));
                 break;
-            case saved_eqno:       /* \.{\\eqno} vs \.{\\leqno} */
+            case saved_eqno:
+                /*tex \.{\\eqno} vs \.{\\leqno} */
                 tprint(", ");
                 print_int(save_value(i));
                 break;
@@ -339,10 +339,11 @@ void print_save_stack(void)
             case saved_textdir:
             case saved_boxdir:
                 tprint(", ");
-                print_dir(dir_dir(save_value(i)));
+                print_dir_text(save_value(i));
                 break;
             case saved_boxattr:
             case saved_boxpack:
+            case saved_attrlist:
                 tprint(", ");
                 print_int(save_value(i));
                 break;
@@ -357,27 +358,28 @@ void print_save_stack(void)
     end_diagnostic(true);
 }
 
-@ The \.{\\showgroups} command displays all currently active grouping
-  levels.
+/*tex
+
+The \.{\\showgroups} command displays all currently active grouping levels.
+
+The modifications of \TeX\ required for the display produced by the
+|show_save_groups| procedure were first discussed by Donald~E. Knuth in {\sl
+TUGboat\/} {\bf 11}, 165--170 and 499--511, 1990. @^Knuth, Donald Ervin@>
 
-@ The modifications of \TeX\ required for the display produced by the
-  |show_save_groups| procedure were first discussed by Donald~E. Knuth in
-  {\sl TUGboat\/} {\bf 11}, 165--170 and 499--511, 1990.
-  @^Knuth, Donald Ervin@>
+In order to understand a group type we also have to know its mode. Since
+unrestricted horizontal modes are not associated with grouping, they are skipped
+when traversing the semantic nest.
 
-  In order to understand a group type we also have to know its mode.
-  Since unrestricted horizontal modes are not associated with grouping,
-  they are skipped when traversing the semantic nest.
+*/
 
-@c
 void show_save_groups(void)
 {
-    int p = nest_ptr;           /* index into |nest| */
-    int m;                      /* mode */
-    save_pointer v = save_ptr;  /* saved value of |save_ptr| */
-    quarterword l = cur_level;  /* saved value of |cur_level| */
-    group_code c = cur_group;   /* saved value of |cur_group| */
-    int a = 1;                  /* to keep track of alignments */
+    int p = nest_ptr;
+    int m;
+    save_pointer v = save_ptr;
+    quarterword l = cur_level;
+    group_code c = cur_group;
+    int a = 1; /* to keep track of alignments */
     int i;
     quarterword j;
     const char *s = NULL;
@@ -447,16 +449,21 @@ void show_save_groups(void)
                 break;
             case disc_group:
                 tprint_esc("discretionary");
-                for (i = 1; i < 3; i++)
-                    if (i <= saved_value(-2))
+                for (i = 1; i < 3; i++) {
+                    if (i <= saved_value(-2)) {
                         tprint("{}");
+                    }
+                }
                 goto FOUND2;
                 break;
             case math_choice_group:
                 tprint_esc("mathchoice");
-                for (i = 1; i < 4; i++)
-                    if (i <= saved_value(-3))       /* different offset because |-2==saved_textdir| */
+                for (i = 1; i < 4; i++) {
+                    /*tex A different offset because |-2==saved_textdir|: */
+                    if (i <= saved_value(-3)) {
                         tprint("{}");
+                    }
+                }
                 goto FOUND2;
                 break;
             case insert_group:
@@ -500,7 +507,7 @@ void show_save_groups(void)
                 confusion("showgroups");
                 break;
         }
-        /* Show the box context */
+        /*tex Show the box context */
         i = saved_value(-5);
         if (i != 0) {
             if (i < box_flag) {
@@ -528,9 +535,8 @@ void show_save_groups(void)
         }
       FOUND1:
         tprint_esc(s);
-        /* Show the box packaging info */
+        /*tex Show the box packaging info. The offsets may vary. */
         {
-            /* offsets may vary */
             int ii = -1;
             while (saved_type(ii) != saved_boxspec)
                 ii--;
@@ -558,18 +564,20 @@ void show_save_groups(void)
     cur_group = c;
 }
 
-@ Just before an entry of |eqtb| is changed, the following procedure should
-be called to update the other data structures properly. It is important
-to keep in mind that reference counts in |mem| include references from
-within |save_stack|, so these counts must be handled carefully.
-@^reference counts@>
+/*tex
+
+Just before an entry of |eqtb| is changed, the following procedure should be
+called to update the other data structures properly. It is important to keep in
+mind that reference counts in |mem| include references from within |save_stack|,
+so these counts must be handled carefully. @^reference counts@>
 
-@c
-/* we don't need to destroy when an assignment has the same node */
+We don't need to destroy when an assignment has the same node:
+
+*/
 
 void eq_destroy(memory_word w)
-{                               /* gets ready to forget |w| */
-    halfword q;                 /* |equiv| field of |w| */
+{
+    halfword q;
     switch (eq_type_field(w)) {
         case call_cmd:
         case long_call_cmd:
@@ -581,10 +589,16 @@ void eq_destroy(memory_word w)
             flush_node(equiv_field(w));
             break;
         case shape_ref_cmd:
-            q = equiv_field(w);     /* we need to free a \.{\\parshape} block */
-            if (q != null)
+            q = equiv_field(w);
+            if (q != null) {
+                /*tex
+                    We need to free a \.{\\parshape} block. Such a block is
+                    |2n+1| words long, where |n=vinfo(q)|. It happens in the
+                    flush function.
+                */
                 flush_node(q);
-            break;                  /* such a block is |2n+1| words long, where |n=vinfo(q)| */
+            }
+            break;
         case box_ref_cmd:
             flush_node_list(equiv_field(w));
             break;
@@ -593,12 +607,14 @@ void eq_destroy(memory_word w)
     }
 }
 
-@ To save a value of |eqtb[p]| that was established at level |l|, we
-can use the following subroutine.
+/*tex
 
-@c
+To save a value of |eqtb[p]| that was established at level |l|, we can use the
+following subroutine.
+
+*/
 void eq_save(halfword p, quarterword l)
-{                               /* saves |eqtb[p]| */
+{
     check_full_save_stack();
     if (l == level_zero) {
         save_type(save_ptr) = restore_zero;
@@ -613,16 +629,17 @@ void eq_save(halfword p, quarterword l)
     incr(save_ptr);
 }
 
-@ The procedure |eq_define| defines an |eqtb| entry having specified
-|eq_type| and |equiv| fields, and saves the former value if appropriate.
-This procedure is used only for entries in the first four regions of |eqtb|,
-i.e., only for entries that have |eq_type| and |equiv| fields.
-After calling this routine, it is safe to put four more entries on
-|save_stack|, provided that there was room for four more entries before
-the call, since |eq_save| makes the necessary test.
+/*tex
+
+The procedure |eq_define| defines an |eqtb| entry having specified |eq_type| and
+|equiv| fields, and saves the former value if appropriate. This procedure is used
+only for entries in the first four regions of |eqtb|, i.e., only for entries that
+have |eq_type| and |equiv| fields. After calling this routine, it is safe to put
+four more entries on |save_stack|, provided that there was room for four more
+entries before the call, since |eq_save| makes the necessary test.
+
+*/
 
-@ new data for |eqtb|
-@c
 void eq_define(halfword p, quarterword t, halfword e)
 {
     boolean trace = tracing_assigns_par > 0;
@@ -645,11 +662,14 @@ void eq_define(halfword p, quarterword t, halfword e)
         diagnostic_trace(p, "into");
 }
 
-@ The counterpart of |eq_define| for the remaining (fullword) positions in
-|eqtb| is called |eq_word_define|. Since |xeq_level[p]>=level_one| for all
-|p|, a `|restore_zero|' will never be used in this case.
+/*tex
+
+The counterpart of |eq_define| for the remaining (fullword) positions in |eqtb|
+is called |eq_word_define|. Since |xeq_level[p]>=level_one| for all |p|, a
+`|restore_zero|' will never be used in this case.
+
+*/
 
-@c
 void eq_word_define(halfword p, int w)
 {
     boolean trace = tracing_assigns_par > 0;
@@ -669,15 +689,17 @@ void eq_word_define(halfword p, int w)
         diagnostic_trace(p, "into");
 }
 
+/*tex
 
-@ The |eq_define| and |eq_word_define| routines take care of local definitions.
-@^global definitions@>
-Global definitions are done in almost the same way, but there is no need
-to save old values, and the new value is associated with |level_one|.
+The |eq_define| and |eq_word_define| routines take care of local definitions.
+@^global definitions@> Global definitions are done in almost the same way, but
+there is no need to save old values, and the new value is associated with
+|level_one|.
+
+*/
 
-@c
 void geq_define(halfword p, quarterword t, halfword e)
-{                               /* global |eq_define| */
+{
     boolean trace = tracing_assigns_par > 0;
     if (trace)
         diagnostic_trace(p, "globally changing");
@@ -690,7 +712,7 @@ void geq_define(halfword p, quarterword t, halfword e)
 }
 
 void geq_word_define(halfword p, int w)
-{                               /* global |eq_word_define| */
+{
     boolean trace = tracing_assigns_par > 0;
     if (trace)
         diagnostic_trace(p, "globally changing");
@@ -700,9 +722,12 @@ void geq_word_define(halfword p, int w)
         diagnostic_trace(p, "into");
 }
 
-@ Subroutine |save_for_after| puts a token on the stack for save-keeping.
+/*tex
+
+Subroutine |save_for_after| puts a token on the stack for save-keeping.
+
+*/
 
-@c
 void save_for_after(halfword t)
 {
     if (cur_level > level_one) {
@@ -714,16 +739,20 @@ void save_for_after(halfword t)
     }
 }
 
-@ The |unsave| routine goes the other way, taking items off of |save_stack|.
-This routine takes care of restoration when a level ends; everything
-belonging to the topmost group is cleared off of the save stack.
+/*tex
+
+The |unsave| routine goes the other way, taking items off of |save_stack|. This
+routine takes care of restoration when a level ends; everything belonging to the
+topmost group is cleared off of the save stack.
+
+*/
 
-@c
 void unsave(void)
-{                               /* pops the top level off the save stack */
-    halfword p;                 /* position to be restored */
-    quarterword l = level_one;  /* saved level, if in fullword regions of |eqtb| */
-    boolean a = false;          /* have we already processed an \.{\\aftergroup} ? */
+{
+    halfword p;
+    quarterword l = level_one;
+    /*tex Variable |a| registers if we already have processed an \.{\\aftergroup}. */
+    boolean a = false;
     unsave_math_codes(cur_level);
     unsave_cat_codes(cat_code_table_par, cur_level);
     unsave_text_codes(cur_level);
@@ -731,7 +760,7 @@ void unsave(void)
     if (cur_level > level_one) {
         boolean trace = tracing_restores_par > 0;
         decr(cur_level);
-        /* Clear off top level from |save_stack| */
+        /*tex Clear off top level from |save_stack|. */
         while (true) {
             decr(save_ptr);
             if (save_type(save_ptr) == level_boundary)
@@ -739,7 +768,8 @@ void unsave(void)
             p = save_value(save_ptr);
             if (save_type(save_ptr) == insert_token) {
                 reinsert_token(a, p);
-                a = true; /* always ... always etex now */
+                /*tex always |true| as we are always in \ETEX\ now. */
+                a = true;
             } else {
                 if (save_type(save_ptr) == restore_old_value) {
                     l = save_level(save_ptr);
@@ -747,21 +777,25 @@ void unsave(void)
                 } else {
                     save_word(save_ptr) = eqtb[undefined_control_sequence];
                 }
-                /* Store |save_stack[save_ptr]| in |eqtb[p]|, unless
-                   |eqtb[p]| holds a global value */
-                /* A global definition, which sets the level to |level_one|,
-                   will not be undone by |unsave|. If at least one global definition of
-                   |eqtb[p]| has been carried out within the group that just ended, the
-                   last such definition will therefore survive.
-                 */
+                /*tex
+                    Store |save_stack[save_ptr]| in |eqtb[p]|, unless |eqtb[p]|
+                    holds a global value A global definition, which sets the
+                    level to |level_one|, will not be undone by |unsave|. If at
+                    least one global definition of |eqtb[p]| has been carried out
+                    within the group that just ended, the last such definition
+                    will therefore survive.
+                */
                 if (p < int_base || p > eqtb_size) {
                     if (eq_level(p) == level_one) {
-                        eq_destroy(save_word(save_ptr));        /* destroy the saved value */
+                        /*tex Destroy the saved value: */
+                        eq_destroy(save_word(save_ptr));
                         if (trace)
                             diagnostic_trace(p, "retaining");
                     } else {
-                        eq_destroy(eqtb[p]);    /* destroy the current value */
-                        eqtb[p] = save_word(save_ptr);  /* restore the saved value */
+                        /*tex Destroy the current value: */
+                        eq_destroy(eqtb[p]);
+                        /*tex Restore the saved value: */
+                        eqtb[p] = save_word(save_ptr);
                         if (trace)
                             diagnostic_trace(p, "restoring");
                     }
@@ -776,32 +810,40 @@ void unsave(void)
                 }
             }
         }
-        if (tracing_groups_par > 0)
+
+        if (tracing_groups_par > 0) {
             group_trace(true);
-        if (grp_stack[in_open] == cur_boundary)
-            group_warning();    /* groups possibly not properly nested with files */
+        }
+        if (grp_stack[in_open] == cur_boundary) {
+            /*tex Groups are possibly not properly nested with files. */
+            group_warning();
+        }
         cur_group = save_level(save_ptr);
         cur_boundary = save_value(save_ptr);
         decr(save_ptr);
     } else {
-        confusion("curlevel");  /* |unsave| is not used when |cur_group=bottom_level| */
+        /*tex |unsave| is not used when |cur_group=bottom_level| */
+        confusion("curlevel");
     }
     attr_list_cache = cache_disabled;
 }
 
-@ Most of the parameters kept in |eqtb| can be changed freely, but there's
-an exception:  The magnification should not be used with two different
-values during any \TeX\ job, since a single magnification is applied to an
-entire run. The global variable |mag_set| is set to the current magnification
-whenever it becomes necessary to ``freeze'' it at a particular value.
+/*tex
+
+Most of the parameters kept in |eqtb| can be changed freely, but there's an
+exception: The magnification should not be used with two different values during
+any \TeX\ job, since a single magnification is applied to an entire run. The
+global variable |mag_set| is set to the current magnification whenever it becomes
+necessary to ``freeze'' it at a particular value.
 
-@c
-int mag_set = 0; /* if nonzero, this magnification should be used henceforth */
+The |prepare_mag| subroutine is called whenever \TeX\ wants to use |mag| for
+magnification. If nonzero, this magnification should be used henceforth. We might
+drop magnifaction at some point.
 
-@ The |prepare_mag| subroutine is called whenever \TeX\ wants to use |mag|
-for magnification.
+*/
+
+int mag_set = 0;
 
-@c
 void prepare_mag(void)
 {
     if ((mag_set > 0) && (mag_par != mag_set)) {
@@ -809,14 +851,18 @@ void prepare_mag(void)
         print_int(mag_par);
         tprint(");");
         tprint_nl(" the previous value will be retained");
-        help2("I can handle only one magnification ratio per job. So I've",
-              "reverted to the magnification you used earlier on this run.");
+        help2(
+            "I can handle only one magnification ratio per job. So I've",
+            "reverted to the magnification you used earlier on this run."
+        );
         int_error(mag_set);
         geq_word_define(int_base + mag_code, mag_set);  /* |mag:=mag_set| */
     }
     if ((mag_par <= 0) || (mag_par > 32768)) {
         print_err("Illegal magnification has been changed to 1000");
-        help1("The magnification ratio must be between 1 and 32768.");
+        help1(
+            "The magnification ratio must be between 1 and 32768."
+        );
         int_error(mag_par);
         geq_word_define(int_base + mag_code, 1000);
     }
@@ -829,65 +875,74 @@ void prepare_mag(void)
     mag_set = mag_par;
 }
 
-@ Let's pause a moment now and try to look at the Big Picture.
-The \TeX\ program consists of three main parts: syntactic routines,
-semantic routines, and output routines. The chief purpose of the
-syntactic routines is to deliver the user's input to the semantic routines,
-one token at a time. The semantic routines act as an interpreter
-responding to these tokens, which may be regarded as commands. And the
-output routines are periodically called on to convert box-and-glue
-lists into a compact set of instructions that will be sent
-to a typesetter. We have discussed the basic data structures and utility
-routines of \TeX, so we are good and ready to plunge into the real activity by
-considering the syntactic routines.
-
-Our current goal is to come to grips with the |get_next| procedure,
-which is the keystone of \TeX's input mechanism. Each call of |get_next|
-sets the value of three variables |cur_cmd|, |cur_chr|, and |cur_cs|,
-representing the next input token.
-$$\vbox{\halign{#\hfil\cr
-  \hbox{|cur_cmd| denotes a command code from the long list of codes
-   given above;}\cr
-  \hbox{|cur_chr| denotes a character code or other modifier of the command
-   code;}\cr
-  \hbox{|cur_cs| is the |eqtb| location of the current control sequence,}\cr
-  \hbox{\qquad if the current token was a control sequence,
-   otherwise it's zero.}\cr}}$$
-Underlying this external behavior of |get_next| is all the machinery
-necessary to convert from character files to tokens. At a given time we
-may be only partially finished with the reading of several files (for
-which \.{\\input} was specified), and partially finished with the expansion
-of some user-defined macros and/or some macro parameters, and partially
-finished with the generation of some text in a template for \.{\\halign},
-and so on. When reading a character file, special characters must be
-classified as math delimiters, etc.; comments and extra blank spaces must
-be removed, paragraphs must be recognized, and control sequences must be
-found in the hash table. Furthermore there are occasions in which the
-scanning routines have looked ahead for a word like `\.{plus}' but only
-part of that word was found, hence a few characters must be put back
-into the input and scanned again.
-
-To handle these situations, which might all be present simultaneously,
-\TeX\ uses various stacks that hold information about the incomplete
-activities, and there is a finite state control for each level of the
-input mechanism. These stacks record the current state of an implicitly
-recursive process, but the |get_next| procedure is not recursive.
-Therefore it will not be difficult to translate these algorithms into
-low-level languages that do not support recursion.
-
-@c
-int cur_cmd;                    /* current command set by |get_next| */
-halfword cur_chr;               /* operand of current command */
-halfword cur_cs;                /* control sequence found here, zero if none found */
-halfword cur_tok;               /* packed representative of |cur_cmd| and |cur_chr| */
-
-@ Here is a procedure that displays the current command.
-
-@c
+/*tex
+
+Let's pause a moment now and try to look at the Big Picture. The \TeX\ program
+consists of three main parts: syntactic routines, semantic routines, and output
+routines. The chief purpose of the syntactic routines is to deliver the user's
+input to the semantic routines, one token at a time. The semantic routines act as
+an interpreter responding to these tokens, which may be regarded as commands. And
+the output routines are periodically called on to convert box-and-glue lists into
+a compact set of instructions that will be sent to a typesetter. We have
+discussed the basic data structures and utility routines of \TeX, so we are good
+and ready to plunge into the real activity by considering the syntactic routines.
+
+Our current goal is to come to grips with the |get_next| procedure, which is the
+keystone of \TeX's input mechanism. Each call of |get_next| sets the value of
+three variables |cur_cmd|, |cur_chr|, and |cur_cs|, representing the next input
+token.
+
+$$
+    \vbox{\halign{#\hfil\cr
+        \hbox{|cur_cmd| denotes a command code from the long list of codes given above;}\cr
+        \hbox{|cur_chr| denotes a character code or other modifier of the command code;}\cr
+        \hbox{|cur_cs| is the |eqtb| location of the current control sequence,}\cr
+        \hbox{\qquad if the current token was a control sequence, otherwise it's zero.}\cr}}
+$$
+
+Underlying this external behavior of |get_next| is all the machinery necessary to
+convert from character files to tokens. At a given time we may be only partially
+finished with the reading of several files (for which \.{\\input} was specified),
+and partially finished with the expansion of some user-defined macros and/or some
+macro parameters, and partially finished with the generation of some text in a
+template for \.{\\halign}, and so on. When reading a character file, special
+characters must be classified as math delimiters, etc.; comments and extra blank
+spaces must be removed, paragraphs must be recognized, and control sequences must
+be found in the hash table. Furthermore there are occasions in which the scanning
+routines have looked ahead for a word like `\.{plus}' but only part of that word
+was found, hence a few characters must be put back into the input and scanned
+again.
+
+To handle these situations, which might all be present simultaneously, \TeX\ uses
+various stacks that hold information about the incomplete activities, and there
+is a finite state control for each level of the input mechanism. These stacks
+record the current state of an implicitly recursive process, but the |get_next|
+procedure is not recursive. Therefore it will not be difficult to translate these
+algorithms into low-level languages that do not support recursion.
+
+In general, |cur_cmd| is the current command as set by |get_next|, while
+|cur_chr| is the operand of the current command. The control sequence found here
+is registsred in |cur_cs| and is zero if none found. The |cur_tok| variable
+contains the packed representative of |cur_cmd| and |cur_chr| and like the other
+ones is global.
+
+*/
+
+int cur_cmd;
+halfword cur_chr;
+halfword cur_cs;
+halfword cur_tok;
+
+/*tex
+
+Here is a procedure that displays the current command. The variable |n| holds the
+level of \.{\\if...\\fi} nesting and |l| the line where \.{\\if} started.
+
+*/
+
 void show_cur_cmd_chr(void)
 {
-    int n;                      /* level of \.{\\if...\\fi} nesting */
-    int l;                      /* line where \.{\\if} started */
+    int n, l;
     halfword p;
     begin_diagnostic();
     tprint_nl("{");
@@ -926,23 +981,26 @@ void show_cur_cmd_chr(void)
     end_diagnostic(false);
 }
 
-@ Here is a procedure that displays the contents of |eqtb[n]| symbolically.
+/*tex
+
+Here is a procedure that displays the contents of |eqtb[n]| symbolically.
+
+*/
 
-@c
 void show_eqtb(halfword n)
 {
     if (n < null_cs) {
-        /* this can't happen */
-        print_char('?');
+        /*tex
+            This can't happen in a pure \TEX\ run, but careless usage of tokens
+            at the \LUA\ end can make you end up here.
+        */
+        tprint("? bad token, case 1: ");
+        print_int(n);
     } else if ((n < glue_base) || ((n > eqtb_size) && (n <= eqtb_top))) {
-        /*
-            Show equivalent |n|, in region 1 or 2
-
-            Here is a routine that displays the current meaning of an |eqtb| entry
-            in region 1 or~2. (Similar routines for the other regions will appear
-            below.)
+        /*tex
+            This routine show the current meaning of |eqtb| entry |n| in region 1 or 2.
+            Similar routines for the other regions will appear below.
         */
-
         sprint_cs(n);
         print_char('=');
         print_cmd_chr(eq_type(n), equiv(n));
@@ -951,10 +1009,9 @@ void show_eqtb(halfword n)
             show_token_list(token_link(equiv(n)), null, 32);
         }
     } else if (n < local_base) {
-        /*
-            Show equivalent |n|, in region 3
-
-            All glue parameters and registers are initially `\.{0pt plus0pt minus0pt}'.
+        /*tex
+            Here we show equivalent |n| in region 3. All glue parameters and registers
+            are initially `\.{0pt plus0pt minus0pt}'.
         */
         if (n < skip_base) {
             if (n < glue_base + thin_mu_skip_code)
@@ -979,18 +1036,17 @@ void show_eqtb(halfword n)
         }
 
     } else if (n < int_base) {
-        /*
-            Show equivalent |n|, in region 4
-
-            We initialize most things to null or undefined values. An undefined font
-            is represented by the internal code |font_base|.
-
-            However, the character code tables are given initial values based on the
-            conventional interpretation of ASCII code. These initial values should
-            not be changed when \TeX\ is adapted for use with non-English languages;
-            all changes to the initialization conventions should be made in format
-            packages, not in \TeX\ itself, so that global interchange of formats is
-            possible.
+        /*tex
+            We're now at equivalent |n| in region 4. First we initialize most
+            things to null or undefined values. An undefined font is represented
+            by the internal code |font_base|.
+
+            However, the character code tables are given initial values based on
+            the conventional interpretation of ASCII code. These initial values
+            should not be changed when \TeX\ is adapted for use with non-English
+            languages; all changes to the initialization conventions should be
+            made in format packages, not in \TeX\ itself, so that global
+            interchange of formats is possible.
         */
         if ((n == par_shape_loc) || ((n >= etex_pen_base) && (n < etex_pens))) {
             if (n == par_shape_loc)
@@ -1032,13 +1088,16 @@ void show_eqtb(halfword n)
                 show_node_list(equiv(n));
             }
         } else if (n == cur_font_loc) {
-            /* Show the font identifier in |eqtb[n]| */
+            /*tex
+                Let's show the font identifier in |eqtb[n]|, that's
+                |font_id_text(equiv(n))|
+            */
             tprint("current font");
             print_char('=');
-            print_esc(hash[font_id_base + equiv(n)].rh);        /* that's |font_id_text(equiv(n))| */
+            print_esc(hash[font_id_base + equiv(n)].rh);
         }
     } else if (n < dimen_base) {
-        /* Show equivalent |n|, in region 5 */
+        /*tex Show equivalent |n| in region 5: */
         if (n < dir_base) {
             print_cmd_chr(assign_int_cmd, n);
             print_char('=');
@@ -1046,7 +1105,7 @@ void show_eqtb(halfword n)
         } else if (n < count_base) {
             print_cmd_chr(assign_dir_cmd, n);
             print_char(' ');
-            print_dir(eqtb[n].cint);
+            print_dir_par(eqtb[n].cint);
         } else if (n < attribute_base) {
             tprint_esc("count");
             print_int(n - count_base);
@@ -1059,7 +1118,7 @@ void show_eqtb(halfword n)
             print_int(eqtb[n].cint);
         }
     } else if (n <= eqtb_size) {
-        /* Show equivalent |n|, in region 6 */
+        /*tex Show equivalent |n| in region 6: */
         if (n < scaled_base) {
             print_cmd_chr(assign_dimen_cmd, n);
         } else {
@@ -1070,31 +1129,28 @@ void show_eqtb(halfword n)
         print_scaled(eqtb[n].cint);
         tprint("pt");
     } else {
-        /* this can't happen either */
-        print_char('?');
+        /*tex This can't happen unless you messed up at the \LUA\ end. */
+        tprint("? bad token, case 2: ");
+        print_int(n);
     }
 }
 
-@ @c
 void show_eqtb_meaning(halfword n)
 {
     if (n < null_cs) {
-        /* this can't happen */
+        /*tex This can't happen. */
         print_char('?');
     } else if ((n < glue_base) || ((n > eqtb_size) && (n <= eqtb_top))) {
-        /*
-            Show equivalent |n|, in region 1 or 2
-
-            Here is a routine that displays the current meaning of an |eqtb| entry
-            in region 1 or~2. (Similar routines for the other regions will appear
-            below.)
+        /*tex
+            Here is a routine that displays the current meaning of an |eqtb|
+            entry in region 1 or~2. Similar routines for the other regions will
+            appear below.
         */
         sprint_cs(n);
     } else if (n < local_base) {
         /*
-            Show equivalent |n|, in region 3
-
-            All glue parameters and registers are initially `\.{0pt plus0pt minus0pt}'.
+            Show equivalent |n| in region 3. All glue parameters and registers
+            are initially `\.{0pt plus0pt minus0pt}'.
         */
         if (n < skip_base) {
             if (n < glue_base + thin_mu_skip_code)
@@ -1108,20 +1164,16 @@ void show_eqtb_meaning(halfword n)
             tprint_esc("muskip");
             print_int(n - mu_skip_base);
         }
-
     } else if (n < int_base) {
-        /*
-            Show equivalent |n|, in region 4
-
-            We initialize most things to null or undefined values. An undefined font
-            is represented by the internal code |font_base|.
-
-            However, the character code tables are given initial values based on the
-            conventional interpretation of ASCII code. These initial values should
-            not be changed when \TeX\ is adapted for use with non-English languages;
-            all changes to the initialization conventions should be made in format
-            packages, not in \TeX\ itself, so that global interchange of formats is
-            possible.
+        /*tex
+            Show equivalent |n| in region 4. We initialize most things to null or
+            undefined values. An undefined font is represented by the internal
+            code |font_base|. However, the character code tables are given
+            initial values based on the conventional interpretation of ASCII
+            code. These initial values should not be changed when \TeX\ is
+            adapted for use with non-English languages; all changes to the
+            initialization conventions should be made in format packages, not in
+            \TeX\ itself, so that global interchange of formats is possible.
         */
         if ((n == par_shape_loc) || ((n >= etex_pen_base) && (n < etex_pens))) {
             if (n == par_shape_loc)
@@ -1137,11 +1189,11 @@ void show_eqtb_meaning(halfword n)
             tprint_esc("box");
             print_int(n - box_base);
         } else if (n == cur_font_loc) {
-            /* Show the font identifier in |eqtb[n]| */
+            /*tex Show the font identifier in |eqtb[n]|. */
             tprint("current font");
         }
     } else if (n < dimen_base) {
-        /* Show equivalent |n|, in region 5 */
+        /*tex Show equivalent |n| in region 5. */
         if (n < dir_base) {
             print_cmd_chr(assign_int_cmd, n);
         } else if (n < count_base) {
@@ -1154,7 +1206,7 @@ void show_eqtb_meaning(halfword n)
             print_int(n - attribute_base);
         }
     } else if (n <= eqtb_size) {
-        /* Show equivalent |n|, in region 6 */
+        /*tex Show equivalent |n| in region 6. */
         if (n < scaled_base) {
             print_cmd_chr(assign_dimen_cmd, n);
         } else {
@@ -1162,7 +1214,7 @@ void show_eqtb_meaning(halfword n)
             print_int(n - scaled_base);
         }
     } else {
-        /* this can't happen either */
+        /*tex This can't happen either. */
         print_char('?');
     }
 }
diff --git a/texk/web2c/luatexdir/tex/errors.c b/texk/web2c/luatexdir/tex/errors.c
new file mode 100644
index 000000000..b630422ee
--- /dev/null
+++ b/texk/web2c/luatexdir/tex/errors.c
@@ -0,0 +1,1032 @@
+/*
+
+errors.w
+
+Copyright 2009-2010 Taco Hoekwater <taco@@luatex.org>
+
+This file is part of LuaTeX.
+
+LuaTeX is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 2 of the License, or (at your
+option) any later version.
+
+LuaTeX is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+License for more details.
+
+You should have received a copy of the GNU General Public License along
+with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#include "ptexlib.h"
+#define edit_var "TEXEDIT"
+
+/*tex
+
+When something anomalous is detected, \TeX\ typically does something like this:
+$$\vbox{\halign{#\hfil\cr |print_err("Something anomalous has been
+detected");|\cr |help3("This is the first line of my offer to help.")|\cr |("This
+is the second line. I'm trying to")|\cr |("explain the best way for you to
+proceed.");|\cr |error;|\cr}}$$ A two-line help message would be given using
+|help2|, etc.; these informal helps should use simple vocabulary that complements
+the words used in the official error message that was printed. (Outside the
+U.S.A., the help messages should preferably be translated into the local
+vernacular. Each line of help is at most 60 characters long, in the present
+implementation, so that |max_print_line| will not be exceeded.)
+
+The |print_err| procedure supplies a `\.!' before the official message, and makes
+sure that the terminal is awake if a stop is going to occur. The |error|
+procedure supplies a `\..' after the official message, then it shows the location
+of the error; and if |interaction=error_stop_mode|, it also enters into a dialog
+with the user, during which time the help message may be printed. @^system
+dependencies@>
+
+*/
+
+/*tex The current level of interaction: */
+
+int interaction;
+
+/*tex Set from the command line: */
+
+int interactionoption;
+
+char *last_error = NULL;
+char *last_lua_error = NULL;
+char *last_warning_tag = NULL;
+char *last_warning_str = NULL;
+char *last_error_context = NULL;
+
+int err_old_setting = 0 ;
+int in_error = 0 ;
+
+void set_last_error_context(void)
+{
+    str_number str;
+    int sel = selector;
+    int saved_new_line_char;
+    int saved_new_string_line;
+    selector = new_string;
+    saved_new_line_char = new_line_char_par;
+    saved_new_string_line = new_string_line;
+    new_line_char_par = 10;
+    new_string_line = 10;
+    show_context();
+    xfree(last_error_context);
+    str = make_string();
+    last_error_context = makecstring(str);
+    flush_str(str);
+    selector = sel;
+    new_line_char_par = saved_new_line_char;
+    new_string_line = saved_new_string_line;
+    return;
+}
+
+void flush_err(void)
+{
+    str_number s_error;
+    char *s = NULL;
+    int callback_id ;
+    if (in_error) {
+        selector = err_old_setting;
+        str_room(1);
+        s_error = make_string();
+        s = makecstring(s_error);
+        flush_str(s_error);
+        if (interaction == error_stop_mode) {
+            wake_up_terminal();
+        }
+        xfree(last_error);
+        last_error = (string) xmalloc((unsigned) (strlen(s) + 1));
+        strcpy(last_error,s);
+        callback_id = callback_defined(show_error_message_callback);
+        if (callback_id > 0) {
+            run_callback(callback_id, "->");
+        } else {
+            tprint(s);
+        }
+        in_error = 0 ;
+    }
+}
+
+void print_err(const char *s)
+{
+    int callback_id = callback_defined(show_error_message_callback);
+    if (interaction == error_stop_mode) {
+        wake_up_terminal();
+    }
+    if (callback_id > 0) {
+        err_old_setting = selector;
+        selector = new_string;
+        in_error = 1 ;
+    }
+    if (filelineerrorstylep) {
+        print_file_line();
+    } else {
+        tprint_nl("! ");
+    }
+    tprint(s);
+    if (callback_id <= 0) {
+        xfree(last_error);
+        last_error = (string) xmalloc((unsigned) (strlen(s) + 1));
+        strcpy(last_error,s);
+    }
+}
+
+/*tex
+
+\TeX\ is careful not to call |error| when the print |selector| setting might be
+unusual. The only possible values of |selector| at the time of error messages are
+
+|no_print| (when |interaction=batch_mode| and |log_file| not yet open);
+
+|term_only| (when |interaction>batch_mode| and |log_file| not yet open);
+
+|log_only| (when |interaction=batch_mode| and |log_file| is open);
+
+|term_and_log| (when |interaction>batch_mode| and |log_file| is open).
+
+*/
+
+void fixup_selector(boolean logopened)
+{
+    if (interaction == batch_mode)
+        selector = no_print;
+    else
+        selector = term_only;
+    if (logopened)
+        selector = selector + 2;
+}
+
+/*tex
+
+A global variable |deletions_allowed| is set |false| if the |get_next| routine is
+active when |error| is called; this ensures that |get_next| and related routines
+like |get_token| will never be called recursively. A similar interlock is
+provided by |set_box_allowed|. @^recursion@>
+
+The global variable |history| records the worst level of error that has been
+detected. It has four possible values: |spotless|, |warning_issued|,
+|error_message_issued|, and |fatal_error_stop|.
+
+Another global variable, |error_count|, is increased by one when an |error|
+occurs without an interactive dialog, and it is reset to zero at the end of every
+paragraph. If |error_count| reaches 100, \TeX\ decides that there is no point in
+continuing further.
+
+*/
+
+/*tex Is it safe for |error| to call |get_token|? */
+
+boolean deletions_allowed;
+
+/*tex Is it safe to do a \.{\\setbox} assignment? */
+
+boolean set_box_allowed;
+/*tex Has the source input been clean so far? */
+
+int history;
+
+/*tex The number of scrolled errors since the last paragraph ended. */
+
+int error_count;
+
+/*tex Should \TeX\ pause for instructions? */
+
+int interrupt;
+
+/*tex Should interrupts be observed? */
+
+boolean OK_to_interrupt;
+
+/*tex
+
+The value of |history| is initially |fatal_error_stop|, but it will be changed to
+|spotless| if \TeX\ survives the initialization process.
+
+*/
+
+void initialize_errors(void)
+{
+    if (interactionoption == unspecified_mode)
+        interaction = error_stop_mode;
+    else
+        interaction = interactionoption;
+    deletions_allowed = true;
+    set_box_allowed = true;
+    OK_to_interrupt = true;
+}
+
+/*tex
+
+It is possible for |error| to be called recursively if some error arises when
+|get_token| is being used to delete a token, and/or if some fatal error occurs
+while \TeX\ is trying to fix a non-fatal one. But such recursion @^recursion@> is
+never more than two levels deep.
+
+Individual lines of help are recorded in the array |help_line|.
+
+*/
+
+const char *help_line[7];
+
+/*tex
+    Should the |err_help| list be shown?
+*/
+
+boolean use_err_help;
+
+/*tex
+
+The |jump_out| procedure just cuts across all active procedure levels and exits
+the program. It is used when there is no recovery from a particular error. The
+exit code can be overloaded.
+
+*/
+
+int defaultexitcode = 0;
+
+__attribute__ ((noreturn))
+void do_final_end(void)
+{
+    update_terminal();
+    ready_already = 0;
+    lua_close(Luas);
+    if ((history != spotless) && (history != warning_issued))
+        uexit(1);
+    else
+        uexit(defaultexitcode);
+}
+
+__attribute__ ((noreturn))
+void jump_out(void)
+{
+    close_files_and_terminate();
+    do_final_end();
+}
+
+/*tex
+
+Here is the function that calls the editor, if one is defined. This is loosely
+based on a similar function in kpathsea, but the calling convention is quite
+different.
+
+*/
+
+static const_string edit_value = EDITOR;
+
+#if defined(WIN32)
+
+static int Isspace (char c)
+{
+    return (c == ' ' || c == '\t');
+}
+
+#endif /* WIN32 */
+
+__attribute__ ((noreturn))
+static void luatex_calledit (int baseptr, int linenumber)
+{
+    char *temp, *command, *fullcmd;
+    char c;
+    int sdone, ddone, i;
+    char *filename = makecstring(input_stack[base_ptr].name_field);
+    int fnlength = strlen(filename);
+#ifdef WIN32
+    char *fp, *ffp, *env, editorname[256], buffer[256];
+    int cnt = 0;
+    int dontchange = 0;
+#endif
+    sdone = ddone = 0;
+    /*tex
+        Close any open input files, since we're going to kill the job.
+    */
+    close_files_and_terminate();
+    /*tex
+        Replace the default with the value of the appropriate environment
+        variable or config file value, if it's set.
+    */
+    temp = kpse_var_value (edit_var);
+    if (temp != NULL)
+        edit_value = temp;
+    /*tex
+        Construct the command string.  The `11' is the maximum length an
+        integer might be.
+    */
+    command = xmalloc (strlen (edit_value) + fnlength + 11);
+    /*tex
+        So we can construct it as we go.
+    */
+    temp = command;
+#ifdef WIN32
+    fp = editorname;
+    if ((isalpha(*edit_value) && *(edit_value + 1) == ':' && IS_DIR_SEP (*(edit_value + 2)))
+            || (*edit_value == '"' && isalpha(*(edit_value + 1))
+            && *(edit_value + 2) == ':' && IS_DIR_SEP (*(edit_value + 3)))) {
+        dontchange = 1;
+    }
+#endif
+    while ((c = *edit_value++) != 0) {
+        if (c == '%') {
+            switch (c = *edit_value++) {
+                case 'd':
+                    if (ddone)
+                        FATAL1 ("call_edit: `%%d' appears twice in editor command: `%s'", edit_value);
+                    sprintf (temp, "%ld", (long int)linenumber);
+                    while (*temp != '\0')
+                        temp++;
+                    ddone = 1;
+                    break;
+                case 's':
+                    if (sdone)
+                        FATAL1 ("call_edit: `%%s' appears twice in editor command: `%s'", edit_value);
+                    for (i =0; i < fnlength; i++)
+                        *temp++ = filename[i];
+                    sdone = 1;
+                    break;
+                case '\0':
+                    *temp++ = '%';
+                    /*tex
+                        Back up to the null to force termination.
+                    */
+                    edit_value--;
+                    break;
+                default:
+                    *temp++ = '%';
+                    *temp++ = c;
+                    break;
+            }
+        } else {
+#ifdef WIN32
+            if (dontchange) {
+                *temp++ = c;
+            } else if(Isspace(c) && cnt == 0) {
+                cnt++;
+                temp = command;
+                *temp++ = c;
+                *fp = '\0';
+            } else if(!Isspace(c) && cnt == 0) {
+                *fp++ = c;
+            } else {
+                *temp++ = c;
+            }
+#else
+            *temp++ = c;
+#endif
+        }
+    }
+    *temp = 0;
+#ifdef WIN32
+    if (dontchange == 0) {
+        if(editorname[0] == '.' || editorname[0] == '/' || editorname[0] == '\\') {
+            fprintf(stderr, "%s is not allowed to execute.\n", editorname);
+            do_final_end();
+        }
+        env = (char *)getenv("PATH");
+        if(SearchPath(env, editorname, ".exe", 256, buffer, &ffp)==0) {
+            if(SearchPath(env, editorname, ".bat", 256, buffer, &ffp)==0) {
+                fprintf(stderr, "I cannot find %s in the PATH.\n", editorname);
+                do_final_end();
+            }
+        }
+        fullcmd = (char *)xmalloc(strlen(buffer)+strlen(command)+5);
+        strcpy(fullcmd, "\"");
+        strcat(fullcmd, buffer);
+        strcat(fullcmd, "\"");
+        strcat(fullcmd, command);
+    }
+#endif
+    fullcmd = command;
+    /*tex Execute the command. */
+    if (system (fullcmd) != 0) {
+        fprintf (stderr, "! Trouble executing `%s'.\n", command);
+    }
+    /*tex Quit, since we found an error.  */
+    do_final_end ();
+}
+
+/*tex
+
+  This completes the job of error reporting.
+
+*/
+
+void error(void)
+{
+    /*tex What the user types :*/
+    ASCII_code c;
+    int callback_id;
+    /*tex Used to save global variables when deleting tokens: */
+    int s1, s2, s3, s4;
+    int i;
+    flush_err();
+    if (history < error_message_issued)
+        history = error_message_issued;
+    callback_id = callback_defined(show_error_hook_callback);
+    if (callback_id > 0) {
+        set_last_error_context();
+        run_callback(callback_id, "->");
+    } else {
+        print_char('.');
+        show_context();
+    }
+    if (haltonerrorp) {
+        history = fatal_error_stop;
+        jump_out();
+    }
+    if (interaction == error_stop_mode) {
+        /*tex Get user's advice and |return|. */
+        while (1) {
+          CONTINUE:
+            clear_for_error_prompt();
+            prompt_input("? ");
+            if (last == first)
+                return;
+            c = buffer[first];
+            if (c >= 'a')
+                c = c + 'A' - 'a';
+                /*tex
+                    Interpret code |c| and |return| if done. It is desirable to
+                    provide an `\.E' option here that gives the user an easy way
+                    to return from \TeX\ to the system editor, with the offending
+                    line ready to be edited. But such an extension requires some
+                    system wizardry, so the present implementation simply types
+                    out the name of the file that should be edited and the
+                    relevant line number.
+                */
+            switch (c) {
+            case '0':
+            case '1':
+            case '2':
+            case '3':
+            case '4':
+            case '5':
+            case '6':
+            case '7':
+            case '8':
+            case '9':
+                if (deletions_allowed) {
+                    /*tex
+                        Delete |c-"0"| tokens and |goto continue|. We allow
+                        deletion of up to 99 tokens at a time.
+                    */
+                    s1 = cur_tok;
+                    s2 = cur_cmd;
+                    s3 = cur_chr;
+                    s4 = align_state;
+                    align_state = 1000000;
+                    OK_to_interrupt = false;
+                    if ((last > first + 1) && (buffer[first + 1] >= '0')
+                        && (buffer[first + 1] <= '9'))
+                        c = c * 10 + buffer[first + 1] - '0' * 11;
+                    else
+                        c = c - '0';
+                    while (c > 0) {
+                        /*tex One-level recursive call of |error| is possible. */
+                        get_token();
+                        decr(c);
+                    }
+                    cur_tok = s1;
+                    cur_cmd = s2;
+                    cur_chr = s3;
+                    align_state = s4;
+                    OK_to_interrupt = true;
+                    help2(
+                        "I have just deleted some text, as you asked.",
+                        "You can now delete more, or insert, or whatever."
+                    );
+                    show_context();
+                    goto CONTINUE;
+                }
+                break;
+            case 'E':
+                if (base_ptr > 0) {
+                    int callback_id = callback_defined(call_edit_callback);
+                    if (callback_id>0) {
+                        (void)run_callback(callback_id, "Sd->", makecstring(input_stack[base_ptr].name_field), line);
+                        /*tex This should not be reached. */
+                        jump_out();
+                    } else {
+                        tprint_nl("You want to edit file ");
+                        print(input_stack[base_ptr].name_field);
+                        tprint(" at line ");
+                        print_int(line);
+                        interaction = scroll_mode;
+                        if (kpse_init) {
+                            luatex_calledit(base_ptr, line);
+                        } else {
+                            /*tex This should not be reached. */
+                            tprint_nl("There is no valid callback defined.");
+                            jump_out();
+                        }
+                    }
+                }
+                break;
+            case 'H':
+                /*tex Print the help information and |goto continue| */
+                if (use_err_help) {
+                    give_err_help();
+                } else {
+                    if (help_line[0] == NULL) {
+                        help2(
+                            "Sorry, I don't know how to help in this situation.",
+                            "Maybe you should try asking a human?"
+                        );
+                    }
+                    i = 0;
+                    while (help_line[i] != NULL)
+                        tprint_nl(help_line[i++]);
+                    help4(
+                        "Sorry, I already gave what help I could...",
+                        "Maybe you should try asking a human?",
+                        "An error might have occurred before I noticed any problems.",
+                        "``If all else fails, read the instructions.''"
+                    );
+                    goto CONTINUE;
+                }
+                break;
+            case 'I':
+                /*tex
+
+                    Introduce new material from the terminal and |return|. When
+                    the following code is executed, |buffer[(first+1)..(last-1)]|
+                    may contain the material inserted by the user; otherwise
+                    another prompt will be given. In order to understand this
+                    part of the program fully, you need to be familiar with
+                    \TeX's input stacks.
+
+                    We enter a new syntactic level for terminal input:
+
+                */
+                begin_file_reading();
+                /*tex
+                    Now |state=mid_line|, so an initial blank space will count as
+                    a blank.
+                */
+                if (last > first + 1) {
+                    iloc = first + 1;
+                    buffer[first] = ' ';
+                } else {
+                    prompt_input("insert>");
+                    iloc = first;
+                }
+                first = last;
+                /*tex No |end_line_char| ends this line. */
+                ilimit = last - 1;
+                return;
+                break;
+            case 'Q':
+            case 'R':
+            case 'S':
+                /*tex
+
+                    Change the interaction level and |return|. Here the author of
+                    \TeX\ apologizes for making use of the numerical relation
+                    between |"Q"|, |"R"|, |"S"|, and the desired interaction
+                    settings |batch_mode|, |nonstop_mode|, |scroll_mode|.
+
+                */
+                error_count = 0;
+                interaction = batch_mode + c - 'Q';
+                tprint("OK, entering ");
+                switch (c) {
+                case 'Q':
+                    tprint_esc("batchmode");
+                    decr(selector);
+                    break;
+                case 'R':
+                    tprint_esc("nonstopmode");
+                    break;
+                case 'S':
+                    tprint_esc("scrollmode");
+                    break;
+                }
+                tprint("...");
+                print_ln();
+                update_terminal();
+                return;
+                break;
+            case 'X':
+                interaction = scroll_mode;
+                jump_out();
+                break;
+            default:
+                break;
+            }
+            if (!use_err_help) {
+                /* Print the menu of available options */
+                tprint("Type <return> to proceed, S to scroll future error messages,");
+                tprint_nl("R to run without stopping, Q to run quietly,");
+                tprint_nl("I to insert something, ");
+                if (base_ptr > 0)
+                    tprint("E to edit your file,");
+                if (deletions_allowed)
+                    tprint_nl("1 or ... or 9 to ignore the next 1 to 9 tokens of input,");
+                tprint_nl("H for help, X to quit.");
+            }
+            use_err_help = false;
+        }
+
+    }
+    incr(error_count);
+    if (error_count == 100) {
+        tprint_nl("(That makes 100 errors; please try again.)");
+        history = fatal_error_stop;
+        jump_out();
+    }
+    /*tex Put help message on the transcript file. */
+    if (interaction > batch_mode) {
+        /*tex Avoid terminal output: */
+        decr(selector);
+    }
+    if (use_err_help) {
+        print_ln();
+        give_err_help();
+    } else {
+        int i1 = 0;
+        while (help_line[i1] != NULL)
+            tprint_nl(help_line[i1++]);
+    }
+    print_ln();
+    if (interaction > batch_mode) {
+        /*tex Re-enable terminal output: */
+        incr(selector);
+    }
+    print_ln();
+}
+
+/*tex
+
+A dozen or so error messages end with a parenthesized integer, so we save a teeny
+bit of program space by declaring the following procedure:
+
+*/
+
+void int_error(int n)
+{
+    tprint(" (");
+    print_int(n);
+    print_char(')');
+    error();
+}
+
+/*tex
+
+In anomalous cases, the print selector might be in an unknown state; the
+following subroutine is called to fix things just enough to keep running a bit
+longer.
+
+*/
+
+void normalize_selector(void)
+{
+    if (log_opened_global)
+        selector = term_and_log;
+    else
+        selector = term_only;
+    if (job_name == 0)
+        open_log_file();
+    if (interaction == batch_mode)
+        decr(selector);
+}
+
+/*tex
+
+The following procedure prints \TeX's last words before dying.
+
+*/
+
+void succumb(void)
+{
+    if (interaction == error_stop_mode) {
+        /*tex No more interaction: */
+        interaction = scroll_mode;
+    }
+    if (log_opened_global) {
+        error();
+    }
+    history = fatal_error_stop;
+    /*tex Irrecoverable error: */
+    jump_out();
+}
+
+/*tex
+
+This prints |s|, and that's it.
+
+*/
+
+void fatal_error(const char *s)
+{
+    normalize_selector();
+    print_err("Emergency stop");
+    help1(s);
+    succumb();
+}
+
+/*tex
+
+Here is the most dreaded error message. We stop due to finiteness.
+
+*/
+
+void overflow(const char *s, unsigned int n)
+{
+    normalize_selector();
+    print_err("TeX capacity exceeded, sorry [");
+    tprint(s);
+    print_char('=');
+    print_int((int) n);
+    print_char(']');
+    if (varmem == NULL) {
+      print_err("Sorry, I ran out of memory.");
+      print_ln();
+      exit(EXIT_FAILURE);
+    }
+    help2(
+        "If you really absolutely need more capacity,",
+        "you can ask a wizard to enlarge me."
+    );
+    succumb();
+}
+
+/*tex
+
+The program might sometime run completely amok, at which point there is no choice
+but to stop. If no previous error has been detected, that's bad news; a message
+is printed that is really intended for the \TeX\ maintenance person instead of
+the user (unless the user has been particularly diabolical). The index entries
+for `this can't happen' may help to pinpoint the problem. @^dry rot@>
+
+*/
+
+void confusion(const char *s)
+{                               /* consistency check violated; |s| tells where */
+    normalize_selector();
+    if (history < error_message_issued) {
+        print_err("This can't happen (");
+        tprint(s);
+        print_char(')');
+        help1(
+            "I'm broken. Please show this to someone who can fix"
+        );
+    } else {
+        print_err("I can't go on meeting you like this");
+        help2(
+            "One of your faux pas seems to have wounded me deeply...",
+            "in fact, I'm barely conscious. Please fix it and try again."
+        );
+    }
+    succumb();
+}
+
+/*tex
+
+Users occasionally want to interrupt \TeX\ while it's running. If the runtime
+system allows this, one can implement a routine that sets the global variable
+|interrupt| to some nonzero value when such an interrupt is signalled. Otherwise
+there is probably at least a way to make |interrupt| nonzero using the debugger.
+@^system dependencies@> @^debugging@>
+
+*/
+
+void check_interrupt(void)
+{
+    if (interrupt != 0)
+        pause_for_instructions();
+}
+
+/*tex
+
+When an interrupt has been detected, the program goes into its highest
+interaction level and lets the user have nearly the full flexibility of the
+|error| routine. \TeX\ checks for interrupts only at times when it is safe to do
+this.
+
+*/
+
+void pause_for_instructions(void)
+{
+    if (OK_to_interrupt) {
+        interaction = error_stop_mode;
+        if ((selector == log_only) || (selector == no_print))
+            incr(selector);
+        print_err("Interruption");
+        help3(
+            "You rang?",
+            "Try to insert some instructions for me (e.g.,`I\\showlists'),",
+            "unless you just want to quit by typing `X'."
+        );
+        deletions_allowed = false;
+        error();
+        deletions_allowed = true;
+        interrupt = 0;
+    }
+}
+
+void tex_error(const char *msg, const char **hlp)
+{
+    print_err(msg);
+    if (hlp != NULL) {
+        int i;
+        for (i = 0; (hlp[i] != NULL && i <= 5); i++) {
+            help_line[i] = hlp[i];
+        }
+        help_line[i] = NULL;
+    } else {
+        help_line[0] = NULL;
+    }
+    error();
+}
+
+/*tex
+
+The |back_error| routine is used when we want to replace an offending token just
+before issuing an error message. This routine, like |back_input|, requires that
+|cur_tok| has been set. We disable interrupts during the call of |back_input| so
+that the help message won't be lost.
+
+*/
+
+void back_error(void)
+{
+    OK_to_interrupt = false;
+    back_input();
+    OK_to_interrupt = true;
+    error();
+}
+
+/*tex
+
+    Back up one inserted token and call |error|.
+*/
+
+void ins_error(void)
+{
+    OK_to_interrupt = false;
+    back_input();
+    token_type = inserted;
+    OK_to_interrupt = true;
+    error();
+}
+
+/*tex
+
+When \TeX\ wants to typeset a character that doesn't exist, the character node is
+not created; thus the output routine can assume that characters exist when it
+sees them. The following procedure prints a warning message unless the user has
+suppressed it.
+
+*/
+
+void char_warning(internal_font_number f, int c)
+{
+    /*tex saved value of |tracing_online| */
+    int old_setting;
+    /* index to current digit; we assume that $0\L n<16^{22}$ */
+    int k;
+    if (tracing_lost_chars_par > 0) {
+        old_setting = tracing_online_par;
+        if (tracing_lost_chars_par > 1)
+            tracing_online_par = 1;
+        begin_diagnostic();
+        tprint_nl("Missing character: There is no ");
+        print(c);
+        tprint(" (U+");
+        k = 0;
+        if (c < 16)
+            print_char('0');
+        if (c < 256)
+            print_char('0');
+        if (c < 4096)
+            print_char('0');
+        do {
+            dig[k] = c % 16;
+            c = c / 16;
+            incr(k);
+        } while (c != 0);
+        print_the_digs((eight_bits) k);
+        tprint(") in font ");
+        print_font_name(f);
+        print_char('!');
+        end_diagnostic(false);
+        tracing_online_par = old_setting;
+    }
+}
+
+void wrapup_backend(void) {
+    ensure_output_state(static_pdf, ST_OMODE_FIX);
+    if (output_mode_used == OMODE_NONE) {
+        print_err(" ==> Fatal error occurred, no FMT file produced!");
+    } else {
+        backend_out_control[backend_control_finish_file](static_pdf,history == fatal_error_stop);
+    }
+}
+
+void normal_error(const char *t, const char *p)
+{
+    normalize_selector();
+    if (interaction == error_stop_mode) {
+        wake_up_terminal();
+    }
+    if (filelineerrorstylep) {
+        print_file_line();
+    } else {
+        tprint_nl("! ");
+    }
+    tprint("error: ");
+    if (cur_file_name) {
+        tprint(" (file ");
+        tprint(cur_file_name);
+        tprint(")");
+    }
+    if (t != NULL) {
+        tprint(" (");
+        tprint(t);
+        tprint(")");
+    }
+    tprint(": ");
+    if (p != NULL)
+        tprint(p);
+    history = fatal_error_stop;
+    wrapup_backend();
+    exit(EXIT_FAILURE);
+}
+
+void normal_warning(const char *t, const char *p)
+{
+    int report_id ;
+    if (strcmp(t,"lua") == 0) {
+        int saved_new_line_char;
+        saved_new_line_char = new_line_char_par;
+        new_line_char_par = 10;
+        report_id = callback_defined(show_lua_error_hook_callback);
+        if (report_id == 0) {
+            tprint(p);
+            help2(
+                "The lua interpreter ran into a problem, so the",
+                "remainder of this lua chunk will be ignored."
+            );
+        } else {
+            (void) run_callback(report_id, "->");
+        }
+        error();
+        new_line_char_par = saved_new_line_char;
+    } else {
+        report_id = callback_defined(show_warning_message_callback);
+        if (report_id > 0) {
+            /*tex Free the last ones, */
+            xfree(last_warning_str);
+            xfree(last_warning_tag);
+            last_warning_str = (string) xmalloc(strlen(p) + 1);
+            last_warning_tag = (string) xmalloc(strlen(t) + 1);
+            strcpy(last_warning_str,p);
+            strcpy(last_warning_tag,t);
+            run_callback(report_id, "->");
+        } else {
+            print_ln();
+            tprint("warning ");
+            if (cur_file_name) {
+                tprint(" (file ");
+                tprint(cur_file_name);
+                tprint(")");
+            }
+            if (t != NULL) {
+                tprint(" (");
+                tprint(t);
+                tprint(")");
+            }
+            tprint(": ");
+            if (p != NULL)
+                tprint(p);
+            print_ln();
+        }
+        if (history == spotless)
+            history = warning_issued;
+    }
+}
+
+static char print_buf[PRINTF_BUF_SIZE];
+
+__attribute__ ((format(printf, 2,3)))
+void formatted_error(const char *t, const char *fmt, ...)
+{
+    va_list args;
+    va_start(args, fmt);
+    vsnprintf(print_buf, PRINTF_BUF_SIZE, fmt, args);
+    normal_error(t,print_buf);
+    va_end(args);
+}
+
+__attribute__ ((format(printf, 2,3)))
+void formatted_warning(const char *t, const char *fmt, ...)
+{
+    va_list args;
+    va_start(args, fmt);
+    vsnprintf(print_buf, PRINTF_BUF_SIZE, fmt, args);
+    normal_warning(t,print_buf);
+    va_end(args);
+}
diff --git a/texk/web2c/luatexdir/tex/errors.w b/texk/web2c/luatexdir/tex/errors.w
deleted file mode 100644
index 93dbe141b..000000000
--- a/texk/web2c/luatexdir/tex/errors.w
+++ /dev/null
@@ -1,972 +0,0 @@
-% errors.w
-%
-% Copyright 2009-2010 Taco Hoekwater <taco@@luatex.org>
-%
-% This file is part of LuaTeX.
-%
-% LuaTeX is free software; you can redistribute it and/or modify it under
-% the terms of the GNU General Public License as published by the Free
-% Software Foundation; either version 2 of the License, or (at your
-% option) any later version.
-%
-% LuaTeX is distributed in the hope that it will be useful, but WITHOUT
-% ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-% FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
-% License for more details.
-%
-% You should have received a copy of the GNU General Public License along
-% with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
-
-@ TODO: we need to use a formatted normal_error in:
-
-hyphen.w
-luafflib.c
-
-@ @c
-#include "ptexlib.h"
-#define edit_var "TEXEDIT"
-
-@ When something anomalous is detected, \TeX\ typically does something like this:
-$$\vbox{\halign{#\hfil\cr
-|print_err("Something anomalous has been detected");|\cr
-|help3("This is the first line of my offer to help.")|\cr
-|("This is the second line. I'm trying to")|\cr
-|("explain the best way for you to proceed.");|\cr
-|error;|\cr}}$$
-A two-line help message would be given using |help2|, etc.; these informal
-helps should use simple vocabulary that complements the words used in the
-official error message that was printed. (Outside the U.S.A., the help
-messages should preferably be translated into the local vernacular. Each
-line of help is at most 60 characters long, in the present implementation,
-so that |max_print_line| will not be exceeded.)
-
-The |print_err| procedure supplies a `\.!' before the official message,
-and makes sure that the terminal is awake if a stop is going to occur.
-The |error| procedure supplies a `\..' after the official message, then it
-shows the location of the error; and if |interaction=error_stop_mode|,
-it also enters into a dialog with the user, during which time the help
-message may be printed.
-@^system dependencies@>
-
-@c
-int interaction;                /* current level of interaction */
-int interactionoption;          /* set from command line */
-
-/* ls-hh: so, new code only kicks in when we have a callback defined */
-
-char *last_error = NULL;
-char *last_lua_error = NULL;
-char *last_warning_tag = NULL;
-char *last_warning_str = NULL;
-char *last_error_context = NULL;
-
-int err_old_setting = 0 ;
-int in_error = 0 ;
-
-void set_last_error_context(void)
-{
-    str_number str;
-    int sel = selector;
-    int saved_new_line_char;
-    int saved_new_string_line;
-    selector = new_string;
-    saved_new_line_char = new_line_char_par;
-    saved_new_string_line = new_string_line;
-    new_line_char_par = 10;
-    new_string_line = 10;
-    show_context();
-    xfree(last_error_context);
-    str = make_string();
-    last_error_context = makecstring(str);
-    flush_str(str);
-    selector = sel;
-    new_line_char_par = saved_new_line_char;
-    new_string_line = saved_new_string_line;
-    return;
-}
-
-void flush_err(void)
-{
-    str_number s_error;
-    char *s = NULL;
-    int callback_id ;
-    if (in_error) {
-        selector = err_old_setting;
-        str_room(1);
-        s_error = make_string();
-        s = makecstring(s_error);
-        flush_str(s_error);
-        if (interaction == error_stop_mode) {
-            wake_up_terminal();
-        }
-        xfree(last_error);
-        last_error = (string) xmalloc((unsigned) (strlen(s) + 1));
-        strcpy(last_error,s);
-        callback_id = callback_defined(show_error_message_callback);
-        if (callback_id > 0) {
-            run_callback(callback_id, "->");
-        } else {
-            tprint(s);
-        }
-        in_error = 0 ;
-    }
-}
-
-void print_err(const char *s)
-{
-    int callback_id = callback_defined(show_error_message_callback);
-    if (interaction == error_stop_mode) {
-        wake_up_terminal();
-    }
-    if (callback_id > 0) {
-        err_old_setting = selector;
-        selector = new_string;
-        in_error = 1 ;
-    }
-    if (filelineerrorstylep) {
-        print_file_line();
-    } else {
-        tprint_nl("! ");
-    }
-    tprint(s);
-    if (callback_id <= 0) {
-        xfree(last_error);
-        last_error = (string) xmalloc((unsigned) (strlen(s) + 1));
-        strcpy(last_error,s);
-    }
-}
-
-@ \TeX\ is careful not to call |error| when the print |selector| setting
-might be unusual. The only possible values of |selector| at the time of
-error messages are
-
-\yskip
-\hang|no_print| (when |interaction=batch_mode| and |log_file| not yet open);
-
-\hang|term_only| (when |interaction>batch_mode| and |log_file| not yet open);
-
-\hang|log_only| (when |interaction=batch_mode| and |log_file| is open);
-
-\hang|term_and_log| (when |interaction>batch_mode| and |log_file| is open).
-
-@c
-void fixup_selector(boolean logopened)
-{
-    if (interaction == batch_mode)
-        selector = no_print;
-    else
-        selector = term_only;
-    if (logopened)
-        selector = selector + 2;
-}
-
-@ A global variable |deletions_allowed| is set |false| if the |get_next|
-routine is active when |error| is called; this ensures that |get_next|
-and related routines like |get_token| will never be called recursively.
-A similar interlock is provided by |set_box_allowed|.
-@^recursion@>
-
-The global variable |history| records the worst level of error that
-has been detected. It has four possible values: |spotless|, |warning_issued|,
-|error_message_issued|, and |fatal_error_stop|.
-
-Another global variable, |error_count|, is increased by one when an
-|error| occurs without an interactive dialog, and it is reset to zero at
-the end of every paragraph.  If |error_count| reaches 100, \TeX\ decides
-that there is no point in continuing further.
-
-@c
-boolean deletions_allowed;      /* is it safe for |error| to call |get_token|? */
-boolean set_box_allowed;        /* is it safe to do a \.{\\setbox} assignment? */
-int history;                    /* has the source input been clean so far? */
-int error_count;                /* the number of scrolled errors since the last paragraph ended */
-int interrupt;                  /* should \TeX\ pause for instructions? */
-boolean OK_to_interrupt;        /* should interrupts be observed? */
-
-@ The value of |history| is initially |fatal_error_stop|, but it will
-be changed to |spotless| if \TeX\ survives the initialization process.
-
-@c
-void initialize_errors(void)
-{
-    if (interactionoption == unspecified_mode)
-        interaction = error_stop_mode;
-    else
-        interaction = interactionoption;
-    deletions_allowed = true;
-    set_box_allowed = true;
-    OK_to_interrupt = true;
-    /* |history| is initialized elsewhere */
-}
-
-@ It is possible for |error| to be called recursively if some error arises
-when |get_token| is being used to delete a token, and/or if some fatal error
-occurs while \TeX\ is trying to fix a non-fatal one. But such recursion
-@^recursion@>
-is never more than two levels deep.
-
-@ Individual lines of help are recorded in the array |help_line|.
-
-@c
-const char *help_line[7];       /* helps for the next |error| */
-boolean use_err_help;           /* should the |err_help| list be shown? */
-
-@ The |jump_out| procedure just cuts across all active procedure levels and
-exits the program. It is used when there is no recovery from a particular error.
-
-@c
-int defaultexitcode = 0; /* the exit code can be overloaded */
-
-__attribute__ ((noreturn))
-void do_final_end(void)
-{
-    update_terminal();
-    ready_already = 0;
-    lua_close(Luas); /* new per 0.99 */
-    if ((history != spotless) && (history != warning_issued))
-        uexit(1);
-    else
-        uexit(defaultexitcode);
-}
-
-__attribute__ ((noreturn))
-void jump_out(void)
-{
-    close_files_and_terminate();
-    do_final_end();
-}
-@ Here is the function that calls the editor, if one is defined. This
-is loosely based on a similar function in kpathsea, but the calling
-convention is quite different.
-
-@c
-static const_string edit_value = EDITOR;
-
-#if defined(WIN32)
-static int
-Isspace (char c)
-{
-  return (c == ' ' || c == '\t');
-}
-#endif /* WIN32 */
-
-__attribute__ ((noreturn))
-static void luatex_calledit (int baseptr, int linenumber)
-{
-  char *temp, *command, *fullcmd;
-  char c;
-  int sdone, ddone, i;
-  char *filename = makecstring(input_stack[base_ptr].name_field);
-  int fnlength = strlen(filename);
-
-#ifdef WIN32
-  char *fp, *ffp, *env, editorname[256], buffer[256];
-  int cnt = 0;
-  int dontchange = 0;
-#endif
-
-  sdone = ddone = 0;
-
-  /* Close any open input files, since we're going to kill the job.  */
-  close_files_and_terminate();
-
-  /* Replace the default with the value of the appropriate environment
-     variable or config file value, if it's set.  */
-  temp = kpse_var_value (edit_var);
-  if (temp != NULL)
-    edit_value = temp;
-
-  /* Construct the command string.  The `11' is the maximum length an
-     integer might be.  */
-  command = xmalloc (strlen (edit_value) + fnlength + 11);
-
-  /* So we can construct it as we go.  */
-  temp = command;
-
-#ifdef WIN32
-  fp = editorname;
-  if ((isalpha(*edit_value) && *(edit_value + 1) == ':'
-        && IS_DIR_SEP (*(edit_value + 2)))
-      || (*edit_value == '"' && isalpha(*(edit_value + 1))
-        && *(edit_value + 2) == ':'
-        && IS_DIR_SEP (*(edit_value + 3)))
-     )
-    dontchange = 1;
-#endif
-
-  while ((c = *edit_value++) != 0)
-    {
-      if (c == '%')
-        {
-          switch (c = *edit_value++)
-            {
-            case 'd':
-              if (ddone)
-                FATAL1 ("call_edit: `%%d' appears twice in editor command: `%s'", edit_value);
-              sprintf (temp, "%ld", (long int)linenumber);
-              while (*temp != '\0')
-                temp++;
-              ddone = 1;
-              break;
-
-            case 's':
-              if (sdone)
-                FATAL1 ("call_edit: `%%s' appears twice in editor command: `%s'", edit_value);
-              for (i =0; i < fnlength; i++)
-                *temp++ = filename[i];
-              sdone = 1;
-              break;
-
-            case '\0':
-              *temp++ = '%';
-              /* Back up to the null to force termination.  */
-              edit_value--;
-              break;
-
-            default:
-              *temp++ = '%';
-              *temp++ = c;
-              break;
-            }
-        }
-      else {
-#ifdef WIN32
-        if (dontchange)
-          *temp++ = c;
-        else { if(Isspace(c) && cnt == 0) {
-            cnt++;
-            temp = command;
-            *temp++ = c;
-            *fp = '\0';
-          } else if(!Isspace(c) && cnt == 0) {
-            *fp++ = c;
-          } else {
-            *temp++ = c;
-          }
-        }
-#else
-        *temp++ = c;
-#endif
-      }
-    }
-
-  *temp = 0;
-
-#ifdef WIN32
-  if (dontchange == 0) {
-    if(editorname[0] == '.' ||
-       editorname[0] == '/' ||
-       editorname[0] == '\\') {
-      fprintf(stderr, "%s is not allowed to execute.\n", editorname);
-      do_final_end();
-    }
-    env = (char *)getenv("PATH");
-    if(SearchPath(env, editorname, ".exe", 256, buffer, &ffp)==0) {
-      if(SearchPath(env, editorname, ".bat", 256, buffer, &ffp)==0) {
-        fprintf(stderr, "I cannot find %s in the PATH.\n", editorname);
-        do_final_end();
-      }
-    }
-    fullcmd = (char *)xmalloc(strlen(buffer)+strlen(command)+5);
-    strcpy(fullcmd, "\"");
-    strcat(fullcmd, buffer);
-    strcat(fullcmd, "\"");
-    strcat(fullcmd, command);
-  } else
-#endif
-  fullcmd = command;
-
-  /* Execute the command.  */
-  if (system (fullcmd) != 0)
-    fprintf (stderr, "! Trouble executing `%s'.\n", command);
-
-  /* Quit, since we found an error.  */
-  do_final_end ();
-}
-
-
-@ @c
-void error(void)
-{                               /* completes the job of error reporting */
-    ASCII_code c;               /* what the user types */
-    int callback_id;
-    int s1, s2, s3, s4;         /* used to save global variables when deleting tokens */
-    int i;
-    flush_err(); /* hh-ls */
-    if (history < error_message_issued)
-        history = error_message_issued;
-    callback_id = callback_defined(show_error_hook_callback);
-    if (callback_id > 0) {
-        set_last_error_context();
-        run_callback(callback_id, "->");
-    } else {
-        print_char('.');
-        show_context();
-    }
-    if (haltonerrorp) {
-        history = fatal_error_stop;
-        jump_out();
-    }
-    if (interaction == error_stop_mode) {
-        /* Get user's advice and |return| */
-        while (1) {
-          CONTINUE:
-            clear_for_error_prompt();
-            prompt_input("? ");
-            if (last == first)
-                return;
-            c = buffer[first];
-            if (c >= 'a')
-                c = c + 'A' - 'a';      /* convert to uppercase */
-            /* Interpret code |c| and |return| if done */
-
-            /* It is desirable to provide an `\.E' option here that gives the user
-               an easy way to return from \TeX\ to the system editor, with the offending
-               line ready to be edited. But such an extension requires some system
-               wizardry, so the present implementation simply types out the name of the
-               file that should be  edited and the relevant line number.
-
-               There is a secret `\.D' option available when the debugging routines haven't
-               been commented~out. */
-
-            switch (c) {
-            case '0':
-            case '1':
-            case '2':
-            case '3':
-            case '4':
-            case '5':
-            case '6':
-            case '7':
-            case '8':
-            case '9':
-                if (deletions_allowed) {
-                    /* Delete |c-"0"| tokens and |goto continue| */
-                    /* We allow deletion of up to 99 tokens at a time */
-                    s1 = cur_tok;
-                    s2 = cur_cmd;
-                    s3 = cur_chr;
-                    s4 = align_state;
-                    align_state = 1000000;
-                    OK_to_interrupt = false;
-                    if ((last > first + 1) && (buffer[first + 1] >= '0')
-                        && (buffer[first + 1] <= '9'))
-                        c = c * 10 + buffer[first + 1] - '0' * 11;
-                    else
-                        c = c - '0';
-                    while (c > 0) {
-                        get_token();    /* one-level recursive call of |error| is possible */
-                        decr(c);
-                    }
-                    cur_tok = s1;
-                    cur_cmd = s2;
-                    cur_chr = s3;
-                    align_state = s4;
-                    OK_to_interrupt = true;
-                    help2("I have just deleted some text, as you asked.",
-                          "You can now delete more, or insert, or whatever.");
-                    show_context();
-                    goto CONTINUE;
-                }
-                break;
-#ifdef DEBUG
-            case 'D':
-                debug_help();
-                goto CONTINUE;
-                break;
-#endif
-            case 'E':
-                if (base_ptr > 0) {
-                    int callback_id = callback_defined(call_edit_callback);
-                    if (callback_id>0) {
-                        (void)run_callback(callback_id, "Sd->", makecstring(input_stack[base_ptr].name_field), line);
-                        jump_out(); /* should not be reached */
-                    } else {
-                        tprint_nl("You want to edit file ");
-                        print(input_stack[base_ptr].name_field);
-                        tprint(" at line ");
-                        print_int(line);
-                        interaction = scroll_mode;
-                        if (kpse_init) {
-                            luatex_calledit(base_ptr, line);
-                        } else {
-                            tprint_nl("There is no valid callback defined.");
-                            jump_out(); /* should not be reached */
-                        }
-                    }
-                }
-                break;
-            case 'H':
-                /* Print the help information and |goto continue| */
-                if (use_err_help) {
-                    give_err_help();
-                } else {
-                    if (help_line[0] == NULL) {
-                        help2
-                            ("Sorry, I don't know how to help in this situation.",
-                             "Maybe you should try asking a human?");
-                    }
-                    i = 0;
-                    while (help_line[i] != NULL)
-                        tprint_nl(help_line[i++]);
-                    help4("Sorry, I already gave what help I could...",
-                          "Maybe you should try asking a human?",
-                          "An error might have occurred before I noticed any problems.",
-                          "``If all else fails, read the instructions.''");
-                    goto CONTINUE;
-                }
-                break;
-            case 'I':
-                /* Introduce new material from the terminal and |return| */
-                /* When the following code is executed, |buffer[(first+1)..(last-1)]| may
-                   contain the material inserted by the user; otherwise another prompt will
-                   be given. In order to understand this part of the program fully, you need
-                   to be familiar with \TeX's input stacks. */
-
-                begin_file_reading();   /* enter a new syntactic level for terminal input */
-                /* now |state=mid_line|, so an initial blank space will count as a blank */
-                if (last > first + 1) {
-                    iloc = first + 1;
-                    buffer[first] = ' ';
-                } else {
-                    prompt_input("insert>");
-                    iloc = first;
-                }
-                first = last;
-                ilimit = last - 1;      /* no |end_line_char| ends this line */
-                return;
-                break;
-            case 'Q':
-            case 'R':
-            case 'S':
-                /* Change the interaction level and |return| */
-                /* Here the author of \TeX\ apologizes for making use of the numerical
-                   relation between |"Q"|, |"R"|, |"S"|, and the desired interaction settings
-                   |batch_mode|, |nonstop_mode|, |scroll_mode|. */
-                error_count = 0;
-                interaction = batch_mode + c - 'Q';
-                tprint("OK, entering ");
-                switch (c) {
-                case 'Q':
-                    tprint_esc("batchmode");
-                    decr(selector);
-                    break;
-                case 'R':
-                    tprint_esc("nonstopmode");
-                    break;
-                case 'S':
-                    tprint_esc("scrollmode");
-                    break;
-                }
-                tprint("...");
-                print_ln();
-                update_terminal();
-                return;
-                break;
-            case 'X':
-                interaction = scroll_mode;
-                jump_out();
-                break;
-            default:
-                break;
-            }
-            if (!use_err_help) {
-                /* Print the menu of available options */
-                tprint("Type <return> to proceed, S to scroll future error messages,");
-                tprint_nl("R to run without stopping, Q to run quietly,");
-                tprint_nl("I to insert something, ");
-                if (base_ptr > 0)
-                    tprint("E to edit your file,");
-                if (deletions_allowed)
-                    tprint_nl("1 or ... or 9 to ignore the next 1 to 9 tokens of input,");
-                tprint_nl("H for help, X to quit.");
-            }
-            use_err_help = false;
-        }
-
-    }
-    incr(error_count);
-    if (error_count == 100) {
-        tprint_nl("(That makes 100 errors; please try again.)");
-        history = fatal_error_stop;
-        jump_out();
-    }
-    /* Put help message on the transcript file */
-    if (interaction > batch_mode)
-        decr(selector);         /* avoid terminal output */
-    if (use_err_help) {
-        print_ln();
-        give_err_help();
-    } else {
-        int i1 = 0;
-        while (help_line[i1] != NULL)
-            tprint_nl(help_line[i1++]);
-    }
-    print_ln();
-    if (interaction > batch_mode)
-        incr(selector);         /* re-enable terminal output */
-    print_ln();
-}
-
-@ A dozen or so error messages end with a parenthesized integer, so we
-save a teeny bit of program space by declaring the following procedure:
-
-@c
-void int_error(int n)
-{
-    tprint(" (");
-    print_int(n);
-    print_char(')');
-    error();
-}
-
-@ In anomalous cases, the print selector might be in an unknown state;
-the following subroutine is called to fix things just enough to keep
-running a bit longer.
-
-@c
-void normalize_selector(void)
-{
-    if (log_opened_global)
-        selector = term_and_log;
-    else
-        selector = term_only;
-    if (job_name == 0)
-        open_log_file();
-    if (interaction == batch_mode)
-        decr(selector);
-}
-
-@ The following procedure prints \TeX's last words before dying
-@c
-void succumb(void)
-{
-    if (interaction == error_stop_mode)
-        interaction = scroll_mode;      /* no more interaction */
-    if (log_opened_global)
-        error();
-#ifdef DEBUG
-    if (interaction > batch_mode)
-        debug_help();
-#endif
-    history = fatal_error_stop;
-    jump_out();                 /* irrecoverable error */
-}
-
-@ @c
-void fatal_error(const char *s)
-{                               /* prints |s|, and that's it */
-    normalize_selector();
-    print_err("Emergency stop");
-    help1(s);
-    succumb();
-}
-
-@ Here is the most dreaded error message
-@c
-void overflow(const char *s, unsigned int n)
-{                               /* stop due to finiteness */
-    normalize_selector();
-    print_err("TeX capacity exceeded, sorry [");
-    tprint(s);
-    print_char('=');
-    print_int((int) n);
-    print_char(']');
-    if (varmem == NULL) {
-      print_err("Sorry, I ran out of memory.");
-      print_ln();
-      exit(EXIT_FAILURE);
-    }
-    help2("If you really absolutely need more capacity,",
-          "you can ask a wizard to enlarge me.");
-    succumb();
-}
-
-@ The program might sometime run completely amok, at which point there is
-no choice but to stop. If no previous error has been detected, that's bad
-news; a message is printed that is really intended for the \TeX\
-maintenance person instead of the user (unless the user has been
-particularly diabolical).  The index entries for `this can't happen' may
-help to pinpoint the problem.
-@^dry rot@>
-
-@c
-void confusion(const char *s)
-{                               /* consistency check violated; |s| tells where */
-    normalize_selector();
-    if (history < error_message_issued) {
-        print_err("This can't happen (");
-        tprint(s);
-        print_char(')');
-        help1("I'm broken. Please show this to someone who can fix can fix");
-    } else {
-        print_err("I can't go on meeting you like this");
-        help2("One of your faux pas seems to have wounded me deeply...",
-              "in fact, I'm barely conscious. Please fix it and try again.");
-    }
-    succumb();
-}
-
-@ Users occasionally want to interrupt \TeX\ while it's running.
-If the runtime system allows this, one can implement
-a routine that sets the global variable |interrupt| to some nonzero value
-when such an interrupt is signalled. Otherwise there is probably at least
-a way to make |interrupt| nonzero using the debugger.
-@^system dependencies@>
-@^debugging@>
-
-@c
-void check_interrupt(void)
-{
-    if (interrupt != 0)
-        pause_for_instructions();
-}
-
-@ When an interrupt has been detected, the program goes into its
-highest interaction level and lets the user have nearly the full flexibility of
-the |error| routine.  \TeX\ checks for interrupts only at times when it is
-safe to do this.
-
-@c
-void pause_for_instructions(void)
-{
-    if (OK_to_interrupt) {
-        interaction = error_stop_mode;
-        if ((selector == log_only) || (selector == no_print))
-            incr(selector);
-        print_err("Interruption");
-        help3("You rang?",
-              "Try to insert some instructions for me (e.g.,`I\\showlists'),",
-              "unless you just want to quit by typing `X'.");
-        deletions_allowed = false;
-        error();
-        deletions_allowed = true;
-        interrupt = 0;
-    }
-}
-
-@ @c
-void tex_error(const char *msg, const char **hlp)
-{
-    print_err(msg);
-    if (hlp != NULL) {
-        int i;
-        for (i = 0; (hlp[i] != NULL && i <= 5); i++) {
-            help_line[i] = hlp[i];
-        }
-        help_line[i] = NULL;
-    } else {
-        help_line[0] = NULL;
-    }
-    error();
-}
-
-@ The |back_error| routine is used when we want to replace an offending token
-just before issuing an error message. This routine, like |back_input|,
-requires that |cur_tok| has been set. We disable interrupts during the
-call of |back_input| so that the help message won't be lost.
-
-@c
-void back_error(void)
-{                               /* back up one token and call |error| */
-    OK_to_interrupt = false;
-    back_input();
-    OK_to_interrupt = true;
-    error();
-}
-
-@ @c
-void ins_error(void)
-{                               /* back up one inserted token and call |error| */
-    OK_to_interrupt = false;
-    back_input();
-    token_type = inserted;
-    OK_to_interrupt = true;
-    error();
-}
-
-@ When \TeX\ wants to typeset a character that doesn't exist, the
-character node is not created; thus the output routine can assume
-that characters exist when it sees them. The following procedure
-prints a warning message unless the user has suppressed it.
-
-@c
-void char_warning(internal_font_number f, int c)
-{
-    int old_setting;            /* saved value of |tracing_online| */
-    int k;                      /* index to current digit; we assume that $0\L n<16^{22}$ */
-    if (tracing_lost_chars_par > 0) {
-        old_setting = tracing_online_par;
-        if (tracing_lost_chars_par > 1)
-            tracing_online_par = 1;
-        begin_diagnostic();
-        tprint_nl("Missing character: There is no ");
-        print(c);
-        tprint(" (U+");
-        k = 0;
-        if (c < 16)
-            print_char('0');
-        if (c < 256)
-            print_char('0');
-        if (c < 4096)
-            print_char('0');
-        do {
-            dig[k] = c % 16;
-            c = c / 16;
-            incr(k);
-        } while (c != 0);
-        print_the_digs((eight_bits) k);
-        tprint(") in font ");
-        print_font_name(f);
-        print_char('!');
-        end_diagnostic(false);
-        tracing_online_par = old_setting;
-    }
-}
-
-@ @c
-
-void wrapup_backend(void) {
-    ensure_output_state(static_pdf, ST_OMODE_FIX);
-    switch (output_mode_used) {
-        case OMODE_NONE:
-            print_err(" ==> Fatal error occurred, no FMT file produced!");
-            break;
-        case OMODE_PDF:
-            if (history == fatal_error_stop) {
-                remove_pdffile(static_pdf); /* will become remove_output_file */
-                print_err(" ==> Fatal error occurred, no output PDF file produced!");
-            } else {
-                finish_pdf_file(static_pdf, luatex_version, get_luatexrevision());
-            }
-            break;
-        case OMODE_DVI:
-            if (history == fatal_error_stop) {
-                print_err(" ==> Fatal error occurred, bad output DVI file produced!");
-                finish_dvi_file(static_pdf, luatex_version, get_luatexrevision());
-            } else {
-                finish_dvi_file(static_pdf, luatex_version, get_luatexrevision());
-            }
-            break;
-    }
-}
-
-void normal_error(const char *t, const char *p)
-{
-    normalize_selector();
-    if (interaction == error_stop_mode) {
-        wake_up_terminal();
-    }
-    if (filelineerrorstylep) {
-        print_file_line();
-    } else {
-        tprint_nl("! ");
-    }
-    tprint("error: ");
-    if (cur_file_name) {
-        tprint(" (file ");
-        tprint(cur_file_name);
-        tprint(")");
-    }
-    if (t != NULL) {
-        tprint(" (");
-        tprint(t);
-        tprint(")");
-    }
-    tprint(": ");
-    if (p != NULL)
-        tprint(p);
-    history = fatal_error_stop;
-    wrapup_backend();
-    exit(EXIT_FAILURE);
-}
-
-/*
-void normal_error(const char *t, const char *p)
-{
-    normalize_selector();
-    if (interaction == error_stop_mode) {
-        wake_up_terminal();
-    }
-    tprint("error : ");
-    if (p != NULL)
-        tprint(p);
-    history = fatal_error_stop;
-    wrapup_backend();
-    exit(EXIT_FAILURE);
-}
-*/
-
-@ @c
-void normal_warning(const char *t, const char *p)
-{
-    int report_id ;
-    if (strcmp(t,"lua") == 0) {
-        int saved_new_line_char;
-        saved_new_line_char = new_line_char_par;
-        new_line_char_par = 10;
-        report_id = callback_defined(show_lua_error_hook_callback);
-        if (report_id == 0) {
-            tprint(p);
-            help2("The lua interpreter ran into a problem, so the",
-                  "remainder of this lua chunk will be ignored.");
-        } else {
-            (void) run_callback(report_id, "->");
-        }
-        error();
-        new_line_char_par = saved_new_line_char;
-    } else {
-        report_id = callback_defined(show_warning_message_callback);
-        if (report_id > 0) {
-            /* free last ones */
-            xfree(last_warning_str);
-            xfree(last_warning_tag);
-            last_warning_str = (string) xmalloc(strlen(p) + 1);
-            last_warning_tag = (string) xmalloc(strlen(t) + 1);
-            strcpy(last_warning_str,p);
-            strcpy(last_warning_tag,t);
-            run_callback(report_id, "->");
-        } else {
-            print_ln();
-            tprint("warning ");
-            if (cur_file_name) {
-                tprint(" (file ");
-                tprint(cur_file_name);
-                tprint(")");
-            }
-            if (t != NULL) {
-                tprint(" (");
-                tprint(t);
-                tprint(")");
-            }
-            tprint(": ");
-            if (p != NULL)
-                tprint(p);
-            print_ln();
-        }
-        if (history == spotless)
-            history = warning_issued;
-    }
-}
-
-@ @c
-static char print_buf[PRINTF_BUF_SIZE];
-__attribute__ ((format(printf, 2,3)))
-void formatted_error(const char *t, const char *fmt, ...)
-{
-    va_list args;
-    va_start(args, fmt);
-    vsnprintf(print_buf, PRINTF_BUF_SIZE, fmt, args);
-    normal_error(t,print_buf);
-    va_end(args);
-}
-
-__attribute__ ((format(printf, 2,3)))
-void formatted_warning(const char *t, const char *fmt, ...)
-{
-    va_list args;
-    va_start(args, fmt);
-    vsnprintf(print_buf, PRINTF_BUF_SIZE, fmt, args);
-    normal_warning(t,print_buf);
-    va_end(args);
-}
diff --git a/texk/web2c/luatexdir/tex/expand.c b/texk/web2c/luatexdir/tex/expand.c
new file mode 100644
index 000000000..a0a317db2
--- /dev/null
+++ b/texk/web2c/luatexdir/tex/expand.c
@@ -0,0 +1,967 @@
+/*
+
+Copyright 2009-2010 Taco Hoekwater <taco@luatex.org>
+
+This file is part of LuaTeX.
+
+LuaTeX is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 2 of the License, or (at your
+option) any later version.
+
+LuaTeX is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+License for more details.
+
+You should have received a copy of the GNU General Public License along
+with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#include "ptexlib.h"
+
+/*tex
+
+    Only a dozen or so command codes |>max_command| can possibly be returned by
+    |get_next|; in increasing order, they are |undefined_cs|, |expand_after|,
+    |no_expand|, |input|, |if_test|, |fi_or_else|, |cs_name|, |convert|, |the|,
+    |top_bot_mark|, |call|, |long_call|, |outer_call|, |long_outer_call|, and
+    |end_template|.
+
+    Sometimes, recursive calls to the following |expand| routine may cause
+    exhaustion of the run-time calling stack, resulting in forced execution stops
+    by the operating system. To diminish the chance of this happening, a counter
+    is used to keep track of the recursion depth, in conjunction with a constant
+    called |expand_depth|.
+
+    Note that this does not catch all possible infinite recursion loops, just the
+    ones that exhaust the application calling stack. The actual maximum value of
+    |expand_depth| is outside of our control, but the initial setting of |100|
+    should be enough to prevent problems.
+
+*/
+
+static int expand_depth_count = 0;
+
+/*tex
+
+    The |expand| subroutine is used when |cur_cmd>max_command|. It removes a
+    ``call'' or a conditional or one of the other special operations just listed.
+    It follows that |expand| might invoke itself recursively. In all cases,
+    |expand| destroys the current token, but it sets things up so that the next
+    |get_next| will deliver the appropriate next token. The value of |cur_tok|
+    need not be known when |expand| is called.
+
+    Since several of the basic scanning routines communicate via global
+    variables, their values are saved as local variables of |expand| so that
+    recursive calls don't invalidate them.
+
+*/
+
+int is_in_csname = 0;
+
+void expand(void)
+{
+    /*tex token that is being ``expanded after'' */
+    halfword t;
+    /*tex for list manipulation */
+    halfword p;
+    /*tex for a local token list pointer */
+    halfword cur_ptr;
+    /*tex to save the global quantity |cur_val| */
+    int cv_backup;
+    /*tex to save |cur_val_level|, etc. */
+    int cvl_backup, radix_backup, co_backup;
+    /*tex to save |link(backup_head)| */
+    halfword backup_backup;
+    /*tex temporary storage of |scanner_status| */
+    int save_scanner_status;
+    incr(expand_depth_count);
+    if (expand_depth_count >= expand_depth)
+        overflow("expansion depth", (unsigned) expand_depth);
+    cv_backup = cur_val;
+    cvl_backup = cur_val_level;
+    radix_backup = radix;
+    co_backup = cur_order;
+    backup_backup = token_link(backup_head);
+  RESWITCH:
+    if (cur_cmd < call_cmd) {
+        /*tex Expand a nonmacro. */
+        if (tracing_commands_par > 1)
+            show_cur_cmd_chr();
+        switch (cur_cmd) {
+            case top_bot_mark_cmd:
+                /*tex Insert the appropriate mark text into the scanner. */
+                t = cur_chr % marks_code;
+                if (cur_chr >= marks_code)
+                    scan_mark_num();
+                else
+                    cur_val = 0;
+                switch (t) {
+                    case first_mark_code:
+                        cur_ptr = first_mark(cur_val);
+                        break;
+                    case bot_mark_code:
+                        cur_ptr = bot_mark(cur_val);
+                        break;
+                    case split_first_mark_code:
+                        cur_ptr = split_first_mark(cur_val);
+                        break;
+                    case split_bot_mark_code:
+                        cur_ptr = split_bot_mark(cur_val);
+                        break;
+                    default:
+                        cur_ptr = top_mark(cur_val);
+                        break;
+                }
+                if (cur_ptr != null)
+                    begin_token_list(cur_ptr, mark_text);
+                break;
+            case expand_after_cmd:
+                if (cur_chr == 0) {
+                    /*tex
+
+                        Expand the token after the next token. It takes only a
+                        little shuffling to do what \TeX\ calls
+                        \.{\\expandafter}.
+
+                    */
+                    get_token();
+                    t = cur_tok;
+                    get_token();
+                    if (cur_cmd > max_command_cmd)
+                        expand();
+                    else
+                        back_input();
+                    cur_tok = t;
+                    back_input();
+                } else {
+                    /*tex
+
+                        Negate a boolean conditional and |goto reswitch|. The
+                        result of a boolean condition is reversed when the
+                        conditional is preceded by \.{\\unless}.
+
+                    */
+                    get_token();
+                    if ((cur_cmd == if_test_cmd) && (cur_chr != if_case_code)) {
+                        cur_chr = cur_chr + unless_code;
+                        goto RESWITCH;
+                    }
+                    print_err("You can't use `\\unless' before `");
+                    print_cmd_chr((quarterword) cur_cmd, cur_chr);
+                    print_char('\'');
+                    help1("Continue, and I'll forget that it ever happened.");
+                    back_error();
+                }
+                break;
+            case no_expand_cmd:
+                if (cur_chr == 0) {
+                    /*tex
+
+                        Suppress expansion of the next token. The implementation
+                        of \.{\\noexpand} is a bit trickier, because it is
+                        necessary to insert a special `|dont_expand|' marker into
+                        \TeX's reading mechanism. This special marker is
+                        processed by |get_next|, but it does not slow down the
+                        inner loop.
+
+                        Since \.{\\outer} macros might arise here, we must also
+                        clear the |scanner_status| temporarily.
+
+                    */
+                    save_scanner_status = scanner_status;
+                    scanner_status = normal;
+                    get_token();
+                    scanner_status = save_scanner_status;
+                    t = cur_tok;
+                    back_input();
+                    /*tex Now |start| and |loc| point to the backed-up token |t|. */
+                    if (t >= cs_token_flag) {
+                        p = get_avail();
+                        set_token_info(p, cs_token_flag + frozen_dont_expand);
+                        set_token_link(p, iloc);
+                        istart = p;
+                        iloc = p;
+                    }
+
+                } else {
+                    /*tex
+
+                        The \.{\\primitive} handling. If the primitive meaning of
+                        the next token is an expandable command, it suffices to
+                        replace the current token with the primitive one and
+                        restart |expand|.
+
+                        Otherwise, the token we just read has to be pushed back,
+                        as well as a token matching the internal form of
+                        \.{\\primitive}, that is sneaked in as an alternate form
+                        of |ignore_spaces|.
+
+                        An implementation problem surfaces: There really is no
+                        |cur_cs| attached to the inserted primitive command, so
+                        it is safer to set |cur_cs| to zero. |cur_tok| has a
+                        similar problem. And for the non-expanded branch, simply
+                        pushing back a token that matches the correct internal
+                        command does not work, because that approach would not
+                        survive roundtripping to a temporary file or even a token
+                        list.
+
+                        It would be smart to create |frozen_| versions of all the
+                        primitives. Then, this problem would not happen, at the
+                        expense of a few hundred extra control sequences.
+
+                    */
+                    save_scanner_status = scanner_status;
+                    scanner_status = normal;
+                    get_token();
+                    scanner_status = save_scanner_status;
+                    cur_cs = prim_lookup(cs_text(cur_cs));
+                    if (cur_cs != undefined_primitive) {
+                        t = get_prim_eq_type(cur_cs);
+                        if (t > max_command_cmd) {
+                            cur_cmd = t;
+                            cur_chr = get_prim_equiv(cur_cs);
+                            cur_tok = token_val(cur_cmd, cur_chr);
+                            cur_cs = 0;
+                            goto RESWITCH;
+                        } else {
+                            back_input();
+                            /*tex  Now |loc| and |start| point to a one-item list. */
+                            p = get_avail();
+                            set_token_info(p, cs_token_flag + frozen_primitive);
+                            set_token_link(p, iloc);
+                            iloc = p;
+                            istart = p;
+                        }
+                    } else if (suppress_primitive_error_par == 0) {
+                        print_err("Missing primitive name");
+                        help2(
+                            "The control sequence marked <to be read again> does not",
+                            "represent any known primitive."
+                        );
+                        back_error();
+                    }
+                }
+                break;
+            case cs_name_cmd:
+                /*tex Manufacture a control sequence name. */
+                if (cur_chr == 0) {
+                    manufacture_csname(0);
+                } else if (cur_chr == 1) {
+                    inject_last_tested_cs();
+                } else {
+                    manufacture_csname(1);
+                }
+                break;
+            case convert_cmd:
+                conv_toks();
+                break;
+            case the_cmd:
+                ins_the_toks();
+                break;
+            case combine_toks_cmd:
+                combine_the_toks(cur_chr);
+                break;
+            case if_test_cmd:
+                /*tex An experiment. */
+                if (cur_chr == if_condition_code) {
+                    break;
+                }
+                /*tex End of experiment. */
+                conditional();
+                break;
+            case fi_or_else_cmd:
+                /*tex
+
+                    Terminate the current conditional and skip to \.{\\fi} The
+                    processing of conditionals is complete except for the
+                    following code, which is actually part of |expand|. It comes
+                    into play when \.{\\or}, \.{\\else}, or \.{\\fi} is scanned.
+
+                */
+                if (tracing_ifs_par > 0)
+                    if (tracing_commands_par <= 1)
+                        show_cur_cmd_chr();
+                if (cur_chr > if_limit) {
+                    if (if_limit == if_code) {
+                        /*tex Condition is not yet evaluated. */
+                        insert_relax();
+                    } else {
+                        print_err("Extra ");
+                        print_cmd_chr(fi_or_else_cmd, cur_chr);
+                        help1("I'm ignoring this; it doesn't match any \\if.");
+                        error();
+                    }
+                } else {
+                    while (cur_chr != fi_code) {
+                        /*tex Skip to \.{\\fi}. */
+                        pass_text();
+                    }
+                    pop_condition_stack();
+                }
+                break;
+            case input_cmd:
+                /*tex Initiate or terminate input from a file */
+                if (cur_chr == 1)
+                    force_eof = true;
+                else if (cur_chr == 2)
+                    pseudo_start();
+                else if (cur_chr == 3) {
+                    pseudo_start();
+                    iname = 19;
+                } else if (name_in_progress)
+                    insert_relax();
+                else
+                    start_input();
+                break;
+            case lua_expandable_call_cmd:
+                if (cur_chr <= 0) {
+                    normal_error("luacall", "invalid number");
+                } else {
+                    str_number u = save_cur_string();
+                    luacstrings = 0;
+                    luafunctioncall(cur_chr);
+                    restore_cur_string(u);
+                    if (luacstrings > 0)
+                        lua_string_start();
+                }
+                break;
+            case lua_local_call_cmd:
+                if (cur_chr <= 0) {
+                    normal_error("luacall", "invalid number");
+                } else {
+                    str_number u = save_cur_string();
+                    luacstrings = 0;
+                    lua_rawgeti(Luas, LUA_REGISTRYINDEX, cur_chr);
+                    lua_call(Luas,0,0);
+                    restore_cur_string(u);
+                    if (luacstrings > 0)
+                        lua_string_start();
+                }
+                break;
+            case variable_cmd:
+                do_variable();
+                break;
+            case feedback_cmd:
+                do_feedback();
+                break;
+            default:
+                /*tex Complain about an undefined macro */
+                print_err("Undefined control sequence");
+                help5(
+                    "The control sequence at the end of the top line",
+                    "of your error message was never \\def'ed. If you have",
+                    "misspelled it (e.g., `\\hobx'), type `I' and the correct",
+                    "spelling (e.g., `I\\hbox'). Otherwise just continue,",
+                    "and I'll forget about whatever was undefined."
+                );
+                error();
+                break;
+        }
+    } else if (cur_cmd < end_template_cmd) {
+        macro_call();
+    } else {
+        /*tex
+
+            Insert a token containing |frozen_endv|. An |end_template| command is
+            effectively changed to an |endv| command by the following code. (The
+            reason for this is discussed below; the |frozen_end_template| at the
+            end of the template has passed the |check_outer_validity| test, so
+            its mission of error detection has been accomplished.)
+
+        */
+        cur_tok = cs_token_flag + frozen_endv;
+        back_input();
+    }
+    cur_val = cv_backup;
+    cur_val_level = cvl_backup;
+    radix = radix_backup;
+    cur_order = co_backup;
+    set_token_link(backup_head, backup_backup);
+    decr(expand_depth_count);
+}
+
+void complain_missing_csname(void)
+{
+    print_err("Missing \\endcsname inserted");
+    help2(
+        "The control sequence marked <to be read again> should",
+        "not appear between \\csname and \\endcsname."
+    );
+    back_error();
+}
+
+void manufacture_csname(boolean use)
+{
+    halfword p, q, r;
+    lstring *ss;
+    r = get_avail();
+    p = r;
+    is_in_csname += 1;
+    do {
+        get_x_token();
+        if (cur_cs == 0)
+            store_new_token(cur_tok);
+    } while (cur_cs == 0);
+    if (cur_cmd != end_cs_name_cmd) {
+        /*tex Complain about missing \.{\\endcsname}. */
+        complain_missing_csname();
+    }
+    /*tex Look up the characters of list |r| in the hash table, and set |cur_cs|. */
+    ss = tokenlist_to_lstring(r, true);
+    is_in_csname -= 1;
+    if (use) {
+        if (ss->l > 0) {
+            cur_cs = string_lookup((char *) ss->s, ss->l);
+        } else {
+            cur_cs = null_cs;
+        }
+        last_cs_name = cur_cs ;
+        free_lstring(ss);
+        flush_list(r);
+        if (cur_cs == null_cs) {
+            /*tex skip */
+        } else if (eq_type(cur_cs) == undefined_cs_cmd) {
+            /*tex skip */
+        } else {
+            cur_tok = cur_cs + cs_token_flag;
+            back_input();
+        }
+    } else {
+        if (ss->l > 0) {
+            no_new_control_sequence = false;
+            cur_cs = string_lookup((char *) ss->s, ss->l);
+            no_new_control_sequence = true;
+        } else {
+            /*tex the list is empty */
+            cur_cs = null_cs;
+        }
+        last_cs_name = cur_cs ;
+        free_lstring(ss);
+        flush_list(r);
+        if (eq_type(cur_cs) == undefined_cs_cmd) {
+            /*tex The |save_stack| might change! */
+            eq_define(cur_cs, relax_cmd, too_big_char);
+        };
+        /*tex The control sequence will now match \.{\\relax} */
+        cur_tok = cur_cs + cs_token_flag;
+        back_input();
+    }
+}
+
+void inject_last_tested_cs(void)
+{
+    if (last_cs_name != null_cs) {
+        cur_cs = last_cs_name;
+        cur_tok = last_cs_name + cs_token_flag;
+        back_input();
+    }
+}
+
+/*tex
+
+    Sometimes the expansion looks too far ahead, so we want to insert a harmless
+    \.{\\relax} into the user's input.
+
+*/
+
+void insert_relax(void)
+{
+    cur_tok = cs_token_flag + cur_cs;
+    back_input();
+    cur_tok = cs_token_flag + frozen_relax;
+    back_input();
+    token_type = inserted;
+}
+
+
+/*tex
+
+    Here is a recursive procedure that is \TeX's usual way to get the next token
+    of input. It has been slightly optimized to take account of common cases.
+
+*/
+
+void get_x_token(void)
+{
+    /*tex This code sets |cur_cmd|, |cur_chr|, |cur_tok|, and expands macros. */
+  RESTART:
+    get_next();
+    if (cur_cmd <= max_command_cmd)
+        goto DONE;
+    if (cur_cmd >= call_cmd) {
+        if (cur_cmd < end_template_cmd) {
+            macro_call();
+        } else {
+            cur_cs = frozen_endv;
+            cur_cmd = endv_cmd;
+            /*tex Now |cur_chr=null_list|. */
+            goto DONE;
+        }
+    } else {
+        expand();
+    }
+    goto RESTART;
+  DONE:
+    if (cur_cs == 0)
+        cur_tok = token_val(cur_cmd, cur_chr);
+    else
+        cur_tok = cs_token_flag + cur_cs;
+}
+
+/*tex
+
+    The |get_x_token| procedure is equivalent to two consecutive procedure calls:
+    |get_next; x_token|. It's |get_x_token| without the initial |get_next|.
+
+*/
+
+void x_token(void)
+{
+    while (cur_cmd > max_command_cmd) {
+        expand();
+        get_next();
+   }
+    if (cur_cs == 0)
+        cur_tok = token_val(cur_cmd, cur_chr);
+    else
+        cur_tok = cs_token_flag + cur_cs;
+}
+
+/*tex
+
+    A control sequence that has been \.{\\def}'ed by the user is expanded by
+    \TeX's |macro_call| procedure.
+
+    Before we get into the details of |macro_call|, however, let's consider the
+    treatment of primitives like \.{\\topmark}, since they are essentially macros
+    without parameters. The token lists for such marks are kept in five global
+    arrays of pointers; we refer to the individual entries of these arrays by
+    symbolic macros |top_mark|, etc. The value of |top_mark(x)|, etc. is either
+    |null| or a pointer to the reference count of a token list.
+
+    The variable |biggest_used_mark| is an aid to try and keep the code somehwat
+    efficient without too much extra work: it registers the highest mark class
+    ever instantiated by the user, so the loops in |fire_up| and |vsplit| do not
+    have to traverse the full range |0..biggest_mark|.
+
+*/
+
+halfword top_marks_array[(biggest_mark + 1)];
+halfword first_marks_array[(biggest_mark + 1)];
+halfword bot_marks_array[(biggest_mark + 1)];
+halfword split_first_marks_array[(biggest_mark + 1)];
+halfword split_bot_marks_array[(biggest_mark + 1)];
+halfword biggest_used_mark;
+
+void initialize_marks(void)
+{
+    int i;
+    biggest_used_mark = 0;
+    for (i = 0; i <= biggest_mark; i++) {
+        top_mark(i) = null;
+        first_mark(i) = null;
+        bot_mark(i) = null;
+        split_first_mark(i) = null;
+        split_bot_mark(i) = null;
+    }
+}
+
+/*tex
+
+    Now let's consider |macro_call| itself, which is invoked when \TeX\ is
+    scanning a control sequence whose |cur_cmd| is either |call|, |long_call|,
+    |outer_call|, or |long_outer_call|. The control sequence definition appears
+    in the token list whose reference count is in location |cur_chr| of |mem|.
+
+    The global variable |long_state| will be set to |call| or to |long_call|,
+    depending on whether or not the control sequence disallows \.{\\par} in its
+    parameters. The |get_next| routine will set |long_state| to |outer_call| and
+    emit \.{\\par}, if a file ends or if an \.{\\outer} control sequence occurs
+    in the midst of an argument.
+
+*/
+
+/*tex Governs the acceptance of \.{\\par}: */
+
+int long_state;
+
+/*tex
+
+    The parameters, if any, must be scanned before the macro is expanded.
+    Parameters are token lists without reference counts. They are placed on an
+    auxiliary stack called |pstack| while they are being scanned, since the
+    |param_stack| may be losing entries during the matching process. (Note that
+    |param_stack| can't be gaining entries, since |macro_call| is the only
+    routine that puts anything onto |param_stack|, and it is not recursive.)
+
+*/
+
+/*tex The arguments supplied to a macro: */
+
+halfword pstack[9];
+
+/*tex
+
+    After parameter scanning is complete, the parameters are moved to the
+    |param_stack|. Then the macro body is fed to the scanner; in other words,
+    |macro_call| places the defined text of the control sequence at the top of\/
+    \TeX's input stack, so that |get_next| will proceed to read it next.
+
+    The global variable |cur_cs| contains the |eqtb| address of the control
+    sequence being expanded, when |macro_call| begins. If this control sequence
+    has not been declared \.{\\long}, i.e., if its command code in the |eq_type|
+    field is not |long_call| or |long_outer_call|, its parameters are not allowed
+    to contain the control sequence \.{\\par}. If an illegal \.{\\par} appears,
+    the macro call is aborted, and the \.{\\par} will be rescanned.
+
+*/
+
+/*tex This invokes a user-defined control sequence. */
+
+void macro_call(void)
+{
+    /*tex current node in the macro's token list */
+    halfword r;
+    /*tex current node in parameter token list being built */
+    halfword p = null;
+    /*tex new node being put into the token list */
+    halfword q;
+    /*tex backup pointer for parameter matching */
+    halfword s;
+    /*tex cycle pointer for backup recovery */
+    halfword t;
+    /*tex auxiliary pointers for backup recovery */
+    halfword u, v;
+    /*tex one step before the last |right_brace| token */
+    halfword rbrace_ptr = null;
+    /*tex the number of parameters scanned */
+    int n = 0;
+    /*tex unmatched left braces in current parameter */
+    halfword unbalance;
+    /*tex the number of tokens or groups (usually) */
+    halfword m = 0;
+    /*tex start of the token list */
+    halfword ref_count;
+    /*tex |scanner_status| upon entry */
+    int save_scanner_status = scanner_status;
+    /*tex |warning_index| upon entry */
+    halfword save_warning_index = warning_index;
+    /*tex character used in parameter */
+    int match_chr = 0;
+    warning_index = cur_cs;
+    ref_count = cur_chr;
+    r = token_link(ref_count);
+    if (tracing_macros_par > 0) {
+        /*tex Show the text of the macro being expanded. */
+        begin_diagnostic();
+        print_ln();
+        print_cs(warning_index);
+        token_show(ref_count);
+        end_diagnostic(false);
+    }
+    if (token_info(r) == protected_token)
+        r = token_link(r);
+    if (token_info(r) != end_match_token) {
+        /*tex
+
+            Scan the parameters and make |link(r)| point to the macro body; but
+            |return| if an illegal \.{\\par} is detected.
+
+            At this point, the reader will find it advisable to review the
+            explanation of token list format that was presented earlier, since
+            many aspects of that format are of importance chiefly in the
+            |macro_call| routine.
+
+            The token list might begin with a string of compulsory tokens before
+            the first |match| or |end_match|. In that case the macro name is
+            supposed to be followed by those tokens; the following program will
+            set |s=null| to represent this restriction. Otherwise |s| will be set
+            to the first token of a string that will delimit the next parameter.
+
+        */
+        scanner_status = matching;
+        unbalance = 0;
+        long_state = eq_type(cur_cs);
+        if (long_state >= outer_call_cmd)
+            long_state = long_state - 2;
+        do {
+            set_token_link(temp_token_head, null);
+            if ((token_info(r) >= end_match_token)
+                || (token_info(r) < match_token)) {
+                s = null;
+            } else {
+                match_chr = token_info(r) - match_token;
+                s = token_link(r);
+                r = s;
+                p = temp_token_head;
+                m = 0;
+            }
+            /*tex
+
+                Scan a parameter until its delimiter string has been found; or,
+                if |s=null|, simply scan the delimiter string.
+
+                If |info(r)| is a |match| or |end_match| command, it cannot be
+                equal to any token found by |get_token|. Therefore an undelimited
+                parameter---i.e., a |match| that is immediately followed by
+                |match| or |end_match|---will always fail the test
+                `|cur_tok=info(r)|' in the following algorithm.
+
+            */
+          CONTINUE:
+            /*tex Set |cur_tok| to the next token of input: */
+            get_token();
+            if (cur_tok == token_info(r)) {
+                /*tex
+
+                    Advance |r|; |goto found| if the parameter delimiter has been
+                    fully matched, otherwise |goto continue|.
+
+                    A slightly subtle point arises here: When the parameter
+                    delimiter ends with `\.{\#\{}', the token list will have a
+                    left brace both before and after the |end_match|\kern-.4pt.
+                    Only one of these should affect the |align_state|, but both
+                    will be scanned, so we must make a correction.
+
+                */
+                r = token_link(r);
+                if ((token_info(r) >= match_token)
+                    && (token_info(r) <= end_match_token)) {
+                    if (cur_tok < left_brace_limit)
+                        decr(align_state);
+                    goto FOUND;
+                } else {
+                    goto CONTINUE;
+                }
+
+            }
+            /*tex
+
+                Contribute the recently matched tokens to the current parameter,
+                and |goto continue| if a partial match is still in effect; but
+                abort if |s=null|.
+
+                When the following code becomes active, we have matched tokens
+                from |s| to the predecessor of |r|, and we have found that
+                |cur_tok<>info(r)|. An interesting situation now presents itself:
+                If the parameter is to be delimited by a string such as `\.{ab}',
+                and if we have scanned `\.{aa}', we want to contribute one `\.a'
+                to the current parameter and resume looking for a `\.b'. The
+                program must account for such partial matches and for others that
+                can be quite complex. But most of the time we have |s=r| and
+                nothing needs to be done.
+
+                Incidentally, it is possible for \.{\\par} tokens to sneak in to
+                certain parameters of non-\.{\\long} macros. For example,
+                consider a case like `\.{\\def\\a\#1\\par!\{...\}}' where the
+                first \.{\\par} is not followed by an exclamation point. In such
+                situations it does not seem appropriate to prohibit the
+                \.{\\par}, so \TeX\ keeps quiet about this bending of the rules.
+
+            */
+            if (s != r) {
+                if (s == null) {
+                    /*tex Report an improper use of the macro and abort. */
+                    print_err("Use of ");
+                    sprint_cs(warning_index);
+                    tprint(" doesn't match its definition");
+                    help4(
+                        "If you say, e.g., `\\def\\a1{...}', then you must always",
+                        "put `1' after `\\a', since control sequence names are",
+                        "made up of letters only. The macro here has not been",
+                        "followed by the required stuff, so I'm ignoring it."
+                    );
+                    error();
+                    goto EXIT;
+
+                } else {
+                    t = s;
+                    do {
+                        store_new_token(token_info(t));
+                        incr(m);
+                        u = token_link(t);
+                        v = s;
+                        while (1) {
+                            if (u == r) {
+                                if (cur_tok != token_info(v)) {
+                                    goto DONE;
+                                } else {
+                                    r = token_link(v);
+                                    goto CONTINUE;
+                                }
+                            }
+                            if (token_info(u) != token_info(v))
+                                goto DONE;
+                            u = token_link(u);
+                            v = token_link(v);
+                        }
+                      DONE:
+                        t = token_link(t);
+                    } while (t != r);
+                    r = s;
+                    /*tex At this point, no tokens are recently matched. */
+                }
+            }
+            if (cur_tok == par_token)
+                if (long_state != long_call_cmd)
+                    if (!suppress_long_error_par) {
+                        goto RUNAWAY;
+                    }
+            if (cur_tok < right_brace_limit) {
+                if (cur_tok < left_brace_limit) {
+                    /*tex Contribute an entire group to the current parameter. */
+                    unbalance = 1;
+                    while (1) {
+                        fast_store_new_token(cur_tok);
+                        get_token();
+                        if (cur_tok == par_token) {
+                            if (long_state != long_call_cmd) {
+                                if (!suppress_long_error_par) {
+                                    goto RUNAWAY;
+
+                                }
+                            }
+                        }
+                        if (cur_tok < right_brace_limit) {
+                            if (cur_tok < left_brace_limit) {
+                                incr(unbalance);
+                            } else {
+                                decr(unbalance);
+                                if (unbalance == 0)
+                                    break;
+                            }
+                        }
+                    }
+                    rbrace_ptr = p;
+                    store_new_token(cur_tok);
+                } else {
+                    /*tex Report an extra right brace and |goto continue|. */
+                    back_input();
+                    print_err("Argument of ");
+                    sprint_cs(warning_index);
+                    tprint(" has an extra }");
+                    help6(
+                        "I've run across a `}' that doesn't seem to match anything.",
+                        "For example, `\\def\\a#1{...}' and `\\a}' would produce",
+                        "this error. If you simply proceed now, the `\\par' that",
+                        "I've just inserted will cause me to report a runaway",
+                        "argument that might be the root of the problem. But if",
+                        "your `}' was spurious, just type `2' and it will go away."
+                    );
+                    incr(align_state);
+                    long_state = call_cmd;
+                    cur_tok = par_token;
+                    ins_error();
+                    goto CONTINUE;
+                    /*tex A white lie; the \.{\\par} won't always trigger a runaway. */
+                }
+            } else {
+                /*tex
+
+                    Store the current token, but |goto continue| if it is a blank
+                    space that would become an undelimited parameter.
+
+                */
+                if (cur_tok == space_token && token_info(r) <= end_match_token && token_info(r) >= match_token)
+                    goto CONTINUE;
+                store_new_token(cur_tok);
+            }
+            incr(m);
+            if (token_info(r) > end_match_token)
+                goto CONTINUE;
+            if (token_info(r) < match_token)
+                goto CONTINUE;
+          FOUND:
+            if (s != null) {
+                /*
+
+                    Tidy up the parameter just scanned, and tuck it away. If the
+                    parameter consists of a single group enclosed in braces, we
+                    must strip off the enclosing braces. That's why |rbrace_ptr|
+                    was introduced.
+
+                */
+                if ((m == 1) && (token_info(p) < right_brace_limit)
+                    && (p != temp_token_head)) {
+                    set_token_link(rbrace_ptr, null);
+                    free_avail(p);
+                    p = token_link(temp_token_head);
+                    pstack[n] = token_link(p);
+                    free_avail(p);
+                } else {
+                    pstack[n] = token_link(temp_token_head);
+                }
+                incr(n);
+                if (tracing_macros_par > 0) {
+                    begin_diagnostic();
+                    print_nl(match_chr);
+                    print_int(n);
+                    tprint("<-");
+                    show_token_list(pstack[n - 1], null, 1000);
+                    end_diagnostic(false);
+                }
+            }
+            /*tex
+
+                Now |info(r)| is a token whose command code is either |match| or
+                |end_match|.
+
+            */
+        } while (token_info(r) != end_match_token);
+    }
+    /*tex
+
+        Feed the macro body and its parameters to the scanner Before we put a new
+        token list on the input stack, it is wise to clean off all token lists
+        that have recently been depleted. Then a user macro that ends with a call
+        to itself will not require unbounded stack space.
+
+    */
+    while ((istate == token_list) && (iloc == null) && (token_type != v_template)) {
+        /*tex Conserve stack space. */
+        end_token_list();
+    }
+    begin_token_list(ref_count, macro);
+    iname = warning_index;
+    iloc = token_link(r);
+    if (n > 0) {
+        if (param_ptr + n > max_param_stack) {
+            max_param_stack = param_ptr + n;
+            if (max_param_stack > param_size)
+                overflow("parameter stack size", (unsigned) param_size);
+        }
+        for (m = 0; m <= n - 1; m++)
+            param_stack[param_ptr + m] = pstack[m];
+        param_ptr = param_ptr + n;
+    }
+    goto EXIT;
+  RUNAWAY:
+    /*tex
+
+        Report a runaway argument and abort. If |long_state=outer_call|, a
+        runaway argument has already been reported.
+
+    */
+    if (long_state == call_cmd) {
+        runaway();
+        print_err("Paragraph ended before ");
+        sprint_cs(warning_index);
+        tprint(" was complete");
+        help3(
+            "I suspect you've forgotten a `}', causing me to apply this",
+            "control sequence to too much text. How can we recover?",
+            "My plan is to forget the whole thing and hope for the best."
+        );
+        back_error();
+    }
+    pstack[n] = token_link(temp_token_head);
+    align_state = align_state - unbalance;
+    for (m = 0; m <= n; m++)
+        flush_list(pstack[m]);
+  EXIT:
+    scanner_status = save_scanner_status;
+    warning_index = save_warning_index;
+}
diff --git a/texk/web2c/luatexdir/tex/expand.w b/texk/web2c/luatexdir/tex/expand.w
deleted file mode 100644
index c912863b2..000000000
--- a/texk/web2c/luatexdir/tex/expand.w
+++ /dev/null
@@ -1,829 +0,0 @@
-% expand.w
-%
-% Copyright 2009-2010 Taco Hoekwater <taco@@luatex.org>
-%
-% This file is part of LuaTeX.
-%
-% LuaTeX is free software; you can redistribute it and/or modify it under
-% the terms of the GNU General Public License as published by the Free
-% Software Foundation; either version 2 of the License, or (at your
-% option) any later version.
-%
-% LuaTeX is distributed in the hope that it will be useful, but WITHOUT
-% ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-% FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
-% License for more details.
-%
-% You should have received a copy of the GNU General Public License along
-% with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
-
-@ @c
-
-
-#include "ptexlib.h"
-
-@ Only a dozen or so command codes |>max_command| can possibly be returned by
-|get_next|; in increasing order, they are |undefined_cs|, |expand_after|,
-|no_expand|, |input|, |if_test|, |fi_or_else|, |cs_name|, |convert|, |the|,
-|top_bot_mark|, |call|, |long_call|, |outer_call|, |long_outer_call|, and
-|end_template|.{\emergencystretch=40pt\par}
-
-Sometimes, recursive calls to the following |expand| routine may
-cause exhaustion of the run-time calling stack, resulting in
-forced execution stops by the operating system. To diminish the chance
-of this happening, a counter is used to keep track of the recursion
-depth, in conjunction with a constant called |expand_depth|.
-
-Note that this does not catch all possible infinite recursion loops,
-just the ones that exhaust the application calling stack. The
-actual maximum value of |expand_depth| is outside of our control, but
-the initial setting of |100| should be enough to prevent problems.
-@^system dependencies@>
-
-@c
-static int expand_depth_count = 0;
-
-
-@ The |expand| subroutine is used when |cur_cmd>max_command|. It removes a
-``call'' or a conditional or one of the other special operations just
-listed.  It follows that |expand| might invoke itself recursively. In all
-cases, |expand| destroys the current token, but it sets things up so that
-the next |get_next| will deliver the appropriate next token. The value of
-|cur_tok| need not be known when |expand| is called.
-
-Since several of the basic scanning routines communicate via global variables,
-their values are saved as local variables of |expand| so that
-recursive calls don't invalidate them.
-@^recursion@>
-
-@c
-int is_in_csname = 0;
-
-@ @c
-void expand(void)
-{
-    halfword t;                 /* token that is being ``expanded after'' */
-    halfword p;                 /* for list manipulation */
-    halfword cur_ptr;           /* for a local token list pointer */
-    int cv_backup;              /* to save the global quantity |cur_val| */
-    int cvl_backup, radix_backup, co_backup;    /* to save |cur_val_level|, etc. */
-    halfword backup_backup;     /* to save |link(backup_head)| */
-    int save_scanner_status;    /* temporary storage of |scanner_status| */
-    incr(expand_depth_count);
-    if (expand_depth_count >= expand_depth)
-        overflow("expansion depth", (unsigned) expand_depth);
-    cv_backup = cur_val;
-    cvl_backup = cur_val_level;
-    radix_backup = radix;
-    co_backup = cur_order;
-    backup_backup = token_link(backup_head);
-  RESWITCH:
-    if (cur_cmd < call_cmd) {
-        /* Expand a nonmacro */
-        if (tracing_commands_par > 1)
-            show_cur_cmd_chr();
-        switch (cur_cmd) {
-        case top_bot_mark_cmd:
-            /* Insert the appropriate mark text into the scanner */
-            t = cur_chr % marks_code;
-            if (cur_chr >= marks_code)
-                scan_mark_num();
-            else
-                cur_val = 0;
-            switch (t) {
-            case first_mark_code:
-                cur_ptr = first_mark(cur_val);
-                break;
-            case bot_mark_code:
-                cur_ptr = bot_mark(cur_val);
-                break;
-            case split_first_mark_code:
-                cur_ptr = split_first_mark(cur_val);
-                break;
-            case split_bot_mark_code:
-                cur_ptr = split_bot_mark(cur_val);
-                break;
-            default:
-                cur_ptr = top_mark(cur_val);
-                break;
-            }
-            if (cur_ptr != null)
-                begin_token_list(cur_ptr, mark_text);
-            break;
-        case expand_after_cmd:
-            if (cur_chr == 0) {
-                /* Expand the token after the next token */
-                /* It takes only a little shuffling to do what \TeX\ calls \.{\\expandafter}. */
-                get_token();
-                t = cur_tok;
-                get_token();
-                if (cur_cmd > max_command_cmd)
-                    expand();
-                else
-                    back_input();
-                cur_tok = t;
-                back_input();
-
-            } else {            /* \\unless */
-                /* Negate a boolean conditional and |goto reswitch| */
-                /* The result of a boolean condition is reversed when the conditional is
-                   preceded by \.{\\unless}. */
-                get_token();
-                if ((cur_cmd == if_test_cmd) && (cur_chr != if_case_code)) {
-                    cur_chr = cur_chr + unless_code;
-                    goto RESWITCH;
-                }
-                print_err("You can't use `\\unless' before `");
-                print_cmd_chr((quarterword) cur_cmd, cur_chr);
-                print_char('\'');
-                help1("Continue, and I'll forget that it ever happened.");
-                back_error();
-            }
-            break;
-        case no_expand_cmd:
-            if (cur_chr == 0) {
-                /* Suppress expansion of the next token */
-                /* The implementation of \.{\\noexpand} is a bit trickier, because it is
-                   necessary to insert a special `|dont_expand|' marker into \TeX's reading
-                   mechanism.  This special marker is processed by |get_next|, but it does
-                   not slow down the inner loop.
-
-                   Since \.{\\outer} macros might arise here, we must also
-                   clear the |scanner_status| temporarily.
-                 */
-
-                save_scanner_status = scanner_status;
-                scanner_status = normal;
-                get_token();
-                scanner_status = save_scanner_status;
-                t = cur_tok;
-                back_input();   /* now |start| and |loc| point to the backed-up token |t| */
-                if (t >= cs_token_flag) {
-                    p = get_avail();
-                    set_token_info(p, cs_token_flag + frozen_dont_expand);
-                    set_token_link(p, iloc);
-                    istart = p;
-                    iloc = p;
-                }
-
-            } else {
-                /* Implement \.{\\primitive} */
-                /*
-                   The \.{\\primitive} handling. If the primitive meaning of the next
-                   token is an expandable command, it suffices to replace the current
-                   token with the primitive one and restart |expand|.
-
-                   Otherwise, the token we just read has to be pushed back, as well
-                   as a token matching the internal form of \.{\\primitive}, that is
-                   sneaked in as an alternate form of |ignore_spaces|.
-
-                   An implementation problem surfaces: There really is no |cur_cs|
-                   attached to the inserted primitive command, so it is safer to set
-                   |cur_cs| to zero.  |cur_tok| has a similar problem. And for the
-                   non-expanded branch, simply pushing back a token that matches the
-                   correct internal command does not work, because that approach would
-                   not survive roundtripping to a temporary file or even a token list.
-
-                   In a next version, it would be smart to create |frozen_| versions of
-                   all the primitives.  Then, this problem would not happen, at the
-                   expense of a few hundred extra control sequences.
-                 */
-                save_scanner_status = scanner_status;
-                scanner_status = normal;
-                get_token();
-                scanner_status = save_scanner_status;
-                cur_cs = prim_lookup(cs_text(cur_cs));
-                if (cur_cs != undefined_primitive) {
-                    t = get_prim_eq_type(cur_cs);
-                    if (t > max_command_cmd) {
-                        cur_cmd = t;
-                        cur_chr = get_prim_equiv(cur_cs);
-                        cur_tok = token_val(cur_cmd, cur_chr);
-                        cur_cs = 0;
-                        goto RESWITCH;
-                    } else {
-                        back_input();   /*  now |loc| and |start| point to a one-item list */
-                        p = get_avail();
-                        set_token_info(p, cs_token_flag + frozen_primitive);
-                        set_token_link(p, iloc);
-                        iloc = p;
-                        istart = p;
-                    }
-                } else if (suppress_primitive_error_par == 0) {
-                    print_err("Missing primitive name");
-                    help2
-                        ("The control sequence marked <to be read again> does not",
-                         "represent any known primitive.");
-                    back_error();
-                }
-
-            }
-            break;
-        case cs_name_cmd:
-            /* Manufacture a control sequence name; */
-            if (cur_chr == 0) {
-                manufacture_csname(0);
-            } else if (cur_chr == 1) {
-                inject_last_tested_cs();
-            } else {
-                manufacture_csname(1);
-            }
-            break;
-        case convert_cmd:
-            conv_toks();        /* this procedure is discussed in Part 27 below */
-            break;
-        case the_cmd:
-            ins_the_toks();     /* this procedure is discussed in Part 27 below */
-            break;
-        case combine_toks_cmd:
-            combine_the_toks(cur_chr);
-            break;
-        case if_test_cmd:
-            conditional();      /* this procedure is discussed in Part 28 below */
-            break;
-        case fi_or_else_cmd:
-            /* Terminate the current conditional and skip to \.{\\fi} */
-            /* The processing of conditionals is complete except for the following
-               code, which is actually part of |expand|. It comes into play when
-               \.{\\or}, \.{\\else}, or \.{\\fi} is scanned. */
-
-            if (tracing_ifs_par > 0)
-                if (tracing_commands_par <= 1)
-                    show_cur_cmd_chr();
-            if (cur_chr > if_limit) {
-                if (if_limit == if_code) {
-                    insert_relax();     /*  condition not yet evaluated */
-                } else {
-                    print_err("Extra ");
-                    print_cmd_chr(fi_or_else_cmd, cur_chr);
-                    help1("I'm ignoring this; it doesn't match any \\if.");
-                    error();
-                }
-            } else {
-                while (cur_chr != fi_code)
-                    pass_text();        /* skip to \.{\\fi} */
-                pop_condition_stack();
-            }
-
-            break;
-        case input_cmd:
-            /* Initiate or terminate input from a file */
-            if (cur_chr == 1)
-                force_eof = true;
-            else if (cur_chr == 2)
-                pseudo_start();
-            else if (cur_chr == 3) {
-                pseudo_start();
-                iname = 19;
-            } else if (name_in_progress)
-                insert_relax();
-            else
-                start_input();
-            break;
-        case variable_cmd:
-            do_variable();
-            break;
-        case feedback_cmd:
-            do_feedback();
-            break;
-        default:
-            /* Complain about an undefined macro */
-            print_err("Undefined control sequence");
-            help5("The control sequence at the end of the top line",
-                  "of your error message was never \\def'ed. If you have",
-                  "misspelled it (e.g., `\\hobx'), type `I' and the correct",
-                  "spelling (e.g., `I\\hbox'). Otherwise just continue,",
-                  "and I'll forget about whatever was undefined.");
-            error();
-            break;
-        }
-    } else if (cur_cmd < end_template_cmd) {
-        macro_call();
-    } else {
-        /* Insert a token containing |frozen_endv| */
-        /* An |end_template| command is effectively changed to an |endv| command
-           by the following code. (The reason for this is discussed below; the
-           |frozen_end_template| at the end of the template has passed the
-           |check_outer_validity| test, so its mission of error detection has been
-           accomplished.)
-         */
-        cur_tok = cs_token_flag + frozen_endv;
-        back_input();
-
-    }
-    cur_val = cv_backup;
-    cur_val_level = cvl_backup;
-    radix = radix_backup;
-    cur_order = co_backup;
-    set_token_link(backup_head, backup_backup);
-    decr(expand_depth_count);
-}
-
-@ @c
-void complain_missing_csname(void)
-{
-    print_err("Missing \\endcsname inserted");
-    help2("The control sequence marked <to be read again> should",
-          "not appear between \\csname and \\endcsname.");
-    back_error();
-}
-
-@ @c
-void manufacture_csname(boolean use)
-{
-    halfword p, q, r;
-    lstring *ss;
-    r = get_avail();
-    p = r;                      /* head of the list of characters */
-    is_in_csname += 1;
-    do {
-        get_x_token();
-        if (cur_cs == 0)
-            store_new_token(cur_tok);
-    } while (cur_cs == 0);
-    if (cur_cmd != end_cs_name_cmd) {
-        /* Complain about missing \.{\\endcsname} */
-        complain_missing_csname();
-    }
-    /* Look up the characters of list |r| in the hash table, and set |cur_cs| */
-    ss = tokenlist_to_lstring(r, true);
-    is_in_csname -= 1;
-    if (use) {
-        if (ss->l > 0) {
-            cur_cs = string_lookup((char *) ss->s, ss->l);
-        } else {
-            cur_cs = null_cs;
-        }
-        last_cs_name = cur_cs ;
-        free_lstring(ss);
-        flush_list(r);
-        if (cur_cs == null_cs) {
-            /* skip */
-        } else if (eq_type(cur_cs) == undefined_cs_cmd) {
-            /* skip */
-        } else {
-            cur_tok = cur_cs + cs_token_flag;
-            back_input();
-        }
-    } else {
-        if (ss->l > 0) {
-            no_new_control_sequence = false;
-            cur_cs = string_lookup((char *) ss->s, ss->l);
-            no_new_control_sequence = true;
-        } else {
-            cur_cs = null_cs;       /* the list is empty */
-        }
-        last_cs_name = cur_cs ;
-        free_lstring(ss);
-        flush_list(r);
-        if (eq_type(cur_cs) == undefined_cs_cmd) {
-            eq_define(cur_cs, relax_cmd, too_big_char);     /* N.B.: The |save_stack| might change */
-        };                          /* the control sequence will now match `\.{\\relax}' */
-        cur_tok = cur_cs + cs_token_flag;
-        back_input();
-    }
-}
-
-void inject_last_tested_cs(void)
-{
-    if (last_cs_name != null_cs) {
-        cur_cs = last_cs_name;
-        cur_tok = last_cs_name + cs_token_flag;
-        back_input();
-    }
-}
-
-@ Sometimes the expansion looks too far ahead, so we want to insert
-a harmless \.{\\relax} into the user's input.
-
-@c
-void insert_relax(void)
-{
-    cur_tok = cs_token_flag + cur_cs;
-    back_input();
-    cur_tok = cs_token_flag + frozen_relax;
-    back_input();
-    token_type = inserted;
-}
-
-
-@ Here is a recursive procedure that is \TeX's usual way to get the
-next token of input. It has been slightly optimized to take account of
-common cases.
-
-@c
-void get_x_token(void)
-{                               /* sets |cur_cmd|, |cur_chr|, |cur_tok|,  and expands macros */
-  RESTART:
-    get_next();
-    if (cur_cmd <= max_command_cmd)
-        goto DONE;
-    if (cur_cmd >= call_cmd) {
-        if (cur_cmd < end_template_cmd) {
-            macro_call();
-        } else {
-            cur_cs = frozen_endv;
-            cur_cmd = endv_cmd;
-            goto DONE;          /* |cur_chr=null_list| */
-        }
-    } else {
-        expand();
-    }
-    goto RESTART;
-  DONE:
-    if (cur_cs == 0)
-        cur_tok = token_val(cur_cmd, cur_chr);
-    else
-        cur_tok = cs_token_flag + cur_cs;
-}
-
-
-@ The |get_x_token| procedure is equivalent to two consecutive
-procedure calls: |get_next; x_token|.
-
-@c
-void x_token(void)
-{                               /* |get_x_token| without the initial |get_next| */
-    while (cur_cmd > max_command_cmd) {
-        expand();
-        get_next();
-   }
-    if (cur_cs == 0)
-        cur_tok = token_val(cur_cmd, cur_chr);
-    else
-        cur_tok = cs_token_flag + cur_cs;
-}
-
-
-@ A control sequence that has been \.{\\def}'ed by the user is expanded by
-\TeX's |macro_call| procedure.
-
-Before we get into the details of |macro_call|, however, let's consider the
-treatment of primitives like \.{\\topmark}, since they are essentially
-macros without parameters. The token lists for such marks are kept in five
-global arrays of pointers; we refer to the individual entries of these
-arrays by symbolic macros |top_mark|, etc. The value of |top_mark(x)|, etc.
-is either |null| or a pointer to the reference count of a token list.
-
-The variable |biggest_used_mark| is an aid to try and keep the code
-somehwat efficient without too much extra work: it registers the
-highest mark class ever instantiated by the user, so the loops
-in |fire_up| and |vsplit| do not have to traverse the full range
-|0..biggest_mark|.
-
-@c
-halfword top_marks_array[(biggest_mark + 1)];
-halfword first_marks_array[(biggest_mark + 1)];
-halfword bot_marks_array[(biggest_mark + 1)];
-halfword split_first_marks_array[(biggest_mark + 1)];
-halfword split_bot_marks_array[(biggest_mark + 1)];
-halfword biggest_used_mark;
-
-@ @c
-void initialize_marks(void)
-{
-    int i;
-    biggest_used_mark = 0;
-    for (i = 0; i <= biggest_mark; i++) {
-        top_mark(i) = null;
-        first_mark(i) = null;
-        bot_mark(i) = null;
-        split_first_mark(i) = null;
-        split_bot_mark(i) = null;
-    }
-}
-
-
-@ Now let's consider |macro_call| itself, which is invoked when \TeX\ is
-scanning a control sequence whose |cur_cmd| is either |call|, |long_call|,
-|outer_call|, or |long_outer_call|.  The control sequence definition
-appears in the token list whose reference count is in location |cur_chr|
-of |mem|.
-
-The global variable |long_state| will be set to |call| or to |long_call|,
-depending on whether or not the control sequence disallows \.{\\par}
-in its parameters. The |get_next| routine will set |long_state| to
-|outer_call| and emit \.{\\par}, if a file ends or if an \.{\\outer}
-control sequence occurs in the midst of an argument.
-
-@c
-int long_state;                 /* governs the acceptance of \.{\\par} */
-
-@ The parameters, if any, must be scanned before the macro is expanded.
-Parameters are token lists without reference counts. They are placed on
-an auxiliary stack called |pstack| while they are being scanned, since
-the |param_stack| may be losing entries during the matching process.
-(Note that |param_stack| can't be gaining entries, since |macro_call| is
-the only routine that puts anything onto |param_stack|, and it
-is not recursive.)
-
-@c
-halfword pstack[9];             /* arguments supplied to a macro */
-
-
-@ After parameter scanning is complete, the parameters are moved to the
-|param_stack|. Then the macro body is fed to the scanner; in other words,
-|macro_call| places the defined text of the control sequence at the
-top of\/ \TeX's input stack, so that |get_next| will proceed to read it
-next.
-
-The global variable |cur_cs| contains the |eqtb| address of the control sequence
-being expanded, when |macro_call| begins. If this control sequence has not been
-declared \.{\\long}, i.e., if its command code in the |eq_type| field is
-not |long_call| or |long_outer_call|, its parameters are not allowed to contain
-the control sequence \.{\\par}. If an illegal \.{\\par} appears, the macro
-call is aborted, and the \.{\\par} will be rescanned.
-
-@c
-void macro_call(void)
-{                               /* invokes a user-defined control sequence */
-    halfword r;                 /* current node in the macro's token list */
-    halfword p = null;          /* current node in parameter token list being built */
-    halfword q;                 /* new node being put into the token list */
-    halfword s;                 /* backup pointer for parameter matching */
-    halfword t;                 /* cycle pointer for backup recovery */
-    halfword u, v;              /* auxiliary pointers for backup recovery */
-    halfword rbrace_ptr = null; /* one step before the last |right_brace| token */
-    int n = 0;                  /* the number of parameters scanned */
-    halfword unbalance;         /* unmatched left braces in current parameter */
-    halfword m = 0;             /* the number of tokens or groups (usually) */
-    halfword ref_count;         /* start of the token list */
-    int save_scanner_status = scanner_status;   /* |scanner_status| upon entry */
-    halfword save_warning_index = warning_index;        /* |warning_index| upon entry */
-    int match_chr = 0;          /* character used in parameter */
-    warning_index = cur_cs;
-    ref_count = cur_chr;
-    r = token_link(ref_count);
-    if (tracing_macros_par > 0) {
-        /* Show the text of the macro being expanded */
-        begin_diagnostic();
-        print_ln();
-        print_cs(warning_index);
-        token_show(ref_count);
-        end_diagnostic(false);
-    }
-    if (token_info(r) == protected_token)
-        r = token_link(r);
-    if (token_info(r) != end_match_token) {
-        /* Scan the parameters and make |link(r)| point to the macro body; but
-           |return| if an illegal \.{\\par} is detected */
-        /* At this point, the reader will find it advisable to review the explanation
-           of token list format that was presented earlier, since many aspects of that
-           format are of importance chiefly in the |macro_call| routine.
-
-           The token list might begin with a string of compulsory tokens before the
-           first |match| or |end_match|. In that case the macro name is supposed to be
-           followed by those tokens; the following program will set |s=null| to
-           represent this restriction. Otherwise |s| will be set to the first token of
-           a string that will delimit the next parameter.
-         */
-
-        scanner_status = matching;
-        unbalance = 0;
-        long_state = eq_type(cur_cs);
-        if (long_state >= outer_call_cmd)
-            long_state = long_state - 2;
-        do {
-            set_token_link(temp_token_head, null);
-            if ((token_info(r) >= end_match_token)
-                || (token_info(r) < match_token)) {
-                s = null;
-            } else {
-                match_chr = token_info(r) - match_token;
-                s = token_link(r);
-                r = s;
-                p = temp_token_head;
-                m = 0;
-            }
-            /* Scan a parameter until its delimiter string has been found; or, if |s=null|,
-               simply scan the delimiter string; */
-
-            /* If |info(r)| is a |match| or |end_match| command, it cannot be equal to
-               any token found by |get_token|. Therefore an undelimited parameter---i.e.,
-               a |match| that is immediately followed by |match| or |end_match|---will
-               always fail the test `|cur_tok=info(r)|' in the following algorithm. */
-          CONTINUE:
-            get_token();        /* set |cur_tok| to the next token of input */
-            if (cur_tok == token_info(r)) {
-                /* Advance |r|; |goto found| if the parameter delimiter has been
-                   fully matched, otherwise |goto continue| */
-                /* A slightly subtle point arises here: When the parameter delimiter ends
-                   with `\.{\#\{}', the token list will have a left brace both before and
-                   after the |end_match|\kern-.4pt. Only one of these should affect the
-                   |align_state|, but both will be scanned, so we must make a correction.
-                 */
-                r = token_link(r);
-                if ((token_info(r) >= match_token)
-                    && (token_info(r) <= end_match_token)) {
-                    if (cur_tok < left_brace_limit)
-                        decr(align_state);
-                    goto FOUND;
-                } else {
-                    goto CONTINUE;
-                }
-
-            }
-            /* Contribute the recently matched tokens to the current parameter, and
-               |goto continue| if a partial match is still in effect; but abort if |s=null| */
-
-            /* When the following code becomes active, we have matched tokens from |s| to
-               the predecessor of |r|, and we have found that |cur_tok<>info(r)|. An
-               interesting situation now presents itself: If the parameter is to be
-               delimited by a string such as `\.{ab}', and if we have scanned `\.{aa}',
-               we want to contribute one `\.a' to the current parameter and resume
-               looking for a `\.b'. The program must account for such partial matches and
-               for others that can be quite complex.  But most of the time we have |s=r|
-               and nothing needs to be done.
-
-               Incidentally, it is possible for \.{\\par} tokens to sneak in to certain
-               parameters of non-\.{\\long} macros. For example, consider a case like
-               `\.{\\def\\a\#1\\par!\{...\}}' where the first \.{\\par} is not followed
-               by an exclamation point. In such situations it does not seem appropriate
-               to prohibit the \.{\\par}, so \TeX\ keeps quiet about this bending of
-               the rules. */
-
-            if (s != r) {
-                if (s == null) {
-                    /* Report an improper use of the macro and abort */
-                    print_err("Use of ");
-                    sprint_cs(warning_index);
-                    tprint(" doesn't match its definition");
-                    help4
-                        ("If you say, e.g., `\\def\\a1{...}', then you must always",
-                         "put `1' after `\\a', since control sequence names are",
-                         "made up of letters only. The macro here has not been",
-                         "followed by the required stuff, so I'm ignoring it.");
-                    error();
-                    goto EXIT;
-
-                } else {
-                    t = s;
-                    do {
-                        store_new_token(token_info(t));
-                        incr(m);
-                        u = token_link(t);
-                        v = s;
-                        while (1) {
-                            if (u == r) {
-                                if (cur_tok != token_info(v)) {
-                                    goto DONE;
-                                } else {
-                                    r = token_link(v);
-                                    goto CONTINUE;
-                                }
-                            }
-                            if (token_info(u) != token_info(v))
-                                goto DONE;
-                            u = token_link(u);
-                            v = token_link(v);
-                        }
-                      DONE:
-                        t = token_link(t);
-                    } while (t != r);
-                    r = s;      /* at this point, no tokens are recently matched */
-                }
-            }
-
-            if (cur_tok == par_token)
-                if (long_state != long_call_cmd)
-                    if (!suppress_long_error_par) {
-                        goto RUNAWAY;
-                    }
-            if (cur_tok < right_brace_limit) {
-                if (cur_tok < left_brace_limit) {
-                    /* Contribute an entire group to the current parameter */
-                    unbalance = 1;
-                    while (1) {
-                        fast_store_new_token(cur_tok);
-                        get_token();
-                        if (cur_tok == par_token) {
-                            if (long_state != long_call_cmd) {
-                                if (!suppress_long_error_par) {
-                                    goto RUNAWAY;
-
-                                }
-                            }
-                        }
-                        if (cur_tok < right_brace_limit) {
-                            if (cur_tok < left_brace_limit) {
-                                incr(unbalance);
-                            } else {
-                                decr(unbalance);
-                                if (unbalance == 0)
-                                    break;
-                            }
-                        }
-                    }
-                    rbrace_ptr = p;
-                    store_new_token(cur_tok);
-
-                } else {
-                    /* Report an extra right brace and |goto continue| */
-                    back_input();
-                    print_err("Argument of ");
-                    sprint_cs(warning_index);
-                    tprint(" has an extra }");
-                    help6
-                        ("I've run across a `}' that doesn't seem to match anything.",
-                         "For example, `\\def\\a#1{...}' and `\\a}' would produce",
-                         "this error. If you simply proceed now, the `\\par' that",
-                         "I've just inserted will cause me to report a runaway",
-                         "argument that might be the root of the problem. But if",
-                         "your `}' was spurious, just type `2' and it will go away.");
-                    incr(align_state);
-                    long_state = call_cmd;
-                    cur_tok = par_token;
-                    ins_error();
-                    goto CONTINUE;
-                    /* a white lie; the \.{\\par} won't always trigger a runaway */
-                }
-            } else {
-                /* Store the current token, but |goto continue| if it is
-                   a blank space that would become an undelimited parameter */
-                if (cur_tok == space_token)
-                    if (token_info(r) <= end_match_token)
-                        if (token_info(r) >= match_token)
-                            goto CONTINUE;
-                store_new_token(cur_tok);
-
-            }
-            incr(m);
-            if (token_info(r) > end_match_token)
-                goto CONTINUE;
-            if (token_info(r) < match_token)
-                goto CONTINUE;
-          FOUND:
-            if (s != null) {
-                /* Tidy up the parameter just scanned, and tuck it away */
-                /* If the parameter consists of a single group enclosed in braces, we must
-                   strip off the enclosing braces. That's why |rbrace_ptr| was introduced. */
-                if ((m == 1) && (token_info(p) < right_brace_limit)
-                    && (p != temp_token_head)) {
-                    set_token_link(rbrace_ptr, null);
-                    free_avail(p);
-                    p = token_link(temp_token_head);
-                    pstack[n] = token_link(p);
-                    free_avail(p);
-                } else {
-                    pstack[n] = token_link(temp_token_head);
-                }
-                incr(n);
-                if (tracing_macros_par > 0) {
-                    begin_diagnostic();
-                    print_nl(match_chr);
-                    print_int(n);
-                    tprint("<-");
-                    show_token_list(pstack[n - 1], null, 1000);
-                    end_diagnostic(false);
-                }
-
-            }
-
-            /* now |info(r)| is a token whose command code is either |match| or |end_match| */
-        } while (token_info(r) != end_match_token);
-
-    }
-    /* Feed the macro body and its parameters to the scanner */
-    /* Before we put a new token list on the input stack, it is wise to clean off
-       all token lists that have recently been depleted. Then a user macro that ends
-       with a call to itself will not require unbounded stack space. */
-    while ((istate == token_list) && (iloc == null) && (token_type != v_template)) {
-        /* conserve stack space */
-        end_token_list();
-    }
-    begin_token_list(ref_count, macro);
-    iname = warning_index;
-    iloc = token_link(r);
-    if (n > 0) {
-        if (param_ptr + n > max_param_stack) {
-            max_param_stack = param_ptr + n;
-            if (max_param_stack > param_size)
-                overflow("parameter stack size", (unsigned) param_size);
-        }
-        for (m = 0; m <= n - 1; m++)
-            param_stack[param_ptr + m] = pstack[m];
-        param_ptr = param_ptr + n;
-    }
-    goto EXIT;
-  RUNAWAY:
-    /* Report a runaway argument and abort */
-    /* If |long_state=outer_call|, a runaway argument has already been reported. */
-    if (long_state == call_cmd) {
-        runaway();
-        print_err("Paragraph ended before ");
-        sprint_cs(warning_index);
-        tprint(" was complete");
-        help3("I suspect you've forgotten a `}', causing me to apply this",
-              "control sequence to too much text. How can we recover?",
-              "My plan is to forget the whole thing and hope for the best.");
-        back_error();
-    }
-    pstack[n] = token_link(temp_token_head);
-    align_state = align_state - unbalance;
-    for (m = 0; m <= n; m++)
-        flush_list(pstack[m]);
-
-  EXIT:
-    scanner_status = save_scanner_status;
-    warning_index = save_warning_index;
-}
diff --git a/texk/web2c/luatexdir/tex/extensions.c b/texk/web2c/luatexdir/tex/extensions.c
new file mode 100644
index 000000000..d5914db8a
--- /dev/null
+++ b/texk/web2c/luatexdir/tex/extensions.c
@@ -0,0 +1,1329 @@
+/*
+
+Copyright 2009-2010 Taco Hoekwater <taco@luatex.org>
+
+This file is part of LuaTeX.
+
+LuaTeX is free software; you can redistribute it and/or modify it under the terms
+of the GNU General Public License as published by the Free Software Foundation;
+either version 2 of the License, or (at your option) any later version.
+
+LuaTeX is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU General Public License along with
+LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#include "ptexlib.h"
+
+#define mode     mode_par
+#define tail     tail_par
+#define head     head_par
+#define dir_save dirs_par
+
+/*tex
+
+    The program above includes a bunch of ``hooks'' that allow further
+    capabilities to be added without upsetting \TeX's basic structure. Most of
+    these hooks are concerned with ``whatsit'' nodes, which are intended to be
+    used for special purposes; whenever a new extension to \TeX\ involves a new
+    kind of whatsit node, a corresponding change needs to be made to the routines
+    below that deal with such nodes, but it will usually be unnecessary to make
+    many changes to the other parts of this program.
+
+    In order to demonstrate how extensions can be made, we shall treat
+    `\.{\\write}', `\.{\\openout}', `\.{\\closeout}', `\.{\\immediate}', and
+    `\.{\\special}' as if they were extensions. These commands are actually
+    primitives of \TeX, and they should appear in all implementations of the
+    system; but let's try to imagine that they aren't. Then the program below
+    illustrates how a person could add them.
+
+    Sometimes, of course, an extension will require changes to \TeX\ itself; no
+    system of hooks could be complete enough for all conceivable extensions. The
+    features associated with `\.{\\write}' are almost all confined to the
+    following paragraphs, but there are small parts of the |print_ln| and
+    |print_char| procedures that were introduced specifically to \.{\\write}
+    characters. Furthermore one of the token lists recognized by the scanner is a
+    |write_text|; and there are a few other miscellaneous places where we have
+    already provided for some aspect of \.{\\write}. The goal of a \TeX\ extender
+    should be to minimize alterations to the standard parts of the program, and
+    to avoid them completely if possible. He or she should also be quite sure
+    that there's no easy way to accomplish the desired goals with the standard
+    features that \TeX\ already has. ``Think thrice before extending,'' because
+    that may save a lot of work, and it will also keep incompatible extensions of
+    \TeX\ from proliferating.
+
+    First let's consider the format of whatsit nodes that are used to represent
+    the data associated with \.{\\write} and its relatives. Recall that a whatsit
+    has |type=whatsit_node|, and the |subtype| is supposed to distinguish
+    different kinds of whatsits. Each node occupies two or more words; the exact
+    number is immaterial, as long as it is readily determined from the |subtype|
+    or other data.
+
+    We shall introduce five |subtype| values here, corresponding to the control
+    sequences \.{\\openout}, \.{\\write}, \.{\\closeout}, and \.{\\special}. The
+    second word of I/O whatsits has a |write_stream| field that identifies the
+    write-stream number (0 to 15, or 16 for out-of-range and positive, or 17 for
+    out-of-range and negative). In the case of \.{\\write} and \.{\\special},
+    there is also a field that points to the reference count of a token list that
+    should be sent. In the case of \.{\\openout}, we need three words and three
+    auxiliary subfields to hold the string numbers for name, area, and extension.
+
+    Extensions might introduce new command codes; but it's best to use
+    |extension| with a modifier, whenever possible, so that |main_control| stays
+    the same.
+
+    The sixteen possible \.{\\write} streams are represented by the |write_file|
+    array. The |j|th file is open if and only if |write_open[j]=true|. The last
+    two streams are special; |write_open[16]| represents a stream number greater
+    than 15, while |write_open[17]| represents a negative stream number, and both
+    of these variables are always |false|.
+
+*/
+
+alpha_file write_file[last_file_selector+1];
+halfword write_file_mode[last_file_selector+1];
+halfword write_file_translation[last_file_selector+1];
+boolean write_open[last_file_selector+1];
+
+scaled neg_wd;
+scaled pos_wd;
+scaled neg_ht;
+
+/*tex
+
+    The variable |write_loc| just introduced is used to provide an appropriate
+    error message in case of ``runaway'' write texts.
+
+*/
+
+/*tex The |eqtb| address of \.{\\write}: */
+
+halfword write_loc;
+
+/*tex
+
+    When an |extension| command occurs in |main_control|, in any mode, the
+    |do_extension| routine is called.
+
+*/
+
+int last_saved_image_index ;
+int last_saved_image_pages ;
+int last_saved_box_index ;
+scaledpos last_position = { 0, 0 };
+
+static void do_extension_dvi(int immediate)
+{
+    if (scan_keyword("literal")) {
+        new_whatsit(special_node);
+        write_stream(tail) = null;
+        scan_toks(false, true);
+        write_tokens(tail) = def_ref;
+    } else {
+        tex_error("unexpected use of \\dviextension",null);
+    }
+}
+
+static void do_extension_pdf(int immediate)
+{
+    int i;
+    if (scan_keyword("literal")) {
+        new_whatsit(pdf_literal_node);
+        if (scan_keyword("direct"))
+            set_pdf_literal_mode(tail, direct_always);
+        else if (scan_keyword("page"))
+            set_pdf_literal_mode(tail, direct_page);
+        else if (scan_keyword("text"))
+            set_pdf_literal_mode(tail, direct_text);
+        else if (scan_keyword("raw"))
+            set_pdf_literal_mode(tail, direct_raw);
+        else if (scan_keyword("origin"))
+            set_pdf_literal_mode(tail, set_origin);
+        else
+            set_pdf_literal_mode(tail, set_origin);
+        scan_toks(false, true);
+        set_pdf_literal_type(tail, normal);
+        set_pdf_literal_data(tail, def_ref);
+    } else if (scan_keyword("dest")) {
+        scan_pdfdest(static_pdf);
+    } else if (scan_keyword("annot")) {
+        scan_annot(static_pdf);
+    } else if (scan_keyword("save")) {
+        new_whatsit(pdf_save_node);
+    } else if (scan_keyword("restore")) {
+        new_whatsit(pdf_restore_node);
+    } else if (scan_keyword("setmatrix")) {
+        new_whatsit(pdf_setmatrix_node);
+        scan_toks(false, true);
+        set_pdf_setmatrix_data(tail, def_ref);
+    } else if (scan_keyword("obj")) {
+        scan_obj(static_pdf);
+        if (immediate) {
+            if (obj_data_ptr(static_pdf, pdf_last_obj) == 0) {
+                /*tex This object has not been initialized yet. */
+                normal_error("pdf backend","\\pdfextension obj 'reserveobjnum' cannot be used with \\immediate");
+            }
+            pdf_write_obj(static_pdf, pdf_last_obj);
+        }
+    } else if (scan_keyword("refobj")) {
+        scan_refobj(static_pdf);
+    } else if (scan_keyword("colorstack")) {
+        scan_int();
+        if (cur_val >= colorstackused()) {
+            print_err("Unknown color stack number ");
+            print_int(cur_val);
+            help3(
+                "Allocate and initialize a color stack with \\pdfextension colorstackinit.",
+                "I'll use default color stack 0 here.",
+                "Proceed, with fingers crossed."
+            );
+            error();
+            cur_val = 0;
+        }
+        if (cur_val < 0) {
+            print_err("Invalid negative color stack number");
+            help2(
+                "I'll use default color stack 0 here.",
+                "Proceed, with fingers crossed."
+            );
+            error();
+            cur_val = 0;
+        }
+        if (scan_keyword("set"))
+            i = colorstack_set;
+        else if (scan_keyword("push"))
+            i = colorstack_push;
+        else if (scan_keyword("pop"))
+            i = colorstack_pop;
+        else if (scan_keyword("current"))
+            i = colorstack_current;
+        else
+            i = -1;
+        if (i >= 0) {
+            new_whatsit(pdf_colorstack_node);
+            set_pdf_colorstack_stack(tail, cur_val);
+            set_pdf_colorstack_cmd(tail, i);
+            set_pdf_colorstack_data(tail, null);
+            if (i <= colorstack_data) {
+                scan_toks(false, true);
+                set_pdf_colorstack_data(tail, def_ref);
+            }
+        } else {
+            print_err("Color stack action is missing");
+            help3(
+                "The expected actions for \\pdfextension colorstack:",
+                "    set, push, pop, current",
+                "I'll ignore the color stack command."
+            );
+            error();
+        }
+    } else if (scan_keyword("startlink")) {
+        scan_startlink(static_pdf);
+    } else if (scan_keyword("endlink")) {
+        if (abs(mode) == vmode)
+            normal_error("pdf backend", "\\pdfextension endlink cannot be used in vertical mode");
+        new_whatsit(pdf_end_link_node);
+    } else if (scan_keyword("startthread")) {
+        new_annot_whatsit(pdf_start_thread_node);
+        scan_thread_id();
+    } else if (scan_keyword("endthread")) {
+        new_whatsit(pdf_end_thread_node);
+    } else if (scan_keyword("thread")) {
+        new_annot_whatsit(pdf_thread_node);
+        scan_thread_id();
+    } else if (scan_keyword("outline")) {
+        scan_pdfoutline(static_pdf);
+    } else if (scan_keyword("glyphtounicode")) {
+        glyph_to_unicode();
+    } else if (scan_keyword("catalog")) {
+        scan_pdfcatalog(static_pdf);
+    } else if (scan_keyword("fontattr")) {
+        /*tex
+
+            The font attributes are simply initialized to zero now, this is
+            easier to deal with from C than an empty \TeX{} string, and surely
+            nobody will want to set font attr to a string containing a single
+            zero, as that would be nonsensical in the PDF output.
+
+        */
+        scan_font_ident();
+        i = cur_val;
+        if (i == null_font)
+            normal_error("pdf backend", "invalid font identifier");
+        scan_toks(false, true);
+        set_pdf_font_attr(i, tokens_to_string(def_ref));
+        if (str_length(pdf_font_attr(i)) == 0) {
+            /*tex From |tokens_to_string|. */
+            flush_str((str_ptr - 1));
+            set_pdf_font_attr(i, 0);
+        }
+    } else if (scan_keyword("mapfile")) {
+        scan_toks(false, true);
+        pdfmapfile(def_ref);
+        delete_token_ref(def_ref);
+    } else if (scan_keyword("mapline")) {
+        scan_toks(false, true);
+        pdfmapline(def_ref);
+        delete_token_ref(def_ref);
+    } else if (scan_keyword("includechars")) {
+        pdf_include_chars(static_pdf);
+    } else if (scan_keyword("info")) {
+        scan_toks(false, true);
+        pdf_info_toks = concat_tokens(pdf_info_toks, def_ref);
+    } else if (scan_keyword("names")) {
+        scan_toks(false, true);
+        pdf_names_toks = concat_tokens(pdf_names_toks, def_ref);
+    } else if (scan_keyword("trailer")) {
+        scan_toks(false, true);
+        pdf_trailer_toks = concat_tokens(pdf_trailer_toks, def_ref);
+    } else {
+        tex_error("unexpected use of \\pdfextension",null);
+    }
+}
+
+static void do_resource_dvi(int immediate, int code)
+{
+    /*tex Nothing is done here. */
+}
+
+static void do_resource_pdf(int immediate, int code)
+{
+    switch (code) {
+        case use_box_resource_code:
+            scan_pdfrefxform(static_pdf);
+            break;
+        case use_image_resource_code:
+            scan_pdfrefximage(static_pdf);
+            break;
+        case save_box_resource_code:
+            scan_pdfxform(static_pdf);
+            if (immediate) {
+                pdf_cur_form = last_saved_box_index;
+                ship_out(static_pdf, obj_xform_box(static_pdf, last_saved_box_index), SHIPPING_FORM);
+            }
+            break;
+        case save_image_resource_code:
+            scan_pdfximage(static_pdf);
+            if (immediate) {
+                pdf_write_image(static_pdf, last_saved_image_index);
+            }
+            break;
+    }
+}
+
+/*tex
+
+    Ad immediate:
+
+    To write a token list, we must run it through \TeX's scanner, expanding
+    macros and \.{\\the} and \.{\\number}, etc. This might cause runaways, if a
+    delimited macro parameter isn't matched, and runaways would be extremely
+    confusing since we are calling on \TeX's scanner in the middle of a
+    \.{\\shipout} command. Therefore we will put a dummy control sequence as a
+    ``stopper,'' right after the token list. This control sequence is
+    artificially defined to be \.{\\outer}.
+
+    The presence of `\.{\\immediate}' causes the |do_extension| procedure to
+    descend to one level of recursion. Nothing happens unless \.{\\immediate} is
+    followed by `\.{\\openout}', `\.{\\write}', or `\.{\\closeout}'.
+
+*/
+
+/*tex
+
+    The extensions are backend related. The next subroutine uses |cur_chr| to
+    decide what sort of whatsit is involved, and also inserts a |write_stream|
+    number.
+
+*/
+
+static void new_write_whatsit(int w, int check)
+{
+    new_whatsit(cur_chr);
+    if (check) {
+        /*tex So we check with open and close. */
+        scan_limited_int(last_file_selector,NULL);
+    } else {
+        /*tex But we're tolerant with the rest. */
+        scan_int();
+        if (cur_val < 0)
+            cur_val = term_only;
+        else if (cur_val > last_file_selector) {
+            cur_val = term_and_log;
+        }
+    }
+    write_stream(tail) = cur_val;
+}
+
+void do_extension(int immediate)
+{
+    /*tex An all-purpose pointer. */
+    halfword p;
+    if (cur_cmd == extension_cmd) {
+        /*tex These have their own range starting at 0. */
+        switch (cur_chr) {
+            case open_code:
+                p = tail;
+                new_write_whatsit(open_node_size,1);
+                scan_optional_equals();
+                scan_file_name();
+                open_name(tail) = cur_name;
+                open_area(tail) = cur_area;
+                open_ext(tail) = cur_ext;
+                if (immediate) {
+                    wrapup_leader(tail);
+                    flush_node_list(tail);
+                    tail = p;
+                    vlink(p) = null;
+                }
+                break;
+            case write_code:
+                /*tex
+
+                    When `\.{\\write 12\{...\}}' appears, we scan the token list
+                    `\.{\{...\}}' without expanding its macros; the macros will
+                    be expanded later when this token list is rescanned.
+
+                */
+                p = tail;
+                new_write_whatsit(write_node_size,0);
+                cur_cs = write_stream(tail);
+                scan_toks(false, false);
+                write_tokens(tail) = def_ref;
+                if (immediate) {
+                    wrapup_leader(tail);
+                    flush_node_list(tail);
+                    tail = p;
+                    vlink(p) = null;
+                }
+                break;
+            case close_code:
+                p = tail;
+                new_write_whatsit(close_node_size,1);
+                write_tokens(tail) = null;
+                if (immediate) {
+                    wrapup_leader(tail);
+                    flush_node_list(tail);
+                    tail = p;
+                    vlink(p) = null;
+                }
+                break;
+            case special_code:
+                /*tex
+
+                    When `\.{\\special\{...\}}' appears, we expand the macros in
+                    the token list as in \.{\\xdef} and \.{\\mark}.
+
+                */
+                new_whatsit(special_node);
+                write_stream(tail) = null;
+                p = scan_toks(false, true);
+                write_tokens(tail) = def_ref;
+                break;
+            case immediate_code:
+                get_x_token();
+                do_extension(1);
+                break;
+            case end_local_code:
+                if (tracing_nesting_par > 2) {
+                    local_control_message("leaving token scanner");
+                }
+                end_local_control();
+                break;
+            case use_box_resource_code:
+            case use_image_resource_code:
+            case save_box_resource_code:
+            case save_image_resource_code:
+                switch (get_o_mode()) {
+                    case OMODE_DVI:
+                        do_resource_dvi(immediate,cur_chr);
+                        break;
+                    case OMODE_PDF:
+                        do_resource_pdf(immediate,cur_chr);
+                        break;
+                    default:
+                        break;
+                }
+                break;
+            /*tex Backend extensions have their own range starting at 32. */
+            case dvi_extension_code:
+                if (get_o_mode() == OMODE_DVI)
+                    do_extension_dvi(immediate);
+                break;
+            case pdf_extension_code:
+                if (get_o_mode() == OMODE_PDF)
+                    do_extension_pdf(immediate);
+                break;
+            /*tex Done. */
+            default:
+                if (immediate) {
+                    back_input();
+                } else {
+                    confusion("invalid extension");
+                }
+                break;
+        }
+    } else {
+        /*tex No extension command, quite certainly following |\immediate|. */
+        back_input();
+    }
+}
+
+/*tex
+
+    Here is a subroutine that creates a whatsit node having a given |subtype| and
+    a given number of words. It initializes only the first word of the whatsit,
+    and appends it to the current list.
+
+*/
+
+void new_whatsit(int s)
+{
+    halfword p = new_node(whatsit_node, s);
+    couple_nodes(tail, p);
+    tail = p;
+}
+
+/*tex
+
+    The final line of this routine is slightly subtle; at least, the author
+    didn't think about it until getting burnt! There is a used-up token list on
+    the stack, namely the one that contained |end_write_token|. (We insert this
+    artificial `\.{\\endwrite}' to prevent runaways, as explained above.) If it
+    were not removed, and if there were numerous writes on a single page, the
+    stack would overflow.
+
+*/
+
+void expand_macros_in_tokenlist(halfword p)
+{
+    int old_mode;
+    pointer q = get_avail();
+    pointer r = get_avail();
+    token_info(q) = right_brace_token + '}';
+    token_link(q) = r;
+    token_info(r) = end_write_token;
+    begin_token_list(q, inserted);
+    begin_token_list(write_tokens(p), write_text);
+    q = get_avail();
+    token_info(q) = left_brace_token + '{';
+    begin_token_list(q, inserted);
+    /*tex
+
+        Now we're ready to scan `\.\{$\langle\,$token list$\,\rangle$\.{\}
+        \\endwrite}'.
+
+    */
+    old_mode = mode;
+    mode = 0;
+    /*tex
+
+        Disable \.{\\prevdepth}, \.{\\spacefactor}, \.{\\lastskip},
+        \.{\\prevgraf}.
+
+    */
+    cur_cs = write_loc;
+    /*tex Expand macros, etc. */
+    q = scan_toks(false, true);
+    get_token();
+    if (cur_tok != end_write_token) {
+        /*tex Recover from an unbalanced write command */
+        const char *hlp[] = {
+            "On this page there's a \\write with fewer real {'s than }'s.",
+            "I can't handle that very well; good luck.",
+            NULL
+        };
+        tex_error("Unbalanced write command", hlp);
+        do {
+            get_token();
+        } while (cur_tok != end_write_token);
+    }
+    mode = old_mode;
+    /*tex Conserve stack space. */
+    end_token_list();
+}
+
+void write_out(halfword p)
+{
+    /*tex holds print |selector| */
+    int old_setting;
+    /*tex write stream number */
+    int j;
+    /*tex line to be written, as a C string */
+    char *s, *ss;
+    int callback_id;
+    int lua_retval;
+    expand_macros_in_tokenlist(p);
+    old_setting = selector;
+    j = write_stream(p);
+    if (file_can_be_written(j)) {
+        selector = j;
+    } else if ((j == term_only) && (selector == term_and_log)) {
+        /*tex write to the terminal if file isn't open */
+        selector = log_only;
+        tprint_nl("");
+    } else {
+        tprint_nl("");
+    }
+    s = tokenlist_to_cstring(def_ref, false, NULL);
+    if (selector < no_print) {
+        /*tex selector is a file */
+        callback_id = callback_defined(process_output_buffer_callback);
+        if (callback_id > 0) {
+            /*tex fix up the output buffer using callbacks */
+            lua_retval = run_callback(callback_id, "S->S", s, &ss);
+            if ((lua_retval == true) && (ss != NULL)) {
+                xfree(s);
+                s = ss;
+            }
+        }
+    }
+    tprint(s);
+    xfree(s);
+    print_ln();
+    flush_list(def_ref);
+    selector = old_setting;
+}
+
+void finalize_write_files(void) {
+    int k;
+    for (k = 0; k <= last_file_selector; k++) {
+        if (write_open[k]) {
+            lua_a_close_out(write_file[k]);
+        }
+    }
+}
+
+void initialize_write_files(void) {
+    int k;
+    for (k = 0; k <= last_file_selector; k++) {
+        write_open[k] = false;
+    }
+}
+
+void close_write_file(int id) {
+    if (write_open[id]) {
+        lua_a_close_out(write_file[id]);
+        write_open[id] = false;
+    }
+}
+
+boolean open_write_file(int id, char *fn) {
+    if (lua_a_open_out(&(write_file[id]), fn, (id + 1))) {
+        write_open[id] = true;
+        return true;
+    } else {
+        return false;
+    }
+}
+
+/*tex
+
+    To implement primitives as \.{\\pdfextension info}, \.{\\pdfextension
+    catalog} or \.{\\pdfextension names} we need to concatenate tokens lists.
+
+*/
+
+halfword concat_tokens(halfword q, halfword r)
+{
+    /*tex concat |q| and |r| and returns the result tokens list */
+    halfword p;
+    if (q == null)
+        return r;
+    p = q;
+    while (token_link(p) != null)
+        p = token_link(p);
+    set_token_link(p, token_link(r));
+    free_avail(r);
+    return q;
+}
+
+/*tex
+
+    The \eTeX\ features available in extended mode are grouped into two
+    categories: (1)~Some of them are permanently enabled and have no semantic
+    effect as long as none of the additional primitives are executed. (2)~The
+    remaining \eTeX\ features are optional and can be individually enabled and
+    disabled. For each optional feature there is an \eTeX\ state variable named
+    \.{\\...state}; the feature is enabled, resp.\ disabled by assigning a
+    positive, resp.\ non-positive value to that integer.
+
+    In order to handle \.{\\everyeof} we need an array |eof_seen| of boolean
+    variables.
+
+*/
+
+boolean *eof_seen;
+
+/*tex
+
+    The |print_group| procedure prints the current level of grouping and the name
+    corresponding to |cur_group|.
+
+*/
+
+void print_group(boolean e)
+{
+    switch (cur_group) {
+        case bottom_level:
+            tprint("bottom level");
+            return;
+            break;
+        case simple_group:
+        case semi_simple_group:
+            if (cur_group == semi_simple_group)
+                tprint("semi ");
+            tprint("simple");
+            break;;
+        case hbox_group:
+        case adjusted_hbox_group:
+            if (cur_group == adjusted_hbox_group)
+                tprint("adjusted ");
+            tprint("hbox");
+            break;
+        case vbox_group:
+            tprint("vbox");
+            break;
+        case vtop_group:
+            tprint("vtop");
+            break;
+        case align_group:
+        case no_align_group:
+            if (cur_group == no_align_group)
+                tprint("no ");
+            tprint("align");
+            break;
+        case output_group:
+            tprint("output");
+            break;
+        case disc_group:
+            tprint("disc");
+            break;
+        case insert_group:
+            tprint("insert");
+            break;
+        case vcenter_group:
+            tprint("vcenter");
+            break;
+        case math_group:
+        case math_choice_group:
+        case math_shift_group:
+        case math_left_group:
+            tprint("math");
+            if (cur_group == math_choice_group)
+                tprint(" choice");
+            else if (cur_group == math_shift_group)
+                tprint(" shift");
+            else if (cur_group == math_left_group)
+                tprint(" left");
+            break;
+    }
+    tprint(" group (level ");
+    print_int(cur_level);
+    print_char(')');
+    if (saved_value(-1) != 0) {
+        /*tex |saved_line| */
+        if (e)
+            tprint(" entered at line ");
+        else
+            tprint(" at line ");
+        print_int(saved_value(-1));
+    }
+}
+
+/*tex
+
+    The |group_trace| procedure is called when a new level of grouping begins
+    (|e=false|) or ends (|e=true|) with |saved_value(-1)| containing the line
+    number.
+
+*/
+
+void group_trace(boolean e)
+{
+    begin_diagnostic();
+    print_char('{');
+    if (e)
+        tprint("leaving ");
+    else
+        tprint("entering ");
+    print_group(e);
+    print_char('}');
+    end_diagnostic(false);
+}
+
+/*tex
+
+    A group entered (or a conditional started) in one file may end in a different
+    file. Such slight anomalies, although perfectly legitimate, may cause errors
+    that are difficult to locate. In order to be able to give a warning message
+    when such anomalies occur, \eTeX\ uses the |grp_stack| and |if_stack| arrays
+    to record the initial |cur_boundary| and |cond_ptr| values for each input
+    file.
+
+*/
+
+/*tex initial |cur_boundary| */
+
+save_pointer *grp_stack;
+
+/*tex initial |cond_ptr| */
+
+halfword *if_stack;
+
+/*tex
+
+    When a group ends that was apparently entered in a different input file, the
+    |group_warning| procedure is invoked in order to update the |grp_stack|. If
+    moreover \.{\\tracingnesting} is positive we want to give a warning message.
+    The situation is, however, somewhat complicated by two facts: (1)~There may
+    be |grp_stack| elements without a corresponding \.{\\input} file or
+    \.{\\scantokens} pseudo file (e.g., error insertions from the terminal); and
+    (2)~the relevant information is recorded in the |name_field| of the
+    |input_stack| only loosely synchronized with the |in_open| variable indexing
+    |grp_stack|.
+
+*/
+
+void group_warning(void)
+{
+    /*tex do we need a warning? */
+    boolean w = false;
+    /*tex index into |grp_stack| */
+    int i = in_open;
+    base_ptr = input_ptr;
+    /*tex store current state */
+    input_stack[base_ptr] = cur_input;
+    while ((grp_stack[i] == cur_boundary) && (i > 0)) {
+        /*tex
+
+            Set variable |w| to indicate if this case should be reported. This
+            code scans the input stack in order to determine the type of the
+            current input file.
+
+        */
+        if (tracing_nesting_par > 0) {
+            while ((input_stack[base_ptr].state_field == token_list) || (input_stack[base_ptr].index_field > i))
+                decr(base_ptr);
+            if (input_stack[base_ptr].name_field > 17)
+                w = true;
+        }
+        grp_stack[i] = save_value(save_ptr);
+        decr(i);
+    }
+    if (w) {
+        tprint_nl("Warning: end of ");
+        print_group(true);
+        tprint(" of a different file");
+        print_ln();
+        if (tracing_nesting_par > 1)
+            show_context();
+        if (history == spotless)
+            history = warning_issued;
+    }
+}
+
+/*tex
+
+    When a conditional ends that was apparently started in a different input
+    file, the |if_warning| procedure is invoked in order to update the
+    |if_stack|. If moreover \.{\\tracingnesting} is positive we want to give a
+    warning message (with the same complications as above).
+
+*/
+
+void if_warning(void)
+{
+    /*tex Do we need a warning? */
+    boolean w = false;
+    int i = in_open;
+    base_ptr = input_ptr;
+    /*tex Store current state. */
+    input_stack[base_ptr] = cur_input;
+    while (if_stack[i] == cond_ptr) {
+        /*tex Set variable |w| to. */
+        if (tracing_nesting_par > 0) {
+            while ((input_stack[base_ptr].state_field == token_list) || (input_stack[base_ptr].index_field > i))
+                decr(base_ptr);
+            if (input_stack[base_ptr].name_field > 17)
+                w = true;
+        }
+        if_stack[i] = vlink(cond_ptr);
+        decr(i);
+    }
+    if (w) {
+        tprint_nl("Warning: end of ");
+        print_cmd_chr(if_test_cmd, cur_if);
+        print_if_line(if_line);
+        tprint(" of a different file");
+        print_ln();
+        if (tracing_nesting_par > 1)
+            show_context();
+        if (history == spotless)
+            history = warning_issued;
+    }
+}
+
+/*tex
+
+    Conversely, the |file_warning| procedure is invoked when a file ends and some
+    groups entered or conditionals started while reading from that file are still
+    incomplete.
+
+*/
+
+void file_warning(void)
+{
+    /*tex saved value of |save_ptr| or |cond_ptr| */
+    halfword p = save_ptr;
+    /*tex saved value of |cur_level| or |if_limit| */
+    int l = cur_level;
+    /*tex saved value of |cur_group| or |cur_if| */
+    int c = cur_group;
+    /*tex saved value of |if_line| */
+    int i;
+    save_ptr = cur_boundary;
+    while (grp_stack[in_open] != save_ptr) {
+        decr(cur_level);
+        tprint_nl("Warning: end of file when ");
+        print_group(true);
+        tprint(" is incomplete");
+        cur_group = save_level(save_ptr);
+        save_ptr = save_value(save_ptr);
+    }
+    save_ptr = p;
+    cur_level = (quarterword) l;
+    /*tex Restore old values. */
+    cur_group = (group_code) c;
+    p = cond_ptr;
+    l = if_limit;
+    c = cur_if;
+    i = if_line;
+    while (if_stack[in_open] != cond_ptr) {
+        tprint_nl("Warning: end of file when ");
+        print_cmd_chr(if_test_cmd, cur_if);
+        if (if_limit == fi_code)
+            tprint_esc("else");
+        print_if_line(if_line);
+        tprint(" is incomplete");
+        if_line = if_line_field(cond_ptr);
+        cur_if = if_limit_subtype(cond_ptr);
+        if_limit = if_limit_type(cond_ptr);
+        cond_ptr = vlink(cond_ptr);
+    }
+    /*tex restore old values */
+    cond_ptr = p;
+    if_limit = l;
+    cur_if = c;
+    if_line = i;
+    print_ln();
+    if (tracing_nesting_par > 1)
+        show_context();
+    if (history == spotless)
+        history = warning_issued;
+}
+
+/*tex The |par_fill_skip| glue node of the new paragraph. */
+
+halfword last_line_fill;
+
+/*tex
+
+    The lua interface needs some extra functions. The functions themselves are
+    quite boring, but they are handy because otherwise this internal stuff has to
+    be accessed from C directly, where lots of the defines are not available.
+
+*/
+
+#define get_tex_dimen_register(j) dimen(j)
+#define get_tex_skip_register(j) skip(j)
+#define get_tex_mu_skip_register(j) mu_skip(j)
+#define get_tex_count_register(j) count(j)
+#define get_tex_attribute_register(j) attribute(j)
+#define get_tex_box_register(j) box(j)
+
+/*tex These can now be macros (todo). */
+
+int get_tex_extension_count_register(int i)
+{
+    return (int) int_par(backend_int_base-int_base+i);
+}
+
+void set_tex_extension_count_register(int i, int d)
+{
+    int_par(backend_int_base-int_base+i) = d;
+}
+
+int get_tex_extension_dimen_register(int i)
+{
+    return (int) dimen_par(backend_dimen_base-dimen_base+i);
+}
+
+void set_tex_extension_dimen_register(int i, int d)
+{
+    dimen_par(backend_dimen_base-dimen_base+i) = d;
+}
+
+int get_tex_extension_toks_register(int i)
+{
+    return equiv(backend_toks_base+i);
+}
+
+int set_tex_dimen_register(int j, scaled v)
+{
+    int a;
+    if (global_defs_par > 0)
+        a = 4;
+    else
+        a = 0;
+    word_define(j + scaled_base, v);
+    return 0;
+}
+
+int set_tex_skip_register(int j, halfword v)
+{
+    int a;
+    if (global_defs_par > 0)
+        a = 4;
+    else
+        a = 0;
+    if (type(v) != glue_spec_node)
+        return 1;
+    word_define(j + skip_base, v);
+    return 0;
+}
+
+int set_tex_mu_skip_register(int j, halfword v)
+{
+    int a;
+    if (global_defs_par > 0)
+        a = 4;
+    else
+        a = 0;
+    if (type(v) != glue_spec_node)
+        return 1;
+    word_define(j + mu_skip_base, v);
+    return 0;
+}
+
+int set_tex_count_register(int j, scaled v)
+{
+    int a;
+    if (global_defs_par > 0)
+        a = 4;
+    else
+        a = 0;
+    word_define(j + count_base, v);
+    return 0;
+}
+
+int set_tex_box_register(int j, scaled v)
+{
+    int a;
+    if (global_defs_par > 0)
+        a = 4;
+    else
+        a = 0;
+    define(j + box_base, box_ref_cmd, v);
+    return 0;
+}
+
+int set_tex_attribute_register(int j, scaled v)
+{
+    int a;
+    if (global_defs_par > 0)
+        a = 4;
+    else
+        a = 0;
+    if (j > max_used_attr)
+        max_used_attr = j;
+    attr_list_cache = cache_disabled;
+    word_define(j + attribute_base, v);
+    return 0;
+}
+
+int get_tex_toks_register(int j)
+{
+    str_number s = get_nullstr();
+    if (toks(j) != null) {
+        s = tokens_to_string(toks(j));
+    }
+    return s;
+}
+
+int set_tex_toks_register(int j, lstring s)
+{
+    int a;
+    halfword ref = get_avail();
+    (void) str_toks(s);
+    set_token_ref_count(ref, 0);
+    set_token_link(ref, token_link(temp_token_head));
+    if (global_defs_par > 0)
+        a = 4;
+    else
+        a = 0;
+    define(j + toks_base, call_cmd, ref);
+    return 0;
+}
+
+int scan_tex_toks_register(int j, int c, lstring s)
+{
+    int a;
+    halfword ref = get_avail();
+    (void) str_scan_toks(c,s);
+    set_token_ref_count(ref, 0);
+    set_token_link(ref, token_link(temp_token_head));
+    if (global_defs_par > 0)
+        a = 4;
+    else
+        a = 0;
+    define(j + toks_base, call_cmd, ref);
+    return 0;
+}
+
+scaled get_tex_box_width(int j)
+{
+    halfword q = box(j);
+    if (q != null)
+        return width(q);
+    return 0;
+}
+
+int set_tex_box_width(int j, scaled v)
+{
+    halfword q = box(j);
+    if (q == null)
+        return 1;
+    width(q) = v;
+    return 0;
+}
+
+scaled get_tex_box_height(int j)
+{
+    halfword q = box(j);
+    if (q != null)
+        return height(q);
+    return 0;
+}
+
+int set_tex_box_height(int j, scaled v)
+{
+    halfword q = box(j);
+    if (q == null)
+        return 1;
+    height(q) = v;
+    return 0;
+}
+
+scaled get_tex_box_depth(int j)
+{
+    halfword q = box(j);
+    if (q != null)
+        return depth(q);
+    return 0;
+}
+
+int set_tex_box_depth(int j, scaled v)
+{
+    halfword q = box(j);
+    if (q == null)
+        return 1;
+    depth(q) = v;
+    return 0;
+}
+
+/*tex
+
+    This section is devoted to the {\sl Synchronize \TeX nology} - or simply {\sl
+    Sync\TeX} - used to synchronize between input and output. This section
+    explains how synchronization basics are implemented. Before we enter into
+    more technical details, let us recall in a few words what is synchronization.
+
+    \TeX\ typesetting system clearly separates the input and the output material,
+    and synchronization will provide a new link between both that can help text
+    editors and viewers to work together. More precisely, forwards
+    synchronization is the ability, given a location in the input source file, to
+    find what is the corresponding place in the output. Backwards synchronization
+    just performs the opposite: given a location in the output, retrieve the
+    corresponding material in the input source file.
+
+    For better code management and maintainance, we adopt a naming convention.
+    Throughout this program, code related to the {\sl Synchronize \TeX nology} is
+    tagged with the ``{\sl synctex}'' key word. Any code extract where {\sl
+    Sync\TeX} plays its part, either explicitly or implicitly, (should) contain
+    the string ``{\sl synctex}''. This naming convention also holds for external
+    files. Moreover, all the code related to {\sl Sync\TeX} is gathered in this
+    section, except the definitions.
+
+    Enabling synchronization should be performed from the command line,
+    |synctexoption| is used for that purpose. This global integer variable is
+    declared here but it is not used here. This is just a placeholder where the
+    command line controller will put the {\sl Sync\TeX} related options, and the
+    {\sl Sync\TeX} controller will read them.
+
+*/
+
+int synctexoption;
+
+/*tex
+
+    A convenient primitive is provided: \.{\\synctex=1} in the input source file
+    enables synchronization whereas \.{\\synctex=0} disables it. Its memory
+    address is |synctex_code|. It is initialized by the {\sl Sync\TeX} controller
+    to the command-line option if given. The controller may filter some reserved
+    bits.
+
+    In order to give the {\sl Sync\TeX} controller read and write access to the
+    contents of the \.{\\synctex} primitive, we declare |synctexoffset|, such
+    that |mem[synctexoffset]| and \.{\\synctex} correspond to the same memory
+    storage. |synctexoffset| is initialized to the correct value when quite
+    everything is initialized.
+
+*/
+
+/*tex Holds the true value of |synctex_code|: */
+
+int synctexoffset;
+
+/*tex
+
+    Synchronization is achieved with the help of an auxiliary file named `\.{{\sl
+    jobname}.synctex}' ({\sl jobname} is the contents of the \.{\\jobname}
+    macro), where a {\sl Sync\TeX} controller implemented in the external
+    |synctex.c| file will store geometrical information. This {\sl Sync\TeX}
+    controller will take care of every technical details concerning the {\sl
+    Sync\TeX} file, we will only focus on the messages the controller will
+    receive from the \TeX\ program.
+
+    The most accurate synchronization information should allow to map any
+    character of the input source file to the corresponding location in the
+    output, if relevant. Ideally, the synchronization information of the input
+    material consists of the file name, the line and column numbers of every
+    character. The synchronization information in the output is simply the page
+    number and either point coordinates, or box dimensions and position. The
+    problem is that the mapping between these informations is only known at ship
+    out time, which means that we must keep track of the input synchronization
+    information until the pages ship out.
+
+    As \TeX\ only knows about file names and line numbers, but forgets the column
+    numbers, we only consider a restricted input synchronization information
+    called {\sl Sync\TeX\ information}. It consists of a unique file name
+    identifier, the {\sl Sync\TeX\ file tag}, and the line number.
+
+    Keeping track of such information, should be different whether characters or
+    nodes are involved. Actually, only certain nodes are involved in {\sl
+    Sync\TeX}, we call them {\sl synchronized nodes}. Synchronized nodes store
+    the {\sl Sync\TeX} information in their last two words: the first one
+    contains a {\sl Sync\TeX\ file tag} uniquely identifying the input file, and
+    the second one contains the current line number, as returned by the
+    \.{\\inputlineno} primitive. The |synctex_field_size| macro contains the
+    necessary size to store the {\sl Sync\TeX} information in a node.
+
+    When declaring the size of a new node, it is recommanded to use the following
+    convention: if the node is synchronized, use a definition similar to
+    |my_synchronized_node_size|={\sl xxx}+|synctex_field_size|. Moreover, one
+    should expect that the {\sl Sync\TeX} information is always stored in the
+    last two words of a synchronized node.
+
+    By default, every node with a sufficiently big size is initialized at
+    creation time in the |get_node| routine with the current {\sl Sync\TeX}
+    information, whether or not the node is synchronized. One purpose is to set
+    this information very early in order to minimize code dependencies, including
+    forthcoming extensions. Another purpose is to avoid the assumption that every
+    node type has a dedicated getter, where initialization should take place.
+    Actually, it appears that some nodes are created using directly the
+    |get_node| routine and not the dedicated constructor. And finally,
+    initializing the node at only one place is less error prone.
+
+    Instead of storing the input file name, it is better to store just an
+    identifier. Each time \TeX\ opens a new file, it notifies the {\sl Sync\TeX}
+    controller with a |synctex_start_input| message. This controller will create
+    a new {\sl Sync\TeX} file tag and will update the current input state record
+    accordingly. If the input comes from the terminal or a pseudo file, the
+    |synctex_tag| is set to 0. It results in automatically disabling
+    synchronization for material input from the terminal or pseudo files.
+
+    Synchronized nodes are boxes, math, kern and glue nodes. Other nodes should
+    be synchronized too, in particular math noads. \TeX\ assumes that math, kern
+    and glue nodes have the same size, this is why both are synchronized. {\sl In
+    fine}, only horizontal lists are really used in {\sl Sync\TeX}, but all box
+    nodes are considered the same with respect to synchronization, because a box
+    node type is allowed to change at execution time.
+
+    {\em Nota Bene:} The {\sl Sync\TeX} code is very close to the memory model.
+    It is not connected to any other part of the code, except for memory
+    management. It is possible to neutralize the {\sl Sync\TeX} code rather
+    simply. The first step is to define a null |synctex_field_size|. The second
+    step is to comment out the code in ``Initialize bigger nodes...'' and every
+    ``Copy ... {\sl Sync\TeX} information''. The last step will be to comment out
+    the |synctex_tag_field| related code in the definition of |synctex_tag| and
+    the various ``Prepare ... {\sl Sync\TeX} information''. Then all the
+    remaining code should be just harmless. The resulting program would behave
+    exactly the same as if absolutely no {\sl Sync\TeX} related code was there,
+    including memory management. Of course, all this assumes that {\sl Sync\TeX}
+    is turned off from the command line.
+
+    Here are extra variables for Web2c. (This numbering of the system-dependent
+    section allows easy integration of Web2c and e-\TeX, etc.)
+
+*/
+
+/*tex where the filename to switch to starts */
+
+pool_pointer edit_name_start;
+
+/*tex what line to start editing at */
+
+int edit_name_length, edit_line;
+
+/*tex whether |more_name| returns false for space */
+
+boolean stop_at_space;
+
+/*tex
+
+    The |edit_name_start| will be set to point into |str_pool| somewhere after
+    its beginning if \TeX\ is supposed to switch to an editor on exit.
+
+*/
+
+int shellenabledp;
+int restrictedshell;
+char *output_comment;
+
+/*tex
+
+    Are we printing extra info as we read the format file?
+
+*/
+
+boolean debug_format_file;
+
+void wrapup_leader(halfword p)
+{
+    /*tex Do some work that has been queued up for \.{\\write}. */
+    if (!doing_leaders) {
+        int j = write_stream(p);
+        if (subtype(p) == write_node) {
+            write_out(p);
+        } else if (subtype(p) == close_node) {
+            close_write_file(j);
+        } else if (valid_write_file(j)) {
+            char *fn;
+            close_write_file(j);
+            cur_name = open_name(p);
+            cur_area = open_area(p);
+            cur_ext = open_ext(p);
+            if (cur_ext == get_nullstr())
+                cur_ext = maketexstring(".tex");
+            fn = pack_file_name(cur_name, cur_area, cur_ext);
+            while (! open_write_file(j,fn)) {
+                fn = prompt_file_name("output file name", ".tex");
+            }
+        }
+    }
+}
diff --git a/texk/web2c/luatexdir/tex/extensions.w b/texk/web2c/luatexdir/tex/extensions.w
deleted file mode 100644
index 73dc3ba45..000000000
--- a/texk/web2c/luatexdir/tex/extensions.w
+++ /dev/null
@@ -1,1211 +0,0 @@
-% extensions.w
-%
-% Copyright 2009-2010 Taco Hoekwater <taco@@luatex.org>
-%
-% This file is part of LuaTeX.
-%
-% LuaTeX is free software; you can redistribute it and/or modify it under
-% the terms of the GNU General Public License as published by the Free
-% Software Foundation; either version 2 of the License, or (at your
-% option) any later version.
-%
-% LuaTeX is distributed in the hope that it will be useful, but WITHOUT
-% ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-% FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
-% License for more details.
-%
-% You should have received a copy of the GNU General Public License along
-% with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
-
-\def\eTeX{e-\TeX}
-\def\pdfTeX{pdf\TeX}
-
-@ @c
-#include "ptexlib.h"
-
-@ @c
-#define mode     mode_par
-#define tail     tail_par
-#define head     head_par
-#define dir_save dirs_par
-
-@ The program above includes a bunch of ``hooks'' that allow further
-capabilities to be added without upsetting \TeX's basic structure.
-Most of these hooks are concerned with ``whatsit'' nodes, which are
-intended to be used for special purposes; whenever a new extension to
-\TeX\ involves a new kind of whatsit node, a corresponding change needs
-to be made to the routines below that deal with such nodes,
-but it will usually be unnecessary to make many changes to the
-other parts of this program.
-
-In order to demonstrate how extensions can be made, we shall treat
-`\.{\\write}', `\.{\\openout}', `\.{\\closeout}', `\.{\\immediate}',
-and `\.{\\special}' as if they were extensions.
-These commands are actually primitives of \TeX, and they should
-appear in all implementations of the system; but let's try to imagine
-that they aren't. Then the program below illustrates how a person
-could add them.
-
-Sometimes, of course, an extension will require changes to \TeX\ itself;
-no system of hooks could be complete enough for all conceivable extensions.
-The features associated with `\.{\\write}' are almost all confined to the
-following paragraphs, but there are small parts of the |print_ln| and
-|print_char| procedures that were introduced specifically to \.{\\write}
-characters. Furthermore one of the token lists recognized by the scanner
-is a |write_text|; and there are a few other miscellaneous places where we
-have already provided for some aspect of \.{\\write}.  The goal of a \TeX\
-extender should be to minimize alterations to the standard parts of the
-program, and to avoid them completely if possible. He or she should also
-be quite sure that there's no easy way to accomplish the desired goals
-with the standard features that \TeX\ already has. ``Think thrice before
-extending,'' because that may save a lot of work, and it will also keep
-incompatible extensions of \TeX\ from proliferating.
-@^system dependencies@>
-@^extensions to \TeX@>
-
-First let's consider the format of whatsit nodes that are used to represent
-the data associated with \.{\\write} and its relatives. Recall that a whatsit
-has |type=whatsit_node|, and the |subtype| is supposed to distinguish
-different kinds of whatsits. Each node occupies two or more words; the
-exact number is immaterial, as long as it is readily determined from the
-|subtype| or other data.
-
-We shall introduce five |subtype| values here, corresponding to the
-control sequences \.{\\openout}, \.{\\write}, \.{\\closeout}, and \.{\\special}.
-The second word of I/O whatsits has a |write_stream| field
-that identifies the write-stream number (0 to 15, or 16 for out-of-range and
-positive, or 17 for out-of-range and negative).
-In the case of \.{\\write} and \.{\\special}, there is also a field that
-points to the reference count of a token list that should be sent. In the
-case of \.{\\openout}, we need three words and three auxiliary subfields
-to hold the string numbers for name, area, and extension.
-
-@ Extensions might introduce new command codes; but it's best to use
-|extension| with a modifier, whenever possible, so that |main_control|
-stays the same.
-
-@ The sixteen possible \.{\\write} streams are represented by the |write_file|
-array. The |j|th file is open if and only if |write_open[j]=true|. The last
-two streams are special; |write_open[16]| represents a stream number
-greater than 15, while |write_open[17]| represents a negative stream number,
-and both of these variables are always |false|.
-
-@c
-alpha_file write_file[last_file_selector+1];
-halfword write_file_mode[last_file_selector+1];
-halfword write_file_translation[last_file_selector+1];
-boolean write_open[last_file_selector+1];
-
-scaled neg_wd;
-scaled pos_wd;
-scaled neg_ht;
-
-@ The variable |write_loc| just introduced is used to provide an
-appropriate error message in case of ``runaway'' write texts.
-
-@c
-halfword write_loc;             /* |eqtb| address of \.{\\write} */
-
-/*
-    hh: eventually i'll make \pdfextension a lua token parsed function;
-    a complication is that sometimes token lists are delayed
-*/
-
-@ When an |extension| command occurs in |main_control|, in any mode,
-the |do_extension| routine is called.
-
-@c
-int last_saved_image_index ;
-int last_saved_image_pages ;
-int last_saved_box_index ;
-scaledpos last_position = { 0, 0 };
-
-static void do_extension_dvi(int immediate)
-{
-    if (scan_keyword("literal")) {
-        new_whatsit(special_node);
-        write_stream(tail) = null;
-        scan_toks(false, true);
-        write_tokens(tail) = def_ref;
-    } else {
-        tex_error("unexpected use of \\dviextension",null);
-    }
-}
-
-static void do_extension_pdf(int immediate)
-{
-    int i;
-
-    if (scan_keyword("literal")) {
-        new_whatsit(pdf_literal_node);
-        if (scan_keyword("direct"))
-            set_pdf_literal_mode(tail, direct_always);
-        else if (scan_keyword("page"))
-            set_pdf_literal_mode(tail, direct_page);
-        else if (scan_keyword("text"))
-            set_pdf_literal_mode(tail, direct_text);
-        else if (scan_keyword("raw"))
-            set_pdf_literal_mode(tail, direct_raw);
-        else if (scan_keyword("origin"))
-            set_pdf_literal_mode(tail, set_origin);
-        else
-            set_pdf_literal_mode(tail, set_origin);
-        scan_toks(false, true);
-        set_pdf_literal_type(tail, normal);
-        set_pdf_literal_data(tail, def_ref);
-    } else if (scan_keyword("dest")) {
-        scan_pdfdest(static_pdf);
-    } else if (scan_keyword("annot")) {
-        scan_annot(static_pdf);
-    } else if (scan_keyword("save")) {
-        new_whatsit(pdf_save_node);
-    } else if (scan_keyword("restore")) {
-        new_whatsit(pdf_restore_node);
-    } else if (scan_keyword("setmatrix")) {
-        new_whatsit(pdf_setmatrix_node);
-        scan_toks(false, true);
-        set_pdf_setmatrix_data(tail, def_ref);
-    } else if (scan_keyword("obj")) {
-        scan_obj(static_pdf);
-        if (immediate) {
-            if (obj_data_ptr(static_pdf, pdf_last_obj) == 0)   /* this object has not been initialized yet */
-                normal_error("pdf backend","\\pdfextension obj 'reserveobjnum' cannot be used with \\immediate");
-            pdf_write_obj(static_pdf, pdf_last_obj);
-        }
-    } else if (scan_keyword("refobj")) {
-        scan_refobj(static_pdf);
-    } else if (scan_keyword("colorstack")) {
-        scan_int();
-        if (cur_val >= colorstackused()) {
-            print_err("Unknown color stack number ");
-            print_int(cur_val);
-            help3
-                ("Allocate and initialize a color stack with \\pdfextension colorstackinit.",
-                 "I'll use default color stack 0 here.",
-                 "Proceed, with fingers crossed.");
-            error();
-            cur_val = 0;
-        }
-        if (cur_val < 0) {
-            print_err("Invalid negative color stack number");
-            help2("I'll use default color stack 0 here.",
-                  "Proceed, with fingers crossed.");
-            error();
-            cur_val = 0;
-        }
-        if (scan_keyword("set"))
-            i = colorstack_set;
-        else if (scan_keyword("push"))
-            i = colorstack_push;
-        else if (scan_keyword("pop"))
-            i = colorstack_pop;
-        else if (scan_keyword("current"))
-            i = colorstack_current;
-        else
-            i = -1; /* error */
-        if (i >= 0) {
-            new_whatsit(pdf_colorstack_node);
-            set_pdf_colorstack_stack(tail, cur_val);
-            set_pdf_colorstack_cmd(tail, i);
-            set_pdf_colorstack_data(tail, null);
-            if (i <= colorstack_data) {
-                scan_toks(false, true);
-                set_pdf_colorstack_data(tail, def_ref);
-            }
-        } else {
-            print_err("Color stack action is missing");
-            help3("The expected actions for \\pdfextension colorstack:",
-                  "    set, push, pop, current",
-                  "I'll ignore the color stack command.");
-            error();
-        }
-    } else if (scan_keyword("startlink")) {
-        scan_startlink(static_pdf);
-    } else if (scan_keyword("endlink")) {
-        if (abs(mode) == vmode)
-            normal_error("pdf backend", "\\pdfextension endlink cannot be used in vertical mode");
-        new_whatsit(pdf_end_link_node);
-    } else if (scan_keyword("startthread")) {
-        new_annot_whatsit(pdf_start_thread_node);
-        scan_thread_id();
-    } else if (scan_keyword("endthread")) {
-        new_whatsit(pdf_end_thread_node);
-    } else if (scan_keyword("thread")) {
-        new_annot_whatsit(pdf_thread_node);
-        scan_thread_id();
-    } else if (scan_keyword("outline")) {
-        scan_pdfoutline(static_pdf);
-    } else if (scan_keyword("glyphtounicode")) {
-        glyph_to_unicode();
-    } else if (scan_keyword("catalog")) {
-        scan_pdfcatalog(static_pdf);
-    } else if (scan_keyword("fontattr")) {
-        /*
-            The font attributes are simply initialized to zero now, this is easier to deal with from C than an
-            empty \TeX{} string, and surely nobody will want to set font attr to a string containing a single zero,
-            as that would be nonsensical in the PDF output.
-        */
-        scan_font_ident();
-        i = cur_val;
-        if (i == null_font)
-            normal_error("pdf backend", "invalid font identifier");
-        scan_toks(false, true);
-        set_pdf_font_attr(i, tokens_to_string(def_ref));
-        if (str_length(pdf_font_attr(i)) == 0) {
-            flush_str((str_ptr - 1));   /* from |tokens_to_string| */
-            set_pdf_font_attr(i, 0);
-        }
-    } else if (scan_keyword("mapfile")) {
-        scan_toks(false, true);
-        pdfmapfile(def_ref);
-        delete_token_ref(def_ref);
-    } else if (scan_keyword("mapline")) {
-        scan_toks(false, true);
-        pdfmapline(def_ref);
-        delete_token_ref(def_ref);
-    } else if (scan_keyword("includechars")) {
-        pdf_include_chars(static_pdf);
-    } else if (scan_keyword("info")) {
-        scan_toks(false, true);
-        pdf_info_toks = concat_tokens(pdf_info_toks, def_ref);
-    } else if (scan_keyword("names")) {
-        scan_toks(false, true);
-        pdf_names_toks = concat_tokens(pdf_names_toks, def_ref);
-    } else if (scan_keyword("trailer")) {
-        scan_toks(false, true);
-        pdf_trailer_toks = concat_tokens(pdf_trailer_toks, def_ref);
-    } else {
-        tex_error("unexpected use of \\pdfextension",null);
-    }
-}
-
-static void do_resource_dvi(int immediate, int code)
-{
-}
-
-static void do_resource_pdf(int immediate, int code)
-{
-    switch (code) {
-        case use_box_resource_code:
-            scan_pdfrefxform(static_pdf);
-            break;
-        case use_image_resource_code:
-            scan_pdfrefximage(static_pdf);
-            break;
-        case save_box_resource_code:
-            scan_pdfxform(static_pdf);
-            if (immediate) {
-                pdf_cur_form = last_saved_box_index;
-                ship_out(static_pdf, obj_xform_box(static_pdf, last_saved_box_index), SHIPPING_FORM);
-            }
-            break;
-        case save_image_resource_code:
-            scan_pdfximage(static_pdf);
-            if (immediate) {
-                pdf_write_image(static_pdf, last_saved_image_index);
-            }
-            break;
-    }
-}
-
-/*
-
-    Ad immediate:
-
-    To write a token list, we must run it through \TeX's scanner, expanding
-    macros and \.{\\the} and \.{\\number}, etc. This might cause runaways,
-    if a delimited macro parameter isn't matched, and runaways would be
-    extremely confusing since we are calling on \TeX's scanner in the middle
-    of a \.{\\shipout} command. Therefore we will put a dummy control sequence as
-    a ``stopper,'' right after the token list. This control sequence is
-    artificially defined to be \.{\\outer}.
-
-    The presence of `\.{\\immediate}' causes the |do_extension| procedure
-    to descend to one level of recursion. Nothing happens unless \.{\\immediate}
-    is followed by `\.{\\openout}', `\.{\\write}', or `\.{\\closeout}'.
-
-*/
-
-/* extensions are backend related */
-
-@ The next subroutine uses |cur_chr| to decide what sort of whatsit is
-involved, and also inserts a |write_stream| number.
-
-@c
-static void new_write_whatsit(int w, int check)
-{
-    new_whatsit(cur_chr);
-    if (check) {
-        /* so we check with open and close */
-        scan_limited_int(last_file_selector,NULL);
-    } else {
-        /* but we're tolerant with the rest */
-        scan_int();
-        if (cur_val < 0)
-            cur_val = term_only;
-        else if (cur_val > last_file_selector) {
-            cur_val = term_and_log;
-        }
-    }
-    write_stream(tail) = cur_val;
-}
-
-void do_extension(int immediate)
-{
-    halfword p; /* all-purpose pointer */
-    if (cur_cmd == extension_cmd) {
-        /* these have their own range starting at 0 */
-        switch (cur_chr) {
-        case open_code:
-            p = tail;
-            new_write_whatsit(open_node_size,1);
-            scan_optional_equals();
-            scan_file_name();
-            open_name(tail) = cur_name;
-            open_area(tail) = cur_area;
-            open_ext(tail) = cur_ext;
-            if (immediate) {
-                out_what(static_pdf, tail);
-                flush_node_list(tail);
-                tail = p;
-                vlink(p) = null;
-            }
-            break;
-        case write_code:
-            /*
-                When `\.{\\write 12\{...\}}' appears, we scan the token list `\.{\{...\}}'
-                without expanding its macros; the macros will be expanded later when this
-                token list is rescanned.
-            */
-            p = tail;
-            new_write_whatsit(write_node_size,0);
-            cur_cs = write_stream(tail);
-            scan_toks(false, false);
-            write_tokens(tail) = def_ref;
-            if (immediate) {
-                out_what(static_pdf, tail);
-                flush_node_list(tail);
-                tail = p;
-                vlink(p) = null;
-            }
-            break;
-        case close_code:
-            p = tail;
-            new_write_whatsit(close_node_size,1);
-            write_tokens(tail) = null;
-            if (immediate) {
-                out_what(static_pdf, tail);
-                flush_node_list(tail);
-                tail = p;
-                vlink(p) = null;
-            }
-            break;
-        case special_code:
-            /*
-                When `\.{\\special\{...\}}' appears, we expand the macros in the token
-                list as in \.{\\xdef} and \.{\\mark}.
-            */
-            new_whatsit(special_node);
-            write_stream(tail) = null;
-            p = scan_toks(false, true);
-            write_tokens(tail) = def_ref;
-            break;
-        case immediate_code:
-            get_x_token();
-            do_extension(1);
-            break;
-        case use_box_resource_code:
-        case use_image_resource_code:
-        case save_box_resource_code:
-        case save_image_resource_code:
-            switch (get_o_mode()) {
-                case OMODE_DVI:
-                    do_resource_dvi(immediate,cur_chr);
-                    break;
-                case OMODE_PDF:
-                    do_resource_pdf(immediate,cur_chr);
-                    break;
-                default:
-                    break;
-            }
-            break;
-        /* backend extensions have their own range starting at 32 */
-        case dvi_extension_code:
-            if (get_o_mode() == OMODE_DVI)
-                do_extension_dvi(immediate);
-            break;
-        case pdf_extension_code:
-            if (get_o_mode() == OMODE_PDF)
-                do_extension_pdf(immediate);
-            break;
-        /* done */
-        default:
-            if (immediate) {
-                back_input();
-            } else {
-                confusion("invalid extension");
-            }
-            break;
-        }
-    } else {
-        /* no extension command, quite certainly following \immediate */
-        back_input();
-    }
-}
-
-@ Here is a subroutine that creates a whatsit node having a given |subtype|
-and a given number of words. It initializes only the first word of the whatsit,
-and appends it to the current list.
-
-@c
-void new_whatsit(int s)
-{
-    halfword p = new_node(whatsit_node, s);
-    couple_nodes(tail, p);
-    tail = p;
-}
-
-@ The final line of this routine is slightly subtle; at least, the author
-didn't think about it until getting burnt! There is a used-up token list
-@^Knuth, Donald Ervin@>
-on the stack, namely the one that contained |end_write_token|. (We
-insert this artificial `\.{\\endwrite}' to prevent runaways, as explained
-above.) If it were not removed, and if there were numerous writes on a
-single page, the stack would overflow.
-
-@c
-void expand_macros_in_tokenlist(halfword p)
-{
-    int old_mode;
-    pointer q = get_avail();
-    pointer r = get_avail();
-    token_info(q) = right_brace_token + '}';
-    token_link(q) = r;
-    token_info(r) = end_write_token;
-    begin_token_list(q, inserted);
-    begin_token_list(write_tokens(p), write_text);
-    q = get_avail();
-    token_info(q) = left_brace_token + '{';
-    begin_token_list(q, inserted);
-    /* now we're ready to scan
-       `\.\{$\langle\,$token list$\,\rangle$\.{\} \\endwrite}' */
-    old_mode = mode;
-    mode = 0;
-    /* disable \.{\\prevdepth}, \.{\\spacefactor}, \.{\\lastskip}, \.{\\prevgraf} */
-    cur_cs = write_loc;
-    q = scan_toks(false, true); /* expand macros, etc. */
-    get_token();
-    if (cur_tok != end_write_token) {
-        /* Recover from an unbalanced write command */
-        const char *hlp[] = {
-            "On this page there's a \\write with fewer real {'s than }'s.",
-            "I can't handle that very well; good luck.", NULL
-        };
-        tex_error("Unbalanced write command", hlp);
-        do {
-            get_token();
-        } while (cur_tok != end_write_token);
-    }
-    mode = old_mode;
-    end_token_list();           /* conserve stack space */
-}
-
-void write_out(halfword p)
-{
-    int old_setting;            /* holds print |selector| */
-    int j;                      /* write stream number */
-    char *s, *ss;               /* line to be written, as a C string */
-    int callback_id;
-    int lua_retval;
-    expand_macros_in_tokenlist(p);
-    old_setting = selector;
-    j = write_stream(p);
-    if (file_can_be_written(j)) {
-        selector = j;
-    } else if ((j == term_only) && (selector == term_and_log)) {
-        /* write to the terminal if file isn't open */
-        selector = log_only;
-        tprint_nl("");
-    } else {
-        tprint_nl("");
-    }
-    s = tokenlist_to_cstring(def_ref, false, NULL);
-    if (selector < no_print) {
-        /* selector is a file */
-        callback_id = callback_defined(process_output_buffer_callback);
-        if (callback_id > 0) {
-            /* fix up the output buffer using callbacks */
-            lua_retval = run_callback(callback_id, "S->S", s, &ss);
-            if ((lua_retval == true) && (ss != NULL)) {
-                xfree(s);
-                s = ss;
-            }
-        }
-    }
-    tprint(s);
-    xfree(s);
-    print_ln();
-    flush_list(def_ref);
-    selector = old_setting;
-}
-
-void finalize_write_files(void) {
-    int k;
-    for (k = 0; k <= last_file_selector; k++) {
-        if (write_open[k]) {
-            lua_a_close_out(write_file[k]);
-        }
-    }
-}
-
-void initialize_write_files(void) {
-    int k;
-    for (k = 0; k <= last_file_selector; k++) {
-        write_open[k] = false;
-    }
-}
-
-void close_write_file(int id) {
-    if (write_open[id]) {
-        lua_a_close_out(write_file[id]);
-        write_open[id] = false;
-    }
-}
-
-boolean open_write_file(int id, char *fn) {
-    if (lua_a_open_out(&(write_file[id]), fn, (id + 1))) {
-        write_open[id] = true;
-        return true;
-    } else {
-        return false;
-    }
-}
-
-
-@ To implement primitives as \.{\\pdfextension info}, \.{\\pdfextension catalog} or
-\.{\\pdfextension names} we need to concatenate tokens lists.
-
-@c
-halfword concat_tokens(halfword q, halfword r)
-{                               /* concat |q| and |r| and returns the result tokens list */
-    halfword p;
-    if (q == null)
-        return r;
-    p = q;
-    while (token_link(p) != null)
-        p = token_link(p);
-    set_token_link(p, token_link(r));
-    free_avail(r);
-    return q;
-}
-
-@ The \eTeX\ features available in extended mode are grouped into two
-categories:  (1)~Some of them are permanently enabled and have no
-semantic effect as long as none of the additional primitives are
-executed.  (2)~The remaining \eTeX\ features are optional and can be
-individually enabled and disabled.  For each optional feature there is
-an \eTeX\ state variable named \.{\\...state}; the feature is enabled,
-resp.\ disabled by assigning a positive, resp.\ non-positive value to
-that integer.
-
-@ In order to handle \.{\\everyeof} we need an array |eof_seen| of
-boolean variables.
-
-@c
-boolean *eof_seen;              /* has eof been seen? */
-
-@ The |print_group| procedure prints the current level of grouping and
-the name corresponding to |cur_group|.
-
-@c
-void print_group(boolean e)
-{
-    switch (cur_group) {
-        case bottom_level:
-            tprint("bottom level");
-            return;
-            break;
-        case simple_group:
-        case semi_simple_group:
-            if (cur_group == semi_simple_group)
-                tprint("semi ");
-            tprint("simple");
-            break;;
-        case hbox_group:
-        case adjusted_hbox_group:
-            if (cur_group == adjusted_hbox_group)
-                tprint("adjusted ");
-            tprint("hbox");
-            break;
-        case vbox_group:
-            tprint("vbox");
-            break;
-        case vtop_group:
-            tprint("vtop");
-            break;
-        case align_group:
-        case no_align_group:
-            if (cur_group == no_align_group)
-                tprint("no ");
-            tprint("align");
-            break;
-        case output_group:
-            tprint("output");
-            break;
-        case disc_group:
-            tprint("disc");
-            break;
-        case insert_group:
-            tprint("insert");
-            break;
-        case vcenter_group:
-            tprint("vcenter");
-            break;
-        case math_group:
-        case math_choice_group:
-        case math_shift_group:
-        case math_left_group:
-            tprint("math");
-            if (cur_group == math_choice_group)
-                tprint(" choice");
-            else if (cur_group == math_shift_group)
-                tprint(" shift");
-            else if (cur_group == math_left_group)
-                tprint(" left");
-            break;
-    }                           /* there are no other cases */
-    tprint(" group (level ");
-    print_int(cur_level);
-    print_char(')');
-    if (saved_value(-1) != 0) { /* |saved_line| */
-        if (e)
-            tprint(" entered at line ");
-        else
-            tprint(" at line ");
-        print_int(saved_value(-1));     /* |saved_line| */
-    }
-}
-
-@ The |group_trace| procedure is called when a new level of grouping
-begins (|e=false|) or ends (|e=true|) with |saved_value(-1)| containing the
-line number.
-
-@c
-void group_trace(boolean e)
-{
-    begin_diagnostic();
-    print_char('{');
-    if (e)
-        tprint("leaving ");
-    else
-        tprint("entering ");
-    print_group(e);
-    print_char('}');
-    end_diagnostic(false);
-}
-
-@ A group entered (or a conditional started) in one file may end in a
-different file.  Such slight anomalies, although perfectly legitimate,
-may cause errors that are difficult to locate.  In order to be able to
-give a warning message when such anomalies occur, \eTeX\ uses the
-|grp_stack| and |if_stack| arrays to record the initial |cur_boundary|
-and |cond_ptr| values for each input file.
-
-@c
-save_pointer *grp_stack;        /* initial |cur_boundary| */
-halfword *if_stack;             /* initial |cond_ptr| */
-
-@ When a group ends that was apparently entered in a different input
-file, the |group_warning| procedure is invoked in order to update the
-|grp_stack|.  If moreover \.{\\tracingnesting} is positive we want to
-give a warning message.  The situation is, however, somewhat complicated
-by two facts:  (1)~There may be |grp_stack| elements without a
-corresponding \.{\\input} file or \.{\\scantokens} pseudo file (e.g.,
-error insertions from the terminal); and (2)~the relevant information is
-recorded in the |name_field| of the |input_stack| only loosely
-synchronized with the |in_open| variable indexing |grp_stack|.
-
-@c
-void group_warning(void)
-{
-    boolean w = false;                  /* do we need a warning? */
-    int i = in_open;                    /* index into |grp_stack| */
-    base_ptr = input_ptr;
-    input_stack[base_ptr] = cur_input;  /* store current state */
-    while ((grp_stack[i] == cur_boundary) && (i > 0)) {
-        /* Set variable |w| to indicate if this case should be reported */
-        /* This code scans the input stack in order to determine the type of the
-           current input file. */
-        if (tracing_nesting_par > 0) {
-            while ((input_stack[base_ptr].state_field == token_list) ||
-                   (input_stack[base_ptr].index_field > i))
-                decr(base_ptr);
-            if (input_stack[base_ptr].name_field > 17)
-                w = true;
-        }
-
-        grp_stack[i] = save_value(save_ptr);
-        decr(i);
-    }
-    if (w) {
-        tprint_nl("Warning: end of ");
-        print_group(true);
-        tprint(" of a different file");
-        print_ln();
-        if (tracing_nesting_par > 1)
-            show_context();
-        if (history == spotless)
-            history = warning_issued;
-    }
-}
-
-@ When a conditional ends that was apparently started in a different
-input file, the |if_warning| procedure is invoked in order to update the
-|if_stack|.  If moreover \.{\\tracingnesting} is positive we want to
-give a warning message (with the same complications as above).
-
-@c
-void if_warning(void)
-{
-    boolean w = false;                  /* do we need a warning? */
-    int i = in_open;
-    base_ptr = input_ptr;
-    input_stack[base_ptr] = cur_input;  /* store current state */
-    while (if_stack[i] == cond_ptr) {
-        /* Set variable |w| to... */
-        if (tracing_nesting_par > 0) {
-            while ((input_stack[base_ptr].state_field == token_list) ||
-                   (input_stack[base_ptr].index_field > i))
-                decr(base_ptr);
-            if (input_stack[base_ptr].name_field > 17)
-                w = true;
-        }
-
-        if_stack[i] = vlink(cond_ptr);
-        decr(i);
-    }
-    if (w) {
-        tprint_nl("Warning: end of ");
-        print_cmd_chr(if_test_cmd, cur_if);
-        print_if_line(if_line);
-        tprint(" of a different file");
-        print_ln();
-        if (tracing_nesting_par > 1)
-            show_context();
-        if (history == spotless)
-            history = warning_issued;
-    }
-}
-
-
-@ Conversely, the |file_warning| procedure is invoked when a file ends
-and some groups entered or conditionals started while reading from that
-file are still incomplete.
-
-@c
-void file_warning(void)
-{
-    halfword p = save_ptr; /* saved value of |save_ptr| or |cond_ptr| */
-    int l = cur_level;     /* saved value of |cur_level| or |if_limit| */
-    int c = cur_group;     /* saved value of |cur_group| or |cur_if| */
-    int i;                 /* saved value of |if_line| */
-    save_ptr = cur_boundary;
-    while (grp_stack[in_open] != save_ptr) {
-        decr(cur_level);
-        tprint_nl("Warning: end of file when ");
-        print_group(true);
-        tprint(" is incomplete");
-        cur_group = save_level(save_ptr);
-        save_ptr = save_value(save_ptr);
-    }
-    save_ptr = p;
-    cur_level = (quarterword) l;
-    cur_group = (group_code) c; /* restore old values */
-    p = cond_ptr;
-    l = if_limit;
-    c = cur_if;
-    i = if_line;
-    while (if_stack[in_open] != cond_ptr) {
-        tprint_nl("Warning: end of file when ");
-        print_cmd_chr(if_test_cmd, cur_if);
-        if (if_limit == fi_code)
-            tprint_esc("else");
-        print_if_line(if_line);
-        tprint(" is incomplete");
-        if_line = if_line_field(cond_ptr);
-        cur_if = if_limit_subtype(cond_ptr);
-        if_limit = if_limit_type(cond_ptr);
-        cond_ptr = vlink(cond_ptr);
-    }
-    cond_ptr = p;
-    if_limit = l;
-    cur_if = c;
-    if_line = i;                /* restore old values */
-    print_ln();
-    if (tracing_nesting_par > 1)
-        show_context();
-    if (history == spotless)
-        history = warning_issued;
-}
-
-@ @c
-halfword last_line_fill;        /* the |par_fill_skip| glue node of the new paragraph */
-
-@ The lua interface needs some extra functions. The functions
-themselves are quite boring, but they are handy because otherwise this
-internal stuff has to be accessed from C directly, where lots of the
-defines are not available.
-
-@c
-#define get_tex_dimen_register(j) dimen(j)
-#define get_tex_skip_register(j) skip(j)
-#define get_tex_mu_skip_register(j) mu_skip(j)
-#define get_tex_count_register(j) count(j)
-#define get_tex_attribute_register(j) attribute(j)
-#define get_tex_box_register(j) box(j)
-
-/* these can now be macros (todo) */
-
-int get_tex_extension_count_register(int i)
-{
-    return (int) int_par(backend_int_base-int_base+i);
-}
-
-void set_tex_extension_count_register(int i, int d)
-{
-    int_par(backend_int_base-int_base+i) = d;
-}
-
-int get_tex_extension_dimen_register(int i)
-{
-    return (int) dimen_par(backend_dimen_base-dimen_base+i);
-}
-
-void set_tex_extension_dimen_register(int i, int d)
-{
-    dimen_par(backend_dimen_base-dimen_base+i) = d;
-}
-
-int get_tex_extension_toks_register(int i)
-{
-    return equiv(backend_toks_base+i);
-}
-
-int set_tex_dimen_register(int j, scaled v)
-{
-    int a;                      /* return non-nil for error */
-    if (global_defs_par > 0)
-        a = 4;
-    else
-        a = 0;
-    word_define(j + scaled_base, v);
-    return 0;
-}
-
-int set_tex_skip_register(int j, halfword v)
-{
-    int a;                      /* return non-nil for error */
-    if (global_defs_par > 0)
-        a = 4;
-    else
-        a = 0;
-    if (type(v) != glue_spec_node)
-        return 1;
-    word_define(j + skip_base, v);
-    return 0;
-}
-
-int set_tex_mu_skip_register(int j, halfword v)
-{
-    int a;                      /* return non-nil for error */
-    if (global_defs_par > 0)
-        a = 4;
-    else
-        a = 0;
-    if (type(v) != glue_spec_node)
-        return 1;
-    word_define(j + mu_skip_base, v);
-    return 0;
-}
-
-int set_tex_count_register(int j, scaled v)
-{
-    int a;                      /* return non-nil for error */
-    if (global_defs_par > 0)
-        a = 4;
-    else
-        a = 0;
-    word_define(j + count_base, v);
-    return 0;
-}
-
-int set_tex_box_register(int j, scaled v)
-{
-    int a;                      /* return non-nil for error */
-    if (global_defs_par > 0)
-        a = 4;
-    else
-        a = 0;
-    define(j + box_base, box_ref_cmd, v);
-    return 0;
-}
-
-int set_tex_attribute_register(int j, scaled v)
-{
-    int a;                      /* return non-nil for error */
-    if (global_defs_par > 0)
-        a = 4;
-    else
-        a = 0;
-    if (j > max_used_attr)
-        max_used_attr = j;
-    attr_list_cache = cache_disabled;
-    word_define(j + attribute_base, v);
-    return 0;
-}
-
-int get_tex_toks_register(int j)
-{
-    str_number s = get_nullstr();
-    if (toks(j) != null) {
-        s = tokens_to_string(toks(j));
-    }
-    return s;
-}
-
-int set_tex_toks_register(int j, lstring s)
-{
-    int a;
-    halfword ref = get_avail();
-    (void) str_toks(s);
-    set_token_ref_count(ref, 0);
-    set_token_link(ref, token_link(temp_token_head));
-    if (global_defs_par > 0)
-        a = 4;
-    else
-        a = 0;
-    define(j + toks_base, call_cmd, ref);
-    return 0;
-}
-
-int scan_tex_toks_register(int j, int c, lstring s)
-{
-    int a;
-    halfword ref = get_avail();
-    (void) str_scan_toks(c,s);
-    set_token_ref_count(ref, 0);
-    set_token_link(ref, token_link(temp_token_head));
-    if (global_defs_par > 0)
-        a = 4;
-    else
-        a = 0;
-    define(j + toks_base, call_cmd, ref);
-    return 0;
-}
-
-scaled get_tex_box_width(int j)
-{
-    halfword q = box(j);
-    if (q != null)
-        return width(q);
-    return 0;
-}
-
-int set_tex_box_width(int j, scaled v)
-{
-    halfword q = box(j);
-    if (q == null)
-        return 1;
-    width(q) = v;
-    return 0;
-}
-
-scaled get_tex_box_height(int j)
-{
-    halfword q = box(j);
-    if (q != null)
-        return height(q);
-    return 0;
-}
-
-int set_tex_box_height(int j, scaled v)
-{
-    halfword q = box(j);
-    if (q == null)
-        return 1;
-    height(q) = v;
-    return 0;
-}
-
-scaled get_tex_box_depth(int j)
-{
-    halfword q = box(j);
-    if (q != null)
-        return depth(q);
-    return 0;
-}
-
-int set_tex_box_depth(int j, scaled v)
-{
-    halfword q = box(j);
-    if (q == null)
-        return 1;
-    depth(q) = v;
-    return 0;
-}
-
-@ This section is devoted to the {\sl Synchronize \TeX nology}
-- or simply {\sl Sync\TeX} - used to synchronize between input and output.
-This section explains how synchronization basics are implemented.
-Before we enter into more technical details,
-let us recall in a few words what is synchronization.
-
-\TeX\ typesetting system clearly separates the input and the output material,
-and synchronization will provide a new link between both that can help
-text editors and viewers to work together.
-More precisely, forwards synchronization is the ability,
-given a location in the input source file,
-to find what is the corresponding place in the output.
-Backwards synchronization just performs the opposite:
-given a location in the output,
-retrieve the corresponding material in the input source file.
-
-For better code management and maintainance, we adopt a naming convention.
-Throughout this program, code related to the {\sl Synchronize \TeX nology} is tagged
-with the ``{\sl synctex}'' key word. Any code extract where {\sl Sync\TeX} plays
-its part, either explicitly or implicitly, (should) contain the string ``{\sl synctex}''.
-This naming convention also holds for external files.
-Moreover, all the code related to {\sl Sync\TeX} is gathered in this section,
-except the definitions.
-
-Enabling synchronization should be performed from the command line,
-|synctexoption| is used for that purpose.
-This global integer variable is declared here but it is not used here.
-This is just a placeholder where the command line controller will put
-the {\sl Sync\TeX} related options, and the {\sl Sync\TeX} controller will read them.
-
-@c
-int synctexoption;
-
-@ A convenient primitive is provided:
-\.{\\synctex=1} in the input source file enables synchronization whereas
-\.{\\synctex=0} disables it.
-Its memory address is |synctex_code|.
-It is initialized by the {\sl Sync\TeX} controller to the command-line option if given.
-The controller may filter some reserved bits.
-
-In order to give the {\sl Sync\TeX} controller read and write access to
-the contents of the \.{\\synctex} primitive, we declare |synctexoffset|,
-such that |mem[synctexoffset]| and \.{\\synctex} correspond to
-the same memory storage. |synctexoffset| is initialized to
-the correct value when quite everything is initialized.
-
-@c
-int synctexoffset;              /* holds the true value of |synctex_code| */
-
-@ Synchronization is achieved with the help of an auxiliary file named
-`\.{{\sl jobname}.synctex}' ({\sl jobname} is the contents of the
-\.{\\jobname} macro), where a {\sl Sync\TeX} controller implemented
-in the external |synctex.c| file will store geometrical information.
-This {\sl Sync\TeX} controller will take care of every technical details
-concerning the {\sl Sync\TeX} file, we will only focus on the messages
-the controller will receive from the \TeX\ program.
-
-The most accurate synchronization information should allow to map
-any character of the input source file to the corresponding location
-in the output, if relevant.
-Ideally, the synchronization information of the input material consists of
-the file name, the line and column numbers of every character.
-The synchronization information in the output is simply the page number and
-either point coordinates, or box dimensions and position.
-The problem is that the mapping between these informations is only known at
-ship out time, which means that we must keep track of the input
-synchronization information until the pages ship out.
-
-As \TeX\ only knows about file names and line numbers,
-but forgets the column numbers, we only consider a
-restricted input synchronization information called {\sl Sync\TeX\ information}.
-It consists of a unique file name identifier, the {\sl Sync\TeX\ file tag},
-and the line number.
-
-Keeping track of such information,
-should be different whether characters or nodes are involved.
-Actually, only certain nodes are involved in {\sl Sync\TeX},
-we call them {\sl synchronized nodes}.
-Synchronized nodes store the {\sl Sync\TeX} information in their last two words:
-the first one contains a {\sl Sync\TeX\ file tag} uniquely identifying
-the input file, and the second one contains the current line number,
-as returned by the \.{\\inputlineno} primitive.
-The |synctex_field_size| macro contains the necessary size to store
-the {\sl Sync\TeX} information in a node.
-
-When declaring the size of a new node, it is recommanded to use the following
-convention: if the node is synchronized, use a definition similar to
-|my_synchronized_node_size|={\sl xxx}+|synctex_field_size|.
-Moreover, one should expect that the {\sl Sync\TeX} information is always stored
-in the last two words of a synchronized node.
-
-By default, every node with a sufficiently big size is initialized
-at creation time in the |get_node| routine with the current
-{\sl Sync\TeX} information, whether or not the node is synchronized.
-One purpose is to set this information very early in order to minimize code
-dependencies, including forthcoming extensions.
-Another purpose is to avoid the assumption that every node type has a dedicated getter,
-where initialization should take place. Actually, it appears that some nodes are created
-using directly the |get_node| routine and not the dedicated constructor.
-And finally, initializing the node at only one place is less error prone.
-
-Instead of storing the input file name, it is better to store just an identifier.
-Each time \TeX\ opens a new file, it notifies the {\sl Sync\TeX} controller with
-a |synctex_start_input| message.
-This controller will create a new {\sl Sync\TeX} file tag and
-will update the current input state record accordingly.
-If the input comes from the terminal or a pseudo file, the |synctex_tag| is set to 0.
-It results in automatically disabling synchronization for material
-input from the terminal or pseudo files.
-
-Synchronized nodes are boxes, math, kern and glue nodes.
-Other nodes should be synchronized too, in particular math noads.
-\TeX\ assumes that math, kern and glue nodes have the same size,
-this is why both are synchronized.
-{\sl In fine}, only horizontal lists are really used in {\sl Sync\TeX},
-but all box nodes are considered the same with respect to synchronization,
-because a box node type is allowed to change at execution time.
-
-{\sl Nota Bene:}
-The {\sl Sync\TeX} code is very close to the memory model.
-It is not connected to any other part of the code,
-except for memory management. It is possible to neutralize the {\sl Sync\TeX} code
-rather simply. The first step is to define a null |synctex_field_size|.
-The second step is to comment out the code in ``Initialize bigger nodes...'' and every
-``Copy ... {\sl Sync\TeX} information''.
-The last step will be to comment out the |synctex_tag_field| related code in the
-definition of |synctex_tag| and the various ``Prepare ... {\sl Sync\TeX} information''.
-Then all the remaining code should be just harmless.
-The resulting program would behave exactly the same as if absolutely no {\sl Sync\TeX}
-related code was there, including memory management.
-Of course, all this assumes that {\sl Sync\TeX} is turned off from the command line.
-@^synctex@>
-@^synchronization@>
-
-@ Here are extra variables for Web2c.  (This numbering of the
-system-dependent section allows easy integration of Web2c and e-\TeX, etc.)
-@^<system dependencies@>
-
-@c
-pool_pointer edit_name_start;   /* where the filename to switch to starts */
-int edit_name_length, edit_line;        /* what line to start editing at */
-boolean stop_at_space;          /* whether |more_name| returns false for space */
-
-@ The |edit_name_start| will be set to point into |str_pool| somewhere after
-its beginning if \TeX\ is supposed to switch to an editor on exit.
-
-@c
-int shellenabledp;
-int restrictedshell;
-char *output_comment;
-
-@ Are we printing extra info as we read the format file?
-
-@c
-boolean debug_format_file;
diff --git a/texk/web2c/luatexdir/tex/filename.w b/texk/web2c/luatexdir/tex/filename.c
similarity index 56%
rename from texk/web2c/luatexdir/tex/filename.w
rename to texk/web2c/luatexdir/tex/filename.c
index 9e5d9c5cc..fdc6641ef 100644
--- a/texk/web2c/luatexdir/tex/filename.w
+++ b/texk/web2c/luatexdir/tex/filename.c
@@ -1,59 +1,62 @@
-% filename.w
-%
-% Copyright 2009-2010 Taco Hoekwater <taco@@luatex.org>
-%
-% This file is part of LuaTeX.
-%
-% LuaTeX is free software; you can redistribute it and/or modify it under
-% the terms of the GNU General Public License as published by the Free
-% Software Foundation; either version 2 of the License, or (at your
-% option) any later version.
-%
-% LuaTeX is distributed in the hope that it will be useful, but WITHOUT
-% ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-% FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
-% License for more details.
-%
-% You should have received a copy of the GNU General Public License along
-% with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
-
-@ @c
+/*
 
+filename.w
+
+Copyright 2009-2010 Taco Hoekwater <taco@@luatex.org>
+
+This file is part of LuaTeX.
+
+LuaTeX is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 2 of the License, or (at your
+option) any later version.
+
+LuaTeX is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+License for more details.
+
+You should have received a copy of the GNU General Public License along
+with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+
+*/
 
 #include "ptexlib.h"
 
 
-@  In order to isolate the system-dependent aspects of file names, the
-  @^system dependencies@>
-  system-independent parts of \TeX\ are expressed in terms
-  of three system-dependent
-  procedures called |begin_name|, |more_name|, and |end_name|. In
-  essence, if the user-specified characters of the file name are $c_1\ldots c_n$,
-  the system-independent driver program does the operations
-  $$|begin_name|;\,|more_name|(c_1);\,\ldots\,;\,|more_name|(c_n);
-  \,|end_name|.$$
-  These three procedures communicate with each other via global variables.
-  Afterwards the file name will appear in the string pool as three strings
-  called |cur_name|\penalty10000\hskip-.05em,
-  |cur_area|, and |cur_ext|; the latter two are null (i.e.,
-  |""|), unless they were explicitly specified by the user.
-  
-  Actually the situation is slightly more complicated, because \TeX\ needs
-  to know when the file name ends. The |more_name| routine is a function
-  (with side effects) that returns |true| on the calls |more_name|$(c_1)$,
-  \dots, |more_name|$(c_{n-1})$. The final call |more_name|$(c_n)$
-  returns |false|; or, it returns |true| and the token following $c_n$ is
-  something like `\.{\\hbox}' (i.e., not a character). In other words,
-  |more_name| is supposed to return |true| unless it is sure that the
-  file name has been completely scanned; and |end_name| is supposed to be able
-  to finish the assembly of |cur_name|, |cur_area|, and |cur_ext| regardless of
-  whether $|more_name|(c_n)$ returned |true| or |false|.
-
-
-@ Here now is the first of the system-dependent routines for file name scanning. 
-@^system dependencies@> 
-
-@c
+/*tex
+
+    In order to isolate the system-dependent aspects of file names, the @^system
+    dependencies@> system-independent parts of \TeX\ are expressed in terms of
+    three system-dependent procedures called |begin_name|, |more_name|, and
+    |end_name|. In essence, if the user-specified characters of the file name are
+    $c_1\ldots c_n$, the system-independent driver program does the operations
+    $$|begin_name|;\,|more_name|(c_1);\,\ldots\,;\,|more_name|(c_n);
+    \,|end_name|.$$
+
+    These three procedures communicate with each other via global variables.
+    Afterwards the file name will appear in the string pool as three strings
+    called |cur_name|\penalty10000\hskip-.05em, |cur_area|, and |cur_ext|; the
+    latter two are null (i.e., |""|), unless they were explicitly specified by
+    the user.
+
+    Actually the situation is slightly more complicated, because \TeX\ needs to
+    know when the file name ends. The |more_name| routine is a function (with
+    side effects) that returns |true| on the calls |more_name|$(c_1)$, \dots,
+    |more_name|$(c_{n-1})$. The final call |more_name|$(c_n)$ returns |false|;
+    or, it returns |true| and the token following $c_n$ is something like
+    `\.{\\hbox}' (i.e., not a character). In other words, |more_name| is supposed
+    to return |true| unless it is sure that the file name has been completely
+    scanned; and |end_name| is supposed to be able to finish the assembly of
+    |cur_name|, |cur_area|, and |cur_ext| regardless of whether
+    $|more_name|(c_n)$ returned |true| or |false|.
+
+
+    Here now is the first of the system-dependent routines for file name
+    scanning. @^system dependencies@>
+
+*/
+
 static void begin_name(void)
 {
     area_delimiter = 0;
@@ -61,13 +64,16 @@ static void begin_name(void)
     quoted_filename = false;
 }
 
-@ And here's the second. The string pool might change as the file name is
-   being scanned, since a new \.{\\csname} might be entered; therefore we keep
-   |area_delimiter| and |ext_delimiter| relative to the beginning of the current
-   string, instead of assigning an absolute address like |pool_ptr| to them.
-   @^system dependencies@> 
+/*tex
+
+    And here's the second. The string pool might change as the file name is being
+    scanned, since a new \.{\\csname} might be entered; therefore we keep
+    |area_delimiter| and |ext_delimiter| relative to the beginning of the current
+    string, instead of assigning an absolute address like |pool_ptr| to them.
+    @^system dependencies@>
+
+*/
 
-@c
 static boolean more_name(ASCII_code c)
 {
     if (c == ' ' && stop_at_space && (!quoted_filename)) {
@@ -77,7 +83,7 @@ static boolean more_name(ASCII_code c)
         return true;
     } else {
         str_room(1);
-        append_char(c);         /* contribute |c| to the current string */
+        append_char(c);
         if (IS_DIR_SEP(c)) {
             area_delimiter = (pool_pointer) cur_length;
             ext_delimiter = 0;
@@ -87,17 +93,21 @@ static boolean more_name(ASCII_code c)
     }
 }
 
-@ The third.
-@^system dependencies@>
+/*tex
+
+    The third. @^system dependencies@>
+
+*/
 
-@c
 static void end_name(void)
 {
     unsigned char *s;
     if (str_ptr + 3 > (max_strings + STRING_OFFSET))
-        overflow("number of strings",
-                 (unsigned) (max_strings - init_str_ptr + STRING_OFFSET));
-    /* at this point, the full string lives in |cur_string| */
+        overflow(
+            "number of strings",
+            (unsigned) (max_strings - init_str_ptr + STRING_OFFSET)
+        );
+    /*tex At this point, the full string lives in |cur_string|. */
     if (area_delimiter == 0) {
         cur_area = get_nullstr();
     } else {
@@ -105,7 +115,7 @@ static void end_name(void)
         cur_string[area_delimiter] = '\0';
         cur_length = (unsigned) strlen((char *) cur_string);
         cur_area = make_string();
-	xfree(cur_string);
+        xfree(cur_string);
         cur_length = (unsigned) strlen((char *) s);
         cur_string = s;
     }
@@ -118,24 +128,27 @@ static void end_name(void)
         cur_string[l] = '\0';
         cur_length = (unsigned) strlen((char *) cur_string);
         cur_name = make_string();
-	xfree(cur_string);
+        xfree(cur_string);
         cur_length = (unsigned) strlen((char *) s);
         cur_string = s;
         cur_ext = make_string();
     }
 }
 
-@ Now let's consider the ``driver'' routines by which \TeX\ deals with file names
-   in a system-independent manner.  First comes a procedure that looks for a
+/*tex
+
+   Now let's consider the ``driver'' routines by which \TeX\ deals with file
+   names in a system-independent manner. First comes a procedure that looks for a
    file name in the input by calling |get_x_token| for the information.
 
-@c
+*/
+
 void scan_file_name(void)
 {
     str_number u = 0;
     name_in_progress = true;
     begin_name();
-    /* Get the next non-blank non-call token; */
+    /*tex Get the next non-blank non-call token: */
     do {
         get_x_token();
     } while ((cur_cmd == spacer_cmd) || (cur_cmd == relax_cmd));
@@ -145,9 +158,11 @@ void scan_file_name(void)
             back_input();
             break;
         }
-        /* If |cur_chr| is a space and we're not scanning a token list, check
-           whether we're at the end of the buffer. Otherwise we end up adding
-           spurious spaces to file names in some cases. */
+        /*tex
+            If |cur_chr| is a space and we're not scanning a token list, check
+            whether we're at the end of the buffer. Otherwise we end up adding
+            spurious spaces to file names in some cases.
+        */
         if ((cur_chr == ' ') && (istate != token_list) && (iloc > ilimit)
             && !quoted_filename)
             break;
@@ -174,8 +189,10 @@ void scan_file_name(void)
     name_in_progress = false;
 }
 
-@ This function constructs a the three file name strings from a token list 
-@c
+/*
+    This function constructs a the three file name strings from a token list.
+*/
+
 void scan_file_name_toks(void)
 {
     char *a, *n, *e, *s = NULL;
@@ -192,12 +209,14 @@ void scan_file_name_toks(void)
             e = s + i;
         }
     }
-    if (n != s) {               /* explicit area */
+    if (n != s) {
+        /*tex explicit area */
         cur_area = maketexlstring(a, (size_t) (n - a));
     } else {
         cur_area = get_nullstr();
     }
-    if (e != NULL) {            /* explicit extension */
+    if (e != NULL) {
+        /*tex explicit extension */
         cur_name = maketexlstring(n, (size_t) (e - n));
         cur_ext = maketexstring(e);
     } else {
@@ -205,33 +224,34 @@ void scan_file_name_toks(void)
         cur_ext = get_nullstr();
     }
     xfree(s);
-  
-}
-
 
+}
 
+/*tex
 
-@  Here is a routine that manufactures the output file names, assuming that
-  |job_name<>0|. It ignores and changes the current settings of |cur_area|
-  and |cur_ext|.
+    Here is a routine that manufactures the output file names, assuming that
+    |job_name<>0|. It ignores and changes the current settings of |cur_area| and
+    |cur_ext|; |s = ".log"|, |".dvi"|, or |format_extension|
+*/
 
-@c
 char *pack_job_name(const char *s)
-{                               /* |s = ".log"|, |".dvi"|, or |format_extension| */
+{
     cur_area = get_nullstr();
     cur_ext = maketexstring(s);
     cur_name = job_name;
     return pack_file_name(cur_name, cur_area, cur_ext);
 }
 
-@ If some trouble arises when \TeX\ tries to open a file, the following
-   routine calls upon the user to supply another file name. Parameter~|s|
-   is used in the error message to identify the type of file; parameter~|e|
-   is the default extension if none is given. Upon exit from the routine,
-   variables |cur_name|, |cur_area|, and |cur_ext| are
-   ready for another attempt at file opening.
+/*tex
+
+    If some trouble arises when \TeX\ tries to open a file, the following routine
+    calls upon the user to supply another file name. Parameter~|s| is used in the
+    error message to identify the type of file; parameter~|e| is the default
+    extension if none is given. Upon exit from the routine, variables |cur_name|,
+    |cur_area|, and |cur_ext| are ready for another attempt at file opening.
+
+*/
 
-@c
 char *prompt_file_name(const char *s, const char *e)
 {
     int k;                      /* index into |buffer| */
@@ -290,12 +310,10 @@ char *prompt_file_name(const char *s, const char *e)
     return pack_file_name(cur_name, cur_area, cur_ext);
 }
 
-
-@ @c
 void tprint_file_name(unsigned char *n, unsigned char *a, unsigned char *e)
 {
-    boolean must_quote;         /* whether to quote the filename */
-    unsigned char *j;           /* index into string */
+    boolean must_quote; /* whether to quote the filename */
+    unsigned char *j;   /* index into string */
     must_quote = false;
     if (a != NULL) {
         j = a;
@@ -318,13 +336,11 @@ void tprint_file_name(unsigned char *n, unsigned char *a, unsigned char *e)
             j++;
         }
     }
-    /* FIXME: Alternative is to assume that any filename that has to be quoted has
-       at least one quoted component...if we pick this, a number of insertions
-       of |print_file_name| should go away.
-       |must_quote|:=((|a|<>0)and(|str_pool|[|str_start|[|a|]]=""""))or
-       ((|n|<>0)and(|str_pool|[|str_start|[|n|]]=""""))or
-       ((|e|<>0)and(|str_pool|[|str_start|[|e|]]="""")); */
-
+    /*tex
+        Alternative is to assume that any filename that has to be quoted has at
+        least one quoted component...if we pick this, a number of insertions of
+        |print_file_name| should go away.
+    */
     if (must_quote)
         print_char('"');
     if (a != NULL) {
@@ -346,15 +362,17 @@ void tprint_file_name(unsigned char *n, unsigned char *a, unsigned char *e)
         print_char('"');
 }
 
-@ @c
 void print_file_name(str_number n, str_number a, str_number e)
 {
     char *nam, *are, *ext;
     nam = makecstring(n);
     are = makecstring(a);
     ext = makecstring(e);
-    tprint_file_name((unsigned char *) nam, (unsigned char *) are,
-                     (unsigned char *) ext);
+    tprint_file_name(
+        (unsigned char *) nam,
+        (unsigned char *) are,
+        (unsigned char *) ext
+    );
     free(nam);
     free(are);
     free(ext);
diff --git a/texk/web2c/luatexdir/tex/inputstack.w b/texk/web2c/luatexdir/tex/inputstack.c
similarity index 53%
rename from texk/web2c/luatexdir/tex/inputstack.w
rename to texk/web2c/luatexdir/tex/inputstack.c
index 68b22e1a3..c64111edc 100644
--- a/texk/web2c/luatexdir/tex/inputstack.w
+++ b/texk/web2c/luatexdir/tex/inputstack.c
@@ -1,51 +1,85 @@
-% inputstack.w
-%
-% Copyright 2009-2010 Taco Hoekwater <taco@@luatex.org>
-%
-% This file is part of LuaTeX.
-%
-% LuaTeX is free software; you can redistribute it and/or modify it under
-% the terms of the GNU General Public License as published by the Free
-% Software Foundation; either version 2 of the License, or (at your
-% option) any later version.
-%
-% LuaTeX is distributed in the hope that it will be useful, but WITHOUT
-% ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-% FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
-% License for more details.
-%
-% You should have received a copy of the GNU General Public License along
-% with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
-
-@ @c
+/*
+
+inputstack.w
+
+Copyright 2009-2010 Taco Hoekwater <taco@@luatex.org>
+
+This file is part of LuaTeX.
+
+LuaTeX is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 2 of the License, or (at your
+option) any later version.
+
+LuaTeX is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+License for more details.
+
+You should have received a copy of the GNU General Public License along
+with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+
+*/
 
 #include "ptexlib.h"
 
-@ @c
 in_state_record *input_stack = NULL;
-int input_ptr = 0;              /* first unused location of |input_stack| */
-int max_in_stack = 0;           /* largest value of |input_ptr| when pushing */
-in_state_record cur_input;      /* the ``top'' input state */
 
-int in_open = 0;                /* the number of lines in the buffer, less one */
-int open_parens = 0;            /* the number of open text files */
+/*tex First unused location of |input_stack|: */
+
+int input_ptr = 0;
+
+/*tex Largest value of |input_ptr| when pushing: */
+
+int max_in_stack = 0;
+
+/*tex The `top' input state: */
+
+in_state_record cur_input;
+
+/*tex The number of lines in the buffer, less one: */
+
+int in_open = 0;
+
+/*tex The number of open text files: */
+
+int open_parens = 0;
+
 alpha_file *input_file = NULL;
-int line = 0;                   /* current line number in the current source file */
+
+/*tex The current line number in the current source file: */
+
+int line = 0;
+
 int *line_stack = NULL;
+
 str_number *source_filename_stack = NULL;
+
 char **full_source_filename_stack = NULL;
 
-int scanner_status = 0;         /* can a subfile end now? */
-pointer warning_index = null;   /* identifier relevant to non-|normal| scanner status */
-pointer def_ref = null;         /* reference count of token list being defined */
+/*tex Can a subfile end now? */
 
-@ Here is a procedure that uses |scanner_status| to print a warning message
-when a subfile has ended, and at certain other crucial times:
+int scanner_status = 0;
+
+/*tex Identifier relevant to non-|normal| scanner status: */
+
+pointer warning_index = null;
+
+/*tex Reference count of token list being defined: */
+
+pointer def_ref = null;
+
+/*tex
+
+Here is a procedure that uses |scanner_status| to print a warning message when a
+subfile has ended, and at certain other crucial times:
+
+*/
 
-@c
 void runaway(void)
 {
-    pointer p = null; /* head of runaway list */
+    /*tex The head of the runaway list: */
+    pointer p = null;
     if (scanner_status > skipping) {
         switch (scanner_status) {
         case defining:
@@ -65,7 +99,7 @@ void runaway(void)
             p = def_ref;
             break;
         default:
-            /* there are no other cases */
+            /*tex There are no other cases. */
             break;
         }
         print_char('?');
@@ -74,48 +108,69 @@ void runaway(void)
     }
 }
 
-@ The |param_stack| is an auxiliary array used to hold pointers to the token
-lists for parameters at the current level and subsidiary levels of input.
-This stack is maintained with convention (2), and it grows at a different
-rate from the others.
-
-@c
-pointer *param_stack = NULL;    /* token list pointers for parameters */
-int param_ptr = 0;              /* first unused entry in |param_stack| */
-int max_param_stack = 0;        /* largest value of |param_ptr|, will be |<=param_size+9| */
-
-@ The input routines must also interact with the processing of
-\.{\\halign} and \.{\\valign}, since the appearance of tab marks and
-\.{\\cr} in certain places is supposed to trigger the beginning of special
-$v_j$ template text in the scanner. This magic is accomplished by an
-|align_state| variable that is increased by~1 when a `\.{\char'173}' is
-scanned and decreased by~1 when a `\.{\char'175}' is scanned. The |align_state|
-is nonzero during the $u_j$ template, after which it is set to zero; the
-$v_j$ template begins when a tab mark or \.{\\cr} occurs at a time that
-|align_state=0|.
-
-@c
-int align_state = 0;            /* group level with respect to current alignment */
-
-@ Thus, the ``current input state'' can be very complicated indeed; there
-can be many levels and each level can arise in a variety of ways. The
-|show_context| procedure, which is used by \TeX's error-reporting routine to
-print out the current input state on all levels down to the most recent
-line of characters from an input file, illustrates most of these conventions.
-The global variable |base_ptr| contains the lowest level that was
-displayed by this procedure.
-
-@c
-int base_ptr = 0;               /* shallowest level shown by |show_context| */
-
-@ The status at each level is indicated by printing two lines, where the first
-line indicates what was read so far and the second line shows what remains
-to be read. The context is cropped, if necessary, so that the first line
-contains at most |half_error_line| characters, and the second contains
-at most |error_line|. Non-current input levels whose |token_type| is
-`|backed_up|' are shown only if they have not been fully read.
-
-@c
+/*tex
+
+The |param_stack| is an auxiliary array used to hold pointers to the token lists
+for parameters at the current level and subsidiary levels of input. This stack is
+maintained with convention (2), and it grows at a different rate from the others.
+
+*/
+
+/*tex Token list pointers for parameters: */
+
+pointer *param_stack = NULL;
+
+/*tex First unused entry in |param_stack|: */
+
+int param_ptr = 0;
+
+/*tex Largest value of |param_ptr|, will be |<=param_size+9|: */
+
+int max_param_stack = 0;
+
+/*tex
+
+The input routines must also interact with the processing of \.{\\halign} and
+\.{\\valign}, since the appearance of tab marks and \.{\\cr} in certain places is
+supposed to trigger the beginning of special $v_j$ template text in the scanner.
+This magic is accomplished by an |align_state| variable that is increased by~1
+when a `\.{\char'173}' is scanned and decreased by~1 when a `\.{\char'175}' is
+scanned. The |align_state| is nonzero during the $u_j$ template, after which it
+is set to zero; the $v_j$ template begins when a tab mark or \.{\\cr} occurs at a
+time that |align_state=0|.
+
+*/
+
+/*tex The group level with respect to current alignment: */
+
+int align_state = 0;
+
+/*tex
+
+Thus, the ``current input state'' can be very complicated indeed; there can be
+many levels and each level can arise in a variety of ways. The |show_context|
+procedure, which is used by \TeX's error-reporting routine to print out the
+current input state on all levels down to the most recent line of characters from
+an input file, illustrates most of these conventions. The global variable
+|base_ptr| contains the lowest level that was displayed by this procedure.
+
+*/
+
+/*tex The shallowest level shown by |show_context|: */
+
+int base_ptr = 0;
+
+/*tex
+
+The status at each level is indicated by printing two lines, where the first line
+indicates what was read so far and the second line shows what remains to be read.
+The context is cropped, if necessary, so that the first line contains at most
+|half_error_line| characters, and the second contains at most |error_line|.
+Non-current input levels whose |token_type| is `|backed_up|' are shown only if
+they have not been fully read.
+
+*/
+
 static void print_token_list_type(int t)
 {
     switch (t) {
@@ -172,47 +227,49 @@ static void print_token_list_type(int t)
         case write_text:
             tprint_nl("<write> ");
             break;
+        case local_text:
+            tprint_nl("<local> ");
+            break;
         default:
             tprint_nl("?");
-            /* this should never happen */
+            /*tex This should never happen. */
             break;
     }
 }
 
-@ Here it is necessary to explain a little trick. We don't want to store a long
-string that corresponds to a token list, because that string might take up
-lots of memory; and we are printing during a time when an error message is
-being given, so we dare not do anything that might overflow one of \TeX's
-tables. So `pseudoprinting' is the answer: We enter a mode of printing
-that stores characters into a buffer of length |error_line|, where character
-$k+1$ is placed into \hbox{|trick_buf[k mod error_line]|} if
-|k<trick_count|, otherwise character |k| is dropped. Initially we set
-|tally:=0| and |trick_count:=1000000|; then when we reach the
-point where transition from line 1 to line 2 should occur, we
-set |first_count:=tally| and |trick_count:=@tmax@>(error_line,
-tally+1+error_line-half_error_line)|. At the end of the
-pseudoprinting, the values of |first_count|, |tally|, and
-|trick_count| give us all the information we need to print the two lines,
-and all of the necessary text is in |trick_buf|.
-
-Namely, let |l| be the length of the descriptive information that appears
-on the first line. The length of the context information gathered for that
-line is |k=first_count|, and the length of the context information
-gathered for line~2 is $m=\min(|tally|, |trick_count|)-k$. If |l+k<=h|,
-where |h=half_error_line|, we print |trick_buf[0..k-1]| after the
-descriptive information on line~1, and set |n:=l+k|; here |n| is the
-length of line~1. If $l+k>h$, some cropping is necessary, so we set |n:=h|
-and print `\.{...}' followed by
-$$\hbox{|trick_buf[(l+k-h+3)..k-1]|,}$$
-where subscripts of |trick_buf| are circular modulo |error_line|. The
-second line consists of |n|~spaces followed by |trick_buf[k..(k+m-1)]|,
-unless |n+m>error_line|; in the latter case, further cropping is done.
-This is easier to program than to explain.
-
-@ The following code sets up the print routines so that they will gather
-the desired information.
-
-@c
+/*tex
+
+Here it is necessary to explain a little trick. We don't want to store a long
+string that corresponds to a token list, because that string might take up lots
+of memory; and we are printing during a time when an error message is being
+given, so we dare not do anything that might overflow one of \TeX's tables. So
+`pseudoprinting' is the answer: We enter a mode of printing that stores
+characters into a buffer of length |error_line|, where character $k+1$ is placed
+into \hbox{|trick_buf[k mod error_line]|} if |k<trick_count|, otherwise character
+|k| is dropped. Initially we set |tally:=0| and |trick_count:=1000000|; then when
+we reach the point where transition from line 1 to line 2 should occur, we set
+|first_count:=tally| and |trick_count:=@tmax@>(error_line,
+tally+1+error_line-half_error_line)|. At the end of the pseudoprinting, the
+values of |first_count|, |tally|, and |trick_count| give us all the information
+we need to print the two lines, and all of the necessary text is in |trick_buf|.
+
+Namely, let |l| be the length of the descriptive information that appears on the
+first line. The length of the context information gathered for that line is
+|k=first_count|, and the length of the context information gathered for line~2 is
+$m=\min(|tally|, |trick_count|)-k$. If |l+k<=h|, where |h=half_error_line|, we
+print |trick_buf[0..k-1]| after the descriptive information on line~1, and set
+|n:=l+k|; here |n| is the length of line~1. If $l+k>h$, some cropping is
+necessary, so we set |n:=h| and print `\.{...}' followed by
+$$\hbox{|trick_buf[(l+k-h+3)..k-1]|,}$$ where subscripts of |trick_buf| are
+circular modulo |error_line|. The second line consists of |n|~spaces followed by
+|trick_buf[k..(k+m-1)]|, unless |n+m>error_line|; in the latter case, further
+cropping is done. This is easier to program than to explain.
+
+The following code sets up the print routines so that they will gather the
+desired information.
+
+*/
+
 void set_trick_count(void)
 {
     first_count = tally;
@@ -230,10 +287,12 @@ void set_trick_count(void)
 
 #define PSEUDO_PRINT_THE_LINE()	do { \
     begin_pseudoprint(); \
-    if (buffer[ilimit]==end_line_char_par) \
+    if (buffer[ilimit]==end_line_char_par) { \
         j=ilimit; \
-    else \
-        j=ilimit+1; /* determine the effective end of the line */ \
+    } else { \
+        /*tex Determine the effective end of the line. */ \
+        j=ilimit+1; \
+    } \
     if (j>0) { \
         for (i=istart;i<=j-1;i++) { \
             if (i==iloc) \
@@ -243,10 +302,12 @@ void set_trick_count(void)
     } \
 } while (0)
 
-/*
-    We don't care too much if we stay a bit too much below the max error_line
-    even if we have more room on the line. If length is really an issue then
-    any length is. After all one can set the length larger.
+/*tex
+
+We don't care too much if we stay a bit too much below the max error_line even if
+we have more room on the line. If length is really an issue then any length is.
+After all one can set the length larger.
+
 */
 
 #define print_valid_utf8(q) do { \
@@ -268,46 +329,66 @@ void set_trick_count(void)
         print_char(trick_buf[(q+2) % error_line]); \
         print_char(trick_buf[(q+3) % error_line]); \
     } else { \
-        /* invalid */ \
+        /*tex Invalid character! */ \
     } \
 } while (0)
 
-@ @c
+/*tex
+
+This one prints where the scanner is.
+
+*/
+
 void show_context(void)
-{                                /* prints where the scanner is */
-    int old_setting;             /* saved |selector| setting */
-    int nn = -1;                 /* number of contexts shown so far, less one */
-    boolean bottom_line = false; /* have we reached the final context to be shown? */
-    int i;                       /* index into |buffer| */
-    int j;                       /* end of current line in |buffer| */
-    int l;                       /* length of descriptive information on line 1 */
-    int m;                       /* context information gathered for line 2 */
-    int n;                       /* length of line 1 */
-    int p;                       /* starting or ending place in |trick_buf| */
-    int q;                       /* temporary index */
-    int c;                       /* used in sanitizer */
+{
+    /*tex Saved |selector| setting: */
+    int old_setting;
+    /*tex Number of contexts shown so far, less one: */
+    int nn = -1;
+    /*tex Have we reached the final context to be shown? */
+    boolean bottom_line = false;
+    /*tex Index into |buffer|: */
+    int i;
+    /*tex End of current line in |buffer|: */
+    int j;
+    /*tex Length of descriptive information on line 1: */
+    int l;
+    /*tex Context information gathered for line 2: */
+    int m;
+    /*tex Length of line 1: */
+    int n;
+    /*tex Starting or ending place in |trick_buf|: */
+    int p;
+    /*tex Temporary index: */
+    int q;
+    /*tex Used in sanitizer: */
+    int c;
     base_ptr = input_ptr;
     input_stack[base_ptr] = cur_input;
-    /* store current state */
+    /*tex Store the current state. */
     while (true) {
-        cur_input = input_stack[base_ptr];      /* enter into the context */
+        /*tex Enter into the context. */
+        cur_input = input_stack[base_ptr];
         if (istate != token_list) {
             if ((iname > 21) || (base_ptr == 0))
                 bottom_line = true;
         }
         if ((base_ptr == input_ptr) || bottom_line || (nn < error_context_lines_par)) {
-            /* Display the current context */
+            /*tex Display the current context. */
             if ((base_ptr == input_ptr) || (istate != token_list) || (token_type != backed_up) || (iloc != null)) {
-                /* we omit backed-up token lists that have already been read */
-                tally = 0;      /* get ready to count characters */
+                /*tex
+                    We omit backed-up token lists that have already been read.
+                    Get ready to count characters.
+                */
+                tally = 0;
                 old_setting = selector;
                 if (istate != token_list) {
-                    /*
-                        Print location of current line
-
-                        This routine should be changed, if necessary, to give the best possible
-                        indication of where the current line resides in the input file. For example,
-                        on some systems it is best to print both a page and line number.
+                    /*tex
+                        Print the location of the current line. This routine
+                        should be changed, if necessary, to give the best
+                        possible indication of where the current line resides in
+                        the input file. For example, on some systems it is best
+                        to print both a page and line number.
                      */
                     if (iname <= 17) {
                         if (terminal_input) {
@@ -327,7 +408,8 @@ void show_context(void)
                         tprint_nl("l.");
                         if (iindex == in_open) {
                             print_int(line);
-                        } else {     /* input from a pseudo file */
+                        } else {
+                            /*tex Input from a pseudo file. */
                             print_int(line_stack[iindex + 1]);
                         }
                     }
@@ -337,21 +419,26 @@ void show_context(void)
                     print_token_list_type(token_type);
 
                     begin_pseudoprint();
-                    if (token_type < macro)
+                    if (token_type < macro) {
                         show_token_list(istart, iloc, 100000);
-                    else
-                        show_token_list(token_link(istart), iloc, 100000);      /* avoid reference count */
+                    } else {
+                        /*tex Avoid reference count. */
+                        show_token_list(token_link(istart), iloc, 100000);
+                    }
                 }
-                /* stop pseudoprinting */
+                /*tex Stop pseudoprinting. */
                 selector = old_setting;
-                /* Print two lines using the tricky pseudoprinted information */
-                if (trick_count == 1000000)
+                /*tex Print two lines using the tricky pseudoprinted information. */
+                if (trick_count == 1000000) {
                     set_trick_count();
-                /* |set_trick_count| must be performed */
-                if (tally < trick_count)
+                }
+                /*tex The |set_trick_count| must be performed. */
+                if (tally < trick_count) {
                     m = tally - first_count;
-                else
-                    m = trick_count - first_count;      /* context on line 2 */
+                } else {
+                     /* The context on line 2: */
+                    m = trick_count - first_count;
+                }
                 if (l + first_count <= half_error_line) {
                     p = 0;
                     n = l + first_count;
@@ -360,12 +447,14 @@ void show_context(void)
                     p = l + first_count - half_error_line + 3;
                     n = half_error_line;
                 }
-                for (q = p; q <= first_count - 1; q++)
+                for (q = p; q <= first_count - 1; q++) {
                     print_valid_utf8(q);
-                    print_ln();
-                /* print |n| spaces to begin line~2 */
-                for (q = 1; q <= n; q++)
+                }
+                print_ln();
+                /*tex Print |n| spaces to begin line 2. */
+                for (q = 1; q <= n; q++) {
                     print_char(' ');
+                }
                 if (m + n <= error_line)
                     p = first_count + m;
                 else
@@ -379,24 +468,26 @@ void show_context(void)
         } else if (nn == error_context_lines_par) {
             tprint_nl("...");
             incr(nn);
-            /* omitted if |error_context_lines_par<0| */
+            /*tex Omitted if |error_context_lines_par<0|. */
         }
         if (bottom_line)
             break;
         decr(base_ptr);
     }
-    /* restore original state */
+    /*tex Restore the original state. */
     cur_input = input_stack[input_ptr];
 }
 
-@ The following subroutines change the input status in commonly needed ways.
+/*tex
+
+The following subroutines change the input status in commonly needed ways.
 
 First comes |push_input|, which stores the current state and creates a
 new level (having, initially, the same properties as the old).
 
-@c
+Enter a new input level, save the old:
 
-/* enter a new input level, save the old */
+*/
 
 # define pop_input() \
     cur_input=input_stack[--input_ptr]
@@ -411,12 +502,14 @@ new level (having, initially, the same properties as the old).
     nofilter = false; \
     incr(input_ptr);
 
-@
-Here is a procedure that starts a new level of token-list input, given
-a token list |p| and its type |t|. If |t=macro|, the calling routine should
-set |name| and |loc|.
+/*tex
+
+Here is a procedure that starts a new level of token-list input, given a token
+list |p| and its type |t|. If |t=macro|, the calling routine should set |name|
+and |loc|.
+
+*/
 
-@c
 void begin_token_list(halfword p, quarterword t)
 {
     push_input();
@@ -424,7 +517,7 @@ void begin_token_list(halfword p, quarterword t)
     istart = p;
     token_type = (unsigned char) t;
     if (t >= macro) {
-        /* the token list starts with a reference count */
+        /*tex The token list starts with a reference count. */
         add_token_ref(p);
         if (t == macro) {
             param_start = param_ptr;
@@ -438,8 +531,7 @@ void begin_token_list(halfword p, quarterword t)
                 else if (t == write_text)
                     tprint_esc("write");
                 else
-                    print_cmd_chr(assign_toks_cmd,
-                                  t - output_text + output_routine_loc);
+                    print_cmd_chr(assign_toks_cmd, t - output_text + output_routine_loc);
                 tprint("->");
                 token_show(p);
                 end_diagnostic(false);
@@ -450,24 +542,26 @@ void begin_token_list(halfword p, quarterword t)
     }
 }
 
-@ When a token list has been fully scanned, the following computations
-should be done as we leave that level of input. The |token_type| tends
-to be equal to either |backed_up| or |inserted| about 2/3 of the time.
-@^inner loop@>
+/*tex
+
+When a token list has been fully scanned, the following computations should be
+done as we leave that level of input. The |token_type| tends to be equal to
+either |backed_up| or |inserted| about 2/3 of the time. @^inner loop@>
+
+*/
 
-@c
 void end_token_list(void)
 {
-    /* leave a token-list input level */
+    /*tex Leave a token-list input level: */
     if (token_type >= backed_up) {
-        /* token list to be deleted */
+        /*tex The token list to be deleted: */
         if (token_type <= inserted) {
             flush_list(istart);
         } else {
-            /* update reference count */
+            /*tex Update the reference count: */
             delete_token_ref(istart);
             if (token_type == macro) {
-                /* parameters must be flushed */
+                /*tex Parameters must be flushed: */
                 while (param_ptr > param_start) {
                     decr(param_ptr);
                     flush_list(param_stack[param_ptr]);
@@ -484,23 +578,24 @@ void end_token_list(void)
     check_interrupt();
 }
 
-@ Sometimes \TeX\ has read too far and wants to ``unscan'' what it has
-seen. The |back_input| procedure takes care of this by putting the token
-just scanned back into the input stream, ready to be read again. This
-procedure can be used only if |cur_tok| represents the token to be
-replaced. Some applications of \TeX\ use this procedure a lot,
-so it has been slightly optimized for speed.
-@^inner loop@>
+/*tex
+
+Sometimes \TeX\ has read too far and wants to ``unscan'' what it has seen. The
+|back_input| procedure takes care of this by putting the token just scanned back
+into the input stream, ready to be read again. This procedure can be used only if
+|cur_tok| represents the token to be replaced. Some applications of \TeX\ use
+this procedure a lot, so it has been slightly optimized for speed. @^inner loop@>
 
-@c
+*/
 
 /* undoes one token of input */
 
 void back_input(void)
 {
-    halfword p; /* a token list of length one */
+    /*tex A token list of length one: */
+    halfword p;
     while ((istate == token_list) && (iloc == null) && (token_type != v_template)) {
-        /* conserve stack space */
+        /*tex Conserve stack space. */
         end_token_list();
     }
     p = get_avail();
@@ -512,14 +607,18 @@ void back_input(void)
             incr(align_state);
     }
     push_input();
+    /*tex This is |back_list(p)|, without procedure overhead: */
     istate = token_list;
     istart = p;
     token_type = backed_up;
-    iloc = p;                   /* that was |back_list(p)|, without procedure overhead */
+    iloc = p;
 }
 
-@ Insert token |p| into \TeX's input
-@c
+/*tex
+
+Insert token |p| into \TeX's input
+
+*/
 
 void reinsert_token(boolean a, halfword pp)
 {
@@ -545,13 +644,15 @@ void reinsert_token(boolean a, halfword pp)
     cur_tok = t;
 }
 
-@ The |begin_file_reading| procedure starts a new level of input for lines
-of characters to be read from a file, or as an insertion from the
-terminal. It does not take care of opening the file, nor does it set |loc|
-or |limit| or |line|.
+/*tex
+
+The |begin_file_reading| procedure starts a new level of input for lines of
+characters to be read from a file, or as an insertion from the terminal. It does
+not take care of opening the file, nor does it set |loc| or |limit| or |line|.
 @^system dependencies@>
 
-@c
+*/
+
 void begin_file_reading(void)
 {
     if (in_open == max_in_open)
@@ -569,48 +670,59 @@ void begin_file_reading(void)
     line_stack[iindex] = line;
     istart = first;
     istate = mid_line;
-    iname = 0;                  /* |terminal_input| is now |true| */
+    iname = 0;
+    /*tex Variable |terminal_input| is now |true|. */
     line_catcode_table = DEFAULT_CAT_TABLE;
     line_partial = false;
-    /* Prepare terminal input {\sl Sync\TeX} information */
+    /*tex Prepare terminal input \SYNCTEX\ information. */
     synctex_tag = 0;
 }
 
-@ Conversely, the variables must be downdated when such a level of input
-is finished:
+/*tex
+
+Conversely, the variables must be downdated when such a level of input is
+finished:
+
+*/
 
-@c
 void end_file_reading(void)
 {
     first = istart;
     line = line_stack[iindex];
-    if ((iname >= 18) && (iname <= 20))
+    if ((iname >= 18) && (iname <= 20)) {
         pseudo_close();
-    else if (iname == 21)
+    } else if (iname == 21) {
         luacstring_close(iindex);
-    else if (iname > 17)
-        lua_a_close_in(cur_file, 0);    /* forget it */
+    } else if (iname > 17) {
+        /*tex Forget it. */
+        lua_a_close_in(cur_file, 0);
+    }
     pop_input();
     decr(in_open);
 }
 
-@ In order to keep the stack from overflowing during a long sequence of
+/*tex
+
+In order to keep the stack from overflowing during a long sequence of
 inserted `\.{\\show}' commands, the following routine removes completed
 error-inserted lines from memory.
 
-@c
+*/
 void clear_for_error_prompt(void)
 {
-    while ((istate != token_list) && terminal_input
-           && (input_ptr > 0) && (iloc > ilimit))
+    while ((istate != token_list) && terminal_input && (input_ptr > 0) && (iloc > ilimit)) {
         end_file_reading();
+    }
     print_ln();
     clear_terminal();
 }
 
-@ To get \TeX's whole input mechanism going, we perform the following actions.
+/*tex
+
+To get \TeX's whole input mechanism going, we perform the following actions.
+
+*/
 
-@c
 void initialize_inputstack(void)
 {
     input_ptr = 0;
@@ -645,29 +757,29 @@ void initialize_inputstack(void)
     line_catcode_table = DEFAULT_CAT_TABLE;
     line_partial = false;
     align_state = 1000000;
-    if (!init_terminal())
-        exit(EXIT_FAILURE);     /* |goto final_end|; */
+    if (!init_terminal()) {
+        /*tex |goto final_end|; */
+        exit(EXIT_FAILURE);
+    }
+    /* |init_terminal| has set |loc| and |last| */
     ilimit = last;
-    first = last + 1;           /* |init_terminal| has set |loc| and |last| */
+    first = last + 1;
 }
 
-@ The global variable |pseudo_files| is used to maintain a stack of
-pseudo files.  The |pseudo_lines| field of each pseudo file points to
-a linked list of variable size nodes representing lines not yet
-processed: the |subtype| field contains the size of this node,
-all the following words contain ASCII codes.
+/*tex
 
-/*
+The global variable |pseudo_files| is used to maintain a stack of pseudo files.
+The |pseudo_lines| field of each pseudo file points to a linked list of variable
+size nodes representing lines not yet processed: the |subtype| field contains the
+size of this node, all the following words contain ASCII codes.
 
-    hh: todo: if this is really critical code (which it isn't) then we can
-    consider a c stack and store a pointer to a line in the line node instead
-    which saves splitting here and reconstructing later.
+If this is really critical code (which it isn't) then we can consider a c stack
+and store a pointer to a line in the line node instead which saves splitting here
+and reconstructing later.
 
 */
 
-
-@c
-halfword pseudo_files; /* stack of pseudo files */
+halfword pseudo_files;
 
 static halfword string_to_pseudo(str_number str, int nl)
 {
@@ -680,7 +792,8 @@ static halfword string_to_pseudo(str_number str, int nl)
     len = (unsigned) str_length(str);
     l = 0;
     while (l < len) {
-        unsigned m = l; /* start of current line */
+        /*tex start of current line */
+        unsigned m = l;
         while ((l < len) && (s[l] != nl))
             l++;
         sz = (int) (l - m + 7) / 4;
@@ -703,7 +816,8 @@ static halfword string_to_pseudo(str_number str, int nl)
         if (q == null) {
             pseudo_lines(h) = r;
         } else {
-            vlink(q) = r ; /* no prev node here so no couple_nodes !*/
+            /*tex There is no |prev| node here so no need to couple_nodes! */
+            vlink(q) = r ;
         }
         q = r ;
         if (s[l] == nl)
@@ -712,24 +826,33 @@ static halfword string_to_pseudo(str_number str, int nl)
     return h;
 }
 
-@ The |pseudo_start| procedure initiates reading from a pseudo file.
+/*tex
+
+The |pseudo_start| procedure initiates reading from a pseudo file.
+
+*/
 
-@c
 void pseudo_from_string(void)
 {
-    str_number s;  /* string to be converted into a pseudo file */
-    halfword p;    /* for list construction */
+    /*tex The string to be converted into a pseudo file: */
+    str_number s;
+    /*tex A helper for list construction: */
+    halfword p;
     s = make_string();
-    /* Convert string |s| into a new pseudo file */
+    /*tex Convert string |s| into a new pseudo file */
     p = string_to_pseudo(s, new_line_char_par);
     vlink(p) = pseudo_files;
     pseudo_files = p;
     flush_str(s);
-    /* Initiate input from new pseudo file */
-    begin_file_reading(); /* set up |cur_file| and new level of input */
+    /*tex
+        Initiate input from new pseudo file. It sets up |cur_file| and a new level
+        of input
+    */
+    begin_file_reading();
     line = 0;
     ilimit = istart;
-    iloc = ilimit + 1; /* force line read */
+    /*tex force line read */
+    iloc = ilimit + 1;
     if (tracing_scan_tokens_par > 0) {
         if (term_offset > max_print_line - 3)
             print_ln();
@@ -742,7 +865,7 @@ void pseudo_from_string(void)
     } else {
         iname = 18;
     }
-    /* Prepare pseudo file {\sl Sync\TeX} information */
+    /*tex Prepare pseudo file \SYNCTEX\ information. */
     synctex_tag = 0;
 }
 
@@ -759,29 +882,37 @@ void pseudo_start(void)
     pseudo_from_string();
 }
 
-@ @c
 void lua_string_start(void)
 {
-    begin_file_reading(); /* set up |cur_file| and new level of input */
+    /*tex Set up |cur_file| and a new level of input: */
+    begin_file_reading();
     line = 0;
     ilimit = istart;
-    iloc = ilimit + 1; /* force line read */
+    /*tex Force line read: */
+    iloc = ilimit + 1;
     iname = 21;
     luacstring_start(iindex);
 }
 
-@ Here we read a line from the current pseudo file into |buffer|.
+/*tex
 
-@c
-/* inputs the next line or returns |false| */
+Here we read a line from the current pseudo file into |buffer|.
+It inputs the next line or returns |false|.
+
+*/
 
 boolean pseudo_input(void)
 {
-    halfword p;      /* current line from pseudo file */
-    int sz;          /* size of node |p| */
-    four_quarters w; /* four ASCII codes */
-    halfword r;      /* loop index */
-    last = first;    /* cf.\ Matthew 19\thinspace:\thinspace30 */
+    /*tex The current line from pseudo file: */
+    halfword p;
+    /*tex The size of node |p|: */
+    int sz;
+    /*tex Four ASCII codes: */
+    four_quarters w;
+    /*tex The loop index: */
+    halfword r;
+    /*tex cf.\ Matthew 19\thinspace:\thinspace30 */
+    last = first;
     p = pseudo_lines(pseudo_files);
     if (p == null) {
         return false;
@@ -808,10 +939,11 @@ boolean pseudo_input(void)
     return true;
 }
 
-@ When we are done with a pseudo file we `close' it.
+/*tex
+
+When we are done with a pseudo file we `close' it.
 
-@c
-/* close the top level pseudo file */
+*/
 
 void pseudo_close(void)
 {
diff --git a/texk/web2c/luatexdir/tex/linebreak.c b/texk/web2c/luatexdir/tex/linebreak.c
new file mode 100644
index 000000000..df13931e1
--- /dev/null
+++ b/texk/web2c/luatexdir/tex/linebreak.c
@@ -0,0 +1,2520 @@
+/*
+
+Copyright 2006-2008 Taco Hoekwater <taco@luatex.org>
+
+This file is part of LuaTeX.
+
+LuaTeX is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 2 of the License, or (at your
+option) any later version.
+
+LuaTeX is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+License for more details.
+
+You should have received a copy of the GNU General Public License along
+with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#include "ptexlib.h"
+
+/*tex
+
+    We come now to what is probably the most interesting algorithm of \TeX: the
+    mechanism for choosing the ``best possible'' breakpoints that yield the
+    individual lines of a paragraph. \TeX's line-breaking algorithm takes a given
+    horizontal list and converts it to a sequence of boxes that are appended to
+    the current vertical list. In the course of doing this, it creates a special
+    data structure containing three kinds of records that are not used elsewhere
+    in \TeX. Such nodes are created while a paragraph is being processed, and
+    they are destroyed afterwards; thus, the other parts of \TeX\ do not need to
+    know anything about how line-breaking is done.
+
+    The method used here is based on an approach devised by Michael F. Plass and
+    the author in 1977, subsequently generalized and improved by the same two
+    people in 1980. A detailed discussion appears in {\sl SOFTWARE---Practice
+    \AM\ Experience \bf11} (1981), 1119--1184, where it is shown that the
+    line-breaking problem can be regarded as a special case of the problem of
+    computing the shortest path in an acyclic network. The cited paper includes
+    numerous examples and describes the history of line breaking as it has been
+    practiced by printers through the ages. The present implementation adds two
+    new ideas to the algorithm of 1980: Memory space requirements are
+    considerably reduced by using smaller records for inactive nodes than for
+    active ones, and arithmetic overflow is avoided by using ``delta distances''
+    instead of keeping track of the total distance from the beginning of the
+    paragraph to the current point.
+
+    The |line_break| procedure should be invoked only in horizontal mode; it
+    leaves that mode and places its output into the current vlist of the
+    enclosing vertical mode (or internal vertical mode). There is one explicit
+    parameter: |d| is true for partial paragraphs preceding display math mode; in
+    this case the amount of additional penalty inserted before the final line is
+    |display_widow_penalty| instead of |widow_penalty|.
+
+    There are also a number of implicit parameters: The hlist to be broken starts
+    at |vlink(head)|, and it is nonempty. The value of |prev_graf| in the
+    enclosing semantic level tells where the paragraph should begin in the
+    sequence of line numbers, in case hanging indentation or \.{\\parshape} are
+    in use; |prev_graf| is zero unless this paragraph is being continued after a
+    displayed formula. Other implicit parameters, such as the |par_shape_ptr| and
+    various penalties to use for hyphenation, etc., appear in |eqtb|.
+
+    After |line_break| has acted, it will have updated the current vlist and the
+    value of |prev_graf|. Furthermore, the global variable |just_box| will point
+    to the final box created by |line_break|, so that the width of this line can
+    be ascertained when it is necessary to decide whether to use
+    |above_display_skip| or |above_display_short_skip| before a displayed
+    formula.
+
+*/
+
+/*tex The |hlist_node| for the last line of the new paragraph: */
+
+halfword just_box;
+
+/*tex
+
+    In it's complete form, |line_break| is a rather lengthy procedure---sort of a
+    small world unto itself---we must build it up little by little. Below you see
+    only the general outline.
+
+    The main task performed here is to move the list from |head| to |temp_head|
+    and go into the enclosing semantic level. We also append the
+    \.{\\parfillskip} glue to the end of the paragraph, removing a space (or
+    other glue node) if it was there, since spaces usually precede blank lines
+    and instances of `\.{\$\$}'. The |par_fill_skip| is preceded by an infinite
+    penalty, so it will never be considered as a potential breakpoint.
+
+    That code assumes that a |glue_node| and a |penalty_node| occupy the same
+    number of |mem|~words.
+
+    Most other processing is delegated to external functions.
+
+*/
+
+void line_break(boolean d, int line_break_context)
+{
+    /*tex Main direction of paragraph: */
+    int paragraph_dir = 0;
+    halfword final_par_glue;
+    halfword start_of_par;
+    int callback_id;
+    /*tex this is for over/underfull box messages */
+    pack_begin_line = cur_list.ml_field;
+    alink(temp_head) = null;
+    vlink(temp_head) = vlink(cur_list.head_field);
+    new_hyphenation(temp_head, cur_list.tail_field);
+    cur_list.tail_field = new_ligkern(temp_head, cur_list.tail_field);
+    if (is_char_node(cur_list.tail_field)) {
+        tail_append(new_penalty(inf_penalty,line_penalty));
+    } else if (type(cur_list.tail_field) != glue_node) {
+        tail_append(new_penalty(inf_penalty,line_penalty));
+    } else {
+        halfword t = alink(cur_list.tail_field);
+		flush_node(cur_list.tail_field);
+		cur_list.tail_field = t;
+		tail_append(new_penalty(inf_penalty,line_penalty));
+    }
+    final_par_glue = new_param_glue(par_fill_skip_code);
+    couple_nodes(cur_list.tail_field, final_par_glue);
+    cur_list.tail_field = vlink(cur_list.tail_field);
+    lua_node_filter(pre_linebreak_filter_callback, line_break_context, temp_head, addressof(cur_list.tail_field));
+    last_line_fill = cur_list.tail_field;
+    pop_nest();
+    start_of_par = cur_list.tail_field;
+    callback_id = callback_defined(linebreak_filter_callback);
+    if (callback_id > 0) {
+        callback_id = lua_linebreak_callback(d, temp_head, addressof(cur_list.tail_field));
+        if (callback_id > 0) {
+            /*tex find the correct value for the |just_box| */
+            halfword box_search = cur_list.tail_field;
+            just_box  = null;
+            if (box_search != null) {
+                do {
+                    if (type(box_search) == hlist_node) {
+                       just_box = box_search;
+                    }
+                    box_search = vlink(box_search);
+                } while (box_search != null);
+            }
+            if (just_box == null) {
+                help3(
+                    "A linebreaking routine should return a non-empty list of nodes",
+                    "and at least one of those has to be a \\hbox.",
+                    "Sorry, I cannot recover from this."
+                );
+                print_err("Invalid linebreak_filter");
+                succumb();
+            }
+        } else {
+            if (tracing_paragraphs_par > 0) {
+                begin_diagnostic();
+                print_int(line);
+                end_diagnostic(true);
+            }
+        }
+    }
+    if (callback_id == 0) {
+        if ((!is_char_node(vlink(temp_head))) && ((type(vlink(temp_head)) == local_par_node))) {
+            paragraph_dir = local_par_dir(vlink(temp_head));
+        } else {
+            confusion("weird par dir");
+        }
+        ext_do_line_break(
+            paragraph_dir,
+            pretolerance_par,
+            tracing_paragraphs_par,
+            tolerance_par,
+            emergency_stretch_par,
+            looseness_par,
+            adjust_spacing_par,
+            par_shape_par_ptr,
+            adj_demerits_par,
+            protrude_chars_par,
+            line_penalty_par,
+            last_line_fit_par,
+            double_hyphen_demerits_par,
+            final_hyphen_demerits_par,
+            hang_indent_par,
+            hsize_par,
+            hang_after_par,
+            left_skip_par,
+            right_skip_par,
+            inter_line_penalties_par_ptr,
+            inter_line_penalty_par,
+            club_penalty_par,
+            club_penalties_par_ptr,
+            (d ? display_widow_penalties_par_ptr : widow_penalties_par_ptr),
+            (d ? display_widow_penalty_par : widow_penalty_par),
+            broken_penalty_par,
+            final_par_glue
+        );
+    }
+    lua_node_filter(post_linebreak_filter_callback, line_break_context, start_of_par, addressof(cur_list.tail_field));
+    pack_begin_line = 0;
+}
+
+/*tex
+
+    Glue nodes in a horizontal list that is being paragraphed are not supposed to
+    include ``infinite'' shrinkability; that is why the algorithm maintains four
+    registers for stretching but only one for shrinking. If the user tries to
+    introduce infinite shrinkability, the shrinkability will be reset to finite
+    and an error message will be issued. A boolean variable |no_shrink_error_yet|
+    prevents this error message from appearing more than once per paragraph.
+
+*/
+
+#define check_shrinkage(a) \
+    if ((shrink_order((a))!=normal)&&(shrink((a))!=0)) \
+        a=finite_shrink((a))
+
+/*tex Have we complained about infinite shrinkage? */
+
+static boolean no_shrink_error_yet;
+
+/*tex Recovers from infinite shrinkage. */
+
+static halfword finite_shrink(halfword p)
+{
+    const char *hlp[] = {
+        "The paragraph just ended includes some glue that has",
+        "infinite shrinkability, e.g., `\\hskip 0pt minus 1fil'.",
+        "Such glue doesn't belong there---it allows a paragraph",
+        "of any length to fit on one line. But it's safe to proceed,",
+        "since the offensive shrinkability has been made finite.",
+        NULL
+    };
+    if (no_shrink_error_yet) {
+        no_shrink_error_yet = false;
+        tex_error("Infinite glue shrinkage found in a paragraph", hlp);
+    }
+    shrink_order(p) = normal;
+    return p;
+}
+
+/*tex
+
+    A pointer variable |cur_p| runs through the given horizontal list as we look
+    for breakpoints. This variable is global, since it is used both by
+    |line_break| and by its subprocedure |try_break|.
+
+    Another global variable called |threshold| is used to determine the
+    feasibility of individual lines: breakpoints are feasible if there is a way
+    to reach them without creating lines whose badness exceeds |threshold|. (The
+    badness is compared to |threshold| before penalties are added, so that
+    penalty values do not affect the feasibility of breakpoints, except that no
+    break is allowed when the penalty is 10000 or more.) If |threshold| is 10000
+    or more, all legal breaks are considered feasible, since the |badness|
+    function specified above never returns a value greater than~10000.
+
+    Up to three passes might be made through the paragraph in an attempt to find
+    at least one set of feasible breakpoints. On the first pass, we have
+    |threshold=pretolerance| and |second_pass=final_pass=false|. If this pass
+    fails to find a feasible solution, |threshold| is set to |tolerance|,
+    |second_pass| is set |true|, and an attempt is made to hyphenate as many
+    words as possible. If that fails too, we add |emergency_stretch| to the
+    background stretchability and set |final_pass=true|.
+
+*/
+
+/*tex is this our second attempt to break this paragraph? */
+
+static boolean second_pass;
+
+/*tex is this our final attempt to break this paragraph? */
+
+static boolean final_pass;
+
+/*tex maximum badness on feasible lines */
+
+static int threshold;
+
+/*tex
+
+    The maximum fill level for |hlist_stack|. Maybe good if larger than |2 *
+    max_quarterword|, so that box nesting level would overflow first.
+
+*/
+
+#define max_hlist_stack 512
+
+/*tex stack for |find_protchar_left()| and |find_protchar_right()| */
+
+static halfword hlist_stack[max_hlist_stack];
+
+/*tex fill level for |hlist_stack| */
+
+static short hlist_stack_level = 0;
+
+static void push_node(halfword p)
+{
+    if (hlist_stack_level >= max_hlist_stack)
+        normal_error("push_node","stack overflow");
+    hlist_stack[hlist_stack_level++] = p;
+}
+
+static halfword pop_node(void)
+{
+    if (hlist_stack_level <= 0) {
+        /*tex This can point to some bug. */
+        normal_error("pop_node","stack underflow (internal error)");
+    }
+    return hlist_stack[--hlist_stack_level];
+}
+
+/*tex maximal stretch ratio of expanded fonts */
+
+static int max_stretch_ratio = 0;
+
+/*tex maximal shrink ratio of expanded fonts */
+
+static int max_shrink_ratio = 0;
+
+/*tex the current step of expanded fonts */
+
+static int cur_font_step = 0;
+
+static boolean check_expand_pars(internal_font_number f)
+{
+    int m;
+    if ((font_step(f) == 0) || ((font_max_stretch(f) == 0) && (font_max_shrink(f) == 0)))
+        return false;
+    if (cur_font_step < 0)
+        cur_font_step = font_step(f);
+    else if (cur_font_step != font_step(f))
+        normal_error("font expansion","using fonts with different step of expansion in one paragraph is not allowed");
+    m = font_max_stretch(f);
+    if (m != 0) {
+        if (max_stretch_ratio < 0)
+            max_stretch_ratio = m;
+        else if (max_stretch_ratio != m)
+            normal_error("font expansion","using fonts with different limit of expansion in one paragraph is not allowed");
+    }
+    m = font_max_shrink(f);
+    if (m != 0) {
+        if (max_shrink_ratio < 0)
+            max_shrink_ratio = -m;
+        else if (max_shrink_ratio != -m)
+            normal_error("font expansion","using fonts with different limit of expansion in one paragraph is not allowed");
+    }
+    return true;
+}
+
+/*tex Search left to right from list head |l|, returns 1st non-skipable item */
+
+halfword find_protchar_left(halfword l, boolean d)
+{
+    halfword t;
+    boolean run;
+    boolean done = false ;
+    while ((vlink(l) != null) && (type(l) == hlist_node) && zero_dimensions(l) && (list_ptr(l) == null)) {
+        /*tex For paragraph start with \.{\\parindent} = 0pt or any empty hbox. */
+        l = vlink(l);
+        done = true ;
+    }
+    if ((!done) && (type(l) == local_par_node)) {
+        l = vlink(l);
+        done = true ;
+    }
+    if ((!done) && d) {
+        while ((vlink(l) != null) && (!(is_char_node(l) || non_discardable(l)))) {
+            /*tex standard discardables at line break, \TeX book, p 95 */
+            l = vlink(l);
+        }
+    }
+    if (type(l) != glyph_node) {
+        hlist_stack_level = 0;
+        run = true;
+        do {
+            t = l;
+            while (run && (type(l) == hlist_node) && (list_ptr(l) != null)) {
+                push_node(l);
+                l = list_ptr(l);
+            }
+            while (run && cp_skipable(l)) {
+                while ((vlink(l) == null) && (hlist_stack_level > 0)) {
+                    /*tex Don't visit this node again. */
+                    l = pop_node();
+                    run = false;
+                }
+                if ((vlink(l) != null) && (type(l) == boundary_node) && (subtype(l) == protrusion_boundary) &&
+                        ((boundary_value(l) == 1) || (boundary_value(l) == 3))) {
+                    /*tex Skip next node. */
+                    l = vlink(l);
+                }
+                if (vlink(l) != null) {
+                    l = vlink(l);
+                } else if (hlist_stack_level == 0) {
+                    run = false;
+                }
+            }
+        } while (t != l);
+    }
+    return l;
+}
+
+/*tex
+
+    Search right to left from list tail |r| to head |l|, returns 1st non-skipable
+    item.
+
+*/
+
+halfword find_protchar_right(halfword l, halfword r)
+{
+    halfword t;
+    boolean run = true;
+    if (r == null)
+        return null;
+    hlist_stack_level = 0;
+    do {
+        t = r;
+        while (run && (type(r) == hlist_node) && (list_ptr(r) != null)) {
+            push_node(l);
+            push_node(r);
+            l = list_ptr(r);
+            r = l;
+            while (vlink(r) != null) {
+                halfword s = r;
+                r = vlink(r);
+                alink(r) = s;
+            }
+        }
+        while (run && cp_skipable(r)) {
+            while ((r == l) && (hlist_stack_level > 0)) {
+                /*tex Don't visit this node again. */
+                r = pop_node();
+                l = pop_node();
+            }
+            if ((r != l) && (r != null)) {
+                if ((alink(r) != null) && (type(r) == boundary_node) && (subtype(r) == protrusion_boundary) &&
+                        ((boundary_value(r) == 2) || (boundary_value(r) == 3))) {
+                    /*tex Skip next node. */
+                    r = alink(r);
+                }
+                if (alink(r) != null) {
+                    r = alink(r);
+                } else {
+                    /*tex This is the input: \.{\\leavevmode\\penalty-10000\\penalty-10000} (bug \#268). */
+                    run = false;
+                }
+            } else if ((r == l) && (hlist_stack_level == 0))
+                run = false;
+        }
+    } while (t != r);
+    return r;
+}
+
+#define left_pw(a) char_pw((a), left_side)
+#define right_pw(a) char_pw((a), right_side)
+
+/*tex
+
+    When looking for optimal line breaks, \TeX\ creates a ``break node'' for each
+    break that is {\sl feasible}, in the sense that there is a way to end a line
+    at the given place without requiring any line to stretch more than a given
+    tolerance. A break node is characterized by three things: the position of the
+    break (which is a pointer to a |glue_node|, |math_node|, |penalty_node|, or
+    |disc_node|); the ordinal number of the line that will follow this
+    breakpoint; and the fitness classification of the line that has just ended,
+    i.e., |tight_fit|, |decent_fit|, |loose_fit|, or |very_loose_fit|.
+
+*/
+
+typedef enum {
+    /*tex fitness classification for lines stretching more than their stretchability */
+    very_loose_fit = 0,
+    /*tex fitness classification for lines stretching 0.5 to 1.0 of their stretchability */
+    loose_fit,
+    /*tex fitness classification for all other lines */
+    decent_fit,
+    /*tex fitness classification for lines shrinking 0.5 to 1.0 of their shrinkability */
+    tight_fit
+} fitness_value;
+
+/*tex
+
+    The algorithm essentially determines the best possible way to achieve each
+    feasible combination of position, line, and fitness. Thus, it answers
+    questions like, ``What is the best way to break the opening part of the
+    paragraph so that the fourth line is a tight line ending at such-and-such a
+    place?'' However, the fact that all lines are to be the same length after a
+    certain point makes it possible to regard all sufficiently large line numbers
+    as equivalent, when the looseness parameter is zero, and this makes it
+    possible for the algorithm to save space and time.
+
+    An ``active node'' and a ``passive node'' are created in |mem| for each
+    feasible breakpoint that needs to be considered. Active nodes are three words
+    long and passive nodes are two words long. We need active nodes only for
+    breakpoints near the place in the paragraph that is currently being examined,
+    so they are recycled within a comparatively short time after they are
+    created.
+
+    An active node for a given breakpoint contains six fields:
+
+    \startitemize[n]
+
+        \startitem
+            |vlink| points to the next node in the list of active nodes; the last
+            active node has |vlink=active|.
+        \stopitem
+
+        \startitem
+            |break_node| points to the passive node associated with this
+            breakpoint.
+        \stopitem
+
+        \startitem
+            |line_number| is the number of the line that follows this breakpoint.
+        \stopitem
+
+        \startitem
+            |fitness| is the fitness classification of the line ending at this
+            breakpoint.
+        \stopitem
+
+        \startitem
+            |type| is either |hyphenated_node| or |unhyphenated_node|, depending
+            on whether this breakpoint is a |disc_node|.
+        \stopitem
+
+        \startitem
+            |total_demerits| is the minimum possible sum of demerits over all
+            lines leading from the beginning of the paragraph to this breakpoint.
+        \stopitem
+
+    \stopitemize
+
+    The value of |vlink(active)| points to the first active node on a vlinked
+    list of all currently active nodes. This list is in order by |line_number|,
+    except that nodes with |line_number>easy_line| may be in any order relative
+    to each other.
+
+*/
+
+void initialize_active(void)
+{
+    type(active) = hyphenated_node;
+    line_number(active) = max_halfword;
+    /*tex The |subtype| is never examined. */
+    subtype(active) = 0;
+}
+
+/*tex
+
+    The passive node for a given breakpoint contains eight fields:
+
+    \startitemize
+
+        \startitem
+            |vlink| points to the passive node created just before this one, if
+            any, otherwise it is |null|.
+        \stopitem
+
+        \startitem
+            |cur_break| points to the position of this breakpoint in the
+            horizontal list for the paragraph being broken.
+        \stopitem
+
+        \startitem
+            |prev_break| points to the passive node that should precede this one
+            in an optimal path to this breakpoint.
+        \stopitem
+
+        \startitem
+            |serial| is equal to |n| if this passive node is the |n|th one
+            created during the current pass. (This field is used only when
+            printing out detailed statistics about the line-breaking
+            calculations.)
+        \stopitem
+
+        \startitem
+            |passive_pen_inter| holds the current \.{\\localinterlinepenalty}
+        \stopitem
+
+        \startitem
+            |passive_pen_broken| holds the current \.{\\localbrokenpenalty}
+        \stopitem
+
+    \stopitemize
+
+    There is a global variable called |passive| that points to the most recently
+    created passive node. Another global variable, |printed_node|, is used to
+    help print out the paragraph when detailed information about the
+    line-breaking computation is being displayed.
+
+*/
+
+/*tex most recent node on passive list */
+
+static halfword passive;
+
+/*tex most recent node that has been printed */
+
+static halfword printed_node;
+
+/*tex the number of passive nodes allocated on this pass */
+
+static halfword pass_number;
+
+/*tex
+
+    The active list also contains ``delta'' nodes that help the algorithm compute
+    the badness of individual lines. Such nodes appear only between two active
+    nodes, and they have |type=delta_node|. If |p| and |r| are active nodes and
+    if |q| is a delta node between them, so that |vlink(p)=q| and |vlink(q)=r|,
+    then |q| tells the space difference between lines in the horizontal list that
+    start after breakpoint |p| and lines that start after breakpoint |r|. In
+    other words, if we know the length of the line that starts after |p| and ends
+    at our current position, then the corresponding length of the line that
+    starts after |r| is obtained by adding the amounts in node~|q|. A delta node
+    contains seven scaled numbers, since it must record the net change in glue
+    stretchability with respect to all orders of infinity. The natural width
+    difference appears in |mem[q+1].sc|; the stretch differences in units of pt,
+    sfi, fil, fill, and filll appear in |mem[q+2..q+6].sc|; and the shrink
+    difference appears in |mem[q+7].sc|. The |subtype| field of a delta node is
+    not used.
+
+    Actually, we have two more fields that are used by |pdftex|.
+
+    As the algorithm runs, it maintains a set of seven delta-like registers for
+    the length of the line following the first active breakpoint to the current
+    position in the given hlist. When it makes a pass through the active list, it
+    also maintains a similar set of seven registers for the length following the
+    active breakpoint of current interest. A third set holds the length of an
+    empty line (namely, the sum of \.{\\leftskip} and \.{\\rightskip}); and a
+    fourth set is used to create new delta nodes.
+
+    When we pass a delta node we want to do operations like:
+
+    \starttyping
+    for k := 1 to 7 do
+        cur_active_width[k] := cur_active_width[k] + mem[q+k].sc|};
+    \stoptyping
+
+    and we want to do this without the overhead of |for| loops. The |do_all_six|
+    macro makes such six-tuples convenient.
+
+*/
+
+/*tex distance from first active node to~|cur_p| */
+
+static scaled active_width[10] = { 0 };
+
+/*tex length of an ``empty'' line */
+
+static scaled background[10] = { 0 };
+
+/*tex length being computed after current break */
+
+static scaled break_width[10] = { 0 };
+
+/*tex Make |auto_breaking| accessible out of |line_break|: */
+
+static boolean auto_breaking;
+
+/*tex
+
+    Let's state the principles of the delta nodes more precisely and concisely,
+    so that the following programs will be less obscure. For each legal
+    breakpoint~|p| in the paragraph, we define two quantities $\alpha(p)$ and
+    $\beta(p)$ such that the length of material in a line from breakpoint~|p| to
+    breakpoint~|q| is $\gamma+\beta(q)-\alpha(p)$, for some fixed $\gamma$.
+    Intuitively, $\alpha(p)$ and $\beta(q)$ are the total length of material from
+    the beginning of the paragraph to a point ``after'' a break at |p| and to a
+    point ``before'' a break at |q|; and $\gamma$ is the width of an empty line,
+    namely the length contributed by \.{\\leftskip} and \.{\\rightskip}.
+
+    Suppose, for example, that the paragraph consists entirely of alternating
+    boxes and glue skips; let the boxes have widths $x_1\ldots x_n$ and let the
+    skips have widths $y_1\ldots y_n$, so that the paragraph can be represented
+    by $x_1y_1\ldots x_ny_n$. Let $p_i$ be the legal breakpoint at $y_i$; then
+    $\alpha(p_i)=x_1+y_1+\cdots+x_i+y_i$, and $\beta(p_i)= x_1+y_1+\cdots+x_i$.
+    To check this, note that the length of material from $p_2$ to $p_5$, say, is
+    $\gamma+x_3+y_3+x_4+y_4+x_5=\gamma+\beta(p_5) -\alpha(p_2)$.
+
+    The quantities $\alpha$, $\beta$, $\gamma$ involve glue stretchability and
+    shrinkability as well as a natural width. If we were to compute $\alpha(p)$
+    and $\beta(p)$ for each |p|, we would need multiple precision arithmetic, and
+    the multiprecise numbers would have to be kept in the active nodes. \TeX\
+    avoids this problem by working entirely with relative differences or
+    ``deltas.'' Suppose, for example, that the active list contains
+    $a_1\,\delta_1\,a_2\,\delta_2\,a_3$, where the |a|'s are active breakpoints
+    and the $\delta$'s are delta nodes. Then $\delta_1=\alpha(a_1)-\alpha(a_2)$
+    and $\delta_2=\alpha(a_2)-\alpha(a_3)$. If the line breaking algorithm is
+    currently positioned at some other breakpoint |p|, the |active_width| array
+    contains the value $\gamma+\beta(p)-\alpha(a_1)$. If we are scanning through
+    the list of active nodes and considering a tentative line that runs from
+    $a_2$ to~|p|, say, the |cur_active_width| array will contain the value
+    $\gamma+\beta(p)-\alpha(a_2)$. Thus, when we move from $a_2$ to $a_3$, we
+    want to add $\alpha(a_2)-\alpha(a_3)$ to |cur_active_width|; and this is just
+    $\delta_2$, which appears in the active list between $a_2$ and $a_3$. The
+    |background| array contains $\gamma$. The |break_width| array will be used to
+    calculate values of new delta nodes when the active list is being updated.
+
+    The heart of the line-breaking procedure is `|try_break|', a subroutine that
+    tests if the current breakpoint |cur_p| is feasible, by running through the
+    active list to see what lines of text can be made from active nodes
+    to~|cur_p|. If feasible breaks are possible, new break nodes are created. If
+    |cur_p| is too far from an active node, that node is deactivated.
+
+    The parameter |pi| to |try_break| is the penalty associated with a break at
+    |cur_p|; we have |pi=eject_penalty| if the break is forced, and
+    |pi=inf_penalty| if the break is illegal.
+
+    The other parameter, |break_type|, is set to |hyphenated_node| or
+    |unhyphenated_node|, depending on whether or not the current break is at a
+    |disc_node|. The end of a paragraph is also regarded as `|hyphenated_node|';
+    this case is distinguishable by the condition |cur_p=null|.
+
+*/
+
+/*tex running \.{\\localinterlinepenalty} */
+
+static int internal_pen_inter;
+
+/*tex running \.{\\localbrokenpenalty} */
+
+static int internal_pen_broken;
+
+/*tex running \.{\\localleftbox} */
+
+static halfword internal_left_box;
+
+/*tex running \.{\\localleftbox} width */
+
+static int internal_left_box_width;
+
+/*tex running \.{\\localleftbox} */
+
+static halfword init_internal_left_box;
+
+/*tex running \.{\\localleftbox} width */
+
+static int init_internal_left_box_width;
+
+/*tex running \.{\\localrightbox} */
+
+static halfword internal_right_box;
+
+/*tex running \.{\\localrightbox} width */
+
+static int internal_right_box_width;
+
+/*tex the length of discretionary material preceding a break */
+
+static scaled disc_width[10] = { 0 };
+
+/*tex
+
+    As we consider various ways to end a line at |cur_p|, in a given line number
+    class, we keep track of the best total demerits known, in an array with one
+    entry for each of the fitness classifications. For example,
+    |minimal_demerits[tight_fit]| contains the fewest total demerits of feasible
+    line breaks ending at |cur_p| with a |tight_fit| line;
+    |best_place[tight_fit]| points to the passive node for the break
+    before~|cur_p| that achieves such an optimum; and |best_pl_line[tight_fit]|
+    is the |line_number| field in the active node corresponding to
+    |best_place[tight_fit]|. When no feasible break sequence is known, the
+    |minimal_demerits| entries will be equal to |awful_bad|, which is $2^{30}-1$.
+    Another variable, |minimum_demerits|, keeps track of the smallest value in
+    the |minimal_demerits| array.
+
+*/
+
+/*tex best total demerits known for current line class and position, given the fitness */
+
+static int minimal_demerits[4];
+
+/*tex best total demerits known for current line class and position */
+
+static int minimum_demerits;
+
+/*tex how to achieve  |minimal_demerits| */
+
+static halfword best_place[4];
+
+/*tex corresponding line number */
+
+static halfword best_pl_line[4];
+
+/*tex
+
+    The length of lines depends on whether the user has specified \.{\\parshape}
+    or \.{\\hangindent}. If |par_shape_ptr| is not null, it points to a
+    $(2n+1)$-word record in |mem|, where the |vinfo| in the first word contains
+    the value of |n|, and the other $2n$ words contain the left margins and line
+    lengths for the first |n| lines of the paragraph; the specifications for line
+    |n| apply to all subsequent lines. If |par_shape_ptr=null|, the shape of the
+    paragraph depends on the value of |n=hang_after|; if |n>=0|, hanging
+    indentation takes place on lines |n+1|, |n+2|, \dots, otherwise it takes
+    place on lines 1, \dots, $\vert n\vert$. When hanging indentation is active,
+    the left margin is |hang_indent|, if |hang_indent>=0|, else it is 0; the line
+    length is $|hsize|-\vert|hang_indent|\vert$. The normal setting is
+    |par_shape_ptr=null|, |hang_after=1|, and |hang_indent=0|. Note that if
+    |hang_indent=0|, the value of |hang_after| is irrelevant.
+
+*/
+
+/*tex line numbers |>easy_line| are equivalent in break nodes */
+
+static halfword easy_line;
+
+/*tex line numbers |>last_special_line| all have the same width */
+
+static halfword last_special_line;
+
+/*tex the width of all lines |<=last_special_line|, if no \.{\\parshape} has been specified */
+
+static scaled first_width;
+
+/*tex the width of all lines |>last_special_line| */
+
+static scaled second_width;
+
+/*tex left margin to go with |first_width| */
+
+static scaled first_indent;
+
+/*tex left margin to go with |second_width| */
+
+static scaled second_indent;
+
+/*tex use this passive node and its predecessors */
+
+static halfword best_bet;
+
+/*tex the demerits associated with |best_bet| */
+
+static int fewest_demerits;
+
+/*tex line number following the last line of the new paragraph */
+
+static halfword best_line;
+
+/*tex the difference between |line_number(best_bet)| and the optimum |best_line| */
+
+static int actual_looseness;
+
+/*tex the difference between the current line number and the optimum |best_line| */
+
+static int line_diff;
+
+/*tex
+
+    \TeX\ makes use of the fact that |hlist_node|, |vlist_node|, |rule_node|,
+    |ins_node|, |mark_node|, |adjust_node|, |disc_node|, |whatsit_node|, and
+    |math_node| are at the low end of the type codes, by permitting a break at
+    glue in a list if and only if the |type| of the previous node is less than
+    |math_node|. Furthermore, a node is discarded after a break if its type is
+    |math_node| or~more.
+
+*/
+
+#define do_all_six(a) a(1);a(2);a(3);a(4);a(5);a(6);a(7)
+#define do_seven_eight(a) if (adjust_spacing > 1) { a(8);a(9); }
+#define do_all_eight(a) do_all_six(a); do_seven_eight(a)
+#define do_one_seven_eight(a) a(1); do_seven_eight(a)
+
+#define store_background(a) {active_width[a]=background[a];}
+
+#define kern_break() { \
+    if ((!is_char_node(vlink(cur_p))) && auto_breaking) \
+        if (type(vlink(cur_p))==glue_node) \
+            ext_try_break(\
+                0, \
+                unhyphenated_node, \
+                line_break_dir, \
+                adjust_spacing, \
+                par_shape_ptr, \
+                adj_demerits, \
+                tracing_paragraphs, \
+                protrude_chars, \
+                line_penalty, \
+                last_line_fit, \
+                double_hyphen_demerits, \
+                final_hyphen_demerits, \
+                first_p, \
+                cur_p \
+            ); \
+    if (type(cur_p)!=math_node) \
+        active_width[1] += width(cur_p); \
+    else \
+        active_width[1] += surround(cur_p); \
+}
+
+#define clean_up_the_memory() { \
+    q=vlink(active); \
+    while (q!=active) { \
+        cur_p = vlink(q); \
+        if (type(q)==delta_node) \
+            flush_node(q); \
+        else \
+            flush_node(q); \
+        q = cur_p; \
+    } \
+    q = passive;  \
+    while (q!=null) { \
+        cur_p = vlink(q); \
+        flush_node(q); \
+        q = cur_p; \
+    } \
+}
+
+/*tex special algorithm for last line of paragraph? */
+
+static boolean do_last_line_fit;
+
+/*tex infinite stretch components of  |par_fill_skip| */
+
+static scaled fill_width[4];
+
+/*tex |shortfall|  corresponding to |minimal_demerits| */
+
+static scaled best_pl_short[4];
+
+/*tex corresponding glue stretch or shrink */
+
+static scaled best_pl_glue[4];
+
+#define reset_disc_width(a) disc_width[(a)] = 0
+
+#define add_disc_width_to_break_width(a)     break_width[(a)] += disc_width[(a)]
+#define sub_disc_width_from_active_width(a)  active_width[(a)] -= disc_width[(a)]
+
+#define add_char_shrink(a,b)  a += char_shrink((b))
+#define add_char_stretch(a,b) a += char_stretch((b))
+#define sub_char_shrink(a,b)  a -= char_shrink((b))
+#define sub_char_stretch(a,b) a -= char_stretch((b))
+
+#define add_kern_shrink(a,b)  a += kern_shrink((b))
+#define add_kern_stretch(a,b) a += kern_stretch((b))
+#define sub_kern_shrink(a,b)  a -= kern_shrink((b))
+#define sub_kern_stretch(a,b) a -= kern_stretch((b))
+
+/*tex
+
+    This function is used to add the width of a list of nodes (from a
+    discretionary) to one of the width arrays.
+
+    Replacement texts and discretionary texts are supposed to contain only
+    character nodes, kern nodes, and box or rule nodes.
+
+*/
+
+#define bad_node_in_disc_error(p) { \
+    if (type(p) == whatsit_node) { \
+        formatted_error("linebreak","invalid node with type %s and subtype %i found in discretionary",node_data[type(p)].name,subtype(p)); \
+    } else { \
+        formatted_error("linebreak","invalid node with type %s found in discretionary",node_data[type(p)].name); \
+    } \
+}
+
+static void add_to_widths(halfword s, int line_break_dir, int adjust_spacing, scaled * widths)
+{
+    while (s != null) {
+        if (is_char_node(s)) {
+            widths[1] += pack_width(line_break_dir, dir_TRT, s, true);
+            if ((adjust_spacing > 1) && check_expand_pars(font(s))) {
+                set_prev_char_p(s);
+                add_char_stretch(widths[8], s);
+                add_char_shrink(widths[9], s);
+            };
+        } else {
+            switch (type(s)) {
+                case hlist_node:
+                case vlist_node:
+                    widths[1] += pack_width(line_break_dir, box_dir(s), s, false);
+                    break;
+                case kern_node:
+                    if ((adjust_spacing == 2) && (subtype(s) == normal)) {
+                        add_kern_stretch(widths[8], s);
+                        add_kern_shrink(widths[9], s);
+                    }
+                    /*tex fall through */
+                case rule_node:
+                    widths[1] += width(s);
+                    break;
+                case disc_node:
+                    break;
+                default:
+                    bad_node_in_disc_error(s);
+                    break;
+            }
+        }
+        s = vlink(s);
+    }
+}
+
+/*tex
+
+    This function is used to substract the width of a list of nodes (from a
+    discretionary) from one of the width arrays. It is used only once, but
+    deserves it own function because of orthogonality with the |add_to_widths|
+    function.
+
+*/
+
+static void sub_from_widths(halfword s, int line_break_dir, int adjust_spacing, scaled * widths)
+{
+    while (s != null) {
+        /*tex Subtract the width of node |s| from |break_width|; */
+        if (is_char_node(s)) {
+            widths[1] -= pack_width(line_break_dir, dir_TRT, s, true);
+            if ((adjust_spacing > 1) && check_expand_pars(font(s))) {
+                set_prev_char_p(s);
+                sub_char_stretch(widths[8], s);
+                sub_char_shrink(widths[9], s);
+            }
+        } else {
+            switch (type(s)) {
+                case hlist_node:
+                case vlist_node:
+                    widths[1] -= pack_width(line_break_dir, box_dir(s), s, false);
+                    break;
+                case kern_node:
+                    if ((adjust_spacing == 2) && (subtype(s) == normal)) {
+                        sub_kern_stretch(widths[8], s);
+                        sub_kern_shrink(widths[9], s);
+                    }
+                    /*tex fall through */
+                case rule_node:
+                    widths[1] -= width(s);
+                    break;
+                case disc_node:
+                    break;
+                default:
+                    bad_node_in_disc_error(s);
+                    break;
+            }
+        }
+        s = vlink(s);
+    }
+}
+
+/*tex
+
+    When we insert a new active node for a break at |cur_p|, suppose this new
+    node is to be placed just before active node |a|; then we essentially want to
+    insert `$\delta\,|cur_p|\,\delta^\prime$' before |a|, where
+    $\delta=\alpha(a)-\alpha(|cur_p|)$ and
+    $\delta^\prime=\alpha(|cur_p|)-\alpha(a)$ in the notation explained above.
+    The |cur_active_width| array now holds $\gamma+\beta(|cur_p|)-\alpha(a)$; so
+    $\delta$ can be obtained by subtracting |cur_active_width| from the quantity
+    $\gamma+\beta(|cur_p|)- \alpha(|cur_p|)$. The latter quantity can be regarded
+    as the length of a line ``from |cur_p| to |cur_p|''; we call it the
+    |break_width| at |cur_p|.
+
+    The |break_width| is usually negative, since it consists of the background
+    (which is normally zero) minus the width of nodes following~|cur_p| that are
+    eliminated after a break. If, for example, node |cur_p| is a glue node, the
+    width of this glue is subtracted from the background; and we also look ahead
+    to eliminate all subsequent glue and penalty and kern and math nodes,
+    subtracting their widths as well.
+
+    Kern nodes do not disappear at a line break unless they are |explicit|.
+
+*/
+
+static void compute_break_width(int break_type, int line_break_dir, int adjust_spacing, halfword p)
+{
+    /*tex
+
+        Glue and other 'whitespace' to be skipped after a break; used if
+        unhyphenated, or |post_break==empty|.
+
+    */
+    halfword s = p;
+    if (break_type > unhyphenated_node && p != null) {
+        /*tex
+
+            Compute the discretionary |break_width| values.
+
+            When |p| is a discretionary break, the length of a line ``from |p| to
+            |p|'' has to be defined properly so that the other calculations work
+            out. Suppose that the pre-break text at |p| has length $l_0$, the
+            post-break text has length $l_1$, and the replacement text has length
+            |l|. Suppose also that |q| is the node following the replacement
+            text. Then length of a line from |p| to |q| will be computed as
+            $\gamma+\beta(q)-\alpha(|p|)$, where $\beta(q)=\beta(|p|)-l_0+l$. The
+            actual length will be the background plus $l_1$, so the length from
+            |p| to |p| should be $\gamma+l_0+l_1-l$. If the post-break text of
+            the discretionary is empty, a break may also discard~|q|; in that
+            unusual case we subtract the length of~|q| and any other nodes that
+            will be discarded after the discretionary break.
+
+            The value of $l_0$ need not be computed, since |line_break| will put
+            it into the global variable |disc_width| before calling |try_break|.
+
+            In case of nested discretionaries, we always follow the no-break
+            path, as we are talking about the breaking on {\it this} position.
+
+        */
+        sub_from_widths(vlink_no_break(p), line_break_dir, adjust_spacing, break_width);
+        add_to_widths(vlink_post_break(p), line_break_dir, adjust_spacing, break_width);
+        do_one_seven_eight(add_disc_width_to_break_width);
+        if (vlink_post_break(p) == null) {
+            /*tex no |post_break|: 'skip' any 'whitespace' following */
+            s = vlink(p);
+        } else {
+            s = null;
+        }
+    }
+    while (s != null) {
+        switch (type(s)) {
+            case math_node:
+                /*tex begin mathskip code */
+                if (glue_is_zero(s)) {
+                    break_width[1] -= surround(s);
+                    break;
+                } else {
+                    /*tex fall through */
+                }
+                /*tex end mathskip code */
+            case glue_node:
+                /*tex Subtract glue from |break_width|; */
+                break_width[1] -= width(s);
+                break_width[2 + stretch_order(s)] -= stretch(s);
+                break_width[7] -= shrink(s);
+                break;
+            case penalty_node:
+                break;
+            case kern_node:
+                if (subtype(s) != explicit_kern && subtype(s) != italic_kern)
+                    return;
+                else
+                    break_width[1] -= width(s);
+                break;
+            default:
+                return;
+        };
+        s = vlink(s);
+    }
+}
+
+static void print_break_node(halfword q, fitness_value fit_class, quarterword break_type, halfword cur_p)
+{
+    /*tex Print a symbolic description of the new break node. */
+    tprint_nl("@@");
+    print_int(serial(passive));
+    tprint(": line ");
+    print_int(line_number(q) - 1);
+    print_char('.');
+    print_int(fit_class);
+    if (break_type == hyphenated_node)
+        print_char('-');
+    tprint(" t=");
+    print_int(total_demerits(q));
+    if (do_last_line_fit) {
+        /*tex Print additional data in the new active node. */
+        tprint(" s=");
+        print_scaled(active_short(q));
+        if (cur_p == null)
+            tprint(" a=");
+        else
+            tprint(" g=");
+        print_scaled(active_glue(q));
+    }
+    tprint(" -> @");
+    if (prev_break(passive) == null)
+        print_char('0');
+    else
+        print_int(serial(prev_break(passive)));
+}
+
+static void print_feasible_break(halfword cur_p, pointer r, halfword b, int pi, int d, boolean artificial_demerits)
+{
+    /*tex
+
+        Print a symbolic description of this feasible break.
+
+    */
+    if (printed_node != cur_p) {
+        /*tex
+
+            Print the list between |printed_node| and |cur_p|, then set
+            |printed_node:=cur_p|.
+
+        */
+        tprint_nl("");
+        if (cur_p == null) {
+            short_display(vlink(printed_node));
+        } else {
+            halfword save_link = vlink(cur_p);
+            vlink(cur_p) = null;
+            tprint_nl("");
+            short_display(vlink(printed_node));
+            vlink(cur_p) = save_link;
+        }
+        printed_node = cur_p;
+    }
+    tprint_nl("@");
+    if (cur_p == null) {
+        tprint_esc("par");
+    } else if (type(cur_p) != glue_node) {
+        if (type(cur_p) == penalty_node)
+            tprint_esc("penalty");
+        else if (type(cur_p) == disc_node)
+            tprint_esc("discretionary");
+        else if (type(cur_p) == kern_node)
+            tprint_esc("kern");
+        else
+            tprint_esc("math");
+    }
+    tprint(" via @");
+    if (break_node(r) == null)
+        print_char('0');
+    else
+        print_int(serial(break_node(r)));
+    tprint(" b=");
+    if (b > inf_bad)
+        print_char('*');
+    else
+        print_int(b);
+    tprint(" p=");
+    print_int(pi);
+    tprint(" d=");
+    if (artificial_demerits)
+        print_char('*');
+    else
+        print_int(d);
+}
+
+#define add_disc_width_to_active_width(a)   active_width[a] += disc_width[a]
+#define update_width(a) cur_active_width[a] += varmem[(r+(a))].cint
+
+#define set_break_width_to_background(a) break_width[a]=background[(a)]
+
+#define convert_to_break_width(a) \
+  varmem[(prev_r+(a))].cint = varmem[(prev_r+(a))].cint-cur_active_width[(a)]+break_width[(a)]
+
+#define store_break_width(a) active_width[(a)]=break_width[(a)]
+
+#define new_delta_to_break_width(a) \
+  varmem[(q+(a))].cint=break_width[(a)]-cur_active_width[(a)]
+
+#define new_delta_from_break_width(a) \
+  varmem[(q+(a))].cint=cur_active_width[(a)]-break_width[(a)]
+
+#define copy_to_cur_active(a) cur_active_width[(a)]=active_width[(a)]
+
+#define combine_two_deltas(a) varmem[(prev_r+(a))].cint += varmem[(r+(a))].cint
+#define downdate_width(a) cur_active_width[(a)] -= varmem[(prev_r+(a))].cint
+#define update_active(a) active_width[(a)]+=varmem[(r+(a))].cint
+
+#define total_font_stretch cur_active_width[8]
+#define total_font_shrink cur_active_width[9]
+
+#define cal_margin_kern_var(a) { \
+    character(cp) = character((a)); \
+    font(cp) = font((a)); \
+    do_subst_font(cp, 1000); \
+    if (font(cp) != font((a))) \
+        margin_kern_stretch += (left_pw((a)) - left_pw(cp)); \
+    font(cp) = font((a)); \
+    do_subst_font(cp, -1000); \
+    if (font(cp) != font((a))) \
+        margin_kern_shrink += (left_pw(cp) - left_pw((a))); \
+}
+
+static void ext_try_break(
+    int pi,
+    quarterword break_type,
+    int line_break_dir,
+    int adjust_spacing,
+    int par_shape_ptr,
+    int adj_demerits,
+    int tracing_paragraphs,
+    int protrude_chars,
+    int line_penalty,
+    int last_line_fit,
+    int double_hyphen_demerits,
+    int final_hyphen_demerits, halfword first_p, halfword cur_p
+)
+{
+    /*tex runs through the active list */
+    pointer r;
+    scaled margin_kern_stretch;
+    scaled margin_kern_shrink;
+    halfword lp, rp, cp;
+    /*tex stays a step behind |r| */
+    halfword prev_r = active;
+    /*tex a step behind |prev_r|, if |type(prev_r)=delta_node| */
+    halfword prev_prev_r = null;
+    /*tex maximum line number in current equivalence class of lines */
+    halfword old_l = 0;
+    /*tex have we found a feasible break at |cur_p|? */
+    boolean no_break_yet = true;
+    /*tex points to a new node being created */
+    halfword q;
+    /*tex line number of current active node */
+    halfword l;
+    /*tex should node |r| remain in the active list? */
+    boolean node_r_stays_active;
+    /*tex the current line will be justified to this width */
+    scaled line_width = 0;
+    /*tex possible fitness class of test line */
+    fitness_value fit_class;
+    /*tex badness of test line */
+    halfword b;
+    /*tex demerits of test line */
+    int d;
+    /*tex has |d| been forced to zero? */
+    boolean artificial_demerits;
+    /*tex used in badness calculations */
+    scaled shortfall;
+    /*tex glue stretch or shrink of test line, adjustment for last line */
+    scaled g = 0;
+    /*tex distance from current active node */
+    scaled cur_active_width[10] = { 0 };
+    /*tex Make sure that |pi| is in the proper range; */
+    if (pi >= inf_penalty) {
+        /*tex this breakpoint is inhibited by infinite penalty */
+        return;
+    } else if (pi <= -inf_penalty) {
+        /*tex this breakpoint will be forced */
+        pi = eject_penalty;
+    }
+
+    do_all_eight(copy_to_cur_active);
+
+    while (1) {
+        r = vlink(prev_r);
+        /*tex
+
+            If node |r| is of type |delta_node|, update |cur_active_width|, set
+            |prev_r| and |prev_prev_r|, then |goto continue|. The following code
+            uses the fact that |type(active)<>delta_node|.
+
+        */
+        if (type(r) == delta_node) {
+            /*tex implicit */
+            do_all_eight(update_width);
+            prev_prev_r = prev_r;
+            prev_r = r;
+            continue;
+        }
+        /*tex
+
+            If a line number class has ended, create new active nodes for the
+            best feasible breaks in that class; then |return| if |r=active|,
+            otherwise compute the new |line_width|.
+
+            The first part of the following code is part of \TeX's inner loop, so
+            we don't want to waste any time. The current active node, namely node
+            |r|, contains the line number that will be considered next. At the
+            end of the list we have arranged the data structure so that
+            |r=active| and |line_number(active)>old_l|.
+
+        */
+        l = line_number(r);
+        if (l > old_l) {
+            /*tex now we are no longer in the inner loop */
+            if ((minimum_demerits < awful_bad)
+                && ((old_l != easy_line) || (r == active))) {
+                /*tex
+
+                    Create new active nodes for the best feasible breaks just
+                    found. It is not necessary to create new active nodes having
+                    |minimal_demerits| greater than
+                    |minimum_demerits+abs(adj_demerits)|, since such active nodes
+                    will never be chosen in the final paragraph breaks. This
+                    observation allows us to omit a substantial number of
+                    feasible breakpoints from further consideration.
+
+                */
+                if (no_break_yet) {
+                    no_break_yet = false;
+                    do_all_eight(set_break_width_to_background);
+                    compute_break_width(break_type, line_break_dir, adjust_spacing, cur_p);
+                }
+                /*tex
+
+                    Insert a delta node to prepare for breaks at |cur_p|. We use
+                    the fact that |type(active)<>delta_node|.
+
+                */
+                if (type(prev_r) == delta_node) {
+                    /*tex modify an existing delta node */
+                    do_all_eight(convert_to_break_width);
+                } else if (prev_r == active) {
+                    /*tex no delta node needed at the beginning */
+                    do_all_eight(store_break_width);
+                } else {
+                    q = new_node(delta_node, 0);
+                    vlink(q) = r;
+                    do_all_eight(new_delta_to_break_width);
+                    vlink(prev_r) = q;
+                    prev_prev_r = prev_r;
+                    prev_r = q;
+                }
+                if (abs(adj_demerits) >= awful_bad - minimum_demerits)
+                    minimum_demerits = awful_bad - 1;
+                else
+                    minimum_demerits += abs(adj_demerits);
+                for (fit_class = very_loose_fit; fit_class <= tight_fit;
+                     fit_class++) {
+                    if (minimal_demerits[fit_class] <= minimum_demerits) {
+                        /*tex
+
+                            Insert a new active node from |best_place[fit_class]|
+                            to |cur_p|. When we create an active node, we also
+                            create the corresponding passive node.
+
+                        */
+                        q = new_node(passive_node, 0);
+                        vlink(q) = passive;
+                        passive = q;
+                        cur_break(q) = cur_p;
+                        incr(pass_number);
+                        serial(q) = pass_number;
+                        prev_break(q) = best_place[fit_class];
+                        /*tex
+
+                            Here we keep track of the subparagraph penalties in
+                            the break nodes.
+
+                        */
+                        passive_pen_inter(q) = internal_pen_inter;
+                        passive_pen_broken(q) = internal_pen_broken;
+                        passive_last_left_box(q) = internal_left_box;
+                        passive_last_left_box_width(q) =
+                            internal_left_box_width;
+                        if (prev_break(q) != null) {
+                            passive_left_box(q) = passive_last_left_box(prev_break(q));
+                            passive_left_box_width(q) = passive_last_left_box_width(prev_break(q));
+                        } else {
+                            passive_left_box(q) = init_internal_left_box;
+                            passive_left_box_width(q) = init_internal_left_box_width;
+                        }
+                        passive_right_box(q) = internal_right_box;
+                        passive_right_box_width(q) = internal_right_box_width;
+                        q = new_node(break_type, fit_class);
+                        break_node(q) = passive;
+                        line_number(q) = best_pl_line[fit_class] + 1;
+                        total_demerits(q) = minimal_demerits[fit_class];
+                        if (do_last_line_fit) {
+                            /*tex
+
+                                Store additional data in the new active node.
+                                Here we save these data in the active node
+                                representing a potential line break.
+
+                            */
+                            active_short(q) = best_pl_short[fit_class];
+                            active_glue(q) = best_pl_glue[fit_class];
+                        }
+                        vlink(q) = r;
+                        vlink(prev_r) = q;
+                        prev_r = q;
+                        if (tracing_paragraphs > 0)
+                            print_break_node(q, fit_class, break_type, cur_p);
+                    }
+                    minimal_demerits[fit_class] = awful_bad;
+                }
+                minimum_demerits = awful_bad;
+                /*tex
+
+                    Insert a delta node to prepare for the next active node. When
+                    the following code is performed, we will have just inserted
+                    at least one active node before |r|, so
+                    |type(prev_r)<>delta_node|.
+
+                */
+                if (r != active) {
+                    q = new_node(delta_node, 0);
+                    vlink(q) = r;
+                    do_all_eight(new_delta_from_break_width);
+                    vlink(prev_r) = q;
+                    prev_prev_r = prev_r;
+                    prev_r = q;
+                }
+            }
+            if (r == active)
+                return;
+            /*tex
+
+                Compute the new line width. When we come to the following code,
+                we have just encountered the first active node~|r| whose
+                |line_number| field contains |l|. Thus we want to compute the
+                length of the $l\mskip1mu$th line of the current paragraph.
+                Furthermore, we want to set |old_l| to the last number in the
+                class of line numbers equivalent to~|l|.
+
+            */
+            if (l > easy_line) {
+                old_l = max_halfword - 1;
+                line_width = second_width;
+            } else {
+                old_l = l;
+                if (l > last_special_line) {
+                    line_width = second_width;
+                } else if (par_shape_ptr == null) {
+                    line_width = first_width;
+                } else {
+                    line_width = varmem[(par_shape_ptr + 2 * l + 1)].cint;
+                }
+            }
+        }
+        /*tex
+
+            If a line number class has ended, create new active nodes for the
+            best feasible breaks in that class; then |return| if |r=active|,
+            otherwise compute the new |line_width|.
+
+            Consider the demerits for a line from |r| to |cur_p|; deactivate node
+            |r| if it should no longer be active; then |goto continue| if a line
+            from |r| to |cur_p| is infeasible, otherwise record a new feasible
+            break.
+
+        */
+        artificial_demerits = false;
+        shortfall = line_width - cur_active_width[1];
+        if (break_node(r) == null)
+            shortfall -= init_internal_left_box_width;
+        else
+            shortfall -= passive_last_left_box_width(break_node(r));
+        shortfall -= internal_right_box_width;
+        if (protrude_chars > 1) {
+            halfword l1, o;
+            l1 = (break_node(r) == null) ? first_p : cur_break(break_node(r));
+            if (cur_p == null) {
+                o = null;
+            } else {
+                o = alink(cur_p);
+                assert(vlink(o) == cur_p);
+            }
+            /*tex
+
+                The disc could be a SELECT subtype, to we might need to get the
+                last character as |pre_break| from either the |pre_break| list
+                (if the previous INIT disc was taken), or the |no_break| (sic)
+                list (if the previous INIT disc was not taken).
+
+                The last characters (hyphenation character) if these two list
+                should always be the same anyway, so we just look at |pre_break|.
+
+                Let's look at the right margin first.
+
+            */
+            if ((cur_p != null) && (type(cur_p) == disc_node) && (vlink_pre_break(cur_p) != null)) {
+                /*tex a |disc_node| with non-empty |pre_break|, protrude the last char of |pre_break| */
+                o = tlink_pre_break(cur_p);
+            } else {
+                o = find_protchar_right(l1, o);
+            }
+            /*tex now the left margin */
+            if ((l1 != null) && (type(l1) == disc_node) && (vlink_post_break(l1) != null)) {
+                /*tex The first char could be a disc! Protrude the first char. */
+                l1 = vlink_post_break(l1);
+            } else {
+                l1 = find_protchar_left(l1, true);
+            }
+            shortfall += (left_pw(l1) + right_pw(o));
+        }
+        if (shortfall != 0) {
+            margin_kern_stretch = 0;
+            margin_kern_shrink = 0;
+            if (protrude_chars > 1) {
+                /*tex Calculate variations of marginal kerns. */
+                lp = last_leftmost_char;
+                rp = last_rightmost_char;
+                cp = raw_glyph_node();
+                if (lp != null) {
+                    cal_margin_kern_var(lp);
+                }
+                if (rp != null) {
+                    cal_margin_kern_var(rp);
+                }
+                flush_node(cp);
+            }
+            if ((shortfall > 0) && ((total_font_stretch + margin_kern_stretch) > 0)) {
+                if ((total_font_stretch + margin_kern_stretch) > shortfall)
+                    shortfall = ((total_font_stretch + margin_kern_stretch) / (max_stretch_ratio / cur_font_step)) / 2;
+                else
+                    shortfall -= (total_font_stretch + margin_kern_stretch);
+            } else if ((shortfall < 0) && ((total_font_shrink + margin_kern_shrink) > 0)) {
+                if ((total_font_shrink + margin_kern_shrink) > -shortfall)
+                    shortfall -= ((total_font_shrink + margin_kern_shrink) / (max_shrink_ratio / cur_font_step)) / 2;
+                else
+                    shortfall += (total_font_shrink + margin_kern_shrink);
+            }
+        }
+        if (shortfall > 0) {
+            /*tex
+
+                Set the value of |b| to the badness for stretching the line, and
+                compute the corresponding |fit_class|.
+
+                When a line must stretch, the available stretchability can be
+                found in the subarray |cur_active_width[2..6]|, in units of
+                points, sfi, fil, fill and filll.
+
+                The present section is part of \TeX's inner loop, and it is most
+                often performed when the badness is infinite; therefore it is
+                worth while to make a quick test for large width excess and small
+                stretchability, before calling the |badness| subroutine.
+
+            */
+            if ((cur_active_width[3] != 0) || (cur_active_width[4] != 0) ||
+                (cur_active_width[5] != 0) || (cur_active_width[6] != 0)) {
+                if (do_last_line_fit) {
+                    if (cur_p == null) {
+                        /*tex
+
+                            The last line of a paragraph. Perform computations
+                            for last line and |goto found|.
+
+                            Here we compute the adjustment |g| and badness |b|
+                            for a line from |r| to the end of the paragraph. When
+                            any of the criteria for adjustment is violated we
+                            fall through to the normal algorithm.
+
+                            The last line must be too short, and have infinite
+                            stretch entirely due to |par_fill_skip|.
+
+                        */
+                        if ((active_short(r) == 0) || (active_glue(r) <= 0))
+                            /*tex
+
+                                Previous line was neither stretched nor shrunk,
+                                or was infinitely bad.
+
+                            */
+                            goto NOT_FOUND;
+                        if ((cur_active_width[3] != fill_width[0]) || (cur_active_width[4] != fill_width[1]) ||
+                            (cur_active_width[5] != fill_width[2]) || (cur_active_width[6] != fill_width[3]))
+                            /*tex
+
+                                Infinite stretch of this line not entirely due to |par_fill_skip|.
+
+                            */
+                            goto NOT_FOUND;
+                        if (active_short(r) > 0)
+                            g = cur_active_width[2];
+                        else
+                            g = cur_active_width[7];
+                        if (g <= 0)
+                            /*tex No finite stretch resp.\ no shrink. */
+                            goto NOT_FOUND;
+                        arith_error = false;
+                        g = fract(g, active_short(r), active_glue(r),
+                                  max_dimen);
+                        if (last_line_fit < 1000)
+                            g = fract(g, last_line_fit, 1000, max_dimen);
+                        if (arith_error) {
+                            if (active_short(r) > 0)
+                                g = max_dimen;
+                            else
+                                g = -max_dimen;
+                        }
+                        if (g > 0) {
+                            /*tex
+
+                                Set the value of |b| to the badness of the last
+                                line for stretching, compute the corresponding
+                                |fit_class, and |goto found|. These badness
+                                computations are rather similar to those of the
+                                standard algorithm, with the adjustment amount
+                                |g| replacing the |shortfall|.
+
+                            */
+                            if (g > shortfall)
+                                g = shortfall;
+                            if (g > 7230584) {
+                                if (cur_active_width[2] < 1663497) {
+                                    b = inf_bad;
+                                    fit_class = very_loose_fit;
+                                    goto FOUND;
+                                }
+                            }
+                            b = badness(g, cur_active_width[2]);
+                            if (b > 99) {
+                                fit_class = very_loose_fit;
+                            } else if (b > 12) {
+                                fit_class = loose_fit;
+                            } else {
+                                fit_class = decent_fit;
+                            }
+                            goto FOUND;
+                        } else if (g < 0) {
+                            /*tex
+
+                                Set the value of |b| to the badness of the last
+                                line for shrinking, compute the corresponding
+                                |fit_class, and |goto found||.
+
+                            */
+                            if (-g > cur_active_width[7])
+                                g = -cur_active_width[7];
+                            b = badness(-g, cur_active_width[7]);
+                            if (b > 12)
+                                fit_class = tight_fit;
+                            else
+                                fit_class = decent_fit;
+                            goto FOUND;
+                        }
+                    }
+                  NOT_FOUND:
+                    shortfall = 0;
+                }
+                b = 0;
+                /*tex Infinite stretch. */
+                fit_class = decent_fit;
+            } else if (shortfall > 7230584 && cur_active_width[2] < 1663497) {
+                b = inf_bad;
+                fit_class = very_loose_fit;
+            } else {
+                b = badness(shortfall, cur_active_width[2]);
+                if (b > 99) {
+                    fit_class = very_loose_fit;
+                } else if (b > 12) {
+                    fit_class = loose_fit;
+                } else {
+                    fit_class = decent_fit;
+                }
+            }
+        } else {
+            /*tex
+
+                Set the value of |b| to the badness for shrinking the line, and
+                compute the corresponding |fit_class|. Shrinkability is never
+                infinite in a paragraph; we can shrink the line from |r| to
+                |cur_p| by at most |cur_active_width[7]|.
+
+            */
+            if (-shortfall > cur_active_width[7])
+                b = inf_bad + 1;
+            else
+                b = badness(-shortfall, cur_active_width[7]);
+            if (b > 12)
+                fit_class = tight_fit;
+            else
+                fit_class = decent_fit;
+        }
+        if (do_last_line_fit) {
+            /*tex Adjust the additional data for last line; */
+            if (cur_p == null)
+                shortfall = 0;
+            if (shortfall > 0) {
+                g = cur_active_width[2];
+            } else if (shortfall < 0) {
+                g = cur_active_width[7];
+            } else {
+                g = 0;
+            }
+        }
+      FOUND:
+        if ((b > inf_bad) || (pi == eject_penalty)) {
+            /*tex
+
+                Prepare to deactivate node~|r|, and |goto deactivate| unless
+                there is a reason to consider lines of text from |r| to |cur_p|.
+                During the final pass, we dare not lose all active nodes, lest we
+                lose touch with the line breaks already found. The code shown
+                here makes sure that such a catastrophe does not happen, by
+                permitting overfull boxes as a last resort. This particular part
+                of \TeX\ was a source of several subtle bugs before the correct
+                program logic was finally discovered; readers who seek to
+                ``improve'' \TeX\ should therefore think thrice before daring to
+                make any changes here.
+
+            */
+            if (final_pass && (minimum_demerits == awful_bad) &&
+                (vlink(r) == active) && (prev_r == active)) {
+                /*tex Set demerits zero, this break is forced. */
+                artificial_demerits = true;
+            } else if (b > threshold) {
+                goto DEACTIVATE;
+            }
+            node_r_stays_active = false;
+        } else {
+            prev_r = r;
+            if (b > threshold)
+                continue;
+            node_r_stays_active = true;
+        }
+        /*tex
+
+            Record a new feasible break. When we get to this part of the code,
+            the line from |r| to |cur_p| is feasible, its badness is~|b|, and its
+            fitness classification is |fit_class|. We don't want to make an
+            active node for this break yet, but we will compute the total
+            demerits and record them in the |minimal_demerits| array, if such a
+            break is the current champion among all ways to get to |cur_p| in a
+            given line-number class and fitness class.
+
+        */
+        if (artificial_demerits) {
+            d = 0;
+        } else {
+            /*tex Compute the demerits, |d|, from |r| to |cur_p|. */
+            d = line_penalty + b;
+            if (abs(d) >= 10000)
+                d = 100000000;
+            else
+                d = d * d;
+            if (pi != 0) {
+                if (pi > 0) {
+                    d += (pi * pi);
+                } else if (pi > eject_penalty) {
+                    d -= (pi * pi);
+                }
+            }
+            if ((break_type == hyphenated_node) && (type(r) == hyphenated_node)) {
+                if (cur_p != null)
+                    d += double_hyphen_demerits;
+                else
+                    d += final_hyphen_demerits;
+            }
+            if (abs(fit_class - fitness(r)) > 1)
+                d = d + adj_demerits;
+        }
+        if (tracing_paragraphs > 0) {
+            print_feasible_break(cur_p, r, b, pi, d, artificial_demerits);
+        }
+        /*tex This is the minimum total demerits from the beginning to |cur_p| via |r|. */
+        d += total_demerits(r);
+        if (d <= minimal_demerits[fit_class]) {
+            minimal_demerits[fit_class] = d;
+            best_place[fit_class] = break_node(r);
+            best_pl_line[fit_class] = l;
+            if (do_last_line_fit) {
+                /*tex
+
+                    Store additional data for this feasible break. For each
+                    feasible break we record the shortfall and glue stretch or
+                    shrink (or adjustment).
+
+                */
+                best_pl_short[fit_class] = shortfall;
+                best_pl_glue[fit_class] = g;
+            }
+            if (d < minimum_demerits)
+                minimum_demerits = d;
+        }
+        /*tex Record a new feasible break. */
+        if (node_r_stays_active) {
+            /*tex |prev_r| has been set to |r|. */
+            continue;
+        }
+      DEACTIVATE:
+        /*tex
+
+            Deactivate node |r|. When an active node disappears, we must delete
+            an adjacent delta node if the active node was at the beginning or the
+            end of the active list, or if it was surrounded by delta nodes. We
+            also must preserve the property that |cur_active_width| represents
+            the length of material from |vlink(prev_r)| to~|cur_p|.
+
+        */
+        vlink(prev_r) = vlink(r);
+        flush_node(r);
+        if (prev_r == active) {
+            /*tex
+
+                Update the active widths, since the first active node has been
+                deleted. The following code uses the fact that
+                |type(active)<>delta_node|. If the active list has just become
+                empty, we do not need to update the |active_width| array, since
+                it will be initialized when an active node is next inserted.
+
+            */
+            r = vlink(active);
+            if (type(r) == delta_node) {
+                do_all_eight(update_active);
+                do_all_eight(copy_to_cur_active);
+                vlink(active) = vlink(r);
+                flush_node(r);
+            }
+        } else if (type(prev_r) == delta_node) {
+            r = vlink(prev_r);
+            if (r == active) {
+                do_all_eight(downdate_width);
+                vlink(prev_prev_r) = active;
+                flush_node(prev_r);
+                prev_r = prev_prev_r;
+            } else if (type(r) == delta_node) {
+                do_all_eight(update_width);
+                do_all_eight(combine_two_deltas);
+                vlink(prev_r) = vlink(r);
+                flush_node(r);
+            }
+        }
+    }
+}
+
+void ext_do_line_break(
+    int paragraph_dir,
+    int pretolerance,
+    int tracing_paragraphs,
+    int tolerance,
+    scaled emergency_stretch,
+    int looseness,
+    int adjust_spacing,
+    halfword par_shape_ptr,
+    int adj_demerits,
+    int protrude_chars,
+    int line_penalty,
+    int last_line_fit,
+    int double_hyphen_demerits,
+    int final_hyphen_demerits,
+    int hang_indent,
+    int hsize,
+    int hang_after,
+    halfword left_skip,
+    halfword right_skip,
+    halfword inter_line_penalties_ptr,
+    int inter_line_penalty,
+    int club_penalty,
+    halfword club_penalties_ptr,
+    halfword widow_penalties_ptr,
+    int widow_penalty,
+    int broken_penalty,
+    halfword final_par_glue
+)
+{
+    /*tex Miscellaneous nodes of temporary interest. */
+    halfword cur_p, q, r, s;
+    int line_break_dir = paragraph_dir;
+    /*tex Get ready to start */
+    minimum_demerits = awful_bad;
+    minimal_demerits[tight_fit] = awful_bad;
+    minimal_demerits[decent_fit] = awful_bad;
+    minimal_demerits[loose_fit] = awful_bad;
+    minimal_demerits[very_loose_fit] = awful_bad;
+    fewest_demerits = 0;
+    actual_looseness = 0;
+    /*tex
+
+        We compute the values of |easy_line| and the other local variables
+        relating to line length when the |line_break| procedure is initializing
+        itself.
+
+    */
+    if (par_shape_ptr == null) {
+        if (hang_indent == 0) {
+            last_special_line = 0;
+            second_width = hsize;
+            second_indent = 0;
+        } else {
+            halfword used_hang_indent = swap_hang_indent(hang_indent);
+            /*tex
+
+                Set line length parameters in preparation for hanging
+                indentation. We compute the values of |easy_line| and the other
+                local variables relating to line length when the |line_break|
+                procedure is initializing itself.
+
+            */
+            last_special_line = abs(hang_after);
+            if (hang_after < 0) {
+                first_width = hsize - abs(used_hang_indent);
+                if (used_hang_indent >= 0)
+                    first_indent = used_hang_indent;
+                else
+                    first_indent = 0;
+                second_width = hsize;
+                second_indent = 0;
+            } else {
+                first_width = hsize;
+                first_indent = 0;
+                second_width = hsize - abs(used_hang_indent);
+                if (used_hang_indent >= 0)
+                    second_indent = used_hang_indent;
+                else
+                    second_indent = 0;
+            }
+        }
+    } else {
+        last_special_line = vinfo(par_shape_ptr + 1) - 1;
+        second_indent = varmem[(par_shape_ptr + 2 * (last_special_line + 1))].cint;
+        second_width = varmem[(par_shape_ptr + 2 * (last_special_line + 1) + 1)].cint;
+        second_indent = swap_parshape_indent(second_indent,second_width);
+    }
+    if (looseness == 0)
+        easy_line = last_special_line;
+    else
+        easy_line = max_halfword;
+    no_shrink_error_yet = true;
+    check_shrinkage(left_skip);
+    check_shrinkage(right_skip);
+    q = left_skip;
+    r = right_skip;
+    background[1] = width(q) + width(r);
+    background[2] = 0;
+    background[3] = 0;
+    background[4] = 0;
+    background[5] = 0;
+    background[6] = 0;
+    background[2 + stretch_order(q)] = stretch(q);
+    background[2 + stretch_order(r)] += stretch(r);
+    background[7] = shrink(q) + shrink(r);
+    if (adjust_spacing > 1) {
+        background[8] = 0;
+        background[9] = 0;
+        max_stretch_ratio = -1;
+        max_shrink_ratio = -1;
+        cur_font_step = -1;
+        set_prev_char_p(null);
+    }
+    /*tex
+
+        Check for special treatment of last line of paragraph. The new algorithm
+        for the last line requires that the stretchability |par_fill_skip| is
+        infinite and the stretchability of |left_skip| plus |right_skip| is
+        finite.
+
+    */
+    do_last_line_fit = false;
+    if (last_line_fit > 0) {
+        q = last_line_fill;
+        if ((stretch(q) > 0) && (stretch_order(q) > normal)) {
+            if ((background[3] == 0) && (background[4] == 0) && (background[5] == 0) && (background[6] == 0)) {
+                do_last_line_fit = true;
+                fill_width[0] = 0;
+                fill_width[1] = 0;
+                fill_width[2] = 0;
+                fill_width[3] = 0;
+                fill_width[stretch_order(q) - 1] = stretch(q);
+            }
+        }
+    }
+    /*tex Initialize |dir_ptr| for |line_break|. */
+    if (dir_ptr != null) {
+        flush_node_list(dir_ptr);
+        dir_ptr = null;
+    }
+    /*tex Find optimal breakpoints. */
+    threshold = pretolerance;
+    if (threshold >= 0) {
+        if (tracing_paragraphs > 0) {
+            begin_diagnostic();
+            tprint_nl("@firstpass");
+        }
+        second_pass = false;
+        final_pass = false;
+    } else {
+        threshold = tolerance;
+        second_pass = true;
+        final_pass = (emergency_stretch <= 0);
+        if (tracing_paragraphs > 0)
+            begin_diagnostic();
+    }
+    while (1) {
+        halfword first_p;
+        halfword nest_stack[10];
+        int nest_index = 0;
+        if (threshold > inf_bad)
+            threshold = inf_bad;
+        /*tex Create an active breakpoint representing the beginning of the paragraph. */
+        q = new_node(unhyphenated_node, decent_fit);
+        vlink(q) = active;
+        break_node(q) = null;
+        line_number(q) = cur_list.pg_field + 1;
+        total_demerits(q) = 0;
+        active_short(q) = 0;
+        active_glue(q) = 0;
+        vlink(active) = q;
+        do_all_eight(store_background);
+        passive = null;
+        printed_node = temp_head;
+        pass_number = 0;
+        font_in_short_display = null_font;
+        /*tex Create an active breakpoint representing the beginning of the paragraph. */
+        auto_breaking = true;
+        cur_p = vlink(temp_head);
+        /*tex Initialize with first |local_paragraph| node. */
+        if ((cur_p != null) && (type(cur_p) == local_par_node)) {
+            /*tex This used to be an assert, but may as well force it. */
+            alink(cur_p) = temp_head;
+            internal_pen_inter = local_pen_inter(cur_p);
+            internal_pen_broken = local_pen_broken(cur_p);
+            init_internal_left_box = local_box_left(cur_p);
+            init_internal_left_box_width = local_box_left_width(cur_p);
+            internal_left_box = init_internal_left_box;
+            internal_left_box_width = init_internal_left_box_width;
+            internal_right_box = local_box_right(cur_p);
+            internal_right_box_width = local_box_right_width(cur_p);
+        } else {
+            internal_pen_inter = 0;
+            internal_pen_broken = 0;
+            init_internal_left_box = null;
+            init_internal_left_box_width = 0;
+            internal_left_box = init_internal_left_box;
+            internal_left_box_width = init_internal_left_box_width;
+            internal_right_box = null;
+            internal_right_box_width = 0;
+        }
+        /*tex Initialize with first |local_paragraph| node. */
+        set_prev_char_p(null);
+        first_p = cur_p;
+        /*tex
+
+            To access the first node of paragraph as the first active node has
+            |break_node=null|.
+
+        */
+        while ((cur_p != null) && (vlink(active) != active)) {
+            /*tex
+
+                |try_break| if |cur_p| is a legal breakpoint; on the 2nd pass,
+                also look at |disc_node|s.
+
+            */
+            while (is_char_node(cur_p)) {
+                /*tex
+
+                    Advance |cur_p| to the node following the present string of
+                    characters. The code that passes over the characters of words
+                    in a paragraph is part of \TeX's inner loop, so it has been
+                    streamlined for speed. We use the fact that
+                    `\.{\\parfillskip}' glue appears at the end of each
+                    paragraph; it is therefore unnecessary to check if
+                    |vlink(cur_p)=null| when |cur_p| is a character node.
+
+                */
+                active_width[1] += pack_width(line_break_dir, dir_TRT, cur_p, true);
+                if ((adjust_spacing > 1) && check_expand_pars(font(cur_p))) {
+                    set_prev_char_p(cur_p);
+                    add_char_stretch(active_width[8], cur_p);
+                    add_char_shrink(active_width[9], cur_p);
+                }
+                cur_p = vlink(cur_p);
+                while (cur_p == null && nest_index > 0) {
+                    cur_p = nest_stack[--nest_index];
+                }
+            }
+            if (cur_p == null) {
+                normal_error("linebreak","invalid list tail, probably missing glue");
+            }
+            /*tex
+
+                Determine legal breaks: As we move through the hlist, we need to
+                keep the |active_width| array up to date, so that the badness of
+                individual lines is readily calculated by |try_break|. It is
+                convenient to use the short name |active_width[1]| for the
+                component of active width that represents real width as opposed
+                to glue.
+
+            */
+            switch (type(cur_p)) {
+                case hlist_node:
+                case vlist_node:
+                    active_width[1] += pack_width(line_break_dir, box_dir(cur_p), cur_p, false);
+                    break;
+                case rule_node:
+                    active_width[1] += width(cur_p);
+                    break;
+                case dir_node:
+                    /*tex Adjust the dir stack for the |line_break| routine. */
+                    if (subtype(cur_p) == normal_dir) {
+                        line_break_dir = dir_dir(cur_p);
+                        /* Adds to |dir_ptr|. */
+                        push_dir_node(dir_ptr,cur_p);
+                    } else {
+                        pop_dir_node(dir_ptr);
+                        if (dir_ptr != null) {
+                            line_break_dir = dir_dir(dir_ptr);
+                        }
+                    }
+                    break;
+                case local_par_node:
+                    /*tex Advance past a |local_paragraph| node. */
+                    internal_pen_inter = local_pen_inter(cur_p);
+                    internal_pen_broken = local_pen_broken(cur_p);
+                    internal_left_box = local_box_left(cur_p);
+                    internal_left_box_width = local_box_left_width(cur_p);
+                    internal_right_box = local_box_right(cur_p);
+                    internal_right_box_width = local_box_right_width(cur_p);
+                    break;
+                case math_node:
+                    auto_breaking = (subtype(cur_p) == after);
+                    /*tex begin mathskip code */
+                    if (glue_is_zero(cur_p) || ignore_math_skip(cur_p)) {
+                        kern_break();
+                        break;
+                    } else {
+                        /*tex fall through */
+                    }
+                    /*tex end mathskip code */
+                case glue_node:
+                    /*tex
+
+                        If node |cur_p| is a legal breakpoint, call |try_break|;
+                        then update the active widths by including the glue in
+                        |glue_ptr(cur_p)|.
+
+                        When node |cur_p| is a glue node, we look at the previous
+                        to see whether or not a breakpoint is legal at |cur_p|,
+                        as explained above.
+
+                        We only break after certain nodes (see texnodes.h), a
+                        font related kern and a dir node when
+                        |\breakafterdirmode=1|.
+
+                    */
+                    if (auto_breaking) {
+                        halfword prev_p = alink(cur_p);
+                        if (prev_p != temp_head && (is_char_node(prev_p)
+                             || precedes_break(prev_p) || precedes_kern(prev_p) || precedes_dir(prev_p))) {
+                            ext_try_break(
+                                0,
+                                unhyphenated_node,
+                                line_break_dir,
+                                adjust_spacing,
+                                par_shape_ptr,
+                                adj_demerits,
+                                tracing_paragraphs,
+                                protrude_chars,
+                                line_penalty,
+                                last_line_fit,
+                                double_hyphen_demerits,
+                                final_hyphen_demerits,
+                                first_p,
+                                cur_p
+                            );
+                        }
+                    }
+                    check_shrinkage(cur_p);
+                    active_width[1] += width(cur_p);
+                    active_width[2 + stretch_order(cur_p)] += stretch(cur_p);
+                    active_width[7] += shrink(cur_p);
+                    break;
+                case kern_node:
+                    if (subtype(cur_p) == explicit_kern || subtype(cur_p) == italic_kern) {
+                        kern_break();
+                    } else {
+                        active_width[1] += width(cur_p);
+                        if ((adjust_spacing == 2) && (subtype(cur_p) == normal)) {
+                            add_kern_stretch(active_width[8], cur_p);
+                            add_kern_shrink(active_width[9], cur_p);
+                        }
+                    }
+                    break;
+                case disc_node:
+                    /*tex
+
+                        |select_disc|s are handled by the leading |init_disc|.
+
+                    */
+                    if (subtype(cur_p) == select_disc)
+                        break;
+                    /*tex
+
+                        Try to break after a discretionary fragment, then |goto
+                        done5|. The following code knows that discretionary texts
+                        contain only character nodes, kern nodes, box nodes, and
+                        rule nodes. This branch differs a bit from older engines
+                        because in \LUATEX\ we already have hyphenated the list.
+                        This means that we need to skip automatic disc nodes. Of
+                        better, we need to treat discretionaries and explicit
+                        hyphens always, even in the first pass.
+
+                    */
+                    if (second_pass || subtype(cur_p) <= automatic_disc) {
+                        int actual_penalty = (int) disc_penalty(cur_p);
+                        s = vlink_pre_break(cur_p);
+                        do_one_seven_eight(reset_disc_width);
+                        if (s == null) {
+                            /*tex trivial pre-break */
+                            ext_try_break(actual_penalty, hyphenated_node,
+                                          line_break_dir, adjust_spacing,
+                                          par_shape_ptr, adj_demerits,
+                                          tracing_paragraphs, protrude_chars,
+                                          line_penalty, last_line_fit,
+                                          double_hyphen_demerits,
+                                          final_hyphen_demerits, first_p, cur_p);
+                        } else {
+                            add_to_widths(s, line_break_dir, adjust_spacing, disc_width);
+                            do_one_seven_eight(add_disc_width_to_active_width);
+                            ext_try_break(actual_penalty, hyphenated_node,
+                                          line_break_dir, adjust_spacing,
+                                          par_shape_ptr, adj_demerits,
+                                          tracing_paragraphs, protrude_chars,
+                                          line_penalty, last_line_fit,
+                                          double_hyphen_demerits,
+                                          final_hyphen_demerits, first_p, cur_p);
+                            if (subtype(cur_p) == init_disc) {
+                                /*tex
+
+                                    We should at two break points after the one
+                                    we added above:
+
+                                    \startitemize[n]
+                                        \startitem
+                                            which does a possible break in INIT's
+                                            |post_break|
+                                        \stopitem
+                                        \startitem
+                                            which means the |no_break| actually
+                                            was broken just a character later
+                                        \stopitem
+                                    \stopitemize
+
+                                    Do the select-0 case |f-f-i|:
+
+                                */
+                                s = vlink_pre_break(vlink(cur_p));
+                                add_to_widths(s, line_break_dir, adjust_spacing, disc_width);
+                                ext_try_break(actual_penalty, hyphenated_node,
+                                              line_break_dir, adjust_spacing,
+                                              par_shape_ptr, adj_demerits,
+                                              tracing_paragraphs,
+                                              protrude_chars, line_penalty,
+                                              last_line_fit, double_hyphen_demerits,
+                                              final_hyphen_demerits, first_p,
+                                              vlink(cur_p));
+                                /*tex This does not work. */
+#if 0
+                                /*tex Go back to the starting situation. */
+                                do_one_seven_eight(sub_disc_width_from_active_width);
+                                do_one_seven_eight(reset_disc_width);
+                                /*tex Add select |no_break| to |active_width|. */
+                                s = vlink_no_break(vlink(cur_p));
+                                add_to_widths(s, line_break_dir, adjust_spacing, disc_width);
+                                ext_try_break(actual_penalty, hyphenated_node,
+                                              line_break_dir, adjust_spacing,
+                                              par_shape_ptr, adj_demerits,
+                                              tracing_paragraphs,
+                                              protrude_chars, line_penalty,
+                                              last_line_fit, double_hyphen_demerits,
+                                              final_hyphen_demerits, first_p,
+                                              vlink(cur_p));
+#endif
+                            }
+                            do_one_seven_eight(sub_disc_width_from_active_width);
+                        }
+                    }
+                    s = vlink_no_break(cur_p);
+                    add_to_widths(s, line_break_dir, adjust_spacing, active_width);
+                    break;
+                case penalty_node:
+                    ext_try_break(penalty(cur_p), unhyphenated_node, line_break_dir,
+                                  adjust_spacing, par_shape_ptr, adj_demerits,
+                                  tracing_paragraphs, protrude_chars,
+                                  line_penalty, last_line_fit,
+                                  double_hyphen_demerits, final_hyphen_demerits,
+                                  first_p, cur_p);
+                    break;
+                case boundary_node:
+                case whatsit_node:
+                    /*tex Advance past a whatsit node in the |line_break| loop. */
+                case mark_node:
+                case ins_node:
+                case adjust_node:
+                    break;
+                case glue_spec_node:
+                    normal_warning("parbuilder","found a glue_spec in a paragraph");
+                    break;
+                default:
+                    formatted_error("parbuilder","weird node %d in paragraph",type(cur_p));
+            }
+            cur_p = vlink(cur_p);
+            while (cur_p == null && nest_index > 0) {
+                cur_p = nest_stack[--nest_index];
+            }
+        }
+        if (cur_p == null) {
+            /*tex
+
+                Try the final line break at the end of the paragraph, and |goto
+                done| if the desired breakpoints have been found.
+
+                The forced line break at the paragraph's end will reduce the list
+                of breakpoints so that all active nodes represent breaks at
+                |cur_p=null|. On the first pass, we insist on finding an active
+                node that has the correct ``looseness.'' On the final pass, there
+                will be at least one active node, and we will match the desired
+                looseness as well as we can.
+
+                The global variable |best_bet| will be set to the active node for
+                the best way to break the paragraph, and a few other variables
+                are used to help determine what is best.
+
+            */
+            ext_try_break(eject_penalty, hyphenated_node, line_break_dir,
+                          adjust_spacing, par_shape_ptr, adj_demerits,
+                          tracing_paragraphs, protrude_chars, line_penalty,
+                          last_line_fit, double_hyphen_demerits,
+                          final_hyphen_demerits, first_p, cur_p);
+            if (vlink(active) != active) {
+                /*tex Find an active node with fewest demerits; */
+                r = vlink(active);
+                fewest_demerits = awful_bad;
+                do {
+                    if (type(r) != delta_node) {
+                        if (total_demerits(r) < fewest_demerits) {
+                            fewest_demerits = total_demerits(r);
+                            best_bet = r;
+                        }
+                    }
+                    r = vlink(r);
+                } while (r != active);
+                best_line = line_number(best_bet);
+                /*tex
+                    Find an active node with fewest demerits;
+                */
+                if (looseness == 0)
+                    goto DONE;
+                /*tex
+
+                    Find the best active node for the desired looseness;
+
+                    The adjustment for a desired looseness is a slightly more
+                    complicated version of the loop just considered. Note that if
+                    a paragraph is broken into segments by displayed equations,
+                    each segment will be subject to the looseness calculation,
+                    independently of the other segments.
+
+                */
+                r = vlink(active);
+                actual_looseness = 0;
+                do {
+                    if (type(r) != delta_node) {
+                        line_diff = line_number(r) - best_line;
+                        if (((line_diff < actual_looseness)
+                             && (looseness <= line_diff))
+                            || ((line_diff > actual_looseness)
+                                && (looseness >= line_diff))) {
+                            best_bet = r;
+                            actual_looseness = line_diff;
+                            fewest_demerits = total_demerits(r);
+                        } else if ((line_diff == actual_looseness) &&
+                                   (total_demerits(r) < fewest_demerits)) {
+                            best_bet = r;
+                            fewest_demerits = total_demerits(r);
+                        }
+                    }
+                    r = vlink(r);
+                } while (r != active);
+                best_line = line_number(best_bet);
+                /*tex
+                    Find the best active node for the desired looseness.
+                */
+                if ((actual_looseness == looseness) || final_pass)
+                    goto DONE;
+            }
+        }
+        /*tex Clean up the memory by removing the break nodes. */
+        clean_up_the_memory();
+        /*tex Clean up the memory by removing the break nodes. */
+        if (!second_pass) {
+            if (tracing_paragraphs > 0)
+                tprint_nl("@secondpass");
+            threshold = tolerance;
+            second_pass = true;
+            final_pass = (emergency_stretch <= 0);
+        } else {
+            /*tex If at first you do not succeed, then: */
+            if (tracing_paragraphs > 0)
+                tprint_nl("@emergencypass");
+            background[2] += emergency_stretch;
+            final_pass = true;
+        }
+    }
+
+  DONE:
+    if (tracing_paragraphs > 0) {
+        end_diagnostic(true);
+        normalize_selector();
+    }
+    if (do_last_line_fit) {
+        /*tex
+            Adjust the final line of the paragraph; here we either reset
+            |do_last_line_fit| or adjust the |par_fill_skip| glue.
+        */
+        if (active_short(best_bet) == 0) {
+            do_last_line_fit = false;
+        } else {
+            width(last_line_fill) += (active_short(best_bet) - active_glue(best_bet));
+            stretch(last_line_fill) = 0;
+        }
+    }
+    /*tex
+        Break the paragraph at the chosen. Once the best sequence of
+        breakpoints has been found (hurray), we call on the procedure
+        |post_line_break| to finish the remainder of the work. By introducing
+        this subprocedure, we are able to keep |line_break| from getting
+        extremely long.
+
+        the first thing |ext_post_line_break| does is reset |dir_ptr|.
+
+    */
+    flush_node_list(dir_ptr);
+    dir_ptr = null;
+    ext_post_line_break(paragraph_dir,
+                        right_skip,
+                        left_skip,
+                        protrude_chars,
+                        par_shape_ptr,
+                        adjust_spacing,
+                        inter_line_penalties_par_ptr,
+                        inter_line_penalty,
+                        club_penalty,
+                        club_penalties_ptr,
+                        widow_penalties_ptr,
+                        widow_penalty,
+                        broken_penalty,
+                        final_par_glue,
+                        best_bet,
+                        last_special_line,
+                        second_width,
+                        second_indent, first_width, first_indent, best_line);
+    /*tex
+
+        Clean up the memory by removing the break nodes.
+
+    */
+    clean_up_the_memory();
+}
+
+void get_linebreak_info (int *f, int *a)
+{
+    *f = fewest_demerits;
+    *a = actual_looseness;
+}
diff --git a/texk/web2c/luatexdir/tex/linebreak.w b/texk/web2c/luatexdir/tex/linebreak.w
deleted file mode 100644
index 345a1a424..000000000
--- a/texk/web2c/luatexdir/tex/linebreak.w
+++ /dev/null
@@ -1,2164 +0,0 @@
-% linebreak.w
-%
-% Copyright 2006-2008 Taco Hoekwater <taco@@luatex.org>
-%
-% This file is part of LuaTeX.
-%
-% LuaTeX is free software; you can redistribute it and/or modify it under
-% the terms of the GNU General Public License as published by the Free
-% Software Foundation; either version 2 of the License, or (at your
-% option) any later version.
-%
-% LuaTeX is distributed in the hope that it will be useful, but WITHOUT
-% ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-% FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
-% License for more details.
-%
-% You should have received a copy of the GNU General Public License along
-% with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
-
-@ @c
-
-#include "ptexlib.h"
-
-@ We come now to what is probably the most interesting algorithm of \TeX:
-the mechanism for choosing the ``best possible'' breakpoints that yield
-the individual lines of a paragraph. \TeX's line-breaking algorithm takes
-a given horizontal list and converts it to a sequence of boxes that are
-appended to the current vertical list. In the course of doing this, it
-creates a special data structure containing three kinds of records that are
-not used elsewhere in \TeX. Such nodes are created while a paragraph is
-being processed, and they are destroyed afterwards; thus, the other parts
-of \TeX\ do not need to know anything about how line-breaking is done.
-
-The method used here is based on an approach devised by Michael F. Plass and
-@^Plass, Michael Frederick@>
-@^Knuth, Donald Ervin@>
-the author in 1977, subsequently generalized and improved by the same two
-people in 1980. A detailed discussion appears in {\sl SOFTWARE---Practice
-\AM\ Experience \bf11} (1981), 1119--1184, where it is shown that the
-line-breaking problem can be regarded as a special case of the problem of
-computing the shortest path in an acyclic network. The cited paper includes
-numerous examples and describes the history of line breaking as it has been
-practiced by printers through the ages. The present implementation adds two
-new ideas to the algorithm of 1980: Memory space requirements are considerably
-reduced by using smaller records for inactive nodes than for active ones,
-and arithmetic overflow is avoided by using ``delta distances'' instead of
-keeping track of the total distance from the beginning of the paragraph to the
-current point.
-
-The |line_break| procedure should be invoked only in horizontal mode; it
-leaves that mode and places its output into the current vlist of the
-enclosing vertical mode (or internal vertical mode).
-There is one explicit parameter:  |d| is true for partial paragraphs
-preceding display math mode; in this case the amount of additional
-penalty inserted before the final line is |display_widow_penalty|
-instead of |widow_penalty|.
-
-There are also a number of implicit parameters: The hlist to be broken
-starts at |vlink(head)|, and it is nonempty. The value of |prev_graf| in the
-enclosing semantic level tells where the paragraph should begin in the
-sequence of line numbers, in case hanging indentation or \.{\\parshape}
-are in use; |prev_graf| is zero unless this paragraph is being continued
-after a displayed formula.  Other implicit parameters, such as the
-|par_shape_ptr| and various penalties to use for hyphenation, etc., appear
-in |eqtb|.
-
-After |line_break| has acted, it will have updated the current vlist and the
-value of |prev_graf|. Furthermore, the global variable |just_box| will
-point to the final box created by |line_break|, so that the width of this
-line can be ascertained when it is necessary to decide whether to use
-|above_display_skip| or |above_display_short_skip| before a displayed formula.
-
-@c
-halfword just_box;              /* the |hlist_node| for the last line of the new paragraph */
-
-@ In it's complete form, |line_break| is a rather lengthy
-procedure---sort of a small world unto itself---we must build it up
-little by little. Below you see only the general outline.
-
-The main task performed here is to move the list from |head| to
-|temp_head| and go into the enclosing semantic level. We also append
-the \.{\\parfillskip} glue to the end of the paragraph, removing a
-space (or other glue node) if it was there, since spaces usually
-precede blank lines and instances of `\.{\$\$}'. The |par_fill_skip|
-is preceded by an infinite penalty, so it will never be considered as
-a potential breakpoint.
-
-That code assumes that a |glue_node| and a |penalty_node| occupy the
-same number of |mem|~words.
-@^data structure assumptions@>
-
-Most other processing is delegated to external functions.
-
-@c
-void line_break(boolean d, int line_break_context)
-{
-    int paragraph_dir = 0;      /* main direction of paragraph */
-    halfword final_par_glue;
-    halfword start_of_par;
-    int callback_id;
-    pack_begin_line = cur_list.ml_field;        /* this is for over/underfull box messages */
-    alink(temp_head) = null; /* hh-ls */
-    vlink(temp_head) = vlink(cur_list.head_field);
-    new_hyphenation(temp_head, cur_list.tail_field);
-    cur_list.tail_field = new_ligkern(temp_head, cur_list.tail_field);
-    if (is_char_node(cur_list.tail_field)) {
-        tail_append(new_penalty(inf_penalty,line_penalty));
-    } else if (type(cur_list.tail_field) != glue_node) {
-        tail_append(new_penalty(inf_penalty,line_penalty));
-    } else {
-        halfword t = alink(cur_list.tail_field);
-		flush_node(cur_list.tail_field);
-		cur_list.tail_field = t;
-		tail_append(new_penalty(inf_penalty,line_penalty));
-    }
-    final_par_glue = new_param_glue(par_fill_skip_code);
-    couple_nodes(cur_list.tail_field, final_par_glue);
-    cur_list.tail_field = vlink(cur_list.tail_field);
-    lua_node_filter(pre_linebreak_filter_callback,
-                    line_break_context, temp_head,
-                    addressof(cur_list.tail_field));
-    last_line_fill = cur_list.tail_field;
-    pop_nest();
-    start_of_par = cur_list.tail_field;
-    callback_id = callback_defined(linebreak_filter_callback);
-    if (callback_id > 0) {
-        callback_id = lua_linebreak_callback(d, temp_head, addressof(cur_list.tail_field));
-        if (callback_id > 0) {
-            /* find the correct value for the |just_box| */
-            halfword box_search = cur_list.tail_field;
-            just_box  = null;
-            if (box_search != null) {
-                do {
-                    if (type(box_search) == hlist_node) {
-                       just_box = box_search;
-                    }
-                    box_search = vlink(box_search);
-                } while (box_search != null);
-            }
-            if (just_box == null) {
-                help3
-                    ("A linebreaking routine should return a non-empty list of nodes",
-                     "and at least one of those has to be a \\hbox.",
-                     "Sorry, I cannot recover from this.");
-                print_err("Invalid linebreak_filter");
-                succumb();
-            }
-        } else {
-            if (tracing_paragraphs_par > 0) {
-                begin_diagnostic();
-                print_int(line);
-                end_diagnostic(true);
-            }
-        }
-    }
-    if (callback_id == 0) {
-        if ((!is_char_node(vlink(temp_head))) && ((type(vlink(temp_head)) == local_par_node))) {
-            paragraph_dir = local_par_dir(vlink(temp_head));
-        } else {
-            confusion("weird par dir"); /* assert(0); */ /* |paragraph_dir = 0|; */
-        }
-        ext_do_line_break(paragraph_dir,
-                          pretolerance_par,
-                          tracing_paragraphs_par,
-                          tolerance_par,
-                          emergency_stretch_par,
-                          looseness_par,
-                          adjust_spacing_par,
-                          par_shape_par_ptr,
-                          adj_demerits_par,
-                          protrude_chars_par,
-                          line_penalty_par,
-                          last_line_fit_par,
-                          double_hyphen_demerits_par,
-                          final_hyphen_demerits_par,
-                          hang_indent_par,
-                          hsize_par,
-                          hang_after_par,
-                          left_skip_par,
-                          right_skip_par,
-                          inter_line_penalties_par_ptr,
-                          inter_line_penalty_par,
-                          club_penalty_par,
-                          club_penalties_par_ptr,
-                          (d ? display_widow_penalties_par_ptr : widow_penalties_par_ptr),
-                          (d ? display_widow_penalty_par : widow_penalty_par),
-                          broken_penalty_par,
-                          final_par_glue);
-    }
-    lua_node_filter(post_linebreak_filter_callback,
-                    line_break_context, start_of_par,
-                    addressof(cur_list.tail_field));
-    pack_begin_line = 0;
-}
-
-@ Glue nodes in a horizontal list that is being paragraphed are not supposed to
-   include ``infinite'' shrinkability; that is why the algorithm maintains
-   four registers for stretching but only one for shrinking. If the user tries to
-   introduce infinite shrinkability, the shrinkability will be reset to finite
-   and an error message will be issued. A boolean variable |no_shrink_error_yet|
-   prevents this error message from appearing more than once per paragraph.
-
-@c
-#define check_shrinkage(a) \
-    if ((shrink_order((a))!=normal)&&(shrink((a))!=0)) \
-        a=finite_shrink((a))
-
-static boolean no_shrink_error_yet;     /*have we complained about infinite shrinkage? */
-
-static halfword finite_shrink(halfword p)
-{                               /* recovers from infinite shrinkage */
-    const char *hlp[] = {
-        "The paragraph just ended includes some glue that has",
-        "infinite shrinkability, e.g., `\\hskip 0pt minus 1fil'.",
-        "Such glue doesn't belong there---it allows a paragraph",
-        "of any length to fit on one line. But it's safe to proceed,",
-        "since the offensive shrinkability has been made finite.",
-        NULL
-    };
-    if (no_shrink_error_yet) {
-        no_shrink_error_yet = false;
-        tex_error("Infinite glue shrinkage found in a paragraph", hlp);
-    }
-    shrink_order(p) = normal;
-    return p;
-}
-
-@ A pointer variable |cur_p| runs through the given horizontal list as we look
-   for breakpoints. This variable is global, since it is used both by |line_break|
-   and by its subprocedure |try_break|.
-
-   Another global variable called |threshold| is used to determine the feasibility
-   of individual lines: breakpoints are feasible if there is a way to reach
-   them without creating lines whose badness exceeds |threshold|.  (The
-   badness is compared to |threshold| before penalties are added, so that
-   penalty values do not affect the feasibility of breakpoints, except that
-   no break is allowed when the penalty is 10000 or more.) If |threshold|
-   is 10000 or more, all legal breaks are considered feasible, since the
-   |badness| function specified above never returns a value greater than~10000.
-
-   Up to three passes might be made through the paragraph in an attempt to find at
-   least one set of feasible breakpoints. On the first pass, we have
-   |threshold=pretolerance| and |second_pass=final_pass=false|.
-   If this pass fails to find a
-   feasible solution, |threshold| is set to |tolerance|, |second_pass| is set
-   |true|, and an attempt is made to hyphenate as many words as possible.
-   If that fails too, we add |emergency_stretch| to the background
-   stretchability and set |final_pass=true|.
-
-@c
-static boolean second_pass;     /* is this our second attempt to break this paragraph? */
-static boolean final_pass;      /*is this our final attempt to break this paragraph? */
-static int threshold;           /* maximum badness on feasible lines */
-
-/* maximum fill level for |hlist_stack|*/
-#define max_hlist_stack 512     /* maybe good if larger than |2 *
-                                   max_quarterword|, so that box nesting
-                                   level would overflow first */
-
-/* stack for |find_protchar_left()| and |find_protchar_right()| */
-static halfword hlist_stack[max_hlist_stack];
-
-/* fill level for |hlist_stack| */
-static short hlist_stack_level = 0;
-
-@ @c
-static void push_node(halfword p)
-{
-    if (hlist_stack_level >= max_hlist_stack)
-        normal_error("push_node","stack overflow");
-    hlist_stack[hlist_stack_level++] = p;
-}
-
-static halfword pop_node(void)
-{
-    if (hlist_stack_level <= 0) /* would point to some bug */
-        normal_error("pop_node","stack underflow (internal error)");
-    return hlist_stack[--hlist_stack_level];
-}
-
-@ @c
-static int max_stretch_ratio = 0;       /*maximal stretch ratio of expanded fonts */
-static int max_shrink_ratio = 0;        /*maximal shrink ratio of expanded fonts */
-static int cur_font_step = 0;   /*the current step of expanded fonts */
-
-static boolean check_expand_pars(internal_font_number f)
-{
-    int m;
-
-    if ((font_step(f) == 0)
-        || ((font_max_stretch(f) == 0) && (font_max_shrink(f) == 0)))
-        return false;
-    if (cur_font_step < 0)
-        cur_font_step = font_step(f);
-    else if (cur_font_step != font_step(f))
-        normal_error("font expansion","using fonts with different step of expansion in one paragraph is not allowed");
-    m = font_max_stretch(f);
-    if (m != 0) {
-        if (max_stretch_ratio < 0)
-            max_stretch_ratio = m;
-        else if (max_stretch_ratio != m)
-            normal_error("font expansion","using fonts with different limit of expansion in one paragraph is not allowed");
-    }
-    m = font_max_shrink(f);
-    if (m != 0) {
-        if (max_shrink_ratio < 0)
-            max_shrink_ratio = -m;
-        else if (max_shrink_ratio != -m)
-            normal_error("font expansion","using fonts with different limit of expansion in one paragraph is not allowed");
-    }
-    return true;
-}
-
-@ searches left to right from list head |l|, returns 1st non-skipable item
-
-@c
-/*public*/ halfword find_protchar_left(halfword l, boolean d)
-{
-    halfword t;
-    boolean run;
-    boolean done = false ;
-    while ((vlink(l) != null) && (type(l) == hlist_node) && zero_dimensions(l) && (list_ptr(l) == null)) {
-        /*for paragraph start with \.{\\parindent} = 0pt or any empty hbox */
-        l = vlink(l);
-        done = true ;
-    }
-    if ((!done) && (type(l) == local_par_node)) {
-        l = vlink(l);
-        done = true ;
-    }
-    if ((!done) && d) {
-        while ((vlink(l) != null) && (!(is_char_node(l) || non_discardable(l)))) {
-            /* std.\ discardables at line break, \TeX book, p 95 */
-            l = vlink(l);
-        }
-    }
-    if (type(l) != glyph_node) {
-        hlist_stack_level = 0;
-        run = true;
-        do {
-            t = l;
-            while (run && (type(l) == hlist_node) && (list_ptr(l) != null)) {
-                push_node(l);
-                l = list_ptr(l);
-            }
-            while (run && cp_skipable(l)) {
-                while ((vlink(l) == null) && (hlist_stack_level > 0)) {
-                    l = pop_node(); /* don't visit this node again */
-                    run = false;
-                }
-                if ((vlink(l) != null) && (type(l) == boundary_node) && (subtype(l) == protrusion_boundary) &&
-                        ((boundary_value(l) == 1) || (boundary_value(l) == 3))) {
-                    /* skip next node */
-                    l = vlink(l);
-                }
-                if (vlink(l) != null) {
-                    l = vlink(l);
-                } else if (hlist_stack_level == 0) {
-                    run = false;
-                }
-            }
-        } while (t != l);
-    }
-    return l;
-}
-
-@ searches right to left from list tail |r| to head |l|, returns 1st non-skipable item
-
-@c
-/*public*/ halfword find_protchar_right(halfword l, halfword r)
-{
-    halfword t;
-    boolean run = true;
-    if (r == null)
-        return null;
-    hlist_stack_level = 0;
-    do {
-        t = r;
-        while (run && (type(r) == hlist_node) && (list_ptr(r) != null)) {
-            push_node(l);
-            push_node(r);
-            l = list_ptr(r);
-            r = l;
-            while (vlink(r) != null) {
-                halfword s = r;
-                r = vlink(r);
-                alink(r) = s;
-            }
-        }
-        while (run && cp_skipable(r)) {
-            while ((r == l) && (hlist_stack_level > 0)) {
-                r = pop_node(); /* don't visit this node again */
-                l = pop_node();
-            }
-            if ((r != l) && (r != null)) {
-                if ((alink(r) != null) && (type(r) == boundary_node) && (subtype(r) == protrusion_boundary) &&
-                        ((boundary_value(r) == 2) || (boundary_value(r) == 3))) {
-                    /* skip next node */
-                    r = alink(r);
-                }
-                if (alink(r) != null) {
-                    r = alink(r);
-                } else {        /* this is the input: \.{\\leavevmode\\penalty-10000\\penalty-10000} (bug \#268) */
-                    run = false;
-                }
-            } else if ((r == l) && (hlist_stack_level == 0))
-                run = false;
-        }
-    } while (t != r);
-    return r;
-}
-
-@ @c
-#define left_pw(a) char_pw((a), left_side)
-#define right_pw(a) char_pw((a), right_side)
-
-@ When looking for optimal line breaks, \TeX\ creates a ``break node'' for
-   each break that is {\sl feasible}, in the sense that there is a way to end
-   a line at the given place without requiring any line to stretch more than
-   a given tolerance. A break node is characterized by three things: the position
-   of the break (which is a pointer to a |glue_node|, |math_node|, |penalty_node|,
-   or |disc_node|); the ordinal number of the line that will follow this
-   breakpoint; and the fitness classification of the line that has just
-   ended, i.e., |tight_fit|, |decent_fit|, |loose_fit|, or |very_loose_fit|.
-
-@c
-typedef enum {
-    very_loose_fit = 0,         /* fitness classification for lines stretching more than
-                                   their stretchability */
-    loose_fit,                  /* fitness classification for lines stretching 0.5 to 1.0 of their
-                                   stretchability */
-    decent_fit,                 /* fitness classification for all other lines */
-    tight_fit                   /* fitness classification for lines shrinking 0.5 to 1.0 of their
-                                   shrinkability */
-} fitness_value;
-
-
-@ The algorithm essentially determines the best possible way to achieve
-   each feasible combination of position, line, and fitness. Thus, it answers
-   questions like, ``What is the best way to break the opening part of the
-   paragraph so that the fourth line is a tight line ending at such-and-such
-   a place?'' However, the fact that all lines are to be the same length
-   after a certain point makes it possible to regard all sufficiently large
-   line numbers as equivalent, when the looseness parameter is zero, and this
-   makes it possible for the algorithm to save space and time.
-
-   An ``active node'' and a ``passive node'' are created in |mem| for each
-   feasible breakpoint that needs to be considered. Active nodes are three
-   words long and passive nodes are two words long. We need active nodes only
-   for breakpoints near the place in the paragraph that is currently being
-   examined, so they are recycled within a comparatively short time after
-   they are created.
-
-@ An active node for a given breakpoint contains six fields:
-
-|vlink| points to the next node in the list of active nodes; the
-last active node has |vlink=active|.
-
-|break_node| points to the passive node associated with this
-breakpoint.
-
-|line_number| is the number of the line that follows this
-breakpoint.
-
-|fitness| is the fitness classification of the line ending at this
-breakpoint.
-
-|type| is either |hyphenated_node| or |unhyphenated_node|, depending on
-whether this breakpoint is a |disc_node|.
-
-|total_demerits| is the minimum possible sum of demerits over all
-lines leading from the beginning of the paragraph to this breakpoint.
-
-The value of |vlink(active)| points to the first active node on a vlinked list
-of all currently active nodes. This list is in order by |line_number|,
-except that nodes with |line_number>easy_line| may be in any order relative
-to each other.
-
-@c
-void initialize_active(void)
-{
-    type(active) = hyphenated_node;
-    line_number(active) = max_halfword;
-    subtype(active) = 0;        /* the |subtype| is never examined */
-}
-
-@ The passive node for a given breakpoint contains EIGHT fields:
-
-|vlink| points to the passive node created just before this one,
-if any, otherwise it is |null|.
-
-|cur_break| points to the position of this breakpoint in the
-horizontal list for the paragraph being broken.
-
-|prev_break| points to the passive node that should precede this
-one in an optimal path to this breakpoint.
-
-|serial| is equal to |n| if this passive node is the |n|th
-one created during the current pass. (This field is used only when
-printing out detailed statistics about the line-breaking calculations.)
-
-|passive_pen_inter| holds the current \.{\\localinterlinepenalty}
-
-|passive_pen_broken| holds the current \.{\\localbrokenpenalty}
-
-There is a global variable called |passive| that points to the most
-recently created passive node. Another global variable, |printed_node|,
-is used to help print out the paragraph when detailed information about
-the line-breaking computation is being displayed.
-
-@c
-static halfword passive;        /* most recent node on passive list */
-static halfword printed_node;   /*most recent node that has been printed */
-static halfword pass_number;    /*the number of passive nodes allocated on this pass */
-
-@ The active list also contains ``delta'' nodes that help the algorithm
-compute the badness of individual lines. Such nodes appear only between two
-active nodes, and they have |type=delta_node|. If |p| and |r| are active nodes
-and if |q| is a delta node between them, so that |vlink(p)=q| and |vlink(q)=r|,
-then |q| tells the space difference between lines in the horizontal list that
-start after breakpoint |p| and lines that start after breakpoint |r|. In
-other words, if we know the length of the line that starts after |p| and
-ends at our current position, then the corresponding length of the line that
-starts after |r| is obtained by adding the amounts in node~|q|. A delta node
-contains seven scaled numbers, since it must record the net change in glue
-stretchability with respect to all orders of infinity. The natural width
-difference appears in |mem[q+1].sc|; the stretch differences in units of
-pt, sfi, fil, fill, and filll appear in |mem[q+2..q+6].sc|; and the shrink
-difference appears in |mem[q+7].sc|. The |subtype| field of a delta node
-is not used.
-
-Actually, we have two more fields that are used by |pdftex|.
-
-As the algorithm runs, it maintains a set of seven delta-like registers
-for the length of the line following the first active breakpoint to the
-current position in the given hlist. When it makes a pass through the
-active list, it also maintains a similar set of seven registers for the
-length following the active breakpoint of current interest. A third set
-holds the length of an empty line (namely, the sum of \.{\\leftskip} and
-\.{\\rightskip}); and a fourth set is used to create new delta nodes.
-
-When we pass a delta node we want to do operations like
-$$\hbox{\ignorespaces|for
-k:=1 to 7 do cur_active_width[k]:=cur_active_width[k]+mem[q+k].sc|};$$ and we
-want to do this without the overhead of |for| loops. The |do_all_six|
-macro makes such six-tuples convenient.
-
-@c
-static scaled active_width[10] = { 0 }; /*distance from first active node to~|cur_p| */
-static scaled background[10] = { 0 };   /*length of an ``empty'' line */
-static scaled break_width[10] = { 0 };  /*length being computed after current break */
-
-static boolean auto_breaking;   /*make |auto_breaking| accessible out of |line_break| */
-
-@  Let's state the principles of the delta nodes more precisely and concisely,
-   so that the following programs will be less obscure. For each legal
-   breakpoint~|p| in the paragraph, we define two quantities $\alpha(p)$ and
-   $\beta(p)$ such that the length of material in a line from breakpoint~|p|
-   to breakpoint~|q| is $\gamma+\beta(q)-\alpha(p)$, for some fixed $\gamma$.
-   Intuitively, $\alpha(p)$ and $\beta(q)$ are the total length of material from
-   the beginning of the paragraph to a point ``after'' a break at |p| and to a
-   point ``before'' a break at |q|; and $\gamma$ is the width of an empty line,
-   namely the length contributed by \.{\\leftskip} and \.{\\rightskip}.
-
-   Suppose, for example, that the paragraph consists entirely of alternating
-   boxes and glue skips; let the boxes have widths $x_1\ldots x_n$ and
-   let the skips have widths $y_1\ldots y_n$, so that the paragraph can be
-   represented by $x_1y_1\ldots x_ny_n$. Let $p_i$ be the legal breakpoint
-   at $y_i$; then $\alpha(p_i)=x_1+y_1+\cdots+x_i+y_i$, and $\beta(p_i)=
-   x_1+y_1+\cdots+x_i$. To check this, note that the length of material from
-   $p_2$ to $p_5$, say, is $\gamma+x_3+y_3+x_4+y_4+x_5=\gamma+\beta(p_5)
-   -\alpha(p_2)$.
-
-   The quantities $\alpha$, $\beta$, $\gamma$ involve glue stretchability and
-   shrinkability as well as a natural width. If we were to compute $\alpha(p)$
-   and $\beta(p)$ for each |p|, we would need multiple precision arithmetic, and
-   the multiprecise numbers would have to be kept in the active nodes.
-   \TeX\ avoids this problem by working entirely with relative differences
-   or ``deltas.'' Suppose, for example, that the active list contains
-   $a_1\,\delta_1\,a_2\,\delta_2\,a_3$, where the |a|'s are active breakpoints
-   and the $\delta$'s are delta nodes. Then $\delta_1=\alpha(a_1)-\alpha(a_2)$
-   and $\delta_2=\alpha(a_2)-\alpha(a_3)$. If the line breaking algorithm is
-   currently positioned at some other breakpoint |p|, the |active_width| array
-   contains the value $\gamma+\beta(p)-\alpha(a_1)$. If we are scanning through
-   the list of active nodes and considering a tentative line that runs from
-   $a_2$ to~|p|, say, the |cur_active_width| array will contain the value
-   $\gamma+\beta(p)-\alpha(a_2)$. Thus, when we move from $a_2$ to $a_3$,
-   we want to add $\alpha(a_2)-\alpha(a_3)$ to |cur_active_width|; and this
-   is just $\delta_2$, which appears in the active list between $a_2$ and
-   $a_3$. The |background| array contains $\gamma$. The |break_width| array
-   will be used to calculate values of new delta nodes when the active
-   list is being updated.
-
-@  The heart of the line-breaking procedure is `|try_break|', a subroutine
-   that tests if the current breakpoint |cur_p| is feasible, by running
-   through the active list to see what lines of text can be made from active
-   nodes to~|cur_p|.  If feasible breaks are possible, new break nodes are
-   created.  If |cur_p| is too far from an active node, that node is
-   deactivated.
-
-   The parameter |pi| to |try_break| is the penalty associated
-   with a break at |cur_p|; we have |pi=eject_penalty| if the break is forced,
-   and |pi=inf_penalty| if the break is illegal.
-
-   The other parameter, |break_type|, is set to |hyphenated_node| or |unhyphenated_node|,
-   depending on whether or not the current break is at a |disc_node|. The
-   end of a paragraph is also regarded as `|hyphenated_node|'; this case is
-   distinguishable by the condition |cur_p=null|.
-
-@c
-static int internal_pen_inter;  /* running \.{\\localinterlinepenalty} */
-static int internal_pen_broken; /* running \.{\\localbrokenpenalty} */
-static halfword internal_left_box;      /* running \.{\\localleftbox} */
-static int internal_left_box_width;     /* running \.{\\localleftbox} width */
-static halfword init_internal_left_box; /* running \.{\\localleftbox} */
-static int init_internal_left_box_width;        /* running \.{\\localleftbox} width */
-static halfword internal_right_box;     /* running \.{\\localrightbox} */
-static int internal_right_box_width;    /* running \.{\\localrightbox} width */
-
-static scaled disc_width[10] = { 0 };   /* the length of discretionary material preceding a break */
-
-@  As we consider various ways to end a line at |cur_p|, in a given line number
-   class, we keep track of the best total demerits known, in an array with
-   one entry for each of the fitness classifications. For example,
-   |minimal_demerits[tight_fit]| contains the fewest total demerits of feasible
-   line breaks ending at |cur_p| with a |tight_fit| line; |best_place[tight_fit]|
-   points to the passive node for the break before~|cur_p| that achieves such
-   an optimum; and |best_pl_line[tight_fit]| is the |line_number| field in the
-   active node corresponding to |best_place[tight_fit]|. When no feasible break
-   sequence is known, the |minimal_demerits| entries will be equal to
-   |awful_bad|, which is $2^{30}-1$. Another variable, |minimum_demerits|,
-   keeps track of the smallest value in the |minimal_demerits| array.
-
-@c
-static int minimal_demerits[4]; /* best total demerits known for current
-                                   line class and position, given the fitness */
-static int minimum_demerits;    /* best total demerits known for current line class
-                                   and position */
-static halfword best_place[4];  /* how to achieve  |minimal_demerits| */
-static halfword best_pl_line[4];        /*corresponding line number */
-
-@  The length of lines depends on whether the user has specified
-\.{\\parshape} or \.{\\hangindent}. If |par_shape_ptr| is not null, it
-points to a $(2n+1)$-word record in |mem|, where the |vinfo| in the first
-word contains the value of |n|, and the other $2n$ words contain the left
-margins and line lengths for the first |n| lines of the paragraph; the
-specifications for line |n| apply to all subsequent lines. If
-|par_shape_ptr=null|, the shape of the paragraph depends on the value of
-|n=hang_after|; if |n>=0|, hanging indentation takes place on lines |n+1|,
-|n+2|, \dots, otherwise it takes place on lines 1, \dots, $\vert
-n\vert$. When hanging indentation is active, the left margin is
-|hang_indent|, if |hang_indent>=0|, else it is 0; the line length is
-$|hsize|-\vert|hang_indent|\vert$. The normal setting is
-|par_shape_ptr=null|, |hang_after=1|, and |hang_indent=0|.
-Note that if |hang_indent=0|, the value of |hang_after| is irrelevant.
-@^length of lines@> @^hanging indentation@>
-
-@c
-static halfword easy_line;          /*line numbers |>easy_line| are equivalent in break nodes */
-static halfword last_special_line;  /*line numbers |>last_special_line| all have the same width */
-static scaled first_width;          /*the width of all lines |<=last_special_line|, if
-                                      no \.{\\parshape} has been specified */
-static scaled second_width;         /*the width of all lines |>last_special_line| */
-static scaled first_indent;         /*left margin to go with |first_width| */
-static scaled second_indent;        /*left margin to go with |second_width| */
-
-static halfword best_bet;           /*use this passive node and its predecessors */
-static int fewest_demerits;         /*the demerits associated with |best_bet| */
-static halfword best_line;          /*line number following the last line of the new paragraph */
-static int actual_looseness;        /*the difference between |line_number(best_bet)|
-                                      and the optimum |best_line| */
-static int line_diff;               /*the difference between the current line number and
-                                      the optimum |best_line| */
-
-@  \TeX\ makes use of the fact that |hlist_node|, |vlist_node|,
-   |rule_node|, |ins_node|, |mark_node|, |adjust_node|,
-   |disc_node|, |whatsit_node|, and |math_node| are at the low end of the
-   type codes, by permitting a break at glue in a list if and only if the
-   |type| of the previous node is less than |math_node|. Furthermore, a
-   node is discarded after a break if its type is |math_node| or~more.
-
-@c
-#define do_all_six(a) a(1);a(2);a(3);a(4);a(5);a(6);a(7)
-#define do_seven_eight(a) if (adjust_spacing > 1) { a(8);a(9); }
-#define do_all_eight(a) do_all_six(a); do_seven_eight(a)
-#define do_one_seven_eight(a) a(1); do_seven_eight(a)
-
-#define store_background(a) {active_width[a]=background[a];}
-
-#define kern_break() { \
-    if ((!is_char_node(vlink(cur_p))) && auto_breaking) \
-        if (type(vlink(cur_p))==glue_node) \
-            ext_try_break(0, \
-                          unhyphenated_node, \
-                          line_break_dir, \
-                          adjust_spacing, \
-                          par_shape_ptr, \
-                          adj_demerits, \
-                          tracing_paragraphs, \
-                          protrude_chars, \
-                          line_penalty, \
-                          last_line_fit, \
-                          double_hyphen_demerits, \
-                          final_hyphen_demerits, \
-                          first_p, \
-                          cur_p); \
-    if (type(cur_p)!=math_node) \
-        active_width[1] += width(cur_p); \
-    else \
-        active_width[1] += surround(cur_p); \
-}
-
-#define clean_up_the_memory() { \
-    q=vlink(active); \
-    while (q!=active) { \
-        cur_p = vlink(q); \
-        if (type(q)==delta_node) \
-            flush_node(q); \
-        else \
-            flush_node(q); \
-        q = cur_p; \
-    } \
-    q = passive;  \
-    while (q!=null) { \
-        cur_p = vlink(q); \
-        flush_node(q); \
-        q = cur_p; \
-    } \
-}
-
-static boolean do_last_line_fit;        /* special algorithm for last line of paragraph? */
-static scaled fill_width[4];    /* infinite stretch components of  |par_fill_skip| */
-static scaled best_pl_short[4]; /* |shortfall|  corresponding to |minimal_demerits| */
-static scaled best_pl_glue[4];  /*corresponding glue stretch or shrink */
-
-#define reset_disc_width(a) disc_width[(a)] = 0
-
-#define add_disc_width_to_break_width(a)     break_width[(a)] += disc_width[(a)]
-#define sub_disc_width_from_active_width(a)  active_width[(a)] -= disc_width[(a)]
-
-#define add_char_shrink(a,b)  a += char_shrink((b))
-#define add_char_stretch(a,b) a += char_stretch((b))
-#define sub_char_shrink(a,b)  a -= char_shrink((b))
-#define sub_char_stretch(a,b) a -= char_stretch((b))
-
-#define add_kern_shrink(a,b)  a += kern_shrink((b))
-#define add_kern_stretch(a,b) a += kern_stretch((b))
-#define sub_kern_shrink(a,b)  a -= kern_shrink((b))
-#define sub_kern_stretch(a,b) a -= kern_stretch((b))
-
-@ This function is used to add the width of a list of nodes
-(from a discretionary) to one of the width arrays.
-
-Replacement texts and discretionary texts are supposed to contain
-only character nodes, kern nodes, and box or rule nodes.
-
-@c
-#define bad_node_in_disc_error(p) { \
-    if (type(p) == whatsit_node) { \
-        formatted_error("linebreak","invalid node with type %s and subtype %i found in discretionary",node_data[type(p)].name,subtype(p)); \
-    } else { \
-        formatted_error("linebreak","invalid node with type %s found in discretionary",node_data[type(p)].name); \
-    } \
-}
-
-static void add_to_widths(halfword s, int line_break_dir, int adjust_spacing, scaled * widths)
-{
-    while (s != null) {
-        if (is_char_node(s)) {
-            widths[1] += pack_width(line_break_dir, dir_TRT, s, true);
-            if ((adjust_spacing > 1) && check_expand_pars(font(s))) {
-                set_prev_char_p(s);
-                add_char_stretch(widths[8], s);
-                add_char_shrink(widths[9], s);
-            };
-        } else {
-            switch (type(s)) {
-                case hlist_node:
-                case vlist_node:
-                    widths[1] += pack_width(line_break_dir, box_dir(s), s, false);
-                    break;
-                case kern_node:
-                    if ((adjust_spacing == 2) && (subtype(s) == normal)) {
-                        add_kern_stretch(widths[8], s);
-                        add_kern_shrink(widths[9], s);
-                    }
-                    /* fall through */
-                case rule_node:
-                    widths[1] += width(s);
-                    break;
-                case disc_node:    /* TH temp */
-                    break;
-                default:
-                    bad_node_in_disc_error(s);
-                    break;
-            }
-        }
-        s = vlink(s);
-    }
-}
-
-@ This function is used to substract the width of a list of nodes
-(from a discretionary) from one of the width arrays.
-It is used only once, but deserves it own function because of orthogonality
-with the |add_to_widths| function.
-
-@c
-static void sub_from_widths(halfword s, int line_break_dir, int adjust_spacing, scaled * widths)
-{
-    while (s != null) {
-        /* Subtract the width of node |s| from |break_width|; */
-        if (is_char_node(s)) {
-            widths[1] -= pack_width(line_break_dir, dir_TRT, s, true);
-            if ((adjust_spacing > 1) && check_expand_pars(font(s))) {
-                set_prev_char_p(s);
-                sub_char_stretch(widths[8], s);
-                sub_char_shrink(widths[9], s);
-            }
-        } else {
-            switch (type(s)) {
-                case hlist_node:
-                case vlist_node:
-                    widths[1] -= pack_width(line_break_dir, box_dir(s), s, false);
-                    break;
-                case kern_node:
-                    if ((adjust_spacing == 2) && (subtype(s) == normal)) {
-                        sub_kern_stretch(widths[8], s);
-                        sub_kern_shrink(widths[9], s);
-                    }
-                    /* fall through */
-                case rule_node:
-                    widths[1] -= width(s);
-                    break;
-                case disc_node:    /* TH temp */
-                    break;
-                default:
-                    bad_node_in_disc_error(s);
-                    break;
-            }
-        }
-        s = vlink(s);
-    }
-}
-
-@  When we insert a new active node for a break at |cur_p|, suppose this
-   new node is to be placed just before active node |a|; then we essentially
-   want to insert `$\delta\,|cur_p|\,\delta^\prime$' before |a|, where
-   $\delta=\alpha(a)-\alpha(|cur_p|)$ and $\delta^\prime=\alpha(|cur_p|)-\alpha(a)$
-   in the notation explained above.  The |cur_active_width| array now holds
-   $\gamma+\beta(|cur_p|)-\alpha(a)$; so $\delta$ can be obtained by
-   subtracting |cur_active_width| from the quantity $\gamma+\beta(|cur_p|)-
-   \alpha(|cur_p|)$. The latter quantity can be regarded as the length of a
-   line ``from |cur_p| to |cur_p|''; we call it the |break_width| at |cur_p|.
-
-   The |break_width| is usually negative, since it consists of the background
-   (which is normally zero) minus the width of nodes following~|cur_p| that are
-   eliminated after a break. If, for example, node |cur_p| is a glue node, the
-   width of this glue is subtracted from the background; and we also look
-   ahead to eliminate all subsequent glue and penalty and kern and math
-   nodes, subtracting their widths as well.
-
-   Kern nodes do not disappear at a line break unless they are |explicit|.
-
-@c
-static void compute_break_width(int break_type, int line_break_dir, int adjust_spacing, halfword p)
-{
-    halfword s = p; /* glue and other 'whitespace' to be skipped after a break;
-                       used if unhyphenated, or |post_break==empty| */
-    if (break_type > unhyphenated_node && p != null) {
-        /*Compute the discretionary |break_width| values; */
-        /* When |p| is a discretionary break, the length of a line
-           ``from |p| to |p|'' has to be defined properly so
-           that the other calculations work out.  Suppose that the
-           pre-break text at |p| has length $l_0$, the post-break
-           text has length $l_1$, and the replacement text has length
-           |l|. Suppose also that |q| is the node following the
-           replacement text. Then length of a line from |p| to |q|
-           will be computed as $\gamma+\beta(q)-\alpha(|p|)$, where
-           $\beta(q)=\beta(|p|)-l_0+l$. The actual length will be
-           the background plus $l_1$, so the length from |p| to
-           |p| should be $\gamma+l_0+l_1-l$.  If the post-break text
-           of the discretionary is empty, a break may also discard~|q|;
-           in that unusual case we subtract the length of~|q| and any
-           other nodes that will be discarded after the discretionary
-           break.
-
-           TH: I don't quite understand the above remarks.
-
-           The value of $l_0$ need not be computed, since |line_break|
-           will put it into the global variable |disc_width| before
-           calling |try_break|.
-         */
-        /* In case of nested discretionaries, we always follow the no-break
-           path, as we are talking about the breaking on {\it this} position.
-         */
-
-        sub_from_widths(vlink_no_break(p), line_break_dir, adjust_spacing, break_width);
-        add_to_widths(vlink_post_break(p), line_break_dir, adjust_spacing, break_width);
-        do_one_seven_eight(add_disc_width_to_break_width);
-        if (vlink_post_break(p) == null) {
-            s = vlink(p);       /* no |post_break|: 'skip' any 'whitespace' following */
-        } else {
-            s = null;
-        }
-    }
-    while (s != null) {
-        switch (type(s)) {
-            case math_node:
-                /* begin mathskip code */
-                if (glue_is_zero(s)) {
-                    break_width[1] -= surround(s);
-                    break;
-                } else {
-                    /* fall through */
-                }
-                /* end mathskip code */
-            case glue_node:
-                /*Subtract glue from |break_width|; */
-                break_width[1] -= width(s);
-                break_width[2 + stretch_order(s)] -= stretch(s);
-                break_width[7] -= shrink(s);
-                break;
-            case penalty_node:
-                break;
-            case kern_node:
-                if (subtype(s) != explicit_kern && subtype(s) != italic_kern)
-                    return;
-                else
-                    break_width[1] -= width(s);
-                break;
-            default:
-                return;
-        };
-        s = vlink(s);
-    }
-}
-
-@ @c
-static void print_break_node(halfword q, fitness_value fit_class,
-    quarterword break_type, halfword cur_p)
-{
-    /* Print a symbolic description of the new break node */
-    tprint_nl("@@@@");
-    print_int(serial(passive));
-    tprint(": line ");
-    print_int(line_number(q) - 1);
-    print_char('.');
-    print_int(fit_class);
-    if (break_type == hyphenated_node)
-        print_char('-');
-    tprint(" t=");
-    print_int(total_demerits(q));
-    if (do_last_line_fit) {
-        /*Print additional data in the new active node; */
-        tprint(" s=");
-        print_scaled(active_short(q));
-        if (cur_p == null)
-            tprint(" a=");
-        else
-            tprint(" g=");
-        print_scaled(active_glue(q));
-    }
-    tprint(" -> @@");
-    if (prev_break(passive) == null)
-        print_char('0');
-    else
-        print_int(serial(prev_break(passive)));
-}
-
-@ @c
-static void print_feasible_break(halfword cur_p, pointer r, halfword b, int pi,
-    int d, boolean artificial_demerits)
-{
-    /* Print a symbolic description of this feasible break; */
-    if (printed_node != cur_p) {
-        /* Print the list between |printed_node| and |cur_p|, then
-           set |printed_node:=cur_p|; */
-        tprint_nl("");
-        if (cur_p == null) {
-            short_display(vlink(printed_node));
-        } else {
-            halfword save_link = vlink(cur_p);
-            vlink(cur_p) = null;
-            tprint_nl("");
-            short_display(vlink(printed_node));
-            vlink(cur_p) = save_link;
-        }
-        printed_node = cur_p;
-    }
-    tprint_nl("@@");
-    if (cur_p == null) {
-        tprint_esc("par");
-    } else if (type(cur_p) != glue_node) {
-        if (type(cur_p) == penalty_node)
-            tprint_esc("penalty");
-        else if (type(cur_p) == disc_node)
-            tprint_esc("discretionary");
-        else if (type(cur_p) == kern_node)
-            tprint_esc("kern");
-        else
-            tprint_esc("math");
-    }
-    tprint(" via @@");
-    if (break_node(r) == null)
-        print_char('0');
-    else
-        print_int(serial(break_node(r)));
-    tprint(" b=");
-    if (b > inf_bad)
-        print_char('*');
-    else
-        print_int(b);
-    tprint(" p=");
-    print_int(pi);
-    tprint(" d=");
-    if (artificial_demerits)
-        print_char('*');
-    else
-        print_int(d);
-}
-
-@ @c
-#define add_disc_width_to_active_width(a)   active_width[a] += disc_width[a]
-#define update_width(a) cur_active_width[a] += varmem[(r+(a))].cint
-
-#define set_break_width_to_background(a) break_width[a]=background[(a)]
-
-#define convert_to_break_width(a) \
-  varmem[(prev_r+(a))].cint = varmem[(prev_r+(a))].cint-cur_active_width[(a)]+break_width[(a)]
-
-#define store_break_width(a) active_width[(a)]=break_width[(a)]
-
-#define new_delta_to_break_width(a) \
-  varmem[(q+(a))].cint=break_width[(a)]-cur_active_width[(a)]
-
-#define new_delta_from_break_width(a) \
-  varmem[(q+(a))].cint=cur_active_width[(a)]-break_width[(a)]
-
-#define copy_to_cur_active(a) cur_active_width[(a)]=active_width[(a)]
-
-#define combine_two_deltas(a) varmem[(prev_r+(a))].cint += varmem[(r+(a))].cint
-#define downdate_width(a) cur_active_width[(a)] -= varmem[(prev_r+(a))].cint
-#define update_active(a) active_width[(a)]+=varmem[(r+(a))].cint
-
-#define total_font_stretch cur_active_width[8]
-#define total_font_shrink cur_active_width[9]
-
-#define cal_margin_kern_var(a) { \
-    character(cp) = character((a)); \
-    font(cp) = font((a)); \
-    do_subst_font(cp, 1000); \
-    if (font(cp) != font((a))) \
-        margin_kern_stretch += (left_pw((a)) - left_pw(cp)); \
-    font(cp) = font((a)); \
-    do_subst_font(cp, -1000); \
-    if (font(cp) != font((a))) \
-        margin_kern_shrink += (left_pw(cp) - left_pw((a))); \
-}
-
-static void ext_try_break(int pi,
-                          quarterword break_type,
-                          int line_break_dir,
-                          int adjust_spacing,
-                          int par_shape_ptr,
-                          int adj_demerits,
-                          int tracing_paragraphs,
-                          int protrude_chars,
-                          int line_penalty,
-                          int last_line_fit,
-                          int double_hyphen_demerits,
-                          int final_hyphen_demerits, halfword first_p, halfword cur_p)
-{
-    /* labels: |CONTINUE,DEACTIVATE,FOUND,NOT_FOUND|; */
-    pointer r;                  /* runs through the active list */
-    scaled margin_kern_stretch;
-    scaled margin_kern_shrink;
-    halfword lp, rp, cp;
-    halfword prev_r = active;    /* stays a step behind |r| */
-    halfword prev_prev_r = null; /*a step behind |prev_r|, if |type(prev_r)=delta_node| */
-    halfword old_l = 0;          /* maximum line number in current equivalence class of lines */
-    boolean no_break_yet = true; /* have we found a feasible break at |cur_p|? */
-    halfword q;                  /*points to a new node being created */
-    halfword l;                  /*line number of current active node */
-    boolean node_r_stays_active; /*should node |r| remain in the active list? */
-    scaled line_width = 0;       /*the current line will be justified to this width */
-    fitness_value fit_class;     /*possible fitness class of test line */
-    halfword b;                  /*badness of test line */
-    int d;                       /*demerits of test line */
-    boolean artificial_demerits; /*has |d| been forced to zero? */
-
-    scaled shortfall;           /*used in badness calculations */
-    scaled g = 0;               /*glue stretch or shrink of test line, adjustment for last line */
-    scaled cur_active_width[10] = { 0 }; /*distance from current active node */
-
-    /*Make sure that |pi| is in the proper range; */
-    if (pi >= inf_penalty) {
-        return;                 /* this breakpoint is inhibited by infinite penalty */
-    } else if (pi <= -inf_penalty) {
-        pi = eject_penalty;     /*this breakpoint will be forced */
-    }
-
-    do_all_eight(copy_to_cur_active);
-
-    while (1) {
-        r = vlink(prev_r);
-        /* If node |r| is of type |delta_node|, update |cur_active_width|,
-           set |prev_r| and |prev_prev_r|, then |goto continue|; */
-        /* The following code uses the fact that |type(active)<>delta_node| */
-        if (type(r) == delta_node) {
-            do_all_eight(update_width); /* IMPLICIT ,r */
-            prev_prev_r = prev_r;
-            prev_r = r;
-            continue;
-        }
-        /* If a line number class has ended, create new active nodes for
-           the best feasible breaks in that class; then |return|
-           if |r=active|, otherwise compute the new |line_width|; */
-        /* The first part of the following code is part of \TeX's inner loop, so
-           we don't want to waste any time. The current active node, namely node |r|,
-           contains the line number that will be considered next. At the end of the
-           list we have arranged the data structure so that |r=active| and
-           |line_number(active)>old_l|.
-         */
-        l = line_number(r);
-        if (l > old_l) {        /* now we are no longer in the inner loop */
-            if ((minimum_demerits < awful_bad)
-                && ((old_l != easy_line) || (r == active))) {
-                /*Create new active nodes for the best feasible breaks just found */
-                /* It is not necessary to create new active nodes having |minimal_demerits|
-                   greater than
-                   |minimum_demerits+abs(adj_demerits)|, since such active nodes will never
-                   be chosen in the final paragraph breaks. This observation allows us to
-                   omit a substantial number of feasible breakpoints from further consideration.
-                 */
-                if (no_break_yet) {
-                    no_break_yet = false;
-                    do_all_eight(set_break_width_to_background);
-                    compute_break_width(break_type, line_break_dir, adjust_spacing, cur_p);
-                }
-                /* Insert a delta node to prepare for breaks at |cur_p|; */
-                /* We use the fact that |type(active)<>delta_node|. */
-                if (type(prev_r) == delta_node) {       /* modify an existing delta node */
-                    do_all_eight(convert_to_break_width);       /* IMPLICIT |prev_r| */
-                } else if (prev_r == active) {  /* no delta node needed at the beginning */
-                    do_all_eight(store_break_width);
-                } else {
-                    q = new_node(delta_node, 0);
-                    vlink(q) = r;
-                    do_all_eight(new_delta_to_break_width);     /* IMPLICIT q */
-                    vlink(prev_r) = q;
-                    prev_prev_r = prev_r;
-                    prev_r = q;
-                }
-
-                if (abs(adj_demerits) >= awful_bad - minimum_demerits)
-                    minimum_demerits = awful_bad - 1;
-                else
-                    minimum_demerits += abs(adj_demerits);
-                for (fit_class = very_loose_fit; fit_class <= tight_fit;
-                     fit_class++) {
-                    if (minimal_demerits[fit_class] <= minimum_demerits) {
-                        /* Insert a new active node from |best_place[fit_class]|
-                           to |cur_p|; */
-                        /* When we create an active node, we also create the corresponding
-                           passive node.
-                         */
-                        q = new_node(passive_node, 0);
-                        vlink(q) = passive;
-                        passive = q;
-                        cur_break(q) = cur_p;
-                        incr(pass_number);
-                        serial(q) = pass_number;
-                        prev_break(q) = best_place[fit_class];
-                        /*Here we keep track of the subparagraph penalties in the break nodes */
-                        passive_pen_inter(q) = internal_pen_inter;
-                        passive_pen_broken(q) = internal_pen_broken;
-                        passive_last_left_box(q) = internal_left_box;
-                        passive_last_left_box_width(q) =
-                            internal_left_box_width;
-                        if (prev_break(q) != null) {
-                            passive_left_box(q) =
-                                passive_last_left_box(prev_break(q));
-                            passive_left_box_width(q) =
-                                passive_last_left_box_width(prev_break(q));
-                        } else {
-                            passive_left_box(q) = init_internal_left_box;
-                            passive_left_box_width(q) =
-                                init_internal_left_box_width;
-                        }
-                        passive_right_box(q) = internal_right_box;
-                        passive_right_box_width(q) = internal_right_box_width;
-                        q = new_node(break_type, fit_class);
-                        break_node(q) = passive;
-                        line_number(q) = best_pl_line[fit_class] + 1;
-                        total_demerits(q) = minimal_demerits[fit_class];
-                        if (do_last_line_fit) {
-                            /*Store additional data in the new active node */
-                            /* Here we save these data in the active node
-                               representing a potential line break. */
-                            active_short(q) = best_pl_short[fit_class];
-                            active_glue(q) = best_pl_glue[fit_class];
-                        }
-                        vlink(q) = r;
-                        vlink(prev_r) = q;
-                        prev_r = q;
-                        if (tracing_paragraphs > 0)
-                            print_break_node(q, fit_class, break_type, cur_p);
-                    }
-                    minimal_demerits[fit_class] = awful_bad;
-                }
-                minimum_demerits = awful_bad;
-                /* Insert a delta node to prepare for the next active node; */
-                /* When the following code is performed, we will have just inserted at
-                   least one active node before |r|, so |type(prev_r)<>delta_node|.
-                 */
-                if (r != active) {
-                    q = new_node(delta_node, 0);
-                    vlink(q) = r;
-                    do_all_eight(new_delta_from_break_width);   /* IMPLICIT q */
-                    vlink(prev_r) = q;
-                    prev_prev_r = prev_r;
-                    prev_r = q;
-                }
-            }
-            if (r == active)
-                return;
-            /*Compute the new line width; */
-            /* When we come to the following code, we have just encountered
-               the first active node~|r| whose |line_number| field contains
-               |l|. Thus we want to compute the length of the $l\mskip1mu$th
-               line of the current paragraph. Furthermore, we want to set
-               |old_l| to the last number in the class of line numbers
-               equivalent to~|l|.
-             */
-            if (l > easy_line) {
-                old_l = max_halfword - 1;
-                line_width = second_width;
-            } else {
-                old_l = l;
-                if (l > last_special_line) {
-                    line_width = second_width;
-                } else if (par_shape_ptr == null) {
-                    line_width = first_width;
-                } else {
-                    line_width = varmem[(par_shape_ptr + 2 * l + 1)].cint;
-                }
-            }
-        }
-        /* /If a line number class has ended, create new active nodes for
-           the best feasible breaks in that class; then |return|
-           if |r=active|, otherwise compute the new |line_width|; */
-
-        /* Consider the demerits for a line from |r| to |cur_p|;
-           deactivate node |r| if it should no longer be active;
-           then |goto continue| if a line from |r| to |cur_p| is infeasible,
-           otherwise record a new feasible break; */
-        artificial_demerits = false;
-        shortfall = line_width - cur_active_width[1];
-        if (break_node(r) == null)
-            shortfall -= init_internal_left_box_width;
-        else
-            shortfall -= passive_last_left_box_width(break_node(r));
-        shortfall -= internal_right_box_width;
-        if (protrude_chars > 1) {
-            halfword l1, o;
-            l1 = (break_node(r) == null) ? first_p : cur_break(break_node(r));
-            if (cur_p == null) {
-                o = null;
-            } else {            /* TODO |if (is_character_node(alink(cur_p)))| */
-                o = alink(cur_p);
-                assert(vlink(o) == cur_p);
-            }
-            /* MAGIC: the disc could be a SELECT subtype, to we might need
-             to get the last character as |pre_break| from either the
-             |pre_break| list (if the previous INIT disc was taken), or the
-             |no_break| (sic) list (if the previous INIT disc was not taken)
-
-             BUT:
-             the last characters (hyphenation character) if these two list
-             should always be the same anyway, so we just look at |pre_break|.
-             */
-            /* let's look at the right margin first */
-            if ((cur_p != null) && (type(cur_p) == disc_node)
-                && (vlink_pre_break(cur_p) != null)) {
-                /* a |disc_node| with non-empty |pre_break|, protrude the last char of |pre_break| */
-                o = tlink_pre_break(cur_p);
-            } else {
-                o = find_protchar_right(l1, o);
-            }
-            /* now the left margin */
-            if ((l1 != null) && (type(l1) == disc_node) && (vlink_post_break(l1) != null)) {
-                /* FIXME: first 'char' could be a disc! */
-                l1 = vlink_post_break(l1);        /* protrude the first char */
-            } else {
-                l1 = find_protchar_left(l1, true);
-            }
-            shortfall += (left_pw(l1) + right_pw(o));
-        }
-        if (shortfall != 0) {
-            margin_kern_stretch = 0;
-            margin_kern_shrink = 0;
-            if (protrude_chars > 1) {
-                /* Calculate variations of marginal kerns; */
-                lp = last_leftmost_char;
-                rp = last_rightmost_char;
-                cp = raw_glyph_node();
-                if (lp != null) {
-                    cal_margin_kern_var(lp);
-                }
-                if (rp != null) {
-                    cal_margin_kern_var(rp);
-                }
-                flush_node(cp);
-            }
-            if ((shortfall > 0) && ((total_font_stretch + margin_kern_stretch) > 0)) {
-                if ((total_font_stretch + margin_kern_stretch) > shortfall)
-                    shortfall = ((total_font_stretch + margin_kern_stretch) / (max_stretch_ratio / cur_font_step)) / 2;
-                else
-                    shortfall -= (total_font_stretch + margin_kern_stretch);
-            } else if ((shortfall < 0) && ((total_font_shrink + margin_kern_shrink) > 0)) {
-                if ((total_font_shrink + margin_kern_shrink) > -shortfall)
-                    shortfall = -((total_font_shrink + margin_kern_shrink) / (max_shrink_ratio / cur_font_step)) / 2;
-                else
-                    shortfall += (total_font_shrink + margin_kern_shrink);
-            }
-        }
-        if (shortfall > 0) {
-            /* Set the value of |b| to the badness for stretching the line,
-               and compute the corresponding |fit_class| */
-
-            /* When a line must stretch, the available stretchability can be
-               found in the subarray |cur_active_width[2..6]|, in units of
-               points, sfi, fil, fill and filll.
-
-               The present section is part of \TeX's inner loop, and it is
-               most often performed when the badness is infinite; therefore
-               it is worth while to make a quick test for large width excess
-               and small stretchability, before calling the |badness|
-               subroutine. */
-
-            if ((cur_active_width[3] != 0) || (cur_active_width[4] != 0) ||
-                (cur_active_width[5] != 0) || (cur_active_width[6] != 0)) {
-                if (do_last_line_fit) {
-                    if (cur_p == null) {        /* the last line of a paragraph */
-                        /* Perform computations for last line and |goto found|; */
-
-                        /* Here we compute the adjustment |g| and badness |b| for
-                           a line from |r| to the end of the paragraph.  When any
-                           of the criteria for adjustment is violated we fall
-                           through to the normal algorithm.
-
-                           The last line must be too short, and have infinite
-                           stretch entirely due to |par_fill_skip|. */
-                        if ((active_short(r) == 0) || (active_glue(r) <= 0))
-                            /* previous line was neither stretched nor shrunk, or
-                               was infinitely bad */
-                            goto NOT_FOUND;
-                        if ((cur_active_width[3] != fill_width[0]) ||
-                            (cur_active_width[4] != fill_width[1]) ||
-                            (cur_active_width[5] != fill_width[2]) ||
-                            (cur_active_width[6] != fill_width[3]))
-                            /* infinite stretch of this line not entirely due to
-                               |par_fill_skip| */
-                            goto NOT_FOUND;
-                        if (active_short(r) > 0)
-                            g = cur_active_width[2];
-                        else
-                            g = cur_active_width[7];
-                        if (g <= 0)
-                            /*no finite stretch resp.\ no shrink */
-                            goto NOT_FOUND;
-                        arith_error = false;
-                        g = fract(g, active_short(r), active_glue(r),
-                                  max_dimen);
-                        if (last_line_fit < 1000)
-                            g = fract(g, last_line_fit, 1000, max_dimen);
-                        if (arith_error) {
-                            if (active_short(r) > 0)
-                                g = max_dimen;
-                            else
-                                g = -max_dimen;
-                        }
-                        if (g > 0) {
-                            /*Set the value of |b| to the badness of the last line
-                               for stretching, compute the corresponding |fit_class,
-                               and |goto found|| */
-                            /* These badness computations are rather similar to
-                               those of the standard algorithm, with the adjustment
-                               amount |g| replacing the |shortfall|. */
-                            if (g > shortfall)
-                                g = shortfall;
-                            if (g > 7230584) {
-                                if (cur_active_width[2] < 1663497) {
-                                    b = inf_bad;
-                                    fit_class = very_loose_fit;
-                                    goto FOUND;
-                                }
-                            }
-                            b = badness(g, cur_active_width[2]);
-                            if (b > 99) {
-                                fit_class = very_loose_fit;
-                            } else if (b > 12) {
-                                fit_class = loose_fit;
-                            } else {
-                                fit_class = decent_fit;
-                            }
-                            goto FOUND;
-                        } else if (g < 0) {
-                            /*Set the value of |b| to the badness of the last line
-                               for shrinking, compute the corresponding |fit_class,
-                               and |goto found||; */
-                            if (-g > cur_active_width[7])
-                                g = -cur_active_width[7];
-                            b = badness(-g, cur_active_width[7]);
-                            if (b > 12)
-                                fit_class = tight_fit;
-                            else
-                                fit_class = decent_fit;
-                            goto FOUND;
-                        }
-                    }
-                  NOT_FOUND:
-                    shortfall = 0;
-                }
-                b = 0;
-                fit_class = decent_fit; /* infinite stretch */
-            } else {
-                if (shortfall > 7230584 && cur_active_width[2] < 1663497) {
-                    b = inf_bad;
-                    fit_class = very_loose_fit;
-                } else {
-                    b = badness(shortfall, cur_active_width[2]);
-                    if (b > 99) {
-                        fit_class = very_loose_fit;
-                    } else if (b > 12) {
-                        fit_class = loose_fit;
-                    } else {
-                        fit_class = decent_fit;
-                    }
-                }
-            }
-        } else {
-            /* Set the value of |b| to the badness for shrinking the line,
-               and compute the corresponding |fit_class|; */
-            /* Shrinkability is never infinite in a paragraph; we can shrink
-               the line from |r| to |cur_p| by at most
-               |cur_active_width[7]|. */
-            if (-shortfall > cur_active_width[7])
-                b = inf_bad + 1;
-            else
-                b = badness(-shortfall, cur_active_width[7]);
-            if (b > 12)
-                fit_class = tight_fit;
-            else
-                fit_class = decent_fit;
-        }
-        if (do_last_line_fit) {
-            /* Adjust the additional data for last line; */
-            if (cur_p == null)
-                shortfall = 0;
-            if (shortfall > 0) {
-                g = cur_active_width[2];
-            } else if (shortfall < 0) {
-                g = cur_active_width[7];
-            } else {
-                g = 0;
-            }
-        }
-      FOUND:
-        if ((b > inf_bad) || (pi == eject_penalty)) {
-            /* Prepare to deactivate node~|r|, and |goto deactivate| unless
-               there is a reason to consider lines of text from |r| to |cur_p| */
-            /* During the final pass, we dare not lose all active nodes, lest we lose
-               touch with the line breaks already found. The code shown here makes
-               sure that such a catastrophe does not happen, by permitting overfull
-               boxes as a last resort. This particular part of \TeX\ was a source of
-               several subtle bugs before the correct program logic was finally
-               discovered; readers who seek to ``improve'' \TeX\ should therefore
-               think thrice before daring to make any changes here.
-             */
-            if (final_pass && (minimum_demerits == awful_bad) &&
-                (vlink(r) == active) && (prev_r == active)) {
-                artificial_demerits = true;     /* set demerits zero, this break is forced */
-            } else if (b > threshold) {
-                goto DEACTIVATE;
-            }
-            node_r_stays_active = false;
-        } else {
-            prev_r = r;
-            if (b > threshold)
-                continue;
-            node_r_stays_active = true;
-        }
-        /* Record a new feasible break; */
-        /* When we get to this part of the code, the line from |r| to |cur_p| is
-           feasible, its badness is~|b|, and its fitness classification is
-           |fit_class|.  We don't want to make an active node for this break yet,
-           but we will compute the total demerits and record them in the
-           |minimal_demerits| array, if such a break is the current champion among
-           all ways to get to |cur_p| in a given line-number class and fitness
-           class.
-         */
-        if (artificial_demerits) {
-            d = 0;
-        } else {
-            /* Compute the demerits, |d|, from |r| to |cur_p|; */
-            d = line_penalty + b;
-            if (abs(d) >= 10000)
-                d = 100000000;
-            else
-                d = d * d;
-            if (pi != 0) {
-                if (pi > 0) {
-                    d += (pi * pi);
-                } else if (pi > eject_penalty) {
-                    d -= (pi * pi);
-                }
-            }
-            if ((break_type == hyphenated_node) && (type(r) == hyphenated_node)) {
-                if (cur_p != null)
-                    d += double_hyphen_demerits;
-                else
-                    d += final_hyphen_demerits;
-            }
-            if (abs(fit_class - fitness(r)) > 1)
-                d = d + adj_demerits;
-        }
-        if (tracing_paragraphs > 0)
-            print_feasible_break(cur_p, r, b, pi, d, artificial_demerits);
-        d += total_demerits(r); /*this is the minimum total demerits
-                                   from the beginning to |cur_p| via |r| */
-        if (d <= minimal_demerits[fit_class]) {
-            minimal_demerits[fit_class] = d;
-            best_place[fit_class] = break_node(r);
-            best_pl_line[fit_class] = l;
-            if (do_last_line_fit) {
-                /* Store additional data for this feasible break; */
-                /* For each feasible break we record the shortfall and glue stretch or
-                   shrink (or adjustment). */
-                best_pl_short[fit_class] = shortfall;
-                best_pl_glue[fit_class] = g;
-            }
-            if (d < minimum_demerits)
-                minimum_demerits = d;
-        }
-        /* /Record a new feasible break */
-        if (node_r_stays_active)
-            continue;           /*|prev_r| has been set to |r| */
-      DEACTIVATE:
-        /* Deactivate node |r|; */
-        /* When an active node disappears, we must delete an adjacent delta node if
-           the active node was at the beginning or the end of the active list, or
-           if it was surrounded by delta nodes. We also must preserve the property
-           that |cur_active_width| represents the length of material from
-           |vlink(prev_r)| to~|cur_p|. */
-
-        vlink(prev_r) = vlink(r);
-        flush_node(r);
-        if (prev_r == active) {
-            /*Update the active widths, since the first active node has been
-               deleted */
-            /* The following code uses the fact that |type(active)<>delta_node|.
-               If the active list has just become empty, we do not need to update the
-               |active_width| array, since it will be initialized when an active
-               node is next inserted.
-             */
-            r = vlink(active);
-            if (type(r) == delta_node) {
-                do_all_eight(update_active);    /* IMPLICIT r */
-                do_all_eight(copy_to_cur_active);
-                vlink(active) = vlink(r);
-                flush_node(r);
-            }
-        } else if (type(prev_r) == delta_node) {
-            r = vlink(prev_r);
-            if (r == active) {
-                do_all_eight(downdate_width);   /* IMPLICIT |prev_r| */
-                vlink(prev_prev_r) = active;
-                flush_node(prev_r);
-                prev_r = prev_prev_r;
-            } else if (type(r) == delta_node) {
-                do_all_eight(update_width);     /* IMPLICIT ,r */
-                do_all_eight(combine_two_deltas);       /* IMPLICIT r |prev_r| */
-                vlink(prev_r) = vlink(r);
-                flush_node(r);
-            }
-        }
-    }
-}
-
-@ @c
-void ext_do_line_break(int paragraph_dir,
-                       int pretolerance,
-                       int tracing_paragraphs,
-                       int tolerance,
-                       scaled emergency_stretch,
-                       int looseness,
-                       int adjust_spacing,
-                       halfword par_shape_ptr,
-                       int adj_demerits,
-                       int protrude_chars,
-                       int line_penalty,
-                       int last_line_fit,
-                       int double_hyphen_demerits,
-                       int final_hyphen_demerits,
-                       int hang_indent,
-                       int hsize,
-                       int hang_after,
-                       halfword left_skip,
-                       halfword right_skip,
-                       halfword inter_line_penalties_ptr,
-                       int inter_line_penalty,
-                       int club_penalty,
-                       halfword club_penalties_ptr,
-                       halfword widow_penalties_ptr,
-                       int widow_penalty,
-                       int broken_penalty,
-                       halfword final_par_glue)
-{
-    /* DONE,DONE1,DONE2,DONE3,DONE4,DONE5,CONTINUE; */
-    halfword cur_p, q, r, s;    /* miscellaneous nodes of temporary interest */
-    int line_break_dir = paragraph_dir;
-
-    /* Get ready to start ... */
-    minimum_demerits = awful_bad;
-    minimal_demerits[tight_fit] = awful_bad;
-    minimal_demerits[decent_fit] = awful_bad;
-    minimal_demerits[loose_fit] = awful_bad;
-    minimal_demerits[very_loose_fit] = awful_bad;
-
-    fewest_demerits = 0;
-    actual_looseness = 0;
-
-    /* We compute the values of |easy_line| and the other local variables relating
-       to line length when the |line_break| procedure is initializing itself. */
-    if (par_shape_ptr == null) {
-        if (hang_indent == 0) {
-            last_special_line = 0;
-            second_width = hsize;
-            second_indent = 0;
-        } else {
-            halfword used_hang_indent = swap_hang_indent(hang_indent);
-            /*  Set line length parameters in preparation for hanging indentation */
-            /* We compute the values of |easy_line| and the other local variables relating
-               to line length when the |line_break| procedure is initializing itself. */
-            last_special_line = abs(hang_after);
-            if (hang_after < 0) {
-                first_width = hsize - abs(used_hang_indent);
-                if (used_hang_indent >= 0)
-                    first_indent = used_hang_indent;
-                else
-                    first_indent = 0;
-                second_width = hsize;
-                second_indent = 0;
-            } else {
-                first_width = hsize;
-                first_indent = 0;
-                second_width = hsize - abs(used_hang_indent);
-                if (used_hang_indent >= 0)
-                    second_indent = used_hang_indent;
-                else
-                    second_indent = 0;
-            }
-        }
-    } else {
-        last_special_line = vinfo(par_shape_ptr + 1) - 1;
-        second_indent = varmem[(par_shape_ptr + 2 * (last_special_line + 1))].cint;
-        second_width = varmem[(par_shape_ptr + 2 * (last_special_line + 1) + 1)].cint;
-        second_indent = swap_parshape_indent(second_indent,second_width);
-    }
-    if (looseness == 0)
-        easy_line = last_special_line;
-    else
-        easy_line = max_halfword;
-
-    no_shrink_error_yet = true;
-    check_shrinkage(left_skip);
-    check_shrinkage(right_skip);
-    q = left_skip;
-    r = right_skip;
-    background[1] = width(q) + width(r);
-    background[2] = 0;
-    background[3] = 0;
-    background[4] = 0;
-    background[5] = 0;
-    background[6] = 0;
-    background[2 + stretch_order(q)] = stretch(q);
-    background[2 + stretch_order(r)] += stretch(r);
-    background[7] = shrink(q) + shrink(r);
-    if (adjust_spacing > 1) {
-        background[8] = 0;
-        background[9] = 0;
-        max_stretch_ratio = -1;
-        max_shrink_ratio = -1;
-        cur_font_step = -1;
-        set_prev_char_p(null);
-    }
-    /* Check for special treatment of last line of paragraph; */
-    /* The new algorithm for the last line requires that the stretchability
-       |par_fill_skip| is infinite and the stretchability of |left_skip| plus
-       |right_skip| is finite.
-     */
-    do_last_line_fit = false;
-    if (last_line_fit > 0) {
-        q = last_line_fill;
-        if ((stretch(q) > 0) && (stretch_order(q) > normal)) {
-            if ((background[3] == 0) && (background[4] == 0) &&
-                (background[5] == 0) && (background[6] == 0)) {
-                do_last_line_fit = true;
-                fill_width[0] = 0;
-                fill_width[1] = 0;
-                fill_width[2] = 0;
-                fill_width[3] = 0;
-                fill_width[stretch_order(q) - 1] = stretch(q);
-            }
-        }
-    }
-    /* DIR: Initialize |dir_ptr| for |line_break| */
-    if (dir_ptr != null) {
-        flush_node_list(dir_ptr);
-        dir_ptr = null;
-    }
-#if 0
-    push_dir(dir_ptr,paragraph_dir); /* TODO what was the point of this? */
-#endif
-
-    /* Find optimal breakpoints; */
-    threshold = pretolerance;
-    if (threshold >= 0) {
-        if (tracing_paragraphs > 0) {
-            begin_diagnostic();
-            tprint_nl("@@firstpass");
-        }
-        second_pass = false;
-        final_pass = false;
-    } else {
-        threshold = tolerance;
-        second_pass = true;
-        final_pass = (emergency_stretch <= 0);
-        if (tracing_paragraphs > 0)
-            begin_diagnostic();
-    }
-    while (1) {
-        halfword first_p;
-        halfword nest_stack[10];
-        int nest_index = 0;
-        if (threshold > inf_bad)
-            threshold = inf_bad;
-        /* Create an active breakpoint representing the beginning of the paragraph */
-        q = new_node(unhyphenated_node, decent_fit);
-        vlink(q) = active;
-        break_node(q) = null;
-        line_number(q) = cur_list.pg_field + 1;
-        total_demerits(q) = 0;
-        active_short(q) = 0;
-        active_glue(q) = 0;
-        vlink(active) = q;
-        do_all_eight(store_background);
-        passive = null;
-        printed_node = temp_head;
-        pass_number = 0;
-        font_in_short_display = null_font;
-        /* /Create an active breakpoint representing the beginning of the paragraph */
-        auto_breaking = true;
-        cur_p = vlink(temp_head);
-        /* LOCAL: Initialize with first |local_paragraph| node */
-        if ((cur_p != null) && (type(cur_p) == local_par_node)) {
-            alink(cur_p) = temp_head; /* this used to be an assert, but may as well force it */
-            internal_pen_inter = local_pen_inter(cur_p);
-            internal_pen_broken = local_pen_broken(cur_p);
-            init_internal_left_box = local_box_left(cur_p);
-            init_internal_left_box_width = local_box_left_width(cur_p);
-            internal_left_box = init_internal_left_box;
-            internal_left_box_width = init_internal_left_box_width;
-            internal_right_box = local_box_right(cur_p);
-            internal_right_box_width = local_box_right_width(cur_p);
-        } else {
-            internal_pen_inter = 0;
-            internal_pen_broken = 0;
-            init_internal_left_box = null;
-            init_internal_left_box_width = 0;
-            internal_left_box = init_internal_left_box;
-            internal_left_box_width = init_internal_left_box_width;
-            internal_right_box = null;
-            internal_right_box_width = 0;
-        }
-        /* /LOCAL: Initialize with first |local_paragraph| node */
-        set_prev_char_p(null);
-        first_p = cur_p;
-        /* to access the first node of paragraph as the first active node
-           has |break_node=null| */
-        while ((cur_p != null) && (vlink(active) != active)) {
-            /* |try_break| if |cur_p| is a legal breakpoint; on the 2nd pass, also look at |disc_node|s. */
-
-            while (is_char_node(cur_p)) {
-                /* Advance |cur_p| to the node following the present string of characters ; */
-                /* The code that passes over the characters of words in a paragraph is part of
-                   \TeX's inner loop, so it has been streamlined for speed. We use the fact that
-                   `\.{\\parfillskip}' glue appears at the end of each paragraph; it is therefore
-                   unnecessary to check if |vlink(cur_p)=null| when |cur_p| is a character node.
-                 */
-                active_width[1] += pack_width(line_break_dir, dir_TRT, cur_p, true);
-                if ((adjust_spacing > 1) && check_expand_pars(font(cur_p))) {
-                    set_prev_char_p(cur_p);
-                    add_char_stretch(active_width[8], cur_p);
-                    add_char_shrink(active_width[9], cur_p);
-                }
-                cur_p = vlink(cur_p);
-                while (cur_p == null && nest_index > 0) {
-                    cur_p = nest_stack[--nest_index];
-                }
-            }
-            if (cur_p == null) {
-                normal_error("linebreak","invalid list tail, probably missing glue");
-            }
-            /* Determine legal breaks: As we move through the hlist, we need to keep
-               the |active_width| array up to date, so that the badness of individual
-               lines is readily calculated by |try_break|. It is convenient to use the
-               short name |active_width[1]| for the component of active width that represents
-               real width as opposed to glue. */
-
-            switch (type(cur_p)) {
-                case hlist_node:
-                case vlist_node:
-                    active_width[1] += pack_width(line_break_dir, box_dir(cur_p), cur_p, false);
-                    break;
-                case rule_node:
-                    active_width[1] += width(cur_p);
-                    break;
-                case dir_node: /* DIR: Adjust the dir stack for the |line_break| routine; */
-                    if (dir_dir(cur_p) >= 0) {
-                        line_break_dir = dir_dir(cur_p);
-                        push_dir_node(dir_ptr,cur_p);   /* adds to |dir_ptr| */
-                    } else {
-                        pop_dir_node(dir_ptr);
-                        if (dir_ptr != null) {
-                            line_break_dir = dir_dir(dir_ptr);
-                        }
-                    }
-                    break;
-                case local_par_node:   /* LOCAL: Advance past a |local_paragraph| node; */
-                    internal_pen_inter = local_pen_inter(cur_p);
-                    internal_pen_broken = local_pen_broken(cur_p);
-                    internal_left_box = local_box_left(cur_p);
-                    internal_left_box_width = local_box_left_width(cur_p);
-                    internal_right_box = local_box_right(cur_p);
-                    internal_right_box_width = local_box_right_width(cur_p);
-                    break;
-                case math_node:
-                    auto_breaking = (subtype(cur_p) == after);
-                    /* begin mathskip code */
-                    if (glue_is_zero(cur_p) || ignore_math_skip(cur_p)) {
-                        kern_break();
-                        break;
-                    } else {
-                        /* fall through */
-                    }
-                    /* end mathskip code */
-                case glue_node:
-                    /*
-                        If node |cur_p| is a legal breakpoint, call |try_break|;
-                        then update the active widths by including the glue in
-                        |glue_ptr(cur_p)|;
-
-                        When node |cur_p| is a glue node, we look at the previous
-                        to see whether or not a breakpoint is legal at |cur_p|,
-                        as explained above.
-
-                        We only break after certain nodes (see texnodes.h), a font related
-                        kern and a dir node when |\breakafterdirmode=1|.
-                    */
-                    if (auto_breaking) {
-                        halfword prev_p = alink(cur_p);
-                        if (prev_p != temp_head && (
-                                is_char_node(prev_p)
-                             || precedes_break(prev_p)
-                             || precedes_kern(prev_p)
-                             || precedes_dir(prev_p)
-                            )) {
-                            ext_try_break(0, unhyphenated_node, line_break_dir, adjust_spacing,
-                                          par_shape_ptr, adj_demerits,
-                                          tracing_paragraphs, protrude_chars,
-                                          line_penalty, last_line_fit,
-                                          double_hyphen_demerits,
-                                          final_hyphen_demerits, first_p, cur_p);
-                        }
-                    }
-                    /* *INDENT-ON* */
-                    check_shrinkage(cur_p);
-                    active_width[1] += width(cur_p);
-                    active_width[2 + stretch_order(cur_p)] += stretch(cur_p);
-                    active_width[7] += shrink(cur_p);
-                    break;
-                case kern_node:
-                    if (subtype(cur_p) == explicit_kern || subtype(cur_p) == italic_kern) {
-                        kern_break();
-                    } else {
-                        active_width[1] += width(cur_p);
-                        if ((adjust_spacing == 2) && (subtype(cur_p) == normal)) {
-                            add_kern_stretch(active_width[8], cur_p);
-                            add_kern_shrink(active_width[9], cur_p);
-                        }
-                    }
-                    break;
-                case disc_node:
-                    /* |select_disc|s are handled by the leading |init_disc| */
-                    if (subtype(cur_p) == select_disc)
-                        break;
-                    /* Try to break after a discretionary fragment, then |goto done5|; */
-                    /* The following code knows that discretionary texts contain
-                       only character nodes, kern nodes, box nodes, and rule
-                       nodes. This branch differs a bit from older engines because in LuaTeX we
-                       already have hyphenated the list. This means that we need to skip
-                       automatic disc nodes. Of better, we need to treat discretionaries
-                       and explicit hyphens always, even in the first pass (HH). */
-                    if (second_pass || subtype(cur_p) <= automatic_disc) {
-                        /*
-                        int actual_penalty = hyphen_penalty;
-                        if (disc_penalty(cur_p) != 0) {
-                            actual_penalty = (int) disc_penalty(cur_p);
-                        } else if (subtype(cur_p) == automatic_disc) {
-                            actual_penalty = ex_hyphen_penalty;
-                        }
-                        */
-                        int actual_penalty = (int) disc_penalty(cur_p);
-                        s = vlink_pre_break(cur_p);
-                        do_one_seven_eight(reset_disc_width);
-                        if (s == null) {    /* trivial pre-break */
-                            ext_try_break(actual_penalty, hyphenated_node,
-                                          line_break_dir, adjust_spacing,
-                                          par_shape_ptr, adj_demerits,
-                                          tracing_paragraphs, protrude_chars,
-                                          line_penalty, last_line_fit,
-                                          double_hyphen_demerits,
-                                          final_hyphen_demerits, first_p, cur_p);
-                        } else {
-                            add_to_widths(s, line_break_dir, adjust_spacing, disc_width);
-                            do_one_seven_eight(add_disc_width_to_active_width);
-                            ext_try_break(actual_penalty, hyphenated_node,
-                                          line_break_dir, adjust_spacing,
-                                          par_shape_ptr, adj_demerits,
-                                          tracing_paragraphs, protrude_chars,
-                                          line_penalty, last_line_fit,
-                                          double_hyphen_demerits,
-                                          final_hyphen_demerits, first_p, cur_p);
-                            if (subtype(cur_p) == init_disc) {
-                                /* we should at two break points after the one we
-                                 added above:
-                                 \item1 which does a possible break in INIT's |post_break|
-                                 \item2 which means the |no_break| actually was broken
-                                 just a character later */
-                                /* do the select-0 case 'f-f-i' */
-                                s = vlink_pre_break(vlink(cur_p));
-                                add_to_widths(s, line_break_dir, adjust_spacing, disc_width);
-                                ext_try_break(actual_penalty, hyphenated_node,
-                                              line_break_dir, adjust_spacing,
-                                              par_shape_ptr, adj_demerits,
-                                              tracing_paragraphs,
-                                              protrude_chars, line_penalty,
-                                              last_line_fit, double_hyphen_demerits,
-                                              final_hyphen_demerits, first_p,
-                                              vlink(cur_p));
-#if 0
-                                /* TODO this does not work */
-                                /* go back to the starting situation */
-                                do_one_seven_eight(sub_disc_width_from_active_width);
-                                do_one_seven_eight(reset_disc_width);
-                                /* add select |no_break| to |active_width| */
-                                s = vlink_no_break(vlink(cur_p));
-                                add_to_widths(s, line_break_dir, adjust_spacing, disc_width);
-                                ext_try_break(actual_penalty, hyphenated_node,
-                                              line_break_dir, adjust_spacing,
-                                              par_shape_ptr, adj_demerits,
-                                              tracing_paragraphs,
-                                              protrude_chars, line_penalty,
-                                              last_line_fit, double_hyphen_demerits,
-                                              final_hyphen_demerits, first_p,
-                                              vlink(cur_p));
-#endif
-                            }
-                            do_one_seven_eight(sub_disc_width_from_active_width);
-                        }
-                    }
-                    s = vlink_no_break(cur_p);
-                    add_to_widths(s, line_break_dir, adjust_spacing, active_width);
-                    break;
-                case penalty_node:
-                    ext_try_break(penalty(cur_p), unhyphenated_node, line_break_dir,
-                                  adjust_spacing, par_shape_ptr, adj_demerits,
-                                  tracing_paragraphs, protrude_chars,
-                                  line_penalty, last_line_fit,
-                                  double_hyphen_demerits, final_hyphen_demerits,
-                                  first_p, cur_p);
-                    break;
-                case boundary_node:
-                case whatsit_node:
-                    /* / Advance past a whatsit node in the |line_break| loop/; */
-                case mark_node:
-                case ins_node:
-                case adjust_node:
-                    break;
-                case glue_spec_node:
-                    normal_warning("parbuilder","found a glue_spec in a paragraph");
-                    break;
-                default:
-                    formatted_error("parbuilder","weird node %d in paragraph",type(cur_p));
-            }
-            cur_p = vlink(cur_p);
-            while (cur_p == null && nest_index > 0) {
-                cur_p = nest_stack[--nest_index];
-            }
-        }
-        if (cur_p == null) {
-            /*
-                Try the final line break at the end of the paragraph,
-                and |goto done| if the desired breakpoints have been found
-
-                The forced line break at the paragraph's end will reduce the list of
-                breakpoints so that all active nodes represent breaks at |cur_p=null|.
-                On the first pass, we insist on finding an active node that has the
-                correct ``looseness.'' On the final pass, there will be at least one active
-                node, and we will match the desired looseness as well as we can.
-
-                The global variable |best_bet| will be set to the active node for the best
-                way to break the paragraph, and a few other variables are used to
-                help determine what is best.
-            */
-            ext_try_break(eject_penalty, hyphenated_node, line_break_dir,
-                          adjust_spacing, par_shape_ptr, adj_demerits,
-                          tracing_paragraphs, protrude_chars, line_penalty,
-                          last_line_fit, double_hyphen_demerits,
-                          final_hyphen_demerits, first_p, cur_p);
-            if (vlink(active) != active) {
-                /* Find an active node with fewest demerits; */
-                r = vlink(active);
-                fewest_demerits = awful_bad;
-                do {
-                    if (type(r) != delta_node) {
-                        if (total_demerits(r) < fewest_demerits) {
-                            fewest_demerits = total_demerits(r);
-                            best_bet = r;
-                        }
-                    }
-                    r = vlink(r);
-                } while (r != active);
-                best_line = line_number(best_bet);
-                /*
-                    Find an active node with fewest demerits;
-                */
-                if (looseness == 0)
-                    goto DONE;
-                /*
-                    Find the best active node for the desired looseness;
-
-                    The adjustment for a desired looseness is a slightly more complicated
-                    version of the loop just considered. Note that if a paragraph is broken
-                    into segments by displayed equations, each segment will be subject to the
-                    looseness calculation, independently of the other segments.
-                 */
-                r = vlink(active);
-                actual_looseness = 0;
-                do {
-                    if (type(r) != delta_node) {
-                        line_diff = line_number(r) - best_line;
-                        if (((line_diff < actual_looseness)
-                             && (looseness <= line_diff))
-                            || ((line_diff > actual_looseness)
-                                && (looseness >= line_diff))) {
-                            best_bet = r;
-                            actual_looseness = line_diff;
-                            fewest_demerits = total_demerits(r);
-                        } else if ((line_diff == actual_looseness) &&
-                                   (total_demerits(r) < fewest_demerits)) {
-                            best_bet = r;
-                            fewest_demerits = total_demerits(r);
-                        }
-                    }
-                    r = vlink(r);
-                } while (r != active);
-                best_line = line_number(best_bet);
-                /*
-                    Find the best active node for the desired looseness;
-                */
-                if ((actual_looseness == looseness) || final_pass)
-                    goto DONE;
-            }
-        }
-        /* Clean up the memory by removing the break nodes; */
-        clean_up_the_memory();
-        /* /Clean up the memory by removing the break nodes; */
-        if (!second_pass) {
-            if (tracing_paragraphs > 0)
-                tprint_nl("@@secondpass");
-            threshold = tolerance;
-            second_pass = true;
-            final_pass = (emergency_stretch <= 0);
-        } else {
-            /* if at first you do not succeed, \dots */
-            if (tracing_paragraphs > 0)
-                tprint_nl("@@emergencypass");
-            background[2] += emergency_stretch;
-            final_pass = true;
-        }
-    }
-
-  DONE:
-    if (tracing_paragraphs > 0) {
-        end_diagnostic(true);
-        normalize_selector();
-    }
-    if (do_last_line_fit) {
-        /*
-            Adjust the final line of the paragraph; here we either reset
-            |do_last_line_fit| or adjust the |par_fill_skip| glue.
-        */
-        if (active_short(best_bet) == 0) {
-            do_last_line_fit = false;
-        } else {
-            width(last_line_fill) += (active_short(best_bet) - active_glue(best_bet));
-            stretch(last_line_fill) = 0;
-        }
-    }
-
-    /*
-        Break the paragraph at the chosen...; Once the best sequence of breakpoints
-        has been found (hurray), we call on the procedure |post_line_break| to finish
-        the remainder of the work. By introducing this subprocedure, we are able to
-        keep |line_break| from getting extremely long.
-    */
-
-    /* first thing |ext_post_line_break| does is reset |dir_ptr| */
-    flush_node_list(dir_ptr);
-    dir_ptr = null;
-    ext_post_line_break(paragraph_dir,
-                        right_skip,
-                        left_skip,
-                        protrude_chars,
-                        par_shape_ptr,
-                        adjust_spacing,
-                        inter_line_penalties_par_ptr,
-                        inter_line_penalty,
-                        club_penalty,
-                        club_penalties_ptr,
-                        widow_penalties_ptr,
-                        widow_penalty,
-                        broken_penalty,
-                        final_par_glue,
-                        best_bet,
-                        last_special_line,
-                        second_width,
-                        second_indent, first_width, first_indent, best_line);
-    /*
-        Break the paragraph at the chosen ...Clean up the memory by removing
-        the break nodes.
-    */
-    clean_up_the_memory();
-}
-
-@ @c
-void get_linebreak_info (int *f, int *a)
-{
-    *f = fewest_demerits;
-    *a = actual_looseness;
-}
diff --git a/texk/web2c/luatexdir/tex/mainbody.c b/texk/web2c/luatexdir/tex/mainbody.c
new file mode 100644
index 000000000..ca9a79dbb
--- /dev/null
+++ b/texk/web2c/luatexdir/tex/mainbody.c
@@ -0,0 +1,769 @@
+/*
+
+mainbody.w
+
+Copyright 2009-2010 Taco Hoekwater <taco@@luatex.org>
+
+This file is part of LuaTeX.
+
+LuaTeX is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 2 of the License, or (at your
+option) any later version.
+
+LuaTeX is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+License for more details.
+
+You should have received a copy of the GNU General Public License along
+with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#include "ptexlib.h"
+
+/*tex
+
+This is where the action starts. We're speaking of \LUATEX, a continuation of
+\PDFTEX\ (which included \ETEX) and \ALEPH. As \TEX, \LUATEX\ is a document
+compiler intended to simplify high quality typesetting for many of the world's
+languages. It is an extension of D. E. Knuth's \TEX, which was designed
+essentially for the typesetting of languages using the Latin alphabet. Although
+it is a direct decendant of \TEX, and therefore mostly compatible, there are
+some subtle differences that relate to \UNICODE\ support and \OPENTYPE\ math.
+
+The \ALEPH\ subsystem loosens many of the restrictions imposed by~\TeX: register
+numbers are no longer limited to 8~bits. Fonts may have more than 256~characters,
+more than 256~fonts may be used, etc. We use a similar model. We also borrowed
+the directional model but have upgraded it a bit as well as integrated it more
+tightly.
+
+This program is directly derived from Donald E. Knuth's \TEX; the change history
+which follows and the reward offered for finders of bugs refer specifically to
+\TEX; they should not be taken as referring to \LUATEX, \PDFTEX, nor \ETEX,
+although the change history is relevant in that it demonstrates the evolutionary
+path followed. This program is not \TEX; that name is reserved strictly for the
+program which is the creation and sole responsibility of Professor Knuth.
+
+\starttyping
+% Version 0 was released in September 1982 after it passed a variety of tests.
+% Version 1 was released in November 1983 after thorough testing.
+% Version 1.1 fixed ``disappearing font identifiers'' et alia (July 1984).
+% Version 1.2 allowed `0' in response to an error, et alia (October 1984).
+% Version 1.3 made memory allocation more flexible and local (November 1984).
+% Version 1.4 fixed accents right after line breaks, et alia (April 1985).
+% Version 1.5 fixed \the\toks after other expansion in \edefs (August 1985).
+% Version 2.0 (almost identical to 1.5) corresponds to "Volume B" (April 1986).
+% Version 2.1 corrected anomalies in discretionary breaks (January 1987).
+% Version 2.2 corrected "(Please type...)" with null \endlinechar (April 1987).
+% Version 2.3 avoided incomplete page in premature termination (August 1987).
+% Version 2.4 fixed \noaligned rules in indented displays (August 1987).
+% Version 2.5 saved cur_order when expanding tokens (September 1987).
+% Version 2.6 added 10sp slop when shipping leaders (November 1987).
+% Version 2.7 improved rounding of negative-width characters (November 1987).
+% Version 2.8 fixed weird bug if no \patterns are used (December 1987).
+% Version 2.9 made \csname\endcsname's "relax" local (December 1987).
+% Version 2.91 fixed \outer\def\a0{}\a\a bug (April 1988).
+% Version 2.92 fixed \patterns, also file names with complex macros (May 1988).
+% Version 2.93 fixed negative halving in allocator when mem_min<0 (June 1988).
+% Version 2.94 kept open_log_file from calling fatal_error (November 1988).
+% Version 2.95 solved that problem a better way (December 1988).
+% Version 2.96 corrected bug in "Infinite shrinkage" recovery (January 1989).
+% Version 2.97 corrected blunder in creating 2.95 (February 1989).
+% Version 2.98 omitted save_for_after at outer level (March 1989).
+% Version 2.99 caught $$\begingroup\halign..$$ (June 1989).
+% Version 2.991 caught .5\ifdim.6... (June 1989).
+% Version 2.992 introduced major changes for 8-bit extensions (September 1989).
+% Version 2.993 fixed a save_stack synchronization bug et alia (December 1989).
+% Version 3.0 fixed unusual displays; was more \output robust (March 1990).
+% Version 3.1 fixed nullfont, disabled \write{\the\prevgraf} (September 1990).
+% Version 3.14 fixed unprintable font names and corrected typos (March 1991).
+% Version 3.141 more of same; reconstituted ligatures better (March 1992).
+% Version 3.1415 preserved nonexplicit kerns, tidied up (February 1993).
+% Version 3.14159 allowed fontmemsize to change; bulletproofing (March 1995).
+% Version 3.141592 fixed \xleaders, glueset, weird alignments (December 2002).
+% Version 3.1415926 was a general cleanup with minor fixes (February 2008).
+\stoptyping
+
+Although considerable effort has been expended to make the LuaTeX program correct
+and reliable, no warranty is implied; the authors disclaim any obligation or
+liability for damages, including but not limited to special, indirect, or
+consequential damages arising out of or in connection with the use or performance
+of this software. This work has been a ``labor of love'' and the authors hope
+that users enjoy it.
+
+{\em You will find a lot of comments that originate in original \TEX. We kept them
+as a side effect of the conversion from \WEB\ to \CWEB. Because there is not much
+webbing going on here eventually the files became regular \CCODE\ files with still
+potentially typeset comments. As we add our own comments, and also comments are
+there from \PDFTEX, \ALEPH\ and \ETEX, we get a curious mix. The best comments are
+of course from Don Knuth. All bad comments are ours. All errors are ours too!
+
+Not all comments make sense, because some things are implemented differently, for
+instance some memory management. But the principles of tokens and nodes stayed.
+It anyway means that you sometimes need to keep in mind that the explanation is
+more geared to traditional \TEX. But that's not a bad thing. Sorry Don for any
+confusion we introduced. The readers should have a copy of the \TEX\ books at hand
+anyway.}
+
+A large piece of software like \TeX\ has inherent complexity that cannot be
+reduced below a certain level of difficulty, although each individual part is
+fairly simple by itself. The \.{WEB} language is intended to make the algorithms
+as readable as possible, by reflecting the way the individual program pieces fit
+together and by providing the cross-references that connect different parts.
+Detailed comments about what is going on, and about why things were done in
+certain ways, have been liberally sprinkled throughout the program. These
+comments explain features of the implementation, but they rarely attempt to
+explain the \TeX\ language itself, since the reader is supposed to be familiar
+with {\sl The \TeX book}.
+
+The present implementation has a long ancestry, beginning in the summer of~1977,
+when Michael~F. Plass and Frank~M. Liang designed and coded a prototype @^Plass,
+Michael Frederick@> @^Liang, Franklin Mark@> @^Knuth, Donald Ervin@> based on
+some specifications that the author had made in May of that year. This original
+proto\TeX\ included macro definitions and elementary manipulations on boxes and
+glue, but it did not have line-breaking, page-breaking, mathematical formulas,
+alignment routines, error recovery, or the present semantic nest; furthermore, it
+used character lists instead of token lists, so that a control sequence like
+\.{\\halign} was represented by a list of seven characters. A complete version of
+\TeX\ was designed and coded by the author in late 1977 and early 1978; that
+program, like its prototype, was written in the {\mc SAIL} language, for which an
+excellent debugging system was available. Preliminary plans to convert the {\mc
+SAIL} code into a form somewhat like the present ``web'' were developed by Luis
+Trabb~Pardo and @^Trabb Pardo, Luis Isidoro@> the author at the beginning of
+1979, and a complete implementation was created by Ignacio~A. Zabala in 1979 and
+1980. The \TeX82 program, which @^Zabala Salelles, Ignacio Andr\'es@> was written
+by the author during the latter part of 1981 and the early part of 1982, also
+incorporates ideas from the 1979 implementation of @^Guibas, Leonidas Ioannis@>
+@^Sedgewick, Robert@> @^Wyatt, Douglas Kirk@> \TeX\ in {\mc MESA} that was
+written by Leonidas Guibas, Robert Sedgewick, and Douglas Wyatt at the Xerox Palo
+Alto Research Center. Several hundred refinements were introduced into \TeX82
+based on the experiences gained with the original implementations, so that
+essentially every part of the system has been substantially improved. After the
+appearance of ``Version 0'' in September 1982, this program benefited greatly
+from the comments of many other people, notably David~R. Fuchs and Howard~W.
+Trickey. A final revision in September 1989 extended the input character set to
+eight-bit codes and introduced the ability to hyphenate words from different
+languages, based on some ideas of Michael~J. Ferguson. @^Fuchs, David Raymond@>
+@^Trickey, Howard Wellington@> @^Ferguson, Michael John@>
+
+No doubt there still is plenty of room for improvement, but the author is firmly
+committed to keeping \TeX82 ``frozen'' from now on; stability and reliability are
+to be its main virtues.
+On the other hand, the \.{WEB} description can be extended without changing the
+core of \TeX82 itself, and the program has been designed so that such extensions
+are not extremely difficult to make. The |banner| string defined here should be
+changed whenever \TeX\ undergoes any modifications, so that it will be clear
+which version of \TeX\ might be the guilty party when a problem arises.
+@^extensions to \TeX@> @^system dependencies@>
+
+This program contains code for various features extending \TeX, therefore this
+program is called `\eTeX' and not `\TeX'; the official name `\TeX' by itself is
+reserved for software systems that are fully compatible with each other. A
+special test suite called the ``\.{TRIP} test'' is available for helping to
+determine whether a particular implementation deserves to be known as `\TeX'
+[cf.~Stanford Computer Science report CS1027, November 1984].
+
+A similar test suite called the ``\.{e-TRIP} test'' is available for helping to
+determine whether a particular implementation deserves to be known as `\eTeX'.
+
+This is the first of many sections of \TeX\ where global variables are defined.
+
+*/
+
+/*tex Are we using lua for initializations? */
+
+boolean luainit;
+
+/*tex Print file open and close info? */
+
+boolean tracefilenames;
+
+/*tex
+
+This program has two important variations: (1) There is a long and slow version
+called \.{INITEX}, which does the extra calculations needed to @.INITEX@>
+initialize \TeX's internal tables; and (2)~there is a shorter and faster
+production version, which cuts the initialization to a bare minimum.
+
+*/
+
+/*tex are we \.{INITEX}? */
+
+boolean ini_version;
+
+/*tex was the dump name option used? */
+
+boolean dump_option;
+
+/*tex was a \.{\%\AM format} line seen? */
+
+boolean dump_line;
+
+/*tex temporary for setup */
+
+int bound_default;
+
+/*tex temporary for setup */
+
+char *bound_name;
+
+/*tex width of context lines on terminal error messages */
+
+int error_line;
+
+/*tex
+    width of first lines of contexts in terminal error messages; should be
+    between 30 and |error_line-15|
+*/
+
+int half_error_line;
+
+/*tex width of longest text lines output; should be at least 60 */
+
+int max_print_line;
+
+/*tex maximum number of strings; must not exceed |max_halfword| */
+
+int max_strings;
+
+/*tex strings available after format loaded */
+
+int strings_free;
+
+/*tex loop variable for initialization */
+
+int font_k;
+
+/*tex
+    maximum number of characters simultaneously present in current lines of open
+    files and in control sequences between \.{\\csname} and \.{\\endcsname}; must
+    not exceed |max_halfword|
+*/
+
+int buf_size;
+
+/*tex maximum number of simultaneous input sources */
+
+int stack_size;
+
+/*tex
+    maximum number of input files and error insertions that can be going on
+    simultaneously
+*/
+
+int max_in_open;
+
+/*tex maximum number of simultaneous macro parameters */
+
+int param_size;
+
+/*tex maximum number of semantic levels simultaneously active */
+
+int nest_size;
+
+/*tex
+    space for saving values outside of current group; must be at most
+    |max_halfword|
+*/
+
+int save_size;
+
+/*tex limits recursive calls of the |expand| procedure */
+
+int expand_depth;
+
+/*tex parse the first line for options */
+
+int parsefirstlinep;
+
+/*tex format messages as file:line:error */
+
+int filelineerrorstylep;
+
+/*tex stop at first error */
+
+int haltonerrorp;
+
+/*tex current filename is quoted */
+
+boolean quoted_filename;
+
+int get_luatexversion(void)
+{
+    return luatex_version;
+}
+
+/*tex the number of pages that have been shipped out */
+
+int total_pages = 0;
+
+/*tex recent outputs that didn't ship anything out */
+
+int dead_cycles = 0;
+
+str_number get_luatexrevision(void)
+{
+    return luatex_revision;
+}
+
+/*tex
+
+This is it: the part of \TeX\ that executes all those procedures we have written.
+
+We have noted that there are two versions of \TeX82. One, called \.{INITEX},
+@.INITEX@> has to be run first; it initializes everything from scratch, without
+reading a format file, and it has the capability of dumping a format file. The
+other one is called `\.{VIRTEX}'; it is a ``virgin'' program that needs
+@.VIRTEX@> to input a format file in order to get started.
+
+For \LUATEX\ it is important to know that we still dump a format. But, in order
+to gain speed and a smaller footprint, we gzip the format (level 3). We also
+store some information that makes an abort possible in case of an incompatible
+engine version, which is important as \LUATEX\ develops. It is possible to store
+\LUA\ code in the format but not the current upvalues so you still need to
+initialize. Also, traditional fonts are stored, as are extended fonts but any
+additional information needed for instance to deal with \OPENTYPE\ fonts is to be
+handled by \LUA\ code and therefore not present in the format.
+
+*/
+
+#define const_chk(A) do { \
+    if (A < inf_##A) \
+        A = inf_##A; \
+    if (A > sup_##A) \
+        A = sup_##A; \
+} while (0)
+
+#define setup_bound_var(A,B,C) do { \
+    if (luainit>0) { \
+        get_lua_number("texconfig",B,&C); \
+        if (C==0) \
+            C=A; \
+    } else { \
+        integer x; \
+        setupboundvariable(&x, B, A); \
+        C = (int)x; \
+    } \
+} while (0)
+
+int ready_already = 0;
+
+int main_initialize(void)
+{
+    /*
+        In case somebody has inadvertently made bad settings of the
+        ``constants,'' \LUATEX\ checks them using a variable called |bad|.
+    */
+    int bad = 0;
+    /*tex
+        Bounds that may be set from the configuration file. We want the user to
+        be able to specify the names with underscores, but \.{TANGLE} removes
+        underscores, so we're stuck giving the names twice, once as a string,
+        once as the identifier. How ugly. (We can change that now.)
+    */
+    setup_bound_var(15000, "max_strings", max_strings);
+    setup_bound_var(100, "strings_free", strings_free);
+    setup_bound_var(3000, "buf_size", buf_size);
+    setup_bound_var(50, "nest_size", nest_size);
+    setup_bound_var(15, "max_in_open", max_in_open);
+    setup_bound_var(60, "param_size", param_size);
+    setup_bound_var(4000, "save_size", save_size);
+    setup_bound_var(300, "stack_size", stack_size);
+    setup_bound_var(16384, "dvi_buf_size", dvi_buf_size);
+    setup_bound_var(79, "error_line", error_line);
+    setup_bound_var(50, "half_error_line", half_error_line);
+    setup_bound_var(79, "max_print_line", max_print_line);
+    setup_bound_var(0, "hash_extra", hash_extra);
+    setup_bound_var(72, "pk_dpi", pk_dpi);
+    setup_bound_var(10000, "expand_depth", expand_depth);
+    /*tex
+        Check other constants against their sup and inf.
+    */
+    const_chk(buf_size);
+    const_chk(nest_size);
+    const_chk(max_in_open);
+    const_chk(param_size);
+    const_chk(save_size);
+    const_chk(stack_size);
+    const_chk(dvi_buf_size);
+    const_chk(max_strings);
+    const_chk(strings_free);
+    const_chk(hash_extra);
+    const_chk(pk_dpi);
+    if (error_line > ssup_error_line) {
+        error_line = ssup_error_line;
+    }
+    /*tex
+        Array memory allocation
+    */
+    buffer = xmallocarray(packed_ASCII_code, (unsigned) buf_size);
+    nest = xmallocarray(list_state_record, (unsigned) nest_size);
+    save_stack = xmallocarray(save_record, (unsigned) save_size);
+    input_stack = xmallocarray(in_state_record, (unsigned) stack_size);
+    input_file = xmallocarray(alpha_file, (unsigned) max_in_open);
+    input_file_callback_id = xmallocarray(int, (unsigned) max_in_open);
+    line_stack = xmallocarray(int, (unsigned) max_in_open);
+    eof_seen = xmallocarray(boolean, (unsigned) max_in_open);
+    grp_stack = xmallocarray(save_pointer, (unsigned) max_in_open);
+    if_stack = xmallocarray(pointer, (unsigned) max_in_open);
+    source_filename_stack = xmallocarray(str_number, (unsigned) max_in_open);
+    full_source_filename_stack = xmallocarray(char *, (unsigned) max_in_open);
+    param_stack = xmallocarray(halfword, (unsigned) param_size);
+    dvi_buf = xmallocarray(eight_bits, (unsigned) dvi_buf_size);
+    /*tex
+        Only in ini mode:
+    */
+    if (ini_version) {
+        fixmem = xmallocarray(smemory_word, fix_mem_init + 1);
+        memset(voidcast(fixmem), 0, (fix_mem_init + 1) * sizeof(smemory_word));
+        fix_mem_min = 0;
+        fix_mem_max = fix_mem_init;
+        eqtb_top = eqtb_size + hash_extra;
+        if (hash_extra == 0)
+            hash_top = undefined_control_sequence;
+        else
+            hash_top = eqtb_top;
+        hash = xmallocarray(two_halves, (unsigned) (hash_top + 1));
+        memset(hash, 0, sizeof(two_halves) * (unsigned) (hash_top + 1));
+        eqtb = xmallocarray(memory_word, (unsigned) (eqtb_top + 1));
+        memset(eqtb, 0, sizeof(memory_word) * (unsigned) (eqtb_top + 1));
+        init_string_pool_array((unsigned) max_strings);
+        reset_cur_string();
+    }
+    /*tex
+        Check the ``constant'' values...
+    */
+    if ((half_error_line < 30) || (half_error_line > error_line - 15))
+        bad = 1;
+    if (max_print_line < 60)
+        bad = 2;
+    if (dvi_buf_size % 8 != 0)
+        bad = 3;
+    if (hash_prime > hash_size)
+        bad = 5;
+    if (max_in_open >= (sup_max_in_open+1)) /* 128 */
+        bad = 6;
+    /*tex
+        Here are the inequalities that the quarterword and halfword values
+        must satisfy (or rather, the inequalities that they mustn't satisfy):
+    */
+    if ((min_quarterword > 0) || (max_quarterword < 0x7FFF))
+        bad = 11;
+    if ((min_halfword > 0) || (max_halfword < 0x3FFFFFFF))
+        bad = 12;
+    if ((min_quarterword < min_halfword) || (max_quarterword > max_halfword))
+        bad = 13;
+    if (font_base < min_quarterword)
+        bad = 15;
+    if ((save_size > max_halfword) || (max_strings > max_halfword))
+        bad = 17;
+    if (buf_size > max_halfword)
+        bad = 18;
+    if (max_quarterword - min_quarterword < 0xFFFF)
+        bad = 19;
+    if (cs_token_flag + eqtb_size + hash_extra > max_halfword)
+        bad = 21;
+    if (bad > 0) {
+        wterm_cr();
+        fprintf(term_out,
+            "Ouch---my internal constants have been clobbered! ---case %d",
+            (int) bad
+        );
+    } else {
+        /*tex Set global variables to their starting values. */
+        initialize();
+        if (ini_version) {
+            /*tex Initialize all the primitives. */
+            no_new_control_sequence = false;
+            first = 0;
+            initialize_commands();
+            initialize_etex_commands();
+            init_str_ptr = str_ptr;
+            no_new_control_sequence = true;
+            fix_date_and_time();
+        }
+        ready_already = 314159;
+    }
+    return bad;
+}
+
+
+void main_body(void)
+{
+    static char pdftex_map[] = "pdftex.map";
+    int bad = main_initialize();
+    /*tex in case we quit during initialization */
+    history = fatal_error_stop;
+    /*tex open the terminal for output */
+    t_open_out();
+    if (!luainit)
+        tracefilenames = true;
+    if (bad > 0) {
+        goto FINAL_END;
+    }
+    print_banner(luatex_version_string);
+    /*tex
+        Get the first line of input and prepare to start When we begin the
+        following code, \TeX's tables may still contain garbage; the strings
+        might not even be present. Thus we must proceed cautiously to get
+        bootstrapped in.
+
+        But when we finish this part of the program, \TeX\ is ready to call on
+        the |main_control| routine to do its work.
+    */
+    /*tex
+        This copies the command line,
+    */
+    initialize_inputstack();
+    if (buffer[iloc] == '*')
+        incr(iloc);
+    if ((format_ident == 0) || (buffer[iloc] == '&') || dump_line) {
+        char *fname = NULL;
+        if (format_ident != 0 && !ini_version) {
+            /*tex Erase preloaded format. */
+            initialize();
+        }
+        if ((fname = open_fmt_file()) == NULL)
+            goto FINAL_END;
+        if (!load_fmt_file(fname)) {
+            zwclose(fmt_file);
+            goto FINAL_END;
+        }
+        zwclose(fmt_file);
+        while ((iloc < ilimit) && (buffer[iloc] == ' '))
+            incr(iloc);
+    }
+    if (output_mode_option != 0)
+        output_mode_par = output_mode_value;
+    if (draft_mode_option != 0) {
+        draft_mode_par = draft_mode_value;
+    }
+    /*tex can this be moved? */
+    pdf_init_map_file((char *) pdftex_map);
+    /* */
+    if (end_line_char_inactive)
+        decr(ilimit);
+    else
+        buffer[ilimit] = (packed_ASCII_code) end_line_char_par;
+    fix_date_and_time();
+    random_seed = (microseconds * 1000) + (epochseconds % 1000000);
+    init_randoms(random_seed);
+    initialize_math();
+    fixup_selector(log_opened_global);
+    check_texconfig_init();
+    if ((iloc < ilimit) && (get_cat_code(cat_code_table_par, buffer[iloc]) != escape_cmd)) {
+        /*tex \.{\\input} assumed */
+        start_input();
+    }
+    /*tex Initialize |text_dir_ptr| */
+    text_dir_ptr = new_dir(0);
+    /*tex Ready to go! */
+    history = spotless;
+    /*tex Initialize synctex primitive */
+    synctexinitcommand();
+    /*tex Come to life. */
+    main_control();
+    flush_node(text_dir_ptr);
+    /*tex Prepare for death. */
+    final_cleanup();
+    close_files_and_terminate();
+  FINAL_END:
+    do_final_end();
+}
+
+/*tex
+
+Here we do whatever is needed to complete \TeX's job gracefully on the local
+operating system. The code here might come into play after a fatal error; it must
+therefore consist entirely of ``safe'' operations that cannot produce error
+messages. For example, it would be a mistake to call |str_room| or |make_string|
+at this time, because a call on |overflow| might lead to an infinite loop.
+@^system dependencies@>
+
+Actually there's one way to get error messages, via |prepare_mag|; but that can't
+cause infinite recursion. @^recursion@>
+
+This program doesn't bother to close the input files that may still be open.
+
+*/
+
+void close_files_and_terminate(void)
+{
+    int callback_id;
+    callback_id = callback_defined(stop_run_callback);
+    finalize_write_files();
+    if (tracing_stats_par > 0) {
+        if (callback_id == 0) {
+            /*tex
+                Output statistics about this job. The present section goes
+                directly to the log file instead of using |print| commands,
+                because there's no need for these strings to take up
+                |string_pool| memory when a non-{\bf stat} version of \TeX\ is
+                being used.
+            */
+            if (log_opened_global) {
+                fprintf(log_file,
+                    "\n\nHere is how much of LuaTeX's memory you used:\n"
+                );
+                fprintf(log_file, " %d string%s out of %d\n",
+                    (int) (str_ptr - init_str_ptr),
+                    (str_ptr == (init_str_ptr + 1) ? "" : "s"),
+                    (int) (max_strings - init_str_ptr + STRING_OFFSET)
+                );
+                fprintf(log_file, " %d,%d words of node,token memory allocated",
+                    (int) var_mem_max, (int) fix_mem_max
+                );
+                print_node_mem_stats();
+                fprintf(log_file,
+                    " %d multiletter control sequences out of %ld+%d\n",
+                    (int) cs_count, (long) hash_size, (int) hash_extra
+                );
+                fprintf(log_file, " %d font%s using %d bytes\n",
+                    (int) max_font_id(), (max_font_id() == 1 ? "" : "s"),
+                    (int) font_bytes
+                );
+                fprintf(log_file,
+                    " %di,%dn,%dp,%db,%ds stack positions out of %di,%dn,%dp,%db,%ds\n",
+                    (int) max_in_stack, (int) max_nest_stack,
+                    (int) max_param_stack, (int) max_buf_stack,
+                    (int) max_save_stack + 6, (int) stack_size,
+                    (int) nest_size, (int) param_size, (int) buf_size,
+                    (int) save_size
+                );
+            }
+        }
+    }
+    wake_up_terminal();
+    /*tex
+        Rubish, these \PDF arguments, passed, needs to be fixed, e.g. with a
+        dummy in \DVI.
+    */
+    wrapup_backend();
+    /*tex
+        Close {\sl Sync\TeX} file and write status.
+    */
+    synctexterminate(log_opened_global);
+    /*tex
+        The following is needed because synctex removes files and we want to keep
+        them which means renaming a temp file .. we can't bypass the terminate
+        because it might do mem cleanup.
+    */
+    if (synctex_get_mode() > 0) {
+        callback_id = callback_defined(finish_synctex_callback);
+        if (callback_id > 0) {
+            run_callback(callback_id, "->");
+        }
+    }
+    /* free_text_codes(); */
+    /* free_math_codes(); */
+    if (log_opened_global) {
+        wlog_cr();
+        selector = selector - 2;
+        if ((selector == term_only) && (callback_id == 0)) {
+            tprint_nl("Transcript written on ");
+            tprint_file_name(NULL, texmf_log_name, NULL);
+            print_char('.');
+            print_ln();
+        }
+        lua_a_close_out(log_file);
+    }
+    callback_id = callback_defined(wrapup_run_callback);
+    if (callback_id > 0) {
+        run_callback(callback_id, "->");
+    }
+    free_text_codes();
+    free_math_codes();
+}
+
+/*tex
+
+We get to the |final_cleanup| routine when \.{\\end} or \.{\\dump} has been
+scanned and |its_all_over|.
+
+*/
+
+void final_cleanup(void)
+{
+    /*tex This one gets the value 0 for \.{\\end}, 1 for \.{\\dump}. */
+    int c;
+    /*tex Here's one for looping marks: */
+    halfword i;
+    /*tex This was a global temp_ptr: */
+    halfword t;
+    c = cur_chr;
+    if (job_name == 0)
+        open_log_file();
+    while (input_ptr > 0)
+        if (istate == token_list)
+            end_token_list();
+        else
+            end_file_reading();
+    while (open_parens > 0) {
+        report_stop_file(filetype_tex);
+        decr(open_parens);
+    }
+    if (cur_level > level_one) {
+        tprint_nl("(\\end occurred inside a group at level ");
+        print_int(cur_level - level_one);
+        print_char(')');
+        show_save_groups();
+    }
+    while (cond_ptr != null) {
+        tprint_nl("(\\end occurred when ");
+        print_cmd_chr(if_test_cmd, cur_if);
+        if (if_line != 0) {
+            tprint(" on line ");
+            print_int(if_line);
+        }
+        tprint(" was incomplete)");
+        if_line = if_line_field(cond_ptr);
+        cur_if = subtype(cond_ptr);
+        t = cond_ptr;
+        cond_ptr = vlink(cond_ptr);
+        flush_node(t);
+    }
+    if (callback_defined(stop_run_callback) == 0)
+        if (history != spotless)
+            if ((history == warning_issued) || (interaction < error_stop_mode))
+                if (selector == term_and_log) {
+                    selector = term_only;
+                    tprint_nl("(see the transcript file for additional information)");
+                    selector = term_and_log;
+                }
+    if (c == 1) {
+        if (ini_version) {
+            for (i = 0; i <= biggest_used_mark; i++) {
+                delete_top_mark(i);
+                delete_first_mark(i);
+                delete_bot_mark(i);
+                delete_split_first_mark(i);
+                delete_split_bot_mark(i);
+            }
+            for (c = last_box_code; c <= vsplit_code; c++)
+                flush_node_list(disc_ptr[c]);
+            if (last_glue != max_halfword) {
+                flush_node(last_glue);
+            }
+            /*tex Flush the pseudo files. */
+            while (pseudo_files != null) {
+                pseudo_close();
+            }
+            store_fmt_file();
+            return;
+        }
+        tprint_nl("(\\dump is performed only by INITEX)");
+        return;
+    }
+}
+
+/*tex
+
+Once \TeX\ is working, you should be able to diagnose most errors with the
+\.{\\show} commands and other diagnostic features.
+
+Because we have made some internal changes the optional debug interface
+has been removed.
+
+*/
diff --git a/texk/web2c/luatexdir/tex/mainbody.w b/texk/web2c/luatexdir/tex/mainbody.w
deleted file mode 100644
index 4d38b9d4a..000000000
--- a/texk/web2c/luatexdir/tex/mainbody.w
+++ /dev/null
@@ -1,708 +0,0 @@
-% mainbody.w
-%
-% Copyright 2009-2010 Taco Hoekwater <taco@@luatex.org>
-%
-% This file is part of LuaTeX.
-%
-% LuaTeX is free software; you can redistribute it and/or modify it under
-% the terms of the GNU General Public License as published by the Free
-% Software Foundation; either version 2 of the License, or (at your
-% option) any later version.
-%
-% LuaTeX is distributed in the hope that it will be useful, but WITHOUT
-% ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-% FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
-% License for more details.
-%
-% You should have received a copy of the GNU General Public License along
-% with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
-
-\def\eTeX{e-\TeX}
-\def\Aleph{Aleph}
-\def\pdfTeX{pdf\TeX}
-
-@ @c
-
-
-#include "ptexlib.h"
-
-@
-pdfTeX is copyright (C) 1996-2006 Han The Thanh, <thanh@@pdftex.org>.
-
-e-TeX is copyright (C) 1994,98 by Peter Breitenlohner.
-
-This is LuaTeX, a continuation of $\pdfTeX$ and $\Aleph$.  LuaTeX is a
-document compiler intended to simplify high-quality typesetting for
-many of the world's languages.  It is an extension of D. E. Knuth's
-\TeX, which was designed essentially for the typesetting of languages
-using the Latin alphabet.
-
-The $\Aleph$ subsystem loosens many of the restrictions imposed by~\TeX:
-register numbers are no longer limited to 8~bits;  fonts may have more
-than 256~characters;  more than 256~fonts may be used;  etc.
-
-% This program is directly derived from Donald E. Knuth's TeX;
-% the change history which follows and the reward offered for finders of
-% bugs refer specifically to TeX; they should not be taken as referring
-% to LuaTeX, pdfTeX, nor e-TeX, although the change history is relevant in that it
-% demonstrates the evolutionary path followed.  This program is not TeX;
-% that name is reserved strictly for the program which is the creation
-% and sole responsibility of Professor Knuth.
-
-% Version 0 was released in September 1982 after it passed a variety of tests.
-% Version 1 was released in November 1983 after thorough testing.
-% Version 1.1 fixed ``disappearing font identifiers'' et alia (July 1984).
-% Version 1.2 allowed `0' in response to an error, et alia (October 1984).
-% Version 1.3 made memory allocation more flexible and local (November 1984).
-% Version 1.4 fixed accents right after line breaks, et alia (April 1985).
-% Version 1.5 fixed \the\toks after other expansion in \edefs (August 1985).
-% Version 2.0 (almost identical to 1.5) corresponds to "Volume B" (April 1986).
-% Version 2.1 corrected anomalies in discretionary breaks (January 1987).
-% Version 2.2 corrected "(Please type...)" with null \endlinechar (April 1987).
-% Version 2.3 avoided incomplete page in premature termination (August 1987).
-% Version 2.4 fixed \noaligned rules in indented displays (August 1987).
-% Version 2.5 saved cur_order when expanding tokens (September 1987).
-% Version 2.6 added 10sp slop when shipping leaders (November 1987).
-% Version 2.7 improved rounding of negative-width characters (November 1987).
-% Version 2.8 fixed weird bug if no \patterns are used (December 1987).
-% Version 2.9 made \csname\endcsname's "relax" local (December 1987).
-% Version 2.91 fixed \outer\def\a0{}\a\a bug (April 1988).
-% Version 2.92 fixed \patterns, also file names with complex macros (May 1988).
-% Version 2.93 fixed negative halving in allocator when mem_min<0 (June 1988).
-% Version 2.94 kept open_log_file from calling fatal_error (November 1988).
-% Version 2.95 solved that problem a better way (December 1988).
-% Version 2.96 corrected bug in "Infinite shrinkage" recovery (January 1989).
-% Version 2.97 corrected blunder in creating 2.95 (February 1989).
-% Version 2.98 omitted save_for_after at outer level (March 1989).
-% Version 2.99 caught $$\begingroup\halign..$$ (June 1989).
-% Version 2.991 caught .5\ifdim.6... (June 1989).
-% Version 2.992 introduced major changes for 8-bit extensions (September 1989).
-% Version 2.993 fixed a save_stack synchronization bug et alia (December 1989).
-% Version 3.0 fixed unusual displays; was more \output robust (March 1990).
-% Version 3.1 fixed nullfont, disabled \write{\the\prevgraf} (September 1990).
-% Version 3.14 fixed unprintable font names and corrected typos (March 1991).
-% Version 3.141 more of same; reconstituted ligatures better (March 1992).
-% Version 3.1415 preserved nonexplicit kerns, tidied up (February 1993).
-% Version 3.14159 allowed fontmemsize to change; bulletproofing (March 1995).
-% Version 3.141592 fixed \xleaders, glueset, weird alignments (December 2002).
-% Version 3.1415926 was a general cleanup with minor fixes (February 2008).
-
-
-% Although considerable effort has been expended to make the LuaTeX program
-% correct and reliable, no warranty is implied; the authors disclaim any
-% obligation or liability for damages, including but not limited to
-% special, indirect, or consequential damages arising out of or in
-% connection with the use or performance of this software. This work has
-% been a ``labor of love'' and the authors hope that users enjoy it.
-
-A large piece of software like \TeX\ has inherent complexity that cannot
-be reduced below a certain level of difficulty, although each individual
-part is fairly simple by itself. The \.{WEB} language is intended to make
-the algorithms as readable as possible, by reflecting the way the
-individual program pieces fit together and by providing the
-cross-references that connect different parts. Detailed comments about
-what is going on, and about why things were done in certain ways, have
-been liberally sprinkled throughout the program.  These comments explain
-features of the implementation, but they rarely attempt to explain the
-\TeX\ language itself, since the reader is supposed to be familiar with
-{\sl The \TeX book}.
-@.WEB@>
-@:TeXbook}{\sl The \TeX book@>
-
-The present implementation has a long ancestry, beginning in the summer
-of~1977, when Michael~F. Plass and Frank~M. Liang designed and coded
-a prototype
-@^Plass, Michael Frederick@>
-@^Liang, Franklin Mark@>
-@^Knuth, Donald Ervin@>
-based on some specifications that the author had made in May of that year.
-This original proto\TeX\ included macro definitions and elementary
-manipulations on boxes and glue, but it did not have line-breaking,
-page-breaking, mathematical formulas, alignment routines, error recovery,
-or the present semantic nest; furthermore,
-it used character lists instead of token lists, so that a control sequence
-like \.{\\halign} was represented by a list of seven characters. A
-complete version of \TeX\ was designed and coded by the author in late
-1977 and early 1978; that program, like its prototype, was written in the
-{\mc SAIL} language, for which an excellent debugging system was
-available. Preliminary plans to convert the {\mc SAIL} code into a form
-somewhat like the present ``web'' were developed by Luis Trabb~Pardo and
-@^Trabb Pardo, Luis Isidoro@>
-the author at the beginning of 1979, and a complete implementation was
-created by Ignacio~A. Zabala in 1979 and 1980. The \TeX82 program, which
-@^Zabala Salelles, Ignacio Andr\'es@>
-was written by the author during the latter part of 1981 and the early
-part of 1982, also incorporates ideas from the 1979 implementation of
-@^Guibas, Leonidas Ioannis@>
-@^Sedgewick, Robert@>
-@^Wyatt, Douglas Kirk@>
-\TeX\ in {\mc MESA} that was written by Leonidas Guibas, Robert Sedgewick,
-and Douglas Wyatt at the Xerox Palo Alto Research Center.  Several hundred
-refinements were introduced into \TeX82 based on the experiences gained with
-the original implementations, so that essentially every part of the system
-has been substantially improved. After the appearance of ``Version 0'' in
-September 1982, this program benefited greatly from the comments of
-many other people, notably David~R. Fuchs and Howard~W. Trickey.
-A final revision in September 1989 extended the input character set to
-eight-bit codes and introduced the ability to hyphenate words from
-different languages, based on some ideas of Michael~J. Ferguson.
-@^Fuchs, David Raymond@>
-@^Trickey, Howard Wellington@>
-@^Ferguson, Michael John@>
-
-No doubt there still is plenty of room for improvement, but the author
-is firmly committed to keeping \TeX82 ``frozen'' from now on; stability
-and reliability are to be its main virtues.
-
-On the other hand, the \.{WEB} description can be extended without changing
-the core of \TeX82 itself, and the program has been designed so that such
-extensions are not extremely difficult to make.
-The |banner| string defined here should be changed whenever \TeX\
-undergoes any modifications, so that it will be clear which version of
-\TeX\ might be the guilty party when a problem arises.
-@^extensions to \TeX@>
-@^system dependencies@>
-
-This program contains code for various features extending \TeX,
-therefore this program is called `\eTeX' and not
-`\TeX'; the official name `\TeX' by itself is reserved
-for software systems that are fully compatible with each other.
-A special test suite called the ``\.{TRIP} test'' is available for
-helping to determine whether a particular implementation deserves to be
-known as `\TeX' [cf.~Stanford Computer Science report CS1027,
-November 1984].
-
-A similar test suite called the ``\.{e-TRIP} test'' is available for
-helping to determine whether a particular implementation deserves to be
-known as `\eTeX'.
-
-@ This is the first of many sections of \TeX\ where global variables are
-defined.
-
-@c
-boolean luainit;                /* are we using lua for initializations  */
-boolean tracefilenames;         /* print file open-close  info? */
-
-
-@ This program has two important variations: (1) There is a long and slow
-version called \.{INITEX}, which does the extra calculations needed to
-@.INITEX@>
-initialize \TeX's internal tables; and (2)~there is a shorter and faster
-production version, which cuts the initialization to a bare minimum.
-
-@c
-boolean ini_version;            /* are we \.{INITEX}? */
-boolean dump_option;            /* was the dump name option used? */
-boolean dump_line;              /* was a \.{\%\AM format} line seen? */
-int bound_default;              /* temporary for setup */
-char *bound_name;               /* temporary for setup */
-int error_line;                 /* width of context lines on terminal error messages */
-int half_error_line;            /* width of first lines of contexts in terminal
-                                   error messages; should be between 30 and |error_line-15| */
-int max_print_line;             /* width of longest text lines output; should be at least 60 */
-int max_strings;                /* maximum number of strings; must not exceed |max_halfword| */
-int strings_free;               /* strings available after format loaded */
-int font_k;                     /* loop variable for initialization */
-int buf_size;                   /* maximum number of characters simultaneously present in
-                                   current lines of open files and in control sequences between
-                                   \.{\\csname} and \.{\\endcsname}; must not exceed |max_halfword| */
-int stack_size;                 /* maximum number of simultaneous input sources */
-int max_in_open;                /* maximum number of input files and error insertions that
-                                   can be going on simultaneously */
-int param_size;                 /* maximum number of simultaneous macro parameters */
-int nest_size;                  /* maximum number of semantic levels simultaneously active */
-int save_size;                  /* space for saving values outside of current group; must be
-                                   at most |max_halfword| */
-int expand_depth;               /* limits recursive calls of the |expand| procedure */
-int parsefirstlinep;            /* parse the first line for options */
-int filelineerrorstylep;        /* format messages as file:line:error */
-int haltonerrorp;               /* stop at first error */
-boolean quoted_filename;        /* current filename is quoted */
-
-@ @c
-int get_luatexversion(void)
-{
-    return luatex_version;
-}
-
-str_number get_luatexrevision(void)
-{
-    return luatex_revision;
-}
-
-@ This is it: the part of \TeX\ that executes all those procedures we have
-written.
-
-We have noted that there are two versions of \TeX82. One, called \.{INITEX},
-@.INITEX@>
-has to be run first; it initializes everything from scratch, without
-reading a format file, and it has the capability of dumping a format file.
-The other one is called `\.{VIRTEX}'; it is a ``virgin'' program that needs
-@.VIRTEX@>
-to input a format file in order to get started.
-
-@c
-#define const_chk(A) do {			\
-	if (A < inf_##A) A = inf_##A;		\
-	if (A > sup_##A) A = sup_##A;		\
-    } while (0)
-
-#define setup_bound_var(A,B,C) do {				\
-	if (luainit>0) {					\
-	    get_lua_number("texconfig",B,&C);			\
-	    if (C==0) C=A;					\
-	} else {						\
-	    integer x;						\
-	    setupboundvariable(&x, B, A);			\
-	    C = (int)x;						\
-	}							\
-    } while (0)
-
-
-int ready_already = 0;
-
-int main_initialize(void)
-{
-    /* In case somebody has inadvertently made bad settings of the ``constants,''
-       \LuaTeX\ checks them using a variable called |bad|. */
-    int bad = 0;
-    /* Bounds that may be set from the configuration file. We want the user to
-       be able to specify the names with underscores, but \.{TANGLE} removes
-       underscores, so we're stuck giving the names twice, once as a string,
-       once as the identifier. How ugly. */
-
-    setup_bound_var(15000, "max_strings", max_strings);
-    setup_bound_var(100, "strings_free", strings_free);
-    setup_bound_var(3000, "buf_size", buf_size);
-    setup_bound_var(50, "nest_size", nest_size);
-    setup_bound_var(15, "max_in_open", max_in_open);
-    setup_bound_var(60, "param_size", param_size);
-    setup_bound_var(4000, "save_size", save_size);
-    setup_bound_var(300, "stack_size", stack_size);
-    setup_bound_var(16384, "dvi_buf_size", dvi_buf_size);
-    setup_bound_var(79, "error_line", error_line);
-    setup_bound_var(50, "half_error_line", half_error_line);
-    setup_bound_var(79, "max_print_line", max_print_line);
-    setup_bound_var(0, "hash_extra", hash_extra);
-    setup_bound_var(72, "pk_dpi", pk_dpi);
-    setup_bound_var(10000, "expand_depth", expand_depth);
-
-    /* Check other constants against their sup and inf. */
-    const_chk(buf_size);
-    const_chk(nest_size);
-    const_chk(max_in_open);
-    const_chk(param_size);
-    const_chk(save_size);
-    const_chk(stack_size);
-    const_chk(dvi_buf_size);
-    const_chk(max_strings);
-    const_chk(strings_free);
-    const_chk(hash_extra);
-    const_chk(pk_dpi);
-    if (error_line > ssup_error_line)
-        error_line = ssup_error_line;
-
-    /* array memory allocation */
-    buffer = xmallocarray(packed_ASCII_code, (unsigned) buf_size);
-    nest = xmallocarray(list_state_record, (unsigned) nest_size);
-    save_stack = xmallocarray(save_record, (unsigned) save_size);
-    input_stack = xmallocarray(in_state_record, (unsigned) stack_size);
-    input_file = xmallocarray(alpha_file, (unsigned) max_in_open);
-    input_file_callback_id = xmallocarray(int, (unsigned) max_in_open);
-    line_stack = xmallocarray(int, (unsigned) max_in_open);
-    eof_seen = xmallocarray(boolean, (unsigned) max_in_open);
-    grp_stack = xmallocarray(save_pointer, (unsigned) max_in_open);
-    if_stack = xmallocarray(pointer, (unsigned) max_in_open);
-    source_filename_stack = xmallocarray(str_number, (unsigned) max_in_open);
-    full_source_filename_stack = xmallocarray(char *, (unsigned) max_in_open);
-    param_stack = xmallocarray(halfword, (unsigned) param_size);
-    dvi_buf = xmallocarray(eight_bits, (unsigned) dvi_buf_size);
-
-    if (ini_version) {
-        fixmem = xmallocarray(smemory_word, fix_mem_init + 1);
-        memset(voidcast(fixmem), 0, (fix_mem_init + 1) * sizeof(smemory_word));
-        fix_mem_min = 0;
-        fix_mem_max = fix_mem_init;
-        eqtb_top = eqtb_size + hash_extra;
-        if (hash_extra == 0)
-            hash_top = undefined_control_sequence;
-        else
-            hash_top = eqtb_top;
-        hash = xmallocarray(two_halves, (unsigned) (hash_top + 1));
-        memset(hash, 0, sizeof(two_halves) * (unsigned) (hash_top + 1));
-        eqtb = xmallocarray(memory_word, (unsigned) (eqtb_top + 1));
-        memset(eqtb, 0, sizeof(memory_word) * (unsigned) (eqtb_top + 1));
-        init_string_pool_array((unsigned) max_strings);
-        reset_cur_string();
-    }
-    /* Check the ``constant'' values... */
-    if ((half_error_line < 30) || (half_error_line > error_line - 15))
-        bad = 1;
-    if (max_print_line < 60)
-        bad = 2;
-    if (dvi_buf_size % 8 != 0)
-        bad = 3;
-    if (hash_prime > hash_size)
-        bad = 5;
-    if (max_in_open >= (sup_max_in_open+1)) /* 128 */
-        bad = 6;
-    /* Here are the inequalities that the quarterword and halfword values
-       must satisfy (or rather, the inequalities that they mustn't satisfy): */
-    if ((min_quarterword > 0) || (max_quarterword < 0x7FFF))
-        bad = 11;
-    if ((min_halfword > 0) || (max_halfword < 0x3FFFFFFF))
-        bad = 12;
-    if ((min_quarterword < min_halfword) || (max_quarterword > max_halfword))
-        bad = 13;
-    if (font_base < min_quarterword)
-        bad = 15;
-    if ((save_size > max_halfword) || (max_strings > max_halfword))
-        bad = 17;
-    if (buf_size > max_halfword)
-        bad = 18;
-    if (max_quarterword - min_quarterword < 0xFFFF)
-        bad = 19;
-    if (cs_token_flag + eqtb_size + hash_extra > max_halfword)
-        bad = 21;
-    if (bad > 0) {
-        wterm_cr();
-        fprintf(term_out,
-                "Ouch---my internal constants have been clobbered! ---case %d",
-                (int) bad);
-    } else {
-        initialize();           /* set global variables to their starting values */
-        if (ini_version) {
-            /* initialize all the primitives */
-            no_new_control_sequence = false;
-            first = 0;
-            initialize_commands();
-            initialize_etex_commands();
-            init_str_ptr = str_ptr;
-            no_new_control_sequence = true;
-            fix_date_and_time();
-        }
-        ready_already = 314159;
-    }
-    return bad;
-}
-
-@ @c
-void main_body(void)
-{
-    static char pdftex_map[] = "pdftex.map";
-    int bad = main_initialize();
-    history = fatal_error_stop; /* in case we quit during initialization */
-    t_open_out();               /* open the terminal for output */
-    if (!luainit)
-        tracefilenames = true;
-    if (bad > 0) {
-        goto FINAL_END;
-    }
-    print_banner(luatex_version_string);
-
-    /* Get the first line of input and prepare to start */
-    /* When we begin the following code, \TeX's tables may still contain garbage;
-       the strings might not even be present. Thus we must proceed cautiously to get
-       bootstrapped in.
-
-       But when we finish this part of the program, \TeX\ is ready to call on the
-       |main_control| routine to do its work.
-     */
-    initialize_inputstack();    /* this copies the command-line */
-    if (buffer[iloc] == '*')
-        incr(iloc);
-    if ((format_ident == 0) || (buffer[iloc] == '&') || dump_line) {
-        char *fname = NULL;
-        if (format_ident != 0 && !ini_version)
-            initialize();       /* erase preloaded format */
-        if ((fname = open_fmt_file()) == NULL)
-            goto FINAL_END;
-        if (!load_fmt_file(fname)) {
-            zwclose(fmt_file);
-            goto FINAL_END;
-        }
-        zwclose(fmt_file);
-        while ((iloc < ilimit) && (buffer[iloc] == ' '))
-            incr(iloc);
-    }
-    if (output_mode_option != 0)
-        output_mode_par = output_mode_value;
-    if (draft_mode_option != 0) {
-        draft_mode_par = draft_mode_value;
-    }
-    /* can this be moved? */
-    pdf_init_map_file((char *) pdftex_map);
-    /* */
-    if (end_line_char_inactive)
-        decr(ilimit);
-    else
-        buffer[ilimit] = (packed_ASCII_code) end_line_char_par;
-    fix_date_and_time();
-    random_seed = (microseconds * 1000) + (epochseconds % 1000000);
-    init_randoms(random_seed);
-    initialize_math();
-    fixup_selector(log_opened_global);
-    check_texconfig_init();
-    if ((iloc < ilimit) && (get_cat_code(cat_code_table_par, buffer[iloc]) != escape_cmd))
-        start_input();          /* \.{\\input} assumed */
-    /* DIR: Initialize |text_dir_ptr| */
-    text_dir_ptr = new_dir(0);
-
-    history = spotless;         /* ready to go! */
-    /* Initialize synctex primitive */
-    synctexinitcommand();
-    main_control();             /* come to life */
-    flush_node(text_dir_ptr);
-    final_cleanup();            /* prepare for death */
-    close_files_and_terminate();
-  FINAL_END:
-    do_final_end();
-}
-
-
-@ Here we do whatever is needed to complete \TeX's job gracefully on the
-local operating system. The code here might come into play after a fatal
-error; it must therefore consist entirely of ``safe'' operations that
-cannot produce error messages. For example, it would be a mistake to call
-|str_room| or |make_string| at this time, because a call on |overflow|
-might lead to an infinite loop.
-@^system dependencies@>
-
-Actually there's one way to get error messages, via |prepare_mag|;
-but that can't cause infinite recursion.
-@^recursion@>
-
-This program doesn't bother to close the input files that may still be open.
-
-@c
-void close_files_and_terminate(void)
-{
-    int callback_id;
-    callback_id = callback_defined(stop_run_callback);
-    finalize_write_files();
-    if (tracing_stats_par > 0) {
-        if (callback_id == 0) {
-            /* Output statistics about this job */
-            /* The present section goes directly to the log file instead of using
-               |print| commands, because there's no need for these strings to take
-               up |string_pool| memory when a non-{\bf stat} version of \TeX\ is being used.
-             */
-
-            if (log_opened_global) {
-                fprintf(log_file,
-                        "\n\nHere is how much of LuaTeX's memory you used:\n");
-                fprintf(log_file, " %d string%s out of %d\n",
-                        (int) (str_ptr - init_str_ptr),
-                        (str_ptr == (init_str_ptr + 1) ? "" : "s"),
-                        (int) (max_strings - init_str_ptr + STRING_OFFSET));
-                fprintf(log_file, " %d,%d words of node,token memory allocated",
-                        (int) var_mem_max, (int) fix_mem_max);
-                print_node_mem_stats();
-                fprintf(log_file,
-                        " %d multiletter control sequences out of %ld+%d\n",
-                        (int) cs_count, (long) hash_size, (int) hash_extra);
-                fprintf(log_file, " %d font%s using %d bytes\n",
-                        (int) max_font_id(), (max_font_id() == 1 ? "" : "s"),
-                        (int) font_bytes);
-                fprintf(log_file,
-                        " %di,%dn,%dp,%db,%ds stack positions out of %di,%dn,%dp,%db,%ds\n",
-                        (int) max_in_stack, (int) max_nest_stack,
-                        (int) max_param_stack, (int) max_buf_stack,
-                        (int) max_save_stack + 6, (int) stack_size,
-                        (int) nest_size, (int) param_size, (int) buf_size,
-                        (int) save_size);
-            }
-        }
-    }
-    wake_up_terminal();
-    /* rubish, these pdf arguments, passed, needs to be fixed, e.g. with a dummy in dvi */
-    wrapup_backend();
-    /* Close {\sl Sync\TeX} file and write status */
-    synctexterminate(log_opened_global);
-    /*
-        The following is needed because synctex removes files and we want to keep them which
-        means renaming a temp file .. we can't bypass the terminate because it might do mem
-        cleanup.
-    */
-    if (synctex_get_mode() > 0) {
-        callback_id = callback_defined(finish_synctex_callback);
-        if (callback_id > 0) {
-            run_callback(callback_id, "->");
-        }
-    }
-    free_text_codes();
-    free_math_codes();
-    if (log_opened_global) {
-        wlog_cr();
-        selector = selector - 2;
-        if ((selector == term_only) && (callback_id == 0)) {
-            tprint_nl("Transcript written on ");
-            tprint_file_name(NULL, texmf_log_name, NULL);
-            print_char('.');
-            print_ln();
-        }
-        lua_a_close_out(log_file);
-    }
-}
-
-
-@ We get to the |final_cleanup| routine when \.{\\end} or \.{\\dump} has
-been scanned and |its_all_over|\kern-2pt.
-
-@c
-void final_cleanup(void)
-{
-    int c;                      /* 0 for \.{\\end}, 1 for \.{\\dump} */
-    halfword i;                 /* for looping marks  */
-    halfword t;                 /* was a global temp_ptr */
-    c = cur_chr;
-    if (job_name == 0)
-        open_log_file();
-    while (input_ptr > 0)
-        if (istate == token_list)
-            end_token_list();
-        else
-            end_file_reading();
-    while (open_parens > 0) {
-        report_stop_file(filetype_tex);
-        decr(open_parens);
-    }
-    if (cur_level > level_one) {
-        tprint_nl("(\\end occurred inside a group at level ");
-        print_int(cur_level - level_one);
-        print_char(')');
-        show_save_groups();
-    }
-    while (cond_ptr != null) {
-        tprint_nl("(\\end occurred when ");
-        print_cmd_chr(if_test_cmd, cur_if);
-        if (if_line != 0) {
-            tprint(" on line ");
-            print_int(if_line);
-        }
-        tprint(" was incomplete)");
-        if_line = if_line_field(cond_ptr);
-        cur_if = subtype(cond_ptr);
-        t = cond_ptr;
-        cond_ptr = vlink(cond_ptr);
-        flush_node(t);
-    }
-    if (callback_defined(stop_run_callback) == 0)
-        if (history != spotless)
-            if ((history == warning_issued) || (interaction < error_stop_mode))
-                if (selector == term_and_log) {
-                    selector = term_only;
-                    tprint_nl("(see the transcript file for additional information)");
-                    selector = term_and_log;
-                }
-    if (c == 1) {
-        if (ini_version) {
-            for (i = 0; i <= biggest_used_mark; i++) {
-                delete_top_mark(i);
-                delete_first_mark(i);
-                delete_bot_mark(i);
-                delete_split_first_mark(i);
-                delete_split_bot_mark(i);
-            }
-            for (c = last_box_code; c <= vsplit_code; c++)
-                flush_node_list(disc_ptr[c]);
-            if (last_glue != max_halfword) {
-                flush_node(last_glue);
-            }
-            while (pseudo_files != null)
-                pseudo_close(); /* flush pseudo files */
-            store_fmt_file();
-            return;
-        }
-        tprint_nl("(\\dump is performed only by INITEX)");
-        return;
-    }
-}
-
-@ Once \TeX\ is working, you should be able to diagnose most errors with
-the \.{\\show} commands and other diagnostic features.
-An additional routine called |debug_help|
-will come into play when you type `\.D' after an error message;
-|debug_help| also occurs just before a fatal error causes \TeX\ to succumb.
-@^debugging@>
-@^system dependencies@>
-
-The interface to |debug_help| is primitive, but it is good enough when used
-with a debugger that allows you to set breakpoints and to read
-variables and change their values. After getting the prompt `\.{debug \#}', you
-type either a negative number (this exits |debug_help|), or zero (this
-goes to a location where you can set a breakpoint, thereby entering into
-dialog with the debugger), or a positive number |m| followed by
-an argument |n|. The meaning of |m| and |n| will be clear from the
-program below. (If |m=13|, there is an additional argument, |l|.)
-@.debug \#@>
-
-@c
-#ifdef DEBUG
-void debug_help(void)
-{                               /* routine to display various things */
-    int k;
-    int m = 0, n = 0, l = 0;
-    while (1) {
-        wake_up_terminal();
-        tprint_nl("debug # (-1 to exit):");
-        update_terminal();
-        (void) fscanf(term_in, "%d", &m);
-        if (m < 0)
-            return;
-        else if (m == 0)
-            abort();            /* go to every label at least once */
-        else {
-            (void) fscanf(term_in, "%d", &n);
-            switch (m) {
-            case 1:
-                print_word(varmem[n]);  /* display |varmem[n]| in all forms */
-                break;
-            case 2:
-                print_int(info(n));
-                break;
-            case 3:
-                print_int(link(n));
-                break;
-            case 4:
-                print_word(eqtb[n]);
-                break;
-            case 6:
-                print_int(save_type(n));
-                print_int(save_level(n));
-                print_word(save_word(n));
-                break;
-            case 7:
-                show_box(n);    /* show a box, abbreviated by |show_box_depth| and |show_box_breadth| */
-                break;
-            case 8:
-                breadth_max = 10000;
-                depth_threshold = 0x7FFFFFFF;
-                show_node_list(n);      /* show a box in its entirety */
-                break;
-            case 9:
-                show_token_list(n, null, 1000);
-                break;
-            case 10:
-                print(n);
-                break;
-            case 13:
-                (void) fscanf(term_in, "%d", &l);
-                print_cmd_chr(n, l);
-                break;
-            case 14:
-                for (k = 0; k <= n; k++)
-                    print(buffer[k]);
-                break;
-            case 15:
-                font_in_short_display = null_font;
-                short_display(n);
-                break;
-            default:
-                tprint("?");
-                break;
-            }
-        }
-    }
-}
-#endif
diff --git a/texk/web2c/luatexdir/tex/maincontrol.w b/texk/web2c/luatexdir/tex/maincontrol.c
similarity index 66%
rename from texk/web2c/luatexdir/tex/maincontrol.w
rename to texk/web2c/luatexdir/tex/maincontrol.c
index 7b4cf9065..295e2c6cc 100644
--- a/texk/web2c/luatexdir/tex/maincontrol.w
+++ b/texk/web2c/luatexdir/tex/maincontrol.c
@@ -1,80 +1,79 @@
-% maincontrol.w
-%
-% Copyright 2009-2010 Taco Hoekwater <taco@@luatex.org>
-%
-% This file is part of LuaTeX.
-%
-% LuaTeX is free software; you can redistribute it and/or modify it under
-% the terms of the GNU General Public License as published by the Free
-% Software Foundation; either version 2 of the License, or (at your
-% option) any later version.
-%
-% LuaTeX is distributed in the hope that it will be useful, but WITHOUT
-% ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-% FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
-% License for more details.
-%
-% You should have received a copy of the GNU General Public License along
-% with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
-
-@ @c
+/*
+
+maincontrol.w
+
+Copyright 2009-2010 Taco Hoekwater <taco@@luatex.org>
+
+This file is part of LuaTeX.
+
+LuaTeX is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 2 of the License, or (at your
+option) any later version.
+
+LuaTeX is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+License for more details.
+
+You should have received a copy of the GNU General Public License along
+with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+
+*/
 
 #include "ptexlib.h"
 #include "lua/luatex-api.h"
 
-@ @c
 #define mode     mode_par
 #define tail     tail_par
 #define head     head_par
 #define dir_save dirs_par
 
-@ We come now to the |main_control| routine, which contains the master
-switch that causes all the various pieces of \TeX\ to do their things,
-in the right order.
-
-In a sense, this is the grand climax of the program: It applies all the
-tools that we have worked so hard to construct. In another sense, this is
-the messiest part of the program: It necessarily refers to other pieces
-of code all over the place, so that a person can't fully understand what is
-going on without paging back and forth to be reminded of conventions that
-are defined elsewhere. We are now at the hub of the web, the central nervous
-system that touches most of the other parts and ties them together.
-@^brain@>
-
-The structure of |main_control| itself is quite simple. There's a label
-called |big_switch|, at which point the next token of input is fetched
-using |get_x_token|. Then the program branches at high speed into one of
-about 100 possible directions, based on the value of the current
-mode and the newly fetched command code; the sum |abs(mode)+cur_cmd|
-indicates what to do next. For example, the case `|vmode+letter|' arises
-when a letter occurs in vertical mode (or internal vertical mode); this
-case leads to instructions that initialize a new paragraph and enter
-horizontal mode.
+/*tex
+
+We come now to the |main_control| routine, which contains the master switch that
+causes all the various pieces of \TeX\ to do their things, in the right order.
+
+In a sense, this is the grand climax of the program: It applies all the tools
+that we have worked so hard to construct. In another sense, this is the messiest
+part of the program: It necessarily refers to other pieces of code all over the
+place, so that a person can't fully understand what is going on without paging
+back and forth to be reminded of conventions that are defined elsewhere. We are
+now at the hub of the web, the central nervous system that touches most of the
+other parts and ties them together. @^brain@>
+
+The structure of |main_control| itself is quite simple. There's a label called
+|big_switch|, at which point the next token of input is fetched using
+|get_x_token|. Then the program branches at high speed into one of about 100
+possible directions, based on the value of the current mode and the newly fetched
+command code; the sum |abs(mode)+cur_cmd| indicates what to do next. For example,
+the case `|vmode+letter|' arises when a letter occurs in vertical mode (or
+internal vertical mode); this case leads to instructions that initialize a new
+paragraph and enter horizontal mode.
 
 The big |case| statement that contains this multiway switch has been labeled
-|reswitch|, so that the program can |goto reswitch| when the next token
-has already been fetched. Most of the cases are quite short; they call
-an ``action procedure'' that does the work for that case, and then they
-either |goto reswitch| or they ``fall through'' to the end of the |case|
-statement, which returns control back to |big_switch|. Thus, |main_control|
-is not an extremely large procedure, in spite of the multiplicity of things
-it must do; it is small enough to be handled by PASCAL compilers that put
-severe restrictions on procedure size.
-@!@^action procedure@>
-
-One case is singled out for special treatment, because it accounts for most
-of \TeX's activities in typical applications. The process of reading simple
-text and converting it into |char_node| records, while looking for ligatures
-and kerns, is part of \TeX's ``inner loop''; the whole program runs
-efficiently when its inner loop is fast, so this part has been written
-with particular care.
-
-We leave the |space_factor| unchanged if |sf_code(cur_chr)=0|; otherwise we
-set it equal to |sf_code(cur_chr)|, except that it should never change
-from a value less than 1000 to a value exceeding 1000. The most common
-case is |sf_code(cur_chr)=1000|, so we want that case to be fast.
-
-@c
+|reswitch|, so that the program can |goto reswitch| when the next token has
+already been fetched. Most of the cases are quite short; they call an ``action
+procedure'' that does the work for that case, and then they either |goto
+reswitch| or they ``fall through'' to the end of the |case| statement, which
+returns control back to |big_switch|. Thus, |main_control| is not an extremely
+large procedure, in spite of the multiplicity of things it must do; it is small
+enough to be handled by PASCAL compilers that put severe restrictions on
+procedure size. @!@^action procedure@>
+
+One case is singled out for special treatment, because it accounts for most of
+\TeX's activities in typical applications. The process of reading simple text and
+converting it into |char_node| records, while looking for ligatures and kerns, is
+part of \TeX's ``inner loop''; the whole program runs efficiently when its inner
+loop is fast, so this part has been written with particular care.
+
+We leave the |space_factor| unchanged if |sf_code(cur_chr)=0|; otherwise we set
+it equal to |sf_code(cur_chr)|, except that it should never change from a value
+less than 1000 to a value exceeding 1000. The most common case is
+|sf_code(cur_chr)=1000|, so we want that case to be fast.
+
+*/
+
 void adjust_space_factor(void)
 {
     halfword s = get_sf_code(cur_chr);
@@ -90,21 +89,21 @@ void adjust_space_factor(void)
     }
 }
 
-@ From Knuth: ``Having |font_glue| allocated for each text font saves
-both time and memory.''  That may be true, but it also punches through
-the API wall for fonts, so I removed that -- Taco. But a bit of caching
-is very welcome, which is why I need to have the next two globals:
+/*tex
 
-@ To handle the execution state of |main_control|'s eternal loop,
-an extra global variable is used, along with a macro to define
-its values.
+To handle the execution state of |main_control|'s eternal loop, an extra global
+variable is used, along with a macro to define its values.
+
+*/
 
-@c
 #define goto_next 0
 #define goto_skip_token 1
 #define goto_return 2
 
 static int main_control_state;
+static int local_level = 0;
+
+/*tex
 
 @* Main control helpers.
 
@@ -112,8 +111,8 @@ Here are all the functions that are called from |main_control| that
 are not already defined elsewhere. For the moment, this list simply
 in the order that the appear in |init_main_control|, below.
 
-@
-@c
+*/
+
 static void run_char_num (void) {
     scan_char_num();
     cur_chr = cur_val;
@@ -126,23 +125,49 @@ static void run_char (void) {
     tail_append(new_char(cur_font_par, cur_chr));
 }
 
-@
-The occurrence of blank spaces is almost part of \TeX's inner loop,
-since we usually encounter about one space for every five non-blank characters.
-Therefore |main_control| gives second-highest priority to ordinary spaces.
+static void run_node (void) {
+    halfword n = cur_chr;
+    if (copy_lua_input_nodes_par) {
+        n = copy_node_list(n);
+    }
+    tail_append(n);
+    while (vlink(n) != null) {
+        n = vlink(n);
+        tail_append(n);
+    }
+}
 
-When a glue parameter like \.{\\spaceskip} is set to `\.{0pt}', we will
-see to it later that the corresponding glue specification is precisely
-|zero_glue|, not merely a pointer to some specification that happens
-to be full of zeroes. Therefore it is simple to test whether a glue parameter
-is zero or~not.
+static void run_lua_call(void) {
+    if (cur_chr <= 0) {
+        normal_error("luacall", "invalid number");
+    } else {
+        str_number u = save_cur_string();
+        luacstrings = 0;
+        luafunctioncall(cur_chr);
+        restore_cur_string(u);
+        if (luacstrings > 0)
+            lua_string_start();
+    }
+}
+
+/*tex
+
+The occurrence of blank spaces is almost part of \TeX's inner loop, since we
+usually encounter about one space for every five non-blank characters. Therefore
+|main_control| gives second-highest priority to ordinary spaces.
+
+When a glue parameter like \.{\\spaceskip} is set to `\.{0pt}', we will see to it
+later that the corresponding glue specification is precisely |zero_glue|, not
+merely a pointer to some specification that happens to be full of zeroes.
+Therefore it is simple to test whether a glue parameter is zero or~not.
+
+*/
 
-@c
 static void run_app_space (void) {
     halfword p; /* was a global temp_ptr */
     int method = disable_space_par ;
     if (method == 1) {
-        /* don't inject anything, not even zero skip */
+        /*tex Don't inject anything, not even zero skip. */
     } else if (method == 2) {
         p = new_glue(zero_glue);
         couple_nodes(tail,p);
@@ -150,9 +175,9 @@ static void run_app_space (void) {
     } else if ((abs(mode) + cur_cmd == hmode + spacer_cmd) && (!(space_factor_par == 1000))) {
         app_space();
     } else {
-        /* Append a normal inter-word space to the current list */
+        /*tex Append a normal inter-word space to the current list. */
         if (glue_is_zero(space_skip_par)) {
-            /* Find the glue specification for text spaces in the current font */
+            /*tex Find the glue specification for text spaces in the current font. */
             p = new_glue(zero_glue);
             width(p) = space(cur_font_par);
             stretch(p) = space_stretch(cur_font_par);
@@ -161,20 +186,24 @@ static void run_app_space (void) {
         } else {
             p = new_param_glue(space_skip_code);
         }
-        /* so from now we have a subtype with spaces: */
+        /*tex So from now we have a subtype with spaces: */
         subtype(p) = space_skip_code + 1 ;
         couple_nodes(tail,p);
         tail = p;
     }
 }
 
-@ Append a |boundary_node|
-@c
+/*tex
+
+Append a |boundary_node|
+
+*/
+
 static void run_boundary (void) {
     halfword n ;
     n = new_node(boundary_node,cur_chr);
     if ((cur_chr == 1) || (cur_chr == 2) ) {
-        /* user boundary or protrusion boundary */
+        /*tex We expect a user boundary or protrusion boundary. */
         scan_int();
         boundary_value(n) = cur_val;
     }
@@ -182,7 +211,6 @@ static void run_boundary (void) {
     tail = n;
 }
 
-@ @c
 static void run_char_ghost (void) {
     int t;
     t = cur_chr;
@@ -199,19 +227,21 @@ static void run_char_ghost (void) {
     }
 }
 
-@ @c
 static void run_relax (void) {
     return;
 }
 
-@ |ignore_spaces| is a special case: after it has acted, |get_x_token| has already
-fetched the next token from the input, so that operation in |main_control|
-should be skipped.
+/*tex
+
+|ignore_spaces| is a special case: after it has acted, |get_x_token| has already
+fetched the next token from the input, so that operation in |main_control| should
+be skipped.
+
+*/
 
-@c
 static void run_ignore_spaces (void) {
     if (cur_chr == 0) {
-        /* Get the next non-blank non-call... */
+        /*tex Get the next non-blank non-call... */
         do {
             get_x_token();
         } while (cur_cmd == spacer_cmd);
@@ -231,24 +261,33 @@ static void run_ignore_spaces (void) {
     }
 }
 
-@ |stop| is the second special case. We want |main_control| to return to its caller
+/*tex
+
+|stop| is the second special case. We want |main_control| to return to its caller
 if there is nothing left to do.
 
-@c
+*/
+
 static void run_stop (void) {
-    if (its_all_over())
-       main_control_state= goto_return; /* this is the only way out */
+    if (its_all_over()) {
+        /*tex this is the only way out */
+        main_control_state= goto_return;
+    }
 }
 
-@ @c
 static void run_non_math_math (void) {
     back_input();
     new_graf(true);
 }
 
-@ @c
+/*tex
+
+    We build up an argument to |set_math_char|:
+
+*/
+
 static void run_math_char_num (void) {
-    mathcodeval mval;           /* to build up an argument to |set_math_char| */
+    mathcodeval mval;
     if (cur_chr == 0)
         mval = scan_mathchar(tex_mathcode);
     else if (cur_chr == 1)
@@ -258,35 +297,47 @@ static void run_math_char_num (void) {
     math_char_in_text(mval);
 }
 
-@ @c
+/*tex
+
+    We build up an argument to |set_math_char|:
+*/
+
 static void run_math_given (void) {
-    mathcodeval mval;           /* to build up an argument to |set_math_char| */
+    mathcodeval mval;
     mval = mathchar_from_integer(cur_chr, tex_mathcode);
     math_char_in_text(mval);
 }
 
+/*tex
+
+    We build up an argument to |set_math_char| the \LUATEX\ way:
+*/
+
 static void run_xmath_given (void) {
-    mathcodeval mval;           /* to build up an argument to |set_math_char| */
+    mathcodeval mval;
     mval = mathchar_from_integer(cur_chr, umath_mathcode);
     math_char_in_text(mval);
 }
 
-@  The most important parts of |main_control| are concerned with \TeX's
-chief mission of box-making. We need to control the activities that put
-entries on vlists and hlists, as well as the activities that convert
-those lists into boxes. All of the necessary machinery has already been
-developed; it remains for us to ``push the buttons'' at the right times.
+/*tex
 
-As an introduction to these routines, let's consider one of the simplest
-cases: What happens when `\.{\\hrule}' occurs in vertical mode, or
-`\.{\\vrule}' in horizontal mode or math mode? The code in |main_control|
-is short, since the |scan_rule_spec| routine already does most of what is
-required; thus, there is no need for a special action procedure.
+The most important parts of |main_control| are concerned with \TeX's chief
+mission of box-making. We need to control the activities that put entries on
+vlists and hlists, as well as the activities that convert those lists into boxes.
+All of the necessary machinery has already been developed; it remains for us to
+``push the buttons'' at the right times.
 
-Note that baselineskip calculations are disabled after a rule in vertical
-mode, by setting |prev_depth:=ignore_depth|.
+As an introduction to these routines, let's consider one of the simplest cases:
+What happens when `\.{\\hrule}' occurs in vertical mode, or `\.{\\vrule}' in
+horizontal mode or math mode? The code in |main_control| is short, since the
+|scan_rule_spec| routine already does most of what is required; thus, there is no
+need for a special action procedure.
+
+Note that baselineskip calculations are disabled after a rule in vertical mode,
+by setting |prev_depth:=ignore_depth|.
+
+*/
 
-@c
 static void run_rule (void) {
     tail_append(scan_rule_spec());
     if (abs(mode) == vmode)
@@ -295,29 +346,30 @@ static void run_rule (void) {
         space_factor_par = 1000;
 }
 
-@
-Many of the actions related to box-making are triggered by the appearance
-of braces in the input. For example, when the user says `\.{\\hbox}
-\.{to} \.{100pt\{$\langle\,\hbox{hlist}\,\rangle$\}}' in vertical mode,
-the information about the box size (100pt, |exactly|) is put onto |save_stack|
-with a level boundary word just above it, and |cur_group:=adjusted_hbox_group|;
-\TeX\ enters restricted horizontal mode to process the hlist. The right
-brace eventually causes |save_stack| to be restored to its former state,
-at which time the information about the box size (100pt, |exactly|) is
-available once again; a box is packaged and we leave restricted horizontal
-mode, appending the new box to the current list of the enclosing mode
-(in this case to the current list of vertical mode), followed by any
-vertical adjustments that were removed from the box by |hpack|.
-
-The next few sections of the program are therefore concerned with the
-treatment of left and right curly braces.
-
-If a left brace occurs in the middle of a page or paragraph, it simply
-introduces a new level of grouping, and the matching right brace will not have
-such a drastic effect. Such grouping affects neither the mode nor the
-current list.
-
-@c
+/*tex
+
+Many of the actions related to box-making are triggered by the appearance of
+braces in the input. For example, when the user says `\.{\\hbox} \.{to}
+\.{100pt\{$\langle\,\hbox{hlist}\,\rangle$\}}' in vertical mode, the information
+about the box size (100pt, |exactly|) is put onto |save_stack| with a level
+boundary word just above it, and |cur_group:=adjusted_hbox_group|; \TeX\ enters
+restricted horizontal mode to process the hlist. The right brace eventually
+causes |save_stack| to be restored to its former state, at which time the
+information about the box size (100pt, |exactly|) is available once again; a box
+is packaged and we leave restricted horizontal mode, appending the new box to the
+current list of the enclosing mode (in this case to the current list of vertical
+mode), followed by any vertical adjustments that were removed from the box by
+|hpack|.
+
+The next few sections of the program are therefore concerned with the treatment
+of left and right curly braces.
+
+If a left brace occurs in the middle of a page or paragraph, it simply introduces
+a new level of grouping, and the matching right brace will not have such a
+drastic effect. Such grouping affects neither the mode nor the current list.
+
+*/
+
 static void run_left_brace (void) {
     new_save_level(simple_group);
     eq_word_define(int_base + no_local_whatsits_code, 0);
@@ -338,11 +390,14 @@ static void run_end_group (void) {
     }
 }
 
-@ Constructions that require a box are started by calling |scan_box| with
-a specified context code. The |scan_box| routine verifies
-that a |make_box| command comes next and then it calls |begin_box|.
+/*tex
+
+Constructions that require a box are started by calling |scan_box| with a
+specified context code. The |scan_box| routine verifies that a |make_box| command
+comes next and then it calls |begin_box|.
+
+*/
 
-@c
 static void run_move (void) {
     int t = cur_chr;
     scan_normal_dimen();
@@ -352,17 +407,14 @@ static void run_move (void) {
         scan_box(-cur_val);
 }
 
-@ @c
 static void run_leader_ship (void) {
     scan_box(leader_flag - a_leaders + cur_chr);
 }
 
-@ @c
 static void run_make_box (void) {
     begin_box(0);
 }
 
-@ @c
 static void run_box_dir (void) {
     scan_register_num();
     cur_box = box(cur_val);
@@ -372,37 +424,51 @@ static void run_box_dir (void) {
         box_dir(cur_box) = cur_val;
 }
 
-@ There is a really small patch to add a new primitive called
-\.{\\quitvmode}. In vertical modes, it is identical to \.{\\indent},
-but in horizontal and math modes it is really a no-op (as opposed to
-\.{\\indent}, which executes the |indent_in_hmode| procedure).
+static void run_box_direction (void) {
+    scan_register_num();
+    cur_box = box(cur_val);
+    scan_optional_equals();
+    scan_int();
+    check_dir_value(cur_val);
+    if (cur_box != null)
+        box_dir(cur_box) = cur_val;
+}
+
+/*tex
+
+There is a really small patch to add a new primitive called \.{\\quitvmode}. In
+vertical modes, it is identical to \.{\\indent}, but in horizontal and math modes
+it is really a no-op (as opposed to \.{\\indent}, which executes the
+|indent_in_hmode| procedure).
 
-A paragraph begins when horizontal-mode material occurs in vertical mode,
-or when the paragraph is explicitly started by `\.{\\quitvmode}',
-`\.{\\indent}' or `\.{\\noindent}'.
+A paragraph begins when horizontal-mode material occurs in vertical mode, or when
+the paragraph is explicitly started by `\.{\\quitvmode}', `\.{\\indent}' or
+`\.{\\noindent}'.
+
+*/
 
-@c
 static void run_start_par_vmode (void) {
     new_graf((cur_chr > 0));
 }
 
-@ @c
 static void run_start_par (void) {
    if (cur_chr != 2)
        indent_in_hmode();
 }
 
-@ @c
 static void run_new_graf (void) {
    back_input();
    new_graf(true);
 }
 
-@ A paragraph ends when a |par_end| command is sensed, or when we are in
-horizontal mode when reaching the right brace of vertical-mode routines
-like \.{\\vbox}, \.{\\insert}, or \.{\\output}.
+/*tex
+
+A paragraph ends when a |par_end| command is sensed, or when we are in horizontal
+mode when reaching the right brace of vertical-mode routines like \.{\\vbox},
+\.{\\insert}, or \.{\\output}.
+
+*/
 
-@c
 static void run_par_end_vmode (void) {
     normal_paragraph();
     if (mode > 0) {
@@ -411,28 +477,27 @@ static void run_par_end_vmode (void) {
     }
 }
 
-@ @c
 static void run_par_end_hmode (void) {
-    if (align_state < 0)
-        off_save();         /* this tries to  recover from an alignment that didn't end properly */
-    end_graf(bottom_level); /* this takes us to the enclosing mode, if |mode>0| */
+    if (align_state < 0) {
+        /*tex This tries to recover from an alignment that didn't end properly. */
+        off_save();
+    }
+    /* This takes us to the enclosing mode, if |mode>0|. */
+    end_graf(bottom_level);
     if (mode == vmode) {
         checked_page_filter(hmode_par);
         build_page();
     }
 }
 
-@ @c
 static void append_italic_correction_mmode (void) {
-    tail_append(new_kern(0)); /* what subtype to use */
+    tail_append(new_kern(0));
 }
 
-@ @c
 static void run_local_box (void) {
     append_local_box(cur_chr);
 }
 
-@ @c
 static void run_halign_mmode (void) {
     if (privileged()) {
         if (cur_group == math_shift_group)
@@ -442,7 +507,6 @@ static void run_halign_mmode (void) {
     }
 }
 
-@ @c
 static void run_eq_no (void) {
     if (privileged()) {
         if (cur_group == math_shift_group)
@@ -452,21 +516,18 @@ static void run_eq_no (void) {
     }
 }
 
-@ @c
 static void run_letter_mmode (void) {
    set_math_char(get_math_code(cur_chr));
 }
 
-@ @c
 static void run_char_num_mmode (void) {
     scan_char_num();
     cur_chr = cur_val;
     set_math_char(get_math_code(cur_chr));
 }
 
-@ @c
 static void run_math_char_num_mmode (void) {
-    mathcodeval mval;           /* to build up an argument to |set_math_char| */
+    mathcodeval mval;
     if (cur_chr == 0)
         mval = scan_mathchar(tex_mathcode);
     else if (cur_chr == 1)
@@ -476,31 +537,27 @@ static void run_math_char_num_mmode (void) {
     set_math_char(mval);
 }
 
-@ @c
 static void run_math_given_mmode (void) {
-    mathcodeval mval;           /* to build up an argument to |set_math_char| */
+    mathcodeval mval;
     mval = mathchar_from_integer(cur_chr, tex_mathcode);
     set_math_char(mval);
 }
 
 static void run_xmath_given_mmode (void) {
-    mathcodeval mval;           /* to build up an argument to |set_math_char| */
+    mathcodeval mval;
     mval = mathchar_from_integer(cur_chr, umath_mathcode);
     set_math_char(mval);
 }
 
-@ @c
 static void run_delim_num (void) {
-    mathcodeval mval;           /* to build up an argument to |set_math_char| */
+    mathcodeval mval;
     if (cur_chr == 0)
         mval = scan_delimiter_as_mathchar(tex_mathcode);
     else
         mval = scan_delimiter_as_mathchar(umath_mathcode);
     set_math_char(mval);
-
 }
 
-@ @c
 static void run_vcenter (void) {
     scan_spec(vcenter_group);
     normal_paragraph();
@@ -511,18 +568,15 @@ static void run_vcenter (void) {
         begin_token_list(every_vbox_par, every_vbox_text);
 }
 
-@ @c
 static void run_math_style (void) {
     tail_append(new_style((small_number) cur_chr));
 }
 
-@ @c
 static void run_non_script (void) {
     tail_append(new_glue(zero_glue));
     subtype(tail) = cond_math_glue;
 }
 
-@ @c
 static void run_math_choice (void) {
     if (cur_chr == 0)
         append_choices();
@@ -530,7 +584,6 @@ static void run_math_choice (void) {
         setup_math_style();
 }
 
-@ @c
 static void run_math_shift (void) {
     if (cur_group == math_shift_group)
         after_math();
@@ -538,19 +591,16 @@ static void run_math_shift (void) {
         off_save();
 }
 
-@ @c
 static void run_after_assignment (void) {
     get_token();
     after_token = cur_tok;
 }
 
-@ @c
 static void run_after_group (void) {
     get_token();
     save_for_after(cur_tok);
 }
 
-@ @c
 static void run_extension (void) {
     do_extension(0);
 }
@@ -565,12 +615,16 @@ static void run_normal (void) {
             scan_int();
             if ((cur_val < 0) || (cur_val > 0x7FFF)) {
                 print_err("Invalid \\catcode table");
-                help1("All \\catcode table ids must be between 0 and 0x7FFF");
+                help1(
+                    "All \\catcode table ids must be between 0 and 0x7FFF"
+                );
                 error();
             } else {
                 if (cur_val == cat_code_table_par) {
                     print_err("Invalid \\catcode table");
-                    help1("You cannot overwrite the current \\catcode table");
+                    help1(
+                        "You cannot overwrite the current \\catcode table"
+                    );
                     error();
                 } else {
                     copy_cat_codes(cat_code_table_par, cur_val);
@@ -581,12 +635,16 @@ static void run_normal (void) {
             scan_int();
             if ((cur_val < 0) || (cur_val > 0x7FFF)) {
                 print_err("Invalid \\catcode table");
-                help1("All \\catcode table ids must be between 0 and 0x7FFF");
+                help1(
+                    "All \\catcode table ids must be between 0 and 0x7FFF"
+                );
                 error();
             } else {
                 if (cur_val == cat_code_table_par) {
                     print_err("Invalid \\catcode table");
-                    help1("You cannot overwrite the current \\catcode table");
+                    help1(
+                        "You cannot overwrite the current \\catcode table"
+                    );
                     error();
                 } else {
                     initex_cat_codes(cur_val);
@@ -607,6 +665,12 @@ static void run_normal (void) {
             (void) scan_toks(false, false);
             late_lua_data(tail) = def_ref;
             break;
+        case late_lua_call_code:
+            new_whatsit(late_lua_node);
+            late_lua_type(tail) = lua_refid_call;
+            scan_int();
+            late_lua_data(tail) = cur_val;
+            break;
         case expand_font_code:
             read_expand_font();
             break;
@@ -617,9 +681,10 @@ static void run_normal (void) {
     }
 }
 
-/*
-    this is experimental and not used for production, only for testing and writing
-    macros (some options stay)
+/*tex
+
+This is experimental and not used for production, only for testing and writing
+macros (some options stay).
 
 */
 
@@ -633,14 +698,10 @@ static void run_option(void) {
         case math_option_code:
             if (scan_keyword("old")) {
                 mathoption_set_int(c_mathoption_old_code);
-            } else if (scan_keyword("noitaliccompensation")) {
-                mathoption_set_int(c_mathoption_no_italic_compensation_code);
-            } else if (scan_keyword("nocharitalic")) {
-                mathoption_set_int(c_mathoption_no_char_italic_code);
-            } else if (scan_keyword("useoldfractionscaling")) {
-                mathoption_set_int(c_mathoption_use_old_fraction_scaling_code);
+            /*
             } else if (scan_keyword("umathcodemeaning")) {
                 mathoption_set_int(c_mathoption_umathcode_meaning_code);
+            */
             } else {
                 normal_warning("mathoption","unknown key");
             }
@@ -651,20 +712,55 @@ static void run_option(void) {
     }
 }
 
-@ For mode-independent commands, the following macro is useful.
+static void lua_function_call(void) {
+    scan_int();
+    if (cur_val <= 0) {
+        normal_error("luafunctioncall", "invalid number");
+    } else {
+        str_number u = save_cur_string();
+        luacstrings = 0;
+        luafunctioncall(cur_val);
+        restore_cur_string(u);
+        if (luacstrings > 0)
+            lua_string_start();
+    }
+}
+
+static void lua_bytecode_call(void) {
+    scan_int();
+    if (cur_val < 0 || cur_val > 65535) {
+        normal_error("luabytecodecall", "invalid number");
+    } else {
+        str_number u = save_cur_string();
+        luacstrings = 0;
+        luabytecodecall(cur_val);
+        restore_cur_string(u);
+        if (luacstrings > 0)
+            lua_string_start();
+    }
+}
+
+/*tex
+
+For mode-independent commands, the following macro is useful.
 
-Also, there is a list of cases where the user has probably gotten into or out of math
-mode by mistake. \TeX\ will insert a dollar sign and rescan the current token, and
-it makes sense ot have a macro for that as well.
+Also, there is a list of cases where the user has probably gotten into or out of
+math mode by mistake. \TeX\ will insert a dollar sign and rescan the current
+token, and it makes sense ot have a macro for that as well.
+
+*/
 
-@c
 #define any_mode(A,B) jump_table[vmode+(A)]=B; jump_table[hmode+(A)]=B; jump_table[mmode+(A)]=B
 #define non_math(A,B) jump_table[vmode+(A)]=B; jump_table[hmode+(A)]=B;
 
+/*tex
+
+The |main_control| uses a jump table, and |init_main_control| sets that table up.
+
+*/
 
-@ The |main_control| uses a jump table, and |init_main_control| sets that table up.
-@c
 typedef void (*main_control_function) (void);
+
 main_control_function *jump_table;
 
 static void init_main_control (void) {
@@ -749,6 +845,7 @@ static void init_main_control (void) {
     any_mode(leader_ship_cmd, run_leader_ship);
     any_mode(make_box_cmd, run_make_box);
     any_mode(assign_box_dir_cmd, run_box_dir);
+    any_mode(assign_box_direction_cmd, run_box_direction);
     jump_table[vmode + start_par_cmd] = run_start_par_vmode;
     jump_table[hmode + start_par_cmd] = run_start_par;
     jump_table[mmode + start_par_cmd] = run_start_par;
@@ -835,6 +932,7 @@ static void init_main_control (void) {
     any_mode(assign_int_cmd, prefixed_command);
     any_mode(assign_attr_cmd, prefixed_command);
     any_mode(assign_dir_cmd, prefixed_command);
+    any_mode(assign_direction_cmd, prefixed_command);
     any_mode(assign_dimen_cmd, prefixed_command);
     any_mode(assign_glue_cmd, prefixed_command);
     any_mode(assign_mu_glue_cmd, prefixed_command);
@@ -879,46 +977,181 @@ static void init_main_control (void) {
     any_mode(normal_cmd, run_normal);
     any_mode(extension_cmd, run_extension);
     any_mode(option_cmd, run_option);
+
+    any_mode(lua_function_call_cmd, lua_function_call);
+    any_mode(lua_bytecode_call_cmd, lua_bytecode_call);
+    any_mode(def_lua_call_cmd, prefixed_command);
+    any_mode(lua_call_cmd, run_lua_call);
+ /* any_mode(lua_expandable_call_cmd, run_lua_call); */ /* no! outside jump table anyway, handled in expand() */
+    any_mode(node_cmd, run_node);
+
 }
 
-@ And here is |main_control| itself.  It is quite short nowadays.
+/*tex
+
+    And here is |main_control| itself.  It is quite short nowadays.
+
+*/
 
-@c
 void main_control(void)
 {
     main_control_state = goto_next;
-    init_main_control () ;
-
-    if (equiv(every_job_loc) != null)
+    init_main_control() ;
+    if (equiv(every_job_loc) != null) {
         begin_token_list(equiv(every_job_loc), every_job_text);
-
+    }
     while (1) {
-        if (main_control_state == goto_skip_token)
-                main_control_state = goto_next; /* reset */
-        else
+        if (main_control_state == goto_skip_token) {
+            main_control_state = goto_next;
+        } else {
             get_x_token();
-
-        /* Give diagnostic information, if requested */
-        /* When a new token has just been fetched at |big_switch|, we have an
-           ideal place to monitor \TeX's activity. */
+        }
+        /*tex
+            Give diagnostic information, if requested When a new token has just
+            been fetched at |big_switch|, we have an ideal place to monitor
+            \TeX's activity.
+        */
         if (interrupt != 0 && OK_to_interrupt) {
             back_input();
             check_interrupt();
             continue;
         }
-        if (tracing_commands_par > 0)
+        if (tracing_commands_par > 0) {
             show_cur_cmd_chr();
+        }
+        /*tex run the command */
+        (jump_table[(abs(mode) + cur_cmd)])();
+        if (main_control_state == goto_return) {
+            return;
+        }
+    }
+    /*tex not reached */
+    return;
+}
 
-        (jump_table[(abs(mode) + cur_cmd)])(); /* run the command */
+/*tex
 
-        if (main_control_state == goto_return) {
+We assume a trailing relax: |{...}\relax|, so we don't need a |back_input()| here.
+
+*/
+
+/*int local_level = 0; */
+
+extern void local_control_message(const char *s)
+{
+    tprint("local control level ");
+    print_int(local_level);
+    tprint(": ");
+    tprint(s);
+    tprint_nl("");
+}
+
+void local_control(void)
+{
+    int ll = local_level;
+    main_control_state = goto_next;
+    local_level += 1;
+    while (1) {
+        if (main_control_state == goto_skip_token) {
+            main_control_state = goto_next;
+        } else {
+            get_x_token();
+        }
+        if (interrupt != 0 && OK_to_interrupt) {
+            back_input();
+            check_interrupt();
+            continue;
+        }
+        if (tracing_commands_par > 0) {
+            show_cur_cmd_chr();
+        }
+        (jump_table[(abs(mode) + cur_cmd)])();
+        if (local_level <= ll) {
+            main_control_state = goto_next;
+            if (tracing_nesting_par > 2) {
+                local_control_message("leaving due to level change");
+            }
+            return ;
+        } else if (main_control_state == goto_return) {
+            if (tracing_nesting_par > 2) {
+                local_control_message("leaving due to triggering");
+            }
             return;
         }
     }
-    return; /* not reached */
+    return;
+}
+
+void end_local_control(void )
+{
+    local_level -= 1;
+}
+
+/*tex
+    We need to go back to the main loop. This is rather nasty and dirty
+    and counterintuive code and there might be a cleaner way. Basically
+    we trigger the main control state from here.
+
+    \starttyping
+     0 0       \directlua{token.scan_list()}\hbox{!}
+    -1 0       \setbox0\hbox{x}\directlua{token.scan_list()}\box0
+     1 1       \toks0={\directlua{token.scan_list()}\hbox{x}}\directlua{tex.runtoks(0)}
+     0 0  1 1  \directlua{tex.box[0]=token.scan_list()}\hbox{x\directlua{node.write(token.scan_list())}\hbox{x}}
+     0 0  0 1  \setbox0\hbox{x}\directlua{tex.box[0]=token.scan_list()}\hbox{x\directlua{node.write(token.scan_list())}\box0}
+    \stoptyping
+
+    It's rather fragile code so we added some tracing options.
+
+*/
+
+halfword local_scan_box(void)
+{
+    int old_mode = mode;
+    int ll = local_level;
+    mode = -hmode;
+    scan_box(lua_scan_flag);
+    if (local_level == ll) {
+        /*tex |\directlua{print(token.scan_list())}\hbox{!}| (n n) */
+        if (tracing_nesting_par > 2) {
+            local_control_message("entering at end of box scanning");
+        }
+        local_control();
+    } else {
+        /*tex |\directlua{print(token.scan_list())}\box0| (n-1 n) */
+        /*
+            if (tracing_nesting_par > 2) {
+                local_control_message("setting level after box scanning");
+            }
+        */
+        local_level = ll;
+    }
+    mode = old_mode;
+    return cur_box;
+}
+
+/*tex
+
+    We have an issue with modes when we quit here because we're coming
+    from and still staying at the \LUA\ end. So, unless we're already
+    nested, we trigger an end_local_level token (an extension code).
+
+*/
+
+static void wrapup_local_scan_box(void)
+{
+    /*
+    if (tracing_nesting_par > 2) {
+        local_control_message("leaving box scanner");
+    }
+    */
+    local_level -= 1;
+}
+
+int current_local_level(void)
+{
+    return local_level;
 }
 
-@ @c
 void app_space(void)
 {                               /* handle spaces when |space_factor<>1000| */
     halfword q;                 /* glue node */
@@ -948,20 +1181,24 @@ void app_space(void)
     tail = q;
 }
 
-@ @c
 void insert_dollar_sign(void)
 {
     back_input();
     cur_tok = math_shift_token + '$';
     print_err("Missing $ inserted");
-    help2("I've inserted a begin-math/end-math symbol since I think",
-          "you left one out. Proceed, with fingers crossed.");
+    help2(
+        "I've inserted a begin-math/end-math symbol since I think",
+        "you left one out. Proceed, with fingers crossed."
+    );
     ins_error();
 }
 
-@  We can silently ignore  \.{\\par}s in a math formula.
+/*tex
+
+    We can silently ignore  \.{\\par}s in a math formula.
+
+*/
 
-@c
 void insert_dollar_sign_par_end(void)
 {
     if (!suppress_mathpar_error_par) {
@@ -969,10 +1206,13 @@ void insert_dollar_sign_par_end(void)
     }
 }
 
-@ The `|you_cant|' procedure prints a line saying that the current command
-is illegal in the current mode; it identifies these things symbolically.
+/*tex
+
+The `|you_cant|' procedure prints a line saying that the current command is
+illegal in the current mode; it identifies these things symbolically.
+
+*/
 
-@c
 void you_cant(void)
 {
     print_err("You can't use `");
@@ -980,34 +1220,40 @@ void you_cant(void)
     print_in_mode(mode);
 }
 
-@
-When erroneous situations arise, \TeX\ usually issues an error message
-specific to the particular error. For example, `\.{\\noalign}' should
-not appear in any mode, since it is recognized by the |align_peek| routine
-in all of its legitimate appearances; a special error message is given
-when `\.{\\noalign}' occurs elsewhere. But sometimes the most appropriate
-error message is simply that the user is not allowed to do what he or she
-has attempted. For example, `\.{\\moveleft}' is allowed only in vertical mode,
-and `\.{\\lower}' only in non-vertical modes.  Such cases are enumerated
-here and in the other sections referred to under `See also \dots.'
+/*tex
+
+When erroneous situations arise, \TeX\ usually issues an error message specific
+to the particular error. For example, `\.{\\noalign}' should not appear in any
+mode, since it is recognized by the |align_peek| routine in all of its legitimate
+appearances; a special error message is given when `\.{\\noalign}' occurs
+elsewhere. But sometimes the most appropriate error message is simply that the
+user is not allowed to do what he or she has attempted. For example,
+`\.{\\moveleft}' is allowed only in vertical mode, and `\.{\\lower}' only in
+non-vertical modes. Such cases are enumerated here and in the other sections
+referred to under `See also \dots.'
+
+*/
 
-@c
 void report_illegal_case(void)
 {
     you_cant();
-    help4("Sorry, but I'm not programmed to handle this case;",
-          "I'll just pretend that you didn''t ask for it.",
-          "If you're in the wrong mode, you might be able to",
-          "return to the right one by typing `I}' or `I$' or `I\\par'.");
+    help4(
+        "Sorry, but I'm not programmed to handle this case;",
+        "I'll just pretend that you didn''t ask for it.",
+        "If you're in the wrong mode, you might be able to",
+        "return to the right one by typing `I}' or `I$' or `I\\par'."
+    );
     error();
 }
 
-@ Some operations are allowed only in privileged modes, i.e., in cases
-that |mode>0|. The |privileged| function is used to detect violations
-of this rule; it issues an error message and returns |false| if the
-current |mode| is negative.
+/*tex
+
+Some operations are allowed only in privileged modes, i.e., in cases that
+|mode>0|. The |privileged| function is used to detect violations of this rule; it
+issues an error message and returns |false| if the current |mode| is negative.
+
+*/
 
-@c
 boolean privileged(void)
 {
     if (mode > 0) {
@@ -1018,15 +1264,18 @@ boolean privileged(void)
     }
 }
 
-@ We don't want to leave |main_control| immediately when a |stop| command
-is sensed, because it may be necessary to invoke an \.{\\output} routine
-several times before things really grind to a halt. (The output routine
-might even say `\.{\\gdef\\end\{...\}}', to prolong the life of the job.)
-Therefore |its_all_over| is |true| only when the current page
-and contribution list are empty, and when the last output was not a
-``dead cycle.''
+/*tex
+
+We don't want to leave |main_control| immediately when a |stop| command is
+sensed, because it may be necessary to invoke an \.{\\output} routine several
+times before things really grind to a halt. (The output routine might even say
+`\.{\\gdef\\end\{...\}}', to prolong the life of the job.) Therefore
+|its_all_over| is |true| only when the current page and contribution list are
+empty, and when the last output was not a ``dead cycle.''
+
+*/
+
 
-@c
 boolean its_all_over(void)
 {                               /* do this when \.{\\end} or \.{\\dump} occurs */
     if (privileged()) {
@@ -1044,16 +1293,18 @@ boolean its_all_over(void)
     return false;
 }
 
+/*tex
+
+The |hskip| and |vskip| command codes are used for control sequences like
+\.{\\hss} and \.{\\vfil} as well as for \.{\\hskip} and \.{\\vskip}. The
+difference is in the value of |cur_chr|.
 
-@ The |hskip| and |vskip| command codes are used for control sequences
-like \.{\\hss} and \.{\\vfil} as well as for \.{\\hskip} and \.{\\vskip}.
-The difference is in the value of |cur_chr|.
+All the work relating to glue creation has been relegated to the following
+subroutine. It does not call |build_page|, because it is used in at least one
+place where that would be a mistake.
 
-All the work relating to glue creation has been relegated to the
-following subroutine. It does not call |build_page|, because it is
-used in at least one place where that would be a mistake.
+*/
 
-@c
 void append_glue(void)
 {
     int s = cur_chr;
@@ -1085,35 +1336,37 @@ void append_glue(void)
     }
 }
 
-@ @c
 void append_kern(void)
 {
-    int s;                      /* |subtype| of the kern node */
-    s = cur_chr;
+    int s = cur_chr; /* |subtype| of the kern node */
     scan_dimen((s == mu_glue), false, false);
     tail_append(new_kern(cur_val));
     subtype(tail) = (quarterword) s;
 }
 
-@ We have to deal with errors in which braces and such things are not
-properly nested. Sometimes the user makes an error of commission by
-inserting an extra symbol, but sometimes the user makes an error of omission.
-\TeX\ can't always tell one from the other, so it makes a guess and tries
-to avoid getting into a loop.
+/*tex
+
+We have to deal with errors in which braces and such things are not properly
+nested. Sometimes the user makes an error of commission by inserting an extra
+symbol, but sometimes the user makes an error of omission. \TeX\ can't always
+tell one from the other, so it makes a guess and tries to avoid getting into a
+loop.
 
 The |off_save| routine is called when the current group code is wrong. It tries
-to insert something into the user's input that will help clean off
-the top level.
+to insert something into the user's input that will help clean off the top level.
+
+*/
 
-@c
 void off_save(void)
 {
-    halfword p, q;              /* inserted token */
+    halfword p, q;
     if (cur_group == bottom_level) {
-        /* Drop current token and complain that it was unmatched */
+        /*tex Drop current token and complain that it was unmatched */
         print_err("Extra ");
         print_cmd_chr((quarterword) cur_cmd, cur_chr);
-        help1("Things are pretty mixed up, but I think the worst is over.");
+        help1(
+            "Things are pretty mixed up, but I think the worst is over."
+        );
         error();
 
     } else {
@@ -1121,8 +1374,11 @@ void off_save(void)
         p = get_avail();
         set_token_link(temp_token_head, p);
         print_err("Missing ");
-        /* Prepare to insert a token that matches |cur_group|, and print what it is */
-        /* At this point, |link(temp_token_head)=p|, a pointer to an empty one-word node. */
+        /*tex
+            Prepare to insert a token that matches |cur_group|, and print what it
+            is. At this point, |link(temp_token_head)=p|, a pointer to an empty
+            one-word node.
+        */
         switch (cur_group) {
             case semi_simple_group:
                 set_token_info(p, cs_token_flag + frozen_end_group);
@@ -1147,23 +1403,27 @@ void off_save(void)
         }
         tprint(" inserted");
         ins_list(token_link(temp_token_head));
-        help5("I've inserted something that you may have forgotten.",
-              "(See the <inserted text> above.)",
-              "With luck, this will get me unwedged. But if you",
-              "really didn't forget anything, try typing `2' now; then",
-              "my insertion and my current dilemma will both disappear.");
+        help5(
+            "I've inserted something that you may have forgotten.",
+            "(See the <inserted text> above.)",
+            "With luck, this will get me unwedged. But if you",
+            "really didn't forget anything, try typing `2' now; then",
+            "my insertion and my current dilemma will both disappear."
+        );
         error();
     }
 }
+/*tex
+
+The routine for a |right_brace| character branches into many subcases, since a
+variety of things may happen, depending on |cur_group|. Some types of groups are
+not supposed to be ended by a right brace; error messages are given in hopes of
+pinpointing the problem. Most branches of this routine will be filled in later,
+when we are ready to understand them; meanwhile, we must prepare ourselves to
+deal with such errors.
 
-@ The routine for a |right_brace| character branches into many subcases,
-since a variety of things may happen, depending on |cur_group|. Some
-types of groups are not supposed to be ended by a right brace; error
-messages are given in hopes of pinpointing the problem. Most branches
-of this routine will be filled in later, when we are ready to understand
-them; meanwhile, we must prepare ourselves to deal with such errors.
+*/
 
-@c
 void handle_right_brace(void)
 {
     halfword p, q;              /* for short-term use */
@@ -1176,8 +1436,10 @@ void handle_right_brace(void)
             break;
         case bottom_level:
             print_err("Too many }'s");
-            help2("You've closed more groups than you opened.",
-                  "Such booboos are generally harmless, so keep going.");
+            help2(
+                "You've closed more groups than you opened.",
+                "Such booboos are generally harmless, so keep going."
+            );
             error();
             break;
         case semi_simple_group:
@@ -1185,10 +1447,20 @@ void handle_right_brace(void)
         case math_left_group:
             extra_right_brace();
             break;
+        /*tex
+            When the right brace occurs at the end of an \.{\\hbox} or
+            \.{\\vbox} or \.{\\vtop} construction, the |package| routine
+            comes into action. We might also have to finish a paragraph that
+            hasn't ended.
+        */
         case hbox_group:
-            /* When the right brace occurs at the end of an \.{\\hbox} or \.{\\vbox} or
-               \.{\\vtop} construction, the |package| routine comes into action. We might
-               also have to finish a paragraph that hasn't ended. */
+            if (fixup_boxes_par) {
+                /*tex
+                    This is unofficial! Fixing up (also elsewhere) might become default
+                    some day but for a while I will test this in ConTeXt.
+                */
+                fixup_directions_only();
+            }
             package(0);
             break;
         case adjusted_hbox_group:
@@ -1211,7 +1483,9 @@ void handle_right_brace(void)
             f = floating_penalty_par;
             unsave();
             save_ptr--;
-            /* now |saved_value(0)| is the insertion number, or the |vadjust| subtype */
+            /*tex
+                Now |saved_value(0)| is the insertion number, or the |vadjust| subtype.
+            */
             p = vpack(vlink(head), 0, additional, -1);
             pop_nest();
             if (saved_type(0) == saved_insert) {
@@ -1236,9 +1510,11 @@ void handle_right_brace(void)
             }
             break;
         case output_group:
-            /* this is needed in case the \.{\\output} executes a \.{\\textdir} command. */
+            /*tex
+                this is needed in case the \.{\\output} executes a \.{\\textdir} command.
+            */
             if (dir_level(text_dir_ptr) == cur_level) {
-                /* DIR: Remove from |text_dir_ptr| */
+                /*tex Remove from |text_dir_ptr| */
                 halfword text_dir_tmp = vlink(text_dir_ptr);
                 flush_node(text_dir_ptr);
                 text_dir_ptr = text_dir_tmp;
@@ -1255,7 +1531,9 @@ void handle_right_brace(void)
             back_input();
             cur_tok = cs_token_flag + frozen_cr;
             print_err("Missing \\cr inserted");
-            help1("I'm guessing that you meant to end an alignment here.");
+            help1(
+                "I'm guessing that you meant to end an alignment here."
+            );
             ins_error();
             break;
         case no_align_group:
@@ -1279,7 +1557,6 @@ void handle_right_brace(void)
     }
 }
 
-@ @c
 void extra_right_brace(void)
 {
     print_err("Extra }, or forgotten ");
@@ -1294,19 +1571,24 @@ void extra_right_brace(void)
             tprint_esc("right");
             break;
     }
-    help5("I've deleted a group-closing symbol because it seems to be",
-          "spurious, as in `$x}$'. But perhaps the } is legitimate and",
-          "you forgot something else, as in `\\hbox{$x}'. In such cases",
-          "the way to recover is to insert both the forgotten and the",
-          "deleted material, e.g., by typing `I$}'.");
+    help5(
+        "I've deleted a group-closing symbol because it seems to be",
+        "spurious, as in `$x}$'. But perhaps the } is legitimate and",
+        "you forgot something else, as in `\\hbox{$x}'. In such cases",
+        "the way to recover is to insert both the forgotten and the",
+        "deleted material, e.g., by typing `I$}'."
+    );
     error();
     incr(align_state);
 }
 
-@ Here is where we clear the parameters that are supposed to revert to their
+/*tex
+
+Here is where we clear the parameters that are supposed to revert to their
 default values after every paragraph and when internal vertical mode is entered.
 
-@c
+*/
+
 void normal_paragraph(void)
 {
     if (looseness_par != 0)
@@ -1323,27 +1605,35 @@ void normal_paragraph(void)
         eq_word_define(dimen_base + shape_mode_code, 0);
 }
 
-@ The global variable |cur_box| will point to a newly-made box. If the box
-is void, we will have |cur_box=null|. Otherwise we will have
-|type(cur_box)=hlist_node| or |vlist_node| or |rule_node|; the |rule_node|
-case can occur only with leaders.
+/*tex
+
+The global variable |cur_box| will point to a newly-made box. If the box is void,
+we will have |cur_box=null|. Otherwise we will have |type(cur_box)=hlist_node| or
+|vlist_node| or |rule_node|; the |rule_node| case can occur only with leaders.
+
+*/
 
-@c
 halfword cur_box;               /* box to be placed into its context */
 
-@ The |box_end| procedure does the right thing with |cur_box|, if
-|box_context| represents the context as explained above.
+/*tex
+
+The |box_end| procedure does the right thing with |cur_box|, if |box_context|
+represents the context as explained above.
+
+*/
 
-@c
 void box_end(int box_context)
 {
     if (box_context < box_flag) {
-        /* Append box |cur_box| to the current list, shifted by |box_context| */
-        /*
-           The global variable |adjust_tail| will be non-null if and only if the
-           current box might include adjustments that should be appended to the
-           current vertical list.
-         */
+        /*tex
+
+            Append box |cur_box| to the current list, shifted by |box_context|.
+            The global variable |adjust_tail| will be non-null if and only if the
+            current box might include adjustments that should be appended to the
+            current vertical list.
+
+        */
+
         if (cur_box != null) {
             shift_amount(cur_box) = box_context;
             if (abs(mode) == vmode) {
@@ -1372,15 +1662,28 @@ void box_end(int box_context)
             }
         }
     } else if (box_context < ship_out_flag) {
-        /* Store |cur_box| in a box register */
+        /*tex
+            Store |cur_box| in a box register
+        */
         if (box_context < global_box_flag)
             eq_define(box_base + box_context - box_flag, box_ref_cmd, cur_box);
         else
             geq_define(box_base + box_context - global_box_flag, box_ref_cmd, cur_box);
+    } else if (box_context == lua_scan_flag) {
+        /*tex
+            We are done with scanning so let's return to the caller.
+        */
+        wrapup_local_scan_box();
     } else if (cur_box != null) {
-        if (box_context > ship_out_flag) {
-            /* Append a new leader node that uses |cur_box| */
-            /* Get the next non-blank non-relax... */
+        /*tex
+            The leaders contexts come after shipout and luascan contexts.
+        */
+        /* if (box_context > lua_scan_flag) { */
+        if (box_context >= leader_flag) {
+            /*tex
+                Append a new leader node that uses |cur_box| and get the next
+                non-blank non-relax...
+            */
             do {
                 get_x_token();
             } while ((cur_cmd == spacer_cmd) || (cur_cmd == relax_cmd));
@@ -1391,25 +1694,32 @@ void box_end(int box_context)
                 leader_ptr(tail) = cur_box;
             } else {
                 print_err("Leaders not followed by proper glue");
-                help3
-                    ("You should say `\\leaders <box or rule><hskip or vskip>'.",
-                     "I found the <box or rule>, but there's no suitable",
-                     "<hskip or vskip>, so I'm ignoring these leaders.");
+                help3(
+                    "You should say `\\leaders <box or rule><hskip or vskip>'.",
+                    "I found the <box or rule>, but there's no suitable",
+                    "<hskip or vskip>, so I'm ignoring these leaders."
+                );
                 back_error();
                 flush_node_list(cur_box);
             }
         } else {
+            if (box_context != ship_out_flag) {
+                normal_error("scanner","shipout expected");
+            }
             ship_out(static_pdf, cur_box, SHIPPING_PAGE);
         }
     }
 }
 
-@ the next input should specify a box or perhaps a rule
+/*tex
+
+the next input should specify a box or perhaps a rule
+
+*/
 
-@c
 void scan_box(int box_context)
 {
-    /* Get the next non-blank non-relax... */
+    /*tex Get the next non-blank non-relax... */
     do {
         get_x_token();
     } while ((cur_cmd == spacer_cmd) || (cur_cmd == relax_cmd));
@@ -1422,26 +1732,36 @@ void scan_box(int box_context)
         box_end(box_context);
     } else {
         print_err("A <box> was supposed to be here");
-        help3("I was expecting to see \\hbox or \\vbox or \\copy or \\box or",
-              "something like that. So you might find something missing in",
-              "your output. But keep trying; you can fix this later.");
+        help3(
+            "I was expecting to see \\hbox or \\vbox or \\copy or \\box or",
+            "something like that. So you might find something missing in",
+            "your output. But keep trying; you can fix this later."
+        );
         back_error();
+        if (box_context == lua_scan_flag) {
+            cur_box = null;
+            box_end(box_context);
+        }
     }
 }
 
-@ @c
 void new_graf(boolean indented)
 {
     halfword p, q, dir_graf_tmp;
     halfword dir_rover;
-    prev_graf_par = 0;
+    int callback_id;
     if ((mode == vmode) || (head != tail)) {
         tail_append(new_param_glue(par_skip_code));
     }
+    callback_id = callback_defined(new_graf_callback);
+    if (callback_id > 0) {
+        run_callback(callback_id, "db->b", cur_list.mode_field,indented,&indented);
+    }
+    prev_graf_par = 0;
     push_nest();
     mode = hmode;
     space_factor_par = 1000;
-    /* LOCAL: Add local paragraph node */
+    /*tex  Add local paragraph node */
     tail_append(make_local_par_node(new_graf_par_code));
     if (indented) {
         p = new_null_box();
@@ -1470,15 +1790,16 @@ void new_graf(boolean indented)
         begin_token_list(every_par_par, every_par_text);
     if (nest_ptr == 1) {
         checked_page_filter(new_graf);
-        build_page();           /* put |par_skip| glue on current page */
+        /*tex put |par_skip| glue on current page */
+        build_page();
     }
 }
 
-@ @c
 void indent_in_hmode(void)
 {
     halfword p;
-    if (cur_chr > 0) {          /* \.{\\indent} */
+    if (cur_chr > 0) {
+        /*tex \.{\\indent} */
         p = new_null_box();
         width(p) = par_indent_par;
         if (abs(mode) == hmode)
@@ -1489,7 +1810,6 @@ void indent_in_hmode(void)
     }
 }
 
-@ @c
 void head_for_vmode(void)
 {
     if (mode < 0) {
@@ -1497,8 +1817,10 @@ void head_for_vmode(void)
             off_save();
         } else {
             print_err("You can't use `\\hrule' here except with leaders");
-            help2("To put a horizontal rule in an hbox or an alignment,",
-                  "you should use \\leaders or \\hrulefill (see The TeXbook).");
+            help2(
+                "To put a horizontal rule in an hbox or an alignment,",
+                "you should use \\leaders or \\hrulefill (see The TeXbook)."
+            );
             error();
         }
     } else {
@@ -1509,19 +1831,23 @@ void head_for_vmode(void)
     }
 }
 
-@ TODO (BUG?): |dir_save| would have been set by |line_break| by means
-of |post_line_break|, but this is not done right now, as it introduces
-pretty heavy memory leaks. This means the current code is probably
-wrong in some way that relates to in-paragraph displays.
+/*tex
+
+|dir_save| would have been set by |line_break| by means of |post_line_break|, but
+this is not done right now, as it introduces pretty heavy memory leaks. This
+means the current code might be wrong in some way that relates to in-paragraph
+displays.
+
+*/
 
-@c
 void end_graf(int line_break_context)
 {
     if (mode == hmode) {
         if ((head == tail) || (vlink(head) == tail)) {
             if (vlink(head) == tail)
                 flush_node(vlink(head));
-            pop_nest();         /* null paragraphs are ignored, all contain a |local_paragraph| node */
+            /*tex |null| paragraphs are ignored, all contain a |local_paragraph| node */
+            pop_nest();
         } else {
             line_break(false, line_break_context);
         }
@@ -1534,7 +1860,6 @@ void end_graf(int line_break_context)
     }
 }
 
-@ @c
 void begin_insert_or_adjust(void)
 {
     if (cur_cmd != vadjust_cmd) {
@@ -1542,7 +1867,9 @@ void begin_insert_or_adjust(void)
         if (cur_val == output_box_par) {
             print_err("You can't \\insert");
             print_int(output_box_par);
-            help1("I'm changing to \\insert0; box \\outputbox is special.");
+            help1(
+                "I'm changing to \\insert0; box \\outputbox is special."
+            );
             error();
             cur_val = 0;
         }
@@ -1561,12 +1888,14 @@ void begin_insert_or_adjust(void)
     prev_depth_par = ignore_depth;
 }
 
-@ I (TH)'ve renamed the |make_mark| procedure to this, because if the
-current chr code is 1, then the actual command was \.{\\clearmarks},
-which does not generate a mark node but instead destroys the current
-mark tokenlists.
+/*tex
+
+I (TH)'ve renamed the |make_mark| procedure to this, because if the current chr
+code is 1, then the actual command was \.{\\clearmarks}, which does not generate
+a mark node but instead destroys the current mark tokenlists.
+
+*/
 
-@c
 void handle_mark(void)
 {
     halfword p;                 /* new node */
@@ -1597,7 +1926,6 @@ void handle_mark(void)
     }
 }
 
-@ @c
 void append_penalty(void)
 {
     scan_int();
@@ -1608,29 +1936,34 @@ void append_penalty(void)
     }
 }
 
-@ When |delete_last| is called, |cur_chr| is the |type| of node that
-will be deleted, if present.
+/*tex
+
+When |delete_last| is called, |cur_chr| is the |type| of node that will be
+deleted, if present.
 
-The |remove_item| command removes a penalty, kern, or glue node if it
-appears at the tail of the current list, using a brute-force linear scan.
-Like \.{\\lastbox}, this command is not allowed in vertical mode (except
-internal vertical mode), since the current list in vertical mode is sent
-to the page builder.  But if we happen to be able to implement it in
-vertical mode, we do.
+The |remove_item| command removes a penalty, kern, or glue node if it appears at
+the tail of the current list, using a brute-force linear scan. Like
+\.{\\lastbox}, this command is not allowed in vertical mode (except internal
+vertical mode), since the current list in vertical mode is sent to the page
+builder. But if we happen to be able to implement it in vertical mode, we do.
+
+*/
 
-@c
 void delete_last(void)
 {
     halfword p, q;              /* run through the current list */
     if ((mode == vmode) && (tail == head)) {
-        /* Apologize for inability to do the operation now,
-           unless \.{\\unskip} follows non-glue */
+        /*tex
+            Apologize for inability to do the operation now, unless \.{\\unskip}
+            follows non-glue
+        */
         if ((cur_chr != glue_node) || (last_glue != max_halfword)) {
             you_cant();
             if (cur_chr == kern_node) {
-                help2
-                    ("Sorry...I usually can't take things from the current page.",
-                     "Try `I\\kern-\\lastkern' instead.");
+                help2(
+                    "Sorry...I usually can't take things from the current page.",
+                    "Try `I\\kern-\\lastkern' instead."
+                );
             } else if (cur_chr != glue_node) {
                 help2
                     ("Sorry...I usually can't take things from the current page.",
@@ -1643,7 +1976,7 @@ void delete_last(void)
             error();
         }
     } else {
-        /* todo: clean this up */
+        /*tex Todo: clean this up! */
         if (!is_char_node(tail)) {
             if (type(tail) == cur_chr) {
                 q = head;
@@ -1665,7 +1998,6 @@ void delete_last(void)
     }
 }
 
-@ @c
 void unpackage(void)
 {
     halfword p;                 /* the box */
@@ -1673,7 +2005,7 @@ void unpackage(void)
     int c;                      /* should we copy? */
     halfword s;                 /* for varmem assignment */
     if (cur_chr > copy_code) {
-        /* Handle saved items and |goto done| */
+        /*tex Handle saved items and |goto done| */
         try_couple_nodes(tail, disc_ptr[cur_chr]);
         disc_ptr[cur_chr] = null;
         goto DONE;
@@ -1687,9 +2019,11 @@ void unpackage(void)
         || ((abs(mode) == vmode) && (type(p) != vlist_node))
         || ((abs(mode) == hmode) && (type(p) != hlist_node))) {
         print_err("Incompatible list can't be unboxed");
-        help3("Sorry, Pandora. (You sneaky devil.)",
-              "I refuse to unbox an \\hbox in vertical mode or vice versa.",
-              "And I can't open any boxes in math mode.");
+        help3(
+            "Sorry, Pandora. (You sneaky devil.)",
+            "I refuse to unbox an \\hbox in vertical mode or vice versa.",
+            "And I can't open any boxes in math mode."
+        );
         error();
         return;
     }
@@ -1713,12 +2047,14 @@ void unpackage(void)
     }
 }
 
-@
+/*tex
+
 Italic corrections are converted to kern nodes when the |ital_corr| command
-follows a character. In math mode the same effect is achieved by appending
-a kern of zero here, since italic corrections are supplied later.
+follows a character. In math mode the same effect is achieved by appending a kern
+of zero here, since italic corrections are supplied later.
+
+*/
 
-@c
 void append_italic_correction(void)
 {
     halfword p;                 /* |char_node| at the tail of the current list */
@@ -1734,7 +2070,6 @@ void append_italic_correction(void)
     }
 }
 
-@ @c
 void append_local_box(int kind)
 {
     incr(save_ptr);
@@ -1746,20 +2081,23 @@ void append_local_box(int kind)
     space_factor_par = 1000;
 }
 
-@ Discretionary nodes are easy in the common case `\.{\\-}', but in the
-general case we must process three braces full of items.
+/*tex
+
+Discretionary nodes are easy in the common case `\.{\\-}', but in the general
+case we must process three braces full of items.
+
+The space factor does not change when we append a discretionary node, but it
+starts out as 1000 in the subsidiary lists.
 
-The space factor does not change when we append a discretionary node,
-but it starts out as 1000 in the subsidiary lists.
+*/
 
-@c
 void append_discretionary(void)
 {
     int c;
     tail_append(new_disc());
     subtype(tail) = (quarterword) cur_chr;
     if (cur_chr == explicit_disc) {
-        /* \- */
+        /* |\-| */
         c = get_pre_hyphen_char(cur_lang_par);
         if (c > 0) {
             vlink(pre_break(tail)) = new_char(equiv(cur_font_loc), c);
@@ -1774,7 +2112,7 @@ void append_discretionary(void)
         }
         set_explicit_disc_penalty(tail);
     } else if (cur_chr == automatic_disc) {
-        /* - as done in hyphenator */
+        /*tex As done in hyphenator: */
         c = get_pre_exhyphen_char(cur_lang_par);
         if (c <= 0) {
             c = ex_hyphen_char_par;
@@ -1798,7 +2136,7 @@ void append_discretionary(void)
         }
         set_automatic_disc_penalty(tail);
     } else {
-        /* \discretionary */
+        /*tex |\discretionary| */
         if (scan_keyword("penalty")) {
             scan_int();
             disc_penalty(tail) = cur_val;
@@ -1810,14 +2148,17 @@ void append_discretionary(void)
         push_nest();
         mode = -hmode;
         space_factor_par = 1000;
-        /* already preset: disc_penalty(tail) = hyphen_penalty_par; */
+        /*tex Already preset: |disc_penalty(tail) = hyphen_penalty_par;| */
     }
 }
 
-@ The test for |p != null| ensures that empty \.{\\localleftbox} and
-    \.{\\localrightbox} commands are not applied.
+/*tex
+
+The test for |p != null| ensures that empty \.{\\localleftbox} and
+\.{\\localrightbox} commands are not applied.
+
+*/
 
-@c
 void build_local_box(void)
 {
     halfword p;
@@ -1828,41 +2169,51 @@ void build_local_box(void)
     decr(save_ptr);
     p = vlink(head);
     pop_nest();
-    if (p != null)
-        p = hpack(p, 0, additional, -1);
+    if (p != null) {
+        /*tex Somehow |filtered_hpack| goes beyond the first node so we loose it. */
+        new_hyphenation(p, null);
+        (void) new_ligkern(p, null);
+        p = lua_hpack_filter(p, 0, additional, local_box_group, -1, null);
+    }
     if (kind == 0)
         eq_define(local_left_box_base, box_ref_cmd, p);
     else
         eq_define(local_right_box_base, box_ref_cmd, p);
     if (abs(mode) == hmode) {
-        /* LOCAL: Add local paragraph node */
+        /*tex Add local paragraph node */
         tail_append(make_local_par_node(local_box_par_code));
     }
     eq_word_define(int_base + no_local_whatsits_code, no_local_whatsits_par + 1);
 }
 
-@ The three discretionary lists are constructed somewhat as if they were
-hboxes. A~subroutine called |build_discretionary| handles the transitions.
-(This is sort of fun.)
+/*tex
+
+The three discretionary lists are constructed somewhat as if they were hboxes.
+A~subroutine called |build_discretionary| handles the transitions. (This is sort
+of fun.)
+
+*/
 
-@c
 void build_discretionary(void)
 {
     halfword p, q;              /* for link manipulation */
     int n;                      /* length of discretionary list */
     unsave();
-    /* Prune the current list, if necessary, until it contains only
-       |char_node|, |kern_node|, |hlist_node|, |vlist_node| and
-       |rule_node| items; set |n| to the length of the list,
-       and set |q| to the lists tail */
-    /* During this loop, |p=vlink(q)| and there are |n| items preceding |p|. */
+    /*tex
+        Prune the current list, if necessary, until it contains only |char_node|,
+        |kern_node|, |hlist_node|, |vlist_node| and |rule_node| items; set |n| to
+        the length of the list, and set |q| to the lists tail. During this loop,
+        |p=vlink(q)| and there are |n| items preceding |p|.
+    */
     q = head;
     p = vlink(q);
     n = 0;
     while (p != null) {
         if (!is_char_node(p) && type(p) > rule_node && type(p) != kern_node) {
             print_err("Improper discretionary list");
-            help1("Discretionary lists must contain only boxes and kerns.");
+            help1(
+                "Discretionary lists must contain only boxes and kerns."
+            );
             error();
             begin_diagnostic();
             tprint_nl("The following discretionary sublist has been deleted:");
@@ -1897,12 +2248,16 @@ void build_discretionary(void)
         }
         break;
     case 2:
-        /* Attach list |p| to the current list, and record its length;
-           then finish up and |return| */
+        /*tex
+            Attach list |p| to the current list, and record its length; then
+            finish up and |return|
+        */
         if ((n > 0) && (abs(mode) == mmode)) {
             print_err("Illegal math \\discretionary");
-            help2("Sorry: The third part of a discretionary break must be",
-                  "empty, in math formulas. I had to delete your third part.");
+            help2(
+                "Sorry: The third part of a discretionary break must be",
+                "empty, in math formulas. I had to delete your third part."
+            );
             flush_node_list(p);
             error();
         } else {
@@ -1913,9 +2268,10 @@ void build_discretionary(void)
             }
         }
         decr(save_ptr);
+        /*tex There are no other cases. */
         return;
         break;
-    }                           /* there are no other cases */
+    }
     set_saved_record(-1, saved_disc, 0, (saved_value(-1) + 1));
     new_save_level(disc_group);
     scan_left_brace();
@@ -1924,15 +2280,18 @@ void build_discretionary(void)
     space_factor_par = 1000;
 }
 
-@ The positioning of accents is straightforward but tedious. Given an accent
-of width |a|, designed for characters of height |x| and slant |s|;
-and given a character of width |w|, height |h|, and slant |t|: We will shift
-the accent down by |x-h|, and we will insert kern nodes that have the effect of
-centering the accent over the character and shifting the accent to the
-right by $\delta={1\over2}(w-a)+h\cdot t-x\cdot s$.  If either character is
-absent from the font, we will simply use the other, without shifting.
+/*tex
+
+The positioning of accents is straightforward but tedious. Given an accent of
+width |a|, designed for characters of height |x| and slant |s|; and given a
+character of width |w|, height |h|, and slant |t|: We will shift the accent down
+by |x-h|, and we will insert kern nodes that have the effect of centering the
+accent over the character and shifting the accent to the right by
+$\delta={1\over2}(w-a)+h\cdot t-x\cdot s$. If either character is absent from the
+font, we will simply use the other, without shifting.
+
+*/
 
-@c
 void make_accent(void)
 {
     double s, t;                /* amount of slant */
@@ -1944,11 +2303,14 @@ void make_accent(void)
     p = new_glyph(f, cur_val);
     if (p != null) {
         x = x_height(f);
-        s = float_cast(slant(f)) / float_constant(65536);       /* real division */
+        /*tex real division */
+        s = float_cast(slant(f)) / float_constant(65536);
         a = glyph_width(p);
         do_assignments();
-        /* Create a character node |q| for the next character,
-           but set |q:=null| if problems arise */
+        /*tex
+            Create a character node |q| for the next character, but set |q:=null|
+            if problems arise
+        */
         q = null;
         f = equiv(cur_font_loc);
         if ((cur_cmd == letter_cmd) ||
@@ -1962,22 +2324,26 @@ void make_accent(void)
         }
 
         if (q != null) {
-            /* Append the accent with appropriate kerns, then set |p:=q| */
-            /* The kern nodes appended here must be distinguished from other kerns, lest
-               they be wiped away by the hyphenation algorithm or by a previous line break.
-
-               The two kerns are computed with (machine-dependent) |real| arithmetic, but
-               their sum is machine-independent; the net effect is machine-independent,
-               because the user cannot remove these nodes nor access them via \.{\\lastkern}.
+            /*tex
+                Append the accent with appropriate kerns, then set |p:=q|. The
+                kern nodes appended here must be distinguished from other kerns,
+                lest they be wiped away by the hyphenation algorithm or by a
+                previous line break. The two kerns are computed with
+                (machine-dependent) |real| arithmetic, but their sum is
+                machine-independent; the net effect is machine-independent,
+                because the user cannot remove these nodes nor access them via
+                \.{\\lastkern}.
              */
             t = float_cast(slant(f)) / float_constant(65536);   /* real division */
             w = glyph_width(q);
             h = glyph_height(q);
-            if (h != x) {       /* the accent must be shifted up or down */
+            if (h != x) {
+                /*tex the accent must be shifted up or down */
                 p = hpack(p, 0, additional, -1);
                 shift_amount(p) = x - h;
             }
-            delta = round(float_cast(w - a) / float_constant(2) + h * t - x * s);       /* real multiplication */
+            /*tex real multiplication */
+            delta = round(float_cast(w - a) / float_constant(2) + h * t - x * s);
             r = new_kern(delta);
             subtype(r) = accent_kern;
             couple_nodes(tail, r);
@@ -1994,34 +2360,43 @@ void make_accent(void)
     }
 }
 
-@ When `\.{\\cr}' or `\.{\\span}' or a tab mark comes through the scanner
-into |main_control|, it might be that the user has foolishly inserted
-one of them into something that has nothing to do with alignment. But it is
-far more likely that a left brace or right brace has been omitted, since
-|get_next| takes actions appropriate to alignment only when `\.{\\cr}'
-or `\.{\\span}' or tab marks occur with |align_state=0|. The following
-program attempts to make an appropriate recovery.
+/*tex
+
+When `\.{\\cr}' or `\.{\\span}' or a tab mark comes through the scanner into
+|main_control|, it might be that the user has foolishly inserted one of them into
+something that has nothing to do with alignment. But it is far more likely that a
+left brace or right brace has been omitted, since |get_next| takes actions
+appropriate to alignment only when `\.{\\cr}' or `\.{\\span}' or tab marks occur
+with |align_state=0|. The following program attempts to make an appropriate
+recovery.
+
+*/
 
-@c
 void align_error(void)
 {
     if (abs(align_state) > 2) {
-        /* Express consternation over the fact that no alignment is in progress */
+        /*tex
+            Express consternation over the fact that no alignment is in progress.
+        */
         print_err("Misplaced ");
         print_cmd_chr((quarterword) cur_cmd, cur_chr);
         if (cur_tok == tab_token + '&') {
-            help6("I can't figure out why you would want to use a tab mark",
-                  "here. If you just want an ampersand, the remedy is",
-                  "simple: Just type `I\\&' now. But if some right brace",
-                  "up above has ended a previous alignment prematurely,",
-                  "you're probably due for more error messages, and you",
-                  "might try typing `S' now just to see what is salvageable.");
+            help6(
+                "I can't figure out why you would want to use a tab mark",
+                "here. If you just want an ampersand, the remedy is",
+                "simple: Just type `I\\&' now. But if some right brace",
+                "up above has ended a previous alignment prematurely,",
+                "you're probably due for more error messages, and you",
+                "might try typing `S' now just to see what is salvageable."
+            );
         } else {
-            help5("I can't figure out why you would want to use a tab mark",
-                  "or \\cr or \\span just now. If something like a right brace",
-                  "up above has ended a previous alignment prematurely,",
-                  "you're probably due for more error messages, and you",
-                  "might try typing `S' now just to see what is salvageable.");
+            help5(
+                "I can't figure out why you would want to use a tab mark",
+                "or \\cr or \\span just now. If something like a right brace",
+                "up above has ended a previous alignment prematurely,",
+                "you're probably due for more error messages, and you",
+                "might try typing `S' now just to see what is salvageable."
+            );
         }
         error();
 
@@ -2036,43 +2411,55 @@ void align_error(void)
             decr(align_state);
             cur_tok = right_brace_token + '}';
         }
-        help3("I've put in what seems to be necessary to fix",
-              "the current column of the current alignment.",
-              "Try to go on, since this might almost work.");
+        help3(
+            "I've put in what seems to be necessary to fix",
+            "the current column of the current alignment.",
+            "Try to go on, since this might almost work."
+        );
         ins_error();
     }
 }
 
-@ The help messages here contain a little white lie, since \.{\\noalign}
-and \.{\\omit} are allowed also after `\.{\\noalign\{...\}}'.
+/*tex
+
+The help messages here contain a little white lie, since \.{\\noalign} and
+\.{\\omit} are allowed also after `\.{\\noalign\{...\}}'.
+
+*/
 
-@c
 void no_align_error(void)
 {
     print_err("Misplaced \\noalign");
-    help2("I expect to see \\noalign only after the \\cr of",
-          "an alignment. Proceed, and I'll ignore this case.");
+    help2(
+        "I expect to see \\noalign only after the \\cr of",
+        "an alignment. Proceed, and I'll ignore this case."
+    );
     error();
 }
 
 void omit_error(void)
 {
     print_err("Misplaced \\omit");
-    help2("I expect to see \\omit only after tab marks or the \\cr of",
-          "an alignment. Proceed, and I'll ignore this case.");
+    help2(
+        "I expect to see \\omit only after tab marks or the \\cr of",
+        "an alignment. Proceed, and I'll ignore this case."
+    );
     error();
 }
 
-@ We've now covered most of the abuses of \.{\\halign} and \.{\\valign}.
-Let's take a look at what happens when they are used correctly.
+/*tex
+
+We've now covered most of the abuses of \.{\\halign} and \.{\\valign}. Let's take
+a look at what happens when they are used correctly.
 
-An |align_group| code is supposed to remain on the |save_stack|
-during an entire alignment, until |fin_align| removes it.
+An |align_group| code is supposed to remain on the |save_stack| during an entire
+alignment, until |fin_align| removes it.
 
-A devious user might force an |endv| command to occur just about anywhere;
-we must defeat such hacks.
+A devious user might force an |endv| command to occur just about anywhere; we
+must defeat such hacks.
+
+*/
 
-@c
 void do_endv(void)
 {
     base_ptr = input_ptr;
@@ -2085,7 +2472,7 @@ void do_endv(void)
         (input_stack[base_ptr].loc_field != null) ||
         (input_stack[base_ptr].state_field != token_list))
         fatal_error("(interwoven alignment preambles are not allowed)");
-    /*.interwoven alignment preambles... */
+    /*tex interwoven alignment preambles... */
     if (cur_group == align_group) {
         end_graf(align_group);
         if (fin_col())
@@ -2095,55 +2482,62 @@ void do_endv(void)
     }
 }
 
-@ Finally, \.{\\endcsname} is not supposed to get through to |main_control|.
+/*tex
+
+Finally, \.{\\endcsname} is not supposed to get through to |main_control|.
+
+*/
 
-@c
 void cs_error(void)
 {
     print_err("Extra \\endcsname");
-    help1("I'm ignoring this, since I wasn't doing a \\csname.");
+    help1(
+        "I'm ignoring this, since I wasn't doing a \\csname."
+    );
     error();
 }
 
-@
-  Assignments to values in |eqtb| can be global or local. Furthermore, a
-  control sequence can be defined to be `\.{\\long}', `\.{\\protected}',
-  or `\.{\\outer}', and it might or might not be expanded. The prefixes
-  `\.{\\global}', `\.{\\long}', `\.{\\protected}',
-  and `\.{\\outer}' can occur in any order. Therefore we assign binary numeric
-  codes, making it possible to accumulate the union of all specified prefixes
-  by adding the corresponding codes.  (PASCAL's |set| operations could also
-  have been used.)
+/*tex
+
+Assignments to values in |eqtb| can be global or local. Furthermore, a control
+sequence can be defined to be `\.{\\long}', `\.{\\protected}', or `\.{\\outer}',
+and it might or might not be expanded. The prefixes `\.{\\global}', `\.{\\long}',
+`\.{\\protected}', and `\.{\\outer}' can occur in any order. Therefore we assign
+binary numeric codes, making it possible to accumulate the union of all specified
+prefixes by adding the corresponding codes. (PASCAL's |set| operations could also
+have been used.)
 
-  Every prefix, and every command code that might or might not be prefixed,
-  calls the action procedure |prefixed_command|. This routine accumulates
-  a sequence of prefixes until coming to a non-prefix, then it carries out
-  the command.
+Every prefix, and every command code that might or might not be prefixed, calls
+the action procedure |prefixed_command|. This routine accumulates a sequence of
+prefixes until coming to a non-prefix, then it carries out the command.
 
-@ If the user says, e.g., `\.{\\global\\global}', the redundancy is
-silently accepted.
+*/
 
+/*tex
 
-@ The different types of code values have different legal ranges; the
+If the user says, e.g., `\.{\\global\\global}', the redundancy is silently
+accepted. The different types of code values have different legal ranges; the
 following program is careful to check each case properly.
 
-@c
-#define check_def_code(A) do {						\
-	if (((cur_val<0)&&(p<(A)))||(cur_val>n)) {			\
-	    print_err("Invalid code (");				\
-	    print_int(cur_val);						\
-	    if (p<(A))							\
-		tprint("), should be in the range 0..");		\
-	    else							\
-		tprint("), should be at most ");			\
-	    print_int(n);						\
-	    help1("I'm going to use 0 instead of that illegal code value."); \
-	    error();							\
-	    cur_val=0;							\
-	}								\
+*/
+
+#define check_def_code(A) do { \
+    if (((cur_val<0)&&(p<(A)))||(cur_val>n)) { \
+        print_err("Invalid code ("); \
+        print_int(cur_val); \
+        if (p<(A)) \
+            tprint("), should be in the range 0.."); \
+        else \
+            tprint("), should be at most "); \
+        print_int(n); \
+        help1( \
+            "I'm going to use 0 instead of that illegal code value." \
+        ); \
+        error(); \
+        cur_val=0; \
+    } \
 } while (0)
 
-@ @c
 /*
 halfword swap_hang_indent(halfword indentation, halfword shape_mode) {
     if (shape_mode == 1 || shape_mode == 3 || shape_mode == -1 || shape_mode == -3) {
@@ -2176,40 +2570,51 @@ void prefixed_command(void)
     while (cur_cmd == prefix_cmd) {
         if (!odd(a / cur_chr))
             a = a + cur_chr;
-        /* Get the next non-blank non-relax... */
+        /*tex
+            Get the next non-blank non-relax...
+        */
         do {
             get_x_token();
         } while ((cur_cmd == spacer_cmd) || (cur_cmd == relax_cmd));
 
         if (cur_cmd <= max_non_prefixed_command) {
-            /* Discard erroneous prefixes and |return| */
+            /*tex
+                Discard erroneous prefixes and |return|
+            */
             print_err("You can't use a prefix with `");
             print_cmd_chr((quarterword) cur_cmd, cur_chr);
             print_char('\'');
-            help2
-                ("I'll pretend you didn't say \\long or \\outer or \\global or",
-                 "\\protected.");
+            help2(
+                "I'll pretend you didn't say \\long or \\outer or \\global or",
+                "\\protected."
+            );
             back_error();
             return;
         }
         if (tracing_commands_par > 2)
             show_cur_cmd_chr();
     }
-    /* Discard the prefixes \.{\\long} and \.{\\outer} if they are irrelevant */
+    /*tex
+        Discard the prefixes \.{\\long} and \.{\\outer} if they are irrelevant
+    */
     if (a >= 8) {
         j = protected_token;
         a = a - 8;
     } else {
         j = 0;
     }
-    if ((cur_cmd != def_cmd) && ((a % 4 != 0) || (j != 0))) {
+    if ((cur_cmd != def_cmd) && (cur_cmd != def_lua_call_cmd) && ((a % 4 != 0) || (j != 0))) {
         print_err("You can't use `\\long' or `\\outer' or `\\protected' with `");
         print_cmd_chr((quarterword) cur_cmd, cur_chr);
         print_char('\'');
-        help1("I'll pretend you didn't say \\long or \\outer or \\protected here.");
+        help1(
+            "I'll pretend you didn't say \\long or \\outer or \\protected here."
+        );
         error();
     }
-    /* Adjust for the setting of \.{\\globaldefs} */
+    /*tex
+        Adjust for the setting of \.{\\globaldefs}
+    */
     if (global_defs_par != 0) {
         if (global_defs_par < 0) {
             if (is_global(a))
@@ -2221,15 +2626,18 @@ void prefixed_command(void)
     }
     switch (cur_cmd) {
         case set_font_cmd:
-            /* Here's an example of the way many of the following routines operate.
-               (Unfortunately, they aren't all as simple as this.) */
+            /*tex
+                Here's an example of the way many of the following routines operate.
+                (Unfortunately, they aren't all as simple as this.)
+            */
             define(cur_font_loc, data_cmd, cur_chr);
             break;
         case def_cmd:
-            /* When a |def| command has been scanned,
-               |cur_chr| is odd if the definition is supposed to be global, and
-               |cur_chr>=2| if the definition is supposed to be expanded. */
-
+            /*tex
+                When a |def| command has been scanned, |cur_chr| is odd if the
+                definition is supposed to be global, and |cur_chr>=2| if the
+                definition is supposed to be expanded.
+            */
             if (odd(cur_chr) && !is_global(a) && (global_defs_par >= 0))
                 a = a + 4;
             e = (cur_chr >= 2);
@@ -2246,35 +2654,15 @@ void prefixed_command(void)
             break;
         case let_cmd:
             n = cur_chr;
-            if (n == normal) {
-                get_r_token();
-                p = cur_cs;
-                do {
-                    get_token();
-                } while (cur_cmd == spacer_cmd);
-                if (cur_tok == other_token + '=') {
-                    get_token();
-                    if (cur_cmd == spacer_cmd)
-                        get_token();
-                }
-            } else if (n == normal + 1) {
-                /* futurelet */
-                get_r_token();
-                p = cur_cs;
-                get_token();
-                q = cur_tok;
-                get_token();
-                back_input();
-                cur_tok = q;
-                /* look ahead, then back up */
-                /* note that |back_input| doesn't affect |cur_cmd|, |cur_chr| */
-                back_input();
-            } else {
-                /* letcharcode */
-                scan_int();
-                if (cur_val > 0) {
-                    cur_cs = active_to_cs(cur_val, true);
-                    set_token_info(cur_cs, cur_cs + cs_token_flag);
+            switch (n) {
+                case 0:
+                    /*tex |glet| */
+                    if (!is_global(a) && (global_defs_par >= 0)) {
+                        a = a + 4;
+                    }
+                case 1:
+                    /*tex |let| */
+                    get_r_token();
                     p = cur_cs;
                     do {
                         get_token();
@@ -2284,21 +2672,60 @@ void prefixed_command(void)
                         if (cur_cmd == spacer_cmd)
                             get_token();
                     }
-                } else {
+                    break;
+                case 2:
+                    /*tex |futurelet| */
+                    get_r_token();
+                    p = cur_cs;
+                    get_token();
+                    q = cur_tok;
+                    get_token();
+                    back_input();
+                    cur_tok = q;
+                    /*tex
+                        We look ahead and then back up. Note that |back_input| doesn't
+                        affect |cur_cmd|, |cur_chr|
+                    */
+                    back_input();
+                    break;
+                case 3:
+                    /*tex |letcharcode| */
+                    scan_int();
+                    if (cur_val > 0) {
+                        cur_cs = active_to_cs(cur_val, true);
+                        set_token_info(cur_cs, cur_cs + cs_token_flag);
+                        p = cur_cs;
+                        do {
+                            get_token();
+                        } while (cur_cmd == spacer_cmd);
+                        if (cur_tok == other_token + '=') {
+                            get_token();
+                            if (cur_cmd == spacer_cmd)
+                                get_token();
+                        }
+                    } else {
+                        p = null;
+                        tex_error("invalid number for \\letcharcode",NULL);
+                    }
+                    break;
+                default:
+                    /*tex We please the compiler. */
                     p = null;
-                    tex_error("invalid number for \\letcharcode",NULL);
-                }
+                    confusion("let");
+                    break;
             }
             if (cur_cmd >= call_cmd)
                 add_token_ref(cur_chr);
             define(p, cur_cmd, cur_chr);
             break;
         case shorthand_def_cmd:
-            /* We temporarily define |p| to be |relax|, so that an occurrence of |p|
-               while scanning the definition will simply stop the scanning instead of
-               producing an ``undefined control sequence'' error or expanding the
-               previous meaning.  This allows, for instance, `\.{\\chardef\\foo=123\\foo}'.
-             */
+            /*tex
+                We temporarily define |p| to be |relax|, so that an occurrence of
+                |p| while scanning the definition will simply stop the scanning
+                instead of producing an ``undefined control sequence'' error or
+                expanding the previous meaning. This allows, for instance,
+                `\.{\\chardef\\foo=123\\foo}'.
+            */
             n = cur_chr;
             get_r_token();
             p = cur_cs;
@@ -2311,13 +2738,13 @@ void prefixed_command(void)
                 break;
             case math_char_def_code:
                 mval = scan_mathchar(tex_mathcode);
-                if (math_umathcode_meaning_par == 1) {
-                    cur_val = (mval.class_value + (8 * mval.family_value)) * (65536 * 32) + mval.character_value;
-                    define(p, xmath_given_cmd, cur_val);
-                } else {
+             /* if (math_umathcode_meaning_par == 1) { */
+             /*     cur_val = (mval.class_value + (8 * mval.family_value)) * (65536 * 32) + mval.character_value; */
+             /*     define(p, xmath_given_cmd, cur_val); */
+             /* } else { */
                     cur_val = (mval.class_value * 16 + mval.family_value) * 256 + mval.character_value;
                     define(p, math_given_cmd, cur_val);
-                }
+             /* } */
                 break;
             case xmath_char_def_code:
                 mval = scan_mathchar(umath_mathcode);
@@ -2363,8 +2790,10 @@ void prefixed_command(void)
             n = cur_val;
             if (!scan_keyword("to")) {
                 print_err("Missing `to' inserted");
-                help2("You should have said `\\read<number> to \\cs'.",
-                      "I'm going to look for the \\cs now.");
+                help2(
+                    "You should have said `\\read<number> to \\cs'.",
+                    "I'm going to look for the \\cs now."
+                );
                 error();
             }
             get_r_token();
@@ -2374,25 +2803,30 @@ void prefixed_command(void)
             break;
         case toks_register_cmd:
         case assign_toks_cmd:
-            /* The token-list parameters, \.{\\output} and \.{\\everypar}, etc., receive
-               their values in the following way. (For safety's sake, we place an
-               enclosing pair of braces around an \.{\\output} list.) */
+            /*tex
+                The token-list parameters, \.{\\output} and \.{\\everypar}, etc.,
+                receive their values in the following way. (For safety's sake, we
+                place an enclosing pair of braces around an \.{\\output} list.)
+            */
             q = cur_cs;
             if (cur_cmd == toks_register_cmd) {
                 scan_register_num();
                 p = toks_base + cur_val;
             } else {
-                p = cur_chr;        /* |p=every_par_loc| or |output_routine_loc| or \dots */
+                /*tex |p=every_par_loc| or |output_routine_loc| or \dots */
+                p = cur_chr;
             }
             scan_optional_equals();
-            /* Get the next non-blank non-relax non-call token */
+            /*tex Get the next non-blank non-relax non-call token */
             do {
                 get_x_token();
             } while ((cur_cmd == spacer_cmd) || (cur_cmd == relax_cmd));
 
             if (cur_cmd != left_brace_cmd) {
-                /* If the right-hand side is a token parameter
-                   or token register, finish the assignment and |goto done| */
+                /*tex
+                    If the right-hand side is a token parameter or token
+                    register, finish the assignment and |goto done|
+                */
                 if (cur_cmd == toks_register_cmd) {
                     scan_register_num();
                     cur_cmd = assign_toks_cmd;
@@ -2431,7 +2865,7 @@ void prefixed_command(void)
             }
             break;
         case assign_int_cmd:
-            /* Similar routines are used to assign values to the numeric parameters. */
+            /*tex Similar routines are used to assign values to the numeric parameters. */
             p = cur_chr;
             scan_optional_equals();
             scan_int();
@@ -2446,9 +2880,18 @@ void prefixed_command(void)
             attr_list_cache = cache_disabled;
             word_define(p, cur_val);
             break;
+        case assign_direction_cmd:
         case assign_dir_cmd:
-            /* DIR: Assign direction codes */
-            scan_direction();
+            /*tex Assign direction codes. */
+            if (cur_cmd == assign_direction_cmd) {
+                p = cur_chr;
+                scan_optional_equals();
+                scan_int();
+                check_dir_value(cur_val);
+                cur_chr = p;
+            } else {
+                scan_direction();
+            }
             switch (cur_chr) {
                 case int_base + page_direction_code:
                     eq_word_define(int_base + page_direction_code, cur_val);
@@ -2487,17 +2930,19 @@ void prefixed_command(void)
                     }
                     if (abs(mode) == hmode) {
                         if (no_local_dirs_par > 0) {
-                            /* tail is non zero but we test anyway */
+                            /*tex |tail| is non zero but we test anyway. */
                             if (check_glue && (tail != null && type(tail) == glue_node))  {
                                 halfword prev = alink(tail);
-                                halfword dirn = new_dir(text_direction_par - dir_swap);
+                                halfword dirn = new_dir(text_direction_par);
+                                subtype(dirn) = cancel_dir;
                                 couple_nodes(prev,dirn);
                                 couple_nodes(dirn,tail);
                             } else {
-                                tail_append(new_dir(text_direction_par - dir_swap));
+                                tail_append(new_dir(text_direction_par));
+                                subtype(tail) = cancel_dir;
                             }
                         } else {
-                            /* what is the use of nolocaldirs .. maybe we should get rid of it */
+                            /*tex What is the use of nolocaldirs? Maybe we should get rid of it. */
                         }
                         update_text_dir_ptr(cur_val);
                         tail_append(new_dir(cur_val));
@@ -2505,19 +2950,6 @@ void prefixed_command(void)
                     } else {
                         update_text_dir_ptr(cur_val);
                     }
-                    /*  original:
-
-                        // if ((no_local_dirs_par > 0) && (abs(mode) == hmode)) {
-                        //  // tail_append(new_dir(text_direction_par)              // kind of wrong
-                        //     tail_append(new_dir(text_direction_par - dir_swap)); // better
-                        // }
-
-                        update_text_dir_ptr(cur_val);
-                        if (abs(mode) == hmode) {
-                            tail_append(new_dir(cur_val));
-                            dir_level(tail) = cur_level;
-                        }
-                    */
                     eq_word_define(int_base + text_direction_code, cur_val);
                     eq_word_define(int_base + no_local_dirs_code, no_local_dirs_par + 1);
                     break;
@@ -2542,14 +2974,13 @@ void prefixed_command(void)
             break;
         case def_char_code_cmd:
         case def_del_code_cmd:
-            /* Let |n| be the largest legal code value, based on |cur_chr| */
+            /*tex Let |n| be the largest legal code value, based on |cur_chr| */
             if (cur_chr == cat_code_base)
                 n = max_char_code;
             else if (cur_chr == sf_code_base)
                 n = 077777;
             else
                 n = biggest_char;
-
             p = cur_chr;
             if (cur_chr == math_code_base) {
                 if (is_global(a))
@@ -2621,8 +3052,9 @@ void prefixed_command(void)
             get_token();
             if (cur_cmd != math_style_cmd) {
                 print_err("Missing math style, treated as \\displaystyle");
-                help1
-                    ("A style should have been here; I inserted `\\displaystyle'.");
+                help1(
+                    "A style should have been here; I inserted `\\displaystyle'."
+                );
                 cur_val1 = display_style;
                 back_error();
             } else {
@@ -2652,9 +3084,11 @@ void prefixed_command(void)
             do_register_command(a);
             break;
         case set_box_cmd:
-            /* The processing of boxes is somewhat different, because we may need
-               to scan and create an entire box before we actually change the value
-               of the old one. */
+            /*tex
+                The processing of boxes is somewhat different, because we may
+                need to scan and create an entire box before we actually change
+                the value of the old one.
+            */
             scan_register_num();
             if (is_global(a))
                 n = global_box_flag + cur_val;
@@ -2665,16 +3099,22 @@ void prefixed_command(void)
                 scan_box(n);
             } else {
                 print_err("Improper \\setbox");
-                help2("Sorry, \\setbox is not allowed after \\halign in a display,",
-                      "or between \\accent and an accented character.");
+                help3(
+                    "Sorry, \\setbox is not allowed after \\halign in a display,",
+                    "between \\accent and an accented character, or in immediate",
+                    "assignments."
+                );
                 error();
             }
             break;
         case set_aux_cmd:
-            /* The |space_factor| or |prev_depth| settings are changed when a |set_aux|
-               command is sensed. Similarly, |prev_graf| is changed in the presence of
-               |set_prev_graf|, and |dead_cycles| or |insert_penalties| in the presence of
-               |set_page_int|. These definitions are always global. */
+            /*tex
+                The |space_factor| or |prev_depth| settings are changed when a
+                |set_aux| command is sensed. Similarly, |prev_graf| is changed in
+                the presence of |set_prev_graf|, and |dead_cycles| or
+                |insert_penalties| in the presence of |set_page_int|. These
+                definitions are always global.
+            */
             alter_aux();
             break;
         case set_prev_graf_cmd:
@@ -2687,8 +3127,11 @@ void prefixed_command(void)
             alter_integer();
             break;
         case set_box_dimen_cmd:
-            /* When some dimension of a box register is changed, the change isn't exactly
-               global; but \TeX\ does not look at the \.{\\global} switch. */
+            /*tex
+                When some dimension of a box register is changed, the change
+                isn't exactly global; but \TeX\ does not look at the \.{\\global}
+                switch.
+            */
             alter_box_dimen();
             break;
         case set_tex_shape_cmd:
@@ -2722,7 +3165,7 @@ void prefixed_command(void)
                 p = new_node(shape_node, 2 * n + 1 + 1);
                 vinfo(p + 1) = n;
                 n = cur_val;
-                varmem[p + 2].cint = n;     /* number of penalties */
+                varmem[p + 2].cint = n;             /* number of penalties */
                 for (j = p + 3; j <= p + n + 2; j++) {
                     scan_int();
                     varmem[j].cint = cur_val;       /* penalty values */
@@ -2733,8 +3176,10 @@ void prefixed_command(void)
             define(q, shape_ref_cmd, p);
             break;
         case hyph_data_cmd:
-            /* All of \TeX's parameters are kept in |eqtb| except the font information,
-               the interaction mode, and the hyphenation tables; these are strictly global.
+            /*tex
+                All of \TeX's parameters are kept in |eqtb| except the font
+                information, the interaction mode, and the hyphenation tables;
+                these are strictly global.
              */
             switch (cur_chr) {
                 case 0:
@@ -2801,9 +3246,20 @@ void prefixed_command(void)
             }
             break;
         case def_font_cmd:
-            /* Here is where the information for a new font gets loaded. */
+            /*tex Here is where the information for a new font gets loaded. */
             tex_def_font((small_number) a);
             break;
+        case def_lua_call_cmd:
+            get_r_token();
+            p = cur_cs;
+            scan_optional_equals();
+            scan_int();
+            if (j != 0) {
+                define(p, lua_call_cmd, cur_val);
+            } else {
+                define(p, lua_expandable_call_cmd, cur_val);
+            }
+            break;
         case letterspace_font_cmd:
             new_letterspaced_font((small_number) a);
             break;
@@ -2821,9 +3277,10 @@ void prefixed_command(void)
         default:
             confusion("prefix");
             break;
-    }                           /* end of Assignments cases */
+    }
+    /*tex End of assignments cases. */
   DONE:
-    /* Insert a token saved by \.{\\afterassignment}, if any */
+    /*tex Insert a token saved by \.{\\afterassignment}, if any. */
     if (after_token != 0) {
         cur_tok = after_token;
         back_input();
@@ -2831,14 +3288,13 @@ void prefixed_command(void)
     }
 }
 
-@ @c
 void fixup_directions(void)
 {
     int temp_no_whatsits = no_local_whatsits_par;
     int temp_no_dirs = no_local_dirs_par;
     int temporary_dir = text_direction_par;
     if (dir_level(text_dir_ptr) == cur_level) {
-        /* DIR: Remove from |text_dir_ptr| */
+        /* Remove from |text_dir_ptr|. */
         halfword text_dir_tmp = vlink(text_dir_ptr);
         flush_node(text_dir_ptr);
         text_dir_ptr = text_dir_tmp;
@@ -2846,22 +3302,50 @@ void fixup_directions(void)
     unsave();
     if (abs(mode) == hmode) {
         if (temp_no_dirs != 0) {
-            /* DIR: Add local dir node */
+            /* Add local dir node. */
             tail_append(new_dir(text_direction_par));
-            dir_dir(tail) = temporary_dir - dir_swap;
+            dir_dir(tail) = temporary_dir;
+            subtype(tail) = cancel_dir;
         }
         if (temp_no_whatsits != 0) {
-            /* LOCAL: Add local paragraph node */
+            /*tex Add local paragraph node. */
             tail_append(make_local_par_node(hmode_par_par_code));
         }
     }
 }
 
-@ When a control sequence is to be defined, by \.{\\def} or \.{\\let} or
-something similar, the |get_r_token| routine will substitute a special
-control sequence for a token that is not redefinable.
+/*tex
+
+    This is experimental and needs more checking!
+
+*/
+
+void fixup_directions_only(void)
+{
+    int temp_no_dirs = no_local_dirs_par;
+    int temporary_dir = text_direction_par;
+    if (dir_level(text_dir_ptr) == cur_level) {
+        /* Remove from |text_dir_ptr|. */
+        halfword text_dir_tmp = vlink(text_dir_ptr);
+        flush_node(text_dir_ptr);
+        text_dir_ptr = text_dir_tmp;
+    }
+    if (temp_no_dirs != 0) {
+        /* Add local dir node. */
+        tail_append(new_dir(text_direction_par));
+        dir_dir(tail) = temporary_dir;
+        subtype(tail) = cancel_dir;
+    }
+}
+
+/*tex
+
+When a control sequence is to be defined, by \.{\\def} or \.{\\let} or something
+similar, the |get_r_token| routine will substitute a special control sequence for
+a token that is not redefinable.
+
+*/
 
-@c
 void get_r_token(void)
 {
   RESTART:
@@ -2871,11 +3355,13 @@ void get_r_token(void)
     if ((cur_cs == 0) || (cur_cs > eqtb_top) ||
         ((cur_cs > frozen_control_sequence) && (cur_cs <= eqtb_size))) {
         print_err("Missing control sequence inserted");
-        help5("Please don't say `\\def cs{...}', say `\\def\\cs{...}'.",
-              "I've inserted an inaccessible control sequence so that your",
-              "definition will be completed without mixing me up too badly.",
-              "You can recover graciously from this error, if you're",
-              "careful; see exercise 27.2 in The TeXbook.");
+        help5(
+            "Please don't say `\\def cs{...}', say `\\def\\cs{...}'.",
+            "I've inserted an inaccessible control sequence so that your",
+            "definition will be completed without mixing me up too badly.",
+            "You can recover graciously from this error, if you're",
+            "careful; see exercise 27.2 in The TeXbook."
+        );
         if (cur_cs == 0)
             back_input();
         cur_tok = cs_token_flag + frozen_protection;
@@ -2884,7 +3370,6 @@ void get_r_token(void)
     }
 }
 
-@ @c
 void assign_internal_value(int a, halfword p, int val)
 {
     halfword n;
@@ -2896,17 +3381,19 @@ void assign_internal_value(int a, halfword p, int val)
                     word_define(p, val);
             } else {
                 print_err("Invalid \\catcode table");
-                help2
-                    ("You can only switch to a \\catcode table that is initialized",
-                     "using \\savecatcodetable or \\initcatcodetable, or to table 0");
+                help2(
+                    "You can only switch to a \\catcode table that is initialized",
+                    "using \\savecatcodetable or \\initcatcodetable, or to table 0"
+                );
                 error();
             }
             break;
         case output_box_code:
             if ((val > 65535) | (val < 0)) {
                 print_err("Invalid \\outputbox");
-                help1
-                    ("The value for \\outputbox has to be between 0 and 65535.");
+                help1(
+                    "The value for \\outputbox has to be between 0 and 65535."
+                );
                 error();
             } else {
                 word_define(p, val);
@@ -2915,9 +3402,10 @@ void assign_internal_value(int a, halfword p, int val)
         case new_line_char_code:
             if (val > 127) {
                 print_err("Invalid \\newlinechar");
-                help2
-                    ("The value for \\newlinechar has to be no higher than 127.",
-                     "Your invalid assignment will be ignored.");
+                help2(
+                    "The value for \\newlinechar has to be no higher than 127.",
+                    "Your invalid assignment will be ignored."
+                );
                 error();
             } else {
                 word_define(p, val);
@@ -2926,9 +3414,10 @@ void assign_internal_value(int a, halfword p, int val)
         case end_line_char_code:
             if (val > 127) {
                 print_err("Invalid \\endlinechar");
-                help2
-                    ("The value for \\endlinechar has to be no higher than 127.",
-                     "Your invalid assignment will be ignored.");
+                help2(
+                    "The value for \\endlinechar has to be no higher than 127.",
+                    "Your invalid assignment will be ignored."
+                );
                 error();
             } else {
                 word_define(p, val);
@@ -2940,9 +3429,10 @@ void assign_internal_value(int a, halfword p, int val)
                 word_define(p, -1);
             } else if (val > 16383) {
                 print_err("Invalid \\language");
-                help2
-                    ("The absolute value for \\language has to be no higher than 16383.",
-                     "Your invalid assignment will be ignored.");
+                help2(
+                    "The absolute value for \\language has to be no higher than 16383.",
+                    "Your invalid assignment will be ignored."
+                );
                 error();
             } else {
                 word_define(int_base + cur_lang_code, val);
@@ -2953,15 +3443,17 @@ void assign_internal_value(int a, halfword p, int val)
             word_define(p, val);
             break;
         }
-        /* If we are defining subparagraph penalty levels while we are
-           in hmode, then we put out a whatsit immediately, otherwise
-           we leave it alone.  This mechanism might not be sufficiently
-           powerful, and some other algorithm, searching down the stack,
-           might be necessary.  Good first step. */
+        /*tex
+            If we are defining subparagraph penalty levels while we are in hmode,
+            then we put out a whatsit immediately, otherwise we leave it alone.
+            This mechanism might not be sufficiently powerful, and some other
+            algorithm, searching down the stack, might be necessary. Good first
+            step.
+        */
         if ((abs(mode) == hmode) &&
             ((p == (int_base + local_inter_line_penalty_code)) ||
              (p == (int_base + local_broken_penalty_code)))) {
-            /* LOCAL: Add local paragraph node */
+            /*tex Add local paragraph node */
             tail_append(make_local_par_node(penalty_par_code));
             eq_word_define(int_base + no_local_whatsits_code, no_local_whatsits_par + 1);
         }
@@ -2980,20 +3472,23 @@ void assign_internal_value(int a, halfword p, int val)
             word_define(dimen_base + page_top_offset_code, n);
         }
         word_define(p, val);
-    } else if ((p >= local_base) && (p < toks_base)) {  /* internal locals  */
+    } else if ((p >= local_base) && (p < toks_base)) {
+        /*tex internal locals */
         define(p, call_cmd, val);
     } else {
         confusion("assign internal value");
     }
 }
 
-@ We use the fact that |register<advance<multiply<divide|
+/*tex
 
-Compute the register location |l| and its type |p|; but |return| if invalid
-Here we use the fact that the consecutive codes |int_val..mu_val| and
+We use the fact that |register| $<$ |advance| $<$ |multiply| $<$ |divide|/ We
+compute the register location |l| and its type |p| but |return| if invalid. Here
+we use the fact that the consecutive codes |int_val..mu_val| and
 |assign_int..assign_mu_glue| correspond to each other nicely.
 
-@c
+*/
+
 void do_register_command(int a)
 {
     int p;
@@ -3011,7 +3506,9 @@ void do_register_command(int a)
             print_cmd_chr((quarterword) cur_cmd, cur_chr);
             tprint("' after ");
             print_cmd_chr((quarterword) q, 0);
-            help1("I'm forgetting what you said and not changing anything.");
+            help1(
+                "I'm forgetting what you said and not changing anything."
+            );
             error();
             return;
         }
@@ -3032,11 +3529,11 @@ void do_register_command(int a)
     if (q == register_cmd) {
         scan_optional_equals();
     } else if (scan_keyword("by")) {
-        /* optional `\.{by}' */
+        /*tex optional `\.{by}' */
     }
     arith_error = false;
     if (q < multiply_cmd) {
-        /* Compute result of |register| or |advance|, put it in |cur_val| */
+        /*tex Compute result of |register| or |advance|, put it in |cur_val|. */
         if (p < glue_val_level) {
             if ((p == int_val_level) || (p == attr_val_level))
                 scan_int();
@@ -3045,7 +3542,6 @@ void do_register_command(int a)
             if (q == advance_cmd)
                 cur_val = cur_val + eqtb[l].cint;
         } else {
-            /* we can probably save a copy */
             scan_glue(p);
             if (q == advance_cmd) {
                 /* Compute the sum of two glue specs */
@@ -3075,7 +3571,7 @@ void do_register_command(int a)
             }
         }
     } else {
-        /* Compute result of |multiply| or |divide|, put it in |cur_val| */
+        /*tex Compute result of |multiply| or |divide|, put it in |cur_val| */
         scan_int();
         if (p < glue_val_level) {
             if (q == multiply_cmd) {
@@ -3104,8 +3600,10 @@ void do_register_command(int a)
     }
     if (arith_error) {
         print_err("Arithmetic overflow");
-        help2("I can't carry out that multiplication or division,",
-              "since the result is out of range.");
+        help2(
+            "I can't carry out that multiplication or division,",
+            "since the result is out of range."
+        );
         if (p >= glue_val_level)
             flush_node(cur_val);
         error();
@@ -3126,10 +3624,9 @@ void do_register_command(int a)
     }
 }
 
-@ @c
 void alter_aux(void)
 {
-    halfword c;                 /* |hmode| or |vmode| */
+    halfword c; /* |hmode| or |vmode| */
     if (cur_chr != abs(mode)) {
         report_illegal_case();
     } else {
@@ -3142,7 +3639,9 @@ void alter_aux(void)
             scan_int();
             if ((cur_val <= 0) || (cur_val > 32767)) {
                 print_err("Bad space factor");
-                help1("I allow only values in the range 1..32767 here.");
+                help1(
+                    "I allow only values in the range 1..32767 here."
+                );
                 int_error(cur_val);
             } else {
                 space_factor_par = cur_val;
@@ -3151,39 +3650,39 @@ void alter_aux(void)
     }
 }
 
-@ @c
 void alter_prev_graf(void)
 {
-    int p;                      /* index into |nest| */
-    p = nest_ptr;
+    int p = nest_ptr; /* index into |nest| */
     while (abs(nest[p].mode_field) != vmode)
         decr(p);
     scan_optional_equals();
     scan_int();
     if (cur_val < 0) {
         print_err("Bad \\prevgraf");
-        help1("I allow only nonnegative values here.");
+        help1(
+            "I allow only nonnegative values here."
+        );
         int_error(cur_val);
     } else {
         nest[p].pg_field = cur_val;
     }
 }
 
-@ @c
 void alter_page_so_far(void)
 {
-    int c;                      /* index into |page_so_far| */
-    c = cur_chr;
+    int c = cur_chr;   /* index into |page_so_far| */
     scan_optional_equals();
     scan_normal_dimen();
     page_so_far[c] = cur_val;
 }
 
-@ @c
+/*tex
+    The value of |c| is 0 for \.{\\deadcycles}, 1 for \.{\\insertpenalties}, etc.
+*/
+
 void alter_integer(void)
 {
-    int c;                      /* 0 for \.{\\deadcycles}, 1 for \.{\\insertpenalties}, etc. */
-    c = cur_chr;
+    int c = cur_chr;
     scan_optional_equals();
     scan_int();
     if (c == 0) {
@@ -3191,8 +3690,10 @@ void alter_integer(void)
     } else if (c == 2) {
         if ((cur_val < batch_mode) || (cur_val > error_stop_mode)) {
             print_err("Bad interaction mode");
-            help2("Modes are 0=batch, 1=nonstop, 2=scroll, and",
-                  "3=errorstop. Proceed, and I'll ignore this case.");
+            help2(
+                "Modes are 0=batch, 1=nonstop, 2=scroll, and",
+                "3=errorstop. Proceed, and I'll ignore this case."
+            );
             int_error(cur_val);
         } else {
             cur_chr = cur_val;
@@ -3203,11 +3704,10 @@ void alter_integer(void)
     }
 }
 
-@ @c
 void alter_box_dimen(void)
 {
-    int c;                      /* |width_offset| or |height_offset| or |depth_offset| */
-    int b;                      /* box number */
+    int c; /* |width_offset| or |height_offset| or |depth_offset| */
+    int b; /* box number */
     c = cur_chr;
     scan_register_num();
     b = cur_val;
@@ -3217,7 +3717,6 @@ void alter_box_dimen(void)
         varmem[box(b) + c].cint = cur_val;
 }
 
-@ @c
 void new_interaction(void)
 {
     print_ln();
@@ -3229,21 +3728,27 @@ void new_interaction(void)
     fixup_selector(log_opened_global);
 }
 
-@ The \.{\\afterassignment} command puts a token into the global
-variable |after_token|. This global variable is examined just after
-every assignment has been performed.
+/*tex
+
+The \.{\\afterassignment} command puts a token into the global variable
+|after_token|. This global variable is examined just after every assignment has
+been performed. It's value is zero, or a saved token.
+
+*/
+
+halfword after_token;
+
+/*tex
 
-@c
-halfword after_token;           /* zero, or a saved token */
+    Here is a procedure that might be called `Get the next non-blank non-relax
+    non-call non-assignment token'.
 
-@ Here is a procedure that might be called `Get the next non-blank non-relax
-non-call non-assignment token'.
+*/
 
-@c
 void do_assignments(void)
 {
     while (true) {
-        /* Get the next non-blank non-relax... */
+        /*tex Get the next non-blank non-relax... */
         do {
             get_x_token();
         } while ((cur_cmd == spacer_cmd) || (cur_cmd == relax_cmd));
@@ -3255,13 +3760,13 @@ void do_assignments(void)
     }
 }
 
-@ @c
+/*tex |cur_chr| is 1 for \.{\\openin}, 0 for \.{\\closein}: */
+
 void open_or_close_in(void)
 {
-    int c;                      /* 1 for \.{\\openin}, 0 for \.{\\closein} */
-    int n;                      /* stream number */
+    int c = cur_chr;
+    int n;
     char *fn;
-    c = cur_chr;
     scan_four_bit_int();
     n = cur_val;
     if (read_open[n] != closed) {
@@ -3275,7 +3780,8 @@ void open_or_close_in(void)
         } while ((cur_cmd == spacer_cmd) || (cur_cmd == relax_cmd));
         back_input();
         if (cur_cmd != left_brace_cmd) {
-            scan_file_name();   /* set |cur_name| to desired file name */
+            /*tex Set |cur_name| to desired file name. */
+            scan_file_name();
             if (cur_ext == get_nullstr())
                 cur_ext = maketexstring(".tex");
         } else {
@@ -3288,14 +3794,17 @@ void open_or_close_in(void)
     }
 }
 
-@ @c
-boolean long_help_seen;         /* has the long \.{\\errmessage} help been used? */
+/*tex
+    Has the long \.{\\errmessage} help been used?
+*/
+
+boolean long_help_seen;
 
 void issue_message(void)
 {
-    int old_setting;            /* holds |selector| setting */
-    int c;                      /* identifies \.{\\message} and \.{\\errmessage} */
-    str_number s;               /* the message */
+    int old_setting; /* holds |selector| setting */
+    int c;           /* identifies \.{\\message} and \.{\\errmessage} */
+    str_number s;    /* the message */
     c = cur_chr;
     (void) scan_toks(false, true);
     old_setting = selector;
@@ -3306,7 +3815,7 @@ void issue_message(void)
     str_room(1);
     s = make_string();
     if (c == 0) {
-        /* Print string |s| on the terminal */
+        /*tex Print string |s| on the terminal */
         if (term_offset + (int) str_length(s) > max_print_line - 2)
             print_ln();
         else if ((term_offset > 0) || (file_offset > 0))
@@ -3315,23 +3824,29 @@ void issue_message(void)
         update_terminal();
 
     } else {
-        /* Print string |s| as an error message */
-        /* If \.{\\errmessage} occurs often in |scroll_mode|, without user-defined
-           \.{\\errhelp}, we don't want to give a long help message each time. So we
-           give a verbose explanation only once. */
+        /*tex
+            Print string |s| as an error message. If \.{\\errmessage} occurs
+            often in |scroll_mode|, without user-defined \.{\\errhelp}, we don't
+            want to give a long help message each time. So we give a verbose
+            explanation only once.
+        */
         print_err("");
         print(s);
         if (err_help_par != null) {
             use_err_help = true;
         } else if (long_help_seen) {
-            help1("(That was another \\errmessage.)");
+            help1(
+                "(That was another \\errmessage.)"
+            );
         } else {
             if (interaction < error_stop_mode)
                 long_help_seen = true;
-            help4("This error message was generated by an \\errmessage",
-                  "command, so I can't give any explicit help.",
-                  "Pretend that you're Hercule Poirot: Examine all clues,",
-                  "and deduce the truth by order and method.");
+            help4(
+                "This error message was generated by an \\errmessage",
+                "command, so I can't give any explicit help.",
+                "Pretend that you're Hercule Poirot: Examine all clues,",
+                "and deduce the truth by order and method."
+            );
         }
         error();
         use_err_help = false;
@@ -3340,34 +3855,40 @@ void issue_message(void)
     flush_str(s);
 }
 
-@ The |error| routine calls on |give_err_help| if help is requested from
-the |err_help| parameter.
+/*tex
+
+The |error| routine calls on |give_err_help| if help is requested from the
+|err_help| parameter.
+
+*/
 
-@c
 void give_err_help(void)
 {
     token_show(err_help_par);
 }
 
-@ The \.{\\uppercase} and \.{\\lowercase} commands are implemented by
-building a token list and then changing the cases of the letters in it.
+/*tex
+
+The \.{\\uppercase} and \.{\\lowercase} commands are implemented by building a
+token list and then changing the cases of the letters in it.
+
+*/
 
-@c
 void shift_case(void)
 {
-    halfword b;                 /* |lc_code_base| or |uc_code_base| */
-    halfword p;                 /* runs through the token list */
-    halfword t;                 /* token */
-    halfword c;                 /* character code */
-    halfword i;                 /* inbetween */
+    halfword b;  /* |lc_code_base| or |uc_code_base| */
+    halfword p;  /* runs through the token list */
+    halfword t;  /* token */
+    halfword c;  /* character code */
+    halfword i;  /* inbetween */
     b = cur_chr;
     p = scan_toks(false, false);
     p = token_link(def_ref);
     while (p != null) {
-        /* Change the case of the token in |p|, if a change is appropriate */
-        /*
-           When the case of a |chr_code| changes, we don't change the |cmd|.
-           We also change active characters.
+        /*tex
+            Change the case of the token in |p|, if a change is appropriate. When
+            the case of a |chr_code| changes, we don't change the |cmd|. We also
+            change active characters.
          */
         t = token_info(p);
         if (t < cs_token_flag) {
@@ -3390,27 +3911,30 @@ void shift_case(void)
         p = token_link(p);
     }
     back_list(token_link(def_ref));
-    free_avail(def_ref);        /* omit reference count */
+    free_avail(def_ref);
 }
 
-@ We come finally to the last pieces missing from |main_control|, namely the
+/*tex
+
+We come finally to the last pieces missing from |main_control|, namely the
 `\.{\\show}' commands that are useful when debugging.
 
-@c
+*/
+
 void show_whatever(void)
 {
-    halfword p;                 /* tail of a token list to show */
-    int t;                      /* type of conditional being shown */
-    int m;                      /* upper bound on |fi_or_else| codes */
-    int l;                      /* line where that conditional began */
-    int n;                      /* level of \.{\\if...\\fi} nesting */
+    halfword p; /* tail of a token list to show */
+    int t;      /* type of conditional being shown */
+    int m;      /* upper bound on |fi_or_else| codes */
+    int l;      /* line where that conditional began */
+    int n;      /* level of \.{\\if...\\fi} nesting */
     switch (cur_chr) {
     case show_lists:
         begin_diagnostic();
         show_activities();
         break;
     case show_box_code:
-        /* Show the current contents of a box */
+        /*tex Show the current contents of a box. */
         scan_register_num();
         begin_diagnostic();
         tprint_nl("> \\box");
@@ -3422,7 +3946,7 @@ void show_whatever(void)
             show_box(box(cur_val));
         break;
     case show_code:
-        /* Show the current meaning of a token, then |goto common_ending| */
+        /*tex Show the current meaning of a token, then |goto common_ending|. */
         get_token();
         if (interaction == error_stop_mode)
             wake_up_terminal();
@@ -3434,7 +3958,7 @@ void show_whatever(void)
         print_meaning();
         goto COMMON_ENDING;
         break;
-        /* Cases for |show_whatever| */
+        /*tex Cases for |show_whatever| */
     case show_groups:
         begin_diagnostic();
         show_save_groups();
@@ -3474,8 +3998,10 @@ void show_whatever(void)
         }
         break;
     default:
-        /* Show the current value of some parameter or register,
-           then |goto common_ending| */
+        /*tex
+            Show the current value of some parameter or register, then |goto
+            common_ending|.
+        */
         p = the_toks();
         if (interaction == error_stop_mode)
             wake_up_terminal();
@@ -3485,7 +4011,7 @@ void show_whatever(void)
         goto COMMON_ENDING;
         break;
     }
-    /* Complete a potentially long \.{\\show} command */
+    /*tex Complete a potentially long \.{\\show} command: */
     end_diagnostic(true);
     print_err("OK");
     if (selector == term_and_log) {
@@ -3500,32 +4026,40 @@ void show_whatever(void)
         help0();
         decr(error_count);
     } else if (tracing_online_par > 0) {
-        help3("This isn't an error message; I'm just \\showing something.",
-              "Type `I\\show...' to show more (e.g., \\show\\cs,",
-              "\\showthe\\count10, \\showbox255, \\showlists).");
+        help3(
+            "This isn't an error message; I'm just \\showing something.",
+            "Type `I\\show...' to show more (e.g., \\show\\cs,",
+            "\\showthe\\count10, \\showbox255, \\showlists)."
+        );
     } else {
-        help5("This isn't an error message; I'm just \\showing something.",
-              "Type `I\\show...' to show more (e.g., \\show\\cs,",
-              "\\showthe\\count10, \\showbox255, \\showlists).",
-              "And type `I\\tracingonline=1\\show...' to show boxes and",
-              "lists on your terminal as well as in the transcript file.");
+        help5(
+            "This isn't an error message; I'm just \\showing something.",
+            "Type `I\\show...' to show more (e.g., \\show\\cs,",
+            "\\showthe\\count10, \\showbox255, \\showlists).",
+            "And type `I\\tracingonline=1\\show...' to show boxes and",
+            "lists on your terminal as well as in the transcript file."
+        );
     }
     error();
 }
 
-@ @c
+/*tex
+    This procedure gets things started properly:
+*/
+
 void initialize(void)
-{                               /* this procedure gets things started properly */
-    int k;                      /* index into |mem|, |eqtb|, etc. */
-    /* Initialize whatever \TeX\ might access */
-    /* Set initial values of key variables */
+{
+    int k; /* index into |mem|, |eqtb|, etc. */
+    /*tex
+        Initialize whatever \TeX\ might access and set initial values of key
+        variables
+    */
     initialize_errors();
     initialize_arithmetic();
     max_used_attr = -1;
     attr_list_cache = cache_disabled;
     initialize_nesting();
-
-    /* Start a new current page */
+    /*tex Start a new current page: */
     page_contents = empty;
     page_tail = page_head;
 #if 0
@@ -3539,7 +4073,7 @@ void initialize(void)
     page_max_depth = 0;
 
     initialize_equivalents();
-    no_new_control_sequence = true;     /* new identifiers are usually forbidden */
+    no_new_control_sequence = true; /* new identifiers are usually forbidden */
     init_primitives();
 
     mag_set = 0;
@@ -3559,11 +4093,10 @@ void initialize(void)
     stop_at_space = true;
 
     if (ini_version) {
-        /* Initialize table entries (done by \.{INITEX} only) */
-
+        /*tex Initialize table entries (done by \.{INITEX} only). */
         init_node_mem(500);
         initialize_tokens();
-        /* Initialize the special list heads and constant nodes */
+        /*tex Initialize the special list heads and constant nodes. */
         initialize_alignments();
         initialize_buildpage();
 
@@ -3629,7 +4162,9 @@ void initialize(void)
         math_pre_display_gap_factor_par = 2000;
         pre_bin_op_penalty_par = inf_penalty;
         math_script_box_mode_par = 1;
+        math_script_char_mode_par = 1;
         pre_rel_penalty_par = inf_penalty;
+        compound_hyphen_mode_par = 1;
         escape_char_par = '\\';
         end_line_char_par = carriage_return;
         set_del_code('.', 0, 0, 0, 0, level_one); /* this null delimiter is used in error recovery */
@@ -3642,7 +4177,7 @@ void initialize(void)
         page_right_offset_par = one_inch;
         page_bottom_offset_par = one_inch;
         ini_init_primitives();
-        hash_used = frozen_control_sequence;    /* nothing is used */
+        hash_used = frozen_control_sequence;
         hash_high = 0;
         cs_count = 0;
         set_eq_type(frozen_dont_expand, dont_expand_cmd);
@@ -3655,16 +4190,16 @@ void initialize(void)
         font_bytes = 0;
         px_dimen_par = one_bp;
         math_eqno_gap_step_par = 1000 ;
+        math_flatten_mode_par = 1; /* ord */
         cs_text(frozen_protection) = maketexstring("inaccessible");
         format_ident = maketexstring(" (INITEX)");
         cs_text(end_write) = maketexstring("endwrite");
         set_eq_level(end_write, level_one);
         set_eq_type(end_write, outer_call_cmd);
         set_equiv(end_write, null);
-        /* bah */
+        /*tex Bah, this is a bad place do do this. */
         set_pdf_major_version(1);
         set_pdf_minor_version(0);
     }
     synctexoffset = int_base + synctex_code;
-
 }
diff --git a/texk/web2c/luatexdir/tex/mathcodes.w b/texk/web2c/luatexdir/tex/mathcodes.c
similarity index 80%
rename from texk/web2c/luatexdir/tex/mathcodes.w
rename to texk/web2c/luatexdir/tex/mathcodes.c
index a0a357e53..42e8b0b15 100644
--- a/texk/web2c/luatexdir/tex/mathcodes.w
+++ b/texk/web2c/luatexdir/tex/mathcodes.c
@@ -1,81 +1,88 @@
-% mathnodes.w
-%
-% Copyright 2006-2012 Taco Hoekwater <taco@@luatex.org>
-% Copyright 2012 Khaled Hosny <khaledhosny@@eglug.org>
-%
-% This file is part of LuaTeX.
-%
-% LuaTeX is free software; you can redistribute it and/or modify it under
-% the terms of the GNU General Public License as published by the Free
-% Software Foundation; either version 2 of the License, or (at your
-% option) any later version.
-%
-% LuaTeX is distributed in the hope that it will be useful, but WITHOUT
-% ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-% FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
-% License for more details.
-%
-% You should have received a copy of the GNU General Public License along
-% with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
-
-@ @c
+/*
+
+mathnodes.w
+
+Copyright 2006-2010 Taco Hoekwater <taco@@luatex.org>
+
+This file is part of LuaTeX.
+
+LuaTeX is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 2 of the License, or (at your
+option) any later version.
+
+LuaTeX is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+License for more details.
+
+You should have received a copy of the GNU General Public License along
+with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+
+*/
 
 #include "ptexlib.h"
 
-@ math codes
-@c
+/*tex
+
+We support tre traditional math codes as well as larger ones suitable for
+\UNICODE\ input and fonts.
+
+*/
+
 static sa_tree mathcode_head = NULL;
 
-/* the 0xFFFFFFFF is a flag value */
+/*tex the |0xFFFFFFFF| is a flag value. */
 
 #define MATHCODESTACK 8
 #define MATHCODEDEFAULT 0xFFFFFFFF
 #define MATHCODEACTIVE  0xFFFFFFFE
 
-@ delcodes
-@c
+/*tex
+
+Delcodes are also went larger.
+
+*/
+
 static sa_tree delcode_head = NULL;
 
 #define DELCODESTACK 4
 #define DELCODEDEFAULT 0xFFFFFFFF
 
-@ some helpers for mathcode printing
+/*tex
+
+We now get lots of helpers for definitions and printing. The storage model
+that we use is different because we can hav emany more so we need to be
+sparse. Therefore we use trees.
+
+*/
+
 
-@c
-#define print_hex_digit(A) do {                 \
-    if ((A)>=10) print_char('A'+(A)-10);        \
-    else print_char('0'+(A));                   \
+#define print_hex_digit(A) do { \
+    if ((A)>=10) print_char('A'+(A)-10); \
+    else print_char('0'+(A)); \
   } while (0)
 
-#define two_hex(A) do {       \
-    print_hex_digit((A)/16);  \
-    print_hex_digit((A)%16);  \
+#define two_hex(A) do { \
+    print_hex_digit((A)/16); \
+    print_hex_digit((A)%16); \
   } while (0)
 
-#define four_hex(A) do {      \
-    two_hex((A)/256);         \
-    two_hex((A)%256);         \
+#define four_hex(A) do { \
+    two_hex((A)/256); \
+    two_hex((A)%256); \
   } while (0)
 
-#define six_hex(A) do {       \
-    two_hex((A)/65536);       \
+#define six_hex(A) do { \
+    two_hex((A)/65536); \
     two_hex(((A)%65536)/256); \
-    two_hex((A)%256);         \
+    two_hex((A)%256); \
   } while (0)
 
-/*
-    At some point we will drop the mathchardef 8 bit storage (c_mathoption_umathcode_meaning_code => 1)
-    and then some of the conversion can go away. Like mathchar_from_integer: only wide characters are
-    possible then.
-*/
-
-
-@ @c
 mathcodeval mathchar_from_integer(int value, int extcode)
 {
     mathcodeval mval;
     if (extcode == tex_mathcode) {
-     /* printf("can't happen: tex_mathcode\n"); */
         mval.class_value = (value / 0x1000);
         mval.family_value = ((value % 0x1000) / 0x100);
         mval.character_value = (value % 0x100);
@@ -88,12 +95,12 @@ mathcodeval mathchar_from_integer(int value, int extcode)
     return mval;
 }
 
-@ @c
 void show_mathcode_value_old(int value)
 {
     print_char('"');
     four_hex(value);
 }
+
 void show_mathcode_value(mathcodeval c)
 {
     print_char('"');
@@ -104,7 +111,6 @@ void show_mathcode_value(mathcodeval c)
     six_hex(c.character_value);
 }
 
-@ @c
 static void show_mathcode(int n)
 {
     mathcodeval c = get_math_code(n);
@@ -114,7 +120,6 @@ static void show_mathcode(int n)
     show_mathcode_value(c);
 }
 
-@ @c
 static void unsavemathcode(quarterword gl)
 {
     sa_stack_item st;
@@ -138,7 +143,6 @@ static void unsavemathcode(quarterword gl)
     }
 }
 
-@ @c
 void set_math_code(int n, int mathclass, int mathfamily, int mathcharacter, quarterword level)
 {
     sa_tree_item v;
@@ -161,9 +165,6 @@ void set_math_code(int n, int mathclass, int mathfamily, int mathcharacter, quar
     }
 }
 
-@ @c
-/* we could use two structs ... tex and umath */
-
 mathcodeval get_math_code(int n)
 {
     mathcodeval d;
@@ -189,14 +190,12 @@ mathcodeval get_math_code(int n)
     return d;
 }
 
-@ @c
 int get_math_code_num(int n)
 {
     mathcodeval d = get_math_code(n);
     return (d.class_value + (d.family_value * 8)) * (65536 * 32) + d.character_value;
 }
 
-@ @c
 static void initializemathcode(void)
 {
     sa_tree_item sa_value = { 0 };
@@ -214,7 +213,6 @@ static void undumpmathcode(void)
     mathcode_head = undump_sa_tree("mathcodes");
 }
 
-@ @c
 static void show_delcode(int n)
 {
     delcodeval c;
@@ -232,7 +230,6 @@ static void show_delcode(int n)
     }
 }
 
-@ @c
 static void unsavedelcode(quarterword gl)
 {
     sa_stack_item st;
@@ -256,7 +253,6 @@ static void unsavedelcode(quarterword gl)
     }
 }
 
-@ @c
 void set_del_code(int n, int smathfamily, int smathcharacter, int lmathfamily, int lmathcharacter, quarterword gl)
 {
     sa_tree_item v;
@@ -266,7 +262,8 @@ void set_del_code(int n, int smathfamily, int smathcharacter, int lmathfamily, i
     v.del_code_value.dummy_value = 0;
     v.del_code_value.large_family_value = lmathfamily;
     v.del_code_value.large_character_value = lmathcharacter;
-    set_sa_item(delcode_head, n, v, gl); /* always global */
+    /*tex Always global! */
+    set_sa_item(delcode_head, n, v, gl);
     if (tracing_assigns_par > 1) {
         begin_diagnostic();
         print_char('{');
@@ -278,7 +275,6 @@ void set_del_code(int n, int smathfamily, int smathcharacter, int lmathfamily, i
     }
 }
 
-@ @c
 delcodeval get_del_code(int n)
 {
     delcodeval d;
@@ -299,9 +295,12 @@ delcodeval get_del_code(int n)
     return d;
 }
 
-@ this really only works for old-style delcodes!
+/*tex
+
+This really only works for old-style delcodes!
+
+*/
 
-@c
 int get_del_code_num(int n)
 {
     delcodeval d = get_del_code(n);
@@ -313,7 +312,6 @@ int get_del_code_num(int n)
     }
 }
 
-@ @c
 static void initializedelcode(void)
 {
     sa_tree_item sa_value = { 0 };
@@ -321,7 +319,6 @@ static void initializedelcode(void)
     delcode_head = new_sa_tree(DELCODESTACK, 2, sa_value);
 }
 
-@ @c
 static void dumpdelcode(void)
 {
     dump_sa_tree(delcode_head,"delcodes");
@@ -332,28 +329,24 @@ static void undumpdelcode(void)
     delcode_head = undump_sa_tree("delcodes");
 }
 
-@ @c
 void unsave_math_codes(quarterword grouplevel)
 {
     unsavemathcode(grouplevel);
     unsavedelcode(grouplevel);
 }
 
-@ @c
 void initialize_math_codes(void)
 {
     initializemathcode();
     initializedelcode();
 }
 
-@ @c
 void free_math_codes(void)
 {
     destroy_sa_tree(mathcode_head);
     destroy_sa_tree(delcode_head);
 }
 
-@ @c
 void dump_math_codes(void)
 {
     dumpmathcode();
diff --git a/texk/web2c/luatexdir/tex/memoryword.c b/texk/web2c/luatexdir/tex/memoryword.c
new file mode 100644
index 000000000..7bf758dd0
--- /dev/null
+++ b/texk/web2c/luatexdir/tex/memoryword.c
@@ -0,0 +1,29 @@
+/*
+memoryword.w
+
+Copyright 2009-2010 Taco Hoekwater <taco@@luatex.org>
+
+This file is part of LuaTeX.
+
+LuaTeX is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 2 of the License, or (at your
+option) any later version.
+
+LuaTeX is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+License for more details.
+
+You should have received a copy of the GNU General Public License along
+with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#include "ptexlib.h"
+
+/*tex
+
+The debug code is no longer present!
+
+*/
diff --git a/texk/web2c/luatexdir/tex/memoryword.w b/texk/web2c/luatexdir/tex/memoryword.w
deleted file mode 100644
index b596abb37..000000000
--- a/texk/web2c/luatexdir/tex/memoryword.w
+++ /dev/null
@@ -1,55 +0,0 @@
-% memoryword.w
-%
-% Copyright 2009-2010 Taco Hoekwater <taco@@luatex.org>
-%
-% This file is part of LuaTeX.
-%
-% LuaTeX is free software; you can redistribute it and/or modify it under
-% the terms of the GNU General Public License as published by the Free
-% Software Foundation; either version 2 of the License, or (at your
-% option) any later version.
-%
-% LuaTeX is distributed in the hope that it will be useful, but WITHOUT
-% ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-% FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
-% License for more details.
-%
-% You should have received a copy of the GNU General Public License along
-% with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
-
-@ @c
-
-
-#include "ptexlib.h"
-
-@ When debugging, we may want to print a |memory_word| without knowing
-what type it is; so we print it in all modes.
-
-@c
-#ifdef DEBUG
-void print_word(memory_word w)
-{
-    /* prints |w| in all ways */
-    print_int(w.cint);
-    print_char(' ');
-    print_scaled(w.cint);
-    print_char(' ');
-    print_scaled(round(unity * float_cast(w.gr)));
-    print_ln();
-    print_int(w.hh.lhfield);
-    print_char('=');
-    print_int(w.hh.b0);
-    print_char(':');
-    print_int(w.hh.b1);
-    print_char(';');
-    print_int(w.hh.rh);
-    print_char(' ');
-    print_int(w.qqqq.b0);
-    print_char(':');
-    print_int(w.qqqq.b1);
-    print_char(':');
-    print_int(w.qqqq.b2);
-    print_char(':');
-    print_int(w.qqqq.b3);
-}
-#endif
diff --git a/texk/web2c/luatexdir/tex/mlist.w b/texk/web2c/luatexdir/tex/mlist.c
similarity index 66%
rename from texk/web2c/luatexdir/tex/mlist.w
rename to texk/web2c/luatexdir/tex/mlist.c
index 291ce8c48..8f6d71eb2 100644
--- a/texk/web2c/luatexdir/tex/mlist.w
+++ b/texk/web2c/luatexdir/tex/mlist.c
@@ -1,71 +1,72 @@
-% mlist.w
-%
-% Copyright 2006-2010 Taco Hoekwater <taco@@luatex.org>
-%
-% This file is part of LuaTeX.
-%
-% LuaTeX is free software; you can redistribute it and/or modify it under
-% the terms of the GNU General Public License as published by the Free
-% Software Foundation; either version 2 of the License, or (at your
-% option) any later version.
-%
-% LuaTeX is distributed in the hope that it will be useful, but WITHOUT
-% ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-% FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
-% License for more details.
-%
-% You should have received a copy of the GNU General Public License along
-% with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
-
-% (HH / 0.82+):
-
-@ In traditional \TeX\ the italic correction is added to the width of the glyph. This
-is part of the engine design and related font design. In opentype math this is
-different. There the italic correction had more explicit usage. The 1.7 spec
-says:
-
-italic correction:
-
-  When a run of slanted characters is followed by a straight character (such as
-  an operator or a delimiter), the italics correction of the last glyph is added
-  to its advance width.
-
-  When positioning limits on an N-ary operator (e.g., integral sign), the horizontal
-  position of the upper limit is moved to the right by ½ of the italics correction,
-  while the position of the lower limit is moved to the left by the same distance.
-
-  When positioning superscripts and subscripts, their default horizontal positions are
-  also different by the amount of the italics correction of the preceding glyph.
-
-math kerning:
-
-  Set the default horizontal position for the superscript as shifted relative to the
-  position of the subscript by the italics correction of the base glyph.
-
-Before this was specified we had to gamble a bit and assume that cambria was the font
-benchmark and trust our eyes (and msword) for the logic. I must admit that I have been
-fighting these italics in fonts (and the heuristics that Lua\TeX\ provided) right from
-the start (e.g. using Lua based postprocessing) but by now we know more and have more
-fonts to test with. More fonts are handy because not all fonts are alike when it comes
-to italics. Axis are another area of concern, as it looks like opentype math fonts often
-already apply that shift.
-
-@ @c
+/*
+
+Copyright 2006-2010 Taco Hoekwater <taco@luatex.org>
+
+This file is part of LuaTeX.
+
+LuaTeX is free software; you can redistribute it and/or modify it under the terms
+of the GNU General Public License as published by the Free Software Foundation;
+either version 2 of the License, or (at your option) any later version.
+
+LuaTeX is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU General Public License along with
+LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+
+*/
+
+/*tex
+
+    In traditional \TeX\ the italic correction is added to the width of the
+    glyph. This is part of the engine design and related font design. In opentype
+    math this is different. There the italic correction had more explicit usage.
+    The 1.7 spec says:
+
+    \startitemize
+
+    \startitem
+        {\em italic correction:} When a run of slanted characters is followed by
+        a straight character (such as an operator or a delimiter), the italics
+        correction of the last glyph is added to its advance width.
+
+        When positioning limits on an N-ary operator (e.g., integral sign), the
+        horizontal position of the upper limit is moved to the right by ½ of the
+        italics correction, while the position of the lower limit is moved to the
+        left by the same distance.
+
+        When positioning superscripts and subscripts, their default horizontal
+        positions are also different by the amount of the italics correction of
+        the preceding glyph.
+    \stopitem
+
+    \startitem
+        {\em math kerning:} Set the default horizontal position for the
+        superscript as shifted relative to the position of the subscript by the
+        italics correction of the base glyph.
+    \stopitem
+
+    \stopitemize
+
+    Before this was specified we had to gamble a bit and assume that cambria was
+    the font benchmark and trust our eyes (and msword) for the logic. I must
+    admit that I have been fighting these italics in fonts (and the heuristics
+    that Lua\TeX\ provided) right from the start (e.g. using Lua based
+    postprocessing) but by now we know more and have more fonts to test with.
+    More fonts are handy because not all fonts are alike when it comes to
+    italics. Axis are another area of concern, as it looks like opentype math
+    fonts often already apply that shift.
+
+*/
+
 #define is_new_mathfont(A)   ((font_math_params(A) >0) && (math_old_par == 0))
 #define is_old_mathfont(A,B) ((font_math_params(A)==0) && (font_params(A)>=(B)))
 #define do_new_math(A)       ((font_math_params(A) >0) && (font_oldmath(A) == 0) && (math_old_par == 0))
 
-@
-\def\LuaTeX{Lua\TeX}
-
-@ @c
-
 #include "ptexlib.h"
 #include "lua/luatex-api.h"
 
-@ @c
-#define nDEBUG
-
 #define reset_attributes(p,newatt) do { \
     delete_attribute_ref(node_attr(p)); \
     node_attr(p) = newatt;              \
@@ -97,83 +98,160 @@ already apply that shift.
 #define font_MATH_par(a,b) \
   (font_math_params(a)>=b ? font_math_param(a,b) : undefined_math_parameter)
 
-@ here are the math parameters that are font-dependant
+/*tex
+
+    Here are the math parameters that are font-dependant.
 
-@ Before an mlist is converted to an hlist, \TeX\ makes sure that
-the fonts in family~2 have enough parameters to be math-symbol
-fonts, and that the fonts in family~3 have enough parameters to be
-math-extension fonts. The math-symbol parameters are referred to by using the
-following macros, which take a size code as their parameter; for example,
-|num1(cur_size)| gives the value of the |num1| parameter for the current size.
-@^parameters for symbols@>
-@^font parameters@>
+    Before an mlist is converted to an hlist, \TeX\ makes sure that the fonts in
+    family~2 have enough parameters to be math-symbol fonts, and that the fonts
+    in family~3 have enough parameters to be math-extension fonts. The
+    math-symbol parameters are referred to by using the following macros, which
+    take a size code as their parameter; for example, |num1(cur_size)| gives the
+    value of the |num1| parameter for the current size.
+
+*/
 
-@c
 #define total_mathsy_params 22
 #define total_mathex_params 13
 
 #define mathsy(A,B) font_param(fam_fnt(2,A),B)
 
-#define math_x_height(A) mathsy(A,5) /* height of `\.x' */
-#define math_quad(A) mathsy(A,6)     /* \.{18mu} */
-#define num1(A) mathsy(A,8)          /* numerator shift-up in display styles */
-#define num2(A) mathsy(A,9)          /* numerator shift-up in non-display, non-\.{\\atop} */
-#define num3(A) mathsy(A,10)         /* numerator shift-up in non-display \.{\\atop} */
-#define denom1(A) mathsy(A,11)       /* denominator shift-down in display styles */
-#define denom2(A) mathsy(A,12)       /* denominator shift-down in non-display styles */
-#define sup1(A) mathsy(A,13)         /* superscript shift-up in uncramped display style */
-#define sup2(A) mathsy(A,14)         /* superscript shift-up in uncramped non-display */
-#define sup3(A) mathsy(A,15)         /* superscript shift-up in cramped styles */
-#define sub1(A) mathsy(A,16)         /* subscript shift-down if superscript is absent */
-#define sub2(A) mathsy(A,17)         /* subscript shift-down if superscript is present */
-#define sup_drop(A) mathsy(A,18)     /* superscript baseline below top of large box */
-#define sub_drop(A) mathsy(A,19)     /* subscript baseline below bottom of large box */
-#define delim1(A) mathsy(A,20)       /* size of \.{\\atopwithdelims} delimiters in display styles */
-#define delim2(A) mathsy(A,21)       /* size of \.{\\atopwithdelims} delimiters in non-displays */
-#define axis_height(A) mathsy(A,22)  /* height of fraction lines above the baseline */
-
-@ The math-extension parameters have similar macros, but the size code is
-omitted (since it is always |cur_size| when we refer to such parameters).
-@^parameters for symbols@>
-@^font parameters@>
-
-@c
+/*tex height of `\.x' */
+
+#define math_x_height(A) mathsy(A,5)
+
+/*tex \.{18mu} */
+
+#define math_quad(A) mathsy(A,6)
+
+/*tex numerator shift-up in display styles */
+
+#define num1(A) mathsy(A,8)
+
+/*tex numerator shift-up in non-display, non-\.{\\atop} */
+
+#define num2(A) mathsy(A,9)
+
+/*tex numerator shift-up in non-display \.{\\atop} */
+
+#define num3(A) mathsy(A,10)
+
+/*tex denominator shift-down in display styles */
+
+#define denom1(A) mathsy(A,11)
+
+/*tex denominator shift-down in non-display styles */
+
+#define denom2(A) mathsy(A,12)
+
+/*tex superscript shift-up in uncramped display style */
+
+#define sup1(A) mathsy(A,13)
+
+/*tex superscript shift-up in uncramped non-display */
+
+#define sup2(A) mathsy(A,14)
+
+/*tex superscript shift-up in cramped styles */
+
+#define sup3(A) mathsy(A,15)
+
+/*tex subscript shift-down if superscript is absent */
+
+#define sub1(A) mathsy(A,16)
+
+/*tex subscript shift-down if superscript is present */
+
+#define sub2(A) mathsy(A,17)
+
+/*tex superscript baseline below top of large box */
+
+#define sup_drop(A) mathsy(A,18)
+
+/*tex subscript baseline below bottom of large box */
+
+#define sub_drop(A) mathsy(A,19)
+
+/*tex size of \.{\\atopwithdelims} delimiters in display styles */
+
+#define delim1(A) mathsy(A,20)
+
+/*tex size of \.{\\atopwithdelims} delimiters in non-displays */
+
+#define delim2(A) mathsy(A,21)
+
+/*tex height of fraction lines above the baseline */
+
+#define axis_height(A) mathsy(A,22)
+
+/*tex
+
+    The math-extension parameters have similar macros, but the size code is
+    omitted (since it is always |cur_size| when we refer to such parameters).
+
+*/
+
 #define mathex(A,B) font_param(fam_fnt(3,A),B)
-#define default_rule_thickness(A) mathex(A,8)   /* thickness of \.{\\over} bars */
-#define big_op_spacing1(A) mathex(A,9)  /* minimum clearance above a displayed op */
-#define big_op_spacing2(A) mathex(A,10) /* minimum clearance below a displayed op */
-#define big_op_spacing3(A) mathex(A,11) /* minimum baselineskip above displayed op */
-#define big_op_spacing4(A) mathex(A,12) /* minimum baselineskip below displayed op */
-#define big_op_spacing5(A) mathex(A,13) /* padding above and below displayed limits */
 
-@ I (TH) made a bunch of extensions cf. the MATH table in OpenType, but some of
-the MathConstants values have no matching usage in \LuaTeX\ right now.
+/*tex thickness of \.{\\over} bars */
+
+#define default_rule_thickness(A) mathex(A,8)
+
+/*tex minimum clearance above a displayed op */
+
+#define big_op_spacing1(A) mathex(A,9)
+
+/*tex minimum clearance below a displayed op */
+
+#define big_op_spacing2(A) mathex(A,10)
+
+/*tex minimum baselineskip above displayed op */
+
+#define big_op_spacing3(A) mathex(A,11)
+
+/*tex minimum baselineskip below displayed op */
 
-ScriptPercentScaleDown,
-ScriptScriptPercentScaleDown:
-  These should be handled by the macro package, on the engine
-  side there are three separate fonts
+#define big_op_spacing4(A) mathex(A,12)
 
-DelimitedSubFormulaMinHeight:
-  This is perhaps related to word's natural math input? I have
-  no idea what to do about it
+/*tex padding above and below displayed limits */
 
-MathLeading:
-  LuaTeX does not currently handle multi-line displays, and
-  the parameter does not seem to make much sense elsewhere
+#define big_op_spacing5(A) mathex(A,13)
 
-FlattenedAccentBaseHeight:
-  This is based on the 'flac' GSUB feature. It would not be hard
-  to support that, but proper math accent placements cf. MATH
-  needs support for MathTopAccentAttachment table to be
-  implemented first
+/*tex
 
-Also still TODO for OpenType Math:
-  * prescripts
+    \LUATEX makes a bunch of extensions cf. the |MATH| table in \OPENTYPE, but
+    some of the |MathConstants| values have no matching usage in \LUATEX\ right
+    now.
 
-@ this is not really a math parameter at all
+    \startitemize
+
+        \startitem
+            |ScriptPercentScaleDown| |ScriptScriptPercentScaleDown|: These should
+            be handled by the macro package, on the engine side there are three
+            separate fonts.
+        \stopitem
+
+        \startitem
+            |DelimitedSubFormulaMinHeight|: This is perhaps related to word's
+            natural math input? We have no idea what to do about it.
+        \stopitem
+
+        \startitem
+            |MathLeading|: \LUATEX does not currently handle multi-line displays,
+            and the parameter does not seem to make much sense elsewhere.
+        \stopitem
+
+        \startitem
+            |FlattenedAccentBaseHeight|: This is based on the |flac| |GSUB|
+            feature. It would not be hard to support that, but proper math accent
+            placements cf.\ |MATH| needs support for |MathTopAccentAttachment|
+            table to be implemented first.
+        \stopitem
+
+    \stopitemize
+
+*/
 
-@c
 static void math_param_error(const char *param, int style)
 {
     char s[256];
@@ -184,16 +262,11 @@ static void math_param_error(const char *param, int style)
         "the parameter mentioned earlier.",
         NULL
     };
-    snprintf(s, 256, "Math error: parameter \\Umath%s\\%sstyle is not set",
-             param, math_style_names[style]);
+    snprintf(s, 256, "Math error: parameter \\Umath%s\\%sstyle is not set", param, math_style_names[style]);
     tex_error(s, hlp);
-#if 0
-    flush_math();
-#endif
     return;
 }
 
-@ @c
 static scaled accent_base_height(int f)
 {
     scaled a;
@@ -207,11 +280,14 @@ static scaled accent_base_height(int f)
     return a;
 }
 
-@ The non-staticness of this function is for the benefit of |texmath.w|. Watch out,
-this one uses the style! The style and size numbers don't match because we have
-cramped styles.
+/*tex
+
+        The non-staticness of this function is for the benefit of |texmath.w|.
+        Watch out, this one uses the style! The style and size numbers don't
+        match because we have cramped styles.
+
+*/
 
-@c
 scaled get_math_quad_style(int var)
 {
     scaled a = get_math_param(math_param_quad, var);
@@ -223,10 +299,13 @@ scaled get_math_quad_style(int var)
     }
 }
 
-@ For this reason the next one is different because it is called with a size
-specifier instead of a style specifier.
+/*tex
+
+    For this reason the next one is different because it is called with a size
+    specifier instead of a style specifier.
+
+*/
 
-@c
 static scaled math_axis_size(int b)
 {
     scaled a;
@@ -246,7 +325,6 @@ static scaled math_axis_size(int b)
     }
 }
 
-@ @c
 scaled get_math_quad_size(int b)
 {
     int var;
@@ -259,26 +337,32 @@ scaled get_math_quad_size(int b)
     return get_math_param(math_param_quad, var);
 }
 
-@ @c
 static scaled minimum_operator_size(int var)
 {
     scaled a = get_math_param(math_param_operator_size, var);
     return a;
 }
 
-@ Old-style fonts do not define the |radical_rule|. This allows |make_radical| to select
-the backward compatibility code, and it means that we can't raise an error here.
+/*tex
+
+    Old-style fonts do not define the |radical_rule|. This allows |make_radical|
+    to select the backward compatibility code, and it means that we can't raise
+    an error here.
+
+*/
 
-@c
 static scaled radical_rule_par(int var)
 {
     scaled a = get_math_param(math_param_radical_rule, var);
     return a;
 }
 
-@ now follow all the trivial math parameters
+/*tex
+
+    Now follow all the trivial math parameters.
+
+*/
 
-@c
 #define get_math_param_or_error(a,b) do_get_math_param_or_error(a, math_param_##b, #b)
 #define get_math_param_or_zero(a,b) do_get_math_param_or_zero(a, math_param_##b, #b)
 
@@ -301,9 +385,12 @@ static scaled do_get_math_param_or_zero(int var, int param, const char *name)
     return a;
 }
 
-@ A variant on a suggestion on the list based on analysis by UV.
+/*tex
+
+    A variant on a suggestion on the list based on analysis by UV.
+
+*/
 
-@c
 static scaled get_delimiter_height(scaled max_d, scaled max_h, boolean axis) {
     scaled delta, delta1, delta2;
     if (axis) {
@@ -313,7 +400,7 @@ static scaled get_delimiter_height(scaled max_d, scaled max_h, boolean axis) {
     }
     delta1 = max_h + max_d - delta2;
     if (delta2 > delta1) {
-        /* |delta1| is max distance from axis */
+        /*tex |delta1| is max distance from axis */
         delta1 = delta2;
     }
     delta = (delta1 / 500) * delimiter_factor_par;
@@ -325,7 +412,6 @@ static scaled get_delimiter_height(scaled max_d, scaled max_h, boolean axis) {
     }
 }
 
-@ @c
 #define radical_degree_before(a) get_math_param_or_error(a, radical_degree_before)
 #define radical_degree_after(a)  get_math_param_or_error(a, radical_degree_after)
 #define radical_degree_raise(a)  get_math_param_or_error(a, radical_degree_raise)
@@ -359,9 +445,7 @@ static scaled get_delimiter_height(scaled max_d, scaled max_h, boolean axis) {
 #define fraction_num_up(a)       get_math_param_or_error(a, fraction_num_up)
 #define fraction_denom_down(a)   get_math_param_or_error(a, fraction_denom_down)
 #define fraction_del_size_new(a) get_math_param_or_error(a, fraction_del_size)
-/*
-#define fraction_del_size_old(a) get_math_param(a, math_param_fraction_del_size)
-*/
+/*      fraction_del_size_old(a) get_math_param         (a, math_param_fraction_del_size) */
 #define fraction_del_size_old(a) get_math_param_or_error(a, fraction_del_size)
 
 #define skewed_fraction_hgap(a)  get_math_param_or_error(a, skewed_fraction_hgap)
@@ -390,11 +474,11 @@ static scaled get_delimiter_height(scaled max_d, scaled max_h, boolean axis) {
 
 #define space_after_script(a)    get_math_param_or_error(a, space_after_script)
 
-@ @c
 void fixup_math_parameters(int fam_id, int size_id, int f, int lvl)
 {
+    if (is_new_mathfont(f)) {
 
-    if (is_new_mathfont(f)) {   /* fix all known parameters */
+        /*tex Fix all known parameters. */
 
         DEFINE_MATH_PARAMETERS(math_param_quad, size_id,
             font_size(f), lvl);
@@ -632,7 +716,7 @@ void fixup_math_parameters(int fam_id, int size_id, int f, int lvl)
 
     } else if (fam_id == 2 && is_old_mathfont(f, total_mathsy_params)) {
 
-        /* fix old-style |sy| parameters */
+        /*tex Fix old-style |sy| parameters. */
 
         DEFINE_MATH_PARAMETERS(math_param_quad, size_id,
             math_quad(size_id), lvl);
@@ -746,9 +830,11 @@ void fixup_math_parameters(int fam_id, int size_id, int f, int lvl)
         DEFINE_DMATH_PARAMETERS(math_param_sup_sub_bottom_max, size_id,
             (abs(math_x_height(size_id) * 4) / 5), lvl);
 
-        /*
-            The display-size |radical_vgap| is done twice because it needs
-            values from both the sy and the ex font.
+        /*tex
+
+            The display-size |radical_vgap| is done twice because it needs values
+            from both the sy and the ex font.
+
         */
 
         DEFINE_DMATH_PARAMETERS(math_param_radical_vgap, size_id,
@@ -768,7 +854,7 @@ void fixup_math_parameters(int fam_id, int size_id, int f, int lvl)
 
     } else if (fam_id == 3 && is_old_mathfont(f, total_mathex_params)) {
 
-        /* fix old-style |ex| parameters */
+        /*tex Fix old-style |ex| parameters. */
 
         DEFINE_MATH_PARAMETERS(math_param_overbar_kern, size_id,
             default_rule_thickness(size_id), lvl);
@@ -853,9 +939,12 @@ void fixup_math_parameters(int fam_id, int size_id, int f, int lvl)
         DEFINE_DMATH_PARAMETERS(math_param_subsup_vgap, size_id,
             4 * default_rule_thickness(size_id), lvl);
 
-        /*
-            All of the |space_after_script|s are done in |finalize_math_parameters|
-            because the \.{\\scriptspace} may have been altered by the user
+        /*tex
+
+            All of the |space_after_script|s are done in
+            |finalize_math_parameters| because the \.{\\scriptspace} may have
+            been altered by the user.
+
         */
 
         DEFINE_MATH_PARAMETERS(math_param_connector_overlap_min, size_id,
@@ -880,9 +969,11 @@ void fixup_math_parameters(int fam_id, int size_id, int f, int lvl)
         DEFINE_DMATH_PARAMETERS(math_param_over_delimiter_bgap, size_id,
             big_op_spacing3(size_id), lvl);
 
-        /*
-            The display-size |radical_vgap| is done twice because it needs
-            values from both the sy and the ex font.
+        /*tex
+
+            The display-size |radical_vgap| is done twice because it needs values
+            from both the sy and the ex font.
+
         */
 
         DEFINE_DMATH_PARAMETERS(math_param_radical_vgap, size_id,
@@ -891,10 +982,13 @@ void fixup_math_parameters(int fam_id, int size_id, int f, int lvl)
     }
 }
 
-@ This needs to be called just at the start of |mlist_to_hlist|, for
-backward compatibility with \.{\\scriptspace}.
+/*tex
+
+    This needs to be called just at the start of |mlist_to_hlist|, for backward
+    compatibility with \.{\\scriptspace}.
+
+*/
 
-@c
 static void finalize_math_parameters(void)
 {
     int saved_trace = tracing_assigns_par;
@@ -920,16 +1014,19 @@ static void finalize_math_parameters(void)
     tracing_assigns_par = saved_trace;
 }
 
-@ In order to convert mlists to hlists, i.e., noads to nodes, we need several
-subroutines that are conveniently dealt with now.
+/*tex
+
+    In order to convert mlists to hlists, i.e., noads to nodes, we need several
+    subroutines that are conveniently dealt with now.
+
+    Let us first introduce the macros that make it easy to get at the parameters
+    and other font information. A size code, which is a multiple of 256, is added
+    to a family number to get an index into the table of internal font numbers
+    for each combination of family and size. (Be alert: Size codes get larger as
+    the type gets smaller.)
 
-Let us first introduce the macros that make it easy to get at the parameters and
-other font information. A size code, which is a multiple of 256, is added to a
-family number to get an index into the table of internal font numbers
-for each combination of family and size.  (Be alert: Size codes get
-larger as the type gets smaller.)
+*/
 
-@c
 static const char *math_size_string(int s)
 {
     if (s == text_size)
@@ -940,10 +1037,13 @@ static const char *math_size_string(int s)
         return "scriptscriptfont";
 }
 
-@ When the style changes, the following piece of program computes associated
-information:
+/*tex
+
+    When the style changes, the following piece of program computes associated
+    information:
+
+*/
 
-@c
 #define setup_cur_size(a) do { \
     if (a==script_style || a==cramped_script_style) \
         cur_size = script_size; \
@@ -954,8 +1054,12 @@ information:
 } while (0)
 
 
-@ a simple routine that creates a flat copy of a nucleus
-@c
+/*tex
+
+    A simple routine that creates a flat copy of a nucleus.
+
+*/
+
 static pointer math_clone(pointer q)
 {
     pointer x;
@@ -972,14 +1076,17 @@ static pointer math_clone(pointer q)
     return x;
 }
 
-@ Here is a function that returns a pointer to a rule node having a given
-  thickness |t|. The rule will extend horizontally to the boundary of the vlist
-  that eventually contains it.
+/*tex
+
+    Here is a function that returns a pointer to a rule node having a given
+    thickness |t|. The rule will extend horizontally to the boundary of the vlist
+    that eventually contains it.
+
+*/
 
-@c
 static pointer do_fraction_rule(scaled t, pointer att, halfword some_rule, halfword cur_size, halfword cur_fam)
 {
-    pointer p;                  /* the new node */
+    pointer p;
     if (math_rules_mode_par) {
         p = new_rule(some_rule);
         rule_math_size(p) = cur_size;
@@ -994,14 +1101,17 @@ static pointer do_fraction_rule(scaled t, pointer att, halfword some_rule, halfw
     return p;
 }
 
-@ The |overbar| function returns a pointer to a vlist box that consists of
-  a given box |b|, above which has been placed a kern of height |k| under a
-  fraction rule of thickness |t| under additional space of height |ht|.
+/*tex
+
+    The |overbar| function returns a pointer to a vlist box that consists of a
+    given box |b|, above which has been placed a kern of height |k| under a
+    fraction rule of thickness |t| under additional space of height |ht|.
+
+*/
 
-@c
 static pointer overbar(pointer b, scaled k, scaled t, scaled ht, pointer att, halfword index, halfword cur_size, halfword cur_fam)
 {
-    pointer p, q;               /* nodes being constructed */
+    pointer p, q;
     p = new_kern(k);
     reset_attributes(p, att);
     couple_nodes(p,b);
@@ -1015,16 +1125,20 @@ static pointer overbar(pointer b, scaled k, scaled t, scaled ht, pointer att, ha
     return q;
 }
 
-@ Here is a subroutine that creates a new box, whose list contains a
-single character, and whose width includes the italic correction for
-that character. The height or depth of the box will be negative, if
-the height or depth of the character is negative; thus, this routine
-may deliver a slightly different result than |hpack| would produce.
+/*tex
+
+    Here is a subroutine that creates a new box, whose list contains a single
+    character, and whose width includes the italic correction for that character.
+    The height or depth of the box will be negative, if the height or depth of
+    the character is negative; thus, this routine may deliver a slightly
+    different result than |hpack| would produce.
+
+*/
 
-@c
 static pointer char_box(internal_font_number f, int c, pointer bb)
 {
-    pointer b, p; /* the new box and its character node */
+    /*tex The new box and its character node. */
+    pointer b, p;
     b = new_null_box();
     if (do_new_math(f))
         width(b) = char_width(f, c);
@@ -1039,24 +1153,31 @@ static pointer char_box(internal_font_number f, int c, pointer bb)
     return b;
 }
 
-@ Another handy subroutine computes the height plus depth of
-  a given character:
+/*tex
+
+    Another handy subroutine computes the height plus depth of a given character:
+
+*/
 
-@c
 static scaled height_plus_depth(internal_font_number f, int c)
 {
     return (char_height(f, c) + char_depth(f, c));
 }
 
-@ When we build an extensible character, it's handy to have the
-  following subroutine, which puts a given character on top
-  of the characters already in box |b|:
+/*tex
+
+    When we build an extensible character, it's handy to have the following
+    subroutine, which puts a given character on top of the characters already in
+    box |b|:
+
+*/
 
-@c
 static scaled stack_into_box(pointer b, internal_font_number f, int c)
 {
-    pointer p, q; /* new node placed into |b| */
-    p = char_box(f, c, node_attr(b)); /* italic gets added to width */
+    /*tex New node placed into |b|: */
+    pointer p, q;
+    /*tex Italic gets added to width. */
+    p = char_box(f, c, node_attr(b));
     if (type(b) == vlist_node) {
         try_couple_nodes(p,list_ptr(b));
         list_ptr(b) = p;
@@ -1085,7 +1206,9 @@ static void stack_glue_into_box(pointer b, scaled min, scaled max) {
     halfword p = new_glue(zero_glue);
     width(p) = min;
     stretch(p) = max - min;
-    reset_attributes(p, node_attr(b));
+    if (node_attr(b) != null) {
+        reset_attributes(p, node_attr(b));
+    }
     if (type(b) == vlist_node) {
         try_couple_nodes(p,list_ptr(b));
         list_ptr(b) = p;
@@ -1094,59 +1217,96 @@ static void stack_glue_into_box(pointer b, scaled min, scaled max) {
         if (q == null) {
             list_ptr(b) = p;
         } else {
-            while (vlink(q) != null)
+            while (vlink(q) != null) {
                 q = vlink(q);
+            }
             couple_nodes(q,p);
         }
     }
 }
 
-@ \TeX's most important routine for dealing with formulas is called
- |mlist_to_hlist|.  After a formula has been scanned and represented
- as an mlist, this routine converts it to an hlist that can be placed
- into a box or incorporated into the text of a paragraph.  The
- explicit parameter |cur_mlist| points to the first node or noad in
- the given mlist (and it might be |null|); the parameter |penalties|
- is |true| if penalty nodes for potential line breaks are to be
- inserted into the resulting hlist, the parameter |cur_style| is a
- style code.  After |mlist_to_hlist| has acted, |vlink(temp_head)|
- points to the translated hlist.
-
- Since mlists can be inside mlists, the procedure is recursive. And since this
- is not part of \TeX's inner loop, the program has been written in a manner
- that stresses compactness over efficiency.
-@^recursion@>
-
-@c
-int cur_size; /* size code corresponding to |cur_style|  */
-
-@ @c
-static pointer get_delim_box(pointer q, extinfo * ext, internal_font_number f, scaled v,
-                             pointer att, int cur_style, int boxtype)
+/*tex
+
+    \TeX's most important routine for dealing with formulas is called
+    |mlist_to_hlist|. After a formula has been scanned and represented as an
+    mlist, this routine converts it to an hlist that can be placed into a box or
+    incorporated into the text of a paragraph. The explicit parameter |cur_mlist|
+    points to the first node or noad in the given mlist (and it might be |null|);
+    the parameter |penalties| is |true| if penalty nodes for potential line
+    breaks are to be inserted into the resulting hlist, the parameter |cur_style|
+    is a style code. After |mlist_to_hlist| has acted, |vlink(temp_head)| points
+    to the translated hlist.
+
+    Since mlists can be inside mlists, the procedure is recursive. And since this
+    is not part of \TeX's inner loop, the program has been written in a manner
+    that stresses compactness over efficiency.
+
+*/
+
+/*tex Size code corresponding to |cur_style|:  */
+
+int cur_size;
+
+static pointer get_delim_box(internal_font_number fnt, halfword chr, scaled v, scaled min_overlap, int horizontal, halfword att)
 {
-    pointer b;                  /* new box */
-    scaled b_max;               /* natural (maximum) size of the stack */
-    scaled s_max;               /* amount of possible shrink in the stack */
+    int callback_id = callback_defined(make_extensible_callback);
+    if (callback_id > 0) {
+        /*tex
+            This call is not optimized as it hardly makes sense to use it ... special
+            and a it of feature creep too.
+        */
+        halfword b = null;
+        run_callback(callback_id, "ddddbN->N",fnt,chr,v,min_overlap,horizontal,att,&b);
+        if (b == null) {
+            /*tex
+                We see this as a signal to do it the \TEX\ way.
+            */
+        } else if (type(b) == hlist_node || type(b) == vlist_node) {
+            return b;
+        } else {
+            formatted_error("fonts","invalid extensible character %i created for font %i, [h|v]list expected",chr,fnt);
+        }
+    }
+    return make_extensible(fnt, chr, v, min_overlap, horizontal, att);
+}
+
+pointer make_extensible(internal_font_number fnt, halfword chr, scaled v, scaled min_overlap, int horizontal, halfword att)
+{
+    /*tex new box */
+    pointer b;
+    /*tex natural (maximum) size of the stack */
+    scaled b_max;
+    /*tex amount of possible shrink in the stack */
+    scaled s_max;
     extinfo *cur;
-    scaled min_overlap, prev_overlap;
-    int i;                      /* a temporary counter number of extensible pieces */
-    int with_extenders;         /* number of times to repeat each repeatable item in |ext| */
+    extinfo *ext;
+    scaled prev_overlap;
+    /*tex a temporary counter number of extensible pieces */
+    int i;
+    /*tex number of times to repeat each repeatable item in |ext| */
+    int with_extenders;
     int num_extenders, num_normal;
     scaled a, c, d;
-
-    assert(ext != NULL);
     b = new_null_box();
-    type(b) = (quarterword) boxtype;
-    reset_attributes(b, att);
-    min_overlap = connector_overlap_min(cur_style);
-    assert(min_overlap >= 0);
     with_extenders = -1;
     num_extenders = 0;
     num_normal = 0;
-
+    if (min_overlap < 0) {
+        min_overlap = 0;
+    }
+    if (horizontal) {
+        type(b) = (quarterword) hlist_node;
+        ext = get_charinfo_hor_variants(char_info(fnt,chr));
+    } else {
+        type(b) = (quarterword) vlist_node;
+        ext = get_charinfo_vert_variants(char_info(fnt,chr));
+    }
+    if (att != null) {
+        reset_attributes(b,att);
+    }
     cur = ext;
     while (cur != NULL) {
-        if (!char_exists(f, cur->glyph)) {
+        if (!char_exists(fnt, cur->glyph)) {
             const char *hlp[] = {
                 "Each glyph part in an extensible item should exist in the font.",
                 "I will give up trying to find a suitable size for now. Fix your font!",
@@ -1160,7 +1320,7 @@ static pointer get_delim_box(pointer q, extinfo * ext, internal_font_number f, s
             num_extenders++;
         else
             num_normal++;
-        /* no negative overlaps or advances are allowed */
+        /*tex No negative overlaps or advances are allowed. */
         if (cur->start_overlap < 0 || cur->end_overlap < 0 || cur->advance < 0) {
             const char *hlp[] = {
                 "All measurements in extensible items should be positive.",
@@ -1190,16 +1350,16 @@ static pointer get_delim_box(pointer q, extinfo * ext, internal_font_number f, s
         num_normal = 1;
         num_extenders--;
     }
-    /*
+    /*tex
+
         |ext| holds a linked list of numerous items that may or may not be
         repeatable. For the total height, we have to figure out how many items
         are needed to create a stack of at least |v|.
 
-        The next |while| loop does  that. It has two goals: it finds out
-        the natural height |b_max|  of the all the parts needed to reach
-        at least |v|,  and it sets |with_extenders| to the number of times
-        each of the repeatable items in |ext| has to be repeated to reach
-        that height.
+        The next |while| loop does that. It has two goals: it finds out the
+        natural height |b_max| of the all the parts needed to reach at least |v|,
+        and it sets |with_extenders| to the number of times each of the
+        repeatable items in |ext| has to be repeated to reach that height.
 
     */
     cur = ext;
@@ -1217,12 +1377,15 @@ static pointer get_delim_box(pointer q, extinfo * ext, internal_font_number f, s
                     c = prev_overlap;
                 a = cur->advance;
                 if (a == 0) {
-                    /* for tfm fonts */
-                    if (boxtype == vlist_node)
-                        a = height_plus_depth(f, cur->glyph);
-                    else
-                        a = char_width(f, cur->glyph);
-                    assert(a >= 0);
+                    /*tex for tfm fonts */
+                    if (horizontal) {
+                        a = char_width(fnt, cur->glyph);
+                    } else {
+                        a = height_plus_depth(fnt, cur->glyph);
+                    }
+                    if (a < 0) {
+                        formatted_error("fonts","bad extensible character %i in font %i",chr,fnt);
+                    }
                 }
                 b_max += a - c;
                 prev_overlap = cur->end_overlap;
@@ -1236,12 +1399,15 @@ static pointer get_delim_box(pointer q, extinfo * ext, internal_font_number f, s
                         c = prev_overlap;
                     a = cur->advance;
                     if (a == 0) {
-                        /* for tfm fonts */
-                        if (boxtype == vlist_node)
-                            a = height_plus_depth(f, cur->glyph);
-                        else
-                            a = char_width(f, cur->glyph);
-                        assert(a >= 0);
+                        /*tex for tfm fonts */
+                        if (horizontal) {
+                            a = char_width(fnt, cur->glyph);
+                        } else {
+                            a = height_plus_depth(fnt, cur->glyph);
+                        }
+                        if (a < 0) {
+                            formatted_error("fonts","bad extensible character %i in font %i",chr,fnt);
+                        }
                     }
                     b_max += a - c;
                     prev_overlap = cur->end_overlap;
@@ -1250,10 +1416,11 @@ static pointer get_delim_box(pointer q, extinfo * ext, internal_font_number f, s
             }
         }
     }
+    /*tex
+
+        Assemble box using |with_extenders| copies of each extender, with
+        appropriate glue wherever an overlap occurs.
 
-    /*
-        assemble box using |with_extenders| copies of each extender, with
-        appropriate glue wherever an overlap occurs
     */
     prev_overlap = 0;
     b_max = 0;
@@ -1271,7 +1438,7 @@ static pointer get_delim_box(pointer q, extinfo * ext, internal_font_number f, s
                 s_max += (-c) - (-d);
                 b_max -= d;
             }
-            b_max += stack_into_box(b, f, cur->glyph);
+            b_max += stack_into_box(b, fnt, cur->glyph);
             prev_overlap = cur->end_overlap;
             i--;
         } else {
@@ -1288,19 +1455,17 @@ static pointer get_delim_box(pointer q, extinfo * ext, internal_font_number f, s
                     s_max += (-c) - (-d);
                     b_max -= d;
                 }
-                b_max += stack_into_box(b, f, cur->glyph);
+                b_max += stack_into_box(b, fnt, cur->glyph);
                 prev_overlap = cur->end_overlap;
                 i--;
             }
         }
     }
-
-    /* set glue so as to stretch the connections if needed */
-
+    /*tex Set glue so as to stretch the connections if needed. */
     d = 0;
     if (v > b_max && s_max > 0) {
         d = v-b_max;
-        /* don't stretch more than |s_max| */
+        /*tex Don't stretch more than |s_max|. */
         if (d > s_max)
             d = s_max;
         glue_order(b) = normal;
@@ -1308,32 +1473,33 @@ static pointer get_delim_box(pointer q, extinfo * ext, internal_font_number f, s
         glue_set(b) = unfloat(d/(float) s_max);
         b_max += d;
     }
-
-    if (boxtype == vlist_node) {
-        height(b) = b_max;
-    } else {
+    if (horizontal) {
         width(b) = b_max;
+    } else {
+        height(b) = b_max;
     }
-
     return b;
 }
 
-@ The |var_delimiter| function, which finds or constructs a sufficiently
-  large delimiter, is the most interesting of the auxiliary functions that
-  currently concern us. Given a pointer |d| to a delimiter field in some noad,
-  together with a size code |s| and a vertical distance |v|, this function
-  returns a pointer to a box that contains the smallest variant of |d| whose
-  height plus depth is |v| or more. (And if no variant is large enough, it
-  returns the largest available variant.) In particular, this routine will
-  construct arbitrarily large delimiters from extensible components, if
-  |d| leads to such characters.
-
-  The value returned is a box whose |shift_amount| has been set so that
-  the box is vertically centered with respect to the axis in the given size.
-  If a built-up symbol is returned, the height of the box before shifting
-  will be the height of its topmost component.
-
-@c
+/*tex
+
+    The |var_delimiter| function, which finds or constructs a sufficiently large
+    delimiter, is the most interesting of the auxiliary functions that currently
+    concern us. Given a pointer |d| to a delimiter field in some noad, together
+    with a size code |s| and a vertical distance |v|, this function returns a
+    pointer to a box that contains the smallest variant of |d| whose height plus
+    depth is |v| or more. (And if no variant is large enough, it returns the
+    largest available variant.) In particular, this routine will construct
+    arbitrarily large delimiters from extensible components, if |d| leads to such
+    characters.
+
+    The value returned is a box whose |shift_amount| has been set so that the box
+    is vertically centered with respect to the axis in the given size. If a
+    built-up symbol is returned, the height of the box before shifting will be
+    the height of its topmost component.
+
+*/
+
 static void endless_loop_error(internal_font_number g, int y)
 {
     char s[256];
@@ -1343,23 +1509,31 @@ static void endless_loop_error(internal_font_number g, int y)
         "I will jump out of the loop all by myself now. Fix your font!",
         NULL
     };
-    snprintf(s, 256, "Math error: endless loop in charlist (U+%04x in %s)",
-             (int) y, font_name(g));
+    snprintf(s, 256, "Math error: endless loop in charlist (U+%04x in %s)", (int) y, font_name(g));
     tex_error(s, hlp);
 }
 
 static pointer do_delimiter(pointer q, pointer d, int s, scaled v, boolean flat, int cur_style, boolean shift, boolean *stack, scaled *delta, int *same)
 {
-    pointer b;                     /* the box that will be constructed */
-    internal_font_number f, g;     /* best-so-far and tentative font codes */
-    int c, i, x, y;                /* best-so-far and tentative character codes */
-    scaled u;                      /* height-plus-depth of a tentative character */
-    scaled w = 0;                  /* largest height-plus-depth so far */
-    int z;                         /* runs through font family members */
-    boolean large_attempt = false; /* are we trying the ``large'' variant? */
-    pointer att = null;            /* to save the current attribute list */
+    /*tex the box that will be constructed */
+    pointer b;
+    /*tex best-so-far and tentative font codes */
+    internal_font_number f, g;
+    /*tex best-so-far and tentative character codes */
+    int c, i, x, y;
+    /*tex height-plus-depth of a tentative character */
+    scaled u;
+    /*tex largest height-plus-depth so far */
+    scaled w = 0;
+    /*tex runs through font family members */
+    int z;
+    /*tex are we trying the ``large'' variant? */
+    boolean large_attempt = false;
+    /*tex to save the current attribute list */
+    pointer att = null;
     int emas = 0 ;
     boolean do_parts = false;
+    boolean parts_done = false;
     extinfo *ext;
     f = null_font;
     c = 0;
@@ -1373,10 +1547,12 @@ static pointer do_delimiter(pointer q, pointer d, int s, scaled v, boolean flat,
         same = 0;
     }
     while (true) {
-        /*
-            The search process is complicated slightly by the facts that some of the
-            characters might not be present in some of the fonts, and they might not
-            be probed in increasing order of height.
+        /*tex
+
+            The search process is complicated slightly by the facts that some of
+            the characters might not be present in some of the fonts, and they
+            might not be probed in increasing order of height.
+
         */
         if ((z != 0) || (x != 0)) {
             g = fam_fnt(z, s);
@@ -1403,7 +1579,6 @@ static pointer do_delimiter(pointer q, pointer d, int s, scaled v, boolean flat,
                         goto FOUND;
                     }
                     if (i > 10000) {
-                        /* endless loop */
                         endless_loop_error(g, y);
                         goto FOUND;
                     }
@@ -1414,8 +1589,10 @@ static pointer do_delimiter(pointer q, pointer d, int s, scaled v, boolean flat,
                 }
             }
         }
-        if (large_attempt)
-            goto FOUND; /* there were none large enough */
+        if (large_attempt) {
+            /*tex There were none large enough. */
+            goto FOUND;
+        }
         large_attempt = true;
         z = large_fam(d);
         x = large_char(d);
@@ -1427,17 +1604,20 @@ static pointer do_delimiter(pointer q, pointer d, int s, scaled v, boolean flat,
         flush_node(d);
     }
     if (f != null_font) {
-        /*
-            When the following code is executed, |do_parts| will be true
-            if a built-up symbol is supposed to be returned.
+        /*tex
+
+            When the following code is executed, |do_parts| will be true if a
+            built-up symbol is supposed to be returned.
+
         */
         ext = NULL;
         if ((do_parts) && ((!flat && (ext = get_charinfo_vert_variants(char_info(f,c))) != NULL)
                        ||  ( flat && (ext = get_charinfo_hor_variants (char_info(f,c))) != NULL))) {
+            parts_done = true;
             if (flat) {
-                b = get_delim_box(d, ext, f, v, att, cur_style, hlist_node);
+                b = get_delim_box(f, c, v, connector_overlap_min(cur_style), 1, att);
             } else {
-                b = get_delim_box(d, ext, f, v, att, cur_style, vlist_node);
+                b = get_delim_box(f, c, v, connector_overlap_min(cur_style), 0, att);
             }
             if (delta != NULL) {
                 if (do_new_math(f)) {
@@ -1449,16 +1629,18 @@ static pointer do_delimiter(pointer q, pointer d, int s, scaled v, boolean flat,
             if (stack != NULL)
                 *stack = true ;
         } else {
+            parts_done = false;
             if (same != NULL && x == c) {
                 *same = emas;
             }
             b = char_box(f, c, att);
             if (!do_new_math(f)) {
-                /* italic gets added to width */
+                /*tex Italic gets added to width. */
                 width(b) += char_italic(f, c);
             }
             if (delta != NULL) {
-                *delta = char_italic(f, c); /* was historically (f, x) */
+                /*tex This used to be (f, x). */
+                *delta = char_italic(f, c);
             }
             if (stack != NULL)
                 *stack = false ;
@@ -1469,7 +1651,7 @@ static pointer do_delimiter(pointer q, pointer d, int s, scaled v, boolean flat,
         if (flat) {
             width(b) = 0;
         } else {
-            /* use this width if no delimiter was found */
+            /*tex Use this width if no delimiter was found. */
             width(b) = null_delimiter_space_par;
         }
         if (delta != NULL) {
@@ -1479,38 +1661,54 @@ static pointer do_delimiter(pointer q, pointer d, int s, scaled v, boolean flat,
             *stack = false ;
     }
     if (!flat) {
-        if (emas == 0 || ! delimitermodenoshift) {
-            /* vertical variant */
-            shift_amount(b) = half(height(b) - depth(b));
-            if (shift) {
-                shift_amount(b) -= math_axis_size(s);
-            }
+        /*tex when emas ~= 0 then we have a non scaled character */
+        if (emas != 0 && delimitermodesamenos) {
+            /*tex same character and no shift when same forced */
+            goto DONE;
+        }
+        if (! parts_done && delimitermodecharnos) {
+            /*tex same character and no shift when same forced */
+            goto DONE;
+        }
+        if (delimitermodenoshift) {
+            /*tex no shift forced */
+            goto DONE;
+        }
+        /*tex vertical variant */
+        shift_amount(b) = half(height(b) - depth(b));
+        if (shift) {
+            shift_amount(b) -= math_axis_size(s);
         }
     }
+    DONE:
     delete_attribute_ref(att);
     return b;
 }
 
-@ The next subroutine is much simpler; it is used for numerators and
-denominators of fractions as well as for displayed operators and
-their limits above and below. It takes a given box~|b| and
-changes it so that the new box is centered in a box of width~|w|.
-The centering is done by putting \.{\\hss} glue at the left and right
-of the list inside |b|, then packaging the new box; thus, the
-actual box might not really be centered, if it already contains
-infinite glue.
+/*tex
+
+    The next subroutine is much simpler; it is used for numerators and
+    denominators of fractions as well as for displayed operators and their limits
+    above and below. It takes a given box~|b| and changes it so that the new box
+    is centered in a box of width~|w|. The centering is done by putting \.{\\hss}
+    glue at the left and right of the list inside |b|, then packaging the new
+    box; thus, the actual box might not really be centered, if it already
+    contains infinite glue.
+
+    The given box might contain a single character whose italic correction has
+    been added to the width of the box; in this case a compensating kern is
+    inserted.
 
-The given box might contain a single character whose italic correction
-has been added to the width of the box; in this case a compensating
-kern is inserted.
+*/
 
-@c
 static pointer rebox(pointer b, scaled w)
 {
-    pointer p, q, r, att;       /* temporary registers for list manipulation */
-    internal_font_number f;     /* font in a one-character box */
-    scaled v;                   /* width of a character without italic correction */
-
+    /*tex temporary registers for list manipulation */
+    pointer p, q, r, att;
+    /*tex font in a one-character box */
+    internal_font_number f;
+    /*tex width of a character without italic correction */
+    scaled v;
     if ((width(b) != w) && (list_ptr(b) != null)) {
         if (type(b) == vlist_node) {
             p = hpack(b, 0, additional, -1);
@@ -1549,23 +1747,30 @@ static pointer rebox(pointer b, scaled w)
     }
 }
 
-@ Here is a subroutine that creates a new glue specification from another
-one that is expressed in `\.{mu}', given the value of the math unit.
+/*tex
+
+    Here is a subroutine that creates a new glue specification from another one
+    that is expressed in `\.{mu}', given the value of the math unit.
+
+*/
 
-@c
 #define mu_mult(A) mult_and_add(n,(A),xn_over_d((A),f,unity),max_dimen)
 
 static pointer math_glue(pointer g, scaled m)
 {
-    int n = x_over_n(m, unity); /* integer part of |m| */
-    scaled f = tex_remainder;   /* fraction part of |m| */
-    pointer p;                  /* the new glue specification */
+    /*tex integer part of |m| */
+    int n = x_over_n(m, unity);
+    /*tex fraction part of |m| */
+    scaled f = tex_remainder;
+    /*tex the new glue specification */
+    pointer p;
     if (f < 0) {
         decr(n);
         f = f + unity;
     }
     p = new_node(glue_node, 0);
-    width(p) = mu_mult(width(g)); /* convert \.{mu} to \.{pt} */
+    /* convert \.{mu} to \.{pt} */
+    width(p) = mu_mult(width(g));
     stretch_order(p) = stretch_order(g);
     if (stretch_order(p) == normal)
         stretch(p) = mu_mult(stretch(g));
@@ -1581,13 +1786,16 @@ static pointer math_glue(pointer g, scaled m)
 
 static void math_glue_to_glue(pointer p, scaled m)
 {
-    int n = x_over_n(m, unity); /* integer part of |m| */
-    scaled f = tex_remainder;   /* fraction part of |m| */
+    /*tex integer part of |m| */
+    int n = x_over_n(m, unity);
+    /*tex fraction part of |m| */
+    scaled f = tex_remainder;
     if (f < 0) {
         decr(n);
         f = f + unity;
     }
-    width(p) = mu_mult(width(p)); /* convert \.{mu} to \.{pt} */
+    /* convert \.{mu} to \.{pt} */
+    width(p) = mu_mult(width(p));
     if (stretch_order(p) == normal)
         stretch(p) = mu_mult(stretch(p));
     if (shrink_order(p) == normal)
@@ -1595,14 +1803,18 @@ static void math_glue_to_glue(pointer p, scaled m)
     subtype(p) = normal;
 }
 
-@ The |math_kern| subroutine removes |mu_glue| from a kern node, given
-the value of the math unit.
+/*tex
+
+    The |math_kern| subroutine removes |mu_glue| from a kern node, given the
+    value of the math unit.
 
-@c
+*/
 static void math_kern(pointer p, scaled m)
 {
-    int n;    /* integer part of |m| */
-    scaled f; /* fraction part of |m| */
+    /*tex integer part of |m| */
+    int n;
+    /*tex fraction part of |m| */
+    scaled f;
     if (subtype(p) == mu_glue) {
         n = x_over_n(m, unity);
         f = tex_remainder;
@@ -1611,15 +1823,15 @@ static void math_kern(pointer p, scaled m)
             f = f + unity;
         }
         width(p) = mu_mult(width(p));
-        subtype(p) = italic_kern; /* this is weird, it's not a italic but explicit_kern */
+        /* this is weird, it's not a italic but explicit_kern */
+        subtype(p) = italic_kern;
     }
 }
 
-@ @c
 void run_mlist_to_hlist(halfword p, boolean penalties, int mstyle)
 {
     int callback_id;
-    int a, sfix;
+    int a, sfix, i;
     if (p == null) {
         vlink(temp_head) = null;
         return;
@@ -1636,18 +1848,16 @@ void run_mlist_to_hlist(halfword p, boolean penalties, int mstyle)
         nodelist_to_lua(Luas, p);
         lua_push_math_style_name(Luas, mstyle);
         lua_pushboolean(Luas, penalties);
-        if (lua_pcall(Luas, 3, 1, 0) != 0) {            /* 3 args, 1 result */
-            char errmsg[256]; /* temp hack ... we will have a formatted error */
-            snprintf(errmsg, 255, "error: %s\n", lua_tostring(Luas, -1));
-            errmsg[255]='\0';
+        if ((i=lua_pcall(Luas, 3, 1, 0)) != 0) {
+            formatted_warning("mlist to hlist","error: %s",lua_tostring(Luas, -1));
             lua_settop(Luas, sfix);
-            normal_error("mlist to hlist",errmsg); /* to be done */
+            luatex_error(Luas, (i == LUA_ERRRUN ? 0 : 1));
             return;
         }
-        a = nodelist_from_lua(Luas);
+        a = nodelist_from_lua(Luas,-1);
         /* alink(vlink(a)) = null; */
-        lua_settop(Luas, sfix);
         vlink(temp_head) = a;
+        lua_settop(Luas, sfix);
     } else if (callback_id == 0) {
         mlist_to_hlist(p, penalties, mstyle);
     } else {
@@ -1655,22 +1865,27 @@ void run_mlist_to_hlist(halfword p, boolean penalties, int mstyle)
     }
 }
 
-@ The recursion in |mlist_to_hlist| is due primarily to a subroutine
-called |clean_box| that puts a given noad field into a box using a given
-math style; |mlist_to_hlist| can call |clean_box|, which can call
-|mlist_to_hlist|.
-@^recursion@>
+/*tex
+
+    The recursion in |mlist_to_hlist| is due primarily to a subroutine called
+    |clean_box| that puts a given noad field into a box using a given math style;
+    |mlist_to_hlist| can call |clean_box|, which can call |mlist_to_hlist|.
 
-The box returned by |clean_box| is ``clean'' in the
-sense that its |shift_amount| is zero.
+    The box returned by |clean_box| is ``clean'' in the sense that its
+    |shift_amount| is zero.
+
+*/
 
-@c
 static pointer clean_box(pointer p, int s, int cur_style)
 {
-    pointer q;            /* beginning of a list to be boxed */
-    pointer x;            /* box to be returned */
-    pointer r;            /* temporary pointer */
-    pointer mlist = null; /* beginning of mlist to be translated */
+    /*tex beginning of a list to be boxed */
+    pointer q;
+    /*tex box to be returned */
+    pointer x;
+    /*tex temporary pointer */
+    pointer r;
+    /*tex beginning of mlist to be translated */
+    pointer mlist = null;
     switch (type(p)) {
         case math_char_node:
             mlist = new_noad();
@@ -1689,18 +1904,20 @@ static pointer clean_box(pointer p, int s, int cur_style)
             goto FOUND;
     }
     mlist_to_hlist(mlist, false, s);
-    q = vlink(temp_head); /* recursive call */
+    /*tex recursive call */
+    q = vlink(temp_head);
     setup_cur_size(cur_style);
   FOUND:
     if (is_char_node(q) || (q == null))
         x = hpack(q, 0, additional, -1);
     else if ((vlink(q) == null) && (type(q) <= vlist_node) && (shift_amount(q) == 0))
-        x = q; /* it's already clean */
+        /*tex It's already clean. */
+        x = q;
     else
         x = hpack(q, 0, additional, -1);
     if (x != q && q != null)
         reset_attributes(x, node_attr(q));
-    /* Here we save memory space in a common case. */
+    /*tex Here we save memory space in a common case. */
     q = list_ptr(x);
     if (is_char_node(q)) {
         r = vlink(q);
@@ -1708,7 +1925,7 @@ static pointer clean_box(pointer p, int s, int cur_style)
             if (vlink(r) == null) {
                 if (!is_char_node(r)) {
                     if (type(r) == kern_node) {
-                        /* unneeded italic correction */
+                        /*tex Unneeded italic correction. */
                         flush_node(r);
                         vlink(q) = null;
                     }
@@ -1719,22 +1936,30 @@ static pointer clean_box(pointer p, int s, int cur_style)
     return x;
 }
 
-@ It is convenient to have a procedure that converts a |math_char|
-field to an ``unpacked'' form. The |fetch| routine sets |cur_f| and |cur_c|
-to the font code and character code of a given noad field.
-It also takes care of issuing error messages for
-nonexistent characters; in such cases, |char_exists(cur_f,cur_c)| will be |false|
-after |fetch| has acted, and the field will also have been reset to |null|.
+/*tex
 
-The outputs of |fetch| are placed in global variables.
+    It is convenient to have a procedure that converts a |math_char| field to an
+    ``unpacked'' form. The |fetch| routine sets |cur_f| and |cur_c| to the font
+    code and character code of a given noad field. It also takes care of issuing
+    error messages for nonexistent characters; in such cases,
+    |char_exists(cur_f,cur_c)| will be |false| after |fetch| has acted, and the
+    field will also have been reset to |null|.
 
-@c
-internal_font_number cur_f; /* the |font| field of a |math_char| */
-int cur_c;                  /* the |character| field of a |math_char| */
+    The outputs of |fetch| are placed in global variables.
 
-@ Here we unpack the |math_char| field |a|.
+*/
+
+/*tex the |font| field of a |math_char| */
+
+internal_font_number cur_f;
+
+/*tex the |character| field of a |math_char| */
 
-@c static void fetch(pointer a)
+int cur_c;
+
+/*tex Here we unpack the |math_char| field |a|. */
+
+static void fetch(pointer a)
 {
     cur_c = math_character(a);
     cur_f = fam_fnt(math_fam(a), cur_size);
@@ -1757,75 +1982,125 @@ int cur_c;                  /* the |character| field of a |math_char| */
     }
 }
 
-@ We need to do a lot of different things, so |mlist_to_hlist| makes two
-passes over the given mlist.
+/*tex
+
+    We need to do a lot of different things, so |mlist_to_hlist| makes two passes
+    over the given mlist.
 
-The first pass does most of the processing: It removes ``mu'' spacing from
-glue, it recursively evaluates all subsidiary mlists so that only the
-top-level mlist remains to be handled, it puts fractions and square roots
-and such things into boxes, it attaches subscripts and superscripts, and
-it computes the overall height and depth of the top-level mlist so that
-the size of delimiters for a |fence_noad| will be known.
-The hlist resulting from each noad is recorded in that noad's |new_hlist|
-field, an integer field that replaces the |nucleus| or |thickness|.
-@^recursion@>
+    The first pass does most of the processing: It removes ``mu'' spacing from
+    glue, it recursively evaluates all subsidiary mlists so that only the
+    top-level mlist remains to be handled, it puts fractions and square roots and
+    such things into boxes, it attaches subscripts and superscripts, and it
+    computes the overall height and depth of the top-level mlist so that the size
+    of delimiters for a |fence_noad| will be known. The hlist resulting from each
+    noad is recorded in that noad's |new_hlist| field, an integer field that
+    replaces the |nucleus| or |thickness|.
 
-The second pass eliminates all noads and inserts the correct glue and
-penalties between nodes.
+    The second pass eliminates all noads and inserts the correct glue and
+    penalties between nodes.
+
+*/
 
-@c
 static void assign_new_hlist(pointer q, pointer r)
 {
     switch (type(q)) {
-    case fraction_noad:
-        math_list(numerator(q)) = null;
-        flush_node(numerator(q));
-        numerator(q) = null;
-        math_list(denominator(q)) = null;
-        flush_node(denominator(q));
-        denominator(q) = null;
-        break;
-    case radical_noad:
-    case simple_noad:
-    case accent_noad:
-        if (nucleus(q) != null) {
-            math_list(nucleus(q)) = null;
-            flush_node(nucleus(q));
-            nucleus(q) = null;
-        }
-        break;
+        case fraction_noad:
+            math_list(numerator(q)) = null;
+            flush_node(numerator(q));
+            numerator(q) = null;
+            math_list(denominator(q)) = null;
+            flush_node(denominator(q));
+            denominator(q) = null;
+            break;
+        case radical_noad:
+        case simple_noad:
+        case accent_noad:
+            if (nucleus(q) != null) {
+                math_list(nucleus(q)) = null;
+                flush_node(nucleus(q));
+                nucleus(q) = null;
+            }
+            break;
     }
     new_hlist(q) = r;
 }
 
-@ @c
 #define choose_mlist(A) do { p=A(q); A(q)=null; } while (0)
 
-@ Most of the actual construction work of |mlist_to_hlist| is done
-by procedures with names like |make_fraction|, |make_radical|, etc. To
-illustrate the general setup of such procedures, let's begin with a
-couple of simple ones.
+/*tex
+
+    Most of the actual construction work of |mlist_to_hlist| is done by
+    procedures with names like |make_fraction|, |make_radical|, etc. To
+    illustrate the general setup of such procedures, let's begin with a couple of
+    simple ones.
+
+*/
 
-@c
 static void make_over(pointer q, int cur_style, int cur_size, int cur_fam)
 {
+    /*tex
+
+        No rule adaption yet, maybe never as overbars should be proper
+        extensibles.
+
+    */
     pointer p;
+    scaled f, t;
+    scaled used_thickness = overbar_rule(cur_style);
+    scaled used_fam = cur_fam;
+    if (math_rule_thickness_mode_par > 0) {
+        f = noad_fam(q);
+        if (f >= 0) {
+            t = fam_fnt(f,cur_size);
+            if (do_new_math(t)) {
+                t = font_MATH_par(t, OverbarRuleThickness);
+                if (t != undefined_math_parameter) {
+                    used_thickness = t;
+                    used_fam = f;
+               }
+            }
+        }
+    }
     p = overbar(clean_box(nucleus(q), cramped_style(cur_style), cur_style),
-                overbar_vgap(cur_style), overbar_rule(cur_style),
-                overbar_kern(cur_style), node_attr(nucleus(q)), math_over_rule, cur_size, cur_fam);
+                overbar_vgap(cur_style), used_thickness, overbar_kern(cur_style),
+                node_attr(nucleus(q)), math_over_rule, cur_size, used_fam);
     math_list(nucleus(q)) = p;
     type(nucleus(q)) = sub_box_node;
 }
 
 static void make_under(pointer q, int cur_style, int cur_size, int cur_fam)
 {
-    pointer p, x, y, r;         /* temporary registers for box construction */
-    scaled delta;               /* overall height plus depth */
+    /*tex
+
+        No rule adaption yet, maybe never as underbars should be proper
+        extensibles.
+
+    */
+    /*tex temporary registers for box construction */
+    pointer p, x, y, r;
+    /*tex overall height plus depth */
+    scaled delta;
+    scaled f, t;
+    scaled used_thickness = underbar_rule(cur_style);
+    scaled used_fam = cur_fam;
     x = clean_box(nucleus(q), cur_style, cur_style);
     p = new_kern(underbar_vgap(cur_style));
     reset_attributes(p, node_attr(q));
     couple_nodes(x,p);
-    r = do_fraction_rule(underbar_rule(cur_style), node_attr(q), math_under_rule, cur_size, cur_fam);
+    if (math_rule_thickness_mode_par > 0) {
+        f = noad_fam(q);
+        if (f >= 0) {
+            t = fam_fnt(f,cur_size);
+            if (do_new_math(t)) {
+                t = font_MATH_par(t, UnderbarRuleThickness);
+                if (t != undefined_math_parameter) {
+                    used_thickness = t;
+                    used_fam = f;
+               }
+            }
+        }
+    }
+    r = do_fraction_rule(used_thickness, node_attr(q), math_under_rule, cur_size, used_fam);
     couple_nodes(p,r);
     y = vpackage(x, 0, additional, max_dimen, math_direction_par);
     reset_attributes(y, node_attr(q));
@@ -1838,8 +2113,10 @@ static void make_under(pointer q, int cur_style, int cur_size, int cur_fam)
 
 static void make_vcenter(pointer q)
 {
-    pointer v;                  /* the box that should be centered vertically */
-    scaled delta;               /* its height plus depth */
+    /*tex the box that should be centered vertically */
+    pointer v;
+    /*tex its height plus depth */
+    scaled delta;
     v = math_list(nucleus(q));
     if (type(v) != vlist_node)
         confusion("vcenter");
@@ -1848,16 +2125,19 @@ static void make_vcenter(pointer q)
     depth(v) = delta - height(v);
 }
 
-@ According to the rules in the \.{DVI} file specifications, we ensure alignment
-@^square roots@>
-between a square root sign and the rule above its nucleus by assuming that the
-baseline of the square-root symbol is the same as the bottom of the rule. The
-height of the square-root symbol will be the thickness of the rule, and the
-depth of the square-root symbol should exceed or equal the height-plus-depth
-of the nucleus plus a certain minimum clearance~|psi|. The symbol will be
-placed so that the actual clearance is |psi| plus half the excess.
+/*tex
+
+    According to the rules in the \.{DVI} file specifications, we ensure
+    alignment between a square root sign and the rule above its nucleus by
+    assuming that the baseline of the square-root symbol is the same as the
+    bottom of the rule. The height of the square-root symbol will be the
+    thickness of the rule, and the depth of the square-root symbol should exceed
+    or equal the height-plus-depth of the nucleus plus a certain minimum
+    clearance~|psi|. The symbol will be placed so that the actual clearance is
+    |psi| plus half the excess.
+
+*/
 
-@c
 static void make_hextension(pointer q, int cur_style)
 {
     pointer e, p;
@@ -1885,25 +2165,50 @@ static void make_hextension(pointer q, int cur_style)
 
 static void make_radical(pointer q, int cur_style)
 {
-    pointer x, y, p, l1, l2;     /* temporary registers for box construction */
-    scaled delta, clr, theta, h; /* dimensions involved in the calculation */
+    /*tex temporary registers for box construction */
+    pointer x, y, p, l1, l2;
+    /*tex dimensions involved in the calculation */
+    scaled delta, clr, theta, h, f;
+    scaled t, used_fam ;
     x = clean_box(nucleus(q), cramped_style(cur_style), cur_style);
     clr = radical_vgap(cur_style);
     theta = radical_rule_par(cur_style);
+    used_fam = small_fam(left_delimiter(q));
+    /*tex
+
+        We can take the rule width from the fam/style of the delimiter or use the
+        most recent math parameters value.
+
+    */
+    if (math_rule_thickness_mode_par > 0) {
+        f = small_fam(left_delimiter(q));
+        if (f >= 0) {
+            t = fam_fnt(f,cur_size);
+            if (do_new_math(t)) {
+                t = font_MATH_par(t, RadicalRuleThickness);
+                if (t != undefined_math_parameter) {
+                    theta = t;
+                    used_fam = f;
+                }
+            }
+        }
+    }
     if (theta == undefined_math_parameter) {
-        /* a real radical */
+        /*tex a real radical */
         theta = fraction_rule(cur_style);
         y = do_delimiter(q, left_delimiter(q), cur_size, height(x) + depth(x) + clr + theta, false, cur_style, true, NULL, NULL, NULL);
-        /*
+        /*tex
+
             If |y| is a composite then set |theta| to the height of its top
             character, else set it to the height of |y|.
+
         */
         l1 = list_ptr(y);
         if ((l1 != null) && (type(l1) == hlist_node)) {
-            /* possible composite */
+            /*tex possible composite */
             l2 = list_ptr(l1);
             if ((l2 != null) && (type(l2) == glyph_node)) {
-                /* top character */
+                /*tex top character */
                 theta = char_height(font(l2), character(l2));
             } else {
                 theta = height(y);
@@ -1912,18 +2217,29 @@ static void make_radical(pointer q, int cur_style)
             theta = height(y);
         }
     } else {
-        /* not really a radical but we use its node, historical sharing (like in mathml) */
+        /*tex
+
+            Not really a radical but we use its node, historical sharing (like in
+            mathml).
+
+        */
         y = do_delimiter(q, left_delimiter(q), cur_size, height(x) + depth(x) + clr + theta, false, cur_style, true, NULL, NULL, NULL);
     }
+    /*tex
+
+        Weird hack, in overbar we use small_fam(left_delimiter(q)) so actually
+        small_fam(0).
+
+    */
     left_delimiter(q) = null;
     delta = (depth(y) + height(y) - theta) - (height(x) + depth(x) + clr);
     if (delta > 0) {
-        /* increase the actual clearance */
+        /*tex increase the actual clearance */
         clr = clr + half(delta);
     }
     shift_amount(y) = (height(y) - theta) - (height(x) + clr);
     h = depth(y) + height(y);
-    p = overbar(x, clr, theta, radical_kern(cur_style), node_attr(y), math_radical_rule, cur_size, small_fam(left_delimiter(q)));
+    p = overbar(x, clr, theta, radical_kern(cur_style), node_attr(y), math_radical_rule, cur_size, used_fam);
     couple_nodes(y,p);
     if (degree(q) != null) {
         scaled wr, br, ar;
@@ -1949,7 +2265,7 @@ static void make_radical(pointer q, int cur_style)
             couple_nodes(x,r);
             y = x;
         }
-        /* for \.{\\Uroot ..{<list>}{}} : */
+        /*tex for \.{\\Uroot ..{<list>}{}} : */
         math_list(degree(q)) = null;
         flush_node(degree(q));
     }
@@ -1959,12 +2275,11 @@ static void make_radical(pointer q, int cur_style)
     type(nucleus(q)) = sub_box_node;
 }
 
-@ Construct a vlist box
+/*tex Construct a vlist box: */
 
-@c
 static pointer wrapup_over_under_delimiter(pointer x, pointer y, pointer q, scaled shift_up, scaled shift_down)
 {
-    pointer p;  /* temporary register for box construction */
+    pointer p;
     pointer v = new_null_box();
     type(v) = vlist_node;
     height(v) = shift_up + height(x);
@@ -1978,9 +2293,7 @@ static pointer wrapup_over_under_delimiter(pointer x, pointer y, pointer q, scal
     return v;
 }
 
-/* when exact use radicalwidth (y is delimiter) */
-
-@ @c
+/*tex When |exact| use radicalwidth (|y| is delimiter). */
 
 #define fixup_widths(q,x,y) do { \
     if (width(y) >= width(x)) { \
@@ -2014,7 +2327,7 @@ static pointer wrapup_over_under_delimiter(pointer x, pointer y, pointer q, scal
             width(r) = radicalwidth(q); \
             reset_attributes(r, node_attr(q)); \
         } else if (radicalright(q)) { \
-            /* also kind of exact compared to vertical */ \
+            /*tex also kind of exact compared to vertical */ \
             r = hpack(r, 0, additional, -1); \
             width(r) = radicalwidth(q); \
             reset_attributes(r, node_attr(q)); \
@@ -2030,12 +2343,15 @@ static pointer wrapup_over_under_delimiter(pointer x, pointer y, pointer q, scal
     } \
 } while (0)
 
-@ this has the |nucleus| box |x| as a limit above an extensible delimiter |y|
+/*tex
+
+    This has the |nucleus| box |x| as a limit above an extensible delimiter |y|.
+
+*/
 
-@c
 static void make_over_delimiter(pointer q, int cur_style)
 {
-    pointer x, y, v; /* temporary registers for box construction */
+    pointer x, y, v;
     scaled shift_up, shift_down, clr, delta, wd;
     boolean stack;
     x = clean_box(nucleus(q), sub_style(cur_style), cur_style);
@@ -2052,17 +2368,21 @@ static void make_over_delimiter(pointer q, int cur_style)
         shift_up = shift_up + delta;
     }
     v = wrapup_over_under_delimiter(x, y, q, shift_up, shift_down);
-    width(v) = width(x); /* this also equals |width(y)| */
+    /*tex This also equals |width(y)|: */
+    width(v) = width(x);
     math_list(nucleus(q)) = v;
     type(nucleus(q)) = sub_box_node;
 }
 
-@ this has the extensible delimiter |x| as a limit below |nucleus| box |y|
+/*tex
+
+    This has the extensible delimiter |x| as a limit below |nucleus| box |y|.
+
+*/
 
-@c
 static void make_under_delimiter(pointer q, int cur_style)
 {
-    pointer x, y, v; /* temporary registers for box construction */
+    pointer x, y, v;
     scaled shift_up, shift_down, clr, delta, wd;
     boolean stack;
     y = clean_box(nucleus(q), sup_style(cur_style), cur_style);
@@ -2079,17 +2399,21 @@ static void make_under_delimiter(pointer q, int cur_style)
         shift_down = shift_down + delta;
     }
     v = wrapup_over_under_delimiter(x, y, q, shift_up, shift_down);
-    width(v) = width(y); /* this also equals |width(y)| */
+    /*tex This also equals |width(y)|: */
+    width(v) = width(y);
     math_list(nucleus(q)) = v;
     type(nucleus(q)) = sub_box_node;
 }
 
-@ this has the extensible delimiter |x| as a limit above |nucleus| box |y|
+/*tex
+
+    This has the extensible delimiter |x| as a limit above |nucleus| box |y|.
+
+*/
 
-@c
 static void make_delimiter_over(pointer q, int cur_style)
 {
-    pointer x, y, v; /* temporary registers for box construction */
+    pointer x, y, v;
     scaled shift_up, shift_down, clr, actual, wd;
     boolean stack;
     y = clean_box(nucleus(q), cur_style, cur_style);
@@ -2106,17 +2430,21 @@ static void make_delimiter_over(pointer q, int cur_style)
         shift_up = shift_up + (clr-actual);
     }
     v = wrapup_over_under_delimiter(x, y, q, shift_up, shift_down);
-    width(v) = width(x); /* this also equals |width(y)| */
+    /*tex This also equals |width(y)|: */
+    width(v) = width(x);
     math_list(nucleus(q)) = v;
     type(nucleus(q)) = sub_box_node;
 }
 
-@ this has the extensible delimiter |y| as a limit below a |nucleus| box |x|
+/*tex
+
+    This has the extensible delimiter |y| as a limit below a |nucleus| box |x|.
+
+*/
 
-@c
 static void make_delimiter_under(pointer q, int cur_style)
 {
-    pointer x, y, v;            /* temporary registers for box construction */
+    pointer x, y, v;
     scaled shift_up, shift_down, clr, actual, wd;
     boolean stack;
     x = clean_box(nucleus(q), cur_style, cur_style);
@@ -2133,16 +2461,20 @@ static void make_delimiter_under(pointer q, int cur_style)
        shift_down += (clr-actual);
     }
     v = wrapup_over_under_delimiter(x, y, q, shift_up, shift_down);
-    width(v) = width(y); /* this also equals |width(y)| */
+    /*tex This also equals |width(y)|: */
+    width(v) = width(y);
     math_list(nucleus(q)) = v;
     type(nucleus(q)) = sub_box_node;
 }
 
-@ Slants are not considered when placing accents in math mode. The accenter is
-centered over the accentee, and the accent width is treated as zero with
-respect to the size of the final box.
+/*tex
+
+    Slants are not considered when placing accents in math mode. The accenter is
+    centered over the accentee, and the accent width is treated as zero with
+    respect to the size of the final box.
+
+*/
 
-@c
 #define TOP_CODE            1
 #define BOT_CODE            2
 #define OVERLAY_CODE        4
@@ -2150,14 +2482,17 @@ respect to the size of the final box.
 
 static boolean compute_accent_skew(pointer q, int flags, scaled *s)
 {
-    pointer p;                     /* temporary register for box construction */
-    boolean s_is_absolute = false; /* will be true if a top-accent is placed in |s| */
+    /*tex temporary register for box construction */
+    pointer p;
+    /*tex will be true if a top-accent is placed in |s| */
+    boolean s_is_absolute = false;
     if (type(nucleus(q)) == math_char_node) {
         fetch(nucleus(q));
         if (do_new_math(cur_f)) {
-            /*
-                there is no bot_accent so let's assume similarity
+            /*tex
+                There is no bot_accent so let's assume similarity
 
+                \starttyping
                 if (flags & (TOP_CODE | OVERLAY_CODE)) {
                     *s = char_top_accent(cur_f, cur_c);
                     if (*s != INT_MIN) {
@@ -2169,6 +2504,7 @@ static boolean compute_accent_skew(pointer q, int flags, scaled *s)
                         s_is_absolute = true;
                     }
                 }
+                \stoptyping
             */
             *s = char_top_accent(cur_f, cur_c);
             if (*s != INT_MIN) {
@@ -2182,15 +2518,24 @@ static boolean compute_accent_skew(pointer q, int flags, scaled *s)
             }
         }
     } else if (type(nucleus(q)) == sub_mlist_node) {
-        /*
-            if |nucleus(q)| is a |sub_mlist_node| composed of an |accent_noad| we
-
-            * use the positioning of the nucleus of that noad, recursing until
-            * the inner most |accent_noad|. This way multiple stacked accents are
-            * aligned to the inner most one.
-
-            the vlink test was added in version 1.06, so that we only consider a lone
-            noad:
+        /*tex
+            If |nucleus(q)| is a |sub_mlist_node| composed of an |accent_noad| we:
+
+            \startitemize
+            \startitem
+                use the positioning of the nucleus of that noad, recursing until
+            \stopitem
+            \startitem
+                the inner most |accent_noad|. This way multiple stacked accents
+                are
+            \stopitem
+            \startitem
+                aligned to the inner most one.
+            \stopitem
+            \stoptitemize
+
+            The vlink test was added in version 1.06, so that we only consider a
+            lone noad:
 
             $
                 \Umathaccent bottom 0 0 "023DF {   \Umathaccent fixed 0 0 "00302 { m } r } \quad
@@ -2213,12 +2558,18 @@ static boolean compute_accent_skew(pointer q, int flags, scaled *s)
 
 static void do_make_math_accent(pointer q, internal_font_number f, int c, int flags, int cur_style)
 {
-    pointer p, r, x, y;    /* temporary registers for box construction */
-    scaled s;              /* amount to skew the accent to the right */
-    scaled h;              /* height of character being accented */
-    scaled delta;          /* space to remove between accent and accentee */
-    scaled w;              /* width of the accentee, not including sub/superscripts */
-    boolean s_is_absolute; /* will be true if a top-accent is placed in |s| */
+    /*tex temporary registers for box construction */
+    pointer p, r, x, y;
+    /*tex amount to skew the accent to the right */
+    scaled s;
+    /*tex height of character being accented */
+    scaled h;
+    /*tex space to remove between accent and accentee */
+    scaled delta;
+    /*tex width of the accentee, not including sub/superscripts */
+    scaled w;
+    /*tex will be true if a top-accent is placed in |s| */
+    boolean s_is_absolute;
     scaled fraction ;
     scaled ic = 0;
     scaled target ;
@@ -2232,7 +2583,7 @@ static void do_make_math_accent(pointer q, internal_font_number f, int c, int fl
     if (fraction == 0) {
         fraction = 1000;
     }
-    /* Compute the amount of skew, or set |s| to an alignment point */
+    /*tex Compute the amount of skew, or set |s| to an alignment point */
     s_is_absolute = compute_accent_skew(q, flags, &s);
     x = clean_box(nucleus(q), cramped_style(cur_style), cur_style);
     w = width(x);
@@ -2241,7 +2592,7 @@ static void do_make_math_accent(pointer q, internal_font_number f, int c, int fl
         s = half(w);
         s_is_absolute = true;
     }
-    /* Switch to a larger accent if available and appropriate */
+    /*tex Switch to a larger accent if available and appropriate */
     y = null;
     ext = NULL;
     if (flags & OVERLAY_CODE) {
@@ -2258,31 +2609,32 @@ static void do_make_math_accent(pointer q, internal_font_number f, int c, int fl
         }
     }
     if ((flags & STRETCH_ACCENT_CODE) && (char_width(f, c) < w)) {
-      while (1) {
-        if ((char_tag(f, c) == ext_tag) && ((ext = get_charinfo_hor_variants(char_info(f, c))) != NULL)) {
-            /* a bit weird for an overlay but anyway, here we don't need a factor as we don't step */
-            y = get_delim_box(q, ext, f, w, node_attr(attr_p), cur_style, hlist_node);
-            break;
-        } else if (char_tag(f, c) != list_tag) {
-            break;
-        } else {
-            int yy = char_remainder(f, c);
-            if (!char_exists(f, yy)) {
+        while (1) {
+            if ((char_tag(f, c) == ext_tag) && ((ext = get_charinfo_hor_variants(char_info(f, c))) != NULL)) {
+                /*tex a bit weird for an overlay but anyway, here we don't need a factor as we don't step */
+                y = get_delim_box(f, c, w, connector_overlap_min(cur_style), 1, node_attr(attr_p));
+                break;
+            } else if (char_tag(f, c) != list_tag) {
                 break;
-            } else if (flags & OVERLAY_CODE) {
-                if (char_height(f, yy) > target) {
-                   break;
-                }
             } else {
-                if (char_width(f, yy) > target)
-                   break;
+                int yy = char_remainder(f, c);
+                if (!char_exists(f, yy)) {
+                    break;
+                } else if (flags & OVERLAY_CODE) {
+                    if (char_height(f, yy) > target) {
+                        break;
+                    }
+                } else {
+                    if (char_width(f, yy) > target)
+                    break;
+                }
+                c = yy;
             }
-            c = yy;
         }
-      }
     }
     if (y == null) {
-        y = char_box(f, c, node_attr(attr_p)); /* italic gets added to width */
+        /*tex italic gets added to width */
+        y = char_box(f, c, node_attr(attr_p));
     }
     if (flags & TOP_CODE) {
         if (h < accent_base_height(f)) {
@@ -2291,13 +2643,14 @@ static void do_make_math_accent(pointer q, internal_font_number f, int c, int fl
             delta = accent_base_height(f);
         }
     } else if (flags & OVERLAY_CODE) {
-        delta = half(height(y) + depth(y) + height(x) + depth(x)); /* center the accent vertically around the accentee */
+        /*tex center the accent vertically around the accentee */
+        delta = half(height(y) + depth(y) + height(x) + depth(x));
     } else {
         delta = 0; /* hm */
     }
     if ((supscr(q) != null) || (subscr(q) != null)) {
         if (type(nucleus(q)) == math_char_node) {
-            /* swap the subscript and superscript into box |x| */
+            /*tex swap the subscript and superscript into box |x| */
             flush_node_list(x);
             x = new_noad();
             r = math_clone(nucleus(q));
@@ -2313,32 +2666,34 @@ static void do_make_math_accent(pointer q, internal_font_number f, int c, int fl
             h = height(x);
         }
     } else if ((vlink(q) != null) && (type(nucleus(q)) == math_char_node)) {
-        /* only pure math char nodes */
+        /*tex only pure math char nodes */
         internal_font_number f = fam_fnt(math_fam(nucleus(q)),cur_size);
         if (do_new_math(f)) {
             ic = char_italic(f,math_character(nucleus(q)));
         }
     }
-    /* the top accents of both characters are aligned */
+    /*tex the top accents of both characters are aligned */
     if (s_is_absolute) {
         scaled sa;
         if (ext != NULL) {
-            /* if the accent is extensible just take the center */
+            /*tex if the accent is extensible just take the center */
             sa = half(width(y));
         } else {
-            /*
-                there is no bot_accent so let's assume similarity
+            /*tex
+                There is no bot_accent so let's assume similarity
 
+                \starttyping
                 if (flags & BOT_CODE) {
                     sa = char_bot_accent(f, c);
                 } else {
                     sa = char_top_accent(f, c);
                 }
+                \stoptyping
             */
             sa = char_top_accent(f, c);
         }
         if (sa == INT_MIN) {
-            /* just take the center */
+            /*tex just take the center */
             sa = half(width(y));
         }
         if (math_direction_par == dir_TRT) {
@@ -2371,7 +2726,7 @@ static void do_make_math_accent(pointer q, internal_font_number f, int c, int fl
     y = r;
     if (flags & (TOP_CODE | OVERLAY_CODE)) {
         if (height(y) < h) {
-            /* make the height of box |y| equal to |h| */
+            /*tex make the height of box |y| equal to |h| */
             p = new_kern(h - height(y));
             reset_attributes(p, node_attr(q));
             try_couple_nodes(p,list_ptr(y));
@@ -2382,7 +2737,7 @@ static void do_make_math_accent(pointer q, internal_font_number f, int c, int fl
         shift_amount(y) = -(h - height(y));
     }
     if (ic != 0) {
-        /* old font codepath has ic built in, new font code doesn't */
+        /*tex old font codepath has ic built in, new font code doesn't */
         width(r) += ic ;
     }
     math_list(nucleus(q)) = y;
@@ -2420,26 +2775,48 @@ static void make_math_accent(pointer q, int cur_style)
     }
 }
 
-@ The |make_fraction| procedure is a bit different because it sets
-|new_hlist(q)| directly rather than making a sub-box.
+/*tex
+
+    The |make_fraction| procedure is a bit different because it sets
+    |new_hlist(q)| directly rather than making a sub-box.
+
+*/
 
-@c
 static void make_fraction(pointer q, int cur_style)
 {
-    pointer p, p1, p2, v, x, y, z, l, r, m; /* temporary registers for box construction */
-    scaled delta, delta1, delta2, shift_up, shift_down, clr1, clr2;
-    /* dimensions for box calculations */
+    pointer p, p1, p2, v, x, y, z, l, r, m;
+    scaled delta, delta1, delta2, shift_up, shift_down, clr1, clr2, f, t;\
+    /*tex
+
+        We can take the rule width from an explicitly set fam, even if a fraction
+        itself has no character, otherwise we just use the math parameter.
+
+    */
+    scaled used_fam = math_rules_fam_par;
+    if (math_rule_thickness_mode_par > 0 && thickness(q) != 0) {
+        f = fraction_fam(q);
+        if (f >= 0) {
+            t = fam_fnt(f,cur_size);
+            if (do_new_math(t)) {
+                t = font_MATH_par(t, FractionRuleThickness);
+                if (t != undefined_math_parameter) {
+                    thickness(q) = t;
+                    used_fam = f;
+               }
+            }
+        }
+    }
     if (thickness(q) == default_code)
         thickness(q) = fraction_rule(cur_style);
-    /*
+    /*tex
+
         Create equal-width boxes |x| and |z| for the numerator and denominator,
         and compute the default amounts |shift_up| and |shift_down| by which they
-        are displaced from the baseline
-    */
+        are displaced from the baseline.
 
+    */
     x = clean_box(numerator(q), num_style(cur_style), cur_style);
     z = clean_box(denominator(q), denom_style(cur_style), cur_style);
-
     if (middle_delimiter(q) != null) {
         delta = 0;
         m = do_delimiter(q, middle_delimiter(q), cur_size, delta, false, cur_style, true, NULL, NULL, NULL);
@@ -2452,17 +2829,18 @@ static void make_fraction(pointer q, int cur_style)
             z = rebox(z, width(x));
         }
     }
-
     if (m != null) {
         shift_up = 0;
         shift_down = 0;
     } else if (thickness(q) == 0) {
         shift_up = stack_num_up(cur_style);
         shift_down = stack_denom_down(cur_style);
-        /*
-            the numerator and denominator must be separated by a certain minimum
-            clearance, called |clr| in the following program. The difference between
-            |clr| and the actual clearance is |2delta|.
+        /*tex
+
+            The numerator and denominator must be separated by a certain minimum
+            clearance, called |clr| in the following program. The difference
+            between |clr| and the actual clearance is |2delta|.
+
         */
         clr1 = stack_vgap(cur_style);
         delta = half(clr1 - ((shift_up - depth(x)) - (height(z) - shift_down)));
@@ -2473,9 +2851,11 @@ static void make_fraction(pointer q, int cur_style)
     } else {
         shift_up = fraction_num_up(cur_style);
         shift_down = fraction_denom_down(cur_style);
-        /*
-            in the case of a fraction line, the minimum clearance depends on the actual
-            thickness of the line.
+        /*tex
+
+            In the case of a fraction line, the minimum clearance depends on the
+            actual thickness of the line.
+
         */
         clr1 = fraction_num_vgap(cur_style);
         clr2 = fraction_denom_vgap(cur_style);
@@ -2497,15 +2877,17 @@ static void make_fraction(pointer q, int cur_style)
         }
     }
     if (m != null) {
-        /*
-            construct a hlist box for the fraction, according to |hgap| and |vgap|
+        /*tex
+
+            Construct a hlist box for the fraction, according to |hgap| and
+            |vgap|.
+
         */
         shift_up = skewed_fraction_vgap(cur_style);
 
         if (!fractionnoaxis(q)) {
             shift_up += half(math_axis_size(cur_size));
         }
-
         shift_down = shift_up;
         v = new_null_box();
         reset_attributes(v, node_attr(q));
@@ -2516,7 +2898,6 @@ static void make_fraction(pointer q, int cur_style)
         depth(v) = depth(x);
         shift_amount(v) = - shift_up;
         x = v;
-
         v = new_null_box();
         reset_attributes(v, node_attr(q));
         type(v) = hlist_node;
@@ -2526,7 +2907,6 @@ static void make_fraction(pointer q, int cur_style)
         depth(v) = depth(z) + shift_down;
         shift_amount(v) = shift_down;
         z = v;
-
         v = new_null_box();
         reset_attributes(v, node_attr(q));
         type(v) = hlist_node;
@@ -2546,7 +2926,6 @@ static void make_fraction(pointer q, int cur_style)
         if (depth(m) > depth(v)) {
             depth(v) = depth(m);
         }
-
         if (fractionexact(q)) {
             delta1 = -half(skewed_fraction_hgap(cur_style));
             delta2 = delta1;
@@ -2557,33 +2936,34 @@ static void make_fraction(pointer q, int cur_style)
             width(v) = width(x) + width(z) + skewed_fraction_hgap(cur_style);
             width(m) = 0;
         }
-
         p1 = new_kern(delta1);
         reset_attributes(p1, node_attr(q));
         p2 = new_kern(delta2);
         reset_attributes(p2, node_attr(q));
-
         couple_nodes(x,p1);
         couple_nodes(p1,m);
         couple_nodes(m,p2);
         couple_nodes(p2,z);
-
         list_ptr(v) = x;
     } else {
-        /*
-            construct a vlist box for the fraction, according to |shift_up| and |shift_down|
+        /*tex
+
+            Construct a vlist box for the fraction, according to |shift_up| and
+            |shift_down|.
+
         */
         v = new_null_box();
         type(v) = vlist_node;
         height(v) = shift_up + height(x);
         depth(v) = depth(z) + shift_down;
-        width(v) = width(x); /* this also equals |width(z)| */
+        /*tex This also equals |width(z)|. */
+        width(v) = width(x);
         reset_attributes(v, node_attr(q));
         if (thickness(q) == 0) {
             p = new_kern((shift_up - depth(x)) - (height(z) - shift_down));
             couple_nodes(p,z);
         } else {
-            y = do_fraction_rule(thickness(q), node_attr(q), math_fraction_rule, cur_size, math_rules_fam_par);
+            y = do_fraction_rule(thickness(q), node_attr(q), math_fraction_rule, cur_size, used_fam);
             p = new_kern((math_axis_size(cur_size) - delta) - (height(z) - shift_down));
             reset_attributes(p, node_attr(q));
             couple_nodes(y,p);
@@ -2595,16 +2975,14 @@ static void make_fraction(pointer q, int cur_style)
         couple_nodes(x,p);
         list_ptr(v) = x;
     }
-    /*
-        put the fraction into a box with its delimiters, and make |new_hlist(q)|
-        point to it
+    /*tex
+
+        Put the fraction into a box with its delimiters, and make |new_hlist(q)|
+        point to it.
+
     */
     if (do_new_math(cur_f)) {
-        if (math_use_old_fraction_scaling_par) {
-            delta = fraction_del_size_old(cur_style);
-        } else {
-            delta = fraction_del_size_new(cur_style);
-        }
+        delta = fraction_del_size_new(cur_style);
         if (delta == undefined_math_parameter) {
             delta = get_delimiter_height(depth(v), height(v), true);
         }
@@ -2622,31 +3000,38 @@ static void make_fraction(pointer q, int cur_style)
     assign_new_hlist(q, y);
 }
 
-@ If the nucleus of an |op_noad| is a single character, it is to be
-centered vertically with respect to the axis, after first being enlarged
-(via a character list in the font) if we are in display style.  The normal
-convention for placing displayed limits is to put them above and below the
-operator in display style.
+/*tex
+
+    If the nucleus of an |op_noad| is a single character, it is to be centered
+    vertically with respect to the axis, after first being enlarged (via a
+    character list in the font) if we are in display style. The normal convention
+    for placing displayed limits is to put them above and below the operator in
+    display style.
+
+    The italic correction is removed from the character if there is a subscript
+    and the limits are not being displayed. The |make_op| routine returns the
+    value that should be used as an offset between subscript and superscript.
 
-The italic correction is removed from the character if there is a subscript
-and the limits are not being displayed. The |make_op| routine returns the
-value that should be used as an offset between subscript and superscript.
+    After |make_op| has acted, |subtype(q)| will be |limits| if and only if the
+    limits have been set above and below the operator. In that case,
+    |new_hlist(q)| will already contain the desired final box.
 
-After |make_op| has acted, |subtype(q)| will be |limits| if and only if
-the limits have been set above and below the operator. In that case,
-|new_hlist(q)| will already contain the desired final box.
+*/
 
-@c
 static void make_scripts(pointer q, pointer p, scaled it, int cur_style, scaled supshift, scaled subshift);
 static pointer check_nucleus_complexity(halfword q, scaled * delta, int cur_style, int *same);
 
 static scaled make_op(pointer q, int cur_style)
 {
-    scaled delta = 0;            /* offset between subscript and superscript */
+    /*tex offset between subscript and superscript */
+    scaled delta = 0;
     scaled dummy = 0;
-    pointer p, v, x, y, z, n;    /* temporary registers for box construction */
-    int c;                       /* register for character examination */
-    scaled shift_up, shift_down; /* dimensions for box calculation */
+    /*tex temporary registers for box construction */
+    pointer p, v, x, y, z, n;
+    /*tex register for character examination */
+    int c;
+    /*tex dimensions for box calculation */
+    scaled shift_up, shift_down;
     boolean axis_shift = false;
     scaled ok_size;
     if ((subtype(q) == op_noad_type_normal) && (cur_style < text_style)) {
@@ -2655,10 +3040,10 @@ static scaled make_op(pointer q, int cur_style)
     if (type(nucleus(q)) == math_char_node) {
         fetch(nucleus(q));
         if (cur_style < text_style) {
-            /* try to make it larger */
+            /*tex try to make it larger */
             ok_size = minimum_operator_size(cur_style);
             if (ok_size != undefined_math_parameter) {
-                /* creating a temporary delimiter is the cleanest way */
+                /*tex creating a temporary delimiter is the cleanest way */
                 y = new_node(delim_node, 0);
                 reset_attributes(y, node_attr(q));
                 small_fam(y) = math_fam(nucleus(q));
@@ -2666,9 +3051,9 @@ static scaled make_op(pointer q, int cur_style)
                 x = do_delimiter(q, y, text_size, ok_size, false, cur_style, true, NULL, &delta, NULL);
                 if (delta != 0) {
                     if (do_new_math(cur_f)) {
-                        /* we never added italic correction */
+                        /*tex we never added italic correction */
                     } else if ((subscr(q) != null) && (subtype(q) != op_noad_type_limits)) {
-                        /* remove italic correction */
+                        /*tex remove italic correction */
                         width(x) -= delta;
                     }
                 }
@@ -2685,82 +3070,91 @@ static scaled make_op(pointer q, int cur_style)
                 x = clean_box(nucleus(q), cur_style, cur_style);
                 if (delta != 0) {
                     if (do_new_math(cur_f)) {
-                        /* we never added italic correction */
+                        /*tex we never added italic correction */
                     } else if ((subscr(q) != null) && (subtype(q) != op_noad_type_limits)) {
-                        /* remove italic correction */
+                        /*tex remove italic correction */
                         width(x) -= delta;
                     }
                 }
                 axis_shift = true;
             }
         } else {
-            /* normal size */
+            /*tex normal size */
             delta = char_italic(cur_f, cur_c);
             x = clean_box(nucleus(q), cur_style, cur_style);
             if (delta != 0) {
                 if (do_new_math(cur_f)) {
-                    /* we never added italic correction */
+                    /*tex we never added italic correction */
                 } else if ((subscr(q) != null) && (subtype(q) != op_noad_type_limits)) {
-                    /* remove italic correction */
+                    /*tex remove italic correction */
                     width(x) -= delta;
                 }
             }
             axis_shift = true;
         }
         if (axis_shift) {
-            /* center vertically */
+            /*tex center vertically */
             shift_amount(x) = half(height(x) - depth(x)) - math_axis_size(cur_size);
         }
         type(nucleus(q)) = sub_box_node;
         math_list(nucleus(q)) = x;
     }
-
-    /* we now handle op_nod_type_no_limits here too */
-
+    /*tex we now handle op_nod_type_no_limits here too */
     if (subtype(q) == op_noad_type_no_limits) {
         if (do_new_math(cur_f)) {
-            /*
+            /*tex
+                Not:
+
+                \starttyping
                 if (delta != 0) {
                     delta = half(delta) ;
                 }
+                \stoptyping
             */
             p = check_nucleus_complexity(q, &dummy, cur_style, NULL);
             if ((subscr(q) == null) && (supscr(q) == null)) {
                 assign_new_hlist(q, p);
             } else {
-                /*
+                /*tex
+                    Not:
+
+                    \starttyping
                     make_scripts(q, p, 0, cur_style, delta, -delta);
+                    \stoptyping
                 */
                 int mode = math_nolimits_mode_par; /* wins */
-                /*
-                    for easy configuration ... fonts are somewhat inconsistent and the
-                    values for italic correction run from 30 to 60% of the width
+                /*tex
+
+                    For easy configuration ... fonts are somewhat inconsistent
+                    and the values for italic correction run from 30 to 60\% of.
+                    the width.
+
                 */
                 switch (mode) {
                     case 0 :
-                        /* full bottom correction */
+                        /*tex full bottom correction */
                         make_scripts(q, p, 0, cur_style, 0, -delta);
                         break;
                     case 1 :
-                        /* MathConstants driven */
+                        /*tex |MathConstants| driven */
                         make_scripts(q, p, 0, cur_style,
                              round_xn_over_d(delta, nolimit_sup_factor(cur_style), 1000),
                             -round_xn_over_d(delta, nolimit_sub_factor(cur_style), 1000));
                     case 2 :
-                        /* no correction */
+                        /*tex no correction */
                         make_scripts(q, p, 0, cur_style, 0, 0);
                         break ;
                     case 3 :
-                        /* half bottom correction */
+                        /*tex half bottom correction */
                         make_scripts(q, p, 0, cur_style, 0, -half(delta));
                         break;
                     case 4 :
-                        /* half bottom and top correction */
+                        /*tex half bottom and top correction */
                         make_scripts(q, p, 0, cur_style, half(delta), -half(delta));
                         break;
                     default :
                         if (mode > 15) {
-                            /* for quickly testing values */
+                            /*tex for quickly testing values */
                             make_scripts(q, p, 0, cur_style, 0, -round_xn_over_d(delta, mode, 1000));
                         } else {
                             make_scripts(q, p, 0, cur_style, 0, 0);
@@ -2770,7 +3164,7 @@ static scaled make_op(pointer q, int cur_style)
             }
             delta = 0;
         } else {
-            /* similar code then the caller (before CHECK_DIMENSIONS) */
+            /*tex similar code then the caller (before CHECK_DIMENSIONS) */
             p = check_nucleus_complexity(q, &delta, cur_style, NULL);
             if ((subscr(q) == null) && (supscr(q) == null)) {
                 assign_new_hlist(q, p);
@@ -2779,8 +3173,13 @@ static scaled make_op(pointer q, int cur_style)
             }
         }
     } else if (subtype(q) == op_noad_type_limits) {
-        /* The following program builds a vlist box |v| for displayed limits. The
-           width of the box is not affected by the fact that the limits may be skewed. */
+        /*tex
+
+            The following program builds a vlist box |v| for displayed limits.
+            The width of the box is not affected by the fact that the limits may
+            be skewed.
+
+        */
         x = clean_box(supscr(q), sup_style(cur_style), cur_style);
         y = clean_box(nucleus(q), cur_style, cur_style);
         z = clean_box(subscr(q), sub_style(cur_style), cur_style);
@@ -2788,38 +3187,36 @@ static scaled make_op(pointer q, int cur_style)
         reset_attributes(v, node_attr(q));
         type(v) = vlist_node;
         if (do_new_math(cur_f)) {
-            n = null;
-            if (! math_no_italic_compensation_par) {
-                n = nucleus(q);
-                if (n != null) {
-                    if ((type(n) == sub_mlist_node) || (type(n) == sub_box_node)) {
-                        n = math_list(n);
-                        if (n != null) {
-                            if (type(n) == hlist_node) {
-                                n = list_ptr(n); /* just a not scaled char */
-                                while (n != null) {
-                                    if (type(n) == glyph_node) {
-                                        delta = char_italic(font(n),character(n));
-                                    }
-                                    n = vlink(n);
+            n = nucleus(q);
+            if (n != null) {
+                if ((type(n) == sub_mlist_node) || (type(n) == sub_box_node)) {
+                    n = math_list(n);
+                    if (n != null) {
+                        if (type(n) == hlist_node) {
+                            /*tex just a not scaled char */
+                            n = list_ptr(n);
+                            while (n != null) {
+                                if (type(n) == glyph_node) {
+                                    delta = char_italic(font(n),character(n));
                                 }
-                            } else {
-                                while (n != null) {
-                                    if (type(n) == fence_noad) {
-                                        if (delimiteritalic(n) > delta) {
-                                            /* we can have dummies, the period ones */
-                                            delta = delimiteritalic(n);
-                                        }
+                                n = vlink(n);
+                            }
+                        } else {
+                            while (n != null) {
+                                if (type(n) == fence_noad) {
+                                    if (delimiteritalic(n) > delta) {
+                                        /*tex we can have dummies, the period ones */
+                                        delta = delimiteritalic(n);
                                     }
-                                    n = vlink(n);
                                 }
+                                n = vlink(n);
                             }
                         }
-                    } else {
-                        n = nucleus(q);
-                        if (type(n) == math_char_node) {
-                            delta = char_italic(fam_fnt(math_fam(n),cur_size),math_character(n));
-                        }
+                    }
+                } else {
+                    n = nucleus(q);
+                    if (type(n) == math_char_node) {
+                        delta = char_italic(fam_fnt(math_fam(n),cur_size),math_character(n));
                     }
                 }
             }
@@ -2834,23 +3231,23 @@ static scaled make_op(pointer q, int cur_style)
         z = rebox(z, width(v));
         shift_amount(x) = half(delta);
         shift_amount(z) = -shift_amount(x);
-        /* v is the still empty target */
+        /*tex v is the still empty target */
         height(v) = height(y);
         depth(v) = depth(y);
-        /*
-            attach the limits to |y| and adjust |height(v)|, |depth(v)| to
-            account for their presence
+        /*tex
 
-            we use |shift_up| and |shift_down| in the following program for the
-            amount of glue between the displayed operator |y| and its limits |x| and
-            |z|
+            Attach the limits to |y| and adjust |height(v)|, |depth(v)| to
+            account for their presence.
 
-            the vlist inside box |v| will consist of |x| followed by |y| followed
-            by |z|, with kern nodes for the spaces between and around them
+            We use |shift_up| and |shift_down| in the following program for the
+            amount of glue between the displayed operator |y| and its limits |x|
+            and |z|.
 
-            b: baseline  v: minumum gap
-        */
+            The vlist inside box |v| will consist of |x| followed by |y| followed
+            by |z|, with kern nodes for the spaces between and around them;
+            |b| is baseline and |v| is the minumum gap.
 
+        */
         if (supscr(q) == null) {
             list_ptr(x) = null;
             flush_node(x);
@@ -2905,17 +3302,20 @@ static scaled make_op(pointer q, int cur_style)
     return delta;
 }
 
-@ A ligature found in a math formula does not create a ligature, because
-there is no question of hyphenation afterwards; the ligature will simply be
-stored in an ordinary |glyph_node|, after residing in an |ord_noad|.
+/*tex
 
-The |type| is converted to |math_text_char| here if we would not want to
-apply an italic correction to the current character unless it belongs
-to a math font (i.e., a font with |space=0|).
+    A ligature found in a math formula does not create a ligature, because there
+    is no question of hyphenation afterwards; the ligature will simply be stored
+    in an ordinary |glyph_node|, after residing in an |ord_noad|.
 
-No boundary characters enter into these ligatures.
+    The |type| is converted to |math_text_char| here if we would not want to
+    apply an italic correction to the current character unless it belongs to a
+    math font (i.e., a font with |space=0|).
+
+    No boundary characters enter into these ligatures.
+
+*/
 
-@c
 #define simple_char_noad(p) (\
     (p != null) && \
     (type(p) == simple_noad) && \
@@ -2928,10 +3328,14 @@ No boundary characters enter into these ligatures.
 
 static void make_ord(pointer q)
 {
-    int a;           /* the left-side character for lig/kern testing */
-    pointer p, r, s; /* temporary registers for list manipulation */
-    scaled k;        /* a kern */
-    liginfo lig;     /* a ligature */
+    /*tex the left-side character for lig/kern testing */
+    int a;
+    /*tex temporary registers for list manipulation */
+    pointer p, r, s;
+    /*tex a kern */
+    scaled k;
+    /*tex a ligature */
+    liginfo lig;
   RESTART:
     if (subscr(q) == null && supscr(q) == null && type(nucleus(q)) == math_char_node) {
         p = vlink(q);
@@ -2939,7 +3343,7 @@ static void make_ord(pointer q)
             type(nucleus(q)) = math_text_char_node;
             fetch(nucleus(q));
             a = cur_c;
-            /* add italic correction */
+            /*tex add italic correction */
             if (do_new_math(cur_f) && (char_italic(cur_f,math_character(nucleus(q))) != 0)) {
                 p = new_kern(char_italic(cur_f,math_character(nucleus(q))));
                 subtype(p) = italic_kern;
@@ -2948,45 +3352,49 @@ static void make_ord(pointer q)
                 couple_nodes(q,p);
                 return;
             }
-            /* construct ligatures, quite unlikely in new math fonts */
+            /*tex construct ligatures, quite unlikely in new math fonts */
             if ((has_kern(cur_f, a)) || (has_lig(cur_f, a))) {
                 cur_c = math_character(nucleus(p));
-                /*
-                    if character |a| has a kern with |cur_c|, attach the kern after~|q|; or if
-                    it has a ligature with |cur_c|, combine noads |q| and~|p| appropriately;
-                    then |return| if the cursor has moved past a noad, or |goto restart|
+                /*tex
 
-                    note that a ligature between an |ord_noad| and another kind of noad
-                    is replaced by an |ord_noad|, when the two noads collapse into one
+                    If character |a| has a kern with |cur_c|, attach the kern
+                    after~|q|; or if it has a ligature with |cur_c|, combine
+                    noads |q| and~|p| appropriately; then |return| if the cursor
+                    has moved past a noad, or |goto restart|.
 
-                    we could make a parenthesis (say) change shape when it follows
-                    certain letters. Presumably a font designer will define such
-                    ligatures only when this convention makes sense
-                */
+                    Note that a ligature between an |ord_noad| and another kind
+                    of noad is replaced by an |ord_noad|, when the two noads
+                    collapse into one.
 
+                    We could make a parenthesis (say) change shape when it
+                    follows certain letters. Presumably a font designer will
+                    define such ligatures only when this convention makes sense.
+
+                */
                 if (disable_lig_par == 0 && has_lig(cur_f, a)) {
                     lig = get_ligature(cur_f, a, cur_c);
                     if (is_valid_ligature(lig)) {
-                        check_interrupt();      /* allow a way out of infinite ligature loop */
+                        /*tex allow a way out of infinite ligature loop */
+                        check_interrupt();
                         switch (lig_type(lig)) {
                         case 1:
-                            /* \.{=:\char`\|} */
+                            /*tex \.{=:\char`\|} */
                         case 5:
-                            /* \.{=:\char`\|>} */
+                            /*tex \.{=:\char`\|>} */
                             math_character(nucleus(q)) = lig_replacement(lig);
                             break;
                         case 2:
-                            /* \.{\char`\|=:} */
+                            /*tex \.{\char`\|=:} */
                         case 6:
-                            /* \.{\char`\|=:>} */
+                            /*tex \.{\char`\|=:>} */
                             math_character(nucleus(p)) = lig_replacement(lig);
                             break;
                         case 3:
-                             /* \.{\char`\|=:\char`\|} */
+                            /*tex \.{\char`\|=:\char`\|} */
                         case 7:
-                             /* \.{\char`\|=:\char`\|>} */
+                            /*tex \.{\char`\|=:\char`\|>} */
                         case 11:
-                             /* \.{\char`\|=:\char`\|>>} */
+                            /*tex \.{\char`\|=:\char`\|>>} */
                             r = new_noad();
                             reset_attributes(r, node_attr(q));
                             s = new_node(math_char_node, 0);
@@ -2996,21 +3404,20 @@ static void make_ord(pointer q)
                             math_fam(nucleus(r)) = math_fam(nucleus(q));
                             couple_nodes(q,r);
                             couple_nodes(r,p);
-                            if (lig_type(lig) < 11)
+                            if (lig_type(lig) < 11) {
                                 type(nucleus(r)) = math_char_node;
-                            else
-                                /* prevent combination */
+                            } else {
+                                /*tex prevent combination */
                                 type(nucleus(r)) = math_text_char_node;
+                            }
                             break;
                         default:
                             try_couple_nodes(q,vlink(p));
                             math_character(nucleus(q)) = lig_replacement(lig); /* \.{=:} */
-                            s = math_clone(subscr(p));
-                            subscr(q) = s;
-                            s = math_clone(supscr(p));
-                            supscr(q) = s;
-                            math_reset(subscr(p)); /* just in case */
-                            math_reset(supscr(p));
+                            subscr(q) = subscr(p);
+                            supscr(q) = supscr(p);
+                            subscr(p) = null ;
+                            supscr(p) = null ;
                             flush_node(p);
                             break;
                         }
@@ -3021,7 +3428,7 @@ static void make_ord(pointer q)
                     }
                 }
                 if (disable_kern_par == 0 && has_kern(cur_f, a)) {
-                    /* todo: should this use mathkerns? */
+                    /*tex todo: should this use mathkerns? */
                     k = get_kern(cur_f, a, cur_c);
                     if (k != 0) {
                         p = new_kern(k);
@@ -3036,32 +3443,35 @@ static void make_ord(pointer q)
     }
 }
 
-@ If the fonts for the left and right bits of a mathkern are not
-both new-style fonts, then return a sentinel value meaning:
-please use old-style italic correction placement
+/*tex
+
+    If the fonts for the left and right bits of a mathkern are not both new-style
+    fonts, then return a sentinel value meaning: please use old-style italic
+    correction placement
+
+*/
 
-@c
 #define MATH_KERN_NOT_FOUND 0x7FFFFFFF
 
-@ This function tries to find the kern needed for proper cut-ins.
-The left side doesn't move, but the right side does, so the first
-order of business is to create a staggered fence line on the
-left side of the right character.
+/*tex
 
-The microsoft spec says that there are four quadrants, but the
-actual images say
+    This function tries to find the kern needed for proper cut-ins. The left side
+    doesn't move, but the right side does, so the first order of business is to
+    create a staggered fence line on the left side of the right character.
+
+    The microsoft spec says that there are four quadrants, but the actual images
+    say.
+
+*/
 
-@c
 static scaled math_kern_at(internal_font_number f, int c, int side, int v)
 {
     int h, k, numkerns;
     scaled *kerns_heights;
     scaled kern = 0;
-    charinfo *co = char_info(f, c); /* known to exist */
+    /*tex Known to exist: */
+    charinfo *co = char_info(f, c);
     numkerns = get_charinfo_math_kerns(co, side);
-#ifdef DEBUG
-    fprintf(stderr, "  entries = %d, height = %d\n", numkerns, v);
-#endif
     if (numkerns == 0)
         return kern;
     if (side == top_left_kern) {
@@ -3073,21 +3483,15 @@ static scaled math_kern_at(internal_font_number f, int c, int side, int v)
     } else if (side == bottom_right_kern) {
         kerns_heights = co->bottom_right_math_kern_array;
     } else {
+        /*tex Not reached: */
         confusion("math_kern_at");
-        kerns_heights = NULL;   /* not reached */
+        kerns_heights = NULL;
     }
-#ifdef DEBUG
-    fprintf(stderr, "   entry 0: %d,%d\n", kerns_heights[0], kerns_heights[1]);
-#endif
     if (v < kerns_heights[0])
         return kerns_heights[1];
     for (k = 0; k < numkerns; k++) {
         h = kerns_heights[(k * 2)];
         kern = kerns_heights[(k * 2) + 1];
-#ifdef DEBUG
-        if (k > 0)
-            fprintf(stderr, "   entry %d: %d,%d\n", k, h, kern);
-#endif
         if (h > v) {
             return kern;
         }
@@ -3095,68 +3499,55 @@ static scaled math_kern_at(internal_font_number f, int c, int side, int v)
     return kern;
 }
 
-@ @c
-static scaled find_math_kern(internal_font_number l_f, int l_c,
-                             internal_font_number r_f, int r_c,
-                             int cmd, scaled shift)
+static scaled find_math_kern(internal_font_number l_f, int l_c, internal_font_number r_f, int r_c, int cmd, scaled shift)
 {
     scaled corr_height_top = 0, corr_height_bot = 0;
     scaled krn_l = 0, krn_r = 0, krn = 0;
-//    if ((!do_new_math(l_f)) || (!do_new_math(r_f)) || (!char_exists(l_f, l_c)) || (!char_exists(r_f, r_c)))
-    if ((!(do_new_math(l_f) || do_new_math(r_f))) || (!char_exists(l_f, l_c)) || (!char_exists(r_f, r_c)))
+    if ((!do_new_math(l_f)) || (!do_new_math(r_f)) || (!char_exists(l_f,l_c)) || (!char_exists(r_f,r_c)))
         return MATH_KERN_NOT_FOUND;
-
     if (cmd == sup_mark_cmd) {
         corr_height_top = char_height(l_f, l_c);
-        corr_height_bot = -char_depth(r_f, r_c) + shift; /* bottom of superscript */
+        /*tex bottom of superscript */
+        corr_height_bot = -char_depth(r_f, r_c) + shift;
         krn_l = math_kern_at(l_f, l_c, top_right_kern, corr_height_top);
         krn_r = math_kern_at(r_f, r_c, bottom_left_kern, corr_height_top);
-#ifdef DEBUG
-        fprintf(stderr, "SUPER Top LR = %d,%d (shift %d)\n", krn_l, krn_r, shift);
-#endif
         krn = (krn_l + krn_r);
         krn_l = math_kern_at(l_f, l_c, top_right_kern, corr_height_bot);
         krn_r = math_kern_at(r_f, r_c, bottom_left_kern, corr_height_bot);
-#ifdef DEBUG
-        fprintf(stderr, "SUPER Bot LR = %d,%d\n", krn_l, krn_r);
-#endif
         if ((krn_l + krn_r) < krn)
             krn = (krn_l + krn_r);
         return (krn);
-
     } else if (cmd == sub_mark_cmd) {
-        corr_height_top = char_height(r_f, r_c) - shift; /* top of subscript */
+        /*tex top of subscript */
+        corr_height_top = char_height(r_f, r_c) - shift;
         corr_height_bot = -char_depth(l_f, l_c);
         krn_l = math_kern_at(l_f, l_c, bottom_right_kern, corr_height_top);
         krn_r = math_kern_at(r_f, r_c, top_left_kern, corr_height_top);
-#ifdef DEBUG
-        fprintf(stderr, "SUB Top LR = %d,%d\n", krn_l, krn_r);
-#endif
         krn = (krn_l + krn_r);
         krn_l = math_kern_at(l_f, l_c, bottom_right_kern, corr_height_bot);
         krn_r = math_kern_at(r_f, r_c, top_left_kern, corr_height_bot);
-#ifdef DEBUG
-        fprintf(stderr, "SUB Bot LR = %d,%d\n", krn_l, krn_r);
-#endif
         if ((krn_l + krn_r) < krn)
             krn = (krn_l + krn_r);
         return (krn);
-
     } else {
         confusion("find_math_kern");
     }
-    return 0; /* not reached */
+    /*tex Not reached: */
+    return 0;
 }
 
-@ just a small helper
-@c
-static pointer attach_hkern_to_new_hlist(pointer q, scaled delta2)
+/*tex Just a small helper: */
+
+static pointer attach_hkern_to_new_hlist(pointer q, scaled delta2, halfword subtyp)
 {
     pointer y;
     pointer z = new_kern(delta2);
+    if (subtyp != 0) {
+        subtype(z) = subtyp;
+    }
     reset_attributes(z, node_attr(q));
     if (new_hlist(q) == null) {
-        /* this is somewhat weird */
+        /*tex this is somewhat weird */
         new_hlist(q) = z;
     } else {
         y = new_hlist(q);
@@ -3167,67 +3558,36 @@ static pointer attach_hkern_to_new_hlist(pointer q, scaled delta2)
     return new_hlist(q);
 }
 
-@
-@c
-#ifdef DEBUG
-void dump_simple_field(pointer q)
-{
-    pointer p;
-    printf("   [%d,  type=%d, vlink=%d] ", q, type(q), vlink(q));
-    switch (type(q)) {
-    case math_char_node:
-        printf("mathchar ");
-        break;
-    case math_text_char_node:
-        printf("texchar ");
-        break;
-    case sub_box_node:
-        printf("box ");
-        break;
-    case sub_mlist_node:
-        printf("mlist ");
-        p = math_list(q);
-        while (p != null) {
-            dump_simple_field(p);
-            p = vlink(p);
-        }
-        break;
-    }
-}
+/*tex
 
-void dump_simple_node(pointer q)
-{
-    printf("node %d, type=%d, vlink=%d\n", q, type(q), vlink(q));
-    printf("nucleus: ");
-    dump_simple_field(nucleus(q));
-    printf("\n");
-    printf("sub: ");
-    dump_simple_field(subscr(q));
-    printf("\n");
-    printf("sup: ");
-    dump_simple_field(supscr(q));
-    printf("\n\n");
-}
-#endif
+    The purpose of |make_scripts(q,it)| is to attach the subscript and/or
+    superscript of noad |q| to the list that starts at |new_hlist(q)|, given that
+    subscript and superscript aren't both empty. The superscript will be
+    horizontally shifted over |delta1|, the subscript over |delta2|.
 
-@ The purpose of |make_scripts(q,it)| is to attach the subscript and/or
-superscript of noad |q| to the list that starts at |new_hlist(q)|,
-given that subscript and superscript aren't both empty. The superscript
-will be horizontally shifted over |delta1|, the subscript over |delta2|.
+    We set |shift_down| and |shift_up| to the minimum amounts to shift the
+    baseline of subscripts and superscripts based on the given nucleus.
 
-We set |shift_down| and |shift_up| to the minimum amounts to shift the
-baseline of subscripts and superscripts based on the given nucleus.
+    Note: We need to look at a character but also at the first one in a sub list
+    and there we ignore leading kerns and glue. Elsewhere is code that removes
+    kerns assuming that is italic correction. The heuristics are unreliable for
+    the new fonts so eventualy there will be an option to ignore such
+    corrections.
 
-Note: We need to look at a character but also at the first one in a sub list
-and there we ignore leading kerns and glue. Elsewhere is code that removes
-kerns assuming that is italic correction. The heuristics are unreliable for
-the new fonts so eventualy there will be an option to ignore such corrections.
+*/
 
-@ @c
 #define analyze_script(init,su_n,su_f,su_c) do { \
     su_n = init; \
     if (su_n != null) { \
-        if (math_script_box_mode_par > 0 && type(su_n) == sub_mlist_node) { \
+        if (math_script_char_mode_par > 0 && type(su_n) == math_char_node) { \
+            fetch(su_n); \
+            if (char_exists(cur_f, cur_c)) { \
+                su_f = cur_f; \
+                su_c = cur_c; \
+            } else { \
+                su_n = null; \
+            } \
+        } else if (math_script_box_mode_par > 0 && type(su_n) == sub_mlist_node) { \
             su_n = math_list(su_n); \
             while (su_n != null) { \
                 if ((type(su_n) == kern_node) || (type(su_n) == glue_node)) { \
@@ -3312,10 +3672,10 @@ the new fonts so eventualy there will be an option to ignore such corrections.
 
 static void make_scripts(pointer q, pointer p, scaled it, int cur_style, scaled supshift, scaled subshift)
 {
-    pointer x, y, z;                  /* temporary registers for box construction */
-    scaled shift_up, shift_down, clr; /* dimensions in the calculation */
+    pointer x, y, z;
+    scaled shift_up, shift_down, clr;
     scaled delta1, delta2;
-    halfword sub_n, sup_n;
+    halfword sub_n, sup_n, subtyp;
     internal_font_number sub_f, sup_f;
     int sub_c, sup_c;
     sub_n = null;
@@ -3326,18 +3686,13 @@ static void make_scripts(pointer q, pointer p, scaled it, int cur_style, scaled
     sup_c = 0;
     delta1 = it;
     delta2 = 0;
-
-#ifdef DEBUG
-    printf("it: %d\n", it);
-    dump_simple_node(q);
-    printf("p: node %d, type=%d, subtype=%d\n", p, type(p), subtype(p));
-#endif
+    subtyp = 0;
     switch (type(nucleus(q))) {
         case math_char_node:
         case math_text_char_node:
             if ((subscr(q) == null) && (delta1 != 0)) {
-                /* todo: selective */
-                x = new_kern(delta1); /* italic correction */
+                /*tex todo: selective italic correction */
+                x = new_kern(delta1);
                 subtype(x) = italic_kern;
                 reset_attributes(x, node_attr(nucleus(q)));
                 couple_nodes(p,x);
@@ -3355,22 +3710,20 @@ static void make_scripts(pointer q, pointer p, scaled it, int cur_style, scaled
         list_ptr(z) = null;
         flush_node(z);
     }
-
     if (is_char_node(p)) {
-        /* we look at the subscript character (_i) or first character in a list (_{ij}) */
+        /*tex We look at the subscript character (_i) or first character in a list (_{ij}). */
         analyze_script(subscr(q),sub_n,sub_f,sub_c);
-        /* we look at the superscript character (^i) or first character in a list (^{ij}) */
+        /*tex We look at the superscript character (^i) or first character in a list (^{ij}). */
         analyze_script(supscr(q),sup_n,sup_f,sup_c);
     }
-
     if (supscr(q) == null) {
-        /*
-            construct a subscript box |x| when there is no superscript
+        /*tex
 
-            when there is a subscript without a superscript, the top of the subscript
+            Construct a subscript box |x| when there is no superscript. When
+            there is a subscript without a superscript, the top of the subscript
             should not exceed the baseline plus four-fifths of the x-height.
+
         */
-    /*  x = clean_box(subscr(q), sub_style(cur_style), cur_style); */
         x = clean_box(subscr(q), (noadoptionnosubscript(q) ? cur_style : sub_style(cur_style)), cur_style);
         width(x) = width(x) + space_after_script(cur_style);
         switch (math_scripts_mode_par) {
@@ -3398,30 +3751,29 @@ static void make_scripts(pointer q, pointer p, scaled it, int cur_style, scaled
                 break;
         }
         shift_amount(x) = shift_down;
-
-        /* now find and correct for horizontal shift */
+        /*tex Now find and correct for horizontal shift. */
+        subtyp = 0;
         if (sub_n != null) {
             delta2 = find_math_kern(font(p), character(p),sub_f,sub_c,sub_mark_cmd, shift_down);
             if (delta2 == MATH_KERN_NOT_FOUND) {
                 delta2 = subshift ;
             } else {
                 delta2 = delta2 + subshift ;
+                subtyp = font_kern;
             }
         } else {
             delta2 = subshift ;
         }
         if (delta2 != 0) {
-            p = attach_hkern_to_new_hlist(q, delta2);
+            p = attach_hkern_to_new_hlist(q, delta2, subtyp);
         }
-
     } else {
-        /*
-            construct a superscript box |x|
+        /*tex
+
+            Construct a superscript box |x|. The bottom of a superscript should
+            never descend below the baseline plus one-fourth of the x-height.
 
-            the bottom of a superscript should never descend below the baseline plus
-            one-fourth of the x-height.
         */
-    /*  x = clean_box(supscr(q), sup_style(cur_style), cur_style); */
         x = clean_box(supscr(q), (noadoptionnosupscript(q) ? cur_style : sup_style(cur_style)), cur_style);
         width(x) = width(x) + space_after_script(cur_style);
         switch (math_scripts_mode_par) {
@@ -3451,33 +3803,35 @@ static void make_scripts(pointer q, pointer p, scaled it, int cur_style, scaled
         }
         if (subscr(q) == null) {
             shift_amount(x) = -shift_up;
-            /* now find and correct for horizontal shift */
+            /*tex Now find and correct for horizontal shift. */
+            subtyp = 0;
             if (sup_n != null) {
                 clr = find_math_kern(font(p),character(p),sup_f,sup_c,sup_mark_cmd,shift_up);
                 if (clr == MATH_KERN_NOT_FOUND) {
                     clr = supshift ;
                 } else {
                     clr = clr + supshift ;
+                    subtyp = font_kern;
                 }
             } else {
                 clr = supshift;
             }
             if (clr != 0) {
-                p = attach_hkern_to_new_hlist(q, clr);
+                p = attach_hkern_to_new_hlist(q, clr, subtyp);
             }
         } else {
-            /*
-                construct a sub/superscript combination box |x|, with the superscript offset
-                by |delta|
+            /*tex
 
-                when both subscript and superscript are present, the subscript must be
-                separated from the superscript by at least four times |default_rule_thickness|
+                Construct a sub/superscript combination box |x|, with the
+                superscript offset by |delta|. When both subscript and
+                superscript are present, the subscript must be separated from the
+                superscript by at least four times |default_rule_thickness| If
+                this condition would be violated, the subscript moves down, after
+                which both subscript and superscript move up so that the bottom
+                of the superscript is at least as high as the baseline plus
+                four-fifths of the x-height.
 
-                if this condition would be violated, the subscript moves down, after which
-                both subscript and superscript move up so that the bottom of the superscript
-                is at least as high as the baseline plus four-fifths of the x-height
             */
-        /*  y = clean_box(subscr(q) sub_style(cur_style), cur_style); */
             y = clean_box(subscr(q), (noadoptionnosubscript(q) ? cur_style : sub_style(cur_style)), cur_style);
             width(y) = width(y) + space_after_script(cur_style);
             switch (math_scripts_mode_par) {
@@ -3510,30 +3864,37 @@ static void make_scripts(pointer q, pointer p, scaled it, int cur_style, scaled
                     }
                 break;
             }
-            /* now find and correct for horizontal shift */
+            /*tex Now find and correct for horizontal shift. */
+            subtyp = 0;
             if (sub_n != null) {
                 delta2 = find_math_kern(font(p), character(p),sub_f,sub_c,sub_mark_cmd, shift_down);
                 if (delta2 == MATH_KERN_NOT_FOUND) {
                     delta2 = subshift ;
                 } else {
                     delta2 = delta2 + subshift ;
+                    subtyp = font_kern;
                 }
             } else {
                 delta2 = subshift ;
             }
             if (delta2 != 0) {
-                p = attach_hkern_to_new_hlist(q, delta2);
+                p = attach_hkern_to_new_hlist(q, delta2, subtyp);
             }
-            /*
-                now the horizontal shift for the superscript; the superscript is also to be shifted
-                by |delta1| (the italic correction)
+            /*tex
+
+                Now the horizontal shift for the superscript; the superscript is
+                also to be shifted by |delta1| (the italic correction).
+
             */
             clr = MATH_KERN_NOT_FOUND;
             if (sup_n != null) {
                 clr = find_math_kern(font(p),character(p),sup_f,sup_c,sup_mark_cmd,shift_up);
             }
+            /*tex
 
-            /* delta can already have been applied and now be 0 */
+                The delta can already have been applied and now be 0.
+
+            */
             if (delta2 == MATH_KERN_NOT_FOUND)
                 delta2 = - supshift ;
             else
@@ -3543,18 +3904,17 @@ static void make_scripts(pointer q, pointer p, scaled it, int cur_style, scaled
             } else {
                 shift_amount(x) = delta1 - delta2;
             }
-            /* todo: only if kern != 0 */
+            /*tex todo: only if kern != 0 */
             p = new_kern((shift_up - depth(x)) - (height(y) - shift_down));
             reset_attributes(p, node_attr(q));
             couple_nodes(x,p);
             couple_nodes(p,y);
-            /* we end up with funny dimensions */
+            /*tex We end up with funny dimensions. */
             x = vpackage(x, 0, additional, max_dimen, math_direction_par);
             reset_attributes(x, node_attr(q));
             shift_amount(x) = shift_down;
         }
     }
-
     if (new_hlist(q) == null) {
         new_hlist(q) = x;
     } else {
@@ -3575,12 +3935,15 @@ static void make_scripts(pointer q, pointer p, scaled it, int cur_style, scaled
     }
 }
 
-@ The |make_left_right| function constructs a left or right delimiter of
-the required size and returns the value |open_noad| or |close_noad|. The
-|left_noad_side| and |right_noad_side| will both be based on the original |style|,
-so they will have consistent sizes.
+/*tex
+
+    The |make_left_right| function constructs a left or right delimiter of the
+    required size and returns the value |open_noad| or |close_noad|. The
+    |left_noad_side| and |right_noad_side| will both be based on the original
+    |style|, so they will have consistent sizes.
+
+*/
 
-@c
 static small_number make_left_right(pointer q, int style, scaled max_d, scaled max_h)
 {
     scaled delta;
@@ -3589,21 +3952,21 @@ static small_number make_left_right(pointer q, int style, scaled max_d, scaled m
     boolean stack = false;
     boolean axis = false;
     int same = subtype(q);
-
     setup_cur_size(style);
-
     if ((delimiterheight(q)!=0) || (delimiterdepth(q)!=0)) {
 
         delta = delimiterheight(q) + delimiterdepth(q);
         tmp = do_delimiter(q, delimiter(q), cur_size, delta, false, style, false, &stack, &ic, &same);
         delimiteritalic(q) = ic;
+        /*tex
 
-        /* beware, a stacked delimiter has a shift but no corrected height/depth (yet) */
+            Beware, a stacked delimiter has a shift but no corrected height/depth
+            (yet).
 
+        */
         if (stack) {
             shift_amount(tmp) = delimiterdepth(q);
         }
-
         if (delimiterexact(q)) {
             delimiterheight(q) = height(tmp) - shift_amount(tmp);
             delimiterdepth(q)  = depth(tmp)  + shift_amount(tmp);
@@ -3629,7 +3992,7 @@ static small_number make_left_right(pointer q, int style, scaled max_d, scaled m
     }
     delimiter(q) = null;
     assign_new_hlist(q, tmp);
-    delimitersamesize(q) = same; /* new */
+    delimitersamesize(q) = same;
     if (delimiterclass(q) >= ord_noad_type) {
         if (delimiterclass(q) <= inner_noad_type) {
             return delimiterclass(q);
@@ -3643,35 +4006,32 @@ static small_number make_left_right(pointer q, int style, scaled max_d, scaled m
     }
 }
 
-@ @c
-#define TEXT_STYLES(A,B) do {					\
-    def_math_param(A,display_style,(B),level_one);		\
-    def_math_param(A,cramped_display_style,(B),level_one);	\
-    def_math_param(A,text_style,(B),level_one);			\
-    def_math_param(A,cramped_text_style,(B),level_one);		\
+#define TEXT_STYLES(A,B) do {                              \
+    def_math_param(A,display_style,(B),level_one);         \
+    def_math_param(A,cramped_display_style,(B),level_one); \
+    def_math_param(A,text_style,(B),level_one);            \
+    def_math_param(A,cramped_text_style,(B),level_one);    \
   } while (0)
 
-#define SCRIPT_STYLES(A,B) do {						\
-    def_math_param(A,script_style,(B),level_one);			\
-    def_math_param(A,cramped_script_style,(B),level_one);		\
-    def_math_param(A,script_script_style,(B),level_one);		\
-    def_math_param(A,cramped_script_script_style,(B),level_one);	\
+#define SCRIPT_STYLES(A,B) do {                                  \
+    def_math_param(A,script_style,(B),level_one);                \
+    def_math_param(A,cramped_script_style,(B),level_one);        \
+    def_math_param(A,script_script_style,(B),level_one);         \
+    def_math_param(A,cramped_script_script_style,(B),level_one); \
   } while (0)
 
-#define ALL_STYLES(A,B) do {			\
-    TEXT_STYLES(A,(B));				\
-    SCRIPT_STYLES(A,(B));			\
+#define ALL_STYLES(A,B) do { \
+    TEXT_STYLES(A,(B));      \
+    SCRIPT_STYLES(A,(B));    \
   } while (0)
 
-#define SPLIT_STYLES(A,B,C) do {		\
-    TEXT_STYLES(A,(B));				\
-    SCRIPT_STYLES(A,(C));			\
+#define SPLIT_STYLES(A,B,C) do { \
+    TEXT_STYLES(A,(B));          \
+    SCRIPT_STYLES(A,(C));        \
   } while (0)
 
-
 void initialize_math_spacing(void)
 {
-    /* *INDENT-OFF* */
     ALL_STYLES   (math_param_ord_ord_spacing,     0);
     ALL_STYLES   (math_param_ord_op_spacing,      thin_mu_skip_code);
     SPLIT_STYLES (math_param_ord_bin_spacing,     med_mu_skip_code, 0);
@@ -3743,10 +4103,8 @@ void initialize_math_spacing(void)
     ALL_STYLES   (math_param_inner_close_spacing, 0);
     SPLIT_STYLES (math_param_inner_punct_spacing, thin_mu_skip_code, 0);
     SPLIT_STYLES (math_param_inner_inner_spacing, thin_mu_skip_code, 0);
-    /* *INDENT-ON* */
 }
 
-@ @c
 #define both_types(A,B) ((A)*16+(B))
 
 static pointer math_spacing_glue(int l_type, int r_type, int mstyle, scaled mmu)
@@ -3758,102 +4116,99 @@ static pointer math_spacing_glue(int l_type, int r_type, int mstyle, scaled mmu)
     if (r_type == op_noad_type_limits || r_type == op_noad_type_no_limits)
         r_type = op_noad_type_normal;
     switch (both_types(l_type, r_type)) {
-    /* *INDENT-OFF* */
-    case both_types(ord_noad_type,       ord_noad_type      ): x = get_math_param(math_param_ord_ord_spacing,mstyle); break;
-    case both_types(ord_noad_type,       op_noad_type_normal): x = get_math_param(math_param_ord_op_spacing,mstyle); break;
-    case both_types(ord_noad_type,       bin_noad_type      ): x = get_math_param(math_param_ord_bin_spacing,mstyle); break;
-    case both_types(ord_noad_type,       rel_noad_type      ): x = get_math_param(math_param_ord_rel_spacing,mstyle); break;
-    case both_types(ord_noad_type,       open_noad_type     ): x = get_math_param(math_param_ord_open_spacing,mstyle); break;
-    case both_types(ord_noad_type,       close_noad_type    ): x = get_math_param(math_param_ord_close_spacing,mstyle); break;
-    case both_types(ord_noad_type,       punct_noad_type    ): x = get_math_param(math_param_ord_punct_spacing,mstyle); break;
-    case both_types(ord_noad_type,       inner_noad_type    ): x = get_math_param(math_param_ord_inner_spacing,mstyle); break;
-    case both_types(op_noad_type_normal, ord_noad_type      ): x = get_math_param(math_param_op_ord_spacing,mstyle); break;
-    case both_types(op_noad_type_normal, op_noad_type_normal): x = get_math_param(math_param_op_op_spacing,mstyle); break;
-#if 0
-    case both_types(op_noad_type_normal, bin_noad_type      ): x = get_math_param(math_param_op_bin_spacing,mstyle); break;
-#endif
-    case both_types(op_noad_type_normal, rel_noad_type      ): x = get_math_param(math_param_op_rel_spacing,mstyle); break;
-    case both_types(op_noad_type_normal, open_noad_type     ): x = get_math_param(math_param_op_open_spacing,mstyle); break;
-    case both_types(op_noad_type_normal, close_noad_type    ): x = get_math_param(math_param_op_close_spacing,mstyle); break;
-    case both_types(op_noad_type_normal, punct_noad_type    ): x = get_math_param(math_param_op_punct_spacing,mstyle); break;
-    case both_types(op_noad_type_normal, inner_noad_type    ): x = get_math_param(math_param_op_inner_spacing,mstyle); break;
-    case both_types(bin_noad_type,       ord_noad_type      ): x = get_math_param(math_param_bin_ord_spacing,mstyle); break;
-    case both_types(bin_noad_type,       op_noad_type_normal): x = get_math_param(math_param_bin_op_spacing,mstyle); break;
-#if 0
-    case both_types(bin_noad_type,       bin_noad_type      ): x = get_math_param(math_param_bin_bin_spacing,mstyle); break;
-    case both_types(bin_noad_type,       rel_noad_type      ): x = get_math_param(math_param_bin_rel_spacing,mstyle); break;
-#endif
-    case both_types(bin_noad_type,       open_noad_type     ): x = get_math_param(math_param_bin_open_spacing,mstyle); break;
-#if 0
-    case both_types(bin_noad_type,       close_noad_type    ): x = get_math_param(math_param_bin_close_spacing,mstyle); break;
-    case both_types(bin_noad_type,       punct_noad_type    ): x = get_math_param(math_param_bin_punct_spacing,mstyle); break;
-#endif
-    case both_types(bin_noad_type,       inner_noad_type    ): x = get_math_param(math_param_bin_inner_spacing,mstyle); break;
-    case both_types(rel_noad_type,       ord_noad_type      ): x = get_math_param(math_param_rel_ord_spacing,mstyle); break;
-    case both_types(rel_noad_type,       op_noad_type_normal): x = get_math_param(math_param_rel_op_spacing,mstyle); break;
-#if 0
-    case both_types(rel_noad_type,       bin_noad_type      ): x = get_math_param(math_param_rel_bin_spacing,mstyle); break;
-#endif
-    case both_types(rel_noad_type,       rel_noad_type      ): x = get_math_param(math_param_rel_rel_spacing,mstyle); break;
-    case both_types(rel_noad_type,       open_noad_type     ): x = get_math_param(math_param_rel_open_spacing,mstyle); break;
-    case both_types(rel_noad_type,       close_noad_type    ): x = get_math_param(math_param_rel_close_spacing,mstyle); break;
-    case both_types(rel_noad_type,       punct_noad_type    ): x = get_math_param(math_param_rel_punct_spacing,mstyle); break;
-    case both_types(rel_noad_type,       inner_noad_type    ): x = get_math_param(math_param_rel_inner_spacing,mstyle); break;
-    case both_types(open_noad_type,      ord_noad_type      ): x = get_math_param(math_param_open_ord_spacing,mstyle); break;
-    case both_types(open_noad_type,      op_noad_type_normal): x = get_math_param(math_param_open_op_spacing,mstyle); break;
-#if 0
-    case both_types(open_noad_type,      bin_noad_type      ): x = get_math_param(math_param_open_bin_spacing,mstyle); break;
-#endif
-    case both_types(open_noad_type,      rel_noad_type      ): x = get_math_param(math_param_open_rel_spacing,mstyle); break;
-    case both_types(open_noad_type,      open_noad_type     ): x = get_math_param(math_param_open_open_spacing,mstyle); break;
-    case both_types(open_noad_type,      close_noad_type    ): x = get_math_param(math_param_open_close_spacing,mstyle); break;
-    case both_types(open_noad_type,      punct_noad_type    ): x = get_math_param(math_param_open_punct_spacing,mstyle); break;
-    case both_types(open_noad_type,      inner_noad_type    ): x = get_math_param(math_param_open_inner_spacing,mstyle); break;
-    case both_types(close_noad_type,     ord_noad_type      ): x = get_math_param(math_param_close_ord_spacing,mstyle); break;
-    case both_types(close_noad_type,     op_noad_type_normal): x = get_math_param(math_param_close_op_spacing,mstyle); break;
-    case both_types(close_noad_type,     bin_noad_type      ): x = get_math_param(math_param_close_bin_spacing,mstyle); break;
-    case both_types(close_noad_type,     rel_noad_type      ): x = get_math_param(math_param_close_rel_spacing,mstyle); break;
-    case both_types(close_noad_type,     open_noad_type     ): x = get_math_param(math_param_close_open_spacing,mstyle); break;
-    case both_types(close_noad_type,     close_noad_type    ): x = get_math_param(math_param_close_close_spacing,mstyle); break;
-    case both_types(close_noad_type,     punct_noad_type    ): x = get_math_param(math_param_close_punct_spacing,mstyle); break;
-    case both_types(close_noad_type,     inner_noad_type    ): x = get_math_param(math_param_close_inner_spacing,mstyle); break;
-    case both_types(punct_noad_type,     ord_noad_type      ): x = get_math_param(math_param_punct_ord_spacing,mstyle); break;
-    case both_types(punct_noad_type,     op_noad_type_normal): x = get_math_param(math_param_punct_op_spacing,mstyle); break;
-#if 0
-    case both_types(punct_noad_type,     bin_noad_type      ): x = get_math_param(math_param_punct_bin_spacing,mstyle); break;
-#endif
-    case both_types(punct_noad_type,     rel_noad_type      ): x = get_math_param(math_param_punct_rel_spacing,mstyle); break;
-    case both_types(punct_noad_type,     open_noad_type     ): x = get_math_param(math_param_punct_open_spacing,mstyle); break;
-    case both_types(punct_noad_type,     close_noad_type    ): x = get_math_param(math_param_punct_close_spacing,mstyle); break;
-    case both_types(punct_noad_type,     punct_noad_type    ): x = get_math_param(math_param_punct_punct_spacing,mstyle); break;
-    case both_types(punct_noad_type,     inner_noad_type    ): x = get_math_param(math_param_punct_inner_spacing,mstyle); break;
-    case both_types(inner_noad_type,     ord_noad_type      ): x = get_math_param(math_param_inner_ord_spacing,mstyle); break;
-    case both_types(inner_noad_type,     op_noad_type_normal): x = get_math_param(math_param_inner_op_spacing,mstyle); break;
-    case both_types(inner_noad_type,     bin_noad_type      ): x = get_math_param(math_param_inner_bin_spacing,mstyle); break;
-    case both_types(inner_noad_type,     rel_noad_type      ): x = get_math_param(math_param_inner_rel_spacing,mstyle); break;
-    case both_types(inner_noad_type,     open_noad_type     ): x = get_math_param(math_param_inner_open_spacing,mstyle); break;
-    case both_types(inner_noad_type,     close_noad_type    ): x = get_math_param(math_param_inner_close_spacing,mstyle); break;
-    case both_types(inner_noad_type,     punct_noad_type    ): x = get_math_param(math_param_inner_punct_spacing,mstyle); break;
-    case both_types(inner_noad_type,     inner_noad_type    ): x = get_math_param(math_param_inner_inner_spacing,mstyle); break;
-    /* *INDENT-ON* */
+        case both_types(ord_noad_type,       ord_noad_type      ): x = get_math_param(math_param_ord_ord_spacing,mstyle); break;
+        case both_types(ord_noad_type,       op_noad_type_normal): x = get_math_param(math_param_ord_op_spacing,mstyle); break;
+        case both_types(ord_noad_type,       bin_noad_type      ): x = get_math_param(math_param_ord_bin_spacing,mstyle); break;
+        case both_types(ord_noad_type,       rel_noad_type      ): x = get_math_param(math_param_ord_rel_spacing,mstyle); break;
+        case both_types(ord_noad_type,       open_noad_type     ): x = get_math_param(math_param_ord_open_spacing,mstyle); break;
+        case both_types(ord_noad_type,       close_noad_type    ): x = get_math_param(math_param_ord_close_spacing,mstyle); break;
+        case both_types(ord_noad_type,       punct_noad_type    ): x = get_math_param(math_param_ord_punct_spacing,mstyle); break;
+        case both_types(ord_noad_type,       inner_noad_type    ): x = get_math_param(math_param_ord_inner_spacing,mstyle); break;
+        case both_types(op_noad_type_normal, ord_noad_type      ): x = get_math_param(math_param_op_ord_spacing,mstyle); break;
+        case both_types(op_noad_type_normal, op_noad_type_normal): x = get_math_param(math_param_op_op_spacing,mstyle); break;
+        /* shouldn't happen */
+        case both_types(op_noad_type_normal, bin_noad_type      ): x = get_math_param(math_param_op_bin_spacing,mstyle); break;
+        /* */
+        case both_types(op_noad_type_normal, rel_noad_type      ): x = get_math_param(math_param_op_rel_spacing,mstyle); break;
+        case both_types(op_noad_type_normal, open_noad_type     ): x = get_math_param(math_param_op_open_spacing,mstyle); break;
+        case both_types(op_noad_type_normal, close_noad_type    ): x = get_math_param(math_param_op_close_spacing,mstyle); break;
+        case both_types(op_noad_type_normal, punct_noad_type    ): x = get_math_param(math_param_op_punct_spacing,mstyle); break;
+        case both_types(op_noad_type_normal, inner_noad_type    ): x = get_math_param(math_param_op_inner_spacing,mstyle); break;
+        case both_types(bin_noad_type,       ord_noad_type      ): x = get_math_param(math_param_bin_ord_spacing,mstyle); break;
+        case both_types(bin_noad_type,       op_noad_type_normal): x = get_math_param(math_param_bin_op_spacing,mstyle); break;
+        /* shouldn't happen */
+        case both_types(bin_noad_type,       bin_noad_type      ): x = get_math_param(math_param_bin_bin_spacing,mstyle); break;
+        case both_types(bin_noad_type,       rel_noad_type      ): x = get_math_param(math_param_bin_rel_spacing,mstyle); break;
+        /* */
+        case both_types(bin_noad_type,       open_noad_type     ): x = get_math_param(math_param_bin_open_spacing,mstyle); break;
+        /* shouldn't happen */
+        case both_types(bin_noad_type,       close_noad_type    ): x = get_math_param(math_param_bin_close_spacing,mstyle); break;
+        case both_types(bin_noad_type,       punct_noad_type    ): x = get_math_param(math_param_bin_punct_spacing,mstyle); break;
+        /* */
+        case both_types(bin_noad_type,       inner_noad_type    ): x = get_math_param(math_param_bin_inner_spacing,mstyle); break;
+        case both_types(rel_noad_type,       ord_noad_type      ): x = get_math_param(math_param_rel_ord_spacing,mstyle); break;
+        case both_types(rel_noad_type,       op_noad_type_normal): x = get_math_param(math_param_rel_op_spacing,mstyle); break;
+        /* shouldn't happen */
+        case both_types(rel_noad_type,       bin_noad_type      ): x = get_math_param(math_param_rel_bin_spacing,mstyle); break;
+        /* */
+        case both_types(rel_noad_type,       rel_noad_type      ): x = get_math_param(math_param_rel_rel_spacing,mstyle); break;
+        case both_types(rel_noad_type,       open_noad_type     ): x = get_math_param(math_param_rel_open_spacing,mstyle); break;
+        case both_types(rel_noad_type,       close_noad_type    ): x = get_math_param(math_param_rel_close_spacing,mstyle); break;
+        case both_types(rel_noad_type,       punct_noad_type    ): x = get_math_param(math_param_rel_punct_spacing,mstyle); break;
+        case both_types(rel_noad_type,       inner_noad_type    ): x = get_math_param(math_param_rel_inner_spacing,mstyle); break;
+        case both_types(open_noad_type,      ord_noad_type      ): x = get_math_param(math_param_open_ord_spacing,mstyle); break;
+        case both_types(open_noad_type,      op_noad_type_normal): x = get_math_param(math_param_open_op_spacing,mstyle); break;
+        /* shouldn't happen */
+        case both_types(open_noad_type,      bin_noad_type      ): x = get_math_param(math_param_open_bin_spacing,mstyle); break;
+        /* */
+        case both_types(open_noad_type,      rel_noad_type      ): x = get_math_param(math_param_open_rel_spacing,mstyle); break;
+        case both_types(open_noad_type,      open_noad_type     ): x = get_math_param(math_param_open_open_spacing,mstyle); break;
+        case both_types(open_noad_type,      close_noad_type    ): x = get_math_param(math_param_open_close_spacing,mstyle); break;
+        case both_types(open_noad_type,      punct_noad_type    ): x = get_math_param(math_param_open_punct_spacing,mstyle); break;
+        case both_types(open_noad_type,      inner_noad_type    ): x = get_math_param(math_param_open_inner_spacing,mstyle); break;
+        case both_types(close_noad_type,     ord_noad_type      ): x = get_math_param(math_param_close_ord_spacing,mstyle); break;
+        case both_types(close_noad_type,     op_noad_type_normal): x = get_math_param(math_param_close_op_spacing,mstyle); break;
+        case both_types(close_noad_type,     bin_noad_type      ): x = get_math_param(math_param_close_bin_spacing,mstyle); break;
+        case both_types(close_noad_type,     rel_noad_type      ): x = get_math_param(math_param_close_rel_spacing,mstyle); break;
+        case both_types(close_noad_type,     open_noad_type     ): x = get_math_param(math_param_close_open_spacing,mstyle); break;
+        case both_types(close_noad_type,     close_noad_type    ): x = get_math_param(math_param_close_close_spacing,mstyle); break;
+        case both_types(close_noad_type,     punct_noad_type    ): x = get_math_param(math_param_close_punct_spacing,mstyle); break;
+        case both_types(close_noad_type,     inner_noad_type    ): x = get_math_param(math_param_close_inner_spacing,mstyle); break;
+        case both_types(punct_noad_type,     ord_noad_type      ): x = get_math_param(math_param_punct_ord_spacing,mstyle); break;
+        case both_types(punct_noad_type,     op_noad_type_normal): x = get_math_param(math_param_punct_op_spacing,mstyle); break;
+        /* shouldn't happen */
+        case both_types(punct_noad_type,     bin_noad_type      ): x = get_math_param(math_param_punct_bin_spacing,mstyle); break;
+        /* */
+        case both_types(punct_noad_type,     rel_noad_type      ): x = get_math_param(math_param_punct_rel_spacing,mstyle); break;
+        case both_types(punct_noad_type,     open_noad_type     ): x = get_math_param(math_param_punct_open_spacing,mstyle); break;
+        case both_types(punct_noad_type,     close_noad_type    ): x = get_math_param(math_param_punct_close_spacing,mstyle); break;
+        case both_types(punct_noad_type,     punct_noad_type    ): x = get_math_param(math_param_punct_punct_spacing,mstyle); break;
+        case both_types(punct_noad_type,     inner_noad_type    ): x = get_math_param(math_param_punct_inner_spacing,mstyle); break;
+        case both_types(inner_noad_type,     ord_noad_type      ): x = get_math_param(math_param_inner_ord_spacing,mstyle); break;
+        case both_types(inner_noad_type,     op_noad_type_normal): x = get_math_param(math_param_inner_op_spacing,mstyle); break;
+        case both_types(inner_noad_type,     bin_noad_type      ): x = get_math_param(math_param_inner_bin_spacing,mstyle); break;
+        case both_types(inner_noad_type,     rel_noad_type      ): x = get_math_param(math_param_inner_rel_spacing,mstyle); break;
+        case both_types(inner_noad_type,     open_noad_type     ): x = get_math_param(math_param_inner_open_spacing,mstyle); break;
+        case both_types(inner_noad_type,     close_noad_type    ): x = get_math_param(math_param_inner_close_spacing,mstyle); break;
+        case both_types(inner_noad_type,     punct_noad_type    ): x = get_math_param(math_param_inner_punct_spacing,mstyle); break;
+        case both_types(inner_noad_type,     inner_noad_type    ): x = get_math_param(math_param_inner_inner_spacing,mstyle); break;
     }
     if (x < 0) {
         confusion("mathspacing");
     }
     if (x != 0) {
         if (x <= thick_mu_skip_code) {
-            /* trap thin/med/thick settings cf. old TeX */
-            z = math_glue(glue_par(x), mmu); /* allocates a glue */
-            /* store a symbolic subtype */
+            /*tex trap thin/med/thick settings cf.\ old \TeX */
+            z = math_glue(glue_par(x), mmu);
+            /*tex store a symbolic subtype */
             subtype(z) = (quarterword) (x + 1);
         } else {
-            z = math_glue(x, mmu); /* allocates a glue */
+            z = math_glue(x, mmu);
         }
     }
     return z;
 }
 
-@ @c
 static pointer check_nucleus_complexity(halfword q, scaled * delta, int cur_style, int *same)
 {
     pointer p = null;
@@ -3866,37 +4221,36 @@ static pointer check_nucleus_complexity(halfword q, scaled * delta, int cur_styl
         case math_text_char_node:
             fetch(nucleus(q));
             if (char_exists(cur_f, cur_c)) {
-                /* we could look at neighbours */
+                /*tex we could look at neighbours */
                 if (do_new_math(cur_f)) {
-                    *delta = 0 ; /* cf spec only the last one */
+                    /*tex cf spec only the last one */
+                    *delta = 0 ;
                 } else {
                     *delta = char_italic(cur_f, cur_c);
                 }
                 p = new_glyph(cur_f, cur_c);
                 reset_attributes(p, node_attr(nucleus(q)));
                 if (do_new_math(cur_f)) {
-                    if (! math_no_char_italic_par) {
-                        /* keep italic, but bad with two successive letters */
-                    } else if (get_char_cat_code(cur_c) == 11) {
-                        /* no italic correction in mid-word of text font */
+                    if (get_char_cat_code(cur_c) == 11) {
+                        /*tex no italic correction in mid-word of text font */
                         *delta = 0;
                     }
                 } else {
-                    /* no italic correction in mid-word of text font */
+                    /*tex no italic correction in mid-word of text font */
                     if (((type(nucleus(q))) == math_text_char_node) && (space(cur_f) != 0)) {
                         *delta = 0;
                     }
                 }
-                /* so we only add italic correction when we have no scripts */
+                /*tex so we only add italic correction when we have no scripts */
                 if ((subscr(q) == null) && (supscr(q) == null) && (*delta != 0)) {
                     pointer x = new_kern(*delta);
                     subtype(x) = italic_kern;
                     reset_attributes(x, node_attr(nucleus(q)));
                     couple_nodes(p,x);
                     *delta = 0;
-                } else /* needs checking but looks ok */
-                if (do_new_math(cur_f)) {
-                    *delta = char_italic(cur_f, cur_c); /* must be more selective */
+                } else if (do_new_math(cur_f)) {
+                    /*tex Needs checking but looks ok. It must be more selective. */
+                    *delta = char_italic(cur_f, cur_c);
                 }
             }
             break;
@@ -3905,60 +4259,80 @@ static pointer check_nucleus_complexity(halfword q, scaled * delta, int cur_styl
             break;
         case sub_mlist_node:
             t = math_list(nucleus(q));
-            mlist_to_hlist(t, false, cur_style);   /* recursive call */
-if (same != NULL && type(t) == fence_noad && delimitersamesize(t)) {
-    *same = delimitersamesize(t) ;
-}
+            /*tex Recursive call: */
+            mlist_to_hlist(t, false, cur_style);
+            if (same != NULL && type(t) == fence_noad && delimitersamesize(t)) {
+                *same = delimitersamesize(t) ;
+            }
             setup_cur_size(cur_style);
             p = hpack(vlink(temp_head), 0, additional, -1);
             reset_attributes(p, node_attr(nucleus(q)));
             break;
         default:
-            confusion("mlist2");    /* this can't happen mlist2 */
+            confusion("mlist2");
     }
     return p;
 }
 
-@ Here is the overall plan of |mlist_to_hlist|, and the list of its
-   local variables.
+/*tex
+
+    Here is the overall plan of |mlist_to_hlist|, and the list of its local
+    variables.
+
+*/
 
-@c
 void mlist_to_hlist(pointer mlist, boolean penalties, int cur_style)
 {
-    pointer q = mlist;                    /* runs through the mlist */
-    pointer r = null;                     /* the most recent noad preceding |q| */
-    int style = cur_style;                /* tuck global parameter away as local variable */
-    int r_type = simple_noad;             /* the |type| of noad |r|, or |op_noad| if |r=null| */
-    int r_subtype = op_noad_type_normal;  /* the |subtype| of noad |r| if |r_type| is |fence_noad| */
-    int t;                                /* the effective |type| of noad |q| during the second pass */
-    int t_subtype;                        /* the effective |subtype| of noad |q| during the second pass */
+    /*tex runs through the mlist */
+    pointer q = mlist;
+    /*tex the most recent noad preceding |q| */
+    pointer r = null;
+    /*tex tuck global parameter away as local variable */
+    int style = cur_style;
+    /*tex the |type| of noad |r|, or |op_noad| if |r=null| */
+    int r_type = simple_noad;
+    /*tex the |subtype| of noad |r| if |r_type| is |fence_noad| */
+    int r_subtype = op_noad_type_normal;
+    /*tex the effective |type| of noad |q| during the second pass */
+    int t;
+    /*tex the effective |subtype| of noad |q| during the second pass */
+    int t_subtype;
     pointer p = null;
     pointer pp = null;
     pointer z = null;
     halfword nxt ;
     int same = 0;
-    int pen;                              /* a penalty to be inserted */
-    int prepen;                           /* a penalty to be inserted */
-    scaled max_hl = 0;                    /* maximum height of the list translated so far */
-    scaled max_d = 0;                     /* maximum depth of the list translated so far */
-    scaled delta;                         /* italic correction offset for subscript and superscript */
-    scaled cur_mu;                        /* the math unit width corresponding to |cur_size| */
+    /*tex a penalty to be inserted */
+    int pen;
+    /*tex a penalty to be inserted */
+    int prepen;
+    /*tex maximum height of the list translated so far */
+    scaled max_hl = 0;
+    /*tex maximum depth of the list translated so far */
+    scaled max_d = 0;
+    /*tex italic correction offset for subscript and superscript */
+    scaled delta;
+    /*tex the math unit width corresponding to |cur_size| */
+    scaled cur_mu;
     r_subtype = op_noad_type_normal;
     setup_cur_size(cur_style);
     cur_mu = x_over_n(get_math_quad_size(cur_size), 18);
     if (math_penalties_mode_par) {
-        /* we could do this via the callback but it's nice to have it as primitive too */
+        /*tex
+            We could do this via the callback but it's nice to have it as
+            primitive too.
+        */
         penalties = 1;
     }
     while (q != null) {
-        /*
-            we use the fact that no character nodes appear in an mlist, hence
-            the field |type(q)| is always present.
+        /*tex
 
-            one of the things we must do on the first pass is change a |bin_noad| to
-            an |ord_noad| if the |bin_noad| is not in the context of a binary operator
+            We use the fact that no character nodes appear in an mlist, hence the
+            field |type(q)| is always present.One of the things we must do on the
+            first pass is change a |bin_noad| to an |ord_noad| if the |bin_noad|
+            is not in the context of a binary operator. The values of |r| and
+            |r_type| make this fairly easy.
 
-            the values of |r| and |r_type| make this fairly easy
         */
       RESWITCH:
         delta = 0;
@@ -3966,66 +4340,69 @@ void mlist_to_hlist(pointer mlist, boolean penalties, int cur_style)
         switch (type(q)) {
             case simple_noad:
                 switch (subtype(q)) {
-                case bin_noad_type:
-                    switch (r_type) {
-                    case simple_noad:
-                        switch (r_subtype) {
-                        case bin_noad_type:
-                        case op_noad_type_normal:
-                        case op_noad_type_limits:
-                        case op_noad_type_no_limits:
-                        case rel_noad_type:
-                        case open_noad_type:
-                        case punct_noad_type:
-                            subtype(q) = ord_noad_type;
-                            goto RESWITCH;
-                            break;
+                    case bin_noad_type:
+                        switch (r_type) {
+                            case simple_noad:
+                                switch (r_subtype) {
+                                case bin_noad_type:
+                                case op_noad_type_normal:
+                                case op_noad_type_limits:
+                                case op_noad_type_no_limits:
+                                case rel_noad_type:
+                                case open_noad_type:
+                                case punct_noad_type:
+                                    subtype(q) = ord_noad_type;
+                                    goto RESWITCH;
+                                    break;
+                                }
+                                break;
+                            case fence_noad:
+                                if (r_subtype == left_noad_side) {
+                                    /*tex So these can best be the same size. */
+                                    subtype(q) = ord_noad_type;
+                                    goto RESWITCH;
+                                }
+                                break;
                         }
                         break;
-                    case fence_noad:
-                        if (r_subtype == left_noad_side) {
-                            subtype(q) = ord_noad_type; /* so these can best be the same size */
-                            goto RESWITCH;
+                    case over_noad_type:
+                        make_over(q, cur_style, cur_size, math_rules_fam_par);
+                        break;
+                    case under_noad_type:
+                        make_under(q, cur_style, cur_size, math_rules_fam_par);
+                        break;
+                    case vcenter_noad_type:
+                        make_vcenter(q);
+                        break;
+                    case rel_noad_type:
+                    case close_noad_type:
+                    case punct_noad_type:
+                        if (r_type == simple_noad && r_subtype == bin_noad_type) {
+                            /*tex Assumes the same size; can't this go. */
+                            type(r) = simple_noad;
+                            subtype(r) = ord_noad_type;
                         }
                         break;
-                    }
-                    break;
-                case over_noad_type:
-                    make_over(q, cur_style, cur_size, math_rules_fam_par);
-                    break;
-                case under_noad_type:
-                    make_under(q, cur_style, cur_size, math_rules_fam_par);
-                    break;
-                case vcenter_noad_type:
-                    make_vcenter(q);
-                    break;
-                case rel_noad_type:
-                case close_noad_type:
-                case punct_noad_type:
-                    if (r_type == simple_noad && r_subtype == bin_noad_type) {
-                        type(r) = simple_noad; /* assumes the same size .. can't this go */
-                        subtype(r) = ord_noad_type;
-                    }
-                    break;
-                case op_noad_type_normal:
-                case op_noad_type_limits:
-                case op_noad_type_no_limits:
-                    delta = make_op(q, cur_style);
-                    if ((subtype(q) == op_noad_type_limits) || (subtype(q) == op_noad_type_no_limits))
-                        goto CHECK_DIMENSIONS;
-                    break;
-                case ord_noad_type:
-                    make_ord(q);
-                    break;
-                case open_noad_type:
-                case inner_noad_type:
-                    break;
+                    case op_noad_type_normal:
+                    case op_noad_type_limits:
+                    case op_noad_type_no_limits:
+                        delta = make_op(q, cur_style);
+                        if ((subtype(q) == op_noad_type_limits) || (subtype(q) == op_noad_type_no_limits))
+                            goto CHECK_DIMENSIONS;
+                        break;
+                    case ord_noad_type:
+                        make_ord(q);
+                        break;
+                    case open_noad_type:
+                    case inner_noad_type:
+                        break;
                 }
                 break;
             case fence_noad:
                 if (subtype(q) != left_noad_side) {
                     if (r_type == simple_noad && r_subtype == bin_noad_type) {
-                        type(r) = simple_noad; /* assumes the same size  */
+                        /*tex Assumes the same size. */
+                        type(r) = simple_noad;
                         subtype(r) = ord_noad_type;
                     }
                 }
@@ -4060,16 +4437,20 @@ void mlist_to_hlist(pointer mlist, boolean penalties, int cur_style)
                 break;
             case choice_node:
                 switch (cur_style / 2) {
-                case 0: /* |display_style=0| */
+                case 0:
+                    /*tex |display_style=0| */
                     choose_mlist(display_mlist);
                     break;
-                case 1: /* |text_style=2| */
+                case 1:
+                    /*tex |text_style=2| */
                     choose_mlist(text_mlist);
                     break;
-                case 2: /* |script_style=4| */
+                case 2:
+                    /*tex |script_style=4| */
                     choose_mlist(script_mlist);
                     break;
-                case 3: /* |script_script_style=6| */
+                case 3:
+                    /*tex |script_script_style=6| */
                     choose_mlist(script_script_mlist);
                     break;
                 }
@@ -4105,14 +4486,16 @@ void mlist_to_hlist(pointer mlist, boolean penalties, int cur_style)
                 goto DONE_WITH_NODE;
                 break;
             case glue_node:
-                /*
-                    conditional math glue (`\.{\\nonscript}') results in a |glue_node|
-                    pointing to |zero_glue|, with |subtype(q)=cond_math_glue|; in such a case
-                    the node following will be eliminated if it is a glue or kern node and if the
-                    current size is different from |text_size|
+                /*tex
+
+                    Conditional math glue (`\.{\\nonscript}') results in a
+                    |glue_node| pointing to |zero_glue|, with
+                    |subtype(q)=cond_math_glue|; in such a case the node
+                    following will be eliminated if it is a glue or kern node and
+                    if the current size is different from |text_size|.
 
-                    unconditional math glue (`\.{\\muskip}') is converted to normal glue by
-                    multiplying the dimensions by |cur_mu|
+                    Unconditional math glue (`\.{\\muskip}') is converted to
+                    normal glue by multiplying the dimensions by |cur_mu|.
 
                 */
                 if (subtype(q) == mu_glue) {
@@ -4139,29 +4522,31 @@ void mlist_to_hlist(pointer mlist, boolean penalties, int cur_style)
             default:
                 confusion("mlist1");
         }
-        /*
-            When we get to the following part of the program, we have ``fallen through''
-            from cases that did not lead to |check_dimensions| or |done_with_noad| or
-            |done_with_node|. Thus, |q|~points to a noad whose nucleus may need to be
-            converted to an hlist, and whose subscripts and superscripts need to be
-            appended if they are present.
+        /*tex
 
-            If |nucleus(q)| is not a |math_char|, the variable |delta| is the amount
-            by which a superscript should be moved right with respect to a subscript
-            when both are present.
+            When we get to the following part of the program, we have ``fallen
+            through'' from cases that did not lead to |check_dimensions| or
+            |done_with_noad| or |done_with_node|. Thus, |q|~points to a noad
+            whose nucleus may need to be converted to an hlist, and whose
+            subscripts and superscripts need to be appended if they are present.
+
+            If |nucleus(q)| is not a |math_char|, the variable |delta| is the
+            amount by which a superscript should be moved right with respect to a
+            subscript when both are present.
 
         */
-same = 0 ;
+        same = 0 ;
         p = check_nucleus_complexity(q, &delta, cur_style, &same);
-if (same) {
-    noadextra4(q) = same ;
-}
+        if (same) {
+            noadextra4(q) = same ;
+        }
         if ((subscr(q) == null) && (supscr(q) == null)) {
-            /*
+            /*tex
+
                 Adding italic correction here is kind of fuzzy because some
-                characters already have that built in. However, we also add
-                it in the scripts so if it's optional here it also should
-                be there.
+                characters already have that built in. However, we also add it in
+                the scripts so if it's optional here it also should be there.
+
             */
             if (nxt && (math_italics_mode_par > 0) && (delta != 0)) {
                 if (type(nxt) == simple_noad) {
@@ -4199,7 +4584,7 @@ if (same) {
             }
             assign_new_hlist(q, p);
         } else {
-            /* top, bottom */
+            /*tex top, bottom */
             make_scripts(q, p, delta, cur_style, 0, 0);
         }
       CHECK_DIMENSIONS:
@@ -4209,7 +4594,7 @@ if (same) {
         if (depth(z) > max_d)
             max_d = depth(z);
         list_ptr(z) = null;
-        /* only drop the \.{\\hbox} */
+        /*tex only drop the \.{\\hbox} */
         flush_node(z);
       DONE_WITH_NOAD:
         r = q;
@@ -4219,7 +4604,8 @@ if (same) {
             r_subtype = left_noad_side;
             cur_style = style;
             setup_cur_size(cur_style);
-            cur_mu = x_over_n(get_math_quad_size(cur_size), 18); /* style */
+            /*tex style */
+            cur_mu = x_over_n(get_math_quad_size(cur_size), 18);
         }
       DONE_WITH_NODE:
         q = vlink(q);
@@ -4228,15 +4614,18 @@ if (same) {
         type(r) = simple_noad;
         subtype(r) = ord_noad_type;
     }
-    /*
+    /*tex
+
         Make a second pass over the mlist, removing all noads and inserting the
         proper spacing and penalties.
 
-        We have now tied up all the loose ends of the first pass of |mlist_to_hlist|.
-        The second pass simply goes through and hooks everything together with the
-        proper glue and penalties. It also handles the |fence_noad|s that
-        might be present, since |max_hl| and |max_d| are now known. Variable |p| points
-        to a node at the current end of the final hlist.
+        We have now tied up all the loose ends of the first pass of
+        |mlist_to_hlist|. The second pass simply goes through and hooks
+        everything together with the proper glue and penalties. It also handles
+        the |fence_noad|s that might be present, since |max_hl| and |max_d| are
+        now known. Variable |p| points to a node at the current end of the final
+        hlist.
+
     */
     p = temp_head;
     vlink(p) = null;
@@ -4248,15 +4637,18 @@ if (same) {
     cur_mu = x_over_n(get_math_quad_size(cur_size), 18);
   NEXT_NODE:
     while (q != null) {
-        /*
+        /*tex
+
             If node |q| is a style node, change the style and |goto delete_q|;
-            otherwise if it is not a noad, put it into the hlist,
-            advance |q|, and |goto done|; otherwise set |s| to the size
-            of noad |q|, set |t| to the associated type (|ord_noad..
-            inner_noad|), and set |pen| to the associated penalty
+            otherwise if it is not a noad, put it into the hlist, advance |q|,
+            and |goto done|; otherwise set |s| to the size of noad |q|, set |t|
+            to the associated type (|ord_noad.. inner_noad|), and set |pen| to
+            the associated penalty.
+
+            Just before doing the big |case| switch in the second pass, the
+            program sets up default values so that most of the branches are
+            short.
 
-            Just before doing the big |case| switch in the second pass, the program
-            sets up default values so that most of the branches are short.
         */
         t = simple_noad;
         t_subtype = ord_noad_type;
@@ -4292,7 +4684,7 @@ if (same) {
             t_subtype = make_left_right(q, style, max_d, max_hl);
             break;
         case style_node:
-            /* Change the current style and |goto delete_q| */
+            /*tex Change the current style and |goto delete_q| */
             cur_style = subtype(q);
             setup_cur_size(cur_style);
             cur_mu = x_over_n(get_math_quad_style(cur_style), 18);
@@ -4316,34 +4708,36 @@ if (same) {
         default:
             confusion("mlist3");
         }
-        /* Append inter-element spacing based on |r_type| and |t| */
+        /*tex Append inter-element spacing based on |r_type| and |t| */
         if (r_type > 0) {
-            /* not the first noad */
+            /*tex not the first noad */
             pp = p;
-if (delimitermodeordinal && t_subtype == inner_noad_type && noadextra4(q) == 1) {
-    z = math_spacing_glue(r_subtype, ord_noad_type, cur_style, cur_mu);
-} else {
-            z = math_spacing_glue(r_subtype, t_subtype, cur_style, cur_mu);
-}
+            if (delimitermodeordinal && t_subtype == inner_noad_type && noadextra4(q) == 1) {
+                z = math_spacing_glue(r_subtype, ord_noad_type, cur_style, cur_mu);
+            } else {
+                z = math_spacing_glue(r_subtype, t_subtype, cur_style, cur_mu);
+            }
             if (z != null) {
                 reset_attributes(z, node_attr(p));
                 couple_nodes(p,z);
                 p = z;
             }
             if (penalties && prepen < inf_penalty && type(pp) != penalty_node) {
-                /* no checking of prev node type */
+                /*tex no checking of prev node type */
                 z = new_penalty(prepen,noad_penalty);
                 reset_attributes(z, node_attr(p));
                 couple_nodes(p,z);
                 p = z;
             }
         }
-        /*
-            Append any |new_hlist| entries for |q|, and any appropriate penalties
+        /*tex
+
+            Append any |new_hlist| entries for |q|, and any appropriate
+            penalties. We insert a penalty node after the hlist entries of noad
+            |q| if |pen| is not an ``infinite'' penalty, and if the node
+            immediately following |q| is not a penalty node or a |rel_noad| or
+            absent entirely.
 
-            We insert a penalty node after the hlist entries of noad |q| if |pen|
-            is not an ``infinite'' penalty, and if the node immediately following |q|
-            is not a penalty node or a |rel_noad| or absent entirely.
         */
         if (new_hlist(q) != null) {
             couple_nodes(p,new_hlist(q));
@@ -4370,12 +4764,13 @@ if (delimitermodeordinal && t_subtype == inner_noad_type && noadextra4(q) == 1)
       DELETE_Q:
         r = q;
         q = vlink(q);
-        /*
-            The m-to-hlist conversion takes place in-place, so the various dependant
-            fields may not be freed (as would happen if |flush_node| was called).
+        /*tex
+
+            The m-to-hlist conversion takes place in-place, so the various
+            dependant fields may not be freed (as would happen if |flush_node|
+            was called). A low-level |free_node| is easier than attempting to
+            nullify such dependant fields for all possible node and noad types.
 
-            A low-level |free_node| is easier than attempting to nullify such dependant
-            fields for all possible node and noad types.
         */
         if (nodetype_has_attributes(type(r))) {
             delete_attribute_ref(node_attr(r));
diff --git a/texk/web2c/luatexdir/tex/nesting.c b/texk/web2c/luatexdir/tex/nesting.c
new file mode 100644
index 000000000..0e50c1031
--- /dev/null
+++ b/texk/web2c/luatexdir/tex/nesting.c
@@ -0,0 +1,429 @@
+/*
+
+nesting.w
+
+Copyright 2009-2010 Taco Hoekwater <taco@@luatex.org>
+
+This file is part of LuaTeX.
+
+LuaTeX is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 2 of the License, or (at your
+option) any later version.
+
+LuaTeX is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+License for more details.
+
+You should have received a copy of the GNU General Public License along
+with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#include "ptexlib.h"
+
+/*tex These are for |show_activities|: */
+
+#define page_goal page_so_far[0]
+
+/*tex
+
+\TeX\ is typically in the midst of building many lists at once. For example, when
+a math formula is being processed, \TeX\ is in math mode and working on an mlist;
+this formula has temporarily interrupted \TeX\ from being in horizontal mode and
+building the hlist of a paragraph; and this paragraph has temporarily interrupted
+\TeX\ from being in vertical mode and building the vlist for the next page of a
+document. Similarly, when a \.{\\vbox} occurs inside of an \.{\\hbox}, \TeX\ is
+temporarily interrupted from working in restricted horizontal mode, and it enters
+internal vertical mode. The ``semantic nest'' is a stack that keeps track of what
+lists and modes are currently suspended.
+
+At each level of processing we are in one of six modes:
+
+|vmode| stands for vertical mode (the page builder);
+
+|hmode| stands for horizontal mode (the paragraph builder);
+
+|mmode| stands for displayed formula mode;
+
+|-vmode| stands for internal vertical mode (e.g., in a \.{\\vbox});
+
+|-hmode| stands for restricted horizontal mode (e.g., in an \.{\\hbox});
+
+|-mmode| stands for math formula mode (not displayed).
+
+The mode is temporarily set to zero while processing \.{\\write} texts in the
+|ship_out| routine.
+
+Numeric values are assigned to |vmode|, |hmode|, and |mmode| so that \TeX's ``big
+semantic switch'' can select the appropriate thing to do by computing the value
+|abs(mode)+cur_cmd|, where |mode| is the current mode and |cur_cmd| is the
+current command code.
+
+*/
+
+static const char *string_mode(int m)
+{
+    if (m > 0) {
+        switch (m / (max_command_cmd + 1)) {
+            case 0:
+                return "vertical mode";
+                break;
+            case 1:
+                return "horizontal mode";
+                break;
+            case 2:
+                return "display math mode";
+                break;
+            default:
+                break;
+        }
+    } else if (m == 0) {
+        return "no mode";
+    } else {
+        switch ((-m) / (max_command_cmd + 1)) {
+            case 0:
+                return "internal vertical mode";
+                break;
+            case 1:
+                return "restricted horizontal mode";
+                break;
+            case 2:
+                return "math mode";
+                break;
+            default:
+                break;
+        }
+    }
+    return "unknown mode";
+}
+
+void print_mode(int m)
+{
+    tprint(string_mode(m));
+}
+
+void print_in_mode(int m)
+{
+    tprint("' in ");
+    tprint(string_mode(m));
+}
+
+int get_mode_id(void)
+{
+    int m = cur_list.mode_field;
+    if (m > 0) {
+        switch (m / (max_command_cmd + 1)) {
+            case 0:
+                return 'v';
+                break;
+            case 1:
+                return 'h';
+                break;
+            case 2:
+                return 'm';
+                break;
+            default:
+                return '\0';
+                break;
+        }
+    } else if (m == 0) {
+        return 'n';;
+    } else {
+        switch ((-m) / (max_command_cmd + 1)) {
+            case 0:
+                return 'V';
+                break;
+            case 1:
+                return 'H';
+                break;
+            case 2:
+                return 'M';
+                break;
+            default:
+                return '\0';
+                break;
+        }
+    }
+}
+
+/*tex
+
+The state of affairs at any semantic level can be represented by five values:
+
+|mode| is the number representing the semantic mode, as just explained.
+
+|head| is a |pointer| to a list head for the list being built; |link(head)|
+therefore points to the first element of the list, or to |null| if the list is
+empty.
+
+|tail| is a |pointer| to the final node of the list being built; thus,
+|tail=head| if and only if the list is empty.
+
+|prev_graf| is the number of lines of the current paragraph that have already
+been put into the present vertical list.
+
+|aux| is an auxiliary |memory_word| that gives further information that is needed
+to characterize the situation.
+
+In vertical mode, |aux| is also known as |prev_depth|; it is the scaled value
+representing the depth of the previous box, for use in baseline calculations, or
+it is |<=-1000|pt if the next box on the vertical list is to be exempt from
+baseline calculations. In horizontal mode, |aux| is also known as |space_factor|;
+it holds the current space factor used in spacing calculations. In math mode,
+|aux| is also known as |incompleat_noad|; if not |null|, it points to a record
+that represents the numerator of a generalized fraction for which the denominator
+is currently being formed in the current list.
+
+There is also a sixth quantity, |mode_line|, which correlates the semantic nest
+with the user's input; |mode_line| contains the source line number at which the
+current level of nesting was entered. The negative of this line number is the
+|mode_line| at the level of the user's output routine.
+
+A seventh quantity, |eTeX_aux|, is used by the extended features eTeX. In math
+mode it is known as |delim_ptr| and points to the most recent |fence_noad| of a
+|math_left_group|.
+
+In horizontal mode, the |prev_graf| field is used for initial language data.
+
+The semantic nest is an array called |nest| that holds the |mode|, |head|,
+|tail|, |prev_graf|, |aux|, and |mode_line| values for all semantic levels below
+the currently active one. Information about the currently active level is kept in
+the global quantities |mode|, |head|, |tail|, |prev_graf|, |aux|, and
+|mode_line|, which live in a struct that is ready to be pushed onto |nest| if
+necessary.
+
+The math field is used by various bits and pieces in |texmath.w|
+
+This implementation of \TeX\ uses two different conventions for representing
+sequential stacks. @^stack conventions@>@^conventions for representing stacks@>
+
+1) If there is frequent access to the top entry, and if the stack is essentially
+never empty, then the top entry is kept in a global variable (even better would
+be a machine register), and the other entries appear in the array
+$\\{stack}[0\to(\\{ptr}-1)]$. The semantic stack is handled this way.
+
+2) If there is infrequent top access, the entire stack contents are in the array
+$\\{stack}[0\to(\\{ptr}-1)]$. For example, the |save_stack| is treated this way,
+as we have seen.
+
+In |nest_ptr| we have the first unused location of |nest|, and |max_nest_stack|
+has the maximum of |nest_ptr| when pushing. In |shown_mode| we store the most
+recent mode shown by \.{\\tracingcommands} and with |save_tail| we can examine
+whether we have an auto kern before a glue.
+
+*/
+
+list_state_record *nest;
+int nest_ptr, max_nest_stack, shown_mode;
+halfword save_tail;
+
+/*tex
+
+We will see later that the vertical list at the bottom semantic level is split
+into two parts; the ``current page'' runs from |page_head| to |page_tail|, and
+the ``contribution list'' runs from |contrib_head| to |tail| of semantic level
+zero. The idea is that contributions are first formed in vertical mode, then
+``contributed'' to the current page (during which time the page-breaking
+decisions are made). For now, we don't need to know any more details about the
+page-building process.
+
+*/
+
+void initialize_nesting(void)
+{
+    nest_ptr = 0;
+    max_nest_stack = 0;
+    shown_mode = 0;
+    cur_list.mode_field = vmode;
+    cur_list.head_field = contrib_head;
+    cur_list.tail_field = contrib_head;
+    cur_list.eTeX_aux_field = null;
+    cur_list.prev_depth_field = ignore_depth;
+    cur_list.space_factor_field = 1000;
+    cur_list.incompleat_noad_field = null;
+    cur_list.ml_field = 0;
+    cur_list.pg_field = 0;
+    cur_list.dirs_field = null;
+    init_math_fields();
+}
+
+/*tex
+
+Here is a common way to make the current list grow:
+
+*/
+
+void tail_append(halfword p)
+{
+    couple_nodes(cur_list.tail_field, p);
+    cur_list.tail_field = vlink(cur_list.tail_field);
+}
+
+halfword pop_tail(void)
+{
+    halfword n, r;
+    if (cur_list.tail_field != cur_list.head_field) {
+        r = cur_list.tail_field;
+        if (vlink(alink(cur_list.tail_field)) == cur_list.tail_field) {
+            n = alink(cur_list.tail_field);
+        } else {
+            n = cur_list.head_field;
+            while (vlink(n) != cur_list.tail_field)
+                n = vlink(n);
+        }
+        flush_node(cur_list.tail_field);
+        cur_list.tail_field = n;
+        vlink(n) = null;
+        return r;
+    } else {
+        return null;
+    }
+}
+
+/*tex
+
+When \TeX's work on one level is interrupted, the state is saved by calling
+|push_nest|. This routine changes |head| and |tail| so that a new (empty) list is
+begun; it does not change |mode| or |aux|.
+
+*/
+
+void push_nest(void)
+{
+    if (nest_ptr > max_nest_stack) {
+        max_nest_stack = nest_ptr;
+        if (nest_ptr == nest_size)
+            overflow("semantic nest size", (unsigned) nest_size);
+    }
+    incr(nest_ptr);
+    cur_list.mode_field = nest[nest_ptr - 1].mode_field;
+    cur_list.head_field = new_node(temp_node, 0);
+    cur_list.tail_field = cur_list.head_field;
+    cur_list.eTeX_aux_field = null;
+    cur_list.ml_field = line;
+    cur_list.pg_field = 0;
+    cur_list.dirs_field = null;
+    cur_list.prev_depth_field = nest[nest_ptr - 1].prev_depth_field;
+    cur_list.space_factor_field = nest[nest_ptr - 1].space_factor_field;
+    cur_list.incompleat_noad_field = nest[nest_ptr - 1].incompleat_noad_field;
+    init_math_fields();
+}
+
+/*tex
+
+Conversely, when \TeX\ is finished on the current level, the former state is
+restored by calling |pop_nest|. This routine will never be called at the lowest
+semantic level, nor will it be called unless |head| is a node that should be
+returned to free memory.
+
+*/
+
+void pop_nest(void)
+{
+    flush_node(cur_list.head_field);
+    decr(nest_ptr);
+}
+
+/*tex
+
+Here is a procedure that displays what \TeX\ is working on, at all levels.
+
+*/
+
+void show_activities(void)
+{
+    /*tex Index into |nest|: */
+    int p;
+    /*tex The mode: */
+    int m;
+    /*tex For showing the current page: */
+    halfword q, r;
+    /*tex Ditto: */
+    int t;
+    tprint_nl("");
+    print_ln();
+    for (p = nest_ptr; p >= 0; p--) {
+        m = nest[p].mode_field;
+        tprint_nl("### ");
+        print_mode(m);
+        tprint(" entered at line ");
+        print_int(abs(nest[p].ml_field));
+        if (nest[p].ml_field < 0)
+            tprint(" (\\output routine)");
+        if (p == 0) {
+            /*tex Show the status of the current page */
+            if (page_head != page_tail) {
+                tprint_nl("### current page:");
+                if (output_active)
+                    tprint(" (held over for next output)");
+                show_box(vlink(page_head));
+                if (page_contents > empty) {
+                    tprint_nl("total height ");
+                    print_totals();
+                    tprint_nl(" goal height ");
+                    print_scaled(page_goal);
+                    r = vlink(page_ins_head);
+                    while (r != page_ins_head) {
+                        print_ln();
+                        tprint_esc("insert");
+                        t = subtype(r);
+                        print_int(t);
+                        tprint(" adds ");
+                        if (count(t) == 1000)
+                            t = height(r);
+                        else
+                            t = x_over_n(height(r), 1000) * count(t);
+                        print_scaled(t);
+                        if (type(r) == split_up_node) {
+                            q = page_head;
+                            t = 0;
+                            do {
+                                q = vlink(q);
+                                if ((type(q) == ins_node)
+                                    && (subtype(q) == subtype(r)))
+                                    incr(t);
+                            } while (q != broken_ins(r));
+                            tprint(", #");
+                            print_int(t);
+                            tprint(" might split");
+                        }
+                        r = vlink(r);
+                    }
+                }
+            }
+            if (vlink(contrib_head) != null)
+                tprint_nl("### recent contributions:");
+        }
+        show_box(vlink(nest[p].head_field));
+        /*tex Show the auxiliary field, |a|. */
+        switch (abs(m) / (max_command_cmd + 1)) {
+            case 0:
+                tprint_nl("prevdepth ");
+                if (nest[p].prev_depth_field <= ignore_depth)
+                    tprint("ignored");
+                else
+                    print_scaled(nest[p].prev_depth_field);
+                if (nest[p].pg_field != 0) {
+                    tprint(", prevgraf ");
+                    print_int(nest[p].pg_field);
+                    if (nest[p].pg_field != 1)
+                        tprint(" lines");
+                    else
+                        tprint(" line");
+                }
+                break;
+            case 1:
+                tprint_nl("spacefactor ");
+                print_int(nest[p].space_factor_field);
+                break;
+            case 2:
+                if (nest[p].incompleat_noad_field != null) {
+                    tprint("this will be denominator of:");
+                    show_box(nest[p].incompleat_noad_field);
+                }
+                break;
+        }
+    }
+}
diff --git a/texk/web2c/luatexdir/tex/nesting.w b/texk/web2c/luatexdir/tex/nesting.w
deleted file mode 100644
index d9e7cf744..000000000
--- a/texk/web2c/luatexdir/tex/nesting.w
+++ /dev/null
@@ -1,436 +0,0 @@
-% nesting.w
-%
-% Copyright 2009-2010 Taco Hoekwater <taco@@luatex.org>
-%
-% This file is part of LuaTeX.
-%
-% LuaTeX is free software; you can redistribute it and/or modify it under
-% the terms of the GNU General Public License as published by the Free
-% Software Foundation; either version 2 of the License, or (at your
-% option) any later version.
-%
-% LuaTeX is distributed in the hope that it will be useful, but WITHOUT
-% ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-% FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
-% License for more details.
-%
-% You should have received a copy of the GNU General Public License along
-% with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
-
-@ @c
-
-#include "ptexlib.h"
-
-@ these are for |show_activities|
-@c
-#define page_goal page_so_far[0]
-
-@ \TeX\ is typically in the midst of building many lists at once. For example,
-when a math formula is being processed, \TeX\ is in math mode and
-working on an mlist; this formula has temporarily interrupted \TeX\ from
-being in horizontal mode and building the hlist of a paragraph; and this
-paragraph has temporarily interrupted \TeX\ from being in vertical mode
-and building the vlist for the next page of a document. Similarly, when a
-\.{\\vbox} occurs inside of an \.{\\hbox}, \TeX\ is temporarily
-interrupted from working in restricted horizontal mode, and it enters
-internal vertical mode.  The ``semantic nest'' is a stack that
-keeps track of what lists and modes are currently suspended.
-
-At each level of processing we are in one of six modes:
-
-\yskip\hang|vmode| stands for vertical mode (the page builder);
-
-\hang|hmode| stands for horizontal mode (the paragraph builder);
-
-\hang|mmode| stands for displayed formula mode;
-
-\hang|-vmode| stands for internal vertical mode (e.g., in a \.{\\vbox});
-
-\hang|-hmode| stands for restricted horizontal mode (e.g., in an \.{\\hbox});
-
-\hang|-mmode| stands for math formula mode (not displayed).
-
-\yskip\noindent The mode is temporarily set to zero while processing \.{\\write}
-texts in the |ship_out| routine.
-
-Numeric values are assigned to |vmode|, |hmode|, and |mmode| so that
-\TeX's ``big semantic switch'' can select the appropriate thing to
-do by computing the value |abs(mode)+cur_cmd|, where |mode| is the current
-mode and |cur_cmd| is the current command code.
-
-@c
-static const char *string_mode(int m)
-{                               /* prints the mode represented by |m| */
-    if (m > 0) {
-        switch (m / (max_command_cmd + 1)) {
-        case 0:
-            return "vertical mode";
-            break;
-        case 1:
-            return "horizontal mode";
-            break;
-        case 2:
-            return "display math mode";
-            break;
-        default:
-            break;
-        }
-    } else if (m == 0) {
-        return "no mode";
-    } else {
-        switch ((-m) / (max_command_cmd + 1)) {
-        case 0:
-            return "internal vertical mode";
-            break;
-        case 1:
-            return "restricted horizontal mode";
-            break;
-        case 2:
-            return "math mode";
-            break;
-        default:
-            break;
-        }
-    }
-    return "unknown mode";
-}
-
-@ @c
-void print_mode(int m)
-{                               /* prints the mode represented by |m| */
-    tprint(string_mode(m));
-}
-
-@ @c
-void print_in_mode(int m)
-{                               /* prints the mode represented by |m| */
-    tprint("' in ");
-    tprint(string_mode(m));
-}
-
-@ @c
-int get_mode_id(void)
-{                               /* returns the mode represented by |m| */
-    int m = cur_list.mode_field;
-    if (m > 0) {
-        switch (m / (max_command_cmd + 1)) {
-        case 0:
-            return 'v';
-            break;
-        case 1:
-            return 'h';
-            break;
-        case 2:
-            return 'm';
-            break;
-        default:
-            return '\0';
-            break;
-        }
-    } else if (m == 0) {
-        return 'n';;
-    } else {
-        switch ((-m) / (max_command_cmd + 1)) {
-        case 0:
-            return 'V';
-            break;
-        case 1:
-            return 'H';
-            break;
-        case 2:
-            return 'M';
-            break;
-        default:
-            return '\0';
-            break;
-        }
-    }
-}
-
-
-@ The state of affairs at any semantic level can be represented by
-five values:
-
-\yskip\hang|mode| is the number representing the semantic mode, as
-just explained.
-
-\yskip\hang|head| is a |pointer| to a list head for the list being built;
-|link(head)| therefore points to the first element of the list, or
-to |null| if the list is empty.
-
-\yskip\hang|tail| is a |pointer| to the final node of the list being
-built; thus, |tail=head| if and only if the list is empty.
-
-\yskip\hang|prev_graf| is the number of lines of the current paragraph that
-have already been put into the present vertical list.
-
-\yskip\hang|aux| is an auxiliary |memory_word| that gives further information
-that is needed to characterize the situation.
-
-\yskip\noindent
-In vertical mode, |aux| is also known as |prev_depth|; it is the scaled
-value representing the depth of the previous box, for use in baseline
-calculations, or it is |<=-1000|pt if the next box on the vertical list is to
-be exempt from baseline calculations.  In horizontal mode, |aux| is also
-known as |space_factor|; it holds the current space factor used in
-spacing calculations. In math mode, |aux| is also known as |incompleat_noad|;
-if not |null|, it points to a record that represents the numerator of a
-generalized fraction for which the denominator is currently being formed
-in the current list.
-
-There is also a sixth quantity, |mode_line|, which correlates
-the semantic nest with the user's input; |mode_line| contains the source
-line number at which the current level of nesting was entered. The negative
-of this line number is the |mode_line| at the level of the
-user's output routine.
-
-A seventh quantity, |eTeX_aux|, is used by the extended features eTeX.
-In math mode it is known as |delim_ptr| and points to the most
-recent |fence_noad|  of a |math_left_group|.
-
-In horizontal mode, the |prev_graf| field is used for initial language data.
-
-The semantic nest is an array called |nest| that holds the |mode|, |head|,
-|tail|, |prev_graf|, |aux|, and |mode_line| values for all semantic levels
-below the currently active one. Information about the currently active
-level is kept in the global quantities |mode|, |head|, |tail|, |prev_graf|,
-|aux|, and |mode_line|, which live in a struct that is ready to
-be pushed onto |nest| if necessary.
-
-The math field is used by various bits and pieces in |texmath.w|
-
-@ This implementation of
-\TeX\ uses two different conventions for representing sequential stacks.
-@^stack conventions@>@^conventions for representing stacks@>
-
-\yskip\hang 1) If there is frequent access to the top entry, and if the
-stack is essentially never empty, then the top entry is kept in a global
-variable (even better would be a machine register), and the other entries
-appear in the array $\\{stack}[0\to(\\{ptr}-1)]$. The
-semantic stack is handled this way.
-
-\yskip\hang 2) If there is infrequent top access, the entire stack contents
-are in the array $\\{stack}[0\to(\\{ptr}-1)]$. For example, the |save_stack|
-is treated this way, as we have seen.
-
-@c
-list_state_record *nest;
-int nest_ptr;                   /* first unused location of |nest| */
-int max_nest_stack;             /* maximum of |nest_ptr| when pushing */
-int shown_mode;                 /* most recent mode shown by \.{\\tracingcommands} */
-halfword save_tail;             /* save |tail| so we can examine whether we have an auto
-                                   kern before a glue */
-
-@ We will see later that the vertical list at the bottom semantic level is split
-into two parts; the ``current page'' runs from |page_head| to |page_tail|,
-and the ``contribution list'' runs from |contrib_head| to |tail| of
-semantic level zero. The idea is that contributions are first formed in
-vertical mode, then ``contributed'' to the current page (during which time
-the page-breaking decisions are made). For now, we don't need to know
-any more details about the page-building process.
-
-@c
-void initialize_nesting(void)
-{
-    nest_ptr = 0;
-    max_nest_stack = 0;
-    shown_mode = 0;
-    cur_list.mode_field = vmode;
-    cur_list.head_field = contrib_head;
-    cur_list.tail_field = contrib_head;
-    cur_list.eTeX_aux_field = null;
-    cur_list.prev_depth_field = ignore_depth;
-    cur_list.space_factor_field = 1000;
-    cur_list.incompleat_noad_field = null;
-    cur_list.ml_field = 0;
-    cur_list.pg_field = 0;
-    cur_list.dirs_field = null;
-    init_math_fields();
-}
-
-@ Here is a common way to make the current list grow:
-
-@c
-void tail_append(halfword p)
-{
-    couple_nodes(cur_list.tail_field, p);
-    cur_list.tail_field = vlink(cur_list.tail_field);
-}
-
-@ @c
-halfword pop_tail(void)
-{
-    halfword n, r;
-    if (cur_list.tail_field != cur_list.head_field) {
-        r = cur_list.tail_field;
-        if (vlink(alink(cur_list.tail_field)) == cur_list.tail_field) {
-            n = alink(cur_list.tail_field);
-        } else {
-            n = cur_list.head_field;
-            while (vlink(n) != cur_list.tail_field)
-                n = vlink(n);
-        }
-        flush_node(cur_list.tail_field);
-        cur_list.tail_field = n;
-        vlink(n) = null;
-        return r;
-    } else {
-        return null;
-    }
-}
-
-@ When \TeX's work on one level is interrupted, the state is saved by
-calling |push_nest|. This routine changes |head| and |tail| so that
-a new (empty) list is begun; it does not change |mode| or |aux|.
-
-@c
-void push_nest(void)
-{                               /* enter a new semantic level, save the old */
-    if (nest_ptr > max_nest_stack) {
-        max_nest_stack = nest_ptr;
-        if (nest_ptr == nest_size)
-            overflow("semantic nest size", (unsigned) nest_size);
-    }
-    incr(nest_ptr);
-    cur_list.mode_field = nest[nest_ptr - 1].mode_field;
-    cur_list.head_field = new_node(temp_node, 0);
-    cur_list.tail_field = cur_list.head_field;
-    cur_list.eTeX_aux_field = null;
-    cur_list.ml_field = line;
-    cur_list.pg_field = 0;
-    cur_list.dirs_field = null;
-    cur_list.prev_depth_field = nest[nest_ptr - 1].prev_depth_field;
-    cur_list.space_factor_field = nest[nest_ptr - 1].space_factor_field;
-    cur_list.incompleat_noad_field = nest[nest_ptr - 1].incompleat_noad_field;
-    init_math_fields();
-}
-
-@ Conversely, when \TeX\ is finished on the current level, the former
-state is restored by calling |pop_nest|. This routine will never be
-called at the lowest semantic level, nor will it be called unless |head|
-is a node that should be returned to free memory.
-
-@c
-void pop_nest(void)
-{                               /* leave a semantic level, re-enter the old */
-    flush_node(cur_list.head_field);
-    decr(nest_ptr);
-}
-
-@ Here is a procedure that displays what \TeX\ is working on, at all levels.
-
-@c
-void show_activities(void)
-{
-    int p;                      /* index into |nest| */
-    int m;                      /* mode */
-    halfword q, r;              /* for showing the current page */
-    int t;                      /* ditto */
-    tprint_nl("");
-    print_ln();
-    for (p = nest_ptr; p >= 0; p--) {
-        m = nest[p].mode_field;
-        tprint_nl("### ");
-        print_mode(m);
-        tprint(" entered at line ");
-        print_int(abs(nest[p].ml_field));
-        /* we dont do this any more */
-#if 0
-
-           if (m == hmode)
-           if (nest[p].pg_field != 040600000) {
-           tprint(" (language");
-           print_int(nest[p].pg_field % 0200000);
-           tprint(":hyphenmin");
-           print_int(nest[p].pg_field / 020000000);
-           print_char(',');
-           print_int((nest[p].pg_field / 0200000) % 0100);
-           print_char(')');
-           }
-#endif
-        if (nest[p].ml_field < 0)
-            tprint(" (\\output routine)");
-        if (p == 0) {
-            /* Show the status of the current page */
-            if (page_head != page_tail) {
-                tprint_nl("### current page:");
-                if (output_active)
-                    tprint(" (held over for next output)");
-                show_box(vlink(page_head));
-                if (page_contents > empty) {
-                    tprint_nl("total height ");
-                    print_totals();
-                    tprint_nl(" goal height ");
-                    print_scaled(page_goal);
-                    r = vlink(page_ins_head);
-                    while (r != page_ins_head) {
-                        print_ln();
-                        tprint_esc("insert");
-                        t = subtype(r);
-                        print_int(t);
-                        tprint(" adds ");
-                        if (count(t) == 1000)
-                            t = height(r);
-                        else
-                            t = x_over_n(height(r), 1000) * count(t);
-                        print_scaled(t);
-                        if (type(r) == split_up_node) {
-                            q = page_head;
-                            t = 0;
-                            do {
-                                q = vlink(q);
-                                if ((type(q) == ins_node)
-                                    && (subtype(q) == subtype(r)))
-                                    incr(t);
-                            } while (q != broken_ins(r));
-                            tprint(", #");
-                            print_int(t);
-                            tprint(" might split");
-                        }
-                        r = vlink(r);
-                    }
-                }
-            }
-            if (vlink(contrib_head) != null)
-                tprint_nl("### recent contributions:");
-        }
-        show_box(vlink(nest[p].head_field));
-        /* Show the auxiliary field, |a| */
-        switch (abs(m) / (max_command_cmd + 1)) {
-        case 0:
-            tprint_nl("prevdepth ");
-            if (nest[p].prev_depth_field <= ignore_depth)
-                tprint("ignored");
-            else
-                print_scaled(nest[p].prev_depth_field);
-            if (nest[p].pg_field != 0) {
-                tprint(", prevgraf ");
-                print_int(nest[p].pg_field);
-                if (nest[p].pg_field != 1)
-                    tprint(" lines");
-                else
-                    tprint(" line");
-            }
-            break;
-        case 1:
-            tprint_nl("spacefactor ");
-            print_int(nest[p].space_factor_field);
-            /* we dont do this any more, this was aux.rh originally */
-#if 0
-               if (m > 0) {
-               if (nest[p].current_language_field > 0) {
-               tprint(", current language ");
-               print_int(nest[p].current_language_field);
-               }
-               }
-#endif
-            break;
-        case 2:
-            if (nest[p].incompleat_noad_field != null) {
-                tprint("this will be denominator of:");
-                show_box(nest[p].incompleat_noad_field);
-            }
-        }                       /* there are no other cases */
-
-    }
-}
diff --git a/texk/web2c/luatexdir/tex/packaging.w b/texk/web2c/luatexdir/tex/packaging.c
similarity index 62%
rename from texk/web2c/luatexdir/tex/packaging.w
rename to texk/web2c/luatexdir/tex/packaging.c
index f094a0d96..e2b007f11 100644
--- a/texk/web2c/luatexdir/tex/packaging.w
+++ b/texk/web2c/luatexdir/tex/packaging.c
@@ -1,84 +1,68 @@
-% packaging.w
-%
-% Copyright 2009-2010 Taco Hoekwater <taco@@luatex.org>
-%
-% This file is part of LuaTeX.
-%
-% LuaTeX is free software; you can redistribute it and/or modify it under
-% the terms of the GNU General Public License as published by the Free
-% Software Foundation; either version 2 of the License, or (at your
-% option) any later version.
-%
-% LuaTeX is distributed in the hope that it will be useful, but WITHOUT
-% ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-% FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
-% License for more details.
-%
-% You should have received a copy of the GNU General Public License along
-% with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
-
-@ @c
+/*
+
+Copyright 2009-2010 Taco Hoekwater <taco@luatex.org>
+
+This file is part of LuaTeX.
+
+LuaTeX is free software; you can redistribute it and/or modify it under the terms
+of the GNU General Public License as published by the Free Software Foundation;
+either version 2 of the License, or (at your option) any later version.
+
+LuaTeX is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU General Public License along with
+LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+
+*/
 
 #include "ptexlib.h"
 
-@ We're essentially done with the parts of \TeX\ that are concerned with the
-input (|get_next|) and the output (|ship_out|). So it's time to get heavily into
-the remaining part, which does the real work of typesetting.
-
-After lists are constructed, \TeX\ wraps them up and puts them into boxes. Two
-major subroutines are given the responsibility for this task: |hpack| applies to
-horizontal lists (hlists) and |vpack| applies to vertical lists (vlists). The
-main duty of |hpack| and |vpack| is to compute the dimensions of the resulting
-boxes, and to adjust the glue if one of those dimensions is pre-specified. The
-computed sizes normally enclose all of the material inside the new box; but some
-items may stick out if negative glue is used, if the box is overfull, or if a
-\.{\\vbox} includes other boxes that have been shifted left.
-
-The subroutine call |hpack(p,w,m)| returns a pointer to an |hlist_node| for a box
-containing the hlist that starts at |p|. Parameter |w| specifies a width; and
-parameter |m| is either `|exactly|' or `|additional|'. Thus, |hpack(p,w,exactly)|
-produces a box whose width is exactly |w|, while |hpack(p,w,additional)| yields a
-box whose width is the natural width plus |w|. It is convenient to define a macro
-called `|natural|' to cover the most common case, so that we can say
-|hpack(p,natural)| to get a box that has the natural width of list |p|.
-
-Similarly, |vpack(p,w,m)| returns a pointer to a |vlist_node| for a box
-containing the vlist that starts at |p|. In this case |w| represents a height
-instead of a width; the parameter |m| is interpreted as in |hpack|.
-
-@ The parameters to |hpack| and |vpack| correspond to \TeX's primitives like
-`\.{\\hbox} \.{to} \.{300pt}', `\.{\\hbox} \.{spread} \.{10pt}'; note that
-`\.{\\hbox}' with no dimension following it is equivalent to `\.{\\hbox}
-\.{spread} \.{0pt}'. The |scan_spec| subroutine scans such constructions in the
-user's input, including the mandatory left brace that follows them, and it puts
-the specification onto |save_stack| so that the desired box can later be obtained
-by executing the following code: $$\vbox{\halign{#\hfil\cr
-|save_ptr:=save_ptr-1;|\cr |hpack(p,saved_value(0),saved_level(0)).|\cr}}$$
-
-@c
-/*
-    void scan_spec(group_code c)
-    {
-        int spec_code;
-        if (scan_keyword("to")) {
-            spec_code = exactly;
-            scan_normal_dimen();
-        } else if (scan_keyword("spread")) {
-            spec_code = additional;
-            scan_normal_dimen();
-        } else {
-            spec_code = additional;
-            cur_val = 0;
-        }
-        set_saved_record(0, saved_boxspec, spec_code, cur_val);
-        save_ptr++;
-        new_save_level(c);
-        scan_left_brace();
-    }
+/*tex
+
+    We're essentially done with the parts of \TeX\ that are concerned with the
+    input (|get_next|) and the output (|ship_out|). So it's time to get heavily
+    into the remaining part, which does the real work of typesetting.
+
+    After lists are constructed, \TeX\ wraps them up and puts them into boxes.
+    Two major subroutines are given the responsibility for this task: |hpack|
+    applies to horizontal lists (hlists) and |vpack| applies to vertical lists
+    (vlists). The main duty of |hpack| and |vpack| is to compute the dimensions
+    of the resulting boxes, and to adjust the glue if one of those dimensions is
+    pre-specified. The computed sizes normally enclose all of the material inside
+    the new box; but some items may stick out if negative glue is used, if the
+    box is overfull, or if a \.{\\vbox} includes other boxes that have been
+    shifted left.
+
+    The subroutine call |hpack(p,w,m)| returns a pointer to an |hlist_node| for a
+    box containing the hlist that starts at |p|. Parameter |w| specifies a width;
+    and parameter |m| is either `|exactly|' or `|additional|'. Thus,
+    |hpack(p,w,exactly)| produces a box whose width is exactly |w|, while
+    |hpack(p,w,additional)| yields a box whose width is the natural width plus
+    |w|. It is convenient to define a macro called `|natural|' to cover the most
+    common case, so that we can say |hpack(p,natural)| to get a box that has the
+    natural width of list |p|.
+
+    Similarly, |vpack(p,w,m)| returns a pointer to a |vlist_node| for a box
+    containing the vlist that starts at |p|. In this case |w| represents a height
+    instead of a width; the parameter |m| is interpreted as in |hpack|.
+
+    The parameters to |hpack| and |vpack| correspond to \TeX's primitives like
+    `\.{\\hbox} \.{to} \.{300pt}', `\.{\\hbox} \.{spread} \.{10pt}'; note that
+    `\.{\\hbox}' with no dimension following it is equivalent to `\.{\\hbox}
+    \.{spread} \.{0pt}'. The |scan_spec| subroutine scans such constructions in
+    the user's input, including the mandatory left brace that follows them, and
+    it puts the specification onto |save_stack| so that the desired box can later
+    be obtained by executing the following code: $$\vbox{\halign{#\hfil\cr
+    |save_ptr:=save_ptr-1;|\cr |hpack(p,saved_value(0),saved_level(0)).|\cr}}$$
+
 */
 
+/*tex Scan a box specification and left brace: */
+
 void scan_spec(group_code c)
-{                               /* scans a box specification and left brace */
+{
     int spec_code;
     boolean done = false ;
     do {
@@ -89,7 +73,7 @@ void scan_spec(group_code c)
         cur_val = 0;
         done = true;
     } else {
-        /* todo: attr */
+        /*tex todo: attr */
         back_input();
         if (scan_keyword("to")) {
             spec_code = exactly;
@@ -110,84 +94,21 @@ void scan_spec(group_code c)
     }
 }
 
-@ When scanning, special care is necessary to ensure that the special
-|save_stack| codes are placed just below the new group code, because scanning can
-change |save_stack| when \.{\\csname} appears.
+/*tex
 
-This coincides with the text on |dir| and |attr| keywords, as these are exaclty
-the uses of \.{\\hbox}, \.{\\vbox}, and \.{\\vtop} in the input stream (the
-others are \.{\\vcenter}, \.{\\valign}, and \.{\\halign}).
+    When scanning, special care is necessary to ensure that the special
+    |save_stack| codes are placed just below the new group code, because scanning
+    can change |save_stack| when \.{\\csname} appears.
+
+    This coincides with the text on |dir| and |attr| keywords, as these are
+    exaclty the uses of \.{\\hbox}, \.{\\vbox}, and \.{\\vtop} in the input
+    stream (the others are \.{\\vcenter}, \.{\\valign}, and \.{\\halign}).
 
-@c
-/*
-    void scan_full_spec(group_code c, int spec_direction)
-    {
-        int s;
-        int i;
-        int v;
-        int spec_code;
-        halfword attr_list;
-        if (attr_list_cache == cache_disabled)
-            update_attribute_cache();
-        attr_list = attr_list_cache;
-        s = saved_value(0);
-      CONTINUE:
-        while (cur_cmd == relax_cmd || cur_cmd == spacer_cmd) {
-            get_x_token();
-            if (cur_cmd != relax_cmd && cur_cmd != spacer_cmd)
-                back_input();
-        }
-        if (scan_keyword("attr")) {
-            scan_register_num();
-            i = cur_val;
-            scan_optional_equals();
-            scan_int();
-            v = cur_val;
-            if ((attr_list != null) && (attr_list == attr_list_cache)) {
-                attr_list = copy_attribute_list(attr_list_cache);
-                add_node_attr_ref(attr_list);
-            }
-            attr_list = do_set_attribute(attr_list, i, v);
-            goto CONTINUE;
-        }
-        if (scan_keyword("dir")) {
-            scan_direction();
-            spec_direction = cur_val;
-            goto CONTINUE;
-        }
-        if (attr_list == attr_list_cache) {
-            add_node_attr_ref(attr_list);
-        }
-        if (scan_keyword("to")) {
-            spec_code = exactly;
-        } else if (scan_keyword("spread")) {
-            spec_code = additional;
-        } else {
-            spec_code = additional;
-            cur_val = 0;
-            goto FOUND;
-        }
-        scan_normal_dimen();
-      FOUND:
-        set_saved_record(0, saved_boxcontext, 0, s);
-        set_saved_record(1, saved_boxspec, spec_code, cur_val);
-        if (spec_direction != -1) {
-            set_saved_record(2, saved_boxdir, spec_direction, text_dir_ptr);
-            text_dir_ptr = new_dir(spec_direction);
-        } else {
-            set_saved_record(2, saved_boxdir, spec_direction, null);
-        }
-        set_saved_record(3, saved_boxattr, 0, attr_list);
-        save_ptr += 4;
-        new_save_level(c);
-        scan_left_brace();
-        eq_word_define(int_base + body_direction_code, spec_direction);
-        eq_word_define(int_base + par_direction_code, spec_direction);
-        eq_word_define(int_base + text_direction_code, spec_direction);
-    }
 */
 
-/* scans a box specification and left brace */
+/*tex Scan a box specification and left brace: */
+
+#define first_char_is(a,A) (cur_cs == 0 && (cur_chr == a || cur_chr == A))
 
 void scan_full_spec(group_code c, int spec_direction, int just_pack)
 {
@@ -195,10 +116,12 @@ void scan_full_spec(group_code c, int spec_direction, int just_pack)
     boolean done = false ;
     halfword attr_list;
     boolean attr_done = false ;
+    boolean dir_done = false ;
     if (attr_list_cache == cache_disabled)
         update_attribute_cache();
     attr_list = attr_list_cache;
-    s = saved_value(0); /* the box context */
+    /*tex The box context: */
+    s = saved_value(0);
     do {
         get_x_token();
     } while ((cur_cmd == spacer_cmd) || (cur_cmd == relax_cmd));
@@ -219,6 +142,7 @@ void scan_full_spec(group_code c, int spec_direction, int just_pack)
         }
     }
   KEYWORDS:
+    /*tex Multiple |attr| keys possible (before or after dir). */
     if (scan_keyword("attr")) {
         scan_register_num();
         i = cur_val;
@@ -232,11 +156,23 @@ void scan_full_spec(group_code c, int spec_direction, int just_pack)
         attr_list = do_set_attribute(attr_list, i, v);
         goto CONTINUE;
     }
-    if (scan_keyword("dir")) {
-        scan_direction();
-        spec_direction = cur_val;
-        goto CONTINUE;
+    /*tex We only permit one |(b)dir| directive. */
+    if (! dir_done) {
+        if (scan_keyword("bdir")) {
+            scan_int();
+            check_dir_value(cur_val);
+            spec_direction = cur_val;
+            dir_done = true;
+            goto CONTINUE;
+        }
+        if (scan_keyword("dir")) {
+            scan_direction();
+            spec_direction = cur_val;
+            dir_done = true;
+            goto CONTINUE;
+        }
     }
+    /*tex Only one |to| or |spread| key possible and it comes last. */
     if (scan_keyword("to")) {
         spec_code = exactly;
     } else if (scan_keyword("spread")) {
@@ -256,7 +192,7 @@ void scan_full_spec(group_code c, int spec_direction, int just_pack)
     add_node_attr_ref(attr_list);
     set_saved_record(0, saved_boxcontext, 0, s);
     set_saved_record(1, saved_boxspec, spec_code, cur_val);
-    /* DIR: Adjust |text_dir_ptr| for |scan_spec| */
+    /*tex Adjust |text_dir_ptr| for |scan_spec|. */
     if (spec_direction != -1) {
         set_saved_record(2, saved_boxdir, spec_direction, text_dir_ptr);
         text_dir_ptr = new_dir(spec_direction);
@@ -270,73 +206,91 @@ void scan_full_spec(group_code c, int spec_direction, int just_pack)
     if (! done) {
         scan_left_brace();
     }
-    /* no gain: if (body_direction_par != spec_direction) etc */
+    /*tex No gain in |if (body_direction_par != spec_direction)| etc. */
     eq_word_define(int_base + body_direction_code, spec_direction);
     eq_word_define(int_base + par_direction_code, spec_direction);
     eq_word_define(int_base + text_direction_code, spec_direction);
 }
 
+/*tex
 
-@ To figure out the glue setting, |hpack| and |vpack| determine how much
-stretchability and shrinkability are present, considering all four orders of
-infinity. The highest order of infinity that has a nonzero coefficient is then
-used as if no other orders were present.
+    To figure out the glue setting, |hpack| and |vpack| determine how much
+    stretchability and shrinkability are present, considering all four orders of
+    infinity. The highest order of infinity that has a nonzero coefficient is
+    then used as if no other orders were present.
 
-For example, suppose that the given list contains six glue nodes with the
-respective stretchabilities 3pt, 8fill, 5fil, 6pt, $-3$fil, $-8$fill. Then the
-total is essentially 2fil; and if a total additional space of 6pt is to be
-achieved by stretching, the actual amounts of stretch will be 0pt, 0pt, 15pt,
-0pt, $-9$pt, and 0pt, since only `fil' glue will be considered. (The `fill' glue
-is therefore not really stretching infinitely with respect to `fil'; nobody would
-actually want that to happen.)
+    For example, suppose that the given list contains six glue nodes with the
+    respective stretchabilities 3pt, 8fill, 5fil, 6pt, $-3$fil, $-8$fill. Then
+    the total is essentially 2fil; and if a total additional space of 6pt is to
+    be achieved by stretching, the actual amounts of stretch will be 0pt, 0pt,
+    15pt, 0pt, $-9$pt, and 0pt, since only `fil' glue will be considered. (The
+    `fill' glue is therefore not really stretching infinitely with respect to
+    `fil'; nobody would actually want that to happen.)
 
-The arrays |total_stretch| and |total_shrink| are used to determine how much glue
-of each kind is present. A global variable |last_badness| is used to implement
-\.{\\badness}.
+    The arrays |total_stretch| and |total_shrink| are used to determine how much
+    glue of each kind is present. A global variable |last_badness| is used to
+    implement \.{\\badness}.
+
+*/
+
+/*tex Glue found by |hpack| or |vpack|. */
 
-@c
 scaled total_stretch[5];
-scaled total_shrink[5];         /* glue found by |hpack| or |vpack| */
-int last_badness;               /* badness of the most recently packaged box */
+scaled total_shrink[5];
+
+/*tex Badness of the most recently packaged box. */
+
+int last_badness;
+
+/*tex
 
-@ If the global variable |adjust_tail| is non-null, the |hpack| routine also
-removes all occurrences of |ins_node|, |mark_node|, and |adjust_node| items and
-appends the resulting material onto the list that ends at location |adjust_tail|.
+    If the global variable |adjust_tail| is non-null, the |hpack| routine also
+    removes all occurrences of |ins_node|, |mark_node|, and |adjust_node| items
+    and appends the resulting material onto the list that ends at location
+    |adjust_tail|.
 
-@c
-halfword adjust_tail;           /* tail of adjustment list */
+*/
+
+/*tex Tail of adjustment list. */
+
+halfword adjust_tail;
 
+/*tex
 
-@ Materials in \.{\\vadjust} used with \.{pre} keyword will be appended to
-|pre_adjust_tail| instead of |adjust_tail|.
+    Materials in \.{\\vadjust} used with \.{pre} keyword will be appended to
+    |pre_adjust_tail| instead of |adjust_tail|.
+
+*/
 
-@c
 halfword pre_adjust_tail;
 
 halfword last_leftmost_char;
 halfword last_rightmost_char;
 
-halfword next_char_p;           /* pointer to the next char of an implicit kern */
-halfword prev_char_p;           /* pointer to the previous char of an implicit kern */
+/*tex Pointers to the prev and next char of an implicit kern. */
+
+halfword next_char_p;
+halfword prev_char_p;
+
+/*tex This procedure is called repeatedly from inside the line break algorithm. */
 
-@ This procedure is called repeatedly from inside the line break algorithm.
-@c
 void set_prev_char_p(halfword p)
 {
     prev_char_p = p;
 }
 
-/*
-    the kern stretch / shrink code was (or had become) rather weird ... the width field
-    is set, and then used in a second calculation, repeatedly, so why is that ... maybe some
-    some weird left-over ... anyway, the values are so small that in practice they are not
-    significant at all when the backend sees them because a few hundred sp positive or
-    negative are just noise there (so adjustlevel 3 has hardly any consequence for the
-    result but is more efficient)
-*/
+/*tex
+
+    The kern stretch / shrink code was (or had become) rather weird ... the width
+    field is set, and then used in a second calculation, repeatedly, so why is
+    that ... maybe some some weird left-over ... anyway, the values are so small
+    that in practice they are not significant at all when the backend sees them
+    because a few hundred sp positive or negative are just noise there (so
+    adjustlevel 3 has hardly any consequence for the result but is more
+    efficient).
 
+*/
 
-@ @c
 scaled char_stretch(halfword p)
 {
     internal_font_number f = font(p);
@@ -345,7 +299,7 @@ scaled char_stretch(halfword p)
         int c = character(p);
         int ef = get_ef_code(f, c);
         if (ef > 0) {
-            scaled dw = calc_char_width(f, c, m) - char_width(f, c) - x_advance(p);
+            scaled dw = calc_char_width(f, c, m) - char_width(f, c);
             if (dw > 0) {
                 return round_xn_over_d(dw, ef, 1000);
             }
@@ -354,7 +308,6 @@ scaled char_stretch(halfword p)
     return 0;
 }
 
-@ @c
 scaled char_shrink(halfword p)
 {
     internal_font_number f = font(p);
@@ -363,7 +316,7 @@ scaled char_shrink(halfword p)
         int c = character(p);
         int ef = get_ef_code(f, c);
         if (ef > 0) {
-            scaled dw = char_width(f, c) + x_advance(p) - calc_char_width(f, c, -m);
+            scaled dw = char_width(f, c) - calc_char_width(f, c, -m);
             if (dw > 0) {
                 return round_xn_over_d(dw, ef, 1000);
             }
@@ -372,33 +325,6 @@ scaled char_shrink(halfword p)
     return 0;
 }
 
-@ @c
-/*
-scaled kern_stretch(halfword p)
-{
-    halfword l, r;
-    scaled d;
-    int m;
-    if ((prev_char_p == null) || (vlink(prev_char_p) != p) || (vlink(p) == null))
-        return 0;
-    l = prev_char_p;
-    // we need a left char
-    if (!is_char_node(l))
-        return 0;
-    r = vlink(p);
-    // and a right char
-    if (!is_char_node(r))
-        return 0;
-    // and a reason to kern
-    if ((font(l) != font(r)) || (font_max_stretch(font(l)) == 0))
-        return 0;
-    m = font_max_stretch(font(l));
-    d = get_kern(font(l), character(l), character(r)); // real kern, so what is width(p) then; the messed up one
-    d = round_xn_over_d(d, 1000 + m, 1000);
-    return round_xn_over_d(d - width(p), get_ef_code(font(l), character(l)), 1000);
-}
-*/
-
 scaled kern_stretch(halfword p)
 {
     int m;
@@ -407,69 +333,39 @@ scaled kern_stretch(halfword p)
     halfword l;
     halfword r;
     if (w == 0)  {
-        /* why bother about zero kerns */
+        /*tex Why bother about zero kerns. */
         return 0;
     }
     l = prev_char_p ;
     if ((l == null) || (vlink(l) != p)) {
-        /* we only care about kerns following a char*/
+        /*tex We only care about kerns following a char. */
         return 0;
     }
     r = vlink(p);
     if (r == null) {
-        /* we only care about kerns between a char and something else */
+        /*tex We only care about kerns between a char and something else. */
     }
     if (!(is_char_node(l) && is_char_node(r))) {
-        /* we want two chars (but but don't care about the fonts) */
+        /*tex We want two chars (but but don't care about the fonts). */
         return 0;
     }
-    /* we use the old logic, kind of, but average the ef as we might depend on proper overlap */
+    /*tex We use the old logic, kind of, but average the ef as we might depend on proper overlap. */
     m = (font_max_stretch(font(l)) + font_max_stretch(font(r)))/2;
     if (m == 0) {
-        /* nothing to kern */
+        /*tex nothing to kern */
         return 0;
     }
     d = round_xn_over_d(w, 1000 + m, 1000);
-    /* we use the old logic, kind of, but average the ef as we might depend on proper overlap */
+    /*tex We use the old logic, kind of, but average the ef as we might depend on proper overlap. */
     e = (get_ef_code(font(l), character(l)) + get_ef_code(font(r), character(r)))/2 ;
     if (e == 1000) {
         x = d - w;
     } else {
         x = round_xn_over_d(d - w, e, 1000);
     }
-    /*
-        printf("STRETCH w=%i s=%i x=%i\n",w,e+m,x);
-    */
     return x;
 }
 
-@ @c
-/*
-scaled kern_shrink(halfword p)
-{
-    halfword l, r;
-    scaled d;
-    int m;
-    if ((prev_char_p == null) || (vlink(prev_char_p) != p) || (vlink(p) == null))
-        return 0;
-    l = prev_char_p;
-    // we need a left char
-    if (!is_char_node(l))
-        return 0;
-    r = vlink(p);
-    // and a right char
-    if (!is_char_node(r))
-        return 0;
-    // and a reason to kern
-    if ((font(l) != font(r)) || (font_max_shrink(font(l)) == 0))
-        return 0;
-    m = font_max_shrink(font(l));
-    d = get_kern(font(l), character(l), character(r)); // real kern, so what is width(p) then; the messed up one
-    d = round_xn_over_d(d, 1000 - m, 1000);
-    return round_xn_over_d(width(p) - d, get_ef_code(font(l), character(l)), 1000);
-}
-*/
-
 scaled kern_shrink(halfword p)
 {
     int m;
@@ -478,26 +374,26 @@ scaled kern_shrink(halfword p)
     halfword l;
     halfword r;
     if (w == 0)  {
-        /* why bother about zero kerns */
+        /*tex Why bother about zero kerns. */
         return 0;
     }
     l = prev_char_p ;
     if ((l == null) || (vlink(l) != p)) {
-        /* we only care about kerns following a char*/
+        /*tex We only care about kerns following a char. */
         return 0;
     }
     r = vlink(p);
     if (r == null) {
-        /* we only care about kerns between a char and something else */
+        /*tex We only care about kerns between a char and something else. */
     }
     if (!(is_char_node(l) && is_char_node(r))) {
-        /* we want two chars (but but don't care about the fonts) */
+        /*tex We want two chars (but but don't care about the fonts). */
         return 0;
     }
-    /* we use the old logic, kind of, but average the ef as we might depend on proper overlap */
+    /*tex We use the old logic, kind of, but average the ef as we might depend on proper overlap. */
     m = (font_max_shrink(font(l)) + font_max_shrink(font(r)))/2;
     if (m == 0) {
-        /* nothing to kern */
+        /*tex Nothing to kern. */
         return 0;
     }
     d = round_xn_over_d(w, 1000 - m, 1000);
@@ -507,13 +403,9 @@ scaled kern_shrink(halfword p)
     } else {
         x = round_xn_over_d(w - d, e, 1000);
     }
-    /*
-    printf("SHRINK w=%i s=%i x=%i\n",w,e+m,x);
-    */
     return x;
 }
 
-@ @c
 void do_subst_font(halfword p, int ex_ratio)
 {
     if (type(p) == disc_node) {
@@ -555,7 +447,6 @@ void do_subst_font(halfword p, int ex_ratio)
     }
 }
 
-@ @c
 scaled char_pw(halfword p, int side)
 {
     internal_font_number f;
@@ -582,7 +473,6 @@ scaled char_pw(halfword p, int side)
     return round_xn_over_d(w, c, 1000);
 }
 
-@ @c
 halfword new_margin_kern(scaled w, halfword p, int side)
 {
     halfword k, q;
@@ -595,11 +485,16 @@ halfword new_margin_kern(scaled w, halfword p, int side)
     return k;
 }
 
-@ Here is |hpack|, which is place where we do font substituting when font
-expansion is being used.
+/*tex
+
+    Here we prepare for |hpack|, which is place where we do font substituting
+    when font expansion is being used.
+
+*/
+
+/*tex The current expansion ratio, needed for recursive call. */
 
-@c
-int font_expand_ratio = 0;  /* current expansion ratio, needed for recursive call */
+int font_expand_ratio = 0;
 
 int ignore_math_skip(halfword p)
 {
@@ -632,47 +527,60 @@ int ignore_math_skip(halfword p)
 
 halfword hpack(halfword p, scaled w, int m, int pack_direction)
 {
-    halfword r;                 /* the box node that will be returned */
-    halfword q;                 /* trails behind |p| */
-    scaled h = 0;               /* height */
-    scaled d = 0;               /* depth */
-    scaled x = 0;               /* natural width */
+    /*tex the box node that will be returned */
+    halfword r;
+    /*tex trails behind |p| */
+    halfword q;
+    /*tex height */
+    scaled h = 0;
+    /*tex depth */
+    scaled d = 0;
+    /*tex natural width */
+    scaled x = 0;
     scaled_whd whd;
-    scaled s;                   /* shift amount */
-    int o;                      /* order of infinity */
-    halfword dir_ptr1 = null;   /* for managing the direction stack */
-    int hpack_dir;              /* the current direction */
+    /*tex shift amount */
+    scaled s;
+    /*tex order of infinity */
+    int o;
+    /*tex for managing the direction stack */
+    halfword dir_ptr1 = null;
+    /*tex the current direction */
+    int hpack_dir;
     int disc_level = 0;
     halfword pack_interrupt[8];
     scaled font_stretch = 0;
     scaled font_shrink = 0;
     int adjust_spacing = adjust_spacing_par;
-
-/*
-    int font_expand_ratio = 0;
-*/
     last_badness = 0;
-    r = new_node(hlist_node, min_quarterword); /* the box node that will be returned */
+    /*tex the box node that will be returned */
+    r = new_node(hlist_node, min_quarterword);
     if (pack_direction == -1) {
         hpack_dir = text_direction_par;
     } else {
         hpack_dir = pack_direction;
     }
     box_dir(r) = hpack_dir;
-    /*
-        potential optimimization, save a little but neglectable in practice (not so
-        many empty boxes are used)
+    /*tex
 
+        A potential optimimization, save a little but neglectable in practice
+        (not so many empty boxes are used):
+
+        \starttyping
         if (p == null) {
             width(r) = w;
             return r;
         }
+        \stoptyping
+
     */
-    push_dir(dir_ptr1,hpack_dir); /* push null */
-    q = r + list_offset; /* hm, adding something to a node address? */
+    /*tex push null */
+    push_dir(dir_ptr1,hpack_dir);
+    /*tex hm, adding something to a node address? */
+    q = r + list_offset;
     vlink(q) = p;
     if (m == cal_expand_ratio) {
-        prev_char_p = null; /* why not always */
+        /*tex Why not always: */
+        prev_char_p = null;
     }
     if (adjust_spacing > 2) {
         adjust_spacing = 0;
@@ -687,7 +595,6 @@ halfword hpack(halfword p, scaled w, int m, int pack_direction)
     total_shrink[fill] = 0;
     total_stretch[filll] = 0;
     total_shrink[filll] = 0;
-
   RESWITCH:
     while ((p != null) || (disc_level > 0)) {
         if (p == null) {
@@ -695,20 +602,24 @@ halfword hpack(halfword p, scaled w, int m, int pack_direction)
             p = pack_interrupt[disc_level];
             goto RESWITCH;
         }
-        /*
-            Examine node |p| in the hlist, taking account of its effect
-            on the dimensions of the new box, or moving it to the adjustment list;
-            then advance |p| to the next node
+        /*tex
+
+            Examine node |p| in the hlist, taking account of its effect on the
+            dimensions of the new box, or moving it to the adjustment list; then
+            advance |p| to the next node.
+
         */
         while (is_char_node(p)) {
-            /*
+            /*tex
+
                 Incorporate character dimensions into the dimensions of the hbox
                 that will contain~it, then move to the next node.
 
                 The following code is part of \TeX's inner loop; i.e., adding
                 another character of text to the user's input will cause each of
                 these instructions to be exercised one more time.
-             */
+
+            */
             if (m >= cal_expand_ratio) {
                 prev_char_p = p;
                 if (m == cal_expand_ratio) {
@@ -730,13 +641,16 @@ halfword hpack(halfword p, scaled w, int m, int pack_direction)
             switch (type(p)) {
                 case hlist_node:
                 case vlist_node:
-                    /*
-                        Incorporate box dimensions into the dimensions of the hbox
-                        that will contain~it
+                    /*tex
+
+                        Incorporate box dimensions into the dimensions of the
+                        hbox that will contain~it
+
+                        The code here implicitly uses the fact that running
+                        dimensions are indicated by |null_flag|, which will be
+                        ignored in the calculations because it is a highly
+                        negative number.
 
-                        The code here implicitly uses the fact that running dimensions are
-                        indicated by |null_flag|, which will be ignored in the calculations
-                        because it is a highly negative number.
                     */
                     s = shift_amount(p);
                     whd = pack_width_height_depth(hpack_dir, box_dir(p), p, false);
@@ -746,20 +660,6 @@ halfword hpack(halfword p, scaled w, int m, int pack_direction)
                     if (whd.dp + s > d)
                         d = whd.dp + s;
                     break;
-                /*
-                case rule_node:
-                case unset_node:
-                    x += width(p);
-                    if (type(p) >= rule_node) // always
-                        s = 0;
-                    else
-                        s = shift_amount(p);
-                    if (height(p) - s > h)
-                        h = height(p) - s;
-                    if (depth(p) + s > d)
-                        d = depth(p) + s;
-                    break;
-                */
                 case rule_node:
                 case unset_node:
                     x += width(p);
@@ -768,18 +668,17 @@ halfword hpack(halfword p, scaled w, int m, int pack_direction)
                     if (depth(p) > d)
                         d = depth(p);
                     break;
-                /* */
                 case math_node:
-                    /* begin mathskip code */
+                    /*tex Begin mathskip code. */
                     if (glue_is_zero(p) || ignore_math_skip(p)) {
                         x += surround(p);
                         break;
                     } else {
-                        /* fall through */
+                        /*tex Fall through. */
                     }
-                    /* end mathskip code */
+                    /*tex End mathskip code. */
                 case glue_node:
-                    /* Incorporate glue into the horizontal totals */
+                    /*tex Incorporate glue into the horizontal totals. */
                     x += width(p);
                     o = stretch_order(p);
                     total_stretch[o] = total_stretch[o] + stretch(p);
@@ -796,12 +695,12 @@ halfword hpack(halfword p, scaled w, int m, int pack_direction)
                 case kern_node:
                     x += width(p);
                     if (subtype(p) == font_kern && adjust_spacing) {
-                        /* so only when 1 or 2 */
+                        /*tex So only when 1 or 2. */
                         if (m == cal_expand_ratio) {
                             font_stretch = font_stretch + kern_stretch(p);
                             font_shrink = font_shrink + kern_shrink(p);
                         } else if (m == subst_ex_font) {
-                            /* this is the finalizer */
+                            /*tex This is the finalizer. */
                             int k = 0;
                             if (font_expand_ratio > 0) {
                                 k = kern_stretch(p);
@@ -810,9 +709,6 @@ halfword hpack(halfword p, scaled w, int m, int pack_direction)
                             }
                             ex_kern(p) = k;
                             x += k;
-                            /*
-                                if (x!=0) printf("SET %i %i %i\n",font_expand_ratio,k,x);
-                            */
                         }
                     }
                     break;
@@ -826,8 +722,8 @@ halfword hpack(halfword p, scaled w, int m, int pack_direction)
                     }
                     break;
                 case dir_node:
-                    /* Adjust the dir stack for the |hpack| routine */
-                    if (dir_dir(p) >= 0) {
+                    /*tex Adjust the dir stack for the |hpack| routine. */
+                    if (subtype(p) == normal_dir) {
                         hpack_dir = dir_dir(p);
                         push_dir_node(dir_ptr1,p);
                     } else {
@@ -856,15 +752,17 @@ halfword hpack(halfword p, scaled w, int m, int pack_direction)
                 case ins_node:
                 case mark_node:
                 case adjust_node:
-                    /*
-                        Transfer node |p| to the adjustment list.
-
-                        Although node |q| is not necessarily the immediate predecessor of node |p|,
-                        it always points to some node in the list preceding |p|. Thus, we can delete
-                        nodes by moving |q| when necessary. The algorithm takes linear time, and the
-                        extra computation does not intrude on the inner loop unless it is necessary
-                        to make a deletion.
-                     */
+                    /*tex
+
+                        Transfer node |p| to the adjustment list.\Although node
+                        |q| is not necessarily the immediate predecessor of node
+                        |p|, it always points to some node in the list preceding
+                        |p|. Thus, we can delete nodes by moving |q| when
+                        necessary. The algorithm takes linear time, and the extra
+                        computation does not intrude on the inner loop unless it
+                        is necessary to make a deletion.
+
+                    */
                     if (adjust_tail != null || pre_adjust_tail != null) {
                         while (vlink(q) != p)
                             q = vlink(q);
@@ -885,13 +783,11 @@ halfword hpack(halfword p, scaled w, int m, int pack_direction)
                         p = q;
                     }
                     break;
-                /* */
                 default:
                     break;
             }
             p = vlink(p);
         }
-
     }
 
     if (adjust_tail != null)
@@ -900,31 +796,35 @@ halfword hpack(halfword p, scaled w, int m, int pack_direction)
         vlink(pre_adjust_tail) = null;
     height(r) = h;
     depth(r) = d;
-    /*
+    /*tex
+
         Determine the value of |width(r)| and the appropriate glue setting; then
         |return| or |goto common_ending|.
 
         When we get to the present part of the program, |x| is the natural width
         of the box being packaged.
+
     */
     if (m == additional)
         w = x + w;
     width(r) = w;
     x = w - x;
-    /* now |x| is the excess to be made up */
+    /*tex Now |x| is the excess to be made up. */
     if (x == 0) {
         glue_sign(r) = normal;
         glue_order(r) = normal;
         set_glue_ratio_zero(glue_set(r));
         goto EXIT;
     } else if (x > 0) {
-        /*
-            Determine horizontal glue stretch setting, then |return|
-            or \hbox{|goto common_ending|}.
+        /*tex
+
+            Determine horizontal glue stretch setting, then |return| or
+            |goto common_ending|.
 
             If |hpack| is called with |m=cal_expand_ratio| we calculate
             |font_expand_ratio| and return without checking for overfull or
             underfull box.
+
         */
         if (total_stretch[filll] != 0)
             o = filll;
@@ -936,7 +836,6 @@ halfword hpack(halfword p, scaled w, int m, int pack_direction)
             o = sfi;
         else
             o = normal;
-
         if ((m == cal_expand_ratio) && (o == normal) && (font_stretch > 0)) {
             font_expand_ratio = divide_scaled_n(x, font_stretch, 1000.0);
             goto EXIT;
@@ -946,15 +845,17 @@ halfword hpack(halfword p, scaled w, int m, int pack_direction)
         if (total_stretch[o] != 0) {
             glue_set(r) = unfloat((double) x / total_stretch[o]);
         } else {
-            /* there's nothing to stretch */
+            /*tex There's nothing to stretch. */
             glue_sign(r) = normal;
             set_glue_ratio_zero(glue_set(r));
         }
         if (o == normal) {
             if (list_ptr(r) != null) {
-                /*
-                    Report an underfull hbox and |goto common_ending|, if this box
-                    is sufficiently bad.
+                /*tex
+
+                    Report an underfull hbox and |goto common_ending|, if this
+                    box is sufficiently bad.
+
                 */
                 last_badness = badness(x, total_stretch[normal]);
                 if (last_badness > hbadness_par) {
@@ -987,9 +888,11 @@ halfword hpack(halfword p, scaled w, int m, int pack_direction)
         }
         goto EXIT;
     } else {
-        /*
-            Determine horizontal glue shrink setting, then |return|
-            or \hbox{|goto common_ending|},
+        /*tex
+
+            Determine horizontal glue shrink setting, then |return| or |goto
+            common_ending|,
+
         */
         if (total_shrink[filll] != 0)
             o = filll;
@@ -1001,7 +904,6 @@ halfword hpack(halfword p, scaled w, int m, int pack_direction)
             o = sfi;
         else
             o = normal;
-
         if ((m == cal_expand_ratio) && (o == normal) && (font_shrink > 0)) {
             font_expand_ratio = divide_scaled_n(x, font_shrink, 1000.0);
             goto EXIT;
@@ -1011,18 +913,20 @@ halfword hpack(halfword p, scaled w, int m, int pack_direction)
         if (total_shrink[o] != 0) {
             glue_set(r) = unfloat((double) (-x) / (double) total_shrink[o]);
         } else {
-            /* there's nothing to shrink */
+            /*tex There's nothing to shrink. */
             glue_sign(r) = normal;
             set_glue_ratio_zero(glue_set(r));
         }
         if ((total_shrink[o] < -x) && (o == normal) && (list_ptr(r) != null)) {
             int overshoot = -x - total_shrink[normal] ;
             last_badness = 1000000;
-            /* use the maximum shrinkage */
+            /*tex Use the maximum shrinkage */
             set_glue_ratio_one(glue_set(r));
-            /*
-                Report an overfull hbox and |goto common_ending|, if this box
-                is sufficiently bad.
+            /*tex
+
+                Report an overfull hbox and |goto common_ending|, if this box is
+                sufficiently bad.
+
             */
             if ((overshoot > hfuzz_par) || (hbadness_par < 100)) {
                 int callback_id = callback_defined(hpack_quality_callback);
@@ -1050,9 +954,11 @@ halfword hpack(halfword p, scaled w, int m, int pack_direction)
             }
         } else if (o == normal) {
             if (list_ptr(r) != null) {
-                /*
+                /*tex
+
                     Report a tight hbox and |goto common_ending|, if this box is
                     sufficiently bad.
+
                 */
                 last_badness = badness(-x, total_shrink[normal]);
                 if (last_badness > hbadness_par) {
@@ -1079,10 +985,7 @@ halfword hpack(halfword p, scaled w, int m, int pack_direction)
     }
 
   COMMON_ENDING:
-    /*
-        Finish issuing a diagnostic message for an overfull or underfull
-        hbox.
-    */
+    /*tex Finish issuing a diagnostic message for an overfull or underfull hbox. */
     if (output_active) {
         tprint(") has occurred while \\output is active");
     } else {
@@ -1113,17 +1016,16 @@ halfword hpack(halfword p, scaled w, int m, int pack_direction)
         q = list_ptr(r);
         list_ptr(r) = null;
         flush_node(r);
-        /* this nested call uses the more or less global font_expand_ratio */
+        /*tex This nested call uses the more or less global font_expand_ratio. */
         r = hpack(q, w, subst_ex_font, hpack_dir);
     }
     while (dir_ptr1 != null)
         pop_dir_node(dir_ptr1);
-    /* here we reset the font_expan_ratio */
+    /*tex Here we reset the |font_expand_ratio|. */
     font_expand_ratio = 0;
     return r;
 }
 
-@ @c
 halfword filtered_hpack(halfword p, halfword qt, scaled w, int m, int grp, int pac, int just_pack, halfword attr)
 {
     halfword q;
@@ -1131,32 +1033,33 @@ halfword filtered_hpack(halfword p, halfword qt, scaled w, int m, int grp, int p
         q = vlink(p);
     } else if (type(p) == temp_node && vlink(p) == null) {
         q = vlink(p);
-        /*
-            q = new_node(hlist_node, min_quarterword);
-            box_dir(q) = (pac == -1) ? text_direction_par : pac;
-            width(q) = w;
-            return q;
-        */
     } else {
         new_hyphenation(p, qt);
-        (void) new_ligkern(p, qt);  /* we don't care about the tail in this case */
+        /*tex We don't care about the tail in this case. */
+        (void) new_ligkern(p, qt);
         q = vlink(p);
-        /* maybe here: alink(p) = null */
-        q = lua_hpack_filter(q, w, m, grp, pac, attr); /* ignores empty anyway */ /* maybe also pass tail */
+        /*tex Maybe here: |alink(p) = null|. */
+        /*tex ignores empty anyway. Maybe also pass tail? */
+        q = lua_hpack_filter(q, w, m, grp, pac, attr);
     }
     return hpack(q, w, m, pac);
 }
 
-@ here is a function to calculate the natural whd of a (horizontal) node list
+/*tex
 
-@c
-scaled_whd natural_sizes(halfword p, halfword pp, glue_ratio g_mult,
-                         int g_sign, int g_order, int pack_direction)
+    Here is a function to calculate the natural whd of a (horizontal) node list.
+
+*/
+
+scaled_whd natural_sizes(halfword p, halfword pp, glue_ratio g_mult, int g_sign, int g_order, int pack_direction)
 {
-    scaled s;      /* shift amount */
-    halfword g;    /* points to a glue specification */
+    /*tex shift amount */
+    scaled s;
+    /*tex points to a glue specification */
+    halfword g;
     int hpack_dir;
-    scaled_whd xx; /* for recursion */
+    /*tex For recursion */
+    scaled_whd xx;
     scaled_whd whd, siz = { 0, 0, 0 };
     scaled gp = 0;
     scaled gm = 0;
@@ -1187,20 +1090,6 @@ scaled_whd natural_sizes(halfword p, halfword pp, glue_ratio g_mult,
                     if (whd.dp + s > siz.dp)
                         siz.dp = whd.dp + s;
                     break;
-                /*
-                case rule_node:
-                case unset_node:
-                    siz.wd += width(p);
-                    if (type(p) >= rule_node) // always true
-                        s = 0;
-                    else
-                        s = shift_amount(p);
-                    if (height(p) - s > siz.ht)
-                        siz.ht = height(p) - s;
-                    if (depth(p) + s > siz.dp)
-                        siz.dp = depth(p) + s;
-                    break;
-                */
                 case rule_node:
                 case unset_node:
                     siz.wd += width(p);
@@ -1209,29 +1098,28 @@ scaled_whd natural_sizes(halfword p, halfword pp, glue_ratio g_mult,
                     if (depth(p) > siz.dp)
                         siz.dp = depth(p);
                     break;
-                /* */
                 case math_node:
-                    /* begin mathskip code */
+                    /*tex Begin mathskip code. */
                     if (glue_is_zero(p) || ignore_math_skip(p)) {
                         siz.wd += surround(p);
                         break;
                     } else {
-                        /* fall through */
+                        /*tex Fall through. */
                     }
-                    /* end mathskip code */
+                    /*tex End mathskip code. */
                 case glue_node:
                     siz.wd += width(p);
                     if (g_sign != normal) {
                         if (g_sign == stretching) {
                             if (stretch_order(p) == g_order) {
-                                /*
-                                    siz.wd += float_round(float_cast(g_mult) * float_cast(stretch(p)));
+                                /*tex
+                                    |siz.wd += float_round(float_cast(g_mult) * float_cast(stretch(p)))|
                                 */
                                 gp += stretch(p);
                             }
                         } else if (shrink_order(p) == g_order) {
-                            /*
-                                siz.wd -= float_round(float_cast(g_mult) * float_cast(shrink(p)));
+                            /*tex
+                                |siz.wd -= float_round(float_cast(g_mult) * float_cast(shrink(p)));|
                             */
                             gm += shrink(p);
                         }
@@ -1275,34 +1163,46 @@ scaled_whd natural_sizes(halfword p, halfword pp, glue_ratio g_mult,
     return siz;
 }
 
-@ In order to provide a decent indication of where an overfull or underfull box
-originated, we use a global variable |pack_begin_line| that is set nonzero only
-when |hpack| is being called by the paragraph builder or the alignment finishing
-routine.
+/*tex
+
+    In order to provide a decent indication of where an overfull or underfull box
+    originated, we use a global variable |pack_begin_line| that is set nonzero
+    only when |hpack| is being called by the paragraph builder or the alignment
+    finishing routine.
 
-@ The source file line where the current paragraph or alignment began; a negative
-value denotes alignment:
+    The source file line where the current paragraph or alignment began; a
+    negative value denotes alignment:
+
+*/
 
-@c
 int pack_begin_line;
 
-@ The |vpack| subroutine is actually a special case of a slightly more general
-routine called |vpackage|, which has four parameters. The fourth parameter, which
-is |max_dimen| in the case of |vpack|, specifies the maximum depth of the page
-box that is constructed. The depth is first computed by the normal rules; if it
-exceeds this limit, the reference point is simply moved down until the limiting
-depth is attained.
+/*tex
+
+    The |vpack| subroutine is actually a special case of a slightly more general
+    routine called |vpackage|, which has four parameters. The fourth parameter,
+    which is |max_dimen| in the case of |vpack|, specifies the maximum depth of
+    the page box that is constructed. The depth is first computed by the normal
+    rules; if it exceeds this limit, the reference point is simply moved down
+    until the limiting depth is attained.
+
+*/
 
-@c
 halfword vpackage(halfword p, scaled h, int m, scaled l, int pack_direction)
 {
-    halfword r;                 /* the box node that will be returned */
-    scaled w = 0;               /* width */
-    scaled d = 0;               /* depth */
-    scaled x = 0;               /* natural height */
+    /*tex the box node that will be returned */
+    halfword r;
+    /*tex width */
+    scaled w = 0;
+    /*tex depth */
+    scaled d = 0;
+    /*tex natural height */
+    scaled x = 0;
     scaled_whd whd;
-    scaled s;                   /* shift amount */
-    int o;                      /* order of infinity */
+    /*tex shift amount */
+    scaled s;
+    /*tex order of infinity */
+    int o;
     last_badness = 0;
     r = new_node(vlist_node, 0);
     if (pack_direction == -1) {
@@ -1323,12 +1223,12 @@ halfword vpackage(halfword p, scaled h, int m, scaled l, int pack_direction)
     total_shrink[fill] = 0;
     total_stretch[filll] = 0;
     total_shrink[filll] = 0;
-
     while (p != null) {
-        /*
-            Examine node |p| in the vlist, taking account of its effect
-            on the dimensions of the new box; then advance |p| to the next
-            node.
+        /*tex
+
+            Examine node |p| in the vlist, taking account of its effect on the
+            dimensions of the new box; then advance |p| to the next node.
+
         */
         if (is_char_node(p)) {
             confusion("vpack");
@@ -1336,9 +1236,11 @@ halfword vpackage(halfword p, scaled h, int m, scaled l, int pack_direction)
             switch (type(p)) {
             case hlist_node:
             case vlist_node:
-                /*
-                    Incorporate box dimensions into the dimensions of
-                    the vbox that will contain it.
+                /*tex
+
+                    Incorporate box dimensions into the dimensions of the vbox
+                    that will contain it.
+
                 */
                 s = shift_amount(p);
                 whd = pack_width_height_depth(box_dir(r), box_dir(p), p, false);
@@ -1347,19 +1249,6 @@ halfword vpackage(halfword p, scaled h, int m, scaled l, int pack_direction)
                 x += d + whd.ht;
                 d = whd.dp;
                 break;
-            /*
-            case rule_node:
-            case unset_node:
-                x += d + height(p);
-                d = depth(p);
-                if (type(p) >= rule_node) // always
-                    s = 0;
-                else
-                    s = shift_amount(p);
-                if (width(p) + s > w)
-                    w = width(p) + s;
-                break;
-            */
             case rule_node:
             case unset_node:
                 x += d + height(p);
@@ -1367,9 +1256,8 @@ halfword vpackage(halfword p, scaled h, int m, scaled l, int pack_direction)
                 if (width(p) > w)
                     w = width(p);
                 break;
-            /* */
             case glue_node:
-                /* Incorporate glue into the vertical totals */
+                /*tex Incorporate glue into the vertical totals. */
                 x += d;
                 d = 0;
                 x += width(p);
@@ -1400,27 +1288,30 @@ halfword vpackage(halfword p, scaled h, int m, scaled l, int pack_direction)
     } else {
         depth(r) = d;
     }
-    /*
-        Determine the value of |height(r)| and the appropriate glue setting;
-        then |return| or |goto common_ending|.
+    /*tex
+
+        Determine the value of |height(r)| and the appropriate glue setting; then
+        |return| or |goto common_ending|.
 
-        When we get to the present part of the program, |x| is the natural
-        height of the box being packaged.
+        When we get to the present part of the program, |x| is the natural height
+        of the box being packaged.
     */
     if (m == additional)
         h = x + h;
     height(r) = h;
     x = h - x;
-    /* now |x| is the excess to be made up */
+    /*tex Now |x| is the excess to be made up. */
     if (x == 0) {
         glue_sign(r) = normal;
         glue_order(r) = normal;
         set_glue_ratio_zero(glue_set(r));
         return r;
     } else if (x > 0) {
-        /*
-            Determine vertical glue stretch setting, then |return|
-            or \hbox{|goto common_ending|}.
+        /*tex
+
+            Determine vertical glue stretch setting, then |return| or |goto
+            common_ending|.
+
         */
         if (total_stretch[filll] != 0)
             o = filll;
@@ -1432,20 +1323,22 @@ halfword vpackage(halfword p, scaled h, int m, scaled l, int pack_direction)
             o = sfi;
         else
             o = normal;
-
         glue_order(r) = (quarterword) o;
         glue_sign(r) = stretching;
         if (total_stretch[o] != 0) {
             glue_set(r) = unfloat((double) x / total_stretch[o]);
         } else {
+            /*tex There's nothing to stretch. */
             glue_sign(r) = normal;
-            set_glue_ratio_zero(glue_set(r));   /* there's nothing to stretch */
+            set_glue_ratio_zero(glue_set(r));
         }
         if (o == normal) {
             if (list_ptr(r) != null) {
-                /*
-                    Report an underfull vbox and |goto common_ending|, if this box
-                    is sufficiently bad.
+                /*tex
+
+                    Report an underfull vbox and |goto common_ending|, if this
+                    box is sufficiently bad.
+
                 */
                 last_badness = badness(x, total_stretch[normal]);
                 if (last_badness > vbadness_par) {
@@ -1471,11 +1364,12 @@ halfword vpackage(halfword p, scaled h, int m, scaled l, int pack_direction)
             }
         }
         return r;
-
     } else {
-        /*
-            Determine vertical glue shrink setting, then |return|
-            or \hbox{|goto common_ending|}.
+        /*tex
+
+            Determine vertical glue shrink setting, then |return| or |goto
+            common_ending|.
+
         */
         if (total_shrink[filll] != 0)
             o = filll;
@@ -1487,24 +1381,25 @@ halfword vpackage(halfword p, scaled h, int m, scaled l, int pack_direction)
             o = sfi;
         else
             o = normal;
-
         glue_order(r) = (quarterword) o;
         glue_sign(r) = shrinking;
         if (total_shrink[o] != 0) {
             glue_set(r) = unfloat((double) (-x) / total_shrink[o]);
         } else {
-            /* there's nothing to shrink */
+            /*tex There's nothing to shrink. */
             glue_sign(r) = normal;
             set_glue_ratio_zero(glue_set(r));
         }
         if ((total_shrink[o] < -x) && (o == normal) && (list_ptr(r) != null)) {
             int overshoot = -x - total_shrink[normal];
             last_badness = 1000000;
-            /* use the maximum shrinkage */
+            /*tex Use the maximum shrinkage */
             set_glue_ratio_one(glue_set(r));
-            /*
-                Report an overfull vbox and |goto common_ending|, if this box
-                is sufficiently bad.
+            /*tex
+
+                Report an overfull vbox and |goto common_ending|, if this box is
+                sufficiently bad.
+
             */
             if ((overshoot > vfuzz_par) || (vbadness_par < 100)) {
                 int callback_id = callback_defined(vpack_quality_callback);
@@ -1521,9 +1416,11 @@ halfword vpackage(halfword p, scaled h, int m, scaled l, int pack_direction)
             }
         } else if (o == normal) {
             if (list_ptr(r) != null) {
-                /*
+                /*tex
+
                     Report a tight vbox and |goto common_ending|, if this box is
                     sufficiently bad.
+
                 */
                 last_badness = badness(-x, total_shrink[normal]);
                 if (last_badness > vbadness_par) {
@@ -1544,12 +1441,12 @@ halfword vpackage(halfword p, scaled h, int m, scaled l, int pack_direction)
     }
 
   COMMON_ENDING:
-    /* Finish issuing a diagnostic message or an overfull or underfull vbox */
+    /*tex Finish issuing a diagnostic message or an overfull or underfull vbox. */
     if (output_active) {
         tprint(") has occurred while \\output is active");
     } else {
         if (pack_begin_line != 0) {
-            /* it's actually negative */
+            /*tex It's actually negative. */
             tprint(") in alignment at lines ");
             print_int(abs(pack_begin_line));
             tprint("--");
@@ -1566,17 +1463,14 @@ halfword vpackage(halfword p, scaled h, int m, scaled l, int pack_direction)
     return r;
 }
 
-@ @c
 halfword filtered_vpackage(halfword p, scaled h, int m, scaled l, int grp, int pack_direction, int just_pack, halfword attr)
 {
     halfword q = p;
     if (!just_pack)
- /* if (q != null) */
         q = lua_vpack_filter(q, h, m, l, grp, pack_direction, attr);
     return vpackage(q, h, m, l, pack_direction);
 }
 
-@ @c
 void finish_vcenter(void)
 {
     halfword p;
@@ -1588,12 +1482,11 @@ void finish_vcenter(void)
     tail_append(p);
 }
 
-@ @c
 void package(int c)
 {
     halfword saved0, saved2, saved3, saved4;
     int grp = cur_group;
-    scaled d = box_max_depth_par; /* max depth */
+    scaled d = box_max_depth_par;
     unsave();
     save_ptr -= 5;
     saved0 = saved_value(0);
@@ -1608,11 +1501,13 @@ void package(int c)
         cur_box = filtered_vpackage(vlink(cur_list.head_field),
             saved_value(1), saved_level(1), d, grp, saved_level(2), saved4, saved3);
         if (c == vtop_code) {
-            /*
+            /*tex
+
                 Read just the height and depth of |cur_box|, for \.{\\vtop}. The
                 height of a `\.{\\vtop}' box is inherited from the first item on
                 its list, if that item is an |hlist_node|, |vlist_node|, or
                 |rule_node|; otherwise the \.{\\vtop} height is zero.
+
             */
             scaled h = 0;
             halfword p = list_ptr(cur_box);
@@ -1625,7 +1520,7 @@ void package(int c)
         }
     }
     if (saved2 != null) {
-        /* DIR: Adjust back |text_dir_ptr| for |scan_spec| */
+        /*tex Adjust back |text_dir_ptr| for |scan_spec| */
         flush_node_list(text_dir_ptr);
         text_dir_ptr = saved2;
 
@@ -1635,14 +1530,19 @@ void package(int c)
     box_end(saved0);
 }
 
-@ When a box is being appended to the current vertical list, the baselineskip
-calculation is handled by the |append_to_vlist| routine.
+/*tex
+
+    When a box is being appended to the current vertical list, the baselineskip
+    calculation is handled by the |append_to_vlist| routine.
+
+*/
 
-@c
 void append_to_vlist(halfword b, int location)
 {
-    scaled d;   /* deficiency of space between baselines */
-    halfword p; /* a new glue node */
+    /*tex The deficiency of space between baselines: */
+    scaled d;
+    /*tex A new glue node. */
+    halfword p;
     boolean mirrored = (type(b) == hlist_node) && is_mirrored(box_dir(b)) ;
     halfword result = null;
     halfword next_depth = ignore_depth;
@@ -1682,188 +1582,235 @@ void append_to_vlist(halfword b, int location)
     }
 }
 
-@ When |saving_vdiscards| is positive then the glue, kern, and penalty nodes
-removed by the page builder or by \.{\\vsplit} from the top of a vertical list
-are saved in special lists instead of being discarded.
+/*tex
+
+    When |saving_vdiscards| is positive then the glue, kern, and penalty nodes
+    removed by the page builder or by \.{\\vsplit} from the top of a vertical
+    list are saved in special lists instead of being discarded.
+
+*/
+
+/*tex last item removed by page builder */
+
+#define tail_page_disc disc_ptr[copy_code]
+
+/*tex first item removed by page builder */
+
+#define page_disc disc_ptr[last_box_code]
+
+/*tex first item removed by \.{\\vsplit} */
 
-@c
-#define tail_page_disc disc_ptr[copy_code]  /* last item removed by page builder */
-#define page_disc disc_ptr[last_box_code]   /* first item removed by page builder */
-#define split_disc disc_ptr[vsplit_code]    /* first item removed by \.{\\vsplit} */
+#define split_disc disc_ptr[vsplit_code]
 
-halfword disc_ptr[(vsplit_code + 1)];       /* list pointers */
+/*tex List pointers. */
 
-@ The |vsplit| procedure, which implements \TeX's \.{\\vsplit} operation, is
-considerably simpler than |line_break| because it doesn't have to worry about
-hyphenation, and because its mission is to discover a single break instead of an
-optimum sequence of breakpoints. But before we get into the details of |vsplit|,
-we need to consider a few more basic things.
+halfword disc_ptr[(vsplit_code + 1)];
 
-A subroutine called |prune_page_top| takes a pointer to a vlist and returns a
-pointer to a modified vlist in which all glue, kern, and penalty nodes have been
-deleted before the first box or rule node. However, the first box or rule is
-actually preceded by a newly created glue node designed so that the topmost
-baseline will be at distance |split_top_skip| from the top, whenever this is
-possible without backspacing.
+/*tex
 
-When the second argument |s| is |false| the deleted nodes are destroyed,
-otherwise they are collected in a list starting at |split_disc|.
+    The |vsplit| procedure, which implements \TeX's \.{\\vsplit} operation, is
+    considerably simpler than |line_break| because it doesn't have to worry about
+    hyphenation, and because its mission is to discover a single break instead of
+    an optimum sequence of breakpoints. But before we get into the details of
+    |vsplit|, we need to consider a few more basic things.
+
+    A subroutine called |prune_page_top| takes a pointer to a vlist and returns a
+    pointer to a modified vlist in which all glue, kern, and penalty nodes have
+    been deleted before the first box or rule node. However, the first box or
+    rule is actually preceded by a newly created glue node designed so that the
+    topmost baseline will be at distance |split_top_skip| from the top, whenever
+    this is possible without backspacing.
+
+    When the second argument |s| is |false| the deleted nodes are destroyed,
+    otherwise they are collected in a list starting at |split_disc|.
+
+*/
 
-@c
 halfword prune_page_top(halfword p, boolean s)
 {
     halfword q;
-    halfword prev_p = temp_head; /* lags one step behind |p| */
+    /*tex Lags one step behind |p|. */
+    halfword prev_p = temp_head;
     halfword r = null;
     vlink(temp_head) = p;
     while (p != null) {
         switch (type(p)) {
-        case hlist_node:
-        case vlist_node:
-        case rule_node:
-            /* Insert glue for |split_top_skip| and set~|p:=null| */
-            q = new_skip_param(split_top_skip_code);
-            vlink(prev_p) = q;
-            vlink(q) = p;
-            if (width(q) > height(p))
-                width(q) = width(q) - height(p);
-            else
-                width(q) = 0;
-            p = null;
-            break;
-        case boundary_node:
-        case whatsit_node:
-        case mark_node:
-        case ins_node:
-            prev_p = p;
-            p = vlink(prev_p);
-            break;
-        case glue_node:
-        case kern_node:
-        case penalty_node:
-            q = p;
-            p = vlink(q);
-            vlink(q) = null;
-            vlink(prev_p) = p;
-            if (s) {
-                if (split_disc == null)
-                    split_disc = q;
+            case hlist_node:
+            case vlist_node:
+            case rule_node:
+                /*tex Insert glue for |split_top_skip| and set |p:=null|. */
+                q = new_skip_param(split_top_skip_code);
+                vlink(prev_p) = q;
+                vlink(q) = p;
+                if (width(q) > height(p))
+                    width(q) = width(q) - height(p);
                 else
-                    vlink(r) = q;
-                r = q;
-            } else {
-                flush_node_list(q);
-            }
-            break;
-        default:
-            confusion("pruning");
-            break;
+                    width(q) = 0;
+                p = null;
+                break;
+            case boundary_node:
+            case whatsit_node:
+            case mark_node:
+            case ins_node:
+                prev_p = p;
+                p = vlink(prev_p);
+                break;
+            case glue_node:
+            case kern_node:
+            case penalty_node:
+                q = p;
+                p = vlink(q);
+                vlink(q) = null;
+                vlink(prev_p) = p;
+                if (s) {
+                    if (split_disc == null)
+                        split_disc = q;
+                    else
+                        vlink(r) = q;
+                    r = q;
+                } else {
+                    flush_node_list(q);
+                }
+                break;
+            default:
+                confusion("pruning");
+                break;
         }
     }
     return vlink(temp_head);
 }
 
-@ The next subroutine finds the best place to break a given vertical list so as
-to obtain a box of height~|h|, with maximum depth~|d|. A pointer to the beginning
-of the vertical list is given, and a pointer to the optimum breakpoint is
-returned. The list is effectively followed by a forced break, i.e., a penalty
-node with the |eject_penalty|; if the best break occurs at this artificial node,
-the value |null| is returned.
+/*tex
+
+    The next subroutine finds the best place to break a given vertical list so as
+    to obtain a box of height~|h|, with maximum depth~|d|. A pointer to the
+    beginning of the vertical list is given, and a pointer to the optimum
+    breakpoint is returned. The list is effectively followed by a forced break,
+    i.e., a penalty node with the |eject_penalty|; if the best break occurs at
+    this artificial node, the value |null| is returned.
 
-@c
-scaled active_height[10]; /* distance from first active node to~|cur_p| */
+*/
+
+/*tex The distance from first active node to |cur_p|: */
+
+scaled active_height[10];
 
-@ An array of six |scaled| distances is used to keep track of the height from the
-beginning of the list to the current place, just as in |line_break|. In fact, we
-use one of the same arrays, only changing its name to reflect its new
-significance.
+/*tex
+
+    An array of six |scaled| distances is used to keep track of the height from
+    the beginning of the list to the current place, just as in |line_break|. In
+    fact, we use one of the same arrays, only changing its name to reflect its
+    new significance.
+
+*/
 
-@c
 #define do_all_six(A) A(1);A(2);A(3);A(4);A(5);A(6);A(7)
 #define set_height_zero(A) active_height[A]=0   /* initialize the height to zero */
 
-@ A global variable |best_height_plus_depth| will be set to the natural size of
-the box that corresponds to the optimum breakpoint found by |vert_break|. (This
-value is used by the insertion-splitting algorithm of the page builder.)
+/*tex
 
-@ height of the best box, without stretching or shrinking
+    A global variable |best_height_plus_depth| will be set to the natural size of
+    the box that corresponds to the optimum breakpoint found by |vert_break|.
+    (This value is used by the insertion-splitting algorithm of the page
+    builder.)
 
-@c
-scaled best_height_plus_depth;
+*/
 
-/* finds optimum page break */
+/*tex The height of the best box, without stretching or shrinking: */
+
+scaled best_height_plus_depth;
 
 halfword vert_break(halfword p, scaled h, scaled d)
 {
-    halfword prev_p = p;        /* if |p| is a glue node, |type(prev_p)| determines whether |p| is a
-                                   legal breakpoint, an initial glue node is not a legal breakpoint */
-    int pi = 0;                 /* penalty value */
-    int b;                      /* badness at a trial breakpoint */
-    int t;                      /* |type| of the node following a kern */
-    int least_cost;             /* the smallest badness plus penalties found so far */
-    halfword best_place = null; /* the most recent break that leads to |least_cost| */
-    scaled prev_dp = 0;         /* depth of previous box in the list */
+    /*tex
+        If |p| is a glue node, |type(prev_p)| determines whether |p| is a legal
+        breakpoint, an initial glue node is not a legal breakpoint.
+    */
+    halfword prev_p = p;
+    /*tex penalty value */
+    int pi = 0;
+    /*tex badness at a trial breakpoint */
+    int b;
+    /*tex |type| of the node following a kern */
+    int t;
+    /*tex the smallest badness plus penalties found so far */
+    int least_cost;
+    /*tex the most recent break that leads to |least_cost| */
+    halfword best_place = null;
+    /*tex depth of previous box in the list */
+    scaled prev_dp = 0;
     least_cost = awful_bad;
     do_all_six(set_height_zero);
     while (1) {
-        /* If node |p| is a legal breakpoint, check if this break is
-           the best known, and |goto done| if |p| is null or
-           if the page-so-far is already too full to accept more stuff */
-        /* A subtle point to be noted here is that the maximum depth~|d| might be
-           negative, so |cur_height| and |prev_dp| might need to be corrected even
-           after a glue or kern node. */
+        /*tex
 
+            If node |p| is a legal breakpoint, check if this break is the best
+            known, and |goto done| if |p| is null or if the page-so-far is
+            already too full to accept more stuff.
+
+            A subtle point to be noted here is that the maximum depth~|d| might
+            be negative, so |cur_height| and |prev_dp| might need to be corrected
+            even after a glue or kern node.
+        */
         if (p == null) {
             pi = eject_penalty;
         } else {
-            /* Use node |p| to update the current height and depth measurements;
-               if this node is not a legal breakpoint, |goto not_found|
-               or |update_heights|,
-               otherwise set |pi| to the associated penalty at the break */
+            /*tex
+
+                Use node |p| to update the current height and depth measurements;
+                if this node is not a legal breakpoint, |goto not_found| or
+                |update_heights|, otherwise set |pi| to the associated penalty at
+                the break.
+
+            */
             switch (type(p)) {
-            case hlist_node:
-            case vlist_node:
-            case rule_node:
-                cur_height = cur_height + prev_dp + height(p);
-                prev_dp = depth(p);
-                goto NOT_FOUND;
-                break;
-            case boundary_node:
-            case whatsit_node:
-                goto NOT_FOUND;
-                break;
-            case glue_node:
-                if (precedes_break(prev_p))
-                    pi = 0;
-                else
-                    goto UPDATE_HEIGHTS;
-                break;
-            case kern_node:
-                if (vlink(p) == null)
-                    t = penalty_node;
-                else
-                    t = type(vlink(p));
-                if (t == glue_node)
-                    pi = 0;
-                else
-                    goto UPDATE_HEIGHTS;
-                break;
-            case penalty_node:
-                pi = penalty(p);
-                break;
-            case mark_node:
-            case ins_node:
-                goto NOT_FOUND;
-                break;
-            default:
-                confusion("vertbreak");
-                break;
+                case hlist_node:
+                case vlist_node:
+                case rule_node:
+                    cur_height = cur_height + prev_dp + height(p);
+                    prev_dp = depth(p);
+                    goto NOT_FOUND;
+                    break;
+                case boundary_node:
+                case whatsit_node:
+                    goto NOT_FOUND;
+                    break;
+                case glue_node:
+                    if (precedes_break(prev_p))
+                        pi = 0;
+                    else
+                        goto UPDATE_HEIGHTS;
+                    break;
+                case kern_node:
+                    if (vlink(p) == null)
+                        t = penalty_node;
+                    else
+                        t = type(vlink(p));
+                    if (t == glue_node)
+                        pi = 0;
+                    else
+                        goto UPDATE_HEIGHTS;
+                    break;
+                case penalty_node:
+                    pi = penalty(p);
+                    break;
+                case mark_node:
+                case ins_node:
+                    goto NOT_FOUND;
+                    break;
+                default:
+                    confusion("vertbreak");
+                    break;
             }
         }
-        /* Check if node |p| is a new champion breakpoint; then |goto done|
-           if |p| is a forced break or if the page-so-far is already too full */
+        /*tex
+
+            Check if node |p| is a new champion breakpoint; then |goto done| if
+            |p| is a forced break or if the page-so-far is already too full.
+
+        */
         if (pi < inf_penalty) {
-            /* Compute the badness, |b|, using |awful_bad| if the box is too full */
+            /*tex Compute the badness, |b|, using |awful_bad| if the box is too full. */
             if (cur_height < h) {
                 if ((active_height[3] != 0) || (active_height[4] != 0) ||
                     (active_height[5] != 0) || (active_height[6] != 0))
@@ -1875,7 +1822,6 @@ halfword vert_break(halfword p, scaled h, scaled d)
             } else {
                 b = badness(cur_height - h, active_height[7]);
             }
-
             if (b < awful_bad) {
                 if (pi <= eject_penalty)
                     b = pi;
@@ -1892,25 +1838,29 @@ halfword vert_break(halfword p, scaled h, scaled d)
             if ((b == awful_bad) || (pi <= eject_penalty))
                 goto DONE;
         }
-
         if ((type(p) < glue_node) || (type(p) > kern_node))
             goto NOT_FOUND;
       UPDATE_HEIGHTS:
-        /* Update the current height and depth measurements with
-           respect to a glue or kern node~|p| */
-        /* Vertical lists that are subject to the |vert_break| procedure should not
-           contain infinite shrinkability, since that would permit any amount of
-           information to ``fit'' on one page. */
+        /*tex
+
+            Update the current height and depth measurements with respect to a
+            glue or kern node~|p|. Vertical lists that are subject to the
+            |vert_break| procedure should not contain infinite shrinkability,
+            since that would permit any amount of information to ``fit'' on one
+            page.
 
+        */
         if (type(p) != kern_node) {
             active_height[2 + stretch_order(p)] += stretch(p);
             active_height[7] += shrink(p);
             if ((shrink_order(p) != normal) && (shrink(p) != 0)) {
                 print_err("Infinite glue shrinkage found in box being split");
-                help4("The box you are \\vsplitting contains some infinitely",
-                      "shrinkable glue, e.g., `\\vss' or `\\vskip 0pt minus 1fil'.",
-                      "Such glue doesn't belong there; but you can safely proceed,",
-                      "since the offensive shrinkability has been made finite.");
+                help4(
+                    "The box you are \\vsplitting contains some infinitely",
+                    "shrinkable glue, e.g., `\\vss' or `\\vskip 0pt minus 1fil'.",
+                    "Such glue doesn't belong there; but you can safely proceed,",
+                    "since the offensive shrinkability has been made finite."
+                );
                 error();
                 shrink_order(p) = normal;
             }
@@ -1929,31 +1879,39 @@ halfword vert_break(halfword p, scaled h, scaled d)
     return best_place;
 }
 
-@ Now we are ready to consider |vsplit| itself. Most of its work is accomplished
-by the two subroutines that we have just considered.
+/*tex
+
+    Now we are ready to consider |vsplit| itself. Most of its work is
+    accomplished by the two subroutines that we have just considered.
 
-Given the number of a vlist box |n|, and given a desired page height |h|, the
-|vsplit| function finds the best initial segment of the vlist and returns a box
-for a page of height~|h|. The remainder of the vlist, if any, replaces the
-original box, after removing glue and penalties and adjusting for
-|split_top_skip|. Mark nodes in the split-off box are used to set the values of
-|split_first_mark| and |split_bot_mark|; we use the fact that
-|split_first_mark(x)=null| if and only if |split_bot_mark(x)=null|.
+    Given the number of a vlist box |n|, and given a desired page height |h|, the
+    |vsplit| function finds the best initial segment of the vlist and returns a
+    box for a page of height~|h|. The remainder of the vlist, if any, replaces
+    the original box, after removing glue and penalties and adjusting for
+    |split_top_skip|. Mark nodes in the split-off box are used to set the values
+    of |split_first_mark| and |split_bot_mark|; we use the fact that
+    |split_first_mark(x)=null| if and only if |split_bot_mark(x)=null|.
 
-The original box becomes ``void'' if and only if it has been entirely extracted.
-The extracted box is ``void'' if and only if the original box was void (or if it
-was, erroneously, an hlist box).
+    The original box becomes ``void'' if and only if it has been entirely
+    extracted. The extracted box is ``void'' if and only if the original box was
+    void (or if it was, erroneously, an hlist box).
 
-@c
-/* extracts a page of height |h| from box |n| */
+*/
+
+/*tex Extract a page of height |h| from box |n|: */
 
 halfword vsplit(halfword n, scaled h, int m)
 {
-    halfword v;  /* the box to be split */
-    int vdir;    /* the direction of the box to be split */
-    halfword p;  /* runs through the vlist */
-    halfword q;  /* points to where the break occurs */
-    halfword i;  /* for traversing marks lists */
+    /*tex the box to be split */
+    halfword v;
+    /*tex the direction of the box to be split */
+    int vdir;
+    /*tex runs through the vlist */
+    halfword p;
+    /*tex points to where the break occurs */
+    halfword q;
+    /*tex for traversing marks lists */
+    halfword i;
     v = box(n);
     vdir = box_dir(v);
     flush_node_list(split_disc);
@@ -1962,23 +1920,27 @@ halfword vsplit(halfword n, scaled h, int m)
         delete_split_first_mark(i);
         delete_split_bot_mark(i);
     }
-    /* Dispense with trivial cases of void or bad boxes */
+    /*tex Dispense with trivial cases of void or bad boxes. */
     if (v == null) {
         return null;
     }
     if (type(v) != vlist_node) {
         print_err("\\vsplit needs a \\vbox");
-        help2("The box you are trying to split is an \\hbox.",
-              "i can't split such a box, so I''ll leave it alone.");
+        help2(
+            "The box you are trying to split is an \\hbox.",
+            "i can't split such a box, so I''ll leave it alone."
+        );
         error();
         return null;
     }
     q = vert_break(list_ptr(v), h, split_max_depth_par);
-    /*
-        Look at all the marks in nodes before the break, and set the final
-        link to |null| at the break. It's possible that the box begins with
-        a penalty node that is the ``best'' break, so we must be careful to
-        handle this special case correctly.
+    /*tex
+
+        Look at all the marks in nodes before the break, and set the final link
+        to |null| at the break. It's possible that the box begins with a penalty
+        node that is the ``best'' break, so we must be careful to handle this
+        special case correctly.
+
     */
     p = list_ptr(v);
     if (p == q) {
@@ -2009,7 +1971,7 @@ halfword vsplit(halfword n, scaled h, int m)
     list_ptr(v) = null;
     flush_node(v);
     if (q == null) {
-        /* the |eq_level| of the box stays the same */
+        /*tex The |eq_level| of the box stays the same. */
         box(n) = null;
     } else {
         box(n) = filtered_vpackage(q, 0, additional, max_depth_par, split_keep_group, vdir, 0, 0);
@@ -2021,17 +1983,23 @@ halfword vsplit(halfword n, scaled h, int m)
     }
 }
 
-@ Now that we can see what eventually happens to boxes, we can consider the first
-steps in their creation. The |begin_box| routine is called when |box_context| is
-a context specification, |cur_chr| specifies the type of box desired, and
-|cur_cmd=make_box|.
+/*tex
+
+    Now that we can see what eventually happens to boxes, we can consider the
+    first steps in their creation. The |begin_box| routine is called when
+    |box_context| is a context specification, |cur_chr| specifies the type of box
+    desired, and |cur_cmd=make_box|.
+
+*/
 
-@c
 void begin_box(int box_context)
 {
-    halfword q; /* run through the current list */
-    halfword k; /* 0 or |vmode| or |hmode| */
-    int n;      /* a box number */
+    /*tex run through the current list */
+    halfword q;
+    /*tex 0 or |vmode| or |hmode| */
+    halfword k;
+    /*tex a box number */
+    int n;
     int spec_direction = -1;
     int just_pack = 0;
     int split_mode = exactly ;
@@ -2039,7 +2007,7 @@ void begin_box(int box_context)
         case box_code:
             scan_register_num();
             cur_box = box(cur_val);
-            /* the box becomes void, at the same level */
+            /*tex The box becomes void, at the same level. */
             box(cur_val) = null;
             break;
         case copy_code:
@@ -2047,10 +2015,11 @@ void begin_box(int box_context)
             cur_box = copy_node_list(box(cur_val));
             break;
         case last_box_code:
-            /*
-                If the current list ends with a box node, delete it from
-                the list and make |cur_box| point to it; otherwise set
-                |cur_box:=null|.
+            /*tex
+
+                If the current list ends with a box node, delete it from the list
+                and make |cur_box| point to it; otherwise set |cur_box:=null|.
+
             */
             cur_box = null;
             if (abs(cur_list.mode_field) == mmode) {
@@ -2059,17 +2028,15 @@ void begin_box(int box_context)
                 error();
             } else if ((cur_list.mode_field == vmode) && (cur_list.head_field == cur_list.tail_field)) {
                 you_cant();
-                help2("Sorry...I usually can't take things from the current page.",
-                      "This \\lastbox will therefore be void.");
+                help2(
+                    "Sorry...I usually can't take things from the current page.",
+                    "This \\lastbox will therefore be void."
+                );
                 error();
             } else {
                 if (cur_list.head_field != cur_list.tail_field) {
-                    /* todo: new code,  needs testing */
-
-                    /* maybe: ((type(cur_list.tail_field) == hlist_node) < rule_node) */
-
                     if ((type(cur_list.tail_field) == hlist_node) || (type(cur_list.tail_field) == vlist_node)) {
-                        /* Remove the last box ... */
+                        /*tex Remove the last box */
                         q = alink(cur_list.tail_field);
                         if (q == null || vlink(q) != cur_list.tail_field) {
                             q = cur_list.head_field;
@@ -2086,9 +2053,11 @@ void begin_box(int box_context)
             }
             break;
         case vsplit_code:
-            /*
-                Split off part of a vertical box, make |cur_box| point to it. Here we
-                deal with things like `\.{\\vsplit 13 to 100pt}'.
+            /*tex
+
+                Split off part of a vertical box, make |cur_box| point to it.
+                Here we deal with things like `\.{\\vsplit 13 to 100pt}'.
+
             */
             scan_register_num();
             n = cur_val;
@@ -2096,18 +2065,22 @@ void begin_box(int box_context)
                 split_mode = additional ;
             } else if (!scan_keyword("to")) {
                 print_err("Missing `to' inserted");
-                help2("I'm working on `\\vsplit<box number> to <dimen>';",
-                      "will look for the <dimen> next.");
+                help2(
+                    "I'm working on `\\vsplit<box number> to <dimen>';",
+                  "will look for the <dimen> next."
+                );
                 error();
             }
             scan_normal_dimen();
             cur_box = vsplit(n, cur_val, split_mode);
          break;
         default:
-            /*
-                Initiate the construction of an hbox or vbox, then |return|. Here is
-                where we enter restricted horizontal mode or internal vertical mode,
-                in order to make a box.
+            /*tex
+
+                Initiate the construction of an hbox or vbox, then |return|. Here
+                is where we enter restricted horizontal mode or internal vertical
+                mode, in order to make a box.
+
             */
             switch (cur_chr) {
                 case tpack_code:
@@ -2123,7 +2096,6 @@ void begin_box(int box_context)
                     just_pack = 1;
                     break;
             }
-            /* */
             k = cur_chr - vtop_code;
             set_saved_record(0, saved_boxcontext, 0, box_context);
             switch (abs(cur_list.mode_field)) {
@@ -2165,6 +2137,6 @@ void begin_box(int box_context)
             return;
             break;
     }
-    /* in simple cases, we use the box immediately */
+    /*tex In simple cases, we use the box immediately. */
     box_end(box_context);
 }
diff --git a/texk/web2c/luatexdir/tex/postlinebreak.w b/texk/web2c/luatexdir/tex/postlinebreak.c
similarity index 52%
rename from texk/web2c/luatexdir/tex/postlinebreak.w
rename to texk/web2c/luatexdir/tex/postlinebreak.c
index dd85cf01b..cbc77e556 100644
--- a/texk/web2c/luatexdir/tex/postlinebreak.w
+++ b/texk/web2c/luatexdir/tex/postlinebreak.c
@@ -1,60 +1,65 @@
-% postlinebreak.w
-%
-% Copyright 2006-2010 Taco Hoekwater <taco@@luatex.org>
-%
-% This file is part of LuaTeX.
-%
-% LuaTeX is free software; you can redistribute it and/or modify it under
-% the terms of the GNU General Public License as published by the Free
-% Software Foundation; either version 2 of the License, or (at your
-% option) any later version.
-%
-% LuaTeX is distributed in the hope that it will be useful, but WITHOUT
-% ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-% FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
-% License for more details.
-%
-% You should have received a copy of the GNU General Public License along
-% with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+/*
 
-@ @c
+postlinebreak.w
 
+Copyright 2006-2010 Taco Hoekwater <taco@@luatex.org>
+
+This file is part of LuaTeX.
+
+LuaTeX is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 2 of the License, or (at your
+option) any later version.
+
+LuaTeX is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+License for more details.
+
+You should have received a copy of the GNU General Public License along
+with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+
+*/
 
 #include "ptexlib.h"
 
-@ So far we have gotten a little way into the |line_break| routine, having
-covered its important |try_break| subroutine. Now let's consider the
-rest of the process.
+/*tex
+
+So far we have gotten a little way into the |line_break| routine, having covered
+its important |try_break| subroutine. Now let's consider the rest of the process.
 
-The main loop of |line_break| traverses the given hlist,
-starting at |vlink(temp_head)|, and calls |try_break| at each legal
-breakpoint. A variable called |auto_breaking| is set to true except
-within math formulas, since glue nodes are not legal breakpoints when
-they appear in formulas.
+The main loop of |line_break| traverses the given hlist, starting at
+|vlink(temp_head)|, and calls |try_break| at each legal breakpoint. A variable
+called |auto_breaking| is set to true except within math formulas, since glue
+nodes are not legal breakpoints when they appear in formulas.
 
 The current node of interest in the hlist is pointed to by |cur_p|. Another
-variable, |prev_p|, is usually one step behind |cur_p|, but the real
-meaning of |prev_p| is this: If |type(cur_p)=glue_node| then |cur_p| is a legal
-breakpoint if and only if |auto_breaking| is true and |prev_p| does not
-point to a glue node, penalty node, explicit kern node, or math node.
+variable, |prev_p|, is usually one step behind |cur_p|, but the real meaning of
+|prev_p| is this: If |type(cur_p)=glue_node| then |cur_p| is a legal breakpoint
+if and only if |auto_breaking| is true and |prev_p| does not point to a glue
+node, penalty node, explicit kern node, or math node.
+
+The total number of lines that will be set by |post_line_break| is
+|best_line-prev_graf-1|. The last breakpoint is specified by
+|break_node(best_bet)|, and this passive node points to the other breakpoints via
+the |prev_break| links. The finishing-up phase starts by linking the relevant
+passive nodes in forward order, changing |prev_break| to |next_break|. (The
+|next_break| fields actually reside in the same memory space as the |prev_break|
+fields did, but we give them a new name because of their new significance.) Then
+the lines are justified, one by one.
 
-@ The total number of lines that will be set by |post_line_break|
-is |best_line-prev_graf-1|. The last breakpoint is specified by
-|break_node(best_bet)|, and this passive node points to the other breakpoints
-via the |prev_break| links. The finishing-up phase starts by linking the
-relevant passive nodes in forward order, changing |prev_break| to
-|next_break|. (The |next_break| fields actually reside in the same memory
-space as the |prev_break| fields did, but we give them a new name because
-of their new significance.) Then the lines are justified, one by one.
+The |post_line_break| must also keep an dir stack, so that it can output end
+direction instructions at the ends of lines and begin direction instructions at
+the beginnings of lines.
 
-The |post_line_break| must also keep an dir stack, so that it can
-output end direction instructions at the ends of lines
-and begin direction instructions at the beginnings of lines.
+*/
 
-@c
-#define next_break prev_break   /*new name for |prev_break| after links are reversed */
+/*tex The new name for |prev_break| after links are reversed: */
+
+#define next_break prev_break
+
+/*tex The |int|s are actually halfwords. */
 
-/* the ints are actually halfwords */
 void ext_post_line_break(int paragraph_dir,
                          int right_skip,
                          int left_skip,
@@ -78,32 +83,39 @@ void ext_post_line_break(int paragraph_dir,
 {
 
     boolean have_directional = true;
-    halfword q, r;              /* temporary registers for list manipulation */
+    /*tex temporary registers for list manipulation */
+    halfword q, r;
     halfword k;
     scaled w;
-    boolean glue_break;         /* was a break at glue? */
-    boolean disc_break;         /*was the current break at a discretionary node? */
-    boolean post_disc_break;    /*and did it have a nonempty post-break part? */
-    scaled cur_width;           /*width of line number |cur_line| */
-    scaled cur_indent;          /*left margin of line number |cur_line| */
-    int pen;                    /*use when calculating penalties between lines */
-    halfword cur_p;             /* |cur_p|, but localized */
-    halfword cur_line;          /*the current line number being justified */
-
+     /*tex was a break at glue? */
+    boolean glue_break;
+    /*tex was the current break at a discretionary node? */
+    boolean disc_break;
+    /*tex and did it have a nonempty post-break part? */
+    boolean post_disc_break;
+    /*tex width of line number |cur_line| */
+    scaled cur_width;
+    /*tex left margin of line number |cur_line| */
+    scaled cur_indent;
+    /*tex use when calculating penalties between lines */
+    int pen;
+    /*tex |cur_p|, but localized */
+    halfword cur_p;
+    /*tex the current line number being justified */
+    halfword cur_line;
+    /*tex the current direction: */
     dir_ptr = cur_list.dirs_field;
-    /* Reverse the links of the relevant passive nodes, setting |cur_p| to
-       the first breakpoint; */
-    /* The job of reversing links in a list is conveniently regarded as the job
-       of taking items off one stack and putting them on another. In this case we
-       take them off a stack pointed to by |q| and having |prev_break| fields;
-       we put them on a stack pointed to by |cur_p| and having |next_break| fields.
-       Node |r| is the passive node being moved from stack to stack.
-     */
+    /*tex
+        Reverse the links of the relevant passive nodes, setting |cur_p| to the
+        first breakpoint. The job of reversing links in a list is conveniently
+        regarded as the job of taking items off one stack and putting them on
+        another. In this case we take them off a stack pointed to by |q| and
+        having |prev_break| fields; we put them on a stack pointed to by |cur_p|
+        and having |next_break| fields. Node |r| is the passive node being moved
+        from stack to stack.
+    */
     q = break_node(best_bet);
-#if 0
-    used_discs = used_disc(best_bet);
-#endif
-    /* |has_direction| */
+    /*tex |cur_p| will become the first breakpoint; */
     cur_p = null;
     do {
         r = q;
@@ -111,73 +123,68 @@ void ext_post_line_break(int paragraph_dir,
         next_break(r) = cur_p;
         cur_p = r;
     } while (q != null);
-    /* |cur_p| is now the first breakpoint; */
-
-    cur_line = cur_list.pg_field + 1;   /* prevgraf+1 */
-
+    /*tex prevgraf + 1 */
+    cur_line = cur_list.pg_field + 1;
     do {
-        /* Justify the line ending at breakpoint |cur_p|, and append it to the
-           current vertical list, together with associated penalties and other
-           insertions;    */
-        /* The current line to be justified appears in a horizontal list starting
-           at |vlink(temp_head)| and ending at |cur_break(cur_p)|. If |cur_break(cur_p)| is
-           a glue node, we reset the glue to equal the |right_skip| glue; otherwise
-           we append the |right_skip| glue at the right. If |cur_break(cur_p)| is a
-           discretionary node, we modify the list so that the discretionary break
-           is compulsory, and we set |disc_break| to |true|. We also append
-           the |left_skip| glue at the left of the line, unless it is zero. */
-
-#if 0
-        tprint("BEGIN OF LINE ");
-        print_int(cur_break(cur_p));
-        breadth_max = 100000;
-        depth_threshold = 100000;
-        show_node_list(temp_head);
-#endif
-
-        /* DIR: Insert dir nodes at the beginning of the current line; */
-        for (q = dir_ptr; q != null; q = vlink(q)) {
-            halfword tmp = new_dir(dir_dir(q));
-            halfword nxt = vlink(temp_head);
-            delete_attribute_ref(node_attr(tmp));
-            node_attr(tmp) = node_attr(temp_head);
-            add_node_attr_ref(node_attr(tmp));
-            couple_nodes(temp_head, tmp);
-            try_couple_nodes(tmp, nxt); /* \.{\\break}\.{\\par} */
-        }
+        /*tex
+            Justify the line ending at breakpoint |cur_p|, and append it to the
+            current vertical list, together with associated penalties and other
+            insertions.
+
+            The current line to be justified appears in a horizontal list
+            starting at |vlink(temp_head)| and ending at |cur_break(cur_p)|. If
+            |cur_break(cur_p)| is a glue node, we reset the glue to equal the
+            |right_skip| glue; otherwise we append the |right_skip| glue at the
+            right. If |cur_break(cur_p)| is a discretionary node, we modify the
+            list so that the discretionary break is compulsory, and we set
+            |disc_break| to |true|. We also append the |left_skip| glue at the
+            left of the line, unless it is zero.
+        */
         if (dir_ptr != null) {
+            /*tex Insert dir nodes at the beginning of the current line. */
+            for (q = dir_ptr; q != null; q = vlink(q)) {
+                halfword tmp = new_dir(dir_dir(q));
+                halfword nxt = vlink(temp_head);
+                delete_attribute_ref(node_attr(tmp));
+                node_attr(tmp) = node_attr(temp_head);
+                add_node_attr_ref(node_attr(tmp));
+                couple_nodes(temp_head, tmp);
+                /*tex \.{\\break}\.{\\par} */
+                try_couple_nodes(tmp, nxt);
+            }
             flush_node_list(dir_ptr);
             dir_ptr = null;
         }
+        /*tex
+            Modify the end of the line to reflect the nature of the break and to
+            include \.{\\rightskip}; also set the proper value of |disc_break|.
+            At the end of the following code, |q| will point to the final node on
+            the list about to be justified. In the meanwhile |r| will point to
+            the node we will use to insert end-of-line stuff after. |q==null|
+            means we use the final position of |r|.
+        */
 
-        /* Modify the end of the line to reflect the nature of the break and to
-           include \.{\\rightskip}; also set the proper value of |disc_break|; */
-        /* At the end of the following code, |q| will point to the final node on the
-           list about to be justified. In the meanwhile |r| will point to the
-           node we will use to insert end-of-line stuff after. |q==null| means
-           we use the final position of |r| */
-
-        /* begin mathskip code */
         if (temp_head != null) {
-                q = temp_head;
-                while(q != null) {
-                    if (type(q) == math_node) {
-                        surround(q) = 0 ;
-                        reset_glue_to_zero(q);
-                        break;
-                    } else if ((type(q) == hlist_node) && (subtype(q) == indent_list)) {
-                        /* go on */
-                    } else if (is_char_node(q)) {
-                        break;
-                    } else if (non_discardable(q)) {
-                        break;
-                    } else if (type(q) == kern_node && subtype(q) != explicit_kern && subtype(q) != italic_kern) {
-                        break;
-                    }
-                    q = vlink(q);
+            /*tex begin mathskip code */
+            q = temp_head;
+            while(q != null) {
+                if (type(q) == math_node) {
+                    surround(q) = 0 ;
+                    reset_glue_to_zero(q);
+                    break;
+                } else if ((type(q) == hlist_node) && (subtype(q) == indent_list)) {
+                    /* go on */
+                } else if (is_char_node(q)) {
+                    break;
+                } else if (non_discardable(q)) {
+                    break;
+                } else if (type(q) == kern_node && subtype(q) != explicit_kern && subtype(q) != italic_kern) {
+                    break;
                 }
+                q = vlink(q);
             }
-        /* end mathskip code */
+            /*tex end mathskip code */
+        }
 
         r = cur_break(cur_p);
         q = null;
@@ -189,27 +196,26 @@ void ext_post_line_break(int paragraph_dir,
         if (r == null) {
             for (r = temp_head; vlink(r) != null; r = vlink(r));
             if (r == final_par_glue) {
-                /* This should almost always be true... */
-                /* TODO assert ? */
+                /*tex This should almost always be true... */
                 q = r;
-                /* |q| refers to the last node of the line (and paragraph) */
+                /*tex |q| refers to the last node of the line (and paragraph) */
                 r = alink(r);
             }
-            /* |r| refers to the node after which the dir nodes should be closed */
+            /*tex |r| refers to the node after which the dir nodes should be closed */
         } else if (type(r) == math_node) {
             surround(r) = 0;
-            /* begin mathskip code */
+            /*tex begin mathskip code */
             reset_glue_to_zero(r);
-            /* end mathskip code */
+            /*tex end mathskip code */
         } else if (type(r) == glue_node) {
             copy_glue_values(r,right_skip);
             subtype(r) = right_skip_code + 1;
             glue_break = true;
-            /* |q| refers to the last node of the line */
+            /*tex |q| refers to the last node of the line */
             q = r;
             r = alink(r);
             assert(vlink(r) == q);
-            /* |r| refers to the node after which the dir nodes should be closed */
+            /*tex |r| refers to the node after which the dir nodes should be closed */
         } else if (type(r) == disc_node) {
             halfword a = alink(r);
             halfword v = vlink(r);
@@ -228,7 +234,6 @@ void ext_post_line_break(int paragraph_dir,
                     vlink_no_break(r) = null;
                     tlink_no_break(r) = null;
                 }
-
                 assert(type(a) == disc_node && subtype(a) == init_disc);
                 flush_node_list(vlink_no_break(a));
                 vlink_no_break(a) = null;
@@ -239,11 +244,10 @@ void ext_post_line_break(int paragraph_dir,
                 flush_node_list(vlink_post_break(a));
                 vlink_post_break(a) = null;
                 tlink_post_break(a) = null;
-
                 break;
             case init_disc:
                 assert(type(v) == disc_node && subtype(v) == select_disc);
-                subtype(v) = syllable_disc;     /* not special any more */
+                subtype(v) = syllable_disc;
                 flush_node_list(vlink_no_break(v));
                 vlink_no_break(v) = vlink_post_break(r);
                 tlink_no_break(v) = tlink_post_break(r);
@@ -273,27 +277,24 @@ void ext_post_line_break(int paragraph_dir,
         } else if (type(r) == kern_node) {
             width(r) = 0;
         }
-
-        /* DIR: Adjust the dir stack based on dir nodes in this line; */
-        /* TODO what about the previousparagraph ??? */
+        /*tex Adjust the dir stack based on dir nodes in this line. */
         if (have_directional) {
-            halfword e;
-            halfword p;
+            halfword e, p;
             for (e = vlink(temp_head); e != null && e != cur_break(cur_p); e = vlink(e)) {
                 if (type(e) == dir_node) {
-                    if (dir_dir(e) >= 0) {
+                    if (subtype(e) == normal_dir) {
                         dir_ptr = do_push_dir_node(dir_ptr, e);
-                    } else if (dir_ptr != null && dir_dir(dir_ptr) == (dir_dir(e) + dir_swap)) {
+                    } else if (dir_ptr != null && dir_dir(dir_ptr) == dir_dir(e)) {
                         dir_ptr = do_pop_dir_node(dir_ptr);
                     }
                 }
             }
             assert(e == cur_break(cur_p));
-
-            /* DIR: Insert dir nodes at the end of the current line; */
+            /*tex Insert dir nodes at the end of the current line. */
             e = vlink(r);
             for (p = dir_ptr; p != null; p = vlink(p)) {
-                halfword s = new_dir(dir_dir(p) - dir_swap);
+                halfword s = new_dir(dir_dir(p));
+                subtype(s) = cancel_dir;
                 delete_attribute_ref(node_attr(s));
                 node_attr(s) = node_attr(r);
                 add_node_attr_ref(node_attr(s));
@@ -303,7 +304,6 @@ void ext_post_line_break(int paragraph_dir,
             }
         }
         if (passive_right_box(cur_p) != null) {
-            /* TODO: CHECK has |s| below a |alink| ? */
             halfword s = copy_node_list(passive_right_box(cur_p));
             halfword e = vlink(r);
             couple_nodes(r, s);
@@ -313,28 +313,30 @@ void ext_post_line_break(int paragraph_dir,
         if (q == null) {
             q = r;
         }
-        /* Now [q] refers to the last node on the line */
-
-        /* FIXME from this point on we no longer keep alink() valid */
-
-        /* at this point |q| is the rightmost breakpoint; the only exception is
-           the case of a discretionary break with non-empty |pre_break|, then |q|
-           has been changed to the last node of the |pre_break| list */
-        /* If the par ends with a \break command, the last line is utterly empty.
-           That is the case of |q==temp_head| */
+        /*tex
+            Now [q] refers to the last node on the line and therefore the
+            rightmost breakpoint. The only exception is the case of a
+            discretionary break with non-empty |pre_break|, then |q| has been
+            changed to the last node of the |pre_break| list. If the par ends
+            with a \break command, the last line is utterly empty. That is the
+            case of |q==temp_head|.
+        */
         if (q != temp_head && protrude_chars > 0) {
             halfword p, ptmp;
             if (disc_break && (is_char_node(q) || (type(q) != disc_node))) {
-                p = q;          /* |q| has been reset to the last node of |pre_break| */
+                /*tex |q| is reset to the last node of |pre_break| */
+                p = q;
                 ptmp = p;
             } else {
-                p = alink(q);   /* get |vlink(p) = q| */
+                /*tex get |vlink(p) = q| */
+                p = alink(q);
                 assert(vlink(p) == q);
                 ptmp = p;
             }
             p = find_protchar_right(vlink(temp_head), p);
             w = char_pw(p, right_side);
-            if (w != 0) {       /* we have found a marginal kern, append it after |ptmp| */
+            if (w != 0) {
+                /*tex we have found a marginal kern, append it after |ptmp| */
                 k = new_margin_kern(-w, last_rightmost_char, right_side);
                 delete_attribute_ref(node_attr(k));
                 node_attr(k) = node_attr(p);
@@ -345,10 +347,12 @@ void ext_post_line_break(int paragraph_dir,
                     q = vlink(q);
             }
         }
-        /* if |q| was not a breakpoint at glue and has been reset to |rightskip|
-           then we append |rightskip| after |q| now */
+        /*tex
+            If |q| was not a breakpoint at glue and has been reset to |rightskip|
+            then we append |rightskip| after |q| now.
+        */
         if (!glue_break) {
-            /* Put the \.{\\rightskip} glue after node |q|; */
+            /*tex Put the \.{\\rightskip} glue after node |q|. */
             halfword r1 = new_glue((right_skip == null ? zero_glue : right_skip));
             subtype(r1) = right_skip_code+1;
             try_couple_nodes(r1,vlink(q));
@@ -358,21 +362,22 @@ void ext_post_line_break(int paragraph_dir,
             couple_nodes(q,r1);
             q = r1;
         }
-
-        /* /Modify the end of the line to reflect the nature of the break and to
-           include \.{\\rightskip}; also set the proper value of |disc_break|; */
-
-        /* Put the \.{\\leftskip} glue at the left and detach this line; */
-        /* The following code begins with |q| at the end of the list to be
-           justified. It ends with |q| at the beginning of that list, and with
-           |vlink(temp_head)| pointing to the remainder of the paragraph, if any. */
+        /*tex
+            Modify the end of the line to reflect the nature of the break and to
+            include \.{\\rightskip}; also set the proper value of |disc_break|;
+            Also put the \.{\\leftskip} glue at the left and detach this line.
+
+            The following code begins with |q| at the end of the list to be
+            justified. It ends with |q| at the beginning of that list, and with
+            |vlink(temp_head)| pointing to the remainder of the paragraph, if
+            any.
+        */
         r = vlink(q);
         vlink(q) = null;
 
         q = vlink(temp_head);
         try_couple_nodes(temp_head, r);
         if (passive_left_box(cur_p) != null && passive_left_box(cur_p) != 0) {
-            /* omega bits: */
             halfword s;
             r = copy_node_list(passive_left_box(cur_p));
             s = vlink(q);
@@ -388,11 +393,14 @@ void ext_post_line_break(int paragraph_dir,
                 }
             }
         }
-        /*at this point |q| is the leftmost node; all discardable nodes have been discarded */
+        /*tex
+            At this point |q| is the leftmost node; all discardable nodes have
+            been discarded
+        */
         if (protrude_chars > 0) {
             halfword p;
             p = q;
-            p = find_protchar_left(p, false);   /* no more discardables */
+            p = find_protchar_left(p, false);
             w = char_pw(p, left_side);
             if (w != 0) {
                 k = new_margin_kern(-w, last_leftmost_char, left_side);
@@ -412,13 +420,14 @@ void ext_post_line_break(int paragraph_dir,
             couple_nodes(r,q);
             q = r;
         }
-        /* /Put the \.{\\leftskip} glue at the left and detach this line; */
-
-        /* Call the packaging subroutine, setting |just_box| to the justified box; */
-        /* Now |q| points to the hlist that represents the current line of the
-           paragraph. We need to compute the appropriate line width, pack the
-           line into a box of this size, and shift the box by the appropriate
-           amount of indentation. */
+        /*tex
+            Put the \.{\\leftskip} glue at the left and detach this line. Call
+            the packaging subroutine, setting |just_box| to the justified box.
+            Now |q| points to the hlist that represents the current line of the
+            paragraph. We need to compute the appropriate line width, pack the
+            line into a box of this size, and shift the box by the appropriate
+            amount of indentation.
+        */
         if (cur_line > last_special_line) {
             cur_width = second_width;
             cur_indent = second_indent;
@@ -438,8 +447,10 @@ void ext_post_line_break(int paragraph_dir,
         }
         shift_amount(just_box) = cur_indent;
         subtype(just_box) = line_list;
-        /* /Call the packaging subroutine, setting |just_box| to the justified box; */
-
+        /*tex
+            Call the packaging subroutine, setting |just_box| to the justified
+            box.
+        */
         if ((vlink(contrib_head) != null))
             checked_break_filter(pre_box);
         if (pre_adjust_head != pre_adjust_tail) {
@@ -454,17 +465,17 @@ void ext_post_line_break(int paragraph_dir,
             checked_break_filter(adjust);
         }
         adjust_tail = null;
-
-        /* /Append the new box to the current vertical list, followed by the list of
-           special nodes taken out of the box by the packager; */
-
-        /* Append a penalty node, if a nonzero penalty is appropriate */
-        /* Penalties between the lines of a paragraph come from club and widow lines,
-           from the |inter_line_penalty| parameter, and from lines that end at
-           discretionary breaks.  Breaking between lines of a two-line paragraph gets
-           both club-line and widow-line penalties. The local variable |pen| will
-           be set to the sum of all relevant penalties for the current line, except
-           that the final line is never penalized. */
+        /*tex
+            Append the new box to the current vertical list, followed by the list
+            of special nodes taken out of the box by the packager. Append a
+            penalty node, if a nonzero penalty is appropriate. Penalties between
+            the lines of a paragraph come from club and widow lines, from the
+            |inter_line_penalty| parameter, and from lines that end at
+            discretionary breaks. Breaking between lines of a two-line paragraph
+            gets both club-line and widow-line penalties. The local variable
+            |pen| will be set to the sum of all relevant penalties for the
+            current line, except that the final line is never penalized.
+        */
         if (cur_line + 1 != best_line) {
             q = inter_line_penalties_ptr;
             if (q != null) {
@@ -481,11 +492,13 @@ void ext_post_line_break(int paragraph_dir,
             }
             q = club_penalties_ptr;
             if (q != null) {
-                r = cur_line - cur_list.pg_field;       /* prevgraf */
+                /*tex prevgraf */
+                r = cur_line - cur_list.pg_field;
                 if (r > penalty(q))
                     r = penalty(q);
                 pen += penalty(q + r);
-            } else if (cur_line == cur_list.pg_field + 1) {     /* prevgraf */
+            } else if (cur_line == cur_list.pg_field + 1) {
+                /*tex prevgraf */
                 pen += club_penalty;
             }
             q = widow_penalties_ptr;
@@ -510,34 +523,37 @@ void ext_post_line_break(int paragraph_dir,
                 cur_list.tail_field = r;
             }
         }
-        /* /Append a penalty node, if a nonzero penalty is appropriate */
-
-        /* /Justify the line ending at breakpoint |cur_p|, and append it to the
-           current vertical list, together with associated penalties and other
-           insertions;   */
+        /*tex
+            Append a penalty node, if a nonzero penalty is appropriate. Justify
+            the line ending at breakpoint |cur_p|, and append it to the current
+            vertical list, together with associated penalties and other
+            insertions.
+        */
         incr(cur_line);
         cur_p = next_break(cur_p);
         if (cur_p != null && !post_disc_break) {
-            /* Prune unwanted nodes at the beginning of the next line; */
-            /* Glue and penalty and kern and math nodes are deleted at the
-               beginning of a line, except in the anomalous case that the
-               node to be deleted is actually one of the chosen
-               breakpoints. Otherwise the pruning done here is designed to
-               match the lookahead computation in |try_break|, where the
-               |break_width| values are computed for non-discretionary
-               breakpoints. */
+            /*tex
+                Prune unwanted nodes at the beginning of the next line. Glue and
+                penalty and kern and math nodes are deleted at the beginning of a
+                line, except in the anomalous case that the node to be deleted is
+                actually one of the chosen breakpoints. Otherwise the pruning
+                done here is designed to match the lookahead computation in
+                |try_break|, where the |break_width| values are computed for
+                non-discretionary breakpoints.
+            */
             r = temp_head;
-            /*
-                Normally we have a matching math open and math close node but when we cross a line
-                the open node is removed, including any glue or penalties following it. This is however
-                not that nice for callbacks that rely on symmetry. Of course this only counts for one
-                liners, as we can still have only a begin or end node on a line. The end_of_math lua
-                helper is made robust against this although there you should be aware of the fact that
-                one can end up in the middle of math in callbacks that don't work on whole paragraphs,
-                but at least this branch makes sure that some proper analysis is possible. (todo: check
-                if math glyphs have the subtype marked done).
-
-                Todo: turn math nodes into glues when mathskip otherwise remove them.
+            /*tex
+                Normally we have a matching math open and math close node but
+                when we cross a line the open node is removed, including any glue
+                or penalties following it. This is however not that nice for
+                callbacks that rely on symmetry. Of course this only counts for
+                one liners, as we can still have only a begin or end node on a
+                line. The end_of_math lua helper is made robust against this
+                although there you should be aware of the fact that one can end
+                up in the middle of math in callbacks that don't work on whole
+                paragraphs, but at least this branch makes sure that some proper
+                analysis is possible. (todo: check if math glyphs have the
+                subtype marked done).
             */
             while (1) {
                 q = vlink(r);
@@ -550,17 +566,17 @@ void ext_post_line_break(int paragraph_dir,
                 }
                 */
                 if (type(q) == math_node) {
-                    /* begin mathskip code */
+                    /*tex begin mathskip code */
                     surround(q) = 0 ;
                     reset_glue_to_zero(q);
-                    /* end mathskip code */
+                    /*tex end mathskip code */
                 }
                 if (q == cur_break(cur_p)) {
                     break;
                 } else if (is_char_node(q)) {
                     break;
                 } else if (type(q) == local_par_node) {
-                    /* weird, in the middle somewhere */
+                    /*tex weird, in the middle somewhere */
                 } else if (non_discardable(q)) {
                     break;
                 } else if (type(q) == kern_node && subtype(q) != explicit_kern && subtype(q) != italic_kern) {
@@ -577,7 +593,9 @@ void ext_post_line_break(int paragraph_dir,
     } while (cur_p != null);
     if ((cur_line != best_line) || (vlink(temp_head) != null))
         confusion("line breaking");
-    cur_list.pg_field = best_line - 1;  /* prevgraf */
-    cur_list.dirs_field = dir_ptr;      /* |dir_save| */
+    /*tex prevgraf */
+    cur_list.pg_field = best_line - 1;
+    /*tex |dir_save| */
+    cur_list.dirs_field = dir_ptr;
     dir_ptr = null;
 }
diff --git a/texk/web2c/luatexdir/tex/primitive.c b/texk/web2c/luatexdir/tex/primitive.c
new file mode 100644
index 000000000..f16d69a33
--- /dev/null
+++ b/texk/web2c/luatexdir/tex/primitive.c
@@ -0,0 +1,785 @@
+/*
+
+primitive.w
+
+Copyright 2008-2010 Taco Hoekwater <taco@@luatex.org>
+
+This file is part of LuaTeX.
+
+LuaTeX is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 2 of the License, or (at your
+option) any later version.
+
+LuaTeX is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+License for more details.
+
+You should have received a copy of the GNU General Public License along
+with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#include "ptexlib.h"
+
+/*tex
+
+Control sequences are stored and retrieved by means of a fairly standard hash
+table algorithm called the method of ``coalescing lists'' (cf.\ Algorithm 6.4C in
+{\sl The Art of Computer Programming\/}). Once a control sequence enters the
+table, it is never removed, because there are complicated situations involving
+\.{\\gdef} where the removal of a control sequence at the end of a group would be
+a mistake preventable only by the introduction of a complicated reference-count
+mechanism.
+
+The actual sequence of letters forming a control sequence identifier is stored in
+the |str_pool| array together with all the other strings. An auxiliary array
+|hash| consists of items with two halfword fields per word. The first of these,
+called |next(p)|, points to the next identifier belonging to the same coalesced
+list as the identifier corresponding to~|p|; and the other, called |text(p)|,
+points to the |str_start| entry for |p|'s identifier. If position~|p| of the hash
+table is empty, we have |text(p)=0|; if position |p| is either empty or the end
+of a coalesced hash list, we have |next(p)=0|. An auxiliary pointer variable
+called |hash_used| is maintained in such a way that all locations |p>=hash_used|
+are nonempty. The global variable |cs_count| tells how many multiletter control
+sequences have been defined, if statistics are being kept.
+
+A global boolean variable called |no_new_control_sequence| is set to |true|
+during the time that new hash table entries are forbidden.
+
+*/
+
+/*tex The hash table: */
+
+two_halves *hash;
+
+/*tex Allocation pointer for |hash|: */
+
+halfword hash_used;
+
+/*tex |hash_extra=hash| above |eqtb_size|: */
+
+int hash_extra;
+
+/*tex Maximum of the hash array: */
+
+halfword hash_top;
+
+/*tex Pointer to next high hash location: */
+
+halfword hash_high;
+
+/*tex Are new identifiers legal? */
+
+boolean no_new_control_sequence;
+
+/*tex Total number of known identifiers: */
+
+int cs_count;
+
+/*tex Test if all positions are occupied: */
+
+#define hash_is_full (hash_used==hash_base)
+
+/*tex
+
+    \.{\\primitive} support needs a few extra variables and definitions,
+    like:
+
+*/
+
+#define prim_base 1
+
+/*tex
+
+The arrays |prim| and |prim_eqtb| are used for name -> cmd,chr lookups. The are
+modelled after |hash| and |eqtb|, except that primitives do not have an
+|eq_level|, that field is replaced by |origin|.
+
+*/
+
+/*tex Link for coalesced lists: */
+
+#define prim_next(a) prim[(a)].lhfield
+
+/*tex String number for control sequence name: */
+
+#define prim_text(a) prim[(a)].rh
+
+/*tex Test if all positions are occupied: */
+
+#define prim_is_full (prim_used==prim_base)
+
+#define prim_origin_field(a) (a).hh.b1
+
+#define prim_eq_type_field(a)  (a).hh.b0
+
+#define prim_equiv_field(a) (a).hh.rh
+
+/*tex Level of definition: */
+
+#define prim_origin(a) prim_origin_field(prim_eqtb[(a)])
+
+/*tex Command code for equivalent: */
+
+#define prim_eq_type(a) prim_eq_type_field(prim_eqtb[(a)])
+
+/*tex Equivalent value: */
+
+#define prim_equiv(a) prim_equiv_field(prim_eqtb[(a)])
+
+/*tex Allocation pointer for |prim|: */
+
+static pointer prim_used;
+
+/*tex The primitives table: */
+
+static two_halves prim[(prim_size + 1)];
+
+static memory_word prim_eqtb[(prim_size + 1)];
+
+/*tex
+
+The array |prim_data| works the other way around, it is used for cmd,chr -> name
+lookups.
+
+*/
+
+typedef struct prim_info {
+    /*tex Number of name entries: */
+    halfword subids;
+    /*tex Offset to be used for |chr_code|s: */
+    halfword offset;
+    /*tex Array of names: */
+    str_number *names;
+} prim_info;
+
+static prim_info prim_data[(last_cmd + 1)];
+
+/*tex
+
+Initialize the memory arrays:
+
+*/
+
+void init_primitives(void)
+{
+    int k;
+    memset(prim_data, 0, (sizeof(prim_info) * (last_cmd + 1)));
+    memset(prim, 0, (sizeof(two_halves) * (prim_size + 1)));
+    memset(prim_eqtb, 0, (sizeof(memory_word) * (prim_size + 1)));
+    for (k = 0; k <= prim_size; k++) {
+        prim_eq_type(k) = undefined_cs_cmd;
+    }
+}
+
+/*tex Nothing is used (yet). */
+
+void ini_init_primitives(void)
+{
+    prim_used = prim_size;
+}
+
+
+/*tex
+
+The value of |hash_prime| should be roughly 85\%! of |hash_size|, and it should
+be a prime number. The theory of hashing tells us to expect fewer than two table
+probes, on the average, when the search is successful. [See J.~S. Vitter, {\sl
+Journal of the ACM\/ \bf30} (1983), 231--258.] @^Vitter, Jeffrey Scott@>
+
+*/
+
+static halfword compute_hash(const char *j, unsigned int l, halfword prime_number)
+{
+    int k;
+    halfword h = (unsigned char) *j;
+    for (k = 1; k <= (int)(l - 1); k++) {
+        h = h + h + (unsigned char) *(j + k);
+        while (h >= prime_number) {
+            h = h - prime_number;
+        }
+    }
+    return h;
+}
+
+/*tex
+
+Here is the subroutine that searches the primitive table for an identifier.
+
+*/
+
+pointer prim_lookup(str_number s)
+{
+    /*tex The hash code: */
+    int h;
+    /*tex The index in the |hash| array: */
+    pointer p;
+    unsigned char *j;
+    unsigned l;
+    if (s < STRING_OFFSET) {
+        p = s;
+        if ((p < 0) || (get_prim_eq_type(p) == undefined_cs_cmd)) {
+            p = undefined_primitive;
+        }
+    } else {
+        j = str_string(s);
+        l = (unsigned) str_length(s);
+        h = compute_hash((char *) j, l, prim_prime);
+        /*tex We start searching here; note that |0<=h<hash_prime|. */
+        p = h + prim_base;
+        while (1) {
+            if (prim_text(p) > 0)
+                if (str_length(prim_text(p)) == l)
+                    if (str_eq_str(prim_text(p), s))
+                        goto FOUND;
+            if (prim_next(p) == 0) {
+                if (no_new_control_sequence) {
+                    p = undefined_primitive;
+                } else {
+                    /*tex Insert a new primitive after |p|, then make |p| point to it. */
+                    if (prim_text(p) > 0) {
+                        do {
+                            /*tex Search for an empty location in |prim| */
+                            if (prim_is_full) {
+                                overflow("primitive size", prim_size);
+                            }
+                            decr(prim_used);
+                        } while (prim_text(prim_used) != 0);
+                        prim_next(p) = prim_used;
+                        p = prim_used;
+                    }
+                    prim_text(p) = s;
+                }
+                goto FOUND;
+            }
+            p = prim_next(p);
+        }
+    }
+  FOUND:
+    return p;
+}
+
+/*tex
+
+How to test a csname for primitive-ness?
+
+*/
+
+boolean is_primitive(str_number csname)
+{
+    int n, m;
+    char *ss;
+    m = prim_lookup(csname);
+    ss = makecstring(csname);
+    n = string_lookup(ss, str_length(csname));
+    free(ss);
+    return ((n != undefined_cs_cmd) && (m != undefined_primitive) &&
+        (eq_type(n) == prim_eq_type(m)) && (equiv(n) == prim_equiv(m)));
+}
+
+
+/*tex
+
+A few simple accessors.
+
+*/
+
+quarterword get_prim_eq_type(int p)
+{
+    return prim_eq_type(p);
+}
+
+quarterword get_prim_origin(int p)
+{
+    return prim_origin(p);
+}
+
+halfword get_prim_equiv(int p)
+{
+    return prim_equiv(p);
+}
+
+str_number get_prim_text(int p)
+{
+    return prim_text(p);
+}
+
+
+/*tex
+
+Dumping and undumping.
+
+*/
+
+void dump_primitives(void)
+{
+    int p, q;
+    for (p = 0; p <= prim_size; p++) {
+        dump_hh(prim[p]);
+    }
+    for (p = 0; p <= prim_size; p++) {
+        dump_wd(prim_eqtb[p]);
+    }
+    for (p = 0; p <= last_cmd; p++) {
+        dump_int(prim_data[p].offset);
+        dump_int(prim_data[p].subids);
+        for (q = 0; q < prim_data[p].subids; q++) {
+            dump_int(prim_data[p].names[q]);
+        }
+    }
+}
+
+void undump_primitives(void)
+{
+    int p, q;
+    for (p = 0; p <= prim_size; p++) {
+        undump_hh(prim[p]);
+    }
+    for (p = 0; p <= prim_size; p++) {
+        undump_wd(prim_eqtb[p]);
+    }
+    for (p = 0; p <= last_cmd; p++) {
+        undump_int(prim_data[p].offset);
+        undump_int(prim_data[p].subids);
+        if (prim_data[p].subids > 0) {
+            prim_data[p].names = (str_number *) xmalloc((unsigned) ((unsigned) prim_data[p].subids * sizeof(str_number *)));
+            for (q = 0; q < prim_data[p].subids; q++) {
+                undump_int(prim_data[p].names[q]);
+            }
+        }
+    }
+}
+
+/*tex
+
+We need to put \TeX's ``primitive'' control sequences into the hash table,
+together with their command code (which will be the |eq_type|) and an operand
+(which will be the |equiv|). The |primitive| procedure does this, in a way that
+no \TeX\ user can. The global value |cur_val| contains the new |eqtb| pointer
+after |primitive| has acted.
+
+Because the definitions of the actual user-accessible name of a primitive can be
+postponed until runtime, the function |primitive_def| is needed that does nothing
+except creating the control sequence name.
+
+*/
+
+void primitive_def(const char *s, size_t l, quarterword c, halfword o)
+{
+    int nncs = no_new_control_sequence;
+    no_new_control_sequence = false;
+    /*tex This creates the |text()| string: */
+    cur_val = string_lookup(s, l);
+    no_new_control_sequence = nncs;
+    eq_level(cur_val) = level_one;
+    eq_type(cur_val) = c;
+    equiv(cur_val) = o;
+}
+
+/*tex
+
+The function |store_primitive_name| sets up the bookkeeping for the reverse
+lookup. It is quite paranoid, because it is easy to mess this up accidentally.
+
+The |offset| is needed because sometimes character codes (in |o|) are indices
+into |eqtb| or are offset by a magical value to make sure they do not conflict
+with something else. We don't want the |prim_data[c].names| to have too many
+entries as it will just be wasted room, so |offset| is substracted from |o|
+because creating or accessing the array. The |assert(idx<=0xFFFF)| is not
+strictly needed, but it helps catch errors of this kind.
+
+*/
+
+static void store_primitive_name(str_number s, quarterword c, halfword o, halfword offset)
+{
+    int idx;
+    /*
+    if (prim_data[c].offset != 0 && prim_data[c].offset != offset) {
+        assert(false);
+    }
+    */
+    prim_data[c].offset = offset;
+    idx = ((int) o - offset);
+    /*
+    assert(idx >= 0);
+    assert(idx <= 0xFFFF);
+    */
+    if (prim_data[c].subids < (idx + 1)) {
+        str_number *new = (str_number *) xcalloc((unsigned) (idx + 1), sizeof(str_number *));
+        if (prim_data[c].names != NULL) {
+            /*
+            assert(prim_data[c].subids);
+            */
+            memcpy(new, (prim_data[c].names), (unsigned) (prim_data[c].subids) * sizeof(str_number));
+            free(prim_data[c].names);
+        }
+        prim_data[c].names = new;
+        prim_data[c].subids = idx + 1;
+    }
+    prim_data[c].names[idx] = s;
+}
+
+/*tex
+
+Compared to tex82, |primitive| has two extra parameters. The |off| is an offset
+that will be passed on to |store_primitive_name|, the |cmd_origin| is the bit
+that is used to group primitives by originator.
+
+*/
+
+void primitive(const char *thes, quarterword c, halfword o, halfword off, int cmd_origin)
+{
+    /*tex Needed to fill |prim_eqtb|: */
+    int prim_val;
+    str_number ss;
+    ss = maketexstring(thes);
+    if (cmd_origin == tex_command || cmd_origin == core_command) {
+        primitive_def(thes, strlen(thes), c, o);
+    }
+    prim_val = prim_lookup(ss);
+    prim_origin(prim_val) = (quarterword) cmd_origin;
+    prim_eq_type(prim_val) = c;
+    prim_equiv(prim_val) = o;
+    store_primitive_name(ss, c, o, off);
+}
+
+/*tex
+
+Here is a helper that does the actual hash insertion. This code far from ideal:
+the existance of |hash_extra| changes all the potential (short) coalesced lists
+into a single (long) one. This will create a slowdown.
+
+*/
+
+static halfword insert_id(halfword p, const unsigned char *j, unsigned int l)
+{
+    unsigned saved_cur_length;
+    unsigned saved_cur_string_size;
+    unsigned char *saved_cur_string;
+    const unsigned char *k;
+    if (cs_text(p) > 0) {
+        if (hash_high < hash_extra) {
+            incr(hash_high);
+            /*tex
+                Can't we use |eqtb_top| here (perhaps because that is not
+                finalized yet when called from |primitive|?
+            */
+            cs_next(p) = hash_high + eqtb_size;
+            p = cs_next(p);
+        } else {
+            /*tex
+                Search for an empty location in |hash|.
+            */
+            do {
+                if (hash_is_full)
+                    overflow("hash size", (unsigned) (hash_size + hash_extra));
+                decr(hash_used);
+            } while (cs_text(hash_used) != 0);
+            cs_next(p) = hash_used;
+            p = hash_used;
+        }
+    }
+    saved_cur_length = cur_length;
+    saved_cur_string = cur_string;
+    saved_cur_string_size = cur_string_size;
+    reset_cur_string();
+    for (k = j; k <= j + l - 1; k++) {
+        append_char(*k);
+    }
+    cs_text(p) = make_string();
+    cur_length = saved_cur_length;
+    xfree(cur_string);
+    cur_string = saved_cur_string;
+    cur_string_size = saved_cur_string_size;
+    incr(cs_count);
+    return p;
+}
+
+
+/*tex
+
+Here is the subroutine that searches the hash table for an identifier that
+matches a given string of length |l>1| appearing in |buffer[j.. (j+l-1)]|. If the
+identifier is found, the corresponding hash table address is returned. Otherwise,
+if the global variable |no_new_control_sequence| is |true|, the dummy address
+|undefined_control_sequence| is returned. Otherwise the identifier is inserted
+into the hash table and its location is returned.
+
+*/
+
+pointer id_lookup(int j, int l)
+{
+    /*tex The hash code: */
+    int h;
+    /*tex The index in |hash| array: */
+    pointer p;
+    h = compute_hash((char *) (buffer + j), (unsigned) l, hash_prime);
+    /*tex We start searching here. Note that |0<=h<hash_prime|: */
+    p = h + hash_base;
+    while (1) {
+        if (cs_text(p) > 0)
+            if (str_length(cs_text(p)) == (unsigned) l)
+                if (str_eq_buf(cs_text(p), j))
+                    goto FOUND;
+        if (cs_next(p) == 0) {
+            if (no_new_control_sequence) {
+                p = undefined_control_sequence;
+            } else {
+                p = insert_id(p, (buffer + j), (unsigned) l);
+            }
+            goto FOUND;
+        }
+        p = cs_next(p);
+    }
+  FOUND:
+    return p;
+}
+
+/*tex
+
+Here is a similar subroutine for finding a primitive in the hash.
+This one is based on a C string.
+
+*/
+
+pointer string_lookup(const char *s, size_t l)
+{
+    /*tex The hash code: */
+    int h;
+    /*tex The index in |hash| array: */
+    pointer p;
+    h = compute_hash(s, (unsigned) l, hash_prime);
+    /*tex We start searching here. Note that |0<=h<hash_prime|: */
+    p = h + hash_base;
+    while (1) {
+        if (cs_text(p) > 0)
+            if (str_eq_cstr(cs_text(p), s, l))
+                goto FOUND;
+        if (cs_next(p) == 0) {
+            if (no_new_control_sequence) {
+                p = undefined_control_sequence;
+            } else {
+                p = insert_id(p, (const unsigned char *) s, (unsigned) l);
+            }
+            goto FOUND;
+        }
+        p = cs_next(p);
+    }
+  FOUND:
+    return p;
+}
+
+/*tex
+
+The |print_cmd_chr| routine prints a symbolic interpretation of a command code
+and its modifier. This is used in certain `\.{You can\'t}' error messages, and in
+the implementation of diagnostic routines like \.{\\show}.
+
+The body of |print_cmd_chr| use to be a rather tedious listing of print commands,
+and most of it was essentially an inverse to the |primitive| routine that enters
+a \TeX\ primitive into |eqtb|.
+
+Thanks to |prim_data|, there is no need for all that tediousness. What is left of
+|primt_cnd_chr| are just the exceptions to the general rule that the
+|cmd,chr_code| pair represents in a single primitive command.
+
+*/
+
+#define chr_cmd(A) do { tprint(A); print(chr_code); } while (0)
+
+static void prim_cmd_chr(quarterword cmd, halfword chr_code)
+{
+    int idx = chr_code - prim_data[cmd].offset;
+    if (cmd <= last_cmd &&
+        idx >= 0 && idx < prim_data[cmd].subids &&
+        prim_data[cmd].names != NULL && prim_data[cmd].names[idx] != 0) {
+        tprint_esc("");
+        print(prim_data[cmd].names[idx]);
+    } else {
+        /* \TEX82 didn't print the |cmd,idx| information, but it may be useful. */
+        tprint("[unknown command code! (");
+        print_int(cmd);
+        tprint(", ");
+        print_int(idx);
+        tprint(")]");
+    }
+}
+
+void print_cmd_chr(quarterword cmd, halfword chr_code)
+{
+    int n;
+    switch (cmd) {
+        case left_brace_cmd:
+            chr_cmd("begin-group character ");
+            break;
+        case right_brace_cmd:
+            chr_cmd("end-group character ");
+            break;
+        case math_shift_cmd:
+            chr_cmd("math shift character ");
+            break;
+        case mac_param_cmd:
+            if (chr_code == tab_mark_cmd_code)
+                tprint_esc("alignmark");
+            else
+                chr_cmd("macro parameter character ");
+            break;
+        case sup_mark_cmd:
+            chr_cmd("superscript character ");
+            break;
+        case sub_mark_cmd:
+            chr_cmd("subscript character ");
+            break;
+        case endv_cmd:
+            tprint("end of alignment template");
+            break;
+        case spacer_cmd:
+            chr_cmd("blank space ");
+            break;
+        case letter_cmd:
+            chr_cmd("the letter ");
+            break;
+        case other_char_cmd:
+            chr_cmd("the character ");
+            break;
+        case tab_mark_cmd:
+            if (chr_code == span_code)
+                tprint_esc("span");
+            else if (chr_code == tab_mark_cmd_code)
+                tprint_esc("aligntab");
+            else
+                chr_cmd("alignment tab character ");
+            break;
+        case if_test_cmd:
+            if (chr_code >= unless_code)
+                tprint_esc("unless");
+            prim_cmd_chr(cmd, (chr_code % unless_code));
+            break;
+        case char_given_cmd:
+            tprint_esc("char");
+            print_qhex(chr_code);
+            break;
+        case math_given_cmd:
+            /*tex
+                Okay, it's better for old macro packages that mess with meaning
+                to report a traditional value. A compromise.
+            */
+            tprint_esc("mathchar");
+            show_mathcode_value_old(chr_code);
+            break;
+        case xmath_given_cmd:
+            tprint_esc("Umathchar");
+            show_mathcode_value(mathchar_from_integer(chr_code, umath_mathcode));
+            break;
+        case lua_expandable_call_cmd:
+            tprint("expandable luacall ");
+            print_int(chr_code);
+            break;
+        case lua_local_call_cmd:
+            tprint("local luacall ");
+            print_int(chr_code);
+            break;
+        case lua_call_cmd:
+            tprint("luacall ");
+            print_int(chr_code);
+            break;
+        case set_font_cmd:
+            tprint("select font ");
+            tprint(font_name(chr_code));
+            if (font_size(chr_code) != font_dsize(chr_code)) {
+                tprint(" at ");
+                print_scaled(font_size(chr_code));
+                tprint("pt");
+            }
+            break;
+        case undefined_cs_cmd:
+            tprint("undefined");
+            break;
+        case call_cmd:
+        case long_call_cmd:
+        case outer_call_cmd:
+        case long_outer_call_cmd:
+            n = cmd - call_cmd;
+            if (token_info(token_link(chr_code)) == protected_token)
+                n = n + 4;
+            if (odd(n / 4))
+                tprint_esc("protected");
+            if (odd(n))
+                tprint_esc("long");
+            if (odd(n / 2))
+                tprint_esc("outer");
+            if (n > 0)
+                tprint(" ");
+            tprint("macro");
+            break;
+        case assign_glue_cmd:
+        case assign_mu_glue_cmd:
+            if (chr_code < skip_base) {
+                prim_cmd_chr(cmd, chr_code);
+            } else if (chr_code < mu_skip_base) {
+                tprint_esc("skip");
+                print_int(chr_code - skip_base);
+            } else {
+                tprint_esc("muskip");
+                print_int(chr_code - mu_skip_base);
+            }
+            break;
+        case assign_toks_cmd:
+            if (chr_code >= toks_base) {
+                tprint_esc("toks");
+                print_int(chr_code - toks_base);
+            } else {
+                prim_cmd_chr(cmd, chr_code);
+            }
+            break;
+        case assign_int_cmd:
+            if (chr_code < count_base) {
+                prim_cmd_chr(cmd, chr_code);
+            } else {
+                tprint_esc("count");
+                print_int(chr_code - count_base);
+            }
+            break;
+        case assign_attr_cmd:
+            tprint_esc("attribute");
+            print_int(chr_code - attribute_base);
+            break;
+        case assign_dimen_cmd:
+            if (chr_code < scaled_base) {
+                prim_cmd_chr(cmd, chr_code);
+            } else {
+                tprint_esc("dimen");
+                print_int(chr_code - scaled_base);
+            }
+            break;
+        case normal_cmd:
+            if (chr_code < prim_data[cmd].subids && prim_data[cmd].names[chr_code] != 0) {
+                prim_cmd_chr(cmd, chr_code);
+            } else {
+                tprint("[unknown command! (");
+                print_int(chr_code);
+                tprint(")]");
+            }
+            break;
+        case extension_cmd:
+            if (chr_code < prim_data[cmd].subids && prim_data[cmd].names[chr_code] != 0) {
+                prim_cmd_chr(cmd, chr_code);
+            } else {
+                tprint("[unknown extension! (");
+                print_int(chr_code);
+                tprint(")]");
+
+            }
+            break;
+        case node_cmd:
+            tprint("node ");
+            print_int(chr_code);
+            break;
+        default:
+            /*tex These are most commands, actually. */
+            prim_cmd_chr(cmd, chr_code);
+            break;
+    }
+}
diff --git a/texk/web2c/luatexdir/tex/primitive.w b/texk/web2c/luatexdir/tex/primitive.w
deleted file mode 100644
index 8c6592c9e..000000000
--- a/texk/web2c/luatexdir/tex/primitive.w
+++ /dev/null
@@ -1,664 +0,0 @@
-% primitive.w
-%
-% Copyright 2008-2010 Taco Hoekwater <taco@@luatex.org>
-%
-% This file is part of LuaTeX.
-%
-% LuaTeX is free software; you can redistribute it and/or modify it under
-% the terms of the GNU General Public License as published by the Free
-% Software Foundation; either version 2 of the License, or (at your
-% option) any later version.
-%
-% LuaTeX is distributed in the hope that it will be useful, but WITHOUT
-% ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-% FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
-% License for more details.
-%
-% You should have received a copy of the GNU General Public License along
-% with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
-
-@ @c
-
-
-#include "ptexlib.h"
-
-@ Control sequences are stored and retrieved by means of a fairly standard hash
-table algorithm called the method of ``coalescing lists'' (cf.\ Algorithm 6.4C
-in {\sl The Art of Computer Programming\/}). Once a control sequence enters the
-table, it is never removed, because there are complicated situations
-involving \.{\\gdef} where the removal of a control sequence at the end of
-a group would be a mistake preventable only by the introduction of a
-complicated reference-count mechanism.
-
-The actual sequence of letters forming a control sequence identifier is
-stored in the |str_pool| array together with all the other strings. An
-auxiliary array |hash| consists of items with two halfword fields per
-word. The first of these, called |next(p)|, points to the next identifier
-belonging to the same coalesced list as the identifier corresponding to~|p|;
-and the other, called |text(p)|, points to the |str_start| entry for
-|p|'s identifier. If position~|p| of the hash table is empty, we have
-|text(p)=0|; if position |p| is either empty or the end of a coalesced
-hash list, we have |next(p)=0|. An auxiliary pointer variable called
-|hash_used| is maintained in such a way that all locations |p>=hash_used|
-are nonempty. The global variable |cs_count| tells how many multiletter
-control sequences have been defined, if statistics are being kept.
-
-A global boolean variable called |no_new_control_sequence| is set to
-|true| during the time that new hash table entries are forbidden.
-
-@c
-two_halves *hash;               /* the hash table */
-halfword hash_used;             /* allocation pointer for |hash| */
-int hash_extra;                 /* |hash_extra=hash| above |eqtb_size| */
-halfword hash_top;              /* maximum of the hash array */
-halfword hash_high;             /* pointer to next high hash location */
-boolean no_new_control_sequence;        /* are new identifiers legal? */
-int cs_count;                   /* total number of known identifiers */
-
-#define hash_is_full (hash_used==hash_base)     /* test if all positions are occupied */
-
-@ \.{\\primitive} support needs a few extra variables and definitions
-
-@c
-#define prim_base 1
-
-@ The arrays |prim| and |prim_eqtb| are used for name -> cmd,chr lookups.
-
- The are  modelled after |hash| and |eqtb|, except that primitives do not
-  have an |eq_level|, that field is replaced by |origin|.
-
-@c
-#define prim_next(a) prim[(a)].lhfield  /* link for coalesced lists */
-#define prim_text(a) prim[(a)].rh       /* string number for control sequence name */
-#define prim_is_full (prim_used==prim_base)     /* test if all positions are occupied */
-
-#define prim_origin_field(a) (a).hh.b1
-#define prim_eq_type_field(a)  (a).hh.b0
-#define prim_equiv_field(a) (a).hh.rh
-#define prim_origin(a) prim_origin_field(prim_eqtb[(a)])        /* level of definition */
-#define prim_eq_type(a) prim_eq_type_field(prim_eqtb[(a)])      /* command code for equivalent */
-#define prim_equiv(a) prim_equiv_field(prim_eqtb[(a)])  /* equivalent value */
-
-static pointer prim_used;       /* allocation pointer for |prim| */
-static two_halves prim[(prim_size + 1)];        /* the primitives table */
-static memory_word prim_eqtb[(prim_size + 1)];
-
-@ The array |prim_data| works the other way around, it is used for
-   cmd,chr -> name lookups.
-
-@c
-typedef struct prim_info {
-    halfword subids;            /* number of name entries */
-    halfword offset;            /* offset to be used for |chr_code|s */
-    str_number *names;          /* array of names */
-} prim_info;
-
-static prim_info prim_data[(last_cmd + 1)];
-
-@ initialize the memory arrays
-@c
-void init_primitives(void)
-{
-    int k;
-    memset(prim_data, 0, (sizeof(prim_info) * (last_cmd + 1)));
-    memset(prim, 0, (sizeof(two_halves) * (prim_size + 1)));
-    memset(prim_eqtb, 0, (sizeof(memory_word) * (prim_size + 1)));
-    for (k = 0; k <= prim_size; k++)
-        prim_eq_type(k) = undefined_cs_cmd;
-}
-
-void ini_init_primitives(void)
-{
-    prim_used = prim_size;      /* nothing is used */
-}
-
-
-@ The value of |hash_prime| should be roughly 85\%! of |hash_size|, and it
-   should be a prime number.  The theory of hashing tells us to expect fewer
-   than two table probes, on the average, when the search is successful.
-   [See J.~S. Vitter, {\sl Journal of the ACM\/ \bf30} (1983), 231--258.]
-   @^Vitter, Jeffrey Scott@>
-
-@c
-static halfword compute_hash(const char *j, unsigned int l,
-                             halfword prime_number)
-{
-    int k;
-    halfword h = (unsigned char) *j;
-    for (k = 1; k <= (int)(l - 1); k++) {
-        h = h + h + (unsigned char) *(j + k);
-        while (h >= prime_number)
-            h = h - prime_number;
-    }
-    return h;
-}
-
-
-@ Here is the subroutine that searches the primitive table for an identifier
-@c
-pointer prim_lookup(str_number s)
-{
-    int h;                      /* hash code */
-    pointer p;                  /* index in |hash| array */
-    unsigned char *j;
-    unsigned l;
-    if (s < STRING_OFFSET) {
-        p = s;
-        if ((p < 0) || (get_prim_eq_type(p) == undefined_cs_cmd)) {
-            p = undefined_primitive;
-        }
-    } else {
-        j = str_string(s);
-        l = (unsigned) str_length(s);
-        h = compute_hash((char *) j, l, prim_prime);
-        p = h + prim_base;      /* we start searching here; note that |0<=h<hash_prime| */
-        while (1) {
-            if (prim_text(p) > 0)
-                if (str_length(prim_text(p)) == l)
-                    if (str_eq_str(prim_text(p), s))
-                        goto FOUND;
-            if (prim_next(p) == 0) {
-                if (no_new_control_sequence) {
-                    p = undefined_primitive;
-                } else {
-                    /* Insert a new primitive after |p|, then make |p| point to it */
-                    if (prim_text(p) > 0) {
-                        do {    /* search for an empty location in |prim| */
-                            if (prim_is_full)
-                                overflow("primitive size", prim_size);
-                            decr(prim_used);
-                        } while (prim_text(prim_used) != 0);
-                        prim_next(p) = prim_used;
-                        p = prim_used;
-                    }
-                    prim_text(p) = s;
-                }
-                goto FOUND;
-            }
-            p = prim_next(p);
-        }
-    }
-  FOUND:
-    return p;
-}
-
-@ how to test a csname for primitive-ness
-@c
-boolean is_primitive(str_number csname)
-{
-    int n, m;
-    char *ss;
-    m = prim_lookup(csname);
-    ss = makecstring(csname);
-    n = string_lookup(ss, str_length(csname));
-    free(ss);
-    return ((n != undefined_cs_cmd) &&
-            (m != undefined_primitive) &&
-            (eq_type(n) == prim_eq_type(m)) && (equiv(n) == prim_equiv(m)));
-}
-
-
-@ a few simple accessors
-@c
-quarterword get_prim_eq_type(int p)
-{
-    return prim_eq_type(p);
-}
-
-quarterword get_prim_origin(int p)
-{
-    return prim_origin(p);
-}
-
-halfword get_prim_equiv(int p)
-{
-    return prim_equiv(p);
-}
-
-str_number get_prim_text(int p)
-{
-    return prim_text(p);
-}
-
-
-@ dumping and undumping
-@c
-void dump_primitives(void)
-{
-    int p, q;
-    for (p = 0; p <= prim_size; p++)
-        dump_hh(prim[p]);
-    for (p = 0; p <= prim_size; p++)
-        dump_wd(prim_eqtb[p]);
-    for (p = 0; p <= last_cmd; p++) {
-        dump_int(prim_data[p].offset);
-        dump_int(prim_data[p].subids);
-        for (q = 0; q < prim_data[p].subids; q++) {
-            dump_int(prim_data[p].names[q]);
-        }
-    }
-}
-
-void undump_primitives(void)
-{
-    int p, q;
-    for (p = 0; p <= prim_size; p++)
-        undump_hh(prim[p]);
-    for (p = 0; p <= prim_size; p++)
-        undump_wd(prim_eqtb[p]);
-
-    for (p = 0; p <= last_cmd; p++) {
-        undump_int(prim_data[p].offset);
-        undump_int(prim_data[p].subids);
-        if (prim_data[p].subids > 0) {
-            prim_data[p].names = (str_number *)
-                xmalloc((unsigned)
-                        ((unsigned) prim_data[p].subids *
-                         sizeof(str_number *)));
-            for (q = 0; q < prim_data[p].subids; q++)
-                undump_int(prim_data[p].names[q]);
-        }
-    }
-}
-
-@   We need to put \TeX's ``primitive'' control sequences into the hash
-   table, together with their command code (which will be the |eq_type|)
-   and an operand (which will be the |equiv|). The |primitive| procedure
-   does this, in a way that no \TeX\ user can. The global value |cur_val|
-   contains the new |eqtb| pointer after |primitive| has acted.
-
-
-@  Because the definitions of the actual user-accessible name of a
-   primitive can be postponed until runtime, the function |primitive_def|
-   is needed that does nothing except creating the control sequence name.
-
-@c
-void primitive_def(const char *s, size_t l, quarterword c, halfword o)
-{
-    int nncs = no_new_control_sequence;
-    no_new_control_sequence = false;
-    cur_val = string_lookup(s, l);      /* this creates the |text()| string */
-    no_new_control_sequence = nncs;
-    eq_level(cur_val) = level_one;
-    eq_type(cur_val) = c;
-    equiv(cur_val) = o;
-}
-
-@ The function |store_primitive_name| sets up the bookkeeping for the
-   reverse lookup. It is quite paranoid, because it is easy to mess this up
-   accidentally.
-
-   The |offset| is needed because sometimes character codes (in |o|)
-   are indices into |eqtb| or are offset by a magical value to make
-   sure they do not conflict with something else. We don't want the
-   |prim_data[c].names| to have too many entries as it will just be
-   wasted room, so |offset| is substracted from |o| because creating
-   or accessing the array. The |assert(idx<=0xFFFF)| is not strictly
-   needed, but it helps catch errors of this kind.
-
-@c
-static void
-store_primitive_name(str_number s, quarterword c, halfword o, halfword offset)
-{
-    int idx;
-    if (prim_data[c].offset != 0 && prim_data[c].offset != offset) {
-        assert(false);
-    }
-    prim_data[c].offset = offset;
-    idx = ((int) o - offset);
-    assert(idx >= 0);
-    assert(idx <= 0xFFFF);
-    if (prim_data[c].subids < (idx + 1)) {
-        str_number *new =
-            (str_number *) xcalloc((unsigned) (idx + 1), sizeof(str_number *));
-        if (prim_data[c].names != NULL) {
-            assert(prim_data[c].subids);
-            memcpy(new, (prim_data[c].names),
-                   (unsigned) (prim_data[c].subids) * sizeof(str_number));
-            free(prim_data[c].names);
-        }
-        prim_data[c].names = new;
-        prim_data[c].subids = idx + 1;
-    }
-    prim_data[c].names[idx] = s;
-}
-
-@ Compared to tex82, |primitive| has two extra parameters. The |off| is an offset
-   that will be passed on to |store_primitive_name|, the |cmd_origin| is the bit
-   that is used to group primitives by originator.
-
-@c
-void
-primitive(const char *thes, quarterword c, halfword o, halfword off,
-          int cmd_origin)
-{
-    int prim_val;               /* needed to fill |prim_eqtb| */
-    str_number ss;
-    assert(o >= off);
-    ss = maketexstring(thes);
-    if (cmd_origin == tex_command || cmd_origin == core_command) {
-        primitive_def(thes, strlen(thes), c, o);
-    }
-    prim_val = prim_lookup(ss);
-    prim_origin(prim_val) = (quarterword) cmd_origin;
-    prim_eq_type(prim_val) = c;
-    prim_equiv(prim_val) = o;
-    store_primitive_name(ss, c, o, off);
-}
-
-
-
-@ Here is a helper that does the actual hash insertion.
-
-@c
-static halfword insert_id(halfword p, const unsigned char *j, unsigned int l)
-{
-    unsigned saved_cur_length;
-    unsigned saved_cur_string_size;
-    unsigned char *saved_cur_string;
-    const unsigned char *k;
-    /* This code far from ideal: the existance of |hash_extra| changes
-       all the potential (short) coalesced lists into a single (long)
-       one. This will create a slowdown. */
-    if (cs_text(p) > 0) {
-        if (hash_high < hash_extra) {
-            incr(hash_high);
-            /* can't use |eqtb_top| here (perhaps because that is not finalized
-               yet when called from |primitive|?) */
-            cs_next(p) = hash_high + eqtb_size;
-            p = cs_next(p);
-        } else {
-            do {
-                if (hash_is_full)
-                    overflow("hash size", (unsigned) (hash_size + hash_extra));
-                decr(hash_used);
-            } while (cs_text(hash_used) != 0);  /* search for an empty location in |hash| */
-            cs_next(p) = hash_used;
-            p = hash_used;
-        }
-    }
-    saved_cur_length = cur_length;
-    saved_cur_string = cur_string;
-    saved_cur_string_size = cur_string_size;
-    reset_cur_string();
-    for (k = j; k <= j + l - 1; k++)
-        append_char(*k);
-    cs_text(p) = make_string();
-    cur_length = saved_cur_length;
-    xfree(cur_string);
-    cur_string = saved_cur_string;
-    cur_string_size = saved_cur_string_size;
-    incr(cs_count);
-    return p;
-}
-
-
-@ Here is the subroutine that searches the hash table for an identifier
- that matches a given string of length |l>1| appearing in |buffer[j..
- (j+l-1)]|. If the identifier is found, the corresponding hash table address
- is returned. Otherwise, if the global variable |no_new_control_sequence|
- is |true|, the dummy address |undefined_control_sequence| is returned.
- Otherwise the identifier is inserted into the hash table and its location
- is returned.
-
-@c
-pointer id_lookup(int j, int l)
-{                               /* search the hash table */
-    int h;                      /* hash code */
-    pointer p;                  /* index in |hash| array */
-
-    h = compute_hash((char *) (buffer + j), (unsigned) l, hash_prime);
-#ifdef VERBOSE
-    {
-        unsigned char *todo = xmalloc(l + 2);
-        strncpy(todo, (buffer + j), l);
-        todo[l] = '\0';
-        todo[l + 1] = '\0';
-        fprintf(stdout, "id_lookup(%s)\n", todo);
-        free(todo);
-    }
-#endif
-    p = h + hash_base;          /* we start searching here; note that |0<=h<hash_prime| */
-    while (1) {
-        if (cs_text(p) > 0)
-            if (str_length(cs_text(p)) == (unsigned) l)
-                if (str_eq_buf(cs_text(p), j))
-                    goto FOUND;
-        if (cs_next(p) == 0) {
-            if (no_new_control_sequence) {
-                p = undefined_control_sequence;
-            } else {
-                p = insert_id(p, (buffer + j), (unsigned) l);
-            }
-            goto FOUND;
-        }
-        p = cs_next(p);
-    }
-  FOUND:
-    return p;
-}
-
-@ Here is a similar subroutine for finding a primitive in the hash.
-This one is based on a C string.
-
-@c
-pointer string_lookup(const char *s, size_t l)
-{                               /* search the hash table */
-    int h;                      /* hash code */
-    pointer p;                  /* index in |hash| array */
-    h = compute_hash(s, (unsigned) l, hash_prime);
-    p = h + hash_base;          /* we start searching here; note that |0<=h<hash_prime| */
-    while (1) {
-        if (cs_text(p) > 0)
-            if (str_eq_cstr(cs_text(p), s, l))
-                goto FOUND;
-        if (cs_next(p) == 0) {
-            if (no_new_control_sequence) {
-                p = undefined_control_sequence;
-            } else {
-                p = insert_id(p, (const unsigned char *) s, (unsigned) l);
-            }
-            goto FOUND;
-        }
-        p = cs_next(p);
-    }
-  FOUND:
-    return p;
-}
-
-@ The |print_cmd_chr| routine prints a symbolic interpretation of a
-   command code and its modifier. This is used in certain `\.{You can\'t}'
-   error messages, and in the implementation of diagnostic routines like
-   \.{\\show}.
-
-   The body of |print_cmd_chr| use to be  a rather tedious listing of print
-   commands, and most of it was essentially an inverse to the |primitive|
-   routine that enters a \TeX\ primitive into |eqtb|.
-
-   Thanks to |prim_data|, there is no need for all that tediousness. What
-   is left of |primt_cnd_chr| are just the exceptions to the general rule
-   that the  |cmd,chr_code| pair represents in a single primitive command.
-
-@c
-#define chr_cmd(A) do { tprint(A); print(chr_code); } while (0)
-
-static void prim_cmd_chr(quarterword cmd, halfword chr_code)
-{
-    int idx = chr_code - prim_data[cmd].offset;
-    if (cmd <= last_cmd &&
-        idx >= 0 && idx < prim_data[cmd].subids &&
-        prim_data[cmd].names != NULL && prim_data[cmd].names[idx] != 0) {
-        tprint_esc("");
-        print(prim_data[cmd].names[idx]);
-    } else {
-        /* TEX82 didn't print the |cmd,idx| information, but it may be useful */
-        tprint("[unknown command code! (");
-        print_int(cmd);
-        tprint(", ");
-        print_int(idx);
-        tprint(")]");
-    }
-}
-
-void print_cmd_chr(quarterword cmd, halfword chr_code)
-{
-    int n;                      /* temp variable */
-    switch (cmd) {
-    case left_brace_cmd:
-        chr_cmd("begin-group character ");
-        break;
-    case right_brace_cmd:
-        chr_cmd("end-group character ");
-        break;
-    case math_shift_cmd:
-        chr_cmd("math shift character ");
-        break;
-    case mac_param_cmd:
-        if (chr_code == tab_mark_cmd_code)
-            tprint_esc("alignmark");
-        else
-            chr_cmd("macro parameter character ");
-        break;
-    case sup_mark_cmd:
-        chr_cmd("superscript character ");
-        break;
-    case sub_mark_cmd:
-        chr_cmd("subscript character ");
-        break;
-    case endv_cmd:
-        tprint("end of alignment template");
-        break;
-    case spacer_cmd:
-        chr_cmd("blank space ");
-        break;
-    case letter_cmd:
-        chr_cmd("the letter ");
-        break;
-    case other_char_cmd:
-        chr_cmd("the character ");
-        break;
-    case tab_mark_cmd:
-        if (chr_code == span_code)
-            tprint_esc("span");
-        else if (chr_code == tab_mark_cmd_code)
-            tprint_esc("aligntab");
-        else
-            chr_cmd("alignment tab character ");
-        break;
-    case if_test_cmd:
-        if (chr_code >= unless_code)
-            tprint_esc("unless");
-        prim_cmd_chr(cmd, (chr_code % unless_code));
-        break;
-    case char_given_cmd:
-        tprint_esc("char");
-        print_hex(chr_code);
-        break;
-    case math_given_cmd:
-        if (math_umathcode_meaning_par == 1) {
-            tprint_esc("Umathchar");
-            show_mathcode_value(mathchar_from_integer(chr_code, tex_mathcode));
-        } else {
-            /* better for old macro packages that mess with meaning */
-            tprint_esc("mathchar");
-            show_mathcode_value_old(chr_code);
-        }
-        break;
-    case xmath_given_cmd:
-        tprint_esc("Umathchar");
-        show_mathcode_value(mathchar_from_integer(chr_code, umath_mathcode));
-        break;
-    case set_font_cmd:
-        tprint("select font ");
-        tprint(font_name(chr_code));
-        if (font_size(chr_code) != font_dsize(chr_code)) {
-            tprint(" at ");
-            print_scaled(font_size(chr_code));
-            tprint("pt");
-        }
-        break;
-    case undefined_cs_cmd:
-        tprint("undefined");
-        break;
-    case call_cmd:
-    case long_call_cmd:
-    case outer_call_cmd:
-    case long_outer_call_cmd:
-        n = cmd - call_cmd;
-        if (token_info(token_link(chr_code)) == protected_token)
-            n = n + 4;
-        if (odd(n / 4))
-            tprint_esc("protected");
-        if (odd(n))
-            tprint_esc("long");
-        if (odd(n / 2))
-            tprint_esc("outer");
-        if (n > 0)
-            tprint(" ");
-        tprint("macro");
-        break;
-    case assign_glue_cmd:
-    case assign_mu_glue_cmd:
-        if (chr_code < skip_base) {
-            prim_cmd_chr(cmd, chr_code);
-        } else if (chr_code < mu_skip_base) {
-            tprint_esc("skip");
-            print_int(chr_code - skip_base);
-        } else {
-            tprint_esc("muskip");
-            print_int(chr_code - mu_skip_base);
-        }
-        break;
-    case assign_toks_cmd:
-        if (chr_code >= toks_base) {
-            tprint_esc("toks");
-            print_int(chr_code - toks_base);
-        } else {
-            prim_cmd_chr(cmd, chr_code);
-        }
-        break;
-    case assign_int_cmd:
-        if (chr_code < count_base) {
-            prim_cmd_chr(cmd, chr_code);
-        } else {
-            tprint_esc("count");
-            print_int(chr_code - count_base);
-        }
-        break;
-    case assign_attr_cmd:
-        tprint_esc("attribute");
-        print_int(chr_code - attribute_base);
-        break;
-    case assign_dimen_cmd:
-        if (chr_code < scaled_base) {
-            prim_cmd_chr(cmd, chr_code);
-        } else {
-            tprint_esc("dimen");
-            print_int(chr_code - scaled_base);
-        }
-        break;
-    case normal_cmd:
-        if (chr_code < prim_data[cmd].subids && prim_data[cmd].names[chr_code] != 0) {
-            prim_cmd_chr(cmd, chr_code);
-        } else {
-            tprint("[unknown command! (");
-            print_int(chr_code);
-            tprint(")]");
-        }
-        break;
-    case extension_cmd:
-        if (chr_code < prim_data[cmd].subids && prim_data[cmd].names[chr_code] != 0) {
-            prim_cmd_chr(cmd, chr_code);
-        } else {
-            tprint("[unknown extension! (");
-            print_int(chr_code);
-            tprint(")]");
-
-        }
-        break;
-    default:
-        /* these are most commands, actually */
-        prim_cmd_chr(cmd, chr_code);
-        break;
-    }
-}
diff --git a/texk/web2c/luatexdir/tex/printing.w b/texk/web2c/luatexdir/tex/printing.c
similarity index 63%
rename from texk/web2c/luatexdir/tex/printing.w
rename to texk/web2c/luatexdir/tex/printing.c
index 724441564..0a961071b 100644
--- a/texk/web2c/luatexdir/tex/printing.w
+++ b/texk/web2c/luatexdir/tex/printing.c
@@ -1,87 +1,137 @@
-% printing.w
-%
-% Copyright 2009-2013 Taco Hoekwater <taco@@luatex.org>
-%
-% This file is part of LuaTeX.
-%
-% LuaTeX is free software; you can redistribute it and/or modify it under
-% the terms of the GNU General Public License as published by the Free
-% Software Foundation; either version 2 of the License, or (at your
-% option) any later version.
-%
-% LuaTeX is distributed in the hope that it will be useful, but WITHOUT
-% ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-% FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
-% License for more details.
-%
-% You should have received a copy of the GNU General Public License along
-% with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
-
-@ @c
+/*
+
+printing.w
+
+Copyright 2009-2013 Taco Hoekwater <taco@luatex.org>
+
+This file is part of LuaTeX.
+
+LuaTeX is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 2 of the License, or (at your
+option) any later version.
+
+LuaTeX is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+License for more details.
+
+You should have received a copy of the GNU General Public License along
+with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+
+*/
+
 #include "ptexlib.h"
-#include "lua/luatex-api.h" /* for luatex_banner */
+#include "lua/luatex-api.h"
 
-@ @c
 #define wlog(A)  fputc(A,log_file)
 #define wterm(A) fputc(A,term_out)
 
 int new_string_line = 0;
 int escape_controls = 1;
 
-@ Messages that are sent to a user's terminal and to the transcript-log file
-are produced by several `|print|' procedures. These procedures will
-direct their output to a variety of places, based on the setting of
-the global variable |selector|, which has the following possible
-values:
+/*tex
+
+Messages that are sent to a user's terminal and to the transcript-log file are
+produced by several `|print|' procedures. These procedures will direct their
+output to a variety of places, based on the setting of the global variable
+|selector|, which has the following possible values:
+
+\startitemize
+
+\startitem
+    |term_and_log|, the normal setting, prints on the terminal and on the
+    transcript file.
+\stopitem
+
+\startitem
+    |log_only|, prints only on the transcript file.
+\stopitem
+
+\startitem
+    |term_only|, prints only on the terminal.
+\stopitem
+
+\startitem
+    |no_print|, doesn't print at all. This is used only in rare cases before the
+    transcript file is open.
+\stopitem
+
+\startitem
+    |pseudo|, puts output into a cyclic buffer that is used by the |show_context|
+    routine; when we get to that routine we shall discuss the reasoning behind
+    this curious mode.
+\stopitem
+
+\startitem
+    |new_string|, appends the output to the current string in the string pool.
+\stopitem
+
+\startitem
+    0 to 15, prints on one of the sixteen files for \.{\\write} output.
+\stopitem
 
-\yskip
-\hang |term_and_log|, the normal setting, prints on the terminal and on the
-  transcript file.
+\stopitemize
 
-\hang |log_only|, prints only on the transcript file.
+The symbolic names `|term_and_log|', etc., have been assigned numeric codes that
+satisfy the convenient relations |no_print+1=term_only|, |no_print+2=log_only|,
+|term_only+2=log_only+1=term_and_log|.
 
-\hang |term_only|, prints only on the terminal.
+Three additional global variables, |tally| and |term_offset| and |file_offset|,
+record the number of characters that have been printed since they were most
+recently cleared to zero. We use |tally| to record the length of (possibly very
+long) stretches of printing; |term_offset| and |file_offset|, on the other hand,
+keep track of how many characters have appeared so far on the current line that
+has been output to the terminal or to the transcript file, respectively.
 
-\hang |no_print|, doesn't print at all. This is used only in rare cases
-  before the transcript file is open.
+*/
+
+/*tex transcript of \TeX\ session */
+
+alpha_file log_file;
+
+/*tex where to print a message */
+
+int selector = term_only;
+
+/*tex digits in a number being output */
+
+int dig[23];
+
+/*tex the number of characters recently printed */
+
+int tally = 0;
+
+/*tex the number of characters on the current terminal line */
 
-\hang |pseudo|, puts output into a cyclic buffer that is used
-  by the |show_context| routine; when we get to that routine we shall discuss
-  the reasoning behind this curious mode.
+int term_offset = 0;
 
-\hang |new_string|, appends the output to the current string in the
-  string pool.
+/*tex the number of characters on the current file line */
 
-\hang 0 to 15, prints on one of the sixteen files for \.{\\write} output.
+int file_offset = 0;
 
-\yskip
-\noindent The symbolic names `|term_and_log|', etc., have been assigned
-numeric codes that satisfy the convenient relations |no_print+1=term_only|,
-|no_print+2=log_only|, |term_only+2=log_only+1=term_and_log|.
+/*tex circular buffer for pseudoprinting */
 
-Three additional global variables, |tally| and |term_offset| and
-|file_offset|, record the number of characters that have been printed
-since they were most recently cleared to zero. We use |tally| to record
-the length of (possibly very long) stretches of printing; |term_offset|
-and |file_offset|, on the other hand, keep track of how many characters
-have appeared so far on the current line that has been output to the
-terminal or to the transcript file, respectively.
+packed_ASCII_code trick_buf[(ssup_error_line + 1)];
 
-@c
-alpha_file log_file;                /* transcript of \TeX\ session */
-int selector = term_only;           /* where to print a message */
-int dig[23];                        /* digits in a number being output */
-int tally = 0;                      /* the number of characters recently printed */
-int term_offset = 0;                /* the number of characters on the current terminal line */
-int file_offset = 0;                /* the number of characters on the current file line */
-packed_ASCII_code trick_buf[(ssup_error_line + 1)]; /* circular buffer for pseudoprinting */
-int trick_count;                    /* threshold for pseudoprinting, explained later */
-int first_count;                    /* another variable for pseudoprinting */
-boolean inhibit_par_tokens = false; /*  for minor adjustments to |show_token_list|  */
+/*tex threshold for pseudoprinting, explained later */
 
-@ To end a line of text output, we call |print_ln|
+int trick_count;
+
+/*tex another variable for pseudoprinting */
+
+int first_count;
+
+/*tex for minor adjustments to |show_token_list|  */
+
+boolean inhibit_par_tokens = false;
+
+/*tex
+
+To end a line of text output, we call |print_ln|
+
+*/
 
-@c
 void print_ln(void)
 {
     switch (selector) {
@@ -111,19 +161,21 @@ void print_ln(void)
             fprintf(write_file[selector], "\n");
             break;
     }
-    /* |tally| is not affected */
+    /*tex |tally| is not affected */
 }
 
-@ The |print_char| procedure sends one byte to the desired destination.
-All printing comes through |print_ln| or |print_char|, except for the
-case of |tprint| (see below).
+/*tex
+
+The |print_char| procedure sends one byte to the desired destination. All
+printing comes through |print_ln| or |print_char|, except for the case of
+|tprint| (see below).
 
-The checking of the line length is an inheritance from previosu engines
-and we might drop it after release 1.0. We're not too picky about the exact
-match of that length because we have utf output so length is then a bit
-fuzzy anyway.
+The checking of the line length is an inheritance from previosu engines and we
+might drop it after release 1.0. We're not too picky about the exact match of
+that length because we have utf output so length is then a bit fuzzy anyway.
+
+*/
 
-@c
 #define needs_escaping(A) \
     ((! escape_controls) || (A>=0x20) || (A==0x0A) || (A==0x0D) || (A==0x09))
 
@@ -144,17 +196,6 @@ fuzzy anyway.
         term_offset += 2; \
     }
 
-/*
-
-#define needs_wrapping(A,B) \
-  (((A>=0xF0)&&(B+4>=max_print_line)) || \
-   ((A>=0xE0)&&(B+3>=max_print_line)) || \
-   ((A>=0xC0)&&(B+2>=max_print_line)))
-
-we have mostly ascii in logs, so ...
-
-*/
-
 #define needs_wrapping(A,B) \
   (   (A>=0xC0) && \
     (((A>=0xF0) && (B+4>=max_print_line)) || \
@@ -236,23 +277,25 @@ void print_char(int s)
     incr(tally);
 }
 
-@ An entire string is output by calling |print|. Note that if we are outputting
-the single standard ASCII character \.c, we could call |print("c")|, since
-|"c"=99| is the number of a single-character string, as explained above. But
-|print_char("c")| is quicker, so \TeX\ goes directly to the |print_char|
-routine when it knows that this is safe. (The present implementation
-assumes that it is always safe to print a visible ASCII character.)
+/*tex
+
+An entire string is output by calling |print|. Note that if we are outputting the
+single standard ASCII character \.c, we could call |print("c")|, since |"c"=99|
+is the number of a single-character string, as explained above. But
+|print_char("c")| is quicker, so \TeX\ goes directly to the |print_char| routine
+when it knows that this is safe. (The present implementation assumes that it is
+always safe to print a visible ASCII character.)
 
-@^system dependencies@>
+The first 256 entries above the 17th unicode plane are used for a special trick:
+when \TeX\ has to print items in that range, it will instead print the character
+that results from substracting 0x110000 from that value. This allows
+byte-oriented output to things like \.{\\specials} and \.{\\pdfextension
+literals}. Todo: Perhaps it would be useful to do the same substraction while
+typesetting.
 
-The first 256 entries above the 17th unicode plane are used for a
-special trick: when \TeX\ has to print items in that range, it will
-instead print the character that results from substracting 0x110000
-from that value. This allows byte-oriented output to things like
-\.{\\specials} and \.{\\pdfextension literals}. Todo: Perhaps it would be useful
-to do the same substraction while typesetting.
 
-@c
+*/
+
 void print(int s)
 {
     if (s >= str_ptr) {
@@ -262,9 +305,9 @@ void print(int s)
         if (s < 0) {
             normal_warning("print","bad string offset");
         } else {
-            /* TH not sure about this, disabled for now! */
+            /*tex We're not sure about this so it's disabled for now! */
             if ((false) && (selector > pseudo)) {
-                /* internal strings are not expanded */
+                /*tex internal strings are not expanded */
                 print_char(s);
                 return;
             }
@@ -307,12 +350,13 @@ void print(int s)
 }
 
 void lprint (lstring *ss) {
-    unsigned char *j, *l;       /* current character code position */
+    /*tex current character code position */
+    unsigned char *j, *l;
     j = ss->s;
     l = j + ss->l;
     while (j < l) {
-        /* 0x110000 in utf=8: 0xF4 0x90 0x80 0x80  */
-        /* I don't bother checking the last two bytes explicitly */
+        /*tex I don't bother checking the last two bytes explicitly */
+        /* 0x110000 in utf=8: 0xF4 0x90 0x80 0x80 */
         if ((j < l - 4) && (*j == 0xF4) && (*(j + 1) == 0x90)) {
             int c = (*(j + 2) - 128) * 64 + (*(j + 3) - 128);
             assert(c >= 0 && c < 256);
@@ -325,12 +369,17 @@ void lprint (lstring *ss) {
     }
 }
 
-@ The procedure |print_nl| is like |print|, but it makes sure that the
-string appears at the beginning of a new line.
+/*tex
+
+The procedure |print_nl| is like |print|, but it makes sure that the string
+appears at the beginning of a new line.
+
+*/
+
+/*tex Moev to the beginning of the next line. */
 
-@c
 void print_nlp(void)
-{                               /* move to beginning of a line */
+{
     if (new_string_line > 0) {
         print_char(new_string_line);
     } else if (((term_offset > 0) && (odd(selector))) ||
@@ -339,17 +388,22 @@ void print_nlp(void)
     }
 }
 
+/*tex Prints string |s| at beginning of the next line. */
+
 void print_nl(str_number s)
-{                               /* prints string |s| at beginning of line */
+{
     print_nlp();
     print(s);
 }
 
-@ |char *| versions of the same procedures. |tprint| is
-different because it uses buffering, which works well because
-most of the output actually comes through |tprint|.
+/*tex
+
+|char *| versions of the same procedures. |tprint| is different because it uses
+buffering, which works well because most of the output actually comes through
+|tprint|.
+
+*/
 
-@c
 #define t_flush_buffer(target,offset) \
     buffer[i++] = '\n'; \
     buffer[i++] = '\0';\
@@ -361,7 +415,7 @@ most of the output actually comes through |tprint|.
 void tprint(const char *sss)
 {
     char *buffer = NULL;
-    int i = 0; /* buffer index */
+    int i = 0;
     int newlinechar = new_line_char_par;
     int dolog = 0;
     int doterm = 0;
@@ -409,7 +463,7 @@ void tprint(const char *sss)
             }
             break;
     }
-    /* what is left is the 3 term/log settings */
+    /*tex What is left is the 3 term/log settings. */
     if (dolog || doterm) {
         buffer = xmalloc(strlen(sss)*3);
         if (dolog) {
@@ -469,13 +523,16 @@ void tprint_nl(const char *s)
     tprint(s);
 }
 
-@ Here is the very first thing that \TeX\ prints: a headline that identifies
-the version number and format package. The |term_offset| variable is temporarily
-incorrect, but the discrepancy is not serious since we assume that the banner
-and format identifier together will occupy at most |max_print_line|
-character positions.
+/*tex
+
+Here is the very first thing that \TeX\ prints: a headline that identifies the
+version number and format package. The |term_offset| variable is temporarily
+incorrect, but the discrepancy is not serious since we assume that the banner and
+format identifier together will occupy at most |max_print_line| character
+positions.
+
+*/
 
-@c
 void print_banner(const char *v)
 {
     int callback_id = callback_defined(start_run_callback);
@@ -484,15 +541,16 @@ void print_banner(const char *v)
         if (format_ident > 0)
             print(format_ident);
         print_ln();
-        if (show_luahashchars){
+        if (show_luahashchars) {
             wterm(' ');
             fprintf(term_out,"Number of bits used by the hash function (" my_name "): %d",LUAI_HASHLIMIT);
-        print_ln();
+            print_ln();
         }
         if (shellenabledp) {
             wterm(' ');
-            if (restrictedshell)
+            if (restrictedshell) {
                 fprintf(term_out, "restricted ");
+            }
             fprintf(term_out, "system commands enabled.\n");
         }
     } else if (callback_id > 0) {
@@ -500,7 +558,6 @@ void print_banner(const char *v)
     }
 }
 
-@ @c
 void log_banner(const char *v)
 {
     const char *months[] = { "   ",
@@ -536,41 +593,51 @@ void log_banner(const char *v)
     }
 }
 
-@ @c
 void print_version_banner(void)
 {
     fprintf(term_out, "%s", luatex_banner);
 }
 
-@ The procedure |print_esc| prints a string that is preceded by
-the user's escape character (which is usually a backslash).
+/*tex
+
+The procedure |print_esc| prints a string that is preceded by the user's escape
+character (which is usually a backslash).
+
+*/
 
-@c
 void print_esc(str_number s)
 {
-    int c = escape_char_par; /* Set variable |c| to the current escape character */
-    if (c >= 0 && c < STRING_OFFSET)
+    /*tex Set variable |c| to the current escape character: */
+    int c = escape_char_par;
+    if (c >= 0 && c < 0x110000)
         print(c);
     print(s);
 }
 
-@ This prints escape character, then |s|.
+/*tex
+
+This prints escape character, then |s|.
+
+*/
 
-@c
 void tprint_esc(const char *s)
 {
-    int c = escape_char_par; /* Set variable |c| to the current escape character */
-    if (c >= 0 && c < STRING_OFFSET)
+    /*tex Set variable |c| to the current escape character: */
+    int c = escape_char_par;
+    if (c >= 0 && c < 0x110000)
         print(c);
     tprint(s);
 }
 
-@ An array of digits in the range |0..15| is printed by |print_the_digs|.
+/*tex
+
+An array of digits in the range |0..15| is printed by |print_the_digs|.
+
+*/
 
-@c
 void print_the_digs(eight_bits k)
 {
-    /* prints |dig[k-1]|$\,\ldots\,$|dig[0]| */
+    /*tex prints |dig[k-1]|$\,\ldots\,$|dig[0]| */
     while (k-- > 0) {
         if (dig[k] < 10)
             print_char('0' + dig[k]);
@@ -579,17 +646,22 @@ void print_the_digs(eight_bits k)
     }
 }
 
-@ The following procedure, which prints out the decimal representation of a
-given integer |n|, has been written carefully so that it works properly
-if |n=0| or if |(-n)| would cause overflow. It does not apply |mod| or |div|
-to negative arguments, since such operations are not implemented consistently
-by all PASCAL compilers.
+/*tex
+
+The following procedure, which prints out the decimal representation of a given
+integer |n|, has been written carefully so that it works properly if |n=0| or if
+|(-n)| would cause overflow. It does not apply |mod| or |div| to negative
+arguments, since such operations are not implemented consistently by all PASCAL
+compilers.
+
+*/
 
-@c
 void print_int(longinteger n)
 {
-    int k = 0;     /* index to current digit; we assume that $|n|<10^{23}$ */
-    longinteger m; /* used to negate |n| in possibly dangerous cases */
+    /*tex index to current digit; we assume that $|n|<10^{23}$ */
+    int k = 0;
+    /*tex used to negate |n| in possibly dangerous cases */
+    longinteger m;
     if (n < 0) {
         print_char('-');
         if (n > -100000000) {
@@ -615,11 +687,13 @@ void print_int(longinteger n)
     print_the_digs((eight_bits) k);
 }
 
+/*tex
 
-@ Here is a trivial procedure to print two digits; it is usually called with
-a parameter in the range |0<=n<=99|.
+Here is a trivial procedure to print two digits; it is usually called with a
+parameter in the range |0<=n<=99|.
+
+*/
 
-@c
 void print_two(int n)
 {
     n = abs(n) % 100;
@@ -627,12 +701,16 @@ void print_two(int n)
     print_char('0' + (n % 10));
 }
 
-@ Hexadecimal printing of nonnegative integers is accomplished by |print_hex|.
+/*tex
 
-@c
-void print_hex(int n)
+Hexadecimal printing of nonnegative integers is accomplished by |print_hex|.
+
+*/
+
+void print_qhex(int n)
 {
-    int k = 0 ; /* index to current digit; we assume that $0\L n<16^{22}$ */
+    /*tex index to current digit; we assume that $0\L n<16^{22}$ */
+    int k = 0 ;
     print_char('"');
     do {
         dig[k] = n % 16;
@@ -642,16 +720,18 @@ void print_hex(int n)
     print_the_digs((eight_bits) k);
 }
 
-@ Roman numerals are produced by the |print_roman_int| routine.  Readers
-who like puzzles might enjoy trying to figure out how this tricky code
-works; therefore no explanation will be given. Notice that 1990 yields
-\.{mcmxc}, not \.{mxm}.
+/*tex
+
+Roman numerals are produced by the |print_roman_int| routine. Readers who like
+puzzles might enjoy trying to figure out how this tricky code works; therefore no
+explanation will be given. Notice that 1990 yields \.{mcmxc}, not \.{mxm}.
+
+*/
 
-@c
 void print_roman_int(int n)
 {
-    char *j, *k; /* mysterious indices */
-    int u, v;    /* mysterious numbers */
+    char *j, *k;
+    int u, v;
     char mystery[] = "m2d5c2l5x2v5i";
     j = (char *) mystery;
     v = 1000;
@@ -661,7 +741,7 @@ void print_roman_int(int n)
             n = n - v;
         }
         if (n <= 0) {
-            /* nonpositive input produces no output */
+            /*tex nonpositive input produces no output */
             return;
         }
         k = j + 2;
@@ -680,25 +760,31 @@ void print_roman_int(int n)
     }
 }
 
-@ The |print| subroutine will not print a string that is still being
-created. The following procedure will.
+/*tex
+
+The |print| subroutine will not print a string that is still being created. The
+following procedure will.
+
+*/
 
-@c
 void print_current_string(void)
 {
-    unsigned j = 0; /* points to current character code */
+    /*tex points to current character code */
+    unsigned j = 0;
     while (j < cur_length)
         print_char(cur_string[j++]);
 }
 
-@ The procedure |print_cs| prints the name of a control sequence, given
-a pointer to its address in |eqtb|. A space is printed after the name
-unless it is a single nonletter or an active character. This procedure
-might be invoked with invalid data, so it is ``extra robust.'' The
-individual characters must be printed one at a time using |print|, since
-they may be unprintable.
+/*tex
+
+The procedure |print_cs| prints the name of a control sequence, given a pointer
+to its address in |eqtb|. A space is printed after the name unless it is a single
+nonletter or an active character. This procedure might be invoked with invalid
+data, so it is ``extra robust.'' The individual characters must be printed one at
+a time using |print|, since they may be unprintable.
+
+*/
 
-@c
 void print_cs(int p)
 {
     str_number t = cs_text(p);
@@ -731,10 +817,12 @@ void print_cs(int p)
     }
 }
 
-@ Here is a similar procedure; it avoids the error checks, and it never
-prints a space after the control sequence.
+/*tex
 
-@c
+Here is a similar procedure; it avoids the error checks, and it never prints a
+space after the control sequence.
+
+*/
 void sprint_cs(pointer p)
 {
     str_number t;
@@ -762,9 +850,12 @@ void sprint_cs_name(pointer p)
     }
 }
 
-@ This procedure is never called when |interaction<scroll_mode|.
+/*tex
+
+This procedure is never called when |interaction<scroll_mode|.
+
+*/
 
-@c
 void prompt_input(const char *s)
 {
     wake_up_terminal();
@@ -772,10 +863,13 @@ void prompt_input(const char *s)
     term_input();
 }
 
-@ Then there is a subroutine that prints glue stretch and shrink, possibly
-followed by the name of finite units:
+/*tex
+
+Then there is a subroutine that prints glue stretch and shrink, possibly followed
+by the name of finite units:
+
+*/
 
-@c
 void print_glue(scaled d, int order, const char *s)
 {
     print_scaled(d);
@@ -792,9 +886,12 @@ void print_glue(scaled d, int order, const char *s)
     }
 }
 
-@ The next subroutine prints a whole glue specification
+/*tex
+
+The next subroutine prints a whole glue specification
+
+*/
 
-@c
 void print_spec(int p, const char *s)
 {
     if (p < 0) {
@@ -814,42 +911,47 @@ void print_spec(int p, const char *s)
     }
 }
 
-@ We can reinforce our knowledge of the data structures just introduced
-by considering two procedures that display a list in symbolic form.
-The first of these, called |short_display|, is used in ``overfull box''
-messages to give the top-level description of a list. The other one,
-called |show_node_list|, prints a detailed description of exactly what
-is in the data structure.
+/*tex
 
-The philosophy of |short_display| is to ignore the fine points about exactly
-what is inside boxes, except that ligatures and discretionary breaks are
-expanded. As a result, |short_display| is a recursive procedure, but the
-recursion is never more than one level deep.
-@^recursion@>
+We can reinforce our knowledge of the data structures just introduced by
+considering two procedures that display a list in symbolic form. The first of
+these, called |short_display|, is used in ``overfull box'' messages to give the
+top-level description of a list. The other one, called |show_node_list|, prints a
+detailed description of exactly what is in the data structure.
 
-A global variable |font_in_short_display| keeps track of the font code that
-is assumed to be present when |short_display| begins; deviations from this
-font will be printed.
+The philosophy of |short_display| is to ignore the fine points about exactly what
+is inside boxes, except that ligatures and discretionary breaks are expanded. As
+a result, |short_display| is a recursive procedure, but the recursion is never
+more than one level deep. @^recursion@>
 
-@c
-int font_in_short_display; /* an internal font number */
+A global variable |font_in_short_display| keeps track of the font code that is
+assumed to be present when |short_display| begins; deviations from this font will
+be printed.
 
-@ Boxes, rules, inserts, whatsits, marks, and things in general that are
-sort of ``complicated'' are indicated only by printing `\.{[]}'.
+*/
 
-@c
+/*tex An internal font number: */
 
-/*
-So, 0, 1 as well as any large value will behave the same as before. The reason
-for this extension is that a \name not always makes sense.
+int font_in_short_display;
+
+/*tex
+
+Boxes, rules, inserts, whatsits, marks, and things in general that are sort of
+``complicated'' are indicated only by printing `\.{[]}'.
 
+We print a bit more than original \TEX. A value of 0 or 1 or any large value will
+behave the same as before. The reason for this extension is that a |name| not
+always makes sense.
+
+\starttyping
 0   \foo xyz
 1   \foo (bar)
 2   <bar> xyz
-3   <bar @@ ..> xyz
+3   <bar @ ..> xyz
 4   <id>
 5   <id: bar>
-6   <id: bar @@ ..> xyz
+6   <id: bar @ ..> xyz
+\stoptyping
 
 */
 
@@ -858,12 +960,12 @@ void print_font_identifier(internal_font_number f)
     str_number fonttext;
     fonttext = font_id_text(f);
     if (tracing_fonts_par >= 2 && tracing_fonts_par <= 6) {
-        /* < > is less likely to clash with text parenthesis */
+        /*tex < > is less likely to clash with text parenthesis */
         tprint("<");
         if (tracing_fonts_par >= 2 && tracing_fonts_par <= 3) {
             print_font_name(f);
             if (tracing_fonts_par >= 3 || font_size(f) != font_dsize(f)) {
-                tprint(" @@ ");
+                tprint(" @ ");
                 print_scaled(font_size(f));
                 tprint("pt");
             }
@@ -873,7 +975,7 @@ void print_font_identifier(internal_font_number f)
                 tprint(": ");
                 print_font_name(f);
                 if (tracing_fonts_par >= 6 || font_size(f) != font_dsize(f)) {
-                    tprint(" @@ ");
+                    tprint(" @ ");
                     print_scaled(font_size(f));
                     tprint("pt");
                 }
@@ -881,7 +983,7 @@ void print_font_identifier(internal_font_number f)
         }
         print_char('>');
     } else {
-        /* old method, inherited from pdftex  */
+        /*tex old method, inherited from pdftex  */
         if (fonttext > 0) {
             print_esc(fonttext);
         } else {
@@ -892,7 +994,7 @@ void print_font_identifier(internal_font_number f)
             tprint(" (");
             print_font_name(f);
             if (font_size(f) != font_dsize(f)) {
-                tprint("@@");
+                tprint("@");
                 print_scaled(font_size(f));
                 tprint("pt");
             }
@@ -901,9 +1003,12 @@ void print_font_identifier(internal_font_number f)
     }
 }
 
-@ This prints highlights of list |p|.
+/*tex
+
+This prints highlights of list |p|.
+
+*/
 
-@c
 void short_display(int p)
 {
     while (p != null) {
@@ -922,20 +1027,27 @@ void short_display(int p)
                 print(character(p));
             }
         } else {
-            /* Print a short indication of the contents of node |p| */
+            /*tex Print a short indication of the contents of node |p| */
             print_short_node_contents(p);
         }
         p = vlink(p);
     }
 }
 
-@ The |show_node_list| routine requires some auxiliary subroutines: one to
-print a font-and-character combination, one to print a token list without
-its reference count, and one to print a rule dimension.
+/*tex
 
-@ This prints |char_node| data.
+The |show_node_list| routine requires some auxiliary subroutines: one to print a
+font-and-character combination, one to print a token list without its reference
+count, and one to print a rule dimension.
+
+*/
+
+/*tex
+
+This prints |char_node| data.
+
+*/
 
-@c
 void print_font_and_char(int p)
 {
     if (!is_valid_font(font(p)))
@@ -946,9 +1058,12 @@ void print_font_and_char(int p)
     print(character(p));
 }
 
-@ This prints token list data in braces
+/*tex
+
+This prints token list data in braces
+
+*/
 
-@c
 void print_mark(int p)
 {
     print_char('{');
@@ -959,9 +1074,12 @@ void print_mark(int p)
     print_char('}');
 }
 
-@ This prints dimensions of a rule node.
+/*tex
+
+This prints dimensions of a rule node.
+
+*/
 
-@c
 void print_rule_dimen(scaled d)
 {
     if (is_running(d))
@@ -970,41 +1088,54 @@ void print_rule_dimen(scaled d)
         print_scaled(d);
 }
 
-@ Since boxes can be inside of boxes, |show_node_list| is inherently recursive,
-@^recursion@>
-up to a given maximum number of levels.  The history of nesting is indicated
-by the current string, which will be printed at the beginning of each line;
-the length of this string, namely |cur_length|, is the depth of nesting.
+/*tex
 
-A global variable called |depth_threshold| is used to record the maximum
-depth of nesting for which |show_node_list| will show information.  If we
-have |depth_threshold=0|, for example, only the top level information will
-be given and no sublists will be traversed. Another global variable, called
-|breadth_max|, tells the maximum number of items to show at each level;
-|breadth_max| had better be positive, or you won't see anything.
+Since boxes can be inside of boxes, |show_node_list| is inherently recursive,
+@^recursion@> up to a given maximum number of levels. The history of nesting is
+indicated by the current string, which will be printed at the beginning of each
+line; the length of this string, namely |cur_length|, is the depth of nesting.
 
-@c
-int depth_threshold; /* maximum nesting depth in box displays */
-int breadth_max;     /* maximum number of items shown at the same list level */
+A global variable called |depth_threshold| is used to record the maximum depth of
+nesting for which |show_node_list| will show information. If we have
+|depth_threshold=0|, for example, only the top level information will be given
+and no sublists will be traversed. Another global variable, called |breadth_max|,
+tells the maximum number of items to show at each level; |breadth_max| had better
+be positive, or you won't see anything.
 
-@ The recursive machinery is started by calling |show_box|. Assign the values
+*/
+
+/*tex The maximum nesting depth in box displays: */
+
+int depth_threshold;
+
+/*tex The maximum number of items shown at the same list level: */
+
+int breadth_max;
+
+/*tex
+
+The recursive machinery is started by calling |show_box|. Assign the values
 |depth_threshold:=show_box_depth| and |breadth_max:=show_box_breadth|
 
-@c
+*/
+
 void show_box(halfword p)
 {
     depth_threshold = show_box_depth_par;
     breadth_max = show_box_breadth_par;
     if (breadth_max <= 0)
         breadth_max = 5;
-    /* the show starts at |p| */
+    /*tex the show starts at |p| */
     show_node_list(p);
     print_ln();
 }
 
-@ Helper for debugging purposes. It prints highlights of list |p|
+/*tex
+
+Helper for debugging purposes. It prints highlights of list |p|
+
+*/
 
-@c
 void short_display_n(int p, int m)
 {
     int i = 0;
@@ -1041,7 +1172,7 @@ void short_display_n(int p, int m)
                 short_display(vlink(post_break(p)));
                 print_char('|');
             } else {
-                /* Print a short indication of the contents of node |p| */
+                /*tex Print a short indication of the contents of node |p| */
                 print_short_node_contents(p);
             }
         }
@@ -1052,13 +1183,16 @@ void short_display_n(int p, int m)
     update_terminal();
 }
 
-@ When debugging a macro package, it can be useful to see the exact
-control sequence names in the format file.  For example, if ten new
-csnames appear, it's nice to know what they are, to help pinpoint where
-they came from.  (This isn't a truly ``basic'' printing procedure, but
-that's a convenient module in which to put it.)
+/*tex
+
+When debugging a macro package, it can be useful to see the exact control
+sequence names in the format file. For example, if ten new csnames appear, it's
+nice to know what they are, to help pinpoint where they came from. (This isn't a
+truly ``basic'' printing procedure, but that's a convenient module in which to
+put it.)
+
+*/
 
-@c
 void print_csnames(int hstart, int hfinish)
 {
     int h;
@@ -1066,11 +1200,11 @@ void print_csnames(int hstart, int hfinish)
     fprintf(stderr, "fmtdebug:csnames from %d to %d:", (int) hstart, (int) hfinish);
     for (h = hstart; h <= hfinish; h++) {
         if (cs_text(h) > 0) {
-            /* we have anything at this position */
+            /*tex We have anything at this position. */
             c = str_string(cs_text(h));
             l = c + str_length(cs_text(h));
             while (c < l) {
-                /* print the characters */
+                /*tex Print the characters. */
                 fputc(*c++, stderr);
             }
             fprintf(stderr, "|");
@@ -1078,11 +1212,14 @@ void print_csnames(int hstart, int hfinish)
     }
 }
 
-@ A helper for printing file:line:error style messages.  Look for a
-filename in |full_source_filename_stack|, and if we fail to find
-one fall back on the non-file:line:error style.
+/*tex
+
+A helper for printing file:line:error style messages. Look for a filename in
+|full_source_filename_stack|, and if we fail to find one fall back on the
+non-file:line:error style.
+
+*/
 
-@c
 void print_file_line(void)
 {
     int level = in_open;
@@ -1102,11 +1239,14 @@ void print_file_line(void)
     }
 }
 
-@ \TeX\ is occasionally supposed to print diagnostic information that
-goes only into the transcript file, unless |tracing_online| is positive.
-Here are two routines that adjust the destination of print commands:
+/*tex
+
+\TeX\ is occasionally supposed to print diagnostic information that goes only
+into the transcript file, unless |tracing_online| is positive. Here are two
+routines that adjust the destination of print commands:
+
+*/
 
-@c
 void begin_diagnostic(void)
 {
     global_old_setting = selector;
@@ -1117,9 +1257,12 @@ void begin_diagnostic(void)
     }
 }
 
-@ Restore proper conditions after tracing.
+/*tex
+
+Restore proper conditions after tracing.
+
+*/
 
-@c
 void end_diagnostic(boolean blank_line)
 {
     tprint_nl("");
@@ -1128,8 +1271,11 @@ void end_diagnostic(boolean blank_line)
     selector = global_old_setting;
 }
 
-@ Of course we had better declare another global variable, if the previous
-routines are going to work.
+/*tex
+
+Of course we had better declare another global variable, if the previous routines
+are going to work.
+
+*/
 
-@c
 int global_old_setting;
diff --git a/texk/web2c/luatexdir/tex/scanning.c b/texk/web2c/luatexdir/tex/scanning.c
new file mode 100644
index 000000000..8f7e1d591
--- /dev/null
+++ b/texk/web2c/luatexdir/tex/scanning.c
@@ -0,0 +1,2743 @@
+/*
+
+Copyright 2009-2012 Taco Hoekwater <taco@luatex.org>
+
+This file is part of LuaTeX.
+
+LuaTeX is free software; you can redistribute it and/or modify it under the terms
+of the GNU General Public License as published by the Free Software Foundation;
+either version 2 of the License, or (at your option) any later version.
+
+LuaTeX is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU General Public License along with
+LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#include "ptexlib.h"
+
+static void scan_expr(void);
+
+/*tex
+
+    Let's turn now to some procedures that \TeX\ calls upon frequently to digest
+    certain kinds of patterns in the input. Most of these are quite simple; some
+    are quite elaborate. Almost all of the routines call |get_x_token|, which can
+    cause them to be invoked recursively.
+
+    The |scan_left_brace| routine is called when a left brace is supposed to be
+    the next non-blank token. (The term ``left brace'' means, more precisely, a
+    character whose catcode is |left_brace|.) \TeX\ allows \.{\\relax} to appear
+    before the |left_brace|.
+
+*/
+
+/* This reads a mandatory |left_brace|: */
+
+void scan_left_brace(void)
+{
+    /*tex Get the next non-blank non-relax non-call token */
+    do {
+        get_x_token();
+    } while ((cur_cmd == spacer_cmd) || (cur_cmd == relax_cmd));
+    if (cur_cmd != left_brace_cmd) {
+        print_err("Missing { inserted");
+        help4(
+            "A left brace was mandatory here, so I've put one in.",
+            "You might want to delete and/or insert some corrections",
+            "so that I will find a matching right brace soon.",
+            "If you're confused by all this, try typing `I}' now."
+        );
+        back_error();
+        cur_tok = left_brace_token + '{';
+        cur_cmd = left_brace_cmd;
+        cur_chr = '{';
+        incr(align_state);
+    }
+}
+
+/*tex
+
+    The |scan_optional_equals| routine looks for an optional `\.=' sign preceded
+    by optional spaces; `\.{\\relax}' is not ignored here.
+
+*/
+
+void scan_optional_equals(void)
+{
+    /*tex Get the next non-blank non-call token */
+    do {
+        get_x_token();
+    } while (cur_cmd == spacer_cmd);
+    if (cur_tok != other_token + '=')
+        back_input();
+}
+
+/*tex
+
+    Here is a procedure that sounds an alarm when mu and non-mu units are being
+    switched.
+
+*/
+
+static void mu_error(void)
+{
+    print_err("Incompatible glue units");
+    help1("I'm going to assume that 1mu=1pt when they're mixed.");
+    error();
+}
+
+/*tex
+
+    The next routine `|scan_something_internal|' is used to fetch internal
+    numeric quantities like `\.{\\hsize}', and also to handle the `\.{\\the}'
+    when expanding constructions like `\.{\\the\\toks0}' and
+    `\.{\\the\\baselineskip}'. Soon we will be considering the |scan_int|
+    procedure, which calls |scan_something_internal|; on the other hand,
+    |scan_something_internal| also calls |scan_int|, for constructions like
+    `\.{\\catcode\`\\\$}' or `\.{\\fontdimen} \.3 \.{\\ff}'. So we have to
+    declare |scan_int| as a |forward| procedure. A few other procedures are also
+    declared at this point.
+
+    \TeX\ doesn't know exactly what to expect when |scan_something_internal|
+    begins. For example, an integer or dimension or glue value could occur
+    immediately after `\.{\\hskip}'; and one can even say \.{\\the} with respect
+    to token lists in constructions like `\.{\\xdef\\o\{\\the\\output\}}'. On the
+    other hand, only integers are allowed after a construction like
+    `\.{\\count}'. To handle the various possibilities, |scan_something_internal|
+    has a |level| parameter, which tells the ``highest'' kind of quantity that
+    |scan_something_internal| is allowed to produce. Eight levels are
+    distinguished, namely |int_val|, |attr_val|, |dimen_val|, |glue_val|,
+    |mu_val|, |dir_val|, |ident_val|, and |tok_val|.
+
+    The output of |scan_something_internal| (and of the other routines
+    |scan_int|, |scan_dimen|, and |scan_glue| below) is put into the global
+    variable |cur_val|, and its level is put into |cur_val_level|. The highest
+    values of |cur_val_level| are special: |mu_val| is used only when |cur_val|
+    points to something in a ``muskip'' register, or to one of the three
+    parameters \.{\\thinmuskip}, \.{\\medmuskip}, \.{\\thickmuskip}; |ident_val|
+    is used only when |cur_val| points to a font identifier; |tok_val| is used
+    only when |cur_val| points to |null| or to the reference count of a token
+    list. The last two cases are allowed only when |scan_something_internal| is
+    called with |level=tok_val|.
+
+    If the output is glue, |cur_val| will point to a glue specification, and the
+    reference count of that glue will have been updated to reflect this
+    reference; if the output is a nonempty token list, |cur_val| will point to
+    its reference count, but in this case the count will not have been updated.
+    Otherwise |cur_val| will contain the integer or scaled value in question.
+
+*/
+
+/*tex The value returned by numeric scanners: */
+
+int cur_val;
+
+/*tex Delcodes are sometimes 51 digits: */
+
+int cur_val1;
+
+/*tex The level of this value: */
+
+int cur_val_level;
+
+#define scanned_result(A,B) do { \
+    cur_val=A; \
+    cur_val_level=B; \
+} while (0)
+
+/*tex
+
+    When a |glue_val| changes to a |dimen_val|, we use the width component of the
+    glue; there is no need to decrease the reference count, since it has not yet
+    been increased. When a |dimen_val| changes to an |int_val|, we use scaled
+    points so that the value doesn't actually change. And when a |mu_val| changes
+    to a |glue_val|, the value doesn't change either.
+
+*/
+
+static void downgrade_cur_val(boolean delete_glue)
+{
+    if (cur_val_level == glue_val_level) {
+        halfword m = cur_val;
+        cur_val = width(m);
+        if (delete_glue)
+            flush_node(m);
+    } else if (cur_val_level == mu_val_level) {
+        mu_error();
+    }
+    decr(cur_val_level);
+}
+
+void negate_cur_val(boolean modify_glue)
+{
+    if (cur_val_level >= glue_val_level) {
+        if (modify_glue) {
+            /*tex We modify in-place. */
+        } else {
+            cur_val = new_spec(cur_val);
+        }
+        negate(width(cur_val));
+        negate(stretch(cur_val));
+        negate(shrink(cur_val));
+    } else {
+        negate(cur_val);
+    }
+}
+
+/*tex
+
+    Some of the internal items can be fetched both routines, and these have been
+    split off into the next routine, that returns true if the command code was
+    understood.
+
+*/
+
+static boolean short_scan_something_internal(int cmd, int chr, int level, boolean negative)
+{
+    /*tex |chr_code| part of the operand token */
+    halfword m;
+    /*tex general purpose index */
+    halfword q;
+    /*tex index into |nest| */
+    int p;
+    int save_cur_chr;
+    boolean succeeded = true;
+    m = chr;
+    switch (cmd) {
+        case assign_toks_cmd:
+            scanned_result(equiv(m), tok_val_level);
+            break;
+        case assign_int_cmd:
+            scanned_result(eqtb[m].cint, int_val_level);
+            break;
+        case assign_attr_cmd:
+            scanned_result(eqtb[m].cint, int_val_level);
+            break;
+        case assign_dimen_cmd:
+            scanned_result(eqtb[m].cint, dimen_val_level);
+            break;
+        case assign_glue_cmd:
+            scanned_result(equiv(m), glue_val_level);
+            break;
+        case assign_mu_glue_cmd:
+            scanned_result(equiv(m), mu_val_level);
+            break;
+        case assign_direction_cmd:
+            if (m == (int_base + line_direction_code)) {
+                m = int_base + text_direction_code;
+            }
+            scanned_result(eqtb[m].cint, int_val_level);
+            break;
+        case assign_dir_cmd:
+            if (m == (int_base + line_direction_code)) {
+                m = int_base + text_direction_code;
+            }
+            scanned_result(eqtb[m].cint, dir_val_level);
+            break;
+        case math_style_cmd:
+            scanned_result(m, int_val_level);
+            break;
+        case set_aux_cmd:
+            /*tex Fetch the |space_factor| or the |prev_depth|. */
+            if (abs(cur_list.mode_field) != m) {
+                print_err("Improper ");
+                print_cmd_chr(set_aux_cmd, m);
+                help4(
+                    "You can refer to \\spacefactor only in horizontal mode;",
+                    "you can refer to \\prevdepth only in vertical mode; and",
+                    "neither of these is meaningful inside \\write. So",
+                    "I'm forgetting what you said and using zero instead."
+                );
+                error();
+                if (level != tok_val_level)
+                    scanned_result(0, dimen_val_level);
+                else
+                    scanned_result(0, int_val_level);
+            } else if (m == vmode) {
+                scanned_result(prev_depth_par, dimen_val_level);
+            } else {
+                scanned_result(space_factor_par, int_val_level);
+            }
+            break;
+        case set_prev_graf_cmd:
+            /*tex Fetch the |prev_graf| */
+            if (cur_list.mode_field == 0) {
+                /*tex |prev_graf=0| within \.{\\write} */
+                scanned_result(0, int_val_level);
+            } else {
+                p = nest_ptr;
+                while (abs(nest[p].mode_field) != vmode)
+                    decr(p);
+                scanned_result(nest[p].pg_field, int_val_level);
+            }
+            break;
+        case set_page_int_cmd:
+            /*tex Fetch the |dead_cycles| or the |insert_penalties| */
+            if (m == 0)
+                cur_val = dead_cycles;
+            else if (m == 2)
+                cur_val = interaction;
+            else
+                cur_val = insert_penalties;
+            cur_val_level = int_val_level;
+            break;
+        case set_page_dimen_cmd:
+            /*tex Fetch something on the |page_so_far|. */
+            if ((page_contents == empty) && (!output_active)) {
+                if (m == 0)
+                    cur_val = max_dimen;
+                else
+                    cur_val = 0;
+            } else {
+                cur_val = page_so_far[m];
+            }
+            cur_val_level = dimen_val_level;
+            break;
+        case set_tex_shape_cmd:
+            /*tex Fetch the |par_shape| size. */
+            if (par_shape_par_ptr == null)
+                cur_val = 0;
+            else
+                cur_val = vinfo(par_shape_par_ptr + 1);
+            cur_val_level = int_val_level;
+            break;
+        case set_etex_shape_cmd:
+            /*tex Fetch a penalties array element. */
+            scan_int();
+            if ((equiv(m) == null) || (cur_val < 0)) {
+                cur_val = 0;
+            } else {
+                if (cur_val > penalty(equiv(m)))
+                    cur_val = penalty(equiv(m));
+                cur_val = penalty(equiv(m) + cur_val);
+            }
+            cur_val_level = int_val_level;
+            break;
+        case char_given_cmd:
+        case math_given_cmd:
+        case xmath_given_cmd:
+            scanned_result(cur_chr, int_val_level);
+            break;
+        case last_item_cmd:
+            /*tex
+
+                Because the items in this case directly refer to |cur_chr|, it
+                needs to be saved and restored.
+
+            */
+            save_cur_chr = cur_chr;
+            cur_chr = chr;
+            /*tex
+
+                Fetch an item in the current node, if appropriate. Here is where
+                \.{\\lastpenalty}, \.{\\lastkern}, and \.{\\ } are implemented.
+                The reference count for \.{\\lastskip} will be updated later.
+
+                We also handle \.{\\inputlineno} and \.{\\badness} here, because
+                they are legal in similar contexts.
+
+            */
+            if (m >= input_line_no_code) {
+                if (m >= eTeX_glue) {
+                    /*tex Process an expression and |return|. */
+                    if (m < eTeX_mu) {
+                        if (m == mu_to_glue_code) {
+                            scan_mu_glue();
+                        };
+                        cur_val_level = glue_val_level;
+                    } else if (m < eTeX_expr) {
+                        if (m == glue_to_mu_code) {
+                            scan_normal_glue();
+                        }
+                        cur_val_level = mu_val_level;
+                    } else {
+                        cur_val_level = m - eTeX_expr + int_val_level;
+                        scan_expr();
+                    }
+                    /*tex
+
+                        This code for reducing |cur_val_level| and\slash or
+                        negating the result is similar to the one for all the
+                        other cases of |scan_something_internal|; we free a
+                        glue_spec when needed.
+
+                    */
+                    while (cur_val_level > level) {
+                        downgrade_cur_val(true);
+                    }
+                    if (negative) {
+                        /*tex
+
+                            We get a new glue spec node with negated values and
+                            the old intermediate is deleted.
+
+                        */
+                        negate_cur_val(true);
+                    }
+                    return succeeded;
+                } else if (m >= eTeX_dim) {
+                    switch (m) {
+                        case font_char_wd_code:
+                        case font_char_ht_code:
+                        case font_char_dp_code:
+                        case font_char_ic_code:
+                            scan_font_ident();
+                            q = cur_val;
+                            scan_char_num();
+                            if (char_exists(q, cur_val)) {
+                                switch (m) {
+                                case font_char_wd_code:
+                                    cur_val = char_width(q, cur_val);
+                                    break;
+                                case font_char_ht_code:
+                                    cur_val = char_height(q, cur_val);
+                                    break;
+                                case font_char_dp_code:
+                                    cur_val = char_depth(q, cur_val);
+                                    break;
+                                case font_char_ic_code:
+                                    cur_val = char_italic(q, cur_val);
+                                    break;
+				}
+                            } else {
+                                cur_val = 0;
+                            }
+                            break;
+                        case par_shape_length_code:
+                        case par_shape_indent_code:
+                        case par_shape_dimen_code:
+                            q = cur_chr - par_shape_length_code;
+                            scan_int();
+                            if ((par_shape_par_ptr == null) || (cur_val <= 0)) {
+                                cur_val = 0;
+                            } else {
+                                if (q == 2) {
+                                    q = cur_val % 2;
+                                    cur_val = (cur_val + q) / 2;
+                                }
+                                if (cur_val > vinfo(par_shape_par_ptr + 1))
+                                    cur_val = vinfo(par_shape_par_ptr + 1);
+                                cur_val =
+                                    varmem[par_shape_par_ptr + 2 * cur_val - q + 1].cint;
+                            }
+                            cur_val_level = dimen_val_level;
+                            break;
+                        case glue_stretch_code:
+                        case glue_shrink_code:
+                            scan_normal_glue();
+                            q = cur_val;
+                            if (m == glue_stretch_code)
+                                cur_val = stretch(q);
+                            else
+                                cur_val = shrink(q);
+                            flush_node(q);
+                            break;
+                    }
+                    cur_val_level = dimen_val_level;
+                } else {
+                    switch (m) {
+                        case input_line_no_code:
+                            cur_val = line;
+                            break;
+                        case badness_code:
+                            cur_val = last_badness;
+                            break;
+                        case luatex_version_code:
+                            cur_val = get_luatexversion();
+                            break;
+                        case last_saved_box_resource_index_code:
+                            cur_val = last_saved_box_index;
+                            break;
+                        case last_saved_image_resource_index_code:
+                            cur_val = last_saved_image_index;
+                            break;
+                        case last_saved_image_resource_pages_code:
+                            cur_val = last_saved_image_pages;
+                            break;
+                        case last_x_pos_code:
+                            cur_val = last_position.h;
+                            break;
+                        case last_y_pos_code:
+                            cur_val = last_position.v;
+                            break;
+                        case random_seed_code:
+                            cur_val = random_seed;
+                            break;
+                        case eTeX_version_code:
+                            cur_val = eTeX_version;
+                            break;
+                        case eTeX_minor_version_code:
+                            cur_val = eTeX_minor_version;
+                            break;
+                        case current_group_level_code:
+                            cur_val = cur_level - level_one;
+                            break;
+                        case current_group_type_code:
+                            cur_val = cur_group;
+                            break;
+                        case current_if_level_code:
+                            q = cond_ptr;
+                            cur_val = 0;
+                            while (q != null) {
+                                incr(cur_val);
+                                q = vlink(q);
+                            }
+                            break;
+                        case current_if_type_code:
+                            if (cond_ptr == null)
+                                cur_val = 0;
+                            else if (cur_if < unless_code)
+                                cur_val = cur_if + 1;
+                            else
+                                cur_val = -(cur_if - unless_code + 1);
+                            break;
+                        case current_if_branch_code:
+                            if ((if_limit == or_code) || (if_limit == else_code))
+                                cur_val = 1;
+                            else if (if_limit == fi_code)
+                                cur_val = -1;
+                            else
+                                cur_val = 0;
+                            break;
+                        case glue_stretch_order_code:
+                        case glue_shrink_order_code:
+                            scan_normal_glue();
+                            q = cur_val;
+                            if (m == glue_stretch_order_code)
+                                cur_val = stretch_order(q);
+                            else
+                                cur_val = shrink_order(q);
+                            flush_node(q);
+                            break;
+                    }
+                    cur_val_level = int_val_level;
+                }
+            } else {
+                if (cur_chr == glue_val_level)
+                    cur_val = zero_glue;
+                else
+                    cur_val = 0;
+                if (cur_chr == last_node_type_code) {
+                    cur_val_level = int_val_level;
+                    if ((cur_list.tail_field == cur_list.head_field)
+                        || (cur_list.mode_field == 0))
+                        cur_val = -1;
+                } else {
+                    /*tex assumes identical values */
+                    cur_val_level = cur_chr;
+                }
+                if ((cur_list.tail_field != contrib_head) &&
+                    !is_char_node(cur_list.tail_field) &&
+                    (cur_list.mode_field != 0)) {
+                    switch (cur_chr) {
+                        case lastpenalty_code:
+                            if (type(cur_list.tail_field) == penalty_node)
+                                cur_val = penalty(cur_list.tail_field);
+                            break;
+                        case lastkern_code:
+                            if (type(cur_list.tail_field) == kern_node)
+                                cur_val = width(cur_list.tail_field);
+                            break;
+                        case lastskip_code:
+                            if (type(cur_list.tail_field) == glue_node)
+                                cur_val = cur_list.tail_field;
+                            if (subtype(cur_list.tail_field) == mu_glue)
+                                cur_val_level = mu_val_level;
+                            break;
+                        case last_node_type_code:
+                            cur_val = visible_last_node_type(cur_list.tail_field);
+                            break;
+                    }
+                } else if ((cur_list.mode_field == vmode) && (cur_list.tail_field == cur_list.head_field)) {
+                    switch (cur_chr) {
+                        case lastpenalty_code:
+                            cur_val = last_penalty;
+                            break;
+                        case lastkern_code:
+                            cur_val = last_kern;
+                            break;
+                        case lastskip_code:
+                            if (last_glue != max_halfword)
+                                cur_val = last_glue;
+                            break;
+                        case last_node_type_code:
+                            cur_val = last_node_type;
+                            break;
+                    }
+                }
+            }
+            cur_chr = save_cur_chr;
+            break;
+        default:
+            succeeded = false;
+    }
+    if (succeeded) {
+        while (cur_val_level > level) {
+            /*tex Convert |cur_val| to a lower level. */
+            downgrade_cur_val(false);
+        }
+        /*tex
+
+            Fix the reference count, if any, and negate |cur_val| if |negative|.
+            If |cur_val| points to a glue specification at this point, the
+            reference count for the glue does not yet include the reference by
+            |cur_val|. If |negative| is |true|, |cur_val_level| is known to be
+            |<=mu_val|.
+
+         */
+        if (negative) {
+            /*tex We create a new (negated) glue spec and keep the old one. */
+            negate_cur_val(false);
+        } else if ((cur_val_level >= glue_val_level) && (cur_val_level <= mu_val_level)) {
+			cur_val = new_spec(cur_val);
+        }
+    }
+    return succeeded;
+}
+
+/*tex
+
+    First, here is a short routine that is called from lua code. All the real
+    work is delegated to |short_scan_something_internal| that is shared between
+    this routine and |scan_something_internal|.
+
+*/
+
+void scan_something_simple(halfword cmd, halfword subitem)
+{
+    /*tex Negative is never true. */
+    if (!short_scan_something_internal(cmd, subitem, tok_val_level, false)) {
+        /*tex Complain that |texlib| can not do this; give zero result. */
+        print_err("You can't use `");
+        print_cmd_chr((quarterword) cmd, subitem);
+        tprint("' as tex library index");
+        help1("I'm forgetting what you said and using zero instead.");
+        error();
+        scanned_result(0, int_val_level);
+    }
+}
+
+/*tex
+
+    OK, we're ready for |scan_something_internal| itself. A second parameter,
+    |negative|, is set |true| if the value that is found should be negated. It is
+    assumed that |cur_cmd| and |cur_chr| represent the first token of the
+    internal quantity to be scanned; an error will be signalled if
+    |cur_cmd<min_internal| or |cur_cmd>max_internal|.
+
+*/
+
+/*tex Fetch an internal parameter: */
+
+void scan_something_internal(int level, boolean negative)
+{
+    /*tex |chr_code| part of the operand token */
+    halfword m;
+    /*tex accumulators */
+    int n, k;
+  RESTART:
+    m = cur_chr;
+    if (!short_scan_something_internal(cur_cmd, cur_chr, level, negative)) {
+        switch (cur_cmd) {
+            case def_char_code_cmd:
+                /*tex Fetch a character code from some table */
+                scan_char_num();
+                if (m == math_code_base) {
+                    cur_val1 = get_math_code_num(cur_val);
+                    scanned_result(cur_val1, int_val_level);
+                } else if (m == lc_code_base) {
+                    cur_val1 = get_lc_code(cur_val);
+                    scanned_result(cur_val1, int_val_level);
+                } else if (m == uc_code_base) {
+                    cur_val1 = get_uc_code(cur_val);
+                    scanned_result(cur_val1, int_val_level);
+                } else if (m == sf_code_base) {
+                    cur_val1 = get_sf_code(cur_val);
+                    scanned_result(cur_val1, int_val_level);
+                } else if (m == cat_code_base) {
+                    cur_val1 = get_cat_code(cat_code_table_par, cur_val);
+                    scanned_result(cur_val1, int_val_level);
+                } else {
+                    confusion("def_char");
+                }
+                break;
+            case def_del_code_cmd:
+            case extdef_del_code_cmd:
+                /*tex Fetch a character code from some table. */
+                scan_char_num();
+                cur_val1 = get_del_code_num(cur_val);
+                scanned_result(cur_val1, int_val_level);
+                break;
+            case extdef_math_code_cmd:
+                /*tex Fetch an extended math code table value. */
+                scan_char_num();
+                cur_val1 = get_math_code_num(cur_val);
+                scanned_result(cur_val1, int_val_level);
+                break;
+            case toks_register_cmd:
+            case set_font_cmd:
+            case def_font_cmd:
+            case letterspace_font_cmd:
+            case copy_font_cmd:
+                /*tex Fetch a token list or font identifier, provided that |level=tok_val|. */
+                if (level != tok_val_level) {
+                    print_err("Missing number, treated as zero");
+                    help3(
+                        "A number should have been here; I inserted `0'.",
+                        "(If you can't figure out why I needed to see a number,",
+                        "look up `weird error' in the index to The TeXbook.)"
+                    );
+                    back_error();
+                    scanned_result(0, dimen_val_level);
+                } else if (cur_cmd == toks_register_cmd) {
+                    scan_register_num();
+                    m = toks_base + cur_val;
+                    scanned_result(equiv(m), tok_val_level);
+                } else {
+                    back_input();
+                    scan_font_ident();
+                    scanned_result(font_id_base + cur_val, ident_val_level);
+                }
+                break;
+            case set_font_id_cmd:
+                scan_int();
+                scanned_result(font_id_base + cur_val, ident_val_level);
+                break;
+            case def_family_cmd:
+                /*tex Fetch a math font identifier. */
+                scan_char_num();
+                cur_val1 = fam_fnt(cur_val, m);
+                scanned_result(font_id_base + cur_val1, ident_val_level);
+                break;
+            case set_math_param_cmd:
+                /*tex Fetch a math parameter. */
+                cur_val1 = cur_chr;
+                get_token();
+                if (cur_cmd != math_style_cmd) {
+                    print_err("Missing math style, treated as \\displaystyle");
+                    help1("A style should have been here; I inserted `\\displaystyle'.");
+                    cur_val = display_style;
+                    back_error();
+                } else {
+                    cur_val = cur_chr;
+                }
+                if (cur_val1 < math_param_first_mu_glue) {
+                    if (cur_val1 == math_param_radical_degree_raise) {
+                        cur_val1 = get_math_param(cur_val1, cur_chr);
+                        scanned_result(cur_val1, int_val_level);
+                    } else {
+                        cur_val1 = get_math_param(cur_val1, cur_chr);
+                        scanned_result(cur_val1, dimen_val_level);
+                    }
+                } else {
+                    cur_val1 = get_math_param(cur_val1, cur_chr);
+                    if (cur_val1 == thin_mu_skip_code)
+                        cur_val1 = thin_mu_skip_par;
+                    else if (cur_val1 == med_mu_skip_code)
+                        cur_val1 = med_mu_skip_par;
+                    else if (cur_val1 == thick_mu_skip_code)
+                        cur_val1 = thick_mu_skip_par;
+                    scanned_result(cur_val1, mu_val_level);
+                }
+                break;
+            case assign_box_dir_cmd:
+                scan_register_num();
+                m = cur_val;
+                if (box(m) != null)
+                    cur_val = box_dir(box(m));
+                else
+                    cur_val = 0;
+                cur_val_level = dir_val_level;
+                break;
+            case set_box_dimen_cmd:
+                /*tex Fetch a box dimension. */
+                scan_register_num();
+                if (box(cur_val) == null)
+                    cur_val = 0;
+                else
+                    cur_val = varmem[box(cur_val) + m].cint;
+                cur_val_level = dimen_val_level;
+                break;
+            case assign_font_dimen_cmd:
+                /*tex Fetch a font dimension. */
+                get_font_dimen();
+                break;
+            case assign_font_int_cmd:
+                /*tex Fetch a font integer. */
+                scan_font_ident();
+                if (m == 0) {
+                    scanned_result(hyphen_char(cur_val), int_val_level);
+                } else if (m == 1) {
+                    scanned_result(skew_char(cur_val), int_val_level);
+                } else if (m == no_lig_code) {
+                    scanned_result(test_no_ligatures(cur_val), int_val_level);
+                } else {
+                    n = cur_val;
+                    scan_char_num();
+                    k = cur_val;
+                    switch (m) {
+                        case lp_code_base:
+                            scanned_result(get_lp_code(n, k), int_val_level);
+                            break;
+                        case rp_code_base:
+                            scanned_result(get_rp_code(n, k), int_val_level);
+                            break;
+                        case ef_code_base:
+                            scanned_result(get_ef_code(n, k), int_val_level);
+                            break;
+                        case tag_code:
+                            scanned_result(get_tag_code(n, k), int_val_level);
+                            break;
+                    }
+                }
+                break;
+            case register_cmd:
+                /*tex Fetch a register */
+                scan_register_num();
+                switch (m) {
+                    case int_val_level:
+                        cur_val = count(cur_val);
+                        break;
+                    case attr_val_level:
+                        cur_val = attribute(cur_val);
+                        break;
+                    case dimen_val_level:
+                        cur_val = dimen(cur_val);
+                        break;
+                    case glue_val_level:
+                        cur_val = skip(cur_val);
+                        break;
+                    case mu_val_level:
+                        cur_val = mu_skip(cur_val);
+                        break;
+                }
+                cur_val_level = m;
+                break;
+            case ignore_spaces_cmd:
+                /*tex Trap unexpandable primitives. */
+                if (cur_chr == 1) {
+                    /*tex
+
+                        Reset |cur_tok| for unexpandable primitives, goto
+                        restart. This block deals with unexpandable
+                        \.{\\primitive} appearing at a spot where an integer or
+                        an internal values should have been found. It fetches the
+                        next token then resets |cur_cmd|, |cur_cs|, and
+                        |cur_tok|, based on the primitive value of that token. No
+                        expansion takes place, because the next token may be all
+                        sorts of things. This could trigger further expansion
+                        creating new errors.
+
+                    */
+                    get_token();
+                    cur_cs = prim_lookup(cs_text(cur_cs));
+                    if (cur_cs != undefined_primitive) {
+                        cur_cmd = get_prim_eq_type(cur_cs);
+                        cur_chr = get_prim_equiv(cur_cs);
+                        cur_tok = token_val(cur_cmd, cur_chr);
+                    } else {
+                        cur_cmd = relax_cmd;
+                        cur_chr = 0;
+                        cur_tok = cs_token_flag + frozen_relax;
+                        cur_cs = frozen_relax;
+                    }
+                    goto RESTART;
+                }
+                break;
+            case hyph_data_cmd:
+                switch (cur_chr) {
+                    case 0:
+                    case 1:
+                        goto DEFAULT;
+                        break;
+                    case 2:
+                        cur_val = get_pre_hyphen_char(language_par);
+                        cur_val_level = int_val_level;
+                        break;
+                    case 3:
+                        cur_val = get_post_hyphen_char(language_par);
+                        cur_val_level = int_val_level;
+                        break;
+                    case 4:
+                        cur_val = get_pre_exhyphen_char(language_par);
+                        cur_val_level = int_val_level;
+                        break;
+                    case 5:
+                        cur_val = get_post_exhyphen_char(language_par);
+                        cur_val_level = int_val_level;
+                        break;
+                    case 6:
+                        cur_val = get_hyphenation_min(language_par);
+                        cur_val_level = int_val_level;
+                        break;
+                    case 7:
+                        scan_int();
+                        cur_val = get_hj_code(language_par,cur_val);
+                        cur_val_level = int_val_level;
+                        break;
+                }
+                break;
+            default:
+                DEFAULT:
+                /*tex Complain that \.{\\the} can not do this; give zero result. */
+                print_err("You can't use `");
+                print_cmd_chr((quarterword) cur_cmd, cur_chr);
+                tprint("' after \\the");
+                help1("I'm forgetting what you said and using zero instead.");
+                error();
+                if (level != tok_val_level)
+                    scanned_result(0, dimen_val_level);
+                else
+                    scanned_result(0, int_val_level);
+                break;
+        }
+        while (cur_val_level > level) {
+            /*tex Convert |cur_val| to a lower level. */
+            downgrade_cur_val(false);
+        }
+        /*tex
+
+            Fix the reference count, if any, and negate |cur_val| if |negative|.
+            If |cur_val| points to a glue specification at this point, the
+            reference count for the glue does not yet include the reference by
+            |cur_val|. If |negative| is |true|, |cur_val_level| is known to be
+            |<=mu_val|.
+
+         */
+        if (negative) {
+            /*tex We create a new (negated) glue spec and keep the old one. */
+            negate_cur_val(false);
+        } else if ((cur_val_level >= glue_val_level) && (cur_val_level <= mu_val_level)) {
+			cur_val = new_spec(cur_val);
+        }
+    }
+}
+
+/*tex
+
+    It is nice to have routines that say what they do, so the original
+    |scan_eight_bit_int| is superceded by |scan_register_num| and
+    |scan_mark_num|. It may become split up even further in the future.
+
+    Many of the |restricted classes| routines are the essentially the same except
+    for the upper limit and the error message, so it makes sense to combine these
+    all into one function.
+
+*/
+
+void scan_limited_int(int max, const char *name)
+{
+    char hlp[80];
+    scan_int();
+    if ((cur_val < 0) || (cur_val > max)) {
+        if (name == NULL) {
+            snprintf(hlp, 80, "Since I expected to read a number between 0 and %d,", max);
+            print_err("Bad number");
+        } else {
+            char msg[80];
+            snprintf(hlp, 80, "A %s must be between 0 and %d.", name, max);
+            snprintf(msg, 80, "Bad %s", name);
+            print_err(msg);
+        }
+        help2(hlp, "I changed this one to zero.");
+        int_error(cur_val);
+        cur_val = 0;
+    }
+}
+
+void scan_fifteen_bit_int(void)
+{
+    scan_real_fifteen_bit_int();
+    cur_val = ((cur_val / 0x1000) * 0x1000000) + (((cur_val % 0x1000) / 0x100) * 0x10000) + (cur_val % 0x100);
+}
+
+void scan_fifty_one_bit_int(void)
+{
+    int iiii;
+    scan_int();
+    if ((cur_val < 0) || (cur_val > 0777777777)) {
+        print_err("Bad delimiter code");
+        help2(
+            "A numeric delimiter (first part) must be between 0 and 2^{27}-1.",
+            "I changed this one to zero."
+        );
+        int_error(cur_val);
+        cur_val = 0;
+    }
+    iiii = cur_val;
+    scan_int();
+    if ((cur_val < 0) || (cur_val > 0xFFFFFF)) {
+        print_err("Bad delimiter code");
+        help2(
+            "A numeric delimiter (second part) must be between 0 and 2^{24}-1.",
+            "I changed this one to zero."
+        );
+        int_error(cur_val);
+        cur_val = 0;
+    }
+    cur_val1 = cur_val;
+    cur_val = iiii;
+}
+
+/*tex
+
+    An integer number can be preceded by any number of spaces and `\.+' or `\.-'
+    signs. Then comes either a decimal constant (i.e., radix 10), an octal
+    constant (i.e., radix 8, preceded by~'), a hexadecimal constant (radix 16,
+    preceded by~"), an alphabetic constant (preceded by~`), or an internal
+    variable. After scanning is complete, |cur_val| will contain the answer,
+    which must be at most $2^{31}-1=2147483647$ in absolute value. The value of
+    |radix| is set to 10, 8, or 16 in the cases of decimal, octal, or hexadecimal
+    constants, otherwise |radix| is set to zero. An optional space follows a
+    constant.
+
+*/
+
+/*tex |scan_int| sets this to 8, 10, 16, or zero */
+
+int radix;
+
+/*tex
+
+    The |scan_int| routine is used also to scan the integer part of a fraction;
+    for example, the `\.3' in `\.{3.14159}' will be found by |scan_int|. The
+    |scan_dimen| routine assumes that |cur_tok=point_token| after the integer
+    part of such a fraction has been scanned by |scan_int|, and that the decimal
+    point has been backed up to be scanned again.
+
+*/
+
+/*tex Sets |cur_val| to an integer: */
+
+void scan_int(void)
+{
+    /*tex should the answer be negated? */
+    boolean negative;
+    /*tex |$2^{31}$ / radix|, the threshold of danger */
+    int m;
+    /*tex the digit just scanned */
+    int d;
+    /*tex have no digits appeared? */
+    boolean vacuous;
+    /*tex has an error message been issued? */
+    boolean OK_so_far;
+    radix = 0;
+    OK_so_far = true;
+    /*tex Get the next non-blank non-sign token; set |negative| appropriately. */
+    negative = false;
+    do {
+        /*tex Get the next non-blank non-call token. */
+        do {
+            get_x_token();
+        } while (cur_cmd == spacer_cmd);
+        if (cur_tok == other_token + '-') {
+            negative = !negative;
+            cur_tok = other_token + '+';
+        }
+    } while (cur_tok == other_token + '+');
+
+  RESTART:
+    if (cur_tok == alpha_token) {
+        /*tex
+
+            Scan an alphabetic character code into |cur_val|. A space is ignored
+            after an alphabetic character constant, so that such constants behave
+            like numeric ones.
+
+        */
+        /*tex Suppress macro expansion: */
+        get_token();
+        if (cur_tok < cs_token_flag) {
+            cur_val = cur_chr;
+            if (cur_cmd <= right_brace_cmd) {
+                if (cur_cmd == right_brace_cmd)
+                    incr(align_state);
+                else
+                    decr(align_state);
+            }
+        } else {
+            /*tex The value of a csname in this context is its name. */
+            str_number txt = cs_text(cur_tok - cs_token_flag);
+            if (is_active_cs(txt))
+                cur_val = active_cs_value(txt);
+            else if (single_letter(txt))
+                cur_val = pool_to_unichar(str_string(txt));
+            else
+                cur_val = (biggest_char + 1);
+        }
+        if (cur_val > biggest_char) {
+            print_err("Improper alphabetic constant");
+            help2(
+                "A one-character control sequence belongs after a ` mark.",
+                "So I'm essentially inserting \\0 here."
+            );
+            cur_val = '0';
+            back_error();
+        } else {
+            /*tex Scan an optional space. */
+            get_x_token();
+            if (cur_cmd != spacer_cmd)
+                back_input();
+        }
+
+    } else if (cur_tok == cs_token_flag + frozen_primitive) {
+        /*tex
+
+            Reset |cur_tok| for unexpandable primitives, goto restart This block
+            deals with unexpandable \.{\\primitive} appearing at a spot where an
+            integer or an internal values should have been found. It fetches the
+            next token then resets |cur_cmd|, |cur_cs|, and |cur_tok|, based on
+            the primitive value of that token. No expansion takes place, because
+            the next token may be all sorts of things. This could trigger further
+            expansion creating new errors.
+
+        */
+        get_token();
+        cur_cs = prim_lookup(cs_text(cur_cs));
+        if (cur_cs != undefined_primitive) {
+            cur_cmd = get_prim_eq_type(cur_cs);
+            cur_chr = get_prim_equiv(cur_cs);
+            cur_tok = token_val(cur_cmd, cur_chr);
+        } else {
+            cur_cmd = relax_cmd;
+            cur_chr = 0;
+            cur_tok = cs_token_flag + frozen_relax;
+            cur_cs = frozen_relax;
+        }
+        goto RESTART;
+    } else if (cur_cmd == math_style_cmd) {
+        cur_val = cur_chr;
+    } else if ((cur_cmd >= min_internal_cmd) && (cur_cmd <= max_internal_cmd)) {
+        scan_something_internal(int_val_level, false);
+    } else {
+        /*tex Scan a numeric constant. */
+        radix = 10;
+        m = 214748364;
+        if (cur_tok == octal_token) {
+            radix = 8;
+            m = 02000000000;
+            get_x_token();
+        } else if (cur_tok == hex_token) {
+            radix = 16;
+            m = 01000000000;
+            get_x_token();
+        }
+        vacuous = true;
+        cur_val = 0;
+        /*tex Accumulate the constant until |cur_tok| is not a suitable digit. */
+        while (1) {
+            if ((cur_tok < zero_token + radix) && (cur_tok >= zero_token) && (cur_tok <= nine_token)) {
+                d = cur_tok - zero_token;
+            } else if (radix == 16) {
+                if ((cur_tok <= A_token + 5) && (cur_tok >= A_token)) {
+                    d = cur_tok - A_token + 10;
+                } else if ((cur_tok <= other_A_token + 5) && (cur_tok >= other_A_token)) {
+                    d = cur_tok - other_A_token + 10;
+                } else {
+                    break;
+                }
+            } else {
+                break;
+            }
+            vacuous = false;
+            if ((cur_val >= m) && ((cur_val > m) || (d > 7) || (radix != 10))) {
+                if (OK_so_far) {
+                    print_err("Number too big");
+                    help2(
+                        "I can only go up to 2147483647='17777777777=\"7FFFFFFF,",
+                        "so I'm using that number instead of yours."
+                    );
+                    error();
+                    cur_val = infinity;
+                    OK_so_far = false;
+                }
+            } else {
+                cur_val = cur_val * radix + d;
+            }
+            get_x_token();
+        }
+        if (vacuous) {
+            /*tex Express astonishment that no number was here */
+            print_err("Missing number, treated as zero");
+            help3(
+                "A number should have been here; I inserted `0'.",
+                "(If you can't figure out why I needed to see a number,",
+                "look up `weird error' in the index to The TeXbook.)"
+            );
+            back_error();
+        } else if (cur_cmd != spacer_cmd) {
+            back_input();
+        }
+    }
+    if (negative)
+        negate(cur_val);
+}
+
+/*tex
+
+    The following code is executed when |scan_something_internal| was called
+    asking for |mu_val|, when we really wanted a ``mudimen'' instead of
+    ``muglue.''
+
+*/
+
+static void coerce_glue(void)
+{
+    int v;
+    if (cur_val_level >= glue_val_level) {
+        v = width(cur_val);
+        flush_node(cur_val);
+        cur_val = v;
+    }
+}
+
+/*tex
+
+    The |scan_dimen| routine is similar to |scan_int|, but it sets |cur_val| to a
+    |scaled| value, i.e., an integral number of sp. One of its main tasks is
+    therefore to interpret the abbreviations for various kinds of units and to
+    convert measurements to scaled points.
+
+    There are three parameters: |mu| is |true| if the finite units must be
+    `\.{mu}', while |mu| is |false| if `\.{mu}' units are disallowed; |inf| is
+    |true| if the infinite units `\.{fil}', `\.{fill}', `\.{filll}' are
+    permitted; and |shortcut| is |true| if |cur_val| already contains an integer
+    and only the units need to be considered.
+
+    The order of infinity that was found in the case of infinite glue is returned
+    in the global variable |cur_order|.
+
+*/
+
+/*tex The order of infinity found by |scan_dimen|: */
+
+int cur_order;
+
+/*tex
+
+    Constructions like `\.{-\'77 pt}' are legal dimensions, so |scan_dimen| may
+    begin with |scan_int|. This explains why it is convenient to use |scan_int|
+    also for the integer part of a decimal fraction.
+
+    Several branches of |scan_dimen| work with |cur_val| as an integer and with
+    an auxiliary fraction |f|, so that the actual quantity of interest is
+    $|cur_val|+|f|/2^{16}$. At the end of the routine, this ``unpacked''
+    representation is put into the single word |cur_val|, which suddenly switches
+    significance from |integer| to |scaled|.
+
+    The necessary conversion factors can all be specified exactly as fractions
+    whose numerator and denominator add to 32768 or less. According to the
+    definitions here, $\rm2660\,dd\approx1000.33297\,mm$; this agrees well with
+    the value $\rm1000.333\,mm$ cited by Bosshard \^{Bosshard, Hans Rudolf} in
+    {\sl Technische Grundlagen zur Satzherstellung\/} (Bern, 1980). The Didot
+    point has been newly standardized in 1978; it's now exactly $\rm
+    1\,nd=0.375\,mm$. Conversion uses the equation
+    $0.375=21681/20320/72.27\cdot25.4$. The new Cicero follows the new Didot
+    point; $\rm 1\,nc=12\,nd$. These would lead to the ratios $21681/20320$ and
+    $65043/5080$, respectively. The closest approximations supported by the
+    algorithm would be $11183/10481$ and $1370/107$. In order to maintain the
+    relation $\rm 1\,nc=12\,nd$, we pick the ratio $685/642$ for $\rm nd$,
+    however.
+
+*/
+
+static void scan_dimen_mu_error(void) {
+    print_err("Illegal unit of measure (mu inserted)");
+    help4(
+        "The unit of measurement in math glue must be mu.",
+        "To recover gracefully from this error, it's best to",
+        "delete the erroneous units; e.g., type `2' to delete",
+        "two letters. (See Chapter 27 of The TeXbook.)"
+    );
+    error();
+}
+
+static void scan_dimen_unknown_unit_error(void) {
+    print_err("Illegal unit of measure (pt inserted)");
+    help6(
+        "Dimensions can be in units of em, ex, in, pt, pc,",
+        "cm, mm, dd, cc, nd, nc, bp, or sp; but yours is a new one!",
+        "I'll assume that you meant to say pt, for printer's points.",
+        "To recover gracefully from this error, it's best to",
+        "delete the erroneous units; e.g., type `2' to delete",
+        "two letters. (See Chapter 27 of The TeXbook.)"
+    );
+    error();
+}
+
+static void scan_dimen_out_of_range_error(void) {
+    print_err("Dimension too large");
+    help2(
+        "I can't work with sizes bigger than about 19 feet.",
+        "Continue and I'll use the largest value I can."
+    );
+    error();
+}
+
+#define set_conversion(A,B) do { num=(A); denom=(B); } while(0)
+
+/*tex
+
+    This function sets |cur_val| to a dimension. It could be optimized a bit more
+    (but not now, something for luatex > 1).
+
+*/
+
+void scan_dimen(boolean mu, boolean inf, boolean shortcut)
+{
+    /*tex should the answer be negated? */
+    boolean negative = false;
+    boolean is_true  = false;
+    /*tex numerator of a fraction whose denominator is $2^{16}$ */
+    int f = 0;
+    /*tex conversion ratio for the scanned units */
+    int num = 0;
+    int denom = 0;
+    /*tex top of decimal digit stack */
+    halfword q;
+    /*tex an internal dimension */
+    scaled v;
+    /*tex temporary storage of |cur_val| */
+    int save_cur_val;
+    arith_error = false;
+    cur_order = normal;
+    if (!shortcut) {
+        /*tex Get the next non-blank non-sign. */
+        do {
+            /*tex Get the next non-blank non-call token. */
+            do {
+                get_x_token();
+            } while (cur_cmd == spacer_cmd);
+            if (cur_tok == minus_token) {
+                negative = !negative;
+                cur_tok = plus_token;
+            }
+        } while (cur_tok == plus_token);
+        if ((cur_cmd >= min_internal_cmd) && (cur_cmd <= max_internal_cmd)) {
+            /*tex Fetch an internal dimension and |goto attach_sign|, or fetch an internal integer. */
+            if (mu) {
+                scan_something_internal(mu_val_level, false);
+                coerce_glue();
+                if (cur_val_level == mu_val_level) {
+                    goto ATTACH_SIGN;
+                } else if (cur_val_level != int_val_level) {
+                    mu_error();
+                }
+            } else {
+                scan_something_internal(dimen_val_level, false);
+                if (cur_val_level == dimen_val_level) {
+                    goto ATTACH_SIGN;
+                }
+            }
+        } else {
+            back_input();
+            if (cur_tok == continental_point_token) {
+                cur_tok = point_token;
+            }
+            if (cur_tok != point_token) {
+                scan_int();
+            } else {
+                radix = 10;
+                cur_val = 0;
+            }
+            if (cur_tok == continental_point_token) {
+                cur_tok = point_token;
+            }
+            if ((radix == 10) && (cur_tok == point_token)) {
+                /*tex
+
+                    Scan decimal fraction. When the following code is executed,
+                    we have |cur_tok=point_token|, but this token has been backed
+                    up using |back_input|; we must first discard it. It turns out
+                    that a decimal point all by itself is equivalent to
+                    `\.{0.0}'. Let's hope people don't use that fact.
+
+                */
+                int k = 0;
+                halfword p = null;
+                int kk;
+                /*tex The |point_token| is being re-scanned. */
+                get_token();
+                while (1) {
+                    get_x_token();
+                    if ((cur_tok > nine_token) || (cur_tok < zero_token))
+                        break;
+                    if (k < 17) {
+                        /*tex Digits for |k>=17| cannot affect the result. */
+                        q = get_avail();
+                        set_token_link(q, p);
+                        set_token_info(q, cur_tok - zero_token);
+                        p = q;
+                        incr(k);
+                    }
+                }
+                for (kk = k; kk >= 1; kk--) {
+                    dig[kk - 1] = token_info(p);
+                    q = p;
+                    p = token_link(p);
+                    free_avail(q);
+                }
+                f = round_decimals(k);
+                if (cur_cmd != spacer_cmd) {
+                    back_input();
+                }
+            }
+        }
+    }
+    if (cur_val < 0) {
+        /*tex In this case |f=0|. */
+        negative = !negative;
+        negate(cur_val);
+    }
+    /*tex
+
+        Scan units and set |cur_val| to $x\cdot(|cur_val|+f/2^{16})$, where there
+        are |x| sp per unit; |goto attach_sign| if the units are internal. Now
+        comes the harder part: At this point in the program, |cur_val| is a
+        nonnegative integer and $f/2^{16}$ is a nonnegative fraction less than 1;
+        we want to multiply the sum of these two quantities by the appropriate
+        factor, based on the specified units, in order to produce a |scaled|
+        result, and we want to do the calculation with fixed point arithmetic
+        that does not overflow.
+
+    */
+    if (inf) {
+         if (scan_keyword("fi")) {
+             cur_order = sfi;
+             if (scan_keyword("l")) {
+                cur_order = fil;
+                if (scan_keyword("l")) {
+                    cur_order = fill;
+                    if (scan_keyword("l")) {
+                        cur_order = filll;
+                    }
+                }
+            }
+            goto ATTACH_FRACTION;
+         }
+    }
+    /*tex
+
+        Scan for (u)units that are internal dimensions; |goto attach_sign| with
+        |cur_val| set if found.
+
+    */
+    save_cur_val = cur_val;
+    /*tex
+
+        Get the next non-blank non-call; a pitty if just backed up the input.
+
+    */
+    do {
+        get_x_token();
+    } while (cur_cmd == spacer_cmd);
+
+    if ((cur_cmd < min_internal_cmd) || (cur_cmd > max_internal_cmd)) {
+        back_input();
+    } else {
+        /*tex |math_given_cmd|, |xmath_given_cmd| and |last_item_cmd} */
+        if (mu) {
+            scan_something_internal(mu_val_level, false);
+            coerce_glue();
+            if (cur_val_level != mu_val_level) {
+                mu_error();
+            }
+        } else {
+            scan_something_internal(dimen_val_level, false);
+        }
+        v = cur_val;
+        goto FOUND;
+    }
+    /*tex Bah |true| forces to split the unit scanner. */
+    if (mu) {
+        /*tex Scan for (m)\.{mu} units and |goto attach_fraction|. */
+        if (! scan_keyword("mu")) {
+            scan_dimen_mu_error();
+        }
+        goto ATTACH_FRACTION;
+    } else if (scan_keyword("em")) {
+        v = quad(get_cur_font());
+    } else if (scan_keyword("ex")) {
+        v = x_height(get_cur_font());
+    } else if (scan_keyword("px")) {
+        v = px_dimen_par;
+    } else {
+        goto PICKUP_UNIT;
+    }
+    /*tex Scan an optional space (after em, ex or px) */
+    get_x_token();
+    if (cur_cmd != spacer_cmd) {
+        back_input();
+    }
+  FOUND:
+    cur_val = nx_plus_y(save_cur_val, v, xn_over_d(v, f, 0200000));
+    goto ATTACH_SIGN;
+    /*tex
+
+        Scan for (a)all other units and adjust |cur_val| and |f| accordingly;
+        |goto done| in the case of scaled points.
+
+    */
+  PICKUP_UNIT:
+    if (scan_keyword("pt")) {
+        /*tex The easy case: */
+        goto SCALE_VALUE;
+    } else if (scan_keyword("mm")) {
+        set_conversion(7227, 2540);
+        goto SCALE_VALUE;
+    } else if (scan_keyword("cm")) {
+        set_conversion(7227, 254);
+        goto SCALE_VALUE;
+    } else if (scan_keyword("sp")) {
+        goto DONE;
+    } else if (scan_keyword("bp")) {
+        set_conversion(7227, 7200);
+        goto SCALE_VALUE;
+    } else if (scan_keyword("in")) {
+        set_conversion(7227, 100);
+        goto SCALE_VALUE;
+    } else if (scan_keyword("dd")) {
+        set_conversion(1238, 1157);
+        goto SCALE_VALUE;
+    } else if (scan_keyword("cc")) {
+        set_conversion(14856, 1157);
+        goto SCALE_VALUE;
+    } else if (scan_keyword("pc")) {
+        set_conversion(12, 1);
+        goto SCALE_VALUE;
+    } else if (scan_keyword("nd")) {
+        set_conversion(685, 642);
+        goto SCALE_VALUE;
+    } else if (scan_keyword("nc")) {
+        set_conversion(1370, 107);
+        goto SCALE_VALUE;
+    } else if (!is_true && scan_keyword("true")) {
+        is_true = true;
+        goto PICKUP_UNIT;
+    }
+    /*tex Complain about unknown unit and |goto done2|. */
+    scan_dimen_unknown_unit_error();
+    goto BAD_NEWS;
+  SCALE_VALUE:
+    /*tex Adjust |f| for the magnification ratio. */
+    if (is_true) {
+        /*tex Maybe at some point we will drop mag completely, even in \DVI\ mode. */
+        if (output_mode_used <= OMODE_DVI) {
+            prepare_mag();
+            if (mag_par != 1000) {
+                cur_val = xn_over_d(cur_val, 1000, mag_par);
+                f = (1000 * f + 0200000 * tex_remainder) / mag_par;
+                cur_val = cur_val + (f / 0200000);
+                f = f % 0200000;
+            }
+        } else {
+            /*tex in \PDF\ mode we're always |true|. */
+            one_true_inch = one_inch;
+        }
+    }
+    if (num) {
+        cur_val = xn_over_d(cur_val, num, denom);
+        f = (num * f + 0200000 * tex_remainder) / denom;
+        cur_val = cur_val + (f / 0200000);
+        f = f % 0200000;
+    }
+  BAD_NEWS:
+  ATTACH_FRACTION:
+    if (cur_val >= 040000) {
+        arith_error = true;
+    } else {
+        cur_val = cur_val * unity + f;
+    }
+  DONE:
+    /*tex Scan an optional space; this happens too often. */
+    get_x_token();
+    if (cur_cmd != spacer_cmd) {
+        back_input();
+    }
+  ATTACH_SIGN:
+    if (arith_error || (abs(cur_val) >= 010000000000)) {
+        /*tex Report that this dimension is out of range. */
+        scan_dimen_out_of_range_error();
+        cur_val = max_dimen;
+        arith_error = false;
+    }
+    if (negative) {
+        negate(cur_val);
+    }
+}
+
+/*tex
+
+    The final member of \TeX's value-scanning trio is |scan_glue|, which makes
+    |cur_val| point to a glue specification. The reference count of that glue
+    spec will take account of the fact that |cur_val| is pointing to~it.
+
+    The |level| parameter should be either |glue_val| or |mu_val|.
+
+    Since |scan_dimen| was so much more complex than |scan_int|, we might expect
+    |scan_glue| to be even worse. But fortunately, it is very simple, since most
+    of the work has already been done.
+
+*/
+
+void scan_glue(int level)
+{
+    /*tex should the answer be negated? */
+    boolean negative = false;
+    /*tex new glue specification */
+    halfword q = null;
+    /*tex does |level=mu_val|? */
+    boolean mu = (level == mu_val_level);
+    /*tex Get the next non-blank non-sign. */
+    do {
+        /*tex Get the next non-blank non-call token. */
+        do {
+            get_x_token();
+        } while (cur_cmd == spacer_cmd);
+        if (cur_tok == minus_token) {
+            negative = !negative;
+            cur_tok = plus_token;
+        }
+    } while (cur_tok == plus_token);
+    if ((cur_cmd >= min_internal_cmd) && (cur_cmd <= max_internal_cmd)) {
+        scan_something_internal(level, negative);
+        if (cur_val_level >= glue_val_level) {
+            if (cur_val_level != level)
+                mu_error();
+            return;
+        }
+        if (cur_val_level == int_val_level)
+            scan_dimen(mu, false, true);
+        else if (level == mu_val_level)
+            mu_error();
+    } else {
+        back_input();
+        scan_dimen(mu, false, false);
+        if (negative)
+            negate(cur_val);
+    }
+    /*tex
+
+        Create a new glue specification whose width is |cur_val|; scan for its
+        stretch and shrink components.
+
+    */
+    q = new_spec(zero_glue);
+    width(q) = cur_val;
+    if (scan_keyword("plus")) {
+        scan_dimen(mu, true, false);
+        stretch(q) = cur_val;
+        stretch_order(q) = (quarterword) cur_order;
+    }
+    if (scan_keyword("minus")) {
+        scan_dimen(mu, true, false);
+        shrink(q) = cur_val;
+        shrink_order(q) = (quarterword) cur_order;
+    }
+    cur_val = q;
+}
+
+/*tex
+
+    This procedure is supposed to scan something like `\.{\\skip\\count12}',
+    i.e., whatever can follow `\.{\\the}', and it constructs a token list
+    containing something like `\.{-3.0pt minus 0.5fill}'.
+
+*/
+
+halfword the_toks(void)
+{
+    /*tex holds |selector| setting */
+    int old_setting;
+    /*tex used for copying a token list */
+    halfword p, q, r;
+    /*tex value of |cur_chr| */
+    int c;
+    str_number s;
+    halfword retval;
+    /*tex Handle \.{\\unexpanded} or \.{\\detokenize} and |return|. */
+    if (odd(cur_chr)) {
+        c = cur_chr;
+        scan_general_text();
+        if (c == 1) {
+            return cur_val;
+        } else {
+            old_setting = selector;
+            selector = new_string;
+            p = get_avail();
+            set_token_link(p, token_link(temp_token_head));
+            token_show(p);
+            flush_list(p);
+            selector = old_setting;
+            s = make_string();
+            retval = str_toks(str_lstring(s));
+            flush_str(s);
+            return retval;
+        }
+    }
+    get_x_token();
+    scan_something_internal(tok_val_level, false);
+    if (cur_val_level >= ident_val_level) {
+        /*tex Copy the token list */
+        p = temp_token_head;
+        set_token_link(p, null);
+        if (cur_val_level == ident_val_level) {
+            store_new_token(cs_token_flag + cur_val);
+        } else if (cur_val != null) {
+            /*tex Do not copy the reference count! */
+            r = token_link(cur_val);
+            while (r != null) {
+                fast_store_new_token(token_info(r));
+                r = token_link(r);
+            }
+        }
+        return p;
+    } else {
+        old_setting = selector;
+        selector = new_string;
+        switch (cur_val_level) {
+            case int_val_level:
+                print_int(cur_val);
+                break;
+            case attr_val_level:
+                print_int(cur_val);
+                break;
+            case dir_val_level:
+                print_dir_par(cur_val);
+                break;
+            case dimen_val_level:
+                print_scaled(cur_val);
+                tprint("pt");
+                break;
+            case glue_val_level:
+                print_spec(cur_val, "pt");
+                flush_node(cur_val);
+                break;
+            case mu_val_level:
+                print_spec(cur_val, "mu");
+                flush_node(cur_val);
+                break;
+        }
+        selector = old_setting;
+        s = make_string();
+        retval = str_toks(str_lstring(s));
+        flush_str(s);
+        return retval;
+    }
+}
+
+str_number the_scanned_result(void)
+{
+    /*tex holds |selector| setting */
+    int old_setting;
+    /*tex return value */
+    str_number r;
+    old_setting = selector;
+    selector = new_string;
+    if (cur_val_level >= ident_val_level) {
+        if (cur_val != null) {
+            show_token_list(token_link(cur_val), null, -1);
+            r = make_string();
+        } else {
+            r = get_nullstr();
+        }
+    } else {
+        switch (cur_val_level) {
+            case int_val_level:
+                print_int(cur_val);
+                break;
+            case attr_val_level:
+                print_int(cur_val);
+                break;
+            case dir_val_level:
+                print_dir_par(cur_val);
+                break;
+            case dimen_val_level:
+                print_scaled(cur_val);
+                tprint("pt");
+                break;
+            case glue_val_level:
+                print_spec(cur_val, "pt");
+                flush_node(cur_val);
+                break;
+            case mu_val_level:
+                print_spec(cur_val, "mu");
+                flush_node(cur_val);
+                break;
+        }
+        r = make_string();
+    }
+    selector = old_setting;
+    return r;
+}
+
+/*tex
+
+    The following routine is used to implement `\.{\\fontdimen} |n| |f|'. The
+    boolean parameter |writing| is set |true| if the calling program intends to
+    change the parameter value.
+
+*/
+
+static void font_param_error(int f)
+{
+    print_err("Font ");
+    print_esc(font_id_text(f));
+    tprint(" has only ");
+    print_int(font_params(f));
+    tprint(" fontdimen parameters");
+    help2(
+        "To increase the number of font parameters, you must",
+        "use \\fontdimen immediately after the \\font is loaded."
+    );
+    error();
+}
+
+void set_font_dimen(void)
+{
+    internal_font_number f;
+    int n;
+    scan_int();
+    n = cur_val;
+    scan_font_ident();
+    f = cur_val;
+    if (n <= 0) {
+        font_param_error(f);
+    } else if (n > font_params(f)) {
+        if (font_used(f)) {
+            font_param_error(f);
+        } else {
+            /*tex Increase the number of parameters in the font. */
+            do {
+                set_font_param(f, (font_params(f) + 1), 0);
+            } while (n != font_params(f));
+        }
+    }
+    scan_optional_equals();
+    scan_normal_dimen();
+    set_font_param(f, n, cur_val);
+}
+
+void get_font_dimen(void)
+{
+    internal_font_number f;
+    /*tex The parameter number: */
+    int n;
+    scan_int();
+    n = cur_val;
+    scan_font_ident();
+    f = cur_val;
+    /*tex Initialize return value: */
+    cur_val = 0;
+    if (n <= 0) {
+        font_param_error(f);
+        goto EXIT;
+    } else if (n > font_params(f)) {
+        if (font_used(f)) {
+            font_param_error(f);
+            goto EXIT;
+        } else {
+            /*tex Increase the number of parameters in the font. */
+            do {
+                set_font_param(f, (font_params(f) + 1), 0);
+            } while (n != font_params(f));
+        }
+    }
+    cur_val = font_param(f, n);
+  EXIT:
+    scanned_result(cur_val, dimen_val_level);
+}
+
+/*tex
+
+    Here's a similar procedure that returns a pointer to a rule node. This
+    routine is called just after \TeX\ has seen \.{\\hrule} or \.{\\vrule};
+    therefore |cur_cmd| will be either |hrule| or |vrule|. The idea is to store
+    the default rule dimensions in the node, then to override them if
+    `\.{height}' or `\.{width}' or `\.{depth}' specifications are found (in any
+    order).
+
+*/
+
+halfword scan_rule_spec(void)
+{
+    /*tex |width|, |depth|, and |height| all equal |null_flag| now */
+    halfword q;
+    if (cur_cmd == no_vrule_cmd) {
+        q = new_rule(empty_rule);
+        cur_cmd = vrule_cmd;
+    } else if (cur_cmd == no_hrule_cmd) {
+        q = new_rule(empty_rule);
+        cur_cmd = hrule_cmd;
+    } else {
+        q = new_rule(normal_rule);
+    }
+    if (cur_cmd == vrule_cmd) {
+        width(q) = default_rule;
+        rule_dir(q) = body_direction_par;
+    } else {
+        height(q) = default_rule;
+        depth(q) = 0;
+        rule_dir(q) = text_direction_par;
+    }
+  RESWITCH:
+    if (scan_keyword("width")) {
+        scan_normal_dimen();
+        width(q) = cur_val;
+        goto RESWITCH;
+    }
+    if (scan_keyword("height")) {
+        scan_normal_dimen();
+        height(q) = cur_val;
+        goto RESWITCH;
+    }
+    if (scan_keyword("depth")) {
+        scan_normal_dimen();
+        depth(q) = cur_val;
+        goto RESWITCH;
+    }
+    return q;
+}
+
+/*tex Declare procedures that scan font-related stuff. */
+
+void scan_font_ident(void)
+{
+    internal_font_number f;
+    halfword m;
+    /*tex Get the next non-blank non-call. */
+    do {
+        get_x_token();
+    } while (cur_cmd == spacer_cmd);
+    if ((cur_cmd == def_font_cmd) || (cur_cmd == letterspace_font_cmd) || (cur_cmd == copy_font_cmd)) {
+        f = get_cur_font();
+    } else if (cur_cmd == set_font_cmd) {
+        f = cur_chr;
+        set_font_touched(f, 1);
+    } else if (cur_cmd == def_family_cmd) {
+        m = cur_chr;
+        scan_math_family_int();
+        f = fam_fnt(cur_val, m);
+        set_font_touched(f, 1);
+    } else {
+        print_err("Missing font identifier");
+        help2(
+            "I was looking for a control sequence whose",
+            "current meaning has been defined by \\font."
+        );
+        back_error();
+        f = null_font;
+    }
+    cur_val = f;
+}
+
+/*tex
+
+    The |scan_general_text| procedure is much like |scan_toks(false,false)|, but
+    will be invoked via |expand|, i.e., recursively.
+
+    The token list (balanced text) created by |scan_general_text| begins at
+    |link(temp_token_head)| and ends at |cur_val|. (If |cur_val=temp_token_head|,
+    the list is empty.)
+
+*/
+
+void scan_general_text(void)
+{
+    /*tex Here we save |scanner_status|: */
+    int s;
+    /*tex Here we save |warning_index|: */
+    halfword w;
+    /*tex Here we save |def_ref|: */
+    halfword d;
+    /*tex The tail of the token list being built: */
+    halfword p;
+    /*tex The new node being added to the token list via |store_new_token|: */
+    halfword q;
+    /*tex The number of unmatched left braces: */
+    halfword unbalance;
+    s = scanner_status;
+    w = warning_index;
+    d = def_ref;
+    scanner_status = absorbing;
+    warning_index = cur_cs;
+    p = get_avail();
+    def_ref = p;
+    set_token_ref_count(def_ref, 0);
+    p = def_ref;
+    /*tex Remove the compulsory left brace. */
+    scan_left_brace();
+    unbalance = 1;
+    while (1) {
+        get_token();
+        if (cur_tok < right_brace_limit) {
+            if (cur_cmd < right_brace_cmd) {
+                incr(unbalance);
+            } else {
+                decr(unbalance);
+                if (unbalance == 0)
+                    break;
+            }
+        }
+        store_new_token(cur_tok);
+    }
+    q = token_link(def_ref);
+    /*tex Discard reference count. */
+    free_avail(def_ref);
+    if (q == null)
+        cur_val = temp_token_head;
+    else
+        cur_val = p;
+    set_token_link(temp_token_head, q);
+    scanner_status = s;
+    warning_index = w;
+    def_ref = d;
+}
+
+/*tex
+
+    The |get_x_or_protected| procedure is like |get_x_token| except that
+    protected macros are not expanded. It sets |cur_cmd|, |cur_chr|,
+    |cur_tok|,and expands non-protected macros.
+
+*/
+
+void get_x_or_protected(void)
+{
+
+    while (1) {
+        get_token();
+        if (cur_cmd <= max_command_cmd)
+            return;
+        if ((cur_cmd >= call_cmd) && (cur_cmd < end_template_cmd)) {
+            if (token_info(token_link(cur_chr)) == protected_token)
+                return;
+        }
+        expand();
+    }
+}
+
+/*tex
+
+    |scan_toks|. This function returns a pointer to the tail of a new token list,
+    and it also makes |def_ref| point to the reference count at the head of that
+    list.
+
+    There are two boolean parameters, |macro_def| and |xpand|. If |macro_def| is
+    true, the goal is to create the token list for a macro definition; otherwise
+    the goal is to create the token list for some other \TeX\ primitive:
+    \.{\\mark}, \.{\\output}, \.{\\everypar}, \.{\\lowercase}, \.{\\uppercase},
+    \.{\\message}, \.{\\errmessage}, \.{\\write}, or \.{\\special}. In the latter
+    cases a left brace must be scanned next; this left brace will not be part of
+    the token list, nor will the matching right brace that comes at the end. If
+    |xpand| is false, the token list will simply be copied from the input using
+    |get_token|. Otherwise all expandable tokens will be expanded until
+    unexpandable tokens are left, except that the results of expanding
+    `\.{\\the}' are not expanded further. If both |macro_def| and |xpand| are
+    true, the expansion applies only to the macro body (i.e., to the material
+    following the first |left_brace| character).
+
+    The value of |cur_cs| when |scan_toks| begins should be the |eqtb| address of
+    the control sequence to display in ``runaway'' error messages.
+
+*/
+
+halfword scan_toks(boolean macro_def, boolean xpand)
+{
+    /*tex token representing the highest parameter number */
+    halfword t;
+    /*tex saved token */
+    halfword s;
+    /*tex tail of the token list being built */
+    halfword p;
+    /*tex new node being added to the token list via |store_new_token| */
+    halfword q;
+    /*tex number of unmatched left braces */
+    halfword unbalance;
+    /*tex possible `\.{\#\{}' token */
+    halfword hash_brace;
+    if (macro_def)
+        scanner_status = defining;
+    else
+        scanner_status = absorbing;
+    warning_index = cur_cs;
+    p = get_avail();
+    def_ref = p;
+    set_token_ref_count(def_ref, 0);
+    p = def_ref;
+    hash_brace = 0;
+    t = zero_token;
+    if (macro_def) {
+        /*tex Scan and build the parameter part of the macro definition. */
+        while (1) {
+            /*tex Set |cur_cmd|, |cur_chr|, |cur_tok|: */
+            get_token();
+            if (cur_tok < right_brace_limit)
+                break;
+            if (cur_cmd == mac_param_cmd) {
+                /*tex
+
+                        If the next character is a parameter number, make
+                        |cur_tok| a |match| token; but if it is a left brace,
+                        store `|left_brace|, |end_match|', set |hash_brace|, and
+                        |goto done|.
+
+                */
+                s = match_token + cur_chr;
+                get_token();
+                if (cur_cmd == left_brace_cmd) {
+                    hash_brace = cur_tok;
+                    store_new_token(cur_tok);
+                    store_new_token(end_match_token);
+                    goto DONE;
+                }
+                if (t == nine_token) {
+                    print_err("You already have nine parameters");
+                    help1("I'm going to ignore the # sign you just used.");
+                    error();
+                } else {
+                    incr(t);
+                    if (cur_tok != t) {
+                        print_err("Parameters must be numbered consecutively");
+                        help2(
+                            "I've inserted the digit you should have used after the #.",
+                            "Type `1' to delete what you did use."
+                        );
+                        back_error();
+                    }
+                    cur_tok = s;
+                }
+            }
+            store_new_token(cur_tok);
+        }
+        store_new_token(end_match_token);
+        if (cur_cmd == right_brace_cmd) {
+            /*tex Express shock at the missing left brace; |goto found|. */
+            print_err("Missing { inserted");
+            incr(align_state);
+            help2(
+                "Where was the left brace? You said something like `\\def\\a}',",
+                "which I'm going to interpret as `\\def\\a{}'."
+            );
+            error();
+            goto FOUND;
+        }
+
+    } else {
+        /*tex Remove the compulsory left brace. */
+        scan_left_brace();
+    }
+  DONE:
+    /*tex Scan and build the body of the token list; |goto found| when finished. */
+    unbalance = 1;
+    while (1) {
+        if (xpand) {
+            /*tex
+
+                Expand the next part of the input. Here we insert an entire token
+                list created by |the_toks| without expanding it further.
+
+            */
+            while (1) {
+                get_next();
+                if (cur_cmd >= call_cmd) {
+                    if (token_info(token_link(cur_chr)) == protected_token) {
+                        cur_cmd = relax_cmd;
+                        cur_chr = no_expand_flag;
+                    }
+                }
+                if (cur_cmd <= max_command_cmd)
+                    break;
+                if (cur_cmd != the_cmd) {
+                    expand();
+                } else {
+                    q = the_toks();
+                    if (token_link(temp_token_head) != null) {
+                        set_token_link(p, token_link(temp_token_head));
+                        p = q;
+                    }
+                }
+            }
+            x_token();
+        } else {
+            get_token();
+        }
+        if (cur_tok < right_brace_limit) {
+            if (cur_cmd < right_brace_cmd) {
+                incr(unbalance);
+            } else {
+                decr(unbalance);
+                if (unbalance == 0)
+                    goto FOUND;
+            }
+        } else if (cur_cmd == mac_param_cmd) {
+            if (macro_def) {
+                /*tex Look for parameter number or \.{\#\#}. */
+                s = cur_tok;
+                if (xpand)
+                    get_x_token();
+                else
+                    get_token();
+                if (cur_cmd != mac_param_cmd) {
+                    if ((cur_tok <= zero_token) || (cur_tok > t)) {
+                        print_err("Illegal parameter number in definition of ");
+                        sprint_cs(warning_index);
+                        help3(
+                            "You meant to type ## instead of #, right?",
+                            "Or maybe a } was forgotten somewhere earlier, and things",
+                            "are all screwed up? I'm going to assume that you meant ##."
+                        );
+                        back_error();
+                        cur_tok = s;
+                    } else {
+                        cur_tok = out_param_token - '0' + cur_chr;
+                    }
+                }
+            }
+        }
+        store_new_token(cur_tok);
+    }
+  FOUND:
+    scanner_status = normal;
+    if (hash_brace != 0)
+        store_new_token(hash_brace);
+    return p;
+}
+
+/*tex
+
+    Here we declare two trivial procedures in order to avoid mutually recursive
+    procedures with parameters.
+
+*/
+
+void scan_normal_glue(void)
+{
+    scan_glue(glue_val_level);
+}
+
+void scan_mu_glue(void)
+{
+    scan_glue(mu_val_level);
+}
+
+/*tex
+
+    The |scan_expr| procedure scans and evaluates an expression. Evaluating an
+    expression is a recursive process: When the left parenthesis of a
+    subexpression is scanned we descend to the next level of recursion; the
+    previous level is resumed with the matching right parenthesis.
+
+*/
+
+typedef enum {
+    /*tex \.( seen, or \.( $\langle\it expr\rangle$ \.) seen */
+    expr_none  = 0,
+    /*tex \.( $\langle\it expr\rangle$ \.+ seen */
+    expr_add   = 1,
+    /*tex \.( $\langle\it expr\rangle$ \.- seen */
+    expr_sub   = 2,
+    /*tex $\langle\it term\rangle$ \.* seen */
+    expr_mult  = 3,
+    /*tex $\langle\it term\rangle$ \./ seen */
+    expr_div   = 4,
+    /*tex $\langle\it term\rangle$ \.* $\langle\it factor\rangle$ \./ seen */
+    expr_scale = 5,
+} expression_states;
+
+/*tex
+
+    We want to make sure that each term and (intermediate) result is in the
+    proper range. Integer values must not exceed |infinity| ($2^{31}-1$) in
+    absolute value, dimensions must not exceed |max_dimen| ($2^{30}-1$). We avoid
+    the absolute value of an integer, because this might fail for the value
+    $-2^{31}$ using 32-bit arithmetic.
+
+*/
+
+/* Clear a number or dimension and set |arith_error|: */
+
+#define num_error(A) do { \
+    arith_error=true; \
+    A=0; \
+} while (0)
+
+/*tex Clear a glue spec and set |arith_error|: */
+
+#define glue_error(A) do { \
+    arith_error=true; \
+    reset_glue_to_zero(A); \
+} while (0)
+
+#define normalize_glue(A) do { \
+    if (stretch(A)==0) stretch_order(A)=normal; \
+    if (shrink(A)==0) shrink_order(A)=normal; \
+} while (0)
+
+/*tex
+
+    Parenthesized subexpressions can be inside expressions, and this nesting has
+    a stack. Seven local variables represent the top of the expression stack: |p|
+    points to pushed-down entries, if any; |l| specifies the type of expression
+    currently beeing evaluated; |e| is the expression so far and |r| is the state
+    of its evaluation; |t| is the term so far and |s| is the state of its
+    evaluation; finally |n| is the numerator for a combined multiplication and
+    division, if any.
+
+*/
+
+#define expr_add_sub(A,B,C) add_or_sub((A),(B),(C),(r==expr_sub))
+#define expr_a(A,B) expr_add_sub((A),(B),max_dimen)
+
+/*tex
+
+    The function |add_or_sub(x,y,max_answer,negative)| computes the sum (for
+    |negative=false|) or difference (for |negative=true|) of |x| and |y|,
+    provided the absolute value of the result does not exceed |max_answer|.
+
+*/
+
+inline static int add_or_sub(int x, int y, int max_answer, boolean negative)
+{
+    int a;
+    if (negative)
+        negate(y);
+    if (x >= 0) {
+        if (y <= max_answer - x)
+            a = x + y;
+        else
+            num_error(a);
+    } else if (y >= -max_answer - x) {
+        a = x + y;
+    } else {
+        num_error(a);
+    }
+    return a;
+}
+
+#define expr_m(A) A = nx_plus_y((A),f,0)
+#define expr_d(A) A=quotient((A),f)
+
+/*tex
+
+    The function |quotient(n,d)| computes the rounded quotient $q=\lfloor
+    n/d+{1\over2}\rfloor$, when $n$ and $d$ are positive.
+
+*/
+
+inline static int quotient(int n, int d)
+{
+    /*tex Should the answer be negated? */
+    boolean negative;
+    /*tex The answer: */
+    int a;
+    if (d == 0) {
+        num_error(a);
+    } else {
+        if (d > 0) {
+            negative = false;
+        } else {
+            negate(d);
+            negative = true;
+        }
+        if (n < 0) {
+            negate(n);
+            negative = !negative;
+        }
+        a = n / d;
+        n = n - a * d;
+        /*tex Avoid certain compiler optimizations! */
+        d = n - d;
+        if (d + n >= 0)
+            incr(a);
+        if (negative)
+            negate(a);
+    }
+    return a;
+}
+
+#define expr_s(A) A=fract((A),n,f,max_dimen)
+
+/*tex
+
+    Finally, the function |fract(x,n,d,max_answer)| computes the integer
+    $q=\lfloor xn/d+{1\over2}\rfloor$, when $x$, $n$, and $d$ are positive and
+    the result does not exceed |max_answer|. We can't use floating point
+    arithmetic since the routine must produce identical results in all cases; and
+    it would be too dangerous to multiply by~|n| and then divide by~|d|, in
+    separate operations, since overflow might well occur. Hence this subroutine
+    simulates double precision arithmetic, somewhat analogous to Metafont's
+    |make_fraction| and |take_fraction| routines.
+
+*/
+
+int fract(int x, int n, int d, int max_answer)
+{
+    /*tex should the answer be negated? */
+    boolean negative;
+    /*tex the answer */
+    int a;
+    /*tex a proper fraction */
+    int f;
+    /*tex smallest integer such that |2*h>=d| */
+    int h;
+    /*tex intermediate remainder */
+    int r;
+    /*tex temp variable */
+    int t;
+    if (d == 0)
+        goto TOO_BIG;
+    a = 0;
+    if (d > 0) {
+        negative = false;
+    } else {
+        negate(d);
+        negative = true;
+    }
+    if (x < 0) {
+        negate(x);
+        negative = !negative;
+    } else if (x == 0) {
+        goto DONE;
+    }
+    if (n < 0) {
+        negate(n);
+        negative = !negative;
+    }
+    t = n / d;
+    if (t > max_answer / x)
+        goto TOO_BIG;
+    a = t * x;
+    n = n - t * d;
+    if (n == 0)
+        goto FOUND;
+    t = x / d;
+    if (t > (max_answer - a) / n)
+        goto TOO_BIG;
+    a = a + t * n;
+    x = x - t * d;
+    if (x == 0)
+        goto FOUND;
+    if (x < n) {
+        t = x;
+        x = n;
+        n = t;
+    }
+    /*tex
+
+        Now |0<n<=x<d| and we compute $f=\lfloor xn/d+{1\over2}\rfloor$. The loop
+        here preserves the following invariant relations between |f|, |x|, |n|,
+        and~|r|: (i)~$f+\lfloor(xn+(r+d))/d\rfloor=\lfloor
+        x_0n_0/d+{1\over2}\rfloor$; (ii)~|-d<=r<0<n<=x<d|, where $x_0$, $n_0$ are
+        the original values of~$x$ and $n$.
+
+        Notice that the computation specifies |(x-d)+x| instead of |(x+x)-d|,
+        because the latter could overflow.
+
+    */
+    f = 0;
+    r = (d / 2) - d;
+    h = -r;
+    while (1) {
+        if (odd(n)) {
+            r = r + x;
+            if (r >= 0) {
+                r = r - d;
+                incr(f);
+            }
+        }
+        n = n / 2;
+        if (n == 0)
+            break;
+        if (x < h) {
+            x = x + x;
+        } else {
+            t = x - d;
+            x = t + x;
+            f = f + n;
+            if (x < n) {
+                if (x == 0)
+                    break;
+                t = x;
+                x = n;
+                n = t;
+            }
+        }
+    }
+    if (f > (max_answer - a))
+        goto TOO_BIG;
+    a = a + f;
+  FOUND:
+    if (negative)
+        negate(a);
+    goto DONE;
+  TOO_BIG:
+    num_error(a);
+  DONE:
+    return a;
+}
+
+/*tex Scans and evaluates an expression: */
+
+static void scan_expr(void)
+{
+    /*tex saved values of |arith_error| */
+    boolean a, b;
+    /*tex type of expression */
+    int l;
+    /*tex state of expression so far */
+    int r;
+    /*tex state of term so far */
+    int s;
+    /*tex next operation or type of next factor */
+    int o;
+    /*tex expression so far */
+    int e;
+    /*tex term so far */
+    int t;
+    /*tex current factor */
+    int f;
+    /*tex numerator of combined multiplication and division */
+    int n;
+    /*tex top of expression stack */
+    halfword p;
+    /*tex for stack manipulations */
+    halfword q;
+    l = cur_val_level;
+    a = arith_error;
+    b = false;
+    p = null;
+    /*tex Scan and evaluate an expression |e| of type |l|. */
+  RESTART:
+    r = expr_none;
+    e = 0;
+    s = expr_none;
+    t = 0;
+    n = 0;
+  CONTINUE:
+    if (s == expr_none)
+        o = l;
+    else
+        o = int_val_level;
+    /*tex
+
+        Scan a factor |f| of type |o| or start a subexpression. Get the next
+        non-blank non-call token.
+
+    */
+    do {
+        get_x_token();
+    } while (cur_cmd == spacer_cmd);
+
+    if (cur_tok == other_token + '(') {
+        /*tex Push the expression stack and |goto restart|. */
+        q = new_node(expr_node, 0);
+        vlink(q) = p;
+        expr_type(q) = (quarterword) l;
+        expr_state(q) = (quarterword) (4 * s + r);
+        expr_e_field(q) = e;
+        expr_t_field(q) = t;
+        expr_n_field(q) = n;
+        p = q;
+        l = o;
+        goto RESTART;
+    }
+    back_input();
+    if ((o == int_val_level) || (o == attr_val_level))
+        scan_int();
+    else if (o == dimen_val_level)
+        scan_normal_dimen();
+    else if (o == glue_val_level)
+        scan_normal_glue();
+    else
+        scan_mu_glue();
+    f = cur_val;
+
+  FOUND:
+    /*tex
+
+        Scan the next operator and set |o| and Get the next non-blank non-call
+        token.
+
+    */
+    do {
+        get_x_token();
+    } while (cur_cmd == spacer_cmd);
+
+    if (cur_tok == other_token + '+') {
+        o = expr_add;
+    } else if (cur_tok == other_token + '-') {
+        o = expr_sub;
+    } else if (cur_tok == other_token + '*') {
+        o = expr_mult;
+    } else if (cur_tok == other_token + '/') {
+        o = expr_div;
+    } else {
+        o = expr_none;
+        if (p == null) {
+            if (cur_cmd != relax_cmd)
+                back_input();
+        } else if (cur_tok != other_token + ')') {
+            print_err("Missing ) inserted for expression");
+            help1("I was expecting to see `+', `-', `*', `/', or `)'. Didn't.");
+            back_error();
+        }
+    }
+    arith_error = b;
+    /*tex Make sure that |f| is in the proper range. */
+    if (((l == int_val_level) || (l == attr_val_level)) || (s > expr_sub)) {
+        if ((f > infinity) || (f < -infinity))
+            num_error(f);
+    } else if (l == dimen_val_level) {
+        if (abs(f) > max_dimen)
+            num_error(f);
+    } else {
+        if ((abs(width(f)) > max_dimen) || (abs(stretch(f)) > max_dimen) || (abs(shrink(f)) > max_dimen))
+            glue_error(f);
+    }
+    /*tex Cases for evaluation of the current term. */
+    switch (s) {
+        case expr_none:
+            /*tex
+
+                Applying the factor |f| to the partial term |t| (with the
+                operator |s|) is delayed until the next operator |o| has been
+                scanned. Here we handle the first factor of a partial term. A
+                glue spec has to be copied unless the next operator is a right
+                parenthesis; this allows us later on to simply modify the glue
+                components.
+
+            */
+            t = f;
+            if ((l >= glue_val_level) && (o != expr_none)) {
+                /*tex Do we really need to copy here? */
+                normalize_glue(t);
+            } else {
+                t = f;
+            }
+            break;
+        case expr_mult:
+            /*tex
+
+                If a multiplication is followed by a division, the two operations
+                are combined into a `scaling' operation. Otherwise the term |t|
+                is multiplied by the factor |f|.
+
+            */
+            if (o == expr_div) {
+                n = f;
+                o = expr_scale;
+            } else if ((l == int_val_level) || (l == attr_val_level)) {
+                t = mult_integers(t, f);
+            } else if (l == dimen_val_level) {
+                expr_m(t);
+            } else {
+                expr_m(width(t));
+                expr_m(stretch(t));
+                expr_m(shrink(t));
+            }
+            break;
+        case expr_div:
+            /*tex Here we divide the term |t| by the factor |f|. */
+            if (l < glue_val_level) {
+                expr_d(t);
+            } else {
+                expr_d(width(t));
+                expr_d(stretch(t));
+                expr_d(shrink(t));
+            }
+            break;
+        case expr_scale:
+            /*tex Here the term |t| is multiplied by the quotient $n/f$. */
+            if ((l == int_val_level) || (l == attr_val_level)) {
+                t = fract(t, n, f, infinity);
+            } else if (l == dimen_val_level) {
+                expr_s(t);
+            } else {
+                expr_s(width(t));
+                expr_s(stretch(t));
+                expr_s(shrink(t));
+            }
+            break;
+    }
+    if (o > expr_sub) {
+        s = o;
+    } else {
+        /*tex
+
+            Evaluate the current expression. When a term |t| has been completed
+            it is copied to, added to, or subtracted from the expression |e|.
+
+        */
+        s = expr_none;
+        if (r == expr_none) {
+            e = t;
+        } else if ((l == int_val_level) || (l == attr_val_level)) {
+            e = expr_add_sub(e, t, infinity);
+        } else if (l == dimen_val_level) {
+            e = expr_a(e, t);
+        } else {
+            /*tex
+
+                Compute the sum or difference of two glue specs. We know that
+                |stretch_order(e)>normal| implies |stretch(e)<>0| and
+                |shrink_order(e)>normal| implies |shrink(e)<>0|.
+
+            */
+            width(e) = expr_a(width(e), width(t));
+            if (stretch_order(e) == stretch_order(t)) {
+                stretch(e) = expr_a(stretch(e), stretch(t));
+            } else if ((stretch_order(e) < stretch_order(t)) && (stretch(t) != 0)) {
+                stretch(e) = stretch(t);
+                stretch_order(e) = stretch_order(t);
+            }
+            if (shrink_order(e) == shrink_order(t)) {
+                shrink(e) = expr_a(shrink(e), shrink(t));
+            } else if ((shrink_order(e) < shrink_order(t)) && (shrink(t) != 0)) {
+                shrink(e) = shrink(t);
+                shrink_order(e) = shrink_order(t);
+            }
+            flush_node(t);
+            normalize_glue(e);
+        }
+        r = o;
+    }
+    b = arith_error;
+    if (o != expr_none)
+        goto CONTINUE;
+    if (p != null) {
+        /*tex Pop the expression stack and |goto found|. */
+        f = e;
+        q = p;
+        e = expr_e_field(q);
+        t = expr_t_field(q);
+        n = expr_n_field(q);
+        s = expr_state(q) / 4;
+        r = expr_state(q) % 4;
+        l = expr_type(q);
+        p = vlink(q);
+        flush_node(q);
+        goto FOUND;
+    }
+
+    if (b) {
+        print_err("Arithmetic overflow");
+        help2(
+            "I can't evaluate this expression,",
+            "since the result is out of range."
+        );
+        error();
+        if (l >= glue_val_level) {
+            reset_glue_to_zero(e);
+        } else {
+            e = 0;
+        }
+    }
+    arith_error = a;
+    cur_val = e;
+    cur_val_level = l;
+}
diff --git a/texk/web2c/luatexdir/tex/scanning.w b/texk/web2c/luatexdir/tex/scanning.w
deleted file mode 100644
index 7bed4d290..000000000
--- a/texk/web2c/luatexdir/tex/scanning.w
+++ /dev/null
@@ -1,2621 +0,0 @@
-% scanning.w
-%
-% Copyright 2009-2012 Taco Hoekwater <taco@@luatex.org>
-%
-% This file is part of LuaTeX.
-%
-% LuaTeX is free software; you can redistribute it and/or modify it under
-% the terms of the GNU General Public License as published by the Free
-% Software Foundation; either version 2 of the License, or (at your
-% option) any later version.
-%
-% LuaTeX is distributed in the hope that it will be useful, but WITHOUT
-% ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-% FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
-% License for more details.
-%
-% You should have received a copy of the GNU General Public License along
-% with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
-
-@ @c
-
-#include "ptexlib.h"
-
-@ @c
-static void scan_expr(void);
-
-@ Let's turn now to some procedures that \TeX\ calls upon frequently to digest
-certain kinds of patterns in the input. Most of these are quite simple;
-some are quite elaborate. Almost all of the routines call |get_x_token|,
-which can cause them to be invoked recursively.
-
-The |scan_left_brace| routine is called when a left brace is supposed to be
-the next non-blank token. (The term ``left brace'' means, more precisely,
-a character whose catcode is |left_brace|.) \TeX\ allows \.{\\relax} to
-appear before the |left_brace|.
-
-@c
-void scan_left_brace(void)
-{                               /* reads a mandatory |left_brace| */
-    /* Get the next non-blank non-relax non-call token */
-    do {
-        get_x_token();
-    } while ((cur_cmd == spacer_cmd) || (cur_cmd == relax_cmd));
-
-    if (cur_cmd != left_brace_cmd) {
-        print_err("Missing { inserted");
-        help4("A left brace was mandatory here, so I've put one in.",
-              "You might want to delete and/or insert some corrections",
-              "so that I will find a matching right brace soon.",
-              "If you're confused by all this, try typing `I}' now.");
-        back_error();
-        cur_tok = left_brace_token + '{';
-        cur_cmd = left_brace_cmd;
-        cur_chr = '{';
-        incr(align_state);
-    }
-}
-
-@ The |scan_optional_equals| routine looks for an optional `\.=' sign preceded
-by optional spaces; `\.{\\relax}' is not ignored here.
-
-@c
-void scan_optional_equals(void)
-{
-    /* Get the next non-blank non-call token */
-    do {
-        get_x_token();
-    } while (cur_cmd == spacer_cmd);
-    if (cur_tok != other_token + '=')
-        back_input();
-}
-
-@ Here is a procedure that sounds an alarm when mu and non-mu units
-are being switched.
-
-@c
-static void mu_error(void)
-{
-    print_err("Incompatible glue units");
-    help1("I'm going to assume that 1mu=1pt when they're mixed.");
-    error();
-}
-
-@ The next routine `|scan_something_internal|' is used to fetch internal
-numeric quantities like `\.{\\hsize}', and also to handle the `\.{\\the}'
-when expanding constructions like `\.{\\the\\toks0}' and
-`\.{\\the\\baselineskip}'. Soon we will be considering the |scan_int|
-procedure, which calls |scan_something_internal|; on the other hand,
-|scan_something_internal| also calls |scan_int|, for constructions like
-`\.{\\catcode\`\\\$}' or `\.{\\fontdimen} \.3 \.{\\ff}'. So we
-have to declare |scan_int| as a |forward| procedure. A few other
-procedures are also declared at this point.
-
-\TeX\ doesn't know exactly what to expect when
-|scan_something_internal| begins.  For example, an integer or
-dimension or glue value could occur immediately after `\.{\\hskip}';
-and one can even say \.{\\the} with respect to token lists in
-constructions like `\.{\\xdef\\o\{\\the\\output\}}'.  On the other
-hand, only integers are allowed after a construction like
-`\.{\\count}'. To handle the various possibilities,
-|scan_something_internal| has a |level| parameter, which tells the
-``highest'' kind of quantity that |scan_something_internal| is allowed
-to produce. Eight levels are distinguished, namely |int_val|,
-|attr_val|, |dimen_val|, |glue_val|, |mu_val|, |dir_val|, |ident_val|,
-and |tok_val|.
-
-The output of |scan_something_internal| (and of the other routines
-|scan_int|, |scan_dimen|, and |scan_glue| below) is put into the global
-variable |cur_val|, and its level is put into |cur_val_level|. The highest
-values of |cur_val_level| are special: |mu_val| is used only when
-|cur_val| points to something in a ``muskip'' register, or to one of the
-three parameters \.{\\thinmuskip}, \.{\\medmuskip}, \.{\\thickmuskip};
-|ident_val| is used only when |cur_val| points to a font identifier;
-|tok_val| is used only when |cur_val| points to |null| or to the reference
-count of a token list. The last two cases are allowed only when
-|scan_something_internal| is called with |level=tok_val|.
-
-If the output is glue, |cur_val| will point to a glue specification, and
-the reference count of that glue will have been updated to reflect this
-reference; if the output is a nonempty token list, |cur_val| will point to
-its reference count, but in this case the count will not have been updated.
-Otherwise |cur_val| will contain the integer or scaled value in question.
-
-@c
-int cur_val;                    /* value returned by numeric scanners */
-int cur_val1;                   /* delcodes are sometimes 51 digits */
-int cur_val_level;              /* the ``level'' of this value */
-
-#define scanned_result(A,B) do { \
-    cur_val=A; \
-    cur_val_level=B; \
-} while (0)
-
-@ When a |glue_val| changes to a |dimen_val|, we use the width component
-of the glue; there is no need to decrease the reference count, since it
-has not yet been increased.  When a |dimen_val| changes to an |int_val|,
-we use scaled points so that the value doesn't actually change. And when a
-|mu_val| changes to a |glue_val|, the value doesn't change either.
-
-@c
-static void downgrade_cur_val(boolean delete_glue)
-{
-    if (cur_val_level == glue_val_level) {
-        halfword m = cur_val;
-        cur_val = width(m);
-        if (delete_glue)
-            flush_node(m);
-    } else if (cur_val_level == mu_val_level) {
-        mu_error();
-    }
-    decr(cur_val_level);
-}
-
-/*
-void negate_cur_val(boolean delete_glue)
-{
-    if (cur_val_level >= glue_val_level) {
-        halfword m = cur_val;
-        cur_val = new_spec(m);
-        if (delete_glue)
-            flush_node(m);
-        negate(width(cur_val));
-        negate(stretch(cur_val));
-        negate(shrink(cur_val));
-    } else {
-        negate(cur_val);
-    }
-}
-*/
-
-void negate_cur_val(boolean modify_glue)
-{
-    if (cur_val_level >= glue_val_level) {
-        if (modify_glue) {
-            /* we modify in-place */
-        } else {
-            cur_val = new_spec(cur_val);
-        }
-        negate(width(cur_val));
-        negate(stretch(cur_val));
-        negate(shrink(cur_val));
-    } else {
-        negate(cur_val);
-    }
-}
-
-@ Some of the internal items can be fetched both routines,
-and these have been split off into the next routine, that
-returns true if the command code was understood
-
-@c
-static boolean short_scan_something_internal(int cmd, int chr, int level,
-                                             boolean negative)
-{
-    halfword m;                 /* |chr_code| part of the operand token */
-    halfword q;                 /* general purpose index */
-    int p;                      /* index into |nest| */
-    int save_cur_chr;
-    boolean succeeded = true;
-    m = chr;
-    switch (cmd) {
-    case assign_toks_cmd:
-        scanned_result(equiv(m), tok_val_level);
-        break;
-    case assign_int_cmd:
-        scanned_result(eqtb[m].cint, int_val_level);
-        break;
-    case assign_attr_cmd:
-        scanned_result(eqtb[m].cint, int_val_level);
-        break;
-    case assign_dir_cmd:
-        if (m == (int_base + line_direction_code)) {
-            m = int_base + text_direction_code;
-        }
-        scanned_result(eqtb[m].cint, dir_val_level);
-        break;
-    case assign_dimen_cmd:
-        scanned_result(eqtb[m].cint, dimen_val_level);
-        break;
-    case assign_glue_cmd:
-        scanned_result(equiv(m), glue_val_level);
-        break;
-    case assign_mu_glue_cmd:
-        scanned_result(equiv(m), mu_val_level);
-        break;
-    case math_style_cmd:
-        scanned_result(m, int_val_level);
-        break;
-    case set_aux_cmd:
-        /* Fetch the |space_factor| or the |prev_depth| */
-        if (abs(cur_list.mode_field) != m) {
-            print_err("Improper ");
-            print_cmd_chr(set_aux_cmd, m);
-            help4("You can refer to \\spacefactor only in horizontal mode;",
-                  "you can refer to \\prevdepth only in vertical mode; and",
-                  "neither of these is meaningful inside \\write. So",
-                  "I'm forgetting what you said and using zero instead.");
-            error();
-            if (level != tok_val_level)
-                scanned_result(0, dimen_val_level);
-            else
-                scanned_result(0, int_val_level);
-        } else if (m == vmode) {
-            scanned_result(prev_depth_par, dimen_val_level);
-        } else {
-            scanned_result(space_factor_par, int_val_level);
-        }
-        break;
-    case set_prev_graf_cmd:
-        /* Fetch the |prev_graf| */
-        if (cur_list.mode_field == 0) {
-            scanned_result(0, int_val_level);   /* |prev_graf=0| within \.{\\write} */
-        } else {
-            p = nest_ptr;
-            while (abs(nest[p].mode_field) != vmode)
-                decr(p);
-            scanned_result(nest[p].pg_field, int_val_level);
-        }
-        break;
-    case set_page_int_cmd:
-        /* Fetch the |dead_cycles| or the |insert_penalties| */
-        if (m == 0)
-            cur_val = dead_cycles;
-        else if (m == 2)
-            cur_val = interaction;      /* interactionmode */
-        else
-            cur_val = insert_penalties;
-        cur_val_level = int_val_level;
-        break;
-    case set_page_dimen_cmd:
-        /* Fetch something on the |page_so_far| */
-        if ((page_contents == empty) && (!output_active)) {
-            if (m == 0)
-                cur_val = max_dimen;
-            else
-                cur_val = 0;
-        } else {
-            cur_val = page_so_far[m];
-        }
-        cur_val_level = dimen_val_level;
-        break;
-    case set_tex_shape_cmd:
-        /* Fetch the |par_shape| size */
-        if (par_shape_par_ptr == null)
-            cur_val = 0;
-        else
-            cur_val = vinfo(par_shape_par_ptr + 1);
-        cur_val_level = int_val_level;
-        break;
-    case set_etex_shape_cmd:
-        /* Fetch a penalties array element */
-        scan_int();
-        if ((equiv(m) == null) || (cur_val < 0)) {
-            cur_val = 0;
-        } else {
-            if (cur_val > penalty(equiv(m)))
-                cur_val = penalty(equiv(m));
-            cur_val = penalty(equiv(m) + cur_val);
-        }
-        cur_val_level = int_val_level;
-        break;
-    case char_given_cmd:
-    case math_given_cmd:
-    case xmath_given_cmd:
-        scanned_result(cur_chr, int_val_level);
-        break;
-    case last_item_cmd:
-        /* Because the items in this case directly refer to |cur_chr|,
-           it needs to be saved and restored */
-        save_cur_chr = cur_chr;
-        cur_chr = chr;
-        /* Fetch an item in the current node, if appropriate */
-        /* Here is where \.{\\lastpenalty}, \.{\\lastkern}, and \.{\\   } are
-           implemented. The reference count for \.{\\lastskip} will be updated later.
-
-           We also handle \.{\\inputlineno} and \.{\\badness} here, because they are
-           legal in similar contexts. */
-
-        if (m >= input_line_no_code) {
-            if (m >= eTeX_glue) {
-                /* Process an expression and |return| */
-                if (m < eTeX_mu) {
-                    switch (m) {
-                    case mu_to_glue_code:
-                        scan_mu_glue();
-                        break;
-                    };          /* there are no other cases */
-                    cur_val_level = glue_val_level;
-                } else if (m < eTeX_expr) {
-                    switch (m) {
-                    case glue_to_mu_code:
-                        scan_normal_glue();
-                        break;
-                    }           /* there are no other cases */
-                    cur_val_level = mu_val_level;
-                } else {
-                    cur_val_level = m - eTeX_expr + int_val_level;
-                    scan_expr();
-                }
-                /* This code for reducing |cur_val_level| and\slash or negating the
-                   result is similar to the one for all the other cases of
-                   |scan_something_internal|; we free a glue_spec when needed.
-                 */
-                while (cur_val_level > level) {
-                    downgrade_cur_val(true);
-                }
-                if (negative) {
-                    /*
-                        we get a new glue spec node with negated values and the old
-                        intermediate is deleted
-                    */
-                    negate_cur_val(true);
-                }
-                return succeeded;
-
-            } else if (m >= eTeX_dim) {
-                switch (m) {
-                case font_char_wd_code:
-                case font_char_ht_code:
-                case font_char_dp_code:
-                case font_char_ic_code:
-                    scan_font_ident();
-                    q = cur_val;
-                    scan_char_num();
-                    if (char_exists(q, cur_val)) {
-                        switch (m) {
-                        case font_char_wd_code:
-                            cur_val = char_width(q, cur_val);
-                            break;
-                        case font_char_ht_code:
-                            cur_val = char_height(q, cur_val);
-                            break;
-                        case font_char_dp_code:
-                            cur_val = char_depth(q, cur_val);
-                            break;
-                        case font_char_ic_code:
-                            cur_val = char_italic(q, cur_val);
-                            break;
-                        }       /* there are no other cases */
-                    } else {
-                        cur_val = 0;
-                    }
-                    break;
-                case par_shape_length_code:
-                case par_shape_indent_code:
-                case par_shape_dimen_code:
-                    q = cur_chr - par_shape_length_code;
-                    scan_int();
-                    if ((par_shape_par_ptr == null) || (cur_val <= 0)) {
-                        cur_val = 0;
-                    } else {
-                        if (q == 2) {
-                            q = cur_val % 2;
-                            cur_val = (cur_val + q) / 2;
-                        }
-                        if (cur_val > vinfo(par_shape_par_ptr + 1))
-                            cur_val = vinfo(par_shape_par_ptr + 1);
-                        cur_val =
-                            varmem[par_shape_par_ptr + 2 * cur_val - q + 1].cint;
-                    }
-                    cur_val_level = dimen_val_level;
-                    break;
-                case glue_stretch_code:
-                case glue_shrink_code:
-                    scan_normal_glue();
-                    q = cur_val;
-                    if (m == glue_stretch_code)
-                        cur_val = stretch(q);
-                    else
-                        cur_val = shrink(q);
-                    flush_node(q);
-                    break;
-                }               /* there are no other cases */
-                cur_val_level = dimen_val_level;
-            } else {
-                switch (m) {
-                case input_line_no_code:
-                    cur_val = line;
-                    break;
-                case badness_code:
-                    cur_val = last_badness;
-                    break;
-                case luatex_version_code:
-                    cur_val = get_luatexversion();
-                    break;
-                case last_saved_box_resource_index_code:
-                    cur_val = last_saved_box_index;
-                    break;
-                case last_saved_image_resource_index_code:
-                    cur_val = last_saved_image_index;
-                    break;
-                case last_saved_image_resource_pages_code:
-                    cur_val = last_saved_image_pages;
-                    break;
-                case last_x_pos_code:
-                    cur_val = last_position.h;
-                    break;
-                case last_y_pos_code:
-                    cur_val = last_position.v;
-                    break;
-                case random_seed_code:
-                    cur_val = random_seed;
-                    break;
-                case eTeX_version_code:
-                    cur_val = eTeX_version;
-                    break;
-                case eTeX_minor_version_code:
-                    cur_val = eTeX_minor_version;
-                    break;
-                case current_group_level_code:
-                    cur_val = cur_level - level_one;
-                    break;
-                case current_group_type_code:
-                    cur_val = cur_group;
-                    break;
-                case current_if_level_code:
-                    q = cond_ptr;
-                    cur_val = 0;
-                    while (q != null) {
-                        incr(cur_val);
-                        q = vlink(q);
-                    }
-                    break;
-                case current_if_type_code:
-                    if (cond_ptr == null)
-                        cur_val = 0;
-                    else if (cur_if < unless_code)
-                        cur_val = cur_if + 1;
-                    else
-                        cur_val = -(cur_if - unless_code + 1);
-                    break;
-                case current_if_branch_code:
-                    if ((if_limit == or_code) || (if_limit == else_code))
-                        cur_val = 1;
-                    else if (if_limit == fi_code)
-                        cur_val = -1;
-                    else
-                        cur_val = 0;
-                    break;
-                case glue_stretch_order_code:
-                case glue_shrink_order_code:
-                    scan_normal_glue();
-                    q = cur_val;
-                    if (m == glue_stretch_order_code)
-                        cur_val = stretch_order(q);
-                    else
-                        cur_val = shrink_order(q);
-                    flush_node(q);
-                    break;
-                }               /* there are no other cases */
-                cur_val_level = int_val_level;
-            }
-        } else {
-            if (cur_chr == glue_val_level)
-                cur_val = zero_glue; /* a pointer */
-            else
-                cur_val = 0;
-            if (cur_chr == last_node_type_code) {
-                cur_val_level = int_val_level;
-                if ((cur_list.tail_field == cur_list.head_field)
-                    || (cur_list.mode_field == 0))
-                    cur_val = -1;
-            } else {
-                cur_val_level = cur_chr;        /* assumes identical values */
-            }
-            if ((cur_list.tail_field != contrib_head) &&
-                !is_char_node(cur_list.tail_field) &&
-                (cur_list.mode_field != 0)) {
-                switch (cur_chr) {
-                case lastpenalty_code:
-                    if (type(cur_list.tail_field) == penalty_node)
-                        cur_val = penalty(cur_list.tail_field);
-                    break;
-                case lastkern_code:
-                    if (type(cur_list.tail_field) == kern_node)
-                        cur_val = width(cur_list.tail_field);
-                    break;
-                case lastskip_code:
-                    if (type(cur_list.tail_field) == glue_node)
-                     // cur_val = new_spec(cur_list.tail_field);
-                        cur_val = cur_list.tail_field;
-                    if (subtype(cur_list.tail_field) == mu_glue)
-                        cur_val_level = mu_val_level;
-                    break;
-                case last_node_type_code:
-                    cur_val = visible_last_node_type(cur_list.tail_field);
-                    break;
-                }               /* there are no other cases */
-            } else if ((cur_list.mode_field == vmode)
-                       && (cur_list.tail_field == cur_list.head_field)) {
-                switch (cur_chr) {
-                case lastpenalty_code:
-                    cur_val = last_penalty;
-                    break;
-                case lastkern_code:
-                    cur_val = last_kern;
-                    break;
-                case lastskip_code:
-                    if (last_glue != max_halfword)
-                        cur_val = last_glue;
-                    break;
-                case last_node_type_code:
-                    cur_val = last_node_type;
-                    break;
-                }               /* there are no other cases */
-            }
-        }
-        cur_chr = save_cur_chr;
-        break;
-    default:
-        succeeded = false;
-    }
-    if (succeeded) {
-        while (cur_val_level > level) {
-            /* Convert |cur_val| to a lower level */
-            downgrade_cur_val(false);
-        }
-        /* Fix the reference count, if any, and negate |cur_val| if |negative| */
-        /* If |cur_val| points to a glue specification at this point, the reference
-           count for the glue does not yet include the reference by |cur_val|.
-           If |negative| is |true|, |cur_val_level| is known to be |<=mu_val|.
-         */
-        if (negative) {
-            /* we create a new (negated) glue spec and keep the old one */
-            negate_cur_val(false);
-        } else if ((cur_val_level >= glue_val_level) && (cur_val_level <= mu_val_level)) {
-			cur_val = new_spec(cur_val);
-        }
-    }
-    return succeeded;
-}
-
-@ First, here is a short routine that is called from lua code. All
-the  real work is delegated to |short_scan_something_internal| that
-is shared between this routine and |scan_something_internal|.
-
-@c
-void scan_something_simple(halfword cmd, halfword subitem)
-{
-    /* negative is never true */
-    if (!short_scan_something_internal(cmd, subitem, tok_val_level, false)) {
-        /* Complain that |texlib| can not do this; give zero result */
-        print_err("You can't use `");
-        print_cmd_chr((quarterword) cmd, subitem);
-        tprint("' as tex library index");
-        help1("I'm forgetting what you said and using zero instead.");
-        error();
-        scanned_result(0, int_val_level);
-    }
-}
-
-@ OK, we're ready for |scan_something_internal| itself. A second parameter,
-|negative|, is set |true| if the value that is found should be negated.
-It is assumed that |cur_cmd| and |cur_chr| represent the first token of
-the internal quantity to be scanned; an error will be signalled if
-|cur_cmd<min_internal| or |cur_cmd>max_internal|.
-
-@c
-void scan_something_internal(int level, boolean negative)
-{
-    /* fetch an internal parameter */
-    halfword m;                 /* |chr_code| part of the operand token */
-    int n, k;                   /* accumulators */
-  RESTART:
-    m = cur_chr;
-    if (!short_scan_something_internal(cur_cmd, cur_chr, level, negative)) {
-        switch (cur_cmd) {
-        case def_char_code_cmd:
-            /* Fetch a character code from some table */
-            scan_char_num();
-            if (m == math_code_base) {
-                cur_val1 = get_math_code_num(cur_val);
-                scanned_result(cur_val1, int_val_level);
-            } else if (m == lc_code_base) {
-                cur_val1 = get_lc_code(cur_val);
-                scanned_result(cur_val1, int_val_level);
-            } else if (m == uc_code_base) {
-                cur_val1 = get_uc_code(cur_val);
-                scanned_result(cur_val1, int_val_level);
-            } else if (m == sf_code_base) {
-                cur_val1 = get_sf_code(cur_val);
-                scanned_result(cur_val1, int_val_level);
-            } else if (m == cat_code_base) {
-                cur_val1 = get_cat_code(cat_code_table_par, cur_val);
-                scanned_result(cur_val1, int_val_level);
-            } else {
-                confusion("def_char");
-            }
-            break;
-        case def_del_code_cmd:
-        case extdef_del_code_cmd: /* bonus */
-            /* Fetch a character code from some table */
-            scan_char_num();
-            cur_val1 = get_del_code_num(cur_val);
-            scanned_result(cur_val1, int_val_level);
-            break;
-        case extdef_math_code_cmd:
-            /* Fetch an extended math code table value */
-            scan_char_num();
-            cur_val1 = get_math_code_num(cur_val);
-            scanned_result(cur_val1, int_val_level);
-            break;
-        case toks_register_cmd:
-        case set_font_cmd:
-        case def_font_cmd:
-        case letterspace_font_cmd:
-        case copy_font_cmd:
-            /* Fetch a token list or font identifier, provided that |level=tok_val| */
-            if (level != tok_val_level) {
-                print_err("Missing number, treated as zero");
-                help3("A number should have been here; I inserted `0'.",
-                      "(If you can't figure out why I needed to see a number,",
-                      "look up `weird error' in the index to The TeXbook.)");
-                back_error();
-                scanned_result(0, dimen_val_level);
-            } else if (cur_cmd == toks_register_cmd) {
-                scan_register_num();
-                m = toks_base + cur_val;
-                scanned_result(equiv(m), tok_val_level);
-            } else {
-                back_input();
-                scan_font_ident();
-                scanned_result(font_id_base + cur_val, ident_val_level);
-            }
-            break;
-        case set_font_id_cmd:
-            scan_int();
-            scanned_result(font_id_base + cur_val, ident_val_level);
-            break;
-        case def_family_cmd:
-            /* Fetch a math font identifier */
-            scan_char_num();
-            cur_val1 = fam_fnt(cur_val, m);
-            scanned_result(font_id_base + cur_val1, ident_val_level);
-            break;
-        case set_math_param_cmd:
-            /* Fetch a math param */
-            cur_val1 = cur_chr;
-            get_token();
-            if (cur_cmd != math_style_cmd) {
-                print_err("Missing math style, treated as \\displaystyle");
-                help1("A style should have been here; I inserted `\\displaystyle'.");
-                cur_val = display_style;
-                back_error();
-            } else {
-                cur_val = cur_chr;
-            }
-            if (cur_val1 < math_param_first_mu_glue) {
-                if (cur_val1 == math_param_radical_degree_raise) {
-                    cur_val1 = get_math_param(cur_val1, cur_chr);
-                    scanned_result(cur_val1, int_val_level);
-                } else {
-                    cur_val1 = get_math_param(cur_val1, cur_chr);
-                    scanned_result(cur_val1, dimen_val_level);
-                }
-            } else {
-                cur_val1 = get_math_param(cur_val1, cur_chr);
-                if (cur_val1 == thin_mu_skip_code)
-                    cur_val1 = thin_mu_skip_par;
-                else if (cur_val1 == med_mu_skip_code)
-                    cur_val1 = med_mu_skip_par;
-                else if (cur_val1 == thick_mu_skip_code)
-                    cur_val1 = thick_mu_skip_par;
-                scanned_result(cur_val1, mu_val_level);
-            }
-            break;
-        case assign_box_dir_cmd:
-            scan_register_num();
-            m = cur_val;
-            if (box(m) != null)
-                cur_val = box_dir(box(m));
-            else
-                cur_val = 0;
-            cur_val_level = dir_val_level;
-            break;
-        case set_box_dimen_cmd:
-            /* Fetch a box dimension */
-            scan_register_num();
-            if (box(cur_val) == null)
-                cur_val = 0;
-            else
-                cur_val = varmem[box(cur_val) + m].cint;
-            cur_val_level = dimen_val_level;
-            break;
-        case assign_font_dimen_cmd:
-            /* Fetch a font dimension */
-            get_font_dimen();
-            break;
-        case assign_font_int_cmd:
-            /* Fetch a font integer */
-            scan_font_ident();
-            if (m == 0) {
-                scanned_result(hyphen_char(cur_val), int_val_level);
-            } else if (m == 1) {
-                scanned_result(skew_char(cur_val), int_val_level);
-            } else if (m == no_lig_code) {
-                scanned_result(test_no_ligatures(cur_val), int_val_level);
-            } else {
-                n = cur_val;
-                scan_char_num();
-                k = cur_val;
-                switch (m) {
-                case lp_code_base:
-                    scanned_result(get_lp_code(n, k), int_val_level);
-                    break;
-                case rp_code_base:
-                    scanned_result(get_rp_code(n, k), int_val_level);
-                    break;
-                case ef_code_base:
-                    scanned_result(get_ef_code(n, k), int_val_level);
-                    break;
-                case tag_code:
-                    scanned_result(get_tag_code(n, k), int_val_level);
-                    break;
-                }
-            }
-            break;
-        case register_cmd:
-            /* Fetch a register */
-            scan_register_num();
-            switch (m) {
-            case int_val_level:
-                cur_val = count(cur_val);
-                break;
-            case attr_val_level:
-                cur_val = attribute(cur_val);
-                break;
-            case dimen_val_level:
-                cur_val = dimen(cur_val);
-                break;
-            case glue_val_level:
-                cur_val = skip(cur_val);
-                break;
-            case mu_val_level:
-                cur_val = mu_skip(cur_val);
-                break;
-            }                   /* there are no other cases */
-            cur_val_level = m;
-            break;
-        case ignore_spaces_cmd:        /* trap unexpandable primitives */
-            if (cur_chr == 1) {
-                /* Reset |cur_tok| for unexpandable primitives, goto restart */
-                /* This block deals with unexpandable \.{\\primitive} appearing at a spot where
-                   an integer or an internal values should have been found. It fetches the
-                   next token then resets |cur_cmd|, |cur_cs|, and |cur_tok|, based on the
-                   primitive value of that token. No expansion takes place, because the
-                   next token may be all sorts of things. This could trigger further
-                   expansion creating new errors.
-                 */
-                get_token();
-                cur_cs = prim_lookup(cs_text(cur_cs));
-                if (cur_cs != undefined_primitive) {
-                    cur_cmd = get_prim_eq_type(cur_cs);
-                    cur_chr = get_prim_equiv(cur_cs);
-                    cur_tok = token_val(cur_cmd, cur_chr);
-                } else {
-                    cur_cmd = relax_cmd;
-                    cur_chr = 0;
-                    cur_tok = cs_token_flag + frozen_relax;
-                    cur_cs = frozen_relax;
-                }
-                goto RESTART;
-            }
-            break;
-        case hyph_data_cmd:
-            switch (cur_chr) {
-                case 0:
-                case 1:
-                    goto DEFAULT;
-                    break;
-                case 2:
-                    cur_val = get_pre_hyphen_char(language_par);
-                    cur_val_level = int_val_level;
-                    break;
-                case 3:
-                    cur_val = get_post_hyphen_char(language_par);
-                    cur_val_level = int_val_level;
-                    break;
-                case 4:
-                    cur_val = get_pre_exhyphen_char(language_par);
-                    cur_val_level = int_val_level;
-                    break;
-                case 5:
-                    cur_val = get_post_exhyphen_char(language_par);
-                    cur_val_level = int_val_level;
-                    break;
-                case 6:
-                    cur_val = get_hyphenation_min(language_par);
-                    cur_val_level = int_val_level;
-                    break;
-                case 7:
-                    scan_int();
-                    cur_val = get_hj_code(language_par,cur_val);
-                    cur_val_level = int_val_level;
-                    break;
-            }
-            break;
-        default:
-            DEFAULT:
-            /* Complain that \.{\\the} can not do this; give zero result */
-            print_err("You can't use `");
-            print_cmd_chr((quarterword) cur_cmd, cur_chr);
-            tprint("' after \\the");
-            help1("I'm forgetting what you said and using zero instead.");
-            error();
-            if (level != tok_val_level)
-                scanned_result(0, dimen_val_level);
-            else
-                scanned_result(0, int_val_level);
-            break;
-        }
-        while (cur_val_level > level) {
-            /* Convert |cur_val| to a lower level */
-            downgrade_cur_val(false);
-        }
-        /* Fix the reference count, if any, and negate |cur_val| if |negative| */
-        /* If |cur_val| points to a glue specification at this point, the reference
-           count for the glue does not yet include the reference by |cur_val|.
-           If |negative| is |true|, |cur_val_level| is known to be |<=mu_val|.
-         */
-        if (negative) {
-            /* we create a new (negated) glue spec and keep the old one */
-            negate_cur_val(false);
-        } else if ((cur_val_level >= glue_val_level) && (cur_val_level <= mu_val_level)) {
-			cur_val = new_spec(cur_val);
-        }
-    }
-}
-
-@ It is nice to have routines that say what they do, so the original
-|scan_eight_bit_int| is superceded by |scan_register_num| and
-|scan_mark_num|. It may become split up even further in the future.
-
-Many of the |restricted classes| routines are the essentially
-the same except for the upper limit and the error message, so it makes
-sense to combine these all into one function.
-
-@c
-void scan_limited_int(int max, const char *name)
-{
-    char hlp[80];
-    scan_int();
-    if ((cur_val < 0) || (cur_val > max)) {
-        if (name == NULL) {
-            snprintf(hlp, 80,
-                     "Since I expected to read a number between 0 and %d,",
-                     max);
-            print_err("Bad number");
-        } else {
-            char msg[80];
-            snprintf(hlp, 80, "A %s must be between 0 and %d.", name, max);
-            snprintf(msg, 80, "Bad %s", name);
-            print_err(msg);
-        }
-        help2(hlp, "I changed this one to zero.");
-        int_error(cur_val);
-        cur_val = 0;
-    }
-}
-
-@ @c
-void scan_fifteen_bit_int(void)
-{
-    scan_real_fifteen_bit_int();
-    cur_val = ((cur_val / 0x1000) * 0x1000000) +
-        (((cur_val % 0x1000) / 0x100) * 0x10000) + (cur_val % 0x100);
-}
-
-@ @c
-void scan_fifty_one_bit_int(void)
-{
-    int iiii;
-    scan_int();
-    if ((cur_val < 0) || (cur_val > 0777777777)) {
-        print_err("Bad delimiter code");
-        help2
-            ("A numeric delimiter (first part) must be between 0 and 2^{27}-1.",
-             "I changed this one to zero.");
-        int_error(cur_val);
-        cur_val = 0;
-    }
-    iiii = cur_val;
-    scan_int();
-    if ((cur_val < 0) || (cur_val > 0xFFFFFF)) {
-        print_err("Bad delimiter code");
-        help2
-            ("A numeric delimiter (second part) must be between 0 and 2^{24}-1.",
-             "I changed this one to zero.");
-        int_error(cur_val);
-        cur_val = 0;
-    }
-    cur_val1 = cur_val;
-    cur_val = iiii;
-}
-
-@ An integer number can be preceded by any number of spaces and `\.+' or
-`\.-' signs. Then comes either a decimal constant (i.e., radix 10), an
-octal constant (i.e., radix 8, preceded by~'), a hexadecimal constant
-(radix 16, preceded by~"), an alphabetic constant (preceded by~`), or
-an internal variable. After scanning is complete,
-|cur_val| will contain the answer, which must be at most
-$2^{31}-1=2147483647$ in absolute value. The value of |radix| is set to
-10, 8, or 16 in the cases of decimal, octal, or hexadecimal constants,
-otherwise |radix| is set to zero. An optional space follows a constant.
-
-@c
-int radix;                      /* |scan_int| sets this to 8, 10, 16, or zero */
-
-@ The |scan_int| routine is used also to scan the integer part of a
-  fraction; for example, the `\.3' in `\.{3.14159}' will be found by
-  |scan_int|. The |scan_dimen| routine assumes that |cur_tok=point_token|
-  after the integer part of such a fraction has been scanned by |scan_int|,
-  and that the decimal point has been backed up to be scanned again.
-
-@c
-void scan_int(void)
-{                               /* sets |cur_val| to an integer */
-    boolean negative;           /* should the answer be negated? */
-    int m;                      /* |$2^{31}$ / radix|, the threshold of danger */
-    int d;                      /* the digit just scanned */
-    boolean vacuous;            /* have no digits appeared? */
-    boolean OK_so_far;          /* has an error message been issued? */
-    radix = 0;
-    OK_so_far = true;
-    /* Get the next non-blank non-sign token; set |negative| appropriately */
-    negative = false;
-    do {
-        /* Get the next non-blank non-call token */
-        do {
-            get_x_token();
-        } while (cur_cmd == spacer_cmd);
-        if (cur_tok == other_token + '-') {
-            negative = !negative;
-            cur_tok = other_token + '+';
-        }
-    } while (cur_tok == other_token + '+');
-
-  RESTART:
-    if (cur_tok == alpha_token) {
-        /* Scan an alphabetic character code into |cur_val| */
-        /* A space is ignored after an alphabetic character constant, so that
-           such constants behave like numeric ones. */
-        get_token();            /* suppress macro expansion */
-        if (cur_tok < cs_token_flag) {
-            cur_val = cur_chr;
-            if (cur_cmd <= right_brace_cmd) {
-                if (cur_cmd == right_brace_cmd)
-                    incr(align_state);
-                else
-                    decr(align_state);
-            }
-        } else {                /* the value of a csname in this context is its name */
-            str_number txt = cs_text(cur_tok - cs_token_flag);
-            if (is_active_cs(txt))
-                cur_val = active_cs_value(txt);
-            else if (single_letter(txt))
-                cur_val = pool_to_unichar(str_string(txt));
-            else
-                cur_val = (biggest_char + 1);
-        }
-        if (cur_val > biggest_char) {
-            print_err("Improper alphabetic constant");
-            help2("A one-character control sequence belongs after a ` mark.",
-                  "So I'm essentially inserting \\0 here.");
-            cur_val = '0';
-            back_error();
-        } else {
-            /* Scan an optional space */
-            get_x_token();
-            if (cur_cmd != spacer_cmd)
-                back_input();
-        }
-
-    } else if (cur_tok == cs_token_flag + frozen_primitive) {
-        /* Reset |cur_tok| for unexpandable primitives, goto restart */
-        /* This block deals with unexpandable \.{\\primitive} appearing at a spot where
-           an integer or an internal values should have been found. It fetches the
-           next token then resets |cur_cmd|, |cur_cs|, and |cur_tok|, based on the
-           primitive value of that token. No expansion takes place, because the
-           next token may be all sorts of things. This could trigger further
-           expansion creating new errors.
-         */
-        get_token();
-        cur_cs = prim_lookup(cs_text(cur_cs));
-        if (cur_cs != undefined_primitive) {
-            cur_cmd = get_prim_eq_type(cur_cs);
-            cur_chr = get_prim_equiv(cur_cs);
-            cur_tok = token_val(cur_cmd, cur_chr);
-        } else {
-            cur_cmd = relax_cmd;
-            cur_chr = 0;
-            cur_tok = cs_token_flag + frozen_relax;
-            cur_cs = frozen_relax;
-        }
-        goto RESTART;
-    } else if (cur_cmd == math_style_cmd) {
-        cur_val = cur_chr;
-    } else if ((cur_cmd >= min_internal_cmd) && (cur_cmd <= max_internal_cmd)) {
-        scan_something_internal(int_val_level, false);
-    } else {
-        /* Scan a numeric constant */
-        radix = 10;
-        m = 214748364;
-        if (cur_tok == octal_token) {
-            radix = 8;
-            m = 02000000000;
-            get_x_token();
-        } else if (cur_tok == hex_token) {
-            radix = 16;
-            m = 01000000000;
-            get_x_token();
-        }
-        vacuous = true;
-        cur_val = 0;
-        /* Accumulate the constant until |cur_tok| is not a suitable digit */
-        while (1) {
-            if ((cur_tok < zero_token + radix) && (cur_tok >= zero_token)
-                && (cur_tok <= zero_token + 9)) {
-                d = cur_tok - zero_token;
-            } else if (radix == 16) {
-                if ((cur_tok <= A_token + 5) && (cur_tok >= A_token)) {
-                    d = cur_tok - A_token + 10;
-                } else if ((cur_tok <= other_A_token + 5)
-                           && (cur_tok >= other_A_token)) {
-                    d = cur_tok - other_A_token + 10;
-                } else {
-                    break;
-                }
-            } else {
-                break;
-            }
-            vacuous = false;
-            if ((cur_val >= m) && ((cur_val > m) || (d > 7) || (radix != 10))) {
-                if (OK_so_far) {
-                    print_err("Number too big");
-                    help2
-                        ("I can only go up to 2147483647='17777777777=\"7FFFFFFF,",
-                         "so I'm using that number instead of yours.");
-                    error();
-                    cur_val = infinity;
-                    OK_so_far = false;
-                }
-            } else {
-                cur_val = cur_val * radix + d;
-            }
-            get_x_token();
-        }
-        if (vacuous) {
-            /* Express astonishment that no number was here */
-            print_err("Missing number, treated as zero");
-            help3("A number should have been here; I inserted `0'.",
-                  "(If you can't figure out why I needed to see a number,",
-                  "look up `weird error' in the index to The TeXbook.)");
-            back_error();
-        } else if (cur_cmd != spacer_cmd) {
-            back_input();
-        }
-    }
-    if (negative)
-        negate(cur_val);
-}
-
-@ The following code is executed when |scan_something_internal| was
-called asking for |mu_val|, when we really wanted a ``mudimen'' instead
-of ``muglue.''
-
-@c
-static void coerce_glue(void)
-{
-    int v;
-    if (cur_val_level >= glue_val_level) {
-        v = width(cur_val);
-        flush_node(cur_val);
-        cur_val = v;
-    }
-}
-
-@ The |scan_dimen| routine is similar to |scan_int|, but it sets |cur_val| to
-a |scaled| value, i.e., an integral number of sp. One of its main tasks
-is therefore to interpret the abbreviations for various kinds of units and
-to convert measurements to scaled points.
-
-There are three parameters: |mu| is |true| if the finite units must be
-`\.{mu}', while |mu| is |false| if `\.{mu}' units are disallowed;
-|inf| is |true| if the infinite units `\.{fil}', `\.{fill}', `\.{filll}'
-are permitted; and |shortcut| is |true| if |cur_val| already contains
-an integer and only the units need to be considered.
-
-The order of infinity that was found in the case of infinite glue is returned
-in the global variable |cur_order|.
-
-@c
-int cur_order;                  /* order of infinity found by |scan_dimen| */
-
-
-@ Constructions like `\.{-\'77 pt}' are legal dimensions, so |scan_dimen|
-may begin with |scan_int|. This explains why it is convenient to use
-|scan_int| also for the integer part of a decimal fraction.
-
-Several branches of |scan_dimen| work with |cur_val| as an integer and
-with an auxiliary fraction |f|, so that the actual quantity of interest is
-$|cur_val|+|f|/2^{16}$. At the end of the routine, this ``unpacked''
-representation is put into the single word |cur_val|, which suddenly
-switches significance from |integer| to |scaled|.
-
-@
-The necessary conversion factors can all be specified exactly as
-fractions whose numerator and denominator add to 32768 or less.
-According to the definitions here, $\rm2660\,dd\approx1000.33297\,mm$;
-this agrees well with the value $\rm1000.333\,mm$ cited by Bosshard
-\^{Bosshard, Hans Rudolf}
-in {\sl Technische Grundlagen zur Satzherstellung\/} (Bern, 1980).
-The Didot point has been newly standardized in 1978;
-it's now exactly $\rm 1\,nd=0.375\,mm$.
-Conversion uses the equation $0.375=21681/20320/72.27\cdot25.4$.
-The new Cicero follows the new Didot point; $\rm 1\,nc=12\,nd$.
-These would lead to the ratios $21681/20320$ and $65043/5080$,
-respectively.
-The closest approximations supported by the algorithm would be
-$11183/10481$ and $1370/107$.  In order to maintain the
-relation $\rm 1\,nc=12\,nd$, we pick the ratio $685/642$ for
-$\rm nd$, however.
-
-@c
-
-static void scan_dimen_mu_error(void) {
-    print_err("Illegal unit of measure (mu inserted)");
-    help4("The unit of measurement in math glue must be mu.",
-          "To recover gracefully from this error, it's best to",
-          "delete the erroneous units; e.g., type `2' to delete",
-          "two letters. (See Chapter 27 of The TeXbook.)");
-    error();
-}
-
-static void scan_dimen_unknown_unit_error(void) {
-    print_err("Illegal unit of measure (pt inserted)");
-    help6("Dimensions can be in units of em, ex, in, pt, pc,",
-          "cm, mm, dd, cc, nd, nc, bp, or sp; but yours is a new one!",
-          "I'll assume that you meant to say pt, for printer's points.",
-          "To recover gracefully from this error, it's best to",
-          "delete the erroneous units; e.g., type `2' to delete",
-          "two letters. (See Chapter 27 of The TeXbook.)");
-    error();
-}
-
-static void scan_dimen_out_of_range_error(void) {
-    print_err("Dimension too large");
-    help2("I can't work with sizes bigger than about 19 feet.",
-          "Continue and I'll use the largest value I can.");
-    error();
-}
-
-#define set_conversion(A,B) do { num=(A); denom=(B); } while(0)
-
-/*
-    This function sets |cur_val| to a dimension. It could be optimized a bit
-    more (but not now, something for luatex > 1).
-*/
-
-void scan_dimen(boolean mu, boolean inf, boolean shortcut)
-{
-    boolean negative = false; /* should the answer be negated? */
-    boolean is_true  = false;
-    int f = 0;                /* numerator of a fraction whose denominator is $2^{16}$ */
-    int num = 0;              /* conversion ratio for the scanned units */
-    int denom = 0;
-    halfword q;               /* top of decimal digit stack */
-    scaled v;                 /* an internal dimension */
-    int save_cur_val;         /* temporary storage of |cur_val| */
-    arith_error = false;
-    cur_order = normal;
-    if (!shortcut) {
-        /* Get the next non-blank non-sign... */
-        do {
-            /* Get the next non-blank non-call token */
-            do {
-                get_x_token();
-            } while (cur_cmd == spacer_cmd);
-            if (cur_tok == other_token + '-') {
-                negative = !negative;
-                cur_tok = other_token + '+';
-            }
-        } while (cur_tok == other_token + '+');
-        if ((cur_cmd >= min_internal_cmd) && (cur_cmd <= max_internal_cmd)) {
-            /* Fetch an internal dimension and |goto attach_sign|, or fetch an internal integer */
-            if (mu) {
-                scan_something_internal(mu_val_level, false);
-                coerce_glue();
-                if (cur_val_level == mu_val_level) {
-                    goto ATTACH_SIGN;
-                } else if (cur_val_level != int_val_level) {
-                    mu_error();
-                }
-            } else {
-                scan_something_internal(dimen_val_level, false);
-                if (cur_val_level == dimen_val_level) {
-                    goto ATTACH_SIGN;
-                }
-            }
-        } else {
-            back_input();
-            if (cur_tok == continental_point_token) {
-                cur_tok = point_token;
-            }
-            if (cur_tok != point_token) {
-                scan_int();
-            } else {
-                radix = 10;
-                cur_val = 0;
-            }
-            if (cur_tok == continental_point_token) {
-                cur_tok = point_token;
-            }
-            if ((radix == 10) && (cur_tok == point_token)) {
-                /*
-                    Scan decimal fraction. When the following code is executed, we have
-                    |cur_tok=point_token|, but this token has been backed up using |back_input|;
-                    we must first discard it. It turns out that a decimal point all by itself
-                    is equivalent to `\.{0.0}'. Let's hope people don't use that fact.
-                */
-                int k = 0;
-                halfword p = null;
-                int kk;
-                get_token(); /* |point_token| is being re-scanned */
-                while (1) {
-                    get_x_token();
-                    if ((cur_tok > zero_token + 9) || (cur_tok < zero_token))
-                        break;
-                    if (k < 17) {
-                        /* digits for |k>=17| cannot affect the result */
-                        q = get_avail();
-                        set_token_link(q, p);
-                        set_token_info(q, cur_tok - zero_token);
-                        p = q;
-                        incr(k);
-                    }
-                }
-                for (kk = k; kk >= 1; kk--) {
-                    dig[kk - 1] = token_info(p);
-                    q = p;
-                    p = token_link(p);
-                    free_avail(q);
-                }
-                f = round_decimals(k);
-                if (cur_cmd != spacer_cmd) {
-                    back_input();
-                }
-            }
-        }
-    }
-    if (cur_val < 0) {
-        /* in this case |f=0| */
-        negative = !negative;
-        negate(cur_val);
-    }
-    /*
-        Scan units and set |cur_val| to $x\cdot(|cur_val|+f/2^{16})$, where there
-        are |x| sp per unit; |goto attach_sign| if the units are internal. Now comes
-        the harder part: At this point in the program, |cur_val| is a nonnegative
-        integer and $f/2^{16}$ is a nonnegative fraction less than 1; we want to
-        multiply the sum of these two quantities by the appropriate factor, based
-        on the specified units, in order to produce a |scaled| result, and we want
-        to do the calculation with fixed point arithmetic that does not overflow.
-    */
-    if (inf) {
-        /*
-            Scan for (f)\.{fil} units; |goto attach_fraction| if found. In traditional
-            \TeX, a specification like `\.{filllll}' or `\.{fill L L L}' will lead to
-            two error messages (one for each additional keyword \.{"l"}). Not so for
-            \LuaTeX, it just parses the construct in reverse.
-
-             if (scan_keyword("filll")) {
-                 cur_order = filll;
-                 goto ATTACH_FRACTION;
-             } else if (scan_keyword("fill")) {
-                 cur_order = fill;
-                 goto ATTACH_FRACTION;
-             } else if (scan_keyword("fil")) {
-                 cur_order = fil;
-                 goto ATTACH_FRACTION;
-             } else if (scan_keyword("fi")) {
-                 cur_order = sfi;
-                 goto ATTACH_FRACTION;
-             }
-
-            But ... it failed in alignments so now we do this. And, as we support an extra
-            l we don't issue an error message (we didn't do that anyway).
-         */
-         if (scan_keyword("fi")) {
-             cur_order = sfi;
-             if (scan_keyword("l")) {
-                cur_order = fil;
-                if (scan_keyword("l")) {
-                    cur_order = fill;
-                    if (scan_keyword("l")) {
-                        cur_order = filll;
-                    }
-                }
-            }
-            goto ATTACH_FRACTION;
-         }
-    }
-    /*
-        Scan for (u)units that are internal dimensions; |goto attach_sign| with
-        |cur_val| set if found
-    */
-    save_cur_val = cur_val;
-    /* Get the next non-blank non-call... a pitty if just backed up the input */
-    do {
-        get_x_token();
-    } while (cur_cmd == spacer_cmd);
-
-    if ((cur_cmd < min_internal_cmd) || (cur_cmd > max_internal_cmd)) {
-        back_input();
-    } else {
-        /* math_given_cmd xmath_given_cmd last_item_cmd */
-        if (mu) {
-            scan_something_internal(mu_val_level, false);
-            coerce_glue();
-            if (cur_val_level != mu_val_level) {
-                mu_error();
-            }
-        } else {
-            scan_something_internal(dimen_val_level, false);
-        }
-        v = cur_val;
-        goto FOUND;
-    }
-    /* bah ... true forces to split the unit scanner */
-    if (mu) {
-        /* Scan for (m)\.{mu} units and |goto attach_fraction| */
-        if (! scan_keyword("mu")) {
-            scan_dimen_mu_error();
-        }
-        goto ATTACH_FRACTION;
-    } else if (scan_keyword("em")) {
-        v = quad(get_cur_font());
-    } else if (scan_keyword("ex")) {
-        v = x_height(get_cur_font());
-    } else if (scan_keyword("px")) {
-        v = px_dimen_par;
-    } else {
-        goto PICKUP_UNIT;
-    }
-    /* Scan an optional space (after em, ex or px) */
-    get_x_token();
-    if (cur_cmd != spacer_cmd) {
-        back_input();
-    }
-  FOUND:
-    cur_val = nx_plus_y(save_cur_val, v, xn_over_d(v, f, 0200000));
-    goto ATTACH_SIGN;
-    /*
-        Scan for (a)all other units and adjust |cur_val| and |f| accordingly;
-        |goto done| in the case of scaled points
-    */
-  PICKUP_UNIT:
-    if (scan_keyword("pt")) {
-        goto SCALE_VALUE;   /* the easy case */
-    } else if (scan_keyword("mm")) {
-        set_conversion(7227, 2540);
-        goto SCALE_VALUE;
-    } else if (scan_keyword("cm")) {
-        set_conversion(7227, 254);
-        goto SCALE_VALUE;
-    } else if (scan_keyword("sp")) {
-        goto DONE;
-    } else if (scan_keyword("bp")) {
-        set_conversion(7227, 7200);
-        goto SCALE_VALUE;
-    } else if (scan_keyword("in")) {
-        set_conversion(7227, 100);
-        goto SCALE_VALUE;
-    } else if (scan_keyword("dd")) {
-        set_conversion(1238, 1157);
-        goto SCALE_VALUE;
-    } else if (scan_keyword("cc")) {
-        set_conversion(14856, 1157);
-        goto SCALE_VALUE;
-    } else if (scan_keyword("pc")) {
-        set_conversion(12, 1);
-        goto SCALE_VALUE;
-    } else if (scan_keyword("nd")) {
-        set_conversion(685, 642);
-        goto SCALE_VALUE;
-    } else if (scan_keyword("nc")) {
-        set_conversion(1370, 107);
-        goto SCALE_VALUE;
-    } else if (!is_true && scan_keyword("true")) {
-        is_true = true;
-        goto PICKUP_UNIT;
-    }
-    /* Complain about unknown unit and |goto done2| */
-    scan_dimen_unknown_unit_error();
-    goto BAD_NEWS;
-  SCALE_VALUE:
-    /* Adjust (f) for the magnification ratio */
-    if (is_true) {
-        /* maybe at some point we will drop mag completely, even in dvi mode */
-        if (output_mode_used <= OMODE_DVI) {
-            prepare_mag();
-            if (mag_par != 1000) {
-                cur_val = xn_over_d(cur_val, 1000, mag_par);
-                f = (1000 * f + 0200000 * tex_remainder) / mag_par;
-                cur_val = cur_val + (f / 0200000);
-                f = f % 0200000;
-            }
-        } else {
-            /* in pdf mode we're always true */
-            one_true_inch = one_inch; /* saveguard */
-        }
-    }
-    /* */
-    if (num) {
-        cur_val = xn_over_d(cur_val, num, denom);
-        f = (num * f + 0200000 * tex_remainder) / denom;
-        cur_val = cur_val + (f / 0200000);
-        f = f % 0200000;
-    }
-  BAD_NEWS:
-  ATTACH_FRACTION:
-    if (cur_val >= 040000) {
-        arith_error = true;
-    } else {
-        cur_val = cur_val * unity + f;
-    }
-  DONE:
-    /* Scan an optional space */ /* happens too often */
-    get_x_token();
-    if (cur_cmd != spacer_cmd) {
-        back_input();
-    }
-  ATTACH_SIGN:
-    if (arith_error || (abs(cur_val) >= 010000000000)) {
-        /* Report that this dimension is out of range */
-        scan_dimen_out_of_range_error();
-        cur_val = max_dimen;
-        arith_error = false;
-    }
-    if (negative) {
-        negate(cur_val);
-    }
-}
-
-@ The final member of \TeX's value-scanning trio is |scan_glue|, which
-makes |cur_val| point to a glue specification. The reference count of that
-glue spec will take account of the fact that |cur_val| is pointing to~it.
-
-The |level| parameter should be either |glue_val| or |mu_val|.
-
-Since |scan_dimen| was so much more complex than |scan_int|, we might expect
-|scan_glue| to be even worse. But fortunately, it is very simple, since
-most of the work has already been done.
-
-@c
-void scan_glue(int level)
-{
-    boolean negative = false;             /* should the answer be negated? */
-    halfword q = null;                    /* new glue specification */
-    boolean mu = (level == mu_val_level); /* does |level=mu_val|? */
-    /* Get the next non-blank non-sign ... */
-    do {
-        /* Get the next non-blank non-call token */
-        do {
-            get_x_token();
-        } while (cur_cmd == spacer_cmd);
-        if (cur_tok == other_token + '-') {
-            negative = !negative;
-            cur_tok = other_token + '+';
-        }
-    } while (cur_tok == other_token + '+');
-    if ((cur_cmd >= min_internal_cmd) && (cur_cmd <= max_internal_cmd)) {
-        scan_something_internal(level, negative);
-        if (cur_val_level >= glue_val_level) {
-            if (cur_val_level != level)
-                mu_error();
-            return;
-        }
-        if (cur_val_level == int_val_level)
-            scan_dimen(mu, false, true);
-        else if (level == mu_val_level)
-            mu_error();
-    } else {
-        back_input();
-        scan_dimen(mu, false, false);
-        if (negative)
-            negate(cur_val);
-    }
-    /*
-        Create a new glue specification whose width is |cur_val|; scan for its
-        stretch and shrink components.
-    */
-    q = new_spec(zero_glue);
-    width(q) = cur_val;
-    if (scan_keyword("plus")) {
-        scan_dimen(mu, true, false);
-        stretch(q) = cur_val;
-        stretch_order(q) = (quarterword) cur_order;
-    }
-    if (scan_keyword("minus")) {
-        scan_dimen(mu, true, false);
-        shrink(q) = cur_val;
-        shrink_order(q) = (quarterword) cur_order;
-    }
-    cur_val = q;
-}
-
-@ This is an omega routine
-@c
-void scan_scaled(void)
-{                               /* sets |cur_val| to a scaled value */
-    boolean negative;           /* should the answer be negated? */
-    int f;                      /* numerator of a fraction whose denominator is $2^{16}$ */
-    int k, kk;                  /* number of digits in a decimal fraction */
-    halfword p, q;              /* top of decimal digit stack */
-    f = 0;
-    arith_error = false;
-    negative = false;
-    /* Get the next non-blank non-sign... */
-    do {
-        /* Get the next non-blank non-call token */
-        do {
-            get_x_token();
-        } while (cur_cmd == spacer_cmd);
-        if (cur_tok == other_token + '-') {
-            negative = !negative;
-            cur_tok = other_token + '+';
-        }
-    } while (cur_tok == other_token + '+');
-
-    back_input();
-    if (cur_tok == continental_point_token)
-        cur_tok = point_token;
-    if (cur_tok != point_token) {
-        scan_int();
-    } else {
-        radix = 10;
-        cur_val = 0;
-    }
-    if (cur_tok == continental_point_token)
-        cur_tok = point_token;
-    if ((radix == 10) && (cur_tok == point_token)) {
-        /* Scan decimal fraction */
-        /* TODO: merge this with the same block in |scan_dimen| */
-        /* When the following code is executed, we have |cur_tok=point_token|, but this
-           token has been backed up using |back_input|; we must first discard it.
-
-           It turns out that a decimal point all by itself is equivalent to `\.{0.0}'.
-           Let's hope people don't use that fact. */
-
-        k = 0;
-        p = null;
-        get_token();            /* |point_token| is being re-scanned */
-        while (1) {
-            get_x_token();
-            if ((cur_tok > zero_token + 9) || (cur_tok < zero_token))
-                break;
-            if (k < 17) {       /* digits for |k>=17| cannot affect the result */
-                q = get_avail();
-                set_token_link(q, p);
-                set_token_info(q, cur_tok - zero_token);
-                p = q;
-                incr(k);
-            }
-        }
-        for (kk = k; kk >= 1; kk--) {
-            dig[kk - 1] = token_info(p);
-            q = p;
-            p = token_link(p);
-            free_avail(q);
-        }
-        f = round_decimals(k);
-        if (cur_cmd != spacer_cmd)
-            back_input();
-
-    }
-    if (cur_val < 0) {          /* in this case |f=0| */
-        negative = !negative;
-        negate(cur_val);
-    }
-    if (cur_val > 040000)
-        arith_error = true;
-    else
-        cur_val = cur_val * unity + f;
-    if (arith_error || (abs(cur_val) >= 010000000000)) {
-        print_err("Stack number too large");
-        error();
-    }
-    if (negative)
-        negate(cur_val);
-}
-
-@ This procedure is supposed to scan something like `\.{\\skip\\count12}',
-i.e., whatever can follow `\.{\\the}', and it constructs a token list
-containing something like `\.{-3.0pt minus 0.5fill}'.
-
-@c
-halfword the_toks(void)
-{
-    int old_setting;            /* holds |selector| setting */
-    halfword p, q, r;           /* used for copying a token list */
-    int c;                      /* value of |cur_chr| */
-    str_number s;
-    halfword retval;
-    /* Handle \.{\\unexpanded} or \.{\\detokenize} and |return| */
-    if (odd(cur_chr)) {
-        c = cur_chr;
-        scan_general_text();
-        if (c == 1) {
-            return cur_val;
-        } else {
-            old_setting = selector;
-            selector = new_string;
-            p = get_avail();
-            set_token_link(p, token_link(temp_token_head));
-            token_show(p);
-            flush_list(p);
-            selector = old_setting;
-            s = make_string();
-            retval = str_toks(str_lstring(s));
-            flush_str(s);
-            return retval;
-        }
-    }
-    get_x_token();
-    scan_something_internal(tok_val_level, false);
-    if (cur_val_level >= ident_val_level) {
-        /* Copy the token list */
-        p = temp_token_head;
-        set_token_link(p, null);
-        if (cur_val_level == ident_val_level) {
-            store_new_token(cs_token_flag + cur_val);
-        } else if (cur_val != null) {
-            r = token_link(cur_val);    /* do not copy the reference count */
-            while (r != null) {
-                fast_store_new_token(token_info(r));
-                r = token_link(r);
-            }
-        }
-        return p;
-    } else {
-        old_setting = selector;
-        selector = new_string;
-        switch (cur_val_level) {
-        case int_val_level:
-            print_int(cur_val);
-            break;
-        case attr_val_level:
-            print_int(cur_val);
-            break;
-        case dir_val_level:
-            print_dir(cur_val);
-            break;
-        case dimen_val_level:
-            print_scaled(cur_val);
-            tprint("pt");
-            break;
-        case glue_val_level:
-            print_spec(cur_val, "pt");
-            flush_node(cur_val);
-            break;
-        case mu_val_level:
-            print_spec(cur_val, "mu");
-            flush_node(cur_val);
-            break;
-        }                       /* there are no other cases */
-        selector = old_setting;
-        s = make_string();
-        retval = str_toks(str_lstring(s));
-        flush_str(s);
-        return retval;
-    }
-}
-
-@ @c
-str_number the_scanned_result(void)
-{
-    int old_setting;            /* holds |selector| setting */
-    str_number r;               /* return value * */
-    old_setting = selector;
-    selector = new_string;
-    if (cur_val_level >= ident_val_level) {
-        if (cur_val != null) {
-            show_token_list(token_link(cur_val), null, -1);
-            r = make_string();
-        } else {
-            r = get_nullstr();
-        }
-    } else {
-        switch (cur_val_level) {
-        case int_val_level:
-            print_int(cur_val);
-            break;
-        case attr_val_level:
-            print_int(cur_val);
-            break;
-        case dir_val_level:
-            print_dir(cur_val);
-            break;
-        case dimen_val_level:
-            print_scaled(cur_val);
-            tprint("pt");
-            break;
-        case glue_val_level:
-            print_spec(cur_val, "pt");
-            flush_node(cur_val);
-            break;
-        case mu_val_level:
-            print_spec(cur_val, "mu");
-            flush_node(cur_val);
-            break;
-        }                       /* there are no other cases */
-        r = make_string();
-    }
-    selector = old_setting;
-    return r;
-}
-
-@ The following routine is used to implement `\.{\\fontdimen} |n| |f|'.
-The boolean parameter |writing| is set |true| if the calling program
-intends to change the parameter value.
-
-@c
-static void font_param_error(int f)
-{
-    print_err("Font ");
-    print_esc(font_id_text(f));
-    tprint(" has only ");
-    print_int(font_params(f));
-    tprint(" fontdimen parameters");
-    help2("To increase the number of font parameters, you must",
-          "use \\fontdimen immediately after the \\font is loaded.");
-    error();
-}
-
-void set_font_dimen(void)
-{
-    internal_font_number f;
-    int n;                      /* the parameter number */
-    scan_int();
-    n = cur_val;
-    scan_font_ident();
-    f = cur_val;
-    if (n <= 0) {
-        font_param_error(f);
-    } else {
-        if (n > font_params(f)) {
-            if (font_used(f)) {
-                font_param_error(f);
-            } else {
-                /* Increase the number of parameters in the font */
-                do {
-                    set_font_param(f, (font_params(f) + 1), 0);
-                } while (n != font_params(f));
-            }
-        }
-    }
-    scan_optional_equals();
-    scan_normal_dimen();
-    set_font_param(f, n, cur_val);
-}
-
-void get_font_dimen(void)
-{
-    internal_font_number f;
-    int n;                      /* the parameter number */
-    scan_int();
-    n = cur_val;
-    scan_font_ident();
-    f = cur_val;
-    cur_val = 0;                /* initialize return value */
-    if (n <= 0) {
-        font_param_error(f);
-        goto EXIT;
-    } else {
-        if (n > font_params(f)) {
-            if (font_used(f)) {
-                font_param_error(f);
-                goto EXIT;
-            } else {
-                /* Increase the number of parameters in the font */
-                do {
-                    set_font_param(f, (font_params(f) + 1), 0);
-                } while (n != font_params(f));
-
-            }
-        }
-    }
-    cur_val = font_param(f, n);
-  EXIT:
-    scanned_result(cur_val, dimen_val_level);
-}
-
-@ Here's a similar procedure that returns a pointer to a rule node. This
-routine is called just after \TeX\ has seen \.{\\hrule} or \.{\\vrule};
-therefore |cur_cmd| will be either |hrule| or |vrule|. The idea is to store
-the default rule dimensions in the node, then to override them if
-`\.{height}' or `\.{width}' or `\.{depth}' specifications are
-found (in any order).
-
-@c
-halfword scan_rule_spec(void)
-{
-    /* |width|, |depth|, and |height| all equal |null_flag| now */
-    halfword q;
-    if (cur_cmd == no_vrule_cmd) {
-        q = new_rule(empty_rule);
-        cur_cmd = vrule_cmd;
-    } else if (cur_cmd == no_hrule_cmd) {
-        q = new_rule(empty_rule);
-        cur_cmd = hrule_cmd;
-    } else {
-        q = new_rule(normal_rule);
-    }
-    if (cur_cmd == vrule_cmd) {
-        width(q) = default_rule;
-        rule_dir(q) = body_direction_par;
-    } else {
-        height(q) = default_rule;
-        depth(q) = 0;
-        rule_dir(q) = text_direction_par;
-    }
-  RESWITCH:
-    if (scan_keyword("width")) {
-        scan_normal_dimen();
-        width(q) = cur_val;
-        goto RESWITCH;
-    }
-    if (scan_keyword("height")) {
-        scan_normal_dimen();
-        height(q) = cur_val;
-        goto RESWITCH;
-    }
-    if (scan_keyword("depth")) {
-        scan_normal_dimen();
-        depth(q) = cur_val;
-        goto RESWITCH;
-    }
-    return q;
-}
-
-
-@ Declare procedures that scan font-related stuff
-
-@c
-void scan_font_ident(void)
-{
-    internal_font_number f;
-    halfword m;
-    /* Get the next non-blank non-call... */
-    do {
-        get_x_token();
-    } while (cur_cmd == spacer_cmd);
-
-    if ((cur_cmd == def_font_cmd) || (cur_cmd == letterspace_font_cmd) || (cur_cmd == copy_font_cmd)) {
-        f = get_cur_font();
-    } else if (cur_cmd == set_font_cmd) {
-        f = cur_chr;
-        set_font_touched(f, 1);
-    } else if (cur_cmd == def_family_cmd) {
-        m = cur_chr;
-        scan_math_family_int();
-        f = fam_fnt(cur_val, m);
-        set_font_touched(f, 1);
-    } else {
-        print_err("Missing font identifier");
-        help2("I was looking for a control sequence whose",
-              "current meaning has been defined by \\font.");
-        back_error();
-        f = null_font;
-    }
-    cur_val = f;
-}
-
-@ The |scan_general_text| procedure is much like |scan_toks(false,false)|,
-but will be invoked via |expand|, i.e., recursively.
-
-The token list (balanced text) created by |scan_general_text| begins
-at |link(temp_token_head)| and ends at |cur_val|.  (If |cur_val=temp_token_head|,
-the list is empty.)
-
-@c
-void scan_general_text(void)
-{
-    int s;                      /* to save |scanner_status| */
-    halfword w;                 /* to save |warning_index| */
-    halfword d;                 /* to save |def_ref| */
-    halfword p;                 /* tail of the token list being built */
-    halfword q;                 /* new node being added to the token list via |store_new_token| */
-    halfword unbalance;         /* number of unmatched left braces */
-    s = scanner_status;
-    w = warning_index;
-    d = def_ref;
-    scanner_status = absorbing;
-    warning_index = cur_cs;
-    p = get_avail();
-    def_ref = p;
-    set_token_ref_count(def_ref, 0);
-    p = def_ref;
-    scan_left_brace();          /* remove the compulsory left brace */
-    unbalance = 1;
-    while (1) {
-        get_token();
-        if (cur_tok < right_brace_limit) {
-            if (cur_cmd < right_brace_cmd) {
-                incr(unbalance);
-            } else {
-                decr(unbalance);
-                if (unbalance == 0)
-                    break;
-            }
-        }
-        store_new_token(cur_tok);
-    }
-    q = token_link(def_ref);
-    free_avail(def_ref);        /* discard reference count */
-    if (q == null)
-        cur_val = temp_token_head;
-    else
-        cur_val = p;
-    set_token_link(temp_token_head, q);
-    scanner_status = s;
-    warning_index = w;
-    def_ref = d;
-}
-
-@ The |get_x_or_protected| procedure is like |get_x_token| except that
-protected macros are not expanded.
-
-@c
-void get_x_or_protected(void)
-{                               /* sets |cur_cmd|, |cur_chr|, |cur_tok|,
-                                   and expands non-protected macros */
-    while (1) {
-        get_token();
-        if (cur_cmd <= max_command_cmd)
-            return;
-        if ((cur_cmd >= call_cmd) && (cur_cmd < end_template_cmd)) {
-            if (token_info(token_link(cur_chr)) == protected_token)
-                return;
-        }
-        expand();
-    }
-}
-
-@ |scan_toks|. This function returns a pointer to the tail of a new token
-list, and it also makes |def_ref| point to the reference count at the
-head of that list.
-
-There are two boolean parameters, |macro_def| and |xpand|. If |macro_def|
-is true, the goal is to create the token list for a macro definition;
-otherwise the goal is to create the token list for some other \TeX\
-primitive: \.{\\mark}, \.{\\output}, \.{\\everypar}, \.{\\lowercase},
-\.{\\uppercase}, \.{\\message}, \.{\\errmessage}, \.{\\write}, or
-\.{\\special}. In the latter cases a left brace must be scanned next; this
-left brace will not be part of the token list, nor will the matching right
-brace that comes at the end. If |xpand| is false, the token list will
-simply be copied from the input using |get_token|. Otherwise all expandable
-tokens will be expanded until unexpandable tokens are left, except that
-the results of expanding `\.{\\the}' are not expanded further.
-If both |macro_def| and |xpand| are true, the expansion applies
-only to the macro body (i.e., to the material following the first
-|left_brace| character).
-
-The value of |cur_cs| when |scan_toks| begins should be the |eqtb|
-address of the control sequence to display in ``runaway'' error
-messages.
-
-@c
-halfword scan_toks(boolean macro_def, boolean xpand)
-{
-    halfword t;                 /* token representing the highest parameter number */
-    halfword s;                 /* saved token */
-    halfword p;                 /* tail of the token list being built */
-    halfword q;                 /* new node being added to the token list via |store_new_token| */
-    halfword unbalance;         /* number of unmatched left braces */
-    halfword hash_brace;        /* possible `\.{\#\{}' token */
-    if (macro_def)
-        scanner_status = defining;
-    else
-        scanner_status = absorbing;
-    warning_index = cur_cs;
-    p = get_avail();
-    def_ref = p;
-    set_token_ref_count(def_ref, 0);
-    p = def_ref;
-    hash_brace = 0;
-    t = zero_token;
-    if (macro_def) {
-        /* Scan and build the parameter part of the macro definition */
-        while (1) {
-            get_token();        /* set |cur_cmd|, |cur_chr|, |cur_tok| */
-            if (cur_tok < right_brace_limit)
-                break;
-            if (cur_cmd == mac_param_cmd) {
-                /* If the next character is a parameter number, make |cur_tok|
-                   a |match| token; but if it is a left brace, store
-                   `|left_brace|, |end_match|', set |hash_brace|, and |goto done|;
-                 */
-                s = match_token + cur_chr;
-                get_token();
-                if (cur_cmd == left_brace_cmd) {
-                    hash_brace = cur_tok;
-                    store_new_token(cur_tok);
-                    store_new_token(end_match_token);
-                    goto DONE;
-                }
-                if (t == zero_token + 9) {
-                    print_err("You already have nine parameters");
-                    help1("I'm going to ignore the # sign you just used.");
-                    error();
-                } else {
-                    incr(t);
-                    if (cur_tok != t) {
-                        print_err("Parameters must be numbered consecutively");
-                        help2
-                            ("I've inserted the digit you should have used after the #.",
-                             "Type `1' to delete what you did use.");
-                        back_error();
-                    }
-                    cur_tok = s;
-                }
-            }
-            store_new_token(cur_tok);
-        }
-        store_new_token(end_match_token);
-        if (cur_cmd == right_brace_cmd) {
-            /* Express shock at the missing left brace; |goto found| */
-            print_err("Missing { inserted");
-            incr(align_state);
-            help2
-                ("Where was the left brace? You said something like `\\def\\a}',",
-                 "which I'm going to interpret as `\\def\\a{}'.");
-            error();
-            goto FOUND;
-        }
-
-    } else {
-        scan_left_brace();      /* remove the compulsory left brace */
-    }
-  DONE:
-    /* Scan and build the body of the token list; |goto found| when finished */
-    unbalance = 1;
-    while (1) {
-        if (xpand) {
-            /* Expand the next part of the input */
-            /* Here we insert an entire token list created by |the_toks| without
-               expanding it further. */
-            while (1) {
-                get_next();
-                if (cur_cmd >= call_cmd) {
-                    if (token_info(token_link(cur_chr)) == protected_token) {
-                        cur_cmd = relax_cmd;
-                        cur_chr = no_expand_flag;
-                    }
-                }
-                if (cur_cmd <= max_command_cmd)
-                    break;
-                if (cur_cmd != the_cmd) {
-                    expand();
-                } else {
-                    q = the_toks();
-                    if (token_link(temp_token_head) != null) {
-                        set_token_link(p, token_link(temp_token_head));
-                        p = q;
-                    }
-                }
-            }
-            x_token();
-
-        } else {
-            get_token();
-        }
-        if (cur_tok < right_brace_limit) {
-            if (cur_cmd < right_brace_cmd) {
-                incr(unbalance);
-            } else {
-                decr(unbalance);
-                if (unbalance == 0)
-                    goto FOUND;
-            }
-        } else if (cur_cmd == mac_param_cmd) {
-            if (macro_def) {
-                /* Look for parameter number or \.{\#\#} */
-                s = cur_tok;
-                if (xpand)
-                    get_x_token();
-                else
-                    get_token();
-                if (cur_cmd != mac_param_cmd) {
-                    if ((cur_tok <= zero_token) || (cur_tok > t)) {
-                        print_err("Illegal parameter number in definition of ");
-                        sprint_cs(warning_index);
-                        help3("You meant to type ## instead of #, right?",
-                              "Or maybe a } was forgotten somewhere earlier, and things",
-                              "are all screwed up? I'm going to assume that you meant ##.");
-                        back_error();
-                        cur_tok = s;
-                    } else {
-                        cur_tok = out_param_token - '0' + cur_chr;
-                    }
-                }
-            }
-        }
-        store_new_token(cur_tok);
-    }
-  FOUND:
-    scanner_status = normal;
-    if (hash_brace != 0)
-        store_new_token(hash_brace);
-    return p;
-}
-
-@ Here we declare two trivial procedures in order to avoid mutually
-recursive procedures with parameters.
-
-@c
-void scan_normal_glue(void)
-{
-    scan_glue(glue_val_level);
-}
-
-void scan_mu_glue(void)
-{
-    scan_glue(mu_val_level);
-}
-
-@ The |scan_expr| procedure scans and evaluates an expression.
-
-@ Evaluating an expression is a recursive process:  When the left
-parenthesis of a subexpression is scanned we descend to the next level
-of recursion; the previous level is resumed with the matching right
-parenthesis.
-
-@c
-typedef enum {
-    expr_none  = 0, /* \.( seen, or \.( $\langle\it expr\rangle$ \.) seen */
-    expr_add   = 1, /* \.( $\langle\it expr\rangle$ \.+ seen */
-    expr_sub   = 2, /* \.( $\langle\it expr\rangle$ \.- seen */
-    expr_mult  = 3, /* $\langle\it term\rangle$ \.* seen */
-    expr_div   = 4, /* $\langle\it term\rangle$ \./ seen */
-    expr_scale = 5, /* $\langle\it term\rangle$ \.*  $\langle\it factor\rangle$ \./ seen */
-} expression_states;
-
-@  We want to make sure that each term and (intermediate) result is in
-  the proper range.  Integer values must not exceed |infinity|
-  ($2^{31}-1$) in absolute value, dimensions must not exceed |max_dimen|
-  ($2^{30}-1$).  We avoid the absolute value of an integer, because this
-  might fail for the value $-2^{31}$ using 32-bit arithmetic.
-
-@   clear a number or dimension and set |arith_error|
-
-@c
-#define num_error(A) do { \
-    arith_error=true; \
-    A=0; \
-} while (0)
-
-@   clear a glue spec and set |arith_error|
-
-@c
-#define glue_error(A) do { \
-    arith_error=true; \
-    reset_glue_to_zero(A); \
-} while (0)
-
-#define normalize_glue(A) do { \
-    if (stretch(A)==0) stretch_order(A)=normal; \
-    if (shrink(A)==0) shrink_order(A)=normal; \
-} while (0)
-
-@ Parenthesized subexpressions can be inside expressions, and this
-nesting has a stack.  Seven local variables represent the top of the
-expression stack:  |p| points to pushed-down entries, if any; |l|
-specifies the type of expression currently beeing evaluated; |e| is the
-expression so far and |r| is the state of its evaluation; |t| is the
-term so far and |s| is the state of its evaluation; finally |n| is the
-numerator for a combined multiplication and division, if any.
-
-@c
-#define expr_add_sub(A,B,C) add_or_sub((A),(B),(C),(r==expr_sub))
-#define expr_a(A,B) expr_add_sub((A),(B),max_dimen)
-
-@
-  The function |add_or_sub(x,y,max_answer,negative)| computes the sum
-  (for |negative=false|) or difference (for |negative=true|) of |x| and
-  |y|, provided the absolute value of the result does not exceed
-  |max_answer|.
-
-@c
-inline static int add_or_sub(int x, int y, int max_answer, boolean negative)
-{
-    int a;                      /* the answer */
-    if (negative)
-        negate(y);
-    if (x >= 0) {
-        if (y <= max_answer - x)
-            a = x + y;
-        else
-            num_error(a);
-    } else if (y >= -max_answer - x) {
-        a = x + y;
-    } else {
-        num_error(a);
-    }
-    return a;
-}
-
-#define expr_m(A) A = nx_plus_y((A),f,0)
-#define expr_d(A) A=quotient((A),f)
-
-@ The function |quotient(n,d)| computes the rounded quotient
-$q=\lfloor n/d+{1\over2}\rfloor$, when $n$ and $d$ are positive.
-
-@c
-inline static int quotient(int n, int d)
-{
-    boolean negative;           /* should the answer be negated? */
-    int a;                      /* the answer */
-    if (d == 0) {
-        num_error(a);
-    } else {
-        if (d > 0) {
-            negative = false;
-        } else {
-            negate(d);
-            negative = true;
-        }
-        if (n < 0) {
-            negate(n);
-            negative = !negative;
-        }
-        a = n / d;
-        n = n - a * d;
-        d = n - d;              /* avoid certain compiler optimizations! */
-        if (d + n >= 0)
-            incr(a);
-        if (negative)
-            negate(a);
-    }
-    return a;
-}
-
-#define expr_s(A) A=fract((A),n,f,max_dimen)
-
-@ Finally, the function |fract(x,n,d,max_answer)| computes the integer
-$q=\lfloor xn/d+{1\over2}\rfloor$, when $x$, $n$, and $d$ are positive
-and the result does not exceed |max_answer|.  We can't use floating
-point arithmetic since the routine must produce identical results in all
-cases; and it would be too dangerous to multiply by~|n| and then divide
-by~|d|, in separate operations, since overflow might well occur.  Hence
-this subroutine simulates double precision arithmetic, somewhat
-analogous to Metafont's |make_fraction| and |take_fraction| routines.
-
-@c
-int fract(int x, int n, int d, int max_answer)
-{
-    boolean negative;           /* should the answer be negated? */
-    int a;                      /* the answer */
-    int f;                      /* a proper fraction */
-    int h;                      /* smallest integer such that |2*h>=d| */
-    int r;                      /* intermediate remainder */
-    int t;                      /* temp variable */
-    if (d == 0)
-        goto TOO_BIG;
-    a = 0;
-    if (d > 0) {
-        negative = false;
-    } else {
-        negate(d);
-        negative = true;
-    }
-    if (x < 0) {
-        negate(x);
-        negative = !negative;
-    } else if (x == 0) {
-        goto DONE;
-    }
-    if (n < 0) {
-        negate(n);
-        negative = !negative;
-    }
-    t = n / d;
-    if (t > max_answer / x)
-        goto TOO_BIG;
-    a = t * x;
-    n = n - t * d;
-    if (n == 0)
-        goto FOUND;
-    t = x / d;
-    if (t > (max_answer - a) / n)
-        goto TOO_BIG;
-    a = a + t * n;
-    x = x - t * d;
-    if (x == 0)
-        goto FOUND;
-    if (x < n) {
-        t = x;
-        x = n;
-        n = t;
-    }
-    /* now |0<n<=x<d| */
-    /* Compute $f=\lfloor xn/d+{1\over2}\rfloor$; */
-    /* The loop here preserves the following invariant relations
-       between |f|, |x|, |n|, and~|r|:
-       (i)~$f+\lfloor(xn+(r+d))/d\rfloor=\lfloor x_0n_0/d+{1\over2}\rfloor$;
-       (ii)~|-d<=r<0<n<=x<d|, where $x_0$, $n_0$ are the original values of~$x$
-       and $n$. */
-    /* Notice that the computation specifies |(x-d)+x| instead of |(x+x)-d|,
-       because the latter could overflow. */
-    f = 0;
-    r = (d / 2) - d;
-    h = -r;
-    while (1) {
-        if (odd(n)) {
-            r = r + x;
-            if (r >= 0) {
-                r = r - d;
-                incr(f);
-            }
-        }
-        n = n / 2;
-        if (n == 0)
-            break;
-        if (x < h) {
-            x = x + x;
-        } else {
-            t = x - d;
-            x = t + x;
-            f = f + n;
-            if (x < n) {
-                if (x == 0)
-                    break;
-                t = x;
-                x = n;
-                n = t;
-            }
-        }
-    }
-
-    if (f > (max_answer - a))
-        goto TOO_BIG;
-    a = a + f;
-  FOUND:
-    if (negative)
-        negate(a);
-    goto DONE;
-  TOO_BIG:
-    num_error(a);
-  DONE:
-    return a;
-}
-
-@ @c
-static void scan_expr(void)
-{                               /* scans and evaluates an expression */
-    boolean a, b;               /* saved values of |arith_error| */
-    int l;                      /* type of expression */
-    int r;                      /* state of expression so far */
-    int s;                      /* state of term so far */
-    int o;                      /* next operation or type of next factor */
-    int e;                      /* expression so far */
-    int t;                      /* term so far */
-    int f;                      /* current factor */
-    int n;                      /* numerator of combined multiplication and division */
-    halfword p;                 /* top of expression stack */
-    halfword q;                 /* for stack manipulations */
-    l = cur_val_level;
-    a = arith_error;
-    b = false;
-    p = null;
-    /* Scan and evaluate an expression |e| of type |l| */
-  RESTART:
-    r = expr_none;
-    e = 0;
-    s = expr_none;
-    t = 0;
-    n = 0;
-  CONTINUE:
-    if (s == expr_none)
-        o = l;
-    else
-        o = int_val_level;
-    /* Scan a factor |f| of type |o| or start a subexpression */
-    /* Get the next non-blank non-call token */
-    do {
-        get_x_token();
-    } while (cur_cmd == spacer_cmd);
-
-    if (cur_tok == other_token + '(') {
-        /* Push the expression stack and |goto restart| */
-        q = new_node(expr_node, 0);
-        vlink(q) = p;
-        expr_type(q) = (quarterword) l;
-        expr_state(q) = (quarterword) (4 * s + r);
-        expr_e_field(q) = e;
-        expr_t_field(q) = t;
-        expr_n_field(q) = n;
-        p = q;
-        l = o;
-        goto RESTART;
-    }
-    back_input();
-    if ((o == int_val_level) || (o == attr_val_level))
-        scan_int();
-    else if (o == dimen_val_level)
-        scan_normal_dimen();
-    else if (o == glue_val_level)
-        scan_normal_glue();
-    else
-        scan_mu_glue();
-    f = cur_val;
-
-  FOUND:
-    /* Scan the next operator and set |o| */
-    /* Get the next non-blank non-call token */
-    do {
-        get_x_token();
-    } while (cur_cmd == spacer_cmd);
-
-    if (cur_tok == other_token + '+') {
-        o = expr_add;
-    } else if (cur_tok == other_token + '-') {
-        o = expr_sub;
-    } else if (cur_tok == other_token + '*') {
-        o = expr_mult;
-    } else if (cur_tok == other_token + '/') {
-        o = expr_div;
-    } else {
-        o = expr_none;
-        if (p == null) {
-            if (cur_cmd != relax_cmd)
-                back_input();
-        } else if (cur_tok != other_token + ')') {
-            print_err("Missing ) inserted for expression");
-            help1("I was expecting to see `+', `-', `*', `/', or `)'. Didn't.");
-            back_error();
-        }
-    }
-
-    arith_error = b;
-    /* Make sure that |f| is in the proper range */
-    if (((l == int_val_level) || (l == attr_val_level)) || (s > expr_sub)) {
-        if ((f > infinity) || (f < -infinity))
-            num_error(f);
-    } else if (l == dimen_val_level) {
-        if (abs(f) > max_dimen)
-            num_error(f);
-    } else {
-        if ((abs(width(f)) > max_dimen) || (abs(stretch(f)) > max_dimen) || (abs(shrink(f)) > max_dimen))
-            glue_error(f);
-    }
-
-    switch (s) {
-        /* Cases for evaluation of the current term */
-    case expr_none:
-        /*
-           Applying the factor |f| to the partial term |t| (with the operator
-           |s|) is delayed until the next operator |o| has been scanned.  Here we
-           handle the first factor of a partial term.  A glue spec has to be copied
-           unless the next operator is a right parenthesis; this allows us later on
-           to simply modify the glue components.
-         */
-        t = f;
-        if ((l >= glue_val_level) && (o != expr_none)) {
-	        /* do we really need to copy here ? */
-//            t = new_spec(f);
-//            flush_node(f);
-            normalize_glue(t);
-        } else {
-            t = f;
-        }
-        break;
-    case expr_mult:
-        /* If a multiplication is followed by a division, the two operations are
-           combined into a `scaling' operation.  Otherwise the term |t| is
-           multiplied by the factor |f|. */
-        if (o == expr_div) {
-            n = f;
-            o = expr_scale;
-        } else if ((l == int_val_level) || (l == attr_val_level)) {
-            t = mult_integers(t, f);
-        } else if (l == dimen_val_level) {
-            expr_m(t);
-        } else {
-            expr_m(width(t));
-            expr_m(stretch(t));
-            expr_m(shrink(t));
-        }
-        break;
-    case expr_div:
-        /* Here we divide the term |t| by the factor |f| */
-        if (l < glue_val_level) {
-            expr_d(t);
-        } else {
-            expr_d(width(t));
-            expr_d(stretch(t));
-            expr_d(shrink(t));
-        }
-        break;
-    case expr_scale:
-        /* Here the term |t| is multiplied by the quotient $n/f$. */
-        if ((l == int_val_level) || (l == attr_val_level)) {
-            t = fract(t, n, f, infinity);
-        } else if (l == dimen_val_level) {
-            expr_s(t);
-        } else {
-            expr_s(width(t));
-            expr_s(stretch(t));
-            expr_s(shrink(t));
-        }
-        break;
-    }                           /* there are no other cases */
-    if (o > expr_sub) {
-        s = o;
-    } else {
-        /* Evaluate the current expression */
-        /* When a term |t| has been completed it is copied to, added to, or
-           subtracted from the expression |e|. */
-        s = expr_none;
-        if (r == expr_none) {
-            e = t;
-        } else if ((l == int_val_level) || (l == attr_val_level)) {
-            e = expr_add_sub(e, t, infinity);
-        } else if (l == dimen_val_level) {
-            e = expr_a(e, t);
-        } else {
-            /* Compute the sum or difference of two glue specs */
-            /* We know that |stretch_order(e)>normal| implies |stretch(e)<>0| and
-               |shrink_order(e)>normal| implies |shrink(e)<>0|. */
-            width(e) = expr_a(width(e), width(t));
-            if (stretch_order(e) == stretch_order(t)) {
-                stretch(e) = expr_a(stretch(e), stretch(t));
-            } else if ((stretch_order(e) < stretch_order(t)) && (stretch(t) != 0)) {
-                stretch(e) = stretch(t);
-                stretch_order(e) = stretch_order(t);
-            }
-            if (shrink_order(e) == shrink_order(t)) {
-                shrink(e) = expr_a(shrink(e), shrink(t));
-            } else if ((shrink_order(e) < shrink_order(t)) && (shrink(t) != 0)) {
-                shrink(e) = shrink(t);
-                shrink_order(e) = shrink_order(t);
-            }
-            flush_node(t);
-            normalize_glue(e);
-        }
-        r = o;
-    }
-    b = arith_error;
-    if (o != expr_none)
-        goto CONTINUE;
-    if (p != null) {
-        /* Pop the expression stack and |goto found| */
-        f = e;
-        q = p;
-        e = expr_e_field(q);
-        t = expr_t_field(q);
-        n = expr_n_field(q);
-        s = expr_state(q) / 4;
-        r = expr_state(q) % 4;
-        l = expr_type(q);
-        p = vlink(q);
-        flush_node(q);
-        goto FOUND;
-    }
-
-    if (b) {
-        print_err("Arithmetic overflow");
-        help2("I can't evaluate this expression,",
-              "since the result is out of range.");
-        error();
-        if (l >= glue_val_level) {
-            reset_glue_to_zero(e);
-        } else {
-            e = 0;
-        }
-    }
-    arith_error = a;
-    cur_val = e;
-    cur_val_level = l;
-}
diff --git a/texk/web2c/luatexdir/tex/stringpool.w b/texk/web2c/luatexdir/tex/stringpool.c
similarity index 53%
rename from texk/web2c/luatexdir/tex/stringpool.w
rename to texk/web2c/luatexdir/tex/stringpool.c
index 5972657f5..bc09f814b 100644
--- a/texk/web2c/luatexdir/tex/stringpool.w
+++ b/texk/web2c/luatexdir/tex/stringpool.c
@@ -1,69 +1,89 @@
-% stringpool.w
-%
-% Copyright 2009-2010 Taco Hoekwater <taco@@luatex.org>
-%
-% This file is part of LuaTeX.
-%
-% LuaTeX is free software; you can redistribute it and/or modify it under
-% the terms of the GNU General Public License as published by the Free
-% Software Foundation; either version 2 of the License, or (at your
-% option) any later version.
-%
-% LuaTeX is distributed in the hope that it will be useful, but WITHOUT
-% ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-% FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
-% License for more details.
-%
-% You should have received a copy of the GNU General Public License along
-% with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
-
-@ @c
+/*
 
+stringpool.w
+
+Copyright 2009-2010 Taco Hoekwater <taco@@luatex.org>
+
+This file is part of LuaTeX.
+
+LuaTeX is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 2 of the License, or (at your
+option) any later version.
+
+LuaTeX is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+License for more details.
+
+You should have received a copy of the GNU General Public License along
+with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+
+*/
 
 #include "ptexlib.h"
 
-@ Control sequence names and diagnostic messages are variable-length strings
-of eight-bit characters. Since PASCAL did not have a well-developed string
+/*tex
+
+Control sequence names and diagnostic messages are variable-length strings of
+eight-bit characters. Since PASCAL did not have a well-developed string
 mechanism, \TeX\ did all of its string processing by homegrown methods.
 
-Elaborate facilities for dynamic strings are not needed, so all of the
-necessary operations can be handled with a simple data structure.
-The array |str_pool| contains all of the (eight-bit) bytes off all
-of the strings, and the array |str_start| contains indices of the starting
-points of each string. Strings are referred to by integer numbers, so that
-string number |s| comprises the characters |str_pool[j]| for
-|str_start_macro(s)<=j<str_start_macro(s+1)|. Additional integer variables
-|pool_ptr| and |str_ptr| indicate the number of entries used so far
-in |str_pool| and |str_start|, respectively; locations
-|str_pool[pool_ptr]| and |str_start_macro(str_ptr)| are
-ready for the next string to be allocated.
-
-String numbers 0 to |biggest_char| are reserved for strings that correspond to 
+Elaborate facilities for dynamic strings are not needed, so all of the necessary
+operations can be handled with a simple data structure. The array |str_pool|
+contains all of the (eight-bit) bytes off all of the strings, and the array
+|str_start| contains indices of the starting points of each string. Strings are
+referred to by integer numbers, so that string number |s| comprises the
+characters |str_pool[j]| for |str_start_macro(s)<=j<str_start_macro(s+1)|.
+Additional integer variables |pool_ptr| and |str_ptr| indicate the number of
+entries used so far in |str_pool| and |str_start|, respectively; locations
+|str_pool[pool_ptr]| and |str_start_macro(str_ptr)| are ready for the next string
+to be allocated.
+
+String numbers 0 to |biggest_char| are reserved for strings that correspond to
 single UNICODE characters. This is in accordance with the conventions of \.{WEB}
-which converts single-character strings into the ASCII code number of the
-single character involved.
+which converts single-character strings into the ASCII code number of the single
+character involved.
+
+*/
+
+/*tex The array of strings: */
+
+lstring *string_pool;
+
+/*tex
+    This variable lives |STRING_OFFSET| below |string_pool| (handy for debugging:
+    |_string_pool[str_ptr] == str_string(str_ptr)|:
+*/
+
+lstring *_string_pool;
+
+/*tex The number of the current string being created: */
+
+str_number str_ptr = (STRING_OFFSET + 1);
+
+/*tex The starting value of |str_ptr|: */
 
-@c
-lstring *string_pool;           /* the array of strings */
-lstring *_string_pool;          /* this variable lives |STRING_OFFSET| below |string_pool| 
-                                   (handy for debugging: 
-                                   |_string_pool[str_ptr] == str_string(str_ptr)| */
+str_number init_str_ptr;
 
-str_number str_ptr = (STRING_OFFSET + 1);       /* number of the current string being created */
-str_number init_str_ptr;        /* the starting value of |str_ptr| */
+/*tex
+    The current string buffer, the current index in that buffer, the malloced
+    size of |cur_string| and the occupied byte count:
+*/
 
-unsigned char *cur_string;      /*  current string buffer */
-unsigned cur_length;            /* current index in that buffer */
-unsigned cur_string_size;       /*  malloced size of |cur_string| */
-unsigned pool_size;             /* occupied byte count */
+unsigned char *cur_string;
+unsigned cur_length;
+unsigned cur_string_size;
+unsigned pool_size;
 
+/*tex
 
-@ Once a sequence of characters has been appended to |cur_string|, it
-officially becomes a string when the function |make_string| is called.
-This function returns the identification number of the new string as its
-value.
+Once a sequence of characters has been appended to |cur_string|, it officially
+becomes a string when the function |make_string| is called. This function returns
+the identification number of the new string as its value.
+
+*/
 
-@c
 void reset_cur_string(void)
 {
     cur_length = 0;
@@ -72,44 +92,41 @@ void reset_cur_string(void)
     memset(cur_string, 0, 256);
 }
 
-@  current string enters the pool 
-@c
 str_number make_string(void)
 {
-    if (str_ptr == (max_strings + STRING_OFFSET))
-        overflow("number of strings",
-                 (unsigned) (max_strings - init_str_ptr + STRING_OFFSET));
+    if (str_ptr == (max_strings + STRING_OFFSET)) {
+        overflow(
+            "number of strings",
+             (unsigned) (max_strings - init_str_ptr + STRING_OFFSET)
+        );
+    }
     str_room(1);
     cur_string[cur_length] = '\0';      /* now |lstring.s| is always a valid C string */
     str_string(str_ptr) = (unsigned char *) cur_string;
     str_length(str_ptr) = cur_length;
     pool_size += cur_length;
     reset_cur_string();
-#if 0
-    printf("Made a string: %s (s=%d)\n", (char *)str_string(str_ptr), (int)str_ptr);
-#endif
     str_ptr++;
     return (str_ptr - 1);
 }
 
-@ @c
 int pool_to_unichar(unsigned char *t)
 {
     return (int) str2uni(t);
 }
 
+/*tex
 
+The following subroutine compares string |s| with another string of the same
+length that appears in |buffer| starting at position |k|; the result is |true| if
+and only if the strings are equal. Empirical tests indicate that |str_eq_buf| is
+used in such a way that it tends to return |true| about 80 percent of the time.
 
-@ The following subroutine compares string |s| with another string of the
-same length that appears in |buffer| starting at position |k|;
-the result is |true| if and only if the strings are equal.
-Empirical tests indicate that |str_eq_buf| is used in such a way that
-it tends to return |true| about 80 percent of the time.
+*/
 
-@c
 boolean str_eq_buf(str_number s, int k)
-{                               /* test equality of strings */
-    int a;                      /* a unicode character */
+{
+    int a;
     if (s < STRING_OFFSET) {
         a = buffer_to_unichar(k);
         if (a != s)
@@ -125,15 +142,17 @@ boolean str_eq_buf(str_number s, int k)
     return true;
 }
 
+/*tex
+
+Here is a similar routine, but it compares two strings in the string pool, and it
+does not assume that they have the same length.
 
-@ Here is a similar routine, but it compares two strings in the string pool,
-and it does not assume that they have the same length.
+*/
 
-@c
 boolean str_eq_str(str_number s, str_number t)
-{                               /* test equality of strings */
-    int a = 0;                  /* a utf char */
-    unsigned char *j, *k, *l;   /* running indices */
+{
+    int a = 0;
+    unsigned char *j, *k, *l;
     if (s < STRING_OFFSET) {
         if (t >= STRING_OFFSET) {
             k = str_string(t);
@@ -167,8 +186,8 @@ boolean str_eq_str(str_number s, str_number t)
     return true;
 }
 
-@ string compare 
-@c
+/*tex A string compare helper: */
+
 boolean str_eq_cstr(str_number r, const char *s, size_t l)
 {
     if (l != (size_t) str_length(r))
@@ -177,43 +196,47 @@ boolean str_eq_cstr(str_number r, const char *s, size_t l)
 }
 
 
-@ The initial values of |str_pool|, |str_start|, |pool_ptr|,
-and |str_ptr| are computed by the \.{INITEX} program, based in part
-on the information that \.{WEB} has output while processing \TeX.
+/*tex
 
-The first |string_offset| strings are single-characters strings matching
-Unicode. There is no point in generating all of these. But |str_ptr| has
-initialized properly, otherwise |print_char| cannot see the difference
-between characters and strings.
+The initial values of |str_pool|, |str_start|, |pool_ptr|, and |str_ptr| are
+computed by the \.{INITEX} program, based in part on the information that \.{WEB}
+has output while processing \TeX.
 
+The first |string_offset| strings are single-characters strings matching Unicode.
+There is no point in generating all of these. But |str_ptr| has initialized
+properly, otherwise |print_char| cannot see the difference between characters and
+strings.
+
+*/
 
-@ initializes the string pool, but returns |false| if something goes wrong 
-@c
 boolean get_strings_started(void)
 {
     reset_cur_string();
     return true;
 }
 
-@ The string recycling routines.
-   \TeX{} uses 2 upto 4 {\it new\/} strings when scanning a filename in an
-   \.{\\input}, \.{\\openin}, or \.{\\openout} operation.  These strings are
-   normally lost because the reference to them are not saved after finishing
-   the operation.  |search_string| searches through the string pool for the
-   given string and returns either 0 or the found string number.
+/*tex
+
+The string recycling routines. \TeX{} uses 2 upto 4 {\it new\/} strings when
+scanning a filename in an \.{\\input}, \.{\\openin}, or \.{\\openout} operation.
+These strings are normally lost because the reference to them are not saved after
+finishing the operation. |search_string| searches through the string pool for the
+given string and returns either 0 or the found string number.
+
+*/
 
-@c
 str_number search_string(str_number search)
 {
-    str_number s;               /* running index */
-    size_t len;                 /* length of searched string */
+    str_number s;
+    size_t len;
     len = str_length(search);
     if (len == 0) {
         return get_nullstr();
     } else {
-        s = search - 1;         /* start search with newest string below |s|; |search>1|! */
+        /*tex We start the search with newest string below |s|; |search>1|! */
+        s = search - 1;
         while (s >= STRING_OFFSET) {
-            /* first |string_offset| strings depend on implementation!! */
+            /* The first |string_offset| of strings depend on the implementation! */
             if (str_length(s) == len)
                 if (str_eq_str(s, search))
                     return s;
@@ -223,7 +246,6 @@ str_number search_string(str_number search)
     return 0;
 }
 
-@ @c
 str_number maketexstring(const char *s)
 {
     if (s == NULL || *s == 0)
@@ -231,7 +253,6 @@ str_number maketexstring(const char *s)
     return maketexlstring(s, strlen(s));
 }
 
-@ @c
 str_number maketexlstring(const char *s, size_t l)
 {
     if (s == NULL || l == 0)
@@ -243,8 +264,12 @@ str_number maketexlstring(const char *s, size_t l)
     return (str_ptr - 1);
 }
 
-@ append a C string to a TeX string
-@c
+/*tex
+
+    This appends a C string to a \TEX\ string:
+
+*/
+
 void append_string(const unsigned char *s, unsigned l)
 {
     if (s == NULL || *s == 0)
@@ -256,14 +281,12 @@ void append_string(const unsigned char *s, unsigned l)
     return;
 }
 
-@ @c
 char *makecstring(int s)
 {
     size_t l;
     return makeclstring(s, &l);
 }
 
-@ @c
 char *makeclstring(int s, size_t * len)
 {
     if (s < STRING_OFFSET) {
@@ -279,7 +302,6 @@ char *makeclstring(int s, size_t * len)
     }
 }
 
-@ @c
 int dump_string_pool(void)
 {
     int j;
@@ -297,7 +319,6 @@ int dump_string_pool(void)
     return (k - STRING_OFFSET);
 }
 
-@ @c
 int undump_string_pool(void)
 {
     int j;
@@ -325,7 +346,6 @@ int undump_string_pool(void)
     return str_ptr;
 }
 
-@ @c
 void init_string_pool_array(unsigned s)
 {
     string_pool = xmallocarray(lstring, s);
@@ -336,14 +356,16 @@ void init_string_pool_array(unsigned s)
     string_pool[0].s[0] = '\0';
 }
 
-@ To destroy an already made string, we say |flush_str|. 
-@c
+/*tex
+
+    To destroy an already made string, we say |flush_str|.
+
+*/
+
 void flush_str(str_number s)
 {
-#if 0	
-    printf("Flushing a string: %s (s=%d,str_ptr=%d)\n", (char *)str_string(s), (int)s, (int)str_ptr); 
-#endif
-    if (s > STRING_OFFSET) {    /* don't ever delete the null string */
+    if (s > STRING_OFFSET) {
+        /*tex Don't ever delete the null string! */
         pool_size -= (unsigned) str_length(s);
         str_length(s) = 0;
         xfree(str_string(s));
diff --git a/texk/web2c/luatexdir/tex/texdeffont.w b/texk/web2c/luatexdir/tex/texdeffont.c
similarity index 50%
rename from texk/web2c/luatexdir/tex/texdeffont.w
rename to texk/web2c/luatexdir/tex/texdeffont.c
index 7fe5ae1e1..f0b057d40 100644
--- a/texk/web2c/luatexdir/tex/texdeffont.w
+++ b/texk/web2c/luatexdir/tex/texdeffont.c
@@ -1,57 +1,73 @@
-% texdeffont.w
-%
-% Copyright 2008-2010 Taco Hoekwater <taco@@luatex.org>
-%
-% This file is part of LuaTeX.
-%
-% LuaTeX is free software; you can redistribute it and/or modify it under
-% the terms of the GNU General Public License as published by the Free
-% Software Foundation; either version 2 of the License, or (at your
-% option) any later version.
-%
-% LuaTeX is distributed in the hope that it will be useful, but WITHOUT
-% ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-% FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
-% License for more details.
-%
-% You should have received a copy of the GNU General Public License along
-% with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
-
-@ @c
+/*
 
+texdeffont.w
+
+Copyright 2008-2010 Taco Hoekwater <taco@@luatex.org>
+
+This file is part of LuaTeX.
+
+LuaTeX is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 2 of the License, or (at your
+option) any later version.
+
+LuaTeX is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+License for more details.
+
+You should have received a copy of the GNU General Public License along
+with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+
+*/
 
 #include "ptexlib.h"
 
-@ When the user defines \.{\\font\\f}, say, \TeX\ assigns an internal number
-to the user's font~\.{\\f}. Adding this number to |font_id_base| gives the
-|eqtb| location of a ``frozen'' control sequence that will always select
-the font.
+/*tex
+
+When the user defines \.{\\font\\f}, say, \TeX\ assigns an internal number to the
+user's font~\.{\\f}. Adding this number to |font_id_base| gives the |eqtb|
+location of a ``frozen'' control sequence that will always select the font.
+
+The variable |a| in the following code indicates the global nature of the value
+to be set. It's used in the |define| macro. Here we're never global.
+
+There's not much scanner code here because the other scanners are defined where
+they make most sense.
+
+*/
 
-@c
 int font_bytes;
 
 void set_cur_font(internal_font_number f)
 {
-    int a = 0;                  /* never global */
+    int a = 0;
     define(cur_font_loc, data_cmd, f);
 }
 
-@ @c
+/*tex
+
+    This prints a scaled real, rounded to five digits.
+
+*/
+
 static char *scaled_to_string(scaled s)
-{                               /* prints scaled real, rounded to five digits */
+{
     static char result[16];
     int n, k;
-    scaled delta;               /* amount of allowable inaccuracy */
+    /*tex The amount of allowable inaccuracy: */
+    scaled delta;
     k = 0;
     if (s < 0) {
+        /*tex Only print the sign, if negative */
         result[k++] = '-';
-        s = -s;                 /* print the sign, if negative */
+        s = -s;
     }
     {
         int l = 0;
         char digs[8] = { 0 };
         n = s / unity;
-        /* process the integer part */
+        /*tex Process the integer part: */
         do {
             digs[l++] = (char) (n % 10);
             n = n / 10;;
@@ -64,29 +80,37 @@ static char *scaled_to_string(scaled s)
     s = 10 * (s % unity) + 5;
     delta = 10;
     do {
-        if (delta > unity)
-            s = s + 0100000 - 050000;   /* round the last digit */
+        if (delta > unity) {
+            /*tex Round the last digit: */
+            s = s + 0100000 - 050000;
+        }
         result[k++] = (char) ('0' + (s / unity));
         s = 10 * (s % unity);
         delta = delta * 10;
     } while (s > delta);
-
     result[k] = 0;
     return (char *) result;
 }
 
-@ @c
 void tex_def_font(small_number a)
 {
-    pointer u;                  /* user's font identifier */
-    internal_font_number f;     /* runs through existing fonts */
-    str_number t;               /* name for the frozen font identifier */
-    int old_setting;            /* holds |selector| setting */
-    scaled s = -1000;           /* stated ``at'' size, or negative of scaled magnification */
-    int natural_dir = -1;       /* the natural direction of the font */
+    /*tex The user's font identifier. */
+    pointer u;
+    /*tex This runs through existing fonts. */
+    internal_font_number f;
+    /*tex The name for the frozen font identifier. */
+    str_number t;
+    /*tex Thos holds the |selector| setting. */
+    int old_setting;
+    /*tex Stated `at' size, or negative of scaled magnification. */
+    scaled s = -1000;
+    /*tex The natural direction of the font. */
+    int natural_dir = -1;
     char *fn;
-    if (job_name == 0)
-        open_log_file();        /* avoid confusing \.{texput} with the font name */
+    if (job_name == 0) {
+        /*tex Avoid confusing \.{texput} with the font name. */
+        open_log_file();
+    }
     get_r_token();
     u = cur_cs;
     if (u >= null_cs)
@@ -99,7 +123,7 @@ void tex_def_font(small_number a)
         eq_define(u, set_font_cmd, null_font);
     }
     scan_optional_equals();
-    /* Get the next non-blank non-call token; */
+    /*tex Get the next non-blank non-call token. */
     do {
         get_x_token();
     } while ((cur_cmd == spacer_cmd) || (cur_cmd == relax_cmd));
@@ -108,8 +132,10 @@ void tex_def_font(small_number a)
         back_input();
         scan_file_name();
         if (cur_area != get_nullstr() || cur_ext != get_nullstr()) {
-            /* Have to do some rescue-ing here, fonts only have a name,
-               no area nor extension */
+            /*tex
+                Have to do some rescue-ing here, fonts only have a name, no area
+                nor extension.
+            */
             old_setting = selector;
             selector = new_string;
             if (cur_area != get_nullstr()) {
@@ -134,26 +160,27 @@ void tex_def_font(small_number a)
         token_show(def_ref);
         selector = old_setting;
         flush_list(def_ref);
-        /* |str_room(1)|; *//* what did that do ? */
         cur_name = make_string();
         cur_ext = get_nullstr();
         cur_area = get_nullstr();
     }
-    /* Scan the font size specification; */
-    name_in_progress = true;    /* this keeps |cur_name| from being changed */
+    /*tex
+        Scan the font size specification. The next variable keeps |cur_name| from
+        being changed
+    */
+    name_in_progress = true;
     if (scan_keyword("at")) {
-        /* Put the positive `at' size into |s| */
+        /*tex Put the positive `at' size into |s|. */
         scan_normal_dimen();
         s = cur_val;
         if ((s <= 0) || (s >= 01000000000)) {
             char err[256];
-            const char *errhelp[] =
-                { "I can only handle fonts at positive sizes that are",
+            const char *errhelp[] = {
+                "I can only handle fonts at positive sizes that are",
                 "less than 2048pt, so I've changed what you said to 10pt.",
                 NULL
             };
-            snprintf(err, 255, "Improper `at' size (%spt), replaced by 10pt",
-                     scaled_to_string(s));
+            snprintf(err, 255, "Improper `at' size (%spt), replaced by 10pt", scaled_to_string(s));
             tex_error(err, errhelp);
             s = 10 * unity;
         }
@@ -162,27 +189,31 @@ void tex_def_font(small_number a)
         s = -cur_val;
         if ((cur_val <= 0) || (cur_val > 32768)) {
             char err[256];
-            const char *errhelp[] =
-                { "The magnification ratio must be between 1 and 32768.",
+            const char *errhelp[] = {
+                "The magnification ratio must be between 1 and 32768.",
                 NULL
             };
-            snprintf(err, 255,
-                     "Illegal magnification has been changed to 1000 (%d)",
-                     (int) cur_val);
+            snprintf(err, 255, "Illegal magnification has been changed to 1000 (%d)", (int) cur_val);
             tex_error(err, errhelp);
             s = -1000;
         }
     }
+    /*tex
+        There is no real reason to support this obsolete key as there are no useful
+        fonts out there so let's get rid of this overhead. This also means that
+        |natural_dir| can go away.
+    */
+    /*
     if (scan_keyword("naturaldir")) {
         scan_direction();
         natural_dir = cur_val;
     }
+    */
     name_in_progress = false;
     fn = makecstring(cur_name);
     f = read_font_info(u, fn, s, natural_dir);
     xfree(fn);
     equiv(u) = f;
-
     eqtb[font_id_base + f] = eqtb[u];
     cs_text(font_id_base + f) = t;
 }
diff --git a/texk/web2c/luatexdir/tex/texfileio.c b/texk/web2c/luatexdir/tex/texfileio.c
new file mode 100644
index 000000000..143e694e1
--- /dev/null
+++ b/texk/web2c/luatexdir/tex/texfileio.c
@@ -0,0 +1,1509 @@
+/*
+
+Copyright 2009-2010 Taco Hoekwater <taco@luatex.org>
+
+This file is part of LuaTeX.
+
+LuaTeX is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 2 of the License, or (at your
+option) any later version.
+
+LuaTeX is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+License for more details.
+
+You should have received a copy of the GNU General Public License along
+with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#include "ptexlib.h"
+
+#include <string.h>
+#include <kpathsea/absolute.h>
+
+/*tex
+
+The bane of portability is the fact that different operating systems treat input
+and output quite differently, perhaps because computer scientists have not given
+sufficient attention to this problem. People have felt somehow that input and
+output are not part of ``real'' programming. Well, it is true that some kinds of
+programming are more fun than others. With existing input/output conventions
+being so diverse and so messy, the only sources of joy in such parts of the code
+are the rare occasions when one can find a way to make the program a little less
+bad than it might have been. We have two choices, either to attack I/O now and
+get it over with, or to postpone I/O until near the end. Neither prospect is very
+attractive, so let's get it over with.
+
+The basic operations we need to do are (1)~inputting and outputting of text, to
+or from a file or the user's terminal; (2)~inputting and outputting of eight-bit
+bytes, to or from a file; (3)~instructing the operating system to initiate
+(``open'') or to terminate (``close'') input or output from a specified file;
+(4)~testing whether the end of an input file has been reached.
+
+\TeX\ needs to deal with two kinds of files. We shall use the term |alpha_file|
+for a file that contains textual data, and the term |byte_file| for a file that
+contains eight-bit binary information. These two types turn out to be the same on
+many computers, but sometimes there is a significant distinction, so we shall be
+careful to distinguish between them. Standard protocols for transferring such
+files from computer to computer, via high-speed networks, are now becoming
+available to more and more communities of users.
+
+The program actually makes use also of a third kind of file, called a
+|word_file|, when dumping and reloading base information for its own
+initialization. We shall define a word file later; but it will be possible for us
+to specify simple operations on word files before they are defined.
+
+We finally did away with |nameoffile| and |namelength|, but the variables have to
+be kept otherwise there will be link errors from |openclose.c| in the web2c
+library
+
+*/
+
+char *nameoffile;
+int namelength;
+
+/*tex
+
+    When input files are opened via a callback, they will also be read using
+    callbacks. for that purpose, the |open_read_file_callback| returns an integer
+    to uniquely identify a callback table. This id replaces the file point |f| in
+    this case, because the input does not have to be a file in the traditional
+    sense.
+
+    Signalling this fact is achieved by having two arrays of integers.
+
+*/
+
+int *input_file_callback_id;
+int read_file_callback_id[17];
+
+/*tex
+
+    Here we handle |-output-directory|. We assume that it is OK to look here
+    first. Possibly it would be better to replace lookups in "." with lookups in
+    the |output_directory| followed by "." but to do this requires much more
+    invasive surgery in libkpathsea.
+
+*/
+
+static char *find_in_output_directory(const char *s)
+{
+    if (output_directory && !kpse_absolute_p(s, false)) {
+        FILE *f_ptr;
+        char *ftemp = concat3(output_directory, DIR_SEP_STRING, s);
+        /*tex This code is used for input files only. */
+        f_ptr = fopen(ftemp, "rb");
+        if (f_ptr) {
+            fclose(f_ptr);
+            return ftemp;
+        } else {
+            free(ftemp);
+
+        }
+    }
+    return NULL;
+}
+
+/*tex
+
+    Find an \.{\\input} or \.{\\read} file. |n| differentiates between those
+    case.
+
+*/
+
+int kpse_available(const char *m) {
+    if (!kpse_init) {
+        fprintf(stdout,"missing kpse replacement callback '%s', quitting\n",m);
+        exit(1);
+    }
+    return 1 ;
+}
+
+char *luatex_find_read_file(const char *s, int n, int callback_index)
+{
+    char *ftemp = NULL;
+    int callback_id = callback_defined(callback_index);
+    if (callback_id > 0) {
+        (void) run_callback(callback_id, "dS->R", n, s, &ftemp);
+    } else if (kpse_available("find_read_file")) {
+        /*tex Use kpathsea here. */
+        ftemp = find_in_output_directory(s);
+        if (!ftemp)
+            ftemp = kpse_find_file(s, kpse_tex_format, 1);
+    }
+    if (ftemp) {
+        if (fullnameoffile)
+            free(fullnameoffile);
+        fullnameoffile = xstrdup(ftemp);
+    }
+    return ftemp;
+}
+
+/*tex Find other files types. */
+
+char *luatex_find_file(const char *s, int callback_index)
+{
+    char *ftemp = NULL;
+    int callback_id = callback_defined(callback_index);
+    if (callback_id > 0) {
+        (void) run_callback(callback_id, "S->R", s, &ftemp);
+    } else if (kpse_available("find_read_file")) {
+        /*tex Use kpathsea here. */
+        switch (callback_index) {
+            case find_enc_file_callback:
+                ftemp = kpse_find_file(s, kpse_enc_format, 0);
+                break;
+            case find_map_file_callback:
+                ftemp = kpse_find_file(s, kpse_fontmap_format, 0);
+                break;
+            case find_type1_file_callback:
+                ftemp = kpse_find_file(s, kpse_type1_format, 0);
+                break;
+            case find_truetype_file_callback:
+                ftemp = kpse_find_file(s, kpse_truetype_format, 0);
+                break;
+            case find_opentype_file_callback:
+                ftemp = kpse_find_file(s, kpse_opentype_format, 0);
+                if (ftemp == NULL)
+                    ftemp = kpse_find_file(s, kpse_truetype_format, 0);
+                break;
+            case find_data_file_callback:
+                ftemp = find_in_output_directory(s);
+                if (!ftemp)
+                    ftemp = kpse_find_file(s, kpse_tex_format, 1);
+                break;
+            case find_font_file_callback:
+                ftemp = kpse_find_file(s, kpse_ofm_format, 1);
+                if (ftemp == NULL)
+                    ftemp = kpse_find_file(s, kpse_tfm_format, 1);
+                break;
+            case find_vf_file_callback:
+                ftemp = kpse_find_file(s, kpse_ovf_format, 0);
+                if (ftemp == NULL)
+                    ftemp = kpse_find_file(s, kpse_vf_format, 0);
+                break;
+            case find_cidmap_file_callback:
+                ftemp = kpse_find_file(s, kpse_cid_format, 0);
+                break;
+            default:
+                printf("luatex_find_file(): do not know how to handle file %s of type %d\n", s, callback_index);
+                break;
+        }
+    }
+    return ftemp;
+}
+
+/*tex
+
+    \LUATEX\ used to have private functions for these that did not use kpathsea,
+    but since the file paranoia tests have to come from kpathsea anyway, that is
+    no longer useful. The only downside to using luatex is that if one wants to
+    disable kpathsea via the Lua startup script, it is now an absolute
+    requirement that all file discovery callbacks are specified. Just using the
+    find_read_file, but not setting open_read_file, for example, does not work
+    any more if kpathsea is not to be used at all.
+
+*/
+
+#define openoutnameok(A) kpse_out_name_ok (A)
+#define openinnameok(A)  kpse_in_name_ok (A)
+
+/*tex
+
+    Open an input file F, using the kpathsea format FILEFMT and passing
+    |FOPEN_MODE| to fopen. The filename is in `fn'. We return whether or not the
+    open succeeded.
+
+*/
+
+boolean luatex_open_input(FILE ** f_ptr, const char *fn, int filefmt, const_string fopen_mode, boolean must_exist)
+{
+    /*tex We haven't found anything yet. */
+    string fname = NULL;
+    *f_ptr = NULL;
+    if (fullnameoffile)
+        free(fullnameoffile);
+    fullnameoffile = NULL;
+    fname = kpse_find_file(fn, (kpse_file_format_type) filefmt, must_exist);
+    if (fname) {
+        fullnameoffile = xstrdup(fname);
+        /*tex
+
+            If we found the file in the current directory, don't leave the `./'
+            at the beginning of `fn', since it looks dumb when `tex foo' says
+            `(./foo.tex ... )'. On the other hand, if the user said `tex ./foo',
+            and that's what we opened, then keep it -- the user specified it, so
+            we shouldn't remove it.
+
+        */
+        if (fname[0] == '.' && IS_DIR_SEP(fname[1]) && (fn[0] != '.' || !IS_DIR_SEP(fn[1]))) {
+            unsigned i = 0;
+            while (fname[i + 2] != 0) {
+                fname[i] = fname[i + 2];
+                i++;
+            }
+            fname[i] = 0;
+        }
+        /*tex This fopen is not allowed to fail. */
+        *f_ptr = xfopen(fname, fopen_mode);
+    }
+    if (*f_ptr) {
+        recorder_record_input(fname);
+    }
+    return *f_ptr != NULL;
+}
+
+boolean luatex_open_output(FILE ** f_ptr, const char *fn, const_string fopen_mode)
+{
+    char *fname;
+    boolean absolute = kpse_absolute_p(fn, false);
+    /*tex If we have an explicit output directory, use it. */
+    if (output_directory && !absolute) {
+        fname = concat3(output_directory, DIR_SEP_STRING, fn);
+    } else {
+        fname = xstrdup(fn);
+    }
+    /*tex Is the filename openable as given?  */
+    *f_ptr = fopen(fname, fopen_mode);
+    if (!*f_ptr) {
+        /*tex Can't open as given. Try the envvar.  */
+        string texmfoutput = kpse_var_value("TEXMFOUTPUT");
+        if (texmfoutput && *texmfoutput && !absolute) {
+            fname = concat3(texmfoutput, DIR_SEP_STRING, fn);
+            *f_ptr = fopen(fname, fopen_mode);
+        }
+    }
+    if (*f_ptr) {
+        recorder_record_output(fname);
+    }
+    free(fname);
+    return *f_ptr != NULL;
+}
+
+boolean lua_a_open_in(alpha_file * f, char *fn, int n)
+{
+    int k;
+    char *fnam;
+    int callback_id;
+    boolean ret = true;
+    boolean file_ok = true;
+    if (n == 0) {
+        input_file_callback_id[iindex] = 0;
+    } else {
+        read_file_callback_id[n] = 0;
+    }
+    if (*fn == '|')
+        fnam = fn;
+    else
+        fnam = luatex_find_read_file(fn, n, find_read_file_callback);
+    if (!fnam)
+        return false;
+    callback_id = callback_defined(open_read_file_callback);
+    if (callback_id > 0) {
+        k = run_and_save_callback(callback_id, "S->", fnam);
+        if (k > 0) {
+            ret = true;
+            if (n == 0)
+                input_file_callback_id[iindex] = k;
+            else
+                read_file_callback_id[n] = k;
+        } else {
+            /*tex read failed */
+            file_ok = false;
+        }
+    } else {
+        /*tex no read callback */
+        if (openinnameok(fnam)) {
+            ret = open_in_or_pipe(f, fnam, kpse_tex_format, FOPEN_RBIN_MODE, (n == 0 ? true : false));
+        } else {
+            /*tex open failed */
+            file_ok = false;
+        }
+    }
+    if (!file_ok) {
+        ret = false;
+    }
+    return ret;
+}
+
+boolean lua_a_open_out(alpha_file * f, char *fn, int n)
+{
+    boolean test;
+    str_number fnam;
+    int callback_id;
+    boolean ret = false;
+    callback_id = callback_defined(find_write_file_callback);
+    if (callback_id > 0) {
+        fnam = 0;
+        test = run_callback(callback_id, "dS->s", n, fn, &fnam);
+        if ((test) && (fnam != 0) && (str_length(fnam) > 0)) {
+            /*tex
+
+                There is no message here because if that is needed the macro
+                package should do that in the callback code. As elsewhere,
+                messaging is left to \LUA\ then.
+
+            */
+            ret = open_outfile(f, fn, FOPEN_W_MODE);
+        }
+    } else {
+        if (openoutnameok(fn)) {
+            if (n > 0 && selector != term_only) {
+                /*tex
+
+                    This message to the log is for downward compatibility with
+                    other tex's as there are scripts out there that act on this
+                    message. An alternative is to let a macro package write an
+                    explicit message.
+
+                */
+                fprintf(log_file,"\n\\openout%i = %s\n",n-1,fn);
+             }
+             ret = open_out_or_pipe(f, fn, FOPEN_W_MODE);
+        }
+    }
+    return ret;
+}
+
+boolean lua_b_open_out(alpha_file * f, char *fn)
+{
+    boolean test;
+    str_number fnam;
+    int callback_id;
+    boolean ret = false;
+    callback_id = callback_defined(find_output_file_callback);
+    if (callback_id > 0) {
+        fnam = 0;
+        test = run_callback(callback_id, "S->s", fn, &fnam);
+        if ((test) && (fnam != 0) && (str_length(fnam) > 0)) {
+            ret = open_outfile(f, fn, FOPEN_WBIN_MODE);
+        }
+    } else {
+        if (openoutnameok(fn)) {
+            ret = luatex_open_output(f, fn, FOPEN_WBIN_MODE);
+        }
+    }
+    return ret;
+}
+
+void lua_a_close_in(alpha_file f, int n)
+{
+    int callback_id;
+    if (n == 0)
+        callback_id = input_file_callback_id[iindex];
+    else
+        callback_id = read_file_callback_id[n];
+    if (callback_id > 0) {
+        run_saved_callback(callback_id, "close", "->");
+        destroy_saved_callback(callback_id);
+        if (n == 0)
+            input_file_callback_id[iindex] = 0;
+        else
+            read_file_callback_id[n] = 0;
+    } else {
+        close_file_or_pipe(f);
+    }
+}
+
+void lua_a_close_out(alpha_file f)
+{
+    close_file_or_pipe(f);
+}
+
+/*tex
+
+    Binary input and output are done with C's ordinary procedures, so we don't
+    have to make any other special arrangements for binary~I/O. Text output is
+    also easy to do with standard routines. The treatment of text input is more
+    difficult, however, because of the necessary translation to |ASCII_code|
+    values. \TeX's conventions should be efficient, and they should blend nicely
+    with the user's operating environment.
+
+    Input from text files is read one line at a time, using a routine called
+    |lua_input_ln|. This function is defined in terms of global variables called
+    |buffer|, |first|, and |last| that will be described in detail later; for
+    now, it suffices for us to know that |buffer| is an array of |ASCII_code|
+    values, and that |first| and |last| are indices into this array representing
+    the beginning and ending of a line of text.
+
+*/
+
+/*tex lines of characters being read */
+
+packed_ASCII_code *buffer;
+
+/*tex the first unused position in |buffer| */
+
+int first;
+
+/*tex end of the line just input to |buffer| */
+
+int last;
+
+/*tex largest index used in |buffer| */
+
+int max_buf_stack;
+
+/*tex
+
+    The |lua_input_ln| function brings the next line of input from the specified
+    file into available positions of the buffer array and returns the value
+    |true|, unless the file has already been entirely read, in which case it
+    returns |false| and sets |last:=first|. In general, the |ASCII_code| numbers
+    that represent the next line of the file are input into |buffer[first]|,
+    |buffer[first+1]|, \dots, |buffer[last-1]|; and the global variable |last| is
+    set equal to |first| plus the length of the line. Trailing blanks are removed
+    from the line; thus, either |last=first| (in which case the line was entirely
+    blank) or |buffer[last-1]<>" "|.
+
+    An overflow error is given, however, if the normal actions of |lua_input_ln|
+    would make |last>=buf_size|; this is done so that other parts of \TeX\ can
+    safely look at the contents of |buffer[last+1]| without overstepping the
+    bounds of the |buffer| array. Upon entry to |lua_input_ln|, the condition
+    |first<buf_size| will always hold, so that there is always room for an
+    ``empty'' line.
+
+    The variable |max_buf_stack|, which is used to keep track of how large the
+    |buf_size| parameter must be to accommodate the present job, is also kept up
+    to date by |lua_input_ln|.
+
+    If the |bypass_eoln| parameter is |true|, |lua_input_ln| will do a |get|
+    before looking at the first character of the line; this skips over an |eoln|
+    that was in |f^|. The procedure does not do a |get| when it reaches the end
+    of the line; therefore it can be used to acquire input from the user's
+    terminal as well as from ordinary text files.
+
+    Since the inner loop of |lua_input_ln| is part of \TeX's ``inner
+    loop''---each character of input comes in at this place---it is wise to
+    reduce system overhead by making use of special routines that read in an
+    entire array of characters at once, if such routines are available.
+
+*/
+
+boolean lua_input_ln(alpha_file f, int n, boolean bypass_eoln)
+{
+    boolean lua_result;
+    int last_ptr;
+    int callback_id;
+    /*tex Todo: variable can be removed: */
+    (void) bypass_eoln;
+    if (n == 0)
+        callback_id = input_file_callback_id[iindex];
+    else
+        callback_id = read_file_callback_id[n];
+    if (callback_id > 0) {
+        last = first;
+        last_ptr = first;
+        lua_result =
+            run_saved_callback(callback_id, "reader", "->l", &last_ptr);
+        if ((lua_result == true) && (last_ptr != 0)) {
+            last = last_ptr;
+            if (last > max_buf_stack)
+                max_buf_stack = last;
+        } else {
+            lua_result = false;
+        }
+    } else {
+        lua_result = input_ln(f, bypass_eoln);
+    }
+    if (lua_result == true) {
+        /*tex Fix up the input buffer using callbacks */
+        if (last >= first) {
+            callback_id = callback_defined(process_input_buffer_callback);
+            if (callback_id > 0) {
+                last_ptr = first;
+                lua_result =
+                    run_callback(callback_id, "l->l", (last - first),
+                                 &last_ptr);
+                if ((lua_result == true) && (last_ptr != 0)) {
+                    last = last_ptr;
+                    if (last > max_buf_stack)
+                        max_buf_stack = last;
+                }
+            }
+        }
+        return true;
+    }
+    return false;
+}
+
+/*tex
+
+    We need a special routine to read the first line of \TeX\ input from the
+    user's terminal. This line is different because it is read before we have
+    opened the transcript file; there is sort of a ``chicken and egg'' problem
+    here. If the user types `\.{\\input paper}' on the first line, or if some
+    macro invoked by that line does such an \.{\\input}, the transcript file will
+    be named `\.{paper.log}'; but if no \.{\\input} commands are performed during
+    the first line of terminal input, the transcript file will acquire its
+    default name `\.{texput.log}'. (The transcript file will not contain error
+    messages generated by the first line before the first \.{\\input} command.)
+
+    The first line is special also because it may be read before \TeX\ has input
+    a format file. In such cases, normal error messages cannot yet be given. The
+    following code uses concepts that will be explained later.
+
+    Different systems have different ways to get started. But regardless of what
+    conventions are adopted, the routine that initializes the terminal should
+    satisfy the following specifications:
+
+    \startitemize[n]
+
+        \startitem
+            It should open file |term_in| for input from the terminal. (The file
+            |term_out| will already be open for output to the terminal.)
+        \stopitem
+
+        \startitem
+            If the user has given a command line, this line should be considered
+            the first line of terminal input. Otherwise the user should be
+            prompted with `\.{**}', and the first line of input should be
+            whatever is typed in response.
+        \stopitem
+
+        \startitem
+            The first line of input, which might or might not be a command line,
+            should appear in locations |first| to |last-1| of the |buffer| array.
+        \stopitem
+
+        \startitem
+            The global variable |loc| should be set so that the character to be
+            read next by \TeX\ is in |buffer[loc]|. This character should not be
+            blank, and we should have |loc<last|.
+        \stopitem
+
+    \stopitemize
+
+    It may be necessary to prompt the user several times before a non-blank line
+    comes in. The prompt is `\.{**}' instead of the later `\.*' because the
+    meaning is slightly different: `\.{\\input}' need not be typed immediately
+    after~`\.{**}'.)
+
+    The following program does the required initialization. Iff anything has been
+    specified on the command line, then |t_open_in| will return with |last >
+    first|.
+
+*/
+
+boolean init_terminal(void)
+{
+    /*tex This gets the terminal input started. */
+    t_open_in();
+    if (last > first) {
+        iloc = first;
+        while ((iloc < last) && (buffer[iloc] == ' '))
+            incr(iloc);
+        if (iloc < last) {
+            return true;
+        }
+    }
+    while (1) {
+        wake_up_terminal();
+        fputs("**", term_out);
+        update_terminal();
+        if (!input_ln(term_in, true)) {
+            /*tex This shouldn't happen. */
+            fputs("\n! End of file on the terminal... why?\n", term_out);
+            return false;
+        }
+        iloc = first;
+        while ((iloc < last) && (buffer[iloc] == ' ')) {
+            incr(iloc);
+        }
+        /*tex Return unless the line was all blank. */
+        if (iloc < last) {
+            return true;
+        }
+        fputs("Please type the name of your input file.\n", term_out);
+    }
+}
+
+
+/*tex
+
+    Here is a procedure that asks the user to type a line of input, assuming that
+    the |selector| setting is either |term_only| or |term_and_log|. The input is
+    placed into locations |first| through |last-1| of the |buffer| array, and
+    echoed on the transcript file if appropriate.
+
+*/
+
+void term_input(void)
+{
+    /*tex Index into |buffer|: */
+    int k;
+    /*tex Now the user sees the prompt for sure: */
+    update_terminal();
+    if (!input_ln(term_in, true))
+        fatal_error("End of file on the terminal!");
+    /*tex The user's line ended with \.{<return>}: */
+    term_offset = 0;
+    /*tex Prepare to echo the input. */
+    decr(selector);
+    if (last != first) {
+        for (k = first; k <= last - 1; k++)
+            print_char(buffer[k]);
+    }
+    print_ln();
+    /*tex Restore previous status. */
+    incr(selector);
+}
+
+/*tex
+
+    It's time now to fret about file names. Besides the fact that different
+    operating systems treat files in different ways, we must cope with the fact
+    that completely different naming conventions are used by different groups of
+    people. The following programs show what is required for one particular
+    operating system; similar routines for other systems are not difficult to
+    devise.
+
+    \TeX\ assumes that a file name has three parts: the name proper; its
+    ``extension''; and a ``file area'' where it is found in an external file
+    system. The extension of an input file or a write file is assumed to be
+    `\.{.tex}' unless otherwise specified; it is `\.{.log}' on the transcript
+    file that records each run of \TeX; it is `\.{.tfm}' on the font metric files
+    that describe characters in the fonts \TeX\ uses; it is `\.{.dvi}' on the
+    output files that specify typesetting information; and it is `\.{.fmt}' on
+    the format files written by \.{INITEX} to initialize \TeX. The file area can
+    be arbitrary on input files, but files are usually output to the user's
+    current area. If an input file cannot be found on the specified area, \TeX\
+    will look for it on a special system area; this special area is intended for
+    commonly used input files like \.{webmac.tex}.
+
+    Simple uses of \TeX\ refer only to file names that have no explicit extension
+    or area. For example, a person usually says `\.{\\input} \.{paper}' or
+    `\.{\\font\\tenrm} \.= \.{helvetica}' instead of `\.{\\input} \.{paper.new}'
+    or `\.{\\font\\tenrm} \.= \.{<csd.knuth>test}'. Simple file names are best,
+    because they make the \TeX\ source files portable; whenever a file name
+    consists entirely of letters and digits, it should be treated in the same way
+    by all implementations of \TeX. However, users need the ability to refer to
+    other files in their environment, especially when responding to error
+    messages concerning unopenable files; therefore we want to let them use the
+    syntax that appears in their favorite operating system.
+
+    The following procedures don't allow spaces to be part of file names; but
+    some users seem to like names that are spaced-out. System-dependent changes
+    to allow such things should probably be made with reluctance, and only when
+    an entire file name that includes spaces is ``quoted'' somehow.
+
+    Here are the global values that file names will be scanned into.
+
+*/
+
+/*tex name of file just scanned */
+
+str_number cur_name;
+
+/*tex file area just scanned, or \.{""} */
+
+str_number cur_area;
+
+/*tex file extension just scanned, or \.{""} */
+
+str_number cur_ext;
+
+/*tex
+
+    The file names we shall deal with have the following structure: If the name
+    contains `\./' or `\.:' (for Amiga only), the file area consists of all
+    characters up to and including the final such character; otherwise the file
+    area is null. If the remaining file name contains `\..', the file extension
+    consists of all such characters from the last `\..' to the end, otherwise the
+    file extension is null.
+
+    We can scan such file names easily by using two global variables that keep
+    track of the occurrences of area and extension delimiters:
+
+*/
+
+/*tex the most recent `\./', if any */
+
+pool_pointer area_delimiter;
+
+/*tex the relevant `\..', if any */
+
+pool_pointer ext_delimiter;
+
+/*tex
+
+    Input files that can't be found in the user's area may appear in a standard
+    system area called |TEX_area|. Font metric files whose areas are not given
+    explicitly are assumed to appear in a standard system area called
+    |TEX_font_area|. $\Omega$'s compiled translation process files whose areas
+    are not given explicitly are assumed to appear in a standard system area.
+    These system area names will, of course, vary from place to place.
+
+*/
+
+#define append_to_fn(A) do {                                    \
+        c=(A);                                                  \
+        if (c!='"') {                                           \
+            if (k<file_name_size) fn[k++]=(unsigned char)(c);   \
+        }                                                       \
+    } while (0)
+
+
+char *pack_file_name(str_number n, str_number a, str_number e)
+{
+    /*tex character being packed */
+    ASCII_code c;
+    /*tex index into |str_pool| */
+    unsigned char *j;
+    /*tex number of positions filled in |fn| */
+    int k = 0;
+    unsigned char *fn = xmallocarray(packed_ASCII_code, str_length(a) + str_length(n) + str_length(e) + 1);
+    for (j = str_string(a); j < str_string(a) + str_length(a); j++)
+        append_to_fn(*j);
+    for (j = str_string(n); j < str_string(n) + str_length(n); j++)
+        append_to_fn(*j);
+    for (j = str_string(e); j < str_string(e) + str_length(e); j++)
+        append_to_fn(*j);
+    fn[k] = 0;
+    return (char *) fn;
+}
+
+/*tex
+
+    A messier routine is also needed, since format file names must be scanned
+    before \TeX's string mechanism has been initialized. We shall use the global
+    variable |TEX_format_default| to supply the text for default system areas and
+    extensions related to format files.
+
+    Under \UNIX\ we don't give the area part, instead depending on the path
+    searching that will happen during file opening. Also, the length will be set
+    in the main program.
+
+*/
+
+char *TEX_format_default;
+
+
+/*tex
+
+    This part of the program becomes active when a ``virgin'' \TeX\ is trying to
+    get going, just after the preliminary initialization, or when the user is
+    substituting another format file by typing `\.\&' after the initial `\.{**}'
+    prompt. The buffer contains the first line of input in
+    |buffer[loc..(last-1)]|, where |loc<last| and |buffer[loc]<>" "|.
+
+*/
+
+char *open_fmt_file(void)
+{
+    /*tex The first space after the format file name: */
+    int j;
+    char *fmt = NULL;
+    int dist;
+    j = iloc;
+    if (buffer[iloc] == '&') {
+        incr(iloc);
+        j = iloc;
+        buffer[last] = ' ';
+        while (buffer[j] != ' ')
+            incr(j);
+        fmt = xmalloc((unsigned) (j - iloc + 1));
+        strncpy(fmt, (char *) (buffer + iloc), (size_t) (j - iloc));
+        fmt[j - iloc] = 0;
+        dist = (int) (strlen(fmt) - strlen(DUMP_EXT));
+        if (!(strstr(fmt, DUMP_EXT) == fmt + dist))
+            fmt = concat(fmt, DUMP_EXT);
+        if (zopen_w_input(&fmt_file, fmt, DUMP_FORMAT, FOPEN_RBIN_MODE))
+            goto FOUND;
+        wake_up_terminal();
+        fprintf(stdout, "Sorry, I can't find the format `%s'; will try `%s'.\n",
+                fmt, TEX_format_default);
+        update_terminal();
+    }
+    /*tex Now pull out all the stops: try for the system \.{plain} file. */
+    fmt = TEX_format_default;
+    if (!zopen_w_input(&fmt_file, fmt, DUMP_FORMAT, FOPEN_RBIN_MODE)) {
+        wake_up_terminal();
+        fprintf(stdout, "I can't find the format file `%s'!\n",
+                TEX_format_default);
+        return NULL;
+    }
+  FOUND:
+    iloc = j;
+    return fmt;
+}
+
+/*tex
+
+    The global variable |name_in_progress| is used to prevent recursive use of
+    |scan_file_name|, since the |begin_name| and other procedures communicate via
+    global variables. Recursion would arise only by devious tricks like
+    `\.{\\input\\input f}'; such attempts at sabotage must be thwarted.
+    Furthermore, |name_in_progress| prevents \.{\\input} from being initiated
+    when a font size specification is being scanned.
+
+    Another global variable, |job_name|, contains the file name that was first
+    \.{\\input} by the user. This name is extended by `\.{.log}' and `\.{.dvi}'
+    and `\.{.fmt}' in the names of \TeX's output files.
+
+*/
+
+/*tex is a file name being scanned? */
+
+boolean name_in_progress;
+
+/*tex principal file name */
+
+str_number job_name;
+
+/*tex has the transcript file been opened? */
+
+boolean log_opened_global;
+
+/*tex
+
+    Initially |job_name=0|; it becomes nonzero as soon as the true name is known.
+    We have |job_name=0| if and only if the `\.{log}' file has not been opened,
+    except of course for a short time just after |job_name| has become nonzero.
+
+*/
+
+/*tex full name of the log file */
+
+unsigned char *texmf_log_name;
+
+/*tex
+
+    The |open_log_file| routine is used to open the transcript file and to help
+    it catch up to what has previously been printed on the terminal.
+
+*/
+
+void open_log_file(void)
+{
+    /*tex previous |selector| setting */
+    int old_setting;
+    /*tex index into |buffer| */
+    int k;
+    /*tex end of first input line */
+    int l;
+    char *fn;
+    old_setting = selector;
+    if (job_name == 0)
+        job_name = getjobname(maketexstring("texput"));
+    fn = pack_job_name(".fls");
+    recorder_change_filename(fn);
+    fn = pack_job_name(".log");
+    while (!lua_a_open_out(&log_file, fn, 0)) {
+        /*tex
+
+            Try to get a different log file name. Sometimes |open_log_file| is
+            called at awkward moments when \TeX\ is unable to print error
+            messages or even to |show_context|. The |prompt_file_name| routine
+            can result in a |fatal_error|, but the |error| routine will not be
+            invoked because |log_opened| will be false.
+
+            The normal idea of |batch_mode| is that nothing at all should be
+            written on the terminal. However, in the unusual case that no log
+            file could be opened, we make an exception and allow an explanatory
+            message to be seen.
+
+            Incidentally, the program always refers to the log file as a
+            `\.{transcript file}', because some systems cannot use the extension
+            `\.{.log}' for this file.
+        */
+        selector = term_only;
+        fn = prompt_file_name("transcript file name", ".log");
+    }
+    texmf_log_name = (unsigned char *) xstrdup(fn);
+    selector = log_only;
+    log_opened_global = true;
+    if (callback_defined(start_run_callback) == 0) {
+        /*tex Print the banner line, including current date and time. */
+        log_banner(luatex_version_string);
+        /*tex Make sure bottom level is in memory. */
+        input_stack[input_ptr] = cur_input;
+        tprint_nl("**");
+        /*tex The last position of first line. */
+        l = input_stack[0].limit_field;
+        if (buffer[l] == end_line_char_par) {
+            /*tex maybe also handle multichar endlinechar */
+            decr(l);
+        }
+        for (k = 1; k <= l; k++) {
+            print_char(buffer[k]);
+        }
+        /*tex now the transcript file contains the first line of input */
+        print_ln();
+    }
+    /*tex should be done always */
+    flush_loggable_info();
+    /*tex should be done always */
+    selector = old_setting + 2; 
+}
+
+/*tex
+
+    This function is needed by synctex to make its log appear in the right spot
+    when |output_directory| is set.
+
+*/
+
+char *get_full_log_name (void)
+{
+   if (output_directory) {
+       char *ret  = xmalloc(strlen((char *)texmf_log_name)+2+strlen(output_directory));
+       ret = strcpy(ret, output_directory);
+       strcat(ret, "/");
+       strcat(ret, (char *)texmf_log_name);
+       return ret;
+   } else {
+       return xstrdup((const char*)texmf_log_name);
+   }
+}
+
+/*tex Synctex uses this to get the anchored path of an input file. */
+
+char *luatex_synctex_get_current_name (void)
+{
+  char *pwdbuf = NULL, *ret;
+  if (kpse_absolute_p(fullnameoffile, false)) {
+     return xstrdup(fullnameoffile);
+  }
+  pwdbuf = xgetcwd();
+  ret = concat3(pwdbuf, DIR_SEP_STRING, fullnameoffile);
+  free(pwdbuf) ;
+  return ret;
+}
+
+/*tex
+
+    Let's turn now to the procedure that is used to initiate file reading when an
+    `\.{\\input}' command is being processed.
+
+*/
+
+void start_input(void)
+{
+    str_number temp_str;
+    char *fn;
+    do {
+        get_x_token();
+    } while ((cur_cmd == spacer_cmd) || (cur_cmd == relax_cmd));
+
+    back_input();
+    if (cur_cmd != left_brace_cmd) {
+        /*tex Set |cur_name| to desired file name. */
+        scan_file_name();
+    } else {
+        scan_file_name_toks();
+    }
+    fn = pack_file_name(cur_name, cur_area, cur_ext);
+    while (1) {
+        /*tex Set up |cur_file| and new level of input. */
+        begin_file_reading();
+        if (lua_a_open_in(&cur_file, fn, 0)) {
+            break;
+        }
+        /*tex Remove the level that didn't work. */
+        end_file_reading();
+        fn = prompt_file_name("input file name", "");
+    }
+    iname = maketexstring(fullnameoffile);
+    /*tex
+
+        Now that we have |fullnameoffile|, it is time to post-adjust |cur_name|
+        and |cur_ext| for trailing |.tex|.
+
+    */
+    {
+        char *n, *p;
+        n = p = fullnameoffile + strlen(fullnameoffile);
+        while (p>fullnameoffile) {
+            p--;
+            if (IS_DIR_SEP(*p)) {
+                break;
+            }
+        }
+        if (IS_DIR_SEP(*p)) {
+            p++;
+        }
+        while (n>fullnameoffile) {
+            n--;
+            if (*n == '.') {
+                break;
+            }
+        }
+        if (n>p) {
+            int q = *n;
+            cur_ext = maketexstring(n);
+            *n = 0;
+            cur_name = maketexstring(p);
+            *n = q;
+        }
+    }
+    source_filename_stack[in_open] = iname;
+    full_source_filename_stack[in_open] = xstrdup(fullnameoffile);
+    /*tex We can try to conserve string pool space now. */
+    temp_str = search_string(iname);
+    if (temp_str > 0) {
+        flush_str(iname);
+        iname = temp_str;
+    }
+    if (job_name == 0) {
+        job_name = getjobname(cur_name);
+        open_log_file();
+    }
+    /*tex
+
+        |open_log_file| doesn't |show_context|, so |limit| and |loc| needn't be
+        set to meaningful values yet.
+
+    */
+    report_start_file(filetype_tex,fullnameoffile);
+    incr(open_parens);
+    update_terminal();
+    istate = new_line;
+    /*tex Prepare new file {\sl Sync\TeX} information. */
+    if (! synctex_get_no_files()) {
+        /*tex Give control to the {\sl Sync\TeX} controller. */
+        synctexstartinput();
+    }
+    /*tex
+
+        Read the first line of the new file. Here we have to remember to tell the
+        |lua_input_ln| routine not to start with a |get|. If the file is empty,
+        it is considered to contain a single blank line.
+
+    */
+    line = 1;
+    if (lua_input_ln(cur_file, 0, false)) {
+        ;
+    }
+    firm_up_the_line();
+    if (end_line_char_inactive)
+        decr(ilimit);
+    else
+        buffer[ilimit] = (packed_ASCII_code) end_line_char_par;
+    first = ilimit + 1;
+    iloc = istart;
+}
+
+/*tex
+
+    Because the format is zipped we read and write dump files through zlib.
+    Earlier versions recast |*f| from |FILE *| to |gzFile|, but there is no
+    guarantee that these have the same size, so a static variable is needed.
+
+*/
+
+static gzFile gz_fmtfile = NULL;
+
+/*tex
+
+    As distributed, the dump files are architecture dependent; specifically,
+    BigEndian and LittleEndian architectures produce different files. These
+    routines always output BigEndian files. This still does not guarantee them to
+    be architecture-independent, because it is possible to make a format that
+    dumps a glue ratio, i.e., a floating-point number. Fortunately, none of the
+    standard formats do that.
+
+*/
+
+#if !defined (WORDS_BIGENDIAN) && !defined (NO_DUMP_SHARE)
+
+/*tex
+
+    This macro is always invoked as a statement. It assumes a variable `temp'.
+
+*/
+
+#  define SWAP(x, y) do { temp = x; x = y; y = temp; } while (0)
+
+/*tex
+
+    Make the NITEMS items pointed at by P, each of size SIZE, be the
+    opposite-endianness of whatever they are now.
+
+*/
+
+static void swap_items(char *pp, int nitems, int size)
+{
+    char temp;
+    unsigned total = (unsigned) (nitems * size);
+    char *q = xmalloc(total);
+    char *p = q;
+    memcpy(p,pp,total);
+    /*tex
+
+        Since `size' does not change, we can write a while loop for each case,
+        and avoid testing `size' for each time.
+
+    */
+    switch (size) {
+        case 16:
+            /*tex
+
+                16-byte items happen on the DEC Alpha machine when we are not doing
+                sharable memory dumps.
+
+            */
+            while (nitems--) {
+                SWAP(p[0], p[15]);
+                SWAP(p[1], p[14]);
+                SWAP(p[2], p[13]);
+                SWAP(p[3], p[12]);
+                SWAP(p[4], p[11]);
+                SWAP(p[5], p[10]);
+                SWAP(p[6], p[9]);
+                SWAP(p[7], p[8]);
+                p += size;
+            }
+            break;
+
+        case 12:
+            while (nitems--) {
+                SWAP(p[0], p[11]);
+                SWAP(p[1], p[10]);
+                SWAP(p[2], p[9]);
+                SWAP(p[3], p[8]);
+                SWAP(p[4], p[7]);
+                SWAP(p[5], p[6]);
+                p += size;
+            }
+            break;
+
+        case 8:
+            while (nitems--) {
+                SWAP(p[0], p[7]);
+                SWAP(p[1], p[6]);
+                SWAP(p[2], p[5]);
+                SWAP(p[3], p[4]);
+                p += size;
+            }
+            break;
+
+        case 4:
+            while (nitems--) {
+                SWAP(p[0], p[3]);
+                SWAP(p[1], p[2]);
+                p += size;
+            }
+            break;
+
+        case 2:
+            while (nitems--) {
+                SWAP(p[0], p[1]);
+                p += size;
+            }
+            break;
+        case 1:
+            /*tex Nothing to do. */
+            break;
+        default:
+            FATAL1("Can't swap a %d-byte item for (un)dumping", size);
+    }
+    memcpy(pp,q,total);
+    xfree(q);
+}
+#endif
+
+/*tex
+
+    That second swap is to make sure following calls don't get confused in the
+    case of |dump_things|.
+
+*/
+
+void do_zdump(char *p, int item_size, int nitems, FILE * out_file)
+{
+    int err;
+    (void) out_file;
+    if (nitems == 0)
+        return;
+#if !defined (WORDS_BIGENDIAN) && !defined (NO_DUMP_SHARE)
+    swap_items(p, nitems, item_size);
+#endif
+    if (gzwrite(gz_fmtfile, (void *) p, (unsigned) (item_size * nitems)) !=
+        item_size * nitems) {
+        fprintf(stderr, "! Could not write %d %d-byte item(s): %s.\n", nitems, item_size, gzerror(gz_fmtfile, &err));
+        uexit(1);
+    }
+#if !defined (WORDS_BIGENDIAN) && !defined (NO_DUMP_SHARE)
+    swap_items(p, nitems, item_size);
+#endif
+}
+
+void do_zundump(char *p, int item_size, int nitems, FILE * in_file)
+{
+    int err;
+    (void) in_file;
+    if (nitems == 0)
+        return;
+    if (gzread(gz_fmtfile, (void *) p, (unsigned) (item_size * nitems)) <= 0) {
+        fprintf(stderr, "Could not undump %d %d-byte item(s): %s.\n", nitems, item_size, gzerror(gz_fmtfile, &err));
+        uexit(1);
+    }
+#if !defined (WORDS_BIGENDIAN) && !defined (NO_DUMP_SHARE)
+    swap_items(p, nitems, item_size);
+#endif
+}
+
+/*tex
+
+    Tests has shown that a level 3 compression is the most optimal tradeoff
+    between file size and load time.
+
+*/
+
+#define COMPRESSION "R3"
+
+boolean zopen_w_input(FILE ** f, const char *fname, int format, const_string fopen_mode)
+{
+    int callbackid;
+    int res;
+    char *fnam;
+    callbackid = callback_defined(find_format_file_callback);
+    if (callbackid > 0) {
+        res = run_callback(callbackid, "S->R", fname, &fnam);
+        if (res && fnam && strlen(fnam) > 0) {
+            *f = fopen(fnam, fopen_mode);
+            if (*f == NULL) {
+                return 0;
+            }
+        } else {
+            return 0;
+        }
+    } else {
+        res = luatex_open_input(f, fname, format, fopen_mode, true);
+    }
+    if (res) {
+        gz_fmtfile = gzdopen(fileno(*f), "rb" COMPRESSION);
+    }
+    return res;
+}
+
+boolean zopen_w_output(FILE ** f, const char *s, const_string fopen_mode)
+{
+    int res = 1;
+    if (luainit) {
+        *f = fopen(s, fopen_mode);
+        if (*f == NULL) {
+            return 0;
+        }
+    } else {
+        res = luatex_open_output(f, s, fopen_mode);
+    }
+    if (res) {
+        gz_fmtfile = gzdopen(fileno(*f), "wb" COMPRESSION);
+    }
+    return res;
+}
+
+void zwclose(FILE * f)
+{
+    (void) f;
+    gzclose(gz_fmtfile);
+}
+
+/*tex Create the \DVI\ or \PDF\ file. */
+
+int open_outfile(FILE ** f, const char *name, const char *mode)
+{
+    FILE *res;
+    res = fopen(name, mode);
+    if (res != NULL) {
+        *f = res;
+        return 1;
+    }
+    return 0;
+}
+
+/*tex The caller should set |tfm_buffer=NULL| and |tfm_size=0|. */
+
+int readbinfile(FILE * f, unsigned char **tfm_buffer, int *tfm_size)
+{
+    void *buf;
+    int size;
+    if (fseek(f, 0, SEEK_END) == 0) {
+        size = (int) ftell(f);
+        if (size > 0) {
+            buf = xmalloc((unsigned) size);
+            if (fseek(f, 0, SEEK_SET) == 0) {
+                if (fread((void *) buf, (size_t) size, 1, f) == 1) {
+                    *tfm_buffer = (unsigned char *) buf;
+                    *tfm_size = size;
+                    return 1;
+                }
+            }
+        } else {
+            *tfm_buffer = NULL;
+            *tfm_size = 0;
+            return 1;
+        }
+    }
+    /*tex Either seek failed or we have a zero-sized file. */
+    return 0;
+}
+
+/*tex
+
+    Like |os.execute()|, the |runpopen()| function is called only when
+    |shellenabledp == 1|. Unlike |os.execute()| we write errors to stderr, since
+    we have nowhere better to use; and of course we return a file handle (or
+    NULL) instead of a status indicator.
+
+*/
+
+static FILE *runpopen(char *cmd, const char *mode)
+{
+    FILE *f = NULL;
+    char *safecmd = NULL;
+    char *cmdname = NULL;
+    int allow;
+#ifdef WIN32
+    char *pp;
+
+    for (pp = cmd; *pp; pp++) {
+      if (*pp == '\'') *pp = '"';
+    }
+#endif
+    /*tex If |restrictedshell| is zero, any command is allowed. */
+    if (restrictedshell == 0) {
+        allow = 1;
+    } else {
+        const char *thecmd = cmd;
+        allow = shell_cmd_is_allowed(thecmd, &safecmd, &cmdname);
+    }
+    if (allow == 1)
+        f = popen(cmd, mode);
+    else if (allow == 2)
+        f = popen(safecmd, mode);
+    else if (allow == -1)
+        fprintf(stderr, "\nrunpopen quotation error in command line: %s\n", cmd);
+    else
+        fprintf(stderr, "\nrunpopen command not allowed: %s\n", cmdname);
+    if (safecmd)
+        free(safecmd);
+    if (cmdname)
+        free(cmdname);
+    return f;
+}
+
+/*tex
+
+    The code that implements |popen()| needs an array for tracking possible pipe
+    file pointers, because these need to be closed using |pclose()|.
+
+*/
+
+#define NUM_PIPES 16
+static FILE *pipes[NUM_PIPES];
+
+#ifdef WIN32
+FILE *Poptr;
+#endif
+
+boolean open_in_or_pipe(FILE ** f_ptr, char *fn, int filefmt, const_string fopen_mode, boolean must_exist)
+{
+    string fname = NULL;
+    int i;
+    /*tex
+
+        Opening a read pipe is straightforward, only have to skip past the pipe
+        symbol in the file name. filename quoting is assumed to happen elsewhere
+        (it does :-))
+
+    */
+    if (shellenabledp && *fn == '|') {
+        /*tex The user requested a pipe. */
+        *f_ptr = NULL;
+        fname = (string) xmalloc((unsigned) (strlen(fn) + 1));
+        strcpy(fname, fn);
+        if (fullnameoffile)
+            free(fullnameoffile);
+        fullnameoffile = xstrdup(fname);
+        recorder_record_input(fname + 1);
+        *f_ptr = runpopen(fname + 1, "r");
+        free(fname);
+        for (i = 0; i < NUM_PIPES; i++) {
+            if (pipes[i] == NULL) {
+                pipes[i] = *f_ptr;
+                break;
+            }
+        }
+        if (*f_ptr)
+            setvbuf(*f_ptr, (char *) NULL, _IONBF, 0);
+#ifdef WIN32
+        Poptr = *f_ptr;
+#endif
+        return *f_ptr != NULL;
+    }
+    return luatex_open_input(f_ptr, fn, filefmt, fopen_mode, must_exist);
+}
+
+
+boolean open_out_or_pipe(FILE ** f_ptr, char *fn, const_string fopen_mode)
+{
+    string fname;
+    int i;
+    /*tex
+
+        Opening a write pipe takes a little bit more work, because TeX will
+        perhaps have appended ".tex". To avoid user confusion as much as
+        possible, this extension is stripped only when the command is a bare
+        word. Some small string trickery is needed to make sure the correct
+        number of bytes is free()-d afterwards.
+    */
+    if (shellenabledp && *fn == '|') {
+        /*tex The user requested a pipe. */
+        fname = (string) xmalloc((unsigned) (strlen(fn) + 1));
+        strcpy(fname, fn);
+        if (strchr(fname, ' ') == NULL && strchr(fname, '>') == NULL) {
+            /*tex
+
+                \METAPOST\ and \METAFIONT\ currently do not use this code, but it
+                is better to be prepared. Hm, what has this todo with \LUATEX ?
+
+            */
+            if (STREQ((fname + strlen(fname) - 3), "tex"))
+                *(fname + strlen(fname) - 4) = 0;
+            *f_ptr = runpopen(fname + 1, "w");
+            *(fname + strlen(fname)) = '.';
+        } else {
+            *f_ptr = runpopen(fname + 1, "w");
+        }
+        recorder_record_output(fname + 1);
+        free(fname);
+        for (i = 0; i < NUM_PIPES; i++) {
+            if (pipes[i] == NULL) {
+                pipes[i] = *f_ptr;
+                break;
+            }
+        }
+        if (*f_ptr)
+            setvbuf(*f_ptr, (char *) NULL, _IONBF, 0);
+        return *f_ptr != NULL;
+    }
+    return luatex_open_output(f_ptr, fn, fopen_mode);
+}
+
+
+void close_file_or_pipe(FILE * f)
+{
+    int i;
+    if (shellenabledp) {
+        for (i = 0; i <= 15; i++) {
+            /*tex If this file was a pipe, |pclose()| it and return. */
+            if (pipes[i] == f) {
+                if (f) {
+                    pclose(f);
+#ifdef WIN32
+                    Poptr = NULL;
+#endif
+                }
+                pipes[i] = NULL;
+                return;
+            }
+        }
+    }
+    close_file(f);
+}
diff --git a/texk/web2c/luatexdir/tex/texfileio.w b/texk/web2c/luatexdir/tex/texfileio.w
deleted file mode 100644
index a10e9ba63..000000000
--- a/texk/web2c/luatexdir/tex/texfileio.w
+++ /dev/null
@@ -1,1389 +0,0 @@
-% texfileio.w
-%
-% Copyright 2009-2010 Taco Hoekwater <taco@@luatex.org>
-%
-% This file is part of LuaTeX.
-%
-% LuaTeX is free software; you can redistribute it and/or modify it under
-% the terms of the GNU General Public License as published by the Free
-% Software Foundation; either version 2 of the License, or (at your
-% option) any later version.
-%
-% LuaTeX is distributed in the hope that it will be useful, but WITHOUT
-% ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-% FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
-% License for more details.
-%
-% You should have received a copy of the GNU General Public License along
-% with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
-
-@ @c
-
-
-#include "ptexlib.h"
-
-#include <string.h>
-#include <kpathsea/absolute.h>
-
-@ The bane of portability is the fact that different operating systems treat
-input and output quite differently, perhaps because computer scientists
-have not given sufficient attention to this problem. People have felt somehow
-that input and output are not part of ``real'' programming. Well, it is true
-that some kinds of programming are more fun than others. With existing
-input/output conventions being so diverse and so messy, the only sources of
-joy in such parts of the code are the rare occasions when one can find a
-way to make the program a little less bad than it might have been. We have
-two choices, either to attack I/O now and get it over with, or to postpone
-I/O until near the end. Neither prospect is very attractive, so let's
-get it over with.
-
-The basic operations we need to do are (1)~inputting and outputting of
-text, to or from a file or the user's terminal; (2)~inputting and
-outputting of eight-bit bytes, to or from a file; (3)~instructing the
-operating system to initiate (``open'') or to terminate (``close'') input or
-output from a specified file; (4)~testing whether the end of an input
-file has been reached.
-
-\TeX\ needs to deal with two kinds of files.
-We shall use the term |alpha_file| for a file that contains textual data,
-and the term |byte_file| for a file that contains eight-bit binary information.
-These two types turn out to be the same on many computers, but
-sometimes there is a significant distinction, so we shall be careful to
-distinguish between them. Standard protocols for transferring
-such files from computer to computer, via high-speed networks, are
-now becoming available to more and more communities of users.
-
-The program actually makes use also of a third kind of file, called a
-|word_file|, when dumping and reloading base information for its own
-initialization.  We shall define a word file later; but it will be possible
-for us to specify simple operations on word files before they are defined.
-
-@ We finally did away with |nameoffile| and |namelength|, but the variables
-have to be kept otherwise there will be link errors from |openclose.c| in
-the web2c library
-
-@c
-char *nameoffile;
-int namelength;
-
-
-@ When input files are opened via a callback, they will also be read using
-callbacks. for that purpose, the |open_read_file_callback| returns an
-integer to uniquely identify a callback table. This id replaces the file
-point |f| in this case, because the input does not have to be a file
-in the traditional sense.
-
-Signalling this fact is achieved by having two arrays of integers.
-
-@c
-int *input_file_callback_id;
-int read_file_callback_id[17];
-
-@ Handle -output-directory.
-
-We assume that it is OK to look here first.  Possibly it
-would be better to replace lookups in "." with lookups in the
-|output_directory| followed by "." but to do this requires much more
-invasive surgery in libkpathsea.
-
-@c
-static char *find_in_output_directory(const char *s)
-{
-    if (output_directory && !kpse_absolute_p(s, false)) {
-        FILE *f_ptr;
-        char *ftemp = concat3(output_directory, DIR_SEP_STRING, s);
-        f_ptr = fopen(ftemp, "rb");     /* this code is used for input files only */
-        if (f_ptr) {
-            fclose(f_ptr);
-            return ftemp;
-        } else {
-            free(ftemp);
-
-        }
-    }
-    return NULL;
-}
-
-@ find an \.{\\input} or \.{\\read} file. |n| differentiates between those case.
-
-@c
-int kpse_available(const char *m) {
-    if (!kpse_init) {
-          fprintf(stdout,"missing kpse replacement callback '%s', quitting\n",m);
-          exit(1);
-    }
-    return 1 ;
-}
-
-char *luatex_find_read_file(const char *s, int n, int callback_index)
-{
-    char *ftemp = NULL;
-    int callback_id = callback_defined(callback_index);
-    if (callback_id > 0) {
-        (void) run_callback(callback_id, "dS->R", n, s, &ftemp);
-    } else if (kpse_available("find_read_file")) {
-        /* use kpathsea here */
-        ftemp = find_in_output_directory(s);
-        if (!ftemp)
-            ftemp = kpse_find_file(s, kpse_tex_format, 1);
-    }
-    if (ftemp) {
-        if (fullnameoffile)
-            free(fullnameoffile);
-        fullnameoffile = xstrdup(ftemp);
-    }
-    return ftemp;
-}
-
-@ find other files types
-@c
-char *luatex_find_file(const char *s, int callback_index)
-{
-    char *ftemp = NULL;
-    int callback_id = callback_defined(callback_index);
-    if (callback_id > 0) {
-        (void) run_callback(callback_id, "S->R", s, &ftemp);
-
-    } else if (kpse_available("find_read_file")) {
-        /* use kpathsea here */
-        switch (callback_index) {
-        case find_enc_file_callback:
-            ftemp = kpse_find_file(s, kpse_enc_format, 0);
-            break;
-        case find_map_file_callback:
-            ftemp = kpse_find_file(s, kpse_fontmap_format, 0);
-            break;
-        case find_type1_file_callback:
-            ftemp = kpse_find_file(s, kpse_type1_format, 0);
-            break;
-        case find_truetype_file_callback:
-            ftemp = kpse_find_file(s, kpse_truetype_format, 0);
-            break;
-        case find_opentype_file_callback:
-            ftemp = kpse_find_file(s, kpse_opentype_format, 0);
-            if (ftemp == NULL)
-                ftemp = kpse_find_file(s, kpse_truetype_format, 0);
-            break;
-        case find_data_file_callback:
-            ftemp = find_in_output_directory(s);
-            if (!ftemp)
-                ftemp = kpse_find_file(s, kpse_tex_format, 1);
-            break;
-        case find_font_file_callback:
-            ftemp = kpse_find_file(s, kpse_ofm_format, 1);
-            if (ftemp == NULL)
-                ftemp = kpse_find_file(s, kpse_tfm_format, 1);
-            break;
-        case find_vf_file_callback:
-            ftemp = kpse_find_file(s, kpse_ovf_format, 0);
-            if (ftemp == NULL)
-                ftemp = kpse_find_file(s, kpse_vf_format, 0);
-            break;
-        case find_cidmap_file_callback:
-            ftemp = kpse_find_file(s, kpse_cid_format, 0);
-            break;
-        default:
-            printf
-                ("luatex_find_file(): do not know how to handle file %s of type %d\n",
-                 s, callback_index);
-            break;
-        }
-    }
-    return ftemp;
-}
-
-
-@  LuaTeX used to have private functions for these that did not use kpathsea,
-but since the file paranoia tests have to come from kpathsea anyway, that is no
-longer useful. The only downside to using luatex is that if one wants to disable
-kpathsea via the Lua startup script, it is now an absolute requirement that all
-file discovery callbacks are specified. Just using the find_read_file, but not
-setting open_read_file, for example, does not work any more if kpathsea is not
-to be used at all.
-
-@c
-#define openoutnameok(A)  kpse_out_name_ok (A)
-#define openinnameok(A)  kpse_in_name_ok (A)
-
-@  Open an input file F, using the kpathsea format FILEFMT and passing
-   |FOPEN_MODE| to fopen.  The filename is in `fn'.  We return whether or
-   not the open succeeded.
-
-@c
-boolean
-luatex_open_input(FILE ** f_ptr, const char *fn, int filefmt,
-                  const_string fopen_mode, boolean must_exist)
-{
-    string fname = NULL;
-    /* We havent found anything yet. */
-    *f_ptr = NULL;
-    if (fullnameoffile)
-        free(fullnameoffile);
-    fullnameoffile = NULL;
-    fname = kpse_find_file(fn, (kpse_file_format_type) filefmt, must_exist);
-    if (fname) {
-        fullnameoffile = xstrdup(fname);
-        /* If we found the file in the current directory, don't leave
-           the `./' at the beginning of `fn', since it looks
-           dumb when `tex foo' says `(./foo.tex ... )'.  On the other
-           hand, if the user said `tex ./foo', and that's what we
-           opened, then keep it -- the user specified it, so we
-           shouldn't remove it.  */
-        if (fname[0] == '.' && IS_DIR_SEP(fname[1])
-            && (fn[0] != '.' || !IS_DIR_SEP(fn[1]))) {
-            unsigned i = 0;
-            while (fname[i + 2] != 0) {
-                fname[i] = fname[i + 2];
-                i++;
-            }
-            fname[i] = 0;
-        }
-        /* This fopen is not allowed to fail. */
-        *f_ptr = xfopen(fname, fopen_mode);
-    }
-    if (*f_ptr) {
-        recorder_record_input(fname);
-    }
-    return *f_ptr != NULL;
-}
-
-@ @c
-boolean luatex_open_output(FILE ** f_ptr, const char *fn,
-                           const_string fopen_mode)
-{
-    char *fname;
-    boolean absolute = kpse_absolute_p(fn, false);
-
-    /* If we have an explicit output directory, use it. */
-    if (output_directory && !absolute) {
-        fname = concat3(output_directory, DIR_SEP_STRING, fn);
-    } else {
-        fname = xstrdup(fn);
-    }
-
-    /* Is the filename openable as given?  */
-    *f_ptr = fopen(fname, fopen_mode);
-
-    if (!*f_ptr) {
-        /* Can't open as given.  Try the envvar.  */
-        string texmfoutput = kpse_var_value("TEXMFOUTPUT");
-
-        if (texmfoutput && *texmfoutput && !absolute) {
-            fname = concat3(texmfoutput, DIR_SEP_STRING, fn);
-            *f_ptr = fopen(fname, fopen_mode);
-        }
-    }
-    if (*f_ptr) {
-        recorder_record_output(fname);
-    }
-    free(fname);
-    return *f_ptr != NULL;
-}
-
-
-@ @c
-boolean lua_a_open_in(alpha_file * f, char *fn, int n)
-{
-    int k;
-    char *fnam;                 /* string returned by find callback */
-    int callback_id;
-    boolean ret = true;         /* return value */
-    boolean file_ok = true;     /* the status so far  */
-    if (n == 0) {
-        input_file_callback_id[iindex] = 0;
-    } else {
-        read_file_callback_id[n] = 0;
-    }
-    if (*fn == '|')
-        fnam = fn;
-    else
-        fnam = luatex_find_read_file(fn, n, find_read_file_callback);
-    if (!fnam)
-        return false;
-    callback_id = callback_defined(open_read_file_callback);
-    if (callback_id > 0) {
-        k = run_and_save_callback(callback_id, "S->", fnam);
-        if (k > 0) {
-            ret = true;
-            if (n == 0)
-                input_file_callback_id[iindex] = k;
-            else
-                read_file_callback_id[n] = k;
-        } else {
-            file_ok = false;    /* read failed */
-        }
-    } else {                    /* no read callback */
-        if (openinnameok(fnam)) {
-            ret =
-                open_in_or_pipe(f, fnam, kpse_tex_format, FOPEN_RBIN_MODE,
-                                (n == 0 ? true : false));
-        } else {
-            file_ok = false;    /* open failed */
-        }
-    }
-    if (!file_ok) {
-        ret = false;
-    }
-    return ret;
-}
-
-
-@ @c
-boolean lua_a_open_out(alpha_file * f, char *fn, int n)
-{
-    boolean test;
-    str_number fnam;
-    int callback_id;
-    boolean ret = false;
-    callback_id = callback_defined(find_write_file_callback);
-    if (callback_id > 0) {
-        fnam = 0;
-        test = run_callback(callback_id, "dS->s", n, fn, &fnam);
-        if ((test) && (fnam != 0) && (str_length(fnam) > 0)) {
-            /* There is no message here because if that is needed the macro package */
-            /* should do that in the callback code. As elsewhere, messaging is left */
-            /* to lua then. */
-            ret = open_outfile(f, fn, FOPEN_W_MODE);
-        }
-    } else {
-        if (openoutnameok(fn)) {
-            if (n > 0 && selector != term_only) {
-                /* This message to the log is for downward compatibility with other tex's  */
-                /* as there are scripts out there that act on this message. An alternative */
-                /* is to let a macro package write an explicit message. */
-                fprintf(log_file,"\n\\openout%i = %s\n",n-1,fn);
-             }
-             ret = open_out_or_pipe(f, fn, FOPEN_W_MODE);
-        }
-    }
-    return ret;
-}
-
-
-@ @c
-boolean lua_b_open_out(alpha_file * f, char *fn)
-{
-    boolean test;
-    str_number fnam;
-    int callback_id;
-    boolean ret = false;
-    callback_id = callback_defined(find_output_file_callback);
-    if (callback_id > 0) {
-        fnam = 0;
-        test = run_callback(callback_id, "S->s", fn, &fnam);
-        if ((test) && (fnam != 0) && (str_length(fnam) > 0)) {
-            ret = open_outfile(f, fn, FOPEN_WBIN_MODE);
-        }
-    } else {
-        if (openoutnameok(fn)) {
-            ret = luatex_open_output(f, fn, FOPEN_WBIN_MODE);
-        }
-    }
-    return ret;
-}
-
-@ @c
-void lua_a_close_in(alpha_file f, int n)
-{                               /* close a text file */
-    int callback_id;
-    if (n == 0)
-        callback_id = input_file_callback_id[iindex];
-    else
-        callback_id = read_file_callback_id[n];
-    if (callback_id > 0) {
-        run_saved_callback(callback_id, "close", "->");
-        destroy_saved_callback(callback_id);
-        if (n == 0)
-            input_file_callback_id[iindex] = 0;
-        else
-            read_file_callback_id[n] = 0;
-    } else {
-        close_file_or_pipe(f);
-    }
-}
-
-@ @c
-void lua_a_close_out(alpha_file f)
-{                               /* close a text file */
-    close_file_or_pipe(f);
-}
-
-
-@ Binary input and output are done with C's ordinary
-procedures, so we don't have to make any other special arrangements for
-binary~I/O. Text output is also easy to do with standard routines.
-The treatment of text input is more difficult, however, because
-of the necessary translation to |ASCII_code| values.
-\TeX's conventions should be efficient, and they should
-blend nicely with the user's operating environment.
-
-Input from text files is read one line at a time, using a routine called
-|lua_input_ln|. This function is defined in terms of global variables called
-|buffer|, |first|, and |last| that will be described in detail later; for
-now, it suffices for us to know that |buffer| is an array of |ASCII_code|
-values, and that |first| and |last| are indices into this array
-representing the beginning and ending of a line of text.
-
-@c
-packed_ASCII_code *buffer;      /* lines of characters being read */
-int first;                      /* the first unused position in |buffer| */
-int last;                       /* end of the line just input to |buffer| */
-int max_buf_stack;              /* largest index used in |buffer| */
-
-
-@ The |lua_input_ln| function brings the next line of input from the specified
-file into available positions of the buffer array and returns the value
-|true|, unless the file has already been entirely read, in which case it
-returns |false| and sets |last:=first|.  In general, the |ASCII_code|
-numbers that represent the next line of the file are input into
-|buffer[first]|, |buffer[first+1]|, \dots, |buffer[last-1]|; and the
-global variable |last| is set equal to |first| plus the length of the
-line. Trailing blanks are removed from the line; thus, either |last=first|
-(in which case the line was entirely blank) or |buffer[last-1]<>" "|.
-
-An overflow error is given, however, if the normal actions of |lua_input_ln|
-would make |last>=buf_size|; this is done so that other parts of \TeX\
-can safely look at the contents of |buffer[last+1]| without overstepping
-the bounds of the |buffer| array. Upon entry to |lua_input_ln|, the condition
-|first<buf_size| will always hold, so that there is always room for an
-``empty'' line.
-
-The variable |max_buf_stack|, which is used to keep track of how large
-the |buf_size| parameter must be to accommodate the present job, is
-also kept up to date by |lua_input_ln|.
-
-If the |bypass_eoln| parameter is |true|, |lua_input_ln| will do a |get|
-before looking at the first character of the line; this skips over
-an |eoln| that was in |f^|. The procedure does not do a |get| when it
-reaches the end of the line; therefore it can be used to acquire input
-from the user's terminal as well as from ordinary text files.
-
-Since the inner loop of |lua_input_ln| is part of \TeX's ``inner loop''---each
-character of input comes in at this place---it is wise to reduce system
-overhead by making use of special routines that read in an entire array
-of characters at once, if such routines are available.
-@^inner loop@>
-
-@c
-boolean lua_input_ln(alpha_file f, int n, boolean bypass_eoln)
-{
-    boolean lua_result;
-    int last_ptr;
-    int callback_id;
-    (void) bypass_eoln;         /* todo: variable can be removed */
-    if (n == 0)
-        callback_id = input_file_callback_id[iindex];
-    else
-        callback_id = read_file_callback_id[n];
-    if (callback_id > 0) {
-        last = first;
-        last_ptr = first;
-        lua_result =
-            run_saved_callback(callback_id, "reader", "->l", &last_ptr);
-        if ((lua_result == true) && (last_ptr != 0)) {
-            last = last_ptr;
-            if (last > max_buf_stack)
-                max_buf_stack = last;
-        } else {
-            lua_result = false;
-        }
-    } else {
-        lua_result = input_ln(f, bypass_eoln);
-    }
-    if (lua_result == true) {
-        /* Fix up the input buffer using callbacks */
-        if (last >= first) {
-            callback_id = callback_defined(process_input_buffer_callback);
-            if (callback_id > 0) {
-                last_ptr = first;
-                lua_result =
-                    run_callback(callback_id, "l->l", (last - first),
-                                 &last_ptr);
-                if ((lua_result == true) && (last_ptr != 0)) {
-                    last = last_ptr;
-                    if (last > max_buf_stack)
-                        max_buf_stack = last;
-                }
-            }
-        }
-        return true;
-    }
-    return false;
-}
-
-
-@ We need a special routine to read the first line of \TeX\ input from
-the user's terminal. This line is different because it is read before we
-have opened the transcript file; there is sort of a ``chicken and
-egg'' problem here. If the user types `\.{\\input paper}' on the first
-line, or if some macro invoked by that line does such an \.{\\input},
-the transcript file will be named `\.{paper.log}'; but if no \.{\\input}
-commands are performed during the first line of terminal input, the transcript
-file will acquire its default name `\.{texput.log}'. (The transcript file
-will not contain error messages generated by the first line before the
-first \.{\\input} command.)
-@.texput@>
-
-The first line is special also because it may be read before \TeX\ has
-input a format file. In such cases, normal error messages cannot yet
-be given. The following code uses concepts that will be explained later.
-
-@ Different systems have different ways to get started. But regardless of
-what conventions are adopted, the routine that initializes the terminal
-should satisfy the following specifications:
-
-\yskip\textindent{1)}It should open file |term_in| for input from the
-  terminal. (The file |term_out| will already be open for output to the
-  terminal.)
-
-\textindent{2)}If the user has given a command line, this line should be
-  considered the first line of terminal input. Otherwise the
-  user should be prompted with `\.{**}', and the first line of input
-  should be whatever is typed in response.
-
-\textindent{3)}The first line of input, which might or might not be a
-  command line, should appear in locations |first| to |last-1| of the
-  |buffer| array.
-
-\textindent{4)}The global variable |loc| should be set so that the
-  character to be read next by \TeX\ is in |buffer[loc]|. This
-  character should not be blank, and we should have |loc<last|.
-
-\yskip\noindent(It may be necessary to prompt the user several times
-before a non-blank line comes in. The prompt is `\.{**}' instead of the
-later `\.*' because the meaning is slightly different: `\.{\\input}' need
-not be typed immediately after~`\.{**}'.)
-
-The following program does the required initialization.
-Iff anything has been specified on the command line, then |t_open_in|
-will return with |last > first|.
-@^system dependencies@>
-
-@c
-boolean init_terminal(void)
-{                               /* gets the terminal input started */
-    t_open_in();
-    if (last > first) {
-        iloc = first;
-        while ((iloc < last) && (buffer[iloc] == ' '))
-            incr(iloc);
-        if (iloc < last) {
-            return true;
-        }
-    }
-    while (1) {
-        wake_up_terminal();
-        fputs("**", term_out);
-        update_terminal();
-        if (!input_ln(term_in, true)) {
-            /* this shouldn't happen */
-            fputs("\n! End of file on the terminal... why?\n", term_out);
-            return false;
-        }
-        iloc = first;
-        while ((iloc < last) && (buffer[iloc] == ' '))
-            incr(iloc);
-        if (iloc < last) {
-            return true;        /* return unless the line was all blank */
-        }
-        fputs("Please type the name of your input file.\n", term_out);
-    }
-}
-
-
-@ Here is a procedure that asks the user to type a line of input,
-assuming that the |selector| setting is either |term_only| or |term_and_log|.
-The input is placed into locations |first| through |last-1| of the
-|buffer| array, and echoed on the transcript file if appropriate.
-
-@c
-void term_input(void)
-{                               /* gets a line from the terminal */
-    int k;                      /* index into |buffer| */
-    update_terminal();          /* now the user sees the prompt for sure */
-    if (!input_ln(term_in, true))
-        fatal_error("End of file on the terminal!");
-    term_offset = 0;            /* the user's line ended with \.{<return>} */
-    decr(selector);             /* prepare to echo the input */
-    if (last != first) {
-        for (k = first; k <= last - 1; k++)
-            print_char(buffer[k]);
-    }
-    print_ln();
-    incr(selector);             /* restore previous status */
-}
-
-
-@ It's time now to fret about file names.  Besides the fact that different
-operating systems treat files in different ways, we must cope with the
-fact that completely different naming conventions are used by different
-groups of people. The following programs show what is required for one
-particular operating system; similar routines for other systems are not
-difficult to devise.
-@^fingers@>
-@^system dependencies@>
-
-\TeX\ assumes that a file name has three parts: the name proper; its
-``extension''; and a ``file area'' where it is found in an external file
-system.  The extension of an input file or a write file is assumed to be
-`\.{.tex}' unless otherwise specified; it is `\.{.log}' on the
-transcript file that records each run of \TeX; it is `\.{.tfm}' on the font
-metric files that describe characters in the fonts \TeX\ uses; it is
-`\.{.dvi}' on the output files that specify typesetting information; and it
-is `\.{.fmt}' on the format files written by \.{INITEX} to initialize \TeX.
-The file area can be arbitrary on input files, but files are usually
-output to the user's current area.  If an input file cannot be
-found on the specified area, \TeX\ will look for it on a special system
-area; this special area is intended for commonly used input files like
-\.{webmac.tex}.
-
-Simple uses of \TeX\ refer only to file names that have no explicit
-extension or area. For example, a person usually says `\.{\\input} \.{paper}'
-or `\.{\\font\\tenrm} \.= \.{helvetica}' instead of `\.{\\input}
-\.{paper.new}' or `\.{\\font\\tenrm} \.= \.{<csd.knuth>test}'. Simple file
-names are best, because they make the \TeX\ source files portable;
-whenever a file name consists entirely of letters and digits, it should be
-treated in the same way by all implementations of \TeX. However, users
-need the ability to refer to other files in their environment, especially
-when responding to error messages concerning unopenable files; therefore
-we want to let them use the syntax that appears in their favorite
-operating system.
-
-The following procedures don't allow spaces to be part of
-file names; but some users seem to like names that are spaced-out.
-System-dependent changes to allow such things should probably
-be made with reluctance, and only when an entire file name that
-includes spaces is ``quoted'' somehow.
-
-Here are the global values that file names will be scanned into.
-
-@c
-str_number cur_name;            /* name of file just scanned */
-str_number cur_area;            /* file area just scanned, or \.{""} */
-str_number cur_ext;             /* file extension just scanned, or \.{""} */
-
-
-@ The file names we shall deal with have the
-following structure:  If the name contains `\./' or `\.:'
-(for Amiga only), the file area
-consists of all characters up to and including the final such character;
-otherwise the file area is null.  If the remaining file name contains
-`\..', the file extension consists of all such characters from the last
-`\..' to the end, otherwise the file extension is null.
-
-We can scan such file names easily by using two global variables that keep track
-of the occurrences of area and extension delimiters:
-
-@c
-pool_pointer area_delimiter;    /* the most recent `\./', if any */
-pool_pointer ext_delimiter;     /* the relevant `\..', if any */
-
-
-@ Input files that can't be found in the user's area may appear in a standard
-system area called |TEX_area|. Font metric files whose areas are not given
-explicitly are assumed to appear in a standard system area called
-|TEX_font_area|.  $\Omega$'s compiled translation process files whose areas
-are not given explicitly are assumed to appear in a standard system area.
-These system area names will, of course, vary from place to place.
-
-@c
-#define append_to_fn(A) do {                                    \
-        c=(A);                                                  \
-        if (c!='"') {                                           \
-            if (k<file_name_size) fn[k++]=(unsigned char)(c);   \
-        }                                                       \
-    } while (0)
-
-
-char *pack_file_name(str_number n, str_number a, str_number e)
-{
-    ASCII_code c;               /* character being packed */
-    unsigned char *j;           /* index into |str_pool| */
-    int k = 0;                  /* number of positions filled in |fn| */
-    unsigned char *fn = xmallocarray(packed_ASCII_code,
-                                     str_length(a) + str_length(n) +
-                                     str_length(e) + 1);
-    for (j = str_string(a); j < str_string(a) + str_length(a); j++)
-        append_to_fn(*j);
-    for (j = str_string(n); j < str_string(n) + str_length(n); j++)
-        append_to_fn(*j);
-    for (j = str_string(e); j < str_string(e) + str_length(e); j++)
-        append_to_fn(*j);
-    fn[k] = 0;
-    return (char *) fn;
-}
-
-
-
-@ A messier routine is also needed, since format file names must be scanned
-before \TeX's string mechanism has been initialized. We shall use the
-global variable |TEX_format_default| to supply the text for default system areas
-and extensions related to format files.
-@^system dependencies@>
-
-Under {\mc UNIX} we don't give the area part, instead depending
-on the path searching that will happen during file opening.  Also, the
-length will be set in the main program.
-
-@c
-char *TEX_format_default;
-
-
-@ This part of the program becomes active when a ``virgin'' \TeX\ is trying to get going,
-just after the preliminary initialization, or when the user is substituting another
-format file by typing `\.\&' after the initial `\.{**}' prompt.  The buffer
-contains the first line of input in |buffer[loc..(last-1)]|, where
-|loc<last| and |buffer[loc]<>" "|.
-
-@c
-char *open_fmt_file(void)
-{
-    int j;                      /* the first space after the format file name */
-    char *fmt = NULL;
-    int dist;
-    j = iloc;
-    if (buffer[iloc] == '&') {
-        incr(iloc);
-        j = iloc;
-        buffer[last] = ' ';
-        while (buffer[j] != ' ')
-            incr(j);
-        fmt = xmalloc((unsigned) (j - iloc + 1));
-        strncpy(fmt, (char *) (buffer + iloc), (size_t) (j - iloc));
-        fmt[j - iloc] = 0;
-        dist = (int) (strlen(fmt) - strlen(DUMP_EXT));
-        if (!(strstr(fmt, DUMP_EXT) == fmt + dist))
-            fmt = concat(fmt, DUMP_EXT);
-        if (zopen_w_input(&fmt_file, fmt, DUMP_FORMAT, FOPEN_RBIN_MODE))
-            goto FOUND;
-        wake_up_terminal();
-        fprintf(stdout, "Sorry, I can't find the format `%s'; will try `%s'.\n",
-                fmt, TEX_format_default);
-        update_terminal();
-    }
-    /* now pull out all the stops: try for the system \.{plain} file */
-    fmt = TEX_format_default;
-    if (!zopen_w_input(&fmt_file, fmt, DUMP_FORMAT, FOPEN_RBIN_MODE)) {
-        wake_up_terminal();
-        fprintf(stdout, "I can't find the format file `%s'!\n",
-                TEX_format_default);
-        return NULL;
-    }
-  FOUND:
-    iloc = j;
-    return fmt;
-}
-
-
-@ The global variable |name_in_progress| is used to prevent recursive
-use of |scan_file_name|, since the |begin_name| and other procedures
-communicate via global variables. Recursion would arise only by
-devious tricks like `\.{\\input\\input f}'; such attempts at sabotage
-must be thwarted. Furthermore, |name_in_progress| prevents \.{\\input}
-@^recursion@>
-from being initiated when a font size specification is being scanned.
-
-Another global variable, |job_name|, contains the file name that was first
-\.{\\input} by the user. This name is extended by `\.{.log}' and `\.{.dvi}'
-and `\.{.fmt}' in the names of \TeX's output files.
-
-@c
-boolean name_in_progress;       /* is a file name being scanned? */
-str_number job_name;            /* principal file name */
-boolean log_opened_global;             /* has the transcript file been opened? */
-
-
-@ Initially |job_name=0|; it becomes nonzero as soon as the true name is known.
-We have |job_name=0| if and only if the `\.{log}' file has not been opened,
-except of course for a short time just after |job_name| has become nonzero.
-
-@c
-unsigned char *texmf_log_name;  /* full name of the log file */
-
-@ The |open_log_file| routine is used to open the transcript file and to help
-it catch up to what has previously been printed on the terminal.
-
-@c
-void open_log_file(void)
-{
-    int old_setting;            /* previous |selector| setting */
-    int k;                      /* index into |buffer| */
-    int l;                      /* end of first input line */
-    char *fn;
-    old_setting = selector;
-    if (job_name == 0)
-        job_name = getjobname(maketexstring("texput")); /* TODO */
-    fn = pack_job_name(".fls");
-    recorder_change_filename(fn);
-    fn = pack_job_name(".log");
-    while (!lua_a_open_out(&log_file, fn, 0)) {
-        /* Try to get a different log file name */
-        /* Sometimes |open_log_file| is called at awkward moments when \TeX\ is
-           unable to print error messages or even to |show_context|.
-           The |prompt_file_name| routine can result in a |fatal_error|, but the |error|
-           routine will not be invoked because |log_opened| will be false.
-
-           The normal idea of |batch_mode| is that nothing at all should be written
-           on the terminal. However, in the unusual case that
-           no log file could be opened, we make an exception and allow
-           an explanatory message to be seen.
-
-           Incidentally, the program always refers to the log file as a `\.{transcript
-           file}', because some systems cannot use the extension `\.{.log}' for
-           this file.
-         */
-        selector = term_only;
-        fn = prompt_file_name("transcript file name", ".log");
-    }
-    texmf_log_name = (unsigned char *) xstrdup(fn);
-    selector = log_only;
-    log_opened_global = true;
-    if (callback_defined(start_run_callback) == 0) {
-        /* Print the banner line, including current date and time */
-        log_banner(luatex_version_string);
-
-        input_stack[input_ptr] = cur_input;     /* make sure bottom level is in memory */
-        tprint_nl("**");
-        l = input_stack[0].limit_field; /* last position of first line */
-        if (buffer[l] == end_line_char_par)
-            decr(l);            /* TODO: multichar endlinechar */
-        for (k = 1; k <= l; k++)
-            print_char(buffer[k]);
-        print_ln();             /* now the transcript file contains the first line of input */
-    }
-    flush_loggable_info();      /* should be done always */
-    selector = old_setting + 2; /* |log_only| or |term_and_log| */
-}
-
-@ This function is needed by synctex to make its log appear in the right
-spot when |output_directory| is set.
-
-@c
-char *get_full_log_name (void)
-{
-   if (output_directory) {
-       char *ret  = xmalloc(strlen((char *)texmf_log_name)+2+strlen(output_directory));
-       ret = strcpy(ret, output_directory);
-       strcat(ret, "/");
-       strcat(ret, (char *)texmf_log_name);
-       return ret;
-   } else {
-       return xstrdup((const char*)texmf_log_name);
-   }
-}
-
-@ Synctex uses this to get the anchored path of an input file.
-
-@c
-char *luatex_synctex_get_current_name (void)
-{
-  char *pwdbuf = NULL, *ret;
-  if (kpse_absolute_p(fullnameoffile, false)) {
-     return xstrdup(fullnameoffile);
-  }
-  pwdbuf = xgetcwd();
-  ret = concat3(pwdbuf, DIR_SEP_STRING, fullnameoffile);
-  free(pwdbuf) ;
-  return ret;
-}
-
-
-@ Let's turn now to the procedure that is used to initiate file reading
-when an `\.{\\input}' command is being processed.
-
-@c
-void start_input(void)
-{                               /* \TeX\ will \.{\\input} something */
-    str_number temp_str;
-    char *fn;
-    do {
-        get_x_token();
-    } while ((cur_cmd == spacer_cmd) || (cur_cmd == relax_cmd));
-
-    back_input();
-    if (cur_cmd != left_brace_cmd) {
-        scan_file_name();       /* set |cur_name| to desired file name */
-    } else {
-        scan_file_name_toks();
-    }
-    fn = pack_file_name(cur_name, cur_area, cur_ext);
-    while (1) {
-        begin_file_reading();   /* set up |cur_file| and new level of input */
-        if (lua_a_open_in(&cur_file, fn, 0))
-            break;
-        end_file_reading();     /* remove the level that didn't work */
-        fn = prompt_file_name("input file name", "");
-    }
-    iname = maketexstring(fullnameoffile);
-    /* Now that we have |fullnameoffile|, it is time to post-adjust
-      |cur_name| and |cur_ext| for trailing |.tex| */
-    {
-	char *n, *p;
-	n = p = fullnameoffile + strlen(fullnameoffile);
-	while (p>fullnameoffile) {
-	    p--;
-            if (IS_DIR_SEP(*p)) {
-	        break;
-            }
-	}
-	if (IS_DIR_SEP(*p)) {
-	    p++;
-	}
-	while (n>fullnameoffile) {
-	    n--;
-            if (*n == '.') {
-	        break;
-            }
-	}
-	if (n>p) {
-	    int q = *n;
-	    cur_ext = maketexstring(n);
-	    *n = 0;
-	    cur_name = maketexstring(p);
-	    *n = q;
-        }
-    }
-
-
-    source_filename_stack[in_open] = iname;
-    full_source_filename_stack[in_open] = xstrdup(fullnameoffile);
-    /* we can try to conserve string pool space now */
-    temp_str = search_string(iname);
-    if (temp_str > 0) {
-        flush_str(iname);
-        iname = temp_str;
-    }
-    if (job_name == 0) {
-        job_name = getjobname(cur_name);
-        open_log_file();
-    }
-    /* |open_log_file| doesn't |show_context|, so |limit|
-       and |loc| needn't be set to meaningful values yet */
-    report_start_file(filetype_tex,fullnameoffile);
-    incr(open_parens);
-    update_terminal();
-    istate = new_line;
-    /* Prepare new file {\sl Sync\TeX} information */
-    if (! synctex_get_no_files()) {
-        synctexstartinput();        /* Give control to the {\sl Sync\TeX} controller */
-    }
-    /* Read the first line of the new file */
-    /* Here we have to remember to tell the |lua_input_ln| routine not to
-       start with a |get|. If the file is empty, it is considered to
-       contain a single blank line. */
-    line = 1;
-    if (lua_input_ln(cur_file, 0, false)) {
-        ;
-    }
-    firm_up_the_line();
-    if (end_line_char_inactive)
-        decr(ilimit);
-    else
-        buffer[ilimit] = (packed_ASCII_code) end_line_char_par;
-    first = ilimit + 1;
-    iloc = istart;
-}
-
-@ Read and write dump files through zlib
-
-@ Earlier versions recast |*f| from |FILE *| to |gzFile|, but there is
-no guarantee that these have the same size, so a static variable
-is needed.
-
-@c
-static gzFile gz_fmtfile = NULL;
-
-@ As distributed, the dump files are
-architecture dependent; specifically, BigEndian and LittleEndian
-architectures produce different files.  These routines always output
-BigEndian files.  This still does not guarantee them to be
-architecture-independent, because it is possible to make a format
-that dumps a glue ratio, i.e., a floating-point number.  Fortunately,
-none of the standard formats do that.
-
-@c
-#if !defined (WORDS_BIGENDIAN) && !defined (NO_DUMP_SHARE)
-
-/* This macro is always invoked as a statement.  It assumes a variable
-   `temp'.  */
-#  define SWAP(x, y) do { temp = x; x = y; y = temp; } while (0)
-
-/* Make the NITEMS items pointed at by P, each of size SIZE, be the
-   opposite-endianness of whatever they are now.  */
-static void
-swap_items(char *pp, int nitems, int size)
-{
-    char temp;
-    unsigned total = (unsigned) (nitems * size);
-    char *q = xmalloc(total);
-    char *p = q;
-    memcpy(p,pp,total);
-    /* Since `size' does not change, we can write a while loop for each
-       case, and avoid testing `size' for each time.  */
-    switch (size) {
-        /* 16-byte items happen on the DEC Alpha machine when we are not
-           doing sharable memory dumps.  */
-    case 16:
-        while (nitems--) {
-            SWAP(p[0], p[15]);
-            SWAP(p[1], p[14]);
-            SWAP(p[2], p[13]);
-            SWAP(p[3], p[12]);
-            SWAP(p[4], p[11]);
-            SWAP(p[5], p[10]);
-            SWAP(p[6], p[9]);
-            SWAP(p[7], p[8]);
-            p += size;
-        }
-        break;
-
-    case 12:
-        while (nitems--) {
-            SWAP(p[0], p[11]);
-            SWAP(p[1], p[10]);
-            SWAP(p[2], p[9]);
-            SWAP(p[3], p[8]);
-            SWAP(p[4], p[7]);
-            SWAP(p[5], p[6]);
-            p += size;
-        }
-        break;
-
-    case 8:
-        while (nitems--) {
-            SWAP(p[0], p[7]);
-            SWAP(p[1], p[6]);
-            SWAP(p[2], p[5]);
-            SWAP(p[3], p[4]);
-            p += size;
-        }
-        break;
-
-    case 4:
-        while (nitems--) {
-            SWAP(p[0], p[3]);
-            SWAP(p[1], p[2]);
-            p += size;
-        }
-        break;
-
-    case 2:
-        while (nitems--) {
-            SWAP(p[0], p[1]);
-            p += size;
-        }
-        break;
-
-    case 1:
-        /* Nothing to do.  */
-        break;
-
-    default:
-        FATAL1("Can't swap a %d-byte item for (un)dumping", size);
-    }
-    memcpy(pp,q,total);
-    xfree(q);
-}
-#endif                          /* not WORDS_BIGENDIAN and not NO_DUMP_SHARE */
-
-@ That second swap is to make sure following calls don't get
-confused in the case of |dump_things|.
-
-@c
-void do_zdump(char *p, int item_size, int nitems, FILE * out_file)
-{
-    int err;
-    (void) out_file;
-    if (nitems == 0)
-        return;
-#if !defined (WORDS_BIGENDIAN) && !defined (NO_DUMP_SHARE)
-    swap_items(p, nitems, item_size);
-#endif
-    if (gzwrite(gz_fmtfile, (void *) p, (unsigned) (item_size * nitems)) !=
-        item_size * nitems) {
-        fprintf(stderr, "! Could not write %d %d-byte item(s): %s.\n", nitems,
-                item_size, gzerror(gz_fmtfile, &err));
-        uexit(1);
-    }
-#if !defined (WORDS_BIGENDIAN) && !defined (NO_DUMP_SHARE)
-    swap_items(p, nitems, item_size);
-#endif
-}
-
-@ @c
-void do_zundump(char *p, int item_size, int nitems, FILE * in_file)
-{
-    int err;
-    (void) in_file;
-    if (nitems == 0)
-        return;
-    if (gzread(gz_fmtfile, (void *) p, (unsigned) (item_size * nitems)) <= 0) {
-        fprintf(stderr, "Could not undump %d %d-byte item(s): %s.\n",
-                nitems, item_size, gzerror(gz_fmtfile, &err));
-        uexit(1);
-    }
-#if !defined (WORDS_BIGENDIAN) && !defined (NO_DUMP_SHARE)
-    swap_items(p, nitems, item_size);
-#endif
-}
-
-@ @c
-#define COMPRESSION "R3"
-
-boolean zopen_w_input(FILE ** f, const char *fname, int format,
-                      const_string fopen_mode)
-{
-    int callbackid;
-    int res;
-    char *fnam;
-    callbackid = callback_defined(find_format_file_callback);
-    if (callbackid > 0) {
-        res = run_callback(callbackid, "S->R", fname, &fnam);
-        if (res && fnam && strlen(fnam) > 0) {
-            *f = fopen(fnam, fopen_mode);
-            if (*f == NULL) {
-                return 0;
-            }
-        } else {
-            return 0;
-        }
-    } else {
-        res = luatex_open_input(f, fname, format, fopen_mode, true);
-    }
-    if (res) {
-        gz_fmtfile = gzdopen(fileno(*f), "rb" COMPRESSION);
-    }
-    return res;
-}
-
-@ @c
-boolean zopen_w_output(FILE ** f, const char *s, const_string fopen_mode)
-{
-    int res = 1;
-    if (luainit) {
-        *f = fopen(s, fopen_mode);
-        if (*f == NULL) {
-            return 0;
-        }
-    } else {
-        res = luatex_open_output(f, s, fopen_mode);
-    }
-    if (res) {
-        gz_fmtfile = gzdopen(fileno(*f), "wb" COMPRESSION);
-    }
-    return res;
-}
-
-@ @c
-void zwclose(FILE * f)
-{
-    (void) f;
-    gzclose(gz_fmtfile);
-}
-
-@  create the dvi or pdf file
-@c
-int open_outfile(FILE ** f, const char *name, const char *mode)
-{
-    FILE *res;
-    res = fopen(name, mode);
-    if (res != NULL) {
-        *f = res;
-        return 1;
-    }
-    return 0;
-}
-
-
-@ the caller should set |tfm_buffer=NULL| and |tfm_size=0|
-@c
-int readbinfile(FILE * f, unsigned char **tfm_buffer, int *tfm_size)
-{
-    void *buf;
-    int size;
-    if (fseek(f, 0, SEEK_END) == 0) {
-        size = (int) ftell(f);
-        if (size > 0) {
-            buf = xmalloc((unsigned) size);
-            if (fseek(f, 0, SEEK_SET) == 0) {
-                if (fread((void *) buf, (size_t) size, 1, f) == 1) {
-                    *tfm_buffer = (unsigned char *) buf;
-                    *tfm_size = size;
-                    return 1;
-                }
-            }
-        } else {
-            *tfm_buffer = NULL;
-            *tfm_size = 0;
-            return 1;
-        }
-    }                           /* seek failed, or zero-sized file */
-    return 0;
-}
-
-@ Like |os.execute()|, the |runpopen()| function is called only when
-|shellenabledp == 1|. Unlike |os.execute()| we write errors to stderr, since we
-have nowhere better to use; and of course we return a file handle (or NULL)
-instead of a status indicator.
-
-@c
-static FILE *runpopen(char *cmd, const char *mode)
-{
-    FILE *f = NULL;
-    char *safecmd = NULL;
-    char *cmdname = NULL;
-    int allow;
-
-#ifdef WIN32
-    char *pp;
-
-    for (pp = cmd; *pp; pp++) {
-      if (*pp == '\'') *pp = '"';
-    }
-#endif
-
-    /* If restrictedshell == 0, any command is allowed. */
-    if (restrictedshell == 0) {
-        allow = 1;
-    } else {
-        const char *thecmd = cmd;
-        allow = shell_cmd_is_allowed(thecmd, &safecmd, &cmdname);
-    }
-    if (allow == 1)
-        f = popen(cmd, mode);
-    else if (allow == 2)
-        f = popen(safecmd, mode);
-    else if (allow == -1)
-        fprintf(stderr, "\nrunpopen quotation error in command line: %s\n",
-                cmd);
-    else
-        fprintf(stderr, "\nrunpopen command not allowed: %s\n", cmdname);
-
-    if (safecmd)
-        free(safecmd);
-    if (cmdname)
-        free(cmdname);
-    return f;
-}
-
-@  piped I/O
-
-
-@ The code that implements |popen()| needs an array for tracking
-   possible pipe file pointers, because these need to be
-   closed using |pclose()|.
-
-@c
-#define NUM_PIPES 16
-static FILE *pipes[NUM_PIPES];
-
-#ifdef WIN32
-FILE *Poptr;
-#endif
-
-boolean open_in_or_pipe(FILE ** f_ptr, char *fn, int filefmt,
-                        const_string fopen_mode, boolean must_exist)
-{
-    string fname = NULL;
-    int i;                      /* iterator */
-
-    /* opening a read pipe is straightforward, only have to
-       skip past the pipe symbol in the file name. filename
-       quoting is assumed to happen elsewhere (it does :-)) */
-
-    if (shellenabledp && *fn == '|') {
-        /* the user requested a pipe */
-        *f_ptr = NULL;
-        fname = (string) xmalloc((unsigned) (strlen(fn) + 1));
-        strcpy(fname, fn);
-        if (fullnameoffile)
-            free(fullnameoffile);
-        fullnameoffile = xstrdup(fname);
-        recorder_record_input(fname + 1);
-        *f_ptr = runpopen(fname + 1, "r");
-        free(fname);
-        for (i = 0; i < NUM_PIPES; i++) {
-            if (pipes[i] == NULL) {
-                pipes[i] = *f_ptr;
-                break;
-            }
-        }
-        if (*f_ptr)
-            setvbuf(*f_ptr, (char *) NULL, _IONBF, 0);
-#ifdef WIN32
-        Poptr = *f_ptr;
-#endif
-
-        return *f_ptr != NULL;
-    }
-
-    return luatex_open_input(f_ptr, fn, filefmt, fopen_mode, must_exist);
-}
-
-
-boolean open_out_or_pipe(FILE ** f_ptr, char *fn, const_string fopen_mode)
-{
-    string fname;
-    int i;                      /* iterator */
-
-    /* opening a write pipe takes a little bit more work, because TeX
-       will perhaps have appended ".tex".  To avoid user confusion as
-       much as possible, this extension is stripped only when the command
-       is a bare word.  Some small string trickery is needed to make
-       sure the correct number of bytes is free()-d afterwards */
-
-    if (shellenabledp && *fn == '|') {
-        /* the user requested a pipe */
-        fname = (string) xmalloc((unsigned) (strlen(fn) + 1));
-        strcpy(fname, fn);
-        if (strchr(fname, ' ') == NULL && strchr(fname, '>') == NULL) {
-            /* mp and mf currently do not use this code, but it
-               is better to be prepared */
-            if (STREQ((fname + strlen(fname) - 3), "tex"))
-                *(fname + strlen(fname) - 4) = 0;
-            *f_ptr = runpopen(fname + 1, "w");
-            *(fname + strlen(fname)) = '.';
-        } else {
-            *f_ptr = runpopen(fname + 1, "w");
-        }
-        recorder_record_output(fname + 1);
-        free(fname);
-
-        for (i = 0; i < NUM_PIPES; i++) {
-            if (pipes[i] == NULL) {
-                pipes[i] = *f_ptr;
-                break;
-            }
-        }
-
-        if (*f_ptr)
-            setvbuf(*f_ptr, (char *) NULL, _IONBF, 0);
-
-        return *f_ptr != NULL;
-    }
-
-    return luatex_open_output(f_ptr, fn, fopen_mode);
-}
-
-
-void close_file_or_pipe(FILE * f)
-{
-    int i;                      /* iterator */
-
-    if (shellenabledp) {
-        for (i = 0; i <= 15; i++) {
-        /* if this file was a pipe, |pclose()| it and return */
-            if (pipes[i] == f) {
-                if (f) {
-                    pclose(f);
-#ifdef WIN32
-                    Poptr = NULL;
-#endif
-                }
-                pipes[i] = NULL;
-                return;
-            }
-        }
-    }
-    close_file(f);
-}
diff --git a/texk/web2c/luatexdir/tex/texmath.w b/texk/web2c/luatexdir/tex/texmath.c
similarity index 61%
rename from texk/web2c/luatexdir/tex/texmath.w
rename to texk/web2c/luatexdir/tex/texmath.c
index 6d4b87a38..69e58b0ea 100644
--- a/texk/web2c/luatexdir/tex/texmath.w
+++ b/texk/web2c/luatexdir/tex/texmath.c
@@ -1,46 +1,43 @@
-% texmath.w
-%
-% Copyright 2008-2010 Taco Hoekwater <taco@@luatex.org>
-%
-% This file is part of LuaTeX.
-%
-% LuaTeX is free software; you can redistribute it and/or modify it under
-% the terms of the GNU General Public License as published by the Free
-% Software Foundation; either version 2 of the License, or (at your
-% option) any later version.
-%
-% LuaTeX is distributed in the hope that it will be useful, but WITHOUT
-% ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-% FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
-% License for more details.
-%
-% You should have received a copy of the GNU General Public License along
-% with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
-
-@ @c
+/*
+
+Copyright 2008-2010 Taco Hoekwater <taco@luatex.org>
+
+This file is part of LuaTeX.
+
+LuaTeX is free software; you can redistribute it and/or modify it under the terms
+of the GNU General Public License as published by the Free Software Foundation;
+either version 2 of the License, or (at your option) any later version.
+
+LuaTeX is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU General Public License along with
+LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+
+*/
+
 #include "ptexlib.h"
 
-@ @c
 #define mode     mode_par
 #define tail     tail_par
 #define head     head_par
 #define dir_save dirs_par
 
-/*
-
-    \mathdisplayskipmode
+/*tex
 
-    tex normally always inserts before and only after when larger than zero
+    Concerning display skips, \TEX\ normally always inserts before and only after
+    when larger than zero. THis can ow be controlled with |\mathdisplayskipmode|:
 
-    0 = normal tex
-    1 = always
-    2 = non-zero
-    3 = ignore
+    \starttabulate
+    \NC 0 \NC normal \TEX \NC \NR
+    \NC 1 \NC always      \NC \NR
+    \NC 2 \NC non-zero    \NC \NR
+    \NC 3 \NC ignore      \NC \NR
+    \stoptabulate
 
 */
 
-@ TODO: not sure if this is the right order
-@c
 #define back_error(A,B) do {                    \
     OK_to_interrupt=false;                      \
     back_input();                               \
@@ -48,90 +45,107 @@
     tex_error(A,B);                             \
   } while (0)
 
-@ @c
 int scan_math(pointer, int);
 int scan_math_style(pointer, int);
 pointer fin_mlist(pointer);
 
-@ When \TeX\ reads a formula that is enclosed between \.\$'s, it constructs an
-{\sl mlist}, which is essentially a tree structure representing that
-formula.  An mlist is a linear sequence of items, but we can regard it as
-a tree structure because mlists can appear within mlists. For example, many
-of the entries can be subscripted or superscripted, and such ``scripts''
-are mlists in their own right.
-
-An entire formula is parsed into such a tree before any of the actual
-typesetting is done, because the current style of type is usually not
-known until the formula has been fully scanned. For example, when the
-formula `\.{\$a+b \\over c+d\$}' is being read, there is no way to tell
-that `\.{a+b}' will be in script size until `\.{\\over}' has appeared.
-
-During the scanning process, each element of the mlist being built is
-classified as a relation, a binary operator, an open parenthesis, etc.,
-or as a construct like `\.{\\sqrt}' that must be built up. This classification
-appears in the mlist data structure.
-
-After a formula has been fully scanned, the mlist is converted to an hlist
-so that it can be incorporated into the surrounding text. This conversion is
-controlled by a recursive procedure that decides all of the appropriate
-styles by a ``top-down'' process starting at the outermost level and working
-in towards the subformulas. The formula is ultimately pasted together using
-combinations of horizontal and vertical boxes, with glue and penalty nodes
-inserted as necessary.
-
-An mlist is represented internally as a linked list consisting chiefly
-of ``noads'' (pronounced ``no-adds''), to distinguish them from the somewhat
-similar ``nodes'' in hlists and vlists. Certain kinds of ordinary nodes are
-allowed to appear in mlists together with the noads; \TeX\ tells the difference
-by means of the |type| field, since a noad's |type| is always greater than
-that of a node. An mlist does not contain character nodes, hlist nodes, vlist
-nodes, math nodes or unset nodes; in particular, each mlist item appears in the
-variable-size part of |mem|, so the |type| field is always present.
-
-Each noad is five or more words long. The first word contains the
-|type| and |subtype| and |link| fields that are already so familiar to
-us; the second contains the attribute list pointer, and the third,
-fourth an fifth words are called the noad's |nucleus|, |subscr|, and
-|supscr| fields. (This use of a combined attribute list is temporary.
-Eventually, each of fields need their own list)
-
-Consider, for example, the simple formula `\.{\$x\^2\$}', which would be
-parsed into an mlist containing a single element called an |ord_noad|.
-The |nucleus| of this noad is a representation of `\.x', the |subscr| is
-empty, and the |supscr| is a representation of `\.2'.
-
-The |nucleus|, |subscr|, and |supscr| fields are further broken into
-subfields. If |p| points to a noad, and if |q| is one of its principal
-fields (e.g., |q=subscr(p)|), |q=null| indicates a field with no value (the
-corresponding attribute of noad |p| is not present). Otherwise, there are
-several possibilities for the subfields, depending on the |type| of |q|.
-
-\yskip\hang|type(q)=math_char_node| means that |math_fam(q)| refers to one of
-the sixteen font families, and |character(q)| is the number of a character
-within a font of that family, as in a character node.
-
-\yskip\hang|type(q)=math_text_char_node| is similar, but the character is
-unsubscripted and unsuperscripted and it is followed immediately by another
-character from the same font. (This |type| setting appears only
-briefly during the processing; it is used to suppress unwanted italic
-corrections.)
-
-\yskip\hang|type(q)=sub_box_node| means that |math_list(q)| points to a box
-node (either an |hlist_node| or a |vlist_node|) that should be used as the
-value of the field.  The |shift_amount| in the subsidiary box node is the
-amount by which that box will be shifted downward.
-
-\yskip\hang|type(q)=sub_mlist_node| means that |math_list(q)| points to
-an mlist; the mlist must be converted to an hlist in order to obtain
-the value of this field.
-
-\yskip\noindent In the latter case, we might have |math_list(q)=null|. This
-is not the same as |q=null|; for example, `\.{\$P\_\{\}\$}'
-and `\.{\$P\$}' produce different results (the former will not have the
-``italic correction'' added to the width of |P|, but the ``script skip''
-will be added).
-
-@c
+/*tex
+
+    When \TeX\ reads a formula that is enclosed between \.\$'s, it constructs an
+    {\sl mlist}, which is essentially a tree structure representing that formula.
+    An mlist is a linear sequence of items, but we can regard it as a tree
+    structure because mlists can appear within mlists. For example, many of the
+    entries can be subscripted or superscripted, and such ``scripts'' are mlists
+    in their own right.
+
+    An entire formula is parsed into such a tree before any of the actual
+    typesetting is done, because the current style of type is usually not known
+    until the formula has been fully scanned. For example, when the formula
+    `\.{\$a+b \\over c+d\$}' is being read, there is no way to tell that
+    `\.{a+b}' will be in script size until `\.{\\over}' has appeared.
+
+    During the scanning process, each element of the mlist being built is
+    classified as a relation, a binary operator, an open parenthesis, etc., or as
+    a construct like `\.{\\sqrt}' that must be built up. This classification
+    appears in the mlist data structure.
+
+    After a formula has been fully scanned, the mlist is converted to an hlist so
+    that it can be incorporated into the surrounding text. This conversion is
+    controlled by a recursive procedure that decides all of the appropriate
+    styles by a ``top-down'' process starting at the outermost level and working
+    in towards the subformulas. The formula is ultimately pasted together using
+    combinations of horizontal and vertical boxes, with glue and penalty nodes
+    inserted as necessary.
+
+    An mlist is represented internally as a linked list consisting chiefly of
+    ``noads'' (pronounced ``no-adds''), to distinguish them from the somewhat
+    similar ``nodes'' in hlists and vlists. Certain kinds of ordinary nodes are
+    allowed to appear in mlists together with the noads; \TeX\ tells the
+    difference by means of the |type| field, since a noad's |type| is always
+    greater than that of a node. An mlist does not contain character nodes, hlist
+    nodes, vlist nodes, math nodes or unset nodes; in particular, each mlist item
+    appears in the variable-size part of |mem|, so the |type| field is always
+    present.
+
+    Each noad is five or more words long. The first word contains the |type| and
+    |subtype| and |link| fields that are already so familiar to us; the second
+    contains the attribute list pointer, and the third, fourth an fifth words are
+    called the noad's |nucleus|, |subscr|, and |supscr| fields. (This use of a
+    combined attribute list is temporary. Eventually, each of fields need their
+    own list)
+
+    Consider, for example, the simple formula `\.{\$x\^2\$}', which would be
+    parsed into an mlist containing a single element called an |ord_noad|. The
+    |nucleus| of this noad is a representation of `\.x', the |subscr| is empty,
+    and the |supscr| is a representation of `\.2'.
+
+    The |nucleus|, |subscr|, and |supscr| fields are further broken into
+    subfields. If |p| points to a noad, and if |q| is one of its principal fields
+    (e.g., |q=subscr(p)|), |q=null| indicates a field with no value (the
+    corresponding attribute of noad |p| is not present). Otherwise, there are
+    several possibilities for the subfields, depending on the |type| of |q|.
+
+    \startitemize
+
+        \startitem
+            |type(q)=math_char_node| means that |math_fam(q)| refers to one of
+            the sixteen font families, and |character(q)| is the number of a
+            character within a font of that family, as in a character node.
+        \stopitem
+
+        \startitem
+            |type(q)=math_text_char_node| is similar, but the character is
+            unsubscripted and unsuperscripted and it is followed immediately by
+            another character from the same font. (This |type| setting appears
+            only briefly during the processing; it is used to suppress unwanted
+            italic corrections.)
+        \stopitem
+
+        \startitem
+            |type(q)=sub_box_node| means that |math_list(q)| points to a box node
+            (either an |hlist_node| or a |vlist_node|) that should be used as the
+            value of the field. The |shift_amount| in the subsidiary box node is
+            the amount by which that box will be shifted downward.
+        \stopitem
+
+        \startitem
+            |type(q)=sub_mlist_node| means that |math_list(q)| points to an
+            mlist; the mlist must be converted to an hlist in order to obtain the
+            value of this field.
+        \stopitem
+
+        \startitem
+            In the latter case, we might have |math_list(q)=null|. This is not
+            the same as |q=null|; for example, `\.{\$P\_\{\}\$}' and `\.{\$P\$}'
+            produce different results (the former will not have the ``italic
+            correction'' added to the width of |P|, but the ``script skip'' will
+            be added).
+        \stopitem
+
+    \startitemize
+
+*/
+
 static void unsave_math(void)
 {
     unsave();
@@ -141,10 +155,13 @@ static void unsave_math(void)
     text_dir_ptr = saved_value(0);
 }
 
-@ Sometimes it is necessary to destroy an mlist. The following
-subroutine empties the current list, assuming that |abs(mode)=mmode|.
+/*tex
+
+    Sometimes it is necessary to destroy an mlist. The following subroutine
+    empties the current list, assuming that |abs(mode)=mmode|.
+
+*/
 
-@c
 void flush_math(void)
 {
     flush_node_list(vlink(head));
@@ -154,15 +171,13 @@ void flush_math(void)
     incompleat_noad_par = null;
 }
 
-@ Before we can do anything in math mode, we need fonts.
+/*tex Before we can do anything in math mode, we need fonts. */
 
-@c
 #define MATHFONTSTACK  8
-#define MATHFONTDEFAULT 0       /* == nullfont */
+#define MATHFONTDEFAULT 0
 
 static sa_tree math_fam_head = NULL;
 
-@ @c
 int fam_fnt(int fam_id, int size_id)
 {
     int n = fam_id + (256 * size_id);
@@ -189,7 +204,6 @@ void def_fam_fnt(int fam_id, int size_id, int f, int lvl)
     }
 }
 
-@ @c
 static void unsave_math_fam_data(int gl)
 {
     sa_stack_item st;
@@ -201,7 +215,7 @@ static void unsave_math_fam_data(int gl)
         st = math_fam_head->stack[math_fam_head->stack_ptr];
         if (st.level > 0) {
             rawset_sa_item(math_fam_head, st.code, st.value);
-            /* now do a trace message, if requested */
+            /*tex Now do a trace message, if requested. */
             if (tracing_restores_par > 1) {
                 int size_id = st.code / 256;
                 int fam_id = st.code % 256;
@@ -220,15 +234,13 @@ static void unsave_math_fam_data(int gl)
     }
 }
 
-@ and parameters
+/*tex Parameters */
 
-@c
 #define MATHPARAMSTACK  8
 #define MATHPARAMDEFAULT undefined_math_parameter
 
 static sa_tree math_param_head = NULL;
 
-@ @c
 void def_math_param(int param_id, int style_id, scaled value, int lvl)
 {
     int n = param_id + (256 * style_id);
@@ -254,7 +266,6 @@ scaled get_math_param(int param_id, int style_id)
     return (scaled) get_sa_item(math_param_head, n).int_value;
 }
 
-@ @c
 static void unsave_math_param_data(int gl)
 {
     sa_stack_item st;
@@ -266,7 +277,7 @@ static void unsave_math_param_data(int gl)
         st = math_param_head->stack[math_param_head->stack_ptr];
         if (st.level > 0) {
             rawset_sa_item(math_param_head, st.code, st.value);
-            /* now do a trace message, if requested */
+            /*tex Do a trace message, if requested. */
             if (tracing_restores_par > 1) {
                 int param_id = st.code % 256;
                 int style_id = st.code / 256;
@@ -285,17 +296,16 @@ static void unsave_math_param_data(int gl)
     }
 }
 
-@ saving and unsaving of both
+/*tex Saving and unsaving of both: */
 
-@c
 void unsave_math_data(int gl)
 {
     unsave_math_fam_data(gl);
     unsave_math_param_data(gl);
 }
 
-@ Dumping and undumping
-@c
+/*tex Dumping and undumping: */
+
 void dump_math_data(void)
 {
     sa_tree_item sa_value = { 0 };
@@ -317,7 +327,6 @@ void undump_math_data(void)
     math_param_head = undump_sa_tree("mathparameters");
 }
 
-@ @c
 void initialize_math(void)
 {
     sa_tree_item sa_value = { 0 };
@@ -333,62 +342,63 @@ void initialize_math(void)
     return;
 }
 
-@ Each portion of a formula is classified as Ord, Op, Bin, Rel, Ope,
-Clo, Pun, or Inn, for purposes of spacing and line breaking. An
-|ord_noad|, |op_noad|, |bin_noad|, |rel_noad|, |open_noad|, |close_noad|,
-|punct_noad|, or |inner_noad| is used to represent portions of the various
-types. For example, an `\.=' sign in a formula leads to the creation of a
-|rel_noad| whose |nucleus| field is a representation of an equals sign
-(usually |fam=0|, |character=075|).  A formula preceded by \.{\\mathrel}
-also results in a |rel_noad|.  When a |rel_noad| is followed by an
-|op_noad|, say, and possibly separated by one or more ordinary nodes (not
-noads), \TeX\ will insert a penalty node (with the current |rel_penalty|)
-just after the formula that corresponds to the |rel_noad|, unless there
-already was a penalty immediately following; and a ``thick space'' will be
-inserted just before the formula that corresponds to the |op_noad|.
-
-A noad of type |ord_noad|, |op_noad|, \dots, |inner_noad| usually
-has a |subtype=normal|. The only exception is that an |op_noad| might
-have |subtype=limits| or |no_limits|, if the normal positioning of
-limits has been overridden for this operator.
-
-A |radical_noad| also has a |left_delimiter| field, which usually
-represents a square root sign.
-
-A |fraction_noad| has a |right_delimiter| field as well as a |left_delimiter|.
-
-Delimiter fields have four subfields
-called |small_fam|, |small_char|, |large_fam|, |large_char|. These subfields
-represent variable-size delimiters by giving the ``small'' and ``large''
-starting characters, as explained in Chapter~17 of {\sl The \TeX book}.
-@:TeXbook}{\sl The \TeX book@>
-
-A |fraction_noad| is actually quite different from all other noads.
-It has |thickness|, |denominator|, and |numerator| fields instead of
-|nucleus|, |subscr|, and |supscr|. The |thickness| is a scaled value
-that tells how thick to make a fraction rule; however, the special
-value |default_code| is used to stand for the
-|default_rule_thickness| of the current size. The |numerator| and
-|denominator| point to mlists that define a fraction; we always have
-$$\hbox{|type(numerator)=type(denominator)=sub_mlist|}.$$ The
-|left_delimiter| and |right_delimiter| fields specify delimiters that will
-be placed at the left and right of the fraction. In this way, a
-|fraction_noad| is able to represent all of \TeX's operators \.{\\over},
-\.{\\atop}, \.{\\above}, \.{\\overwithdelims}, \.{\\atopwithdelims}, and
- \.{\\abovewithdelims}.
-
-@ The |new_noad| function creates an |ord_noad| that is completely null
-
-@c
+/*tex
+
+    Each portion of a formula is classified as Ord, Op, Bin, Rel, Ope, Clo, Pun,
+    or Inn, for purposes of spacing and line breaking. An |ord_noad|, |op_noad|,
+    |bin_noad|, |rel_noad|, |open_noad|, |close_noad|, |punct_noad|, or
+    |inner_noad| is used to represent portions of the various types. For example,
+    an `\.=' sign in a formula leads to the creation of a |rel_noad| whose
+    |nucleus| field is a representation of an equals sign (usually |fam=0|,
+    |character=075|). A formula preceded by \.{\\mathrel} also results in a
+    |rel_noad|. When a |rel_noad| is followed by an |op_noad|, say, and possibly
+    separated by one or more ordinary nodes (not noads), \TeX\ will insert a
+    penalty node (with the current |rel_penalty|) just after the formula that
+    corresponds to the |rel_noad|, unless there already was a penalty immediately
+    following; and a ``thick space'' will be inserted just before the formula
+    that corresponds to the |op_noad|.
+
+    A noad of type |ord_noad|, |op_noad|, \dots, |inner_noad| usually has a
+    |subtype=normal|. The only exception is that an |op_noad| might have
+    |subtype=limits| or |no_limits|, if the normal positioning of limits has been
+    overridden for this operator.
+
+    A |radical_noad| also has a |left_delimiter| field, which usually represents
+    a square root sign.
+
+    A |fraction_noad| has a |right_delimiter| field as well as a
+    |left_delimiter|.
+
+    Delimiter fields have four subfields called |small_fam|, |small_char|,
+    |large_fam|, |large_char|. These subfields represent variable-size delimiters
+    by giving the ``small'' and ``large'' starting characters, as explained in
+    Chapter~17 of {\sl The \TeX book}.
+
+    A |fraction_noad| is actually quite different from all other noads. It has
+    |thickness|, |denominator|, and |numerator| fields instead of |nucleus|,
+    |subscr|, and |supscr|. The |thickness| is a scaled value that tells how
+    thick to make a fraction rule; however, the special value |default_code| is
+    used to stand for the |default_rule_thickness| of the current size. The
+    |numerator| and |denominator| point to mlists that define a fraction; we
+    always have $$\hbox{|type(numerator)=type(denominator)=sub_mlist|}.$$ The
+    |left_delimiter| and |right_delimiter| fields specify delimiters that will be
+    placed at the left and right of the fraction. In this way, a |fraction_noad|
+    is able to represent all of \TeX's operators \.{\\over}, \.{\\atop},
+    \.{\\above}, \.{\\overwithdelims}, \.{\\atopwithdelims}, and
+    \.{\\abovewithdelims}.
+
+    The |new_noad| function creates an |ord_noad| that is completely null
+
+*/
+
 pointer new_noad(void)
 {
     pointer p;
     p = new_node(simple_noad, ord_noad_type);
-    /* all noad fields are zero after this */
+    /*tex All noad fields are zero after this. */
     return p;
 }
 
-@ @c
 pointer new_sub_box(pointer curbox)
 {
     pointer p, q;
@@ -399,40 +409,41 @@ pointer new_sub_box(pointer curbox)
     return p;
 }
 
-@ A few more kinds of noads will complete the set: An |under_noad| has its
-nucleus underlined; an |over_noad| has it overlined. An |accent_noad| places
-an accent over its nucleus; the accent character appears as
-|math_fam(accent_chr(p))| and |math_character(accent_chr(p))|. A |vcenter_noad|
-centers its nucleus vertically with respect to the axis of the formula;
-in such noads we always have |type(nucleus(p))=sub_box|.
-
-And finally, we have the |fence_noad| type, to implement
-\TeX's \.{\\left} and \.{\\right} as well as eTeX's \.{\\middle}.
-The |nucleus| of such noads is
-replaced by a |delimiter| field; thus, for example, `\.{\\left(}' produces
-a |fence_noad| such that |delimiter(p)| holds the family and character
-codes for all left parentheses. A |fence_noad| of subtype |left_noad_side|
-never appears in an mlist except as the first element, and a |fence_noad|
-with subtype |right_noad_side| never appears in an mlist
-except as the last element; furthermore, we either have both a |left_noad_side|
-and a |right_noad_side|, or neither one is present.
-
-@ Math formulas can also contain instructions like \.{\\textstyle} that
-override \TeX's normal style rules. A |style_node| is inserted into the
-data structure to record such instructions; it is three words long, so it
-is considered a node instead of a noad. The |subtype| is either |display_style|
-or |text_style| or |script_style| or |script_script_style|. The
-second and third words of a |style_node| are not used, but they are
-present because a |choice_node| is converted to a |style_node|.
-
-\TeX\ uses even numbers 0, 2, 4, 6 to encode the basic styles
-|display_style|, \dots, |script_script_style|, and adds~1 to get the
-``cramped'' versions of these styles. This gives a numerical order that
-is backwards from the convention of Appendix~G in {\sl The \TeX book\/};
-i.e., a smaller style has a larger numerical value.
-@:TeXbook}{\sl The \TeX book@>
-
-@c
+/*tex
+
+    A few more kinds of noads will complete the set: An |under_noad| has its
+    nucleus underlined; an |over_noad| has it overlined. An |accent_noad| places
+    an accent over its nucleus; the accent character appears as
+    |math_fam(accent_chr(p))| and |math_character(accent_chr(p))|. A
+    |vcenter_noad| centers its nucleus vertically with respect to the axis of the
+    formula; in such noads we always have |type(nucleus(p))=sub_box|.
+
+    And finally, we have the |fence_noad| type, to implement \TeX's \.{\\left}
+    and \.{\\right} as well as eTeX's \.{\\middle}. The |nucleus| of such noads
+    is replaced by a |delimiter| field; thus, for example, `\.{\\left(}' produces
+    a |fence_noad| such that |delimiter(p)| holds the family and character codes
+    for all left parentheses. A |fence_noad| of subtype |left_noad_side| never
+    appears in an mlist except as the first element, and a |fence_noad| with
+    subtype |right_noad_side| never appears in an mlist except as the last
+    element; furthermore, we either have both a |left_noad_side| and a
+    |right_noad_side|, or neither one is present.
+
+    Math formulas can also contain instructions like \.{\\textstyle} that
+    override \TeX's normal style rules. A |style_node| is inserted into the data
+    structure to record such instructions; it is three words long, so it is
+    considered a node instead of a noad. The |subtype| is either |display_style|
+    or |text_style| or |script_style| or |script_script_style|. The second and
+    third words of a |style_node| are not used, but they are present because a
+    |choice_node| is converted to a |style_node|.
+
+    \TeX\ uses even numbers 0, 2, 4, 6 to encode the basic styles
+    |display_style|, \dots, |script_script_style|, and adds~1 to get the
+    ``cramped'' versions of these styles. This gives a numerical order that is
+    backwards from the convention of Appendix~G in {\sl The \TeX book\/}; i.e., a
+    smaller style has a larger numerical value.
+
+*/
+
 const char *math_style_names[] = {
     "display", "crampeddisplay",
     "text", "crampedtext",
@@ -482,93 +493,96 @@ const char *math_param_names[] = {
     NULL
 };
 
-@ @c
 pointer new_style(small_number s)
-{                               /* create a style node */
+{
     m_style = s;
     return new_node(style_node, s);
 }
 
-@ Finally, the \.{\\mathchoice} primitive creates a |choice_node|, which
-has special subfields |display_mlist|, |text_mlist|, |script_mlist|,
-and |script_script_mlist| pointing to the mlists for each style.
+/*tex
+
+    Finally, the \.{\\mathchoice} primitive creates a |choice_node|, which has
+    special subfields |display_mlist|, |text_mlist|, |script_mlist|, and
+    |script_script_mlist| pointing to the mlists for each style.
+
+*/
 
-@c
 static pointer new_choice(void)
-{                               /* create a choice node */
-    return new_node(choice_node, 0);    /* the |subtype| is not used */
-}
-
-@ Let's consider now the previously unwritten part of |show_node_list|
-that displays the things that can only be present in mlists; this
-program illustrates how to access the data structures just defined.
-
-In the context of the following program, |p| points to a node or noad that
-should be displayed, and the current string contains the ``recursion history''
-that leads to this point. The recursion history consists of a dot for each
-outer level in which |p| is subsidiary to some node, or in which |p| is
-subsidiary to the |nucleus| field of some noad; the dot is replaced by
-`\.\_' or `\.\^' or `\./' or `\.\\' if |p| is descended from the |subscr|
-or |supscr| or |denominator| or |numerator| fields of noads. For example,
-the current string would be `\.{.\^.\_/}' if |p| points to the |ord_noad| for
-|x| in the (ridiculous) formula
-`\.{\$\\sqrt\{a\^\{\\mathinner\{b\_\{c\\over x+y\}\}\}\}\$}'.
-
-@c
-void display_normal_noad(pointer p);    /* forward */
-void display_fence_noad(pointer p);     /* forward */
-void display_fraction_noad(pointer p);  /* forward */
+{
+    return new_node(choice_node, 0);
+}
+
+/*tex
+
+    Let's consider now the previously unwritten part of |show_node_list| that
+    displays the things that can only be present in mlists; this program
+    illustrates how to access the data structures just defined.
+
+    In the context of the following program, |p| points to a node or noad that
+    should be displayed, and the current string contains the ``recursion
+    history'' that leads to this point. The recursion history consists of a dot
+    for each outer level in which |p| is subsidiary to some node, or in which |p|
+    is subsidiary to the |nucleus| field of some noad; the dot is replaced by
+    `\.\_' or `\.\^' or `\./' or `\.\\' if |p| is descended from the |subscr| or
+    |supscr| or |denominator| or |numerator| fields of noads. For example, the
+    current string would be `\.{.\^.\_/}' if |p| points to the |ord_noad| for |x|
+    in the (ridiculous) formula `\.{\$\\sqrt\{a\^\{\\mathinner\{b\_\{c\\over
+    x+y\}\}\}\}\$}'.
+
+*/
+
+void display_normal_noad(pointer p);
+void display_fence_noad(pointer p);
+void display_fraction_noad(pointer p);
 
 void show_math_node(pointer p)
 {
     switch (type(p)) {
-    case style_node:
-        print_cmd_chr(math_style_cmd, subtype(p));
-        break;
-    case choice_node:
-        tprint_esc("mathchoice");
-        append_char('D');
-        show_node_list(display_mlist(p));
-        flush_char();
-        append_char('T');
-        show_node_list(text_mlist(p));
-        flush_char();
-        append_char('S');
-        show_node_list(script_mlist(p));
-        flush_char();
-        append_char('s');
-        show_node_list(script_script_mlist(p));
-        flush_char();
-        break;
-    case simple_noad:
-    case radical_noad:
-    case accent_noad:
-        display_normal_noad(p);
-        break;
-    case fence_noad:
-        display_fence_noad(p);
-        break;
-    case fraction_noad:
-        display_fraction_noad(p);
-        break;
-    default:
-        tprint("Unknown node type!");
-        break;
+        case style_node:
+            print_cmd_chr(math_style_cmd, subtype(p));
+            break;
+        case choice_node:
+            tprint_esc("mathchoice");
+            append_char('D');
+            show_node_list(display_mlist(p));
+            flush_char();
+            append_char('T');
+            show_node_list(text_mlist(p));
+            flush_char();
+            append_char('S');
+            show_node_list(script_mlist(p));
+            flush_char();
+            append_char('s');
+            show_node_list(script_script_mlist(p));
+            flush_char();
+            break;
+        case simple_noad:
+        case radical_noad:
+        case accent_noad:
+            display_normal_noad(p);
+            break;
+        case fence_noad:
+            display_fence_noad(p);
+            break;
+        case fraction_noad:
+            display_fraction_noad(p);
+            break;
+        default:
+            tprint("Unknown node type!");
+            break;
     }
 }
 
-@ Here are some simple routines used in the display of noads.
+/*tex Here are some simple routines used in the display of noads. */
 
-@c
 static void print_fam_and_char(pointer p)
-{                               /* prints family and character */
+{
     tprint_esc("fam");
     print_int(math_fam(p));
     print_char(' ');
     print(math_character(p));
 }
 
-@ @c
 static void print_delimiter(pointer p)
 {
     int a;
@@ -598,36 +612,38 @@ static void print_delimiter(pointer p)
         tprint(" ");
     }
     if (small_fam(p) < 0) {
-        print_int(-1);          /* this should never happen */
-    } else if (small_fam(p) < 16 && large_fam(p) < 16 &&
-               small_char(p) < 256 && large_char(p) < 256) {
-        /* traditional tex style */
+        /*tex This should never happen. */
+        print_int(-1);
+    } else if (small_fam(p) < 16 && large_fam(p) < 16 && small_char(p) < 256 && large_char(p) < 256) {
+        /*tex Traditional tex style. */
         a = small_fam(p) * 256 + small_char(p);
         a = a * 0x1000 + large_fam(p) * 256 + large_char(p);
-        print_hex(a);
-    } else if ((large_fam(p) == 0 && large_char(p) == 0) ||
-               small_char(p) > 65535 || large_char(p) > 65535) {
-        /* modern xetex/luatex style */
-        print_hex(small_fam(p));
-        print_hex(small_char(p));
+        print_qhex(a);
+    } else if ((large_fam(p) == 0 && large_char(p) == 0) || small_char(p) > 65535 || large_char(p) > 65535) {
+        /*tex \LUATEX\ style. */
+        print_qhex(small_fam(p));
+        print_qhex(small_char(p));
     }
 }
 
-@ The next subroutine will descend to another level of recursion when a
-subsidiary mlist needs to be displayed. The parameter |c| indicates what
-character is to become part of the recursion history. An empty mlist is
-distinguished from a missing field, because these are not equivalent
-(as explained above).
-@^recursion@>
+/*tex
+
+    The next subroutine will descend to another level of recursion when a
+    subsidiary mlist needs to be displayed. The parameter |c| indicates what
+    character is to become part of the recursion history. An empty mlist is
+    distinguished from a missing field, because these are not equivalent (as
+    explained above).
+
+*/
 
-@c
 static void print_subsidiary_data(pointer p, ASCII_code c)
-{                               /* display a noad field */
+{
     if ((int) cur_length >= depth_threshold) {
         if (p != null)
             tprint(" []");
     } else {
-        append_char(c);         /* include |c| in the recursion history */
+        /*tex Include |c| in the recursion history. */
+        append_char(c);
         if (p != null) {
             switch (type(p)) {
             case math_char_node:
@@ -649,58 +665,58 @@ static void print_subsidiary_data(pointer p, ASCII_code c)
                 break;
             }
         }
-        flush_char();           /* remove |c| from the recursion history */
+        /*tex Remove |c| from the recursion history. */
+        flush_char();
     }
 }
 
-@ @c
 void display_normal_noad(pointer p)
 {
     switch (type(p)) {
     case simple_noad:
         switch (subtype(p)) {
-        case ord_noad_type:
-            tprint_esc("mathord");
-            break;
-        case op_noad_type_normal:
-        case op_noad_type_limits:
-        case op_noad_type_no_limits:
-            tprint_esc("mathop");
-            if (subtype(p) == op_noad_type_limits)
-                tprint_esc("limits");
-            else if (subtype(p) == op_noad_type_no_limits)
-                tprint_esc("nolimits");
-            break;
-        case bin_noad_type:
-            tprint_esc("mathbin");
-            break;
-        case rel_noad_type:
-            tprint_esc("mathrel");
-            break;
-        case open_noad_type:
-            tprint_esc("mathopen");
-            break;
-        case close_noad_type:
-            tprint_esc("mathclose");
-            break;
-        case punct_noad_type:
-            tprint_esc("mathpunct");
-            break;
-        case inner_noad_type:
-            tprint_esc("mathinner");
-            break;
-        case over_noad_type:
-            tprint_esc("overline");
-            break;
-        case under_noad_type:
-            tprint_esc("underline");
-            break;
-        case vcenter_noad_type:
-            tprint_esc("vcenter");
-            break;
-        default:
-            tprint("<unknown noad type!>");
-            break;
+            case ord_noad_type:
+                tprint_esc("mathord");
+                break;
+            case op_noad_type_normal:
+            case op_noad_type_limits:
+            case op_noad_type_no_limits:
+                tprint_esc("mathop");
+                if (subtype(p) == op_noad_type_limits)
+                    tprint_esc("limits");
+                else if (subtype(p) == op_noad_type_no_limits)
+                    tprint_esc("nolimits");
+                break;
+            case bin_noad_type:
+                tprint_esc("mathbin");
+                break;
+            case rel_noad_type:
+                tprint_esc("mathrel");
+                break;
+            case open_noad_type:
+                tprint_esc("mathopen");
+                break;
+            case close_noad_type:
+                tprint_esc("mathclose");
+                break;
+            case punct_noad_type:
+                tprint_esc("mathpunct");
+                break;
+            case inner_noad_type:
+                tprint_esc("mathinner");
+                break;
+            case over_noad_type:
+                tprint_esc("overline");
+                break;
+            case under_noad_type:
+                tprint_esc("underline");
+                break;
+            case vcenter_noad_type:
+                tprint_esc("vcenter");
+                break;
+            default:
+                tprint("<unknown noad type!>");
+                break;
         }
         break;
     case radical_noad:
@@ -810,7 +826,6 @@ void display_normal_noad(pointer p)
     print_subsidiary_data(subscr(p), '_');
 }
 
-@ @c
 void display_fence_noad(pointer p)
 {
     if (subtype(p) == right_noad_side)
@@ -822,7 +837,6 @@ void display_fence_noad(pointer p)
     print_delimiter(delimiter(p));
 }
 
-@ @c
 void display_fraction_noad(pointer p)
 {
     tprint_esc("fraction, thickness ");
@@ -831,18 +845,14 @@ void display_fraction_noad(pointer p)
     else
         print_scaled(thickness(p));
     if ((left_delimiter(p) != null) &&
-        ((small_fam(left_delimiter(p)) != 0) ||
-         (small_char(left_delimiter(p)) != 0) ||
-         (large_fam(left_delimiter(p)) != 0) ||
-         (large_char(left_delimiter(p)) != 0))) {
+        ((small_fam(left_delimiter(p)) != 0) || (small_char(left_delimiter(p)) != 0) ||
+         (large_fam(left_delimiter(p)) != 0) || (large_char(left_delimiter(p)) != 0))) {
         tprint(", left-delimiter ");
         print_delimiter(left_delimiter(p));
     }
     if ((right_delimiter(p) != null) &&
-        ((small_fam(right_delimiter(p)) != 0) ||
-         (small_char(right_delimiter(p)) != 0) ||
-         (large_fam(right_delimiter(p)) != 0) ||
-         (large_char(right_delimiter(p)) != 0))) {
+        ((small_fam(right_delimiter(p)) != 0) || (small_char(right_delimiter(p)) != 0) ||
+         (large_fam(right_delimiter(p)) != 0) || (large_char(right_delimiter(p)) != 0))) {
         tprint(", right-delimiter ");
         print_delimiter(right_delimiter(p));
     }
@@ -850,16 +860,19 @@ void display_fraction_noad(pointer p)
     print_subsidiary_data(denominator(p), '/');
 }
 
-@ The routines that \TeX\ uses to create mlists are similar to those we have
-just seen for the generation of hlists and vlists. But it is necessary to
-make ``noads'' as well as nodes, so the reader should review the
-discussion of math mode data structures before trying to make sense out of
-the following program.
+/*tex
+
+    The routines that \TeX\ uses to create mlists are similar to those we have
+    just seen for the generation of hlists and vlists. But it is necessary to
+    make ``noads'' as well as nodes, so the reader should review the discussion
+    of math mode data structures before trying to make sense out of the following
+    program.
 
-Here is a little routine that needs to be done whenever a subformula
-is about to be processed. The parameter is a code like |math_group|.
+    Here is a little routine that needs to be done whenever a subformula is about
+    to be processed. The parameter is a code like |math_group|.
+
+*/
 
-@c
 static void new_save_level_math(group_code c)
 {
     set_saved_record(0, saved_textdir, 0, text_dir_ptr);
@@ -871,7 +884,6 @@ static void new_save_level_math(group_code c)
     eq_word_define(int_base + text_direction_code, math_direction_par);
 }
 
-@ @c
 static void push_math(group_code c, int mstyle)
 {
     if (math_direction_par != text_direction_par)
@@ -883,7 +895,6 @@ static void push_math(group_code c, int mstyle)
     new_save_level_math(c);
 }
 
-@ @c
 static void enter_ordinary_math(void)
 {
     push_math(math_shift_group, text_style);
@@ -892,19 +903,21 @@ static void enter_ordinary_math(void)
         begin_token_list(every_math_par, every_math_text);
 }
 
-@ @c
 void enter_display_math(void);
 
-@ We get into math mode from horizontal mode when a `\.\$' (i.e., a
-|math_shift| character) is scanned. We must check to see whether this
-`\.\$' is immediately followed by another, in case display math mode is
-called for.
+/*tex
+
+    We get into math mode from horizontal mode when a `\.\$' (i.e., a
+    |math_shift| character) is scanned. We must check to see whether this `\.\$'
+    is immediately followed by another, in case display math mode is called for.
+
+*/
 
-@c
 void init_math(void)
 {
     if (cur_cmd == math_shift_cmd) {
-        get_token();            /* |get_x_token| would fail on \.{\\ifmmode}\thinspace! */
+        /*tex |get_x_token| would fail on \.{\\ifmmode}\thinspace! */
+        get_token();
         if ((cur_cmd == math_shift_cmd) && (mode > 0)) {
             enter_display_math();
         } else {
@@ -920,15 +933,17 @@ void init_math(void)
     }
 }
 
-@ We get into ordinary math mode from display math mode when `\.{\\eqno}' or
-`\.{\\leqno}' appears. In such cases |cur_chr| will be 0 or~1, respectively;
-the value of |cur_chr| is placed onto |save_stack| for safe keeping.
+/*tex
 
-@ When \TeX\ is in display math mode, |cur_group=math_shift_group|,
-so it is not necessary for the |start_eq_no| procedure to test for
-this condition.
+    We get into ordinary math mode from display math mode when `\.{\\eqno}' or
+    `\.{\\leqno}' appears. In such cases |cur_chr| will be 0 or~1, respectively;
+    the value of |cur_chr| is placed onto |save_stack| for safe keeping.
+
+    When \TeX\ is in display math mode, |cur_group=math_shift_group|, so it is
+    not necessary for the |start_eq_no| procedure to test for this condition.
+
+*/
 
-@c
 void start_eq_no(void)
 {
     set_saved_record(0, saved_eqno, 0, cur_chr);
@@ -936,21 +951,24 @@ void start_eq_no(void)
     enter_ordinary_math();
 }
 
-@ Subformulas of math formulas cause a new level of math mode to be entered,
-on the semantic nest as well as the save stack. These subformulas arise in
-several ways: (1)~A left brace by itself indicates the beginning of a
-subformula that will be put into a box, thereby freezing its glue and
-preventing line breaks. (2)~A subscript or superscript is treated as a
-subformula if it is not a single character; the same applies to
-the nucleus of things like \.{\\underline}. (3)~The \.{\\left} primitive
-initiates a subformula that will be terminated by a matching \.{\\right}.
-The group codes placed on |save_stack| in these three cases are
-|math_group|, |math_group|, and |math_left_group|, respectively.
+/*tex
+
+    Subformulas of math formulas cause a new level of math mode to be entered, on
+    the semantic nest as well as the save stack. These subformulas arise in
+    several ways: (1)~A left brace by itself indicates the beginning of a
+    subformula that will be put into a box, thereby freezing its glue and
+    preventing line breaks. (2)~A subscript or superscript is treated as a
+    subformula if it is not a single character; the same applies to the nucleus
+    of things like \.{\\underline}. (3)~The \.{\\left} primitive initiates a
+    subformula that will be terminated by a matching \.{\\right}. The group codes
+    placed on |save_stack| in these three cases are |math_group|, |math_group|,
+    and |math_left_group|, respectively.
 
-Here is the code that handles case (1); the other cases are not quite as
-trivial, so we shall consider them later.
+    Here is the code that handles case (1); the other cases are not quite as
+    trivial, so we shall consider them later.
+
+*/
 
-@c
 void math_left_brace(void)
 {
     pointer q;
@@ -961,18 +979,20 @@ void math_left_brace(void)
     (void) scan_math(nucleus(tail), m_style);
 }
 
-@ If the inline directions of \.{\\pardir} and \.{\\mathdir} are
-opposite, then this function will return true. Discovering that fact
-is somewhat odd because it needs traversal of the |save_stack|.
-The occurance of displayed equations is weird enough that this is
-probably still better than having yet another field in the |input_stack|
-structures.
+/*tex
+
+    If the inline directions of \.{\\pardir} and \.{\\mathdir} are opposite, then
+    this function will return true. Discovering that fact is somewhat odd because
+    it needs traversal of the |save_stack|. The occurance of displayed equations
+    is weird enough that this is probably still better than having yet another
+    field in the |input_stack| structures.
 
-None of this makes much sense if the inline direction of either one of
-\.{\\pardir} or \.{\\mathdir} is vertical, but in that case the current
-math machinery is ill suited anyway so I do not bother to test that.
+    None of this makes much sense if the inline direction of either one of
+    \.{\\pardir} or \.{\\mathdir} is vertical, but in that case the current math
+    machinery is ill suited anyway so I do not bother to test that.
+
+*/
 
-@c
 static boolean math_and_text_reversed_p(void)
 {
     int i = save_ptr - 1;
@@ -989,26 +1009,43 @@ static boolean math_and_text_reversed_p(void)
     return false;
 }
 
-@ When we enter display math mode, we need to call |line_break| to
-process the partial paragraph that has just been interrupted by the
-display. Then we can set the proper values of |display_width| and
-|display_indent| and |pre_display_size|.
+/*tex
+
+    When we enter display math mode, we need to call |line_break| to process the
+    partial paragraph that has just been interrupted by the display. Then we can
+    set the proper values of |display_width| and |display_indent| and
+    |pre_display_size|.
+
+*/
 
-@c
 void enter_display_math(void)
 {
-    scaled w;                   /* new or partial |pre_display_size| */
-    scaled l;                   /* new |display_width| */
-    scaled s;                   /* new |display_indent| */
+    /*tex new or partial |pre_display_size| */
+    scaled w;
+    /*tex new |display_width| */
+    scaled l;
+    /*tex new |display_indent| */
+    scaled s;
     pointer p;
-    int n;                      /* scope of paragraph shape specification */
-    if (head == tail ||         /* `\.{\\noindent\$\$}' or `\.{\$\${ }\$\$}' */
-        (vlink(head) == tail && /* the 2nd of \.{\$\${ }\$\$} \.{\$\${ }\$\$} */
+    /*tex scope of paragraph shape specification */
+    int n;
+    /*tex
+
+        `\.{\\noindent\$\$}' or `\.{\$\${ }\$\$}' or the 2nd of \.{\$\${ }\$\$}
+        \.{\$\${ }\$\$}
+
+    */
+    if (head == tail ||
+        (vlink(head) == tail &&
          type(tail) == local_par_node && vlink(tail) == null)) {
         if (vlink(head) == tail) {
-            /* bug \#270: |resume_after_display| inserts a |local_par_node|, but if
-               there is another display immediately following, we have to get rid
-               of that node */
+            /*tex
+
+                |resume_after_display| inserts a |local_par_node|, but if there
+                is another display immediately following, we have to get rid of
+                that node.
+
+            */
             flush_node(tail);
         }
         pop_nest();
@@ -1017,9 +1054,13 @@ void enter_display_math(void)
         line_break(true, math_shift_group);
         w = actual_box_width(just_box, x_over_n(quad(get_cur_font()),1000) * math_pre_display_gap_factor_par);
     }
-    /* now we are in vertical mode, working on the list that will contain the display */
-    /* A displayed equation is considered to be three lines long, so we
-       calculate the length and offset of line number |prev_graf+2|. */
+    /*tex
+
+        Now we are in vertical mode, working on the list that will contain the
+        display. A displayed equation is considered to be three lines long, so we
+        calculate the length and offset of line number |prev_graf+2|.
+
+    */
     if (par_shape_par_ptr == null) {
         if ((hang_indent_par != 0) && (((hang_after_par >= 0) && (prev_graf_par + 2 > hang_after_par)) || (prev_graf_par + 1 < -hang_after_par))) {
             halfword used_hang_indent = swap_hang_indent(hang_indent_par);
@@ -1042,7 +1083,6 @@ void enter_display_math(void)
         l = varmem[p].cint;
         s = swap_parshape_indent(s,l);
     }
-
     push_math(math_shift_group, display_style);
     mode = mmode;
     eq_word_define(int_base + cur_fam_code, -1);
@@ -1058,12 +1098,15 @@ void enter_display_math(void)
     }
 }
 
-@ The next routine parses all variations of a delimiter code. The |extcode|
- tells what syntax form to use (\TeX, XeTeX, XeTeXnum, ...) , the
- |doclass| tells whether or not read a math class also (for \.{\\delimiter} c.s.).
- (the class is passed on for conversion to \.{\\mathchar}).
+/*tex
+
+    The next routine parses all variations of a delimiter code. The |extcode|
+    tells what syntax form to use (\TeX, XeTeX, XeTeXnum, ...) , the |doclass|
+    tells whether or not read a math class also (for \.{\\delimiter} c.s.). (the
+    class is passed on for conversion to \.{\\mathchar}).
+
+*/
 
-@c
 static delcodeval do_scan_extdef_del_code(int extcode, boolean doclass)
 {
     const char *hlp[] = {
@@ -1072,9 +1115,14 @@ static delcodeval do_scan_extdef_del_code(int extcode, boolean doclass)
     };
     delcodeval d;
     int mcls = 0, msfam = 0, mschr = 0, mlfam = 0, mlchr = 0;
-    if (extcode == tex_mathcode) {      /* \.{\\delcode}, this is the easiest */
+    if (extcode == tex_mathcode) {
+        /*tex
+
+            \.{\\delcode}, this is the easiest
+
+        */
         scan_int();
-        /*  "MFCCFCC or "FCCFCC */
+        /*tex  "MFCCFCC or "FCCFCC */
         if (doclass) {
             mcls = (cur_val / 0x1000000);
             cur_val = (cur_val & 0xFFFFFF);
@@ -1087,8 +1135,12 @@ static delcodeval do_scan_extdef_del_code(int extcode, boolean doclass)
         mschr = (cur_val % 0x100000) / 0x1000;
         mlfam = (cur_val & 0xFFF) / 0x100;
         mlchr = (cur_val % 0x100);
-    } else if (extcode == umath_mathcode) {     /* \.{\\Udelcode} */
-        /* <0-7>,<0-0xFF>,<0-0x10FFFF>  or <0-0xFF>,<0-0x10FFFF> */
+    } else if (extcode == umath_mathcode) {
+        /*tex
+
+            \.{\\Udelcode}: <0-7>,<0-0xFF>,<0-0x10FFFF>  or <0-0xFF>,<0-0x10FFFF>
+
+        */
         if (doclass) {
             scan_int();
             mcls = cur_val;
@@ -1104,11 +1156,13 @@ static delcodeval do_scan_extdef_del_code(int extcode, boolean doclass)
         }
         mlfam = 0;
         mlchr = 0;
-    } else if (extcode == umathnum_mathcode) {  /* \.{\\Udelcodenum} */
-        /* "FF<21bits> */
-        /* the largest numeric value is $2^29-1$, but
-           the top of bit 21 can't be used as it contains invalid USV's
-         */
+    } else if (extcode == umathnum_mathcode) {
+        /*tex
+
+           \.{\\Udelcodenum}:"FF<21bits>; the largest numeric value is $2^29-1$,
+           but the top of bit 21 can't be used as it contains invalid USV's.
+
+        */
         if (doclass) {          /* such a primitive doesn't exist */
             confusion("umathnum_mathcode");
         }
@@ -1123,7 +1177,7 @@ static delcodeval do_scan_extdef_del_code(int extcode, boolean doclass)
         mlfam = 0;
         mlchr = 0;
     } else {
-        /* something's gone wrong */
+        /*tex Something's gone wrong! */
         confusion("unknown_extcode");
     }
     d.class_value = mcls;
@@ -1134,7 +1188,6 @@ static delcodeval do_scan_extdef_del_code(int extcode, boolean doclass)
     return d;
 }
 
-@ @c
 void scan_extdef_del_code(int level, int extcode)
 {
     delcodeval d;
@@ -1144,11 +1197,9 @@ void scan_extdef_del_code(int level, int extcode)
     scan_optional_equals();
     d = do_scan_extdef_del_code(extcode, false);
     set_del_code(p, d.small_family_value, d.small_character_value,
-                 d.large_family_value, d.large_character_value,
-                 (quarterword) (level));
+        d.large_family_value, d.large_character_value, (quarterword) (level));
 }
 
-@ @c
 mathcodeval scan_mathchar(int extcode)
 {
     char errstr[255] = { 0 };
@@ -1158,15 +1209,11 @@ mathcodeval scan_mathchar(int extcode)
     };
     mathcodeval d;
     int mcls = 0, mfam = 0, mchr = 0;
-    if (extcode == tex_mathcode) {      /* \.{\\mathcode} */
-        /* "TFCC */
+    if (extcode == tex_mathcode) {
+        /*tex \.{\\mathcode}: "TFCC */
         scan_int();
         if (cur_val > 0x8000) {
-            /*
-                tex_error("Invalid math code", hlp);
-                cur_val = 0;
-            */
-            /* needed for latex: fallback to umathnum_mathcode */
+            /*tex Needed for latex: fallback to umathnum_mathcode. */
             mfam = (cur_val / 0x200000) & 0x7FF;
             mcls = mfam % 0x08;
             mfam = mfam / 0x08;
@@ -1188,7 +1235,7 @@ mathcodeval scan_mathchar(int extcode)
             mchr = (cur_val % 0x100);
         }
     } else if (extcode == umath_mathcode) {
-        /* <0-0x7> <0-0xFF> <0-0x10FFFF> */
+        /*tex <0-0x7> <0-0xFF> <0-0x10FFFF> */
         scan_int();
         mcls = cur_val;
         scan_int();
@@ -1202,11 +1249,14 @@ mathcodeval scan_mathchar(int extcode)
             mcls = 0;
         }
     } else if (extcode == umathnum_mathcode) {
-        /* "FFT<21bits> */
-        /* the largest numeric value is $2^32-1$, but
-           the top of bit 21 can't be used as it contains invalid USV's
-         */
-        /* Note: |scan_int| won't accept families 128-255 because these use bit 32 */
+        /*tex
+
+            "FFT<21bits>: the largest numeric value is $2^32-1$, but the top of
+            bit 21 can't be used as it contains invalid USV's
+
+            Note: |scan_int| won't accept families 128-255 because these use bit 32
+
+        */
         scan_int();
         mfam = (cur_val / 0x200000) & 0x7FF;
         mcls = mfam % 0x08;
@@ -1219,7 +1269,7 @@ mathcodeval scan_mathchar(int extcode)
             mchr = 0;
         }
     } else {
-        /* something's gone wrong */
+        /*tex Something's gone wrong. */
         confusion("unknown_extcode");
     }
     d.class_value = mcls;
@@ -1228,7 +1278,6 @@ mathcodeval scan_mathchar(int extcode)
     return d;
 }
 
-@ @c
 void scan_extdef_math_code(int level, int extcode)
 {
     mathcodeval d;
@@ -1237,12 +1286,11 @@ void scan_extdef_math_code(int level, int extcode)
     p = cur_val;
     scan_optional_equals();
     d = scan_mathchar(extcode);
-    set_math_code(p, d.class_value,
-                  d.family_value, d.character_value, (quarterword) (level));
+    set_math_code(p, d.class_value, d.family_value, d.character_value, (quarterword) (level));
 }
 
-@ this reads in a delcode when actually a mathcode is needed
-@c
+/*tex This reads in a delcode when actually a mathcode is needed. */
+
 mathcodeval scan_delimiter_as_mathchar(int extcode)
 {
     delcodeval dval;
@@ -1254,14 +1302,17 @@ mathcodeval scan_delimiter_as_mathchar(int extcode)
     return mval;
 }
 
-@ Recall that the |nucleus|, |subscr|, and |supscr| fields in a noad
-are broken down into subfields called |type| and either |math_list| or
-|(math_fam,math_character)|. The job of |scan_math| is to figure out
-what to place in one of these principal fields; it looks at the
-subformula that comes next in the input, and places an encoding of
-that subformula into a given word of |mem|.
+/*tex
+
+    Recall that the |nucleus|, |subscr|, and |supscr| fields in a noad are broken
+    down into subfields called |type| and either |math_list| or
+    |(math_fam,math_character)|. The job of |scan_math| is to figure out what to
+    place in one of these principal fields; it looks at the subformula that comes
+    next in the input, and places an encoding of that subformula into a given
+    word of |mem|.
+
+*/
 
-@c
 #define get_next_nb_nr() do { get_x_token(); } while (cur_cmd==spacer_cmd||cur_cmd==relax_cmd)
 
 int scan_math_style(pointer p, int mstyle)
@@ -1277,7 +1328,6 @@ int scan_math_style(pointer p, int mstyle)
 
 int scan_math(pointer p, int mstyle)
 {
-    /* label restart,reswitch,exit; */
     mathcodeval mval = { 0, 0, 0 };
     assert(p != null);
   RESTART:
@@ -1289,7 +1339,7 @@ int scan_math(pointer p, int mstyle)
     case char_given_cmd:
         mval = get_math_code(cur_chr);
         if (mval.class_value == 8) {
-            /* An active character that is an |outer_call| is allowed here */
+            /*tex An active character that is an |outer_call| is allowed here. */
             cur_cs = active_to_cs(cur_chr, true);
             cur_cmd = eq_type(cur_cs);
             cur_chr = equiv(cur_cs);
@@ -1329,8 +1379,12 @@ int scan_math(pointer p, int mstyle)
             confusion("scan_math");
         break;
     default:
-        /* The pointer |p| is placed on |save_stack| while a complex subformula
-           is being scanned. */
+        /*tex
+
+            The pointer |p| is placed on |save_stack| while a complex subformula
+            is being scanned.
+
+        */
         back_input();
         scan_left_brace();
         set_saved_record(0, saved_math, 0, p);
@@ -1347,12 +1401,15 @@ int scan_math(pointer p, int mstyle)
     return 0;
 }
 
-@ The |set_math_char| procedure creates a new noad appropriate to a given
-math code, and appends it to the current mlist. However, if the math code
-is sufficiently large, the |cur_chr| is treated as an active character and
-nothing is appended.
+/*tex
+
+    The |set_math_char| procedure creates a new noad appropriate to a given math
+    code, and appends it to the current mlist. However, if the math code is
+    sufficiently large, the |cur_chr| is treated as an active character and
+    nothing is appended.
+
+*/
 
-@c
 #define math_class_to_type(target,source) \
     switch (source) { \
         case 0: target = ord_noad_type; break; \
@@ -1366,9 +1423,9 @@ nothing is appended.
 
 void set_math_char(mathcodeval mval)
 {
-    pointer p;                  /* the new noad */
+    pointer p;
     if (mval.class_value == 8) {
-        /* An active character that is an |outer_call| is allowed here */
+        /*tex An active character that is an |outer_call| is allowed here */
         cur_cs = active_to_cs(cur_chr, true);
         cur_cmd = eq_type(cur_cs);
         cur_chr = equiv(cur_cs);
@@ -1393,17 +1450,20 @@ void set_math_char(mathcodeval mval)
     }
 }
 
-@ The |math_char_in_text| procedure creates a new node representing a math char
-in text code, and appends it to the current list. However, if the math code
-is sufficiently large, the |cur_chr| is treated as an active character and
-nothing is appended.
+/*tex
+
+    The |math_char_in_text| procedure creates a new node representing a math char
+    in text code, and appends it to the current list. However, if the math code
+    is sufficiently large, the |cur_chr| is treated as an active character and
+    nothing is appended.
+
+*/
 
-@c
 void math_char_in_text(mathcodeval mval)
 {
-    pointer p;                  /* the new node */
+    pointer p;
     if (mval.class_value == 8) {
-        /* An active character that is an |outer_call| is allowed here */
+        /*tex An active character that is an |outer_call| is allowed here */
         cur_cs = active_to_cs(cur_chr, true);
         cur_cmd = eq_type(cur_cs);
         cur_chr = equiv(cur_cs);
@@ -1416,7 +1476,6 @@ void math_char_in_text(mathcodeval mval)
     }
 }
 
-@ @c
 void math_math_comp(void)
 {
     pointer q;
@@ -1430,7 +1489,6 @@ void math_math_comp(void)
         (void) scan_math(nucleus(tail), m_style);
 }
 
-@ @c
 void math_limit_switch(void)
 {
     const char *hlp[] = {
@@ -1449,18 +1507,23 @@ void math_limit_switch(void)
     tex_error("Limit controls must follow a math operator", hlp);
 }
 
-@ Delimiter fields of noads are filled in by the |scan_delimiter| routine.
-The first parameter of this procedure is the |mem| address where the
-delimiter is to be placed; the second tells if this delimiter follows
-\.{\\radical} or not.
+/*tex
+
+     Delimiter fields of noads are filled in by the |scan_delimiter| routine. The
+     first parameter of this procedure is the |mem| address where the delimiter
+     is to be placed; the second tells if this delimiter follows \.{\\radical} or
+     not.
+
+*/
 
-@c
 static void scan_delimiter(pointer p, int r)
 {
     delcodeval dval = { 0, 0, 0, 0, 0 };
-    if (r == tex_mathcode) {    /* \.{\\radical} */
+    if (r == tex_mathcode) {
+        /*tex \.{\\radical} */
         dval = do_scan_extdef_del_code(tex_mathcode, true);
-    } else if (r == umath_mathcode) {   /* \.{\\Uradical} */
+    } else if (r == umath_mathcode) {
+        /*tex \.{\\Uradical} */
         dval = do_scan_extdef_del_code(umath_mathcode, false);
     } else if (r == no_mathcode) {
         get_next_nb_nr();
@@ -1470,12 +1533,15 @@ static void scan_delimiter(pointer p, int r)
             dval = get_del_code(cur_chr);
             break;
         case delim_num_cmd:
-            if (cur_chr == 0)   /* \.{\\delimiter} */
+            if (cur_chr == 0) {
+                /*tex \.{\\delimiter} */
                 dval = do_scan_extdef_del_code(tex_mathcode, true);
-            else if (cur_chr == 1)      /* \.{\\Udelimiter} */
+            } else if (cur_chr == 1) {
+                /*tex \.{\\Udelimiter} */
                 dval = do_scan_extdef_del_code(umath_mathcode, true);
-            else
+            } else {
                 confusion("scan_delimiter1");
+            }
             break;
         default:
             dval.small_family_value = -1;
@@ -1510,7 +1576,6 @@ static void scan_delimiter(pointer p, int r)
     return;
 }
 
-@ @c
 void math_radical(void)
 {
     halfword q;
@@ -1534,31 +1599,44 @@ void math_radical(void)
         }
     }
     radicaloptions(tail) = options;
-    if (chr_code == 0)          /* \.{\\radical} */
+    if (chr_code == 0)
+        /*tex \.{\\radical} */
         scan_delimiter(left_delimiter(tail), tex_mathcode);
-    else if (chr_code == 1)     /* \.{\\Uradical} */
+    else if (chr_code == 1)
+        /*tex \.{\\Uradical} */
         scan_delimiter(left_delimiter(tail), umath_mathcode);
-    else if (chr_code == 2)     /* \.{\\Uroot} */
+    else if (chr_code == 2)
+        /*tex \.{\\Uroot} */
         scan_delimiter(left_delimiter(tail), umath_mathcode);
-    else if (chr_code == 3)     /* \.{\\Uunderdelimiter} */
+    else if (chr_code == 3)
+        /*tex \.{\\Uunderdelimiter} */
         scan_delimiter(left_delimiter(tail), umath_mathcode);
-    else if (chr_code == 4)     /* \.{\\Uoverdelimiter} */
+    else if (chr_code == 4)
+        /*tex \.{\\Uoverdelimiter} */
         scan_delimiter(left_delimiter(tail), umath_mathcode);
-    else if (chr_code == 5)     /* \.{\\Udelimiterunder} */
+    else if (chr_code == 5)
+        /*tex \.{\\Udelimiterunder} */
         scan_delimiter(left_delimiter(tail), umath_mathcode);
-    else if (chr_code == 6)     /* \.{\\Udelimiterover} */
+    else if (chr_code == 6)
+        /*tex \.{\\Udelimiterover} */
         scan_delimiter(left_delimiter(tail), umath_mathcode);
-    else if (chr_code == 7)     /* \.{\\Uhextensible} */
+    else if (chr_code == 7)
+        /*tex \.{\\Uhextensible} */
         scan_delimiter(left_delimiter(tail), umath_mathcode);
     else
         confusion("math_radical");
     if (chr_code == 7) {
-        q = new_node(sub_box_node, 0); /* type will change */
+        /*tex type will change */
+        q = new_node(sub_box_node, 0);
         nucleus(tail) = q;
         return;
     } else if (chr_code == 2) {
-        /* the trick with the |vlink(q)| is used by |scan_math|
-           to decide whether it needs to go on */
+        /*tex
+
+            The trick with the |vlink(q)| is used by |scan_math| to decide
+            whether it needs to go on.
+
+        */
         q = new_node(math_char_node, 0);
         vlink(q) = tail;
         degree(tail) = q;
@@ -1575,7 +1653,6 @@ void math_radical(void)
     }
 }
 
-@ @c
 void math_ac(void)
 {
     halfword q;
@@ -1591,15 +1668,17 @@ void math_ac(void)
         tex_error("Please use \\mathaccent for accents in math mode", hlp);
     }
     tail_append(new_node(accent_noad, 0));
-    if (cur_chr == 0) {         /* \.{\\mathaccent} */
+    if (cur_chr == 0) {
+        /*tex \.{\\mathaccent} */
         t = scan_mathchar(tex_mathcode);
-    } else if (cur_chr == 1) {  /* \.{\\Umathaccent} */
+    } else if (cur_chr == 1) {
+        /*tex \.{\\Umathaccent} */
         if (scan_keyword("fixed")) {
-            /* top */
+            /*tex top */
             subtype(tail) = 1;
             t = scan_mathchar(umath_mathcode);
         } else if (scan_keyword("both")) {
-            /* top bottom */
+            /*tex top bottom */
             if (scan_keyword("fixed")) {
                 subtype(tail) = 1;
             }
@@ -1609,13 +1688,13 @@ void math_ac(void)
             }
             b = scan_mathchar(umath_mathcode);
         } else if (scan_keyword("bottom")) {
-            /* bottom */
+            /*tex bottom */
             if (scan_keyword("fixed")) {
                 subtype(tail) = 2;
             }
             b = scan_mathchar(umath_mathcode);
         } else if (scan_keyword("top")) {
-            /* top */
+            /*tex top */
             if (scan_keyword("fixed")) {
                 subtype(tail) = 1;
             }
@@ -1627,7 +1706,7 @@ void math_ac(void)
             }
             o = scan_mathchar(umath_mathcode);
         } else {
-            /* top */
+            /*tex top */
             t = scan_mathchar(umath_mathcode);
         }
         if (scan_keyword("fraction")) {
@@ -1669,7 +1748,6 @@ void math_ac(void)
     (void) scan_math(nucleus(tail), cramped_style(m_style));
 }
 
-@ @c
 pointer math_vcenter_group(pointer p)
 {
     pointer q, r;
@@ -1681,10 +1759,13 @@ pointer math_vcenter_group(pointer p)
     return q;
 }
 
-@ The routine that scans the four mlists of a \.{\\mathchoice} is very
-much like the routine that builds discretionary nodes.
+/*tex
+
+    The routine that scans the four mlists of a \.{\\mathchoice} is very much
+    like the routine that builds discretionary nodes.
+
+*/
 
-@c
 void append_choices(void)
 {
     tail_append(new_choice());
@@ -1694,10 +1775,9 @@ void append_choices(void)
     scan_left_brace();
 }
 
-@ @c
 void build_choices(void)
 {
-    pointer p;                  /* the current mlist */
+    pointer p;
     int prev_style;
     prev_style = m_style;
     unsave_math();
@@ -1718,16 +1798,19 @@ void build_choices(void)
         decr(save_ptr);
         return;
         break;
-    }                           /* there are no other cases */
+    }
     set_saved_record(-1, saved_choices, 0, (saved_value(-1) + 1));
     push_math(math_choice_group, (prev_style + 2));
     scan_left_brace();
 }
 
-@ Subscripts and superscripts are attached to the previous nucleus by the
-action procedure called |sub_sup|.
+/*tex
+
+    Subscripts and superscripts are attached to the previous nucleus by the
+    action procedure called |sub_sup|.
+
+*/
 
-@c
 static void do_sub_sup(int no)
 {
     pointer q;
@@ -1736,7 +1819,8 @@ static void do_sub_sup(int no)
         q = new_node(sub_mlist_node, 0);
         nucleus(tail) = q;
     }
-    if (cur_cmd == sup_mark_cmd || cur_chr == sup_mark_cmd) {   /* |super_sub_script| */
+    if (cur_cmd == sup_mark_cmd || cur_chr == sup_mark_cmd) {
+        /*tex |super_sub_script| */
         if (supscr(tail) != null) {
             const char *hlp[] = {
                 "I treat `x^1^2' essentially like `x^1{}^2'.", NULL
@@ -1781,19 +1865,21 @@ void no_sub_sup(void)
     do_sub_sup(1);
 }
 
+/*tex
 
-@ An operation like `\.{\\over}' causes the current mlist to go into a
-state of suspended animation: |incompleat_noad| points to a |fraction_noad|
-that contains the mlist-so-far as its numerator, while the denominator
-is yet to come. Finally when the mlist is finished, the denominator will
-go into the incompleat fraction noad, and that noad will become the
-whole formula, unless it is surrounded by `\.{\\left}' and `\.{\\right}'
-delimiters.
+    An operation like `\.{\\over}' causes the current mlist to go into a state of
+    suspended animation: |incompleat_noad| points to a |fraction_noad| that
+    contains the mlist-so-far as its numerator, while the denominator is yet to
+    come. Finally when the mlist is finished, the denominator will go into the
+    incompleat fraction noad, and that noad will become the whole formula, unless
+    it is surrounded by `\.{\\left}' and `\.{\\right}' delimiters.
+
+*/
 
-@c
 void math_fraction(void)
 {
-    halfword c;                 /* the type of generalized fraction we are scanning */
+    /*tex The type of generalized fraction we are scanning: */
+    halfword c;
     pointer q;
     halfword options = 0;
     halfword temp_value;
@@ -1870,16 +1956,19 @@ void math_fraction(void)
     }
 }
 
-@ At the end of a math formula or subformula, the |fin_mlist| routine is
-called upon to return a pointer to the newly completed mlist, and to
-pop the nest back to the enclosing semantic level. The parameter to
-|fin_mlist|, if not null, points to a |fence_noad| that ends the
-current mlist; this |fence_noad| has not yet been appended.
+/*tex
+
+    At the end of a math formula or subformula, the |fin_mlist| routine is called
+    upon to return a pointer to the newly completed mlist, and to pop the nest
+    back to the enclosing semantic level. The parameter to |fin_mlist|, if not
+    null, points to a |fence_noad| that ends the current mlist; this |fence_noad|
+    has not yet been appended.
+
+*/
 
-@c
 pointer fin_mlist(pointer p)
 {
-    pointer q;                  /* the mlist to return */
+    pointer q;
     if (incompleat_noad_par != null) {
         if (denominator(incompleat_noad_par) != null) {
             type(denominator(incompleat_noad_par)) = sub_mlist_node;
@@ -1892,9 +1981,8 @@ pointer fin_mlist(pointer p)
             q = incompleat_noad_par;
         } else {
             q = math_list(numerator(incompleat_noad_par));
-            if ((type(q) != fence_noad) || (subtype(q) != left_noad_side)
-                || (delim_par == null))
-                confusion("right");     /* this can't happen */
+            if ((type(q) != fence_noad) || (subtype(q) != left_noad_side) || (delim_par == null))
+                confusion("right");
             math_list(numerator(incompleat_noad_par)) = vlink(delim_par);
             vlink(delim_par) = incompleat_noad_par;
             vlink(incompleat_noad_par) = p;
@@ -1907,26 +1995,50 @@ pointer fin_mlist(pointer p)
     return q;
 }
 
-@ Now at last we're ready to see what happens when a right brace occurs
-in a math formula. Two special cases are simplified here: Braces are effectively
-removed when they surround a single Ord without sub/superscripts, or when they
-surround an accent that is the nucleus of an Ord atom.
+/*tex
+
+    Now at last we're ready to see what happens when a right brace occurs in a
+    math formula. Two special cases are simplified here: Braces are effectively
+    removed when they surround a single Ord without sub/superscripts, or when
+    they surround an accent that is the nucleus of an Ord atom.
+
+*/
 
-@c
 void close_math_group(pointer p)
 {
     int old_style = m_style;
     unsave_math();
-
     decr(save_ptr);
     assert(saved_type(0) == saved_math);
     type(saved_value(0)) = sub_mlist_node;
     p = fin_mlist(null);
     math_list(saved_value(0)) = p;
-    if (p != null) {
-        if (vlink(p) == null) {
-            if (type(p) == simple_noad && subtype(p) == ord_noad_type) {
-                if (subscr(p) == null && supscr(p) == null) {
+    if (p != null && vlink(p) == null) {
+        if (type(p) == simple_noad) {
+            if (subscr(p) == null && supscr(p) == null) {
+                /*tex (subtype(p) == ord_noad_type) */
+                int flatten = 0;
+                int modepar = math_flatten_mode_par;
+                switch (subtype(p)) {
+                    case ord_noad_type :
+                        flatten = (modepar & 1) == 1;
+                        break;
+                    case bin_noad_type :
+                        flatten = (modepar & 2) == 2;
+                        break;
+                    case rel_noad_type :
+                        flatten = (modepar & 4) == 4;
+                        break;
+                    case punct_noad_type :
+                        flatten = (modepar & 8) == 8;
+                        break;
+                    case inner_noad_type :
+                        flatten = (modepar & 16) == 16;
+                        break;
+                    default:
+                        break;
+                }
+                if (flatten) {
                     type(saved_value(0)) = type(nucleus(p));
                     if (type(nucleus(p)) == math_char_node) {
                         math_fam(saved_value(0)) = math_fam(nucleus(p));
@@ -1941,24 +2053,21 @@ void close_math_group(pointer p)
                     node_attr(nucleus(p)) = null;
                     flush_node(p);
                 }
-            } else if (type(p) == accent_noad) {
-                if (saved_value(0) == nucleus(tail)) {
-                    if (type(tail) == simple_noad
-                        && subtype(tail) == ord_noad_type) {
-                        pointer q = head;
-                        while (vlink(q) != tail)
-                            q = vlink(q);
-                        vlink(q) = p;
-                        nucleus(tail) = null;
-                        subscr(tail) = null;
-                        supscr(tail) = null;
-                        delete_attribute_ref(node_attr(p));
-                        node_attr(p) = node_attr(tail);
-                        node_attr(tail) = null;
-                        flush_node(tail);
-                        tail = p;
-                    }
-                }
+            }
+        } else if (type(p) == accent_noad) {
+            if (saved_value(0) == nucleus(tail) && type(tail) == simple_noad  && subtype(tail) == ord_noad_type) {
+                pointer q = head;
+                while (vlink(q) != tail)
+                    q = vlink(q);
+                vlink(q) = p;
+                nucleus(tail) = null;
+                subscr(tail) = null;
+                supscr(tail) = null;
+                delete_attribute_ref(node_attr(p));
+                node_attr(p) = node_attr(tail);
+                node_attr(tail) = null;
+                flush_node(tail);
+                tail = p;
             }
         }
     }
@@ -1969,30 +2078,36 @@ void close_math_group(pointer p)
         vlink(saved_value(0)) = null;
         saved_value(0) = q;
         (void) scan_math(saved_value(0), old_style);
-        /* restart */
+        /*tex restart */
     }
 }
 
-@ We have dealt with all constructions of math mode except `\.{\\left}' and
-`\.{\\right}', so the picture is completed by the following sections of
-the program. The |middle| feature of eTeX allows one ore several \.{\\middle}
-delimiters to appear between \.{\\left} and \.{\\right}.
+/*tex
+
+    We have dealt with all constructions of math mode except `\.{\\left}' and
+    `\.{\\right}', so the picture is completed by the following sections of the
+    program. The |middle| feature of eTeX allows one ore several \.{\\middle}
+    delimiters to appear between \.{\\left} and \.{\\right}.
+
+*/
 
-@c
 void math_left_right(void)
 {
-    halfword t;      /* |left_noad_side| .. |right_noad_side| */
-    pointer p;       /* new noad */
-    pointer q;       /* resulting mlist */
-    pointer r;       /* temporary */
+    /*tex |left_noad_side| .. |right_noad_side| */
+    halfword t;
+    /*tex new noad */
+    pointer p;
+    /*tex resulting mlist */
+    pointer q;
+    /*tex temporary */
+    pointer r;
     halfword ht = 0;
     halfword dp = 0;
     halfword options = 0;
     halfword type = -1 ;
     t = cur_chr;
-
     if (t > 10) {
-        /* we have \Uleft \Uright \Umiddle */
+        /*tex we have \Uleft \Uright \Umiddle */
         t = t - 10;
         while (1) {
             if (scan_keyword("height")) {
@@ -2015,7 +2130,6 @@ void math_left_right(void)
             }
         }
     }
-
     if ((t != no_noad_side) && (t != left_noad_side) && (cur_group != math_left_group)) {
         if (cur_group == math_shift_group) {
             scan_delimiter(null, no_mathcode);
@@ -2041,14 +2155,12 @@ void math_left_right(void)
         subtype(p) = (quarterword) t;
         r = new_node(delim_node, 0);
         delimiter(p) = r;
-
         delimiterheight(p) = ht;
         delimiterdepth(p) = dp;
         delimiteroptions(p) = options;
         delimiterclass(p) = type;
         delimiteritalic(p) = 0;
         delimitersamesize(p) = 0;
-
         scan_delimiter(delimiter(p), no_mathcode);
         if (t == no_noad_side) {
             tail_append(new_noad());
@@ -2058,7 +2170,6 @@ void math_left_right(void)
             math_list(nucleus(tail)) = p;
             return ;
         }
-
         if (t == left_noad_side) {
             q = p;
         } else {
@@ -2080,10 +2191,13 @@ void math_left_right(void)
     }
 }
 
-@ \TeX\ gets to the following part of the program when
-the first `\.\$' ending a display has been scanned.
+/*tex
+
+    \TeX\ gets to the following part of the program when the first `\.\$' ending
+    a display has been scanned.
+
+*/
 
-@c
 static void check_second_math_shift(void)
 {
     get_x_token();
@@ -2119,7 +2233,6 @@ static void check_inline_math_end(void)
     }
 }
 
-@ @c
 static void resume_after_display(void)
 {
     if (cur_group != math_shift_group)
@@ -2129,7 +2242,7 @@ static void resume_after_display(void)
     push_nest();
     mode = hmode;
     space_factor_par = 1000;
-    /* this needs to be intercepted in the display math start ! */
+    /*tex This needs to be intercepted in the display math start! */
     tail_append(make_local_par_node(penalty_par_code));
     get_x_token();
     if (cur_cmd != spacer_cmd)
@@ -2140,30 +2253,40 @@ static void resume_after_display(void)
     }
 }
 
-@  The fussiest part of math mode processing occurs when a displayed formula is
-being centered and placed with an optional equation number.
+/*tex
+
+    The fussiest part of math mode processing occurs when a displayed formula is
+    being centered and placed with an optional equation number.
 
-At this time we are in vertical mode (or internal vertical mode).
+    At this time we are in vertical mode (or internal vertical mode).
 
-  |p| points to the mlist for the formula.
-  |a| is either |null| or it points to a box containing the equation number.
-  |l| is true if there was an \.{\\leqno}/ (so |a| is a horizontal box).
+    \starttabulate
+    \NC \type {p} \NC points to the mlist for the formula \NC \NR
+    \NC \type {a} \NC is either |null| or it points to a box containing the equation number \NC \NR
+    \NC \type {l} \NC is true if there was an \.{\\leqno}/ (so |a| is a horizontal box) \NC \NR
+    \stoptabulate
+
+*/
 
-@c
 #define inject_display_skip_before(g) \
     if (g > 0) { \
         switch (display_skip_mode_par) { \
-            case 0 : /* normal tex | always */ \
-            case 1 : /* always */ \
+            case 0 : \
+                /*tex normal tex | always */ \
+            case 1 : \
+                /*tex always */ \
                 tail_append(new_param_glue(g)); \
                 break; \
-            case 2 : /* non-zero */ \
+            case 2 : \
+                /*tex non-zero */ \
                 if (! glue_is_zero(glue_par(g))) \
                     tail_append(new_param_glue(g)); \
                 break; \
-            case 3: /* ignore */ \
+            case 3: \
+                /*tex ignore */ \
                 break; \
-            default: /* > 3 reserved for future use */ \
+            default: \
+                /*tex > 3 reserved for future use */ \
                 tail_append(new_param_glue(g)); \
                 break; \
         } \
@@ -2172,17 +2295,22 @@ At this time we are in vertical mode (or internal vertical mode).
 #define inject_display_skip_after(g) \
     if (g > 0) { \
         switch (display_skip_mode_par) { \
-            case 0 : /* normal tex | always */ \
-            case 1 : /* always */ \
+            case 0 : \
+                /*tex normal tex | always */ \
+            case 1 : \
+                /*tex always */ \
                 tail_append(new_param_glue(g)); \
                 break; \
-            case 2 : /* non-zero */ \
+            case 2 : \
+                /*tex non-zero */ \
                 if (! glue_is_zero(glue_par(g))) \
                     tail_append(new_param_glue(g)); \
                 break; \
-            case 3: /* ignore */ \
+            case 3: \
+                /*tex ignore */ \
                 break; \
-            default: /* > 3 reserved for future use */ \
+            default: \
+                /*tex > 3 reserved for future use */ \
                 tail_append(new_param_glue(g)); \
                 break; \
         } \
@@ -2190,18 +2318,30 @@ At this time we are in vertical mode (or internal vertical mode).
 
 static void finish_displayed_math(boolean l, pointer eqno_box, pointer p)
 {
-    pointer eq_box;             /* box containing the equation */
-    scaled eq_w;                /* width of the equation */
-    scaled line_w;              /* width of the line */
-    scaled eqno_w;              /* width of equation number */
-    scaled eqno_w2;             /* width of equation number plus space to separate from equation */
-    scaled line_s;              /* move the line right this much */
-    scaled d;                   /* displacement of equation in the line */
-    small_number g1, g2;        /* glue parameter codes for before and after */
-    pointer r,s;                /* kern nodes used to position the display */
-    pointer t;                  /* tail of adjustment list */
-    pointer pre_t;              /* tail of pre-adjustment list */
-    boolean swap_dir;           /* true if the math and surrounding text dirs are opposed */
+    /*tex box containing the equation */
+    pointer eq_box;
+    /*tex width of the equation */
+    scaled eq_w;
+    /*tex width of the line */
+    scaled line_w;
+    /*tex width of equation number */
+    scaled eqno_w;
+    /*tex width of equation number plus space to separate from equation */
+    scaled eqno_w2;
+    /*tex move the line right this much */
+    scaled line_s;
+    /*tex displacement of equation in the line */
+    scaled d;
+    /*tex glue parameter codes for before and after */
+    small_number g1, g2;
+    /*tex kern nodes used to position the display */
+    pointer r,s;
+    /*tex tail of adjustment list */
+    pointer t;
+    /*tex tail of pre-adjustment list */
+    pointer pre_t;
+    /*tex true if the math and surrounding text dirs are opposed */
+    boolean swap_dir;
     scaled eqno_width;
     swap_dir = (pre_display_direction_par < 0 ? true : false );
     if (eqno_box != null && swap_dir)
@@ -2209,7 +2349,7 @@ static void finish_displayed_math(boolean l, pointer eqno_box, pointer p)
     adjust_tail = adjust_head;
     pre_adjust_tail = pre_adjust_head;
     eq_box = hpack(p, 0, additional, -1);
-    subtype(eq_box) = equation_list; /* new */
+    subtype(eq_box) = equation_list;
     build_attribute_list(eq_box);
     p = list_ptr(eq_box);
     t = adjust_tail;
@@ -2227,21 +2367,23 @@ static void finish_displayed_math(boolean l, pointer eqno_box, pointer p)
         eqno_w = width(eqno_box);
         eqno_width = eqno_w;
         eqno_w2 = eqno_w + round_xn_over_d(math_eqno_gap_step_par, get_math_quad_style(text_style), 1000);
-        subtype(eqno_box) = equation_number_list; /* new */
-     /* build_attribute_list(eqno_box); */ /* probably already set */
-   }
+        subtype(eqno_box) = equation_number_list;
+        /*tex build_attribute_list(eqno_box); */
+    }
     if (eq_w + eqno_w2 > line_w) {
-        /* The user can force the equation number to go on a separate line
-           by causing its width to be zero. */
+        /*tex
+
+            The user can force the equation number to go on a separate line by
+            causing its width to be zero.
+
+        */
         if ((eqno_w != 0) && ((eq_w - total_shrink[normal] + eqno_w2 <= line_w)
-                || (total_shrink[sfi] != 0)
-                || (total_shrink[fil] != 0)
-                || (total_shrink[fill] != 0)
-                || (total_shrink[filll] != 0))) {
+                || (total_shrink[sfi] != 0) || (total_shrink[fil] != 0)
+                || (total_shrink[fill] != 0) || (total_shrink[filll] != 0))) {
             list_ptr(eq_box) = null;
             flush_node(eq_box);
             eq_box = hpack(p, line_w - eqno_w2, exactly, -1);
-            subtype(eq_box) = equation_list; /* new */
+            subtype(eq_box) = equation_list;
             build_attribute_list(eq_box);
         } else {
             eqno_w = 0;
@@ -2249,47 +2391,52 @@ static void finish_displayed_math(boolean l, pointer eqno_box, pointer p)
                 list_ptr(eq_box) = null;
                 flush_node(eq_box);
                 eq_box = hpack(p, line_w, exactly, -1);
-                subtype(eq_box) = equation_list; /* new */
+                subtype(eq_box) = equation_list;
                 build_attribute_list(eq_box);
             }
         }
         eq_w = width(eq_box);
     }
-    /* We try first to center the display without regard to the existence of
-       the equation number. If that would make it too close (where ``too close''
-       means that the space between display and equation number is less than the
-       width of the equation number), we either center it in the remaining space
-       or move it as far from the equation number as possible. The latter alternative
-       is taken only if the display begins with glue, since we assume that the
-       user put glue there to control the spacing precisely.
-     */
+    /*tex
+
+        We try first to center the display without regard to the existence of the
+        equation number. If that would make it too close (where ``too close''
+        means that the space between display and equation number is less than the
+        width of the equation number), we either center it in the remaining space
+        or move it as far from the equation number as possible. The latter
+        alternative is taken only if the display begins with glue, since we
+        assume that the user put glue there to control the spacing precisely.
+
+    */
     d = half(line_w - eq_w);
-    if ((eqno_w > 0) && (d < 2 * eqno_w)) {     /* too close */
+    if ((eqno_w > 0) && (d < 2 * eqno_w)) {
+        /*tex too close */
         d = half(line_w - eq_w - eqno_w);
         if (p != null)
             if (!is_char_node(p))
                 if (type(p) == glue_node)
                     d = 0;
     }
-
     tail_append(new_penalty(pre_display_penalty_par,after_display_penalty));
-    if ((d + line_s <= pre_display_size_par) || l) {        /* not enough clearance */
+    if ((d + line_s <= pre_display_size_par) || l) {
+        /*tex not enough clearance */
         g1 = above_display_skip_code;
         g2 = below_display_skip_code;
     } else {
         g1 = above_display_short_skip_code;
         g2 = below_display_short_skip_code;
     }
+    /*tex
+
+        If the equation number is set on a line by itself, either before or after
+        the formula, we append an infinite penalty so that no page break will
+        separate the display from its number; and we use the same size and
+        displacement for all three potential lines of the display, even though
+        `\.{\\parshape}' may specify them differently.
 
-    /* If the equation number is set on a line by itself, either before or
-       after the formula, we append an infinite penalty so that no page break will
-       separate the display from its number; and we use the same size and
-       displacement for all three potential lines of the display, even though
-       `\.{\\parshape}' may specify them differently.
-     */
-     /* \.{\\leqno} on a forced single line due to |width=0| */
-     /* it follows that |type(a)=hlist_node| */
+        \.{\\leqno} on a forced single line due to |width=0|; it follows that |type(a)=hlist_node|
 
+    */
     if (eqno_box && l && (eqno_w == 0)) {
      /* if (math_direction_par==dir_TLT) { */
             shift_amount(eqno_box) = 0;
@@ -2300,40 +2447,27 @@ static void finish_displayed_math(boolean l, pointer eqno_box, pointer p)
     } else {
         inject_display_skip_before(g1);
     }
-
     if (eqno_w != 0) {
         r = new_kern(line_w - eq_w - eqno_w - d);
         if (l) {
             if (swap_dir) {
                 if (math_direction_par==dir_TLT) {
-                    /* TRT + TLT + \eqno,    (swap_dir=true,  math_direction_par=TLT, l=true)  */
-#ifdef DEBUG
-        fprintf(stderr, "\nDEBUG: CASE 1\n");
-#endif
+                    /*tex TRT + TLT + \eqno: (swap_dir=true,  math_direction_par=TLT, l=true) */
                     s = new_kern(width(r) + eqno_w);
                     try_couple_nodes(eqno_box,r);
                     try_couple_nodes(r,eq_box);
                     try_couple_nodes(eq_box,s);
                 } else {
-                    /* TLT + TRT + \eqno,    (swap_dir=true,  math_direction_par=TRT, l=true) */
-#ifdef DEBUG
-        fprintf(stderr, "\nDEBUG: CASE 2\n");
-#endif
+                    /*tex TLT + TRT + \eqno: (swap_dir=true,  math_direction_par=TRT, l=true) */
                     try_couple_nodes(eqno_box,r);
                     try_couple_nodes(r,eq_box);
                 }
             } else {
                 if (math_direction_par==dir_TLT) {
-                    /* TLT + TLT + \leqno,   (swap_dir=false, math_direction_par=TLT, l=true) */ /* OK */
-#ifdef DEBUG
-        fprintf(stderr, "\nDEBUG: CASE 3\n");
-#endif
+                    /*tex TLT + TLT + \leqno: (swap_dir=false, math_direction_par=TLT, l=true) */
                     s = new_kern(width(r) + eqno_w);
                 } else {
-                    /* TRT + TRT + \leqno,    (swap_dir=false, math_direction_par=TRT, l=true) */
-#ifdef DEBUG
-        fprintf(stderr, "\nDEBUG: CASE 4\n");
-#endif
+                    /*tex TRT + TRT + \leqno: (swap_dir=false, math_direction_par=TRT, l=true) */
                     s = new_kern(width(r));
                 }
                 try_couple_nodes(eqno_box,r);
@@ -2344,30 +2478,18 @@ static void finish_displayed_math(boolean l, pointer eqno_box, pointer p)
         } else {
             if (swap_dir) {
                 if (math_direction_par==dir_TLT) {
-                    /* TRT + TLT + \leqno,   (swap_dir=true,  math_direction_par=TLT, l=false) */
-#ifdef DEBUG
-        fprintf(stderr, "\nDEBUG: CASE 5\n");
-#endif
+                    /*tex TRT + TLT + \leqno: (swap_dir=true,  math_direction_par=TLT, l=false) */
                 } else {
-                    /* TLT + TRT + \leqno,   (swap_dir=true,  math_direction_par=TRT, l=false) */
-#ifdef DEBUG
-        fprintf(stderr, "\nDEBUG: CASE 6\n");
-#endif
+                    /*tex TLT + TRT + \leqno: (swap_dir=true,  math_direction_par=TRT, l=false) */
                 }
                 try_couple_nodes(eq_box,r);
                 try_couple_nodes(r,eqno_box);
             } else {
                 if (math_direction_par==dir_TLT) {
-                    /*  TLT + TLT + \eqno,    (swap_dir=false, math_direction_par=TLT, l=false) */ /* OK */
-#ifdef DEBUG
-        fprintf(stderr, "\nDEBUG: CASE 7\n");
-#endif
+                    /*tex TLT + TLT + \eqno: (swap_dir=false, math_direction_par=TLT, l=false) */
                     s = new_kern(d);
                 } else {
-                    /* TRT + TRT + \eqno,   (swap_dir=false, math_direction_par=TRT, l=false) */
-#ifdef DEBUG
-        fprintf(stderr, "\nDEBUG: CASE 8\n");
-#endif
+                    /*tex TRT + TRT + \eqno: (swap_dir=false, math_direction_par=TRT, l=false) */
                     s = new_kern(width(r) + eqno_w);
                 }
                 try_couple_nodes(s,eq_box);
@@ -2383,9 +2505,8 @@ static void finish_displayed_math(boolean l, pointer eqno_box, pointer p)
     } else {
         shift_amount(eq_box) = line_s + d;
     }
-/* check for prev: */
+    /*tex check for prev: */
     append_to_vlist(eq_box,lua_key_index(equation));
-
     if ((eqno_box != null) && (eqno_w == 0) && !l) {
         tail_append(new_penalty(inf_penalty,equation_number_penalty));
      /* if (math_direction_par==dir_TLT) { */
@@ -2395,15 +2516,14 @@ static void finish_displayed_math(boolean l, pointer eqno_box, pointer p)
         append_to_vlist(eqno_box,lua_key_index(equation_number));
         g2 = 0;
     }
-    if (t != adjust_head) {     /* migrating material comes after equation number */
+    if (t != adjust_head) {
+        /*tex migrating material comes after equation number */
         vlink(tail) = vlink(adjust_head);
-        /* needs testing */
         alink(adjust_tail) = alink(tail);
         tail = t;
     }
     if (pre_t != pre_adjust_head) {
         vlink(tail) = vlink(pre_adjust_head);
-        /* needs testing */
         alink(pre_adjust_tail) = alink(tail);
         tail = pre_t;
     }
@@ -2412,20 +2532,25 @@ static void finish_displayed_math(boolean l, pointer eqno_box, pointer p)
     resume_after_display();
 }
 
-@ @c
 void after_math(void)
 {
-    int m;                      /* |mmode| or |-mmode| */
-    pointer p;                  /* the formula */
-    pointer a = null;           /* box containing equation number */
-    boolean l = false;          /* `\.{\\leqno}' instead of `\.{\\eqno}' */
+    /*tex |mmode| or |-mmode| */
+    int m;
+    /*tex the formula */
+    pointer p;
+    /*tex box containing equation number */
+    pointer a = null;
+    /*tex `\.{\\leqno}' instead of `\.{\\eqno}' */
+    boolean l = false;
     m = mode;
-    p = fin_mlist(null);        /* this pops the nest */
+    /*tex this pops the nest */
+    p = fin_mlist(null);
     if (cur_cmd == math_shift_cs_cmd &&
         (cur_chr == text_style || cur_chr == display_style)) {
         you_cant();
     }
-    if (mode == -m) {           /* end of equation number */
+    if (mode == -m) {
+        /*tex end of equation number */
         if (cur_cmd == math_shift_cmd) {
             check_second_math_shift();
         } else {
@@ -2435,7 +2560,8 @@ void after_math(void)
         a = hpack(vlink(temp_head), 0, additional, -1);
         build_attribute_list(a);
         unsave_math();
-        decr(save_ptr);         /* now |cur_group=math_shift_group| */
+        /*tex now |cur_group=math_shift_group| */
+        decr(save_ptr);
         assert(saved_type(0) == saved_eqno);
         if (saved_value(0) == 1)
             l = true;
@@ -2444,47 +2570,50 @@ void after_math(void)
 
     }
     if (m < 0) {
-        /* The |unsave| is done after everything else here; hence an appearance of
-           `\.{\\mathsurround}' inside of `\.{\$...\$}' affects the spacing at these
-           particular \.\$'s. This is consistent with the conventions of
-           `\.{\$\$...\$\$}', since `\.{\\abovedisplayskip}' inside a display affects the
-           space above that display.
-         */
+        /*tex
+
+            The |unsave| is done after everything else here; hence an appearance
+            of `\.{\\mathsurround}' inside of `\.{\$...\$}' affects the spacing
+            at these particular \.\$'s. This is consistent with the conventions
+            of `\.{\$\$...\$\$}', since `\.{\\abovedisplayskip}' inside a display
+            affects the space above that display.
+
+        */
         if (cur_cmd == math_shift_cs_cmd) {
             check_inline_math_end();
         }
         tail_append(new_math(math_surround_par, before));
-        /* begin mathskip code */
+        /*tex begin mathskip code */
         switch (math_skip_mode) {
             case 0 :
-                /* obey mathsurround when zero glue */
+                /*tex obey mathsurround when zero glue */
                 if (! glue_is_zero(math_skip_par)) {
                     copy_glue_values(tail,math_skip_par);
                     surround(tail) = 0;
                 }
                 break ;
             case 1 :
-                /* always left */
+                /*tex always left */
             case 3 :
-                /* always both */
+                /*tex always both */
             case 6 :
-                /* only when skip */
+                /*tex only when skip */
                 copy_glue_values(tail,math_skip_par);
                 surround(tail) = 0;
                 break ;
             case 2 :
-                /* only right */
+                /*tex only right */
                 surround(tail) = 0;
                 break ;
             case 4 :
-                /* ignore, obey marthsurround */
+                /*tex ignore, obey marthsurround */
                 break ;
             case 5:
-                /* all spacing disabled */
+                /*tex all spacing disabled */
                 surround(tail) = 0;
                 break ;
         }
-        /* end mathskip code */
+        /*tex end mathskip code */
         if (dir_math_save) {
             tail_append(new_dir(math_direction_par));
         }
@@ -2494,41 +2623,42 @@ void after_math(void)
             tail = vlink(tail);
         }
         if (dir_math_save) {
-            tail_append(new_dir(math_direction_par - dir_swap));
+            tail_append(new_dir(math_direction_par));
+            subtype(tail) = cancel_dir;
         }
         dir_math_save = false;
         tail_append(new_math(math_surround_par, after));
-        /* begin mathskip code */
+        /*tex begin mathskip code */
         switch (math_skip_mode) {
             case 0 :
-                /* obey mathsurround when zero glue */
+                /*tex obey mathsurround when zero glue */
                 if (! glue_is_zero(math_skip_par)) {
                     copy_glue_values(tail,math_skip_par);
                     surround(tail) = 0;
                 }
                 break ;
             case 2 :
-                /* always right */
+                /*tex always right */
             case 3 :
-                /* always both */
+                /*tex always both */
             case 6 :
-                /* only when skip */
+                /*tex only when skip */
                 copy_glue_values(tail,math_skip_par);
                 surround(tail) = 0;
                 break ;
             case 1 :
-                /* only left */
+                /*tex only left */
                 surround(tail) = 0;
                 break ;
             case 4 :
-                /* ignore, obey marthsurround */
+                /*tex ignore, obey marthsurround */
                 break ;
             case 5:
-                /* all spacing disabled */
+                /*tex all spacing disabled */
                 surround(tail) = 0;
                 break ;
         }
-        /* end mathskip code */
+        /*tex end mathskip code */
         space_factor_par = 1000;
         unsave_math();
     } else {
@@ -2544,12 +2674,15 @@ void after_math(void)
     }
 }
 
-@ When \.{\\halign} appears in a display, the alignment routines operate
-essentially as they do in vertical mode. Then the following program is
-activated, with |p| and |q| pointing to the beginning and end of the
-resulting list, and with |aux_save| holding the |prev_depth| value.
+/*tex
+
+    When \.{\\halign} appears in a display, the alignment routines operate
+    essentially as they do in vertical mode. Then the following program is
+    activated, with |p| and |q| pointing to the beginning and end of the
+    resulting list, and with |aux_save| holding the |prev_depth| value.
+
+*/
 
-@c
 void finish_display_alignment(pointer p, pointer q, halfword saved_prevdepth)
 {
     do_assignments();
@@ -2570,9 +2703,8 @@ void finish_display_alignment(pointer p, pointer q, halfword saved_prevdepth)
     resume_after_display();
 }
 
-@ Interface to \.{\\Umath} and \.{\\mathstyle}
+/*tex Interface to \.{\\Umath} and \.{\\mathstyle}: */
 
-@c
 void setup_math_style(void)
 {
     pointer q;
@@ -2582,7 +2714,6 @@ void setup_math_style(void)
     (void) scan_math_style(nucleus(tail), num_style(m_style));
 }
 
-@ @c
 void print_math_style(void)
 {
     if (abs(mode) == mmode)
diff --git a/texk/web2c/luatexdir/tex/texnodes.c b/texk/web2c/luatexdir/tex/texnodes.c
new file mode 100644
index 000000000..1dd28cdf5
--- /dev/null
+++ b/texk/web2c/luatexdir/tex/texnodes.c
@@ -0,0 +1,4770 @@
+/*
+
+Copyright 2006-2010 Taco Hoekwater <taco@luatex.org>
+
+This file is part of LuaTeX.
+
+LuaTeX is free software; you can redistribute it and/or modify it under the terms
+of the GNU General Public License as published by the Free Software Foundation;
+either version 2 of the License, or (at your option) any later version.
+
+LuaTeX is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU General Public License along with
+LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#include "ptexlib.h"
+#include "lua/luatex-api.h"
+
+/*tex
+
+    This module started out using NDEBUG to trigger checking invalid node usage,
+    something that is needed because users can mess up nodes in Lua. At some
+    point that code was always enabled so it is now always on but still can be
+    recognized as additional code. And as the performance hit is close to zero so
+    disabling makes no sense, not even to make it configureable. There is a
+    little more memory used but that is neglectable compared to other memory
+    usage.
+
+*/
+
+#define MAX_CHAIN_SIZE   13 /* why not a bit larger */
+#define CHECK_NODE_USAGE  1 /* this triggers checking */
+
+memory_word *volatile varmem = NULL;
+
+#ifdef CHECK_NODE_USAGE
+    char *varmem_sizes = NULL;
+#endif
+
+halfword var_mem_max = 0;
+halfword rover = 0;
+
+halfword free_chain[MAX_CHAIN_SIZE] = { null };
+
+static int my_prealloc = 0;
+
+/*tex Used in font and lang: */
+
+int fix_node_lists = 1;
+
+/*tex Defined below. */
+
+halfword slow_get_node(int s);
+
+#define fake_node       100
+#define fake_node_size  2
+#define fake_node_name "fake"
+
+#define variable_node_size 2
+
+/*tex
+
+    The following definitions are used for keys at the \LUA\ end and
+    provide an efficient way to share hashed strings.
+
+*/
+
+# define init_node_key(target,n,key) \
+    target[n].lua  = luaS_##key##_index; \
+    target[n].name = luaS_##key##_ptr;
+
+# define init_field_key(target,n,key) \
+    target[n].lua  = luaS_##key##_index; \
+    target[n].name = luaS_##key##_ptr;
+
+# define init_field_nop(target,n) \
+    target[n].lua  = 0; \
+    target[n].name = NULL;
+
+/*tex The fields of nodes. */
+
+field_info node_fields_accent[10];
+field_info node_fields_adjust[3];
+field_info node_fields_attribute[3];
+field_info node_fields_attribute_list[1];
+field_info node_fields_boundary[3];
+field_info node_fields_choice[6];
+field_info node_fields_delim[6];
+field_info node_fields_dir[4];
+field_info node_fields_disc[6];
+field_info node_fields_fence[8];
+field_info node_fields_fraction[10];
+field_info node_fields_glue[8];
+field_info node_fields_glue_spec[6];
+field_info node_fields_glyph[16];
+field_info node_fields_insert[7];
+field_info node_fields_inserting[9];
+field_info node_fields_kern[4];
+field_info node_fields_list[11];
+field_info node_fields_local_par[9];
+field_info node_fields_margin_kern[4];
+field_info node_fields_mark[4];
+field_info node_fields_math[8];
+field_info node_fields_math_char[4];
+field_info node_fields_math_text_char[4];
+field_info node_fields_noad[5];
+field_info node_fields_penalty[3];
+field_info node_fields_radical[9];
+field_info node_fields_rule[9];
+field_info node_fields_splitup[6];
+field_info node_fields_style[3];
+field_info node_fields_sub_box[3];
+field_info node_fields_sub_mlist[3];
+field_info node_fields_unset[12];
+
+/*tex The fields of whatsit nodes. */
+
+field_info node_fields_whatsit_close[3];
+field_info node_fields_whatsit_late_lua[6];
+field_info node_fields_whatsit_open[6];
+field_info node_fields_whatsit_save_pos[2];
+field_info node_fields_whatsit_special[3];
+field_info node_fields_whatsit_user_defined[5];
+field_info node_fields_whatsit_write[4];
+
+field_info node_fields_whatsit_pdf_action[7];
+field_info node_fields_whatsit_pdf_annot[7];
+field_info node_fields_whatsit_pdf_colorstack[5];
+field_info node_fields_whatsit_pdf_dest[10];
+field_info node_fields_whatsit_pdf_end_link[2];
+field_info node_fields_whatsit_pdf_end_thread[2];
+field_info node_fields_whatsit_pdf_literal[4];
+field_info node_fields_whatsit_pdf_refobj[3];
+field_info node_fields_whatsit_pdf_restore[2];
+field_info node_fields_whatsit_pdf_save[2];
+field_info node_fields_whatsit_pdf_setmatrix[3];
+field_info node_fields_whatsit_pdf_start_link[8];
+field_info node_fields_whatsit_pdf_start_thread[8];
+field_info node_fields_whatsit_pdf_thread[8];
+
+/*tex The values of fields. */
+
+subtype_info node_values_dir[] = {
+    { 0,  NULL, 0 },
+    { 1,  NULL, 0 },
+    { 2,  NULL, 0 },
+    { 3,  NULL, 0 },
+    { -1, NULL, 0 },
+};
+
+subtype_info node_values_pdf_destination[] = {
+    { 0,  NULL, 0 },
+    { 1,  NULL, 0 },
+    { 2,  NULL, 0 },
+    { 3,  NULL, 0 },
+    { 4,  NULL, 0 },
+    { 5,  NULL, 0 },
+    { 6,  NULL, 0 },
+    { 7,  NULL, 0 },
+    { -1, NULL, 0 },
+};
+
+subtype_info node_values_pdf_action[] = {
+    { 0,  NULL, 0 },
+    { 1,  NULL, 0 },
+    { 2,  NULL, 0 },
+    { 3,  NULL, 0 },
+    { -1, NULL, 0 },
+};
+
+subtype_info node_values_pdf_window[] = {
+    { 0,  NULL, 0 },
+    { 1,  NULL, 0 },
+    { 2,  NULL, 0 },
+    { -1, NULL, 0 },
+};
+
+subtype_info node_values_color_stack[] = {
+    { 0,  NULL, 0 },
+    { 1,  NULL, 0 },
+    { 2,  NULL, 0 },
+    { 3,  NULL, 0 },
+    { -1, NULL, 0 },
+};
+
+subtype_info node_values_fill[] = {
+    { normal, NULL, 0 },
+    { sfi,    NULL, 0 },
+    { fil,    NULL, 0 },
+    { fill,   NULL, 0 },
+    { filll,  NULL, 0 },
+    { -1,     NULL, 0 },
+};
+
+subtype_info node_values_pdf_literal[] = {
+    { set_origin,    NULL, 0 },
+    { direct_page,   NULL, 0 },
+    { direct_always, NULL, 0 },
+    { direct_raw,    NULL, 0 },
+    { direct_text,   NULL, 0 },
+    { direct_font,   NULL, 0 },
+    { scan_special,  NULL, 0 },
+    { -1,            NULL, 0 },
+};
+
+subtype_info other_values_page_states[] = {
+    { 0,  NULL, 0 },
+    { 1,  NULL, 0 },
+    { 2,  NULL, 0 },
+    { -1, NULL, 0 },
+};
+
+/*tex The subtypes of nodes (most have one). */
+
+subtype_info node_subtypes_dir[] = {
+    { normal_dir, NULL, 0 },
+    { cancel_dir, NULL, 0 },
+    { -1,         NULL, 0 },
+};
+
+subtype_info node_subtypes_glue[] = {
+    { user_skip_glue,                NULL, 0 },
+    { line_skip_glue,                NULL, 0 },
+    { baseline_skip_glue,            NULL, 0 },
+    { par_skip_glue,                 NULL, 0 },
+    { above_display_skip_glue,       NULL, 0 },
+    { below_display_skip_glue,       NULL, 0 },
+    { above_display_short_skip_glue, NULL, 0 },
+    { below_display_short_skip_glue, NULL, 0 },
+    { left_skip_glue,                NULL, 0 },
+    { right_skip_glue,               NULL, 0 },
+    { top_skip_glue,                 NULL, 0 },
+    { split_top_skip_glue,           NULL, 0 },
+    { tab_skip_glue,                 NULL, 0 },
+    { space_skip_glue,               NULL, 0 },
+    { xspace_skip_glue,              NULL, 0 },
+    { par_fill_skip_glue,            NULL, 0 },
+    { math_skip_glue,                NULL, 0 },
+    { thin_mu_skip_glue,             NULL, 0 },
+    { med_mu_skip_glue,              NULL, 0 },
+    { thick_mu_skip_glue,            NULL, 0 },
+    /* math */
+    { cond_math_glue,                NULL, 0 },
+    { mu_glue,                       NULL, 0 },
+    /* leaders */
+    { a_leaders,                     NULL, 0 },
+    { c_leaders,                     NULL, 0 },
+    { x_leaders,                     NULL, 0 },
+    { g_leaders,                     NULL, 0 },
+    { -1,                            NULL, 0 },
+};
+
+/*tex
+
+    Math glue and leaders have special numbers. At some point we might decide to
+    move them down so best don't use hard coded numbers!
+
+*/
+
+subtype_info node_subtypes_mathglue[] = { /* 98+ */
+    { cond_math_glue, NULL, 0 },
+    { mu_glue,        NULL, 0 },
+    { -1,             NULL, 0 },
+};
+
+subtype_info node_subtypes_leader[] = { /* 100+ */
+    { a_leaders, NULL, 0 },
+    { c_leaders, NULL, 0 },
+    { x_leaders, NULL, 0 },
+    { g_leaders, NULL, 0 },
+    { -1,        NULL, 0 },
+};
+
+subtype_info node_subtypes_boundary[] = {
+    { cancel_boundary,     NULL, 0 },
+    { user_boundary,       NULL, 0 },
+    { protrusion_boundary, NULL, 0 },
+    { word_boundary,       NULL, 0 },
+    { -1,                  NULL, 0 },
+};
+
+subtype_info node_subtypes_penalty[] = {
+    { user_penalty,            NULL, 0 },
+    { linebreak_penalty,       NULL, 0 },
+    { line_penalty,            NULL, 0 },
+    { word_penalty,            NULL, 0 },
+    { final_penalty,           NULL, 0 },
+    { noad_penalty,            NULL, 0 },
+    { before_display_penalty,  NULL, 0 },
+    { after_display_penalty,   NULL, 0 },
+    { equation_number_penalty, NULL, 0 },
+    { -1,                      NULL, 0 },
+};
+
+subtype_info node_subtypes_kern[] = {
+    { font_kern,     NULL, 0 },
+    { explicit_kern, NULL, 0 },
+    { accent_kern,   NULL, 0 },
+    { italic_kern,   NULL, 0 },
+    { -1,            NULL, 0 },
+};
+
+subtype_info node_subtypes_rule[] = {
+    { normal_rule,        NULL, 0 },
+    { box_rule,           NULL, 0 },
+    { image_rule,         NULL, 0 },
+    { empty_rule,         NULL, 0 },
+    { user_rule,          NULL, 0 },
+    { math_over_rule,     NULL, 0 },
+    { math_under_rule,    NULL, 0 },
+    { math_fraction_rule, NULL, 0 },
+    { math_radical_rule,  NULL, 0 },
+    { outline_rule,       NULL, 0 },
+    { -1,                 NULL, 0 },
+};
+
+subtype_info node_subtypes_glyph[] = {
+    { glyph_unset,     NULL, 0 },
+    { glyph_character, NULL, 0 },
+    { glyph_ligature,  NULL, 0 },
+    { glyph_ghost,     NULL, 0 },
+    { glyph_left,      NULL, 0 },
+    { glyph_right,     NULL, 0 },
+    { -1,              NULL, 0 },
+};
+
+subtype_info node_subtypes_disc[] = {
+    { discretionary_disc, NULL, 0 },
+    { explicit_disc,      NULL, 0 },
+    { automatic_disc,     NULL, 0 },
+    { syllable_disc,      NULL, 0 },
+    { init_disc,          NULL, 0 },
+    { select_disc,        NULL, 0 },
+    { -1,                 NULL, 0 },
+};
+
+subtype_info node_subtypes_marginkern[] = {
+    { left_side,  NULL, 0 },
+    { right_side, NULL, 0 },
+    { -1,         NULL, 0 },
+};
+
+subtype_info node_subtypes_list[] = {
+    { unknown_list,         NULL, 0 },
+    { line_list,            NULL, 0 },
+    { hbox_list,            NULL, 0 },
+    { indent_list,          NULL, 0 },
+    { align_row_list,       NULL, 0 },
+    { align_cell_list,      NULL, 0 },
+    { equation_list,        NULL, 0 },
+    { equation_number_list, NULL, 0 },
+    { -1,                   NULL, 0 },
+};
+
+subtype_info node_subtypes_adjust[] = {
+    { 0,  NULL, 0 },
+    { 1,  NULL, 0 },
+    { -1, NULL, 0 },
+};
+
+subtype_info node_subtypes_math[] = {
+    { before, NULL, 0 },
+    { after,  NULL, 0 },
+    { -1,     NULL, 0 },
+};
+
+subtype_info node_subtypes_noad[] = {
+    { ord_noad_type,          NULL, 0 },
+    { op_noad_type_normal,    NULL, 0 },
+    { op_noad_type_limits,    NULL, 0 },
+    { op_noad_type_no_limits, NULL, 0 },
+    { bin_noad_type,          NULL, 0 },
+    { rel_noad_type,          NULL, 0 },
+    { open_noad_type,         NULL, 0 },
+    { close_noad_type,        NULL, 0 },
+    { punct_noad_type,        NULL, 0 },
+    { inner_noad_type,        NULL, 0 },
+    { under_noad_type,        NULL, 0 },
+    { over_noad_type,         NULL, 0 },
+    { vcenter_noad_type,      NULL, 0 },
+    { -1,                     NULL, 0 },
+};
+
+subtype_info node_subtypes_radical[] = {
+    { radical_noad_type,         NULL, 0 },
+    { uradical_noad_type,        NULL, 0 },
+    { uroot_noad_type,           NULL, 0 },
+    { uunderdelimiter_noad_type, NULL, 0 },
+    { uoverdelimiter_noad_type,  NULL, 0 },
+    { udelimiterunder_noad_type, NULL, 0 },
+    { udelimiterover_noad_type,  NULL, 0 },
+    { -1,                        NULL, 0 },
+};
+
+subtype_info node_subtypes_accent[] = {
+    { bothflexible_accent, NULL, 0 },
+    { fixedtop_accent,     NULL, 0 },
+    { fixedbottom_accent,  NULL, 0 },
+    { fixedboth_accent,    NULL, 0 },
+    { -1,                  NULL, 0 },
+};
+
+subtype_info node_subtypes_fence[] = {
+    { unset_noad_side,  NULL, 0 },
+    { left_noad_side,   NULL, 0 },
+    { middle_noad_side, NULL, 0 },
+    { right_noad_side,  NULL, 0 },
+    { no_noad_side,     NULL, 0 },
+    { -1,               NULL, 0 },
+};
+
+/*tes This brings all together */
+
+node_info node_data[] = {
+    { hlist_node,          box_node_size,         node_subtypes_list,       node_fields_list,                          NULL,  1, 0 },
+    { vlist_node,          box_node_size,         node_subtypes_list,       node_fields_list,                          NULL,  2, 0 },
+    { rule_node,           rule_node_size,        node_subtypes_rule,       node_fields_rule,                          NULL,  3, 0 },
+    { ins_node,            ins_node_size,         NULL,                     node_fields_insert,                        NULL,  4, 0 },
+    { mark_node,           mark_node_size,        NULL,                     node_fields_mark,                          NULL,  5, 0 },
+    { adjust_node,         adjust_node_size,      node_subtypes_adjust,     node_fields_adjust,                        NULL,  6, 0 },
+    { boundary_node,       boundary_node_size,    node_subtypes_boundary,   node_fields_boundary,                      NULL, -1, 0 },
+    { disc_node,           disc_node_size,        node_subtypes_disc,       node_fields_disc,                          NULL,  8, 0 },
+    { whatsit_node,        -1,                    NULL,                     NULL,                                      NULL,  9, 0 },
+    { local_par_node,      local_par_size,        NULL,                     node_fields_local_par,                     NULL, -1, 0 },
+    { dir_node,            dir_node_size,         node_subtypes_dir,        node_fields_dir,                           NULL, -1, 0 },
+    { math_node,           math_node_size,        node_subtypes_math,       node_fields_math,                          NULL, 10, 0 },
+    { glue_node,           glue_node_size,        node_subtypes_glue,       node_fields_glue,                          NULL, 11, 0 },
+    { kern_node,           kern_node_size,        node_subtypes_kern,       node_fields_kern,                          NULL, 12, 0 },
+    { penalty_node,        penalty_node_size,     node_subtypes_penalty,    node_fields_penalty,                       NULL, 13, 0 },
+    { unset_node,          box_node_size,         NULL,                     node_fields_unset,                         NULL, 14, 0 },
+    { style_node,          style_node_size,       NULL,                     node_fields_style,                         NULL, 15, 0 },
+    { choice_node,         style_node_size,       NULL,                     node_fields_choice,                        NULL, 15, 0 },
+    { simple_noad,         noad_size,             node_subtypes_noad,       node_fields_noad,                          NULL, 15, 0 },
+    { radical_noad,        radical_noad_size,     node_subtypes_radical,    node_fields_radical,                       NULL, 15, 0 },
+    { fraction_noad,       fraction_noad_size,    NULL,                     node_fields_fraction,                      NULL, 15, 0 },
+    { accent_noad,         accent_noad_size,      node_subtypes_accent,     node_fields_accent,                        NULL, 15, 0 },
+    { fence_noad,          fence_noad_size,       node_subtypes_fence,      node_fields_fence,                         NULL, 15, 0 },
+    { math_char_node,      math_kernel_node_size, NULL,                     node_fields_math_char,                     NULL, 15, 0 },
+    { sub_box_node,        math_kernel_node_size, NULL,                     node_fields_sub_box,                       NULL, 15, 0 },
+    { sub_mlist_node,      math_kernel_node_size, NULL,                     node_fields_sub_mlist,                     NULL, 15, 0 },
+    { math_text_char_node, math_kernel_node_size, NULL,                     node_fields_math_text_char,                NULL, 15, 0 },
+    { delim_node,          math_shield_node_size, NULL,                     node_fields_delim,                         NULL, 15, 0 },
+    { margin_kern_node,    margin_kern_node_size, node_subtypes_marginkern, node_fields_margin_kern,                   NULL, -1, 0 },
+    { glyph_node,          glyph_node_size,       node_subtypes_glyph,      node_fields_glyph,                         NULL,  0, 0 },
+    { align_record_node,   box_node_size,         NULL,                     NULL,                                      NULL, -1, 0 },
+    { pseudo_file_node,    pseudo_file_node_size, NULL,                     NULL,                                      NULL, -1, 0 },
+    { pseudo_line_node,    variable_node_size,    NULL,                     NULL,                                      NULL, -1, 0 },
+    { inserting_node,      page_ins_node_size,    NULL,                     node_fields_inserting,                     NULL, -1, 0 },
+    { split_up_node,       page_ins_node_size,    NULL,                     node_fields_splitup,                       NULL, -1, 0 },
+    { expr_node,           expr_node_size,        NULL,                     NULL,                                      NULL, -1, 0 },
+    { nesting_node,        nesting_node_size,     NULL,                     NULL,                                      NULL, -1, 0 },
+    { span_node,           span_node_size,        NULL,                     NULL,                                      NULL, -1, 0 },
+    { attribute_node,      attribute_node_size,   NULL,                     node_fields_attribute,                     NULL, -1, 0 },
+    { glue_spec_node,      glue_spec_size,        NULL,                     node_fields_glue_spec,                     NULL, -1, 0 },
+    { attribute_list_node, attribute_node_size,   NULL,                     node_fields_attribute_list,                NULL, -1, 0 },
+    { temp_node,           temp_node_size,        NULL,                     NULL,                                      NULL, -1, 0 },
+    { align_stack_node,    align_stack_node_size, NULL,                     NULL,                                      NULL, -1, 0 },
+    { movement_node,       movement_node_size,    NULL,                     NULL,                                      NULL, -1, 0 },
+    { if_node,             if_node_size,          NULL,                     NULL,                                      NULL, -1, 0 },
+    { unhyphenated_node,   active_node_size,      NULL,                     NULL,                                      NULL, -1, 0 },
+    { hyphenated_node,     active_node_size,      NULL,                     NULL,                                      NULL, -1, 0 },
+    { delta_node,          delta_node_size,       NULL,                     NULL,                                      NULL, -1, 0 },
+    { passive_node,        passive_node_size,     NULL,                     NULL,                                      NULL, -1, 0 },
+    { shape_node,          variable_node_size,    NULL,                     NULL,                                      NULL, -1, 0 },
+    { -1,                 -1,                     NULL,                     NULL,                                      NULL, -1, 0 }
+};
+
+void l_set_node_data(void) {
+    init_node_key(node_data, hlist_node,          hlist)
+    init_node_key(node_data, vlist_node,          vlist)
+    init_node_key(node_data, rule_node,           rule)
+    init_node_key(node_data, ins_node,            ins)
+    init_node_key(node_data, mark_node,           mark)
+    init_node_key(node_data, adjust_node,         adjust)
+    init_node_key(node_data, boundary_node,       boundary)
+    init_node_key(node_data, disc_node,           disc)
+    init_node_key(node_data, whatsit_node,        whatsit)
+    init_node_key(node_data, local_par_node,      local_par)
+    init_node_key(node_data, dir_node,            dir)
+    init_node_key(node_data, math_node,           math)
+    init_node_key(node_data, glue_node,           glue)
+    init_node_key(node_data, kern_node,           kern)
+    init_node_key(node_data, penalty_node,        penalty)
+    init_node_key(node_data, unset_node,          unset)
+    init_node_key(node_data, style_node,          style)
+    init_node_key(node_data, choice_node,         choice)
+    init_node_key(node_data, simple_noad,         noad)
+    init_node_key(node_data, radical_noad,        radical)
+    init_node_key(node_data, fraction_noad,       fraction)
+    init_node_key(node_data, accent_noad,         accent)
+    init_node_key(node_data, fence_noad,          fence)
+    init_node_key(node_data, math_char_node,      math_char)
+    init_node_key(node_data, sub_box_node,        sub_box)
+    init_node_key(node_data, sub_mlist_node,      sub_mlist)
+    init_node_key(node_data, math_text_char_node, math_text_char)
+    init_node_key(node_data, delim_node,          delim)
+    init_node_key(node_data, margin_kern_node,    margin_kern)
+    init_node_key(node_data, glyph_node,          glyph)
+    init_node_key(node_data, align_record_node,   align_record)
+    init_node_key(node_data, pseudo_file_node,    pseudo_file)
+    init_node_key(node_data, pseudo_line_node,    pseudo_line)
+    init_node_key(node_data, inserting_node,      page_insert)
+    init_node_key(node_data, split_up_node,       split_insert)
+    init_node_key(node_data, expr_node,           expr_stack)
+    init_node_key(node_data, nesting_node,        nested_list)
+    init_node_key(node_data, span_node,           span)
+    init_node_key(node_data, attribute_node,      attribute)
+    init_node_key(node_data, glue_spec_node,      glue_spec)
+    init_node_key(node_data, attribute_list_node, attribute_list)
+    init_node_key(node_data, temp_node,           temp)
+    init_node_key(node_data, align_stack_node,    align_stack)
+    init_node_key(node_data, movement_node,       movement_stack)
+    init_node_key(node_data, if_node,             if_stack)
+    init_node_key(node_data, unhyphenated_node,   unhyphenated)
+    init_node_key(node_data, hyphenated_node,     hyphenated)
+    init_node_key(node_data, delta_node,          delta)
+    init_node_key(node_data, passive_node,        passive)
+    init_node_key(node_data, shape_node,          shape)
+
+    init_node_key(node_subtypes_dir, normal_dir, normal)
+    init_node_key(node_subtypes_dir, cancel_dir, cancel)
+
+    init_node_key(node_subtypes_glue, user_skip_glue,                userskip)
+    init_node_key(node_subtypes_glue, line_skip_glue,                lineskip)
+    init_node_key(node_subtypes_glue, baseline_skip_glue,            baselineskip)
+    init_node_key(node_subtypes_glue, par_skip_glue,                 parskip)
+    init_node_key(node_subtypes_glue, above_display_skip_glue,       abovedisplayskip)
+    init_node_key(node_subtypes_glue, below_display_skip_glue,       belowdisplayskip)
+    init_node_key(node_subtypes_glue, above_display_short_skip_glue, abovedisplayshortskip)
+    init_node_key(node_subtypes_glue, below_display_short_skip_glue, belowdisplayshortskip)
+    init_node_key(node_subtypes_glue, left_skip_glue,                leftskip)
+    init_node_key(node_subtypes_glue, right_skip_glue,               rightskip)
+    init_node_key(node_subtypes_glue, top_skip_glue,                 topskip)
+    init_node_key(node_subtypes_glue, split_top_skip_glue,           splittopskip)
+    init_node_key(node_subtypes_glue, tab_skip_glue,                 tabskip)
+    init_node_key(node_subtypes_glue, space_skip_glue,               spaceskip)
+    init_node_key(node_subtypes_glue, xspace_skip_glue,              xspaceskip)
+    init_node_key(node_subtypes_glue, par_fill_skip_glue,            parfillskip)
+    init_node_key(node_subtypes_glue, math_skip_glue,                mathskip)
+    init_node_key(node_subtypes_glue, thin_mu_skip_glue,             thinmuskip)
+    init_node_key(node_subtypes_glue, med_mu_skip_glue,              medmuskip)
+    init_node_key(node_subtypes_glue, thick_mu_skip_glue,            thickmuskip)
+    init_node_key(node_subtypes_glue, thick_mu_skip_glue + 1,        conditionalmathskip)
+    init_node_key(node_subtypes_glue, thick_mu_skip_glue + 2,        muglue)
+    init_node_key(node_subtypes_glue, thick_mu_skip_glue + 3,        leaders)
+    init_node_key(node_subtypes_glue, thick_mu_skip_glue + 4,        cleaders)
+    init_node_key(node_subtypes_glue, thick_mu_skip_glue + 5,        xleaders)
+    init_node_key(node_subtypes_glue, thick_mu_skip_glue + 6,        gleaders)
+
+    init_node_key(node_subtypes_mathglue, 0, conditionalmathskip)
+    init_node_key(node_subtypes_mathglue, 1, muglue)
+
+    init_node_key(node_subtypes_leader, 0, leaders)
+    init_node_key(node_subtypes_leader, 1, cleaders)
+    init_node_key(node_subtypes_leader, 2, xleaders)
+    init_node_key(node_subtypes_leader, 3, gleaders)
+
+    init_node_key(node_subtypes_boundary, cancel_boundary,     cancel)
+    init_node_key(node_subtypes_boundary, user_boundary,       user)
+    init_node_key(node_subtypes_boundary, protrusion_boundary, protrusion)
+    init_node_key(node_subtypes_boundary, word_boundary,       word)
+
+    init_node_key(node_subtypes_penalty, user_penalty,            userpenalty)
+    init_node_key(node_subtypes_penalty, linebreak_penalty,       linebreakpenalty)
+    init_node_key(node_subtypes_penalty, line_penalty,            linepenalty)
+    init_node_key(node_subtypes_penalty, word_penalty,            wordpenalty)
+    init_node_key(node_subtypes_penalty, final_penalty,           finalpenalty)
+    init_node_key(node_subtypes_penalty, noad_penalty,            noadpenalty)
+    init_node_key(node_subtypes_penalty, before_display_penalty,  beforedisplaypenalty)
+    init_node_key(node_subtypes_penalty, after_display_penalty,   afterdisplaypenalty)
+    init_node_key(node_subtypes_penalty, equation_number_penalty, equationnumberpenalty)
+
+    init_node_key(node_subtypes_kern, font_kern,     fontkern)
+    init_node_key(node_subtypes_kern, explicit_kern, userkern)
+    init_node_key(node_subtypes_kern, accent_kern,   accentkern)
+    init_node_key(node_subtypes_kern, italic_kern,   italiccorrection)
+
+    init_node_key(node_subtypes_rule, normal_rule,        normal)
+    init_node_key(node_subtypes_rule, box_rule,           box)
+    init_node_key(node_subtypes_rule, image_rule,         image)
+    init_node_key(node_subtypes_rule, empty_rule,         empty)
+    init_node_key(node_subtypes_rule, user_rule,          user)
+    init_node_key(node_subtypes_rule, math_over_rule,     over)
+    init_node_key(node_subtypes_rule, math_under_rule,    under)
+    init_node_key(node_subtypes_rule, math_fraction_rule, fraction)
+    init_node_key(node_subtypes_rule, math_radical_rule,  radical)
+    init_node_key(node_subtypes_rule, outline_rule,       outline)
+
+    init_node_key(node_subtypes_glyph, 0, unset)
+    init_node_key(node_subtypes_glyph, 1, character)
+    init_node_key(node_subtypes_glyph, 2, ligature)
+    init_node_key(node_subtypes_glyph, 3, ghost)
+    init_node_key(node_subtypes_glyph, 4, left)
+    init_node_key(node_subtypes_glyph, 5, right)
+
+    init_node_key(node_subtypes_disc, discretionary_disc, discretionary)
+    init_node_key(node_subtypes_disc, explicit_disc,      explicit)
+    init_node_key(node_subtypes_disc, automatic_disc,     automatic)
+    init_node_key(node_subtypes_disc, syllable_disc,      regular)
+    init_node_key(node_subtypes_disc, init_disc,          first)
+    init_node_key(node_subtypes_disc, select_disc,        second)
+
+    init_node_key(node_subtypes_fence, unset_noad_side,  unset)
+    init_node_key(node_subtypes_fence, left_noad_side,   left)
+    init_node_key(node_subtypes_fence, middle_noad_side, middle)
+    init_node_key(node_subtypes_fence, right_noad_side,  right)
+    init_node_key(node_subtypes_fence, no_noad_side,     no)
+
+    init_node_key(node_subtypes_list, unknown_list,         unknown)
+    init_node_key(node_subtypes_list, line_list,            line)
+    init_node_key(node_subtypes_list, hbox_list,            box)
+    init_node_key(node_subtypes_list, indent_list,          indent)
+    init_node_key(node_subtypes_list, align_row_list,       alignment)
+    init_node_key(node_subtypes_list, align_cell_list,      cell)
+    init_node_key(node_subtypes_list, equation_list,        equation)
+    init_node_key(node_subtypes_list, equation_number_list, equationnumber)
+
+    init_node_key(node_subtypes_math, before, beginmath)
+    init_node_key(node_subtypes_math, after,  endmath)
+
+    init_node_key(node_subtypes_marginkern, left_side,  left)
+    init_node_key(node_subtypes_marginkern, right_side, right)
+
+    init_node_key(node_subtypes_adjust, 0, normal)
+    init_node_key(node_subtypes_adjust, 1, pre)
+
+    init_node_key(node_subtypes_noad, ord_noad_type,          ord)
+    init_node_key(node_subtypes_noad, op_noad_type_normal,    opdisplaylimits)
+    init_node_key(node_subtypes_noad, op_noad_type_limits,    oplimits)
+    init_node_key(node_subtypes_noad, op_noad_type_no_limits, opnolimits)
+    init_node_key(node_subtypes_noad, bin_noad_type,          bin)
+    init_node_key(node_subtypes_noad, rel_noad_type,          rel)
+    init_node_key(node_subtypes_noad, open_noad_type,         open)
+    init_node_key(node_subtypes_noad, close_noad_type,        close)
+    init_node_key(node_subtypes_noad, punct_noad_type,        punct)
+    init_node_key(node_subtypes_noad, inner_noad_type,        inner)
+    init_node_key(node_subtypes_noad, under_noad_type,        under)
+    init_node_key(node_subtypes_noad, over_noad_type,         over)
+    init_node_key(node_subtypes_noad, vcenter_noad_type,      vcenter)
+
+    init_node_key(node_subtypes_radical, radical_noad_type,         radical)
+    init_node_key(node_subtypes_radical, uradical_noad_type,        uradical)
+    init_node_key(node_subtypes_radical, uroot_noad_type,           uroot)
+    init_node_key(node_subtypes_radical, uunderdelimiter_noad_type, uunderdelimiter)
+    init_node_key(node_subtypes_radical, uoverdelimiter_noad_type,  uoverdelimiter)
+    init_node_key(node_subtypes_radical, udelimiterunder_noad_type, udelimiterunder)
+    init_node_key(node_subtypes_radical, udelimiterover_noad_type,  udelimiterover)
+
+    init_node_key(node_subtypes_accent, bothflexible_accent, bothflexible)
+    init_node_key(node_subtypes_accent, fixedtop_accent,     fixedtop)
+    init_node_key(node_subtypes_accent, fixedbottom_accent,  fixedbottom)
+    init_node_key(node_subtypes_accent, fixedboth_accent,    fixedboth)
+
+    init_node_key(node_values_fill, normal, normal)
+    init_node_key(node_values_fill, sfi,    fi)
+    init_node_key(node_values_fill, fil,    fil)
+    init_node_key(node_values_fill, fill,   fill)
+    init_node_key(node_values_fill, filll,  filll)
+
+    init_node_key(node_values_dir, 0, TLT)
+    init_node_key(node_values_dir, 1, TRT)
+    init_node_key(node_values_dir, 2, LTL)
+    init_node_key(node_values_dir, 3, RTT)
+
+    init_node_key(other_values_page_states, 0, empty)
+    init_node_key(other_values_page_states, 1, box_there)
+    init_node_key(other_values_page_states, 2, inserts_only)
+
+    init_field_key(node_fields_accent, 0, attr);
+    init_field_key(node_fields_accent, 1, nucleus);
+    init_field_key(node_fields_accent, 2, sub);
+    init_field_key(node_fields_accent, 3, sup);
+    init_field_key(node_fields_accent, 4, accent);
+    init_field_key(node_fields_accent, 5, bot_accent);
+    init_field_key(node_fields_accent, 6, top_accent);
+    init_field_key(node_fields_accent, 7, overlay_accent);
+    init_field_key(node_fields_accent, 8, fraction);
+    init_field_nop(node_fields_accent, 9);
+
+    init_field_key(node_fields_adjust, 0, attr);
+    init_field_key(node_fields_adjust, 1, head);
+    init_field_nop(node_fields_adjust, 2);
+
+    init_field_key(node_fields_attribute, 0, number);
+    init_field_key(node_fields_attribute, 1, value);
+    init_field_nop(node_fields_attribute, 2);
+
+    init_field_nop(node_fields_attribute_list,0);
+
+    init_field_key(node_fields_boundary, 0, attr);
+    init_field_key(node_fields_boundary, 1, value);
+    init_field_nop(node_fields_boundary, 2);
+
+    init_field_key(node_fields_choice, 0, attr);
+    init_field_key(node_fields_choice, 1, display);
+    init_field_key(node_fields_choice, 2, text);
+    init_field_key(node_fields_choice, 3, script);
+    init_field_key(node_fields_choice, 4, scriptscript);
+    init_field_nop(node_fields_choice, 5);
+
+    init_field_key(node_fields_delim, 0, attr);
+    init_field_key(node_fields_delim, 1, small_fam);
+    init_field_key(node_fields_delim, 2, small_char);
+    init_field_key(node_fields_delim, 3, large_fam);
+    init_field_key(node_fields_delim, 4, large_char);
+    init_field_nop(node_fields_delim, 5);
+
+    init_field_key(node_fields_dir, 0, attr);
+    init_field_key(node_fields_dir, 1, dir);
+    init_field_key(node_fields_dir, 2, level);
+    init_field_nop(node_fields_dir, 3);
+
+    init_field_key(node_fields_disc, 0, attr);
+    init_field_key(node_fields_disc, 1, pre);
+    init_field_key(node_fields_disc, 2, post);
+    init_field_key(node_fields_disc, 3, replace);
+    init_field_key(node_fields_disc, 4, penalty);
+    init_field_nop(node_fields_disc, 5);
+
+    init_field_key(node_fields_fence, 0, attr);
+    init_field_key(node_fields_fence, 1, delim);
+    init_field_key(node_fields_fence, 2, italic);
+    init_field_key(node_fields_fence, 3, height);
+    init_field_key(node_fields_fence, 4, depth);
+    init_field_key(node_fields_fence, 5, options);
+    init_field_key(node_fields_fence, 6, class);
+    init_field_nop(node_fields_fence, 7);
+
+    init_field_key(node_fields_fraction, 0, attr);
+    init_field_key(node_fields_fraction, 1, width);
+    init_field_key(node_fields_fraction, 2, num);
+    init_field_key(node_fields_fraction, 3, denom);
+    init_field_key(node_fields_fraction, 4, left);
+    init_field_key(node_fields_fraction, 5, right);
+    init_field_key(node_fields_fraction, 6, middle);
+    init_field_key(node_fields_fraction, 7, fam);
+    init_field_key(node_fields_fraction, 8, options);
+    init_field_nop(node_fields_fraction, 9);
+
+    init_field_key(node_fields_glue, 0, attr);
+    init_field_key(node_fields_glue, 1, leader);
+    init_field_key(node_fields_glue, 2, width);
+    init_field_key(node_fields_glue, 3, stretch);
+    init_field_key(node_fields_glue, 4, shrink);
+    init_field_key(node_fields_glue, 5, stretch_order);
+    init_field_key(node_fields_glue, 6, shrink_order);
+    init_field_nop(node_fields_glue, 7);
+
+    init_field_key(node_fields_glue_spec, 0, width);
+    init_field_key(node_fields_glue_spec, 1, stretch);
+    init_field_key(node_fields_glue_spec, 2, shrink);
+    init_field_key(node_fields_glue_spec, 3, stretch_order);
+    init_field_key(node_fields_glue_spec, 4, shrink_order);
+    init_field_nop(node_fields_glue_spec, 5);
+
+    init_field_key(node_fields_glyph,  0, attr);
+    init_field_key(node_fields_glyph,  1, char);
+    init_field_key(node_fields_glyph,  2, font);
+    init_field_key(node_fields_glyph,  3, lang);
+    init_field_key(node_fields_glyph,  4, left);
+    init_field_key(node_fields_glyph,  5, right);
+    init_field_key(node_fields_glyph,  6, uchyph);
+    init_field_key(node_fields_glyph,  7, components);
+    init_field_key(node_fields_glyph,  8, xoffset);
+    init_field_key(node_fields_glyph,  9, yoffset);
+    init_field_key(node_fields_glyph, 10, width);
+    init_field_key(node_fields_glyph, 11, height);
+    init_field_key(node_fields_glyph, 12, depth);
+    init_field_key(node_fields_glyph, 13, expansion_factor);
+    init_field_key(node_fields_glyph, 14, data);
+    init_field_nop(node_fields_glyph, 15);
+
+    init_field_key(node_fields_insert, 0, attr);
+    init_field_key(node_fields_insert, 1, cost);
+    init_field_key(node_fields_insert, 2, depth);
+    init_field_key(node_fields_insert, 3, height);
+    init_field_key(node_fields_insert, 4, spec);
+    init_field_key(node_fields_insert, 5, head);
+    init_field_nop(node_fields_insert, 6);
+
+    init_field_key(node_fields_inserting, 0, height);
+    init_field_key(node_fields_inserting, 1, last_ins_ptr);
+    init_field_key(node_fields_inserting, 2, best_ins_ptr);
+    init_field_key(node_fields_inserting, 3, width);
+    init_field_key(node_fields_inserting, 4, stretch);
+    init_field_key(node_fields_inserting, 5, shrink);
+    init_field_key(node_fields_inserting, 6, stretch_order);
+    init_field_key(node_fields_inserting, 7, shrink_order);
+    init_field_nop(node_fields_inserting, 8);
+
+    init_field_key(node_fields_kern, 0, attr);
+    init_field_key(node_fields_kern, 1, kern);
+    init_field_key(node_fields_kern, 2, expansion_factor);
+    init_field_nop(node_fields_kern, 3);
+
+    init_field_key(node_fields_list,  0, attr);
+    init_field_key(node_fields_list,  1, width);
+    init_field_key(node_fields_list,  2, depth);
+    init_field_key(node_fields_list,  3, height);
+    init_field_key(node_fields_list,  4, dir);
+    init_field_key(node_fields_list,  5, shift);
+    init_field_key(node_fields_list,  6, glue_order);
+    init_field_key(node_fields_list,  7, glue_sign);
+    init_field_key(node_fields_list,  8, glue_set);
+    init_field_key(node_fields_list,  9, head);
+    init_field_nop(node_fields_list, 10);
+
+    init_field_key(node_fields_local_par, 0, attr);
+    init_field_key(node_fields_local_par, 1, pen_inter);
+    init_field_key(node_fields_local_par, 2, pen_broken);
+    init_field_key(node_fields_local_par, 3, dir);
+    init_field_key(node_fields_local_par, 4, box_left);
+    init_field_key(node_fields_local_par, 5, box_left_width);
+    init_field_key(node_fields_local_par, 6, box_right);
+    init_field_key(node_fields_local_par, 7, box_right_width);
+    init_field_nop(node_fields_local_par, 8);
+
+    init_field_key(node_fields_margin_kern, 0, attr);
+    init_field_key(node_fields_margin_kern, 1, width);
+    init_field_key(node_fields_margin_kern, 2, glyph);
+    init_field_nop(node_fields_margin_kern, 3);
+
+    init_field_key(node_fields_mark, 0, attr);
+    init_field_key(node_fields_mark, 1, class);
+    init_field_key(node_fields_mark, 2, mark);
+    init_field_nop(node_fields_mark, 3);
+
+    init_field_key(node_fields_math, 0, attr);
+    init_field_key(node_fields_math, 1, surround);
+    init_field_key(node_fields_math, 2, width);
+    init_field_key(node_fields_math, 3, stretch);
+    init_field_key(node_fields_math, 4, shrink);
+    init_field_key(node_fields_math, 5, stretch_order);
+    init_field_key(node_fields_math, 6, shrink_order);
+    init_field_nop(node_fields_math, 7);
+
+    init_field_key(node_fields_math_char, 0, attr);
+    init_field_key(node_fields_math_char, 1, fam);
+    init_field_key(node_fields_math_char, 2, char);
+    init_field_nop(node_fields_math_char, 3);
+
+    init_field_key(node_fields_math_text_char, 0, attr);
+    init_field_key(node_fields_math_text_char, 1, fam);
+    init_field_key(node_fields_math_text_char, 2, char);
+    init_field_nop(node_fields_math_text_char, 3);
+
+    init_field_key(node_fields_noad, 0, attr);
+    init_field_key(node_fields_noad, 1, nucleus);
+    init_field_key(node_fields_noad, 2, sub);
+    init_field_key(node_fields_noad, 3, sup);
+    init_field_nop(node_fields_noad, 4);
+
+    init_field_key(node_fields_penalty, 0, attr);
+    init_field_key(node_fields_penalty, 1, penalty);
+    init_field_nop(node_fields_penalty, 2);
+
+    init_field_key(node_fields_radical, 0, attr);
+    init_field_key(node_fields_radical, 1, nucleus);
+    init_field_key(node_fields_radical, 2, sub);
+    init_field_key(node_fields_radical, 3, sup);
+    init_field_key(node_fields_radical, 4, left);
+    init_field_key(node_fields_radical, 5, degree);
+    init_field_key(node_fields_radical, 6, width);
+    init_field_key(node_fields_radical, 7, options);
+    init_field_nop(node_fields_radical, 8);
+
+    init_field_key(node_fields_rule, 0, attr);
+    init_field_key(node_fields_rule, 1, width);
+    init_field_key(node_fields_rule, 2, depth);
+    init_field_key(node_fields_rule, 3, height);
+    init_field_key(node_fields_rule, 4, dir);
+    init_field_key(node_fields_rule, 5, index);
+    init_field_key(node_fields_rule, 6, left);
+    init_field_key(node_fields_rule, 7, right);
+    init_field_nop(node_fields_rule, 8);
+
+    init_field_key(node_fields_splitup, 0, height);
+    init_field_key(node_fields_splitup, 1, last_ins_ptr);
+    init_field_key(node_fields_splitup, 2, best_ins_ptr);
+    init_field_key(node_fields_splitup, 3, broken_ptr);
+    init_field_key(node_fields_splitup, 4, broken_ins);
+    init_field_nop(node_fields_splitup, 5);
+
+    init_field_key(node_fields_style, 0, attr);
+    init_field_key(node_fields_style, 1, style);
+    init_field_nop(node_fields_style, 2);
+
+    init_field_key(node_fields_sub_box, 0, attr);
+    init_field_key(node_fields_sub_box, 1, head);
+    init_field_nop(node_fields_sub_box, 2);
+
+    init_field_key(node_fields_sub_mlist, 0, attr);
+    init_field_key(node_fields_sub_mlist, 1, head);
+    init_field_nop(node_fields_sub_mlist, 2);
+
+    init_field_key(node_fields_unset,  0, attr);
+    init_field_key(node_fields_unset,  1, width);
+    init_field_key(node_fields_unset,  2, depth);
+    init_field_key(node_fields_unset,  3, height);
+    init_field_key(node_fields_unset,  4, dir);
+    init_field_key(node_fields_unset,  5, shrink);
+    init_field_key(node_fields_unset,  6, glue_order);
+    init_field_key(node_fields_unset,  7, glue_sign);
+    init_field_key(node_fields_unset,  8, stretch);
+    init_field_key(node_fields_unset,  9, span);
+    init_field_key(node_fields_unset, 10, head);
+    init_field_nop(node_fields_unset, 11);
+
+}
+
+node_info whatsit_node_data[] = {
+
+    /*tex These are always there. The fake nodes are historical. */
+
+    { open_node,             open_node_size,           NULL, node_fields_whatsit_open,             NULL, -1, 0 },
+    { write_node,            write_node_size,          NULL, node_fields_whatsit_write,            NULL, -1, 0 },
+    { close_node,            close_node_size,          NULL, node_fields_whatsit_close,            NULL, -1, 0 },
+    { special_node,          special_node_size,        NULL, node_fields_whatsit_special,          NULL, -1, 0 },
+    { fake_node,             fake_node_size,           NULL, NULL,                                 NULL, -1, 0 },
+    { fake_node,             fake_node_size,           NULL, NULL,                                 NULL, -1, 0 },
+    { save_pos_node,         save_pos_node_size,       NULL, node_fields_whatsit_save_pos,         NULL, -1, 0 },
+    { late_lua_node,         late_lua_node_size,       NULL, node_fields_whatsit_late_lua,         NULL, -1, 0 },
+    { user_defined_node,     user_defined_node_size,   NULL, node_fields_whatsit_user_defined,     NULL, -1, 0 },
+    { fake_node,             fake_node_size,           NULL, NULL,                                 NULL, -1, 0 },
+    { fake_node,             fake_node_size,           NULL, NULL,                                 NULL, -1, 0 },
+    { fake_node,             fake_node_size,           NULL, NULL,                                 NULL, -1, 0 },
+    { fake_node,             fake_node_size,           NULL, NULL,                                 NULL, -1, 0 },
+    { fake_node,             fake_node_size,           NULL, NULL,                                 NULL, -1, 0 },
+    { fake_node,             fake_node_size,           NULL, NULL,                                 NULL, -1, 0 },
+    { fake_node,             fake_node_size,           NULL, NULL,                                 NULL, -1, 0 },
+
+    /*tex Here starts the \DVI\ backend section, todo: a separate list. */
+
+    /*tex {\em There is nothing here.} */
+
+    /*tex Here starts the \PDF\ backend section, todo: a separate list.  */
+
+    { pdf_literal_node,      write_node_size,          NULL, node_fields_whatsit_pdf_literal,      NULL, -1, 0 },
+    { pdf_refobj_node,       pdf_refobj_node_size,     NULL, node_fields_whatsit_pdf_refobj,       NULL, -1, 0 },
+    { pdf_annot_node,        pdf_annot_node_size,      NULL, node_fields_whatsit_pdf_annot,        NULL, -1, 0 },
+    { pdf_start_link_node,   pdf_annot_node_size,      NULL, node_fields_whatsit_pdf_start_link,   NULL, -1, 0 },
+    { pdf_end_link_node,     pdf_end_link_node_size,   NULL, node_fields_whatsit_pdf_end_link,     NULL, -1, 0 },
+    { pdf_dest_node,         pdf_dest_node_size,       NULL, node_fields_whatsit_pdf_dest,         NULL, -1, 0 },
+    { pdf_action_node,       pdf_action_size,          NULL, node_fields_whatsit_pdf_action,       NULL, -1, 0 },
+    { pdf_thread_node,       pdf_thread_node_size,     NULL, node_fields_whatsit_pdf_thread,       NULL, -1, 0 },
+    { pdf_start_thread_node, pdf_thread_node_size,     NULL, node_fields_whatsit_pdf_start_thread, NULL, -1, 0 },
+    { pdf_end_thread_node,   pdf_end_thread_node_size, NULL, node_fields_whatsit_pdf_end_thread,   NULL, -1, 0 },
+    { pdf_thread_data_node,  pdf_thread_node_size,     NULL, NULL,                                 NULL, -1, 0 },
+    { pdf_link_data_node,    pdf_annot_node_size,      NULL, NULL,                                 NULL, -1, 0 },
+    { pdf_colorstack_node,   pdf_colorstack_node_size, NULL, node_fields_whatsit_pdf_colorstack,   NULL, -1, 0 },
+    { pdf_setmatrix_node,    pdf_setmatrix_node_size,  NULL, node_fields_whatsit_pdf_setmatrix,    NULL, -1, 0 },
+    { pdf_save_node,         pdf_save_node_size,       NULL, node_fields_whatsit_pdf_save,         NULL, -1, 0 },
+    { pdf_restore_node,      pdf_restore_node_size,    NULL, node_fields_whatsit_pdf_restore,      NULL, -1, 0 },
+
+    /*tex That's it. */
+
+    { -1,                    -1,                       NULL, NULL,                                 NULL, -1, 0 },
+
+};
+
+void l_set_whatsit_data(void) {
+    init_node_key(whatsit_node_data, open_node,         open)
+    init_node_key(whatsit_node_data, write_node,        write)
+    init_node_key(whatsit_node_data, close_node,        close)
+    init_node_key(whatsit_node_data, special_node,      special)
+    init_node_key(whatsit_node_data, save_pos_node,     save_pos)
+    init_node_key(whatsit_node_data, late_lua_node,     late_lua)
+    init_node_key(whatsit_node_data, user_defined_node, user_defined)
+
+    init_field_key(node_fields_whatsit_close, 0, attr);
+    init_field_key(node_fields_whatsit_close, 1, stream);
+    init_field_nop(node_fields_whatsit_close, 2);
+
+    init_field_key(node_fields_whatsit_late_lua, 0, attr);
+    init_field_key(node_fields_whatsit_late_lua, 1, reg);
+    init_field_key(node_fields_whatsit_late_lua, 2, data);
+    init_field_key(node_fields_whatsit_late_lua, 3, name);
+    init_field_key(node_fields_whatsit_late_lua, 4, string);
+    init_field_nop(node_fields_whatsit_late_lua, 5);
+
+    init_field_key(node_fields_whatsit_open, 0, attr);
+    init_field_key(node_fields_whatsit_open, 1, stream);
+    init_field_key(node_fields_whatsit_open, 2, name);
+    init_field_key(node_fields_whatsit_open, 3, area);
+    init_field_key(node_fields_whatsit_open, 4, ext);
+    init_field_nop(node_fields_whatsit_open, 5);
+
+    init_field_key(node_fields_whatsit_save_pos, 0, attr);
+    init_field_nop(node_fields_whatsit_save_pos, 1);
+
+    init_field_key(node_fields_whatsit_special, 0, attr);
+    init_field_key(node_fields_whatsit_special, 1, data);
+    init_field_nop(node_fields_whatsit_special, 2);
+
+    init_field_key(node_fields_whatsit_user_defined, 0, attr);
+    init_field_key(node_fields_whatsit_user_defined, 1, user_id);
+    init_field_key(node_fields_whatsit_user_defined, 2, type);
+    init_field_key(node_fields_whatsit_user_defined, 3, value);
+    init_field_nop(node_fields_whatsit_user_defined, 4);
+
+    init_field_key(node_fields_whatsit_write, 0, attr);
+    init_field_key(node_fields_whatsit_write, 1, stream);
+    init_field_key(node_fields_whatsit_write, 2, data);
+    init_field_nop(node_fields_whatsit_write, 3);
+
+    init_node_key(whatsit_node_data, pdf_literal_node,     pdf_literal)
+    init_node_key(whatsit_node_data, pdf_refobj_node,      pdf_refobj)
+    init_node_key(whatsit_node_data, pdf_annot_node,       pdf_annot)
+    init_node_key(whatsit_node_data, pdf_start_link_node,  pdf_start_link)
+    init_node_key(whatsit_node_data, pdf_end_link_node,    pdf_end_link)
+    init_node_key(whatsit_node_data, pdf_dest_node,        pdf_dest)
+    init_node_key(whatsit_node_data, pdf_action_node,      pdf_action)
+    init_node_key(whatsit_node_data, pdf_thread_node,      pdf_thread)
+    init_node_key(whatsit_node_data, pdf_start_thread_node,pdf_start_thread)
+    init_node_key(whatsit_node_data, pdf_end_thread_node,  pdf_end_thread)
+    init_node_key(whatsit_node_data, pdf_thread_data_node, pdf_thread_data)
+    init_node_key(whatsit_node_data, pdf_link_data_node,   pdf_link_data)
+    init_node_key(whatsit_node_data, pdf_colorstack_node,  pdf_colorstack)
+    init_node_key(whatsit_node_data, pdf_setmatrix_node,   pdf_setmatrix)
+    init_node_key(whatsit_node_data, pdf_save_node,        pdf_save)
+    init_node_key(whatsit_node_data, pdf_restore_node,     pdf_restore)
+
+    init_node_key(node_values_pdf_destination, 0, xyz)
+    init_node_key(node_values_pdf_destination, 1, fit)
+    init_node_key(node_values_pdf_destination, 2, fith)
+    init_node_key(node_values_pdf_destination, 3, fitv)
+    init_node_key(node_values_pdf_destination, 4, fitb)
+    init_node_key(node_values_pdf_destination, 5, fitbh)
+    init_node_key(node_values_pdf_destination, 6, fitbv)
+    init_node_key(node_values_pdf_destination, 7, fitr)
+
+    init_node_key(node_values_pdf_literal, set_origin,    origin)
+    init_node_key(node_values_pdf_literal, direct_page,   page)
+    init_node_key(node_values_pdf_literal, direct_always, always)
+    init_node_key(node_values_pdf_literal, direct_raw,    raw)
+    init_node_key(node_values_pdf_literal, direct_text,   text)
+    init_node_key(node_values_pdf_literal, direct_font,   font)
+    init_node_key(node_values_pdf_literal, scan_special,  special)
+
+    init_node_key(node_values_pdf_action, 0, page)
+    init_node_key(node_values_pdf_action, 1, goto)
+    init_node_key(node_values_pdf_action, 2, thread)
+    init_node_key(node_values_pdf_action, 3, user)
+
+    init_node_key(node_values_pdf_window, 0, unset)
+    init_node_key(node_values_pdf_window, 1, new)
+    init_node_key(node_values_pdf_window, 2, nonew)
+
+    init_node_key(node_values_color_stack, 0, set)
+    init_node_key(node_values_color_stack, 1, push)
+    init_node_key(node_values_color_stack, 2, pop)
+    init_node_key(node_values_color_stack, 3, current)
+
+    init_field_key(node_fields_whatsit_pdf_action, 0, action_type);
+    init_field_key(node_fields_whatsit_pdf_action, 1, named_id);
+    init_field_key(node_fields_whatsit_pdf_action, 2, action_id);
+    init_field_key(node_fields_whatsit_pdf_action, 3, file);
+    init_field_key(node_fields_whatsit_pdf_action, 4, new_window);
+    init_field_key(node_fields_whatsit_pdf_action, 5, data);
+    init_field_nop(node_fields_whatsit_pdf_action, 6);
+
+    init_field_key(node_fields_whatsit_pdf_annot, 0, attr);
+    init_field_key(node_fields_whatsit_pdf_annot, 1, width);
+    init_field_key(node_fields_whatsit_pdf_annot, 2, depth);
+    init_field_key(node_fields_whatsit_pdf_annot, 3, height);
+    init_field_key(node_fields_whatsit_pdf_annot, 4, objnum);
+    init_field_key(node_fields_whatsit_pdf_annot, 5, data);
+    init_field_nop(node_fields_whatsit_pdf_annot, 6);
+
+    init_field_key(node_fields_whatsit_pdf_colorstack, 0, attr);
+    init_field_key(node_fields_whatsit_pdf_colorstack, 1, stack);
+    init_field_key(node_fields_whatsit_pdf_colorstack, 2, cmd);
+    init_field_key(node_fields_whatsit_pdf_colorstack, 3, data);
+    init_field_nop(node_fields_whatsit_pdf_colorstack, 4);
+
+    init_field_key(node_fields_whatsit_pdf_dest, 0, attr);
+    init_field_key(node_fields_whatsit_pdf_dest, 1, width);
+    init_field_key(node_fields_whatsit_pdf_dest, 2, depth);
+    init_field_key(node_fields_whatsit_pdf_dest, 3, height);
+    init_field_key(node_fields_whatsit_pdf_dest, 4, named_id);
+    init_field_key(node_fields_whatsit_pdf_dest, 5, dest_id);
+    init_field_key(node_fields_whatsit_pdf_dest, 6, dest_type);
+    init_field_key(node_fields_whatsit_pdf_dest, 7, xyz_zoom);
+    init_field_key(node_fields_whatsit_pdf_dest, 8, objnum);
+    init_field_nop(node_fields_whatsit_pdf_dest, 9);
+
+    init_field_key(node_fields_whatsit_pdf_end_link, 0, attr);
+    init_field_nop(node_fields_whatsit_pdf_end_link, 1);
+
+    init_field_key(node_fields_whatsit_pdf_end_thread, 0, attr);
+    init_field_nop(node_fields_whatsit_pdf_end_thread, 1);
+
+    init_field_key(node_fields_whatsit_pdf_literal, 0, attr);
+    init_field_key(node_fields_whatsit_pdf_literal, 1, mode);
+    init_field_key(node_fields_whatsit_pdf_literal, 2, data);
+    init_field_nop(node_fields_whatsit_pdf_literal, 3);
+
+    init_field_key(node_fields_whatsit_pdf_refobj, 0, attr);
+    init_field_key(node_fields_whatsit_pdf_refobj, 1, objnum);
+    init_field_nop(node_fields_whatsit_pdf_refobj, 2);
+
+    init_field_key(node_fields_whatsit_pdf_restore, 0, attr);
+    init_field_nop(node_fields_whatsit_pdf_restore, 1);
+
+    init_field_key(node_fields_whatsit_pdf_save, 0, attr);
+    init_field_nop(node_fields_whatsit_pdf_save, 1);
+
+    init_field_key(node_fields_whatsit_pdf_setmatrix, 0, attr);
+    init_field_key(node_fields_whatsit_pdf_setmatrix, 1, data);
+    init_field_nop(node_fields_whatsit_pdf_setmatrix, 2);
+
+    init_field_key(node_fields_whatsit_pdf_start_link, 0, attr);
+    init_field_key(node_fields_whatsit_pdf_start_link, 1, width);
+    init_field_key(node_fields_whatsit_pdf_start_link, 2, depth);
+    init_field_key(node_fields_whatsit_pdf_start_link, 3, height);
+    init_field_key(node_fields_whatsit_pdf_start_link, 4, objnum);
+    init_field_key(node_fields_whatsit_pdf_start_link, 5, link_attr);
+    init_field_key(node_fields_whatsit_pdf_start_link, 6, action);
+    init_field_nop(node_fields_whatsit_pdf_start_link, 7);
+
+    init_field_key(node_fields_whatsit_pdf_start_thread, 0, attr);
+    init_field_key(node_fields_whatsit_pdf_start_thread, 1, width);
+    init_field_key(node_fields_whatsit_pdf_start_thread, 2, depth);
+    init_field_key(node_fields_whatsit_pdf_start_thread, 3, height);
+    init_field_key(node_fields_whatsit_pdf_start_thread, 4, named_id);
+    init_field_key(node_fields_whatsit_pdf_start_thread, 5, thread_id);
+    init_field_key(node_fields_whatsit_pdf_start_thread, 6, thread_attr);
+    init_field_nop(node_fields_whatsit_pdf_start_thread, 7);
+
+    init_field_key(node_fields_whatsit_pdf_thread, 0, attr);
+    init_field_key(node_fields_whatsit_pdf_thread, 1, width);
+    init_field_key(node_fields_whatsit_pdf_thread, 2, depth);
+    init_field_key(node_fields_whatsit_pdf_thread, 3, height);
+    init_field_key(node_fields_whatsit_pdf_thread, 4, named_id);
+    init_field_key(node_fields_whatsit_pdf_thread, 5, thread_id);
+    init_field_key(node_fields_whatsit_pdf_thread, 6, thread_attr);
+    init_field_nop(node_fields_whatsit_pdf_thread, 7);
+
+}
+
+#define last_whatsit_node pdf_restore_node
+
+/*tex
+
+    When we copy a node list, there are several possibilities: we do the same as
+    a new node, we copy the entry to the table in properties (a reference), we do
+    a deep copy of a table in the properties, we create a new table and give it
+    the original one as a metatable. After some experiments (that also included
+    timing) with these scenarios I decided that a deep copy made no sense, nor
+    did nilling. In the end both the shallow copy and the metatable variant were
+    both ok, although the second ons is slower. The most important aspect to keep
+    in mind is that references to other nodes in properties no longer can be
+    valid for that copy. We could use two tables (one unique and one shared) or
+    metatables but that only complicates matters.
+
+    When defining a new node, we could already allocate a table but it is rather
+    easy to do that at the lua end e.g. using a metatable __index method. That
+    way it is under macro package control.
+
+    When deleting a node, we could keep the slot (e.g. setting it to false) but
+    it could make memory consumption raise unneeded when we have temporary large
+    node lists and after that only small lists.
+
+    So, in the end this is what we ended up with. For the record, I also
+    experimented with the following:
+
+    \startitemize
+
+        \startitem
+            Copy attributes to the properties so that we have fast access at the
+            lua end: in the end the overhead is not compensated by speed and
+            convenience, in fact, attributes are not that slow when it comes to
+            accessing them.
+        \stopitem
+
+        \startitem
+            A bitset in the node but again the gain compared to attributes is
+            neglectable and it also demands a pretty string agreement over what
+            bit represents what, and this is unlikely to succeed in the tex
+            community (I could use it for font handling, which is cross package,
+            but decided that it doesn't pay off.
+        \stopitem
+
+    \stopitemize
+
+    In case one wonders why properties make sense then, well, it is not so much
+    speed that we gain, but more convenience: storing all kind of (temporary)
+    data in attributes is no fun and this mechanism makes sure that properties
+    are cleaned up when a node is freed. Also, the advantage of a more or less
+    global properties table is that we stay at the lua end. An alternative is to
+    store a reference in the node itself but that is complicated by the fact that
+    the register has some limitations (no numeric keys) and we also don't want to
+    mess with it too much.
+
+*/
+
+int lua_properties_level         = 0 ;
+int lua_properties_enabled       = 0 ;
+int lua_properties_use_metatable = 0 ;
+
+/*tex
+
+    We keep track of nesting so that we don't oveflow the stack, and, what is
+    more important, don't keep resolving the registry index.
+
+*/
+
+#define lua_properties_push do { \
+    if (lua_properties_enabled) { \
+        lua_properties_level = lua_properties_level + 1 ; \
+        if (lua_properties_level == 1) { \
+            lua_get_metatablelua_l(Luas,node_properties); \
+        } \
+    } \
+} while(0)
+
+#define lua_properties_pop do { \
+    if (lua_properties_enabled) { \
+        if (lua_properties_level == 1) \
+            lua_pop(Luas,1); \
+        lua_properties_level = lua_properties_level - 1 ; \
+    } \
+} while(0)
+
+/*tex No setting is needed: */
+
+#define lua_properties_set(target) do { \
+} while(0)
+
+/*tex Resetting boils down to nilling. */
+
+#define lua_properties_reset(target) do { \
+    if (lua_properties_enabled) { \
+        if (lua_properties_level == 0) { \
+            lua_get_metatablelua_l(Luas,node_properties); \
+            lua_pushnil(Luas); \
+            lua_rawseti(Luas,-2,target); \
+            lua_pop(Luas,1); \
+        } else { \
+            lua_pushnil(Luas); \
+            lua_rawseti(Luas,-2,target); \
+        } \
+    } \
+} while(0)
+
+/*tex
+
+    For a moment I considered supporting all kind of data types but in practice
+    that makes no sense. So we stick to a cheap shallow copy with as option a
+    metatable. BTW, a deep copy would look like this:
+
+    \starttyping
+    static void copy_lua_table(lua_State* L, int index) {
+        lua_newtable(L);
+        lua_pushnil(L);
+        while(lua_next(L, index-1) != 0) {
+            lua_pushvalue(L, -2);
+            lua_insert(L, -2);
+            if (lua_type(L,-1)==LUA_TTABLE)
+                copy_lua_table(L,-1);
+            lua_settable(L, -4);
+        }
+        lua_pop(L,1);
+    }
+
+    #define lua_properties_copy(target, source) do { \
+        if (lua_properties_enabled) { \
+            lua_pushinteger(Luas,source); \
+            lua_rawget(Luas,-2); \
+            if (lua_type(Luas,-1)==LUA_TTABLE) { \
+                copy_lua_table(Luas,-1); \
+                lua_pushinteger(Luas,target); \
+                lua_insert(Luas,-2); \
+                lua_rawset(Luas,-3); \
+            } else { \
+                lua_pop(Luas,1); \
+            } \
+        } \
+    } while(0)
+    \stoptyping
+
+*/
+
+/*tex Isn't there a faster way to metatable? */
+
+/*tex
+
+    \starttyping
+    #define lua_properties_copy(target,source) do { \
+        if (lua_properties_enabled) { \
+            if (lua_properties_level == 0) { \
+                lua_get_metatablelua_l(Luas,node_properties); \
+                lua_rawgeti(Luas,-1,source); \
+                if (lua_type(Luas,-1)==LUA_TTABLE) { \
+                    if (lua_properties_use_metatable) { \
+                        lua_newtable(Luas); \
+                        lua_insert(Luas,-2); \
+                        lua_setfield(Luas,-2,"__index"); \
+                        lua_newtable(Luas); \
+                        lua_insert(Luas,-2); \
+                        lua_setmetatable(Luas,-2); \
+                    } \
+                    lua_rawseti(Luas,-2,target); \
+                } else { \
+                    lua_pop(Luas,1); \
+                } \
+                lua_pop(Luas,1); \
+            } else { \
+                lua_rawgeti(Luas,-1,source); \
+                if (lua_type(Luas,-1)==LUA_TTABLE) { \
+                    if (lua_properties_use_metatable) { \
+                        lua_newtable(Luas); \
+                        lua_insert(Luas,-2); \
+                        lua_setfield(Luas,-2,"__index"); \
+                        lua_newtable(Luas); \
+                        lua_insert(Luas,-2); \
+                        lua_setmetatable(Luas,-2); \
+                    } \
+                    lua_rawseti(Luas,-2,target); \
+                } else { \
+                    lua_pop(Luas,1); \
+                } \
+            } \
+        } \
+    } while(0)
+    \stoptyping
+
+*/
+
+/*tex
+
+    A simple testrun on many pages of dumb text shows 1% gain (of course it
+    depends on how properties are used but some other tests confirm it).
+
+*/
+
+#define lua_properties_copy(target,source) do { \
+    if (lua_properties_enabled) { \
+        if (lua_properties_level == 0) { \
+            lua_get_metatablelua_l(Luas,node_properties); \
+            lua_rawgeti(Luas,-1,source); \
+            if (lua_type(Luas,-1)==LUA_TTABLE) { \
+                if (lua_properties_use_metatable) { \
+                    lua_newtable(Luas); \
+                    lua_insert(Luas,-2); \
+                    lua_push_string_by_name(Luas,__index); \
+                    lua_insert(Luas,-2); \
+                    lua_rawset(Luas, -3); \
+                    lua_newtable(Luas); \
+                    lua_insert(Luas,-2); \
+                    lua_setmetatable(Luas,-2); \
+                } \
+                lua_rawseti(Luas,-2,target); \
+            } else { \
+                lua_pop(Luas,1); \
+            } \
+            lua_pop(Luas,1); \
+        } else { \
+            lua_rawgeti(Luas,-1,source); \
+            if (lua_type(Luas,-1)==LUA_TTABLE) { \
+                if (lua_properties_use_metatable) { \
+                    lua_newtable(Luas); \
+                    lua_insert(Luas,-2); \
+                    lua_push_string_by_name(Luas,__index); \
+                    lua_insert(Luas,-2); \
+                    lua_rawset(Luas, -3); \
+                    lua_newtable(Luas); \
+                    lua_insert(Luas,-2); \
+                    lua_setmetatable(Luas,-2); \
+                } \
+                lua_rawseti(Luas,-2,target); \
+            } else { \
+                lua_pop(Luas,1); \
+            } \
+        } \
+    } \
+} while(0)
+
+/*tex Here end the property handlers. */
+
+int valid_node(halfword p)
+{
+    if (p > my_prealloc && p < var_mem_max) {
+#ifdef CHECK_NODE_USAGE
+        if (varmem_sizes[p] > 0) {
+            return 1;
+        }
+#else
+        return 1;
+#endif
+    }
+    return 0;
+}
+
+static int test_count = 1;
+
+#define dorangetest(a,b,c)  do {                                 \
+    if (!(b>=0 && b<c)) {                                        \
+        fprintf(stdout,"For node p:=%d, 0<=%d<%d (l.%d,r.%d)\n", \
+            (int)a, (int)b, (int)c, __LINE__,test_count);        \
+        confusion("node range test failed");                     \
+    } } while (0)
+
+#define dotest(a,b,c) do {                                     \
+    if (b!=c) {                                                \
+        fprintf(stdout,"For node p:=%d, %d==%d (l.%d,r.%d)\n", \
+            (int)a, (int)b, (int)c, __LINE__,test_count);      \
+        confusion("node test failed");                         \
+    } } while (0)
+
+#define check_action_ref(a)    { dorangetest(p,a,var_mem_max); }
+#define check_attribute_ref(a) { dorangetest(p,a,var_mem_max); }
+
+/*tex hm, we can just pass |p| then. */
+
+#define check_token_ref(p) { \
+    if (type(p) == whatsit_node) { \
+        formatted_error("nodes","fuzzy token cleanup in whatsit node with type %s and subtype %i",node_data[type(p)].name,subtype(p)); \
+    } else { \
+        formatted_error("nodes","fuzzy token cleanup in node with type %s",node_data[type(p)].name); \
+    } \
+}
+
+#ifdef CHECK_NODE_USAGE
+
+static void check_static_node_mem(void)
+{
+    dotest(zero_glue, width(zero_glue), 0);
+    dotest(zero_glue, type(zero_glue), glue_spec_node);
+    dotest(zero_glue, vlink(zero_glue), null);
+    dotest(zero_glue, stretch(zero_glue), 0);
+    dotest(zero_glue, stretch_order(zero_glue), normal);
+    dotest(zero_glue, shrink(zero_glue), 0);
+    dotest(zero_glue, shrink_order(zero_glue), normal);
+
+    dotest(sfi_glue, width(sfi_glue), 0);
+    dotest(sfi_glue, type(sfi_glue), glue_spec_node);
+    dotest(sfi_glue, vlink(sfi_glue), null);
+    dotest(sfi_glue, stretch(sfi_glue), 0);
+    dotest(sfi_glue, stretch_order(sfi_glue), sfi);
+    dotest(sfi_glue, shrink(sfi_glue), 0);
+    dotest(sfi_glue, shrink_order(sfi_glue), normal);
+
+    dotest(fil_glue, width(fil_glue), 0);
+    dotest(fil_glue, type(fil_glue), glue_spec_node);
+    dotest(fil_glue, vlink(fil_glue), null);
+    dotest(fil_glue, stretch(fil_glue), unity);
+    dotest(fil_glue, stretch_order(fil_glue), fil);
+    dotest(fil_glue, shrink(fil_glue), 0);
+    dotest(fil_glue, shrink_order(fil_glue), normal);
+
+    dotest(fill_glue, width(fill_glue), 0);
+    dotest(fill_glue, type(fill_glue), glue_spec_node);
+    dotest(fill_glue, vlink(fill_glue), null);
+    dotest(fill_glue, stretch(fill_glue), unity);
+    dotest(fill_glue, stretch_order(fill_glue), fill);
+    dotest(fill_glue, shrink(fill_glue), 0);
+    dotest(fill_glue, shrink_order(fill_glue), normal);
+
+    dotest(ss_glue, width(ss_glue), 0);
+    dotest(ss_glue, type(ss_glue), glue_spec_node);
+    dotest(ss_glue, vlink(ss_glue), null);
+    dotest(ss_glue, stretch(ss_glue), unity);
+    dotest(ss_glue, stretch_order(ss_glue), fil);
+    dotest(ss_glue, shrink(ss_glue), unity);
+    dotest(ss_glue, shrink_order(ss_glue), fil);
+
+    dotest(fil_neg_glue, width(fil_neg_glue), 0);
+    dotest(fil_neg_glue, type(fil_neg_glue), glue_spec_node);
+    dotest(fil_neg_glue, vlink(fil_neg_glue), null);
+    dotest(fil_neg_glue, stretch(fil_neg_glue), -unity);
+    dotest(fil_neg_glue, stretch_order(fil_neg_glue), fil);
+    dotest(fil_neg_glue, shrink(fil_neg_glue), 0);
+    dotest(fil_neg_glue, shrink_order(fil_neg_glue), normal);
+}
+
+static void node_mem_dump(halfword p)
+{
+    halfword r;
+    for (r = my_prealloc + 1; r < var_mem_max; r++) {
+        if (vlink(r) == p) {
+            halfword s = r;
+            while (s > my_prealloc && varmem_sizes[s] == 0) {
+                s--;
+            }
+            if (s != null
+                && s != my_prealloc
+                && s != var_mem_max
+                && (r - s) < get_node_size(type(s), subtype(s))
+                && alink(s) != p) {
+                if (type(s) == disc_node) {
+                    fprintf(stdout,"  pointed to from %s node %d (vlink %d, alink %d): ",
+                        get_node_name(type(s), subtype(s)), (int) s,
+                        (int) vlink(s), (int) alink(s));
+                    fprintf(stdout, "pre_break(%d,%d,%d), ",
+                        (int) vlink_pre_break(s), (int) tlink(pre_break(s)),
+                        (int) alink(pre_break(s)));
+                    fprintf(stdout, "post_break(%d,%d,%d), ",
+                        (int) vlink_post_break(s),
+                        (int) tlink(post_break(s)),
+                        (int) alink(post_break(s)));
+                    fprintf(stdout, "no_break(%d,%d,%d)",
+                        (int) vlink_no_break(s), (int) tlink(no_break(s)),
+                        (int) alink(no_break(s)));
+                    fprintf(stdout, "\n");
+                } else {
+                    if (vlink(s) == p
+                        || (type(s) == glyph_node && lig_ptr (s) == p)
+                        || (type(s) == vlist_node && list_ptr(s) == p)
+                        || (type(s) == hlist_node && list_ptr(s) == p)
+                        || (type(s) == unset_node && list_ptr(s) == p)
+                        || (type(s) == ins_node   && ins_ptr (s) == p)
+                        ) {
+                        fprintf(stdout,"  pointed to from %s node %d (vlink %d, alink %d): ",
+                            get_node_name(type(s), subtype(s)), (int) s,
+                            (int) vlink(s), (int) alink(s));
+                        if (type(s) == glyph_node) {
+                            fprintf(stdout, "lig_ptr(%d)", (int) lig_ptr(s));
+                        } else if (type(s) == vlist_node || type(s) == hlist_node) {
+                            fprintf(stdout, "list_ptr(%d)", (int) list_ptr(s));
+                        }
+                        fprintf(stdout, "\n");
+                    } else {
+                        if ((type(s) != penalty_node) && (type(s) != math_node) && (type(s) != kern_node)) {
+                            fprintf(stdout, "  pointed to from %s node %d\n",
+                                get_node_name(type(s), subtype(s)), (int) s);
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+#endif
+
+static int free_error(halfword p)
+{
+    if (p > my_prealloc && p < var_mem_max) {
+#ifdef CHECK_NODE_USAGE
+        int i;
+        if (varmem_sizes[p] == 0) {
+            check_static_node_mem();
+            for (i = (my_prealloc + 1); i < var_mem_max; i++) {
+                if (varmem_sizes[i] > 0) {
+                    check_node(i);
+                }
+            }
+            test_count++;
+            if (type(p) == glyph_node) {
+                formatted_error("nodes", "attempt to double-free glyph (%c) node %d, ignored", (int) character(p), (int) p);
+            } else {
+                formatted_error("nodes", "attempt to double-free %s node %d, ignored", get_node_name(type(p), subtype(p)), (int) p);
+            }
+            node_mem_dump(p);
+            return 1;
+        }
+#endif
+    } else {
+        formatted_error("nodes", "attempt to free an impossible node %d", (int) p);
+        return 1;
+    }
+    return 0;
+}
+
+static int copy_error(halfword p)
+{
+    if (p >= 0 && p < var_mem_max) {
+#ifdef CHECK_NODE_USAGE
+        if (p > my_prealloc && varmem_sizes[p] == 0) {
+            if (type(p) == glyph_node) {
+                formatted_warning("nodes", "attempt to copy free glyph (%c) node %d, ignored", (int) character(p), (int) p);
+            } else {
+                formatted_warning("nodes", "attempt to copy free %s node %d, ignored", get_node_name(type(p), subtype(p)), (int) p);
+            }
+            return 1;
+        }
+#endif
+    } else {
+        formatted_error("nodes", "attempt to copy an impossible node %d", (int) p);
+        return 1;
+    }
+    return 0;
+}
+
+/*tex
+
+    Because of the 5-10\% overhead that \SYNTEX\ creates some options have been
+    implemented controlled by |synctex_anyway_mode|.
+
+    \startabulate
+    \NC \type {1} \NC all but glyphs  \NC \NR
+    \NC \type {2} \NC also glyphs     \NC \NR
+    \NC \type {3} \NC glyphs and glue \NC \NR
+    \NC \type {4} \NC only glyphs     \NC \NR
+    \stoptabulate
+
+*/
+
+static halfword synctex_anyway_mode = 0;
+static halfword synctex_line_field  = 0;
+static halfword synctex_no_files    = 0;
+
+void synctex_set_mode(int m)
+{
+    synctex_anyway_mode = m;
+};
+
+int synctex_get_mode(void)
+{
+    return synctex_anyway_mode;
+};
+
+void synctex_set_no_files(int f)
+{
+    synctex_no_files = f;
+};
+
+int synctex_get_no_files(void)
+{
+    return (int) synctex_no_files ;
+};
+
+void synctex_set_tag(int t)
+{
+    cur_input.synctex_tag_field = t;
+};
+
+int synctex_get_tag(void)
+{
+    return (int) cur_input.synctex_tag_field;
+};
+
+int synctex_get_line(void)
+{
+    return (int) synctex_line_field;
+};
+
+static int forced_tag  = 0;
+static int forced_line = 0;
+
+void synctex_force_tag(int t)
+{
+    forced_tag = t;
+};
+
+void synctex_force_line(int t)
+{
+    forced_line = t;
+};
+
+void synctex_set_line(int l)
+{
+    synctex_line_field = l;
+};
+
+/*tex |if_stack| is called a lot so maybe optimize that one. */
+
+halfword new_node(int i, int j)
+{
+    int s = get_node_size(i, j);
+    halfword n = get_node(s);
+    /*tex
+
+        It should be possible to do this memset at |free_node()|. Both type() and
+        subtype() will be set below, and vlink() is set to null by |get_node()|,
+        so we can do we clearing one word less than |s|.
+
+    */
+    (void) memset((void *) (varmem + n + 1), 0, (sizeof(memory_word) * ((unsigned) s - 1)));
+    switch (i) {
+        case glyph_node:
+            init_lang_data(n);
+            break;
+        case hlist_node:
+        case vlist_node:
+            box_dir(n) = -1;
+            break;
+        case disc_node:
+            pre_break(n) = pre_break_head(n);
+            type(pre_break(n)) = nesting_node;
+            subtype(pre_break(n)) = pre_break_head(0);
+            post_break(n) = post_break_head(n);
+            type(post_break(n)) = nesting_node;
+            subtype(post_break(n)) = post_break_head(0);
+            no_break(n) = no_break_head(n);
+            type(no_break(n)) = nesting_node;
+            subtype(no_break(n)) = no_break_head(0);
+            break;
+        case rule_node:
+            depth(n) = null_flag;
+            height(n) = null_flag;
+            width(n) = null_flag;
+            rule_dir(n) = -1;
+            rule_index(n) = 0;
+            rule_transform(n) = 0;
+            break;
+        case whatsit_node:
+            if (j == open_node) {
+                open_name(n) = get_nullstr();
+                open_area(n) = open_name(n);
+                open_ext(n) = open_name(n);
+            }
+            break;
+        case unset_node:
+            width(n) = null_flag;
+            break;
+        case pseudo_line_node:
+        case shape_node:
+            /*tex
+
+                This is a trick that makes |pseudo_files| slightly slower, but
+                the overall allocation faster then an explicit test at the top of
+                |new_node()|.
+
+            */
+            if (j>0) {
+              free_node(n, variable_node_size);
+              n = slow_get_node(j);
+              (void) memset((void *) (varmem + n + 1), 0, (sizeof(memory_word) * ((unsigned) j - 1)));
+            }
+            break;
+        case fraction_noad:
+            fraction_fam(n) = -1;
+            break;
+        case simple_noad:
+            noad_fam(n) = -1;
+            break;
+        default:
+            break;
+    }
+    if (synctex_anyway_mode) {
+        /*tex See table above. */
+        switch (i) {
+            case glyph_node:
+                if (synctex_anyway_mode > 1) {
+                    synctex_tag_glyph(n) = forced_tag ? forced_tag : cur_input.synctex_tag_field;
+                    synctex_line_glyph(n) = forced_line ? forced_line : synctex_line_field ? synctex_line_field : line;
+                }
+                break;
+            case glue_node:
+                if (synctex_anyway_mode < 4) {
+                    synctex_tag_glue(n) = forced_tag ? forced_tag : cur_input.synctex_tag_field;
+                    synctex_line_glue(n) = forced_line ? forced_line : synctex_line_field ? synctex_line_field : line;
+                }
+                break;
+            case kern_node:
+                if (synctex_anyway_mode < 3) {
+                    synctex_tag_kern(n) = forced_tag ? forced_tag : cur_input.synctex_tag_field;
+                    synctex_line_kern(n) = forced_line ? forced_line : synctex_line_field ? synctex_line_field : line;
+                }
+                break;
+            case hlist_node:
+            case vlist_node:
+            case unset_node:
+                /*tex Rather useless: */
+                if (synctex_anyway_mode < 3) {
+                    synctex_tag_box(n) = forced_tag ? forced_tag : cur_input.synctex_tag_field;
+                    synctex_line_box(n) = forced_line ? forced_line : synctex_line_field ? synctex_line_field : line;
+                }
+                break;
+            case rule_node:
+                if (synctex_anyway_mode < 3) {
+                    synctex_tag_rule(n) = forced_tag ? forced_tag : cur_input.synctex_tag_field;
+                    synctex_line_rule(n) = forced_line ? forced_line : synctex_line_field ? synctex_line_field : line;
+                }
+                break;
+            case math_node:
+                /*tex Noads probably make more sense but let's not change that. */
+                if (synctex_anyway_mode < 3) {
+                    synctex_tag_math(n) = forced_tag ? forced_tag : cur_input.synctex_tag_field;
+                    synctex_line_math(n) = forced_line ? forced_line : synctex_line_field ? synctex_line_field : line;
+                }
+                break;
+        }
+    } else if (synctex_par) {
+        /*tex Handle the \SYNTEX\ extension. */
+        switch (i) {
+            case glue_node:
+                synctex_tag_glue(n) = cur_input.synctex_tag_field;
+                synctex_line_glue(n) = line;
+                break;
+            case kern_node:
+                if (j != 0) {
+                    synctex_tag_kern(n) = cur_input.synctex_tag_field;
+                    synctex_line_kern(n) = line;
+                }
+                break;
+            case hlist_node:
+            case vlist_node:
+            case unset_node:
+                synctex_tag_box(n) = cur_input.synctex_tag_field;
+                synctex_line_box(n) = line;
+                break;
+            case rule_node:
+                synctex_tag_rule(n) = cur_input.synctex_tag_field;
+                synctex_line_rule(n) = line;
+                break;
+            case math_node:
+                synctex_tag_math(n) = cur_input.synctex_tag_field;
+                synctex_line_math(n) = line;
+                break;
+        }
+    }
+    /*tex Take care of attributes. */
+    if (nodetype_has_attributes(i)) {
+        build_attribute_list(n);
+        /*tex No need for |lua_properties_set|. */
+    }
+    type(n) = (quarterword) i;
+    subtype(n) = (quarterword) j;
+    return n;
+}
+
+halfword raw_glyph_node(void)
+{
+    register halfword n = get_node(glyph_node_size);
+    (void) memset((void *) (varmem + n + 1), 0, (sizeof(memory_word) * (glyph_node_size - 1)));
+    if (synctex_anyway_mode > 1) {
+        synctex_tag_glyph(n) = forced_tag ? forced_tag : cur_input.synctex_tag_field;
+        synctex_line_glyph(n) = forced_line ? forced_line : synctex_line_field ? synctex_line_field : line;
+    }
+    type(n) = glyph_node;
+    subtype(n) = 0;
+    return n;
+}
+
+halfword new_glyph_node(void)
+{
+    register halfword n = get_node(glyph_node_size);
+    (void) memset((void *) (varmem + n + 1), 0, (sizeof(memory_word) * (glyph_node_size - 1)));
+    if (synctex_anyway_mode > 1) {
+        synctex_tag_glyph(n) = forced_tag ? forced_tag : cur_input.synctex_tag_field;
+        synctex_line_glyph(n) = forced_line ? forced_line : synctex_line_field ? synctex_line_field : line;
+    }
+    type(n) = glyph_node;
+    subtype(n) = 0;
+    build_attribute_list(n);
+    /*tex No need for |lua_properties_set|. */
+    return n;
+}
+
+/*tex
+
+    This makes a duplicate of the node list that starts at |p| and returns a
+    pointer to the new list.
+
+*/
+
+halfword do_copy_node_list(halfword p, halfword end)
+{
+    /*tex previous position in new list */
+    halfword q = null;
+    /*tex head of the list */
+    halfword h = null;
+    register halfword s ;
+    /*tex saves stack and time */
+    lua_properties_push;
+    while (p != end) {
+        s = copy_node(p);
+        if (h == null) {
+            h = s;
+        } else {
+            couple_nodes(q, s);
+        }
+        q = s;
+        p = vlink(p);
+    }
+    /*tex saves stack and time */
+    lua_properties_pop;
+    return h;
+}
+
+halfword copy_node_list(halfword p)
+{
+    return do_copy_node_list(p, null);
+}
+
+#define copy_sub_list(target,source) do { \
+     if (source != null) { \
+         s = do_copy_node_list(source, null); \
+         target = s; \
+     } else { \
+         target = null; \
+     } \
+ } while (0)
+
+#define copy_sub_node(target,source) do { \
+    if (source != null) { \
+        s = copy_node(source); \
+        target = s ; \
+    } else { \
+        target = null; \
+    } \
+} while (0)
+
+/*tex Make a dupe of a single node. */
+
+static void copy_node_wrapup_core(halfword p, halfword r)
+{
+    halfword s ;
+    switch (subtype(p)) {
+        case write_node:
+        case special_node:
+            add_token_ref(write_tokens(p));
+            break;
+        case late_lua_node:
+            copy_late_lua(r, p);
+            break;
+        case user_defined_node:
+            switch (user_node_type(p)) {
+            case 'a':
+                add_node_attr_ref(user_node_value(p));
+                break;
+            case 'l':
+                copy_user_lua(r, p);
+                break;
+            case 'n':
+                s = copy_node_list(user_node_value(p));
+                user_node_value(r) = s;
+                break;
+            case 's':
+                /* |add_string_ref(user_node_value(p));| */
+                break;
+            case 't':
+                add_token_ref(user_node_value(p));
+                break;
+            }
+            break;
+        default:
+            break ;
+    }
+}
+
+void copy_node_wrapup_dvi(halfword p, halfword r)
+{
+}
+
+void copy_node_wrapup_pdf(halfword p, halfword r)
+{
+    switch(subtype(p)) {
+        case pdf_literal_node:
+            copy_pdf_literal(r, p);
+            break;
+        case pdf_colorstack_node:
+            if (pdf_colorstack_cmd(p) <= colorstack_data)
+                add_token_ref(pdf_colorstack_data(p));
+            break;
+        case pdf_setmatrix_node:
+            add_token_ref(pdf_setmatrix_data(p));
+            break;
+        case pdf_annot_node:
+            add_token_ref(pdf_annot_data(p));
+            break;
+        case pdf_start_link_node:
+            if (pdf_link_attr(r) != null)
+                add_token_ref(pdf_link_attr(r));
+            add_action_ref(pdf_link_action(r));
+            break;
+        case pdf_dest_node:
+            if (pdf_dest_named_id(p) > 0)
+                add_token_ref(pdf_dest_id(p));
+            break;
+        case pdf_thread_node:
+        case pdf_start_thread_node:
+            if (pdf_thread_named_id(p) > 0)
+                add_token_ref(pdf_thread_id(p));
+            if (pdf_thread_attr(p) != null)
+                add_token_ref(pdf_thread_attr(p));
+            break;
+        default:
+            break;
+    }
+}
+
+halfword copy_node(const halfword p)
+{
+    /*tex current node being fabricated for new list */
+    halfword r;
+    /*tex whatsit subtype */
+    halfword w;
+    /*tex type of node */
+    halfword t;
+    /*tex a helper variable for copying into variable mem  */
+    register halfword s;
+    register int i;
+    if (copy_error(p)) {
+        r = new_node(temp_node, 0);
+        return r;
+    }
+    t = type(p);
+    i = get_node_size(t,subtype(p));
+    r = get_node(i);
+    (void) memcpy((void *) (varmem + r), (void *) (varmem + p), (sizeof(memory_word) * (unsigned) i));
+    /*tex A possible speedup:
+
+    \starttyping
+    if t == glue_spec) {
+        return r;
+    }
+    \stoptyping
+
+    */
+    if (synctex_anyway_mode) {
+        /*tex Not:
+
+        \starttyping
+        if (t == glyph_node) {
+            if (synctex_anyway_mode > 1) {
+                synctex_tag_glyph(r) = forced_tag ? forced_tag : cur_input.synctex_tag_field;
+                synctex_line_glyph(r) = forced_line ? forced_line : synctex_line_field ? synctex_line_field : line;
+            }
+        }
+        \stoptyping
+        */
+    } else if (synctex_par) {
+        /*tex Handle synctex extension. */
+        switch (t) {
+            case math_node:
+                synctex_tag_math(r) = cur_input.synctex_tag_field;
+                synctex_line_math(r) = line;
+                break;
+            case kern_node:
+                synctex_tag_kern(r) = cur_input.synctex_tag_field;
+                synctex_line_kern(r) = line;
+                break;
+        }
+    }
+    if (nodetype_has_attributes(t)) {
+        add_node_attr_ref(node_attr(p));
+        alink(r) = null;
+        lua_properties_copy(r,p);
+    }
+    vlink(r) = null;
+    switch (t) {
+        case glyph_node:
+            copy_sub_list(lig_ptr(r),lig_ptr(p)) ;
+            break;
+        case glue_node:
+            copy_sub_list(leader_ptr(r),leader_ptr(p)) ;
+            break;
+        case hlist_node:
+        case vlist_node:
+        case unset_node:
+            copy_sub_list(list_ptr(r),list_ptr(p)) ;
+            break;
+        case disc_node:
+            pre_break(r) = pre_break_head(r);
+            if (vlink_pre_break(p) != null) {
+                s = copy_node_list(vlink_pre_break(p));
+                alink(s) = pre_break(r);
+                tlink_pre_break(r) = tail_of_list(s);
+                vlink_pre_break(r) = s;
+            } else {
+                assert(tlink(pre_break(r)) == null);
+            }
+            post_break(r) = post_break_head(r);
+            if (vlink_post_break(p) != null) {
+                s = copy_node_list(vlink_post_break(p));
+                alink(s) = post_break(r);
+                tlink_post_break(r) = tail_of_list(s);
+                vlink_post_break(r) = s;
+            } else {
+                assert(tlink_post_break(r) == null);
+            }
+            no_break(r) = no_break_head(r);
+            if (vlink(no_break(p)) != null) {
+                s = copy_node_list(vlink_no_break(p));
+                alink(s) = no_break(r);
+                tlink_no_break(r) = tail_of_list(s);
+                vlink_no_break(r) = s;
+            } else {
+                assert(tlink_no_break(r) == null);
+            }
+            break;
+        case math_node:
+            break;
+        case ins_node:
+            copy_sub_list(ins_ptr(r),ins_ptr(p)) ;
+            break;
+        case margin_kern_node:
+            copy_sub_node(margin_char(r),margin_char(p));
+            break;
+        case mark_node:
+            add_token_ref(mark_ptr(p));
+            break;
+        case adjust_node:
+            copy_sub_list(adjust_ptr(r),adjust_ptr(p));
+            break;
+        case choice_node:
+            copy_sub_list(display_mlist(r),display_mlist(p)) ;
+            copy_sub_list(text_mlist(r),text_mlist(p)) ;
+            copy_sub_list(script_mlist(r),script_mlist(p)) ;
+            copy_sub_list(script_script_mlist(r),script_script_mlist(p)) ;
+            break;
+        case simple_noad:
+            copy_sub_list(nucleus(r),nucleus(p)) ;
+            copy_sub_list(subscr(r),subscr(p)) ;
+            copy_sub_list(supscr(r),supscr(p)) ;
+            break;
+        case radical_noad:
+            copy_sub_list(nucleus(r),nucleus(p)) ;
+            copy_sub_list(subscr(r),subscr(p)) ;
+            copy_sub_list(supscr(r),supscr(p)) ;
+            copy_sub_node(left_delimiter(r),left_delimiter(p)) ;
+            copy_sub_list(degree(r),degree(p)) ;
+            break;
+        case accent_noad:
+            copy_sub_list(nucleus(r),nucleus(p)) ;
+            copy_sub_list(subscr(r),subscr(p)) ;
+            copy_sub_list(supscr(r),supscr(p)) ;
+            copy_sub_list(top_accent_chr(r),top_accent_chr(p)) ;
+            copy_sub_list(bot_accent_chr(r),bot_accent_chr(p)) ;
+            copy_sub_list(overlay_accent_chr(r),overlay_accent_chr(p)) ;
+            break;
+        case fence_noad:
+            copy_sub_node(delimiter(r),delimiter(p)) ;
+            break;
+        case sub_box_node:
+        case sub_mlist_node:
+            copy_sub_list(math_list(r),math_list(p)) ;
+            break;
+        case fraction_noad:
+            copy_sub_list(numerator(r),numerator(p)) ;
+            copy_sub_list(denominator(r),denominator(p)) ;
+            copy_sub_node(left_delimiter(r),left_delimiter(p)) ;
+            copy_sub_node(right_delimiter(r),right_delimiter(p)) ;
+            break;
+        case glue_spec_node:
+            break;
+        case dir_node:
+            break;
+        case local_par_node:
+            copy_sub_list(local_box_left(r),local_box_left(p));
+            copy_sub_list(local_box_right(r),local_box_right(p));
+        case boundary_node:
+            break;
+        case whatsit_node:
+            w = subtype(p) ;
+            if (w >= backend_first_pdf_whatsit) {
+                copy_node_wrapup_pdf(p,r);
+            } else if (w >= backend_first_dvi_whatsit) {
+                copy_node_wrapup_dvi(p,r);
+            } else {
+                copy_node_wrapup_core(p,r);
+            }
+            break;
+    }
+    return r;
+}
+
+#define free_sub_list(source) if (source != null) flush_node_list(source);
+#define free_sub_node(source) if (source != null) flush_node(source);
+
+static void flush_node_wrapup_core(halfword p)
+{
+    switch (subtype(p)) {
+        case open_node:
+        case write_node:
+        case close_node:
+        case save_pos_node:
+            break;
+        case special_node:
+            delete_token_ref(write_tokens(p));
+            break;
+        case late_lua_node:
+            free_late_lua(p);
+            break;
+        case user_defined_node:
+            switch (user_node_type(p)) {
+            case 'a':
+                delete_attribute_ref(user_node_value(p));
+                break;
+            case 'd':
+                break;
+            case 'l':
+                free_user_lua(user_node_value(p));
+                break;
+            case 'n':
+                flush_node_list(user_node_value(p));
+                break;
+            case 's':
+                /*tex |delete_string_ref(user_node_value(p));| *//* if this was mpost .. */
+                break;
+            case 't':
+                delete_token_ref(user_node_value(p));
+                break;
+            default:
+                {
+                    const char *hlp[] = {
+                        "The type of the value in a user defined whatsit node should be one",
+                        "of 'a' (attribute list), 'd' (number), 'n' (node list), 's' (string),",
+                        "or 't' (tokenlist). Yours has an unknown type, and therefore I don't",
+                        "know how to free the node's value. A memory leak may result.",
+                        NULL
+                    };
+                    tex_error("Unidentified user defined whatsit", hlp);
+                }
+                break;
+            }
+            break;
+    }
+}
+
+void flush_node_wrapup_dvi(halfword p)
+{
+}
+
+void flush_node_wrapup_pdf(halfword p)
+{
+    switch(subtype(p)) {
+        case pdf_save_node:
+        case pdf_restore_node:
+        case pdf_refobj_node:
+        case pdf_end_link_node:
+        case pdf_end_thread_node:
+            break;
+        case pdf_literal_node:
+            free_pdf_literal(p);
+            break;
+        case pdf_colorstack_node:
+            if (pdf_colorstack_cmd(p) <= colorstack_data)
+                delete_token_ref(pdf_colorstack_data(p));
+            break;
+        case pdf_setmatrix_node:
+            delete_token_ref(pdf_setmatrix_data(p));
+            break;
+        case pdf_annot_node:
+            delete_token_ref(pdf_annot_data(p));
+            break;
+        case pdf_link_data_node:
+            break;
+        case pdf_start_link_node:
+            if (pdf_link_attr(p) != null)
+                delete_token_ref(pdf_link_attr(p));
+            delete_action_ref(pdf_link_action(p));
+            break;
+        case pdf_dest_node:
+            if (pdf_dest_named_id(p) > 0)
+                delete_token_ref(pdf_dest_id(p));
+            break;
+        case pdf_action_node:
+            if (pdf_action_type(p) == pdf_action_user) {
+                delete_token_ref(pdf_action_tokens(p));
+            } else {
+                if (pdf_action_file(p) != null)
+                    delete_token_ref(pdf_action_file(p));
+                if (pdf_action_type(p) == pdf_action_page)
+                    delete_token_ref(pdf_action_tokens(p));
+                else if (pdf_action_named_id(p) > 0)
+                    delete_token_ref(pdf_action_id(p));
+            }
+            break;
+        case pdf_thread_data_node:
+            break;
+        case pdf_thread_node:
+        case pdf_start_thread_node:
+            if (pdf_thread_named_id(p) > 0)
+                delete_token_ref(pdf_thread_id(p));
+            if (pdf_thread_attr(p) != null)
+                delete_token_ref(pdf_thread_attr(p));
+            break;
+    }
+}
+
+void flush_node(halfword p)
+{
+    halfword w;
+    if (p == null){
+        /*tex legal, but no-op. */
+        return;
+    }
+    if (free_error(p))
+        return;
+    switch (type(p)) {
+        case glyph_node:
+            free_sub_list(lig_ptr(p));
+            break;
+        case glue_node:
+            free_sub_list(leader_ptr(p));
+            break;
+        case hlist_node:
+        case vlist_node:
+        case unset_node:
+            free_sub_list(list_ptr(p));
+            break;
+        case disc_node:
+            /*tex Watch the start at temp node hack! */
+            free_sub_list(vlink(pre_break(p)));
+            free_sub_list(vlink(post_break(p)));
+            free_sub_list(vlink(no_break(p)));
+            break;
+        case rule_node:
+        case kern_node:
+        case penalty_node:
+        case math_node:
+            break;
+        case glue_spec_node:
+            /*tex This allows free-ing of lua-allocated glue specs. */
+            break ;
+        case dir_node:
+            break;
+        case local_par_node:
+            free_sub_list(local_box_left(p));
+            free_sub_list(local_box_right(p));
+            break;
+        case boundary_node:
+            break;
+        case whatsit_node:
+            w = subtype(p) ;
+            if (w >= backend_first_pdf_whatsit) {
+                flush_node_wrapup_pdf(p);
+            } else if (w >= backend_first_dvi_whatsit) {
+                flush_node_wrapup_dvi(p);
+            } else {
+                flush_node_wrapup_core(p);
+            }
+            break;
+        case ins_node:
+            flush_node_list(ins_ptr(p));
+            break;
+        case margin_kern_node:
+            flush_node(margin_char(p));
+            break;
+        case mark_node:
+            delete_token_ref(mark_ptr(p));
+            break;
+        case adjust_node:
+            flush_node_list(adjust_ptr(p));
+            break;
+        case style_node:
+            /*tex Nothing to do. */
+            break;
+        case choice_node:
+            free_sub_list(display_mlist(p));
+            free_sub_list(text_mlist(p));
+            free_sub_list(script_mlist(p));
+            free_sub_list(script_script_mlist(p));
+            break;
+        case simple_noad:
+            free_sub_list(nucleus(p));
+            free_sub_list(subscr(p));
+            free_sub_list(supscr(p));
+            break;
+        case radical_noad:
+            free_sub_list(nucleus(p));
+            free_sub_list(subscr(p));
+            free_sub_list(supscr(p));
+            free_sub_node(left_delimiter(p));
+            free_sub_list(degree(p));
+            break;
+        case accent_noad:
+            free_sub_list(nucleus(p));
+            free_sub_list(subscr(p));
+            free_sub_list(supscr(p));
+            free_sub_list(top_accent_chr(p));
+            free_sub_list(bot_accent_chr(p));
+            free_sub_list(overlay_accent_chr(p));
+            break;
+        case fence_noad:
+            free_sub_list(delimiter(p));
+            break;
+        case delim_node:
+        case math_char_node:
+        case math_text_char_node:
+            /*tex Nothing to do. */
+            break;
+        case sub_box_node:
+        case sub_mlist_node:
+            free_sub_list(math_list(p));
+            break;
+        case fraction_noad:
+            free_sub_list(numerator(p));
+            free_sub_list(denominator(p));
+            free_sub_node(left_delimiter(p));
+            free_sub_node(right_delimiter(p));
+            break;
+        case pseudo_file_node:
+            free_sub_list(pseudo_lines(p));
+            break;
+        case pseudo_line_node:
+        case shape_node:
+            free_node(p, subtype(p));
+            return;
+            break;
+        case align_stack_node:
+        case span_node:
+        case movement_node:
+        case if_node:
+        case nesting_node:
+        case unhyphenated_node:
+        case hyphenated_node:
+        case delta_node:
+        case passive_node:
+        case inserting_node:
+        case split_up_node:
+        case expr_node:
+        case attribute_node:
+        case attribute_list_node:
+        case temp_node:
+            break;
+        default:
+            formatted_error("nodes","flushing weird node type %d", type(p));
+            return;
+    }
+    if (nodetype_has_attributes(type(p))) {
+        delete_attribute_ref(node_attr(p));
+        lua_properties_reset(p);
+    }
+    free_node(p, get_node_size(type(p), subtype(p)));
+    return;
+}
+
+/*tex Erase the list of nodes starting at |pp|. */
+
+void flush_node_list(halfword pp)
+{
+    register halfword p = pp;
+    if (p == null) {
+        /*tex Legal, but no-op. */
+        return;
+    }
+    if (free_error(p))
+        return;
+    /*tex Saves stack and time. */
+    lua_properties_push;
+    while (p != null) {
+        register halfword q = vlink(p);
+        flush_node(p);
+        p = q;
+    }
+    /*tex Saves stack and time. */
+    lua_properties_pop;
+}
+
+static void check_node_wrapup_core(halfword p)
+{
+    switch (subtype(p)) {
+        /*tex Frontend code. */
+        case special_node:
+            check_token_ref(p);
+            break;
+        case user_defined_node:
+            switch (user_node_type(p)) {
+                case 'a':
+                    check_attribute_ref(user_node_value(p));
+                    break;
+                case 't':
+                    check_token_ref(p);
+                    break;
+                case 'n':
+                    dorangetest(p, user_node_value(p), var_mem_max);
+                    break;
+                case 's':
+                case 'd':
+                    break;
+                default:
+                    confusion("unknown user node type");
+                    break;
+            }
+            break;
+        case open_node:
+        case write_node:
+        case close_node:
+        case save_pos_node:
+            break;
+    }
+}
+
+void check_node_wrapup_dvi(halfword p)
+{
+}
+
+void check_node_wrapup_pdf(halfword p)
+{
+    switch (subtype(p)) {
+        case pdf_literal_node:
+            if (pdf_literal_type(p) == normal)
+                check_token_ref(p);
+            break;
+        case pdf_colorstack_node:
+            if (pdf_colorstack_cmd(p) <= colorstack_data)
+                check_token_ref(p);
+            break;
+        case pdf_setmatrix_node:
+            check_token_ref(p);
+            break;
+        case late_lua_node:
+            if (late_lua_name(p) > 0)
+                check_token_ref(p);
+            if (late_lua_type(p) == normal)
+                check_token_ref(p);
+            break;
+        case pdf_annot_node:
+            check_token_ref(p);
+            break;
+        case pdf_start_link_node:
+            if (pdf_link_attr(p) != null)
+                check_token_ref(p);
+            check_action_ref(pdf_link_action(p));
+            break;
+        case pdf_dest_node:
+            if (pdf_dest_named_id(p) > 0)
+                check_token_ref(p);
+            break;
+        case pdf_thread_node:
+        case pdf_start_thread_node:
+            if (pdf_thread_named_id(p) > 0)
+                check_token_ref(p);
+            if (pdf_thread_attr(p) != null)
+                check_token_ref(p);
+            break;
+        case pdf_save_node:
+        case pdf_restore_node:
+        case pdf_refobj_node:
+        case pdf_end_link_node:
+        case pdf_end_thread_node:
+            break;
+        default:
+            confusion("wrapup pdf nodes");
+            break;
+    }
+}
+
+void check_node(halfword p)
+{
+    halfword w ;
+    switch (type(p)) {
+        case glyph_node:
+            dorangetest(p, lig_ptr(p), var_mem_max);
+            break;
+        case glue_node:
+            dorangetest(p, leader_ptr(p), var_mem_max);
+            break;
+        case hlist_node:
+        case vlist_node:
+        case unset_node:
+        case align_record_node:
+            dorangetest(p, list_ptr(p), var_mem_max);
+            break;
+        case ins_node:
+            dorangetest(p, ins_ptr(p), var_mem_max);
+            break;
+        case whatsit_node:
+            w = subtype(p) ;
+            if (w >= backend_first_pdf_whatsit) {
+                check_node_wrapup_pdf(p);
+            } else if (w >= backend_first_dvi_whatsit) {
+                check_node_wrapup_dvi(p);
+            } else {
+                check_node_wrapup_core(p);
+            }
+            break;
+        case margin_kern_node:
+            check_node(margin_char(p));
+            break;
+        case math_node:
+            break;
+        case disc_node:
+            dorangetest(p, vlink(pre_break(p)), var_mem_max);
+            dorangetest(p, vlink(post_break(p)), var_mem_max);
+            dorangetest(p, vlink(no_break(p)), var_mem_max);
+            break;
+        case adjust_node:
+            dorangetest(p, adjust_ptr(p), var_mem_max);
+            break;
+        case pseudo_file_node:
+            dorangetest(p, pseudo_lines(p), var_mem_max);
+            break;
+        case pseudo_line_node:
+        case shape_node:
+            break;
+        case choice_node:
+            dorangetest(p, display_mlist(p), var_mem_max);
+            dorangetest(p, text_mlist(p), var_mem_max);
+            dorangetest(p, script_mlist(p), var_mem_max);
+            dorangetest(p, script_script_mlist(p), var_mem_max);
+            break;
+        case fraction_noad:
+            dorangetest(p, numerator(p), var_mem_max);
+            dorangetest(p, denominator(p), var_mem_max);
+            dorangetest(p, left_delimiter(p), var_mem_max);
+            dorangetest(p, right_delimiter(p), var_mem_max);
+            break;
+        case simple_noad:
+            dorangetest(p, nucleus(p), var_mem_max);
+            dorangetest(p, subscr(p), var_mem_max);
+            dorangetest(p, supscr(p), var_mem_max);
+            break;
+        case radical_noad:
+            dorangetest(p, nucleus(p), var_mem_max);
+            dorangetest(p, subscr(p), var_mem_max);
+            dorangetest(p, supscr(p), var_mem_max);
+            dorangetest(p, degree(p), var_mem_max);
+            dorangetest(p, left_delimiter(p), var_mem_max);
+            break;
+        case accent_noad:
+            dorangetest(p, nucleus(p), var_mem_max);
+            dorangetest(p, subscr(p), var_mem_max);
+            dorangetest(p, supscr(p), var_mem_max);
+            dorangetest(p, top_accent_chr(p), var_mem_max);
+            dorangetest(p, bot_accent_chr(p), var_mem_max);
+            dorangetest(p, overlay_accent_chr(p), var_mem_max);
+            break;
+        case fence_noad:
+            dorangetest(p, delimiter(p), var_mem_max);
+            break;
+        case local_par_node:
+            dorangetest(p, local_box_left(p), var_mem_max);
+            dorangetest(p, local_box_right(p), var_mem_max);
+            break;
+        /*tex
+
+        There is no need for useless cases:
+
+        \starttyping
+        case rule_node:
+        case kern_node:
+        case penalty_node:
+        case mark_node:
+        case style_node:
+        case attribute_list_node:
+        case attribute_node:
+        case glue_spec_node:
+        case temp_node:
+        case align_stack_node:
+        case movement_node:
+        case if_node:
+        case nesting_node:
+        case span_node:
+        case unhyphenated_node:
+        case hyphenated_node:
+        case delta_node:
+        case passive_node:
+        case expr_node:
+        case dir_node:
+        case boundary_node:
+            break;
+        default:
+            fprintf(stdout, "check_node: type is %d\n", type(p));
+        \stoptyping
+
+        */
+    }
+}
+
+halfword fix_node_list(halfword head)
+{
+    halfword next, tail;
+    if (head == null)
+        return null;
+    tail = head;
+    next = vlink(head);
+    while (next != null) {
+        alink(next) = tail;
+        tail = next;
+        next = vlink(tail);
+    }
+    return tail;
+}
+
+halfword get_node(int s)
+{
+    register halfword r;
+
+    if (s < MAX_CHAIN_SIZE) {
+        r = free_chain[s];
+        if (r != null) {
+            free_chain[s] = vlink(r);
+#ifdef CHECK_NODE_USAGE
+            varmem_sizes[r] = (char) s;
+#endif
+            vlink(r) = null;
+            /*tex Maintain usage statistics. */
+            var_used += s;
+            return r;
+        }
+        /*tex This is the end of the \quote {inner loop}. */
+        return slow_get_node(s);
+    } else {
+        normal_error("nodes","there is a problem in getting a node, case 1");
+        return null;
+    }
+}
+
+void free_node(halfword p, int s)
+{
+    if (p <= my_prealloc) {
+        formatted_error("nodes", "node number %d of type %d should not be freed", (int) p, type(p));
+        return;
+    }
+#ifdef CHECK_NODE_USAGE
+    varmem_sizes[p] = 0;
+#endif
+    if (s < MAX_CHAIN_SIZE) {
+        vlink(p) = free_chain[s];
+        free_chain[s] = p;
+    } else {
+        /*tex Todo: it is perhaps possible to merge this node with an existing rover? */
+        node_size(p) = s;
+        vlink(p) = rover;
+        while (vlink(rover) != vlink(p)) {
+            rover = vlink(rover);
+        }
+        vlink(rover) = p;
+    }
+    /*tex Maintain statistics. */
+    var_used -= s;
+}
+
+static void free_node_chain(halfword q, int s)
+{
+    register halfword p = q;
+    while (vlink(p) != null) {
+#ifdef CHECK_NODE_USAGE
+        varmem_sizes[p] = 0;
+#endif
+        var_used -= s;
+        p = vlink(p);
+    }
+    var_used -= s;
+#ifdef CHECK_NODE_USAGE
+    varmem_sizes[p] = 0;
+#endif
+    vlink(p) = free_chain[s];
+    free_chain[s] = q;
+}
+
+/*tex
+
+    At the start of the node memory area we reserve some special nodes, for
+    instance frequently used glue specifications. We could as well just use
+    new_glue here but for the moment we stick to the traditional approach.
+
+*/
+
+#define initialize_glue(n,wi,st,sh,sto,sho) \
+    vlink(n) = null; \
+    type(n) = glue_spec_node; \
+    width(n) = wi; \
+    stretch(n) = st; \
+    shrink(n) = sh; \
+    stretch_order(n) = sto; \
+    shrink_order(n) = sho;
+
+#define initialize_whatever(n,t) \
+    vinfo(n) = 0; \
+    type(n) = t; \
+    vlink(n) = null; \
+    alink(n) = null;
+
+#define initialize_point(n) \
+    type(n) = glyph_node; \
+    subtype(n) = 0; \
+    vlink(n) = null; \
+    vinfo(n + 1) = null; \
+    alink(n) = null; \
+    font(n) = 0; \
+    character(n) = '.'; \
+    vinfo(n + 3) = 0; \
+    vlink(n + 3) = 0; \
+    vinfo(n + 4) = 0; \
+    vlink(n + 4) = 0;
+
+void init_node_mem(int t)
+{
+    my_prealloc = var_mem_stat_max;
+
+    varmem = (memory_word *) realloc((void *) varmem, sizeof(memory_word) * (unsigned) t);
+    if (varmem == NULL) {
+        overflow("node memory size", (unsigned) var_mem_max);
+    }
+    memset((void *) (varmem), 0, (unsigned) t * sizeof(memory_word));
+#ifdef CHECK_NODE_USAGE
+    varmem_sizes = (char *) realloc(varmem_sizes, sizeof(char) * (unsigned) t);
+    if (varmem_sizes == NULL) {
+        overflow("node memory size", (unsigned) var_mem_max);
+    }
+    memset((void *) varmem_sizes, 0, sizeof(char) * (unsigned) t);
+#endif
+    var_mem_max = t;
+    rover = var_mem_stat_max + 1;
+    vlink(rover) = rover;
+    node_size(rover) = (t - rover);
+    var_used = 0;
+
+    /*tex Initialize static glue specs. */
+
+    initialize_glue(zero_glue,0,0,0,0,0);
+    initialize_glue(sfi_glue,0,0,0,sfi,0);
+    initialize_glue(fil_glue,0,unity,0,fil,0);
+    initialize_glue(fill_glue,0,unity,0,fill,0);
+    initialize_glue(ss_glue,0,unity,unity,fil,fil);
+    initialize_glue(fil_neg_glue,0,-unity,0,fil,0);
+
+    /*tex Initialize node list heads. */
+
+    initialize_whatever(page_ins_head,temp_node);
+    initialize_whatever(contrib_head,temp_node);
+    initialize_whatever(page_head,temp_node);
+    initialize_whatever(temp_head,temp_node);
+    initialize_whatever(hold_head,temp_node);
+    initialize_whatever(adjust_head,temp_node);
+    initialize_whatever(pre_adjust_head,temp_node);
+    initialize_whatever(align_head,temp_node);
+
+    initialize_whatever(active,unhyphenated_node);
+    initialize_whatever(end_span,span_node);
+
+    initialize_point(begin_point);
+    initialize_point(end_point);
+}
+
+void dump_node_mem(void)
+{
+    dump_int(var_mem_max);
+    dump_int(rover);
+    dump_things(varmem[0], var_mem_max);
+#ifdef CHECK_NODE_USAGE
+    dump_things(varmem_sizes[0], var_mem_max);
+#endif
+    dump_things(free_chain[0], MAX_CHAIN_SIZE);
+    dump_int(var_used);
+    dump_int(my_prealloc);
+}
+
+/*tex
+
+    It makes sense to enlarge the varmem array immediately.
+
+*/
+
+void undump_node_mem(void)
+{
+    int x;
+    undump_int(x);
+    undump_int(rover);
+    var_mem_max = (x < 100000 ? 100000 : x);
+    varmem = xmallocarray(memory_word, (unsigned) var_mem_max);
+    undump_things(varmem[0], x);
+#ifdef CHECK_NODE_USAGE
+    varmem_sizes = xmallocarray(char, (unsigned) var_mem_max);
+    memset((void *) varmem_sizes, 0, (unsigned) var_mem_max * sizeof(char));
+    undump_things(varmem_sizes[0], x);
+#endif
+    undump_things(free_chain[0], MAX_CHAIN_SIZE);
+    undump_int(var_used);
+    undump_int(my_prealloc);
+    if (var_mem_max > x) {
+        /*tex Todo: is it perhaps possible to merge the new node with an existing rover? */
+        vlink(x) = rover;
+        node_size(x) = (var_mem_max - x);
+        while (vlink(rover) != vlink(x)) {
+            rover = vlink(rover);
+        }
+        vlink(rover) = x;
+    }
+}
+
+halfword slow_get_node(int s)
+{
+    register int t;
+
+  RETRY:
+    t = node_size(rover);
+    if (vlink(rover) < var_mem_max && vlink(rover) != 0) {
+        if (t > s) {
+            /*tex Allocating from the bottom helps decrease page faults. */
+            register halfword r = rover;
+            rover += s;
+            vlink(rover) = vlink(r);
+            node_size(rover) = node_size(r) - s;
+            if (vlink(rover) != r) {
+                /*tex The list is longer than one. */
+                halfword q = r;
+                while (vlink(q) != r) {
+                    q = vlink(q);
+                }
+                vlink(q) += s;
+            } else {
+                vlink(rover) += s;
+            }
+            if (vlink(rover) < var_mem_max) {
+#ifdef CHECK_NODE_USAGE
+                varmem_sizes[r] = (char) (s > 127 ? 127 : s);
+#endif
+                vlink(r) = null;
+                /*tex Maintain usage statistics. */
+                var_used += s;
+                /*tex This is the only exit. */
+                return r;
+            } else {
+                normal_error("nodes","there is a problem in getting a node, case 2");
+                return null;
+            }
+        } else {
+            /*tex Attempt to keep the free list small. */
+            int x;
+            if (vlink(rover) != rover) {
+                if (t < MAX_CHAIN_SIZE) {
+                    halfword l = vlink(rover);
+                    vlink(rover) = free_chain[t];
+                    free_chain[t] = rover;
+                    rover = l;
+                    while (vlink(l) != free_chain[t]) {
+                        l = vlink(l);
+                    }
+                    vlink(l) = rover;
+                    goto RETRY;
+                } else {
+                    halfword l = rover;
+                    while (vlink(rover) != l) {
+                        if (node_size(rover) > s) {
+                            goto RETRY;
+                        }
+                        rover = vlink(rover);
+                    }
+                }
+            }
+            /*tex If we are still here, it was apparently impossible to get a match. */
+            x = (var_mem_max >> 2) + s;
+            varmem = (memory_word *) realloc((void *) varmem, sizeof(memory_word) * (unsigned) (var_mem_max + x));
+            if (varmem == NULL) {
+                overflow("node memory size", (unsigned) var_mem_max);
+            }
+            memset((void *) (varmem + var_mem_max), 0, (unsigned) x * sizeof(memory_word));
+#ifdef CHECK_NODE_USAGE
+            varmem_sizes = (char *) realloc(varmem_sizes, sizeof(char) * (unsigned) (var_mem_max + x));
+            if (varmem_sizes == NULL) {
+                overflow("node memory size", (unsigned) var_mem_max);
+            }
+            memset((void *) (varmem_sizes + var_mem_max), 0, (unsigned) (x) * sizeof(char));
+#endif
+            /*tex Todo: is it perhaps possible to merge the new memory with an existing rover? */
+            vlink(var_mem_max) = rover;
+            node_size(var_mem_max) = x;
+            while (vlink(rover) != vlink(var_mem_max)) {
+                rover = vlink(rover);
+            }
+            vlink(rover) = var_mem_max;
+            rover = var_mem_max;
+            var_mem_max += x;
+            goto RETRY;
+        }
+    } else {
+        normal_error("nodes","there is a problem in getting a node, case 3");
+        return null;
+    }
+}
+
+char *sprint_node_mem_usage(void)
+{
+    char *s;
+#ifdef CHECK_NODE_USAGE
+    char *ss;
+    int i;
+    int b = 0;
+    char msg[256];
+    int node_counts[last_normal_node + last_whatsit_node + 2] = { 0 };
+    s = strdup("");
+    for (i = (var_mem_max - 1); i > my_prealloc; i--) {
+        if (varmem_sizes[i] > 0) {
+            if (type(i) > last_normal_node + last_whatsit_node) {
+                node_counts[last_normal_node + last_whatsit_node + 1]++;
+            } else if (type(i) == whatsit_node) {
+                node_counts[(subtype(i) + last_normal_node + 1)]++;
+            } else {
+                node_counts[type(i)]++;
+            }
+        }
+    }
+    for (i = 0; i < last_normal_node + last_whatsit_node + 2; i++) {
+        if (node_counts[i] > 0) {
+            int j =
+                (i > (last_normal_node + 1) ? (i - last_normal_node - 1) : 0);
+            snprintf(msg, 255, "%s%d %s", (b ? ", " : ""), (int) node_counts[i],
+                     get_node_name((i > last_normal_node ? whatsit_node : i), j));
+            ss = xmalloc((unsigned) (strlen(s) + strlen(msg) + 1));
+            strcpy(ss, s);
+            strcat(ss, msg);
+            free(s);
+            s = ss;
+            b = 1;
+        }
+    }
+#else
+    s = strdup("");
+#endif
+    return s;
+}
+
+halfword list_node_mem_usage(void)
+{
+    halfword q = null;
+#ifdef CHECK_NODE_USAGE
+    halfword p = null;
+    halfword i, j;
+    char *saved_varmem_sizes = xmallocarray(char, (unsigned) var_mem_max);
+    memcpy(saved_varmem_sizes, varmem_sizes, (size_t) var_mem_max);
+    for (i = my_prealloc + 1; i < (var_mem_max - 1); i++) {
+        if (saved_varmem_sizes[i] > 0) {
+            j = copy_node(i);
+            if (p == null) {
+                q = j;
+            } else {
+                vlink(p) = j;
+            }
+            p = j;
+        }
+    }
+    free(saved_varmem_sizes);
+#endif
+    return q;
+}
+
+void print_node_mem_stats(void)
+{
+    int i, b;
+    halfword j;
+    char msg[256];
+    char *s;
+    int free_chain_counts[MAX_CHAIN_SIZE] = { 0 };
+    snprintf(msg, 255, " %d words of node memory still in use:", (int) (var_used + my_prealloc));
+    tprint_nl(msg);
+    s = sprint_node_mem_usage();
+    tprint_nl("   ");
+    tprint(s);
+    free(s);
+    tprint(" nodes");
+    tprint_nl("   avail lists: ");
+    b = 0;
+    for (i = 1; i < MAX_CHAIN_SIZE; i++) {
+        for (j = free_chain[i]; j != null; j = vlink(j))
+            free_chain_counts[i]++;
+        if (free_chain_counts[i] > 0) {
+            snprintf(msg, 255, "%s%d:%d", (b ? "," : ""), i, (int) free_chain_counts[i]);
+            tprint(msg);
+            b = 1;
+        }
+    }
+    /*tex A newline, if needed: */
+    print_nlp();
+}
+
+halfword new_span_node(halfword n, int s, scaled w)
+{
+    halfword p = new_node(span_node, 0);
+    span_link(p) = n;
+    span_span(p) = s;
+    width(p) = w;
+    return p;
+}
+
+/* Now comes some attribute stuff. */
+
+static halfword new_attribute_node(unsigned int i, int v)
+{
+    register halfword r = get_node(attribute_node_size);
+    type(r) = attribute_node;
+    attribute_id(r) = (halfword) i;
+    attribute_value(r) = v;
+    /* not used but nicer in print */
+    subtype(r) = 0;
+    return r;
+}
+
+halfword copy_attribute_list(halfword n)
+{
+    halfword q = get_node(attribute_node_size);
+    register halfword p = q;
+    type(p) = attribute_list_node;
+    attr_list_ref(p) = 0;
+    n = vlink(n);
+    while (n != null) {
+        register halfword r = get_node(attribute_node_size);
+        /*tex The link will be fixed automatically in the next loop. */
+        (void) memcpy((void *) (varmem + r), (void *) (varmem + n), (sizeof(memory_word) * attribute_node_size));
+        vlink(p) = r;
+        p = r;
+        n = vlink(n);
+    }
+    return q;
+}
+
+void update_attribute_cache(void)
+{
+    halfword p;
+    register int i;
+    attr_list_cache = get_node(attribute_node_size);
+    type(attr_list_cache) = attribute_list_node;
+    attr_list_ref(attr_list_cache) = 0;
+    p = attr_list_cache;
+    for (i = 0; i <= max_used_attr; i++) {
+        register int v = attribute(i);
+        if (v > UNUSED_ATTRIBUTE) {
+            register halfword r = new_attribute_node((unsigned) i, v);
+            vlink(p) = r;
+            p = r;
+        }
+    }
+    if (vlink(attr_list_cache) == null) {
+        free_node(attr_list_cache, attribute_node_size);
+        attr_list_cache = null;
+    }
+    return;
+}
+
+void build_attribute_list(halfword b)
+{
+    if (max_used_attr >= 0) {
+        if (attr_list_cache == cache_disabled|| attr_list_cache == null) {
+            update_attribute_cache();
+            if (attr_list_cache == null)
+                return;
+        }
+        attr_list_ref(attr_list_cache)++;
+        node_attr(b) = attr_list_cache;
+    }
+}
+
+halfword current_attribute_list(void)
+{
+    if (max_used_attr >= 0) {
+      if (attr_list_cache == cache_disabled) {
+            update_attribute_cache();
+      }
+      return attr_list_cache ;
+    }
+    return null ;
+}
+
+void reassign_attribute(halfword n, halfword new)
+{
+    halfword old;
+    old = node_attr(n);
+    if (new == null) {
+        /*tex There is nothing to assign but we need to check for an old value. */
+        if (old != null) {
+            /*tex This also nulls |attr| field of |n|. */
+            delete_attribute_ref(old);
+        }
+    } else if (old == null) {
+        /*tex Nothing is assigned so we just do that now. */
+        assign_attribute_ref(n,new);
+    } else if (old != new) {
+        /*tex Something is assigned so we need to clean up and assign then. */
+        delete_attribute_ref(old);
+        assign_attribute_ref(n,new);
+    }
+    /*tex The same value so there is no need to assign and change the refcount. */
+    node_attr(n) = new ;
+}
+
+void delete_attribute_ref(halfword b)
+{
+    if (b != null) {
+        if (type(b) == attribute_list_node){
+            attr_list_ref(b)--;
+            if (attr_list_ref(b) == 0) {
+                if (b == attr_list_cache)
+                    attr_list_cache = cache_disabled;
+                free_node_chain(b, attribute_node_size);
+            }
+            /*tex Maintain sanity. */
+            if (attr_list_ref(b) < 0) {
+                attr_list_ref(b) = 0;
+            }
+        } else {
+            normal_error("nodes","trying to delete an attribute reference of a non attribute node");
+        }
+    }
+}
+
+void reset_node_properties(halfword b)
+{
+    if (b != null) {
+        lua_properties_reset(b);
+    }
+}
+
+/*tex Here |p| is an attr list head, or zero. */
+
+halfword do_set_attribute(halfword p, int i, int val)
+{
+    register halfword q;
+    register int j = 0;
+    if (p == null) {
+        /*tex Add a new head \& node. */
+        q = get_node(attribute_node_size);
+        type(q) = attribute_list_node;
+        attr_list_ref(q) = 1;
+        p = new_attribute_node((unsigned) i, val);
+        vlink(q) = p;
+        return q;
+    }
+    q = p;
+    if (vlink(p) != null) {
+        while (vlink(p) != null) {
+            int t = attribute_id(vlink(p));
+            if (t == i && attribute_value(vlink(p)) == val) {
+                /*tex There is no need to do anything. */
+                return q;
+            }
+            if (t >= i)
+                break;
+            j++;
+            p = vlink(p);
+        }
+        p = q;
+        while (j-- > 0)
+            p = vlink(p);
+        if (attribute_id(vlink(p)) == i) {
+            attribute_value(vlink(p)) = val;
+        } else {
+            /*tex Add a new node. */
+            halfword r = new_attribute_node((unsigned) i, val);
+            vlink(r) = vlink(p);
+            vlink(p) = r;
+        }
+        return q;
+    } else {
+        normal_error("nodes","trying to set an attribute fails, case 1");
+        return null ;
+    }
+}
+
+void set_attribute(halfword n, int i, int val)
+{
+    register halfword p;
+    register int j = 0;
+    /*tex Not all nodes can have an attribute list. */
+    if (!nodetype_has_attributes(type(n)))
+        return;
+    /*tex If we have no list, we create one and quit. */
+    p = node_attr(n);
+    if (p == null) {            /* add a new head \& node */
+        p = get_node(attribute_node_size);
+        type(p) = attribute_list_node;
+        attr_list_ref(p) = 1;
+        node_attr(n) = p;
+        p = new_attribute_node((unsigned) i, val);
+        vlink(node_attr(n)) = p;
+        return;
+    }
+    /*tex We check if we have this attribute already and quit if the value stays the same. */
+    if (vlink(p) != null) {
+        while (vlink(p) != null) {
+            int t = attribute_id(vlink(p));
+            if (t == i && attribute_value(vlink(p)) == val)
+                return;
+            if (t >= i)
+                break;
+            j++;
+            p = vlink(p);
+        }
+        /*tex If found |j| has now the position and we assume a sorted list ! */
+        p = node_attr(n);
+        if (attr_list_ref(p) == 0 ) {
+            /*tex The list is invalid i.e. freed already. */
+            formatted_warning("nodes","node %d has an attribute list that is free already, case 1",(int) n);
+            /*tex The still dangling list gets ref count 1. */
+            attr_list_ref(p) = 1;
+        } else if (attr_list_ref(p) == 1) {
+            /*tex This can really happen! */
+            if (p == attr_list_cache) {
+                /*tex
+
+                    We can invalidate the cache setting with |attr_list_cache =
+                    cache_disabled| or or save the list, as done below.
+
+                */
+                p = copy_attribute_list(p);
+                node_attr(n) = p;
+                /*tex The copied list gets ref count 1. */
+                attr_list_ref(p) = 1;
+            }
+        } else {
+            /*tex The list is used multiple times so we make a copy. */
+            p = copy_attribute_list(p);
+            /*tex We decrement the ref count or the original. */
+            delete_attribute_ref(node_attr(n));
+            node_attr(n) = p;
+            /*tex The copied list gets ref count 1. */
+            attr_list_ref(p) = 1;
+        }
+        /*tex We go to position |j| in the list. */
+        while (j-- > 0)
+            p = vlink(p);
+        /*tex If we have a hit we just set the value otherwise we add a new node. */
+        if (attribute_id(vlink(p)) == i) {
+            attribute_value(vlink(p)) = val;
+        } else {
+            /*tex Add a new node. */
+            halfword r = new_attribute_node((unsigned) i, val);
+            vlink(r) = vlink(p);
+            vlink(p) = r;
+        }
+    } else {
+        normal_error("nodes","trying to set an attribute fails, case 2");
+    }
+}
+
+int unset_attribute(halfword n, int i, int val)
+{
+    register halfword p;
+    register int t;
+    register int j = 0;
+    if (!nodetype_has_attributes(type(n)))
+        return null;
+    p = node_attr(n);
+    if (p == null)
+        return UNUSED_ATTRIBUTE;
+    if (attr_list_ref(p) == 0) {
+        formatted_warning("nodes","node %d has an attribute list that is free already, case 2", (int) n);
+        return UNUSED_ATTRIBUTE;
+    }
+    if (vlink(p) != null) {
+        while (vlink(p) != null) {
+            t = attribute_id(vlink(p));
+            if (t > i)
+                return UNUSED_ATTRIBUTE;
+            if (t == i) {
+                p = vlink(p);
+                break;
+            }
+            j++;
+            p = vlink(p);
+        }
+        if (attribute_id(p) != i)
+            return UNUSED_ATTRIBUTE;
+        /*tex If we are still here, the attribute exists. */
+        p = node_attr(n);
+        if (attr_list_ref(p) > 1 || p == attr_list_cache) {
+            halfword q = copy_attribute_list(p);
+            if (attr_list_ref(p) > 1) {
+                delete_attribute_ref(node_attr(n));
+            }
+            attr_list_ref(q) = 1;
+            node_attr(n) = q;
+        }
+        p = vlink(node_attr(n));
+        while (j-- > 0)
+            p = vlink(p);
+        t = attribute_value(p);
+        if (val == UNUSED_ATTRIBUTE || t == val) {
+            attribute_value(p) = UNUSED_ATTRIBUTE;
+        }
+        return t;
+    } else {
+        normal_error("nodes","trying to unset an attribute fails");
+        return null;
+    }
+}
+
+int has_attribute(halfword n, int i, int val)
+{
+    register halfword p;
+    if (!nodetype_has_attributes(type(n)))
+        return UNUSED_ATTRIBUTE;
+    p = node_attr(n);
+    if (p == null || vlink(p) == null)
+        return UNUSED_ATTRIBUTE;
+    p = vlink(p);
+    while (p != null) {
+        if (attribute_id(p) == i) {
+            int ret = attribute_value(p);
+            if (val == UNUSED_ATTRIBUTE || val == ret)
+                return ret;
+            return UNUSED_ATTRIBUTE;
+        } else if (attribute_id(p) > i) {
+            return UNUSED_ATTRIBUTE;
+        }
+        p = vlink(p);
+    }
+    return UNUSED_ATTRIBUTE;
+}
+
+void print_short_node_contents(halfword p)
+{
+    switch (type(p)) {
+        case hlist_node:
+        case vlist_node:
+        case ins_node:
+        case whatsit_node:
+        case mark_node:
+        case adjust_node:
+        case unset_node:
+            print_char('[');
+            print_char(']');
+            break;
+        case rule_node:
+            print_char('|');
+            break;
+        case glue_node:
+            if (! glue_is_zero(p))
+                print_char(' ');
+            break;
+        case math_node:
+            print_char('$');
+            break;
+        case disc_node:
+            short_display(vlink(pre_break(p)));
+            short_display(vlink(post_break(p)));
+            break;
+    }
+}
+
+static void show_pdftex_whatsit_rule_spec(int p)
+{
+    tprint("(");
+    print_rule_dimen(height(p));
+    print_char('+');
+    print_rule_dimen(depth(p));
+    tprint(")x");
+    print_rule_dimen(width(p));
+}
+
+/*tex
+
+    Each new type of node that appears in our data structure must be capable of
+    being displayed, copied, destroyed, and so on. The routines that we need for
+    write-oriented whatsits are somewhat like those for mark nodes; other
+    extensions might, of course, involve more subtlety here.
+
+*/
+
+static void print_write_whatsit(const char *s, pointer p)
+{
+    tprint_esc(s);
+    if (write_stream(p) < 16)
+        print_int(write_stream(p));
+    else if (write_stream(p) == 16)
+        print_char('*');
+    else
+        print_char('-');
+}
+
+static void show_node_wrapup_core(int p)
+{
+    switch (subtype(p)) {
+        case open_node:
+            print_write_whatsit("openout", p);
+            print_char('=');
+            print_file_name(open_name(p), open_area(p), open_ext(p));
+            break;
+        case write_node:
+            print_write_whatsit("write", p);
+            print_mark(write_tokens(p));
+            break;
+        case close_node:
+            print_write_whatsit("closeout", p);
+            break;
+        case special_node:
+            tprint_esc("special");
+            print_mark(write_tokens(p));
+            break;
+        case late_lua_node:
+            show_late_lua(p);
+            break;
+        case save_pos_node:
+            tprint_esc("savepos");
+            break;
+        case user_defined_node:
+            tprint_esc("whatsit");
+            print_int(user_node_id(p));
+            print_char('=');
+            switch (user_node_type(p)) {
+            case 'a':
+                tprint("<>");
+                break;
+            case 'n':
+                tprint("[");
+                show_node_list(user_node_value(p));
+                tprint("]");
+                break;
+            case 's':
+                print_char('"');
+                print(user_node_value(p));
+                print_char('"');
+                break;
+            case 't':
+                print_mark(user_node_value(p));
+                break;
+            default:               /* only 'd' */
+                print_int(user_node_value(p));
+                break;
+            }
+            break;
+    }
+}
+
+void show_node_wrapup_dvi(int p)
+{
+}
+
+void show_node_wrapup_pdf(int p)
+{
+    switch (subtype(p)) {
+        case pdf_literal_node:
+            show_pdf_literal(p);
+            break;
+        case pdf_colorstack_node:
+            tprint_esc("pdfcolorstack ");
+            print_int(pdf_colorstack_stack(p));
+            switch (pdf_colorstack_cmd(p)) {
+            case colorstack_set:
+                tprint(" set ");
+                break;
+            case colorstack_push:
+                tprint(" push ");
+                break;
+            case colorstack_pop:
+                tprint(" pop");
+                break;
+            case colorstack_current:
+                tprint(" current");
+                break;
+            default:
+                confusion("colorstack");
+                break;
+            }
+            if (pdf_colorstack_cmd(p) <= colorstack_data)
+                print_mark(pdf_colorstack_data(p));
+            break;
+        case pdf_setmatrix_node:
+            tprint_esc("pdfsetmatrix");
+            print_mark(pdf_setmatrix_data(p));
+            break;
+        case pdf_save_node:
+            tprint_esc("pdfsave");
+            break;
+        case pdf_restore_node:
+            tprint_esc("pdfrestore");
+            break;
+        case pdf_refobj_node:
+            tprint_esc("pdfrefobj");
+            if (obj_obj_is_stream(static_pdf, pdf_obj_objnum(p))) {
+                if (obj_obj_stream_attr(static_pdf, pdf_obj_objnum(p)) != LUA_NOREF) {
+                    tprint(" attr");
+                    lua_rawgeti(Luas, LUA_REGISTRYINDEX, obj_obj_stream_attr(static_pdf, pdf_obj_objnum(p)));
+                    print_char(' ');
+                    tprint((const char *) lua_tostring(Luas, -1));
+                    lua_pop(Luas, 1);
+                }
+                tprint(" stream");
+            }
+            if (obj_obj_is_file(static_pdf, pdf_obj_objnum(p)))
+                tprint(" file");
+            if (obj_obj_data(static_pdf, pdf_obj_objnum(p)) != LUA_NOREF) {
+                lua_rawgeti(Luas, LUA_REGISTRYINDEX, obj_obj_data(static_pdf, pdf_obj_objnum(p)));
+                print_char(' ');
+                tprint((const char *) lua_tostring(Luas, -1));
+                lua_pop(Luas, 1);
+            }
+            break;
+        case pdf_annot_node:
+            tprint_esc("pdfannot");
+            show_pdftex_whatsit_rule_spec(p);
+            print_mark(pdf_annot_data(p));
+            break;
+        case pdf_start_link_node:
+            tprint_esc("pdfstartlink");
+            show_pdftex_whatsit_rule_spec(p);
+            if (pdf_link_attr(p) != null) {
+                tprint(" attr");
+                print_mark(pdf_link_attr(p));
+            }
+            tprint(" action");
+            if (pdf_action_type(pdf_link_action(p)) == pdf_action_user) {
+                tprint(" user");
+                print_mark(pdf_action_tokens(pdf_link_action(p)));
+                return;
+            }
+            if (pdf_action_file(pdf_link_action(p)) != null) {
+                tprint(" file");
+                print_mark(pdf_action_file(pdf_link_action(p)));
+            }
+            switch (pdf_action_type(pdf_link_action(p))) {
+            case pdf_action_goto:
+                if (pdf_action_named_id(pdf_link_action(p)) > 0) {
+                    tprint(" goto name");
+                    print_mark(pdf_action_id(pdf_link_action(p)));
+                } else {
+                    tprint(" goto num");
+                    print_int(pdf_action_id(pdf_link_action(p)));
+                }
+                break;
+            case pdf_action_page:
+                tprint(" page");
+                print_int(pdf_action_id(pdf_link_action(p)));
+                print_mark(pdf_action_tokens(pdf_link_action(p)));
+                break;
+            case pdf_action_thread:
+                if (pdf_action_named_id(pdf_link_action(p)) > 0) {
+                    tprint(" thread name");
+                    print_mark(pdf_action_id(pdf_link_action(p)));
+                } else {
+                    tprint(" thread num");
+                    print_int(pdf_action_id(pdf_link_action(p)));
+                }
+                break;
+            default:
+                normal_error("pdf backend", "unknown action type for link");
+                break;
+            }
+            break;
+        case pdf_end_link_node:
+            tprint_esc("pdfendlink");
+            break;
+        case pdf_dest_node:
+            tprint_esc("pdfdest");
+            if (pdf_dest_named_id(p) > 0) {
+                tprint(" name");
+                print_mark(pdf_dest_id(p));
+            } else {
+                tprint(" num");
+                print_int(pdf_dest_id(p));
+            }
+            print_char(' ');
+            switch (pdf_dest_type(p)) {
+            case pdf_dest_xyz:
+                tprint("xyz");
+                if (pdf_dest_xyz_zoom(p) != null) {
+                    tprint(" zoom");
+                    print_int(pdf_dest_xyz_zoom(p));
+                }
+                break;
+            case pdf_dest_fitbh:
+                tprint("fitbh");
+                break;
+            case pdf_dest_fitbv:
+                tprint("fitbv");
+                break;
+            case pdf_dest_fitb:
+                tprint("fitb");
+                break;
+            case pdf_dest_fith:
+                tprint("fith");
+                break;
+            case pdf_dest_fitv:
+                tprint("fitv");
+                break;
+            case pdf_dest_fitr:
+                tprint("fitr");
+                show_pdftex_whatsit_rule_spec(p);
+                break;
+            case pdf_dest_fit:
+                tprint("fit");
+                break;
+            default:
+                tprint("unknown!");
+                break;
+            }
+            break;
+        case pdf_thread_node:
+        case pdf_start_thread_node:
+            if (subtype(p) == pdf_thread_node)
+                tprint_esc("pdfthread");
+            else
+                tprint_esc("pdfstartthread");
+            tprint("(");
+            print_rule_dimen(height(p));
+            print_char('+');
+            print_rule_dimen(depth(p));
+            tprint(")x");
+            print_rule_dimen(width(p));
+            if (pdf_thread_attr(p) != null) {
+                tprint(" attr");
+                print_mark(pdf_thread_attr(p));
+            }
+            if (pdf_thread_named_id(p) > 0) {
+                tprint(" name");
+                print_mark(pdf_thread_id(p));
+            } else {
+                tprint(" num");
+                print_int(pdf_thread_id(p));
+            }
+            break;
+        case pdf_end_thread_node:
+            tprint_esc("pdfendthread");
+            break;
+        default:
+            break;
+    }
+}
+
+/*tex
+
+    Now we are ready for |show_node_list| itself. This procedure has been written
+    to be ``extra robust'' in the sense that it should not crash or get into a
+    loop even if the data structures have been messed up by bugs in the rest of
+    the program. You can safely call its parent routine |show_box(p)| for
+    arbitrary values of |p| when you are debugging \TeX. However, in the presence
+    of bad data, the procedure may fetch a |memory_word| whose variant is
+    different from the way it was stored; for example, it might try to read
+    |mem[p].hh| when |mem[p]| contains a scaled integer, if |p| is a pointer that
+    has been clobbered or chosen at random.
+
+*/
+
+#define node_list_display(A) do { \
+    append_char('.');  \
+    show_node_list(A); \
+    flush_char();      \
+} while (0)
+
+#define node_list_display_x(A,B) do { \
+    if ((B) != null) {     \
+        append_char('.');  \
+        append_char(A);    \
+        append_char(' ');  \
+        show_node_list(B); \
+        flush_char();      \
+        flush_char();      \
+        flush_char();      \
+    } \
+} while (0)
+
+/*tex Print a node list symbolically: */
+
+void show_node_list(int p)
+{
+    /*tex The number of items already printed at this level: */
+    int n = 0;
+    halfword w;
+    /*tex A glue ratio, as a floating point number: */
+    real g;
+    if ((int) cur_length > depth_threshold) {
+        if (p > null) {
+            /*tex Indicate that there's been some truncation. */
+            tprint(" []");
+        }
+        return;
+    }
+    while (p != null) {
+        print_ln();
+        print_current_string();
+        /*tex Display the nesting history. */
+        if (tracing_online_par < -2)
+            print_int(p);
+        incr(n);
+        if (n > breadth_max) {
+            /*tex Time to stop. */
+            tprint("etc.");
+            return;
+        }
+        /*tex Display node |p|. */
+        if (is_char_node(p)) {
+            print_font_and_char(p);
+            if (is_ligature(p)) {
+                /*tex Display ligature |p|. */
+                tprint(" (ligature ");
+                if (is_leftboundary(p))
+                    print_char('|');
+                font_in_short_display = font(p);
+                short_display(lig_ptr(p));
+                if (is_rightboundary(p))
+                    print_char('|');
+                print_char(')');
+            }
+        } else {
+            switch (type(p)) {
+                case hlist_node:
+                case vlist_node:
+                case unset_node:
+                    /*tex Display box |p|. */
+                    if (type(p) == hlist_node)
+                        tprint_esc("h");
+                    else if (type(p) == vlist_node)
+                        tprint_esc("v");
+                    else
+                        tprint_esc("unset");
+                    tprint("box(");
+                    print_scaled(height(p));
+                    print_char('+');
+                    print_scaled(depth(p));
+                    tprint(")x");
+                    print_scaled(width(p));
+                    if (type(p) == unset_node) {
+                        /*tex Display special fields of the unset node |p|. */
+                        if (span_count(p) != min_quarterword) {
+                            tprint(" (");
+                            print_int(span_count(p) + 1);
+                            tprint(" columns)");
+                        }
+                        if (glue_stretch(p) != 0) {
+                            tprint(", stretch ");
+                            print_glue(glue_stretch(p), glue_order(p), NULL);
+                        }
+                        if (glue_shrink(p) != 0) {
+                            tprint(", shrink ");
+                            print_glue(glue_shrink(p), glue_sign(p), NULL);
+                        }
+                    } else {
+                        /*tex
+
+                            Display the value of |glue_set(p)|. The code will
+                            have to change in this place if |glue_ratio| is a
+                            structured type instead of an ordinary |real|. Note
+                            that this routine should avoid arithmetic errors even
+                            if the |glue_set| field holds an arbitrary random
+                            value. The following code assumes that a properly
+                            formed nonzero |real| number has absolute value
+                            $2^{20}$ or more when it is regarded as an integer;
+                            this precaution was adequate to prevent floating
+                            point underflow on the author's computer.
+
+                        */
+                        g = (real) (glue_set(p));
+                        if ((g != 0.0) && (glue_sign(p) != normal)) {
+                            tprint(", glue set ");
+                            if (glue_sign(p) == shrinking)
+                                tprint("- ");
+                            if (g > 20000.0 || g < -20000.0) {
+                                if (g > 0.0)
+                                    print_char('>');
+                                else
+                                    tprint("< -");
+                                print_glue(20000 * unity, glue_order(p), NULL);
+                            } else {
+                                print_glue(round(unity * g), glue_order(p), NULL);
+                            }
+                        }
+                        if (shift_amount(p) != 0) {
+                            tprint(", shifted ");
+                            print_scaled(shift_amount(p));
+                        }
+                        tprint(", direction ");
+                        print_dir_par(box_dir(p));
+                    }
+                    /*tex Recursive call: */
+                    node_list_display(list_ptr(p));
+                    break;
+                case rule_node:
+                    /*tex Display rule |p|. */
+                    if (subtype(p) == normal_rule) {
+                        tprint_esc("rule(");
+                    } else if (subtype(p) == empty_rule) {
+                        tprint_esc("norule(");
+                    } else if (subtype(p) == user_rule) {
+                        tprint_esc("userrule(");
+                    } else if (subtype(p) == box_rule) {
+                        tprint_esc("box(");
+                    } else if (subtype(p) == image_rule) {
+                        tprint_esc("image(");
+                    }
+                    print_rule_dimen(height(p));
+                    print_char('+');
+                    print_rule_dimen(depth(p));
+                    tprint(")x");
+                    print_rule_dimen(width(p));
+                    break;
+                case ins_node:
+                    /*tex Display insertion |p|. */
+                    tprint_esc("insert");
+                    print_int(subtype(p));
+                    tprint(", natural size ");
+                    print_scaled(height(p));
+                    tprint("; split(");
+                    print_spec(split_top_ptr(p), NULL);
+                    print_char(',');
+                    print_scaled(depth(p));
+                    tprint("); float cost ");
+                    print_int(float_cost(p));
+                    /*tex Recursive call. */
+                    node_list_display(ins_ptr(p));
+                    break;
+                case dir_node:
+                    if (subtype(p) == cancel_dir) {
+                        tprint_esc("enddir");
+                    } else {
+                        tprint_esc("begindir");
+                    }
+                    print_char(' ');
+                    print_dir_par(dir_dir(p));
+                    break;
+                case local_par_node:
+                    tprint_esc("localpar");
+                    append_char('.');
+                    print_ln();
+                    print_current_string();
+                    tprint_esc("localinterlinepenalty");
+                    print_char('=');
+                    print_int(local_pen_inter(p));
+                    print_ln();
+                    print_current_string();
+                    tprint_esc("localbrokenpenalty");
+                    print_char('=');
+                    print_int(local_pen_broken(p));
+                    print_ln();
+                    print_current_string();
+                    tprint_esc("localleftbox");
+                    if (local_box_left(p) == null) {
+                        tprint("=null");
+                    } else {
+                        append_char('.');
+                        show_node_list(local_box_left(p));
+                        decr(cur_length);
+                    }
+                    print_ln();
+                    print_current_string();
+                    tprint_esc("localrightbox");
+                    if (local_box_right(p) == null) {
+                        tprint("=null");
+                    } else {
+                        append_char('.');
+                        show_node_list(local_box_right(p));
+                        decr(cur_length);
+                    }
+                    decr(cur_length);
+                    break;
+                case boundary_node:
+                    if (subtype(p)==0) {
+                        tprint_esc("noboundary");
+                    } else {
+                        switch (subtype(p)) {
+                            case 1:
+                                tprint_esc("boundary");
+                                break;
+                            case 2:
+                                tprint_esc("protrusionboundary");
+                                break;
+                            case 3:
+                                tprint_esc("wordboundary");
+                                break;
+                            default:
+                                tprint_esc("boundary");
+                                print_char(':');
+                                print_int(subtype(p));
+                                break;
+                        }
+                        print_char('=');
+                        print_int(boundary_value(p));
+                    }
+                    break;
+                case whatsit_node:
+                    w = subtype(p) ;
+                    if (w >= backend_first_pdf_whatsit) {
+                        show_node_wrapup_pdf(p);
+                    } else if (w >= backend_first_dvi_whatsit) {
+                        show_node_wrapup_dvi(p);
+                    } else {
+                        show_node_wrapup_core(p);
+                    }
+                    break;
+                case glue_node:
+                    /*tex Display glue |p|. */
+                    if (subtype(p) >= a_leaders) {
+                        /*tex Display leaders |p|. */
+                        tprint_esc("");
+                        switch (subtype(p)) {
+                        case a_leaders:
+                            break;
+                        case c_leaders:
+                            print_char('c');
+                            break;
+                        case x_leaders:
+                            print_char('x');
+                            break;
+                        case g_leaders:
+                            print_char('g');
+                            break;
+                        default:
+                            normal_warning("nodes","weird glue leader subtype ignored");
+                        }
+                        tprint("leaders ");
+                        print_spec(p, NULL);
+                        /*tex Recursive call: */
+                        node_list_display(leader_ptr(p));
+                    } else {
+                        tprint_esc("glue");
+                        if (subtype(p) != normal) {
+                            print_char('(');
+                            if ((subtype(p) - 1) < thin_mu_skip_code) {
+                                print_cmd_chr(assign_glue_cmd, glue_base + (subtype(p) - 1));
+                            } else if (subtype(p) < cond_math_glue) {
+                                print_cmd_chr(assign_mu_glue_cmd, glue_base + (subtype(p) - 1));
+                            } else if (subtype(p) == cond_math_glue) {
+                                tprint_esc("nonscript");
+                            } else {
+                                tprint_esc("mskip");
+                            }
+                            print_char(')');
+                        }
+                        if (subtype(p) != cond_math_glue) {
+                            print_char(' ');
+                            if (subtype(p) < cond_math_glue)
+                                print_spec(p, NULL);
+                            else
+                                print_spec(p, "mu");
+                        }
+                    }
+                    break;
+                case margin_kern_node:
+                    tprint_esc("kern");
+                    print_scaled(width(p));
+                    if (subtype(p) == left_side)
+                        tprint(" (left margin)");
+                    else
+                        tprint(" (right margin)");
+                    break;
+                case kern_node:
+                    /*tex Display kern |p| */
+                    if (subtype(p) != mu_glue) {
+                        tprint_esc("kern");
+                        /*tex
+
+                        \starttyping
+                        if (subtype(p) != normal) {
+                            print_char(' ');
+                        }
+                        \stoptyping
+
+                        */
+                        print_scaled(width(p));
+                        if (subtype(p) == font_kern)
+                            tprint(" (font)");
+                        else if (subtype(p) == italic_kern)
+                            tprint(" (italic)");
+                        else if (subtype(p) == accent_kern)
+                            tprint(" (accent)");
+                    } else {
+                        tprint_esc("mkern");
+                        print_scaled(width(p));
+                        tprint("mu");
+                    }
+                    break;
+                case math_node:
+                    /*tex Display math node |p|. */
+                    tprint_esc("math");
+                    if (subtype(p) == before)
+                        tprint("on");
+                    else
+                        tprint("off");
+                    if (!glue_is_zero(p)) {
+                        tprint(", glued ");
+                        print_spec(p, NULL);
+                    } else if (surround(p) != 0) {
+                        tprint(", surrounded ");
+                        print_scaled(surround(p));
+                    }
+                    break;
+                case penalty_node:
+                    /*tex Display penalty |p|. */
+                    tprint_esc("penalty ");
+                    print_int(penalty(p));
+                    break;
+                case disc_node:
+                    /*tex
+
+                        Display discretionary |p|. The |post_break| list of a
+                        discretionary node is indicated by a prefixed
+                        `\.{\char'174}' instead of the `\..' before the
+                        |pre_break| list.
+
+                        We're not compatible anyway  so ...
+
+                        \starttyping
+                        tprint_esc("discretionary");
+                        print_int(disc_penalty(p));
+                        print_char('|');
+                        if (vlink(no_break(p)) != null) {
+                            tprint(" replacing ");
+                            node_list_display(vlink(no_break(p)));
+                        }
+                        node_list_display(vlink(pre_break(p)));
+                        append_char('|');
+                        show_node_list(vlink(post_break(p)));
+                        flush_char();
+                        \stoptyping
+
+                        has become:
+
+                    */
+                    tprint_esc("discretionary");
+                    tprint(" (penalty ");
+                    print_int(disc_penalty(p));
+                    print_char(')');
+                    node_list_display_x('<',vlink(pre_break(p)));
+                    node_list_display_x('>',vlink(post_break(p)));
+                    node_list_display_x('=',vlink(no_break(p)));
+                    break;
+                case mark_node:
+                    /*tex Display mark |p|. */
+                    tprint_esc("mark");
+                    if (mark_class(p) != 0) {
+                        print_char('s');
+                        print_int(mark_class(p));
+                    }
+                    print_mark(mark_ptr(p));
+                    break;
+                case adjust_node:
+                    /*tex Display adjustment |p|. */
+                    tprint_esc("vadjust");
+                    if (subtype(p) != 0)
+                        tprint(" pre ");
+                    /*tex Recursive call. */
+                    node_list_display(adjust_ptr(p));
+                    break;
+                case glue_spec_node:
+                    tprint("<glue_spec ");
+                    print_spec(p, NULL);
+                    tprint(">");
+                    break;
+                default:
+                    show_math_node(p);
+                    break;
+            }
+        }
+        p = vlink(p);
+    }
+}
+
+/*tex
+
+    This routine finds the 'base' width of a horizontal box, using the same logic
+    that \TeX82 used for \.{\\predisplaywidth}.
+
+*/
+
+static pointer get_actual_box_width(pointer r,pointer p, scaled initial_width)
+{
+    /*tex increment to |v| */
+    scaled d;
+    /*tex calculated |size| */
+    scaled w = -max_dimen;
+    /*tex |w| plus possible glue amount */
+    scaled v = initial_width;
+    while (p != null) {
+        if (is_char_node(p)) {
+            d = glyph_width(p);
+            goto FOUND;
+        }
+        switch (type(p)) {
+            case hlist_node:
+            case vlist_node:
+            case rule_node:
+                d = width(p);
+                goto FOUND;
+                break;
+            case margin_kern_node:
+                d = width(p);
+                break;
+            case kern_node:
+                d = width(p);
+                break;
+            case disc_node:
+                /*tex At the end of the line we should actually take the |pre|. */
+                if (no_break(p) != null) {
+                    d = get_actual_box_width(r,vlink_no_break(p),0);
+                    if (d <= -max_dimen || d >= max_dimen) {
+                        d = 0;
+                    }
+                } else {
+                    d = 0;
+                }
+                goto FOUND;
+                break;
+            case math_node:
+                /*tex Begin mathskip code. */
+                if (glue_is_zero(p)) {
+                    d = surround(p);
+                    break;
+                } else {
+                    /*tex Fall through. */
+                }
+                /*tex End mathskip code. */
+            case glue_node:
+                /*tex
+
+                    We need to be careful that |w|, |v|, and |d| do not depend on
+                    any |glue_set| values, since such values are subject to
+                    system-dependent rounding. System-dependent numbers are not
+                    allowed to infiltrate parameters like |pre_display_size|,
+                    since \TeX82 is supposed to make the same decisions on all
+                    machines.
+
+                */
+                d = width(p);
+                if (glue_sign(r) == stretching) {
+                    if ((glue_order(r) == stretch_order(p)) && (stretch(p) != 0))
+                        v = max_dimen;
+                } else if (glue_sign(r) == shrinking) {
+                    if ((glue_order(r) == shrink_order(p)) && (shrink(p) != 0))
+                        v = max_dimen;
+                }
+                if (subtype(p) >= a_leaders)
+                    goto FOUND;
+                break;
+            default:
+                d = 0;
+                break;
+        }
+        if (v < max_dimen)
+            v = v + d;
+        goto NOT_FOUND;
+      FOUND:
+        if (v < max_dimen) {
+            v = v + d;
+            w = v;
+        } else {
+            w = max_dimen;
+            break;
+        }
+      NOT_FOUND:
+        p = vlink(p);
+    }
+    return w;
+}
+
+pointer actual_box_width(pointer r, scaled base_width)
+{
+    /*tex
+
+        Often this is the same as:
+
+        \starttyping
+        return + shift_amount(r) + base_width +
+            natural_sizes(list_ptr(r),null,(glue_ratio) glue_set(r),glue_sign(r),glue_order(r),box_dir(r));
+        \stoptyping
+    */
+    return get_actual_box_width(r,list_ptr(r),shift_amount(r) + base_width);
+}
+
+halfword tail_of_list(halfword p)
+{
+    halfword q = p;
+    while (vlink(q) != null)
+        q = vlink(q);
+    return q;
+}
+
+int var_used;
+
+/*tex
+
+    Attribute lists need two extra globals to increase processing efficiency.
+    |max_used_attr| limits the test loop that checks for set attributes, and
+    |attr_list_cache| contains a pointer to an already created attribute list. It
+    is set to the special value |cache_disabled| when the current value can no
+    longer be trusted: after an assignment to an attribute register, and after a
+    group has ended.
+
+*/
+
+/*tex The maximum assigned attribute id: */
+
+int max_used_attr;
+halfword attr_list_cache;
+
+/*tex
+
+    From the computer's standpoint, \TeX's chief mission is to create horizontal
+    and vertical lists. We shall now investigate how the elements of these lists
+    are represented internally as nodes in the dynamic memory.
+
+    A horizontal or vertical list is linked together by |link| fields in the
+    first word of each node. Individual nodes represent boxes, glue, penalties,
+    or special things like discretionary hyphens; because of this variety, some
+    nodes are longer than others, and we must distinguish different kinds of
+    nodes. We do this by putting a `|type|' field in the first word, together
+    with the link and an optional `|subtype|'.
+
+    Character nodes appear only in horizontal lists, never in vertical lists.
+
+    An |hlist_node| stands for a box that was made from a horizontal list. Each
+    |hlist_node| is seven words long, and contains the following fields (in
+    addition to the mandatory |type| and |link|, which we shall not mention
+    explicitly when discussing the other node types): The |height| and |width|
+    and |depth| are scaled integers denoting the dimensions of the box. There is
+    also a |shift_amount| field, a scaled integer indicating how much this box
+    should be lowered (if it appears in a horizontal list), or how much it should
+    be moved to the right (if it appears in a vertical list). There is a
+    |list_ptr| field, which points to the beginning of the list from which this
+    box was fabricated; if |list_ptr| is |null|, the box is empty. Finally, there
+    are three fields that represent the setting of the glue: |glue_set(p)| is a
+    word of type |glue_ratio| that represents the proportionality constant for
+    glue setting; |glue_sign(p)| is |stretching| or |shrinking| or |normal|
+    depending on whether or not the glue should stretch or shrink or remain
+    rigid; and |glue_order(p)| specifies the order of infinity to which glue
+    setting applies (|normal|, |sfi|, |fil|, |fill|, or |filll|). The |subtype|
+    field is not used.
+
+    The |new_null_box| function returns a pointer to an |hlist_node| in which all
+    subfields have the values corresponding to `\.{\\hbox\{\}}'. The |subtype|
+    field is set to |min_quarterword|, since that's the desired |span_count|
+    value if this |hlist_node| is changed to an |unset_node|.
+
+*/
+
+/*tex Create a new box node. */
+
+halfword new_null_box(void)
+{
+    halfword p = new_node(hlist_node, min_quarterword);
+    box_dir(p) = text_direction_par;
+    return p;
+}
+
+/*tex
+
+    A |vlist_node| is like an |hlist_node| in all respects except that it
+    contains a vertical list.
+
+    A |rule_node| stands for a solid black rectangle; it has |width|, |depth|,
+    and |height| fields just as in an |hlist_node|. However, if any of these
+    dimensions is $-2^{30}$, the actual value will be determined by running the
+    rule up to the boundary of the innermost enclosing box. This is called a
+    ``running dimension.'' The |width| is never running in an hlist; the |height|
+    and |depth| are never running in a~vlist.
+
+    A new rule node is delivered by the |new_rule| function. It makes all the
+    dimensions ``running,'' so you have to change the ones that are not allowed
+    to run.
+
+*/
+
+halfword new_rule(int s)
+{
+    halfword p = new_node(rule_node,s);
+    return p;
+}
+
+/*tex
+
+    Insertions are represented by |ins_node| records, where the |subtype|
+    indicates the corresponding box number. For example, `\.{\\insert 250}' leads
+    to an |ins_node| whose |subtype| is |250+min_quarterword|. The |height| field
+    of an |ins_node| is slightly misnamed; it actually holds the natural height
+    plus depth of the vertical list being inserted. The |depth| field holds the
+    |split_max_depth| to be used in case this insertion is split, and the
+    |split_top_ptr| points to the corresponding |split_top_skip|. The
+    |float_cost| field holds the |floating_penalty| that will be used if this
+    insertion floats to a subsequent page after a split insertion of the same
+    class. There is one more field, the |ins_ptr|, which points to the beginning
+    of the vlist for the insertion.
+
+    A |mark_node| has a |mark_ptr| field that points to the reference count of a
+    token list that contains the user's \.{\\mark} text. In addition there is a
+    |mark_class| field that contains the mark class.
+
+    An |adjust_node|, which occurs only in horizontal lists, specifies material
+    that will be moved out into the surrounding vertical list; i.e., it is used
+    to implement \TeX's `\.{\\vadjust}' operation. The |adjust_ptr| field points
+    to the vlist containing this material.
+
+    A |glyph_node|, which occurs only in horizontal lists, specifies a glyph in a
+    particular font, along with its attribute list. Older versions of \TeX\ could
+    use token memory for characters, because the font,char combination would fit
+    in a single word (both values were required to be strictly less than
+    $2^{16}$). In LuaTeX, room is needed for characters that are larger than
+    that, as well as a pointer to a potential attribute list, and the two
+    displacement values.
+
+    In turn, that made the node so large that it made sense to merge ligature
+    glyphs as well, as that requires only one extra pointer. A few extra classes
+    of glyph nodes will be introduced later. The unification of all those types
+    makes it easier to manipulate lists of glyphs. The subtype differentiates
+    various glyph kinds.
+
+    First, here is a function that returns a pointer to a glyph node for a given
+    glyph in a given font. If that glyph doesn't exist, |null| is returned
+    instead. Nodes of this subtype are directly created only for accents and
+    their base (through |make_accent|), and math nucleus items (in the conversion
+    from |mlist| to |hlist|).
+
+*/
+
+halfword new_glyph(int f, int c)
+{
+    halfword p = null;
+    if ((f == 0) || (char_exists(f, c))) {
+        p = new_glyph_node();
+        set_to_glyph(p);
+        font(p) = f;
+        character(p) = c;
+    }
+    return p;
+}
+
+/*tex
+
+    A subset of the glyphs nodes represent ligatures: characters fabricated from
+    the interaction of two or more actual characters. The characters that
+    generated the ligature have not been forgotten, since they are needed for
+    diagnostic messages; the |lig_ptr| field points to a linked list of character
+    nodes for all original characters that have been deleted. (This list might be
+    empty if the characters that generated the ligature were retained in other
+    nodes.)
+
+    The |subtype| field of these |glyph_node|s is 1, plus 2 and/or 1 if the
+    original source of the ligature included implicit left and/or right
+    boundaries. These nodes are created by the C function |new_ligkern|.
+
+    A third general type of glyphs could be called a character, as it only
+    appears in lists that are not yet processed by the ligaturing and kerning
+    steps of the program.
+
+    |main_control| inserts these, and they are later converted to
+    |subtype_normal| by |new_ligkern|.
+
+*/
+
+quarterword norm_min(int h)
+{
+    if (h <= 0)
+        return 1;
+    else if (h >= 255)
+        return 255;
+    else
+        return (quarterword) h;
+}
+
+halfword new_char(int f, int c)
+{
+    halfword p;
+    p = new_glyph_node();
+    set_to_character(p);
+    font(p) = f;
+    character(p) = c;
+    lang_data(p) = make_lang_data(uc_hyph_par, cur_lang_par, left_hyphen_min_par, right_hyphen_min_par);
+    return p;
+}
+
+/*tex
+
+    Left and right ghost glyph nodes are the result of \.{\\leftghost} and
+    \.{\\rightghost}, respectively. They are going to be removed by
+    |new_ligkern|, at the end of which they are no longer needed.
+
+    Here are a few handy helpers used by the list output routines.
+
+*/
+
+scaled glyph_width(halfword p)
+{
+    scaled w = char_width(font(p), character(p));
+    return w;
+}
+
+scaled glyph_height(halfword p)
+{
+    scaled w = char_height(font(p), character(p)) + y_displace(p);
+    if (w < 0)
+        w = 0;
+    return w;
+}
+
+scaled glyph_depth(halfword p)
+{
+    scaled w = char_depth(font(p), character(p));
+    if (y_displace(p) > 0)
+        w = w - y_displace(p);
+    if (w < 0)
+        w = 0;
+    return w;
+}
+
+/*tex
+
+    A |disc_node|, which occurs only in horizontal lists, specifies a
+    ``dis\-cretion\-ary'' line break. If such a break occurs at node |p|, the
+    text that starts at |pre_break(p)| will precede the break, the text that
+    starts at |post_break(p)| will follow the break, and text that appears in
+    |no_break(p)| nodes will be ignored. For example, an ordinary discretionary
+    hyphen, indicated by `\.{\\-}', yields a |disc_node| with |pre_break|
+    pointing to a |char_node| containing a hyphen, |post_break=null|, and
+    |no_break=null|.
+
+    If |subtype(p)=automatic_disc|, the |ex_hyphen_penalty| will be charged for
+    this break. Otherwise the |hyphen_penalty| will be charged. The texts will
+    actually be substituted into the list by the line-breaking algorithm if it
+    decides to make the break, and the discretionary node will disappear at that
+    time; thus, the output routine sees only discretionaries that were not
+    chosen.
+
+*/
+
+halfword new_disc(void)
+{
+    halfword p = new_node(disc_node, 0);
+    disc_penalty(p) = hyphen_penalty_par;
+    return p;
+}
+
+/*
+
+    A |whatsit_node| is a wild card reserved for extensions to \TeX. The
+    |subtype| field in its first word says what `\\{whatsit}' it is, and
+    implicitly determines the node size (which must be 2 or more) and the format
+    of the remaining words. When a |whatsit_node| is encountered in a list,
+    special actions are invoked; knowledgeable people who are careful not to mess
+    up the rest of \TeX\ are able to make \TeX\ do new things by adding code at
+    the end of the program. For example, there might be a `\TeX nicolor'
+    extension to specify different colors of ink, and the whatsit node might
+    contain the desired parameters.
+
+    The present implementation of \TeX\ treats the features associated with
+    `\.{\\write}' and `\.{\\special}' as if they were extensions, in order to
+    illustrate how such routines might be coded. We shall defer further
+    discussion of extensions until the end of this program.
+
+    A |math_node|, which occurs only in horizontal lists, appears before and
+    after mathematical formulas. The |subtype| field is |before| before the
+    formula and |after| after it. There is a |surround| field, which represents
+    the amount of surrounding space inserted by \.{\\mathsurround}.
+
+*/
+
+halfword new_math(scaled w, int s)
+{
+    halfword p = new_node(math_node, s);
+    surround(p) = w;
+    return p;
+}
+
+/*tex
+
+    \TeX\ makes use of the fact that |hlist_node|, |vlist_node|, |rule_node|,
+    |ins_node|, |mark_node|, |adjust_node|, |disc_node|, |whatsit_node|, and
+    |math_node| are at the low end of the type codes, by permitting a break at
+    glue in a list if and only if the |type| of the previous node is less than
+    |math_node|. Furthermore, a node is discarded after a break if its type is
+    |math_node| or~more.
+
+    A |glue_node| represents glue in a list. However, it is really only a pointer
+    to a separate glue specification, since \TeX\ makes use of the fact that many
+    essentially identical nodes of glue are usually present. If |p| points to a
+    |glue_node|, |glue_ptr(p)| points to another packet of words that specify the
+    stretch and shrink components, etc.
+
+    Glue nodes also serve to represent leaders; the |subtype| is used to
+    distinguish between ordinary glue (which is called |normal|) and the three
+    kinds of leaders (which are called |a_leaders|, |c_leaders|, and
+    |x_leaders|). The |leader_ptr| field points to a rule node or to a box node
+    containing the leaders; it is set to |null| in ordinary glue nodes.
+
+    Many kinds of glue are computed from \TeX's ``skip'' parameters, and it is
+    helpful to know which parameter has led to a particular glue node. Therefore
+    the |subtype| is set to indicate the source of glue, whenever it originated
+    as a parameter. We will be defining symbolic names for the parameter numbers
+    later (e.g., |line_skip_code=0|, |baseline_skip_code=1|, etc.); it suffices
+    for now to say that the |subtype| of parametric glue will be the same as the
+    parameter number, plus~one.
+
+    In math formulas there are two more possibilities for the |subtype| in a glue
+    node: |mu_glue| denotes an \.{\\mskip} (where the units are scaled \.{mu}
+    instead of scaled \.{pt}); and |cond_math_glue| denotes the `\.{\\nonscript}'
+    feature that cancels the glue node immediately following if it appears in a
+    subscript.
+
+    A glue specification has a halfword reference count in its first word,
+    representing |null| plus the number of glue nodes that point to it (less
+    one). Note that the reference count appears in the same position as the
+    |link| field in list nodes; this is the field that is initialized to |null|
+    when a node is allocated, and it is also the field that is flagged by
+    |empty_flag| in empty nodes.
+
+    Glue specifications also contain three |scaled| fields, for the |width|,
+    |stretch|, and |shrink| dimensions. Finally, there are two one-byte fields
+    called |stretch_order| and |shrink_order|; these contain the orders of
+    infinity (|normal|, |sfi|, |fil|, |fill|, or |filll|) corresponding to the
+    stretch and shrink values.
+
+    Here is a function that returns a pointer to a copy of a glue spec. The
+    reference count in the copy is |null|, because there is assumed to be exactly
+    one reference to the new specification.
+
+*/
+
+halfword new_spec(halfword q)
+{
+    if (q == null) {
+        return copy_node(zero_glue);
+    } else if (type(q) == glue_spec_node) {
+        return copy_node(q);
+    } else if (type(q) == glue_node) {
+        halfword p = copy_node(zero_glue);
+        width(p) = width(q);
+        stretch(p) = stretch(q);
+        shrink(p) = shrink(q);
+        stretch_order(p) = stretch_order(q);
+        shrink_order(p) = shrink_order(q);
+        return p;
+    } else {
+        /*tex Alternatively we can issue a warning. */
+        return copy_node(zero_glue);
+    }
+}
+
+/*tex
+
+    And here's a function that creates a glue node for a given parameter
+    identified by its code number; for example, |new_param_glue(line_skip_code)|
+    returns a pointer to a glue node for the current \.{\\lineskip}.
+
+*/
+
+halfword new_param_glue(int n)
+{
+    halfword p = new_node(glue_node, n + 1);
+    halfword q = glue_par(n);
+    width(p) = width(q);
+    stretch(p) = stretch(q);
+    shrink(p) = shrink(q);
+    stretch_order(p) = stretch_order(q);
+    shrink_order(p) = shrink_order(q);
+    return p;
+}
+
+/*tex
+
+    Glue nodes that are more or less anonymous are created by |new_glue|, whose
+    argument points to a glue specification.
+
+*/
+
+halfword new_glue(halfword q)
+{
+    halfword p = new_node(glue_node, normal);
+    width(p) = width(q);
+    stretch(p) = stretch(q);
+    shrink(p) = shrink(q);
+    stretch_order(p) = stretch_order(q);
+    shrink_order(p) = shrink_order(q);
+    return p;
+}
+
+/*tex
+
+    Still another subroutine is needed: This one is sort of a combination of
+    |new_param_glue| and |new_glue|. It creates a glue node for one of the
+    current glue parameters, but it makes a fresh copy of the glue specification,
+    since that specification will probably be subject to change, while the
+    parameter will stay put.
+
+    The global variable |temp_ptr| is set to the address of the new spec.
+
+*/
+
+halfword new_skip_param(int n)
+{
+    halfword p = new_node(glue_node, n + 1);
+    halfword q = glue_par(n);
+    width(p) = width(q);
+    stretch(p) = stretch(q);
+    shrink(p) = shrink(q);
+    stretch_order(p) = stretch_order(q);
+    shrink_order(p) = shrink_order(q);
+    return p;
+}
+
+/*tex
+
+    A |kern_node| has a |width| field to specify a (normally negative) amount of
+    spacing. This spacing correction appears in horizontal lists between letters
+    like A and V when the font designer said that it looks better to move them
+    closer together or further apart. A kern node can also appear in a vertical
+    list, when its `|width|' denotes additional spacing in the vertical
+    direction. The |subtype| is either |normal| (for kerns inserted from font
+    information or math mode calculations) or |explicit| (for kerns inserted from
+    \.{\\kern} and \.{\\/} commands) or |acc_kern| (for kerns inserted from
+    non-math accents) or |mu_glue| (for kerns inserted from \.{\\mkern}
+    specifications in math formulas).
+
+    The |new_kern| function creates a kern node having a given width.
+
+*/
+
+halfword new_kern(scaled w)
+{
+    halfword p = new_node(kern_node, normal);
+    width(p) = w;
+    return p;
+}
+
+/*tex
+
+    A |penalty_node| specifies the penalty associated with line or page breaking,
+    in its |penalty| field. This field is a fullword integer, but the full range
+    of integer values is not used: Any penalty |>=10000| is treated as infinity,
+    and no break will be allowed for such high values. Similarly, any penalty
+    |<=-10000| is treated as negative infinity, and a break will be forced.
+
+    Anyone who has been reading the last few sections of the program will be able
+    to guess what comes next.
+
+*/
+
+halfword new_penalty(int m, int s)
+{
+    halfword p = new_node(penalty_node, 0);
+    penalty(p) = m;
+    subtype(p) = s;
+    return p;
+}
+
+/*tex
+
+    You might think that we have introduced enough node types by now. Well,
+    almost, but there is one more: An |unset_node| has nearly the same format as
+    an |hlist_node| or |vlist_node|; it is used for entries in \.{\\halign} or
+    \.{\\valign} that are not yet in their final form, since the box dimensions
+    are their ``natural'' sizes before any glue adjustment has been made. The
+    |glue_set| word is not present; instead, we have a |glue_stretch| field,
+    which contains the total stretch of order |glue_order| that is present in the
+    hlist or vlist being boxed. Similarly, the |shift_amount| field is replaced
+    by a |glue_shrink| field, containing the total shrink of order |glue_sign|
+    that is present. The |subtype| field is called |span_count|; an unset box
+    typically contains the data for |qo(span_count)+1| columns. Unset nodes will
+    be changed to box nodes when alignment is completed.
+
+    In fact, there are still more types coming. When we get to math formula
+    processing we will see that a |style_node| has |type=14|; and a number of
+    larger type codes will also be defined, for use in math mode only.
+
+    Warning: If any changes are made to these data structure layouts, such as
+    changing any of the node sizes or even reordering the words of nodes, the
+    |copy_node_list| procedure and the memory initialization code below may have
+    to be changed. Such potentially dangerous parts of the program are listed in
+    the index under `data structure assumptions'. However, other references to
+    the nodes are made symbolically in terms of the \.{WEB} macro definitions
+    above, so that format changes will leave \TeX's other algorithms intact.
+
+*/
+
+halfword make_local_par_node(int mode)
+{
+    int callback_id;
+    halfword q;
+    halfword p = new_node(local_par_node,0);
+    local_pen_inter(p) = local_inter_line_penalty_par;
+    local_pen_broken(p) = local_broken_penalty_par;
+    if (local_left_box_par != null) {
+        q = copy_node_list(local_left_box_par);
+        local_box_left(p) = q;
+        local_box_left_width(p) = width(local_left_box_par);
+    }
+    if (local_right_box_par != null) {
+        q = copy_node_list(local_right_box_par);
+        local_box_right(p) = q;
+        local_box_right_width(p) = width(local_right_box_par);
+    }
+    local_par_dir(p) = par_direction_par;
+    /*tex Callback with node passed: */
+    callback_id = callback_defined(insert_local_par_callback);
+    if (callback_id > 0) {
+        /*tex Todo: use general mechanism/wrapper. */
+        int sfix = lua_gettop(Luas);
+        if (!get_callback(Luas, callback_id)) {
+            lua_settop(Luas, sfix);
+        } else {
+            int i;
+            nodelist_to_lua(Luas, p);
+            lua_push_local_par_mode(Luas,mode)
+            /*tex 2 arg, 0 result */
+            i = lua_pcall(Luas, 2, 0, 0);
+            if (i != 0) {
+                lua_gc(Luas, LUA_GCCOLLECT, 0);
+                Luas = luatex_error(Luas, (i == LUA_ERRRUN ? 0 : 1));
+            }
+            lua_settop(Luas, sfix);
+        }
+    }
+    return p;
+}
diff --git a/texk/web2c/luatexdir/tex/texnodes.w b/texk/web2c/luatexdir/tex/texnodes.w
deleted file mode 100644
index 0c8bdb837..000000000
--- a/texk/web2c/luatexdir/tex/texnodes.w
+++ /dev/null
@@ -1,3910 +0,0 @@
-% texnodes.w
-%
-% Copyright 2006-2010 Taco Hoekwater <taco@@luatex.org>
-%
-% This file is part of LuaTeX.
-%
-% LuaTeX is free software; you can redistribute it and/or modify it under
-% the terms of the GNU General Public License as published by the Free
-% Software Foundation; either version 2 of the License, or (at your
-% option) any later version.
-%
-% LuaTeX is distributed in the hope that it will be useful, but WITHOUT
-% ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-% FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
-% License for more details.
-%
-% You should have received a copy of the GNU General Public License along
-% with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
-
-@ @c
-
-#include "ptexlib.h"
-#include "lua/luatex-api.h"
-
-/* we can consider less mode sizes: 2 4 6 8 */
-
-@
-This module started out using NDEBUG to trigger checking invalid node usage,
-something that is needed because users can mess up nodes in Lua. At some point
-that code was always enabled so it is now always on but still can be recognized
-as additional code. And as the performance hit is close to zero so disabling
-makes no sense, not even to make it configureable. There is a little more memory
-used but that is neglectable compared to other memory usage.
-
-@c
-#define MAX_CHAIN_SIZE   13 /* why not a bit larger */
-#define CHECK_NODE_USAGE  1 /* this triggers checking */
-
-memory_word *volatile varmem = NULL;
-
-#ifdef CHECK_NODE_USAGE
-    char *varmem_sizes = NULL;
-#endif
-
-halfword var_mem_max = 0;
-halfword rover = 0;
-
-halfword free_chain[MAX_CHAIN_SIZE] = { null };
-
-static int my_prealloc = 0;
-
-int fix_node_lists = 1; /* used in font and lang */
-
-halfword slow_get_node(int s);  /* defined below */
-
-#define fake_node       100
-#define fake_node_size  2
-#define fake_node_name "fake"
-
-#define variable_node_size 2
-
-/* core nodes */
-
-const char *node_fields_list[] = {
-    "attr", "width", "depth", "height", "dir", "shift", "glue_order", "glue_sign",
-    "glue_set", "head", NULL
-};
-const char *node_fields_rule[] = {
-    "attr", "width", "depth", "height", "dir", "index", NULL
-};
-const char *node_fields_insert[] = {
-    "attr", "cost", "depth", "height", "spec", "head", NULL
-};
-const char *node_fields_mark[] = {
-    "attr", "class", "mark", NULL
-};
-const char *node_fields_adjust[] = {
-    "attr", "head", NULL
-};
-const char *node_fields_disc[] = {
-    "attr", "pre", "post", "replace", "penalty", NULL
-};
-const char *node_fields_math[] = {
-    "attr", "surround", "width", "stretch", "shrink", "stretch_order", "shrink_order", NULL
-};
-const char *node_fields_glue[] = {
-    "attr", "leader", "width", "stretch", "shrink", "stretch_order", "shrink_order", NULL
-};
-const char *node_fields_kern[] = {
-    "attr", "kern", "expansion_factor", NULL
-};
-const char *node_fields_penalty[] = {
-    "attr", "penalty", NULL
-};
-const char *node_fields_unset[] = {
-    "attr", "width", "depth", "height", "dir", "shrink", "glue_order",
-    "glue_sign", "stretch", "span", "head", NULL
-};
-const char *node_fields_margin_kern[]  = {
-    "attr", "width", "glyph", NULL
-};
-const char *node_fields_glyph[] = {
-    "attr", "char", "font", "lang", "left", "right", "uchyph", "components",
-    "xoffset", "yoffset", "width", "height", "depth", "expansion_factor", NULL
-};
-const char *node_fields_inserting[] = {
-    "height", "last_ins_ptr", "best_ins_ptr",
-    "width", "stretch", "shrink", "stretch_order", "shrink_order", NULL
-};
-const char *node_fields_splitup[] = {
-    "height", "last_ins_ptr", "best_ins_ptr", "broken_ptr", "broken_ins", NULL
-};
-const char *node_fields_attribute[] = {
-    "number", "value", NULL
-};
-const char *node_fields_glue_spec[] = {
-    "width", "stretch", "shrink", "stretch_order", "shrink_order", NULL
-};
-const char *node_fields_attribute_list[] = {
-    NULL
-};
-const char *node_fields_local_par[] = {
-    "attr", "pen_inter", "pen_broken", "dir", "box_left", "box_left_width",
-    "box_right", "box_right_width", NULL
-};
-const char *node_fields_dir[] = {
-    "attr", "dir", "level", NULL
-};
-const char *node_fields_boundary[] = {
-    "attr", "value", NULL
-};
-
-/* math nodes */
-
-const char *node_fields_noad[] = {
-    "attr", "nucleus", "sub", "sup", NULL
-};
-
-const char *node_fields_style[] = {
-    "attr", "style", NULL
-};
-const char *node_fields_choice[] = {
-    "attr", "display", "text", "script", "scriptscript", NULL
-};
-const char *node_fields_radical[] = {
-    "attr", "nucleus", "sub", "sup", "left", "degree", "width", "options", NULL
-};
-const char *node_fields_fraction[] = {
-    "attr", "width", "num", "denom", "left", "right", "middle", "options", NULL
-};
-const char *node_fields_accent[] = {
-    "attr", "nucleus", "sub", "sup", "accent", "bot_accent", "top_accent",
-    "overlay_accent", "fraction", NULL
-};
-const char *node_fields_fence[] = {
-    "attr", "delim", "italic", "height", "depth", "options", "class", NULL
-};
-const char *node_fields_math_char[] = {
-    "attr", "fam", "char", NULL
-};
-const char *node_fields_sub_box[] = {
-    "attr", "head", NULL
-};
-const char *node_fields_sub_mlist[] = {
-    "attr", "head", NULL
-};
-const char *node_fields_math_text_char[] = {
-    "attr", "fam", "char", NULL
-};
-const char *node_fields_delim[] = {
-    "attr", "small_fam", "small_char", "large_fam", "large_char", NULL
-};
-
-/* whatsit nodes */
-
-const char *node_fields_whatsit_open[] = {
-    "attr", "stream", "name", "area", "ext", NULL
-};
-const char *node_fields_whatsit_write[] = {
-    "attr", "stream", "data", NULL
-};
-const char *node_fields_whatsit_close[] = {
-    "attr", "stream", NULL
-};
-const char *node_fields_whatsit_special[] = {
-    "attr", "data", NULL
-};
-const char *node_fields_whatsit_save_pos[] = {
-    "attr", NULL
-};
-const char *node_fields_whatsit_late_lua[] = {
-    "attr", "reg", "data", "name", "string", NULL
-};
-const char *node_fields_whatsit_user_defined[] = {
-    "attr", "user_id", "type", "value", NULL
-};
-
-/* pdf backend whatsit nodes */
-
-const char *node_fields_whatsit_pdf_literal[] = {
-    "attr", "mode", "data", NULL
-};
-const char *node_fields_whatsit_pdf_refobj[] = {
-    "attr", "objnum", NULL
-};
-const char *node_fields_whatsit_pdf_annot[] = {
-    "attr", "width", "depth", "height", "objnum", "data", NULL
-};
-const char *node_fields_whatsit_pdf_start_link[] = {
-    "attr", "width", "depth", "height", "objnum", "link_attr", "action", NULL
-};
-const char *node_fields_whatsit_pdf_end_link[] = {
-    "attr", NULL
-};
-const char *node_fields_whatsit_pdf_dest[] = {
-    "attr", "width", "depth", "height", "named_id", "dest_id", "dest_type",
-    "xyz_zoom", "objnum", NULL
-};
-const char *node_fields_whatsit_pdf_action[] = {
-    "action_type", "named_id", "action_id", "file", "new_window", "data", NULL
-};
-const char *node_fields_whatsit_pdf_thread[] = {
-    "attr", "width", "depth", "height",  "named_id", "thread_id", "thread_attr", NULL
-};
-const char *node_fields_whatsit_pdf_start_thread[] = {
-    "attr", "width", "depth", "height", "named_id", "thread_id", "thread_attr", NULL
-};
-const char *node_fields_whatsit_pdf_end_thread[] = {
-    "attr", NULL
-};
-const char *node_fields_whatsit_pdf_colorstack[] = {
-    "attr", "stack", "cmd", "data", NULL
-};
-const char *node_fields_whatsit_pdf_setmatrix[] = {
-    "attr", "data", NULL
-};
-const char *node_fields_whatsit_pdf_save[] = {
-    "attr", NULL
-};
-const char *node_fields_whatsit_pdf_restore[] = {
-    "attr", NULL
-};
-
-/* subtypes */
-
-const char *node_subtypes_glue[] = {
-    "userskip", "lineskip", "baselineskip", "parskip", "abovedisplayskip", "belowdisplayskip",
-    "abovedisplayshortskip", "belowdisplayshortskip", "leftskip", "rightskip", "topskip",
-    "splittopskip", "tabskip", "spaceskip", "xspaceskip", "parfillskip",
-    "mathskip", "thinmuskip", "medmuskip", "thickmuskip", NULL
-};
-const char *node_subtypes_mathglue[] = { /* 98+ */
-    "conditionalmathskip", "muglue", NULL
-};
-const char *node_subtypes_leader[] = { /* 100+ */
-    "leaders", "cleaders", "xleaders", "gleaders", NULL
-};
-const char *node_subtypes_fill[] = {
-    "stretch", "fi", "fil", "fill", "filll", NULL
-};
-const char *node_subtypes_boundary[] = {
-    "cancel", "user", "protrusion", "word", NULL
-};
-const char *node_subtypes_penalty[] = {
-    "userpenalty", "linebreakpenalty", "linepenalty", "wordpenalty", "finalpenalty",
-    "noadpenalty", "beforedisplaypenalty", "afterdisplaypenalty", "equationnumberpenalty", NULL
-};
-const char *node_subtypes_kern[] = {
-    "fontkern", "userkern", "accentkern", "italiccorrection", NULL
-};
-const char *node_subtypes_rule[] = {
-    "normal", "box", "image", "empty", "user", "over", "under", "fraction", "radical", NULL
-};
-const char *node_subtypes_glyph[] = {
-    "character", "glyph", "ligature", "ghost", "left", "right", NULL
-};
-const char *node_subtypes_disc[] = {
-    "discretionary", "explicit", "automatic", "regular", "first", "second", NULL
-};
-const char *node_subtypes_marginkern[] = {
-    "left", "right", NULL
-};
-const char *node_subtypes_list[] = {
-    "unknown", "line", "box", "indent", "alignment", "cell", "equation", "equationnumber", NULL
-};
-const char *node_subtypes_adjust[] = {
-    "normal", "pre", NULL
-};
-const char *node_subtypes_math[] = {
-    "beginmath", "endmath", NULL
-};
-const char *node_subtypes_noad[] = {
-    "ord", "opdisplaylimits", "oplimits", "opnolimits", "bin", "rel", "open", "close",
-    "punct", "inner", "under", "over", "vcenter", NULL
-};
-const char *node_subtypes_radical[] = {
-    "radical", "uradical", "uroot", "uunderdelimiter", "uoverdelimiter", "udelimiterunder",
-    "udelimiterover", NULL
-};
-const char *node_subtypes_accent[] = {
-    "bothflexible", "fixedtop", "fixedbottom", "fixedboth", NULL,
-};
-const char *node_subtypes_fence[] = {
-    "unset", "left", "middle", "right", NULL
-};
-
-node_info node_data[] = { /* the last entry in a row is the etex number */
-    { hlist_node,          box_node_size,         node_fields_list,                          "hlist",           1 },
-    { vlist_node,          box_node_size,         node_fields_list,                          "vlist",           2 },
-    { rule_node,           rule_node_size,        node_fields_rule,                          "rule",            3 },
-    { ins_node,            ins_node_size,         node_fields_insert,                        "ins",             4 },
-    { mark_node,           mark_node_size,        node_fields_mark,                          "mark",            5 },
-    { adjust_node,         adjust_node_size,      node_fields_adjust,                        "adjust",          6 },
-    { boundary_node,       boundary_node_size,    node_fields_boundary,                      "boundary",       -1 },
-    { disc_node,           disc_node_size,        node_fields_disc,                          "disc",            8 },
-    { whatsit_node,        -1,                    NULL,                                      "whatsit",         9 },
-    { local_par_node,      local_par_size,        node_fields_local_par,                     "local_par",      -1 },
-    { dir_node,            dir_node_size,         node_fields_dir,                           "dir",            -1 },
-    { math_node,           math_node_size,        node_fields_math,                          "math",           10 },
-    { glue_node,           glue_node_size,        node_fields_glue,                          "glue",           11 },
-    { kern_node,           kern_node_size,        node_fields_kern,                          "kern",           12 },
-    { penalty_node,        penalty_node_size,     node_fields_penalty,                       "penalty",        13 },
-    { unset_node,          box_node_size,         node_fields_unset,                         "unset",          14 },
-    { style_node,          style_node_size,       node_fields_style,                         "style",          15 },
-    { choice_node,         style_node_size,       node_fields_choice,                        "choice",         15 },
-    { simple_noad,         noad_size,             node_fields_noad,                          "noad",           15 },
-    { radical_noad,        radical_noad_size,     node_fields_radical,                       "radical",        15 },
-    { fraction_noad,       fraction_noad_size,    node_fields_fraction,                      "fraction",       15 },
-    { accent_noad,         accent_noad_size,      node_fields_accent,                        "accent",         15 },
-    { fence_noad,          fence_noad_size,       node_fields_fence,                         "fence",          15 },
-    { math_char_node,      math_kernel_node_size, node_fields_math_char,                     "math_char",      15 },
-    { sub_box_node,        math_kernel_node_size, node_fields_sub_box,                       "sub_box",        15 },
-    { sub_mlist_node,      math_kernel_node_size, node_fields_sub_mlist,                     "sub_mlist",      15 },
-    { math_text_char_node, math_kernel_node_size, node_fields_math_text_char,                "math_text_char", 15 },
-    { delim_node,          math_shield_node_size, node_fields_delim,                         "delim",          15 },
-    { margin_kern_node,    margin_kern_node_size, node_fields_margin_kern,                   "margin_kern",    -1 },
-    { glyph_node,          glyph_node_size,       node_fields_glyph,                         "glyph",           0 },
-    { align_record_node,   box_node_size,         NULL,                                      "align_record",   -1 },
-    { pseudo_file_node,    pseudo_file_node_size, NULL,                                      "pseudo_file",    -1 },
-    { pseudo_line_node,    variable_node_size,    NULL,                                      "pseudo_line",    -1 },
-    { inserting_node,      page_ins_node_size,    node_fields_inserting,                     "page_insert",    -1 },
-    { split_up_node,       page_ins_node_size,    node_fields_splitup,                       "split_insert",   -1 },
-    { expr_node,           expr_node_size,        NULL,                                      "expr_stack",     -1 },
-    { nesting_node,        nesting_node_size,     NULL,                                      "nested_list",    -1 },
-    { span_node,           span_node_size,        NULL,                                      "span",           -1 },
-    { attribute_node,      attribute_node_size,   node_fields_attribute,                     "attribute",      -1 },
-    { glue_spec_node,      glue_spec_size,        node_fields_glue_spec,                     "glue_spec",      -1 },
-    { attribute_list_node, attribute_node_size,   node_fields_attribute_list,                "attribute_list", -1 },
-    { temp_node,           temp_node_size,        NULL,                                      "temp",           -1 },
-    { align_stack_node,    align_stack_node_size, NULL,                                      "align_stack",    -1 },
-    { movement_node,       movement_node_size,    NULL,                                      "movement_stack", -1 },
-    { if_node,             if_node_size,          NULL,                                      "if_stack",       -1 },
-    { unhyphenated_node,   active_node_size,      NULL,                                      "unhyphenated",   -1 },
-    { hyphenated_node,     active_node_size,      NULL,                                      "hyphenated",     -1 },
-    { delta_node,          delta_node_size,       NULL,                                      "delta",          -1 },
-    { passive_node,        passive_node_size,     NULL,                                      "passive",        -1 },
-    { shape_node,          variable_node_size,    NULL,                                      "shape",          -1 },
-    { -1,                 -1,                     NULL,                                      NULL,             -1 },
-};
-
-const char *node_subtypes_pdf_destination[] = {
-    "xyz", "fit", "fith", "fitv", "fitb", "fitbh", "fitbv", "fitr", NULL
-};
-const char *node_subtypes_pdf_literal[] = {
-    "origin", "page", "direct", NULL
-};
-
-node_info whatsit_node_data[] = {
-    { open_node,         open_node_size,               node_fields_whatsit_open,             "open",             -1 },
-    { write_node,        write_node_size,              node_fields_whatsit_write,            "write",            -1 },
-    { close_node,        close_node_size,              node_fields_whatsit_close,            "close",            -1 },
-    { special_node,      special_node_size,            node_fields_whatsit_special,          "special",          -1 },
-    { fake_node,         fake_node_size,               NULL,                                 fake_node_name,     -1 },
-    { fake_node,         fake_node_size,               NULL,                                 fake_node_name,     -1 },
-    { save_pos_node,     save_pos_node_size,           node_fields_whatsit_save_pos,         "save_pos",         -1 },
-    { late_lua_node,     late_lua_node_size,           node_fields_whatsit_late_lua,         "late_lua",         -1 },
-    { user_defined_node, user_defined_node_size,       node_fields_whatsit_user_defined,     "user_defined",     -1 },
-    { fake_node,         fake_node_size,               NULL,                                 fake_node_name,     -1 },
-    { fake_node,         fake_node_size,               NULL,                                 fake_node_name,     -1 },
-    { fake_node,         fake_node_size,               NULL,                                 fake_node_name,     -1 },
-    { fake_node,         fake_node_size,               NULL,                                 fake_node_name,     -1 },
-    { fake_node,         fake_node_size,               NULL,                                 fake_node_name,     -1 },
-    { fake_node,         fake_node_size,               NULL,                                 fake_node_name,     -1 },
-    { fake_node,         fake_node_size,               NULL,                                 fake_node_name,     -1 },
-    /* here starts the dvi backend section, todo: a separate list  */
-    /* nothing for dvi */
-    /* here starts the pdf backend section, todo: a separate list  */
-    { pdf_literal_node,      write_node_size,          node_fields_whatsit_pdf_literal,      "pdf_literal",      -1 },
-    { pdf_refobj_node,       pdf_refobj_node_size,     node_fields_whatsit_pdf_refobj,       "pdf_refobj",       -1 },
-    { pdf_annot_node,        pdf_annot_node_size,      node_fields_whatsit_pdf_annot,        "pdf_annot",        -1 },
-    { pdf_start_link_node,   pdf_annot_node_size,      node_fields_whatsit_pdf_start_link,   "pdf_start_link",   -1 },
-    { pdf_end_link_node,     pdf_end_link_node_size,   node_fields_whatsit_pdf_end_link,     "pdf_end_link",     -1 },
-    { pdf_dest_node,         pdf_dest_node_size,       node_fields_whatsit_pdf_dest,         "pdf_dest",         -1 },
-    { pdf_action_node,       pdf_action_size,          node_fields_whatsit_pdf_action,       "pdf_action",       -1 },
-    { pdf_thread_node,       pdf_thread_node_size,     node_fields_whatsit_pdf_thread,       "pdf_thread",       -1 },
-    { pdf_start_thread_node, pdf_thread_node_size,     node_fields_whatsit_pdf_start_thread, "pdf_start_thread", -1 },
-    { pdf_end_thread_node,   pdf_end_thread_node_size, node_fields_whatsit_pdf_end_thread,   "pdf_end_thread",   -1 },
-    { pdf_thread_data_node,  pdf_thread_node_size,     NULL,                                 "pdf_thread_data",  -1 },
-    { pdf_link_data_node,    pdf_annot_node_size,      NULL,                                 "pdf_link_data",    -1 },
-    { pdf_colorstack_node,   pdf_colorstack_node_size, node_fields_whatsit_pdf_colorstack,   "pdf_colorstack",   -1 },
-    { pdf_setmatrix_node,    pdf_setmatrix_node_size,  node_fields_whatsit_pdf_setmatrix,    "pdf_setmatrix",    -1 },
-    { pdf_save_node,         pdf_save_node_size,       node_fields_whatsit_pdf_save,         "pdf_save",         -1 },
-    { pdf_restore_node,      pdf_restore_node_size,    node_fields_whatsit_pdf_restore,      "pdf_restore",      -1 },
-    /* done */
-    { -1,                    -1,                       NULL,                                 NULL,               -1 },
-};
-
-#define last_whatsit_node pdf_restore_node
-
-@
-When we copy a node list, there are several possibilities: we do the same as a new node,
-we copy the entry to the table in properties (a reference), we do a deep copy of a table
-in the properties, we create a new table and give it the original one as a metatable.
-After some experiments (that also included timing) with these scenarios I decided that a
-deep copy made no sense, nor did nilling. In the end both the shallow copy and the metatable
-variant were both ok, although the second ons is slower. The most important aspect to keep
-in mind is that references to other nodes in properties no longer can be valid for that
-copy. We could use two tables (one unique and one shared) or metatables but that only
-complicates matters.
-
-When defining a new node, we could already allocate a table but it is rather easy to do
-that at the lua end e.g. using a metatable __index method. That way it is under macro
-package control.
-
-When deleting a node, we could keep the slot (e.g. setting it to false) but it could make
-memory consumption raise unneeded when we have temporary large node lists and after that
-only small lists.
-
-So, in the end this is what we ended up with. For the record, I also experimented with the
-following:
-
-- copy attributes to the properties so that we have fast access at the lua end: in the end
-  the overhead is not compensated by speed and convenience, in fact, attributes are not
-  that slow when it comes to accessing them
-
-- a bitset in the node but again the gain compared to attributes is neglectable and it also
-  demands a pretty string agreement over what bit represents what, and this is unlikely to
-  succeed in the tex community (I could use it for font handling, which is cross package,
-  but decided that it doesn't pay off
-
-In case one wonders why properties make sense then, well, it is not so much speed that we
-gain, but more convenience: storing all kind of (temporary) data in attributes is no fun and
-this mechanism makes sure that properties are cleaned up when a node is freed. Also, the
-advantage of a more or less global properties table is that we stay at the lua end. An
-alternative is to store a reference in the node itself but that is complicated by the fact
-that the register has some limitations (no numeric keys) and we also don't want to mess with
-it too much.
-
-@c
-int lua_properties_level         = 0 ; /* can be private */
-int lua_properties_enabled       = 0 ;
-int lua_properties_use_metatable = 0 ;
-
-@
-We keep track of nesting so that we don't oveflow the stack, and, what is more
-important, don't keep resolving the registry index.
-
-@c
-#define lua_properties_push do { \
-    if (lua_properties_enabled) { \
-        lua_properties_level = lua_properties_level + 1 ; \
-        if (lua_properties_level == 1) { \
-            lua_get_metatablelua_l(Luas,node_properties); \
-        } \
-    } \
-} while(0)
-
-#define lua_properties_pop do { \
-    if (lua_properties_enabled) { \
-        if (lua_properties_level == 1) \
-            lua_pop(Luas,1); \
-        lua_properties_level = lua_properties_level - 1 ; \
-    } \
-} while(0)
-
-/* No setting is needed: */
-
-#define lua_properties_set(target) do { \
-} while(0)
-
-/* Resetting boils down to nilling. */
-
-#define lua_properties_reset(target) do { \
-    if (lua_properties_enabled) { \
-        if (lua_properties_level == 0) { \
-            lua_get_metatablelua_l(Luas,node_properties); \
-            lua_pushnil(Luas); \
-            lua_rawseti(Luas,-2,target); \
-            lua_pop(Luas,1); \
-        } else { \
-            lua_pushnil(Luas); \
-            lua_rawseti(Luas,-2,target); \
-        } \
-    } \
-} while(0)
-
-/*
-    For a moment I considered supporting all kind of data types but in practice
-    that makes no sense. So we stick to a cheap shallow copy with as option a
-    metatable. Btw, a deep copy would look like this:
-
-    static void copy_lua_table(lua_State* L, int index) {
-        lua_newtable(L);
-        lua_pushnil(L);
-        while(lua_next(L, index-1) != 0) {
-            lua_pushvalue(L, -2);
-            lua_insert(L, -2);
-            if (lua_type(L,-1)==LUA_TTABLE)
-                copy_lua_table(L,-1);
-            lua_settable(L, -4);
-        }
-        lua_pop(L,1);
-    }
-
-    #define lua_properties_copy(target, source) do { \
-        if (lua_properties_enabled) { \
-            lua_pushinteger(Luas,source); \
-            lua_rawget(Luas,-2); \
-            if (lua_type(Luas,-1)==LUA_TTABLE) { \
-                copy_lua_table(Luas,-1); \
-                lua_pushinteger(Luas,target); \
-                lua_insert(Luas,-2); \
-                lua_rawset(Luas,-3); \
-            } else { \
-                lua_pop(Luas,1); \
-            } \
-        } \
-    } while(0)
-
-*/
-
-/* isn't there a faster way to metatable? */
-
-/*
-
-#define lua_properties_copy(target,source) do { \
-    if (lua_properties_enabled) { \
-        if (lua_properties_level == 0) { \
-            lua_get_metatablelua_l(Luas,node_properties); \
-            lua_rawgeti(Luas,-1,source); \
-            if (lua_type(Luas,-1)==LUA_TTABLE) { \
-                if (lua_properties_use_metatable) { \
-                    lua_newtable(Luas); \
-                    lua_insert(Luas,-2); \
-                    lua_setfield(Luas,-2,"__index"); \
-                    lua_newtable(Luas); \
-                    lua_insert(Luas,-2); \
-                    lua_setmetatable(Luas,-2); \
-                } \
-                lua_rawseti(Luas,-2,target); \
-            } else { \
-                lua_pop(Luas,1); \
-            } \
-            lua_pop(Luas,1); \
-        } else { \
-            lua_rawgeti(Luas,-1,source); \
-            if (lua_type(Luas,-1)==LUA_TTABLE) { \
-                if (lua_properties_use_metatable) { \
-                    lua_newtable(Luas); \
-                    lua_insert(Luas,-2); \
-                    lua_setfield(Luas,-2,"__index"); \
-                    lua_newtable(Luas); \
-                    lua_insert(Luas,-2); \
-                    lua_setmetatable(Luas,-2); \
-                } \
-                lua_rawseti(Luas,-2,target); \
-            } else { \
-                lua_pop(Luas,1); \
-            } \
-        } \
-    } \
-} while(0)
-
-*/
-
-/*
-    A simple testrun on many pages of dumb text shows 1% gain (of course it depends
-    on how properties are used but some other tests confirm it).
-*/
-
-#define lua_properties_copy(target,source) do { \
-    if (lua_properties_enabled) { \
-        if (lua_properties_level == 0) { \
-            lua_get_metatablelua_l(Luas,node_properties); \
-            lua_rawgeti(Luas,-1,source); \
-            if (lua_type(Luas,-1)==LUA_TTABLE) { \
-                if (lua_properties_use_metatable) { \
-                    lua_newtable(Luas); \
-                    lua_insert(Luas,-2); \
-                    lua_push_string_by_name(Luas,__index); \
-                    lua_insert(Luas,-2); \
-                    lua_rawset(Luas, -3); \
-                    lua_newtable(Luas); \
-                    lua_insert(Luas,-2); \
-                    lua_setmetatable(Luas,-2); \
-                } \
-                lua_rawseti(Luas,-2,target); \
-            } else { \
-                lua_pop(Luas,1); \
-            } \
-            lua_pop(Luas,1); \
-        } else { \
-            lua_rawgeti(Luas,-1,source); \
-            if (lua_type(Luas,-1)==LUA_TTABLE) { \
-                if (lua_properties_use_metatable) { \
-                    lua_newtable(Luas); \
-                    lua_insert(Luas,-2); \
-                    lua_push_string_by_name(Luas,__index); \
-                    lua_insert(Luas,-2); \
-                    lua_rawset(Luas, -3); \
-                    lua_newtable(Luas); \
-                    lua_insert(Luas,-2); \
-                    lua_setmetatable(Luas,-2); \
-                } \
-                lua_rawseti(Luas,-2,target); \
-            } else { \
-                lua_pop(Luas,1); \
-            } \
-        } \
-    } \
-} while(0)
-
-/* Here end the property handlers. */
-
-@ @c
-int valid_node(halfword p)
-{
-    if (p > my_prealloc && p < var_mem_max) {
-#ifdef CHECK_NODE_USAGE
-        if (varmem_sizes[p] > 0) {
-            return 1;
-        }
-#else
-        return 1;
-#endif
-    }
-    return 0;
-}
-
-@ @c
-static int test_count = 1;
-
-#define dorangetest(a,b,c)  do {                                 \
-    if (!(b>=0 && b<c)) {                                        \
-        fprintf(stdout,"For node p:=%d, 0<=%d<%d (l.%d,r.%d)\n", \
-            (int)a, (int)b, (int)c, __LINE__,test_count);        \
-        confusion("node range test failed");                     \
-    } } while (0)
-
-#define dotest(a,b,c) do {                                     \
-    if (b!=c) {                                                \
-        fprintf(stdout,"For node p:=%d, %d==%d (l.%d,r.%d)\n", \
-            (int)a, (int)b, (int)c, __LINE__,test_count);      \
-        confusion("node test failed");                         \
-    } } while (0)
-
-#define check_action_ref(a)    { dorangetest(p,a,var_mem_max); }
-#define check_attribute_ref(a) { dorangetest(p,a,var_mem_max); }
-
-/* hm, we can just pass p then */
-
-#define check_token_ref(p) { \
-    if (type(p) == whatsit_node) { \
-        formatted_error("nodes","fuzzy token cleanup in whatsit node with type %s and subtype %i",node_data[type(p)].name,subtype(p)); \
-    } else { \
-        formatted_error("nodes","fuzzy token cleanup in node with type %s",node_data[type(p)].name); \
-    } \
-}
-
-#ifdef CHECK_NODE_USAGE
-
-static void check_static_node_mem(void)
-{
-    dotest(zero_glue, width(zero_glue), 0);
-    dotest(zero_glue, type(zero_glue), glue_spec_node);
-    dotest(zero_glue, vlink(zero_glue), null);
-    dotest(zero_glue, stretch(zero_glue), 0);
-    dotest(zero_glue, stretch_order(zero_glue), normal);
-    dotest(zero_glue, shrink(zero_glue), 0);
-    dotest(zero_glue, shrink_order(zero_glue), normal);
-
-    dotest(sfi_glue, width(sfi_glue), 0);
-    dotest(sfi_glue, type(sfi_glue), glue_spec_node);
-    dotest(sfi_glue, vlink(sfi_glue), null);
-    dotest(sfi_glue, stretch(sfi_glue), 0);
-    dotest(sfi_glue, stretch_order(sfi_glue), sfi);
-    dotest(sfi_glue, shrink(sfi_glue), 0);
-    dotest(sfi_glue, shrink_order(sfi_glue), normal);
-
-    dotest(fil_glue, width(fil_glue), 0);
-    dotest(fil_glue, type(fil_glue), glue_spec_node);
-    dotest(fil_glue, vlink(fil_glue), null);
-    dotest(fil_glue, stretch(fil_glue), unity);
-    dotest(fil_glue, stretch_order(fil_glue), fil);
-    dotest(fil_glue, shrink(fil_glue), 0);
-    dotest(fil_glue, shrink_order(fil_glue), normal);
-
-    dotest(fill_glue, width(fill_glue), 0);
-    dotest(fill_glue, type(fill_glue), glue_spec_node);
-    dotest(fill_glue, vlink(fill_glue), null);
-    dotest(fill_glue, stretch(fill_glue), unity);
-    dotest(fill_glue, stretch_order(fill_glue), fill);
-    dotest(fill_glue, shrink(fill_glue), 0);
-    dotest(fill_glue, shrink_order(fill_glue), normal);
-
-    dotest(ss_glue, width(ss_glue), 0);
-    dotest(ss_glue, type(ss_glue), glue_spec_node);
-    dotest(ss_glue, vlink(ss_glue), null);
-    dotest(ss_glue, stretch(ss_glue), unity);
-    dotest(ss_glue, stretch_order(ss_glue), fil);
-    dotest(ss_glue, shrink(ss_glue), unity);
-    dotest(ss_glue, shrink_order(ss_glue), fil);
-
-    dotest(fil_neg_glue, width(fil_neg_glue), 0);
-    dotest(fil_neg_glue, type(fil_neg_glue), glue_spec_node);
-    dotest(fil_neg_glue, vlink(fil_neg_glue), null);
-    dotest(fil_neg_glue, stretch(fil_neg_glue), -unity);
-    dotest(fil_neg_glue, stretch_order(fil_neg_glue), fil);
-    dotest(fil_neg_glue, shrink(fil_neg_glue), 0);
-    dotest(fil_neg_glue, shrink_order(fil_neg_glue), normal);
-}
-
-static void node_mem_dump(halfword p)
-{
-    halfword r;
-    for (r = my_prealloc + 1; r < var_mem_max; r++) {
-        if (vlink(r) == p) {
-            halfword s = r;
-            while (s > my_prealloc && varmem_sizes[s] == 0) {
-                s--;
-            }
-            if (s != null
-                && s != my_prealloc
-                && s != var_mem_max
-                && (r - s) < get_node_size(type(s), subtype(s))
-                && alink(s) != p) {
-                if (type(s) == disc_node) {
-                    fprintf(stdout,"  pointed to from %s node %d (vlink %d, alink %d): ",
-                            get_node_name(type(s), subtype(s)), (int) s,
-                            (int) vlink(s), (int) alink(s));
-                    fprintf(stdout, "pre_break(%d,%d,%d), ",
-                            (int) vlink_pre_break(s), (int) tlink(pre_break(s)),
-                            (int) alink(pre_break(s)));
-                    fprintf(stdout, "post_break(%d,%d,%d), ",
-                            (int) vlink_post_break(s),
-                            (int) tlink(post_break(s)),
-                            (int) alink(post_break(s)));
-                    fprintf(stdout, "no_break(%d,%d,%d)",
-                            (int) vlink_no_break(s), (int) tlink(no_break(s)),
-                            (int) alink(no_break(s)));
-                    fprintf(stdout, "\n");
-                } else {
-                    if (vlink(s) == p
-                        || (type(s) == glyph_node && lig_ptr (s) == p)
-                        || (type(s) == vlist_node && list_ptr(s) == p)
-                        || (type(s) == hlist_node && list_ptr(s) == p)
-                        || (type(s) == unset_node && list_ptr(s) == p)
-                        || (type(s) == ins_node   && ins_ptr (s) == p)
-                        ) {
-                        fprintf(stdout,"  pointed to from %s node %d (vlink %d, alink %d): ",
-                                get_node_name(type(s), subtype(s)), (int) s,
-                                (int) vlink(s), (int) alink(s));
-                        if (type(s) == glyph_node) {
-                            fprintf(stdout, "lig_ptr(%d)", (int) lig_ptr(s));
-                        } else if (type(s) == vlist_node || type(s) == hlist_node) {
-                            fprintf(stdout, "list_ptr(%d)", (int) list_ptr(s));
-                        }
-                        fprintf(stdout, "\n");
-                    } else {
-                        if ((type(s) != penalty_node) && (type(s) != math_node) && (type(s) != kern_node)) {
-                            fprintf(stdout, "  pointed to from %s node %d\n",
-                                get_node_name(type(s), subtype(s)), (int) s);
-                        }
-                    }
-                }
-            }
-        }
-    }
-}
-
-#endif
-
-static int free_error(halfword p)
-{
-    if (p > my_prealloc && p < var_mem_max) {
-#ifdef CHECK_NODE_USAGE
-        int i;
-        if (varmem_sizes[p] == 0) {
-            check_static_node_mem();
-            for (i = (my_prealloc + 1); i < var_mem_max; i++) {
-                if (varmem_sizes[i] > 0) {
-                    check_node(i);
-                }
-            }
-            test_count++;
-            if (type(p) == glyph_node) {
-                formatted_error("nodes", "attempt to double-free glyph (%c) node %d, ignored", (int) character(p), (int) p);
-            } else {
-                formatted_error("nodes", "attempt to double-free %s node %d, ignored", get_node_name(type(p), subtype(p)), (int) p);
-            }
-            node_mem_dump(p);
-            return 1;
-        }
-#endif
-    } else {
-        formatted_error("nodes", "attempt to free an impossible node %d", (int) p);
-        return 1;
-    }
-    return 0;
-}
-
-@ @c
-static int copy_error(halfword p)
-{
-    if (p >= 0 && p < var_mem_max) {
-#ifdef CHECK_NODE_USAGE
-        if (p > my_prealloc && varmem_sizes[p] == 0) {
-            if (type(p) == glyph_node) {
-                formatted_warning("nodes", "attempt to copy free glyph (%c) node %d, ignored", (int) character(p), (int) p);
-            } else {
-                formatted_warning("nodes", "attempt to copy free %s node %d, ignored", get_node_name(type(p), subtype(p)), (int) p);
-            }
-            return 1;
-        }
-#endif
-    } else {
-        formatted_error("nodes", "attempt to copy an impossible node %d", (int) p);
-        return 1;
-    }
-    return 0;
-}
-
-@ @c
-static halfword synctex_anyway_mode = 0; /* 2 also glyphs */
-static halfword synctex_line_field  = 0;
-static halfword synctex_no_files    = 0;
-
-void synctex_set_mode(int m)
-{
-    synctex_anyway_mode = m;
-};
-
-int synctex_get_mode(void)
-{
-    return synctex_anyway_mode;
-};
-
-void synctex_set_no_files(int f)
-{
-    synctex_no_files = f;
-};
-
-int synctex_get_no_files(void)
-{
-    return (int) synctex_no_files ;
-};
-
-void synctex_set_tag(int t)
-{
-    cur_input.synctex_tag_field = t;
-};
-
-int synctex_get_tag(void)
-{
-    return (int) cur_input.synctex_tag_field;
-};
-
-
-int synctex_get_line(void)
-{
-    return (int) synctex_line_field;
-};
-
-static int forced_tag  = 0;
-static int forced_line = 0;
-
-void synctex_force_tag(int t)
-{
-    forced_tag = t;
-};
-
-void synctex_force_line(int t)
-{
-    forced_line = t;
-};
-
-void synctex_set_line(int l)
-{
-    synctex_line_field = l;
-};
-
-@ @c
-/* if_stack is called a lot so maybe optimize */
-
-halfword new_node(int i, int j)
-{
-    int s = get_node_size(i, j);
-    halfword n = get_node(s);
-    /*
-        It should be possible to do this memset at |free_node()|.
-
-        Both type() and subtype() will be set below, and vlink() is
-        set to null by |get_node()|, so we can do we clearing one
-        word less than |s|
-    */
-    (void) memset((void *) (varmem + n + 1), 0, (sizeof(memory_word) * ((unsigned) s - 1)));
-    switch (i) {
-        case glyph_node:
-            init_lang_data(n);
-            break;
-        case hlist_node:
-        case vlist_node:
-            box_dir(n) = -1;
-            break;
-        case disc_node:
-            pre_break(n) = pre_break_head(n);
-            type(pre_break(n)) = nesting_node;
-            subtype(pre_break(n)) = pre_break_head(0);
-            post_break(n) = post_break_head(n);
-            type(post_break(n)) = nesting_node;
-            subtype(post_break(n)) = post_break_head(0);
-            no_break(n) = no_break_head(n);
-            type(no_break(n)) = nesting_node;
-            subtype(no_break(n)) = no_break_head(0);
-            break;
-        case rule_node:
-            depth(n) = null_flag;
-            height(n) = null_flag;
-            width(n) = null_flag;
-            rule_dir(n) = -1;
-            rule_index(n) = 0;
-            rule_transform(n) = 0;
-            break;
-        case whatsit_node:
-            if (j == open_node) {
-                open_name(n) = get_nullstr();
-                open_area(n) = open_name(n);
-                open_ext(n) = open_name(n);
-            }
-            break;
-        case unset_node:
-            width(n) = null_flag;
-            break;
-        case pseudo_line_node:
-        case shape_node:
-            /* this is a trick that makes |pseudo_files| slightly slower,
-             but the overall allocation faster then an explicit test
-             at the top of |new_node()|.
-             */
-            if (j>0) {
-              free_node(n, variable_node_size);
-              n = slow_get_node(j);
-              (void) memset((void *) (varmem + n + 1), 0, (sizeof(memory_word) * ((unsigned) j - 1)));
-            }
-            break;
-        default:
-            break;
-    }
-    if (synctex_anyway_mode) {
-        switch (i) {
-            /* 1 = all but glyphs  */
-            /* 2 = also glyphs     */
-            /* 3 = glyphs and glue */
-            /* 4 = only glyphs     */
-            case glyph_node:
-                if (synctex_anyway_mode > 1) {
-                    synctex_tag_glyph(n) = forced_tag ? forced_tag : cur_input.synctex_tag_field;
-                    synctex_line_glyph(n) = forced_line ? forced_line : synctex_line_field ? synctex_line_field : line;
-                }
-                break;
-            case glue_node:
-                if (synctex_anyway_mode < 4) {
-                    synctex_tag_glue(n) = forced_tag ? forced_tag : cur_input.synctex_tag_field;
-                    synctex_line_glue(n) = forced_line ? forced_line : synctex_line_field ? synctex_line_field : line;
-                }
-                break;
-            case kern_node:
-                if (synctex_anyway_mode < 3) {
-                    synctex_tag_kern(n) = forced_tag ? forced_tag : cur_input.synctex_tag_field;
-                    synctex_line_kern(n) = forced_line ? forced_line : synctex_line_field ? synctex_line_field : line;
-                }
-                break;
-            case hlist_node:
-            case vlist_node:
-            case unset_node: /* useless */
-                if (synctex_anyway_mode < 3) {
-                    synctex_tag_box(n) = forced_tag ? forced_tag : cur_input.synctex_tag_field;
-                    synctex_line_box(n) = forced_line ? forced_line : synctex_line_field ? synctex_line_field : line;
-                }
-                break;
-            case rule_node:
-                if (synctex_anyway_mode < 3) {
-                    synctex_tag_rule(n) = forced_tag ? forced_tag : cur_input.synctex_tag_field;
-                    synctex_line_rule(n) = forced_line ? forced_line : synctex_line_field ? synctex_line_field : line;
-                }
-                break;
-            case math_node: /* noads probably make more sense */
-                if (synctex_anyway_mode < 3) {
-                    synctex_tag_math(n) = forced_tag ? forced_tag : cur_input.synctex_tag_field;
-                    synctex_line_math(n) = forced_line ? forced_line : synctex_line_field ? synctex_line_field : line;
-                }
-                break;
-        }
-    } else if (synctex_par) {
-        /* handle synctex extension */
-        switch (i) {
-            case glue_node:
-                synctex_tag_glue(n) = cur_input.synctex_tag_field;
-                synctex_line_glue(n) = line;
-                break;
-            case kern_node:
-                if (j != 0) {
-                    synctex_tag_kern(n) = cur_input.synctex_tag_field;
-                    synctex_line_kern(n) = line;
-                }
-                break;
-            case hlist_node:
-            case vlist_node:
-            case unset_node:
-                synctex_tag_box(n) = cur_input.synctex_tag_field;
-                synctex_line_box(n) = line;
-                break;
-            case rule_node:
-                synctex_tag_rule(n) = cur_input.synctex_tag_field;
-                synctex_line_rule(n) = line;
-                break;
-            case math_node:
-                synctex_tag_math(n) = cur_input.synctex_tag_field;
-                synctex_line_math(n) = line;
-                break;
-        }
-    }
-    /* take care of attributes */
-    if (nodetype_has_attributes(i)) {
-        build_attribute_list(n);
-        /* lua_properties_set */
-    }
-    type(n) = (quarterword) i;
-    subtype(n) = (quarterword) j;
-    return n;
-}
-
-halfword raw_glyph_node(void)
-{
-    register halfword n = get_node(glyph_node_size);
-    (void) memset((void *) (varmem + n + 1), 0, (sizeof(memory_word) * (glyph_node_size - 1)));
-    if (synctex_anyway_mode > 1) {
-        synctex_tag_glyph(n) = forced_tag ? forced_tag : cur_input.synctex_tag_field;
-        synctex_line_glyph(n) = forced_line ? forced_line : synctex_line_field ? synctex_line_field : line;
-    }
-    type(n) = glyph_node;
-    subtype(n) = 0;
-    return n;
-}
-
-halfword new_glyph_node(void)
-{
-    register halfword n = get_node(glyph_node_size);
-    (void) memset((void *) (varmem + n + 1), 0, (sizeof(memory_word) * (glyph_node_size - 1)));
-    if (synctex_anyway_mode > 1) {
-        synctex_tag_glyph(n) = forced_tag ? forced_tag : cur_input.synctex_tag_field;
-        synctex_line_glyph(n) = forced_line ? forced_line : synctex_line_field ? synctex_line_field : line;
-    }
-    type(n) = glyph_node;
-    subtype(n) = 0;
-    build_attribute_list(n);
-    /* lua_properties_set */
-    return n;
-}
-
-@ makes a duplicate of the node list that starts at |p| and returns a
-pointer to the new list
-
-@c
-halfword do_copy_node_list(halfword p, halfword end)
-{
-    halfword q = null; /* previous position in new list */
-    halfword h = null; /* head of the list */
-    register halfword s ;
-    lua_properties_push; /* saves stack and time */
-    while (p != end) {
-        s = copy_node(p);
-        if (h == null) {
-            h = s;
-        } else {
-            couple_nodes(q, s);
-        }
-        q = s;
-        p = vlink(p);
-    }
-    lua_properties_pop; /* saves stack and time */
-    return h;
-}
-
-halfword copy_node_list(halfword p)
-{
-    return do_copy_node_list(p, null);
-}
-
-#define copy_sub_list(target,source) do { \
-     if (source != null) { \
-         s = do_copy_node_list(source, null); \
-         target = s; \
-     } else { \
-         target = null; \
-     } \
- } while (0)
-
-#define copy_sub_node(target,source) do { \
-    if (source != null) { \
-        s = copy_node(source); \
-        target = s ; \
-    } else { \
-        target = null; \
-    } \
-} while (0)
-
-@ make a dupe of a single node
-
-@c
-static void copy_node_wrapup_core(halfword p, halfword r)
-{
-    halfword s ;
-    switch (subtype(p)) {
-        case write_node:
-        case special_node:
-            add_token_ref(write_tokens(p));
-            break;
-        case late_lua_node:
-            copy_late_lua(r, p);
-            break;
-        case user_defined_node:
-            switch (user_node_type(p)) {
-            case 'a':
-                add_node_attr_ref(user_node_value(p));
-                break;
-            case 'l':
-                copy_user_lua(r, p);
-                break;
-            case 'n':
-                s = copy_node_list(user_node_value(p));
-                user_node_value(r) = s;
-                break;
-            case 's':
-                /* |add_string_ref(user_node_value(p));| */
-                break;
-            case 't':
-                add_token_ref(user_node_value(p));
-                break;
-            }
-            break;
-        default:
-            break ;
-    }
-}
-
-void copy_node_wrapup_dvi(halfword p, halfword r)
-{
-}
-
-void copy_node_wrapup_pdf(halfword p, halfword r)
-{
-    switch(subtype(p)) {
-        case pdf_literal_node:
-            copy_pdf_literal(r, p);
-            break;
-        case pdf_colorstack_node:
-            if (pdf_colorstack_cmd(p) <= colorstack_data)
-                add_token_ref(pdf_colorstack_data(p));
-            break;
-        case pdf_setmatrix_node:
-            add_token_ref(pdf_setmatrix_data(p));
-            break;
-        case pdf_annot_node:
-            add_token_ref(pdf_annot_data(p));
-            break;
-        case pdf_start_link_node:
-            if (pdf_link_attr(r) != null)
-                add_token_ref(pdf_link_attr(r));
-            add_action_ref(pdf_link_action(r));
-            break;
-        case pdf_dest_node:
-            if (pdf_dest_named_id(p) > 0)
-                add_token_ref(pdf_dest_id(p));
-            break;
-        case pdf_thread_node:
-        case pdf_start_thread_node:
-            if (pdf_thread_named_id(p) > 0)
-                add_token_ref(pdf_thread_id(p));
-            if (pdf_thread_attr(p) != null)
-                add_token_ref(pdf_thread_attr(p));
-            break;
-        default:
-            break;
-    }
-}
-
-halfword copy_node(const halfword p)
-{
-    halfword r;                 /* current node being fabricated for new list */
-    halfword w;                 /* whatsit subtype */
-    halfword t;                 /* type of node */
-    register halfword s;        /* a helper variable for copying into variable mem  */
-    register int i;
-    if (copy_error(p)) {
-        r = new_node(temp_node, 0);
-        return r;
-    }
-    t = type(p);
-    i = get_node_size(t,subtype(p));
-    r = get_node(i);
-
-    (void) memcpy((void *) (varmem + r), (void *) (varmem + p), (sizeof(memory_word) * (unsigned) i));
-
-    /* possible speedup: */
-    /*
-        if t == glue_spec) {
-            return r;
-        }
-    */
-
-    if (synctex_anyway_mode) {
-        /*
-        if (t == glyph_node) {
-            if (synctex_anyway_mode > 1) {
-                synctex_tag_glyph(r) = forced_tag ? forced_tag : cur_input.synctex_tag_field;
-                synctex_line_glyph(r) = forced_line ? forced_line : synctex_line_field ? synctex_line_field : line;
-            }
-        }
-        */
-    } else if (synctex_par) {
-        /* handle synctex extension */
-        switch (t) {
-            case math_node:
-                synctex_tag_math(r) = cur_input.synctex_tag_field;
-                synctex_line_math(r) = line;
-                break;
-            case kern_node:
-                synctex_tag_kern(r) = cur_input.synctex_tag_field;
-                synctex_line_kern(r) = line;
-                break;
-        }
-    }
-    if (nodetype_has_attributes(t)) {
-        add_node_attr_ref(node_attr(p));
-        alink(r) = null;
-        lua_properties_copy(r,p);
-    }
-    vlink(r) = null;
-
-    switch (t) {
-        case glyph_node:
-            copy_sub_list(lig_ptr(r),lig_ptr(p)) ;
-            break;
-        case glue_node:
-            copy_sub_list(leader_ptr(r),leader_ptr(p)) ;
-            break;
-        case hlist_node:
-        case vlist_node:
-        case unset_node:
-            copy_sub_list(list_ptr(r),list_ptr(p)) ;
-            break;
-        case disc_node:
-            pre_break(r) = pre_break_head(r);
-            if (vlink_pre_break(p) != null) {
-                s = copy_node_list(vlink_pre_break(p));
-                alink(s) = pre_break(r);
-                tlink_pre_break(r) = tail_of_list(s);
-                vlink_pre_break(r) = s;
-            } else {
-                assert(tlink(pre_break(r)) == null);
-            }
-            post_break(r) = post_break_head(r);
-            if (vlink_post_break(p) != null) {
-                s = copy_node_list(vlink_post_break(p));
-                alink(s) = post_break(r);
-                tlink_post_break(r) = tail_of_list(s);
-                vlink_post_break(r) = s;
-            } else {
-                assert(tlink_post_break(r) == null);
-            }
-            no_break(r) = no_break_head(r);
-            if (vlink(no_break(p)) != null) {
-                s = copy_node_list(vlink_no_break(p));
-                alink(s) = no_break(r);
-                tlink_no_break(r) = tail_of_list(s);
-                vlink_no_break(r) = s;
-            } else {
-                assert(tlink_no_break(r) == null);
-            }
-            break;
-        case math_node:
-            break;
-        case ins_node:
-            copy_sub_list(ins_ptr(r),ins_ptr(p)) ;
-            break;
-        case margin_kern_node:
-            copy_sub_node(margin_char(r),margin_char(p));
-            break;
-        case mark_node:
-            add_token_ref(mark_ptr(p));
-            break;
-        case adjust_node:
-            copy_sub_list(adjust_ptr(r),adjust_ptr(p));
-            break;
-        case choice_node:
-            copy_sub_list(display_mlist(r),display_mlist(p)) ;
-            copy_sub_list(text_mlist(r),text_mlist(p)) ;
-            copy_sub_list(script_mlist(r),script_mlist(p)) ;
-            copy_sub_list(script_script_mlist(r),script_script_mlist(p)) ;
-            break;
-        case simple_noad:
-            copy_sub_list(nucleus(r),nucleus(p)) ;
-            copy_sub_list(subscr(r),subscr(p)) ;
-            copy_sub_list(supscr(r),supscr(p)) ;
-            break;
-        case radical_noad:
-            copy_sub_list(nucleus(r),nucleus(p)) ;
-            copy_sub_list(subscr(r),subscr(p)) ;
-            copy_sub_list(supscr(r),supscr(p)) ;
-            copy_sub_node(left_delimiter(r),left_delimiter(p)) ;
-            copy_sub_list(degree(r),degree(p)) ;
-            break;
-        case accent_noad:
-            copy_sub_list(nucleus(r),nucleus(p)) ;
-            copy_sub_list(subscr(r),subscr(p)) ;
-            copy_sub_list(supscr(r),supscr(p)) ;
-            copy_sub_list(top_accent_chr(r),top_accent_chr(p)) ;
-            copy_sub_list(bot_accent_chr(r),bot_accent_chr(p)) ;
-            copy_sub_list(overlay_accent_chr(r),overlay_accent_chr(p)) ;
-            break;
-        case fence_noad:
-            copy_sub_node(delimiter(r),delimiter(p)) ;
-            break;
-        case sub_box_node:
-        case sub_mlist_node:
-            copy_sub_list(math_list(r),math_list(p)) ;
-            break;
-        case fraction_noad:
-            copy_sub_list(numerator(r),numerator(p)) ;
-            copy_sub_list(denominator(r),denominator(p)) ;
-            copy_sub_node(left_delimiter(r),left_delimiter(p)) ;
-            copy_sub_node(right_delimiter(r),right_delimiter(p)) ;
-            break;
-        case glue_spec_node:
-        case dir_node:
-        case local_par_node:
-        case boundary_node:
-            break;
-        case whatsit_node:
-            w = subtype(p) ;
-            if (w >= backend_first_pdf_whatsit) {
-                copy_node_wrapup_pdf(p,r);
-            } else if (w >= backend_first_dvi_whatsit) {
-                copy_node_wrapup_dvi(p,r);
-            } else {
-                copy_node_wrapup_core(p,r);
-            }
-            break;
-    }
-    return r;
-}
-
-/* x */
-
-#define free_sub_list(source) if (source != null) flush_node_list(source);
-#define free_sub_node(source) if (source != null) flush_node(source);
-
-@ @c
-
-static void flush_node_wrapup_core(halfword p)
-{
-    switch (subtype(p)) {
-        case open_node:
-        case write_node:
-        case close_node:
-        case save_pos_node:
-            break;
-        case special_node:
-            delete_token_ref(write_tokens(p));
-            break;
-        case late_lua_node:
-            free_late_lua(p);
-            break;
-        case user_defined_node:
-            switch (user_node_type(p)) {
-            case 'a':
-                delete_attribute_ref(user_node_value(p));
-                break;
-            case 'd':
-                break;
-            case 'l':
-                free_user_lua(user_node_value(p));
-                break;
-            case 'n':
-                flush_node_list(user_node_value(p));
-                break;
-            case 's':
-                /* |delete_string_ref(user_node_value(p));| *//* if this was mpost .. */
-                break;
-            case 't':
-                delete_token_ref(user_node_value(p));
-                break;
-            default:
-                {
-                    const char *hlp[] = {
-                        "The type of the value in a user defined whatsit node should be one",
-                        "of 'a' (attribute list), 'd' (number), 'n' (node list), 's' (string),",
-                        "or 't' (tokenlist). Yours has an unknown type, and therefore I don't",
-                        "know how to free the node's value. A memory leak may result.",
-                        NULL
-                    };
-                    tex_error("Unidentified user defined whatsit", hlp);
-                }
-                break;
-            }
-            break;
-    }
-}
-
-void flush_node_wrapup_dvi(halfword p)
-{
-}
-
-void flush_node_wrapup_pdf(halfword p)
-{
-    switch(subtype(p)) {
-        case pdf_save_node:
-        case pdf_restore_node:
-        case pdf_refobj_node:
-        case pdf_end_link_node:
-        case pdf_end_thread_node:
-            break;
-        case pdf_literal_node:
-            free_pdf_literal(p);
-            break;
-        case pdf_colorstack_node:
-            if (pdf_colorstack_cmd(p) <= colorstack_data)
-                delete_token_ref(pdf_colorstack_data(p));
-            break;
-        case pdf_setmatrix_node:
-            delete_token_ref(pdf_setmatrix_data(p));
-            break;
-        case pdf_annot_node:
-            delete_token_ref(pdf_annot_data(p));
-            break;
-        case pdf_link_data_node:
-            break;
-        case pdf_start_link_node:
-            if (pdf_link_attr(p) != null)
-                delete_token_ref(pdf_link_attr(p));
-            delete_action_ref(pdf_link_action(p));
-            break;
-        case pdf_dest_node:
-            if (pdf_dest_named_id(p) > 0)
-                delete_token_ref(pdf_dest_id(p));
-            break;
-        case pdf_action_node:
-            if (pdf_action_type(p) == pdf_action_user) {
-                delete_token_ref(pdf_action_tokens(p));
-            } else {
-                if (pdf_action_file(p) != null)
-                    delete_token_ref(pdf_action_file(p));
-                if (pdf_action_type(p) == pdf_action_page)
-                    delete_token_ref(pdf_action_tokens(p));
-                else if (pdf_action_named_id(p) > 0)
-                    delete_token_ref(pdf_action_id(p));
-            }
-            break;
-        case pdf_thread_data_node:
-            break;
-        case pdf_thread_node:
-        case pdf_start_thread_node:
-            if (pdf_thread_named_id(p) > 0)
-                delete_token_ref(pdf_thread_id(p));
-            if (pdf_thread_attr(p) != null)
-                delete_token_ref(pdf_thread_attr(p));
-            break;
-    }
-}
-
-void flush_node(halfword p)
-{
-    halfword w;
-    if (p == null)              /* legal, but no-op */
-        return;
-    if (free_error(p))
-        return;
-    switch (type(p)) {
-        case glyph_node:
-            free_sub_list(lig_ptr(p));
-            break;
-        case glue_node:
-            free_sub_list(leader_ptr(p));
-            break;
-        case hlist_node:
-        case vlist_node:
-        case unset_node:
-            free_sub_list(list_ptr(p));
-            break;
-        case disc_node:
-            /* watch the start at temp node hack */
-            free_sub_list(vlink(pre_break(p)));
-            free_sub_list(vlink(post_break(p)));
-            free_sub_list(vlink(no_break(p)));
-            break;
-        case rule_node:
-        case kern_node:
-        case penalty_node:
-        case math_node:
-            break;
-        case glue_spec_node:
-            /* this allows free-ing of lua-allocated glue specs */
-//if (valid_node(p)) {
-//    free_node(p, subtype(p));
-//}
-//            return ;
-            break ;
-        case dir_node:
-        case local_par_node:
-        case boundary_node:
-            break;
-        case whatsit_node:
-            w = subtype(p) ;
-            if (w >= backend_first_pdf_whatsit) {
-                flush_node_wrapup_pdf(p);
-            } else if (w >= backend_first_dvi_whatsit) {
-                flush_node_wrapup_dvi(p);
-            } else {
-                flush_node_wrapup_core(p);
-            }
-            break;
-        case ins_node:
-            flush_node_list(ins_ptr(p));
-            break;
-        case margin_kern_node:
-            flush_node(margin_char(p));
-            break;
-        case mark_node:
-            delete_token_ref(mark_ptr(p));
-            break;
-        case adjust_node:
-            flush_node_list(adjust_ptr(p));
-            break;
-        case style_node:           /* nothing to do */
-            break;
-        case choice_node:
-            free_sub_list(display_mlist(p));
-            free_sub_list(text_mlist(p));
-            free_sub_list(script_mlist(p));
-            free_sub_list(script_script_mlist(p));
-            break;
-        case simple_noad:
-            free_sub_list(nucleus(p));
-            free_sub_list(subscr(p));
-            free_sub_list(supscr(p));
-            break;
-        case radical_noad:
-            free_sub_list(nucleus(p));
-            free_sub_list(subscr(p));
-            free_sub_list(supscr(p));
-            free_sub_node(left_delimiter(p));
-            free_sub_list(degree(p));
-            break;
-        case accent_noad:
-            free_sub_list(nucleus(p));
-            free_sub_list(subscr(p));
-            free_sub_list(supscr(p));
-            free_sub_list(top_accent_chr(p));
-            free_sub_list(bot_accent_chr(p));
-            free_sub_list(overlay_accent_chr(p));
-            break;
-        case fence_noad:
-            free_sub_list(delimiter(p));
-            break;
-        case delim_node:           /* nothing to do */
-        case math_char_node:
-        case math_text_char_node:
-            break;
-        case sub_box_node:
-        case sub_mlist_node:
-            free_sub_list(math_list(p));
-            break;
-        case fraction_noad:
-            free_sub_list(numerator(p));
-            free_sub_list(denominator(p));
-            free_sub_node(left_delimiter(p));
-            free_sub_node(right_delimiter(p));
-            break;
-        case pseudo_file_node:
-            free_sub_list(pseudo_lines(p));
-            break;
-        case pseudo_line_node:
-        case shape_node:
-            free_node(p, subtype(p));
-            return;
-            break;
-        case align_stack_node:
-        case span_node:
-        case movement_node:
-        case if_node:
-        case nesting_node:
-        case unhyphenated_node:
-        case hyphenated_node:
-        case delta_node:
-        case passive_node:
-        case inserting_node:
-        case split_up_node:
-        case expr_node:
-        case attribute_node:
-        case attribute_list_node:
-        case temp_node:
-            break;
-        default:
-            formatted_error("nodes","flushing weird node type %d", type(p));
-            return;
-    }
-    if (nodetype_has_attributes(type(p))) {
-        delete_attribute_ref(node_attr(p));
-        lua_properties_reset(p);
-    }
-    free_node(p, get_node_size(type(p), subtype(p)));
-    return;
-}
-
-@ @c
-void flush_node_list(halfword pp)
-{                               /* erase list of nodes starting at |p| */
-    register halfword p = pp;
-    if (p == null)              /* legal, but no-op */
-        return;
-    if (free_error(p))
-        return;
-    lua_properties_push; /* saves stack and time */
-    while (p != null) {
-        register halfword q = vlink(p);
-        flush_node(p);
-        p = q;
-    }
-    lua_properties_pop; /* saves stack and time */
-}
-
-@ @c
-static void check_node_wrapup_core(halfword p)
-{
-    switch (subtype(p)) {
-        /* frontend code */
-        case special_node:
-            check_token_ref(p);
-            break;
-        case user_defined_node:
-            switch (user_node_type(p)) {
-                case 'a':
-                    check_attribute_ref(user_node_value(p));
-                    break;
-                case 't':
-                    check_token_ref(p);
-                    break;
-                case 'n':
-                    dorangetest(p, user_node_value(p), var_mem_max);
-                    break;
-                case 's':
-                case 'd':
-                    break;
-                default:
-                    confusion("unknown user node type");
-                    break;
-            }
-            break;
-        case open_node:
-        case write_node:
-        case close_node:
-        case save_pos_node:
-            break;
-    }
-}
-
-void check_node_wrapup_dvi(halfword p)
-{
-}
-
-void check_node_wrapup_pdf(halfword p)
-{
-    switch (subtype(p)) {
-        case pdf_literal_node:
-            if (pdf_literal_type(p) == normal)
-                check_token_ref(p);
-            break;
-        case pdf_colorstack_node:
-            if (pdf_colorstack_cmd(p) <= colorstack_data)
-                check_token_ref(p);
-            break;
-        case pdf_setmatrix_node:
-            check_token_ref(p);
-            break;
-        case late_lua_node:
-            if (late_lua_name(p) > 0)
-                check_token_ref(p);
-            if (late_lua_type(p) == normal)
-                check_token_ref(p);
-            break;
-        case pdf_annot_node:
-            check_token_ref(p);
-            break;
-        case pdf_start_link_node:
-            if (pdf_link_attr(p) != null)
-                check_token_ref(p);
-            check_action_ref(pdf_link_action(p));
-            break;
-        case pdf_dest_node:
-            if (pdf_dest_named_id(p) > 0)
-                check_token_ref(p);
-            break;
-        case pdf_thread_node:
-        case pdf_start_thread_node:
-            if (pdf_thread_named_id(p) > 0)
-                check_token_ref(p);
-            if (pdf_thread_attr(p) != null)
-                check_token_ref(p);
-            break;
-        case pdf_save_node:
-        case pdf_restore_node:
-        case pdf_refobj_node:
-        case pdf_end_link_node:
-        case pdf_end_thread_node:
-            break;
-        default:
-            confusion("wrapup pdf nodes");
-            break;
-    }
-}
-
-void check_node(halfword p)
-{
-    halfword w ;
-    switch (type(p)) {
-        case glyph_node:
-            dorangetest(p, lig_ptr(p), var_mem_max);
-            break;
-        case glue_node:
-            dorangetest(p, leader_ptr(p), var_mem_max);
-            break;
-        case hlist_node:
-        case vlist_node:
-        case unset_node:
-        case align_record_node:
-            dorangetest(p, list_ptr(p), var_mem_max);
-            break;
-        case ins_node:
-            dorangetest(p, ins_ptr(p), var_mem_max);
-            break;
-        case whatsit_node:
-            w = subtype(p) ;
-            if (w >= backend_first_pdf_whatsit) {
-                check_node_wrapup_pdf(p);
-            } else if (w >= backend_first_dvi_whatsit) {
-                check_node_wrapup_dvi(p);
-            } else {
-                check_node_wrapup_core(p);
-            }
-            break;
-        case margin_kern_node:
-            check_node(margin_char(p));
-            break;
-        case math_node:
-            break;
-        case disc_node:
-            dorangetest(p, vlink(pre_break(p)), var_mem_max);
-            dorangetest(p, vlink(post_break(p)), var_mem_max);
-            dorangetest(p, vlink(no_break(p)), var_mem_max);
-            break;
-        case adjust_node:
-            dorangetest(p, adjust_ptr(p), var_mem_max);
-            break;
-        case pseudo_file_node:
-            dorangetest(p, pseudo_lines(p), var_mem_max);
-            break;
-        case pseudo_line_node:
-        case shape_node:
-            break;
-        case choice_node:
-            dorangetest(p, display_mlist(p), var_mem_max);
-            dorangetest(p, text_mlist(p), var_mem_max);
-            dorangetest(p, script_mlist(p), var_mem_max);
-            dorangetest(p, script_script_mlist(p), var_mem_max);
-            break;
-        case fraction_noad:
-            dorangetest(p, numerator(p), var_mem_max);
-            dorangetest(p, denominator(p), var_mem_max);
-            dorangetest(p, left_delimiter(p), var_mem_max);
-            dorangetest(p, right_delimiter(p), var_mem_max);
-            break;
-        case simple_noad:
-            dorangetest(p, nucleus(p), var_mem_max);
-            dorangetest(p, subscr(p), var_mem_max);
-            dorangetest(p, supscr(p), var_mem_max);
-            break;
-        case radical_noad:
-            dorangetest(p, nucleus(p), var_mem_max);
-            dorangetest(p, subscr(p), var_mem_max);
-            dorangetest(p, supscr(p), var_mem_max);
-            dorangetest(p, degree(p), var_mem_max);
-            dorangetest(p, left_delimiter(p), var_mem_max);
-            break;
-        case accent_noad:
-            dorangetest(p, nucleus(p), var_mem_max);
-            dorangetest(p, subscr(p), var_mem_max);
-            dorangetest(p, supscr(p), var_mem_max);
-            dorangetest(p, top_accent_chr(p), var_mem_max);
-            dorangetest(p, bot_accent_chr(p), var_mem_max);
-            dorangetest(p, overlay_accent_chr(p), var_mem_max);
-            break;
-        case fence_noad:
-            dorangetest(p, delimiter(p), var_mem_max);
-            break;
-        /*
-        case rule_node:
-        case kern_node:
-        case penalty_node:
-        case mark_node:
-        case style_node:
-        case attribute_list_node:
-        case attribute_node:
-        case glue_spec_node:
-        case temp_node:
-        case align_stack_node:
-        case movement_node:
-        case if_node:
-        case nesting_node:
-        case span_node:
-        case unhyphenated_node:
-        case hyphenated_node:
-        case delta_node:
-        case passive_node:
-        case expr_node:
-        case dir_node:
-        case boundary_node:
-        case local_par_node:
-            break;
-        default:
-            fprintf(stdout, "check_node: type is %d\n", type(p));
-        */
-    }
-}
-
-@ @c
-halfword fix_node_list(halfword head)
-{
-    halfword next, tail;
-    if (head == null)
-        return null;
-    tail = head;
-    next = vlink(head);
-    while (next != null) {
-        alink(next) = tail;
-        tail = next;
-        next = vlink(tail);
-    }
-    return tail;
-}
-
-@ @c
-halfword get_node(int s)
-{
-    register halfword r;
-
-    if (s < MAX_CHAIN_SIZE) {
-        r = free_chain[s];
-        if (r != null) {
-            free_chain[s] = vlink(r);
-#ifdef CHECK_NODE_USAGE
-            varmem_sizes[r] = (char) s;
-#endif
-            vlink(r) = null;
-            var_used += s; /* maintain usage statistics */
-            return r;
-        }
-        /* this is the end of the 'inner loop' */
-        return slow_get_node(s);
-    } else {
-        normal_error("nodes","there is a problem in getting a node, case 1");
-        return null;
-    }
-}
-
-@ @c
-void free_node(halfword p, int s)
-{
-    if (p <= my_prealloc) {
-        formatted_error("nodes", "node number %d of type %d should not be freed", (int) p, type(p));
-        return;
-    }
-#ifdef CHECK_NODE_USAGE
-    varmem_sizes[p] = 0;
-#endif
-    if (s < MAX_CHAIN_SIZE) {
-        vlink(p) = free_chain[s];
-        free_chain[s] = p;
-    } else {
-        /* todo ? it is perhaps possible to merge this node with an existing rover */
-        node_size(p) = s;
-        vlink(p) = rover;
-        while (vlink(rover) != vlink(p)) {
-            rover = vlink(rover);
-        }
-        vlink(rover) = p;
-    }
-    /* maintain statistics */
-    var_used -= s;
-}
-
-@ @c
-static void free_node_chain(halfword q, int s)
-{
-    register halfword p = q;
-    while (vlink(p) != null) {
-#ifdef CHECK_NODE_USAGE
-        varmem_sizes[p] = 0;
-#endif
-        var_used -= s;
-        p = vlink(p);
-    }
-    var_used -= s;
-#ifdef CHECK_NODE_USAGE
-    varmem_sizes[p] = 0;
-#endif
-    vlink(p) = free_chain[s];
-    free_chain[s] = q;
-}
-
-@ At the start of the node memory area we reserve some special nodes,
-for instance frequently used glue specifications. We could as well just
-use new_glue here but for the moment we stick to the traditional approach.
-
-@c
-#define initialize_glue(n,wi,st,sh,sto,sho) \
-    vlink(n) = null; \
-    type(n) = glue_spec_node; \
-    width(n) = wi; \
-    stretch(n) = st; \
-    shrink(n) = sh; \
-    stretch_order(n) = sto; \
-    shrink_order(n) = sho;
-
-#define initialize_whatever(n,t) \
-    vinfo(n) = 0; \
-    type(n) = t; \
-    vlink(n) = null; \
-    alink(n) = null;
-
-#define initialize_point(n) \
-    type(n) = glyph_node; \
-    subtype(n) = 0; \
-    vlink(n) = null; \
-    vinfo(n + 1) = null; \
-    alink(n) = null; \
-    font(n) = 0; \
-    character(n) = '.'; \
-    vinfo(n + 3) = 0; \
-    vlink(n + 3) = 0; \
-    vinfo(n + 4) = 0; \
-    vlink(n + 4) = 0;
-
-void init_node_mem(int t)
-{
-    my_prealloc = var_mem_stat_max;
-
-    varmem = (memory_word *) realloc((void *) varmem, sizeof(memory_word) * (unsigned) t);
-    if (varmem == NULL) {
-        overflow("node memory size", (unsigned) var_mem_max);
-    }
-    memset((void *) (varmem), 0, (unsigned) t * sizeof(memory_word));
-#ifdef CHECK_NODE_USAGE
-    varmem_sizes = (char *) realloc(varmem_sizes, sizeof(char) * (unsigned) t);
-    if (varmem_sizes == NULL) {
-        overflow("node memory size", (unsigned) var_mem_max);
-    }
-    memset((void *) varmem_sizes, 0, sizeof(char) * (unsigned) t);
-#endif
-    var_mem_max = t;
-    rover = var_mem_stat_max + 1;
-    vlink(rover) = rover;
-    node_size(rover) = (t - rover);
-    var_used = 0;
-
-    /* initialize static glue specs */
-
-    initialize_glue(zero_glue,0,0,0,0,0);
-    initialize_glue(sfi_glue,0,0,0,sfi,0);
-    initialize_glue(fil_glue,0,unity,0,fil,0);
-    initialize_glue(fill_glue,0,unity,0,fill,0);
-    initialize_glue(ss_glue,0,unity,unity,fil,fil);
-    initialize_glue(fil_neg_glue,0,-unity,0,fil,0);
-
-    /* initialize node list heads */
-
-    initialize_whatever(page_ins_head,temp_node);
-    initialize_whatever(contrib_head,temp_node);
-    initialize_whatever(page_head,temp_node);
-    initialize_whatever(temp_head,temp_node);
-    initialize_whatever(hold_head,temp_node);
-    initialize_whatever(adjust_head,temp_node);
-    initialize_whatever(pre_adjust_head,temp_node);
-    initialize_whatever(align_head,temp_node);
-
-    initialize_whatever(active,unhyphenated_node);
-    initialize_whatever(end_span,span_node);
-
-    initialize_point(begin_point);
-    initialize_point(end_point);
-}
-
-@ @c
-void dump_node_mem(void)
-{
-    dump_int(var_mem_max);
-    dump_int(rover);
-    dump_things(varmem[0], var_mem_max);
-#ifdef CHECK_NODE_USAGE
-    dump_things(varmem_sizes[0], var_mem_max);
-#endif
-    dump_things(free_chain[0], MAX_CHAIN_SIZE);
-    dump_int(var_used);
-    dump_int(my_prealloc);
-}
-
-@ it makes sense to enlarge the varmem array immediately
-@c
-
-void undump_node_mem(void)
-{
-    int x;
-    undump_int(x);
-    undump_int(rover);
-    var_mem_max = (x < 100000 ? 100000 : x);
-    varmem = xmallocarray(memory_word, (unsigned) var_mem_max);
-    undump_things(varmem[0], x);
-#ifdef CHECK_NODE_USAGE
-    varmem_sizes = xmallocarray(char, (unsigned) var_mem_max);
-    memset((void *) varmem_sizes, 0, (unsigned) var_mem_max * sizeof(char));
-    undump_things(varmem_sizes[0], x);
-#endif
-    undump_things(free_chain[0], MAX_CHAIN_SIZE);
-    undump_int(var_used);
-    undump_int(my_prealloc);
-    if (var_mem_max > x) {
-        /* todo ? it is perhaps possible to merge the new node with an existing rover */
-        vlink(x) = rover;
-        node_size(x) = (var_mem_max - x);
-        while (vlink(rover) != vlink(x)) {
-            rover = vlink(rover);
-        }
-        vlink(rover) = x;
-    }
-}
-
-@ @c
-halfword slow_get_node(int s)
-{
-    register int t;
-
-  RETRY:
-    t = node_size(rover);
-    if (vlink(rover) < var_mem_max && vlink(rover) != 0) {
-        if (t > s) {
-            /* allocating from the bottom helps decrease page faults */
-            register halfword r = rover;
-            rover += s;
-            vlink(rover) = vlink(r);
-            node_size(rover) = node_size(r) - s;
-            if (vlink(rover) != r) {        /* list is longer than one */
-                halfword q = r;
-                while (vlink(q) != r) {
-                    q = vlink(q);
-                }
-                vlink(q) += s;
-            } else {
-                vlink(rover) += s;
-            }
-            if (vlink(rover) < var_mem_max) {
-#ifdef CHECK_NODE_USAGE
-                varmem_sizes[r] = (char) (s > 127 ? 127 : s);
-#endif
-                vlink(r) = null;
-                var_used += s;          /* maintain usage statistics */
-                return r;               /* this is the only exit */
-            } else {
-                normal_error("nodes","there is a problem in getting a node, case 2");
-                return null;
-            }
-        } else {
-            /* attempt to keep the free list small */
-            int x;
-            if (vlink(rover) != rover) {
-                if (t < MAX_CHAIN_SIZE) {
-                    halfword l = vlink(rover);
-                    vlink(rover) = free_chain[t];
-                    free_chain[t] = rover;
-                    rover = l;
-                    while (vlink(l) != free_chain[t]) {
-                        l = vlink(l);
-                    }
-                    vlink(l) = rover;
-                    goto RETRY;
-                } else {
-                    halfword l = rover;
-                    while (vlink(rover) != l) {
-                        if (node_size(rover) > s) {
-                            goto RETRY;
-                        }
-                        rover = vlink(rover);
-                    }
-                }
-            }
-            /* if we are still here, it was apparently impossible to get a match */
-            x = (var_mem_max >> 2) + s;
-            varmem = (memory_word *) realloc((void *) varmem, sizeof(memory_word) * (unsigned) (var_mem_max + x));
-            if (varmem == NULL) {
-                overflow("node memory size", (unsigned) var_mem_max);
-            }
-            memset((void *) (varmem + var_mem_max), 0, (unsigned) x * sizeof(memory_word));
-#ifdef CHECK_NODE_USAGE
-            varmem_sizes = (char *) realloc(varmem_sizes, sizeof(char) * (unsigned) (var_mem_max + x));
-            if (varmem_sizes == NULL) {
-                overflow("node memory size", (unsigned) var_mem_max);
-            }
-            memset((void *) (varmem_sizes + var_mem_max), 0, (unsigned) (x) * sizeof(char));
-#endif
-            /* todo ? it is perhaps possible to merge the new memory with an existing rover */
-            vlink(var_mem_max) = rover;
-            node_size(var_mem_max) = x;
-            while (vlink(rover) != vlink(var_mem_max)) {
-                rover = vlink(rover);
-            }
-            vlink(rover) = var_mem_max;
-            rover = var_mem_max;
-            var_mem_max += x;
-            goto RETRY;
-        }
-    } else {
-        normal_error("nodes","there is a problem in getting a node, case 3");
-        return null;
-    }
-}
-
-@ @c
-char *sprint_node_mem_usage(void)
-{
-    char *s;
-#ifdef CHECK_NODE_USAGE
-    char *ss;
-    int i;
-    int b = 0;
-    char msg[256];
-    int node_counts[last_normal_node + last_whatsit_node + 2] = { 0 };
-    s = strdup("");
-    for (i = (var_mem_max - 1); i > my_prealloc; i--) {
-        if (varmem_sizes[i] > 0) {
-            if (type(i) > last_normal_node + last_whatsit_node) {
-                node_counts[last_normal_node + last_whatsit_node + 1]++;
-            } else if (type(i) == whatsit_node) {
-                node_counts[(subtype(i) + last_normal_node + 1)]++;
-            } else {
-                node_counts[type(i)]++;
-            }
-        }
-    }
-    for (i = 0; i < last_normal_node + last_whatsit_node + 2; i++) {
-        if (node_counts[i] > 0) {
-            int j =
-                (i > (last_normal_node + 1) ? (i - last_normal_node - 1) : 0);
-            snprintf(msg, 255, "%s%d %s", (b ? ", " : ""), (int) node_counts[i],
-                     get_node_name((i > last_normal_node ? whatsit_node : i), j));
-            ss = xmalloc((unsigned) (strlen(s) + strlen(msg) + 1));
-            strcpy(ss, s);
-            strcat(ss, msg);
-            free(s);
-            s = ss;
-            b = 1;
-        }
-    }
-#else
-    s = strdup("");
-#endif
-    return s;
-}
-
-@ @c
-halfword list_node_mem_usage(void)
-{
-    halfword q = null;
-#ifdef CHECK_NODE_USAGE
-    halfword p = null;
-    halfword i, j;
-    char *saved_varmem_sizes = xmallocarray(char, (unsigned) var_mem_max);
-    memcpy(saved_varmem_sizes, varmem_sizes, (size_t) var_mem_max);
-    for (i = my_prealloc + 1; i < (var_mem_max - 1); i++) {
-        if (saved_varmem_sizes[i] > 0) {
-            j = copy_node(i);
-            if (p == null) {
-                q = j;
-            } else {
-                vlink(p) = j;
-            }
-            p = j;
-        }
-    }
-    free(saved_varmem_sizes);
-#endif
-    return q;
-}
-
-@ @c
-void print_node_mem_stats(void)
-{
-    int i, b;
-    halfword j;
-    char msg[256];
-    char *s;
-    int free_chain_counts[MAX_CHAIN_SIZE] = { 0 };
-    snprintf(msg, 255, " %d words of node memory still in use:", (int) (var_used + my_prealloc));
-    tprint_nl(msg);
-    s = sprint_node_mem_usage();
-    tprint_nl("   ");
-    tprint(s);
-    free(s);
-    tprint(" nodes");
-    tprint_nl("   avail lists: ");
-    b = 0;
-    for (i = 1; i < MAX_CHAIN_SIZE; i++) {
-        for (j = free_chain[i]; j != null; j = vlink(j))
-            free_chain_counts[i]++;
-        if (free_chain_counts[i] > 0) {
-            snprintf(msg, 255, "%s%d:%d", (b ? "," : ""), i, (int) free_chain_counts[i]);
-            tprint(msg);
-            b = 1;
-        }
-    }
-    /* newline, if needed */
-    print_nlp();
-}
-
-/* this belongs in the web but i couldn't find the correct syntactic place */
-
-halfword new_span_node(halfword n, int s, scaled w)
-{
-    halfword p = new_node(span_node, 0);
-    span_link(p) = n;
-    span_span(p) = s;
-    width(p) = w;
-    return p;
-}
-
-@* Attribute stuff.
-
-@c
-static halfword new_attribute_node(unsigned int i, int v)
-{
-    register halfword r = get_node(attribute_node_size);
-    type(r) = attribute_node;
-    attribute_id(r) = (halfword) i;
-    attribute_value(r) = v;
-    /* not used but nicer in print */
-    subtype(r) = 0;
-    return r;
-}
-
-@ @c
-halfword copy_attribute_list(halfword n)
-{
-    halfword q = get_node(attribute_node_size);
-    register halfword p = q;
-    type(p) = attribute_list_node;
-    attr_list_ref(p) = 0;
-    n = vlink(n);
-    while (n != null) {
-        register halfword r = get_node(attribute_node_size);
-        /* the link will be fixed automatically in the next loop */
-        (void) memcpy((void *) (varmem + r), (void *) (varmem + n),
-                      (sizeof(memory_word) * attribute_node_size));
-        vlink(p) = r;
-        p = r;
-        n = vlink(n);
-    }
-    return q;
-}
-
-@ @c
-void update_attribute_cache(void)
-{
-    halfword p;
-    register int i;
-    attr_list_cache = get_node(attribute_node_size);
-    type(attr_list_cache) = attribute_list_node;
-    attr_list_ref(attr_list_cache) = 0;
-    p = attr_list_cache;
-    for (i = 0; i <= max_used_attr; i++) {
-        register int v = attribute(i);
-        if (v > UNUSED_ATTRIBUTE) {
-            register halfword r = new_attribute_node((unsigned) i, v);
-            vlink(p) = r;
-            p = r;
-        }
-    }
-    if (vlink(attr_list_cache) == null) {
-        free_node(attr_list_cache, attribute_node_size);
-        attr_list_cache = null;
-    }
-    return;
-}
-
-@ @c
-void build_attribute_list(halfword b)
-{
-    if (max_used_attr >= 0) {
-        if (attr_list_cache == cache_disabled|| attr_list_cache == null) {
-            update_attribute_cache();
-            if (attr_list_cache == null)
-                return;
-        }
-        attr_list_ref(attr_list_cache)++;
-        node_attr(b) = attr_list_cache;
-    }
-}
-
-@ @c
-halfword current_attribute_list(void)
-{
-    if (max_used_attr >= 0) {
-      if (attr_list_cache == cache_disabled) {
-            update_attribute_cache();
-      }
-      return attr_list_cache ;
-    }
-    return null ;
-}
-
-
-@ @c
-void reassign_attribute(halfword n, halfword new)
-{
-    halfword old;
-    old = node_attr(n);
-    if (new == null) {
-         /* there is nothing to assign but we need to check for an old value */
-        if (old != null)
-            delete_attribute_ref(old); /* also nulls attr field of n */
-    } else if (old == null) {
-         /* nothing is assigned so we just do that now */
-        assign_attribute_ref(n,new);
-    } else if (old != new) {
-         /* something is assigned so we need to clean up and assign then */
-        delete_attribute_ref(old);
-        assign_attribute_ref(n,new);
-    }
-     /* else: same value so there is no need to assign and change the refcount */
-    node_attr(n) = new ;
-}
-
-@ @c
-void delete_attribute_ref(halfword b)
-{
-    if (b != null) {
-        if (type(b) == attribute_list_node){
-            attr_list_ref(b)--;
-            if (attr_list_ref(b) == 0) {
-                if (b == attr_list_cache)
-                    attr_list_cache = cache_disabled;
-                free_node_chain(b, attribute_node_size);
-            }
-            /* maintain sanity */
-            if (attr_list_ref(b) < 0) {
-                attr_list_ref(b) = 0;
-            }
-        } else {
-            normal_error("nodes","trying to delete an attribute reference of a non attribute node");
-        }
-    }
-}
-
-void reset_node_properties(halfword b)
-{
-    if (b != null) {
-        lua_properties_reset(b);
-    }
-}
-
-@ |p| is an attr list head, or zero
-@c
-halfword do_set_attribute(halfword p, int i, int val)
-{
-    register halfword q;
-    register int j = 0;
-    if (p == null) {            /* add a new head \& node */
-        q = get_node(attribute_node_size);
-        type(q) = attribute_list_node;
-        attr_list_ref(q) = 1;
-        p = new_attribute_node((unsigned) i, val);
-        vlink(q) = p;
-        return q;
-    }
-    q = p;
-    if (vlink(p) != null) {
-        while (vlink(p) != null) {
-            int t = attribute_id(vlink(p));
-            if (t == i && attribute_value(vlink(p)) == val)
-                return q;           /* no need to do anything */
-            if (t >= i)
-                break;
-            j++;
-            p = vlink(p);
-        }
-
-        p = q;
-        while (j-- > 0)
-            p = vlink(p);
-        if (attribute_id(vlink(p)) == i) {
-            attribute_value(vlink(p)) = val;
-        } else {                    /* add a new node */
-            halfword r = new_attribute_node((unsigned) i, val);
-            vlink(r) = vlink(p);
-            vlink(p) = r;
-        }
-        return q;
-    } else {
-        normal_error("nodes","trying to set an attribute fails, case 1");
-        return null ;
-    }
-}
-
-@ @c
-void set_attribute(halfword n, int i, int val)
-{
-    register halfword p;
-    register int j = 0;
-    /* not all nodes can have an attribute list */
-    if (!nodetype_has_attributes(type(n)))
-        return;
-    /* if we have no list, we create one and quit */
-    p = node_attr(n);
-    if (p == null) {            /* add a new head \& node */
-        p = get_node(attribute_node_size);
-        type(p) = attribute_list_node;
-        attr_list_ref(p) = 1;
-        node_attr(n) = p;
-        p = new_attribute_node((unsigned) i, val);
-        vlink(node_attr(n)) = p;
-        return;
-    }
-    /* we check if we have this attribute already and quit if the value stays the same */
-    if (vlink(p) != null) {
-        while (vlink(p) != null) {
-            int t = attribute_id(vlink(p));
-            if (t == i && attribute_value(vlink(p)) == val)
-                return;
-            if (t >= i)
-                break;
-            j++;
-            p = vlink(p);
-        }
-        /* j has now the position (if found) .. we assume a sorted list ! */
-        p = node_attr(n);
-
-        if (attr_list_ref(p) == 0 ) {
-            /* the list is invalid i.e. freed already */
-            formatted_warning("nodes","node %d has an attribute list that is free already, case 1",(int) n);
-            /* the still dangling list gets ref count 1 */
-            attr_list_ref(p) = 1;
-        } else if (attr_list_ref(p) == 1) {
-            /* this can really happen HH-LS */
-            if (p == attr_list_cache) {
-                /* we can invalidate the cache setting */
-                /* attr_list_cache = cache_disabled    */
-                /* or save the list, as done below     */
-                p = copy_attribute_list(p);
-                node_attr(n) = p;
-                /* the copied list gets ref count 1 */
-                attr_list_ref(p) = 1;
-            }
-        } else {
-            /* the list is used multiple times so we make a copy */
-            p = copy_attribute_list(p);
-            /* we decrement the ref count or the original */
-            delete_attribute_ref(node_attr(n));
-            node_attr(n) = p;
-            /* the copied list gets ref count 1 */
-            attr_list_ref(p) = 1;
-        }
-
-
-        /* we go to position j in the list */
-        while (j-- > 0)
-            p = vlink(p);
-        /* if we have a hit we just set the value otherwise we add a new node */
-        if (attribute_id(vlink(p)) == i) {
-            attribute_value(vlink(p)) = val;
-        } else {                    /* add a new node */
-            halfword r = new_attribute_node((unsigned) i, val);
-            vlink(r) = vlink(p);
-            vlink(p) = r;
-        }
-    } else {
-        normal_error("nodes","trying to set an attribute fails, case 2");
-    }
-}
-
-@ @c
-int unset_attribute(halfword n, int i, int val)
-{
-    register halfword p;
-    register int t;
-    register int j = 0;
-
-    if (!nodetype_has_attributes(type(n)))
-        return null;
-    p = node_attr(n);
-    if (p == null)
-        return UNUSED_ATTRIBUTE;
-    if (attr_list_ref(p) == 0) {
-        formatted_warning("nodes","node %d has an attribute list that is free already, case 2", (int) n);
-        return UNUSED_ATTRIBUTE;
-    }
-    if (vlink(p) != null) {
-        while (vlink(p) != null) {
-            t = attribute_id(vlink(p));
-            if (t > i)
-                return UNUSED_ATTRIBUTE;
-            if (t == i) {
-                p = vlink(p);
-                break;
-            }
-            j++;
-            p = vlink(p);
-        }
-        if (attribute_id(p) != i)
-            return UNUSED_ATTRIBUTE;
-        /* if we are still here, the attribute exists */
-        p = node_attr(n);
-        if (attr_list_ref(p) > 1 || p == attr_list_cache) {
-            halfword q = copy_attribute_list(p);
-            if (attr_list_ref(p) > 1) {
-                delete_attribute_ref(node_attr(n));
-            }
-            attr_list_ref(q) = 1;
-            node_attr(n) = q;
-        }
-        p = vlink(node_attr(n));
-        while (j-- > 0)
-            p = vlink(p);
-        t = attribute_value(p);
-        if (val == UNUSED_ATTRIBUTE || t == val) {
-            attribute_value(p) = UNUSED_ATTRIBUTE;
-        }
-        return t;
-    } else {
-        normal_error("nodes","trying to unset an attribute fails");
-        return null;
-    }
-}
-
-@ @c
-int has_attribute(halfword n, int i, int val)
-{
-    register halfword p;
-    if (!nodetype_has_attributes(type(n)))
-        return UNUSED_ATTRIBUTE;
-    p = node_attr(n);
-    if (p == null || vlink(p) == null)
-        return UNUSED_ATTRIBUTE;
-    p = vlink(p);
-    while (p != null) {
-        if (attribute_id(p) == i) {
-            int ret = attribute_value(p);
-            if (val == UNUSED_ATTRIBUTE || val == ret)
-                return ret;
-            return UNUSED_ATTRIBUTE;
-        } else if (attribute_id(p) > i) {
-            return UNUSED_ATTRIBUTE;
-        }
-        p = vlink(p);
-    }
-    return UNUSED_ATTRIBUTE;
-}
-
-@ @c
-void print_short_node_contents(halfword p)
-{
-    switch (type(p)) {
-        case hlist_node:
-        case vlist_node:
-        case ins_node:
-        case whatsit_node:
-        case mark_node:
-        case adjust_node:
-        case unset_node:
-            print_char('[');
-            print_char(']');
-            break;
-        case rule_node:
-            print_char('|');
-            break;
-        case glue_node:
-            if (! glue_is_zero(p))
-                print_char(' ');
-            break;
-        case math_node:
-            print_char('$');
-            break;
-        case disc_node:
-            short_display(vlink(pre_break(p)));
-            short_display(vlink(post_break(p)));
-            break;
-    }
-}
-
-@ @c
-static void show_pdftex_whatsit_rule_spec(int p)
-{
-    tprint("(");
-    print_rule_dimen(height(p));
-    print_char('+');
-    print_rule_dimen(depth(p));
-    tprint(")x");
-    print_rule_dimen(width(p));
-}
-
-@ Each new type of node that appears in our data structure must be capable
-of being displayed, copied, destroyed, and so on. The routines that we
-need for write-oriented whatsits are somewhat like those for mark nodes;
-other extensions might, of course, involve more subtlety here.
-
-@c
-static void print_write_whatsit(const char *s, pointer p)
-{
-    tprint_esc(s);
-    if (write_stream(p) < 16)
-        print_int(write_stream(p));
-    else if (write_stream(p) == 16)
-        print_char('*');
-    else
-        print_char('-');
-}
-
-@ @c
-static void show_node_wrapup_core(int p)
-{
-    switch (subtype(p)) {
-        case open_node:
-            print_write_whatsit("openout", p);
-            print_char('=');
-            print_file_name(open_name(p), open_area(p), open_ext(p));
-            break;
-        case write_node:
-            print_write_whatsit("write", p);
-            print_mark(write_tokens(p));
-            break;
-        case close_node:
-            print_write_whatsit("closeout", p);
-            break;
-        case special_node:
-            tprint_esc("special");
-            print_mark(write_tokens(p));
-            break;
-        case late_lua_node:
-            show_late_lua(p);
-            break;
-        case save_pos_node:
-            tprint_esc("savepos");
-            break;
-        case user_defined_node:
-            tprint_esc("whatsit");
-            print_int(user_node_id(p));
-            print_char('=');
-            switch (user_node_type(p)) {
-            case 'a':
-                tprint("<>");
-                break;
-            case 'n':
-                tprint("[");
-                show_node_list(user_node_value(p));
-                tprint("]");
-                break;
-            case 's':
-                print_char('"');
-                print(user_node_value(p));
-                print_char('"');
-                break;
-            case 't':
-                print_mark(user_node_value(p));
-                break;
-            default:               /* only 'd' */
-                print_int(user_node_value(p));
-                break;
-            }
-            break;
-    }
-}
-
-void show_node_wrapup_dvi(int p)
-{
-}
-
-void show_node_wrapup_pdf(int p)
-{
-    switch (subtype(p)) {
-        case pdf_literal_node:
-            show_pdf_literal(p);
-            break;
-        case pdf_colorstack_node:
-            tprint_esc("pdfcolorstack ");
-            print_int(pdf_colorstack_stack(p));
-            switch (pdf_colorstack_cmd(p)) {
-            case colorstack_set:
-                tprint(" set ");
-                break;
-            case colorstack_push:
-                tprint(" push ");
-                break;
-            case colorstack_pop:
-                tprint(" pop");
-                break;
-            case colorstack_current:
-                tprint(" current");
-                break;
-            default:
-                confusion("colorstack");
-                break;
-            }
-            if (pdf_colorstack_cmd(p) <= colorstack_data)
-                print_mark(pdf_colorstack_data(p));
-            break;
-        case pdf_setmatrix_node:
-            tprint_esc("pdfsetmatrix");
-            print_mark(pdf_setmatrix_data(p));
-            break;
-        case pdf_save_node:
-            tprint_esc("pdfsave");
-            break;
-        case pdf_restore_node:
-            tprint_esc("pdfrestore");
-            break;
-        case pdf_refobj_node:
-            tprint_esc("pdfrefobj");
-            if (obj_obj_is_stream(static_pdf, pdf_obj_objnum(p))) {
-                if (obj_obj_stream_attr(static_pdf, pdf_obj_objnum(p)) != LUA_NOREF) {
-                    tprint(" attr");
-                    lua_rawgeti(Luas, LUA_REGISTRYINDEX,
-                                obj_obj_stream_attr(static_pdf, pdf_obj_objnum(p)));
-                    print_char(' ');
-                    tprint((const char *) lua_tostring(Luas, -1));
-                    lua_pop(Luas, 1);
-                }
-                tprint(" stream");
-            }
-            if (obj_obj_is_file(static_pdf, pdf_obj_objnum(p)))
-                tprint(" file");
-            if (obj_obj_data(static_pdf, pdf_obj_objnum(p)) != LUA_NOREF) {
-                lua_rawgeti(Luas, LUA_REGISTRYINDEX,
-                            obj_obj_data(static_pdf, pdf_obj_objnum(p)));
-                print_char(' ');
-                tprint((const char *) lua_tostring(Luas, -1));
-                lua_pop(Luas, 1);
-            }
-            break;
-        case pdf_annot_node:
-            tprint_esc("pdfannot");
-            show_pdftex_whatsit_rule_spec(p);
-            print_mark(pdf_annot_data(p));
-            break;
-        case pdf_start_link_node:
-            tprint_esc("pdfstartlink");
-            show_pdftex_whatsit_rule_spec(p);
-            if (pdf_link_attr(p) != null) {
-                tprint(" attr");
-                print_mark(pdf_link_attr(p));
-            }
-            tprint(" action");
-            if (pdf_action_type(pdf_link_action(p)) == pdf_action_user) {
-                tprint(" user");
-                print_mark(pdf_action_tokens(pdf_link_action(p)));
-                return;
-            }
-            if (pdf_action_file(pdf_link_action(p)) != null) {
-                tprint(" file");
-                print_mark(pdf_action_file(pdf_link_action(p)));
-            }
-            switch (pdf_action_type(pdf_link_action(p))) {
-            case pdf_action_goto:
-                if (pdf_action_named_id(pdf_link_action(p)) > 0) {
-                    tprint(" goto name");
-                    print_mark(pdf_action_id(pdf_link_action(p)));
-                } else {
-                    tprint(" goto num");
-                    print_int(pdf_action_id(pdf_link_action(p)));
-                }
-                break;
-            case pdf_action_page:
-                tprint(" page");
-                print_int(pdf_action_id(pdf_link_action(p)));
-                print_mark(pdf_action_tokens(pdf_link_action(p)));
-                break;
-            case pdf_action_thread:
-                if (pdf_action_named_id(pdf_link_action(p)) > 0) {
-                    tprint(" thread name");
-                    print_mark(pdf_action_id(pdf_link_action(p)));
-                } else {
-                    tprint(" thread num");
-                    print_int(pdf_action_id(pdf_link_action(p)));
-                }
-                break;
-            default:
-                normal_error("pdf backend", "unknown action type for link");
-                break;
-            }
-            break;
-        case pdf_end_link_node:
-            tprint_esc("pdfendlink");
-            break;
-        case pdf_dest_node:
-            tprint_esc("pdfdest");
-            if (pdf_dest_named_id(p) > 0) {
-                tprint(" name");
-                print_mark(pdf_dest_id(p));
-            } else {
-                tprint(" num");
-                print_int(pdf_dest_id(p));
-            }
-            print_char(' ');
-            switch (pdf_dest_type(p)) {
-            case pdf_dest_xyz:
-                tprint("xyz");
-                if (pdf_dest_xyz_zoom(p) != null) {
-                    tprint(" zoom");
-                    print_int(pdf_dest_xyz_zoom(p));
-                }
-                break;
-            case pdf_dest_fitbh:
-                tprint("fitbh");
-                break;
-            case pdf_dest_fitbv:
-                tprint("fitbv");
-                break;
-            case pdf_dest_fitb:
-                tprint("fitb");
-                break;
-            case pdf_dest_fith:
-                tprint("fith");
-                break;
-            case pdf_dest_fitv:
-                tprint("fitv");
-                break;
-            case pdf_dest_fitr:
-                tprint("fitr");
-                show_pdftex_whatsit_rule_spec(p);
-                break;
-            case pdf_dest_fit:
-                tprint("fit");
-                break;
-            default:
-                tprint("unknown!");
-                break;
-            }
-            break;
-        case pdf_thread_node:
-        case pdf_start_thread_node:
-            if (subtype(p) == pdf_thread_node)
-                tprint_esc("pdfthread");
-            else
-                tprint_esc("pdfstartthread");
-            tprint("(");
-            print_rule_dimen(height(p));
-            print_char('+');
-            print_rule_dimen(depth(p));
-            tprint(")x");
-            print_rule_dimen(width(p));
-            if (pdf_thread_attr(p) != null) {
-                tprint(" attr");
-                print_mark(pdf_thread_attr(p));
-            }
-            if (pdf_thread_named_id(p) > 0) {
-                tprint(" name");
-                print_mark(pdf_thread_id(p));
-            } else {
-                tprint(" num");
-                print_int(pdf_thread_id(p));
-            }
-            break;
-        case pdf_end_thread_node:
-            tprint_esc("pdfendthread");
-            break;
-        default:
-            break;
-    }
-}
-
-@  Now we are ready for |show_node_list| itself. This procedure has been
-  written to be ``extra robust'' in the sense that it should not crash or get
-  into a loop even if the data structures have been messed up by bugs in
-  the rest of the program. You can safely call its parent routine
-  |show_box(p)| for arbitrary values of |p| when you are debugging \TeX.
-  However, in the presence of bad data, the procedure may
-  fetch a |memory_word| whose variant is different from the way it was stored;
-  for example, it might try to read |mem[p].hh| when |mem[p]|
-  contains a scaled integer, if |p| is a pointer that has been
-  clobbered or chosen at random.
-
-
-@ |str_room| need not be checked; see |show_box|
-
-@ Recursive calls on |show_node_list| therefore use the following pattern:
-@c
-#define node_list_display(A) do { \
-    append_char('.');  \
-    show_node_list(A); \
-    flush_char();      \
-} while (0)
-
-#define node_list_display_x(A,B) do { \
-    if ((B) != null) {     \
-        append_char('.');  \
-        append_char(A);    \
-        append_char(' ');  \
-        show_node_list(B); \
-        flush_char();      \
-        flush_char();      \
-        flush_char();      \
-    } \
-} while (0)
-
-/* prints a node list symbolically */
-
-void show_node_list(int p)
-{
-    int n = 0;                  /* the number of items already printed at this level */
-    halfword w;
-    real g;                     /* a glue ratio, as a floating point number */
-    if ((int) cur_length > depth_threshold) {
-        if (p > null)
-            tprint(" []");      /* indicate that there's been some truncation */
-        return;
-    }
-    while (p != null) {
-        print_ln();
-        print_current_string(); /* display the nesting history */
-        if (tracing_online_par < -2)
-            print_int(p);
-        incr(n);
-        if (n > breadth_max) {  /* time to stop */
-            tprint("etc.");
-            return;
-        }
-        /* Display node |p| */
-        if (is_char_node(p)) {
-            print_font_and_char(p);
-            if (is_ligature(p)) {
-                /* Display ligature |p|; */
-                tprint(" (ligature ");
-                if (is_leftboundary(p))
-                    print_char('|');
-                font_in_short_display = font(p);
-                short_display(lig_ptr(p));
-                if (is_rightboundary(p))
-                    print_char('|');
-                print_char(')');
-            }
-        } else {
-            switch (type(p)) {
-            case hlist_node:
-            case vlist_node:
-            case unset_node:
-                /* Display box |p|; */
-                if (type(p) == hlist_node)
-                    tprint_esc("h");
-                else if (type(p) == vlist_node)
-                    tprint_esc("v");
-                else
-                    tprint_esc("unset");
-                tprint("box(");
-                print_scaled(height(p));
-                print_char('+');
-                print_scaled(depth(p));
-                tprint(")x");
-                print_scaled(width(p));
-                if (type(p) == unset_node) {
-                    /* Display special fields of the unset node |p|; */
-                    if (span_count(p) != min_quarterword) {
-                        tprint(" (");
-                        print_int(span_count(p) + 1);
-                        tprint(" columns)");
-                    }
-                    if (glue_stretch(p) != 0) {
-                        tprint(", stretch ");
-                        print_glue(glue_stretch(p), glue_order(p), NULL);
-                    }
-                    if (glue_shrink(p) != 0) {
-                        tprint(", shrink ");
-                        print_glue(glue_shrink(p), glue_sign(p), NULL);
-                    }
-                } else {
-                    /* Display the value of |glue_set(p)| */
-                    /* The code will have to change in this place if |glue_ratio| is
-                       a structured type instead of an ordinary |real|. Note that this routine
-                       should avoid arithmetic errors even if the |glue_set| field holds an
-                       arbitrary random value. The following code assumes that a properly
-                       formed nonzero |real| number has absolute value $2^{20}$ or more when
-                       it is regarded as an integer; this precaution was adequate to prevent
-                       floating point underflow on the author's computer.
-                     */
-
-                    g = (real) (glue_set(p));
-                    if ((g != 0.0) && (glue_sign(p) != normal)) {
-                        tprint(", glue set ");
-                        if (glue_sign(p) == shrinking)
-                            tprint("- ");
-                        if (g > 20000.0 || g < -20000.0) {
-                            if (g > 0.0)
-                                print_char('>');
-                            else
-                                tprint("< -");
-                            print_glue(20000 * unity, glue_order(p), NULL);
-                        } else {
-                            print_glue(round(unity * g), glue_order(p), NULL);
-                        }
-                    }
-
-                    if (shift_amount(p) != 0) {
-                        tprint(", shifted ");
-                        print_scaled(shift_amount(p));
-                    }
-                    tprint(", direction ");
-                    print_dir(box_dir(p));
-                }
-                node_list_display(list_ptr(p)); /* recursive call */
-                break;
-            case rule_node:
-                /* Display rule |p|; */
-                if (subtype(p) == normal_rule) {
-                    tprint_esc("rule(");
-                } else if (subtype(p) == empty_rule) {
-                    tprint_esc("norule(");
-                } else if (subtype(p) == user_rule) {
-                    tprint_esc("userrule(");
-                } else if (subtype(p) == box_rule) {
-                    tprint_esc("box(");
-                } else if (subtype(p) == image_rule) {
-                    tprint_esc("image(");
-                }
-                print_rule_dimen(height(p));
-                print_char('+');
-                print_rule_dimen(depth(p));
-                tprint(")x");
-                print_rule_dimen(width(p));
-                break;
-            case ins_node:
-                /* Display insertion |p|; */
-                tprint_esc("insert");
-                print_int(subtype(p));
-                tprint(", natural size ");
-                print_scaled(height(p));
-                tprint("; split(");
-                print_spec(split_top_ptr(p), NULL);
-                print_char(',');
-                print_scaled(depth(p));
-                tprint("); float cost ");
-                print_int(float_cost(p));
-                node_list_display(ins_ptr(p));  /* recursive call */
-                break;
-            case dir_node:
-                if (dir_dir(p) < 0) {
-                    tprint_esc("enddir");
-                    print_char(' ');
-                    print_dir(dir_dir(p) + dir_swap);
-                } else {
-                    tprint_esc("begindir");
-                    print_char(' ');
-                    print_dir(dir_dir(p));
-                }
-                break;
-            case local_par_node:
-                tprint_esc("localpar");
-                append_char('.');
-                print_ln();
-                print_current_string();
-                tprint_esc("localinterlinepenalty");
-                print_char('=');
-                print_int(local_pen_inter(p));
-                print_ln();
-                print_current_string();
-                tprint_esc("localbrokenpenalty");
-                print_char('=');
-                print_int(local_pen_broken(p));
-                print_ln();
-                print_current_string();
-                tprint_esc("localleftbox");
-                if (local_box_left(p) == null) {
-                    tprint("=null");
-                } else {
-                    append_char('.');
-                    show_node_list(local_box_left(p));
-                    decr(cur_length);
-                }
-                print_ln();
-                print_current_string();
-                tprint_esc("localrightbox");
-                if (local_box_right(p) == null) {
-                    tprint("=null");
-                } else {
-                    append_char('.');
-                    show_node_list(local_box_right(p));
-                    decr(cur_length);
-                }
-                decr(cur_length);
-                break;
-            case boundary_node:
-                if (subtype(p)==0) {
-                    tprint_esc("noboundary");
-                } else {
-                    switch (subtype(p)) {
-                        case 1:
-                            tprint_esc("boundary");
-                            break;
-                        case 2:
-                            tprint_esc("protrusionboundary");
-                            break;
-                        case 3:
-                            tprint_esc("wordboundary");
-                            break;
-                        default:
-                            tprint_esc("boundary");
-                            print_char(':');
-                            print_int(subtype(p));
-                            break;
-                    }
-                    print_char('=');
-                    print_int(boundary_value(p));
-                }
-                break;
-            case whatsit_node:
-                w = subtype(p) ;
-                if (w >= backend_first_pdf_whatsit) {
-                    show_node_wrapup_pdf(p);
-                } else if (w >= backend_first_dvi_whatsit) {
-                    show_node_wrapup_dvi(p);
-                } else {
-                    show_node_wrapup_core(p);
-                }
-                break;
-            case glue_node:
-                /* Display glue |p|; */
-                if (subtype(p) >= a_leaders) {
-                    /* Display leaders |p|; */
-                    tprint_esc("");
-                    switch (subtype(p)) {
-                    case a_leaders:
-                        break;
-                    case c_leaders:
-                        print_char('c');
-                        break;
-                    case x_leaders:
-                        print_char('x');
-                        break;
-                    case g_leaders:
-                        print_char('g');
-                        break;
-                    default:
-                        normal_warning("nodes","weird glue leader subtype ignored");
-                    }
-                    tprint("leaders ");
-                    print_spec(p, NULL);
-                    node_list_display(leader_ptr(p));   /* recursive call */
-                } else {
-                    tprint_esc("glue");
-                    if (subtype(p) != normal) {
-                        print_char('(');
-                        if ((subtype(p) - 1) < thin_mu_skip_code) {
-                            print_cmd_chr(assign_glue_cmd, glue_base + (subtype(p) - 1));
-                        } else if (subtype(p) < cond_math_glue) {
-                            print_cmd_chr(assign_mu_glue_cmd, glue_base + (subtype(p) - 1));
-                        } else if (subtype(p) == cond_math_glue) {
-                            tprint_esc("nonscript");
-                        } else {
-                            tprint_esc("mskip");
-                        }
-                        print_char(')');
-                    }
-                    if (subtype(p) != cond_math_glue) {
-                        print_char(' ');
-                        if (subtype(p) < cond_math_glue)
-                            print_spec(p, NULL);
-                        else
-                            print_spec(p, "mu");
-                    }
-                }
-                break;
-            case margin_kern_node:
-                tprint_esc("kern");
-                print_scaled(width(p));
-                if (subtype(p) == left_side)
-                    tprint(" (left margin)");
-                else
-                    tprint(" (right margin)");
-                break;
-            case kern_node:
-                /* Display kern |p|; */
-                /*  An ``explicit'' kern value is indicated implicitly by an explicit space. */
-                if (subtype(p) != mu_glue) {
-                    tprint_esc("kern");
-                    /*
-                    if (subtype(p) != normal)
-                        print_char(' ');
-                    */
-                    print_scaled(width(p));
-                    if (subtype(p) == font_kern)
-                        tprint(" (font)");
-                    else if (subtype(p) == italic_kern)
-                        tprint(" (italic)");
-                    else if (subtype(p) == accent_kern)
-                        tprint(" (accent)");
-                } else {
-                    tprint_esc("mkern");
-                    print_scaled(width(p));
-                    tprint("mu");
-                }
-                break;
-            case math_node:
-                /* Display math node |p|; */
-                tprint_esc("math");
-                if (subtype(p) == before)
-                    tprint("on");
-                else
-                    tprint("off");
-                if (!glue_is_zero(p)) {
-                    tprint(", glued ");
-                    print_spec(p, NULL);
-                } else if (surround(p) != 0) {
-                    tprint(", surrounded ");
-                    print_scaled(surround(p));
-                }
-                break;
-            case penalty_node:
-                /* Display penalty |p|; */
-                tprint_esc("penalty ");
-                print_int(penalty(p));
-                break;
-            case disc_node:
-                /* Display discretionary |p|; */
-                /* The |post_break| list of a discretionary node is indicated by a prefixed
-                   `\.{\char'174}' instead of the `\..' before the |pre_break| list. */
-                /* We're not compatible anyway  so ...
-                    tprint_esc("discretionary");
-                    print_int(disc_penalty(p));
-                    print_char('|');
-                    if (vlink(no_break(p)) != null) {
-                        tprint(" replacing ");
-                        node_list_display(vlink(no_break(p)));
-                    }
-                    node_list_display(vlink(pre_break(p)));
-                    append_char('|');
-                    show_node_list(vlink(post_break(p)));
-                    flush_char();
-                */
-                tprint_esc("discretionary");
-                tprint(" (penalty ");
-                print_int(disc_penalty(p));
-                print_char(')');
-                node_list_display_x('<',vlink(pre_break(p)));
-                node_list_display_x('>',vlink(post_break(p)));
-                node_list_display_x('=',vlink(no_break(p)));
-                break;
-            case mark_node:
-                /* Display mark |p|; */
-                tprint_esc("mark");
-                if (mark_class(p) != 0) {
-                    print_char('s');
-                    print_int(mark_class(p));
-                }
-                print_mark(mark_ptr(p));
-                break;
-            case adjust_node:
-                /* Display adjustment |p|; */
-                tprint_esc("vadjust");
-                if (subtype(p) != 0)
-                    tprint(" pre ");
-                node_list_display(adjust_ptr(p));       /* recursive call */
-                break;
-            case glue_spec_node:
-                tprint("<glue_spec ");
-                print_spec(p, NULL);
-                tprint(">");
-                break;
-            default:
-                show_math_node(p);
-                break;
-            }
-        }
-        p = vlink(p);
-    }
-}
-
-@ This routine finds the 'base' width of a horizontal box, using the same logic
-  that \TeX82 used for \.{\\predisplaywidth} */
-
-@c
-static pointer get_actual_box_width(pointer r,pointer p, scaled initial_width)
-{
-    scaled d;                  /* increment to |v| */
-    scaled w = -max_dimen;     /* calculated |size| */
-    scaled v = initial_width;  /* |w| plus possible glue amount */
-    while (p != null) {
-        if (is_char_node(p)) {
-            d = glyph_width(p);
-            goto FOUND;
-        }
-        switch (type(p)) {
-            case hlist_node:
-            case vlist_node:
-            case rule_node:
-                d = width(p);
-                goto FOUND;
-                break;
-            case margin_kern_node:
-                d = width(p);
-                break;
-            case kern_node:
-                d = width(p);
-                break;
-            case disc_node:
-                /* at the end of the line we should actually take the pre */
-                if (no_break(p) != null) {
-                    d = get_actual_box_width(r,vlink_no_break(p),0);
-                    if (d <= -max_dimen || d >= max_dimen) {
-                        d = 0;
-                    }
-                } else {
-                    d = 0;
-                }
-                goto FOUND;
-                break;
-            case math_node:
-                /* begin mathskip code */
-                if (glue_is_zero(p)) {
-                    d = surround(p);
-                    break;
-                } else {
-                    /* fall through */
-                }
-                /* end mathskip code */
-            case glue_node:
-                /* We need to be careful that |w|, |v|, and |d| do not depend on any |glue_set|
-                   values, since such values are subject to system-dependent rounding.
-                   System-dependent numbers are not allowed to infiltrate parameters like
-                   |pre_display_size|, since \TeX82 is supposed to make the same decisions on all
-                   machines.
-                 */
-                d = width(p);
-                if (glue_sign(r) == stretching) {
-                    if ((glue_order(r) == stretch_order(p)) && (stretch(p) != 0))
-                        v = max_dimen;
-                } else if (glue_sign(r) == shrinking) {
-                    if ((glue_order(r) == shrink_order(p)) && (shrink(p) != 0))
-                        v = max_dimen;
-                }
-                if (subtype(p) >= a_leaders)
-                    goto FOUND;
-                break;
-            default:
-                d = 0;
-                break;
-        }
-        if (v < max_dimen)
-            v = v + d;
-        goto NOT_FOUND;
-      FOUND:
-        if (v < max_dimen) {
-            v = v + d;
-            w = v;
-        } else {
-            w = max_dimen;
-            break;
-        }
-      NOT_FOUND:
-        p = vlink(p);
-    }
-    return w;
-}
-
-pointer actual_box_width(pointer r, scaled base_width)
-{
-    /* often this is the same as:
-        return + shift_amount(r) + base_width +
-            natural_sizes(list_ptr(r),null,(glue_ratio) glue_set(r),glue_sign(r),glue_order(r),box_dir(r));
-    */
-    return get_actual_box_width(r,list_ptr(r),shift_amount(r) + base_width);
-}
-
-@ @c
-halfword tail_of_list(halfword p)
-{
-    halfword q = p;
-    while (vlink(q) != null)
-        q = vlink(q);
-    return q;
-}
-
-
-
-@ @c
-int var_used;
-
-@ Attribute lists need two extra globals to increase processing efficiency.
-|max_used_attr| limits the test loop that checks for set attributes, and
-|attr_list_cache| contains a pointer to an already created attribute list.  It is
-set to the special value |cache_disabled| when the current value can no longer be
-trusted: after an assignment to an attribute register, and after a group has
-ended.
-
-@c
-int max_used_attr;        /* maximum assigned attribute id  */
-halfword attr_list_cache;
-
-@ From the computer's standpoint, \TeX's chief mission is to create
-horizontal and vertical lists. We shall now investigate how the elements
-of these lists are represented internally as nodes in the dynamic memory.
-
-A horizontal or vertical list is linked together by |link| fields in
-the first word of each node. Individual nodes represent boxes, glue,
-penalties, or special things like discretionary hyphens; because of this
-variety, some nodes are longer than others, and we must distinguish different
-kinds of nodes. We do this by putting a `|type|' field in the first word,
-together with the link and an optional `|subtype|'.
-
-@ Character nodes appear only in horizontal lists, never in vertical lists.
-
-An |hlist_node| stands for a box that was made from a horizontal list.
-Each |hlist_node| is seven words long, and contains the following fields
-(in addition to the mandatory |type| and |link|, which we shall not
-mention explicitly when discussing the other node types): The |height| and
-|width| and |depth| are scaled integers denoting the dimensions of the
-box.  There is also a |shift_amount| field, a scaled integer indicating
-how much this box should be lowered (if it appears in a horizontal list),
-or how much it should be moved to the right (if it appears in a vertical
-list). There is a |list_ptr| field, which points to the beginning of the
-list from which this box was fabricated; if |list_ptr| is |null|, the box
-is empty. Finally, there are three fields that represent the setting of
-the glue:  |glue_set(p)| is a word of type |glue_ratio| that represents
-the proportionality constant for glue setting; |glue_sign(p)| is
-|stretching| or |shrinking| or |normal| depending on whether or not the
-glue should stretch or shrink or remain rigid; and |glue_order(p)|
-specifies the order of infinity to which glue setting applies (|normal|,
-|sfi|, |fil|, |fill|, or |filll|). The |subtype| field is not used.
-
-@ The |new_null_box| function returns a pointer to an |hlist_node| in
-which all subfields have the values corresponding to `\.{\\hbox\{\}}'.
-The |subtype| field is set to |min_quarterword|, since that's the desired
-|span_count| value if this |hlist_node| is changed to an |unset_node|.
-
-@c
-halfword new_null_box(void)
-{                               /* creates a new box node */
-    halfword p = new_node(hlist_node, min_quarterword);
-    box_dir(p) = text_direction_par;
-    return p;
-}
-
-@ A |vlist_node| is like an |hlist_node| in all respects except that it
-contains a vertical list.
-
-@ A |rule_node| stands for a solid black rectangle; it has |width|,
-|depth|, and |height| fields just as in an |hlist_node|. However, if
-any of these dimensions is $-2^{30}$, the actual value will be determined
-by running the rule up to the boundary of the innermost enclosing box.
-This is called a ``running dimension.'' The |width| is never running in
-an hlist; the |height| and |depth| are never running in a~vlist.
-
-@ A new rule node is delivered by the |new_rule| function. It
-makes all the dimensions ``running,'' so you have to change the
-ones that are not allowed to run.
-
-@c
-halfword new_rule(int s)
-{
-    halfword p = new_node(rule_node,s);
-    return p;
-}
-
-@ Insertions are represented by |ins_node| records, where the |subtype|
-indicates the corresponding box number. For example, `\.{\\insert 250}'
-leads to an |ins_node| whose |subtype| is |250+min_quarterword|.
-The |height| field of an |ins_node| is slightly misnamed; it actually holds
-the natural height plus depth of the vertical list being inserted.
-The |depth| field holds the |split_max_depth| to be used in case this
-insertion is split, and the |split_top_ptr| points to the corresponding
-|split_top_skip|. The |float_cost| field holds the |floating_penalty| that
-will be used if this insertion floats to a subsequent page after a
-split insertion of the same class.  There is one more field, the
-|ins_ptr|, which points to the beginning of the vlist for the insertion.
-
-@ A |mark_node| has a |mark_ptr| field that points to the reference count
-of a token list that contains the user's \.{\\mark} text.
-In addition there is a |mark_class| field that contains the mark class.
-
-@ An |adjust_node|, which occurs only in horizontal lists,
-specifies material that will be moved out into the surrounding
-vertical list; i.e., it is used to implement \TeX's `\.{\\vadjust}'
-operation.  The |adjust_ptr| field points to the vlist containing this
-material.
-
-@ A |glyph_node|, which occurs only in horizontal lists, specifies a
-glyph in a particular font, along with its attribute list. Older
-versions of \TeX\ could use token memory for characters, because the
-font,char combination would fit in a single word (both values were
-required to be strictly less than $2^{16}$). In LuaTeX, room is
-needed for characters that are larger than that, as well as a pointer
-to a potential attribute list, and the two displacement values.
-
-In turn, that made the node so large that it made sense to merge
-ligature glyphs as well, as that requires only one extra pointer.  A
-few extra classes of glyph nodes will be introduced later.  The
-unification of all those types makes it easier to manipulate lists of
-glyphs. The subtype differentiates various glyph kinds.
-
-First, here is a function that returns a pointer to a glyph node for a given
-glyph in a given font. If that glyph doesn't exist, |null| is returned
-instead.  Nodes of this subtype are directly created only for accents
-and their base (through |make_accent|), and math nucleus items (in the
-conversion from |mlist| to |hlist|).
-
-@c
-halfword new_glyph(int f, int c)
-{
-    halfword p = null;          /* the new node */
-    if ((f == 0) || (char_exists(f, c))) {
-        p = new_glyph_node();
-        set_to_glyph(p);
-        font(p) = f;
-        character(p) = c;
-    }
-    return p;
-}
-
-@ A subset of the glyphs nodes represent ligatures: characters
-fabricated from the interaction of two or more actual characters.  The
-characters that generated the ligature have not been forgotten, since
-they are needed for diagnostic messages; the |lig_ptr| field points to
-a linked list of character nodes for all original characters that have
-been deleted. (This list might be empty if the characters that
-generated the ligature were retained in other nodes.)
-
-The |subtype| field of these |glyph_node|s is 1, plus 2 and/or 1 if
-the original source of the ligature included implicit left and/or
-right boundaries. These nodes are created by the C function |new_ligkern|.
-
-A third general type of glyphs could be called a character, as it
-only appears in lists that are not yet processed by the ligaturing and
-kerning steps of the program.
-
-|main_control| inserts these, and they are later converted to
-|subtype_normal| by |new_ligkern|.
-
-@c
-quarterword norm_min(int h)
-{
-    if (h <= 0)
-        return 1;
-    else if (h >= 255)
-        return 255;
-    else
-        return (quarterword) h;
-}
-
-halfword new_char(int f, int c)
-{
-    halfword p;                 /* the new node */
-    p = new_glyph_node();
-    set_to_character(p);
-    font(p) = f;
-    character(p) = c;
-    lang_data(p) = make_lang_data(uc_hyph_par, cur_lang_par, left_hyphen_min_par, right_hyphen_min_par);
-    return p;
-}
-
-@ Left and right ghost glyph nodes are the result of \.{\\leftghost}
-and \.{\\rightghost}, respectively. They are going to be removed by
-|new_ligkern|, at the end of which they are no longer needed.
-
-@ Here are a few handy helpers used by the list output routines.
-
-@c
-scaled glyph_width(halfword p)
-{
-    scaled w = char_width(font(p), character(p));
-    return w;
-}
-
-scaled glyph_height(halfword p)
-{
-    scaled w = char_height(font(p), character(p)) + y_displace(p);
-    if (w < 0)
-        w = 0;
-    return w;
-}
-
-scaled glyph_depth(halfword p)
-{
-    scaled w = char_depth(font(p), character(p));
-    if (y_displace(p) > 0)
-        w = w - y_displace(p);
-    if (w < 0)
-        w = 0;
-    return w;
-}
-
-@ A |disc_node|, which occurs only in horizontal lists, specifies a
-``dis\-cretion\-ary'' line break. If such a break occurs at node |p|, the text
-that starts at |pre_break(p)| will precede the break, the text that starts at
-|post_break(p)| will follow the break, and text that appears in
-|no_break(p)| nodes will be ignored. For example, an ordinary
-discretionary hyphen, indicated by `\.{\\-}', yields a |disc_node| with
-|pre_break| pointing to a |char_node| containing a hyphen, |post_break=null|,
-and |no_break=null|.
-
-{TODO: Knuth said: All three of the discretionary texts must be lists
-that consist entirely of character, kern, box and rule nodes.}
-
-If |subtype(p)=automatic_disc|, the |ex_hyphen_penalty| will be charged for this
-break.  Otherwise the |hyphen_penalty| will be charged.  The texts will
-actually be substituted into the list by the line-breaking algorithm if it
-decides to make the break, and the discretionary node will disappear at
-that time; thus, the output routine sees only discretionaries that were
-not chosen.
-
-@c
-halfword new_disc(void)
-{                               /* creates an empty |disc_node| */
-    halfword p = new_node(disc_node, 0);
-    disc_penalty(p) = hyphen_penalty_par;
-    return p;
-}
-
-@ A |whatsit_node| is a wild card reserved for extensions to \TeX. The
-|subtype| field in its first word says what `\\{whatsit}' it is, and
-implicitly determines the node size (which must be 2 or more) and the
-format of the remaining words. When a |whatsit_node| is encountered
-in a list, special actions are invoked; knowledgeable people who are
-careful not to mess up the rest of \TeX\ are able to make \TeX\ do new
-things by adding code at the end of the program. For example, there
-might be a `\TeX nicolor' extension to specify different colors of ink,
-@^extensions to \TeX@>
-and the whatsit node might contain the desired parameters.
-
-The present implementation of \TeX\ treats the features associated with
-`\.{\\write}' and `\.{\\special}' as if they were extensions, in order to
-illustrate how such routines might be coded. We shall defer further
-discussion of extensions until the end of this program.
-
-@ A |math_node|, which occurs only in horizontal lists, appears before and
-after mathematical formulas. The |subtype| field is |before| before the
-formula and |after| after it. There is a |surround| field, which represents
-the amount of surrounding space inserted by \.{\\mathsurround}.
-
-@c
-halfword new_math(scaled w, int s)
-{
-    halfword p = new_node(math_node, s);
-    surround(p) = w;
-    return p;
-}
-
-@ \TeX\ makes use of the fact that |hlist_node|, |vlist_node|,
-|rule_node|, |ins_node|, |mark_node|, |adjust_node|,
-|disc_node|, |whatsit_node|, and |math_node| are at the low end of the
-type codes, by permitting a break at glue in a list if and only if the
-|type| of the previous node is less than |math_node|. Furthermore, a
-node is discarded after a break if its type is |math_node| or~more.
-
-@ A |glue_node| represents glue in a list. However, it is really only
-a pointer to a separate glue specification, since \TeX\ makes use of the
-fact that many essentially identical nodes of glue are usually present.
-If |p| points to a |glue_node|, |glue_ptr(p)| points to
-another packet of words that specify the stretch and shrink components, etc.
-
-Glue nodes also serve to represent leaders; the |subtype| is used to
-distinguish between ordinary glue (which is called |normal|) and the three
-kinds of leaders (which are called |a_leaders|, |c_leaders|, and |x_leaders|).
-The |leader_ptr| field points to a rule node or to a box node containing the
-leaders; it is set to |null| in ordinary glue nodes.
-
-Many kinds of glue are computed from \TeX's ``skip'' parameters, and
-it is helpful to know which parameter has led to a particular glue node.
-Therefore the |subtype| is set to indicate the source of glue, whenever
-it originated as a parameter. We will be defining symbolic names for the
-parameter numbers later (e.g., |line_skip_code=0|, |baseline_skip_code=1|,
-etc.); it suffices for now to say that the |subtype| of parametric glue
-will be the same as the parameter number, plus~one.
-
-@ In math formulas there are two more possibilities for the |subtype| in a
-glue node: |mu_glue| denotes an \.{\\mskip} (where the units are scaled \.{mu}
-instead of scaled \.{pt}); and |cond_math_glue| denotes the `\.{\\nonscript}'
-feature that cancels the glue node immediately following if it appears
-in a subscript.
-
-@ A glue specification has a halfword reference count in its first word,
-@^reference counts@>
-representing |null| plus the number of glue nodes that point to it (less one).
-Note that the reference count appears in the same position as
-the |link| field in list nodes; this is the field that is initialized
-to |null| when a node is allocated, and it is also the field that is flagged
-by |empty_flag| in empty nodes.
-
-Glue specifications also contain three |scaled| fields, for the |width|,
-|stretch|, and |shrink| dimensions. Finally, there are two one-byte
-fields called |stretch_order| and |shrink_order|; these contain the
-orders of infinity (|normal|, |sfi|, |fil|, |fill|, or |filll|)
-corresponding to the stretch and shrink values.
-
-@ Here is a function that returns a pointer to a copy of a glue spec.
-The reference count in the copy is |null|, because there is assumed
-to be exactly one reference to the new specification.
-
-@c
-halfword new_spec(halfword q) /* safeguard for copying a glue node */
-{
-    if (q == null) {
-        return copy_node(zero_glue);
-    } else if (type(q) == glue_spec_node) {
-        return copy_node(q);
-    } else if (type(q) == glue_node) {
-        halfword p = copy_node(zero_glue);
-        width(p) = width(q);
-        stretch(p) = stretch(q);
-        shrink(p) = shrink(q);
-        stretch_order(p) = stretch_order(q);
-        shrink_order(p) = shrink_order(q);
-        return p;
-    } else {
-        /* alternatively we can issue a warning */
-        return copy_node(zero_glue);
-    }
-}
-
-@ And here's a function that creates a glue node for a given parameter
-identified by its code number; for example,
-|new_param_glue(line_skip_code)| returns a pointer to a glue node for the
-current \.{\\lineskip}.
-
-@c
-halfword new_param_glue(int n)
-{
-    halfword p = new_node(glue_node, n + 1);
-    halfword q = glue_par(n);
-    width(p) = width(q);
-    stretch(p) = stretch(q);
-    shrink(p) = shrink(q);
-    stretch_order(p) = stretch_order(q);
-    shrink_order(p) = shrink_order(q);
-    return p;
-}
-
-@ Glue nodes that are more or less anonymous are created by |new_glue|,
-whose argument points to a glue specification.
-
-@c
-halfword new_glue(halfword q)
-{
-    halfword p = new_node(glue_node, normal);
-    width(p) = width(q);
-    stretch(p) = stretch(q);
-    shrink(p) = shrink(q);
-    stretch_order(p) = stretch_order(q);
-    shrink_order(p) = shrink_order(q);
-    return p;
-}
-
-@ Still another subroutine is needed: This one is sort of a combination
-of |new_param_glue| and |new_glue|. It creates a glue node for one of
-the current glue parameters, but it makes a fresh copy of the glue
-specification, since that specification will probably be subject to change,
-while the parameter will stay put.
-
-/*
-    The global variable |temp_ptr| is set to the address of the new spec.
-*/
-
-@c
-halfword new_skip_param(int n)
-{
-    halfword p = new_node(glue_node, n + 1);
-    halfword q = glue_par(n);
-    width(p) = width(q);
-    stretch(p) = stretch(q);
-    shrink(p) = shrink(q);
-    stretch_order(p) = stretch_order(q);
-    shrink_order(p) = shrink_order(q);
-    return p;
-}
-
-@ A |kern_node| has a |width| field to specify a (normally negative)
-amount of spacing. This spacing correction appears in horizontal lists
-between letters like A and V when the font designer said that it looks
-better to move them closer together or further apart. A kern node can
-also appear in a vertical list, when its `|width|' denotes additional
-spacing in the vertical direction. The |subtype| is either |normal| (for
-kerns inserted from font information or math mode calculations) or |explicit|
-(for kerns inserted from \.{\\kern} and \.{\\/} commands) or |acc_kern|
-(for kerns inserted from non-math accents) or |mu_glue| (for kerns
-inserted from \.{\\mkern} specifications in math formulas).
-
-@ The |new_kern| function creates a kern node having a given width.
-
-@c
-halfword new_kern(scaled w)
-{
-    halfword p = new_node(kern_node, normal);
-    width(p) = w;
-    return p;
-}
-
-@ A |penalty_node| specifies the penalty associated with line or page
-breaking, in its |penalty| field. This field is a fullword integer, but
-the full range of integer values is not used: Any penalty |>=10000| is
-treated as infinity, and no break will be allowed for such high values.
-Similarly, any penalty |<=-10000| is treated as negative infinity, and a
-break will be forced.
-
-@ Anyone who has been reading the last few sections of the program will
-be able to guess what comes next.
-
-@c
-halfword new_penalty(int m, int s)
-{
-    halfword p = new_node(penalty_node, 0); /* the |subtype| is not used */
-    penalty(p) = m;
-    subtype(p) = s;
-    return p;
-}
-
-@ You might think that we have introduced enough node types by now. Well,
-almost, but there is one more: An |unset_node| has nearly the same format
-as an |hlist_node| or |vlist_node|; it is used for entries in \.{\\halign}
-or \.{\\valign} that are not yet in their final form, since the box
-dimensions are their ``natural'' sizes before any glue adjustment has been
-made. The |glue_set| word is not present; instead, we have a |glue_stretch|
-field, which contains the total stretch of order |glue_order| that is
-present in the hlist or vlist being boxed.
-Similarly, the |shift_amount| field is replaced by a |glue_shrink| field,
-containing the total shrink of order |glue_sign| that is present.
-The |subtype| field is called |span_count|; an unset box typically
-contains the data for |qo(span_count)+1| columns.
-Unset nodes will be changed to box nodes when alignment is completed.
-
-In fact, there are still more types coming. When we get to math formula
-processing we will see that a |style_node| has |type=14|; and a number
-of larger type codes will also be defined, for use in math mode only.
-
-Warning: If any changes are made to these data structure layouts, such as
-changing any of the node sizes or even reordering the words of nodes,
-the |copy_node_list| procedure and the memory initialization code
-below may have to be changed. Such potentially dangerous parts of the
-program are listed in the index under `data structure assumptions'.
-@!@^data structure assumptions@>
-However, other references to the nodes are made symbolically in terms of
-the \.{WEB} macro definitions above, so that format changes will leave
-\TeX's other algorithms intact.
-@^system dependencies@>
-
-@ This function creates a |local_paragraph| node
-
-@c
-
-halfword make_local_par_node(int mode)
-{
-    int callback_id;
-    halfword q;
-    halfword p = new_node(local_par_node,0);
-    local_pen_inter(p) = local_inter_line_penalty_par;
-    local_pen_broken(p) = local_broken_penalty_par;
-    if (local_left_box_par != null) {
-        q = copy_node_list(local_left_box_par);
-        local_box_left(p) = q;
-        local_box_left_width(p) = width(local_left_box_par);
-    }
-    if (local_right_box_par != null) {
-        q = copy_node_list(local_right_box_par);
-        local_box_right(p) = q;
-        local_box_right_width(p) = width(local_right_box_par);
-    }
-    local_par_dir(p) = par_direction_par;
-    /* callback with node passed */
-    callback_id = callback_defined(insert_local_par_callback);
-    if (callback_id > 0) {
-        int sfix = lua_gettop(Luas);
-        if (!get_callback(Luas, callback_id)) {
-            lua_settop(Luas, sfix);
-            return p;
-        }
-        nodelist_to_lua(Luas, p);
-        lua_push_local_par_mode(Luas,mode)
-        if (lua_pcall(Luas, 2, 0, 0) != 0) { /* 2 arg, 0 result */
-            char errmsg[256]; /* temp hack ... we will have a formatted error */
-            snprintf(errmsg, 255, "error: %s\n", lua_tostring(Luas, -1));
-            errmsg[255]='\0';
-            lua_settop(Luas, sfix);
-            normal_error("insert_local_par",errmsg); /* to be done */
-            return p;
-        }
-        lua_settop(Luas, sfix);
-    }
-    /* done */
-    return p;
-}
diff --git a/texk/web2c/luatexdir/tex/textcodes.w b/texk/web2c/luatexdir/tex/textcodes.c
similarity index 84%
rename from texk/web2c/luatexdir/tex/textcodes.w
rename to texk/web2c/luatexdir/tex/textcodes.c
index 89e936841..a6a0b3a55 100644
--- a/texk/web2c/luatexdir/tex/textcodes.w
+++ b/texk/web2c/luatexdir/tex/textcodes.c
@@ -1,27 +1,35 @@
-% textcodes.w
-%
-% Copyright 2006-2010 Taco Hoekwater <taco@@luatex.org>
-%
-% This file is part of LuaTeX.
-%
-% LuaTeX is free software; you can redistribute it and/or modify it under
-% the terms of the GNU General Public License as published by the Free
-% Software Foundation; either version 2 of the License, or (at your
-% option) any later version.
-%
-% LuaTeX is distributed in the hope that it will be useful, but WITHOUT
-% ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-% FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
-% License for more details.
-%
-% You should have received a copy of the GNU General Public License along
-% with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
-
-@ @c
+/*
+
+textcodes.w
+
+Copyright 2006-2010 Taco Hoekwater <taco@@luatex.org>
+
+This file is part of LuaTeX.
+
+LuaTeX is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 2 of the License, or (at your
+option) any later version.
+
+LuaTeX is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+License for more details.
+
+You should have received a copy of the GNU General Public License along
+with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+
+*/
 
 #include "ptexlib.h"
 
-@ catcodes @c
+/*tex
+
+Contrary to traditional \TEX\ we have catcode tables so that we can switch
+catcode regimes very fast. We can have many such regimes and they're stored in
+trees.
+
+*/
 
 #define CATCODESTACK       8
 #define CATCODEDEFAULT    12
@@ -174,7 +182,11 @@ static void freecatcodes(void)
     xfree(catcode_valid);
 }
 
-@ lccodes @c
+/*tex
+
+The lowercase mapping codes are also stored in a tree.
+
+*/
 
 #define LCCODESTACK   8
 #define LCCODEDEFAULT 0
@@ -220,7 +232,11 @@ static void freelccodes(void)
     destroy_sa_tree(lccode_head);
 }
 
-@ uccodes @c
+/*tex
+
+And the uppercase mapping codes are again stored in a tree.
+
+*/
 
 #define UCCODESTACK   8
 #define UCCODEDEFAULT 0
@@ -266,7 +282,11 @@ static void freeuccodes(void)
     destroy_sa_tree(uccode_head);
 }
 
-@ sfcodes @c
+/*tex
+
+By now it will be no surprise that the space factors get stored in a tree.
+
+*/
 
 #define SFCODESTACK      8
 #define SFCODEDEFAULT 1000
@@ -312,19 +332,29 @@ static void freesfcodes(void)
     destroy_sa_tree(sfcode_head);
 }
 
-@ hjcodes @c
+/*tex
+
+The hyphenation codes are indeed stored in a tree and are used instead of
+lowercase codes when deciding what characters to take into acccount when
+hyphenating. They are bound to upto |HJCODE_MAX| languages.
+
+*/
 
 #define HJCODESTACK       8
 #define HJCODEDEFAULT     0
-#define HJCODE_MAX    16383 /* number of languages */
+#define HJCODE_MAX    16383
 
 static sa_tree *hjcode_heads = NULL;
 static int hjcode_max = 0;
 static unsigned char *hjcode_valid = NULL;
 
-@ Here we set codes but we don't initialize from lccodes.
+/*tex
+
+Here we set codes but we don't initialize from lccodes.
+
+*/
 
-@c void set_hj_code(int h, int n, halfword v, quarterword gl)
+void set_hj_code(int h, int n, halfword v, quarterword gl)
 {
     sa_tree_item sa_value = { 0 };
     sa_tree s = hjcode_heads[h];
@@ -339,9 +369,13 @@ static unsigned char *hjcode_valid = NULL;
     set_sa_item(s, n, sa_value, gl);
 }
 
-@ We just return the lccodes when nothing is set.
+/*tex
 
-@c halfword get_hj_code(int h, int n)
+We just return the lccodes when nothing is set.
+
+*/
+
+halfword get_hj_code(int h, int n)
 {
     sa_tree s = hjcode_heads[h];
     if (s == NULL) {
@@ -350,12 +384,14 @@ static unsigned char *hjcode_valid = NULL;
     return (halfword) get_sa_item(s, n).int_value;
 }
 
-@ We don't restore as we can have more languages in a paragraph
-and hyphenation takes place at a later stage so we would get
-weird grouping side effects .. so, one can overload settings
-but management is then upto the used, so no:
+/*tex
+
+We don't restore as we can have more languages in a paragraph and hyphenation
+takes place at a later stage so we would get weird grouping side effects .. so,
+one can overload settings but management is then upto the used, so no:
+
+*/
 
-@c
 /*
     static void unsavehjcodes(quarterword gl) { }
 */
@@ -444,7 +480,11 @@ static void freehjcodes(void)
     xfree(hjcode_valid);
 }
 
-/* management */
+/*tex
+
+The public management functions.
+
+*/
 
 void unsave_text_codes(quarterword grouplevel)
 {
diff --git a/texk/web2c/luatexdir/tex/textoken.w b/texk/web2c/luatexdir/tex/textoken.c
similarity index 63%
rename from texk/web2c/luatexdir/tex/textoken.w
rename to texk/web2c/luatexdir/tex/textoken.c
index d58aa3dc4..6056bba25 100644
--- a/texk/web2c/luatexdir/tex/textoken.w
+++ b/texk/web2c/luatexdir/tex/textoken.c
@@ -1,40 +1,26 @@
-% textoken.w
-%
-% Copyright 2006-2011 Taco Hoekwater <taco@@luatex.org>
-%
-% This file is part of LuaTeX.
-%
-% LuaTeX is free software; you can redistribute it and/or modify it under
-% the terms of the GNU General Public License as published by the Free
-% Software Foundation; either version 2 of the License, or (at your
-% option) any later version.
-%
-% LuaTeX is distributed in the hope that it will be useful, but WITHOUT
-% ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-% FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
-% License for more details.
-%
-% You should have received a copy of the GNU General Public License along
-% with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
-
-@ @c
+/*
 
-#include "ptexlib.h"
+Copyright 2006-2011 Taco Hoekwater <taco@luatex.org>
 
-@ @c
-#define detokenized_line() (line_catcode_table==NO_CAT_TABLE)
+This file is part of LuaTeX.
+
+LuaTeX is free software; you can redistribute it and/or modify it under the terms
+of the GNU General Public License as published by the Free Software Foundation;
+either version 2 of the License, or (at your option) any later version.
+
+LuaTeX is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU General Public License along with
+LuaTeX; if not, see <http://www.gnu.org/licenses/>.
 
-/*
-#define do_get_cat_code(a,b) do { \
-    if (line_catcode_table<=-0xFF) \
-      a= - line_catcode_table - 0xFF ; \
-    else if (line_catcode_table!=DEFAULT_CAT_TABLE) \
-      a=get_cat_code(line_catcode_table,b); \
-    else \
-      a=get_cat_code(cat_code_table_par,b); \
-  } while (0)
 */
 
+#include "ptexlib.h"
+
+#define detokenized_line() (line_catcode_table==NO_CAT_TABLE)
+
 #define do_get_cat_code(a,b) do { \
     if (line_catcode_table==DEFAULT_CAT_TABLE) \
       a=get_cat_code(cat_code_table_par,b); \
@@ -45,47 +31,85 @@
   } while (0)
 
 
-@ The \TeX\ system does nearly all of its own memory allocation, so that it can
-readily be transported into environments that do not have automatic facilities
-for strings, garbage collection, etc., and so that it can be in control of what
-error messages the user receives. The dynamic storage requirements of \TeX\ are
-handled by providing two large arrays called |fixmem| and |varmem| in which
-consecutive blocks of words are used as nodes by the \TeX\ routines.
+/*tex
+
+    The \TeX\ system does nearly all of its own memory allocation, so that it can
+    readily be transported into environments that do not have automatic
+    facilities for strings, garbage collection, etc., and so that it can be in
+    control of what error messages the user receives. The dynamic storage
+    requirements of \TeX\ are handled by providing two large arrays called
+    |fixmem| and |varmem| in which consecutive blocks of words are used as nodes
+    by the \TeX\ routines.
+
+    Pointer variables are indices into this array, or into another array called
+    |eqtb| that will be explained later. A pointer variable might also be a
+    special flag that lies outside the bounds of |mem|, so we allow pointers to
+    assume any |halfword| value. The minimum halfword value represents a null
+    pointer. \TeX\ does not assume that |mem[null]| exists.
+
+    Locations in |fixmem| are used for storing one-word records; a conventional
+    \.{AVAIL} stack is used for allocation in this array.
+
+*/
+
+/*tex the big dynamic storage area */
+
+smemory_word *fixmem;
+
+/*tex the smallest location of one-word memory in use */
 
-Pointer variables are indices into this array, or into another array called
-|eqtb| that will be explained later. A pointer variable might also be a special
-flag that lies outside the bounds of |mem|, so we allow pointers to assume any
-|halfword| value. The minimum halfword value represents a null pointer. \TeX\
-does not assume that |mem[null]| exists.
+unsigned fix_mem_min;
 
-@ Locations in |fixmem| are used for storing one-word records; a conventional
-\.{AVAIL} stack is used for allocation in this array.
+/*tex the largest location of one-word memory in use */
 
-@c
-smemory_word *fixmem;           /* the big dynamic storage area */
-unsigned fix_mem_min;           /* the smallest location of one-word memory in use */
-unsigned fix_mem_max;           /* the largest location of one-word memory in use */
+unsigned fix_mem_max;
 
-@ In order to study the memory requirements of particular applications, it is
-possible to prepare a version of \TeX\ that keeps track of current and maximum
-memory usage. When code between the delimiters |@!stat| $\ldots$ |tats| is not
-commented out, \TeX\ will run a bit slower but it will report these statistics
-when |tracing_stats| is sufficiently large.
+/*tex
+
+    In order to study the memory requirements of particular applications, it is
+    possible to prepare a version of \TeX\ that keeps track of current and
+    maximum memory usage. When code between the delimiters |stat| $\ldots$
+    |tats| is not commented out, \TeX\ will run a bit slower but it will report
+    these statistics when |tracing_stats| is sufficiently large.
+
+*/
 
-@c
-int var_used, dyn_used;         /* how much memory is in use */
+/*tex how much memory is in use */
 
-halfword avail;                 /* head of the list of available one-word nodes */
-unsigned fix_mem_end;           /* the last one-word node used in |mem| */
+int var_used, dyn_used;
 
-halfword garbage;               /* head of a junk list, write only */
-halfword temp_token_head;       /* head of a temporary list of some kind */
-halfword hold_token_head;       /* head of a temporary list of another kind */
-halfword omit_template;         /* a constant token list */
-halfword null_list;             /* permanently empty list */
-halfword backup_head;           /* head of token list built by |scan_keyword| */
+/*tex head of the list of available one-word nodes */
+
+halfword avail;
+
+/*tex the last one-word node used in |mem| */
+
+unsigned fix_mem_end;
+
+/*tex head of a junk list, write only */
+
+halfword garbage;
+
+/*tex head of a temporary list of some kind */
+
+halfword temp_token_head;
+
+/*tex head of a temporary list of another kind */
+
+halfword hold_token_head;
+
+/*tex a constant token list */
+
+halfword omit_template;
+
+/*tex permanently empty list */
+
+halfword null_list;
+
+/*tex head of token list built by |scan_keyword| */
+
+halfword backup_head;
 
-@ @c
 void initialize_tokens(void)
 {
     halfword p;
@@ -109,37 +133,44 @@ void initialize_tokens(void)
     p = get_avail();
     garbage = p;
     set_token_info(garbage, 0);
-    dyn_used = 0;               /* initialize statistics */
+    dyn_used = 0;
 }
 
-@ The function |get_avail| returns a pointer to a new one-word node whose |link|
-field is null. However, \TeX\ will halt if there is no more room left.
-@^inner loop@>
+/*tex
+
+    The function |get_avail| returns a pointer to a new one-word node whose
+    |link| field is null. However, \TeX\ will halt if there is no more room left.
 
-If the available-space list is empty, i.e., if |avail=null|, we try first to
-increase |fix_mem_end|. If that cannot be done, i.e., if
-|fix_mem_end=fix_mem_max|, we try to reallocate array |fixmem|. If, that doesn't
-work, we have to quit.
+    If the available-space list is empty, i.e., if |avail=null|, we try first to
+    increase |fix_mem_end|. If that cannot be done, i.e., if
+    |fix_mem_end=fix_mem_max|, we try to reallocate array |fixmem|. If, that
+    doesn't work, we have to quit.
+
+    Single-word node allocation:
+*/
 
-@c
 halfword get_avail(void)
-{                               /* single-word node allocation */
-    unsigned p;                 /* the new node being got */
+{
+    /*tex The new node being got: */
+    unsigned p;
     unsigned t;
-    p = (unsigned) avail;       /* get top location in the |avail| stack */
+    /*tex Get top location in the |avail| stack. */
+    p = (unsigned) avail;
     if (p != null) {
-        avail = token_link(avail);      /* and pop it off */
-    } else if (fix_mem_end < fix_mem_max) {     /* or go into virgin territory */
+        /*tex Pop it off. */
+        avail = token_link(avail);
+    } else if (fix_mem_end < fix_mem_max) {
+        /*tex Go into virgin territory. */
         incr(fix_mem_end);
         p = fix_mem_end;
     } else {
-        smemory_word *new_fixmem;       /* the big dynamic storage area */
+        /*tex The big dynamic storage area. */
+        smemory_word *new_fixmem;
         t = (fix_mem_max / 5);
-        new_fixmem =
-            fixmemcast(realloc
-                       (fixmem, sizeof(smemory_word) * (fix_mem_max + t + 1)));
+        new_fixmem = fixmemcast(realloc(fixmem, sizeof(smemory_word) * (fix_mem_max + t + 1)));
         if (new_fixmem == NULL) {
-            runaway();          /* if memory is exhausted, display possible runaway text */
+            /*tex If memory is exhausted, display possible runaway text. */
+            runaway();
             overflow("token memory size", fix_mem_max);
         } else {
             fixmem = new_fixmem;
@@ -148,111 +179,127 @@ halfword get_avail(void)
         fix_mem_max += t;
         p = ++fix_mem_end;
     }
-    token_link(p) = null;       /* provide an oft-desired initialization of the new node */
-    incr(dyn_used);             /* maintain statistics */
+    /*tex Provide an oft-desired initialization of the new node. */
+    token_link(p) = null;
+    /*tex Maintain statistics. */
+    incr(dyn_used);
     return (halfword) p;
 }
 
-@ The procedure |flush_list(p)| frees an entire linked list of one-word nodes
-that starts at position |p|.
-@^inner loop@>
+/*tex
+
+    The procedure |flush_list(p)| frees an entire linked list of one-word nodes
+    that starts at position |p|.
+
+    This makes list of single-word nodes available:
+
+*/
 
-@c
 void flush_list(halfword p)
-{                               /* makes list of single-word nodes available */
-    halfword q, r;              /* list traversers */
+{
+    halfword q, r;
     if (p != null) {
         r = p;
         do {
             q = r;
             r = token_link(r);
             decr(dyn_used);
-        } while (r != null);    /* now |q| is the last node on the list */
+        } while (r != null);
+        /*tex Now |q| is the last node on the list. */
         token_link(q) = avail;
         avail = p;
     }
 }
 
-@ A \TeX\ token is either a character or a control sequence, and it is @^token@>
-represented internally in one of two ways: (1)~A character whose ASCII code
-number is |c| and whose command code is |m| is represented as the number
-$2^{21}m+c$; the command code is in the range |1<=m<=14|. (2)~A control sequence
-whose |eqtb| address is |p| is represented as the number |cs_token_flag+p|. Here
-|cs_token_flag=@t$2^{25}-1$@>| is larger than $2^{21}m+c$, yet it is small enough
-that |cs_token_flag+p< max_halfword|; thus, a token fits comfortably in a
-halfword.
-
-A token |t| represents a |left_brace| command if and only if
-|t<left_brace_limit|; it represents a |right_brace| command if and only if we
-have |left_brace_limit<=t<right_brace_limit|; and it represents a |match| or
-|end_match| command if and only if |match_token<=t<=end_match_token|. The
-following definitions take care of these token-oriented constants and a few
-others.
-
-@ A token list is a singly linked list of one-word nodes in |mem|, where each
-word contains a token and a link. Macro definitions, output-routine definitions,
-marks, \.{\\write} texts, and a few other things are remembered by \TeX\ in the
-form of token lists, usually preceded by a node with a reference count in its
-|token_ref_count| field. The token stored in location |p| is called |info(p)|.
-
-Three special commands appear in the token lists of macro definitions. When
-|m=match|, it means that \TeX\ should scan a parameter for the current macro;
-when |m=end_match|, it means that parameter matching should end and \TeX\ should
-start reading the macro text; and when |m=out_param|, it means that \TeX\ should
-insert parameter number |c| into the text at this point.
-
-The enclosing \.{\char'173} and \.{\char'175} characters of a macro definition
-are omitted, but the final right brace of an output routine is included at the
-end of its token list.
-
-Here is an example macro definition that illustrates these conventions. After
-\TeX\ processes the text
-
-$$\.{\\def\\mac a\#1\#2 \\b \{\#1\\-a \#\#1\#2 \#2\}}$$
-
-the definition of \.{\\mac} is represented as a token list containing
-
-$$\def\,{\hskip2pt}
-\vbox{\halign{\hfil#\hfil\cr
-(reference count), |letter|\,\.a, |match|\,\#, |match|\,\#, |spacer|\,\.\ ,
-\.{\\b}, |end_match|,\cr
-|out_param|\,1, \.{\\-}, |letter|\,\.a, |spacer|\,\.\ , |mac_param|\,\#,
-|other_char|\,\.1,\cr
-|out_param|\,2, |spacer|\,\.\ , |out_param|\,2.\cr}}$$
-
-The procedure |scan_toks| builds such token lists, and |macro_call| does the
-parameter matching. @^reference counts@>
-
-Examples such as $$\.{\\def\\m\{\\def\\m\{a\}\ b\}}$$ explain why reference
-counts would be needed even if \TeX\ had no \.{\\let} operation: When the token
-list for \.{\\m} is being read, the redefinition of \.{\\m} changes the |eqtb|
-entry before the token list has been fully consumed, so we dare not simply
-destroy a token list when its control sequence is being redefined.
-
-If the parameter-matching part of a definition ends with `\.{\#\{}', the
-corresponding token list will have `\.\{' just before the `|end_match|' and also
-at the very end. The first `\.\{' is used to delimit the parameter; the second
-one keeps the first from disappearing.
-
-The |print_meaning| subroutine displays |cur_cmd| and |cur_chr| in symbolic form,
-including the expansion of a macro or mark.
-
-@c
+/*tex
+
+    A \TeX\ token is either a character or a control sequence, and it is
+    represented internally in one of two ways: (1)~A character whose ASCII code
+    number is |c| and whose command code is |m| is represented as the number
+    $2^{21}m+c$; the command code is in the range |1<=m<=14|. (2)~A control
+    sequence whose |eqtb| address is |p| is represented as the number
+    |cs_token_flag+p|. Here |cs_token_flag=t=| $2^{25}-1$ is larger than
+    $2^{21}m+c$, yet it is small enough that |cs_token_flag+p< max_halfword|;
+    thus, a token fits comfortably in a halfword.
+
+    A token |t| represents a |left_brace| command if and only if
+    |t<left_brace_limit|; it represents a |right_brace| command if and only if we
+    have |left_brace_limit<=t<right_brace_limit|; and it represents a |match| or
+    |end_match| command if and only if |match_token<=t<=end_match_token|. The
+    following definitions take care of these token-oriented constants and a few
+    others.
+
+    A token list is a singly linked list of one-word nodes in |mem|, where each
+    word contains a token and a link. Macro definitions, output-routine
+    definitions, marks, \.{\\write} texts, and a few other things are remembered
+    by \TeX\ in the form of token lists, usually preceded by a node with a
+    reference count in its |token_ref_count| field. The token stored in location
+    |p| is called |info(p)|.
+
+    Three special commands appear in the token lists of macro definitions. When
+    |m=match|, it means that \TeX\ should scan a parameter for the current macro;
+    when |m=end_match|, it means that parameter matching should end and \TeX\
+    should start reading the macro text; and when |m=out_param|, it means that
+    \TeX\ should insert parameter number |c| into the text at this point.
+
+    The enclosing \.{\char'173} and \.{\char'175} characters of a macro
+    definition are omitted, but the final right brace of an output routine is
+    included at the end of its token list.
+
+    Here is an example macro definition that illustrates these conventions. After
+    \TeX\ processes the text
+
+    \starttyping
+    \def\mac a#1#2 \b {#1\-a ##1#2 \#2\}
+    \stoptyping
+
+    the definition of \.{\\mac} is represented as a token list containing
+
+    \starttyping
+    (reference count) |letter|a |match|# |match|# |spacer| \b |end_match|
+    |out_param|1 \- |letter|a |spacer|, |mac_param|# |other_char|1
+    |out_param|2 |spacer| |out_param|2
+    \stoptyping
+
+    The procedure |scan_toks| builds such token lists, and |macro_call| does the
+    parameter matching.
+
+    Examples such as \type{\def\m{\def\m{a} b}} explain why reference
+    counts would be needed even if \TeX\ had no \.{\\let} operation: When the
+    token list for \.{\\m} is being read, the redefinition of \.{\\m} changes the
+    |eqtb| entry before the token list has been fully consumed, so we dare not
+    simply destroy a token list when its control sequence is being redefined.
+
+    If the parameter-matching part of a definition ends with `\.{\#\{}', the
+    corresponding token list will have `\.\{' just before the `|end_match|' and
+    also at the very end. The first `\.\{' is used to delimit the parameter; the
+    second one keeps the first from disappearing.
+
+    The |print_meaning| subroutine displays |cur_cmd| and |cur_chr| in symbolic
+    form, including the expansion of a macro or mark.
+
+*/
+
 void print_meaning(void)
 {
-    /* remap \mathchar onto \Umathchar */
-/*
+    /*tex
+
+    This would make sense but some macro packages don't like it:
+
+    \starttyping
     if (cur_cmd == math_given_cmd) {
         cur_cmd = xmath_given_cmd ;
     }
-*/
+    \stoptyping
+
+    */
     print_cmd_chr((quarterword) cur_cmd, cur_chr);
     if (cur_cmd >= call_cmd) {
         print_char(':');
         print_ln();
         token_show(cur_chr);
     } else {
-        /* Show the meaning of a mark node */
+        /*tex Show the meaning of a mark node. */
         if ((cur_cmd == top_bot_mark_cmd) && (cur_chr < marks_code)) {
             print_char(':');
             print_ln();
@@ -277,31 +324,35 @@ void print_meaning(void)
     }
 }
 
-@ The procedure |show_token_list|, which prints a symbolic form of the token list
-that starts at a given node |p|, illustrates these conventions. The token list
-being displayed should not begin with a reference count. However, the procedure
-is intended to be robust, so that if the memory links are awry or if |p| is not
-really a pointer to a token list, nothing catastrophic will happen.
-
-An additional parameter |q| is also given; this parameter is either null or it
-points to a node in the token list where a certain magic computation takes place
-that will be explained later. (Basically, |q| is non-null when we are printing
-the two-line context information at the time of an error message; |q| marks the
-place corresponding to where the second line should begin.)
-
-For example, if |p| points to the node containing the first \.a in the token list
-above, then |show_token_list| will print the string $$\hbox{`\.{a\#1\#2\ \\b\
-->\#1\\-a\ \#\#1\#2\ \#2}';}$$ and if |q| points to the node containing the
-second \.a, the magic computation will be performed just before the second \.a is
-printed.
-
-The generation will stop, and `\.{\\ETC.}' will be printed, if the length of
-printing exceeds a given limit~|l|. Anomalous entries are printed in the form of
-control sequences that are not followed by a blank space, e.g., `\.{\\BAD.}';
-this cannot be confused with actual control sequences because a real control
-sequence named \.{BAD} would come out `\.{\\BAD\ }'.
-
-@c
+/*tex
+
+    The procedure |show_token_list|, which prints a symbolic form of the token
+    list that starts at a given node |p|, illustrates these conventions. The
+    token list being displayed should not begin with a reference count. However,
+    the procedure is intended to be robust, so that if the memory links are awry
+    or if |p| is not really a pointer to a token list, nothing catastrophic will
+    happen.
+
+    An additional parameter |q| is also given; this parameter is either null or
+    it points to a node in the token list where a certain magic computation takes
+    place that will be explained later. (Basically, |q| is non-null when we are
+    printing the two-line context information at the time of an error message;
+    |q| marks the place corresponding to where the second line should begin.)
+
+    For example, if |p| points to the node containing the first \.a in the token
+    list above, then |show_token_list| will print the string $$\hbox{`\.{a\#1\#2\
+    \\b\ ->\#1\\-a\ \#\#1\#2\ \#2}';}$$ and if |q| points to the node containing
+    the second \.a, the magic computation will be performed just before the
+    second \.a is printed.
+
+    The generation will stop, and `\.{\\ETC.}' will be printed, if the length of
+    printing exceeds a given limit~|l|. Anomalous entries are printed in the form
+    of control sequences that are not followed by a blank space, e.g.,
+    `\.{\\BAD.}'; this cannot be confused with actual control sequences because a
+    real control sequence named \.{BAD} would come out `\.{\\BAD\ }'.
+
+*/
+
 #define not_so_bad(p) \
     switch (m) { \
         case assign_int_cmd: \
@@ -316,6 +367,18 @@ sequence named \.{BAD} would come out `\.{\\BAD\ }'.
             if (c >= (backend_toks_base) && c <= (backend_toks_last)) \
                 p("[internal backend tokenlist]"); \
             break; \
+        case node_cmd: \
+            p("[internal node pointer]"); \
+            break; \
+        case lua_call_cmd: \
+            p("[internal lua function call]"); \
+            break; \
+        case lua_expandable_call_cmd: \
+            p("[internal expandable lua function call]"); \
+            break; \
+        case lua_local_call_cmd: \
+            p("[internal local lua function call]"); \
+            break; \
         default: \
             p("BAD"); \
             break; \
@@ -323,18 +386,21 @@ sequence named \.{BAD} would come out `\.{\\BAD\ }'.
 
 void show_token_list(int p, int q, int l)
 {
-    int m, c;                    /* pieces of a token */
-    ASCII_code match_chr = '#';  /* character used in a `|match|' */
-    ASCII_code n = '0';          /* the highest parameter number, as an ASCII digit */
+    /*tex pieces of a token */
+    int m, c;
+    /*tex character used in a `|match|' */
+    ASCII_code match_chr = '#';
+    /*tex the highest parameter number, as an ASCII digit */
+    ASCII_code n = '0';
     tally = 0;
     if (l < 0)
         l = 0x3FFFFFFF;
     while ((p != null) && (tally < l)) {
         if (p == q) {
-            /* Do magic computation */
+            /*tex Do magic computation. */
             set_trick_count();
         }
-        /* Display token |p|, and |return| if there are problems */
+        /*tex Display token |p|, and |return| if there are problems. */
         if ((p < (int) fix_mem_min) || (p > (int) fix_mem_end)) {
             tprint_esc("CLOBBERED.");
             return;
@@ -349,11 +415,11 @@ void show_token_list(int p, int q, int l)
                 tprint_esc("BAD");
             } else {
                 /*
-                    Display the token $(|m|,|c|)$
-
-                    The procedure usually ``learns'' the character code used for macro
-                    parameters by seeing one in a |match| command before it runs into any
+                    Display the token \type {(|m|,|c|)}. The procedure usually
+                    ``learns'' the character code used for macro parameters by
+                    seeing one in a |match| command before it runs into any
                     |out_param| commands.
+
                 */
                 switch (m) {
                     case left_brace_cmd:
@@ -405,31 +471,36 @@ void show_token_list(int p, int q, int l)
         tprint_esc("ETC.");
 }
 
-@ @c
 #define do_buffer_to_unichar(a,b) do { \
     a = (halfword)str2uni(buffer+b); \
     b += utf8_size(a); \
 } while (0)
 
-@ Here's the way we sometimes want to display a token list, given a pointer to
-its reference count; the pointer may be null.
+/*tex
+
+    Here's the way we sometimes want to display a token list, given a pointer to
+    its reference count; the pointer may be null.
+
+*/
 
-@c
 void token_show(halfword p)
 {
     if (p != null)
         show_token_list(token_link(p), null, 10000000);
 }
 
-@ |delete_token_ref|, is called when a pointer to a token list's reference count
-is being removed. This means that the token list should disappear if the
-reference count was |null|, otherwise the count should be decreased by one.
-@^reference counts@>
+/*tex
 
-@ |p| points to the reference count of a token list that is losing one
-reference.
+    |delete_token_ref|, is called when a pointer to a token list's reference
+    count is being removed. This means that the token list should disappear if
+    the reference count was |null|, otherwise the count should be decreased by
+    one.
+
+    |p| points to the reference count of a token list that is losing one
+    reference.
+
+*/
 
-@c
 void delete_token_ref(halfword p)
 {
     if (token_ref_count(p) == 0)
@@ -438,7 +509,6 @@ void delete_token_ref(halfword p)
         decr(token_ref_count(p));
 }
 
-@ @c
 int get_char_cat_code(int curchr)
 {
     int a;
@@ -446,7 +516,6 @@ int get_char_cat_code(int curchr)
     return a;
 }
 
-@ @c
 static void invalid_character_error(void)
 {
     const char *hlp[] = {
@@ -459,10 +528,9 @@ static void invalid_character_error(void)
     deletions_allowed = true;
 }
 
-@ @c
-static boolean process_sup_mark(void);  /* below */
+static boolean process_sup_mark(void);
 
-static int scan_control_sequence(void); /* below */
+static int scan_control_sequence(void);
 
 typedef enum {
     next_line_ok,
@@ -470,57 +538,83 @@ typedef enum {
     next_line_restart
 } next_line_retval;
 
-static next_line_retval next_line(void); /* below */
+static next_line_retval next_line(void);
 
-@ In case you are getting bored, here is a slightly less trivial routine: Given a
-string of lowercase letters, like `\.{pt}' or `\.{plus}' or `\.{width}', the
-|scan_keyword| routine checks to see whether the next tokens of input match this
-string. The match must be exact, except that uppercase letters will match their
-lowercase counterparts; uppercase equivalents are determined by subtracting
-|"a"-"A"|, rather than using the |uc_code| table, since \TeX\ uses this routine
-only for its own limited set of keywords.
+/*tex
 
-If a match is found, the characters are effectively removed from the input and
-|true| is returned. Otherwise |false| is returned, and the input is left
-essentially unchanged (except for the fact that some macros may have been
-expanded, etc.). @^inner loop@>
+    In case you are getting bored, here is a slightly less trivial routine: Given
+    a string of lowercase letters, like `\.{pt}' or `\.{plus}' or `\.{width}',
+    the |scan_keyword| routine checks to see whether the next tokens of input
+    match this string. The match must be exact, except that uppercase letters
+    will match their lowercase counterparts; uppercase equivalents are determined
+    by subtracting |"a"-"A"|, rather than using the |uc_code| table, since \TeX\
+    uses this routine only for its own limited set of keywords.
+
+    If a match is found, the characters are effectively removed from the input
+    and |true| is returned. Otherwise |false| is returned, and the input is left
+    essentially unchanged (except for the fact that some macros may have been
+    expanded, etc.).
+
+*/
 
-@c
 boolean scan_keyword(const char *s)
-{                               /* look for a given string */
-    halfword p;                 /* tail of the backup list */
-    halfword q;                 /* new node being added to the token list via |store_new_token| */
-    const char *k;              /* index into |str_pool| */
+{
+    /*tex tail of the backup list */
+    halfword p;
+    /*tex new node being added to the token list via |store_new_token| */
+    halfword q;
+    /*tex index into |str_pool| */
+    const char *k;
     halfword save_cur_cs = cur_cs;
-    if (strlen(s) == 0)        /* was assert (strlen(s) > 1); */
-      return false ;           /* but not with newtokenlib  zero keyword simply doesn't match  */
+    if (strlen(s) == 0) {
+        /*tex but not with newtokenlib zero keyword simply doesn't match  */
+        return false ;
+    }
     p = backup_head;
     token_link(p) = null;
     k = s;
     while (*k) {
-        get_x_token();      /* recursion is possible here */
+        /*tex Recursion is possible here! */
+        get_x_token();
         if ((cur_cs == 0) && ((cur_chr == *k) || (cur_chr == *k - 'a' + 'A'))) {
             store_new_token(cur_tok);
             k++;
         } else if ((cur_cmd != spacer_cmd) || (p != backup_head)) {
-            /*
-                crashes on some alignments:
+            back_input();
+            if (p != backup_head) {
+                begin_token_list(token_link(backup_head), backed_up);
+            }
+            cur_cs = save_cur_cs;
+            return false;
+        }
+    }
+    if (token_link(backup_head) != null)
+        flush_list(token_link(backup_head));
+    cur_cs = save_cur_cs;
+    return true;
+}
 
-                if (p != backup_head) {
-                    q = get_avail();
-                    token_info(q) = cur_tok;
-                    token_link(q) = null;
-                    token_link(p) = q;
-                    begin_token_list(token_link(backup_head), backed_up);
-                } else {
-                    back_input();
-                }
-            */
+boolean scan_keyword_case_sensitive(const char *s)
+{
+    halfword p;
+    halfword q;
+    const char *k;
+    halfword save_cur_cs = cur_cs;
+    if (strlen(s) == 0)
+        return false ;
+    p = backup_head;
+    token_link(p) = null;
+    k = s;
+    while (*k) {
+        get_x_token();
+        if ((cur_cs == 0) && (cur_chr == *k)) {
+            store_new_token(cur_tok);
+            k++;
+        } else if ((cur_cmd != spacer_cmd) || (p != backup_head)) {
             back_input();
             if (p != backup_head) {
                 begin_token_list(token_link(backup_head), backed_up);
             }
-            /*  */
             cur_cs = save_cur_cs;
             return false;
         }
@@ -531,36 +625,11 @@ boolean scan_keyword(const char *s)
     return true;
 }
 
-@ We can not return |undefined_control_sequence| under some conditions
- (inside |shift_case|, for example). This needs thinking.
+/*tex
 
-@c
+    We can not return |undefined_control_sequence| under some conditions (inside
+    |shift_case|, for example). This needs thinking.
 
-/*
-    halfword active_to_cs(int curchr, int force)
-    {
-        halfword curcs;
-        char *a, *b;
-        char *utfbytes = xmalloc(8);
-        int nncs = no_new_control_sequence;
-        a = (char *) uni2str(0xFFFF);
-        utfbytes = strcpy(utfbytes, a);
-        if (force)
-            no_new_control_sequence = false;
-        if (curchr > 0) {
-            b = (char *) uni2str((unsigned) curchr);
-            utfbytes = strcat(utfbytes, b);
-            free(b);
-            curcs = string_lookup(utfbytes, strlen(utfbytes));
-        } else {
-            utfbytes[3] = '\0';
-            curcs = string_lookup(utfbytes, 4);
-        }
-        no_new_control_sequence = nncs;
-        free(a);
-        free(utfbytes);
-        return curcs;
-    }
 */
 
 /*static char * FFFF = "\xEF\xBF\xBF";*/ /* 0xFFFF */
@@ -581,7 +650,8 @@ halfword active_to_cs(int curchr, int force)
         curcs = string_lookup(utfbytes, utf8_size(curchr)+3);
         free(utfbytes);
     } else {
-        curcs = string_lookup("\xEF\xBF\xBF", 4); /* 0xFFFF ... why not 3 ? */
+        /*tex 0xFFFF ... why not 3 ? */
+        curcs = string_lookup("\xEF\xBF\xBF", 4);
     }
     no_new_control_sequence = nncs;
     return curcs;
@@ -641,11 +711,12 @@ halfword active_to_cs(int curchr, int force)
 
 */
 
-@ TODO this function should listen to \.{\\escapechar}
+/*tex
 
-@ prints a control sequence
+    Maybe this function should listen to \.{\\escapechar} but we can do without.
+
+*/
 
-@c
 static char *cs_to_string(halfword p)
 {
     const char *s;
@@ -687,9 +758,8 @@ static char *cs_to_string(halfword p)
     return (char *) ret;
 }
 
-@ TODO this is a quick hack, will be solved differently soon
+/*tex This is sort of a hack. */
 
-@c
 static char *cmd_chr_to_string(int cmd, int chr)
 {
     char *s;
@@ -704,56 +774,76 @@ static char *cmd_chr_to_string(int cmd, int chr)
     return s;
 }
 
-@ The heart of \TeX's input mechanism is the |get_next| procedure, which we shall
-develop in the next few sections of the program. Perhaps we shouldn't actually
-call it the ``heart,'' however, because it really acts as \TeX's eyes and mouth,
-reading the source files and gobbling them up. And it also helps \TeX\ to
-regurgitate stored token lists that are to be processed again. @^eyes and mouth@>
-
-The main duty of |get_next| is to input one token and to set |cur_cmd| and
-|cur_chr| to that token's command code and modifier. Furthermore, if the input
-token is a control sequence, the |eqtb| location of that control sequence is
-stored in |cur_cs|; otherwise |cur_cs| is set to zero.
-
-Underlying this simple description is a certain amount of complexity because of
-all the cases that need to be handled. However, the inner loop of |get_next| is
-reasonably short and fast.
-
-When |get_next| is asked to get the next token of a \.{\\read} line,
-it sets |cur_cmd=cur_chr=cur_cs=0| in the case that no more tokens
-appear on that line. (There might not be any tokens at all, if the
-|end_line_char| has |ignore| as its catcode.)
-
-The value of |par_loc| is the |eqtb| address of `\.{\\par}'. This quantity is
-needed because a blank line of input is supposed to be exactly equivalent to the
-appearance of \.{\\par}; we must set |cur_cs:=par_loc| when detecting a blank
-line.
-
-@c
-halfword par_loc;   /* location of `\.{\\par}' in |eqtb| */
-halfword par_token; /* token representing `\.{\\par}' */
-
-@ Parts |get_next| are executed more often than any other instructions of \TeX.
-@^mastication@>@^inner loop@>
-
-The global variable |force_eof| is normally |false|; it is set |true| by an
-\.{\\endinput} command. |luacstrings| is the number of lua print statements
-waiting to be input, it is changed by |luatokencall|.
-
-@c
-boolean force_eof; /* should the next \.{\\input} be aborted early? */
-int luacstrings;   /* how many lua strings are waiting to be input? */
-
-@ If the user has set the |pausing| parameter to some positive value, and if
-nonstop mode has not been selected, each line of input is displayed on the
-terminal and the transcript file, followed by `\.{=>}'. \TeX\ waits for a
-response. If the response is simply |carriage_return|, the line is accepted as it
-stands, otherwise the line typed is used instead of the line in the file.
-
-@c
+/*tex
+
+    The heart of \TeX's input mechanism is the |get_next| procedure, which we
+    shall develop in the next few sections of the program. Perhaps we shouldn't
+    actually call it the ``heart,'' however, because it really acts as \TeX's
+    eyes and mouth, reading the source files and gobbling them up. And it also
+    helps \TeX\ to regurgitate stored token lists that are to be processed again.
+
+    The main duty of |get_next| is to input one token and to set |cur_cmd| and
+    |cur_chr| to that token's command code and modifier. Furthermore, if the
+    input token is a control sequence, the |eqtb| location of that control
+    sequence is stored in |cur_cs|; otherwise |cur_cs| is set to zero.
+
+    Underlying this simple description is a certain amount of complexity because
+    of all the cases that need to be handled. However, the inner loop of
+    |get_next| is reasonably short and fast.
+
+    When |get_next| is asked to get the next token of a \.{\\read} line, it sets
+    |cur_cmd=cur_chr=cur_cs=0| in the case that no more tokens appear on that
+    line. (There might not be any tokens at all, if the |end_line_char| has
+    |ignore| as its catcode.)
+
+    The value of |par_loc| is the |eqtb| address of `\.{\\par}'. This quantity is
+    needed because a blank line of input is supposed to be exactly equivalent to
+    the appearance of \.{\\par}; we must set |cur_cs:=par_loc| when detecting a
+    blank line.
+
+*/
+
+/*tex
+
+    The location of `\.{\\par}' in |eqtb| adn the token representing `\.{\\par}.
+
+*/
+
+halfword par_loc;
+halfword par_token;
+
+/*tex
+
+    Parts |get_next| are executed more often than any other instructions of \TeX.
+
+    The global variable |force_eof| is normally |false|; it is set |true| by an
+    \.{\\endinput} command. |luacstrings| is the number of lua print statements
+    waiting to be input, it is changed by |luatokencall|.
+
+
+*/
+
+/*tex Should the next \.{\\input} be aborted early? */
+boolean force_eof;
+
+/*tex How many lua strings are waiting to be input? */
+
+int luacstrings;
+
+/*tex
+
+    If the user has set the |pausing| parameter to some positive value, and if
+    nonstop mode has not been selected, each line of input is displayed on the
+    terminal and the transcript file, followed by `\.{=>}'. \TeX\ waits for a
+    response. If the response is simply |carriage_return|, the line is accepted
+    as it stands, otherwise the line typed is used instead of the line in the
+    file.
+
+*/
+
 void firm_up_the_line(void)
 {
-    int k;                      /* an index into |buffer| */
+    int k;
     ilimit = last;
     if (pausing_par > 0) {
         if (interaction > nonstop_mode) {
@@ -764,9 +854,10 @@ void firm_up_the_line(void)
                     print_char(buffer[k]);
             }
             first = ilimit;
-            prompt_input("=>"); /* wait for user response */
+            prompt_input("=>");
             if (last > first) {
-                for (k = first; k < +last - 1; k++)     /* move line down in buffer */
+                /*tex Move line down in buffer. */
+                for (k = first; k < +last - 1; k++)
                     buffer[k + istart - first] = buffer[k];
                 ilimit = istart + last - first;
             }
@@ -774,31 +865,42 @@ void firm_up_the_line(void)
     }
 }
 
-@ Before getting into |get_next|, let's consider the subroutine that is called
-when an `\.{\\outer}' control sequence has been scanned or when the end of a file
-has been reached. These two cases are distinguished by |cur_cs|, which is zero at
-the end of a file.
+/*tex
+
+    Before getting into |get_next|, let's consider the subroutine that is called
+    when an `\.{\\outer}' control sequence has been scanned or when the end of a
+    file has been reached. These two cases are distinguished by |cur_cs|, which
+    is zero at the end of a file.
+
+*/
 
-@c
 void check_outer_validity(void)
 {
-    halfword p;                 /* points to inserted token list */
-    halfword q;                 /* auxiliary pointer */
+    /*tex points to inserted token list */
+    halfword p;
+    /*tex auxiliary pointer */
+    halfword q;
     if (suppress_outer_error_par)
         return;
     if (scanner_status != normal) {
         deletions_allowed = false;
-        /* Back up an outer control sequence so that it can be reread; */
-        /* An outer control sequence that occurs in a \.{\\read} will not be reread,
-           since the error recovery for \.{\\read} is not very powerful. */
+        /*tex
+
+            Back up an outer control sequence so that it can be reread. An
+            outer control sequence that occurs in a \.{\\read} will not be
+            reread, since the error recovery for \.{\\read} is not very powerful.
+
+        */
         if (cur_cs != 0) {
             if ((istate == token_list) || (iname < 1) || (iname > 17)) {
                 p = get_avail();
                 token_info(p) = cs_token_flag + cur_cs;
-                begin_token_list(p, backed_up); /* prepare to read the control sequence again */
+                /*tex prepare to read the control sequence again */
+                begin_token_list(p, backed_up);
             }
+            /*tex replace it by a space */
             cur_cmd = spacer_cmd;
-            cur_chr = ' ';      /* replace it by a space */
+            cur_chr = ' ';
         }
         if (scanner_status > skipping) {
             const char *errhlp[] = {
@@ -808,56 +910,64 @@ void check_outer_validity(void)
                 "you'd better type `E' or `X' now and fix your file.",
                 NULL
             };
-            char errmsg[256];
+            char errmsg[318];
             const char *startmsg;
             const char *scannermsg;
-            /* Tell the user what has run away and try to recover */
-            runaway();          /* print a definition, argument, or preamble */
+            /*tex
+
+                Tell the user what has run away and try to recover Print a
+                definition, argument, or preamble.
+
+            */
+            runaway();
             if (cur_cs == 0) {
                 startmsg = "File ended";
             } else {
                 cur_cs = 0;
                 startmsg = "Forbidden control sequence found";
             }
-            /* Print either `\.{definition}' or `\.{use}' or `\.{preamble}' or `\.{text}',
-               and insert tokens that should lead to recovery; */
-            /* The recovery procedure can't be fully understood without knowing more
-               about the \TeX\ routines that should be aborted, but we can sketch the
-               ideas here:  For a runaway definition we will insert a right brace; for a
-               runaway preamble, we will insert a special \.{\\cr} token and a right
-               brace; and for a runaway argument, we will set |long_state| to
-               |outer_call| and insert \.{\\par}. */
+            /*tex
+
+                Print either `\.{definition}' or `\.{use}' or `\.{preamble}' or
+                `\.{text}', and insert tokens that should lead to recovery. The
+                recovery procedure can't be fully understood without knowing more
+                about the \TeX\ routines that should be aborted, but we can
+                sketch the ideas here: For a runaway definition we will insert a
+                right brace; for a runaway preamble, we will insert a special
+                \.{\\cr} token and a right brace; and for a runaway argument, we
+                will set |long_state| to |outer_call| and insert \.{\\par}.
+
+            */
             p = get_avail();
             switch (scanner_status) {
-            case defining:
-                scannermsg = "definition";
-                token_info(p) = right_brace_token + '}';
-                break;
-            case matching:
-                scannermsg = "use";
-                token_info(p) = par_token;
-                long_state = outer_call_cmd;
-                break;
-            case aligning:
-                scannermsg = "preamble";
-                token_info(p) = right_brace_token + '}';
-                q = p;
-                p = get_avail();
-                token_link(p) = q;
-                token_info(p) = cs_token_flag + frozen_cr;
-                align_state = -1000000;
-                break;
-            case absorbing:
-                scannermsg = "text";
-                token_info(p) = right_brace_token + '}';
-                break;
-            default:           /* can't happen */
-                scannermsg = "unknown";
-                break;
-            }                   /*there are no other cases */
+                case defining:
+                    scannermsg = "definition";
+                    token_info(p) = right_brace_token + '}';
+                    break;
+                case matching:
+                    scannermsg = "use";
+                    token_info(p) = par_token;
+                    long_state = outer_call_cmd;
+                    break;
+                case aligning:
+                    scannermsg = "preamble";
+                    token_info(p) = right_brace_token + '}';
+                    q = p;
+                    p = get_avail();
+                    token_link(p) = q;
+                    token_info(p) = cs_token_flag + frozen_cr;
+                    align_state = -1000000;
+                    break;
+                case absorbing:
+                    scannermsg = "text";
+                    token_info(p) = right_brace_token + '}';
+                    break;
+                default:
+                    scannermsg = "unknown";
+                    break;
+            }
             begin_token_list(p, inserted);
-            snprintf(errmsg, 255, "%s while scanning %s of %s",
-                     startmsg, scannermsg, cs_to_string(warning_index));
+            snprintf(errmsg, 318, "%s while scanning %s of %s", startmsg, scannermsg, cs_to_string(warning_index));
             tex_error(errmsg, errhlp);
         } else {
             char errmsg[256];
@@ -883,9 +993,9 @@ void check_outer_validity(void)
             snprintf(errmsg, 255, "Incomplete %s; all text was ignored after line %d",
                  ss, (int) skip_line);
             free(ss);
-            /* Incomplete \\if... */
+            /*tex Incomplete |\if...| */
             cur_tok = cs_token_flag + frozen_fi;
-            /* back up one inserted token and call |error| */
+            /*tex back up one inserted token and call |error|. */
             {
                 OK_to_interrupt = false;
                 back_input();
@@ -898,61 +1008,65 @@ void check_outer_validity(void)
     }
 }
 
-@ @c
-
 #if 0
 
-/*
-    The other variant gives less clutter in tracing cache usage when profiling and for
-    some files (like the manual) also a bit of a speedup.
+/*tex
+
+    The other variant gives less clutter in tracing cache usage when profiling
+    and for some files (like the manual) also a bit of a speedup.
+
 */
 
 static boolean get_next_file(void)
 {
   SWITCH:
     if (iloc <= ilimit) {
-        /* current line not yet finished */
+        /*tex current line not yet finished */
         do_buffer_to_unichar(cur_chr, iloc);
-
       RESWITCH:
         if (detokenized_line()) {
             cur_cmd = (cur_chr == ' ' ? 10 : 12);
         } else {
             do_get_cat_code(cur_cmd, cur_chr);
         }
-        /*
+        /*tex
+
             Change state if necessary, and |goto switch| if the current
             character should be ignored, or |goto reswitch| if the current
             character changes to another;
 
-            The following 48-way switch accomplishes the scanning quickly, assuming
-            that a decent C compiler has translated the code. Note that the numeric
-            values for |mid_line|, |skip_blanks|, and |new_line| are spaced
-            apart from each other by |max_char_code+1|, so we can add a character's
-            command code to the state to get a single number that characterizes both.
+            The following 48-way switch accomplishes the scanning quickly,
+            assuming that a decent C compiler has translated the code. Note that
+            the numeric values for |mid_line|, |skip_blanks|, and |new_line| are
+            spaced apart from each other by |max_char_code+1|, so we can add a
+            character's command code to the state to get a single number that
+            characterizes both.
 
-            Remark [ls/hh]: checking performance indicated that this switch was the
-            cause of many branch prediction errors but changing it to:
+            Remark [ls/hh]: checking performance indicated that this switch was
+            the cause of many branch prediction errors but changing it to:
 
-                c = istate + cur_cmd;
-                if (c == (mid_line + letter_cmd) || c == (mid_line + other_char_cmd)) {
-                    return true;
-                } else if (c >= new_line) {
-                    switch (c) {
-                    }
-                } else if (c >= skip_blanks) {
-                    switch (c) {
-                    }
-                } else if (c >= mid_line) {
-                    switch (c) {
-                    }
-                } else {
-                    istate = mid_line;
-                    return true;
+            \starttyping
+            c = istate + cur_cmd;
+            if (c == (mid_line + letter_cmd) || c == (mid_line + other_char_cmd)) {
+                return true;
+            } else if (c >= new_line) {
+                switch (c) {
+                }
+            } else if (c >= skip_blanks) {
+                switch (c) {
+                }
+            } else if (c >= mid_line) {
+                switch (c) {
                 }
+            } else {
+                istate = mid_line;
+                return true;
+            }
+            \stoptyping
+
+            gives as many prediction errors. So, we can indeed assume that the
+            compiler does the right job, or that there is simply no other way.
 
-            gives as many prediction errors. So, we can indeed assume that the compiler
-            does the right job, or that there is simply no other way.
         */
 
         switch (istate + cur_cmd) {
@@ -961,13 +1075,13 @@ static boolean get_next_file(void)
             case new_line + ignore_cmd:
             case skip_blanks + spacer_cmd:
             case new_line + spacer_cmd:
-                /* Cases where character is ignored */
+                /*tex Cases where character is ignored. */
                 goto SWITCH;
                 break;
             case mid_line + escape_cmd:
             case new_line + escape_cmd:
             case skip_blanks + escape_cmd:
-                /* Scan a control sequence ...; */
+                /*tex Scan a control sequence. */
                 istate = (unsigned char) scan_control_sequence();
                 if (! suppress_outer_error_par && cur_cmd >= outer_call_cmd)
                     check_outer_validity();
@@ -975,7 +1089,7 @@ static boolean get_next_file(void)
             case mid_line + active_char_cmd:
             case new_line + active_char_cmd:
             case skip_blanks + active_char_cmd:
-                /* Process an active-character  */
+                /*tex Process an active-character.  */
                 cur_cs = active_to_cs(cur_chr, false);
                 cur_cmd = eq_type(cur_cs);
                 cur_chr = equiv(cur_cs);
@@ -986,7 +1100,7 @@ static boolean get_next_file(void)
             case mid_line + sup_mark_cmd:
             case new_line + sup_mark_cmd:
             case skip_blanks + sup_mark_cmd:
-                /* If this |sup_mark| starts */
+                /*tex If this |sup_mark| starts. */
                 if (process_sup_mark())
                     goto RESWITCH;
                 else
@@ -995,22 +1109,27 @@ static boolean get_next_file(void)
             case mid_line + invalid_char_cmd:
             case new_line + invalid_char_cmd:
             case skip_blanks + invalid_char_cmd:
-                /* Decry the invalid character and |goto restart|; */
+                /*tex Decry the invalid character and |goto restart|. */
                 invalid_character_error();
-                return false; /* because state may be |token_list| now */
+                /*tex Because state may be |token_list| now: */
+                return false;
                 break;
             case mid_line + spacer_cmd:
-                /* Enter |skip_blanks| state, emit a space; */
+                /*tex Enter |skip_blanks| state, emit a space. */
                 istate = skip_blanks;
                 cur_chr = ' ';
                 break;
             case mid_line + car_ret_cmd:
-                /*
-                    Finish line, emit a space. When a character of type |spacer| gets through, its
-                    character code is changed to $\.{"\ "}=040$. This means that the ASCII codes
-                    for tab and space, and for the space inserted at the end of a line, will be
-                    treated alike when macro parameters are being matched. We do this since such
-                    characters are indistinguishable on most computer terminal displays.
+                /*tex
+
+                    Finish line, emit a space. When a character of type |spacer|
+                    gets through, its character code is changed to $\.{"\
+                    "}=040$. This means that the ASCII codes for tab and space,
+                    and for the space inserted at the end of a line, will be
+                    treated alike when macro parameters are being matched. We do
+                    this since such characters are indistinguishable on most
+                    computer terminal displays.
+
                  */
                 iloc = ilimit + 1;
                 cur_cmd = spacer_cmd;
@@ -1020,12 +1139,12 @@ static boolean get_next_file(void)
             case mid_line + comment_cmd:
             case new_line + comment_cmd:
             case skip_blanks + comment_cmd:
-                /* Finish line, |goto switch|; */
+                /*tex Finish line, |goto switch|; */
                 iloc = ilimit + 1;
                 goto SWITCH;
                 break;
             case new_line + car_ret_cmd:
-                /* Finish line, emit a \.{\\par}; */
+                /*tex Finish line, emit a \.{\\par}; */
                 iloc = ilimit + 1;
                 cur_cs = par_loc;
                 cur_cmd = eq_type(cur_cs);
@@ -1036,14 +1155,14 @@ static boolean get_next_file(void)
             case skip_blanks + left_brace_cmd:
             case new_line + left_brace_cmd:
                 istate = mid_line;
-                /* fall through */
+                /*tex Fall through. */
             case mid_line + left_brace_cmd:
                 align_state++;
                 break;
             case skip_blanks + right_brace_cmd:
             case new_line + right_brace_cmd:
                 istate = mid_line;
-                /* fall through */
+                /*tex Fall through. */
             case mid_line + right_brace_cmd:
                 align_state--;
                 break;
@@ -1075,11 +1194,12 @@ static boolean get_next_file(void)
     } else {
         if (iname != 21)
             istate = new_line;
-        /*
-           Move to next line of file,
-           or |goto restart| if there is no next line,
+        /*tex
+
+           Move to next line of file, or |goto restart| if there is no next line,
            or |return| if a \.{\\read} line has finished;
-         */
+
+        */
         do {
             next_line_retval r = next_line();
             if (r == next_line_return) {
@@ -1096,13 +1216,10 @@ static boolean get_next_file(void)
 
 #else
 
-/* 10 times less Bim in callgrind */
+/*tex
+
+    This variant gives 10 times less Bim in vallgrind!
 
-/*
-    escape_cmd left_brace_cmd right_brace_cmd math_shift_cmd
-    tab_mark_cmd car_ret_cmd mac_param_cmd sup_mark_cmd
-    sub_mark_cmd ignore_cmd spacer_cmd letter_cmd
-    other_char_cmd active_char_cmd comment_cmd invalid_char_cmd
 */
 
 static boolean get_next_file(void)
@@ -1110,7 +1227,7 @@ static boolean get_next_file(void)
     int c = 0;
   SWITCH:
     if (iloc <= ilimit) {
-        /* current line not yet finished */
+        /*tex current line not yet finished */
         do_buffer_to_unichar(cur_chr, iloc);
       RESWITCH:
         if (detokenized_line()) {
@@ -1118,10 +1235,12 @@ static boolean get_next_file(void)
         } else {
             do_get_cat_code(cur_cmd, cur_chr);
         }
-        /*
-           Change state if necessary, and |goto switch| if the current
-           character should be ignored, or |goto reswitch| if the current
-           character changes to another;
+        /*tex
+
+           Change state if necessary, and |goto switch| if the current character
+           should be ignored, or |goto reswitch| if the current character changes
+           to another.
+
         */
         c = istate + cur_cmd;
         if (c == (mid_line + letter_cmd) || c == (mid_line + other_char_cmd)) {
@@ -1148,7 +1267,7 @@ static boolean get_next_file(void)
                     istate = mid_line;
                     return true;
                 case car_ret_cmd:
-                    /* Finish line, emit a \.{\\par}; */
+                    /*tex Finish line, emit a \.{\\par}. */
                     iloc = ilimit + 1;
                     cur_cs = par_loc;
                     cur_cmd = eq_type(cur_cs);
@@ -1172,7 +1291,7 @@ static boolean get_next_file(void)
                     goto SWITCH;
                     return true;
                 case spacer_cmd:
-                    /* Cases where character is ignored */
+                    /*tex Cases where character is ignored. */
                     goto SWITCH;
                 case letter_cmd:
                     istate = mid_line;
@@ -1192,8 +1311,9 @@ static boolean get_next_file(void)
                     iloc = ilimit + 1;
                     goto SWITCH;
                 case invalid_char_cmd:
+                    /*tex Because state may be |token_list| now. */
                     invalid_character_error();
-                    return false; /* because state may be |token_list| now */
+                    return false;
                 default:
                     istate = mid_line;
                     return true;
@@ -1201,7 +1321,7 @@ static boolean get_next_file(void)
         } else if (c >= skip_blanks) {
             switch (c-skip_blanks) {
                 case escape_cmd:
-                    /* Scan a control sequence ...; */
+                    /*tex Scan a control sequence. */
                     istate = (unsigned char) scan_control_sequence();
                     if (! suppress_outer_error_par && cur_cmd >= outer_call_cmd)
                         check_outer_validity();
@@ -1227,7 +1347,6 @@ static boolean get_next_file(void)
                     istate = mid_line;
                     return true;
                 case sup_mark_cmd:
-                    /* If this |sup_mark| starts */
                     if (process_sup_mark())
                         goto RESWITCH;
                     else
@@ -1255,13 +1374,14 @@ static boolean get_next_file(void)
                         check_outer_validity();
                     return true;
                 case comment_cmd:
-                    /* Finish line, |goto switch|; */
+                    /*tex Finish line, |goto switch|. */
                     iloc = ilimit + 1;
                     goto SWITCH;
                 case invalid_char_cmd:
-                    /* Decry the invalid character and |goto restart|; */
+                    /*tex Decry the invalid character and |goto restart|. */
                     invalid_character_error();
-                    return false; /* because state may be |token_list| now */
+                    /*tex Because state may be |token_list| now. */
+                    return false;
                 default:
                     istate = mid_line;
                     return true;
@@ -1284,13 +1404,17 @@ static boolean get_next_file(void)
                 case tab_mark_cmd:
                     return true;
                 case car_ret_cmd:
-                    /*
-                        Finish line, emit a space. When a character of type |spacer| gets through, its
-                        character code is changed to $\.{"\ "}=040$. This means that the ASCII codes
-                        for tab and space, and for the space inserted at the end of a line, will be
-                        treated alike when macro parameters are being matched. We do this since such
-                        characters are indistinguishable on most computer terminal displays.
-                     */
+                    /*tex
+
+                        Finish line, emit a space. When a character of type
+                        |spacer| gets through, its character code is changed to
+                        $\.{"\ "}=040$. This means that the ASCII codes for tab
+                        and space, and for the space inserted at the end of a
+                        line, will be treated alike when macro parameters are
+                        being matched. We do this since such characters are
+                        indistinguishable on most computer terminal displays.
+
+                    */
                     iloc = ilimit + 1;
                     cur_cmd = spacer_cmd;
                     cur_chr = ' ';
@@ -1308,7 +1432,7 @@ static boolean get_next_file(void)
                 case ignore_cmd:
                     goto SWITCH;
                 case spacer_cmd:
-                    /* Enter |skip_blanks| state, emit a space; */
+                    /*tex Enter |skip_blanks| state, emit a space. */
                     istate = skip_blanks;
                     cur_chr = ' ';
                     return true;
@@ -1330,8 +1454,9 @@ static boolean get_next_file(void)
                     iloc = ilimit + 1;
                     goto SWITCH;
                 case invalid_char_cmd:
+                    /*tex Because state may be |token_list| now. */
                     invalid_character_error();
-                    return false; /* because state may be |token_list| now */
+                    return false;
                 default:
                     istate = mid_line;
                     return true;
@@ -1344,9 +1469,11 @@ static boolean get_next_file(void)
         if (iname != 21) {
             istate = new_line;
         }
-        /*
-           Move to next line of file, or |goto restart| if there is no next line,
-           or |return| if a \.{\\read} line has finished;
+        /*tex
+
+            Move to next line of file, or |goto restart| if there is no next
+            line, or |return| if a \.{\\read} line has finished;
+
         */
         do {
             next_line_retval r = next_line();
@@ -1364,14 +1491,18 @@ static boolean get_next_file(void)
 
 #endif
 
-@ Notice that a code like \.{\^\^8} becomes \.x if not followed by a hex digit.
-We only support a limited set:
+/*tex
 
-^^^^^^XXXXXX
-^^^^XXXXXX
-^^XX ^^<char>
+    Notice that a code like \.{\^\^8} becomes \.x if not followed by a hex digit.
+    We only support a limited set:
 
-@c
+    \starttyping
+    ^^^^^^XXXXXX
+    ^^^^XXXXXX
+    ^^XX ^^<char>
+    \stoptyping
+
+*/
 
 #define is_hex(a) ((a>='0'&&a<='9')||(a>='a'&&a<='f'))
 
@@ -1412,7 +1543,7 @@ static boolean process_sup_mark(void)
         if (iloc < ilimit) {
             if ((cur_chr == buffer[iloc + 1]) && (cur_chr == buffer[iloc + 2])) {
                 if ((cur_chr == buffer[iloc + 3]) && (cur_chr == buffer[iloc + 4])) {
-                    /* ^^^^^^XXXXXX */
+                    /*tex |^^^^^^XXXXXX| */
                     if ((iloc + 10) <= ilimit) {
                         int c1 = buffer[iloc +  5];
                         int c2 = buffer[iloc +  6];
@@ -1432,7 +1563,7 @@ static boolean process_sup_mark(void)
                         tex_error("^^^^^^ needs six hex digits, end of input", NULL);
                     }
                 } else {
-                    /* ^^^^XXXX */
+                    /*tex |^^^^XXXX| */
                     if ((iloc + 6) <= ilimit) {
                         int c1 = buffer[iloc + 3];
                         int c2 = buffer[iloc + 4];
@@ -1450,7 +1581,7 @@ static boolean process_sup_mark(void)
                     }
                 }
             } else {
-                /* ^^XX */
+                /*tex |^^XX| */
                 if ((iloc + 2) <= ilimit) {
                     int c1 = buffer[iloc + 1];
                     int c2 = buffer[iloc + 2];
@@ -1460,10 +1591,10 @@ static boolean process_sup_mark(void)
                         return true;
                     }
                 }
-                /* go on, no error, good old tex */
+                /*tex Go on, no error, good old \TEX . */
             }
         }
-        /* the rest */
+        /*tex The rest. */
         {
             int c1 = buffer[iloc + 1];
             if (c1 < 0200) {
@@ -1484,37 +1615,43 @@ static boolean process_sup_mark(void)
     return false;
 }
 
-@ Control sequence names are scanned only when they appear in some line of a
-file; once they have been scanned the first time, their |eqtb| location serves as
-a unique identification, so \TeX\ doesn't need to refer to the original name any
-more except when it prints the equivalent in symbolic form.
+/*tex
+
+    Control sequence names are scanned only when they appear in some line of a
+    file; once they have been scanned the first time, their |eqtb| location
+    serves as a unique identification, so \TeX\ doesn't need to refer to the
+    original name any more except when it prints the equivalent in symbolic form.
 
-The program that scans a control sequence has been written carefully in order to
-avoid the blowups that might otherwise occur if a malicious user tried something
-like `\.{\\catcode\'15=0}'. The algorithm might look at |buffer[ilimit+1]|, but
-it never looks at |buffer[ilimit+2]|.
+    The program that scans a control sequence has been written carefully in order
+    to avoid the blowups that might otherwise occur if a malicious user tried
+    something like `\.{\\catcode\'15=0}'. The algorithm might look at
+    |buffer[ilimit+1]|, but it never looks at |buffer[ilimit+2]|.
 
-If expanded characters like `\.{\^\^A}' or `\.{\^\^df}' appear in or just
-following a control sequence name, they are converted to single characters in the
-buffer and the process is repeated, slowly but surely.
+    If expanded characters like `\.{\^\^A}' or `\.{\^\^df}' appear in or just
+    following a control sequence name, they are converted to single characters in
+    the buffer and the process is repeated, slowly but surely.
+
+*/
 
-@c
 static boolean check_expanded_code(int *kk);    /* below */
 
 static int scan_control_sequence(void)
 {
     int retval = mid_line;
     if (iloc > ilimit) {
-        cur_cs = null_cs;       /* |state| is irrelevant in this case */
+        /*tex |state| is irrelevant in this case. */
+        cur_cs = null_cs;
     } else {
-        register int cat;       /* |cat_code(cur_chr)|, usually */
+        /*tex |cat_code(cur_chr)|, usually: */
+        register int cat;
         while (1) {
             int k = iloc;
             do_buffer_to_unichar(cur_chr, k);
             do_get_cat_code(cat, cur_chr);
             if (cat != letter_cmd || k > ilimit) {
                 retval = (cat == spacer_cmd ? skip_blanks : mid_line);
-                if (cat == sup_mark_cmd && check_expanded_code(&k))     /* If an expanded...; */
+                /*tex If an expanded \unknown */
+                if (cat == sup_mark_cmd && check_expanded_code(&k))
                     continue;
             } else {
                 retval = skip_blanks;
@@ -1522,20 +1659,11 @@ static int scan_control_sequence(void)
                     do_buffer_to_unichar(cur_chr, k);
                     do_get_cat_code(cat, cur_chr);
                 } while (cat == letter_cmd && k <= ilimit);
-
-                if (cat == sup_mark_cmd && check_expanded_code(&k))     /* If an expanded...; */
+                /*tex If an expanded \unknown */
+                if (cat == sup_mark_cmd && check_expanded_code(&k))
                     continue;
                 if (cat != letter_cmd) {
-                    /* backtrack one character which can be utf */
-                    /*
-                    decr(k);
-                    if (cur_chr > 0xFFFF)
-                        decr(k);
-                    if (cur_chr > 0x7FF)
-                        decr(k);
-                    if (cur_chr > 0x7F)
-                        decr(k);
-                    */
+                    /*tex Backtrack one character which can be \UTF. */
                     if (cur_chr <= 0x7F) {
                         k -= 1; /* in most cases */
                     } else if (cur_chr > 0xFFFF) {
@@ -1545,7 +1673,7 @@ static int scan_control_sequence(void)
                     } else /* if (cur_chr > 0x7F) */ {
                         k -= 2;
                     }
-                    /* now |k| points to first nonletter */
+                    /*tex Now |k| points to first nonletter. */
                 }
             }
             cur_cs = id_lookup(iloc, k - iloc);
@@ -1558,14 +1686,17 @@ static int scan_control_sequence(void)
     return retval;
 }
 
-@ Whenever we reach the following piece of code, we will have
-|cur_chr=buffer[k-1]| and |k<=ilimit+1| and
-|cat=get_cat_code(cat_code_table,cur_chr)|. If an expanded code like \.{\^\^A} or
-\.{\^\^df} appears in |buffer[(k-1)..(k+1)]| or |buffer[(k-1)..(k+2)]|, we will
-store the corresponding code in |buffer[k-1]| and shift the rest of the buffer
-left two or three places.
+/*tex
+
+    Whenever we reach the following piece of code, we will have
+    |cur_chr=buffer[k-1]| and |k<=ilimit+1| and
+    |cat=get_cat_code(cat_code_table,cur_chr)|. If an expanded code like
+    \.{\^\^A} or \.{\^\^df} appears in |buffer[(k-1)..(k+1)]| or
+    |buffer[(k-1)..(k+2)]|, we will store the corresponding code in |buffer[k-1]|
+    and shift the rest of the buffer left two or three places.
+
+*/
 
-@c
 static boolean check_expanded_code(int *kk)
 {
     int l;
@@ -1666,26 +1797,38 @@ static boolean check_expanded_code(int *kk)
     return false;
 }
 
-@ All of the easy branches of |get_next| have now been taken care of. There is
-one more branch.
+/*tex
 
-@c static next_line_retval next_line(void)
+    All of the easy branches of |get_next| have now been taken care of. There is
+    one more branch.
+
+*/
+
+static next_line_retval next_line(void)
 {
-    boolean inhibit_eol = false; /* a way to end a pseudo file without trailing space */
+    /*tex A way to end a pseudo file without trailing space: */
+    boolean inhibit_eol = false;
     if (iname > 17) {
-        /* Read next line of file into |buffer|, or |goto restart| if the file has ended */
+        /*tex
+
+            Read next line of file into |buffer|, or |goto restart| if the file
+            has ended.
+
+        */
         incr(line);
         first = istart;
         if (!force_eof) {
             if (iname <= 20) {
-                if (pseudo_input()) {   /* not end of file */
-                    firm_up_the_line(); /* this sets |ilimit| */
+                if (pseudo_input()) {
+                    /*tex Not end of file; set |ilimit|. */
+                    firm_up_the_line();
                     line_catcode_table = DEFAULT_CAT_TABLE;
                     if ((iname == 19) && (pseudo_lines(pseudo_files) == null))
                         inhibit_eol = true;
                 } else if ((every_eof_par != null) && !eof_seen[iindex]) {
                     ilimit = first - 1;
-                    eof_seen[iindex] = true; /* fake one empty line */
+                    /*tex Fake one empty line. */
+                    eof_seen[iindex] = true;
                     if (iname != 19)
                         begin_token_list(every_eof_par, every_eof_text);
                     return next_line_restart;
@@ -1694,30 +1837,58 @@ one more branch.
                 }
             } else {
                 if (iname == 21) {
-                    if (luacstring_input()) { /* not end of strings  */
-                        firm_up_the_line();
-                        line_catcode_table = (short) luacstring_cattable();
-                        line_partial = (signed char) luacstring_partial();
-                        if (luacstring_final_line() || line_partial
-                            || line_catcode_table == NO_CAT_TABLE)
-                            inhibit_eol = true;
-                        if (!line_partial)
-                            istate = new_line;
-                    } else {
-                        force_eof = true;
+                    halfword n = null;
+                    int t = luacstring_input(&n);
+                    switch (t) {
+                        case 0:
+                            force_eof = true;
+                            break;
+                        case 1:
+                            /*tex string */
+                            firm_up_the_line();
+                            line_catcode_table = (short) luacstring_cattable();
+                            line_partial = (signed char) luacstring_partial();
+                            if (luacstring_final_line() || line_partial || line_catcode_table == NO_CAT_TABLE)
+                                inhibit_eol = true;
+                            if (!line_partial)
+                                istate = new_line;
+                            break;
+                        case 2:
+                            /*tex token */
+                            cur_tok = n;
+                            back_input();
+                            /*tex Needs checking. */
+                            return next_line_restart;
+                            break;
+                        case 3:
+                            /*tex node */
+                            if (n < biggest_char) {
+                                /*tex |0x10FFFF == 1114111| */
+                                cur_tok = token_val(node_cmd, n);
+                                back_input();
+                                /*tex Needs checking. */
+                                return next_line_restart;
+                            } else {
+                                normal_warning("nodes","unable to store reference from lua in tex");
+                                force_eof = true;
+                            }
+                            break;
+                        default:
+                            force_eof = true;
+                            break;
                     }
+                } else if (lua_input_ln(cur_file, 0, true)) {
+                    /*tex Not end of file, set |ilimit|. */
+                    firm_up_the_line();
+                    line_catcode_table = DEFAULT_CAT_TABLE;
+                } else if ((every_eof_par != null) && (!eof_seen[iindex])) {
+                    ilimit = first - 1;
+                    /* tex Fake one empty line. */
+                    eof_seen[iindex] = true;
+                    begin_token_list(every_eof_par, every_eof_text);
+                    return next_line_restart;
                 } else {
-                    if (lua_input_ln(cur_file, 0, true)) { /* not end of file */
-                        firm_up_the_line(); /* this sets |ilimit| */
-                        line_catcode_table = DEFAULT_CAT_TABLE;
-                    } else if ((every_eof_par != null) && (!eof_seen[iindex])) {
-                        ilimit = first - 1;
-                        eof_seen[iindex] = true; /* fake one empty line */
-                        begin_token_list(every_eof_par, every_eof_text);
-                        return next_line_restart;
-                    } else {
-                        force_eof = true;
-                    }
+                    force_eof = true;
                 }
             }
         }
@@ -1725,7 +1896,7 @@ one more branch.
             if (tracing_nesting_par > 0)
                 if ((grp_stack[in_open] != cur_boundary) || (if_stack[in_open] != cond_ptr))
                     if (!((iname == 19) || (iname == 21))) {
-                        /* give warning for some unfinished groups and/or conditionals */
+                        /*tex Give warning for some unfinished groups and/or conditionals. */
                         file_warning();
                     }
             if ((iname > 21) || (iname == 20)) {
@@ -1733,7 +1904,7 @@ one more branch.
                 decr(open_parens);
             }
             force_eof = false;
-            /* lua input or \.{\\scantextokens} */
+            /*tex \LUA\ input or \.{\\scantextokens} */
             if (iname == 21 || iname == 19) {
                 end_file_reading();
             } else {
@@ -1748,18 +1919,20 @@ one more branch.
         else
             buffer[ilimit] = (packed_ASCII_code) end_line_char_par;
         first = ilimit + 1;
-        iloc = istart; /* ready to read */
+        iloc = istart;
+        /*tex We're ready to read. */
     } else {
         if (!terminal_input) {
-            /* \.{\\read} line has ended */
+            /*tex \.{\\read} line has ended */
             cur_cmd = 0;
             cur_chr = 0;
-            return next_line_return;    /* OUTER */
+            return next_line_return;
         }
         if (input_ptr > 0) {
-            /* text was inserted during error recovery */
+            /*tex Text was inserted during error recovery. */
             end_file_reading();
-            return next_line_restart; /* resume previous level */
+            /*tex Resume previous level. */
+            return next_line_restart;
         }
         if (selector < log_only)
             open_log_file();
@@ -1767,12 +1940,13 @@ one more branch.
             if (end_line_char_inactive)
                 ilimit++;
             if (ilimit == istart) {
-                /* previous line was empty */
+                /*tex Previous line was empty. */
                 tprint_nl("(Please type a command or say `\\end')");
             }
             print_ln();
             first = istart;
-            prompt_input("*"); /* input on-line into |buffer| */
+            /*tex Input on-line into |buffer| */
+            prompt_input("*");
             ilimit = last;
             if (end_line_char_inactive)
                 ilimit--;
@@ -1781,9 +1955,11 @@ one more branch.
             first = ilimit + 1;
             iloc = istart;
         } else {
-            /*
+            /*tex
+
                 Nonstop mode, which is intended for overnight batch processing,
                 never waits for on-line input.
+
             */
             fatal_error("*** (job aborted, no legal \\end found)");
         }
@@ -1791,24 +1967,31 @@ one more branch.
     return next_line_ok;
 }
 
-@ Let's consider now what happens when |get_next| is looking at a token list.
+/*tex
+
+    Let's consider now what happens when |get_next| is looking at a token list.
+
+*/
 
-@c
 static boolean get_next_tokenlist(void)
 {
     register halfword t = token_info(iloc);
-    iloc = token_link(iloc); /* move to next */
+    /*tex Move to next. */
+    iloc = token_link(iloc);
     if (t >= cs_token_flag) {
-        /* a control sequence token */
+        /*tex A control sequence token */
         cur_cs = t - cs_token_flag;
         cur_cmd = eq_type(cur_cs);
         if (cur_cmd >= outer_call_cmd) {
             if (cur_cmd == dont_expand_cmd) {
-                /*
-                    Get the next token, suppressing expansion. The present point in the program
-                    is reached only when the |expand| routine has inserted a special marker into
-                    the input. In this special case, |token_info(iloc)| is known to be a control
-                    sequence token, and |token_link(iloc)=null|.
+                /*tex
+
+                    Get the next token, suppressing expansion. The present point
+                    in the program is reached only when the |expand| routine has
+                    inserted a special marker into the input. In this special
+                    case, |token_info(iloc)| is known to be a control sequence
+                    token, and |token_link(iloc)=null|.
+
                 */
                 cur_cs = token_info(iloc) - cs_token_flag;
                 iloc = null;
@@ -1834,7 +2017,7 @@ static boolean get_next_tokenlist(void)
                 align_state--;
                 break;
             case out_param_cmd:
-                /* Insert macro parameter and |goto restart|; */
+                /*tex Insert macro parameter and |goto restart|. */
                 begin_token_list(param_stack[param_start + cur_chr - 1], parameter);
                 return false;
                 break;
@@ -1843,61 +2026,73 @@ static boolean get_next_tokenlist(void)
     return true;
 }
 
-@ Now we're ready to take the plunge into |get_next| itself. Parts of this
-routine are executed more often than any other instructions of \TeX.
-@^mastication@>@^inner loop@>
+/*tex
+
+    Now we're ready to take the plunge into |get_next| itself. Parts of this
+    routine are executed more often than any other instructions of \TeX.
 
-@ sets |cur_cmd|, |cur_chr|, |cur_cs| to next token
+    This sets |cur_cmd|, |cur_chr|, |cur_cs| to next token:
+
+*/
 
-@c
 void get_next(void)
 {
   RESTART:
     cur_cs = 0;
     if (istate != token_list) {
-        /* Input from external file, |goto restart| if no input found */
+        /*tex Input from external file, |goto restart| if no input found. */
         if (!get_next_file())
             goto RESTART;
     } else {
         if (iloc == null) {
             end_token_list();
-            goto RESTART;       /* list exhausted, resume previous level */
+            /*tex List exhausted, resume previous level. */
+            goto RESTART;
         } else if (!get_next_tokenlist()) {
-            goto RESTART;       /* parameter needs to be expanded */
+            /*tex Parameter needs to be expanded. */
+            goto RESTART;
         }
     }
-    /* If an alignment entry has just ended, take appropriate action */
+    /*tex If an alignment entry has just ended, take appropriate action. */
     if ((cur_cmd == tab_mark_cmd || cur_cmd == car_ret_cmd) && align_state == 0) {
         insert_vj_template();
         goto RESTART;
     }
 }
 
-@ Since |get_next| is used so frequently in \TeX, it is convenient to define
-three related procedures that do a little more:
-
-\yskip\hang|get_token| not only sets |cur_cmd| and |cur_chr|, it also sets
-|cur_tok|, a packed halfword version of the current token.
-
-\yskip\hang|get_x_token|, meaning ``get an expanded token,'' is like |get_token|,
-but if the current token turns out to be a user-defined control sequence (i.e., a
-macro call), or a conditional, or something like \.{\\topmark} or
-\.{\\expandafter} or \.{\\csname}, it is eliminated from the input by beginning
-the expansion of the macro or the evaluation of the conditional.
-
-\yskip\hang|x_token| is like |get_x_token| except that it assumes that |get_next|
-has already been called.
-
-\yskip\noindent In fact, these three procedures account for almost every use of
-|get_next|.
+/*tex
+
+    Since |get_next| is used so frequently in \TeX, it is convenient to define
+    three related procedures that do a little more:
+
+    \startitemize
+        \startitem
+            |get_token| not only sets |cur_cmd| and |cur_chr|, it also sets
+            |cur_tok|, a packed halfword version of the current token.
+        \stopitem
+        \startitem
+            |get_x_token|, meaning ``get an expanded token,'' is like
+            |get_token|, but if the current token turns out to be a user-defined
+            control sequence (i.e., a macro call), or a conditional, or something
+            like \.{\\topmark} or \.{\\expandafter} or \.{\\csname}, it is
+            eliminated from the input by beginning the expansion of the macro or
+            the evaluation of the conditional.
+        \stopitem
+        \startitem
+            |x_token| is like |get_x_token| except that it assumes that
+            |get_next| has already been called.
+        \stopitem
+    \stopitemize
+
+    In fact, these three procedures account for almost every use of |get_next|.
+    No new control sequences will be defined except during a call of |get_token|,
+    or when \.{\\csname} compresses a token list, because
+    |no_new_control_sequence| is always |true| at other times.
+
+    This sets |cur_cmd|, |cur_chr|, |cur_tok|:
 
-No new control sequences will be defined except during a call of |get_token|, or
-when \.{\\csname} compresses a token list, because |no_new_control_sequence| is
-always |true| at other times.
-
-@ sets |cur_cmd|, |cur_chr|, |cur_tok|
+*/
 
-@c
 void get_token(void)
 {
     no_new_control_sequence = false;
@@ -1909,14 +2104,16 @@ void get_token(void)
         cur_tok = cs_token_flag + cur_cs;
 }
 
-@ changes the string |s| to a token list
+/*tex This changes the string |s| to a token list. */
 
-@c
 halfword string_to_toks(const char *ss)
 {
-    halfword p; /* tail of the token list */
-    halfword q; /* new node being added to the token list via |store_new_token| */
-    halfword t; /* token being appended */
+    /*tex tail of the token list */
+    halfword p;
+    /*tex new node being added to the token list via |store_new_token| */
+    halfword q;
+    /*tex token being appended */
+    halfword t;
     const char *s = ss;
     const char *se = ss + strlen(s);
     p = temp_token_head;
@@ -1933,29 +2130,37 @@ halfword string_to_toks(const char *ss)
     return token_link(temp_token_head);
 }
 
-@ The token lists for macros and for other things like \.{\\mark} and
-\.{\\output} and \.{\\write} are produced by a procedure called |scan_toks|.
+/*tex
 
-Before we get into the details of |scan_toks|, let's consider a much simpler
-task, that of converting the current string into a token list. The |str_toks|
-function does this; it classifies spaces as type |spacer| and everything else as
-type |other_char|.
+    The token lists for macros and for other things like \.{\\mark} and
+    \.{\\output} and \.{\\write} are produced by a procedure called |scan_toks|.
 
-The token list created by |str_toks| begins at |link(temp_token_head)| and ends
-at the value |p| that is returned. (If |p=temp_token_head|, the list is empty.)
+    Before we get into the details of |scan_toks|, let's consider a much simpler
+    task, that of converting the current string into a token list. The |str_toks|
+    function does this; it classifies spaces as type |spacer| and everything else
+    as type |other_char|.
 
-|lua_str_toks| is almost identical, but it also escapes the three symbols that
-|lua| considers special while scanning a literal string
+    The token list created by |str_toks| begins at |link(temp_token_head)| and
+    ends at the value |p| that is returned. (If |p=temp_token_head|, the list is
+    empty.)
 
-@ changes the string |str_pool[b..pool_ptr]| to a token list
+    |lua_str_toks| is almost identical, but it also escapes the three symbols
+    that |lua| considers special while scanning a literal string.
+
+    This changes the string |str_pool[b..pool_ptr]| to a token list:
+
+*/
 
-@c
 halfword lua_str_toks(lstring b)
 {
-    halfword p;       /* tail of the token list */
-    halfword q;       /* new node being added to the token list via |store_new_token| */
-    halfword t;       /* token being appended */
-    unsigned char *k; /* index into string */
+    /*tex tail of the token list */
+    halfword p;
+    /*tex new node being added to the token list via |store_new_token| */
+    halfword q;
+    /*tex token being appended */
+    halfword t;
+    /*tex index into string */
+    unsigned char *k;
     p = temp_token_head;
     set_token_link(p, null);
     k = (unsigned char *) b.s;
@@ -1978,18 +2183,25 @@ halfword lua_str_toks(lstring b)
     return p;
 }
 
-@ Incidentally, the main reason for wanting |str_toks| is the function
-|the_toks|, which has similar input/output characteristics.
+/*tex
+
+    Incidentally, the main reason for wanting |str_toks| is the function
+    |the_toks|, which has similar input/output characteristics.
 
-@ changes the string |str_pool[b..pool_ptr]| to a token list
+    This changes the string |str_pool[b..pool_ptr]| to a token list:
+
+*/
 
-@c
 halfword str_toks(lstring s)
 {
-    halfword p;           /* tail of the token list */
-    halfword q;           /* new node being added to the token list via |store_new_token| */
-    halfword t;           /* token being appended */
-    unsigned char *k, *l; /* index into string */
+    /*tex tail of the token list */
+    halfword p;
+    /*tex new node being added to the token list via |store_new_token| */
+    halfword q;
+    /*tex token being appended */
+    halfword t;
+    /*tex index into string */
+    unsigned char *k, *l;
     p = temp_token_head;
     set_token_link(p, null);
     k = s.s;
@@ -2006,18 +2218,25 @@ halfword str_toks(lstring s)
     return p;
 }
 
-/*
-    hh: most of the converter is similar to the one i made for macro so at some point i
-    can make a helper; also todo: there is no need to go through the pool
+/*tex
+
+    Most of the converter is similar to the one i made for macro so at some point
+    I can make a helper; also todo: there is no need to go through the pool.
 
 */
 
+/*tex Change the string |str_pool[b..pool_ptr]| to a token list. */
+
 halfword str_scan_toks(int ct, lstring s)
-{                         /* changes the string |str_pool[b..pool_ptr]| to a token list */
-    halfword p;           /* tail of the token list */
-    halfword q;           /* new node being added to the token list via |store_new_token| */
-    halfword t;           /* token being appended */
-    unsigned char *k, *l; /* index into string */
+{
+    /*tex tail of the token list */
+    halfword p;
+    /*tex new node being added to the token list via |store_new_token| */
+    halfword q;
+    /*tex token being appended */
+    halfword t;
+    /*tex index into string */
+    unsigned char *k, *l;
     int cc;
     p = temp_token_head;
     set_token_link(p, null);
@@ -2028,7 +2247,7 @@ halfword str_scan_toks(int ct, lstring s)
         k += utf8_size(t);
         cc = get_cat_code(ct,t);
             if (cc == 0) {
-                /* we have a potential control sequence so we check for it */
+                /*tex We have a potential control sequence so we check for it. */
                 int _lname = 0 ;
                 int _s = 0 ;
                 int _c = 0 ;
@@ -2042,7 +2261,7 @@ halfword str_scan_toks(int ct, lstring s)
                         k += _s ;
                         _lname = _lname + _s ;
                     } else if (_c == 10) {
-                        /* we ignore a trailing space like normal scanning does */
+                        /*tex We ignore a trailing space like normal scanning does. */
                         k += _s ;
                         break ;
                     } else {
@@ -2050,7 +2269,7 @@ halfword str_scan_toks(int ct, lstring s)
                     }
                 }
                 if (_s > 0) {
-                    /* we have a potential \cs */
+                    /*tex We have a potential |\cs|. */
                     _cs = string_lookup((const char *) _name, _lname);
                     if (_cs == undefined_control_sequence) {
                         /* let's play safe and backtrack */
@@ -2060,15 +2279,24 @@ halfword str_scan_toks(int ct, lstring s)
                         t = cs_token_flag + _cs;
                     }
                 } else {
-                    /* just a character with some meaning, so \unknown becomes effectively */
-                    /* \\unknown assuming that \\ has some useful meaning of course        */
+                    /*tex
+
+                        Just a character with some meaning, so |\unknown| becomes
+                        effectively |\unknown| assuming that |\\| has some useful
+                        meaning of course.
+
+                    */
                     t = cc * (1<<21) + t ;
                     k = _name ;
                 }
 
             } else {
-                /* whatever token, so for instance $x^2$ just works given a tex */
-                /* catcode regime */
+                /*tex
+
+                    Whatever token, so for instance $x^2$ just works given a \TEX\
+                    catcode regime.
+
+                */
                 t = cc * (1<<21) + t ;
             }
             fast_store_new_token(t);
@@ -2077,171 +2305,227 @@ halfword str_scan_toks(int ct, lstring s)
     return p;
 }
 
-@ Here's part of the |expand| subroutine that we are now ready to complete:
+/*tex
+
+    Here's part of the |expand| subroutine that we are now ready to complete:
+
+*/
 
-@c
 void ins_the_toks(void)
 {
     (void) the_toks();
     ins_list(token_link(temp_token_head));
 }
 
-#define set_toks_register(n,t,g) { \
+#define set_toks_register(n,t,g) do { \
     int a = (g>0) ? 4 : 0; \
     halfword ref = get_avail();  \
     set_token_ref_count(ref, 0); \
     set_token_link(ref, token_link(t)); \
     define(n + toks_base, call_cmd, ref); \
-}
+} while (0)
+
+#define append_copied_toks_list(s,t) do { \
+    halfword p; \
+    halfword q; \
+    p = temp_token_head; \
+    set_token_link(p, null); \
+    while (s != null) { \
+        fast_store_new_token(token_info(s)); \
+        s = token_link(s); \
+    } \
+    while (t != null) { \
+        fast_store_new_token(token_info(t)); \
+        t = token_link(t); \
+    } \
+   } while (0)
+
+
+/*tex
+
+   \starttabulate[|T||T||]
+   \NC 0 \NC \type {toksapp}   \NC 1 \NC \type {etoksapp} \NC \NR
+   \NC 2 \NC \type {tokspre}   \NC 3 \NC \type {etokspre} \NC \NR
+   \NC 4 \NC \type {gtoksapp}  \NC 5 \NC \type {xtoksapp} \NC \NR
+   \NC 6 \NC \type {gtokspre}  \NC 7 \NC \type {xtokspre} \NC \NR
+   \stoptabulate
+
+*/
 
 void combine_the_toks(int how)
 {
-    halfword nt;
+    halfword source = null;
+    halfword target = null;
+    halfword append = (how == 0) || (how == 1) || (how == 4) || (how == 5);
+    halfword expand = odd(how);
+    halfword global = how > 3;
+    halfword nt, ns, s, t, p, q, h;
     get_x_token();
-    /* target */
+    /*tex The target. */
     if (cur_cmd == assign_toks_cmd) {
+        /*tex Check range. */
         nt = equiv(cur_cs) - toks_base;
-        /* check range */
     } else {
         back_input();
-        scan_int();
+        scan_register_num();
         nt = cur_val;
     }
-    /* source */
+    /*tex The source. */
     do {
         get_x_token();
     } while (cur_cmd == spacer_cmd);
     if (cur_cmd == left_brace_cmd) {
-        halfword x, source;
         back_input();
-        x = scan_toks(false,how > 1); /* expanded or not */
+        scan_toks(false,expand);
         source = def_ref;
-        /* action */
+        /*tex The action. */
         if (source != null) {
-            halfword target = toks(nt);
+            target = toks(nt);
             if (target == null) {
-                set_toks_register(nt,source,0);
+                set_toks_register(nt,source,global);
             } else {
-                halfword s = token_link(source);
+                s = token_link(source);
                 if (s != null) {
-                    halfword t = token_link(target);
+                    t = token_link(target);
                     if (t == null) {
-                        /* can this happen ? */
+                        /*tex Can this happen? */
                         set_token_link(target, s);
-                    } else if (odd(how)) {
-                        /* prepend */
-                        if (cur_level != eq_level_field(eqtb[toks_base+nt])) {
-                            halfword p = temp_token_head;
-                            halfword q;
-                            set_token_link(p, s); /* s = head, x = tail */
-                            p = x;
-                            while (t != null) {
-                                fast_store_new_token(token_info(t));
-                                t = token_link(t);
+                    } else if (append) {
+                        /*tex Append. */
+                        if (token_ref_count(target) == 0) {
+                            p = t;
+                            while (token_link(p) != null) {
+                                p = token_link(p);
+                            }
+                            while (s != null) {
+                                fast_store_new_token(token_info(s));
+                                s = token_link(s);
                             }
-                            set_toks_register(nt,temp_token_head,0);
                         } else {
-                            set_token_link(x,t);
-                            set_token_link(target,s);
+                            token_ref_count(target)--;
+                            append_copied_toks_list(t,s);
+                            set_toks_register(nt,temp_token_head,global);
                         }
                     } else {
-                        /* append */
-                        if (cur_level != eq_level_field(eqtb[toks_base+nt])) {
-                            halfword p = temp_token_head;
-                            halfword q;
-                            set_token_link(p, null);
-                            while (t != null) {
-                                fast_store_new_token(token_info(t));
-                                t = token_link(t);
+                        /* prepend */
+                        if (token_ref_count(target) == 0) {
+                            h = null;
+                            p = null ;
+                            while (s != null) {
+                                fast_store_new_token(token_info(s));
+                                if (h == null) {
+                                    h = p;
+                                }
+                                s = token_link(s);
                             }
-                            set_token_link(p,s);
-                            set_toks_register(nt,temp_token_head,0);
+                            set_token_link(p,t);
+                            set_token_link(target,h);
                         } else {
-                            while (token_link(t) != null) {
-                                t = token_link(t);
-                            }
-                            set_token_link(t,s);
+                            token_ref_count(target)--;
+                            append_copied_toks_list(s,t);
+                            set_toks_register(nt,temp_token_head,global);
                         }
                     }
                 }
             }
         }
     } else {
-        halfword source, ns;
         if (cur_cmd == assign_toks_cmd) {
             ns = equiv(cur_cs) - toks_base;
-            /* check range */
+            /*tex Check range. */
         } else {
-            back_input();
-            scan_int();
+            scan_register_num();
             ns = cur_val;
         }
-        /* action */
+        /*tex The action. */
         source = toks(ns);
         if (source != null) {
-            halfword target = toks(nt);
+            target = toks(nt);
             if (target == null) {
+                /*tex The assign. */
+                token_ref_count(source)++;
                 equiv(toks_base+nt) = source;
-                equiv(toks_base+ns) = null;
+                return;
+            }
+            s = token_link(source);
+            t = token_link(target);
+            if (append) {
+                /*tex Append. */
+                if (token_ref_count(target) == 0) {
+                    p = t;
+                    while (token_link(p) != null) {
+                        p = token_link(p);
+                    }
+                    while (s != null) {
+                        fast_store_new_token(token_info(s));
+                        s = token_link(s);
+                    }
+                } else {
+                    token_ref_count(target)--;
+                    append_copied_toks_list(t,s);
+                    set_toks_register(nt,temp_token_head,global);
+                }
             } else {
-                halfword s = token_link(source);
-                if (s != null) {
-                    halfword t = token_link(target);
-                    if (t == null) {
-                        set_token_link(target, s);
-                    } else if (odd(how)) {
-                        /* prepend */
-                        halfword x = s;
-                        while (token_link(x) != null) {
-                            x = token_link(x);
-                        }
-                        set_token_link(x,t);
-                        set_token_link(target,s);
-                    } else {
-                        /* append */
-                        while (token_link(t) != null) {
-                            t = token_link(t);
+                /*tex Prepend. */
+                if (token_ref_count(target) == 0) {
+                    h = null;
+                    p = null;
+                    while (s != null) {
+                        fast_store_new_token(token_info(s));
+                        if (h == null) {
+                            h = p;
                         }
-                        set_token_link(t,s);
+                        s = token_link(s);
                     }
-                     equiv(toks_base+ns) = null;
+                    set_token_link(p,t);
+                    set_token_link(target,h);
+                } else {
+                    token_ref_count(target)--;
+                    append_copied_toks_list(s,t);
+                    set_toks_register(nt,temp_token_head,global);
                 }
             }
         }
     }
 }
 
-@ This routine, used in the next one, prints the job name, possibly modified by
-the |process_jobname| callback.
+/*tex
+
+    This routine, used in the next one, prints the job name, possibly modified by
+    the |process_jobname| callback.
+
+*/
 
-@c
 static void print_job_name(void)
 {
-   if (job_name) {
-      char *s, *ss; /* C strings for jobname before and after processing */
-      int callback_id, lua_retval;
-      s = (char*)str_string(job_name);
-      callback_id = callback_defined(process_jobname_callback);
-      if (callback_id > 0) {
-        lua_retval = run_callback(callback_id, "S->S", s, &ss);
-        if ((lua_retval == true) && (ss != NULL))
-            s = ss;
-      }
-      tprint(s);
-   } else {
-      print(job_name);
-   }
+    if (job_name) {
+        /*tex C strings for jobname before and after processing. */
+          char *s, *ss;
+          int callback_id, lua_retval;
+          s = (char*)str_string(job_name);
+          callback_id = callback_defined(process_jobname_callback);
+          if (callback_id > 0) {
+            lua_retval = run_callback(callback_id, "S->S", s, &ss);
+            if ((lua_retval == true) && (ss != NULL))
+                s = ss;
+        }
+        tprint(s);
+    } else {
+        print(job_name);
+    }
 }
 
-@ Here is a routine that print the result of a convert command, using the
-argument |i|. It returns |false | if it does not know to print the code |c|. The
-function exists because lua code and tex code can both call it to convert
-something.
+/*tex
 
-@ Parse optional lua state integer, or an instance name to be stored in |sn| and
-get the next non-blank non-relax non-call token.
+    Here is a routine that print the result of a convert command, using the
+    argument |i|. It returns |false | if it does not know to print the code |c|.
+    The function exists because lua code and tex code can both call it to convert
+    something.
 
-@c
+    Parse optional \LUA\ state integer, or an instance name to be stored in |sn|
+    and get the next non-blank non-relax non-call token.
+
+*/
 
 int scan_lua_state(void)
 {
@@ -2263,15 +2547,18 @@ int scan_lua_state(void)
     return sn;
 }
 
-@ The procedure |conv_toks| uses |str_toks| to insert the token list for
-|convert| functions into the scanner; `\.{\\outer}' control sequences are allowed
-to follow `\.{\\string}' and `\.{\\meaning}'.
+/*tex
+
+    The procedure |conv_toks| uses |str_toks| to insert the token list for
+    |convert| functions into the scanner; `\.{\\outer}' control sequences are
+    allowed to follow `\.{\\string}' and `\.{\\meaning}'.
 
-The extra temp string |u| is needed because |pdf_scan_ext_toks| incorporates any
-pending string in its output. In order to save such a pending string, we have to
-create a temporary string that is destroyed immediately after.
+    The extra temp string |u| is needed because |pdf_scan_ext_toks| incorporates
+    any pending string in its output. In order to save such a pending string, we
+    have to create a temporary string that is destroyed immediately after.
+
+*/
 
-@c
 #define push_selector { \
     old_setting = selector; \
     selector = new_string; \
@@ -2327,6 +2614,8 @@ static int do_variable_pdf(halfword c)
     else if (scan_keyword("pkfixeddpi"))           { do_variable_backend_int(c_pdf_pk_fixed_dpi); }
     else if (scan_keyword("suppressoptionalinfo")) { do_variable_backend_int(c_pdf_suppress_optional_info); }
     else if (scan_keyword("omitcidset"))           { do_variable_backend_int(c_pdf_omit_cidset); }
+    else if (scan_keyword("omitcharset"))          { do_variable_backend_int(c_pdf_omit_charset); }
+    else if (scan_keyword("recompress"))           { do_variable_backend_int(c_pdf_recompress); }
 
     else if (scan_keyword("horigin"))              { do_variable_backend_dimen(d_pdf_h_origin); }
     else if (scan_keyword("vorigin"))              { do_variable_backend_dimen(d_pdf_v_origin); }
@@ -2353,23 +2642,30 @@ static int do_feedback_dvi(halfword c)
     return 0;
 }
 
-/* codes not really needed but cleaner when testing */
+/*tex Codes not really needed but cleaner when testing */
 
 #define pdftex_version  140 /* these values will not change any more */
 #define pdftex_revision "0" /* these values will not change any more */
 
 static int do_feedback_pdf(halfword c)
 {
-    int old_setting;            /* holds |selector| setting */
-    int save_scanner_status;    /* |scanner_status| upon entry */
-    halfword save_def_ref;      /* |def_ref| upon entry, important if inside `\.{\\message}' */
+    /*tex holds |selector| setting */
+    int old_setting;
+    /*tex |scanner_status| upon entry */
+    int save_scanner_status;
+    /*tex |def_ref| upon entry, important if inside `\.{\\message}' */
+    halfword save_def_ref;
     halfword save_warning_index;
-    boolean bool;               /* temp boolean */
-    str_number s;               /* first temp string */
-    int ff;                     /* for use with |set_ff| */
-    str_number u = 0;           /* third temp string, will become non-nil if a string is already being built */
-    char *str;                  /* color stack init str */
-
+    /*tex temp boolean */
+    boolean bool;
+    /*tex first temp string */
+    str_number s;
+    /*tex for use with |set_ff| */
+    int ff;
+    /*tex third temp string, will become non-nil if a string is already being built */
+    str_number u = 0;
+    /*tex color stack init str */
+    char *str;
     if (scan_keyword("lastlink")) {
         push_selector;
         print_int(pdf_last_link);
@@ -2394,7 +2690,7 @@ static int do_feedback_pdf(halfword c)
         pop_selector;
     } else if (scan_keyword("creationdate")) {
         ins_list(string_to_toks(getcreationdate(static_pdf)));
-        /* no further action */
+        /*tex No further action. */
         return 2;
     } else if (scan_keyword("fontname")) {
         scan_font_ident();
@@ -2488,19 +2784,27 @@ static int do_feedback_pdf(halfword c)
 
 void conv_toks(void)
 {
-    int old_setting;            /* holds |selector| setting */
+    /*tex holds |selector| setting */
+    int old_setting;
     halfword p, q;
-    int save_scanner_status;    /* |scanner_status| upon entry */
-    halfword save_def_ref;      /* |def_ref| upon entry, important if inside `\.{\\message}' */
+    /*tex |scanner_status| upon entry */
+    int save_scanner_status;
+    /*tex |def_ref| upon entry, important if inside `\.{\\message}' */
+    halfword save_def_ref;
     halfword save_warning_index;
-    boolean bool;               /* temp boolean */
-    str_number s;               /* first temp string */
-    int sn;                     /* lua chunk name */
-    str_number u = 0;           /* third temp string, will become non-nil if a string is already being built */
-    int c = cur_chr;            /* desired type of conversion */
+    /*tex temp boolean */
+    boolean bool;
+    /*tex first temp string */
+    str_number s;
+    /*tex lua chunk name */
+    int sn;
+    /*tex third temp string, will become non-nil if a string is already being built */
+    str_number u = 0;
+    /*tex desired type of conversion */
+    int c = cur_chr;
     str_number str;
     int i = 0;
-    /* Scan the argument for command |c| */
+    /*tex Scan the argument for command |c|. */
     switch (c) {
         case number_code:
             scan_int();
@@ -2520,7 +2824,20 @@ void conv_toks(void)
                 if (luacstrings > 0)
                     lua_string_start();
             }
-            /* no further action */
+            return;
+            break;
+        case lua_bytecode_code:
+            scan_int();
+            if (cur_val < 0 || cur_val > 65535) {
+                normal_error("luabytecode", "invalid number");
+            } else {
+                u = save_cur_string();
+                luacstrings = 0;
+                luabytecodecall(cur_val);
+                restore_cur_string(u);
+                if (luacstrings > 0)
+                    lua_string_start();
+            }
             return;
             break;
         case lua_code:
@@ -2537,10 +2854,10 @@ void conv_toks(void)
             luacstrings = 0;
             luatokencall(s, sn);
             delete_token_ref(s);
-            restore_cur_string(u);  /* TODO: check this, was different */
+            restore_cur_string(u);
             if (luacstrings > 0)
                 lua_string_start();
-            /* no further action */
+            /*tex No further action. */
             return;
             break;
         case expanded_code:
@@ -2554,7 +2871,56 @@ void conv_toks(void)
             ins_list(token_link(def_ref));
             def_ref = save_def_ref;
             restore_cur_string(u);
-            /* no further action */
+            /*tex No further action. */
+            return;
+            break;
+        case immediate_assignment_code:
+        case immediate_assigned_code:
+            /*tex
+
+                This is on-the-road-to-bachotex brain-wave but it needs a bit
+                more testing. A first variant did more in sequence till a relax
+                of spacer was seen (like do_assignments). It permits for instance
+                setting counters in full expansion.
+
+            */
+            save_scanner_status = scanner_status;
+            save_warning_index = warning_index;
+            save_def_ref = def_ref;
+            u = save_cur_string();
+            do {
+                get_x_token();
+            } while ((cur_cmd == spacer_cmd) || (cur_cmd == relax_cmd));
+            if (c == immediate_assignment_code) {
+                /*tex one-step do_assignment */
+                if (cur_cmd > max_non_prefixed_command) {
+                    set_box_allowed = false;
+                    prefixed_command();
+                    set_box_allowed = true;
+                }
+                /*tex done */
+            } else {
+                /*tex pseudo token list do_assignment */
+                if (cur_cmd == left_brace_cmd) {
+                    while (1) {
+                        do {
+                            get_x_token();
+                        } while ((cur_cmd == spacer_cmd) || (cur_cmd == relax_cmd));
+                        if (cur_cmd == right_brace_cmd) {
+                            break;
+                        } else {
+                            set_box_allowed = false;
+                            prefixed_command();
+                            set_box_allowed = true;
+                        }
+                    }
+                }
+                /*tex done */
+            }
+            warning_index = save_warning_index;
+            scanner_status = save_scanner_status;
+            def_ref = save_def_ref;
+            restore_cur_string(u);
             return;
             break;
         case math_style_code:
@@ -2629,7 +2995,7 @@ void conv_toks(void)
                 free(escstr.s);
                 return;
             }
-            /* no further action */
+            /*tex no further action */
             break;
         case font_id_code:
             scan_font_ident();
@@ -2672,9 +3038,12 @@ void conv_toks(void)
             p = list_ptr(box(cur_val));
             if (p != null) {
                 p = tail_of_list(p);
-                /*
-                    there can be a leftskip, rightskip, penalty and yes, also a disc node with a nesting
-                    node that points to glue spec ... and we don't want to analyze that messy lot
+                /*tex
+
+                    There can be a leftskip, rightskip, penalty and yes, also a
+                    disc node with a nesting node that points to glue spec ...
+                    and we don't want to analyze that messy lot.
+
                 */
                 while ((p != null) && (type(p) == glue_node)) {
                     p = alink(p);
@@ -2685,10 +3054,12 @@ void conv_toks(void)
                         if ((q != null) && ((type(q) == margin_kern_node) && (subtype(q) == right_side))) {
                             p = q;
                         } else {
-                            /*
-                                officially we should look in the replace but currently protrusion doesn't
-                                work anyway with "foo\discretionary{}{}{bar-} " (no following char) so we
-                                don't need it now
+                            /*tex
+
+                                Officially we should look in the replace but
+                                currently protrusion doesn't work anyway with
+                                "foo\discretionary{}{}{bar-} " (no following
+                                char) so we don't need it now.
                             */
                         }
                     }
@@ -2832,7 +3203,7 @@ void do_feedback(void)
                 return ;
             }
             if (done==0) {
-                /* we recover */
+                /*tex We recover. */
                 normal_warning("pdf backend","unexpected use of \\pdffeedback");
                 return;
             } else if (done==2) {
@@ -2857,7 +3228,7 @@ void do_variable(void)
         case dvi_variable_code:
             done = do_variable_dvi(c);
             if (done==0) {
-                /* we recover */
+                /*tex We recover. */
                 normal_warning("dvi backend","unexpected use of \\dvivariable");
             }
             return;
@@ -2865,7 +3236,7 @@ void do_variable(void)
         case pdf_variable_code:
             done = do_variable_pdf(c);
             if (done==0) {
-                /* we recover */
+                /*tex We recover. */
                 normal_warning("pdf backend","unexpected use of \\pdfvariable");
             }
             return;
@@ -2876,33 +3247,8 @@ void do_variable(void)
     }
 }
 
-/*
-    The following code is not used as we can only set math options and not query them. If
-    an option is really important we will provide a proper variable. Most options are not
-    meant for users anyway but for development.
-*/
-
-/*
+/*tex This boolean is keeping track of the lua string escape state */
 
-#define do_mathoption_int(i) \
-    cur_cmd = assign_int_cmd; \
-    cur_val = mathoption_int_base + i; \
-    cur_tok = token_val(cur_cmd, cur_val); \
-    back_input();
-
-void do_mathoption(void)
-{
-         if (scan_keyword("old"))                    { do_mathoption_int(c_mathoption_no_italic_compensation_code); }
-         if (scan_keyword("noitaliccompensation"))   { do_mathoption_int(c_mathoption_no_char_italic_code); }
-    else if (scan_keyword("nocharitalic"))           { do_mathoption_int(c_mathoption_use_old_fraction_scaling_code); }
-    else if (scan_keyword("useoldfractionscaling"))  { do_mathoption_int(c_mathoption_old_code); }
-    else if (scan_keyword("umathcodemeaning"))       { do_mathoption_int(c_mathoption_umathcode_meaning_code); }
-}
-
-*/
-
-@ This boolean is keeping track of the lua string escape state
-@c
 boolean in_lua_escape;
 
 static int the_convert_string_dvi(halfword c, int i)
@@ -2948,7 +3294,7 @@ static int the_convert_string_pdf(halfword c, int i)
 
 str_number the_convert_string(halfword c, int i)
 {
-    int old_setting;            /* saved |selector| setting */
+    int old_setting;
     str_number ret = 0;
     boolean done = true ;
     old_setting = selector;
@@ -3017,14 +3363,14 @@ str_number the_convert_string(halfword c, int i)
         case font_identifier_code:
             print_font_identifier(i);
             break;
-        /* backend: this might become obsolete */
+        /*tex Backend: this might become obsolete! */
         case dvi_feedback_code:
             done = the_convert_string_dvi(c,i);
             break;
         case pdf_feedback_code:
             done = the_convert_string_pdf(c,i);
             break;
-        /* done */
+        /*tex done */
         default:
             done = false;
             break;
@@ -3036,16 +3382,24 @@ str_number the_convert_string(halfword c, int i)
     return ret;
 }
 
-@ Another way to create a token list is via the \.{\\read} command. The sixteen
-files potentially usable for reading appear in the following global variables.
-The value of |read_open[n]| will be |closed| if stream number |n| has not been
-opened or if it has been fully read; |just_open| if an \.{\\openin} but not a
-\.{\\read} has been done; and |normal| if it is open and ready to read the next
-line.
+/*tex
+
+    Another way to create a token list is via the \.{\\read} command. The sixteen
+    files potentially usable for reading appear in the following global
+    variables. The value of |read_open[n]| will be |closed| if stream number |n|
+    has not been opened or if it has been fully read; |just_open| if an
+    \.{\\openin} but not a \.{\\read} has been done; and |normal| if it is open
+    and ready to read the next line.
+
+*/
+
+/*tex used for \.{\\read} */
+
+FILE *read_file[16];
 
-@c
-FILE *read_file[16]; /* used for \.{\\read} */
-int read_open[17];   /* state of |read_file[n]| */
+/*tex state of |read_file[n]| */
+
+int read_open[17];
 
 void initialize_read(void)
 {
@@ -3054,41 +3408,51 @@ void initialize_read(void)
         read_open[k] = closed;
 }
 
-@ The |read_toks| procedure constructs a token list like that for any macro
-definition, and makes |cur_val| point to it. Parameter |r| points to the control
-sequence that will receive this token list.
+/*tex
+
+    The |read_toks| procedure constructs a token list like that for any macro
+    definition, and makes |cur_val| point to it. Parameter |r| points to the
+    control sequence that will receive this token list.
+
+*/
 
-@c
 void read_toks(int n, halfword r, halfword j)
 {
-    halfword p; /* tail of the token list */
-    halfword q; /* new node being added to the token list via |store_new_token| */
-    int s;      /* saved value of |align_state| */
-    int m;      /* stream number */
+    /*tex tail of the token list */
+    halfword p;
+    /*tex new node being added to the token list via |store_new_token| */
+    halfword q;
+    /*tex saved value of |align_state| */
+    int s;
+    /*tex stream number */
+    int m;
     scanner_status = defining;
     warning_index = r;
     p = get_avail();
     def_ref = p;
     set_token_ref_count(def_ref, 0);
-    p = def_ref;                /* the reference count */
+    /*tex the reference count */
+    p = def_ref;
     store_new_token(end_match_token);
     if ((n < 0) || (n > 15))
         m = 16;
     else
         m = n;
     s = align_state;
-    align_state = 1000000;      /* disable tab marks, etc. */
+    /*tex disable tab marks, etc. */
+    align_state = 1000000;
     do {
-        /* Input and store tokens from the next line of the file */
+        /*tex Input and store tokens from the next line of the file. */
         begin_file_reading();
         iname = m + 1;
         if (read_open[m] == closed) {
-            /*
-                Input for \.{\\read} from the terminal
+            /*tex
+
+                Input for \.{\\read} from the terminal. We input on-line into the
+                |buffer| array, prompting the user explicitly if |n>=0|. The
+                value of |n| is set negative so that additional prompts will not
+                be given in the case of multi-line input.
 
-                Here we input on-line into the |buffer| array, prompting the user explicitly
-                if |n>=0|.  The value of |n| is set negative so that additional prompts
-                will not be given in the case of multi-line input.
             */
             if (interaction > nonstop_mode) {
                 if (n < 0) {
@@ -3106,11 +3470,12 @@ void read_toks(int n, halfword r, halfword j)
             }
 
         } else if (read_open[m] == just_open) {
-            /*
-                Input the first line of |read_file[m]|
+            /*tex
+
+                Input the first line of |read_file[m]|. The first line of a file
+                must be treated specially, since |lua_input_ln| must be told not
+                to start with |get|.
 
-                The first line of a file must be treated specially, since |lua_input_ln|
-                must be told not to start with |get|.
             */
             if (lua_input_ln(read_file[m], (m + 1), false)) {
                 read_open[m] = normal;
@@ -3120,10 +3485,11 @@ void read_toks(int n, halfword r, halfword j)
             }
 
         } else {
-            /*
-                Input the next line of |read_file[m]|
+            /*tex
+
+                Input the next line of |read_file[m]|. An empty line is appended
+                at the end of a |read_file|.
 
-                An empty line is appended at the end of a |read_file|.
             */
             if (!lua_input_ln(read_file[m], (m + 1), true)) {
                 lua_a_close_in(read_file[m], (m + 1));
@@ -3146,10 +3512,10 @@ void read_toks(int n, halfword r, halfword j)
         first = ilimit + 1;
         iloc = istart;
         istate = new_line;
-        /* Handle \.{\\readline} and |goto done|; */
+        /*tex Handle \.{\\readline} and |goto done|. */
         if (j == 1) {
             while (iloc <= ilimit) {
-                /* current line not yet finished */
+                /*tex Current line not yet finished. */
                 do_buffer_to_unichar(cur_chr, iloc);
                 if (cur_chr == ' ')
                     cur_tok = space_token;
@@ -3161,11 +3527,11 @@ void read_toks(int n, halfword r, halfword j)
             while (1) {
                 get_token();
                 if (cur_tok == 0) {
-                    /* |cur_cmd=cur_chr=0| will occur at the end of the line */
+                    /*tex |cur_cmd=cur_chr=0| will occur at the end of the line. */
                     break;
                 }
                 if (align_state < 1000000) {
-                    /* unmatched `\.\}' aborts the line */
+                    /*tex Unmatched right brace aborts the line. */
                     do {
                         get_token();
                     } while (cur_tok != 0);
@@ -3183,9 +3549,8 @@ void read_toks(int n, halfword r, halfword j)
     align_state = s;
 }
 
-@ return a string from tokens list
+/*tex Return a string from tokens list: */
 
-@c
 str_number tokens_to_string(halfword p)
 {
     int old_setting;
@@ -3198,11 +3563,20 @@ str_number tokens_to_string(halfword p)
     return make_string();
 }
 
-@ @c
+/*tex
+
+    Values like 512 and 128 also work ok. There is not much to gain in
+    optimization here.
+
+*/
+
+#define alloci_default 1024
+#define alloci_step     256
+
 #define make_room(a)                     \
     if ((unsigned)i+a+1>alloci) {        \
-        ret = xrealloc(ret,(alloci+64)); \
-        alloci = alloci + 64;            \
+        ret = xrealloc(ret,(alloci+alloci_step)); \
+        alloci = alloci + alloci_step; \
     }
 
 #define append_i_byte(a) ret[i++] = (char)(a)
@@ -3247,11 +3621,14 @@ str_number tokens_to_string(halfword p)
 #define is_cat_letter(a) \
     (get_char_cat_code(pool_to_unichar(str_string((a)))) == 11)
 
-@ the actual token conversion in this function is now functionally equivalent to
-|show_token_list|, except that it always prints the whole token list. TODO: check
-whether this causes problems in the lua library.
+/*tex
+
+    The actual token conversion in this function is now functionally equivalent
+    to |show_token_list|, except that it always prints the whole token list.
+    TODO: check whether this causes problems in the lua library.
+
+*/
 
-@c
 char *tokenlist_to_cstring(int pp, int inhibit_par, int *siz)
 {
     register int p, c, m;
@@ -3262,7 +3639,7 @@ char *tokenlist_to_cstring(int pp, int inhibit_par, int *siz)
     char *ret;
     int match_chr = '#';
     int n = '0';
-    unsigned alloci = 1024;
+    unsigned alloci = alloci_default;
     int i = 0;
     p = pp;
     if (p == null) {
@@ -3271,7 +3648,8 @@ char *tokenlist_to_cstring(int pp, int inhibit_par, int *siz)
         return NULL;
     }
     ret = xmalloc(alloci);
-    p = token_link(p);          /* skip refcount */
+    /*tex Skip refcount. */
+    p = token_link(p);
     if (p != null) {
         e = escape_char_par;
     }
@@ -3389,7 +3767,7 @@ char *tokenlist_to_xstring(int pp, int inhibit_par, int *siz)
     char *ret;
     int match_chr = '#';
     int n = '0';
-    unsigned alloci = 1024;
+    unsigned alloci = alloci_default;
     int i = 0;
     int skipping = 1;
     p = pp;
@@ -3399,13 +3777,14 @@ char *tokenlist_to_xstring(int pp, int inhibit_par, int *siz)
         return NULL;
     }
     ret = xmalloc(alloci);
-    p = token_link(p);          /* skip refcount */
+    /*tex Skip refcount. */
+    p = token_link(p);
     if (p != null) {
         e = escape_char_par;
     }
     while (p != null) {
         if (p < (int) fix_mem_min || p > (int) fix_mem_end) {
-            /* nothing */
+            /*tex Nothing done. */
             break;
         }
         infop = token_info(p);
@@ -3413,13 +3792,12 @@ char *tokenlist_to_xstring(int pp, int inhibit_par, int *siz)
             if (!(inhibit_par && infop == par_token)) {
                 q = infop - cs_token_flag;
                 if (q < hash_base) {
-                    /* nothing */
+                    /*tex Nothing done. */
                 } else if ((q >= undefined_control_sequence) && ((q <= eqtb_size) || (q > eqtb_size + hash_extra))) {
-                    /* nothing */
+                    /*tex Nothing done. */
                 } else if ((cs_text(q) < 0) || (cs_text(q) >= str_ptr)) {
-                    /* nothing */
-                } else {
-if (!skipping) {
+                    /*tex Nothing done. */
+                } else if (!skipping) {
                     str_number txt = cs_text(q);
                     sh = makecstring(txt);
                     s = sh;
@@ -3440,12 +3818,11 @@ if (!skipping) {
                         }
                     }
                     free(sh);
-}
                 }
             }
         } else {
             if (infop < 0) {
-                /* nothing */
+                /*tex Nothing done. */
             } else {
                 m = token_cmd(infop);
                 c = token_chr(infop);
@@ -3459,54 +3836,54 @@ if (!skipping) {
                     case spacer_cmd:
                     case letter_cmd:
                     case other_char_cmd:
-if (!skipping) {
-                        Print_uchar(c);
-}
+                        if (!skipping) {
+                            Print_uchar(c);
+                        }
                         break;
                    case mac_param_cmd:
-if (!skipping) {
-                        if (!in_lua_escape && (is_in_csname==0))
+                        if (!skipping) {
+                            if (!in_lua_escape && (is_in_csname==0))
+                                Print_uchar(c);
                             Print_uchar(c);
-                        Print_uchar(c);
-}
+                        }
                         break;
                     case out_param_cmd:
-if (!skipping) {
-                        Print_uchar(match_chr);
-}
+                        if (!skipping) {
+                            Print_uchar(match_chr);
+                        }
                         if (c <= 9) {
-if (!skipping) {
-                            Print_char(c + '0');
-}
+                            if (!skipping) {
+                                Print_char(c + '0');
+                            }
                         } else {
-                            /* nothing */
+                            /*tex Nothing done. */
                             goto EXIT;
                         }
                         break;
                     case match_cmd:
                         match_chr = c;
-if (!skipping) {
-                       Print_uchar(c);
-}
+                        if (!skipping) {
+                            Print_uchar(c);
+                        }
                         n++;
-if (!skipping) {
-                        Print_char(n);
-}
+                        if (!skipping) {
+                            Print_char(n);
+                        }
                         if (n > '9')
                             goto EXIT;
                         break;
                     case end_match_cmd:
                         if (c == 0) {
-if (!skipping) {
-                            Print_char('-');
-                            Print_char('>');
-}
+                            if (!skipping) {
+                                Print_char('-');
+                                Print_char('>');
+                            }
                             i = 0;
-skipping = 0 ;
+                            skipping = 0 ;
                         }
                         break;
                     default:
-                        /* nothing */
+                        /*tex Nothing done. */
                         break;
                 }
             }
@@ -3520,7 +3897,6 @@ skipping = 0 ;
     return ret;
 }
 
-@ @c
 lstring *tokenlist_to_lstring(int pp, int inhibit_par)
 {
     int siz;
@@ -3530,7 +3906,6 @@ lstring *tokenlist_to_lstring(int pp, int inhibit_par)
     return ret;
 }
 
-@ @c
 void free_lstring(lstring * ls)
 {
     if (ls == NULL)
diff --git a/texk/web2c/luatexdir/utils/avlstuff.c b/texk/web2c/luatexdir/utils/avlstuff.c
new file mode 100644
index 000000000..887ba4f46
--- /dev/null
+++ b/texk/web2c/luatexdir/utils/avlstuff.c
@@ -0,0 +1,63 @@
+/*
+
+Copyright 1996-2006 Han The Thanh <thanh@pdftex.org>
+Copyright 2006-2009 Taco Hoekwater <taco@luatex.org>
+
+This file is part of LuaTeX.
+
+LuaTeX is free software; you can redistribute it and/or modify it under the terms
+of the GNU General Public License as published by the Free Software Foundation;
+either version 2 of the License, or (at your option) any later version.
+
+LuaTeX is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU General Public License along with
+LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#include "ptexlib.h"
+#include "utils/avl.h"
+
+/*tex
+
+    Some memory management functions for AVL.
+
+*/
+
+static void *avl_xmalloc(struct libavl_allocator *allocator, size_t size)
+{
+    assert(allocator != NULL && size > 0);
+    return xmalloc((unsigned) size);
+}
+
+static void avl_xfree(struct libavl_allocator *allocator, void *block)
+{
+    assert(allocator != NULL && block != NULL);
+    xfree(block);
+}
+
+struct libavl_allocator avl_xallocator = {
+    avl_xmalloc,
+    avl_xfree
+};
+
+/*tex
+
+    The general AVL comparison functions.
+
+*/
+int comp_int_entry(const void *pa, const void *pb, void *p)
+{
+    (void) p;
+    cmp_return(*(const int *) pa, *(const int *) pb);
+    return 0;
+}
+
+int comp_string_entry(const void *pa, const void *pb, void *p)
+{
+    (void) p;
+    return strcmp((const char *) pa, (const char *) pb);
+}
diff --git a/texk/web2c/luatexdir/utils/avlstuff.w b/texk/web2c/luatexdir/utils/avlstuff.w
deleted file mode 100644
index 1ea148b09..000000000
--- a/texk/web2c/luatexdir/utils/avlstuff.w
+++ /dev/null
@@ -1,61 +0,0 @@
-% avlstuff.w
-%
-% Copyright 1996-2006 Han The Thanh <thanh@@pdftex.org>
-% Copyright 2006-2009 Taco Hoekwater <taco@@luatex.org>
-%
-% This file is part of LuaTeX.
-%
-% LuaTeX is free software; you can redistribute it and/or modify it under
-% the terms of the GNU General Public License as published by the Free
-% Software Foundation; either version 2 of the License, or (at your
-% option) any later version.
-%
-% LuaTeX is distributed in the hope that it will be useful, but WITHOUT
-% ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-% FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
-% License for more details.
-%
-% You should have received a copy of the GNU General Public License along
-% with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
-
-@* AVL helper functions.
-
-@ @c
-
-
-#include "ptexlib.h"
-#include "utils/avl.h"
-
-@ memory management functions for AVL
-@c
-static void *avl_xmalloc(struct libavl_allocator *allocator, size_t size)
-{
-    assert(allocator != NULL && size > 0);
-    return xmalloc((unsigned) size);
-}
-
-static void avl_xfree(struct libavl_allocator *allocator, void *block)
-{
-    assert(allocator != NULL && block != NULL);
-    xfree(block);
-}
-
-struct libavl_allocator avl_xallocator = {
-    avl_xmalloc,
-    avl_xfree
-};
-
-@ general AVL comparison functions
-@c
-int comp_int_entry(const void *pa, const void *pb, void *p)
-{
-    (void) p;
-    cmp_return(*(const int *) pa, *(const int *) pb);
-    return 0;
-}
-
-int comp_string_entry(const void *pa, const void *pb, void *p)
-{
-    (void) p;
-    return strcmp((const char *) pa, (const char *) pb);
-}
diff --git a/texk/web2c/luatexdir/utils/managed-sa.w b/texk/web2c/luatexdir/utils/managed-sa.c
similarity index 79%
rename from texk/web2c/luatexdir/utils/managed-sa.w
rename to texk/web2c/luatexdir/utils/managed-sa.c
index 6ac4a68ac..6cf10e301 100644
--- a/texk/web2c/luatexdir/utils/managed-sa.w
+++ b/texk/web2c/luatexdir/utils/managed-sa.c
@@ -1,36 +1,36 @@
-% managed-sa.w
-%
-% Copyright 2006-2010 Taco Hoekwater <taco@@luatex.org>
-%
-% This file is part of LuaTeX.
-%
-% LuaTeX is free software; you can redistribute it and/or modify it under
-% the terms of the GNU General Public License as published by the Free
-% Software Foundation; either version 2 of the License, or (at your
-% option) any later version.
-%
-% LuaTeX is distributed in the hope that it will be useful, but WITHOUT
-% ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-% FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
-% License for more details.
-%
-% You should have received a copy of the GNU General Public License along
-% with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+/*
 
-@* Sparse arrays with an embedded save stack.
+Copyright 2006-2010 Taco Hoekwater <taco@luatex.org>
 
-These functions are called very often but a few days of experimenting proved that
-there is not much to gain (if at all) from using macros or optimizations like
-preallocating and fast access to the first 128 entries. In practice the overhead
-is mostly in accessing memory and not in (probably inlined) calls. So, we should
-accept fate and wait for faster memory. It's the price we pay for being unicode
-on the one hand and sparse on the other.
+This file is part of LuaTeX.
 
-@ @c
+LuaTeX is free software; you can redistribute it and/or modify it under the terms
+of the GNU General Public License as published by the Free Software Foundation;
+either version 2 of the License, or (at your option) any later version.
+
+LuaTeX is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU General Public License along with
+LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+
+*/
+
+/*tex
+
+    Here we implement sparse arrays with an embedded save stack. These functions
+    are called very often but a few days of experimenting proved that there is
+    not much to gain (if at all) from using macros or optimizations like
+    preallocating and fast access to the first 128 entries. In practice the
+    overhead is mostly in accessing memory and not in (probably inlined) calls.
+    So, we should accept fate and wait for faster memory. It's the price we pay
+    for being unicode on the one hand and sparse on the other.
+
+*/
 
 #include "ptexlib.h"
 
-@ @c
 static void store_sa_stack(sa_tree a, int n, sa_tree_item v, int gl)
 {
     sa_stack_item st;
@@ -47,7 +47,6 @@ static void store_sa_stack(sa_tree a, int n, sa_tree_item v, int gl)
     a->stack[a->stack_ptr] = st;
 }
 
-@ @c
 static void skip_in_stack(sa_tree a, int n)
 {
     int p = a->stack_ptr;
@@ -61,7 +60,6 @@ static void skip_in_stack(sa_tree a, int n)
     }
 }
 
-@ @c
 sa_tree_item get_sa_item(const sa_tree head, const int n)
 {
     if (head->tree != NULL) {
@@ -76,7 +74,6 @@ sa_tree_item get_sa_item(const sa_tree head, const int n)
     return head->dflt;
 }
 
-@ @c
 void set_sa_item(sa_tree head, int n, sa_tree_item v, int gl)
 {
     int h = HIGHPART_PART(n);
@@ -103,13 +100,11 @@ void set_sa_item(sa_tree head, int n, sa_tree_item v, int gl)
     head->tree[h][m][l] = v;
 }
 
-@ @c
 void rawset_sa_item(sa_tree head, int n, sa_tree_item v)
 {
     head->tree[HIGHPART_PART(n)][MIDPART_PART(n)][LOWPART_PART(n)] = v;
 }
 
-@ @c
 void clear_sa_stack(sa_tree a)
 {
     xfree(a->stack);
@@ -117,7 +112,6 @@ void clear_sa_stack(sa_tree a)
     a->stack_size = a->stack_step;
 }
 
-@ @c
 void destroy_sa_tree(sa_tree a)
 {
     if (a == NULL)
@@ -138,7 +132,6 @@ void destroy_sa_tree(sa_tree a)
     xfree(a);
 }
 
-@ @c
 sa_tree copy_sa_tree(sa_tree b)
 {
     sa_tree a = (sa_tree) Mxmalloc_array(sa_tree_head, 1);
@@ -168,15 +161,17 @@ sa_tree copy_sa_tree(sa_tree b)
     return a;
 }
 
-@ The main reason to fill in the lowest entry branches here immediately
-is that most of the sparse arrays have a bias toward ASCII values.
+/*tes
 
-Allocating those here immediately improves the chance of the structure
-|a->tree[0][0][x]| being close together in actual memory locations
+    The main reason to fill in the lowest entry branches here immediately is that
+    most of the sparse arrays have a bias toward \ASCII\ values.
 
-@c
+    Allocating those here immediately improves the chance of the structure
+    |a->tree[0][0][x]| being close together in actual memory locations
 
-/* we could save less for type 0 stacks */
+    We could save less for type 0 stacks.
+
+*/
 
 sa_tree new_sa_tree(int size, int type, sa_tree_item dflt)
 {
@@ -190,11 +185,9 @@ sa_tree new_sa_tree(int size, int type, sa_tree_item dflt)
     a->stack_step = size;
     a->stack_type = type;
     a->stack_ptr = 0;
- /* printf("creating sa tree of type %d\n",type); */
     return (sa_tree) a;
 }
 
-@ @c
 void restore_sa_stack(sa_tree head, int gl)
 {
     sa_stack_item st;
@@ -209,7 +202,6 @@ void restore_sa_stack(sa_tree head, int gl)
     }
 }
 
-@ @c
 void dump_sa_tree(sa_tree a, const char * name)
 {
     boolean f;
@@ -219,10 +211,10 @@ void dump_sa_tree(sa_tree a, const char * name)
     x = a->dflt.int_value;
     dump_int(x);
     if (a->tree != NULL) {
-        dump_int(1); /* marker */
+        /*tex A marker: */
+        dump_int(1);
         n = a->stack_type;
         dump_int(n);
-     /* printf("dumping sa tree %s with type %d\n",name,n); */
         for (h = 0; h < HIGHPART; h++) {
             if (a->tree[h] != NULL) {
                 f = 1;
@@ -253,11 +245,11 @@ void dump_sa_tree(sa_tree a, const char * name)
             }
         }
     } else {
-        dump_int(0); /* marker */
+        /*tex A marker: */
+        dump_int(0);
     }
 }
 
-@ @c
 sa_tree undump_sa_tree(const char * name)
 {
     int x, n;
@@ -272,13 +264,13 @@ sa_tree undump_sa_tree(const char * name)
     a->stack = Mxmalloc_array(sa_stack_item, a->stack_size);
     a->stack_ptr = 0;
     a->tree = NULL;
-    undump_int(x); /* marker */
+    /*tex The marker: */
+    undump_int(x);
     if (x == 0)
         return a;
     a->tree = (sa_tree_item ***) Mxcalloc_array(void *, HIGHPART);
     undump_int(n);
     a->stack_type = n;
- /* printf("undumping sa tree %s with type %d\n",name,n); */
     for (h = 0; h < HIGHPART; h++) {
         undump_qqqq(f);
         if (f > 0) {
diff --git a/texk/web2c/luatexdir/utils/unistring.w b/texk/web2c/luatexdir/utils/unistring.c
similarity index 75%
rename from texk/web2c/luatexdir/utils/unistring.w
rename to texk/web2c/luatexdir/utils/unistring.c
index a5b365a5f..6c95ee31e 100644
--- a/texk/web2c/luatexdir/utils/unistring.w
+++ b/texk/web2c/luatexdir/utils/unistring.c
@@ -1,34 +1,29 @@
-% unistring.w
-%
-% Copyright 2013 Taco Hoekwater <taco@@luatex.org>
-%
-% This file is part of LuaTeX.
-%
-% LuaTeX is free software; you can redistribute it and/or modify it under
-% the terms of the GNU General Public License as published by the Free
-% Software Foundation; either version 2 of the License, or (at your
-% option) any later version.
-%
-% LuaTeX is distributed in the hope that it will be useful, but WITHOUT
-% ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-% FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
-% License for more details.
-%
-% You should have received a copy of the GNU General Public License along
-% with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
-
-@ @c
-
-
-@ @c
+/*
+
+Copyright 2013 Taco Hoekwater <taco@luatex.org>
+
+This file is part of LuaTeX.
+
+LuaTeX is free software; you can redistribute it and/or modify it under the terms
+of the GNU General Public License as published by the Free Software Foundation;
+either version 2 of the License, or (at your option) any later version.
+
+LuaTeX is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU General Public License along with
+LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+
+*/
+
 #include "ptexlib.h"
 #include <string.h>
 
-@ @c
 static void utf_error(void)
 {
-    const char *hlp[] =
-        { "A funny symbol that I can't read has just been (re)read.",
+    const char *hlp[] = {
+        "A funny symbol that I can't read has just been (re)read.",
         "Just continue, I'll change it to 0xFFFD.",
         NULL
     };
@@ -37,7 +32,6 @@ static void utf_error(void)
     deletions_allowed = true;
 }
 
-@ @c
 unsigned str2uni(const unsigned char *k)
 {
     register int ch;
@@ -45,7 +39,8 @@ unsigned str2uni(const unsigned char *k)
     const unsigned char *text = k;
     if ((ch = *text++) < 0x80) {
         val = (unsigned) ch;
-    } else if (ch <= 0xbf) {    /* error */
+    } else if (ch <= 0xbf) {
+        /*tex An error that we skip. */
     } else if (ch <= 0xdf) {
         if (*text >= 0x80 && *text < 0xc0)
             val = (unsigned) (((ch & 0x1f) << 6) | (*text++ & 0x3f));
@@ -64,9 +59,11 @@ unsigned str2uni(const unsigned char *k)
             *text >= 0xc0 || text[1] >= 0xc0 || text[2] >= 0xc0)
             val = 0xFFFD;
     } else {
-        /* the 5- and 6-byte UTF-8 sequences generate integers
-           that are outside of the valid UCS range, and therefore
-           unsupported
+        /*tex
+
+            The 5- and 6-byte UTF-8 sequences generate integers that are outside
+            of the valid UCS range, and therefore unsupported.
+
          */
     }
     if (val == 0xFFFD)
@@ -74,8 +71,11 @@ unsigned str2uni(const unsigned char *k)
     return (val);
 }
 
-@ This is a very basic helper
-@c
+/*tex
+
+    A real basic helper.
+*/
+
 unsigned char *uni2str(unsigned unic)
 {
     unsigned char *buf = xmalloc(5);
@@ -106,26 +106,30 @@ unsigned char *uni2str(unsigned unic)
     return buf;
 }
 
-@ |buffer_to_unichar| converts a sequence of bytes in the |buffer|
-into a unicode character value. It does not check for overflow
-of the |buffer|, but it is careful to check the validity of the
-UTF-8 encoding.
+/*tex
+
+    Function |buffer_to_unichar| converts a sequence of bytes in the |buffer|
+    into a unicode character value. It does not check for overflow of the
+    |buffer|, but it is careful to check the validity of the \UTF-8 encoding.
+
+*/
 
-@c
 int buffer_to_unichar(int k)
 {
    return str2uni((const unsigned char *)(buffer+k));
 }
 
+/*tex
+
+    These came from texlang.c:
+
+*/
 
-@ These came from texlang.w
-@c
 char *uni2string(char *utf8_text, unsigned ch)
 {
-    /* Increment and deposit character */
+    /*tex Increment and deposit character: */
     if (ch >= 17 * 65536)
         return (utf8_text);
-
     if (ch <= 127)
         *utf8_text++ = (char) ch;
     else if (ch <= 0x7ff) {
@@ -155,15 +159,12 @@ unsigned u_length(register unsigned int *str)
     return (len);
 }
 
-
 void utf2uni_strcpy(unsigned int *ubuf, const char *utf8buf)
 {
     int len = (int) strlen(utf8buf) + 1;
     unsigned int *upt = ubuf, *uend = ubuf + len - 1;
-    const unsigned char *pt = (const unsigned char *) utf8buf, *end =
-        pt + strlen(utf8buf);
+    const unsigned char *pt = (const unsigned char *) utf8buf, *end = pt + strlen(utf8buf);
     int w, w2;
-
     while (pt < end && *pt != '\0' && upt < uend) {
         if (*pt <= 127)
             *upt = *pt++;
@@ -171,9 +172,7 @@ void utf2uni_strcpy(unsigned int *ubuf, const char *utf8buf)
             *upt = (unsigned int) (((*pt & 0x1f) << 6) | (pt[1] & 0x3f));
             pt += 2;
         } else if (*pt <= 0xef) {
-            *upt =
-                (unsigned int) (((*pt & 0xf) << 12) | ((pt[1] & 0x3f) << 6) |
-                                (pt[2] & 0x3f));
+            *upt = (unsigned int) (((*pt & 0xf) << 12) | ((pt[1] & 0x3f) << 6) | (pt[2] & 0x3f));
             pt += 3;
         } else {
             w = (((*pt & 0x7) << 2) | ((pt[1] & 0x30) >> 4)) - 1;
@@ -187,15 +186,11 @@ void utf2uni_strcpy(unsigned int *ubuf, const char *utf8buf)
     *upt = '\0';
 }
 
-@ @c
 char *utf16be_str(long code)
 {
     static char buf[SMALL_BUF_SIZE];
     long v;
     unsigned vh, vl;
-
-    assert(code >= 0);
-
     if (code <= 0xFFFF)
         sprintf(buf, "%04lX", code);
     else {
@@ -206,5 +201,3 @@ char *utf16be_str(long code)
     }
     return buf;
 }
-
-
diff --git a/texk/web2c/luatexdir/utils/utils.w b/texk/web2c/luatexdir/utils/utils.c
similarity index 63%
rename from texk/web2c/luatexdir/utils/utils.w
rename to texk/web2c/luatexdir/utils/utils.c
index 420f5cfe4..55ff1cb3e 100644
--- a/texk/web2c/luatexdir/utils/utils.w
+++ b/texk/web2c/luatexdir/utils/utils.c
@@ -1,51 +1,52 @@
-% utils.w
-%
-% Copyright 1996-2006 Han The Thanh <thanh@@pdftex.org>
-% Copyright 2006-2012 Taco Hoekwater <taco@@luatex.org>
-%
-% This file is part of LuaTeX.
-%
-% LuaTeX is free software; you can redistribute it and/or modify it under
-% the terms of the GNU General Public License as published by the Free
-% Software Foundation; either version 2 of the License, or (at your
-% option) any later version.
-%
-% LuaTeX is distributed in the hope that it will be useful, but WITHOUT
-% ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-% FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
-% License for more details.
-%
-% You should have received a copy of the GNU General Public License along
-% with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
-
-@ @c
-
-
-@ @c
+/*
+
+Copyright 1996-2006 Han The Thanh <thanh@pdftex.org>
+Copyright 2006-2012 Taco Hoekwater <taco@luatex.org>
+
+This file is part of LuaTeX.
+
+LuaTeX is free software; you can redistribute it and/or modify it under the terms
+of the GNU General Public License as published by the Free Software Foundation;
+either version 2 of the License, or (at your option) any later version.
+
+LuaTeX is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU General Public License along with
+LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+
+*/
+
 #include "ptexlib.h"
 
-#include <kpathsea/config.h> /* this is a trick to load mingw32's io.h early,
-				using a macro redefinition of |eof()|. */
+/*tex
+
+    This is a trick to load mingw32's io.h early, using a macro redefinition of
+    |eof()|.
+
+*/
+
+#include <kpathsea/config.h>
 #include "sys/types.h"
 #include <kpathsea/c-stat.h>
 #include <kpathsea/c-fopen.h>
 #include <string.h>
 #include <time.h>
-#include <float.h>              /* for |DBL_EPSILON| */
+
+/*tex For |DBL_EPSILON|: */
+
+#include <float.h>
+
 #include "zlib.h"
 #include "md5.h"
 
-#include "lua/luatex-api.h"     /* for luatex_banner */
+#include "lua/luatex-api.h"
 #include "luatex_svnversion.h"
 
 #include "png.h"
 #include "mplib.h"
 
-/* POPPLER_VERSION is defined in poppler-config.h for poppler from
- * the TeX Live tree, or in the Makefile for an installed version.  */
-#include "poppler-config.h"
-
-@ @c
 #define check_nprintf(size_get, size_want) \
     if ((unsigned)(size_get) >= (unsigned)(size_want)) \
         formatted_error("internal","snprintf failed: file %s, line %d", __FILE__, __LINE__);
@@ -55,12 +56,11 @@ static char print_buf[PRINTF_BUF_SIZE];
 int epochseconds;
 int microseconds;
 
-/* define |char_ptr|, |char_array|, and |char_limit| */
 typedef char char_entry;
 define_array(char);
 
-@ @c
 #define SUBSET_TAG_LENGTH 6
+
 void make_subset_tag(fd_entry * fd)
 {
     int i, j = 0, a[SUBSET_TAG_LENGTH];
@@ -117,7 +117,6 @@ void make_subset_tag(fd_entry * fd)
         formatted_warning("subsets","subset-tag collision, resolved in round %d",j);
 }
 
-@ @c
 __attribute__ ((format(printf, 1, 2)))
 void tex_printf(const char *fmt, ...)
 {
@@ -129,7 +128,6 @@ void tex_printf(const char *fmt, ...)
     va_end(args);
 }
 
-@ @c
 size_t xfwrite(void *ptr, size_t size, size_t nmemb, FILE * stream)
 {
     if (fwrite(ptr, size, nmemb, stream) != nmemb)
@@ -137,7 +135,6 @@ size_t xfwrite(void *ptr, size_t size, size_t nmemb, FILE * stream)
     return nmemb;
 }
 
-@ @c
 int xfflush(FILE * stream)
 {
     if (fflush(stream) != 0)
@@ -145,7 +142,6 @@ int xfflush(FILE * stream)
     return 0;
 }
 
-@ @c
 int xgetc(FILE * stream)
 {
     int c = getc(stream);
@@ -154,7 +150,6 @@ int xgetc(FILE * stream)
     return c;
 }
 
-@ @c
 int xputc(int c, FILE * stream)
 {
     int i = putc(c, stream);
@@ -163,7 +158,6 @@ int xputc(int c, FILE * stream)
     return i;
 }
 
-@ @c
 scaled ext_xn_over_d(scaled x, scaled n, scaled d)
 {
     double r = (((double) x) * ((double) n)) / ((double) d);
@@ -176,9 +170,13 @@ scaled ext_xn_over_d(scaled x, scaled n, scaled d)
     return (scaled) r;
 }
 
-@ function strips trailing zeros in string with numbers;
-leading zeros are not stripped (as in real life)
-@c
+/*tex
+
+    This function strips trailing zeros in string with numbers; leading zeros are
+    not stripped (as in real life), It's not used.
+
+*/
+
 #if 0
 char *stripzeros(char *a)
 {
@@ -248,9 +246,9 @@ char *stripzeros(char *a)
 }
 #endif
 
-@ @c
 void initversionstring(char **versions)
 {
+
 #ifdef LuajitTeX
 #define LUA_VER_STRING  LUAJIT_VERSION
 #else
@@ -258,35 +256,37 @@ void initversionstring(char **versions)
 #endif
 #define STR(tok) STR2(tok)
 #define STR2(tok) #tok
+
     const_string fmt =
-                    "Compiled with libpng %s; using %s\n"
-                    "Compiled with %s\n" /* Lua or LuaJIT */
-                    "Compiled with mplib version %s\n"
-                    "Compiled with poppler version %s\n"
-                    "Compiled with zlib %s; using %s\n"
-                    "\nDevelopment id: %s\n";
+        "Compiled with libpng %s; using %s\n"
+        "Compiled with %s\n" /* Lua or LuaJIT */
+        "Compiled with mplib version %s\n"
+        "Compiled with zlib %s; using %s\n"
+        "\nDevelopment id: %s\n";
     size_t len = strlen(fmt)
-                    + strlen(PNG_LIBPNG_VER_STRING) + strlen(png_libpng_ver)
-                    + strlen(LUA_VER_STRING) 
-                    + strlen(mp_metapost_version())
-                    + strlen(POPPLER_VERSION)
-                    + strlen(ZLIB_VERSION) + strlen(zlib_version)
-                    + strlen(STR(luatex_svn_revision))
-                    + 1;
-
-    /* len will be more than enough, because of the placeholder chars in fmt
-       that get replaced by the arguments.  */
+               + strlen(PNG_LIBPNG_VER_STRING) + strlen(png_libpng_ver)
+               + strlen(LUA_VER_STRING)
+               + strlen(mp_metapost_version())
+               + strlen(ZLIB_VERSION) + strlen(zlib_version)
+               + strlen(STR(luatex_svn_revision))
+               + 1;
+
+    /*tex
+        The size of |len| will be more than enough, because of the placeholder
+        chars in fmt that get replaced by the arguments.
+    */
     *versions = xmalloc(len);
     sprintf(*versions, fmt,
                     PNG_LIBPNG_VER_STRING, png_libpng_ver, LUA_VER_STRING,
-                    mp_metapost_version(),POPPLER_VERSION,
+                    mp_metapost_version(),
                     ZLIB_VERSION, zlib_version,STR(luatex_svn_revision));
+
 #undef STR2
 #undef STR
 #undef LUA_VER_STRING
+
 }
 
-@ @c
 void check_buffer_overflow(int wsize)
 {
     if (wsize > buf_size) {
@@ -294,16 +294,18 @@ void check_buffer_overflow(int wsize)
         if (nsize < wsize) {
             nsize = wsize + 5;
         }
-        buffer =
-            (unsigned char *) xreallocarray(buffer, char, (unsigned) nsize);
+        buffer = (unsigned char *) xreallocarray(buffer, char, (unsigned) nsize);
         buf_size = nsize;
     }
 }
 
-@  the return value is a decimal number with the point |dd| places from the back,
-   |scaled_out| is the number of scaled points corresponding to that.
+/*tex
+
+    The return value is a decimal number with the point |dd| places from the
+    back, |scaled_out| is the number of scaled points corresponding to that.
+
+*/
 
-@c
 #define max_integer 0x7FFFFFFF
 
 scaled divide_scaled(scaled s, scaled m, int dd)
@@ -331,7 +333,7 @@ scaled divide_scaled(scaled s, scaled m, int dd)
         q = 10 * q + (10 * r) / m;
         r = (10 * r) % m;
     }
-    /* rounding */
+    /*tex Rounding: */
     if (2 * r >= m) {
         q++;
     }
@@ -343,8 +345,12 @@ scaled divide_scaled(scaled s, scaled m, int dd)
 #define floor win32_floor
 #endif
 
-@ Same function, but using doubles instead of integers (faster)
-@c
+/*tex
+
+    The same function, but using doubles instead of integers (faster).
+
+*/
+
 scaled divide_scaled_n(double sd, double md, double n)
 {
     double dd, di = 0.0;
@@ -356,11 +362,9 @@ scaled divide_scaled_n(double sd, double md, double n)
     return (scaled) di;
 }
 
-@ @c
 int do_zround(double r)
 {
     int i;
-
     if (r > 2147483647.0)
         i = 2147483647;
     else if (r < -2147483647.0)
@@ -369,16 +373,20 @@ int do_zround(double r)
         i = (int) (r + 0.5);
     else
         i = (int) (r - 0.5);
-
     return i;
 }
 
 
-@ Old MSVC doesn't have |rint|.
-@c
+/*tex
+
+    Old MSVC doesn't have |rint|.
+
+*/
+
 #if defined(_MSC_VER) && _MSC_VER <= 1600
 
 #  include <math.h>
+
 double rint(double x)
 {
     return floor(x+0.5);
@@ -386,57 +394,66 @@ double rint(double x)
 
 #endif
 
-@ replace tmpfile() on Windows
-@c
+/*tex
+
+    We replace |tmpfile| on \MSWINDOWS:
+
+*/
+
 #if defined(_WIN32)
-/* _cairo_win_tmpfile (void) - replace tmpfile() on Windows
- * extracted from cairo-misc.c in cairo - a vector graphics library
- * with display and print output
- * the functiion name is changed from
- * _cairo_win32_tmpfile (void) to
- * _cairo_win_tmpfile (void)
- *
- *
- * Copyright 2002 University of Southern California
- * Copyright 2005 Red Hat, Inc.
- * Copyright 2007 Adrian Johnson
- *
- * This library is free software; you can redistribute it and/or
- * modify it either under the terms of the GNU Lesser General Public
- * License version 2.1 as published by the Free Software Foundation
- * (the "LGPL") or, at your option, under the terms of the Mozilla
- * Public License Version 1.1 (the "MPL"). If you do not alter this
- * notice, a recipient may use your version of this file under either
- * the MPL or the LGPL.
- *
- * You should have received a copy of the LGPL along with this library
- * in the file COPYING-LGPL-2.1; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA
- * You should have received a copy of the MPL along with this library
- * in the file COPYING-MPL-1.1
- *
- * The contents of this file are subject to the Mozilla Public License
- * Version 1.1 (the "License"); you may not use this file except in
- * compliance with the License. You may obtain a copy of the License at
- * http://www.mozilla.org/MPL/
- *
- * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY
- * OF ANY KIND, either express or implied. See the LGPL or the MPL for
- * the specific language governing rights and limitations.
- *
- * The Original Code is the cairo graphics library.
- *
- * The Initial Developer of the Original Code is University of Southern
- * California.
- *
- * Contributor(s):
- *	Carl D. Worth <cworth@cworth.org>
- *      Adrian Johnson <ajohnson@redneon.com>
- */
+
+/*
+
+    _cairo_win_tmpfile (void) - replace tmpfile() on Windows
+    extracted from cairo-misc.c in cairo - a vector graphics library
+    with display and print output
+
+    the functiion name is changed from _cairo_win32_tmpfile (void) to
+    _cairo_win_tmpfile (void)
+
+    Copyright 2002 University of Southern California
+    Copyright 2005 Red Hat, Inc.
+    Copyright 2007 Adrian Johnson
+
+    This library is free software; you can redistribute it and/or modify it
+    either under the terms of the GNU Lesser General Public License version 2.1
+    as published by the Free Software Foundation (the "LGPL") or, at your option,
+    under the terms of the Mozilla Public License Version 1.1 (the "MPL"). If you
+    do not alter this notice, a recipient may use your version of this file under
+    either the MPL or the LGPL.
+
+    You should have received a copy of the LGPL along with this library in the
+    file COPYING-LGPL-2.1; if not, write to the Free Software Foundation, Inc.,
+    51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA You should have
+    received a copy of the MPL along with this library in the file
+    COPYING-MPL-1.1
+
+    The contents of this file are subject to the Mozilla Public License Version
+    1.1 (the "License"); you may not use this file except in compliance with the
+    License. You may obtain a copy of the License at http://www.mozilla.org/MPL/
+
+    This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+    KIND, either express or implied. See the LGPL or the MPL for the specific
+    language governing rights and limitations.
+
+    The Original Code is the cairo graphics library. The Initial Developer of the
+    Original Code is University of Southern California. Contributor(s):
+
+    Carl D. Worth  <cworth@cworth.org>
+    Adrian Johnson <ajohnson@redneon.com>
+
+*/
 
 #include <stdio.h>
 #define WIN32_LEAN_AND_MEAN
-/* We require Windows 2000 features such as ETO_PDY */
+
+/*tex
+
+    We require \MSWINDOWS\ 2000 features such as |ETO_PDY|. We probably can now
+    assume that all \MSWINDOWS\ versions are recent.
+
+*/
+
 #if !defined(WINVER) || (WINVER < 0x0500)
 # define WINVER 0x0500
 #endif
@@ -447,14 +464,15 @@ double rint(double x)
 #include <windows.h>
 #include <io.h>
 
-/* tmpfile() replacement for Windows.
- *
- * On Windows tmpfile() creates the file in the root directory. This
- * may fail due to unsufficient privileges. However, this isn't a
- * problem on Windows CE so we don't use it there.
- */
-FILE *
-_cairo_win_tmpfile (void)
+/*tex
+
+    On \MSWINDOWS\ |tmpfile| creates the file in the root directory. This may
+    fail due to unsufficient privileges. However, this isn't a problem on
+    \MSWINDOWS\ CE so we don't use it there. Who is actually using CE anyway?
+
+*/
+
+FILE * _cairo_win_tmpfile (void)
 {
     DWORD path_len;
     WCHAR path_name[MAX_PATH + 1];
@@ -462,14 +480,11 @@ _cairo_win_tmpfile (void)
     HANDLE handle;
     int fd;
     FILE *fp;
-
     path_len = GetTempPathW (MAX_PATH, path_name);
     if (path_len <= 0 || path_len >= MAX_PATH)
-	return NULL;
-
+        return NULL;
     if (GetTempFileNameW (path_name, L"ps_", 0, file_name) == 0)
-	return NULL;
-
+        return NULL;
     handle = CreateFileW (file_name,
 			 GENERIC_READ | GENERIC_WRITE,
 			 0,
@@ -478,22 +493,20 @@ _cairo_win_tmpfile (void)
 			 FILE_ATTRIBUTE_NORMAL | FILE_FLAG_DELETE_ON_CLOSE,
 			 NULL);
     if (handle == INVALID_HANDLE_VALUE) {
-	DeleteFileW (file_name);
-	return NULL;
+        DeleteFileW (file_name);
+        return NULL;
     }
-
     fd = _open_osfhandle((intptr_t) handle, 0);
     if (fd < 0) {
-	CloseHandle (handle);
-	return NULL;
+        CloseHandle (handle);
+        return NULL;
     }
-
     fp = _fdopen(fd, "w+b");
     if (fp == NULL) {
-	_close(fd);
-	return NULL;
+        _close(fd);
+        return NULL;
     }
-
     return fp;
 }
+
 #endif
--- texlive-source/texk/web2c/luatexdir/font/luafont.c.me	1970-01-01 01:00:00.000000000 +0100
+++ texlive-source/texk/web2c/luatexdir/font/luafont.c	2020-11-07 15:50:28.079336523 +0100
@@ -0,0 +1,2420 @@
+/*
+
+Copyright 2006-2011 Taco Hoekwater <taco@luatex.org>
+
+This file is part of LuaTeX.
+
+LuaTeX is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 2 of the License, or (at your
+option) any later version.
+
+LuaTeX is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+License for more details.
+
+You should have received a copy of the GNU General Public License along
+with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#include "ptexlib.h"
+#include "lua/luatex-api.h"
+
+#define noVERBOSE
+
+/*tex
+
+    Todo: make these keys.
+
+*/
+
+const char *font_type_strings[] = {
+    "unknown", "virtual", "real", NULL
+};
+
+const char *font_writingmode_strings[] = {
+    "unknown", "horizontal", "vertical", NULL
+};
+
+const char *font_identity_strings[] = {
+    "unknown", "horizontal", "vertical", NULL
+};
+
+const char *font_format_strings[] = {
+    "unknown", "type1", "type3", "truetype", "opentype", NULL
+};
+
+const char *font_embedding_strings[] = {
+    "unknown", "no", "subset", "full", NULL
+};
+
+const char *ligature_type_strings[] = {
+    "=:", "=:|", "|=:", "|=:|", "", "=:|>", "|=:>", "|=:|>", "", "", "", "|=:|>>", NULL
+};
+
+const char *MATH_param_names[] = {
+    "nil",
+    "ScriptPercentScaleDown",
+    "ScriptScriptPercentScaleDown",
+    "DelimitedSubFormulaMinHeight",
+    "DisplayOperatorMinHeight",
+    "MathLeading",
+    "AxisHeight",
+    "AccentBaseHeight",
+    "FlattenedAccentBaseHeight",
+    "SubscriptShiftDown",
+    "SubscriptTopMax",
+    "SubscriptBaselineDropMin",
+    "SuperscriptShiftUp",
+    "SuperscriptShiftUpCramped",
+    "SuperscriptBottomMin",
+    "SuperscriptBaselineDropMax",
+    "SubSuperscriptGapMin",
+    "SuperscriptBottomMaxWithSubscript",
+    "SpaceAfterScript",
+    "UpperLimitGapMin",
+    "UpperLimitBaselineRiseMin",
+    "LowerLimitGapMin",
+    "LowerLimitBaselineDropMin",
+    "StackTopShiftUp",
+    "StackTopDisplayStyleShiftUp",
+    "StackBottomShiftDown",
+    "StackBottomDisplayStyleShiftDown",
+    "StackGapMin",
+    "StackDisplayStyleGapMin",
+    "StretchStackTopShiftUp",
+    "StretchStackBottomShiftDown",
+    "StretchStackGapAboveMin",
+    "StretchStackGapBelowMin",
+    "FractionNumeratorShiftUp",
+    "FractionNumeratorDisplayStyleShiftUp",
+    "FractionDenominatorShiftDown",
+    "FractionDenominatorDisplayStyleShiftDown",
+    "FractionNumeratorGapMin",
+    "FractionNumeratorDisplayStyleGapMin",
+    "FractionRuleThickness",
+    "FractionDenominatorGapMin",
+    "FractionDenominatorDisplayStyleGapMin",
+    "SkewedFractionHorizontalGap",
+    "SkewedFractionVerticalGap",
+    "OverbarVerticalGap",
+    "OverbarRuleThickness",
+    "OverbarExtraAscender",
+    "UnderbarVerticalGap",
+    "UnderbarRuleThickness",
+    "UnderbarExtraDescender",
+    "RadicalVerticalGap",
+    "RadicalDisplayStyleVerticalGap",
+    "RadicalRuleThickness",
+    "RadicalExtraAscender",
+    "RadicalKernBeforeDegree",
+    "RadicalKernAfterDegree",
+    "RadicalDegreeBottomRaisePercent",
+    "MinConnectorOverlap",
+    "SubscriptShiftDownWithSuperscript",
+    "FractionDelimiterSize",
+    "FractionDelimiterDisplayStyleSize",
+    "NoLimitSubFactor",
+    "NoLimitSupFactor",
+    NULL,
+};
+
+int ff_checkoption (lua_State *L, int narg, const char *def, const char *const lst[]);
+
+int ff_checkoption (lua_State *L, int narg, const char *def, const char *const lst[]) {
+    const char *name = (def) ? luaL_optstring(L, narg, def) : luaL_checkstring(L, narg);
+    int i;
+    for (i=0; lst[i]; i++)
+    if (strcmp(lst[i], name) == 0)
+        return i;
+    return -1;
+}
+
+#define dump_intfield(L,n,c) \
+    lua_push_string_by_name(L,n); \
+    lua_pushinteger(L, c); \
+    lua_rawset(L, -3); \
+
+#define dump_stringfield(L,n,c) \
+    lua_push_string_by_name(L,n); \
+    lua_pushstring(L, c); \
+    lua_rawset(L, -3);
+
+#define dump_booleanfield(L,n,c) \
+    lua_push_string_by_name(L,n); \
+    lua_pushboolean(L, c); \
+    lua_rawset(L, -3);
+
+static void dump_math_kerns(lua_State * L, charinfo * co, int l, int id)
+{
+    int i;
+    for (i = 0; i < l; i++) {
+        lua_newtable(L);
+        if (id==top_left_kern) {
+            dump_intfield(L, height, co->top_left_math_kern_array[(2*i)]);
+            dump_intfield(L, kern,   co->top_left_math_kern_array[(2*i)+1]);
+        } else if (id==top_right_kern) {
+            dump_intfield(L, height, co->top_right_math_kern_array[(2*i)]);
+            dump_intfield(L, kern,   co->top_right_math_kern_array[(2*i)+1]);
+        } else if (id==bottom_right_kern) {
+            dump_intfield(L, height, co->bottom_right_math_kern_array[(2*i)]);
+            dump_intfield(L, kern,   co->bottom_right_math_kern_array[(2*i)+1]);
+        } else if (id==bottom_left_kern) {
+            dump_intfield(L, height, co->bottom_left_math_kern_array[(2*i)]);
+            dump_intfield(L, kern,   co->bottom_left_math_kern_array[(2*i)+1]);
+        }
+        lua_rawseti(L, -2, (i + 1));
+    }
+}
+
+static void font_char_to_lua(lua_State * L, internal_font_number f, charinfo * co)
+{
+    liginfo *l;
+    kerninfo *ki;
+    lua_createtable(L, 0, 10);
+    dump_intfield(L,width,get_charinfo_width(co));
+    dump_intfield(L,height,get_charinfo_height(co));
+    dump_intfield(L,depth,get_charinfo_depth(co));
+    if (get_charinfo_italic(co) != 0) {
+       dump_intfield(L,italic,get_charinfo_italic(co));
+    }
+    if (get_charinfo_vert_italic(co) != 0) {
+       dump_intfield(L,vert_italic,get_charinfo_vert_italic(co));
+    }
+    if (get_charinfo_top_accent(co) !=0 && get_charinfo_top_accent(co) != INT_MIN) {
+       dump_intfield(L,top_accent,get_charinfo_top_accent(co));
+    }
+    if (get_charinfo_bot_accent(co) != 0 && get_charinfo_bot_accent(co) != INT_MIN) {
+       dump_intfield(L,bot_accent,get_charinfo_bot_accent(co));
+    }
+    if (get_charinfo_ef(co) != 1000) {
+        dump_intfield(L,expansion_factor,get_charinfo_ef(co));
+    }
+    if (get_charinfo_lp(co) != 0) {
+        dump_intfield(L,left_protruding,get_charinfo_lp(co));
+    }
+    if (get_charinfo_rp(co) != 0) {
+        dump_intfield(L,right_protruding,get_charinfo_rp(co));
+    }
+    if (font_encodingbytes(f) == 2) {
+        dump_intfield(L,index,get_charinfo_index(co));
+    }
+    if (get_charinfo_name(co) != NULL) {
+        dump_stringfield(L,name,get_charinfo_name(co));
+    }
+    if (get_charinfo_tounicode(co) != NULL) {
+        dump_stringfield(L,tounicode,get_charinfo_tounicode(co));
+    }
+    if (get_charinfo_tag(co) == list_tag) {
+        dump_intfield(L,next,get_charinfo_remainder(co));
+    }
+    if (get_charinfo_used(co)) {
+        dump_booleanfield(L,used,(get_charinfo_used(co) ? true : false));
+    }
+    if (get_charinfo_tag(co) == ext_tag) {
+        extinfo *h;
+        h = get_charinfo_hor_variants(co);
+        if (h != NULL) {
+            int i = 1;
+            lua_push_string_by_name(L,horiz_variants);
+            lua_newtable(L);
+            while (h != NULL) {
+                lua_createtable(L, 0, 5);
+                dump_intfield(L, glyph, h->glyph);
+                dump_intfield(L, extender, h->extender);
+                dump_intfield(L, start, h->start_overlap);
+                dump_intfield(L, end, h->end_overlap);
+                dump_intfield(L, advance, h->advance);
+                lua_rawseti(L, -2, i);
+                i++;
+                h = h->next;
+            }
+            lua_rawset(L, -3);
+        }
+        h = get_charinfo_vert_variants(co);
+        if (h != NULL) {
+            int i = 1;
+            lua_push_string_by_name(L,vert_variants);
+            lua_newtable(L);
+            while (h != NULL) {
+                lua_createtable(L, 0, 5);
+                dump_intfield(L, glyph, h->glyph);
+                dump_intfield(L, extender, h->extender);
+                dump_intfield(L, start, h->start_overlap);
+                dump_intfield(L, end, h->end_overlap);
+                dump_intfield(L, advance, h->advance);
+                lua_rawseti(L, -2, i);
+                i++;
+                h = h->next;
+            }
+            lua_rawset(L, -3);
+        }
+    }
+    ki = get_charinfo_kerns(co);
+    if (ki != NULL) {
+        int i;
+        lua_push_string_by_name(L,kerns);
+        lua_createtable(L, 10, 1);
+        for (i = 0; !kern_end(ki[i]); i++) {
+            if (kern_disabled(ki[i])) {
+                /*tex Skip like in lookup. */
+            } else {
+                lua_rawgeti(L, -1, kern_char(ki[i]));
+                if (lua_type(L,-1) == LUA_TNIL) {
+                    lua_pop(L,1);
+                    if (kern_char(ki[i]) == right_boundarychar) {
+                        lua_push_string_by_name(L,right_boundary);
+                    } else {
+                        lua_pushinteger(L, kern_char(ki[i]));
+                    }
+                    lua_pushinteger(L, kern_kern(ki[i]));
+                    lua_rawset(L, -3);
+                } else {
+                    /*tex The first one wins. */
+                    lua_pop(L,1);
+                }
+            }
+        }
+        lua_rawset(L, -3);
+    }
+    l = get_charinfo_ligatures(co);
+    if (l != NULL) {
+        int i;
+        lua_push_string_by_name(L,ligatures);
+        lua_createtable(L, 10, 1);
+        for (i = 0; !lig_end(l[i]); i++) {
+            if (lig_char(l[i]) == right_boundarychar) {
+                lua_push_string_by_name(L,right_boundary);
+            } else {
+                lua_pushinteger(L, lig_char(l[i]));
+            }
+            lua_createtable(L, 0, 2);
+            lua_push_string_by_name(L,type);
+            lua_pushinteger(L, lig_type(l[i]));
+            lua_rawset(L, -3);
+            lua_push_string_by_name(L,char);
+            lua_pushinteger(L, lig_replacement(l[i]));
+            lua_rawset(L, -3);
+            lua_rawset(L, -3);
+        }
+        lua_rawset(L, -3);
+    }
+    lua_push_string_by_name(L,mathkern);
+    lua_newtable(L);
+    {
+        int i, j;
+        i = get_charinfo_math_kerns(co, top_right_kern);
+        j = 0;
+        if (i > 0) {
+            j++;
+            lua_push_string_by_name(L,top_right);
+            lua_newtable(L);
+            dump_math_kerns(L, co, i, top_right_kern);
+            lua_rawset(L, -3);
+        }
+        i = get_charinfo_math_kerns(co, top_left_kern);
+        if (i > 0) {
+            j++;
+            lua_push_string_by_name(L,top_left);
+            lua_newtable(L);
+            dump_math_kerns(L, co, i, top_left_kern);
+            lua_rawset(L, -3);
+        }
+        i = get_charinfo_math_kerns(co, bottom_right_kern);
+        if (i > 0) {
+            j++;
+            lua_push_string_by_name(L,bottom_right);
+            lua_newtable(L);
+            dump_math_kerns(L, co, i, bottom_right_kern);
+            lua_rawset(L, -3);
+        }
+        i = get_charinfo_math_kerns(co, bottom_left_kern);
+        if (i > 0) {
+            j++;
+            lua_push_string_by_name(L,bottom_left);
+            lua_newtable(L);
+            dump_math_kerns(L, co, i, bottom_left_kern);
+            lua_rawset(L, -3);
+        }
+        if (j > 0)
+            lua_rawset(L, -3);
+        else
+            lua_pop(L, 2);
+    }
+}
+
+static void write_lua_parameters(lua_State * L, int f)
+{
+    int k;
+    lua_push_string_by_name(L,parameters);
+    lua_newtable(L);
+    for (k = 1; k <= font_params(f); k++) {
+        switch (k) {
+            case slant_code:
+                dump_intfield(L,slant,font_param(f, k));
+                break;
+            case space_code:
+                dump_intfield(L,space,font_param(f, k));
+                break;
+            case space_stretch_code:
+                dump_intfield(L,space_stretch,font_param(f, k));
+                break;
+            case space_shrink_code:
+                dump_intfield(L,space_shrink,font_param(f, k));
+                break;
+            case x_height_code:
+                dump_intfield(L,x_height,font_param(f, k));
+                break;
+            case quad_code:
+                dump_intfield(L,quad,font_param(f, k));
+                break;
+            case extra_space_code:
+                dump_intfield(L,extra_space,font_param(f, k));
+                break;
+            default:
+                lua_pushinteger(L, font_param(f, k));
+                lua_rawseti(L, -2, k);
+        }
+    }
+    lua_rawset(L, -3);
+}
+
+static void write_lua_math_parameters(lua_State * L, int f)
+{
+    int k;
+    lua_push_string_by_name(L,MathConstants);
+    lua_newtable(L);
+    for (k = 1; k <= font_math_params(f); k++) {
+        lua_pushinteger(L, font_math_param(f, k));
+        if (k <= MATH_param_max) {
+            lua_setfield(L, -2, MATH_param_names[k]);
+        } else {
+            lua_rawseti(L, -2, k);
+        }
+    }
+    lua_rawset(L, -3);
+}
+
+int font_to_lua(lua_State * L, int f)
+{
+    int k;
+    charinfo *co;
+    if (font_cache_id(f) > 0) {
+        /*tex Fetch the table from the registry if it was saved there by |font_from_lua|. */
+        lua_rawgeti(L, LUA_REGISTRYINDEX, font_cache_id(f));
+        /*tex Font dimenensions can be changed from \TEX\ code. */
+        write_lua_parameters(L, f);
+        return 1;
+    }
+    lua_newtable(L);
+    lua_push_string_by_name(L,name);
+    lua_pushstring(L, font_name(f));
+    lua_rawset(L, -3);
+    if (font_area(f) != NULL) {
+        dump_stringfield(L,area,font_area(f));
+    }
+    if (font_filename(f) != NULL) {
+        dump_stringfield(L,filename,font_filename(f));
+    }
+    if (font_fullname(f) != NULL) {
+        dump_stringfield(L,fullname,font_fullname(f));
+    }
+    if (font_psname(f) != NULL) {
+        dump_stringfield(L,psname,font_psname(f));
+    }
+    if (font_encodingname(f) != NULL) {
+        dump_stringfield(L,encodingname,font_encodingname(f));
+    }
+    dump_booleanfield(L,used,(font_used(f) ? true : false));
+    dump_stringfield(L,type,font_type_strings[font_type(f)]);
+    dump_stringfield(L,format,font_format_strings[font_format(f)]);
+    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));
+    dump_intfield(L,designsize,font_dsize(f));
+    dump_intfield(L,checksum,font_checksum(f));
+    dump_intfield(L,slant,font_slant(f));
+    dump_intfield(L,extend,font_extend(f));
+    dump_intfield(L,squeeze,font_squeeze(f));
+    dump_intfield(L,mode,font_mode(f));
+    dump_intfield(L,width,font_width(f));
+    dump_intfield(L,direction,font_natural_dir(f));
+    dump_intfield(L,encodingbytes,font_encodingbytes(f));
+    dump_booleanfield(L,oldmath,font_oldmath(f));
+    dump_intfield(L,tounicode,font_tounicode(f));
+    /*tex The next one is read only: */
+    if (font_max_shrink(f) != 0) {
+        dump_intfield(L,shrink,font_max_shrink(f));
+    }
+    if (font_max_stretch(f) != 0) {
+        dump_intfield(L,stretch,font_max_stretch(f));
+    }
+    if (font_step(f) != 0) {
+        dump_intfield(L,step,font_step(f));
+    }
+    if (pdf_font_attr(f) != 0) {
+        char *s = makecstring(pdf_font_attr(f));
+        dump_stringfield(L,attributes,s);
+        free(s);
+    }
+    /*tex Parameters: */
+    write_lua_parameters(L, f);
+    write_lua_math_parameters(L, f);
+    /*tex Characters: */
+    lua_push_string_by_name(L,characters);
+    lua_createtable(L, font_tables[f]->charinfo_size, 0);
+    if (has_left_boundary(f)) {
+        co = get_charinfo(f, left_boundarychar);
+        lua_push_string_by_name(L,left_boundary);
+        font_char_to_lua(L, f, co);
+        lua_rawset(L, -3);
+    }
+    if (has_right_boundary(f)) {
+        co = get_charinfo(f, right_boundarychar);
+        lua_push_string_by_name(L,right_boundary);
+        font_char_to_lua(L, f, co);
+        lua_rawset(L, -3);
+    }
+    for (k = font_bc(f); k <= font_ec(f); k++) {
+        if (quick_char_exists(f, k)) {
+            lua_pushinteger(L, k);
+            co = get_charinfo(f, k);
+            font_char_to_lua(L, f, co);
+            lua_rawset(L, -3);
+        }
+    }
+    lua_rawset(L, -3);
+    if (font_cache_id(f) == 0) {
+        /*tex Renew the cache. */
+        int r;
+        lua_pushvalue(L, -1);
+        r = luaL_ref(L, LUA_REGISTRYINDEX);
+        set_font_cache_id(f, r);
+    }
+    return 1;
+}
+
+#define count_hash_items(L,name,n) \
+    n = 0; \
+    lua_key_rawgeti(name); \
+    if (lua_type(L, -1) == LUA_TTABLE) { \
+        lua_pushnil(L); \
+        while (lua_next(L, -2) != 0) { \
+            n++; \
+            lua_pop(L, 1); \
+        } \
+    } \
+    if (n) { \
+        /*tex Keep the table on stack. */ \
+    } else{ \
+        lua_pop(L, 1); \
+    }
+
+#define streq(a,b) (strcmp(a,b)==0)
+
+#define append_packet(k) { *(cp++) = (eight_bits) (k); }
+
+#define do_store_four(l) {                 \
+    append_packet((l & 0xFF000000) >> 24); \
+    append_packet((l & 0x00FF0000) >> 16); \
+    append_packet((l & 0x0000FF00) >> 8);  \
+    append_packet((l & 0x000000FF));       \
+}
+
+static void append_float(eight_bits ** cpp, float a)
+{
+    unsigned int i;
+    eight_bits *cp = *cpp;
+    union U {
+        float a;
+        eight_bits b[sizeof(float)];
+    } u;
+    u.a = a;
+    for (i = 0; i < sizeof(float); i++)
+        append_packet(u.b[i]);
+    *cpp = cp;
+}
+
+static int n_enum_field(lua_State * L, int name_index, int dflt, const char **values)
+{
+    int k, t;
+    const char *s;
+    int i = dflt;
+    /*tex Fetch the string pointer: */
+    lua_rawgeti(L, LUA_REGISTRYINDEX, name_index);
+    lua_rawget(L, -2);
+    t = lua_type(L,-1);
+    if (t == LUA_TNUMBER) {
+        i = (int) lua_tointeger(L, -1);
+    } else if (t == LUA_TSTRING) {
+        s = lua_tostring(L, -1);
+        k = 0;
+        while (values[k] != NULL) {
+            if (strcmp(values[k], s) == 0) {
+                i = k;
+                break;
+            }
+            k++;
+        }
+    }
+    lua_pop(L, 1);
+    return i;
+}
+
+static int n_boolean_field(lua_State * L, int name_index, int dflt)
+{
+    int i = dflt;
+    /*tex Fetch the string pointer: */
+    lua_rawgeti(L, LUA_REGISTRYINDEX, name_index);
+    lua_rawget(L, -2);
+    if (lua_isboolean(L, -1)) {
+        i = lua_toboolean(L, -1);
+    }
+    lua_pop(L, 1);
+    return i;
+}
+
+static char *n_string_field_copy(lua_State * L, int name_index, const char *dflt)
+{
+    char *i;
+    /*tex Fetch the string pointer: */
+    lua_rawgeti(L, LUA_REGISTRYINDEX, name_index);
+    lua_rawget(L, -2);
+    if (lua_type(L,-1) == LUA_TSTRING) {
+        i = xstrdup(lua_tostring(L, -1));
+    } else if (dflt == NULL) {
+        i = NULL;
+    } else {
+        i = xstrdup(dflt);
+    }
+    lua_pop(L, 1);
+    return i;
+}
+
+static const char *n_string_field(lua_State * L, int name_index)
+{
+    /*tex Fetch the string pointer: */
+    lua_rawgeti(L, LUA_REGISTRYINDEX, name_index);
+    lua_rawget(L, -2);
+    return lua_tostring(L,-1);
+}
+
+static int n_some_field(lua_State * L, int name_index)
+{
+    /*tex Fetch the string pointer: */
+    lua_rawgeti(L, LUA_REGISTRYINDEX, name_index);
+    lua_rawget(L, -2);
+    return lua_type(L,-1);
+}
+
+static int count_char_packet_bytes(lua_State * L)
+{
+    register int i;
+    register int ts;
+    register int l = 0;
+    int ff = 0;
+    for (i = 1; i <= (int) lua_rawlen(L, -1); i++) {
+        lua_rawgeti(L, -1, i);
+        if (lua_istable(L, -1)) {
+            lua_rawgeti(L, -1, 1);
+            if (lua_type(L,-1) == LUA_TSTRING) {
+                const char *s = lua_tostring(L, -1);
+                if (lua_key_eq(s, font)) {
+                    l += 5;
+                    ff = 1;
+                } else if (lua_key_eq(s, char)) {
+                    if (ff == 0) {
+                        l += 5;
+                    }
+                    l += 5;
+                    ff = 1;
+                } else if (lua_key_eq(s, slot)) {
+                    l += 10;
+                } else if (lua_key_eq(s, comment) || lua_key_eq(s, nop)) {
+                    ;
+                } else if (lua_key_eq(s, push) || lua_key_eq(s, pop)) {
+                    l++;
+                } else if (lua_key_eq(s, rule)) {
+                    l += 9;
+                } else if (lua_key_eq(s, right) || lua_key_eq(s, node) || lua_key_eq(s, down) || lua_key_eq(s, image) || lua_key_eq(s, lua)) {
+                    l += 5;
+                } else if (lua_key_eq(s, scale)) {
+                    l += sizeof(float) + 1;
+                } else if (lua_key_eq(s, pdf)) {
+                    size_t len;
+                    l += 5;
+                    ts = lua_rawlen(L, -2);
+                    lua_rawgeti(L, -2, 2);
+                    if (ts == 3) {
+                        if (lua_type(L,-1) == LUA_TSTRING) {
+                            /*tex There is no need to do something. */
+                        } else if (lua_type(L,-1) == LUA_TNUMBER) {
+                            /*tex There is no need to do something. */
+                        } else {
+                            normal_error("vf command","invalid packet pdf literal category");
+                        }
+                        lua_rawgeti(L, -3, 3);
+                    }
+                    if (lua_type(L,-1) == LUA_TSTRING) {
+                        (void) lua_tolstring(L, -1, &len);
+                        if (len > 0) {
+                            l = (int) (l + 5 + (int) len);
+                        }
+                    } else {
+                        normal_error("vf command","invalid packet pdf literal");
+                    }
+                    lua_pop(L, ts == 3 ? 2 : 1);
+                } else if (lua_key_eq(s, special)) {
+                    size_t len;
+                    lua_rawgeti(L, -2, 2);
+                    if (lua_type(L,-1) == LUA_TSTRING) {
+                        (void) lua_tolstring(L, -1, &len);
+                        if (len > 0) {
+                            l = (int) (l + 5 + (int) len);
+                        }
+                    } else {
+                        normal_error("vf command","invalid packet special");
+                    }
+                    lua_pop(L, 1);
+                } else {
+                    normal_error("vf command","unknown packet command");
+                }
+            } else {
+                normal_error("vf command","no packet command");
+            }
+            /*tex Pop the command name: */
+            lua_pop(L, 1);
+        }
+        /*tex Pop this item: */
+        lua_pop(L, 1);
+    }
+    return l;
+}
+
+static scaled sp_to_dvi(halfword sp, halfword atsize)
+{
+    double result, mult;
+    mult = (double) (atsize / 65536.0);
+    result = (double) (sp * 16.0);
+    return floor(result / mult);
+}
+
+static void read_char_packets(lua_State * L, int *l_fonts, charinfo * co, internal_font_number f, int atsize)
+{
+    int i, n, m;
+    size_t l;
+    int cmd;
+    const char *s;
+    eight_bits *cpackets, *cp;
+    int ff = 0;
+    int sf = 0;
+    int ts = 0;
+    int max_f = 0;
+    int pc = count_char_packet_bytes(L);
+    if (pc <= 0)
+        return;
+    while (l_fonts[(max_f + 1)] != 0)
+        max_f++;
+    cp = cpackets = xmalloc((unsigned) (pc + 1));
+    for (i = 1; i <= (int) lua_rawlen(L, -1); i++) {
+        lua_rawgeti(L, -1, i);
+        if (lua_istable(L, -1)) {
+            /*tex fetch the command code */
+            lua_rawgeti(L, -1, 1);
+            if (lua_type(L,-1) == LUA_TSTRING) {
+                s = lua_tostring(L, -1);
+                cmd = 0;
+                if (lua_key_eq(s, font)) {
+                    cmd = packet_font_code;
+                } else if (lua_key_eq(s, char)) {
+                    cmd = packet_char_code;
+                    if (ff == 0) {
+                        append_packet(packet_font_code);
+                        ff = l_fonts[1];
+                        do_store_four(ff);
+                    }
+                } else if (lua_key_eq(s, slot)) {
+                    /*tex we could be sparse but no real reason */
+                    cmd = packet_nop_code;
+                    lua_rawgeti(L, -2, 2);
+                    n = (int) lua_roundnumber(L, -1);
+                    if (n == 0) {
+                        sf = f;
+                    } else {
+                        sf = (n > max_f ? l_fonts[1] : l_fonts[n]);
+                    }
+                    lua_rawgeti(L, -3, 3);
+                    n = (int) lua_roundnumber(L, -1);
+                    lua_pop(L, 2);
+                    append_packet(packet_font_code);
+                    do_store_four(sf);
+                    append_packet(packet_char_code);
+                    do_store_four(n);
+                } else if (lua_key_eq(s, comment) || lua_key_eq(s, nop)) {
+                    cmd = packet_nop_code;
+                } else if (lua_key_eq(s, node)) {
+                    cmd = packet_node_code;
+                } else if (lua_key_eq(s, push)) {
+                    cmd = packet_push_code;
+                } else if (lua_key_eq(s, pop)) {
+                    cmd = packet_pop_code;
+                } else if (lua_key_eq(s, rule)) {
+                    cmd = packet_rule_code;
+                } else if (lua_key_eq(s, right)) {
+                    cmd = packet_right_code;
+                } else if (lua_key_eq(s, down)) {
+                    cmd = packet_down_code;
+                } else if (lua_key_eq(s, pdf)) {
+                    cmd = packet_pdf_code;
+                } else if (lua_key_eq(s, special)) {
+                    cmd = packet_special_code;
+                } else if (lua_key_eq(s, image)) {
+                    cmd = packet_image_code;
+                } else if (lua_key_eq(s, scale)) {
+                    cmd = packet_scale_code;
+                } else if (lua_key_eq(s, lua)) {
+                    cmd = packet_lua_code;
+                }
+                switch (cmd) {
+                    case packet_push_code:
+                    case packet_pop_code:
+                        append_packet(cmd);
+                        break;
+                    case packet_font_code:
+                        append_packet(cmd);
+                        lua_rawgeti(L, -2, 2);
+                        n = (int) lua_roundnumber(L, -1);
+                        if (n == 0) {
+                            ff = n;
+                        } else {
+                            ff = (n > max_f ? l_fonts[1] : l_fonts[n]);
+                        }
+                        do_store_four(ff);
+                        lua_pop(L, 1);
+                        break;
+                    case packet_node_code:
+                        append_packet(cmd);
+                        lua_rawgeti(L, -2, 2);
+                        n = copy_node_list(nodelist_from_lua(L,-1));
+                        do_store_four(n);
+                        lua_pop(L, 1);
+                        break;
+                    case packet_char_code:
+                        append_packet(cmd);
+                        lua_rawgeti(L, -2, 2);
+                        n = (int) lua_roundnumber(L, -1);
+                        do_store_four(n);
+                        lua_pop(L, 1);
+                        break;
+                    case packet_right_code:
+                    case packet_down_code:
+                        append_packet(cmd);
+                        lua_rawgeti(L, -2, 2);
+                        n = (int) lua_roundnumber(L, -1);
+                        do_store_four(sp_to_dvi(n, atsize));
+                        lua_pop(L, 1);
+                        break;
+                    case packet_rule_code:
+                        append_packet(cmd);
+                        lua_rawgeti(L, -2, 2);
+                        n = (int) lua_roundnumber(L, -1);
+                        do_store_four(sp_to_dvi(n, atsize));
+                        lua_rawgeti(L, -3, 3);
+                        n = (int) lua_roundnumber(L, -1);
+                        do_store_four(sp_to_dvi(n, atsize));
+                        lua_pop(L, 2);
+                        break;
+                    case packet_pdf_code:
+                        ts = (int) lua_rawlen(L, -2);
+                        lua_rawgeti(L, -2, 2);
+                        if (ts == 3) {
+                            /*tex mode on stack */
+                            s = lua_tostring(L, -1);
+                            if (lua_type(L, -1) == LUA_TSTRING) {
+                                /*tex |<pdf> <mode> <direct|page|text|raw|origin>| */
+                                if (lua_key_eq(s, mode)) {
+                                    cmd = packet_pdf_mode;
+                                    lua_rawgeti(L, -3, 3);
+                                    /*tex mode on stack */
+                                    s = lua_tostring(L, -1);
+                                }
+                            } else {
+                                /*tex |<pdf> <direct|page|text|raw|origin> <string>| */
+                            }
+                            if (lua_type(L, -1) == LUA_TSTRING) {
+                                if (lua_key_eq(s, direct)) {
+                                    n = direct_always;
+                                } else if (lua_key_eq(s, page)) {
+                                    n = direct_page;
+                                } else if (lua_key_eq(s, text)) {
+                                    n = direct_text;
+                                } else if (lua_key_eq(s, font)) {
+                                    n = direct_font;
+                                } else if (lua_key_eq(s, raw)) {
+                                    n = direct_raw;
+                                } else if (lua_key_eq(s, origin)) {
+                                    n = set_origin;
+                                } else {
+                                    n = set_origin ;
+                                }
+                            } else {
+                                n = (int) lua_roundnumber(L, -1);
+                                if (n < set_origin || n >= scan_special) {
+                                    n = set_origin ;
+                                }
+                            }
+                            if (cmd == packet_pdf_code) {
+                                /*tex string on stack */
+                                lua_rawgeti(L, -3, 3);
+                            }
+                        } else {
+                            n = set_origin;
+                        }
+                        append_packet(cmd);
+                        do_store_four(n);
+                        if (cmd == packet_pdf_code) {
+                            s = luaL_checklstring(L, -1, &l);
+                            do_store_four(l);
+                            if (l > 0) {
+                                m = (int) l;
+                                while (m > 0) {
+                                    n = *s++;
+                                    m--;
+                                    append_packet(n);
+                                }
+                            }
+                        }
+                        lua_pop(L,ts == 3 ? 2 : 1);
+                        break;
+                    case packet_special_code:
+                        append_packet(cmd);
+                        lua_rawgeti(L, -2, 2);
+                        s = luaL_checklstring(L, -1, &l);
+                        if (l > 0) {
+                            do_store_four(l);
+                            m = (int) l;
+                            while (m > 0) {
+                                n = *s++;
+                                m--;
+                                append_packet(n);
+                            }
+                        }
+                        lua_pop(L, 1);
+                        break;
+                    case packet_lua_code:
+                        append_packet(cmd);
+                        lua_rawgeti(L, -2, 2);
+                        n = luaL_ref(L, LUA_REGISTRYINDEX);
+                        do_store_four(n);
+                        break;
+                    case packet_image_code:
+                        append_packet(cmd);
+                        lua_rawgeti(L, -2, 2);
+                        if (lua_istable(L, -1)) {
+                            lua_getglobal(L, "img");
+                            lua_pushstring(L, "new");
+                            lua_gettable(L, -2);
+                            lua_insert(L, -3);
+                            lua_pop(L, 1);
+                            lua_call(L, 1, 1);
+                        }
+                        luaL_checkudata(L, -1, TYPE_IMG);
+                        n = luaL_ref(L, LUA_REGISTRYINDEX);
+                        do_store_four(n);
+                        break;
+                    case packet_nop_code:
+                        break;
+                    case packet_scale_code:
+                        append_packet(cmd);
+                        lua_rawgeti(L, -2, 2);
+                        append_float(&cp, (float) luaL_checknumber(L, -1));
+                        lua_pop(L, 1);
+                        break;
+                    default:
+                        normal_error("vf command","invalid packet code");
+                }
+            }
+            /*tex Command code: */
+            lua_pop(L, 1);
+        } else {
+            normal_error("vf command","commands has to be a table");
+        }
+        /*tex Command table: */
+        lua_pop(L, 1);
+    }
+    append_packet(packet_end_code);
+    set_charinfo_packets(co, cpackets);
+    return;
+}
+
+static void read_lua_cidinfo(lua_State * L, int f)
+{
+    int i;
+    char *s;
+    lua_key_rawgeti(cidinfo);
+    if (lua_istable(L, -1)) {
+        i = lua_numeric_field_by_index(L,lua_key_index(version), 0);
+        set_font_cidversion(f, i);
+        i = lua_numeric_field_by_index(L,lua_key_index(supplement), 0);
+        set_font_cidsupplement(f, i);
+        s = n_string_field_copy(L, lua_key_index(registry), "Adobe");
+        set_font_cidregistry(f, s);
+        s = n_string_field_copy(L, lua_key_index(ordering), "Identity");
+        set_font_cidordering(f, s);
+    }
+    lua_pop(L, 1);
+}
+
+static void read_lua_parameters(lua_State * L, int f)
+{
+    int i, n, t;
+    const char *s;
+    lua_key_rawgeti(parameters);
+    if (lua_istable(L, -1)) {
+        /*tex The number of parameters is the |max(IntegerKeys(L)),7)| */
+        n = 7;
+        lua_pushnil(L);
+        while (lua_next(L, -2) != 0) {
+            if (lua_type(L, -2) == LUA_TNUMBER) {
+                i = (int) lua_tointeger(L, -2);
+                if (i > n)
+                    n = i;
+            }
+            lua_pop(L, 1);
+        }
+        if (n > 7)
+            set_font_params(f, n);
+        /*tex Sometimes it is handy to have all integer keys: */
+        for (i = 1; i <= 7; i++) {
+            lua_rawgeti(L, -1, i);
+            if (lua_type(L, -1) == LUA_TNUMBER) {
+                n = lua_roundnumber(L, -1);
+                set_font_param(f, i, n);
+            }
+            lua_pop(L, 1);
+        }
+        lua_pushnil(L);
+        while (lua_next(L, -2) != 0) {
+            t = lua_type(L,-2);
+            if (t == LUA_TNUMBER) {
+                i = (int) lua_tointeger(L, -2);
+                if (i >= 8) {
+                    if (lua_type(L,-1) == LUA_TNUMBER) {
+                        n = lua_roundnumber(L, -1);
+                    } else {
+                        n = 0;
+                    }
+                    set_font_param(f, i, n);
+                }
+            } else if (t == LUA_TSTRING) {
+                s = lua_tostring(L, -2);
+                if (lua_type(L,-1) == LUA_TNUMBER) {
+                    n = lua_roundnumber(L, -1);
+                } else {
+                    n = 0;
+                }
+                if (lua_key_eq(s, slant)) {
+                    set_font_param(f, slant_code, n);
+                } else if (lua_key_eq(s, space)) {
+                    set_font_param(f, space_code, n);
+                } else if (lua_key_eq(s, space_stretch)) {
+                    set_font_param(f, space_stretch_code, n);
+                } else if (lua_key_eq(s, space_shrink)) {
+                    set_font_param(f, space_shrink_code, n);
+                } else if (lua_key_eq(s, x_height)) {
+                    set_font_param(f, x_height_code, n);
+                } else if (lua_key_eq(s, quad)) {
+                    set_font_param(f, quad_code, n);
+                } else if (lua_key_eq(s, extra_space)) {
+                    set_font_param(f, extra_space_code, n);
+                }
+            }
+            lua_pop(L, 1);
+        }
+    }
+    lua_pop(L, 1);
+
+}
+
+static void read_lua_math_parameters(lua_State * L, int f)
+{
+    int i = 0, n = 0, t;
+    lua_key_rawgeti(MathConstants);
+    if (lua_istable(L, -1)) {
+        lua_pushnil(L);
+        while (lua_next(L, -2) != 0) {
+            t = lua_type(L,-2);
+            if (t == LUA_TNUMBER) {
+                i = (int) lua_tointeger(L, -2);
+            } else if (t == LUA_TSTRING) {
+                i = ff_checkoption(L, -2, NULL, MATH_param_names);
+            }
+            n = (int) lua_roundnumber(L, -1);
+            if (i > 0) {
+                set_font_math_param(f, i, n);
+            }
+            lua_pop(L, 1);
+        }
+        set_font_oldmath(f,false);
+    } else {
+        set_font_oldmath(f,true);
+    }
+    lua_pop(L, 1);
+}
+
+#define MIN_INF -0x7FFFFFFF
+
+static void store_math_kerns(lua_State * L, int index, charinfo * co, int id)
+{
+    int l, k;
+    scaled ht, krn;
+    lua_key_direct_rawgeti(index);
+    if (lua_istable(L, -1) && ((k = (int) lua_rawlen(L, -1)) > 0)) {
+        for (l = 0; l < k; l++) {
+            lua_rawgeti(L, -1, (l + 1));
+            if (lua_istable(L, -1)) {
+                ht = (scaled) lua_numeric_field_by_index(L, lua_key_index(height), MIN_INF);
+                krn = (scaled) lua_numeric_field_by_index(L, lua_key_index(kern), MIN_INF);
+                if (krn > MIN_INF && ht > MIN_INF)
+                    add_charinfo_math_kern(co, id, ht, krn);
+            }
+            lua_pop(L, 1);
+        }
+    }
+    lua_pop(L, 1);
+}
+
+static void font_char_from_lua(lua_State * L, internal_font_number f, int i, int *l_fonts, boolean has_math)
+{
+    int k, r, t, lt, u, n;
+    charinfo *co;
+    kerninfo *ckerns;
+    liginfo *cligs;
+    scaled j;
+    const char *s;
+    /*tex The number of ligature table items: */
+    int nl = 0;
+    /*tex The number of kern table items: */
+    int nk = 0;
+    int ctr = 0;
+    int atsize = font_size(f);
+    if (lua_istable(L, -1)) {
+        co = get_charinfo(f, i);
+        set_charinfo_tag(co, 0);
+        j = lua_numeric_field_by_index(L, lua_key_index(width), 0);
+        set_charinfo_width(co, j);
+        j = lua_numeric_field_by_index(L, lua_key_index(height), 0);
+        set_charinfo_height(co, j);
+        j = lua_numeric_field_by_index(L, lua_key_index(depth), 0);
+        set_charinfo_depth(co, j);
+        j = lua_numeric_field_by_index(L, lua_key_index(italic), 0);
+        set_charinfo_italic(co, j);
+        j = lua_numeric_field_by_index(L, lua_key_index(vert_italic), 0);
+        set_charinfo_vert_italic(co, j);
+        j = lua_numeric_field_by_index(L, lua_key_index(index), 0);
+        set_charinfo_index(co, j);
+        j = lua_numeric_field_by_index(L, lua_key_index(expansion_factor), 1000);
+        set_charinfo_ef(co, j);
+        j = lua_numeric_field_by_index(L, lua_key_index(left_protruding), 0);
+        set_charinfo_lp(co, j);
+        j = lua_numeric_field_by_index(L, lua_key_index(right_protruding), 0);
+        set_charinfo_rp(co, j);
+        k = n_boolean_field(L, lua_key_index(used), 0);
+        set_charinfo_used(co, k);
+        s = n_string_field(L, lua_key_index(name));
+        if (s != NULL)
+            set_charinfo_name(co, xstrdup(s));
+        else
+            set_charinfo_name(co, NULL);
+        /*tex |n_string_field| leaves a value on stack*/
+        lua_pop(L,1);
+        u = n_some_field(L,lua_key_index(tounicode));
+        if (u == LUA_TNUMBER) {
+            u = lua_tointeger(L,-1);
+            if (u < 0) {
+                set_charinfo_tounicode(co, NULL);
+            } else if (u < 0xD7FF || (u > 0xDFFF && u <= 0xFFFF)) {
+                char *s = malloc(5);
+                sprintf(s,"%04X",(unsigned int) u);
+                set_charinfo_tounicode(co,s);
+            } else {
+                char *s = malloc(11);
+                u = u - 0x10000;
+                sprintf(s,"%04X%04X",(unsigned int) (floor(u/1024)+0xD800),(unsigned int) (u%1024+0xDC00));
+                set_charinfo_tounicode(co,s);
+            }
+        } else if (u == LUA_TTABLE) {
+            n = lua_rawlen(L,-1);
+            u = 0;
+            for (k = 1; k <= n; k++) {
+                lua_rawgeti(L, -1, k);
+                if (lua_type(L,-1) == LUA_TNUMBER) {
+                    u = lua_tointeger(L,-1);
+                } else {
+                    lua_pop(L, 1);
+                    break;
+                }
+                if (u < 0) {
+                    u = -1;
+                    lua_pop(L, 1);
+                    break;
+                } else if (u < 0xD7FF || (u > 0xDFFF && u <= 0xFFFF)) {
+                    u = u + 4;
+                } else {
+                    u = u + 8;
+                }
+                lua_pop(L, 1);
+            }
+            if (u>0) {
+                char *s = malloc(u+1);
+                char *t = s ;
+                for (k = 1; k <= n; k++) {
+                    lua_rawgeti(L, -1, k);
+                    u = lua_tointeger(L,-1);
+                    if (u < 0xD7FF || (u > 0xDFFF && u <= 0xFFFF)) {
+                        sprintf(t,"%04X",(unsigned int) u);
+                        t += 4;
+                    } else {
+                        u = u - 0x10000;
+                        sprintf(t,"%04X%04X",(unsigned int) (floor(u/1024)+0xD800),(unsigned int) (u%1024+0xDC00));
+                        t += 8;
+                    }
+                    lua_pop(L, 1);
+                }
+                set_charinfo_tounicode(co,s);
+            } else {
+                set_charinfo_tounicode(co, NULL);
+            }
+        } else if (u == LUA_TSTRING) {
+            s = lua_tostring(L,-1);
+            set_charinfo_tounicode(co, xstrdup(s));
+        } else {
+            set_charinfo_tounicode(co, NULL);
+        }
+        lua_pop(L,1);
+        if (has_math) {
+            j = lua_numeric_field_by_index(L, lua_key_index(top_accent), INT_MIN);
+            set_charinfo_top_accent(co, j);
+            j = lua_numeric_field_by_index(L, lua_key_index(bot_accent), INT_MIN);
+            set_charinfo_bot_accent(co, j);
+            k = lua_numeric_field_by_index(L, lua_key_index(next), -1);
+            if (k >= 0) {
+                set_charinfo_tag(co, list_tag);
+                set_charinfo_remainder(co, k);
+            }
+            lua_key_rawgeti(extensible);
+            if (lua_istable(L, -1)) {
+                int top, bot, mid, rep;
+                top = lua_numeric_field_by_index(L, lua_key_index(top), 0);
+                bot = lua_numeric_field_by_index(L, lua_key_index(bot), 0);
+                mid = lua_numeric_field_by_index(L, lua_key_index(mid), 0);
+                rep = lua_numeric_field_by_index(L, lua_key_index(rep), 0);
+                if (top != 0 || bot != 0 || mid != 0 || rep != 0) {
+                    set_charinfo_tag(co, ext_tag);
+                    set_charinfo_extensible(co, top, bot, mid, rep);
+                } else {
+                    formatted_warning("font", "lua-loaded font %s char U+%X has an invalid extensible field", font_name(f), (int) i);
+                }
+            }
+            lua_pop(L, 1);
+            lua_key_rawgeti(horiz_variants);
+            if (lua_istable(L, -1)) {
+                int glyph, startconnect, endconnect, advance, extender;
+                extinfo *h;
+                set_charinfo_tag(co, ext_tag);
+                set_charinfo_hor_variants(co, NULL);
+                for (k = 1;; k++) {
+                    lua_rawgeti(L, -1, k);
+                    if (lua_istable(L, -1)) {
+                        glyph = lua_numeric_field_by_index(L, lua_key_index(glyph), 0);
+                        extender = lua_numeric_field_by_index(L, lua_key_index(extender), 0);
+                        startconnect = lua_numeric_field_by_index(L, lua_key_index(start), 0);
+                        endconnect = lua_numeric_field_by_index(L, lua_key_index(end), 0);
+                        advance = lua_numeric_field_by_index(L, lua_key_index(advance), 0);
+                        h = new_variant(glyph, startconnect, endconnect, advance, extender);
+                        add_charinfo_hor_variant(co, h);
+                        lua_pop(L, 1);
+                    } else {
+                        lua_pop(L, 1);
+                        break;
+                    }
+                }
+            }
+            lua_pop(L, 1);
+            lua_key_rawgeti(vert_variants);
+            if (lua_istable(L, -1)) {
+                int glyph, startconnect, endconnect, advance, extender;
+                extinfo *h;
+                set_charinfo_tag(co, ext_tag);
+                set_charinfo_vert_variants(co, NULL);
+                for (k = 1;; k++) {
+                    lua_rawgeti(L, -1, k);
+                    if (lua_istable(L, -1)) {
+                        glyph = lua_numeric_field_by_index(L, lua_key_index(glyph), 0);
+                        extender = lua_numeric_field_by_index(L, lua_key_index(extender), 0);
+                        startconnect = lua_numeric_field_by_index(L, lua_key_index(start), 0);
+                        endconnect = lua_numeric_field_by_index(L, lua_key_index(end), 0);
+                        advance = lua_numeric_field_by_index(L, lua_key_index(advance), 0);
+                        h = new_variant(glyph, startconnect, endconnect, advance, extender);
+                        add_charinfo_vert_variant(co, h);
+                        lua_pop(L, 1);
+                    } else {
+                        lua_pop(L, 1);
+                        break;
+                    }
+                }
+            }
+            lua_pop(L, 1);
+            /*tex
+                Here is a complete example:
+
+                \starttyping
+                mathkern = {
+                     bottom_left  = { { height = 420, kern = 80  }, { height = 520, kern = 4   } },
+                     bottom_right = { { height = 0,   kern = 48  } },
+                     top_left     = { { height = 620, kern = 0   }, { height = 720, kern = -80 } },
+                     top_right    = { { height = 676, kern = 115 }, { height = 776, kern = 45  } },
+                }
+                \stoptyping
+
+            */
+            lua_key_rawgeti(mathkern);
+            if (lua_istable(L, -1)) {
+                store_math_kerns(L,lua_key_index(top_left), co, top_left_kern);
+                store_math_kerns(L,lua_key_index(top_right), co, top_right_kern);
+                store_math_kerns(L,lua_key_index(bottom_right), co, bottom_right_kern);
+                store_math_kerns(L,lua_key_index(bottom_left), co, bottom_left_kern);
+            }
+            lua_pop(L, 1);
+        }
+        /*tex end of |has_math| */
+        count_hash_items(L, kerns, nk);
+        if (nk > 0) {
+            /*tex The kerns table is still on stack. */
+            ckerns = xcalloc((unsigned) (nk + 1), sizeof(kerninfo));
+            ctr = 0;
+            /*tex Traverse the hash. */
+            lua_pushnil(L);
+            while (lua_next(L, -2) != 0) {
+                k = non_boundarychar;
+                lt = lua_type(L,-2);
+                if (lt == LUA_TNUMBER) {
+                    /*tex Adjacent char: */
+                    k = (int) lua_tointeger(L, -2);
+                    if (k < 0)
+                        k = non_boundarychar;
+                } else if (lt == LUA_TSTRING) {
+                    s = lua_tostring(L, -2);
+                    if (lua_key_eq(s, right_boundary)) {
+                        k = right_boundarychar;
+                        if (!has_right_boundary(f))
+                            set_right_boundary(f, get_charinfo(f, right_boundarychar));
+                    }
+                }
+                j = lua_roundnumber(L, -1);
+                if (k != non_boundarychar) {
+                    set_kern_item(ckerns[ctr], k, j);
+                    ctr++;
+                } else {
+                    formatted_warning("font", "lua-loaded font %s char U+%X has an invalid kern field", font_name(f), (int) i);
+                }
+                lua_pop(L, 1);
+            }
+            /*tex A guard against empty tables. */
+            if (ctr > 0) {
+                set_kern_item(ckerns[ctr], end_kern, 0);
+                set_charinfo_kerns(co, ckerns);
+            } else {
+                formatted_warning("font", "lua-loaded font %s char U+%X has an invalid kerns field", font_name(f), (int) i);
+            }
+            lua_pop(L, 1);
+        }
+        /*tex Packet commands. */
+        lua_key_rawgeti(commands);
+        if (lua_istable(L, -1)) {
+            lua_pushnil(L);
+            if (lua_next(L, -2) != 0) {
+                lua_pop(L, 2);
+                read_char_packets(L, (int *) l_fonts, co, f, atsize);
+            }
+        }
+        lua_pop(L, 1);
+        /*tex The ligatures. */
+        count_hash_items(L, ligatures, nl);
+        if (nl > 0) {
+            /*tex The ligatures table still on stack. */
+            cligs = xcalloc((unsigned) (nl + 1), sizeof(liginfo));
+            ctr = 0;
+            /*tex Traverse the hash. */
+            lua_pushnil(L);
+            while (lua_next(L, -2) != 0) {
+                k = non_boundarychar;
+                lt = lua_type(L,-2);
+                if (lt == LUA_TNUMBER) {
+                    /*tex Adjacent char: */
+                    k = (int) lua_tointeger(L, -2);
+                    if (k < 0) {
+                        k = non_boundarychar;
+                    }
+                } else if (lt == LUA_TSTRING) {
+                    s = lua_tostring(L, -2);
+                    if (lua_key_eq(s, right_boundary)) {
+                        k = right_boundarychar;
+                        if (!has_right_boundary(f))
+                            set_right_boundary(f, get_charinfo(f, right_boundarychar));
+                    }
+                }
+                r = -1;
+                if (lua_istable(L, -1)) {
+                    /*tex Ligature: */
+                    r = lua_numeric_field_by_index(L, lua_key_index(char), -1);
+                }
+                if (r != -1 && k != non_boundarychar) {
+                    t = n_enum_field(L, lua_key_index(type), 0, ligature_type_strings);
+                    set_ligature_item(cligs[ctr], (char) ((t * 2) + 1), k, r);
+                    ctr++;
+                } else {
+                    formatted_warning("font", "lua-loaded font %s char U+%X has an invalid ligature field", font_name(f), (int) i);
+                }
+                /*tex The iterator value: */
+                lua_pop(L, 1);
+            }
+            /*tex A guard against empty tables. */
+            if (ctr > 0) {
+                set_ligature_item(cligs[ctr], 0, end_ligature, 0);
+                set_charinfo_ligatures(co, cligs);
+            } else {
+                formatted_warning("font", "lua-loaded font %s char U+%X has an invalid ligatures field", font_name(f), (int) i);
+            }
+            /*tex The ligatures table. */
+            lua_pop(L, 1);
+        }
+    }
+}
+
+/*tex
+
+    The caller has to fix the state of the lua stack when there is an error!
+
+*/
+
+int font_from_lua(lua_State * L, int f)
+{
+    int i, n, r, t, lt;
+    int s_top;
+    int bc;
+    int ec;
+    char *s;
+    const char *ss;
+    int *l_fonts = NULL;
+    int save_ref ;
+    boolean no_math = false;
+    /*tex Will we save a cache of the \LUA\ table? */
+    save_ref = 1;
+    ss = NULL;
+    ss = n_string_field(L, lua_key_index(cache));
+    if (lua_key_eq(ss, no))
+        save_ref = -1;
+    else if (lua_key_eq(ss, renew))
+        save_ref = 0;
+    /*tex |n_string_field| leaves a value on stack. */
+    lua_pop(L,1);
+    /*tex The table is at stack |index -1| */
+    s = n_string_field_copy(L,lua_key_index(area), "");
+    set_font_area(f, s);
+    s = n_string_field_copy(L, lua_key_index(filename), NULL);
+    set_font_filename(f, s);
+    s = n_string_field_copy(L, lua_key_index(encodingname), NULL);
+    set_font_encodingname(f, s);
+    s = n_string_field_copy(L, lua_key_index(name), NULL);
+    set_font_name(f, s);
+    s = n_string_field_copy(L, lua_key_index(fullname), font_name(f));
+    set_font_fullname(f, s);
+    if (s == NULL) {
+        formatted_error("font","lua-loaded font '%d' has no name!", f);
+        return false;
+    }
+    s = n_string_field_copy(L, lua_key_index(psname), NULL);
+    set_font_psname(f, s);
+    i = lua_numeric_field_by_index(L,lua_key_index(units_per_em), 0);
+    set_font_units_per_em(f, i);
+    i = lua_numeric_field_by_index(L,lua_key_index(designsize), 655360);
+    set_font_dsize(f, i);
+    i = lua_numeric_field_by_index(L,lua_key_index(size), font_dsize(f));
+    set_font_size(f, i);
+    set_font_checksum(f, (unsigned)(lua_unsigned_numeric_field_by_index(L,lua_key_index(checksum), 0))) ;
+    i = lua_numeric_field_by_index(L,lua_key_index(direction), 0);
+    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);
+    set_font_tounicode(f, (char) i);
+    i = lua_numeric_field_by_index(L,lua_key_index(slant), 0);
+    if (i < FONT_SLANT_MIN)
+        i = FONT_SLANT_MIN;
+    if (i > FONT_SLANT_MAX)
+        i = FONT_SLANT_MAX;
+    set_font_slant(f, i);
+    i = lua_numeric_field_by_index(L,lua_key_index(extend), 1000);
+    if (i < FONT_EXTEND_MIN)
+        i = FONT_EXTEND_MIN;
+    if (i > FONT_EXTEND_MAX)
+        i = FONT_EXTEND_MAX;
+    set_font_extend(f, i);
+    i = lua_numeric_field_by_index(L,lua_key_index(squeeze), 1000);
+    if (i < FONT_SQUEEZE_MIN)
+        i = FONT_SQUEEZE_MIN;
+    if (i > FONT_SQUEEZE_MAX)
+        i = FONT_SQUEEZE_MAX;
+    set_font_squeeze(f, i);
+    i = lua_numeric_field_by_index(L,lua_key_index(width), 0);
+    if (i < FONT_WIDTH_MIN)
+        i = FONT_WIDTH_MIN;
+    if (i > FONT_WIDTH_MAX)
+        i = FONT_WIDTH_MAX;
+    set_font_width(f, i);
+    i = lua_numeric_field_by_index(L,lua_key_index(mode), 0);
+    if (i < FONT_MODE_MIN)
+        i = FONT_MODE_MIN;
+    if (i > FONT_MODE_MAX)
+        i = FONT_MODE_MAX;
+    set_font_mode(f, i);
+    i = lua_numeric_field_by_index(L,lua_key_index(hyphenchar), default_hyphen_char_par);
+    set_hyphen_char(f, i);
+    i = lua_numeric_field_by_index(L,lua_key_index(skewchar), default_skew_char_par);
+    set_skew_char(f, i);
+    i = n_boolean_field(L, lua_key_index(used), 0);
+    set_font_used(f, (char) i);
+    s = n_string_field_copy(L, lua_key_index(attributes), NULL);
+    if (s != NULL && strlen(s) > 0) {
+        i = maketexstring(s);
+        set_pdf_font_attr(f, i);
+    }
+    free(s);
+    i = n_enum_field(L, lua_key_index(type), unknown_font_type, font_type_strings);
+    set_font_type(f, i);
+    i = n_enum_field(L, lua_key_index(format), unknown_format, font_format_strings);
+    set_font_format(f, i);
+    i = n_enum_field(L, lua_key_index(writingmode), unknown_writingmode, font_writingmode_strings);
+    set_font_writingmode(f, i);
+    i = n_enum_field(L, lua_key_index(identity), unknown_identity, font_identity_strings);
+    set_font_identity(f, i);
+    i = n_enum_field(L, lua_key_index(embedding), unknown_embedding, font_embedding_strings);
+    set_font_embedding(f, i);
+    if (font_encodingbytes(f) == 0 && (font_format(f) == opentype_format || font_format(f) == truetype_format)) {
+        set_font_encodingbytes(f, 2);
+    }
+    /*tex Now fetch the base fonts, if needed. */
+    count_hash_items(L, fonts, n);
+    if (n > 0) {
+        /*tex The font table still on stack. */
+        l_fonts = xmalloc((unsigned) ((unsigned) (n + 2) * sizeof(int)));
+        memset(l_fonts, 0, (size_t) ((unsigned) (n + 2) * sizeof(int)));
+        for (i = 1; i <= n; i++) {
+            lua_rawgeti(L, -1, i);
+            if (lua_istable(L, -1)) {
+                lua_key_rawgeti(id);
+                if (lua_isnumber(L, -1)) {
+                    l_fonts[i] = (int) lua_tointeger(L, -1);
+                    if (l_fonts[i] == 0) {
+                        l_fonts[i] = (int) f;
+                    }
+                    /*tex Pop id and entry. */
+                    lua_pop(L, 2);
+                    continue;
+                }
+                /*tex Pop id. */
+                lua_pop(L, 1);
+            };
+            ss = NULL;
+            if (lua_istable(L, -1)) {
+                ss = n_string_field(L, lua_key_index(name));
+                /*tex The string is anchored. */
+                lua_pop(L,1);
+            }
+            if (ss != NULL) {
+                t = lua_numeric_field_by_index(L, lua_key_index(size), -1000);
+                /*tex The stack is messed up, otherwise this explicit resizing would not be needed! */
+                s_top = lua_gettop(L);
+                if (strcmp(font_name(f), ss) == 0)
+                    l_fonts[i] = f;
+                else
+                    l_fonts[i] = find_font_id(ss, t);
+                lua_settop(L, s_top);
+            } else {
+                formatted_error("font","invalid local font at index %i in lua-loaded font '%s' (1)",i,font_name(f));
+            }
+            /*tex Pop the list entry. */
+            lua_pop(L, 1);
+        }
+        /*tex Pop the font table. */
+        lua_pop(L, 1);
+    } else if (font_type(f) == virtual_font_type) {
+        /*tex
+            We no longer do this check but instead create an entry. This permits
+            (valid) tricks.
+        */
+        /*
+        formatted_error("font","invalid local fonts in lua-loaded font '%s' (2)", font_name(f));
+        */
+    } else {
+        l_fonts = xmalloc(3 * sizeof(int));
+        l_fonts[0] = 0;
+        l_fonts[1] = f;
+        l_fonts[2] = 0;
+    }
+    /*tex The parameters. */
+    no_math = n_boolean_field(L, lua_key_index(nomath), 0);
+    read_lua_parameters(L, f);
+    if (!no_math) {
+        read_lua_math_parameters(L, f);
+        if (n_boolean_field(L, lua_key_index(oldmath), 0)) {
+            set_font_oldmath(f,true);
+        }
+
+    } else {
+        set_font_oldmath(f,true);
+    }
+    read_lua_cidinfo(L, f);
+    /*tex The characters. */
+    lua_key_rawgeti(characters);
+    if (lua_istable(L, -1)) {
+        /*tex Find the array size values; |num| holds the number of characters to add. */
+        int num = 0;
+        ec = 0;
+        bc = -1;
+        /*tex The first key: */
+        lua_pushnil(L);
+        while (lua_next(L, -2) != 0) {
+            if (lua_isnumber(L, -2)) {
+                i = (int) lua_tointeger(L, -2);
+                if (i >= 0) {
+                    if (lua_istable(L, -1)) {
+                        num++;
+                        if (i > ec)
+                            ec = i;
+                        if (bc < 0)
+                            bc = i;
+                        if (bc >= 0 && i < bc)
+                            bc = i;
+                    }
+                }
+            }
+            lua_pop(L, 1);
+        }
+        if (bc != -1) {
+            int fstep;
+            font_malloc_charinfo(f, num);
+            set_font_bc(f, bc);
+            set_font_ec(f, ec);
+            /*tex The first key: */
+            lua_pushnil(L);
+            while (lua_next(L, -2) != 0) {
+                lt = lua_type(L,-2);
+                if (lt == LUA_TNUMBER) {
+                    i = (int) lua_tointeger(L, -2);
+                    if (i >= 0) {
+                        font_char_from_lua(L, f, i, l_fonts, !no_math);
+                    }
+                } else if (lt == LUA_TSTRING) {
+                    const char *ss1 = lua_tostring(L, -2);
+                    if (lua_key_eq(ss1, left_boundary)) {
+                        font_char_from_lua(L, f, left_boundarychar, l_fonts, !no_math);
+                    } else if (lua_key_eq(ss1, right_boundary)) {
+                        font_char_from_lua(L, f, right_boundarychar, l_fonts, !no_math);
+                    }
+                }
+                lua_pop(L, 1);
+            }
+            lua_pop(L, 1);
+            /*tex
+
+                Handle font expansion last: the |copy_font| routine is called eventually,
+                and that needs to know |bc| and |ec|. We permits virtual fonts to use
+                expansion as one can always turn it off.
+
+            */
+            fstep = lua_numeric_field_by_index(L, lua_key_index(step), 0);
+            if (fstep < 0)
+                fstep = 0;
+            if (fstep > 100)
+                fstep = 100;
+            if (fstep != 0) {
+                int fshrink = lua_numeric_field_by_index(L, lua_key_index(shrink), 0);
+                int fstretch= lua_numeric_field_by_index(L, lua_key_index(stretch), 0);
+                if (fshrink < 0)
+                    fshrink = 0;
+                if (fshrink > 500)
+                    fshrink = 500;
+                fshrink -= (fshrink % fstep);
+                if (fshrink < 0)
+                    fshrink = 0;
+                if (fstretch < 0)
+                    fstretch = 0;
+                if (fstretch > 1000)
+                    fstretch = 1000;
+                fstretch -= (fstretch % fstep);
+                if (fstretch < 0)
+                    fstretch = 0;
+                set_expand_params(f, fstretch, fshrink, fstep);
+            }
+
+        } else {
+            formatted_warning("font","lua-loaded font '%d' with name '%s' has no characters", f, font_name(f));
+        }
+        if (save_ref > 0) {
+            /*tex This pops the table. */
+            r = luaL_ref(L, LUA_REGISTRYINDEX);
+            set_font_cache_id(f, r);
+        } else {
+            lua_pop(L, 1);
+            set_font_cache_id(f, save_ref);
+        }
+    } else {
+        formatted_warning("font","lua-loaded font '%d' with name '%s' has no character table", f, font_name(f));
+    }
+    if (l_fonts != NULL)
+        free(l_fonts);
+    return true;
+}
+
+int characters_from_lua(lua_State * L, int f)
+{
+    int i, n, t, lt;
+    int *l_fonts = NULL;
+    int s_top;
+    const char *ss;
+    boolean no_math = false;
+    /*tex Speedup: */
+    no_math = n_boolean_field(L, lua_key_index(nomath), 0);
+    /*tex Type: */
+    i = n_enum_field(L, lua_key_index(type), font_type(f), font_type_strings);
+    set_font_type(f, i);
+    /*tex Fonts: */
+    count_hash_items(L, fonts, n);
+    if (n > 0) {
+        /*tex The font table still on stack. */
+        l_fonts = xmalloc((unsigned) ((unsigned) (n + 2) * sizeof(int)));
+        memset(l_fonts, 0, (size_t) ((unsigned) (n + 2) * sizeof(int)));
+        for (i = 1; i <= n; i++) {
+            lua_rawgeti(L, -1, i);
+            if (lua_istable(L, -1)) {
+                lua_key_rawgeti(id);
+                if (lua_isnumber(L, -1)) {
+                    l_fonts[i] = (int) lua_tointeger(L, -1);
+                    if (l_fonts[i] == 0) {
+                        l_fonts[i] = (int) f;
+                    }
+                    /*tex Pop id and entry. */
+                    lua_pop(L, 2);
+                    continue;
+                }
+                /*tex Pop id. */
+                lua_pop(L, 1);
+            };
+            ss = NULL;
+            if (lua_istable(L, -1)) {
+                ss = n_string_field(L, lua_key_index(name));
+                /* string is anchored */
+                lua_pop(L,1);
+            }
+            if (ss != NULL) {
+                t = lua_numeric_field_by_index(L, lua_key_index(size), -1000);
+                /*tex the stack is messed up, otherwise this explicit resizing would not be needed! */
+                s_top = lua_gettop(L);
+                if (strcmp(font_name(f), ss) == 0)
+                    l_fonts[i] = f;
+                else
+                    l_fonts[i] = find_font_id(ss, t);
+                lua_settop(L, s_top);
+            } else {
+                formatted_error("font","invalid local font in lua-loaded font '%s' (3)", font_name(f));
+            }
+            /*tex Pop list entry. */
+            lua_pop(L, 1);
+        }
+        /*tex Pop font table. */
+        lua_pop(L, 1);
+    } else if (font_type(f) == virtual_font_type) {
+        formatted_error("font","invalid local fonts in lua-loaded font '%s' (4)", font_name(f));
+    } else {
+        l_fonts = xmalloc(3 * sizeof(int));
+        l_fonts[0] = 0;
+        l_fonts[1] = f;
+        l_fonts[2] = 0;
+    }
+    /*tex The characters. */
+    lua_key_rawgeti(characters);
+    if (lua_istable(L, -1)) {
+        /*tex Find the array size values; |num| has the amount. */
+        int num = 0;
+        int todo = 0;
+        int bc = font_bc(f);
+        int ec = font_ec(f);
+        /*tex First key: */
+        lua_pushnil(L);
+        while (lua_next(L, -2) != 0) {
+            if (lua_isnumber(L, -2)) {
+                i = (int) lua_tointeger(L, -2);
+                if (i >= 0) {
+                    if (lua_istable(L, -1)) {
+                        todo++;
+                        if (! quick_char_exists(f,i)) {
+                            num++;
+                            if (i > ec)
+                                ec = i;
+                            if (bc < 0)
+                                bc = i;
+                            if (bc >= 0 && i < bc)
+                                bc = i;
+                        }
+                    }
+                }
+            }
+            lua_pop(L, 1);
+        }
+        if (todo > 0) {
+            font_malloc_charinfo(f, num);
+            set_font_bc(f, bc);
+            set_font_ec(f, ec);
+            /*tex First key: */
+            lua_pushnil(L);
+            while (lua_next(L, -2) != 0) {
+                lt = lua_type(L,-2);
+                if (lt == LUA_TNUMBER) {
+                    i = (int) lua_tointeger(L, -2);
+                    if (i >= 0) {
+                        if (quick_char_exists(f,i)) {
+                            charinfo *co = char_info(f, i);
+                            set_charinfo_name(co, NULL);
+                            set_charinfo_tounicode(co, NULL);
+                            set_charinfo_packets(co, NULL);
+                            set_charinfo_ligatures(co, NULL);
+                            set_charinfo_kerns(co, NULL);
+                            set_charinfo_vert_variants(co, NULL);
+                            set_charinfo_hor_variants(co, NULL);
+                        }
+                        font_char_from_lua(L, f, i, l_fonts, !no_math);
+                    }
+                }
+                lua_pop(L, 1);
+            }
+            lua_pop(L, 1);
+        }
+    }
+    if (l_fonts != NULL)
+        free(l_fonts);
+    return true;
+}
+
+/*tex Ligaturing starts here */
+
+static void nesting_append(halfword nest1, halfword newn)
+{
+    halfword tail = tlink(nest1);
+    if (tail == null) {
+        couple_nodes(nest1, newn);
+    } else {
+        couple_nodes(tail, newn);
+    }
+    tlink(nest1) = newn;
+}
+
+static void nesting_prepend(halfword nest1, halfword newn)
+{
+    halfword head = vlink(nest1);
+    couple_nodes(nest1, newn);
+    if (head == null) {
+        tlink(nest1) = newn;
+    } else {
+        couple_nodes(newn, head);
+    }
+}
+
+static void nesting_prepend_list(halfword nest1, halfword newn)
+{
+    halfword head = vlink(nest1);
+    couple_nodes(nest1, newn);
+    if (head == null) {
+        tlink(nest1) = tail_of_list(newn);
+    } else {
+        halfword tail = tail_of_list(newn);
+        couple_nodes(tail, head);
+    }
+}
+
+static int test_ligature(liginfo * lig, halfword left, halfword right)
+{
+    if (type(left) != glyph_node)
+        return 0;
+    if (font(left) != font(right))
+        return 0;
+    if (is_ghost(left) || is_ghost(right))
+        return 0;
+    *lig = get_ligature(font(left), character(left), character(right));
+    if (is_valid_ligature(*lig)) {
+        return 1;
+    }
+    return 0;
+}
+
+static int try_ligature(halfword * frst, halfword fwd)
+{
+    halfword cur = *frst;
+    liginfo lig;
+    if (test_ligature(&lig, cur, fwd)) {
+        int move_after = (lig_type(lig) & 0x0C) >> 2;
+        int keep_right = ((lig_type(lig) & 0x01) != 0);
+        int keep_left = ((lig_type(lig) & 0x02) != 0);
+        halfword newgl = raw_glyph_node();
+        font(newgl) = font(cur);
+        character(newgl) = lig_replacement(lig);
+        set_is_ligature(newgl);
+        /*tex
+            Below might not be correct in contrived border case. but we use it
+            only for debugging.
+        */
+        if (character(cur) < 0) {
+            set_is_leftboundary(newgl);
+        }
+        if (character(fwd) < 0) {
+            set_is_rightboundary(newgl);
+        }
+        if (character(cur) < 0) {
+            if (character(fwd) < 0) {
+                build_attribute_list(newgl);
+            } else {
+                add_node_attr_ref(node_attr(fwd));
+                node_attr(newgl) = node_attr(fwd);
+            }
+        } else {
+            add_node_attr_ref(node_attr(cur));
+            node_attr(newgl) = node_attr(cur);
+        }
+        /*tex
+            Maybe if this ligature is consists of another ligature we should add
+            it's |lig_ptr| to the new glyphs |lig_ptr| (and cleanup the no longer
+            needed node). This has a very low priority, so low that it might
+            never happen.
+        */
+        /*tex Left side: */
+        if (keep_left) {
+            halfword new_first = copy_node(cur);
+            lig_ptr(newgl) = new_first;
+            couple_nodes(cur, newgl);
+            if (move_after) {
+                move_after--;
+                cur = newgl;
+            }
+        } else {
+            halfword prev = alink(cur);
+            uncouple_node(cur);
+            lig_ptr(newgl) = cur;
+            couple_nodes(prev, newgl);
+            cur = newgl;        /* as cur has disappeared */
+        }
+        /*tex Right side: */
+        if (keep_right) {
+            halfword new_second = copy_node(fwd);
+            /*tex This is correct, because we {\em know} |lig_ptr| points to {\em one} node. */
+            couple_nodes(lig_ptr(newgl), new_second);
+            couple_nodes(newgl, fwd);
+            if (move_after) {
+                move_after--;
+                cur = fwd;
+            }
+        } else {
+            halfword next = vlink(fwd);
+            uncouple_node(fwd);
+            /*tex This works because we {\em know} |lig_ptr| points to {\em one} node. */
+            couple_nodes(lig_ptr(newgl), fwd);
+            if (next != null) {
+                couple_nodes(newgl, next);
+            }
+        }
+        /*tex Check and return. */
+        *frst = cur;
+        return 1;
+    }
+    return 0;
+}
+
+/*tex
+
+    There shouldn't be any ligatures here - we only add them at the end of
+    |xxx_break| in a \.{DISC-1 - DISC-2} situation and we stop processing
+    \.{DISC-1} (we continue with \.{DISC-1}'s |post_| and |no_break|.
+
+*/
+
+static halfword handle_lig_nest(halfword root, halfword cur)
+{
+    if (cur == null)
+        return root;
+    while (vlink(cur) != null) {
+        halfword fwd = vlink(cur);
+        if (type(cur) == glyph_node && type(fwd) == glyph_node &&
+                font(cur) == font(fwd) && try_ligature(&cur, fwd)) {
+            continue;
+        }
+        cur = vlink(cur);
+    }
+    tlink(root) = cur;
+    return root;
+}
+
+static halfword handle_lig_word(halfword cur)
+{
+    halfword right = null;
+    if (type(cur) == boundary_node) {
+        halfword prev = alink(cur);
+        halfword fwd = vlink(cur);
+        /*tex There is no need to uncouple |cur|, it is freed. */
+        flush_node(cur);
+        if (fwd == null) {
+            vlink(prev) = fwd;
+            return prev;
+        }
+        couple_nodes(prev, fwd);
+        if (type(fwd) != glyph_node)
+            return prev;
+        cur = fwd;
+    } else if (has_left_boundary(font(cur))) {
+        halfword prev = alink(cur);
+        halfword p = new_glyph(font(cur), left_boundarychar);
+        couple_nodes(prev, p);
+        couple_nodes(p, cur);
+        cur = p;
+    }
+    if (has_right_boundary(font(cur))) {
+        right = new_glyph(font(cur), right_boundarychar);
+    }
+    while (1) {
+        /*tex A glyph followed by \unknown */
+        if (type(cur) == glyph_node) {
+            halfword fwd = vlink(cur);
+            if (fwd == null) {
+                /*tex The last character of a paragraph. */
+                if (right == null)
+                    break;
+                /*tex |par| prohibits the use of |couple_nodes| here. */
+                try_couple_nodes(cur, right);
+                right = null;
+                continue;
+            }
+            if (type(fwd) == glyph_node) {
+                /*tex a glyph followed by a glyph */
+                if (font(cur) != font(fwd))
+                    break;
+                if (try_ligature(&cur, fwd))
+                    continue;
+            } else if (type(fwd) == disc_node) {
+                /*tex a glyph followed by a disc */
+                halfword pre = vlink_pre_break(fwd);
+                halfword nob = vlink_no_break(fwd);
+                halfword next, tail;
+                liginfo lig;
+                /*tex Check on: |a{b?}{?}{?}| and |a+b=>B| : |{B?}{?}{a?}| */
+                /*tex Check on: |a{?}{?}{b?}| and |a+b=>B| : |{a?}{?}{B?}| */
+                if ((pre != null && type(pre) == glyph_node && test_ligature(&lig, cur, pre))
+                       || (nob != null && type(nob) == glyph_node && test_ligature(&lig, cur, nob))) {
+                    /*tex Move |cur| from before disc to skipped part */
+                    halfword prev = alink(cur);
+                    uncouple_node(cur);
+                    couple_nodes(prev, fwd);
+                    nesting_prepend(no_break(fwd), cur);
+                    /*tex Now ligature the |pre_break|. */
+                    nesting_prepend(pre_break(fwd), copy_node(cur));
+                    /*tex As we have removed cur, we need to start again. */
+                    cur = prev;
+                }
+                /*tex Check on: |a{?}{?}{}b| and |a+b=>B| : |{a?}{?b}{B}|. */
+                next = vlink(fwd);
+                if (nob == null && next != null && type(next) == glyph_node && test_ligature(&lig, cur, next)) {
+                    /*tex Move |cur| from before |disc| to |no_break| part. */
+                    halfword prev = alink(cur);
+                    uncouple_node(cur);
+                    couple_nodes(prev, fwd);
+                    /*tex We {\em know} it's empty. */
+                    couple_nodes(no_break(fwd), cur);
+                    /*tex Now copy |cur| the |pre_break|. */
+                    nesting_prepend(pre_break(fwd), copy_node(cur));
+                    /*tex Move next from after disc to |no_break| part. */
+                    tail = vlink(next);
+                    uncouple_node(next);
+                    try_couple_nodes(fwd, tail);
+                    /*tex We {\em know} this works. */
+                    couple_nodes(cur, next);
+                    /*tex Make sure the list is correct. */
+                    tlink(no_break(fwd)) = next;
+                    /*tex Now copy next to the |post_break|. */
+                    nesting_append(post_break(fwd), copy_node(next));
+                    /*tex As we have removed cur, we need to start again. */
+                    cur = prev;
+                }
+                /*tex We are finished with the |pre_break|. */
+                handle_lig_nest(pre_break(fwd), vlink_pre_break(fwd));
+            } else if (type(fwd) == boundary_node) {
+                halfword next = vlink(fwd);
+                try_couple_nodes(cur, next);
+                flush_node(fwd);
+                if (right != null) {
+                    /*tex Shame, didn't need it. */
+                    flush_node(right);
+                    /*tex No need to reset |right|, we're going to leave the loop anyway. */
+                }
+                break;
+            } else {
+                /*tex Is something unknown. */
+                if (right == null)
+                    break;
+                couple_nodes(cur, right);
+                couple_nodes(right, fwd);
+                right = null;
+                continue;
+            }
+            /*tex A discretionary followed by \unknown */
+        } else if (type(cur) == disc_node) {
+            /*tex If |{?}{x}{?}| or |{?}{?}{y}| then: */
+            if (vlink_no_break(cur) != null || vlink_post_break(cur) != null) {
+                halfword prev = 0;
+                halfword fwd;
+                liginfo lig;
+                if (subtype(cur) == select_disc) {
+                    prev = alink(cur);
+                    if (vlink_post_break(cur) != null)
+                        handle_lig_nest(post_break(prev), vlink_post_break(prev));
+                    if (vlink_no_break(cur) != null)
+                        handle_lig_nest(no_break(prev), vlink_no_break(prev));
+                }
+                if (vlink_post_break(cur) != null)
+                    handle_lig_nest(post_break(cur), vlink_post_break(cur));
+                if (vlink_no_break(cur) != null)
+                    handle_lig_nest(no_break(cur), vlink_no_break(cur));
+                while ((fwd = vlink(cur)) != null) {
+                    halfword nob, pst, next;
+                    if (type(fwd) != glyph_node)
+                        break;
+                    if (subtype(cur) != select_disc) {
+                        nob = tlink_no_break(cur);
+                        pst = tlink_post_break(cur);
+                        if ((nob == null || !test_ligature(&lig, nob, fwd)) &&
+                            (pst == null || !test_ligature(&lig, pst, fwd)))
+                            break;
+                        nesting_append(no_break(cur), copy_node(fwd));
+                        handle_lig_nest(no_break(cur), nob);
+                    } else {
+                        int dobreak = 0;
+                        nob = tlink_no_break(prev);
+                        pst = tlink_post_break(prev);
+                        if ((nob == null || !test_ligature(&lig, nob, fwd)) &&
+                            (pst == null || !test_ligature(&lig, pst, fwd)))
+                            dobreak = 1;
+                        if (!dobreak) {
+                            nesting_append(no_break(prev), copy_node(fwd));
+                            handle_lig_nest(no_break(prev), nob);
+                            nesting_append(post_break(prev), copy_node(fwd));
+                            handle_lig_nest(post_break(prev), pst);
+                        }
+                        dobreak = 0;
+                        nob = tlink_no_break(cur);
+                        pst = tlink_post_break(cur);
+                        if ((nob == null || !test_ligature(&lig, nob, fwd)) &&
+                            (pst == null || !test_ligature(&lig, pst, fwd)))
+                            dobreak = 1;
+                        if (!dobreak) {
+                            nesting_append(no_break(cur), copy_node(fwd));
+                            handle_lig_nest(no_break(cur), nob);
+                        }
+                        if (dobreak)
+                            break;
+                    }
+                    next = vlink(fwd);
+                    uncouple_node(fwd);
+                    try_couple_nodes(cur, next);
+                    nesting_append(post_break(cur), fwd);
+                    handle_lig_nest(post_break(cur), pst);
+                }
+                if (fwd != null && type(fwd) == disc_node) {
+                        halfword next = vlink(fwd);
+                        if (vlink_no_break(fwd) == null
+                        && vlink_post_break(fwd) == null
+                        && next != null
+                        && type(next) == glyph_node
+                        && ((tlink_post_break(cur) != null && test_ligature(&lig, tlink_post_break(cur), next)) ||
+                            (tlink_no_break  (cur) != null && test_ligature(&lig, tlink_no_break  (cur), next)))) {
+                        /*tex Building an |init_disc| followed by a |select_disc|: |{a-}{b}{AB} {-}{}{} c| */
+  		        halfword last1 = vlink(next), tail;
+                        uncouple_node(next);
+                        try_couple_nodes(fwd, last1);
+                        /*tex |{a-}{b}{AB} {-}{c}{}| */
+                        nesting_append(post_break(fwd), copy_node(next));
+                        /*tex |{a-}{b}{AB} {-}{c}{-}| */
+                        if (vlink_no_break(cur) != null) {
+                            nesting_prepend(no_break(fwd), copy_node(vlink_pre_break(fwd)));
+                        }
+                        /*tex |{a-}{b}{AB} {b-}{c}{-}| */
+                        if (vlink_post_break(cur) != null)
+                            nesting_prepend_list(pre_break(fwd), copy_node_list(vlink_post_break(cur)));
+                        /*tex |{a-}{b}{AB} {b-}{c}{AB-}| */
+                        if (vlink_no_break(cur) != null) {
+                            nesting_prepend_list(no_break(fwd), copy_node_list(vlink_no_break(cur)));
+                        }
+                        /*tex |{a-}{b}{ABC} {b-}{c}{AB-}| */
+                        tail = tlink_no_break(cur);
+                        nesting_append(no_break(cur), copy_node(next));
+                        handle_lig_nest(no_break(cur), tail);
+                        /*tex |{a-}{BC}{ABC} {b-}{c}{AB-}| */
+                        tail = tlink_post_break(cur);
+                        nesting_append(post_break(cur), next);
+                        handle_lig_nest(post_break(cur), tail);
+                        /*tex Set the subtypes: */
+                        subtype(cur) = init_disc;
+                        subtype(fwd) = select_disc;
+                    }
+                }
+            }
+
+        } else {
+            /*tex We have glyph nor disc. */
+            return cur;
+        }
+        /*tex Goto the next node, where |\par| allows |vlink(cur)| to be NULL. */
+        cur = vlink(cur);
+    }
+    return cur;
+}
+
+/*tex The return value is the new tail, head should be a dummy: */
+
+halfword handle_ligaturing(halfword head, halfword tail)
+{
+    /*tex A trick to allow explicit |node==null| tests. */
+    halfword save_tail1 = null;
+    halfword cur, prev;
+    if (vlink(head) == null)
+        return tail;
+    if (tail != null) {
+        save_tail1 = vlink(tail);
+        vlink(tail) = null;
+    }
+    if (fix_node_lists) {
+        fix_node_list(head);
+    }
+    prev = head;
+    cur = vlink(prev);
+    while (cur != null) {
+        if (type(cur) == glyph_node || (type(cur) == boundary_node)) {
+            cur = handle_lig_word(cur);
+        }
+        prev = cur;
+        cur = vlink(cur);
+    }
+    if (prev == null) {
+        prev = tail;
+    }
+    if (tail != null) {
+        try_couple_nodes(prev, save_tail1);
+    }
+    return prev;
+}
+
+
+/*tex Kerning starts here: */
+
+static void add_kern_before(halfword left, halfword right)
+{
+    if ((!is_rightghost(right)) &&
+        font(left) == font(right) && has_kern(font(left), character(left))) {
+        int k = raw_get_kern(font(left), character(left), character(right));
+        if (k != 0) {
+            halfword kern = new_kern(k);
+            halfword prev = alink(right);
+            couple_nodes(prev, kern);
+            couple_nodes(kern, right);
+            /*tex Update the attribute list (inherit from left): */
+            delete_attribute_ref(node_attr(kern));
+            add_node_attr_ref(node_attr(left));
+            node_attr(kern) = node_attr(left);
+        }
+    }
+}
+
+static void add_kern_after(halfword left, halfword right, halfword aft)
+{
+    if ((!is_rightghost(right)) &&
+        font(left) == font(right) && has_kern(font(left), character(left))) {
+        int k = raw_get_kern(font(left), character(left), character(right));
+        if (k != 0) {
+            halfword kern = new_kern(k);
+            halfword next = vlink(aft);
+            couple_nodes(aft, kern);
+            try_couple_nodes(kern, next);
+            /*tex Update the attribute list (inherit from left == aft): */
+            delete_attribute_ref(node_attr(kern));
+            add_node_attr_ref(node_attr(aft));
+            node_attr(kern) = node_attr(aft);
+        }
+    }
+}
+
+static void do_handle_kerning(halfword root, halfword init_left, halfword init_right)
+{
+    halfword cur = vlink(root);
+    halfword left = null;
+    if (cur == null) {
+        if (init_left != null && init_right != null) {
+            add_kern_after(init_left, init_right, root);
+            tlink(root) = vlink(root);
+        }
+        return;
+    }
+    if (type(cur) == glyph_node) {
+        set_is_glyph(cur);
+        if (init_left != null)
+            add_kern_before(init_left, cur);
+        left = cur;
+    }
+    while ((cur = vlink(cur)) != null) {
+        if (type(cur) == glyph_node) {
+            set_is_glyph(cur);
+            if (left != null) {
+                add_kern_before(left, cur);
+                if (character(left) < 0 || is_ghost(left)) {
+                    halfword prev = alink(left);
+                    couple_nodes(prev, cur);
+                    flush_node(left);
+                }
+            }
+            left = cur;
+        } else {
+            if (type(cur) == disc_node) {
+                halfword right = type(vlink(cur)) == glyph_node ? vlink(cur) : null;
+                do_handle_kerning(pre_break(cur), left, null);
+                if (vlink_pre_break(cur) != null)
+                    tlink_pre_break(cur) = tail_of_list(vlink_pre_break(cur));
+                do_handle_kerning(post_break(cur), null, right);
+                if (vlink_post_break(cur) != null)
+                    tlink_post_break(cur) = tail_of_list(vlink_post_break(cur));
+                do_handle_kerning(no_break(cur), left, right);
+                if (vlink_no_break(cur) != null)
+                    tlink_no_break(cur) = tail_of_list(vlink_no_break(cur));
+            }
+            if (left != null) {
+                if (character(left) < 0 || is_ghost(left)) {
+                    halfword prev = alink(left);
+                    couple_nodes(prev, cur);
+                    flush_node(left);
+                }
+                left = null;
+            }
+        }
+    }
+    if (left != null) {
+        if (init_right != null)
+            add_kern_after(left, init_right, left);
+        if (character(left) < 0 || is_ghost(left)) {
+            halfword prev = alink(left);
+            halfword next = vlink(left);
+            if (next != null) {
+                couple_nodes(prev, next);
+                tlink(root) = next;
+            } else if (prev != root) {
+                vlink(prev) = null;
+                tlink(root) = prev;
+            } else {
+                vlink(root) = null;
+                tlink(root) = null;
+            }
+            flush_node(left);
+        }
+    }
+}
+
+halfword handle_kerning(halfword head, halfword tail)
+{
+    halfword save_link = null;
+    if (tail == null) {
+        tlink(head) = null;
+        do_handle_kerning(head, null, null);
+    } else {
+        save_link = vlink(tail);
+        vlink(tail) = null;
+        tlink(head) = tail;
+        do_handle_kerning(head, null, null);
+        tail = tlink(head);
+        if (valid_node(save_link)) {
+            try_couple_nodes(tail, save_link);
+        }
+    }
+    return tail;
+}
+
+/*tex The ligaturing and kerning \LUA\ interface: */
+
+static halfword run_lua_ligkern_callback(halfword head, halfword tail, int callback_id)
+{
+    int i;
+    int top = lua_gettop(Luas);
+    if (!get_callback(Luas, callback_id)) {
+        lua_settop(Luas, top);
+        return tail;
+    }
+    nodelist_to_lua(Luas, head);
+    nodelist_to_lua(Luas, tail);
+    if ((i=lua_pcall(Luas, 2, 0, 0)) != 0) {
+        formatted_warning("ligkern","error: %s",lua_tostring(Luas, -1));
+        lua_settop(Luas, top);
+        luatex_error(Luas, (i == LUA_ERRRUN ? 0 : 1));
+        return tail;
+    }
+    if (fix_node_lists) {
+        fix_node_list(head);
+    }
+    lua_settop(Luas, top);
+    return tail;
+}
+
+halfword new_ligkern(halfword head, halfword tail)
+{
+    int callback_id = 0;
+    if (vlink(head) == null)
+        return tail;
+    callback_id = callback_defined(ligaturing_callback);
+    if (callback_id > 0) {
+        tail = run_lua_ligkern_callback(head, tail, callback_id);
+        if (tail == null)
+            tail = tail_of_list(head);
+    } else if (callback_id == 0) {
+        tail = handle_ligaturing(head, tail);
+    }
+    callback_id = callback_defined(kerning_callback);
+    if (callback_id > 0) {
+        tail = run_lua_ligkern_callback(head, tail, callback_id);
+        if (tail == null) {
+            tail = tail_of_list(head);
+        }
+    } else if (callback_id == 0) {
+        halfword nest1 = new_node(nesting_node, 1);
+        halfword cur = vlink(head);
+        halfword aft = vlink(tail);
+        couple_nodes(nest1, cur);
+        tlink(nest1) = tail;
+        vlink(tail) = null;
+        do_handle_kerning(nest1, null, null);
+        couple_nodes(head, vlink(nest1));
+        tail = tlink(nest1);
+        try_couple_nodes(tail, aft);
+        flush_node(nest1);
+    }
+    return tail;
+}
--- texlive-source/texk/web2c/luatexdir/font/writecff.c.me	1970-01-01 01:00:00.000000000 +0100
+++ texlive-source/texk/web2c/luatexdir/font/writecff.c	2020-11-07 15:50:28.081338255 +0100
@@ -0,0 +1,3156 @@
+/*
+
+Copyright 2006-2010 Taco Hoekwater <taco@luatex.org>
+
+This file is part of LuaTeX.
+
+LuaTeX is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 2 of the License, or (at your
+option) any later version.
+
+LuaTeX is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+License for more details.
+
+You should have received a copy of the GNU General Public License along
+with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#include "ptexlib.h"
+#include "lua/luatex-api.h"
+#include "font/writecff.h"
+
+extern int cidset;
+
+#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
+#undef b2
+#undef b3
+
+#define WORK_BUFFER_SIZE 1024
+
+static char work_buffer[WORK_BUFFER_SIZE];
+
+static unsigned long get_unsigned(cff_font * cff, int n)
+{
+    unsigned long v = 0;
+    while (n-- > 0)
+        v = v * 256 + get_card8(cff);
+    return v;
+}
+
+const char *const cff_stdstr[CFF_STDSTR_MAX] = {
+    ".notdef", "space", "exclam", "quotedbl", "numbersign",
+    "dollar", "percent", "ampersand", "quoteright", "parenleft",
+    "parenright", "asterisk", "plus", "comma", "hyphen",
+    "period", "slash", "zero", "one", "two",
+    "three", "four", "five", "six", "seven",
+    "eight", "nine", "colon", "semicolon", "less",
+    "equal", "greater", "question", "at", "A",
+    "B", "C", "D", "E", "F",
+    "G", "H", "I", "J", "K",
+    "L", "M", "N", "O", "P",
+    "Q", "R", "S", "T", "U",
+    "V", "W", "X", "Y", "Z",
+    "bracketleft", "backslash", "bracketright", "asciicircum", "underscore",
+    "quoteleft", "a", "b", "c", "d",
+    "e", "f", "g", "h", "i",
+    "j", "k", "l", "m", "n",
+    "o", "p", "q", "r", "s",
+    "t", "u", "v", "w", "x",
+    "y", "z", "braceleft", "bar", "braceright",
+    "asciitilde", "exclamdown", "cent", "sterling", "fraction",
+    "yen", "florin", "section", "currency", "quotesingle",
+    "quotedblleft", "guillemotleft", "guilsinglleft", "guilsinglright", "fi",
+    "fl", "endash", "dagger", "daggerdbl", "periodcentered",
+    "paragraph", "bullet", "quotesinglbase", "quotedblbase", "quotedblright",
+    "guillemotright", "ellipsis", "perthousand", "questiondown", "grave",
+    "acute", "circumflex", "tilde", "macron", "breve",
+    "dotaccent", "dieresis", "ring", "cedilla", "hungarumlaut",
+    "ogonek", "caron", "emdash", "AE", "ordfeminine",
+    "Lslash", "Oslash", "OE", "ordmasculine", "ae",
+    "dotlessi", "lslash", "oslash", "oe", "germandbls",
+    "onesuperior", "logicalnot", "mu", "trademark", "Eth",
+    "onehalf", "plusminus", "Thorn", "onequarter", "divide",
+    "brokenbar", "degree", "thorn", "threequarters", "twosuperior",
+    "registered", "minus", "eth", "multiply", "threesuperior",
+    "copyright", "Aacute", "Acircumflex", "Adieresis", "Agrave",
+    "Aring", "Atilde", "Ccedilla", "Eacute", "Ecircumflex",
+    "Edieresis", "Egrave", "Iacute", "Icircumflex", "Idieresis",
+    "Igrave", "Ntilde", "Oacute", "Ocircumflex", "Odieresis",
+    "Ograve", "Otilde", "Scaron", "Uacute", "Ucircumflex",
+    "Udieresis", "Ugrave", "Yacute", "Ydieresis", "Zcaron",
+    "aacute", "acircumflex", "adieresis", "agrave", "aring",
+    "atilde", "ccedilla", "eacute", "ecircumflex", "edieresis",
+    "egrave", "iacute", "icircumflex", "idieresis", "igrave",
+    "ntilde", "oacute", "ocircumflex", "odieresis", "ograve",
+    "otilde", "scaron", "uacute", "ucircumflex", "udieresis",
+    "ugrave", "yacute", "ydieresis", "zcaron", "exclamsmall",
+    "Hungarumlautsmall", "dollaroldstyle", "dollarsuperior", "ampersandsmall",
+    "Acutesmall",
+    "parenleftsuperior", "parenrightsuperior", "twodotenleader",
+    "onedotenleader", "zerooldstyle",
+    "oneoldstyle", "twooldstyle", "threeoldstyle", "fouroldstyle",
+    "fiveoldstyle",
+    "sixoldstyle", "sevenoldstyle", "eightoldstyle", "nineoldstyle",
+    "commasuperior",
+    "threequartersemdash", "periodsuperior", "questionsmall", "asuperior",
+    "bsuperior",
+    "centsuperior", "dsuperior", "esuperior", "isuperior", "lsuperior",
+    "msuperior", "nsuperior", "osuperior", "rsuperior", "ssuperior",
+    "tsuperior", "ff", "ffi", "ffl", "parenleftinferior",
+    "parenrightinferior", "Circumflexsmall", "hyphensuperior", "Gravesmall",
+    "Asmall",
+    "Bsmall", "Csmall", "Dsmall", "Esmall", "Fsmall",
+    "Gsmall", "Hsmall", "Ismall", "Jsmall", "Ksmall",
+    "Lsmall", "Msmall", "Nsmall", "Osmall", "Psmall",
+    "Qsmall", "Rsmall", "Ssmall", "Tsmall", "Usmall",
+    "Vsmall", "Wsmall", "Xsmall", "Ysmall", "Zsmall",
+    "colonmonetary", "onefitted", "rupiah", "Tildesmall", "exclamdownsmall",
+    "centoldstyle", "Lslashsmall", "Scaronsmall", "Zcaronsmall",
+    "Dieresissmall",
+    "Brevesmall", "Caronsmall", "Dotaccentsmall", "Macronsmall", "figuredash",
+    "hypheninferior", "Ogoneksmall", "Ringsmall", "Cedillasmall",
+    "questiondownsmall",
+    "oneeighth", "threeeighths", "fiveeighths", "seveneighths", "onethird",
+    "twothirds", "zerosuperior", "foursuperior", "fivesuperior", "sixsuperior",
+    "sevensuperior", "eightsuperior", "ninesuperior", "zeroinferior",
+    "oneinferior",
+    "twoinferior", "threeinferior", "fourinferior", "fiveinferior",
+    "sixinferior",
+    "seveninferior", "eightinferior", "nineinferior", "centinferior",
+    "dollarinferior",
+    "periodinferior", "commainferior", "Agravesmall", "Aacutesmall",
+    "Acircumflexsmall",
+    "Atildesmall", "Adieresissmall", "Aringsmall", "AEsmall", "Ccedillasmall",
+    "Egravesmall", "Eacutesmall", "Ecircumflexsmall", "Edieresissmall",
+    "Igravesmall",
+    "Iacutesmall", "Icircumflexsmall", "Idieresissmall", "Ethsmall",
+    "Ntildesmall",
+    "Ogravesmall", "Oacutesmall", "Ocircumflexsmall", "Otildesmall",
+    "Odieresissmall",
+    "OEsmall", "Oslashsmall", "Ugravesmall", "Uacutesmall", "Ucircumflexsmall",
+    "Udieresissmall", "Yacutesmall", "Thornsmall", "Ydieresissmall",
+    "001.000", "001.001", "001.002", "001.003",
+    "Black", "Bold", "Book", "Light", "Medium", "Regular", "Roman", "Semibold"
+};
+
+/*tex Only read the header part and forget about the body */
+
+cff_index *cff_get_index_header(cff_font * cff)
+{
+    cff_index *idx;
+    card16 i, count;
+    idx = xcalloc(1, sizeof(cff_index));
+    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 (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;
+        idx->offset = NULL;
+        idx->data = NULL;
+    }
+    return idx;
+}
+
+cff_index *cff_get_index(cff_font * cff)
+{
+    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 (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;
+        idx->data = NULL;
+    }
+    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)
+{
+    /*tex 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;
+    idx->offset[1] = length + 1;
+    idx->data = xmalloc((unsigned) length * sizeof(card8));
+    memcpy(idx->data, &cff->stream[cff->offset], length );
+    cff->offset += length ;
+    return idx;
+}
+
+long cff_pack_index(cff_index * idx, card8 * dest, long destlen)
+{
+    long len = 0;
+    unsigned long datalen;
+    card16 i;
+    if (idx->count < 1) {
+        if (destlen < 2)
+            normal_error("cff","not enough space available");
+        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;
+        for (i = 0; i <= idx->count; i++) {
+            *(dest++) = (card8) (idx->offset[i] & 0xff);
+        }
+    } else if (datalen < 0xffffUL) {
+        idx->offsize = 2;
+        *(dest++) = 2;
+        for (i = 0; i <= idx->count; i++) {
+            *(dest++) = (card8) ((idx->offset[i] >> 8) & 0xff);
+            *(dest++) = (card8) (idx->offset[i] & 0xff);
+        }
+    } else if (datalen < 0xffffffUL) {
+        idx->offsize = 3;
+        *(dest++) = 3;
+        for (i = 0; i <= idx->count; i++) {
+            *(dest++) = (card8) ((idx->offset[i] >> 16) & 0xff);
+            *(dest++) = (card8) ((idx->offset[i] >> 8) & 0xff);
+            *(dest++) = (card8) (idx->offset[i] & 0xff);
+        }
+    } else {
+        idx->offsize = 4;
+        *(dest++) = 4;
+        for (i = 0; i <= idx->count; i++) {
+            *(dest++) = (card8) ((idx->offset[i] >> 24) & 0xff);
+            *(dest++) = (card8) ((idx->offset[i] >> 16) & 0xff);
+            *(dest++) = (card8) ((idx->offset[i] >> 8) & 0xff);
+            *(dest++) = (card8) (idx->offset[i] & 0xff);
+        }
+    }
+    memmove(dest, idx->data, idx->offset[idx->count] - 1);
+    return len;
+}
+
+long cff_index_size(cff_index * idx)
+{
+    if (idx->count > 0) {
+        l_offset datalen;
+        datalen = idx->offset[idx->count] - 1;
+        if (datalen < 0xffUL) {
+            idx->offsize = 1;
+        } else if (datalen < 0xffffUL) {
+            idx->offsize = 2;
+        } else if (datalen < 0xffffffUL) {
+            idx->offsize = 3;
+        } else {
+            idx->offsize = 4;
+        }
+        return (3 + (idx->offsize) * (idx->count + 1) + (long) datalen);
+    } else {
+        return 2;
+    }
+}
+
+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;
+    } else {
+        idx->offset = NULL;
+    }
+    idx->data = NULL;
+    return idx;
+}
+
+void cff_release_index(cff_index * idx)
+{
+    if (idx) {
+        xfree(idx->data);
+        xfree(idx->offset);
+        xfree(idx);
+    }
+}
+
+void cff_release_dict(cff_dict * dict)
+{
+    if (dict) {
+        if (dict->entries) {
+            int i;
+            for (i = 0; i < dict->count; i++) {
+                xfree((dict->entries)[i].values);
+            }
+            xfree(dict->entries);
+        }
+        xfree(dict);
+    }
+}
+
+void cff_release_encoding(cff_encoding * encoding)
+{
+    if (encoding) {
+        switch (encoding->format & (~0x80)) {
+        case 0:
+            xfree(encoding->data.codes);
+            break;
+        case 1:
+            xfree(encoding->data.range1);
+            break;
+        default:
+            normal_error("cff","unknown encoding format");
+        }
+        if (encoding->format & 0x80)
+            xfree(encoding->supp);
+        xfree(encoding);
+    }
+}
+
+void cff_release_charsets(cff_charsets * charset)
+{
+    if (charset) {
+        switch (charset->format) {
+        case 0:
+            xfree(charset->data.glyphs);
+            break;
+        case 1:
+            xfree(charset->data.range1);
+            break;
+        case 2:
+            xfree(charset->data.range2);
+            break;
+        default:
+            break;
+        }
+        xfree(charset);
+    }
+}
+
+void cff_release_fdselect(cff_fdselect * fdselect)
+{
+    if (fdselect) {
+        if (fdselect->format == 0) {
+            xfree(fdselect->data.fds);
+        } else if (fdselect->format == 3) {
+            xfree(fdselect->data.ranges);
+        }
+        xfree(fdselect);
+    }
+}
+
+void cff_close(cff_font * cff)
+{
+    card16 i;
+    if (cff) {
+        xfree(cff->fontname);
+        if (cff->name)
+            cff_release_index(cff->name);
+        if (cff->topdict)
+            cff_release_dict(cff->topdict);
+        if (cff->string)
+            cff_release_index(cff->string);
+        if (cff->gsubr)
+            cff_release_index(cff->gsubr);
+        if (cff->encoding)
+            cff_release_encoding(cff->encoding);
+        if (cff->charsets)
+            cff_release_charsets(cff->charsets);
+        if (cff->fdselect)
+            cff_release_fdselect(cff->fdselect);
+        if (cff->cstrings)
+            cff_release_index(cff->cstrings);
+        if (cff->fdarray) {
+            for (i = 0; i < cff->num_fds; i++) {
+                if (cff->fdarray[i])
+                    cff_release_dict(cff->fdarray[i]);
+            }
+            xfree(cff->fdarray);
+        }
+        if (cff->private) {
+            for (i = 0; i < cff->num_fds; i++) {
+                if (cff->private[i])
+                    cff_release_dict(cff->private[i]);
+            }
+            xfree(cff->private);
+        }
+        if (cff->subrs) {
+            for (i = 0; i < cff->num_fds; i++) {
+                if (cff->subrs[i])
+                    cff_release_index(cff->subrs[i]);
+            }
+            xfree(cff->subrs);
+        }
+        if (cff->_string)
+            cff_release_index(cff->_string);
+        xfree(cff);
+    }
+    return;
+}
+
+char *cff_get_name(cff_font * cff)
+{
+    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;
+}
+
+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;
+    idx->offset = xmalloc(2 * sizeof(l_offset));
+    (idx->offset)[0] = 1;
+    (idx->offset)[1] = strlen(name) + 1;
+    idx->data = xmalloc((unsigned) strlen(name) * sizeof(card8));
+    /*tex No trailing |\0| */
+    memmove(idx->data, name, strlen(name));
+    return (long) (5 + strlen(name));
+}
+
+long cff_put_header(cff_font * cff, card8 * dest, long destlen)
+{
+    if (destlen < 4)
+        normal_error("cff","not enough space available");
+    /*tex cff->header_major */
+    *(dest++) = 1;
+    *(dest++) = cff->header_minor;
+    *(dest++) = 4;
+    /*tex
+        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;
+}
+
+#define CFF_PARSE_OK                    0
+#define CFF_CFF_ERROR_PARSE_CFF_ERROR  -1
+#define CFF_CFF_ERROR_STACK_OVERFLOW   -2
+#define CFF_CFF_ERROR_STACK_UNDERFLOW  -3
+#define CFF_CFF_ERROR_STACK_RANGECHECK -4
+
+#define DICT_ENTRY_MAX 16
+
+cff_dict *cff_new_dict(void)
+{
+    cff_dict *dict;
+    dict = xcalloc(1, sizeof(cff_dict));
+    dict->max = DICT_ENTRY_MAX;
+    dict->count = 0;
+    dict->entries = xcalloc((unsigned) dict->max, sizeof(cff_dict_entry));
+    return dict;
+}
+
+/*tex
+
+    Operand stack: only numbers are stored (as double). Operand types are:
+
+    \startitemize
+    \startitem number:  double (integer or real) \stopitem
+    \startitem boolean: stored as a number       \stopitem
+    \startitem SID:     stored as a number       \stopitem
+    \startitem array:   array of numbers         \stopitem
+    \startitem delta:   array of numbers         \stopitem
+    \stopitemize
+
+*/
+
+#define CFF_DICT_STACK_LIMIT 64
+static int stack_top = 0;
+static double arg_stack[CFF_DICT_STACK_LIMIT];
+
+/* The CFF DICT encoding: */
+
+#define CFF_LAST_DICT_OP1 26
+#define CFF_LAST_DICT_OP2 39
+#define CFF_LAST_DICT_OP (CFF_LAST_DICT_OP1 + CFF_LAST_DICT_OP2)
+
+static struct {
+    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 },
+    { "UniqueID", CFF_TYPE_NUMBER },
+    { "XUID", CFF_TYPE_ARRAY },
+    { "charset", CFF_TYPE_OFFSET },
+    { "Encoding", CFF_TYPE_OFFSET },
+    { "CharStrings", CFF_TYPE_OFFSET },
+    { "Private", CFF_TYPE_SZOFF },
+    { "Subrs", CFF_TYPE_OFFSET },
+    { "defaultWidthX", CFF_TYPE_NUMBER },
+    { "nominalWidthX", CFF_TYPE_NUMBER },
+    { NULL, -1 },
+    { NULL, -1 },
+    /*tex two CFF2 instructions */
+    { "vstore", CFF_TYPE_OFFSET },
+    { "maxstack", CFF_TYPE_NUMBER },
+    /*tex 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 }
+};
+
+/*tex Parse DICT data */
+
+static double get_integer(card8 ** data, card8 * endptr, int *status)
+{
+    long result = 0;
+    card8 b0, b1, b2;
+
+    b0 = *(*data)++;
+    if (b0 == 28 && *data < endptr - 2) {
+        /*tex shortint */
+        b1 = *(*data)++;
+        b2 = *(*data)++;
+        result = b1 * 256 + b2;
+        if (result > 0x7fffL)
+            result -= 0x10000L;
+    } else if (b0 == 29 && *data < endptr - 4) {
+        /*tex longint */
+        int i;
+        result = *(*data)++;
+        if (result > 0x7f)
+            result -= 0x100;
+        for (i = 0; i < 3; i++) {
+            result = result * 256 + (**data);
+            *data += 1;
+        }
+    } else if (b0 >= 32 && b0 <= 246) {
+        /*tex int (1) */
+        result = b0 - 139;
+    } else if (b0 >= 247 && b0 <= 250) {
+        /*tex int (2) */
+        b1 = *(*data)++;
+        result = (b0 - 247) * 256 + b1 + 108;
+    } else if (b0 >= 251 && b0 <= 254) {
+        b1 = *(*data)++;
+        result = -(b0 - 251) * 256 - b1 - 108;
+    } else {
+        *status = CFF_CFF_ERROR_PARSE_CFF_ERROR;
+    }
+    return (double) result;
+}
+
+/*tex Simply uses |strtod|: */
+
+static double get_real(card8 ** data, card8 * endptr, int *status)
+{
+    double result = 0.0;
+    int nibble = 0, pos = 0;
+    int len = 0, fail = 0;
+
+    if (**data != 30 || *data >= endptr - 1) {
+        *status = CFF_CFF_ERROR_PARSE_CFF_ERROR;
+        return 0.0;
+    }
+    /*tex Skip the first byte (30): */
+    *data += 1;
+    pos = 0;
+    while ((!fail) && len < WORK_BUFFER_SIZE - 2 && *data < endptr) {
+        /*tex Get a nibble. */
+        if (pos % 2) {
+            nibble = **data & 0x0f;
+            *data += 1;
+        } else {
+            nibble = (**data >> 4) & 0x0f;
+        }
+        if (nibble >= 0x00 && nibble <= 0x09) {
+            work_buffer[len++] = (char) (nibble + '0');
+        } else if (nibble == 0x0a) {    /* . */
+            work_buffer[len++] = '.';
+        } else if (nibble == 0x0b || nibble == 0x0c) {
+            /*tex E, E- */
+            work_buffer[len++] = 'e';
+            if (nibble == 0x0c)
+                work_buffer[len++] = '-';
+        } else if (nibble == 0x0e) {
+            /*tex the minus */
+            work_buffer[len++] = '-';
+        } else if (nibble == 0x0d) {
+            /*tex do nothing */
+        } else if (nibble == 0x0f) {
+            /*tex we're done */
+            work_buffer[len++] = '\0';
+            if (((pos % 2) == 0) && (**data != 0xff)) {
+                fail = 1;
+            }
+            break;
+        } else {
+            /*tex invalid */
+            fail = 1;
+        }
+        pos++;
+    }
+    /*tex the returned values */
+    if (fail || nibble != 0x0f) {
+        *status = CFF_CFF_ERROR_PARSE_CFF_ERROR;
+    } else {
+        char *s;
+        errno=0;
+        result = strtod(work_buffer, &s);
+        if ((result==0.0 && work_buffer==s) || errno) {
+              /*tex Conversion is not possible. */
+             *status = CFF_CFF_ERROR_PARSE_CFF_ERROR;
+         }
+    }
+    return result;
+}
+
+/*tex Operators */
+
+static void add_dict(cff_dict * dict, card8 ** data, card8 * endptr, int *status)
+{
+    int id, argtype, t;
+    id = **data;
+    if (id == 0x0c) {
+        *data += 1;
+        if (*data >= endptr ||
+            (id = **data + CFF_LAST_DICT_OP1) >= CFF_LAST_DICT_OP) {
+            *status = CFF_CFF_ERROR_PARSE_CFF_ERROR;
+            return;
+        }
+    } else if (id >= CFF_LAST_DICT_OP1) {
+        *status = CFF_CFF_ERROR_PARSE_CFF_ERROR;
+        return;
+    }
+    argtype = dict_operator[id].argtype;
+    if (dict_operator[id].opname == NULL || argtype < 0) {
+        *status = CFF_CFF_ERROR_PARSE_CFF_ERROR;
+        return;
+    }
+    if (dict->count >= dict->max) {
+        dict->max += DICT_ENTRY_MAX;
+        /*tex Not zeroed! */
+        dict->entries = xrealloc(dict->entries, (unsigned) ((unsigned) dict->max * sizeof(cff_dict_entry)));
+    }
+    (dict->entries)[dict->count].id = id;
+    (dict->entries)[dict->count].key = dict_operator[id].opname;
+    if (argtype == CFF_TYPE_NUMBER ||
+        argtype == CFF_TYPE_BOOLEAN ||
+        argtype == CFF_TYPE_SID || argtype == CFF_TYPE_OFFSET) {
+        /*tex Check for underflow here, as exactly one operand is expected. */
+        if (stack_top < 1) {
+            *status = CFF_CFF_ERROR_STACK_UNDERFLOW;
+            return;
+        }
+        stack_top--;
+        (dict->entries)[dict->count].count = 1;
+        (dict->entries)[dict->count].values = xcalloc(1, sizeof(double));
+        (dict->entries)[dict->count].values[0] = arg_stack[stack_top];
+        dict->count += 1;
+    } else {
+        /*tex
+            Just ignore operator if there were no operands provided. Don't treat
+            this as underflow, e.g. |StemSnapV| in |TemporaLGCUni-Italic.otf|.
+        */
+        if ((t = stack_top) > 0) {
+            (dict->entries)[dict->count].count = stack_top;
+            (dict->entries)[dict->count].values =
+                xmalloc((unsigned) ((unsigned) stack_top * sizeof(double)));
+            while (stack_top > 0) {
+                stack_top--;
+                (dict->entries)[dict->count].values[stack_top] =
+                    arg_stack[stack_top];
+            }
+            if (t > 3 && strcmp(dict_operator[id].opname, "FontMatrix") == 0) {
+                (dict->entries)[dict->count].values[0] = 0.001;
+                (dict->entries)[dict->count].values[3] = 0.001;
+            }
+            dict->count += 1;
+        }
+    }
+    *data += 1;
+    return;
+}
+
+/*tex
+
+    All operands are treated as number or array of numbers.
+
+    \startitemize
+    \startitem |Private|: two numbers, size and offset     \stopitem
+    \startitem |ROS|: hree numbers, SID, SID, and a number \stopitem
+    \stopitemize
+
+*/
+
+cff_dict *cff_dict_unpack(card8 * data, card8 * endptr)
+{
+    cff_dict *dict;
+    int status = CFF_PARSE_OK;
+    stack_top = 0;
+    dict = cff_new_dict();
+    while (data < endptr && status == CFF_PARSE_OK) {
+        if (*data < CFF_LAST_DICT_OP1) {
+            /*tex Some operator. */
+            add_dict(dict, &data, endptr, &status);
+        } else if (*data == 30) {
+            /*tex First byte of a sequence (variable). */
+            if (stack_top < CFF_DICT_STACK_LIMIT) {
+                arg_stack[stack_top] = get_real(&data, endptr, &status);
+                stack_top++;
+            } else {
+                status = CFF_CFF_ERROR_STACK_OVERFLOW;
+            }
+        } else if (*data == 255 || (*data >= CFF_LAST_DICT_OP1 && *data <= 27)) {
+            /*tex Reserved. */
+            data++;
+        } else {
+            /*tex Everything else is an integer. */
+            if (stack_top < CFF_DICT_STACK_LIMIT) {
+                arg_stack[stack_top] = get_integer(&data, endptr, &status);
+                stack_top++;
+            } else {
+                status = CFF_CFF_ERROR_STACK_OVERFLOW;
+            }
+        }
+    }
+    if (status != CFF_PARSE_OK) {
+        formatted_error("cff","parsing DICT failed (error=%d)", status);
+    } else if (stack_top != 0) {
+        normal_warning("cff","garbage in DICT data");
+        stack_top = 0;
+    }
+    return dict;
+}
+
+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;
+}
+
+double cff_dict_get(cff_dict * dict, const char *key, int idx)
+{
+    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)
+                value = (dict->entries)[i].values[idx];
+            else
+                normal_error("cff","invalid index number");
+            break;
+        }
+    }
+    if (i == dict->count)
+        formatted_error("cff","DICT entry '%s' not found", key);
+    return value;
+}
+
+card8 cff_fdselect_lookup(cff_font * cff, card16 gid)
+{
+    card8 fd = 0xff;
+    cff_fdselect *fdsel;
+    if (cff->fdselect == NULL)
+        normal_error("cff","FDSelect not available");
+    fdsel = cff->fdselect;
+    if (gid >= cff->num_glyphs)
+        normal_error("cff","invalid glyph index");
+    switch (fdsel->format) {
+        case 0:
+            fd = fdsel->data.fds[gid];
+            break;
+        case 3:
+            {
+                if (gid == 0) {
+                    fd = (fdsel->data).ranges[0].fd;
+                } else {
+                    card16 i;
+                    for (i = 1; i < (fdsel->num_entries); i++) {
+                        if (gid < (fdsel->data).ranges[i].first)
+                            break;
+                    }
+                    fd = (fdsel->data).ranges[i - 1].fd;
+                }
+            }
+            break;
+        default:
+            normal_error("cff","invalid FDSelect format");
+            break;
+    }
+    if (fd >= cff->num_fds)
+        normal_error("cff","invalid Font DICT index");
+    return fd;
+}
+
+long cff_read_subrs(cff_font * cff)
+{
+    long len = 0;
+    long offset;
+    int i;
+    if ((cff->flag & FONTTYPE_CIDFONT) && cff->fdselect == NULL) {
+        cff_read_fdselect(cff);
+    }
+    if ((cff->flag & FONTTYPE_CIDFONT) && cff->fdarray == NULL) {
+        cff_read_fdarray(cff);
+    }
+    if (cff->private == NULL)
+        cff_read_private(cff);
+    if (cff->gsubr == NULL) {
+        cff->offset = cff->gsubr_offset;
+        cff->gsubr = cff_get_index(cff);
+    }
+    cff->subrs = xcalloc(cff->num_fds, sizeof(cff_index *));
+    if (cff->flag & FONTTYPE_CIDFONT) {
+        for (i = 0; i < cff->num_fds; i++) {
+            if (cff->private[i] == NULL ||
+                !cff_dict_known(cff->private[i], "Subrs")) {
+                (cff->subrs)[i] = NULL;
+            } else {
+                offset = (long) cff_dict_get(cff->fdarray[i], "Private", 1);
+                offset += (long) cff_dict_get(cff->private[i], "Subrs", 0);
+                cff->offset = (l_offset) offset;
+                (cff->subrs)[i] = cff_get_index(cff);
+                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 {
+        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;
+}
+
+long cff_read_fdarray(cff_font * cff)
+{
+    long len = 0;
+    cff_index *idx;
+    long offset, size;
+    card16 i;
+    if (cff->topdict == NULL)
+        normal_error("cff","top DICT not found");
+    if (!(cff->flag & FONTTYPE_CIDFONT))
+        return 0;
+    offset = (long) cff_dict_get(cff->topdict, "FDArray", 0);
+    cff->offset = (l_offset) offset;
+    idx = cff_get_index(cff);
+    cff->num_fds = (card8) idx->count;
+    cff->fdarray = xmalloc((unsigned) (idx->count * sizeof(cff_dict *)));
+    for (i = 0; i < idx->count; i++) {
+        card8 *data = idx->data + (idx->offset)[i] - 1;
+        size = (long) ((idx->offset)[i + 1] - (idx->offset)[i]);
+        if (size > 0) {
+            (cff->fdarray)[i] = cff_dict_unpack(data, data + size);
+        } else {
+            (cff->fdarray)[i] = NULL;
+        }
+    }
+    len = cff_index_size(idx);
+    cff_release_index(idx);
+    return len;
+}
+
+long cff_read_private(cff_font * cff)
+{
+    long len = 0;
+    card8 *data;
+    long offset, size;
+    if (cff->flag & FONTTYPE_CIDFONT) {
+        int i;
+        if (cff->fdarray == NULL)
+            cff_read_fdarray(cff);
+        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) {
+                offset = (long) cff_dict_get(cff->fdarray[i], "Private", 1);
+                cff->offset = (l_offset) offset;
+                data = xmalloc((unsigned) size * sizeof(card8));
+                memcpy(data, &cff->stream[cff->offset], (size_t) size);
+                cff->offset = (l_offset) size;
+                (cff->private)[i] = cff_dict_unpack(data, data + size);
+                xfree(data);
+                len += size;
+            } else {
+                (cff->private)[i] = NULL;
+            }
+        }
+    } else {
+        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) {
+            offset = (long) cff_dict_get(cff->topdict, "Private", 1);
+            cff->offset = (l_offset) offset;
+            data = xmalloc((unsigned) size * sizeof(card8));
+            memcpy(data, &cff->stream[cff->offset], (size_t) size);
+            cff->offset = (l_offset) size;
+            cff->private[0] = cff_dict_unpack(data, data + size);
+            xfree(data);
+            len += size;
+        } else {
+            (cff->private)[0] = NULL;
+            len = 0;
+        }
+    }
+    return len;
+}
+
+cff_font *read_cff(unsigned char *buf, long buflength, int n)
+{
+    cff_font *cff;
+    cff_index *idx;
+    long offset;
+    cff = xcalloc(1, sizeof(cff_font));
+    cff->stream = buf;
+    cff->stream_size = (l_offset) buflength;
+    cff->index = n;
+    cff->header_major = get_card8(cff);
+    cff->header_minor = get_card8(cff);
+    cff->header_hdr_size = get_card8(cff);
+    if (cff->header_major == 2) {
+        /*tex 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 > 2) {
+        formatted_warning("cff","major version %u not supported", cff->header_major);
+        cff_close(cff);
+        return NULL;
+    }
+    cff->offset = cff->header_hdr_size;
+    /*tex The name index. */
+    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);
+    }
+    /*tex The top dict index. */
+    if (cff->header_major == 2) {
+        /*tex we fake an index (just one entry) */
+        idx = cff_get_index2(cff);
+    } else {
+        idx = cff_get_index(cff);
+    }
+    if (n > idx->count - 1) {
+        normal_warning("cff","top DICT not exist");
+        cff_close(cff);
+        return NULL;
+    }
+    cff->topdict = cff_dict_unpack(idx->data + idx->offset[n] - 1, idx->data + idx->offset[n + 1] - 1);
+    if (!cff->topdict) {
+        normal_warning("cff","parsing top DICT data failed");
+        cff_close(cff);
+        return NULL;
+    }
+    cff_release_index(idx);
+    if (cff_dict_known(cff->topdict, "CharstringType") &&
+        cff_dict_get(cff->topdict, "CharstringType", 0) != 2) {
+        normal_warning("cff","only type 2 charstrings supported");
+        cff_close(cff);
+        return NULL;
+    }
+    if (cff_dict_known(cff->topdict, "SyntheticBase")) {
+        normal_warning("cff","synthetic font not supported");
+        cff_close(cff);
+        return NULL;
+    }
+    /*tex The string index. */
+    if (cff->header_major == 2) {
+        /*tex do nothing */
+    } else {
+        cff->string = cff_get_index(cff);
+    }
+    /*tex The offset to subroutines. */
+    cff->gsubr_offset = cff->offset;
+    /*tex The number of glyphs. */
+    offset = (long) cff_dict_get(cff->topdict, "CharStrings", 0);
+    cff->offset = (l_offset) offset;
+    cff->num_glyphs = get_card16(cff);
+    /*tex Check for font type. */
+    if (cff_dict_known(cff->topdict, "ROS")) {
+        cff->flag |= FONTTYPE_CIDFONT;
+    } else {
+        cff->flag |= FONTTYPE_FONT;
+    }
+    /*tex Check for the encoding. */
+    if (cff_dict_known(cff->topdict, "Encoding")) {
+        offset = (long) cff_dict_get(cff->topdict, "Encoding", 0);
+        if (offset == 0) {      /* predefined */
+            cff->flag |= ENCODING_STANDARD;
+        } else if (offset == 1) {
+            cff->flag |= ENCODING_EXPERT;
+        }
+    } else {
+        cff->flag |= ENCODING_STANDARD;
+    }
+    cff->offset = cff->gsubr_offset;
+    return cff;
+}
+
+/*tex Write CFF data for an \OPENTYPE\ font. We need to pack dictionary data. */
+
+static long pack_integer(card8 * dest, long destlen, long value)
+{
+    long len = 0;
+    if (value >= -107 && value <= 107) {
+        if (destlen < 1)
+            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 (2)");
+        value = (long) 0xf700u + value - 108;
+        dest[0] = (card8) ((value >> 8) & 0xff);
+        dest[1] = (card8) (value & 0xff);
+        len = 2;
+    } else if (value >= -1131 && value <= -108) {
+        if (destlen < 2)
+            normal_error("cff","buffer overflow (3)");
+        value = (long) 0xfb00u - value - 108;
+        dest[0] = (card8) ((value >> 8) & 0xff);
+        dest[1] = (card8) (value & 0xff);
+        len = 2;
+    } else if (value >= -32768 && value <= 32767) {
+        /*tex shortint */
+        if (destlen < 3)
+            normal_error("cff","buffer overflow (4)");
+        dest[0] = 28;
+        dest[1] = (card8) ((value >> 8) & 0xff);
+        dest[2] = (card8) (value & 0xff);
+        len = 3;
+    } else {
+        /*tex longint */
+        if (destlen < 5)
+            normal_error("cff","buffer overflow (5)");
+        dest[0] = 29;
+        dest[1] = (card8) ((value >> 24) & 0xff);
+        dest[2] = (card8) ((value >> 16) & 0xff);
+        dest[3] = (card8) ((value >> 8) & 0xff);
+        dest[4] = (card8) (value & 0xff);
+        len = 5;
+    }
+    return len;
+}
+
+static long pack_real(card8 * dest, long destlen, double value)
+{
+    long e;
+    int i = 0, pos = 2;
+    int res;
+#define CFF_REAL_MAX_LEN 17
+    if (destlen < 2)
+        normal_error("cff","buffer overflow (6)");
+    dest[0] = 30;
+    if (value == 0.0) {
+        dest[1] = 0x0f;
+        return 2;
+    }
+    if (value < 0.0) {
+        dest[1] = 0xe0;
+        value *= -1.0;
+        pos++;
+    }
+    e = 0;
+    if (value >= 10.0) {
+        while (value >= 10.0) {
+            value /= 10.0;
+            e++;
+        }
+    } else if (value < 1.0) {
+        while (value < 1.0) {
+            value *= 10.0;
+            e--;
+        }
+    }
+    res = sprintf(work_buffer, "%1.14g", value);
+    if (res<0)
+        normal_error("cff","invalid conversion");
+    if (res>CFF_REAL_MAX_LEN)
+        res=CFF_REAL_MAX_LEN;
+    for (i = 0; i < res; i++) {
+        unsigned char ch = 0;
+        if (work_buffer[i] == '\0') {
+            /*tex In fact |res| should prevent this. */
+            break;
+        } else if (work_buffer[i] == '.') {
+            ch = 0x0a;
+        } else if (work_buffer[i] >= '0' && work_buffer[i] <= '9') {
+            ch = (unsigned char) (work_buffer[i] - '0');
+        } else {
+            normal_error("cff","invalid character");
+        }
+        if (destlen < pos / 2 + 1)
+            normal_error("cff","buffer overflow (7)");
+
+        if (pos % 2) {
+            dest[pos / 2] = (card8) (dest[pos / 2] + ch);
+        } else {
+            dest[pos / 2] = (card8) (ch << 4);
+        }
+        pos++;
+    }
+    if (e > 0) {
+        if (pos % 2) {
+            dest[pos / 2] = (card8) (dest[pos / 2] + 0x0b);
+        } else {
+            if (destlen < pos / 2 + 1)
+                normal_error("cff","buffer overflow (8)");
+            dest[pos / 2] = (card8) (0xb0);
+        }
+        pos++;
+    } else if (e < 0) {
+        if (pos % 2) {
+            dest[pos / 2] = (card8) (dest[pos / 2] + 0x0c);
+        } else {
+            if (destlen < pos / 2 + 1)
+                normal_error("cff","buffer overflow (9)");
+            dest[pos / 2] = (card8) (0xc0);
+        }
+        e *= -1;
+        pos++;
+    }
+    if (e != 0) {
+        sprintf(work_buffer, "%ld", e);
+        for (i = 0; i < CFF_REAL_MAX_LEN; i++) {
+            unsigned char ch = 0;
+            if (work_buffer[i] == '\0') {
+                break;
+            } else if (work_buffer[i] == '.') {
+                ch = 0x0a;
+            } else if (work_buffer[i] >= '0' && work_buffer[i] <= '9') {
+                ch = (unsigned char) (work_buffer[i] - '0');
+            } else {
+                normal_error("cff","invalid character");
+            }
+            if (destlen < pos / 2 + 1)
+                normal_error("cff","buffer overflow (10)");
+            if (pos % 2) {
+                dest[pos / 2] = (card8) (dest[pos / 2] + ch);
+            } else {
+                dest[pos / 2] = (card8) (ch << 4);
+            }
+            pos++;
+        }
+    }
+    if (pos % 2) {
+        dest[pos / 2] = (card8) (dest[pos / 2] + 0x0f);
+        pos++;
+    } else {
+        if (destlen < pos / 2 + 1)
+            normal_error("cff","buffer overflow (11)");
+        dest[pos / 2] = (card8) (0xff);
+        pos += 2;
+    }
+    return pos / 2;
+}
+
+static long cff_dict_put_number(double value, card8 * dest, long destlen, int type)
+{
+    long len = 0;
+    double nearint;
+    nearint = floor(value + 0.5);
+    if (type == CFF_TYPE_OFFSET) {
+        long lvalue;
+        lvalue = (long) value;
+        if (destlen < 5)
+            normal_error("cff","buffer overflow (12)");
+        dest[0] = 29;
+        dest[1] = (card8) ((lvalue >> 24) & 0xff);
+        dest[2] = (card8) ((lvalue >> 16) & 0xff);
+        dest[3] = (card8) ((lvalue >> 8) & 0xff);
+        dest[4] = (card8) (lvalue & 0xff);
+        len = 5;
+    } else if (value > CFF_INT_MAX || value < CFF_INT_MIN || (fabs(value - nearint) > 1.0e-5)) {
+        /*tex A real */
+        len = pack_real(dest, destlen, value);
+    } else {
+        /*tex An integer */
+        len = pack_integer(dest, destlen, (long) nearint);
+    }
+    return len;
+}
+
+static long put_dict_entry(cff_dict_entry * de, card8 * dest, long destlen)
+{
+    long len = 0;
+    int i, type, id;
+    if (de->count > 0) {
+        id = de->id;
+        if (dict_operator[id].argtype == CFF_TYPE_OFFSET ||
+            dict_operator[id].argtype == CFF_TYPE_SZOFF) {
+            type = CFF_TYPE_OFFSET;
+        } else {
+            type = CFF_TYPE_NUMBER;
+        }
+        for (i = 0; i < de->count; i++) {
+            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 (13)");
+            dest[len++] = (card8) id;
+        } else if (id >= 0 && id < CFF_LAST_DICT_OP) {
+            if (len + 2 > destlen)
+                normal_error("cff","buffer overflow (14)");
+            dest[len++] = 12;
+            dest[len++] = (card8) (id - CFF_LAST_DICT_OP1);
+        } else {
+            normal_error("cff","invalid DICT operator ID");
+        }
+    }
+    return len;
+}
+
+long cff_dict_pack(cff_dict * dict, card8 * dest, long destlen)
+{
+    long len = 0;
+    int i;
+    for (i = 0; i < dict->count; i++) {
+        if (!strcmp(dict->entries[i].key, "ROS")) {
+            len += put_dict_entry(&dict->entries[i], dest, destlen);
+            break;
+        }
+    }
+    for (i = 0; i < dict->count; i++) {
+        if (strcmp(dict->entries[i].key, "ROS")) {
+            len += put_dict_entry(&dict->entries[i], dest + len, destlen - len);
+        }
+    }
+    return len;
+}
+
+void cff_dict_add(cff_dict * dict, const char *key, int count)
+{
+    int id, i;
+    for (id = 0; id < CFF_LAST_DICT_OP; id++) {
+        if (key && dict_operator[id].opname &&
+            strcmp(dict_operator[id].opname, key) == 0)
+            break;
+    }
+    if (id == CFF_LAST_DICT_OP)
+        normal_error("cff","unknown DICT operator");
+    for (i = 0; i < dict->count; i++) {
+        if ((dict->entries)[i].id == id) {
+            if ((dict->entries)[i].count != count)
+                normal_error("cff","inconsistent DICT argument number");
+            return;
+        }
+    }
+    if (dict->count + 1 >= dict->max) {
+        dict->max += 8;
+        dict->entries =
+            xrealloc(dict->entries, (unsigned) ((unsigned) dict->max * sizeof(cff_dict_entry)));
+    }
+    (dict->entries)[dict->count].id = id;
+    (dict->entries)[dict->count].key = dict_operator[id].opname;
+    (dict->entries)[dict->count].count = count;
+    if (count > 0) {
+        (dict->entries)[dict->count].values = xcalloc((unsigned) count, sizeof(double));
+    } else {
+        (dict->entries)[dict->count].values = NULL;
+    }
+    dict->count += 1;
+    return;
+}
+
+void cff_dict_remove(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;
+            xfree((dict->entries)[i].values);
+        }
+    }
+}
+
+void cff_dict_set(cff_dict * dict, const char *key, int idx, double value)
+{
+    int i;
+    for (i = 0; i < dict->count; i++) {
+        if (strcmp(key, (dict->entries)[i].key) == 0) {
+            if ((dict->entries)[i].count > idx)
+                (dict->entries)[i].values[idx] = value;
+            else
+                normal_error("cff","invalid index number");
+            break;
+        }
+    }
+    if (i == dict->count)
+        formatted_error("cff","DICT entry '%s' not found", key);
+}
+
+
+/*tex Strings */
+
+char *cff_get_string(cff_font * cff, s_SID id)
+{
+    char *result = NULL;
+    size_t len;
+    if (id < CFF_STDSTR_MAX) {
+        len = strlen(cff_stdstr[id]);
+        result = xmalloc((unsigned) (len + 1) * sizeof(char));
+        memcpy(result, cff_stdstr[id], len);
+        result[len] = '\0';
+    } else if (cff && cff->string) {
+        cff_index *strings = cff->string;
+        id = (s_SID) (id - CFF_STDSTR_MAX);
+        if (id < strings->count) {
+            len = (strings->offset)[id + 1] - (strings->offset)[id];
+            result = xmalloc((unsigned) (len + 1) * sizeof(char));
+            memmove(result, strings->data + (strings->offset)[id] - 1, len);
+            result[len] = '\0';
+        }
+    }
+    return result;
+}
+
+long cff_get_sid(cff_font * cff, const char *str)
+{
+    card16 i;
+    if (!cff || !str)
+        return -1;
+    /*tex We search the string index first. */
+    if (cff && cff->string) {
+        cff_index *idx = cff->string;
+        for (i = 0; i < idx->count; i++) {
+            if (strlen(str) == (idx->offset)[i + 1] - (idx->offset)[i] &&
+                !memcmp(str, (idx->data) + (idx->offset)[i] - 1, strlen(str)))
+                return (i + CFF_STDSTR_MAX);
+        }
+    }
+    for (i = 0; i < CFF_STDSTR_MAX; i++) {
+        if (!strcmp(str, cff_stdstr[i]))
+            return i;
+    }
+    return -1;
+}
+
+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;
+    cff->_string = NULL;
+}
+
+s_SID cff_add_string(cff_font * cff, const char *str)
+{
+    card16 idx;
+    cff_index *strings;
+    l_offset offset, size;
+    if (cff == NULL) {
+        normal_error("cff","CFF font not opened");
+    }
+    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))) {
+            return (s_SID) (idx + CFF_STDSTR_MAX);
+        }
+    }
+    for (idx = 0; idx < CFF_STDSTR_MAX; idx++) {
+        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)));
+    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)));
+    memcpy(strings->data + offset - 1, str, strlen(str));
+    return (s_SID) (idx + CFF_STDSTR_MAX);
+}
+
+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]);
+                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]);
+                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]);
+                if (str != NULL) {
+                    (dict->entries)[i].values[1] = cff_add_string(cff, str);
+                    xfree(str);
+                }
+            }
+        }
+    }
+}
+
+/*tex The charsets. */
+
+long cff_read_charsets(cff_font * cff)
+{
+    cff_charsets *charset;
+    long offset, length;
+    card16 count, i;
+    if (cff->topdict == NULL)
+        normal_error("cff","top DICT not available");
+    if (!cff_dict_known(cff->topdict, "charset")) {
+        cff->flag |= CHARSETS_ISOADOBE;
+        cff->charsets = NULL;
+        return 0;
+    }
+    offset = (long) cff_dict_get(cff->topdict, "charset", 0);
+    if (offset == 0) {
+        /*tex predefined */
+        cff->flag |= CHARSETS_ISOADOBE;
+        cff->charsets = NULL;
+        return 0;
+    } else if (offset == 1) {
+        cff->flag |= CHARSETS_EXPERT;
+        cff->charsets = NULL;
+        return 0;
+    } else if (offset == 2) {
+        cff->flag |= CHARSETS_EXPSUB;
+        cff->charsets = NULL;
+        return 0;
+    }
+    cff->offset = (l_offset) offset;
+    cff->charsets = charset = xcalloc(1, sizeof(cff_charsets));
+    charset->format = get_card8(cff);
+    charset->num_entries = 0;
+    count = (card16) (cff->num_glyphs - 1);
+    length = 1;
+    /*tex Not well documented. */
+    switch (charset->format) {
+        case 0:
+            charset->num_entries = (card16) (cff->num_glyphs - 1);  /* no .notdef */
+            charset->data.glyphs =
+                xmalloc((unsigned) (charset->num_entries * sizeof(s_SID)));
+            length += (charset->num_entries) * 2;
+            for (i = 0; i < (charset->num_entries); i++) {
+                charset->data.glyphs[i] = get_card16(cff);
+            }
+            count = 0;
+            break;
+        case 1:
+            {
+                cff_range1 *ranges = NULL;
+                while (count > 0 && charset->num_entries < cff->num_glyphs) {
+                    ranges =
+                        xrealloc(ranges,
+                                 (unsigned) (((unsigned) charset->num_entries +
+                                              1) * sizeof(cff_range1)));
+                    ranges[charset->num_entries].first = get_card16(cff);
+                    ranges[charset->num_entries].n_left = get_card8(cff);
+                    count = (card16) (count - ranges[charset->num_entries].n_left + 1);     /* no-overrap */
+                    charset->num_entries++;
+                    charset->data.range1 = ranges;
+                }
+                length += (charset->num_entries) * 3;
+            }
+            break;
+        case 2:
+            {
+                cff_range2 *ranges = NULL;
+                while (count > 0 && charset->num_entries < cff->num_glyphs) {
+                    ranges =
+                        xrealloc(ranges,
+                                 (unsigned) (((unsigned) charset->num_entries +
+                                              1) * sizeof(cff_range2)));
+                    ranges[charset->num_entries].first = get_card16(cff);
+                    ranges[charset->num_entries].n_left = get_card16(cff);
+                    count = (card16) (count - (ranges[charset->num_entries].n_left + 1));   /* non-overrapping */
+                    charset->num_entries++;
+                }
+                charset->data.range2 = ranges;
+                length += (charset->num_entries) * 4;
+            }
+            break;
+        default:
+            xfree(charset);
+            normal_error("cff","unknown charset format");
+            break;
+    }
+    if (count > 0) {
+        normal_warning("cff","charset data possibly broken (too many glyphs)");
+    }
+    return length;
+}
+
+long cff_pack_charsets(cff_font * cff, card8 * dest, long destlen)
+{
+    long len = 0;
+    card16 i;
+    cff_charsets *charset;
+    if (cff->flag & HAVE_STANDARD_CHARSETS || cff->charsets == NULL)
+        return 0;
+    if (destlen < 1)
+        normal_error("cff","buffer overflow (15)");
+    charset = cff->charsets;
+    dest[len++] = charset->format;
+    switch (charset->format) {
+        case 0:
+            if (destlen < len + (charset->num_entries) * 2)
+                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);
+                dest[len++] = (card8) (sid & 0xff);
+            }
+            break;
+        case 1:
+            {
+                if (destlen < len + (charset->num_entries) * 3)
+                    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 & 0xff);
+                    dest[len++] = (card8) ((charset->data).range1[i].n_left);
+                }
+            }
+            break;
+        case 2:
+            {
+                if (destlen < len + (charset->num_entries) * 4)
+                    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 & 0xff);
+                    dest[len++] = (card8) (((charset->data).range2[i].n_left >> 8) & 0xff);
+                    dest[len++] = (card8) ((charset->data).range2[i].n_left & 0xff);
+                }
+            }
+            break;
+        default:
+            normal_error("cff","unknown charset format");
+            break;
+    }
+    return len;
+}
+
+/*tex
+
+    Here we decode and encode Type 2 charstring. All local/global subroutine
+    calls in a given charstring is replace by the content of subroutine
+    charstrings. We do this because some PostScript RIP may have problems with
+    sparse subroutine array. Workaround for this is to re-order subroutine array
+    so that no gap appears in the subroutine array, or put dummy charstrings that
+    contains only `return' in the gap. However, re-ordering of subroutine is
+    rather difficult for Type 2 charstrings due to the bias which depends on the
+    total number of subroutines. Replacing callgsubr/callsubr calls with the
+    content of the corresponding subroutine charstring may be more efficient than
+    putting dummy subroutines in the case of subsetted font. Adobe distiller
+    seems doing same thing.
+
+    And also note that subroutine numbers within subroutines can depend on the
+    content of operand stack as follows:
+
+    \startyping
+    \.{  ... l m callsubr << subr \#(m+bias): n add callsubr >> ...}
+    \stoptyping
+
+    I've not implemented the `random' operator which generates a pseudo-random
+    number in the range (0, 1] and push them into argument stack. How
+    pseudo-random sequences are generated is not documented in the Type 2
+    charstring spec.
+
+*/
+
+#define CS_TYPE2_DEBUG_STR   "Type2 Charstring Parser"
+#define CS_TYPE2_DEBUG       5
+
+#define CS_BUFFER_CFF_ERROR -3
+#define CS_STACK_CFF_ERROR  -2
+#define CS_PARSE_CFF_ERROR  -1
+#define CS_PARSE_OK          0
+#define CS_PARSE_END         1
+#define CS_SUBR_RETURN       2
+#define CS_CHAR_END          3
+
+static int status = CS_PARSE_CFF_ERROR;
+
+#define DST_NEED(a,b) {if ((a) < (b)) { status = CS_BUFFER_CFF_ERROR ; return ; }}
+#define SRC_NEED(a,b) {if ((a) < (b)) { status = CS_PARSE_CFF_ERROR  ; return ; }}
+#define NEED(a,b)     {if ((a) < (b)) { status = CS_STACK_CFF_ERROR  ; return ; }}
+
+/*tex The hintmask and cntrmask need the number of stem zones. */
+
+static int num_stems = 0;
+static int phase = 0;
+
+/*tex Subroutine nesting.
+*/
+static int cs2_nest = 0;
+
+/*tex The advance width. */
+
+static int have_width = 0;
+static double width = 0.0;
+
+/*tex
+
+    Standard Encoding Accented Characters: Optional four arguments for endchar.
+    See, CFF spec., p.35. This is obsolete feature and is no longer supported.
+
+    \starttyping
+    static double seac[4] = { 0.0, 0.0, 0.0, 0.0 }; // gone
+    \stoptyping
+
+*/
+
+/*tex Operand stack and Transient array */
+
+static int cs2_stack_top = 0;
+static double cs2_arg_stack[CS_ARG_STACK_MAX];
+static double trn_array[CS_TRANS_ARRAY_MAX];
+
+/*tex
+
+    Type 2 CharString encoding, first the 1 byte operators:
+
+*/
+
+/*      RESERVED       0 */
+#define cs_hstem       1
+/*      RESERVED       2 */
+#define cs_vstem       3
+#define cs_vmoveto     4
+#define cs_rlineto     5
+#define cs_hlineto     6
+#define cs_vlineto     7
+#define cs_rrcurveto   8
+/*      cs_closepath   9  */
+#define cs_callsubr   10
+#define cs_return     11
+#define cs_escape     12
+/*      cs_hsbw       13 */
+#define cs_endchar    14
+#define cs_setvsindex 15
+#define cs_blend      16
+/*      RESERVED      17 */
+#define cs_hstemhm    18
+#define cs_hintmask   19
+#define cs_cntrmask   20
+#define cs_rmoveto    21
+#define cs_hmoveto    22
+#define cs_vstemhm    23
+#define cs_rcurveline 24
+#define cs_rlinecurve 25
+#define cs_vvcurveto  26
+#define cs_hhcurveto  27
+/*      SHORTINT      28 */
+#define cs_callgsubr  29
+#define cs_vhcurveto  30
+#define cs_hvcurveto  31
+
+/*tex
+
+    Next the two byte CharString operators:
+
+*/
+
+#define cs_dotsection       0
+/*      cs_vstem3           1 */
+/*      cs_hstem3           2 */
+#define cs_and              3
+#define cs_or               4
+#define cs_not              5
+/*      cs_seac             6 */
+/*      cs_sbw              7 */
+/*      RESERVED            8 */
+#define cs_abs              9
+#define cs_add             10
+#define cs_sub             11
+#define cs_div             12
+/*      RESERVED           13 */
+#define cs_neg             14
+#define cs_eq              15
+/*      cs_callothersubr   16 */
+/*      cs_pop|            17 */
+#define cs_drop            18
+/*      RESERVED           19 */
+#define cs_put             20
+#define cs_get             21
+#define cs_ifelse          22
+#define cs_random          23
+#define cs_mul             24
+/*      RESERVED           25 */
+#define cs_sqrt            26
+#define cs_dup             27
+#define cs_exch            28
+#define cs_index           29
+#define cs_roll            30
+/*      cs_setcurrentpoint 31 */
+/*      RESERVED           32 */
+/*      RESERVED           33 */
+#define cs_hflex           34
+#define cs_flex            35
+#define cs_hflex1          36
+#define cs_flex1           37
+
+/*tex  |clear_stack| put all operands sotred in operand stack to dest. */
+
+static void clear_stack(card8 ** dest, card8 * limit)
+{
+    int i;
+    for (i = 0; i < cs2_stack_top; i++) {
+        double value;
+        long ivalue;
+        value = cs2_arg_stack[i];
+        /*tex The nearest integer value. */
+        ivalue = (long) floor(value + 0.5);
+        if (value >= 0x8000L || value <= (-0x8000L - 1)) {
+            /*tex
+                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) {
+            /*tex A 16.16-bit signed fixed value  */
+            DST_NEED(limit, *dest + 5);
+            *(*dest)++ = 255;
+            /*tex The mantissa. */
+            ivalue = (long) floor(value);
+            *(*dest)++ = (card8) ((ivalue >> 8) & 0xff);
+            *(*dest)++ = (card8) (ivalue & 0xff);
+            /*tex The fraction. */
+            ivalue = (long) ((value - (double) ivalue) * 0x10000l);
+            *(*dest)++ = (card8) ((ivalue >> 8) & 0xff);
+            *(*dest)++ = (card8) (ivalue & 0xff);
+            /*tex Everything else is integer. */
+        } else if (ivalue >= -107 && ivalue <= 107) {
+            DST_NEED(limit, *dest + 1);
+            *(*dest)++ = (card8) (ivalue + 139);
+        } else if (ivalue >= 108 && ivalue <= 1131) {
+            DST_NEED(limit, *dest + 2);
+            ivalue = (long) 0xf700u + ivalue - 108;
+            *(*dest)++ = (card8) ((ivalue >> 8) & 0xff);
+            *(*dest)++ = (card8) (ivalue & 0xff);
+        } else if (ivalue >= -1131 && ivalue <= -108) {
+            DST_NEED(limit, *dest + 2);
+            ivalue = (long) 0xfb00u - ivalue - 108;
+            *(*dest)++ = (card8) ((ivalue >> 8) & 0xff);
+            *(*dest)++ = (card8) (ivalue & 0xff);
+        } else if (ivalue >= -32768 && ivalue <= 32767) {
+            /*tex A shortint. */
+            DST_NEED(limit, *dest + 3);
+            *(*dest)++ = 28;
+            *(*dest)++ = (card8) ((ivalue >> 8) & 0xff);
+            *(*dest)++ = (card8) ((ivalue) & 0xff);
+        } else {
+            normal_error("cff","unexpected error");
+        }
+    }
+    /*tex Clear the stack. */
+    cs2_stack_top = 0;
+    return;
+}
+
+/*tex
+    Single byte operators: Path construction, Operator for finishing a path, Hint
+    operators. Phases:
+
+    \starttabulate
+    \NC \type{0} \NC inital state \NC \NR
+    \NC \type{1} \NC hint declaration, first stack-clearing operator appeared \NC \NR
+    \NC \type{2} \NC in path construction \NC \NR
+    \stoptabulate
+
+*/
+
+static void do_operator1(card8 ** dest, card8 * limit, card8 ** data, card8 * endptr)
+{
+    card8 op = **data;
+
+    *data += 1;
+
+    switch (op) {
+        case cs_hstemhm:
+        case cs_vstemhm:
+            /*tex  A charstring may have a hintmask if the above operator has been seen. */
+        case cs_hstem:
+        case cs_vstem:
+            if (phase == 0 && (cs2_stack_top % 2)) {
+                have_width = 1;
+                width = cs2_arg_stack[0];
+            }
+            num_stems += cs2_stack_top / 2;
+            clear_stack(dest, limit);
+            DST_NEED(limit, *dest + 1);
+            *(*dest)++ = op;
+            phase = 1;
+            break;
+        case cs_hintmask:
+        case cs_cntrmask:
+            if (phase < 2) {
+                if (phase == 0 && (cs2_stack_top % 2)) {
+                    have_width = 1;
+                    width = cs2_arg_stack[0];
+                }
+                num_stems += cs2_stack_top / 2;
+            }
+            clear_stack(dest, limit);
+            DST_NEED(limit, *dest + 1);
+            *(*dest)++ = op;
+            if (num_stems > 0) {
+                int masklen = (num_stems + 7) / 8;
+                DST_NEED(limit, *dest + masklen);
+                SRC_NEED(endptr, *data + masklen);
+                memmove(*dest, *data, (size_t) masklen);
+                *data += masklen;
+                *dest += masklen;
+            }
+            phase = 2;
+            break;
+        case cs_rmoveto:
+            if (phase == 0 && (cs2_stack_top % 2)) {
+                have_width = 1;
+                width = cs2_arg_stack[0];
+            }
+            clear_stack(dest, limit);
+            DST_NEED(limit, *dest + 1);
+            *(*dest)++ = op;
+            phase = 2;
+            break;
+        case cs_hmoveto:
+        case cs_vmoveto:
+            if (phase == 0 && (cs2_stack_top % 2) == 0) {
+                have_width = 1;
+                width = cs2_arg_stack[0];
+            }
+            clear_stack(dest, limit);
+            DST_NEED(limit, *dest + 1);
+            *(*dest)++ = op;
+            phase = 2;
+            break;
+        case cs_endchar:
+            if (cs2_stack_top == 1) {
+                have_width = 1;
+                width = cs2_arg_stack[0];
+                clear_stack(dest, limit);
+            } else if (cs2_stack_top == 4 || cs2_stack_top == 5) {
+                normal_warning("cff","'seac' character deprecated in type 2 charstring");
+                status = CS_PARSE_CFF_ERROR;
+                return;
+            } else if (cs2_stack_top > 0) {
+                normal_warning("cff","operand stack not empty");
+            }
+            DST_NEED(limit, *dest + 1);
+            *(*dest)++ = op;
+            status = CS_CHAR_END;
+            break;
+            /*tex The 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:
+        case cs_rrcurveto:
+        case cs_rcurveline:
+        case cs_rlinecurve:
+        case cs_vvcurveto:
+        case cs_hhcurveto:
+        case cs_vhcurveto:
+        case cs_hvcurveto:
+            if (phase < 2) {
+                normal_warning("cff","broken type 2 charstring");
+                status = CS_PARSE_CFF_ERROR;
+                return;
+            }
+            clear_stack(dest, limit);
+            DST_NEED(limit, *dest + 1);
+            *(*dest)++ = op;
+            break;
+            /*tex All the operotors above are stack clearing. */
+        case cs_return:
+            normal_error("cff","unexpected return");
+        case cs_callgsubr:
+            normal_error("cff","unexpected callgsubr");
+        case cs_callsubr:
+            normal_error("cff","unexpected callsubr");
+            break;
+        default:
+            formatted_warning("cff","%s: unknown charstring operator: 0x%02x", CS_TYPE2_DEBUG_STR, op);
+            status = CS_PARSE_CFF_ERROR;
+            break;
+    }
+    return;
+}
+
+/*tex
+
+    Double byte operators: Flex, arithmetic, conditional, and storage operators.
+    The following operators are not supported: random but How random ?
+
+*/
+
+static void do_operator2(card8 ** dest, card8 * limit, card8 ** data, card8 * endptr)
+{
+    card8 op;
+    *data += 1;
+    SRC_NEED(endptr, *data + 1);
+    op = **data;
+    *data += 1;
+    switch (op) {
+        case cs_dotsection:
+            normal_warning("cff","Operator 'dotsection' deprecated in type 2 charstring");
+            status = CS_PARSE_CFF_ERROR;
+            return;
+            break;
+        case cs_hflex:
+        case cs_flex:
+        case cs_hflex1:
+        case cs_flex1:
+            if (phase < 2) {
+                formatted_warning("cff","%s: broken type 2 charstring", CS_TYPE2_DEBUG_STR);
+                status = CS_PARSE_CFF_ERROR;
+                return;
+            }
+            clear_stack(dest, limit);
+            DST_NEED(limit, *dest + 2);
+            *(*dest)++ = cs_escape;
+            *(*dest)++ = op;
+            break;
+            /*tex All operators above are stack clearing. */
+        case cs_and:
+            NEED(cs2_stack_top, 2);
+            cs2_stack_top--;
+            if (cs2_arg_stack[cs2_stack_top] && cs2_arg_stack[cs2_stack_top - 1]) {
+                cs2_arg_stack[cs2_stack_top - 1] = 1.0;
+            } else {
+                cs2_arg_stack[cs2_stack_top - 1] = 0.0;
+            }
+            break;
+        case cs_or:
+            NEED(cs2_stack_top, 2);
+            cs2_stack_top--;
+            if (cs2_arg_stack[cs2_stack_top] || cs2_arg_stack[cs2_stack_top - 1]) {
+                cs2_arg_stack[cs2_stack_top - 1] = 1.0;
+            } else {
+                cs2_arg_stack[cs2_stack_top - 1] = 0.0;
+            }
+            break;
+        case cs_not:
+            NEED(cs2_stack_top, 1);
+            if (cs2_arg_stack[cs2_stack_top - 1]) {
+                cs2_arg_stack[cs2_stack_top - 1] = 0.0;
+            } else {
+                cs2_arg_stack[cs2_stack_top - 1] = 1.0;
+            }
+            break;
+        case cs_abs:
+            NEED(cs2_stack_top, 1);
+            cs2_arg_stack[cs2_stack_top - 1] =
+                fabs(cs2_arg_stack[cs2_stack_top - 1]);
+            break;
+        case cs_add:
+            NEED(cs2_stack_top, 2);
+            cs2_arg_stack[cs2_stack_top - 2] += cs2_arg_stack[cs2_stack_top - 1];
+            cs2_stack_top--;
+            break;
+        case cs_sub:
+            NEED(cs2_stack_top, 2);
+            cs2_arg_stack[cs2_stack_top - 2] -= cs2_arg_stack[cs2_stack_top - 1];
+            cs2_stack_top--;
+            break;
+        case cs_div:
+            NEED(cs2_stack_top, 2);
+            cs2_arg_stack[cs2_stack_top - 2] /= cs2_arg_stack[cs2_stack_top - 1];
+            cs2_stack_top--;
+            break;
+        case cs_neg:
+            NEED(cs2_stack_top, 1);
+            cs2_arg_stack[cs2_stack_top - 1] *= -1.0;
+            break;
+        case cs_eq:
+            NEED(cs2_stack_top, 2);
+            cs2_stack_top--;
+            if (cs2_arg_stack[cs2_stack_top] == cs2_arg_stack[cs2_stack_top - 1]) {
+                cs2_arg_stack[cs2_stack_top - 1] = 1.0;
+            } else {
+                cs2_arg_stack[cs2_stack_top - 1] = 0.0;
+            }
+            break;
+        case cs_drop:
+            NEED(cs2_stack_top, 1);
+            cs2_stack_top--;
+            break;
+        case cs_put:
+            NEED(cs2_stack_top, 2);
+            {
+                int idx = (int) cs2_arg_stack[--cs2_stack_top];
+                NEED(CS_TRANS_ARRAY_MAX, idx);
+                trn_array[idx] = cs2_arg_stack[--cs2_stack_top];
+            }
+            break;
+        case cs_get:
+            NEED(cs2_stack_top, 1);
+            {
+                int idx = (int) cs2_arg_stack[cs2_stack_top - 1];
+                NEED(CS_TRANS_ARRAY_MAX, idx);
+                cs2_arg_stack[cs2_stack_top - 1] = trn_array[idx];
+            }
+            break;
+        case cs_ifelse:
+            NEED(cs2_stack_top, 4);
+            cs2_stack_top -= 3;
+            if (cs2_arg_stack[cs2_stack_top + 1] > cs2_arg_stack[cs2_stack_top + 2]) {
+                cs2_arg_stack[cs2_stack_top - 1] = cs2_arg_stack[cs2_stack_top];
+            }
+            break;
+        case cs_mul:
+            NEED(cs2_stack_top, 2);
+            cs2_arg_stack[cs2_stack_top - 2] =
+                cs2_arg_stack[cs2_stack_top - 2] * cs2_arg_stack[cs2_stack_top - 1];
+            cs2_stack_top--;
+            break;
+        case cs_sqrt:
+            NEED(cs2_stack_top, 1);
+            cs2_arg_stack[cs2_stack_top - 1] =
+                sqrt(cs2_arg_stack[cs2_stack_top - 1]);
+            break;
+        case cs_dup:
+            NEED(cs2_stack_top, 1);
+            NEED(CS_ARG_STACK_MAX, cs2_stack_top + 1);
+            cs2_arg_stack[cs2_stack_top] = cs2_arg_stack[cs2_stack_top - 1];
+            cs2_stack_top++;
+            break;
+        case cs_exch:
+            NEED(cs2_stack_top, 2);
+            {
+                double save = cs2_arg_stack[cs2_stack_top - 2];
+                cs2_arg_stack[cs2_stack_top - 2] = cs2_arg_stack[cs2_stack_top - 1];
+                cs2_arg_stack[cs2_stack_top - 1] = save;
+            }
+            break;
+        case cs_index:
+            NEED(cs2_stack_top, 2);
+            {
+                int idx = (int) cs2_arg_stack[cs2_stack_top - 1];
+                if (idx < 0) {
+                    cs2_arg_stack[cs2_stack_top - 1] =
+                        cs2_arg_stack[cs2_stack_top - 2];
+                } else {
+                    NEED(cs2_stack_top, idx + 2);
+                    cs2_arg_stack[cs2_stack_top - 1] =
+                        cs2_arg_stack[cs2_stack_top - idx - 2];
+                }
+            }
+            break;
+        case cs_roll:
+            NEED(cs2_stack_top, 2);
+            {
+                int N, J;
+                J = (int) cs2_arg_stack[--cs2_stack_top];
+                N = (int) cs2_arg_stack[--cs2_stack_top];
+                NEED(cs2_stack_top, N);
+                if (J > 0) {
+                    J = J % N;
+                    while (J-- > 0) {
+                        double save = cs2_arg_stack[cs2_stack_top - 1];
+                        int i = cs2_stack_top - 1;
+                        while (i > cs2_stack_top - N) {
+                            cs2_arg_stack[i] = cs2_arg_stack[i - 1];
+                            i--;
+                        }
+                        cs2_arg_stack[i] = save;
+                    }
+                } else {
+                    J = (-J) % N;
+                    while (J-- > 0) {
+                        double save = cs2_arg_stack[cs2_stack_top - N];
+                        int i = cs2_stack_top - N;
+                        while (i < cs2_stack_top - 1) {
+                            cs2_arg_stack[i] = cs2_arg_stack[i + 1];
+                            i++;
+                        }
+                        cs2_arg_stack[i] = save;
+                    }
+                }
+            }
+            break;
+        case cs_random:
+            formatted_warning("cff","%s: Charstring operator 'random' found.", CS_TYPE2_DEBUG_STR);
+            NEED(CS_ARG_STACK_MAX, cs2_stack_top + 1);
+            cs2_arg_stack[cs2_stack_top++] = 1.0;
+            break;
+        default:
+            formatted_warning("cff","%s: unknown charstring operator: 0x0c%02x", CS_TYPE2_DEBUG_STR, op);
+            status = CS_PARSE_CFF_ERROR;
+            break;
+    }
+    return;
+}
+
+/*tex integer: exactly the same as the DICT encoding (except 29) */
+
+static void cs2_get_integer(card8 ** data, card8 * endptr)
+{
+    long result = 0;
+    card8 b0 = **data, b1, b2;
+    *data += 1;
+    if (b0 == 28) {
+        /*tex shortint */
+        SRC_NEED(endptr, *data + 2);
+        b1 = **data;
+        b2 = *(*data + 1);
+        result = b1 * 256 + b2;
+        if (result > 0x7fff)
+            result -= 0x10000L;
+        *data += 2;
+    } else if (b0 >= 32 && b0 <= 246) {
+        /*tex int (1) */
+        result = b0 - 139;
+    } else if (b0 >= 247 && b0 <= 250) {
+        /*tex int (2) */
+        SRC_NEED(endptr, *data + 1);
+        b1 = **data;
+        result = (b0 - 247) * 256 + b1 + 108;
+        *data += 1;
+    } else if (b0 >= 251 && b0 <= 254) {
+        SRC_NEED(endptr, *data + 1);
+        b1 = **data;
+        result = -(b0 - 251) * 256 - b1 - 108;
+        *data += 1;
+    } else {
+        status = CS_PARSE_CFF_ERROR;
+        return;
+    }
+    NEED(CS_ARG_STACK_MAX, cs2_stack_top + 1);
+    cs2_arg_stack[cs2_stack_top++] = (double) result;
+    return;
+}
+
+/*tex Signed 16.16-bits fixed number for Type 2 charstring encoding. */
+
+static void get_fixed(card8 ** data, card8 * endptr)
+{
+    long ivalue;
+    double rvalue;
+    *data += 1;
+    SRC_NEED(endptr, *data + 4);
+    ivalue = *(*data) * 0x100 + *(*data + 1);
+    rvalue = (double) ((ivalue > 0x7fffL) ? (ivalue - 0x10000L) : ivalue);
+    ivalue = *(*data + 2) * 0x100 + *(*data + 3);
+    rvalue += ((double) ivalue) / 0x10000L;
+    NEED(CS_ARG_STACK_MAX, cs2_stack_top + 1);
+    cs2_arg_stack[cs2_stack_top++] = rvalue;
+    *data += 4;
+    return;
+}
+
+/*tex
+
+Subroutines: the bias for subroutine number is introduced in type 2
+charstrings.
+
+\starttabulate
+\NC \type {subr}     \NC set to a pointer to the subroutine charstring \NC \NR
+\NC \type {len}      \NC set to the length of subroutine charstring \NC \NR
+\NC \type {subr_idx} \NC CFF INDEX data that contains subroutines \NC \NR
+\NC \type {id}       \NC biased subroutine number \NC \NR
+\stoptabulate
+
+*/
+
+static void get_subr(card8 ** subr, long *len, cff_index * subr_idx, long id)
+{
+    card16 count;
+    if (subr_idx == NULL)
+        formatted_error("cff","%s: subroutine called but no subroutine found",CS_TYPE2_DEBUG_STR);
+    count = subr_idx->count;
+    /*tex addi the bias number */
+    if (count < 1240) {
+        id += 107;
+    } else if (count < 33900) {
+        id += 1131;
+    } else {
+        id += 32768;
+    }
+    if (id > count)
+        formatted_error("cff","%s: invalid subroutine index: %ld (max=%u)", CS_TYPE2_DEBUG_STR, id, count);
+    *len = (long) ((subr_idx->offset)[id + 1] - (subr_idx->offset)[id]);
+    *subr = subr_idx->data + (subr_idx->offset)[id] - 1;
+    return;
+}
+
+/*tex
+
+    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.
+
+*/
+
+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;
+    if (cs2_nest > CS_SUBR_NEST_MAX)
+        formatted_error("cff","%s: subroutine nested too deeply", CS_TYPE2_DEBUG_STR);
+    cs2_nest++;
+    while (*data < endptr && status == CS_PARSE_OK) {
+        b0 = **data;
+        if (b0 == 255) {
+            /*tex A 16-bit.16-bit fixed signed number. */
+            get_fixed(data, endptr);
+        } else if (b0 == cs_return) {
+            status = CS_SUBR_RETURN;
+        } else if (b0 == cs_callgsubr) {
+            if (cs2_stack_top < 1) {
+                status = CS_STACK_CFF_ERROR;
+            } else {
+                cs2_stack_top--;
+                get_subr(&subr, &len, gsubr_idx, (long) cs2_arg_stack[cs2_stack_top]);
+                if (*dest + len > limit)
+                    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) {
+            if (cs2_stack_top < 1) {
+                status = CS_STACK_CFF_ERROR;
+            } else {
+                cs2_stack_top--;
+                get_subr(&subr, &len, subr_idx, (long) cs2_arg_stack[cs2_stack_top]);
+                if (limit < *dest + len)
+                    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) {
+            do_operator2(dest, limit, data, endptr);
+        } else if (b0 < 32 && b0 != 28) {
+            do_operator1(dest, limit, data, endptr);
+        } else if ((b0 <= 22 && b0 >= 27) || b0 == 31) {
+            status = CS_PARSE_CFF_ERROR;
+        } else {
+            cs2_get_integer(data, endptr);
+        }
+    }
+    if (cff2) {
+        DST_NEED(limit, *dest + 1);
+        ++endptr;
+        *(*dest)++ = cs_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);
+    } else if (status < CS_PARSE_OK) {
+        formatted_error("cff","%s: parsing charstring failed: (status=%d, stack=%d)", CS_TYPE2_DEBUG_STR, status, cs2_stack_top);
+    }
+    cs2_nest--;
+    return;
+}
+
+static void cs_parse_init(void)
+{
+    status = CS_PARSE_OK;
+    cs2_nest = 0;
+    phase = 0;
+    num_stems = 0;
+    cs2_stack_top = 0;
+}
+
+/*tex Not just copying \unknown */
+
+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;
+
+    cs_parse_init();
+
+    width = 0.0;
+    have_width = 0;
+
+    /* expand call(g)subrs */
+    do_charstring(&dst, dst + dstlen, &src, src + srclen, gsubr, subr, cff2);
+
+    if (ginfo) {
+        ginfo->flags = 0;       /* not used */
+        if (have_width) {
+            ginfo->wx = nominal_width + width;
+        } else {
+            ginfo->wx = default_width;
+        }
+    }
+
+    return (long) (dst - save);
+}
+
+/*tex CID-Keyed font specific. */
+
+long cff_read_fdselect(cff_font * cff)
+{
+    cff_fdselect *fdsel;
+    long offset, length;
+    card16 i;
+    if (cff->topdict == NULL)
+        normal_error("cff","top DICT not available");
+    if (!(cff->flag & FONTTYPE_CIDFONT))
+        return 0;
+    offset = (long) cff_dict_get(cff->topdict, "FDSelect", 0);
+    cff->offset = (l_offset) offset;
+    cff->fdselect = fdsel = xcalloc(1, sizeof(cff_fdselect));
+    fdsel->format = get_card8(cff);
+    length = 1;
+    switch (fdsel->format) {
+        case 0:
+            fdsel->num_entries = cff->num_glyphs;
+            (fdsel->data).fds = xmalloc(fdsel->num_entries * sizeof(card8));
+            for (i = 0; i < (fdsel->num_entries); i++) {
+                (fdsel->data).fds[i] = get_card8(cff);
+            }
+            length += fdsel->num_entries;
+            break;
+        case 3:
+            {
+                cff_range3 *ranges;
+                fdsel->num_entries = get_card16(cff);
+                fdsel->data.ranges = ranges =
+                    xcalloc(fdsel->num_entries, sizeof(cff_range3));
+                for (i = 0; i < (fdsel->num_entries); i++) {
+                    ranges[i].first = get_card16(cff);
+                    ranges[i].fd = get_card8(cff);
+                }
+                if (ranges[0].first != 0)
+                    normal_error("cff","range not starting with 0");
+                if (cff->num_glyphs != get_card16(cff))
+                    normal_error("cff","sentinel value mismatched with number of glyphs");
+                length += (fdsel->num_entries) * 3 + 4;
+            }
+            break;
+        default:
+            xfree(fdsel);
+            normal_error("cff","unknown FDSelect format");
+            break;
+    }
+    return length;
+}
+
+long cff_pack_fdselect(cff_font * cff, card8 * dest, long destlen)
+{
+    cff_fdselect *fdsel;
+    long len = 0;
+    card16 i;
+    if (cff->fdselect == NULL)
+        return 0;
+    if (destlen < 1)
+        normal_error("cff","buffer overflow (23)");
+    fdsel = cff->fdselect;
+    dest[len++] = fdsel->format;
+    switch (fdsel->format) {
+        case 0:
+            if (fdsel->num_entries != cff->num_glyphs)
+                normal_error("cff","invalid data");
+            if (destlen < len + fdsel->num_entries)
+                normal_error("cff","buffer overflow (24)");
+            for (i = 0; i < fdsel->num_entries; i++) {
+                dest[len++] = (fdsel->data).fds[i];
+            }
+            break;
+        case 3:
+            {
+                if (destlen < len + 2)
+                    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 (26)");
+                    dest[len++] =
+                        (card8) (((fdsel->data).ranges[i].first >> 8) & 0xff);
+                    dest[len++] = (card8) ((fdsel->data).ranges[i].first & 0xff);
+                    dest[len++] = (card8) ((fdsel->data).ranges[i].fd);
+                }
+                if (destlen < len + 2)
+                    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);
+                dest[2] = (card8) ((len / 3 - 1) & 0xff);
+            }
+            break;
+        default:
+            normal_error("cff","unknown FDSelect format");
+            break;
+    }
+    return len;
+}
+
+/*tex Create an instance of embeddable font. */
+
+static void write_fontfile(PDF pdf, cff_font * cffont, char *fullname)
+{
+    cff_index *topdict, *fdarray, *private;
+    unsigned char *dest;
+    long destlen = 0, i, size;
+    long offset, topdict_offset, fdarray_offset;
+    topdict = cff_new_index(1);
+    fdarray = cff_new_index(cffont->num_fds);
+    private = cff_new_index(cffont->num_fds);
+    cff_dict_remove(cffont->topdict, "UniqueID");
+    cff_dict_remove(cffont->topdict, "XUID");
+    /*tex A bad font may have this: */
+    cff_dict_remove(cffont->topdict, "Private");
+    /*tex A bad font may have this: */
+    cff_dict_remove(cffont->topdict, "Encoding");
+    /*tex This is CFF2 specific: */
+    cff_dict_remove(cffont->topdict, "vstore");
+    /*tex This is CFF2 specific: */
+    cff_dict_remove(cffont->topdict, "maxstack");
+    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) {
+                /*tex |Private| contains 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));
+    }
+    /*tex The header size: */
+    destlen = 4;
+    destlen += cff_set_name(cffont, fullname);
+    destlen += cff_index_size(topdict);
+    destlen += cff_index_size(cffont->string);
+    destlen += cff_index_size(cffont->gsubr);
+    /*tex |charset| format 0 */
+    destlen += (cffont->charsets->num_entries) * 2 + 1;
+    /*tex |fdselect| format 3 */
+    destlen += (cffont->fdselect->num_entries) * 3 + 5;
+    destlen += cff_index_size(cffont->cstrings);
+    destlen += cff_index_size(fdarray);
+    /* |Private| is not indexed */
+    destlen = (long) (destlen + (long) private->offset[private->count] - 1);
+    dest = xcalloc((unsigned) destlen, sizeof(card8));
+    offset = 0;
+    /*tex |Header| */
+    offset += cff_put_header(cffont, dest + offset, destlen - offset);
+    /*tex |Name| */
+    offset += cff_pack_index(cffont->name, dest + offset, destlen - offset);
+    /*tex |Top DICT| */
+    topdict_offset = offset;
+    offset += cff_index_size(topdict);
+    /*tex |Strings| */
+    offset += cff_pack_index(cffont->string, dest + offset, destlen - offset);
+    /*tex |Global Subrs| */
+    offset += cff_pack_index(cffont->gsubr, dest + offset, destlen - offset);
+    /*tex |charset| */
+    cff_dict_set(cffont->topdict, "charset", 0, (double) offset);
+    offset += cff_pack_charsets(cffont, dest + offset, destlen - offset);
+    /*tex |FDSelect| */
+    cff_dict_set(cffont->topdict, "FDSelect", 0, (double) offset);
+    offset += cff_pack_fdselect(cffont, dest + offset, destlen - offset);
+    /*tex |CharStrings| */
+    cff_dict_set(cffont->topdict, "CharStrings", 0, (double) offset);
+    offset += cff_pack_index(cffont->cstrings, dest + offset, cff_index_size(cffont->cstrings));
+    cff_release_index(cffont->cstrings);
+    /*tex |Charstring|s can consume a lot of memory. */
+    cffont->cstrings = NULL;
+    /*tex |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));
+    for (i = 0; i < cffont->num_fds; i++) {
+        size = (long) (private->offset[i + 1] - private->offset[i]);
+        if (cffont->private[i] && size > 0) {
+            cff_dict_pack(cffont->private[i], dest + offset, size);
+            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));
+        offset += size;
+    }
+    cff_pack_index(fdarray, dest + fdarray_offset, cff_index_size(fdarray));
+    cff_release_index(fdarray);
+    cff_release_index(private);
+    /*tex Finally the |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));
+    cff_pack_index(topdict, dest + topdict_offset, cff_index_size(topdict));
+    cff_release_index(topdict);
+    for (i = 0; i < offset; i++) {
+        strbuf_putchar(pdf->fb, dest[i]);
+    }
+    xfree(dest);
+    return;
+}
+
+void write_cff(PDF pdf, cff_font * cffont, fd_entry * fd)
+{
+    cff_index *charstrings, *cs_idx;
+    long charstring_len, max_len;
+    long size, offset = 0;
+    card8 *data;
+    card16 num_glyphs, cs_count1, code, gid, last_cid;
+    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);
+    /*tex Finish parsing the CFF. */
+    cff_read_private(cffont);
+    cff_read_subrs(cffont);
+    /*tex The |Width|s. */
+    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);
+    } else {
+        nominal_width = CFF_NOMINALWIDTHX_DEFAULT;
+    }
+    num_glyphs = 0;
+    last_cid = 0;
+    glyph = xtalloc(1, glw_entry);
+    /*tex insert |notdef| */
+    glyph->id = 0;
+    if (avl_find(fd->gl_tree, glyph) == NULL) {
+        avl_insert(fd->gl_tree, glyph);
+        glyph = xtalloc(1, glw_entry);
+    }
+    avl_t_init(&t, fd->gl_tree);
+    for (found = (glw_entry *) avl_t_first(&t, fd->gl_tree);
+         found != NULL; found = (glw_entry *) avl_t_next(&t)) {
+        if (found->id > last_cid)
+            last_cid = (card16) found->id;
+        num_glyphs++;
+    }
+    {
+        cff_fdselect *fdselect;
+        fdselect = xcalloc(1, sizeof(cff_fdselect));
+        fdselect->format = 3;
+        fdselect->num_entries = 1;
+        fdselect->data.ranges = xcalloc(1, sizeof(cff_range3));
+        fdselect->data.ranges[0].first = 0;
+        fdselect->data.ranges[0].fd = 0;
+        cffont->fdselect = fdselect;
+    }
+    {
+        cff_charsets *charset;
+        charset = xcalloc(1, sizeof(cff_charsets));
+        charset->format = 0;
+        charset->num_entries = (card16) (num_glyphs - 1);
+        charset->data.glyphs = xcalloc(num_glyphs, sizeof(s_SID));
+        gid = 0;
+        avl_t_init(&t, fd->gl_tree);
+        for (found = (glw_entry *) avl_t_first(&t, fd->gl_tree);
+             found != NULL; found = (glw_entry *) avl_t_next(&t)) {
+            if (found->id != 0) {
+                charset->data.glyphs[gid] = (s_SID) found->id;
+                gid++;
+            }
+        }
+        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);
+    /*tex fix: 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);
+    /*tex |FDArray| index offset, not known yet */
+    cff_dict_add(cffont->topdict, "FDArray", 1);
+    cff_dict_set(cffont->topdict, "FDArray", 0, 0.0);
+    /*tex |FDSelect| offset, not known yet */
+    cff_dict_add(cffont->topdict, "FDSelect", 1);
+    cff_dict_set(cffont->topdict, "FDSelect", 0, 0.0);
+    cff_dict_remove(cffont->topdict, "UniqueID");
+    cff_dict_remove(cffont->topdict, "XUID");
+    cff_dict_remove(cffont->topdict, "Private");
+    cff_dict_remove(cffont->topdict, "Encoding");
+    cffont->offset = (l_offset) cff_dict_get(cffont->topdict, "CharStrings", 0);
+    cs_idx = cff_get_index_header(cffont);
+    offset = (long) cffont->offset;
+    cs_count1 = cs_idx->count;
+    if (cs_count1 < 2) {
+        normal_error("cff","no valid charstring data found");
+    }
+    /*tex Build the new charstrings entry. */
+    charstrings = cff_new_index((card16) (cs_count1==USHRT_MAX?cs_count1: cs_count1 + 1));
+    max_len = 2 * CS_STR_LEN_MAX;
+    charstrings->data = xcalloc((unsigned) max_len, sizeof(card8));
+    charstring_len = 0;
+    gid = 0;
+    data = xcalloc(CS_STR_LEN_MAX, sizeof(card8));
+    {
+        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;
+            if ((avl_find(fd->gl_tree,glyph) != NULL)) {
+                /*tex 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++;
+            }
+        }
+    }
+    /*tex
+        The |CIDSet| is 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);
+        }
+    }
+    /*tex
+        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;
+    }
+    xfree(data);
+    cff_release_index(cs_idx);
+    (charstrings->offset)[num_glyphs] = (l_offset) (charstring_len + 1);
+    charstrings->count = num_glyphs;
+    cffont->num_glyphs = num_glyphs;
+    cffont->cstrings = charstrings;
+    /*tex
+        We don't use subroutines at all.
+    */
+    if (cffont->gsubr)
+        cff_release_index(cffont->gsubr);
+    cffont->gsubr = cff_new_index(0);
+    if (cffont->subrs && cffont->subrs[0])
+        cff_release_index(cffont->subrs[0]);
+    cffont->subrs[0] = NULL;
+    if (cffont->private && (cffont->private)[0]) {
+        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");
+    if (cffont->header_major == 2) {
+        /*tex A crash. */
+    } else {
+        cff_dict_update(cffont->private[0], cffont);
+    }
+    cff_update_string(cffont);
+    /* 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", 2, 0.0);
+    write_fontfile(pdf, cffont, fullname);
+    xfree(fontname);
+    xfree(fullname);
+    cff_close(cffont);
+}
+
+#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;
+    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 ;
+    char *fullname;
+    glw_entry *glyph;
+    unsigned char *CIDToGIDMap = NULL;
+    cff_fdselect *fdselect = NULL;
+    cff_charsets *charset = NULL;
+    if (!is_cidfont(cffont)) {
+        normal_error("cff","invalid 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);
+    /*tex Finish parsing the CFF. */
+    if (cff_dict_known(cffont->topdict, "CIDCount")) {
+        cid_count = (card16) cff_dict_get(cffont->topdict, "CIDCount", 0);
+    } else {
+        cid_count = CFF_CIDCOUNT_DEFAULT;
+    }
+    if (cffont->header_major == 2) {
+        /*tex 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);
+    /*tex insert |notdef| */
+    glyph->id = 0;
+    if (avl_find(fd->gl_tree, glyph) == NULL) {
+        avl_insert(fd->gl_tree, glyph);
+        glyph = xtalloc(1, glw_entry);
+    }
+    last_cid = 0;
+    num_glyphs = 0;
+    for (cid = 0; cid <= CID_MAX; cid++) {
+        glyph->id = (unsigned) cid;
+        if (avl_find(fd->gl_tree, glyph) != NULL) {
+            gid = (card16) cid;
+            CIDToGIDMap[2 * cid] = (unsigned char) ((gid >> 8) & 0xff);
+            CIDToGIDMap[2 * cid + 1] = (unsigned char) (gid & 0xff);
+            last_cid = (card16) cid;
+            num_glyphs++;
+        }
+    }
+    if (cffont->header_major == 2) {
+        /*tex hm */
+    } else if (last_cid >= cffont->num_glyphs) {
+        formatted_error("cff font","bad glyph index %i",last_cid);
+    }
+    /*tex
+        The |CIDSet| table is 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) {
+            size_t l = (last_cid / 8) + 1;
+            char *stream = xmalloc(l);
+            memset(stream, 0, l);
+            for (cid = 1; cid <= (long) last_cid; cid++) {
+                if (CIDToGIDMap[2 * cid] || CIDToGIDMap[2 * cid + 1]) {
+                    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);
+            xfree(stream);
+        }
+    }
+    cff_read_fdselect(cffont);
+    cff_read_fdarray(cffont);
+    cff_read_private(cffont);
+    cff_read_subrs(cffont);
+    cffont->offset = (l_offset) cff_dict_get(cffont->topdict, "CharStrings", 0);
+    cs_idx = cff_get_index_header(cffont);
+    offset = (long) cffont->offset;
+    cs_count1 = cs_idx->count;
+    if (cs_count1 < 2) {
+        normal_error("cff","no valid charstring data found");
+    }
+    charset = xcalloc(1, sizeof(cff_charsets));
+    charset->format = 0;
+    charset->num_entries = 0;
+    charset->data.glyphs = xcalloc(num_glyphs, sizeof(s_SID));
+    fdselect = xcalloc(1, sizeof(cff_fdselect));
+    fdselect->format = 3;
+    fdselect->num_entries = 0;
+    fdselect->data.ranges = xcalloc(num_glyphs, sizeof(cff_range3));
+    charstrings = cff_new_index((card16) (cs_count1==USHRT_MAX?cs_count1: cs_count1 + 1));
+    max_len = 2 * CS_STR_LEN_MAX;
+    charstrings->data = xcalloc((unsigned) max_len, sizeof(card8));
+    charstring_len = 0;
+    prev_fd = -1;
+    gid = 0;
+    data = xcalloc(CS_STR_LEN_MAX, sizeof(card8));
+    for (cid = 0; cid <= last_cid; cid++) {
+        unsigned short gid_org;
+        glyph->id = (unsigned) cid;
+        if (avl_find(fd->gl_tree, glyph) == NULL)
+            continue;
+        gid_org = (short unsigned) ((CIDToGIDMap[2 * cid] << 8) | (CIDToGIDMap[2 * cid + 1]));
+        fdsel = cff_fdselect_lookup(cffont, gid_org);
+        if (callback_id > 0) {
+            /*tex The next blob is not yet tested \unknown\ I need a font. */
+            lstring * result;
+            run_callback(callback_id, "ddd->L", tex_font, gid_org, streamprovider, &result);
+            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++;
+        }
+        if (fdsel != prev_fd) {
+            fdselect->data.ranges[fdselect->num_entries].first = gid;
+            fdselect->data.ranges[fdselect->num_entries].fd = (card8) fdsel;
+            fdselect->num_entries++;
+            prev_fd = fdsel;
+        }
+        gid++;
+    }
+    if (gid != num_glyphs)
+        formatted_error("cff","unexpected error: %i != %i", gid, num_glyphs);
+    xfree(data);
+    cff_release_index(cs_idx);
+    xfree(CIDToGIDMap);
+    (charstrings->offset)[num_glyphs] = (l_offset) (charstring_len + 1);
+    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;
+    /*tex
+        We don't use subroutines at all.
+    */
+    if (cffont->gsubr)
+        cff_release_index(cffont->gsubr);
+    cffont->gsubr = cff_new_index(0);
+    for (fdsel = 0; fdsel < cffont->num_fds; fdsel++) {
+        if (cffont->subrs && cffont->subrs[fdsel]) {
+            cff_release_index(cffont->subrs[fdsel]);
+            cffont->subrs[fdsel] = NULL;
+        }
+        if (cffont->private && (cffont->private)[fdsel]) {
+            cff_dict_remove((cffont->private)[fdsel], "Subrs"); /* no Subrs */
+        }
+    }
+    write_fontfile(pdf, cffont, fullname);
+    xfree(fullname);
+    cff_close(cffont);
+}
+
+/*tex
+
+    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.
+
+*/
+
+void writetype1w(PDF pdf, fd_entry * fd)
+{
+    cff_font *cff;
+    int i;
+    FILE *fp;
+    ff_entry *ff;
+    unsigned char *tfm_buffer = NULL;
+    int tfm_size = 0;
+    ff = check_ff_exist(fd->fm->ff_name, 0);
+    fp = fopen(ff->ff_path, "rb");
+    cur_file_name = ff->ff_path;
+    if (!fp) {
+        formatted_error("cff","could not open Type1 font: %s", cur_file_name);
+    }
+    fclose(fp);
+    if (is_subsetted(fd->fm)) {
+        report_start_file(filetype_subset,cur_file_name);
+    } else {
+        report_start_file(filetype_font,cur_file_name);
+    }
+    (void) ff_createcff(ff->ff_path, &tfm_buffer, &tfm_size);
+    if (tfm_size > 0) {
+        cff = read_cff(tfm_buffer, tfm_size, 0);
+        if (cff != NULL) {
+            write_cff(pdf, cff, fd);
+        } else {
+            for (i = 0; i < tfm_size; i++)
+                strbuf_putchar(pdf->fb, tfm_buffer[i]);
+        }
+        fd->ff_found = 1;
+    } else {
+        formatted_error("cff","could not understand Type1 font: %s",cur_file_name);
+    }
+    if (is_subsetted(fd->fm)) {
+        report_stop_file(filetype_subset);
+    } else {
+        report_stop_file(filetype_font);
+    }
+    cur_file_name = NULL;
+}
--- texlive-source/texk/web2c/luatexdir/font/writet1.c.me	1970-01-01 01:00:00.000000000 +0100
+++ texlive-source/texk/web2c/luatexdir/font/writet1.c	2020-11-07 15:50:28.081338255 +0100
@@ -0,0 +1,1693 @@
+/*
+
+Copyright 1996-2006 Han The Thanh <thanh@pdftex.org>
+Copyright 2006-2009 Taco Hoekwater <taco@luatex.org>
+
+This file is part of LuaTeX.
+
+LuaTeX is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 2 of the License, or (at your
+option) any later version.
+
+LuaTeX is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
+License for more details.
+
+You should have received a copy of the GNU General Public License along
+with LuaTeX; if not, see <http://www.gnu.org/licenses/>.
+
+*/
+
+#include "ptexlib.h"
+#include <string.h>
+
+#define get_length1()              t1_length1 = t1_offset() - t1_save_offset
+#define get_length2()              t1_length2 = t1_offset() - t1_save_offset
+#define get_length3()              t1_length3 = fixedcontent? t1_offset() - t1_save_offset : 0
+#define save_offset()              t1_save_offset = t1_offset()
+#define t1_putchar(A)              strbuf_putchar(pdf->fb, (A))
+#define t1_offset()                strbuf_offset(pdf->fb)
+#define out_eexec_char             t1_putchar
+#define end_last_eexec_line()      t1_eexec_encrypt = false
+#define t1_char(c)                 c
+#define embed_all_glyphs(tex_font) fm_cur->all_glyphs
+#define extra_charset()            fm_cur->charset
+#define fixedcontent               false
+
+int t1_length1, t1_length2, t1_length3;
+static int t1_save_offset;
+static int t1_fontname_offset;
+
+static unsigned char *t1_buffer = NULL;
+static int t1_size = 0;
+static int t1_curbyte = 0;
+
+#define t1_read_file()   readbinfile(t1_file,&t1_buffer,&t1_size)
+#define t1_close()       xfclose(t1_file,cur_file_name)
+#define t1_getchar()     t1_buffer[t1_curbyte++]
+#define t1_ungetchar(c)  t1_curbyte--
+#define t1_eof()         (t1_curbyte>t1_size)
+
+#define t1_prefix(s)     str_prefix(t1_line_array, s)
+#define t1_buf_prefix(s) str_prefix(t1_buf_array, s)
+#define t1_suffix(s)     str_suffix(t1_line_array, t1_line_ptr, s)
+#define t1_buf_suffix(s) str_suffix(t1_buf_array, t1_buf_ptr, s)
+#define t1_charstrings() strstr(t1_line_array, charstringname)
+#define t1_subrs()       t1_prefix("/Subrs")
+#define t1_end_eexec()   t1_suffix("mark currentfile closefile")
+#define t1_cleartomark() t1_prefix("cleartomark")
+
+static unsigned char *enc_buffer = NULL;
+static int enc_size = 0;
+static int enc_curbyte = 0;
+
+#define enc_open(a)     (enc_file = fopen((char *)(a), FOPEN_RBIN_MODE))
+#define enc_read_file() readbinfile(enc_file,&enc_buffer,&enc_size)
+#define enc_close()     xfclose(enc_file,cur_file_name)
+#define enc_getchar()   enc_buffer[enc_curbyte++]
+#define enc_eof()       (enc_curbyte>enc_size)
+
+#define valid_code(c)  (c >= 0 && c < 256)
+#define fixedcontent    false
+
+static const char *standard_glyph_names[256] = {
+    /* 0x00 */
+    notdef, notdef, notdef, notdef, notdef, notdef, notdef, notdef, notdef,
+    notdef, notdef, notdef, notdef, notdef, notdef, notdef,
+    /* 0x10 */
+    notdef, notdef, notdef, notdef, notdef, notdef, notdef, notdef, notdef,
+    notdef, notdef, notdef, notdef, notdef, notdef, notdef,
+    /* 0x20 */
+    "space", "exclam", "quotedbl", "numbersign", "dollar", "percent",
+    "ampersand", "quoteright", "parenleft", "parenright", "asterisk",
+    "plus", "comma", "hyphen", "period", "slash",
+    /* 0x30 */
+    "zero", "one", "two", "three", "four", "five", "six", "seven", "eight",
+    "nine", "colon", "semicolon", "less", "equal", "greater", "question",
+    /* 0x40 */
+    "at", "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N",
+    "O",
+    /* 0x50 */
+    "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z", "bracketleft",
+    "backslash", "bracketright", "asciicircum", "underscore",
+    /* 0x60 */
+    "quoteleft", "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l",
+    "m", "n", "o",
+    /* 0x70 */
+    "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z", "braceleft", "bar",
+    "braceright", "asciitilde", notdef,
+    /* 0x80 */
+    notdef, notdef, notdef, notdef, notdef, notdef, notdef, notdef, notdef,
+    notdef, notdef, notdef, notdef, notdef, notdef, notdef,
+    /* 0x90 */
+    notdef, notdef, notdef, notdef, notdef, notdef, notdef, notdef, notdef,
+    notdef, notdef, notdef, notdef, notdef, notdef, notdef,
+    /* 0xa0 */
+    notdef, "exclamdown", "cent", "sterling", "fraction", "yen", "florin",
+    "section", "currency", "quotesingle", "quotedblleft", "guillemotleft",
+    "guilsinglleft", "guilsinglright", "fi", "fl",
+    /* 0xb0 */
+    notdef, "endash", "dagger", "daggerdbl", "periodcentered", notdef,
+    "paragraph", "bullet", "quotesinglbase", "quotedblbase",
+    "quotedblright", "guillemotright", "ellipsis", "perthousand", notdef,
+    "questiondown",
+    /* 0xc0 */
+    notdef, "grave", "acute", "circumflex", "tilde", "macron", "breve",
+    "dotaccent", "dieresis", notdef,
+    "ring", "cedilla", notdef, "hungarumlaut", "ogonek", "caron",
+    /* 0xd0 */
+    "emdash", notdef, notdef, notdef, notdef, notdef, notdef, notdef, notdef,
+    notdef, notdef, notdef, notdef, notdef, notdef, notdef,
+    /* 0xe0 */
+    notdef, "AE", notdef, "ordfeminine", notdef, notdef, notdef, notdef,
+    "Lslash", "Oslash", "OE", "ordmasculine", notdef, notdef, notdef,
+    notdef,
+    /* 0xf0 */
+    notdef, "ae", notdef, notdef, notdef, "dotlessi", notdef, notdef, "lslash",
+    "oslash", "oe", "germandbls", notdef, notdef, notdef, notdef
+};
+
+static fd_entry *fd_cur;
+
+static char charstringname[] = "/CharStrings";
+
+enum { ENC_STANDARD, ENC_BUILTIN } t1_encoding;
+
+#define T1_BUF_SIZE   0x0010
+#define ENC_BUF_SIZE  0x1000
+
+#define CS_HSTEM             1
+#define CS_VSTEM             3
+#define CS_VMOVETO           4
+#define CS_RLINETO           5
+#define CS_HLINETO           6
+#define CS_VLINETO           7
+#define CS_RRCURVETO         8
+#define CS_CLOSEPATH         9
+#define CS_CALLSUBR         10
+#define CS_RETURN           11
+#define CS_ESCAPE           12
+#define CS_HSBW             13
+#define CS_ENDCHAR          14
+#define CS_RMOVETO          21
+#define CS_HMOVETO          22
+#define CS_VHCURVETO        30
+#define CS_HVCURVETO        31
+#define CS_1BYTE_MAX        (CS_HVCURVETO + 1)
+
+#define CS_DOTSECTION       CS_1BYTE_MAX +  0
+#define CS_VSTEM3           CS_1BYTE_MAX +  1
+#define CS_HSTEM3           CS_1BYTE_MAX +  2
+#define CS_SEAC             CS_1BYTE_MAX +  6
+#define CS_SBW              CS_1BYTE_MAX +  7
+#define CS_DIV              CS_1BYTE_MAX + 12
+#define CS_CALLOTHERSUBR    CS_1BYTE_MAX + 16
+#define CS_POP              CS_1BYTE_MAX + 17
+#define CS_SETCURRENTPOINT  CS_1BYTE_MAX + 33
+#define CS_2BYTE_MAX        (CS_SETCURRENTPOINT + 1)
+#define CS_MAX              CS_2BYTE_MAX
+
+typedef unsigned char byte;
+
+/*tex A |CharString| command: */
+
+typedef struct {
+    /*tex number of arguments */
+    byte nargs;
+    /*tex take arguments from bottom of stack? */
+    boolean bottom;
+    /*tex clear stack? */
+    boolean clear;
+    boolean valid;
+} cc_entry;
+
+typedef struct {
+    /*tex glyph name (or |notdef| for |Subrs| entry) */
+    char *name;
+    byte *data;
+    /*tex length of the whole string */
+    unsigned short len;
+    /*tex length of the encoded part of the string */
+    unsigned short cslen;
+    boolean used;
+    boolean valid;
+} cs_entry;
+
+static unsigned short t1_dr, t1_er;
+static const unsigned short t1_c1 = 52845, t1_c2 = 22719;
+static unsigned short t1_cslen;
+static short t1_lenIV;
+static char enc_line[ENC_BUF_SIZE];
+
+#define t1_line_entry char
+define_array(t1_line);
+
+#define t1_buf_entry char
+define_array(t1_buf);
+
+static int cs_start;
+
+static cs_entry *cs_tab, *cs_ptr, *cs_notdef;
+static char *cs_dict_start, *cs_dict_end;
+static int cs_counter, cs_size, cs_size_pos;
+
+static cs_entry *subr_tab;
+static char *subr_array_start, *subr_array_end;
+static int subr_max, subr_size, subr_size_pos;
+
+/*tex
+
+    This list contains the begin/end tokens commonly used in the |/Subrs| array of
+    a Type 1 font.
+
+*/
+
+static const char *cs_token_pairs_list[][2] = {
+    { " RD", "NP" },
+    { " -|", "|" },
+    { " RD", "noaccess put" },
+    { " -|", "noaccess put" },
+    { NULL,  NULL }
+};
+
+static const char **cs_token_pair;
+
+static boolean t1_pfa, t1_cs, t1_scan, t1_eexec_encrypt, t1_synthetic;
+
+/*tex This one becomes 0 before 1 during and 2 after |eexec| encryption. */
+
+static int t1_in_eexec;
+
+static long t1_block_length;
+static int last_hexbyte;
+static FILE *t1_file;
+static FILE *enc_file;
+
+static void enc_getline(void)
+{
+    char *p;
+    char c;
+  restart:
+    if (enc_eof())
+        normal_error("type 1","unexpected end of file");
+    p = enc_line;
+    do {
+        c = (char) enc_getchar();
+        append_char_to_buf(c, p, enc_line, ENC_BUF_SIZE);
+    }
+    while (c != 10 && !enc_eof());
+    append_eol(p, enc_line, ENC_BUF_SIZE);
+    if (p - enc_line < 2 || *enc_line == '%')
+        goto restart;
+}
+
+/*tex
+
+    Read encoding from .enc file, return |glyph_names array|, or |pdffail|.
+
+*/
+
+char **load_enc_file(char *enc_name)
+{
+    int callback_id = 0;
+    int file_opened = 0;
+    char buf[ENC_BUF_SIZE], *p, *r;
+    int i, names_count;
+    char **glyph_names;
+    cur_file_name = luatex_find_file(enc_name, find_enc_file_callback);
+    if (cur_file_name == NULL) {
+        formatted_error("type 1","cannot find encoding file '%s' for reading", enc_name);
+    }
+    callback_id = callback_defined(read_enc_file_callback);
+    enc_curbyte = 0;
+    enc_size = 0;
+    if (callback_id > 0) {
+        if (run_callback(callback_id, "S->bSd", cur_file_name, &file_opened, &enc_buffer, &enc_size)) {
+            if ((!file_opened) || enc_size == 0) {
+                formatted_error("type 1","cannot open encoding file '%s' for reading", cur_file_name);
+            }
+        }
+    } else {
+        if (!enc_open(cur_file_name)) {
+            formatted_error("type 1","cannot open encoding file '%s' for reading", cur_file_name);
+        }
+        enc_read_file();
+        enc_close();
+    }
+    glyph_names = xtalloc(256, char *);
+    for (i = 0; i < 256; i++)
+        glyph_names[i] = (char *) notdef;
+    report_start_file(filetype_map,cur_file_name);
+    enc_getline();
+    if (*enc_line != '/' || (r = strchr(enc_line, '[')) == NULL) {
+        remove_eol(r, enc_line);
+        formatted_error("type 1","invalid encoding vector (a name or '[' missing): '%s'", enc_line);
+    }
+    names_count = 0;
+    /*tex Skip |[|: */
+    r++;
+    skip_char(r, ' ');
+    for (;;) {
+        while (*r == '/') {
+            for (p = buf, r++;
+                 *r != ' ' && *r != 10 && *r != ']' && *r != '/'; *p++ = *r++);
+            *p = 0;
+            skip_char(r, ' ');
+            if (names_count >= 256)
+                normal_error("type 1","encoding vector contains more than 256 names");
+            if (strcmp(buf, notdef) != 0)
+                glyph_names[names_count] = xstrdup(buf);
+            names_count++;
+        }
+        if (*r != 10 && *r != '%') {
+            if (strncmp(r, "] def", strlen("] def")) == 0)
+                goto done;
+            else {
+                remove_eol(r, enc_line);
+                formatted_error("type 1","invalid encoding vector: a name or '] def' expected: `%s'",enc_line);
+            }
+        }
+        enc_getline();
+        r = enc_line;
+    }
+  done:
+    report_stop_file(filetype_map);
+    cur_file_name = NULL;
+    xfree(enc_buffer);
+    return glyph_names;
+}
+
+static void t1_check_pfa(void)
+{
+    const int c = t1_getchar();
+    t1_pfa = (c != 128) ? true : false;
+    t1_ungetchar(c);
+}
+
+static int t1_getbyte(void)
+{
+    int c = t1_getchar();
+    if (t1_pfa)
+        return c;
+    if (t1_block_length == 0) {
+        if (c != 128)
+            normal_error("type 1","invalid marker");
+        c = t1_getchar();
+        if (c == 3) {
+            while (!t1_eof())
+                (void) t1_getchar();
+            return EOF;
+        }
+        t1_block_length = t1_getchar() & 0xff;
+        t1_block_length |= (t1_getchar() & 0xff) << 8;
+        t1_block_length |= (t1_getchar() & 0xff) << 16;
+        t1_block_length |= (t1_getchar() & 0xff) << 24;
+        c = t1_getchar();
+    }
+    t1_block_length--;
+    return c;
+}
+
+static int hexval(int c)
+{
+    if (c >= 'A' && c <= 'F')
+        return c - 'A' + 10;
+    else if (c >= 'a' && c <= 'f')
+        return c - 'a' + 10;
+    else if (c >= '0' && c <= '9')
+        return c - '0';
+    else
+        return -1;
+}
+
+static byte edecrypt(byte cipher)
+{
+    byte plain;
+    if (t1_pfa) {
+        while (cipher == 10 || cipher == 13)
+            cipher = (byte) t1_getbyte();
+        last_hexbyte = cipher = (byte) ((hexval(cipher) << 4) + hexval(t1_getbyte()));
+    }
+    plain = (byte) (cipher ^ (t1_dr >> 8));
+    t1_dr = (unsigned short) ((cipher + t1_dr) * t1_c1 + t1_c2);
+    return plain;
+}
+
+static byte cdecrypt(byte cipher, unsigned short *cr)
+{
+    const byte plain = (byte) (cipher ^ (*cr >> 8));
+    *cr = (unsigned short) ((cipher + *cr) * t1_c1 + t1_c2);
+    return plain;
+}
+
+static byte eencrypt(byte plain)
+{
+    const byte cipher = (byte) (plain ^ (t1_er >> 8));
+    t1_er = (unsigned short) ((cipher + t1_er) * t1_c1 + t1_c2);
+    return cipher;
+}
+
+static byte cencrypt(byte plain, unsigned short *cr)
+{
+    const byte cipher = (byte) (plain ^ (*cr >> 8));
+    *cr = (unsigned short) ((cipher + *cr) * t1_c1 + t1_c2);
+    return cipher;
+}
+
+static char *eol(char *s)
+{
+    char *p = strend(s);
+    if (p - s > 1 && p[-1] != 10) {
+        *p++ = 10;
+        *p = 0;
+    }
+    return p;
+}
+
+static float t1_scan_num(char *p, char **r)
+{
+    float f;
+    skip_char(p, ' ');
+    if (sscanf(p, "%g", &f) != 1) {
+        remove_eol(p, t1_line_array);
+        formatted_error("type 1","a number expected: '%s'", t1_line_array);
+    }
+    if (r != NULL) {
+        for (; isdigit((unsigned char)*p) || *p == '.' ||
+             *p == 'e' || *p == 'E' || *p == '+' || *p == '-'; p++);
+        *r = p;
+    }
+    return f;
+}
+
+static boolean str_suffix(const char *begin_buf, const char *end_buf, const char *s)
+{
+    const char *s1 = end_buf - 1, *s2 = strend(s) - 1;
+    if (*s1 == 10)
+        s1--;
+    while (s1 >= begin_buf && s2 >= s) {
+        if (*s1-- != *s2--)
+            return false;
+    }
+    return s2 < s;
+}
+
+static void t1_getline(void)
+{
+    int c, l, eexec_scan;
+    char *p;
+    static const char eexec_str[] = "currentfile eexec";
+    static int eexec_len = 17;
+  restart:
+    if (t1_eof())
+        normal_error("type 1","unexpected end of file");
+    t1_line_ptr = t1_line_array;
+    alloc_array(t1_line, 1, T1_BUF_SIZE);
+    t1_cslen = 0;
+    eexec_scan = 0;
+    c = t1_getbyte();
+    if (c == EOF)
+        goto exit;
+    while (!t1_eof()) {
+        if (t1_in_eexec == 1)
+            c = edecrypt((byte) c);
+        alloc_array(t1_line, 1, T1_BUF_SIZE);
+        {
+            char cc = (char) c;
+            append_char_to_buf(cc, t1_line_ptr, t1_line_array, t1_line_limit);
+        }
+        if (t1_in_eexec == 0 && eexec_scan >= 0 && eexec_scan < eexec_len) {
+            if (t1_line_array[eexec_scan] == eexec_str[eexec_scan])
+                eexec_scan++;
+            else
+                eexec_scan = -1;
+        }
+        if (c == 10 || c == 13
+            || (t1_pfa && eexec_scan == eexec_len && c == 32)) {
+            break;
+        }
+        if (t1_cs && t1_cslen == 0 && (t1_line_ptr - t1_line_array > 4) &&
+            (t1_suffix(" RD ") || t1_suffix(" -| "))) {
+            p = t1_line_ptr - 5;
+            while (*p != ' ')
+                p--;
+            l = (int) t1_scan_num(p + 1, 0);
+            t1_cslen = (unsigned short) l;
+            /*tex |cs_start| is an index now */
+            cs_start = (int) (t1_line_ptr - t1_line_array);
+            alloc_array(t1_line, l, T1_BUF_SIZE);
+            while (l-- > 0)
+                *t1_line_ptr++ = (t1_line_entry) edecrypt((byte) t1_getbyte());
+        }
+        c = t1_getbyte();
+    }
+    /*tex |append_eol| can append 2 chars */
+    alloc_array(t1_line, 2, T1_BUF_SIZE);
+    append_eol(t1_line_ptr, t1_line_array, t1_line_limit);
+    if (t1_line_ptr - t1_line_array < 2)
+        goto restart;
+    if (eexec_scan == eexec_len)
+        t1_in_eexec = 1;
+  exit:
+    /*tex Ensure that |t1_buf_array| has as much room as |t1_line_array|. */
+    t1_buf_ptr = t1_buf_array;
+    alloc_array(t1_buf, t1_line_limit, t1_line_limit);
+}
+
+static void t1_putline(PDF pdf)
+{
+    char *p = t1_line_array;
+    if (t1_line_ptr - t1_line_array <= 1)
+        return;
+    if (t1_eexec_encrypt) {
+        while (p < t1_line_ptr)
+            t1_putchar((eight_bits) eencrypt((byte) * p++));
+    } else
+        while (p < t1_line_ptr)
+            t1_putchar((eight_bits) * p++);
+}
+
+static void t1_puts(PDF pdf, const char *s)
+{
+    if (s != t1_line_array)
+        strcpy(t1_line_array, s);
+    t1_line_ptr = strend(t1_line_array);
+    t1_putline(pdf);
+}
+
+__attribute__ ((format(printf, 2, 3)))
+static void t1_printf(PDF pdf, const char *fmt, ...)
+{
+    va_list args;
+    va_start(args, fmt);
+    vsprintf(t1_line_array, fmt, args);
+    t1_puts(pdf, t1_line_array);
+    va_end(args);
+}
+
+static void t1_init_params(int open_name_prefix)
+{
+    report_start_file(open_name_prefix,cur_file_name);
+    t1_lenIV = 4;
+    t1_dr = 55665;
+    t1_er = 55665;
+    t1_in_eexec = 0;
+    t1_cs = false;
+    t1_scan = true;
+    t1_synthetic = false;
+    t1_eexec_encrypt = false;
+    t1_block_length = 0;
+    t1_check_pfa();
+}
+
+static void t1_close_font_file(int close_name_suffix)
+{
+    report_stop_file(close_name_suffix);
+    cur_file_name = NULL;
+}
+
+static void t1_check_block_len(boolean decrypt)
+{
+    int l, c;
+    if (t1_block_length == 0)
+        return;
+    c = t1_getbyte();
+    if (decrypt)
+        c = edecrypt((byte) c);
+    l = (int) t1_block_length;
+    if (!(l == 0 && (c == 10 || c == 13))) {
+        formatted_error("type 1","%i bytes more than expected were ignored", l + 1);
+    }
+}
+
+static void t1_start_eexec(PDF pdf)
+{
+    int i;
+    get_length1();
+    save_offset();
+    if (!t1_pfa)
+        t1_check_block_len(false);
+    for (t1_line_ptr = t1_line_array, i = 0; i < 4; i++) {
+        edecrypt((byte) t1_getbyte());
+        *t1_line_ptr++ = 0;
+    }
+    t1_eexec_encrypt = true;
+    /*tex To put the first four bytes: */
+    t1_putline(pdf);
+}
+
+static void t1_stop_eexec(PDF pdf)
+{
+    int c;
+    get_length2();
+    save_offset();
+    t1_eexec_encrypt = false;
+    if (!t1_pfa)
+        t1_check_block_len(true);
+    else {
+        c = edecrypt((byte) t1_getbyte());
+        if (!(c == 10 || c == 13)) {
+            if (last_hexbyte == 0)
+                t1_puts(pdf, "00");
+            else
+                normal_error("type 1","unexpected data after eexec");
+        }
+    }
+    t1_cs = false;
+    t1_in_eexec = 2;
+}
+
+/*tex Macros for various transforms; unused, left for reference: */
+
+#ifdef T1TRANSFORMMACROS
+#  define do_xshift(x,a) {x[4]+=a;}
+#  define do_yshift(x,a) {x[5]+=a;}
+#  define do_xscale(x,a) {x[0]*=a; x[2]*=a; x[4]*=a;}
+#  define do_yscale(x,a) {x[1]*=a; x[3]*=a; x[5]*=a;}
+#  define do_extend(x,a) {do_xscale(x,a);}
+#  define do_scale(x,a)  {do_xscale(x,a); do_yscale(x,a);}
+#  define do_slant(x,a)  {x[0]+=x[1]*(a); x[2]+=x[3]*(a); x[4]+=x[5]*(a);}
+#  define do_shear(x,a)  {x[1]+=x[0]*(a); x[3]+=x[2]*(a); x[5]+=x[4]*(a);}
+
+#  define do_rotate(x,a) {        \
+    float t, u=cos(a), v=sin(a);  \
+    t    =x[0]*u+x[1]*-v;         \
+    x[1] =x[0]*v+x[1]* u; x[0]=t; \
+    t    =x[2]*u+x[3]*-v;         \
+    x[3] =x[2]*v+x[3]* u; x[2]=t; \
+    t    =x[4]*u+x[5]*-v;         \
+    x[5] =x[4]*v+x[5]* u; x[4]=t; \
+}
+#endif
+
+static void t1_scan_keys(PDF pdf)
+{
+    int i, k;
+    char *p, *q, *r;
+    const key_entry *key;
+    if (t1_prefix("/FontType")) {
+        p = t1_line_array + strlen("FontType") + 1;
+        if ((i = (int) t1_scan_num(p, 0)) != 1)
+            formatted_error("type 1","Type%d fonts unsupported by backend", i);
+        return;
+    }
+    for (key = (const key_entry *) font_key; key - font_key < FONT_KEYS_NUM;
+         key++) {
+        if (key->t1name[0] != '\0'
+            && str_prefix(t1_line_array + 1, key->t1name))
+            break;
+    }
+    if (key - font_key == FONT_KEYS_NUM)
+        return;
+    p = t1_line_array + strlen(key->t1name) + 1;
+    skip_char(p, ' ');
+    if ((k = (int) (key - font_key)) == FONTNAME_CODE) {
+        if (*p != '/') {
+            remove_eol(p, t1_line_array);
+            formatted_error("type 1","a name expected: '%s'", t1_line_array);
+        }
+        /*tex Skip the slash. */
+        r = ++p;
+        for (q = t1_buf_array; *p != ' ' && *p != 10; *q++ = *p++);
+        *q = 0;
+        xfree(fd_cur->fontname);
+        fd_cur->fontname = xstrdup(t1_buf_array);
+        /*tex
+
+            At this moment we cannot call |make_subset_tag| yet, as the encoding
+            is not read; thus we mark the offset of the subset tag and write it
+            later.
+
+        */
+        if (is_subsetted(fd_cur->fm)) {
+            t1_fontname_offset = (int) (t1_offset() + (r - t1_line_array));
+            strcpy(t1_buf_array, p);
+            sprintf(r, "ABCDEF+%s%s", fd_cur->fontname, t1_buf_array);
+            t1_line_ptr = eol(r);
+        }
+        return;
+    }
+    if ((k == STEMV_CODE || k == FONTBBOX1_CODE) && (*p == '[' || *p == '{'))
+        p++;
+    if (k == FONTBBOX1_CODE) {
+        for (i = 0; i < 4; i++, k++) {
+            fd_cur->font_dim[k].val = (int) t1_scan_num(p, &r);
+            fd_cur->font_dim[k].set = true;
+            p = r;
+        }
+        return;
+    }
+    fd_cur->font_dim[k].val = (int) t1_scan_num(p, 0);
+    fd_cur->font_dim[k].set = true;
+}
+
+static void t1_scan_param(PDF pdf)
+{
+    static const char *lenIV = "/lenIV";
+    if (!t1_scan || *t1_line_array != '/')
+        return;
+    if (t1_prefix(lenIV)) {
+        t1_lenIV = (short) t1_scan_num(t1_line_array + strlen(lenIV), 0);
+        if (t1_lenIV < 0)
+            normal_error("type 1","negative value of lenIV is not supported");
+        return;
+    }
+    t1_scan_keys(pdf);
+}
+
+static void copy_glyph_names(char **glyph_names, int a, int b)
+{
+    if (glyph_names[b] != notdef) {
+        xfree(glyph_names[b]);
+        glyph_names[b] = (char *) notdef;
+    }
+    if (glyph_names[a] != notdef) {
+        glyph_names[b] = xstrdup(glyph_names[a]);
+    }
+}
+
+/*tex Read encoding from Type1 font file, return |glyph_names| array, or |pdffail|. */
+
+static char **t1_builtin_enc(void)
+{
+    int i, a, b, c, counter = 0;
+    char *r, *p, **glyph_names;
+    /*tex At this moment |/Encoding| is the prefix of |t1_line_array|. */
+    glyph_names = xtalloc(256, char *);
+    for (i = 0; i < 256; i++)
+        glyph_names[i] = (char *) notdef;
+    if (t1_suffix("def")) {
+        /*tex A predefined encoding: */
+        sscanf(t1_line_array + strlen("/Encoding"), "%255s", t1_buf_array);
+        if (strcmp(t1_buf_array, "StandardEncoding") == 0) {
+            t1_encoding = ENC_STANDARD;
+            for (i = 0; i < 256; i++) {
+                if (standard_glyph_names[i] != notdef)
+                    glyph_names[i] = xstrdup(standard_glyph_names[i]);
+            }
+            return glyph_names;
+        } else
+            formatted_error("type 1","cannot subset font (unknown predefined encoding '%s')",t1_buf_array);
+    }
+    /*
+
+        At this moment |/Encoding| is the prefix of |t1_line_array|, and the
+        encoding is not a predefined encoding. We have two possible forms of
+        vector. The first case is
+
+        \starttyping
+        /Encoding [
+            /a /b /c ...
+        ] readonly def
+        \stoptyping
+
+        and the second case can look like
+
+        \starttyping
+        /Encoding 256 array 0 1 255 {
+            1 index exch /.notdef put} for
+            dup 0 /x put
+            dup 1 /y put
+            ...
+        } readonly def
+        \stoptyping
+
+    */
+    t1_encoding = ENC_BUILTIN;
+    if (t1_prefix("/Encoding [") || t1_prefix("/Encoding[")) {  /* the first case */
+        r = strchr(t1_line_array, '[') + 1;
+        skip_char(r, ' ');
+        for (;;) {
+            while (*r == '/') {
+                for (p = t1_buf_array, r++; *r != 32 && *r != 10 && *r != ']' && *r != '/'; *p++ = *r++);
+                *p = 0;
+                skip_char(r, ' ');
+                if (counter > 255)
+                    normal_error("type 1","encoding vector contains more than 256 names");
+                if (strcmp(t1_buf_array, notdef) != 0)
+                    glyph_names[counter] = xstrdup(t1_buf_array);
+                counter++;
+            }
+            if (*r != 10 && *r != '%') {
+                if (str_prefix(r, "] def") || str_prefix(r, "] readonly def"))
+                    break;
+                else {
+                    remove_eol(r, t1_line_array);
+                    formatted_error("type 1","a name or '] def' or '] readonly def' expected: '%s'", t1_line_array);
+                }
+            }
+            t1_getline();
+            r = t1_line_array;
+        }
+    } else {
+        /*tex The second case. */
+        p = strchr(t1_line_array, 10);
+        for (;;) {
+            if (*p == 10) {
+                t1_getline();
+                p = t1_line_array;
+            }
+            /*tex Check for |dup <index> <glyph> put|. */
+            if (sscanf(p, "dup %i%255s put", &i, t1_buf_array) == 2 &&
+                *t1_buf_array == '/' && valid_code(i)) {
+                if (strcmp(t1_buf_array + 1, notdef) != 0)
+                    glyph_names[i] = xstrdup(t1_buf_array + 1);
+                p = strstr(p, " put") + strlen(" put");
+                skip_char(p, ' ');
+            }
+            /*tex Check for |dup dup <to> exch <from> get put|. */
+            else if (sscanf(p, "dup dup %i exch %i get put", &b, &a) == 2 && valid_code(a) && valid_code(b)) {
+                copy_glyph_names(glyph_names, a, b);
+                p = strstr(p, " get put") + strlen(" get put");
+                skip_char(p, ' ');
+            }
+            /*tex Check for |dup dup <from> <size> getinterval <to> exch putinterval|. */
+            else if (sscanf(p, "dup dup %i %i getinterval %i exch putinterval",
+                    &a, &c, &b) == 3 && valid_code(a) && valid_code(b) && valid_code(c)) {
+                for (i = 0; i < c; i++)
+                    copy_glyph_names(glyph_names, a + i, b + i);
+                p = strstr(p, " putinterval") + strlen(" putinterval");
+                skip_char(p, ' ');
+            }
+            /*tex Check for |def or |readonly def|. */
+            else if ((p == t1_line_array || (p > t1_line_array && p[-1] == ' ')) && strcmp(p, "def\n") == 0) {
+                return glyph_names;
+            } else {
+                /*tex Skip an unrecognizable word. */
+                while (*p != ' ' && *p != 10)
+                    p++;
+                skip_char(p, ' ');
+            }
+        }
+    }
+    return glyph_names;
+}
+
+static void t1_check_end(PDF pdf)
+{
+    if (t1_eof())
+        return;
+    t1_getline();
+    if (t1_prefix("{restore}"))
+        t1_putline(pdf);
+}
+
+static boolean t1_open_fontfile(int open_name_prefix)
+{
+    ff_entry *ff;
+    int callback_id = 0;
+    int file_opened = 0;
+    t1_curbyte = 0;
+    t1_size = 0;
+    ff = check_ff_exist(fd_cur->fm->ff_name, is_truetype(fd_cur->fm));
+    if (ff->ff_path == NULL) {
+        formatted_error("type 1","cannot open file for reading '%s'",fd_cur->fm->ff_name);
+        return false;
+    }
+    cur_file_name = luatex_find_file(ff->ff_path, find_type1_file_callback);
+    if (cur_file_name == NULL) {
+        formatted_error("type 1","cannot open file for reading '%s'", ff->ff_path);
+        return false;
+    }
+    callback_id = callback_defined(read_type1_file_callback);
+    if (callback_id > 0) {
+        if (!run_callback(callback_id, "S->bSd", cur_file_name, &file_opened, &t1_buffer, &t1_size)
+            && file_opened && t1_size > 0) {
+            formatted_warning("type 1","cannot open file for reading '%s'",cur_file_name);
+            return false;
+        }
+    } else {
+        t1_file = xfopen(cur_file_name, FOPEN_RBIN_MODE);
+        t1_read_file();
+        t1_close();
+    }
+    recorder_record_input(cur_file_name);
+    t1_init_params(open_name_prefix);
+    return true;
+}
+
+static void t1_include(PDF pdf)
+{
+    do {
+        t1_getline();
+        t1_scan_param(pdf);
+        t1_putline(pdf);
+    }
+    while (t1_in_eexec == 0);
+    t1_start_eexec(pdf);
+    do {
+        t1_getline();
+        t1_scan_param(pdf);
+        t1_putline(pdf);
+    }
+    while (!(t1_charstrings() || t1_subrs()));
+    t1_cs = true;
+    do {
+        t1_getline();
+        t1_putline(pdf);
+    }
+    while (!t1_end_eexec());
+    t1_stop_eexec(pdf);
+    if (fixedcontent) {
+        /*tex Copy 512 zeros (not needed for \PDF). */
+        do {
+            t1_getline();
+            t1_putline(pdf);
+        }
+        while (!t1_cleartomark());
+        /*tex Write |{restore} if| if found. */
+        t1_check_end(pdf);
+    }
+    get_length3();
+}
+
+#define check_subr(subr) \
+    if (subr >= subr_size || subr < 0) \
+        formatted_error("type 1","Subrs array: entry index out of range '%i'", subr);
+
+static const char **check_cs_token_pair(void)
+{
+    const char **p = (const char **) cs_token_pairs_list;
+    for (; p[0] != NULL; ++p)
+        if (t1_buf_prefix(p[0]) && t1_buf_suffix(p[1]))
+            return p;
+    return NULL;
+}
+
+static void cs_store(boolean is_subr)
+{
+    char *p;
+    cs_entry *ptr;
+    int subr;
+    for (p = t1_line_array, t1_buf_ptr = t1_buf_array; *p != ' ';
+         *t1_buf_ptr++ = *p++);
+    *t1_buf_ptr = 0;
+    if (is_subr) {
+        subr = (int) t1_scan_num(p + 1, 0);
+        check_subr(subr);
+        ptr = subr_tab + subr;
+    } else {
+        ptr = cs_ptr++;
+        if (cs_ptr - cs_tab > cs_size)
+            formatted_error("type 1","CharStrings dict: more entries than dict size '%i'", cs_size);
+        if (strcmp(t1_buf_array + 1, notdef) == 0)      /* skip the slash */
+            ptr->name = (char *) notdef;
+        else
+            ptr->name = xstrdup(t1_buf_array + 1);
+    }
+    /*tex Copy |" RD " + cs data| to |t1_buf_array|. */
+    memcpy(t1_buf_array, t1_line_array + cs_start - 4, (unsigned) (t1_cslen + 4));
+    /*tex Copy the end of cs data to |t1_buf_array|. */
+    for (p = t1_line_array + cs_start + t1_cslen, t1_buf_ptr =
+         t1_buf_array + t1_cslen + 4; *p != 10; *t1_buf_ptr++ = *p++);
+    *t1_buf_ptr++ = 10;
+    if (is_subr && cs_token_pair == NULL)
+        cs_token_pair = check_cs_token_pair();
+    ptr->len = (unsigned short) (t1_buf_ptr - t1_buf_array);
+    ptr->cslen = t1_cslen;
+    xfree(ptr->data);
+    ptr->data = xtalloc(ptr->len, byte);
+    memcpy(ptr->data, t1_buf_array, ptr->len);
+    ptr->valid = true;
+}
+
+#define store_subr() cs_store(true)
+#define store_cs()   cs_store(false)
+
+#define CC_STACK_SIZE 24
+
+static int cc_stack[CC_STACK_SIZE], *stack_ptr = cc_stack;
+static cc_entry cc_tab[CS_MAX];
+static boolean is_cc_init = false;
+
+#define cc_pop(N) \
+    if (stack_ptr - cc_stack < (N)) \
+        stack_error(N); \
+    stack_ptr -= N
+
+#define stack_error(N) { \
+    formatted_error("type 1","CharString: invalid access '%i' to stack, '%i' entries", (int) N, (int)(stack_ptr - cc_stack)); \
+    goto cs_error; \
+}
+
+#define cc_get(N)  ((N) < 0 ? *(stack_ptr + (N)) : *(cc_stack + (N)))
+#define cc_push(V) *stack_ptr++ = V
+#define cc_clear() stack_ptr = cc_stack
+
+#define set_cc(N, B, A, C) \
+    cc_tab[N].nargs = A;   \
+    cc_tab[N].bottom = B;  \
+    cc_tab[N].clear = C;   \
+    cc_tab[N].valid = true
+
+static void cc_init(void)
+{
+    int i;
+    if (is_cc_init)
+        return;
+    for (i = 0; i < CS_MAX; i++)
+        cc_tab[i].valid = false;
+    set_cc(CS_HSTEM, true, 2, true);
+    set_cc(CS_VSTEM, true, 2, true);
+    set_cc(CS_VMOVETO, true, 1, true);
+    set_cc(CS_RLINETO, true, 2, true);
+    set_cc(CS_HLINETO, true, 1, true);
+    set_cc(CS_VLINETO, true, 1, true);
+    set_cc(CS_RRCURVETO, true, 6, true);
+    set_cc(CS_CLOSEPATH, false, 0, true);
+    set_cc(CS_CALLSUBR, false, 1, false);
+    set_cc(CS_RETURN, false, 0, false);
+    set_cc(CS_HSBW, true, 2, true);
+    set_cc(CS_ENDCHAR, false, 0, true);
+    set_cc(CS_RMOVETO, true, 2, true);
+    set_cc(CS_HMOVETO, true, 1, true);
+    set_cc(CS_VHCURVETO, true, 4, true);
+    set_cc(CS_HVCURVETO, true, 4, true);
+    set_cc(CS_DOTSECTION, false, 0, true);
+    set_cc(CS_VSTEM3, true, 6, true);
+    set_cc(CS_HSTEM3, true, 6, true);
+    set_cc(CS_SEAC, true, 5, true);
+    set_cc(CS_SBW, true, 4, true);
+    set_cc(CS_DIV, false, 2, false);
+    set_cc(CS_CALLOTHERSUBR, false, 0, false);
+    set_cc(CS_POP, false, 0, false);
+    set_cc(CS_SETCURRENTPOINT, true, 2, true);
+    is_cc_init = true;
+}
+
+#define cs_getchar()    cdecrypt(*data++, &cr)
+
+#define mark_subr(n)    cs_mark(0, n)
+#define mark_cs(s)      cs_mark(s, 0)
+
+static void cs_fail(const char *cs_name, int subr, const char *fmt, ...)
+{
+    char buf[SMALL_BUF_SIZE];
+    va_list args;
+    va_start(args, fmt);
+    vsprintf(buf, fmt, args);
+    va_end(args);
+    if (cs_name == NULL)
+        formatted_error("type 1","Subr '%i': %s", (int) subr, buf);
+    else
+        formatted_error("type 1","CharString (/%s): %s", cs_name, buf);
+}
+
+/*tex Fix a return-less subr by appending |CS_RETURN|. */
+
+static void append_cs_return(cs_entry * ptr)
+{
+    unsigned short cr;
+    int i;
+    byte *p, *q, *data, *new_data;
+    /*tex Decrypt the cs data to |t1_buf_array|, append |CS_RETURN|. */
+    p = (byte *) t1_buf_array;
+    data = ptr->data + 4;
+    cr = 4330;
+    for (i = 0; i < ptr->cslen; i++)
+        *p++ = cs_getchar();
+    *p = CS_RETURN;
+    /*tex Encrypt the new cs data to |new_data|. */
+    new_data = xtalloc((unsigned) (ptr->len + 1), byte);
+    memcpy(new_data, ptr->data, 4);
+    p = new_data + 4;
+    q = (byte *) t1_buf_array;
+    cr = 4330;
+    for (i = 0; i < ptr->cslen + 1; i++)
+        *p++ = cencrypt(*q++, &cr);
+    memcpy(p, ptr->data + 4 + ptr->cslen, (size_t) (ptr->len - ptr->cslen - 4));
+    /*tex Update |*ptr|. */
+    xfree(ptr->data);
+    ptr->data = new_data;
+    ptr->len++;
+    ptr->cslen++;
+}
+
+static void cs_mark(const char *cs_name, int subr)
+{
+    byte *data;
+    int i, b, cs_len;
+    int last_cmd = 0;
+    int a, a1, a2;
+    unsigned short cr;
+    /*tex The argument of last call to |OtherSubrs[3]|. */
+    static int lastargOtherSubr3 = 3;
+    cs_entry *ptr;
+    cc_entry *cc;
+    if (cs_name == NULL) {
+        check_subr(subr);
+        ptr = subr_tab + subr;
+        if (!ptr->valid)
+            return;
+    } else if (cs_notdef != NULL && (cs_name == notdef || strcmp(cs_name, notdef) == 0)) {
+        ptr = cs_notdef;
+    }else {
+        for (ptr = cs_tab; ptr < cs_ptr; ptr++)
+            if (strcmp(ptr->name, cs_name) == 0)
+                break;
+        if (ptr == cs_ptr) {
+            formatted_warning("type 1","glyph '%s' undefined", cs_name);
+            return;
+        }
+        if (ptr->name == notdef)
+            cs_notdef = ptr;
+    }
+    /*tex
+        Only marked CharString entries and invalid entries can be skipped; valid
+        marked subrs must be parsed to keep the stack in sync.
+    */
+    if (!ptr->valid || (ptr->used && cs_name != NULL))
+        return;
+    ptr->used = true;
+    cr = 4330;
+    cs_len = ptr->cslen;
+    data = ptr->data + 4;
+    for (i = 0; i < t1_lenIV; i++, cs_len--)
+        cs_getchar();
+    while (cs_len > 0) {
+        --cs_len;
+        b = cs_getchar();
+        if (b >= 32) {
+            if (b <= 246)
+                a = b - 139;
+            else if (b <= 250) {
+                --cs_len;
+                a = ((b - 247) << 8) + 108 + cs_getchar();
+            } else if (b <= 254) {
+                --cs_len;
+                a = -((b - 251) << 8) - 108 - cs_getchar();
+            } else {
+                cs_len -= 4;
+                a = (cs_getchar() & 0xff) << 24;
+                a |= (cs_getchar() & 0xff) << 16;
+                a |= (cs_getchar() & 0xff) << 8;
+                a |= (cs_getchar() & 0xff) << 0;
+                if (sizeof(int) > 4 && (a & 0x80000000))
+                    a |= ~0x7FFFFFFF;
+            }
+            cc_push(a);
+        } else {
+            if (b == CS_ESCAPE) {
+                b = cs_getchar() + CS_1BYTE_MAX;
+                cs_len--;
+            }
+            if (b >= CS_MAX) {
+                cs_fail(cs_name, subr, "command value out of range: %i", (int) b);
+                goto cs_error;
+            }
+            cc = cc_tab + b;
+            if (!cc->valid) {
+                cs_fail(cs_name, subr, "command not valid: %i", (int) b);
+                goto cs_error;
+            }
+            if (cc->bottom) {
+                if (stack_ptr - cc_stack < cc->nargs)
+                    cs_fail(cs_name, subr,
+                            "less arguments on stack '%i' than required '%i'",
+                            (int) (stack_ptr - cc_stack), (int) cc->nargs);
+                else if (stack_ptr - cc_stack > cc->nargs)
+                    cs_fail(cs_name, subr,
+                            "more arguments on stack '%i' than required '%i'",
+                            (int) (stack_ptr - cc_stack), (int) cc->nargs);
+            }
+            last_cmd = b;
+            switch (cc - cc_tab) {
+                case CS_CALLSUBR:
+                    a1 = cc_get(-1);
+                    cc_pop(1);
+                    mark_subr(a1);
+                    if (!subr_tab[a1].valid) {
+                        cs_fail(cs_name, subr, "cannot call subr '%i'", (int) a1);
+                        goto cs_error;
+                    }
+                    break;
+                case CS_DIV:
+                    cc_pop(2);
+                    cc_push(0);
+                    break;
+                case CS_CALLOTHERSUBR:
+                    if (cc_get(-1) == 3)
+                        lastargOtherSubr3 = cc_get(-3);
+                    a1 = cc_get(-2) + 2;
+                    cc_pop(a1);
+                    break;
+                case CS_POP:
+                    cc_push(lastargOtherSubr3);
+                    /*tex
+                        The only case when we care about the value being pushed
+                        onto stack is when |POP| follows |CALLOTHERSUBR| changing
+                        hints by |OtherSubrs[3]|.
+                    */
+                    break;
+                case CS_SEAC:
+                    a1 = cc_get(3);
+                    a2 = cc_get(4);
+                    cc_clear();
+                    mark_cs(standard_glyph_names[a1]);
+                    mark_cs(standard_glyph_names[a2]);
+                    break;
+                default:
+                    if (cc->clear)
+                        cc_clear();
+            }
+        }
+    }
+    if (cs_name == NULL && last_cmd != CS_RETURN) {
+        formatted_warning("type 1",
+            "last command in subr '%i' is not a RETURN; I will add it now but please consider fixing the font",
+            (int) subr);
+        append_cs_return(ptr);
+    }
+    return;
+    /*tex An error occured during parsing: */
+  cs_error:
+    cc_clear();
+    ptr->valid = false;
+    ptr->used = false;
+}
+
+/* AVL search tree for glyph code by glyph name. */
+
+static int comp_t1_glyphs(const void *pa, const void *pb, void *p
+    __attribute__ ((unused)))
+{
+    return strcmp(*(const char *const *) pa, *(const char *const *) pb);
+}
+
+static struct avl_table *create_t1_glyph_tree(char **glyph_names)
+{
+    int i;
+    void **aa;
+    static struct avl_table *gl_tree;
+    gl_tree = avl_create(comp_t1_glyphs, NULL, &avl_xallocator);
+    for (i = 0; i < 256; i++) {
+        if (glyph_names[i] != notdef &&
+            (char **) avl_find(gl_tree, &glyph_names[i]) == NULL) {
+            /*tex No |strdup| here, just point to the |glyph_names| array members. */
+            aa = avl_probe(gl_tree, &glyph_names[i]);
+            if (aa == NULL) {
+                /*tex Is this a problem? */
+            }
+        }
+    }
+    return gl_tree;
+}
+
+static void destroy_t1_glyph_tree(struct avl_table *gl_tree)
+{
+    avl_destroy(gl_tree, NULL);
+}
+
+static void t1_subset_ascii_part(PDF pdf)
+{
+    int j, *p;
+    char *glyph, **gg, **glyph_names;
+    struct avl_table *gl_tree;
+    struct avl_traverser t;
+    void **aa;
+    t1_getline();
+    while (!t1_prefix("/Encoding")) {
+        t1_scan_param(pdf);
+        t1_putline(pdf);
+        t1_getline();
+    }
+    glyph_names = t1_builtin_enc();
+    fd_cur->builtin_glyph_names = glyph_names;
+    if (is_subsetted(fd_cur->fm)) {
+        if (fd_cur->tx_tree != NULL) {
+            /*tex Take over collected non-reencoded characters from \TeX. */
+            avl_t_init(&t, fd_cur->tx_tree);
+            for (p = (int *) avl_t_first(&t, fd_cur->tx_tree); p != NULL;
+                 p = (int *) avl_t_next(&t)) {
+                if ((char *) avl_find(fd_cur->gl_tree, glyph_names[*p]) == NULL) {
+                    glyph = xstrdup(glyph_names[*p]);
+                    aa = avl_probe(fd_cur->gl_tree, glyph);
+                    assert(aa != NULL);
+                }
+            }
+        }
+        make_subset_tag(fd_cur);
+        strncpy((char *) pdf->fb->data + t1_fontname_offset, fd_cur->subset_tag,6);
+    }
+    /*tex Now really all glyphs needed from this font are in the |fd_cur->gl_tree|. */
+    if (t1_encoding == ENC_STANDARD)
+        t1_puts(pdf, "/Encoding StandardEncoding def\n");
+    else {
+        t1_puts(pdf,"/Encoding 256 array\n0 1 255 {1 index exch /.notdef put} for\n");
+        gl_tree = create_t1_glyph_tree(glyph_names);
+        avl_t_init(&t, fd_cur->gl_tree);
+        j = 0;
+        for (glyph = (char *) avl_t_first(&t, fd_cur->gl_tree); glyph != NULL;
+             glyph = (char *) avl_t_next(&t)) {
+            if ((gg = (char **) avl_find(gl_tree, &glyph)) != NULL) {
+                t1_printf(pdf, "dup %i /%s put\n", (int) (gg - glyph_names),*gg);
+                j++;
+            }
+        }
+        destroy_t1_glyph_tree(gl_tree);
+        if (j == 0) {
+            /*tex
+                We didn't mark anything for the Encoding array. We add |{dup 0
+                /.notdef put}| for compatibility with Acrobat 5.0.
+            */
+            t1_puts(pdf, "dup 0 /.notdef put\n");
+        }
+        t1_puts(pdf, "readonly def\n");
+    }
+    do {
+        t1_getline();
+        t1_scan_param(pdf);
+        if (!t1_prefix("/UniqueID")) {
+            /*tex Ignore |/UniqueID| for subsetted fonts. */
+            t1_putline(pdf);
+        }
+    }
+    while (t1_in_eexec == 0);
+}
+
+static void cs_init(void)
+{
+    cs_ptr = cs_tab = NULL;
+    cs_dict_start = cs_dict_end = NULL;
+    cs_counter = cs_size = cs_size_pos = 0;
+    cs_token_pair = NULL;
+    subr_tab = NULL;
+    subr_array_start = subr_array_end = NULL;
+    subr_max = subr_size = subr_size_pos = 0;
+}
+
+static void init_cs_entry(cs_entry * cs)
+{
+    cs->data = NULL;
+    cs->name = NULL;
+    cs->len = 0;
+    cs->cslen = 0;
+    cs->used = false;
+    cs->valid = false;
+}
+
+static void t1_read_subrs(PDF pdf)
+{
+    int i, s;
+    cs_entry *ptr;
+    t1_getline();
+    while (!(t1_charstrings() || t1_subrs())) {
+        t1_scan_param(pdf);
+        if (!t1_prefix("/UniqueID")) {
+            /*tex Ignore |/UniqueID| for subsetted fonts. */
+            t1_putline(pdf);
+        }
+        t1_getline();
+    }
+  found:
+    t1_cs = true;
+    t1_scan = false;
+    if (!t1_subrs())
+        return;
+    subr_size_pos = strlen("/Subrs") + 1;
+    /*tex |subr_size_pos| points to the number indicating dict size after |Subrs|. */
+    subr_size = (int) t1_scan_num(t1_line_array + subr_size_pos, 0);
+    if (subr_size == 0) {
+        while (!t1_charstrings())
+            t1_getline();
+        return;
+    }
+    subr_tab = xtalloc((unsigned) subr_size, cs_entry);
+    for (ptr = subr_tab; ptr - subr_tab < subr_size; ptr++)
+        init_cs_entry(ptr);
+    subr_array_start = xstrdup(t1_line_array);
+    t1_getline();
+    while (t1_cslen) {
+        store_subr();
+        t1_getline();
+    }
+    /*tex Mark the first four entries without parsing. */
+    for (i = 0; i < subr_size && i < 4; i++)
+        subr_tab[i].used = true;
+    /*tex
+
+        The end of the |Subrs| array might have more than one line so we need to
+        concatenate them to |subr_array_end|. Unfortunately some fonts don't have
+        the |Subrs| array followed by the |CharStrings| dict immediately (synthetic
+        fonts). If we cannot find |CharStrings| in next |POST_SUBRS_SCAN| lines
+        then we will treat the font as synthetic and ignore everything until next
+        |Subrs| is found.
+
+     */
+#define POST_SUBRS_SCAN 5
+    s = 0;
+    *t1_buf_array = 0;
+    for (i = 0; i < POST_SUBRS_SCAN; i++) {
+        if (t1_charstrings())
+            break;
+        s = (int) (s + t1_line_ptr - t1_line_array);
+        alloc_array(t1_buf, s, T1_BUF_SIZE);
+        strcat(t1_buf_array, t1_line_array);
+        t1_getline();
+    }
+    subr_array_end = xstrdup(t1_buf_array);
+    if (i == POST_SUBRS_SCAN) {
+        /*tex |CharStrings| not found: assume a synthetic font. */
+        for (ptr = subr_tab; ptr - subr_tab < subr_size; ptr++)
+            if (ptr->valid)
+                xfree(ptr->data);
+        xfree(subr_tab);
+        xfree(subr_array_start);
+        xfree(subr_array_end);
+        cs_init();
+        t1_cs = false;
+        t1_synthetic = true;
+        while (!(t1_charstrings() || t1_subrs()))
+            t1_getline();
+        goto found;
+    }
+}
+
+#define t1_subr_flush()  t1_flush_cs(pdf, true)
+#define t1_cs_flush()    t1_flush_cs(pdf, false)
+
+static void t1_flush_cs(PDF pdf, boolean is_subr)
+{
+    char *p;
+    byte *r, *return_cs = NULL;
+    cs_entry *tab, *end_tab, *ptr;
+    char *start_line, *line_end;
+    int count, size_pos;
+    unsigned short cr, cs_len;
+    if (is_subr) {
+        start_line = subr_array_start;
+        line_end = subr_array_end;
+        size_pos = subr_size_pos;
+        tab = subr_tab;
+        count = subr_max + 1;
+        end_tab = subr_tab + count;
+    } else {
+        start_line = cs_dict_start;
+        line_end = cs_dict_end;
+        size_pos = cs_size_pos;
+        tab = cs_tab;
+        end_tab = cs_ptr;
+        count = cs_counter;
+    }
+    t1_line_ptr = t1_line_array;
+    for (p = start_line; p - start_line < size_pos;)
+        *t1_line_ptr++ = *p++;
+    while (isdigit((unsigned char)*p))
+        p++;
+    sprintf(t1_line_ptr, "%u", count);
+    strcat(t1_line_ptr, p);
+    t1_line_ptr = eol(t1_line_array);
+    t1_putline(pdf);
+    /*tex For |-Wall|. */
+    cs_len = 0;
+    /*tex Create |return_cs| to replace unsused |subr|s. */
+    if (is_subr) {
+        cr = 4330;
+        cs_len = 0;
+        /*tex
+            At this point we have |t1_lenIV >= 0;| a negative value would be
+            caught in |t1_scan_param|.
+        */
+        return_cs = xtalloc((unsigned) (t1_lenIV + 1), byte);
+        for (cs_len = 0, r = return_cs; cs_len < t1_lenIV; cs_len++, r++)
+            *r = cencrypt(0x00, &cr);
+        *r = cencrypt(CS_RETURN, &cr);
+        cs_len++;
+    }
+    for (ptr = tab; ptr < end_tab; ptr++) {
+        if (ptr->used) {
+            if (is_subr)
+                sprintf(t1_line_array, "dup %li %u", (long int) (ptr - tab),
+                        ptr->cslen);
+            else
+                sprintf(t1_line_array, "/%s %u", ptr->name, ptr->cslen);
+            p = strend(t1_line_array);
+            memcpy(p, ptr->data, ptr->len);
+            t1_line_ptr = p + ptr->len;
+            t1_putline(pdf);
+        } else {
+            /*tex Replace unsused subr's by |return_cs|. */
+            if (is_subr) {
+                sprintf(t1_line_array, "dup %li %u%s ", (long int) (ptr - tab),
+                        cs_len, cs_token_pair[0]);
+                p = strend(t1_line_array);
+                memcpy(p, return_cs, cs_len);
+                t1_line_ptr = p + cs_len;
+                t1_putline(pdf);
+                sprintf(t1_line_array, " %s", cs_token_pair[1]);
+                t1_line_ptr = eol(t1_line_array);
+                t1_putline(pdf);
+            }
+        }
+        xfree(ptr->data);
+        if (is_subr)
+            ptr->valid = false;
+        if (ptr->name != notdef)
+            xfree(ptr->name);
+    }
+    sprintf(t1_line_array, "%s", line_end);
+    t1_line_ptr = eol(t1_line_array);
+    t1_putline(pdf);
+    if (is_subr) {
+        end_tab = subr_tab + subr_size;
+        for (ptr = tab; ptr < end_tab; ptr++) {
+            if (ptr->valid) {
+                xfree(ptr->data);
+                if (ptr->name != notdef)
+                    xfree(ptr->name);
+            }
+        }
+        xfree(return_cs);
+    }
+    xfree(tab);
+    xfree(start_line);
+    xfree(line_end);
+}
+
+static void t1_mark_glyphs(void)
+{
+    char *glyph;
+    struct avl_traverser t;
+    cs_entry *ptr;
+    if (t1_synthetic || fd_cur->all_glyphs) {
+        /*tex Mark everything. */
+        if (cs_tab != NULL)
+            for (ptr = cs_tab; ptr < cs_ptr; ptr++)
+                if (ptr->valid)
+                    ptr->used = true;
+        if (subr_tab != NULL) {
+            for (ptr = subr_tab; ptr - subr_tab < subr_size; ptr++)
+                if (ptr->valid)
+                    ptr->used = true;
+            subr_max = subr_size - 1;
+        }
+        return;
+    }
+    mark_cs(notdef);
+    avl_t_init(&t, fd_cur->gl_tree);
+    for (glyph = (char *) avl_t_first(&t, fd_cur->gl_tree); glyph != NULL;
+         glyph = (char *) avl_t_next(&t)) {
+        mark_cs(glyph);
+    }
+    if (subr_tab != NULL)
+        for (subr_max = -1, ptr = subr_tab; ptr - subr_tab < subr_size; ptr++)
+            if (ptr->used && ptr - subr_tab > subr_max)
+                subr_max = (int) (ptr - subr_tab);
+}
+
+
+/*tex
+
+    When |t1_subset_charstrings| is called, the |t1_line_array| contains
+    |/CharStrings|. When we hit a case like this:
+
+    \starttyping
+     dup/CharStrings
+     229 dict dup begin
+    \stoptyping
+
+    we read the next line and concatenate to |t1_line_array| before moving on.
+    That is what |t1_check_unusual_charstring| is for.
+
+*/
+
+static void t1_check_unusual_charstring(void)
+{
+    char *p = strstr(t1_line_array, charstringname) + strlen(charstringname);
+    int i;
+    /*tex If no number follows |/CharStrings|, let's read the next line. */
+    if (sscanf(p, "%i", &i) != 1) {
+        strcpy(t1_buf_array, t1_line_array);
+        t1_getline();
+        strcat(t1_buf_array, t1_line_array);
+        strcpy(t1_line_array, t1_buf_array);
+        t1_line_ptr = eol(t1_line_array);
+    }
+}
+
+static void t1_subset_charstrings(PDF pdf)
+{
+    cs_entry *ptr;
+    t1_check_unusual_charstring();
+    cs_size_pos = (int) (strstr(t1_line_array, charstringname) + strlen(charstringname) - t1_line_array + 1);
+    /*tex |cs_size_pos| points to the number indicating dict size after |/CharStrings|. */
+    cs_size = (int) t1_scan_num(t1_line_array + cs_size_pos, 0);
+    cs_ptr = cs_tab = xtalloc((unsigned) cs_size, cs_entry);
+    for (ptr = cs_tab; ptr - cs_tab < cs_size; ptr++)
+        init_cs_entry(ptr);
+    cs_notdef = NULL;
+    cs_dict_start = xstrdup(t1_line_array);
+    t1_getline();
+    while (t1_cslen) {
+        store_cs();
+        t1_getline();
+    }
+    cs_dict_end = xstrdup(t1_line_array);
+    t1_mark_glyphs();
+    if (subr_tab != NULL) {
+        if (cs_token_pair == NULL)
+            formatted_error("type 1","mismatched subroutine begin/end token pairs");
+        t1_subr_flush();
+    }
+    for (cs_counter = 0, ptr = cs_tab; ptr < cs_ptr; ptr++)
+        if (ptr->used)
+            cs_counter++;
+    t1_cs_flush();
+}
+
+static void t1_subset_end(PDF pdf)
+{
+    if (t1_synthetic) {
+        /*tex Copy to |dup /FontName get exch definefont pop|. */
+        while (!strstr(t1_line_array, "definefont")) {
+            t1_getline();
+            t1_putline(pdf);
+        }
+        while (!t1_end_eexec()) {
+            /*tex Ignore the rest. */
+            t1_getline();
+        }
+        /*tex Write \.{mark currentfile closefile}. */
+        t1_putline(pdf);
+    } else {
+        while (!t1_end_eexec()) {
+            /*tex Copy to \.{mark currentfile closefile}. */
+            t1_getline();
+            t1_putline(pdf);
+        }
+    }
+    t1_stop_eexec(pdf);
+    if (fixedcontent) {
+        /*tex Copy 512 zeros (not needed for PDF). */
+        while (!t1_cleartomark()) {
+            t1_getline();
+            t1_putline(pdf);
+        }
+        /*tex Don't check \.{{restore}if} for synthetic fonts. */
+        if (!t1_synthetic) {
+            /*tex Write \.{{restore}if} if found. */
+            t1_check_end(pdf);
+        }
+    }
+    get_length3();
+}
+
+void writet1(PDF pdf, fd_entry * fd)
+{
+    /*tex |fd_cur| is global inside |writet1.c|. */
+    fd_cur = fd;
+    assert(fd_cur->fm != NULL);
+    assert(is_type1(fd->fm));
+    assert(is_included(fd->fm));
+
+    t1_save_offset = 0;
+    if (!is_subsetted(fd_cur->fm)) {
+        /*tex Include entire font. */
+        if (!(fd->ff_found = t1_open_fontfile(filetype_font)))
+            return;
+        t1_include(pdf);
+        t1_close_font_file(filetype_font);
+        xfree(t1_buffer);
+        return;
+    }
+    /*tex Partial downloading. */
+    if (!(fd->ff_found = t1_open_fontfile(filetype_subset)))
+        return;
+    t1_subset_ascii_part(pdf);
+    t1_start_eexec(pdf);
+    cc_init();
+    cs_init();
+    t1_read_subrs(pdf);
+    t1_subset_charstrings(pdf);
+    t1_subset_end(pdf);
+    t1_close_font_file(filetype_subset);
+    xfree(t1_buffer);
+}
+
+void t1_free(void)
+{
+    xfree(t1_line_array);
+    xfree(t1_buf_array);
+}