/*
 * quarto.c
 * Quickie program to filter PostScript (EPS) files and...
 *   - list the pages
 *         ... | quarto -l ...
 *   - extract selected pages
 *         ... | quarto -p1,2,6-8 ...
 *   - change page order (reverse, even, odd; etc)
 *         ... | quarto -r ...           print in reverse order
 *         ... | quarto -p odd ...       select the odd pages
 *   - print "N-up" (quarto/octavo; N=2,3,4,6,8,9,16,25) layouts
 *         ... | quarto -4 -c -b ...     print 4 pages per page
 *
 * Currently only tested and used with a NeXT printer + A4 (letter)  paper,
 * with input in portrait orientation.  It should be easy to fix for
 * other media; check PBox, the test pattern, the calculation of  'Scale',
 * and the macro 'pgx()' (used by the 'putNup()' routines).
 *
 * Enjoy at your own peril, but please send me any improvements.
 *
 * M. J. Hawley
 * MIT media Laboratory
 * 20 Ames Street
 * Cambridge, MA 02139
 * mike@media-lab.mit.edu
 * Copyright (c) MIT Media Laboratory 1991.
 * Burn before reading!  This means you!!
 *
 * Changes by Corey Satten, corey @ cac.washington.edu:
 * - 16,25-up additions
 * - showpage enhancements to work if showpage was already re-defined
 * - tmpfile removal
 * - work around for illegal (but common) initial coordinate transformation
 *   in otherwise conforming PostScript Prolog.
 */
#include <stdio.h>
#include <sys/types.h>
#include <signal.h>
#include <ctype.h>

/*
 * Some general utilities ----------------------------------------
 */
char *av0;
#define Case break; case
#define Default break; default
static char *_arg, *_argp; /* use by 'for_each_argument */
extern char *av0;       /* will hold name of the command */
#define argument  (_arg=(*_argp? _argp : av[++i==ac? --i : i]),_argp+=strlen(_argp),_arg)
#define for_each_argument av0 = av[0]; for (i=1;i<ac && *av[i]=='-';i++)\
                        for (_argp = &av[i][1]; *_argp;)\
                                switch(*_argp++)

extern char *malloc(), *index();
extern int atoi();
extern double atof();

stripnl(s) char *s; { /* remove trailing \n and space from 's' */
    char *p = s + strlen(s)-1;
    while (p>s && (*p=='\n' || *p == ' ')) *p-- = '\0';
}

char *
skipsp(s) char *s; {
    while (*s==' ' || *s=='\t' || *s == '\n') ++s;
    return s;
}


error(a,b,c,d,e,f) int a,b,c,d,e,f; { /* printf an error msg */
    fprintf(stderr,(char *)a,b,c,d,e,f); fprintf(stderr,"\n");
}

/* ---------------------------------------------------------------- */

FILE *Input;
char *CurFile;

typedef struct { float x, y; } Point;
typedef struct { Point o, c; } Rectangle;
#define HS(r) (r.c.x-r.o.x)
#define VS(r) (r.c.y-r.o.y)

Rectangle BBox = { 0, 0, 612, 792 }; /* bbox of the document */

Rectangle PBox = { 10, 14, 600, 780 }; /* Letter-sized page-bounding box */
                 /* These values probably depend on the printer and
                  * paper size; use the test pattern to adjust them for now.
                  */
Rectangle NullRect = {0,0,0,0};

int TestPattern = 0;    /* if true, overlay a test pattern on the page*/
int ListPages = 0;      /* if true, list pages in the document (no print) */

#define _N_up 1
int N_up = 1;           /* default # pages to fit on a sheet */

#define _Gutter 12.
float Gutter= _Gutter;
#define _CutMarks 0
#define _Borders  1
int CutMarks=_CutMarks, /* print cutmarks around shrunken pages */
    Borders=_Borders;   /* print dashed borders around shrunken pages */
int ReversePages = 0;

float Scale = .45;      /* Scale is normally set by the tiling routines; */
int ScaleSet = 0;       /* made a user option just in case. */
int Rotate = 0;         /* will be true when landscaping for -2,6,8 */
int Lax = 0;		/* x flag relaxes strict Conforming PS requirements */

