| blob | d5d2d2364b620180478ea38652faac9b990b04d6 |
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 };
311 };
315 };
318 };
321 };
350 { math_text_char_node, math_kernel_node_size, node_fields_math_text_char, "math_text_char", 15 },
375 };
377 #define last_normal_node shape_node
381 };
384 };
386 node_info whatsit_node_data[] = {
395 { user_defined_node, user_defined_node_size, node_fields_whatsit_user_defined, "user_defined", -1 },
409 { pdf_start_link_node, pdf_annot_node_size, node_fields_whatsit_pdf_start_link, "pdf_start_link", -1 },
410 { pdf_end_link_node, pdf_end_link_node_size, node_fields_whatsit_pdf_end_link, "pdf_end_link", -1 },
414 { pdf_start_thread_node, pdf_thread_node_size, node_fields_whatsit_pdf_start_thread, "pdf_start_thread", -1 },
415 { pdf_end_thread_node, pdf_end_thread_node_size, node_fields_whatsit_pdf_end_thread, "pdf_end_thread", -1 },
418 { pdf_colorstack_node, pdf_colorstack_node_size, node_fields_whatsit_pdf_colorstack, "pdf_colorstack", -1 },
419 { pdf_setmatrix_node, pdf_setmatrix_node_size, node_fields_whatsit_pdf_setmatrix, "pdf_setmatrix", -1 },
421 { pdf_restore_node, pdf_restore_node_size, node_fields_whatsit_pdf_restore, "pdf_restore", -1 },
424 };
426 #define last_whatsit_node pdf_restore_node
428 @
431 in the properties, we create a new table and give it the original one as a metatable.
433 deep copy made no sense, nor did nilling. In the end both the shallow copy and the metatable
434 variant were both ok, although the second ons is slower. The most important aspect to keep
435 in mind is that references to other nodes in properties no longer can be valid for that
437 complicates matters.
439 When defining a new node, we could already allocate a table but it is rather easy to do
440 that at the lua end e.g. using a metatable __index method. That way it is under macro
441 package control.
444 memory consumption raise unneeded when we have temporary large node lists and after that
445 only small lists.
448 following:
452 that slow when it comes to accessing them
454 - a bitset in the node but again the gain compared to attributes is neglectable and it also
455 demands a pretty string agreement over what bit represents what, and this is unlikely to
457 but decided that it doesn't pay off
461 this mechanism makes sure that properties are cleaned up when a node is freed. Also, the
462 advantage of a more or less global properties table is that we stay at the lua end. An
463 alternative is to store a reference in the node itself but that is complicated by the fact
465 it too much.
467 @c
472 @
474 important, don't keep resolving the registry index.
476 @c
477 #define lua_properties_push do { \
482 } \
483 } \
486 #define lua_properties_pop do { \
491 } \
511 } \
512 } \
515 /*
516 For a moment I considered supporting all kind of data types but in practice
517 that makes no sense. So we stick to a cheap shallow copy with as option a
529 }
531 }
544 } \
545 } \
548 */
565 } \
569 } \
581 } \
585 } \
586 } \
587 } \
592 @ @c
594 {
596 #ifdef CHECK_NODE_USAGE
599 }
600 #else
602 #endif
603 }
605 }
607 @ @c
628 #ifdef CHECK_NODE_USAGE
631 {
679 }
682 {
683 halfword r;
688 s--;
689 }
691 && s != my_prealloc
692 && s != var_mem_max
693 && (r - s) < get_node_size(type(s), subtype(s))
694 && alink(s) != p) {
717 ) {
725 }
731 }
732 }
733 }
734 }
735 }
736 }
737 }
739 #endif
742 {
744 #ifdef CHECK_NODE_USAGE
745 int i;
747 check_static_node_mem();
751 }
752 }
753 test_count++;
755 formatted_error("nodes", "attempt to double-free glyph (%c) node %d, ignored", (int) character(p), (int) p);
757 formatted_error("nodes", "attempt to double-free %s node %d, ignored", get_node_name(type(p), subtype(p)), (int) p);
758 }
761 }
762 #endif
766 }
768 }
770 @ @c
772 {
774 #ifdef CHECK_NODE_USAGE
777 formatted_warning("nodes", "attempt to copy free glyph (%c) node %d, ignored", (int) character(p), (int) p);
779 formatted_warning("nodes", "attempt to copy free %s node %d, ignored", get_node_name(type(p), subtype(p)), (int) p);
780 }
782 }
783 #endif
787 }
789 }
791 @ @c
793 {
796 /*
797 It should be possible to do this memset at |free_node()|.
801 word less than |s|
802 */
805 case glyph_node:
807 break;
808 case hlist_node:
809 case vlist_node:
811 break;
812 case disc_node:
822 break;
823 case rule_node:
830 break;
831 case whatsit_node:
836 }
837 break;
838 case unset_node:
840 break;
841 case pseudo_line_node:
842 case shape_node:
844 but the overall allocation faster then an explicit test
845 at the top of |new_node()|.
846 */
851 }
852 break;
853 default:
854 break;
855 }
859 case math_node:
862 break;
863 case glue_node:
866 break;
867 case kern_node:
871 }
872 break;
873 case hlist_node:
874 case vlist_node:
875 case unset_node:
878 break;
879 case rule_node:
882 break;
883 }
884 }
889 }
892 return n;
893 }
896 {
901 return n;
902 }
905 {
912 return n;
913 }
915 @ makes a duplicate of the node list that starts at |p| and returns a
916 pointer to the new list
918 @c
920 {
923 register halfword s ;
931 }
934 }
936 return h;
937 }
940 {
942 }
950 } \
959 } \
962 @ make a dupe of a single node
964 @c
966 {
967 halfword s ;
969 case write_node:
970 case special_node:
972 break;
973 case late_lua_node:
975 break;
976 case user_defined_node:
978 case 'a':
980 break;
981 case 'l':
983 break;
984 case 'n':
987 break;
988 case 's':
990 break;
991 case 't':
993 break;
994 }
995 break;
996 default:
997 break ;
998 }
999 }
1002 {
1003 }
1006 {
1008 case pdf_literal_node:
1010 break;
1011 case pdf_colorstack_node:
1014 break;
1015 case pdf_setmatrix_node:
1017 break;
1018 case pdf_annot_node:
1020 break;
1021 case pdf_start_link_node:
1025 break;
1026 case pdf_dest_node:
1029 break;
1030 case pdf_thread_node:
1031 case pdf_start_thread_node:
1036 break;
1037 default:
1038 break;
1039 }
1040 }
1043 {
1047 register int i;
1050 return r;
1051 }
1055 (void) memcpy((void *) (varmem + r), (void *) (varmem + p), (sizeof(memory_word) * (unsigned) i));
1060 case math_node:
1063 break;
1064 case kern_node:
1067 break;
1068 }
1069 }
1074 }
1078 case glyph_node:
1080 break;
1081 case glue_node:
1083 break;
1084 case hlist_node:
1085 case vlist_node:
1086 case unset_node:
1088 break;
1089 case disc_node:
1098 }
1107 }
1116 }
1117 break;
1118 case math_node:
1119 break;
1120 case ins_node:
1122 break;
1123 case margin_kern_node:
1125 break;
1126 case mark_node:
1128 break;
1129 case adjust_node:
1131 break;
1132 case choice_node:
1137 break;
1138 case simple_noad:
1142 break;
1143 case radical_noad:
1149 break;
1150 case accent_noad:
1157 break;
1158 case fence_noad:
1160 break;
1161 case sub_box_node:
1162 case sub_mlist_node:
1164 break;
1165 case fraction_noad:
1170 break;
1171 case glue_spec_node:
1172 case dir_node:
1173 case local_par_node:
1174 case boundary_node:
1175 break;
1176 case whatsit_node:
1184 }
1185 break;
1186 }
1187 return r;
1188 }
1195 @ @c
1198 {
1200 case open_node:
1201 case write_node:
1202 case close_node:
1203 case save_pos_node:
1204 break;
1205 case special_node:
1207 break;
1208 case late_lua_node:
1210 break;
1211 case user_defined_node:
1213 case 'a':
1215 break;
1216 case 'd':
1217 break;
1218 case 'n':
1220 break;
1221 case 's':
1223 break;
1224 case 't':
1226 break;
1227 default:
1228 {
1234 NULL
1235 };
1237 }
1238 break;
1239 }
1240 break;
1241 }
1242 }
1245 {
1246 }
1249 {
1251 case pdf_save_node:
1252 case pdf_restore_node:
1253 case pdf_refobj_node:
1254 case pdf_end_link_node:
1255 case pdf_end_thread_node:
1256 break;
1257 case pdf_literal_node:
1259 break;
1260 case pdf_colorstack_node:
1263 break;
1264 case pdf_setmatrix_node:
1266 break;
1267 case pdf_annot_node:
1269 break;
1270 case pdf_link_data_node:
1271 break;
1272 case pdf_start_link_node:
1276 break;
1277 case pdf_dest_node:
1280 break;
1281 case pdf_action_node:
1291 }
1292 break;
1293 case pdf_thread_data_node:
1294 break;
1295 case pdf_thread_node:
1296 case pdf_start_thread_node:
1301 break;
1302 }
1303 }
1306 {
1307 halfword w;
1309 return;
1311 return;
1313 case glyph_node:
1315 break;
1316 case glue_node:
1318 break;
1319 case hlist_node:
1320 case vlist_node:
1321 case unset_node:
1323 break;
1324 case disc_node:
1329 break;
1330 case rule_node:
1331 case kern_node:
1332 case penalty_node:
1333 case math_node:
1334 break;
1335 case glue_spec_node:
1339 //}
1341 break ;
1342 case dir_node:
1343 case local_par_node:
1344 case boundary_node:
1345 break;
1346 case whatsit_node:
1354 }
1355 break;
1356 case ins_node:
1358 break;
1359 case margin_kern_node:
1361 break;
1362 case mark_node:
1364 break;
1365 case adjust_node:
1367 break;
1369 break;
1370 case choice_node:
1375 break;
1376 case simple_noad:
1380 break;
1381 case radical_noad:
1387 break;
1388 case accent_noad:
1395 break;
1396 case fence_noad:
1398 break;
1400 case math_char_node:
1401 case math_text_char_node:
1402 break;
1403 case sub_box_node:
1404 case sub_mlist_node:
1406 break;
1407 case fraction_noad:
1412 break;
1413 case pseudo_file_node:
1415 break;
1416 case pseudo_line_node:
1417 case shape_node:
1419 return;
1420 break;
1421 case align_stack_node:
1422 case span_node:
1423 case movement_node:
1424 case if_node:
1425 case nesting_node:
1426 case unhyphenated_node:
1427 case hyphenated_node:
1428 case delta_node:
1429 case passive_node:
1430 case inserting_node:
1431 case split_up_node:
1432 case expr_node:
1433 case attribute_node:
1434 case attribute_list_node:
1435 case temp_node:
1436 break;
1437 default:
1439 return;
1440 }
1444 }
1446 return;
1447 }
1449 @ @c
1454 return;
1456 return;
1462 }
1464 }
1466 @ @c
1468 {
1471 case special_node:
1473 break;
1474 case user_defined_node:
1476 case 'a':
1478 break;
1479 case 't':
1481 break;
1482 case 'n':
1484 break;
1485 case 's':
1486 case 'd':
1487 break;
1488 default:
1490 break;
1491 }
1492 break;
1493 case open_node:
1494 case write_node:
1495 case close_node:
1496 case save_pos_node:
1497 break;
1498 }
1499 }
1502 {
1503 }
1506 {
1508 case pdf_literal_node:
1511 break;
1512 case pdf_colorstack_node:
1515 break;
1516 case pdf_setmatrix_node:
1518 break;
1519 case late_lua_node:
1524 break;
1525 case pdf_annot_node:
1527 break;
1528 case pdf_start_link_node:
1532 break;
1533 case pdf_dest_node:
1536 break;
1537 case pdf_thread_node:
1538 case pdf_start_thread_node:
1543 break;
1544 case pdf_save_node:
1545 case pdf_restore_node:
1546 case pdf_refobj_node:
1547 case pdf_end_link_node:
1548 case pdf_end_thread_node:
1549 break;
1550 default:
1552 break;
1553 }
1554 }
1557 {
1558 halfword w ;
1560 case glyph_node:
1562 break;
1563 case glue_node:
1565 break;
1566 case hlist_node:
1567 case vlist_node:
1568 case unset_node:
1569 case align_record_node:
1571 break;
1572 case ins_node:
1574 break;
1575 case whatsit_node:
1583 }
1584 break;
1585 case margin_kern_node:
1587 break;
1588 case math_node:
1589 break;
1590 case disc_node:
1594 break;
1595 case adjust_node:
1597 break;
1598 case pseudo_file_node:
1600 break;
1601 case pseudo_line_node:
1602 case shape_node:
1603 break;
1604 case choice_node:
1609 break;
1610 case fraction_noad:
1615 break;
1616 case simple_noad:
1620 break;
1621 case radical_noad:
1627 break;
1628 case accent_noad:
1635 break;
1636 case fence_noad:
1638 break;
1639 /*
1640 case rule_node:
1641 case kern_node:
1642 case penalty_node:
1643 case mark_node:
1644 case style_node:
1645 case attribute_list_node:
1646 case attribute_node:
1647 case glue_spec_node:
1648 case temp_node:
1649 case align_stack_node:
1650 case movement_node:
1651 case if_node:
1652 case nesting_node:
1653 case span_node:
1654 case unhyphenated_node:
1655 case hyphenated_node:
1656 case delta_node:
1657 case passive_node:
1658 case expr_node:
1659 case dir_node:
1660 case boundary_node:
1661 case local_par_node:
1662 break;
1663 default:
1665 */
1666 }
1667 }
1669 @ @c
1671 {
1674 return;
1681 }
1682 }
1684 @ @c
1686 {
1687 register halfword r;
1693 #ifdef CHECK_NODE_USAGE
1695 #endif
1698 return r;
1699 }
1704 return null;
1705 }
1706 }
1708 @ @c
1710 {
1713 return;
1714 }
1715 #ifdef CHECK_NODE_USAGE
1717 #endif
1727 }
1729 }
1732 }
1734 @ @c
1736 {
1739 #ifdef CHECK_NODE_USAGE
1741 #endif
1744 }
1746 #ifdef CHECK_NODE_USAGE
1748 #endif
1751 }
1753 @ @c
1755 {
1758 /* message ?
1762 */
1767 }
1769 #ifdef CHECK_NODE_USAGE
1773 }
1775 #endif
1887 }
1889 @ @c
1891 {
1895 #ifdef CHECK_NODE_USAGE
1897 #endif
1901 }
1903 @ it makes sense to enlarge the varmem array immediately
1904 @c
1907 {
1908 int x;
1914 #ifdef CHECK_NODE_USAGE
1918 #endif
1928 }
1930 }
1931 }
1933 @ @c
1935 {
1936 register int t;
1951 }
1955 }
1957 #ifdef CHECK_NODE_USAGE
1959 #endif
1965 return null;
1966 }
1969 int x;
1978 }
1986 }
1988 }
1989 }
1990 }
1993 varmem = (memory_word *) realloc((void *) varmem, sizeof(memory_word) * (unsigned) (var_mem_max + x));
1996 }
1998 #ifdef CHECK_NODE_USAGE
2002 }
2004 #endif
2010 }
2015 }
2018 return null;
2019 }
2020 }
2022 @ @c
2024 {
2026 #ifdef CHECK_NODE_USAGE
2028 int i;
2041 }
2042 }
2043 }
2046 int j =
2056 }
2057 }
2058 #else
2060 #endif
2061 return s;
2062 }
2064 @ @c
2066 {
2068 #ifdef CHECK_NODE_USAGE
2080 }
2082 }
2083 }
2085 #endif
2086 return q;
2087 }
2089 @ @c
2091 {
2093 halfword j;
2113 }
2114 }
2116 print_nlp();
2117 }
2122 {
2127 return p;
2128 }
2130 @* Attribute stuff.
2132 @c
2134 {
2141 return r;
2142 }
2144 @ @c
2146 {
2160 }
2161 return q;
2162 }
2164 @ @c
2166 {
2167 halfword p;
2168 register int i;
2179 }
2180 }
2184 }
2185 return;
2186 }
2188 @ @c
2190 {
2193 update_attribute_cache();
2195 return;
2196 }
2199 }
2200 }
2202 @ @c
2204 {
2207 update_attribute_cache();
2208 }
2209 return attr_list_cache ;
2210 }
2211 return null ;
2212 }
2215 @ @c
2217 {
2218 halfword old;
2231 }
2234 }
2236 @ @c
2238 {
2246 }
2250 }
2253 }
2254 }
2255 }
2258 {
2261 }
2262 }
2264 @ |p| is an attr list head, or zero
2265 @c
2267 {
2268 register halfword q;
2276 return q;
2277 }
2285 break;
2286 j++;
2288 }
2299 }
2300 return q;
2303 return null ;
2304 }
2305 }
2307 @ @c
2309 {
2310 register halfword p;
2314 return;
2324 return;
2325 }
2331 return;
2333 break;
2334 j++;
2336 }
2342 formatted_warning("nodes","node %d has an attribute list that is free already, case 1",(int) n);
2355 }
2364 }
2377 }
2380 }
2381 }
2383 @ @c
2385 {
2386 register halfword p;
2387 register int t;
2391 return null;
2394 return UNUSED_ATTRIBUTE;
2396 formatted_warning("nodes","node %d has an attribute list that is free already, case 2", (int) n);
2397 return UNUSED_ATTRIBUTE;
2398 }
2403 return UNUSED_ATTRIBUTE;
2406 break;
2407 }
2408 j++;
2410 }
2412 return UNUSED_ATTRIBUTE;
2419 }
2422 }
2429 }
2430 return t;
2433 return null;
2434 }
2435 }
2437 @ @c
2439 {
2440 register halfword p;
2442 return UNUSED_ATTRIBUTE;
2445 return UNUSED_ATTRIBUTE;
2451 return ret;
2452 return UNUSED_ATTRIBUTE;
2454 return UNUSED_ATTRIBUTE;
2455 }
2457 }
2458 return UNUSED_ATTRIBUTE;
2459 }
2461 @ @c
2463 {
2465 case hlist_node:
2466 case vlist_node:
2467 case ins_node:
2468 case whatsit_node:
2469 case mark_node:
2470 case adjust_node:
2471 case unset_node:
2474 break;
2475 case rule_node:
2477 break;
2478 case glue_node:
2481 break;
2482 case math_node:
2484 break;
2485 case disc_node:
2488 break;
2489 }
2490 }
2492 @ @c
2494 {
2501 }
2503 @ Each new type of node that appears in our data structure must be capable
2505 need for write-oriented whatsits are somewhat like those for mark nodes;
2508 @c
2510 {
2516 else
2518 }
2520 @ @c
2522 {
2524 case open_node:
2528 break;
2529 case write_node:
2532 break;
2533 case close_node:
2535 break;
2536 case special_node:
2539 break;
2540 case late_lua_node:
2542 break;
2543 case save_pos_node:
2545 break;
2546 case user_defined_node:
2551 case 'a':
2553 break;
2554 case 'n':
2558 break;
2559 case 's':
2561 print(user_node_value(p));
2563 break;
2564 case 't':
2566 break;
2569 break;
2570 }
2571 break;
2572 }
2573 }
2576 {
2577 }
2580 {
2582 case pdf_literal_node:
2584 break;
2585 case pdf_colorstack_node:
2589 case colorstack_set:
2591 break;
2592 case colorstack_push:
2594 break;
2595 case colorstack_pop:
2597 break;
2598 case colorstack_current:
2600 break;
2601 default:
2603 break;
2604 }
2607 break;
2608 case pdf_setmatrix_node:
2611 break;
2612 case pdf_save_node:
2614 break;
2615 case pdf_restore_node:
2617 break;
2618 case pdf_refobj_node:
2628 }
2630 }
2639 }
2640 break;
2641 case pdf_annot_node:
2645 break;
2646 case pdf_start_link_node:
2652 }
2657 return;
2658 }
2662 }
2664 case pdf_action_goto:
2671 }
2672 break;
2673 case pdf_action_page:
2677 break;
2678 case pdf_action_thread:
2685 }
2686 break;
2687 default:
2689 break;
2690 }
2691 break;
2692 case pdf_end_link_node:
2694 break;
2695 case pdf_dest_node:
2703 }
2706 case pdf_dest_xyz:
2711 }
2712 break;
2713 case pdf_dest_fitbh:
2715 break;
2716 case pdf_dest_fitbv:
2718 break;
2719 case pdf_dest_fitb:
2721 break;
2722 case pdf_dest_fith:
2724 break;
2725 case pdf_dest_fitv:
2727 break;
2728 case pdf_dest_fitr:
2731 break;
2732 case pdf_dest_fit:
2734 break;
2735 default:
2737 break;
2738 }
2739 break;
2740 case pdf_thread_node:
2741 case pdf_start_thread_node:
2744 else
2755 }
2762 }
2763 break;
2764 case pdf_end_thread_node:
2766 break;
2767 default:
2768 break;
2769 }
2770 }
2772 @ Now we are ready for |show_node_list| itself. This procedure has been
2773 written to be ``extra robust'' in the sense that it should not crash or get
2774 into a loop even if the data structures have been messed up by bugs in
2775 the rest of the program. You can safely call its parent routine
2778 fetch a |memory_word| whose variant is different from the way it was stored;
2780 contains a scaled integer, if |p| is a pointer that has been
2781 clobbered or chosen at random.
2784 @ |str_room| need not be checked; see |show_box|
2786 @ Recursive calls on |show_node_list| therefore use the following pattern:
2787 @c
2791 flush_char(); \
2797 {
2799 halfword w;
2804 return;
2805 }
2807 print_ln();
2814 return;
2815 }
2829 }
2832 case hlist_node:
2833 case vlist_node:
2834 case unset_node:
2840 else
2854 }
2858 }
2862 }
2865 /* The code will have to change in this place if |glue_ratio| is
2866 a structured type instead of an ordinary |real|. Note that this routine
2867 should avoid arithmetic errors even if the |glue_set| field holds an
2868 arbitrary random value. The following code assumes that a properly
2870 it is regarded as an integer; this precaution was adequate to prevent
2871 floating point underflow on the author's computer.
2872 */
2882 else
2887 }
2888 }
2893 }
2896 }
2898 break;
2899 case rule_node:
2911 }
2917 break;
2918 case ins_node:
2931 break;
2932 case dir_node:
2941 }
2942 break;
2943 case local_par_node:
2946 print_ln();
2947 print_current_string();
2951 print_ln();
2952 print_current_string();
2956 print_ln();
2957 print_current_string();
2965 }
2966 print_ln();
2967 print_current_string();
2975 }
2977 break;
2978 case boundary_node:
2987 }
2988 break;
2989 case whatsit_node:
2997 }
2998 break;
2999 case glue_node:
3005 case a_leaders:
3006 break;
3007 case c_leaders:
3009 break;
3010 case x_leaders:
3012 break;
3013 case g_leaders:
3015 break;
3016 default:
3018 }
3034 }
3036 }
3041 else
3043 }
3044 }
3045 break;
3046 case margin_kern_node:
3051 else
3053 break;
3054 case kern_node:
3068 }
3069 break;
3070 case math_node:
3075 else
3083 }
3084 break;
3085 case penalty_node:
3089 break;
3090 case disc_node:
3092 /* The |post_break| list of a discretionary node is indicated by a prefixed
3100 }
3105 break;
3106 case mark_node:
3112 }
3114 break;
3115 case adjust_node:
3121 break;
3122 case glue_spec_node:
3126 break;
3127 default:
3129 break;
3130 }
3131 }
3133 }
3134 }
3136 @ This routine finds the 'base' width of a horizontal box, using the same logic
3139 @c
3141 {
3149 goto FOUND;
3150 }
3152 case hlist_node:
3153 case vlist_node:
3154 case rule_node:
3156 goto FOUND;
3157 break;
3158 case margin_kern_node:
3160 break;
3161 case kern_node:
3163 break;
3164 case math_node:
3168 break;
3171 }
3173 case glue_node:
3175 values, since such values are subject to system-dependent rounding.
3176 System-dependent numbers are not allowed to infiltrate parameters like
3177 |pre_display_size|, since \TeX82 is supposed to make the same decisions on all
3178 machines.
3179 */
3187 }
3189 goto FOUND;
3190 break;
3191 default:
3193 break;
3194 }
3197 goto NOT_FOUND;
3198 FOUND:
3204 break;
3205 }
3206 NOT_FOUND:
3208 }
3209 return w;
3210 }
3212 @ @c
3214 {
3218 return q;
3219 }
3223 @ @c
3224 int var_used;
3226 @ Attribute lists need two extra globals to increase processing efficiency.
3227 |max_used_attr| limits the test loop that checks for set attributes, and
3228 |attr_list_cache| contains a pointer to an already created attribute list. It is
3229 set to the special value |cache_disabled| when the current value can no longer be
3231 ended.
3233 @c
3235 halfword attr_list_cache;
3237 @ From the computer's standpoint, \TeX's chief mission is to create
3238 horizontal and vertical lists. We shall now investigate how the elements
3239 of these lists are represented internally as nodes in the dynamic memory.
3241 A horizontal or vertical list is linked together by |link| fields in
3245 kinds of nodes. We do this by putting a `|type|' field in the first word,
3246 together with the link and an optional `|subtype|'.
3248 @ Character nodes appear only in horizontal lists, never in vertical lists.
3250 An |hlist_node| stands for a box that was made from a horizontal list.
3251 Each |hlist_node| is seven words long, and contains the following fields
3253 mention explicitly when discussing the other node types): The |height| and
3254 |width| and |depth| are scaled integers denoting the dimensions of the
3255 box. There is also a |shift_amount| field, a scaled integer indicating
3257 or how much it should be moved to the right (if it appears in a vertical
3260 is empty. Finally, there are three fields that represent the setting of
3263 |stretching| or |shrinking| or |normal| depending on whether or not the
3268 @ The |new_null_box| function returns a pointer to an |hlist_node| in
3270 The |subtype| field is set to |min_quarterword|, since that's the desired
3271 |span_count| value if this |hlist_node| is changed to an |unset_node|.
3273 @c
3278 return p;
3279 }
3281 @ A |vlist_node| is like an |hlist_node| in all respects except that it
3282 contains a vertical list.
3287 by running the rule up to the boundary of the innermost enclosing box.
3288 This is called a ``running dimension.'' The |width| is never running in
3289 an hlist; the |height| and |depth| are never running in a~vlist.
3291 @ A new rule node is delivered by the |new_rule| function. It
3292 makes all the dimensions ``running,'' so you have to change the
3293 ones that are not allowed to run.
3295 @c
3297 {
3299 return p;
3300 }
3302 @ Insertions are represented by |ins_node| records, where the |subtype|
3305 The |height| field of an |ins_node| is slightly misnamed; it actually holds
3306 the natural height plus depth of the vertical list being inserted.
3307 The |depth| field holds the |split_max_depth| to be used in case this
3308 insertion is split, and the |split_top_ptr| points to the corresponding
3309 |split_top_skip|. The |float_cost| field holds the |floating_penalty| that
3310 will be used if this insertion floats to a subsequent page after a
3311 split insertion of the same class. There is one more field, the
3312 |ins_ptr|, which points to the beginning of the vlist for the insertion.
3314 @ A |mark_node| has a |mark_ptr| field that points to the reference count
3316 In addition there is a |mark_class| field that contains the mark class.
3319 specifies material that will be moved out into the surrounding
3321 operation. The |adjust_ptr| field points to the vlist containing this
3322 material.
3325 glyph in a particular font, along with its attribute list. Older
3326 versions of \TeX\ could use token memory for characters, because the
3329 needed for characters that are larger than that, as well as a pointer
3330 to a potential attribute list, and the two displacement values.
3332 In turn, that made the node so large that it made sense to merge
3333 ligature glyphs as well, as that requires only one extra pointer. A
3334 few extra classes of glyph nodes will be introduced later. The
3335 unification of all those types makes it easier to manipulate lists of
3336 glyphs. The subtype differentiates various glyph kinds.
3338 First, here is a function that returns a pointer to a glyph node for a given
3339 glyph in a given font. If that glyph doesn't exist, |null| is returned
3340 instead. Nodes of this subtype are directly created only for accents
3342 conversion from |mlist| to |hlist|).
3344 @c
3346 {
3353 }
3354 return p;
3355 }
3357 @ A subset of the glyphs nodes represent ligatures: characters
3358 fabricated from the interaction of two or more actual characters. The
3359 characters that generated the ligature have not been forgotten, since
3360 they are needed for diagnostic messages; the |lig_ptr| field points to
3361 a linked list of character nodes for all original characters that have
3362 been deleted. (This list might be empty if the characters that
3363 generated the ligature were retained in other nodes.)
3366 the original source of the ligature included implicit left and/or
3367 right boundaries. These nodes are created by the C function |new_ligkern|.
3369 A third general type of glyphs could be called a character, as it
3370 only appears in lists that are not yet processed by the ligaturing and
3371 kerning steps of the program.
3373 |main_control| inserts these, and they are later converted to
3374 |subtype_normal| by |new_ligkern|.
3376 @c
3378 {
3383 else
3385 }
3388 {
3395 return p;
3396 }
3400 |new_ligkern|, at the end of which they are no longer needed.
3402 @ Here are a few handy helpers used by the list output routines.
3404 @c
3406 {
3408 return w;
3409 }
3412 {
3416 return w;
3417 }
3420 {
3426 return w;
3427 }
3436 and |no_break=null|.
3442 break. Otherwise the |hyphen_penalty| will be charged. The texts will
3443 actually be substituted into the list by the line-breaking algorithm if it
3444 decides to make the break, and the discretionary node will disappear at
3446 not chosen.
3448 @c
3453 return p;
3454 }
3456 @ A |whatsit_node| is a wild card reserved for extensions to \TeX. The
3459 format of the remaining words. When a |whatsit_node| is encountered
3461 careful not to mess up the rest of \TeX\ are able to make \TeX\ do new
3462 things by adding code at the end of the program. For example, there
3463 might be a `\TeX nicolor' extension to specify different colors of ink,
3464 @^extensions to \TeX@>
3465 and the whatsit node might contain the desired parameters.
3467 The present implementation of \TeX\ treats the features associated with
3469 illustrate how such routines might be coded. We shall defer further
3470 discussion of extensions until the end of this program.
3473 after mathematical formulas. The |subtype| field is |before| before the
3474 formula and |after| after it. There is a |surround| field, which represents
3477 @c
3479 {
3482 return p;
3483 }
3488 type codes, by permitting a break at glue in a list if and only if the
3489 |type| of the previous node is less than |math_node|. Furthermore, a
3490 node is discarded after a break if its type is |math_node| or~more.
3492 @ A |glue_node| represents glue in a list. However, it is really only
3493 a pointer to a separate glue specification, since \TeX\ makes use of the
3494 fact that many essentially identical nodes of glue are usually present.
3496 another packet of words that specify the stretch and shrink components, etc.
3498 Glue nodes also serve to represent leaders; the |subtype| is used to
3501 The |leader_ptr| field points to a rule node or to a box node containing the
3502 leaders; it is set to |null| in ordinary glue nodes.
3504 Many kinds of glue are computed from \TeX's ``skip'' parameters, and
3505 it is helpful to know which parameter has led to a particular glue node.
3506 Therefore the |subtype| is set to indicate the source of glue, whenever
3507 it originated as a parameter. We will be defining symbolic names for the
3509 etc.); it suffices for now to say that the |subtype| of parametric glue
3510 will be the same as the parameter number, plus~one.
3512 @ In math formulas there are two more possibilities for the |subtype| in a
3515 feature that cancels the glue node immediately following if it appears
3516 in a subscript.
3518 @ A glue specification has a halfword reference count in its first word,
3519 @^reference counts@>
3521 Note that the reference count appears in the same position as
3522 the |link| field in list nodes; this is the field that is initialized
3523 to |null| when a node is allocated, and it is also the field that is flagged
3524 by |empty_flag| in empty nodes.
3528 fields called |stretch_order| and |shrink_order|; these contain the
3530 corresponding to the stretch and shrink values.
3532 @ Here is a function that returns a pointer to a copy of a glue spec.
3533 The reference count in the copy is |null|, because there is assumed
3534 to be exactly one reference to the new specification.
3536 @c
3538 {
3540 }
3542 @ And here's a function that creates a glue node for a given parameter
3547 @c
3549 {
3557 return p;
3558 }
3560 @ Glue nodes that are more or less anonymous are created by |new_glue|,
3561 whose argument points to a glue specification.
3563 @c
3565 {
3572 return p;
3573 }
3575 @ Still another subroutine is needed: This one is sort of a combination
3576 of |new_param_glue| and |new_glue|. It creates a glue node for one of
3577 the current glue parameters, but it makes a fresh copy of the glue
3579 while the parameter will stay put.
3581 /*
3582 The global variable |temp_ptr| is set to the address of the new spec.
3583 */
3585 @c
3587 {
3595 return p;
3596 }
3599 amount of spacing. This spacing correction appears in horizontal lists
3600 between letters like A and V when the font designer said that it looks
3601 better to move them closer together or further apart. A kern node can
3602 also appear in a vertical list, when its `|width|' denotes additional
3603 spacing in the vertical direction. The |subtype| is either |normal| (for
3604 kerns inserted from font information or math mode calculations) or |explicit|
3609 @ The |new_kern| function creates a kern node having a given width.
3611 @c
3613 {
3616 return p;
3617 }
3619 @ A |penalty_node| specifies the penalty associated with line or page
3622 treated as infinity, and no break will be allowed for such high values.
3624 break will be forced.
3626 @ Anyone who has been reading the last few sections of the program will
3627 be able to guess what comes next.
3629 @c
3631 {
3634 return p;
3635 }
3637 @ You might think that we have introduced enough node types by now. Well,
3641 dimensions are their ``natural'' sizes before any glue adjustment has been
3643 field, which contains the total stretch of order |glue_order| that is
3644 present in the hlist or vlist being boxed.
3646 containing the total shrink of order |glue_sign| that is present.
3647 The |subtype| field is called |span_count|; an unset box typically
3649 Unset nodes will be changed to box nodes when alignment is completed.
3651 In fact, there are still more types coming. When we get to math formula
3653 of larger type codes will also be defined, for use in math mode only.
3656 changing any of the node sizes or even reordering the words of nodes,
3657 the |copy_node_list| procedure and the memory initialization code
3658 below may have to be changed. Such potentially dangerous parts of the
3659 program are listed in the index under `data structure assumptions'.
3661 However, other references to the nodes are made symbolically in terms of
3663 \TeX's other algorithms intact.
3664 @^system dependencies@>
3666 @ This function creates a |local_paragraph| node
3668 @c
3671 {
3672 int callback_id;
3673 halfword q;
3681 }
3686 }
3694 return p;
3695 }
3704 return p;
3705 }
3707 }
3709 return p;
3710 }