path: root/z24.c

/*@z24.c:Print Service:PrintInit()@*******************************************/
/*                                                                           */
/*  THE LOUT DOCUMENT FORMATTING SYSTEM (VERSION 3.21)                       */
/*  COPYRIGHT (C) 1991, 2000 Jeffrey H. Kingston                             */
/*                                                                           */
/*  Jeffrey H. Kingston (jeff@cs.usyd.edu.au)                                */
/*  Basser Department of Computer Science                                    */
/*  The University of Sydney 2006                                            */
/*  AUSTRALIA                                                                */
/*                                                                           */
/*  PDF Back End by Vincent Tan, February 1998.                              */
/*                                                                           */
/*  This program 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 2, or (at your option)      */
/*  any later version.                                                       */
/*                                                                           */
/*  This program 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 this program; if not, write to the Free Software              */
/*  Foundation, Inc., 59 Temple Place, Suite 330, Boston MA 02111-1307 USA   */
/*                                                                           */
/*  FILE:         z24.c                                                      */
/*  MODULE:       Print Service                                              */
/*  EXTERNS:      PrintInit(), PrintBeforeFirst(), PrintBetween(),           */
/*                PrintWord(), PrintAfterLast(), CoordTranslate(),           */
/*                CoordRotate(), CoordScale(), SaveGraphicState(),           */
/*                RestoreGraphicState(), PrintGraphicObject(),               */
/*                DefineGraphicNames(), PrintGraphicInclude()                */
/*                                                                           */
/*  This module implements the PostScript back end.                          */
/*                                                                           */
/*****************************************************************************/
#include <math.h>			/* for fabs()                        */

#include "externs.h"
#define	StartUpResource	"LoutStartUp"
#define DEFAULT_XHEIGHT 500
#define	NO_FONT		0		/* actually stolen from z37.c        */
#define	NO_COLOUR	0
#define	MAX_GS		50		/* maximum depth of graphics states  */

#define printnum(x, fp)							\
{ char buff[20];  register int i, y;					\
  if( x >= 0 )  y = x;							\
  else { y = -x; putc(CH_MINUS, fp); }					\
  i = 0;								\
  do { buff[i++] = numtodigitchar(y % 10);				\
     } while( (y = (y / 10)) > 0 );					\
  do { --i; putc(buff[i], fp);						\
     } while( i );							\
}

static FILE	*out_fp;		/* output file                       */

/* these variables used by PLAINTEXT back end only                           */
static int	hsize;			/* horizontal size of page in chars  */
static int	vsize;			/* vertical size of page in chars    */
static FULL_CHAR *page;			/* the page (two-dim array of chars) */

/* these types and variables used by POSTSCRIPT back end only                */
typedef struct
{
  FONT_NUM	gs_font;		/* font number of this state         */
  COLOUR_NUM	gs_colour;		/* colour number of this state       */
  BOOLEAN	gs_cpexists;		/* TRUE if a current point exists    */
  FULL_LENGTH	gs_currenty;		/* if cpexists, its y coordinate     */
  short		gs_xheight2;		/* of font exists, half xheight      */
} GRAPHICS_STATE;

static GRAPHICS_STATE	gs_stack[MAX_GS];/* graphics state stack             */
static int		gs_stack_top;	/* top of graphics state stack       */

static FONT_NUM		currentfont;	/* font of most recent atom          */
static COLOUR_NUM	currentcolour;	/* colour of most recent atom        */
static short		currentxheight2;/* half xheight in current font      */
static BOOLEAN		cpexists;	/* true if a current point exists    */
static FULL_LENGTH	currenty;	/* if cpexists, its y coordinate     */

static int		wordcount;	/* atoms printed since last newline  */
static int		pagecount;	/* total number of pages printed     */
static BOOLEAN		prologue_done;	/* TRUE after prologue is printed    */
static OBJECT		needs;		/* Resource needs of included EPSFs  */
static OBJECT		supplied;	/* Resources supplied by this file   */


/*@::EightBitToPrintForm()@***************************************************/
/*                                                                           */
/*  static char *EightBitToPrintForm[]                                       */
/*                                                                           */
/*  Given 8-bit character i, returns a string of characters that will be     */
/*  interpreted by PostScript as character i when read within a string.      */
/*                                                                           */
/*      CHAR_OUT==1    Printable ASCII literal, others as escape sequences   */
/*      CHAR_OUT==2    Printable ISO-LATIN-1 literal, others escaped         */
/*                                                                           */
/*****************************************************************************/

static char *EightBitToPrintForm[] = {
#if CHAR_OUT==0
    "",      "\\001", "\\002", "\\003", "\\004", "\\005", "\\006", "\\007",
    "\\010", "\\011", "\\012", "\\013", "\\014", "\\015", "\\016", "\\017",
    "\\020", "\\021", "\\022", "\\023", "\\024", "\\025", "\\026", "\\027",
    "\\030", "\\031", "\\032", "\\033", "\\034", "\\035", "\\036", "\\037",
    " ",     "!",     "\"",    "#",     "$",     "%",     "&",     "'",
    "\\(",   "\\)",   "*",     "+",     ",",     "-",     ".",     "/",
    "0",     "1",     "2",     "3",     "4",     "5",     "6",     "7",
    "8",     "9",     ":",     ";",     "<",     "=",     ">",     "?",
    "@",     "A",     "B",     "C",     "D",     "E",     "F",     "G",
    "H",     "I",     "J",     "K",     "L",     "M",     "N",     "O",
    "P",     "Q",     "R",     "S",     "T",     "U",     "V",     "W",
    "X",     "Y",     "Z",     "[",     "\\\\",  "]",     "^",     "_",
    "`",     "a",     "b",     "c",     "d",     "e",     "f",     "g",
    "h",     "i",     "j",     "k",     "l",     "m",     "n",     "o",
    "p",     "q",     "r",     "s",     "t",     "u",     "v",     "w",
    "x",     "y",     "z",     "{",     "|",     "}",     "~",     "\\177",
    "\\200", "\\201", "\\202", "\\203", "\\204", "\\205", "\\206", "\\207",
    "\\210", "\\211", "\\212", "\\213", "\\214", "\\215", "\\216", "\\217",
    "\\220", "\\221", "\\222", "\\223", "\\224", "\\225", "\\226", "\\227",
    "\\230", "\\231", "\\232", "\\233", "\\234", "\\235", "\\236", "\\237",
    "\\240", "\\241", "\\242", "\\243", "\\244", "\\245", "\\246", "\\247",
    "\\250", "\\251", "\\252", "\\253", "\\254", "\\255", "\\256", "\\257",
    "\\260", "\\261", "\\262", "\\263", "\\264", "\\265", "\\266", "\\267",
    "\\270", "\\271", "\\272", "\\273", "\\274", "\\275", "\\276", "\\277",
    "\\300", "\\301", "\\302", "\\303", "\\304", "\\305", "\\306", "\\307",
    "\\310", "\\311", "\\312", "\\313", "\\314", "\\315", "\\316", "\\317",
    "\\320", "\\321", "\\322", "\\323", "\\324", "\\325", "\\326", "\\327",
    "\\330", "\\331", "\\332", "\\333", "\\334", "\\335", "\\336", "\\337",
    "\\340", "\\341", "\\342", "\\343", "\\344", "\\345", "\\346", "\\347",
    "\\350", "\\351", "\\352", "\\353", "\\354", "\\355", "\\356", "\\357",
    "\\360", "\\361", "\\362", "\\363", "\\364", "\\365", "\\366", "\\367",
    "\\370", "\\371", "\\372", "\\373", "\\374", "\\375", "\\376", "\\377"
#else
#if CHAR_OUT==1
    "",      "\\001", "\\002", "\\003", "\\004", "\\005", "\\006", "\\007",
    "\\010", "\\011", "\\012", "\\013", "\\014", "\\015", "\\016", "\\017",
    "\\020", "\\021", "\\022", "\\023", "\\024", "\\025", "\\026", "\\027",
    "\\030", "\\031", "\\032", "\\033", "\\034", "\\035", "\\036", "\\037",
    " ",     "!",     "\"",    "#",     "$",     "%",     "&",     "'",
    "\\(",   "\\)",   "*",     "+",     ",",     "-",     ".",     "/",
    "0",     "1",     "2",     "3",     "4",     "5",     "6",     "7",
    "8",     "9",     ":",     ";",     "<",     "=",     ">",     "?",
    "@",     "A",     "B",     "C",     "D",     "E",     "F",     "G",
    "H",     "I",     "J",     "K",     "L",     "M",     "N",     "O",
    "P",     "Q",     "R",     "S",     "T",     "U",     "V",     "W",
    "X",     "Y",     "Z",     "[",     "\\\\",  "]",     "^",     "_",
    "`",     "a",     "b",     "c",     "d",     "e",     "f",     "g",
    "h",     "i",     "j",     "k",     "l",     "m",     "n",     "o",
    "p",     "q",     "r",     "s",     "t",     "u",     "v",     "w",
    "x",     "y",     "z",     "{",     "|",     "}",     "~",     "\\177",
    "\\200", "\\201", "\\202", "\\203", "\\204", "\\205", "\\206", "\\207",
    "\\210", "\\211", "\\212", "\\213", "\\214", "\\215", "\\216", "\\217",
    "\220",  "\221",  "\222",  "\223",  "\224",  "\225",  "\226",  "\227",
    "\230",  "\\231", "\232",  "\233",  "\\234", "\235",  "\236",  "\237",
    "\240",  "\241",  "\242",  "\243",  "\244",  "\245",  "\246",  "\247",
    "\250",  "\251",  "\252",  "\253",  "\254",  "\255",  "\256",  "\257",
    "\260",  "\261",  "\262",  "\263",  "\264",  "\265",  "\266",  "\267",
    "\270",  "\271",  "\272",  "\273",  "\274",  "\275",  "\276",  "\277",
    "\300",  "\301",  "\302",  "\303",  "\304",  "\305",  "\306",  "\307",
    "\310",  "\311",  "\312",  "\313",  "\314",  "\315",  "\316",  "\317",
    "\320",  "\321",  "\322",  "\323",  "\324",  "\325",  "\326",  "\327",
    "\330",  "\331",  "\332",  "\333",  "\334",  "\335",  "\336",  "\337",
    "\340",  "\341",  "\342",  "\343",  "\344",  "\345",  "\346",  "\347",
    "\350",  "\351",  "\352",  "\353",  "\354",  "\355",  "\356",  "\357",
    "\360",  "\361",  "\362",  "\363",  "\364",  "\365",  "\366",  "\367",
    "\370",  "\371",  "\372",  "\373",  "\374",  "\375",  "\376",  "\377"
#else
If you are trying to compile this you have the wrong CHAR_OUT value!
#endif
#endif
};

