BSD 4_3_Net_2 development

[unix-history] / usr / src / usr.bin / groff / troff / node.cc

// -*- C++ -*-
/* Copyright (C) 1989, 1990, 1991 Free Software Foundation, Inc.
    Written by James Clark (jjc@jclark.uucp)

This file is part of groff.

groff is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
Software Foundation; either version 1, or (at your option) any later
version.

groff is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
for more details.

You should have received a copy of the GNU General Public License along
with groff; see the file LICENSE.  If not, write to the Free Software
Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */

#include "groff.h"
#include "symbol.h"
#include "dictionary.h"
#include "hvunits.h"
#include "env.h"
#include "request.h"
#include "node.h"
#include "token.h"
#include "charinfo.h"
#include "font.h"
#include "reg.h"

symbol HYPHEN_SYMBOL("hy");

enum constant_space_type { 
 CONSTANT_SPACE_NONE,
 CONSTANT_SPACE_RELATIVE,
 CONSTANT_SPACE_ABSOLUTE
 };

struct special_font_list {
 int n;
 special_font_list *next;
};

special_font_list *global_special_fonts;
static int global_ligature_mode = 1;
static int global_kern_mode = 1;

class track_kerning_function {
 int non_zero;
 units min_size;
 hunits min_amount;
 units max_size;
 hunits max_amount;
public:
 track_kerning_function();
 track_kerning_function(units, hunits, units, hunits);
 int operator==(const track_kerning_function &);
 int operator!=(const track_kerning_function &);
 hunits compute(int point_size);
};

// embolden fontno when this is the current font

struct conditional_bold {
 conditional_bold *next;
 int fontno;
 hunits offset;
 conditional_bold(int, hunits, conditional_bold * = 0);
};

struct tfont;

class font_info {
 tfont *last_tfont;
 int number;
 font_size last_size;
 int last_height;
 int last_slant;
 symbol internal_name;
 symbol external_name;
 font *fm;
 char is_bold;
 hunits bold_offset;
 track_kerning_function track_kern;
 constant_space_type is_constant_spaced;
 units constant_space;
 int last_ligature_mode;
 int last_kern_mode;
 conditional_bold *cond_bold_list;
 void flush();
public:
 special_font_list *sf;
 
 font_info(symbol nm, int n, symbol enm, font *f);
 int contains(charinfo *);
 void set_bold(hunits);
 void unbold();
 void set_conditional_bold(int, hunits);
 void conditional_unbold(int);
 void set_track_kern(track_kerning_function &);
 void set_constant_space(constant_space_type, units = 0);
 int is_named(symbol);
 symbol get_name();
 tfont *get_tfont(font_size, int, int, int);
 hunits get_space_width(font_size);
 hunits get_narrow_space_width(font_size);
 hunits get_half_narrow_space_width(font_size);
 int get_bold(hunits *);
 int is_special();
 int is_style();
};

class tfont_spec {
protected:
 symbol name;
 int input_position;
 font *fm;
 font_size size;
 char is_bold;
 char is_constant_spaced;
 int ligature_mode;
 int kern_mode;
 hunits bold_offset;
 hunits track_kern;                    // add this to the width
 hunits constant_space_width;
 int height;
 int slant;
public:
 tfont_spec(symbol nm, int pos, font *, font_size, int, int);
 tfont_spec plain();
 int operator==(const tfont_spec &);
 friend tfont *font_info::get_tfont(font_size fs, int, int, int);
};

class tfont : public tfont_spec {
 static tfont *tfont_list;
 tfont *next;
 tfont *plain_version;
public:
 tfont(tfont_spec &);
 int contains(charinfo *);
 hunits get_width(charinfo *c);
 int get_bold(hunits *);
 int get_constant_space(hunits *);
 hunits get_track_kern();
 tfont *get_plain();
 font_size get_size();
 symbol get_name();
 charinfo *get_lig(charinfo *c1, charinfo *c2);
 int get_kern(charinfo *c1, charinfo *c2, hunits *res);
 int get_input_position();
 int get_character_type(charinfo *);
 int get_height();
 int get_slant();
 vunits get_char_height(charinfo *);
 vunits get_char_depth(charinfo *);
 hunits get_char_skew(charinfo *);
 hunits get_italic_correction(charinfo *);
 hunits get_left_italic_correction(charinfo *);
 hunits get_subscript_correction(charinfo *);
 friend tfont *make_tfont(tfont_spec &);
};

inline int env_definite_font(environment *env)
{
 return env->get_family()->make_definite(env->get_font());
}

static void invalidate_fontno(int n);

/* font_info functions */

static font_info **font_table = 0;
static int font_table_size = 0;

font_info::font_info(symbol nm, int n, symbol enm, font *f)
: internal_name(nm), external_name(enm), fm(f), number(n),
 is_constant_spaced(CONSTANT_SPACE_NONE),
 sf(0), is_bold(0), cond_bold_list(0),
 last_ligature_mode(1), last_kern_mode(1),
 last_tfont(0), last_size(0)
{
}

inline int font_info::contains(charinfo *ci)
{
 return fm != 0 && fm->contains(ci->get_index());
}

inline int font_info::is_special()
{
 return fm != 0 && fm->is_special();
}

inline int font_info::is_style()
{
 return fm == 0;
}

// this is the current_font, fontno is where we found the character,
// presumably a special font

tfont *font_info::get_tfont(font_size fs, int height, int slant, int fontno)
{
 if (last_tfont == 0 || fs != last_size
     || height != last_height || slant != last_slant
     || global_ligature_mode != last_ligature_mode
     || global_kern_mode != last_kern_mode
     || fontno != number) {
       font_info *f = font_table[fontno];
       tfont_spec spec(f->external_name, f->number, f->fm, fs, height, slant);
       for (conditional_bold *p = cond_bold_list; p; p = p->next)
         if (p->fontno == fontno) {
           spec.is_bold = 1;
           spec.bold_offset = p->offset;
           break;
         }
       if (!spec.is_bold && is_bold) {
         spec.is_bold = 1;
         spec.bold_offset = bold_offset;
       }
       spec.track_kern = track_kern.compute(fs.to_scaled_points());
       spec.ligature_mode = global_ligature_mode;
       spec.kern_mode = global_kern_mode;
       switch (is_constant_spaced) {
       case CONSTANT_SPACE_NONE:
         break;
       case CONSTANT_SPACE_ABSOLUTE:
         spec.is_constant_spaced = 1;
         spec.constant_space_width = constant_space;
         break;
       case CONSTANT_SPACE_RELATIVE:
         spec.is_constant_spaced = 1;
         spec.constant_space_width
           = scale(constant_space*fs.to_scaled_points(),
                   units_per_inch,
                   36*72*sizescale);
         break;
       default:
         assert(0);
       }
       if (fontno != number)
         return make_tfont(spec);
       last_tfont = make_tfont(spec);
       last_size = fs;
       last_height = height;
       last_slant = slant;
       last_ligature_mode = global_ligature_mode;
       last_kern_mode = global_kern_mode;
     }
 return last_tfont;
}

int font_info::get_bold(hunits *res)
{
 if (is_bold) {
   *res = bold_offset;
   return 1;
 }
 else
   return 0;
}

void font_info::unbold()
{
 if (is_bold) {
   is_bold = 0;
   flush();
 }
}

void font_info::set_bold(hunits offset)
{
 if (!is_bold || offset != bold_offset) {
   is_bold = 1;
   bold_offset = offset;
   flush();
 }
}

void font_info::set_conditional_bold(int fontno, hunits offset)
{
 for (conditional_bold *p = cond_bold_list; p; p = p->next)
   if (p->fontno == fontno) {
     if (offset != p->offset) {
       p->offset = offset;
       flush();
     }
     return;
   }
 cond_bold_list = new conditional_bold(fontno, offset, cond_bold_list);
}

conditional_bold::conditional_bold(int f, hunits h, conditional_bold *x)
    : fontno(f), offset(h), next(x)
{
}

void font_info::conditional_unbold(int fontno)
{
 for (conditional_bold **p = &cond_bold_list; *p; p = &(*p)->next)
   if ((*p)->fontno == fontno) {
     conditional_bold *tem = *p;
     *p = (*p)->next;
     delete tem;
     flush();
     return;
   }
}
                                
void font_info::set_constant_space(constant_space_type type, units x)
{
 if (type != is_constant_spaced
     || (type != CONSTANT_SPACE_NONE && x != constant_space)) {
       flush();
       is_constant_spaced = type;
       constant_space = x;
     }
}

void font_info::set_track_kern(track_kerning_function  &tk)
{
 if (track_kern != tk) {
   track_kern = tk;
   flush();
 }
}

void font_info::flush()
{
 last_tfont = 0;
}

int font_info::is_named(symbol s)
{
 return internal_name == s;
}

symbol font_info::get_name()
{
 return internal_name;
}

hunits font_info::get_space_width(font_size fs)
{
 return hunits(fm->get_space_width(fs.to_scaled_points()));
}

hunits font_info::get_narrow_space_width(font_size fs)
{
 charinfo *ci = get_charinfo(symbol("|"));
 if (fm->contains(ci->get_index()))
   return hunits(fm->get_width(ci->get_index(), fs.to_scaled_points()));
 else
   return hunits(fs.to_units()/6);
}

hunits font_info::get_half_narrow_space_width(font_size fs)
{
 charinfo *ci = get_charinfo(symbol("^"));
 if (fm->contains(ci->get_index()))
   return hunits(fm->get_width(ci->get_index(), fs.to_scaled_points()));
 else
   return hunits(fs.to_units()/12);
}

/* tfont */

tfont_spec::tfont_spec(symbol nm, int n, font *f, 
                      font_size s, int h, int sl)
    : name(nm), input_position(n), fm(f), size(s),
    is_bold(0), is_constant_spaced(0), ligature_mode(1), kern_mode(1),
    height(h), slant(sl)
{
 if (height == size.to_scaled_points())
   height = 0;
}

int tfont_spec::operator==(const tfont_spec &spec)
{
 if (fm == spec.fm 
     && size == spec.size
     && input_position == spec.input_position
     && name == spec.name
     && height == spec.height
     && slant == spec.slant
     && (is_bold 
         ? (spec.is_bold && bold_offset == spec.bold_offset)
         : !spec.is_bold)
     && track_kern == spec.track_kern
     && (is_constant_spaced
         ? (spec.is_constant_spaced 
            && constant_space_width == spec.constant_space_width)
         : !spec.is_constant_spaced)
     && ligature_mode == spec.ligature_mode
     && kern_mode == spec.kern_mode)
   return 1;
 else
   return 0;
}

tfont_spec tfont_spec::plain()
{
 return tfont_spec(name, input_position, fm, size, height, slant);
}

hunits tfont::get_width(charinfo *c)
{
 if (is_constant_spaced)
   return constant_space_width;
 else if (is_bold)
   return (hunits(fm->get_width(c->get_index(), size.to_scaled_points()))
           + track_kern + bold_offset);
 else
   return (hunits(fm->get_width(c->get_index(), size.to_scaled_points())) + track_kern);
}

vunits tfont::get_char_height(charinfo *c)
{
 vunits v = fm->get_height(c->get_index(), size.to_scaled_points());
 if (height != 0 && height != size.to_scaled_points())
   return scale(v, height, size.to_scaled_points());
 else
   return v;
}

vunits tfont::get_char_depth(charinfo *c)
{
 vunits v = fm->get_depth(c->get_index(), size.to_scaled_points());
 if (height != 0 && height != size.to_scaled_points())
   return scale(v, height, size.to_scaled_points());
 else
   return v;
}

hunits tfont::get_char_skew(charinfo *c)
{
 return hunits(fm->get_skew(c->get_index(), size.to_scaled_points(), slant));
}

hunits tfont::get_italic_correction(charinfo *c)
{
 return hunits(fm->get_italic_correction(c->get_index(), size.to_scaled_points()));
}

hunits tfont::get_left_italic_correction(charinfo *c)
{
 return hunits(fm->get_left_italic_correction(c->get_index(),
                                              size.to_scaled_points()));
}

hunits tfont::get_subscript_correction(charinfo *c)
{
 return hunits(fm->get_subscript_correction(c->get_index(),
                                            size.to_scaled_points()));
}

inline int tfont::get_input_position()
{
 return input_position;
}

inline int tfont::contains(charinfo *ci)
{
 return fm->contains(ci->get_index());
}

inline int tfont::get_character_type(charinfo *ci)
{
 return fm->get_character_type(ci->get_index());
}

inline int tfont::get_bold(hunits *res)
{
 if (is_bold) {
   *res = bold_offset;
   return 1;
 }
 else
   return 0;
}

inline int tfont::get_constant_space(hunits *res)
{
 if (is_constant_spaced) {
   *res = constant_space_width;
   return 1;
 }
 else
   return 0;
}

inline hunits tfont::get_track_kern()
{
 return track_kern;
}

inline tfont *tfont::get_plain()
{
 return plain_version;
}

