BSD 4_3_Net_2 release

[unix-history] / usr / src / usr.bin / groff / grops / ps.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 "driver.h"
#include "stringclass.h"
#include "cset.h"

extern "C" {
  // Sun's stdlib.h fails to declare this.
  char *mktemp(char *);
}

static int landscape_flag = 0;
static int ncopies = 1;
static int linewidth = -1;

#define DEFAULT_LINEWIDTH 40	/* in ems/1000 */
#define FILL_MAX 1000

// Maximum number of definitions in the prologue (used for sizing the
// dictionary.)

const int MAX_PROLOGUE_DEFS = 50;
const char *const dict_name = "grops";
const char *const defs_dict_name = "DEFS";
const int DEFS_DICT_SPARE = 50;

#define PROLOGUE "prologue"

double degrees(double r)
{
  return r*180.0/M_PI;
}

double radians(double d)
{
  return d*M_PI/180.0;
}

inline double transform_fill(int fill)
{
  return 1 - fill/double(FILL_MAX);
}

class ps_output {
public:
  ps_output(FILE *, int max_line_length);
  ps_output &put_string(const char *, int);
  ps_output &put_number(int);
  ps_output &put_fix_number(int);
  ps_output &put_float(double);
  ps_output &put_symbol(const char *);
  ps_output &put_literal_symbol(const char *);
  ps_output &set_fixed_point(int);
  ps_output &simple_comment(const char *);
  ps_output &begin_comment(const char *);
  ps_output &comment_arg(const char *);
  ps_output &end_comment();
  ps_output &set_file(FILE *);
  ps_output &include_file(FILE *);
  ps_output &copy_file(FILE *);
  ps_output &end_line();
  ps_output &put_delimiter(char);
  ps_output &special(const char *);
private:
  FILE *fp;
  int col;
  int max_line_length;		// not including newline
  int need_space;
  int fixed_point;
};

ps_output::ps_output(FILE *f, int n)
: fp(f), max_line_length(n), col(0), need_space(0), fixed_point(0)
{
}

ps_output &ps_output::set_file(FILE *f)
{
  fp = f;
  col = 0;
  return *this;
}

ps_output &ps_output::include_file(FILE *infp)
{
  if (col != 0)
    putc('\n', fp);
  int c;
#ifdef BROKEN_SPOOLER
  // Strip the first line if it's a comment.  I believe
  // some spoolers get confused by %! in the middle of a file.
  if ((c = getc(infp)) == '%') {
    while ((c = getc(infp)) != '\n' && c != '\r' && c != EOF)
      ;
  }
  else if (c != EOF)
    ungetc(c, infp);
#endif /* BROKEN_SPOOLER */
  // We strip out lines beginning with STRIPENDUM.
#ifdef BROKEN_SPOOLER
#define STRIPENDUM "%%"
#else
#define STRIPENDUM "%%IncludeFont:"
#endif
  // Index into STRIPENDUM of next character to be matched.
  int match = 0;
  while ((c = getc(infp)) != EOF) {
    if (match >= 0) {
      if (c == STRIPENDUM[match]) {
	if (++match == sizeof(STRIPENDUM) - 1) {
	  match = -1;
	  while ((c = getc(infp)) != EOF)
	    if (c == '\r' || c == '\n') {
	      match = 0;
	      break;
	    }
	}
      }
      else {
	for (int i = 0; i < match; i++)
	  putc(STRIPENDUM[i], fp);
	putc(c, fp);
	match = (c == '\n' || c == '\r' ? 0 : -1);
      }
    }
    else {
      putc(c, fp);
      match = (c == '\n' || c == '\r' ? 0 : -1);
    }
  }
  for (int i = 0; i < match; i++)
    putc(STRIPENDUM[i], fp);
  if (match != 0)
    putc('\n', fp);
  int lastc = '\n';
  while ((c = getc(infp)) != EOF) {
    putc(c, fp);
    lastc = c;
  }
  if (lastc != '\n')
    putc('\n', fp);
  col = 0;
  need_space = 0;
  return *this;
}

ps_output &ps_output::copy_file(FILE *infp)
{
  int c;
  while ((c = getc(infp)) != EOF)
    putc(c, fp);
  return *this;
}

ps_output &ps_output::end_line()
{
  if (col != 0) {
    putc('\n', fp);
    col = 0;
  }
  return *this;
}

ps_output &ps_output::special(const char *s)
{
  if (s == 0 || *s == '\0')
    return *this;
  if (col != 0) {
    putc('\n', fp);
    col = 0;
  }
  fputs(s, fp);
  if (strchr(s, '\0')[-1] != '\n')
    putc('\n', fp);
  need_space = 0;
  return *this;
}

ps_output &ps_output::simple_comment(const char *s)
{
  if (col != 0)
    putc('\n', fp);
  putc('%', fp);
  putc('%', fp);
  fputs(s, fp);
  putc('\n', fp);
  col = 0;
  need_space = 0;
  return *this;
}

ps_output &ps_output::begin_comment(const char *s)
{
  if (col != 0)
    putc('\n', fp);
  putc('%', fp);
  putc('%', fp);
  fputs(s, fp);
  col = 2 + strlen(s);
  return *this;
}

ps_output &ps_output::end_comment()
{
  if (col != 0) {
    putc('\n', fp);
    col = 0;
  }
  need_space = 0;
  return *this;
}

ps_output &ps_output::comment_arg(const char *s)
{
  int len = strlen(s);
  if (col + len + 1 > max_line_length) {
    putc('\n', fp);
    fputs("%%+", fp);
    col = 3;
  }
  putc(' ',  fp);
  fputs(s, fp);
  col += len + 1;
  return *this;
}

ps_output &ps_output::set_fixed_point(int n)
{
  assert(n >= 0 && n <= 10);
  fixed_point = n;
  return *this;
}

ps_output &ps_output::put_delimiter(char c)
{
  if (col + 1 > max_line_length) {
    putc('\n', fp);
    col = 0;
  }
  putc(c, fp);
  col++;
  need_space = 0;
  return *this;
}

ps_output &ps_output::put_string(const char *s, int n)
{
  int len = 0;
  for (int i = 0; i < n; i++) {
    char c = s[i];
    if (isascii(c) && isprint(c)) {
      if (c == '(' || c == ')' || c == '\\')
	len += 2;
      else
	len += 1;
    }
    else
      len += 4;
  }
  if (len > n*2) {
    if (col + n*2 + 2 > max_line_length && n*2 + 2 <= max_line_length) {
      putc('\n', fp);
      col = 0;
    }
    if (col + 1 > max_line_length) {
      putc('\n', fp);
      col = 0;
    }
    putc('<', fp);
    col++;
    for (i = 0; i < n; i++) {
      if (col + 2 > max_line_length) {
	putc('\n', fp);
	col = 0;
      }
      fprintf(fp, "%02x", s[i] & 0377);
      col += 2;
    }
    putc('>', fp);
    col++;
  }
  else {
    if (col + len + 2 > max_line_length && len + 2 <= max_line_length) {
      putc('\n', fp);
      col = 0;
    }
    if (col + 2 > max_line_length) {
      putc('\n', fp);
      col = 0;
    }
    putc('(', fp);
    col++;
    for (i = 0; i < n; i++) {
      char c = s[i];
      if (isascii(c) && isprint(c)) {
	if (c == '(' || c == ')' || c == '\\')
	  len = 2;
	else
	  len = 1;
      }
      else
	len = 4;
      if (col + len + 1 > max_line_length) {
	putc('\\', fp);
	putc('\n', fp);
	col = 0;
      }
      switch (len) {
      case 1:
	putc(c, fp);
	break;
      case 2:
	putc('\\', fp);
	putc(c, fp);
	break;
      case 4:
	fprintf(fp, "\\%03o", c & 0377);
	break;
      default:
	assert(0);
      }
      col += len;
    }
    putc(')', fp);
    col++;
  }
  need_space = 0;
  return *this;
}