#ifndef MaxP
#define MaxP 4096	/* maximum number of input pages */
#endif
#define Trailer (MaxP-1)
int Page[MaxP], PageLen[MaxP];
Rectangle PageBbox[MaxP], pageBbox;
int NP=0;

findPageOffsets() {
    char s[4192];
    int i,prevpos=0,prevp=0,p;
    FILE *f = Input;
    int TrailerSeen=0;
    int ExpectedPageNo = 1;

    for(i=0;i<MaxP;i++){
        Page[i]=PageLen[i]=0;
        PageBbox[i] = NullRect;
    }

    rewind(f);
    if (!Lax) {
	fgets(s,sizeof s,f);
	if (strncmp(s, "%!PS-Adobe", 10) != 0) return;
	}
    while (fgets(s,sizeof s,f)){
        if (strncmp(s,"%%Page: ",8)==0){
            sscanf(s,"%%%%Page: %*s %d",&p);
	    if (!Lax && p != ExpectedPageNo) {
		NP = 0;
		break;
		}
	    ExpectedPageNo++;
            Page[p] = ftell(f)-strlen(s);
            PageLen[prevp] = Page[p] - prevpos;
            prevp = p;
            prevpos = Page[p];
            NP++;
        } else
        if (strncmp(s,"%%Trailer",9)==0){
	    TrailerSeen = 1;
            Page[Trailer] = ftell(f)-strlen(s);
            PageLen[prevp] = Page[Trailer] - prevpos;
            prevpos = Page[Trailer];
        } else
        if (strncmp(s,"%%BoundingBox:",14)==0){
            char *q = skipsp(index(s,':')+1);
            if (isdigit(*q))
                sscanf(q,"%f %f %f %f",
                         &BBox.o.x,&BBox.o.y,&BBox.c.x,&BBox.c.y);
        } else
        if (strncmp(s,"%%PageBoundingBox:",18)==0){
            Rectangle r;
            char *q = skipsp(index(s,':')+1);
            if (isdigit(*q)){
                sscanf(q,"%f %f %f %f", &r.o.x,&r.o.y,&r.c.x,&r.c.y);
                if (NP) PageBbox[NP] = r;
            }
        }
    }
    if (!TrailerSeen) {
	Page[Trailer] = ftell(f);
	PageLen[prevp] = Page[Trailer] - prevpos;
	prevpos = Page[Trailer];
	}
    PageLen[Trailer] = ftell(f) - prevpos;
    pageBbox = PageBbox[1]; /* hack ... */
        /*
         * Some NeXT programs put out PageBoundingBoxes
         * with various origins for each page,
         * but draw relative to the *first* PageBoundingBox.
         * See "hack", below.
         */
}

showPageOffsets() {
    char s[4192];
    int i,j;
    FILE *f = Input;

    printf("file: %s, %d pages\n",CurFile,NP);
    printf("%8s %8s\n","offset","length");
    for (i=j=0;j<=NP;i++){
        if (Page[i] || i==0){
            fseek(f,Page[i],0);
            fgets(s,sizeof s,f);
            printf("%8d %8d -- %s%s",Page[i], PageLen[i],i?"":"(header) ",s);
            j++;
        }
    }
    fseek(f,Page[Trailer],0);
    s[0] = '\n'; s[1] = 0;	/* clear buffer in case Trailer is EOF */
    fgets(s,sizeof s,f);
    printf("%8d %8d -- (trailer) %s",Page[Trailer],PageLen[Trailer],s);
}

static char *_s = (char *)0;
static int _sn = 0;

char *
readPage(n){
    size_t r;
    if (_s) *_s = '\0';
    if (Page[n] || (n==0 && PageLen[n])){
        if (_sn < PageLen[n]){
            _sn = 2*PageLen[n];
            _s = (_s? (char *)realloc(_s,_sn) : (char *)malloc(_sn));
            if (!_s) error("%s: no memory!",av0), exit(1);
        }
        rewind(Input);
        fseek(Input,Page[n],0);
        *_s = '\0';
        fread(_s,PageLen[n], (size_t)1, Input);
    }
    return _s;
}

copyPage(n)
/*
 * Write the 'n'th page in 'f' onto 'o'.
 */
{
    char *s = readPage(n);
    if (s && *s) fwrite(s,PageLen[n],1,stdout);
}

