| blob | df7de17db5f2cd8c40027ec9f603b81ec3ddc059 |
1 % texnodes.w
2 %
4 %
5 % This file is part of LuaTeX.
6 %
8 % the terms of the GNU General Public License as published by the Free
11 %
15 % License for more details.
16 %
17 % You should have received a copy of the GNU General Public License along
20 @ @c
22 #include "ptexlib.h"
23 #include "lua/luatex-api.h"
27 @
28 This module started out using NDEBUG to trigger checking invalid node usage,
29 something that is needed because users can mess up nodes in Lua. At some point
30 that code was always enabled so it is now always on but still can be recognized
31 as additional code. And as the performance hit is close to zero so disabling
32 makes no sense, not even to make it configureable. There is a little more memory
33 used but that is neglectable compared to other memory usage.
35 @c
49 #ifdef CHECK_NODE_USAGE
51 #endif
64 #define fake_node 100
65 #define fake_node_size 2
66 #define fake_node_name "fake"
68 #define variable_node_size 2
75 };
78 };
81 };
84 };
87 };
90 };
93 };
96 };
99 };
102 };
106 };
109 };
113 };
117 };
120 };
123 };
126 };
128 NULL
129 };
133 };
136 };
139 };
145 };
147 #define node_fields_ord node_fields_noad
148 #define node_fields_op node_fields_noad
149 #define node_fields_bin node_fields_noad
150 #define node_fields_rel node_fields_noad
151 #define node_fields_open node_fields_noad
152 #define node_fields_close node_fields_noad
153 #define node_fields_punct node_fields_noad
154 #define node_fields_inner node_fields_noad
155 #define node_fields_under node_fields_noad
156 #define node_fields_over node_fields_noad
157 #define node_fields_vcenter node_fields_noad
161 };
164 };
167 };
170 };
174 };
177 };
180 };
183 };
186 };
189 };
192 };
198 };
201 };
204 };
207 };
210 };
213 };
216 };
222 };
225 };
228 };
231 };
234 };
238 };
241 };
244 };
247 };
250 };
253 };
256 };
259 };
262 };
271 };
274 };
277 };
280 };
283 };
286 };
289 };
292 };
295 };
298 };
301 };
304 };
307 };
310 };
314 };
318 };
321 };
324 };
353 { math_text_char_node, math_kernel_node_size, node_fields_math_text_char, "math_text_char", 15 },
378 };
380 #define last_normal_node shape_node
384 };
387 };
389 node_info whatsit_node_data[] = {
398 { user_defined_node, user_defined_node_size, node_fields_whatsit_user_defined, "user_defined", -1 },
412 { pdf_start_link_node, pdf_annot_node_size, node_fields_whatsit_pdf_start_link, "pdf_start_link", -1 },
413 { pdf_end_link_node, pdf_end_link_node_size, node_fields_whatsit_pdf_end_link, "pdf_end_link", -1 },
417 { pdf_start_thread_node, pdf_thread_node_size, node_fields_whatsit_pdf_start_thread, "pdf_start_thread", -1 },
418 { pdf_end_thread_node, pdf_end_thread_node_size, node_fields_whatsit_pdf_end_thread, "pdf_end_thread", -1 },
421 { pdf_colorstack_node, pdf_colorstack_node_size, node_fields_whatsit_pdf_colorstack, "pdf_colorstack", -1 },
422 { pdf_setmatrix_node, pdf_setmatrix_node_size, node_fields_whatsit_pdf_setmatrix, "pdf_setmatrix", -1 },
424 { pdf_restore_node, pdf_restore_node_size, node_fields_whatsit_pdf_restore, "pdf_restore", -1 },
427 };
429 #define last_whatsit_node pdf_restore_node
431 @
434 in the properties, we create a new table and give it the original one as a metatable.
436 deep copy made no sense, nor did nilling. In the end both the shallow copy and the metatable
437 variant were both ok, although the second ons is slower. The most important aspect to keep
438 in mind is that references to other nodes in properties no longer can be valid for that
440 complicates matters.
442 When defining a new node, we could already allocate a table but it is rather easy to do
443 that at the lua end e.g. using a metatable __index method. That way it is under macro
444 package control.
447 memory consumption raise unneeded when we have temporary large node lists and after that
448 only small lists.
451 following:
455 that slow when it comes to accessing them
457 - a bitset in the node but again the gain compared to attributes is neglectable and it also
458 demands a pretty string agreement over what bit represents what, and this is unlikely to
460 but decided that it doesn't pay off
464 this mechanism makes sure that properties are cleaned up when a node is freed. Also, the
465 advantage of a more or less global properties table is that we stay at the lua end. An
466 alternative is to store a reference in the node itself but that is complicated by the fact
468 it too much.
470 @c
475 @
477 important, don't keep resolving the registry index.
479 @c
480 #define lua_properties_push do { \
485 } \
486 } \
489 #define lua_properties_pop do { \
494 } \
514 } \
515 } \
518 /*
519 For a moment I considered supporting all kind of data types but in practice
520 that makes no sense. So we stick to a cheap shallow copy with as option a
532 }
534 }
547 } \
548 } \
551 */
568 } \
572 } \
584 } \
588 } \
589 } \
590 } \
595 @ @c
597 {
599 #ifdef CHECK_NODE_USAGE
602 }
603 #else
605 #endif
606 }
608 }
610 @ @c
631 formatted_error("nodes","fuzzy token cleanup in whatsit node with id %i and subtype %i",type(p),subtype(p)); \
634 } \
635 }
637 #ifdef CHECK_NODE_USAGE
640 {
688 }
691 {
692 halfword r;
697 s--;
698 }
700 && s != my_prealloc
701 && s != var_mem_max
702 && (r - s) < get_node_size(type(s), subtype(s))
703 && alink(s) != p) {
726 ) {
734 }
740 }
741 }
742 }
743 }
744 }
745 }
746 }
748 #endif
751 {
753 #ifdef CHECK_NODE_USAGE
754 int i;
756 check_static_node_mem();
760 }
761 }
762 test_count++;
764 formatted_error("nodes", "attempt to double-free glyph (%c) node %d, ignored", (int) character(p), (int) p);
766 formatted_error("nodes", "attempt to double-free %s node %d, ignored", get_node_name(type(p), subtype(p)), (int) p);
767 }
770 }
771 #endif
775 }
777 }
779 @ @c
781 {
783 #ifdef CHECK_NODE_USAGE
786 formatted_warning("nodes", "attempt to copy free glyph (%c) node %d, ignored", (int) character(p), (int) p);
788 formatted_warning("nodes", "attempt to copy free %s node %d, ignored", get_node_name(type(p), subtype(p)), (int) p);
789 }
791 }
792 #endif
796 }
798 }
800 @ @c
802 {
805 /*
806 It should be possible to do this memset at |free_node()|.
810 word less than |s|
811 */
814 case glyph_node:
816 break;
817 case hlist_node:
818 case vlist_node:
820 break;
821 case disc_node:
831 break;
832 case rule_node:
839 break;
840 case whatsit_node:
845 }
846 break;
847 case unset_node:
849 break;
850 case pseudo_line_node:
851 case shape_node:
853 but the overall allocation faster then an explicit test
854 at the top of |new_node()|.
855 */
860 }
861 break;
862 default:
863 break;
864 }
868 case math_node:
871 break;
872 case glue_node:
875 break;
876 case kern_node:
880 }
881 break;
882 case hlist_node:
883 case vlist_node:
884 case unset_node:
887 break;
888 case rule_node:
891 break;
892 }
893 }
898 }
901 return n;
902 }
905 {
910 return n;
911 }
914 {
921 return n;
922 }
924 @ makes a duplicate of the node list that starts at |p| and returns a
925 pointer to the new list
927 @c
929 {
932 register halfword s ;
940 }
943 }
945 return h;
946 }
949 {
951 }
959 } \
968 } \
971 @ make a dupe of a single node
973 @c
975 {
976 halfword s ;
978 case write_node:
979 case special_node:
981 break;
982 case late_lua_node:
984 break;
985 case user_defined_node:
987 case 'a':
989 break;
990 case 'l':
992 break;
993 case 'n':
996 break;
997 case 's':
999 break;
1000 case 't':
1002 break;
1003 }
1004 break;
1005 default:
1006 break ;
1007 }
1008 }
1011 {
1012 }
1015 {
1017 case pdf_literal_node:
1019 break;
1020 case pdf_colorstack_node:
1023 break;
1024 case pdf_setmatrix_node:
1026 break;
1027 case pdf_annot_node:
1029 break;
1030 case pdf_start_link_node:
1034 break;
1035 case pdf_dest_node:
1038 break;
1039 case pdf_thread_node:
1040 case pdf_start_thread_node:
1045 break;
1046 default:
1047 break;
1048 }
1049 }
1052 {
1056 register int i;
1059 return r;
1060 }
1064 (void) memcpy((void *) (varmem + r), (void *) (varmem + p), (sizeof(memory_word) * (unsigned) i));
1069 case math_node:
1072 break;
1073 case kern_node:
1076 break;
1077 }
1078 }
1083 }
1087 case glyph_node:
1089 break;
1090 case glue_node:
1092 break;
1093 case hlist_node:
1094 case vlist_node:
1095 case unset_node:
1097 break;
1098 case disc_node:
1107 }
1116 }
1125 }
1126 break;
1127 case math_node:
1128 break;
1129 case ins_node:
1131 break;
1132 case margin_kern_node:
1134 break;
1135 case mark_node:
1137 break;
1138 case adjust_node:
1140 break;
1141 case choice_node:
1146 break;
1147 case simple_noad:
1151 break;
1152 case radical_noad:
1158 break;
1159 case accent_noad:
1166 break;
1167 case fence_noad:
1169 break;
1170 case sub_box_node:
1171 case sub_mlist_node:
1173 break;
1174 case fraction_noad:
1179 break;
1180 case glue_spec_node:
1181 case dir_node:
1182 case local_par_node:
1183 case boundary_node:
1184 break;
1185 case whatsit_node:
1193 }
1194 break;
1195 }
1196 return r;
1197 }
1204 @ @c
1207 {
1209 case open_node:
1210 case write_node:
1211 case close_node:
1212 case save_pos_node:
1213 break;
1214 case special_node:
1216 break;
1217 case late_lua_node:
1219 break;
1220 case user_defined_node:
1222 case 'a':
1224 break;
1225 case 'd':
1226 break;
1227 case 'n':
1229 break;
1230 case 's':
1232 break;
1233 case 't':
1235 break;
1236 default:
1237 {
1243 NULL
1244 };
1246 }
1247 break;
1248 }
1249 break;
1250 }
1251 }
1254 {
1255 }
1258 {
1260 case pdf_save_node:
1261 case pdf_restore_node:
1262 case pdf_refobj_node:
1263 case pdf_end_link_node:
1264 case pdf_end_thread_node:
1265 break;
1266 case pdf_literal_node:
1268 break;
1269 case pdf_colorstack_node:
1272 break;
1273 case pdf_setmatrix_node:
1275 break;
1276 case pdf_annot_node:
1278 break;
1279 case pdf_link_data_node:
1280 break;
1281 case pdf_start_link_node:
1285 break;
1286 case pdf_dest_node:
1289 break;
1290 case pdf_action_node:
1300 }
1301 break;
1302 case pdf_thread_data_node:
1303 break;
1304 case pdf_thread_node:
1305 case pdf_start_thread_node:
1310 break;
1311 }
1312 }
1315 {
1316 halfword w;
1318 return;
1320 return;
1322 case glyph_node:
1324 break;
1325 case glue_node:
1327 break;
1328 case hlist_node:
1329 case vlist_node:
1330 case unset_node:
1332 break;
1333 case disc_node:
1338 break;
1339 case rule_node:
1340 case kern_node:
1341 case penalty_node:
1342 case math_node:
1343 break;
1344 case glue_spec_node:
1348 //}
1350 break ;
1351 case dir_node:
1352 case local_par_node:
1353 case boundary_node:
1354 break;
1355 case whatsit_node:
1363 }
1364 break;
1365 case ins_node:
1367 break;
1368 case margin_kern_node:
1370 break;
1371 case mark_node:
1373 break;
1374 case adjust_node:
1376 break;
1378 break;
1379 case choice_node:
1384 break;
1385 case simple_noad:
1389 break;
1390 case radical_noad:
1396 break;
1397 case accent_noad:
1404 break;
1405 case fence_noad:
1407 break;
1409 case math_char_node:
1410 case math_text_char_node:
1411 break;
1412 case sub_box_node:
1413 case sub_mlist_node:
1415 break;
1416 case fraction_noad:
1421 break;
1422 case pseudo_file_node:
1424 break;
1425 case pseudo_line_node:
1426 case shape_node:
1428 return;
1429 break;
1430 case align_stack_node:
1431 case span_node:
1432 case movement_node:
1433 case if_node:
1434 case nesting_node:
1435 case unhyphenated_node:
1436 case hyphenated_node:
1437 case delta_node:
1438 case passive_node:
1439 case inserting_node:
1440 case split_up_node:
1441 case expr_node:
1442 case attribute_node:
1443 case attribute_list_node:
1444 case temp_node:
1445 break;
1446 default:
1448 return;
1449 }
1453 }
1455 return;
1456 }
1458 @ @c
1463 return;
1465 return;
1471 }
1473 }
1475 @ @c
1477 {
1480 case special_node:
1482 break;
1483 case user_defined_node:
1485 case 'a':
1487 break;
1488 case 't':
1490 break;
1491 case 'n':
1493 break;
1494 case 's':
1495 case 'd':
1496 break;
1497 default:
1499 break;
1500 }
1501 break;
1502 case open_node:
1503 case write_node:
1504 case close_node:
1505 case save_pos_node:
1506 break;
1507 }
1508 }
1511 {
1512 }
1515 {
1517 case pdf_literal_node:
1520 break;
1521 case pdf_colorstack_node:
1524 break;
1525 case pdf_setmatrix_node:
1527 break;
1528 case late_lua_node:
1533 break;
1534 case pdf_annot_node:
1536 break;
1537 case pdf_start_link_node:
1541 break;
1542 case pdf_dest_node:
1545 break;
1546 case pdf_thread_node:
1547 case pdf_start_thread_node:
1552 break;
1553 case pdf_save_node:
1554 case pdf_restore_node:
1555 case pdf_refobj_node:
1556 case pdf_end_link_node:
1557 case pdf_end_thread_node:
1558 break;
1559 default:
1561 break;
1562 }
1563 }
1566 {
1567 halfword w ;
1569 case glyph_node:
1571 break;
1572 case glue_node:
1574 break;
1575 case hlist_node:
1576 case vlist_node:
1577 case unset_node:
1578 case align_record_node:
1580 break;
1581 case ins_node:
1583 break;
1584 case whatsit_node:
1592 }
1593 break;
1594 case margin_kern_node:
1596 break;
1597 case math_node:
1598 break;
1599 case disc_node:
1603 break;
1604 case adjust_node:
1606 break;
1607 case pseudo_file_node:
1609 break;
1610 case pseudo_line_node:
1611 case shape_node:
1612 break;
1613 case choice_node:
1618 break;
1619 case fraction_noad:
1624 break;
1625 case simple_noad:
1629 break;
1630 case radical_noad:
1636 break;
1637 case accent_noad:
1644 break;
1645 case fence_noad:
1647 break;
1648 /*
1649 case rule_node:
1650 case kern_node:
1651 case penalty_node:
1652 case mark_node:
1653 case style_node:
1654 case attribute_list_node:
1655 case attribute_node:
1656 case glue_spec_node:
1657 case temp_node:
1658 case align_stack_node:
1659 case movement_node:
1660 case if_node:
1661 case nesting_node:
1662 case span_node:
1663 case unhyphenated_node:
1664 case hyphenated_node:
1665 case delta_node:
1666 case passive_node:
1667 case expr_node:
1668 case dir_node:
1669 case boundary_node:
1670 case local_par_node:
1671 break;
1672 default:
1674 */
1675 }
1676 }
1678 @ @c
1680 {
1683 return;
1690 }
1691 }
1693 @ @c
1695 {
1696 register halfword r;
1702 #ifdef CHECK_NODE_USAGE
1704 #endif
1707 return r;
1708 }
1713 return null;
1714 }
1715 }
1717 @ @c
1719 {
1722 return;
1723 }
1724 #ifdef CHECK_NODE_USAGE
1726 #endif
1736 }
1738 }
1741 }
1743 @ @c
1745 {
1748 #ifdef CHECK_NODE_USAGE
1750 #endif
1753 }
1755 #ifdef CHECK_NODE_USAGE
1757 #endif
1760 }
1762 @ @c
1764 {
1767 /* message ?
1771 */
1776 }
1778 #ifdef CHECK_NODE_USAGE
1782 }
1784 #endif
1896 }
1898 @ @c
1900 {
1904 #ifdef CHECK_NODE_USAGE
1906 #endif
1910 }
1912 @ it makes sense to enlarge the varmem array immediately
1913 @c
1916 {
1917 int x;
1923 #ifdef CHECK_NODE_USAGE
1927 #endif
1937 }
1939 }
1940 }
1942 @ @c
1944 {
1945 register int t;
1960 }
1964 }
1966 #ifdef CHECK_NODE_USAGE
1968 #endif
1974 return null;
1975 }
1978 int x;
1987 }
1995 }
1997 }
1998 }
1999 }
2002 varmem = (memory_word *) realloc((void *) varmem, sizeof(memory_word) * (unsigned) (var_mem_max + x));
2005 }
2007 #ifdef CHECK_NODE_USAGE
2011 }
2013 #endif
2019 }
2024 }
2027 return null;
2028 }
2029 }
2031 @ @c
2033 {
2035 #ifdef CHECK_NODE_USAGE
2037 int i;
2050 }
2051 }
2052 }
2055 int j =
2065 }
2066 }
2067 #else
2069 #endif
2070 return s;
2071 }
2073 @ @c
2075 {
2077 #ifdef CHECK_NODE_USAGE
2089 }
2091 }
2092 }
2094 #endif
2095 return q;
2096 }
2098 @ @c
2100 {
2102 halfword j;
2122 }
2123 }
2125 print_nlp();
2126 }
2131 {
2136 return p;
2137 }
2139 @* Attribute stuff.
2141 @c
2143 {
2150 return r;
2151 }
2153 @ @c
2155 {
2169 }
2170 return q;
2171 }
2173 @ @c
2175 {
2176 halfword p;
2177 register int i;
2188 }
2189 }
2193 }
2194 return;
2195 }
2197 @ @c
2199 {
2202 update_attribute_cache();
2204 return;
2205 }
2208 }
2209 }
2211 @ @c
2213 {
2216 update_attribute_cache();
2217 }
2218 return attr_list_cache ;
2219 }
2220 return null ;
2221 }
2224 @ @c
2226 {
2227 halfword old;
2240 }
2243 }
2245 @ @c
2247 {
2255 }
2259 }
2262 }
2263 }
2264 }
2267 {
2270 }
2271 }
2273 @ |p| is an attr list head, or zero
2274 @c
2276 {
2277 register halfword q;
2285 return q;
2286 }
2294 break;
2295 j++;
2297 }
2308 }
2309 return q;
2312 return null ;
2313 }
2314 }
2316 @ @c
2318 {
2319 register halfword p;
2323 return;
2333 return;
2334 }
2340 return;
2342 break;
2343 j++;
2345 }
2351 formatted_warning("nodes","node %d has an attribute list that is free already, case 1",(int) n);
2364 }
2373 }
2386 }
2389 }
2390 }
2392 @ @c
2394 {
2395 register halfword p;
2396 register int t;
2400 return null;
2403 return UNUSED_ATTRIBUTE;
2405 formatted_warning("nodes","node %d has an attribute list that is free already, case 2", (int) n);
2406 return UNUSED_ATTRIBUTE;
2407 }
2412 return UNUSED_ATTRIBUTE;
2415 break;
2416 }
2417 j++;
2419 }
2421 return UNUSED_ATTRIBUTE;
2428 }
2431 }
2438 }
2439 return t;
2442 return null;
2443 }
2444 }
2446 @ @c
2448 {
2449 register halfword p;
2451 return UNUSED_ATTRIBUTE;
2454 return UNUSED_ATTRIBUTE;
2460 return ret;
2461 return UNUSED_ATTRIBUTE;
2463 return UNUSED_ATTRIBUTE;
2464 }
2466 }
2467 return UNUSED_ATTRIBUTE;
2468 }
2470 @ @c
2472 {
2474 case hlist_node:
2475 case vlist_node:
2476 case ins_node:
2477 case whatsit_node:
2478 case mark_node:
2479 case adjust_node:
2480 case unset_node:
2483 break;
2484 case rule_node:
2486 break;
2487 case glue_node:
2490 break;
2491 case math_node:
2493 break;
2494 case disc_node:
2497 break;
2498 }
2499 }
2501 @ @c
2503 {
2510 }
2512 @ Each new type of node that appears in our data structure must be capable
2514 need for write-oriented whatsits are somewhat like those for mark nodes;
2517 @c
2519 {
2525 else
2527 }
2529 @ @c
2531 {
2533 case open_node:
2537 break;
2538 case write_node:
2541 break;
2542 case close_node:
2544 break;
2545 case special_node:
2548 break;
2549 case late_lua_node:
2551 break;
2552 case save_pos_node:
2554 break;
2555 case user_defined_node:
2560 case 'a':
2562 break;
2563 case 'n':
2567 break;
2568 case 's':
2570 print(user_node_value(p));
2572 break;
2573 case 't':
2575 break;
2578 break;
2579 }
2580 break;
2581 }
2582 }
2585 {
2586 }
2589 {
2591 case pdf_literal_node:
2593 break;
2594 case pdf_colorstack_node:
2598 case colorstack_set:
2600 break;
2601 case colorstack_push:
2603 break;
2604 case colorstack_pop:
2606 break;
2607 case colorstack_current:
2609 break;
2610 default:
2612 break;
2613 }
2616 break;
2617 case pdf_setmatrix_node:
2620 break;
2621 case pdf_save_node:
2623 break;
2624 case pdf_restore_node:
2626 break;
2627 case pdf_refobj_node:
2637 }
2639 }
2648 }
2649 break;
2650 case pdf_annot_node:
2654 break;
2655 case pdf_start_link_node:
2661 }
2666 return;
2667 }
2671 }
2673 case pdf_action_goto:
2680 }
2681 break;
2682 case pdf_action_page:
2686 break;
2687 case pdf_action_thread:
2694 }
2695 break;
2696 default:
2698 break;
2699 }
2700 break;
2701 case pdf_end_link_node:
2703 break;
2704 case pdf_dest_node:
2712 }
2715 case pdf_dest_xyz:
2720 }
2721 break;
2722 case pdf_dest_fitbh:
2724 break;
2725 case pdf_dest_fitbv:
2727 break;
2728 case pdf_dest_fitb:
2730 break;
2731 case pdf_dest_fith:
2733 break;
2734 case pdf_dest_fitv:
2736 break;
2737 case pdf_dest_fitr:
2740 break;
2741 case pdf_dest_fit:
2743 break;
2744 default:
2746 break;
2747 }
2748 break;
2749 case pdf_thread_node:
2750 case pdf_start_thread_node:
2753 else
2764 }
2771 }
2772 break;
2773 case pdf_end_thread_node:
2775 break;
2776 default:
2777 break;
2778 }
2779 }
2781 @ Now we are ready for |show_node_list| itself. This procedure has been
2782 written to be ``extra robust'' in the sense that it should not crash or get
2783 into a loop even if the data structures have been messed up by bugs in
2784 the rest of the program. You can safely call its parent routine
2787 fetch a |memory_word| whose variant is different from the way it was stored;
2789 contains a scaled integer, if |p| is a pointer that has been
2790 clobbered or chosen at random.
2793 @ |str_room| need not be checked; see |show_box|
2795 @ Recursive calls on |show_node_list| therefore use the following pattern:
2796 @c
2800 flush_char(); \
2806 {
2808 halfword w;
2813 return;
2814 }
2816 print_ln();
2823 return;
2824 }
2838 }
2841 case hlist_node:
2842 case vlist_node:
2843 case unset_node:
2849 else
2863 }
2867 }
2871 }
2874 /* The code will have to change in this place if |glue_ratio| is
2875 a structured type instead of an ordinary |real|. Note that this routine
2876 should avoid arithmetic errors even if the |glue_set| field holds an
2877 arbitrary random value. The following code assumes that a properly
2879 it is regarded as an integer; this precaution was adequate to prevent
2880 floating point underflow on the author's computer.
2881 */
2891 else
2896 }
2897 }
2902 }
2905 }
2907 break;
2908 case rule_node:
2920 }
2926 break;
2927 case ins_node:
2940 break;
2941 case dir_node:
2950 }
2951 break;
2952 case local_par_node:
2955 print_ln();
2956 print_current_string();
2960 print_ln();
2961 print_current_string();
2965 print_ln();
2966 print_current_string();
2974 }
2975 print_ln();
2976 print_current_string();
2984 }
2986 break;
2987 case boundary_node:
2994 break;
2997 break;
3000 break;
3001 default:
3005 break;
3006 }
3009 }
3010 break;
3011 case whatsit_node:
3019 }
3020 break;
3021 case glue_node:
3027 case a_leaders:
3028 break;
3029 case c_leaders:
3031 break;
3032 case x_leaders:
3034 break;
3035 case g_leaders:
3037 break;
3038 default:
3040 }
3056 }
3058 }
3063 else
3065 }
3066 }
3067 break;
3068 case margin_kern_node:
3073 else
3075 break;
3076 case kern_node:
3090 }
3091 break;
3092 case math_node:
3097 else
3105 }
3106 break;
3107 case penalty_node:
3111 break;
3112 case disc_node:
3114 /* The |post_break| list of a discretionary node is indicated by a prefixed
3122 }
3127 break;
3128 case mark_node:
3134 }
3136 break;
3137 case adjust_node:
3143 break;
3144 case glue_spec_node:
3148 break;
3149 default:
3151 break;
3152 }
3153 }
3155 }
3156 }
3158 @ This routine finds the 'base' width of a horizontal box, using the same logic
3161 @c
3163 {
3171 goto FOUND;
3172 }
3174 case hlist_node:
3175 case vlist_node:
3176 case rule_node:
3178 goto FOUND;
3179 break;
3180 case margin_kern_node:
3182 break;
3183 case kern_node:
3185 break;
3186 case math_node:
3190 break;
3193 }
3195 case glue_node:
3197 values, since such values are subject to system-dependent rounding.
3198 System-dependent numbers are not allowed to infiltrate parameters like
3199 |pre_display_size|, since \TeX82 is supposed to make the same decisions on all
3200 machines.
3201 */
3209 }
3211 goto FOUND;
3212 break;
3213 default:
3215 break;
3216 }
3219 goto NOT_FOUND;
3220 FOUND:
3226 break;
3227 }
3228 NOT_FOUND:
3230 }
3231 return w;
3232 }
3234 @ @c
3236 {
3240 return q;
3241 }
3245 @ @c
3246 int var_used;
3248 @ Attribute lists need two extra globals to increase processing efficiency.
3249 |max_used_attr| limits the test loop that checks for set attributes, and
3250 |attr_list_cache| contains a pointer to an already created attribute list. It is
3251 set to the special value |cache_disabled| when the current value can no longer be
3253 ended.
3255 @c
3257 halfword attr_list_cache;
3259 @ From the computer's standpoint, \TeX's chief mission is to create
3260 horizontal and vertical lists. We shall now investigate how the elements
3261 of these lists are represented internally as nodes in the dynamic memory.
3263 A horizontal or vertical list is linked together by |link| fields in
3267 kinds of nodes. We do this by putting a `|type|' field in the first word,
3268 together with the link and an optional `|subtype|'.
3270 @ Character nodes appear only in horizontal lists, never in vertical lists.
3272 An |hlist_node| stands for a box that was made from a horizontal list.
3273 Each |hlist_node| is seven words long, and contains the following fields
3275 mention explicitly when discussing the other node types): The |height| and
3276 |width| and |depth| are scaled integers denoting the dimensions of the
3277 box. There is also a |shift_amount| field, a scaled integer indicating
3279 or how much it should be moved to the right (if it appears in a vertical
3282 is empty. Finally, there are three fields that represent the setting of
3285 |stretching| or |shrinking| or |normal| depending on whether or not the
3290 @ The |new_null_box| function returns a pointer to an |hlist_node| in
3292 The |subtype| field is set to |min_quarterword|, since that's the desired
3293 |span_count| value if this |hlist_node| is changed to an |unset_node|.
3295 @c
3300 return p;
3301 }
3303 @ A |vlist_node| is like an |hlist_node| in all respects except that it
3304 contains a vertical list.
3309 by running the rule up to the boundary of the innermost enclosing box.
3310 This is called a ``running dimension.'' The |width| is never running in
3311 an hlist; the |height| and |depth| are never running in a~vlist.
3313 @ A new rule node is delivered by the |new_rule| function. It
3314 makes all the dimensions ``running,'' so you have to change the
3315 ones that are not allowed to run.
3317 @c
3319 {
3321 return p;
3322 }
3324 @ Insertions are represented by |ins_node| records, where the |subtype|
3327 The |height| field of an |ins_node| is slightly misnamed; it actually holds
3328 the natural height plus depth of the vertical list being inserted.
3329 The |depth| field holds the |split_max_depth| to be used in case this
3330 insertion is split, and the |split_top_ptr| points to the corresponding
3331 |split_top_skip|. The |float_cost| field holds the |floating_penalty| that
3332 will be used if this insertion floats to a subsequent page after a
3333 split insertion of the same class. There is one more field, the
3334 |ins_ptr|, which points to the beginning of the vlist for the insertion.
3336 @ A |mark_node| has a |mark_ptr| field that points to the reference count
3338 In addition there is a |mark_class| field that contains the mark class.
3341 specifies material that will be moved out into the surrounding
3343 operation. The |adjust_ptr| field points to the vlist containing this
3344 material.
3347 glyph in a particular font, along with its attribute list. Older
3348 versions of \TeX\ could use token memory for characters, because the
3351 needed for characters that are larger than that, as well as a pointer
3352 to a potential attribute list, and the two displacement values.
3354 In turn, that made the node so large that it made sense to merge
3355 ligature glyphs as well, as that requires only one extra pointer. A
3356 few extra classes of glyph nodes will be introduced later. The
3357 unification of all those types makes it easier to manipulate lists of
3358 glyphs. The subtype differentiates various glyph kinds.
3360 First, here is a function that returns a pointer to a glyph node for a given
3361 glyph in a given font. If that glyph doesn't exist, |null| is returned
3362 instead. Nodes of this subtype are directly created only for accents
3364 conversion from |mlist| to |hlist|).
3366 @c
3368 {
3375 }
3376 return p;
3377 }
3379 @ A subset of the glyphs nodes represent ligatures: characters
3380 fabricated from the interaction of two or more actual characters. The
3381 characters that generated the ligature have not been forgotten, since
3382 they are needed for diagnostic messages; the |lig_ptr| field points to
3383 a linked list of character nodes for all original characters that have
3384 been deleted. (This list might be empty if the characters that
3385 generated the ligature were retained in other nodes.)
3388 the original source of the ligature included implicit left and/or
3389 right boundaries. These nodes are created by the C function |new_ligkern|.
3391 A third general type of glyphs could be called a character, as it
3392 only appears in lists that are not yet processed by the ligaturing and
3393 kerning steps of the program.
3395 |main_control| inserts these, and they are later converted to
3396 |subtype_normal| by |new_ligkern|.
3398 @c
3400 {
3405 else
3407 }
3410 {
3417 return p;
3418 }
3422 |new_ligkern|, at the end of which they are no longer needed.
3424 @ Here are a few handy helpers used by the list output routines.
3426 @c
3428 {
3430 return w;
3431 }
3434 {
3438 return w;
3439 }
3442 {
3448 return w;
3449 }
3458 and |no_break=null|.
3464 break. Otherwise the |hyphen_penalty| will be charged. The texts will
3465 actually be substituted into the list by the line-breaking algorithm if it
3466 decides to make the break, and the discretionary node will disappear at
3468 not chosen.
3470 @c
3475 return p;
3476 }
3478 @ A |whatsit_node| is a wild card reserved for extensions to \TeX. The
3481 format of the remaining words. When a |whatsit_node| is encountered
3483 careful not to mess up the rest of \TeX\ are able to make \TeX\ do new
3484 things by adding code at the end of the program. For example, there
3485 might be a `\TeX nicolor' extension to specify different colors of ink,
3486 @^extensions to \TeX@>
3487 and the whatsit node might contain the desired parameters.
3489 The present implementation of \TeX\ treats the features associated with
3491 illustrate how such routines might be coded. We shall defer further
3492 discussion of extensions until the end of this program.
3495 after mathematical formulas. The |subtype| field is |before| before the
3496 formula and |after| after it. There is a |surround| field, which represents
3499 @c
3501 {
3504 return p;
3505 }
3510 type codes, by permitting a break at glue in a list if and only if the
3511 |type| of the previous node is less than |math_node|. Furthermore, a
3512 node is discarded after a break if its type is |math_node| or~more.
3514 @ A |glue_node| represents glue in a list. However, it is really only
3515 a pointer to a separate glue specification, since \TeX\ makes use of the
3516 fact that many essentially identical nodes of glue are usually present.
3518 another packet of words that specify the stretch and shrink components, etc.
3520 Glue nodes also serve to represent leaders; the |subtype| is used to
3523 The |leader_ptr| field points to a rule node or to a box node containing the
3524 leaders; it is set to |null| in ordinary glue nodes.
3526 Many kinds of glue are computed from \TeX's ``skip'' parameters, and
3527 it is helpful to know which parameter has led to a particular glue node.
3528 Therefore the |subtype| is set to indicate the source of glue, whenever
3529 it originated as a parameter. We will be defining symbolic names for the
3531 etc.); it suffices for now to say that the |subtype| of parametric glue
3532 will be the same as the parameter number, plus~one.
3534 @ In math formulas there are two more possibilities for the |subtype| in a
3537 feature that cancels the glue node immediately following if it appears
3538 in a subscript.
3540 @ A glue specification has a halfword reference count in its first word,
3541 @^reference counts@>
3543 Note that the reference count appears in the same position as
3544 the |link| field in list nodes; this is the field that is initialized
3545 to |null| when a node is allocated, and it is also the field that is flagged
3546 by |empty_flag| in empty nodes.
3550 fields called |stretch_order| and |shrink_order|; these contain the
3552 corresponding to the stretch and shrink values.
3554 @ Here is a function that returns a pointer to a copy of a glue spec.
3555 The reference count in the copy is |null|, because there is assumed
3556 to be exactly one reference to the new specification.
3558 @c
3560 {
3562 }
3564 @ And here's a function that creates a glue node for a given parameter
3569 @c
3571 {
3579 return p;
3580 }
3582 @ Glue nodes that are more or less anonymous are created by |new_glue|,
3583 whose argument points to a glue specification.
3585 @c
3587 {
3594 return p;
3595 }
3597 @ Still another subroutine is needed: This one is sort of a combination
3598 of |new_param_glue| and |new_glue|. It creates a glue node for one of
3599 the current glue parameters, but it makes a fresh copy of the glue
3601 while the parameter will stay put.
3603 /*
3604 The global variable |temp_ptr| is set to the address of the new spec.
3605 */
3607 @c
3609 {
3617 return p;
3618 }
3621 amount of spacing. This spacing correction appears in horizontal lists
3622 between letters like A and V when the font designer said that it looks
3623 better to move them closer together or further apart. A kern node can
3624 also appear in a vertical list, when its `|width|' denotes additional
3625 spacing in the vertical direction. The |subtype| is either |normal| (for
3626 kerns inserted from font information or math mode calculations) or |explicit|
3631 @ The |new_kern| function creates a kern node having a given width.
3633 @c
3635 {
3638 return p;
3639 }
3641 @ A |penalty_node| specifies the penalty associated with line or page
3644 treated as infinity, and no break will be allowed for such high values.
3646 break will be forced.
3648 @ Anyone who has been reading the last few sections of the program will
3649 be able to guess what comes next.
3651 @c
3653 {
3656 return p;
3657 }
3659 @ You might think that we have introduced enough node types by now. Well,
3663 dimensions are their ``natural'' sizes before any glue adjustment has been
3665 field, which contains the total stretch of order |glue_order| that is
3666 present in the hlist or vlist being boxed.
3668 containing the total shrink of order |glue_sign| that is present.
3669 The |subtype| field is called |span_count|; an unset box typically
3671 Unset nodes will be changed to box nodes when alignment is completed.
3673 In fact, there are still more types coming. When we get to math formula
3675 of larger type codes will also be defined, for use in math mode only.
3678 changing any of the node sizes or even reordering the words of nodes,
3679 the |copy_node_list| procedure and the memory initialization code
3680 below may have to be changed. Such potentially dangerous parts of the
3681 program are listed in the index under `data structure assumptions'.
3683 However, other references to the nodes are made symbolically in terms of
3685 \TeX's other algorithms intact.
3686 @^system dependencies@>
3688 @ This function creates a |local_paragraph| node
3690 @c
3693 {
3694 int callback_id;
3695 halfword q;
3703 }
3708 }
3716 return p;
3717 }
3726 return p;
3727 }
3729 }
3731 return p;
3732 }