ps_output &ps_output::put_number(int n)
{
  char buf[1 + INT_DIGITS + 1];
  sprintf(buf, "%d", n);
  int len = strlen(buf);
  if (col > 0 && col + len + need_space > max_line_length) {
    putc('\n', fp);
    col = 0;
    need_space = 0;
  }
  if (need_space) {
    putc(' ', fp);
    col++;
  }
  fputs(buf, fp);
  col += len;
  need_space = 1;
  return *this;
}


ps_output &ps_output::put_fix_number(int i)
{
  const char *p = iftoa(i, fixed_point);
  int len = strlen(p);
  if (col > 0 && col + len + need_space > max_line_length) {
    putc('\n', fp);
    col = 0;
    need_space = 0;
  }
  if (need_space) {
    putc(' ', fp);
    col++;
  }
  fputs(p, fp);
  col += len;
  need_space = 1;
  return *this;
}

ps_output &ps_output::put_float(double d)
{
  char buf[128];
  sprintf(buf, "%.4f", d);
  int len = strlen(buf);
  if (col > 0 && col + len + need_space > max_line_length) {
    putc('\n', fp);
    col = 0;
    need_space = 0;
  }
  if (need_space) {
    putc(' ', fp);
    col++;
  }
  fputs(buf, fp);
  col += len;
  need_space = 1;
  return *this;
}

ps_output &ps_output::put_symbol(const char *s)
{
  int len = strlen(s);
  if (col > 0 && col + len + need_space > max_line_length) {
    putc('\n', fp);
    col = 0;
    need_space = 0;
  }
  if (need_space) {
    putc(' ', fp);
    col++;
  }
  fputs(s, fp);
  col += len;
  need_space = 1;
  return *this;
}

ps_output &ps_output::put_literal_symbol(const char *s)
{
  int len = strlen(s);
  if (col > 0 && col + len + 1 > max_line_length) {
    putc('\n', fp);
    col = 0;
  }
  putc('/', fp);
  fputs(s, fp);
  col += len + 1;
  need_space = 1;
  return *this;
}

class ps_font : public font {
  ps_font(const char *);
public:
  int encoding_index;
  char *encoding;
  char *reencoded_name;
  ~ps_font();
  void handle_unknown_font_command(int argc, const char **argv);
  static ps_font *load_ps_font(const char *);
};

ps_font *ps_font::load_ps_font(const char *s)
{
  ps_font *f = new ps_font(s);
  if (!f->load()) {
    delete f;
    return 0;
  }
  return f;
}

ps_font::ps_font(const char *nm)
: font(nm), encoding(0), reencoded_name(0), encoding_index(-1)
{
}

ps_font::~ps_font()
{
  delete encoding;
  delete reencoded_name;
}

void ps_font::handle_unknown_font_command(int argc, const char **argv)
{
  if (strcmp(argv[0], "encoding") == 0) {
    if (argc != 2)
      error("`encoding' command requires exactly 1 argument");
    else
      encoding = strsave(argv[1]);
  }
}


struct style {
  font *f;
  int point_size;
  int height;
  int slant;
  style();
  style(font *, int, int, int);
  int operator==(const style &) const;
  int operator!=(const style &) const;
};

style::style() : f(0)
{
}

style::style(font *p, int sz, int h, int sl)
: f(p), point_size(sz), height(h), slant(sl)
{
}

int style::operator==(const style &s) const
{
  return (f == s.f && point_size == s.point_size
	  && height == s.height && slant == s.slant);
}

int style::operator!=(const style &s) const
{
  return !(*this == s);
}

struct depend_list;

struct document_font {
  enum { LISTED = 01, NEEDED = 02, SUPPLIED = 04 };
  char *name;
  char *filename;
  int flags;
  document_font *next;
  depend_list *depends_on;
  int mark;
  document_font(const char *);
  ~document_font();
  void download(ps_output &);
};

struct depend_list {
  document_font *p;
  depend_list *next;
};


class ps_printer : public printer {
  FILE *tempfp;
  ps_output out;
  int res;
  int space_char_index;
  int pages_output;
  int paper_length;
  int equalise_spaces;
  enum { SBUF_SIZE = 256 };
  char sbuf[SBUF_SIZE];
  int sbuf_len;
  int sbuf_start_hpos;
  int sbuf_vpos;
  int sbuf_end_hpos;
  int sbuf_space_width;
  int sbuf_space_count;
  int sbuf_space_diff_count;
  int sbuf_space_code;
  int sbuf_kern;
  style sbuf_style;
  style output_style;
  int output_hpos;
  int output_vpos;
  int output_draw_point_size;
  int line_thickness;
  int output_line_thickness;
  int fill;
  unsigned char output_space_code;
  enum { MAX_DEFINED_STYLES = 50 };
  style defined_styles[MAX_DEFINED_STYLES];
  int ndefined_styles;
  int next_encoding_index;
  string defs;
  int ndefs;
  document_font *doc_fonts;

  void flush_sbuf();
  void set_style(const style &);
  void set_space_code(unsigned char c);
  int set_encoding_index(ps_font *);
  void do_exec(char *, const environment *);
  void do_import(char *, const environment *);
  void do_def(char *, const environment *);
  void do_mdef(char *, const environment *);
  void do_file(char *, const environment *);
  void set_line_thickness(const environment *);
  void fill_path();
  void merge_download_fonts();
  void merge_import_fonts(FILE *);
  void merge_ps_fonts();
  void print_font_comment();
  void print_supplied_font_comment();
  void print_needed_font_comment();
  void print_include_font_comments();
  document_font *lookup_doc_font(const char *);
  void encode_fonts();
  void download_fonts();
  void define_encoding(const char *, int);
  void reencode_font(ps_font *);
  void read_download_file();
public:
  ps_printer();
  ~ps_printer();
  void set_char(int i, font *f, const environment *env, int w);
  void draw(int code, int *p, int np, const environment *env);
  void begin_page(int);
  void end_page();
  void special(char *arg, const environment *env);
  font *make_font(const char *);
  void end_of_line();
};

