| blob | 4cbd0c00beaef2ee83cc706a8a9ad20c7d97be7e |
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 #ifdef CHECK_NODE_USAGE
634 {
682 }
685 {
686 halfword r;
691 s--;
692 }
694 && s != my_prealloc
695 && s != var_mem_max
696 && (r - s) < get_node_size(type(s), subtype(s))
697 && alink(s) != p) {
720 ) {
728 }
734 }
735 }
736 }
737 }
738 }
739 }
740 }
742 #endif
745 {
747 #ifdef CHECK_NODE_USAGE
748 int i;
750 check_static_node_mem();
754 }
755 }
756 test_count++;
758 formatted_error("nodes", "attempt to double-free glyph (%c) node %d, ignored", (int) character(p), (int) p);
760 formatted_error("nodes", "attempt to double-free %s node %d, ignored", get_node_name(type(p), subtype(p)), (int) p);
761 }
764 }
765 #endif
769 }
771 }
773 @ @c
775 {
777 #ifdef CHECK_NODE_USAGE
780 formatted_warning("nodes", "attempt to copy free glyph (%c) node %d, ignored", (int) character(p), (int) p);
782 formatted_warning("nodes", "attempt to copy free %s node %d, ignored", get_node_name(type(p), subtype(p)), (int) p);
783 }
785 }
786 #endif
790 }
792 }
794 @ @c
796 {
799 /*
800 It should be possible to do this memset at |free_node()|.
804 word less than |s|
805 */
808 case glyph_node:
810 break;
811 case hlist_node:
812 case vlist_node:
814 break;
815 case disc_node:
825 break;
826 case rule_node:
833 break;
834 case whatsit_node:
839 }
840 break;
841 case unset_node:
843 break;
844 case pseudo_line_node:
845 case shape_node:
847 but the overall allocation faster then an explicit test
848 at the top of |new_node()|.
849 */
854 }
855 break;
856 default:
857 break;
858 }
862 case math_node:
865 break;
866 case glue_node:
869 break;
870 case kern_node:
874 }
875 break;
876 case hlist_node:
877 case vlist_node:
878 case unset_node:
881 break;
882 case rule_node:
885 break;
886 }
887 }
892 }
895 return n;
896 }
899 {
904 return n;
905 }
908 {
915 return n;
916 }
918 @ makes a duplicate of the node list that starts at |p| and returns a
919 pointer to the new list
921 @c
923 {
926 register halfword s ;
934 }
937 }
939 return h;
940 }
943 {
945 }
953 } \
962 } \
965 @ make a dupe of a single node
967 @c
969 {
970 halfword s ;
972 case write_node:
973 case special_node:
975 break;
976 case late_lua_node:
978 break;
979 case user_defined_node:
981 case 'a':
983 break;
984 case 'l':
986 break;
987 case 'n':
990 break;
991 case 's':
993 break;
994 case 't':
996 break;
997 }
998 break;
999 default:
1000 break ;
1001 }
1002 }
1005 {
1006 }
1009 {
1011 case pdf_literal_node:
1013 break;
1014 case pdf_colorstack_node:
1017 break;
1018 case pdf_setmatrix_node:
1020 break;
1021 case pdf_annot_node:
1023 break;
1024 case pdf_start_link_node:
1028 break;
1029 case pdf_dest_node:
1032 break;
1033 case pdf_thread_node:
1034 case pdf_start_thread_node:
1039 break;
1040 default:
1041 break;
1042 }
1043 }
1046 {
1050 register int i;
1053 return r;
1054 }
1058 (void) memcpy((void *) (varmem + r), (void *) (varmem + p), (sizeof(memory_word) * (unsigned) i));
1063 case math_node:
1066 break;
1067 case kern_node:
1070 break;
1071 }
1072 }
1077 }
1081 case glyph_node:
1083 break;
1084 case glue_node:
1086 break;
1087 case hlist_node:
1088 case vlist_node:
1089 case unset_node:
1091 break;
1092 case disc_node:
1101 }
1110 }
1119 }
1120 break;
1121 case math_node:
1122 break;
1123 case ins_node:
1125 break;
1126 case margin_kern_node:
1128 break;
1129 case mark_node:
1131 break;
1132 case adjust_node:
1134 break;
1135 case choice_node:
1140 break;
1141 case simple_noad:
1145 break;
1146 case radical_noad:
1152 break;
1153 case accent_noad:
1160 break;
1161 case fence_noad:
1163 break;
1164 case sub_box_node:
1165 case sub_mlist_node:
1167 break;
1168 case fraction_noad:
1173 break;
1174 case glue_spec_node:
1175 case dir_node:
1176 case local_par_node:
1177 case boundary_node:
1178 break;
1179 case whatsit_node:
1187 }
1188 break;
1189 }
1190 return r;
1191 }
1198 @ @c
1201 {
1203 case open_node:
1204 case write_node:
1205 case close_node:
1206 case save_pos_node:
1207 break;
1208 case special_node:
1210 break;
1211 case late_lua_node:
1213 break;
1214 case user_defined_node:
1216 case 'a':
1218 break;
1219 case 'd':
1220 break;
1221 case 'n':
1223 break;
1224 case 's':
1226 break;
1227 case 't':
1229 break;
1230 default:
1231 {
1237 NULL
1238 };
1240 }
1241 break;
1242 }
1243 break;
1244 }
1245 }
1248 {
1249 }
1252 {
1254 case pdf_save_node:
1255 case pdf_restore_node:
1256 case pdf_refobj_node:
1257 case pdf_end_link_node:
1258 case pdf_end_thread_node:
1259 break;
1260 case pdf_literal_node:
1262 break;
1263 case pdf_colorstack_node:
1266 break;
1267 case pdf_setmatrix_node:
1269 break;
1270 case pdf_annot_node:
1272 break;
1273 case pdf_link_data_node:
1274 break;
1275 case pdf_start_link_node:
1279 break;
1280 case pdf_dest_node:
1283 break;
1284 case pdf_action_node:
1294 }
1295 break;
1296 case pdf_thread_data_node:
1297 break;
1298 case pdf_thread_node:
1299 case pdf_start_thread_node:
1304 break;
1305 }
1306 }
1309 {
1310 halfword w;
1312 return;
1314 return;
1316 case glyph_node:
1318 break;
1319 case glue_node:
1321 break;
1322 case hlist_node:
1323 case vlist_node:
1324 case unset_node:
1326 break;
1327 case disc_node:
1332 break;
1333 case rule_node:
1334 case kern_node:
1335 case penalty_node:
1336 case math_node:
1337 break;
1338 case glue_spec_node:
1342 //}
1344 break ;
1345 case dir_node:
1346 case local_par_node:
1347 case boundary_node:
1348 break;
1349 case whatsit_node:
1357 }
1358 break;
1359 case ins_node:
1361 break;
1362 case margin_kern_node:
1364 break;
1365 case mark_node:
1367 break;
1368 case adjust_node:
1370 break;
1372 break;
1373 case choice_node:
1378 break;
1379 case simple_noad:
1383 break;
1384 case radical_noad:
1390 break;
1391 case accent_noad:
1398 break;
1399 case fence_noad:
1401 break;
1403 case math_char_node:
1404 case math_text_char_node:
1405 break;
1406 case sub_box_node:
1407 case sub_mlist_node:
1409 break;
1410 case fraction_noad:
1415 break;
1416 case pseudo_file_node:
1418 break;
1419 case pseudo_line_node:
1420 case shape_node:
1422 return;
1423 break;
1424 case align_stack_node:
1425 case span_node:
1426 case movement_node:
1427 case if_node:
1428 case nesting_node:
1429 case unhyphenated_node:
1430 case hyphenated_node:
1431 case delta_node:
1432 case passive_node:
1433 case inserting_node:
1434 case split_up_node:
1435 case expr_node:
1436 case attribute_node:
1437 case attribute_list_node:
1438 case temp_node:
1439 break;
1440 default:
1442 return;
1443 }
1447 }
1449 return;
1450 }
1452 @ @c
1457 return;
1459 return;
1465 }
1467 }
1469 @ @c
1471 {
1474 case special_node:
1476 break;
1477 case user_defined_node:
1479 case 'a':
1481 break;
1482 case 't':
1484 break;
1485 case 'n':
1487 break;
1488 case 's':
1489 case 'd':
1490 break;
1491 default:
1493 break;
1494 }
1495 break;
1496 case open_node:
1497 case write_node:
1498 case close_node:
1499 case save_pos_node:
1500 break;
1501 }
1502 }
1505 {
1506 }
1509 {
1511 case pdf_literal_node:
1514 break;
1515 case pdf_colorstack_node:
1518 break;
1519 case pdf_setmatrix_node:
1521 break;
1522 case late_lua_node:
1527 break;
1528 case pdf_annot_node:
1530 break;
1531 case pdf_start_link_node:
1535 break;
1536 case pdf_dest_node:
1539 break;
1540 case pdf_thread_node:
1541 case pdf_start_thread_node:
1546 break;
1547 case pdf_save_node:
1548 case pdf_restore_node:
1549 case pdf_refobj_node:
1550 case pdf_end_link_node:
1551 case pdf_end_thread_node:
1552 break;
1553 default:
1555 break;
1556 }
1557 }
1560 {
1561 halfword w ;
1563 case glyph_node:
1565 break;
1566 case glue_node:
1568 break;
1569 case hlist_node:
1570 case vlist_node:
1571 case unset_node:
1572 case align_record_node:
1574 break;
1575 case ins_node:
1577 break;
1578 case whatsit_node:
1586 }
1587 break;
1588 case margin_kern_node:
1590 break;
1591 case math_node:
1592 break;
1593 case disc_node:
1597 break;
1598 case adjust_node:
1600 break;
1601 case pseudo_file_node:
1603 break;
1604 case pseudo_line_node:
1605 case shape_node:
1606 break;
1607 case choice_node:
1612 break;
1613 case fraction_noad:
1618 break;
1619 case simple_noad:
1623 break;
1624 case radical_noad:
1630 break;
1631 case accent_noad:
1638 break;
1639 case fence_noad:
1641 break;
1642 /*
1643 case rule_node:
1644 case kern_node:
1645 case penalty_node:
1646 case mark_node:
1647 case style_node:
1648 case attribute_list_node:
1649 case attribute_node:
1650 case glue_spec_node:
1651 case temp_node:
1652 case align_stack_node:
1653 case movement_node:
1654 case if_node:
1655 case nesting_node:
1656 case span_node:
1657 case unhyphenated_node:
1658 case hyphenated_node:
1659 case delta_node:
1660 case passive_node:
1661 case expr_node:
1662 case dir_node:
1663 case boundary_node:
1664 case local_par_node:
1665 break;
1666 default:
1668 */
1669 }
1670 }
1672 @ @c
1674 {
1677 return;
1684 }
1685 }
1687 @ @c
1689 {
1690 register halfword r;
1696 #ifdef CHECK_NODE_USAGE
1698 #endif
1701 return r;
1702 }
1707 return null;
1708 }
1709 }
1711 @ @c
1713 {
1716 return;
1717 }
1718 #ifdef CHECK_NODE_USAGE
1720 #endif
1730 }
1732 }
1735 }
1737 @ @c
1739 {
1742 #ifdef CHECK_NODE_USAGE
1744 #endif
1747 }
1749 #ifdef CHECK_NODE_USAGE
1751 #endif
1754 }
1756 @ @c
1758 {
1761 /* message ?
1765 */
1770 }
1772 #ifdef CHECK_NODE_USAGE
1776 }
1778 #endif
1890 }
1892 @ @c
1894 {
1898 #ifdef CHECK_NODE_USAGE
1900 #endif
1904 }
1906 @ it makes sense to enlarge the varmem array immediately
1907 @c
1910 {
1911 int x;
1917 #ifdef CHECK_NODE_USAGE
1921 #endif
1931 }
1933 }
1934 }
1936 @ @c
1938 {
1939 register int t;
1954 }
1958 }
1960 #ifdef CHECK_NODE_USAGE
1962 #endif
1968 return null;
1969 }
1972 int x;
1981 }
1989 }
1991 }
1992 }
1993 }
1996 varmem = (memory_word *) realloc((void *) varmem, sizeof(memory_word) * (unsigned) (var_mem_max + x));
1999 }
2001 #ifdef CHECK_NODE_USAGE
2005 }
2007 #endif
2013 }
2018 }
2021 return null;
2022 }
2023 }
2025 @ @c
2027 {
2029 #ifdef CHECK_NODE_USAGE
2031 int i;
2044 }
2045 }
2046 }
2049 int j =
2059 }
2060 }
2061 #else
2063 #endif
2064 return s;
2065 }
2067 @ @c
2069 {
2071 #ifdef CHECK_NODE_USAGE
2083 }
2085 }
2086 }
2088 #endif
2089 return q;
2090 }
2092 @ @c
2094 {
2096 halfword j;
2116 }
2117 }
2119 print_nlp();
2120 }
2125 {
2130 return p;
2131 }
2133 @* Attribute stuff.
2135 @c
2137 {
2144 return r;
2145 }
2147 @ @c
2149 {
2163 }
2164 return q;
2165 }
2167 @ @c
2169 {
2170 halfword p;
2171 register int i;
2182 }
2183 }
2187 }
2188 return;
2189 }
2191 @ @c
2193 {
2196 update_attribute_cache();
2198 return;
2199 }
2202 }
2203 }
2205 @ @c
2207 {
2210 update_attribute_cache();
2211 }
2212 return attr_list_cache ;
2213 }
2214 return null ;
2215 }
2218 @ @c
2220 {
2221 halfword old;
2234 }
2237 }
2239 @ @c
2241 {
2249 }
2253 }
2256 }
2257 }
2258 }
2261 {
2264 }
2265 }
2267 @ |p| is an attr list head, or zero
2268 @c
2270 {
2271 register halfword q;
2279 return q;
2280 }
2288 break;
2289 j++;
2291 }
2302 }
2303 return q;
2306 return null ;
2307 }
2308 }
2310 @ @c
2312 {
2313 register halfword p;
2317 return;
2327 return;
2328 }
2334 return;
2336 break;
2337 j++;
2339 }
2345 formatted_warning("nodes","node %d has an attribute list that is free already, case 1",(int) n);
2358 }
2367 }
2380 }
2383 }
2384 }
2386 @ @c
2388 {
2389 register halfword p;
2390 register int t;
2394 return null;
2397 return UNUSED_ATTRIBUTE;
2399 formatted_warning("nodes","node %d has an attribute list that is free already, case 2", (int) n);
2400 return UNUSED_ATTRIBUTE;
2401 }
2406 return UNUSED_ATTRIBUTE;
2409 break;
2410 }
2411 j++;
2413 }
2415 return UNUSED_ATTRIBUTE;
2422 }
2425 }
2432 }
2433 return t;
2436 return null;
2437 }
2438 }
2440 @ @c
2442 {
2443 register halfword p;
2445 return UNUSED_ATTRIBUTE;
2448 return UNUSED_ATTRIBUTE;
2454 return ret;
2455 return UNUSED_ATTRIBUTE;
2457 return UNUSED_ATTRIBUTE;
2458 }
2460 }
2461 return UNUSED_ATTRIBUTE;
2462 }
2464 @ @c
2466 {
2468 case hlist_node:
2469 case vlist_node:
2470 case ins_node:
2471 case whatsit_node:
2472 case mark_node:
2473 case adjust_node:
2474 case unset_node:
2477 break;
2478 case rule_node:
2480 break;
2481 case glue_node:
2484 break;
2485 case math_node:
2487 break;
2488 case disc_node:
2491 break;
2492 }
2493 }
2495 @ @c
2497 {
2504 }
2506 @ Each new type of node that appears in our data structure must be capable
2508 need for write-oriented whatsits are somewhat like those for mark nodes;
2511 @c
2513 {
2519 else
2521 }
2523 @ @c
2525 {
2527 case open_node:
2531 break;
2532 case write_node:
2535 break;
2536 case close_node:
2538 break;
2539 case special_node:
2542 break;
2543 case late_lua_node:
2545 break;
2546 case save_pos_node:
2548 break;
2549 case user_defined_node:
2554 case 'a':
2556 break;
2557 case 'n':
2561 break;
2562 case 's':
2564 print(user_node_value(p));
2566 break;
2567 case 't':
2569 break;
2572 break;
2573 }
2574 break;
2575 }
2576 }
2579 {
2580 }
2583 {
2585 case pdf_literal_node:
2587 break;
2588 case pdf_colorstack_node:
2592 case colorstack_set:
2594 break;
2595 case colorstack_push:
2597 break;
2598 case colorstack_pop:
2600 break;
2601 case colorstack_current:
2603 break;
2604 default:
2606 break;
2607 }
2610 break;
2611 case pdf_setmatrix_node:
2614 break;
2615 case pdf_save_node:
2617 break;
2618 case pdf_restore_node:
2620 break;
2621 case pdf_refobj_node:
2631 }
2633 }
2642 }
2643 break;
2644 case pdf_annot_node:
2648 break;
2649 case pdf_start_link_node:
2655 }
2660 return;
2661 }
2665 }
2667 case pdf_action_goto:
2674 }
2675 break;
2676 case pdf_action_page:
2680 break;
2681 case pdf_action_thread:
2688 }
2689 break;
2690 default:
2692 break;
2693 }
2694 break;
2695 case pdf_end_link_node:
2697 break;
2698 case pdf_dest_node:
2706 }
2709 case pdf_dest_xyz:
2714 }
2715 break;
2716 case pdf_dest_fitbh:
2718 break;
2719 case pdf_dest_fitbv:
2721 break;
2722 case pdf_dest_fitb:
2724 break;
2725 case pdf_dest_fith:
2727 break;
2728 case pdf_dest_fitv:
2730 break;
2731 case pdf_dest_fitr:
2734 break;
2735 case pdf_dest_fit:
2737 break;
2738 default:
2740 break;
2741 }
2742 break;
2743 case pdf_thread_node:
2744 case pdf_start_thread_node:
2747 else
2758 }
2765 }
2766 break;
2767 case pdf_end_thread_node:
2769 break;
2770 default:
2771 break;
2772 }
2773 }
2775 @ Now we are ready for |show_node_list| itself. This procedure has been
2776 written to be ``extra robust'' in the sense that it should not crash or get
2777 into a loop even if the data structures have been messed up by bugs in
2778 the rest of the program. You can safely call its parent routine
2781 fetch a |memory_word| whose variant is different from the way it was stored;
2783 contains a scaled integer, if |p| is a pointer that has been
2784 clobbered or chosen at random.
2787 @ |str_room| need not be checked; see |show_box|
2789 @ Recursive calls on |show_node_list| therefore use the following pattern:
2790 @c
2794 flush_char(); \
2800 {
2802 halfword w;
2807 return;
2808 }
2810 print_ln();
2817 return;
2818 }
2832 }
2835 case hlist_node:
2836 case vlist_node:
2837 case unset_node:
2843 else
2857 }
2861 }
2865 }
2868 /* The code will have to change in this place if |glue_ratio| is
2869 a structured type instead of an ordinary |real|. Note that this routine
2870 should avoid arithmetic errors even if the |glue_set| field holds an
2871 arbitrary random value. The following code assumes that a properly
2873 it is regarded as an integer; this precaution was adequate to prevent
2874 floating point underflow on the author's computer.
2875 */
2885 else
2890 }
2891 }
2896 }
2899 }
2901 break;
2902 case rule_node:
2914 }
2920 break;
2921 case ins_node:
2934 break;
2935 case dir_node:
2944 }
2945 break;
2946 case local_par_node:
2949 print_ln();
2950 print_current_string();
2954 print_ln();
2955 print_current_string();
2959 print_ln();
2960 print_current_string();
2968 }
2969 print_ln();
2970 print_current_string();
2978 }
2980 break;
2981 case boundary_node:
2988 break;
2991 break;
2994 break;
2995 default:
2999 break;
3000 }
3003 }
3004 break;
3005 case whatsit_node:
3013 }
3014 break;
3015 case glue_node:
3021 case a_leaders:
3022 break;
3023 case c_leaders:
3025 break;
3026 case x_leaders:
3028 break;
3029 case g_leaders:
3031 break;
3032 default:
3034 }
3050 }
3052 }
3057 else
3059 }
3060 }
3061 break;
3062 case margin_kern_node:
3067 else
3069 break;
3070 case kern_node:
3084 }
3085 break;
3086 case math_node:
3091 else
3099 }
3100 break;
3101 case penalty_node:
3105 break;
3106 case disc_node:
3108 /* The |post_break| list of a discretionary node is indicated by a prefixed
3116 }
3121 break;
3122 case mark_node:
3128 }
3130 break;
3131 case adjust_node:
3137 break;
3138 case glue_spec_node:
3142 break;
3143 default:
3145 break;
3146 }
3147 }
3149 }
3150 }
3152 @ This routine finds the 'base' width of a horizontal box, using the same logic
3155 @c
3157 {
3165 goto FOUND;
3166 }
3168 case hlist_node:
3169 case vlist_node:
3170 case rule_node:
3172 goto FOUND;
3173 break;
3174 case margin_kern_node:
3176 break;
3177 case kern_node:
3179 break;
3180 case math_node:
3184 break;
3187 }
3189 case glue_node:
3191 values, since such values are subject to system-dependent rounding.
3192 System-dependent numbers are not allowed to infiltrate parameters like
3193 |pre_display_size|, since \TeX82 is supposed to make the same decisions on all
3194 machines.
3195 */
3203 }
3205 goto FOUND;
3206 break;
3207 default:
3209 break;
3210 }
3213 goto NOT_FOUND;
3214 FOUND:
3220 break;
3221 }
3222 NOT_FOUND:
3224 }
3225 return w;
3226 }
3228 @ @c
3230 {
3234 return q;
3235 }
3239 @ @c
3240 int var_used;
3242 @ Attribute lists need two extra globals to increase processing efficiency.
3243 |max_used_attr| limits the test loop that checks for set attributes, and
3244 |attr_list_cache| contains a pointer to an already created attribute list. It is
3245 set to the special value |cache_disabled| when the current value can no longer be
3247 ended.
3249 @c
3251 halfword attr_list_cache;
3253 @ From the computer's standpoint, \TeX's chief mission is to create
3254 horizontal and vertical lists. We shall now investigate how the elements
3255 of these lists are represented internally as nodes in the dynamic memory.
3257 A horizontal or vertical list is linked together by |link| fields in
3261 kinds of nodes. We do this by putting a `|type|' field in the first word,
3262 together with the link and an optional `|subtype|'.
3264 @ Character nodes appear only in horizontal lists, never in vertical lists.
3266 An |hlist_node| stands for a box that was made from a horizontal list.
3267 Each |hlist_node| is seven words long, and contains the following fields
3269 mention explicitly when discussing the other node types): The |height| and
3270 |width| and |depth| are scaled integers denoting the dimensions of the
3271 box. There is also a |shift_amount| field, a scaled integer indicating
3273 or how much it should be moved to the right (if it appears in a vertical
3276 is empty. Finally, there are three fields that represent the setting of
3279 |stretching| or |shrinking| or |normal| depending on whether or not the
3284 @ The |new_null_box| function returns a pointer to an |hlist_node| in
3286 The |subtype| field is set to |min_quarterword|, since that's the desired
3287 |span_count| value if this |hlist_node| is changed to an |unset_node|.
3289 @c
3294 return p;
3295 }
3297 @ A |vlist_node| is like an |hlist_node| in all respects except that it
3298 contains a vertical list.
3303 by running the rule up to the boundary of the innermost enclosing box.
3304 This is called a ``running dimension.'' The |width| is never running in
3305 an hlist; the |height| and |depth| are never running in a~vlist.
3307 @ A new rule node is delivered by the |new_rule| function. It
3308 makes all the dimensions ``running,'' so you have to change the
3309 ones that are not allowed to run.
3311 @c
3313 {
3315 return p;
3316 }
3318 @ Insertions are represented by |ins_node| records, where the |subtype|
3321 The |height| field of an |ins_node| is slightly misnamed; it actually holds
3322 the natural height plus depth of the vertical list being inserted.
3323 The |depth| field holds the |split_max_depth| to be used in case this
3324 insertion is split, and the |split_top_ptr| points to the corresponding
3325 |split_top_skip|. The |float_cost| field holds the |floating_penalty| that
3326 will be used if this insertion floats to a subsequent page after a
3327 split insertion of the same class. There is one more field, the
3328 |ins_ptr|, which points to the beginning of the vlist for the insertion.
3330 @ A |mark_node| has a |mark_ptr| field that points to the reference count
3332 In addition there is a |mark_class| field that contains the mark class.
3335 specifies material that will be moved out into the surrounding
3337 operation. The |adjust_ptr| field points to the vlist containing this
3338 material.
3341 glyph in a particular font, along with its attribute list. Older
3342 versions of \TeX\ could use token memory for characters, because the
3345 needed for characters that are larger than that, as well as a pointer
3346 to a potential attribute list, and the two displacement values.
3348 In turn, that made the node so large that it made sense to merge
3349 ligature glyphs as well, as that requires only one extra pointer. A
3350 few extra classes of glyph nodes will be introduced later. The
3351 unification of all those types makes it easier to manipulate lists of
3352 glyphs. The subtype differentiates various glyph kinds.
3354 First, here is a function that returns a pointer to a glyph node for a given
3355 glyph in a given font. If that glyph doesn't exist, |null| is returned
3356 instead. Nodes of this subtype are directly created only for accents
3358 conversion from |mlist| to |hlist|).
3360 @c
3362 {
3369 }
3370 return p;
3371 }
3373 @ A subset of the glyphs nodes represent ligatures: characters
3374 fabricated from the interaction of two or more actual characters. The
3375 characters that generated the ligature have not been forgotten, since
3376 they are needed for diagnostic messages; the |lig_ptr| field points to
3377 a linked list of character nodes for all original characters that have
3378 been deleted. (This list might be empty if the characters that
3379 generated the ligature were retained in other nodes.)
3382 the original source of the ligature included implicit left and/or
3383 right boundaries. These nodes are created by the C function |new_ligkern|.
3385 A third general type of glyphs could be called a character, as it
3386 only appears in lists that are not yet processed by the ligaturing and
3387 kerning steps of the program.
3389 |main_control| inserts these, and they are later converted to
3390 |subtype_normal| by |new_ligkern|.
3392 @c
3394 {
3399 else
3401 }
3404 {
3411 return p;
3412 }
3416 |new_ligkern|, at the end of which they are no longer needed.
3418 @ Here are a few handy helpers used by the list output routines.
3420 @c
3422 {
3424 return w;
3425 }
3428 {
3432 return w;
3433 }
3436 {
3442 return w;
3443 }
3452 and |no_break=null|.
3458 break. Otherwise the |hyphen_penalty| will be charged. The texts will
3459 actually be substituted into the list by the line-breaking algorithm if it
3460 decides to make the break, and the discretionary node will disappear at
3462 not chosen.
3464 @c
3469 return p;
3470 }
3472 @ A |whatsit_node| is a wild card reserved for extensions to \TeX. The
3475 format of the remaining words. When a |whatsit_node| is encountered
3477 careful not to mess up the rest of \TeX\ are able to make \TeX\ do new
3478 things by adding code at the end of the program. For example, there
3479 might be a `\TeX nicolor' extension to specify different colors of ink,
3480 @^extensions to \TeX@>
3481 and the whatsit node might contain the desired parameters.
3483 The present implementation of \TeX\ treats the features associated with
3485 illustrate how such routines might be coded. We shall defer further
3486 discussion of extensions until the end of this program.
3489 after mathematical formulas. The |subtype| field is |before| before the
3490 formula and |after| after it. There is a |surround| field, which represents
3493 @c
3495 {
3498 return p;
3499 }
3504 type codes, by permitting a break at glue in a list if and only if the
3505 |type| of the previous node is less than |math_node|. Furthermore, a
3506 node is discarded after a break if its type is |math_node| or~more.
3508 @ A |glue_node| represents glue in a list. However, it is really only
3509 a pointer to a separate glue specification, since \TeX\ makes use of the
3510 fact that many essentially identical nodes of glue are usually present.
3512 another packet of words that specify the stretch and shrink components, etc.
3514 Glue nodes also serve to represent leaders; the |subtype| is used to
3517 The |leader_ptr| field points to a rule node or to a box node containing the
3518 leaders; it is set to |null| in ordinary glue nodes.
3520 Many kinds of glue are computed from \TeX's ``skip'' parameters, and
3521 it is helpful to know which parameter has led to a particular glue node.
3522 Therefore the |subtype| is set to indicate the source of glue, whenever
3523 it originated as a parameter. We will be defining symbolic names for the
3525 etc.); it suffices for now to say that the |subtype| of parametric glue
3526 will be the same as the parameter number, plus~one.
3528 @ In math formulas there are two more possibilities for the |subtype| in a
3531 feature that cancels the glue node immediately following if it appears
3532 in a subscript.
3534 @ A glue specification has a halfword reference count in its first word,
3535 @^reference counts@>
3537 Note that the reference count appears in the same position as
3538 the |link| field in list nodes; this is the field that is initialized
3539 to |null| when a node is allocated, and it is also the field that is flagged
3540 by |empty_flag| in empty nodes.
3544 fields called |stretch_order| and |shrink_order|; these contain the
3546 corresponding to the stretch and shrink values.
3548 @ Here is a function that returns a pointer to a copy of a glue spec.
3549 The reference count in the copy is |null|, because there is assumed
3550 to be exactly one reference to the new specification.
3552 @c
3554 {
3556 }
3558 @ And here's a function that creates a glue node for a given parameter
3563 @c
3565 {
3573 return p;
3574 }
3576 @ Glue nodes that are more or less anonymous are created by |new_glue|,
3577 whose argument points to a glue specification.
3579 @c
3581 {
3588 return p;
3589 }
3591 @ Still another subroutine is needed: This one is sort of a combination
3592 of |new_param_glue| and |new_glue|. It creates a glue node for one of
3593 the current glue parameters, but it makes a fresh copy of the glue
3595 while the parameter will stay put.
3597 /*
3598 The global variable |temp_ptr| is set to the address of the new spec.
3599 */
3601 @c
3603 {
3611 return p;
3612 }
3615 amount of spacing. This spacing correction appears in horizontal lists
3616 between letters like A and V when the font designer said that it looks
3617 better to move them closer together or further apart. A kern node can
3618 also appear in a vertical list, when its `|width|' denotes additional
3619 spacing in the vertical direction. The |subtype| is either |normal| (for
3620 kerns inserted from font information or math mode calculations) or |explicit|
3625 @ The |new_kern| function creates a kern node having a given width.
3627 @c
3629 {
3632 return p;
3633 }
3635 @ A |penalty_node| specifies the penalty associated with line or page
3638 treated as infinity, and no break will be allowed for such high values.
3640 break will be forced.
3642 @ Anyone who has been reading the last few sections of the program will
3643 be able to guess what comes next.
3645 @c
3647 {
3650 return p;
3651 }
3653 @ You might think that we have introduced enough node types by now. Well,
3657 dimensions are their ``natural'' sizes before any glue adjustment has been
3659 field, which contains the total stretch of order |glue_order| that is
3660 present in the hlist or vlist being boxed.
3662 containing the total shrink of order |glue_sign| that is present.
3663 The |subtype| field is called |span_count|; an unset box typically
3665 Unset nodes will be changed to box nodes when alignment is completed.
3667 In fact, there are still more types coming. When we get to math formula
3669 of larger type codes will also be defined, for use in math mode only.
3672 changing any of the node sizes or even reordering the words of nodes,
3673 the |copy_node_list| procedure and the memory initialization code
3674 below may have to be changed. Such potentially dangerous parts of the
3675 program are listed in the index under `data structure assumptions'.
3677 However, other references to the nodes are made symbolically in terms of
3679 \TeX's other algorithms intact.
3680 @^system dependencies@>
3682 @ This function creates a |local_paragraph| node
3684 @c
3687 {
3688 int callback_id;
3689 halfword q;
3697 }
3702 }
3710 return p;
3711 }
3720 return p;
3721 }
3723 }
3725 return p;
3726 }