#define P printf

putProlog(n){
    char *date, *ctime();
    time_t t;

    time(&t); date = ctime(&t); stripnl(date);
    P("%%!PS-Adobe-2.0\n");
    P("%%%%Creator: %s, file: %s\n",av0,CurFile);
    P("%%%%CreationDate: %s\n",date);
    P("%%%%Pages: (atend)\n",n);
    P("%%%%BoundingBox: 0 0 612 792\n");  /* should have options to set */
    P("%%%%EndComments\n");
    P("\n");
    P("%% ---------------------- (routines for \"%s\")\n",av0);
    if (N_up!=1) {
	P("/q_initialmatrix matrix currentmatrix def\n");
	P("/q_fudge matrix def\n");
	P("/q_sheet 0 def\n");
	P("/q_W %f def  /q_H %f def  /q_margin 4 def\n",BBox.c.x,BBox.c.y);
	P("/q_factor %f def\n",Scale);
	P("/q_bbox {\n");
	if (Borders){
	    P("    /q_y 0 q_factor mul def\n");
	    P("    /q_x 0 q_factor mul def\n");
	    P("    /q_w q_W q_margin 2 mul add def\n");
	    P("    /q_h q_H q_margin 2 mul add def\n");
	    P("    q_x q_margin sub q_y q_margin sub q_fudge itransform moveto\n");
	    P("    .2 setgray\n");
	    P("    0 setlinewidth\n");
	    P("    q_w 0 q_fudge idtransform rlineto\n");
	    P("    0 q_h q_fudge idtransform rlineto\n");
	    P("    0 q_w sub 0 q_fudge idtransform rlineto\n");
	    P("    0 0 q_h sub q_fudge idtransform rlineto\n");
	    P("    stroke\n");
	}
	P("} def\n");
	P("\n");
	P("/q_cuts {\n");
	if (CutMarks){
	    P("    /q_y 0 q_factor mul q_margin sub def\n");
	    P("    /q_x 0 q_factor mul q_margin sub def\n");
	    P("    /q_w q_W q_margin 2 mul add def\n");
	    P("    /q_h q_H q_margin 2 mul add def\n");
	    P("    /q_d 10 q_factor mul def\n");
	    P("    0 setgray\n");
	    P("    0 setlinewidth\n");
	    P("    q_x q_d sub 1 sub q_y 1 sub q_fudge itransform moveto\n");
	    P("        q_d 0 q_fudge idtransform rlineto\n");
	    P("        0 0 q_d sub q_fudge idtransform rlineto stroke\n");
	    P("    q_x q_d add q_w add 1 add q_y 1 sub q_fudge itransform moveto\n");
	    P("        0 q_d sub 0 q_fudge idtransform rlineto\n");
	    P("        0 0 q_d sub q_fudge idtransform rlineto stroke\n");
	    P("    q_x q_d add q_w add 1 add q_y q_h add 1 add q_fudge itransform moveto\n");
	    P("        0 q_d sub 0 q_fudge idtransform rlineto\n");
	    P("        0 q_d q_fudge idtransform rlineto stroke\n");
	    P("    q_x q_d sub 1 sub q_y q_h add 1 add q_fudge itransform moveto\n");
	    P("        q_d 0 q_fudge idtransform rlineto\n");
	    P("        0 0 q_d q_fudge idtransform rlineto stroke\n");
	}
	P("} def\n");
	P("\n");
	P("/StartShrunkenPage {\n");
	P("    /q_y exch def /q_x exch def\n");
	P("    gsave\n");
	P("    matrix currentmatrix\n");
	P("    q_initialmatrix matrix invertmatrix\n");
	P("    matrix concatmatrix\n");
	P("    dup /q_fudge exch def\n");
	if (Rotate)
	    P("    [0 q_factor neg q_factor 0 q_x q_y]\n");
	else
	    P("    [q_factor 0 0 q_factor q_x q_y]\n");
	P("    q_initialmatrix\n");
	P("    matrix concatmatrix\n");
	P("    matrix concatmatrix\n");
	P("    setmatrix\n");

	P("    %% q_x q_y translate\n");
	P("    %% q_factor q_factor scale\n");
	if (Rotate) P("    %% -90 rotate\n");
	P("} def\n");
	P("\n");
	P("/EndShrunkenPage {\n");
	P("    grestore\n");
	P("} def\n");
	P("\n");
#ifdef NEVER
        P("/q_oldshowpage {showpage} bind def\n");
#else  NEVER
        P("%% this allows pwin which overrides showpage to work too. Corey.\n");
        P("currentdict /showpage known\n");
        P("    { /q_oldshowpage currentdict /showpage get def }\n");
        P("    { /q_oldshowpage {showpage} bind def }\n");
        P("    ifelse\n");
#endif NEVER
        P("/showpage { } bind def\n");
    }
    if (TestPattern) {
	P("\n");
	P("/q_circ { %% x y size ... draw circle + crosshairs\n");
	P("    /q_size exch def /q_y exch def /q_x exch def\n");
	P("    0 setlinewidth\n");
	P("    q_x q_y moveto\n");
	P("    q_size 0 rlineto\n");
	P("    -2 q_size mul 0 rlineto\n");
	P("    q_size 0 rlineto\n");
	P("    0 q_size rlineto\n");
	P("    0 -2 q_size mul rlineto\n");
	P("    stroke\n");
	P("    q_x q_y moveto\n");
	P("    q_x q_y q_size 2 div 0 360 arc stroke\n");
	P("} def\n");
	P("\n");
	P("/q_box { %% lx ly ux uy ... draw a box\n");
	P("    /q_uy exch def /q_ux exch def /q_ly exch def /q_lx exch def\n");
	P("    q_lx q_ly moveto\n");
	P("    q_ux q_ly lineto\n");
	P("    q_ux q_uy lineto\n");
	P("    q_lx q_uy lineto\n");
	P("    q_lx q_ly lineto\n");
	P("    stroke\n");
	P("} def\n");
	P("\n");
	P("/q_testPattern {\n");
	P("    0 setgray 0 setlinewidth\n");
	P("    %f %f %f %f q_box\n", PBox.o.x,PBox.o.y,PBox.c.x,PBox.c.y);
	P("    %f %f moveto 8 0 rlineto stroke\n",PBox.o.x-4,VS(PBox)/2+PBox.o.y);
	P("    %f %f moveto -8 0 rlineto stroke\n",PBox.c.x+4,VS(PBox)/2+PBox.o.y);
	P("    %f %f moveto 0 8 rlineto stroke\n",HS(PBox)/2+PBox.o.x,PBox.o.y-4);
	P("    %f %f moveto 0 -8 rlineto stroke\n",HS(PBox)/2+PBox.o.x,PBox.c.y+4);
	P("    %f %f 5 q_circ\n",HS(PBox)/2+PBox.o.x,VS(PBox)/2+PBox.o.y);
	P("} def\n");
	P("\n");
    }
    P("%% ----------------------(end of \"%s\" routines)\n\n",av0);
    copyPage(0);  /* put out the previous document header page */
}