ps_printer::ps_printer()
: pages_output(0),
  sbuf_len(0),
  output_hpos(-1),
  output_vpos(-1),
  out(0, 79),
  ndefined_styles(0),
  next_encoding_index(0),
  line_thickness(-1),
  fill(FILL_MAX + 1),
  ndefs(0),
  doc_fonts(0)
{
  static char temp_filename[] = "/tmp/gropsXXXXXX";
  mktemp(temp_filename);
  tempfp = fopen(temp_filename, "w+");
  if (tempfp == 0)
    fatal("can't open temporary file `%1': %2",
	  temp_filename, strerror(errno));
  if (unlink(temp_filename) < 0)
    error("can't unlink `%1': %2", temp_filename, strerror(errno));
  out.set_file(tempfp);
  if (linewidth < 0)
    linewidth = DEFAULT_LINEWIDTH;
  if (font::hor != 1)
    fatal("horizontal resolution must be 1");
  if (font::vert != 1)
    fatal("vertical resolution must be 1");
  if (font::res % (font::sizescale*72) != 0)
    fatal("res must be a multiple of 72*sizescale");
  int r = font::res;
  int point = 0;
  while (r % 10 == 0) {
    r /= 10;
    point++;
  }
  res = r;
  out.set_fixed_point(point);
  space_char_index = font::name_to_index("space");
  paper_length = font::paperlength;
  if (paper_length == 0)
    paper_length = 11*font::res;
  equalise_spaces = font::res >= 72000;
}

int ps_printer::set_encoding_index(ps_font *f)
{
  if (f->encoding_index >= 0)
    return f->encoding_index;
  for (font_pointer_list *p = font_list; p; p = p->next)
    if (p->p != f) {
      char *encoding = ((ps_font *)p->p)->encoding;
      int encoding_index = ((ps_font *)p->p)->encoding_index;
      if (encoding != 0 && encoding_index >= 0 
	  && strcmp(f->encoding, encoding) == 0) {
	return f->encoding_index = encoding_index;
      }
    }
  return f->encoding_index = next_encoding_index++;
}

void ps_printer::set_char(int i, font *f, const environment *env, int w)
{
  if (i == space_char_index)
    return;
  unsigned char code = f->get_code(i);
  style sty(f, env->size, env->height, env->slant);
  if (sty.slant != 0) {
    if (sty.slant > 80 || sty.slant < -80) {
      error("silly slant `%1' degrees", sty.slant);
      sty.slant = 0;
    }
  }
  if (sbuf_len > 0) {
    if (sbuf_len < SBUF_SIZE
	&& sty == sbuf_style
	&& sbuf_vpos == env->vpos) {
      if (sbuf_end_hpos == env->hpos) {
	sbuf[sbuf_len++] = code;
	sbuf_end_hpos += w + sbuf_kern;
	return;
      }
      if (sbuf_len == 1 && sbuf_kern == 0) {
	sbuf_kern = env->hpos - sbuf_end_hpos;
	sbuf_end_hpos = env->hpos + sbuf_kern + w;
	sbuf[sbuf_len++] = code;
	return;
      }
      /* If sbuf_end_hpos - sbuf_kern == env->hpos, we are better off
	 starting a new string. */
      if (sbuf_len < SBUF_SIZE - 1 && env->hpos >= sbuf_end_hpos
	  && (sbuf_kern == 0 || sbuf_end_hpos - sbuf_kern != env->hpos)) {
	if (sbuf_space_code < 0) {
	  if (f->contains(space_char_index)) {
	    sbuf_space_code = f->get_code(space_char_index);
	    sbuf_space_width = env->hpos - sbuf_end_hpos;
	    sbuf_end_hpos = env->hpos + w + sbuf_kern;
	    sbuf[sbuf_len++] = sbuf_space_code;
	    sbuf[sbuf_len++] = code;
	    sbuf_space_count++;
	    return;
	  }
	}
	else {
	  int diff = env->hpos - sbuf_end_hpos - sbuf_space_width;
	  if (diff == 0 || (equalise_spaces && (diff == 1 || diff == -1))) {
	    sbuf_end_hpos = env->hpos + w + sbuf_kern;
	    sbuf[sbuf_len++] = sbuf_space_code;
	    sbuf[sbuf_len++] = code;
	    sbuf_space_count++;
	    if (diff == 1)
	      sbuf_space_diff_count++;
	    else if (diff == -1)
	      sbuf_space_diff_count--;
	    return;
	  }
	}
      }
    }
    flush_sbuf();
  }
  sbuf_len = 1;
  sbuf[0] = code;
  sbuf_end_hpos = env->hpos + w;
  sbuf_start_hpos = env->hpos;
  sbuf_vpos = env->vpos;
  sbuf_style = sty;
  sbuf_space_code = -1;
  sbuf_space_width = 0;
  sbuf_space_count = sbuf_space_diff_count = 0;
  sbuf_kern = 0;
}

int is_small_h(int n)
{
  return n < (font::res*2)/72 && n > -(font::res*10)/72;
}

int is_small_v(int n)
{
  return n < (font::res*4)/72 && n > -(font::res*4)/72;
}

static char *make_encoding_name(int encoding_index)
{
  static char buf[3 + INT_DIGITS + 1];
  sprintf(buf, "ENC%d", encoding_index);
  return buf;
}

const char *const WS = " \t\n\r";

void ps_printer::define_encoding(const char *encoding, int encoding_index)
{
  char *vec[256];
  for (int i = 0; i < 256; i++)
    vec[i] = 0;
  char *path;
  FILE *fp = font::open_file(encoding, &path);
  if (fp == 0)
    fatal("can't open encoding file `%1'", encoding);
  int lineno = 1;
  char buf[256];
  while (fgets(buf, 512, fp) != 0) {
    char *p = buf;
    while (isascii(*p) && isspace(*p))
      p++;
    if (*p != '#' && *p != '\0' && (p = strtok(buf, WS)) != 0) {
      char *q = strtok(0, WS);
      int n;
      if (q == 0 || sscanf(q, "%d", &n) != 1 || n < 0 || n >= 256)
	fatal_with_file_and_line(path, lineno, "bad second field");
      vec[n] = new char[strlen(p) + 1];
      strcpy(vec[n], p);
    }
    lineno++;
  }
  delete path;
  out.put_literal_symbol(make_encoding_name(encoding_index));
  out.put_delimiter('[');
  for (i = 0; i < 256; i++) {
    if (vec[i] == 0)
      out.put_literal_symbol(".notdef");
    else
      out.put_literal_symbol(vec[i]);
  }
  out.put_delimiter(']').put_symbol("def");
}

void ps_printer::reencode_font(ps_font *f)
{
  out.put_literal_symbol(f->reencoded_name)
     .put_symbol(make_encoding_name(f->encoding_index))
     .put_literal_symbol(f->get_internal_name())
     .put_symbol("RE");
}