inline font_size tfont::get_size()
{
 return size;
}

inline symbol tfont::get_name()
{
 return name;
}

inline int tfont::get_height()
{
 return height;
}

inline int tfont::get_slant()
{
 return slant;
}

symbol SYMBOL_ff("ff");
symbol SYMBOL_fi("fi");
symbol SYMBOL_fl("fl");
symbol SYMBOL_Fi("Fi");
symbol SYMBOL_Fl("Fl");

charinfo *tfont::get_lig(charinfo *c1, charinfo *c2)
{
 if (ligature_mode == 0)
   return 0;
 charinfo *ci = 0;
 if (c1->get_ascii_code() == 'f') {
   switch (c2->get_ascii_code()) {
   case 'f':
     if (fm->has_ligature(font::LIG_ff))
       ci = get_charinfo(SYMBOL_ff);
     break;
   case 'i':
     if (fm->has_ligature(font::LIG_fi))
       ci = get_charinfo(SYMBOL_fi);
     break;
   case 'l':
     if (fm->has_ligature(font::LIG_fl))
       ci = get_charinfo(SYMBOL_fl);
     break;
   }
 }
 else if (ligature_mode != 2 && c1->nm == SYMBOL_ff) {
   switch (c2->get_ascii_code()) {
   case 'i':
     if (fm->has_ligature(font::LIG_ffi))
       ci = get_charinfo(SYMBOL_Fi);
     break;
   case 'l':
     if (fm->has_ligature(font::LIG_ffl))
       ci = get_charinfo(SYMBOL_Fl);
     break;
   }
 }
 if (ci != 0 && fm->contains(ci->get_index()))
   return ci;
 return 0;
}

inline int tfont::get_kern(charinfo *c1, charinfo *c2, hunits *res)
{
 if (kern_mode == 0)
   return 0;
 else {
   int n = fm->get_kern(c1->get_index(),
                        c2->get_index(),
                        size.to_scaled_points());
   if (n) {
     *res = hunits(n);
     return 1;
   }
   else
     return 0;
 }
}

tfont *make_tfont(tfont_spec &spec)
{
 for (tfont *p = tfont::tfont_list; p; p = p->next)
   if (*p == spec)
     return p;
 return new tfont(spec);
}

tfont *tfont::tfont_list = 0;

tfont::tfont(tfont_spec &spec) : tfont_spec(spec)
{
 next = tfont_list;
 tfont_list = this;
 tfont_spec plain_spec = plain();
 for (tfont *p = tfont_list; p; p = p->next)
   if (*p == plain_spec) {
     plain_version = p;
     break;
   }
 if (!p)
   plain_version = new tfont(plain_spec);
}

/* output_file */

class real_output_file : public output_file {
 int piped;
 int printing;
 virtual void really_transparent_char(unsigned char) = 0;
 virtual void really_print_line(hunits x, vunits y, node *n,
                                vunits before, vunits after) = 0;
 virtual void really_begin_page(int pageno, vunits page_length) = 0;
 virtual void really_copy_file(hunits x, vunits y, const char *filename);
protected:
 FILE *fp;
public:
 real_output_file();
 ~real_output_file();
 void flush();
 void transparent_char(unsigned char);
 void print_line(hunits x, vunits y, node *n, vunits before, vunits after);
 void begin_page(int pageno, vunits page_length);
 int is_printing();
 void copy_file(hunits x, vunits y, const char *filename);
};

class suppress_output_file : public real_output_file {
public:
 suppress_output_file();
 void really_transparent_char(unsigned char);
 void really_print_line(hunits x, vunits y, node *n, vunits, vunits);
 void really_begin_page(int pageno, vunits page_length);
};

class ascii_output_file : public real_output_file {
public:
 ascii_output_file();
 void really_transparent_char(unsigned char);
 void really_print_line(hunits x, vunits y, node *n, vunits, vunits);
 void really_begin_page(int pageno, vunits page_length);
 void outc(unsigned char c);
 void outs(const char *s);
};

void ascii_output_file::outc(unsigned char c)
{
 fputc(c, fp);
}

void ascii_output_file::outs(const char *s)
{
 fputc('<', fp);
 if (s)
   fputs(s, fp);
 fputc('>', fp);
}

struct hvpair;
     
class troff_output_file : public real_output_file {
 units hpos;
 units vpos;
 units output_vpos;
 units output_hpos;
 int force_motion;
 int current_size;
 int current_slant;
 int current_height;
 tfont *current_tfont;
 int current_font_number;
 symbol *font_position;
 int nfont_positions;
 enum { TBUF_SIZE = 256 };
 char tbuf[TBUF_SIZE];
 int tbuf_len;
 int tbuf_kern;
 void do_motion();
 vunits page_length;
 void put(char c);
 void put(unsigned char c);
 void put(int i);
 void put(const char *s);
 void set_font(tfont *tf);
 void flush_tbuf();
public:
 troff_output_file();
 ~troff_output_file();
 void put_char(charinfo *ci, tfont *tf);
 void put_char_width(charinfo *ci, tfont *tf, hunits w, hunits k);
 void right(hunits);
 void down(vunits);
 void moveto(hunits, vunits);
 void start_special();
 void special_char(unsigned char c);
 void end_special();
 void word_marker();
 void really_transparent_char(unsigned char c);
 void really_print_line(hunits x, vunits y, node *n, vunits before, vunits after);
 void really_begin_page(int pageno, vunits page_length);
 void really_copy_file(hunits x, vunits y, const char *filename);
 void draw(char, hvpair *, int, font_size);
 int get_hpos() { return hpos; }
 int get_vpos() { return vpos; }
};

static void put_string(const char *s, FILE *fp)
{
 for (; *s != '\0'; ++s)
   putc(*s, fp);
}

inline void troff_output_file::put(char c)
{
 putc(c, fp);
}

inline void troff_output_file::put(unsigned char c)
{
 putc(c, fp);
}

inline void troff_output_file::put(const char *s)
{
 put_string(s, fp);
}

inline void troff_output_file::put(int i)
{
 put_string(itoa(i), fp);
}

void troff_output_file::start_special()
{
 flush_tbuf();
 do_motion();
 put("x X ");
}

void troff_output_file::special_char(unsigned char c)
{
 put(c);
 if (c == '\n')
   put('+');
}

void troff_output_file::end_special()
{
 put('\n');
}

inline void troff_output_file::moveto(hunits h, vunits v)
{
 hpos = h.to_units();
 vpos = v.to_units();
}

void troff_output_file::really_print_line(hunits x, vunits y, node *n,
                                         vunits before, vunits after)
{
 moveto(x, y);
 while (n != 0) {
   n->tprint(this);
   n = n->next;
 }
 flush_tbuf();
 // This ensures that transparent throughput will have a more predictable
 // position.
 do_motion();
 force_motion = 1;
 hpos = 0;
 put('n');
 put(before.to_units());
 put(' ');
 put(after.to_units());
 put('\n');
}

inline void troff_output_file::word_marker()
{
 flush_tbuf();
 put('w');
}

inline void troff_output_file::right(hunits n)
{
 hpos += n.to_units();
}

inline void troff_output_file::down(vunits n)
{
 vpos += n.to_units();
}

void troff_output_file::do_motion()
{
 if (force_motion) {
   put('V');
   put(vpos);
   put('\n');
   put('H');
   put(hpos);
   put('\n');
 }
 else {
   if (hpos != output_hpos) {
     units n = hpos - output_hpos;
     if (n > 0 && n < hpos) {
       put('h');
       put(n);
     }
     else {
       put('H');
       put(hpos);
     }
     put('\n');
   }
   if (vpos != output_vpos) {
     units n = vpos - output_vpos;
     if (n > 0 && n < vpos) {
       put('v');
       put(n);
     }
     else {
       put('V');
       put(vpos);
     }
     put('\n');
   }
 }
 output_vpos = vpos;
 output_hpos = hpos;
 force_motion = 0;
}

void troff_output_file::flush_tbuf()
{
 if (tbuf_len == 0)
   return;
 if (tbuf_kern == 0)
   put('t');
 else {
   put('u');
   put(tbuf_kern);
   put(' ');
 }
 for (int i = 0; i < tbuf_len; i++)
   put(tbuf[i]);
 put('\n');
 tbuf_len = 0;
}

void troff_output_file::put_char_width(charinfo *ci, tfont *tf, hunits w,
                                      hunits k)
{
 if (tf != current_tfont) {
   flush_tbuf();
   set_font(tf);
 }
 char c = ci->get_ascii_code();
 int kk = k.to_units();
 if (c == '\0') {
   flush_tbuf();
   do_motion();
   int n = ci->get_number();
   if (n >= 0) {
     put('N');
     put(n);
   }
   else {
     put('C');
     const char *s = ci->nm.contents();
     if (s[1] == 0) {
       put('\\');
       put(s[0]);
     }
     else
       put(s);
   }
   put('\n');
   hpos += w.to_units() + kk;
 }
 else if (tcommand_flag) {
   if (tbuf_len > 0 && hpos == output_hpos && vpos == output_vpos
       && kk == tbuf_kern
       && tbuf_len < TBUF_SIZE) {
     tbuf[tbuf_len++] = c;
     output_hpos += w.to_units() + kk;
     hpos = output_hpos;
     return;
   }
   flush_tbuf();
   do_motion();
   tbuf[tbuf_len++] = c;
   output_hpos += w.to_units() + kk;
   tbuf_kern = kk;
   hpos = output_hpos;
 }
 else {
   // flush_tbuf();
   int n = hpos - output_hpos;
   if (vpos == output_vpos && n > 0 && n < 100 && !force_motion) {
     put(char(n/10 + '0'));
     put(char(n%10 + '0'));
     put(c);
     output_hpos = hpos;
   }
   else {
     do_motion();
     put('c');
     put(c);
   }
   hpos += w.to_units() + kk;
 }
}

void troff_output_file::put_char(charinfo *ci, tfont *tf)
{
 flush_tbuf();
 if (tf != current_tfont)
   set_font(tf);
 char c = ci->get_ascii_code();
 if (c == '\0') {
   do_motion();
   int n = ci->get_number();
   if (n >= 0) {
     put('N');
     put(n);
   }
   else {
     put('C');
     const char *s = ci->nm.contents();
     if (s[1] == 0) {
       put('\\');
       put(s[0]);
     }
     else
       put(s);
   }
   put('\n');
 }
 else {
   int n = hpos - output_hpos;
   if (vpos == output_vpos && n > 0 && n < 100) {
     put(char(n/10 + '0'));
     put(char(n%10 + '0'));
     put(c);
     output_hpos = hpos;
   }
   else {
     do_motion();
     put('c');
     put(c);
   }
 }
}

void troff_output_file::set_font(tfont *tf)
{
 if (current_tfont == tf)
   return;
 int n = tf->get_input_position();
 symbol nm = tf->get_name();
 if (n >= nfont_positions || font_position[n] != nm) {
   put("x font ");
   put(n);
   put(' ');
   put(nm.contents());
   put('\n');
   if (n >= nfont_positions) {
     int old_nfont_positions = nfont_positions;
     symbol *old_font_position = font_position;
     nfont_positions *= 3;
     nfont_positions /= 2;
     if (nfont_positions <= n)
       nfont_positions = n + 10;
     font_position = new symbol[nfont_positions];
     memcpy(font_position, old_font_position,
            old_nfont_positions*sizeof(symbol));
     delete old_font_position;
   }
   font_position[n] = nm;
 }
 if (current_font_number != n) {
   put('f');
   put(n);
   put('\n');
   current_font_number = n;
 }
 int size = tf->get_size().to_scaled_points();
 if (current_size != size) {
   put('s');
   put(size);
   put('\n');
   current_size = size;
 }
 int slant = tf->get_slant();
 if (current_slant != slant) {
   put("x Slant ");
   put(slant);
   put('\n');
   current_slant = slant;
 }
 int height = tf->get_height();
 if (current_height != height) {
   put("x Height ");
   put(height == 0 ? current_size : height);
   put('\n');
   current_height = height;
 }
 current_tfont = tf;
}

void troff_output_file::draw(char code, hvpair *point, int npoints,
                            font_size fsize)
{
 flush_tbuf();
 do_motion();
 int size = fsize.to_scaled_points();
 if (current_size != size) {
   put('s');
   put(size);
   put('\n');
   current_size = size;
   current_tfont = 0;
 }
 put('D');
 put(code);
 int i;
 if (code == 'c') {
   put(' ');
   put(point[0].h.to_units());
 }
 else
   for (i = 0; i < npoints; i++) {
     put(' ');
     put(point[i].h.to_units());
     put(' ');
     put(point[i].v.to_units());
   }
 for (i = 0; i < npoints; i++)
   output_hpos += point[i].h.to_units();
 hpos = output_hpos;
 if (code != 'e') {
   for (i = 0; i < npoints; i++)
     output_vpos += point[i].v.to_units();
   vpos = output_vpos;
 }
 put('\n');
}

