Lout 3.22 tag.3.22

git-svn-id: http://svn.savannah.nongnu.org/svn/lout/tags/3.22@14 9365b830-b601-4143-9ba8-b4a8e2c3339c

1 files changed, 586 insertions, 0 deletions

diff --git a/z51.c b/z51.c
new file mode 100644
index 0000000..365721c
--- /dev/null
+++ b/z51.c
@@ -0,0 +1,586 @@
+/*@z51.c:Plain Text Back End:Plain_BackEnd@***********************************/
+/*                                                                           */
+/*  THE LOUT DOCUMENT FORMATTING SYSTEM (VERSION 3.22)                       */
+/*  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                                                                */
+/*                                                                           */
+/*  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:         z49.c                                                      */
+/*  MODULE:       PostScript Back End                                        */
+/*  EXTERNS:      PS_BackEnd                                                 */
+/*                                                                           */
+/*****************************************************************************/
+#include "externs.h"
+
+
+/*****************************************************************************/
+/*                                                                           */
+/*  PlainCharWidth    the width of each character                            */
+/*  PlainCharHeight   the height of each character                           */
+/*  PlainFormFeed     TRUE if components to be separated by \f.              */
+/*                                                                           */
+/*****************************************************************************/
+
+FULL_LENGTH PlainCharWidth, PlainCharHeight;
+BOOLEAN PlainFormFeed;
+
+/*****************************************************************************/
+/*                                                                           */
+/*  State variables for this module                                          */
+/*                                                                           */
+/*****************************************************************************/
+
+static FILE		*out_fp;	/* file to print output on           */
+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) */
+static BOOLEAN		prologue_done;	/* TRUE after prologue is printed    */
+
+
+/*****************************************************************************/
+/*                                                                           */
+/*  void Plain_PrintInitialize(fp)                                           */
+/*                                                                           */
+/*  Initialize this module; fp is the output file.                           */
+/*                                                                           */
+/*****************************************************************************/
+
+void Plain_PrintInitialize(FILE *fp)
+{
+  debug0(DPT, DD, "Plain_PrintInitialize(fp)");
+  out_fp = fp;
+  prologue_done = FALSE;
+  debug0(DPT, DD, "Plain_PrintInitialize returning.");
+} /* end Plain_PrintInitialize */
+
+
+/*****************************************************************************/
+/*                                                                           */
+/*  void Plain_PrintLength(FULL_CHAR *buff, int length, int length_dim)      */
+/*                                                                           */
+/*  Print a length (debugging only)                                          */
+/*                                                                           */
+/*****************************************************************************/
+
+static void Plain_PrintLength(FULL_CHAR *buff, int length, int length_dim)
+{
+  if( length_dim == COLM )
+  {
+    sprintf( (char *) buff, "%.2fs", (float) length/PlainCharWidth);
+  }
+  else
+  {
+    sprintf( (char *) buff, "%.2ff", (float) length/PlainCharHeight);
+  }
+}
+
+
+/*****************************************************************************/
+/*                                                                           */
+/*  void Plain_PrintPageSetupForFont(OBJECT face, int font_curr_page,        */
+/*    FULL_CHAR *font_name, FULL_CHAR *first_size_str)                       */
+/*                                                                           */
+/*  Print the page setup commands required to use a font on some page:       */
+/*                                                                           */
+/*    face            The font face record, defining which font we need      */
+/*    font_curr_page  The current page number                                */
+/*    font_name       The name of the font                                   */
+/*    first_size_str  No idea, have to check                                 */
+/*                                                                           */
+/*****************************************************************************/
+
+static void Plain_PrintPageSetupForFont(OBJECT face, int font_curr_page,
+  FULL_CHAR *font_name, FULL_CHAR *first_size_str)
+{
+  /* nothing to do here */
+
+} /* end Plain_PrintPageSetupForFont */
+
+
+/*****************************************************************************/
+/*                                                                           */
+/*  void Plain_PrintPageResourceForFont(FULL_CHAR *font_name, BOOLEAN first) */
+/*    BOOLEAN first)                                                         */
+/*                                                                           */
+/*  Print page resource info on file fp for font font_name; first is true    */
+/*  if this is the first resource on this page.                              */
+/*                                                                           */
+/*****************************************************************************/
+
+static void Plain_PrintPageResourceForFont(FULL_CHAR *font_name, BOOLEAN first)
+{
+  /* nothing to do here */
+
+} /* end Plain_PrintPageResourceForFont */
+
+
+/*****************************************************************************/
+/*                                                                           */
+/*  static void Plain_PrintMapping(MAPPING m)                                */
+/*                                                                           */
+/*  Print mapping m.                                                         */
+/*                                                                           */
+/*****************************************************************************/
+
+static void Plain_PrintMapping(MAPPING m)
+{
+  /* nothing to do here */
+
+} /* end Plain_PrintMapping */
+
+
+/*****************************************************************************/
+/*                                                                           */
+/*  void Plain_PrintBeforeFirstPage(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. */
+/*                                                                           */
+/*****************************************************************************/
+
+static void Plain_PrintBeforeFirstPage(FULL_LENGTH h, FULL_LENGTH v,
+  FULL_CHAR *label)
+{ int i, j;
+  debug2(DPT, DD, "PrintBeforeFirst(%d, %d)", h, v);
+
+  /* get a new page[] and clear it */
+  hsize = ceiling(h, PlainCharWidth);
+  vsize = ceiling(v, PlainCharHeight);
+  debug2(DPT, DD, "  PlainCharWidth: %d;  PlainCharHeight: %d",
+    PlainCharWidth, PlainCharHeight);
+  ifdebug(DMA, D, DebugRegisterUsage(MEM_PAGES, 1,
+    hsize * vsize * sizeof(FULL_CHAR)));
+  debug2(DPT, 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] = ' ';
+  prologue_done = TRUE;
+} /* end Plain_PrintBeforeFirstPage */
+
+
+/*****************************************************************************/
+/*                                                                           */
+/*  void Plain_PrintBetweenPages(h, v, label)                                */
+/*                                                                           */
+/*  Start a new output component, of size h by v; label is the page label    */
+/*  to attach to the %%Page comment.                                         */
+/*                                                                           */
+/*****************************************************************************/
+
+static void Plain_PrintBetweenPages(FULL_LENGTH h, FULL_LENGTH v,
+  FULL_CHAR *label)
+{ int new_hsize, new_vsize, i, j, jmax;
+  debug2(DPT, DD, "PrintBetween(%d, %d)", h, v);
+
+  /* print the page that has just ended */
+  ifdebug(DPT, 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(DPT, D, putc('|', out_fp));
+    for( jmax = hsize-1;  jmax >= 0 && page[i*hsize+jmax] == ' ';  jmax--);
+    ifdebug(DPT, D, jmax = hsize - 1);
+    for( j = 0;  j <= jmax;  j++ )
+      putc(page[i*hsize + j], out_fp);
+    ifdebug(DPT, D, putc('|', out_fp));
+    putc('\n', out_fp);
+  }
+  ifdebug(DPT, 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(DPT, DD, "  PrintBetween allocating %d by %d", hsize, vsize);
+    ifdebug(DPT, 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] = ' ';
+} /* end Plain_PrintBetweenPges */
+
+
+/*****************************************************************************/
+/*                                                                           */
+/*  Plain_PrintWord(x, hpos, vpos)                                           */
+/*                                                                           */
+/*  Print non-empty word x; its marks cross at the point (hpos, vpos).       */
+/*                                                                           */
+/*****************************************************************************/
+
+static void Plain_PrintWord(OBJECT x, int hpos, int vpos)
+{ FULL_CHAR *p;  int i, h, v;
+
+  debug6(DPT, DD, "Plain_PrintWord( %s, %d, %d ) font %d colour %d%s",
+    string(x), hpos, vpos, word_font(x), word_colour(x),
+    word_outline(x) ? " outline" : "");
+  TotalWordCount++;
+
+  h = ((float) hpos / PlainCharWidth) + 0.5;
+  v = ((float) vpos / PlainCharHeight);
+  debug3(DPT, 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(51, 1, "word %s deleted (internal error, off page at %d,%d)",
+      WARN, &fpos(x), string(x), h, v);
+  debug0(DPT, DDD, "PrintWord returning");
+} /* end Plain_PrintWord */
+
+
+/*****************************************************************************/
+/*                                                                           */
+/*  Plain_PrintPlainGraphic(x, xmk, ymk, z)                                  */
+/*                                                                           */
+/*  Print plain graphic object x at xmk, ymk with the size of z.             */
+/*                                                                           */
+/*****************************************************************************/
+
+static void Plain_PrintPlainGraphic(OBJECT x, FULL_LENGTH xmk,
+  FULL_LENGTH ymk, OBJECT z)
+{ int i, len, starth, startv, stoph, stopv, h, v;
+  debug2(DPT, D, "Plain_PrintPlainGraphic(x, xmk %s, ymk %s)",
+    EchoLength(xmk), EchoLength(ymk));
+
+  if( type(x) != WORD && type(x) != QWORD )
+  {
+    Error(51, 2, "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(51, 3, "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(DPT, D, "  xmk %s bk %s fwd %s -> %d,%d",
+    EchoLength(xmk), EchoLength(back(z, COLM)), EchoLength(fwd(z, COLM)),
+    starth, stoph);
+  SetLengthDim(ROWM);
+  debug5(DPT, 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(51, 4, "fill %s deleted (internal error, off page at %d,%d)",
+      WARN, &fpos(x), string(x), h, v);
+  }
+} /* end Plain_PrintPlainGraphic */
+
+
+/*****************************************************************************/
+/*                                                                           */
+/*  Plain_PrintUnderline(fnum, xstart, xstop, ymk)                           */
+/*                                                                           */
+/*  Draw an underline suitable for font fnum, from xstart to xstop at the    */
+/*  appropriate distance below mark ymk.                                     */
+/*                                                                           */
+/*****************************************************************************/
+
+static void Plain_PrintUnderline(FONT_NUM fnum, FULL_LENGTH xstart,
+  FULL_LENGTH xstop, FULL_LENGTH ymk)
+{
+
+  debug4(DPT, DD, "Plain_PrintUnderline(fnum %d, xstart %s, xstop %s, ymk %s )",
+    fnum, EchoLength(xstart), EchoLength(xstop), EchoLength(ymk));
+
+  /* do nothing */
+
+  debug0(DPT, DD, "PrintUnderline returning.");
+} /* end Plain_PrintUnderline */
+
+
+/*****************************************************************************/
+/*                                                                           */
+/*  Plain_PrintAfterLastPage()                                               */
+/*                                                                           */
+/*  Clean up this module and close output stream.                            */
+/*                                                                           */
+/*****************************************************************************/
+
+static void Plain_PrintAfterLastPage(void)
+{ int i, j, jmax;
+  if( prologue_done )
+  { 
+    /* print the page that has just ended (exists since prologue_done) */
+    ifdebug(DPT, 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(DPT, D, putc('|', out_fp));
+      for( jmax = hsize-1;  jmax >= 0 && page[i*hsize+jmax] == ' ';  jmax--);
+      ifdebug(DPT, D, jmax = hsize - 1);
+      for( j = 0;  j <= jmax;  j++ )
+        putc(page[i*hsize + j], out_fp);
+      ifdebug(DPT, D, putc('|', out_fp));
+      putc('\n', out_fp);
+    }
+    ifdebug(DPT, D,
+      putc('+', out_fp);
+      for( j = 0;  j < hsize;  j++ )  putc('-', out_fp);
+      putc('+', out_fp);
+      putc('\n', out_fp);
+    );
+  }
+} /* end Plain_PrintAfterLastPage */
+
+
+/*****************************************************************************/
+/*                                                                           */
+/*  Plain_CoordTranslate(xdist, ydist)                                       */
+/*                                                                           */
+/*  Translate coordinate system by the given x and y distances.              */
+/*                                                                           */
+/*****************************************************************************/
+
+void Plain_CoordTranslate(FULL_LENGTH xdist, FULL_LENGTH ydist)
+{ debug2(DPT, D, "Plain_CoordTranslate(%s, %s)",
+    EchoLength(xdist), EchoLength(ydist));
+  assert(FALSE, "Plain_CoordTranslate: should never be called!");
+  debug0(DPT, D, "Plain_CoordTranslate returning.");
+} /* end Plain_CoordTranslate */
+
+
+/*****************************************************************************/
+/*                                                                           */
+/*  Plain_CoordRotate(amount)                                                */
+/*                                                                           */
+/*  Rotate coordinate system by given amount (in internal DG units)          */
+/*                                                                           */
+/*****************************************************************************/
+
+static void Plain_CoordRotate(FULL_LENGTH amount)
+{ debug1(DPT, D, "Plain_CoordRotate(%.1f degrees)", (float) amount / DG);
+  assert(FALSE, "Plain_CoordRotate: should never be called!");
+  debug0(DPT, D, "Plain_CoordRotate returning.");
+} /* end Plain_CoordRotate */
+
+
+/*****************************************************************************/
+/*                                                                           */
+/*  Plain_CoordScale(ratio, dim)                                             */
+/*                                                                           */
+/*  Scale coordinate system by ratio in the given dimension.                 */
+/*                                                                           */
+/*****************************************************************************/
+
+void Plain_CoordScale(float hfactor, float vfactor)
+{
+  assert(FALSE, "Plain_CoordScale: should never be called!");
+} /* end Plain_CoordScale */
+
+
+/*****************************************************************************/
+/*                                                                           */
+/*  Plain_SaveGraphicState(x)                                                */
+/*                                                                           */
+/*  Save current coord system on stack for later restoration.                */
+/*  Object x is just for error reporting, not really used at all.            */
+/*                                                                           */
+/*****************************************************************************/
+
+void Plain_SaveGraphicState(OBJECT x)
+{ debug0(DPT, D, "Plain_SaveGraphicState()");
+  assert(FALSE, "Plain_SaveGraphicState: should never be called!" );
+  debug0(DPT, D, "Plain_SaveGraphicState returning.");
+} /* end Plain_SaveGraphicState */
+
+
+/*****************************************************************************/
+/*                                                                           */
+/*  Plain_RestoreGraphicState()                                              */
+/*                                                                           */
+/*  Restore previously saved coordinate system.                              */
+/*                                                                           */
+/*****************************************************************************/
+
+void Plain_RestoreGraphicState(void)
+{ debug0(DPT, D, "Plain_RestoreGraphicState()");
+  assert(FALSE, "Plain_RestoreGraphicState: should never be called!" );
+  debug0(DPT, D, "Plain_RestoreGraphicState returning.");
+} /* end Plain_RestoreGraphicState */
+
+
+/*****************************************************************************/
+/*                                                                           */
+/*  Plain_PrintGraphicObject(x)                                              */
+/*                                                                           */
+/*  Print object x on out_fp                                                 */
+/*                                                                           */
+/*****************************************************************************/
+
+void Plain_PrintGraphicObject(OBJECT x)
+{
+  debug3(DPT, D, "Plain_PrintGraphicObject(%s %s %s)",
+    EchoFilePos(&fpos(x)), Image(type(x)), EchoObject(x));
+  assert(FALSE, "Plain_PrintGraphicObject: should never be called!" );
+  debug0(DPT, D, "Plain_PrintGraphicObject returning");
+} /* end Plain_PrintGraphicObject */
+
+
+/*****************************************************************************/
+/*                                                                           */
+/*  Plain_DefineGraphicNames(x)                                              */
+/*                                                                           */
+/*  Generate PostScript for xsize, ysize etc. names of graphic object.       */
+/*                                                                           */
+/*****************************************************************************/
+
+void Plain_DefineGraphicNames(OBJECT x)
+{
+  debug1(DPT, D, "Plain_DefineGraphicNames( %s )", EchoObject(x));
+  debug1(DPT, DD, "  style = %s", EchoStyle(&save_style(x)));
+  assert(FALSE, "Plain_DefineGraphicNames: should never be called!" );
+  debug0(DPT, D, "Plain_DefineGraphicNames returning.");
+} /* end Plain_DefineGraphicNames */
+
+
+/*****************************************************************************/
+/*                                                                           */
+/*  Plain_SaveTranslateDefineSave(x, xdist, ydist)                           */
+/*                                                                           */
+/*  Equivalent to the sequence of calls                                      */
+/*                                                                           */
+/*      SaveGraphicState(x)                                                  */
+/*      CoordTranslate(xdist, ydist)                                         */
+/*      DefineGraphicNames(x)                                                */
+/*      SaveGraphicState(x)                                                  */
+/*                                                                           */
+/*  but offers opportunities for optimization.                               */
+/*                                                                           */
+/*****************************************************************************/
+
+void Plain_SaveTranslateDefineSave(OBJECT x, FULL_LENGTH xdist,
+  FULL_LENGTH ydist)
+{
+  assert(FALSE, "Plain_SaveTranslateDefineSave: should never be called!" );
+} /* end Plain_SaveTranslateDefineSave */
+
+
+/*****************************************************************************/
+/*                                                                           */
+/*  Plain_PrintGraphicInclude(x, colmark, rowmark)                           */
+/*                                                                           */
+/*  Print graphic include file, with appropriate surrounds.                  */
+/*                                                                           */
+/*****************************************************************************/
+
+void Plain_PrintGraphicInclude(OBJECT x, FULL_LENGTH colmark,
+  FULL_LENGTH rowmark)
+{
+  debug0(DPT, D, "Plain_PrintGraphicInclude(x)");
+  assert(FALSE, "Plain_PrintGraphicInclude: should never be called!" );
+  debug0(DPT, D, "Plain_PrintGraphicInclude returning.");
+} /* end Plain_PrintGraphicInclude */
+
+
+/*****************************************************************************/
+/*                                                                           */
+/*  Plain_BackEnd                                                            */
+/*                                                                           */
+/*  The record into which all of these functions are packaged.               */
+/*                                                                           */
+/*****************************************************************************/
+
+static struct back_end_rec plain_back = {
+  PLAINTEXT,				/* the code number of the back end   */
+  STR_PLAINTEXT,			/* string name of the back end       */
+  FALSE,				/* TRUE if @Scale is available       */
+  FALSE,				/* TRUE if @Rotate is available      */
+  FALSE,				/* TRUE if @Graphic is available     */
+  FALSE,				/* TRUE if @IncludeGraphic is avail. */
+  TRUE,					/* TRUE if @PlainGraphic is avail.   */
+  FALSE,				/* TRUE if fractional spacing avail. */
+  FALSE,				/* TRUE if actual font metrics used  */
+  FALSE,				/* TRUE if colour is available       */
+  Plain_PrintInitialize,
+  Plain_PrintLength,
+  Plain_PrintPageSetupForFont,
+  Plain_PrintPageResourceForFont,
+  Plain_PrintMapping,
+  Plain_PrintBeforeFirstPage,
+  Plain_PrintBetweenPages,
+  Plain_PrintAfterLastPage,
+  Plain_PrintWord,
+  Plain_PrintPlainGraphic,
+  Plain_PrintUnderline,
+  Plain_CoordTranslate,
+  Plain_CoordRotate,
+  Plain_CoordScale,
+  Plain_SaveGraphicState,
+  Plain_RestoreGraphicState,
+  Plain_PrintGraphicObject,
+  Plain_DefineGraphicNames,
+  Plain_SaveTranslateDefineSave,
+  Plain_PrintGraphicInclude,
+};
+
+BACK_END Plain_BackEnd = &plain_back;