void ps_printer::encode_fonts()
{
  if (next_encoding_index == 0)
    return;
  char *done_encoding = new char[next_encoding_index];
  for (int i = 0; i < next_encoding_index; i++)
    done_encoding[i] = 0;
  for (font_pointer_list *f = font_list; f; f = f->next) {
    int encoding_index = ((ps_font *)f->p)->encoding_index;
    if (encoding_index >= 0) {
      assert(encoding_index < next_encoding_index);
      if (!done_encoding[encoding_index]) {
	done_encoding[encoding_index] = 1;
	define_encoding(((ps_font *)f->p)->encoding, encoding_index);
      }
      reencode_font((ps_font *)f->p);
    }
  }
  delete done_encoding;
}

void ps_printer::set_style(const style &sty)
{
  char buf[1 + INT_DIGITS + 1];
  for (int i = 0; i < ndefined_styles; i++)
    if (sty == defined_styles[i]) {
      sprintf(buf, "F%d", i);
      out.put_symbol(buf);
      return;
    }
  if (ndefined_styles >= MAX_DEFINED_STYLES)
    ndefined_styles = 0;
  sprintf(buf, "F%d", ndefined_styles);
  out.put_literal_symbol(buf);
  const char *psname = sty.f->get_internal_name();
  if (psname == 0)
    fatal("no internalname specified for font `%1'", sty.f->get_name());
  char *encoding = ((ps_font *)sty.f)->encoding;
  if (encoding != 0) {
    char *s = ((ps_font *)sty.f)->reencoded_name;
    if (s == 0) {
      int ei = set_encoding_index((ps_font *)sty.f);
      char *tem = new char[strlen(psname) + 1 + INT_DIGITS + 1];
      sprintf(tem, "%s@%d", psname, ei);
      psname = tem;
      ((ps_font *)sty.f)->reencoded_name = tem;
    }
    else
      psname = s;
  }
  out.put_fix_number((font::res/(72*font::sizescale))*sty.point_size);
  if (sty.height != 0 || sty.slant != 0) {
    int h = sty.height == 0 ? sty.point_size : sty.height;
    h *= font::res/(72*font::sizescale);
    int c = int(h*tan(radians(sty.slant)) + .5);
    out.put_fix_number(c).put_fix_number(h).put_literal_symbol(psname)
       .put_symbol("MF");
  }
  else {
    out.put_literal_symbol(psname).put_symbol("SF");
  }
  defined_styles[ndefined_styles++] = sty;
}

void ps_printer::set_space_code(unsigned char c)
{
  out.put_literal_symbol("SC").put_number(c).put_symbol("def");
}

void ps_printer::end_of_line()
{
  flush_sbuf();
  // this ensures that we do an absolute motion to the beginning of a line
  output_vpos = output_hpos = -1;
}

void ps_printer::flush_sbuf()
{
  enum {
    NONE,
    RELATIVE_H,
    RELATIVE_V,
    RELATIVE_HV,
    ABSOLUTE
    } motion = NONE;
  int space_flag = 0;
  if (sbuf_len == 0)
    return;
  if (output_style != sbuf_style) {
    set_style(sbuf_style);
    output_style = sbuf_style;
  }
  int extra_space = 0;
  if (output_hpos < 0 || output_vpos < 0
      || !is_small_h(output_hpos - sbuf_start_hpos)
      || !is_small_v(output_vpos - sbuf_vpos))
    motion = ABSOLUTE;
  else {
    if (output_hpos != sbuf_start_hpos)
      motion = RELATIVE_H;
    if (output_vpos != sbuf_vpos) {
      if  (motion != NONE)
	motion = RELATIVE_HV;
      else
	motion = RELATIVE_V;
    }
  }
  if (sbuf_space_code >= 0) {
    int w = sbuf_style.f->get_width(space_char_index, sbuf_style.point_size);
    if (w + sbuf_kern != sbuf_space_width) {
      if (sbuf_space_code != output_space_code) {
	set_space_code(sbuf_space_code);
	output_space_code = sbuf_space_code;
      }
      space_flag = 1;
      extra_space = sbuf_space_width - w - sbuf_kern;
      if (sbuf_space_diff_count > sbuf_space_count/2)
	extra_space++;
      else if (sbuf_space_diff_count < -(sbuf_space_count/2))
	extra_space--;
    }
  }
  if (space_flag)
    out.put_fix_number(extra_space);
  if (sbuf_kern != 0)
    out.put_fix_number(sbuf_kern);
  out.put_string(sbuf, sbuf_len);
  char sym[2];
  sym[0] = 'A' + motion*4 + space_flag + 2*(sbuf_kern != 0);
  sym[1] = '\0';
  switch (motion) {
  case NONE:
    break;
  case ABSOLUTE:
    out.put_fix_number(sbuf_start_hpos)
       .put_fix_number(sbuf_vpos);
    break;
  case RELATIVE_H:
    out.put_fix_number(sbuf_start_hpos - output_hpos);
    break;
  case RELATIVE_V:
    out.put_fix_number(sbuf_vpos - output_vpos);
    break;
  case RELATIVE_HV:
    out.put_fix_number(sbuf_start_hpos - output_hpos)
       .put_fix_number(sbuf_vpos - output_vpos);
    break;
  default:
    assert(0);
  }
  out.put_symbol(sym);
  output_hpos = sbuf_end_hpos;
  output_vpos = sbuf_vpos;
  sbuf_len = 0;
}


void ps_printer::set_line_thickness(const environment *env)
{
  if (line_thickness < 0) {
    if (output_draw_point_size != env->size) {
      // we ought to check for overflow here
      int lw = ((font::res/(72*font::sizescale))*linewidth*env->size)/1000;
      out.put_fix_number(lw).put_symbol("LW");
      output_draw_point_size = env->size;
      output_line_thickness = -1;
    }
  }
  else {
    if (output_line_thickness != line_thickness) {
      out.put_fix_number(line_thickness).put_symbol("LW");
      output_line_thickness = line_thickness;
      output_draw_point_size = -1;
    }
  }
}

void ps_printer::fill_path()
{
  if (fill > FILL_MAX)
    out.put_symbol("BL");
  else
    out.put_float(transform_fill(fill)).put_symbol("FL");
}

