diff options
Diffstat (limited to 'z49.c')
| -rw-r--r-- | z49.c | 1148 |
1 files changed, 1148 insertions, 0 deletions
@@ -0,0 +1,1148 @@ +/*@z49.c:PostScript Back End:PS_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" + + +/*****************************************************************************/ +/* */ +/* State variables for this module */ +/* */ +/*****************************************************************************/ +#define StartUpResource "LoutStartUp" +#define NO_FONT 0 /* actually stolen from z37.c */ +#define NO_COLOUR 0 +#define MAX_GS 50 /* maximum depth of graphics states */ + +BOOLEAN Encapsulated; /* TRUE if EPS file is wanted */ + +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 */ +static FILE *out_fp; /* file to print PostScript on */ + + +/*****************************************************************************/ +/* */ +/* Print a number x on file fp. */ +/* */ +/*****************************************************************************/ + +#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 ); \ +} + +/*****************************************************************************/ +/* */ +/* PS_PrintInitialize(FILE *fp) */ +/* */ +/* Initialize this module; fp is the output file. */ +/* */ +/*****************************************************************************/ + +static void PS_PrintInitialize(FILE *fp) +{ + debug0(DPO, DD, "PS_PrintInitialize(fp)"); + out_fp = fp; + 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(DPO, DD, "PS_PrintInitialize returning."); +} /* end PS_PrintInitialize */ + + +/*****************************************************************************/ +/* */ +/* void PS_PrintLength(FULL_CHAR *buff, int length, int length_dim) */ +/* */ +/* Print a length (debugging only) */ +/* */ +/*****************************************************************************/ + +static void PS_PrintLength(FULL_CHAR *buff, int length, int length_dim) +{ + sprintf( (char *) buff, "%.3fc", (float) length/CM); +} + + +/*****************************************************************************/ +/* */ +/* void PS_PrintPageSetupForFont(OBJECT face, int font_curr_page, */ +/* FULL_CHAR *font_name, FULL_CHAR *short_name) */ +/* */ +/* 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 */ +/* short_name Internal short name for the font */ +/* */ +/*****************************************************************************/ + +static void PS_PrintPageSetupForFont(OBJECT face, int font_curr_page, + FULL_CHAR *font_name, FULL_CHAR *short_name) +{ + fprintf(out_fp, "%%%%IncludeResource: font %s\n", font_name); + if( font_recoded(face) ) + { + MapEnsurePrinted(font_mapping(face), font_curr_page); + fprintf(out_fp, "/%s%s %s /%s LoutRecode\n", + font_name, short_name, + MapEncodingName(font_mapping(face)), font_name); + fprintf(out_fp, "/%s { /%s%s LoutFont } def\n", short_name, + font_name, short_name); + } + else fprintf(out_fp, "/%s { /%s LoutFont } def\n", short_name, font_name); +} /* end PrintPageSetupForFont */ + + +/*****************************************************************************/ +/* */ +/* void PS_PrintPageResourceForFont(FULL_CHAR *font_name, 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 PS_PrintPageResourceForFont(FULL_CHAR *font_name, BOOLEAN first) +{ + fprintf(out_fp, "%s font %s\n", first ? "%%PageResources:" : "%%+",font_name); +} /* end PS_PrintPageResourceForFont */ + + +/*****************************************************************************/ +/* */ +/* static void PS_PrintMapping(MAPPING m) */ +/* */ +/* Print mapping m onto out_fp. */ +/* */ +/*****************************************************************************/ + +static void PS_PrintMapping(MAPPING m) +{ MAP_VEC map = MapTable[m]; int i; + fprintf(out_fp, "%%%%BeginResource: encoding %s\n", string(map->name)); + fprintf(out_fp, "/%s [\n", string(map->name)); + for( i = 0; i < MAX_CHARS; i++ ) + fprintf(out_fp, "/%s%c", string(map->vector[i]), (i+1)%8 != 0 ? ' ' : '\n'); + fprintf(out_fp, "] def\n"); + fprintf(out_fp, "%%%%EndResource\n\n"); +} /* end PrintMapping */ + + +/*****************************************************************************/ +/* */ +/* 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; +} + + +/*****************************************************************************/ +/* */ +/* static void PrintBeforeFirstPage(FULL_LENGTH h, FULL_LENGTH v, */ +/* FULL_CHAR *label) */ +/* */ +/* Print whatever is needed before the start of the first page: 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. */ +/* */ +/*****************************************************************************/ + +#define p0(str) fputs(str, out_fp) +#define p1(str, arg1) fprintf(out_fp, str, arg1) +#define p2(str, arg1, arg2) fprintf(out_fp, str, arg1, arg2) +#define p3(str, arg1, arg2, arg3) fprintf(out_fp, str, arg1, arg2, arg3) + +static void PS_PrintBeforeFirstPage(FULL_LENGTH h, FULL_LENGTH v, + FULL_CHAR *label) +{ FILE_NUM fnum; FULL_CHAR *p; + debug2(DPO, DD, "PrintBeforeFirst(%d, %d)", h, v); + + /* print header comments for PostScript DSC 3.0 output */ + if( Encapsulated ) + p0("%!PS-Adobe-3.0 EPSF-3.0\n"); + else + p0("%!PS-Adobe-3.0\n"); + p1("%%%%Creator: %s\n", LOUT_VERSION); + p1("%%%%CreationDate: %s", TimeString()); + p0("%%DocumentData: Binary\n"); + p0("%%DocumentNeededResources: (atend)\n"); + p0("%%DocumentSuppliedResources: (atend)\n"); + p3("%%%%DocumentMedia: %s %d %d 0 white ()\n", MediaName(h, v), h/PT, v/PT); + p0("%%PageOrder: Ascend\n"); + p0("%%Pages: (atend)\n"); + p2("%%%%BoundingBox: 0 0 %d %d\n", h/PT, v/PT); + p0("%%EndComments\n\n"); + + /* print procedure definitions part of header */ + p0("%%BeginProlog\n"); + p1("%%%%BeginResource: procset %s\n", StartUpResource); + p0("/save_cp { currentpoint /cp_y exch def /cp_x exch def } def\n"); + p0("/restore_cp { cp_x cp_y moveto } def\n"); + p0("/outline { gsave 1 1 1 setrgbcolor dup show save_cp\n"); + p0(" grestore true charpath stroke restore_cp } bind def\n"); + p0("/m { 3 1 roll moveto show } bind def\n"); + p0("/mo { 3 1 roll moveto outline } bind def\n"); + p0("/s { exch currentpoint exch pop moveto show } bind def\n"); + p0("/so { exch currentpoint exch pop moveto outline } bind def\n"); + p0("/k { exch neg 0 rmoveto show } bind def\n"); + p0("/ko { exch neg 0 rmoveto outline } bind def\n"); + p0("/r { exch 0 rmoveto show } bind def\n"); + p0("/ro { exch 0 rmoveto outline } bind def\n"); + p0("/c { gsave 3 1 roll rmoveto show grestore } bind def\n"); + p0("/co { gsave 3 1 roll rmoveto outline grestore } bind def\n"); + p0("/ul { gsave setlinewidth dup 3 1 roll\n"); + p0(" moveto lineto stroke grestore } bind def\n"); + p1("/in { %d mul } def\n", IN); + p1("/cm { %d mul } def\n", CM); + p1("/pt { %d mul } def\n", PT); + p1("/em { %d mul } def\n", EM); + p0("/sp { louts mul } def\n"); + p0("/vs { loutv mul } def\n"); + p0("/ft { loutf mul } def\n"); + p0("/dg { } def\n\n"); + + p0("/LoutGraphic {\n"); + p0(" /louts exch def\n"); + p0(" /loutv exch def\n"); + p0(" /loutf exch def\n"); + p0(" /ymark exch def\n"); + p0(" /xmark exch def\n"); + p0(" /ysize exch def\n"); + p0(" /xsize exch def\n} def\n\n"); + + p0("/LoutGr2 { gsave translate LoutGraphic gsave } def\n\n"); + + /* print definition used by Lout output to recode fonts */ + /* adapted from PostScript Language Reference Manual (2nd Ed), p. 275 */ + /* usage: /<fullname> <encodingvector> /<originalname> LoutRecode - */ + + p0("/LoutFont\n"); + p0("{ findfont exch scalefont setfont\n"); + p0("} bind def\n\n"); + + p0("/LoutRecode {\n"); + p0(" { findfont dup length dict begin\n"); + p0(" {1 index /FID ne {def} {pop pop} ifelse} forall\n"); + p0(" /Encoding exch def\n"); + p0(" currentdict end definefont pop\n"); + p0(" }\n"); + p0(" stopped pop\n"); + p0("} bind def\n\n"); + + /* print definitions used by Lout output when including EPSF files */ + /* copied from PostScript Language Reference Manual (2nd Ed.), p. 726 */ + + p0("/BeginEPSF {\n"); + p0(" /LoutEPSFState save def\n"); + p0(" /dict_count countdictstack def\n"); + p0(" /op_count count 1 sub def\n"); + p0(" userdict begin\n"); + p0(" /showpage { } def\n"); + p0(" 0 setgray 0 setlinecap\n"); + p0(" 1 setlinewidth 0 setlinejoin\n"); + p0(" 10 setmiterlimit [] 0 setdash newpath\n"); + p0(" /languagelevel where\n"); + p0(" { pop languagelevel\n"); + p0(" 1 ne\n"); + p0(" { false setstrokeadjust false setoverprint\n"); + p0(" } if\n"); + p0(" } if\n"); + p0("} bind def\n\n"); + + p0("/EndEPSF {\n"); + p0(" count op_count sub { pop } repeat\n"); + p0(" countdictstack dict_count sub { end } repeat\n"); + p0(" LoutEPSFState restore\n"); + p0("} bind def\n"); + + p0("%%EndResource\n\n"); + + /* 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(49, 1, "cannot open %s file %s", WARN, PosOfFile(fnum), + KW_PREPEND, FileName(fnum)); + else if( StringFGets(buff, MAX_BUFF, fp) == NULL ) + Error(49, 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(49, 3, "%s file %s lacks PostScript BeginResource comment", + WARN, PosOfFile(fnum), KW_PREPEND, FileName(fnum)); + StringFPuts(buff, out_fp); + p2("%% %s file %s\n", KW_PREPEND, FileName(fnum)); + while( StringFGets(buff, MAX_BUFF, fp) != NULL ) + StringFPuts(buff, out_fp); + p0("\n"); + fclose(fp); + } + } + + fputs("%%EndProlog\n\n", out_fp); + fputs("%%BeginSetup\n", out_fp); + MapPrintEncodings(); + /* 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); + 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\n"); + prologue_done = TRUE; +} /* end PS_PrintBeforeFirstPage */ + + +/*****************************************************************************/ +/* */ +/* PS_PrintAfterLastPage() */ +/* */ +/* Clean up this module and close output stream. */ +/* */ +/*****************************************************************************/ + +static void PS_PrintAfterLastPage(void) +{ OBJECT x, link; BOOLEAN first_need; + if( prologue_done ) + { + 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)); + } + MapPrintPSResources(out_fp); + + fprintf(out_fp, "%%%%Pages: %d\n", pagecount); + fprintf(out_fp, "%%%%EOF\n"); + } +} /* end PS_PrintAfterLastPage */ + + +/*****************************************************************************/ +/* */ +/* PS_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 PS_PrintBetweenPages(FULL_LENGTH h, FULL_LENGTH v, FULL_CHAR *label) +{ FULL_CHAR *p; + debug2(DPO, DD, "PrintBetweenPages(%d, %d)", h, v); + + fprintf(out_fp, "\npgsave restore\nshowpage\n"); + gs_stack_top = 0; + cpexists = FALSE; + currentfont = NO_FONT; + currentcolour = NO_COLOUR; + if( Encapsulated ) + { PS_PrintAfterLastPage(); + Error(49, 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; +} /* end PS_PrintBetweenPages */ + + +/*****************************************************************************/ +/* */ +/* 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, j; \ + 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(DPO, D, "PrintComposite(cp, %s, fp)", bool(outline)); + while( cp->char_code != '\0' ) + { + debug4(DPO, 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 */ + + +/*****************************************************************************/ +/* */ +/* PS_PrintWord(x, hpos, vpos) */ +/* */ +/* Print non-empty word x; its marks cross at the point (hpos, vpos). */ +/* */ +/*****************************************************************************/ + +static void PS_PrintWord(OBJECT x, int hpos, int vpos) +{ FULL_CHAR *p, *q, *a, *b, *lig, *unacc; + int ksize; char *command; MAPPING m; + unsigned short *composite; COMPOSITE *cmp; + + debug6(DPO, 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++; + + /* 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(DPO, 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(DPO, 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(DPO, 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); + debug0(DPO, DDD, "PrintWord returning"); +} /* end PS_PrintWord */ + + +/*****************************************************************************/ +/* */ +/* PS_PrintPlainGraphic(OBJECT x, FULL_LENGTH xmk, ymk, OBJECT z) */ +/* */ +/* Print a plain graphic object */ +/* */ +/*****************************************************************************/ + +static void PS_PrintPlainGraphic(OBJECT x, FULL_LENGTH xmk, + FULL_LENGTH ymk, OBJECT z) +{ + assert(FALSE, "PS_PrintPlainGraphic: this routine should never be called!"); +} /* end PS_PrintPlainGraphic */ + + +/*****************************************************************************/ +/* */ +/* PS_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 PS_PrintUnderline(FONT_NUM fnum, FULL_LENGTH xstart, + FULL_LENGTH xstop, FULL_LENGTH ymk) +{ + debug4(DPO, DD, "PrintUnderline(fnum %d, xstart %s, xstop %s, ymk %s )", + fnum, EchoLength(xstart), EchoLength(xstop), EchoLength(ymk)); + fprintf(out_fp, "%d %d %d %d ul\n", xstart, xstop, + ymk - finfo[fnum].underline_pos, finfo[fnum].underline_thick); + debug0(DPO, DD, "PrintUnderline returning."); +} /* end PS_PrintUnderline */ + + +/*****************************************************************************/ +/* */ +/* PS_CoordTranslate(xdist, ydist) */ +/* */ +/* Translate coordinate system by the given x and y distances. */ +/* */ +/*****************************************************************************/ + +static void PS_CoordTranslate(FULL_LENGTH xdist, FULL_LENGTH ydist) +{ debug2(DPO, D, "PS_CoordTranslate(%s, %s)", + EchoLength(xdist), EchoLength(ydist)); + fprintf(out_fp, "%d %d translate\n", xdist, ydist); + cpexists = FALSE; + debug0(DPO, D, "PS_CoordTranslate returning."); +} /* end PS_CoordTranslate */ + + +/*****************************************************************************/ +/* */ +/* PS_CoordRotate(amount) */ +/* */ +/* Rotate coordinate system by given amount (in internal DG units) */ +/* */ +/*****************************************************************************/ + +static void PS_CoordRotate(FULL_LENGTH amount) +{ debug1(DPO, D, "PS_CoordRotate(%.1f degrees)", (float) amount / DG); + fprintf(out_fp, "%.4f rotate\n", (float) amount / DG); + cpexists = FALSE; + debug0(DPO, D, "CoordRotate returning."); +} /* end PS_CoordRotate */ + + +/*****************************************************************************/ +/* */ +/* PS_CoordScale(ratio, dim) */ +/* */ +/* Scale coordinate system by ratio in the given dimension. */ +/* */ +/*****************************************************************************/ + +static void PS_CoordScale(float hfactor, float vfactor) +{ +#if DEBUG_ON + char buff[20]; +#endif + ifdebug(DPO, D, sprintf(buff, "%.3f, %.3f", hfactor, vfactor)); + debug1(DPO, D, "CoordScale(%s)", buff); + fprintf(out_fp, "%.4f %.4f scale\n", hfactor, vfactor); + cpexists = FALSE; + debug0(DPO, D, "CoordScale returning."); +} /* end PS_CoordScale */ + + +/*****************************************************************************/ +/* */ +/* PS_SaveGraphicState(x) */ +/* */ +/* Save current coord system on stack for later restoration. */ +/* Object x is just for error reporting, not really used at all. */ +/* */ +/*****************************************************************************/ + +static void PS_SaveGraphicState(OBJECT x) +{ debug0(DPO, D, "SaveGraphicState()"); + fprintf(out_fp, "gsave\n"); + gs_stack_top++; + if( gs_stack_top >= MAX_GS ) + Error(49, 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(DPO, D, "PS_SaveGraphicState returning."); +} /* end PS_SaveGraphicState */ + + +/*****************************************************************************/ +/* */ +/* PS_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 PS_RestoreGraphicState(void) +{ debug0(DPO, D, "PS_RestoreGraphicState()"); + fprintf(out_fp, "\ngrestore\n"); + 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--; + debug0(DPO, D, "PS_RestoreGraphicState returning."); +} /* end PS_RestoreGraphicState */ + + +/*****************************************************************************/ +/* */ +/* PS_PrintGraphicObject(x) */ +/* */ +/* Print object x on out_fp */ +/* */ +/*****************************************************************************/ + +void PS_PrintGraphicObject(OBJECT x) +{ OBJECT y, link; + debug3(DPO, D, "PS_PrintGraphicObject(%s %s %s)", + EchoFilePos(&fpos(x)), Image(type(x)), EchoObject(x)); + switch( type(x) ) + { + case WORD: + case QWORD: + + StringFPuts(string(x), out_fp); + break; + + + case ACAT: + + for( link = Down(x); link != x; link = NextDown(link) ) + { Child(y, link); + if( type(y) == GAP_OBJ ) + { + if( vspace(y) > 0 ) fputs("\n", out_fp); + else if( hspace(y) > 0 ) fputs(" ", out_fp); + } + else if( is_word(type(y)) || type(y) == ACAT ) + PS_PrintGraphicObject(y); + else if( type(y) == WIDE || is_index(type(y)) ) + { + /* ignore: @Wide, indexes are sometimes inserted by Manifest */ + } + else + { Error(49, 6, "error in left parameter of %s", + WARN, &fpos(x), KW_GRAPHIC); + debug1(DPO, D, " type(y) = %s, y =", Image(type(y))); + ifdebug(DPO, D, DebugObject(y)); + } + } + break; + + + default: + + Error(49, 7, "error in left parameter of %s", WARN, &fpos(x), KW_GRAPHIC); + debug1(DPO, D, " type(x) = %s, x =", Image(type(x))); + ifdebug(DPO, D, DebugObject(x)); + break; + + } + debug0(DPO, D, "PS_PrintGraphicObject returning"); +} /* end PS_PrintGraphicObject */ + + +/*****************************************************************************/ +/* */ +/* PS_DefineGraphicNames(x) */ +/* */ +/* Generate PostScript for xsize, ysize etc. names of graphic object. */ +/* */ +/*****************************************************************************/ + +void PS_DefineGraphicNames(OBJECT x) +{ assert( type(x) == GRAPHIC, "PrintGraphic: type(x) != GRAPHIC!" ); + debug1(DPO, D, "DefineGraphicNames( %s )", EchoObject(x)); + debug1(DPO, 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); + fprintf(out_fp, "%hd %s ", 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 ", ColourCommand(currentcolour)); + } + + /* now print the actual command that defines the names */ + 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)))); + debug0(DPO, D, "PS_DefineGraphicNames returning."); +} /* end PS_DefineGraphicNames */ + + +/*****************************************************************************/ +/* */ +/* PS_SaveTranslateDefineSave(x, xdist, ydist) */ +/* */ +/* Equivalent to the sequence of calls */ +/* */ +/* SaveGraphicState(x) */ +/* CoordTranslate(xdist, ydist) */ +/* DefineGraphicNames(x) */ +/* SaveGraphicState(x) */ +/* */ +/* but generates less PostScript. */ +/* */ +/*****************************************************************************/ + +void PS_SaveTranslateDefineSave(OBJECT x, FULL_LENGTH xdist, FULL_LENGTH ydist) +{ + 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 */ + PS_SaveGraphicState(x); + PS_CoordTranslate(xdist, ydist); + PS_DefineGraphicNames(x); + PS_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 PS_SaveTranslateDefineSave */ + + +/*****************************************************************************/ +/* */ +/* PS_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 PS_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(DPO, D, "PS_PrintGraphicInclude(x)"); + + 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"); + PS_CoordTranslate(colmark - back(x, COLM), rowmark - fwd(x, ROWM)); + PS_CoordScale( (float) PT, (float) PT ); + PS_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(49, 8, "ignoring LanguageLevel comment in %s file %s", + WARN, &fpos(x), KW_INCGRAPHIC, string(full_name)); + if( StringBeginsWith(buff, AsciiToFull("%%Extensions:")) ) + Error(49, 9, "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(DPO, D, "PS_PrintGraphicInclude returning."); +} /* end PS_PrintGraphicInclude */ + + +/*****************************************************************************/ +/* */ +/* PS_BackEnd */ +/* */ +/* The record into which all of these functions are packaged. */ +/* */ +/*****************************************************************************/ + +static struct back_end_rec ps_back = { + POSTSCRIPT, /* the code number of the back end */ + STR_POSTSCRIPT, /* string name of the back end */ + TRUE, /* TRUE if @Scale is available */ + TRUE, /* TRUE if @Rotate is available */ + TRUE, /* TRUE if @Graphic is available */ + TRUE, /* TRUE if @IncludeGraphic is avail. */ + FALSE, /* TRUE if @PlainGraphic is avail. */ + TRUE, /* TRUE if fractional spacing avail. */ + TRUE, /* TRUE if actual font metrics used */ + TRUE, /* TRUE if colour is available */ + PS_PrintInitialize, + PS_PrintLength, + PS_PrintPageSetupForFont, + PS_PrintPageResourceForFont, + PS_PrintMapping, + PS_PrintBeforeFirstPage, + PS_PrintBetweenPages, + PS_PrintAfterLastPage, + PS_PrintWord, + PS_PrintPlainGraphic, + PS_PrintUnderline, + PS_CoordTranslate, + PS_CoordRotate, + PS_CoordScale, + PS_SaveGraphicState, + PS_RestoreGraphicState, + PS_PrintGraphicObject, + PS_DefineGraphicNames, + PS_SaveTranslateDefineSave, + PS_PrintGraphicInclude, +}; + +BACK_END PS_BackEnd = &ps_back; |