void troff_output_file::really_begin_page(int pageno, vunits pl)
{
 flush_tbuf();
 if (page_length > V0) {
   put('V');
   put(page_length.to_units());
   put('\n');
 }
 page_length = pl;
 current_tfont = 0;
 current_font_number = -1;
 current_size = 0;
 // current_height = 0;
 // current_slant = 0;
 hpos = 0;
 vpos = 0;
 output_hpos = 0;
 output_vpos = 0;
 force_motion = 1;
 for (int i = 0; i < nfont_positions; i++)
   font_position[i] = NULL_SYMBOL;
 put('p');
 put(pageno);
 put('\n');
}

void troff_output_file::really_copy_file(hunits x, vunits y, const char *filename)
{
 moveto(x, y);
 flush_tbuf();
 do_motion();
 FILE *ifp = fopen(filename, "r");
 if (ifp == 0)
   error("can't open `%1': %2", filename, strerror(errno));
 else {
   int c;
   while ((c = getc(ifp)) != EOF)
     put(char(c));
   fclose(ifp);
 }
 force_motion = 1;
 current_size = 0;
 current_tfont = 0;
 current_font_number = -1;
 for (int i = 0; i < nfont_positions; i++)
   font_position[i] = NULL_SYMBOL;
}
 
void troff_output_file::really_transparent_char(unsigned char c)
{
 put(c);
}

troff_output_file::~troff_output_file()
{
 flush_tbuf();
 if (page_length > V0) {
   put("x trailer\n");
   put('V');
   put(page_length.to_units());
   put('\n');
 }
 put("x stop\n");
 delete font_position;
}

troff_output_file::troff_output_file()
: current_height(0), current_slant(0), tbuf_len(0), nfont_positions(10)
{
 font_position = new symbol[nfont_positions];
 put("x T ");
 put(device);
 put('\n');
 put("x res ");
 put(units_per_inch);
 put(' ');
 put(hresolution);
 put(' ');
 put(vresolution);
 put('\n');
 put("x init\n");
}

/* output_file */

output_file *the_output = 0;

output_file::output_file()
{
}

output_file::~output_file()
{
}

real_output_file::real_output_file()
: printing(0)
{
 if (pipe_command) {
   if ((fp = popen(pipe_command, "w")) != 0) {
     piped = 1;
     return;
   }
   error("pipe open failed: %1", strerror(errno));
 }
 piped = 0;
 fp = stdout;
}

real_output_file::~real_output_file()
{
 if (!fp)
   return;
 // To avoid looping, set fp to 0 before calling fatal().
 if (ferror(fp) || fflush(fp) < 0) {
   fp = 0;
   fatal("error writing output file");
 }
 if (piped) {
   int result = pclose(fp);
   fp = 0;
   if (result < 0)
     fatal("pclose failed");
   if ((result & 0x7f) != 0)
     error("output process `%1' got fatal signal %2",
           pipe_command, result & 0x7f);
   else {
     int exit_status = (result >> 8) & 0xff;
     if (exit_status != 0)
       error("output process `%1' exited with status %2",
             pipe_command, exit_status);
   }
 }
 else if (fclose(fp) < 0) {
   fp = 0;
   fatal("error closing output file");
 }
}

void real_output_file::flush()
{
 if (fflush(fp) < 0)
   fatal("error writing output file");
}

int real_output_file::is_printing()
{
 return printing;
}

void real_output_file::begin_page(int pageno, vunits page_length)
{
 printing = in_output_page_list(pageno);
 if (printing)
   really_begin_page(pageno, page_length);
}

void real_output_file::copy_file(hunits x, vunits y, const char *filename)
{
 if (printing)
   really_copy_file(x, y, filename);
}

void real_output_file::transparent_char(unsigned char c)
{
 if (printing)
   really_transparent_char(c);
}

void real_output_file::print_line(hunits x, vunits y, node *n,
                            vunits before, vunits after)
{
 if (printing)
   really_print_line(x, y, n, before, after);
 delete_node_list(n);
}

void real_output_file::really_copy_file(hunits, vunits, const char *)
{
 // do nothing
}


/* ascii_output_file */

void ascii_output_file::really_transparent_char(unsigned char c)
{
 putc(c, fp);
}

void ascii_output_file::really_print_line(hunits, vunits, node *n, vunits, vunits)
{
 while (n != 0) {
   n->ascii_print(this);
   n = n->next;
 }
 fputc('\n', fp);
}

void ascii_output_file::really_begin_page(int /*pageno*/, vunits /*page_length*/)
{
 fputs("<beginning of page>\n", fp);
}

ascii_output_file::ascii_output_file()
{
}

/* suppress_output_file */

suppress_output_file::suppress_output_file()
{
}

void suppress_output_file::really_print_line(hunits, vunits, node *, vunits, vunits)
{
}

void suppress_output_file::really_begin_page(int pageno, vunits page_length)
{
}

void suppress_output_file::really_transparent_char(unsigned char c)
{
}

/* glyphs, ligatures, kerns, discretionary breaks */

class glyph_node : public node {
 static glyph_node *free_list;
protected:
 charinfo *ci;
 tfont *tf;
#ifdef STORE_WIDTH
 hunits wid;
 glyph_node(charinfo *, tfont *, hunits, node * = 0);
#endif
public:
 void *operator new(size_t);
 void operator delete(void *);
 glyph_node(charinfo *, tfont *, node * = 0);
 ~glyph_node() {}
 node *copy();
 node *merge_glyph_node(glyph_node *);
 node *merge_self(node *);
 hunits width();
 node *last_char_node();
 units size();
 void vertical_extent(vunits *, vunits *);
 hunits subscript_correction();
 hunits italic_correction();
 hunits left_italic_correction();
 hunits skew();
 hyphenation_type get_hyphenation_type();
 tfont *get_tfont();
 void tprint(troff_output_file *);
 void zero_width_tprint(troff_output_file *);
 hyphen_list *get_hyphen_list(hyphen_list *ss = 0);
 node *add_self(node *, hyphen_list **);
 int ends_sentence();
 int overlaps_vertically();
 int overlaps_horizontally();
 void ascii_print(ascii_output_file *);
 void asciify(macro *);
 int character_type();
 int same(node *);
 const char *type();
};

glyph_node *glyph_node::free_list = 0;

class ligature_node : public glyph_node {
 node *n1;
 node *n2;
#ifdef STORE_WIDTH
 ligature_node(charinfo *, tfont *, hunits, node *gn1, node *gn2, node *x = 0);
#endif
public:
 void *operator new(size_t);
 void operator delete(void *);
 ligature_node(charinfo *, tfont *, node *gn1, node *gn2, node *x = 0);
 ~ligature_node();
 node *copy();
 node *add_self(node *, hyphen_list **);
 hyphen_list *get_hyphen_list(hyphen_list *ss = 0);
 void ascii_print(ascii_output_file *);
 void asciify(macro *);
 int same(node *);
 const char *type();
};

class kern_pair_node : public node {
 hunits amount;
 node *n1;
 node *n2;
public:
 kern_pair_node(hunits n, node *first, node *second, node *x = 0);
 ~kern_pair_node();
 node *copy();
 node *merge_glyph_node(glyph_node *);
 node *add_self(node *, hyphen_list **);
 hyphen_list *get_hyphen_list(hyphen_list *ss = 0);
 node *add_discretionary_hyphen();
 hunits width();
 node *last_char_node();
 hunits italic_correction();
 hunits subscript_correction();
 void tprint(troff_output_file *);
 hyphenation_type get_hyphenation_type();
 int ends_sentence();
 void ascii_print(ascii_output_file *);
 void asciify(macro *);
 int same(node *);
 const char *type();
};

class dbreak_node : public node {
 node *none;
 node *pre;
 node *post;
public:
 dbreak_node(node *n, node *p, node *x = 0);
 ~dbreak_node();
 node *copy();
 node *merge_glyph_node(glyph_node *);
 node *add_discretionary_hyphen();
 hunits width();
 node *last_char_node();
 hunits italic_correction();
 hunits subscript_correction();
 void tprint(troff_output_file *);
 breakpoint *get_breakpoints(hunits width, int ns, breakpoint *rest = 0,
                             int is_inner = 0);
 int nbreaks();
 int ends_sentence();
 void split(int, node **, node **);
 hyphenation_type get_hyphenation_type();
 void ascii_print(ascii_output_file *);
 void asciify(macro *);
 int same(node *);
 const char *type();
};

void *glyph_node::operator new(size_t n)
{
 assert(n == sizeof(glyph_node));
 if (!free_list) {
   const int BLOCK = 1024;
   free_list = (glyph_node *)new char[sizeof(glyph_node)*BLOCK];
   for (int i = 0; i < BLOCK - 1; i++)
     free_list[i].next = free_list + i + 1;
   free_list[BLOCK-1].next = 0;
 }
 glyph_node *p = free_list;
 free_list = (glyph_node *)(free_list->next);
 p->next = 0;
 return p;
}

void *ligature_node::operator new(size_t n)
{
 return new char[n];
}

void glyph_node::operator delete(void *p)
{
 if (p) {
   ((glyph_node *)p)->next = free_list;
   free_list = (glyph_node *)p;
 }
}

void ligature_node::operator delete(void *p)
{
 delete p;
}

glyph_node::glyph_node(charinfo *c, tfont *t, node *x)
    : ci(c), tf(t), node(x)
{
#ifdef STORE_WIDTH
 wid = tf->get_width(ci);
#endif
}

#ifdef STORE_WIDTH
glyph_node::glyph_node(charinfo *c, tfont *t, hunits w, node *x)
    : ci(c), tf(t), wid(w), node(x)
{
}
#endif

node *glyph_node::copy()
{
#ifdef STORE_WIDTH
 return new glyph_node(ci, tf, wid);
#else
 return new glyph_node(ci, tf);
#endif
}

node *glyph_node::merge_self(node *nd)
{
 return nd->merge_glyph_node(this);
}

int glyph_node::character_type()
{
 return tf->get_character_type(ci);
}

node *glyph_node::add_self(node *n, hyphen_list **p)
{
 assert(ci->get_hyphenation_code() == (*p)->hyphenation_code);
 next = 0;
 node *nn;
 if (n == 0 || (nn = n->merge_glyph_node(this)) == 0) {
   next = n;
   nn = this;
 }
 if ((*p)->hyphen)
   nn = nn->add_discretionary_hyphen();
 hyphen_list *pp = *p;
 *p = (*p)->next;
 delete pp;
 return nn;
}

int glyph_node::overlaps_horizontally()
{
 return ci->overlaps_horizontally();
}

int glyph_node::overlaps_vertically()
{
 return ci->overlaps_vertically();
}

units glyph_node::size()
{
 return tf->get_size().to_units();
}

hyphen_list *glyph_node::get_hyphen_list(hyphen_list *tail)
{
 return new hyphen_list(ci->get_hyphenation_code(), tail);
}


tfont *node::get_tfont()
{
 return 0;
}

tfont *glyph_node::get_tfont()
{
 return tf;
}

node *node::merge_glyph_node(glyph_node * /*gn*/)
{
 return 0;
}

node *glyph_node::merge_glyph_node(glyph_node *gn)
{
 if (tf == gn->tf) {
   charinfo *lig;
   if ((lig = tf->get_lig(ci, gn->ci)) != 0) {
     node *next1 = next;
     next = 0;
     return new ligature_node(lig, tf, this, gn, next1);
   }
   hunits kern;
   if (tf->get_kern(ci, gn->ci, &kern)) {
     node *next1 = next;
     next = 0;
     return new kern_pair_node(kern, this, gn, next1);
   }
 }
 return 0;
}

#ifdef STORE_WIDTH
inline
#endif
hunits glyph_node::width()
{
#ifdef STORE_WIDTH
 return wid;
#else
 return tf->get_width(ci);
#endif
}

node *glyph_node::last_char_node()
{
 return this;
}

void glyph_node::vertical_extent(vunits *min, vunits *max)
{
 *min = -tf->get_char_height(ci);
 *max = tf->get_char_depth(ci);
}

hunits glyph_node::skew()
{
 return tf->get_char_skew(ci);
}

hunits glyph_node::subscript_correction()
{
 return tf->get_subscript_correction(ci);
}

hunits glyph_node::italic_correction()
{
 return tf->get_italic_correction(ci);
}

hunits glyph_node::left_italic_correction()
{
 return tf->get_left_italic_correction(ci);
}

hyphenation_type glyph_node::get_hyphenation_type()
{
 return HYPHEN_MIDDLE;
}

int glyph_node::ends_sentence()
{
 if (ci->ends_sentence())
   return 1;
 else if (ci->transparent())
   return 2;
 else
   return 0;
}

void glyph_node::ascii_print(ascii_output_file *ascii)
{
 unsigned char c = ci->get_ascii_code();
 if (c != 0)
   ascii->outc(c);
 else
   ascii->outs(ci->nm.contents());
}