void ps_printer::draw(int code, int *p, int np, const environment *env)
{
  int fill_flag = 0;
  switch (code) {
  case 'C':
    fill_flag = 1;
    // fall through
  case 'c':
    // troff adds an extra argument to C
    if (np != 1 && !(code == 'C' && np == 2)) {
      error("1 argument required for circle");
      break;
    }
    out.put_fix_number(env->hpos + p[0]/2)
       .put_fix_number(env->vpos)
       .put_fix_number(p[0]/2)
       .put_symbol("DC");
    if (fill_flag) {
      fill_path();
    }
    else {
      set_line_thickness(env);
      out.put_symbol("ST");
    }
    break;
  case 'l':
    if (np != 2) {
      error("2 arguments required for line");
      break;
    }
    set_line_thickness(env);
    out.put_fix_number(p[0] + env->hpos)
       .put_fix_number(p[1] + env->vpos)
       .put_fix_number(env->hpos)
       .put_fix_number(env->vpos)
       .put_symbol("DL");
    break;
  case 'E':
    fill_flag = 1;
    // fall through
  case 'e':
    if (np != 2) {
      error("2 arguments required for ellipse");
      break;
    }
    out.put_fix_number(p[0])
       .put_fix_number(p[1])
       .put_fix_number(env->hpos + p[0]/2)
       .put_fix_number(env->vpos)
       .put_symbol("DE");
    if (fill_flag) {
      fill_path();
    }
    else {
      set_line_thickness(env);
      out.put_symbol("ST");
    }
    break;
  case 'P':
    fill_flag = 1;
    // fall through
  case 'p':
    {
      if (np & 1) {
	error("even number of arguments required for polygon");
	break;
      }
      if (np == 0) {
	error("no arguments for polygon");
	break;
      }
      out.put_fix_number(env->hpos)
	 .put_fix_number(env->vpos)
	 .put_symbol("MT");
      for (int i = 0; i < np; i += 2)
	out.put_fix_number(p[i])
	   .put_fix_number(p[i+1])
	   .put_symbol("RL");
      out.put_symbol("CL");
      if (fill_flag) {
	fill_path();
      }
      else {
	set_line_thickness(env);
	out.put_symbol("ST");
      }
      break;
    }
  case '~':
    {
      if (np & 1) {
	error("even number of arguments required for spline");
	break;
      }
      if (np == 0) {
	error("no arguments for spline");
	break;
      }
      out.put_fix_number(env->hpos)
	 .put_fix_number(env->vpos)
	 .put_symbol("MT");
      out.put_fix_number(p[0]/2)
	 .put_fix_number(p[1]/2)
	 .put_symbol("RL");
      /* tnum/tden should be between 0 and 1; the closer it is to 1
	 the tighter the curve will be to the guiding lines; 2/3
	 is the standard value */
      const int tnum = 2;
      const int tden = 3;
      for (int i = 0; i < np - 2; i += 2) {
	out.put_fix_number((p[i]*tnum)/(2*tden))
	   .put_fix_number((p[i + 1]*tnum)/(2*tden))
	   .put_fix_number(p[i]/2 + (p[i + 2]*(tden - tnum))/(2*tden))
	   .put_fix_number(p[i + 1]/2 + (p[i + 3]*(tden - tnum))/(2*tden))
	   .put_fix_number((p[i] - p[i]/2) + p[i + 2]/2)
	   .put_fix_number((p[i + 1] - p[i + 1]/2) + p[i + 3]/2)
	   .put_symbol("RC");
      }
      out.put_fix_number(p[np - 2] - p[np - 2]/2)
	 .put_fix_number(p[np - 1] - p[np - 1]/2)
	 .put_symbol("RL");
      set_line_thickness(env);
      out.put_symbol("ST");
    }
    break;
  case 'a':
    {
      if (np != 4) {
	error("4 arguments required for arc");
	break;
      }
      set_line_thickness(env);
      int x = p[0] + p[2];
      int y = p[1] + p[3];
      double n = p[0]*double(x) + p[1]*double(y);
      if (n == 0)
	out.put_fix_number(x + env->hpos)
	   .put_fix_number(y + env->vpos)
	   .put_fix_number(env->hpos)
	   .put_fix_number(env->vpos)
	   .put_symbol("DL");
      else {
	double k = (double(x)*x + double(y)*y)/(2.0*n);
	double cx = k*p[0];
	double cy = k*p[1];
	out.put_fix_number(env->hpos + int(cx))
	   .put_fix_number(env->vpos + int(cy))
	   .put_fix_number(int(sqrt(cx*cx + cy*cy)))
	   .put_float(degrees(atan2(-cy, -cx)))
	   .put_float(degrees(atan2(y - cy, x - cx)))
	   .put_symbol("DA");
      }
    }
    break;
  case 't':
    {
      if (np == 0) {
	line_thickness = -1;
      }
      else {
	// troff gratuitously adds an extra 0
	if (np != 1 && np != 2) {
	  error("0 or 1 argument required for thickness");
	  break;
	}
	line_thickness = p[0];
      }
      break;
    }
  case 'f':
    {
      if (np != 1 && np != 2) {
	error("1 argument required for fill");
	break;
      }
      fill = p[0];
      if (fill < 0 || fill > FILL_MAX) {
	// This means fill with the current color.
	fill = FILL_MAX + 1;
      }
      break;
    }      
  default:
    error("unrecognised drawing command `%1'", char(code));
    break;
  }

  output_hpos = output_vpos = -1;
}

void ps_printer::begin_page(int n)
{
  out.begin_comment("Page:").comment_arg(itoa(n));
  out.comment_arg(itoa(++pages_output)).end_comment();
  output_style.f = 0;
  output_space_code = 32;
  output_draw_point_size = -1;
  output_line_thickness = -1;
  output_hpos = output_vpos = -1;
  ndefined_styles = 0;
  out.put_symbol("BP");
}

void ps_printer::end_page()
{
  flush_sbuf();
  out.put_symbol("EP");
}

font *ps_printer::make_font(const char *nm)
{
  return ps_font::load_ps_font(nm);
}

ps_printer::~ps_printer()
{
  out.simple_comment("Trailer");
  out.put_symbol("end");
  out.end_line();
  if (fseek(tempfp, 0L, 0) < 0)
    fatal("fseek on temporary file failed");
  fputs("%!PS-Adobe-2.1\n", stdout);
  out.set_file(stdout);
  {
    extern const char *version_string;
    out.begin_comment("Creator:")
       .comment_arg("groff")
       .comment_arg("version")
       .comment_arg(version_string)
       .end_comment();
  }
  read_download_file();
  merge_ps_fonts();
  merge_download_fonts();
  print_font_comment();
  print_supplied_font_comment();
  print_needed_font_comment();
  out.begin_comment("Pages:").comment_arg(itoa(pages_output)).end_comment();
  out.simple_comment("EndComments");
  char *path;
  FILE *fp = font::open_file(PROLOGUE, &path);
  if (fp == 0)
    fatal("can't find `%1'", PROLOGUE);
  out.put_literal_symbol(dict_name);
  out.put_number(MAX_DEFINED_STYLES + MAX_PROLOGUE_DEFS).put_symbol("dict");
  out.put_symbol("def");
  out.put_symbol(dict_name).put_symbol("begin");
  out.include_file(fp);
  fclose(fp);
  if (ndefs > 0)
    ndefs += DEFS_DICT_SPARE;
  out.put_literal_symbol(defs_dict_name)
     .put_number(ndefs + 1)
     .put_symbol("dict")
     .put_symbol("def");
  out.put_symbol(defs_dict_name)
     .put_symbol("begin");
  out.put_literal_symbol("u")
     .put_delimiter('{')
     .put_fix_number(1)
     .put_symbol("mul")
     .put_delimiter('}')
     .put_symbol("bind")
     .put_symbol("def");
  defs += '\0';
  out.special(defs.contents());
  out.put_symbol("end");
  delete path;
  out.put_symbol("end");
#ifndef BROKEN_SPOOLER
  out.simple_comment("EndProlog");
#endif /* !BROKEN_SPOOLER */
  print_include_font_comments();
  download_fonts();
#ifndef BROKEN_SPOOLER
  out.simple_comment("BeginSetup");
#endif /* !BROKEN_SPOOLER */
  out.put_symbol(dict_name).put_symbol("begin");
  out.put_literal_symbol("#copies").put_number(ncopies).put_symbol("def");
  out.put_literal_symbol("RES").put_number(res).put_symbol("def");
  out.put_literal_symbol("PL").put_fix_number(paper_length).put_symbol("def");
  out.put_literal_symbol("LS")
     .put_symbol(landscape_flag ? "true" : "false")
     .put_symbol("def");
  encode_fonts();
#ifndef BROKEN_SPOOLER
  out.simple_comment("EndSetup");
#else /* !BROKEN_SPOOLER */
  out.simple_comment("EndProlog");
#endif /* BROKEN_SPOOLER */
  out.end_line();
  out.copy_file(tempfp);
  fclose(tempfp);
}