ShowPage(){
    if (TestPattern) P("q_testPattern\n");
    P("q_sheet type 20 string cvs (savetype) eq {q_sheet restore} if\n");
    P("gsave q_oldshowpage grestore\n");
}

putTrailer(n){
    copyPage(Trailer);
    P("%%%%Pages: %d %d\n",n,n);
}

static Point
center(r) Rectangle r; {
    Point c;
    c.x = HS(r)/2. + r.o.x;
    c.y = VS(r)/2. + r.o.y;
    return c;
}

static Point
add(a,b) Point a,b; {
    a.x += b.x;
    a.y += b.y;
    return a;
}

static Point
sub(a,b) Point a,b; {
    a.x -= b.x;
    a.y -= b.y;
    return a;
}

pput(n,p) Point p; {
    char *s = readPage(n);
    Rectangle r;
    if (s && *s){
        s[2] = 'p';
        r = pageBbox; /* PageBbox[n]; ... Thus endeth the hack. */
        P("%f %f StartShrunkenPage\n",p.x,p.y);
        P("%f %f translate\n",-1.*Scale*r.o.x,-1.*Scale*r.o.y);
        fwrite(s,PageLen[n],1,stdout);
        P("EndShrunkenPage\n");
    }
}

float
fmin(a,b) float a,b; {
    return a<b? a : b;
}