/*****************************************************************************/
/*                                                                           */
/*  char *MediaName(int h, int v)                                            */
/*                                                                           */
/*  Return the PostScript MediaName attribute appropriate to a page of       */
/*  width h and height v.                                                    */
/*                                                                           */
/*  Communicated by Valeriy E. Ushakov, who wrote:                           */
/*                                                                           */
/*  "Attached is a patch to recognize known paper sizes and emit them as     */
/*  media name in DocumentMedia comment.  GhostView and other PostScript     */
/*  viewers recognize these names and display them to the user.  Thus user   */
/*  knows what paper size document uses without having to know the magic     */
/*  numbers."                                                                */
/*                                                                           */
/*****************************************************************************/

static const char *MediaName(int h, int v)
{
    struct paper {
       const char *name;
       FULL_LENGTH width, height;
    };

    /* names for known paper sizes */
    static const struct paper paper_map[] = {
       { "Letter",     612*PT,  792*PT },
       { "Tabloid",    792*PT, 1224*PT },
       { "Ledger",    1224*PT,  792*PT },
       { "Legal",      612*PT, 1008*PT },
       { "Statement",  396*PT,  612*PT },
       { "Executive",  540*PT,  720*PT },
       { "A3",         842*PT, 1190*PT },
       { "A4",         595*PT,  842*PT },
       { "A5",         420*PT,  595*PT },
       { "B4",         729*PT, 1032*PT },
       { "B5",         516*PT,  729*PT },
       { "Folio",      612*PT,  936*PT },
       { "Quarto",     610*PT,  780*PT },
       { "10x14",      720*PT, 1008*PT },
       { NULL,              0,       0 }
    };

    /* default media name */
    static const char *user_defined = "Plain";

    const struct paper *p;
    for (p = paper_map; p->name; ++p) {
       if ((h == p->width) && (v == p->height)) {
           return p->name;
       }
    }
    return user_defined;
}


/*****************************************************************************/
/*                                                                           */
/*  PrintInit(file_ptr)                                                      */
/*                                                                           */
/*  Initialise this module.  Output is to go to FILE file_ptr.               */
/*                                                                           */
/*****************************************************************************/

void PrintInit(FILE *file_ptr)
{ debug0(DGP, DD, "PrintInit()");
  out_fp = file_ptr;  prologue_done = FALSE;
  gs_stack_top = -1;
  currentfont = NO_FONT;
  currentcolour = NO_COLOUR;
  cpexists = FALSE;
  wordcount = pagecount = 0;
  New(needs, ACAT);
  New(supplied, ACAT);
  debug0(DGP, DD, "PrintInit returning.");
}


/*@::PrintBeforeFirst@********************************************************/
/*                                                                           */
/*  PrintBeforeFirst(h, v, label)                                            */
/*                                                                           */
/*  This procedure is called just before starting to print the first         */
/*  component of the output.  Its size is h, v, and label is the page        */
/*  label to attach to the %%Page comment.                                   */
/*                                                                           */
/*  If BackEnd is PLAINTEXT, this procedure obtains a two-dimensional array  */
/*  of characters large enough to hold the first component, and clears it.   */
/*                                                                           */
/*  If BackEnd is POSTSCRIPT, this procedure generates the PostScript        */
/*  prologue, augmented with any @PrependGraphic or @SysPrependGraphic       */
/*  files specified by the user.  The following PostScript operators are     */
/*  defined:                                                                 */
/*                                                                           */
/*      scale_factor  fnt       scale and set font                           */
/*      x_coordinate  x         move to x_coordinate, current y coordinate   */
/*      string        s         show string                                  */
/*      number        in        result is number inches                      */
/*      number        cm        result is number centimetres                 */
/*      number        pt        result is number points                      */
/*      number        sp        result is number spaces                      */
/*      number        vs        result is number vspaces                     */
/*      number        ft        result is number font-sizes                  */
/*                                                                           */
/*  as well as LoutGraphic, for use with the @Graphic operator:              */
/*                                                                           */
/*      xsize ysize xmark ymark fr vs sp LoutGraphic -                       */
/*                                                                           */
/*  Define xmark, ymark, xsize, ysize to be the positions of                 */
/*  these features of x, and define symbols ft, vs and sp                    */
/*  to be the current font size, line separation, and space width.           */
/*                                                                           */
/*****************************************************************************/