void ps_printer::special(char *arg, const environment *env)
{
  typedef void (ps_printer::*SPECIAL_PROCP)(char *, const environment *);
  static struct {
    const char *name;
    SPECIAL_PROCP proc;
  } proc_table[] = {
    "exec", &ps_printer::do_exec,
    "def", &ps_printer::do_def,
    "mdef", &ps_printer::do_mdef,
    "import", &ps_printer::do_import,
    "file", &ps_printer::do_file,
  };
  for (char *p = arg; *p == ' ' || *p == '\n'; p++)
    ;
  char *tag = p;
  for (; *p != '\0' && *p != ':' && *p != ' ' && *p != '\n'; p++)
    ;
  if (*p == '\0' || strncmp(tag, "ps", p - tag) != 0) {
    error("X command without `ps:' tag ignored");
    return;
  }
  p++;
  for (; *p == ' ' || *p == '\n'; p++)
    ;
  char *command = p;
  for (; *p != '\0' && *p != ' ' && *p != '\n'; p++)
    ;
  if (*command == '\0') {
    error("X command without `ps:' tag ignored");
    return;
  }
  for (int i = 0; i < sizeof(proc_table)/sizeof(proc_table[0]); i++)
    if (strncmp(command, proc_table[i].name, p - command) == 0) {
      flush_sbuf();
      (this->*(proc_table[i].proc))(p, env);
      return;
    }
  error("X command `%1' not recognised", command);
}

// A conforming PostScript document must not have lines longer
// than 255 characters (excluding line termination characters).

static int check_line_lengths(const char *p)
{
  for (;;) {
    const char *end = strchr(p, '\n');
    if (end == 0)
      end = strchr(p, '\0');
    if (end - p > 255)
      return 0;
    if (*end == '\0')
      break;
    p = end + 1;
  }
  return 1;
}

void ps_printer::do_exec(char *arg, const environment *env)
{
  while (csspace(*arg))
    arg++;
  if (*arg == '\0') {
    error("missing argument to X exec command");
    return;
  }
  if (!check_line_lengths(arg)) {
    error("lines in X exec command must not be more than 255 characters long");
    return;
  }
  out.put_fix_number(env->hpos)
     .put_fix_number(env->vpos)
     .put_symbol("EBEGIN")
     .special(arg)
     .put_symbol("EEND");
  output_hpos = output_vpos = -1;
  output_style.f = 0;
  output_draw_point_size = -1;
  output_line_thickness = -1;
  ndefined_styles = 0;
}

void ps_printer::do_file(char *arg, const environment *env)
{
  while (csspace(*arg))
    arg++;
  if (*arg == '\0') {
    error("missing argument to X file command");
    return;
  }
  const char *filename = arg;
  do {
    ++arg;
  } while (*arg != '\0' && *arg != ' ' && *arg != '\n');
  FILE *fp = fopen(filename, "r");
  if (!fp) {
    error("can't open `%1': %2", filename, strerror(errno));
    return;
  }
  out.put_fix_number(env->hpos)
     .put_fix_number(env->vpos)
     .put_symbol("EBEGIN")
     .include_file(fp)
     .put_symbol("EEND");
  fclose(fp);
  output_hpos = output_vpos = -1;
  output_style.f = 0;
  output_draw_point_size = -1;
  output_line_thickness = -1;
  ndefined_styles = 0;
}

void ps_printer::do_def(char *arg, const environment *)
{
  while (csspace(*arg))
    arg++;
  if (!check_line_lengths(arg)) {
    error("lines in X def command must not be more than 255 characters long");
    return;
  }
  defs += arg;
  if (*arg != '\0' && strchr(arg, '\0')[-1] != '\n')
    defs += '\n';
  ndefs++;
}

// Like def, but the first argument says how many definitions it contains.

void ps_printer::do_mdef(char *arg, const environment *)
{
  char *p;
  int n = (int)strtol(arg, &p, 10);
  if (n == 0 && p == arg) {
    error("first argument to X mdef must be an integer");
    return;
  }
  if (n < 0) {
    error("out of range argument `%1' to X mdef command", int(n));
    return;
  }
  arg = p;
  while (csspace(*arg))
    arg++;
  if (!check_line_lengths(arg)) {
    error("lines in X mdef command must not be more than 255 characters long");
    return;
  }
  defs += arg;
  if (*arg != '\0' && strchr(arg, '\0')[-1] != '\n')
    defs += '\n';
  ndefs += n;
}