#define maxQ 25+1

#define up_decls \
    int i, j, N = (NP+(N_up-1))/N_up, page[maxQ];\
    float gap = Gutter;\
    Point c, p, g, b, q[maxQ];\
    g.x=g.y = gap/2.; b = BBox.c

#define nup_init() c = center(PBox); \
                   b.x *= Scale; b.y *= Scale; \
                   putProlog(N)

#define pgx(inc,d) pput(i*N_up+j+1,p); page[j] = *_s; q[j++]=p; p.d  += inc
#define putbox() for (j=0; j<N_up;j++) \
                   if (page[j])\
                    P("%f %f StartShrunkenPage q_bbox q_cuts EndShrunkenPage\n",\
                        q[j].x,q[j].y); \
                 ShowPage()


put2up(){
    up_decls;

    if (!ScaleSet)
        Scale = fmin((VS(PBox)/2.-(2.*gap))/b.x,((HS(PBox)-(2.*gap))/b.y));
    nup_init();

    for (i=0;i<N;i++){
        P("\n%%%%Page: %d %d\n/q_sheet save def\n",i+1,i+1);
        j = 0;

        p = c; p.y += g.x + b.x; p.x -= b.y/2.;
        pgx(-(gap+b.x),y);
        pgx(-(gap+b.x),y);

        putbox();   /* put out boxes, cut marks, & ShowPage */
    }
    return N;
}

put3up(){
    up_decls;

    if (!ScaleSet)
        Scale = fmin((VS(PBox)/3.-(2.*gap))/b.x,((HS(PBox)-(2.*gap))/b.y));
    nup_init();

    for (i=0;i<N;i++){
        P("\n%%%%Page: %d %d\n/q_sheet save def\n",i+1,i+1);
        j = 0;

        p = c; p.y += g.x + 1.5*b.x; p.x -= b.y/2.;
        pgx(-(gap+b.x),y);
        pgx(-(gap+b.x),y);
        pgx(-(gap+b.x),y);

        putbox();   /* put out boxes, cut marks, & ShowPage */
    }
    return N;
}

put6up(){
    up_decls;

    if (!ScaleSet)
        Scale = fmin((VS(PBox)/3.-(2.*gap))/b.x,((HS(PBox)/2.-(2.*gap))/b.y));
    nup_init();

    for (i=0;i<N;i++){
        P("\n%%%%Page: %d %d\n/q_sheet save def\n",i+1,i+1);
        j = 0;

        p = c; p.y += gap + 1.5*b.x; p.x += g.x;
        pgx(-(gap+b.x),y);
        pgx(-(gap+b.x),y);
        pgx(-(gap+b.x),y);

        p = c; p.y += gap + 1.5*b.x; p.x -= g.x + b.y;
        pgx(-(gap+b.x),y);
        pgx(-(gap+b.x),y);
        pgx(-(gap+b.x),y);

        putbox();   /* put out boxes, cut marks, & ShowPage */
    }
    return N;
}

put8up(){
    up_decls;

    if (!ScaleSet)
        Scale = fmin((VS(PBox)/4.-(2.*gap))/b.x,((HS(PBox)/2.-(2.*gap))/b.y));
    nup_init();

    for (i=0;i<N;i++){
        P("\n%%%%Page: %d %d\n/q_sheet save def\n",i+1,i+1);
        j = 0;

        p = c; p.y += 1.5*gap + 2.*b.x; p.x += g.x;
        pgx(-(gap+b.x),y);
        pgx(-(gap+b.x),y);
        pgx(-(gap+b.x),y);
        pgx(-(gap+b.x),y);

        p = c; p.y += 1.5*gap + 2.*b.x; p.x -= g.x + b.y;
        pgx(-(gap+b.x),y);
        pgx(-(gap+b.x),y);
        pgx(-(gap+b.x),y);
        pgx(-(gap+b.x),y);

        putbox();   /* put out boxes, cut marks, & ShowPage */
    }
    return N;
}