void PrintBeforeFirst(FULL_LENGTH h, FULL_LENGTH v, FULL_CHAR *label)
{ FILE_NUM fnum;  int i, j;  FULL_CHAR *p;
  debug2(DGP, DD, "PrintBeforeFirst(%d, %d)", h, v);

  switch( BackEnd )
  {
    case PLAINTEXT:

      /* get a new page[] and clear it */
      hsize = ceiling(h, PlainCharWidth);
      vsize = ceiling(v, PlainCharHeight);
      debug2(DGP, DD, "  PlainCharWidth: %d;  PlainCharHeight: %d",
	PlainCharWidth, PlainCharHeight);
      ifdebug(DMA, D, DebugRegisterUsage(MEM_PAGES, 1,
	hsize * vsize * sizeof(FULL_CHAR)));
      debug2(DGP, DD, "  PrintBeforeFirst allocating %d by %d", hsize, vsize);
      page = (FULL_CHAR *) malloc(hsize * vsize * sizeof(FULL_CHAR));
      for( i = 0;  i < vsize;  i++ )
	for( j = 0;  j < hsize;  j++ )
	  page[i*hsize + j] = ' ';
      break;


    case POSTSCRIPT:

      /* print header comments for PostScript DSC 3.0 output */
      if( Encapsulated )
        fprintf(out_fp, "%%!PS-Adobe-3.0 EPSF-3.0\n");
      else
        fprintf(out_fp, "%%!PS-Adobe-3.0\n");
      fprintf(out_fp, "%%%%Creator: %s\n", LOUT_VERSION);
      fprintf(out_fp, "%%%%CreationDate: %s", TimeString());
      fprintf(out_fp, "%%%%DocumentData: Binary\n");
      fprintf(out_fp, "%%%%DocumentNeededResources: (atend)\n");
      fprintf(out_fp, "%%%%DocumentSuppliedResources: (atend)\n");
      fprintf(out_fp, "%%%%DocumentMedia: %s %d %d 0 white ()\n",
	MediaName(h, v), h/PT, v/PT);
      fprintf(out_fp, "%%%%PageOrder: Ascend\n");
      fprintf(out_fp, "%%%%Pages: (atend)\n");
      fprintf(out_fp, "%%%%BoundingBox: 0 0 %d %d\n", h/PT, v/PT);
      fprintf(out_fp, "%%%%EndComments\n\n");

      /* print procedure definitions part of header */
      fprintf(out_fp, "%%%%BeginProlog\n");
      fprintf(out_fp, "%%%%BeginResource: procset %s\n", StartUpResource);
      fprintf(out_fp, "/save_cp { currentpoint /cp_y exch def /cp_x exch def } def\n");
      fprintf(out_fp, "/restore_cp { cp_x cp_y moveto } def\n");
      fprintf(out_fp, "/outline { gsave 1 1 1 setrgbcolor dup show save_cp\n");
      fprintf(out_fp, "  grestore true charpath stroke restore_cp } bind def\n");
      fprintf(out_fp, "/m  { 3 1 roll moveto show } bind def\n");
      fprintf(out_fp, "/mo { 3 1 roll moveto outline } bind def\n");
      fprintf(out_fp, "/s  { exch currentpoint exch pop moveto show } bind def\n");
      fprintf(out_fp, "/so { exch currentpoint exch pop moveto outline } bind def\n");
      fprintf(out_fp, "/k  { exch neg 0 rmoveto show } bind def\n");
      fprintf(out_fp, "/ko { exch neg 0 rmoveto outline } bind def\n");
      fprintf(out_fp, "/r  { exch 0 rmoveto show } bind def\n");
      fprintf(out_fp, "/ro { exch 0 rmoveto outline } bind def\n");
      fprintf(out_fp, "/c  { gsave 3 1 roll rmoveto show grestore } bind def\n");
      fprintf(out_fp, "/co { gsave 3 1 roll rmoveto outline grestore } bind def\n");
      fprintf(out_fp, "/ul { gsave setlinewidth dup 3 1 roll\n");
      fprintf(out_fp, "      moveto lineto stroke grestore } bind def\n");
      fprintf(out_fp, "/in { %d mul } def\n", IN);
      fprintf(out_fp, "/cm { %d mul } def\n", CM);
      fprintf(out_fp, "/pt { %d mul } def\n", PT);
      fprintf(out_fp, "/em { %d mul } def\n", EM);
      fprintf(out_fp, "/sp { louts mul } def\n");
      fprintf(out_fp, "/vs { loutv mul } def\n");
      fprintf(out_fp, "/ft { loutf mul } def\n");
      fprintf(out_fp, "/dg {           } def\n\n");

      fputs("/LoutGraphic {\n",					  out_fp);
      fputs("  /louts exch def\n",				  out_fp);
      fputs("  /loutv exch def\n",				  out_fp);
      fputs("  /loutf exch def\n",				  out_fp);
      fputs("  /ymark exch def\n",				  out_fp);
      fputs("  /xmark exch def\n",				  out_fp);
      fputs("  /ysize exch def\n",				  out_fp);
      fputs("  /xsize exch def\n} def\n\n",			  out_fp);

      fputs("/LoutGr2 { gsave translate LoutGraphic gsave } def\n\n", out_fp);

      /* print definition used by Lout output to recode fonts                */
      /* adapted from PostScript Language Reference Manual (2nd Ed), p. 275  */
      /* usage: /<fullname> <encodingvector> /<originalname> LoutRecode -    */

      fputs("/LoutFont\n",                                            out_fp);
      fputs("{ findfont exch scalefont setfont\n",                    out_fp);
      fputs("} bind def\n\n",					      out_fp);

      fputs("/LoutRecode {\n",                                        out_fp);
      fputs("  { findfont dup length dict begin\n",                   out_fp);
      fputs("    {1 index /FID ne {def} {pop pop} ifelse} forall\n",  out_fp);
      fputs("    /Encoding exch def\n",                               out_fp);
      fputs("    currentdict end definefont pop\n",                   out_fp);
      fputs("  }\n",                                                  out_fp);
      fputs("  stopped pop\n",                                         out_fp);
      fputs("} bind def\n\n",                                         out_fp);

      /* print definitions used by Lout output when including EPSF files     */
      /* copied from PostScript Language Reference Manual (2nd Ed.), p. 726  */

      fputs("/BeginEPSF {\n",					  out_fp);
      fputs("  /LoutEPSFState save def\n",			  out_fp);
      fputs("  /dict_count countdictstack def\n",		  out_fp);
      fputs("  /op_count count 1 sub def\n",			  out_fp);
      fputs("  userdict begin\n",				  out_fp);
      fputs("  /showpage { } def\n",				  out_fp);
      fputs("  0 setgray 0 setlinecap\n",			  out_fp);
      fputs("  1 setlinewidth 0 setlinejoin\n",			  out_fp);
      fputs("  10 setmiterlimit [] 0 setdash newpath\n",	  out_fp);
      fputs("  /languagelevel where\n",				  out_fp);
      fputs("  { pop languagelevel\n",				  out_fp);
      fputs("    1 ne\n",					  out_fp);
      fputs("    { false setstrokeadjust false setoverprint\n",	  out_fp);
      fputs("    } if\n",					  out_fp);
      fputs("  } if\n",						  out_fp);
      fputs("} bind def\n\n",					  out_fp);

      fputs("/EndEPSF {\n",					  out_fp);
      fputs("  count op_count sub { pop } repeat\n",		  out_fp);
      fputs("  countdictstack dict_count sub { end } repeat\n",	  out_fp);
      fputs("  LoutEPSFState restore\n",			  out_fp);
      fputs("} bind def\n",					  out_fp);

      fputs("%%EndResource\n\n",				  out_fp);

      /* print encoding vectors as resources */
      /* MapPrintEncodings(out_fp); obsolete now */

      /* print prepend files (assumed to be organized as DSC 3.0 Resources) */
      for( fnum=FirstFile(PREPEND_FILE);  fnum!=NO_FILE;  fnum=NextFile(fnum) )
      { FULL_CHAR buff[MAX_BUFF];  FILE *fp;
        if( (fp = OpenFile(fnum, FALSE, FALSE)) == null )
          Error(24, 1, "cannot open %s file %s",
	    WARN, PosOfFile(fnum), KW_PREPEND, FileName(fnum));
        else if( StringFGets(buff, MAX_BUFF, fp) == NULL )
          Error(24, 2, "%s file %s is empty",
	    WARN, PosOfFile(fnum), KW_PREPEND, FileName(fnum));
        else
        {
          if( StringBeginsWith(buff, AsciiToFull("%%BeginResource:")) )
	  { OBJECT tmp;
	    tmp = MakeWord(WORD, &buff[strlen("%%BeginResource:")], no_fpos);
	    Link(supplied, tmp);
	  }
	  else
	    Error(24, 3, "%s file %s lacks PostScript BeginResource comment",
	      WARN, PosOfFile(fnum), KW_PREPEND, FileName(fnum));
          StringFPuts(buff, out_fp);
          fprintf(out_fp, "%% %s file %s\n", KW_PREPEND, FileName(fnum));
          while( StringFGets(buff, MAX_BUFF, fp) != NULL )
	    StringFPuts(buff, out_fp);
	  fprintf(out_fp, "\n");
	  fclose(fp);
        }
      }

      fputs("%%EndProlog\n\n", out_fp);
      fputs("%%BeginSetup\n", out_fp);
      FontPrintPageSetup(out_fp);
      fputs("%%EndSetup\n\n", out_fp);
      fprintf(out_fp, "%%%%Page: ");
      for( p = label;  *p != '\0';  p++ )
	fputs(EightBitToPrintForm[*p], out_fp);
      fprintf(out_fp, " %d\n", ++pagecount);
      fprintf(out_fp, "%%%%BeginPageSetup\n");
      FontPrintPageResources(out_fp);
      FontAdvanceCurrentPage();
      fprintf(out_fp, "/pgsave save def\n");
      fprintf(out_fp, "%.4f dup scale %d setlinewidth\n", 1.0 / PT, PT/2);
      fprintf(out_fp, "%%%%EndPageSetup\n\n");
      break;

    case PDF:

      PDFFile_Init(out_fp, h/PT, v/PT, IN, CM, PT, EM);

      /* print encoding vectors as resources */
      /* MapPrintEncodings(out_fp); obsolete now */

	FontPrintPageSetup(out_fp);

      PDFPage_Init(out_fp, 1.0 / PT, PT/2);

    	FontPrintPageResources(out_fp);	/*	write out font objects	*/
      FontAdvanceCurrentPage();
      break;

 } /* end switch */
 prologue_done = TRUE;
} /* end PrintBeforeFirst */


/*@::PrintBetween()@**********************************************************/
/*                                                                           */
/*  PrintBetween(h, v, label)                                                */
/*                                                                           */
/*  Start a new output component, of size h by v; label is the page label    */
/*  to attach to the %%Page comment.                                         */
/*                                                                           */
/*****************************************************************************/