ligature_node::ligature_node(charinfo *c, tfont *t, 
                            node *gn1, node *gn2, node *x)
    : glyph_node(c, t, x), n1(gn1), n2(gn2)
{
}

#ifdef STORE_WIDTH
ligature_node::ligature_node(charinfo *c, tfont *t, hunits w,
                              node *gn1, node *gn2, node *x)
    : glyph_node(c, t, w, x), n1(gn1), n2(gn2)
{
}
#endif

ligature_node::~ligature_node()
{
 delete n1;
 delete n2;
}

node *ligature_node::copy()
{
#ifdef STORE_WIDTH
 return new ligature_node(ci, tf, wid, n1->copy(), n2->copy());
#else
 return new ligature_node(ci, tf, n1->copy(), n2->copy());
#endif
}

void ligature_node::ascii_print(ascii_output_file *ascii)
{
 n1->ascii_print(ascii);
 n2->ascii_print(ascii);
}

hyphen_list *ligature_node::get_hyphen_list(hyphen_list *tail)
{
 return n1->get_hyphen_list(n2->get_hyphen_list(tail));
}

node *ligature_node::add_self(node *n, hyphen_list **p)
{
 n = n1->add_self(n, p);
 n = n2->add_self(n, p);
 n1 = n2 = 0;
 delete this;
 return n;
}

kern_pair_node::kern_pair_node(hunits n, node *first, node *second, node *x)
    : node(x), n1(first), n2(second), amount(n)
{
}

dbreak_node::dbreak_node(node *n, node *p, node *x) 
    : node(x), none(n), pre(p), post(0)
{
}

node *dbreak_node::merge_glyph_node(glyph_node *gn)
{
 glyph_node *gn2 = (glyph_node *)gn->copy();
 node *new_none = none ? none->merge_glyph_node(gn) : 0;
 node *new_post = post ? post->merge_glyph_node(gn2) : 0;
 if (new_none == 0 && new_post == 0) {
   delete gn2;
   return 0;
 }
 if (new_none != 0)
   none = new_none;
 else {
   gn->next = none;
   none = gn;
 }
 if (new_post != 0)
   post = new_post;
 else {
   gn2->next = post;
   post = gn2;
 }
 return this;
}

node *kern_pair_node::merge_glyph_node(glyph_node *gn)
{
 node *nd = n2->merge_glyph_node(gn);
 if (nd == 0)
   return 0;
 n2 = nd;
 nd = n2->merge_self(n1);
 if (nd) {
   nd->next = next;
   n1 = 0;
   n2 = 0;
   delete this;
   return nd;
 }
 return this;
}


hunits kern_pair_node::italic_correction()
{
 return n2->italic_correction();
}

hunits kern_pair_node::subscript_correction()
{
 return n2->subscript_correction();
}

node *kern_pair_node::add_discretionary_hyphen()
{
 charinfo *hci = get_charinfo(HYPHEN_SYMBOL);
 tfont *tf = n2->get_tfont();
 if (tf) {
   if (tf->contains(hci)) {
     node *next1 = next;
     next = 0;
     node *n = copy();
     glyph_node *gn = new glyph_node(hci, tf);
     node *nn = n->merge_glyph_node(gn);
     if (nn == 0) {
       gn->next = n;
       nn = gn;
     }
     return new dbreak_node(this, nn, next1);
   }
 }
 return this;
}


kern_pair_node::~kern_pair_node()
{
 if (n1 != 0)
   delete n1;
 if (n2 != 0)
   delete n2;
}

dbreak_node::~dbreak_node()
{
 delete_node_list(pre);
 delete_node_list(post);
 delete_node_list(none);
}

node *kern_pair_node::copy()
{
 return new kern_pair_node(amount, n1->copy(), n2->copy());
}

node *copy_node_list(node *n)
{
 node *p = 0;
 while (n != 0) {
   node *nn = n->copy();
   nn->next = p;
   p = nn;
   n = n->next;
 }
 while (p != 0) {
   node *pp = p->next;
   p->next = n;
   n = p;
   p = pp;
 }
 return n;
}

void delete_node_list(node *n)
{
 while (n != 0) {
   node *tem = n;
   n = n->next;
   delete tem;
 }
}

node *dbreak_node::copy()
{
 dbreak_node *p = new dbreak_node(copy_node_list(none), copy_node_list(pre));
 p->post = copy_node_list(post);
 return p;
}

hyphen_list *node::get_hyphen_list(hyphen_list *tail)
{
 return tail;
}


hyphen_list *kern_pair_node::get_hyphen_list(hyphen_list *tail)
{
 return n1->get_hyphen_list(n2->get_hyphen_list(tail));
}

class hyphen_inhibitor_node : public node {
public:
 hyphen_inhibitor_node(node *nd = 0);
 node *copy();
 int same(node *);
 const char *type();
 hyphenation_type get_hyphenation_type();
};

hyphen_inhibitor_node::hyphen_inhibitor_node(node *nd) : node(nd)
{
}

node *hyphen_inhibitor_node::copy()
{
 return new hyphen_inhibitor_node;
}

int hyphen_inhibitor_node::same(node *)
{
 return 1;
}

const char *hyphen_inhibitor_node::type()
{
 return "hyphen_inhibitor_node";
}

hyphenation_type hyphen_inhibitor_node::get_hyphenation_type()
{
 return HYPHEN_INHIBIT;
}

/* add_discretionary_hyphen methods */

node *dbreak_node::add_discretionary_hyphen()
{
 if (post)
   post = post->add_discretionary_hyphen();
 if (none)
   none = none->add_discretionary_hyphen();
 return this;
}


node *node::add_discretionary_hyphen()
{
 tfont *tf = get_tfont();
 if (!tf)
   return new hyphen_inhibitor_node(this);
 charinfo *hci = get_charinfo(HYPHEN_SYMBOL);
 if (tf->contains(hci)) {
   node *next1 = next;
   next = 0;
   node *n = copy();
   glyph_node *gn = new glyph_node(hci, tf);
   node *n1 = n->merge_glyph_node(gn);
   if (n1 == 0) {
     gn->next = n;
     n1 = gn;
   }
   return new dbreak_node(this, n1, next1);
 }
 return this;
}


node *node::merge_self(node *)
{
 return 0;
}

node *node::add_self(node *n, hyphen_list ** /*p*/)
{
 next = n;
 return this;
}

node *kern_pair_node::add_self(node *n, hyphen_list **p)
{
 n = n1->add_self(n, p);
 n = n2->add_self(n, p);
 n1 = n2 = 0;
 delete this;
 return n;
}


hunits node::width()
{
 return H0;
}

node *node::last_char_node()
{
 return 0;
}

hunits hmotion_node::width()
{
 return n;
}

units node::size()
{
 return points_to_units(10);
}

hunits kern_pair_node::width()
{
 return n1->width() + n2->width() + amount;
}

node *kern_pair_node::last_char_node()
{
 node *nd = n2->last_char_node();
 if (nd)
   return nd;
 return n1->last_char_node();
}

hunits dbreak_node::width()
{
 hunits x = H0;
 for (node *n = none; n != 0; n = n->next)
   x += n->width();
 return x;
}

node *dbreak_node::last_char_node()
{
 for (node *n = none; n; n = n->next) {
   node *last = n->last_char_node();
   if (last)
     return last;
 }
 return 0;
}

hunits dbreak_node::italic_correction()
{
 return none ? none->italic_correction() : H0;
}

hunits dbreak_node::subscript_correction()
{
 return none ? none->subscript_correction() : H0;
}

class italic_corrected_node : public node {
 node *n;
 hunits x;
public:
 italic_corrected_node(node *, hunits, node * = 0);
 ~italic_corrected_node();
 node *copy();
 void ascii_print(ascii_output_file *);
 void asciify(macro *m);
 hunits width();
 node *last_char_node();
 void vertical_extent(vunits *, vunits *);
 int ends_sentence();
 int overlaps_horizontally();
 int overlaps_vertically();
 int same(node *);
 hyphenation_type get_hyphenation_type();
 tfont *get_tfont();
 hyphen_list *get_hyphen_list(hyphen_list *ss = 0);
 int character_type();
 void tprint(troff_output_file *);
 hunits subscript_correction();
 hunits skew();
 node *add_self(node *, hyphen_list **);
 const char *type();
};

node *node::add_italic_correction(hunits *width)
{
 hunits ic = italic_correction();
 if (ic.is_zero())
   return this;
 else {
   node *next1 = next;
   next = 0;
   *width += ic;
   return new italic_corrected_node(this, ic, next1);
 }
}

italic_corrected_node::italic_corrected_node(node *nn, hunits xx, node *p)
: n(nn), x(xx), node(p)
{
 assert(n != 0);
}

italic_corrected_node::~italic_corrected_node()
{
 delete n;
}

node *italic_corrected_node::copy()
{
 return new italic_corrected_node(n->copy(), x);
}

hunits italic_corrected_node::width()
{
 return n->width() + x;
}

void italic_corrected_node::vertical_extent(vunits *min, vunits *max)
{
 n->vertical_extent(min, max);
}

void italic_corrected_node::tprint(troff_output_file *out)
{
 n->tprint(out);
 out->right(x);
}

hunits italic_corrected_node::skew()
{
 return n->skew() - x/2;
}

hunits italic_corrected_node::subscript_correction()
{
 return n->subscript_correction() - x;
}

void italic_corrected_node::ascii_print(ascii_output_file *out)
{
 n->ascii_print(out);
}

int italic_corrected_node::ends_sentence()
{
 return n->ends_sentence();
}

int italic_corrected_node::overlaps_horizontally()
{
 return n->overlaps_horizontally();
}

int italic_corrected_node::overlaps_vertically()
{
 return n->overlaps_vertically();
}

node *italic_corrected_node::last_char_node()
{
 return n->last_char_node();
}

tfont *italic_corrected_node::get_tfont()
{
 return n->get_tfont();
}

hyphenation_type italic_corrected_node::get_hyphenation_type()
{
 return n->get_hyphenation_type();
}

node *italic_corrected_node::add_self(node *nd, hyphen_list **p)
{
 nd = n->add_self(nd, p);
 hunits not_interested;
 nd = nd->add_italic_correction(&not_interested);
 n = 0;
 delete this;
 return nd;
}

hyphen_list *italic_corrected_node::get_hyphen_list(hyphen_list *tail)
{
 return n->get_hyphen_list(tail);
}

int italic_corrected_node::character_type()
{
 return n->character_type();
}

class break_char_node : public node {
 node *ch;
 char break_code;
public:
 break_char_node(node *, int, node * = 0);
 ~break_char_node();
 node *copy();
 hunits width();
 vunits vertical_width();
 node *last_char_node();
 int character_type();
 int ends_sentence();
 node *add_self(node *, hyphen_list **);
 hyphen_list *get_hyphen_list(hyphen_list *s = 0);
 void tprint(troff_output_file *);
 void zero_width_tprint(troff_output_file *);
 void ascii_print(ascii_output_file *);
 void asciify(macro *m);
 hyphenation_type get_hyphenation_type();
 int overlaps_vertically();
 int overlaps_horizontally();
 units size();
 tfont *get_tfont();
 int same(node *);
 const char *type();
};

break_char_node::break_char_node(node *n, int c, node *x)
: node(x), ch(n), break_code(c)
{
}

break_char_node::~break_char_node()
{
 delete ch;
}

node *break_char_node::copy()
{
 return new break_char_node(ch->copy(), break_code);
}

hunits break_char_node::width()
{
 return ch->width();
}

vunits break_char_node::vertical_width()
{
 return ch->vertical_width();
}

node *break_char_node::last_char_node()
{
 return ch->last_char_node();
}

int break_char_node::character_type()
{
 return ch->character_type();
}

int break_char_node::ends_sentence()
{
 return ch->ends_sentence();
}

node *break_char_node::add_self(node *n, hyphen_list **p)
{
 assert((*p)->hyphenation_code == 0);
 if ((*p)->breakable && (break_code & 1)) {
   n = new space_node(H0, n);
   n->freeze_space();
 }
 next = n;
 n = this;
 if ((*p)->breakable && (break_code & 2)) {
   n = new space_node(H0, n);
   n->freeze_space();
 }
 hyphen_list *pp = *p;
 *p = (*p)->next;
 delete pp;
 return n;
}

hyphen_list *break_char_node::get_hyphen_list(hyphen_list *tail)
{
 return new hyphen_list(0, tail);
}

hyphenation_type break_char_node::get_hyphenation_type()
{
 return HYPHEN_MIDDLE;
}

void break_char_node::ascii_print(ascii_output_file *ascii)
{
 ch->ascii_print(ascii);
}

int break_char_node::overlaps_vertically()
{
 return ch->overlaps_vertically();
}

int break_char_node::overlaps_horizontally()
{
 return ch->overlaps_horizontally();
}

units break_char_node::size()
{
 return ch->size();
}

tfont *break_char_node::get_tfont()
{
 return ch->get_tfont();
}

node *extra_size_node::copy()
{ 
 return new extra_size_node(n); 
}