put4up(){
    up_decls;

    if (!ScaleSet)
        Scale = .5*fmin((HS(PBox)-(2.*gap))/b.x,(VS(PBox)-(2.*gap))/b.y);
    nup_init();

    for (i=0;i<N;i++){
        P("\n%%%%Page: %d %d\n/q_sheet save def\n",i+1,i+1);
        j = 0;

        p = c; p.x -= g.x + b.x; p.y += g.y;
        pgx(gap+b.x,x);
        pgx(gap+b.x,x);
        p = c; p.x -= g.x + b.x; p.y -= g.y + b.y;
        pgx(gap+b.x,x);
        pgx(gap+b.x,x);

        putbox();   /* put out boxes, cut marks, & ShowPage */
    }
    return N;
}

put25up(){
    up_decls;

    if (!ScaleSet)
        Scale = .20*fmin((HS(PBox)-(5.*gap))/b.x,(VS(PBox)-(4.*gap))/b.y);
    nup_init();

    for (i=0;i<N;i++){
        P("\n%%%%Page: %d %d\n/q_sheet save def\n",i+1,i+1);
        j = 0;

        p = c; p.x -= 2.5 * (g.x + b.x); p.y += 1.5 * b.y + 3 * g.y;
        pgx(g.x+b.x,x);
        pgx(g.x+b.x,x);
        pgx(g.x+b.x,x);
        pgx(g.x+b.x,x);
        pgx(g.x+b.x,x);

        p = c; p.x -= 2.5 * (g.x + b.x); p.y += .5 * b.y + 2 * g.y;
        pgx(g.x+b.x,x);
        pgx(g.x+b.x,x);
        pgx(g.x+b.x,x);
        pgx(g.x+b.x,x);
        pgx(g.x+b.x,x);

        p = c; p.x -= 2.5 * (g.x + b.x); p.y -= .5 * b.y - g.y;
        pgx(g.x+b.x,x);
        pgx(g.x+b.x,x);
        pgx(g.x+b.x,x);
        pgx(g.x+b.x,x);
        pgx(g.x+b.x,x);

        p = c; p.x -= 2.5 * (g.x + b.x); p.y -= 1.5 * b.y;
        pgx(g.x+b.x,x);
        pgx(g.x+b.x,x);
        pgx(g.x+b.x,x);
        pgx(g.x+b.x,x);
        pgx(g.x+b.x,x);

        p = c; p.x -= 2.5 * (g.x + b.x); p.y -= 2.5 * b.y + g.y;
        pgx(g.x+b.x,x);
        pgx(g.x+b.x,x);
        pgx(g.x+b.x,x);
        pgx(g.x+b.x,x);
        pgx(g.x+b.x,x);

        putbox();   /* put out boxes, cut marks, & ShowPage */
    }
    return N;
}

put16up(){
    up_decls;

    if (!ScaleSet)
        Scale = .25*fmin((HS(PBox)-(4.*gap))/b.x,(VS(PBox)-(3.*gap))/b.y);
    nup_init();

    for (i=0;i<N;i++){
        P("\n%%%%Page: %d %d\n/q_sheet save def\n",i+1,i+1);
        j = 0;

        p = c; p.x -= 2 * (g.x + b.x); p.y += b.y + 2*g.y;
        pgx(g.x+b.x,x);
        pgx(g.x+b.x,x);
        pgx(g.x+b.x,x);
        pgx(g.x+b.x,x);

        p = c; p.x -= 2 * (g.x + b.x); p.y += g.y;
        pgx(g.x+b.x,x);
        pgx(g.x+b.x,x);
        pgx(g.x+b.x,x);
        pgx(g.x+b.x,x);

        p = c; p.x -= 2 * (g.x + b.x); p.y -= b.y;
        pgx(g.x+b.x,x);
        pgx(g.x+b.x,x);
        pgx(g.x+b.x,x);
        pgx(g.x+b.x,x);

        p = c; p.x -= 2 * (g.x + b.x); p.y -= 2 * b.y + g.y;
        pgx(g.x+b.x,x);
        pgx(g.x+b.x,x);
        pgx(g.x+b.x,x);
        pgx(g.x+b.x,x);

        putbox();   /* put out boxes, cut marks, & ShowPage */
    }
    return N;
}