void PrintBetween(FULL_LENGTH h, FULL_LENGTH v, FULL_CHAR *label)
{ int new_hsize, new_vsize, i, j, jmax;  FULL_CHAR *p;
  debug2(DGP, DD, "PrintBetween(%d, %d)", h, v);

  switch( BackEnd )
  {
    case PLAINTEXT:

      /* print the page that has just ended */
      ifdebug(DGP, D,
	putc('+', out_fp);
	for( j = 0;  j < hsize;  j++ )  putc('-', out_fp);
	putc('+', out_fp);
	putc('\n', out_fp);
      );
      for( i = vsize - 1;  i >= 0;  i-- )
      { ifdebug(DGP, D, putc('|', out_fp));
	for( jmax = hsize-1;  jmax >= 0 && page[i*hsize+jmax] == ' ';  jmax--);
	ifdebug(DGP, D, jmax = hsize - 1);
	for( j = 0;  j <= jmax;  j++ )
	  putc(page[i*hsize + j], out_fp);
        ifdebug(DGP, D, putc('|', out_fp));
	putc('\n', out_fp);
      }
      ifdebug(DGP, D,
	putc('+', out_fp);
	for( j = 0;  j < hsize;  j++ )  putc('-', out_fp);
	putc('+', out_fp);
	putc('\n', out_fp);
      );

      /* separate the page from the next one with a form-feed if required */
      if( PlainFormFeed ) putc('\f', out_fp);

      /* if page size has changed, get a new page[] array */
      new_hsize = ceiling(h, PlainCharWidth);
      new_vsize = ceiling(v, PlainCharHeight);
      if( new_hsize != hsize || new_vsize != vsize )
      {
        ifdebug(DMA, D, DebugRegisterUsage(MEM_PAGES, -1,
	  -hsize * vsize * sizeof(FULL_CHAR)));
	free(page);
	hsize = new_hsize;
	vsize = new_vsize;
        debug2(DGP, DD, "  PrintBetween allocating %d by %d", hsize, vsize);
        ifdebug(DMA, D, DebugRegisterUsage(MEM_PAGES, 1,
	  hsize * vsize * sizeof(FULL_CHAR)));
        page = (FULL_CHAR *) malloc(hsize * vsize * sizeof(FULL_CHAR));
      }

      /* clear page[] for the new page just beginning */
      for( i = 0;  i < vsize;  i++ )
	for( j = 0;  j < hsize;  j++ )
	  page[i*hsize + j] = ' ';
      break;


    case POSTSCRIPT:

      fprintf(out_fp, "\npgsave restore\nshowpage\n");
      gs_stack_top = 0;
      cpexists = FALSE;
      currentfont = NO_FONT;
      currentcolour = NO_COLOUR;
      if( Encapsulated )
      { PrintAfterLast();
        Error(24, 4, "truncating -EPS document at end of first page",
	  FATAL, no_fpos);
      }
      fprintf(out_fp, "\n%%%%Page: ");
      for( p = label;  *p != '\0';  p++ )
	fputs(EightBitToPrintForm[*p], out_fp);
      fprintf(out_fp, " %d\n", ++pagecount);
      fprintf(out_fp, "%%%%BeginPageSetup\n");
      FontPrintPageResources(out_fp);
      fprintf(out_fp, "/pgsave save def\n");
      FontPrintPageSetup(out_fp);
      FontAdvanceCurrentPage();
      fprintf(out_fp, "%.4f dup scale %d setlinewidth\n", 1.0 / PT, PT/2);
      fprintf(out_fp, "%%%%EndPageSetup\n");
      wordcount = 0;
      break;

    case PDF:

      /* write out page objects	*/
      PDFPage_Cleanup(out_fp);
      PDFPage_Init(out_fp, 1.0 / PT, PT/2);

      /* write out font objects	*/
      FontPrintPageResources(out_fp);
      FontPrintPageSetup(out_fp);
      FontAdvanceCurrentPage();
      break;

  } /* end switch */
} /* end PrintBetween */


/*****************************************************************************/
/*                                                                           */
/*  KernLength(fnum, ch1, ch2, res)                                          */
/*                                                                           */
/*  Set res to the kern length between ch1 and ch2 in font fnum, or 0 if     */
/*  none.                                                                    */
/*                                                                           */
/*****************************************************************************/

#define KernLength(fnum, mp, ch1, ch2, res)				\
{ int ua_ch1 = mp[ch1];							\
  int ua_ch2 = mp[ch2];							\
  int i = finfo[fnum].kern_table[ua_ch1], j;				\
  if( i == 0 )  res = 0;						\
  else									\
  { FULL_CHAR *kc = finfo[fnum].kern_chars;				\
    for( j = i;  kc[j] > ua_ch2;  j++ );				\
    res = (kc[j] == ua_ch2) ?						\
      finfo[fnum].kern_sizes[finfo[fnum].kern_value[j]] : 0;		\
  }									\
} /* end KernLength */


/*****************************************************************************/
/*                                                                           */
/*  static void PrintComposite(COMPOSITE *cp, BOOLEAN outline, FILE *fp)     */
/*                                                                           */
/*  Print composite character cp, assuming that the current point is         */
/*  set to the correct origin.  If outline is true, we want to print the     */
/*  composite character in outline.                                          */
/*                                                                           */
/*****************************************************************************/

static void PrintComposite(COMPOSITE *cp, BOOLEAN outline, FILE *fp)
{ debug1(DGP, D, "PrintComposite(cp, %s, fp)", bool(outline));
  while( cp->char_code != '\0' )
  {
    debug4(DGP, D, "  cp = %d printing code %d (%d, %d)", (int) cp,
      cp->char_code, cp->x_offset, cp->y_offset);
    fprintf(fp, "%d %d (%c)%s ", cp->x_offset, cp->y_offset,
      cp->char_code, outline ? "co" : "c");
    cp++;
  }
} /* end PrintComposite */


/*@::PrintWord()@*************************************************************/
/*                                                                           */
/*  PrintWord(x, hpos, vpos)                                                 */
/*                                                                           */
/*  Print non-empty word x; its marks cross at the point (hpos, vpos).       */
/*                                                                           */
/*****************************************************************************/

