summaryrefslogtreecommitdiff
path: root/Build/source/texk/web2c/luatexdir/tex/mathcodes.w
diff options
context:
space:
mode:
Diffstat (limited to 'Build/source/texk/web2c/luatexdir/tex/mathcodes.w')
-rw-r--r--Build/source/texk/web2c/luatexdir/tex/mathcodes.w508
1 files changed, 508 insertions, 0 deletions
diff --git a/Build/source/texk/web2c/luatexdir/tex/mathcodes.w b/Build/source/texk/web2c/luatexdir/tex/mathcodes.w
new file mode 100644
index 00000000000..ef5772b6b33
--- /dev/null
+++ b/Build/source/texk/web2c/luatexdir/tex/mathcodes.w
@@ -0,0 +1,508 @@
+% 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/>.
+
+@ @c
+#include "ptexlib.h"
+
+static const char _svn_version[] =
+ "$Id: mathcodes.w 3587 2010-04-03 14:32:25Z taco $ "
+ "$URL: http://foundry.supelec.fr/svn/luatex/tags/beta-0.60.0/source/texk/web2c/luatexdir/tex/mathcodes.w $";
+
+@ math codes
+@c
+static sa_tree mathcode_head = NULL;
+
+#define MATHCODEHEAP 8
+
+static mathcodeval *mathcode_heap = NULL;
+static int mathcode_heapsize = MATHCODEHEAP;
+static int mathcode_heapptr = 0;
+
+/* the 0xFFFFFFFF is a flag value */
+#define MATHCODESTACK 8
+#define MATHCODEDEFAULT 0xFFFFFFFF
+
+@ delcodes
+@c
+static sa_tree delcode_head = NULL;
+
+#define DELCODEHEAP 8
+
+static delcodeval *delcode_heap = NULL;
+static int delcode_heapsize = DELCODEHEAP;
+static int delcode_heapptr = 0;
+
+#define DELCODESTACK 4
+#define DELCODEDEFAULT 0xFFFFFFFF
+
+@ some helpers for mathcode printing
+
+@c
+#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)
+
+@ @c
+void show_mathcode_value(mathcodeval c)
+{
+ if (c.origin_value == aleph_mathcode) {
+ print_char('"');
+ print_hex_digit(c.class_value);
+ two_hex(c.family_value);
+ four_hex(c.character_value);
+ } else if (c.origin_value == xetex_mathcode) {
+ print_char('"');
+ print_hex_digit(c.class_value);
+ print_char('"');
+ two_hex(c.family_value);
+ print_char('"');
+ six_hex(c.character_value);
+ } else if (c.origin_value == xetexnum_mathcode) {
+ int m;
+ m = (c.class_value + (c.family_value * 8)) * 2097152 +
+ c.character_value;
+ print_int(m);
+ } else {
+ print_char('"');
+ print_hex_digit(c.class_value);
+ print_hex_digit(c.family_value);
+ two_hex(c.character_value);
+ }
+}
+
+@ @c
+void show_mathcode(int n)
+{
+ mathcodeval c = get_math_code(n);
+ if (c.origin_value == aleph_mathcode) {
+ tprint_esc("omathcode");
+ } else if (c.origin_value == xetex_mathcode) {
+ tprint_esc("Umathcode");
+ } else if (c.origin_value == xetexnum_mathcode) {
+ tprint_esc("Umathcodenum");
+ } else {
+ tprint_esc("mathcode");
+ }
+ print_int(n);
+ print_char('=');
+ show_mathcode_value(c);
+}
+
+@ @c
+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)
+ >= (int) gl) {
+ st = mathcode_head->stack[mathcode_head->stack_ptr];
+ if (st.level > 0) {
+ rawset_sa_item(mathcode_head, st.code, st.value);
+ /* now do a trace message, if requested */
+ if (int_par(tracing_restores_code) > 0) {
+ begin_diagnostic();
+ print_char('{');
+ tprint("restoring");
+ print_char(' ');
+ show_mathcode(st.code);
+ print_char('}');
+ end_diagnostic(false);
+ }
+ }
+ (mathcode_head->stack_ptr)--;
+ }
+}
+
+@ @c
+void set_math_code(int n,
+ int commandorigin,
+ int mathclass,
+ int mathfamily, int mathcharacter, quarterword level)
+{
+ mathcodeval d;
+ d.origin_value = commandorigin;
+ d.class_value = mathclass;
+ d.family_value = mathfamily;
+ d.character_value = mathcharacter;
+ if (mathcode_heapptr == mathcode_heapsize) {
+ mathcode_heapsize += MATHCODEHEAP;
+ mathcode_heap =
+ Mxrealloc_array(mathcode_heap, mathcodeval, mathcode_heapsize);
+ }
+ mathcode_heap[mathcode_heapptr] = d;
+ set_sa_item(mathcode_head, n, (sa_tree_item) mathcode_heapptr, level);
+ mathcode_heapptr++;
+ if (int_par(tracing_assigns_code) > 0) {
+ begin_diagnostic();
+ print_char('{');
+ tprint("assigning");
+ print_char(' ');
+ show_mathcode(n);
+ print_char('}');
+ end_diagnostic(false);
+ }
+}
+
+@ @c
+mathcodeval get_math_code(int n)
+{
+ unsigned int ret;
+ ret = get_sa_item(mathcode_head, n);
+ if (ret == MATHCODEDEFAULT) {
+ mathcodeval d;
+ d.class_value = 0;
+ d.family_value = 0;
+ d.origin_value = (n < 256 ? tex_mathcode :
+ (n < 65536 ? aleph_mathcode : xetex_mathcode));
+ d.character_value = n;
+ return d;
+ } else {
+ return mathcode_heap[ret];
+ }
+}
+
+
+@ @c
+int get_math_code_num(int n)
+{
+ mathcodeval mval;
+ mval = get_math_code(n);
+ if (mval.origin_value == tex_mathcode) {
+ return (mval.class_value * 16 + mval.family_value) * 256 +
+ mval.character_value;
+ } else if (mval.origin_value == aleph_mathcode) {
+ return (mval.class_value * 256 + mval.family_value) * 65536 +
+ mval.character_value;
+ } else if (mval.origin_value == xetexnum_mathcode
+ || mval.origin_value == xetex_mathcode) {
+ return (mval.class_value + (mval.family_value * 8)) * (65536 * 32) +
+ mval.character_value;
+ }
+ return 0;
+}
+
+@ @c
+void initializemathcode(void)
+{
+ mathcode_head = new_sa_tree(MATHCODESTACK, MATHCODEDEFAULT);
+ mathcode_heap = Mxmalloc_array(mathcodeval, MATHCODEHEAP);
+}
+
+@ @c
+void dumpmathcode(void)
+{
+ int k;
+ mathcodeval d;
+ dump_sa_tree(mathcode_head);
+ dump_int(mathcode_heapsize);
+ dump_int(mathcode_heapptr);
+ for (k = 0; k < mathcode_heapptr; k++) {
+ d = mathcode_heap[k];
+ dump_int(d.origin_value);
+ dump_int(d.class_value);
+ dump_int(d.family_value);
+ dump_int(d.character_value);
+ }
+}
+
+void undumpmathcode(void)
+{
+ int k, x;
+ mathcodeval d;
+ mathcode_head = undump_sa_tree();
+ undump_int(mathcode_heapsize);
+ undump_int(mathcode_heapptr);
+ mathcode_heap = Mxmalloc_array(mathcodeval, mathcode_heapsize);
+ for (k = 0; k < mathcode_heapptr; k++) {
+ undump_int(x);
+ d.origin_value = x;
+ undump_int(x);
+ d.class_value = x;
+ undump_int(x);
+ d.family_value = x;
+ undump_int(x);
+ d.character_value = x;
+ mathcode_heap[k] = d;
+ }
+ d.origin_value = 0;
+ d.class_value = 0;
+ d.family_value = 0;
+ d.character_value = 0;
+ for (k = mathcode_heapptr; k < mathcode_heapsize; k++) {
+ mathcode_heap[k] = d;
+ }
+}
+
+@ @c
+void show_delcode(int n)
+{
+ delcodeval c;
+ c = get_del_code(n);
+ if (c.origin_value == tex_mathcode) {
+ tprint_esc("delcode");
+ } else if (c.origin_value == aleph_mathcode) {
+ tprint_esc("odelcode");
+ } else if (c.origin_value == xetex_mathcode) {
+ tprint_esc("Udelcode");
+ } else if (c.origin_value == xetexnum_mathcode) {
+ tprint_esc("Udelcodenum");
+ }
+ print_int(n);
+ print_char('=');
+ if (c.small_family_value < 0) {
+ print_char('-');
+ print_char('1');
+ } else {
+ if (c.origin_value == tex_mathcode) {
+ print_char('"');
+ print_hex_digit(c.small_family_value);
+ two_hex(c.small_character_value);
+ print_hex_digit(c.large_family_value);
+ two_hex(c.large_character_value);
+ } else if (c.origin_value == aleph_mathcode) {
+ print_char('"');
+ two_hex(c.small_family_value);
+ four_hex(c.small_character_value);
+ print_char('"');
+ two_hex(c.large_family_value);
+ four_hex(c.large_character_value);
+ } else if (c.origin_value == xetex_mathcode) {
+ print_char('"');
+ two_hex(c.small_family_value);
+ six_hex(c.small_character_value);
+ } else if (c.origin_value == xetexnum_mathcode) {
+ int m;
+ m = c.small_family_value * 2097152 + c.small_character_value;
+ print_int(m);
+ }
+ }
+}
+
+
+
+@ TODO: clean up the heap
+@c
+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)
+ >= (int) gl) {
+ st = delcode_head->stack[delcode_head->stack_ptr];
+ if (st.level > 0) {
+ rawset_sa_item(delcode_head, st.code, st.value);
+ /* now do a trace message, if requested */
+ if (int_par(tracing_restores_code) > 0) {
+ begin_diagnostic();
+ print_char('{');
+ tprint("restoring");
+ print_char(' ');
+ show_delcode(st.code);
+ print_char('}');
+ end_diagnostic(false);
+ }
+ }
+ (delcode_head->stack_ptr)--;
+ }
+
+}
+
+@ @c
+void set_del_code(int n,
+ int commandorigin,
+ int smathfamily,
+ int smathcharacter,
+ int lmathfamily, int lmathcharacter, quarterword gl)
+{
+ delcodeval d;
+ d.class_value = 0;
+ d.origin_value = commandorigin;
+ d.small_family_value = smathfamily;
+ d.small_character_value = smathcharacter;
+ d.large_family_value = lmathfamily;
+ d.large_character_value = lmathcharacter;
+ if (delcode_heapptr == delcode_heapsize) {
+ delcode_heapsize += DELCODEHEAP;
+ delcode_heap =
+ Mxrealloc_array(delcode_heap, delcodeval, delcode_heapsize);
+ }
+ delcode_heap[delcode_heapptr] = d;
+ set_sa_item(delcode_head, n, (sa_tree_item) delcode_heapptr, gl);
+ if (int_par(tracing_assigns_code) > 0) {
+ begin_diagnostic();
+ print_char('{');
+ tprint("assigning");
+ print_char(' ');
+ show_delcode(n);
+ print_char('}');
+ end_diagnostic(false);
+ }
+ delcode_heapptr++;
+}
+
+@ @c
+delcodeval get_del_code(int n)
+{
+ unsigned ret;
+ ret = get_sa_item(delcode_head, n);
+ if (ret == DELCODEDEFAULT) {
+ delcodeval d;
+ d.class_value = 0;
+ d.origin_value = tex_mathcode;
+ d.small_family_value = -1;
+ d.small_character_value = 0;
+ d.large_family_value = 0;
+ d.large_character_value = 0;
+ return d;
+ } else {
+ return delcode_heap[ret];
+ }
+}
+
+@ this really only works for old-style delcodes!
+
+@c
+int get_del_code_num(int n)
+{
+ unsigned ret;
+ ret = get_sa_item(delcode_head, n);
+ if (ret == DELCODEDEFAULT) {
+ return -1;
+ } else {
+ delcodeval d = delcode_heap[ret];
+ if (d.origin_value == tex_mathcode) {
+ return ((d.small_family_value * 256 +
+ d.small_character_value) * 4096 +
+ (d.large_family_value * 256) + d.large_character_value);
+ } else {
+ return -1;
+ }
+ }
+}
+
+@ @c
+void initializedelcode(void)
+{
+ delcode_head = new_sa_tree(DELCODESTACK, DELCODEDEFAULT);
+ delcode_heap = Mxmalloc_array(delcodeval, DELCODEHEAP);
+}
+
+@ @c
+void dumpdelcode(void)
+{
+ int k;
+ delcodeval d;
+ dump_sa_tree(delcode_head);
+ dump_int(delcode_heapsize);
+ dump_int(delcode_heapptr);
+ for (k = 0; k < delcode_heapptr; k++) {
+ d = delcode_heap[k];
+ dump_int(d.origin_value);
+ dump_int(d.class_value);
+ dump_int(d.small_family_value);
+ dump_int(d.small_character_value);
+ dump_int(d.large_family_value);
+ dump_int(d.large_character_value);
+ }
+}
+
+void undumpdelcode(void)
+{
+ int k;
+ delcodeval d;
+ delcode_head = undump_sa_tree();
+ undump_int(delcode_heapsize);
+ undump_int(delcode_heapptr);
+ delcode_heap = Mxmalloc_array(delcodeval, delcode_heapsize);
+ for (k = 0; k < delcode_heapptr; k++) {
+ undump_int(d.origin_value);
+ undump_int(d.class_value);
+ undump_int(d.small_family_value);
+ undump_int(d.small_character_value);
+ undump_int(d.large_family_value);
+ undump_int(d.large_character_value);
+ delcode_heap[k] = d;
+ }
+ d.origin_value = tex_mathcode;
+ d.class_value = 0;
+ d.small_family_value = -1;
+ d.small_character_value = 0;
+ d.large_family_value = 0;
+ d.large_character_value = 0;
+ for (k = delcode_heapptr; k < delcode_heapsize; k++) {
+ delcode_heap[k] = d;
+ }
+}
+
+@ @c
+void unsave_math_codes(quarterword grouplevel)
+{
+ unsavemathcode(grouplevel);
+ unsavedelcode(grouplevel);
+}
+
+@ @c
+void initialize_math_codes(void)
+{
+ initializemathcode();
+ initializedelcode();
+}
+
+@ @c
+void free_math_codes(void)
+{
+ destroy_sa_tree(mathcode_head);
+ xfree(mathcode_heap);
+ destroy_sa_tree(delcode_head);
+ xfree(delcode_heap);
+}
+
+@ @c
+void dump_math_codes(void)
+{
+ dumpmathcode();
+ dumpdelcode();
+}
+
+void undump_math_codes(void)
+{
+ undumpmathcode();
+ undumpdelcode();
+}