put9up(){
    up_decls;

    if (!ScaleSet)
        Scale = .333*fmin((HS(PBox)-(3.*gap))/b.x,(VS(PBox)-(2.*gap))/b.y);
    nup_init();

    for (i=0;i<N;i++){
        P("\n%%%%Page: %d %d\n/q_sheet save def\n",i+1,i+1);
        j = 0;

        p = c; p.x -= g.x + 1.5*b.x; p.y += g.y + .5*b.y;
        pgx(g.x+b.x,x);
        pgx(g.x+b.x,x);
        pgx(g.x+b.x,x);

        p = c; p.x -= g.x + 1.5*b.x; p.y -= .5*b.y;
        pgx(g.x+b.x,x);
        pgx(g.x+b.x,x);
        pgx(g.x+b.x,x);

        p = c; p.x -= g.x + 1.5*b.x; p.y -= g.y + 1.5*b.y;
        pgx(g.x+b.x,x);
        pgx(g.x+b.x,x);
        pgx(g.x+b.x,x);

        putbox();   /* put out boxes, cut marks, & ShowPage */
    }
    return N;
}

putpages(){
    int i;
    char *s, *p, *index();

    putProlog(NP);
    for (i=1;i<=NP;i++){
        s = readPage(i);
        if (s && *s){
            p = index(s,'\n');
            if (p){
                p+1;
                fprintf(stdout,"%%%%Page: %d %d\n",i,i);
                fwrite(p,PageLen[i] - (p-s),1,stdout);
            }
        }
    }
}

char *SelectPages = (char *)0;

ReorderPages(){
    int i,j;

    if (SelectPages){
        char *s = skipsp(SelectPages);
        int start=0,end;
        int pages[MaxP], po[MaxP], pl[MaxP], np=0;
        Rectangle pr[MaxP];
        while (*s){
            if (strncmp(s,"even",4)==0){
                for (i=2;i<=NP;i+=2) pages[np++]=i;
                s+=4;
            } else
            if (strncmp(s,"odd",3)==0){
                for (i=1;i<=NP;i+=2) pages[np++]=i;
                s+=3;
            } else
            if (*s == '-'){
                start = 1;
                ++s;
                end = atoi(s);
                while (isdigit(*s)) ++s;
                for (i=start;i<=end;i++) pages[np++] = i;
            } else
            if (isdigit(*s)){
                pages[np++] = atoi(s);
                while (isdigit(*s) || isspace(*s)) ++s;
                if (*s == '-'){
                    ++s;
                    while (*s && !isdigit(*s)) ++s;
                    end = *s? atoi(s) : NP;
                    while (*s && isdigit(*s)) ++s;
                    for (i=pages[np-1]+1;i<=end;i++) pages[np++] = i;
                }
            } else
                ++s;
            while (*s== ',' || *s=='-' || isspace(*s)) ++s;
        }
        for (i=0;i<np;i++){
            po[i] = Page[pages[i]];
            pl[i] = PageLen[pages[i]];
            pr[i] = PageBbox[pages[i]];
        }
        for (i=0;i<np;i++){
            Page[i+1] = po[i];
            PageLen[i+1] = pl[i];
            PageBbox[i+1] = pr[i];
        }
        for (i=np+1;i<=NP;i++) Page[i] = PageLen[i] = 0;
        NP = np;
    }
    if (ReversePages){
#define swap(a,b) t = a; a = b; b = t
        for (i=1,j=NP; i<j; i++,j--){
            int t;
            Rectangle r;
            swap(Page[i],Page[j]);
            swap(PageLen[i],PageLen[j]);
            r = PageBbox[i]; PageBbox[i] = PageBbox[j]; PageBbox[j] =  
r;
        }
    }
}

doFile(s) char *s; {
    FILE *f = fopen(s,"r");
    int n;
    if (!f) return error("%s: couldn't open %s",av0,s);
    Input = f;
    findPageOffsets();

    if (ListPages)
        showPageOffsets();
    else {
	if(NP)
	    ReorderPages();
	else
	    CopyInputAndExit(f);
    

        switch (N_up){
        Case 2: n=put2up();
        Case 3: n=put3up();
        Case 4: n=put4up();
        Case 6: n=put6up();
        Case 8: n=put8up();
        Case 9: n=put9up();
        Case 16: n=put16up();
        Case 25: n=put25up();
        Default:n=putpages();
        }
    

        putTrailer(n);
    }
    fclose(f);
}

static char *tmpfilename = 0;