void PrintWord(OBJECT x, int hpos, int vpos)
{ FULL_CHAR *p, *q, *a, *b, *lig, *unacc;
  int i, h, v, ksize;  char *command;  MAPPING m;
  unsigned short *composite; COMPOSITE *cmp;

  debug6(DGP, DD, "PrintWord( %s, %d, %d ) font %d colour %d%s", string(x),
	hpos, vpos, word_font(x), word_colour(x),
	word_outline(x) ? " outline" : "");
  TotalWordCount++;

  switch( BackEnd )
  {
    case PLAINTEXT:

      h = ((float) hpos / PlainCharWidth) + 0.5;
      v = ((float) vpos / PlainCharHeight);
      debug3(DGP, DD, "PrintWord(%s at h = %d, v = %d)", string(x), h, v);
      if( h >= 0 && h + StringLength(string(x)) < hsize && v >= 0 && v < vsize )
      {
        assert( h >= 0,     "PrintWord:  h < 0!" );
        assert( h <  hsize, "PrintWord:  h >= hsize!" );
        assert( v >= 0,     "PrintWord:  v < 0!" );
        assert( v <  vsize, "PrintWord:  v >= vsize!" );
        p = &page[v*hsize + h];
        for( i = 0;  string(x)[i] != '\0';  i++ )
	  *p++ = string(x)[i];
      }
      else
      {
        Error(24, 11, "word %s deleted (internal error, off page at %d,%d)",
          WARN, &fpos(x), string(x), h, v);
      }
      break;


    case POSTSCRIPT:

      /* if font is different to previous word then print change */
      if( word_font(x) != currentfont )
      { currentfont = word_font(x);
        currentxheight2 = FontHalfXHeight(currentfont);
        fprintf(out_fp, "%hd %s", FontSize(currentfont, x),
          FontName(currentfont));
        if( ++wordcount >= 5 )
        { putc('\n', out_fp);
          wordcount = 0;
        }
        else putc(' ', out_fp);
      }

      /* if colour is different to previous word then print change */
      if( word_colour(x) != currentcolour )
      { currentcolour = word_colour(x);
	if( currentcolour > 0 )
	{ fprintf(out_fp, "%s", ColourCommand(currentcolour));
          if( ++wordcount >= 5 )
          { putc('\n', out_fp);
            wordcount = 0;
          }
          else putc(' ', out_fp);
	}
      }

      /* convert ligature sequences into ligature characters */
      lig = finfo[word_font(x)].lig_table;
      p = q = string(x);
      do
      { 
        /* check for missing glyph (lig[] == 1) or ligatures (lig[] > 1) */
        if( lig[*q++ = *p++] )
        {
          if( lig[*(q-1)] == 1 ) continue;
          else
          { a = &lig[ lig[*(p-1)] + MAX_CHARS ];
            while( *a++ == *(p-1) )
            { b = p;
              while( *a == *b && *(a+1) != '\0' && *b != '\0' )  a++, b++;
              if( *(a+1) == '\0' )
              { *(q-1) = *a;
                p = b;
                break;
              }
              else
              { while( *++a );
                a++;
              }
            }
          }
        }
      } while( *p );
      *q = '\0';

      /* move to coordinate of x */
      cmp = finfo[word_font(x)].cmp_table;
      composite = finfo[word_font(x)].composite;
      debug1(DGP, DDD, "  currentxheight2 = %d", currentxheight2);
      vpos = vpos - currentxheight2;
      if( cpexists && currenty == vpos )
      { printnum(hpos, out_fp);
        command = word_outline(x) ? "so" : "s";
      }
      else
      { currenty = vpos;
        printnum(hpos, out_fp);
        putc(' ', out_fp);
        printnum(currenty, out_fp);
        command = word_outline(x) ? "mo" : "m";
        cpexists = TRUE;
      }

      /* show string(x) */
      putc('(', out_fp);
      p = string(x);
      if( composite[*p] )
      {
	fprintf(out_fp, ")%s ", command);
	debug3(DGP, D,
	  "  calling PrintComposite(&cmp[composite[%d] = %d]); cmp_top = %d",
	  (int) *p, composite[*p], finfo[word_font(x)].cmp_top);
	PrintComposite(&cmp[composite[*p]], word_outline(x), out_fp);
	printnum(finfo[word_font(x)].size_table[*p].right, out_fp);
        putc('(', out_fp);
	command = word_outline(x) ? "ro" : "r";
      }
      else fputs(EightBitToPrintForm[*p], out_fp);
      m = font_mapping(finfo[word_font(x)].font_table);
      unacc = MapTable[m]->map[MAP_UNACCENTED];
      /* acc   = MapTable[m]->map[MAP_ACCENT]; */
      for( p++;  *p;  p++ )
      { KernLength(word_font(x), unacc, *(p-1), *p, ksize);
        if( ksize != 0 )
        { fprintf(out_fp, ")%s %d(", command, -ksize);
          ++wordcount;
          command = word_outline(x) ? "ko" : "k";
        }
	if( composite[*p] )
	{ fprintf(out_fp, ")%s ", command);
	  debug3(DGP, D,
	    "  calling PrintComposite(&cmp[composite[%d] = %d]); cmp_top = %d",
	    (int) *p, composite[*p], finfo[word_font(x)].cmp_top);
	  PrintComposite(&cmp[composite[*p]], word_outline(x), out_fp);
	  printnum(finfo[word_font(x)].size_table[*p].right, out_fp);
          putc('(', out_fp);
	  command = word_outline(x) ? "ro" : "r";
	}
	else fputs(EightBitToPrintForm[*p], out_fp);
      }
      if( ++wordcount >= 5 )
      { fprintf(out_fp, ")%s\n", command);
        wordcount = 0;
      }
      else fprintf(out_fp, ")%s ", command);


      /* move to coordinate of x */
      /* *** old version
      debug1(DGP, DDD, "  currentxheight2 = %d", currentxheight2);
      vpos = vpos - currentxheight2;
      if( cpexists && currenty == vpos )
      { printnum(hpos, out_fp);
        command = word_outline(x) ? "so" : "s";
      }
      else
      { currenty = vpos;
        printnum(hpos, out_fp);
        fputs(" ", out_fp);
        printnum(currenty, out_fp);
        command = word_outline(x) ? "mo" : "m";
        cpexists = TRUE;
      }
      *** */

      /* show string(x) */
      /* *** old version
      fputs("(", out_fp);
      p = string(x);
      fputs(EightBitToPrintForm[*p], out_fp);
      m = font_mapping(finfo[word_font(x)].font_table);
      unacc = MapTable[m]->map[MAP_UNACCENTED];
      for( p++;  *p;  p++ )
      { KernLength(word_font(x), unacc, *(p-1), *p, ksize);
        if( ksize != 0 )
        { fprintf(out_fp, ")%s %d(", command, -ksize);
          ++wordcount;
          command = word_outline(x) ? "ko" : "k";
        }
	fputs(EightBitToPrintForm[*p], out_fp);
      }
      if( ++wordcount >= 5 )
      { fprintf(out_fp, ")%s\n", command);
        wordcount = 0;
      }
      else fprintf(out_fp, ")%s ", command);
      *** */

      /* ordinary printing moves current point; outlining destroys it */
      /* *** changed the outline commands now so that they move the current
	     point the same way ordinary printing does
      if( word_outline(x) )
	cpexists = FALSE;
      *** */
      break;



    case PDF:
    {

      static int last_hpos;	/* does not need to be initialised */
      static int next_hpos = -1;
#if 0
      struct metrics *fnt;
#endif
      /* if font is different to previous word then print change */
      if( word_font(x) != currentfont )
      { currentfont = word_font(x);
        currentxheight2 = FontHalfXHeight(currentfont);
	  PDFFont_Set(out_fp, FontSize(currentfont, x), FontName(currentfont));
      }

      /* if colour is different to previous word then print change */
      if( word_colour(x) != currentcolour )
      {
        currentcolour = word_colour(x);
	  if( currentcolour > 0 )
	  {
          char	str[256];

	    sprintf(str, "%s ", ColourCommand(currentcolour));
	    PDFPage_Write(out_fp, str);
        }
      }

      /* move to coordinate of x */
      debug1(DGP, DDD, "  currentxheight2 = %d", currentxheight2);
      vpos = vpos - currentxheight2;
      if( cpexists && (currenty == vpos) && PDFHasValidTextMatrix() )
      { /* printnum(hpos, out_fp); */
        command = "s";
/*
	Note: I calculate the width of the space char here in case the font has
	changed. This prevents subtle spacing errors from occurring.
 */
#if 0
        fnt = finfo[currentfont].size_table;

        if ( (next_hpos + fnt[' '].right /* width of space char */ ) == hpos )
          command = " ";
#endif
      }
      else
      { currenty = vpos;
        /* printnum(hpos, out_fp);
        fputs(" ", out_fp);
        printnum(currenty, out_fp); */
        command = "m";
        cpexists = TRUE;
      }

      /* convert ligature sequences into ligature characters */
      lig = finfo[word_font(x)].lig_table;
      p = q = string(x);
      do
      { 
        /* check for missing glyph (lig[] == 1) or ligatures (lig[] > 1) */
        if( lig[*q++ = *p++] )
        {
          if( lig[*(q-1)] == 1 ) continue;
          else
          { a = &lig[ lig[*(p-1)] + MAX_CHARS ];
            while( *a++ == *(p-1) )
            { b = p;
              while( *a == *b && *(a+1) != '\0' && *b != '\0' )  a++, b++;
              if( *(a+1) == '\0' )
              { *(q-1) = *a;
                p = b;
                break;
              }
              else
              { while( *++a );
                a++;
              }
            }
          }
        }
      } while( *p );
      *q = '\0';

      /* show string(x) */
      /* FontWordSize(x); - this should not be necessary	*/

      switch (command[0])
      {
	case 'm':

	  PDFText_OpenXY(out_fp, hpos, vpos);
	  last_hpos = hpos;
	  next_hpos =	hpos + fwd(x, COLM);	/* fwd(x, COLM) = width of wd */
	  break;

	case 's':
#if 0
	  PDFText_Open(out_fp);
	  PDFText_Kern(out_fp, hpos - next_hpos);
#else
	  PDFText_OpenX(out_fp, hpos - last_hpos);
#endif
	  last_hpos = hpos;
	  next_hpos =	hpos + fwd(x, COLM);	/* fwd(x, COLM) = width of wd */
	  break;
#if 0
	case ' ':

	  PDFText_Open(out_fp);
#if 1
	  /* try kerning to get correct position */
	  PDFText_Kern(out_fp, fnt[' '].right);
#else
	  PDFPage_Write(out_fp, EightBitToPrintForm[' ']);
#endif
	  next_hpos += fwd(x, COLM) +	fnt[' '].right;	/* width of space ch */
	  break;
#endif
      }

      p = string(x);
      PDFPage_Write(out_fp, EightBitToPrintForm[*p]);

      m = font_mapping(finfo[word_font(x)].font_table);
      unacc = MapTable[m]->map[MAP_UNACCENTED];
      /* acc   = MapTable[m]->map[MAP_ACCENT]; */
      for( p++;  *p;  p++ )
      {
	/* KernLength(word_font(x), unacc, *(p-1), *p, ksize); */
        KernLength(font_num(finfo[word_font(x)].original_font),
	  unacc, *(p-1), *p, ksize);
	if ( ksize != 0 )
	{
	  PDFText_Kern(out_fp, ksize);
	}
	PDFPage_Write(out_fp, EightBitToPrintForm[*p]);
      }
      PDFText_Close(out_fp);
      break;
    }


  } /* end switch */
  debug0(DGP, DDD, "PrintWord returning");
} /* end PrintWord */


/*****************************************************************************/
/*                                                                           */
/*  PrintPlainGraphicObject(x, xmk, ymk, z)                                  */
/*                                                                           */
/*  Print plain graphic object x at xmk, ymk with the size of z.             */
/*                                                                           */
/*****************************************************************************/