node *vertical_size_node::copy()
{ 
 return new vertical_size_node(n); 
}

node *hmotion_node::copy()
{ 
 return new hmotion_node(n);
}

node *space_char_hmotion_node::copy()
{
 return new space_char_hmotion_node(n);
}

node *vmotion_node::copy()
{ 
 return new vmotion_node(n);
}
 
node *dummy_node::copy()
{ 
 return new dummy_node;
}

node *transparent_dummy_node::copy()
{ 
 return new transparent_dummy_node;
}

hline_node::~hline_node()
{
 if (n)
   delete n;
}

node *hline_node::copy()
{
 return new hline_node(x, n ? n->copy() : 0);
}

hunits hline_node::width()
{
 return x < H0 ? H0 : x;
}


vline_node::~vline_node()
{
 if (n)
   delete n;
}

node *vline_node::copy()
{
 return new vline_node(x, n ? n->copy() : 0);
}

hunits vline_node::width()
{
 return n == 0 ? H0 : n->width();
}


zero_width_node::zero_width_node(node *nd) : n(nd)
{
}

zero_width_node::~zero_width_node()
{
 delete_node_list(n);
}

node *zero_width_node::copy()
{
 return new zero_width_node(copy_node_list(n));
}

int node_list_character_type(node *p)
{
 int t = 0;
 for (; p; p = p->next)
   t |= p->character_type();
 return t;
}

int zero_width_node::character_type()
{
 return node_list_character_type(n);
}

void node_list_vertical_extent(node *p, vunits *min, vunits *max)
{
 *min = V0;
 *max = V0;
 vunits cur_vpos = V0;
 vunits v1, v2;
 for (; p; p = p->next) {
   p->vertical_extent(&v1, &v2);
   v1 += cur_vpos;
   if (v1 < *min)
     *min = v1;
   v2 += cur_vpos;
   if (v2 > *max)
     *max = v2;
   cur_vpos += p->vertical_width();
 }
}

void zero_width_node::vertical_extent(vunits *min, vunits *max)
{
 node_list_vertical_extent(n, min, max);
}

overstrike_node::overstrike_node() : max_width(H0), list(0)
{
}

overstrike_node::~overstrike_node()
{
 delete_node_list(list);
}

node *overstrike_node::copy()
{
 overstrike_node *on = new overstrike_node;
 for (node *tem = list; tem; tem = tem->next)
   on->overstrike(tem->copy());
 return on;
}

void overstrike_node::overstrike(node *n)
{
 if (n == 0)
   return;
 hunits w = n->width();
 if (w > max_width)
   max_width = w;
 for (node **p = &list; *p; p = &(*p)->next)
   ;
 n->next = 0;
 *p = n;
}

hunits overstrike_node::width()
{
 return max_width;
}

bracket_node::bracket_node() : max_width(H0), list(0)
{
}

bracket_node::~bracket_node()
{
 delete_node_list(list);
}

node *bracket_node::copy()
{
 bracket_node *on = new bracket_node;
 for (node *tem = list; tem; tem = tem->next)
   on->bracket(tem->copy());
 return on;
}


void bracket_node::bracket(node *n)
{
 if (n == 0)
   return;
 hunits w = n->width();
 if (w > max_width)
   max_width = w;
 n->next = list;
 list = n;
}

hunits bracket_node::width()
{
 return max_width;
}

int node::nspaces()
{
 return 0;
}

int node::merge_space(hunits)
{
 return 0;
}

#if 0
space_node *space_node::free_list = 0;

void *space_node::operator new(size_t n)
{
 assert(n == sizeof(space_node));
 if (!free_list) {
   free_list = (space_node *)new char[sizeof(space_node)*BLOCK];
   for (int i = 0; i < BLOCK - 1; i++)
     free_list[i].next = free_list + i + 1;
   free_list[BLOCK-1].next = 0;
 }
 space_node *p = free_list;
 free_list = (space_node *)(free_list->next);
 p->next = 0;
 return p;
}

inline void space_node::operator delete(void *p)
{
 if (p) {
   ((space_node *)p)->next = free_list;
   free_list = (space_node *)p;
 }
}
#endif

space_node::space_node(hunits nn, node *p) : node(p), n(nn), set(0)
{
}

space_node::space_node(hunits nn, int s, node *p) : node(p), n(nn), set(s)
{
}

#if 0
space_node::~space_node()
{
}
#endif

node *space_node::copy()
{
 return new space_node(n, set);
}

int space_node::nspaces()
{
 return set ? 0 : 1;
}

int space_node::merge_space(hunits h)
{
 n += h;
 return 1;
}

hunits space_node::width()
{
 return n;
}

void node::spread_space(int*, hunits*)
{
}

void space_node::spread_space(int *nspaces, hunits *desired_space)
{
 if (!set) {
   assert(*nspaces > 0);
   if (*nspaces == 1) {
     n += *desired_space;
     *desired_space = H0;
   }
   else {
     hunits extra = *desired_space / *nspaces;
     *desired_space -= extra;
     n += extra;
   }
   *nspaces -= 1;
   set = 1;
 }
}

void node::freeze_space()
{
}

void space_node::freeze_space()
{
 set = 1;
}

diverted_space_node::diverted_space_node(vunits d, node *p)
: node(p), n(d)
{
}

node *diverted_space_node::copy()
{
 return new diverted_space_node(n);
}

diverted_copy_file_node::diverted_copy_file_node(symbol s, node *p)
: node(p), filename(s)
{
}

node *diverted_copy_file_node::copy()
{
 return new diverted_copy_file_node(filename);
}

int node::ends_sentence()
{
 return 0;
}

int kern_pair_node::ends_sentence()
{
 switch (n2->ends_sentence()) {
 case 0:
   return 0;
 case 1:
   return 1;
 case 2:
   break;
 default:
   assert(0);
 }
 return n1->ends_sentence();
}

int node_list_ends_sentence(node *n)
{
 for (; n != 0; n = n->next)
   switch (n->ends_sentence()) {
   case 0:
     return 0;
   case 1:
     return 1;
   case 2:
     break;
   default:
     assert(0);
   }
 return 2;
}

   
int dbreak_node::ends_sentence()
{
 return node_list_ends_sentence(none);
}


int node::overlaps_horizontally()
{
 return 0;
}

int node::overlaps_vertically()
{
 return 0;
}

int node::discardable()
{
 return 0;
}

int space_node::discardable()
{
 return set ? 0 : 1;
}


vunits node::vertical_width()
{
 return V0;
}

vunits vline_node::vertical_width()
{
 return x;
}

vunits vmotion_node::vertical_width()
{
 return n;
}

int node::character_type()
{
 return 0;
}

hunits node::subscript_correction()
{
 return H0;
}

hunits node::italic_correction()
{
 return H0;
}

hunits node::left_italic_correction()
{
 return H0;
}

hunits node::skew()
{
 return H0;
}


/* vertical_extent methods */

void node::vertical_extent(vunits *min, vunits *max)
{
 vunits v = vertical_width();
 if (v < V0) {
   *min = v;
   *max = V0;
 }
 else {
   *max = v;
   *min = V0;
 }
}

void vline_node::vertical_extent(vunits *min, vunits *max)
{
 if (n == 0)
   node::vertical_extent(min, max);
 else {
   vunits cmin, cmax;
   n->vertical_extent(&cmin, &cmax);
   vunits h = n->size();
   if (x < V0) {
     if (-x < h) {
       *min = x;
       *max = V0;
     }
     else {
       // we print the first character and then move up, so
       *max = cmax;
       // we print the last character and then move up h
       *min = cmin + h;
       if (*min > V0)
         *min = V0;
       *min += x;
     }
   }
   else {
     if (x < h) {
       *max = x;
       *min = V0;
     }
     else {
       // we move down by h and then print the first character, so
       *min = cmin + h;
       if (*min > V0)
         *min = V0;
       *max = x + cmax;
     }
   }
 }
}

/* ascii_print methods */


static void ascii_print_reverse_node_list(ascii_output_file *ascii, node *n)
{
 if (n == 0)
   return;
 ascii_print_reverse_node_list(ascii, n->next);
 n->ascii_print(ascii);
}

void dbreak_node::ascii_print(ascii_output_file *ascii)
{
 ascii_print_reverse_node_list(ascii, none);
}

void kern_pair_node::ascii_print(ascii_output_file *ascii)
{
 n1->ascii_print(ascii);
 n2->ascii_print(ascii);
}


void node::ascii_print(ascii_output_file *ascii)
{
}

void space_node::ascii_print(ascii_output_file *ascii)
{
 if (!n.is_zero())
   ascii->outc(' ');
}

void hmotion_node::ascii_print(ascii_output_file *ascii)
{
 // this is pretty arbitrary
 if (n >= points_to_units(2))
   ascii->outc(' ');
}

void space_char_hmotion_node::ascii_print(ascii_output_file *ascii)
{
 ascii->outc(' ');
}

/* asciify methods */

void node::asciify(macro *m)
{
 m->append(this);
}
     
void glyph_node::asciify(macro *m)
{
 unsigned char c = ci->get_ascii_code();
 if (c != 0) {
   m->append(c);
   delete this;
 }
 else
   m->append(this);
}

void kern_pair_node::asciify(macro *m)
{
 n1->asciify(m);
 n2->asciify(m);
 n1 = n2 = 0;
 delete this;
}

static void asciify_reverse_node_list(macro *m, node *n)
{
 if (n == 0)
   return;
 asciify_reverse_node_list(m, n->next);
 n->asciify(m);
}

void dbreak_node::asciify(macro *m)
{
 asciify_reverse_node_list(m, none);
 none = 0;
 delete this;
}

void ligature_node::asciify(macro *m)
{
 n1->asciify(m);
 n2->asciify(m);
 n1 = n2 = 0;
 delete this;
}

void composite_node::asciify(macro *m)
{
 unsigned char c = ci->get_ascii_code();
 if (c != 0) {
   m->append(c);
   delete this;
 }
 else
   m->append(this);
}

void break_char_node::asciify(macro *m)
{
 ch->asciify(m);
 ch = 0;
 delete this;
}

void italic_corrected_node::asciify(macro *m)
{
 n->asciify(m);
 n = 0;
 delete this;
}

void left_italic_corrected_node::asciify(macro *m)
{
 if (n) {
   n->asciify(m);
   n = 0;
 }
 delete this;
}

space_char_hmotion_node::space_char_hmotion_node(hunits i, node *next)
: hmotion_node(i, next)
{
}

void space_char_hmotion_node::asciify(macro *m)
{
 m->append(' ');
 delete this;
}

void line_start_node::asciify(macro *)
{
 delete this;
}

void vertical_size_node::asciify(macro *)
{
 delete this;
}

breakpoint *node::get_breakpoints(hunits /*width*/, int /*nspaces*/,
                                 breakpoint *rest, int /*is_inner*/)
{
 return rest;
}

int node::nbreaks()
{
 return 0;
}

breakpoint *space_node::get_breakpoints(hunits width, int ns, breakpoint *rest,
                           int is_inner)
{
 if (next->discardable())
   return rest;
 breakpoint *bp = new breakpoint;
 bp->next = rest;
 bp->width = width;
 bp->nspaces = ns;
 bp->hyphenated = 0;
 if (is_inner) {
   assert(rest != 0);
   bp->index = rest->index + 1;
   bp->nd = rest->nd;
 }
 else {
   bp->nd = this;
   bp->index = 0;
 }
 return bp;
}

int space_node::nbreaks()
{
 if (next->discardable())
   return 0;
 else
   return 1;
}

static breakpoint *node_list_get_breakpoints(node *p, hunits *widthp,
                                            int ns, breakpoint *rest)
{
 if (p != 0) {
   rest = p->get_breakpoints(*widthp, 
                             ns, 
                             node_list_get_breakpoints(p->next, widthp, ns,
                                                       rest),
                             1);
   *widthp += p->width();
 }
 return rest;
}


breakpoint *dbreak_node::get_breakpoints(hunits width, int ns,
                                        breakpoint *rest, int is_inner)
{
 breakpoint *bp = new breakpoint;
 bp->next = rest;
 bp->width = width;
 for (node *tem = pre; tem != 0; tem = tem->next)
   bp->width += tem->width();
 bp->nspaces = ns;
 bp->hyphenated = 1;
 if (is_inner) {
   assert(rest != 0);
   bp->index = rest->index + 1;
   bp->nd = rest->nd;
 }
 else {
   bp->nd = this;
   bp->index = 0;
 }
 return node_list_get_breakpoints(none, &width, ns, bp);
}

int dbreak_node::nbreaks()
{
 int i = 1;
 for (node *tem = none; tem != 0; tem = tem->next)
   i += tem->nbreaks();
 return i;
}

void node::split(int /*where*/, node ** /*prep*/, node ** /*postp*/)
{
 assert(0);
}

void space_node::split(int where, node **pre, node **post)
{
 assert(where == 0);
 *pre = next;
 *post = 0;
 delete this;
}