void sigfun(i) int i;
{
    if (tmpfilename) unlink(tmpfilename);
    exit(1);
}

savetmp(s,f) char *s; FILE *f;
/* 
 * Copy 'f' into a tmp file; put the name in s,
 * and return 1 if success.
 */
{
    FILE *o;
    int n, F, O;
    char b[8192];
    strcpy(s,"/tmp/quartoXXXXXX");
    mktemp(s);

    tmpfilename = s;		/* points to main's stack, but it's OK */
    signal(SIGHUP, sigfun);
    signal(SIGINT, sigfun);
    signal(SIGPIPE, sigfun);
    signal(SIGTERM, sigfun);

    if (o = fopen(s,"w")){
	chmod(s,0600);
        F = fileno(f);
        O = fileno(o);
        while ((n=read(F,b,sizeof b))>0)
            write(O,b,n);
        fclose(o);
        return 1;
    } else
        return 0;    

}

use(){
    error("use: %s [-[234689]] [-p <pages>] [-bcdlr] [-g #] [PS file]",av0);
    error("Select pages from a PostScript file, and print in a tiled format.");
    error("(The input must contain EPS-like directives '%%%%Page:...')");
    error("  -p... print the given pages; e.g., '-p1,2,4-8,12-'");
    error("        '-p -4' prints through page four;");
    error("        '-p 12-' prints from page 12 through the end;");
    error("        numbers are original ordinal page numbers, starting at 1");
    error("        also, '-p even', '-p odd', '-p1-4,1-4,1-4,1-4' etc.");
    error("  -2    print 2 tiled, shrunken pages per page;");
    error("        # may be 2,3,4,6,8,9,16 or 25 (default 1);");
    error("        portrait or landscape layout will be chosen accordingly.");
    error("  -b    %sprint borders around each tiled page.", _Borders?"don't ":"");
    error("  -c    %sprint cut-marks for each tiled page.", _CutMarks?"don't ":"");
    error("  -d    overlay a test pattern on the page.");
    error("        (a box around the paper sheet border, ");
    error("         and a circle and cross in the middle;");
    error("         intended to help calibrate for different printers)");
    error("  -g #  set the gap between tiles to # (%3f)",_Gutter);
    error("  -l    list the pages+offsets (don't output any PostScript).");
    error("  -r    reverse the page order");
    error("  -x    Lax enforcement of conforming PS standards");
    exit(1);
}

main(ac,av) char *av[]; {
    int i;

    for_each_argument {
    Case 'l': ListPages = 1;
    Case 'p': SelectPages = argument;
    Case 'r': ReversePages = 1;
    Case 'd': TestPattern = !TestPattern;
    Case 'c': CutMarks = !CutMarks;
    Case 'b': Borders = !Borders;
    Case '1': if (*_argp == '6') ++_argp, N_up = 16; else N_up = 1;
    Case '2': if (*_argp == '5') ++_argp, N_up = 25; else Rotate = 1, N_up = 2;
    Case '3': N_up = 3; Rotate = 1;
    Case '4': N_up = 4;
    Case '6': N_up = 6; Rotate = 1;
    Case '8': N_up = 8; Rotate = 1;
    Case '9': N_up = 9;
    Case 'g': Gutter = atof(argument);
    Case 's': Scale = atof(argument); ScaleSet++; /* not mentioned as option */
    Case 'x': Lax = 1;
    Default : use();
    }

    if (i==ac){
        char s[1024];
        if (savetmp(s,stdin))
            CurFile="stdin", doFile(s), unlink(s);
        else
            error("%s: couldn't save stdin to a tmp file.",av0), exit(1);
    } else
    if ((i+1)==ac)
        CurFile=av[i], doFile(av[i++]);
    else
        error("%s: accepts only one file, or stdin...\n",av0), use();
    exit(0);
}

CopyInputAndExit(f)	/* called if no pages were counted in input */
    FILE *f;
{
    int c;

    rewind(f);
    if (getc(f) != '%' || getc(f) != '!') {
	if (tmpfilename) unlink(tmpfilename);
	exit(1);
	}
    putchar('%'); putchar('!');
    while ((c=getc(f))!=EOF)
	putchar(c);
    if (tmpfilename) unlink(tmpfilename);
    exit(1);
}