void PrintPlainGraphicObject(OBJECT x, FULL_LENGTH xmk,FULL_LENGTH ymk,OBJECT z)
{ int i, len, starth, startv, stoph, stopv, h, v;
  debug2(DGP, D, "PrintPlainGraphicObject(x, xmk %s, ymk %s)",
    EchoLength(xmk), EchoLength(ymk));

  assert( BackEnd == PLAINTEXT, "PrintPlainGraphicObject: back end!" );
  if( type(x) != WORD && type(x) != QWORD )
  {
    Error(24, 12, "left parameter of %s must be a simple word",
      WARN, &fpos(x), KW_PLAINGRAPHIC);
    return;
  }
  len = StringLength(string(x));
  if( StringLength(string(x)) == 0 )
  {
    Error(24, 13, "left parameter of %s must be a non-empty word",
      WARN, &fpos(x), KW_PLAINGRAPHIC);
    return;
  }
  starth = (((float) xmk ) / PlainCharWidth) + 0.5;
  startv = (((float) ymk ) / PlainCharHeight);
  stoph = (((float) xmk + size(z, COLM)) / PlainCharWidth) + 0.5;
  stopv = (((float) ymk - size(z, ROWM)) / PlainCharHeight); /* NB - not + */
  SetLengthDim(COLM);
  debug5(DGP, D, "  xmk %s bk %s fwd %s -> %d,%d",
    EchoLength(xmk), EchoLength(back(z, COLM)), EchoLength(fwd(z, COLM)),
    starth, stoph);
  SetLengthDim(ROWM);
  debug5(DGP, D, "  ymk %s bk %s fwd %s -> %d,%d",
    EchoLength(ymk), EchoLength(back(z, ROWM)), EchoLength(fwd(z, ROWM)),
    startv, stopv);
  if( starth >= 0 && stoph < hsize && startv >= 0 && stopv < vsize )
  { i = 0;
    for( v = startv-1;  v >= stopv;  v-- )
    {
      for( h = starth;  h < stoph;  h++ )
      {
        if( i == len )  i = 0;
        page[v*hsize + h] = string(x)[i++];
      }
    }
  }
  else
  {
    Error(24, 14, "fill %s deleted (internal error, off page at %d,%d)",
      WARN, &fpos(x), string(x), h, v);
  }
} /* end PrintPlainGraphicObject */


/*****************************************************************************/
/*                                                                           */
/*  PrintUnderline(fnum, xstart, xstop, ymk)                                 */
/*                                                                           */
/*  Draw an underline suitable for font fnum, from xstart to xstop at the    */
/*  appropriate distance below mark ymk.                                     */
/*                                                                           */
/*****************************************************************************/

void PrintUnderline(FONT_NUM fnum, FULL_LENGTH xstart, FULL_LENGTH xstop,
  FULL_LENGTH ymk)
{

  debug4(DGP, DD, "PrintUnderline(fnum %d, xstart %s, xstop %s, ymk %s )",
    fnum, EchoLength(xstart), EchoLength(xstop), EchoLength(ymk));

  switch( BackEnd )
  {
    case PLAINTEXT:

      /* do nothing */
      break;


    case POSTSCRIPT:

      fprintf(out_fp, "%d %d %d %d ul\n", xstart, xstop,
	ymk - finfo[fnum].underline_pos, finfo[fnum].underline_thick);
      break;

    case PDF:
	PDFPage_PrintUnderline(out_fp,  xstart, xstop,
	    ymk - finfo[fnum].underline_pos, finfo[fnum].underline_thick);
      break;
  }
  debug0(DGP, DD, "PrintUnderline returning.");
} /* end PrintUnderline */


/*@::PrintAfterLast(), CoordTranslate()@**************************************/
/*                                                                           */
/*  PrintAfterLast()                                                         */
/*                                                                           */
/*  Clean up this module and close output stream.                            */
/*                                                                           */
/*****************************************************************************/

void PrintAfterLast(void)
{ OBJECT x, link;  BOOLEAN first_need;  int i, j, jmax;
  if( prologue_done )
  { 
    switch( BackEnd )
    {
      case PLAINTEXT:

        /* print the page that has just ended (exists since prologue_done) */
	ifdebug(DGP, D,
	  putc('+', out_fp);
	  for( j = 0;  j < hsize;  j++ )  putc('-', out_fp);
	  putc('+', out_fp);
	  putc('\n', out_fp);
	);
        for( i = vsize - 1;  i >= 0;  i-- )
        { ifdebug(DGP, D, putc('|', out_fp));
	  for( jmax = hsize-1;  jmax >= 0 && page[i*hsize+jmax] == ' ';  jmax--);
	  ifdebug(DGP, D, jmax = hsize - 1);
	  for( j = 0;  j <= jmax;  j++ )
	    putc(page[i*hsize + j], out_fp);
          ifdebug(DGP, D, putc('|', out_fp));
	  putc('\n', out_fp);
        }
	ifdebug(DGP, D,
	  putc('+', out_fp);
	  for( j = 0;  j < hsize;  j++ )  putc('-', out_fp);
	  putc('+', out_fp);
	  putc('\n', out_fp);
	);
	break;
    

      case POSTSCRIPT:

        fprintf(out_fp, "\npgsave restore\nshowpage\n");
        fprintf(out_fp, "\n%%%%Trailer\n");

        /* print resource requirements (DSC 3.0 version) - fonts */
        first_need = FontNeeded(out_fp);

        /* print resource requirements (DSC 3.0 version) - included EPSFs  */
        for( link = Down(needs); link != needs; link = NextDown(link) )
        { Child(x, link);
          assert(is_word(type(x)), "PrintAfterLast: needs!" );
          fprintf(out_fp, "%s %s",
	    first_need ? "%%DocumentNeededResources:" : "%%+", string(x));
          first_need = FALSE;
        }

	/* print resources supplied */
	fprintf(out_fp,
	  "%%%%DocumentSuppliedResources: procset %s\n", StartUpResource);
	for( link = Down(supplied);  link != supplied;  link = NextDown(link) )
	{ Child(x, link);
	  fprintf(out_fp, "%%%%+ %s", string(x));
	}
        MapPrintResources(out_fp);

        fprintf(out_fp, "%%%%Pages: %d\n", pagecount);
        fprintf(out_fp, "%%%%EOF\n");
	break;

     case PDF:

    	PDFPage_Cleanup(out_fp);		/* write out page objects */
        /* MapPrintResources(out_fp); not needed */
    	PDFFile_Cleanup(out_fp);
        break;

    } /* end switch */
  } /* end if prologue_done */
} /* end PrintAfterLast */


/*****************************************************************************/
/*                                                                           */
/*  CoordTranslate(xdist, ydist)                                             */
/*                                                                           */
/*  Translate coordinate system by the given x and y distances.              */
/*                                                                           */
/*****************************************************************************/

void CoordTranslate(FULL_LENGTH xdist, FULL_LENGTH ydist)
{ debug2(DRS,D,"CoordTranslate(%s, %s)",
    EchoLength(xdist), EchoLength(ydist));
  assert( BackEnd != PLAINTEXT, "CoordTranslate: BackEnd!" );
  if (BackEnd == POSTSCRIPT)
    fprintf(out_fp, "%d %d translate\n", xdist, ydist);
  else if (BackEnd == PDF)
  {
    if ((xdist != 0) || (ydist != 0))
    {
#if 1
      PDFPage_Translate(out_fp, xdist, ydist);
#else
      char	temp_str[64];
      sprintf(temp_str, "1 0 0 1 %d %d cm\n", xdist, ydist);
      PDFPage_Write(out_fp, temp_str);
#endif
    }
  }
  cpexists = FALSE;
  /***
  currentfont = NO_FONT;
  currentcolour = NO_COLOUR;
  ***/
  debug0(DRS, D, "CoordTranslate returning.");
} /* end CoordTranslate */


/*@::CoordRotate(), CoordScale(), SaveGraphicsState(), etc.@******************/
/*                                                                           */
/*  CoordRotate(amount)                                                      */
/*                                                                           */
/*  Rotate coordinate system by given amount (in internal DG units)          */
/*                                                                           */
/*****************************************************************************/

void CoordRotate(FULL_LENGTH amount)
{ debug1(DRS, D, "CoordRotate(%.1f degrees)", (float) amount / DG);
  assert( BackEnd != PLAINTEXT, "CoordRotate: BackEnd!" );
  if (BackEnd == POSTSCRIPT)
    fprintf(out_fp, "%.4f rotate\n", (float) amount / DG);
  else if (BackEnd == PDF)
  {
    int theAmount = ((amount / DG) % 360);
    if ( theAmount != 0 )
    {
      #define  PI   3.1415926535897931160

      PDFPage_Rotate(out_fp, (double) theAmount * (double) PI / (double) 180.0);
    }
  }
  cpexists = FALSE;
  /***
  currentfont = NO_FONT;
  currentcolour = NO_COLOUR;
  ***/
  debug0(DRS, D, "CoordRotate returning.");
} /* end CoordRotate */


/*****************************************************************************/
/*                                                                           */
/*  CoordScale(ratio, dim)                                                   */
/*                                                                           */
/*  Scale coordinate system by ratio in the given dimension.                 */
/*                                                                           */
/*****************************************************************************/

