diff options
Diffstat (limited to 'Build/source/texk/web2c/luatexdir/tex/mathcodes.c')
-rw-r--r-- | Build/source/texk/web2c/luatexdir/tex/mathcodes.c | 360 |
1 files changed, 360 insertions, 0 deletions
diff --git a/Build/source/texk/web2c/luatexdir/tex/mathcodes.c b/Build/source/texk/web2c/luatexdir/tex/mathcodes.c new file mode 100644 index 00000000000..42e8b0b15b9 --- /dev/null +++ b/Build/source/texk/web2c/luatexdir/tex/mathcodes.c @@ -0,0 +1,360 @@ +/* + +mathnodes.w + +Copyright 2006-2010 Taco Hoekwater <taco@@luatex.org> + +This file is part of LuaTeX. + +LuaTeX is free software; you can redistribute it and/or modify it under +the terms of the GNU General Public License as published by the Free +Software Foundation; either version 2 of the License, or (at your +option) any later version. + +LuaTeX is distributed in the hope that it will be useful, but WITHOUT +ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or +FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public +License for more details. + +You should have received a copy of the GNU General Public License along +with LuaTeX; if not, see <http://www.gnu.org/licenses/>. + +*/ + +#include "ptexlib.h" + +/*tex + +We support tre traditional math codes as well as larger ones suitable for +\UNICODE\ input and fonts. + +*/ + +static sa_tree mathcode_head = NULL; + +/*tex the |0xFFFFFFFF| is a flag value. */ + +#define MATHCODESTACK 8 +#define MATHCODEDEFAULT 0xFFFFFFFF +#define MATHCODEACTIVE 0xFFFFFFFE + +/*tex + +Delcodes are also went larger. + +*/ + +static sa_tree delcode_head = NULL; + +#define DELCODESTACK 4 +#define DELCODEDEFAULT 0xFFFFFFFF + +/*tex + +We now get lots of helpers for definitions and printing. The storage model +that we use is different because we can hav emany more so we need to be +sparse. Therefore we use trees. + +*/ + + +#define print_hex_digit(A) do { \ + if ((A)>=10) print_char('A'+(A)-10); \ + else print_char('0'+(A)); \ + } while (0) + +#define two_hex(A) do { \ + print_hex_digit((A)/16); \ + print_hex_digit((A)%16); \ + } while (0) + +#define four_hex(A) do { \ + two_hex((A)/256); \ + two_hex((A)%256); \ + } while (0) + +#define six_hex(A) do { \ + two_hex((A)/65536); \ + two_hex(((A)%65536)/256); \ + two_hex((A)%256); \ + } while (0) + +mathcodeval mathchar_from_integer(int value, int extcode) +{ + mathcodeval mval; + if (extcode == tex_mathcode) { + mval.class_value = (value / 0x1000); + mval.family_value = ((value % 0x1000) / 0x100); + mval.character_value = (value % 0x100); + } else { + int mfam = (value / 0x200000) & 0x7FF; + mval.class_value = mfam % 0x08; + mval.family_value = mfam / 0x08; + mval.character_value = value & 0x1FFFFF; + } + return mval; +} + +void show_mathcode_value_old(int value) +{ + print_char('"'); + four_hex(value); +} + +void show_mathcode_value(mathcodeval c) +{ + print_char('"'); + print_hex_digit(c.class_value); + print_char('"'); + two_hex(c.family_value); + print_char('"'); + six_hex(c.character_value); +} + +static void show_mathcode(int n) +{ + mathcodeval c = get_math_code(n); + tprint_esc("Umathcode"); + print_int(n); + print_char('='); + show_mathcode_value(c); +} + +static void unsavemathcode(quarterword gl) +{ + sa_stack_item st; + if (mathcode_head->stack == NULL) + return; + while (mathcode_head->stack_ptr > 0 && abs(mathcode_head->stack[mathcode_head->stack_ptr].level) >= gl) { + st = mathcode_head->stack[mathcode_head->stack_ptr]; + if (st.level > 0) { + rawset_sa_item(mathcode_head, st.code, st.value); + if (tracing_restores_par > 1) { + begin_diagnostic(); + print_char('{'); + tprint("restoring"); + print_char(' '); + show_mathcode(st.code); + print_char('}'); + end_diagnostic(false); + } + } + (mathcode_head->stack_ptr)--; + } +} + +void set_math_code(int n, int mathclass, int mathfamily, int mathcharacter, quarterword level) +{ + sa_tree_item v; + if (mathclass == 8 && mathfamily == 0 && mathcharacter == 0) { + v.uint_value = MATHCODEACTIVE; + } else { + v.math_code_value.class_value = mathclass; + v.math_code_value.family_value = mathfamily; + v.math_code_value.character_value = mathcharacter; + } + set_sa_item(mathcode_head, n, v, level); + if (tracing_assigns_par > 1) { + begin_diagnostic(); + print_char('{'); + tprint("assigning"); + print_char(' '); + show_mathcode(n); + print_char('}'); + end_diagnostic(false); + } +} + +mathcodeval get_math_code(int n) +{ + mathcodeval d; + sa_tree_item v = get_sa_item(mathcode_head, n); + if (v.uint_value == MATHCODEDEFAULT) { + d.class_value = 0; + d.family_value = 0; + d.character_value = n; + } else if (v.uint_value == MATHCODEACTIVE) { + d.class_value = 8; + d.family_value = 0; + d.character_value = 0; + } else { + d.class_value = v.math_code_value.class_value; + if (d.class_value == 8) { + d.family_value = 0; + d.character_value = n; + } else { + d.family_value = v.math_code_value.family_value; + d.character_value = v.math_code_value.character_value; + } + } + return d; +} + +int get_math_code_num(int n) +{ + mathcodeval d = get_math_code(n); + return (d.class_value + (d.family_value * 8)) * (65536 * 32) + d.character_value; +} + +static void initializemathcode(void) +{ + sa_tree_item sa_value = { 0 }; + sa_value.uint_value = MATHCODEDEFAULT; + mathcode_head = new_sa_tree(MATHCODESTACK, 1, sa_value); +} + +static void dumpmathcode(void) +{ + dump_sa_tree(mathcode_head,"mathcodes"); +} + +static void undumpmathcode(void) +{ + mathcode_head = undump_sa_tree("mathcodes"); +} + +static void show_delcode(int n) +{ + delcodeval c; + c = get_del_code(n); + tprint_esc("Udelcode"); + print_int(n); + print_char('='); + if (c.small_family_value < 0) { + print_char('-'); + print_char('1'); + } else { + print_char('"'); + two_hex(c.small_family_value); + six_hex(c.small_character_value); + } +} + +static void unsavedelcode(quarterword gl) +{ + sa_stack_item st; + if (delcode_head->stack == NULL) + return; + while (delcode_head->stack_ptr > 0 && abs(delcode_head->stack[delcode_head->stack_ptr].level) >= gl) { + st = delcode_head->stack[delcode_head->stack_ptr]; + if (st.level > 0) { + rawset_sa_item(delcode_head, st.code, st.value); + if (tracing_restores_par > 1) { + begin_diagnostic(); + print_char('{'); + tprint("restoring"); + print_char(' '); + show_delcode(st.code); + print_char('}'); + end_diagnostic(false); + } + } + (delcode_head->stack_ptr)--; + } +} + +void set_del_code(int n, int smathfamily, int smathcharacter, int lmathfamily, int lmathcharacter, quarterword gl) +{ + sa_tree_item v; + v.del_code_value.class_value = 0; + v.del_code_value.small_family_value = smathfamily; + v.del_code_value.small_character_value = smathcharacter; + v.del_code_value.dummy_value = 0; + v.del_code_value.large_family_value = lmathfamily; + v.del_code_value.large_character_value = lmathcharacter; + /*tex Always global! */ + set_sa_item(delcode_head, n, v, gl); + if (tracing_assigns_par > 1) { + begin_diagnostic(); + print_char('{'); + tprint("assigning"); + print_char(' '); + show_delcode(n); + print_char('}'); + end_diagnostic(false); + } +} + +delcodeval get_del_code(int n) +{ + delcodeval d; + sa_tree_item v = get_sa_item(delcode_head, n); + if (v.uint_value == DELCODEDEFAULT) { + d.class_value = 0; + d.small_family_value = -1; + d.small_character_value = 0; + d.large_family_value = 0; + d.large_character_value = 0; + } else { + d.class_value = v.del_code_value.class_value; + d.small_family_value = v.del_code_value.small_family_value; + d.small_character_value = v.del_code_value.small_character_value; + d.large_family_value = v.del_code_value.large_family_value; + d.large_character_value = v.del_code_value.large_character_value; + } + return d; +} + +/*tex + +This really only works for old-style delcodes! + +*/ + +int get_del_code_num(int n) +{ + delcodeval d = get_del_code(n); + if (d.small_family_value < 0) { + return -1; + } else { + return ((d.small_family_value * 256 + d.small_character_value) * 4096 + + (d.large_family_value * 256) + d.large_character_value); + } +} + +static void initializedelcode(void) +{ + sa_tree_item sa_value = { 0 }; + sa_value.uint_value = DELCODEDEFAULT; + delcode_head = new_sa_tree(DELCODESTACK, 2, sa_value); +} + +static void dumpdelcode(void) +{ + dump_sa_tree(delcode_head,"delcodes"); +} + +static void undumpdelcode(void) +{ + delcode_head = undump_sa_tree("delcodes"); +} + +void unsave_math_codes(quarterword grouplevel) +{ + unsavemathcode(grouplevel); + unsavedelcode(grouplevel); +} + +void initialize_math_codes(void) +{ + initializemathcode(); + initializedelcode(); +} + +void free_math_codes(void) +{ + destroy_sa_tree(mathcode_head); + destroy_sa_tree(delcode_head); +} + +void dump_math_codes(void) +{ + dumpmathcode(); + dumpdelcode(); +} + +void undump_math_codes(void) +{ + undumpmathcode(); + undumpdelcode(); +} |