diff options
author | Akira Kakuto <kakuto@fuk.kindai.ac.jp> | 2014-02-11 06:15:25 +0000 |
---|---|---|
committer | Akira Kakuto <kakuto@fuk.kindai.ac.jp> | 2014-02-11 06:15:25 +0000 |
commit | f4c24b082d377124c0e5de05766d758ec059e964 (patch) | |
tree | 28d9b3d26c084c3ff16942f387ece9c7664ebec6 | |
parent | 0a23d9a053200b27239415d5bb3c1452a6416050 (diff) |
Import from LuaTeX r4794
git-svn-id: svn://tug.org/texlive/trunk@32938 c570f23f-e606-0410-a88d-b1316a301751
-rw-r--r-- | Build/source/texk/web2c/luatexdir/ChangeLog | 8 | ||||
-rw-r--r-- | Build/source/texk/web2c/luatexdir/lua/lnodelib.c | 32 | ||||
-rw-r--r-- | Build/source/texk/web2c/luatexdir/lua/ltexlib.c | 13 | ||||
-rw-r--r-- | Build/source/texk/web2c/luatexdir/lua/luanode.w | 829 | ||||
-rw-r--r-- | Build/source/texk/web2c/luatexdir/luafontloader/fontforge/fontforge/parsettf.c | 8 | ||||
-rw-r--r-- | Build/source/texk/web2c/luatexdir/luafontloader/src/luafflib.c | 20 | ||||
-rw-r--r-- | Build/source/texk/web2c/luatexdir/luapeg/lpeg.c | 4085 | ||||
-rw-r--r-- | Build/source/texk/web2c/luatexdir/luapeg/lpeg.h | 407 | ||||
-rw-r--r-- | Build/source/texk/web2c/luatexdir/luatex_svnversion.h | 2 | ||||
-rw-r--r-- | Build/source/texk/web2c/luatexdir/tex/linebreak.w | 4422 | ||||
-rw-r--r-- | Build/source/texk/web2c/luatexdir/tex/mlist.w | 7206 | ||||
-rw-r--r-- | Build/source/texk/web2c/luatexdir/tex/texnodes.w | 6809 | ||||
-rw-r--r-- | Build/source/texk/web2c/luatexdir/tex/textoken.w | 4825 |
13 files changed, 15016 insertions, 13650 deletions
diff --git a/Build/source/texk/web2c/luatexdir/ChangeLog b/Build/source/texk/web2c/luatexdir/ChangeLog index 96ac3a00e78..35fea59915a 100644 --- a/Build/source/texk/web2c/luatexdir/ChangeLog +++ b/Build/source/texk/web2c/luatexdir/ChangeLog @@ -1,3 +1,11 @@ +2014-02-11 Akira Kakuto <kakuto@fuk.kindai.ac.jp> + + * lua/lnodelib.c, lua/ltexlib.c, lua/luanode.w, + luafontloader/fontforge/fontforge/parsettf.c, + luafontloader/src/luafflib.c, luapeg/lpeg.c, luapeg/lpeg.h + tex/linebreak.w, tex/mlist.w, tex/texnodes.w, tex/textoken.w: + Import from r4794. + 2014-02-10 Akira Kakuto <kakuto@fuk.kindai.ac.jp> * lua/luatex-api.h: MSC version has luaopen_bit32() in dll. diff --git a/Build/source/texk/web2c/luatexdir/lua/lnodelib.c b/Build/source/texk/web2c/luatexdir/lua/lnodelib.c index 78a468a7f1c..0a62151427d 100644 --- a/Build/source/texk/web2c/luatexdir/lua/lnodelib.c +++ b/Build/source/texk/web2c/luatexdir/lua/lnodelib.c @@ -96,7 +96,7 @@ */ static const char _svn_version[] = - "$Id: lnodelib.c 4740 2014-01-09 17:22:45Z luigi $ " + "$Id: lnodelib.c 4775 2014-02-07 12:36:34Z luigi $ " "$URL: https://foundry.supelec.fr/svn/luatex/trunk/source/texk/web2c/luatexdir/lua/lnodelib.c $"; #include "ptexlib.h" @@ -1347,12 +1347,16 @@ static int lua_nodelib_remove(lua_State * L) if (lua_isnil(L, 2)) return 2; /* the arguments, as they are */ current = *(check_isnode(L, 2)); - if (head == current) { - if (alink(head) != null && vlink(current) != null) - alink(vlink(current)) = alink(head); - head = vlink(current); - current = head; + if (alink(current)){ + vlink(alink(current)) = vlink(current); // vlink(prev) = next + } + if (vlink(current)){ + alink( vlink(current)) = alink(current); // alink(next) = prev + } + + head = vlink(current); //head = next + current = vlink(current); //current = next } else { /* head != current */ t = alink(current); if (t == null || vlink(t) != current) { @@ -1396,10 +1400,14 @@ static int lua_nodelib_direct_remove(lua_State * L) return 2 ; } if (head == current) { - if (alink(head) != null && vlink(current) != null) - alink(vlink(current)) = alink(head); - head = vlink(current); - current = head; + if (alink(current)){ + vlink( alink(current) ) = vlink(current); // vlink(prev) = next + } + if (vlink(current)){ + alink( vlink(current) ) = alink(current); // alink(next) = prev + } + head = vlink(current); //head = next + current = vlink(current); //current = next } else { t = alink(current); if (t == null || vlink(t) != current) { @@ -2003,6 +2011,7 @@ static int lua_nodelib_mlist_to_hlist(lua_State * L) luaL_checkany(L, 3); m = lua_toboolean(L, 3); mlist_to_hlist_args(n, w, m); + alink(vlink(temp_head)) = null; /*hh-ls */ lua_nodelib_push_fast(L, vlink(temp_head)); return 1; } @@ -4194,6 +4203,7 @@ static int font_tex_ligaturing(lua_State * L) couple_nodes(tmp_head, *h); tlink(tmp_head) = t; t = handle_ligaturing(tmp_head, t); + alink(vlink(tmp_head)) = null ; /* hh-ls */ lua_pushnumber(L, vlink(tmp_head)); /* can be: lua_nodelib_push_fast(L, head); */ flush_node(tmp_head); @@ -4227,6 +4237,7 @@ static int font_tex_kerning(lua_State * L) couple_nodes(tmp_head, *h); tlink(tmp_head) = t; t = handle_kerning(tmp_head, t); + alink(vlink(tmp_head)) = null ; /* hh-ls */ lua_pushnumber(L, vlink(tmp_head)); /* can be: lua_nodelib_push_fast(L, head); */ flush_node(tmp_head); @@ -4238,6 +4249,7 @@ static int font_tex_kerning(lua_State * L) return 3; } + /* node.protect_glyphs (returns also boolean because that signals callback) */ static int lua_nodelib_protect_glyphs(lua_State * L) diff --git a/Build/source/texk/web2c/luatexdir/lua/ltexlib.c b/Build/source/texk/web2c/luatexdir/lua/ltexlib.c index d448bd1aab3..cbc01ed4763 100644 --- a/Build/source/texk/web2c/luatexdir/lua/ltexlib.c +++ b/Build/source/texk/web2c/luatexdir/lua/ltexlib.c @@ -17,13 +17,17 @@ 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: Because the lists start with a temp node, we have to set the prev link +to nil because otherwise at the lua end we expose temp which can create havoc. In the +setter no prev link is created so we can presume that it's not used later on. */ + #include "ptexlib.h" #include "lua/luatex-api.h" static const char _svn_version[] = - "$Id: ltexlib.c 4569 2013-01-30 10:08:33Z taco $ $URL: https://foundry.supelec.fr/svn/luatex/branches/ex-glyph/source/texk/web2c/luatexdir/lua/ltexlib.c $"; + "$Id: ltexlib.c 4775 2014-02-07 12:36:34Z luigi $ $URL: https://foundry.supelec.fr/svn/luatex/trunk/source/texk/web2c/luatexdir/lua/ltexlib.c $"; #define attribute(A) eqtb[attribute_base+(A)].hh.rh #define dimen(A) eqtb[scaled_base+(A)].hh.rh @@ -1603,18 +1607,23 @@ static int getlist(lua_State * L) lua_pushnumber(L, vlink(page_ins_head)); lua_nodelib_push(L); } else if (strcmp(str, "contrib_head") == 0) { + alink(vlink(contrib_head)) = null ; lua_pushnumber(L, vlink(contrib_head)); lua_nodelib_push(L); } else if (strcmp(str, "page_head") == 0) { + alink(vlink(page_head)) = null ;/*hh-ls */ lua_pushnumber(L, vlink(page_head)); lua_nodelib_push(L); } else if (strcmp(str, "temp_head") == 0) { + alink(vlink(temp_head)) = null ;/*hh-ls */ lua_pushnumber(L, vlink(temp_head)); lua_nodelib_push(L); } else if (strcmp(str, "hold_head") == 0) { + alink(vlink(hold_head)) = null ;/*hh-ls */ lua_pushnumber(L, vlink(hold_head)); lua_nodelib_push(L); } else if (strcmp(str, "adjust_head") == 0) { + alink(vlink(adjust_head)) = null ;/*hh-ls */ lua_pushnumber(L, vlink(adjust_head)); lua_nodelib_push(L); } else if (strcmp(str, "best_page_break") == 0) { @@ -1625,9 +1634,11 @@ static int getlist(lua_State * L) } else if (strcmp(str, "best_size") == 0) { lua_pushnumber(L, best_size); } else if (strcmp(str, "pre_adjust_head") == 0) { + alink(vlink(pre_adjust_head)) = null ;/*hh-ls */ lua_pushnumber(L, vlink(pre_adjust_head)); lua_nodelib_push(L); } else if (strcmp(str, "align_head") == 0) { + alink(vlink(align_head)) = null ;/*hh-ls */ lua_pushnumber(L, vlink(align_head)); lua_nodelib_push(L); } else { diff --git a/Build/source/texk/web2c/luatexdir/lua/luanode.w b/Build/source/texk/web2c/luatexdir/lua/luanode.w index b7ed9fcd396..65f4c8a6310 100644 --- a/Build/source/texk/web2c/luatexdir/lua/luanode.w +++ b/Build/source/texk/web2c/luatexdir/lua/luanode.w @@ -1,411 +1,418 @@ -% 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/>. - -@ @c -static const char _svn_version[] = - "$Id: luanode.w 4442 2012-05-25 22:40:34Z hhenkel $" - "$URL: https://foundry.supelec.fr/svn/luatex/branches/ex-glyph/source/texk/web2c/luatexdir/lua/luanode.w $"; - -#include "ptexlib.h" -#include "lua/luatex-api.h" - -@ @c -static const char *group_code_names[] = { - "", - "simple", - "hbox", - "adjusted_hbox", - "vbox", - "vtop", - "align", - "no_align", - "output", - "math", - "disc", - "insert", - "vcenter", - "math_choice", - "semi_simple", - "math_shift", - "math_left", - "local_box", - "split_off", - "split_keep", - "preamble", - "align_set", - "fin_row" -}; - -const char *pack_type_name[] = { "exactly", "additional" }; - - -@ @c -void lua_node_filter_s(int filterid, const char *extrainfo) -{ - lua_State *L = Luas; - int callback_id = callback_defined(filterid); - int s_top = lua_gettop(L); - if (callback_id <= 0) { - lua_settop(L, s_top); - return; - } - if (!get_callback(L, callback_id)) { - lua_settop(L, s_top); - return; - } - lua_pushstring(L, extrainfo); /* arg 1 */ - if (lua_pcall(L, 1, 0, 0) != 0) { - fprintf(stdout, "error: %s\n", lua_tostring(L, -1)); - lua_settop(L, s_top); - error(); - return; - } - lua_settop(L, s_top); - return; -} - -@ @c -void -lua_node_filter(int filterid, int xextrainfo, halfword head_node, - halfword * tail_node) -{ - halfword ret; - int a; - lua_State *L = Luas; - int s_top = lua_gettop(L); - const char *extrainfo = group_code_names[xextrainfo]; - int callback_id = callback_defined(filterid); - if (head_node == null || vlink(head_node) == null || callback_id <= 0) { - lua_settop(L, s_top); - return; - } - if (!get_callback(L, callback_id)) { - lua_settop(L, s_top); - return; - } - nodelist_to_lua(L, vlink(head_node)); /* arg 1 */ - lua_pushstring(L, extrainfo); /* arg 2 */ - if (lua_pcall(L, 2, 1, 0) != 0) { /* no arg, 1 result */ - fprintf(stdout, "error: %s\n", lua_tostring(L, -1)); - lua_settop(L, s_top); - error(); - return; - } - if (lua_isboolean(L, -1)) { - if (lua_toboolean(L, -1) != 1) { - flush_node_list(vlink(head_node)); - vlink(head_node) = null; - } - } else { - a = nodelist_from_lua(L); - try_couple_nodes(head_node,a); - } - lua_pop(L, 2); /* result and callback container table */ - if (fix_node_lists) - fix_node_list(head_node); - ret = vlink(head_node); - if (ret != null) { - while (vlink(ret) != null) - ret = vlink(ret); - *tail_node = ret; - } else { - *tail_node = head_node; - } - lua_settop(L, s_top); - return; -} - - -@ @c -int -lua_linebreak_callback(int is_broken, halfword head_node, halfword * new_head) -{ - int a; - register halfword *p; - int ret = 0; /* failure */ - lua_State *L = Luas; - int s_top = lua_gettop(L); - int callback_id = callback_defined(linebreak_filter_callback); - if (head_node == null || vlink(head_node) == null || callback_id <= 0) { - lua_settop(L, s_top); - return ret; - } - if (!get_callback(L, callback_id)) { - lua_settop(L, s_top); - return ret; - } - nodelist_to_lua(L, vlink(head_node)); /* arg 1 */ - lua_pushboolean(L, is_broken); /* arg 2 */ - if (lua_pcall(L, 2, 1, 0) != 0) { /* no arg, 1 result */ - fprintf(stdout, "error: %s\n", lua_tostring(L, -1)); - lua_settop(L, s_top); - error(); - return ret; - } - - p = lua_touserdata(L, -1); - if (p != NULL) { - a = nodelist_from_lua(L); - try_couple_nodes(*new_head,a); - ret = 1; - } - lua_settop(L, s_top); - return ret; -} - - - -@ @c -halfword -lua_hpack_filter(halfword head_node, scaled size, int pack_type, int extrainfo, - int pack_direction) -{ - halfword ret; - lua_State *L = Luas; - int s_top = lua_gettop(L); - int callback_id = callback_defined(hpack_filter_callback); - if (head_node == null || callback_id <= 0) { - lua_settop(L, s_top); - return head_node; - } - if (!get_callback(L, callback_id)) { - lua_settop(L, s_top); - return head_node; - } - nodelist_to_lua(L, head_node); - lua_pushstring(L, group_code_names[extrainfo]); - lua_pushnumber(L, size); - lua_pushstring(L, pack_type_name[pack_type]); - if (pack_direction >= 0) - lua_pushstring(L, string_dir(pack_direction)); - else - lua_pushnil(L); - if (lua_pcall(L, 5, 1, 0) != 0) { /* no arg, 1 result */ - fprintf(stdout, "error: %s\n", lua_tostring(L, -1)); - lua_settop(L, s_top); - error(); - return head_node; - } - ret = head_node; - if (lua_isboolean(L, -1)) { - if (lua_toboolean(L, -1) != 1) { - flush_node_list(head_node); - ret = null; - } - } else { - ret = nodelist_from_lua(L); - } - lua_settop(L, s_top); -#if 0 - lua_gc(L,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 ret; - int callback_id; - lua_State *L = Luas; - int s_top = lua_gettop(L); - if (head_node == null) { - lua_settop(L, s_top); - return head_node; - } - if (strcmp("output", group_code_names[extrainfo]) == 0) { - callback_id = callback_defined(pre_output_filter_callback); - } else { - callback_id = callback_defined(vpack_filter_callback); - } - if (callback_id <= 0) { - lua_settop(L, s_top); - return head_node; - } - if (!get_callback(L, callback_id)) { - lua_settop(L, s_top); - return head_node; - } - nodelist_to_lua(L, head_node); - lua_pushstring(L, group_code_names[extrainfo]); - lua_pushnumber(L, size); - lua_pushstring(L, pack_type_name[pack_type]); - lua_pushnumber(L, maxd); - if (pack_direction >= 0) - lua_pushstring(L, string_dir(pack_direction)); - else - lua_pushnil(L); - if (lua_pcall(L, 6, 1, 0) != 0) { /* no arg, 1 result */ - fprintf(stdout, "error: %s\n", lua_tostring(L, -1)); - lua_settop(L, s_top); - error(); - return head_node; - } - ret = head_node; - if (lua_isboolean(L, -1)) { - if (lua_toboolean(L, -1) != 1) { - flush_node_list(head_node); - ret = null; - } - } else { - ret = nodelist_from_lua(L); - } - lua_settop(L, s_top); -#if 0 - lua_gc(L,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. - -@c -int visible_last_node_type(int n) -{ - int i = type(n); - if (i == whatsit_node && subtype(n) == local_par_node) - return -1; - if (i == glyph_node) { - if (is_ligature(n)) - return 7; /* old ligature value */ - else - return 0; /* old character value */ - } - if (i <= unset_node) { - return i + 1; - } else if (i <= delim_node) { - return 15; /* so-called math nodes */ - } else { - return -1; - } -} - -@ @c -void lua_pdf_literal(PDF pdf, int i) -{ - 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| */ - lua_pop(Luas, 1); -} - -@ @c -void copy_pdf_literal(pointer r, pointer p) -{ - pdf_literal_type(r) = pdf_literal_type(p); - pdf_literal_mode(r) = pdf_literal_mode(p); - if (pdf_literal_type(p) == normal) { - pdf_literal_data(r) = pdf_literal_data(p); - add_token_ref(pdf_literal_data(p)); - } else { - lua_rawgeti(Luas, LUA_REGISTRYINDEX, pdf_literal_data(p)); - pdf_literal_data(r) = luaL_ref(Luas, LUA_REGISTRYINDEX); - } -} - -void copy_late_lua(pointer r, pointer p) -{ - late_lua_type(r) = late_lua_type(p); - if (late_lua_name(p) > 0) - add_token_ref(late_lua_name(p)); - if (late_lua_type(p) == normal) { - late_lua_data(r) = late_lua_data(p); - add_token_ref(late_lua_data(p)); - } else { - lua_rawgeti(Luas, LUA_REGISTRYINDEX, late_lua_data(p)); - late_lua_data(r) = luaL_ref(Luas, LUA_REGISTRYINDEX); - } -} - - -@ @c -void free_pdf_literal(pointer p) -{ - if (pdf_literal_type(p) == normal) { - delete_token_ref(pdf_literal_data(p)); - } else { - luaL_unref(Luas, LUA_REGISTRYINDEX, pdf_literal_data(p)); - } -} - -void free_late_lua(pointer p) -{ - if (late_lua_name(p) > 0) - delete_token_ref(late_lua_name(p)); - if (late_lua_type(p) == normal) { - delete_token_ref(late_lua_data(p)); - } else { - luaL_unref(Luas, LUA_REGISTRYINDEX, late_lua_data(p)); - } -} - -@ @c -void show_pdf_literal(pointer p) -{ - tprint_esc("pdfliteral"); - switch (pdf_literal_mode(p)) { - case set_origin: - break; - case direct_page: - tprint(" page"); - break; - case direct_always: - tprint(" direct"); - break; - default: - confusion("literal2"); - break; - } - if (pdf_literal_type(p) == normal) { - print_mark(pdf_literal_data(p)); - } else { - lua_rawgeti(Luas, LUA_REGISTRYINDEX, pdf_literal_data(p)); - tprint("\""); - tprint(lua_tostring(Luas, -1)); - tprint("\""); - lua_pop(Luas, 1); - } -} - -void show_late_lua(pointer p) -{ - tprint_esc("latelua"); - print_int(late_lua_reg(p)); - if (late_lua_type(p) == normal) { - print_mark(late_lua_data(p)); - } else { - lua_rawgeti(Luas, LUA_REGISTRYINDEX, late_lua_data(p)); - tprint("\""); - tprint(lua_tostring(Luas, -1)); - tprint("\""); - lua_pop(Luas, 1); - } -} +% 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 removedor inserted, temp nodes don't interfere */
+
+@ @c
+static const char _svn_version[] =
+ "$Id: luanode.w 4775 2014-02-07 12:36:34Z luigi $"
+ "$URL: https://foundry.supelec.fr/svn/luatex/trunk/source/texk/web2c/luatexdir/lua/luanode.w $";
+
+#include "ptexlib.h"
+#include "lua/luatex-api.h"
+
+@ @c
+static const char *group_code_names[] = {
+ "",
+ "simple",
+ "hbox",
+ "adjusted_hbox",
+ "vbox",
+ "vtop",
+ "align",
+ "no_align",
+ "output",
+ "math",
+ "disc",
+ "insert",
+ "vcenter",
+ "math_choice",
+ "semi_simple",
+ "math_shift",
+ "math_left",
+ "local_box",
+ "split_off",
+ "split_keep",
+ "preamble",
+ "align_set",
+ "fin_row"
+};
+
+const char *pack_type_name[] = { "exactly", "additional" };
+
+
+@ @c
+void lua_node_filter_s(int filterid, const char *extrainfo)
+{
+ lua_State *L = Luas;
+ int callback_id = callback_defined(filterid);
+ int s_top = lua_gettop(L);
+ if (callback_id <= 0) {
+ lua_settop(L, s_top);
+ return;
+ }
+ if (!get_callback(L, callback_id)) {
+ lua_settop(L, s_top);
+ return;
+ }
+ lua_pushstring(L, extrainfo); /* arg 1 */
+ if (lua_pcall(L, 1, 0, 0) != 0) {
+ fprintf(stdout, "error: %s\n", lua_tostring(L, -1));
+ lua_settop(L, s_top);
+ error();
+ return;
+ }
+ lua_settop(L, s_top);
+ return;
+}
+
+@ @c
+void
+lua_node_filter(int filterid, int xextrainfo, halfword head_node,
+ halfword * tail_node)
+{
+ halfword ret;
+ int a;
+ lua_State *L = Luas;
+ int s_top = lua_gettop(L);
+ const char *extrainfo = group_code_names[xextrainfo];
+ int callback_id = callback_defined(filterid);
+ if (head_node == null || vlink(head_node) == null || callback_id <= 0) {
+ lua_settop(L, s_top);
+ return;
+ }
+ if (!get_callback(L, callback_id)) {
+ lua_settop(L, s_top);
+ return;
+ }
+ alink(vlink(head_node)) = null ; /* hh-ls */
+ nodelist_to_lua(L, vlink(head_node)); /* arg 1 */
+ lua_pushstring(L, extrainfo); /* arg 2 */
+ if (lua_pcall(L, 2, 1, 0) != 0) { /* no arg, 1 result */
+ fprintf(stdout, "error: %s\n", lua_tostring(L, -1));
+ lua_settop(L, s_top);
+ error();
+ return;
+ }
+ if (lua_isboolean(L, -1)) {
+ if (lua_toboolean(L, -1) != 1) {
+ flush_node_list(vlink(head_node));
+ vlink(head_node) = null;
+ }
+ } else {
+ a = nodelist_from_lua(L);
+ try_couple_nodes(head_node,a);
+ }
+ lua_pop(L, 2); /* result and callback container table */
+ if (fix_node_lists)
+ fix_node_list(head_node);
+ ret = vlink(head_node);
+ if (ret != null) {
+ while (vlink(ret) != null)
+ ret = vlink(ret);
+ *tail_node = ret;
+ } else {
+ *tail_node = head_node;
+ }
+ lua_settop(L, s_top);
+ return;
+}
+
+
+@ @c
+int
+lua_linebreak_callback(int is_broken, halfword head_node, halfword * new_head)
+{
+ int a;
+ register halfword *p;
+ int ret = 0; /* failure */
+ lua_State *L = Luas;
+ int s_top = lua_gettop(L);
+ int callback_id = callback_defined(linebreak_filter_callback);
+ if (head_node == null || vlink(head_node) == null || callback_id <= 0) {
+ lua_settop(L, s_top);
+ return ret;
+ }
+ if (!get_callback(L, callback_id)) {
+ lua_settop(L, s_top);
+ return ret;
+ }
+ alink(vlink(head_node)) = null ; /* hh-ls */
+ nodelist_to_lua(L, vlink(head_node)); /* arg 1 */
+ lua_pushboolean(L, is_broken); /* arg 2 */
+ if (lua_pcall(L, 2, 1, 0) != 0) { /* no arg, 1 result */
+ fprintf(stdout, "error: %s\n", lua_tostring(L, -1));
+ lua_settop(L, s_top);
+ error();
+ return ret;
+ }
+
+ p = lua_touserdata(L, -1);
+ if (p != NULL) {
+ a = nodelist_from_lua(L);
+ try_couple_nodes(*new_head,a);
+ ret = 1;
+ }
+ lua_settop(L, s_top);
+ return ret;
+}
+
+
+
+@ @c
+halfword
+lua_hpack_filter(halfword head_node, scaled size, int pack_type, int extrainfo,
+ int pack_direction)
+{
+ halfword ret;
+ lua_State *L = Luas;
+ int s_top = lua_gettop(L);
+ int callback_id = callback_defined(hpack_filter_callback);
+ if (head_node == null || callback_id <= 0) {
+ lua_settop(L, s_top);
+ return head_node;
+ }
+ if (!get_callback(L, callback_id)) {
+ lua_settop(L, s_top);
+ return head_node;
+ }
+ alink(head_node) = null ; /* hh-ls */
+ nodelist_to_lua(L, head_node);
+ lua_pushstring(L, group_code_names[extrainfo]);
+ lua_pushnumber(L, size);
+ lua_pushstring(L, pack_type_name[pack_type]);
+ if (pack_direction >= 0)
+ lua_pushstring(L, string_dir(pack_direction));
+ else
+ lua_pushnil(L);
+ if (lua_pcall(L, 5, 1, 0) != 0) { /* no arg, 1 result */
+ fprintf(stdout, "error: %s\n", lua_tostring(L, -1));
+ lua_settop(L, s_top);
+ error();
+ return head_node;
+ }
+ ret = head_node;
+ if (lua_isboolean(L, -1)) {
+ if (lua_toboolean(L, -1) != 1) {
+ flush_node_list(head_node);
+ ret = null;
+ }
+ } else {
+ ret = nodelist_from_lua(L);
+ }
+ lua_settop(L, s_top);
+#if 0
+ lua_gc(L,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 ret;
+ int callback_id;
+ lua_State *L = Luas;
+ int s_top = lua_gettop(L);
+ if (head_node == null) {
+ lua_settop(L, s_top);
+ return head_node;
+ }
+ if (strcmp("output", group_code_names[extrainfo]) == 0) {
+ callback_id = callback_defined(pre_output_filter_callback);
+ } else {
+ callback_id = callback_defined(vpack_filter_callback);
+ }
+ if (callback_id <= 0) {
+ lua_settop(L, s_top);
+ return head_node;
+ }
+ if (!get_callback(L, callback_id)) {
+ lua_settop(L, s_top);
+ return head_node;
+ }
+ alink(head_node) = null ; /* hh-ls */
+ nodelist_to_lua(L, head_node);
+ lua_pushstring(L, group_code_names[extrainfo]);
+ lua_pushnumber(L, size);
+ lua_pushstring(L, pack_type_name[pack_type]);
+ lua_pushnumber(L, maxd);
+ if (pack_direction >= 0)
+ lua_pushstring(L, string_dir(pack_direction));
+ else
+ lua_pushnil(L);
+ if (lua_pcall(L, 6, 1, 0) != 0) { /* no arg, 1 result */
+ fprintf(stdout, "error: %s\n", lua_tostring(L, -1));
+ lua_settop(L, s_top);
+ error();
+ return head_node;
+ }
+ ret = head_node;
+ if (lua_isboolean(L, -1)) {
+ if (lua_toboolean(L, -1) != 1) {
+ flush_node_list(head_node);
+ ret = null;
+ }
+ } else {
+ ret = nodelist_from_lua(L);
+ }
+ lua_settop(L, s_top);
+#if 0
+ lua_gc(L,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.
+
+@c
+int visible_last_node_type(int n)
+{
+ int i = type(n);
+ if (i == whatsit_node && subtype(n) == local_par_node)
+ return -1;
+ if (i == glyph_node) {
+ if (is_ligature(n))
+ return 7; /* old ligature value */
+ else
+ return 0; /* old character value */
+ }
+ if (i <= unset_node) {
+ return i + 1;
+ } else if (i <= delim_node) {
+ return 15; /* so-called math nodes */
+ } else {
+ return -1;
+ }
+}
+
+@ @c
+void lua_pdf_literal(PDF pdf, int i)
+{
+ 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| */
+ lua_pop(Luas, 1);
+}
+
+@ @c
+void copy_pdf_literal(pointer r, pointer p)
+{
+ pdf_literal_type(r) = pdf_literal_type(p);
+ pdf_literal_mode(r) = pdf_literal_mode(p);
+ if (pdf_literal_type(p) == normal) {
+ pdf_literal_data(r) = pdf_literal_data(p);
+ add_token_ref(pdf_literal_data(p));
+ } else {
+ lua_rawgeti(Luas, LUA_REGISTRYINDEX, pdf_literal_data(p));
+ pdf_literal_data(r) = luaL_ref(Luas, LUA_REGISTRYINDEX);
+ }
+}
+
+void copy_late_lua(pointer r, pointer p)
+{
+ late_lua_type(r) = late_lua_type(p);
+ if (late_lua_name(p) > 0)
+ add_token_ref(late_lua_name(p));
+ if (late_lua_type(p) == normal) {
+ late_lua_data(r) = late_lua_data(p);
+ add_token_ref(late_lua_data(p));
+ } else {
+ lua_rawgeti(Luas, LUA_REGISTRYINDEX, late_lua_data(p));
+ late_lua_data(r) = luaL_ref(Luas, LUA_REGISTRYINDEX);
+ }
+}
+
+
+@ @c
+void free_pdf_literal(pointer p)
+{
+ if (pdf_literal_type(p) == normal) {
+ delete_token_ref(pdf_literal_data(p));
+ } else {
+ luaL_unref(Luas, LUA_REGISTRYINDEX, pdf_literal_data(p));
+ }
+}
+
+void free_late_lua(pointer p)
+{
+ if (late_lua_name(p) > 0)
+ delete_token_ref(late_lua_name(p));
+ if (late_lua_type(p) == normal) {
+ delete_token_ref(late_lua_data(p));
+ } else {
+ luaL_unref(Luas, LUA_REGISTRYINDEX, late_lua_data(p));
+ }
+}
+
+@ @c
+void show_pdf_literal(pointer p)
+{
+ tprint_esc("pdfliteral");
+ switch (pdf_literal_mode(p)) {
+ case set_origin:
+ break;
+ case direct_page:
+ tprint(" page");
+ break;
+ case direct_always:
+ tprint(" direct");
+ break;
+ default:
+ confusion("literal2");
+ break;
+ }
+ if (pdf_literal_type(p) == normal) {
+ print_mark(pdf_literal_data(p));
+ } else {
+ lua_rawgeti(Luas, LUA_REGISTRYINDEX, pdf_literal_data(p));
+ tprint("\"");
+ tprint(lua_tostring(Luas, -1));
+ tprint("\"");
+ lua_pop(Luas, 1);
+ }
+}
+
+void show_late_lua(pointer p)
+{
+ tprint_esc("latelua");
+ print_int(late_lua_reg(p));
+ if (late_lua_type(p) == normal) {
+ print_mark(late_lua_data(p));
+ } else {
+ lua_rawgeti(Luas, LUA_REGISTRYINDEX, late_lua_data(p));
+ tprint("\"");
+ tprint(lua_tostring(Luas, -1));
+ tprint("\"");
+ lua_pop(Luas, 1);
+ }
+}
diff --git a/Build/source/texk/web2c/luatexdir/luafontloader/fontforge/fontforge/parsettf.c b/Build/source/texk/web2c/luatexdir/luafontloader/fontforge/fontforge/parsettf.c index c682146b352..339f99ffc29 100644 --- a/Build/source/texk/web2c/luatexdir/luafontloader/fontforge/fontforge/parsettf.c +++ b/Build/source/texk/web2c/luatexdir/luafontloader/fontforge/fontforge/parsettf.c @@ -5899,6 +5899,11 @@ static SplineFont *SFFillFromTTF(struct ttfinfo *info) { ++k; } while ( k<sf->subfontcnt ); } + /* more info */ + sf->units_per_em = info->emsize ; + sf->pfminfo = info->pfminfo ; + sf->names = info->names ; + SFRelativeWinAsDs(sf); free(info->savetab); sf->loadvalidation_state = @@ -6041,6 +6046,9 @@ static SplineFont *SFFillFromTTFInfo(struct ttfinfo *info) { free( info->weight ); sf->version = info->version; sf->italicangle = info->italicAngle; + sf->names = info->names; + sf->units_per_em = info->emsize ; + sf->pfminfo = info->pfminfo ; return( sf ); } diff --git a/Build/source/texk/web2c/luatexdir/luafontloader/src/luafflib.c b/Build/source/texk/web2c/luatexdir/luafontloader/src/luafflib.c index 7edd93fd6b3..7163fb2f026 100644 --- a/Build/source/texk/web2c/luatexdir/luafontloader/src/luafflib.c +++ b/Build/source/texk/web2c/luatexdir/luafontloader/src/luafflib.c @@ -33,7 +33,7 @@ #include <locale.h> static const char _svn_version[] = - "$Id: luafflib.c 4744 2014-01-11 11:42:36Z luigi $ " + "$Id: luafflib.c 4768 2014-01-28 15:38:54Z luigi $ " "$URL: https://foundry.supelec.fr/svn/luatex/trunk/source/texk/web2c/luatexdir/luafontloader/src/luafflib.c $"; extern char **gww_errors; @@ -2306,19 +2306,21 @@ void do_ff_info(lua_State * L, SplineFont * sf) dump_stringfield(L, "weight", sf->weight); dump_intfield(L, "units_per_em", sf->units_per_em); - dump_intfield(L, "design_range_bottom", sf->design_range_bottom); - dump_intfield(L, "design_range_top", sf->design_range_top); - dump_intfield(L, "design_size", sf->design_size); + /* These are not assigned in info... */ + /*dump_intfield(L, "design_range_bottom", sf->design_range_bottom);*/ + /*dump_intfield(L, "design_range_top", sf->design_range_top);*/ + /*dump_intfield(L, "design_size", sf->design_size);*/ lua_createtable(L, 0, 40); handle_pfminfo(L, sf->pfminfo); lua_setfield(L, -2, "pfminfo"); - if (sf->names != NULL) { - lua_newtable(L); - handle_ttflangname(L, sf->names); - lua_setfield(L, -2, "names"); - } + /* Do we need this ? */ + if (sf->names != NULL) { + lua_newtable(L); + handle_ttflangname(L, sf->names); + lua_setfield(L, -2, "names"); + } } typedef enum { diff --git a/Build/source/texk/web2c/luatexdir/luapeg/lpeg.c b/Build/source/texk/web2c/luatexdir/luapeg/lpeg.c index d46d4638abd..3e64950fb98 100644 --- a/Build/source/texk/web2c/luatexdir/luapeg/lpeg.c +++ b/Build/source/texk/web2c/luatexdir/luapeg/lpeg.c @@ -1,249 +1,23 @@ -/* -** $Id: lpeg.c,v 1.114 2011/02/16 15:02:20 roberto Exp $ -** LPeg - PEG pattern matching for Lua -** Copyright 2007, Lua.org & PUC-Rio (see 'lpeg.html' for license) -** written by Roberto Ierusalimschy -*/ - - -#include <assert.h> -#include <ctype.h> -#include <limits.h> -#include <stdio.h> -#include <string.h> - -#include "lua.h" -#include "lauxlib.h" #include "lpeg.h" -#define VERSION "0.10" -#define PATTERN_T "lpeg-pattern" -#define MAXSTACKIDX "lpeg-maxstack" - - /* -** compatibility with Lua 5.2 +** $Id: lpprint.c,v 1.7 2013/04/12 16:29:49 roberto Exp $ +** Copyright 2007, Lua.org & PUC-Rio (see 'lpeg.html' for license) */ -#if (LUA_VERSION_NUM == 502) - -#undef lua_equal -#define lua_equal(L,idx1,idx2) lua_compare(L,(idx1),(idx2),LUA_OPEQ) - -#undef lua_getfenv -#define lua_getfenv lua_getuservalue -#undef lua_setfenv -#define lua_setfenv lua_setuservalue - -#undef lua_objlen -#define lua_objlen lua_rawlen - -#undef luaL_register -#define luaL_register(L,n,f) \ - { if ((n) == NULL) luaL_setfuncs(L,f,0); else luaL_newlib(L,f); } - -#endif - - - -/* initial size for call/backtrack stack */ -#define INITBACK 100 - -/* default maximum size for call/backtrack stack */ -#define MAXBACK INITBACK - -/* size for call/backtrack stack for verifier */ -#define MAXBACKVER 200 - -/* initial size for capture's list */ -#define INITCAPSIZE 32 - - -/* index, on Lua stack, for subject */ -#define SUBJIDX 2 - -/* number of fixed arguments to 'match' (before capture arguments) */ -#define FIXEDARGS 3 - -/* index, on Lua stack, for substitution value cache */ -#define subscache(cs) ((cs)->ptop + 1) - -/* index, on Lua stack, for capture list */ -#define caplistidx(ptop) ((ptop) + 2) - -/* index, on Lua stack, for pattern's fenv */ -#define penvidx(ptop) ((ptop) + 3) - -/* index, on Lua stack, for backtracking stack */ -#define stackidx(ptop) ((ptop) + 4) - - - -typedef unsigned char byte; - - -#define CHARSETSIZE ((UCHAR_MAX/CHAR_BIT) + 1) - - -typedef byte Charset[CHARSETSIZE]; - - -/* Virtual Machine's instructions */ -typedef enum Opcode { - IAny, IChar, ISet, ISpan, - IBack, - IRet, IEnd, - IChoice, IJmp, ICall, IOpenCall, - ICommit, IPartialCommit, IBackCommit, IFailTwice, IFail, IGiveup, - IFunc, - IFullCapture, IEmptyCapture, IEmptyCaptureIdx, - IOpenCapture, ICloseCapture, ICloseRunTime -} Opcode; +/* #include <ctype.h> */ +/* #include <limits.h> */ +/* #include <stdio.h> */ -#define ISJMP 0x1 -#define ISCHECK 0x2 -#define ISFIXCHECK 0x4 -#define ISNOFAIL 0x8 -#define ISCAPTURE 0x10 -#define ISMOVABLE 0x20 -#define ISFENVOFF 0x40 - -static const int opproperties[] = { - /* IAny */ ISCHECK | ISFIXCHECK | ISJMP, - /* IChar */ ISCHECK | ISFIXCHECK | ISJMP, - /* ISet */ ISCHECK | ISFIXCHECK | ISJMP, - /* ISpan */ ISNOFAIL, - /* IBack */ 0, - /* IRet */ 0, - /* IEnd */ 0, - /* IChoice */ ISJMP, - /* IJmp */ ISJMP | ISNOFAIL, - /* ICall */ ISJMP, - /* IOpenCall */ ISFENVOFF, - /* ICommit */ ISJMP, - /* IPartialCommit */ ISJMP, - /* IBackCommit */ ISJMP, - /* IFailTwice */ 0, - /* IFail */ 0, - /* IGiveup */ 0, - /* IFunc */ ISCHECK | ISJMP, - /* IFullCapture */ ISCAPTURE | ISNOFAIL | ISFENVOFF, - /* IEmptyCapture */ ISCAPTURE | ISNOFAIL | ISMOVABLE, - /* IEmptyCaptureIdx */ISCAPTURE | ISNOFAIL | ISMOVABLE | ISFENVOFF, - /* IOpenCapture */ ISCAPTURE | ISNOFAIL | ISMOVABLE | ISFENVOFF, - /* ICloseCapture */ ISCAPTURE | ISNOFAIL | ISMOVABLE | ISFENVOFF, - /* ICloseRunTime */ ISCAPTURE | ISFENVOFF -}; - - -typedef union Instruction { - struct Inst { - byte code; - byte aux; - short offset; - } i; - PattFunc f; - int iv; - byte buff[1]; -} Instruction; - -static const Instruction giveup = {{IGiveup, 0, 0}}; - -#define getkind(op) ((op)->i.aux & 0xF) -#define getoff(op) (((op)->i.aux >> 4) & 0xF) - -#define dest(p,x) ((x) + ((p)+(x))->i.offset) - -#define MAXOFF 0xF -#define MAXAUX 0xFF - -/* maximum size (in elements) for a pattern */ -#define MAXPATTSIZE (SHRT_MAX - 10) - - -#define isprop(op,p) (opproperties[(op)->i.code] & (p)) -#define isjmp(op) (isprop(op, ISJMP) && (op)->i.offset != 0) -#define iscapture(op) isprop(op, ISCAPTURE) -#define ischeck(op) (isprop(op, ISCHECK) && (op)->i.offset == 0) -#define isfixcheck(op) (isprop(op, ISFIXCHECK) && (op)->i.offset == 0) -#define istest(op) (isprop(op, ISCHECK) && (op)->i.offset != 0) -#define isnofail(op) isprop(op, ISNOFAIL) -#define ismovable(op) isprop(op, ISMOVABLE) -#define isfenvoff(op) isprop(op, ISFENVOFF) - - -/* kinds of captures */ -typedef enum CapKind { - Cclose, Cposition, Cconst, Cbackref, Carg, Csimple, Ctable, Cfunction, - Cquery, Cstring, Csubst, Cfold, Cruntime, Cgroup -} CapKind; - -#define iscapnosize(k) ((k) == Cposition || (k) == Cconst) - - -typedef struct Capture { - const char *s; /* position */ - short idx; - byte kind; - byte siz; -} Capture; - - -/* size (in elements) for an instruction plus extra l bytes */ -#define instsize(l) (((l) + sizeof(Instruction) - 1)/sizeof(Instruction) + 1) - - -/* size (in elements) for a ISet instruction */ -#define CHARSETINSTSIZE instsize(CHARSETSIZE) - -/* size (in elements) for a IFunc instruction */ -#define funcinstsize(p) ((p)->i.aux + 2) - - -#define loopset(v,b) { int v; for (v = 0; v < CHARSETSIZE; v++) b; } - - -#define testchar(st,c) (((int)(st)[((c) >> 3)] & (1 << ((c) & 7)))) -#define setchar(st,c) ((st)[(c) >> 3] |= (1 << ((c) & 7))) - - -static int target (Instruction *p, int i); - - -static int sizei (const Instruction *i) { - switch((Opcode)i->i.code) { - case ISet: case ISpan: return CHARSETINSTSIZE; - case IFunc: return funcinstsize(i); - default: return 1; - } -} - - -static const char *val2str (lua_State *L, int idx) { - const char *k = lua_tostring(L, idx); - if (k != NULL) - return lua_pushfstring(L, "rule '%s'", k); - else - return lua_pushfstring(L, "rule <a %s>", luaL_typename(L, idx)); -} +/* #include "lptypes.h" */ +/* #include "lpprint.h" */ +/* #include "lpcode.h" */ -static int getposition (lua_State *L, int t, int i) { - int res; - lua_getfenv(L, -1); - lua_rawgeti(L, -1, i); /* get key from pattern's environment */ - lua_gettable(L, t); /* get position from positions table */ - res = lua_tointeger(L, -1); - if (res == 0) { /* key has no registered position? */ - lua_rawgeti(L, -2, i); /* get key again */ - return luaL_error(L, "%s is not defined in given grammar", val2str(L, -1)); - } - lua_pop(L, 2); /* remove environment and position */ - return res; -} +#if defined(LPEG_DEBUG) /* ** {====================================================== @@ -252,7 +26,7 @@ static int getposition (lua_State *L, int t, int i) { */ -static void printcharset (const Charset st) { +void printcharset (const byte *st) { int i; printf("["); for (i = 0; i <= UCHAR_MAX; i++) { @@ -271,51 +45,53 @@ static void printcapkind (int kind) { const char *const modes[] = { "close", "position", "constant", "backref", "argument", "simple", "table", "function", - "query", "string", "substitution", "fold", + "query", "string", "num", "substitution", "fold", "runtime", "group"}; printf("%s", modes[kind]); } static void printjmp (const Instruction *op, const Instruction *p) { - printf("-> "); - if (p->i.offset == 0) printf("FAIL"); - else printf("%d", (int)(dest(0, p) - op)); + printf("-> %d", (int)(p + (p + 1)->offset - op)); } static void printinst (const Instruction *op, const Instruction *p) { const char *const names[] = { - "any", "char", "set", "span", "back", + "any", "char", "set", + "testany", "testchar", "testset", + "span", "behind", "ret", "end", "choice", "jmp", "call", "open_call", "commit", "partial_commit", "back_commit", "failtwice", "fail", "giveup", - "func", - "fullcapture", "emptycapture", "emptycaptureidx", "opencapture", - "closecapture", "closeruntime" + "fullcapture", "opencapture", "closecapture", "closeruntime" }; printf("%02ld: %s ", (long)(p - op), names[p->i.code]); switch ((Opcode)p->i.code) { case IChar: { printf("'%c'", p->i.aux); - printjmp(op, p); break; } - case IAny: { - printf("* %d", p->i.aux); - printjmp(op, p); + case ITestChar: { + printf("'%c'", p->i.aux); printjmp(op, p); + break; + } + case IFullCapture: { + printcapkind(getkind(p)); + printf(" (size = %d) (idx = %d)", getoff(p), p->i.key); break; } - case IFullCapture: case IOpenCapture: - case IEmptyCapture: case IEmptyCaptureIdx: - case ICloseCapture: case ICloseRunTime: { + case IOpenCapture: { printcapkind(getkind(p)); - printf("(n = %d) (off = %d)", getoff(p), p->i.offset); + printf(" (idx = %d)", p->i.key); break; } case ISet: { printcharset((p+1)->buff); - printjmp(op, p); + break; + } + case ITestSet: { + printcharset((p+2)->buff); printjmp(op, p); break; } case ISpan: { @@ -323,16 +99,15 @@ static void printinst (const Instruction *op, const Instruction *p) { break; } case IOpenCall: { - printf("-> %d", p->i.offset); + printf("-> %d", (p + 1)->offset); break; } - case IChoice: { - printjmp(op, p); - printf(" (%d)", p->i.aux); + case IBehind: { + printf("%d", p->i.aux); break; } - case IJmp: case ICall: case ICommit: - case IPartialCommit: case IBackCommit: { + case IJmp: case ICall: case ICommit: case IChoice: + case IPartialCommit: case IBackCommit: case ITestAny: { printjmp(op, p); break; } @@ -342,25 +117,27 @@ static void printinst (const Instruction *op, const Instruction *p) { } -static void printpatt (Instruction *p) { +void printpatt (Instruction *p, int n) { Instruction *op = p; - for (;;) { + while (p < op + n) { printinst(op, p); - if ((Opcode)p->i.code == IEnd) break; p += sizei(p); } } -#if 0 +#if defined(LPEG_DEBUG) static void printcap (Capture *cap) { printcapkind(cap->kind); printf(" (idx: %d - size: %d) -> %p\n", cap->idx, cap->siz, cap->s); } -static void printcaplist (Capture *cap) { - for (; cap->s; cap++) printcap(cap); +void printcaplist (Capture *cap, Capture *limit) { + printf(">======\n"); + for (; cap->s && (limit == NULL || cap < limit); cap++) + printcap(cap); + printf("=======\n"); } #endif @@ -369,14 +146,147 @@ static void printcaplist (Capture *cap) { /* ** {====================================================== +** Printing trees (for debugging) +** ======================================================= +*/ + +static const char *tagnames[] = { + "char", "set", "any", + "true", "false", + "rep", + "seq", "choice", + "not", "and", + "call", "opencall", "rule", "grammar", + "behind", + "capture", "run-time" +}; + + +void printtree (TTree *tree, int ident) { + int i; + for (i = 0; i < ident; i++) printf(" "); + printf("%s", tagnames[tree->tag]); + switch (tree->tag) { + case TChar: { + int c = tree->u.n; + if (isprint(c)) + printf(" '%c'\n", c); + else + printf(" (%02X)\n", c); + break; + } + case TSet: { + printcharset(treebuffer(tree)); + printf("\n"); + break; + } + case TOpenCall: case TCall: { + printf(" key: %d\n", tree->key); + break; + } + case TBehind: { + printf(" %d\n", tree->u.n); + printtree(sib1(tree), ident + 2); + break; + } + case TCapture: { + printf(" cap: %d key: %d n: %d\n", tree->cap, tree->key, tree->u.n); + printtree(sib1(tree), ident + 2); + break; + } + case TRule: { + printf(" n: %d key: %d\n", tree->cap, tree->key); + printtree(sib1(tree), ident + 2); + break; /* do not print next rule as a sibling */ + } + case TGrammar: { + TTree *rule = sib1(tree); + printf(" %d\n", tree->u.n); /* number of rules */ + for (i = 0; i < tree->u.n; i++) { + printtree(rule, ident + 2); + rule = sib2(rule); + } + assert(rule->tag == TTrue); /* sentinel */ + break; + } + default: { + int sibs = numsiblings[tree->tag]; + printf("\n"); + if (sibs >= 1) { + printtree(sib1(tree), ident + 2); + if (sibs >= 2) + printtree(sib2(tree), ident + 2); + } + break; + } + } +} + + +void printktable (lua_State *L, int idx) { + int n, i; + lua_getfenv(L, idx); + if (lua_isnil(L, -1)) /* no ktable? */ + return; + n = lua_objlen(L, -1); + printf("["); + for (i = 1; i <= n; i++) { + printf("%d = ", i); + lua_rawgeti(L, -1, i); + if (lua_isstring(L, -1)) + printf("%s ", lua_tostring(L, -1)); + else + printf("%s ", lua_typename(L, lua_type(L, -1))); + lua_pop(L, 1); + } + printf("]\n"); + /* leave ktable at the stack */ +} + +/* }====================================================== */ + +#endif + + +/* +** $Id: lpvm.c,v 1.5 2013/04/12 16:29:49 roberto Exp $ +** Copyright 2007, Lua.org & PUC-Rio (see 'lpeg.html' for license) +*/ + +/* #include <limits.h> */ +/* #include <string.h> */ + + +/* #include "lua.h" */ +/* #include "lauxlib.h" */ + +/* #include "lpcap.h" */ +/* #include "lptypes.h" */ +/* #include "lpvm.h" */ +/* #include "lpprint.h" */ + + +/* initial size for call/backtrack stack */ +#if !defined(INITBACK) +#define INITBACK 100 +#endif + + +#define getoffset(p) (((p) + 1)->offset) + +static const Instruction giveup = {{IGiveup, 0, 0}}; + + +/* +** {====================================================== ** Virtual Machine ** ======================================================= */ typedef struct Stack { - const char *s; - const Instruction *p; + const char *s; /* saved position (or NULL for calls) */ + const Instruction *p; /* next instruction */ int caplevel; } Stack; @@ -384,10 +294,9 @@ typedef struct Stack { #define getstackbase(L, ptop) ((Stack *)lua_touserdata(L, stackidx(ptop))) -static int runtimecap (lua_State *L, Capture *close, Capture *ocap, - const char *o, const char *s, int ptop); - - +/* +** Double the size of the array of captures +*/ static Capture *doublecap (lua_State *L, Capture *cap, int captop, int ptop) { Capture *newc; if (captop >= INT_MAX/((int)sizeof(Capture) * 2)) @@ -399,61 +308,111 @@ static Capture *doublecap (lua_State *L, Capture *cap, int captop, int ptop) { } +/* +** Double the size of the stack +*/ static Stack *doublestack (lua_State *L, Stack **stacklimit, int ptop) { Stack *stack = getstackbase(L, ptop); Stack *newstack; - int n = *stacklimit - stack; + int n = *stacklimit - stack; /* current stack size */ int max, newn; lua_getfield(L, LUA_REGISTRYINDEX, MAXSTACKIDX); - max = lua_tointeger(L, -1); + max = lua_tointeger(L, -1); /* maximum allowed size */ lua_pop(L, 1); - if (n >= max) + if (n >= max) /* already at maximum size? */ luaL_error(L, "too many pending calls/choices"); - newn = 2*n; if (newn > max) newn = max; + newn = 2 * n; /* new size */ + if (newn > max) newn = max; newstack = (Stack *)lua_newuserdata(L, newn * sizeof(Stack)); memcpy(newstack, stack, n * sizeof(Stack)); lua_replace(L, stackidx(ptop)); *stacklimit = newstack + newn; - return newstack + n; + return newstack + n; /* return next position */ +} + +/* +** Interpret the result of a dynamic capture: false -> fail; +** true -> keep current position; number -> next position. +** Return new subject position. 'fr' is stack index where +** is the result; 'curr' is current subject position; 'limit' +** is subject's size. +*/ +static int resdyncaptures (lua_State *L, int fr, int curr, int limit) { + lua_Integer res; + if (!lua_toboolean(L, fr)) { /* false value? */ + lua_settop(L, fr - 1); /* remove results */ + return -1; /* and fail */ + } + else if (lua_isboolean(L, fr)) /* true? */ + res = curr; /* keep current position */ + else { + res = lua_tointeger(L, fr) - 1; /* new position */ + if (res < curr || res > limit) + luaL_error(L, "invalid position returned by match-time capture"); + } + lua_remove(L, fr); /* remove first result (offset) */ + return res; } +/* +** Add capture values returned by a dynamic capture to the capture list +** 'base', nested inside a group capture. 'fd' indexes the first capture +** value, 'n' is the number of values (at least 1). +*/ static void adddyncaptures (const char *s, Capture *base, int n, int fd) { int i; - assert(base[0].kind == Cruntime && base[0].siz == 0); - base[0].idx = fd; /* first returned capture */ - for (i = 1; i < n; i++) { /* add extra captures */ + /* Cgroup capture is already there */ + assert(base[0].kind == Cgroup && base[0].siz == 0); + base[0].idx = 0; /* make it an anonymous group */ + for (i = 1; i <= n; i++) { /* add runtime captures */ + base[i].kind = Cruntime; base[i].siz = 1; /* mark it as closed */ + base[i].idx = fd + i - 1; /* stack index of capture value */ base[i].s = s; - base[i].kind = Cruntime; - base[i].idx = fd + i; /* stack index */ } - base[n].kind = Cclose; /* add closing entry */ - base[n].siz = 1; - base[n].s = s; + base[i].kind = Cclose; /* close group */ + base[i].siz = 1; + base[i].s = s; } -#define condfailed(p) { int f = p->i.offset; if (f) p+=f; else goto fail; } +/* +** Remove dynamic captures from the Lua stack (called in case of failure) +*/ +static int removedyncap (lua_State *L, Capture *capture, + int level, int last) { + int id = finddyncap(capture + level, capture + last); /* index of 1st cap. */ + int top = lua_gettop(L); + if (id == 0) return 0; /* no dynamic captures? */ + lua_settop(L, id - 1); /* remove captures */ + return top - id + 1; /* number of values removed */ +} + -static const char *match (lua_State *L, - const char *o, const char *s, const char *e, - Instruction *op, Capture *capture, int ptop) { +/* +** Opcode interpreter +*/ +const char *match (lua_State *L, const char *o, const char *s, const char *e, + Instruction *op, Capture *capture, int ptop) { Stack stackbase[INITBACK]; Stack *stacklimit = stackbase + INITBACK; Stack *stack = stackbase; /* point to first empty slot in stack */ int capsize = INITCAPSIZE; int captop = 0; /* point to first empty slot in captures */ - const Instruction *p = op; + int ndyncap = 0; /* number of dynamic captures (in Lua stack) */ + const Instruction *p = op; /* current instruction */ stack->p = &giveup; stack->s = s; stack->caplevel = 0; stack++; lua_pushlightuserdata(L, stackbase); for (;;) { #if defined(DEBUG) - printf("s: |%s| stck: %d c: %d ", - s, stack - getstackbase(L, ptop), captop); + printf("s: |%s| stck:%d, dyncaps:%d, caps:%d ", + s, stack - getstackbase(L, ptop), ndyncap, captop); printinst(op, p); + printcaplist(capture, capture + captop); #endif + assert(stackidx(ptop) + ndyncap == lua_gettop(L) && ndyncap <= captop); switch ((Opcode)p->i.code) { case IEnd: { assert(stack == getstackbase(L, ptop) + 1); @@ -471,24 +430,40 @@ static const char *match (lua_State *L, continue; } case IAny: { - int n = p->i.aux; - if (n <= e - s) { p++; s += n; } - else condfailed(p); + if (s < e) { p++; s++; } + else goto fail; + continue; + } + case ITestAny: { + if (s < e) p += 2; + else p += getoffset(p); continue; } case IChar: { if ((byte)*s == p->i.aux && s < e) { p++; s++; } - else condfailed(p); + else goto fail; + continue; + } + case ITestChar: { + if ((byte)*s == p->i.aux && s < e) p += 2; + else p += getoffset(p); continue; } case ISet: { int c = (byte)*s; if (testchar((p+1)->buff, c) && s < e) { p += CHARSETINSTSIZE; s++; } - else condfailed(p); + else goto fail; + continue; + } + case ITestSet: { + int c = (byte)*s; + if (testchar((p + 2)->buff, c) && s < e) + p += 1 + CHARSETINSTSIZE; + else p += getoffset(p); continue; } - case IBack: { + case IBehind: { int n = p->i.aux; if (n > s - o) goto fail; s -= n; p++; @@ -502,53 +477,47 @@ static const char *match (lua_State *L, p += CHARSETINSTSIZE; continue; } - case IFunc: { - const char *r = (p+1)->f(s, e, o, (p+2)->buff); - if (r != NULL) { s = r; p += funcinstsize(p); } - else condfailed(p); - continue; - } case IJmp: { - p += p->i.offset; + p += getoffset(p); continue; } case IChoice: { if (stack == stacklimit) stack = doublestack(L, &stacklimit, ptop); - stack->p = dest(0, p); - stack->s = s - p->i.aux; + stack->p = p + getoffset(p); + stack->s = s; stack->caplevel = captop; stack++; - p++; + p += 2; continue; } case ICall: { if (stack == stacklimit) stack = doublestack(L, &stacklimit, ptop); stack->s = NULL; - stack->p = p + 1; /* save return address */ + stack->p = p + 2; /* save return address */ stack++; - p += p->i.offset; + p += getoffset(p); continue; } case ICommit: { assert(stack > getstackbase(L, ptop) && (stack - 1)->s != NULL); stack--; - p += p->i.offset; + p += getoffset(p); continue; } case IPartialCommit: { assert(stack > getstackbase(L, ptop) && (stack - 1)->s != NULL); (stack - 1)->s = s; (stack - 1)->caplevel = captop; - p += p->i.offset; + p += getoffset(p); continue; } case IBackCommit: { assert(stack > getstackbase(L, ptop) && (stack - 1)->s != NULL); s = (--stack)->s; captop = stack->caplevel; - p += p->i.offset; + p += getoffset(p); continue; } case IFailTwice: @@ -561,41 +530,41 @@ static const char *match (lua_State *L, assert(stack > getstackbase(L, ptop)); s = (--stack)->s; } while (s == NULL); + if (ndyncap > 0) /* is there matchtime captures? */ + ndyncap -= removedyncap(L, capture, stack->caplevel, captop); captop = stack->caplevel; p = stack->p; continue; } case ICloseRunTime: { + CapState cs; + int rem, res, n; int fr = lua_gettop(L) + 1; /* stack index of first result */ - int ncap = runtimecap(L, capture + captop, capture, o, s, ptop); - lua_Integer res = lua_tointeger(L, fr) - 1; /* offset */ - int n = lua_gettop(L) - fr; /* number of new captures */ - if (res == -1) { /* may not be a number */ - if (!lua_toboolean(L, fr)) { /* false value? */ - lua_settop(L, fr - 1); /* remove results */ - goto fail; /* and fail */ - } - else if (lua_isboolean(L, fr)) /* true? */ - res = s - o; /* keep current position */ - } - if (res < s - o || res > e - o) - luaL_error(L, "invalid position returned by match-time capture"); - s = o + res; /* update current position */ - captop -= ncap; /* remove nested captures */ - lua_remove(L, fr); /* remove first result (offset) */ - if (n > 0) { /* captures? */ - if ((captop += n + 1) >= capsize) { + cs.s = o; cs.L = L; cs.ocap = capture; cs.ptop = ptop; + n = runtimecap(&cs, capture + captop, s, &rem); /* call function */ + captop -= n; /* remove nested captures */ + fr -= rem; /* 'rem' items were popped from Lua stack */ + res = resdyncaptures(L, fr, s - o, e - o); /* get result */ + if (res == -1) /* fail? */ + goto fail; + s = o + res; /* else update current position */ + n = lua_gettop(L) - fr + 1; /* number of new captures */ + ndyncap += n - rem; /* update number of dynamic captures */ + if (n > 0) { /* any new capture? */ + if ((captop += n + 2) >= capsize) { capture = doublecap(L, capture, captop, ptop); capsize = 2 * captop; } - adddyncaptures(s, capture + captop - n - 1, n, fr); + /* add new captures to 'capture' list */ + adddyncaptures(s, capture + captop - n - 2, n, fr); } p++; continue; } case ICloseCapture: { - const char *s1 = s - getoff(p); + const char *s1 = s; assert(captop > 0); + /* if possible, turn capture into a full capture */ if (capture[captop - 1].siz == 0 && s1 - capture[captop - 1].s < UCHAR_MAX) { capture[captop - 1].siz = s1 - capture[captop - 1].s + 1; @@ -604,20 +573,20 @@ static const char *match (lua_State *L, } else { capture[captop].siz = 1; /* mark entry as closed */ - goto capture; + capture[captop].s = s; + goto pushcapture; } } - case IEmptyCapture: case IEmptyCaptureIdx: - capture[captop].siz = 1; /* mark entry as closed */ - goto capture; case IOpenCapture: capture[captop].siz = 0; /* mark entry as open */ - goto capture; + capture[captop].s = s; + goto pushcapture; case IFullCapture: capture[captop].siz = getoff(p) + 1; /* save capture size */ - capture: { capture[captop].s = s - getoff(p); - capture[captop].idx = p->i.offset; + /* goto pushcapture; */ + pushcapture: { + capture[captop].idx = p->i.key; capture[captop].kind = getkind(p); if (++captop >= capsize) { capture = doublecap(L, capture, captop, ptop); @@ -626,10 +595,6 @@ static const char *match (lua_State *L, p++; continue; } - case IOpenCall: { - lua_rawgeti(L, penvidx(ptop), p->i.offset); - luaL_error(L, "reference to %s outside a grammar", val2str(L, -1)); - } default: assert(0); return NULL; } } @@ -638,1207 +603,982 @@ static const char *match (lua_State *L, /* }====================================================== */ -/* -** {====================================================== -** Verifier -** ======================================================= -*/ /* -** check whether pattern may go from 'p' to 'e' without consuming any -** input. Raises an error if it detects a left recursion. 'op' points -** the beginning of the pattern. If pattern belongs to a grammar, -** 'rule' is the stack index where is its corresponding key (only for -** error messages) and 'posttable' is the stack index with a table -** mapping rule keys to the position of their code in the pattern. +** $Id: lpcode.c,v 1.18 2013/04/12 16:30:33 roberto Exp $ +** Copyright 2007, Lua.org & PUC-Rio (see 'lpeg.html' for license) */ -static int verify (lua_State *L, Instruction *op, const Instruction *p, - Instruction *e, int postable, int rule) { - static const char dummy[] = ""; - Stack back[MAXBACKVER]; - int backtop = 0; /* point to first empty slot in back */ - while (p != e) { - switch ((Opcode)p->i.code) { - case IRet: { - p = back[--backtop].p; - continue; - } - case IChoice: { - if (backtop >= MAXBACKVER) - return luaL_error(L, "too many pending calls/choices"); - back[backtop].p = dest(0, p); - back[backtop++].s = dummy; - p++; - continue; - } - case ICall: { - assert((p + 1)->i.code != IRet); /* no tail call */ - if (backtop >= MAXBACKVER) - return luaL_error(L, "too many pending calls/choices"); - back[backtop].s = NULL; - back[backtop++].p = p + 1; - goto dojmp; - } - case IOpenCall: { - int i; - if (postable == 0) /* grammar still not fixed? */ - goto fail; /* to be verified later */ - for (i = 0; i < backtop; i++) { - if (back[i].s == NULL && back[i].p == p + 1) - return luaL_error(L, "%s is left recursive", val2str(L, rule)); - } - if (backtop >= MAXBACKVER) - return luaL_error(L, "too many pending calls/choices"); - back[backtop].s = NULL; - back[backtop++].p = p + 1; - p = op + getposition(L, postable, p->i.offset); - continue; - } - case IBackCommit: - case ICommit: { - assert(backtop > 0 && p->i.offset > 0); - backtop--; - goto dojmp; - } - case IPartialCommit: { - assert(backtop > 0); - if (p->i.offset > 0) goto dojmp; /* forward jump */ - else { /* loop will be detected when checking corresponding rule */ - assert(postable != 0); - backtop--; - p++; /* just go on now */ - continue; - } - } - case IBack: { - if (p->i.aux == 1 && isfixcheck(p + 1)) { /* char test? */ - p++; /* skip back instruction */ - p += sizei(p); /* skip char test */ - } - else { /* standard lookbehind code */ - assert((Opcode)(p - 1)->i.code == IChoice); /* look behind */ - backtop--; - p += (p - 1)->i.offset; - assert((Opcode)(p - 1)->i.code == IFail); /* look behind */ - } - continue; - } - case IAny: - case IChar: - case ISet: { - const Instruction *next = p + sizei(p); - if ((Opcode)next->i.code == IBack) - p = next + 1; /* continue after the back instruction */ - else if (p->i.offset == 0) goto fail; - else /* jump */ - p += p->i.offset; - continue; - } - case IJmp: - dojmp: { - p += p->i.offset; - continue; - } - case IFailTwice: /* 'not' predicate */ - goto fail; /* body could have failed; try to backtrack it */ - case IFail: { - if (p > op && (p - 1)->i.code == IBackCommit) { /* 'and' predicate? */ - p++; /* pretend it succeeded and go ahead */ - continue; - } - /* else failed: go through */ - } - fail: { /* pattern failed: try to backtrack */ - do { - if (backtop-- == 0) - return 1; /* no more backtracking */ - } while (back[backtop].s == NULL); - p = back[backtop].p; - continue; - } - case ISpan: - case IOpenCapture: case ICloseCapture: - case IEmptyCapture: case IEmptyCaptureIdx: - case IFullCapture: { - p += sizei(p); - continue; - } - case ICloseRunTime: { - goto fail; /* be liberal in this case */ - } - case IFunc: { - const char *r = (p+1)->f(dummy, dummy, dummy, (p+2)->buff); - if (r != NULL) { p += funcinstsize(p); } - else condfailed(p); - continue; - } - case IEnd: /* cannot happen (should stop before it) */ - default: assert(0); return 0; - } - } - assert(backtop == 0); - return 0; -} - - -static void checkrule (lua_State *L, Instruction *op, int from, int to, - int postable, int rule) { - int i; - int lastopen = 0; /* more recent OpenCall seen in the code */ - for (i = from; i < to; i += sizei(op + i)) { - if (op[i].i.code == IPartialCommit && op[i].i.offset < 0) { /* loop? */ - int start = dest(op, i); - assert(op[start - 1].i.code == IChoice && - dest(op, start - 1) == target(op, i + 1)); - if (start <= lastopen) { /* loop does contain an open call? */ - if (!verify(L, op, op + start, op + i, postable, rule)) /* check body */ - luaL_error(L, "possible infinite loop in %s", val2str(L, rule)); - } - } - else if (op[i].i.code == IOpenCall) - lastopen = i; - } - assert(op[i - 1].i.code == IRet); - verify(L, op, op + from, op + to - 1, postable, rule); -} - +/* #include <limits.h> */ -/* }====================================================== */ +/* #include "lua.h" */ +/* #include "lauxlib.h" */ +/* #include "lptypes.h" */ +/* #include "lpcode.h" */ -/* -** {====================================================== -** Building Patterns -** ======================================================= -*/ -enum charsetanswer { NOINFO, ISCHARSET, VALIDSTARTS }; +/* signals a "no-instruction */ +#define NOINST -1 -typedef struct CharsetTag { - enum charsetanswer tag; - Charset cs; -} CharsetTag; -static Instruction *getpatt (lua_State *L, int idx, int *size); - - -static void check2test (Instruction *p, int n) { - assert(ischeck(p) && n != 0); - p->i.offset = n; -} +static const Charset fullset_ = + {{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}}; +static const Charset *fullset = &fullset_; /* -** invert array slice p[0]-p[e] (both inclusive) +** {====================================================== +** Analysis and some optimizations +** ======================================================= */ -static void invert (Instruction *p, int e) { - int i; - for (i = 0; i < e; i++, e--) { - Instruction temp = p[i]; - p[i] = p[e]; - p[e] = temp; - } -} - /* -** rotate array slice p[0]-p[e] (both inclusive) 'n' steps -** to the 'left' +** Check whether a charset is empty (IFail), singleton (IChar), +** full (IAny), or none of those (ISet). */ -static void rotate (Instruction *p, int e, int n) { - invert(p, n - 1); - invert(p + n, e - n); - invert(p, e); -} - - -#define op_step(p) ((p)->i.code == IAny ? (p)->i.aux : 1) - - -static int skipchecks (Instruction *p, int up, int *pn) { - int i, n = 0; - for (i = 0; isfixcheck(p + i); i += sizei(p + i)) { - int st = op_step(p + i); - if (n + st > MAXOFF - up) break; - n += st; - } - *pn = n; - return i; -} - - -#define ismovablecap(op) (ismovable(op) && getoff(op) < MAXOFF) - -static void optimizecaptures (Instruction *p) { +static Opcode charsettype (const byte *cs, int *c) { + int count = 0; int i; - int limit = 0; - for (i = 0; p[i].i.code != IEnd; i += sizei(p + i)) { - if (isjmp(p + i) && dest(p, i) >= limit) - limit = dest(p, i) + 1; /* do not optimize jump targets */ - else if (i >= limit && ismovablecap(p + i) && isfixcheck(p + i + 1)) { - int end, n, j; /* found a border capture|check */ - int maxoff = getoff(p + i); - int start = i; - /* find first capture in the group */ - while (start > limit && ismovablecap(p + start - 1)) { - start--; - if (getoff(p + start) > maxoff) maxoff = getoff(p + start); + int candidate = -1; /* candidate position for a char */ + for (i = 0; i < CHARSETSIZE; i++) { + int b = cs[i]; + if (b == 0) { + if (count > 1) return ISet; /* else set is still empty */ + } + else if (b == 0xFF) { + if (count < (i * BITSPERCHAR)) + return ISet; + else count += BITSPERCHAR; /* set is still full */ + } + else if ((b & (b - 1)) == 0) { /* byte has only one bit? */ + if (count > 0) + return ISet; /* set is neither full nor empty */ + else { /* set has only one char till now; track it */ + count++; + candidate = i; } - end = skipchecks(p + i + 1, maxoff, &n) + i; /* find last check */ - if (n == 0) continue; /* first check is too big to move across */ - assert(n <= MAXOFF && start <= i && i < end); - for (j = start; j <= i; j++) - p[j].i.aux += (n << 4); /* correct offset of captures to be moved */ - rotate(p + start, end - start, i - start + 1); /* move them up */ - i = end; - assert(isfixcheck(p + start) && iscapture(p + i)); + } + else return ISet; /* byte is neither empty, full, nor singleton */ + } + switch (count) { + case 0: return IFail; /* empty set */ + case 1: { /* singleton; find character bit inside byte */ + int b = cs[candidate]; + *c = candidate * BITSPERCHAR; + if ((b & 0xF0) != 0) { *c += 4; b >>= 4; } + if ((b & 0x0C) != 0) { *c += 2; b >>= 2; } + if ((b & 0x02) != 0) { *c += 1; } + return IChar; + } + default: { + assert(count == CHARSETSIZE * BITSPERCHAR); /* full set */ + return IAny; } } } - -static int target (Instruction *p, int i) { - while (p[i].i.code == IJmp) i += p[i].i.offset; - return i; -} - - -static void optimizejumps (Instruction *p) { - int i; - for (i = 0; p[i].i.code != IEnd; i += sizei(p + i)) { - if (isjmp(p + i)) - p[i].i.offset = target(p, dest(p, i)) - i; - } +/* +** A few basic operations on Charsets +*/ +static void cs_complement (Charset *cs) { + loopset(i, cs->cs[i] = ~cs->cs[i]); } -static void optimizechoice (Instruction *p) { - assert(p->i.code == IChoice); - if (isfixcheck(p + 1)) { - int lc = sizei(p + 1); - rotate(p, lc, 1); - assert(isfixcheck(p) && (p + lc)->i.code == IChoice); - (p + lc)->i.aux = op_step(p); - check2test(p, (p + lc)->i.offset); - (p + lc)->i.offset -= lc; - } +static int cs_equal (const byte *cs1, const byte *cs2) { + loopset(i, if (cs1[i] != cs2[i]) return 0); + return 1; } /* -** A 'headfail' pattern is a pattern that can only fails in its first -** instruction, which must be a check. +** computes whether sets cs1 and cs2 are disjoint */ -static int isheadfail (Instruction *p) { - if (!ischeck(p)) return 0; - /* check that other operations cannot fail */ - for (p += sizei(p); p->i.code != IEnd; p += sizei(p)) - if (!isnofail(p)) return 0; +static int cs_disjoint (const Charset *cs1, const Charset *cs2) { + loopset(i, if ((cs1->cs[i] & cs2->cs[i]) != 0) return 0;) return 1; } -#define checkpattern(L, idx) ((Instruction *)luaL_checkudata(L, idx, PATTERN_T)) - - /* -** Return the number of elements in the ktable of a pattern. -** in Lua 5.2, default "environment" for patterns is nil, not -** a table. Treat it as an empty table. +** Convert a 'char' pattern (TSet, TChar, TAny) to a charset */ -static int ktablelen (lua_State *L, int idx) { - if (!lua_istable(L, idx)) return 0; - else return lua_objlen(L, idx); -} - - -/* -** join the elements of the ktable from pattern 'p1' into the ktable of -** the pattern at the top of the stack ('p'). If 'p1' has no elements, -** 'p' keeps its original ktable. If 'p' has no elements, it shares -** 'p1' ktable. Otherwise, this function creates a new ktable for 'p'. -** Return the offset of original 'p' elements in the new ktable. -*/ -static int jointable (lua_State *L, int p1) { - int n, n1, i; - lua_getfenv(L, p1); - n1 = ktablelen(L, -1); /* number of elements in p1's env */ - lua_getfenv(L, -2); - if (n1 == 0 || lua_equal(L, -2, -1)) { - lua_pop(L, 2); - return 0; /* no need to change anything */ - } - n = ktablelen(L, -1); /* number of elements in p's env */ - if (n == 0) { - lua_pop(L, 1); /* removes p env */ - lua_setfenv(L, -2); /* p now shares p1's env */ - return 0; /* no need to correct anything */ - } - lua_createtable(L, n + n1, 0); - /* stack: p; p1 env; p env; new p env */ - for (i = 1; i <= n; i++) { - lua_rawgeti(L, -2, i); - lua_rawseti(L, -2, i); - } - for (i = 1; i <= n1; i++) { - lua_rawgeti(L, -3, i); - lua_rawseti(L, -2, n + i); +int tocharset (TTree *tree, Charset *cs) { + switch (tree->tag) { + case TSet: { /* copy set */ + loopset(i, cs->cs[i] = treebuffer(tree)[i]); + return 1; + } + case TChar: { /* only one char */ + assert(0 <= tree->u.n && tree->u.n <= UCHAR_MAX); + loopset(i, cs->cs[i] = 0); /* erase all chars */ + setchar(cs->cs, tree->u.n); /* add that one */ + return 1; + } + case TAny: { + loopset(i, cs->cs[i] = 0xFF); /* add all to the set */ + return 1; + } + default: return 0; } - lua_setfenv(L, -4); /* new table becomes p env */ - lua_pop(L, 2); /* remove p1 env and old p env */ - return n; } -#define copypatt(p1,p2,sz) memcpy(p1, p2, (sz) * sizeof(Instruction)); - -#define pattsize(L,idx) (lua_objlen(L, idx)/sizeof(Instruction) - 1) - - -static int addpatt (lua_State *L, Instruction *p, int p1idx) { - Instruction *p1 = (Instruction *)lua_touserdata(L, p1idx); - int sz = pattsize(L, p1idx); - int corr = jointable(L, p1idx); - copypatt(p, p1, sz + 1); - if (corr != 0) { - Instruction *px; - for (px = p; px < p + sz; px += sizei(px)) { - if (isfenvoff(px) && px->i.offset != 0) - px->i.offset += corr; +/* +** Checks whether a pattern has captures +*/ +int hascaptures (TTree *tree) { + tailcall: + switch (tree->tag) { + case TCapture: case TRunTime: + return 1; + default: { + switch (numsiblings[tree->tag]) { + case 1: /* return hascaptures(sib1(tree)); */ + tree = sib1(tree); goto tailcall; + case 2: + if (hascaptures(sib1(tree))) return 1; + /* else return hascaptures(sib2(tree)); */ + tree = sib2(tree); goto tailcall; + default: assert(numsiblings[tree->tag] == 0); return 0; + } } } - return sz; -} - - -static void setinstaux (Instruction *i, Opcode op, int offset, int aux) { - assert(aux <= MAXAUX); - i->i.code = op; - i->i.offset = offset; - i->i.aux = aux; } -#define setinst(i,op,off) setinstaux(i,op,off,0) - -#define setinstcap(i,op,idx,k,n) setinstaux(i,op,idx,((k) | ((n) << 4))) - /* -** create a new ktable for pattern at the stack top, mapping -** '1' to the value at stack position 'vidx'. +** Checks how a pattern behaves regarding the empty string, +** in one of two different ways: +** A pattern is *nullable* if it can match without consuming any character; +** A pattern is *nofail* if it never fails for any string +** (including the empty string). +** The difference is only for predicates and run-time captures; +** for other patterns, the two properties are equivalent. +** (With predicates, &'a' is nullable but not nofail. Of course, +** nofail => nullable.) +** These functions are all convervative in the following way: +** p is nullable => nullable(p) +** nofail(p) => p cannot fail +** The function assumes that TOpenCall is not nullable; +** this will be checked again when the grammar is fixed.) +** Run-time captures can do whatever they want, so the result +** is conservative. */ -static int value2fenv (lua_State *L, int vidx) { - lua_createtable(L, 1, 0); - lua_pushvalue(L, vidx); - lua_rawseti(L, -2, 1); - lua_setfenv(L, -2); - return 1; +int checkaux (TTree *tree, int pred) { + tailcall: + switch (tree->tag) { + case TChar: case TSet: case TAny: + case TFalse: case TOpenCall: + return 0; /* not nullable */ + case TRep: case TTrue: + return 1; /* no fail */ + case TNot: case TBehind: /* can match empty, but can fail */ + if (pred == PEnofail) return 0; + else return 1; /* PEnullable */ + case TAnd: /* can match empty; fail iff body does */ + if (pred == PEnullable) return 1; + /* else return checkaux(sib1(tree), pred); */ + tree = sib1(tree); goto tailcall; + case TRunTime: /* can fail; match empty iff body does */ + if (pred == PEnofail) return 0; + /* else return checkaux(sib1(tree), pred); */ + tree = sib1(tree); goto tailcall; + case TSeq: + if (!checkaux(sib1(tree), pred)) return 0; + /* else return checkaux(sib2(tree), pred); */ + tree = sib2(tree); goto tailcall; + case TChoice: + if (checkaux(sib2(tree), pred)) return 1; + /* else return checkaux(sib1(tree), pred); */ + tree = sib1(tree); goto tailcall; + case TCapture: case TGrammar: case TRule: + /* return checkaux(sib1(tree), pred); */ + tree = sib1(tree); goto tailcall; + case TCall: /* return checkaux(sib2(tree), pred); */ + tree = sib2(tree); goto tailcall; + default: assert(0); return 0; + }; } -static Instruction *newpatt (lua_State *L, size_t n) { - Instruction *p; - if (n >= MAXPATTSIZE - 1) - luaL_error(L, "pattern too big"); - p = (Instruction *)lua_newuserdata(L, (n + 1) * sizeof(Instruction)); - luaL_getmetatable(L, PATTERN_T); - lua_setmetatable(L, -2); - setinst(p + n, IEnd, 0); - return p; +/* +** number of characters to match a pattern (or -1 if variable) +** ('count' avoids infinite loops for grammars) +*/ +int fixedlenx (TTree *tree, int count, int len) { + tailcall: + switch (tree->tag) { + case TChar: case TSet: case TAny: + return len + 1; + case TFalse: case TTrue: case TNot: case TAnd: case TBehind: + return len; + case TRep: case TRunTime: case TOpenCall: + return -1; + case TCapture: case TRule: case TGrammar: + /* return fixedlenx(sib1(tree), count); */ + tree = sib1(tree); goto tailcall; + case TCall: + if (count++ >= MAXRULES) + return -1; /* may be a loop */ + /* else return fixedlenx(sib2(tree), count); */ + tree = sib2(tree); goto tailcall; + case TSeq: { + len = fixedlenx(sib1(tree), count, len); + if (len < 0) return -1; + /* else return fixedlenx(sib2(tree), count, len); */ + tree = sib2(tree); goto tailcall; + } + case TChoice: { + int n1, n2; + n1 = fixedlenx(sib1(tree), count, len); + if (n1 < 0) return -1; + n2 = fixedlenx(sib2(tree), count, len); + if (n1 == n2) return n1; + else return -1; + } + default: assert(0); return 0; + }; } -static void fillcharset (Instruction *p, Charset cs) { - switch (p[0].i.code) { - case ISet: { - loopset(i, cs[i] = p[1].buff[i]); - break; +/* +** Computes the 'first set' of a pattern. +** The result is a conservative aproximation: +** match p ax -> x' for some x ==> a in first(p). +** The set 'follow' is the first set of what follows the +** pattern (full set if nothing follows it). +** The function returns 0 when this set can be used for +** tests that avoid the pattern altogether. +** A non-zero return can happen for two reasons: +** 1) match p '' -> '' ==> returns 1. +** (tests cannot be used because they always fail for an empty input) +** 2) there is a match-time capture ==> returns 2. +** (match-time captures should not be avoided by optimizations) +*/ +static int getfirst (TTree *tree, const Charset *follow, Charset *firstset) { + tailcall: + switch (tree->tag) { + case TChar: case TSet: case TAny: { + tocharset(tree, firstset); + return 0; } - case IChar: { - loopset(i, cs[i] = 0); - setchar(cs, p[0].i.aux); - break; + case TTrue: { + loopset(i, firstset->cs[i] = follow->cs[i]); + return 1; } - default: { /* any char may start unhandled instructions */ - loopset(i, cs[i] = 0xff); - break; + case TFalse: { + loopset(i, firstset->cs[i] = 0); + return 0; + } + case TChoice: { + Charset csaux; + int e1 = getfirst(sib1(tree), follow, firstset); + int e2 = getfirst(sib2(tree), follow, &csaux); + loopset(i, firstset->cs[i] |= csaux.cs[i]); + return e1 | e2; + } + case TSeq: { + if (!nullable(sib1(tree))) { + /* return getfirst(sib1(tree), fullset, firstset); */ + tree = sib1(tree); follow = fullset; goto tailcall; + } + else { /* FIRST(p1 p2, fl) = FIRST(p1, FIRST(p2, fl)) */ + Charset csaux; + int e2 = getfirst(sib2(tree), follow, &csaux); + int e1 = getfirst(sib1(tree), &csaux, firstset); + if (e1 == 0) return 0; /* 'e1' ensures that first can be used */ + else if ((e1 | e2) & 2) /* one of the children has a matchtime? */ + return 2; /* pattern has a matchtime capture */ + else return e2; /* else depends on 'e2' */ + } + } + case TRep: { + getfirst(sib1(tree), follow, firstset); + loopset(i, firstset->cs[i] |= follow->cs[i]); + return 1; /* accept the empty string */ + } + case TCapture: case TGrammar: case TRule: { + /* return getfirst(sib1(tree), follow, firstset); */ + tree = sib1(tree); goto tailcall; + } + case TRunTime: { /* function invalidates any follow info. */ + int e = getfirst(sib1(tree), fullset, firstset); + if (e) return 2; /* function is not "protected"? */ + else return 0; /* pattern inside capture ensures first can be used */ } + case TCall: { + /* return getfirst(sib2(tree), follow, firstset); */ + tree = sib2(tree); goto tailcall; + } + case TAnd: { + int e = getfirst(sib1(tree), follow, firstset); + loopset(i, firstset->cs[i] &= follow->cs[i]); + return e; + } + case TNot: { + if (tocharset(sib1(tree), firstset)) { + cs_complement(firstset); + return 1; + } + /* else go through */ + } + case TBehind: { /* instruction gives no new information */ + /* call 'getfirst' to check for math-time captures */ + int e = getfirst(sib1(tree), follow, firstset); + loopset(i, firstset->cs[i] = follow->cs[i]); /* uses follow */ + return e | 1; /* always can accept the empty string */ + } + default: assert(0); return 0; } } /* -** Function 'tocharset' gets information about which chars may be a -** valid start for a pattern. +** If it returns true, then pattern can fail only depending on the next +** character of the subject */ - -static enum charsetanswer tocharset (Instruction *p, CharsetTag *c) { - if (isfixcheck(p)) { - fillcharset(p, c->cs); - if ((p + sizei(p))->i.code == IEnd && op_step(p) == 1) - c->tag = ISCHARSET; - else - c->tag = VALIDSTARTS; +static int headfail (TTree *tree) { + tailcall: + switch (tree->tag) { + case TChar: case TSet: case TAny: case TFalse: + return 1; + case TTrue: case TRep: case TRunTime: case TNot: + case TBehind: + return 0; + case TCapture: case TGrammar: case TRule: case TAnd: + tree = sib1(tree); goto tailcall; /* return headfail(sib1(tree)); */ + case TCall: + tree = sib2(tree); goto tailcall; /* return headfail(sib2(tree)); */ + case TSeq: + if (!nofail(sib2(tree))) return 0; + /* else return headfail(sib1(tree)); */ + tree = sib1(tree); goto tailcall; + case TChoice: + if (!headfail(sib1(tree))) return 0; + /* else return headfail(sib2(tree)); */ + tree = sib2(tree); goto tailcall; + default: assert(0); return 0; } - else - c->tag = NOINFO; - return c->tag; } -static int exclusiveset (Charset c1, Charset c2) { - /* non-empty intersection? */ - loopset(i, {if ((c1[i] & c2[i]) != 0) return 0;}); - return 1; /* no intersection */ +/* +** Check whether the code generation for the given tree can benefit +** from a follow set (to avoid computing the follow set when it is +** not needed) +*/ +static int needfollow (TTree *tree) { + tailcall: + switch (tree->tag) { + case TChar: case TSet: case TAny: + case TFalse: case TTrue: case TAnd: case TNot: + case TRunTime: case TGrammar: case TCall: case TBehind: + return 0; + case TChoice: case TRep: + return 1; + case TCapture: + tree = sib1(tree); goto tailcall; + case TSeq: + tree = sib2(tree); goto tailcall; + default: assert(0); return 0; + } } - -static int exclusive (CharsetTag *c1, CharsetTag *c2) { - if (c1->tag == NOINFO || c2->tag == NOINFO) - return 0; /* one of them is not filled */ - else return exclusiveset(c1->cs, c2->cs); -} +/* }====================================================== */ -static Instruction *newcharset (lua_State *L) { - Instruction *p = newpatt(L, CHARSETINSTSIZE); - p[0].i.code = ISet; - p[0].i.offset = 0; - loopset(i, p[1].buff[i] = 0); - return p; -} - -static int set_l (lua_State *L) { - size_t l; - const char *s = luaL_checklstring(L, 1, &l); - if (l == 1) - getpatt(L, 1, NULL); /* a unit set is equivalent to a literal */ - else { - Instruction *p = newcharset(L); - while (l--) { - setchar(p[1].buff, (byte)(*s)); - s++; - } - } - return 1; -} +/* +** {====================================================== +** Code generation +** ======================================================= +*/ -static int range_l (lua_State *L) { - int arg; - int top = lua_gettop(L); - Instruction *p = newcharset(L); - for (arg = 1; arg <= top; arg++) { - int c; - size_t l; - const char *r = luaL_checklstring(L, arg, &l); - luaL_argcheck(L, l == 2, arg, "range must have two characters"); - for (c = (byte)r[0]; c <= (byte)r[1]; c++) - setchar(p[1].buff, c); +/* +** size of an instruction +*/ +int sizei (const Instruction *i) { + switch((Opcode)i->i.code) { + case ISet: case ISpan: return CHARSETINSTSIZE; + case ITestSet: return CHARSETINSTSIZE + 1; + case ITestChar: case ITestAny: case IChoice: case IJmp: + case ICall: case IOpenCall: case ICommit: case IPartialCommit: + case IBackCommit: return 2; + default: return 1; } - return 1; } -static int nter_l (lua_State *L) { - Instruction *p; - luaL_argcheck(L, !lua_isnoneornil(L, 1), 1, "non-nil value expected"); - p = newpatt(L, 1); - setinst(p, IOpenCall, value2fenv(L, 1)); - return 1; -} - - - -static int testpattern (lua_State *L, int idx) { - if (lua_touserdata(L, idx)) { /* value is a userdata? */ - if (lua_getmetatable(L, idx)) { /* does it have a metatable? */ - luaL_getmetatable(L, PATTERN_T); - if (lua_rawequal(L, -1, -2)) { /* does it have the correct mt? */ - lua_pop(L, 2); /* remove both metatables */ - return 1; - } - } - } - return 0; -} +/* +** state for the compiler +*/ +typedef struct CompileState { + Pattern *p; /* pattern being compiled */ + int ncode; /* next position in p->code to be filled */ + lua_State *L; +} CompileState; -static Instruction *fix_l (lua_State *L, int t) { - Instruction *p; - int i; - int totalsize = 2; /* include initial call and jump */ - int n = 0; /* number of rules */ - int base = lua_gettop(L); - lua_newtable(L); /* to store relative positions of each rule */ - lua_pushinteger(L, 1); /* default initial rule */ - /* collect patterns and compute sizes */ - lua_pushnil(L); - while (lua_next(L, t) != 0) { - int l; - if (lua_tonumber(L, -2) == 1 && lua_isstring(L, -1)) { - lua_replace(L, base + 2); /* use this value as initial rule */ - continue; - } - if (!testpattern(L, -1)) - luaL_error(L, "%s is not a pattern", val2str(L, -2)); - l = pattsize(L, -1) + 1; /* space for pattern + ret */ - if (totalsize >= MAXPATTSIZE - l) - luaL_error(L, "grammar too large"); - luaL_checkstack(L, LUA_MINSTACK, "grammar has too many rules"); - lua_insert(L, -2); /* put key on top */ - lua_pushvalue(L, -1); /* duplicate key (for lua_next) */ - lua_pushvalue(L, -1); /* duplicate key (to index positions table)) */ - lua_pushinteger(L, totalsize); /* position for this rule */ - lua_settable(L, base + 1); /* store key=>position in positions table */ - totalsize += l; - n++; - } - luaL_argcheck(L, n > 0, t, "empty grammar"); - p = newpatt(L, totalsize); /* create new pattern */ - p++; /* save space for call */ - setinst(p++, IJmp, totalsize - 1); /* after call, jumps to the end */ - for (i = 1; i <= n; i++) { /* copy all rules into new pattern */ - p += addpatt(L, p, base + 1 + i*2); - setinst(p++, IRet, 0); - } - p -= totalsize; /* back to first position */ - totalsize = 2; /* go through each rule's position */ - for (i = 1; i <= n; i++) { /* check all rules */ - int l = pattsize(L, base + 1 + i*2) + 1; - checkrule(L, p, totalsize, totalsize + l, base + 1, base + 2 + i*2); - totalsize += l; - } - lua_pushvalue(L, base + 2); /* get initial rule */ - lua_gettable(L, base + 1); /* get its position in postions table */ - i = lua_tonumber(L, -1); /* convert to number */ - lua_pop(L, 1); - if (i == 0) /* is it defined? */ - luaL_error(L, "initial rule not defined in given grammar"); - setinst(p, ICall, i); /* first instruction calls initial rule */ - /* correct calls */ - for (i = 0; i < totalsize; i += sizei(p + i)) { - if (p[i].i.code == IOpenCall) { - int pos = getposition(L, base + 1, p[i].i.offset); - p[i].i.code = (p[target(p, i + 1)].i.code == IRet) ? IJmp : ICall; - p[i].i.offset = pos - i; - } - } - optimizejumps(p); - lua_replace(L, t); /* put new pattern in old's position */ - lua_settop(L, base); /* remove rules and positions table */ - return p; -} +/* +** code generation is recursive; 'opt' indicates that the code is +** being generated under a 'IChoice' operator jumping to its end. +** 'tt' points to a previous test protecting this code. 'fl' is +** the follow set of the pattern. +*/ +static void codegen (CompileState *compst, TTree *tree, int opt, int tt, + const Charset *fl); -static Instruction *any (lua_State *L, int n, int extra, int *offsetp) { - int offset = offsetp ? *offsetp : 0; - Instruction *p = newpatt(L, (n - 1)/UCHAR_MAX + extra + 1); - Instruction *p1 = p + offset; - for (; n > UCHAR_MAX; n -= UCHAR_MAX) - setinstaux(p1++, IAny, 0, UCHAR_MAX); - setinstaux(p1++, IAny, 0, n); - if (offsetp) *offsetp = p1 - p; - return p; +void reallocprog (lua_State *L, Pattern *p, int nsize) { + void *ud; + lua_Alloc f = lua_getallocf(L, &ud); + void *newblock = f(ud, p->code, p->codesize * sizeof(Instruction), + nsize * sizeof(Instruction)); + if (newblock == NULL && nsize > 0) + luaL_error(L, "not enough memory"); + p->code = (Instruction *)newblock; + p->codesize = nsize; } -static Instruction *getpatt (lua_State *L, int idx, int *size) { - Instruction *p; - switch (lua_type(L, idx)) { - case LUA_TSTRING: { - size_t i, len; - const char *s = lua_tolstring(L, idx, &len); - p = newpatt(L, len); - for (i = 0; i < len; i++) - setinstaux(p + i, IChar, 0, (byte)s[i]); - lua_replace(L, idx); - break; - } - case LUA_TNUMBER: { - int n = lua_tointeger(L, idx); - if (n == 0) /* empty pattern? */ - p = newpatt(L, 0); - else if (n > 0) - p = any(L, n, 0, NULL); - else if (-n <= UCHAR_MAX) { - p = newpatt(L, 2); - setinstaux(p, IAny, 2, -n); - setinst(p + 1, IFail, 0); - } - else { - int offset = 2; /* space for ITestAny & IChoice */ - p = any(L, -n - UCHAR_MAX, 3, &offset); - setinstaux(p, IAny, offset + 1, UCHAR_MAX); - setinstaux(p + 1, IChoice, offset, UCHAR_MAX); - setinst(p + offset, IFailTwice, 0); - } - lua_replace(L, idx); - break; - } - case LUA_TBOOLEAN: { - if (lua_toboolean(L, idx)) /* true? */ - p = newpatt(L, 0); /* empty pattern (always succeeds) */ - else { - p = newpatt(L, 1); - setinst(p, IFail, 0); - } - lua_replace(L, idx); - break; - } - case LUA_TTABLE: { - p = fix_l(L, idx); - break; - } - case LUA_TFUNCTION: { - p = newpatt(L, 2); - setinstcap(p, IOpenCapture, value2fenv(L, idx), Cruntime, 0); - setinstcap(p + 1, ICloseRunTime, 0, Cclose, 0); - lua_replace(L, idx); - break; - } - default: { - p = checkpattern(L, idx); - break; - } - } - if (size) *size = pattsize(L, idx); - return p; +static int nextinstruction (CompileState *compst) { + int size = compst->p->codesize; + if (compst->ncode >= size) + reallocprog(compst->L, compst->p, size * 2); + return compst->ncode++; } -static int getpattl (lua_State *L, int idx) { - int size; - getpatt(L, idx, &size); - return size; -} +#define getinstr(cs,i) ((cs)->p->code[i]) -static int pattern_l (lua_State *L) { - lua_settop(L, 1); - getpatt(L, 1, NULL); - return 1; +static int addinstruction (CompileState *compst, Opcode op, int aux) { + int i = nextinstruction(compst); + getinstr(compst, i).i.code = op; + getinstr(compst, i).i.aux = aux; + return i; } -#define isany(p) ((p)->i.code == IAny && ((p) + 1)->i.code == IEnd) -#define isfail(p) ((p)->i.code == IFail) -#define issucc(p) ((p)->i.code == IEnd) - -static int concat_l (lua_State *L) { - /* p1; p2; */ - int l1, l2; - Instruction *p1 = getpatt(L, 1, &l1); - Instruction *p2 = getpatt(L, 2, &l2); - if (isfail(p1) || issucc(p2)) - lua_pushvalue(L, 1); /* fail * x == fail; x * true == x */ - else if (isfail(p2) || issucc(p1)) - lua_pushvalue(L, 2); /* x * fail == fail; true * x == x */ - else if (isany(p1) && isany(p2)) - any(L, p1->i.aux + p2->i.aux, 0, NULL); - else { - Instruction *op = newpatt(L, l1 + l2); - Instruction *p = op + addpatt(L, op, 1); - addpatt(L, p, 2); - optimizecaptures(op); - } - return 1; +static int addoffsetinst (CompileState *compst, Opcode op) { + int i = addinstruction(compst, op, 0); /* instruction */ + addinstruction(compst, (Opcode)0, 0); /* open space for offset */ + assert(op == ITestSet || sizei(&getinstr(compst, i)) == 2); + return i; } -static int diff_l (lua_State *L) { - int l1, l2; - Instruction *p1 = getpatt(L, 1, &l1); - Instruction *p2 = getpatt(L, 2, &l2); - CharsetTag st1, st2; - if (tocharset(p1, &st1) == ISCHARSET && tocharset(p2, &st2) == ISCHARSET) { - Instruction *p = newcharset(L); - loopset(i, p[1].buff[i] = st1.cs[i] & ~st2.cs[i]); - } - else if (isheadfail(p2)) { - Instruction *p = newpatt(L, l2 + 1 + l1); - p += addpatt(L, p, 2); - check2test(p - l2, l2 + 1); - setinst(p++, IFail, 0); - addpatt(L, p, 1); - } - else { /* !e2 . e1 */ - /* !e -> choice L1; e; failtwice; L1: ... */ - Instruction *p = newpatt(L, 1 + l2 + 1 + l1); - Instruction *pi = p; - setinst(p++, IChoice, 1 + l2 + 1); - p += addpatt(L, p, 2); - setinst(p++, IFailTwice, 0); - addpatt(L, p, 1); - optimizechoice(pi); - } - return 1; +static void setoffset (CompileState *compst, int instruction, int offset) { + getinstr(compst, instruction + 1).offset = offset; } -static int unm_l (lua_State *L) { - Instruction *p = getpatt(L, 1, NULL); - if (isfail(p)) { /* -false? */ - newpatt(L, 0); /* true */ - return 1; - } - else if (issucc(p)) { /* -true? */ - Instruction *p1 = newpatt(L, 1); /* false */ - setinst(p1, IFail, 0); - return 1; - } - else { /* -A == '' - A */ - lua_pushliteral(L, ""); - lua_insert(L, 1); - return diff_l(L); - } +/* +** Add a capture instruction: +** 'op' is the capture instruction; 'cap' the capture kind; +** 'key' the key into ktable; 'aux' is optional offset +** +*/ +static int addinstcap (CompileState *compst, Opcode op, int cap, int key, + int aux) { + int i = addinstruction(compst, op, joinkindoff(cap, aux)); + getinstr(compst, i).i.key = key; + return i; } -static int pattand_l (lua_State *L) { - int l1; - CharsetTag st1; - Instruction *p1 = getpatt(L, 1, &l1); - if (isfail(p1) || issucc(p1)) - lua_pushvalue(L, 1); /* &fail == fail; &true == true */ - else if (tocharset(p1, &st1) == ISCHARSET) { - Instruction *p = newpatt(L, l1 + 1); - copypatt(p, p1, l1); p += l1; - setinstaux(p, IBack, 0, 1); - } - else { /* Choice L1; p1; BackCommit L2; L1: Fail; L2: */ - Instruction *p = newpatt(L, 1 + l1 + 2); - setinst(p++, IChoice, 1 + l1 + 1); - p += addpatt(L, p, 1); - setinst(p++, IBackCommit, 2); - setinst(p, IFail, 0); - } - return 1; -} - +#define gethere(compst) ((compst)->ncode) -static int nocalls (const Instruction *p) { - for (; (Opcode)p->i.code != IEnd; p += sizei(p)) - if ((Opcode)p->i.code == IOpenCall) return 0; - return 1; -} +#define target(code,i) ((i) + code[i + 1].offset) -static int pattbehind (lua_State *L) { - int l1; - CharsetTag st1; - Instruction *p1 = getpatt(L, 1, &l1); - int n = luaL_optint(L, 2, 1); - luaL_argcheck(L, n <= MAXAUX, 2, "lookbehind delta too large"); - if (!nocalls(p1)) - luaL_error(L, "lookbehind pattern cannot contain non terminals"); - if (isfail(p1) || issucc(p1)) - lua_pushvalue(L, 1); /* <fail == fail; <true == true */ - else if (n == 1 && tocharset(p1, &st1) == ISCHARSET) { - Instruction *p = newpatt(L, 1 + l1); - setinstaux(p, IBack, 0, 1); p++; - copypatt(p, p1, l1); - } - else { /* Choice L1; Back; p1; BackCommit L2; L1: fail; L2: */ - Instruction *p = newpatt(L, 2 + l1 + 2); - setinst(p++, IChoice, 2 + l1 + 1); - setinstaux(p++, IBack, 0, n); - p += addpatt(L, p, 1); - setinst(p++, IBackCommit, 2); - setinst(p, IFail, 0); - } - return 1; +static void jumptothere (CompileState *compst, int instruction, int target) { + if (instruction >= 0) + setoffset(compst, instruction, target - instruction); } - -static int firstpart (Instruction *p, int l) { - if (istest(p)) { - int e = p[0].i.offset - 1; - if ((p[e].i.code == IJmp || p[e].i.code == ICommit) && - e + p[e].i.offset == l) - return e + 1; - } - else if (p[0].i.code == IChoice) { - int e = p[0].i.offset - 1; - if (p[e].i.code == ICommit && e + p[e].i.offset == l) - return e + 1; - } - return 0; +static void jumptohere (CompileState *compst, int instruction) { + jumptothere(compst, instruction, gethere(compst)); } -static Instruction *auxnew (lua_State *L, Instruction **op, int *size, - int extra) { - *op = newpatt(L, *size + extra); - jointable(L, 1); - *size += extra; - return *op + *size - extra; +/* +** Code an IChar instruction, or IAny if there is an equivalent +** test dominating it +*/ +static void codechar (CompileState *compst, int c, int tt) { + if (tt >= 0 && getinstr(compst, tt).i.code == ITestChar && + getinstr(compst, tt).i.aux == c) + addinstruction(compst, IAny, 0); + else + addinstruction(compst, IChar, c); } -static int nofail (Instruction *p, int l) { +/* +** Add a charset posfix to an instruction +*/ +static void addcharset (CompileState *compst, const byte *cs) { + int p = gethere(compst); int i; - for (i = 0; i < l; i += sizei(p + i)) { - if (!isnofail(p + i)) return 0; - } - return 1; + for (i = 0; i < (int)CHARSETINSTSIZE - 1; i++) + nextinstruction(compst); /* space for buffer */ + /* fill buffer with charset */ + loopset(j, getinstr(compst, p).buff[j] = cs[j]); } -static int interfere (Instruction *p1, int l1, CharsetTag *st2) { - if (nofail(p1, l1)) /* p1 cannot fail? */ - return 0; /* nothing can intefere with it */ - if (st2->tag == NOINFO) return 1; - assert(p1->i.offset != 0); - switch (p1->i.code) { - case IChar: return testchar(st2->cs, p1->i.aux); - case ISet: return !exclusiveset(st2->cs, (p1 + 1)->buff); - default: assert(p1->i.code == IAny); return 1; +/* +** code a char set, optimizing unit sets for IChar, "complete" +** sets for IAny, and empty sets for IFail; also use an IAny +** when instruction is dominated by an equivalent test. +*/ +static void codecharset (CompileState *compst, const byte *cs, int tt) { + int c = 0; /* (=) to avoid warnings */ + Opcode op = charsettype(cs, &c); + switch (op) { + case IChar: codechar(compst, c, tt); break; + case ISet: { /* non-trivial set? */ + if (tt >= 0 && getinstr(compst, tt).i.code == ITestSet && + cs_equal(cs, getinstr(compst, tt + 2).buff)) + addinstruction(compst, IAny, 0); + else { + addinstruction(compst, ISet, 0); + addcharset(compst, cs); + } + break; + } + default: addinstruction(compst, op, c); break; } } -static Instruction *basicUnion (lua_State *L, Instruction *p1, int l1, - int l2, int *size, CharsetTag *st2) { - Instruction *op; - CharsetTag st1; - tocharset(p1, &st1); - if (st1.tag == ISCHARSET && st2->tag == ISCHARSET) { - Instruction *p = auxnew(L, &op, size, CHARSETINSTSIZE); - setinst(p, ISet, 0); - loopset(i, p[1].buff[i] = st1.cs[i] | st2->cs[i]); - } - else if (exclusive(&st1, st2) || isheadfail(p1)) { - Instruction *p = auxnew(L, &op, size, l1 + 1 + l2); - copypatt(p, p1, l1); - check2test(p, l1 + 1); - p += l1; - setinst(p++, IJmp, l2 + 1); - addpatt(L, p, 2); - } - else { - /* choice L1; e1; commit L2; L1: e2; L2: ... */ - Instruction *p = auxnew(L, &op, size, 1 + l1 + 1 + l2); - setinst(p++, IChoice, 1 + l1 + 1); - copypatt(p, p1, l1); p += l1; - setinst(p++, ICommit, 1 + l2); - addpatt(L, p, 2); - optimizechoice(p - (1 + l1 + 1)); - } - return op; -} - - -static Instruction *separateparts (lua_State *L, Instruction *p1, int l1, - int l2, int *size, CharsetTag *st2) { - int sp = firstpart(p1, l1); - if (sp == 0) /* first part is entire p1? */ - return basicUnion(L, p1, l1, l2, size, st2); - else if ((p1 + sp - 1)->i.code == ICommit || !interfere(p1, sp, st2)) { - Instruction *p; - int init = *size; - int end = init + sp; - *size = end; - p = separateparts(L, p1 + sp, l1 - sp, l2, size, st2); - copypatt(p + init, p1, sp); - (p + end - 1)->i.offset = *size - (end - 1); - return p; - } - else { /* must change back to non-optimized choice */ - Instruction *p; - int init = *size; - int end = init + sp + 1; /* needs one extra instruction (choice) */ - int sizefirst = sizei(p1); /* size of p1's first instruction (the test) */ - *size = end; - p = separateparts(L, p1 + sp, l1 - sp, l2, size, st2); - copypatt(p + init, p1, sizefirst); /* copy the test */ - (p + init)->i.offset++; /* correct jump (because of new instruction) */ - init += sizefirst; - setinstaux(p + init, IChoice, sp - sizefirst + 1, 1); init++; - copypatt(p + init, p1 + sizefirst, sp - sizefirst - 1); - init += sp - sizefirst - 1; - setinst(p + init, ICommit, *size - (end - 1)); - return p; - } -} - - -static int union_l (lua_State *L) { - int l1, l2; - int size = 0; - Instruction *p1 = getpatt(L, 1, &l1); - Instruction *p2 = getpatt(L, 2, &l2); - CharsetTag st2; - if (isfail(p1)) /* check for simple identities */ - lua_pushvalue(L, 2); /* fail / a == a */ - else if (isfail(p2) || issucc(p1)) - lua_pushvalue(L, 1); /* a / fail == a; true / a == true */ +/* +** code a test set, optimizing unit sets for ITestChar, "complete" +** sets for ITestAny, and empty sets for IJmp (always fails). +** 'e' is true iff test should accept the empty string. (Test +** instructions in the current VM never accept the empty string.) +*/ +static int codetestset (CompileState *compst, Charset *cs, int e) { + if (e) return NOINST; /* no test */ else { - tocharset(p2, &st2); - separateparts(L, p1, l1, l2, &size, &st2); + int c = 0; + Opcode op = charsettype(cs->cs, &c); + switch (op) { + case IFail: return addoffsetinst(compst, IJmp); /* always jump */ + case IAny: return addoffsetinst(compst, ITestAny); + case IChar: { + int i = addoffsetinst(compst, ITestChar); + getinstr(compst, i).i.aux = c; + return i; + } + case ISet: { + int i = addoffsetinst(compst, ITestSet); + addcharset(compst, cs->cs); + return i; + } + default: assert(0); return 0; + } } - return 1; } -static int repeatcharset (lua_State *L, Charset cs, int l1, int n) { - /* e; ...; e; span; */ - int i; - Instruction *p = newpatt(L, n*l1 + CHARSETINSTSIZE); - for (i = 0; i < n; i++) { - p += addpatt(L, p, 1); - } - setinst(p, ISpan, 0); - loopset(k, p[1].buff[k] = cs[k]); - return 1; +/* +** Find the final destination of a sequence of jumps +*/ +static int finaltarget (Instruction *code, int i) { + while (code[i].i.code == IJmp) + i = target(code, i); + return i; } -static Instruction *repeatheadfail (lua_State *L, int l1, int n) { - /* e; ...; e; L2: e'(L1); jump L2; L1: ... */ - int i; - Instruction *p = newpatt(L, (n + 1)*l1 + 1); - Instruction *op = p; - for (i = 0; i < n; i++) { - p += addpatt(L, p, 1); - } - p += addpatt(L, p, 1); - check2test(p - l1, l1 + 1); - setinst(p, IJmp, -l1); - return op; +/* +** final label (after traversing any jumps) +*/ +static int finallabel (Instruction *code, int i) { + return finaltarget(code, target(code, i)); } -static Instruction *repeats (lua_State *L, Instruction *p1, int l1, int n) { - /* e; ...; e; choice L1; L2: e; partialcommit L2; L1: ... */ - int i; - Instruction *op = newpatt(L, (n + 1)*l1 + 2); - Instruction *p = op; - if (!verify(L, p1, p1, p1 + l1, 0, 0)) - luaL_error(L, "loop body may accept empty string"); - for (i = 0; i < n; i++) { - p += addpatt(L, p, 1); - } - setinst(p++, IChoice, 1 + l1 + 1); - p += addpatt(L, p, 1); - setinst(p, IPartialCommit, -l1); - return op; +/* +** <behind(p)> == behind n; <p> (where n = fixedlen(p)) +*/ +static void codebehind (CompileState *compst, TTree *tree) { + if (tree->u.n > 0) + addinstruction(compst, IBehind, tree->u.n); + codegen(compst, sib1(tree), 0, NOINST, fullset); } -static void optionalheadfail (lua_State *L, int l1, int n) { - Instruction *op = newpatt(L, n * l1); - Instruction *p = op; - int i; - for (i = 0; i < n; i++) { - p += addpatt(L, p, 1); - check2test(p - l1, (n - i)*l1); +/* +** Choice; optimizations: +** - when p1 is headfail +** - when first(p1) and first(p2) are disjoint; than +** a character not in first(p1) cannot go to p1, and a character +** in first(p1) cannot go to p2 (at it is not in first(p2)). +** (The optimization is not valid if p1 accepts the empty string, +** as then there is no character at all...) +** - when p2 is empty and opt is true; a IPartialCommit can resuse +** the Choice already active in the stack. +*/ +static void codechoice (CompileState *compst, TTree *p1, TTree *p2, int opt, + const Charset *fl) { + int emptyp2 = (p2->tag == TTrue); + Charset cs1, cs2; + int e1 = getfirst(p1, fullset, &cs1); + if (headfail(p1) || + (!e1 && (getfirst(p2, fl, &cs2), cs_disjoint(&cs1, &cs2)))) { + /* <p1 / p2> == test (fail(p1)) -> L1 ; p1 ; jmp L2; L1: p2; L2: */ + int test = codetestset(compst, &cs1, 0); + int jmp = NOINST; + codegen(compst, p1, 0, test, fl); + if (!emptyp2) + jmp = addoffsetinst(compst, IJmp); + jumptohere(compst, test); + codegen(compst, p2, opt, NOINST, fl); + jumptohere(compst, jmp); + } + else if (opt && emptyp2) { + /* p1? == IPartialCommit; p1 */ + jumptohere(compst, addoffsetinst(compst, IPartialCommit)); + codegen(compst, p1, 1, NOINST, fullset); + } + else { + /* <p1 / p2> == + test(fail(p1)) -> L1; choice L1; <p1>; commit L2; L1: <p2>; L2: */ + int pcommit; + int test = codetestset(compst, &cs1, e1); + int pchoice = addoffsetinst(compst, IChoice); + codegen(compst, p1, emptyp2, test, fullset); + pcommit = addoffsetinst(compst, ICommit); + jumptohere(compst, pchoice); + jumptohere(compst, test); + codegen(compst, p2, opt, NOINST, fl); + jumptohere(compst, pcommit); } } -static void optionals (lua_State *L, int l1, int n) { - /* choice L1; e; partialcommit L2; L2: ... e; L1: commit L3; L3: ... */ - int i; - Instruction *op = newpatt(L, n*(l1 + 1) + 1); - Instruction *p = op; - setinst(p++, IChoice, 1 + n*(l1 + 1)); - for (i = 0; i < n; i++) { - p += addpatt(L, p, 1); - setinst(p++, IPartialCommit, 1); +/* +** And predicate +** optimization: fixedlen(p) = n ==> <&p> == <p>; behind n +** (valid only when 'p' has no captures) +*/ +static void codeand (CompileState *compst, TTree *tree, int tt) { + int n = fixedlen(tree); + if (n >= 0 && n <= MAXBEHIND && !hascaptures(tree)) { + codegen(compst, tree, 0, tt, fullset); + if (n > 0) + addinstruction(compst, IBehind, n); + } + else { /* default: Choice L1; p1; BackCommit L2; L1: Fail; L2: */ + int pcommit; + int pchoice = addoffsetinst(compst, IChoice); + codegen(compst, tree, 0, tt, fullset); + pcommit = addoffsetinst(compst, IBackCommit); + jumptohere(compst, pchoice); + addinstruction(compst, IFail, 0); + jumptohere(compst, pcommit); } - setinst(p - 1, ICommit, 1); /* correct last commit */ - optimizechoice(op); } -static int star_l (lua_State *L) { - int l1; - int n = luaL_checkint(L, 2); - Instruction *p1 = getpatt(L, 1, &l1); - if (n >= 0) { - CharsetTag st; - Instruction *op; - if (tocharset(p1, &st) == ISCHARSET) - return repeatcharset(L, st.cs, l1, n); - if (isheadfail(p1)) - op = repeatheadfail(L, l1, n); - else - op = repeats(L, p1, l1, n); - optimizecaptures(op); - optimizejumps(op); +/* +** Captures: if pattern has fixed (and not too big) length, use +** a single IFullCapture instruction after the match; otherwise, +** enclose the pattern with OpenCapture - CloseCapture. +*/ +static void codecapture (CompileState *compst, TTree *tree, int tt, + const Charset *fl) { + int len = fixedlen(sib1(tree)); + if (len >= 0 && len <= MAXOFF && !hascaptures(sib1(tree))) { + codegen(compst, sib1(tree), 0, tt, fl); + addinstcap(compst, IFullCapture, tree->cap, tree->key, len); } else { - if (isheadfail(p1)) - optionalheadfail(L, l1, -n); - else - optionals(L, l1, -n); + addinstcap(compst, IOpenCapture, tree->cap, tree->key, 0); + codegen(compst, sib1(tree), 0, tt, fl); + addinstcap(compst, ICloseCapture, Cclose, 0, 0); } - return 1; } -static int getlabel (lua_State *L, int labelidx) { - if (labelidx == 0) return 0; - else return value2fenv(L, labelidx); +static void coderuntime (CompileState *compst, TTree *tree, int tt) { + addinstcap(compst, IOpenCapture, Cgroup, tree->key, 0); + codegen(compst, sib1(tree), 0, tt, fullset); + addinstcap(compst, ICloseRunTime, Cclose, 0, 0); } -static int capture_aux (lua_State *L, int kind, int labelidx) { - int l1, n; - Instruction *p1 = getpatt(L, 1, &l1); - int lc = skipchecks(p1, 0, &n); - if (lc == l1) { /* got whole pattern? */ - /* may use a IFullCapture instruction at its end */ - Instruction *p = newpatt(L, l1 + 1); - int label = getlabel(L, labelidx); - p += addpatt(L, p, 1); - setinstcap(p, IFullCapture, label, kind, n); +/* +** Repetion; optimizations: +** When pattern is a charset, can use special instruction ISpan. +** When pattern is head fail, or if it starts with characters that +** are disjoint from what follows the repetions, a simple test +** is enough (a fail inside the repetition would backtrack to fail +** again in the following pattern, so there is no need for a choice). +** When 'opt' is true, the repetion can reuse the Choice already +** active in the stack. +*/ +static void coderep (CompileState *compst, TTree *tree, int opt, + const Charset *fl) { + Charset st; + if (tocharset(tree, &st)) { + addinstruction(compst, ISpan, 0); + addcharset(compst, st.cs); } - else { /* must use open-close pair */ - Instruction *op = newpatt(L, 1 + l1 + 1); - Instruction *p = op; - setinstcap(p++, IOpenCapture, getlabel(L, labelidx), kind, 0); - p += addpatt(L, p, 1); - setinstcap(p, ICloseCapture, 0, Cclose, 0); - optimizecaptures(op); + else { + int e1 = getfirst(tree, fullset, &st); + if (headfail(tree) || (!e1 && cs_disjoint(&st, fl))) { + /* L1: test (fail(p1)) -> L2; <p>; jmp L1; L2: */ + int jmp; + int test = codetestset(compst, &st, 0); + codegen(compst, tree, opt, test, fullset); + jmp = addoffsetinst(compst, IJmp); + jumptohere(compst, test); + jumptothere(compst, jmp, test); + } + else { + /* test(fail(p1)) -> L2; choice L2; L1: <p>; partialcommit L1; L2: */ + /* or (if 'opt'): partialcommit L1; L1: <p>; partialcommit L1; */ + int commit, l2; + int test = codetestset(compst, &st, e1); + int pchoice = NOINST; + if (opt) + jumptohere(compst, addoffsetinst(compst, IPartialCommit)); + else + pchoice = addoffsetinst(compst, IChoice); + l2 = gethere(compst); + codegen(compst, tree, 0, NOINST, fullset); + commit = addoffsetinst(compst, IPartialCommit); + jumptothere(compst, commit, l2); + jumptohere(compst, pchoice); + jumptohere(compst, test); + } } - return 1; } -static int capture_l (lua_State *L) { return capture_aux(L, Csimple, 0); } -static int tcapture_l (lua_State *L) { return capture_aux(L, Ctable, 0); } -static int capsubst_l (lua_State *L) { return capture_aux(L, Csubst, 0); } - -static int rcapture_l (lua_State *L) { - switch (lua_type(L, 2)) { - case LUA_TFUNCTION: return capture_aux(L, Cfunction, 2); - case LUA_TTABLE: return capture_aux(L, Cquery, 2); - case LUA_TSTRING: return capture_aux(L, Cstring, 2); - default: return luaL_argerror(L, 2, "invalid replacement value"); +/* +** Not predicate; optimizations: +** In any case, if first test fails, 'not' succeeds, so it can jump to +** the end. If pattern is headfail, that is all (it cannot fail +** in other parts); this case includes 'not' of simple sets. Otherwise, +** use the default code (a choice plus a failtwice). +*/ +static void codenot (CompileState *compst, TTree *tree) { + Charset st; + int e = getfirst(tree, fullset, &st); + int test = codetestset(compst, &st, e); + if (headfail(tree)) /* test (fail(p1)) -> L1; fail; L1: */ + addinstruction(compst, IFail, 0); + else { + /* test(fail(p))-> L1; choice L1; <p>; failtwice; L1: */ + int pchoice = addoffsetinst(compst, IChoice); + codegen(compst, tree, 0, NOINST, fullset); + addinstruction(compst, IFailTwice, 0); + jumptohere(compst, pchoice); } + jumptohere(compst, test); } -static int fold_l (lua_State *L) { - luaL_checktype(L, 2, LUA_TFUNCTION); - return capture_aux(L, Cfold, 2); -} - - -static int group_l (lua_State *L) { - if (lua_isnoneornil(L, 2)) - return capture_aux(L, Cgroup, 0); - else { - luaL_checkstring(L, 2); - return capture_aux(L, Cgroup, 2); +/* +** change open calls to calls, using list 'positions' to find +** correct offsets; also optimize tail calls +*/ +static void correctcalls (CompileState *compst, int *positions, + int from, int to) { + int i; + Instruction *code = compst->p->code; + for (i = from; i < to; i += sizei(&code[i])) { + if (code[i].i.code == IOpenCall) { + int n = code[i].i.key; /* rule number */ + int rule = positions[n]; /* rule position */ + assert(rule == from || code[rule - 1].i.code == IRet); + if (code[finaltarget(code, i + 2)].i.code == IRet) /* call; ret ? */ + code[i].i.code = IJmp; /* tail call */ + else + code[i].i.code = ICall; + jumptothere(compst, i, rule); /* call jumps to respective rule */ + } } + assert(i == to); } -static int position_l (lua_State *L) { - Instruction *p = newpatt(L, 1); - setinstcap(p, IEmptyCapture, 0, Cposition, 0); - return 1; +/* +** Code for a grammar: +** call L1; jmp L2; L1: rule 1; ret; rule 2; ret; ...; L2: +*/ +static void codegrammar (CompileState *compst, TTree *grammar) { + int positions[MAXRULES]; + int rulenumber = 0; + TTree *rule; + int firstcall = addoffsetinst(compst, ICall); /* call initial rule */ + int jumptoend = addoffsetinst(compst, IJmp); /* jump to the end */ + int start = gethere(compst); /* here starts the initial rule */ + jumptohere(compst, firstcall); + for (rule = sib1(grammar); rule->tag == TRule; rule = sib2(rule)) { + positions[rulenumber++] = gethere(compst); /* save rule position */ + codegen(compst, sib1(rule), 0, NOINST, fullset); /* code rule */ + addinstruction(compst, IRet, 0); + } + assert(rule->tag == TTrue); + jumptohere(compst, jumptoend); + correctcalls(compst, positions, start, gethere(compst)); } -static int backref_l (lua_State *L) { - Instruction *p = newpatt(L, 1); - int n = getlabel(L, 1); - setinstcap(p, IEmptyCaptureIdx, n, Cbackref, 0); - return 1; +static void codecall (CompileState *compst, TTree *call) { + int c = addoffsetinst(compst, IOpenCall); /* to be corrected later */ + getinstr(compst, c).i.key = sib2(call)->cap; /* rule number */ + assert(sib2(call)->tag == TRule); } -static int argcap_l (lua_State *L) { - int n = luaL_checkint(L, 1); - Instruction *p = newpatt(L, 1); - luaL_argcheck(L, 0 < n && n <= SHRT_MAX, 1, "invalid argument index"); - setinstcap(p, IEmptyCapture, n, Carg, 0); - return 1; +/* +** Code first child of a sequence +** (second child is called in-place to allow tail call) +** Return 'tt' for second child +*/ +static int codeseq1 (CompileState *compst, TTree *p1, TTree *p2, + int tt, const Charset *fl) { + if (needfollow(p1)) { + Charset fl1; + getfirst(p2, fl, &fl1); /* p1 follow is p2 first */ + codegen(compst, p1, 0, tt, &fl1); + } + else /* use 'fullset' as follow */ + codegen(compst, p1, 0, tt, fullset); + if (fixedlen(p1) != 0) /* can 'p1' consume anything? */ + return NOINST; /* invalidate test */ + else return tt; /* else 'tt' still protects sib2 */ } -static int matchtime_l (lua_State *L) { - int l1 = getpattl(L, 1); - Instruction *op = newpatt(L, 1 + l1 + 1); - Instruction *p = op; - luaL_checktype(L, 2, LUA_TFUNCTION); - setinstcap(p++, IOpenCapture, value2fenv(L, 2), Cruntime, 0); - p += addpatt(L, p, 1); - setinstcap(p, ICloseRunTime, 0, Cclose, 0); - optimizecaptures(op); - return 1; +/* +** Main code-generation function: dispatch to auxiliar functions +** according to kind of tree +*/ +static void codegen (CompileState *compst, TTree *tree, int opt, int tt, + const Charset *fl) { + tailcall: + switch (tree->tag) { + case TChar: codechar(compst, tree->u.n, tt); break; + case TAny: addinstruction(compst, IAny, 0); break; + case TSet: codecharset(compst, treebuffer(tree), tt); break; + case TTrue: break; + case TFalse: addinstruction(compst, IFail, 0); break; + case TChoice: codechoice(compst, sib1(tree), sib2(tree), opt, fl); break; + case TRep: coderep(compst, sib1(tree), opt, fl); break; + case TBehind: codebehind(compst, tree); break; + case TNot: codenot(compst, sib1(tree)); break; + case TAnd: codeand(compst, sib1(tree), tt); break; + case TCapture: codecapture(compst, tree, tt, fl); break; + case TRunTime: coderuntime(compst, tree, tt); break; + case TGrammar: codegrammar(compst, tree); break; + case TCall: codecall(compst, tree); break; + case TSeq: { + tt = codeseq1(compst, sib1(tree), sib2(tree), tt, fl); /* code 'p1' */ + /* codegen(compst, p2, opt, tt, fl); */ + tree = sib2(tree); goto tailcall; + } + default: assert(0); + } } -static int capconst_l (lua_State *L) { - int i, j; - int n = lua_gettop(L); - Instruction *p = newpatt(L, n > 1 ? n + 2 : n); - lua_createtable(L, n, 0); /* new environment for the new pattern */ - if (n > 1) setinstcap(p++, IOpenCapture, 0, Cgroup, 0); - for (i = j = 1; i <= n; i++) { - if (lua_isnil(L, i)) - setinstcap(p++, IEmptyCaptureIdx, 0, Cconst, 0); - else { - setinstcap(p++, IEmptyCaptureIdx, j, Cconst, 0); - lua_pushvalue(L, i); - lua_rawseti(L, -2, j++); +/* +** Optimize jumps and other jump-like instructions. +** * Update labels of instructions with labels to their final +** destinations (e.g., choice L1; ... L1: jmp L2: becomes +** choice L2) +** * Jumps to other instructions that do jumps become those +** instructions (e.g., jump to return becomes a return; jump +** to commit becomes a commit) +*/ +static void peephole (CompileState *compst) { + Instruction *code = compst->p->code; + int i; + for (i = 0; i < compst->ncode; i += sizei(&code[i])) { + switch (code[i].i.code) { + case IChoice: case ICall: case ICommit: case IPartialCommit: + case IBackCommit: case ITestChar: case ITestSet: + case ITestAny: { /* instructions with labels */ + jumptothere(compst, i, finallabel(code, i)); /* optimize label */ + break; + } + case IJmp: { + int ft = finaltarget(code, i); + switch (code[ft].i.code) { /* jumping to what? */ + case IRet: case IFail: case IFailTwice: + case IEnd: { /* instructions with unconditional implicit jumps */ + code[i] = code[ft]; /* jump becomes that instruction */ + code[i + 1].i.code = IAny; /* 'no-op' for target position */ + break; + } + case ICommit: case IPartialCommit: + case IBackCommit: { /* inst. with unconditional explicit jumps */ + int fft = finallabel(code, ft); + code[i] = code[ft]; /* jump becomes that instruction... */ + jumptothere(compst, i, fft); /* but must correct its offset */ + i--; /* reoptimize its label */ + break; + } + default: { + jumptothere(compst, i, ft); /* optimize label */ + break; + } + } + break; + } + default: break; } } - if (n > 1) setinstcap(p++, ICloseCapture, 0, Cclose, 0); - lua_setfenv(L, -2); /* set environment */ - return 1; + assert(code[i - 1].i.code == IEnd); } -/* }====================================================== */ - - /* -** {====================================================== -** User-Defined Patterns -** ======================================================= +** Compile a pattern */ - -static void l_newpf (lua_State *L, PattFunc f, const void *ud, size_t l) { - int n = instsize(l) + 1; - Instruction *p = newpatt(L, n); - if (n > MAXAUX) luaL_error(L, "pattern data too long"); - p[0].i.code = IFunc; - p[0].i.aux = n - 2; - p[0].i.offset = 0; - p[1].f = f; - memcpy(p[2].buff, ud, l); +Instruction *compile (lua_State *L, Pattern *p) { + CompileState compst; + compst.p = p; compst.ncode = 0; compst.L = L; + reallocprog(L, p, 2); /* minimum initial size */ + codegen(&compst, p->tree, 0, NOINST, fullset); + addinstruction(&compst, IEnd, 0); + reallocprog(L, p, compst.ncode); /* set final size */ + peephole(&compst); + return p->code; } + /* }====================================================== */ /* -** {====================================================== -** Captures -** ======================================================= +** $Id: lpcap.c,v 1.4 2013/03/21 20:25:12 roberto Exp $ +** Copyright 2007, Lua.org & PUC-Rio (see 'lpeg.html' for license) */ +/* #include "lua.h" */ +/* #include "lauxlib.h" */ -typedef struct CapState { - Capture *cap; /* current capture */ - Capture *ocap; /* (original) capture list */ - lua_State *L; - int ptop; /* index of last argument to 'match' */ - const char *s; /* original string */ - int valuecached; /* value stored in cache slot */ -} CapState; +/* #include "lpcap.h" */ +/* #include "lptypes.h" */ #define captype(cap) ((cap)->kind) @@ -1849,84 +1589,114 @@ typedef struct CapState { #define isfullcap(cap) ((cap)->siz != 0) -#define getfromenv(cs,v) lua_rawgeti((cs)->L, penvidx((cs)->ptop), v) -#define pushluaval(cs) getfromenv(cs, (cs)->cap->idx) - -#define pushsubject(cs, c) lua_pushlstring((cs)->L, (c)->s, (c)->siz - 1) +#define getfromktable(cs,v) lua_rawgeti((cs)->L, ktableidx((cs)->ptop), v) +#define pushluaval(cs) getfromktable(cs, (cs)->cap->idx) -#define updatecache(cs,v) { if ((v) != (cs)->valuecached) updatecache_(cs,v); } -static void updatecache_ (CapState *cs, int v) { - getfromenv(cs, v); - lua_replace(cs->L, subscache(cs)); - cs->valuecached = v; +/* +** Put at the cache for Lua values the value indexed by 'v' in ktable +** of the running pattern (if it is not there yet); returns its index. +*/ +static int updatecache (CapState *cs, int v) { + int idx = cs->ptop + 1; /* stack index of cache for Lua values */ + if (v != cs->valuecached) { /* not there? */ + getfromktable(cs, v); /* get value from 'ktable' */ + lua_replace(cs->L, idx); /* put it at reserved stack position */ + cs->valuecached = v; /* keep track of what is there */ + } + return idx; } static int pushcapture (CapState *cs); +/* +** Goes back in a list of captures looking for an open capture +** corresponding to a close +*/ static Capture *findopen (Capture *cap) { - int n = 0; + int n = 0; /* number of closes waiting an open */ for (;;) { cap--; - if (isclosecap(cap)) n++; + if (isclosecap(cap)) n++; /* one more open to skip */ else if (!isfullcap(cap)) if (n-- == 0) return cap; } } -static Capture *nextcap (Capture *cap) { - if (isfullcap(cap)) return cap + 1; - else { - int n = 0; - for (;;) { +/* +** Go to the next capture +*/ +static void nextcap (CapState *cs) { + Capture *cap = cs->cap; + if (!isfullcap(cap)) { /* not a single capture? */ + int n = 0; /* number of opens waiting a close */ + for (;;) { /* look for corresponding close */ cap++; if (isclosecap(cap)) { - if (n-- == 0) return cap + 1; + if (n-- == 0) break; } else if (!isfullcap(cap)) n++; } } + cs->cap = cap + 1; /* + 1 to skip last close (or entire single capture) */ } -static int pushallvalues (CapState *cs, int addextra) { +/* +** Push on the Lua stack all values generated by nested captures inside +** the current capture. Returns number of values pushed. 'addextra' +** makes it push the entire match after all captured values. The +** entire match is pushed also if there are no other nested values, +** so the function never returns zero. +*/ +static int pushnestedvalues (CapState *cs, int addextra) { Capture *co = cs->cap; - int n = 0; - if (isfullcap(cs->cap++)) { - pushsubject(cs, co); /* push whole match */ - return 1; + if (isfullcap(cs->cap++)) { /* no nested captures? */ + lua_pushlstring(cs->L, co->s, co->siz - 1); /* push whole match */ + return 1; /* that is it */ } - while (!isclosecap(cs->cap)) - n += pushcapture(cs); - if (addextra || n == 0) { /* need extra? */ - lua_pushlstring(cs->L, co->s, cs->cap->s - co->s); /* push whole match */ - n++; + else { + int n = 0; + while (!isclosecap(cs->cap)) /* repeat for all nested patterns */ + n += pushcapture(cs); + if (addextra || n == 0) { /* need extra? */ + lua_pushlstring(cs->L, co->s, cs->cap->s - co->s); /* push whole match */ + n++; + } + cs->cap++; /* skip close entry */ + return n; } - cs->cap++; /* skip close entry */ - return n; } +/* +** Push only the first value generated by nested captures +*/ +static void pushonenestedvalue (CapState *cs) { + int n = pushnestedvalues(cs, 0); + if (n > 1) + lua_pop(cs->L, n - 1); /* pop extra values */ +} + + +/* +** Try to find a named group capture with the name given at the top of +** the stack; goes backward from 'cap'. +*/ static Capture *findback (CapState *cs, Capture *cap) { lua_State *L = cs->L; - for (;;) { - if (cap == cs->ocap) { /* not found */ - const char *s = lua_tostring(L, -1); - if (s == NULL) s = lua_pushfstring(L, "(a %s)", luaL_typename(L, -1)); - luaL_error(L, "back reference '%s' not found", s); - } - cap--; + while (cap-- > cs->ocap) { /* repeat until end of list */ if (isclosecap(cap)) - cap = findopen(cap); + cap = findopen(cap); /* skip nested captures */ else if (!isfullcap(cap)) continue; /* opening an enclosing capture: skip and get previous */ if (captype(cap) == Cgroup) { - getfromenv(cs, cap->idx); /* get group name */ + getfromktable(cs, cap->idx); /* get group name */ if (lua_equal(L, -2, -1)) { /* right group? */ lua_pop(L, 2); /* remove reference name and group name */ return cap; @@ -1934,20 +1704,29 @@ static Capture *findback (CapState *cs, Capture *cap) { else lua_pop(L, 1); /* remove group name */ } } + luaL_error(L, "back reference '%s' not found", lua_tostring(L, -1)); + return NULL; /* to avoid warnings */ } +/* +** Back-reference capture. Return number of values pushed. +*/ static int backrefcap (CapState *cs) { int n; Capture *curr = cs->cap; pushluaval(cs); /* reference name */ - cs->cap = findback(cs, curr); - n = pushallvalues(cs, 0); + cs->cap = findback(cs, curr); /* find corresponding group */ + n = pushnestedvalues(cs, 0); /* push group's values */ cs->cap = curr + 1; return n; } +/* +** Table capture: creates a new table and populates it with nested +** captures. +*/ static int tablecap (CapState *cs) { lua_State *L = cs->L; int n = 0; @@ -1956,182 +1735,249 @@ static int tablecap (CapState *cs) { return 1; /* table is empty */ while (!isclosecap(cs->cap)) { if (captype(cs->cap) == Cgroup && cs->cap->idx != 0) { /* named group? */ - int k; pushluaval(cs); /* push group name */ - k = pushallvalues(cs, 0); - if (k == 0) { /* no value? */ - lua_pop(L, 1); /* remove group name */ - continue; /* and go on */ - } - else if (k > 1) - lua_pop(L, k - 1); /* keep just one value */ + pushonenestedvalue(cs); lua_settable(L, -3); } - else { + else { /* not a named group */ int i; int k = pushcapture(cs); - for (i = k; i > 0; i--) + for (i = k; i > 0; i--) /* store all values into table */ lua_rawseti(L, -(i + 1), n + i); n += k; } } cs->cap++; /* skip close entry */ - return 1; + return 1; /* number of values pushed (only the table) */ } +/* +** Table-query capture +*/ static int querycap (CapState *cs) { int idx = cs->cap->idx; - int n = pushallvalues(cs, 0); - if (n > 1) /* extra captures? */ - lua_pop(cs->L, n - 1); /* throw them away */ - updatecache(cs, idx); - lua_gettable(cs->L, subscache(cs)); + pushonenestedvalue(cs); /* get nested capture */ + lua_gettable(cs->L, updatecache(cs, idx)); /* query cap. value at table */ if (!lua_isnil(cs->L, -1)) return 1; - else { - lua_pop(cs->L, 1); /* remove value */ + else { /* no value */ + lua_pop(cs->L, 1); /* remove nil */ return 0; } } +/* +** Fold capture +*/ static int foldcap (CapState *cs) { int n; lua_State *L = cs->L; int idx = cs->cap->idx; - if (isfullcap(cs->cap++) || isclosecap(cs->cap) || (n = pushcapture(cs)) == 0) + if (isfullcap(cs->cap++) || /* no nested captures? */ + isclosecap(cs->cap) || /* no nested captures (large subject)? */ + (n = pushcapture(cs)) == 0) /* nested captures with no values? */ return luaL_error(L, "no initial value for fold capture"); if (n > 1) - lua_pop(L, n - 1); /* leave only one result */ + lua_pop(L, n - 1); /* leave only one result for accumulator */ while (!isclosecap(cs->cap)) { - updatecache(cs, idx); - lua_pushvalue(L, subscache(cs)); /* get folding function */ + lua_pushvalue(L, updatecache(cs, idx)); /* get folding function */ lua_insert(L, -2); /* put it before accumulator */ - n = pushcapture(cs); /* get other captures */ + n = pushcapture(cs); /* get next capture's values */ lua_call(L, n + 1, 1); /* call folding function */ } cs->cap++; /* skip close entry */ - return 1; + return 1; /* only accumulator left on the stack */ } +/* +** Function capture +*/ static int functioncap (CapState *cs) { int n; int top = lua_gettop(cs->L); - pushluaval(cs); - n = pushallvalues(cs, 0); - lua_call(cs->L, n, LUA_MULTRET); - return lua_gettop(cs->L) - top; + pushluaval(cs); /* push function */ + n = pushnestedvalues(cs, 0); /* push nested captures */ + lua_call(cs->L, n, LUA_MULTRET); /* call function */ + return lua_gettop(cs->L) - top; /* return function's results */ } -static int runtimecap (lua_State *L, Capture *close, Capture *ocap, - const char *o, const char *s, int ptop) { - CapState cs; - int n; +/* +** Select capture +*/ +static int numcap (CapState *cs) { + int idx = cs->cap->idx; /* value to select */ + if (idx == 0) { /* no values? */ + nextcap(cs); /* skip entire capture */ + return 0; /* no value produced */ + } + else { + int n = pushnestedvalues(cs, 0); + if (n < idx) /* invalid index? */ + return luaL_error(cs->L, "no capture '%d'", idx); + else { + lua_pushvalue(cs->L, -(n - idx + 1)); /* get selected capture */ + lua_replace(cs->L, -(n + 1)); /* put it in place of 1st capture */ + lua_pop(cs->L, n - 1); /* remove other captures */ + return 1; + } + } +} + + +/* +** Return the stack index of the first runtime capture in the given +** list of captures (or zero if no runtime captures) +*/ +int finddyncap (Capture *cap, Capture *last) { + for (; cap < last; cap++) { + if (cap->kind == Cruntime) + return cap->idx; /* stack position of first capture */ + } + return 0; /* no dynamic captures in this segment */ +} + + +/* +** Calls a runtime capture. Returns number of captures removed by +** the call, including the initial Cgroup. (Captures to be added are +** on the Lua stack.) +*/ +int runtimecap (CapState *cs, Capture *close, const char *s, int *rem) { + int n, id; + lua_State *L = cs->L; + int otop = lua_gettop(L); Capture *open = findopen(close); - assert(captype(open) == Cruntime); - close->kind = Cclose; + assert(captype(open) == Cgroup); + id = finddyncap(open, close); /* get first dynamic capture argument */ + close->kind = Cclose; /* closes the group */ close->s = s; - cs.ocap = ocap; cs.cap = open; cs.L = L; - cs.s = o; cs.valuecached = 0; cs.ptop = ptop; + cs->cap = open; cs->valuecached = 0; /* prepare capture state */ luaL_checkstack(L, 4, "too many runtime captures"); - pushluaval(&cs); + pushluaval(cs); /* push function to be called */ lua_pushvalue(L, SUBJIDX); /* push original subject */ - lua_pushinteger(L, s - o + 1); /* current position */ - n = pushallvalues(&cs, 0); - lua_call(L, n + 2, LUA_MULTRET); - return close - open; + lua_pushinteger(L, s - cs->s + 1); /* push current position */ + n = pushnestedvalues(cs, 0); /* push nested captures */ + lua_call(L, n + 2, LUA_MULTRET); /* call dynamic function */ + if (id > 0) { /* are there old dynamic captures to be removed? */ + int i; + for (i = id; i <= otop; i++) + lua_remove(L, id); /* remove old dynamic captures */ + *rem = otop - id + 1; /* total number of dynamic captures removed */ + } + else + *rem = 0; /* no dynamic captures removed */ + return close - open; /* number of captures of all kinds removed */ } - +/* +** Auxiliary structure for substitution and string captures: keep +** information about nested captures for future use, avoiding to push +** string results into Lua +*/ typedef struct StrAux { - int isstring; + int isstring; /* whether capture is a string */ union { - Capture *cp; - struct { - const char *s; - const char *e; + Capture *cp; /* if not a string, respective capture */ + struct { /* if it is a string... */ + const char *s; /* ... starts here */ + const char *e; /* ... ends here */ } s; } u; } StrAux; #define MAXSTRCAPS 10 +/* +** Collect values from current capture into array 'cps'. Current +** capture must be Cstring (first call) or Csimple (recursive calls). +** (In first call, fills %0 with whole match for Cstring.) +** Returns number of elements in the array that were filled. +*/ static int getstrcaps (CapState *cs, StrAux *cps, int n) { int k = n++; - cps[k].isstring = 1; - cps[k].u.s.s = cs->cap->s; - if (!isfullcap(cs->cap++)) { - while (!isclosecap(cs->cap)) { + cps[k].isstring = 1; /* get string value */ + cps[k].u.s.s = cs->cap->s; /* starts here */ + if (!isfullcap(cs->cap++)) { /* nested captures? */ + while (!isclosecap(cs->cap)) { /* traverse them */ if (n >= MAXSTRCAPS) /* too many captures? */ - cs->cap = nextcap(cs->cap); /* skip it */ - else if (captype(cs->cap) == Csimple) - n = getstrcaps(cs, cps, n); + nextcap(cs); /* skip extra captures (will not need them) */ + else if (captype(cs->cap) == Csimple) /* string? */ + n = getstrcaps(cs, cps, n); /* put info. into array */ else { - cps[n].isstring = 0; - cps[n].u.cp = cs->cap; - cs->cap = nextcap(cs->cap); + cps[n].isstring = 0; /* not a string */ + cps[n].u.cp = cs->cap; /* keep original capture */ + nextcap(cs); n++; } } cs->cap++; /* skip close */ } - cps[k].u.s.e = closeaddr(cs->cap - 1); + cps[k].u.s.e = closeaddr(cs->cap - 1); /* ends here */ return n; } /* -** add next capture (which should be a string) to buffer +** add next capture value (which should be a string) to buffer 'b' */ static int addonestring (luaL_Buffer *b, CapState *cs, const char *what); +/* +** String capture: add result to buffer 'b' (instead of pushing +** it into the stack) +*/ static void stringcap (luaL_Buffer *b, CapState *cs) { StrAux cps[MAXSTRCAPS]; int n; size_t len, i; - const char *c; - updatecache(cs, cs->cap->idx); - c = lua_tolstring(cs->L, subscache(cs), &len); - n = getstrcaps(cs, cps, 0) - 1; - for (i = 0; i < len; i++) { - if (c[i] != '%' || c[++i] < '0' || c[i] > '9') - luaL_addchar(b, c[i]); + const char *fmt; /* format string */ + fmt = lua_tolstring(cs->L, updatecache(cs, cs->cap->idx), &len); + n = getstrcaps(cs, cps, 0) - 1; /* collect nested captures */ + for (i = 0; i < len; i++) { /* traverse them */ + if (fmt[i] != '%') /* not an escape? */ + luaL_addchar(b, fmt[i]); /* add it to buffer */ + else if (fmt[++i] < '0' || fmt[i] > '9') /* not followed by a digit? */ + luaL_addchar(b, fmt[i]); /* add to buffer */ else { - int l = c[i] - '0'; + int l = fmt[i] - '0'; /* capture index */ if (l > n) luaL_error(cs->L, "invalid capture index (%d)", l); else if (cps[l].isstring) luaL_addlstring(b, cps[l].u.s.s, cps[l].u.s.e - cps[l].u.s.s); else { Capture *curr = cs->cap; - cs->cap = cps[l].u.cp; - if (addonestring(b, cs, "capture") == 0) + cs->cap = cps[l].u.cp; /* go back to evaluate that nested capture */ + if (!addonestring(b, cs, "capture")) luaL_error(cs->L, "no values in capture index %d", l); - cs->cap = curr; + cs->cap = curr; /* continue from where it stopped */ } } } } +/* +** Substitution capture: add result to buffer 'b' +*/ static void substcap (luaL_Buffer *b, CapState *cs) { const char *curr = cs->cap->s; if (isfullcap(cs->cap)) /* no nested captures? */ luaL_addlstring(b, curr, cs->cap->siz - 1); /* keep original text */ else { - cs->cap++; - while (!isclosecap(cs->cap)) { + cs->cap++; /* skip open entry */ + while (!isclosecap(cs->cap)) { /* traverse nested captures */ const char *next = cs->cap->s; luaL_addlstring(b, curr, next - curr); /* add text up to capture */ - if (addonestring(b, cs, "replacement") == 0) /* no capture value? */ - curr = next; /* keep original text in final result */ - else + if (addonestring(b, cs, "replacement")) curr = closeaddr(cs->cap - 1); /* continue after match */ + else /* no capture value */ + curr = next; /* keep original text in final result */ } luaL_addlstring(b, curr, cs->cap->s - curr); /* add last piece of text */ } @@ -2139,6 +1985,10 @@ static void substcap (luaL_Buffer *b, CapState *cs) { } +/* +** Evaluates a capture and adds its first value to buffer 'b'; returns +** whether there was a value +*/ static int addonestring (luaL_Buffer *b, CapState *cs, const char *what) { switch (captype(cs->cap)) { case Cstring: @@ -2162,11 +2012,16 @@ static int addonestring (luaL_Buffer *b, CapState *cs, const char *what) { } +/* +** Push all values of the current capture into the stack; returns +** number of values pushed +*/ static int pushcapture (CapState *cs) { - luaL_checkstack(cs->L, 4, "too many captures"); + lua_State *L = cs->L; + luaL_checkstack(L, 4, "too many captures"); switch (captype(cs->cap)) { case Cposition: { - lua_pushinteger(cs->L, cs->cap->s - cs->s + 1); + lua_pushinteger(L, cs->cap->s - cs->s + 1); cs->cap++; return 1; } @@ -2178,50 +2033,45 @@ static int pushcapture (CapState *cs) { case Carg: { int arg = (cs->cap++)->idx; if (arg + FIXEDARGS > cs->ptop) - return luaL_error(cs->L, "reference to absent argument #%d", arg); - lua_pushvalue(cs->L, arg + FIXEDARGS); + return luaL_error(L, "reference to absent argument #%d", arg); + lua_pushvalue(L, arg + FIXEDARGS); return 1; } case Csimple: { - int k = pushallvalues(cs, 1); - if (k > 1) - lua_insert(cs->L, -k); /* whole match is first result */ + int k = pushnestedvalues(cs, 1); + lua_insert(L, -k); /* make whole match be first result */ return k; } case Cruntime: { - int n = 0; - while (!isclosecap(cs->cap++)) { - luaL_checkstack(cs->L, 4, "too many captures"); - lua_pushvalue(cs->L, (cs->cap - 1)->idx); - n++; - } - return n; + lua_pushvalue(L, (cs->cap++)->idx); /* value is in the stack */ + return 1; } case Cstring: { luaL_Buffer b; - luaL_buffinit(cs->L, &b); + luaL_buffinit(L, &b); stringcap(&b, cs); luaL_pushresult(&b); return 1; } case Csubst: { luaL_Buffer b; - luaL_buffinit(cs->L, &b); + luaL_buffinit(L, &b); substcap(&b, cs); luaL_pushresult(&b); return 1; } case Cgroup: { if (cs->cap->idx == 0) /* anonymous group? */ - return pushallvalues(cs, 0); /* add all nested values */ + return pushnestedvalues(cs, 0); /* add all nested values */ else { /* named group: add no values */ - cs->cap = nextcap(cs->cap); /* skip capture */ + nextcap(cs); /* skip capture */ return 0; } } case Cbackref: return backrefcap(cs); case Ctable: return tablecap(cs); case Cfunction: return functioncap(cs); + case Cnum: return numcap(cs); case Cquery: return querycap(cs); case Cfold: return foldcap(cs); default: assert(0); return 0; @@ -2229,7 +2079,15 @@ static int pushcapture (CapState *cs) { } -static int getcaptures (lua_State *L, const char *s, const char *r, int ptop) { +/* +** Prepare a CapState structure and traverse the entire list of +** captures in the stack pushing its results. 's' is the subject +** string, 'r' is the final position of the match, and 'ptop' +** the index in the stack where some useful values were pushed. +** Returns the number of results pushed. (If the list produces no +** results, push the final position of the match.) +*/ +int getcaptures (lua_State *L, const char *s, const char *r, int ptop) { Capture *capture = (Capture *)lua_touserdata(L, caplistidx(ptop)); int n = 0; if (!isclosecap(capture)) { /* is there any capture? */ @@ -2247,16 +2105,1137 @@ static int getcaptures (lua_State *L, const char *s, const char *r, int ptop) { return n; } + +/* +** $Id: lptree.c,v 1.10 2013/04/12 16:30:33 roberto Exp $ +** Copyright 2013, Lua.org & PUC-Rio (see 'lpeg.html' for license) +*/ + +/* #include <ctype.h> */ +/* #include <limits.h> */ +/* #include <string.h> */ + + +/* #include "lua.h" */ +/* #include "lauxlib.h" */ + +/* #include "lptypes.h" */ +/* #include "lpcap.h" */ +/* #include "lpcode.h" */ +/* #include "lpprint.h" */ +/* #include "lptree.h" */ + + +/* number of siblings for each tree */ +const byte numsiblings[] = { + 0, 0, 0, /* char, set, any */ + 0, 0, /* true, false */ + 1, /* rep */ + 2, 2, /* seq, choice */ + 1, 1, /* not, and */ + 0, 0, 2, 1, /* call, opencall, rule, grammar */ + 1, /* behind */ + 1, 1 /* capture, runtime capture */ +}; + + +static TTree *newgrammar (lua_State *L, int arg); + + +/* +** returns a reasonable name for value at index 'idx' on the stack +*/ +static const char *val2str (lua_State *L, int idx) { + const char *k = lua_tostring(L, idx); + if (k != NULL) + return lua_pushfstring(L, "%s", k); + else + return lua_pushfstring(L, "(a %s)", luaL_typename(L, idx)); +} + + +/* +** Fix a TOpenCall into a TCall node, using table 'postable' to +** translate a key to its rule address in the tree. Raises an +** error if key does not exist. +*/ +static void fixonecall (lua_State *L, int postable, TTree *g, TTree *t) { + int n; + lua_rawgeti(L, -1, t->key); /* get rule's name */ + lua_gettable(L, postable); /* query name in position table */ + n = lua_tonumber(L, -1); /* get (absolute) position */ + lua_pop(L, 1); /* remove position */ + if (n == 0) { /* no position? */ + lua_rawgeti(L, -1, t->key); /* get rule's name again */ + luaL_error(L, "rule '%s' undefined in given grammar", val2str(L, -1)); + } + t->tag = TCall; + t->u.ps = n - (t - g); /* position relative to node */ + assert(sib2(t)->tag == TRule); + sib2(t)->key = t->key; +} + + +/* +** Transform left associative constructions into right +** associative ones, for sequence and choice; that is: +** (t11 + t12) + t2 => t11 + (t12 + t2) +** (t11 * t12) * t2 => t11 * (t12 * t2) +** (that is, Op (Op t11 t12) t2 => Op t11 (Op t12 t2)) +*/ +static void correctassociativity (TTree *tree) { + TTree *t1 = sib1(tree); + assert(tree->tag == TChoice || tree->tag == TSeq); + while (t1->tag == tree->tag) { + int n1size = tree->u.ps - 1; /* t1 == Op t11 t12 */ + int n11size = t1->u.ps - 1; + int n12size = n1size - n11size - 1; + memmove(sib1(tree), sib1(t1), n11size * sizeof(TTree)); /* move t11 */ + tree->u.ps = n11size + 1; + sib2(tree)->tag = tree->tag; + sib2(tree)->u.ps = n12size + 1; + } +} + + +/* +** Make final adjustments in a tree. Fix open calls in tree 't', +** making them refer to their respective rules or raising appropriate +** errors (if not inside a grammar). Correct associativity of associative +** constructions (making them right associative). Assume that tree's +** ktable is at the top of the stack (for error messages). +*/ +static void finalfix (lua_State *L, int postable, TTree *g, TTree *t) { + tailcall: + switch (t->tag) { + case TGrammar: /* subgrammars were already fixed */ + return; + case TOpenCall: { + if (g != NULL) /* inside a grammar? */ + fixonecall(L, postable, g, t); + else { /* open call outside grammar */ + lua_rawgeti(L, -1, t->key); + luaL_error(L, "rule '%s' used outside a grammar", val2str(L, -1)); + } + break; + } + case TSeq: case TChoice: + correctassociativity(t); + break; + } + switch (numsiblings[t->tag]) { + case 1: /* finalfix(L, postable, g, sib1(t)); */ + t = sib1(t); goto tailcall; + case 2: + finalfix(L, postable, g, sib1(t)); + t = sib2(t); goto tailcall; /* finalfix(L, postable, g, sib2(t)); */ + default: assert(numsiblings[t->tag] == 0); break; + } +} + + +/* +** {====================================================== +** Tree generation +** ======================================================= +*/ + +/* +** In 5.2, could use 'luaL_testudata'... +*/ +static int testpattern (lua_State *L, int idx) { + if (lua_touserdata(L, idx)) { /* value is a userdata? */ + if (lua_getmetatable(L, idx)) { /* does it have a metatable? */ + luaL_getmetatable(L, PATTERN_T); + if (lua_rawequal(L, -1, -2)) { /* does it have the correct mt? */ + lua_pop(L, 2); /* remove both metatables */ + return 1; + } + } + } + return 0; +} + + +static Pattern *getpattern (lua_State *L, int idx) { + return (Pattern *)luaL_checkudata(L, idx, PATTERN_T); +} + + +static int getsize (lua_State *L, int idx) { + return (lua_objlen(L, idx) - sizeof(Pattern)) / sizeof(TTree) + 1; +} + + +static TTree *gettree (lua_State *L, int idx, int *len) { + Pattern *p = getpattern(L, idx); + if (len) + *len = getsize(L, idx); + return p->tree; +} + + +/* +** create a pattern +*/ +static TTree *newtree (lua_State *L, int len) { + size_t size = (len - 1) * sizeof(TTree) + sizeof(Pattern); + Pattern *p = (Pattern *)lua_newuserdata(L, size); + luaL_getmetatable(L, PATTERN_T); + lua_setmetatable(L, -2); + p->code = NULL; p->codesize = 0; + return p->tree; +} + + +static TTree *newleaf (lua_State *L, int tag) { + TTree *tree = newtree(L, 1); + tree->tag = tag; + return tree; +} + + +static TTree *newcharset (lua_State *L) { + TTree *tree = newtree(L, bytes2slots(CHARSETSIZE) + 1); + tree->tag = TSet; + loopset(i, treebuffer(tree)[i] = 0); + return tree; +} + + +/* +** add to tree a sequence where first sibling is 'sib' (with size +** 'sibsize'); returns position for second sibling +*/ +static TTree *seqaux (TTree *tree, TTree *sib, int sibsize) { + tree->tag = TSeq; tree->u.ps = sibsize + 1; + memcpy(sib1(tree), sib, sibsize * sizeof(TTree)); + return sib2(tree); +} + + +/* +** Add element 'idx' to 'ktable' of pattern at the top of the stack; +** create new 'ktable' if necessary. Return index of new element. +*/ +static int addtoktable (lua_State *L, int idx) { + if (idx == 0 || lua_isnil(L, idx)) /* no actual value to insert? */ + return 0; + else { + int n; + lua_getfenv(L, -1); /* get ktable from pattern */ + n = lua_objlen(L, -1); + if (n == 0) { /* is it empty/non-existent? */ + lua_pop(L, 1); /* remove it */ + lua_createtable(L, 1, 0); /* create a fresh table */ + } + lua_pushvalue(L, idx); /* element to be added */ + lua_rawseti(L, -2, n + 1); + lua_setfenv(L, -2); /* set it as ktable for pattern */ + return n + 1; + } +} + + +/* +** Build a sequence of 'n' nodes, each with tag 'tag' and 'u.n' got +** from the array 's' (or 0 if array is NULL). (TSeq is binary, so it +** must build a sequence of sequence of sequence...) +*/ +static void fillseq (TTree *tree, int tag, int n, const char *s) { + int i; + for (i = 0; i < n - 1; i++) { /* initial n-1 copies of Seq tag; Seq ... */ + tree->tag = TSeq; tree->u.ps = 2; + sib1(tree)->tag = tag; + sib1(tree)->u.n = s ? (byte)s[i] : 0; + tree = sib2(tree); + } + tree->tag = tag; /* last one does not need TSeq */ + tree->u.n = s ? (byte)s[i] : 0; +} + + +/* +** Numbers as patterns: +** 0 == true (always match); n == TAny repeated 'n' times; +** -n == not (TAny repeated 'n' times) +*/ +static TTree *numtree (lua_State *L, int n) { + if (n == 0) + return newleaf(L, TTrue); + else { + TTree *tree, *nd; + if (n > 0) + tree = nd = newtree(L, 2 * n - 1); + else { /* negative: code it as !(-n) */ + n = -n; + tree = newtree(L, 2 * n); + tree->tag = TNot; + nd = sib1(tree); + } + fillseq(nd, TAny, n, NULL); /* sequence of 'n' any's */ + return tree; + } +} + + +/* +** Convert value at index 'idx' to a pattern +*/ +static TTree *getpatt (lua_State *L, int idx, int *len) { + TTree *tree; + switch (lua_type(L, idx)) { + case LUA_TSTRING: { + size_t slen; + const char *s = lua_tolstring(L, idx, &slen); /* get string */ + if (slen == 0) /* empty? */ + tree = newleaf(L, TTrue); /* always match */ + else { + tree = newtree(L, 2 * (slen - 1) + 1); + fillseq(tree, TChar, slen, s); /* sequence of 'slen' chars */ + } + break; + } + case LUA_TNUMBER: { + int n = lua_tointeger(L, idx); + tree = numtree(L, n); + break; + } + case LUA_TBOOLEAN: { + tree = (lua_toboolean(L, idx) ? newleaf(L, TTrue) : newleaf(L, TFalse)); + break; + } + case LUA_TTABLE: { + tree = newgrammar(L, idx); + break; + } + case LUA_TFUNCTION: { + tree = newtree(L, 2); + tree->tag = TRunTime; + tree->key = addtoktable(L, idx); + sib1(tree)->tag = TTrue; + break; + } + default: { + return gettree(L, idx, len); + } + } + lua_replace(L, idx); /* put new tree into 'idx' slot */ + if (len) + *len = getsize(L, idx); + return tree; +} + + +/* +** Return the number of elements in the ktable of pattern at 'idx'. +** In Lua 5.2, default "environment" for patterns is nil, not +** a table. Treat it as an empty table. In Lua 5.1, assumes that +** the environment has no numeric indices (len == 0) +*/ +static int ktablelen (lua_State *L, int idx) { + if (!lua_istable(L, idx)) return 0; + else return lua_objlen(L, idx); +} + + +/* +** Concatentate the contents of table 'idx1' into table 'idx2'. +** (Assume that both indices are negative.) +** Return the original length of table 'idx2' +*/ +static int concattable (lua_State *L, int idx1, int idx2) { + int i; + int n1 = ktablelen(L, idx1); + int n2 = ktablelen(L, idx2); + if (n1 == 0) return 0; /* nothing to correct */ + for (i = 1; i <= n1; i++) { + lua_rawgeti(L, idx1, i); + lua_rawseti(L, idx2 - 1, n2 + i); /* correct 'idx2' */ + } + return n2; +} + + +/* +** Make a merge of ktables from p1 and p2 the ktable for the new +** pattern at the top of the stack. +*/ +static int joinktables (lua_State *L, int p1, int p2) { + int n1, n2; + lua_getfenv(L, p1); /* get ktables */ + lua_getfenv(L, p2); + n1 = ktablelen(L, -2); + n2 = ktablelen(L, -1); + if (n1 == 0 && n2 == 0) { /* are both tables empty? */ + lua_pop(L, 2); /* nothing to be done; pop tables */ + return 0; /* nothing to correct */ + } + if (n2 == 0 || lua_equal(L, -2, -1)) { /* second table is empty or equal? */ + lua_pop(L, 1); /* pop 2nd table */ + lua_setfenv(L, -2); /* set 1st ktable into new pattern */ + return 0; /* nothing to correct */ + } + if (n1 == 0) { /* first table is empty? */ + lua_setfenv(L, -3); /* set 2nd table into new pattern */ + lua_pop(L, 1); /* pop 1st table */ + return 0; /* nothing to correct */ + } + else { + lua_createtable(L, n1 + n2, 0); /* create ktable for new pattern */ + /* stack: new p; ktable p1; ktable p2; new ktable */ + concattable(L, -3, -1); /* from p1 into new ktable */ + concattable(L, -2, -1); /* from p2 into new ktable */ + lua_setfenv(L, -4); /* new ktable becomes p env */ + lua_pop(L, 2); /* pop other ktables */ + return n1; /* correction for indices from p2 */ + } +} + + +static void correctkeys (TTree *tree, int n) { + if (n == 0) return; /* no correction? */ + tailcall: + switch (tree->tag) { + case TOpenCall: case TCall: case TRunTime: case TRule: { + if (tree->key > 0) + tree->key += n; + break; + } + case TCapture: { + if (tree->key > 0 && tree->cap != Carg && tree->cap != Cnum) + tree->key += n; + break; + } + default: break; + } + switch (numsiblings[tree->tag]) { + case 1: /* correctkeys(sib1(tree), n); */ + tree = sib1(tree); goto tailcall; + case 2: + correctkeys(sib1(tree), n); + tree = sib2(tree); goto tailcall; /* correctkeys(sib2(tree), n); */ + default: assert(numsiblings[tree->tag] == 0); break; + } +} + + +/* +** copy 'ktable' of element 'idx' to new tree (on top of stack) +*/ +static void copyktable (lua_State *L, int idx) { + lua_getfenv(L, idx); + lua_setfenv(L, -2); +} + + +/* +** merge 'ktable' from rule at stack index 'idx' into 'ktable' +** from tree at the top of the stack, and correct corresponding +** tree. +*/ +static void mergektable (lua_State *L, int idx, TTree *rule) { + int n; + lua_getfenv(L, -1); /* get ktables */ + lua_getfenv(L, idx); + n = concattable(L, -1, -2); + lua_pop(L, 2); /* remove both ktables */ + correctkeys(rule, n); +} + + +/* +** create a new tree, whith a new root and one sibling. +** Sibling must be on the Lua stack, at index 1. +*/ +static TTree *newroot1sib (lua_State *L, int tag) { + int s1; + TTree *tree1 = getpatt(L, 1, &s1); + TTree *tree = newtree(L, 1 + s1); /* create new tree */ + tree->tag = tag; + memcpy(sib1(tree), tree1, s1 * sizeof(TTree)); + copyktable(L, 1); + return tree; +} + + +/* +** create a new tree, whith a new root and 2 siblings. +** Siblings must be on the Lua stack, first one at index 1. +*/ +static TTree *newroot2sib (lua_State *L, int tag) { + int s1, s2; + TTree *tree1 = getpatt(L, 1, &s1); + TTree *tree2 = getpatt(L, 2, &s2); + TTree *tree = newtree(L, 1 + s1 + s2); /* create new tree */ + tree->tag = tag; + tree->u.ps = 1 + s1; + memcpy(sib1(tree), tree1, s1 * sizeof(TTree)); + memcpy(sib2(tree), tree2, s2 * sizeof(TTree)); + correctkeys(sib2(tree), joinktables(L, 1, 2)); + return tree; +} + + +static int lp_P (lua_State *L) { + luaL_checkany(L, 1); + getpatt(L, 1, NULL); + lua_settop(L, 1); + return 1; +} + + +/* +** sequence operator; optimizations: +** false x => false, x true => x, true x => x +** (cannot do x . false => false because x may have runtime captures) +*/ +static int lp_seq (lua_State *L) { + TTree *tree1 = getpatt(L, 1, NULL); + TTree *tree2 = getpatt(L, 2, NULL); + if (tree1->tag == TFalse || tree2->tag == TTrue) + lua_pushvalue(L, 1); /* false . x == false, x . true = x */ + else if (tree1->tag == TTrue) + lua_pushvalue(L, 2); /* true . x = x */ + else + newroot2sib(L, TSeq); + return 1; +} + + +/* +** choice operator; optimizations: +** charset / charset => charset +** true / x => true, x / false => x, false / x => x +** (x / true is not equivalent to true) +*/ +static int lp_choice (lua_State *L) { + Charset st1, st2; + TTree *t1 = getpatt(L, 1, NULL); + TTree *t2 = getpatt(L, 2, NULL); + if (tocharset(t1, &st1) && tocharset(t2, &st2)) { + TTree *t = newcharset(L); + loopset(i, treebuffer(t)[i] = st1.cs[i] | st2.cs[i]); + } + else if (nofail(t1) || t2->tag == TFalse) + lua_pushvalue(L, 1); /* true / x => true, x / false => x */ + else if (t1->tag == TFalse) + lua_pushvalue(L, 2); /* false / x => x */ + else + newroot2sib(L, TChoice); + return 1; +} + + +/* +** p^n +*/ +static int lp_star (lua_State *L) { + int size1; + int n = luaL_checkint(L, 2); + TTree *tree1 = gettree(L, 1, &size1); + if (n >= 0) { /* seq tree1 (seq tree1 ... (seq tree1 (rep tree1))) */ + TTree *tree = newtree(L, (n + 1) * (size1 + 1)); + if (nullable(tree1)) + luaL_error(L, "loop body may accept empty string"); + while (n--) /* repeat 'n' times */ + tree = seqaux(tree, tree1, size1); + tree->tag = TRep; + memcpy(sib1(tree), tree1, size1 * sizeof(TTree)); + } + else { /* choice (seq tree1 ... choice tree1 true ...) true */ + TTree *tree; + n = -n; + /* size = (choice + seq + tree1 + true) * n, but the last has no seq */ + tree = newtree(L, n * (size1 + 3) - 1); + for (; n > 1; n--) { /* repeat (n - 1) times */ + tree->tag = TChoice; tree->u.ps = n * (size1 + 3) - 2; + sib2(tree)->tag = TTrue; + tree = sib1(tree); + tree = seqaux(tree, tree1, size1); + } + tree->tag = TChoice; tree->u.ps = size1 + 1; + sib2(tree)->tag = TTrue; + memcpy(sib1(tree), tree1, size1 * sizeof(TTree)); + } + copyktable(L, 1); + return 1; +} + + +/* +** #p == &p +*/ +static int lp_and (lua_State *L) { + newroot1sib(L, TAnd); + return 1; +} + + +/* +** -p == !p +*/ +static int lp_not (lua_State *L) { + newroot1sib(L, TNot); + return 1; +} + + +/* +** [t1 - t2] == Seq (Not t2) t1 +** If t1 and t2 are charsets, make their difference. +*/ +static int lp_sub (lua_State *L) { + Charset st1, st2; + int s1, s2; + TTree *t1 = getpatt(L, 1, &s1); + TTree *t2 = getpatt(L, 2, &s2); + if (tocharset(t1, &st1) && tocharset(t2, &st2)) { + TTree *t = newcharset(L); + loopset(i, treebuffer(t)[i] = st1.cs[i] & ~st2.cs[i]); + } + else { + TTree *tree = newtree(L, 2 + s1 + s2); + tree->tag = TSeq; /* sequence of... */ + tree->u.ps = 2 + s2; + sib1(tree)->tag = TNot; /* ...not... */ + memcpy(sib1(sib1(tree)), t2, s2 * sizeof(TTree)); /* ...t2 */ + memcpy(sib2(tree), t1, s1 * sizeof(TTree)); /* ... and t1 */ + correctkeys(sib1(tree), joinktables(L, 1, 2)); + } + return 1; +} + + +static int lp_set (lua_State *L) { + size_t l; + const char *s = luaL_checklstring(L, 1, &l); + TTree *tree = newcharset(L); + while (l--) { + setchar(treebuffer(tree), (byte)(*s)); + s++; + } + return 1; +} + + +static int lp_range (lua_State *L) { + int arg; + int top = lua_gettop(L); + TTree *tree = newcharset(L); + for (arg = 1; arg <= top; arg++) { + int c; + size_t l; + const char *r = luaL_checklstring(L, arg, &l); + luaL_argcheck(L, l == 2, arg, "range must have two characters"); + for (c = (byte)r[0]; c <= (byte)r[1]; c++) + setchar(treebuffer(tree), c); + } + return 1; +} + + +/* +** Look-behind predicate +*/ +static int lp_behind (lua_State *L) { + TTree *tree; + TTree *tree1 = getpatt(L, 1, NULL); + int n = fixedlen(tree1); + luaL_argcheck(L, !hascaptures(tree1), 1, "pattern have captures"); + luaL_argcheck(L, n > 0, 1, "pattern may not have fixed length"); + luaL_argcheck(L, n <= MAXBEHIND, 1, "pattern too long to look behind"); + tree = newroot1sib(L, TBehind); + tree->u.n = n; + return 1; +} + + +/* +** Create a non-terminal +*/ +static int lp_V (lua_State *L) { + TTree *tree = newleaf(L, TOpenCall); + luaL_argcheck(L, !lua_isnoneornil(L, 1), 1, "non-nil value expected"); + tree->key = addtoktable(L, 1); + return 1; +} + + +/* +** Create a tree for a non-empty capture, with a body and +** optionally with an associated Lua value (at index 'labelidx' in the +** stack) +*/ +static int capture_aux (lua_State *L, int cap, int labelidx) { + TTree *tree = newroot1sib(L, TCapture); + tree->cap = cap; + tree->key = addtoktable(L, labelidx); + return 1; +} + + +/* +** Fill a tree with an empty capture, using an empty (TTrue) sibling. +*/ +static TTree *auxemptycap (lua_State *L, TTree *tree, int cap, int idx) { + tree->tag = TCapture; + tree->cap = cap; + tree->key = addtoktable(L, idx); + sib1(tree)->tag = TTrue; + return tree; +} + + +/* +** Create a tree for an empty capture +*/ +static TTree *newemptycap (lua_State *L, int cap, int idx) { + return auxemptycap(L, newtree(L, 2), cap, idx); +} + + +/* +** Captures with syntax p / v +** (function capture, query capture, string capture, or number capture) +*/ +static int lp_divcapture (lua_State *L) { + switch (lua_type(L, 2)) { + case LUA_TFUNCTION: return capture_aux(L, Cfunction, 2); + case LUA_TTABLE: return capture_aux(L, Cquery, 2); + case LUA_TSTRING: return capture_aux(L, Cstring, 2); + case LUA_TNUMBER: { + int n = lua_tointeger(L, 2); + TTree *tree = newroot1sib(L, TCapture); + luaL_argcheck(L, 0 <= n && n <= SHRT_MAX, 1, "invalid number"); + tree->cap = Cnum; + tree->key = n; + return 1; + } + default: return luaL_argerror(L, 2, "invalid replacement value"); + } +} + + +static int lp_substcapture (lua_State *L) { + return capture_aux(L, Csubst, 0); +} + + +static int lp_tablecapture (lua_State *L) { + return capture_aux(L, Ctable, 0); +} + + +static int lp_groupcapture (lua_State *L) { + if (lua_isnoneornil(L, 2)) + return capture_aux(L, Cgroup, 0); + else { + luaL_checkstring(L, 2); + return capture_aux(L, Cgroup, 2); + } +} + + +static int lp_foldcapture (lua_State *L) { + luaL_checktype(L, 2, LUA_TFUNCTION); + return capture_aux(L, Cfold, 2); +} + + +static int lp_simplecapture (lua_State *L) { + return capture_aux(L, Csimple, 0); +} + + +static int lp_poscapture (lua_State *L) { + newemptycap(L, Cposition, 0); + return 1; +} + + +static int lp_argcapture (lua_State *L) { + int n = luaL_checkint(L, 1); + TTree *tree = newemptycap(L, Carg, 0); + tree->key = n; + luaL_argcheck(L, 0 < n && n <= SHRT_MAX, 1, "invalid argument index"); + return 1; +} + + +static int lp_backref (lua_State *L) { + luaL_checkstring(L, 1); + newemptycap(L, Cbackref, 1); + return 1; +} + + +/* +** Constant capture +*/ +static int lp_constcapture (lua_State *L) { + int i; + int n = lua_gettop(L); /* number of values */ + if (n == 0) /* no values? */ + newleaf(L, TTrue); /* no capture */ + else if (n == 1) + newemptycap(L, Cconst, 1); /* single constant capture */ + else { /* create a group capture with all values */ + TTree *tree = newtree(L, 1 + 3 * (n - 1) + 2); + tree->tag = TCapture; + tree->cap = Cgroup; + tree->key = 0; + tree = sib1(tree); + for (i = 1; i <= n - 1; i++) { + tree->tag = TSeq; + tree->u.ps = 3; /* skip TCapture and its sibling */ + auxemptycap(L, sib1(tree), Cconst, i); + tree = sib2(tree); + } + auxemptycap(L, tree, Cconst, i); + } + return 1; +} + + +static int lp_matchtime (lua_State *L) { + TTree *tree; + luaL_checktype(L, 2, LUA_TFUNCTION); + tree = newroot1sib(L, TRunTime); + tree->key = addtoktable(L, 2); + return 1; +} + /* }====================================================== */ -static int version_l (lua_State *L) { +/* +** {====================================================== +** Grammar - Tree generation +** ======================================================= +*/ + +/* +** push on the stack the index and the pattern for the +** initial rule of grammar at index 'arg' in the stack; +** also add that index into position table. +*/ +static void getfirstrule (lua_State *L, int arg, int postab) { + lua_rawgeti(L, arg, 1); /* access first element */ + if (lua_isstring(L, -1)) { /* is it the name of initial rule? */ + lua_pushvalue(L, -1); /* duplicate it to use as key */ + lua_gettable(L, arg); /* get associated rule */ + } + else { + lua_pushinteger(L, 1); /* key for initial rule */ + lua_insert(L, -2); /* put it before rule */ + } + if (!testpattern(L, -1)) { /* initial rule not a pattern? */ + if (lua_isnil(L, -1)) + luaL_error(L, "grammar has no initial rule"); + else + luaL_error(L, "initial rule '%s' is not a pattern", lua_tostring(L, -2)); + } + lua_pushvalue(L, -2); /* push key */ + lua_pushinteger(L, 1); /* push rule position (after TGrammar) */ + lua_settable(L, postab); /* insert pair at position table */ +} + +/* +** traverse grammar at index 'arg', pushing all its keys and patterns +** into the stack. Create a new table (before all pairs key-pattern) to +** collect all keys and their associated positions in the final tree +** (the "position table"). +** Return the number of rules and (in 'totalsize') the total size +** for the new tree. +*/ +static int collectrules (lua_State *L, int arg, int *totalsize) { + int n = 1; /* to count number of rules */ + int postab = lua_gettop(L) + 1; /* index of position table */ + int size; /* accumulator for total size */ + lua_newtable(L); /* create position table */ + getfirstrule(L, arg, postab); + size = 2 + getsize(L, postab + 2); /* TGrammar + TRule + rule */ + lua_pushnil(L); /* prepare to traverse grammar table */ + while (lua_next(L, arg) != 0) { + if (lua_tonumber(L, -2) == 1 || + lua_equal(L, -2, postab + 1)) { /* initial rule? */ + lua_pop(L, 1); /* remove value (keep key for lua_next) */ + continue; + } + if (!testpattern(L, -1)) /* value is not a pattern? */ + luaL_error(L, "rule '%s' is not a pattern", val2str(L, -2)); + luaL_checkstack(L, LUA_MINSTACK, "grammar has too many rules"); + lua_pushvalue(L, -2); /* push key (to insert into position table) */ + lua_pushinteger(L, size); + lua_settable(L, postab); + size += 1 + getsize(L, -1); /* update size */ + lua_pushvalue(L, -2); /* push key (for next lua_next) */ + n++; + } + *totalsize = size + 1; /* TTrue to finish list of rules */ + return n; +} + + +static void buildgrammar (lua_State *L, TTree *grammar, int frule, int n) { + int i; + TTree *nd = sib1(grammar); /* auxiliary pointer to traverse the tree */ + for (i = 0; i < n; i++) { /* add each rule into new tree */ + int ridx = frule + 2*i + 1; /* index of i-th rule */ + int rulesize; + TTree *rn = gettree(L, ridx, &rulesize); + nd->tag = TRule; + nd->key = 0; + nd->cap = i; /* rule number */ + nd->u.ps = rulesize + 1; /* point to next rule */ + memcpy(sib1(nd), rn, rulesize * sizeof(TTree)); /* copy rule */ + mergektable(L, ridx, sib1(nd)); /* merge its ktable into new one */ + nd = sib2(nd); /* move to next rule */ + } + nd->tag = TTrue; /* finish list of rules */ +} + + +/* +** Check whether a tree has potential infinite loops +*/ +static int checkloops (TTree *tree) { + tailcall: + if (tree->tag == TRep && nullable(sib1(tree))) + return 1; + else if (tree->tag == TGrammar) + return 0; /* sub-grammars already checked */ + else { + switch (numsiblings[tree->tag]) { + case 1: /* return checkloops(sib1(tree)); */ + tree = sib1(tree); goto tailcall; + case 2: + if (checkloops(sib1(tree))) return 1; + /* else return checkloops(sib2(tree)); */ + tree = sib2(tree); goto tailcall; + default: assert(numsiblings[tree->tag] == 0); return 0; + } + } +} + + +static int verifyerror (lua_State *L, int *passed, int npassed) { + int i, j; + for (i = npassed - 1; i >= 0; i--) { /* search for a repetition */ + for (j = i - 1; j >= 0; j--) { + if (passed[i] == passed[j]) { + lua_rawgeti(L, -1, passed[i]); /* get rule's key */ + return luaL_error(L, "rule '%s' may be left recursive", val2str(L, -1)); + } + } + } + return luaL_error(L, "too many left calls in grammar"); +} + + +/* +** Check whether a rule can be left recursive; raise an error in that +** case; otherwise return 1 iff pattern is nullable. Assume ktable at +** the top of the stack. +*/ +static int verifyrule (lua_State *L, TTree *tree, int *passed, int npassed, + int nullable) { + tailcall: + switch (tree->tag) { + case TChar: case TSet: case TAny: + case TFalse: + return nullable; /* cannot pass from here */ + case TTrue: + case TBehind: /* look-behind cannot have calls */ + return 1; + case TNot: case TAnd: case TRep: + /* return verifyrule(L, sib1(tree), passed, npassed, 1); */ + tree = sib1(tree); nullable = 1; goto tailcall; + case TCapture: case TRunTime: + /* return verifyrule(L, sib1(tree), passed, npassed); */ + tree = sib1(tree); goto tailcall; + case TCall: + /* return verifyrule(L, sib2(tree), passed, npassed); */ + tree = sib2(tree); goto tailcall; + case TSeq: /* only check 2nd child if first is nullable */ + if (!verifyrule(L, sib1(tree), passed, npassed, 0)) + return nullable; + /* else return verifyrule(L, sib2(tree), passed, npassed); */ + tree = sib2(tree); goto tailcall; + case TChoice: /* must check both children */ + nullable = verifyrule(L, sib1(tree), passed, npassed, nullable); + /* return verifyrule(L, sib2(tree), passed, npassed, nullable); */ + tree = sib2(tree); goto tailcall; + case TRule: + if (npassed >= MAXRULES) + return verifyerror(L, passed, npassed); + else { + passed[npassed++] = tree->key; + /* return verifyrule(L, sib1(tree), passed, npassed); */ + tree = sib1(tree); goto tailcall; + } + case TGrammar: + return nullable(tree); /* sub-grammar cannot be left recursive */ + default: assert(0); return 0; + } +} + + +static void verifygrammar (lua_State *L, TTree *grammar) { + int passed[MAXRULES]; + TTree *rule; + /* check left-recursive rules */ + for (rule = sib1(grammar); rule->tag == TRule; rule = sib2(rule)) { + if (rule->key == 0) continue; /* unused rule */ + verifyrule(L, sib1(rule), passed, 0, 0); + } + assert(rule->tag == TTrue); + /* check infinite loops inside rules */ + for (rule = sib1(grammar); rule->tag == TRule; rule = sib2(rule)) { + if (rule->key == 0) continue; /* unused rule */ + if (checkloops(sib1(rule))) { + lua_rawgeti(L, -1, rule->key); /* get rule's key */ + luaL_error(L, "empty loop in rule '%s'", val2str(L, -1)); + } + } + assert(rule->tag == TTrue); +} + + +/* +** Give a name for the initial rule if it is not referenced +*/ +static void initialrulename (lua_State *L, TTree *grammar, int frule) { + if (sib1(grammar)->key == 0) { /* initial rule is not referenced? */ + int n = lua_objlen(L, -1) + 1; /* index for name */ + lua_pushvalue(L, frule); /* rule's name */ + lua_rawseti(L, -2, n); /* ktable was on the top of the stack */ + sib1(grammar)->key = n; + } +} + + +static TTree *newgrammar (lua_State *L, int arg) { + int treesize; + int frule = lua_gettop(L) + 2; /* position of first rule's key */ + int n = collectrules(L, arg, &treesize); + TTree *g = newtree(L, treesize); + luaL_argcheck(L, n <= MAXRULES, arg, "grammar has too many rules"); + g->tag = TGrammar; g->u.n = n; + lua_newtable(L); /* create 'ktable' */ + lua_setfenv(L, -2); + buildgrammar(L, g, frule, n); + lua_getfenv(L, -1); /* get 'ktable' for new tree */ + finalfix(L, frule - 1, g, sib1(g)); + initialrulename(L, g, frule); + verifygrammar(L, g); + lua_pop(L, 1); /* remove 'ktable' */ + lua_insert(L, -(n * 2 + 2)); /* move new table to proper position */ + lua_pop(L, n * 2 + 1); /* remove position table + rule pairs */ + return g; /* new table at the top of the stack */ +} + +/* }====================================================== */ + + +static Instruction *prepcompile (lua_State *L, Pattern *p, int idx) { + lua_getfenv(L, idx); /* push 'ktable' (may be used by 'finalfix') */ + finalfix(L, 0, NULL, p->tree); + lua_pop(L, 1); /* remove 'ktable' */ + return compile(L, p); +} + + +static int lp_printtree (lua_State *L) { + TTree *tree = getpatt(L, 1, NULL); + int c = lua_toboolean(L, 2); + if (c) { + lua_getfenv(L, 1); /* push 'ktable' (may be used by 'finalfix') */ + finalfix(L, 0, NULL, tree); + lua_pop(L, 1); /* remove 'ktable' */ + } + printktable(L, 1); + printtree(tree, 0); + return 0; +} + + +static int lp_printcode (lua_State *L) { + Pattern *p = getpattern(L, 1); + printktable(L, 1); + if (p->code == NULL) /* not compiled yet? */ + prepcompile(L, p, 1); + printpatt(p->code, p->codesize); + return 0; +} + + +/* +** Get the initial position for the match, interpreting negative +** values from the end of the subject +*/ +static size_t initposition (lua_State *L, size_t len) { + lua_Integer ii = luaL_optinteger(L, 3, 1); + if (ii > 0) { /* positive index? */ + if ((size_t)ii <= len) /* inside the string? */ + return (size_t)ii - 1; /* return it (corrected to 0-base) */ + else return len; /* crop at the end */ + } + else { /* negative index */ + if ((size_t)(-ii) <= len) /* inside the string? */ + return len - ((size_t)(-ii)); /* return position from the end */ + else return 0; /* crop at the beginning */ + } +} + + +/* +** Main match function +*/ +static int lp_match (lua_State *L) { + Capture capture[INITCAPSIZE]; + const char *r; + size_t l; + Pattern *p = (getpatt(L, 1, NULL), getpattern(L, 1)); + Instruction *code = (p->code != NULL) ? p->code : prepcompile(L, p, 1); + const char *s = luaL_checklstring(L, SUBJIDX, &l); + size_t i = initposition(L, l); + int ptop = lua_gettop(L); + lua_pushnil(L); /* initialize subscache */ + lua_pushlightuserdata(L, capture); /* initialize caplistidx */ + lua_getfenv(L, 1); /* initialize penvidx */ + r = match(L, s, s + i, s + l, code, capture, ptop); + if (r == NULL) { + lua_pushnil(L); + return 1; + } + return getcaptures(L, s, r, ptop); +} + + + +/* +** {====================================================== +** Library creation and functions not related to matching +** ======================================================= +*/ + +static int lp_setmax (lua_State *L) { + luaL_optinteger(L, 1, -1); + lua_settop(L, 1); + lua_setfield(L, LUA_REGISTRYINDEX, MAXSTACKIDX); + return 0; +} + + +static int lp_version (lua_State *L) { lua_pushstring(L, VERSION); return 1; } -static int type_l (lua_State *L) { +static int lp_type (lua_State *L) { if (testpattern(L, 1)) lua_pushliteral(L, "pattern"); else @@ -2265,16 +3244,24 @@ static int type_l (lua_State *L) { } +int lp_gc (lua_State *L) { + Pattern *p = getpattern(L, 1); + if (p->codesize > 0) + reallocprog(L, p, 0); + return 0; +} + + static void createcat (lua_State *L, const char *catname, int (catf) (int)) { - Instruction *p = newcharset(L); + TTree *t = newcharset(L); int i; - for (i = 0; i < CHAR_MAX; i++) - if (catf(i)) setchar(p[1].buff, i); + for (i = 0; i <= UCHAR_MAX; i++) + if (catf(i)) setchar(treebuffer(t), i); lua_setfield(L, -2, catname); } -static int locale_l (lua_State *L) { +static int lp_locale (lua_State *L) { if (lua_isnoneornil(L, 1)) { lua_settop(L, 0); lua_createtable(L, 0, 12); @@ -2298,108 +3285,56 @@ static int locale_l (lua_State *L) { } -static int setmax (lua_State *L) { - luaL_optinteger(L, 1, -1); - lua_settop(L, 1); - lua_setfield(L, LUA_REGISTRYINDEX, MAXSTACKIDX); - return 0; -} - - -static int printpat_l (lua_State *L) { - Instruction *p = getpatt(L, 1, NULL); - int n, i; - lua_getfenv(L, 1); - n = ktablelen(L, -1); - printf("["); - for (i = 1; i <= n; i++) { - printf("%d = ", i); - lua_rawgeti(L, -1, i); - if (lua_isstring(L, -1)) - printf("%s ", lua_tostring(L, -1)); - else - printf("%s ", lua_typename(L, lua_type(L, -1))); - lua_pop(L, 1); - } - printf("]\n"); - printpatt(p); - return 0; -} - - -static int matchl (lua_State *L) { - Capture capture[INITCAPSIZE]; - const char *r; - size_t l; - Instruction *p = getpatt(L, 1, NULL); - const char *s = luaL_checklstring(L, SUBJIDX, &l); - int ptop = lua_gettop(L); - lua_Integer ii = luaL_optinteger(L, 3, 1); - size_t i = (ii > 0) ? - (((size_t)ii <= l) ? (size_t)ii - 1 : l) : - (((size_t)-ii <= l) ? l - ((size_t)-ii) : 0); - lua_pushnil(L); /* subscache */ - lua_pushlightuserdata(L, capture); /* caplistidx */ - lua_getfenv(L, 1); /* penvidx */ - r = match(L, s, s + i, s + l, p, capture, ptop); - if (r == NULL) { - lua_pushnil(L); - return 1; - } - return getcaptures(L, s, r, ptop); -} - - static struct luaL_Reg pattreg[] = { - {"match", matchl}, - {"print", printpat_l}, - {"locale", locale_l}, - {"setmaxstack", setmax}, - {"B", pattbehind}, - {"C", capture_l}, - {"Cf", fold_l}, - {"Cc", capconst_l}, - {"Cg", group_l}, - {"Cp", position_l}, - {"Cb", backref_l}, - {"Carg", argcap_l}, - {"Cmt", matchtime_l}, - {"Cs", capsubst_l}, - {"Ct", tcapture_l}, - {"P", pattern_l}, - {"R", range_l}, - {"S", set_l}, - {"V", nter_l}, - {"type", type_l}, - {"version", version_l}, + {"ptree", lp_printtree}, + {"pcode", lp_printcode}, + {"match", lp_match}, + {"B", lp_behind}, + {"V", lp_V}, + {"C", lp_simplecapture}, + {"Cc", lp_constcapture}, + {"Cmt", lp_matchtime}, + {"Cb", lp_backref}, + {"Carg", lp_argcapture}, + {"Cp", lp_poscapture}, + {"Cs", lp_substcapture}, + {"Ct", lp_tablecapture}, + {"Cf", lp_foldcapture}, + {"Cg", lp_groupcapture}, + {"P", lp_P}, + {"S", lp_set}, + {"R", lp_range}, + {"locale", lp_locale}, + {"version", lp_version}, + {"setmaxstack", lp_setmax}, + {"type", lp_type}, {NULL, NULL} }; -static struct luaL_Reg metapattreg[] = { - {"__add", union_l}, - {"__pow", star_l}, - {"__sub", diff_l}, - {"__mul", concat_l}, - {"__div", rcapture_l}, - {"__unm", unm_l}, - {"__len", pattand_l}, +static struct luaL_Reg metareg[] = { + {"__mul", lp_seq}, + {"__add", lp_choice}, + {"__pow", lp_star}, + {"__gc", lp_gc}, + {"__len", lp_and}, + {"__div", lp_divcapture}, + {"__unm", lp_not}, + {"__sub", lp_sub}, {NULL, NULL} }; int luaopen_lpeg (lua_State *L); int luaopen_lpeg (lua_State *L) { - lua_pushcfunction(L, (lua_CFunction)&l_newpf); /* new-pattern function */ - lua_setfield(L, LUA_REGISTRYINDEX, KEYNEWPATT); /* register it */ luaL_newmetatable(L, PATTERN_T); - lua_pushnumber(L, MAXBACK); + lua_pushnumber(L, MAXBACK); /* initialize maximum backtracking */ lua_setfield(L, LUA_REGISTRYINDEX, MAXSTACKIDX); - luaL_register(L, NULL, metapattreg); + luaL_register(L, NULL, metareg); luaL_register(L, "lpeg", pattreg); - lua_pushliteral(L, "__index"); - lua_pushvalue(L, -2); - lua_settable(L, -4); + lua_pushvalue(L, -1); + lua_setfield(L, -3, "__index"); return 1; } +/* }====================================================== */ diff --git a/Build/source/texk/web2c/luatexdir/luapeg/lpeg.h b/Build/source/texk/web2c/luatexdir/luapeg/lpeg.h index 13d7acefd39..456e8277c7d 100644 --- a/Build/source/texk/web2c/luatexdir/luapeg/lpeg.h +++ b/Build/source/texk/web2c/luatexdir/luapeg/lpeg.h @@ -1,38 +1,403 @@ /* -** $Id: lpeg.h,v 1.1 2009/12/23 16:15:36 roberto Exp $ +** $Id: lptypes.h,v 1.8 2013/04/12 16:26:38 roberto Exp $ ** LPeg - PEG pattern matching for Lua -** Copyright 2009, Lua.org & PUC-Rio (see 'lpeg.html' for license) +** Copyright 2007, Lua.org & PUC-Rio (see 'lpeg.html' for license) ** written by Roberto Ierusalimschy */ -#ifndef lpeg_h -#define lpeg_h +#if !defined(lptypes_h) +#define lptypes_h -#include "lua.h" +#if !defined(LPEG_DEBUG) +#define NDEBUG +#endif + +#include <assert.h> +#include <limits.h> +#include <ctype.h> +#include <stdio.h> +#include <string.h> + +#include "lauxlib.h" +#include "lua.h" + + + + +#define VERSION "0.12" + + +#define PATTERN_T "lpeg-pattern" +#define MAXSTACKIDX "lpeg-maxstack" + + +/* +** compatibility with Lua 5.2 +*/ +#if (LUA_VERSION_NUM == 502) + +#undef lua_equal +#define lua_equal(L,idx1,idx2) lua_compare(L,(idx1),(idx2),LUA_OPEQ) + +#undef lua_getfenv +#define lua_getfenv lua_getuservalue +#undef lua_setfenv +#define lua_setfenv lua_setuservalue + +#undef lua_objlen +#define lua_objlen lua_rawlen + +#undef luaL_register +#define luaL_register(L,n,f) \ + { if ((n) == NULL) luaL_setfuncs(L,f,0); else luaL_newlib(L,f); } + +#endif + + +/* default maximum size for call/backtrack stack */ +#if !defined(MAXBACK) +#define MAXBACK 100 +#endif + + +/* maximum number of rules in a grammar */ +#define MAXRULES 200 + + + +/* initial size for capture's list */ +#define INITCAPSIZE 32 + + +/* index, on Lua stack, for subject */ +#define SUBJIDX 2 + +/* number of fixed arguments to 'match' (before capture arguments) */ +#define FIXEDARGS 3 + +/* index, on Lua stack, for capture list */ +#define caplistidx(ptop) ((ptop) + 2) + +/* index, on Lua stack, for pattern's ktable */ +#define ktableidx(ptop) ((ptop) + 3) + +/* index, on Lua stack, for backtracking stack */ +#define stackidx(ptop) ((ptop) + 4) + + + +typedef unsigned char byte; + + +#define BITSPERCHAR 8 + +#define CHARSETSIZE ((UCHAR_MAX/BITSPERCHAR) + 1) + + + +typedef struct Charset { + byte cs[CHARSETSIZE]; +} Charset; + + + +#define loopset(v,b) { int v; for (v = 0; v < CHARSETSIZE; v++) {b;} } + +/* access to charset */ +#define treebuffer(t) ((byte *)((t) + 1)) + +/* number of slots needed for 'n' bytes */ +#define bytes2slots(n) (((n) - 1) / sizeof(TTree) + 1) + +/* set 'b' bit in charset 'cs' */ +#define setchar(cs,b) ((cs)[(b) >> 3] |= (1 << ((b) & 7))) + + +/* +** in capture instructions, 'kind' of capture and its offset are +** packed in field 'aux', 4 bits for each +*/ +#define getkind(op) ((op)->i.aux & 0xF) +#define getoff(op) (((op)->i.aux >> 4) & 0xF) +#define joinkindoff(k,o) ((k) | ((o) << 4)) + +#define MAXOFF 0xF +#define MAXAUX 0xFF + + +/* maximum number of bytes to look behind */ +#define MAXBEHIND MAXAUX + + +/* maximum size (in elements) for a pattern */ +#define MAXPATTSIZE (SHRT_MAX - 10) + + +/* size (in elements) for an instruction plus extra l bytes */ +#define instsize(l) (((l) + sizeof(Instruction) - 1)/sizeof(Instruction) + 1) + + +/* size (in elements) for a ISet instruction */ +#define CHARSETINSTSIZE instsize(CHARSETSIZE) + +/* size (in elements) for a IFunc instruction */ +#define funcinstsize(p) ((p)->i.aux + 2) + + + +#define testchar(st,c) (((int)(st)[((c) >> 3)] & (1 << ((c) & 7)))) + + +#endif + +/* +** $Id: lpcap.h,v 1.1 2013/03/21 20:25:12 roberto Exp $ +*/ + +#if !defined(lpcap_h) +#define lpcap_h + + +/* include "lptypes.h" */ -#define KEYNEWPATT "lpeg.newpf" +/* kinds of captures */ +typedef enum CapKind { + Cclose, Cposition, Cconst, Cbackref, Carg, Csimple, Ctable, Cfunction, + Cquery, Cstring, Cnum, Csubst, Cfold, Cruntime, Cgroup +} CapKind; + + +typedef struct Capture { + const char *s; /* subject position */ + short idx; /* extra info about capture (group name, arg index, etc.) */ + byte kind; /* kind of capture */ + byte siz; /* size of full capture + 1 (0 = not a full capture) */ +} Capture; + + +typedef struct CapState { + Capture *cap; /* current capture */ + Capture *ocap; /* (original) capture list */ + lua_State *L; + int ptop; /* index of last argument to 'match' */ + const char *s; /* original string */ + int valuecached; /* value stored in cache slot */ +} CapState; + + +int runtimecap (CapState *cs, Capture *close, const char *s, int *rem); +int getcaptures (lua_State *L, const char *s, const char *r, int ptop); +int finddyncap (Capture *cap, Capture *last); + +#endif + + +/* +** $Id: lptree.h,v 1.2 2013/03/24 13:51:12 roberto Exp $ +*/ + +#if !defined(lptree_h) +#define lptree_h + + +/*#include "lptypes.h" */ + + +/* +** types of trees +*/ +typedef enum TTag { + TChar = 0, TSet, TAny, /* standard PEG elements */ + TTrue, TFalse, + TRep, + TSeq, TChoice, + TNot, TAnd, + TCall, + TOpenCall, + TRule, /* sib1 is rule's pattern, sib2 is 'next' rule */ + TGrammar, /* sib1 is initial (and first) rule */ + TBehind, /* match behind */ + TCapture, /* regular capture */ + TRunTime /* run-time capture */ +} TTag; + +/* number of siblings for each tree */ +extern const byte numsiblings[]; + + +/* +** Tree trees +** The first sibling of a tree (if there is one) is immediately after +** the tree. A reference to a second sibling (ps) is its position +** relative to the position of the tree itself. A key in ktable +** uses the (unique) address of the original tree that created that +** entry. NULL means no data. +*/ +typedef struct TTree { + byte tag; + byte cap; /* kind of capture (if it is a capture) */ + unsigned short key; /* key in ktable for Lua data (0 if no key) */ + union { + int ps; /* occasional second sibling */ + int n; /* occasional counter */ + } u; +} TTree; + + +/* +** A complete pattern has its tree plus, if already compiled, +** its corresponding code +*/ +typedef struct Pattern { + union Instruction *code; + int codesize; + TTree tree[1]; +} Pattern; + + +/* number of siblings for each tree */ +extern const byte numsiblings[]; + +/* access to siblings */ +#define sib1(t) ((t) + 1) +#define sib2(t) ((t) + (t)->u.ps) + + + + +#endif + +/* +** $Id: lpvm.h,v 1.2 2013/04/03 20:37:18 roberto Exp $ +*/ + +#if !defined(lpvm_h) +#define lpvm_h + +/*#include "lpcap.h"*/ + + +/* Virtual Machine's instructions */ +typedef enum Opcode { + IAny, /* if no char, fail */ + IChar, /* if char != aux, fail */ + ISet, /* if char not in buff, fail */ + ITestAny, /* in no char, jump to 'offset' */ + ITestChar, /* if char != aux, jump to 'offset' */ + ITestSet, /* if char not in buff, jump to 'offset' */ + ISpan, /* read a span of chars in buff */ + IBehind, /* walk back 'aux' characters (fail if not possible) */ + IRet, /* return from a rule */ + IEnd, /* end of pattern */ + IChoice, /* stack a choice; next fail will jump to 'offset' */ + IJmp, /* jump to 'offset' */ + ICall, /* call rule at 'offset' */ + IOpenCall, /* call rule number 'key' (must be closed to a ICall) */ + ICommit, /* pop choice and jump to 'offset' */ + IPartialCommit, /* update top choice to current position and jump */ + IBackCommit, /* "fails" but jump to its own 'offset' */ + IFailTwice, /* pop one choice and then fail */ + IFail, /* go back to saved state on choice and jump to saved offset */ + IGiveup, /* internal use */ + IFullCapture, /* complete capture of last 'off' chars */ + IOpenCapture, /* start a capture */ + ICloseCapture, + ICloseRunTime +} Opcode; + + + +typedef union Instruction { + struct Inst { + byte code; + byte aux; + short key; + } i; + int offset; + byte buff[1]; +} Instruction; + + +int getposition (lua_State *L, int t, int i); +void printpatt (Instruction *p, int n); +const char *match (lua_State *L, const char *o, const char *s, const char *e, + Instruction *op, Capture *capture, int ptop); +int verify (lua_State *L, Instruction *op, const Instruction *p, + Instruction *e, int postable, int rule); +void checkrule (lua_State *L, Instruction *op, int from, int to, + int postable, int rule); + + +#endif /* -** type of extension functions that define new "patterns" for LPEG -** It should return the new current position or NULL if match fails +** $Id: lpcode.h,v 1.5 2013/04/04 21:24:45 roberto Exp $ */ -typedef const char *(*PattFunc) (const char *s, /* current position */ - const char *e, /* string end */ - const char *o, /* string start */ - const void *ud); /* user data */ +#if !defined(lpcode_h) +#define lpcode_h + +/*#include "lua.h"*/ + +/*#include "lptypes.h"*/ +/*#include "lptree.h"*/ +/*#include "lpvm.h"*/ + +int tocharset (TTree *tree, Charset *cs); +int checkaux (TTree *tree, int pred); +int fixedlenx (TTree *tree, int count, int len); +int hascaptures (TTree *tree); +int lp_gc (lua_State *L); +Instruction *compile (lua_State *L, Pattern *p); +void reallocprog (lua_State *L, Pattern *p, int nsize); +int sizei (const Instruction *i); + + +#define PEnullable 0 +#define PEnofail 1 + +#define nofail(t) checkaux(t, PEnofail) +#define nullable(t) checkaux(t, PEnullable) + +#define fixedlen(t) fixedlenx(t, 0, 0) + + + +#endif /* -** function to create new patterns based on 'PattFunc' functions. -** This function is available at *registry[KEYNEWPATT]. (Notice -** the extra indirection; the userdata at the registry points to -** a variable that points to the function. In ANSI C a void* cannot -** point to a function.) +** $Id: lpprint.h,v 1.1 2013/03/21 20:25:12 roberto Exp $ */ -typedef void (*Newpf) (lua_State *L, - PattFunc f, /* pattern */ - const void *ud, /* (user) data to be passed to 'f' */ - size_t l); /* size of data to be passed to 'f' */ + + +#if !defined(lpprint_h) +#define lpprint_h + + +/*#include "lptree.h"*/ +/*#include "lpvm.h"*/ + + +#if defined(LPEG_DEBUG) + +void printpatt (Instruction *p, int n); +void printtree (TTree *tree, int ident); +void printktable (lua_State *L, int idx); +void printcharset (const byte *st); +void printcaplist (Capture *cap, Capture *limit); + +#else + +#define printktable(L,idx) \ + luaL_error(L, "function only implemented in debug mode") +#define printtree(tree,i) \ + luaL_error(L, "function only implemented in debug mode") +#define printpatt(p,n) \ + luaL_error(L, "function only implemented in debug mode") #endif + + +#endif + diff --git a/Build/source/texk/web2c/luatexdir/luatex_svnversion.h b/Build/source/texk/web2c/luatexdir/luatex_svnversion.h index 01e985cf641..2fdac934132 100644 --- a/Build/source/texk/web2c/luatexdir/luatex_svnversion.h +++ b/Build/source/texk/web2c/luatexdir/luatex_svnversion.h @@ -1 +1 @@ -#define luatex_svn_revision 4772 +#define luatex_svn_revision 4794 diff --git a/Build/source/texk/web2c/luatexdir/tex/linebreak.w b/Build/source/texk/web2c/luatexdir/tex/linebreak.w index 07017ab1776..0d7b8b2723b 100644 --- a/Build/source/texk/web2c/luatexdir/tex/linebreak.w +++ b/Build/source/texk/web2c/luatexdir/tex/linebreak.w @@ -1,2210 +1,2212 @@ -% 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 -static const char _svn_version[] = - "$Id: linebreak.w 4679 2013-12-19 15:47:53Z luigi $" - "$URL: https://foundry.supelec.fr/svn/luatex/trunk/source/texk/web2c/luatexdir/tex/linebreak.w $"; - -#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 */ - 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)); - } else if (type(cur_list.tail_field) != glue_node) { - tail_append(new_penalty(inf_penalty)); - } else { - type(cur_list.tail_field) = penalty_node; - delete_glue_ref(glue_ptr(cur_list.tail_field)); - if (leader_ptr(cur_list.tail_field) != null) - flush_node_list(leader_ptr(cur_list.tail_field)); - penalty(cur_list.tail_field) = inf_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); -#ifdef DEBUG - { - int n = temp_head; - fprintf(stdout, "pre_linebreak_filter status:\n"); - while (n) { - fprintf(stdout, " %s node %d\n", - get_node_name(type(n), subtype(n)), (int) n); - n = vlink(n); - } - } -#endif - 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; -#ifdef DEBUG - { - int n = temp_head; - fprintf(stdout, "pre_linebreak_filter returned:\n"); - while (n) { - fprintf(stdout, " %s node %d\n", - get_node_name(type(n), subtype(n)), (int) n); - n = vlink(n); - } - } -#endif - 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 (int_par(tracing_paragraphs_code) > 0) { - begin_diagnostic(); - tprint_nl - ("Lua linebreak_filter failed, reverting to default on line "); - print_int(line); - end_diagnostic(true); - } - } - } - if (callback_id == 0) { - if ((!is_char_node(vlink(temp_head))) - && ((type(vlink(temp_head)) == whatsit_node) - && (subtype(vlink(temp_head)) == local_par_node))) - paragraph_dir = local_par_dir(vlink(temp_head)); - else - assert(0); /* |paragraph_dir = 0|; */ - ext_do_line_break(paragraph_dir, - int_par(pretolerance_code), - int_par(tracing_paragraphs_code), - int_par(tolerance_code), - dimen_par(emergency_stretch_code), - int_par(looseness_code), - int_par(hyphen_penalty_code), - int_par(ex_hyphen_penalty_code), - int_par(pdf_adjust_spacing_code), - equiv(par_shape_loc), - int_par(adj_demerits_code), - int_par(pdf_protrude_chars_code), - int_par(line_penalty_code), - int_par(last_line_fit_code), - int_par(double_hyphen_demerits_code), - int_par(final_hyphen_demerits_code), - dimen_par(hang_indent_code), - dimen_par(hsize_code), - int_par(hang_after_code), - glue_par(left_skip_code), - glue_par(right_skip_code), - dimen_par(pdf_each_line_height_code), - dimen_par(pdf_each_line_depth_code), - dimen_par(pdf_first_line_height_code), - dimen_par(pdf_last_line_depth_code), - equiv(inter_line_penalties_loc), - int_par(inter_line_penalty_code), - int_par(club_penalty_code), - equiv(club_penalties_loc), - (d ? equiv(display_widow_penalties_loc) : equiv(widow_penalties_loc)), - (d ? int_par(display_widow_penalty_code) : int_par(widow_penalty_code)), - int_par(broken_penalty_code), - final_par_glue, dimen_par(pdf_ignored_dimen_code)); - } - 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 */ - halfword q; /*new glue specification */ - 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); - } - q = new_spec(p); - shrink_order(q) = normal; - delete_glue_ref(p); - return q; -} - -@ 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) - pdf_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 */ - pdf_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)) - pdf_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) - pdf_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) - pdf_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; - if ((vlink(l) != null) && (type(l) == hlist_node) && (width(l) == 0) - && (height(l) == 0) && (depth(l) == 0) && (list_ptr(l) == null)) { - l = vlink(l); /*for paragraph start with \.{\\parindent} = 0pt */ - } else if (d) { - while ((vlink(l) != null) && (!(is_char_node(l) || non_discardable(l)))) { - l = vlink(l); /* std.\ discardables at line break, \TeX book, p 95 */ - } - } - 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) - 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; - if (r == null) - return null; - hlist_stack_level = 0; - run = true; - 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) { - assert(vlink(alink(r)) == r); - 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 (pdf_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, pdf_adjust_spacing, \ - par_shape_ptr, adj_demerits, \ - tracing_paragraphs, pdf_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 -static void add_to_widths(halfword s, int line_break_dir, - int pdf_adjust_spacing, scaled * widths) -{ - while (s != null) { - if (is_char_node(s)) { - widths[1] += pack_width(line_break_dir, dir_TRT, s, true); - if ((pdf_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 ((pdf_adjust_spacing > 1) && (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: - confusion("add_disc_widths"); - } - } - 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 pdf_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 ((pdf_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 ((pdf_adjust_spacing > 1) && (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: - confusion("sub_disc_widths"); - 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 pdf_adjust_spacing, - halfword p - /*, halfword s */ ) -{ - halfword s; /* glue and other 'whitespace' to be skipped after a break - * used if unhyphenated, or |post_break==empty| */ - s = p; - 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, pdf_adjust_spacing, - break_width); - add_to_widths(vlink_post_break(p), line_break_dir, pdf_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 glue_node: - /*Subtract glue from |break_width|; */ - { - halfword v = glue_ptr(s); - break_width[1] -= width(v); - break_width[2 + stretch_order(v)] -= stretch(v); - break_width[7] -= shrink(v); - } - break; - case penalty_node: - break; - case math_node: - break_width[1] -= surround(s); - break; - case kern_node: - if (subtype(s) != explicit) - 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 pdf_adjust_spacing, - int par_shape_ptr, - int adj_demerits, - int tracing_paragraphs, - int pdf_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; /* stays a step behind |r| */ - halfword prev_prev_r; /*a step behind |prev_r|, if |type(prev_r)=delta_node| */ - halfword old_l; /* maximum line number in current equivalence class of lines */ - boolean no_break_yet; /* 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; /*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; /*glue stretch or shrink of test line, adjustment for last line */ - scaled cur_active_width[10] = { 0 }; /*distance from current active node */ - - line_width = 0; - g = 0; - prev_prev_r = null; - /*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 */ - } - - no_break_yet = true; - prev_r = active; - old_l = 0; - 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, - pdf_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 (pdf_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) && (pdf_adjust_spacing > 1)) { - margin_kern_stretch = 0; - margin_kern_shrink = 0; - if (pdf_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 hyphen_penalty, - int ex_hyphen_penalty, - int pdf_adjust_spacing, - halfword par_shape_ptr, - int adj_demerits, - int pdf_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, - int pdf_each_line_height, - int pdf_each_line_depth, - int pdf_first_line_height, - int pdf_last_line_depth, - 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, halfword pdf_ignored_dimen) -{ - /* 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; - - /* 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 { - /* 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(hang_indent); - if (hang_indent >= 0) - first_indent = hang_indent; - else - first_indent = 0; - second_width = hsize; - second_indent = 0; - } else { - first_width = hsize; - first_indent = 0; - second_width = hsize - abs(hang_indent); - if (hang_indent >= 0) - second_indent = 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; - } - 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 (pdf_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 = glue_ptr(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(paragraph_dir,dir_ptr); /* 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) == whatsit_node) - && (subtype(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 ((pdf_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]; -#ifdef DEBUG - fprintf(stderr,"Node Pop %d [%d]\n",nest_index,(int)cur_p); -#endif - } - } - if (cur_p == null) { /* TODO */ - confusion("linebreak_tail"); - } - /* 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 whatsit_node: - /* Advance past a whatsit node in the |line_break| loop; */ - switch (subtype(cur_p)) { - 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 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(cur_p,dir_ptr); /* adds to |dir_ptr| */ - } else { - pop_dir_node(dir_ptr); - if (dir_ptr != null) - line_break_dir = dir_dir(dir_ptr); - } - break; - case pdf_refxform_node: - case pdf_refximage_node: - active_width[1] += width(cur_p); - } - /* / Advance past a whatsit node in the |line_break| loop/; */ - break; - 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. */ - /* *INDENT-OFF* */ - if (auto_breaking) { - halfword prev_p = alink(cur_p); - if (prev_p != temp_head && - (is_char_node(prev_p) || - precedes_break(prev_p) || - ((type(prev_p) == kern_node) - && (subtype(prev_p) != explicit)))) { - ext_try_break(0, unhyphenated_node, line_break_dir, pdf_adjust_spacing, - par_shape_ptr, adj_demerits, - tracing_paragraphs, pdf_protrude_chars, - line_penalty, last_line_fit, - double_hyphen_demerits, - final_hyphen_demerits, first_p, cur_p); - } - } - /* *INDENT-ON* */ - check_shrinkage(glue_ptr(cur_p)); - q = glue_ptr(cur_p); - active_width[1] += width(q); - active_width[2 + stretch_order(q)] += stretch(q); - active_width[7] += shrink(q); - break; - case kern_node: - if (subtype(cur_p) == explicit) { - kern_break(); - } else { - active_width[1] += width(cur_p); - if ((pdf_adjust_spacing > 1) && (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. */ - if (second_pass) { - int actual_penalty = hyphen_penalty; - if (subtype(cur_p) == automatic_disc) - actual_penalty = ex_hyphen_penalty; - 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, pdf_adjust_spacing, - par_shape_ptr, adj_demerits, - tracing_paragraphs, pdf_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, pdf_adjust_spacing, - disc_width); - do_one_seven_eight(add_disc_width_to_active_width); - ext_try_break(actual_penalty, hyphenated_node, - line_break_dir, pdf_adjust_spacing, - par_shape_ptr, adj_demerits, - tracing_paragraphs, pdf_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' */ - assert(type(vlink(cur_p)) == disc_node && - subtype(vlink(cur_p)) == select_disc); - s = vlink_pre_break(vlink(cur_p)); - add_to_widths(s, line_break_dir, pdf_adjust_spacing, - disc_width); - ext_try_break(actual_penalty, hyphenated_node, - line_break_dir, pdf_adjust_spacing, - par_shape_ptr, adj_demerits, - tracing_paragraphs, - pdf_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, pdf_adjust_spacing, - disc_width); - ext_try_break(actual_penalty, hyphenated_node, - line_break_dir, pdf_adjust_spacing, - par_shape_ptr, adj_demerits, - tracing_paragraphs, - pdf_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, pdf_adjust_spacing, - active_width); - break; - case math_node: - auto_breaking = (subtype(cur_p) == after); - kern_break(); - break; - case penalty_node: - ext_try_break(penalty(cur_p), unhyphenated_node, line_break_dir, - pdf_adjust_spacing, par_shape_ptr, adj_demerits, - tracing_paragraphs, pdf_protrude_chars, - line_penalty, last_line_fit, - double_hyphen_demerits, final_hyphen_demerits, - first_p, cur_p); - break; - case mark_node: - case ins_node: - case adjust_node: - break; - case glue_spec_node: - fprintf(stdout, "\nfound a glue_spec in a paragraph!"); - break; - default: - fprintf(stdout, "\ntype=%d", type(cur_p)); - confusion("paragraph"); - } - cur_p = vlink(cur_p); - while (cur_p == null && nest_index > 0) { - cur_p = nest_stack[--nest_index]; -#ifdef DEBUG - fprintf(stderr,"Node Pop %d [%d]\n",nest_index,(int)cur_p); -#endif - } - } - 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, - pdf_adjust_spacing, par_shape_ptr, adj_demerits, - tracing_paragraphs, pdf_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 { - q = new_spec(glue_ptr(last_line_fill)); - delete_glue_ref(glue_ptr(last_line_fill)); - width(q) += (active_short(best_bet) - active_glue(best_bet)); - stretch(q) = 0; - glue_ptr(last_line_fill) = q; - } - } - - /* 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, - pdf_protrude_chars, - par_shape_ptr, - pdf_adjust_spacing, - pdf_each_line_height, - pdf_each_line_depth, - pdf_first_line_height, - pdf_last_line_depth, - inter_line_penalties_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, - pdf_ignored_dimen); - /* /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; -} +% 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
+static const char _svn_version[] =
+ "$Id: linebreak.w 4777 2014-02-10 10:09:39Z luigi $"
+ "$URL: https://foundry.supelec.fr/svn/luatex/trunk/source/texk/web2c/luatexdir/tex/linebreak.w $";
+
+#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));
+ } else if (type(cur_list.tail_field) != glue_node) {
+ tail_append(new_penalty(inf_penalty));
+ } else {
+ type(cur_list.tail_field) = penalty_node;
+ delete_glue_ref(glue_ptr(cur_list.tail_field));
+ if (leader_ptr(cur_list.tail_field) != null)
+ flush_node_list(leader_ptr(cur_list.tail_field));
+ penalty(cur_list.tail_field) = inf_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);
+#ifdef DEBUG
+ {
+ int n = temp_head;
+ fprintf(stdout, "pre_linebreak_filter status:\n");
+ while (n) {
+ fprintf(stdout, " %s node %d\n",
+ get_node_name(type(n), subtype(n)), (int) n);
+ n = vlink(n);
+ }
+ }
+#endif
+ 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;
+#ifdef DEBUG
+ {
+ int n = temp_head;
+ fprintf(stdout, "pre_linebreak_filter returned:\n");
+ while (n) {
+ fprintf(stdout, " %s node %d\n",
+ get_node_name(type(n), subtype(n)), (int) n);
+ n = vlink(n);
+ }
+ }
+#endif
+ 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 (int_par(tracing_paragraphs_code) > 0) {
+ begin_diagnostic();
+ tprint_nl
+ ("Lua linebreak_filter failed, reverting to default on line ");
+ print_int(line);
+ end_diagnostic(true);
+ }
+ }
+ }
+ if (callback_id == 0) {
+ if ((!is_char_node(vlink(temp_head)))
+ && ((type(vlink(temp_head)) == whatsit_node)
+ && (subtype(vlink(temp_head)) == local_par_node)))
+ paragraph_dir = local_par_dir(vlink(temp_head));
+ else
+ assert(0); /* |paragraph_dir = 0|; */
+ ext_do_line_break(paragraph_dir,
+ int_par(pretolerance_code),
+ int_par(tracing_paragraphs_code),
+ int_par(tolerance_code),
+ dimen_par(emergency_stretch_code),
+ int_par(looseness_code),
+ int_par(hyphen_penalty_code),
+ int_par(ex_hyphen_penalty_code),
+ int_par(pdf_adjust_spacing_code),
+ equiv(par_shape_loc),
+ int_par(adj_demerits_code),
+ int_par(pdf_protrude_chars_code),
+ int_par(line_penalty_code),
+ int_par(last_line_fit_code),
+ int_par(double_hyphen_demerits_code),
+ int_par(final_hyphen_demerits_code),
+ dimen_par(hang_indent_code),
+ dimen_par(hsize_code),
+ int_par(hang_after_code),
+ glue_par(left_skip_code),
+ glue_par(right_skip_code),
+ dimen_par(pdf_each_line_height_code),
+ dimen_par(pdf_each_line_depth_code),
+ dimen_par(pdf_first_line_height_code),
+ dimen_par(pdf_last_line_depth_code),
+ equiv(inter_line_penalties_loc),
+ int_par(inter_line_penalty_code),
+ int_par(club_penalty_code),
+ equiv(club_penalties_loc),
+ (d ? equiv(display_widow_penalties_loc) : equiv(widow_penalties_loc)),
+ (d ? int_par(display_widow_penalty_code) : int_par(widow_penalty_code)),
+ int_par(broken_penalty_code),
+ final_par_glue, dimen_par(pdf_ignored_dimen_code));
+ }
+ 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 */
+ halfword q; /*new glue specification */
+ 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);
+ }
+ q = new_spec(p);
+ shrink_order(q) = normal;
+ delete_glue_ref(p);
+ return q;
+}
+
+@ 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)
+ pdf_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 */
+ pdf_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))
+ pdf_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)
+ pdf_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)
+ pdf_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;
+ if ((vlink(l) != null) && (type(l) == hlist_node) && (width(l) == 0)
+ && (height(l) == 0) && (depth(l) == 0) && (list_ptr(l) == null)) {
+ l = vlink(l); /*for paragraph start with \.{\\parindent} = 0pt */
+ } else if (d) {
+ while ((vlink(l) != null) && (!(is_char_node(l) || non_discardable(l)))) {
+ l = vlink(l); /* std.\ discardables at line break, \TeX book, p 95 */
+ }
+ }
+ 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)
+ 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;
+ if (r == null)
+ return null;
+ hlist_stack_level = 0;
+ run = true;
+ 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) {
+ assert(vlink(alink(r)) == r);
+ 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 (pdf_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, pdf_adjust_spacing, \
+ par_shape_ptr, adj_demerits, \
+ tracing_paragraphs, pdf_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
+static void add_to_widths(halfword s, int line_break_dir,
+ int pdf_adjust_spacing, scaled * widths)
+{
+ while (s != null) {
+ if (is_char_node(s)) {
+ widths[1] += pack_width(line_break_dir, dir_TRT, s, true);
+ if ((pdf_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 ((pdf_adjust_spacing > 1) && (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:
+ confusion("add_disc_widths");
+ }
+ }
+ 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 pdf_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 ((pdf_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 ((pdf_adjust_spacing > 1) && (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:
+ confusion("sub_disc_widths");
+ 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 pdf_adjust_spacing,
+ halfword p
+ /*, halfword s */ )
+{
+ halfword s; /* glue and other 'whitespace' to be skipped after a break
+ * used if unhyphenated, or |post_break==empty| */
+ s = p;
+ 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, pdf_adjust_spacing,
+ break_width);
+ add_to_widths(vlink_post_break(p), line_break_dir, pdf_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 glue_node:
+ /*Subtract glue from |break_width|; */
+ {
+ halfword v = glue_ptr(s);
+ break_width[1] -= width(v);
+ break_width[2 + stretch_order(v)] -= stretch(v);
+ break_width[7] -= shrink(v);
+ }
+ break;
+ case penalty_node:
+ break;
+ case math_node:
+ break_width[1] -= surround(s);
+ break;
+ case kern_node:
+ if (subtype(s) != explicit)
+ 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 pdf_adjust_spacing,
+ int par_shape_ptr,
+ int adj_demerits,
+ int tracing_paragraphs,
+ int pdf_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; /* stays a step behind |r| */
+ halfword prev_prev_r; /*a step behind |prev_r|, if |type(prev_r)=delta_node| */
+ halfword old_l; /* maximum line number in current equivalence class of lines */
+ boolean no_break_yet; /* 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; /*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; /*glue stretch or shrink of test line, adjustment for last line */
+ scaled cur_active_width[10] = { 0 }; /*distance from current active node */
+
+ line_width = 0;
+ g = 0;
+ prev_prev_r = null;
+ /*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 */
+ }
+
+ no_break_yet = true;
+ prev_r = active;
+ old_l = 0;
+ 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,
+ pdf_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 (pdf_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) && (pdf_adjust_spacing > 1)) {
+ margin_kern_stretch = 0;
+ margin_kern_shrink = 0;
+ if (pdf_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 hyphen_penalty,
+ int ex_hyphen_penalty,
+ int pdf_adjust_spacing,
+ halfword par_shape_ptr,
+ int adj_demerits,
+ int pdf_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,
+ int pdf_each_line_height,
+ int pdf_each_line_depth,
+ int pdf_first_line_height,
+ int pdf_last_line_depth,
+ 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, halfword pdf_ignored_dimen)
+{
+ /* 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;
+
+ /* 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 {
+ /* 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(hang_indent);
+ if (hang_indent >= 0)
+ first_indent = hang_indent;
+ else
+ first_indent = 0;
+ second_width = hsize;
+ second_indent = 0;
+ } else {
+ first_width = hsize;
+ first_indent = 0;
+ second_width = hsize - abs(hang_indent);
+ if (hang_indent >= 0)
+ second_indent = 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;
+ }
+ 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 (pdf_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 = glue_ptr(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(paragraph_dir,dir_ptr); /* 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) == whatsit_node)
+ && (subtype(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 ((pdf_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];
+#ifdef DEBUG
+ fprintf(stderr,"Node Pop %d [%d]\n",nest_index,(int)cur_p);
+#endif
+ }
+ }
+ if (cur_p == null) { /* TODO */
+ confusion("linebreak_tail");
+ }
+ /* 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 whatsit_node:
+ /* Advance past a whatsit node in the |line_break| loop; */
+ switch (subtype(cur_p)) {
+ 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 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(cur_p,dir_ptr); /* adds to |dir_ptr| */
+ } else {
+ pop_dir_node(dir_ptr);
+ if (dir_ptr != null)
+ line_break_dir = dir_dir(dir_ptr);
+ }
+ break;
+ case pdf_refxform_node:
+ case pdf_refximage_node:
+ active_width[1] += width(cur_p);
+ }
+ /* / Advance past a whatsit node in the |line_break| loop/; */
+ break;
+ 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. */
+ /* *INDENT-OFF* */
+ if (auto_breaking) {
+ halfword prev_p = alink(cur_p);
+ if (prev_p != temp_head &&
+ (is_char_node(prev_p) ||
+ precedes_break(prev_p) ||
+ ((type(prev_p) == kern_node)
+ && (subtype(prev_p) != explicit)))) {
+ ext_try_break(0, unhyphenated_node, line_break_dir, pdf_adjust_spacing,
+ par_shape_ptr, adj_demerits,
+ tracing_paragraphs, pdf_protrude_chars,
+ line_penalty, last_line_fit,
+ double_hyphen_demerits,
+ final_hyphen_demerits, first_p, cur_p);
+ }
+ }
+ /* *INDENT-ON* */
+ check_shrinkage(glue_ptr(cur_p));
+ q = glue_ptr(cur_p);
+ active_width[1] += width(q);
+ active_width[2 + stretch_order(q)] += stretch(q);
+ active_width[7] += shrink(q);
+ break;
+ case kern_node:
+ if (subtype(cur_p) == explicit) {
+ kern_break();
+ } else {
+ active_width[1] += width(cur_p);
+ if ((pdf_adjust_spacing > 1) && (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. */
+ if (second_pass) {
+ int actual_penalty = hyphen_penalty;
+ if (subtype(cur_p) == automatic_disc)
+ actual_penalty = ex_hyphen_penalty;
+ 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, pdf_adjust_spacing,
+ par_shape_ptr, adj_demerits,
+ tracing_paragraphs, pdf_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, pdf_adjust_spacing,
+ disc_width);
+ do_one_seven_eight(add_disc_width_to_active_width);
+ ext_try_break(actual_penalty, hyphenated_node,
+ line_break_dir, pdf_adjust_spacing,
+ par_shape_ptr, adj_demerits,
+ tracing_paragraphs, pdf_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' */
+ assert(type(vlink(cur_p)) == disc_node &&
+ subtype(vlink(cur_p)) == select_disc);
+ s = vlink_pre_break(vlink(cur_p));
+ add_to_widths(s, line_break_dir, pdf_adjust_spacing,
+ disc_width);
+ ext_try_break(actual_penalty, hyphenated_node,
+ line_break_dir, pdf_adjust_spacing,
+ par_shape_ptr, adj_demerits,
+ tracing_paragraphs,
+ pdf_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, pdf_adjust_spacing,
+ disc_width);
+ ext_try_break(actual_penalty, hyphenated_node,
+ line_break_dir, pdf_adjust_spacing,
+ par_shape_ptr, adj_demerits,
+ tracing_paragraphs,
+ pdf_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, pdf_adjust_spacing,
+ active_width);
+ break;
+ case math_node:
+ auto_breaking = (subtype(cur_p) == after);
+ kern_break();
+ break;
+ case penalty_node:
+ ext_try_break(penalty(cur_p), unhyphenated_node, line_break_dir,
+ pdf_adjust_spacing, par_shape_ptr, adj_demerits,
+ tracing_paragraphs, pdf_protrude_chars,
+ line_penalty, last_line_fit,
+ double_hyphen_demerits, final_hyphen_demerits,
+ first_p, cur_p);
+ break;
+ case mark_node:
+ case ins_node:
+ case adjust_node:
+ break;
+ case glue_spec_node:
+ fprintf(stdout, "\nfound a glue_spec in a paragraph!");
+ break;
+ default:
+ fprintf(stdout, "\ntype=%d", type(cur_p));
+ confusion("paragraph");
+ }
+ cur_p = vlink(cur_p);
+ while (cur_p == null && nest_index > 0) {
+ cur_p = nest_stack[--nest_index];
+#ifdef DEBUG
+ fprintf(stderr,"Node Pop %d [%d]\n",nest_index,(int)cur_p);
+#endif
+ }
+ }
+ 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,
+ pdf_adjust_spacing, par_shape_ptr, adj_demerits,
+ tracing_paragraphs, pdf_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 {
+ q = new_spec(glue_ptr(last_line_fill));
+ delete_glue_ref(glue_ptr(last_line_fill));
+ width(q) += (active_short(best_bet) - active_glue(best_bet));
+ stretch(q) = 0;
+ glue_ptr(last_line_fill) = q;
+ }
+ }
+
+ /* 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,
+ pdf_protrude_chars,
+ par_shape_ptr,
+ pdf_adjust_spacing,
+ pdf_each_line_height,
+ pdf_each_line_depth,
+ pdf_first_line_height,
+ pdf_last_line_depth,
+ inter_line_penalties_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,
+ pdf_ignored_dimen);
+ /* /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/Build/source/texk/web2c/luatexdir/tex/mlist.w b/Build/source/texk/web2c/luatexdir/tex/mlist.w index 69c2b40ad3f..50ee01fb5da 100644 --- a/Build/source/texk/web2c/luatexdir/tex/mlist.w +++ b/Build/source/texk/web2c/luatexdir/tex/mlist.w @@ -1,3599 +1,3607 @@ -% 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/>. - -\def\LuaTeX{Lua\TeX} - -@ @c -static const char _svn_version[] = - "$Id: mlist.w 4634 2013-04-21 14:45:45Z hhenkel $" - "$URL: https://foundry.supelec.fr/svn/luatex/branches/ex-glyph/source/texk/web2c/luatexdir/tex/mlist.w $"; - -#include "ptexlib.h" -#include "lua/luatex-api.h" - -@ @c -#define delimiter_factor int_par(delimiter_factor_code) -#define delimiter_shortfall dimen_par(delimiter_shortfall_code) -#define bin_op_penalty int_par(bin_op_penalty_code) -#define rel_penalty int_par(rel_penalty_code) -#define null_delimiter_space dimen_par(null_delimiter_space_code) -#define script_space dimen_par(script_space_code) -#define disable_lig int_par(disable_lig_code) -#define disable_kern int_par(disable_kern_code) - -#define nDEBUG - -#define reset_attributes(p,newatt) do { \ - delete_attribute_ref(node_attr(p)); \ - node_attr(p) = newatt; \ - if (newatt!=null) { \ - assert(type(newatt)==attribute_list_node); \ - add_node_attr_ref(node_attr(p)); \ - } \ - } while (0) - - -#define DEFINE_MATH_PARAMETERS(A,B,C,D) do { \ - if (B==text_size) { \ - def_math_param(A, text_style, (C),D); \ - def_math_param(A, cramped_text_style, (C),D); \ - } else if (B==script_size) { \ - def_math_param(A, script_style, (C),D); \ - def_math_param(A, cramped_script_style, (C),D); \ - } else if (B==script_script_size) { \ - def_math_param(A, script_script_style, (C),D); \ - def_math_param(A, cramped_script_script_style, (C),D); \ - } \ - } while (0) - -#define DEFINE_DMATH_PARAMETERS(A,B,C,D) do { \ - if (B==text_size) { \ - def_math_param(A, display_style,(C),D); \ - def_math_param(A, cramped_display_style,(C),D); \ - } \ - } while (0) - - -#define is_new_mathfont(A) (font_math_params(A)>0) -#define is_old_mathfont(A,B) (font_math_params(A)==0 && font_params(A)>=(B)) - - -#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 - -@ 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@> - -@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 -#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. - -ScriptPercentScaleDown, -ScriptScriptPercentScaleDown: - These should be handled by the macro package, on the engine - side there are three separate fonts - -DelimitedSubFormulaMinHeight: - This is perhaps related to word's natural math input? I have - no idea what to do about it - -MathLeading: - LuaTeX does not currently handle multi-line displays, and - the parameter does not seem to make much sense elsewhere - -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 - -SkewedFractionHorizontalGap, -SkewedFractionVerticalGap: - I am not sure it makes sense implementing skewed fractions, - so I would like to see an example first - -Also still TODO for OpenType Math: - * extensible large operators - * prescripts - -@ this is not really a math parameter at all - -@c -static void math_param_error(const char *param, int style) -{ - char s[256]; - const char *hlp[] = { - "Sorry, but I can't typeset math unless various parameters have", - "been set. This is normally done by loading special math fonts", - "into the math family slots. Your font set is lacking at least", - "the parameter mentioned earlier.", - NULL - }; - 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; - if (is_new_mathfont(f)) { - a = font_MATH_par(f, AccentBaseHeight); - if (a == undefined_math_parameter) - a = x_height(f); - } else { - a = x_height(f); - } - return a; -} - -@ the non-staticness of this function is for the benefit of |texmath.w| - -@c -scaled get_math_quad(int var) -{ - scaled a = get_math_param(math_param_quad, var); - if (a == undefined_math_parameter) { - math_param_error("quad", var); - a = 0; - } - return a; -} - -@ this parameter is different because it is called with a size - specifier instead of a style specifier. - -@c -static scaled math_axis(int b) -{ - scaled a; - int var; - if (b == script_size) - var = script_style; - else if (b == script_script_size) - var = script_script_style; - else - var = text_style; - a = get_math_param(math_param_axis, var); - if (a == undefined_math_parameter) { - math_param_error("axis", var); - a = 0; - } - return a; -} - -@ @c -static scaled get_math_quad_size(int b) -{ - int var; - if (b == script_size) - var = script_style; - else if (b == script_script_size) - var = script_script_style; - else - var = text_style; - 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. - -@c -static scaled radical_rule(int var) -{ - scaled a = get_math_param(math_param_radical_rule, var); - return a; -} - -@ 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) - -static scaled do_get_math_param_or_error(int var, int param, const char *name) -{ - scaled a = get_math_param(param, var); - if (a == undefined_math_parameter) { - math_param_error(name, var); - a = 0; - } - return a; -} - -@ @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) - -#define connector_overlap_min(a) get_math_param_or_error(a, connector_overlap_min) - -#define overbar_rule(a) get_math_param_or_error(a, overbar_rule) -#define overbar_kern(a) get_math_param_or_error(a, overbar_kern) -#define overbar_vgap(a) get_math_param_or_error(a, overbar_vgap) - -#define underbar_rule(a) get_math_param_or_error(a, underbar_rule) -#define underbar_kern(a) get_math_param_or_error(a, underbar_kern) -#define underbar_vgap(a) get_math_param_or_error(a, underbar_vgap) - -#define under_delimiter_vgap(a) get_math_param_or_error(a, under_delimiter_vgap) -#define under_delimiter_bgap(a) get_math_param_or_error(a, under_delimiter_bgap) - -#define over_delimiter_vgap(a) get_math_param_or_error(a, over_delimiter_vgap) -#define over_delimiter_bgap(a) get_math_param_or_error(a, over_delimiter_bgap) - -#define radical_vgap(a) get_math_param_or_error(a, radical_vgap) -#define radical_kern(a) get_math_param_or_error(a, radical_kern) - -#define stack_vgap(a) get_math_param_or_error(a, stack_vgap) -#define stack_num_up(a) get_math_param_or_error(a, stack_num_up) -#define stack_denom_down(a) get_math_param_or_error(a, stack_denom_down) - -#define fraction_rule(a) get_math_param_or_error(a, fraction_rule) -#define fraction_num_vgap(a) get_math_param_or_error(a, fraction_num_vgap) -#define fraction_denom_vgap(a) get_math_param_or_error(a, fraction_denom_vgap) -#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(a) get_math_param_or_error(a, fraction_del_size) - -#define limit_above_vgap(a) get_math_param_or_error(a, limit_above_vgap) -#define limit_above_bgap(a) get_math_param_or_error(a, limit_above_bgap) -#define limit_above_kern(a) get_math_param_or_error(a, limit_above_kern) - -#define limit_below_vgap(a) get_math_param_or_error(a, limit_below_vgap) -#define limit_below_bgap(a) get_math_param_or_error(a, limit_below_bgap) -#define limit_below_kern(a) get_math_param_or_error(a, limit_below_kern) - -#define sub_shift_drop(a) get_math_param_or_error(a, sub_shift_drop) -#define sup_shift_drop(a) get_math_param_or_error(a, sup_shift_drop) -#define sub_shift_down(a) get_math_param_or_error(a, sub_shift_down) -#define sub_sup_shift_down(a) get_math_param_or_error(a, sub_sup_shift_down) -#define sup_shift_up(a) get_math_param_or_error(a, sup_shift_up) -#define sub_top_max(a) get_math_param_or_error(a, sub_top_max) -#define sup_bottom_min(a) get_math_param_or_error(a, sup_bottom_min) -#define sup_sub_bottom_max(a) get_math_param_or_error(a, sup_sub_bottom_max) -#define subsup_vgap(a) get_math_param_or_error(a, subsup_vgap) - -#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)) { /* fix all known parameters */ - - DEFINE_MATH_PARAMETERS(math_param_quad, size_id, font_size(f), lvl); - DEFINE_DMATH_PARAMETERS(math_param_quad, size_id, font_size(f), lvl); - DEFINE_MATH_PARAMETERS(math_param_axis, size_id, - font_MATH_par(f, AxisHeight), lvl); - DEFINE_DMATH_PARAMETERS(math_param_axis, size_id, - font_MATH_par(f, AxisHeight), lvl); - DEFINE_MATH_PARAMETERS(math_param_overbar_kern, size_id, - font_MATH_par(f, OverbarExtraAscender), lvl); - DEFINE_DMATH_PARAMETERS(math_param_overbar_kern, size_id, - font_MATH_par(f, OverbarExtraAscender), lvl); - DEFINE_MATH_PARAMETERS(math_param_overbar_rule, size_id, - font_MATH_par(f, OverbarRuleThickness), lvl); - DEFINE_DMATH_PARAMETERS(math_param_overbar_rule, size_id, - font_MATH_par(f, OverbarRuleThickness), lvl); - DEFINE_MATH_PARAMETERS(math_param_overbar_vgap, size_id, - font_MATH_par(f, OverbarVerticalGap), lvl); - DEFINE_DMATH_PARAMETERS(math_param_overbar_vgap, size_id, - font_MATH_par(f, OverbarVerticalGap), lvl); - DEFINE_MATH_PARAMETERS(math_param_underbar_kern, size_id, - font_MATH_par(f, UnderbarExtraDescender), lvl); - DEFINE_DMATH_PARAMETERS(math_param_underbar_kern, size_id, - font_MATH_par(f, UnderbarExtraDescender), lvl); - DEFINE_MATH_PARAMETERS(math_param_underbar_rule, size_id, - font_MATH_par(f, UnderbarRuleThickness), lvl); - DEFINE_DMATH_PARAMETERS(math_param_underbar_rule, size_id, - font_MATH_par(f, UnderbarRuleThickness), lvl); - DEFINE_MATH_PARAMETERS(math_param_underbar_vgap, size_id, - font_MATH_par(f, UnderbarVerticalGap), lvl); - DEFINE_DMATH_PARAMETERS(math_param_underbar_vgap, size_id, - font_MATH_par(f, UnderbarVerticalGap), lvl); - - DEFINE_MATH_PARAMETERS(math_param_under_delimiter_vgap, size_id, - font_MATH_par(f, StretchStackGapAboveMin), lvl); - DEFINE_DMATH_PARAMETERS(math_param_under_delimiter_vgap, size_id, - font_MATH_par(f, StretchStackGapAboveMin), lvl); - DEFINE_MATH_PARAMETERS(math_param_under_delimiter_bgap, size_id, - font_MATH_par(f, StretchStackBottomShiftDown), - lvl); - DEFINE_DMATH_PARAMETERS(math_param_under_delimiter_bgap, size_id, - font_MATH_par(f, StretchStackBottomShiftDown), - lvl); - - DEFINE_MATH_PARAMETERS(math_param_over_delimiter_vgap, size_id, - font_MATH_par(f, StretchStackGapBelowMin), lvl); - DEFINE_DMATH_PARAMETERS(math_param_over_delimiter_vgap, size_id, - font_MATH_par(f, StretchStackGapBelowMin), lvl); - DEFINE_MATH_PARAMETERS(math_param_over_delimiter_bgap, size_id, - font_MATH_par(f, StretchStackTopShiftUp), lvl); - DEFINE_DMATH_PARAMETERS(math_param_over_delimiter_bgap, size_id, - font_MATH_par(f, StretchStackTopShiftUp), lvl); - - - DEFINE_MATH_PARAMETERS(math_param_stack_num_up, size_id, - font_MATH_par(f, StackTopShiftUp), lvl); - DEFINE_DMATH_PARAMETERS(math_param_stack_num_up, size_id, - font_MATH_par(f, StackTopDisplayStyleShiftUp), - lvl); - DEFINE_MATH_PARAMETERS(math_param_stack_denom_down, size_id, - font_MATH_par(f, StackBottomShiftDown), lvl); - DEFINE_DMATH_PARAMETERS(math_param_stack_denom_down, size_id, - font_MATH_par(f, - StackBottomDisplayStyleShiftDown), - lvl); - DEFINE_MATH_PARAMETERS(math_param_stack_vgap, size_id, - font_MATH_par(f, StackGapMin), lvl); - DEFINE_DMATH_PARAMETERS(math_param_stack_vgap, size_id, - font_MATH_par(f, StackDisplayStyleGapMin), lvl); - - DEFINE_MATH_PARAMETERS(math_param_radical_kern, size_id, - font_MATH_par(f, RadicalExtraAscender), lvl); - DEFINE_DMATH_PARAMETERS(math_param_radical_kern, size_id, - font_MATH_par(f, RadicalExtraAscender), lvl); - - DEFINE_DMATH_PARAMETERS(math_param_operator_size, size_id, - font_MATH_par(f, DisplayOperatorMinHeight), - lvl); - - DEFINE_MATH_PARAMETERS(math_param_radical_rule, size_id, - font_MATH_par(f, RadicalRuleThickness), lvl); - DEFINE_DMATH_PARAMETERS(math_param_radical_rule, size_id, - font_MATH_par(f, RadicalRuleThickness), lvl); - DEFINE_MATH_PARAMETERS(math_param_radical_vgap, size_id, - font_MATH_par(f, RadicalVerticalGap), lvl); - DEFINE_DMATH_PARAMETERS(math_param_radical_vgap, size_id, - font_MATH_par(f, - RadicalDisplayStyleVerticalGap), - lvl); - DEFINE_MATH_PARAMETERS(math_param_radical_degree_before, size_id, - font_MATH_par(f, RadicalKernBeforeDegree), lvl); - DEFINE_DMATH_PARAMETERS(math_param_radical_degree_before, size_id, - font_MATH_par(f, RadicalKernBeforeDegree), lvl); - DEFINE_MATH_PARAMETERS(math_param_radical_degree_after, size_id, - font_MATH_par(f, RadicalKernAfterDegree), lvl); - DEFINE_DMATH_PARAMETERS(math_param_radical_degree_after, size_id, - font_MATH_par(f, RadicalKernAfterDegree), lvl); - DEFINE_MATH_PARAMETERS(math_param_radical_degree_raise, size_id, - font_MATH_par(f, - RadicalDegreeBottomRaisePercent), - lvl); - DEFINE_DMATH_PARAMETERS(math_param_radical_degree_raise, size_id, - font_MATH_par(f, - RadicalDegreeBottomRaisePercent), - lvl); - if (size_id == text_size) { - def_math_param(math_param_sup_shift_up, display_style, - font_MATH_par(f, SuperscriptShiftUp), lvl); - def_math_param(math_param_sup_shift_up, cramped_display_style, - font_MATH_par(f, SuperscriptShiftUpCramped), lvl); - def_math_param(math_param_sup_shift_up, text_style, - font_MATH_par(f, SuperscriptShiftUp), lvl); - def_math_param(math_param_sup_shift_up, cramped_text_style, - font_MATH_par(f, SuperscriptShiftUpCramped), lvl); - } else if (size_id == script_size) { - def_math_param(math_param_sup_shift_up, script_style, - font_MATH_par(f, SuperscriptShiftUp), lvl); - def_math_param(math_param_sup_shift_up, cramped_script_style, - font_MATH_par(f, SuperscriptShiftUpCramped), lvl); - } else if (size_id == script_script_size) { - def_math_param(math_param_sup_shift_up, script_script_style, - font_MATH_par(f, SuperscriptShiftUp), lvl); - def_math_param(math_param_sup_shift_up, cramped_script_script_style, - font_MATH_par(f, SuperscriptShiftUpCramped), lvl); - } - - DEFINE_MATH_PARAMETERS(math_param_sub_shift_drop, size_id, - font_MATH_par(f, SubscriptBaselineDropMin), lvl); - DEFINE_DMATH_PARAMETERS(math_param_sub_shift_drop, size_id, - font_MATH_par(f, SubscriptBaselineDropMin), - lvl); - DEFINE_MATH_PARAMETERS(math_param_sup_shift_drop, size_id, - font_MATH_par(f, SuperscriptBaselineDropMax), - lvl); - DEFINE_DMATH_PARAMETERS(math_param_sup_shift_drop, size_id, - font_MATH_par(f, SuperscriptBaselineDropMax), - lvl); - DEFINE_MATH_PARAMETERS(math_param_sub_shift_down, size_id, - font_MATH_par(f, SubscriptShiftDown), lvl); - DEFINE_DMATH_PARAMETERS(math_param_sub_shift_down, size_id, - font_MATH_par(f, SubscriptShiftDown), lvl); - - if (font_MATH_par(f, SubscriptShiftDownWithSuperscript) != - undefined_math_parameter) { - DEFINE_MATH_PARAMETERS(math_param_sub_sup_shift_down, size_id, - font_MATH_par(f, - SubscriptShiftDownWithSuperscript), - lvl); - DEFINE_DMATH_PARAMETERS(math_param_sub_sup_shift_down, size_id, - font_MATH_par(f, - SubscriptShiftDownWithSuperscript), - lvl); - } else { - DEFINE_MATH_PARAMETERS(math_param_sub_sup_shift_down, size_id, - font_MATH_par(f, SubscriptShiftDown), lvl); - DEFINE_DMATH_PARAMETERS(math_param_sub_sup_shift_down, size_id, - font_MATH_par(f, SubscriptShiftDown), lvl); - } - - DEFINE_MATH_PARAMETERS(math_param_sub_top_max, size_id, - font_MATH_par(f, SubscriptTopMax), lvl); - DEFINE_DMATH_PARAMETERS(math_param_sub_top_max, size_id, - font_MATH_par(f, SubscriptTopMax), lvl); - DEFINE_MATH_PARAMETERS(math_param_sup_bottom_min, size_id, - font_MATH_par(f, SuperscriptBottomMin), lvl); - DEFINE_DMATH_PARAMETERS(math_param_sup_bottom_min, size_id, - font_MATH_par(f, SuperscriptBottomMin), lvl); - DEFINE_MATH_PARAMETERS(math_param_sup_sub_bottom_max, size_id, - font_MATH_par(f, - SuperscriptBottomMaxWithSubscript), - lvl); - DEFINE_DMATH_PARAMETERS(math_param_sup_sub_bottom_max, size_id, - font_MATH_par(f, - SuperscriptBottomMaxWithSubscript), - lvl); - DEFINE_MATH_PARAMETERS(math_param_subsup_vgap, size_id, - font_MATH_par(f, SubSuperscriptGapMin), lvl); - DEFINE_DMATH_PARAMETERS(math_param_subsup_vgap, size_id, - font_MATH_par(f, SubSuperscriptGapMin), lvl); - - DEFINE_MATH_PARAMETERS(math_param_limit_above_vgap, size_id, - font_MATH_par(f, UpperLimitGapMin), lvl); - DEFINE_DMATH_PARAMETERS(math_param_limit_above_vgap, size_id, - font_MATH_par(f, UpperLimitGapMin), lvl); - DEFINE_MATH_PARAMETERS(math_param_limit_above_bgap, size_id, - font_MATH_par(f, UpperLimitBaselineRiseMin), - lvl); - DEFINE_DMATH_PARAMETERS(math_param_limit_above_bgap, size_id, - font_MATH_par(f, UpperLimitBaselineRiseMin), - lvl); - DEFINE_MATH_PARAMETERS(math_param_limit_above_kern, size_id, 0, lvl); - DEFINE_DMATH_PARAMETERS(math_param_limit_above_kern, size_id, 0, lvl); - DEFINE_MATH_PARAMETERS(math_param_limit_below_vgap, size_id, - font_MATH_par(f, LowerLimitGapMin), lvl); - DEFINE_DMATH_PARAMETERS(math_param_limit_below_vgap, size_id, - font_MATH_par(f, LowerLimitGapMin), lvl); - DEFINE_MATH_PARAMETERS(math_param_limit_below_bgap, size_id, - font_MATH_par(f, LowerLimitBaselineDropMin), - lvl); - DEFINE_DMATH_PARAMETERS(math_param_limit_below_bgap, size_id, - font_MATH_par(f, LowerLimitBaselineDropMin), - lvl); - DEFINE_MATH_PARAMETERS(math_param_limit_below_kern, size_id, 0, lvl); - DEFINE_DMATH_PARAMETERS(math_param_limit_below_kern, size_id, 0, lvl); - - DEFINE_MATH_PARAMETERS(math_param_fraction_rule, size_id, - font_MATH_par(f, FractionRuleThickness), lvl); - DEFINE_DMATH_PARAMETERS(math_param_fraction_rule, size_id, - font_MATH_par(f, FractionRuleThickness), lvl); - DEFINE_MATH_PARAMETERS(math_param_fraction_num_vgap, size_id, - font_MATH_par(f, FractionNumeratorGapMin), lvl); - DEFINE_DMATH_PARAMETERS(math_param_fraction_num_vgap, size_id, - font_MATH_par(f, - FractionNumeratorDisplayStyleGapMin), - lvl); - DEFINE_MATH_PARAMETERS(math_param_fraction_num_up, size_id, - font_MATH_par(f, FractionNumeratorShiftUp), lvl); - DEFINE_DMATH_PARAMETERS(math_param_fraction_num_up, size_id, - font_MATH_par(f, - FractionNumeratorDisplayStyleShiftUp), - lvl); - DEFINE_MATH_PARAMETERS(math_param_fraction_denom_vgap, size_id, - font_MATH_par(f, FractionDenominatorGapMin), - lvl); - DEFINE_DMATH_PARAMETERS(math_param_fraction_denom_vgap, size_id, - font_MATH_par(f, - FractionDenominatorDisplayStyleGapMin), - lvl); - DEFINE_MATH_PARAMETERS(math_param_fraction_denom_down, size_id, - font_MATH_par(f, FractionDenominatorShiftDown), - lvl); - DEFINE_DMATH_PARAMETERS(math_param_fraction_denom_down, size_id, - font_MATH_par(f, - FractionDenominatorDisplayStyleShiftDown), - lvl); - - DEFINE_MATH_PARAMETERS(math_param_fraction_del_size, size_id, - font_MATH_par(f, FractionDelimiterSize), lvl); - DEFINE_DMATH_PARAMETERS(math_param_fraction_del_size, size_id, - font_MATH_par(f, - FractionDelimiterDisplayStyleSize), - lvl); - - DEFINE_MATH_PARAMETERS(math_param_space_after_script, size_id, - font_MATH_par(f, SpaceAfterScript), lvl); - DEFINE_DMATH_PARAMETERS(math_param_space_after_script, size_id, - font_MATH_par(f, SpaceAfterScript), lvl); - - DEFINE_MATH_PARAMETERS(math_param_connector_overlap_min, size_id, - font_MATH_par(f, MinConnectorOverlap), lvl); - DEFINE_DMATH_PARAMETERS(math_param_connector_overlap_min, size_id, - font_MATH_par(f, MinConnectorOverlap), lvl); - - - } else if (fam_id == 2 && is_old_mathfont(f, total_mathsy_params)) { - /* fix old-style |sy| parameters */ - DEFINE_MATH_PARAMETERS(math_param_quad, size_id, math_quad(size_id), - lvl); - DEFINE_DMATH_PARAMETERS(math_param_quad, size_id, math_quad(size_id), - lvl); - DEFINE_MATH_PARAMETERS(math_param_axis, size_id, axis_height(size_id), - lvl); - DEFINE_DMATH_PARAMETERS(math_param_axis, size_id, axis_height(size_id), - lvl); - DEFINE_MATH_PARAMETERS(math_param_stack_num_up, size_id, num3(size_id), - lvl); - DEFINE_DMATH_PARAMETERS(math_param_stack_num_up, size_id, num1(size_id), - lvl); - DEFINE_MATH_PARAMETERS(math_param_stack_denom_down, size_id, - denom2(size_id), lvl); - DEFINE_DMATH_PARAMETERS(math_param_stack_denom_down, size_id, - denom1(size_id), lvl); - DEFINE_MATH_PARAMETERS(math_param_fraction_num_up, size_id, - num2(size_id), lvl); - DEFINE_DMATH_PARAMETERS(math_param_fraction_num_up, size_id, - num1(size_id), lvl); - DEFINE_MATH_PARAMETERS(math_param_fraction_denom_down, size_id, - denom2(size_id), lvl); - DEFINE_DMATH_PARAMETERS(math_param_fraction_denom_down, size_id, - denom1(size_id), lvl); - DEFINE_MATH_PARAMETERS(math_param_fraction_del_size, size_id, - delim2(size_id), lvl); - DEFINE_DMATH_PARAMETERS(math_param_fraction_del_size, size_id, - delim1(size_id), lvl); - if (size_id == text_size) { - def_math_param(math_param_sup_shift_up, display_style, - sup1(size_id), lvl); - def_math_param(math_param_sup_shift_up, cramped_display_style, - sup3(size_id), lvl); - def_math_param(math_param_sup_shift_up, text_style, sup2(size_id), - lvl); - def_math_param(math_param_sup_shift_up, cramped_text_style, - sup3(size_id), lvl); - } else if (size_id == script_size) { - def_math_param(math_param_sub_shift_drop, display_style, - sub_drop(size_id), lvl); - def_math_param(math_param_sub_shift_drop, cramped_display_style, - sub_drop(size_id), lvl); - def_math_param(math_param_sub_shift_drop, text_style, - sub_drop(size_id), lvl); - def_math_param(math_param_sub_shift_drop, cramped_text_style, - sub_drop(size_id), lvl); - def_math_param(math_param_sup_shift_drop, display_style, - sup_drop(size_id), lvl); - def_math_param(math_param_sup_shift_drop, cramped_display_style, - sup_drop(size_id), lvl); - def_math_param(math_param_sup_shift_drop, text_style, - sup_drop(size_id), lvl); - def_math_param(math_param_sup_shift_drop, cramped_text_style, - sup_drop(size_id), lvl); - def_math_param(math_param_sup_shift_up, script_style, sup2(size_id), - lvl); - def_math_param(math_param_sup_shift_up, cramped_script_style, - sup3(size_id), lvl); - } else if (size_id == script_script_size) { - def_math_param(math_param_sub_shift_drop, script_style, - sub_drop(size_id), lvl); - def_math_param(math_param_sub_shift_drop, cramped_script_style, - sub_drop(size_id), lvl); - def_math_param(math_param_sub_shift_drop, script_script_style, - sub_drop(size_id), lvl); - def_math_param(math_param_sub_shift_drop, - cramped_script_script_style, sub_drop(size_id), lvl); - def_math_param(math_param_sup_shift_drop, script_style, - sup_drop(size_id), lvl); - def_math_param(math_param_sup_shift_drop, cramped_script_style, - sup_drop(size_id), lvl); - def_math_param(math_param_sup_shift_drop, script_script_style, - sup_drop(size_id), lvl); - def_math_param(math_param_sup_shift_drop, - cramped_script_script_style, sup_drop(size_id), lvl); - def_math_param(math_param_sup_shift_up, script_script_style, - sup2(size_id), lvl); - def_math_param(math_param_sup_shift_up, cramped_script_script_style, - sup3(size_id), lvl); - } - DEFINE_MATH_PARAMETERS(math_param_sub_shift_down, size_id, - sub1(size_id), lvl); - DEFINE_DMATH_PARAMETERS(math_param_sub_shift_down, size_id, - sub1(size_id), lvl); - DEFINE_MATH_PARAMETERS(math_param_sub_sup_shift_down, size_id, - sub2(size_id), lvl); - DEFINE_DMATH_PARAMETERS(math_param_sub_sup_shift_down, size_id, - sub2(size_id), lvl); - DEFINE_MATH_PARAMETERS(math_param_sub_top_max, size_id, - (abs(math_x_height(size_id) * 4) / 5), lvl); - DEFINE_DMATH_PARAMETERS(math_param_sub_top_max, size_id, - (abs(math_x_height(size_id) * 4) / 5), lvl); - DEFINE_MATH_PARAMETERS(math_param_sup_bottom_min, size_id, - (abs(math_x_height(size_id)) / 4), lvl); - DEFINE_DMATH_PARAMETERS(math_param_sup_bottom_min, size_id, - (abs(math_x_height(size_id)) / 4), lvl); - DEFINE_MATH_PARAMETERS(math_param_sup_sub_bottom_max, size_id, - (abs(math_x_height(size_id) * 4) / 5), 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. */ - DEFINE_DMATH_PARAMETERS(math_param_radical_vgap, size_id, - (default_rule_thickness(size_id) + - (abs(math_x_height(size_id)) / 4)), lvl); - - DEFINE_MATH_PARAMETERS(math_param_radical_degree_raise, size_id, - 60, lvl); - DEFINE_DMATH_PARAMETERS(math_param_radical_degree_raise, size_id, - 60, lvl); - DEFINE_MATH_PARAMETERS(math_param_radical_degree_before, size_id, - xn_over_d(get_math_quad_size(size_id), 5, 18), - lvl); - DEFINE_DMATH_PARAMETERS(math_param_radical_degree_before, size_id, - xn_over_d(get_math_quad_size(size_id), 5, 18), - lvl); - DEFINE_MATH_PARAMETERS(math_param_radical_degree_after, size_id, - (-xn_over_d - (get_math_quad_size(size_id), 10, 18)), lvl); - DEFINE_DMATH_PARAMETERS(math_param_radical_degree_after, size_id, - (-xn_over_d - (get_math_quad_size(size_id), 10, 18)), lvl); - - } else if (fam_id == 3 && is_old_mathfont(f, total_mathex_params)) { - /* fix old-style |ex| parameters */ - DEFINE_MATH_PARAMETERS(math_param_overbar_kern, size_id, - default_rule_thickness(size_id), lvl); - DEFINE_MATH_PARAMETERS(math_param_overbar_rule, size_id, - default_rule_thickness(size_id), lvl); - DEFINE_MATH_PARAMETERS(math_param_overbar_vgap, size_id, - 3 * default_rule_thickness(size_id), lvl); - DEFINE_DMATH_PARAMETERS(math_param_overbar_kern, size_id, - default_rule_thickness(size_id), lvl); - DEFINE_DMATH_PARAMETERS(math_param_overbar_rule, size_id, - default_rule_thickness(size_id), lvl); - DEFINE_DMATH_PARAMETERS(math_param_overbar_vgap, size_id, - 3 * default_rule_thickness(size_id), lvl); - DEFINE_MATH_PARAMETERS(math_param_underbar_kern, size_id, - default_rule_thickness(size_id), lvl); - DEFINE_MATH_PARAMETERS(math_param_underbar_rule, size_id, - default_rule_thickness(size_id), lvl); - DEFINE_MATH_PARAMETERS(math_param_underbar_vgap, size_id, - 3 * default_rule_thickness(size_id), lvl); - DEFINE_DMATH_PARAMETERS(math_param_underbar_kern, size_id, - default_rule_thickness(size_id), lvl); - DEFINE_DMATH_PARAMETERS(math_param_underbar_rule, size_id, - default_rule_thickness(size_id), lvl); - DEFINE_DMATH_PARAMETERS(math_param_underbar_vgap, size_id, - 3 * default_rule_thickness(size_id), lvl); - DEFINE_MATH_PARAMETERS(math_param_radical_kern, size_id, - default_rule_thickness(size_id), lvl); - DEFINE_DMATH_PARAMETERS(math_param_radical_kern, size_id, - default_rule_thickness(size_id), lvl); - - DEFINE_MATH_PARAMETERS(math_param_radical_vgap, size_id, - (default_rule_thickness(size_id) + - (abs(default_rule_thickness(size_id)) / 4)), - lvl); - - DEFINE_MATH_PARAMETERS(math_param_stack_vgap, size_id, - 3 * default_rule_thickness(size_id), lvl); - DEFINE_DMATH_PARAMETERS(math_param_stack_vgap, size_id, - 7 * default_rule_thickness(size_id), lvl); - DEFINE_MATH_PARAMETERS(math_param_fraction_rule, size_id, - default_rule_thickness(size_id), lvl); - DEFINE_DMATH_PARAMETERS(math_param_fraction_rule, size_id, - default_rule_thickness(size_id), lvl); - DEFINE_MATH_PARAMETERS(math_param_fraction_num_vgap, size_id, - default_rule_thickness(size_id), lvl); - DEFINE_DMATH_PARAMETERS(math_param_fraction_num_vgap, size_id, - 3 * default_rule_thickness(size_id), lvl); - DEFINE_MATH_PARAMETERS(math_param_fraction_denom_vgap, size_id, - default_rule_thickness(size_id), lvl); - DEFINE_DMATH_PARAMETERS(math_param_fraction_denom_vgap, size_id, - 3 * default_rule_thickness(size_id), lvl); - DEFINE_MATH_PARAMETERS(math_param_limit_above_vgap, size_id, - big_op_spacing1(size_id), lvl); - DEFINE_DMATH_PARAMETERS(math_param_limit_above_vgap, size_id, - big_op_spacing1(size_id), lvl); - DEFINE_MATH_PARAMETERS(math_param_limit_above_bgap, size_id, - big_op_spacing3(size_id), lvl); - DEFINE_DMATH_PARAMETERS(math_param_limit_above_bgap, size_id, - big_op_spacing3(size_id), lvl); - DEFINE_MATH_PARAMETERS(math_param_limit_above_kern, size_id, - big_op_spacing5(size_id), lvl); - DEFINE_DMATH_PARAMETERS(math_param_limit_above_kern, size_id, - big_op_spacing5(size_id), lvl); - DEFINE_MATH_PARAMETERS(math_param_limit_below_vgap, size_id, - big_op_spacing2(size_id), lvl); - DEFINE_DMATH_PARAMETERS(math_param_limit_below_vgap, size_id, - big_op_spacing2(size_id), lvl); - DEFINE_MATH_PARAMETERS(math_param_limit_below_bgap, size_id, - big_op_spacing4(size_id), lvl); - DEFINE_DMATH_PARAMETERS(math_param_limit_below_bgap, size_id, - big_op_spacing4(size_id), lvl); - DEFINE_MATH_PARAMETERS(math_param_limit_below_kern, size_id, - big_op_spacing5(size_id), lvl); - DEFINE_DMATH_PARAMETERS(math_param_limit_below_kern, size_id, - big_op_spacing5(size_id), lvl); - DEFINE_MATH_PARAMETERS(math_param_subsup_vgap, size_id, - 4 * default_rule_thickness(size_id), 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 - */ - DEFINE_MATH_PARAMETERS(math_param_connector_overlap_min, size_id, 0, - lvl); - DEFINE_DMATH_PARAMETERS(math_param_connector_overlap_min, size_id, 0, - lvl); - - DEFINE_MATH_PARAMETERS(math_param_under_delimiter_vgap, size_id, - big_op_spacing2(size_id), lvl); - DEFINE_DMATH_PARAMETERS(math_param_under_delimiter_vgap, size_id, - big_op_spacing2(size_id), lvl); - DEFINE_MATH_PARAMETERS(math_param_under_delimiter_bgap, size_id, - big_op_spacing4(size_id), lvl); - DEFINE_DMATH_PARAMETERS(math_param_under_delimiter_bgap, size_id, - big_op_spacing4(size_id), lvl); - DEFINE_MATH_PARAMETERS(math_param_over_delimiter_vgap, size_id, - big_op_spacing1(size_id), lvl); - DEFINE_DMATH_PARAMETERS(math_param_over_delimiter_vgap, size_id, - big_op_spacing1(size_id), lvl); - DEFINE_MATH_PARAMETERS(math_param_over_delimiter_bgap, size_id, - big_op_spacing3(size_id), 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. */ - DEFINE_DMATH_PARAMETERS(math_param_radical_vgap, size_id, - (default_rule_thickness(size_id) + - (abs(math_x_height(size_id)) / 4)), lvl); - } -} - -@ 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 = int_par(tracing_assigns_code); - int_par(tracing_assigns_code) = 0; - if (get_math_param(math_param_space_after_script, display_style) == - undefined_math_parameter) { - def_math_param(math_param_space_after_script, display_style, - script_space, level_one); - def_math_param(math_param_space_after_script, text_style, - script_space, level_one); - def_math_param(math_param_space_after_script, script_style, - script_space, level_one); - def_math_param(math_param_space_after_script, script_script_style, - script_space, level_one); - def_math_param(math_param_space_after_script, cramped_display_style, - script_space, level_one); - def_math_param(math_param_space_after_script, cramped_text_style, - script_space, level_one); - def_math_param(math_param_space_after_script, cramped_script_style, - script_space, level_one); - def_math_param(math_param_space_after_script, - cramped_script_script_style, script_space, level_one); - } - int_par(tracing_assigns_code) = saved_trace; - -} - - -@ 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.) - -@c -static const char *math_size_string(int s) -{ - if (s == text_size) - return "textfont"; - else if (s == script_size) - return "scriptfont"; - else - return "scriptscriptfont"; -} - -@ 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; \ - else if (a==script_script_style || \ - a==cramped_script_script_style) \ - cur_size=script_script_size; \ - else cur_size=text_size; \ - } while (0) - - -@ a simple routine that creates a flat copy of a nucleus -@c -static pointer math_clone(pointer q) -{ - pointer x; - if (q == null) - return null; - x = new_node(type(q), 0); - reset_attributes(x, node_attr(q)); - if (type(q) == math_char_node) { - math_fam(x) = math_fam(q); - math_character(x) = math_character(q); - } else { - math_list(x) = math_list(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. - -@c -static pointer do_fraction_rule(scaled t, pointer att) -{ - pointer p; /* the new node */ - p = new_rule(); - rule_dir(p) = math_direction; - height(p) = t; - depth(p) = 0; - reset_attributes(p, att); - 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|. - -@c -static pointer overbar(pointer b, scaled k, scaled t, scaled ht, pointer att) -{ - pointer p, q; /* nodes being constructed */ - p = new_kern(k); - vlink(p) = b; - reset_attributes(p, att); - q = do_fraction_rule(t, att); - vlink(q) = p; - p = new_kern(ht); - reset_attributes(p, att); - vlink(p) = q; - q = vpackage(p, 0, additional, max_dimen, math_direction); - reset_attributes(q, att); - 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. - -@c -static pointer char_box(internal_font_number f, int c, pointer bb) -{ - pointer b, p; /* the new box and its character node */ - b = new_null_box(); - width(b) = char_width(f, c) + char_italic(f, c); - height(b) = char_height(f, c); - depth(b) = char_depth(f, c); - reset_attributes(b, bb); - p = new_char(f, c); - reset_attributes(p, bb); - list_ptr(b) = p; - return b; -} - -@ 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|: - -@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)); - if (type(b) == vlist_node) { - vlink(p) = list_ptr(b); - list_ptr(b) = p; - height(b) = height(p); - if (width(b) < width(p)) - width(b) = width(p); - return height_plus_depth(f, c); - } else { - q = list_ptr(b); - if (q == null) { - list_ptr(b) = p; - } else { - while (vlink(q) != null) - q = vlink(q); - vlink(q) = p; - } - if (height(b) < height(p)) - height(b) = height(p); - if (depth(b) < depth(p)) - depth(b) = depth(p); - return char_width(f, c); - } -} - -static void stack_glue_into_box(pointer b, scaled min, scaled max) { - pointer p, q; /* new node placed into |b| */ - q = new_spec(zero_glue); - width(q) = min; - stretch(q) = max-min; - p = new_glue(q); - reset_attributes(p, node_attr(b)); - if (type(b) == vlist_node) { - vlink(p) = list_ptr(b); - list_ptr(b) = p; - height(b) = height(p); - } else { - q = list_ptr(b); - if (q == null) { - list_ptr(b) = p; - } else { - while (vlink(q) != null) - q = vlink(q); - vlink(q) = p; - } - if (height(b) < height(p)) - height(b) = height(p); - if (depth(b) < depth(p)) - depth(b) = depth(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(extinfo * ext, internal_font_number f, scaled v, - pointer att, int boxtype, int cur_style) -{ - pointer b; /* new box */ - scaled b_max; /* natural (maximum) size of the stack */ - scaled s_max; /* amount of possible shrink in the stack */ - 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| */ - 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; - - cur = ext; - while (cur != NULL) { - if (!char_exists(f, 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!", - NULL - }; - tex_error("Variant part doesn't exist.", hlp); - width(b) = null_delimiter_space; - return b; - } - if (cur->extender > 0) - num_extenders++; - else - num_normal++; - /* 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.", - "To get around this problem, I have changed the font metrics.", - "Fix your font!", - NULL - }; - tex_error("Extensible recipe has negative fields.", hlp); - if (cur->start_overlap < 0) - cur->start_overlap = 0; - if (cur->end_overlap < 0) - cur->end_overlap = 0; - if (cur->advance < 0) - cur->advance = 0; - } - cur = cur->next; - } - if (num_normal == 0) { - const char *hlp[] = { - "Each extensible recipe should have at least one non-repeatable part.", - "To get around this problem, I have changed the first part to be", - "non-repeatable. Fix your font!", - NULL - }; - tex_error("Extensible recipe has no fixed parts.", hlp); - ext->extender = 0; - num_normal = 1; - num_extenders--; - } - /* |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. - */ - cur = ext; - b_max = 0; - while (b_max < v && num_extenders > 0) { - b_max = 0; - prev_overlap = 0; - with_extenders++; - for (cur = ext; cur != NULL; cur = cur->next) { - if (cur->extender == 0) { - c = cur->start_overlap; - if (min_overlap < c) - c = min_overlap; - if (prev_overlap < c) - 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); - } - b_max += a - c; - prev_overlap = cur->end_overlap; - } else { - i = with_extenders; - while (i > 0) { - c = cur->start_overlap; - if (min_overlap < c) - c = min_overlap; - if (prev_overlap < c) - 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); - } - b_max += a - c; - prev_overlap = cur->end_overlap; - i--; - } - } - } - } - - /* assemble box using |with_extenders| copies of each extender, with - appropriate glue wherever an overlap occurs */ - prev_overlap = 0; - b_max = 0; - s_max = 0; - for (cur = ext; cur != NULL; cur = cur->next) { - if (cur->extender == 0) { - c = cur->start_overlap; - if (prev_overlap < c) - c = prev_overlap; - d = c; - if (min_overlap < c) - c = min_overlap; - if (d > 0) { - stack_glue_into_box(b, -d, -c); - s_max += (-c) - (-d); - b_max -= d; - } - b_max += stack_into_box(b, f, cur->glyph); - prev_overlap = cur->end_overlap; - i--; - } else { - i = with_extenders; - while (i > 0) { - c = cur->start_overlap; - if (prev_overlap < c) - c = prev_overlap; - d = c; - if (min_overlap < c) - c = min_overlap; - if (d > 0) { - stack_glue_into_box(b, -d, -c); - s_max += (-c) - (-d); - b_max -= d; - } - b_max += stack_into_box(b, f, cur->glyph); - prev_overlap = cur->end_overlap; - i--; - } - } - } - - /* 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| */ - if (d > s_max) - d = s_max; - glue_order(b) = normal; - glue_sign(b) = stretching; - glue_set(b) = unfloat(d/(float) s_max); - b_max += d; - } - - if (boxtype == vlist_node) - height(b) = b_max; - else - width(b) = b_max; - - return b; -} - -static pointer get_delim_vbox(extinfo * ext, internal_font_number f, scaled v, - pointer att, int cur_style) -{ - return get_delim_box(ext, f, v, att, vlist_node, cur_style); -} - -static pointer get_delim_hbox(extinfo * ext, internal_font_number f, scaled v, - pointer att, int cur_style) -{ - return get_delim_box(ext, f, v, att, hlist_node, cur_style); -} - - - -@ 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 -static void endless_loop_error(internal_font_number g, int y) -{ - char s[256]; - const char *hlp[] = { - "You managed to create a seemingly endless charlist chain in the current", - "font. I have counted until 10000 already and still have not escaped, so" - "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)); - tex_error(s, hlp); -} - -static pointer do_var_delimiter(pointer d, int s, scaled v, scaled * ic, - boolean flat, int cur_style) -{ - /* label found,continue; */ - 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; /* largest height-plus-depth so far */ - int z; /* runs through font family members */ - boolean large_attempt; /* are we trying the ``large'' variant? */ - pointer att; /* to save the current attribute list */ - boolean do_parts; - extinfo *ext; - att = null; - f = null_font; - c = 0; - w = 0; - do_parts = false; - large_attempt = false; - if (d == null) - goto FOUND; - z = small_fam(d); - x = small_char(d); - i = 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. */ - if ((z != 0) || (x != 0)) { - g = fam_fnt(z, s); - if (g != null_font) { - y = x; - CONTINUE: - i++; - if (char_exists(g, y)) { - if (flat) - u = char_width(g, y); - else - u = height_plus_depth(g, y); - if (u > w) { - f = g; - c = y; - w = u; - if (u >= v) - goto FOUND; - } - if (char_tag(g, y) == ext_tag) { - f = g; - c = y; - do_parts = true; - goto FOUND; - } - if (i > 10000) { - /* endless loop */ - endless_loop_error(g, y); - goto FOUND; - } - if (char_tag(g, y) == list_tag) { - y = char_remainder(g, y); - goto CONTINUE; - } - } - } - } - if (large_attempt) - goto FOUND; /* there were none large enough */ - large_attempt = true; - z = large_fam(d); - x = large_char(d); - } - FOUND: - if (d != null) { - att = node_attr(d); - node_attr(d) = null; - 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. - */ - 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))) { - b = (flat ? get_delim_hbox(ext, f, v, att, cur_style) : - get_delim_vbox(ext, f, v, att, cur_style)); - } else { - b = char_box(f, c, att); - } - /* This next test is because for OT MATH fonts, the italic correction of an - extensible character is only used for the placement of a subscript - (in negated form), and it is not supposed to be added to the - width of the character box at all. - - This has an effect later on in |make_op| as well, where it has to do - an extra correction for |make_script|'s addition of yet another italic - correction. - */ - if (!is_new_mathfont(f)) { - width(b) += char_italic(f, c); - } - if (ic != NULL) - *ic = char_italic(f, c); - } else { - b = new_null_box(); - reset_attributes(b, att); - width(b) = (flat ? 0 : null_delimiter_space); /* use this width if no delimiter was found */ - if (ic != NULL) - *ic = 0; - } - if (!flat) - shift_amount(b) = half(height(b) - depth(b)) - math_axis(s); - delete_attribute_ref(att); - return b; -} - - -static pointer var_delimiter(pointer d, int s, scaled v, scaled * ic, - int cur_style) -{ - return do_var_delimiter(d, s, v, ic, false, cur_style); -} - -static pointer flat_delimiter(pointer d, int s, scaled v, int cur_style) -{ - return do_var_delimiter(d, s, v, NULL, true, cur_style); -} - -@ 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. - -@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 */ - - if ((width(b) != w) && (list_ptr(b) != null)) { - if (type(b) == vlist_node) { - p = hpack(b, 0, additional, -1); - reset_attributes(p, node_attr(b)); - b = p; - } - p = list_ptr(b); - att = node_attr(b); - add_node_attr_ref(att); - if ((is_char_node(p)) && (vlink(p) == null)) { - f = font(p); - v = char_width(f, character(p)); - if (v != width(b)) { - q = new_kern(width(b) - v); - reset_attributes(q, att); - vlink(p) = q; - } - } - list_ptr(b) = null; - flush_node(b); - b = new_glue(ss_glue); - reset_attributes(b, att); - vlink(b) = p; - while (vlink(p) != null) - p = vlink(p); - q = new_glue(ss_glue); - reset_attributes(q, att); - vlink(p) = q; - r = hpack(b, w, exactly, -1); - reset_attributes(r, att); - delete_attribute_ref(att); - return r; - } else { - width(b) = w; - return b; - } -} - -@ 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) -{ - pointer p; /* the new glue specification */ - int n; /* integer part of |m| */ - scaled f; /* fraction part of |m| */ - n = x_over_n(m, unity); - f = tex_remainder; - if (f < 0) { - decr(n); - f = f + unity; - } - p = new_node(glue_spec_node, 0); - width(p) = mu_mult(width(g)); /* convert \.{mu} to \.{pt} */ - stretch_order(p) = stretch_order(g); - if (stretch_order(p) == normal) - stretch(p) = mu_mult(stretch(g)); - else - stretch(p) = stretch(g); - shrink_order(p) = shrink_order(g); - if (shrink_order(p) == normal) - shrink(p) = mu_mult(shrink(g)); - else - shrink(p) = shrink(g); - return p; -} - -@ 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| */ - if (subtype(p) == mu_glue) { - n = x_over_n(m, unity); - f = tex_remainder; - if (f < 0) { - decr(n); - f = f + unity; - } - width(p) = mu_mult(width(p)); - subtype(p) = explicit; - } -} - -@ @c -void run_mlist_to_hlist(halfword p, int mstyle, boolean penalties) -{ - int callback_id; - int a, sfix; - lua_State *L = Luas; - if (p == null) { - vlink(temp_head) = null; - return; - } - finalize_math_parameters(); - callback_id = callback_defined(mlist_to_hlist_callback); - if (callback_id > 0) { - sfix = lua_gettop(L); - if (!get_callback(L, callback_id)) { - lua_settop(L, sfix); - return; - } - nodelist_to_lua(L, p); /* arg 1 */ - lua_pushstring(L, math_style_names[mstyle]); /* arg 2 */ - lua_pushboolean(L, penalties); /* arg 3 */ - if (lua_pcall(L, 3, 1, 0) != 0) { /* 3 args, 1 result */ - fprintf(stdout, "error: %s\n", lua_tostring(L, -1)); - lua_settop(L, sfix); - error(); - return; - } - a = nodelist_from_lua(L); - lua_settop(L, sfix); - vlink(temp_head) = a; - } else if (callback_id == 0) { - mlist_to_hlist_args(p, mstyle, penalties); - } else { - vlink(temp_head) = null; - } -} - -@ 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@> - - -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 */ - switch (type(p)) { - case math_char_node: - mlist = new_noad(); - r = math_clone(p); - nucleus(mlist) = r; - break; - case sub_box_node: - q = math_list(p); - goto FOUND; - break; - case sub_mlist_node: - mlist = math_list(p); - break; - default: - q = new_null_box(); - goto FOUND; - } - mlist_to_hlist_args(mlist, s, false); - q = vlink(temp_head); /* recursive call */ - 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 */ - 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. */ - q = list_ptr(x); - if (is_char_node(q)) { - r = vlink(q); - if (r != null) { - if (vlink(r) == null) { - if (!is_char_node(r)) { - if (type(r) == kern_node) { - /* unneeded italic correction */ - flush_node(r); - vlink(q) = null; - } - } - } - } - } - 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|. - -The outputs of |fetch| are placed in global variables. - -@c -internal_font_number cur_f; /* the |font| field of a |math_char| */ -int cur_c; /* the |character| field of a |math_char| */ - -static void fetch(pointer a) -{ /* unpack the |math_char| field |a| */ - cur_c = math_character(a); - cur_f = fam_fnt(math_fam(a), cur_size); - if (cur_f == null_font) { - char *msg; - const char *hlp[] = { - "Somewhere in the math formula just ended, you used the", - "stated character from an undefined font family. For example,", - "plain TeX doesn't allow \\it or \\sl in subscripts. Proceed,", - "and I'll try to forget that I needed that character.", - NULL - }; - msg = xmalloc(256); - snprintf(msg, 255, "\\%s%d is undefined (character %d)", - math_size_string(cur_size), (int) math_fam(a), (int) cur_c); - tex_error(msg, hlp); - free(msg); - } else { - if (!(char_exists(cur_f, cur_c))) { - char_warning(cur_f, cur_c); - } - } -} - - -@ 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 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; - } - 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. - -@c -static void make_over(pointer q, int cur_style) -{ - pointer p; - 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_list(nucleus(q)) = p; - type(nucleus(q)) = sub_box_node; -} - -static void make_under(pointer q, int cur_style) -{ - pointer p, x, y, r; /* temporary registers for box construction */ - scaled delta; /* overall height plus depth */ - x = clean_box(nucleus(q), cur_style, cur_style); - p = new_kern(underbar_vgap(cur_style)); - reset_attributes(p, node_attr(q)); - vlink(x) = p; - r = do_fraction_rule(underbar_rule(cur_style), node_attr(q)); - vlink(p) = r; - y = vpackage(x, 0, additional, max_dimen, math_direction); - reset_attributes(y, node_attr(q)); - delta = height(y) + depth(y) + underbar_kern(cur_style); - height(y) = height(x); - depth(y) = delta - height(y); - math_list(nucleus(q)) = y; - type(nucleus(q)) = sub_box_node; -} - -static void make_vcenter(pointer q) -{ - pointer v; /* the box that should be centered vertically */ - scaled delta; /* its height plus depth */ - v = math_list(nucleus(q)); - if (type(v) != vlist_node) - confusion("vcenter"); /* this can't happen vcenter */ - delta = height(v) + depth(v); - height(v) = math_axis(cur_size) + half(delta); - 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. - -@c -static void make_radical(pointer q, int cur_style) -{ - pointer x, y, p; /* temporary registers for box construction */ - scaled delta, clr, theta, h; /* dimensions involved in the calculation */ - x = clean_box(nucleus(q), cramped_style(cur_style), cur_style); - clr = radical_vgap(cur_style); - theta = radical_rule(cur_style); - if (theta == undefined_math_parameter) { - theta = fraction_rule(cur_style); - y = var_delimiter(left_delimiter(q), cur_size, - height(x) + depth(x) + clr + theta, NULL, cur_style); - /* If |y| is a composite then set |theta| to the height of its top - character, else set it to the height of |y|. */ - if (list_ptr(y) != null - && type(list_ptr(y)) == hlist_node - && list_ptr(list_ptr(y)) != null - && type(list_ptr(list_ptr(y))) == glyph_node) { /* and it should be */ - theta = char_height(font(list_ptr(list_ptr(y))), - character(list_ptr(list_ptr(y)))); - } else { - theta = height(y); - } - } else { - y = var_delimiter(left_delimiter(q), cur_size, - height(x) + depth(x) + clr + theta, NULL, cur_style); - } - left_delimiter(q) = null; - delta = (depth(y) + height(y) - theta) - (height(x) + depth(x) + clr); - if (delta > 0) - clr = clr + half(delta); /* increase the actual clearance */ - 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)); - vlink(y) = p; - if (degree(q) != null) { - scaled wr, br, ar; - pointer r = clean_box(degree(q), script_script_style, cur_style); - reset_attributes(r, node_attr(degree(q))); - wr = width(r); - if (wr == 0) { - flush_node(r); - } else { - br = radical_degree_before(cur_style); - ar = radical_degree_after(cur_style); - if (-ar > (wr + br)) - ar = -(wr + br); - x = new_kern(ar); - reset_attributes(x, node_attr(degree(q))); - vlink(x) = y; - shift_amount(r) = - -((xn_over_d(h, radical_degree_raise(cur_style), 100)) - - depth(y) - shift_amount(y)); - vlink(r) = x; - x = new_kern(br); - reset_attributes(x, node_attr(degree(q))); - vlink(x) = r; - y = x; - } - math_list(degree(q)) = null; /* for \.{\\Uroot ..{<list>}{}} */ - flush_node(degree(q)); - } - p = hpack(y, 0, additional, -1); - reset_attributes(p, node_attr(q)); - math_list(nucleus(q)) = p; - type(nucleus(q)) = sub_box_node; -} - - -@ Construct a vlist box -@c -static pointer -wrapup_delimiter(pointer x, pointer y, pointer q, - scaled shift_up, scaled shift_down) -{ - pointer p; /* temporary register for box construction */ - pointer v = new_null_box(); - type(v) = vlist_node; - height(v) = shift_up + height(x); - depth(v) = depth(y) + shift_down; - reset_attributes(v, node_attr(q)); - p = new_kern((shift_up - depth(x)) - (height(y) - shift_down)); - reset_attributes(p, node_attr(q)); - vlink(p) = y; - vlink(x) = p; - list_ptr(v) = x; - return v; -} - -@ @c -#define fixup_widths(x,y) do { \ - if (width(y) >= width(x)) { \ - width(x) = width(y); \ - } else { \ - width(y) = width(x); \ - } \ - } while (0) - -@ 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 */ - scaled shift_up, shift_down, clr, delta; - x = clean_box(nucleus(q), sub_style(cur_style), cur_style); - y = flat_delimiter(left_delimiter(q), cur_size, width(x), cur_style); - left_delimiter(q) = null; - fixup_widths(x, y); - shift_up = over_delimiter_bgap(cur_style); - shift_down = 0; - clr = over_delimiter_vgap(cur_style); - delta = clr - ((shift_up - depth(x)) - (height(y) - shift_down)); - if (delta > 0) { - shift_up = shift_up + delta; - } - v = wrapup_delimiter(x, y, q, shift_up, shift_down); - width(v) = width(x); /* this also equals |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| - -@c -static void make_delimiter_over(pointer q, int cur_style) -{ - pointer x, y, v; /* temporary registers for box construction */ - scaled shift_up, shift_down, clr, actual; - y = clean_box(nucleus(q), cur_style, cur_style); - x = flat_delimiter(left_delimiter(q), - cur_size + (cur_size == script_script_size ? 0 : 1), - width(y), cur_style); - left_delimiter(q) = null; - fixup_widths(x, y); - shift_up = over_delimiter_bgap(cur_style)-height(x)-depth(x); - shift_down = 0; - clr = over_delimiter_vgap(cur_style); - actual = shift_up - height(y); - if (actual < clr) { - shift_up = shift_up + (clr-actual); - } - v = wrapup_delimiter(x, y, q, shift_up, shift_down); - width(v) = width(x); /* this also equals |width(y)| */ - 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| - -@c -static void make_delimiter_under(pointer q, int cur_style) -{ - pointer x, y, v; /* temporary registers for box construction */ - scaled shift_up, shift_down, clr, actual; - x = clean_box(nucleus(q), cur_style, cur_style); - y = flat_delimiter(left_delimiter(q), - cur_size + (cur_size == script_script_size ? 0 : 1), - width(x), cur_style); - left_delimiter(q) = null; - fixup_widths(x, y); - shift_up = 0; - shift_down = under_delimiter_bgap(cur_style) - height(y)-depth(y); - clr = under_delimiter_vgap(cur_style); - actual = shift_down - depth(x); - if (actual<clr) { - shift_down += (clr-actual); - } - v = wrapup_delimiter(x, y, q, shift_up, shift_down); - width(v) = width(y); /* this also equals |width(y)| */ - math_list(nucleus(q)) = v; - type(nucleus(q)) = sub_box_node; - -} - -@ 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 */ - scaled shift_up, shift_down, clr, delta; - y = clean_box(nucleus(q), sup_style(cur_style), cur_style); - x = flat_delimiter(left_delimiter(q), cur_size, width(y), cur_style); - left_delimiter(q) = null; - fixup_widths(x, y); - shift_up = 0; - shift_down = under_delimiter_bgap(cur_style); - clr = under_delimiter_vgap(cur_style); - delta = clr - ((shift_up - depth(x)) - (height(y) - shift_down)); - if (delta > 0) { - shift_down = shift_down + delta; - } - v = wrapup_delimiter(x, y, q, shift_up, shift_down); - width(v) = width(y); /* this also equals |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. - -@c -#define TOP_CODE 1 -#define BOT_CODE 2 -#define TOP_OR_BOT_MASK ((TOP_CODE) | (BOT_CODE)) -#define STRETCH_ACCENT_CODE 4 - -static boolean compute_accent_skew(pointer q, int top_or_bot, scaled *s) -{ - pointer p; /* temporary register for box construction */ - boolean s_is_absolute; /* will be true if a top-accent is placed in |s| */ - - s_is_absolute = false; - - if (type(nucleus(q)) == math_char_node) { - fetch(nucleus(q)); - if (is_new_mathfont(cur_f)) { - if (top_or_bot == TOP_CODE) { - *s = char_top_accent(cur_f, cur_c); - if (*s != INT_MIN) { - s_is_absolute = true; - } - } else { - *s = char_bot_accent(cur_f, cur_c); - if (*s != INT_MIN) { - s_is_absolute = true; - } - } - } else { - if (top_or_bot == TOP_CODE) { - *s = get_kern(cur_f, cur_c, skew_char(cur_f)); - } else { - *s = 0; - } - } - } 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. */ - p = math_list(nucleus(q)); - if (type(p) == accent_noad) { - s_is_absolute = compute_accent_skew(p, top_or_bot, s); - } - } - - return s_is_absolute; -} - -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| */ - extinfo *ext; - pointer attr_p; - const int top_or_bot = flags & TOP_OR_BOT_MASK; - attr_p = (top_or_bot == TOP_CODE ? accent_chr(q) : bot_accent_chr(q)); - c = cur_c; - f = cur_f; - - s = 0; - s_is_absolute = false; - /* Compute the amount of skew, or set |s| to an alignment point */ - s_is_absolute = compute_accent_skew(q, top_or_bot, &s); - - x = clean_box(nucleus(q), cramped_style(cur_style), cur_style); - w = width(x); - h = height(x); - if (is_new_mathfont(cur_f) && !s_is_absolute) { - s = half(w); - s_is_absolute = true; - } - /* Switch to a larger accent if available and appropriate */ - y = null; - ext = NULL; - 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)) { - y = get_delim_hbox(ext, f, w, node_attr(attr_p), cur_style); - break; - } else if (char_tag(f, c) != list_tag) { - break; - } else { - int yy = char_remainder(f, c); - if (!char_exists(f, yy)) - break; - if (char_width(f, yy) > w) - break; - c = yy; - } - } - } - if (y == null) { - y = char_box(f, c, node_attr(attr_p)); - } - if (top_or_bot == TOP_CODE) { - if (h < accent_base_height(f)) - delta = h; - else - delta = accent_base_height(f); - } 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| */ - flush_node_list(x); - x = new_noad(); - r = math_clone(nucleus(q)); - nucleus(x) = r; - supscr(x) = supscr(q); - supscr(q) = null; - subscr(x) = subscr(q); - subscr(q) = null; - type(nucleus(q)) = sub_mlist_node; - math_list(nucleus(q)) = x; - x = clean_box(nucleus(q), cur_style, cur_style); - delta = delta + height(x) - h; - h = height(x); - } - } - if (s_is_absolute) { - scaled sa; - if (ext != NULL) { - sa = half(width(y)); /* if the accent is extensible just take the center */ - } else { - sa = char_top_accent(f, c); - } - if (sa == INT_MIN) { - sa = half(width(y)); /* just take the center */ - } - shift_amount(y) = s - sa; - } else { - if (width(y)== 0) { - shift_amount(y) = s + w; - } else { - shift_amount(y) = s + half(w - width(y)); - } - } - width(y) = 0; - if (top_or_bot == TOP_CODE) { - p = new_kern(-delta); - vlink(p) = x; - vlink(y) = p; - } else { -#if 0 - p = new_kern(-delta); - vlink(x) = p; - vlink(p) = y; - y = x; -#endif - vlink(x) = y; - y = x; - } - r = vpackage(y, 0, additional, max_dimen, math_direction); - reset_attributes(r, node_attr(q)); - width(r) = width(x); - y = r; - if (top_or_bot == TOP_CODE) { - if (height(y) < h) { - /* Make the height of box |y| equal to |h| */ - p = new_kern(h - height(y)); - reset_attributes(p, node_attr(q)); - vlink(p) = list_ptr(y); - list_ptr(y) = p; - height(y) = h; - } - } else { - shift_amount(y) = -(h - height(y)); - } - math_list(nucleus(q)) = y; - type(nucleus(q)) = sub_box_node; -} - -static void make_math_accent(pointer q, int cur_style) -{ - int topstretch = !(subtype(q) % 2); - int botstretch = !(subtype(q) / 2); - - if (accent_chr(q) != null) { - fetch(accent_chr(q)); - if (char_exists(cur_f, cur_c)) { - do_make_math_accent(q, cur_f, cur_c, TOP_CODE | (topstretch ? STRETCH_ACCENT_CODE : 0), cur_style); - } - flush_node(accent_chr(q)); - accent_chr(q) = null; - } - if (bot_accent_chr(q) != null) { - fetch(bot_accent_chr(q)); - if (char_exists(cur_f, cur_c)) { - do_make_math_accent(q, cur_f, cur_c, BOT_CODE | (botstretch ? STRETCH_ACCENT_CODE : 0), cur_style); - } - flush_node(bot_accent_chr(q)); - bot_accent_chr(q) = null; - } -} - -@ 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, v, x, y, z; /* temporary registers for box construction */ - scaled delta, delta1, delta2, shift_up, shift_down, clr; - /* dimensions for box calculations */ - if (thickness(q) == default_code) - thickness(q) = fraction_rule(cur_style); - /* 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 */ - x = clean_box(numerator(q), num_style(cur_style), cur_style); - z = clean_box(denominator(q), denom_style(cur_style), cur_style); - if (width(x) < width(z)) - x = rebox(x, width(z)); - else - z = rebox(z, width(x)); - 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|. */ - clr = stack_vgap(cur_style); - delta = half(clr - ((shift_up - depth(x)) - (height(z) - shift_down))); - if (delta > 0) { - shift_up = shift_up + delta; - shift_down = shift_down + delta; - } - } 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. */ - delta = half(thickness(q)); - clr = fraction_num_vgap(cur_style); - clr = ext_xn_over_d(clr, thickness(q), fraction_rule(cur_style)); - delta1 = clr - ((shift_up - depth(x)) - (math_axis(cur_size) + delta)); - if (delta1 > 0) - shift_up = shift_up + delta1; - clr = fraction_denom_vgap(cur_style); - clr = ext_xn_over_d(clr, thickness(q), fraction_rule(cur_style)); - delta2 = - clr - ((math_axis(cur_size) - delta) - (height(z) - shift_down)); - if (delta2 > 0) - shift_down = shift_down + delta2; - } - /* 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)| */ - reset_attributes(v, node_attr(q)); - if (thickness(q) == 0) { - p = new_kern((shift_up - depth(x)) - (height(z) - shift_down)); - vlink(p) = z; - } else { - y = do_fraction_rule(thickness(q), node_attr(q)); - p = new_kern((math_axis(cur_size) - delta) - (height(z) - shift_down)); - reset_attributes(p, node_attr(q)); - vlink(y) = p; - vlink(p) = z; - p = new_kern((shift_up - depth(x)) - (math_axis(cur_size) + delta)); - vlink(p) = y; - } - reset_attributes(p, node_attr(q)); - vlink(x) = p; - list_ptr(v) = x; - /* Put the fraction into a box with its delimiters, and make |new_hlist(q)| - point to it */ - delta = fraction_del_size(cur_style); - x = var_delimiter(left_delimiter(q), cur_size, delta, NULL, cur_style); - left_delimiter(q) = null; - vlink(x) = v; - z = var_delimiter(right_delimiter(q), cur_size, delta, NULL, cur_style); - right_delimiter(q) = null; - vlink(v) = z; - y = hpack(x, 0, additional, -1); - reset_attributes(y, node_attr(q)); - 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. - -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. - -@c -static scaled make_op(pointer q, int cur_style) -{ - scaled delta; /* offset between subscript and superscript */ - pointer p, v, x, y, z; /* temporary registers for box construction */ - int c; /* register for character examination */ - scaled shift_up, shift_down; /* dimensions for box calculation */ - scaled ok_size; - if ((subtype(q) == op_noad_type_normal) && (cur_style < text_style)) - subtype(q) = op_noad_type_limits; - if (type(nucleus(q)) == math_char_node) { - fetch(nucleus(q)); - if (cur_style < text_style) { /* 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 */ - y = new_node(delim_node, 0); - small_fam(y) = math_fam(nucleus(q)); - small_char(y) = math_character(nucleus(q)); - x = var_delimiter(y, text_size, ok_size, &delta, cur_style); - if ((subscr(q) != null) && (subtype(q) != op_noad_type_limits)) { - width(x) -= delta; /* remove italic correction */ - } - /* For an OT MATH font, we may have to get rid of yet another italic - correction because |make_scripts()| will add one. - This test is somewhat more complicated because |x| can be a null - delimiter */ - if ((subscr(q) != null || supscr(q) != null) - && (subtype(q) != op_noad_type_limits) - && ((list_ptr(x) != null) - && (type(list_ptr(x)) == glyph_node) - && is_new_mathfont(font(list_ptr(x))))) { - width(x) -= delta; /* remove another italic correction */ - } - } else { - ok_size = height_plus_depth(cur_f, cur_c) + 1; - while ((char_tag(cur_f, cur_c) == list_tag) && - height_plus_depth(cur_f, cur_c) < ok_size) { - c = char_remainder(cur_f, cur_c); - if (!char_exists(cur_f, c)) - break; - cur_c = c; - math_character(nucleus(q)) = c; - } - delta = char_italic(cur_f, cur_c); - x = clean_box(nucleus(q), cur_style, cur_style); - if ((subscr(q) != null) && (subtype(q) != op_noad_type_limits)) - width(x) = width(x) - delta; /* remove italic correction */ - - shift_amount(x) = - half(height(x) - depth(x)) - math_axis(cur_size); - /* center vertically */ - } - type(nucleus(q)) = sub_box_node; - math_list(nucleus(q)) = x; - - } else { /* normal size */ - delta = char_italic(cur_f, cur_c); - x = clean_box(nucleus(q), cur_style, cur_style); - if ((subscr(q) != null) && (subtype(q) != op_noad_type_limits)) - width(x) = width(x) - delta; /* remove italic correction */ - - /* For an OT MATH font, we may have to get rid of yet another italic - correction because |make_scripts()| will add one. - This test is somewhat more complicated because |x| can be a null - delimiter */ - if ((subscr(q) != null || supscr(q) != null) - && (subtype(q) != op_noad_type_limits) - && ((list_ptr(x) != null) - && (type(list_ptr(x)) == glyph_node) - && is_new_mathfont(font(list_ptr(x))))) { - width(x) -= delta; /* remove another italic correction */ - } - - shift_amount(x) = half(height(x) - depth(x)) - math_axis(cur_size); - /* center vertically */ - type(nucleus(q)) = sub_box_node; - math_list(nucleus(q)) = x; - } - } else { - delta = 0; - } - 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. */ - 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); - v = new_null_box(); - reset_attributes(v, node_attr(q)); - type(v) = vlist_node; - width(v) = width(y); - if (width(x) > width(v)) - width(v) = width(x); - if (width(z) > width(v)) - width(v) = width(z); - x = rebox(x, width(v)); - y = rebox(y, width(v)); - z = rebox(z, width(v)); - shift_amount(x) = half(delta); - shift_amount(z) = -shift_amount(x); - height(v) = height(y); - depth(v) = depth(y); - /* Attach the limits to |y| and adjust |height(v)|, |depth(v)| to - account for their presence */ - /* 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|. 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. */ - if (supscr(q) == null) { - list_ptr(x) = null; - flush_node(x); - list_ptr(v) = y; - } else { - shift_up = limit_above_bgap(cur_style) - depth(x); - if (shift_up < limit_above_vgap(cur_style)) - shift_up = limit_above_vgap(cur_style); - p = new_kern(shift_up); - reset_attributes(p, node_attr(q)); - vlink(p) = y; - vlink(x) = p; - p = new_kern(limit_above_kern(cur_style)); - reset_attributes(p, node_attr(q)); - vlink(p) = x; - list_ptr(v) = p; - height(v) = - height(v) + limit_above_kern(cur_style) + height(x) + depth(x) + - shift_up; - } - if (subscr(q) == null) { - list_ptr(z) = null; - flush_node(z); - } else { - shift_down = limit_below_bgap(cur_style) - height(z); - if (shift_down < limit_below_vgap(cur_style)) - shift_down = limit_below_vgap(cur_style); - p = new_kern(shift_down); - reset_attributes(p, node_attr(q)); - vlink(y) = p; - vlink(p) = z; - p = new_kern(limit_below_kern(cur_style)); - reset_attributes(p, node_attr(q)); - vlink(z) = p; - depth(v) = - depth(v) + limit_below_kern(cur_style) + height(z) + depth(z) + - shift_down; - } - if (subscr(q) != null) { - math_list(subscr(q)) = null; - flush_node(subscr(q)); - subscr(q) = null; - } - if (supscr(q) != null) { - math_list(supscr(q)) = null; - flush_node(supscr(q)); - supscr(q) = null; - } - assign_new_hlist(q, v); - } - 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|. - -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 -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 */ - RESTART: - if (subscr(q) == null && - supscr(q) == null && type(nucleus(q)) == math_char_node) { - p = vlink(q); - if ((p != null) && - (type(p) == simple_noad) && - (subtype(p) <= punct_noad_type) && - (type(nucleus(p)) == math_char_node) && - (math_fam(nucleus(p)) == math_fam(nucleus(q)))) { - type(nucleus(q)) = math_text_char_node; - fetch(nucleus(q)); - a = cur_c; - 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| */ - - /* 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. - But 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 == 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 */ - switch (lig_type(lig)) { - case 1: - case 5: - math_character(nucleus(q)) = lig_replacement(lig); /* \.{=:\char`\|}, \.{=:\char`\|>} */ - break; - case 2: - case 6: - math_character(nucleus(p)) = lig_replacement(lig); /* \.{\char`\|=:}, \.{\char`\|=:>} */ - break; - case 3: - case 7: - case 11: - r = new_noad(); /* \.{\char`\|=:\char`\|}, \.{\char`\|=:\char`\|>}, \.{\char`\|=:\char`\|>>} */ - reset_attributes(r, node_attr(q)); - s = new_node(math_char_node, 0); - reset_attributes(s, node_attr(q)); - nucleus(r) = s; - math_character(nucleus(r)) = lig_replacement(lig); - math_fam(nucleus(r)) = math_fam(nucleus(q)); - vlink(q) = r; - vlink(r) = p; - if (lig_type(lig) < 11) - type(nucleus(r)) = math_char_node; - else - type(nucleus(r)) = math_text_char_node; /* prevent combination */ - break; - default: - vlink(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)); - flush_node(p); - break; - } - if (lig_type(lig) > 3) - return; - type(nucleus(q)) = math_char_node; - goto RESTART; - } - } - if (disable_kern == 0 && has_kern(cur_f, a)) { - k = get_kern(cur_f, a, cur_c); /* todo: should this use mathkerns? */ - if (k != 0) { - p = new_kern(k); - reset_attributes(p, node_attr(q)); - vlink(p) = vlink(q); - vlink(q) = p; - return; - } - } - } - } - } -} - -@ 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. - - 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 */ - 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) { - kerns_heights = co->top_left_math_kern_array; - } else if (side == bottom_left_kern) { - kerns_heights = co->bottom_left_math_kern_array; - } else if (side == top_right_kern) { - kerns_heights = co->top_right_math_kern_array; - } else if (side == bottom_right_kern) { - kerns_heights = co->bottom_right_math_kern_array; - } else { - confusion("math_kern_at"); - kerns_heights = NULL; /* not reached */ - } -#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; - } - } - 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) -{ - scaled corr_height_top = 0, corr_height_bot = 0; - scaled krn_l = 0, krn_r = 0, krn = 0; - if ((!is_new_mathfont(l_f)) || (!is_new_mathfont(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 */ - 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 */ - 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 */ -} - -@ just a small helper -@c -static pointer attach_hkern_to_new_hlist(pointer q, scaled delta2) -{ - pointer y; - pointer z = new_kern(delta2); - if (new_hlist(q) == null) { /* this is somewhat weird */ - new_hlist(q) = z; - } else { - y = new_hlist(q); - while (vlink(y) != null) - y = vlink(y); - vlink(y) = z; - } - 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; - } -} - - -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|. - -We set |shift_down| and |shift_up| to the minimum amounts to shift the -baseline of subscripts and superscripts based on the given nucleus. - -@c -static void make_scripts(pointer q, pointer p, scaled it, int cur_style) -{ - pointer x, y, z; /* temporary registers for box construction */ - scaled shift_up, shift_down, clr; /* dimensions in the calculation */ - scaled delta1, delta2; - 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 - switch (type(nucleus(q))) { - case math_char_node: - case math_text_char_node: - if ((subscr(q) == null) && (delta1 != 0)) { - x = new_kern(delta1); - reset_attributes(x, node_attr(nucleus(q))); - vlink(p) = x; - delta1 = 0; - } - } - assign_new_hlist(q, p); - if (is_char_node(p)) { - shift_up = 0; - shift_down = 0; - } else { - z = hpack(p, 0, additional, -1); - shift_up = height(z) - sup_shift_drop(cur_style); /* r18 */ - shift_down = depth(z) + sub_shift_drop(cur_style); /* r19 */ - list_ptr(z) = null; - flush_node(z); - } - if (supscr(q) == null) { - /* 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); - width(x) = width(x) + space_after_script(cur_style); - if (shift_down < sub_shift_down(cur_style)) - shift_down = sub_shift_down(cur_style); - clr = height(x) - sub_top_max(cur_style); - if (shift_down < clr) - shift_down = clr; - shift_amount(x) = shift_down; - - /* now find and correct for horizontal shift */ - if (is_char_node(p) && subscr(q) != null - && type(subscr(q)) == math_char_node) { - fetch(subscr(q)); - if (char_exists(cur_f, cur_c)) { - delta2 = - find_math_kern(font(p), character(p), cur_f, cur_c, - sub_mark_cmd, shift_down); - if (delta2 != MATH_KERN_NOT_FOUND && delta2 != 0) { - p = attach_hkern_to_new_hlist(q, delta2); - } - } - } - - } else { - /* Construct a superscript box |x| */ - /*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); - width(x) = width(x) + space_after_script(cur_style); - clr = sup_shift_up(cur_style); - if (shift_up < clr) - shift_up = clr; - clr = depth(x) + sup_bottom_min(cur_style); - if (shift_up < clr) - shift_up = clr; - - if (subscr(q) == null) { - shift_amount(x) = -shift_up; - /* now find and correct for horizontal shift */ - if (is_char_node(p) && type(supscr(q)) == math_char_node) { - fetch(supscr(q)); - if (char_exists(cur_f, cur_c)) { - clr = - find_math_kern(font(p), character(p), cur_f, cur_c, - sup_mark_cmd, shift_up); - if (clr != MATH_KERN_NOT_FOUND && clr != 0) { - p = attach_hkern_to_new_hlist(q, clr); - } - } - } - } else { - /* 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. */ - - y = clean_box(subscr(q), sub_style(cur_style), cur_style); - width(y) = width(y) + space_after_script(cur_style); - if (shift_down < sub_sup_shift_down(cur_style)) - shift_down = sub_sup_shift_down(cur_style); - clr = subsup_vgap(cur_style) - - ((shift_up - depth(x)) - (height(y) - shift_down)); - if (clr > 0) { - shift_down = shift_down + clr; - clr = sup_sub_bottom_max(cur_style) - (shift_up - depth(x)); - if (clr > 0) { - shift_up = shift_up + clr; - shift_down = shift_down - clr; - } - } - /* now find and correct for horizontal shift */ - if (is_char_node(p) && subscr(q) != null - && type(subscr(q)) == math_char_node) { - fetch(subscr(q)); - if (char_exists(cur_f, cur_c)) { - delta2 = - find_math_kern(font(p), character(p), cur_f, cur_c, - sub_mark_cmd, shift_down); - if (delta2 != MATH_KERN_NOT_FOUND && delta2 != 0) { - p = attach_hkern_to_new_hlist(q, delta2); - } - } - } - /* 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 (is_char_node(p) && supscr(q) != null - && type(supscr(q)) == math_char_node) { - fetch(supscr(q)); - if (char_exists(cur_f, cur_c)) { - clr = - find_math_kern(font(p), character(p), cur_f, cur_c, - sup_mark_cmd, shift_up); - } - } - if (delta2 == MATH_KERN_NOT_FOUND) - delta2 = 0; - if (clr != MATH_KERN_NOT_FOUND) { - shift_amount(x) = clr + delta1 - delta2; - } else { - shift_amount(x) = delta1 - delta2; - } - p = new_kern((shift_up - depth(x)) - (height(y) - shift_down)); - reset_attributes(p, node_attr(q)); - vlink(x) = p; - vlink(p) = y; - x = vpackage(x, 0, additional, max_dimen, math_direction); - reset_attributes(x, node_attr(q)); - shift_amount(x) = shift_down; - } - } - - - if (new_hlist(q) == null) { - new_hlist(q) = x; - } else { - p = new_hlist(q); - while (vlink(p) != null) - p = vlink(p); - vlink(p) = x; - } - if (subscr(q) != null) { - math_list(subscr(q)) = null; - flush_node(subscr(q)); - subscr(q) = null; - } - if (supscr(q) != null) { - math_list(supscr(q)) = null; - flush_node(supscr(q)); - supscr(q) = null; - } - -} - -@ 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_hv) -{ - scaled delta, delta1, delta2; /* dimensions used in the calculation */ - pointer tmp; - setup_cur_size(style); - delta2 = max_d + math_axis(cur_size); - delta1 = max_hv + max_d - delta2; - if (delta2 > delta1) - delta1 = delta2; /* |delta1| is max distance from axis */ - delta = (delta1 / 500) * delimiter_factor; - delta2 = delta1 + delta1 - delimiter_shortfall; - if (delta < delta2) - delta = delta2; - tmp = var_delimiter(delimiter(q), cur_size, delta, NULL, style); - delimiter(q) = null; - assign_new_hlist(q, tmp); - if (subtype(q) == left_noad_side) - return open_noad_type; - else - return close_noad_type; -} - -@ @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); \ - } 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); \ - } while (0) - -#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)); \ - } 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); - SPLIT_STYLES (math_param_ord_rel_spacing, thick_mu_skip_code, 0); - ALL_STYLES (math_param_ord_open_spacing, 0); - ALL_STYLES (math_param_ord_close_spacing, 0); - ALL_STYLES (math_param_ord_punct_spacing, 0); - SPLIT_STYLES (math_param_ord_inner_spacing, thin_mu_skip_code, 0); - - ALL_STYLES (math_param_op_ord_spacing, thin_mu_skip_code); - ALL_STYLES (math_param_op_op_spacing, thin_mu_skip_code); - ALL_STYLES (math_param_op_bin_spacing, 0); - SPLIT_STYLES (math_param_op_rel_spacing, thick_mu_skip_code, 0); - ALL_STYLES (math_param_op_open_spacing, 0); - ALL_STYLES (math_param_op_close_spacing, 0); - ALL_STYLES (math_param_op_punct_spacing, 0); - SPLIT_STYLES (math_param_op_inner_spacing, thin_mu_skip_code, 0); - - SPLIT_STYLES (math_param_bin_ord_spacing, med_mu_skip_code, 0); - SPLIT_STYLES (math_param_bin_op_spacing, med_mu_skip_code, 0); - ALL_STYLES (math_param_bin_bin_spacing, 0); - ALL_STYLES (math_param_bin_rel_spacing, 0); - SPLIT_STYLES (math_param_bin_open_spacing, med_mu_skip_code, 0); - ALL_STYLES (math_param_bin_close_spacing, 0); - ALL_STYLES (math_param_bin_punct_spacing, 0); - SPLIT_STYLES (math_param_bin_inner_spacing, med_mu_skip_code, 0); - - SPLIT_STYLES (math_param_rel_ord_spacing, thick_mu_skip_code, 0); - SPLIT_STYLES (math_param_rel_op_spacing, thick_mu_skip_code, 0); - ALL_STYLES (math_param_rel_bin_spacing, 0); - ALL_STYLES (math_param_rel_rel_spacing, 0); - SPLIT_STYLES (math_param_rel_open_spacing, thick_mu_skip_code, 0); - ALL_STYLES (math_param_rel_close_spacing, 0); - ALL_STYLES (math_param_rel_punct_spacing, 0); - SPLIT_STYLES (math_param_rel_inner_spacing, thick_mu_skip_code, 0); - - ALL_STYLES (math_param_open_ord_spacing, 0); - ALL_STYLES (math_param_open_op_spacing, 0); - ALL_STYLES (math_param_open_bin_spacing, 0); - ALL_STYLES (math_param_open_rel_spacing, 0); - ALL_STYLES (math_param_open_open_spacing, 0); - ALL_STYLES (math_param_open_close_spacing, 0); - ALL_STYLES (math_param_open_punct_spacing, 0); - ALL_STYLES (math_param_open_inner_spacing, 0); - - ALL_STYLES (math_param_close_ord_spacing, 0); - ALL_STYLES (math_param_close_op_spacing, thin_mu_skip_code); - SPLIT_STYLES (math_param_close_bin_spacing, med_mu_skip_code, 0); - SPLIT_STYLES (math_param_close_rel_spacing, thick_mu_skip_code, 0); - ALL_STYLES (math_param_close_open_spacing, 0); - ALL_STYLES (math_param_close_close_spacing, 0); - ALL_STYLES (math_param_close_punct_spacing, 0); - SPLIT_STYLES (math_param_close_inner_spacing, thin_mu_skip_code, 0); - - SPLIT_STYLES (math_param_punct_ord_spacing, thin_mu_skip_code, 0); - SPLIT_STYLES (math_param_punct_op_spacing, thin_mu_skip_code, 0); - ALL_STYLES (math_param_punct_bin_spacing, 0); - SPLIT_STYLES (math_param_punct_rel_spacing, thin_mu_skip_code, 0); - SPLIT_STYLES (math_param_punct_open_spacing, thin_mu_skip_code, 0); - SPLIT_STYLES (math_param_punct_close_spacing, thin_mu_skip_code, 0); - SPLIT_STYLES (math_param_punct_punct_spacing, thin_mu_skip_code, 0); - SPLIT_STYLES (math_param_punct_inner_spacing, thin_mu_skip_code, 0); - - SPLIT_STYLES (math_param_inner_ord_spacing, thin_mu_skip_code, 0); - ALL_STYLES (math_param_inner_op_spacing, thin_mu_skip_code); - SPLIT_STYLES (math_param_inner_bin_spacing, med_mu_skip_code, 0); - SPLIT_STYLES (math_param_inner_rel_spacing, thick_mu_skip_code, 0); - SPLIT_STYLES (math_param_inner_open_spacing, thin_mu_skip_code, 0); - 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) -{ - int x = -1; - pointer z = null; - if (l_type == op_noad_type_limits || l_type == op_noad_type_no_limits) - l_type = op_noad_type_normal; - 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* */ - } - if (x < 0) { - confusion("mathspacing"); - } - if (x != 0) { - pointer y; - if (x <= thick_mu_skip_code) { /* trap thin/med/thick settings cf. old TeX */ - y = math_glue(glue_par(x), mmu); - z = new_glue(y); - glue_ref_count(y) = null; - subtype(z) = (quarterword) (x + 1); /* store a symbolic subtype */ - } else { - y = math_glue(x, mmu); - z = new_glue(y); - glue_ref_count(y) = null; - } - } - return z; -} - -@ @c -static pointer check_nucleus_complexity(halfword q, scaled * delta, - int cur_style) -{ - pointer p = null; - switch (type(nucleus(q))) { - case math_char_node: - case math_text_char_node: - fetch(nucleus(q)); - if (char_exists(cur_f, cur_c)) { - *delta = char_italic(cur_f, cur_c); - p = new_glyph(cur_f, cur_c); - reset_attributes(p, node_attr(nucleus(q))); - if ((is_new_mathfont(cur_f) && get_char_cat_code(cur_c) == 11) || - (!is_new_mathfont(cur_f) && type(nucleus(q)) == math_text_char_node && space(cur_f)) != 0) { - *delta = 0; /* no italic correction in mid-word of text font */ - } - if ((subscr(q) == null) && (supscr(q) == null) && (*delta != 0)) { - pointer x = new_kern(*delta); - reset_attributes(x, node_attr(nucleus(q))); - vlink(p) = x; - *delta = 0; - } - } - break; - case sub_box_node: - p = math_list(nucleus(q)); - break; - case sub_mlist_node: - mlist_to_hlist_args(math_list(nucleus(q)), cur_style, false); /* recursive call */ - 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 */ - } - return p; -} - -@ Here is the overall plan of |mlist_to_hlist|, and the list of its - local variables. - -@c -static void mlist_to_hlist(pointer mlist, boolean penalties, int cur_style) -{ - pointer q; /* runs through the mlist */ - pointer r; /* the most recent noad preceding |q| */ - int style; - int r_type; /* the |type| of noad |r|, or |op_noad| if |r=null| */ - int r_subtype; /* 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 */ - pointer p, x, y, z; /* temporary registers for list construction */ - int pen; /* a penalty to be inserted */ - scaled max_hl, max_d; /* maximum height and 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| */ - style = cur_style; /* tuck global parameter away as local variable */ - q = mlist; - r = null; - r_type = simple_noad; - r_subtype = op_noad_type_normal; - max_hl = 0; - max_d = 0; - x = null; - p = null; - setup_cur_size(cur_style); - cur_mu = x_over_n(get_math_quad(cur_size), 18); - while (q != null) { - /* 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. */ - RESWITCH: - delta = 0; - 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; - } - break; - case fence_noad: - if (r_subtype == left_noad_side) { - subtype(q) = ord_noad_type; - goto RESWITCH; - } - break; - } - break; - case over_noad_type: - make_over(q, cur_style); - break; - case under_noad_type: - make_under(q, cur_style); - 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; - 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) - 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; - subtype(r) = ord_noad_type; - } - goto DONE_WITH_NOAD; - break; - case fraction_noad: - make_fraction(q, cur_style); - goto CHECK_DIMENSIONS; - break; - case radical_noad: - if (subtype(q) == 4) - make_under_delimiter(q, cur_style); - else if (subtype(q) == 5) - make_over_delimiter(q, cur_style); - else if (subtype(q) == 6) - make_delimiter_under(q, cur_style); - else if (subtype(q) == 7) - make_delimiter_over(q, cur_style); - else - make_radical(q, cur_style); - break; - case accent_noad: - make_math_accent(q, cur_style); - break; - case style_node: - cur_style = subtype(q); - setup_cur_size(cur_style); - cur_mu = x_over_n(get_math_quad(cur_size), 18); - goto DONE_WITH_NODE; - break; - case choice_node: - switch (cur_style / 2) { - case 0: - choose_mlist(display_mlist); - break; /* |display_style=0| */ - case 1: - choose_mlist(text_mlist); - break; /* |text_style=2| */ - case 2: - choose_mlist(script_mlist); - break; /* |script_style=4| */ - case 3: - choose_mlist(script_script_mlist); - break; /* |script_script_style=6| */ - } /* there are no other cases */ - flush_node_list(display_mlist(q)); - flush_node_list(text_mlist(q)); - flush_node_list(script_mlist(q)); - flush_node_list(script_script_mlist(q)); - type(q) = style_node; - subtype(q) = (quarterword) cur_style; - if (p != null) { - z = vlink(q); - vlink(q) = p; - while (vlink(p) != null) - p = vlink(p); - vlink(p) = z; - } - goto DONE_WITH_NODE; - break; - case ins_node: - case mark_node: - case adjust_node: - case whatsit_node: - case penalty_node: - case disc_node: - goto DONE_WITH_NODE; - break; - case rule_node: - if (height(q) > max_hl) - max_hl = height(q); - if (depth(q) > max_d) - max_d = depth(q); - 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|. Unconditional math glue - (`\.{\\muskip}') is converted to normal glue by multiplying the dimensions - by |cur_mu|. - */ - if (subtype(q) == mu_glue) { - x = glue_ptr(q); - y = math_glue(x, cur_mu); - delete_glue_ref(x); - glue_ptr(q) = y; - subtype(q) = normal; - } else if ((cur_size != text_size) - && (subtype(q) == cond_math_glue)) { - p = vlink(q); - if (p != null) - if ((type(p) == glue_node) || (type(p) == kern_node)) { - vlink(q) = vlink(p); - vlink(p) = null; - flush_node_list(p); - } - } - goto DONE_WITH_NODE; - break; - case kern_node: - math_kern(q, cur_mu); - goto DONE_WITH_NODE; - break; - default: - confusion("mlist1"); /* this can't happen 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. - - 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. - */ - p = check_nucleus_complexity(q, &delta, cur_style); - - if ((subscr(q) == null) && (supscr(q) == null)) { - assign_new_hlist(q, p); - } else { - make_scripts(q, p, delta, cur_style); /* top, bottom */ - } - CHECK_DIMENSIONS: - z = hpack(new_hlist(q), 0, additional, -1); - if (height(z) > max_hl) - max_hl = height(z); - if (depth(z) > max_d) - max_d = depth(z); - list_ptr(z) = null; - flush_node(z); /* only drop the \.{\\hbox} */ - DONE_WITH_NOAD: - r = q; - r_type = type(r); - r_subtype = subtype(r); - if (r_type == fence_noad) { - r_subtype = left_noad_side; - cur_style = style; - setup_cur_size(cur_style); - cur_mu = x_over_n(get_math_quad(cur_size), 18); - } - DONE_WITH_NODE: - q = vlink(q); - } - if (r_type == simple_noad && r_subtype == bin_noad_type) { - type(r) = simple_noad; - subtype(r) = ord_noad_type; - } - /* 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. - */ - p = temp_head; - vlink(p) = null; - q = mlist; - r_type = 0; - r_subtype = 0; - cur_style = style; - setup_cur_size(cur_style); - cur_mu = x_over_n(get_math_quad(cur_size), 18); - NEXT_NODE: - while (q != null) { - /* 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 */ - /* 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; - pen = inf_penalty; - switch (type(q)) { - case simple_noad: - t_subtype = subtype(q); - switch (t_subtype) { - case bin_noad_type: - pen = bin_op_penalty; - break; - case rel_noad_type: - pen = rel_penalty; - break; - case vcenter_noad_type: - case over_noad_type: - case under_noad_type: - t_subtype = ord_noad_type; - break; - } - case radical_noad: - break; - case accent_noad: - break; - case fraction_noad: - t = simple_noad; - t_subtype = inner_noad_type; - break; - case fence_noad: - t_subtype = make_left_right(q, style, max_d, max_hl); - break; - case style_node: - /* 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(cur_size), 18); - goto DELETE_Q; - break; - case whatsit_node: - case penalty_node: - case rule_node: - case disc_node: - case adjust_node: - case ins_node: - case mark_node: - case glue_node: - case kern_node: - vlink(p) = q; - p = q; - q = vlink(q); - vlink(p) = null; - goto NEXT_NODE; - break; - default: - confusion("mlist3"); /* this can't happen mlist3 */ - } - /* Append inter-element spacing based on |r_type| and |t| */ - if (r_type > 0) { /* not the first noad */ - z = math_spacing_glue(r_subtype, t_subtype, cur_style, cur_mu); - if (z != null) { - reset_attributes(z, node_attr(p)); - vlink(p) = z; - p = z; - } - } - - /* 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. */ - - if (new_hlist(q) != null) { - vlink(p) = new_hlist(q); - do { - p = vlink(p); - } while (vlink(p) != null); - } - if (penalties && vlink(q) != null && pen < inf_penalty) { - r_type = type(vlink(q)); - r_subtype = subtype(vlink(q)); - if (r_type != penalty_node - && (r_type != simple_noad || r_subtype != rel_noad_type)) { - z = new_penalty(pen); - reset_attributes(z, node_attr(q)); - vlink(p) = z; - p = z; - } - } - if (type(q) == fence_noad && subtype(q) == right_noad_side) { - t = simple_noad; - t_subtype = open_noad_type; - } - r_type = t; - r_subtype = t_subtype; - 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). - 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)); - free_node(r, get_node_size(type(r), subtype(r))); - } -} - -@ This used to be needed when |mlist_to_hlist| communicated via global -variables. - -@c -void mlist_to_hlist_args(pointer n, int w, boolean m) -{ - mlist_to_hlist(n, m, w); -} +% 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-ls: by using couple_nodes instead of vlink we make sure that we can backtrack as well as have valid prev links */
+
+
+\def\LuaTeX{Lua\TeX}
+
+@ @c
+static const char _svn_version[] =
+ "$Id: mlist.w 4793 2014-02-10 23:13:29Z luigi $"
+ "$URL: https://foundry.supelec.fr/svn/luatex/trunk/source/texk/web2c/luatexdir/tex/mlist.w $";
+
+#include "ptexlib.h"
+#include "lua/luatex-api.h"
+
+@ @c
+#define delimiter_factor int_par(delimiter_factor_code)
+#define delimiter_shortfall dimen_par(delimiter_shortfall_code)
+#define bin_op_penalty int_par(bin_op_penalty_code)
+#define rel_penalty int_par(rel_penalty_code)
+#define null_delimiter_space dimen_par(null_delimiter_space_code)
+#define script_space dimen_par(script_space_code)
+#define disable_lig int_par(disable_lig_code)
+#define disable_kern int_par(disable_kern_code)
+
+#define nDEBUG
+
+#define reset_attributes(p,newatt) do { \
+ delete_attribute_ref(node_attr(p)); \
+ node_attr(p) = newatt; \
+ if (newatt!=null) { \
+ assert(type(newatt)==attribute_list_node); \
+ add_node_attr_ref(node_attr(p)); \
+ } \
+ } while (0)
+
+
+#define DEFINE_MATH_PARAMETERS(A,B,C,D) do { \
+ if (B==text_size) { \
+ def_math_param(A, text_style, (C),D); \
+ def_math_param(A, cramped_text_style, (C),D); \
+ } else if (B==script_size) { \
+ def_math_param(A, script_style, (C),D); \
+ def_math_param(A, cramped_script_style, (C),D); \
+ } else if (B==script_script_size) { \
+ def_math_param(A, script_script_style, (C),D); \
+ def_math_param(A, cramped_script_script_style, (C),D); \
+ } \
+ } while (0)
+
+#define DEFINE_DMATH_PARAMETERS(A,B,C,D) do { \
+ if (B==text_size) { \
+ def_math_param(A, display_style,(C),D); \
+ def_math_param(A, cramped_display_style,(C),D); \
+ } \
+ } while (0)
+
+
+#define is_new_mathfont(A) (font_math_params(A)>0)
+#define is_old_mathfont(A,B) (font_math_params(A)==0 && font_params(A)>=(B))
+
+
+#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
+
+@ 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@>
+
+@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
+#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.
+
+ScriptPercentScaleDown,
+ScriptScriptPercentScaleDown:
+ These should be handled by the macro package, on the engine
+ side there are three separate fonts
+
+DelimitedSubFormulaMinHeight:
+ This is perhaps related to word's natural math input? I have
+ no idea what to do about it
+
+MathLeading:
+ LuaTeX does not currently handle multi-line displays, and
+ the parameter does not seem to make much sense elsewhere
+
+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
+
+SkewedFractionHorizontalGap,
+SkewedFractionVerticalGap:
+ I am not sure it makes sense implementing skewed fractions,
+ so I would like to see an example first
+
+Also still TODO for OpenType Math:
+ * extensible large operators
+ * prescripts
+
+@ this is not really a math parameter at all
+
+@c
+static void math_param_error(const char *param, int style)
+{
+ char s[256];
+ const char *hlp[] = {
+ "Sorry, but I can't typeset math unless various parameters have",
+ "been set. This is normally done by loading special math fonts",
+ "into the math family slots. Your font set is lacking at least",
+ "the parameter mentioned earlier.",
+ NULL
+ };
+ 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;
+ if (is_new_mathfont(f)) {
+ a = font_MATH_par(f, AccentBaseHeight);
+ if (a == undefined_math_parameter)
+ a = x_height(f);
+ } else {
+ a = x_height(f);
+ }
+ return a;
+}
+
+@ the non-staticness of this function is for the benefit of |texmath.w|
+
+@c
+scaled get_math_quad(int var)
+{
+ scaled a = get_math_param(math_param_quad, var);
+ if (a == undefined_math_parameter) {
+ math_param_error("quad", var);
+ a = 0;
+ }
+ return a;
+}
+
+@ this parameter is different because it is called with a size
+ specifier instead of a style specifier.
+
+@c
+static scaled math_axis(int b)
+{
+ scaled a;
+ int var;
+ if (b == script_size)
+ var = script_style;
+ else if (b == script_script_size)
+ var = script_script_style;
+ else
+ var = text_style;
+ a = get_math_param(math_param_axis, var);
+ if (a == undefined_math_parameter) {
+ math_param_error("axis", var);
+ a = 0;
+ }
+ return a;
+}
+
+@ @c
+static scaled get_math_quad_size(int b)
+{
+ int var;
+ if (b == script_size)
+ var = script_style;
+ else if (b == script_script_size)
+ var = script_script_style;
+ else
+ var = text_style;
+ 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.
+
+@c
+static scaled radical_rule(int var)
+{
+ scaled a = get_math_param(math_param_radical_rule, var);
+ return a;
+}
+
+@ 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)
+
+static scaled do_get_math_param_or_error(int var, int param, const char *name)
+{
+ scaled a = get_math_param(param, var);
+ if (a == undefined_math_parameter) {
+ math_param_error(name, var);
+ a = 0;
+ }
+ return a;
+}
+
+@ @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)
+
+#define connector_overlap_min(a) get_math_param_or_error(a, connector_overlap_min)
+
+#define overbar_rule(a) get_math_param_or_error(a, overbar_rule)
+#define overbar_kern(a) get_math_param_or_error(a, overbar_kern)
+#define overbar_vgap(a) get_math_param_or_error(a, overbar_vgap)
+
+#define underbar_rule(a) get_math_param_or_error(a, underbar_rule)
+#define underbar_kern(a) get_math_param_or_error(a, underbar_kern)
+#define underbar_vgap(a) get_math_param_or_error(a, underbar_vgap)
+
+#define under_delimiter_vgap(a) get_math_param_or_error(a, under_delimiter_vgap)
+#define under_delimiter_bgap(a) get_math_param_or_error(a, under_delimiter_bgap)
+
+#define over_delimiter_vgap(a) get_math_param_or_error(a, over_delimiter_vgap)
+#define over_delimiter_bgap(a) get_math_param_or_error(a, over_delimiter_bgap)
+
+#define radical_vgap(a) get_math_param_or_error(a, radical_vgap)
+#define radical_kern(a) get_math_param_or_error(a, radical_kern)
+
+#define stack_vgap(a) get_math_param_or_error(a, stack_vgap)
+#define stack_num_up(a) get_math_param_or_error(a, stack_num_up)
+#define stack_denom_down(a) get_math_param_or_error(a, stack_denom_down)
+
+#define fraction_rule(a) get_math_param_or_error(a, fraction_rule)
+#define fraction_num_vgap(a) get_math_param_or_error(a, fraction_num_vgap)
+#define fraction_denom_vgap(a) get_math_param_or_error(a, fraction_denom_vgap)
+#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(a) get_math_param_or_error(a, fraction_del_size)
+
+#define limit_above_vgap(a) get_math_param_or_error(a, limit_above_vgap)
+#define limit_above_bgap(a) get_math_param_or_error(a, limit_above_bgap)
+#define limit_above_kern(a) get_math_param_or_error(a, limit_above_kern)
+
+#define limit_below_vgap(a) get_math_param_or_error(a, limit_below_vgap)
+#define limit_below_bgap(a) get_math_param_or_error(a, limit_below_bgap)
+#define limit_below_kern(a) get_math_param_or_error(a, limit_below_kern)
+
+#define sub_shift_drop(a) get_math_param_or_error(a, sub_shift_drop)
+#define sup_shift_drop(a) get_math_param_or_error(a, sup_shift_drop)
+#define sub_shift_down(a) get_math_param_or_error(a, sub_shift_down)
+#define sub_sup_shift_down(a) get_math_param_or_error(a, sub_sup_shift_down)
+#define sup_shift_up(a) get_math_param_or_error(a, sup_shift_up)
+#define sub_top_max(a) get_math_param_or_error(a, sub_top_max)
+#define sup_bottom_min(a) get_math_param_or_error(a, sup_bottom_min)
+#define sup_sub_bottom_max(a) get_math_param_or_error(a, sup_sub_bottom_max)
+#define subsup_vgap(a) get_math_param_or_error(a, subsup_vgap)
+
+#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)) { /* fix all known parameters */
+
+ DEFINE_MATH_PARAMETERS(math_param_quad, size_id, font_size(f), lvl);
+ DEFINE_DMATH_PARAMETERS(math_param_quad, size_id, font_size(f), lvl);
+ DEFINE_MATH_PARAMETERS(math_param_axis, size_id,
+ font_MATH_par(f, AxisHeight), lvl);
+ DEFINE_DMATH_PARAMETERS(math_param_axis, size_id,
+ font_MATH_par(f, AxisHeight), lvl);
+ DEFINE_MATH_PARAMETERS(math_param_overbar_kern, size_id,
+ font_MATH_par(f, OverbarExtraAscender), lvl);
+ DEFINE_DMATH_PARAMETERS(math_param_overbar_kern, size_id,
+ font_MATH_par(f, OverbarExtraAscender), lvl);
+ DEFINE_MATH_PARAMETERS(math_param_overbar_rule, size_id,
+ font_MATH_par(f, OverbarRuleThickness), lvl);
+ DEFINE_DMATH_PARAMETERS(math_param_overbar_rule, size_id,
+ font_MATH_par(f, OverbarRuleThickness), lvl);
+ DEFINE_MATH_PARAMETERS(math_param_overbar_vgap, size_id,
+ font_MATH_par(f, OverbarVerticalGap), lvl);
+ DEFINE_DMATH_PARAMETERS(math_param_overbar_vgap, size_id,
+ font_MATH_par(f, OverbarVerticalGap), lvl);
+ DEFINE_MATH_PARAMETERS(math_param_underbar_kern, size_id,
+ font_MATH_par(f, UnderbarExtraDescender), lvl);
+ DEFINE_DMATH_PARAMETERS(math_param_underbar_kern, size_id,
+ font_MATH_par(f, UnderbarExtraDescender), lvl);
+ DEFINE_MATH_PARAMETERS(math_param_underbar_rule, size_id,
+ font_MATH_par(f, UnderbarRuleThickness), lvl);
+ DEFINE_DMATH_PARAMETERS(math_param_underbar_rule, size_id,
+ font_MATH_par(f, UnderbarRuleThickness), lvl);
+ DEFINE_MATH_PARAMETERS(math_param_underbar_vgap, size_id,
+ font_MATH_par(f, UnderbarVerticalGap), lvl);
+ DEFINE_DMATH_PARAMETERS(math_param_underbar_vgap, size_id,
+ font_MATH_par(f, UnderbarVerticalGap), lvl);
+
+ DEFINE_MATH_PARAMETERS(math_param_under_delimiter_vgap, size_id,
+ font_MATH_par(f, StretchStackGapAboveMin), lvl);
+ DEFINE_DMATH_PARAMETERS(math_param_under_delimiter_vgap, size_id,
+ font_MATH_par(f, StretchStackGapAboveMin), lvl);
+ DEFINE_MATH_PARAMETERS(math_param_under_delimiter_bgap, size_id,
+ font_MATH_par(f, StretchStackBottomShiftDown),
+ lvl);
+ DEFINE_DMATH_PARAMETERS(math_param_under_delimiter_bgap, size_id,
+ font_MATH_par(f, StretchStackBottomShiftDown),
+ lvl);
+
+ DEFINE_MATH_PARAMETERS(math_param_over_delimiter_vgap, size_id,
+ font_MATH_par(f, StretchStackGapBelowMin), lvl);
+ DEFINE_DMATH_PARAMETERS(math_param_over_delimiter_vgap, size_id,
+ font_MATH_par(f, StretchStackGapBelowMin), lvl);
+ DEFINE_MATH_PARAMETERS(math_param_over_delimiter_bgap, size_id,
+ font_MATH_par(f, StretchStackTopShiftUp), lvl);
+ DEFINE_DMATH_PARAMETERS(math_param_over_delimiter_bgap, size_id,
+ font_MATH_par(f, StretchStackTopShiftUp), lvl);
+
+
+ DEFINE_MATH_PARAMETERS(math_param_stack_num_up, size_id,
+ font_MATH_par(f, StackTopShiftUp), lvl);
+ DEFINE_DMATH_PARAMETERS(math_param_stack_num_up, size_id,
+ font_MATH_par(f, StackTopDisplayStyleShiftUp),
+ lvl);
+ DEFINE_MATH_PARAMETERS(math_param_stack_denom_down, size_id,
+ font_MATH_par(f, StackBottomShiftDown), lvl);
+ DEFINE_DMATH_PARAMETERS(math_param_stack_denom_down, size_id,
+ font_MATH_par(f,
+ StackBottomDisplayStyleShiftDown),
+ lvl);
+ DEFINE_MATH_PARAMETERS(math_param_stack_vgap, size_id,
+ font_MATH_par(f, StackGapMin), lvl);
+ DEFINE_DMATH_PARAMETERS(math_param_stack_vgap, size_id,
+ font_MATH_par(f, StackDisplayStyleGapMin), lvl);
+
+ DEFINE_MATH_PARAMETERS(math_param_radical_kern, size_id,
+ font_MATH_par(f, RadicalExtraAscender), lvl);
+ DEFINE_DMATH_PARAMETERS(math_param_radical_kern, size_id,
+ font_MATH_par(f, RadicalExtraAscender), lvl);
+
+ DEFINE_DMATH_PARAMETERS(math_param_operator_size, size_id,
+ font_MATH_par(f, DisplayOperatorMinHeight),
+ lvl);
+
+ DEFINE_MATH_PARAMETERS(math_param_radical_rule, size_id,
+ font_MATH_par(f, RadicalRuleThickness), lvl);
+ DEFINE_DMATH_PARAMETERS(math_param_radical_rule, size_id,
+ font_MATH_par(f, RadicalRuleThickness), lvl);
+ DEFINE_MATH_PARAMETERS(math_param_radical_vgap, size_id,
+ font_MATH_par(f, RadicalVerticalGap), lvl);
+ DEFINE_DMATH_PARAMETERS(math_param_radical_vgap, size_id,
+ font_MATH_par(f,
+ RadicalDisplayStyleVerticalGap),
+ lvl);
+ DEFINE_MATH_PARAMETERS(math_param_radical_degree_before, size_id,
+ font_MATH_par(f, RadicalKernBeforeDegree), lvl);
+ DEFINE_DMATH_PARAMETERS(math_param_radical_degree_before, size_id,
+ font_MATH_par(f, RadicalKernBeforeDegree), lvl);
+ DEFINE_MATH_PARAMETERS(math_param_radical_degree_after, size_id,
+ font_MATH_par(f, RadicalKernAfterDegree), lvl);
+ DEFINE_DMATH_PARAMETERS(math_param_radical_degree_after, size_id,
+ font_MATH_par(f, RadicalKernAfterDegree), lvl);
+ DEFINE_MATH_PARAMETERS(math_param_radical_degree_raise, size_id,
+ font_MATH_par(f,
+ RadicalDegreeBottomRaisePercent),
+ lvl);
+ DEFINE_DMATH_PARAMETERS(math_param_radical_degree_raise, size_id,
+ font_MATH_par(f,
+ RadicalDegreeBottomRaisePercent),
+ lvl);
+ if (size_id == text_size) {
+ def_math_param(math_param_sup_shift_up, display_style,
+ font_MATH_par(f, SuperscriptShiftUp), lvl);
+ def_math_param(math_param_sup_shift_up, cramped_display_style,
+ font_MATH_par(f, SuperscriptShiftUpCramped), lvl);
+ def_math_param(math_param_sup_shift_up, text_style,
+ font_MATH_par(f, SuperscriptShiftUp), lvl);
+ def_math_param(math_param_sup_shift_up, cramped_text_style,
+ font_MATH_par(f, SuperscriptShiftUpCramped), lvl);
+ } else if (size_id == script_size) {
+ def_math_param(math_param_sup_shift_up, script_style,
+ font_MATH_par(f, SuperscriptShiftUp), lvl);
+ def_math_param(math_param_sup_shift_up, cramped_script_style,
+ font_MATH_par(f, SuperscriptShiftUpCramped), lvl);
+ } else if (size_id == script_script_size) {
+ def_math_param(math_param_sup_shift_up, script_script_style,
+ font_MATH_par(f, SuperscriptShiftUp), lvl);
+ def_math_param(math_param_sup_shift_up, cramped_script_script_style,
+ font_MATH_par(f, SuperscriptShiftUpCramped), lvl);
+ }
+
+ DEFINE_MATH_PARAMETERS(math_param_sub_shift_drop, size_id,
+ font_MATH_par(f, SubscriptBaselineDropMin), lvl);
+ DEFINE_DMATH_PARAMETERS(math_param_sub_shift_drop, size_id,
+ font_MATH_par(f, SubscriptBaselineDropMin),
+ lvl);
+ DEFINE_MATH_PARAMETERS(math_param_sup_shift_drop, size_id,
+ font_MATH_par(f, SuperscriptBaselineDropMax),
+ lvl);
+ DEFINE_DMATH_PARAMETERS(math_param_sup_shift_drop, size_id,
+ font_MATH_par(f, SuperscriptBaselineDropMax),
+ lvl);
+ DEFINE_MATH_PARAMETERS(math_param_sub_shift_down, size_id,
+ font_MATH_par(f, SubscriptShiftDown), lvl);
+ DEFINE_DMATH_PARAMETERS(math_param_sub_shift_down, size_id,
+ font_MATH_par(f, SubscriptShiftDown), lvl);
+
+ if (font_MATH_par(f, SubscriptShiftDownWithSuperscript) !=
+ undefined_math_parameter) {
+ DEFINE_MATH_PARAMETERS(math_param_sub_sup_shift_down, size_id,
+ font_MATH_par(f,
+ SubscriptShiftDownWithSuperscript),
+ lvl);
+ DEFINE_DMATH_PARAMETERS(math_param_sub_sup_shift_down, size_id,
+ font_MATH_par(f,
+ SubscriptShiftDownWithSuperscript),
+ lvl);
+ } else {
+ DEFINE_MATH_PARAMETERS(math_param_sub_sup_shift_down, size_id,
+ font_MATH_par(f, SubscriptShiftDown), lvl);
+ DEFINE_DMATH_PARAMETERS(math_param_sub_sup_shift_down, size_id,
+ font_MATH_par(f, SubscriptShiftDown), lvl);
+ }
+
+ DEFINE_MATH_PARAMETERS(math_param_sub_top_max, size_id,
+ font_MATH_par(f, SubscriptTopMax), lvl);
+ DEFINE_DMATH_PARAMETERS(math_param_sub_top_max, size_id,
+ font_MATH_par(f, SubscriptTopMax), lvl);
+ DEFINE_MATH_PARAMETERS(math_param_sup_bottom_min, size_id,
+ font_MATH_par(f, SuperscriptBottomMin), lvl);
+ DEFINE_DMATH_PARAMETERS(math_param_sup_bottom_min, size_id,
+ font_MATH_par(f, SuperscriptBottomMin), lvl);
+ DEFINE_MATH_PARAMETERS(math_param_sup_sub_bottom_max, size_id,
+ font_MATH_par(f,
+ SuperscriptBottomMaxWithSubscript),
+ lvl);
+ DEFINE_DMATH_PARAMETERS(math_param_sup_sub_bottom_max, size_id,
+ font_MATH_par(f,
+ SuperscriptBottomMaxWithSubscript),
+ lvl);
+ DEFINE_MATH_PARAMETERS(math_param_subsup_vgap, size_id,
+ font_MATH_par(f, SubSuperscriptGapMin), lvl);
+ DEFINE_DMATH_PARAMETERS(math_param_subsup_vgap, size_id,
+ font_MATH_par(f, SubSuperscriptGapMin), lvl);
+
+ DEFINE_MATH_PARAMETERS(math_param_limit_above_vgap, size_id,
+ font_MATH_par(f, UpperLimitGapMin), lvl);
+ DEFINE_DMATH_PARAMETERS(math_param_limit_above_vgap, size_id,
+ font_MATH_par(f, UpperLimitGapMin), lvl);
+ DEFINE_MATH_PARAMETERS(math_param_limit_above_bgap, size_id,
+ font_MATH_par(f, UpperLimitBaselineRiseMin),
+ lvl);
+ DEFINE_DMATH_PARAMETERS(math_param_limit_above_bgap, size_id,
+ font_MATH_par(f, UpperLimitBaselineRiseMin),
+ lvl);
+ DEFINE_MATH_PARAMETERS(math_param_limit_above_kern, size_id, 0, lvl);
+ DEFINE_DMATH_PARAMETERS(math_param_limit_above_kern, size_id, 0, lvl);
+ DEFINE_MATH_PARAMETERS(math_param_limit_below_vgap, size_id,
+ font_MATH_par(f, LowerLimitGapMin), lvl);
+ DEFINE_DMATH_PARAMETERS(math_param_limit_below_vgap, size_id,
+ font_MATH_par(f, LowerLimitGapMin), lvl);
+ DEFINE_MATH_PARAMETERS(math_param_limit_below_bgap, size_id,
+ font_MATH_par(f, LowerLimitBaselineDropMin),
+ lvl);
+ DEFINE_DMATH_PARAMETERS(math_param_limit_below_bgap, size_id,
+ font_MATH_par(f, LowerLimitBaselineDropMin),
+ lvl);
+ DEFINE_MATH_PARAMETERS(math_param_limit_below_kern, size_id, 0, lvl);
+ DEFINE_DMATH_PARAMETERS(math_param_limit_below_kern, size_id, 0, lvl);
+
+ DEFINE_MATH_PARAMETERS(math_param_fraction_rule, size_id,
+ font_MATH_par(f, FractionRuleThickness), lvl);
+ DEFINE_DMATH_PARAMETERS(math_param_fraction_rule, size_id,
+ font_MATH_par(f, FractionRuleThickness), lvl);
+ DEFINE_MATH_PARAMETERS(math_param_fraction_num_vgap, size_id,
+ font_MATH_par(f, FractionNumeratorGapMin), lvl);
+ DEFINE_DMATH_PARAMETERS(math_param_fraction_num_vgap, size_id,
+ font_MATH_par(f,
+ FractionNumeratorDisplayStyleGapMin),
+ lvl);
+ DEFINE_MATH_PARAMETERS(math_param_fraction_num_up, size_id,
+ font_MATH_par(f, FractionNumeratorShiftUp), lvl);
+ DEFINE_DMATH_PARAMETERS(math_param_fraction_num_up, size_id,
+ font_MATH_par(f,
+ FractionNumeratorDisplayStyleShiftUp),
+ lvl);
+ DEFINE_MATH_PARAMETERS(math_param_fraction_denom_vgap, size_id,
+ font_MATH_par(f, FractionDenominatorGapMin),
+ lvl);
+ DEFINE_DMATH_PARAMETERS(math_param_fraction_denom_vgap, size_id,
+ font_MATH_par(f,
+ FractionDenominatorDisplayStyleGapMin),
+ lvl);
+ DEFINE_MATH_PARAMETERS(math_param_fraction_denom_down, size_id,
+ font_MATH_par(f, FractionDenominatorShiftDown),
+ lvl);
+ DEFINE_DMATH_PARAMETERS(math_param_fraction_denom_down, size_id,
+ font_MATH_par(f,
+ FractionDenominatorDisplayStyleShiftDown),
+ lvl);
+
+ DEFINE_MATH_PARAMETERS(math_param_fraction_del_size, size_id,
+ font_MATH_par(f, FractionDelimiterSize), lvl);
+ DEFINE_DMATH_PARAMETERS(math_param_fraction_del_size, size_id,
+ font_MATH_par(f,
+ FractionDelimiterDisplayStyleSize),
+ lvl);
+
+ DEFINE_MATH_PARAMETERS(math_param_space_after_script, size_id,
+ font_MATH_par(f, SpaceAfterScript), lvl);
+ DEFINE_DMATH_PARAMETERS(math_param_space_after_script, size_id,
+ font_MATH_par(f, SpaceAfterScript), lvl);
+
+ DEFINE_MATH_PARAMETERS(math_param_connector_overlap_min, size_id,
+ font_MATH_par(f, MinConnectorOverlap), lvl);
+ DEFINE_DMATH_PARAMETERS(math_param_connector_overlap_min, size_id,
+ font_MATH_par(f, MinConnectorOverlap), lvl);
+
+
+ } else if (fam_id == 2 && is_old_mathfont(f, total_mathsy_params)) {
+ /* fix old-style |sy| parameters */
+ DEFINE_MATH_PARAMETERS(math_param_quad, size_id, math_quad(size_id),
+ lvl);
+ DEFINE_DMATH_PARAMETERS(math_param_quad, size_id, math_quad(size_id),
+ lvl);
+ DEFINE_MATH_PARAMETERS(math_param_axis, size_id, axis_height(size_id),
+ lvl);
+ DEFINE_DMATH_PARAMETERS(math_param_axis, size_id, axis_height(size_id),
+ lvl);
+ DEFINE_MATH_PARAMETERS(math_param_stack_num_up, size_id, num3(size_id),
+ lvl);
+ DEFINE_DMATH_PARAMETERS(math_param_stack_num_up, size_id, num1(size_id),
+ lvl);
+ DEFINE_MATH_PARAMETERS(math_param_stack_denom_down, size_id,
+ denom2(size_id), lvl);
+ DEFINE_DMATH_PARAMETERS(math_param_stack_denom_down, size_id,
+ denom1(size_id), lvl);
+ DEFINE_MATH_PARAMETERS(math_param_fraction_num_up, size_id,
+ num2(size_id), lvl);
+ DEFINE_DMATH_PARAMETERS(math_param_fraction_num_up, size_id,
+ num1(size_id), lvl);
+ DEFINE_MATH_PARAMETERS(math_param_fraction_denom_down, size_id,
+ denom2(size_id), lvl);
+ DEFINE_DMATH_PARAMETERS(math_param_fraction_denom_down, size_id,
+ denom1(size_id), lvl);
+ DEFINE_MATH_PARAMETERS(math_param_fraction_del_size, size_id,
+ delim2(size_id), lvl);
+ DEFINE_DMATH_PARAMETERS(math_param_fraction_del_size, size_id,
+ delim1(size_id), lvl);
+ if (size_id == text_size) {
+ def_math_param(math_param_sup_shift_up, display_style,
+ sup1(size_id), lvl);
+ def_math_param(math_param_sup_shift_up, cramped_display_style,
+ sup3(size_id), lvl);
+ def_math_param(math_param_sup_shift_up, text_style, sup2(size_id),
+ lvl);
+ def_math_param(math_param_sup_shift_up, cramped_text_style,
+ sup3(size_id), lvl);
+ } else if (size_id == script_size) {
+ def_math_param(math_param_sub_shift_drop, display_style,
+ sub_drop(size_id), lvl);
+ def_math_param(math_param_sub_shift_drop, cramped_display_style,
+ sub_drop(size_id), lvl);
+ def_math_param(math_param_sub_shift_drop, text_style,
+ sub_drop(size_id), lvl);
+ def_math_param(math_param_sub_shift_drop, cramped_text_style,
+ sub_drop(size_id), lvl);
+ def_math_param(math_param_sup_shift_drop, display_style,
+ sup_drop(size_id), lvl);
+ def_math_param(math_param_sup_shift_drop, cramped_display_style,
+ sup_drop(size_id), lvl);
+ def_math_param(math_param_sup_shift_drop, text_style,
+ sup_drop(size_id), lvl);
+ def_math_param(math_param_sup_shift_drop, cramped_text_style,
+ sup_drop(size_id), lvl);
+ def_math_param(math_param_sup_shift_up, script_style, sup2(size_id),
+ lvl);
+ def_math_param(math_param_sup_shift_up, cramped_script_style,
+ sup3(size_id), lvl);
+ } else if (size_id == script_script_size) {
+ def_math_param(math_param_sub_shift_drop, script_style,
+ sub_drop(size_id), lvl);
+ def_math_param(math_param_sub_shift_drop, cramped_script_style,
+ sub_drop(size_id), lvl);
+ def_math_param(math_param_sub_shift_drop, script_script_style,
+ sub_drop(size_id), lvl);
+ def_math_param(math_param_sub_shift_drop,
+ cramped_script_script_style, sub_drop(size_id), lvl);
+ def_math_param(math_param_sup_shift_drop, script_style,
+ sup_drop(size_id), lvl);
+ def_math_param(math_param_sup_shift_drop, cramped_script_style,
+ sup_drop(size_id), lvl);
+ def_math_param(math_param_sup_shift_drop, script_script_style,
+ sup_drop(size_id), lvl);
+ def_math_param(math_param_sup_shift_drop,
+ cramped_script_script_style, sup_drop(size_id), lvl);
+ def_math_param(math_param_sup_shift_up, script_script_style,
+ sup2(size_id), lvl);
+ def_math_param(math_param_sup_shift_up, cramped_script_script_style,
+ sup3(size_id), lvl);
+ }
+ DEFINE_MATH_PARAMETERS(math_param_sub_shift_down, size_id,
+ sub1(size_id), lvl);
+ DEFINE_DMATH_PARAMETERS(math_param_sub_shift_down, size_id,
+ sub1(size_id), lvl);
+ DEFINE_MATH_PARAMETERS(math_param_sub_sup_shift_down, size_id,
+ sub2(size_id), lvl);
+ DEFINE_DMATH_PARAMETERS(math_param_sub_sup_shift_down, size_id,
+ sub2(size_id), lvl);
+ DEFINE_MATH_PARAMETERS(math_param_sub_top_max, size_id,
+ (abs(math_x_height(size_id) * 4) / 5), lvl);
+ DEFINE_DMATH_PARAMETERS(math_param_sub_top_max, size_id,
+ (abs(math_x_height(size_id) * 4) / 5), lvl);
+ DEFINE_MATH_PARAMETERS(math_param_sup_bottom_min, size_id,
+ (abs(math_x_height(size_id)) / 4), lvl);
+ DEFINE_DMATH_PARAMETERS(math_param_sup_bottom_min, size_id,
+ (abs(math_x_height(size_id)) / 4), lvl);
+ DEFINE_MATH_PARAMETERS(math_param_sup_sub_bottom_max, size_id,
+ (abs(math_x_height(size_id) * 4) / 5), 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. */
+ DEFINE_DMATH_PARAMETERS(math_param_radical_vgap, size_id,
+ (default_rule_thickness(size_id) +
+ (abs(math_x_height(size_id)) / 4)), lvl);
+
+ DEFINE_MATH_PARAMETERS(math_param_radical_degree_raise, size_id,
+ 60, lvl);
+ DEFINE_DMATH_PARAMETERS(math_param_radical_degree_raise, size_id,
+ 60, lvl);
+ DEFINE_MATH_PARAMETERS(math_param_radical_degree_before, size_id,
+ xn_over_d(get_math_quad_size(size_id), 5, 18),
+ lvl);
+ DEFINE_DMATH_PARAMETERS(math_param_radical_degree_before, size_id,
+ xn_over_d(get_math_quad_size(size_id), 5, 18),
+ lvl);
+ DEFINE_MATH_PARAMETERS(math_param_radical_degree_after, size_id,
+ (-xn_over_d
+ (get_math_quad_size(size_id), 10, 18)), lvl);
+ DEFINE_DMATH_PARAMETERS(math_param_radical_degree_after, size_id,
+ (-xn_over_d
+ (get_math_quad_size(size_id), 10, 18)), lvl);
+
+ } else if (fam_id == 3 && is_old_mathfont(f, total_mathex_params)) {
+ /* fix old-style |ex| parameters */
+ DEFINE_MATH_PARAMETERS(math_param_overbar_kern, size_id,
+ default_rule_thickness(size_id), lvl);
+ DEFINE_MATH_PARAMETERS(math_param_overbar_rule, size_id,
+ default_rule_thickness(size_id), lvl);
+ DEFINE_MATH_PARAMETERS(math_param_overbar_vgap, size_id,
+ 3 * default_rule_thickness(size_id), lvl);
+ DEFINE_DMATH_PARAMETERS(math_param_overbar_kern, size_id,
+ default_rule_thickness(size_id), lvl);
+ DEFINE_DMATH_PARAMETERS(math_param_overbar_rule, size_id,
+ default_rule_thickness(size_id), lvl);
+ DEFINE_DMATH_PARAMETERS(math_param_overbar_vgap, size_id,
+ 3 * default_rule_thickness(size_id), lvl);
+ DEFINE_MATH_PARAMETERS(math_param_underbar_kern, size_id,
+ default_rule_thickness(size_id), lvl);
+ DEFINE_MATH_PARAMETERS(math_param_underbar_rule, size_id,
+ default_rule_thickness(size_id), lvl);
+ DEFINE_MATH_PARAMETERS(math_param_underbar_vgap, size_id,
+ 3 * default_rule_thickness(size_id), lvl);
+ DEFINE_DMATH_PARAMETERS(math_param_underbar_kern, size_id,
+ default_rule_thickness(size_id), lvl);
+ DEFINE_DMATH_PARAMETERS(math_param_underbar_rule, size_id,
+ default_rule_thickness(size_id), lvl);
+ DEFINE_DMATH_PARAMETERS(math_param_underbar_vgap, size_id,
+ 3 * default_rule_thickness(size_id), lvl);
+ DEFINE_MATH_PARAMETERS(math_param_radical_kern, size_id,
+ default_rule_thickness(size_id), lvl);
+ DEFINE_DMATH_PARAMETERS(math_param_radical_kern, size_id,
+ default_rule_thickness(size_id), lvl);
+
+ DEFINE_MATH_PARAMETERS(math_param_radical_vgap, size_id,
+ (default_rule_thickness(size_id) +
+ (abs(default_rule_thickness(size_id)) / 4)),
+ lvl);
+
+ DEFINE_MATH_PARAMETERS(math_param_stack_vgap, size_id,
+ 3 * default_rule_thickness(size_id), lvl);
+ DEFINE_DMATH_PARAMETERS(math_param_stack_vgap, size_id,
+ 7 * default_rule_thickness(size_id), lvl);
+ DEFINE_MATH_PARAMETERS(math_param_fraction_rule, size_id,
+ default_rule_thickness(size_id), lvl);
+ DEFINE_DMATH_PARAMETERS(math_param_fraction_rule, size_id,
+ default_rule_thickness(size_id), lvl);
+ DEFINE_MATH_PARAMETERS(math_param_fraction_num_vgap, size_id,
+ default_rule_thickness(size_id), lvl);
+ DEFINE_DMATH_PARAMETERS(math_param_fraction_num_vgap, size_id,
+ 3 * default_rule_thickness(size_id), lvl);
+ DEFINE_MATH_PARAMETERS(math_param_fraction_denom_vgap, size_id,
+ default_rule_thickness(size_id), lvl);
+ DEFINE_DMATH_PARAMETERS(math_param_fraction_denom_vgap, size_id,
+ 3 * default_rule_thickness(size_id), lvl);
+ DEFINE_MATH_PARAMETERS(math_param_limit_above_vgap, size_id,
+ big_op_spacing1(size_id), lvl);
+ DEFINE_DMATH_PARAMETERS(math_param_limit_above_vgap, size_id,
+ big_op_spacing1(size_id), lvl);
+ DEFINE_MATH_PARAMETERS(math_param_limit_above_bgap, size_id,
+ big_op_spacing3(size_id), lvl);
+ DEFINE_DMATH_PARAMETERS(math_param_limit_above_bgap, size_id,
+ big_op_spacing3(size_id), lvl);
+ DEFINE_MATH_PARAMETERS(math_param_limit_above_kern, size_id,
+ big_op_spacing5(size_id), lvl);
+ DEFINE_DMATH_PARAMETERS(math_param_limit_above_kern, size_id,
+ big_op_spacing5(size_id), lvl);
+ DEFINE_MATH_PARAMETERS(math_param_limit_below_vgap, size_id,
+ big_op_spacing2(size_id), lvl);
+ DEFINE_DMATH_PARAMETERS(math_param_limit_below_vgap, size_id,
+ big_op_spacing2(size_id), lvl);
+ DEFINE_MATH_PARAMETERS(math_param_limit_below_bgap, size_id,
+ big_op_spacing4(size_id), lvl);
+ DEFINE_DMATH_PARAMETERS(math_param_limit_below_bgap, size_id,
+ big_op_spacing4(size_id), lvl);
+ DEFINE_MATH_PARAMETERS(math_param_limit_below_kern, size_id,
+ big_op_spacing5(size_id), lvl);
+ DEFINE_DMATH_PARAMETERS(math_param_limit_below_kern, size_id,
+ big_op_spacing5(size_id), lvl);
+ DEFINE_MATH_PARAMETERS(math_param_subsup_vgap, size_id,
+ 4 * default_rule_thickness(size_id), 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
+ */
+ DEFINE_MATH_PARAMETERS(math_param_connector_overlap_min, size_id, 0,
+ lvl);
+ DEFINE_DMATH_PARAMETERS(math_param_connector_overlap_min, size_id, 0,
+ lvl);
+
+ DEFINE_MATH_PARAMETERS(math_param_under_delimiter_vgap, size_id,
+ big_op_spacing2(size_id), lvl);
+ DEFINE_DMATH_PARAMETERS(math_param_under_delimiter_vgap, size_id,
+ big_op_spacing2(size_id), lvl);
+ DEFINE_MATH_PARAMETERS(math_param_under_delimiter_bgap, size_id,
+ big_op_spacing4(size_id), lvl);
+ DEFINE_DMATH_PARAMETERS(math_param_under_delimiter_bgap, size_id,
+ big_op_spacing4(size_id), lvl);
+ DEFINE_MATH_PARAMETERS(math_param_over_delimiter_vgap, size_id,
+ big_op_spacing1(size_id), lvl);
+ DEFINE_DMATH_PARAMETERS(math_param_over_delimiter_vgap, size_id,
+ big_op_spacing1(size_id), lvl);
+ DEFINE_MATH_PARAMETERS(math_param_over_delimiter_bgap, size_id,
+ big_op_spacing3(size_id), 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. */
+ DEFINE_DMATH_PARAMETERS(math_param_radical_vgap, size_id,
+ (default_rule_thickness(size_id) +
+ (abs(math_x_height(size_id)) / 4)), lvl);
+ }
+}
+
+@ 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 = int_par(tracing_assigns_code);
+ int_par(tracing_assigns_code) = 0;
+ if (get_math_param(math_param_space_after_script, display_style) ==
+ undefined_math_parameter) {
+ def_math_param(math_param_space_after_script, display_style,
+ script_space, level_one);
+ def_math_param(math_param_space_after_script, text_style,
+ script_space, level_one);
+ def_math_param(math_param_space_after_script, script_style,
+ script_space, level_one);
+ def_math_param(math_param_space_after_script, script_script_style,
+ script_space, level_one);
+ def_math_param(math_param_space_after_script, cramped_display_style,
+ script_space, level_one);
+ def_math_param(math_param_space_after_script, cramped_text_style,
+ script_space, level_one);
+ def_math_param(math_param_space_after_script, cramped_script_style,
+ script_space, level_one);
+ def_math_param(math_param_space_after_script,
+ cramped_script_script_style, script_space, level_one);
+ }
+ int_par(tracing_assigns_code) = saved_trace;
+
+}
+
+
+@ 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.)
+
+@c
+static const char *math_size_string(int s)
+{
+ if (s == text_size)
+ return "textfont";
+ else if (s == script_size)
+ return "scriptfont";
+ else
+ return "scriptscriptfont";
+}
+
+@ 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; \
+ else if (a==script_script_style || \
+ a==cramped_script_script_style) \
+ cur_size=script_script_size; \
+ else cur_size=text_size; \
+ } while (0)
+
+
+@ a simple routine that creates a flat copy of a nucleus
+@c
+static pointer math_clone(pointer q)
+{
+ pointer x;
+ if (q == null)
+ return null;
+ x = new_node(type(q), 0);
+ reset_attributes(x, node_attr(q));
+ if (type(q) == math_char_node) {
+ math_fam(x) = math_fam(q);
+ math_character(x) = math_character(q);
+ } else {
+ math_list(x) = math_list(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.
+
+@c
+static pointer do_fraction_rule(scaled t, pointer att)
+{
+ pointer p; /* the new node */
+ p = new_rule();
+ rule_dir(p) = math_direction;
+ height(p) = t;
+ depth(p) = 0;
+ reset_attributes(p, att);
+ 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|.
+
+@c
+static pointer overbar(pointer b, scaled k, scaled t, scaled ht, pointer att)
+{
+ pointer p, q; /* nodes being constructed */
+ p = new_kern(k);
+ couple_nodes(p,b);
+ reset_attributes(p, att);
+ q = do_fraction_rule(t, att);
+ couple_nodes(q,p);
+ p = new_kern(ht);
+ reset_attributes(p, att);
+ couple_nodes(p,q);
+ q = vpackage(p, 0, additional, max_dimen, math_direction);
+ reset_attributes(q, att);
+ 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.
+
+@c
+static pointer char_box(internal_font_number f, int c, pointer bb)
+{
+ pointer b, p; /* the new box and its character node */
+ b = new_null_box();
+ width(b) = char_width(f, c) + char_italic(f, c);
+ height(b) = char_height(f, c);
+ depth(b) = char_depth(f, c);
+ reset_attributes(b, bb);
+ p = new_char(f, c);
+ reset_attributes(p, bb);
+ list_ptr(b) = p;
+ return b;
+}
+
+@ 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|:
+
+@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));
+ if (type(b) == vlist_node) {
+// vlink(p) = list_ptr(b);
+try_couple_nodes(p,list_ptr(b));
+ list_ptr(b) = p;
+ height(b) = height(p);
+ if (width(b) < width(p))
+ width(b) = width(p);
+ return height_plus_depth(f, c);
+ } else {
+ q = list_ptr(b);
+ if (q == null) {
+ list_ptr(b) = p;
+ } else {
+ while (vlink(q) != null)
+ q = vlink(q);
+ couple_nodes(q,p);
+ }
+ if (height(b) < height(p))
+ height(b) = height(p);
+ if (depth(b) < depth(p))
+ depth(b) = depth(p);
+ return char_width(f, c);
+ }
+}
+
+static void stack_glue_into_box(pointer b, scaled min, scaled max) {
+ pointer p, q; /* new node placed into |b| */
+ q = new_spec(zero_glue);
+ width(q) = min;
+ stretch(q) = max-min;
+ p = new_glue(q);
+ reset_attributes(p, node_attr(b));
+ if (type(b) == vlist_node) {
+// vlink(p) = list_ptr(b);
+try_couple_nodes(p,list_ptr(b));
+ list_ptr(b) = p;
+ height(b) = height(p);
+ } else {
+ q = list_ptr(b);
+ if (q == null) {
+ list_ptr(b) = p;
+ } else {
+ while (vlink(q) != null)
+ q = vlink(q);
+ couple_nodes(q,p);
+ }
+ if (height(b) < height(p))
+ height(b) = height(p);
+ if (depth(b) < depth(p))
+ depth(b) = depth(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(extinfo * ext, internal_font_number f, scaled v,
+ pointer att, int boxtype, int cur_style)
+{
+ pointer b; /* new box */
+ scaled b_max; /* natural (maximum) size of the stack */
+ scaled s_max; /* amount of possible shrink in the stack */
+ 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| */
+ 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;
+
+ cur = ext;
+ while (cur != NULL) {
+ if (!char_exists(f, 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!",
+ NULL
+ };
+ tex_error("Variant part doesn't exist.", hlp);
+ width(b) = null_delimiter_space;
+ return b;
+ }
+ if (cur->extender > 0)
+ num_extenders++;
+ else
+ num_normal++;
+ /* 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.",
+ "To get around this problem, I have changed the font metrics.",
+ "Fix your font!",
+ NULL
+ };
+ tex_error("Extensible recipe has negative fields.", hlp);
+ if (cur->start_overlap < 0)
+ cur->start_overlap = 0;
+ if (cur->end_overlap < 0)
+ cur->end_overlap = 0;
+ if (cur->advance < 0)
+ cur->advance = 0;
+ }
+ cur = cur->next;
+ }
+ if (num_normal == 0) {
+ const char *hlp[] = {
+ "Each extensible recipe should have at least one non-repeatable part.",
+ "To get around this problem, I have changed the first part to be",
+ "non-repeatable. Fix your font!",
+ NULL
+ };
+ tex_error("Extensible recipe has no fixed parts.", hlp);
+ ext->extender = 0;
+ num_normal = 1;
+ num_extenders--;
+ }
+ /* |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.
+ */
+ cur = ext;
+ b_max = 0;
+ while (b_max < v && num_extenders > 0) {
+ b_max = 0;
+ prev_overlap = 0;
+ with_extenders++;
+ for (cur = ext; cur != NULL; cur = cur->next) {
+ if (cur->extender == 0) {
+ c = cur->start_overlap;
+ if (min_overlap < c)
+ c = min_overlap;
+ if (prev_overlap < c)
+ 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);
+ }
+ b_max += a - c;
+ prev_overlap = cur->end_overlap;
+ } else {
+ i = with_extenders;
+ while (i > 0) {
+ c = cur->start_overlap;
+ if (min_overlap < c)
+ c = min_overlap;
+ if (prev_overlap < c)
+ 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);
+ }
+ b_max += a - c;
+ prev_overlap = cur->end_overlap;
+ i--;
+ }
+ }
+ }
+ }
+
+ /* assemble box using |with_extenders| copies of each extender, with
+ appropriate glue wherever an overlap occurs */
+ prev_overlap = 0;
+ b_max = 0;
+ s_max = 0;
+ for (cur = ext; cur != NULL; cur = cur->next) {
+ if (cur->extender == 0) {
+ c = cur->start_overlap;
+ if (prev_overlap < c)
+ c = prev_overlap;
+ d = c;
+ if (min_overlap < c)
+ c = min_overlap;
+ if (d > 0) {
+ stack_glue_into_box(b, -d, -c);
+ s_max += (-c) - (-d);
+ b_max -= d;
+ }
+ b_max += stack_into_box(b, f, cur->glyph);
+ prev_overlap = cur->end_overlap;
+ i--;
+ } else {
+ i = with_extenders;
+ while (i > 0) {
+ c = cur->start_overlap;
+ if (prev_overlap < c)
+ c = prev_overlap;
+ d = c;
+ if (min_overlap < c)
+ c = min_overlap;
+ if (d > 0) {
+ stack_glue_into_box(b, -d, -c);
+ s_max += (-c) - (-d);
+ b_max -= d;
+ }
+ b_max += stack_into_box(b, f, cur->glyph);
+ prev_overlap = cur->end_overlap;
+ i--;
+ }
+ }
+ }
+
+ /* 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| */
+ if (d > s_max)
+ d = s_max;
+ glue_order(b) = normal;
+ glue_sign(b) = stretching;
+ glue_set(b) = unfloat(d/(float) s_max);
+ b_max += d;
+ }
+
+ if (boxtype == vlist_node)
+ height(b) = b_max;
+ else
+ width(b) = b_max;
+
+ return b;
+}
+
+static pointer get_delim_vbox(extinfo * ext, internal_font_number f, scaled v,
+ pointer att, int cur_style)
+{
+ return get_delim_box(ext, f, v, att, vlist_node, cur_style);
+}
+
+static pointer get_delim_hbox(extinfo * ext, internal_font_number f, scaled v,
+ pointer att, int cur_style)
+{
+ return get_delim_box(ext, f, v, att, hlist_node, cur_style);
+}
+
+
+
+@ 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
+static void endless_loop_error(internal_font_number g, int y)
+{
+ char s[256];
+ const char *hlp[] = {
+ "You managed to create a seemingly endless charlist chain in the current",
+ "font. I have counted until 10000 already and still have not escaped, so"
+ "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));
+ tex_error(s, hlp);
+}
+
+static pointer do_var_delimiter(pointer d, int s, scaled v, scaled * ic,
+ boolean flat, int cur_style)
+{
+ /* label found,continue; */
+ 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; /* largest height-plus-depth so far */
+ int z; /* runs through font family members */
+ boolean large_attempt; /* are we trying the ``large'' variant? */
+ pointer att; /* to save the current attribute list */
+ boolean do_parts;
+ extinfo *ext;
+ att = null;
+ f = null_font;
+ c = 0;
+ w = 0;
+ do_parts = false;
+ large_attempt = false;
+ if (d == null)
+ goto FOUND;
+ z = small_fam(d);
+ x = small_char(d);
+ i = 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. */
+ if ((z != 0) || (x != 0)) {
+ g = fam_fnt(z, s);
+ if (g != null_font) {
+ y = x;
+ CONTINUE:
+ i++;
+ if (char_exists(g, y)) {
+ if (flat)
+ u = char_width(g, y);
+ else
+ u = height_plus_depth(g, y);
+ if (u > w) {
+ f = g;
+ c = y;
+ w = u;
+ if (u >= v)
+ goto FOUND;
+ }
+ if (char_tag(g, y) == ext_tag) {
+ f = g;
+ c = y;
+ do_parts = true;
+ goto FOUND;
+ }
+ if (i > 10000) {
+ /* endless loop */
+ endless_loop_error(g, y);
+ goto FOUND;
+ }
+ if (char_tag(g, y) == list_tag) {
+ y = char_remainder(g, y);
+ goto CONTINUE;
+ }
+ }
+ }
+ }
+ if (large_attempt)
+ goto FOUND; /* there were none large enough */
+ large_attempt = true;
+ z = large_fam(d);
+ x = large_char(d);
+ }
+ FOUND:
+ if (d != null) {
+ att = node_attr(d);
+ node_attr(d) = null;
+ 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.
+ */
+ 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))) {
+ b = (flat ? get_delim_hbox(ext, f, v, att, cur_style) :
+ get_delim_vbox(ext, f, v, att, cur_style));
+ } else {
+ b = char_box(f, c, att);
+ }
+ /* This next test is because for OT MATH fonts, the italic correction of an
+ extensible character is only used for the placement of a subscript
+ (in negated form), and it is not supposed to be added to the
+ width of the character box at all.
+
+ This has an effect later on in |make_op| as well, where it has to do
+ an extra correction for |make_script|'s addition of yet another italic
+ correction.
+ */
+ if (!is_new_mathfont(f)) {
+ width(b) += char_italic(f, c);
+ }
+ if (ic != NULL)
+ *ic = char_italic(f, c);
+ } else {
+ b = new_null_box();
+ reset_attributes(b, att);
+ width(b) = (flat ? 0 : null_delimiter_space); /* use this width if no delimiter was found */
+ if (ic != NULL)
+ *ic = 0;
+ }
+ if (!flat)
+ shift_amount(b) = half(height(b) - depth(b)) - math_axis(s);
+ delete_attribute_ref(att);
+ return b;
+}
+
+
+static pointer var_delimiter(pointer d, int s, scaled v, scaled * ic,
+ int cur_style)
+{
+ return do_var_delimiter(d, s, v, ic, false, cur_style);
+}
+
+static pointer flat_delimiter(pointer d, int s, scaled v, int cur_style)
+{
+ return do_var_delimiter(d, s, v, NULL, true, cur_style);
+}
+
+@ 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.
+
+@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 */
+
+ if ((width(b) != w) && (list_ptr(b) != null)) {
+ if (type(b) == vlist_node) {
+ p = hpack(b, 0, additional, -1);
+ reset_attributes(p, node_attr(b));
+ b = p;
+ }
+ p = list_ptr(b);
+ att = node_attr(b);
+ add_node_attr_ref(att);
+ if ((is_char_node(p)) && (vlink(p) == null)) {
+ f = font(p);
+ v = char_width(f, character(p));
+ if (v != width(b)) {
+ q = new_kern(width(b) - v);
+ reset_attributes(q, att);
+ couple_nodes(p,q);
+ }
+ }
+ list_ptr(b) = null;
+ flush_node(b);
+ b = new_glue(ss_glue);
+ reset_attributes(b, att);
+ couple_nodes(b,p);
+ while (vlink(p) != null)
+ p = vlink(p);
+ q = new_glue(ss_glue);
+ reset_attributes(q, att);
+ couple_nodes(p,q);
+ r = hpack(b, w, exactly, -1);
+ reset_attributes(r, att);
+ delete_attribute_ref(att);
+ return r;
+ } else {
+ width(b) = w;
+ return b;
+ }
+}
+
+@ 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)
+{
+ pointer p; /* the new glue specification */
+ int n; /* integer part of |m| */
+ scaled f; /* fraction part of |m| */
+ n = x_over_n(m, unity);
+ f = tex_remainder;
+ if (f < 0) {
+ decr(n);
+ f = f + unity;
+ }
+ p = new_node(glue_spec_node, 0);
+ width(p) = mu_mult(width(g)); /* convert \.{mu} to \.{pt} */
+ stretch_order(p) = stretch_order(g);
+ if (stretch_order(p) == normal)
+ stretch(p) = mu_mult(stretch(g));
+ else
+ stretch(p) = stretch(g);
+ shrink_order(p) = shrink_order(g);
+ if (shrink_order(p) == normal)
+ shrink(p) = mu_mult(shrink(g));
+ else
+ shrink(p) = shrink(g);
+ return p;
+}
+
+@ 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| */
+ if (subtype(p) == mu_glue) {
+ n = x_over_n(m, unity);
+ f = tex_remainder;
+ if (f < 0) {
+ decr(n);
+ f = f + unity;
+ }
+ width(p) = mu_mult(width(p));
+ subtype(p) = explicit;
+ }
+}
+
+@ @c
+void run_mlist_to_hlist(halfword p, int mstyle, boolean penalties)
+{
+ int callback_id;
+ int a, sfix;
+ lua_State *L = Luas;
+ if (p == null) {
+ vlink(temp_head) = null;
+ return;
+ }
+ finalize_math_parameters();
+ callback_id = callback_defined(mlist_to_hlist_callback);
+ if (callback_id > 0) {
+ sfix = lua_gettop(L);
+ if (!get_callback(L, callback_id)) {
+ lua_settop(L, sfix);
+ return;
+ }
+ alink(p) = null ;
+ nodelist_to_lua(L, p); /* arg 1 */
+ lua_pushstring(L, math_style_names[mstyle]); /* arg 2 */
+ lua_pushboolean(L, penalties); /* arg 3 */
+ if (lua_pcall(L, 3, 1, 0) != 0) { /* 3 args, 1 result */
+ fprintf(stdout, "error: %s\n", lua_tostring(L, -1));
+ lua_settop(L, sfix);
+ error();
+ return;
+ }
+ a = nodelist_from_lua(L);
+ /* alink(vlink(a)) = null; */ /* hh-ls: not need to null here */
+ lua_settop(L, sfix);
+ vlink(temp_head) = a;
+ } else if (callback_id == 0) {
+ mlist_to_hlist_args(p, mstyle, penalties);
+ } else {
+ vlink(temp_head) = null;
+ }
+}
+
+@ 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@>
+
+
+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 */
+ switch (type(p)) {
+ case math_char_node:
+ mlist = new_noad();
+ r = math_clone(p);
+ nucleus(mlist) = r;
+ break;
+ case sub_box_node:
+ q = math_list(p);
+ goto FOUND;
+ break;
+ case sub_mlist_node:
+ mlist = math_list(p);
+ break;
+ default:
+ q = new_null_box();
+ goto FOUND;
+ }
+ mlist_to_hlist_args(mlist, s, false);
+ q = vlink(temp_head); /* recursive call */
+ 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 */
+ 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. */
+ q = list_ptr(x);
+ if (is_char_node(q)) {
+ r = vlink(q);
+ if (r != null) {
+ if (vlink(r) == null) {
+ if (!is_char_node(r)) {
+ if (type(r) == kern_node) {
+ /* unneeded italic correction */
+ flush_node(r);
+ vlink(q) = null;
+ }
+ }
+ }
+ }
+ }
+ 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|.
+
+The outputs of |fetch| are placed in global variables.
+
+@c
+internal_font_number cur_f; /* the |font| field of a |math_char| */
+int cur_c; /* the |character| field of a |math_char| */
+
+static void fetch(pointer a)
+{ /* unpack the |math_char| field |a| */
+ cur_c = math_character(a);
+ cur_f = fam_fnt(math_fam(a), cur_size);
+ if (cur_f == null_font) {
+ char *msg;
+ const char *hlp[] = {
+ "Somewhere in the math formula just ended, you used the",
+ "stated character from an undefined font family. For example,",
+ "plain TeX doesn't allow \\it or \\sl in subscripts. Proceed,",
+ "and I'll try to forget that I needed that character.",
+ NULL
+ };
+ msg = xmalloc(256);
+ snprintf(msg, 255, "\\%s%d is undefined (character %d)",
+ math_size_string(cur_size), (int) math_fam(a), (int) cur_c);
+ tex_error(msg, hlp);
+ free(msg);
+ } else {
+ if (!(char_exists(cur_f, cur_c))) {
+ char_warning(cur_f, cur_c);
+ }
+ }
+}
+
+
+@ 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 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;
+ }
+ 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.
+
+@c
+static void make_over(pointer q, int cur_style)
+{
+ pointer p;
+ 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_list(nucleus(q)) = p;
+ type(nucleus(q)) = sub_box_node;
+}
+
+static void make_under(pointer q, int cur_style)
+{
+ pointer p, x, y, r; /* temporary registers for box construction */
+ scaled delta; /* overall height plus depth */
+ 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));
+ couple_nodes(p,r);
+ y = vpackage(x, 0, additional, max_dimen, math_direction);
+ reset_attributes(y, node_attr(q));
+ delta = height(y) + depth(y) + underbar_kern(cur_style);
+ height(y) = height(x);
+ depth(y) = delta - height(y);
+ math_list(nucleus(q)) = y;
+ type(nucleus(q)) = sub_box_node;
+}
+
+static void make_vcenter(pointer q)
+{
+ pointer v; /* the box that should be centered vertically */
+ scaled delta; /* its height plus depth */
+ v = math_list(nucleus(q));
+ if (type(v) != vlist_node)
+ confusion("vcenter"); /* this can't happen vcenter */
+ delta = height(v) + depth(v);
+ height(v) = math_axis(cur_size) + half(delta);
+ 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.
+
+@c
+static void make_radical(pointer q, int cur_style)
+{
+ pointer x, y, p; /* temporary registers for box construction */
+ scaled delta, clr, theta, h; /* dimensions involved in the calculation */
+ x = clean_box(nucleus(q), cramped_style(cur_style), cur_style);
+ clr = radical_vgap(cur_style);
+ theta = radical_rule(cur_style);
+ if (theta == undefined_math_parameter) {
+ theta = fraction_rule(cur_style);
+ y = var_delimiter(left_delimiter(q), cur_size,
+ height(x) + depth(x) + clr + theta, NULL, cur_style);
+ /* If |y| is a composite then set |theta| to the height of its top
+ character, else set it to the height of |y|. */
+ if (list_ptr(y) != null
+ && type(list_ptr(y)) == hlist_node
+ && list_ptr(list_ptr(y)) != null
+ && type(list_ptr(list_ptr(y))) == glyph_node) { /* and it should be */
+ theta = char_height(font(list_ptr(list_ptr(y))),
+ character(list_ptr(list_ptr(y))));
+ } else {
+ theta = height(y);
+ }
+ } else {
+ y = var_delimiter(left_delimiter(q), cur_size,
+ height(x) + depth(x) + clr + theta, NULL, cur_style);
+ }
+ left_delimiter(q) = null;
+ delta = (depth(y) + height(y) - theta) - (height(x) + depth(x) + clr);
+ if (delta > 0)
+ clr = clr + half(delta); /* increase the actual clearance */
+ 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));
+ couple_nodes(y,p);
+ if (degree(q) != null) {
+ scaled wr, br, ar;
+ pointer r = clean_box(degree(q), script_script_style, cur_style);
+ reset_attributes(r, node_attr(degree(q)));
+ wr = width(r);
+ if (wr == 0) {
+ flush_node(r);
+ } else {
+ br = radical_degree_before(cur_style);
+ ar = radical_degree_after(cur_style);
+ if (-ar > (wr + br))
+ ar = -(wr + br);
+ x = new_kern(ar);
+ reset_attributes(x, node_attr(degree(q)));
+ couple_nodes(x,y);
+ shift_amount(r) =
+ -((xn_over_d(h, radical_degree_raise(cur_style), 100)) -
+ depth(y) - shift_amount(y));
+ couple_nodes(r,x);
+ x = new_kern(br);
+ reset_attributes(x, node_attr(degree(q)));
+ couple_nodes(x,r);
+ y = x;
+ }
+ math_list(degree(q)) = null; /* for \.{\\Uroot ..{<list>}{}} */
+ flush_node(degree(q));
+ }
+ p = hpack(y, 0, additional, -1);
+ reset_attributes(p, node_attr(q));
+ math_list(nucleus(q)) = p;
+ type(nucleus(q)) = sub_box_node;
+}
+
+
+@ Construct a vlist box
+@c
+static pointer
+wrapup_delimiter(pointer x, pointer y, pointer q,
+ scaled shift_up, scaled shift_down)
+{
+ pointer p; /* temporary register for box construction */
+ pointer v = new_null_box();
+ type(v) = vlist_node;
+ height(v) = shift_up + height(x);
+ depth(v) = depth(y) + shift_down;
+ reset_attributes(v, node_attr(q));
+ p = new_kern((shift_up - depth(x)) - (height(y) - shift_down));
+ reset_attributes(p, node_attr(q));
+ couple_nodes(p,y);
+ couple_nodes(x,p);
+ list_ptr(v) = x;
+ return v;
+}
+
+@ @c
+#define fixup_widths(x,y) do { \
+ if (width(y) >= width(x)) { \
+ width(x) = width(y); \
+ } else { \
+ width(y) = width(x); \
+ } \
+ } while (0)
+
+@ 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 */
+ scaled shift_up, shift_down, clr, delta;
+ x = clean_box(nucleus(q), sub_style(cur_style), cur_style);
+ y = flat_delimiter(left_delimiter(q), cur_size, width(x), cur_style);
+ left_delimiter(q) = null;
+ fixup_widths(x, y);
+ shift_up = over_delimiter_bgap(cur_style);
+ shift_down = 0;
+ clr = over_delimiter_vgap(cur_style);
+ delta = clr - ((shift_up - depth(x)) - (height(y) - shift_down));
+ if (delta > 0) {
+ shift_up = shift_up + delta;
+ }
+ v = wrapup_delimiter(x, y, q, shift_up, shift_down);
+ width(v) = width(x); /* this also equals |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|
+
+@c
+static void make_delimiter_over(pointer q, int cur_style)
+{
+ pointer x, y, v; /* temporary registers for box construction */
+ scaled shift_up, shift_down, clr, actual;
+ y = clean_box(nucleus(q), cur_style, cur_style);
+ x = flat_delimiter(left_delimiter(q),
+ cur_size + (cur_size == script_script_size ? 0 : 1),
+ width(y), cur_style);
+ left_delimiter(q) = null;
+ fixup_widths(x, y);
+ shift_up = over_delimiter_bgap(cur_style)-height(x)-depth(x);
+ shift_down = 0;
+ clr = over_delimiter_vgap(cur_style);
+ actual = shift_up - height(y);
+ if (actual < clr) {
+ shift_up = shift_up + (clr-actual);
+ }
+ v = wrapup_delimiter(x, y, q, shift_up, shift_down);
+ width(v) = width(x); /* this also equals |width(y)| */
+ 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|
+
+@c
+static void make_delimiter_under(pointer q, int cur_style)
+{
+ pointer x, y, v; /* temporary registers for box construction */
+ scaled shift_up, shift_down, clr, actual;
+ x = clean_box(nucleus(q), cur_style, cur_style);
+ y = flat_delimiter(left_delimiter(q),
+ cur_size + (cur_size == script_script_size ? 0 : 1),
+ width(x), cur_style);
+ left_delimiter(q) = null;
+ fixup_widths(x, y);
+ shift_up = 0;
+ shift_down = under_delimiter_bgap(cur_style) - height(y)-depth(y);
+ clr = under_delimiter_vgap(cur_style);
+ actual = shift_down - depth(x);
+ if (actual<clr) {
+ shift_down += (clr-actual);
+ }
+ v = wrapup_delimiter(x, y, q, shift_up, shift_down);
+ width(v) = width(y); /* this also equals |width(y)| */
+ math_list(nucleus(q)) = v;
+ type(nucleus(q)) = sub_box_node;
+
+}
+
+@ 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 */
+ scaled shift_up, shift_down, clr, delta;
+ y = clean_box(nucleus(q), sup_style(cur_style), cur_style);
+ x = flat_delimiter(left_delimiter(q), cur_size, width(y), cur_style);
+ left_delimiter(q) = null;
+ fixup_widths(x, y);
+ shift_up = 0;
+ shift_down = under_delimiter_bgap(cur_style);
+ clr = under_delimiter_vgap(cur_style);
+ delta = clr - ((shift_up - depth(x)) - (height(y) - shift_down));
+ if (delta > 0) {
+ shift_down = shift_down + delta;
+ }
+ v = wrapup_delimiter(x, y, q, shift_up, shift_down);
+ width(v) = width(y); /* this also equals |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.
+
+@c
+#define TOP_CODE 1
+#define BOT_CODE 2
+#define TOP_OR_BOT_MASK ((TOP_CODE) | (BOT_CODE))
+#define STRETCH_ACCENT_CODE 4
+
+static boolean compute_accent_skew(pointer q, int top_or_bot, scaled *s)
+{
+ pointer p; /* temporary register for box construction */
+ boolean s_is_absolute; /* will be true if a top-accent is placed in |s| */
+
+ s_is_absolute = false;
+
+ if (type(nucleus(q)) == math_char_node) {
+ fetch(nucleus(q));
+ if (is_new_mathfont(cur_f)) {
+ if (top_or_bot == TOP_CODE) {
+ *s = char_top_accent(cur_f, cur_c);
+ if (*s != INT_MIN) {
+ s_is_absolute = true;
+ }
+ } else {
+ *s = char_bot_accent(cur_f, cur_c);
+ if (*s != INT_MIN) {
+ s_is_absolute = true;
+ }
+ }
+ } else {
+ if (top_or_bot == TOP_CODE) {
+ *s = get_kern(cur_f, cur_c, skew_char(cur_f));
+ } else {
+ *s = 0;
+ }
+ }
+ } 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. */
+ p = math_list(nucleus(q));
+ if (type(p) == accent_noad) {
+ s_is_absolute = compute_accent_skew(p, top_or_bot, s);
+ }
+ }
+
+ return s_is_absolute;
+}
+
+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| */
+ extinfo *ext;
+ pointer attr_p;
+ const int top_or_bot = flags & TOP_OR_BOT_MASK;
+ attr_p = (top_or_bot == TOP_CODE ? accent_chr(q) : bot_accent_chr(q));
+ c = cur_c;
+ f = cur_f;
+
+ s = 0;
+ s_is_absolute = false;
+ /* Compute the amount of skew, or set |s| to an alignment point */
+ s_is_absolute = compute_accent_skew(q, top_or_bot, &s);
+
+ x = clean_box(nucleus(q), cramped_style(cur_style), cur_style);
+ w = width(x);
+ h = height(x);
+ if (is_new_mathfont(cur_f) && !s_is_absolute) {
+ s = half(w);
+ s_is_absolute = true;
+ }
+ /* Switch to a larger accent if available and appropriate */
+ y = null;
+ ext = NULL;
+ 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)) {
+ y = get_delim_hbox(ext, f, w, node_attr(attr_p), cur_style);
+ break;
+ } else if (char_tag(f, c) != list_tag) {
+ break;
+ } else {
+ int yy = char_remainder(f, c);
+ if (!char_exists(f, yy))
+ break;
+ if (char_width(f, yy) > w)
+ break;
+ c = yy;
+ }
+ }
+ }
+ if (y == null) {
+ y = char_box(f, c, node_attr(attr_p));
+ }
+ if (top_or_bot == TOP_CODE) {
+ if (h < accent_base_height(f))
+ delta = h;
+ else
+ delta = accent_base_height(f);
+ } 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| */
+ flush_node_list(x);
+ x = new_noad();
+ r = math_clone(nucleus(q));
+ nucleus(x) = r;
+ supscr(x) = supscr(q);
+ supscr(q) = null;
+ subscr(x) = subscr(q);
+ subscr(q) = null;
+ type(nucleus(q)) = sub_mlist_node;
+ math_list(nucleus(q)) = x;
+ x = clean_box(nucleus(q), cur_style, cur_style);
+ delta = delta + height(x) - h;
+ h = height(x);
+ }
+ }
+ if (s_is_absolute) {
+ scaled sa;
+ if (ext != NULL) {
+ sa = half(width(y)); /* if the accent is extensible just take the center */
+ } else {
+ sa = char_top_accent(f, c);
+ }
+ if (sa == INT_MIN) {
+ sa = half(width(y)); /* just take the center */
+ }
+ shift_amount(y) = s - sa;
+ } else {
+ if (width(y)== 0) {
+ shift_amount(y) = s + w;
+ } else {
+ shift_amount(y) = s + half(w - width(y));
+ }
+ }
+ width(y) = 0;
+ if (top_or_bot == TOP_CODE) {
+ p = new_kern(-delta);
+ couple_nodes(p,x);
+ couple_nodes(y,p);
+ } else {
+#if 0
+ p = new_kern(-delta);
+ couple_nodes(x,p);
+ couple_nodes(p,y);
+ y = x;
+#endif
+ couple_nodes(x,y);
+ y = x;
+ }
+ r = vpackage(y, 0, additional, max_dimen, math_direction);
+ reset_attributes(r, node_attr(q));
+ width(r) = width(x);
+ y = r;
+ if (top_or_bot == TOP_CODE) {
+ if (height(y) < h) {
+ /* Make the height of box |y| equal to |h| */
+ p = new_kern(h - height(y));
+ reset_attributes(p, node_attr(q));
+// vlink(p) = list_ptr(y);
+try_couple_nodes(p,list_ptr(y));
+ list_ptr(y) = p;
+ height(y) = h;
+ }
+ } else {
+ shift_amount(y) = -(h - height(y));
+ }
+ math_list(nucleus(q)) = y;
+ type(nucleus(q)) = sub_box_node;
+}
+
+static void make_math_accent(pointer q, int cur_style)
+{
+ int topstretch = !(subtype(q) % 2);
+ int botstretch = !(subtype(q) / 2);
+
+ if (accent_chr(q) != null) {
+ fetch(accent_chr(q));
+ if (char_exists(cur_f, cur_c)) {
+ do_make_math_accent(q, cur_f, cur_c, TOP_CODE | (topstretch ? STRETCH_ACCENT_CODE : 0), cur_style);
+ }
+ flush_node(accent_chr(q));
+ accent_chr(q) = null;
+ }
+ if (bot_accent_chr(q) != null) {
+ fetch(bot_accent_chr(q));
+ if (char_exists(cur_f, cur_c)) {
+ do_make_math_accent(q, cur_f, cur_c, BOT_CODE | (botstretch ? STRETCH_ACCENT_CODE : 0), cur_style);
+ }
+ flush_node(bot_accent_chr(q));
+ bot_accent_chr(q) = null;
+ }
+}
+
+@ 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, v, x, y, z; /* temporary registers for box construction */
+ scaled delta, delta1, delta2, shift_up, shift_down, clr;
+ /* dimensions for box calculations */
+ if (thickness(q) == default_code)
+ thickness(q) = fraction_rule(cur_style);
+ /* 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 */
+ x = clean_box(numerator(q), num_style(cur_style), cur_style);
+ z = clean_box(denominator(q), denom_style(cur_style), cur_style);
+ if (width(x) < width(z))
+ x = rebox(x, width(z));
+ else
+ z = rebox(z, width(x));
+ 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|. */
+ clr = stack_vgap(cur_style);
+ delta = half(clr - ((shift_up - depth(x)) - (height(z) - shift_down)));
+ if (delta > 0) {
+ shift_up = shift_up + delta;
+ shift_down = shift_down + delta;
+ }
+ } 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. */
+ delta = half(thickness(q));
+ clr = fraction_num_vgap(cur_style);
+ clr = ext_xn_over_d(clr, thickness(q), fraction_rule(cur_style));
+ delta1 = clr - ((shift_up - depth(x)) - (math_axis(cur_size) + delta));
+ if (delta1 > 0)
+ shift_up = shift_up + delta1;
+ clr = fraction_denom_vgap(cur_style);
+ clr = ext_xn_over_d(clr, thickness(q), fraction_rule(cur_style));
+ delta2 =
+ clr - ((math_axis(cur_size) - delta) - (height(z) - shift_down));
+ if (delta2 > 0)
+ shift_down = shift_down + delta2;
+ }
+ /* 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)| */
+ 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));
+ p = new_kern((math_axis(cur_size) - delta) - (height(z) - shift_down));
+ reset_attributes(p, node_attr(q));
+ couple_nodes(y,p);
+ couple_nodes(p,z);
+ p = new_kern((shift_up - depth(x)) - (math_axis(cur_size) + delta));
+ couple_nodes(p,y);
+ }
+ reset_attributes(p, node_attr(q));
+ 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 */
+ delta = fraction_del_size(cur_style);
+ x = var_delimiter(left_delimiter(q), cur_size, delta, NULL, cur_style);
+ left_delimiter(q) = null;
+ couple_nodes(x,v);
+ z = var_delimiter(right_delimiter(q), cur_size, delta, NULL, cur_style);
+ right_delimiter(q) = null;
+ couple_nodes(v,z);
+ y = hpack(x, 0, additional, -1);
+ reset_attributes(y, node_attr(q));
+ 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.
+
+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.
+
+@c
+static scaled make_op(pointer q, int cur_style)
+{
+ scaled delta; /* offset between subscript and superscript */
+ pointer p, v, x, y, z; /* temporary registers for box construction */
+ int c; /* register for character examination */
+ scaled shift_up, shift_down; /* dimensions for box calculation */
+ scaled ok_size;
+ if ((subtype(q) == op_noad_type_normal) && (cur_style < text_style))
+ subtype(q) = op_noad_type_limits;
+ if (type(nucleus(q)) == math_char_node) {
+ fetch(nucleus(q));
+ if (cur_style < text_style) { /* 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 */
+ y = new_node(delim_node, 0);
+ small_fam(y) = math_fam(nucleus(q));
+ small_char(y) = math_character(nucleus(q));
+ x = var_delimiter(y, text_size, ok_size, &delta, cur_style);
+ if ((subscr(q) != null) && (subtype(q) != op_noad_type_limits)) {
+ width(x) -= delta; /* remove italic correction */
+ }
+ /* For an OT MATH font, we may have to get rid of yet another italic
+ correction because |make_scripts()| will add one.
+ This test is somewhat more complicated because |x| can be a null
+ delimiter */
+ if ((subscr(q) != null || supscr(q) != null)
+ && (subtype(q) != op_noad_type_limits)
+ && ((list_ptr(x) != null)
+ && (type(list_ptr(x)) == glyph_node)
+ && is_new_mathfont(font(list_ptr(x))))) {
+ width(x) -= delta; /* remove another italic correction */
+ }
+ } else {
+ ok_size = height_plus_depth(cur_f, cur_c) + 1;
+ while ((char_tag(cur_f, cur_c) == list_tag) &&
+ height_plus_depth(cur_f, cur_c) < ok_size) {
+ c = char_remainder(cur_f, cur_c);
+ if (!char_exists(cur_f, c))
+ break;
+ cur_c = c;
+ math_character(nucleus(q)) = c;
+ }
+ delta = char_italic(cur_f, cur_c);
+ x = clean_box(nucleus(q), cur_style, cur_style);
+ if ((subscr(q) != null) && (subtype(q) != op_noad_type_limits))
+ width(x) = width(x) - delta; /* remove italic correction */
+
+ shift_amount(x) =
+ half(height(x) - depth(x)) - math_axis(cur_size);
+ /* center vertically */
+ }
+ type(nucleus(q)) = sub_box_node;
+ math_list(nucleus(q)) = x;
+
+ } else { /* normal size */
+ delta = char_italic(cur_f, cur_c);
+ x = clean_box(nucleus(q), cur_style, cur_style);
+ if ((subscr(q) != null) && (subtype(q) != op_noad_type_limits))
+ width(x) = width(x) - delta; /* remove italic correction */
+
+ /* For an OT MATH font, we may have to get rid of yet another italic
+ correction because |make_scripts()| will add one.
+ This test is somewhat more complicated because |x| can be a null
+ delimiter */
+ if ((subscr(q) != null || supscr(q) != null)
+ && (subtype(q) != op_noad_type_limits)
+ && ((list_ptr(x) != null)
+ && (type(list_ptr(x)) == glyph_node)
+ && is_new_mathfont(font(list_ptr(x))))) {
+ width(x) -= delta; /* remove another italic correction */
+ }
+
+ shift_amount(x) = half(height(x) - depth(x)) - math_axis(cur_size);
+ /* center vertically */
+ type(nucleus(q)) = sub_box_node;
+ math_list(nucleus(q)) = x;
+ }
+ } else {
+ delta = 0;
+ }
+ 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. */
+ 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);
+ v = new_null_box();
+ reset_attributes(v, node_attr(q));
+ type(v) = vlist_node;
+ width(v) = width(y);
+ if (width(x) > width(v))
+ width(v) = width(x);
+ if (width(z) > width(v))
+ width(v) = width(z);
+ x = rebox(x, width(v));
+ y = rebox(y, width(v));
+ z = rebox(z, width(v));
+ shift_amount(x) = half(delta);
+ shift_amount(z) = -shift_amount(x);
+ height(v) = height(y);
+ depth(v) = depth(y);
+ /* Attach the limits to |y| and adjust |height(v)|, |depth(v)| to
+ account for their presence */
+ /* 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|. 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. */
+ if (supscr(q) == null) {
+ list_ptr(x) = null;
+ flush_node(x);
+ list_ptr(v) = y;
+ } else {
+ shift_up = limit_above_bgap(cur_style) - depth(x);
+ if (shift_up < limit_above_vgap(cur_style))
+ shift_up = limit_above_vgap(cur_style);
+ p = new_kern(shift_up);
+ reset_attributes(p, node_attr(q));
+ couple_nodes(p,y);
+ couple_nodes(x,p);
+ p = new_kern(limit_above_kern(cur_style));
+ reset_attributes(p, node_attr(q));
+ couple_nodes(p,x);
+ list_ptr(v) = p;
+ height(v) =
+ height(v) + limit_above_kern(cur_style) + height(x) + depth(x) +
+ shift_up;
+ }
+ if (subscr(q) == null) {
+ list_ptr(z) = null;
+ flush_node(z);
+ } else {
+ shift_down = limit_below_bgap(cur_style) - height(z);
+ if (shift_down < limit_below_vgap(cur_style))
+ shift_down = limit_below_vgap(cur_style);
+ p = new_kern(shift_down);
+ reset_attributes(p, node_attr(q));
+ couple_nodes(y,p);
+ couple_nodes(p,z);
+ p = new_kern(limit_below_kern(cur_style));
+ reset_attributes(p, node_attr(q));
+ couple_nodes(z,p);
+ depth(v) =
+ depth(v) + limit_below_kern(cur_style) + height(z) + depth(z) +
+ shift_down;
+ }
+ if (subscr(q) != null) {
+ math_list(subscr(q)) = null;
+ flush_node(subscr(q));
+ subscr(q) = null;
+ }
+ if (supscr(q) != null) {
+ math_list(supscr(q)) = null;
+ flush_node(supscr(q));
+ supscr(q) = null;
+ }
+ assign_new_hlist(q, v);
+ }
+ 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|.
+
+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
+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 */
+ RESTART:
+ if (subscr(q) == null &&
+ supscr(q) == null && type(nucleus(q)) == math_char_node) {
+ p = vlink(q);
+ if ((p != null) &&
+ (type(p) == simple_noad) &&
+ (subtype(p) <= punct_noad_type) &&
+ (type(nucleus(p)) == math_char_node) &&
+ (math_fam(nucleus(p)) == math_fam(nucleus(q)))) {
+ type(nucleus(q)) = math_text_char_node;
+ fetch(nucleus(q));
+ a = cur_c;
+ 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| */
+
+ /* 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.
+ But 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 == 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 */
+ switch (lig_type(lig)) {
+ case 1:
+ case 5:
+ math_character(nucleus(q)) = lig_replacement(lig); /* \.{=:\char`\|}, \.{=:\char`\|>} */
+ break;
+ case 2:
+ case 6:
+ math_character(nucleus(p)) = lig_replacement(lig); /* \.{\char`\|=:}, \.{\char`\|=:>} */
+ break;
+ case 3:
+ case 7:
+ case 11:
+ r = new_noad(); /* \.{\char`\|=:\char`\|}, \.{\char`\|=:\char`\|>}, \.{\char`\|=:\char`\|>>} */
+ reset_attributes(r, node_attr(q));
+ s = new_node(math_char_node, 0);
+ reset_attributes(s, node_attr(q));
+ nucleus(r) = s;
+ math_character(nucleus(r)) = lig_replacement(lig);
+ math_fam(nucleus(r)) = math_fam(nucleus(q));
+ couple_nodes(q,r);
+ couple_nodes(r,p);
+ if (lig_type(lig) < 11)
+ type(nucleus(r)) = math_char_node;
+ else
+ type(nucleus(r)) = math_text_char_node; /* prevent combination */
+ break;
+ default:
+ 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));
+ flush_node(p);
+ break;
+ }
+ if (lig_type(lig) > 3)
+ return;
+ type(nucleus(q)) = math_char_node;
+ goto RESTART;
+ }
+ }
+ if (disable_kern == 0 && has_kern(cur_f, a)) {
+ k = get_kern(cur_f, a, cur_c); /* todo: should this use mathkerns? */
+ if (k != 0) {
+ p = new_kern(k);
+ reset_attributes(p, node_attr(q));
+ couple_nodes(p,vlink(q));
+ couple_nodes(q,p);
+ return;
+ }
+ }
+ }
+ }
+ }
+}
+
+@ 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.
+
+ 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 */
+ 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) {
+ kerns_heights = co->top_left_math_kern_array;
+ } else if (side == bottom_left_kern) {
+ kerns_heights = co->bottom_left_math_kern_array;
+ } else if (side == top_right_kern) {
+ kerns_heights = co->top_right_math_kern_array;
+ } else if (side == bottom_right_kern) {
+ kerns_heights = co->bottom_right_math_kern_array;
+ } else {
+ confusion("math_kern_at");
+ kerns_heights = NULL; /* not reached */
+ }
+#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;
+ }
+ }
+ 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)
+{
+ scaled corr_height_top = 0, corr_height_bot = 0;
+ scaled krn_l = 0, krn_r = 0, krn = 0;
+ if ((!is_new_mathfont(l_f)) || (!is_new_mathfont(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 */
+ 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 */
+ 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 */
+}
+
+@ just a small helper
+@c
+static pointer attach_hkern_to_new_hlist(pointer q, scaled delta2)
+{
+ pointer y;
+ pointer z = new_kern(delta2);
+ if (new_hlist(q) == null) { /* this is somewhat weird */
+ new_hlist(q) = z;
+ } else {
+ y = new_hlist(q);
+ while (vlink(y) != null)
+ y = vlink(y);
+ couple_nodes(y,z);
+ }
+ 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;
+ }
+}
+
+
+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|.
+
+We set |shift_down| and |shift_up| to the minimum amounts to shift the
+baseline of subscripts and superscripts based on the given nucleus.
+
+@c
+static void make_scripts(pointer q, pointer p, scaled it, int cur_style)
+{
+ pointer x, y, z; /* temporary registers for box construction */
+ scaled shift_up, shift_down, clr; /* dimensions in the calculation */
+ scaled delta1, delta2;
+ 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
+ switch (type(nucleus(q))) {
+ case math_char_node:
+ case math_text_char_node:
+ if ((subscr(q) == null) && (delta1 != 0)) {
+ x = new_kern(delta1);
+ reset_attributes(x, node_attr(nucleus(q)));
+ couple_nodes(p,x);
+ delta1 = 0;
+ }
+ }
+ assign_new_hlist(q, p);
+ if (is_char_node(p)) {
+ shift_up = 0;
+ shift_down = 0;
+ } else {
+ z = hpack(p, 0, additional, -1);
+ shift_up = height(z) - sup_shift_drop(cur_style); /* r18 */
+ shift_down = depth(z) + sub_shift_drop(cur_style); /* r19 */
+ list_ptr(z) = null;
+ flush_node(z);
+ }
+ if (supscr(q) == null) {
+ /* 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);
+ width(x) = width(x) + space_after_script(cur_style);
+ if (shift_down < sub_shift_down(cur_style))
+ shift_down = sub_shift_down(cur_style);
+ clr = height(x) - sub_top_max(cur_style);
+ if (shift_down < clr)
+ shift_down = clr;
+ shift_amount(x) = shift_down;
+
+ /* now find and correct for horizontal shift */
+ if (is_char_node(p) && subscr(q) != null
+ && type(subscr(q)) == math_char_node) {
+ fetch(subscr(q));
+ if (char_exists(cur_f, cur_c)) {
+ delta2 =
+ find_math_kern(font(p), character(p), cur_f, cur_c,
+ sub_mark_cmd, shift_down);
+ if (delta2 != MATH_KERN_NOT_FOUND && delta2 != 0) {
+ p = attach_hkern_to_new_hlist(q, delta2);
+ }
+ }
+ }
+
+ } else {
+ /* Construct a superscript box |x| */
+ /*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);
+ width(x) = width(x) + space_after_script(cur_style);
+ clr = sup_shift_up(cur_style);
+ if (shift_up < clr)
+ shift_up = clr;
+ clr = depth(x) + sup_bottom_min(cur_style);
+ if (shift_up < clr)
+ shift_up = clr;
+
+ if (subscr(q) == null) {
+ shift_amount(x) = -shift_up;
+ /* now find and correct for horizontal shift */
+ if (is_char_node(p) && type(supscr(q)) == math_char_node) {
+ fetch(supscr(q));
+ if (char_exists(cur_f, cur_c)) {
+ clr =
+ find_math_kern(font(p), character(p), cur_f, cur_c,
+ sup_mark_cmd, shift_up);
+ if (clr != MATH_KERN_NOT_FOUND && clr != 0) {
+ p = attach_hkern_to_new_hlist(q, clr);
+ }
+ }
+ }
+ } else {
+ /* 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. */
+
+ y = clean_box(subscr(q), sub_style(cur_style), cur_style);
+ width(y) = width(y) + space_after_script(cur_style);
+ if (shift_down < sub_sup_shift_down(cur_style))
+ shift_down = sub_sup_shift_down(cur_style);
+ clr = subsup_vgap(cur_style) -
+ ((shift_up - depth(x)) - (height(y) - shift_down));
+ if (clr > 0) {
+ shift_down = shift_down + clr;
+ clr = sup_sub_bottom_max(cur_style) - (shift_up - depth(x));
+ if (clr > 0) {
+ shift_up = shift_up + clr;
+ shift_down = shift_down - clr;
+ }
+ }
+ /* now find and correct for horizontal shift */
+ if (is_char_node(p) && subscr(q) != null
+ && type(subscr(q)) == math_char_node) {
+ fetch(subscr(q));
+ if (char_exists(cur_f, cur_c)) {
+ delta2 =
+ find_math_kern(font(p), character(p), cur_f, cur_c,
+ sub_mark_cmd, shift_down);
+ if (delta2 != MATH_KERN_NOT_FOUND && delta2 != 0) {
+ p = attach_hkern_to_new_hlist(q, delta2);
+ }
+ }
+ }
+ /* 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 (is_char_node(p) && supscr(q) != null
+ && type(supscr(q)) == math_char_node) {
+ fetch(supscr(q));
+ if (char_exists(cur_f, cur_c)) {
+ clr =
+ find_math_kern(font(p), character(p), cur_f, cur_c,
+ sup_mark_cmd, shift_up);
+ }
+ }
+ if (delta2 == MATH_KERN_NOT_FOUND)
+ delta2 = 0;
+ if (clr != MATH_KERN_NOT_FOUND) {
+ shift_amount(x) = clr + delta1 - delta2;
+ } else {
+ shift_amount(x) = delta1 - delta2;
+ }
+ 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);
+ x = vpackage(x, 0, additional, max_dimen, math_direction);
+ reset_attributes(x, node_attr(q));
+ shift_amount(x) = shift_down;
+ }
+ }
+
+
+ if (new_hlist(q) == null) {
+ new_hlist(q) = x;
+ } else {
+ p = new_hlist(q);
+ while (vlink(p) != null)
+ p = vlink(p);
+ couple_nodes(p,x);
+ }
+ if (subscr(q) != null) {
+ math_list(subscr(q)) = null;
+ flush_node(subscr(q));
+ subscr(q) = null;
+ }
+ if (supscr(q) != null) {
+ math_list(supscr(q)) = null;
+ flush_node(supscr(q));
+ supscr(q) = null;
+ }
+
+}
+
+@ 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_hv)
+{
+ scaled delta, delta1, delta2; /* dimensions used in the calculation */
+ pointer tmp;
+ setup_cur_size(style);
+ delta2 = max_d + math_axis(cur_size);
+ delta1 = max_hv + max_d - delta2;
+ if (delta2 > delta1)
+ delta1 = delta2; /* |delta1| is max distance from axis */
+ delta = (delta1 / 500) * delimiter_factor;
+ delta2 = delta1 + delta1 - delimiter_shortfall;
+ if (delta < delta2)
+ delta = delta2;
+ tmp = var_delimiter(delimiter(q), cur_size, delta, NULL, style);
+ delimiter(q) = null;
+ assign_new_hlist(q, tmp);
+ if (subtype(q) == left_noad_side)
+ return open_noad_type;
+ else
+ return close_noad_type;
+}
+
+@ @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); \
+ } 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); \
+ } while (0)
+
+#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)); \
+ } 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);
+ SPLIT_STYLES (math_param_ord_rel_spacing, thick_mu_skip_code, 0);
+ ALL_STYLES (math_param_ord_open_spacing, 0);
+ ALL_STYLES (math_param_ord_close_spacing, 0);
+ ALL_STYLES (math_param_ord_punct_spacing, 0);
+ SPLIT_STYLES (math_param_ord_inner_spacing, thin_mu_skip_code, 0);
+
+ ALL_STYLES (math_param_op_ord_spacing, thin_mu_skip_code);
+ ALL_STYLES (math_param_op_op_spacing, thin_mu_skip_code);
+ ALL_STYLES (math_param_op_bin_spacing, 0);
+ SPLIT_STYLES (math_param_op_rel_spacing, thick_mu_skip_code, 0);
+ ALL_STYLES (math_param_op_open_spacing, 0);
+ ALL_STYLES (math_param_op_close_spacing, 0);
+ ALL_STYLES (math_param_op_punct_spacing, 0);
+ SPLIT_STYLES (math_param_op_inner_spacing, thin_mu_skip_code, 0);
+
+ SPLIT_STYLES (math_param_bin_ord_spacing, med_mu_skip_code, 0);
+ SPLIT_STYLES (math_param_bin_op_spacing, med_mu_skip_code, 0);
+ ALL_STYLES (math_param_bin_bin_spacing, 0);
+ ALL_STYLES (math_param_bin_rel_spacing, 0);
+ SPLIT_STYLES (math_param_bin_open_spacing, med_mu_skip_code, 0);
+ ALL_STYLES (math_param_bin_close_spacing, 0);
+ ALL_STYLES (math_param_bin_punct_spacing, 0);
+ SPLIT_STYLES (math_param_bin_inner_spacing, med_mu_skip_code, 0);
+
+ SPLIT_STYLES (math_param_rel_ord_spacing, thick_mu_skip_code, 0);
+ SPLIT_STYLES (math_param_rel_op_spacing, thick_mu_skip_code, 0);
+ ALL_STYLES (math_param_rel_bin_spacing, 0);
+ ALL_STYLES (math_param_rel_rel_spacing, 0);
+ SPLIT_STYLES (math_param_rel_open_spacing, thick_mu_skip_code, 0);
+ ALL_STYLES (math_param_rel_close_spacing, 0);
+ ALL_STYLES (math_param_rel_punct_spacing, 0);
+ SPLIT_STYLES (math_param_rel_inner_spacing, thick_mu_skip_code, 0);
+
+ ALL_STYLES (math_param_open_ord_spacing, 0);
+ ALL_STYLES (math_param_open_op_spacing, 0);
+ ALL_STYLES (math_param_open_bin_spacing, 0);
+ ALL_STYLES (math_param_open_rel_spacing, 0);
+ ALL_STYLES (math_param_open_open_spacing, 0);
+ ALL_STYLES (math_param_open_close_spacing, 0);
+ ALL_STYLES (math_param_open_punct_spacing, 0);
+ ALL_STYLES (math_param_open_inner_spacing, 0);
+
+ ALL_STYLES (math_param_close_ord_spacing, 0);
+ ALL_STYLES (math_param_close_op_spacing, thin_mu_skip_code);
+ SPLIT_STYLES (math_param_close_bin_spacing, med_mu_skip_code, 0);
+ SPLIT_STYLES (math_param_close_rel_spacing, thick_mu_skip_code, 0);
+ ALL_STYLES (math_param_close_open_spacing, 0);
+ ALL_STYLES (math_param_close_close_spacing, 0);
+ ALL_STYLES (math_param_close_punct_spacing, 0);
+ SPLIT_STYLES (math_param_close_inner_spacing, thin_mu_skip_code, 0);
+
+ SPLIT_STYLES (math_param_punct_ord_spacing, thin_mu_skip_code, 0);
+ SPLIT_STYLES (math_param_punct_op_spacing, thin_mu_skip_code, 0);
+ ALL_STYLES (math_param_punct_bin_spacing, 0);
+ SPLIT_STYLES (math_param_punct_rel_spacing, thin_mu_skip_code, 0);
+ SPLIT_STYLES (math_param_punct_open_spacing, thin_mu_skip_code, 0);
+ SPLIT_STYLES (math_param_punct_close_spacing, thin_mu_skip_code, 0);
+ SPLIT_STYLES (math_param_punct_punct_spacing, thin_mu_skip_code, 0);
+ SPLIT_STYLES (math_param_punct_inner_spacing, thin_mu_skip_code, 0);
+
+ SPLIT_STYLES (math_param_inner_ord_spacing, thin_mu_skip_code, 0);
+ ALL_STYLES (math_param_inner_op_spacing, thin_mu_skip_code);
+ SPLIT_STYLES (math_param_inner_bin_spacing, med_mu_skip_code, 0);
+ SPLIT_STYLES (math_param_inner_rel_spacing, thick_mu_skip_code, 0);
+ SPLIT_STYLES (math_param_inner_open_spacing, thin_mu_skip_code, 0);
+ 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)
+{
+ int x = -1;
+ pointer z = null;
+ if (l_type == op_noad_type_limits || l_type == op_noad_type_no_limits)
+ l_type = op_noad_type_normal;
+ 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* */
+ }
+ if (x < 0) {
+ confusion("mathspacing");
+ }
+ if (x != 0) {
+ pointer y;
+ if (x <= thick_mu_skip_code) { /* trap thin/med/thick settings cf. old TeX */
+ y = math_glue(glue_par(x), mmu);
+ z = new_glue(y);
+ glue_ref_count(y) = null;
+ subtype(z) = (quarterword) (x + 1); /* store a symbolic subtype */
+ } else {
+ y = math_glue(x, mmu);
+ z = new_glue(y);
+ glue_ref_count(y) = null;
+ }
+ }
+ return z;
+}
+
+@ @c
+static pointer check_nucleus_complexity(halfword q, scaled * delta,
+ int cur_style)
+{
+ pointer p = null;
+ switch (type(nucleus(q))) {
+ case math_char_node:
+ case math_text_char_node:
+ fetch(nucleus(q));
+ if (char_exists(cur_f, cur_c)) {
+ *delta = char_italic(cur_f, cur_c);
+ p = new_glyph(cur_f, cur_c);
+ reset_attributes(p, node_attr(nucleus(q)));
+ if ((is_new_mathfont(cur_f) && get_char_cat_code(cur_c) == 11) ||
+ (!is_new_mathfont(cur_f) && type(nucleus(q)) == math_text_char_node && space(cur_f)) != 0) {
+ *delta = 0; /* no italic correction in mid-word of text font */
+ }
+ if ((subscr(q) == null) && (supscr(q) == null) && (*delta != 0)) {
+ pointer x = new_kern(*delta);
+ reset_attributes(x, node_attr(nucleus(q)));
+ couple_nodes(p,x);
+ *delta = 0;
+ }
+ }
+ break;
+ case sub_box_node:
+ p = math_list(nucleus(q));
+ break;
+ case sub_mlist_node:
+ mlist_to_hlist_args(math_list(nucleus(q)), cur_style, false); /* recursive call */
+ 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 */
+ }
+ return p;
+}
+
+@ Here is the overall plan of |mlist_to_hlist|, and the list of its
+ local variables.
+
+@c
+static void mlist_to_hlist(pointer mlist, boolean penalties, int cur_style)
+{
+ pointer q; /* runs through the mlist */
+ pointer r; /* the most recent noad preceding |q| */
+ int style;
+ int r_type; /* the |type| of noad |r|, or |op_noad| if |r=null| */
+ int r_subtype; /* 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 */
+ pointer p, x, y, z; /* temporary registers for list construction */
+ int pen; /* a penalty to be inserted */
+ scaled max_hl, max_d; /* maximum height and 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| */
+ style = cur_style; /* tuck global parameter away as local variable */
+ q = mlist;
+ r = null;
+ r_type = simple_noad;
+ r_subtype = op_noad_type_normal;
+ max_hl = 0;
+ max_d = 0;
+ x = null;
+ p = null;
+ setup_cur_size(cur_style);
+ cur_mu = x_over_n(get_math_quad(cur_size), 18);
+ while (q != null) {
+ /* 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. */
+ RESWITCH:
+ delta = 0;
+ 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;
+ }
+ break;
+ case fence_noad:
+ if (r_subtype == left_noad_side) {
+ subtype(q) = ord_noad_type;
+ goto RESWITCH;
+ }
+ break;
+ }
+ break;
+ case over_noad_type:
+ make_over(q, cur_style);
+ break;
+ case under_noad_type:
+ make_under(q, cur_style);
+ 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;
+ 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)
+ 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;
+ subtype(r) = ord_noad_type;
+ }
+ goto DONE_WITH_NOAD;
+ break;
+ case fraction_noad:
+ make_fraction(q, cur_style);
+ goto CHECK_DIMENSIONS;
+ break;
+ case radical_noad:
+ if (subtype(q) == 4)
+ make_under_delimiter(q, cur_style);
+ else if (subtype(q) == 5)
+ make_over_delimiter(q, cur_style);
+ else if (subtype(q) == 6)
+ make_delimiter_under(q, cur_style);
+ else if (subtype(q) == 7)
+ make_delimiter_over(q, cur_style);
+ else
+ make_radical(q, cur_style);
+ break;
+ case accent_noad:
+ make_math_accent(q, cur_style);
+ break;
+ case style_node:
+ cur_style = subtype(q);
+ setup_cur_size(cur_style);
+ cur_mu = x_over_n(get_math_quad(cur_size), 18);
+ goto DONE_WITH_NODE;
+ break;
+ case choice_node:
+ switch (cur_style / 2) {
+ case 0:
+ choose_mlist(display_mlist);
+ break; /* |display_style=0| */
+ case 1:
+ choose_mlist(text_mlist);
+ break; /* |text_style=2| */
+ case 2:
+ choose_mlist(script_mlist);
+ break; /* |script_style=4| */
+ case 3:
+ choose_mlist(script_script_mlist);
+ break; /* |script_script_style=6| */
+ } /* there are no other cases */
+ flush_node_list(display_mlist(q));
+ flush_node_list(text_mlist(q));
+ flush_node_list(script_mlist(q));
+ flush_node_list(script_script_mlist(q));
+ type(q) = style_node;
+ subtype(q) = (quarterword) cur_style;
+ if (p != null) {
+ z = vlink(q);
+ couple_nodes(q,p);
+ while (vlink(p) != null)
+ p = vlink(p);
+ couple_nodes(p,z);
+ }
+ goto DONE_WITH_NODE;
+ break;
+ case ins_node:
+ case mark_node:
+ case adjust_node:
+ case whatsit_node:
+ case penalty_node:
+ case disc_node:
+ goto DONE_WITH_NODE;
+ break;
+ case rule_node:
+ if (height(q) > max_hl)
+ max_hl = height(q);
+ if (depth(q) > max_d)
+ max_d = depth(q);
+ 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|. Unconditional math glue
+ (`\.{\\muskip}') is converted to normal glue by multiplying the dimensions
+ by |cur_mu|.
+ */
+ if (subtype(q) == mu_glue) {
+ x = glue_ptr(q);
+ y = math_glue(x, cur_mu);
+ delete_glue_ref(x);
+ glue_ptr(q) = y;
+ subtype(q) = normal;
+ } else if ((cur_size != text_size)
+ && (subtype(q) == cond_math_glue)) {
+ p = vlink(q);
+ if (p != null)
+ if ((type(p) == glue_node) || (type(p) == kern_node)) {
+ couple_nodes(q,vlink(p));
+ vlink(p) = null;
+ flush_node_list(p);
+ }
+ }
+ goto DONE_WITH_NODE;
+ break;
+ case kern_node:
+ math_kern(q, cur_mu);
+ goto DONE_WITH_NODE;
+ break;
+ default:
+ confusion("mlist1"); /* this can't happen 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.
+
+ 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.
+ */
+ p = check_nucleus_complexity(q, &delta, cur_style);
+
+ if ((subscr(q) == null) && (supscr(q) == null)) {
+ assign_new_hlist(q, p);
+ } else {
+ make_scripts(q, p, delta, cur_style); /* top, bottom */
+ }
+ CHECK_DIMENSIONS:
+ z = hpack(new_hlist(q), 0, additional, -1);
+ if (height(z) > max_hl)
+ max_hl = height(z);
+ if (depth(z) > max_d)
+ max_d = depth(z);
+ list_ptr(z) = null;
+ flush_node(z); /* only drop the \.{\\hbox} */
+ DONE_WITH_NOAD:
+ r = q;
+ r_type = type(r);
+ r_subtype = subtype(r);
+ if (r_type == fence_noad) {
+ r_subtype = left_noad_side;
+ cur_style = style;
+ setup_cur_size(cur_style);
+ cur_mu = x_over_n(get_math_quad(cur_size), 18);
+ }
+ DONE_WITH_NODE:
+ q = vlink(q);
+ }
+ if (r_type == simple_noad && r_subtype == bin_noad_type) {
+ type(r) = simple_noad;
+ subtype(r) = ord_noad_type;
+ }
+ /* 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.
+ */
+ p = temp_head;
+ vlink(p) = null;
+ q = mlist;
+ r_type = 0;
+ r_subtype = 0;
+ cur_style = style;
+ setup_cur_size(cur_style);
+ cur_mu = x_over_n(get_math_quad(cur_size), 18);
+ NEXT_NODE:
+ while (q != null) {
+ /* 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 */
+ /* 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;
+ pen = inf_penalty;
+ switch (type(q)) {
+ case simple_noad:
+ t_subtype = subtype(q);
+ switch (t_subtype) {
+ case bin_noad_type:
+ pen = bin_op_penalty;
+ break;
+ case rel_noad_type:
+ pen = rel_penalty;
+ break;
+ case vcenter_noad_type:
+ case over_noad_type:
+ case under_noad_type:
+ t_subtype = ord_noad_type;
+ break;
+ }
+ case radical_noad:
+ break;
+ case accent_noad:
+ break;
+ case fraction_noad:
+ t = simple_noad;
+ t_subtype = inner_noad_type;
+ break;
+ case fence_noad:
+ t_subtype = make_left_right(q, style, max_d, max_hl);
+ break;
+ case style_node:
+ /* 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(cur_size), 18);
+ goto DELETE_Q;
+ break;
+ case whatsit_node:
+ case penalty_node:
+ case rule_node:
+ case disc_node:
+ case adjust_node:
+ case ins_node:
+ case mark_node:
+ case glue_node:
+ case kern_node:
+ couple_nodes(p,q);
+ p = q;
+ q = vlink(q);
+ vlink(p) = null;
+ goto NEXT_NODE;
+ break;
+ default:
+ confusion("mlist3"); /* this can't happen mlist3 */
+ }
+ /* Append inter-element spacing based on |r_type| and |t| */
+ if (r_type > 0) { /* not the first noad */
+ 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;
+ }
+ }
+
+ /* 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. */
+
+ if (new_hlist(q) != null) {
+ couple_nodes(p,new_hlist(q));
+ do {
+ p = vlink(p);
+ } while (vlink(p) != null);
+ }
+ if (penalties && vlink(q) != null && pen < inf_penalty) {
+ r_type = type(vlink(q));
+ r_subtype = subtype(vlink(q));
+ if (r_type != penalty_node
+ && (r_type != simple_noad || r_subtype != rel_noad_type)) {
+ z = new_penalty(pen);
+ reset_attributes(z, node_attr(q));
+ couple_nodes(p,z);
+ p = z;
+ }
+ }
+ if (type(q) == fence_noad && subtype(q) == right_noad_side) {
+ t = simple_noad;
+ t_subtype = open_noad_type;
+ }
+ r_type = t;
+ r_subtype = t_subtype;
+ 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).
+ 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));
+ free_node(r, get_node_size(type(r), subtype(r)));
+ }
+}
+
+@ This used to be needed when |mlist_to_hlist| communicated via global
+variables.
+
+@c
+void mlist_to_hlist_args(pointer n, int w, boolean m)
+{
+ mlist_to_hlist(n, m, w);
+}
diff --git a/Build/source/texk/web2c/luatexdir/tex/texnodes.w b/Build/source/texk/web2c/luatexdir/tex/texnodes.w index 4ea9cb49c3f..5f4f2739e4a 100644 --- a/Build/source/texk/web2c/luatexdir/tex/texnodes.w +++ b/Build/source/texk/web2c/luatexdir/tex/texnodes.w @@ -1,3400 +1,3409 @@ -% 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 -static const char _svn_version[] = - "$Id: texnodes.w 4442 2012-05-25 22:40:34Z hhenkel $" - "$URL: https://foundry.supelec.fr/svn/luatex/branches/ex-glyph/source/texk/web2c/luatexdir/tex/texnodes.w $"; - -#include "ptexlib.h" -#include "lua/luatex-api.h" - -@ @c -#undef name - -#define noDEBUG -#define DEBUG_OUT stdout - -#define adjust_pre subtype -#define attribute(A) eqtb[attribute_base+(A)].cint - -#define uc_hyph int_par(uc_hyph_code) -#define cur_lang int_par(cur_lang_code) -#define left_hyphen_min int_par(left_hyphen_min_code) -#define right_hyphen_min int_par(right_hyphen_min_code) - -#define text_direction int_par(text_direction_code) - -#define MAX_CHAIN_SIZE 13 - -memory_word *volatile varmem = NULL; - -#ifndef NDEBUG -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; - -int free_error_seen = 0; -int copy_error_seen = 0; - -halfword slow_get_node(int s); /* defined below */ -int copy_error(halfword p); /* define below */ - -#define fake_node 100 -#define fake_node_size 2 -#define fake_node_name "fake" - -#define variable_node_size 2 - -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", 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", NULL }; -const char *node_fields_math[] = { "attr", "surround", NULL }; -const char *node_fields_glue[] = { "attr", "spec", "leader", 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_style[] = { "attr", "style", NULL }; -const char *node_fields_choice[] = - { "attr", "display", "text", "script", "scriptscript", NULL }; -const char *node_fields_ord[] = { "attr", "nucleus", "sub", "sup", NULL }; -const char *node_fields_op[] = { "attr", "nucleus", "sub", "sup", NULL }; -const char *node_fields_bin[] = { "attr", "nucleus", "sub", "sup", NULL }; -const char *node_fields_rel[] = { "attr", "nucleus", "sub", "sup", NULL }; -const char *node_fields_open[] = { "attr", "nucleus", "sub", "sup", NULL }; -const char *node_fields_close[] = { "attr", "nucleus", "sub", "sup", NULL }; -const char *node_fields_punct[] = { "attr", "nucleus", "sub", "sup", NULL }; -const char *node_fields_inner[] = { "attr", "nucleus", "sub", "sup", NULL }; -const char *node_fields_under[] = { "attr", "nucleus", "sub", "sup", NULL }; -const char *node_fields_over[] = { "attr", "nucleus", "sub", "sup", NULL }; -const char *node_fields_vcenter[] = { "attr", "nucleus", "sub", "sup", NULL }; -const char *node_fields_radical[] = - { "attr", "nucleus", "sub", "sup", "left", "degree", NULL }; -const char *node_fields_fraction[] = - { "attr", "width", "num", "denom", "left", "right", NULL }; -const char *node_fields_accent[] = - { "attr", "nucleus", "sub", "sup", "accent", "bot_accent", NULL }; -const char *node_fields_fence[] = { "attr", "delim", 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 }; - -const char *node_fields_inserting[] = - { "height", "last_ins_ptr", "best_ins_ptr", NULL }; - -const char *node_fields_splitup[] = { "height", "last_ins_ptr", "best_ins_ptr", - "broken_ptr", "broken_ins", NULL -}; - -const char *node_fields_action[] = { "action_type", "named_id", "action_id", - "file", "new_window", "data", "ref_count", NULL -}; -const char *node_fields_attribute[] = { "number", "value", NULL }; - -const char *node_fields_glue_spec[] = { "width", "stretch", "shrink", - "stretch_order", "shrink_order", "ref_count", "writable", NULL -}; -const char *node_fields_attribute_list[] = { NULL }; - -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_local_par[] = - { "attr", "pen_inter", "pen_broken", "dir", - "box_left", "box_left_width", "box_right", "box_right_width", NULL -}; -const char *node_fields_whatsit_dir[] = - { "attr", "dir", "level", "dvi_ptr", "dvi_h", NULL }; - -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_refxform[] = - { "attr", "width", "depth", "height", "objnum", NULL }; -const char *node_fields_whatsit_pdf_refximage[] = - { "attr", "width", "depth", "height", "transform", "index", 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_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_save_pos[] = { "attr", NULL }; -const char *node_fields_whatsit_late_lua[] = - { "attr", "reg", "data", "name", "string", NULL }; -const char *node_fields_whatsit_close_lua[] = { "attr", "reg", 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 }; -const char *node_fields_whatsit_cancel_boundary[] = { "attr", NULL }; -const char *node_fields_whatsit_user_defined[] = - { "attr", "user_id", "type", "value", NULL }; - -node_info node_data[] = { - {hlist_node, box_node_size, node_fields_list, "hlist"}, - {vlist_node, box_node_size, node_fields_list, "vlist"}, - {rule_node, rule_node_size, node_fields_rule, "rule"}, - {ins_node, ins_node_size, node_fields_insert, "ins"}, - {mark_node, mark_node_size, node_fields_mark, "mark"}, - {adjust_node, adjust_node_size, node_fields_adjust, "adjust"}, - {fake_node, fake_node_size, NULL, fake_node_name}, /* don't touch this! */ - {disc_node, disc_node_size, node_fields_disc, "disc"}, - {whatsit_node, -1, NULL, "whatsit"}, - {math_node, math_node_size, node_fields_math, "math"}, - {glue_node, glue_node_size, node_fields_glue, "glue"}, - {kern_node, kern_node_size, node_fields_kern, "kern"}, - {penalty_node, penalty_node_size, node_fields_penalty, "penalty"}, - {unset_node, box_node_size, node_fields_unset, "unset"}, - {style_node, style_node_size, node_fields_style, "style"}, - {choice_node, style_node_size, node_fields_choice, "choice"}, - {simple_noad, noad_size, node_fields_ord, "noad"}, - {old_op_noad, noad_size, node_fields_op, "op"}, - {old_bin_noad, noad_size, node_fields_bin, "bin"}, - {old_rel_noad, noad_size, node_fields_rel, "rel"}, - {old_open_noad, noad_size, node_fields_open, "open"}, - {old_close_noad, noad_size, node_fields_close, "close"}, - {old_punct_noad, noad_size, node_fields_punct, "punct"}, - {old_inner_noad, noad_size, node_fields_inner, "inner"}, - {radical_noad, radical_noad_size, node_fields_radical, "radical"}, - {fraction_noad, fraction_noad_size, node_fields_fraction, "fraction"}, - {old_under_noad, noad_size, node_fields_under, "under"}, - {old_over_noad, noad_size, node_fields_over, "over"}, - {accent_noad, accent_noad_size, node_fields_accent, "accent"}, - {old_vcenter_noad, noad_size, node_fields_vcenter, "vcenter"}, - {fence_noad, fence_noad_size, node_fields_fence, "fence"}, - {math_char_node, math_kernel_node_size, node_fields_math_char, "math_char"}, - {sub_box_node, math_kernel_node_size, node_fields_sub_box, "sub_box"}, - {sub_mlist_node, math_kernel_node_size, node_fields_sub_mlist, "sub_mlist"}, - {math_text_char_node, math_kernel_node_size, node_fields_math_text_char, "math_text_char"}, - {delim_node, math_shield_node_size, node_fields_delim, "delim"}, - {margin_kern_node, margin_kern_node_size, node_fields_margin_kern, "margin_kern"}, - {glyph_node, glyph_node_size, node_fields_glyph, "glyph"}, - {align_record_node, box_node_size, NULL, "align_record"}, - {pseudo_file_node, pseudo_file_node_size, NULL, "pseudo_file"}, - {pseudo_line_node, variable_node_size, NULL, "pseudo_line"}, - {inserting_node, page_ins_node_size, node_fields_inserting, "page_insert"}, - {split_up_node, page_ins_node_size, node_fields_splitup, "split_insert"}, - {expr_node, expr_node_size, NULL, "expr_stack"}, - {nesting_node, nesting_node_size, NULL, "nested_list"}, - {span_node, span_node_size, NULL, "span"}, - {attribute_node, attribute_node_size, node_fields_attribute, "attribute"}, - {glue_spec_node, glue_spec_size, node_fields_glue_spec, "glue_spec"}, - {attribute_list_node, attribute_node_size, node_fields_attribute_list, "attribute_list"}, - {action_node, pdf_action_size, node_fields_action, "action"}, - {temp_node, temp_node_size, NULL, "temp"}, - {align_stack_node, align_stack_node_size, NULL, "align_stack"}, - {movement_node, movement_node_size, NULL, "movement_stack"}, - {if_node, if_node_size, NULL, "if_stack"}, - {unhyphenated_node, active_node_size, NULL, "unhyphenated"}, - {hyphenated_node, active_node_size, NULL, "hyphenated"}, - {delta_node, delta_node_size, NULL, "delta"}, - {passive_node, passive_node_size, NULL, "passive"}, - {shape_node, variable_node_size, NULL, "shape"}, - {-1, -1, NULL, NULL} -}; - -#define last_normal_node shape_node - -node_info whatsit_node_data[] = { - {open_node, open_node_size, node_fields_whatsit_open, "open"}, - {write_node, write_node_size, node_fields_whatsit_write, "write"}, - {close_node, close_node_size, node_fields_whatsit_close, "close"}, - {special_node, special_node_size, node_fields_whatsit_special, "special"}, - {fake_node, fake_node_size, NULL, fake_node_name}, - {fake_node, fake_node_size, NULL, fake_node_name}, - {local_par_node, local_par_size, node_fields_whatsit_local_par, - "local_par"}, - {dir_node, dir_node_size, node_fields_whatsit_dir, "dir"}, - {pdf_literal_node, write_node_size, node_fields_whatsit_pdf_literal, - "pdf_literal"}, - {fake_node, fake_node_size, NULL, fake_node_name}, - {pdf_refobj_node, pdf_refobj_node_size, node_fields_whatsit_pdf_refobj, - "pdf_refobj"}, - {fake_node, fake_node_size, NULL, fake_node_name}, - {pdf_refxform_node, pdf_refxform_node_size, - node_fields_whatsit_pdf_refxform, "pdf_refxform"}, - {fake_node, fake_node_size, NULL, fake_node_name}, - {pdf_refximage_node, pdf_refximage_node_size, - node_fields_whatsit_pdf_refximage, "pdf_refximage"}, - {pdf_annot_node, pdf_annot_node_size, node_fields_whatsit_pdf_annot, - "pdf_annot"}, - {pdf_start_link_node, pdf_annot_node_size, - node_fields_whatsit_pdf_start_link, "pdf_start_link"}, - {pdf_end_link_node, pdf_end_link_node_size, - node_fields_whatsit_pdf_end_link, "pdf_end_link"}, - {fake_node, fake_node_size, NULL, fake_node_name}, - {pdf_dest_node, pdf_dest_node_size, node_fields_whatsit_pdf_dest, - "pdf_dest"}, - {pdf_thread_node, pdf_thread_node_size, node_fields_whatsit_pdf_thread, - "pdf_thread"}, - {pdf_start_thread_node, pdf_thread_node_size, - node_fields_whatsit_pdf_start_thread, "pdf_start_thread"}, - {pdf_end_thread_node, pdf_end_thread_node_size, - node_fields_whatsit_pdf_end_thread, "pdf_end_thread"}, - {pdf_save_pos_node, pdf_save_pos_node_size, - node_fields_whatsit_pdf_save_pos, "pdf_save_pos"}, - {pdf_thread_data_node, pdf_thread_node_size, NULL, "pdf_thread_data"}, - {pdf_link_data_node, pdf_annot_node_size, NULL, "pdf_link_data"}, - {fake_node, fake_node_size, NULL, fake_node_name}, - {fake_node, fake_node_size, NULL, fake_node_name}, - {fake_node, fake_node_size, NULL, fake_node_name}, - {fake_node, fake_node_size, NULL, fake_node_name}, - {fake_node, fake_node_size, NULL, fake_node_name}, - {fake_node, fake_node_size, NULL, fake_node_name}, - {fake_node, fake_node_size, NULL, fake_node_name}, - {fake_node, fake_node_size, NULL, fake_node_name}, - {fake_node, fake_node_size, NULL, fake_node_name}, - {late_lua_node, late_lua_node_size, node_fields_whatsit_late_lua, - "late_lua"}, - {close_lua_node, write_node_size, node_fields_whatsit_close_lua, - "close_lua"}, - {fake_node, fake_node_size, NULL, fake_node_name}, - {fake_node, fake_node_size, NULL, fake_node_name}, - {pdf_colorstack_node, pdf_colorstack_node_size, - node_fields_whatsit_pdf_colorstack, "pdf_colorstack"}, - {pdf_setmatrix_node, pdf_setmatrix_node_size, - node_fields_whatsit_pdf_setmatrix, "pdf_setmatrix"}, - {pdf_save_node, pdf_save_node_size, node_fields_whatsit_pdf_save, - "pdf_save"}, - {pdf_restore_node, pdf_restore_node_size, node_fields_whatsit_pdf_restore, - "pdf_restore"}, - {cancel_boundary_node, cancel_boundary_size, - node_fields_whatsit_cancel_boundary, "cancel_boundary"}, - {user_defined_node, user_defined_node_size, - node_fields_whatsit_user_defined, "user_defined"}, - {-1, -1, NULL, NULL} -}; - -#define last_whatsit_node user_defined_node - -@ @c -halfword new_node(int i, int j) -{ - int s; - halfword n; - s = get_node_size(i, j); - n = get_node(s); - /* it should be possible to do this memset at |free_node()| */ - /* 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 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 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; - rule_dir(n) = -1; - /* fall through */ - 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; - } - /* handle synctex extension */ - switch (i) { - case math_node: - synctex_tag_math(n) = cur_input.synctex_tag_field; - synctex_line_math(n) = line; - break; - case glue_node: - synctex_tag_glue(n) = cur_input.synctex_tag_field; - synctex_line_glue(n) = line; - break; - case kern_node: - /* synctex ignores implicit kerns */ - 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; - } - /* take care of attributes */ - if (nodetype_has_attributes(i)) { - build_attribute_list(n); - } - type(n) = (quarterword) i; - subtype(n) = (quarterword) j; -#ifdef DEBUG - fprintf(DEBUG_OUT, "Alloc-ing %s node %d\n", - get_node_name(type(n), subtype(n)), (int) n); -#endif - return n; -} - -halfword raw_glyph_node(void) -{ - register halfword n; - n = get_node(glyph_node_size); - (void) memset((void *) (varmem + n + 1), 0, - (sizeof(memory_word) * (glyph_node_size - 1))); - type(n) = glyph_node; - subtype(n) = 0; - return n; -} - -halfword new_glyph_node(void) -{ - register halfword n; - n = get_node(glyph_node_size); - (void) memset((void *) (varmem + n + 1), 0, - (sizeof(memory_word) * (glyph_node_size - 1))); - type(n) = glyph_node; - subtype(n) = 0; - build_attribute_list(n); - 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 */ - copy_error_seen = 0; - while (p != end) { - register halfword s = copy_node(p); - if (h == null) { - h = s; - } else { - couple_nodes(q, s); - } - q = s; - p = vlink(p); - } - return h; -} - -halfword copy_node_list(halfword p) -{ - return do_copy_node_list(p, null); -} - -@ make a dupe of a single node -@c -halfword copy_node(const halfword p) -{ - halfword r; /* current node being fabricated for new list */ - 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; - } - i = get_node_size(type(p), subtype(p)); - r = get_node(i); - - (void) memcpy((void *) (varmem + r), (void *) (varmem + p), - (sizeof(memory_word) * (unsigned) i)); - - /* handle synctex extension */ - switch (type(p)) { - 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(type(p))) { - add_node_attr_ref(node_attr(p)); - alink(r) = null; /* needs checking */ - } - vlink(r) = null; - - - switch (type(p)) { - case glyph_node: - s = copy_node_list(lig_ptr(p)); - lig_ptr(r) = s; - break; - case glue_node: - add_glue_ref(glue_ptr(p)); - s = copy_node_list(leader_ptr(p)); - leader_ptr(r) = s; - break; - case hlist_node: - case vlist_node: - case unset_node: - s = copy_node_list(list_ptr(p)); - list_ptr(r) = s; - break; - case ins_node: - add_glue_ref(split_top_ptr(p)); - s = copy_node_list(ins_ptr(p)); - ins_ptr(r) = s; - break; - case margin_kern_node: - s = copy_node(margin_char(p)); - margin_char(r) = s; - 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 mark_node: - add_token_ref(mark_ptr(p)); - break; - case adjust_node: - s = copy_node_list(adjust_ptr(p)); - adjust_ptr(r) = s; - break; - - case choice_node: - s = copy_node_list(display_mlist(p)); - display_mlist(r) = s; - s = copy_node_list(text_mlist(p)); - text_mlist(r) = s; - s = copy_node_list(script_mlist(p)); - script_mlist(r) = s; - s = copy_node_list(script_script_mlist(p)); - script_script_mlist(r) = s; - break; - case simple_noad: - case radical_noad: - case accent_noad: - s = copy_node_list(nucleus(p)); - nucleus(r) = s; - s = copy_node_list(subscr(p)); - subscr(r) = s; - s = copy_node_list(supscr(p)); - supscr(r) = s; - if (type(p) == accent_noad) { - s = copy_node_list(accent_chr(p)); - accent_chr(r) = s; - s = copy_node_list(bot_accent_chr(p)); - bot_accent_chr(r) = s; - } else if (type(p) == radical_noad) { - s = copy_node(left_delimiter(p)); - left_delimiter(r) = s; - s = copy_node_list(degree(p)); - degree(r) = s; - } - break; - case fence_noad: - s = copy_node(delimiter(p)); - delimiter(r) = s; - break; - case sub_box_node: - case sub_mlist_node: - s = copy_node_list(math_list(p)); - math_list(r) = s; - break; - case fraction_noad: - s = copy_node_list(numerator(p)); - numerator(r) = s; - s = copy_node_list(denominator(p)); - denominator(r) = s; - s = copy_node(left_delimiter(p)); - left_delimiter(r) = s; - s = copy_node(right_delimiter(p)); - right_delimiter(r) = s; - break; - case glue_spec_node: - glue_ref_count(r) = null; - break; - case whatsit_node: - switch (subtype(p)) { - case dir_node: - case local_par_node: - break; - case write_node: - case special_node: - add_token_ref(write_tokens(p)); - break; - 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 late_lua_node: - copy_late_lua(r, 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; - case user_defined_node: - switch (user_node_type(p)) { - case 'a': - add_node_attr_ref(user_node_value(p)); - break; - case 't': - add_token_ref(user_node_value(p)); - break; - case 's': - /* |add_string_ref(user_node_value(p));| *//* if this was mpost .. */ - break; - case 'n': - s = copy_node_list(user_node_value(p)); - user_node_value(r) = s; - break; - } - break; -#if 0 - case style_node: - case delim_node: - case math_char_node: - case math_text_char_node: - break; -#else - default: -#endif - break; - } - break; - } -#ifdef DEBUG - fprintf(DEBUG_OUT, "Alloc-ing %s node %d (copy of %d)\n", - get_node_name(type(r), subtype(r)), (int) r, (int) p); -#endif - return r; -} - -@ @c -int valid_node(halfword p) -{ - if (p > my_prealloc) { - if (p < var_mem_max) { -#ifndef NDEBUG - if (varmem_sizes[p] > 0) -#endif - return 1; - } - } else { - return 0; - } - return 0; -} - -@ @c -static void do_free_error(halfword p) -{ - halfword r; - char errstr[255] = { 0 }; - const char *errhlp[] = { - "When I tried to free the node mentioned in the error message, it turned", - "out it was not (or no longer) actually in use.", - "Errors such as these are often caused by Lua node list alteration,", - "but could also point to a bug in the executable. It should be safe to continue.", - NULL - }; - - check_node_mem(); - if (free_error_seen) - return; - - r = null; - free_error_seen = 1; - if (type(p) == glyph_node) { - snprintf(errstr, 255, - "Attempt to double-free glyph (%c) node %d, ignored", - (int) character(p), (int) p); - } else { - snprintf(errstr, 255, "Attempt to double-free %s node %d, ignored", - get_node_name(type(p), subtype(p)), (int) p); - } - tex_error(errstr, errhlp); -#ifndef NDEBUG - 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) -{ - assert(p > my_prealloc); - assert(p < var_mem_max); -#ifndef NDEBUG - if (varmem_sizes[p] == 0) { - do_free_error(p); - return 1; /* double free */ - } -#endif - return 0; -} - - -@ @c -static void do_copy_error(halfword p) -{ - char errstr[255] = { 0 }; - const char *errhlp[] = { - "When I tried to copy the node mentioned in the error message, it turned", - "out it was not (or no longer) actually in use.", - "Errors such as these are often caused by Lua node list alteration,", - "but could also point to a bug in the executable. It should be safe to continue.", - NULL - }; - - if (copy_error_seen) - return; - - copy_error_seen = 1; - if (type(p) == glyph_node) { - snprintf(errstr, 255, - "Attempt to copy free glyph (%c) node %d, ignored", - (int) character(p), (int) p); - } else { - snprintf(errstr, 255, "Attempt to copy free %s node %d, ignored", - get_node_name(type(p), subtype(p)), (int) p); - } - tex_error(errstr, errhlp); -} - - -int copy_error(halfword p) -{ - assert(p >= 0); - assert(p < var_mem_max); -#ifndef NDEBUG - if (p > my_prealloc && varmem_sizes[p] == 0) { - do_copy_error(p); - return 1; /* copy free node */ - } -#endif - return 0; -} - - -@ @c -void flush_node(halfword p) -{ - - if (p == null) /* legal, but no-op */ - return; - -#ifdef DEBUG - fprintf(DEBUG_OUT, "Free-ing %s node %d\n", - get_node_name(type(p), subtype(p)), (int) p); -#endif - if (free_error(p)) - return; - - switch (type(p)) { - case glyph_node: - flush_node_list(lig_ptr(p)); - break; - case glue_node: - delete_glue_ref(glue_ptr(p)); - flush_node_list(leader_ptr(p)); - break; - - case attribute_node: - case attribute_list_node: - case temp_node: - case glue_spec_node: - case rule_node: - case kern_node: - case math_node: - case penalty_node: - break; - - case hlist_node: - case vlist_node: - case unset_node: - flush_node_list(list_ptr(p)); - break; - case whatsit_node: - switch (subtype(p)) { - - case dir_node: - break; - case open_node: - case write_node: - case close_node: - case pdf_save_node: - case pdf_restore_node: - case cancel_boundary_node: - case close_lua_node: - case pdf_refobj_node: - case pdf_refxform_node: - case pdf_refximage_node: - case pdf_end_link_node: - case pdf_end_thread_node: - case pdf_save_pos_node: - case local_par_node: - break; - - case special_node: - delete_token_ref(write_tokens(p)); - 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 late_lua_node: - free_late_lua(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_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; - case user_defined_node: - switch (user_node_type(p)) { - case 'a': - delete_attribute_ref(user_node_value(p)); - break; - case 't': - delete_token_ref(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 'd': - 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; - - default: - confusion("ext3"); - return; - - } - break; - case ins_node: - flush_node_list(ins_ptr(p)); - delete_glue_ref(split_top_ptr(p)); - break; - case margin_kern_node: - flush_node(margin_char(p)); - break; - case mark_node: - delete_token_ref(mark_ptr(p)); - break; - case disc_node: - flush_node_list(vlink(pre_break(p))); - flush_node_list(vlink(post_break(p))); - flush_node_list(vlink(no_break(p))); - break; - case adjust_node: - flush_node_list(adjust_ptr(p)); - break; - case style_node: /* nothing to do */ - break; - case choice_node: - flush_node_list(display_mlist(p)); - flush_node_list(text_mlist(p)); - flush_node_list(script_mlist(p)); - flush_node_list(script_script_mlist(p)); - break; - case simple_noad: - case radical_noad: - case accent_noad: - flush_node_list(nucleus(p)); - flush_node_list(subscr(p)); - flush_node_list(supscr(p)); - if (type(p) == accent_noad) { - flush_node_list(accent_chr(p)); - flush_node_list(bot_accent_chr(p)); - } else if (type(p) == radical_noad) { - flush_node(left_delimiter(p)); - flush_node_list(degree(p)); - } - break; - case fence_noad: - flush_node(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: - flush_node_list(math_list(p)); - break; - case fraction_noad: - flush_node_list(numerator(p)); - flush_node_list(denominator(p)); - flush_node(left_delimiter(p)); - flush_node(right_delimiter(p)); - break; - case pseudo_file_node: - flush_node_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 action_node: - case inserting_node: - case split_up_node: - case expr_node: - break; - default: - fprintf(stdout, "flush_node: type is %d\n", type(p)); - return; - - } - if (nodetype_has_attributes(type(p))) - delete_attribute_ref(node_attr(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; - free_error_seen = 0; - if (p == null) /* legal, but no-op */ - return; - if (free_error(p)) - return; - - while (p != null) { - register halfword q = vlink(p); - flush_node(p); - p = q; - } -} - -@ @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("dorangetest"); \ - } } 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("dotest"); \ - } } while (0) - -#define check_action_ref(a) { dorangetest(p,a,var_mem_max); } -#define check_glue_ref(a) { dorangetest(p,a,var_mem_max); } -#define check_attribute_ref(a) { dorangetest(p,a,var_mem_max); } -#define check_token_ref(a) assert(1) - -void check_node(halfword p) -{ - - switch (type(p)) { - case glyph_node: - dorangetest(p, lig_ptr(p), var_mem_max); - break; - case glue_node: - check_glue_ref(glue_ptr(p)); - 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); - check_glue_ref(split_top_ptr(p)); - break; - case whatsit_node: - switch (subtype(p)) { - case special_node: - check_token_ref(write_tokens(p)); - break; - case pdf_literal_node: - if (pdf_literal_type(p) == normal) - check_token_ref(pdf_literal_data(p)); - break; - case pdf_colorstack_node: - if (pdf_colorstack_cmd(p) <= colorstack_data) - check_token_ref(pdf_colorstack_data(p)); - break; - case pdf_setmatrix_node: - check_token_ref(pdf_setmatrix_data(p)); - break; - case late_lua_node: - if (late_lua_name(p) > 0) - check_token_ref(late_lua_name(p)); - if (late_lua_type(p) == normal) - check_token_ref(late_lua_data(p)); - break; - case pdf_annot_node: - check_token_ref(pdf_annot_data(p)); - break; - case pdf_start_link_node: - if (pdf_link_attr(p) != null) - check_token_ref(pdf_link_attr(p)); - check_action_ref(pdf_link_action(p)); - break; - case pdf_dest_node: - if (pdf_dest_named_id(p) > 0) - check_token_ref(pdf_dest_id(p)); - break; - case pdf_thread_node: - case pdf_start_thread_node: - if (pdf_thread_named_id(p) > 0) - check_token_ref(pdf_thread_id(p)); - if (pdf_thread_attr(p) != null) - check_token_ref(pdf_thread_attr(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(user_node_value(p)); - break; - case 'n': - dorangetest(p, user_node_value(p), var_mem_max); - break; - case 's': - case 'd': - break; - default: - confusion("extuser"); - break; - } - break; - case dir_node: - case open_node: - case write_node: - case close_node: - case pdf_save_node: - case pdf_restore_node: - case cancel_boundary_node: - case close_lua_node: - case pdf_refobj_node: - case pdf_refxform_node: - case pdf_refximage_node: - case pdf_end_link_node: - case pdf_end_thread_node: - case pdf_save_pos_node: - case local_par_node: - break; - default: - confusion("ext3"); - } - break; - case margin_kern_node: - check_node(margin_char(p)); - 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, accent_chr(p), var_mem_max); - dorangetest(p, bot_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 math_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: - break; - default: - fprintf(stdout, "check_node: type is %d\n", type(p)); - } -} - -@ @c -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); -} - -@ @c -void check_node_mem(void) -{ - int i; - check_static_node_mem(); -#ifndef NDEBUG - for (i = (my_prealloc + 1); i < var_mem_max; i++) { - if (varmem_sizes[i] > 0) { - check_node(i); - } - } -#endif - test_count++; -} - -@ @c -void fix_node_list(halfword head) -{ - halfword p, q; - if (head == null) - return; - p = head; - q = vlink(p); - while (q != null) { - alink(q) = p; - p = q; - q = vlink(p); - } -} - -@ @c -halfword get_node(int s) -{ - register halfword r; -#if 0 - check_static_node_mem(); -#endif - assert(s < MAX_CHAIN_SIZE); - - r = free_chain[s]; - if (r != null) { - free_chain[s] = vlink(r); -#ifndef NDEBUG - 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); -} - -@ @c -#ifdef DEBUG -static void print_free_chain(int c) -{ - halfword p = free_chain[c]; - fprintf(stdout, "\nfree chain[%d] =\n ", c); - while (p != null) { - fprintf(stdout, "%d,", (int) p); - p = vlink(p); - } - fprintf(stdout, "null;\n"); -} -#endif - -@ @c -void free_node(halfword p, int s) -{ - - if (p <= my_prealloc) { - fprintf(stdout, "node %d (type %d) should not be freed!\n", (int) p, - type(p)); - return; - } -#ifndef NDEBUG - 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; - } - var_used -= s; /* maintain statistics */ -} - -@ @c -static void free_node_chain(halfword q, int s) -{ - register halfword p = q; - while (vlink(p) != null) { -#ifndef NDEBUG - varmem_sizes[p] = 0; -#endif - var_used -= s; - p = vlink(p); - } - var_used -= s; -#ifndef NDEBUG - varmem_sizes[p] = 0; -#endif - vlink(p) = free_chain[s]; - free_chain[s] = q; -} - - -@ @c -void init_node_mem(int t) -{ - my_prealloc = var_mem_stat_max; - assert(whatsit_node_data[user_defined_node].id == user_defined_node); - assert(node_data[passive_node].id == passive_node); - - 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)); - -#ifndef NDEBUG - 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 */ - glue_ref_count(zero_glue) = null + 1; - width(zero_glue) = 0; - type(zero_glue) = glue_spec_node; - vlink(zero_glue) = null; - stretch(zero_glue) = 0; - stretch_order(zero_glue) = normal; - shrink(zero_glue) = 0; - shrink_order(zero_glue) = normal; - glue_ref_count(sfi_glue) = null + 1; - width(sfi_glue) = 0; - type(sfi_glue) = glue_spec_node; - vlink(sfi_glue) = null; - stretch(sfi_glue) = 0; - stretch_order(sfi_glue) = sfi; - shrink(sfi_glue) = 0; - shrink_order(sfi_glue) = normal; - glue_ref_count(fil_glue) = null + 1; - width(fil_glue) = 0; - type(fil_glue) = glue_spec_node; - vlink(fil_glue) = null; - stretch(fil_glue) = unity; - stretch_order(fil_glue) = fil; - shrink(fil_glue) = 0; - shrink_order(fil_glue) = normal; - glue_ref_count(fill_glue) = null + 1; - width(fill_glue) = 0; - type(fill_glue) = glue_spec_node; - vlink(fill_glue) = null; - stretch(fill_glue) = unity; - stretch_order(fill_glue) = fill; - shrink(fill_glue) = 0; - shrink_order(fill_glue) = normal; - glue_ref_count(ss_glue) = null + 1; - width(ss_glue) = 0; - type(ss_glue) = glue_spec_node; - vlink(ss_glue) = null; - stretch(ss_glue) = unity; - stretch_order(ss_glue) = fil; - shrink(ss_glue) = unity; - shrink_order(ss_glue) = fil; - glue_ref_count(fil_neg_glue) = null + 1; - width(fil_neg_glue) = 0; - type(fil_neg_glue) = glue_spec_node; - vlink(fil_neg_glue) = null; - stretch(fil_neg_glue) = -unity; - stretch_order(fil_neg_glue) = fil; - shrink(fil_neg_glue) = 0; - shrink_order(fil_neg_glue) = normal; - /* initialize node list heads */ - vinfo(page_ins_head) = 0; - type(page_ins_head) = temp_node; - vlink(page_ins_head) = null; - alink(page_ins_head) = null; - vinfo(contrib_head) = 0; - type(contrib_head) = temp_node; - vlink(contrib_head) = null; - alink(contrib_head) = null; - vinfo(page_head) = 0; - type(page_head) = temp_node; - vlink(page_head) = null; - alink(page_head) = null; - vinfo(temp_head) = 0; - type(temp_head) = temp_node; - vlink(temp_head) = null; - alink(temp_head) = null; - vinfo(hold_head) = 0; - type(hold_head) = temp_node; - vlink(hold_head) = null; - alink(hold_head) = null; - vinfo(adjust_head) = 0; - type(adjust_head) = temp_node; - vlink(adjust_head) = null; - alink(adjust_head) = null; - vinfo(pre_adjust_head) = 0; - type(pre_adjust_head) = temp_node; - vlink(pre_adjust_head) = null; - alink(pre_adjust_head) = null; - vinfo(active) = 0; - type(active) = unhyphenated_node; - vlink(active) = null; - alink(active) = null; - vinfo(align_head) = 0; - type(align_head) = temp_node; - vlink(align_head) = null; - alink(align_head) = null; - vinfo(end_span) = 0; - type(end_span) = span_node; - vlink(end_span) = null; - alink(end_span) = null; - type(begin_point) = glyph_node; - subtype(begin_point) = 0; - vlink(begin_point) = null; - vinfo(begin_point + 1) = null; - alink(begin_point) = null; - font(begin_point) = 0; - character(begin_point) = '.'; - vinfo(begin_point + 3) = 0; - vlink(begin_point + 3) = 0; - vinfo(begin_point + 4) = 0; - vlink(begin_point + 4) = 0; - type(end_point) = glyph_node; - subtype(end_point) = 0; - vlink(end_point) = null; - vinfo(end_point + 1) = null; - alink(end_point) = null; - font(end_point) = 0; - character(end_point) = '.'; - vinfo(end_point + 3) = 0; - vlink(end_point + 3) = 0; - vinfo(end_point + 4) = 0; - vlink(end_point + 4) = 0; -} - -@ @c -void dump_node_mem(void) -{ - dump_int(var_mem_max); - dump_int(rover); - dump_things(varmem[0], var_mem_max); -#ifndef NDEBUG - 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); -#if 0 - memset ((void *)varmem,0,x*sizeof(memory_word)); -#endif - undump_things(varmem[0], x); -#ifndef NDEBUG - 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; - } -} - -#if 0 -void test_rovers(char *s) -{ - int q = rover; - int r = q; - fprintf(stdout, "%s: {rover=%d,size=%d,link=%d}", s, r, node_size(r), - vlink(r)); - while (vlink(r) != q) { - r = vlink(r); - fprintf(stdout, ",{rover=%d,size=%d,link=%d}", r, node_size(r), - vlink(r)); - } - fprintf(stdout, "\n"); -} -#else -# define test_rovers(a) -#endif - -@ @c -halfword slow_get_node(int s) -{ - register int t; - - RETRY: - t = node_size(rover); - assert(vlink(rover) < var_mem_max); - assert(vlink(rover) != 0); - test_rovers("entry"); - if (t > s) { - register halfword r; - /* allocating from the bottom helps decrease page faults */ - 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; - } - test_rovers("taken"); - assert(vlink(rover) < var_mem_max); -#ifndef NDEBUG - 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 { - int x; - /* attempt to keep the free list small */ - 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; - test_rovers("outtake"); - 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)); - -#ifndef NDEBUG - 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; - test_rovers("realloc"); - var_mem_max += x; - goto RETRY; - } -} - -@ @c -char *sprint_node_mem_usage(void) -{ - int i, b; - - char *s, *ss; -#ifndef NDEBUG - char msg[256]; - int node_counts[last_normal_node + last_whatsit_node + 2] = { 0 }; - - 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)]++; - } - } - } - s = strdup(""); - b = 0; - 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 i, j; - halfword p = null, q = null; -#ifndef NDEBUG - 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; - } - } - print_nlp(); /* newline, if needed */ -} - -/* 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; - 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) { - update_attribute_cache(); - if (attr_list_cache == null) - return; - } - attr_list_ref(attr_list_cache)++; - node_attr(b) = attr_list_cache; -#ifdef DEBUG - fprintf(DEBUG_OUT, "Added attrlist (%d) to node %d (count=%d)\n", - node_attr(b), b, attr_list_ref(attr_list_cache)); -#endif - } -} - -@ @c -void delete_attribute_ref(halfword b) -{ - if (b != null) { - assert(type(b) == attribute_list_node); - attr_list_ref(b)--; -#ifdef DEBUG - fprintf(DEBUG_OUT, "Removed attrlistref (%d) (count=%d)\n", b, - attr_list_ref(b)); -#endif - 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; - } -} - -@ |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; - assert(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; -} - -@ @c -void set_attribute(halfword n, int i, int val) -{ - register halfword p; - register int j = 0; - if (!nodetype_has_attributes(type(n))) - return; - 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; - } - assert(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); - } - p = node_attr(n); - if (attr_list_ref(p) != 1) { - if (attr_list_ref(p) > 1) { - p = copy_attribute_list(p); - delete_attribute_ref(node_attr(n)); - node_attr(n) = p; - } else { - fprintf(stdout, - "Node %d has an attribute list that is free already\n", - (int) n); - } - attr_list_ref(p) = 1; - } - 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; -} - - -@ @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) { - fprintf(stdout, - "Node %d has an attribute list that is free already\n", - (int) n); - return UNUSED_ATTRIBUTE; - } - assert(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; -} - -@ @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_ptr(p) != zero_glue) - 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; - default: - assert(1); - 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_whatsit_node(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 dir_node: - if (dir_dir(p) < 0) { - tprint_esc("enddir"); - print_char(' '); - print_dir(dir_dir(p) + 64); - } else { - tprint_esc("begindir"); - print_char(' '); - print_dir(dir_dir(p)); - } - break; - case local_par_node: - tprint_esc("whatsit"); - 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 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("pdfcolorstack"); - 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 cancel_boundary_node: - tprint_esc("noboundary"); - break; - case late_lua_node: - show_late_lua(p); - break; - case close_lua_node: - tprint_esc("closelua"); - print_int(late_lua_reg(p)); - 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_refxform_node: - case pdf_refximage_node: - if (subtype(p) == pdf_refxform_node) - tprint_esc("pdfrefxform"); - else - tprint_esc("pdfrefximage"); - tprint("("); - print_scaled(height(p)); - print_char('+'); - print_scaled(depth(p)); - tprint(")x"); - print_scaled(width(p)); - 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: - pdf_error("displaying", "unknown action type"); - 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; - case pdf_save_pos_node: - tprint_esc("pdfsavepos"); - 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; - default: - tprint("whatsit?"); - 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) - -void show_node_list(int p) -{ /* prints a node list symbolically */ - int n; /* the number of items already printed at this level */ - 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; - } - n = 0; - while (p != null) { - print_ln(); - print_current_string(); /* display the nesting history */ - if (int_par(tracing_online_code) < -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|; */ - tprint_esc("rule("); - 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 whatsit_node: - show_whatsit_node(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: - assert(0); - } - tprint("leaders "); - print_spec(glue_ptr(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(glue_ptr(p), NULL); - else - print_spec(glue_ptr(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) == acc_kern) - tprint(" (for 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 (width(p) != 0) { - tprint(", surrounded "); - print_scaled(width(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. */ - tprint_esc("discretionary"); - if (vlink(no_break(p)) != null) { - tprint(" replacing "); - node_list_display(vlink(no_break(p))); - } - node_list_display(vlink(pre_break(p))); /* recursive call */ - append_char('|'); - show_node_list(vlink(post_break(p))); - flush_char(); /* recursive call */ - 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 (adjust_pre(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 -pointer actual_box_width(pointer r, scaled base_width) -{ - scaled w; /* calculated |size| */ - pointer p; /* current node when calculating |pre_display_size| */ - pointer q; /* glue specification when calculating |pre_display_size| */ - scaled d; /* increment to |v| */ - scaled v; /* |w| plus possible glue amount */ - w = -max_dimen; - v = shift_amount(r) + base_width; - p = list_ptr(r); - 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 math_node: - d = surround(p); - break; - 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. - */ - q = glue_ptr(p); - d = width(q); - if (glue_sign(r) == stretching) { - if ((glue_order(r) == stretch_order(q)) - && (stretch(q) != 0)) - v = max_dimen; - } else if (glue_sign(r) == shrinking) { - if ((glue_order(r) == shrink_order(q)) - && (shrink(q) != 0)) - v = max_dimen; - } - if (subtype(p) >= a_leaders) - goto found; - break; - case whatsit_node: - if ((subtype(p) == pdf_refxform_node) - || (subtype(p) == pdf_refximage_node)) - d = width(p); - else - d = 0; - 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; -} - - -@ @c -halfword tail_of_list(halfword p) -{ - halfword q = p; - while (vlink(q) != null) - q = vlink(q); - return q; -} - - -@ |delete_glue_ref| is called when a pointer to a glue - specification is being withdrawn. - -@c -#define fast_delete_glue_ref(A) do { \ - if (glue_ref_count(A)==null) { \ - flush_node(A); \ - } else { \ - decr(glue_ref_count(A)); \ - } \ - } while (0) - -void delete_glue_ref(halfword p) -{ /* |p| points to a glue specification */ - assert(type(p) == glue_spec_node); - fast_delete_glue_ref(p); -} - -@ @c -int var_used; -halfword temp_ptr; /* a pointer variable for occasional emergency use */ - - -@ 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; /* the new node */ - p = new_node(hlist_node, min_quarterword); - box_dir(p) = text_direction; - 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(void) -{ - halfword p; /* the new node */ - p = new_node(rule_node, 0); /* the |subtype| is not used */ - 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, cur_lang, left_hyphen_min, right_hyphen_min); - 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; - w = char_width(font(p), character(p)); - return w; -} - -scaled glyph_height(halfword p) -{ - scaled w; - w = char_height(font(p), character(p)) + y_displace(p); - if (w < 0) - w = 0; - return w; -} - -scaled glyph_depth(halfword p) -{ - scaled w; - 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; /* the new node */ - p = new_node(disc_node, 0); - 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; /* the new node */ - 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 p) -{ /* duplicates a glue specification */ - halfword q; /* the new spec */ - q = copy_node(p); - glue_ref_count(q) = null; - return q; -} - -@ 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; /* the new node */ - halfword q; /* the glue specification */ - p = new_node(glue_node, n + 1); - q = glue_par(n); - glue_ptr(p) = q; - incr(glue_ref_count(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; /* the new node */ - p = new_node(glue_node, normal); - glue_ptr(p) = q; - incr(glue_ref_count(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; /* the new node */ - temp_ptr = new_spec(glue_par(n)); - p = new_glue(temp_ptr); - glue_ref_count(temp_ptr) = null; - subtype(p) = (quarterword) (n + 1); - 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; /* the new node */ - 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) -{ - halfword p; /* the new node */ - p = new_node(penalty_node, 0); /* the |subtype| is not used */ - penalty(p) = m; - 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@> +% 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
+static const char _svn_version[] =
+ "$Id: texnodes.w 4754 2014-01-23 10:01:21Z taco $"
+ "$URL: https://foundry.supelec.fr/svn/luatex/trunk/source/texk/web2c/luatexdir/tex/texnodes.w $";
+
+#include "ptexlib.h"
+#include "lua/luatex-api.h"
+
+@ @c
+#undef name
+
+#define noDEBUG
+#define DEBUG_OUT stdout
+
+#define adjust_pre subtype
+#define attribute(A) eqtb[attribute_base+(A)].cint
+
+#define uc_hyph int_par(uc_hyph_code)
+#define cur_lang int_par(cur_lang_code)
+#define left_hyphen_min int_par(left_hyphen_min_code)
+#define right_hyphen_min int_par(right_hyphen_min_code)
+
+#define text_direction int_par(text_direction_code)
+
+#define MAX_CHAIN_SIZE 13
+
+memory_word *volatile varmem = NULL;
+
+#ifndef NDEBUG
+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;
+
+int free_error_seen = 0;
+int copy_error_seen = 0;
+
+halfword slow_get_node(int s); /* defined below */
+int copy_error(halfword p); /* define below */
+
+#define fake_node 100
+#define fake_node_size 2
+#define fake_node_name "fake"
+
+#define variable_node_size 2
+
+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", 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", NULL };
+const char *node_fields_math[] = { "attr", "surround", NULL };
+const char *node_fields_glue[] = { "attr", "spec", "leader", 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_style[] = { "attr", "style", NULL };
+const char *node_fields_choice[] =
+ { "attr", "display", "text", "script", "scriptscript", NULL };
+const char *node_fields_ord[] = { "attr", "nucleus", "sub", "sup", NULL };
+const char *node_fields_op[] = { "attr", "nucleus", "sub", "sup", NULL };
+const char *node_fields_bin[] = { "attr", "nucleus", "sub", "sup", NULL };
+const char *node_fields_rel[] = { "attr", "nucleus", "sub", "sup", NULL };
+const char *node_fields_open[] = { "attr", "nucleus", "sub", "sup", NULL };
+const char *node_fields_close[] = { "attr", "nucleus", "sub", "sup", NULL };
+const char *node_fields_punct[] = { "attr", "nucleus", "sub", "sup", NULL };
+const char *node_fields_inner[] = { "attr", "nucleus", "sub", "sup", NULL };
+const char *node_fields_under[] = { "attr", "nucleus", "sub", "sup", NULL };
+const char *node_fields_over[] = { "attr", "nucleus", "sub", "sup", NULL };
+const char *node_fields_vcenter[] = { "attr", "nucleus", "sub", "sup", NULL };
+const char *node_fields_radical[] =
+ { "attr", "nucleus", "sub", "sup", "left", "degree", NULL };
+const char *node_fields_fraction[] =
+ { "attr", "width", "num", "denom", "left", "right", NULL };
+const char *node_fields_accent[] =
+ { "attr", "nucleus", "sub", "sup", "accent", "bot_accent", NULL };
+const char *node_fields_fence[] = { "attr", "delim", 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 };
+
+const char *node_fields_inserting[] =
+ { "height", "last_ins_ptr", "best_ins_ptr", NULL };
+
+const char *node_fields_splitup[] = { "height", "last_ins_ptr", "best_ins_ptr",
+ "broken_ptr", "broken_ins", NULL
+};
+
+const char *node_fields_action[] = { "action_type", "named_id", "action_id",
+ "file", "new_window", "data", "ref_count", NULL
+};
+const char *node_fields_attribute[] = { "number", "value", NULL };
+
+const char *node_fields_glue_spec[] = { "width", "stretch", "shrink",
+ "stretch_order", "shrink_order", "ref_count", "writable", NULL
+};
+const char *node_fields_attribute_list[] = { NULL };
+
+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_local_par[] =
+ { "attr", "pen_inter", "pen_broken", "dir",
+ "box_left", "box_left_width", "box_right", "box_right_width", NULL
+};
+const char *node_fields_whatsit_dir[] =
+ { "attr", "dir", "level", "dvi_ptr", "dvi_h", NULL };
+
+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_refxform[] =
+ { "attr", "width", "depth", "height", "objnum", NULL };
+const char *node_fields_whatsit_pdf_refximage[] =
+ { "attr", "width", "depth", "height", "transform", "index", 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_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_save_pos[] = { "attr", NULL };
+const char *node_fields_whatsit_late_lua[] =
+ { "attr", "reg", "data", "name", "string", NULL };
+const char *node_fields_whatsit_close_lua[] = { "attr", "reg", 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 };
+const char *node_fields_whatsit_cancel_boundary[] = { "attr", NULL };
+const char *node_fields_whatsit_user_defined[] =
+ { "attr", "user_id", "type", "value", NULL };
+
+node_info node_data[] = {
+ {hlist_node, box_node_size, node_fields_list, "hlist"},
+ {vlist_node, box_node_size, node_fields_list, "vlist"},
+ {rule_node, rule_node_size, node_fields_rule, "rule"},
+ {ins_node, ins_node_size, node_fields_insert, "ins"},
+ {mark_node, mark_node_size, node_fields_mark, "mark"},
+ {adjust_node, adjust_node_size, node_fields_adjust, "adjust"},
+ {fake_node, fake_node_size, NULL, fake_node_name}, /* don't touch this! */
+ {disc_node, disc_node_size, node_fields_disc, "disc"},
+ {whatsit_node, -1, NULL, "whatsit"},
+ {math_node, math_node_size, node_fields_math, "math"},
+ {glue_node, glue_node_size, node_fields_glue, "glue"},
+ {kern_node, kern_node_size, node_fields_kern, "kern"},
+ {penalty_node, penalty_node_size, node_fields_penalty, "penalty"},
+ {unset_node, box_node_size, node_fields_unset, "unset"},
+ {style_node, style_node_size, node_fields_style, "style"},
+ {choice_node, style_node_size, node_fields_choice, "choice"},
+ {simple_noad, noad_size, node_fields_ord, "noad"},
+ {old_op_noad, noad_size, node_fields_op, "op"},
+ {old_bin_noad, noad_size, node_fields_bin, "bin"},
+ {old_rel_noad, noad_size, node_fields_rel, "rel"},
+ {old_open_noad, noad_size, node_fields_open, "open"},
+ {old_close_noad, noad_size, node_fields_close, "close"},
+ {old_punct_noad, noad_size, node_fields_punct, "punct"},
+ {old_inner_noad, noad_size, node_fields_inner, "inner"},
+ {radical_noad, radical_noad_size, node_fields_radical, "radical"},
+ {fraction_noad, fraction_noad_size, node_fields_fraction, "fraction"},
+ {old_under_noad, noad_size, node_fields_under, "under"},
+ {old_over_noad, noad_size, node_fields_over, "over"},
+ {accent_noad, accent_noad_size, node_fields_accent, "accent"},
+ {old_vcenter_noad, noad_size, node_fields_vcenter, "vcenter"},
+ {fence_noad, fence_noad_size, node_fields_fence, "fence"},
+ {math_char_node, math_kernel_node_size, node_fields_math_char, "math_char"},
+ {sub_box_node, math_kernel_node_size, node_fields_sub_box, "sub_box"},
+ {sub_mlist_node, math_kernel_node_size, node_fields_sub_mlist, "sub_mlist"},
+ {math_text_char_node, math_kernel_node_size, node_fields_math_text_char, "math_text_char"},
+ {delim_node, math_shield_node_size, node_fields_delim, "delim"},
+ {margin_kern_node, margin_kern_node_size, node_fields_margin_kern, "margin_kern"},
+ {glyph_node, glyph_node_size, node_fields_glyph, "glyph"},
+ {align_record_node, box_node_size, NULL, "align_record"},
+ {pseudo_file_node, pseudo_file_node_size, NULL, "pseudo_file"},
+ {pseudo_line_node, variable_node_size, NULL, "pseudo_line"},
+ {inserting_node, page_ins_node_size, node_fields_inserting, "page_insert"},
+ {split_up_node, page_ins_node_size, node_fields_splitup, "split_insert"},
+ {expr_node, expr_node_size, NULL, "expr_stack"},
+ {nesting_node, nesting_node_size, NULL, "nested_list"},
+ {span_node, span_node_size, NULL, "span"},
+ {attribute_node, attribute_node_size, node_fields_attribute, "attribute"},
+ {glue_spec_node, glue_spec_size, node_fields_glue_spec, "glue_spec"},
+ {attribute_list_node, attribute_node_size, node_fields_attribute_list, "attribute_list"},
+ {action_node, pdf_action_size, node_fields_action, "action"},
+ {temp_node, temp_node_size, NULL, "temp"},
+ {align_stack_node, align_stack_node_size, NULL, "align_stack"},
+ {movement_node, movement_node_size, NULL, "movement_stack"},
+ {if_node, if_node_size, NULL, "if_stack"},
+ {unhyphenated_node, active_node_size, NULL, "unhyphenated"},
+ {hyphenated_node, active_node_size, NULL, "hyphenated"},
+ {delta_node, delta_node_size, NULL, "delta"},
+ {passive_node, passive_node_size, NULL, "passive"},
+ {shape_node, variable_node_size, NULL, "shape"},
+ {-1, -1, NULL, NULL}
+};
+
+#define last_normal_node shape_node
+
+node_info whatsit_node_data[] = {
+ {open_node, open_node_size, node_fields_whatsit_open, "open"},
+ {write_node, write_node_size, node_fields_whatsit_write, "write"},
+ {close_node, close_node_size, node_fields_whatsit_close, "close"},
+ {special_node, special_node_size, node_fields_whatsit_special, "special"},
+ {fake_node, fake_node_size, NULL, fake_node_name},
+ {fake_node, fake_node_size, NULL, fake_node_name},
+ {local_par_node, local_par_size, node_fields_whatsit_local_par,
+ "local_par"},
+ {dir_node, dir_node_size, node_fields_whatsit_dir, "dir"},
+ {pdf_literal_node, write_node_size, node_fields_whatsit_pdf_literal,
+ "pdf_literal"},
+ {fake_node, fake_node_size, NULL, fake_node_name},
+ {pdf_refobj_node, pdf_refobj_node_size, node_fields_whatsit_pdf_refobj,
+ "pdf_refobj"},
+ {fake_node, fake_node_size, NULL, fake_node_name},
+ {pdf_refxform_node, pdf_refxform_node_size,
+ node_fields_whatsit_pdf_refxform, "pdf_refxform"},
+ {fake_node, fake_node_size, NULL, fake_node_name},
+ {pdf_refximage_node, pdf_refximage_node_size,
+ node_fields_whatsit_pdf_refximage, "pdf_refximage"},
+ {pdf_annot_node, pdf_annot_node_size, node_fields_whatsit_pdf_annot,
+ "pdf_annot"},
+ {pdf_start_link_node, pdf_annot_node_size,
+ node_fields_whatsit_pdf_start_link, "pdf_start_link"},
+ {pdf_end_link_node, pdf_end_link_node_size,
+ node_fields_whatsit_pdf_end_link, "pdf_end_link"},
+ {fake_node, fake_node_size, NULL, fake_node_name},
+ {pdf_dest_node, pdf_dest_node_size, node_fields_whatsit_pdf_dest,
+ "pdf_dest"},
+ {pdf_thread_node, pdf_thread_node_size, node_fields_whatsit_pdf_thread,
+ "pdf_thread"},
+ {pdf_start_thread_node, pdf_thread_node_size,
+ node_fields_whatsit_pdf_start_thread, "pdf_start_thread"},
+ {pdf_end_thread_node, pdf_end_thread_node_size,
+ node_fields_whatsit_pdf_end_thread, "pdf_end_thread"},
+ {pdf_save_pos_node, pdf_save_pos_node_size,
+ node_fields_whatsit_pdf_save_pos, "pdf_save_pos"},
+ {pdf_thread_data_node, pdf_thread_node_size, NULL, "pdf_thread_data"},
+ {pdf_link_data_node, pdf_annot_node_size, NULL, "pdf_link_data"},
+ {fake_node, fake_node_size, NULL, fake_node_name},
+ {fake_node, fake_node_size, NULL, fake_node_name},
+ {fake_node, fake_node_size, NULL, fake_node_name},
+ {fake_node, fake_node_size, NULL, fake_node_name},
+ {fake_node, fake_node_size, NULL, fake_node_name},
+ {fake_node, fake_node_size, NULL, fake_node_name},
+ {fake_node, fake_node_size, NULL, fake_node_name},
+ {fake_node, fake_node_size, NULL, fake_node_name},
+ {fake_node, fake_node_size, NULL, fake_node_name},
+ {late_lua_node, late_lua_node_size, node_fields_whatsit_late_lua,
+ "late_lua"},
+ {close_lua_node, write_node_size, node_fields_whatsit_close_lua,
+ "close_lua"},
+ {fake_node, fake_node_size, NULL, fake_node_name},
+ {fake_node, fake_node_size, NULL, fake_node_name},
+ {pdf_colorstack_node, pdf_colorstack_node_size,
+ node_fields_whatsit_pdf_colorstack, "pdf_colorstack"},
+ {pdf_setmatrix_node, pdf_setmatrix_node_size,
+ node_fields_whatsit_pdf_setmatrix, "pdf_setmatrix"},
+ {pdf_save_node, pdf_save_node_size, node_fields_whatsit_pdf_save,
+ "pdf_save"},
+ {pdf_restore_node, pdf_restore_node_size, node_fields_whatsit_pdf_restore,
+ "pdf_restore"},
+ {cancel_boundary_node, cancel_boundary_size,
+ node_fields_whatsit_cancel_boundary, "cancel_boundary"},
+ {user_defined_node, user_defined_node_size,
+ node_fields_whatsit_user_defined, "user_defined"},
+ {-1, -1, NULL, NULL}
+};
+
+#define last_whatsit_node user_defined_node
+
+@ @c
+halfword new_node(int i, int j)
+{
+ int s;
+ halfword n;
+ s = get_node_size(i, j);
+ n = get_node(s);
+ /* it should be possible to do this memset at |free_node()| */
+ /* 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 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 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;
+ rule_dir(n) = -1;
+ /* fall through */
+ 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;
+ }
+ /* handle synctex extension */
+ switch (i) {
+ case math_node:
+ synctex_tag_math(n) = cur_input.synctex_tag_field;
+ synctex_line_math(n) = line;
+ break;
+ case glue_node:
+ synctex_tag_glue(n) = cur_input.synctex_tag_field;
+ synctex_line_glue(n) = line;
+ break;
+ case kern_node:
+ /* synctex ignores implicit kerns */
+ 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;
+ }
+ /* take care of attributes */
+ if (nodetype_has_attributes(i)) {
+ build_attribute_list(n);
+ }
+ type(n) = (quarterword) i;
+ subtype(n) = (quarterword) j;
+#ifdef DEBUG
+ fprintf(DEBUG_OUT, "Alloc-ing %s node %d\n",
+ get_node_name(type(n), subtype(n)), (int) n);
+#endif
+ return n;
+}
+
+halfword raw_glyph_node(void)
+{
+ register halfword n;
+ n = get_node(glyph_node_size);
+ (void) memset((void *) (varmem + n + 1), 0,
+ (sizeof(memory_word) * (glyph_node_size - 1)));
+ type(n) = glyph_node;
+ subtype(n) = 0;
+ return n;
+}
+
+halfword new_glyph_node(void)
+{
+ register halfword n;
+ n = get_node(glyph_node_size);
+ (void) memset((void *) (varmem + n + 1), 0,
+ (sizeof(memory_word) * (glyph_node_size - 1)));
+ type(n) = glyph_node;
+ subtype(n) = 0;
+ build_attribute_list(n);
+ 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 */
+ copy_error_seen = 0;
+ while (p != end) {
+ register halfword s = copy_node(p);
+ if (h == null) {
+ h = s;
+ } else {
+ couple_nodes(q, s);
+ }
+ q = s;
+ p = vlink(p);
+ }
+ return h;
+}
+
+halfword copy_node_list(halfword p)
+{
+ return do_copy_node_list(p, null);
+}
+
+@ make a dupe of a single node
+@c
+halfword copy_node(const halfword p)
+{
+ halfword r; /* current node being fabricated for new list */
+ 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;
+ }
+ i = get_node_size(type(p), subtype(p));
+ r = get_node(i);
+
+ (void) memcpy((void *) (varmem + r), (void *) (varmem + p),
+ (sizeof(memory_word) * (unsigned) i));
+
+ /* handle synctex extension */
+ switch (type(p)) {
+ 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(type(p))) {
+ add_node_attr_ref(node_attr(p));
+ alink(r) = null; /* needs checking */
+ }
+ vlink(r) = null;
+
+
+ switch (type(p)) {
+ case glyph_node:
+ s = copy_node_list(lig_ptr(p));
+ lig_ptr(r) = s;
+ break;
+ case glue_node:
+ add_glue_ref(glue_ptr(p));
+ s = copy_node_list(leader_ptr(p));
+ leader_ptr(r) = s;
+ break;
+ case hlist_node:
+ case vlist_node:
+ case unset_node:
+ s = copy_node_list(list_ptr(p));
+ list_ptr(r) = s;
+ break;
+ case ins_node:
+ add_glue_ref(split_top_ptr(p));
+ s = copy_node_list(ins_ptr(p));
+ ins_ptr(r) = s;
+ break;
+ case margin_kern_node:
+ s = copy_node(margin_char(p));
+ margin_char(r) = s;
+ 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 mark_node:
+ add_token_ref(mark_ptr(p));
+ break;
+ case adjust_node:
+ s = copy_node_list(adjust_ptr(p));
+ adjust_ptr(r) = s;
+ break;
+
+ case choice_node:
+ s = copy_node_list(display_mlist(p));
+ display_mlist(r) = s;
+ s = copy_node_list(text_mlist(p));
+ text_mlist(r) = s;
+ s = copy_node_list(script_mlist(p));
+ script_mlist(r) = s;
+ s = copy_node_list(script_script_mlist(p));
+ script_script_mlist(r) = s;
+ break;
+ case simple_noad:
+ case radical_noad:
+ case accent_noad:
+ s = copy_node_list(nucleus(p));
+ nucleus(r) = s;
+ s = copy_node_list(subscr(p));
+ subscr(r) = s;
+ s = copy_node_list(supscr(p));
+ supscr(r) = s;
+ if (type(p) == accent_noad) {
+ s = copy_node_list(accent_chr(p));
+ accent_chr(r) = s;
+ s = copy_node_list(bot_accent_chr(p));
+ bot_accent_chr(r) = s;
+ } else if (type(p) == radical_noad) {
+ s = copy_node(left_delimiter(p));
+ left_delimiter(r) = s;
+ s = copy_node_list(degree(p));
+ degree(r) = s;
+ }
+ break;
+ case fence_noad:
+ s = copy_node(delimiter(p));
+ delimiter(r) = s;
+ break;
+ case sub_box_node:
+ case sub_mlist_node:
+ s = copy_node_list(math_list(p));
+ math_list(r) = s;
+ break;
+ case fraction_noad:
+ s = copy_node_list(numerator(p));
+ numerator(r) = s;
+ s = copy_node_list(denominator(p));
+ denominator(r) = s;
+ s = copy_node(left_delimiter(p));
+ left_delimiter(r) = s;
+ s = copy_node(right_delimiter(p));
+ right_delimiter(r) = s;
+ break;
+ case glue_spec_node:
+ glue_ref_count(r) = null;
+ break;
+ case whatsit_node:
+ switch (subtype(p)) {
+ case dir_node:
+ case local_par_node:
+ break;
+ case write_node:
+ case special_node:
+ add_token_ref(write_tokens(p));
+ break;
+ 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 late_lua_node:
+ copy_late_lua(r, 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;
+ case user_defined_node:
+ switch (user_node_type(p)) {
+ case 'a':
+ add_node_attr_ref(user_node_value(p));
+ break;
+ case 't':
+ add_token_ref(user_node_value(p));
+ break;
+ case 's':
+ /* |add_string_ref(user_node_value(p));| *//* if this was mpost .. */
+ break;
+ case 'n':
+ s = copy_node_list(user_node_value(p));
+ user_node_value(r) = s;
+ break;
+ }
+ break;
+#if 0
+ case style_node:
+ case delim_node:
+ case math_char_node:
+ case math_text_char_node:
+ break;
+#else
+ default:
+#endif
+ break;
+ }
+ break;
+ }
+#ifdef DEBUG
+ fprintf(DEBUG_OUT, "Alloc-ing %s node %d (copy of %d)\n",
+ get_node_name(type(r), subtype(r)), (int) r, (int) p);
+#endif
+ return r;
+}
+
+@ @c
+int valid_node(halfword p)
+{
+ if (p > my_prealloc) {
+ if (p < var_mem_max) {
+#ifndef NDEBUG
+ if (varmem_sizes[p] > 0)
+#endif
+ return 1;
+ }
+ } else {
+ return 0;
+ }
+ return 0;
+}
+
+@ @c
+static void do_free_error(halfword p)
+{
+ halfword r;
+ char errstr[255] = { 0 };
+ const char *errhlp[] = {
+ "When I tried to free the node mentioned in the error message, it turned",
+ "out it was not (or no longer) actually in use.",
+ "Errors such as these are often caused by Lua node list alteration,",
+ "but could also point to a bug in the executable. It should be safe to continue.",
+ NULL
+ };
+
+ check_node_mem();
+ if (free_error_seen)
+ return;
+
+ r = null;
+ free_error_seen = 1;
+ if (type(p) == glyph_node) {
+ snprintf(errstr, 255,
+ "Attempt to double-free glyph (%c) node %d, ignored",
+ (int) character(p), (int) p);
+ } else {
+ snprintf(errstr, 255, "Attempt to double-free %s node %d, ignored",
+ get_node_name(type(p), subtype(p)), (int) p);
+ }
+ tex_error(errstr, errhlp);
+#ifndef NDEBUG
+ 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)
+{
+ assert(p > my_prealloc);
+ assert(p < var_mem_max);
+#ifndef NDEBUG
+ if (varmem_sizes[p] == 0) {
+ do_free_error(p);
+ return 1; /* double free */
+ }
+#endif
+ return 0;
+}
+
+
+@ @c
+static void do_copy_error(halfword p)
+{
+ char errstr[255] = { 0 };
+ const char *errhlp[] = {
+ "When I tried to copy the node mentioned in the error message, it turned",
+ "out it was not (or no longer) actually in use.",
+ "Errors such as these are often caused by Lua node list alteration,",
+ "but could also point to a bug in the executable. It should be safe to continue.",
+ NULL
+ };
+
+ if (copy_error_seen)
+ return;
+
+ copy_error_seen = 1;
+ if (type(p) == glyph_node) {
+ snprintf(errstr, 255,
+ "Attempt to copy free glyph (%c) node %d, ignored",
+ (int) character(p), (int) p);
+ } else {
+ snprintf(errstr, 255, "Attempt to copy free %s node %d, ignored",
+ get_node_name(type(p), subtype(p)), (int) p);
+ }
+ tex_error(errstr, errhlp);
+}
+
+
+int copy_error(halfword p)
+{
+ assert(p >= 0);
+ assert(p < var_mem_max);
+#ifndef NDEBUG
+ if (p > my_prealloc && varmem_sizes[p] == 0) {
+ do_copy_error(p);
+ return 1; /* copy free node */
+ }
+#endif
+ return 0;
+}
+
+
+@ @c
+void flush_node(halfword p)
+{
+
+ if (p == null) /* legal, but no-op */
+ return;
+
+#ifdef DEBUG
+ fprintf(DEBUG_OUT, "Free-ing %s node %d\n",
+ get_node_name(type(p), subtype(p)), (int) p);
+#endif
+ if (free_error(p))
+ return;
+
+ switch (type(p)) {
+ case glyph_node:
+ flush_node_list(lig_ptr(p));
+ break;
+ case glue_node:
+ delete_glue_ref(glue_ptr(p));
+ flush_node_list(leader_ptr(p));
+ break;
+ case glue_spec_node:
+ /* this allows free-ing of lua-allocated glue specs */
+ if (valid_node(p)) {
+ if (glue_ref_count(p)!=null) {
+ decr(glue_ref_count(p));
+ } else {
+ free_node(p, get_node_size(type(p), subtype(p)));
+ }
+ }
+ return ;
+ break ;
+ case attribute_node:
+ case attribute_list_node:
+ case temp_node:
+ case rule_node:
+ case kern_node:
+ case math_node:
+ case penalty_node:
+ break;
+
+ case hlist_node:
+ case vlist_node:
+ case unset_node:
+ flush_node_list(list_ptr(p));
+ break;
+ case whatsit_node:
+ switch (subtype(p)) {
+
+ case dir_node:
+ break;
+ case open_node:
+ case write_node:
+ case close_node:
+ case pdf_save_node:
+ case pdf_restore_node:
+ case cancel_boundary_node:
+ case close_lua_node:
+ case pdf_refobj_node:
+ case pdf_refxform_node:
+ case pdf_refximage_node:
+ case pdf_end_link_node:
+ case pdf_end_thread_node:
+ case pdf_save_pos_node:
+ case local_par_node:
+ break;
+
+ case special_node:
+ delete_token_ref(write_tokens(p));
+ 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 late_lua_node:
+ free_late_lua(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_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;
+ case user_defined_node:
+ switch (user_node_type(p)) {
+ case 'a':
+ delete_attribute_ref(user_node_value(p));
+ break;
+ case 't':
+ delete_token_ref(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 'd':
+ 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;
+
+ default:
+ confusion("ext3");
+ return;
+
+ }
+ break;
+ case ins_node:
+ flush_node_list(ins_ptr(p));
+ delete_glue_ref(split_top_ptr(p));
+ break;
+ case margin_kern_node:
+ flush_node(margin_char(p));
+ break;
+ case mark_node:
+ delete_token_ref(mark_ptr(p));
+ break;
+ case disc_node:
+ flush_node_list(vlink(pre_break(p)));
+ flush_node_list(vlink(post_break(p)));
+ flush_node_list(vlink(no_break(p)));
+ break;
+ case adjust_node:
+ flush_node_list(adjust_ptr(p));
+ break;
+ case style_node: /* nothing to do */
+ break;
+ case choice_node:
+ flush_node_list(display_mlist(p));
+ flush_node_list(text_mlist(p));
+ flush_node_list(script_mlist(p));
+ flush_node_list(script_script_mlist(p));
+ break;
+ case simple_noad:
+ case radical_noad:
+ case accent_noad:
+ flush_node_list(nucleus(p));
+ flush_node_list(subscr(p));
+ flush_node_list(supscr(p));
+ if (type(p) == accent_noad) {
+ flush_node_list(accent_chr(p));
+ flush_node_list(bot_accent_chr(p));
+ } else if (type(p) == radical_noad) {
+ flush_node(left_delimiter(p));
+ flush_node_list(degree(p));
+ }
+ break;
+ case fence_noad:
+ flush_node(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:
+ flush_node_list(math_list(p));
+ break;
+ case fraction_noad:
+ flush_node_list(numerator(p));
+ flush_node_list(denominator(p));
+ flush_node(left_delimiter(p));
+ flush_node(right_delimiter(p));
+ break;
+ case pseudo_file_node:
+ flush_node_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 action_node:
+ case inserting_node:
+ case split_up_node:
+ case expr_node:
+ break;
+ default:
+ fprintf(stdout, "flush_node: type is %d\n", type(p));
+ return;
+
+ }
+ if (nodetype_has_attributes(type(p)))
+ delete_attribute_ref(node_attr(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;
+ free_error_seen = 0;
+ if (p == null) /* legal, but no-op */
+ return;
+ if (free_error(p))
+ return;
+
+ while (p != null) {
+ register halfword q = vlink(p);
+ flush_node(p);
+ p = q;
+ }
+}
+
+@ @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("dorangetest"); \
+ } } 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("dotest"); \
+ } } while (0)
+
+#define check_action_ref(a) { dorangetest(p,a,var_mem_max); }
+#define check_glue_ref(a) { dorangetest(p,a,var_mem_max); }
+#define check_attribute_ref(a) { dorangetest(p,a,var_mem_max); }
+#define check_token_ref(a) assert(1)
+
+void check_node(halfword p)
+{
+
+ switch (type(p)) {
+ case glyph_node:
+ dorangetest(p, lig_ptr(p), var_mem_max);
+ break;
+ case glue_node:
+ check_glue_ref(glue_ptr(p));
+ 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);
+ check_glue_ref(split_top_ptr(p));
+ break;
+ case whatsit_node:
+ switch (subtype(p)) {
+ case special_node:
+ check_token_ref(write_tokens(p));
+ break;
+ case pdf_literal_node:
+ if (pdf_literal_type(p) == normal)
+ check_token_ref(pdf_literal_data(p));
+ break;
+ case pdf_colorstack_node:
+ if (pdf_colorstack_cmd(p) <= colorstack_data)
+ check_token_ref(pdf_colorstack_data(p));
+ break;
+ case pdf_setmatrix_node:
+ check_token_ref(pdf_setmatrix_data(p));
+ break;
+ case late_lua_node:
+ if (late_lua_name(p) > 0)
+ check_token_ref(late_lua_name(p));
+ if (late_lua_type(p) == normal)
+ check_token_ref(late_lua_data(p));
+ break;
+ case pdf_annot_node:
+ check_token_ref(pdf_annot_data(p));
+ break;
+ case pdf_start_link_node:
+ if (pdf_link_attr(p) != null)
+ check_token_ref(pdf_link_attr(p));
+ check_action_ref(pdf_link_action(p));
+ break;
+ case pdf_dest_node:
+ if (pdf_dest_named_id(p) > 0)
+ check_token_ref(pdf_dest_id(p));
+ break;
+ case pdf_thread_node:
+ case pdf_start_thread_node:
+ if (pdf_thread_named_id(p) > 0)
+ check_token_ref(pdf_thread_id(p));
+ if (pdf_thread_attr(p) != null)
+ check_token_ref(pdf_thread_attr(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(user_node_value(p));
+ break;
+ case 'n':
+ dorangetest(p, user_node_value(p), var_mem_max);
+ break;
+ case 's':
+ case 'd':
+ break;
+ default:
+ confusion("extuser");
+ break;
+ }
+ break;
+ case dir_node:
+ case open_node:
+ case write_node:
+ case close_node:
+ case pdf_save_node:
+ case pdf_restore_node:
+ case cancel_boundary_node:
+ case close_lua_node:
+ case pdf_refobj_node:
+ case pdf_refxform_node:
+ case pdf_refximage_node:
+ case pdf_end_link_node:
+ case pdf_end_thread_node:
+ case pdf_save_pos_node:
+ case local_par_node:
+ break;
+ default:
+ confusion("ext3");
+ }
+ break;
+ case margin_kern_node:
+ check_node(margin_char(p));
+ 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, accent_chr(p), var_mem_max);
+ dorangetest(p, bot_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 math_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:
+ break;
+ default:
+ fprintf(stdout, "check_node: type is %d\n", type(p));
+ }
+}
+
+@ @c
+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);
+}
+
+@ @c
+void check_node_mem(void)
+{
+ int i;
+ check_static_node_mem();
+#ifndef NDEBUG
+ for (i = (my_prealloc + 1); i < var_mem_max; i++) {
+ if (varmem_sizes[i] > 0) {
+ check_node(i);
+ }
+ }
+#endif
+ test_count++;
+}
+
+@ @c
+void fix_node_list(halfword head)
+{
+ halfword p, q;
+ if (head == null)
+ return;
+ p = head;
+ q = vlink(p);
+ while (q != null) {
+ alink(q) = p;
+ p = q;
+ q = vlink(p);
+ }
+}
+
+@ @c
+halfword get_node(int s)
+{
+ register halfword r;
+#if 0
+ check_static_node_mem();
+#endif
+ assert(s < MAX_CHAIN_SIZE);
+
+ r = free_chain[s];
+ if (r != null) {
+ free_chain[s] = vlink(r);
+#ifndef NDEBUG
+ 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);
+}
+
+@ @c
+#ifdef DEBUG
+static void print_free_chain(int c)
+{
+ halfword p = free_chain[c];
+ fprintf(stdout, "\nfree chain[%d] =\n ", c);
+ while (p != null) {
+ fprintf(stdout, "%d,", (int) p);
+ p = vlink(p);
+ }
+ fprintf(stdout, "null;\n");
+}
+#endif
+
+@ @c
+void free_node(halfword p, int s)
+{
+
+ if (p <= my_prealloc) {
+ fprintf(stdout, "node %d (type %d) should not be freed!\n", (int) p,
+ type(p));
+ return;
+ }
+#ifndef NDEBUG
+ 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;
+ }
+ var_used -= s; /* maintain statistics */
+}
+
+@ @c
+static void free_node_chain(halfword q, int s)
+{
+ register halfword p = q;
+ while (vlink(p) != null) {
+#ifndef NDEBUG
+ varmem_sizes[p] = 0;
+#endif
+ var_used -= s;
+ p = vlink(p);
+ }
+ var_used -= s;
+#ifndef NDEBUG
+ varmem_sizes[p] = 0;
+#endif
+ vlink(p) = free_chain[s];
+ free_chain[s] = q;
+}
+
+
+@ @c
+void init_node_mem(int t)
+{
+ my_prealloc = var_mem_stat_max;
+ assert(whatsit_node_data[user_defined_node].id == user_defined_node);
+ assert(node_data[passive_node].id == passive_node);
+
+ 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));
+
+#ifndef NDEBUG
+ 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 */
+ glue_ref_count(zero_glue) = null + 1;
+ width(zero_glue) = 0;
+ type(zero_glue) = glue_spec_node;
+ vlink(zero_glue) = null;
+ stretch(zero_glue) = 0;
+ stretch_order(zero_glue) = normal;
+ shrink(zero_glue) = 0;
+ shrink_order(zero_glue) = normal;
+ glue_ref_count(sfi_glue) = null + 1;
+ width(sfi_glue) = 0;
+ type(sfi_glue) = glue_spec_node;
+ vlink(sfi_glue) = null;
+ stretch(sfi_glue) = 0;
+ stretch_order(sfi_glue) = sfi;
+ shrink(sfi_glue) = 0;
+ shrink_order(sfi_glue) = normal;
+ glue_ref_count(fil_glue) = null + 1;
+ width(fil_glue) = 0;
+ type(fil_glue) = glue_spec_node;
+ vlink(fil_glue) = null;
+ stretch(fil_glue) = unity;
+ stretch_order(fil_glue) = fil;
+ shrink(fil_glue) = 0;
+ shrink_order(fil_glue) = normal;
+ glue_ref_count(fill_glue) = null + 1;
+ width(fill_glue) = 0;
+ type(fill_glue) = glue_spec_node;
+ vlink(fill_glue) = null;
+ stretch(fill_glue) = unity;
+ stretch_order(fill_glue) = fill;
+ shrink(fill_glue) = 0;
+ shrink_order(fill_glue) = normal;
+ glue_ref_count(ss_glue) = null + 1;
+ width(ss_glue) = 0;
+ type(ss_glue) = glue_spec_node;
+ vlink(ss_glue) = null;
+ stretch(ss_glue) = unity;
+ stretch_order(ss_glue) = fil;
+ shrink(ss_glue) = unity;
+ shrink_order(ss_glue) = fil;
+ glue_ref_count(fil_neg_glue) = null + 1;
+ width(fil_neg_glue) = 0;
+ type(fil_neg_glue) = glue_spec_node;
+ vlink(fil_neg_glue) = null;
+ stretch(fil_neg_glue) = -unity;
+ stretch_order(fil_neg_glue) = fil;
+ shrink(fil_neg_glue) = 0;
+ shrink_order(fil_neg_glue) = normal;
+ /* initialize node list heads */
+ vinfo(page_ins_head) = 0;
+ type(page_ins_head) = temp_node;
+ vlink(page_ins_head) = null;
+ alink(page_ins_head) = null;
+ vinfo(contrib_head) = 0;
+ type(contrib_head) = temp_node;
+ vlink(contrib_head) = null;
+ alink(contrib_head) = null;
+ vinfo(page_head) = 0;
+ type(page_head) = temp_node;
+ vlink(page_head) = null;
+ alink(page_head) = null;
+ vinfo(temp_head) = 0;
+ type(temp_head) = temp_node;
+ vlink(temp_head) = null;
+ alink(temp_head) = null;
+ vinfo(hold_head) = 0;
+ type(hold_head) = temp_node;
+ vlink(hold_head) = null;
+ alink(hold_head) = null;
+ vinfo(adjust_head) = 0;
+ type(adjust_head) = temp_node;
+ vlink(adjust_head) = null;
+ alink(adjust_head) = null;
+ vinfo(pre_adjust_head) = 0;
+ type(pre_adjust_head) = temp_node;
+ vlink(pre_adjust_head) = null;
+ alink(pre_adjust_head) = null;
+ vinfo(active) = 0;
+ type(active) = unhyphenated_node;
+ vlink(active) = null;
+ alink(active) = null;
+ vinfo(align_head) = 0;
+ type(align_head) = temp_node;
+ vlink(align_head) = null;
+ alink(align_head) = null;
+ vinfo(end_span) = 0;
+ type(end_span) = span_node;
+ vlink(end_span) = null;
+ alink(end_span) = null;
+ type(begin_point) = glyph_node;
+ subtype(begin_point) = 0;
+ vlink(begin_point) = null;
+ vinfo(begin_point + 1) = null;
+ alink(begin_point) = null;
+ font(begin_point) = 0;
+ character(begin_point) = '.';
+ vinfo(begin_point + 3) = 0;
+ vlink(begin_point + 3) = 0;
+ vinfo(begin_point + 4) = 0;
+ vlink(begin_point + 4) = 0;
+ type(end_point) = glyph_node;
+ subtype(end_point) = 0;
+ vlink(end_point) = null;
+ vinfo(end_point + 1) = null;
+ alink(end_point) = null;
+ font(end_point) = 0;
+ character(end_point) = '.';
+ vinfo(end_point + 3) = 0;
+ vlink(end_point + 3) = 0;
+ vinfo(end_point + 4) = 0;
+ vlink(end_point + 4) = 0;
+}
+
+@ @c
+void dump_node_mem(void)
+{
+ dump_int(var_mem_max);
+ dump_int(rover);
+ dump_things(varmem[0], var_mem_max);
+#ifndef NDEBUG
+ 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);
+#if 0
+ memset ((void *)varmem,0,x*sizeof(memory_word));
+#endif
+ undump_things(varmem[0], x);
+#ifndef NDEBUG
+ 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;
+ }
+}
+
+#if 0
+void test_rovers(char *s)
+{
+ int q = rover;
+ int r = q;
+ fprintf(stdout, "%s: {rover=%d,size=%d,link=%d}", s, r, node_size(r),
+ vlink(r));
+ while (vlink(r) != q) {
+ r = vlink(r);
+ fprintf(stdout, ",{rover=%d,size=%d,link=%d}", r, node_size(r),
+ vlink(r));
+ }
+ fprintf(stdout, "\n");
+}
+#else
+# define test_rovers(a)
+#endif
+
+@ @c
+halfword slow_get_node(int s)
+{
+ register int t;
+
+ RETRY:
+ t = node_size(rover);
+ assert(vlink(rover) < var_mem_max);
+ assert(vlink(rover) != 0);
+ test_rovers("entry");
+ if (t > s) {
+ register halfword r;
+ /* allocating from the bottom helps decrease page faults */
+ 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;
+ }
+ test_rovers("taken");
+ assert(vlink(rover) < var_mem_max);
+#ifndef NDEBUG
+ 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 {
+ int x;
+ /* attempt to keep the free list small */
+ 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;
+ test_rovers("outtake");
+ 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));
+
+#ifndef NDEBUG
+ 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;
+ test_rovers("realloc");
+ var_mem_max += x;
+ goto RETRY;
+ }
+}
+
+@ @c
+char *sprint_node_mem_usage(void)
+{
+ int i, b;
+
+ char *s, *ss;
+#ifndef NDEBUG
+ char msg[256];
+ int node_counts[last_normal_node + last_whatsit_node + 2] = { 0 };
+
+ 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)]++;
+ }
+ }
+ }
+ s = strdup("");
+ b = 0;
+ 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 i, j;
+ halfword p = null, q = null;
+#ifndef NDEBUG
+ 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;
+ }
+ }
+ print_nlp(); /* newline, if needed */
+}
+
+/* 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;
+ 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) {
+ update_attribute_cache();
+ if (attr_list_cache == null)
+ return;
+ }
+ attr_list_ref(attr_list_cache)++;
+ node_attr(b) = attr_list_cache;
+#ifdef DEBUG
+ fprintf(DEBUG_OUT, "Added attrlist (%d) to node %d (count=%d)\n",
+ node_attr(b), b, attr_list_ref(attr_list_cache));
+#endif
+ }
+}
+
+@ @c
+void delete_attribute_ref(halfword b)
+{
+ if (b != null) {
+ assert(type(b) == attribute_list_node);
+ attr_list_ref(b)--;
+#ifdef DEBUG
+ fprintf(DEBUG_OUT, "Removed attrlistref (%d) (count=%d)\n", b,
+ attr_list_ref(b));
+#endif
+ 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;
+ }
+}
+
+@ |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;
+ assert(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;
+}
+
+@ @c
+void set_attribute(halfword n, int i, int val)
+{
+ register halfword p;
+ register int j = 0;
+ if (!nodetype_has_attributes(type(n)))
+ return;
+ 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;
+ }
+ assert(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);
+ }
+ p = node_attr(n);
+ if (attr_list_ref(p) != 1) {
+ if (attr_list_ref(p) > 1) {
+ p = copy_attribute_list(p);
+ delete_attribute_ref(node_attr(n));
+ node_attr(n) = p;
+ } else {
+ fprintf(stdout,
+ "Node %d has an attribute list that is free already\n",
+ (int) n);
+ }
+ attr_list_ref(p) = 1;
+ }
+ 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;
+}
+
+
+@ @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) {
+ fprintf(stdout,
+ "Node %d has an attribute list that is free already\n",
+ (int) n);
+ return UNUSED_ATTRIBUTE;
+ }
+ assert(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;
+}
+
+@ @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_ptr(p) != zero_glue)
+ 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;
+ default:
+ assert(1);
+ 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_whatsit_node(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 dir_node:
+ if (dir_dir(p) < 0) {
+ tprint_esc("enddir");
+ print_char(' ');
+ print_dir(dir_dir(p) + 64);
+ } else {
+ tprint_esc("begindir");
+ print_char(' ');
+ print_dir(dir_dir(p));
+ }
+ break;
+ case local_par_node:
+ tprint_esc("whatsit");
+ 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 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("pdfcolorstack");
+ 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 cancel_boundary_node:
+ tprint_esc("noboundary");
+ break;
+ case late_lua_node:
+ show_late_lua(p);
+ break;
+ case close_lua_node:
+ tprint_esc("closelua");
+ print_int(late_lua_reg(p));
+ 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_refxform_node:
+ case pdf_refximage_node:
+ if (subtype(p) == pdf_refxform_node)
+ tprint_esc("pdfrefxform");
+ else
+ tprint_esc("pdfrefximage");
+ tprint("(");
+ print_scaled(height(p));
+ print_char('+');
+ print_scaled(depth(p));
+ tprint(")x");
+ print_scaled(width(p));
+ 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:
+ pdf_error("displaying", "unknown action type");
+ 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;
+ case pdf_save_pos_node:
+ tprint_esc("pdfsavepos");
+ 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;
+ default:
+ tprint("whatsit?");
+ 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)
+
+void show_node_list(int p)
+{ /* prints a node list symbolically */
+ int n; /* the number of items already printed at this level */
+ 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;
+ }
+ n = 0;
+ while (p != null) {
+ print_ln();
+ print_current_string(); /* display the nesting history */
+ if (int_par(tracing_online_code) < -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|; */
+ tprint_esc("rule(");
+ 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 whatsit_node:
+ show_whatsit_node(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:
+ assert(0);
+ }
+ tprint("leaders ");
+ print_spec(glue_ptr(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(glue_ptr(p), NULL);
+ else
+ print_spec(glue_ptr(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) == acc_kern)
+ tprint(" (for 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 (width(p) != 0) {
+ tprint(", surrounded ");
+ print_scaled(width(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. */
+ tprint_esc("discretionary");
+ if (vlink(no_break(p)) != null) {
+ tprint(" replacing ");
+ node_list_display(vlink(no_break(p)));
+ }
+ node_list_display(vlink(pre_break(p))); /* recursive call */
+ append_char('|');
+ show_node_list(vlink(post_break(p)));
+ flush_char(); /* recursive call */
+ 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 (adjust_pre(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
+pointer actual_box_width(pointer r, scaled base_width)
+{
+ scaled w; /* calculated |size| */
+ pointer p; /* current node when calculating |pre_display_size| */
+ pointer q; /* glue specification when calculating |pre_display_size| */
+ scaled d; /* increment to |v| */
+ scaled v; /* |w| plus possible glue amount */
+ w = -max_dimen;
+ v = shift_amount(r) + base_width;
+ p = list_ptr(r);
+ 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 math_node:
+ d = surround(p);
+ break;
+ 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.
+ */
+ q = glue_ptr(p);
+ d = width(q);
+ if (glue_sign(r) == stretching) {
+ if ((glue_order(r) == stretch_order(q))
+ && (stretch(q) != 0))
+ v = max_dimen;
+ } else if (glue_sign(r) == shrinking) {
+ if ((glue_order(r) == shrink_order(q))
+ && (shrink(q) != 0))
+ v = max_dimen;
+ }
+ if (subtype(p) >= a_leaders)
+ goto found;
+ break;
+ case whatsit_node:
+ if ((subtype(p) == pdf_refxform_node)
+ || (subtype(p) == pdf_refximage_node))
+ d = width(p);
+ else
+ d = 0;
+ 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;
+}
+
+
+@ @c
+halfword tail_of_list(halfword p)
+{
+ halfword q = p;
+ while (vlink(q) != null)
+ q = vlink(q);
+ return q;
+}
+
+
+@ |delete_glue_ref| is called when a pointer to a glue
+ specification is being withdrawn.
+
+@c
+#define fast_delete_glue_ref(A) do { \
+ if (glue_ref_count(A)==null) { \
+ flush_node(A); \
+ } else { \
+ decr(glue_ref_count(A)); \
+ } \
+ } while (0)
+
+void delete_glue_ref(halfword p)
+{ /* |p| points to a glue specification */
+ assert(type(p) == glue_spec_node);
+ fast_delete_glue_ref(p);
+}
+
+@ @c
+int var_used;
+halfword temp_ptr; /* a pointer variable for occasional emergency use */
+
+
+@ 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; /* the new node */
+ p = new_node(hlist_node, min_quarterword);
+ box_dir(p) = text_direction;
+ 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(void)
+{
+ halfword p; /* the new node */
+ p = new_node(rule_node, 0); /* the |subtype| is not used */
+ 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, cur_lang, left_hyphen_min, right_hyphen_min);
+ 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;
+ w = char_width(font(p), character(p));
+ return w;
+}
+
+scaled glyph_height(halfword p)
+{
+ scaled w;
+ w = char_height(font(p), character(p)) + y_displace(p);
+ if (w < 0)
+ w = 0;
+ return w;
+}
+
+scaled glyph_depth(halfword p)
+{
+ scaled w;
+ 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; /* the new node */
+ p = new_node(disc_node, 0);
+ 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; /* the new node */
+ 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 p)
+{ /* duplicates a glue specification */
+ halfword q; /* the new spec */
+ q = copy_node(p);
+ glue_ref_count(q) = null;
+ return q;
+}
+
+@ 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; /* the new node */
+ halfword q; /* the glue specification */
+ p = new_node(glue_node, n + 1);
+ q = glue_par(n);
+ glue_ptr(p) = q;
+ incr(glue_ref_count(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; /* the new node */
+ p = new_node(glue_node, normal);
+ glue_ptr(p) = q;
+ incr(glue_ref_count(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; /* the new node */
+ temp_ptr = new_spec(glue_par(n));
+ p = new_glue(temp_ptr);
+ glue_ref_count(temp_ptr) = null;
+ subtype(p) = (quarterword) (n + 1);
+ 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; /* the new node */
+ 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)
+{
+ halfword p; /* the new node */
+ p = new_node(penalty_node, 0); /* the |subtype| is not used */
+ penalty(p) = m;
+ 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@>
diff --git a/Build/source/texk/web2c/luatexdir/tex/textoken.w b/Build/source/texk/web2c/luatexdir/tex/textoken.w index d120303ee66..8c12c6d8820 100644 --- a/Build/source/texk/web2c/luatexdir/tex/textoken.w +++ b/Build/source/texk/web2c/luatexdir/tex/textoken.w @@ -1,2413 +1,2412 @@ -% 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 -static const char _svn_version[] = - "$Id: textoken.w 4634 2013-04-21 14:45:45Z hhenkel $" - "$URL: https://foundry.supelec.fr/svn/luatex/branches/ex-glyph/source/texk/web2c/luatexdir/tex/textoken.w $"; - -#include "ptexlib.h" - -@ @c -#define pausing int_par(pausing_code) -#define cat_code_table int_par(cat_code_table_code) -#define tracing_nesting int_par(tracing_nesting_code) -#define end_line_char int_par(end_line_char_code) -#define suppress_outer_error int_par(suppress_outer_error_code) - -#define every_eof equiv(every_eof_loc) -#define box(A) equiv(box_base+(A)) - -#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(line_catcode_table,b); \ - else \ - a=get_cat_code(cat_code_table,b); \ - } 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. - -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. - -@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 */ - - -@ 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 */ - -halfword avail; /* head of the list of available one-word nodes */ -unsigned fix_mem_end; /* the last one-word node used in |mem| */ - -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| */ - -@ @c -void initialize_tokens(void) -{ - halfword p; - avail = null; - fix_mem_end = 0; - p = get_avail(); - temp_token_head = p; - set_token_info(temp_token_head, 0); - p = get_avail(); - hold_token_head = p; - set_token_info(hold_token_head, 0); - p = get_avail(); - omit_template = p; - set_token_info(omit_template, 0); - p = get_avail(); - null_list = p; - set_token_info(null_list, 0); - p = get_avail(); - backup_head = p; - set_token_info(backup_head, 0); - p = get_avail(); - garbage = p; - set_token_info(garbage, 0); - dyn_used = 0; /* initialize statistics */ -} - -@ 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@> - -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. - -@c -halfword get_avail(void) -{ /* single-word node allocation */ - unsigned p; /* the new node being got */ - unsigned t; - p = (unsigned) avail; /* get top location in the |avail| stack */ - if (p != null) { - avail = token_link(avail); /* and pop it off */ - } else if (fix_mem_end < fix_mem_max) { /* or go into virgin territory */ - incr(fix_mem_end); - p = fix_mem_end; - } else { - smemory_word *new_fixmem; /* the big dynamic storage area */ - t = (fix_mem_max / 5); - 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 */ - overflow("token memory size", fix_mem_max); - } else { - fixmem = new_fixmem; - } - memset(voidcast(fixmem + fix_mem_max + 1), 0, t * sizeof(smemory_word)); - 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 */ - return (halfword) p; -} - - -@ The procedure |flush_list(p)| frees an entire linked list of -one-word nodes that starts at position |p|. -@^inner loop@> - -@c -void flush_list(halfword p) -{ /* makes list of single-word nodes available */ - halfword q, r; /* list traversers */ - 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 */ - 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 -void print_meaning(void) -{ - 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 */ - if ((cur_cmd == top_bot_mark_cmd) && (cur_chr < marks_code)) { - print_char(':'); - print_ln(); - switch (cur_chr) { - case first_mark_code: - token_show(first_mark(0)); - break; - case bot_mark_code: - token_show(bot_mark(0)); - break; - case split_first_mark_code: - token_show(split_first_mark(0)); - break; - case split_bot_mark_code: - token_show(split_bot_mark(0)); - break; - default: - token_show(top_mark(0)); - break; - } - } - } -} - - -@ 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 -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; /* the highest parameter number, as an ASCII digit */ - match_chr = '#'; - n = '0'; - tally = 0; - if (l < 0) - l = 0x3FFFFFFF; - while ((p != null) && (tally < l)) { - if (p == q) { - /* Do magic computation */ - set_trick_count(); - } - /* Display token |p|, and |return| if there are problems */ - if ((p < (int) fix_mem_min) || (p > (int) fix_mem_end)) { - tprint_esc("CLOBBERED."); - return; - } - if (token_info(p) >= cs_token_flag) { - if (!((inhibit_par_tokens) && (token_info(p) == par_token))) - print_cs(token_info(p) - cs_token_flag); - } else { - m = token_cmd(token_info(p)); - c = token_chr(token_info(p)); - if (token_info(p) < 0) { - 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 - |out_param| commands. */ - switch (m) { - case left_brace_cmd: - case right_brace_cmd: - case math_shift_cmd: - case tab_mark_cmd: - case sup_mark_cmd: - case sub_mark_cmd: - case spacer_cmd: - case letter_cmd: - case other_char_cmd: - print(c); - break; - case mac_param_cmd: - if (!in_lua_escape) - print(c); - print(c); - break; - case out_param_cmd: - print(match_chr); - if (c <= 9) { - print_char(c + '0'); - } else { - print_char('!'); - return; - } - break; - case match_cmd: - match_chr = c; - print(c); - incr(n); - print_char(n); - if (n > '9') - return; - break; - case end_match_cmd: - if (c == 0) - tprint("->"); - break; - default: - tprint_esc("BAD."); - break; - } - } - } - p = token_link(p); - } - if (p != null) - 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. - -@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@> - -@c -void delete_token_ref(halfword p) -{ /* |p| points to the reference count - of a token list that is losing one reference */ - assert(token_ref_count(p) >= 0); - if (token_ref_count(p) == 0) - flush_list(p); - else - decr(token_ref_count(p)); -} - -@ @c -int get_char_cat_code(int curchr) -{ - int a; - do_get_cat_code(a,curchr); - return a; -} - -@ @c -static void invalid_character_error(void) -{ - const char *hlp[] = - { "A funny symbol that I can't read has just been input.", - "Continue, and I'll forget that it ever happened.", - NULL - }; - deletions_allowed = false; - tex_error("Text line contains an invalid character", hlp); - deletions_allowed = true; -} - -@ @c -static boolean process_sup_mark(void); /* below */ - -static int scan_control_sequence(void); /* below */ - -typedef enum { next_line_ok, next_line_return, - next_line_restart -} next_line_retval; - -static next_line_retval next_line(void); /* below */ - - -@ 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.). - @^inner loop@> - -@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| */ - halfword save_cur_cs = cur_cs; - int saved_align_state = align_state; - assert (strlen(s) > 1); - p = backup_head; - token_link(p) = null; - k = s; - while (*k) { - get_x_token(); /* recursion is possible here */ - 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)) { - 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); - if (cur_cmd != endv_cmd) - align_state = saved_align_state; - } else { - back_input(); - } - cur_cs = save_cur_cs; - return false; - } - } - flush_list(token_link(backup_head)); - cur_cs = save_cur_cs; - if (cur_cmd != endv_cmd) - align_state = saved_align_state; - return true; -} - -@ We can not return |undefined_control_sequence| under some conditions - (inside |shift_case|, for example). This needs thinking. - -@c -halfword active_to_cs(int curchr, int force) -{ - halfword curcs; - char *a, *b; - char *utfbytes = xmalloc(10); - 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; -} - -@ TODO this function should listen to \.{\\escapechar} - -@c -static char *cs_to_string(halfword p) -{ /* prints a control sequence */ - const char *s; - char *sh; - int k = 0; - static char ret[256] = { 0 }; - if (p == 0 || p == null_cs) { - ret[k++] = '\\'; - s = "csname"; - while (*s) { - ret[k++] = *s++; - } - ret[k++] = '\\'; - s = "endcsname"; - while (*s) { - ret[k++] = *s++; - } - ret[k] = 0; - - } else { - str_number txt = cs_text(p); - sh = makecstring(txt); - s = sh; - if (is_active_cs(txt)) { - s = s + 3; - while (*s) { - ret[k++] = *s++; - } - ret[k] = 0; - } else { - ret[k++] = '\\'; - while (*s) { - ret[k++] = *s++; - } - ret[k] = 0; - } - free(sh); - } - return (char *) ret; -} - -@ TODO this is a quick hack, will be solved differently soon - -@c -static char *cmd_chr_to_string(int cmd, int chr) -{ - char *s; - str_number str; - int sel = selector; - selector = new_string; - print_cmd_chr((quarterword) cmd, chr); - str = make_string(); - s = makecstring(str); - selector = sel; - flush_str(str); - 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 -void firm_up_the_line(void) -{ - int k; /* an index into |buffer| */ - ilimit = last; - if (pausing > 0) { - if (interaction > nonstop_mode) { - wake_up_terminal(); - print_ln(); - if (istart < ilimit) { - for (k = istart; k <= ilimit - 1; k++) - print_char(buffer[k]); - } - first = ilimit; - prompt_input("=>"); /* wait for user response */ - if (last > first) { - for (k = first; k < +last - 1; k++) /* move line down in buffer */ - buffer[k + istart - first] = buffer[k]; - ilimit = istart + last - first; - } - } - } -} - - - -@ 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 */ - if (suppress_outer_error) - 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. */ - 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 */ - } - cur_cmd = spacer_cmd; - cur_chr = ' '; /* replace it by a space */ - } - if (scanner_status > skipping) { - const char *errhlp[] = - { "I suspect you have forgotten a `}', causing me", - "to read past where you wanted me to stop.", - "I'll try to recover; but if the error is serious,", - "you'd better type `E' or `X' now and fix your file.", - NULL - }; - char errmsg[256]; - const char *startmsg; - const char *scannermsg; - /* Tell the user what has run away and try to recover */ - runaway(); /* print a definition, argument, or preamble */ - 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}. */ - 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 */ - begin_token_list(p, inserted); - snprintf(errmsg, 255, "%s while scanning %s of %s", - startmsg, scannermsg, cs_to_string(warning_index)); - tex_error(errmsg, errhlp); - } else { - char errmsg[256]; - const char *errhlp_no[] = - { "The file ended while I was skipping conditional text.", - "This kind of error happens when you say `\\if...' and forget", - "the matching `\\fi'. I've inserted a `\\fi'; this might work.", - NULL - }; - const char *errhlp_cs[] = - { "A forbidden control sequence occurred in skipped text.", - "This kind of error happens when you say `\\if...' and forget", - "the matching `\\fi'. I've inserted a `\\fi'; this might work.", - NULL - }; - const char **errhlp = (const char **) errhlp_no; - char *ss; - if (cur_cs != 0) { - errhlp = errhlp_cs; - cur_cs = 0; - } - ss = cmd_chr_to_string(if_test_cmd, cur_if); - snprintf(errmsg, 255, - "Incomplete %s; all text was ignored after line %d", - ss, (int) skip_line); - free(ss); - /* Incomplete \\if... */ - cur_tok = cs_token_flag + frozen_fi; - /* back up one inserted token and call |error| */ - { - OK_to_interrupt = false; - back_input(); - token_type = inserted; - OK_to_interrupt = true; - tex_error(errmsg, errhlp); - } - } - deletions_allowed = true; - } -} - -@ @c -static boolean get_next_file(void) -{ - SWITCH: - if (iloc <= ilimit) { /* 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); - } - /* - 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. - */ - switch (istate + cur_cmd) { - case mid_line + ignore_cmd: - case skip_blanks + ignore_cmd: - case new_line + ignore_cmd: - case skip_blanks + spacer_cmd: - case new_line + spacer_cmd: /* 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 ...; */ - istate = (unsigned char) scan_control_sequence(); - if (cur_cmd >= outer_call_cmd) - check_outer_validity(); - break; - case mid_line + active_char_cmd: - case new_line + active_char_cmd: - case skip_blanks + active_char_cmd: /* Process an active-character */ - cur_cs = active_to_cs(cur_chr, false); - cur_cmd = eq_type(cur_cs); - cur_chr = equiv(cur_cs); - istate = mid_line; - if (cur_cmd >= outer_call_cmd) - check_outer_validity(); - break; - case mid_line + sup_mark_cmd: - case new_line + sup_mark_cmd: - case skip_blanks + sup_mark_cmd: /* If this |sup_mark| starts */ - if (process_sup_mark()) - goto RESWITCH; - else - istate = mid_line; - break; - 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|; */ - invalid_character_error(); - return false; /* because state may be |token_list| now */ - break; - case mid_line + spacer_cmd: /* 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. - */ - iloc = ilimit + 1; - cur_cmd = spacer_cmd; - cur_chr = ' '; - break; - case skip_blanks + car_ret_cmd: - case mid_line + comment_cmd: - case new_line + comment_cmd: - case skip_blanks + comment_cmd: /* Finish line, |goto switch|; */ - iloc = ilimit + 1; - goto SWITCH; - break; - case new_line + car_ret_cmd: /* Finish line, emit a \.{\\par}; */ - iloc = ilimit + 1; - cur_cs = par_loc; - cur_cmd = eq_type(cur_cs); - cur_chr = equiv(cur_cs); - if (cur_cmd >= outer_call_cmd) - check_outer_validity(); - break; - case skip_blanks + left_brace_cmd: - case new_line + left_brace_cmd: - istate = mid_line; /* 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 */ - case mid_line + right_brace_cmd: - align_state--; - break; - case mid_line + math_shift_cmd: - case mid_line + tab_mark_cmd: - case mid_line + mac_param_cmd: - case mid_line + sub_mark_cmd: - case mid_line + letter_cmd: - case mid_line + other_char_cmd: - break; -#if 0 - case skip_blanks + math_shift: - case skip_blanks + tab_mark: - case skip_blanks + mac_param: - case skip_blanks + sub_mark: - case skip_blanks + letter: - case skip_blanks + other_char: - case new_line + math_shift: - case new_line + tab_mark: - case new_line + mac_param: - case new_line + sub_mark: - case new_line + letter: - case new_line + other_char: -#else - default: -#endif - istate = mid_line; - break; - } - } else { - 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; - */ - do { - next_line_retval r = next_line(); - if (r == next_line_return) { - return true; - } else if (r == next_line_restart) { - return false; - } - } while (0); - check_interrupt(); - goto SWITCH; - } - return true; -} - -@ @c -#define is_hex(a) ((a>='0'&&a<='9')||(a>='a'&&a<='f')) - -#define add_nybble(a) do { \ - if (a<='9') cur_chr=(cur_chr<<4)+a-'0'; \ - else cur_chr=(cur_chr<<4)+a-'a'+10; \ - } while (0) - -#define hex_to_cur_chr do { \ - if (c<='9') cur_chr=c-'0'; \ - else cur_chr=c-'a'+10; \ - add_nybble(cc); \ - } while (0) - -#define four_hex_to_cur_chr do { \ - hex_to_cur_chr; \ - add_nybble(ccc); add_nybble(cccc); \ - } while (0) - -#define five_hex_to_cur_chr do { \ - four_hex_to_cur_chr; \ - add_nybble(ccccc); \ - } while (0) - -#define six_hex_to_cur_chr do { \ - five_hex_to_cur_chr; \ - add_nybble(cccccc); \ - } while (0) - - -@ Notice that a code like \.{\^\^8} becomes \.x if not followed by a hex digit. - -@c -static boolean process_sup_mark(void) -{ - if (cur_chr == buffer[iloc]) { - int c, cc; - if (iloc < ilimit) { - if ((cur_chr == buffer[iloc + 1]) && (cur_chr == buffer[iloc + 2]) - && (cur_chr == buffer[iloc + 3]) - && (cur_chr == buffer[iloc + 4]) - && ((iloc + 10) <= ilimit)) { - int ccc, cccc, ccccc, cccccc; /* constituents of a possible expanded code */ - c = buffer[iloc + 5]; - cc = buffer[iloc + 6]; - ccc = buffer[iloc + 7]; - cccc = buffer[iloc + 8]; - ccccc = buffer[iloc + 9]; - cccccc = buffer[iloc + 10]; - if ((is_hex(c)) && (is_hex(cc)) && (is_hex(ccc)) - && (is_hex(cccc)) - && (is_hex(ccccc)) && (is_hex(cccccc))) { - iloc = iloc + 11; - six_hex_to_cur_chr; - return true; - } - } - if ((cur_chr == buffer[iloc + 1]) && (cur_chr == buffer[iloc + 2]) - && (cur_chr == buffer[iloc + 3]) && ((iloc + 8) <= ilimit)) { - int ccc, cccc, ccccc; /* constituents of a possible expanded code */ - c = buffer[iloc + 4]; - cc = buffer[iloc + 5]; - ccc = buffer[iloc + 6]; - cccc = buffer[iloc + 7]; - ccccc = buffer[iloc + 8]; - if ((is_hex(c)) && (is_hex(cc)) && (is_hex(ccc)) - && (is_hex(cccc)) && (is_hex(ccccc))) { - iloc = iloc + 9; - five_hex_to_cur_chr; - return true; - } - } - if ((cur_chr == buffer[iloc + 1]) && (cur_chr == buffer[iloc + 2]) - && ((iloc + 6) <= ilimit)) { - int ccc, cccc; /* constituents of a possible expanded code */ - c = buffer[iloc + 3]; - cc = buffer[iloc + 4]; - ccc = buffer[iloc + 5]; - cccc = buffer[iloc + 6]; - if ((is_hex(c)) && (is_hex(cc)) && (is_hex(ccc)) - && (is_hex(cccc))) { - iloc = iloc + 7; - four_hex_to_cur_chr; - return true; - } - } - c = buffer[iloc + 1]; - if (c < 0200) { /* yes we have an expanded char */ - iloc = iloc + 2; - if (is_hex(c) && iloc <= ilimit) { - cc = buffer[iloc]; - if (is_hex(cc)) { - incr(iloc); - hex_to_cur_chr; - return true; - } - } - cur_chr = (c < 0100 ? c + 0100 : c - 0100); - return true; - } - } - } - 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. - - 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. - -@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 */ - } else { - register int cat; /* |cat_code(cur_chr)|, usually */ - 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...; */ - continue; - } else { - retval = skip_blanks; - do { - 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...; */ - continue; - if (cat != letter_cmd) { - decr(k); - if (cur_chr > 0xFFFF) - decr(k); - if (cur_chr > 0x7FF) - decr(k); - if (cur_chr > 0x7F) - decr(k); - } /* now |k| points to first nonletter */ - } - cur_cs = id_lookup(iloc, k - iloc); - iloc = k; - break; - } - } - cur_cmd = eq_type(cur_cs); - cur_chr = equiv(cur_cs); - 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. - -@c -static boolean check_expanded_code(int *kk) -{ - int l; - int k = *kk; - int d = 1; /* number of excess characters in an expanded code */ - int c, cc, ccc, cccc, ccccc, cccccc; /* constituents of a possible expanded code */ - if (buffer[k] == cur_chr && k < ilimit) { - if ((cur_chr == buffer[k + 1]) && (cur_chr == buffer[k + 2]) - && ((k + 6) <= ilimit)) { - d = 4; - if ((cur_chr == buffer[k + 3]) && ((k + 8) <= ilimit)) - d = 5; - if ((cur_chr == buffer[k + 4]) && ((k + 10) <= ilimit)) - d = 6; - c = buffer[k + d - 1]; - cc = buffer[k + d]; - ccc = buffer[k + d + 1]; - cccc = buffer[k + d + 2]; - if (d == 6) { - ccccc = buffer[k + d + 3]; - cccccc = buffer[k + d + 4]; - if (is_hex(c) && is_hex(cc) && is_hex(ccc) && is_hex(cccc) - && is_hex(ccccc) && is_hex(cccccc)) - six_hex_to_cur_chr; - } else if (d == 5) { - ccccc = buffer[k + d + 3]; - if (is_hex(c) && is_hex(cc) && is_hex(ccc) && is_hex(cccc) - && is_hex(ccccc)) - five_hex_to_cur_chr; - } else { - if (is_hex(c) && is_hex(cc) && is_hex(ccc) && is_hex(cccc)) - four_hex_to_cur_chr; - } - } else { - c = buffer[k + 1]; - if (c < 0200) { - d = 1; - if (is_hex(c) && (k + 2) <= ilimit) { - cc = buffer[k + 2]; - if (is_hex(c) && is_hex(cc)) { - d = 2; - hex_to_cur_chr; - } - } else if (c < 0100) { - cur_chr = c + 0100; - } else { - cur_chr = c - 0100; - } - } - } - if (d > 2) - d = 2 * d - 1; - else - d++; - if (cur_chr <= 0x7F) { - buffer[k - 1] = (packed_ASCII_code) cur_chr; - } else if (cur_chr <= 0x7FF) { - buffer[k - 1] = (packed_ASCII_code) (0xC0 + cur_chr / 0x40); - k++; - d--; - buffer[k - 1] = (packed_ASCII_code) (0x80 + cur_chr % 0x40); - } else if (cur_chr <= 0xFFFF) { - buffer[k - 1] = (packed_ASCII_code) (0xE0 + cur_chr / 0x1000); - k++; - d--; - buffer[k - 1] = - (packed_ASCII_code) (0x80 + (cur_chr % 0x1000) / 0x40); - k++; - d--; - buffer[k - 1] = - (packed_ASCII_code) (0x80 + (cur_chr % 0x1000) % 0x40); - } else { - buffer[k - 1] = (packed_ASCII_code) (0xF0 + cur_chr / 0x40000); - k++; - d--; - buffer[k - 1] = - (packed_ASCII_code) (0x80 + (cur_chr % 0x40000) / 0x1000); - k++; - d--; - buffer[k - 1] = - (packed_ASCII_code) (0x80 + - ((cur_chr % 0x40000) % 0x1000) / 0x40); - k++; - d--; - buffer[k - 1] = - (packed_ASCII_code) (0x80 + - ((cur_chr % 0x40000) % 0x1000) % 0x40); - } - l = k; - ilimit = ilimit - d; - while (l <= ilimit) { - buffer[l] = buffer[l + d]; - l++; - } - *kk = k; - return true; - } - return false; -} - -@ todo: this is a function because it is still used from the converted pascal. - once that is gone, it can be a \#define again - -@c -boolean end_line_char_inactive(void) -{ - return ((end_line_char < 0) || (end_line_char > 127)); -} - -@ All of the easy branches of |get_next| have now been taken care of. - There is one more branch. - -@c -static next_line_retval next_line(void) -{ - boolean inhibit_eol = false; /* a way to end a pseudo file without trailing space */ - if (iname > 17) { - /* 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| */ - line_catcode_table = DEFAULT_CAT_TABLE; - if ((iname == 19) && (pseudo_lines(pseudo_files) == null)) - inhibit_eol = true; - } else if ((every_eof != null) && !eof_seen[iindex]) { - ilimit = first - 1; - eof_seen[iindex] = true; /* fake one empty line */ - if (iname != 19) - begin_token_list(every_eof, every_eof_text); - return next_line_restart; - } else { - force_eof = true; - } - } 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; - } - } 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 != null) && (!eof_seen[iindex])) { - ilimit = first - 1; - eof_seen[iindex] = true; /* fake one empty line */ - begin_token_list(every_eof, every_eof_text); - return next_line_restart; - } else { - force_eof = true; - } - } - } - } - if (force_eof) { - if (tracing_nesting > 0) - if ((grp_stack[in_open] != cur_boundary) - || (if_stack[in_open] != cond_ptr)) - if (!((iname == 19) || (iname == 21))) - file_warning(); /* give warning for some unfinished groups and/or conditionals */ - if ((iname > 21) || (iname == 20)) { - if (tracefilenames) - print_char(')'); - open_parens--; -#if 0 - update_terminal(); /* show user that file has been read */ -#endif - } - force_eof = false; - if (iname == 21 || /* lua input */ - iname == 19) { /* \.{\\scantextokens} */ - end_file_reading(); - } else { - end_file_reading(); - check_outer_validity(); - } - return next_line_restart; - } - if (inhibit_eol || end_line_char_inactive()) - ilimit--; - else - buffer[ilimit] = (packed_ASCII_code) end_line_char; - first = ilimit + 1; - iloc = istart; /* ready to read */ - } else { - if (!terminal_input) { /* \.{\\read} line has ended */ - cur_cmd = 0; - cur_chr = 0; - return next_line_return; /* OUTER */ - } - if (input_ptr > 0) { /* text was inserted during error recovery */ - end_file_reading(); - return next_line_restart; /* resume previous level */ - } - if (selector < log_only) - open_log_file(); - if (interaction > nonstop_mode) { - if (end_line_char_inactive()) - ilimit++; - if (ilimit == istart) { /* previous line was empty */ - tprint_nl("(Please type a command or say `\\end')"); - } - print_ln(); - first = istart; - prompt_input("*"); /* input on-line into |buffer| */ - ilimit = last; - if (end_line_char_inactive()) - ilimit--; - else - buffer[ilimit] = (packed_ASCII_code) end_line_char; - first = ilimit + 1; - iloc = istart; - } else { - fatal_error("*** (job aborted, no legal \\end found)"); - /* nonstop mode, which is intended for overnight batch processing, - never waits for on-line input */ - } - } - return next_line_ok; -} - -@ 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; /* a token */ - t = token_info(iloc); - iloc = token_link(iloc); /* move to next */ - if (t >= cs_token_flag) { /* 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|. - */ - cur_cs = token_info(iloc) - cs_token_flag; - iloc = null; - cur_cmd = eq_type(cur_cs); - if (cur_cmd > max_command_cmd) { - cur_cmd = relax_cmd; - cur_chr = no_expand_flag; - return true; - } - } else { - check_outer_validity(); - } - } - cur_chr = equiv(cur_cs); - } else { - cur_cmd = token_cmd(t); - cur_chr = token_chr(t); - switch (cur_cmd) { - case left_brace_cmd: - align_state++; - break; - case right_brace_cmd: - align_state--; - break; - case out_param_cmd: /* Insert macro parameter and |goto restart|; */ - begin_token_list(param_stack[param_start + cur_chr - 1], parameter); - return false; - break; - } - } - 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@> - -@ 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 */ - if (!get_next_file()) - goto RESTART; - } else { - if (iloc == null) { - end_token_list(); - goto RESTART; /* list exhausted, resume previous level */ - } else if (!get_next_tokenlist()) { - goto RESTART; /* parameter needs to be expanded */ - } - } - /* 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|. - -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. - -@c -void get_token(void) -{ /* sets |cur_cmd|, |cur_chr|, |cur_tok| */ - no_new_control_sequence = false; - get_token_lua(); - no_new_control_sequence = true; - if (cur_cs == 0) - cur_tok = token_val(cur_cmd, cur_chr); - else - cur_tok = cs_token_flag + cur_cs; -} - -@ @c -void get_token_lua(void) -{ - register int callback_id; - callback_id = callback_defined(token_filter_callback); - if (callback_id > 0) { - while (istate == token_list && iloc == null && iindex != v_template) - end_token_list(); - /* there is some stuff we don't want to see inside the callback */ - if (!(istate == token_list && - ((nofilter == true) || (iindex == backed_up && iloc != null)))) { - do_get_token_lua(callback_id); - return; - } - } - get_next(); -} - - -@ changes the string |s| to a token list -@c -halfword string_to_toks(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 */ - char *s = ss, *se = ss + strlen(s); - p = temp_token_head; - set_token_link(p, null); - while (s < se) { - t = (halfword) str2uni((unsigned char *) s); - s += utf8_size(t); - if (t == ' ') - t = space_token; - else - t = other_token + t; - fast_store_new_token(t); - } - 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|. - -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 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.) - -|lua_str_toks| is almost identical, but it also escapes the three -symbols that |lua| considers special while scanning a literal string - -@c -static halfword lua_str_toks(lstring b) -{ /* 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; /* index into string */ - p = temp_token_head; - set_token_link(p, null); - k = (unsigned char *) b.s; - while (k < (unsigned char *) b.s + b.l) { - t = pool_to_unichar(k); - k += utf8_size(t); - if (t == ' ') { - t = space_token; - } else { - if ((t == '\\') || (t == '"') || (t == '\'') || (t == 10) - || (t == 13)) - fast_store_new_token(other_token + '\\'); - if (t == 10) - t = 'n'; - if (t == 13) - t = 'r'; - t = other_token + t; - } - fast_store_new_token(t); - } - return p; -} - - -@ Incidentally, the main reason for wanting |str_toks| is the function |the_toks|, -which has similar input/output characteristics. - -@c -halfword str_toks(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 */ - p = temp_token_head; - set_token_link(p, null); - k = s.s; - l = k + s.l; - while (k < l) { - t = pool_to_unichar(k); - k += utf8_size(t); - if (t == ' ') - t = space_token; - else - t = other_token + t; - fast_store_new_token(t); - } - return p; -} - -@ 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)); -} - -@ 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); - } -} - -@ 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 -static boolean print_convert_string(halfword c, int i) -{ - int ff; /* for use with |set_ff| */ - boolean ret = true; - switch (c) { - case number_code: - print_int(i); - break; - case uchar_code: - print(i); - break; - case roman_numeral_code: - print_roman_int(i); - break; - case etex_code: - tprint(eTeX_version_string); - break; - case pdftex_revision_code: - tprint(pdftex_revision); - break; - case luatex_revision_code: - print(get_luatexrevision()); - break; - case luatex_date_code: - print_int(get_luatex_date_info()); - break; - case pdftex_banner_code: - tprint(pdftex_banner); - break; - case uniform_deviate_code: - print_int(unif_rand(i)); - break; - case normal_deviate_code: - print_int(norm_rand()); - break; - case format_name_code: - print(format_name); - break; - case job_name_code: - print_job_name(); - break; - case font_name_code: - append_string((unsigned char *) font_name(i), - (unsigned) strlen(font_name(i))); - if (font_size(i) != font_dsize(i)) { - tprint(" at "); - print_scaled(font_size(i)); - tprint("pt"); - } - break; - case font_id_code: - print_int(i); - break; - case math_style_code: - print_math_style(); - break; - case pdf_font_name_code: - case pdf_font_objnum_code: - set_ff(i); - if (c == pdf_font_name_code) - print_int(obj_info(static_pdf, pdf_font_num(ff))); - else - print_int(pdf_font_num(ff)); - break; - case pdf_font_size_code: - print_scaled(font_size(i)); - tprint("pt"); - break; - case pdf_page_ref_code: - print_int(pdf_get_obj(static_pdf, obj_type_page, i, false)); - break; - case pdf_xform_name_code: - print_int(obj_info(static_pdf, i)); - break; - case eTeX_revision_code: - tprint(eTeX_revision); - break; - default: - ret = false; - break; - } - return ret; -} - -@ @c -int scan_lua_state(void) -{ - int sn = 0; - if (scan_keyword("name")) { - scan_pdf_ext_toks(); - sn = def_ref; - } - /* Parse optional lua state integer, or an instance name to be stored in |sn| */ - /* Get the next non-blank non-relax non-call token */ - do { - get_x_token(); - } while ((cur_cmd == spacer_cmd) || (cur_cmd == relax_cmd)); - - back_input(); /* have to push it back, whatever it is */ - if (cur_cmd != left_brace_cmd) { - scan_register_num(); - if (get_lua_name(cur_val)) - sn = (cur_val - 65536); - } - 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}'. - -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 -void conv_toks(void) -{ - int old_setting; /* holds |selector| setting */ - halfword p, q; - int save_scanner_status; /* |scanner_status| upon entry */ - halfword save_def_ref; /* |def_ref| upon entry, important if inside `\.{\\message}' */ - 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 i = 0; /* first temp integer */ - int j = 0; /* second temp integer */ - int c = cur_chr; /* desired type of conversion */ - str_number str; - /* Scan the argument for command |c| */ - switch (c) { - case uchar_code: - scan_char_num(); - break; - case number_code: - case roman_numeral_code: - scan_int(); - break; - case string_code: - case meaning_code: - save_scanner_status = scanner_status; - scanner_status = normal; - get_token(); - scanner_status = save_scanner_status; - break; - case etex_code: - break; - case font_name_code: - case font_id_code: - scan_font_ident(); - break; - case pdftex_revision_code: - case luatex_revision_code: - case luatex_date_code: - case pdftex_banner_code: - break; - case pdf_font_name_code: - case pdf_font_objnum_code: - case pdf_font_size_code: - scan_font_ident(); - if (cur_val == null_font) - pdf_error("font", "invalid font identifier"); - if (c != pdf_font_size_code) { - pdf_check_vf(cur_val); - if (!font_used(cur_val)) - pdf_init_font(static_pdf, cur_val); - } - break; - case pdf_page_ref_code: - scan_int(); - if (cur_val <= 0) - pdf_error("pageref", "invalid page number"); - break; - case left_margin_kern_code: - case right_margin_kern_code: - scan_int(); - if ((box(cur_val) == null) || (type(box(cur_val)) != hlist_node)) - pdf_error("marginkern", "a non-empty hbox expected"); - break; - case pdf_xform_name_code: - scan_int(); - check_obj_type(static_pdf, obj_type_xform, cur_val); - break; - case pdf_creation_date_code: - ins_list(string_to_toks(getcreationdate(static_pdf))); - return; - break; - case format_name_code: - case job_name_code: - if (job_name == 0) - open_log_file(); - break; - case pdf_colorstack_init_code: - bool = scan_keyword("page"); - if (scan_keyword("direct")) - cur_val = direct_always; - else if (scan_keyword("page")) - cur_val = direct_page; - else - cur_val = set_origin; - save_scanner_status = scanner_status; - save_warning_index = warning_index; - save_def_ref = def_ref; - u = save_cur_string(); - scan_pdf_ext_toks(); - s = tokens_to_string(def_ref); - delete_token_ref(def_ref); - def_ref = save_def_ref; - warning_index = save_warning_index; - scanner_status = save_scanner_status; - cur_val = newcolorstack(s, cur_val, bool); - flush_str(s); - cur_val_level = int_val_level; - if (cur_val < 0) { - print_err("Too many color stacks"); - help2("The number of color stacks is limited to 32768.", - "I'll use the default color stack 0 here."); - error(); - cur_val = 0; - restore_cur_string(u); - } - break; - case uniform_deviate_code: - scan_int(); - break; - case normal_deviate_code: - break; - case lua_escape_string_code: - { - lstring escstr; - int l = 0; - save_scanner_status = scanner_status; - save_def_ref = def_ref; - save_warning_index = warning_index; - scan_pdf_ext_toks(); - bool = in_lua_escape; - in_lua_escape = true; - escstr.s = (unsigned char *) tokenlist_to_cstring(def_ref, false, &l); - escstr.l = (unsigned) l; - in_lua_escape = bool; - delete_token_ref(def_ref); - def_ref = save_def_ref; - warning_index = save_warning_index; - scanner_status = save_scanner_status; - (void) lua_str_toks(escstr); - ins_list(token_link(temp_token_head)); - free(escstr.s); - return; - } - break; - case math_style_code: - break; - case expanded_code: - save_scanner_status = scanner_status; - save_warning_index = warning_index; - save_def_ref = def_ref; - u = save_cur_string(); - scan_pdf_ext_toks(); - warning_index = save_warning_index; - scanner_status = save_scanner_status; - ins_list(token_link(def_ref)); - def_ref = save_def_ref; - restore_cur_string(u); - return; - break; - case lua_code: - u = save_cur_string(); - save_scanner_status = scanner_status; - save_def_ref = def_ref; - save_warning_index = warning_index; - sn = scan_lua_state(); - scan_pdf_ext_toks(); - s = def_ref; - warning_index = save_warning_index; - def_ref = save_def_ref; - scanner_status = save_scanner_status; - luacstrings = 0; - luatokencall(s, sn); - delete_token_ref(s); - restore_cur_string(u); /* TODO: check this, was different */ - if (luacstrings > 0) - lua_string_start(); - return; - break; - case pdf_insert_ht_code: - scan_register_num(); - break; - case pdf_ximage_bbox_code: - scan_int(); - check_obj_type(static_pdf, obj_type_ximage, cur_val); - i = obj_data_ptr(static_pdf, cur_val); - scan_int(); - j = cur_val; - if ((j < 1) || (j > 4)) - pdf_error("pdfximagebbox", "invalid parameter"); - break; - /* Cases of 'Scan the argument for command |c|' */ - case eTeX_revision_code: - break; - default: - confusion("convert"); - break; - } - - old_setting = selector; - selector = new_string; - - /* Print the result of command |c| */ - if (!print_convert_string(c, cur_val)) { - switch (c) { - case string_code: - if (cur_cs != 0) - sprint_cs(cur_cs); - else - print(cur_chr); - break; - case meaning_code: - print_meaning(); - break; - case left_margin_kern_code: - p = list_ptr(box(cur_val)); - if ((p != null) && (!is_char_node(p)) && - (type(p) == glue_node) && (subtype(p) == left_skip_code + 1)) - p = vlink(p); - if ((p != null) && (!is_char_node(p)) && - (type(p) == margin_kern_node) && (subtype(p) == left_side)) - print_scaled(width(p)); - else - print_char('0'); - tprint("pt"); - break; - case right_margin_kern_code: - q = list_ptr(box(cur_val)); - p = null; - if (q != null) { - p = prev_rightmost(q, null); - if ((p != null) && (!is_char_node(p)) && (type(p) == glue_node) - && (subtype(p) == right_skip_code + 1)) - p = prev_rightmost(q, p); - } - if ((p != null) && (!is_char_node(p)) && - (type(p) == margin_kern_node) && (subtype(p) == right_side)) - print_scaled(width(p)); - else - print_char('0'); - tprint("pt"); - break; - case pdf_colorstack_init_code: - print_int(cur_val); - break; - case pdf_insert_ht_code: - i = cur_val; - p = page_ins_head; - while (i >= subtype(vlink(p))) - p = vlink(p); - if (subtype(p) == i) - print_scaled(height(p)); - else - print_char('0'); - tprint("pt"); - break; - case pdf_ximage_bbox_code: - if (is_pdf_image(i)) { - switch (j) { - case 1: - print_scaled(epdf_orig_x(i)); - break; - case 2: - print_scaled(epdf_orig_y(i)); - break; - case 3: - print_scaled(epdf_orig_x(i) + epdf_xsize(i)); - break; - case 4: - print_scaled(epdf_orig_y(i) + epdf_ysize(i)); - break; - } - } else { - print_scaled(0); - } - tprint("pt"); - break; - case pdf_creation_date_code: - case lua_escape_string_code: - case lua_code: - case expanded_code: - break; - default: - confusion("convert"); - break; - } - } - - selector = old_setting; - str = make_string(); - (void) str_toks(str_lstring(str)); - flush_str(str); - ins_list(token_link(temp_token_head)); -} - -@ This boolean is keeping track of the lua string escape state -@c -boolean in_lua_escape; - -@ probably not needed anymore -@c -boolean is_convert(halfword c) -{ - return (c == convert_cmd); -} - -str_number the_convert_string(halfword c, int i) -{ - int old_setting; /* saved |selector| setting */ - str_number ret = 0; - old_setting = selector; - selector = new_string; - if (print_convert_string(c, i)) { - ret = make_string(); - } else if (c == font_identifier_code) { - print_font_identifier(i); - ret = make_string(); - } - selector = old_setting; - 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. - -@c -FILE *read_file[16]; /* used for \.{\\read} */ -int read_open[17]; /* state of |read_file[n]| */ - -void initialize_read(void) -{ - int k; - for (k = 0; k <= 16; k++) - 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. - -@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 */ - 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 */ - 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. */ - do { - /* 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 */ - /* 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) { - prompt_input(""); - } else { - wake_up_terminal(); - print_ln(); - sprint_cs(r); - prompt_input(" ="); - n = -1; - } - } else { - fatal_error - ("*** (cannot \\read from terminal in nonstop modes)"); - } - - } else if (read_open[m] == just_open) { - /* 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|. */ - if (lua_input_ln(read_file[m], (m + 1), false)) { - read_open[m] = normal; - } else { - lua_a_close_in(read_file[m], (m + 1)); - read_open[m] = closed; - } - - } else { - /* Input the next line of |read_file[m]| */ - /* 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)); - read_open[m] = closed; - if (align_state != 1000000) { - runaway(); - print_err("File ended within \\read"); - help1("This \\read has unbalanced braces."); - align_state = 1000000; - error(); - } - } - - } - ilimit = last; - if (end_line_char_inactive()) - decr(ilimit); - else - buffer[ilimit] = (packed_ASCII_code) int_par(end_line_char_code); - first = ilimit + 1; - iloc = istart; - istate = new_line; - /* Handle \.{\\readline} and |goto done|; */ - if (j == 1) { - while (iloc <= ilimit) { /* current line not yet finished */ - cur_chr = buffer[iloc]; - incr(iloc); - if (cur_chr == ' ') - cur_tok = space_token; - else - cur_tok = cur_chr + other_token; - store_new_token(cur_tok); - } - } else { - while (1) { - get_token(); - if (cur_tok == 0) - break; /* |cur_cmd=cur_chr=0| will occur at the end of the line */ - if (align_state < 1000000) { /* unmatched `\.\}' aborts the line */ - do { - get_token(); - } while (cur_tok != 0); - align_state = 1000000; - break; - } - store_new_token(cur_tok); - } - } - end_file_reading(); - - } while (align_state != 1000000); - cur_val = def_ref; - scanner_status = normal; - align_state = s; -} - -@ @c -str_number tokens_to_string(halfword p) -{ /* return a string from tokens list */ - int old_setting; - if (selector == new_string) - pdf_error("tokens", - "tokens_to_string() called while selector = new_string"); - old_setting = selector; - selector = new_string; - show_token_list(token_link(p), null, -1); - selector = old_setting; - return make_string(); -} - -@ @c -#define make_room(a) \ - if ((unsigned)i+a+1>alloci) { \ - ret = xrealloc(ret,(alloci+64)); \ - alloci = alloci + 64; \ - } - - -#define append_i_byte(a) ret[i++] = (char)(a) - -#define Print_char(a) make_room(1); append_i_byte(a) - -#define Print_uchar(s) { \ - make_room(4); \ - if (s<=0x7F) { \ - append_i_byte(s); \ - } else if (s<=0x7FF) { \ - append_i_byte(0xC0 + (s / 0x40)); \ - append_i_byte(0x80 + (s % 0x40)); \ - } else if (s<=0xFFFF) { \ - append_i_byte(0xE0 + (s / 0x1000)); \ - append_i_byte(0x80 + ((s % 0x1000) / 0x40)); \ - append_i_byte(0x80 + ((s % 0x1000) % 0x40)); \ - } else if (s>=0x110000) { \ - append_i_byte(s-0x11000); \ - } else { \ - append_i_byte(0xF0 + (s / 0x40000)); \ - append_i_byte(0x80 + ((s % 0x40000) / 0x1000)); \ - append_i_byte(0x80 + (((s % 0x40000) % 0x1000) / 0x40)); \ - append_i_byte(0x80 + (((s % 0x40000) % 0x1000) % 0x40)); \ - } } - - -#define Print_esc(b) { \ - const char *v = b; \ - if (e>0 && e<STRING_OFFSET) { \ - Print_uchar (e); \ - } \ - make_room(strlen(v)); \ - while (*v) { append_i_byte(*v); v++; } \ - } - -#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. - -@c -char *tokenlist_to_cstring(int pp, int inhibit_par, int *siz) -{ - register int p, c, m; - int q; - int infop; - char *s, *sh; - int e = 0; - char *ret; - int match_chr = '#'; - int n = '0'; - unsigned alloci = 1024; - int i = 0; - p = pp; - if (p == null) { - if (siz != NULL) - *siz = 0; - return NULL; - } - ret = xmalloc(alloci); - p = token_link(p); /* skip refcount */ - if (p != null) { - e = int_par(escape_char_code); - } - while (p != null) { - if (p < (int) fix_mem_min || p > (int) fix_mem_end) { - Print_esc("CLOBBERED."); - break; - } - infop = token_info(p); - if (infop >= cs_token_flag) { - if (!(inhibit_par && infop == par_token)) { - q = infop - cs_token_flag; - if (q < hash_base) { - if (q == null_cs) { - Print_esc("csname"); - Print_esc("endcsname"); - } else { - Print_esc("IMPOSSIBLE."); - } - } else if ((q >= undefined_control_sequence) - && ((q <= eqtb_size) - || (q > eqtb_size + hash_extra))) { - Print_esc("IMPOSSIBLE."); - } else if ((cs_text(q) < 0) || (cs_text(q) >= str_ptr)) { - Print_esc("NONEXISTENT."); - } else { - str_number txt = cs_text(q); - sh = makecstring(txt); - s = sh; - if (is_active_cs(txt)) { - s = s + 3; - while (*s) { - Print_char(*s); - s++; - } - } else { - Print_uchar(e); - while (*s) { - Print_char(*s); - s++; - } - if ((!single_letter(txt)) || is_cat_letter(txt)) { - Print_char(' '); - } - } - free(sh); - } - } - } else { - if (infop < 0) { - Print_esc("BAD."); - } else { - m = token_cmd(infop); - c = token_chr(infop); - switch (m) { - case left_brace_cmd: - case right_brace_cmd: - case math_shift_cmd: - case tab_mark_cmd: - case sup_mark_cmd: - case sub_mark_cmd: - case spacer_cmd: - case letter_cmd: - case other_char_cmd: - Print_uchar(c); - break; - case mac_param_cmd: - if (!in_lua_escape) - Print_uchar(c); - Print_uchar(c); - break; - case out_param_cmd: - Print_uchar(match_chr); - if (c <= 9) { - Print_char(c + '0'); - } else { - Print_char('!'); - goto EXIT; - } - break; - case match_cmd: - match_chr = c; - Print_uchar(c); - n++; - Print_char(n); - if (n > '9') - goto EXIT; - break; - case end_match_cmd: - if (c == 0) { - Print_char('-'); - Print_char('>'); - } - break; - default: - Print_esc("BAD."); - break; - } - } - } - p = token_link(p); - } - EXIT: - ret[i] = '\0'; - if (siz != NULL) - *siz = i; - return ret; -} - -@ @c -lstring *tokenlist_to_lstring(int pp, int inhibit_par) -{ - int siz; - lstring *ret = xmalloc(sizeof(lstring)); - ret->s = (unsigned char *) tokenlist_to_cstring(pp, inhibit_par, &siz); - ret->l = (size_t) siz; - return ret; -} - -@ @c -void free_lstring(lstring * ls) -{ - if (ls == NULL) - return; - if (ls->s != NULL) - free(ls->s); - free(ls); -} +% 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
+static const char _svn_version[] =
+ "$Id: textoken.w 4786 2014-02-10 13:17:44Z taco $"
+ "$URL: https://foundry.supelec.fr/svn/luatex/trunk/source/texk/web2c/luatexdir/tex/textoken.w $";
+
+#include "ptexlib.h"
+
+@ @c
+#define pausing int_par(pausing_code)
+#define cat_code_table int_par(cat_code_table_code)
+#define tracing_nesting int_par(tracing_nesting_code)
+#define end_line_char int_par(end_line_char_code)
+#define suppress_outer_error int_par(suppress_outer_error_code)
+
+#define every_eof equiv(every_eof_loc)
+#define box(A) equiv(box_base+(A))
+
+#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(line_catcode_table,b); \
+ else \
+ a=get_cat_code(cat_code_table,b); \
+ } 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.
+
+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.
+
+@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 */
+
+
+@ 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 */
+
+halfword avail; /* head of the list of available one-word nodes */
+unsigned fix_mem_end; /* the last one-word node used in |mem| */
+
+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| */
+
+@ @c
+void initialize_tokens(void)
+{
+ halfword p;
+ avail = null;
+ fix_mem_end = 0;
+ p = get_avail();
+ temp_token_head = p;
+ set_token_info(temp_token_head, 0);
+ p = get_avail();
+ hold_token_head = p;
+ set_token_info(hold_token_head, 0);
+ p = get_avail();
+ omit_template = p;
+ set_token_info(omit_template, 0);
+ p = get_avail();
+ null_list = p;
+ set_token_info(null_list, 0);
+ p = get_avail();
+ backup_head = p;
+ set_token_info(backup_head, 0);
+ p = get_avail();
+ garbage = p;
+ set_token_info(garbage, 0);
+ dyn_used = 0; /* initialize statistics */
+}
+
+@ 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@>
+
+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.
+
+@c
+halfword get_avail(void)
+{ /* single-word node allocation */
+ unsigned p; /* the new node being got */
+ unsigned t;
+ p = (unsigned) avail; /* get top location in the |avail| stack */
+ if (p != null) {
+ avail = token_link(avail); /* and pop it off */
+ } else if (fix_mem_end < fix_mem_max) { /* or go into virgin territory */
+ incr(fix_mem_end);
+ p = fix_mem_end;
+ } else {
+ smemory_word *new_fixmem; /* the big dynamic storage area */
+ t = (fix_mem_max / 5);
+ 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 */
+ overflow("token memory size", fix_mem_max);
+ } else {
+ fixmem = new_fixmem;
+ }
+ memset(voidcast(fixmem + fix_mem_max + 1), 0, t * sizeof(smemory_word));
+ 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 */
+ return (halfword) p;
+}
+
+
+@ The procedure |flush_list(p)| frees an entire linked list of
+one-word nodes that starts at position |p|.
+@^inner loop@>
+
+@c
+void flush_list(halfword p)
+{ /* makes list of single-word nodes available */
+ halfword q, r; /* list traversers */
+ 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 */
+ 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
+void print_meaning(void)
+{
+ 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 */
+ if ((cur_cmd == top_bot_mark_cmd) && (cur_chr < marks_code)) {
+ print_char(':');
+ print_ln();
+ switch (cur_chr) {
+ case first_mark_code:
+ token_show(first_mark(0));
+ break;
+ case bot_mark_code:
+ token_show(bot_mark(0));
+ break;
+ case split_first_mark_code:
+ token_show(split_first_mark(0));
+ break;
+ case split_bot_mark_code:
+ token_show(split_bot_mark(0));
+ break;
+ default:
+ token_show(top_mark(0));
+ break;
+ }
+ }
+ }
+}
+
+
+@ 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
+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; /* the highest parameter number, as an ASCII digit */
+ match_chr = '#';
+ n = '0';
+ tally = 0;
+ if (l < 0)
+ l = 0x3FFFFFFF;
+ while ((p != null) && (tally < l)) {
+ if (p == q) {
+ /* Do magic computation */
+ set_trick_count();
+ }
+ /* Display token |p|, and |return| if there are problems */
+ if ((p < (int) fix_mem_min) || (p > (int) fix_mem_end)) {
+ tprint_esc("CLOBBERED.");
+ return;
+ }
+ if (token_info(p) >= cs_token_flag) {
+ if (!((inhibit_par_tokens) && (token_info(p) == par_token)))
+ print_cs(token_info(p) - cs_token_flag);
+ } else {
+ m = token_cmd(token_info(p));
+ c = token_chr(token_info(p));
+ if (token_info(p) < 0) {
+ 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
+ |out_param| commands. */
+ switch (m) {
+ case left_brace_cmd:
+ case right_brace_cmd:
+ case math_shift_cmd:
+ case tab_mark_cmd:
+ case sup_mark_cmd:
+ case sub_mark_cmd:
+ case spacer_cmd:
+ case letter_cmd:
+ case other_char_cmd:
+ print(c);
+ break;
+ case mac_param_cmd:
+ if (!in_lua_escape)
+ print(c);
+ print(c);
+ break;
+ case out_param_cmd:
+ print(match_chr);
+ if (c <= 9) {
+ print_char(c + '0');
+ } else {
+ print_char('!');
+ return;
+ }
+ break;
+ case match_cmd:
+ match_chr = c;
+ print(c);
+ incr(n);
+ print_char(n);
+ if (n > '9')
+ return;
+ break;
+ case end_match_cmd:
+ if (c == 0)
+ tprint("->");
+ break;
+ default:
+ tprint_esc("BAD.");
+ break;
+ }
+ }
+ }
+ p = token_link(p);
+ }
+ if (p != null)
+ 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.
+
+@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@>
+
+@c
+void delete_token_ref(halfword p)
+{ /* |p| points to the reference count
+ of a token list that is losing one reference */
+ assert(token_ref_count(p) >= 0);
+ if (token_ref_count(p) == 0)
+ flush_list(p);
+ else
+ decr(token_ref_count(p));
+}
+
+@ @c
+int get_char_cat_code(int curchr)
+{
+ int a;
+ do_get_cat_code(a,curchr);
+ return a;
+}
+
+@ @c
+static void invalid_character_error(void)
+{
+ const char *hlp[] =
+ { "A funny symbol that I can't read has just been input.",
+ "Continue, and I'll forget that it ever happened.",
+ NULL
+ };
+ deletions_allowed = false;
+ tex_error("Text line contains an invalid character", hlp);
+ deletions_allowed = true;
+}
+
+@ @c
+static boolean process_sup_mark(void); /* below */
+
+static int scan_control_sequence(void); /* below */
+
+typedef enum { next_line_ok, next_line_return,
+ next_line_restart
+} next_line_retval;
+
+static next_line_retval next_line(void); /* below */
+
+
+@ 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.).
+ @^inner loop@>
+
+@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| */
+ halfword save_cur_cs = cur_cs;
+ int saved_align_state = align_state;
+ assert (strlen(s) > 1);
+ p = backup_head;
+ token_link(p) = null;
+ k = s;
+ while (*k) {
+ get_x_token(); /* recursion is possible here */
+ 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)) {
+ 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);
+ if (cur_cmd != endv_cmd)
+ align_state = saved_align_state;
+ } else {
+ back_input();
+ }
+ cur_cs = save_cur_cs;
+ return false;
+ }
+ }
+ flush_list(token_link(backup_head));
+ cur_cs = save_cur_cs;
+ if (cur_cmd != endv_cmd)
+ align_state = saved_align_state;
+ return true;
+}
+
+@ We can not return |undefined_control_sequence| under some conditions
+ (inside |shift_case|, for example). This needs thinking.
+
+@c
+halfword active_to_cs(int curchr, int force)
+{
+ halfword curcs;
+ char *a, *b;
+ char *utfbytes = xmalloc(10);
+ 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;
+}
+
+@ TODO this function should listen to \.{\\escapechar}
+
+@c
+static char *cs_to_string(halfword p)
+{ /* prints a control sequence */
+ const char *s;
+ char *sh;
+ int k = 0;
+ static char ret[256] = { 0 };
+ if (p == 0 || p == null_cs) {
+ ret[k++] = '\\';
+ s = "csname";
+ while (*s) {
+ ret[k++] = *s++;
+ }
+ ret[k++] = '\\';
+ s = "endcsname";
+ while (*s) {
+ ret[k++] = *s++;
+ }
+ ret[k] = 0;
+
+ } else {
+ str_number txt = cs_text(p);
+ sh = makecstring(txt);
+ s = sh;
+ if (is_active_cs(txt)) {
+ s = s + 3;
+ while (*s) {
+ ret[k++] = *s++;
+ }
+ ret[k] = 0;
+ } else {
+ ret[k++] = '\\';
+ while (*s) {
+ ret[k++] = *s++;
+ }
+ ret[k] = 0;
+ }
+ free(sh);
+ }
+ return (char *) ret;
+}
+
+@ TODO this is a quick hack, will be solved differently soon
+
+@c
+static char *cmd_chr_to_string(int cmd, int chr)
+{
+ char *s;
+ str_number str;
+ int sel = selector;
+ selector = new_string;
+ print_cmd_chr((quarterword) cmd, chr);
+ str = make_string();
+ s = makecstring(str);
+ selector = sel;
+ flush_str(str);
+ 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
+void firm_up_the_line(void)
+{
+ int k; /* an index into |buffer| */
+ ilimit = last;
+ if (pausing > 0) {
+ if (interaction > nonstop_mode) {
+ wake_up_terminal();
+ print_ln();
+ if (istart < ilimit) {
+ for (k = istart; k <= ilimit - 1; k++)
+ print_char(buffer[k]);
+ }
+ first = ilimit;
+ prompt_input("=>"); /* wait for user response */
+ if (last > first) {
+ for (k = first; k < +last - 1; k++) /* move line down in buffer */
+ buffer[k + istart - first] = buffer[k];
+ ilimit = istart + last - first;
+ }
+ }
+ }
+}
+
+
+
+@ 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 */
+ if (suppress_outer_error)
+ 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. */
+ 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 */
+ }
+ cur_cmd = spacer_cmd;
+ cur_chr = ' '; /* replace it by a space */
+ }
+ if (scanner_status > skipping) {
+ const char *errhlp[] =
+ { "I suspect you have forgotten a `}', causing me",
+ "to read past where you wanted me to stop.",
+ "I'll try to recover; but if the error is serious,",
+ "you'd better type `E' or `X' now and fix your file.",
+ NULL
+ };
+ char errmsg[256];
+ const char *startmsg;
+ const char *scannermsg;
+ /* Tell the user what has run away and try to recover */
+ runaway(); /* print a definition, argument, or preamble */
+ 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}. */
+ 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 */
+ begin_token_list(p, inserted);
+ snprintf(errmsg, 255, "%s while scanning %s of %s",
+ startmsg, scannermsg, cs_to_string(warning_index));
+ tex_error(errmsg, errhlp);
+ } else {
+ char errmsg[256];
+ const char *errhlp_no[] =
+ { "The file ended while I was skipping conditional text.",
+ "This kind of error happens when you say `\\if...' and forget",
+ "the matching `\\fi'. I've inserted a `\\fi'; this might work.",
+ NULL
+ };
+ const char *errhlp_cs[] =
+ { "A forbidden control sequence occurred in skipped text.",
+ "This kind of error happens when you say `\\if...' and forget",
+ "the matching `\\fi'. I've inserted a `\\fi'; this might work.",
+ NULL
+ };
+ const char **errhlp = (const char **) errhlp_no;
+ char *ss;
+ if (cur_cs != 0) {
+ errhlp = errhlp_cs;
+ cur_cs = 0;
+ }
+ ss = cmd_chr_to_string(if_test_cmd, cur_if);
+ snprintf(errmsg, 255,
+ "Incomplete %s; all text was ignored after line %d",
+ ss, (int) skip_line);
+ free(ss);
+ /* Incomplete \\if... */
+ cur_tok = cs_token_flag + frozen_fi;
+ /* back up one inserted token and call |error| */
+ {
+ OK_to_interrupt = false;
+ back_input();
+ token_type = inserted;
+ OK_to_interrupt = true;
+ tex_error(errmsg, errhlp);
+ }
+ }
+ deletions_allowed = true;
+ }
+}
+
+@ @c
+static boolean get_next_file(void)
+{
+ SWITCH:
+ if (iloc <= ilimit) { /* 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);
+ }
+ /*
+ 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.
+ */
+ switch (istate + cur_cmd) {
+ case mid_line + ignore_cmd:
+ case skip_blanks + ignore_cmd:
+ case new_line + ignore_cmd:
+ case skip_blanks + spacer_cmd:
+ case new_line + spacer_cmd: /* 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 ...; */
+ istate = (unsigned char) scan_control_sequence();
+ if (cur_cmd >= outer_call_cmd)
+ check_outer_validity();
+ break;
+ case mid_line + active_char_cmd:
+ case new_line + active_char_cmd:
+ case skip_blanks + active_char_cmd: /* Process an active-character */
+ cur_cs = active_to_cs(cur_chr, false);
+ cur_cmd = eq_type(cur_cs);
+ cur_chr = equiv(cur_cs);
+ istate = mid_line;
+ if (cur_cmd >= outer_call_cmd)
+ check_outer_validity();
+ break;
+ case mid_line + sup_mark_cmd:
+ case new_line + sup_mark_cmd:
+ case skip_blanks + sup_mark_cmd: /* If this |sup_mark| starts */
+ if (process_sup_mark())
+ goto RESWITCH;
+ else
+ istate = mid_line;
+ break;
+ 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|; */
+ invalid_character_error();
+ return false; /* because state may be |token_list| now */
+ break;
+ case mid_line + spacer_cmd: /* 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.
+ */
+ iloc = ilimit + 1;
+ cur_cmd = spacer_cmd;
+ cur_chr = ' ';
+ break;
+ case skip_blanks + car_ret_cmd:
+ case mid_line + comment_cmd:
+ case new_line + comment_cmd:
+ case skip_blanks + comment_cmd: /* Finish line, |goto switch|; */
+ iloc = ilimit + 1;
+ goto SWITCH;
+ break;
+ case new_line + car_ret_cmd: /* Finish line, emit a \.{\\par}; */
+ iloc = ilimit + 1;
+ cur_cs = par_loc;
+ cur_cmd = eq_type(cur_cs);
+ cur_chr = equiv(cur_cs);
+ if (cur_cmd >= outer_call_cmd)
+ check_outer_validity();
+ break;
+ case skip_blanks + left_brace_cmd:
+ case new_line + left_brace_cmd:
+ istate = mid_line; /* 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 */
+ case mid_line + right_brace_cmd:
+ align_state--;
+ break;
+ case mid_line + math_shift_cmd:
+ case mid_line + tab_mark_cmd:
+ case mid_line + mac_param_cmd:
+ case mid_line + sub_mark_cmd:
+ case mid_line + letter_cmd:
+ case mid_line + other_char_cmd:
+ break;
+#if 0
+ case skip_blanks + math_shift:
+ case skip_blanks + tab_mark:
+ case skip_blanks + mac_param:
+ case skip_blanks + sub_mark:
+ case skip_blanks + letter:
+ case skip_blanks + other_char:
+ case new_line + math_shift:
+ case new_line + tab_mark:
+ case new_line + mac_param:
+ case new_line + sub_mark:
+ case new_line + letter:
+ case new_line + other_char:
+#else
+ default:
+#endif
+ istate = mid_line;
+ break;
+ }
+ } else {
+ 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;
+ */
+ do {
+ next_line_retval r = next_line();
+ if (r == next_line_return) {
+ return true;
+ } else if (r == next_line_restart) {
+ return false;
+ }
+ } while (0);
+ check_interrupt();
+ goto SWITCH;
+ }
+ return true;
+}
+
+@ @c
+#define is_hex(a) ((a>='0'&&a<='9')||(a>='a'&&a<='f'))
+
+#define add_nybble(a) do { \
+ if (a<='9') cur_chr=(cur_chr<<4)+a-'0'; \
+ else cur_chr=(cur_chr<<4)+a-'a'+10; \
+ } while (0)
+
+#define hex_to_cur_chr do { \
+ if (c<='9') cur_chr=c-'0'; \
+ else cur_chr=c-'a'+10; \
+ add_nybble(cc); \
+ } while (0)
+
+#define four_hex_to_cur_chr do { \
+ hex_to_cur_chr; \
+ add_nybble(ccc); add_nybble(cccc); \
+ } while (0)
+
+#define five_hex_to_cur_chr do { \
+ four_hex_to_cur_chr; \
+ add_nybble(ccccc); \
+ } while (0)
+
+#define six_hex_to_cur_chr do { \
+ five_hex_to_cur_chr; \
+ add_nybble(cccccc); \
+ } while (0)
+
+
+@ Notice that a code like \.{\^\^8} becomes \.x if not followed by a hex digit.
+
+@c
+static boolean process_sup_mark(void)
+{
+ if (cur_chr == buffer[iloc]) {
+ int c, cc;
+ if (iloc < ilimit) {
+ if ((cur_chr == buffer[iloc + 1]) && (cur_chr == buffer[iloc + 2])
+ && (cur_chr == buffer[iloc + 3])
+ && (cur_chr == buffer[iloc + 4])
+ && ((iloc + 10) <= ilimit)) {
+ int ccc, cccc, ccccc, cccccc; /* constituents of a possible expanded code */
+ c = buffer[iloc + 5];
+ cc = buffer[iloc + 6];
+ ccc = buffer[iloc + 7];
+ cccc = buffer[iloc + 8];
+ ccccc = buffer[iloc + 9];
+ cccccc = buffer[iloc + 10];
+ if ((is_hex(c)) && (is_hex(cc)) && (is_hex(ccc))
+ && (is_hex(cccc))
+ && (is_hex(ccccc)) && (is_hex(cccccc))) {
+ iloc = iloc + 11;
+ six_hex_to_cur_chr;
+ return true;
+ }
+ }
+ if ((cur_chr == buffer[iloc + 1]) && (cur_chr == buffer[iloc + 2])
+ && (cur_chr == buffer[iloc + 3]) && ((iloc + 8) <= ilimit)) {
+ int ccc, cccc, ccccc; /* constituents of a possible expanded code */
+ c = buffer[iloc + 4];
+ cc = buffer[iloc + 5];
+ ccc = buffer[iloc + 6];
+ cccc = buffer[iloc + 7];
+ ccccc = buffer[iloc + 8];
+ if ((is_hex(c)) && (is_hex(cc)) && (is_hex(ccc))
+ && (is_hex(cccc)) && (is_hex(ccccc))) {
+ iloc = iloc + 9;
+ five_hex_to_cur_chr;
+ return true;
+ }
+ }
+ if ((cur_chr == buffer[iloc + 1]) && (cur_chr == buffer[iloc + 2])
+ && ((iloc + 6) <= ilimit)) {
+ int ccc, cccc; /* constituents of a possible expanded code */
+ c = buffer[iloc + 3];
+ cc = buffer[iloc + 4];
+ ccc = buffer[iloc + 5];
+ cccc = buffer[iloc + 6];
+ if ((is_hex(c)) && (is_hex(cc)) && (is_hex(ccc))
+ && (is_hex(cccc))) {
+ iloc = iloc + 7;
+ four_hex_to_cur_chr;
+ return true;
+ }
+ }
+ c = buffer[iloc + 1];
+ if (c < 0200) { /* yes we have an expanded char */
+ iloc = iloc + 2;
+ if (is_hex(c) && iloc <= ilimit) {
+ cc = buffer[iloc];
+ if (is_hex(cc)) {
+ incr(iloc);
+ hex_to_cur_chr;
+ return true;
+ }
+ }
+ cur_chr = (c < 0100 ? c + 0100 : c - 0100);
+ return true;
+ }
+ }
+ }
+ 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.
+
+ 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.
+
+@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 */
+ } else {
+ register int cat; /* |cat_code(cur_chr)|, usually */
+ 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...; */
+ continue;
+ } else {
+ retval = skip_blanks;
+ do {
+ 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...; */
+ continue;
+ if (cat != letter_cmd) {
+ decr(k);
+ if (cur_chr > 0xFFFF)
+ decr(k);
+ if (cur_chr > 0x7FF)
+ decr(k);
+ if (cur_chr > 0x7F)
+ decr(k);
+ } /* now |k| points to first nonletter */
+ }
+ cur_cs = id_lookup(iloc, k - iloc);
+ iloc = k;
+ break;
+ }
+ }
+ cur_cmd = eq_type(cur_cs);
+ cur_chr = equiv(cur_cs);
+ 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.
+
+@c
+static boolean check_expanded_code(int *kk)
+{
+ int l;
+ int k = *kk;
+ int d = 1; /* number of excess characters in an expanded code */
+ int c, cc, ccc, cccc, ccccc, cccccc; /* constituents of a possible expanded code */
+ if (buffer[k] == cur_chr && k < ilimit) {
+ if ((cur_chr == buffer[k + 1]) && (cur_chr == buffer[k + 2])
+ && ((k + 6) <= ilimit)) {
+ d = 4;
+ if ((cur_chr == buffer[k + 3]) && ((k + 8) <= ilimit))
+ d = 5;
+ if ((cur_chr == buffer[k + 4]) && ((k + 10) <= ilimit))
+ d = 6;
+ c = buffer[k + d - 1];
+ cc = buffer[k + d];
+ ccc = buffer[k + d + 1];
+ cccc = buffer[k + d + 2];
+ if (d == 6) {
+ ccccc = buffer[k + d + 3];
+ cccccc = buffer[k + d + 4];
+ if (is_hex(c) && is_hex(cc) && is_hex(ccc) && is_hex(cccc)
+ && is_hex(ccccc) && is_hex(cccccc))
+ six_hex_to_cur_chr;
+ } else if (d == 5) {
+ ccccc = buffer[k + d + 3];
+ if (is_hex(c) && is_hex(cc) && is_hex(ccc) && is_hex(cccc)
+ && is_hex(ccccc))
+ five_hex_to_cur_chr;
+ } else {
+ if (is_hex(c) && is_hex(cc) && is_hex(ccc) && is_hex(cccc))
+ four_hex_to_cur_chr;
+ }
+ } else {
+ c = buffer[k + 1];
+ if (c < 0200) {
+ d = 1;
+ if (is_hex(c) && (k + 2) <= ilimit) {
+ cc = buffer[k + 2];
+ if (is_hex(c) && is_hex(cc)) {
+ d = 2;
+ hex_to_cur_chr;
+ }
+ } else if (c < 0100) {
+ cur_chr = c + 0100;
+ } else {
+ cur_chr = c - 0100;
+ }
+ }
+ }
+ if (d > 2)
+ d = 2 * d - 1;
+ else
+ d++;
+ if (cur_chr <= 0x7F) {
+ buffer[k - 1] = (packed_ASCII_code) cur_chr;
+ } else if (cur_chr <= 0x7FF) {
+ buffer[k - 1] = (packed_ASCII_code) (0xC0 + cur_chr / 0x40);
+ k++;
+ d--;
+ buffer[k - 1] = (packed_ASCII_code) (0x80 + cur_chr % 0x40);
+ } else if (cur_chr <= 0xFFFF) {
+ buffer[k - 1] = (packed_ASCII_code) (0xE0 + cur_chr / 0x1000);
+ k++;
+ d--;
+ buffer[k - 1] =
+ (packed_ASCII_code) (0x80 + (cur_chr % 0x1000) / 0x40);
+ k++;
+ d--;
+ buffer[k - 1] =
+ (packed_ASCII_code) (0x80 + (cur_chr % 0x1000) % 0x40);
+ } else {
+ buffer[k - 1] = (packed_ASCII_code) (0xF0 + cur_chr / 0x40000);
+ k++;
+ d--;
+ buffer[k - 1] =
+ (packed_ASCII_code) (0x80 + (cur_chr % 0x40000) / 0x1000);
+ k++;
+ d--;
+ buffer[k - 1] =
+ (packed_ASCII_code) (0x80 +
+ ((cur_chr % 0x40000) % 0x1000) / 0x40);
+ k++;
+ d--;
+ buffer[k - 1] =
+ (packed_ASCII_code) (0x80 +
+ ((cur_chr % 0x40000) % 0x1000) % 0x40);
+ }
+ l = k;
+ ilimit = ilimit - d;
+ while (l <= ilimit) {
+ buffer[l] = buffer[l + d];
+ l++;
+ }
+ *kk = k;
+ return true;
+ }
+ return false;
+}
+
+@ todo: this is a function because it is still used from the converted pascal.
+ once that is gone, it can be a \#define again
+
+@c
+boolean end_line_char_inactive(void)
+{
+ return ((end_line_char < 0) || (end_line_char > 127));
+}
+
+@ All of the easy branches of |get_next| have now been taken care of.
+ There is one more branch.
+
+@c
+static next_line_retval next_line(void)
+{
+ boolean inhibit_eol = false; /* a way to end a pseudo file without trailing space */
+ if (iname > 17) {
+ /* 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| */
+ line_catcode_table = DEFAULT_CAT_TABLE;
+ if ((iname == 19) && (pseudo_lines(pseudo_files) == null))
+ inhibit_eol = true;
+ } else if ((every_eof != null) && !eof_seen[iindex]) {
+ ilimit = first - 1;
+ eof_seen[iindex] = true; /* fake one empty line */
+ if (iname != 19)
+ begin_token_list(every_eof, every_eof_text);
+ return next_line_restart;
+ } else {
+ force_eof = true;
+ }
+ } 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;
+ }
+ } 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 != null) && (!eof_seen[iindex])) {
+ ilimit = first - 1;
+ eof_seen[iindex] = true; /* fake one empty line */
+ begin_token_list(every_eof, every_eof_text);
+ return next_line_restart;
+ } else {
+ force_eof = true;
+ }
+ }
+ }
+ }
+ if (force_eof) {
+ if (tracing_nesting > 0)
+ if ((grp_stack[in_open] != cur_boundary)
+ || (if_stack[in_open] != cond_ptr))
+ if (!((iname == 19) || (iname == 21)))
+ file_warning(); /* give warning for some unfinished groups and/or conditionals */
+ if ((iname > 21) || (iname == 20)) {
+ if (tracefilenames)
+ print_char(')');
+ open_parens--;
+#if 0
+ update_terminal(); /* show user that file has been read */
+#endif
+ }
+ force_eof = false;
+ if (iname == 21 || /* lua input */
+ iname == 19) { /* \.{\\scantextokens} */
+ end_file_reading();
+ } else {
+ end_file_reading();
+ check_outer_validity();
+ }
+ return next_line_restart;
+ }
+ if (inhibit_eol || end_line_char_inactive())
+ ilimit--;
+ else
+ buffer[ilimit] = (packed_ASCII_code) end_line_char;
+ first = ilimit + 1;
+ iloc = istart; /* ready to read */
+ } else {
+ if (!terminal_input) { /* \.{\\read} line has ended */
+ cur_cmd = 0;
+ cur_chr = 0;
+ return next_line_return; /* OUTER */
+ }
+ if (input_ptr > 0) { /* text was inserted during error recovery */
+ end_file_reading();
+ return next_line_restart; /* resume previous level */
+ }
+ if (selector < log_only)
+ open_log_file();
+ if (interaction > nonstop_mode) {
+ if (end_line_char_inactive())
+ ilimit++;
+ if (ilimit == istart) { /* previous line was empty */
+ tprint_nl("(Please type a command or say `\\end')");
+ }
+ print_ln();
+ first = istart;
+ prompt_input("*"); /* input on-line into |buffer| */
+ ilimit = last;
+ if (end_line_char_inactive())
+ ilimit--;
+ else
+ buffer[ilimit] = (packed_ASCII_code) end_line_char;
+ first = ilimit + 1;
+ iloc = istart;
+ } else {
+ fatal_error("*** (job aborted, no legal \\end found)");
+ /* nonstop mode, which is intended for overnight batch processing,
+ never waits for on-line input */
+ }
+ }
+ return next_line_ok;
+}
+
+@ 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; /* a token */
+ t = token_info(iloc);
+ iloc = token_link(iloc); /* move to next */
+ if (t >= cs_token_flag) { /* 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|.
+ */
+ cur_cs = token_info(iloc) - cs_token_flag;
+ iloc = null;
+ cur_cmd = eq_type(cur_cs);
+ if (cur_cmd > max_command_cmd) {
+ cur_cmd = relax_cmd;
+ cur_chr = no_expand_flag;
+ return true;
+ }
+ } else {
+ check_outer_validity();
+ }
+ }
+ cur_chr = equiv(cur_cs);
+ } else {
+ cur_cmd = token_cmd(t);
+ cur_chr = token_chr(t);
+ switch (cur_cmd) {
+ case left_brace_cmd:
+ align_state++;
+ break;
+ case right_brace_cmd:
+ align_state--;
+ break;
+ case out_param_cmd: /* Insert macro parameter and |goto restart|; */
+ begin_token_list(param_stack[param_start + cur_chr - 1], parameter);
+ return false;
+ break;
+ }
+ }
+ 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@>
+
+@ 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 */
+ if (!get_next_file())
+ goto RESTART;
+ } else {
+ if (iloc == null) {
+ end_token_list();
+ goto RESTART; /* list exhausted, resume previous level */
+ } else if (!get_next_tokenlist()) {
+ goto RESTART; /* parameter needs to be expanded */
+ }
+ }
+ /* 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|.
+
+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.
+
+@c
+void get_token(void)
+{ /* sets |cur_cmd|, |cur_chr|, |cur_tok| */
+ no_new_control_sequence = false;
+ get_token_lua();
+ no_new_control_sequence = true;
+ if (cur_cs == 0)
+ cur_tok = token_val(cur_cmd, cur_chr);
+ else
+ cur_tok = cs_token_flag + cur_cs;
+}
+
+@ @c
+void get_token_lua(void)
+{
+ register int callback_id;
+ callback_id = callback_defined(token_filter_callback);
+ if (callback_id > 0) {
+ while (istate == token_list && iloc == null && iindex != v_template)
+ end_token_list();
+ /* there is some stuff we don't want to see inside the callback */
+ if (!(istate == token_list &&
+ ((nofilter == true) || (iindex == backed_up && iloc != null)))) {
+ do_get_token_lua(callback_id);
+ return;
+ }
+ }
+ get_next();
+}
+
+
+@ changes the string |s| to a token list
+@c
+halfword string_to_toks(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 */
+ char *s = ss, *se = ss + strlen(s);
+ p = temp_token_head;
+ set_token_link(p, null);
+ while (s < se) {
+ t = (halfword) str2uni((unsigned char *) s);
+ s += utf8_size(t);
+ if (t == ' ')
+ t = space_token;
+ else
+ t = other_token + t;
+ fast_store_new_token(t);
+ }
+ 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|.
+
+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 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.)
+
+|lua_str_toks| is almost identical, but it also escapes the three
+symbols that |lua| considers special while scanning a literal string
+
+@c
+static halfword lua_str_toks(lstring b)
+{ /* 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; /* index into string */
+ p = temp_token_head;
+ set_token_link(p, null);
+ k = (unsigned char *) b.s;
+ while (k < (unsigned char *) b.s + b.l) {
+ t = pool_to_unichar(k);
+ k += utf8_size(t);
+ if (t == ' ') {
+ t = space_token;
+ } else {
+ if ((t == '\\') || (t == '"') || (t == '\'') || (t == 10)
+ || (t == 13))
+ fast_store_new_token(other_token + '\\');
+ if (t == 10)
+ t = 'n';
+ if (t == 13)
+ t = 'r';
+ t = other_token + t;
+ }
+ fast_store_new_token(t);
+ }
+ return p;
+}
+
+
+@ Incidentally, the main reason for wanting |str_toks| is the function |the_toks|,
+which has similar input/output characteristics.
+
+@c
+halfword str_toks(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 */
+ p = temp_token_head;
+ set_token_link(p, null);
+ k = s.s;
+ l = k + s.l;
+ while (k < l) {
+ t = pool_to_unichar(k);
+ k += utf8_size(t);
+ if (t == ' ')
+ t = space_token;
+ else
+ t = other_token + t;
+ fast_store_new_token(t);
+ }
+ return p;
+}
+
+@ 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));
+}
+
+@ 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);
+ }
+}
+
+@ 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
+static boolean print_convert_string(halfword c, int i)
+{
+ int ff; /* for use with |set_ff| */
+ boolean ret = true;
+ switch (c) {
+ case number_code:
+ print_int(i);
+ break;
+ case uchar_code:
+ print(i);
+ break;
+ case roman_numeral_code:
+ print_roman_int(i);
+ break;
+ case etex_code:
+ tprint(eTeX_version_string);
+ break;
+ case pdftex_revision_code:
+ tprint(pdftex_revision);
+ break;
+ case luatex_revision_code:
+ print(get_luatexrevision());
+ break;
+ case luatex_date_code:
+ print_int(get_luatex_date_info());
+ break;
+ case pdftex_banner_code:
+ tprint(pdftex_banner);
+ break;
+ case uniform_deviate_code:
+ print_int(unif_rand(i));
+ break;
+ case normal_deviate_code:
+ print_int(norm_rand());
+ break;
+ case format_name_code:
+ print(format_name);
+ break;
+ case job_name_code:
+ print_job_name();
+ break;
+ case font_name_code:
+ append_string((unsigned char *) font_name(i),
+ (unsigned) strlen(font_name(i)));
+ if (font_size(i) != font_dsize(i)) {
+ tprint(" at ");
+ print_scaled(font_size(i));
+ tprint("pt");
+ }
+ break;
+ case font_id_code:
+ print_int(i);
+ break;
+ case math_style_code:
+ print_math_style();
+ break;
+ case pdf_font_name_code:
+ case pdf_font_objnum_code:
+ set_ff(i);
+ if (c == pdf_font_name_code)
+ print_int(obj_info(static_pdf, pdf_font_num(ff)));
+ else
+ print_int(pdf_font_num(ff));
+ break;
+ case pdf_font_size_code:
+ print_scaled(font_size(i));
+ tprint("pt");
+ break;
+ case pdf_page_ref_code:
+ print_int(pdf_get_obj(static_pdf, obj_type_page, i, false));
+ break;
+ case pdf_xform_name_code:
+ print_int(obj_info(static_pdf, i));
+ break;
+ case eTeX_revision_code:
+ tprint(eTeX_revision);
+ break;
+ default:
+ ret = false;
+ break;
+ }
+ return ret;
+}
+
+@ @c
+int scan_lua_state(void)
+{
+ int sn = 0;
+ if (scan_keyword("name")) {
+ scan_pdf_ext_toks();
+ sn = def_ref;
+ }
+ /* Parse optional lua state integer, or an instance name to be stored in |sn| */
+ /* Get the next non-blank non-relax non-call token */
+ do {
+ get_x_token();
+ } while ((cur_cmd == spacer_cmd) || (cur_cmd == relax_cmd));
+
+ back_input(); /* have to push it back, whatever it is */
+ if (cur_cmd != left_brace_cmd) {
+ scan_register_num();
+ if (get_lua_name(cur_val))
+ sn = (cur_val - 65536);
+ }
+ 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}'.
+
+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
+void conv_toks(void)
+{
+ int old_setting; /* holds |selector| setting */
+ halfword p, q;
+ int save_scanner_status; /* |scanner_status| upon entry */
+ halfword save_def_ref; /* |def_ref| upon entry, important if inside `\.{\\message}' */
+ 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 i = 0; /* first temp integer */
+ int j = 0; /* second temp integer */
+ int c = cur_chr; /* desired type of conversion */
+ str_number str;
+ /* Scan the argument for command |c| */
+ switch (c) {
+ case uchar_code:
+ scan_char_num();
+ break;
+ case number_code:
+ case roman_numeral_code:
+ scan_int();
+ break;
+ case string_code:
+ case meaning_code:
+ save_scanner_status = scanner_status;
+ scanner_status = normal;
+ get_token();
+ scanner_status = save_scanner_status;
+ break;
+ case etex_code:
+ break;
+ case font_name_code:
+ case font_id_code:
+ scan_font_ident();
+ break;
+ case pdftex_revision_code:
+ case luatex_revision_code:
+ case luatex_date_code:
+ case pdftex_banner_code:
+ break;
+ case pdf_font_name_code:
+ case pdf_font_objnum_code:
+ case pdf_font_size_code:
+ scan_font_ident();
+ if (cur_val == null_font)
+ pdf_error("font", "invalid font identifier");
+ if (c != pdf_font_size_code) {
+ pdf_check_vf(cur_val);
+ if (!font_used(cur_val))
+ pdf_init_font(static_pdf, cur_val);
+ }
+ break;
+ case pdf_page_ref_code:
+ scan_int();
+ if (cur_val <= 0)
+ pdf_error("pageref", "invalid page number");
+ break;
+ case left_margin_kern_code:
+ case right_margin_kern_code:
+ scan_int();
+ if ((box(cur_val) == null) || (type(box(cur_val)) != hlist_node))
+ pdf_error("marginkern", "a non-empty hbox expected");
+ break;
+ case pdf_xform_name_code:
+ scan_int();
+ check_obj_type(static_pdf, obj_type_xform, cur_val);
+ break;
+ case pdf_creation_date_code:
+ ins_list(string_to_toks(getcreationdate(static_pdf)));
+ return;
+ break;
+ case format_name_code:
+ case job_name_code:
+ if (job_name == 0)
+ open_log_file();
+ break;
+ case pdf_colorstack_init_code:
+ bool = scan_keyword("page");
+ if (scan_keyword("direct"))
+ cur_val = direct_always;
+ else if (scan_keyword("page"))
+ cur_val = direct_page;
+ else
+ cur_val = set_origin;
+ save_scanner_status = scanner_status;
+ save_warning_index = warning_index;
+ save_def_ref = def_ref;
+ u = save_cur_string();
+ scan_pdf_ext_toks();
+ s = tokens_to_string(def_ref);
+ delete_token_ref(def_ref);
+ def_ref = save_def_ref;
+ warning_index = save_warning_index;
+ scanner_status = save_scanner_status;
+ cur_val = newcolorstack(s, cur_val, bool);
+ flush_str(s);
+ cur_val_level = int_val_level;
+ if (cur_val < 0) {
+ print_err("Too many color stacks");
+ help2("The number of color stacks is limited to 32768.",
+ "I'll use the default color stack 0 here.");
+ error();
+ cur_val = 0;
+ restore_cur_string(u);
+ }
+ break;
+ case uniform_deviate_code:
+ scan_int();
+ break;
+ case normal_deviate_code:
+ break;
+ case lua_escape_string_code:
+ {
+ lstring escstr;
+ int l = 0;
+ save_scanner_status = scanner_status;
+ save_def_ref = def_ref;
+ save_warning_index = warning_index;
+ scan_pdf_ext_toks();
+ bool = in_lua_escape;
+ in_lua_escape = true;
+ escstr.s = (unsigned char *) tokenlist_to_cstring(def_ref, false, &l);
+ escstr.l = (unsigned) l;
+ in_lua_escape = bool;
+ delete_token_ref(def_ref);
+ def_ref = save_def_ref;
+ warning_index = save_warning_index;
+ scanner_status = save_scanner_status;
+ (void) lua_str_toks(escstr);
+ ins_list(token_link(temp_token_head));
+ free(escstr.s);
+ return;
+ }
+ break;
+ case math_style_code:
+ break;
+ case expanded_code:
+ save_scanner_status = scanner_status;
+ save_warning_index = warning_index;
+ save_def_ref = def_ref;
+ u = save_cur_string();
+ scan_pdf_ext_toks();
+ warning_index = save_warning_index;
+ scanner_status = save_scanner_status;
+ ins_list(token_link(def_ref));
+ def_ref = save_def_ref;
+ restore_cur_string(u);
+ return;
+ break;
+ case lua_code:
+ u = save_cur_string();
+ save_scanner_status = scanner_status;
+ save_def_ref = def_ref;
+ save_warning_index = warning_index;
+ sn = scan_lua_state();
+ scan_pdf_ext_toks();
+ s = def_ref;
+ warning_index = save_warning_index;
+ def_ref = save_def_ref;
+ scanner_status = save_scanner_status;
+ luacstrings = 0;
+ luatokencall(s, sn);
+ delete_token_ref(s);
+ restore_cur_string(u); /* TODO: check this, was different */
+ if (luacstrings > 0)
+ lua_string_start();
+ return;
+ break;
+ case pdf_insert_ht_code:
+ scan_register_num();
+ break;
+ case pdf_ximage_bbox_code:
+ scan_int();
+ check_obj_type(static_pdf, obj_type_ximage, cur_val);
+ i = obj_data_ptr(static_pdf, cur_val);
+ scan_int();
+ j = cur_val;
+ if ((j < 1) || (j > 4))
+ pdf_error("pdfximagebbox", "invalid parameter");
+ break;
+ /* Cases of 'Scan the argument for command |c|' */
+ case eTeX_revision_code:
+ break;
+ default:
+ confusion("convert");
+ break;
+ }
+
+ old_setting = selector;
+ selector = new_string;
+
+ /* Print the result of command |c| */
+ if (!print_convert_string(c, cur_val)) {
+ switch (c) {
+ case string_code:
+ if (cur_cs != 0)
+ sprint_cs(cur_cs);
+ else
+ print(cur_chr);
+ break;
+ case meaning_code:
+ print_meaning();
+ break;
+ case left_margin_kern_code:
+ p = list_ptr(box(cur_val));
+ if ((p != null) && (!is_char_node(p)) &&
+ (type(p) == glue_node) && (subtype(p) == left_skip_code + 1))
+ p = vlink(p);
+ if ((p != null) && (!is_char_node(p)) &&
+ (type(p) == margin_kern_node) && (subtype(p) == left_side))
+ print_scaled(width(p));
+ else
+ print_char('0');
+ tprint("pt");
+ break;
+ case right_margin_kern_code:
+ q = list_ptr(box(cur_val));
+ p = null;
+ if (q != null) {
+ p = prev_rightmost(q, null);
+ if ((p != null) && (!is_char_node(p)) && (type(p) == glue_node)
+ && (subtype(p) == right_skip_code + 1))
+ p = prev_rightmost(q, p);
+ }
+ if ((p != null) && (!is_char_node(p)) &&
+ (type(p) == margin_kern_node) && (subtype(p) == right_side))
+ print_scaled(width(p));
+ else
+ print_char('0');
+ tprint("pt");
+ break;
+ case pdf_colorstack_init_code:
+ print_int(cur_val);
+ break;
+ case pdf_insert_ht_code:
+ i = cur_val;
+ p = page_ins_head;
+ while (i >= subtype(vlink(p)))
+ p = vlink(p);
+ if (subtype(p) == i)
+ print_scaled(height(p));
+ else
+ print_char('0');
+ tprint("pt");
+ break;
+ case pdf_ximage_bbox_code:
+ if (is_pdf_image(i)) {
+ switch (j) {
+ case 1:
+ print_scaled(epdf_orig_x(i));
+ break;
+ case 2:
+ print_scaled(epdf_orig_y(i));
+ break;
+ case 3:
+ print_scaled(epdf_orig_x(i) + epdf_xsize(i));
+ break;
+ case 4:
+ print_scaled(epdf_orig_y(i) + epdf_ysize(i));
+ break;
+ }
+ } else {
+ print_scaled(0);
+ }
+ tprint("pt");
+ break;
+ case pdf_creation_date_code:
+ case lua_escape_string_code:
+ case lua_code:
+ case expanded_code:
+ break;
+ default:
+ confusion("convert");
+ break;
+ }
+ }
+
+ selector = old_setting;
+ str = make_string();
+ (void) str_toks(str_lstring(str));
+ flush_str(str);
+ ins_list(token_link(temp_token_head));
+}
+
+@ This boolean is keeping track of the lua string escape state
+@c
+boolean in_lua_escape;
+
+@ probably not needed anymore
+@c
+boolean is_convert(halfword c)
+{
+ return (c == convert_cmd);
+}
+
+str_number the_convert_string(halfword c, int i)
+{
+ int old_setting; /* saved |selector| setting */
+ str_number ret = 0;
+ old_setting = selector;
+ selector = new_string;
+ if (print_convert_string(c, i)) {
+ ret = make_string();
+ } else if (c == font_identifier_code) {
+ print_font_identifier(i);
+ ret = make_string();
+ }
+ selector = old_setting;
+ 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.
+
+@c
+FILE *read_file[16]; /* used for \.{\\read} */
+int read_open[17]; /* state of |read_file[n]| */
+
+void initialize_read(void)
+{
+ int k;
+ for (k = 0; k <= 16; k++)
+ 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.
+
+@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 */
+ 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 */
+ 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. */
+ do {
+ /* 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 */
+ /* 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) {
+ prompt_input("");
+ } else {
+ wake_up_terminal();
+ print_ln();
+ sprint_cs(r);
+ prompt_input(" =");
+ n = -1;
+ }
+ } else {
+ fatal_error
+ ("*** (cannot \\read from terminal in nonstop modes)");
+ }
+
+ } else if (read_open[m] == just_open) {
+ /* 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|. */
+ if (lua_input_ln(read_file[m], (m + 1), false)) {
+ read_open[m] = normal;
+ } else {
+ lua_a_close_in(read_file[m], (m + 1));
+ read_open[m] = closed;
+ }
+
+ } else {
+ /* Input the next line of |read_file[m]| */
+ /* 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));
+ read_open[m] = closed;
+ if (align_state != 1000000) {
+ runaway();
+ print_err("File ended within \\read");
+ help1("This \\read has unbalanced braces.");
+ align_state = 1000000;
+ error();
+ }
+ }
+
+ }
+ ilimit = last;
+ if (end_line_char_inactive())
+ decr(ilimit);
+ else
+ buffer[ilimit] = (packed_ASCII_code) int_par(end_line_char_code);
+ first = ilimit + 1;
+ iloc = istart;
+ istate = new_line;
+ /* Handle \.{\\readline} and |goto done|; */
+ if (j == 1) {
+ while (iloc <= ilimit) { /* current line not yet finished */
+ do_buffer_to_unichar(cur_chr, iloc);
+ if (cur_chr == ' ')
+ cur_tok = space_token;
+ else
+ cur_tok = cur_chr + other_token;
+ store_new_token(cur_tok);
+ }
+ } else {
+ while (1) {
+ get_token();
+ if (cur_tok == 0)
+ break; /* |cur_cmd=cur_chr=0| will occur at the end of the line */
+ if (align_state < 1000000) { /* unmatched `\.\}' aborts the line */
+ do {
+ get_token();
+ } while (cur_tok != 0);
+ align_state = 1000000;
+ break;
+ }
+ store_new_token(cur_tok);
+ }
+ }
+ end_file_reading();
+
+ } while (align_state != 1000000);
+ cur_val = def_ref;
+ scanner_status = normal;
+ align_state = s;
+}
+
+@ @c
+str_number tokens_to_string(halfword p)
+{ /* return a string from tokens list */
+ int old_setting;
+ if (selector == new_string)
+ pdf_error("tokens",
+ "tokens_to_string() called while selector = new_string");
+ old_setting = selector;
+ selector = new_string;
+ show_token_list(token_link(p), null, -1);
+ selector = old_setting;
+ return make_string();
+}
+
+@ @c
+#define make_room(a) \
+ if ((unsigned)i+a+1>alloci) { \
+ ret = xrealloc(ret,(alloci+64)); \
+ alloci = alloci + 64; \
+ }
+
+
+#define append_i_byte(a) ret[i++] = (char)(a)
+
+#define Print_char(a) make_room(1); append_i_byte(a)
+
+#define Print_uchar(s) { \
+ make_room(4); \
+ if (s<=0x7F) { \
+ append_i_byte(s); \
+ } else if (s<=0x7FF) { \
+ append_i_byte(0xC0 + (s / 0x40)); \
+ append_i_byte(0x80 + (s % 0x40)); \
+ } else if (s<=0xFFFF) { \
+ append_i_byte(0xE0 + (s / 0x1000)); \
+ append_i_byte(0x80 + ((s % 0x1000) / 0x40)); \
+ append_i_byte(0x80 + ((s % 0x1000) % 0x40)); \
+ } else if (s>=0x110000) { \
+ append_i_byte(s-0x11000); \
+ } else { \
+ append_i_byte(0xF0 + (s / 0x40000)); \
+ append_i_byte(0x80 + ((s % 0x40000) / 0x1000)); \
+ append_i_byte(0x80 + (((s % 0x40000) % 0x1000) / 0x40)); \
+ append_i_byte(0x80 + (((s % 0x40000) % 0x1000) % 0x40)); \
+ } }
+
+
+#define Print_esc(b) { \
+ const char *v = b; \
+ if (e>0 && e<STRING_OFFSET) { \
+ Print_uchar (e); \
+ } \
+ make_room(strlen(v)); \
+ while (*v) { append_i_byte(*v); v++; } \
+ }
+
+#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.
+
+@c
+char *tokenlist_to_cstring(int pp, int inhibit_par, int *siz)
+{
+ register int p, c, m;
+ int q;
+ int infop;
+ char *s, *sh;
+ int e = 0;
+ char *ret;
+ int match_chr = '#';
+ int n = '0';
+ unsigned alloci = 1024;
+ int i = 0;
+ p = pp;
+ if (p == null) {
+ if (siz != NULL)
+ *siz = 0;
+ return NULL;
+ }
+ ret = xmalloc(alloci);
+ p = token_link(p); /* skip refcount */
+ if (p != null) {
+ e = int_par(escape_char_code);
+ }
+ while (p != null) {
+ if (p < (int) fix_mem_min || p > (int) fix_mem_end) {
+ Print_esc("CLOBBERED.");
+ break;
+ }
+ infop = token_info(p);
+ if (infop >= cs_token_flag) {
+ if (!(inhibit_par && infop == par_token)) {
+ q = infop - cs_token_flag;
+ if (q < hash_base) {
+ if (q == null_cs) {
+ Print_esc("csname");
+ Print_esc("endcsname");
+ } else {
+ Print_esc("IMPOSSIBLE.");
+ }
+ } else if ((q >= undefined_control_sequence)
+ && ((q <= eqtb_size)
+ || (q > eqtb_size + hash_extra))) {
+ Print_esc("IMPOSSIBLE.");
+ } else if ((cs_text(q) < 0) || (cs_text(q) >= str_ptr)) {
+ Print_esc("NONEXISTENT.");
+ } else {
+ str_number txt = cs_text(q);
+ sh = makecstring(txt);
+ s = sh;
+ if (is_active_cs(txt)) {
+ s = s + 3;
+ while (*s) {
+ Print_char(*s);
+ s++;
+ }
+ } else {
+ Print_uchar(e);
+ while (*s) {
+ Print_char(*s);
+ s++;
+ }
+ if ((!single_letter(txt)) || is_cat_letter(txt)) {
+ Print_char(' ');
+ }
+ }
+ free(sh);
+ }
+ }
+ } else {
+ if (infop < 0) {
+ Print_esc("BAD.");
+ } else {
+ m = token_cmd(infop);
+ c = token_chr(infop);
+ switch (m) {
+ case left_brace_cmd:
+ case right_brace_cmd:
+ case math_shift_cmd:
+ case tab_mark_cmd:
+ case sup_mark_cmd:
+ case sub_mark_cmd:
+ case spacer_cmd:
+ case letter_cmd:
+ case other_char_cmd:
+ Print_uchar(c);
+ break;
+ case mac_param_cmd:
+ if (!in_lua_escape)
+ Print_uchar(c);
+ Print_uchar(c);
+ break;
+ case out_param_cmd:
+ Print_uchar(match_chr);
+ if (c <= 9) {
+ Print_char(c + '0');
+ } else {
+ Print_char('!');
+ goto EXIT;
+ }
+ break;
+ case match_cmd:
+ match_chr = c;
+ Print_uchar(c);
+ n++;
+ Print_char(n);
+ if (n > '9')
+ goto EXIT;
+ break;
+ case end_match_cmd:
+ if (c == 0) {
+ Print_char('-');
+ Print_char('>');
+ }
+ break;
+ default:
+ Print_esc("BAD.");
+ break;
+ }
+ }
+ }
+ p = token_link(p);
+ }
+ EXIT:
+ ret[i] = '\0';
+ if (siz != NULL)
+ *siz = i;
+ return ret;
+}
+
+@ @c
+lstring *tokenlist_to_lstring(int pp, int inhibit_par)
+{
+ int siz;
+ lstring *ret = xmalloc(sizeof(lstring));
+ ret->s = (unsigned char *) tokenlist_to_cstring(pp, inhibit_par, &siz);
+ ret->l = (size_t) siz;
+ return ret;
+}
+
+@ @c
+void free_lstring(lstring * ls)
+{
+ if (ls == NULL)
+ return;
+ if (ls->s != NULL)
+ free(ls->s);
+ free(ls);
+}
|