home *** CD-ROM | disk | FTP | other *** search
/ Frozen Fish 1: Amiga / FrozenFish-Apr94.iso / bbs / gnu / groff-1.09-src.lha / src / amiga / groff-1.09 / troff / env.cc < prev    next >
C/C++ Source or Header  |  1993-04-02  |  69KB  |  3,053 lines
  1. // -*- C++ -*-
  2. /* Copyright (C) 1989, 1990, 1991, 1992 Free Software Foundation, Inc.
  3.      Written by James Clark (jjc@jclark.com)
  4.  
  5. This file is part of groff.
  6.  
  7. groff is free software; you can redistribute it and/or modify it under
  8. the terms of the GNU General Public License as published by the Free
  9. Software Foundation; either version 2, or (at your option) any later
  10. version.
  11.  
  12. groff is distributed in the hope that it will be useful, but WITHOUT ANY
  13. WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14. FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15. for more details.
  16.  
  17. You should have received a copy of the GNU General Public License along
  18. with groff; see the file COPYING.  If not, write to the Free Software
  19. Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
  20.  
  21. #include "troff.h"
  22. #include "symbol.h"
  23. #include "dictionary.h"
  24. #include "hvunits.h"
  25. #include "env.h"
  26. #include "request.h"
  27. #include "node.h"
  28. #include "token.h"
  29. #include "div.h"
  30. #include "reg.h"
  31. #include "charinfo.h"
  32. #include "searchpath.h"
  33. #include "macropath.h"
  34. #include <math.h>
  35.  
  36. symbol default_family("T");
  37.  
  38. enum { ADJUST_LEFT = 0, ADJUST_BOTH = 1, ADJUST_CENTER = 3, ADJUST_RIGHT = 5 };
  39.  
  40. enum { HYPHEN_LAST_LINE = 2, HYPHEN_LAST_CHARS = 4, HYPHEN_FIRST_CHARS = 8 };
  41.  
  42. struct env_list {
  43.   environment *env;
  44.   env_list *next;
  45.   env_list(environment *e, env_list *p) : env(e), next(p) {}
  46. };
  47.  
  48. env_list *env_stack;
  49. const int NENVIRONMENTS = 10;
  50. environment *env_table[NENVIRONMENTS];
  51. dictionary env_dictionary(10);
  52. environment *curenv;
  53. static int next_line_number = 0;
  54.  
  55. charinfo *field_delimiter_char;
  56. charinfo *padding_indicator_char;
  57.  
  58. int translate_space_to_dummy = 0;
  59.  
  60. class pending_output_line {
  61.   node *nd;
  62.   int no_fill;
  63.   vunits vs;
  64.   int ls;
  65.   hunits width;
  66. #ifdef WIDOW_CONTROL
  67.   int last_line;        // Is it the last line of the paragraph?
  68. #endif /* WIDOW_CONTROL */
  69. public:
  70.   pending_output_line *next;
  71.  
  72.   pending_output_line(node *, int, vunits, int, hunits,
  73.               pending_output_line * = 0);
  74.   ~pending_output_line();
  75.   int output();
  76.  
  77. #ifdef WIDOW_CONTROL
  78.   friend void environment::mark_last_line();
  79.   friend void environment::output(node *, int, vunits, int, hunits);
  80. #endif /* WIDOW_CONTROL */
  81. };
  82.  
  83. pending_output_line::pending_output_line(node *n, int nf, vunits v, int l,
  84.                      hunits w, pending_output_line *p)
  85. : nd(n), no_fill(nf), vs(v), ls(l), width(w),
  86. #ifdef WIDOW_CONTROL
  87.   last_line(0),
  88. #endif /* WIDOW_CONTROL */
  89.   next(p)
  90. {
  91. }
  92.  
  93. pending_output_line::~pending_output_line()
  94. {
  95.   delete_node_list(nd);
  96. }
  97.  
  98. int pending_output_line::output()
  99. {
  100.   if (trap_sprung_flag)
  101.     return 0;
  102. #ifdef WIDOW_CONTROL
  103.   if (next && next->last_line && !no_fill) {
  104.     curdiv->need(vs*ls + vunits(vresolution));
  105.     if (trap_sprung_flag) {
  106.       next->last_line = 0;    // Try to avoid infinite loops.
  107.       return 0;
  108.     }
  109.   }
  110. #endif
  111.   curdiv->output(nd, no_fill, vs, ls, width);
  112.   nd = 0;
  113.   return 1;
  114. }
  115.  
  116. void environment::output(node *nd, int no_fill, vunits vs, int ls,
  117.              hunits width)
  118. {
  119. #ifdef WIDOW_CONTROL
  120.   while (pending_lines) {
  121.     if (widow_control && !pending_lines->no_fill && !pending_lines->next)
  122.       break;
  123.     if (!pending_lines->output())
  124.       break;
  125.     pending_output_line *tem = pending_lines;
  126.     pending_lines = pending_lines->next;
  127.     delete tem;
  128.   }
  129. #else /* WIDOW_CONTROL */
  130.   output_pending_lines();
  131. #endif /* WIDOW_CONTROL */
  132.   if (!trap_sprung_flag && !pending_lines
  133. #ifdef WIDOW_CONTROL
  134.       && (!widow_control || no_fill)
  135. #endif /* WIDOW_CONTROL */
  136.       )
  137.     curdiv->output(nd, no_fill, vs, ls, width);
  138.   else {
  139.     for (pending_output_line **p = &pending_lines; *p; p = &(*p)->next)
  140.       ;
  141.     *p = new pending_output_line(nd, no_fill, vs, ls, width);
  142.   }
  143. }
  144.  
  145. // a line from .tl goes at the head of the queue
  146.  
  147. void environment::output_title(node *nd, int no_fill, vunits vs, int ls,
  148.                    hunits width)
  149. {
  150.   if (!trap_sprung_flag)
  151.     curdiv->output(nd, no_fill, vs, ls, width);
  152.   else
  153.     pending_lines = new pending_output_line(nd, no_fill, vs, ls, width,
  154.                         pending_lines);
  155. }
  156.  
  157. void environment::output_pending_lines()
  158. {
  159.   while (pending_lines && pending_lines->output()) {
  160.     pending_output_line *tem = pending_lines;
  161.     pending_lines = pending_lines->next;
  162.     delete tem;
  163.   }
  164. }
  165.  
  166. #ifdef WIDOW_CONTROL
  167.  
  168. void environment::mark_last_line()
  169. {
  170.   if (!widow_control || !pending_lines)
  171.     return;
  172.   for (pending_output_line *p = pending_lines; p->next; p = p->next)
  173.     ;
  174.   if (!p->no_fill)
  175.     p->last_line = 1;
  176. }
  177.  
  178. void widow_control_request()
  179. {
  180.   int n;
  181.   if (has_arg() && get_integer(&n))
  182.     curenv->widow_control = n != 0;
  183.   else
  184.     curenv->widow_control = 1;
  185.   skip_line();
  186. }
  187.  
  188. #endif /* WIDOW_CONTROL */
  189.  
  190. /* font_size functions */
  191.  
  192. size_range *font_size::size_table = 0;
  193. int font_size::nranges = 0;
  194.  
  195. extern "C" {
  196.  
  197. static int compare_ranges(const void *p1, const void *p2)
  198. {
  199.   return ((size_range *)p1)->min - ((size_range *)p2)->min;
  200. }
  201.  
  202. }
  203.  
  204. void font_size::init_size_table(int *sizes)
  205. {
  206.   nranges = 0;
  207.   while (sizes[nranges*2] != 0)
  208.     nranges++;
  209.   assert(nranges > 0);
  210.   size_table = new size_range[nranges];
  211.   for (int i = 0; i < nranges; i++) {
  212.     size_table[i].min = sizes[i*2];
  213.     size_table[i].max = sizes[i*2 + 1];
  214.   }
  215.   qsort(size_table, nranges, sizeof(size_range), compare_ranges);
  216. }
  217.  
  218. font_size::font_size(int sp)
  219. {
  220.   for (int i = 0; i < nranges; i++) {
  221.     if (sp < size_table[i].min) {
  222.       if (i > 0 && size_table[i].min - sp >= sp - size_table[i - 1].max)
  223.     p = size_table[i - 1].max;
  224.       else
  225.     p = size_table[i].min;
  226.       return;
  227.     }
  228.     if (sp <= size_table[i].max) {
  229.       p = sp;
  230.       return;
  231.     }
  232.   }
  233.   p = size_table[nranges - 1].max;
  234. }
  235.  
  236. int font_size::to_units()
  237. {
  238.   return scale(p, units_per_inch, sizescale*72);
  239. }
  240.  
  241. // we can't do this in a static constructor because various dictionaries
  242. // have to get initialized first
  243.  
  244. void init_environments()
  245. {
  246.   curenv = env_table[0] = new environment("0");
  247. }
  248.  
  249. void tab_character()
  250. {
  251.   curenv->tab_char = get_optional_char();
  252.   skip_line();
  253. }
  254.  
  255. void leader_character()
  256. {
  257.   curenv->leader_char = get_optional_char();
  258.   skip_line();
  259. }
  260.  
  261. void environment::add_char(charinfo *ci)
  262. {
  263.   if (interrupted)
  264.     ;
  265.   // don't allow fields in dummy environments
  266.   else if (ci == field_delimiter_char && !dummy) {
  267.     if (current_field)
  268.       wrap_up_field();
  269.     else
  270.       start_field();
  271.   }
  272.   else if (current_field && ci == padding_indicator_char)
  273.     add_padding();
  274.   else if (current_tab) {
  275.     if (tab_contents == 0)
  276.       tab_contents = new line_start_node;
  277.     if (ci != hyphen_indicator_char)
  278.       tab_contents = tab_contents->add_char(ci, this, &tab_width);
  279.     else
  280.       tab_contents = tab_contents->add_discretionary_hyphen();
  281.   }
  282.   else {
  283.     if (line == 0)
  284.       start_line();
  285.     if (ci != hyphen_indicator_char)
  286.       line = line->add_char(ci, this, &width_total);
  287.     else
  288.       line = line->add_discretionary_hyphen();
  289.   }
  290. }
  291.  
  292. node *environment::make_char_node(charinfo *ci)
  293. {
  294.   return make_node(ci, this);
  295. }
  296.  
  297. void environment::add_node(node *n)
  298. {
  299.   assert(n != 0);
  300.   if (current_tab || current_field)
  301.     n->freeze_space();
  302.   if (interrupted) {
  303.     delete n;
  304.   }
  305.   else if (current_tab) {
  306.     n->next = tab_contents;
  307.     tab_contents = n;
  308.     tab_width += n->width();
  309.   }
  310.   else {
  311.     if (line == 0) {
  312.       if (discarding && n->discardable()) {
  313.     // XXX possibly: input_line_start -= n->width();
  314.     delete n;
  315.     return;
  316.       }
  317.       start_line();
  318.     }
  319.     width_total += n->width();
  320.     space_total += n->nspaces();
  321.     n->next = line;
  322.     line = n;
  323.   }
  324. }
  325.  
  326.  
  327. void environment::add_hyphen_indicator()
  328. {
  329.   if (current_tab || interrupted || current_field
  330.       || hyphen_indicator_char != 0)
  331.     return;
  332.   if (line == 0)
  333.     start_line();
  334.   line = line->add_discretionary_hyphen();
  335. }
  336.  
  337. int environment::get_hyphenation_flags()
  338. {
  339.   return hyphenation_flags;
  340. }
  341.  
  342. int environment::get_hyphen_line_max()
  343. {
  344.   return hyphen_line_max;
  345. }
  346.  
  347. int environment::get_hyphen_line_count()
  348. {
  349.   return hyphen_line_count;
  350. }
  351.  
  352. int environment::get_center_lines()
  353. {
  354.   return center_lines;
  355. }
  356.  
  357. int environment::get_right_justify_lines()
  358. {
  359.   return right_justify_lines;
  360. }
  361.  
  362. void environment::add_italic_correction()
  363. {
  364.   if (current_tab) {
  365.     if (tab_contents)
  366.       tab_contents = tab_contents->add_italic_correction(&tab_width);
  367.   }
  368.   else if (line)
  369.     line = line->add_italic_correction(&width_total);
  370. }
  371.  
  372. void environment::space_newline()
  373. {
  374.   assert(!current_tab && !current_field);
  375.   if (interrupted)
  376.     return;
  377.   hunits x = H0;
  378.   if (!translate_space_to_dummy) {
  379.     x = env_space_width(this);
  380.     if (node_list_ends_sentence(line) == 1)
  381.       x += env_sentence_space_width(this);
  382.   }
  383.   if (line != 0 && line->merge_space(x)) {
  384.     width_total += x;
  385.     return;
  386.   }
  387.   add_node(new word_space_node(x));
  388.   possibly_break_line(spread_flag);
  389.   spread_flag = 0;
  390. }
  391.  
  392. void environment::space()
  393. {
  394.   if (interrupted)
  395.     return;
  396.   if (current_field && padding_indicator_char == 0) {
  397.     add_padding();
  398.     return;
  399.   }
  400.   hunits x = translate_space_to_dummy ? H0 : env_space_width(this);
  401.   node *p = current_tab ? tab_contents : line;
  402.   hunits *tp = current_tab ? &tab_width : &width_total;
  403.   if (p && p->nspaces() == 1 && p->width() == x
  404.       && node_list_ends_sentence(p->next) == 1) {
  405.     hunits xx = translate_space_to_dummy ? H0 : env_sentence_space_width(this);
  406.     if (p->merge_space(xx)) {
  407.       *tp += xx;
  408.       return;
  409.     }
  410.   }
  411.   if (p && p->merge_space(x)) {
  412.     *tp += x;
  413.     return;
  414.   }
  415.   add_node(new word_space_node(x));
  416.   possibly_break_line(spread_flag);
  417.   spread_flag = 0;
  418. }
  419.  
  420. void environment::set_font(symbol nm)
  421. {
  422.   if (interrupted)
  423.     return;
  424.   if (nm == symbol("P")) {
  425.     if (family->make_definite(prev_fontno) < 0)
  426.       return;
  427.     int tem = fontno;
  428.     fontno = prev_fontno;
  429.     prev_fontno = tem;
  430.   }
  431.   else {
  432.     int n = symbol_fontno(nm);
  433.     if (n < 0) {
  434.       n = next_available_font_position();
  435.       if (!mount_font(n, nm))
  436.     return;
  437.     }
  438.     if (family->make_definite(n) < 0)
  439.       return;
  440.     prev_fontno = fontno;
  441.     fontno = n;
  442.   }
  443. }
  444.  
  445. void environment::set_font(int n)
  446. {
  447.   if (interrupted)
  448.     return;
  449.   if (is_good_fontno(n)) {
  450.     prev_fontno = fontno;
  451.     fontno = n;
  452.   }
  453.   else
  454.     error("bad font number");
  455. }
  456.  
  457. void environment::set_family(symbol fam)
  458. {
  459.   if (fam.is_null()) {
  460.     if (prev_family->make_definite(fontno) < 0)
  461.       return;
  462.     font_family *tem = family;
  463.     family = prev_family;
  464.     prev_family = tem;
  465.   }
  466.   else {
  467.     font_family *f = lookup_family(fam);
  468.     if (f->make_definite(fontno) < 0)
  469.       return;
  470.     prev_family = family;
  471.     family = f;
  472.   }
  473. }
  474.  
  475. void environment::set_size(int n)
  476. {
  477.   if (interrupted)
  478.     return;
  479.   if (n == 0) {
  480.     font_size temp = prev_size;
  481.     prev_size = size;
  482.     size = temp;
  483.     int temp2 = prev_requested_size;
  484.     prev_requested_size = requested_size;
  485.     requested_size = temp2;
  486.   }
  487.   else {
  488.     prev_size = size;
  489.     size = font_size(n);
  490.     prev_requested_size = requested_size;
  491.     requested_size = n;
  492.   }
  493. }
  494.  
  495. void environment::set_char_height(int n)
  496. {
  497.   if (interrupted)
  498.     return;
  499.   if (n == requested_size || n <= 0)
  500.     char_height = 0;
  501.   else
  502.     char_height = n;
  503. }
  504.  
  505. void environment::set_char_slant(int n)
  506. {
  507.   if (interrupted)
  508.     return;
  509.   char_slant = n;
  510. }
  511.  
  512. environment::environment(symbol nm)
  513. : name(nm),
  514.   prev_line_length((units_per_inch*13)/2),
  515.   line_length((units_per_inch*13)/2),
  516.   prev_title_length((units_per_inch*13)/2),
  517.   title_length((units_per_inch*13)/2),
  518.   prev_size(sizescale*10),
  519.   size(sizescale*10),
  520.   requested_size(sizescale*10),
  521.   prev_requested_size(sizescale*10),
  522.   char_height(0),
  523.   char_slant(0),
  524.   space_size(12),
  525.   sentence_space_size(12),
  526.   adjust_mode(ADJUST_BOTH),
  527.   fill(1),
  528.   interrupted(0),
  529.   prev_line_interrupted(0),
  530.   center_lines(0),
  531.   right_justify_lines(0),
  532.   prev_vertical_spacing(points_to_units(12)),
  533.   vertical_spacing(points_to_units(12)),
  534.   prev_line_spacing(1),
  535.   line_spacing(1),
  536.   prev_indent(0),
  537.   indent(0),
  538.   have_temporary_indent(0),
  539.   temporary_indent(0),
  540.   underline_lines(0),
  541.   input_trap_count(0),
  542.   prev_text_length(0),
  543.   width_total(0),
  544.   space_total(0),
  545.   input_line_start(0),
  546.   control_char('.'),
  547.   no_break_control_char('\''),
  548.   hyphen_indicator_char(0),
  549.   spread_flag(0),
  550.   line(0),
  551.   pending_lines(0),
  552.   discarding(0),
  553.   tabs(units_per_inch/2, TAB_LEFT),
  554.   current_tab(TAB_NONE),
  555.   current_field(0),
  556.   margin_character_flags(0),
  557.   margin_character_node(0),
  558.   margin_character_distance(points_to_units(10)),
  559.   numbering_nodes(0),
  560.   number_text_separation(1),
  561.   line_number_multiple(1),
  562.   line_number_indent(0),
  563.   no_number_count(0),
  564.   tab_char(0),
  565.   leader_char(charset_table['.']),
  566.   hyphenation_flags(1),
  567.   dummy(0),
  568.   leader_node(0),
  569. #ifdef WIDOW_CONTROL
  570.   widow_control(0),
  571. #endif /* WIDOW_CONTROL */
  572.   hyphen_line_count(0),
  573.   hyphen_line_max(-1),
  574.   hyphenation_space(H0),
  575.   hyphenation_margin(H0),
  576.   composite(0)
  577. {
  578.   prev_family = family = lookup_family(default_family);
  579.   prev_fontno = fontno = 1;
  580.   if (!is_good_fontno(1))
  581.     fatal("font number 1 not a valid font");
  582.   if (family->make_definite(1) < 0)
  583.     fatal("invalid default family `%1'", default_family.contents());
  584.   prev_fontno = fontno;
  585. }
  586.  
  587. environment::environment(const environment *e)
  588. : name(e->name),        // so that eg `.if "\n[.ev]"0"' works
  589.   prev_line_length(e->prev_line_length),
  590.   line_length(e->line_length),
  591.   prev_title_length(e->prev_title_length),
  592.   title_length(e->title_length),
  593.   prev_size(e->prev_size),
  594.   size(e->size),
  595.   prev_requested_size(e->prev_requested_size),
  596.   requested_size(e->requested_size),
  597.   char_height(e->char_height),
  598.   char_slant(e->char_slant),
  599.   space_size(e->space_size),
  600.   sentence_space_size(e->sentence_space_size),
  601.   adjust_mode(e->adjust_mode),
  602.   fill(e->fill),
  603.   interrupted(0),
  604.   prev_line_interrupted(0),
  605.   center_lines(0),
  606.   right_justify_lines(0),
  607.   prev_vertical_spacing(e->prev_vertical_spacing),
  608.   vertical_spacing(e->vertical_spacing),
  609.   prev_line_spacing(e->prev_line_spacing),
  610.   line_spacing(e->line_spacing),
  611.   prev_indent(e->prev_indent),
  612.   indent(e->indent),
  613.   have_temporary_indent(0),
  614.   temporary_indent(0),
  615.   underline_lines(0),
  616.   input_trap_count(0),
  617.   prev_text_length(e->prev_text_length),
  618.   width_total(0),
  619.   space_total(0),
  620.   input_line_start(0),
  621.   control_char(e->control_char),
  622.   no_break_control_char(e->no_break_control_char),
  623.   hyphen_indicator_char(e->hyphen_indicator_char),
  624.   spread_flag(0),
  625.   line(0),
  626.   pending_lines(0),
  627.   discarding(0),
  628.   tabs(e->tabs),
  629.   current_tab(TAB_NONE),
  630.   current_field(0),
  631.   margin_character_flags(e->margin_character_flags),
  632.   margin_character_node(e->margin_character_node),
  633.   margin_character_distance(e->margin_character_distance),
  634.   numbering_nodes(0),
  635.   number_text_separation(e->number_text_separation),
  636.   line_number_multiple(e->line_number_multiple),
  637.   line_number_indent(e->line_number_indent),
  638.   no_number_count(e->no_number_count),
  639.   tab_char(e->tab_char),
  640.   leader_char(e->leader_char),
  641.   hyphenation_flags(e->hyphenation_flags),
  642.   fontno(e->fontno),
  643.   prev_fontno(e->prev_fontno),
  644.   dummy(1),
  645.   family(e->family),
  646.   prev_family(e->prev_family),
  647.   leader_node(0),
  648. #ifdef WIDOW_CONTROL
  649.   widow_control(e->widow_control),
  650. #endif /* WIDOW_CONTROL */
  651.   hyphen_line_max(e->hyphen_line_max),
  652.   hyphen_line_count(0),
  653.   hyphenation_space(e->hyphenation_space),
  654.   hyphenation_margin(e->hyphenation_margin),
  655.   composite(0)
  656. {
  657. }
  658.  
  659. environment::~environment()
  660. {
  661.   delete leader_node;
  662.   delete_node_list(line);
  663.   delete_node_list(numbering_nodes);
  664. }
  665.  
  666. hunits environment::get_input_line_position()
  667. {
  668.   hunits n;
  669.   if (line == 0)
  670.     n = -input_line_start;
  671.   else
  672.     n = width_total - input_line_start;
  673.   if (current_tab)
  674.     n += tab_width;
  675.   return n;
  676. }
  677.  
  678. void environment::set_input_line_position(hunits n)
  679. {
  680.   input_line_start = line == 0 ? -n : width_total - n;
  681.   if (current_tab)
  682.     input_line_start += tab_width;
  683. }
  684.  
  685. hunits environment::get_line_length()
  686. {
  687.   return line_length;
  688. }
  689.  
  690. hunits environment::get_saved_line_length()
  691. {
  692.   if (line)
  693.     return target_text_length + saved_indent;
  694.   else
  695.     return line_length;
  696. }
  697.  
  698. vunits environment::get_vertical_spacing()
  699. {
  700.   return vertical_spacing;
  701. }
  702.  
  703. int environment::get_line_spacing()
  704. {
  705.   return line_spacing;
  706. }
  707.  
  708. int environment::get_bold()
  709. {
  710.   return get_bold_fontno(fontno);
  711. }
  712.  
  713. hunits environment::get_digit_width()
  714. {
  715.   return env_digit_width(this);
  716. } 
  717.  
  718. int environment::get_adjust_mode()
  719. {
  720.   return adjust_mode;
  721. }
  722.  
  723. int environment::get_fill()
  724. {
  725.   return fill;
  726. }
  727.  
  728. hunits environment::get_indent()
  729. {
  730.   return indent;
  731. }
  732.  
  733. hunits environment::get_saved_indent()
  734. {
  735.   if (line)
  736.     return saved_indent;
  737.   else if (have_temporary_indent)
  738.     return temporary_indent;
  739.   else
  740.     return indent;
  741. }
  742.  
  743. hunits environment::get_temporary_indent()
  744. {
  745.   return temporary_indent;
  746. }
  747.  
  748. hunits environment::get_title_length()
  749. {
  750.   return title_length;
  751. }
  752.  
  753. node *environment::get_prev_char()
  754. {
  755.   for (node *n = current_tab ? tab_contents : line; n; n = n->next) {
  756.     node *last = n->last_char_node();
  757.     if (last)
  758.       return last;
  759.   }
  760.   return 0;
  761. }
  762.  
  763. hunits environment::get_prev_char_width()
  764. {
  765.   node *last = get_prev_char();
  766.   if (!last)
  767.     return H0;
  768.   return last->width();
  769. }
  770.  
  771. hunits environment::get_prev_char_skew()
  772. {
  773.   node *last = get_prev_char();
  774.   if (!last)
  775.     return H0;
  776.   return last->skew();
  777. }
  778.  
  779. vunits environment::get_prev_char_height()
  780. {
  781.   node *last = get_prev_char();
  782.   if (!last)
  783.     return V0;
  784.   vunits min, max;
  785.   last->vertical_extent(&min, &max);
  786.   return -min;
  787. }
  788.  
  789. vunits environment::get_prev_char_depth()
  790. {
  791.   node *last = get_prev_char();
  792.   if (!last)
  793.     return V0;
  794.   vunits min, max;
  795.   last->vertical_extent(&min, &max);
  796.   return max;
  797. }
  798.  
  799. hunits environment::get_text_length()
  800. {
  801.   hunits n = line == 0 ? H0 : width_total;
  802.   if (current_tab)
  803.     n += tab_width;
  804.   return n;
  805. }
  806.  
  807. hunits environment::get_prev_text_length()
  808. {
  809.   return prev_text_length;
  810. }
  811.  
  812.  
  813. static int sb_reg_contents = 0;
  814. static int st_reg_contents = 0;
  815. static int ct_reg_contents = 0;
  816. static int rsb_reg_contents = 0;
  817. static int rst_reg_contents = 0;
  818. static int skw_reg_contents = 0;
  819. static int ssc_reg_contents = 0;
  820.  
  821. void environment::width_registers()
  822. {
  823.   // this is used to implement \w; it sets the st, sb, ct registers
  824.   vunits min = 0, max = 0, cur = 0;
  825.   int character_type = 0;
  826.   ssc_reg_contents = line ? line->subscript_correction().to_units() : 0;
  827.   skw_reg_contents = line ? line->skew().to_units() : 0;
  828.   line = reverse_node_list(line);
  829.   vunits real_min = V0;
  830.   vunits real_max = V0;
  831.   vunits v1, v2;
  832.   for (node *tem = line; tem; tem = tem->next) {
  833.     tem->vertical_extent(&v1, &v2);
  834.     v1 += cur;
  835.     if (v1 < real_min)
  836.       real_min = v1;
  837.     v2 += cur;
  838.     if (v2 > real_max)
  839.       real_max = v2;
  840.     if ((cur += tem->vertical_width()) < min)
  841.       min = cur;
  842.     else if (cur > max)
  843.       max = cur;
  844.     character_type |= tem->character_type();
  845.   }
  846.   line = reverse_node_list(line);
  847.   st_reg_contents = -min.to_units();
  848.   sb_reg_contents = -max.to_units();
  849.   rst_reg_contents = -real_min.to_units();
  850.   rsb_reg_contents = -real_max.to_units();
  851.   ct_reg_contents = character_type;
  852. }
  853.  
  854. node *environment::extract_output_line()
  855. {
  856.   if (current_tab)
  857.     wrap_up_tab();
  858.   node *n = line;
  859.   line = 0;
  860.   return n;
  861. }
  862.  
  863. /* environment related requests */
  864.  
  865. void environment_switch()
  866. {
  867.   int pop = 0;    // 1 means pop, 2 means pop but no error message on underflow
  868.   if (curenv->is_dummy())
  869.     error("can't switch environments when current environment is dummy");
  870.   else if (!has_arg())
  871.     pop = 1;
  872.   else {
  873.     symbol nm;
  874.     if (!tok.delimiter()) {
  875.       // It looks like a number.
  876.       int n;
  877.       if (get_integer(&n)) {
  878.     if (n >= 0 && n < NENVIRONMENTS) {
  879.       env_stack = new env_list(curenv, env_stack);
  880.       if (env_table[n] == 0)
  881.         env_table[n] = new environment(itoa(n));
  882.       curenv = env_table[n];
  883.     }
  884.     else
  885.       nm = itoa(n);
  886.       }
  887.       else
  888.     pop = 2;
  889.     }
  890.     else {
  891.       nm = get_long_name(1);
  892.       if (nm.is_null())
  893.     pop = 2;
  894.     }
  895.     if (!nm.is_null()) {
  896.       environment *e = (environment *)env_dictionary.lookup(nm);
  897.       if (!e) {
  898.     e = new environment(nm);
  899.     (void)env_dictionary.lookup(nm, e);
  900.       }
  901.       env_stack = new env_list(curenv, env_stack);
  902.       curenv = e;
  903.     }
  904.   }
  905.   if (pop) {
  906.     if (env_stack == 0) {
  907.       if (pop == 1)
  908.     error("environment stack underflow");
  909.     }
  910.     else {
  911.       curenv = env_stack->env;
  912.       env_list *tem = env_stack;
  913.       env_stack = env_stack->next;
  914.       delete tem;
  915.     }
  916.   }
  917.   skip_line();
  918. }
  919.  
  920.  
  921. static symbol P_symbol("P");
  922.  
  923. void font_change()
  924. {
  925.   symbol s = get_name();
  926.   int is_number = 1;
  927.   if (s.is_null() || s == P_symbol) {
  928.     s = P_symbol;
  929.     is_number = 0;
  930.   }
  931.   else {
  932.     for (const char *p = s.contents(); p != 0 && *p != 0; p++)
  933.       if (!csdigit(*p)) {
  934.     is_number = 0;
  935.     break;
  936.       }
  937.   }
  938.   if (is_number)
  939.     curenv->set_font(atoi(s.contents()));
  940.   else
  941.     curenv->set_font(s);
  942.   skip_line();
  943. }
  944.  
  945. void family_change()
  946. {
  947.   symbol s = get_name(1);
  948.   if (!s.is_null())
  949.     curenv->set_family(s);
  950.   skip_line();
  951. }
  952.  
  953. void point_size()
  954. {
  955.   int n;
  956.   if (has_arg() && get_number(&n, 'z', curenv->get_requested_point_size())) {
  957.     if (n <= 0)
  958.       n = 1;
  959.     curenv->set_size(n);
  960.   }
  961.   else
  962.     curenv->set_size(0);
  963.   skip_line();
  964. }
  965.  
  966. void space_size()
  967. {
  968.   int n;
  969.   if (get_integer(&n)) {
  970.     curenv->space_size = n;
  971.     if (has_arg() && get_integer(&n))
  972.       curenv->sentence_space_size = n;
  973.     else
  974.       curenv->sentence_space_size = curenv->space_size;
  975.   }
  976.   skip_line();
  977. }
  978.  
  979. void fill()
  980. {
  981.   while (!tok.newline() && !tok.eof())
  982.     tok.next();
  983.   if (break_flag)
  984.     curenv->do_break();
  985.   curenv->fill = 1;
  986.   tok.next();
  987. }
  988.  
  989. void no_fill()
  990. {
  991.   while (!tok.newline() && !tok.eof())
  992.     tok.next();
  993.   if (break_flag)
  994.     curenv->do_break();
  995.   curenv->fill = 0;
  996.   tok.next();
  997. }
  998.  
  999. void center()
  1000. {
  1001.   int n;
  1002.   if (!has_arg() || !get_integer(&n))
  1003.     n = 1;
  1004.   else if (n < 0)
  1005.     n = 0;
  1006.   while (!tok.newline() && !tok.eof())
  1007.     tok.next();
  1008.   if (break_flag)
  1009.     curenv->do_break();
  1010.   curenv->right_justify_lines = 0;
  1011.   curenv->center_lines = n;
  1012.   tok.next();
  1013. }
  1014.  
  1015. void right_justify()
  1016. {
  1017.   int n;
  1018.   if (!has_arg() || !get_integer(&n))
  1019.     n = 1;
  1020.   else if (n < 0)
  1021.     n = 0;
  1022.   while (!tok.newline() && !tok.eof())
  1023.     tok.next();
  1024.   if (break_flag)
  1025.     curenv->do_break();
  1026.   curenv->center_lines = 0;
  1027.   curenv->right_justify_lines = n;
  1028.   tok.next();
  1029. }
  1030.  
  1031. void line_length()
  1032. {
  1033.   hunits temp;
  1034.   if (has_arg() && get_hunits(&temp, 'm', curenv->line_length)) {
  1035.     if (temp < H0) {
  1036.       warning(WARN_RANGE, "bad line length %1u", temp.to_units());
  1037.       temp = H0;
  1038.     }
  1039.   }
  1040.   else
  1041.     temp = curenv->prev_line_length;
  1042.   curenv->prev_line_length = curenv->line_length;
  1043.   curenv->line_length = temp;
  1044.   skip_line();
  1045. }
  1046.  
  1047. void title_length()
  1048. {
  1049.   hunits temp;
  1050.   if (has_arg() && get_hunits(&temp, 'm', curenv->title_length)) {
  1051.     if (temp < H0) {
  1052.       warning(WARN_RANGE, "bad title length %1u", temp.to_units());
  1053.       temp = H0;
  1054.     }
  1055.   }
  1056.   else
  1057.     temp = curenv->prev_title_length;
  1058.   curenv->prev_title_length = curenv->title_length;
  1059.   curenv->title_length = temp;
  1060.   skip_line();
  1061. }
  1062.  
  1063. void vertical_spacing()
  1064. {
  1065.   vunits temp;
  1066.   if (has_arg() && get_vunits(&temp, 'p', curenv->vertical_spacing)) {
  1067.     if (temp <= V0) {
  1068.       warning(WARN_RANGE, "vertical spacing must be greater than 0");
  1069.       temp = vresolution;
  1070.     }
  1071.   }
  1072.   else
  1073.     temp = curenv->prev_vertical_spacing;
  1074.   curenv->prev_vertical_spacing = curenv->vertical_spacing;
  1075.   curenv->vertical_spacing = temp;
  1076.   skip_line();
  1077. }
  1078.  
  1079. void line_spacing()
  1080. {
  1081.   int temp;
  1082.   if (has_arg() && get_integer(&temp)) {
  1083.     if (temp < 1) {
  1084.       warning(WARN_RANGE, "value %1 out of range: interpreted as 1", temp);
  1085.       temp = 1;
  1086.     }
  1087.   }
  1088.   else
  1089.     temp = curenv->prev_line_spacing;
  1090.   curenv->prev_line_spacing = curenv->line_spacing;
  1091.   curenv->line_spacing = temp;
  1092.   skip_line();
  1093. }
  1094.  
  1095. void indent()
  1096. {
  1097.   hunits temp;
  1098.   if (has_arg() && get_hunits(&temp, 'm', curenv->indent)) {
  1099.     if (temp < H0) {
  1100.       warning(WARN_RANGE, "indent cannot be negative");
  1101.       temp = H0;
  1102.     }
  1103.   }
  1104.   else
  1105.     temp = curenv->prev_indent;
  1106.   while (!tok.newline() && !tok.eof())
  1107.     tok.next();
  1108.   if (break_flag)
  1109.     curenv->do_break();
  1110.   curenv->have_temporary_indent = 0;
  1111.   curenv->prev_indent = curenv->indent;
  1112.   curenv->indent = temp;
  1113.   tok.next();
  1114. }
  1115.  
  1116. void temporary_indent()
  1117. {
  1118.   int err = 0;
  1119.   hunits temp;
  1120.   if (!get_hunits(&temp, 'm', curenv->get_indent()))
  1121.     err = 1;
  1122.   while (!tok.newline() && !tok.eof())
  1123.     tok.next();
  1124.   if (break_flag)
  1125.     curenv->do_break();
  1126.   if (temp < H0) {
  1127.     warning(WARN_RANGE, "total indent cannot be negative");
  1128.     temp = H0;
  1129.   }
  1130.   if (!err) {
  1131.     curenv->temporary_indent = temp;
  1132.     curenv->have_temporary_indent = 1;
  1133.   }
  1134.   tok.next();
  1135. }
  1136.  
  1137. void underline()
  1138. {
  1139.   int n;
  1140.   if (!has_arg() || !get_integer(&n))
  1141.     n = 1;
  1142.   if (n <= 0) {
  1143.     if (curenv->underline_lines > 0) {
  1144.       curenv->prev_fontno = curenv->fontno;
  1145.       curenv->fontno = curenv->pre_underline_fontno;
  1146.     }
  1147.     curenv->underline_lines = 0;
  1148.   }
  1149.   else {
  1150.     curenv->underline_lines = n;
  1151.     curenv->pre_underline_fontno = curenv->fontno;
  1152.     curenv->fontno = get_underline_fontno();
  1153.   }
  1154.   skip_line();
  1155. }
  1156.  
  1157. void control_char()
  1158. {
  1159.   curenv->control_char = '.';
  1160.   if (has_arg()) {
  1161.     if (tok.ch() == 0)
  1162.       error("bad control character");
  1163.     else
  1164.       curenv->control_char = tok.ch();
  1165.   }
  1166.   skip_line();
  1167. }
  1168.  
  1169. void no_break_control_char()
  1170. {
  1171.   curenv->no_break_control_char = '\'';
  1172.   if (has_arg()) {
  1173.     if (tok.ch() == 0)
  1174.       error("bad control character");
  1175.     else
  1176.       curenv->no_break_control_char = tok.ch();
  1177.   }
  1178.   skip_line();
  1179. }
  1180.  
  1181. void margin_character()
  1182. {
  1183.   charinfo *ci = get_optional_char();
  1184.   if (ci) {
  1185.     node *nd = curenv->make_char_node(ci);
  1186.     if (nd) {
  1187.       delete curenv->margin_character_node;
  1188.       curenv->margin_character_node = nd;
  1189.       curenv->margin_character_flags = (MARGIN_CHARACTER_ON
  1190.                     |MARGIN_CHARACTER_NEXT);
  1191.       hunits d;
  1192.       if (has_arg() && get_hunits(&d, 'm'))
  1193.     curenv->margin_character_distance = d;
  1194.     }
  1195.   }
  1196.   else {
  1197.     curenv->margin_character_flags &= ~MARGIN_CHARACTER_ON;
  1198.     if (curenv->margin_character_flags == 0) {
  1199.       delete curenv->margin_character_node;
  1200.       curenv->margin_character_node = 0;
  1201.     }
  1202.   }
  1203.   skip_line();
  1204. }
  1205.  
  1206. void number_lines()
  1207. {
  1208.   delete_node_list(curenv->numbering_nodes);
  1209.   curenv->numbering_nodes = 0;
  1210.   if (has_arg()) {
  1211.     node *nd = 0;
  1212.     for (int i = '9'; i >= '0'; i--) {
  1213.       node *tem = make_node(charset_table[i], curenv);
  1214.       if (!tem) {
  1215.     skip_line();
  1216.     return;
  1217.       }
  1218.       tem->next = nd;
  1219.       nd = tem;
  1220.     }
  1221.     curenv->numbering_nodes = nd;
  1222.     curenv->line_number_digit_width = env_digit_width(curenv);
  1223.     int n;
  1224.     if (!tok.delimiter()) {
  1225.       if (get_integer(&n, next_line_number)) {
  1226.     next_line_number = n;
  1227.     if (next_line_number < 0) {
  1228.       warning(WARN_RANGE, "negative line number");
  1229.       next_line_number = 0;
  1230.     }
  1231.       }
  1232.     }
  1233.     else
  1234.       while (!tok.space() && !tok.newline() && !tok.eof())
  1235.     tok.next();
  1236.     if (has_arg()) {
  1237.       if (!tok.delimiter()) {
  1238.     if (get_integer(&n)) {
  1239.       if (n <= 0) {
  1240.         warning(WARN_RANGE, "negative or zero line number multiple");
  1241.       }
  1242.       else
  1243.         curenv->line_number_multiple = n;
  1244.     }
  1245.       }
  1246.       else
  1247.     while (!tok.space() && !tok.newline() && !tok.eof())
  1248.       tok.next();
  1249.       if (has_arg()) {
  1250.     if (!tok.delimiter()) {
  1251.       if (get_integer(&n))
  1252.         curenv->number_text_separation = n;
  1253.     }
  1254.     else
  1255.       while (!tok.space() && !tok.newline() && !tok.eof())
  1256.         tok.next();
  1257.     if (has_arg() && !tok.delimiter() && get_integer(&n))
  1258.       curenv->line_number_indent = n;
  1259.       }
  1260.     }
  1261.   }
  1262.   skip_line();
  1263. }
  1264.  
  1265. void no_number()
  1266. {
  1267.   int n;
  1268.   if (has_arg() && get_integer(&n))
  1269.     curenv->no_number_count = n > 0 ? n : 0;
  1270.   else
  1271.     curenv->no_number_count = 1;
  1272.   skip_line();
  1273. }
  1274.  
  1275. void no_hyphenate()
  1276. {
  1277.   curenv->hyphenation_flags = 0;
  1278.   skip_line();
  1279. }
  1280.  
  1281. void hyphenate_request()
  1282. {
  1283.   int n;
  1284.   if (has_arg() && get_integer(&n))
  1285.     curenv->hyphenation_flags = n;
  1286.   else
  1287.     curenv->hyphenation_flags = 1;
  1288.   skip_line();
  1289. }
  1290.  
  1291. void hyphen_char()
  1292. {
  1293.   curenv->hyphen_indicator_char = get_optional_char();
  1294.   skip_line();
  1295. }
  1296.  
  1297. void hyphen_line_max_request()
  1298. {
  1299.   int n;
  1300.   if (has_arg() && get_integer(&n))
  1301.     curenv->hyphen_line_max = n;
  1302.   else
  1303.     curenv->hyphen_line_max = -1;
  1304.   skip_line();
  1305. }
  1306.  
  1307. void environment::interrupt()
  1308. {
  1309.   if (!dummy) {
  1310.     add_node(new transparent_dummy_node);
  1311.     interrupted = 1;
  1312.   }
  1313. }
  1314.  
  1315. void environment::newline()
  1316. {
  1317.   if (underline_lines > 0) {
  1318.     if (--underline_lines == 0) {
  1319.       prev_fontno = fontno;
  1320.       fontno = pre_underline_fontno;
  1321.     }
  1322.   }
  1323.   if (current_field)
  1324.     wrap_up_field();
  1325.   if (current_tab)
  1326.     wrap_up_tab();
  1327.   // strip trailing spaces
  1328.   while (line != 0 && line->discardable()) {
  1329.     width_total -= line->width();
  1330.     space_total -= line->nspaces();
  1331.     node *tem = line;
  1332.     line = line->next;
  1333.     delete tem;
  1334.   }
  1335.   node *to_be_output = 0;
  1336.   hunits to_be_output_width;
  1337.   prev_line_interrupted = 0;
  1338.   if (dummy)
  1339.     space_newline();
  1340.   else if (interrupted) {
  1341.     interrupted = 0;
  1342.     // see environment::final_break
  1343.     prev_line_interrupted = exit_started ? 2 : 1;
  1344.   }
  1345.   else if (center_lines > 0) {
  1346.     --center_lines;
  1347.     hunits x = target_text_length - width_total;
  1348.     if (x > H0)
  1349.       saved_indent += x/2;
  1350.     to_be_output = line;
  1351.     to_be_output_width = width_total;
  1352.     line = 0;
  1353.   }
  1354.   else if (right_justify_lines > 0) {
  1355.     --right_justify_lines;
  1356.     hunits x = target_text_length - width_total;
  1357.     if (x > H0)
  1358.       saved_indent += x;
  1359.     to_be_output = line;
  1360.     to_be_output_width = width_total;
  1361.     line = 0;
  1362.   }
  1363.   else if (fill)
  1364.     space_newline();
  1365.   else {
  1366.     to_be_output = line;
  1367.     to_be_output_width = width_total;
  1368.     line = 0;
  1369.   }
  1370.   input_line_start = line == 0 ? H0 : width_total;
  1371.   if (to_be_output) {
  1372.     output_line(to_be_output, to_be_output_width);
  1373.     hyphen_line_count = 0;
  1374.   }
  1375.   if (input_trap_count > 0) {
  1376.     if (--input_trap_count == 0)
  1377.       spring_trap(input_trap);
  1378.   }
  1379. }
  1380.  
  1381. void environment::output_line(node *n, hunits width)
  1382. {
  1383.   prev_text_length = width;
  1384.   if (margin_character_flags) {
  1385.     hunits d = line_length + margin_character_distance - saved_indent - width;
  1386.     if (d > 0) {
  1387.       n = new hmotion_node(d, n);
  1388.       width += d;
  1389.     }
  1390.     margin_character_flags &= ~MARGIN_CHARACTER_NEXT;
  1391.     node *tem;
  1392.     if (!margin_character_flags) {
  1393.       tem = margin_character_node;
  1394.       margin_character_node = 0;
  1395.     }
  1396.     else
  1397.       tem = margin_character_node->copy();
  1398.     tem->next = n;
  1399.     n = tem;
  1400.     width += tem->width();
  1401.   }
  1402.   node *nn = 0;
  1403.   while (n != 0) {
  1404.     node *tem = n->next;
  1405.     n->next = nn;
  1406.     nn = n;
  1407.     n = tem;
  1408.   }
  1409.   if (!saved_indent.is_zero())
  1410.     nn = new hmotion_node(saved_indent, nn);
  1411.   width += saved_indent;
  1412.   if (no_number_count > 0)
  1413.     --no_number_count;
  1414.   else if (numbering_nodes) {
  1415.     hunits w = (line_number_digit_width
  1416.         *(3+line_number_indent+number_text_separation));
  1417.     if (next_line_number % line_number_multiple != 0)
  1418.       nn = new hmotion_node(w, nn);
  1419.     else {
  1420.       hunits x = w;
  1421.       nn = new hmotion_node(number_text_separation*line_number_digit_width,
  1422.                 nn);
  1423.       x -= number_text_separation*line_number_digit_width;
  1424.       char buf[30];
  1425.       sprintf(buf, "%3d", next_line_number);
  1426.       for (char *p = strchr(buf, '\0') - 1; p >= buf && *p != ' '; --p) {
  1427.     node *gn = numbering_nodes;
  1428.     for (int count = *p - '0'; count > 0; count--)
  1429.       gn = gn->next;
  1430.     gn = gn->copy();
  1431.     x -= gn->width();
  1432.     gn->next = nn;
  1433.     nn = gn;
  1434.       }
  1435.       nn = new hmotion_node(x, nn);
  1436.     }
  1437.     width += w;
  1438.     ++next_line_number;
  1439.   }
  1440.   output(nn, !fill, vertical_spacing, line_spacing, width);
  1441. }
  1442.  
  1443. void environment::start_line()
  1444. {
  1445.   assert(line == 0);
  1446.   discarding = 0;
  1447.   line = new line_start_node;
  1448.   if (have_temporary_indent) {
  1449.     saved_indent = temporary_indent;
  1450.     have_temporary_indent = 0;
  1451.   }
  1452.   else
  1453.     saved_indent = indent;
  1454.   target_text_length = line_length - saved_indent;
  1455.   width_total = H0;
  1456.   space_total = 0;
  1457. }
  1458.  
  1459. hunits environment::get_hyphenation_space()
  1460. {
  1461.   return hyphenation_space;
  1462. }
  1463.  
  1464. void hyphenation_space_request()
  1465. {
  1466.   hunits n;
  1467.   if (get_hunits(&n, 'm')) {
  1468.     if (n < H0) {
  1469.       warning(WARN_RANGE, "hyphenation space cannot be negative");
  1470.       n = H0;
  1471.     }
  1472.     curenv->hyphenation_space = n;
  1473.   }
  1474.   skip_line();
  1475. }
  1476.  
  1477. hunits environment::get_hyphenation_margin()
  1478. {
  1479.   return hyphenation_margin;
  1480. }
  1481.  
  1482. void hyphenation_margin_request()
  1483. {
  1484.   hunits n;
  1485.   if (get_hunits(&n, 'm')) {
  1486.     if (n < H0) {
  1487.       warning(WARN_RANGE, "hyphenation margin cannot be negative");
  1488.       n = H0;
  1489.     }
  1490.     curenv->hyphenation_margin = n;
  1491.   }
  1492.   skip_line();
  1493. }
  1494.  
  1495. breakpoint *environment::choose_breakpoint()
  1496. {
  1497.   hunits x = width_total;
  1498.   int s = space_total;
  1499.   node *n = line;
  1500.   breakpoint *best_bp = 0;    // the best breakpoint so far
  1501.   int best_bp_fits = 0;
  1502.   while (n != 0) {
  1503.     x -= n->width();
  1504.     s -= n->nspaces();
  1505.     breakpoint *bp = n->get_breakpoints(x, s);
  1506.     while (bp != 0) {
  1507.       if (bp->width <= target_text_length) {
  1508.     if (!bp->hyphenated) {
  1509.       breakpoint *tem = bp->next;
  1510.       bp->next = 0;
  1511.       while (tem != 0) {
  1512.         breakpoint *tem1 = tem;
  1513.         tem = tem->next;
  1514.         delete tem1;
  1515.       }
  1516.       if (best_bp_fits
  1517.           // Decide whether to use the hyphenated breakpoint.
  1518.           && (hyphen_line_max < 0
  1519.           // Only choose the hyphenated breakpoint if it would not
  1520.           // exceed the maximum number of consecutive hyphenated
  1521.           // lines.
  1522.           || hyphen_line_count + 1 <= hyphen_line_max)
  1523.           && !(adjust_mode == ADJUST_BOTH
  1524.            // Don't choose the hyphenated breakpoint if the line
  1525.            // can be justified by adding no more than
  1526.            // hyphenation_space to any word space.
  1527.            ? (bp->nspaces > 0
  1528.               && (((target_text_length - bp->width
  1529.                 + (bp->nspaces - 1)*hresolution)/bp->nspaces)
  1530.               <= hyphenation_space))
  1531.            // Don't choose the hyphenated breakpoint if the line
  1532.            // is no more than hyphenation_margin short.
  1533.            : target_text_length - bp->width <= hyphenation_margin)) {
  1534.         delete bp;
  1535.         return best_bp;
  1536.       }
  1537.       if (best_bp)
  1538.         delete best_bp;
  1539.       return bp;
  1540.     }
  1541.     else {
  1542.       if ((adjust_mode == ADJUST_BOTH
  1543.            ? hyphenation_space == H0
  1544.            : hyphenation_margin == H0)
  1545.           && (hyphen_line_max < 0
  1546.           || hyphen_line_count + 1 <= hyphen_line_max)) {
  1547.         // No need to consider a non-hyphenated breakpoint.
  1548.         if (best_bp)
  1549.           delete best_bp;
  1550.         return bp;
  1551.       }
  1552.       // It fits but it's hyphenated.
  1553.       if (!best_bp_fits) {
  1554.         if (best_bp)
  1555.           delete best_bp;
  1556.         best_bp = bp;
  1557.         bp = bp->next;
  1558.         best_bp_fits = 1;
  1559.       }
  1560.       else {
  1561.         breakpoint *tem = bp;
  1562.         bp = bp->next;
  1563.         delete tem;
  1564.       }
  1565.     }
  1566.       }
  1567.       else {
  1568.     if (best_bp)
  1569.       delete best_bp;
  1570.     best_bp = bp;
  1571.     bp = bp->next;
  1572.       }
  1573.     }
  1574.     n = n->next;
  1575.   }
  1576.   if (best_bp) {
  1577.     if (!best_bp_fits)
  1578.       warning(WARN_BREAK, "can't break line");
  1579.     return best_bp;
  1580.   }
  1581.   return 0;
  1582. }
  1583.  
  1584. void environment::hyphenate_line()
  1585. {
  1586.   if (line == 0)
  1587.     return;
  1588.   hyphenation_type prev_type = line->get_hyphenation_type();
  1589.   for (node **startp = &line->next; *startp != 0; startp = &(*startp)->next) {
  1590.     hyphenation_type this_type = (*startp)->get_hyphenation_type();
  1591.     if (prev_type == HYPHEN_BOUNDARY && this_type == HYPHEN_MIDDLE)
  1592.       break;
  1593.     prev_type = this_type;
  1594.   }
  1595.   if (*startp == 0)
  1596.     return;
  1597.   node *tem = *startp;
  1598.   int i = 0;
  1599.   do {
  1600.     ++i;
  1601.     tem = tem->next;
  1602.   } while (tem != 0 && tem->get_hyphenation_type() == HYPHEN_MIDDLE);
  1603.   int inhibit = (tem != 0 && tem->get_hyphenation_type() == HYPHEN_INHIBIT);
  1604.   node *end = tem;
  1605.   hyphen_list *sl = 0;
  1606.   tem = *startp;
  1607.   node *forward = 0;
  1608.   while (tem != end) {
  1609.     sl = tem->get_hyphen_list(sl);
  1610.     node *tem1 = tem;
  1611.     tem = tem->next;
  1612.     tem1->next = forward;
  1613.     forward = tem1;
  1614.   }
  1615.   if (!inhibit) {
  1616.     // this is for characters like hyphen and emdash
  1617.     int prev_code = 0;
  1618.     for (hyphen_list *h = sl; h; h = h->next) {
  1619.       h->breakable = (prev_code != 0
  1620.               && h->next != 0
  1621.               && h->next->hyphenation_code != 0);
  1622.       prev_code = h->hyphenation_code;
  1623.     }
  1624.   }
  1625.   if (hyphenation_flags != 0
  1626.       && !inhibit
  1627.       // this may not be right if we have extra space on this line
  1628.       && !((hyphenation_flags & HYPHEN_LAST_LINE)
  1629.        && curdiv->distance_to_next_trap() <= line_spacing*vertical_spacing)
  1630.       && i >= 4)
  1631.     hyphenate(sl, hyphenation_flags);
  1632.   while (forward != 0) {
  1633.     node *tem1 = forward;
  1634.     forward = forward->next;
  1635.     tem1->next = 0;
  1636.     tem = tem1->add_self(tem, &sl);
  1637.   }
  1638.   *startp = tem;
  1639. }
  1640.  
  1641. static node *node_list_reverse(node *n)
  1642. {
  1643.   node *res = 0;
  1644.   while (n) {
  1645.     node *tem = n;
  1646.     n = n->next;
  1647.     tem->next = res;
  1648.     res = tem;
  1649.   }
  1650.   return res;
  1651. }
  1652.  
  1653. static void distribute_space(node *n, int nspaces, hunits desired_space,
  1654.                  int force_reverse = 0)
  1655. {
  1656.   static int reverse = 0;
  1657.   if (force_reverse || reverse)
  1658.     n = node_list_reverse(n);
  1659.   for (node *tem = n; tem; tem = tem->next)
  1660.     tem->spread_space(&nspaces, &desired_space);
  1661.   if (force_reverse || reverse)
  1662.     (void)node_list_reverse(n);
  1663.   if (!force_reverse)
  1664.     reverse = !reverse;
  1665.   assert(desired_space.is_zero() && nspaces == 0);
  1666. }
  1667.  
  1668. void environment::possibly_break_line(int forced)
  1669. {
  1670.   if (!fill || current_tab || current_field || dummy)
  1671.     return;
  1672.   while (line != 0 && (forced || width_total > target_text_length)) {
  1673.     hyphenate_line();
  1674.     breakpoint *bp = choose_breakpoint();
  1675.     if (bp == 0)
  1676.       // we'll find one eventually
  1677.       return;
  1678.     node *pre, *post;
  1679.     node **ndp = &line;
  1680.     while (*ndp != bp->nd)
  1681.       ndp = &(*ndp)->next;
  1682.     bp->nd->split(bp->index, &pre, &post);
  1683.     *ndp = post;
  1684.     hunits extra_space_width = H0;
  1685.     switch(adjust_mode) {
  1686.     case ADJUST_BOTH:
  1687.       if (bp->nspaces != 0)
  1688.     extra_space_width = target_text_length - bp->width;
  1689.       break;
  1690.     case ADJUST_CENTER:
  1691.       saved_indent += (target_text_length - bp->width)/2;
  1692.       break;
  1693.     case ADJUST_RIGHT:
  1694.       saved_indent += target_text_length - bp->width;
  1695.       break;
  1696.     }
  1697.     distribute_space(pre, bp->nspaces, extra_space_width);
  1698.     hunits output_width = bp->width + extra_space_width;
  1699.     input_line_start -= output_width;
  1700.     if (bp->hyphenated)
  1701.       hyphen_line_count++;
  1702.     else
  1703.       hyphen_line_count = 0;
  1704.     delete bp;
  1705.     space_total = 0;
  1706.     width_total = 0;
  1707.     node *first_non_discardable = 0;
  1708.     for (node *tem = line; tem != 0; tem = tem->next)
  1709.       if (!tem->discardable())
  1710.     first_non_discardable = tem;
  1711.     node *to_be_discarded;
  1712.     if (first_non_discardable) {
  1713.       to_be_discarded = first_non_discardable->next;
  1714.       first_non_discardable->next = 0;
  1715.       for (tem = line; tem != 0; tem = tem->next) {
  1716.     width_total += tem->width();
  1717.     space_total += tem->nspaces();
  1718.       }
  1719.       discarding = 0;
  1720.     }
  1721.     else {
  1722.       discarding = 1;
  1723.       to_be_discarded = line;
  1724.       line = 0;
  1725.     }
  1726.     // Do output_line() here so that line will be 0 iff the
  1727.     // the environment will be empty.
  1728.     output_line(pre, output_width);
  1729.     while (to_be_discarded != 0) {
  1730.       tem = to_be_discarded;
  1731.       to_be_discarded = to_be_discarded->next;
  1732.       input_line_start -= tem->width();
  1733.       delete tem;
  1734.     }
  1735.     if (line != 0) {
  1736.       if (have_temporary_indent) {
  1737.     saved_indent = temporary_indent;
  1738.     have_temporary_indent = 0;
  1739.       }
  1740.       else
  1741.     saved_indent = indent;
  1742.       target_text_length = line_length - saved_indent;
  1743.     }
  1744.   }
  1745. }
  1746.  
  1747. /*
  1748. Do the break at the end of input after the end macro (if any).
  1749.  
  1750. Unix troff behaves as follows:  if the last line is
  1751.  
  1752. foo bar\c
  1753.  
  1754. it will output foo on the current page, and bar on the next page;
  1755. if the last line is
  1756.  
  1757. foo\c
  1758.  
  1759. or
  1760.  
  1761. foo bar
  1762.  
  1763. everything will be output on the current page.  This behaviour must be
  1764. considered a bug.
  1765.  
  1766. The problem is that some macro packages rely on this.  For example,
  1767. the ATK macros have an end macro that emits \c if it needs to print a
  1768. table of contents but doesn't do a 'bp in the end macro; instead the
  1769. 'bp is done in the bottom of page trap.  This works with Unix troff,
  1770. provided that the current environment is not empty at the end of the
  1771. input file.
  1772.  
  1773. The following will make macro packages that do that sort of thing work
  1774. even if the current environment is empty at the end of the input file.
  1775. If the last input line used \c and this line occurred in the end macro,
  1776. then we'll force everything out on the current page, but we'll make
  1777. sure that the environment isn't empty so that we won't exit at the
  1778. bottom of this page.
  1779. */
  1780.  
  1781. void environment::final_break()
  1782. {
  1783.   if (prev_line_interrupted == 2) {
  1784.     do_break();
  1785.     add_node(new transparent_dummy_node);
  1786.   }
  1787.   else
  1788.     do_break();
  1789. }
  1790.  
  1791. void environment::do_break()
  1792. {
  1793.   if (curdiv == topdiv && topdiv->before_first_page) {
  1794.     topdiv->begin_page();
  1795.     return;
  1796.   }
  1797.   if (current_tab)
  1798.     wrap_up_tab();
  1799.   if (line) {
  1800.     line = new space_node(H0, line); // this is so that hyphenation works
  1801.     space_total++;
  1802.     possibly_break_line();
  1803.   }
  1804.   while (line != 0 && line->discardable()) {
  1805.     width_total -= line->width();
  1806.     space_total -= line->nspaces();
  1807.     node *tem = line;
  1808.     line = line->next;
  1809.     delete tem;
  1810.   }
  1811.   discarding = 0;
  1812.   input_line_start = H0;
  1813.   if (line != 0) {
  1814.     if (fill) {
  1815.       switch (adjust_mode) {
  1816.       case ADJUST_CENTER:
  1817.     saved_indent += (target_text_length - width_total)/2;
  1818.     break;
  1819.       case ADJUST_RIGHT:
  1820.     saved_indent += target_text_length - width_total;
  1821.     break;
  1822.       }
  1823.     }
  1824.     node *tem = line;
  1825.     line = 0;
  1826.     output_line(tem, width_total);
  1827.     hyphen_line_count = 0;
  1828.   }
  1829.   prev_line_interrupted = 0;
  1830. #ifdef WIDOW_CONTROL
  1831.   mark_last_line();
  1832.   output_pending_lines();
  1833. #endif /* WIDOW_CONTROL */
  1834. }
  1835.  
  1836. int environment::is_empty()
  1837. {
  1838.   return !current_tab && line == 0 && pending_lines == 0;
  1839. }
  1840.  
  1841. void break_request()
  1842. {
  1843.   while (!tok.newline() && !tok.eof())
  1844.     tok.next();
  1845.   if (break_flag)
  1846.     curenv->do_break();
  1847.   tok.next();
  1848. }
  1849.  
  1850. void title()
  1851. {
  1852.   if (curdiv == topdiv && topdiv->before_first_page) {
  1853.     handle_initial_title();
  1854.     return;
  1855.   }
  1856.   node *part[3];
  1857.   hunits part_width[3];
  1858.   part[0] = part[1] = part[2] = 0;
  1859.   environment env(curenv);
  1860.   environment *oldenv = curenv;
  1861.   curenv = &env;
  1862.   read_title_parts(part, part_width);
  1863.   curenv = oldenv;
  1864.   curenv->size = env.size;
  1865.   curenv->prev_size = env.prev_size;
  1866.   curenv->requested_size = env.requested_size;
  1867.   curenv->prev_requested_size = env.prev_requested_size;
  1868.   curenv->char_height = env.char_height;
  1869.   curenv->char_slant = env.char_slant;
  1870.   curenv->fontno = env.fontno;
  1871.   curenv->prev_fontno = env.prev_fontno;
  1872.   node *n = 0;
  1873.   node *p = part[2];
  1874.   while (p != 0) {
  1875.     node *tem = p;
  1876.     p = p->next;
  1877.     tem->next = n;
  1878.     n = tem;
  1879.   }
  1880.   hunits title_length(curenv->title_length);
  1881.   hunits f = title_length - part_width[1];
  1882.   hunits f2 = f/2;
  1883.   n = new hmotion_node(f2 - part_width[2], n);
  1884.   p = part[1];
  1885.   while (p != 0) {
  1886.     node *tem = p;
  1887.     p = p->next;
  1888.     tem->next = n;
  1889.     n = tem;
  1890.   }
  1891.   n = new hmotion_node(f - f2 - part_width[0], n);
  1892.   p = part[0];
  1893.   while (p != 0) {
  1894.     node *tem = p;
  1895.     p = p->next;
  1896.     tem->next = n;
  1897.     n = tem;
  1898.   }
  1899.   curenv->output_title(n, !curenv->fill, curenv->vertical_spacing,
  1900.                curenv->line_spacing, title_length);
  1901.   curenv->hyphen_line_count = 0;
  1902.   tok.next();
  1903. }  
  1904.  
  1905. void adjust()
  1906. {
  1907.   curenv->adjust_mode |= 1;
  1908.   if (has_arg()) {
  1909.     switch (tok.ch()) {
  1910.     case 'l':
  1911.       curenv->adjust_mode = ADJUST_LEFT;
  1912.       break;
  1913.     case 'r':
  1914.       curenv->adjust_mode = ADJUST_RIGHT;
  1915.       break;
  1916.     case 'c':
  1917.       curenv->adjust_mode = ADJUST_CENTER;
  1918.       break;
  1919.     case 'b':
  1920.     case 'n':
  1921.       curenv->adjust_mode = ADJUST_BOTH;
  1922.       break;
  1923.     default:
  1924.       int n;
  1925.       if (get_integer(&n)) {
  1926.     if (n < 0)
  1927.       warning(WARN_RANGE, "negative adjustment mode");
  1928.     else if (n > 5) {
  1929.       curenv->adjust_mode = 5;
  1930.       warning(WARN_RANGE, "adjustment mode `%1' out of range", n);
  1931.     }
  1932.     else
  1933.       curenv->adjust_mode = n;
  1934.       }
  1935.     }
  1936.   }
  1937.   skip_line();
  1938. }
  1939.  
  1940. void no_adjust()
  1941. {
  1942.   curenv->adjust_mode &= ~1;
  1943.   skip_line();
  1944. }
  1945.  
  1946. void input_trap()
  1947. {
  1948.   curenv->input_trap_count = 0;
  1949.   int n;
  1950.   if (has_arg() && get_integer(&n)) {
  1951.     if (n <= 0)
  1952.       warning(WARN_RANGE,
  1953.           "number of lines for input trap must be greater than zero");
  1954.     else {
  1955.       symbol s = get_name(1);
  1956.       if (!s.is_null()) {
  1957.     curenv->input_trap_count = n;
  1958.     curenv->input_trap = s;
  1959.       }
  1960.     }
  1961.   }
  1962.   skip_line();
  1963. }
  1964.  
  1965. /* tabs */
  1966.  
  1967. // must not be R or C or L or a legitimate part of a number expression
  1968. const char TAB_REPEAT_CHAR = 'T';
  1969.  
  1970. struct tab {
  1971.   tab *next;
  1972.   hunits pos;
  1973.   tab_type type;
  1974.   tab(hunits, tab_type);
  1975.   enum { BLOCK = 1024 };
  1976.   static tab *free_list;
  1977.   void *operator new(size_t);
  1978.   void operator delete(void *);
  1979. };
  1980.  
  1981. tab *tab::free_list = 0;
  1982.  
  1983. void *tab::operator new(size_t n)
  1984. {
  1985.   assert(n == sizeof(tab));
  1986.   if (!free_list) {
  1987.     free_list = (tab *)new char[sizeof(tab)*BLOCK];
  1988.     for (int i = 0; i < BLOCK - 1; i++)
  1989.       free_list[i].next = free_list + i + 1;
  1990.     free_list[BLOCK-1].next = 0;
  1991.   }
  1992.   tab *p = free_list;
  1993.   free_list = (tab *)(free_list->next);
  1994.   p->next = 0;
  1995.   return p;
  1996. }
  1997.  
  1998. #ifdef __GNUG__
  1999. /* cfront can't cope with this. */
  2000. inline
  2001. #endif
  2002. void tab::operator delete(void *p)
  2003. {
  2004.   if (p) {
  2005.     ((tab *)p)->next = free_list;
  2006.     free_list = (tab *)p;
  2007.   }
  2008. }
  2009.  
  2010. tab::tab(hunits x, tab_type t) : next(0), pos(x), type(t)
  2011. {
  2012. }
  2013.  
  2014. tab_stops::tab_stops(hunits distance, tab_type type) 
  2015.      : initial_list(0)
  2016. {
  2017.   repeated_list = new tab(distance, type);
  2018. }
  2019.  
  2020. tab_stops::~tab_stops()
  2021. {
  2022.   clear();
  2023. }
  2024.  
  2025. tab_type tab_stops::distance_to_next_tab(hunits curpos, hunits *distance)
  2026. {
  2027.   hunits lastpos = 0;
  2028.   for (tab *tem = initial_list; tem && tem->pos <= curpos; tem = tem->next)
  2029.     lastpos = tem->pos;
  2030.   if (tem) {
  2031.     *distance = tem->pos - curpos;
  2032.     return tem->type;
  2033.   }
  2034.   if (repeated_list == 0)
  2035.     return TAB_NONE;
  2036.   hunits base = lastpos;
  2037.   for (;;) {
  2038.     for (tem = repeated_list; tem && tem->pos + base <= curpos; tem = tem->next)
  2039.       lastpos = tem->pos;
  2040.     if (tem) {
  2041.       *distance = tem->pos + base - curpos;
  2042.       return tem->type;
  2043.     }
  2044.     assert(lastpos > 0);
  2045.     base += lastpos;
  2046.   }
  2047.   return TAB_NONE;
  2048. }
  2049.  
  2050. const char *tab_stops::to_string()
  2051. {
  2052.   static char *buf = 0;
  2053.   static int buf_size = 0;
  2054.   // figure out a maximum on the amount of space we can need
  2055.   int count = 0;
  2056.   for (tab *p = initial_list; p; p = p->next)
  2057.     ++count;
  2058.   for (p = repeated_list; p; p = p->next)
  2059.     ++count;
  2060.   // (10 for digits + 1 for u + 1 for 'C' or 'R') + 2 for ' &' + 1 for '\0'
  2061.   int need = count*12 + 3;
  2062.   if (buf == 0 || need > buf_size) {
  2063.     if (buf)
  2064.       a_delete buf;
  2065.     buf_size = need;
  2066.     buf = new char[buf_size];
  2067.   }
  2068.   char *ptr = buf;
  2069.   for (p = initial_list; p; p = p->next) {
  2070.     strcpy(ptr, itoa(p->pos.to_units()));
  2071.     ptr = strchr(ptr, '\0');
  2072.     *ptr++ = 'u';
  2073.     *ptr = '\0';
  2074.     switch (p->type) {
  2075.     case TAB_LEFT:
  2076.       break;
  2077.     case TAB_RIGHT:
  2078.       *ptr++ = 'R';
  2079.       break;
  2080.     case TAB_CENTER:
  2081.       *ptr++ = 'C';
  2082.       break;
  2083.     case TAB_NONE:
  2084.     default:
  2085.       assert(0);
  2086.     }
  2087.   }
  2088.   if (repeated_list)
  2089.     *ptr++ = TAB_REPEAT_CHAR;
  2090.   for (p = repeated_list; p; p = p->next) {
  2091.     strcpy(ptr, itoa(p->pos.to_units()));
  2092.     ptr = strchr(ptr, '\0');
  2093.     *ptr++ = 'u';
  2094.     *ptr = '\0';
  2095.     switch (p->type) {
  2096.     case TAB_LEFT:
  2097.       break;
  2098.     case TAB_RIGHT:
  2099.       *ptr++ = 'R';
  2100.       break;
  2101.     case TAB_CENTER:
  2102.       *ptr++ = 'C';
  2103.       break;
  2104.     case TAB_NONE:
  2105.     default:
  2106.       assert(0);
  2107.     }
  2108.   }
  2109.   *ptr++ = '\0';
  2110.   return buf;
  2111. }
  2112.  
  2113. tab_stops::tab_stops() : initial_list(0), repeated_list(0)
  2114. {
  2115. }
  2116.  
  2117. tab_stops::tab_stops(const tab_stops &ts) 
  2118.      : initial_list(0), repeated_list(0)
  2119. {
  2120.   tab **p = &initial_list;
  2121.   tab *t = ts.initial_list;
  2122.   while (t) {
  2123.     *p = new tab(t->pos, t->type);
  2124.     t = t->next;
  2125.     p = &(*p)->next;
  2126.   }
  2127.   p = &repeated_list;
  2128.   t = ts.repeated_list;
  2129.   while (t) {
  2130.     *p = new tab(t->pos, t->type);
  2131.     t = t->next;
  2132.     p = &(*p)->next;
  2133.   }
  2134. }
  2135.  
  2136. void tab_stops::clear()
  2137. {
  2138.   while (initial_list) {
  2139.     tab *tem = initial_list;
  2140.     initial_list = initial_list->next;
  2141.     delete tem;
  2142.   }
  2143.   while (repeated_list) {
  2144.     tab *tem = repeated_list;
  2145.     repeated_list = repeated_list->next;
  2146.     delete tem;
  2147.   }
  2148. }
  2149.  
  2150. void tab_stops::add_tab(hunits pos, tab_type type, int repeated)
  2151. {
  2152.   for (tab **p = repeated ? &repeated_list : &initial_list; *p; p = &(*p)->next)
  2153.     ;
  2154.   *p = new tab(pos, type);
  2155. }
  2156.  
  2157.  
  2158. void tab_stops::operator=(const tab_stops &ts)
  2159. {
  2160.   clear();
  2161.   tab **p = &initial_list;
  2162.   tab *t = ts.initial_list;
  2163.   while (t) {
  2164.     *p = new tab(t->pos, t->type);
  2165.     t = t->next;
  2166.     p = &(*p)->next;
  2167.   }
  2168.   p = &repeated_list;
  2169.   t = ts.repeated_list;
  2170.   while (t) {
  2171.     *p = new tab(t->pos, t->type);
  2172.     t = t->next;
  2173.     p = &(*p)->next;
  2174.   }
  2175. }
  2176.     
  2177. void set_tabs()
  2178. {
  2179.   hunits pos;
  2180.   hunits prev_pos = 0;
  2181.   int first = 1;
  2182.   int repeated = 0;
  2183.   tab_stops tabs;
  2184.   while (has_arg()) {
  2185.     if (tok.ch() == TAB_REPEAT_CHAR) {
  2186.       tok.next();
  2187.       repeated = 1;
  2188.       prev_pos = 0;
  2189.     }
  2190.     if (!get_hunits(&pos, 'm', prev_pos))
  2191.       break;
  2192.     tab_type type = TAB_LEFT;
  2193.     if (tok.ch() == 'C') {
  2194.       tok.next();
  2195.       type = TAB_CENTER;
  2196.     }
  2197.     else if (tok.ch() == 'R') {
  2198.       tok.next();
  2199.       type = TAB_RIGHT;
  2200.     }
  2201.     else if (tok.ch() == 'L') {
  2202.       tok.next();
  2203.     }
  2204.     if (pos <= prev_pos && !first)
  2205.       warning(WARN_RANGE,
  2206.           "positions of tab stops must be strictly increasing");
  2207.     else {
  2208.       tabs.add_tab(pos, type, repeated);
  2209.       prev_pos = pos;
  2210.       first = 0;
  2211.     }
  2212.   }
  2213.   curenv->tabs = tabs;
  2214.   skip_line();
  2215. }
  2216.  
  2217. const char *environment::get_tabs()
  2218. {
  2219.   return tabs.to_string();
  2220. }
  2221.  
  2222. #if 0
  2223. tab_stops saved_tabs;
  2224.  
  2225. void tabs_save()
  2226. {
  2227.   saved_tabs = curenv->tabs;
  2228.   skip_line();
  2229. }
  2230.  
  2231. void tabs_restore()
  2232. {
  2233.   curenv->tabs = saved_tabs;
  2234.   skip_line();
  2235. }
  2236. #endif
  2237.  
  2238. tab_type environment::distance_to_next_tab(hunits *distance)
  2239. {
  2240.   return curenv->tabs.distance_to_next_tab(get_input_line_position(), distance);
  2241. }
  2242.  
  2243. void field_characters()
  2244. {
  2245.   field_delimiter_char = get_optional_char();
  2246.   if (field_delimiter_char)
  2247.     padding_indicator_char = get_optional_char();
  2248.   else
  2249.     padding_indicator_char = 0;
  2250.   skip_line();
  2251. }
  2252.  
  2253. void environment::wrap_up_tab()
  2254. {
  2255.   if (!current_tab)
  2256.     return;
  2257.   if (line == 0)
  2258.     start_line();
  2259.   hunits tab_amount;
  2260.   switch (current_tab) {
  2261.   case TAB_RIGHT:
  2262.     tab_amount = tab_distance - tab_width;
  2263.     line = make_tab_node(tab_amount, line);
  2264.     break;
  2265.   case TAB_CENTER:
  2266.     tab_amount = tab_distance - tab_width/2;
  2267.     line = make_tab_node(tab_amount, line);
  2268.     break;
  2269.   case TAB_NONE:
  2270.   case TAB_LEFT:
  2271.   default:
  2272.     assert(0);
  2273.   }
  2274.   width_total += tab_amount;
  2275.   width_total += tab_width;
  2276.   if (current_field) {
  2277.     if (tab_precedes_field) {
  2278.       pre_field_width += tab_amount;
  2279.       tab_precedes_field = 0;
  2280.     }
  2281.     field_distance -= tab_amount;
  2282.     field_spaces += tab_field_spaces;
  2283.   }
  2284.   if (tab_contents != 0) {
  2285.     for (node *tem = tab_contents; tem->next != 0; tem = tem->next)
  2286.       ;
  2287.     tem->next = line;
  2288.     line = tab_contents;
  2289.   }
  2290.   tab_field_spaces = 0;
  2291.   tab_contents = 0;
  2292.   tab_width =  H0;
  2293.   tab_distance = H0;
  2294.   current_tab = TAB_NONE;
  2295. }
  2296.  
  2297. node *environment::make_tab_node(hunits d, node *next)
  2298. {
  2299.   if (leader_node != 0 && d < 0) {
  2300.     error("motion generated by leader cannot be negative");
  2301.     delete leader_node;
  2302.     leader_node = 0;
  2303.   }
  2304.   if (!leader_node)
  2305.     return new hmotion_node(d, next);
  2306.   node *n = new hline_node(d, leader_node, next);
  2307.   leader_node = 0;
  2308.   return n;
  2309. }
  2310.  
  2311. void environment::handle_tab(int is_leader)
  2312. {
  2313.   hunits d;
  2314.   if (current_tab)
  2315.     wrap_up_tab();
  2316.   charinfo *ci = is_leader ? leader_char : tab_char;
  2317.   delete leader_node;
  2318.   leader_node = ci ? make_char_node(ci) : 0;
  2319.   tab_type t = distance_to_next_tab(&d);
  2320.   switch (t) {
  2321.   case TAB_NONE:
  2322.     return;
  2323.   case TAB_LEFT:
  2324.     add_node(make_tab_node(d));
  2325.     return;
  2326.   case TAB_RIGHT:
  2327.   case TAB_CENTER:
  2328.     tab_width = 0;
  2329.     tab_distance = d;
  2330.     tab_contents = 0;
  2331.     current_tab = t;
  2332.     tab_field_spaces = 0;
  2333.     return;
  2334.   default:
  2335.     assert(0);
  2336.   }
  2337. }
  2338.  
  2339. void environment::start_field()
  2340. {
  2341.   assert(!current_field);
  2342.   hunits d;
  2343.   if (distance_to_next_tab(&d) != TAB_NONE) {
  2344.     pre_field_width = get_text_length();
  2345.     field_distance = d;
  2346.     current_field = 1;
  2347.     field_spaces = 0;
  2348.     tab_field_spaces = 0;
  2349.     for (node *p = line; p; p = p->next)
  2350.       if (p->nspaces()) {
  2351.     p->freeze_space();
  2352.     space_total--;
  2353.       }
  2354.     tab_precedes_field = current_tab != TAB_NONE;
  2355.   }
  2356.   else
  2357.     error("zero field width");
  2358. }
  2359.  
  2360. void environment::wrap_up_field()
  2361. {
  2362.   if (!current_tab && field_spaces == 0)
  2363.     add_padding();
  2364.   hunits padding = field_distance - (get_text_length() - pre_field_width);
  2365.   if (current_tab && tab_field_spaces != 0) {
  2366.     hunits tab_padding = scale(padding, 
  2367.                    tab_field_spaces, 
  2368.                    field_spaces + tab_field_spaces);
  2369.     padding -= tab_padding;
  2370.     distribute_space(tab_contents, tab_field_spaces, tab_padding, 1);
  2371.     tab_field_spaces = 0;
  2372.     tab_width += tab_padding;
  2373.   }
  2374.   if (field_spaces != 0) {
  2375.     distribute_space(line, field_spaces, padding, 1);
  2376.     width_total += padding;
  2377.     if (current_tab) {
  2378.       // the start of the tab has been moved to the right by padding, so
  2379.       tab_distance -= padding;
  2380.       if (tab_distance <= H0) {
  2381.     // use the next tab stop instead
  2382.     current_tab = tabs.distance_to_next_tab(get_input_line_position()
  2383.                         - tab_width,
  2384.                         &tab_distance);
  2385.     if (current_tab == TAB_NONE || current_tab == TAB_LEFT) {
  2386.       width_total += tab_width;
  2387.       if (current_tab == TAB_LEFT) {
  2388.         line = make_tab_node(tab_distance, line);
  2389.         width_total += tab_distance;
  2390.         current_tab = TAB_NONE;
  2391.       }
  2392.       if (tab_contents != 0) {
  2393.         for (node *tem = tab_contents; tem->next != 0; tem = tem->next)
  2394.           ;
  2395.         tem->next = line;
  2396.         line = tab_contents;
  2397.         tab_contents = 0;
  2398.       }
  2399.       tab_width = H0;
  2400.       tab_distance = H0;
  2401.     }
  2402.       }
  2403.     }
  2404.   }
  2405.   current_field = 0;
  2406. }
  2407.  
  2408. void environment::add_padding()
  2409. {
  2410.   if (current_tab) {
  2411.     tab_contents = new space_node(H0, tab_contents);
  2412.     tab_field_spaces++;
  2413.   }
  2414.   else {
  2415.     if (line == 0)
  2416.       start_line();
  2417.     line = new space_node(H0, line);
  2418.     field_spaces++;
  2419.   }
  2420. }
  2421.  
  2422. typedef int (environment::*INT_FUNCP)();
  2423. typedef vunits (environment::*VUNITS_FUNCP)();
  2424. typedef hunits (environment::*HUNITS_FUNCP)();
  2425. typedef const char *(environment::*STRING_FUNCP)();
  2426.  
  2427. class int_env_reg : public reg {
  2428.   INT_FUNCP func;
  2429.  public:
  2430.   int_env_reg(INT_FUNCP);
  2431.   const char *get_string();
  2432.   int get_value(units *val);
  2433. };
  2434.  
  2435. class vunits_env_reg : public reg {
  2436.   VUNITS_FUNCP func;
  2437.  public:
  2438.   vunits_env_reg(VUNITS_FUNCP f);
  2439.   const char *get_string();
  2440.   int get_value(units *val);
  2441. };
  2442.  
  2443.  
  2444. class hunits_env_reg : public reg {
  2445.   HUNITS_FUNCP func;
  2446.  public:
  2447.   hunits_env_reg(HUNITS_FUNCP f);
  2448.   const char *get_string();
  2449.   int get_value(units *val);
  2450. };
  2451.  
  2452. class string_env_reg : public reg {
  2453.   STRING_FUNCP func;
  2454. public:
  2455.   string_env_reg(STRING_FUNCP);
  2456.   const char *get_string();
  2457. };
  2458.  
  2459. int_env_reg::int_env_reg(INT_FUNCP f) : func(f)
  2460. {
  2461. }
  2462.  
  2463. int int_env_reg::get_value(units *val)
  2464. {
  2465.   *val = (curenv->*func)();
  2466.   return 1;
  2467. }
  2468.  
  2469. const char *int_env_reg::get_string()
  2470. {
  2471.   return itoa((curenv->*func)());
  2472. }
  2473.  
  2474. vunits_env_reg::vunits_env_reg(VUNITS_FUNCP f) : func(f)
  2475. {
  2476. }
  2477.  
  2478. int vunits_env_reg::get_value(units *val)
  2479. {
  2480.   *val = (curenv->*func)().to_units();
  2481.   return 1;
  2482. }
  2483.  
  2484. const char *vunits_env_reg::get_string()
  2485. {
  2486.   return itoa((curenv->*func)().to_units());
  2487. }
  2488.  
  2489. hunits_env_reg::hunits_env_reg(HUNITS_FUNCP f) : func(f)
  2490. {
  2491. }
  2492.  
  2493. int hunits_env_reg::get_value(units *val)
  2494. {
  2495.   *val = (curenv->*func)().to_units();
  2496.   return 1;
  2497. }
  2498.  
  2499. const char *hunits_env_reg::get_string()
  2500. {
  2501.   return itoa((curenv->*func)().to_units());
  2502. }
  2503.  
  2504. string_env_reg::string_env_reg(STRING_FUNCP f) : func(f)
  2505. {
  2506. }
  2507.  
  2508. const char *string_env_reg::get_string()
  2509. {
  2510.   return (curenv->*func)();
  2511. }
  2512.  
  2513. class horizontal_place_reg : public general_reg {
  2514. public:
  2515.   horizontal_place_reg();
  2516.   int get_value(units *);
  2517.   void set_value(units);
  2518. };
  2519.  
  2520. horizontal_place_reg::horizontal_place_reg()
  2521. {
  2522. }
  2523.  
  2524. int horizontal_place_reg::get_value(units *res)
  2525. {
  2526.   *res = curenv->get_input_line_position().to_units();
  2527.   return 1;
  2528. }
  2529.  
  2530. void horizontal_place_reg::set_value(units n)
  2531. {
  2532.   curenv->set_input_line_position(hunits(n));
  2533. }
  2534.  
  2535. const char *environment::get_font_family_string()
  2536. {
  2537.   return family->nm.contents();
  2538. }
  2539.  
  2540. const char *environment::get_name_string()
  2541. {
  2542.   return name.contents();
  2543. }
  2544.  
  2545. // Convert a quantity in scaled points to ascii decimal fraction.
  2546.  
  2547. const char *sptoa(int sp)
  2548. {
  2549.   assert(sp > 0);
  2550.   assert(sizescale > 0);
  2551.   if (sizescale == 1)
  2552.     return itoa(sp);
  2553.   if (sp % sizescale == 0)
  2554.     return itoa(sp/sizescale);
  2555.   // See if 1/sizescale is exactly representable as a decimal fraction,
  2556.   // ie its only prime factors are 2 and 5.
  2557.   int n = sizescale;
  2558.   int power2 = 0;
  2559.   while ((n & 1) == 0) {
  2560.     n >>= 1;
  2561.     power2++;
  2562.   }
  2563.   int power5 = 0;
  2564.   while ((n % 5) == 0) {
  2565.     n /= 5;
  2566.     power5++;
  2567.   }
  2568.   if (n == 1) {
  2569.     int decimal_point = power5 > power2 ? power5 : power2;
  2570.     if (decimal_point <= 10) {
  2571.       int factor = 1;
  2572.       int t;
  2573.       for (t = decimal_point - power2; --t >= 0;)
  2574.     factor *= 2;
  2575.       for (t = decimal_point - power5; --t >= 0;)
  2576.     factor *= 5;
  2577.       if (factor == 1 || sp <= INT_MAX/factor)
  2578.     return iftoa(sp*factor, decimal_point);
  2579.     }
  2580.   }
  2581.   double s = double(sp)/double(sizescale);
  2582.   double factor = 10.0;
  2583.   double val = s;
  2584.   int decimal_point = 0;
  2585.   do  {
  2586.     double v = ceil(s*factor);
  2587.     if (v > INT_MAX)
  2588.       break;
  2589.     val = v;
  2590.     factor *= 10.0;
  2591.   } while (++decimal_point < 10);
  2592.   return iftoa(int(val), decimal_point);
  2593. }
  2594.  
  2595. const char *environment::get_point_size_string()
  2596. {
  2597.   return sptoa(curenv->get_point_size());
  2598. }
  2599.  
  2600. const char *environment::get_requested_point_size_string()
  2601. {
  2602.   return sptoa(curenv->get_requested_point_size());
  2603. }
  2604.  
  2605. #define init_int_env_reg(name, func) \
  2606.   number_reg_dictionary.define(name, new int_env_reg(&environment::func))
  2607.  
  2608. #define init_vunits_env_reg(name, func) \
  2609.   number_reg_dictionary.define(name, new vunits_env_reg(&environment::func))
  2610.  
  2611. #define init_hunits_env_reg(name, func) \
  2612.   number_reg_dictionary.define(name, new hunits_env_reg(&environment::func))
  2613.  
  2614. #define init_string_env_reg(name, func) \
  2615.   number_reg_dictionary.define(name, new string_env_reg(&environment::func))
  2616.  
  2617. void init_env_requests()
  2618. {
  2619.   init_request("it", input_trap);
  2620.   init_request("ad", adjust);
  2621.   init_request("na", no_adjust);
  2622.   init_request("ev", environment_switch);
  2623.   init_request("lt", title_length);
  2624.   init_request("ps", point_size);
  2625.   init_request("ft", font_change);
  2626.   init_request("fam", family_change);
  2627.   init_request("ss", space_size);
  2628.   init_request("fi", fill);
  2629.   init_request("nf", no_fill);
  2630.   init_request("ce", center);
  2631.   init_request("rj", right_justify);
  2632.   init_request("vs", vertical_spacing);
  2633.   init_request("ls", line_spacing);
  2634.   init_request("ll", line_length);
  2635.   init_request("in", indent);
  2636.   init_request("ti", temporary_indent);
  2637.   init_request("ul", underline);
  2638.   init_request("cu", underline);
  2639.   init_request("cc", control_char);
  2640.   init_request("c2", no_break_control_char);
  2641.   init_request("br", break_request);
  2642.   init_request("tl", title);
  2643.   init_request("ta", set_tabs);
  2644.   init_request("fc", field_characters);
  2645.   init_request("mc", margin_character);
  2646.   init_request("nn", no_number);
  2647.   init_request("nm", number_lines);
  2648.   init_request("tc", tab_character);
  2649.   init_request("lc", leader_character);
  2650.   init_request("hy", hyphenate_request);
  2651.   init_request("hc", hyphen_char);
  2652.   init_request("nh", no_hyphenate);
  2653.   init_request("hlm", hyphen_line_max_request);
  2654. #ifdef WIDOW_CONTROL
  2655.   init_request("wdc", widow_control_request);
  2656. #endif /* WIDOW_CONTROL */
  2657. #if 0
  2658.   init_request("tas", tabs_save);
  2659.   init_request("tar", tabs_restore);
  2660. #endif  
  2661.   init_request("hys", hyphenation_space_request);
  2662.   init_request("hym", hyphenation_margin_request);
  2663.   init_int_env_reg(".f", get_font);
  2664.   init_int_env_reg(".b", get_bold);
  2665.   init_hunits_env_reg(".i", get_indent);
  2666.   init_hunits_env_reg(".in", get_saved_indent);
  2667.   init_int_env_reg(".j", get_adjust_mode);
  2668.   init_hunits_env_reg(".k", get_text_length);
  2669.   init_hunits_env_reg(".l", get_line_length);
  2670.   init_hunits_env_reg(".ll", get_saved_line_length);
  2671.   init_int_env_reg(".L", get_line_spacing);
  2672.   init_hunits_env_reg(".n", get_prev_text_length);
  2673.   init_string_env_reg(".s", get_point_size_string);
  2674.   init_string_env_reg(".sr", get_requested_point_size_string);
  2675.   init_int_env_reg(".ps", get_point_size);
  2676.   init_int_env_reg(".psr", get_requested_point_size);
  2677.   init_int_env_reg(".u", get_fill);
  2678.   init_vunits_env_reg(".v", get_vertical_spacing);
  2679.   init_hunits_env_reg(".w", get_prev_char_width);
  2680.   init_int_env_reg(".ss", get_space_size);
  2681.   init_int_env_reg(".sss", get_sentence_space_size);
  2682.   init_string_env_reg(".fam", get_font_family_string);
  2683.   init_string_env_reg(".ev", get_name_string);
  2684.   init_int_env_reg(".hy", get_hyphenation_flags);
  2685.   init_int_env_reg(".hlm", get_hyphen_line_max);
  2686.   init_int_env_reg(".hlc", get_hyphen_line_count);
  2687.   init_hunits_env_reg(".lt", get_title_length);
  2688.   init_string_env_reg(".tabs", get_tabs);
  2689.   init_hunits_env_reg(".csk", get_prev_char_skew);
  2690.   init_vunits_env_reg(".cht", get_prev_char_height);
  2691.   init_vunits_env_reg(".cdp", get_prev_char_depth);
  2692.   init_int_env_reg(".ce", get_center_lines);
  2693.   init_int_env_reg(".rj", get_right_justify_lines);
  2694.   init_hunits_env_reg(".hys", get_hyphenation_space);
  2695.   init_hunits_env_reg(".hym", get_hyphenation_margin);
  2696.   number_reg_dictionary.define("ln", new variable_reg(&next_line_number));
  2697.   number_reg_dictionary.define("ct", new variable_reg(&ct_reg_contents));
  2698.   number_reg_dictionary.define("sb", new variable_reg(&sb_reg_contents));
  2699.   number_reg_dictionary.define("st", new variable_reg(&st_reg_contents));
  2700.   number_reg_dictionary.define("rsb", new variable_reg(&rsb_reg_contents));
  2701.   number_reg_dictionary.define("rst", new variable_reg(&rst_reg_contents));
  2702.   number_reg_dictionary.define("ssc", new variable_reg(&ssc_reg_contents));
  2703.   number_reg_dictionary.define("skw", new variable_reg(&skw_reg_contents));
  2704.   number_reg_dictionary.define("hp", new horizontal_place_reg);
  2705. }
  2706.  
  2707. // Hyphenation - TeX's hyphenation algorithm with a less fancy implementation.
  2708.  
  2709. struct trie_node;
  2710.  
  2711. class trie {
  2712.   trie_node *tp;
  2713.   virtual void do_match(int len, void *val) = 0;
  2714.   virtual void do_delete(void *) = 0;
  2715.   void delete_trie_node(trie_node *);
  2716. public:
  2717.   trie() : tp(0) {}
  2718.   virtual ~trie();        // virtual to shut up g++
  2719.   void insert(const char *, int, void *);
  2720.   // find calls do_match for each match it finds
  2721.   void find(const char *pat, int patlen);
  2722.   void clear();
  2723. };
  2724.  
  2725. class hyphen_trie : private trie {
  2726.   int *h;
  2727.   void do_match(int i, void *v);
  2728.   void do_delete(void *v);
  2729.   void insert_pattern(const char *pat, int patlen, int *num);
  2730. public:
  2731.   hyphen_trie() {}
  2732.   ~hyphen_trie() {}
  2733.   void hyphenate(const char *word, int len, int *hyphens);
  2734.   void read_patterns_file(const char *name);
  2735. };
  2736.  
  2737.  
  2738. struct hyphenation_language {
  2739.   symbol name;
  2740.   dictionary exceptions;
  2741.   hyphen_trie patterns;
  2742.   hyphenation_language(symbol nm) : name(nm), exceptions(501) {}
  2743.   ~hyphenation_language() { }
  2744. };
  2745.  
  2746. dictionary language_dictionary(5);
  2747. hyphenation_language *current_language = 0;
  2748.  
  2749. static void set_hyphenation_language()
  2750. {
  2751.   symbol nm = get_name(1);
  2752.   if (!nm.is_null()) {
  2753.     current_language = (hyphenation_language *)language_dictionary.lookup(nm);
  2754.     if (!current_language) {
  2755.       current_language = new hyphenation_language(nm);
  2756.       (void)language_dictionary.lookup(nm, (void *)current_language);
  2757.     }
  2758.   }
  2759.   skip_line();
  2760. }
  2761.  
  2762. const int WORD_MAX = 1024;
  2763.  
  2764. static void hyphen_word()
  2765. {
  2766.   if (!current_language) {
  2767.     error("no current hyphenation language");
  2768.     skip_line();
  2769.     return;
  2770.   }
  2771.   char buf[WORD_MAX + 1];
  2772.   unsigned char pos[WORD_MAX + 2];
  2773.   for (;;) {
  2774.     tok.skip();
  2775.     if (tok.newline() || tok.eof())
  2776.       break;
  2777.     int i = 0;
  2778.     int npos = 0;
  2779.     while (i < WORD_MAX && !tok.space() && !tok.newline() && !tok.eof()) {
  2780.       charinfo *ci = tok.get_char(1);
  2781.       if (ci == 0) {
  2782.     skip_line();
  2783.     return;
  2784.       }
  2785.       tok.next();
  2786.       if (ci->get_ascii_code() == '-') {
  2787.     if (i > 0 && (npos == 0 || pos[npos - 1] != i))
  2788.       pos[npos++] = i;
  2789.       }
  2790.       else {
  2791.     int c = ci->get_hyphenation_code();
  2792.     if (c == 0)
  2793.       break;
  2794.     buf[i++] = c;
  2795.       }
  2796.     }
  2797.     if (i > 0) {
  2798.       pos[npos] = 0;
  2799.       buf[i] = 0;
  2800.       unsigned char *tem = new unsigned char[npos + 1];
  2801.       memcpy(tem, pos, npos+1);
  2802.       tem = (unsigned char *)current_language->exceptions.lookup(symbol(buf),
  2803.                                  tem);
  2804.       if (tem)
  2805.     a_delete tem;
  2806.     }
  2807.   }
  2808.   skip_line();
  2809. }
  2810.  
  2811. struct trie_node {
  2812.   char c;
  2813.   trie_node *down;
  2814.   trie_node *right;
  2815.   void *val;
  2816.   trie_node(char, trie_node *);
  2817. };
  2818.  
  2819. trie_node::trie_node(char ch, trie_node *p) 
  2820. : c(ch), right(p), down(0), val(0)
  2821. {
  2822. }
  2823.  
  2824. trie::~trie()
  2825. {
  2826.   clear();
  2827. }
  2828.  
  2829. void trie::clear()
  2830. {
  2831.   delete_trie_node(tp);
  2832.   tp = 0;
  2833. }
  2834.  
  2835.  
  2836. void trie::delete_trie_node(trie_node *p)
  2837. {
  2838.   if (p) {
  2839.     delete_trie_node(p->down);
  2840.     delete_trie_node(p->right);
  2841.     if (p->val)
  2842.       do_delete(p->val);
  2843.     delete p;
  2844.   }
  2845. }
  2846.  
  2847. void trie::insert(const char *pat, int patlen, void *val)
  2848. {
  2849.   trie_node **p = &tp;
  2850.   assert(patlen > 0 && pat != 0);
  2851.   for (;;) {
  2852.     while (*p != 0 && (*p)->c < pat[0])
  2853.       p = &((*p)->right);
  2854.     if (*p == 0 || (*p)->c != pat[0])
  2855.       *p = new trie_node(pat[0], *p);
  2856.     if (--patlen == 0) {
  2857.       (*p)->val = val;
  2858.       break;
  2859.     }
  2860.     ++pat;
  2861.     p = &((*p)->down);
  2862.   }
  2863. }
  2864.  
  2865. void trie::find(const char *pat, int patlen)
  2866. {
  2867.   trie_node *p = tp;
  2868.   for (int i = 0; p != 0 && i < patlen; i++) {
  2869.     while (p != 0 && p->c < pat[i])
  2870.       p = p->right;
  2871.     if (p != 0 && p->c == pat[i]) {
  2872.       if (p->val != 0)
  2873.     do_match(i+1, p->val);
  2874.       p = p->down;
  2875.     }
  2876.     else
  2877.       break;
  2878.   }
  2879. }
  2880.  
  2881. struct operation {
  2882.   operation *next;
  2883.   short distance;
  2884.   short num;
  2885.   operation(int, int, operation *);
  2886. };
  2887.  
  2888. operation::operation(int i, int j, operation *op)
  2889. : num(i), distance(j), next(op)
  2890. {
  2891. }
  2892.  
  2893. void hyphen_trie::insert_pattern(const char *pat, int patlen, int *num)
  2894. {
  2895.   operation *op = 0;
  2896.   for (int i = 0; i < patlen+1; i++)
  2897.     if (num[i] != 0)
  2898.       op = new operation(num[i], patlen - i, op);
  2899.   insert(pat, patlen, op);
  2900. }
  2901.  
  2902. void hyphen_trie::hyphenate(const char *word, int len, int *hyphens)
  2903. {
  2904.   for (int j = 0; j < len+1; j++)
  2905.     hyphens[j] = 0;
  2906.   for (j = 0; j < len - 1; j++) {
  2907.     h = hyphens + j;
  2908.     find(word + j, len - j);
  2909.   }
  2910. }
  2911.  
  2912. inline int max(int m, int n)
  2913. {
  2914.   return m > n ? m : n;
  2915. }
  2916.  
  2917. void hyphen_trie::do_match(int i, void *v)
  2918. {
  2919.   operation *op = (operation *)v;
  2920.   while (op != 0) {
  2921.     h[i - op->distance] = max(h[i - op->distance], op->num);
  2922.     op = op->next;
  2923.   }
  2924. }
  2925.  
  2926. void hyphen_trie::do_delete(void *v)
  2927. {
  2928.   operation *op = (operation *)v;
  2929.   while (op) {
  2930.     operation *tem = op;
  2931.     op = tem->next;
  2932.     delete tem;
  2933.   }
  2934. }
  2935.   
  2936. void hyphen_trie::read_patterns_file(const char *name)
  2937. {
  2938.   clear();
  2939.   char buf[WORD_MAX];
  2940.   int num[WORD_MAX+1];
  2941.   errno = 0;
  2942.   char *path = 0;
  2943.   FILE *fp = macro_path.open_file(name, &path);
  2944.   if (fp == 0) {
  2945.     error("can't find hyphenation patterns file `%1'", name);
  2946.     return;
  2947.   }
  2948.   int c = getc(fp);
  2949.   for (;;) {
  2950.     for (;;) {
  2951.       if (c == '%') {
  2952.     do {
  2953.       c = getc(fp);
  2954.     } while (c != EOF && c != '\n');
  2955.       }
  2956.       if (c == EOF || !csspace(c))
  2957.     break;
  2958.       c = getc(fp);
  2959.     }
  2960.     if (c == EOF)
  2961.       break;
  2962.     int i = 0;
  2963.     num[0] = 0;
  2964.     do {
  2965.       if (csdigit(c))
  2966.     num[i] = c - '0';
  2967.       else {
  2968.     buf[i++] = c;
  2969.     num[i] = 0;
  2970.       }
  2971.       c = getc(fp);
  2972.     } while (i < WORD_MAX && c != EOF && !csspace(c) && c != '%');
  2973.     insert_pattern(buf, i, num);
  2974.   }
  2975.   fclose(fp);
  2976.   a_delete path;
  2977.   return;
  2978. }
  2979.  
  2980. void hyphenate(hyphen_list *h, unsigned flags)
  2981. {
  2982.   if (!current_language)
  2983.     return;
  2984.   while (h && h->hyphenation_code == 0)
  2985.     h = h->next;
  2986.   int len = 0;
  2987.   char hbuf[WORD_MAX+2];
  2988.   char *buf = hbuf + 1;
  2989.   for (hyphen_list *tem = h; tem && len < WORD_MAX; tem = tem->next) {
  2990.     if (tem->hyphenation_code != 0)
  2991.       buf[len++] = tem->hyphenation_code;
  2992.     else
  2993.       break;
  2994.   }
  2995.   if (len > 2) {
  2996.     buf[len] = 0;
  2997.     unsigned char *pos = (unsigned char *)current_language->exceptions.lookup(buf);
  2998.     if (pos != 0) {
  2999.       int j = 0;
  3000.       int i = 1;
  3001.       for (tem = h; tem != 0; tem = tem->next, i++)
  3002.     if (pos[j] == i) {
  3003.       tem->hyphen = 1;
  3004.       j++;
  3005.     }
  3006.     }
  3007.     else {
  3008.       hbuf[0] = hbuf[len+1] = '.';
  3009.       int num[WORD_MAX+3];
  3010.       current_language->patterns.hyphenate(hbuf, len+2, num);
  3011.       int i;
  3012.       num[2] = 0;
  3013.       if (flags & 8)
  3014.     num[3] = 0;
  3015.       if (flags & 4)
  3016.     --len;
  3017.       for (i = 2, tem = h; i < len && tem; tem = tem->next, i++)
  3018.     if (num[i] & 1)
  3019.       tem->hyphen = 1;
  3020.     }
  3021.   }
  3022. }
  3023.  
  3024. static void hyphenation_patterns_file()
  3025. {
  3026.   symbol name = get_long_name(1);
  3027.   if (!name.is_null()) {
  3028.     if (!current_language)
  3029.       error("no current hyphenation language");
  3030.     else
  3031.       current_language->patterns.read_patterns_file(name.contents());
  3032.   }
  3033.   skip_line();
  3034. }
  3035.  
  3036. class hyphenation_language_reg : public reg {
  3037. public:
  3038.   const char *get_string();
  3039. };
  3040.  
  3041. const char *hyphenation_language_reg::get_string()
  3042. {
  3043.   return current_language ? current_language->name.contents() : "";
  3044. }
  3045.  
  3046. void init_hyphen_requests()
  3047. {
  3048.   init_request("hw", hyphen_word);
  3049.   init_request("hla", set_hyphenation_language);
  3050.   init_request("hpf", hyphenation_patterns_file);
  3051.   number_reg_dictionary.define(".hla", new hyphenation_language_reg);
  3052. }
  3053.