/contrib/groff/src/roff/troff/div.cpp
C++ | 1198 lines | 983 code | 116 blank | 99 comment | 229 complexity | eb69496b2bb3cfde7585d2f527d8e50c MD5 | raw file
1// -*- C++ -*- 2/* Copyright (C) 1989, 1990, 1991, 1992, 2000, 2001, 2002, 2004 3 Free Software Foundation, Inc. 4 Written by James Clark (jjc@jclark.com) 5 6This file is part of groff. 7 8groff is free software; you can redistribute it and/or modify it under 9the terms of the GNU General Public License as published by the Free 10Software Foundation; either version 2, or (at your option) any later 11version. 12 13groff is distributed in the hope that it will be useful, but WITHOUT ANY 14WARRANTY; without even the implied warranty of MERCHANTABILITY or 15FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 16for more details. 17 18You should have received a copy of the GNU General Public License along 19with groff; see the file COPYING. If not, write to the Free Software 20Foundation, 51 Franklin St - Fifth Floor, Boston, MA 02110-1301, USA. */ 21 22 23// diversions 24 25#include "troff.h" 26#include "dictionary.h" 27#include "hvunits.h" 28#include "stringclass.h" 29#include "mtsm.h" 30#include "env.h" 31#include "request.h" 32#include "node.h" 33#include "token.h" 34#include "div.h" 35#include "reg.h" 36 37#include "nonposix.h" 38 39int exit_started = 0; // the exit process has started 40int done_end_macro = 0; // the end macro (if any) has finished 41int seen_last_page_ejector = 0; // seen the LAST_PAGE_EJECTOR cookie 42int last_page_number = 0; // if > 0, the number of the last page 43 // specified with -o 44static int began_page_in_end_macro = 0; // a new page was begun during the end macro 45 46static int last_post_line_extra_space = 0; // needed for \n(.a 47static int nl_reg_contents = -1; 48static int dl_reg_contents = 0; 49static int dn_reg_contents = 0; 50static int vertical_position_traps_flag = 1; 51static vunits truncated_space; 52static vunits needed_space; 53 54diversion::diversion(symbol s) 55: prev(0), nm(s), vertical_position(V0), high_water_mark(V0), 56 any_chars_added(0), no_space_mode(0), needs_push(0), saved_seen_break(0), 57 saved_seen_space(0), saved_seen_eol(0), saved_suppress_next_eol(0), 58 marked_place(V0) 59{ 60} 61 62struct vertical_size { 63 vunits pre_extra, post_extra, pre, post; 64 vertical_size(vunits vs, vunits post_vs); 65}; 66 67vertical_size::vertical_size(vunits vs, vunits post_vs) 68: pre_extra(V0), post_extra(V0), pre(vs), post(post_vs) 69{ 70} 71 72void node::set_vertical_size(vertical_size *) 73{ 74} 75 76void extra_size_node::set_vertical_size(vertical_size *v) 77{ 78 if (n < V0) { 79 if (-n > v->pre_extra) 80 v->pre_extra = -n; 81 } 82 else if (n > v->post_extra) 83 v->post_extra = n; 84} 85 86void vertical_size_node::set_vertical_size(vertical_size *v) 87{ 88 if (n < V0) 89 v->pre = -n; 90 else 91 v->post = n; 92} 93 94top_level_diversion *topdiv; 95 96diversion *curdiv; 97 98void do_divert(int append, int boxing) 99{ 100 tok.skip(); 101 symbol nm = get_name(); 102 if (nm.is_null()) { 103 if (curdiv->prev) { 104 curenv->seen_break = curdiv->saved_seen_break; 105 curenv->seen_space = curdiv->saved_seen_space; 106 curenv->seen_eol = curdiv->saved_seen_eol; 107 curenv->suppress_next_eol = curdiv->saved_suppress_next_eol; 108 if (boxing) { 109 curenv->line = curdiv->saved_line; 110 curenv->width_total = curdiv->saved_width_total; 111 curenv->space_total = curdiv->saved_space_total; 112 curenv->saved_indent = curdiv->saved_saved_indent; 113 curenv->target_text_length = curdiv->saved_target_text_length; 114 curenv->prev_line_interrupted = curdiv->saved_prev_line_interrupted; 115 } 116 diversion *temp = curdiv; 117 curdiv = curdiv->prev; 118 delete temp; 119 } 120 else 121 warning(WARN_DI, "diversion stack underflow"); 122 } 123 else { 124 macro_diversion *md = new macro_diversion(nm, append); 125 md->prev = curdiv; 126 curdiv = md; 127 curdiv->saved_seen_break = curenv->seen_break; 128 curdiv->saved_seen_space = curenv->seen_space; 129 curdiv->saved_seen_eol = curenv->seen_eol; 130 curdiv->saved_suppress_next_eol = curenv->suppress_next_eol; 131 curenv->seen_break = 0; 132 curenv->seen_space = 0; 133 curenv->seen_eol = 0; 134 if (boxing) { 135 curdiv->saved_line = curenv->line; 136 curdiv->saved_width_total = curenv->width_total; 137 curdiv->saved_space_total = curenv->space_total; 138 curdiv->saved_saved_indent = curenv->saved_indent; 139 curdiv->saved_target_text_length = curenv->target_text_length; 140 curdiv->saved_prev_line_interrupted = curenv->prev_line_interrupted; 141 curenv->line = 0; 142 curenv->start_line(); 143 } 144 } 145 skip_line(); 146} 147 148void divert() 149{ 150 do_divert(0, 0); 151} 152 153void divert_append() 154{ 155 do_divert(1, 0); 156} 157 158void box() 159{ 160 do_divert(0, 1); 161} 162 163void box_append() 164{ 165 do_divert(1, 1); 166} 167 168void diversion::need(vunits n) 169{ 170 vunits d = distance_to_next_trap(); 171 if (d < n) { 172 truncated_space = -d; 173 needed_space = n; 174 space(d, 1); 175 } 176} 177 178macro_diversion::macro_diversion(symbol s, int append) 179: diversion(s), max_width(H0) 180{ 181#if 0 182 if (append) { 183 /* We don't allow recursive appends eg: 184 185 .da a 186 .a 187 .di 188 189 This causes an infinite loop in troff anyway. 190 This is because the user could do 191 192 .as a foo 193 194 in the diversion, and this would mess things up royally, 195 since there would be two things appending to the same 196 macro_header. 197 To make it work, we would have to copy the _contents_ 198 of the macro into which we were diverting; this doesn't 199 strike me as worthwhile. 200 However, 201 202 .di a 203 .a 204 .a 205 .di 206 207 will work and will make `a' contain two copies of what it contained 208 before; in troff, `a' would contain nothing. */ 209 request_or_macro *rm 210 = (request_or_macro *)request_dictionary.remove(s); 211 if (!rm || (mac = rm->to_macro()) == 0) 212 mac = new macro; 213 } 214 else 215 mac = new macro; 216#endif 217 // We can now catch the situation described above by comparing 218 // the length of the charlist in the macro_header with the length 219 // stored in the macro. When we detect this, we copy the contents. 220 mac = new macro(1); 221 if (append) { 222 request_or_macro *rm 223 = (request_or_macro *)request_dictionary.lookup(s); 224 if (rm) { 225 macro *m = rm->to_macro(); 226 if (m) 227 *mac = *m; 228 } 229 } 230} 231 232macro_diversion::~macro_diversion() 233{ 234 request_or_macro *rm = (request_or_macro *)request_dictionary.lookup(nm); 235 macro *m = rm ? rm->to_macro() : 0; 236 if (m) { 237 *m = *mac; 238 delete mac; 239 } 240 else 241 request_dictionary.define(nm, mac); 242 mac = 0; 243 dl_reg_contents = max_width.to_units(); 244 dn_reg_contents = vertical_position.to_units(); 245} 246 247vunits macro_diversion::distance_to_next_trap() 248{ 249 if (!diversion_trap.is_null() && diversion_trap_pos > vertical_position) 250 return diversion_trap_pos - vertical_position; 251 else 252 // Substract vresolution so that vunits::vunits does not overflow. 253 return vunits(INT_MAX - vresolution); 254} 255 256void macro_diversion::transparent_output(unsigned char c) 257{ 258 mac->append(c); 259} 260 261void macro_diversion::transparent_output(node *n) 262{ 263 mac->append(n); 264} 265 266void macro_diversion::output(node *nd, int retain_size, 267 vunits vs, vunits post_vs, hunits width) 268{ 269 no_space_mode = 0; 270 vertical_size v(vs, post_vs); 271 while (nd != 0) { 272 nd->set_vertical_size(&v); 273 node *temp = nd; 274 nd = nd->next; 275 if (temp->interpret(mac)) 276 delete temp; 277 else { 278#if 1 279 temp->freeze_space(); 280#endif 281 mac->append(temp); 282 } 283 } 284 last_post_line_extra_space = v.post_extra.to_units(); 285 if (!retain_size) { 286 v.pre = vs; 287 v.post = post_vs; 288 } 289 if (width > max_width) 290 max_width = width; 291 vunits x = v.pre + v.pre_extra + v.post + v.post_extra; 292 if (vertical_position_traps_flag 293 && !diversion_trap.is_null() && diversion_trap_pos > vertical_position 294 && diversion_trap_pos <= vertical_position + x) { 295 vunits trunc = vertical_position + x - diversion_trap_pos; 296 if (trunc > v.post) 297 trunc = v.post; 298 v.post -= trunc; 299 x -= trunc; 300 truncated_space = trunc; 301 spring_trap(diversion_trap); 302 } 303 mac->append(new vertical_size_node(-v.pre)); 304 mac->append(new vertical_size_node(v.post)); 305 mac->append('\n'); 306 vertical_position += x; 307 if (vertical_position - v.post > high_water_mark) 308 high_water_mark = vertical_position - v.post; 309} 310 311void macro_diversion::space(vunits n, int) 312{ 313 if (vertical_position_traps_flag 314 && !diversion_trap.is_null() && diversion_trap_pos > vertical_position 315 && diversion_trap_pos <= vertical_position + n) { 316 truncated_space = vertical_position + n - diversion_trap_pos; 317 n = diversion_trap_pos - vertical_position; 318 spring_trap(diversion_trap); 319 } 320 else if (n + vertical_position < V0) 321 n = -vertical_position; 322 mac->append(new diverted_space_node(n)); 323 vertical_position += n; 324} 325 326void macro_diversion::copy_file(const char *filename) 327{ 328 mac->append(new diverted_copy_file_node(filename)); 329} 330 331top_level_diversion::top_level_diversion() 332: page_number(0), page_count(0), last_page_count(-1), 333 page_length(units_per_inch*11), 334 prev_page_offset(units_per_inch), page_offset(units_per_inch), 335 page_trap_list(0), have_next_page_number(0), 336 ejecting_page(0), before_first_page(1) 337{ 338} 339 340// find the next trap after pos 341 342trap *top_level_diversion::find_next_trap(vunits *next_trap_pos) 343{ 344 trap *next_trap = 0; 345 for (trap *pt = page_trap_list; pt != 0; pt = pt->next) 346 if (!pt->nm.is_null()) { 347 if (pt->position >= V0) { 348 if (pt->position > vertical_position 349 && pt->position < page_length 350 && (next_trap == 0 || pt->position < *next_trap_pos)) { 351 next_trap = pt; 352 *next_trap_pos = pt->position; 353 } 354 } 355 else { 356 vunits pos = pt->position; 357 pos += page_length; 358 if (pos > 0 && pos > vertical_position && (next_trap == 0 || pos < *next_trap_pos)) { 359 next_trap = pt; 360 *next_trap_pos = pos; 361 } 362 } 363 } 364 return next_trap; 365} 366 367vunits top_level_diversion::distance_to_next_trap() 368{ 369 vunits d; 370 if (!find_next_trap(&d)) 371 return page_length - vertical_position; 372 else 373 return d - vertical_position; 374} 375 376void top_level_diversion::output(node *nd, int retain_size, 377 vunits vs, vunits post_vs, hunits width) 378{ 379 no_space_mode = 0; 380 vunits next_trap_pos; 381 trap *next_trap = find_next_trap(&next_trap_pos); 382 if (before_first_page && begin_page()) 383 fatal("sorry, I didn't manage to begin the first page in time: use an explicit .br request"); 384 vertical_size v(vs, post_vs); 385 for (node *tem = nd; tem != 0; tem = tem->next) 386 tem->set_vertical_size(&v); 387 last_post_line_extra_space = v.post_extra.to_units(); 388 if (!retain_size) { 389 v.pre = vs; 390 v.post = post_vs; 391 } 392 vertical_position += v.pre; 393 vertical_position += v.pre_extra; 394 the_output->print_line(page_offset, vertical_position, nd, 395 v.pre + v.pre_extra, v.post_extra, width); 396 vertical_position += v.post_extra; 397 if (vertical_position > high_water_mark) 398 high_water_mark = vertical_position; 399 if (vertical_position_traps_flag && vertical_position >= page_length) 400 begin_page(); 401 else if (vertical_position_traps_flag 402 && next_trap != 0 && vertical_position >= next_trap_pos) { 403 nl_reg_contents = vertical_position.to_units(); 404 truncated_space = v.post; 405 spring_trap(next_trap->nm); 406 } 407 else if (v.post > V0) { 408 vertical_position += v.post; 409 if (vertical_position_traps_flag 410 && next_trap != 0 && vertical_position >= next_trap_pos) { 411 truncated_space = vertical_position - next_trap_pos; 412 vertical_position = next_trap_pos; 413 nl_reg_contents = vertical_position.to_units(); 414 spring_trap(next_trap->nm); 415 } 416 else if (vertical_position_traps_flag && vertical_position >= page_length) 417 begin_page(); 418 else 419 nl_reg_contents = vertical_position.to_units(); 420 } 421 else 422 nl_reg_contents = vertical_position.to_units(); 423} 424 425void top_level_diversion::transparent_output(unsigned char c) 426{ 427 if (before_first_page && begin_page()) 428 // This can only happen with the .output request. 429 fatal("sorry, I didn't manage to begin the first page in time: use an explicit .br request"); 430 const char *s = asciify(c); 431 while (*s) 432 the_output->transparent_char(*s++); 433} 434 435void top_level_diversion::transparent_output(node * /*n*/) 436{ 437 error("can't transparently output node at top level"); 438} 439 440void top_level_diversion::copy_file(const char *filename) 441{ 442 if (before_first_page && begin_page()) 443 fatal("sorry, I didn't manage to begin the first page in time: use an explicit .br request"); 444 the_output->copy_file(page_offset, vertical_position, filename); 445} 446 447void top_level_diversion::space(vunits n, int forced) 448{ 449 if (no_space_mode) { 450 if (!forced) 451 return; 452 else 453 no_space_mode = 0; 454 } 455 if (before_first_page) { 456 begin_page(n); 457 return; 458 } 459 vunits next_trap_pos; 460 trap *next_trap = find_next_trap(&next_trap_pos); 461 vunits y = vertical_position + n; 462 if (curenv->get_vertical_spacing().to_units()) 463 curenv->seen_space += n.to_units() 464 / curenv->get_vertical_spacing().to_units(); 465 if (vertical_position_traps_flag && next_trap != 0 && y >= next_trap_pos) { 466 vertical_position = next_trap_pos; 467 nl_reg_contents = vertical_position.to_units(); 468 truncated_space = y - vertical_position; 469 spring_trap(next_trap->nm); 470 } 471 else if (y < V0) { 472 vertical_position = V0; 473 nl_reg_contents = vertical_position.to_units(); 474 } 475 else if (vertical_position_traps_flag && y >= page_length && n >= V0) 476 begin_page(y - page_length); 477 else { 478 vertical_position = y; 479 nl_reg_contents = vertical_position.to_units(); 480 } 481} 482 483trap::trap(symbol s, vunits n, trap *p) 484: next(p), position(n), nm(s) 485{ 486} 487 488void top_level_diversion::add_trap(symbol nam, vunits pos) 489{ 490 trap *first_free_slot = 0; 491 trap **p; 492 for (p = &page_trap_list; *p; p = &(*p)->next) { 493 if ((*p)->nm.is_null()) { 494 if (first_free_slot == 0) 495 first_free_slot = *p; 496 } 497 else if ((*p)->position == pos) { 498 (*p)->nm = nam; 499 return; 500 } 501 } 502 if (first_free_slot) { 503 first_free_slot->nm = nam; 504 first_free_slot->position = pos; 505 } 506 else 507 *p = new trap(nam, pos, 0); 508} 509 510void top_level_diversion::remove_trap(symbol nam) 511{ 512 for (trap *p = page_trap_list; p; p = p->next) 513 if (p->nm == nam) { 514 p->nm = NULL_SYMBOL; 515 return; 516 } 517} 518 519void top_level_diversion::remove_trap_at(vunits pos) 520{ 521 for (trap *p = page_trap_list; p; p = p->next) 522 if (p->position == pos) { 523 p->nm = NULL_SYMBOL; 524 return; 525 } 526} 527 528void top_level_diversion::change_trap(symbol nam, vunits pos) 529{ 530 for (trap *p = page_trap_list; p; p = p->next) 531 if (p->nm == nam) { 532 p->position = pos; 533 return; 534 } 535} 536 537void top_level_diversion::print_traps() 538{ 539 for (trap *p = page_trap_list; p; p = p->next) 540 if (p->nm.is_null()) 541 fprintf(stderr, " empty\n"); 542 else 543 fprintf(stderr, "%s\t%d\n", p->nm.contents(), p->position.to_units()); 544 fflush(stderr); 545} 546 547void end_diversions() 548{ 549 while (curdiv != topdiv) { 550 error("automatically ending diversion `%1' on exit", 551 curdiv->nm.contents()); 552 diversion *tem = curdiv; 553 curdiv = curdiv->prev; 554 delete tem; 555 } 556} 557 558void cleanup_and_exit(int exit_code) 559{ 560 if (the_output) { 561 the_output->trailer(topdiv->get_page_length()); 562 delete the_output; 563 } 564 FLUSH_INPUT_PIPE(STDIN_FILENO); 565 exit(exit_code); 566} 567 568// Returns non-zero if it sprung a top-of-page trap. 569// The optional parameter is for the .trunc register. 570int top_level_diversion::begin_page(vunits n) 571{ 572 if (exit_started) { 573 if (page_count == last_page_count 574 ? curenv->is_empty() 575 : (done_end_macro && (seen_last_page_ejector || began_page_in_end_macro))) 576 cleanup_and_exit(0); 577 if (!done_end_macro) 578 began_page_in_end_macro = 1; 579 } 580 if (last_page_number > 0 && page_number == last_page_number) 581 cleanup_and_exit(0); 582 if (!the_output) 583 init_output(); 584 ++page_count; 585 if (have_next_page_number) { 586 page_number = next_page_number; 587 have_next_page_number = 0; 588 } 589 else if (before_first_page == 1) 590 page_number = 1; 591 else 592 page_number++; 593 // spring the top of page trap if there is one 594 vunits next_trap_pos; 595 vertical_position = -vresolution; 596 trap *next_trap = find_next_trap(&next_trap_pos); 597 vertical_position = V0; 598 high_water_mark = V0; 599 ejecting_page = 0; 600 // If before_first_page was 2, then the top of page transition was undone 601 // using eg .nr nl 0-1. See nl_reg::set_value. 602 if (before_first_page != 2) 603 the_output->begin_page(page_number, page_length); 604 before_first_page = 0; 605 nl_reg_contents = vertical_position.to_units(); 606 if (vertical_position_traps_flag && next_trap != 0 && next_trap_pos == V0) { 607 truncated_space = n; 608 spring_trap(next_trap->nm); 609 return 1; 610 } 611 else 612 return 0; 613} 614 615void continue_page_eject() 616{ 617 if (topdiv->get_ejecting()) { 618 if (curdiv != topdiv) 619 error("can't continue page ejection because of current diversion"); 620 else if (!vertical_position_traps_flag) 621 error("can't continue page ejection because vertical position traps disabled"); 622 else { 623 push_page_ejector(); 624 topdiv->space(topdiv->get_page_length(), 1); 625 } 626 } 627} 628 629void top_level_diversion::set_next_page_number(int n) 630{ 631 next_page_number= n; 632 have_next_page_number = 1; 633} 634 635int top_level_diversion::get_next_page_number() 636{ 637 return have_next_page_number ? next_page_number : page_number + 1; 638} 639 640void top_level_diversion::set_page_length(vunits n) 641{ 642 page_length = n; 643} 644 645diversion::~diversion() 646{ 647} 648 649void page_offset() 650{ 651 hunits n; 652 // The troff manual says that the default scaling indicator is v, 653 // but it is in fact m: v wouldn't make sense for a horizontally 654 // oriented request. 655 if (!has_arg() || !get_hunits(&n, 'm', topdiv->page_offset)) 656 n = topdiv->prev_page_offset; 657 topdiv->prev_page_offset = topdiv->page_offset; 658 topdiv->page_offset = n; 659 topdiv->modified_tag.incl(MTSM_PO); 660 skip_line(); 661} 662 663void page_length() 664{ 665 vunits n; 666 if (has_arg() && get_vunits(&n, 'v', topdiv->get_page_length())) 667 topdiv->set_page_length(n); 668 else 669 topdiv->set_page_length(11*units_per_inch); 670 skip_line(); 671} 672 673void when_request() 674{ 675 vunits n; 676 if (get_vunits(&n, 'v')) { 677 symbol s = get_name(); 678 if (s.is_null()) 679 topdiv->remove_trap_at(n); 680 else 681 topdiv->add_trap(s, n); 682 } 683 skip_line(); 684} 685 686void begin_page() 687{ 688 int got_arg = 0; 689 int n = 0; /* pacify compiler */ 690 if (has_arg() && get_integer(&n, topdiv->get_page_number())) 691 got_arg = 1; 692 while (!tok.newline() && !tok.eof()) 693 tok.next(); 694 if (curdiv == topdiv) { 695 if (topdiv->before_first_page) { 696 if (!break_flag) { 697 if (got_arg) 698 topdiv->set_next_page_number(n); 699 if (got_arg || !topdiv->no_space_mode) 700 topdiv->begin_page(); 701 } 702 else if (topdiv->no_space_mode && !got_arg) 703 topdiv->begin_page(); 704 else { 705 /* Given this 706 707 .wh 0 x 708 .de x 709 .tm \\n% 710 .. 711 .bp 3 712 713 troff prints 714 715 1 716 3 717 718 This code makes groff do the same. */ 719 720 push_page_ejector(); 721 topdiv->begin_page(); 722 if (got_arg) 723 topdiv->set_next_page_number(n); 724 topdiv->set_ejecting(); 725 } 726 } 727 else { 728 push_page_ejector(); 729 if (break_flag) 730 curenv->do_break(); 731 if (got_arg) 732 topdiv->set_next_page_number(n); 733 if (!(topdiv->no_space_mode && !got_arg)) 734 topdiv->set_ejecting(); 735 } 736 } 737 tok.next(); 738} 739 740void no_space() 741{ 742 curdiv->no_space_mode = 1; 743 skip_line(); 744} 745 746void restore_spacing() 747{ 748 curdiv->no_space_mode = 0; 749 skip_line(); 750} 751 752/* It is necessary to generate a break before reading the argument, 753because otherwise arguments using | will be wrong. But if we just 754generate a break as usual, then the line forced out may spring a trap 755and thus push a macro onto the input stack before we have had a chance 756to read the argument to the sp request. We resolve this dilemma by 757setting, before generating the break, a flag which will postpone the 758actual pushing of the macro associated with the trap sprung by the 759outputting of the line forced out by the break till after we have read 760the argument to the request. If the break did cause a trap to be 761sprung, then we don't actually do the space. */ 762 763void space_request() 764{ 765 postpone_traps(); 766 if (break_flag) 767 curenv->do_break(); 768 vunits n; 769 if (!has_arg() || !get_vunits(&n, 'v')) 770 n = curenv->get_vertical_spacing(); 771 while (!tok.newline() && !tok.eof()) 772 tok.next(); 773 if (!unpostpone_traps() && !curdiv->no_space_mode) 774 curdiv->space(n); 775 else 776 // The line might have had line spacing that was truncated. 777 truncated_space += n; 778 779 tok.next(); 780} 781 782void blank_line() 783{ 784 curenv->do_break(); 785 if (!trap_sprung_flag && !curdiv->no_space_mode) 786 curdiv->space(curenv->get_vertical_spacing()); 787 else 788 truncated_space += curenv->get_vertical_spacing(); 789} 790 791/* need_space might spring a trap and so we must be careful that the 792BEGIN_TRAP token is not skipped over. */ 793 794void need_space() 795{ 796 vunits n; 797 if (!has_arg() || !get_vunits(&n, 'v')) 798 n = curenv->get_vertical_spacing(); 799 while (!tok.newline() && !tok.eof()) 800 tok.next(); 801 curdiv->need(n); 802 tok.next(); 803} 804 805void page_number() 806{ 807 int n; 808 809 // the ps4html register is set if we are using -Tps 810 // to generate images for html 811 reg *r = (reg *)number_reg_dictionary.lookup("ps4html"); 812 if (r == NULL) 813 if (has_arg() && get_integer(&n, topdiv->get_page_number())) 814 topdiv->set_next_page_number(n); 815 skip_line(); 816} 817 818vunits saved_space; 819 820void save_vertical_space() 821{ 822 vunits x; 823 if (!has_arg() || !get_vunits(&x, 'v')) 824 x = curenv->get_vertical_spacing(); 825 if (curdiv->distance_to_next_trap() > x) 826 curdiv->space(x, 1); 827 else 828 saved_space = x; 829 skip_line(); 830} 831 832void output_saved_vertical_space() 833{ 834 while (!tok.newline() && !tok.eof()) 835 tok.next(); 836 if (saved_space > V0) 837 curdiv->space(saved_space, 1); 838 saved_space = V0; 839 tok.next(); 840} 841 842void flush_output() 843{ 844 while (!tok.newline() && !tok.eof()) 845 tok.next(); 846 if (break_flag) 847 curenv->do_break(); 848 if (the_output) 849 the_output->flush(); 850 tok.next(); 851} 852 853void macro_diversion::set_diversion_trap(symbol s, vunits n) 854{ 855 diversion_trap = s; 856 diversion_trap_pos = n; 857} 858 859void macro_diversion::clear_diversion_trap() 860{ 861 diversion_trap = NULL_SYMBOL; 862} 863 864void top_level_diversion::set_diversion_trap(symbol, vunits) 865{ 866 error("can't set diversion trap when no current diversion"); 867} 868 869void top_level_diversion::clear_diversion_trap() 870{ 871 error("can't set diversion trap when no current diversion"); 872} 873 874void diversion_trap() 875{ 876 vunits n; 877 if (has_arg() && get_vunits(&n, 'v')) { 878 symbol s = get_name(); 879 if (!s.is_null()) 880 curdiv->set_diversion_trap(s, n); 881 else 882 curdiv->clear_diversion_trap(); 883 } 884 else 885 curdiv->clear_diversion_trap(); 886 skip_line(); 887} 888 889void change_trap() 890{ 891 symbol s = get_name(1); 892 if (!s.is_null()) { 893 vunits x; 894 if (has_arg() && get_vunits(&x, 'v')) 895 topdiv->change_trap(s, x); 896 else 897 topdiv->remove_trap(s); 898 } 899 skip_line(); 900} 901 902void print_traps() 903{ 904 topdiv->print_traps(); 905 skip_line(); 906} 907 908void mark() 909{ 910 symbol s = get_name(); 911 if (s.is_null()) 912 curdiv->marked_place = curdiv->get_vertical_position(); 913 else if (curdiv == topdiv) 914 set_number_reg(s, nl_reg_contents); 915 else 916 set_number_reg(s, curdiv->get_vertical_position().to_units()); 917 skip_line(); 918} 919 920// This is truly bizarre. It is documented in the SQ manual. 921 922void return_request() 923{ 924 vunits dist = curdiv->marked_place - curdiv->get_vertical_position(); 925 if (has_arg()) { 926 if (tok.ch() == '-') { 927 tok.next(); 928 vunits x; 929 if (get_vunits(&x, 'v')) 930 dist = -x; 931 } 932 else { 933 vunits x; 934 if (get_vunits(&x, 'v')) 935 dist = x >= V0 ? x - curdiv->get_vertical_position() : V0; 936 } 937 } 938 if (dist < V0) 939 curdiv->space(dist); 940 skip_line(); 941} 942 943void vertical_position_traps() 944{ 945 int n; 946 if (has_arg() && get_integer(&n)) 947 vertical_position_traps_flag = (n != 0); 948 else 949 vertical_position_traps_flag = 1; 950 skip_line(); 951} 952 953class page_offset_reg : public reg { 954public: 955 int get_value(units *); 956 const char *get_string(); 957}; 958 959int page_offset_reg::get_value(units *res) 960{ 961 *res = topdiv->get_page_offset().to_units(); 962 return 1; 963} 964 965const char *page_offset_reg::get_string() 966{ 967 return i_to_a(topdiv->get_page_offset().to_units()); 968} 969 970class page_length_reg : public reg { 971public: 972 int get_value(units *); 973 const char *get_string(); 974}; 975 976int page_length_reg::get_value(units *res) 977{ 978 *res = topdiv->get_page_length().to_units(); 979 return 1; 980} 981 982const char *page_length_reg::get_string() 983{ 984 return i_to_a(topdiv->get_page_length().to_units()); 985} 986 987class vertical_position_reg : public reg { 988public: 989 int get_value(units *); 990 const char *get_string(); 991}; 992 993int vertical_position_reg::get_value(units *res) 994{ 995 if (curdiv == topdiv && topdiv->before_first_page) 996 *res = -1; 997 else 998 *res = curdiv->get_vertical_position().to_units(); 999 return 1; 1000} 1001 1002const char *vertical_position_reg::get_string() 1003{ 1004 if (curdiv == topdiv && topdiv->before_first_page) 1005 return "-1"; 1006 else 1007 return i_to_a(curdiv->get_vertical_position().to_units()); 1008} 1009 1010class high_water_mark_reg : public reg { 1011public: 1012 int get_value(units *); 1013 const char *get_string(); 1014}; 1015 1016int high_water_mark_reg::get_value(units *res) 1017{ 1018 *res = curdiv->get_high_water_mark().to_units(); 1019 return 1; 1020} 1021 1022const char *high_water_mark_reg::get_string() 1023{ 1024 return i_to_a(curdiv->get_high_water_mark().to_units()); 1025} 1026 1027class distance_to_next_trap_reg : public reg { 1028public: 1029 int get_value(units *); 1030 const char *get_string(); 1031}; 1032 1033int distance_to_next_trap_reg::get_value(units *res) 1034{ 1035 *res = curdiv->distance_to_next_trap().to_units(); 1036 return 1; 1037} 1038 1039const char *distance_to_next_trap_reg::get_string() 1040{ 1041 return i_to_a(curdiv->distance_to_next_trap().to_units()); 1042} 1043 1044class diversion_name_reg : public reg { 1045public: 1046 const char *get_string(); 1047}; 1048 1049const char *diversion_name_reg::get_string() 1050{ 1051 return curdiv->get_diversion_name(); 1052} 1053 1054class page_number_reg : public general_reg { 1055public: 1056 page_number_reg(); 1057 int get_value(units *); 1058 void set_value(units); 1059}; 1060 1061page_number_reg::page_number_reg() 1062{ 1063} 1064 1065void page_number_reg::set_value(units n) 1066{ 1067 topdiv->set_page_number(n); 1068} 1069 1070int page_number_reg::get_value(units *res) 1071{ 1072 *res = topdiv->get_page_number(); 1073 return 1; 1074} 1075 1076class next_page_number_reg : public reg { 1077public: 1078 const char *get_string(); 1079}; 1080 1081const char *next_page_number_reg::get_string() 1082{ 1083 return i_to_a(topdiv->get_next_page_number()); 1084} 1085 1086class page_ejecting_reg : public reg { 1087public: 1088 const char *get_string(); 1089}; 1090 1091const char *page_ejecting_reg::get_string() 1092{ 1093 return i_to_a(topdiv->get_ejecting()); 1094} 1095 1096class constant_vunits_reg : public reg { 1097 vunits *p; 1098public: 1099 constant_vunits_reg(vunits *); 1100 const char *get_string(); 1101}; 1102 1103constant_vunits_reg::constant_vunits_reg(vunits *q) : p(q) 1104{ 1105} 1106 1107const char *constant_vunits_reg::get_string() 1108{ 1109 return i_to_a(p->to_units()); 1110} 1111 1112class nl_reg : public variable_reg { 1113public: 1114 nl_reg(); 1115 void set_value(units); 1116}; 1117 1118nl_reg::nl_reg() : variable_reg(&nl_reg_contents) 1119{ 1120} 1121 1122void nl_reg::set_value(units n) 1123{ 1124 variable_reg::set_value(n); 1125 // Setting nl to a negative value when the vertical position in 1126 // the top-level diversion is 0 undoes the top of page transition, 1127 // so that the header macro will be called as if the top of page 1128 // transition hasn't happened. This is used by Larry Wall's 1129 // wrapman program. Setting before_first_page to 2 rather than 1, 1130 // tells top_level_diversion::begin_page not to call 1131 // output_file::begin_page again. 1132 if (n < 0 && topdiv->get_vertical_position() == V0) 1133 topdiv->before_first_page = 2; 1134} 1135 1136class no_space_mode_reg : public reg { 1137public: 1138 int get_value(units *); 1139 const char *get_string(); 1140}; 1141 1142int no_space_mode_reg::get_value(units *val) 1143{ 1144 *val = curdiv->no_space_mode; 1145 return 1; 1146} 1147 1148const char *no_space_mode_reg::get_string() 1149{ 1150 return curdiv->no_space_mode ? "1" : "0"; 1151} 1152 1153void init_div_requests() 1154{ 1155 init_request("box", box); 1156 init_request("boxa", box_append); 1157 init_request("bp", begin_page); 1158 init_request("ch", change_trap); 1159 init_request("da", divert_append); 1160 init_request("di", divert); 1161 init_request("dt", diversion_trap); 1162 init_request("fl", flush_output); 1163 init_request("mk", mark); 1164 init_request("ne", need_space); 1165 init_request("ns", no_space); 1166 init_request("os", output_saved_vertical_space); 1167 init_request("pl", page_length); 1168 init_request("pn", page_number); 1169 init_request("po", page_offset); 1170 init_request("ptr", print_traps); 1171 init_request("rs", restore_spacing); 1172 init_request("rt", return_request); 1173 init_request("sp", space_request); 1174 init_request("sv", save_vertical_space); 1175 init_request("vpt", vertical_position_traps); 1176 init_request("wh", when_request); 1177 number_reg_dictionary.define(".a", 1178 new constant_int_reg(&last_post_line_extra_space)); 1179 number_reg_dictionary.define(".d", new vertical_position_reg); 1180 number_reg_dictionary.define(".h", new high_water_mark_reg); 1181 number_reg_dictionary.define(".ne", 1182 new constant_vunits_reg(&needed_space)); 1183 number_reg_dictionary.define(".ns", new no_space_mode_reg); 1184 number_reg_dictionary.define(".o", new page_offset_reg); 1185 number_reg_dictionary.define(".p", new page_length_reg); 1186 number_reg_dictionary.define(".pe", new page_ejecting_reg); 1187 number_reg_dictionary.define(".pn", new next_page_number_reg); 1188 number_reg_dictionary.define(".t", new distance_to_next_trap_reg); 1189 number_reg_dictionary.define(".trunc", 1190 new constant_vunits_reg(&truncated_space)); 1191 number_reg_dictionary.define(".vpt", 1192 new constant_int_reg(&vertical_position_traps_flag)); 1193 number_reg_dictionary.define(".z", new diversion_name_reg); 1194 number_reg_dictionary.define("dl", new variable_reg(&dl_reg_contents)); 1195 number_reg_dictionary.define("dn", new variable_reg(&dn_reg_contents)); 1196 number_reg_dictionary.define("nl", new nl_reg); 1197 number_reg_dictionary.define("%", new page_number_reg); 1198}