OpenSolaris_b135/tools/codereview/lwlp.c
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (the "License").
* You may not use this file except in compliance with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* or http://www.opensolaris.org/os/licensing.
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright 2008 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
/*
* lwlp - Convert ASCII text to PostScript
*
* Usage:
* lwlp [-{2|4|8}] [-p] [-L] [-r] [-n#] [-l#|-w#] [-c#] [-t#]
* [-hstring] [-Bstring] [-Istring] [-Xstring] [-Pfile] [file ...]
*
* Options:
* -{1|2|4|8} print multiple logical pages per page
* -d debug, don't remove temporary file
* -L specify Landscape instead of Portrait
* -p filter input through pr
* -r toggle page reversal flag (default is off)
* -e elide unchanged functions
* -n# number with numberwidth digits
* -l# specify number of lines/logical page, default 66
* -w# specify number of columns
* -c# specify number of copies
* -t# specify tab spacing
* -htext specify header text
* -Btext specify bold font selector
* -Itext specify italic font selector
* -Xtext specify bold-italic font selector
* -Gtext specify graying selector
* -Pfile specify different Postscript prologue file
*
* If no files are specified, stdin is used.
* Form feeds handled
* Backspacing with underlining (or overprinting) works
* The output conforms to Adobe 2.0
*
* Problems:
* - assumes fixed-width (non-proportional) font in some places
* - can't back up (using backspaces) over tabs
* - assumes 8.5 x 11.0 paper
* - uses logical page with aspect ratio of 3 * 4
*
*/
#define USAGE1 "[-{1|2|4|8}] [-p] [-L] [-r] [-n<numberwidth]"
#define USAGE2 "[-l<lines>|-w<columns>] [-c<count>] [-t<tabs>]"
#define USAGE3 "[-hstring] [-Bstring] [-Istring] [-Xstring] [-Gstring]"
#define USAGE4 "[-Pfile] [file ...]"
#define USAGE6 "[-hstring] [-e] [-y comment] oldfile newfile"
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <sys/file.h>
#include <ctype.h>
#include <pwd.h>
#include <sys/utsname.h>
#include <sys/stat.h>
#include <unistd.h>
#include <sys/types.h>
#include <time.h>
#include <stdarg.h>
/*
* Configurable...
* BUFOUT should be fairly large
*/
#define BUFIN 1024 /* maximum length of an input line */
#define BUFOUT (BUFIN * 5)
#define MAXPAGES 10000
#define REVERSE_OFF 0
#define DEFAULT_PAPER_HEIGHT 11.0
#define DEFAULT_PAPER_WIDTH 8.50
#define DEFAULT_PAGE_HEIGHT 10.0
#define DEFAULT_PAGE_WIDTH 7.50
#define DEFAULT_LINES_PER_PAGE 66
#define DEFAULT_TAB_SIZE 8
static char *default_font = "Courier";
static char *default_font_bold = "Courier-Bold";
static char *default_font_italic = "Courier-Oblique";
static char *default_font_bold_italic = "Courier-BoldOblique";
static char *select_default_font = "FRN";
static char *select_default_font_bold = "FRB";
static char *select_default_font_italic = "FIN";
static char *select_default_font_bold_italic = "FIB";
#define DEFAULT_FONT select_default_font
#define DEFAULT_FONT_BOLD select_default_font_bold
#define DEFAULT_FONT_ITALIC select_default_font_italic
#define DEFAULT_FONT_BOLD_ITALIC select_default_font_bold_italic
#define DEFAULT_CHAR_WIDTH (.6)
#define DEFAULT_SPACES_AFTER_NUMBER 1
#define DEFAULT_DESCENDER_FRACTION 0.3
#define LWLP "lwlp"
#define CODEREVIEW "codereview"
#define END_C_FUNCTION '}'
#define END_ASM_FUNCTION "SET_SIZE("
static char *banner =
"**********************************************************";
/*
* PostScript command strings
*/
#define LINETO "lineto"
#define NEWPATH "newpath"
#define SETLINEWIDTH "setlinewidth"
#define STROKE "stroke"
/*
* PostScript command strings defined in the prologue file
*/
#define BACKSPACE "B"
#define MOVETO "M" /* x y */
#define SHOW "S" /* string */
#define TAB "T" /* spaces */
#define ZEROMOVETO "Z" /* y */
#define SELECT_FONT "SFT" /* size font */
#define SET_WIDTHS "SWT"
#define START_PAGE "SPG" /* angle scale x y */
#define END_PAGE "EPG"
#define FLUSH_PAGE "FPG" /* ncopies */
#define SHADE "SHD" /* x0 y0 x1 y1 */
/*
* Conformance requires that no PostScript line exceed 256 characters
*/
#define POINTS_PER_INCH 72
#define MAX_OUTPUT_LINE_LENGTH 256
#define START_X 0 /* position of start of each line */
#define THREE_HOLE_X 1.0 /* portrait x offset (inches) 3 hole */
#define THREE_HOLE_Y 0.5 /* landscape y offset (inches) 3 hole */
#define RULE_WIDTH 0.25 /* width in units of paging rules */
static struct print_state {
int page_count;
int logical_page_count;
int lineno;
long offset;
float row;
char *font;
} current, saved;
struct format_state {
int numberwidth, linenumber, altlinenumber;
int makegray;
char *font;
};
static int change_seen, dots_inserted, in_change, old_stuff, makegray;
static int lines_per_page;
static int columns;
static float point_size;
static int start_x, start_y, end_x;
static int landscape, rot_text;
static int ncopies;
static int tabstop;
static int reverse;
static int elide;
static int usetmp;
static int dflag, lflag, pflag, vflag, wflag;
static int numberwidth, linenumber, altlinenumber;
static int boldlength, itlclength, bitclength, graylength;
static char *boldstring, *itlcstring, *bitcstring, *graystring;
#define HEADER_EXPLICIT 1
#define HEADER_IMPLICIT 2
static int header = HEADER_IMPLICIT;
static char *headerstring;
static char *bannerfile;
static char bufin[BUFIN]; /* input buffer */
static char bufout[BUFOUT]; /* output buffer */
static long *page_map; /* offset of first byte of each page */
static char *username, *hostname, *currentdate;
static char *comment;
static void preamble(void);
static void postamble(void);
static void setcurrentfont(char *, FILE *);
static void savestate(FILE *);
static void restorestate(FILE *);
static void save_format_state(struct format_state *);
static void printfile(FILE *);
static int printpage(FILE *, FILE *);
static int startpage(FILE *);
static void endpage(FILE *);
static void copypage(FILE *, long, long);
static void process_elide(FILE *);
static void setheaderfile(char *);
static void restore_format_state(struct format_state *, FILE *);
static void flushpage(FILE *);
static void setuppage(FILE *);
static void reversepages(FILE *);
static void proc(char *, FILE *);
static void setup(void);
static int printbanner(char *, FILE *);
static char *fgetline(char *, int, FILE *);
static void fatal(char *fmt, ...);
static char *prologue;
static char *progname;
static int iscodereview;
static char *default_prologue[] = {
"%%EndComments\n",
"%\n",
"% PostScript Prologue for lwlp LaserWriter Line Printer\n",
"%\n",
"/SFT {findfont exch scalefont setfont}bind def\n",
"/SWT {( ) stringwidth pop dup /W exch def neg /NW exch def}bind def\n",
"/SPG {/SV save def translate dup scale rotate}bind def\n",
"/EPG {SV restore}bind def\n",
"/FPG {/#copies exch def showpage}bind def\n",
"/B {NW 0 rmoveto}def\n",
"/M /moveto load def\n",
"/T {W mul 0 rmoveto}def\n",
"/S /show load def\n",
"/Z {0 exch moveto}bind def\n",
"/SHD {save 5 1 roll % S x1 y1 x0 y0\n",
" 2 copy moveto % S x1 y1 x0 y0\n",
" 3 index exch lineto % S x1 y1 x0\n",
" 3 -1 roll 2 index lineto % S y1 x0\n",
" exch lineto % S\n",
" 0.95 setgray fill % S\n",
" restore}def\n",
"%%EndProlog\n",
NULL
};
struct layout {
float scale;
int pages, page_rows, page_cols;
int rotation;
};
static struct layout *layoutp;
static struct layout layout1 = { 1.000000, 1, 1, 1, 0 };
static struct layout layout2 = { 0.666666, 2, 2, 1, 90 };
static struct layout layout4 = { 0.500000, 4, 2, 2, 0 };
static struct layout layout8 = { 0.333333, 8, 4, 2, 90 };
static int box_width, box_height;
static int gap_width, gap_height;
static int margin_x, margin_y;
static struct position {
int base_x;
int base_y;
} positions[8];
int
main(int argc, char **argv)
{
int ch, i, j, first_file;
char *pc;
FILE *infile;
if ((pc = strrchr(argv[0], '/')) != NULL)
progname = pc + 1;
else
progname = argv[0];
lines_per_page = DEFAULT_LINES_PER_PAGE;
layoutp = &layout1;
tabstop = DEFAULT_TAB_SIZE;
current.page_count = 0;
ncopies = 1;
reverse = REVERSE_OFF;
/*LINTED*/
if (iscodereview = strncmp(progname, CODEREVIEW,
sizeof (CODEREVIEW) - 1) == 0) {
layoutp = &layout2;
numberwidth = 4;
columns = 85; /* extra space for numbering */
wflag = -1;
}
while ((ch = getopt(argc, argv,
"1248B:c:deG:h:I:l:Ln:P:prt:vw:X:y:")) != -1) {
switch (ch) {
case '1':
layoutp = &layout1;
break;
case '2':
layoutp = &layout2;
break;
case '4':
layoutp = &layout4;
break;
case '8':
layoutp = &layout8;
break;
case 'B':
boldlength = strlen(optarg);
boldstring = malloc((size_t)(boldlength + 1));
(void) strcpy(boldstring, optarg);
break;
case 'c':
ncopies = atof(optarg);
if (ncopies <= 0) {
fatal("number of copies must be > 0");
/*NOTREACHED*/
}
break;
case 'd':
dflag = 1;
break;
case 'e':
elide = 1;
break;
case 'G':
graylength = strlen(optarg);
graystring = malloc((size_t)(graylength + 1));
(void) strcpy(graystring, optarg);
break;
case 'h':
header = HEADER_EXPLICIT;
i = strlen(optarg);
headerstring = malloc((size_t)(i + 1));
(void) strcpy(headerstring, optarg);
if (strcmp(headerstring, "-") == 0)
header = HEADER_IMPLICIT;
break;
case 'I':
itlclength = strlen(optarg);
itlcstring = malloc((size_t)(itlclength + 1));
(void) strcpy(itlcstring, optarg);
break;
case 'l':
lines_per_page = atoi(optarg);
if (lines_per_page < 1) {
fatal("invalid number of lines/page");
/*NOTREACHED*/
}
lflag = 1;
if (wflag > 0) {
fatal("can't have both -l and -w");
/*NOTREACHED*/
}
wflag = 0;
break;
case 'L':
landscape = 1;
break;
case 'm':
break;
case 'n':
numberwidth = atoi(optarg);
if (numberwidth < 2) {
fatal("invalid numbering width");
/*NOTREACHED*/
}
break;
case 'P':
prologue = optarg;
break;
case 'p':
pflag = 1;
break;
case 'r':
reverse = !reverse;
break;
case 't':
tabstop = atoi(optarg);
if (tabstop < 1) {
fatal("negative tabstop");
/*NOTREACHED*/
}
break;
case 'v':
vflag = 1;
break;
case 'w':
columns = atoi(optarg);
if (columns < 1) {
fatal("invalid number of columns");
/*NOTREACHED*/
}
wflag = 1;
if (lflag) {
fatal("can't have both -l and -w");
/*NOTREACHED*/
}
break;
case 'X':
bitclength = strlen(optarg);
bitcstring = malloc((size_t)(bitclength + 1));
(void) strcpy(bitcstring, optarg);
break;
case 'y':
comment = optarg;
break;
default:
(void) fprintf(stderr,
"usage: %s %s\n\t%s\n\t%s\n\t%s\n",
iscodereview ? LWLP : progname,
USAGE1, USAGE2, USAGE3, USAGE4);
if (iscodereview)
(void) fprintf(stderr, "\t%s [%s flags] %s\n",
CODEREVIEW, LWLP, USAGE6);
exit(1);
}
}
if (elide && !iscodereview) {
fatal("-e option valid only with codereview");
/*NOTREACHED*/
}
usetmp = reverse || elide;
/* allocate page_map if we need one */
if (reverse) {
page_map = malloc((size_t)(MAXPAGES * sizeof (long *)));
if (page_map == NULL) {
fatal("unable to allocate memory for page reversal");
/*NOTREACHED*/
}
}
/*
* Check that all files are readable
* This is so that no output at all is produced if any file is not
* readable in case the output is being piped to a printer
*/
first_file = optind;
for (j = first_file; j < argc; j++) {
if (access(argv[j], R_OK) == -1 && !(iscodereview &&
strcmp(argv[j], "-") == 0)) {
fatal("cannot access %s", argv[j]);
/*NOTREACHED*/
}
}
if (iscodereview && (first_file + 2) != argc) {
fatal("codereview: need old and new file");
/*NOTREACHED*/
}
/* compute logical point size, logical dimensions */
if (!landscape) {
rot_text = layoutp->rotation;
start_y = DEFAULT_PAGE_HEIGHT * POINTS_PER_INCH;
start_x = START_X;
end_x = DEFAULT_PAGE_WIDTH * POINTS_PER_INCH;
if (wflag) {
point_size = DEFAULT_PAGE_WIDTH * POINTS_PER_INCH /
((columns + 0.5) * DEFAULT_CHAR_WIDTH);
lines_per_page = DEFAULT_PAGE_HEIGHT * POINTS_PER_INCH /
point_size;
} else {
point_size = DEFAULT_PAGE_HEIGHT * POINTS_PER_INCH /
(lines_per_page + 0.5);
columns = DEFAULT_PAGE_WIDTH * POINTS_PER_INCH /
(point_size * DEFAULT_CHAR_WIDTH);
}
} else {
rot_text = 90 - layoutp->rotation;
start_y = DEFAULT_PAGE_WIDTH * POINTS_PER_INCH;
start_x = START_X;
end_x = DEFAULT_PAGE_HEIGHT * POINTS_PER_INCH;
if (wflag) {
point_size = DEFAULT_PAGE_HEIGHT * POINTS_PER_INCH /
((columns + 0.5) * DEFAULT_CHAR_WIDTH);
lines_per_page = DEFAULT_PAGE_WIDTH * POINTS_PER_INCH /
point_size;
} else {
point_size = DEFAULT_PAGE_WIDTH * POINTS_PER_INCH /
(lines_per_page + 0.5);
columns = DEFAULT_PAGE_HEIGHT * POINTS_PER_INCH /
(point_size * DEFAULT_CHAR_WIDTH);
}
}
box_height = DEFAULT_PAGE_HEIGHT * POINTS_PER_INCH / layoutp->page_rows;
if (layoutp->rotation == 0)
box_width = box_height /
DEFAULT_PAGE_HEIGHT * DEFAULT_PAGE_WIDTH;
else
box_width = box_height *
DEFAULT_PAGE_HEIGHT / DEFAULT_PAGE_WIDTH;
gap_width = DEFAULT_PAPER_WIDTH * POINTS_PER_INCH /
layoutp->page_cols - box_width;
gap_height = DEFAULT_PAPER_HEIGHT * POINTS_PER_INCH /
layoutp->page_rows - box_height;
margin_x = gap_width/2;
margin_y = gap_height/2;
columns -= numberwidth + DEFAULT_SPACES_AFTER_NUMBER;
if (columns <= 0) {
fatal("numbering width exceeds number of columns");
/* NOT REACHED */
}
/* compute physical "lower left corner" of each logical page */
for (j = 0; j < layoutp->pages; j++) {
int phys_row; /* 0 is bottom row */
int phys_col; /* 0 is left column */
if (landscape == (rot_text == 0)) {
/* logical pages run physically up and down */
phys_row = j % layoutp->page_rows;
phys_col = j / layoutp->page_rows;
} else {
/* logical pages run physically left to right */
phys_row = j / layoutp->page_cols;
phys_col = j % layoutp->page_cols;
}
if (rot_text == 0) {
/* top physical row is logically first */
phys_row = layoutp->page_rows - 1 - phys_row;
}
positions[j].base_x = margin_x +
phys_col * (box_width + gap_width);
positions[j].base_y = margin_y +
phys_row * (box_height + gap_height);
if (rot_text != 0) {
positions[j].base_x += box_width;
}
}
if (vflag) {
(void) fprintf(stderr, "%s:\n\n", progname);
(void) fprintf(stderr, "Lines/page = %d\n", lines_per_page);
(void) fprintf(stderr, "Columns = %d\n", columns);
for (j = 0; j < layoutp->pages; j++) {
(void) fprintf(stderr, "\tx=%3d, y=%3d\n",
positions[j].base_x, positions[j].base_y);
}
(void) fprintf(stderr, "box_width=%3d, box_height=%3d\n",
box_width, box_height);
(void) fprintf(stderr, "gap_width=%3d, gap_height=%3d\n",
gap_width, gap_height);
}
setup();
preamble();
if (iscodereview) {
char command[BUFSIZ];
(void) snprintf(command, BUFSIZ, "diff -b -D %s %s %s",
CODEREVIEW, argv[first_file+1], argv[first_file]);
infile = popen(command, "r");
bannerfile = argv[first_file+1];
if (ungetc(getc(infile), infile) == EOF) {
(void) pclose(infile);
(void) sprintf(command,
"echo No differences encountered");
infile = popen(command, "r");
}
setheaderfile(bannerfile);
printfile(infile);
(void) pclose(infile);
} else if (first_file == argc) { /* no files on command line */
if (vflag)
(void) fprintf(stderr, "\tprinting stdin\n");
setheaderfile("stdin");
printfile(stdin);
} else {
for (i = first_file; i < argc; i++) {
if ((infile = fopen(argv[i], "r")) == (FILE *)NULL) {
fatal("can't open %s for reading", argv[i]);
/*NOTREACHED*/
}
if (pflag) {
char cmdbuf[BUFSIZ];
(void) snprintf(cmdbuf, BUFSIZ, "pr %s",
argv[i]);
(void) fclose(infile);
infile = popen(cmdbuf, "r");
}
if (vflag)
(void) fprintf(stderr, "\tprinting %s\n",
argv[i]);
setheaderfile(argv[i]);
printfile(infile);
if (pflag)
(void) pclose(infile);
else
(void) fclose(infile);
}
}
postamble();
if (fflush(stdout) == EOF) {
fatal("write error on stdout");
/*NOTREACHED*/
}
exit(0);
/*NOTREACHED*/
/*LINTED*/
}
/*
* Initial lines sent to the LaserWriter
* Generates the PostScript header and includes the prologue file
* There is limited checking for I/O errors here
*/
void
preamble(void)
{
(void) printf("%%!PS-Adobe-2.0\n");
(void) printf("%%%%Creator: %s on %s\n", progname, hostname);
(void) printf("%%%%CreationDate: %s\n", currentdate);
(void) printf("%%%%For: %s\n", username);
(void) printf("%%%%DocumentFonts: %s %s %s %s\n",
default_font, default_font_bold,
default_font_italic, default_font_bold_italic);
(void) printf("%%%%Pages: (atend)\n");
if (prologue == NULL) {
char **cpp;
for (cpp = default_prologue; *cpp; cpp++) {
(void) fputs(*cpp, stdout);
}
} else {
FILE *fp;
if ((fp = fopen(prologue, "r")) == NULL) {
fatal("can't open prologue file %s", prologue);
/*NOTREACHED*/
}
while (fgets(bufin, sizeof (bufin), fp) != NULL)
(void) fputs(bufin, stdout);
(void) fclose(fp);
}
if (ferror(stdout) || fflush(stdout) == EOF) {
fatal("write error on stdout");
/*NOTREACHED*/
}
(void) printf("/%s {%f /%s %s}bind def\n", DEFAULT_FONT,
point_size, default_font, SELECT_FONT);
(void) printf("/%s {%f /%s %s}bind def\n", DEFAULT_FONT_BOLD,
point_size, default_font_bold, SELECT_FONT);
(void) printf("/%s {%f /%s %s}bind def\n", DEFAULT_FONT_ITALIC,
point_size, default_font_italic, SELECT_FONT);
(void) printf("/%s {%f /%s %s}bind def\n", DEFAULT_FONT_BOLD_ITALIC,
point_size, default_font_bold_italic, SELECT_FONT);
}
void
postamble(void)
{
(void) printf("%%%%Trailer\n");
(void) printf("%%%%Pages: %d\n", current.page_count);
}
int
printbanner(char *filename, FILE *outfile)
{
char buffer[BUFSIZ];
struct stat statbuf;
struct format_state format_state;
int nlines = 0;
/* we've already verified readability */
(void) stat(filename, &statbuf);
save_format_state(&format_state);
numberwidth = 0;
setcurrentfont(DEFAULT_FONT_BOLD_ITALIC, outfile);
current.row -= point_size;
(void) fprintf(outfile, "%d %.2f %s\n", start_x, current.row, MOVETO);
proc(banner, outfile);
nlines++;
current.row -= point_size;
(void) fprintf(outfile, "%d %.2f %s\n", start_x, current.row, MOVETO);
(void) snprintf(buffer, BUFSIZ, "%8ld %.24s", statbuf.st_size,
ctime(&statbuf.st_mtime));
proc(buffer, outfile);
nlines++;
do {
current.row -= point_size;
(void) fprintf(outfile, "%d %.2f %s\n", start_x, current.row,
MOVETO);
filename += sprintf(buffer, "%.*s", columns, filename);
proc(buffer, outfile);
nlines++;
} while (strlen(filename) != 0);
if (comment != NULL && comment[0] != 0) {
const char *cur = comment;
const char *endl;
int len;
while (*cur != 0) {
current.row -= point_size;
(void) fprintf(outfile, "%d %.2f %s\n", start_x,
current.row, MOVETO);
endl = strchr(cur, '\n');
if (endl == NULL)
endl = cur + strlen(cur);
/* truncate to columns */
len = endl - cur;
if (len > columns)
len = columns;
(void) sprintf(buffer, "%.*s", len, cur);
proc(buffer, outfile);
nlines++;
if (*endl == 0)
break;
cur = endl + 1;
}
}
current.row -= point_size;
(void) fprintf(outfile, "%d %.2f %s\n", start_x, current.row, MOVETO);
proc(banner, outfile);
nlines++;
restore_format_state(&format_state, outfile);
return (nlines);
}
void
setcurrentfont(char *newfont, FILE *outfile)
{
if (current.font != newfont) {
if (newfont)
current.font = newfont;
(void) fprintf(outfile, "%s\n", current.font);
}
}
void
savestate(FILE *f)
{
current.offset = ftell(f);
saved = current;
}
void
restorestate(FILE *f)
{
char *font;
font = current.font;
(void) fseek(f, saved.offset, 0);
current = saved;
setcurrentfont(font, f);
}
void
save_format_state(struct format_state *fs)
{
fs->numberwidth = numberwidth;
fs->linenumber = linenumber;
fs->altlinenumber = altlinenumber;
fs->makegray = makegray;
fs->font = current.font;
}
void
restore_format_state(struct format_state *fs, FILE *outfile)
{
numberwidth = fs->numberwidth;
linenumber = fs->linenumber;
altlinenumber = fs->altlinenumber;
makegray = fs->makegray;
setcurrentfont(fs->font, outfile);
}
/*
* Print a file
*
* The input stream may be stdin, a file, or a pipe
*/
void
printfile(FILE *infile)
{
int eof;
char *p;
FILE *outfile;
if (reverse)
page_map[0] = 0L;
if (usetmp) {
(void) snprintf(bufin, BUFIN, "/tmp/%sXXXXXX", progname);
p = mktemp(bufin);
if ((outfile = fopen(p, "w+")) == NULL) {
fatal("can't open temporary file %s", p);
/* NOTREACHED */
}
if (!dflag)
(void) unlink(p);
else
(void) fprintf(stderr, "will not unlink %s\n", p);
}
else
outfile = stdout;
setcurrentfont(DEFAULT_FONT, outfile);
change_seen = 0;
dots_inserted = 0;
in_change = 0;
makegray = 0;
linenumber = 0;
altlinenumber = 0;
current.logical_page_count = 0;
do {
current.row = start_y;
eof = printpage(infile, outfile);
} while (!eof);
if (((int)current.row) != start_y)
endpage(outfile);
if ((current.logical_page_count % layoutp->pages) != 0)
flushpage(outfile);
if (vflag)
(void) fprintf(stderr, "\n");
if (fflush(outfile) == EOF) {
fatal("write error while flushing output");
/*NOTREACHED*/
}
if (usetmp) {
if (reverse)
reversepages(outfile);
else
copypage(outfile, 0L, current.offset);
(void) fclose(outfile);
}
}
void
process_elide(FILE *outfile)
{
if (!change_seen && !in_change) {
/* don't include function in output */
restorestate(outfile);
if (!dots_inserted) {
struct format_state format_state;
save_format_state(&format_state);
numberwidth = 0;
current.lineno++;
current.row -= point_size;
setcurrentfont(DEFAULT_FONT_BOLD_ITALIC, outfile);
proc("______unchanged_portion_omitted_", outfile);
restore_format_state(&format_state, outfile);
savestate(outfile);
dots_inserted = 1;
}
} else {
savestate(outfile);
change_seen = in_change;
dots_inserted = 0;
}
}
/*
* Process the next page
* Return 1 on EOF, 0 otherwise
*/
int
printpage(FILE *infile, FILE *outfile)
{
int tmplinenumber;
char command[BUFSIZ], flag[BUFSIZ];
if (ungetc(getc(infile), infile) == EOF)
return (1);
current.lineno = 0;
current.lineno += startpage(outfile);
if (bannerfile) {
current.lineno += printbanner(bannerfile, outfile);
bannerfile = NULL;
savestate(outfile);
}
for (; current.lineno < lines_per_page; ) {
if (fgetline(bufin, sizeof (bufin), infile) == (char *)NULL) {
if (elide)
process_elide(outfile);
return (1);
}
/*
* Allow C comment delimiters around flag; only really applies
* to #else and #endif, but we don't expect to see C comments
* around flag for #if. Also accept flag with no C comment
* delimiters.
*/
if (iscodereview &&
(sscanf(bufin, "#%32s /* %80s */", command, flag) == 2 ||
sscanf(bufin, "#%32s %80s", command, flag) == 2) &&
strcmp(flag, CODEREVIEW) == 0) {
if (strcmp(command, "ifdef") == 0) {
change_seen = 1;
in_change = 1;
makegray = 1;
old_stuff = 1;
tmplinenumber = linenumber;
linenumber = altlinenumber;
altlinenumber = tmplinenumber;
setcurrentfont(DEFAULT_FONT_ITALIC, outfile);
} else if (strcmp(command, "ifndef") == 0) {
change_seen = 1;
in_change = 1;
makegray = 1;
old_stuff = 0;
setcurrentfont(DEFAULT_FONT_BOLD, outfile);
} else if (strcmp(command, "else") == 0) {
makegray = 1;
old_stuff = !old_stuff;
tmplinenumber = linenumber;
linenumber = altlinenumber;
altlinenumber = tmplinenumber;
if (!old_stuff)
setcurrentfont(DEFAULT_FONT_BOLD,
outfile);
else
setcurrentfont(DEFAULT_FONT_ITALIC,
outfile);
} else /* if (strcmp(command, "endif") == 0) */ {
in_change = 0;
makegray = 0;
savestate(outfile);
setcurrentfont(DEFAULT_FONT, outfile);
if (old_stuff) {
tmplinenumber = linenumber;
linenumber = altlinenumber;
altlinenumber = tmplinenumber;
}
}
continue;
}
current.lineno++;
current.row -= point_size;
if (bufin[0] == '\f')
break;
proc(bufin, outfile);
if (elide && (bufin[0] == END_C_FUNCTION ||
(strstr(bufin, END_ASM_FUNCTION) != NULL)))
process_elide(outfile);
}
endpage(outfile);
return (0);
}
/*
* Start a new page
*/
int
startpage(FILE *outfile)
{
int logical_page, lines, buflen;
struct format_state format_state;
char buf[8];
logical_page = current.logical_page_count % layoutp->pages;
if (logical_page == 0)
setuppage(outfile);
else
setcurrentfont((char *)NULL, outfile);
(void) fprintf(outfile, "%s ", SET_WIDTHS);
(void) fprintf(outfile, "%d %f %d %d %s\n",
rot_text, layoutp->scale, positions[logical_page].base_x,
positions[logical_page].base_y, START_PAGE);
lines = 0;
if (header) {
save_format_state(&format_state);
setcurrentfont(DEFAULT_FONT_BOLD, outfile);
numberwidth = 0;
makegray = 0;
current.row -= point_size;
(void) fprintf(outfile, "%d %.2f %s\n", start_x, current.row,
MOVETO);
proc(headerstring, outfile);
(void) snprintf(buf, 8, "%d", current.logical_page_count + 1);
buflen = strlen(buf);
(void) fprintf(outfile, "%d %.2f %s (%s)%s\n",
(int)(end_x - (buflen + 0.5) *
DEFAULT_CHAR_WIDTH * point_size),
current.row, MOVETO, buf, SHOW);
current.row -= point_size;
restore_format_state(&format_state, outfile);
lines = 2;
}
return (lines);
}
void
setheaderfile(char *filename)
{
if (header == HEADER_IMPLICIT)
headerstring = filename;
}
/*
* Setup page
*/
void
setuppage(FILE *outfile)
{
int i, ilimit;
int begin, end, place;
(void) fprintf(outfile, "%%%%Page: ? %d\n", current.page_count + 1);
setcurrentfont((char *)NULL, outfile);
if (layoutp->pages == 1)
return;
(void) fprintf(outfile, "%f %s %s\n", RULE_WIDTH, SETLINEWIDTH,
NEWPATH);
begin = 0; end = DEFAULT_PAPER_WIDTH * POINTS_PER_INCH;
for (i = 1, ilimit = layoutp->page_rows; i < ilimit; i++) {
place = margin_y - gap_height/2 + i * (box_height+gap_height);
(void) fprintf(outfile, "%d %d %s ", begin, place, MOVETO);
(void) fprintf(outfile, "%d %d %s\n", end, place, LINETO);
}
begin = 0; end = DEFAULT_PAPER_HEIGHT * POINTS_PER_INCH;
for (i = 1, ilimit = layoutp->page_cols; i < ilimit; i++) {
place = margin_x - gap_width/2 + i * (box_width+gap_width);
(void) fprintf(outfile, "%d %d %s ", place, begin, MOVETO);
(void) fprintf(outfile, "%d %d %s\n", place, end, LINETO);
}
(void) fprintf(outfile, "%s\n", STROKE);
}
/*
* Terminate the logical page and indicate the start of the next
*/
void
endpage(FILE *outfile)
{
(void) fprintf(outfile, "%s\n", END_PAGE);
current.logical_page_count++;
if (vflag)
(void) fprintf(stderr, "x");
if ((current.logical_page_count % layoutp->pages) == 0)
flushpage(outfile);
}
/*
* Flush the physical page
* Record the start of the next page
*/
void
flushpage(FILE *outfile)
{
(void) fprintf(outfile, "%d %s\n", ncopies, FLUSH_PAGE);
current.page_count++;
current.offset = ftell(outfile);
if (reverse) {
if (current.page_count >= MAXPAGES) {
fatal("page reversal limit (%d) reached", MAXPAGES);
/* NOTREACHED */
}
page_map[current.page_count] = current.offset;
}
if (vflag)
(void) fprintf(stderr, "|");
}
/*
* reverse the order of pages
*/
void
reversepages(FILE *outfile)
{
int i;
if (vflag)
(void) fprintf(stderr, "\nreversing %d page%s\n",
current.page_count, current.page_count > 1 ? "s" : "");
for (i = current.page_count - 1; i >= 0; i--) {
copypage(outfile, page_map[i], page_map[i+1]);
}
}
/*
* copy a page (or more) from tempfile to stdout
*/
void
copypage(FILE *outfile, long off_beg, long off_end)
{
int bytecount, nbytes;
if (fseek(outfile, off_beg, 0) == -1L) {
fatal("temporary file seek error");
/* NOTREACHED */
}
nbytes = off_end - off_beg;
while (nbytes > 0) {
bytecount = nbytes;
if (bytecount > sizeof (bufout))
bytecount = sizeof (bufout);
bytecount = fread(bufout, 1, bytecount, outfile);
if (bytecount <= 0) {
fatal("temporary file read error");
/* NOTREACHED */
}
if (fwrite(bufout, 1, bytecount, stdout) != bytecount) {
fatal("write error during page copy");
/* NOTREACHED */
}
nbytes -= bytecount;
}
}
/*
* Process a line of input, escaping characters when necessary and handling
* tabs
*
* The output is improved somewhat by coalescing consecutive tabs and
* backspaces and eliminating tabs at the end of a line
*
* Overprinting (presumably most often used in underlining) can be far from
* optimal; in particular the way nroff underlines by sequences like
* "_\ba_\bb_\bc" creates a large volume of PostScript. This isn't too
* serious since a lot of nroff underlining is unlikely.
*
* Since a newline is generated for each call there will be more
* newlines in the output than is necessary
*/
void
proc(char *in, FILE *outfile)
{
int i;
char *last, *p, *q;
int currentp, instr, tabc, tabto, grayed;
char *altfont;
currentp = 0;
instr = 0;
tabto = 0;
if (iscodereview) {
grayed = makegray;
altfont = current.font;
} else {
grayed = 0;
altfont = DEFAULT_FONT;
}
/* subtract slop factor */
last = bufout + MAX_OUTPUT_LINE_LENGTH - 20;
for (;;) { /* check for any special line treatment */
if (graylength && strncmp(in, graystring, graylength) == 0) {
grayed++;
in += graylength;
} else if (boldlength &&
strncmp(in, boldstring, boldlength) == 0) {
altfont = DEFAULT_FONT_BOLD;
in += boldlength;
} else if (itlclength &&
strncmp(in, itlcstring, itlclength) == 0) {
altfont = DEFAULT_FONT_ITALIC;
in += itlclength;
} else if (bitclength &&
strncmp(in, bitcstring, bitclength) == 0) {
altfont = DEFAULT_FONT_BOLD_ITALIC;
in += bitclength;
} else
break;
}
if (grayed) {
(void) fprintf(outfile, "%d %.2f %d %.2f %s\n",
start_x,
current.row - DEFAULT_DESCENDER_FRACTION * point_size,
end_x,
current.row +
(1.0 - DEFAULT_DESCENDER_FRACTION) * point_size,
SHADE);
}
linenumber++;
if (!in_change)
altlinenumber++;
if (*in == '\0')
return;
if (start_x != 0) {
(void) fprintf(outfile, "%d %.2f %s\n",
start_x, current.row, MOVETO);
}
else
(void) fprintf(outfile, "%.2f %s\n",
current.row, ZEROMOVETO);
if (numberwidth) {
setcurrentfont(DEFAULT_FONT, outfile);
(void) sprintf(bufout, "%*d", numberwidth, linenumber);
for (q = bufout, i = 0; *q == ' '; q++, i++)
;
(void) fprintf(outfile, "%d %s (%s)%s %d %s ",
i, TAB, q, SHOW, DEFAULT_SPACES_AFTER_NUMBER, TAB);
}
setcurrentfont(altfont, outfile);
q = bufout;
*q = '\0';
for (p = in; *p != '\0'; p++) {
switch (*p) {
case '\t':
/*
* Count the number of tabs that immediately follow
* the one we're looking at
*/
tabc = 0;
while (*(p + 1) == '\t') {
p++;
tabc++;
}
if (currentp > 0) { /* not beginning of line */
i = tabstop - (currentp % tabstop) +
tabc * tabstop;
if (instr) {
(void) snprintf(q,
BUFOUT - (q - bufout), ")%s ",
SHOW);
q += strlen(q);
instr = 0;
}
}
else
i = (tabc + 1) * tabstop;
tabto += i;
currentp += i;
break;
case '\b':
/* backspacing over tabs doesn't work... */
if (tabto != 0) {
fatal("attempt to backspace over a tab");
/*NOTREACHED*/
}
p++;
for (i = 1; *p == '\b'; p++)
i++;
p--;
if (currentp - i < 0) {
fatal("too many backspaces");
/*NOTREACHED*/
}
if (instr) {
*q = '\0';
(void) fprintf(outfile, "%s)%s\n",
bufout, SHOW);
}
instr = 0;
if (currentp >= columns)
i -= currentp-columns;
if (i <= 0) {
/* backspace in truncated line */
bufout[0] = '\0';
} else if (i == 1) {
/* frequent case gets special attention */
(void) snprintf(bufout, BUFOUT, "%s ",
BACKSPACE);
} else
(void) snprintf(bufout, BUFOUT, "-%d %s ", i,
TAB);
q = bufout + strlen(bufout);
currentp -= i;
break;
case '\f':
tabto = 0; /* optimizes */
*q = '\0';
if (instr)
(void) fprintf(outfile, "%s)%s\n",
bufout, SHOW);
else
(void) fprintf(outfile, "%s\n", bufout);
endpage(outfile);
(void) startpage(outfile);
current.row = start_y;
(void) fprintf(outfile, "%d %.2f %s\n",
start_x, current.row, MOVETO);
if (numberwidth)
(void) fprintf(outfile, "%d %s\n", numberwidth +
DEFAULT_SPACES_AFTER_NUMBER, TAB);
q = bufout;
currentp = 0;
instr = 0;
break;
case '\r':
tabto = 0; /* optimizes */
if (instr) {
*q = '\0';
(void) fprintf(outfile, "%s)%s\n",
bufout, SHOW);
instr = 0;
q = bufout;
}
(void) fprintf(outfile, "%d %.2f %s\n",
start_x, current.row, MOVETO);
if (numberwidth)
(void) fprintf(outfile, "%d %s\n", numberwidth +
DEFAULT_SPACES_AFTER_NUMBER, TAB);
currentp = 0;
break;
case '\\':
case '(':
case ')':
if (currentp < columns) {
if (!instr) {
if (tabto) {
(void) snprintf(q,
BUFOUT - (q - bufout),
"%d %s ", tabto, TAB);
q += strlen(q);
tabto = 0;
}
*q++ = '(';
instr = 1;
}
*q++ = '\\';
*q++ = *p;
}
currentp++;
break;
default: {
/*
* According to the PostScript Language Manual,
* PostScript files can contain only "the printable
* subset of the ASCII character set (plus the
* newline marker)".
*/
char pchar;
pchar = *p;
if (currentp < columns) {
if (!instr) {
if (tabto) {
(void) snprintf(q,
BUFOUT - (q - bufout),
"%d %s ", tabto, TAB);
q += strlen(q);
tabto = 0;
}
*q++ = '(';
instr = 1;
}
if (!isascii(pchar) || !isprint(pchar)) {
if (iscntrl(pchar)) {
if (pchar == '\177')
pchar = '_';
else
pchar += '@';
*q++ = '^';
} else {
*q++ = '\\';
*q++ = '0' + ((pchar>>6) & 7);
*q++ = '0' + ((pchar>>3) & 7);
pchar = '0' + (pchar & 7);
}
}
*q++ = pchar;
}
currentp++;
break;
}
}
if (q >= last) {
*q = '\0';
if (instr)
(void) fprintf(outfile, "%s)%s\n", bufout,
SHOW);
else
(void) fprintf(outfile, "%s\n", bufout);
q = bufout;
instr = 0;
}
}
if (instr) {
(void) snprintf(q, BUFOUT - (q - bufout), ")%s", SHOW);
q += strlen(q);
}
else
*q = '\0';
if (q >= last) {
fatal("bufout overflow");
/*NOTREACHED*/
}
if (bufout[0] != '\0')
(void) fprintf(outfile, "%s\n", bufout);
}
/*
* Initialize globals:
* username - login name of user
* hostname - name of machine on which lwlp is run
* currentdate - what it says
* Possible system dependencies here...
*/
void
setup(void)
{
int len;
char *p;
long t;
struct utsname utsname;
struct passwd *pw;
if ((p = getlogin()) == (char *)NULL) {
if ((pw = getpwuid(getuid())) == (struct passwd *)NULL)
p = "Whoknows";
else
p = pw->pw_name;
endpwent();
}
username = strdup(p);
(void) uname(&utsname);
hostname = strdup(utsname.nodename);
t = time((long *)0);
p = ctime(&t);
len = strlen(p);
*(p + len - 1) = '\0'; /* zap the newline character */
currentdate = strdup(p);
current.font = DEFAULT_FONT;
}
/*
* Special version of fgets
* Read until a formfeed, newline, or overflow
* If a formfeed is the first character, return it immediately
* If a formfeed is found after the first character, replace it by a newline
* and push the formfeed back onto the input stream
* A special case is a formfeed followed by a newline in which case the
* newline is ignored
* The input buffer will be null-terminated and will *not* end with a newline
* The buffer size n includes the null
*/
char *
fgetline(char *s, int n, FILE *iop)
{
int ch;
char *cs;
if (n < 2) {
fatal("fgetline called with bad buffer size!?");
/*NOTREACHED*/
}
cs = s;
n--; /* the null */
/*
* Check out the special cases
*/
if ((ch = getc(iop)) == EOF)
return ((char *)NULL);
if (ch == '\f') {
if ((ch = getc(iop)) != '\n') {
/*
* If EOF was just read it will be noticed
* next time through
*/
if (ungetc(ch, iop) == EOF && !feof(iop)) {
/*
* Shouldn't happen since a getc()
* was just done
*/
fatal("fgetline - ungetc failed");
/*NOTREACHED*/
}
}
*cs++ = '\f';
*cs = '\0';
return (s);
}
/*
* Check for "weird" input characters is made in proc()
*/
while (n-- > 0) {
if (ch == '\f' || ch == '\n')
break;
*cs++ = ch;
if ((ch = getc(iop)) == EOF)
break;
}
if (ch == EOF && cs == s) /* Nothing was read */
return ((char *)NULL);
if (ch == '\f') {
if (ungetc(ch, iop) == EOF)
(void) fprintf(stderr, "fgetline - can't ungetc??\n");
} else if (ch != '\n' && ch != EOF) {
fatal("fgetline - input line too long");
/*NOTREACHED*/
}
*cs = '\0';
return (s);
}
/*PRINTFLIKE1*/
void
fatal(char *fmt, ...)
{
va_list ap;
(void) fprintf(stderr, "%s: ", progname);
va_start(ap, fmt);
(void) vfprintf(stderr, fmt, ap);
va_end(ap);
(void) fprintf(stderr, "\n");
exit(1);
/*NOTREACHED*/
}