static void node_list_split(node *p, int *wherep, node **prep, node **postp)
{
 if (p == 0)
   return;
 int nb = p->nbreaks();
 node_list_split(p->next, wherep, prep, postp);
 if (*wherep < 0) {
   p->next = *postp;
   *postp = p;
 }
 else if (*wherep < nb) {
   p->next = *prep;
   p->split(*wherep, prep, postp);
 }
 else {
   p->next = *prep;
   *prep = p;
 }
 *wherep -= nb;
}

void dbreak_node::split(int where, node **prep, node **postp)
{
 assert(where >= 0);
 if (where == 0) {
   *postp = post;
   post = 0;
   if (pre == 0)
     *prep = next;
   else {
     for (node *tem = pre; tem->next != 0; tem = tem->next)
       ;
     tem->next = next;
     *prep = pre;
   }
   pre = 0;
   delete this;
 }
 else {
   *prep = next;
   where -= 1;
   node_list_split(none, &where, prep, postp);
   none = 0;
   delete this;
 }
}
 

hyphenation_type node::get_hyphenation_type()
{
 return HYPHEN_BOUNDARY;
}


hyphenation_type dbreak_node::get_hyphenation_type()
{
 return HYPHEN_INHIBIT;
}

hyphenation_type kern_pair_node::get_hyphenation_type()
{
 return HYPHEN_MIDDLE;
}

hyphenation_type dummy_node::get_hyphenation_type()
{
 return HYPHEN_MIDDLE;
}

hyphenation_type transparent_dummy_node::get_hyphenation_type()
{
 return HYPHEN_MIDDLE;
}

int node::interpret(macro *)
{
 return 0;
}

special_node::special_node(const macro &m)
: mac(m)
{
}

int special_node::same(node *n)
{
 return mac == ((special_node *)n)->mac;
}

const char *special_node::type()
{
 return "special_node";
}

node *special_node::copy()
{
 return new special_node(mac);
}

void special_node::tprint_start(troff_output_file *out)
{
 out->start_special();
}

void special_node::tprint_char(troff_output_file *out, unsigned char c)
{
 out->special_char(c);
}

void special_node::tprint_end(troff_output_file *out)
{
 out->end_special();
}

/* composite_node */

composite_node::composite_node(node *p, charinfo *c, font_size s, node *x)
    : node(x), n(p), ci(c), sz(s)
{
}

composite_node::~composite_node()
{
 delete_node_list(n);
}

node *composite_node::copy()
{
 return new composite_node(copy_node_list(n), ci, sz);
}

hunits composite_node::width()
{
 hunits x = H0;
 for (node *tem = n; tem; tem = tem->next)
   x += tem->width();
 return x;
}

node *composite_node::last_char_node()
{
 return this;
}

vunits composite_node::vertical_width()
{
 vunits v = V0;
 for (node *tem = n; tem; tem = tem->next)
   v += tem->vertical_width();
 return v;
}

units composite_node::size()
{
 return sz.to_units();
}

hyphenation_type composite_node::get_hyphenation_type()
{
 return HYPHEN_MIDDLE;
}

int composite_node::overlaps_horizontally()
{
 return ci->overlaps_horizontally();
}

int composite_node::overlaps_vertically()
{
 return ci->overlaps_vertically();
}

void composite_node::ascii_print(ascii_output_file *ascii)
{
 unsigned char c = ci->get_ascii_code();
 if (c != 0)
   ascii->outc(c);
 else
   ascii->outs(ci->nm.contents());

}

hyphen_list *composite_node::get_hyphen_list(hyphen_list *tail)
{
 return new hyphen_list(ci->get_hyphenation_code(), tail);

}

node *composite_node::add_self(node *nn, hyphen_list **p)
{
 assert(ci->get_hyphenation_code() == (*p)->hyphenation_code);
 next = nn;
 nn = this;
 if ((*p)->hyphen)
   nn = nn->add_discretionary_hyphen();
 hyphen_list *pp = *p;
 *p = (*p)->next;
 delete pp;
 return nn;
}

tfont *composite_node::get_tfont()
{
 if (n)
   return n->get_tfont();
 else
   return 0;
}

node *reverse_node_list(node *n)
{
 node *r = 0;
 while (n) {
   node *tem = n;
   n = n->next;
   tem->next = r;
   r = tem;
 }
 return r;
}

void composite_node::vertical_extent(vunits *min, vunits *max)
{
 n = reverse_node_list(n);
 node_list_vertical_extent(n, min, max);
 n = reverse_node_list(n);
}

word_space_node::word_space_node(hunits d, node *x) : space_node(d, x)
{
}

word_space_node::word_space_node(hunits d, int s, node *x)
: space_node(d, s, x)
{
}

node *word_space_node::copy()
{
 return new word_space_node(n, set);
}

void word_space_node::tprint(troff_output_file *out)
{
 out->word_marker();
 space_node::tprint(out);
}


hvpair::hvpair()
{
}

draw_node::draw_node(char c, hvpair *p, int np, font_size s)
    : code(c), npoints(np), sz(s)
{
 point = new hvpair[npoints];
 for (int i = 0; i < npoints; i++)
   point[i] = p[i];
}

int draw_node::same(node *n)
{
 draw_node *nd = (draw_node *)n;
 if (code != nd->code || npoints != nd->npoints || sz != nd->sz)
   return 0;
 for (int i = 0; i < npoints; i++)
   if (point[i].h != nd->point[i].h || point[i].v != nd->point[i].v)
     return 0;
 return 1;
}

const char *draw_node::type()
{
 return "draw_node";
}

draw_node::~draw_node()
{
 if (point)
   delete point;
}

hunits draw_node::width()
{
 hunits x = H0;
 for (int i = 0; i < npoints; i++)
   x += point[i].h;
 return x;
}

vunits draw_node::vertical_width()
{
 if (code == 'e')
   return V0;
 vunits x = V0;
 for (int i = 0; i < npoints; i++)
   x += point[i].v;
 return x;
}

node *draw_node::copy()
{
 return new draw_node(code, point, npoints, sz);
}

void draw_node::tprint(troff_output_file *out)
{
 out->draw(code, point, npoints, sz);
}
 
/* tprint methods */

void glyph_node::tprint(troff_output_file *out)
{
 tfont *ptf = tf->get_plain();
 if (ptf == tf)
   out->put_char_width(ci, ptf, width(), H0);
 else {
   hunits offset;
   int bold = tf->get_bold(&offset);
   hunits w = ptf->get_width(ci);
   hunits k = H0;
   hunits x;
   int cs = tf->get_constant_space(&x);
   if (cs) {
     x -= w;
     if (bold)
       x -= offset;
     hunits x2 = x/2;
     out->right(x2);
     k = x - x2;
   }
   else
     k = tf->get_track_kern();
   if (bold) {
     out->put_char(ci, ptf);
     out->right(offset);
   }
   out->put_char_width(ci, ptf, w, k);
 }
}

void glyph_node::zero_width_tprint(troff_output_file *out)
{
 tfont *ptf = tf->get_plain();
 hunits offset;
 int bold = tf->get_bold(&offset);
 hunits x;
 int cs = tf->get_constant_space(&x);
 if (cs) {
   x -= ptf->get_width(ci);
   if (bold)
     x -= offset;
   x = x/2;
   out->right(x);
 }
 out->put_char(ci, ptf);
 if (bold) {
   out->right(offset);
   out->put_char(ci, ptf);
   out->right(-offset);
 }
 if (cs)
   out->right(-x);
}

void break_char_node::tprint(troff_output_file *t)
{
 ch->tprint(t);
}

void break_char_node::zero_width_tprint(troff_output_file *t)
{
 ch->zero_width_tprint(t);
}

void hline_node::tprint(troff_output_file *out)
{
 if (x < H0) {
   out->right(x);
   x = -x;
 }
 if (n == 0) {
   out->right(x);
   return;
 }
 hunits w = n->width();
 if (w <= H0) {
   error("horizontal line drawing character must have positive width");
   out->right(x);
   return;
 }
 int i = int(x/w);
 if (i == 0) {
   hunits xx = x - w;
   hunits xx2 = xx/2;
   out->right(xx2);
   n->tprint(out);
   out->right(xx - xx2);
 }
 else {
   hunits rem = x - w*i;
   if (rem > H0)
     if (n->overlaps_horizontally()) {
       n->tprint(out);
       out->right(rem - w);
     }
     else
       out->right(rem);
   while (--i >= 0)
     n->tprint(out);
 }
}

void vline_node::tprint(troff_output_file *out)
{
 if (n == 0) {
   out->down(x);
   return;
 }
 vunits h = n->size();
 int overlaps = n->overlaps_vertically();
 vunits y = x;
 if (y < V0) {
   y = -y;
   int i = y / h;
   vunits rem = y - i*h;
   if (i == 0) {
     out->right(n->width());
     out->down(-rem);
   }
   else {
     while (--i > 0) {
       n->zero_width_tprint(out);
       out->down(-h);
     }
     if (overlaps) {
       n->zero_width_tprint(out);
       out->down(-rem);
       n->tprint(out);
       out->down(-h);
     }
     else {
       n->tprint(out);
       out->down(-h - rem);
     }
   }
 }
 else {
   int i = y / h;
   vunits rem = y - i*h;
   if (i == 0) {
     out->down(rem);
     out->right(n->width());
   }
   else {
     out->down(h);
     if (overlaps)
       n->zero_width_tprint(out);
     out->down(rem);
     while (--i > 0) {
       n->zero_width_tprint(out);
       out->down(h);
     }
     n->tprint(out);
   }
 }
}

void zero_width_node::tprint(troff_output_file *out)
{
 if (!n)
   return;
 if (!n->next) {
   n->zero_width_tprint(out);
   return;
 }
 int hpos = out->get_hpos();
 int vpos = out->get_vpos();
 node *tem = n;
 while (tem) {
   tem->tprint(out);
   tem = tem->next;
 }
 out->moveto(hpos, vpos);
}

void overstrike_node::tprint(troff_output_file *out)
{
 hunits pos = H0;
 for (node *tem = list; tem; tem = tem->next) {
   hunits x = (max_width - tem->width())/2;
   out->right(x - pos);
   pos = x;
   tem->zero_width_tprint(out);
 }
 out->right(max_width - pos);
}

void bracket_node::tprint(troff_output_file *out)
{
 if (list == 0)
   return;
 int npieces = 0;
 for (node *tem = list; tem; tem = tem->next)
   ++npieces;
 vunits h = list->size();
 vunits totalh = h*npieces;
 vunits y = (totalh + h)/2;
 out->down(y);
 for (tem = list; tem; tem = tem->next) {
   tem->zero_width_tprint(out);
   out->down(-h);
 }
 out->right(max_width);
 out->down(totalh - y);
}

void node::tprint(troff_output_file *out)
{
}

void node::zero_width_tprint(troff_output_file *out)
{
 int hpos = out->get_hpos();
 int vpos = out->get_vpos();
 tprint(out);
 out->moveto(hpos, vpos);
}

void space_node::tprint(troff_output_file *out)
{
 out->right(n);
}

void hmotion_node::tprint(troff_output_file *out)
{
 out->right(n);
}

void vmotion_node::tprint(troff_output_file *out)
{
 out->down(n);
}

void kern_pair_node::tprint(troff_output_file *out)
{
 n1->tprint(out);
 out->right(amount);
 n2->tprint(out);
}

static void tprint_reverse_node_list(troff_output_file *out, node *n)
{
 if (n == 0)
   return;
 tprint_reverse_node_list(out, n->next);
 n->tprint(out);
}

void dbreak_node::tprint(troff_output_file *out)
{
 tprint_reverse_node_list(out, none);
}

void composite_node::tprint(troff_output_file *out)
{
 tprint_reverse_node_list(out, n);
}

node *make_glyph_node(charinfo *s, environment *env, int no_error_message = 0)
{
 int fontno = env_definite_font(env);
 if (fontno < 0) {
   error("no current font");
   return 0;
 }
 assert(fontno < font_table_size && font_table[fontno] != 0);
 int fn = fontno;
 int found = font_table[fontno]->contains(s);
 if (!found) {
   if (s->numbered()) {
     if (!no_error_message)
       warning(WARN_CHAR, "can't find numbered character %1",
               s->get_number());
     return 0;
   }
   special_font_list *sf = font_table[fontno]->sf;
   while (sf != 0 && !found) {
     fn = sf->n;
     if (font_table[fn])
       found = font_table[fn]->contains(s);
     sf = sf->next;
   }
   if (!found) {
     sf = global_special_fonts;
     while (sf != 0 && !found) {
       fn = sf->n;
       if (font_table[fn])
         found = font_table[fn]->contains(s);
       sf = sf->next;
     }
   }
   if (!found
#if 0   
       && global_special_fonts == 0 && font_table[fontno]->sf == 0
#endif
       ) {
     for (fn = 0; fn < font_table_size; fn++)
       if (font_table[fn] 
           && font_table[fn]->is_special()
           && font_table[fn]->contains(s)) {
             found = 1;
             break;
           }
   }
   if (!found) {
     if (!no_error_message && s->first_time_not_found()) {
       unsigned char input_code = s->get_ascii_code();
       if (input_code != 0) {
         if (csgraph(input_code))
           warning(WARN_CHAR, "can't find character `%1'", input_code);
         else
           warning(WARN_CHAR, "can't find character with input code %1",
                   int(input_code));
       }
       else
         warning(WARN_CHAR, "can't find special character `%1'",
                 s->nm.contents());
     }
     return 0;
   }
 }
 font_size fs = env->get_font_size();
 int char_height = env->get_char_height();
 int char_slant = env->get_char_slant();
 tfont *tf = font_table[fontno]->get_tfont(fs, char_height, char_slant, fn);
 return new glyph_node(s, tf);
}