void CoordScale(float hfactor, float vfactor)
{
#if DEBUG_ON
  char buff[20];
#endif
  assert( BackEnd != PLAINTEXT, "CoordScale: BackEnd!" );
  ifdebug(DRS, D, sprintf(buff, "%.3f, %.3f", hfactor, vfactor));
  debug1(DRS, D, "CoordScale(%s)", buff);
  if (BackEnd == POSTSCRIPT)
    fprintf(out_fp, "%.4f %.4f scale\n", hfactor, vfactor);
  else if (BackEnd == PDF)
  {
    if ( (fabs(hfactor - 1.0) > 0.01) || (fabs(vfactor - 1.0) > 0.01) )
    {
#if 1
      PDFPage_Scale(out_fp, hfactor, vfactor);
#else
      char temp_str[64];
      sprintf(temp_str, "%.2f 0 0 %.2f 0 0 cm\n", hfactor, vfactor);
      PDFPage_Write(out_fp, temp_str);
#endif
    }
  }
  cpexists = FALSE;
  /***
  currentfont = NO_FONT;
  currentcolour = NO_COLOUR;
  ***/
  debug0(DRS, D, "CoordScale returning.");
} /* end CoordScale */


/*****************************************************************************/
/*                                                                           */
/*  SaveGraphicState(x)                                                      */
/*                                                                           */
/*  Save current coord system on stack for later restoration.                */
/*  Object x is just for error reporting, not really used at all.            */
/*                                                                           */
/*****************************************************************************/

void SaveGraphicState(OBJECT x)
{ debug0(DRS, D, "SaveGraphicState()");
  assert( BackEnd != PLAINTEXT, "SaveGraphicState: BackEnd!" );
  if (BackEnd == POSTSCRIPT)
    fprintf(out_fp, "gsave\n");
  else if (BackEnd == PDF)
    PDFPage_Push(out_fp);
  gs_stack_top++;
  if( gs_stack_top >= MAX_GS )
    Error(24, 5, "rotations, graphics etc. too deeply nested (max is %d)",
      FATAL, &fpos(x), MAX_GS);
  gs_stack[gs_stack_top].gs_font	= currentfont;
  gs_stack[gs_stack_top].gs_colour	= currentcolour;
  gs_stack[gs_stack_top].gs_cpexists	= cpexists;
  gs_stack[gs_stack_top].gs_currenty	= currenty;
  gs_stack[gs_stack_top].gs_xheight2	= currentxheight2;
  debug0(DRS, D, "SaveGraphicState returning.");
} /* end SaveGraphicState */


/*****************************************************************************/
/*                                                                           */
/*  RestoreGraphicState()                                                    */
/*                                                                           */
/*  Restore previously saved coordinate system.  NB we normally assume that  */
/*  no white space is needed before any item of output, but since this       */
/*  procedure is sometimes called immediately after PrintGraphicObject(),    */
/*  which does not append a concluding space, we prepend one here.           */
/*                                                                           */
/*****************************************************************************/

void RestoreGraphicState(void)
{ debug0(DRS, D, "RestoreGraphicState()");
  assert( BackEnd != PLAINTEXT, "RestoreGraphicState: BackEnd!" );
  if( BackEnd == POSTSCRIPT )
    fprintf(out_fp, "\ngrestore\n");
  else if( BackEnd == PDF )
    PDFPage_Pop(out_fp);
  currentfont	  = gs_stack[gs_stack_top].gs_font;
  currentcolour	  = gs_stack[gs_stack_top].gs_colour;
  cpexists	  = gs_stack[gs_stack_top].gs_cpexists;
  currenty	  = gs_stack[gs_stack_top].gs_currenty;
  currentxheight2 = gs_stack[gs_stack_top].gs_xheight2;
  gs_stack_top--;
  /* ***
  cpexists = FALSE;
  currentfont = NO_FONT;
  currentcolour = NO_COLOUR;
  *** */
  debug0(DRS, D, "RestoreGraphicState returning.");
} /* end RestoreGraphicState */


/*@::PrintGraphicObject(), DefineGraphicNames()@******************************/
/*                                                                           */
/*  PrintGraphicObject(x)                                                    */
/*                                                                           */
/*  Print object x on out_fp                                                 */
/*                                                                           */
/*****************************************************************************/

void PrintGraphicObject(OBJECT x)
{ OBJECT y, link;
  assert( BackEnd != PLAINTEXT, "PrintGraphicObject: BackEnd!" );
  debug3(DPS, D, "PrintGraphicObject(%s %s %s)",
    EchoFilePos(&fpos(x)), Image(type(x)), EchoObject(x));
  switch( type(x) )
  {
    case WORD:
    case QWORD:
#if 1
      if (BackEnd == POSTSCRIPT)
	StringFPuts(string(x), out_fp);
      else if (BackEnd == PDF)
      {
	PDFPage_WriteGraphic(out_fp, string(x));
      }
#else
      StringFPuts(string(x), out_fp);
#endif
      break;
	

    case ACAT:
    
      for( link = Down(x);  link != x;  link = NextDown(link) )
      {	Child(y, link);
	if( type(y) == GAP_OBJ )
	{
          if( BackEnd == POSTSCRIPT )
	  {
	    if( vspace(y) > 0 )  fputs("\n", out_fp);
	    else if( hspace(y) > 0 ) fputs(" ", out_fp);
	  }
	  else if( BackEnd == PDF )
	  {
	    if( vspace(y) > 0 )  PDFPage_Write(out_fp, "\n");
	    else if( hspace(y) > 0 ) PDFPage_Write(out_fp, " ");
	  }
	}
	else if( is_word(type(y)) || type(y) == ACAT )
	  PrintGraphicObject(y);
	else if( type(y) != WIDE && !is_index(type(y)) )
		/* @Wide, indexes are sometimes inserted by Manifest */
	{ Error(24, 6, "error in left parameter of %s",
	    WARN, &fpos(x), KW_GRAPHIC);
	  debug1(DGP, D, "  type(y) = %s, y =", Image(type(y)));
	  ifdebug(DGP, D, DebugObject(y));
	}
      }
      break;


    default:
    
      Error(24, 7, "error in left parameter of %s", WARN, &fpos(x), KW_GRAPHIC);
      debug1(DGP, D, "  type(x) = %s, x =", Image(type(x)));
      ifdebug(DGP, D, DebugObject(x));
      break;

  }
  debug0(DPS, D, "PrintGraphicObject returning");
} /* end PrintGraphicObject */


/*****************************************************************************/
/*                                                                           */
/*  DefineGraphicNames(x)                                                    */
/*                                                                           */
/*  Generate PostScript for xsize, ysize etc. names of graphic object.       */
/*                                                                           */
/*****************************************************************************/

void DefineGraphicNames(OBJECT x)
{ assert( type(x) == GRAPHIC, "PrintGraphic: type(x) != GRAPHIC!" );
  assert( BackEnd != PLAINTEXT, "DefineGraphicNames: BackEnd!" );
  debug1(DRS, D, "DefineGraphicNames( %s )", EchoObject(x));
  debug1(DRS, DD, "  style = %s", EchoStyle(&save_style(x)));

  /* if font is different to previous word then print change */
  if( font(save_style(x)) != currentfont )
  { currentfont = font(save_style(x));
    if( currentfont > 0 )
    { currentxheight2 = FontHalfXHeight(currentfont);
#if 1	/*	VT 98/01/04: modified for PDF	*/
      if (BackEnd == POSTSCRIPT)
        fprintf(out_fp, "%hd %s ", FontSize(currentfont, x), FontName(currentfont));
      else if (BackEnd == PDF)
	PDFFont_Set(out_fp, FontSize(currentfont, x), FontName(currentfont));
#else
      fprintf(out_fp, "%hd %s ", FontSize(currentfont, x),
        FontName(currentfont));
#endif
    }
  }

  /* if colour is different to previous word then print change */
  if( colour(save_style(x)) != currentcolour )
  { currentcolour = colour(save_style(x));
    if( currentcolour > 0 )
    {
#if 1
      if( BackEnd == POSTSCRIPT )
        fprintf(out_fp, "%s ", ColourCommand(currentcolour));
      else if (BackEnd == PDF)
      {
	char str[256];
	sprintf(str, "%s ", ColourCommand(currentcolour));
	PDFPage_Write(out_fp, str);
      }
#else
      fprintf(out_fp, "%s ", ColourCommand(currentcolour));
#endif
    }
  }

  if (BackEnd == POSTSCRIPT)
    fprintf(out_fp, "%d %d %d %d %d %d %d LoutGraphic\n",
      size(x, COLM), size(x, ROWM), back(x, COLM), fwd(x, ROWM),
      currentfont <= 0 ? 12*PT : FontSize(currentfont, x),
      width(line_gap(save_style(x))), width(space_gap(save_style(x))));
  else if( BackEnd == PDF )
  {
    PDFPage_SetVars(size(x, COLM), size(x, ROWM), back(x, COLM), fwd(x, ROWM),
      currentfont <= 0 ? 12*PT : FontSize(currentfont, x),
      width(line_gap(save_style(x))), width(space_gap(save_style(x))));
  }

  debug0(DRS, D, "DefineGraphicNames returning.");
} /* end DefineGraphicNames */