void ps_printer::do_import(char *arg, const environment *env)
{
  while (*arg == ' ' || *arg == '\n')
    arg++;
  for (char *p = arg; *p != '\0' && *p != ' ' && *p != '\n'; p++)
    ;
  if (*p != '\0')
    *p++ = '\0';
  int parms[6];
  int nparms = 0;
  while (nparms < 6) {
    char *end;
    long n = strtol(p, &end, 10);
    if (n == 0 && end == p)
      break;
    parms[nparms++] = int(n);
    p = end;
  }
  if (csalpha(*p) && (p[1] == '\0' || p[1] == ' ' || p[1] == '\n')) {
    error("scaling indicators not allowed in arguments for X import command");
    return;
  }
  while (*p == ' ' || *p == '\n')
    p++;
  if (nparms < 5) {
    if (*p == '\0')
      error("too few arguments for X import command");
    else
      error("invalid argument `%1' for X import command", p);
    return;
  }
  if (*p != '\0') {
    error("superflous argument `%1' for X import command", p);
    return;
  }
  int llx = parms[0];
  int lly = parms[1];
  int urx = parms[2];
  int ury = parms[3];
  int desired_width = parms[4];
  int desired_height = parms[5];
  if (desired_width <= 0) {
    error("bad width argument `%1' for X import command: must be > 0",
	  desired_width);
    return;
  }
  if (nparms == 6 && desired_height <= 0) {
    error("bad height argument `%1' for X import command: must be > 0",
	  desired_height);
    return;
  }
  if (llx == urx) {
    error("llx and urx arguments for X import command must not be equal");
    return;
  }
  if (lly == ury) {
    error("lly and ury arguments for X import command must not be equal");
    return;
  }
  if (nparms == 5) {
    int old_wid = urx - llx;
    int old_ht = ury - lly;
    if (old_wid < 0)
      old_wid = -old_wid;
    if (old_ht < 0)
      old_ht = -old_ht;
    desired_height = int(desired_width*(double(old_ht)/double(old_wid)) + .5);
  }
  if (env->vpos - desired_height < 0)
    warning("top of imported graphic is above the top of the page");
  FILE *fp = fopen(arg, "r");
  if (fp == 0) {
    error("can't open `%1': %2", arg, strerror(errno));
    return;
  }
  merge_import_fonts(fp);
  out.put_literal_symbol("level1")
     .put_symbol("save")
     .put_symbol("def");
  out.put_number(llx)
     .put_number(lly)
     .put_fix_number(desired_width)
     .put_number(urx - llx)
     .put_fix_number(-desired_height)
     .put_number(ury - lly)
     .put_fix_number(env->hpos)
     .put_fix_number(env->vpos)
     .put_symbol("PICTURE");
  // Put our dictionary off the dictionary stack so that it isn't
  // zapped by unfriendly applications.
  out.put_symbol("end");
  // Disable showpage.
  out.put_literal_symbol("showpage")
     .put_delimiter('{')
     .put_delimiter('}')
     .put_symbol("def");
  out.begin_comment("BeginDocument:")
     .comment_arg(arg)
     .end_comment();
  out.include_file(fp);
  fclose(fp);
  out.simple_comment("EndDocument");
  // Clear junk off operand stack, to lessen chance of an invalidrestore.
  out.put_symbol("clear");
  out.put_symbol(dict_name)
     .put_symbol("begin");
  out.put_symbol("level1")
     .put_symbol("restore");
}

static void add_font(const char *name, int t, document_font **pp)
{
  for (; *pp; pp = &(*pp)->next)
    if (strcmp(name, (*pp)->name) == 0) {
      (*pp)->flags |= t;
      return;
    }
  *pp = new document_font(name);
  (*pp)->flags = t;
}

// Skip the rest of the current line, including any line termination
// characters.

static int skip_line(FILE *fp)
{
  // The spec says any combination of \n and \r is allowed as a line
  // termination.  It seems wrong to allow multiple \n's or multiple
  // \r's since this would mean we were swallowing blank lines.
  for (;;) {
    int c = getc(fp);
    if (c == '\n') {
      c = getc(fp);
      if (c == EOF)
	return 0;
      if (c != '\r')
	ungetc(c, fp);
      return 1;
    }
    if (c == '\r') {
      c = getc(fp);
      if (c == EOF)
	return 0;
      if (c != '\n')
	ungetc(c, fp);
      return 1;
    }
    if (c == EOF)
      break;
  }
  return 0;
}

static void parse_fonts_arg(FILE *fp, int type, document_font **font_listp,
			    int *at_endp)
{
  // More than enough room for a single name.
  char buf[256];
  int c = getc(fp);
  for (;;) {
    while (c == ' ' || c == '\t')
      c = getc(fp);
    if (c == EOF || c == '\n' || c == '\r')
      break;
    int i = 0;
    do {
      if (i >= sizeof(buf) - 1)
	return;
      if (c == '\0')
	return;
      buf[i++] = c;
      c = getc(fp);
    } while (c != '\n' && c != '\r' && c != ' ' && c != '\t' && c != EOF);
    buf[i++] = '\0';
    if (strcmp(buf, "(atend)") == 0 && at_endp != 0)
      *at_endp |= type;
    else
      add_font(buf, type, font_listp);
  }
  if (c == '\n' || c == '\r')
    ungetc(c, fp);
}

static document_font *read_document_fonts(FILE *fp)
{
  int last_comment = 0;
  int document_fonts_at_end = 0;
  // This says which comments we've seen in the header.  The first of each
  // is the significant one.
  int header_comments = 0;
  char buf[sizeof("DocumentSuppliedFonts:")];
#define MAGIC "%!PS-Adobe-"
  if (fread(buf, 1, sizeof(MAGIC)-1, fp) != sizeof(MAGIC)-1
      || memcmp(buf, MAGIC, sizeof(MAGIC)-1) != 0)
    return 0;
  document_font *font_list = 0;
  enum { HEADER, BODY, TRAILER } state = HEADER;
  int level = 0;
  while (skip_line(fp)) {
    if (state == BODY && document_fonts_at_end == 0)
      break;
    int c = getc(fp);
    if (c == '%')
      c = getc(fp);
    if (c == EOF)
      break;
    if (c != '%') {
      if (state == HEADER)
	state = BODY;
      if (c == '\n' || c == '\r')
	ungetc(c, fp);
      continue;
    }
    c = getc(fp);
    if (c == EOF)
      break;
    if (c == '+') {
      if (last_comment)
	parse_fonts_arg(fp, last_comment, &font_list, 0);
      continue;
    }
    last_comment = 0;
    int i = 0;
    while (c != '\r' && c != '\n' && c != ' ' && c != '\t' && c != EOF) {
      if (i >= sizeof(buf) - 1) {
	i = 0;
	break;
      }
      buf[i++] = c;
      if (c == ':')
	break;
      c = getc(fp);
    }
    if (c == '\r' || c == '\n')
      ungetc(c, fp);
    buf[i++] = '\0';
    if (strcmp(buf, "BeginDocument:") == 0)
      level++;
    else if (strcmp(buf, "EndDocument") == 0) {
      if (level > 0)
	level--;
    }
    else if (level == 0) {
      if (strcmp(buf, "Trailer") == 0)
	state = TRAILER;
      else if (strcmp(buf, "EndComments") == 0) {
	if (state == HEADER)
	  state = BODY;
      }
      else if (state == HEADER) {
	int comment_type = 0;
	if (strcmp(buf, "DocumentFonts:") == 0)
	  comment_type = document_font::LISTED;
	else if (strcmp(buf, "DocumentNeededFonts:") == 0)
	  comment_type = document_font::NEEDED;
	else if (strcmp(buf, "DocumentSuppliedFonts:") == 0)
	  comment_type = document_font::SUPPLIED;
	if (comment_type != 0 && !(header_comments & comment_type)) {
	  parse_fonts_arg(fp, comment_type, &font_list,
			  (comment_type == document_font::LISTED
			   ? &document_fonts_at_end
			   : 0));
	  last_comment = comment_type;
	  header_comments |= comment_type;
	}
      }
      else if (state == TRAILER && strcmp(buf, "DocumentFonts:") == 0) {
	parse_fonts_arg(fp, document_font::LISTED, &font_list, 0);
	last_comment = document_font::LISTED;
      }
    }
  }
  return font_list;
}

document_font *ps_printer::lookup_doc_font(const char *nm)
{
  for (document_font **p = &doc_fonts; *p; p = &(*p)->next)
    if (strcmp((*p)->name, nm) == 0)
      return *p;
  return *p = new document_font(nm);
}