node *make_node(charinfo *ci, environment *env)
{
 switch (ci->get_special_translation()) {
 case charinfo::TRANSLATE_SPACE:
   return new space_char_hmotion_node(env->get_space_width());
 case charinfo::TRANSLATE_DUMMY:
   return new dummy_node;
 }
 charinfo *tem = ci->get_translation();
 if (tem)
   ci = tem;
 macro *mac = ci->get_macro();
 if (mac)
   return charinfo_to_node(ci, env);
 else
   return make_glyph_node(ci, env);
}

int character_exists(charinfo *ci, environment *env)
{
 if (ci->get_special_translation() != charinfo::TRANSLATE_NONE)
   return 1;
 charinfo *tem = ci->get_translation();
 if (tem)
   ci = tem;
 if (ci->get_macro())
   return 1;
 node *nd = make_glyph_node(ci, env, 1);
 if (nd) {
   delete nd;
   return 1;
 }
 return 0;
}

node *node::add_char(charinfo *ci, environment *env, hunits *widthp)
{
 node *res;
 switch (ci->get_special_translation()) {
 case charinfo::TRANSLATE_SPACE:
   res = new space_char_hmotion_node(env->get_space_width(), this);
   *widthp += res->width();
   return res;
 case charinfo::TRANSLATE_DUMMY:
   return new dummy_node(this);
 }
 charinfo *tem = ci->get_translation();
 if (tem)
   ci = tem;
 macro *mac = ci->get_macro();
 if (mac) {
   res = charinfo_to_node(ci, env);
   if (res) {
     res->next = this;
     *widthp += res->width();
   }
   else
     return this;
 }
 else {
   node *gn = make_glyph_node(ci, env);
   if (gn == 0)
     return this;
   else {
     hunits old_width = width();
     node *p = gn->merge_self(this);
     if (p == 0) {
       *widthp += gn->width();
       gn->next = this;
       res = gn;
     }
     else {
       *widthp += p->width() - old_width;
       res = p;
     }
   }
 }
 int break_code = 0;
 if (ci->can_break_before())
   break_code = 1;
 if (ci->can_break_after())
   break_code |= 2;
 if (break_code) {
   node *next1 = res->next;
   res->next = 0;
   res = new break_char_node(res, break_code, next1);
 }
 return res;
}


#ifdef __GNUG__
inline
#endif
int same_node(node *n1, node *n2)
{
 if (n1 != 0) {
   if (n2 != 0)
     return n1->type() == n2->type() && n1->same(n2);
   else
     return 0;
 }
 else
   return n2 == 0;
}

int same_node_list(node *n1, node *n2)
{
 while (n1 && n2) {
   if (n1->type() != n2->type() || !n1->same(n2))
     return 0;
   n1 = n1->next;
   n2 = n2->next;
 }
 return !n1 && !n2;
}

int extra_size_node::same(node *nd)
{
 return n == ((extra_size_node *)nd)->n;
}

const char *extra_size_node::type()
{
 return "extra_size_node";
}

int vertical_size_node::same(node *nd)
{
 return n == ((vertical_size_node *)nd)->n;
}

const char *vertical_size_node::type()
{
 return "vertical_size_node";
}

int hmotion_node::same(node *nd)
{
 return n == ((hmotion_node *)nd)->n;
}

const char *hmotion_node::type()
{
 return "hmotion_node";
}

int space_char_hmotion_node::same(node *nd)
{
 return n == ((space_char_hmotion_node *)nd)->n;
}

const char *space_char_hmotion_node::type()
{
 return "space_char_hmotion_node";
}

int vmotion_node::same(node *nd)
{
 return n == ((vmotion_node *)nd)->n;
}

const char *vmotion_node::type()
{
 return "vmotion_node";
}

int hline_node::same(node *nd)
{
 return x == ((hline_node *)nd)->x && same_node(n, ((hline_node *)nd)->n);
}

const char *hline_node::type()
{
 return "hline_node";
}

int vline_node::same(node *nd)
{
 return x == ((vline_node *)nd)->x && same_node(n, ((vline_node *)nd)->n);
}

const char *vline_node::type()
{
 return "vline_node";
}

int dummy_node::same(node * /*nd*/)
{
 return 1;
}

const char *dummy_node::type()
{
 return "dummy_node";
}

int transparent_dummy_node::same(node * /*nd*/)
{
 return 1;
}

const char *transparent_dummy_node::type()
{
 return "transparent_dummy_node";
}

int transparent_dummy_node::ends_sentence()
{
 return 2;
}

int zero_width_node::same(node *nd)
{
 return same_node_list(n, ((zero_width_node *)nd)->n);
}

const char *zero_width_node::type()
{
 return "zero_width_node";
}

int italic_corrected_node::same(node *nd)
{
 return (x == ((italic_corrected_node *)nd)->x
         && same_node(n, ((italic_corrected_node *)nd)->n));
}

const char *italic_corrected_node::type()
{
 return "italic_corrected_node";
}


left_italic_corrected_node::left_italic_corrected_node(node *x)
: n(0), node(x)
{
}

left_italic_corrected_node::~left_italic_corrected_node()
{
 delete n;
}

node *left_italic_corrected_node::merge_glyph_node(glyph_node *gn)
{
 if (n == 0) {
   hunits lic = gn->left_italic_correction();
   if (!lic.is_zero()) {
     x = lic;
     n = gn;
     return this;
   }
 }
 else {
   node *nd = n->merge_glyph_node(gn);
   if (nd) {
     n = nd;
     x = n->left_italic_correction();
     return this;
   }
 }
 return 0;
}

node *left_italic_corrected_node::copy()
{
 left_italic_corrected_node *nd = new left_italic_corrected_node;
 if (n) {
   nd->n = n->copy();
   nd->x = x;
 }
 return nd;
}

void left_italic_corrected_node::tprint(troff_output_file *out)
{
 if (n) {
   out->right(x);
   n->tprint(out);
 }
}

const char *left_italic_corrected_node::type()
{
 return "left_italic_corrected_node";
}

int left_italic_corrected_node::same(node *nd)
{
 return (x == ((left_italic_corrected_node *)nd)->x
         && same_node(n, ((left_italic_corrected_node *)nd)->n));
}

void left_italic_corrected_node::ascii_print(ascii_output_file *out)
{
 if (n)
   n->ascii_print(out);
}

hunits left_italic_corrected_node::width()
{
 return n ? n->width() + x : H0;
}

void left_italic_corrected_node::vertical_extent(vunits *min, vunits *max)
{
 if (n)
   n->vertical_extent(min, max);
 else
   node::vertical_extent(min, max);
}

hunits left_italic_corrected_node::skew()
{
 return n ? n->skew() + x/2 : H0;
}

hunits left_italic_corrected_node::subscript_correction()
{
 return n ? n->subscript_correction() : H0;
}

hunits left_italic_corrected_node::italic_correction()
{
 return n ? n->italic_correction() : H0;
}

int left_italic_corrected_node::ends_sentence()
{
 return n ? n->ends_sentence() : 0;
}

int left_italic_corrected_node::overlaps_horizontally()
{
 return n ? n->overlaps_horizontally() : 0;
}

int left_italic_corrected_node::overlaps_vertically()
{
 return n ? n->overlaps_vertically() : 0;
}

node *left_italic_corrected_node::last_char_node()
{
 return n ? n->last_char_node() : 0;
}

tfont *left_italic_corrected_node::get_tfont()
{
 return n ? n->get_tfont() : 0;
}

hyphenation_type left_italic_corrected_node::get_hyphenation_type()
{
 if (n)
   return n->get_hyphenation_type();
 else
   return HYPHEN_MIDDLE;
}

hyphen_list *left_italic_corrected_node::get_hyphen_list(hyphen_list *tail)
{
 return n ? n->get_hyphen_list(tail) : tail;
}

node *left_italic_corrected_node::add_self(node *nd, hyphen_list **p)
{
 if (n) {
   nd = new left_italic_corrected_node(nd);
   nd = n->add_self(nd, p);
   n = 0;
   delete this;
 }
 return nd;
}

int left_italic_corrected_node::character_type()
{
 return n ? n->character_type() : 0;
}

int overstrike_node::same(node *nd)
{
 return same_node_list(list, ((overstrike_node *)nd)->list);
}

const char *overstrike_node::type()
{
 return "overstrike_node";
}

int bracket_node::same(node *nd)
{
 return same_node_list(list, ((bracket_node *)nd)->list);
}

const char *bracket_node::type()
{
 return "bracket_node";
}

int composite_node::same(node *nd)
{
 return ci == ((composite_node *)nd)->ci
   && same_node_list(n, ((composite_node *)nd)->n);
}

const char *composite_node::type()
{
 return "composite_node";
}

int glyph_node::same(node *nd)
{
 return ci == ((glyph_node *)nd)->ci && tf == ((glyph_node *)nd)->tf;
}

const char *glyph_node::type()
{
 return "glyph_node";
}

int ligature_node::same(node *nd)
{
 return (same_node(n1, ((ligature_node *)nd)->n1) 
         && same_node(n2, ((ligature_node *)nd)->n2)
         && glyph_node::same(nd));
}

const char *ligature_node::type()
{
 return "ligature_node";
}

int kern_pair_node::same(node *nd)
{
 return (amount == ((kern_pair_node *)nd)->amount
         && same_node(n1, ((kern_pair_node *)nd)->n1)
         && same_node(n2, ((kern_pair_node *)nd)->n2));
}

const char *kern_pair_node::type()
{
 return "kern_pair_node";
}

int dbreak_node::same(node *nd)
{
 return (same_node_list(none, ((dbreak_node *)nd)->none)
         && same_node_list(pre, ((dbreak_node *)nd)->pre)
         && same_node_list(post, ((dbreak_node *)nd)->post));
}

const char *dbreak_node::type()
{
 return "dbreak_node";
}

int break_char_node::same(node *nd)
{
 return (break_code == ((break_char_node *)nd)->break_code
         && same_node(ch, ((break_char_node *)nd)->ch));
}

const char *break_char_node::type()
{
 return "break_char_node";
}

int line_start_node::same(node * /*nd*/)
{
 return 1;
}

const char *line_start_node::type()
{
 return "line_start_node";
}

int space_node::same(node *nd)
{
 return n == ((space_node *)nd)->n && set == ((space_node *)nd)->set;
}

const char *space_node::type()
{
 return "space_node";
}

int word_space_node::same(node *nd)
{
 return (n == ((word_space_node *)nd)->n
         && set == ((word_space_node *)nd)->set);
}

const char *word_space_node::type()
{
 return "word_space_node";
}

int diverted_space_node::same(node *nd)
{
 return n == ((diverted_space_node *)nd)->n;
}

const char *diverted_space_node::type()
{
 return "diverted_space_node";
}

int diverted_copy_file_node::same(node *nd)
{
 return filename == ((diverted_copy_file_node *)nd)->filename;
}

const char *diverted_copy_file_node::type()
{
 return "diverted_copy_file_node";
}

// Grow the font_table so that its size is > n.

static void grow_font_table(int n)
{
 assert(n >= font_table_size);
 font_info **old_font_table = font_table;
 int old_font_table_size = font_table_size;
 font_table_size = font_table_size ? (font_table_size*3)/2 : 10;
 if (font_table_size <= n)
   font_table_size = n + 10;
 font_table = new font_info *[font_table_size];
 if (old_font_table_size)
   memcpy(font_table, old_font_table,
          old_font_table_size*sizeof(font_info *));
 for (int i = old_font_table_size; i < font_table_size; i++)
   font_table[i] = 0;
}

dictionary font_translation_dictionary(17);

static symbol get_font_translation(symbol nm)
{
 void *p = font_translation_dictionary.lookup(nm);
 return p ? symbol((char *)p) : nm;
}

dictionary font_dictionary(50);