/*****************************************************************************/
/*                                                                           */
/*  SaveTranslateDefineSave(x, xdist, ydist)                                 */
/*                                                                           */
/*  Equivalent to the sequence of calls                                      */
/*                                                                           */
/*      SaveGraphicState(x)                                                  */
/*      CoordTranslate(xdist, ydist)                                         */
/*      DefineGraphicNames(x)                                                */
/*      SaveGraphicState(x)                                                  */
/*                                                                           */
/*  but generates less PostScript.                                           */
/*                                                                           */
/*****************************************************************************/

void SaveTranslateDefineSave(OBJECT x, FULL_LENGTH xdist, FULL_LENGTH ydist)
{
  if( BackEnd == PDF )
  {
    /* do it bit by bit */
    SaveGraphicState(x);
    CoordTranslate(xdist, ydist);
    DefineGraphicNames(x);
    SaveGraphicState(x);
    return;
  }

  assert( BackEnd == POSTSCRIPT, "SaveTranslateDefineSave: BackEnd!" );
  if( gs_stack_top >= MAX_GS - 1 || font(save_style(x)) != currentfont ||
      colour(save_style(x))!=currentcolour )
  {
    /* do it bit by bit, will be rare anyway */
    SaveGraphicState(x);
    CoordTranslate(xdist, ydist);
    DefineGraphicNames(x);
    SaveGraphicState(x);
  }
  else
  {
    /* no font or colour changes, no stack overflow, so can optimize */

    /* from Save */
    gs_stack_top++;
    gs_stack[gs_stack_top].gs_font	= currentfont;
    gs_stack[gs_stack_top].gs_colour	= currentcolour;
    gs_stack[gs_stack_top].gs_cpexists	= cpexists;
    gs_stack[gs_stack_top].gs_currenty	= currenty;
    gs_stack[gs_stack_top].gs_xheight2	= currentxheight2;

    /* from CoordTranslate */
    cpexists = FALSE;

    /* from Save */
    gs_stack_top++;
    gs_stack[gs_stack_top].gs_font	= currentfont;
    gs_stack[gs_stack_top].gs_colour	= currentcolour;
    gs_stack[gs_stack_top].gs_cpexists	= cpexists;
    gs_stack[gs_stack_top].gs_currenty	= currenty;
    gs_stack[gs_stack_top].gs_xheight2	= currentxheight2;

    /* accumulated output from all four calls, repackaged */
    fprintf(out_fp, "%d %d %d %d %d %d %d %d %d LoutGr2\n",
      size(x, COLM), size(x, ROWM), back(x, COLM), fwd(x, ROWM),
      currentfont <= 0 ? 12*PT : FontSize(currentfont, x),
      width(line_gap(save_style(x))), width(space_gap(save_style(x))),
      xdist, ydist);
      
  }
} /* end SaveTranslateDefineSave */


/*@::PrintGraphicInclude()@***************************************************/
/*                                                                           */
/*  PrintGraphicInclude(x, colmark, rowmark)                                 */
/*                                                                           */
/*  Print graphic include file, with appropriate surrounds.  This code       */
/*  closely follows the PostScript Language Reference Manual, 2n ed.,        */
/*  pages 733-5, except we do not clip the included EPSF.                    */
/*                                                                           */
/*  Note to porters: Version 3.0 of the EPSF standard is not compatible      */
/*  with previous versions.  Thus, this output may crash your system.        */
/*  If you can find out which comment line(s) are causing the trouble,       */
/*  you can add to procedure strip_out to strip them out during the          */
/*  file inclusion step.  e.g. on my system %%EOF causes problems, so I      */
/*  strip it out.                                                            */
/*                                                                           */
/*  May 1994: I've just discovered that %%Trailer causes problems for        */
/*  the mpage Unix utility, so now I'm stripping it out as well.             */
/*                                                                           */
/*****************************************************************************/
#define	SKIPPING	0
#define	READING_DNR	1
#define FINISHED	2

static BOOLEAN strip_out(FULL_CHAR *buff)
{ if( StringBeginsWith(buff, AsciiToFull("%%EOF"))     )  return TRUE;
  if( StringBeginsWith(buff, AsciiToFull("%%Trailer")) )  return TRUE;
  return FALSE;
} /* end strip_out */

void PrintGraphicInclude(OBJECT x, FULL_LENGTH colmark, FULL_LENGTH rowmark)
{ OBJECT y, full_name;  FULL_CHAR buff[MAX_BUFF];
  FILE *fp;  int state;  BOOLEAN compressed;
  debug0(DRS, D, "PrintGraphicInclude(x)");

  if (BackEnd == PDF)
  {
    Error(24, 8, "PrintGraphicInclude: cannot include EPSF in a PDF file. File ignored.",
      WARN, &fpos(x));
    return;
  }

  assert( BackEnd == POSTSCRIPT, "PrintGraphicInclude: BackEnd!" );
  assert(type(x)==INCGRAPHIC || type(x)==SINCGRAPHIC, "PrintGraphicInclude!");
  assert(incgraphic_ok(x), "PrintGraphicInclude: !incgraphic_ok(x)!");

  /* open the include file and get its full path name */
  Child(y, Down(x));
  fp = OpenIncGraphicFile(string(y), type(x), &full_name,&fpos(y),&compressed);
  assert( fp != NULL, "PrintGraphicInclude: fp!" );

  /* if font is different to previous word then print change */
  if( font(save_style(x)) != currentfont )
  { currentfont = font(save_style(x));
    currentxheight2 = FontHalfXHeight(currentfont);
    fprintf(out_fp, "%hd %s\n", FontSize(currentfont,x), FontName(currentfont));
  }

  /* if colour is different to previous word then print change */
  if( colour(save_style(x)) != currentcolour )
  { currentcolour = colour(save_style(x));
    if( currentcolour > 0 )
    {
      fprintf(out_fp, "%s\n", ColourCommand(currentcolour));
    }
  }

  /* generate appropriate header code */
  fprintf(out_fp, "BeginEPSF\n");
  CoordTranslate(colmark - back(x, COLM), rowmark - fwd(x, ROWM));
  CoordScale( (float) PT, (float) PT );
  CoordTranslate(-back(y, COLM), -back(y, ROWM));
  fprintf(out_fp, "%%%%BeginDocument: %s\n", string(full_name));

  /* copy through the include file, except divert resources lines to needs */
  /* and strip out some comment lines that cause problems                  */
  state = (StringFGets(buff, MAX_BUFF, fp) == NULL) ? FINISHED : SKIPPING;
  while( state != FINISHED ) switch(state)
  {
    case SKIPPING:

      if( StringBeginsWith(buff, AsciiToFull("%%DocumentNeededResources:")) &&
	  !StringContains(buff, AsciiToFull("(atend)")) )
      { y = MakeWord(WORD, &buff[StringLength("%%DocumentNeededResources:")],
	      no_fpos);
        Link(needs, y);
	state = (StringFGets(buff,MAX_BUFF,fp)==NULL) ? FINISHED : READING_DNR;
      }
      else
      { if( StringBeginsWith(buff, AsciiToFull("%%LanguageLevel:")) )
	  Error(24, 9, "ignoring LanguageLevel comment in %s file %s",
	    WARN, &fpos(x), KW_INCGRAPHIC, string(full_name));
	if( StringBeginsWith(buff, AsciiToFull("%%Extensions:")) )
	  Error(24, 10, "ignoring Extensions comment in %s file %s",
	    WARN, &fpos(x), KW_INCGRAPHIC, string(full_name));
	if( !strip_out(buff) )  StringFPuts(buff, out_fp);
	state = (StringFGets(buff, MAX_BUFF, fp) == NULL) ? FINISHED : SKIPPING;
      }
      break;

    case READING_DNR:

      if( StringBeginsWith(buff, AsciiToFull("%%+")) )
      {	x = MakeWord(WORD, &buff[StringLength(AsciiToFull("%%+"))], no_fpos);
	Link(needs, x);
	state = (StringFGets(buff,MAX_BUFF,fp)==NULL) ? FINISHED : READING_DNR;
      }
      else
      { if( !strip_out(buff) )  StringFPuts(buff, out_fp);
	state = (StringFGets(buff, MAX_BUFF, fp) == NULL) ? FINISHED : SKIPPING;
      }
      break;
  }

  /* wrapup */
  DisposeObject(full_name);
  fclose(fp);
  if( compressed )  StringRemove(AsciiToFull(LOUT_EPS));
  fprintf(out_fp, "\n%%%%EndDocument\nEndEPSF\n");
  wordcount = 0;
  debug0(DRS, D, "PrintGraphicInclude returning.");
} /* end PrintGraphicInclude */