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