static int mount_font_no_translate(int n, symbol name, symbol external_name)
{
 assert(n >= 0);
 // We store the address of this char in font_dictionary to indicate
 // that we've previously tried to mount the font and failed.
 static char a_char;
 font *fm = 0;
 void *p = font_dictionary.lookup(external_name);
 if (p == 0) {
   fm = font::load_font(external_name.contents());
   if (!fm) {
     font_dictionary.lookup(external_name, &a_char);
     return 0;
   }
   font_dictionary.lookup(name, fm);
 }
 else if (p == &a_char) {
   error("invalid font `%1'", external_name.contents());
   return 0;
 }
 else
   fm = (font*)p;
 if (n >= font_table_size) {
   if (n - font_table_size > 1000) {
     error("font position too much larger than first unused position");
     return 0;
   }
   grow_font_table(n);
 }
 else if (font_table[n] != 0)
   delete font_table[n];
 font_table[n] = new font_info(name, n, external_name, fm);
 invalidate_fontno(n);
 return 1;
}

int mount_font(int n, symbol name, symbol external_name)
{
 assert(n >= 0);
 name = get_font_translation(name);
 if (external_name.is_null())
   external_name = name;
 else
   external_name = get_font_translation(external_name);
 return mount_font_no_translate(n, name, external_name);
}

void mount_style(int n, symbol name)
{
 assert(n >= 0);
 if (n >= font_table_size) {
   if (n - font_table_size > 1000) {
     error("font position too much larger than first unused position");
     return;
   }
   grow_font_table(n);
 }
 else if (font_table[n] != 0)
   delete font_table[n];
 font_table[n] = new font_info(get_font_translation(name), n, NULL_SYMBOL, 0);
 invalidate_fontno(n);
}

/* global functions */

void font_translate()
{
 symbol from = get_name(1);
 if (!from.is_null()) {
   symbol to = get_name();
   if (to.is_null() || from == to)
     font_translation_dictionary.remove(from);
   else
     font_translation_dictionary.lookup(from, (void *)to.contents());
 }
 skip_line();
}

void font_position()
{
 int n;
 if (get_integer(&n)) {
   if (n < 0)
     error("negative font position");
   else {
     symbol internal_name = get_name(1);
     if (!internal_name.is_null()) {
       symbol external_name = get_long_name(0);
       mount_font(n, internal_name, external_name); // ignore error
     }
   }
 }
 skip_line();
}

font_family::font_family(symbol s)
: nm(s), map_size(10)
{
 map = new int[map_size];
 for (int i = 0; i < map_size; i++)
   map[i] = -1;
}

font_family::~font_family()
{
 delete map;
}

int font_family::make_definite(int i)
{
 if (i >= 0) {
   if (i < map_size && map[i] >= 0)
     return map[i];
   else {
     if (i < font_table_size && font_table[i] != 0) {
       if (i >= map_size) {
         int old_map_size = map_size;
         int *old_map = map;
         map_size *= 3;
         map_size /= 2;
         if (i >= map_size)
           map_size = i + 10;
         map = new int[map_size];
         memcpy(map, old_map, old_map_size*sizeof(int));
         delete old_map;
         for (int j = old_map_size; j < map_size; j++)
           map[j] = -1;
       }
       if (font_table[i]->is_style()) {
         symbol sty = font_table[i]->get_name();
         symbol f = concat(nm, sty);
         int n;
         // don't use symbol_fontno, because that might return a style
         // and because we don't want to translate the name
         for (n = 0; n < font_table_size; n++)
           if (font_table[n] != 0 && font_table[n]->is_named(f)
               && !font_table[n]->is_style())
             break;
         if (n >= font_table_size) {
           n = next_available_font_position();
           if (!mount_font_no_translate(n, f, f))
             return -1;
         }
         return map[i] = n;
       }
       else
         return map[i] = i;
     }
     else
       return -1;
   }
 }
 else
   return -1;
}

dictionary family_dictionary(5);

font_family *lookup_family(symbol nm)
{
 font_family *f = (font_family *)family_dictionary.lookup(nm);
 if (!f) {
   f = new font_family(nm);
   (void)family_dictionary.lookup(nm, f);
 }
 return f;
} 

static void invalidate_fontno(int n)
{
 assert(n >= 0 && n < font_table_size);
 dictionary_iterator iter(family_dictionary);
 symbol nm;
 font_family *fam;
 while (iter.get(&nm, (void **)&fam)) {
   int map_size = fam->map_size;
   if (n < map_size)
     fam->map[n] = -1;
   for (int i = 0; i < map_size; i++)
     if (fam->map[i] == n)
       fam->map[i] = -1;
 }
}

void style()
{
 int n;
 if (get_integer(&n)) {
   if (n < 0)
     error("negative font position");
   else {
     symbol internal_name = get_name(1);
     if (!internal_name.is_null())
       mount_style(n, internal_name);
   }
 }
 skip_line();
}

static int get_fontno()
{
 int n;
 tok.skip();
 if (tok.delimiter()) {
   symbol s = get_name(1);
   if (!s.is_null()) {
     n = symbol_fontno(s);
     if (n < 0) {
       n = next_available_font_position();
       if (!mount_font(n, s))
         return -1;
     }
     return curenv->get_family()->make_definite(n);
   }
 }
 else if (get_integer(&n)) {
   if (n < 0 || n >= font_table_size || font_table[n] == 0)
     error("bad font number");
   else
     return curenv->get_family()->make_definite(n);
 }
 return -1;
}

static int underline_fontno = 2;

void underline_font()
{
 int n = get_fontno();
 if (n >= 0)
   underline_fontno = n;
 skip_line();
}

int get_underline_fontno()
{
 return underline_fontno;
}
   
static void read_special_fonts(special_font_list **sp)
{
 special_font_list *s = *sp;
 *sp = 0;
 while (s != 0) {
   special_font_list *tem = s;
   s = s->next;
   delete tem;
 }
 special_font_list **p = sp;
 while (has_arg()) {
   int i = get_fontno();
   if (i >= 0) {
     special_font_list *tem = new special_font_list;
     tem->n = i;
     tem->next = 0;
     *p = tem;
     p = &(tem->next);
   }
 }
}

void font_special_request()
{
 int n = get_fontno();
 if (n >= 0)
   read_special_fonts(&font_table[n]->sf); 
 skip_line();
}

 
void special_request()
{
 read_special_fonts(&global_special_fonts);
 skip_line();
}

int next_available_font_position()
{
 for (int i = 1; i < font_table_size && font_table[i] != 0; i++)
   ;
 return i;
}

int symbol_fontno(symbol s)
{
 s = get_font_translation(s);
 for (int i = 0; i < font_table_size; i++)
   if (font_table[i] != 0 && font_table[i]->is_named(s))
     return i;
 return -1;
}

int is_good_fontno(int n)
{
 return n >= 0 && n < font_table_size && font_table[n] != NULL;
}

int get_bold_fontno(int n)
{
 if (n >= 0 && n < font_table_size && font_table[n] != 0) {
   hunits offset;
   if (font_table[n]->get_bold(&offset))
     return offset.to_units() + 1;
   else
     return 0;
 }
 else
   return 0;
}

hunits env_digit_width(environment *env)
{
 node *n = make_glyph_node(charset_table['0'], env);
 if (n) {
   hunits x = n->width();
   delete n;
   return x;
 }
 else
   return H0;
}

hunits env_space_width(environment *env)
{
 int fn = env_definite_font(env);
 font_size fs = env->get_font_size();
 if (fn < 0 || fn >= font_table_size || font_table[fn] == 0)
   return fs.to_units()/3;
 else
   return font_table[fn]->get_space_width(fs);
}


hunits env_half_narrow_space_width(environment *env)
{
 int fn = env_definite_font(env);
 font_size fs = env->get_font_size();
 if (fn < 0 || fn >= font_table_size || font_table[fn] == 0)
   return 0;
 else
   return font_table[fn]->get_half_narrow_space_width(fs);
}

hunits env_narrow_space_width(environment *env)
{
 int fn = env_definite_font(env);
 font_size fs = env->get_font_size();
 if (fn < 0 || fn >= font_table_size || font_table[fn] == 0)
   return 0;
 else
   return font_table[fn]->get_narrow_space_width(fs);
}

void bold_font()
{
 int n = get_fontno();
 if (n >= 0) {
   if (has_arg()) {
     if (tok.delimiter()) {
       int f = get_fontno();
       if (f >= 0) {
         if (has_arg()) {
           units offset;
           if (get_number(&offset, 'u')) {
             if (offset >= 1)
               font_table[f]->set_conditional_bold(n, hunits(offset - 1));
             else
               font_table[f]->conditional_unbold(n);
           }
         }
         else
           font_table[f]->conditional_unbold(n);
       }
     }
     else {
       units offset;
       if (get_number(&offset, 'u')) {
         if (offset >= 1)
           font_table[n]->set_bold(hunits(offset - 1));
         else
           font_table[n]->unbold();
       }
     }
   }
   else
     font_table[n]->unbold();
 }
 skip_line();
}

track_kerning_function::track_kerning_function() : non_zero(0)
{
}

track_kerning_function::track_kerning_function(int min_s, hunits min_a, 
                                              int max_s, hunits max_a)
    : non_zero(1), 
    min_size(min_s), min_amount(min_a),
    max_size(max_s), max_amount(max_a)
{
}

int track_kerning_function::operator==(const track_kerning_function &tk)
{
 if (non_zero)
   return (tk.non_zero
           && min_size == tk.min_size
           && min_amount == tk.min_amount
           && max_size == tk.max_size
           && max_amount == tk.max_amount);
 else
   return !tk.non_zero;
}

int track_kerning_function::operator!=(const track_kerning_function &tk)
{
 if (non_zero)
   return (!tk.non_zero
           || min_size != tk.min_size
           || min_amount != tk.min_amount
           || max_size != tk.max_size
           || max_amount != tk.max_amount);
 else
   return tk.non_zero;
}

hunits track_kerning_function::compute(int size)
{
 if (non_zero) {
   if (max_size <= min_size)
     return min_amount;
   else if (size <= min_size)
     return min_amount;
   else if (size >= max_size)
     return max_amount;
   else
     return (scale(max_amount, size - min_size, max_size - min_size)
             + scale(min_amount, max_size - size, max_size - min_size));
 }
 else
   return H0;
}

void track_kern()
{
 int n = get_fontno();
 if (n >= 0) {
   if (has_arg()) {
     int min_s, max_s;
     hunits min_a, max_a;
     if (!get_number(&min_s, 'z')
         || !get_hunits(&min_a, 'p')
         || !get_number(&max_s, 'z')
         || !get_hunits(&max_a, 'p'))
       error("bad arguments for track kerning");
     else {
       track_kerning_function tk(min_s, min_a, max_s, max_a);
       font_table[n]->set_track_kern(tk);
     }
   }
   else {
     track_kerning_function tk;
     font_table[n]->set_track_kern(tk);
   }
 }
 skip_line();
}

void constant_space()
{
 int x, y;
 int n = get_fontno();
 if (n >= 0) {
   if (!has_arg())
     font_table[n]->set_constant_space(CONSTANT_SPACE_NONE);
   else if (get_integer(&x)) {
     if (!has_arg())
       font_table[n]->set_constant_space(CONSTANT_SPACE_RELATIVE, x);
     else if (get_number(&y, 'z'))
       font_table[n]->set_constant_space(CONSTANT_SPACE_ABSOLUTE, 
                                         scale(y*x,
                                               units_per_inch,
                                               36*72*sizescale));
   }
 }
 skip_line();
}

void ligature()
{
 if (has_arg()) {
   int lig;
   if (get_integer(&lig)) {
     if (lig > 2 || lig < 0)
       lig = 1;
     global_ligature_mode = lig;
   }
 }
 else
   global_ligature_mode = 1;
 skip_line();
}

void kern_request()
{
 if (has_arg()) {
   int k;
   if (get_integer(&k))
     global_kern_mode = k != 0;
 }
 else
   global_kern_mode = 1;
 skip_line();
}

void init_output()
{
 if (suppress_output_flag)
   the_output = new suppress_output_file;
 else if (ascii_output_flag)
   the_output = new ascii_output_file;
 else
   the_output = new troff_output_file;
}

class next_available_font_position_reg : public reg {
public:
 const char *get_string();
};

const char *next_available_font_position_reg::get_string()
{
 return itoa(next_available_font_position());
}

class printing_reg : public reg {
public:
 const char *get_string();
};

const char *printing_reg::get_string()
{
 if (the_output)
   return the_output->is_printing() ? "1" : "0";
 else
   return "0";
}

void init_node_requests()
{
 init_request("fp", font_position);
 init_request("sty", style);
 init_request("cs", constant_space);
 init_request("bd", bold_font);
 init_request("uf", underline_font);
 init_request("lg", ligature);
 init_request("kern", kern_request);
 init_request("tkf", track_kern);
 init_request("special", special_request);
 init_request("fspecial", font_special_request);
 init_request("ftr", font_translate);
 number_reg_dictionary.define(".fp", new next_available_font_position_reg);
 number_reg_dictionary.define(".kern",
                              new constant_int_reg(&global_kern_mode));
 number_reg_dictionary.define(".lg",
                              new constant_int_reg(&global_ligature_mode));
 number_reg_dictionary.define(".P", new printing_reg);
}