| blob | de718139923060d261f13dfcdf639c09f5381af8 |
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 };
116 };
119 };
122 };
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 };
242 };
245 };
248 };
251 };
254 };
257 };
260 };
263 };
272 };
275 };
278 };
281 };
284 };
287 };
290 };
293 };
296 };
299 };
302 };
306 };
310 };
313 };
316 };
345 { math_text_char_node, math_kernel_node_size, node_fields_math_text_char, "math_text_char", 15 },
370 };
372 #define last_normal_node shape_node
376 };
379 };
381 node_info whatsit_node_data[] = {
390 { user_defined_node, user_defined_node_size, node_fields_whatsit_user_defined, "user_defined", -1 },
404 { pdf_start_link_node, pdf_annot_node_size, node_fields_whatsit_pdf_start_link, "pdf_start_link", -1 },
405 { pdf_end_link_node, pdf_end_link_node_size, node_fields_whatsit_pdf_end_link, "pdf_end_link", -1 },
409 { pdf_start_thread_node, pdf_thread_node_size, node_fields_whatsit_pdf_start_thread, "pdf_start_thread", -1 },
410 { pdf_end_thread_node, pdf_end_thread_node_size, node_fields_whatsit_pdf_end_thread, "pdf_end_thread", -1 },
413 { pdf_colorstack_node, pdf_colorstack_node_size, node_fields_whatsit_pdf_colorstack, "pdf_colorstack", -1 },
414 { pdf_setmatrix_node, pdf_setmatrix_node_size, node_fields_whatsit_pdf_setmatrix, "pdf_setmatrix", -1 },
416 { pdf_restore_node, pdf_restore_node_size, node_fields_whatsit_pdf_restore, "pdf_restore", -1 },
419 };
421 #define last_whatsit_node pdf_restore_node
423 @
426 in the properties, we create a new table and give it the original one as a metatable.
428 deep copy made no sense, nor did nilling. In the end both the shallow copy and the metatable
429 variant were both ok, although the second ons is slower. The most important aspect to keep
430 in mind is that references to other nodes in properties no longer can be valid for that
432 complicates matters.
434 When defining a new node, we could already allocate a table but it is rather easy to do
435 that at the lua end e.g. using a metatable __index method. That way it is under macro
436 package control.
439 memory consumption raise unneeded when we have temporary large node lists and after that
440 only small lists.
443 following:
447 that slow when it comes to accessing them
449 - a bitset in the node but again the gain compared to attributes is neglectable and it also
450 demands a pretty string agreement over what bit represents what, and this is unlikely to
452 but decided that it doesn't pay off
456 this mechanism makes sure that properties are cleaned up when a node is freed. Also, the
457 advantage of a more or less global properties table is that we stay at the lua end. An
458 alternative is to store a reference in the node itself but that is complicated by the fact
460 it too much.
462 @c
467 @
469 important, don't keep resolving the registry index.
471 @c
472 #define lua_properties_push do { \
478 } \
479 } \
482 #define lua_properties_pop do { \
487 } \
508 } \
509 } \
512 /*
513 For a moment I considered supporting all kind of data types but in practice
514 that makes no sense. So we stick to a cheap shallow copy with as option a
526 }
528 }
541 } \
542 } \
545 */
563 } \
567 } \
579 } \
583 } \
584 } \
585 } \
590 @ @c
592 {
594 #ifdef CHECK_NODE_USAGE
597 }
598 #else
600 #endif
601 }
603 }
605 @ @c
627 #ifdef CHECK_NODE_USAGE
630 {
678 }
681 {
682 halfword r;
687 s--;
688 }
690 && s != my_prealloc
691 && s != var_mem_max
692 && (r - s) < get_node_size(type(s), subtype(s))
693 && alink(s) != p) {
716 ) {
724 }
730 }
731 }
732 }
733 }
734 }
735 }
736 }
738 #endif
741 {
743 #ifdef CHECK_NODE_USAGE
744 int i;
746 check_static_node_mem();
750 }
751 }
752 test_count++;
754 formatted_error("nodes", "attempt to double-free glyph (%c) node %d, ignored", (int) character(p), (int) p);
756 formatted_error("nodes", "attempt to double-free %s node %d, ignored", get_node_name(type(p), subtype(p)), (int) p);
757 }
760 }
761 #endif
765 }
767 }
769 @ @c
771 {
773 #ifdef CHECK_NODE_USAGE
776 formatted_warning("nodes", "attempt to copy free glyph (%c) node %d, ignored", (int) character(p), (int) p);
778 formatted_warning("nodes", "attempt to copy free %s node %d, ignored", get_node_name(type(p), subtype(p)), (int) p);
779 }
781 }
782 #endif
786 }
788 }
790 @ @c
792 {
795 /*
796 It should be possible to do this memset at |free_node()|.
800 word less than |s|
801 */
804 case glyph_node:
806 break;
807 case hlist_node:
808 case vlist_node:
810 break;
811 case disc_node:
821 break;
822 case rule_node:
829 break;
830 case whatsit_node:
835 }
836 break;
837 case unset_node:
839 break;
840 case pseudo_line_node:
841 case shape_node:
843 but the overall allocation faster then an explicit test
844 at the top of |new_node()|.
845 */
850 }
851 break;
852 default:
853 break;
854 }
858 case math_node:
861 break;
862 case glue_node:
865 break;
866 case kern_node:
870 }
871 break;
872 case hlist_node:
873 case vlist_node:
874 case unset_node:
877 break;
878 case rule_node:
881 break;
882 }
883 }
888 }
891 return n;
892 }
895 {
900 return n;
901 }
904 {
911 return n;
912 }
914 @ makes a duplicate of the node list that starts at |p| and returns a
915 pointer to the new list
917 @c
919 {
922 register halfword s ;
930 }
933 }
935 return h;
936 }
939 {
941 }
949 } \
958 } \
961 @ make a dupe of a single node
963 @c
965 {
966 halfword s ;
968 case write_node:
969 case special_node:
971 break;
972 case late_lua_node:
974 break;
975 case user_defined_node:
977 case 'a':
979 break;
980 case 'l':
982 break;
983 case 'n':
986 break;
987 case 's':
989 break;
990 case 't':
992 break;
993 }
994 break;
995 default:
996 break ;
997 }
998 }
1001 {
1002 }
1005 {
1007 case pdf_literal_node:
1009 break;
1010 case pdf_colorstack_node:
1013 break;
1014 case pdf_setmatrix_node:
1016 break;
1017 case pdf_annot_node:
1019 break;
1020 case pdf_start_link_node:
1024 break;
1025 case pdf_dest_node:
1028 break;
1029 case pdf_thread_node:
1030 case pdf_start_thread_node:
1035 break;
1036 default:
1037 break;
1038 }
1039 }
1042 {
1046 register int i;
1049 return r;
1050 }
1054 (void) memcpy((void *) (varmem + r), (void *) (varmem + p), (sizeof(memory_word) * (unsigned) i));
1059 case math_node:
1062 break;
1063 case kern_node:
1066 break;
1067 }
1068 }
1073 }
1077 case glyph_node:
1079 break;
1080 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:
1121 }
1122 break;
1123 case ins_node:
1126 break;
1127 case margin_kern_node:
1129 break;
1130 case mark_node:
1132 break;
1133 case adjust_node:
1135 break;
1136 case choice_node:
1141 break;
1142 case simple_noad:
1146 break;
1147 case radical_noad:
1153 break;
1154 case accent_noad:
1161 break;
1162 case fence_noad:
1164 break;
1165 case sub_box_node:
1166 case sub_mlist_node:
1168 break;
1169 case fraction_noad:
1174 break;
1175 case glue_spec_node:
1177 break;
1178 case dir_node:
1179 case local_par_node:
1180 case boundary_node:
1181 break;
1182 case whatsit_node:
1190 }
1191 break;
1192 }
1193 return r;
1194 }
1201 @ @c
1204 {
1206 case open_node:
1207 case write_node:
1208 case close_node:
1209 case save_pos_node:
1210 break;
1211 case special_node:
1213 break;
1214 case late_lua_node:
1216 break;
1217 case user_defined_node:
1219 case 'a':
1221 break;
1222 case 'd':
1223 break;
1224 case 'n':
1226 break;
1227 case 's':
1229 break;
1230 case 't':
1232 break;
1233 default:
1234 {
1240 NULL
1241 };
1243 }
1244 break;
1245 }
1246 break;
1247 }
1248 }
1251 {
1252 }
1255 {
1257 case pdf_save_node:
1258 case pdf_restore_node:
1259 case pdf_refobj_node:
1260 case pdf_end_link_node:
1261 case pdf_end_thread_node:
1262 break;
1263 case pdf_literal_node:
1265 break;
1266 case pdf_colorstack_node:
1269 break;
1270 case pdf_setmatrix_node:
1272 break;
1273 case pdf_annot_node:
1275 break;
1276 case pdf_link_data_node:
1277 break;
1278 case pdf_start_link_node:
1282 break;
1283 case pdf_dest_node:
1286 break;
1287 case pdf_action_node:
1297 }
1298 break;
1299 case pdf_thread_data_node:
1300 break;
1301 case pdf_thread_node:
1302 case pdf_start_thread_node:
1307 break;
1308 }
1309 }
1312 {
1313 halfword w;
1315 return;
1317 return;
1319 case glyph_node:
1321 break;
1322 case glue_node:
1325 break;
1326 case hlist_node:
1327 case vlist_node:
1328 case unset_node:
1330 break;
1331 case disc_node:
1336 break;
1337 case rule_node:
1338 case kern_node:
1339 case penalty_node:
1340 break;
1341 case math_node:
1345 }
1347 break;
1348 case glue_spec_node:
1355 }
1356 }
1357 return ;
1358 break ;
1359 case dir_node:
1360 case local_par_node:
1361 case boundary_node:
1362 break;
1363 case whatsit_node:
1371 }
1372 break;
1373 case ins_node:
1376 break;
1377 case margin_kern_node:
1379 break;
1380 case mark_node:
1382 break;
1383 case adjust_node:
1385 break;
1387 break;
1388 case choice_node:
1393 break;
1394 case simple_noad:
1398 break;
1399 case radical_noad:
1405 break;
1406 case accent_noad:
1413 break;
1414 case fence_noad:
1416 break;
1418 case math_char_node:
1419 case math_text_char_node:
1420 break;
1421 case sub_box_node:
1422 case sub_mlist_node:
1424 break;
1425 case fraction_noad:
1430 break;
1431 case pseudo_file_node:
1433 break;
1434 case pseudo_line_node:
1435 case shape_node:
1437 return;
1438 break;
1439 case align_stack_node:
1440 case span_node:
1441 case movement_node:
1442 case if_node:
1443 case nesting_node:
1444 case unhyphenated_node:
1445 case hyphenated_node:
1446 case delta_node:
1447 case passive_node:
1448 case inserting_node:
1449 case split_up_node:
1450 case expr_node:
1451 case attribute_node:
1452 case attribute_list_node:
1453 case temp_node:
1454 break;
1455 default:
1457 return;
1458 }
1462 }
1464 return;
1465 }
1467 @ @c
1472 return;
1474 return;
1480 }
1482 }
1484 @ @c
1486 {
1489 case special_node:
1491 break;
1492 case user_defined_node:
1494 case 'a':
1496 break;
1497 case 't':
1499 break;
1500 case 'n':
1502 break;
1503 case 's':
1504 case 'd':
1505 break;
1506 default:
1508 break;
1509 }
1510 break;
1511 case open_node:
1512 case write_node:
1513 case close_node:
1514 case save_pos_node:
1515 break;
1516 }
1517 }
1520 {
1521 }
1524 {
1526 case pdf_literal_node:
1529 break;
1530 case pdf_colorstack_node:
1533 break;
1534 case pdf_setmatrix_node:
1536 break;
1537 case late_lua_node:
1542 break;
1543 case pdf_annot_node:
1545 break;
1546 case pdf_start_link_node:
1550 break;
1551 case pdf_dest_node:
1554 break;
1555 case pdf_thread_node:
1556 case pdf_start_thread_node:
1561 break;
1562 case pdf_save_node:
1563 case pdf_restore_node:
1564 case pdf_refobj_node:
1565 case pdf_end_link_node:
1566 case pdf_end_thread_node:
1567 break;
1568 default:
1570 break;
1571 }
1572 }
1575 {
1576 halfword w ;
1578 case glyph_node:
1580 break;
1581 case glue_node:
1584 break;
1585 case hlist_node:
1586 case vlist_node:
1587 case unset_node:
1588 case align_record_node:
1590 break;
1591 case ins_node:
1594 break;
1595 case whatsit_node:
1603 }
1604 break;
1605 case margin_kern_node:
1607 break;
1608 case math_node:
1612 }
1614 break;
1615 case disc_node:
1619 break;
1620 case adjust_node:
1622 break;
1623 case pseudo_file_node:
1625 break;
1626 case pseudo_line_node:
1627 case shape_node:
1628 break;
1629 case choice_node:
1634 break;
1635 case fraction_noad:
1640 break;
1641 case simple_noad:
1645 break;
1646 case radical_noad:
1652 break;
1653 case accent_noad:
1660 break;
1661 case fence_noad:
1663 break;
1664 /*
1665 case rule_node:
1666 case kern_node:
1667 case penalty_node:
1668 case mark_node:
1669 case style_node:
1670 case attribute_list_node:
1671 case attribute_node:
1672 case glue_spec_node:
1673 case temp_node:
1674 case align_stack_node:
1675 case movement_node:
1676 case if_node:
1677 case nesting_node:
1678 case span_node:
1679 case unhyphenated_node:
1680 case hyphenated_node:
1681 case delta_node:
1682 case passive_node:
1683 case expr_node:
1684 case dir_node:
1685 case boundary_node:
1686 case local_par_node:
1687 break;
1688 default:
1690 */
1691 }
1692 }
1694 @ @c
1696 {
1699 return;
1706 }
1707 }
1709 @ @c
1711 {
1712 register halfword r;
1718 #ifdef CHECK_NODE_USAGE
1720 #endif
1723 return r;
1724 }
1729 return null;
1730 }
1731 }
1733 @ @c
1735 {
1738 return;
1739 }
1740 #ifdef CHECK_NODE_USAGE
1742 #endif
1752 }
1754 }
1757 }
1759 @ @c
1761 {
1764 #ifdef CHECK_NODE_USAGE
1766 #endif
1769 }
1771 #ifdef CHECK_NODE_USAGE
1773 #endif
1776 }
1778 @ @c
1780 {
1783 /* message ?
1787 */
1792 }
1794 #ifdef CHECK_NODE_USAGE
1798 }
1800 #endif
1918 }
1920 @ @c
1922 {
1926 #ifdef CHECK_NODE_USAGE
1928 #endif
1932 }
1934 @ it makes sense to enlarge the varmem array immediately
1935 @c
1938 {
1939 int x;
1945 #ifdef CHECK_NODE_USAGE
1949 #endif
1959 }
1961 }
1962 }
1964 @ @c
1966 {
1967 register int t;
1982 }
1986 }
1988 #ifdef CHECK_NODE_USAGE
1990 #endif
1996 return null;
1997 }
2000 int x;
2009 }
2017 }
2019 }
2020 }
2021 }
2024 varmem = (memory_word *) realloc((void *) varmem, sizeof(memory_word) * (unsigned) (var_mem_max + x));
2027 }
2029 #ifdef CHECK_NODE_USAGE
2033 }
2035 #endif
2041 }
2046 }
2049 return null;
2050 }
2051 }
2053 @ @c
2055 {
2057 #ifdef CHECK_NODE_USAGE
2059 int i;
2072 }
2073 }
2074 }
2077 int j =
2087 }
2088 }
2089 #else
2091 #endif
2092 return s;
2093 }
2095 @ @c
2097 {
2099 #ifdef CHECK_NODE_USAGE
2111 }
2113 }
2114 }
2116 #endif
2117 return q;
2118 }
2120 @ @c
2122 {
2124 halfword j;
2144 }
2145 }
2147 print_nlp();
2148 }
2153 {
2158 return p;
2159 }
2161 @* Attribute stuff.
2163 @c
2165 {
2172 return r;
2173 }
2175 @ @c
2177 {
2191 }
2192 return q;
2193 }
2195 @ @c
2197 {
2198 halfword p;
2199 register int i;
2210 }
2211 }
2215 }
2216 return;
2217 }
2219 @ @c
2221 {
2224 update_attribute_cache();
2226 return;
2227 }
2230 }
2231 }
2233 @ @c
2235 {
2238 update_attribute_cache();
2239 }
2240 return attr_list_cache ;
2241 }
2242 return null ;
2243 }
2246 @ @c
2248 {
2249 halfword old;
2262 }
2265 }
2267 @ @c
2269 {
2277 }
2281 }
2284 }
2285 }
2286 }
2289 {
2292 }
2293 }
2295 @ |p| is an attr list head, or zero
2296 @c
2298 {
2299 register halfword q;
2307 return q;
2308 }
2316 break;
2317 j++;
2319 }
2330 }
2331 return q;
2334 return null ;
2335 }
2336 }
2338 @ @c
2340 {
2341 register halfword p;
2345 return;
2355 return;
2356 }
2362 return;
2364 break;
2365 j++;
2367 }
2373 formatted_warning("nodes","node %d has an attribute list that is free already, case 1",(int) n);
2386 }
2395 }
2408 }
2411 }
2412 }
2414 @ @c
2416 {
2417 register halfword p;
2418 register int t;
2422 return null;
2425 return UNUSED_ATTRIBUTE;
2427 formatted_warning("nodes","node %d has an attribute list that is free already, case 2", (int) n);
2428 return UNUSED_ATTRIBUTE;
2429 }
2434 return UNUSED_ATTRIBUTE;
2437 break;
2438 }
2439 j++;
2441 }
2443 return UNUSED_ATTRIBUTE;
2450 }
2453 }
2460 }
2461 return t;
2464 return null;
2465 }
2466 }
2468 @ @c
2470 {
2471 register halfword p;
2473 return UNUSED_ATTRIBUTE;
2476 return UNUSED_ATTRIBUTE;
2482 return ret;
2483 return UNUSED_ATTRIBUTE;
2485 return UNUSED_ATTRIBUTE;
2486 }
2488 }
2489 return UNUSED_ATTRIBUTE;
2490 }
2492 @ @c
2494 {
2496 case hlist_node:
2497 case vlist_node:
2498 case ins_node:
2499 case whatsit_node:
2500 case mark_node:
2501 case adjust_node:
2502 case unset_node:
2505 break;
2506 case rule_node:
2508 break;
2509 case glue_node:
2512 break;
2513 case math_node:
2515 break;
2516 case disc_node:
2519 break;
2520 }
2521 }
2523 @ @c
2525 {
2532 }
2534 @ Each new type of node that appears in our data structure must be capable
2536 need for write-oriented whatsits are somewhat like those for mark nodes;
2539 @c
2541 {
2547 else
2549 }
2551 @ @c
2553 {
2555 case open_node:
2559 break;
2560 case write_node:
2563 break;
2564 case close_node:
2566 break;
2567 case special_node:
2570 break;
2571 case late_lua_node:
2573 break;
2574 case save_pos_node:
2576 break;
2577 case user_defined_node:
2582 case 'a':
2584 break;
2585 case 'n':
2589 break;
2590 case 's':
2592 print(user_node_value(p));
2594 break;
2595 case 't':
2597 break;
2600 break;
2601 }
2602 break;
2603 }
2604 }
2607 {
2608 }
2611 {
2613 case pdf_literal_node:
2615 break;
2616 case pdf_colorstack_node:
2620 case colorstack_set:
2622 break;
2623 case colorstack_push:
2625 break;
2626 case colorstack_pop:
2628 break;
2629 case colorstack_current:
2631 break;
2632 default:
2634 break;
2635 }
2638 break;
2639 case pdf_setmatrix_node:
2642 break;
2643 case pdf_save_node:
2645 break;
2646 case pdf_restore_node:
2648 break;
2649 case pdf_refobj_node:
2659 }
2661 }
2670 }
2671 break;
2672 case pdf_annot_node:
2676 break;
2677 case pdf_start_link_node:
2683 }
2688 return;
2689 }
2693 }
2695 case pdf_action_goto:
2702 }
2703 break;
2704 case pdf_action_page:
2708 break;
2709 case pdf_action_thread:
2716 }
2717 break;
2718 default:
2720 break;
2721 }
2722 break;
2723 case pdf_end_link_node:
2725 break;
2726 case pdf_dest_node:
2734 }
2737 case pdf_dest_xyz:
2742 }
2743 break;
2744 case pdf_dest_fitbh:
2746 break;
2747 case pdf_dest_fitbv:
2749 break;
2750 case pdf_dest_fitb:
2752 break;
2753 case pdf_dest_fith:
2755 break;
2756 case pdf_dest_fitv:
2758 break;
2759 case pdf_dest_fitr:
2762 break;
2763 case pdf_dest_fit:
2765 break;
2766 default:
2768 break;
2769 }
2770 break;
2771 case pdf_thread_node:
2772 case pdf_start_thread_node:
2775 else
2786 }
2793 }
2794 break;
2795 case pdf_end_thread_node:
2797 break;
2798 default:
2799 break;
2800 }
2801 }
2803 @ Now we are ready for |show_node_list| itself. This procedure has been
2804 written to be ``extra robust'' in the sense that it should not crash or get
2805 into a loop even if the data structures have been messed up by bugs in
2806 the rest of the program. You can safely call its parent routine
2809 fetch a |memory_word| whose variant is different from the way it was stored;
2811 contains a scaled integer, if |p| is a pointer that has been
2812 clobbered or chosen at random.
2815 @ |str_room| need not be checked; see |show_box|
2817 @ Recursive calls on |show_node_list| therefore use the following pattern:
2818 @c
2822 flush_char(); \
2828 {
2830 halfword w;
2835 return;
2836 }
2838 print_ln();
2845 return;
2846 }
2860 }
2863 case hlist_node:
2864 case vlist_node:
2865 case unset_node:
2871 else
2885 }
2889 }
2893 }
2896 /* The code will have to change in this place if |glue_ratio| is
2897 a structured type instead of an ordinary |real|. Note that this routine
2898 should avoid arithmetic errors even if the |glue_set| field holds an
2899 arbitrary random value. The following code assumes that a properly
2901 it is regarded as an integer; this precaution was adequate to prevent
2902 floating point underflow on the author's computer.
2903 */
2913 else
2918 }
2919 }
2924 }
2927 }
2929 break;
2930 case rule_node:
2942 }
2948 break;
2949 case ins_node:
2962 break;
2963 case dir_node:
2972 }
2973 break;
2974 case local_par_node:
2977 print_ln();
2978 print_current_string();
2982 print_ln();
2983 print_current_string();
2987 print_ln();
2988 print_current_string();
2996 }
2997 print_ln();
2998 print_current_string();
3006 }
3008 break;
3009 case boundary_node:
3018 }
3019 break;
3020 case whatsit_node:
3028 }
3029 break;
3030 case glue_node:
3036 case a_leaders:
3037 break;
3038 case c_leaders:
3040 break;
3041 case x_leaders:
3043 break;
3044 case g_leaders:
3046 break;
3047 default:
3049 }
3067 }
3069 }
3074 else
3076 }
3077 }
3078 break;
3079 case margin_kern_node:
3084 else
3086 break;
3087 case kern_node:
3101 }
3102 break;
3103 case math_node:
3108 else
3113 }
3114 break;
3115 case penalty_node:
3119 break;
3120 case disc_node:
3122 /* The |post_break| list of a discretionary node is indicated by a prefixed
3130 }
3135 break;
3136 case mark_node:
3142 }
3144 break;
3145 case adjust_node:
3151 break;
3152 case glue_spec_node:
3156 break;
3157 default:
3159 break;
3160 }
3161 }
3163 }
3164 }
3166 @ This routine finds the 'base' width of a horizontal box, using the same logic
3169 @c
3171 {
3180 goto FOUND;
3181 }
3183 case hlist_node:
3184 case vlist_node:
3185 case rule_node:
3187 goto FOUND;
3188 break;
3189 case margin_kern_node:
3191 break;
3192 case kern_node:
3194 break;
3195 case math_node:
3199 break;
3202 }
3204 case glue_node:
3206 values, since such values are subject to system-dependent rounding.
3207 System-dependent numbers are not allowed to infiltrate parameters like
3208 |pre_display_size|, since \TeX82 is supposed to make the same decisions on all
3209 machines.
3210 */
3215 && (stretch(q) != 0))
3219 && (shrink(q) != 0))
3221 }
3223 goto FOUND;
3224 break;
3225 default:
3227 break;
3228 }
3231 goto NOT_FOUND;
3232 FOUND:
3238 break;
3239 }
3240 NOT_FOUND:
3242 }
3243 return w;
3244 }
3246 @ @c
3248 {
3252 return q;
3253 }
3255 @ |delete_glue_ref| is called when a pointer to a glue
3256 specification is being withdrawn.
3258 @c
3266 }
3269 }
3270 }
3272 @ @c
3273 int var_used;
3276 @ Attribute lists need two extra globals to increase processing efficiency.
3277 |max_used_attr| limits the test loop that checks for set attributes, and
3278 |attr_list_cache| contains a pointer to an already created attribute list. It is
3279 set to the special value |cache_disabled| when the current value can no longer be
3281 ended.
3283 @c
3285 halfword attr_list_cache;
3287 @ From the computer's standpoint, \TeX's chief mission is to create
3288 horizontal and vertical lists. We shall now investigate how the elements
3289 of these lists are represented internally as nodes in the dynamic memory.
3291 A horizontal or vertical list is linked together by |link| fields in
3295 kinds of nodes. We do this by putting a `|type|' field in the first word,
3296 together with the link and an optional `|subtype|'.
3298 @ Character nodes appear only in horizontal lists, never in vertical lists.
3300 An |hlist_node| stands for a box that was made from a horizontal list.
3301 Each |hlist_node| is seven words long, and contains the following fields
3303 mention explicitly when discussing the other node types): The |height| and
3304 |width| and |depth| are scaled integers denoting the dimensions of the
3305 box. There is also a |shift_amount| field, a scaled integer indicating
3307 or how much it should be moved to the right (if it appears in a vertical
3310 is empty. Finally, there are three fields that represent the setting of
3313 |stretching| or |shrinking| or |normal| depending on whether or not the
3318 @ The |new_null_box| function returns a pointer to an |hlist_node| in
3320 The |subtype| field is set to |min_quarterword|, since that's the desired
3321 |span_count| value if this |hlist_node| is changed to an |unset_node|.
3323 @c
3328 return p;
3329 }
3331 @ A |vlist_node| is like an |hlist_node| in all respects except that it
3332 contains a vertical list.
3337 by running the rule up to the boundary of the innermost enclosing box.
3338 This is called a ``running dimension.'' The |width| is never running in
3339 an hlist; the |height| and |depth| are never running in a~vlist.
3341 @ A new rule node is delivered by the |new_rule| function. It
3342 makes all the dimensions ``running,'' so you have to change the
3343 ones that are not allowed to run.
3345 @c
3347 {
3349 return p;
3350 }
3352 @ Insertions are represented by |ins_node| records, where the |subtype|
3355 The |height| field of an |ins_node| is slightly misnamed; it actually holds
3356 the natural height plus depth of the vertical list being inserted.
3357 The |depth| field holds the |split_max_depth| to be used in case this
3358 insertion is split, and the |split_top_ptr| points to the corresponding
3359 |split_top_skip|. The |float_cost| field holds the |floating_penalty| that
3360 will be used if this insertion floats to a subsequent page after a
3361 split insertion of the same class. There is one more field, the
3362 |ins_ptr|, which points to the beginning of the vlist for the insertion.
3364 @ A |mark_node| has a |mark_ptr| field that points to the reference count
3366 In addition there is a |mark_class| field that contains the mark class.
3369 specifies material that will be moved out into the surrounding
3371 operation. The |adjust_ptr| field points to the vlist containing this
3372 material.
3375 glyph in a particular font, along with its attribute list. Older
3376 versions of \TeX\ could use token memory for characters, because the
3379 needed for characters that are larger than that, as well as a pointer
3380 to a potential attribute list, and the two displacement values.
3382 In turn, that made the node so large that it made sense to merge
3383 ligature glyphs as well, as that requires only one extra pointer. A
3384 few extra classes of glyph nodes will be introduced later. The
3385 unification of all those types makes it easier to manipulate lists of
3386 glyphs. The subtype differentiates various glyph kinds.
3388 First, here is a function that returns a pointer to a glyph node for a given
3389 glyph in a given font. If that glyph doesn't exist, |null| is returned
3390 instead. Nodes of this subtype are directly created only for accents
3392 conversion from |mlist| to |hlist|).
3394 @c
3396 {
3403 }
3404 return p;
3405 }
3407 @ A subset of the glyphs nodes represent ligatures: characters
3408 fabricated from the interaction of two or more actual characters. The
3409 characters that generated the ligature have not been forgotten, since
3410 they are needed for diagnostic messages; the |lig_ptr| field points to
3411 a linked list of character nodes for all original characters that have
3412 been deleted. (This list might be empty if the characters that
3413 generated the ligature were retained in other nodes.)
3416 the original source of the ligature included implicit left and/or
3417 right boundaries. These nodes are created by the C function |new_ligkern|.
3419 A third general type of glyphs could be called a character, as it
3420 only appears in lists that are not yet processed by the ligaturing and
3421 kerning steps of the program.
3423 |main_control| inserts these, and they are later converted to
3424 |subtype_normal| by |new_ligkern|.
3426 @c
3428 {
3433 else
3435 }
3438 {
3445 return p;
3446 }
3450 |new_ligkern|, at the end of which they are no longer needed.
3452 @ Here are a few handy helpers used by the list output routines.
3454 @c
3456 {
3458 return w;
3459 }
3462 {
3466 return w;
3467 }
3470 {
3476 return w;
3477 }
3486 and |no_break=null|.
3492 break. Otherwise the |hyphen_penalty| will be charged. The texts will
3493 actually be substituted into the list by the line-breaking algorithm if it
3494 decides to make the break, and the discretionary node will disappear at
3496 not chosen.
3498 @c
3503 return p;
3504 }
3506 @ A |whatsit_node| is a wild card reserved for extensions to \TeX. The
3509 format of the remaining words. When a |whatsit_node| is encountered
3511 careful not to mess up the rest of \TeX\ are able to make \TeX\ do new
3512 things by adding code at the end of the program. For example, there
3513 might be a `\TeX nicolor' extension to specify different colors of ink,
3514 @^extensions to \TeX@>
3515 and the whatsit node might contain the desired parameters.
3517 The present implementation of \TeX\ treats the features associated with
3519 illustrate how such routines might be coded. We shall defer further
3520 discussion of extensions until the end of this program.
3523 after mathematical formulas. The |subtype| field is |before| before the
3524 formula and |after| after it. There is a |surround| field, which represents
3527 @c
3529 {
3532 return p;
3533 }
3538 type codes, by permitting a break at glue in a list if and only if the
3539 |type| of the previous node is less than |math_node|. Furthermore, a
3540 node is discarded after a break if its type is |math_node| or~more.
3542 @ A |glue_node| represents glue in a list. However, it is really only
3543 a pointer to a separate glue specification, since \TeX\ makes use of the
3544 fact that many essentially identical nodes of glue are usually present.
3546 another packet of words that specify the stretch and shrink components, etc.
3548 Glue nodes also serve to represent leaders; the |subtype| is used to
3551 The |leader_ptr| field points to a rule node or to a box node containing the
3552 leaders; it is set to |null| in ordinary glue nodes.
3554 Many kinds of glue are computed from \TeX's ``skip'' parameters, and
3555 it is helpful to know which parameter has led to a particular glue node.
3556 Therefore the |subtype| is set to indicate the source of glue, whenever
3557 it originated as a parameter. We will be defining symbolic names for the
3559 etc.); it suffices for now to say that the |subtype| of parametric glue
3560 will be the same as the parameter number, plus~one.
3562 @ In math formulas there are two more possibilities for the |subtype| in a
3565 feature that cancels the glue node immediately following if it appears
3566 in a subscript.
3568 @ A glue specification has a halfword reference count in its first word,
3569 @^reference counts@>
3571 Note that the reference count appears in the same position as
3572 the |link| field in list nodes; this is the field that is initialized
3573 to |null| when a node is allocated, and it is also the field that is flagged
3574 by |empty_flag| in empty nodes.
3578 fields called |stretch_order| and |shrink_order|; these contain the
3580 corresponding to the stretch and shrink values.
3582 @ Here is a function that returns a pointer to a copy of a glue spec.
3583 The reference count in the copy is |null|, because there is assumed
3584 to be exactly one reference to the new specification.
3586 @c
3591 return q;
3592 }
3594 @ And here's a function that creates a glue node for a given parameter
3599 @c
3601 {
3606 return p;
3607 }
3609 @ Glue nodes that are more or less anonymous are created by |new_glue|,
3610 whose argument points to a glue specification.
3612 @c
3614 {
3618 return p;
3619 }
3621 @ Still another subroutine is needed: This one is sort of a combination
3622 of |new_param_glue| and |new_glue|. It creates a glue node for one of
3623 the current glue parameters, but it makes a fresh copy of the glue
3625 while the parameter will stay put. The global variable |temp_ptr| is
3626 set to the address of the new spec.
3628 @c
3630 {
3636 return p;
3637 }
3640 amount of spacing. This spacing correction appears in horizontal lists
3641 between letters like A and V when the font designer said that it looks
3642 better to move them closer together or further apart. A kern node can
3643 also appear in a vertical list, when its `|width|' denotes additional
3644 spacing in the vertical direction. The |subtype| is either |normal| (for
3645 kerns inserted from font information or math mode calculations) or |explicit|
3650 @ The |new_kern| function creates a kern node having a given width.
3652 @c
3654 {
3657 return p;
3658 }
3660 @ A |penalty_node| specifies the penalty associated with line or page
3663 treated as infinity, and no break will be allowed for such high values.
3665 break will be forced.
3667 @ Anyone who has been reading the last few sections of the program will
3668 be able to guess what comes next.
3670 @c
3672 {
3675 return p;
3676 }
3678 @ You might think that we have introduced enough node types by now. Well,
3682 dimensions are their ``natural'' sizes before any glue adjustment has been
3684 field, which contains the total stretch of order |glue_order| that is
3685 present in the hlist or vlist being boxed.
3687 containing the total shrink of order |glue_sign| that is present.
3688 The |subtype| field is called |span_count|; an unset box typically
3690 Unset nodes will be changed to box nodes when alignment is completed.
3692 In fact, there are still more types coming. When we get to math formula
3694 of larger type codes will also be defined, for use in math mode only.
3697 changing any of the node sizes or even reordering the words of nodes,
3698 the |copy_node_list| procedure and the memory initialization code
3699 below may have to be changed. Such potentially dangerous parts of the
3700 program are listed in the index under `data structure assumptions'.
3702 However, other references to the nodes are made symbolically in terms of
3704 \TeX's other algorithms intact.
3705 @^system dependencies@>
3707 @ This function creates a |local_paragraph| node
3709 @c
3712 {
3713 halfword q;
3721 }
3726 }
3728 return p;
3729 }