void ps_printer::merge_download_fonts()
{
  for (document_font *p = doc_fonts; p; p = p->next)
    if (p->filename && (p->flags & document_font::NEEDED)) {
      char *path = 0;
      FILE *fp = font::open_file(p->filename, &path);
      delete path;
      if (fp) {
	document_font *depends = read_document_fonts(fp);
	fclose(fp);
	while (depends) {
	  document_font *tem = depends->next;
	  if (strcmp(p->name, depends->name) != 0) {
	    if ((depends->flags & document_font::LISTED)
		&& !(depends->flags & document_font::SUPPLIED))
	      depends->flags |= document_font::NEEDED;
	    // We ignore the LISTED bit from now on.
	    document_font *q = lookup_doc_font(depends->name);
	    if (q->filename && (depends->flags & document_font::NEEDED)) {
	      depend_list *dep = new depend_list;
	      dep->next = p->depends_on;
	      dep->p = q;
	      p->depends_on = dep;
	      if (!(q->flags & document_font::NEEDED)) {
		// Move q to the end of the list.
		for (document_font **pp = &doc_fonts;
		     *pp != q;
		     pp = &(*pp)->next)
		  ;
		*pp = q->next;
		q->next = 0;
		for (; *pp; pp = &(*pp)->next)
		  ;
		*pp = q;
	      }
	    }
	    q->flags |= depends->flags;
	  }
	  delete depends;
	  depends = tem;
	}
      }
      else {
	error("can't find font file `%1': %2", p->filename, strerror(errno));
	delete p->filename;
	p->filename = 0;
      }
    }
}

void ps_printer::merge_import_fonts(FILE *fp)
{
  document_font *p = read_document_fonts(fp);
  rewind(fp);
  while (p) {
    if ((p->flags & document_font::LISTED)
	&& !(p->flags & document_font::SUPPLIED))
      p->flags |= document_font::NEEDED;
    document_font *tem = p->next;
    document_font *q = lookup_doc_font(p->name);
    q->flags |= p->flags;
    delete p;
    p = tem;
  }
}

void ps_printer::merge_ps_fonts()
{
  for (font_pointer_list *f = font_list; f; f = f->next) {
    ps_font *psf = (ps_font *)(f->p);
    document_font *p = lookup_doc_font(psf->get_internal_name());
    p->flags |= document_font::NEEDED;
  }
}

void ps_printer::print_font_comment()
{
  out.begin_comment("DocumentFonts:");
  for (document_font *list = doc_fonts; list; list = list->next)
    if (list->flags)
      out.comment_arg(list->name);
  out.end_comment();
}

void ps_printer::print_supplied_font_comment()
{
  out.begin_comment("DocumentSuppliedFonts:");
  for (document_font *list = doc_fonts; list; list = list->next)
    if (((list->flags & document_font::NEEDED) && list->filename)
	|| ((list->flags & document_font::SUPPLIED)
#if 0
	    && !(list->flags & document_font::NEEDED)
#endif
	))
      out.comment_arg(list->name);
  out.end_comment();
}

void ps_printer::print_needed_font_comment()
{
  out.begin_comment("DocumentNeededFonts:");
  for (document_font *list = doc_fonts; list; list = list->next)
    if ((list->flags & document_font::NEEDED) && !list->filename)
      out.comment_arg(list->name);
  out.end_comment();
}

void ps_printer::print_include_font_comments()
{
  for (document_font *list = doc_fonts; list; list = list->next)
    if ((list->flags & document_font::NEEDED) && !list->filename)
      out.begin_comment("IncludeFont:").comment_arg(list->name).end_comment();
}
  
void ps_printer::download_fonts()
{
  for (document_font *p = doc_fonts; p; p = p->next)
    p->download(out);
}

void ps_printer::read_download_file()
{
  char *path = 0;
  FILE *fp = font::open_file("download", &path);
  if (!fp)
    fatal("can't find `download'");
  char buf[512];
  int lineno = 0;
  while (fgets(buf, sizeof(buf), fp)) {
    lineno++;
    char *p = strtok(buf, " \t\r\n");
    if (p == 0 || *p == '#')
      continue;
    char *q = strtok(0, " \t\r\n");
    if (!q)
      fatal_with_file_and_line(path, lineno, "missing filename");
    lookup_doc_font(p)->filename = strsave(q);
  }
  delete path;
  fclose(fp);
}

document_font::document_font(const char *s)
: name(strsave(s)), filename(0), flags(0), next(0), depends_on(0), mark(0)
{
  assert(name != 0);
}

document_font::~document_font()
{
  delete name;
  delete filename;
  while (depends_on) {
    depend_list *tem = depends_on->next;
    delete depends_on;
    depends_on = tem;
  }
}

void document_font::download(ps_output &out)
{
  if (!filename)
    return;
  if (!(flags & NEEDED))
      return;
  // Do a reverse topological sort on the dependency graph.
  if (mark == 0) {
    mark = -1;
    for (depend_list *p = depends_on; p; p = p->next)
      p->p->download(out);
    char *path = 0;
    FILE *fp = font::open_file(filename, &path);
    // This shouldn't normally happen because we checked that the file
    // exists in merge_download_fonts.
    if (!fp)
      fatal("can't open `%1': %2", filename, strerror(errno));
    out.begin_comment("BeginFont:").comment_arg(name).end_comment();
    out.begin_comment("BeginDocument:").comment_arg(filename).end_comment();
    out.include_file(fp);
    out.simple_comment("EndDocument");
    out.simple_comment("EndFont");
    fclose(fp);
    delete path;
    mark = 1;
  }
  else if (mark < 0)
    error("loop detected in font dependencies for `%1'", name);
}

printer *make_printer()
{
  return new ps_printer;
}

static void usage();

int main(int argc, char **argv)
{
  program_name = argv[0];
  static char stderr_buf[BUFSIZ];
  setbuf(stderr, stderr_buf);
  int c;
  while ((c = getopt(argc, argv, "F:lc:w:v")) != EOF)
    switch(c) {
    case 'v':
      {
	extern const char *version_string;
	fprintf(stderr, "grops version %s\n", version_string);
	fflush(stderr);
	break;
      }
    case 'c':
      if (sscanf(optarg, "%d", &ncopies) != 1 || ncopies <= 0) {
	error("bad number of copies `%s'", optarg);
	ncopies = 1;
      }
      break;
    case 'l':
      landscape_flag = 1;
      break;
    case 'F':
      font::command_line_font_dir(optarg);
      break;
    case 'w':
      if (sscanf(optarg, "%d", &linewidth) != 1 || linewidth < 0) {
	error("bad linewidth `%s'", optarg);
	linewidth = -1;
      }
      break;
    case '?':
      usage();
      break;
    default:
      assert(0);
    }
  if (optind >= argc)
    do_file("-");
  else {
    for (int i = optind; i < argc; i++)
      do_file(argv[i]);
  }
  delete pr;
  exit(0);
}

static void usage()
{
  fprintf(stderr, "usage: %s [-l] [-c n] [-w n] [-F dir] [-v] [files ...]\n",
	  program_name);
  exit(1);
}