4.3BSD/usr/contrib/dipress/src/bin/maha/maha.c
/*
* maharani - a czarina-like program that generates interpress files
*
* Written for Xerox Corporation by William LeFebvre
*
* Copyright (c) 1984, 1985 Xerox Corporation
*
* HISTORY
* 13-Jan-86 lee at Xerox, WRC
* Changed a call to strcpyn to strncpy.
*
* 8-apr-85 ed flint conditional compilation for vax11-c (vms)
* 26-mar-85 ed @ Xerox, WRC
* add fclose after do_file to prevent running out of open file descriptors
*/
#ifdef vax11c
# include stdio
# include ssdef
# include ctype
# include descrip
#else
# include <stdio.h>
# include <pwd.h>
# include <strings.h>
# include <sys/types.h>
# include <sys/stat.h>
# include <sys/time.h>
#endif
# include "iptokens.h"
# include "literal.h"
# include "operator.h"
# define QIP "qip"
# define Break_size 1024
# define Default_universal_prefix "Xerox/XC1-1-1/"
# define Line_size 128
/* All page boundaries are computed in the 1/10 point co-ordinate system */
/*
* Orig_y is an offset from the top of the page. It must be converted
* to a measurement from the bottom of the page (a calculation that is
* rotation-dependent).
*/
# define INCH 720
# define Half_INCH 360
# define Sixth_INCH 120 /* one line at 6 lpi */
# define Page_width (8 * INCH + Half_INCH)
# define Page_length (11 * INCH)
# define Orig_x (9 * INCH / 10)
# define Orig_y (Sixth_INCH * 5)
# define Header_to_orig_x 0
# define Header_to_orig_y (2 * Sixth_INCH)
/* Frame variable defines */
# define F_transform 0
# define F_headfont 1
# define F_bodyfont 2
# define F_italicfont 3
# define No 0
# define Yes 1
extern int errno;
/* enum, perhaps? */
typedef char boolean;
/* routines that return something other than int */
char *strecpy();
char *allocate();
char *next_arg();
char *sbrk();
char *getenv();
char *itoa();
char *rindex();
/* option flags */
boolean lflg = No; /* line printer mode */
boolean rflg = No; /* rotation - landscape mode */
boolean tflg = No; /* omit title */
/* valued options */
int columns = 1;
char *bodyfont_name = "Vintage-Printwheel/10";
char *headfont_name = "Modern-Bold/12";
char *italicfont_name = "Modern-Bold-Italic/12";
char *banner = NULL;
char *copies = "1";
char *header = "%f %t Page %p, line %l";
char *name = NULL;
char *output = NULL;
char *pages = NULL;
#ifdef vax11c
char *template = "IPPXXXXXX";
#endif
/*
* page characteristics: these variables define the extremes for the
* current page or column. 'column_separation' is the distance between
* the left sides of each column on the page.
*/
int left_margin = Orig_x;
int right_margin;
int top_margin;
int bottom_margin;
int column_separation;
/* sundries */
boolean send_to_printer = Yes;
char real_header[256]; /* header built here */
char *myname; /* name invoked with */
char *filename;
int *page_select = NULL; /* array of page selections */
int *curr_page_select;
int page_low;
int page_high;
int ipress_file; /* interpress file descriptor */
int null_file; /* fd for /dev/null */
int line_number;
int page_number;
int pages_printed = 0; /* total pages for this interpress file */
int special_font = 0; /* fonts that require special handling */
int line_spacing;
int tab_amount = 8;
#ifndef vax11c
struct passwd *pwd; /* passwd entry for this user */
struct stat file_stat; /* stat of current file */
#endif
# define Font_Terminal 1
/* current arguments */
int argc;
char **argv;
/* font structure definition */
struct font
{
char *ft_universal_name;
char *ft_leaf_name;
int ft_size;
};
/* fonts used */
struct font headfont;
struct font bodyfont;
struct font italicfont;
main(_argc, _argv)
int _argc;
char **_argv;
{
char *ptr; /* temporary pointers used for loops and such */
char *src;
char *dest;
int length;
int i;
FILE *file; /* file currently processing */
#ifdef vax11c
int error;
int retlen;
char command[256];
$DESCRIPTOR(mahadesc,"MAHAENV");
$DESCRIPTOR(cmddesc,command);
#endif
/* get our name */
if (_argc < 1)
{
exit(1);
}
#ifdef vax11c
myname= _argv[0];
#else
if ((myname = rindex(_argv[0], '/')) == NULL)
{
myname = _argv[0];
}
else
{
myname++;
}
#endif
/* get the options specified in the environment (defaults) */
#ifdef vax11c
if ( (error= lib$get_symbol(&mahadesc,&cmddesc,&retlen)) == SS$_NORMAL )
{
if ( retlen != 0 )
{
command[retlen & 0xff]= '\0'; /* null terminate string */
src= command;
/* break the string up into null terminated arguments */
/* half the length is a good upper bound on number of arguments */
argv = (char **)allocate(strlen(src) / 2);
for (argc = 1, ptr = src; *ptr != '\0'; argc++)
{
while (*ptr == ' ')
ptr++;
argv[argc] = ptr;
while (*ptr != ' ' && *ptr != '\0')
{
if (*ptr == '"')
{
while (*++ptr != '"' && *ptr != '\0');
}
else if (*ptr == '\'')
{
while (*++ptr != '\'' && *ptr != '\0');
}
ptr++;
}
*ptr++ = '\0';
}
/* terminate the argument list */
argv[argc] = NULL;
/* process the options found in the environment */
get_options();
}
}
#else
if ((src = getenv("MAHA")) != NULL)
{
/* break the string up into null terminated arguments */
/* half the length is a good upper bound on number of arguments */
argv = (char **)allocate(strlen(src) / 2);
for (argc = 1, ptr = src; *ptr != '\0'; argc++)
{
while (*ptr == ' ')
ptr++;
argv[argc] = ptr;
while (*ptr != ' ' && *ptr != '\0')
{
if (*ptr == '"')
{
while (*++ptr != '"' && *ptr != '\0');
}
else if (*ptr == '\'')
{
while (*++ptr != '\'' && *ptr != '\0');
}
ptr++;
}
*ptr++ = '\0';
}
/* terminate the argument list */
argv[argc] = NULL;
/* process the options found in the environment */
get_options();
}
#endif
/* use the real arguments */
argc = _argc;
argv = _argv;
/* process (real) arguments */
get_options();
/* establish and verify the requested fonts */
establish_font(headfont_name, &headfont);
establish_font(bodyfont_name, &bodyfont);
establish_font(italicfont_name, &italicfont);
#ifndef vax11c
/* get passwd entry for future reference */
pwd = getpwuid(geteuid());
#endif
/* setup output file */
if (output == NULL)
{
/* build a temporary file name */
#ifdef vax11c
output= mktemp(template);
#else
output = allocate(1 + 5 + 1 + 2 + 1);
(void) sprintf(output, "/tmp/@%d.ip", getpid());
#endif
}
#ifdef vax11c
if ((ipress_file = creat(output, 0, "rfm=udf")) == -1)
#else
if ((ipress_file = creat(output, 0666)) == -1)
#endif
{
system_error(output);
exit(1);
}
ip_select(ipress_file);
#ifndef vax11c
/* open the null device for throwing away output */
null_file = open("/dev/null", 1);
/* set null strings to default values */
if (name == NULL)
{
/* banner name defaults to full name from gecos field */
name = pwd->pw_gecos;
/* perform expansion and stripping */
if ((ptr = index(name, ',')) != NULL)
{
*ptr = '\0'; /* this affects pwd->pw_gecos, too! */
}
if (index(name, '&') != NULL)
{
name = allocate(strlen(name) + strlen(pwd->pw_name) + 1);
for (src = pwd->pw_gecos, dest = name; *src != '\0'; src++, dest++)
{
if (*src == '&')
{
for (ptr = pwd->pw_name; *ptr != '\0'; ptr++)
{
*dest++ = *ptr;
}
}
else
{
*dest = *src;
}
}
}
}
#endif
if (banner == NULL)
{
/* banner defaults to file name(s) */
if (argc == 0)
{
banner = "out of the blue";
}
else
{
for (length = 0, i = 0; i < argc; i++)
{
length += strlen(argv[i]) + 2;
}
banner = allocate(length + 1);
for (ptr = banner, i = 0; i < argc; i++)
{
ptr = strecpy(ptr, argv[i]);
ptr = strecpy(ptr, ", ");
}
ptr -= 2;
*ptr = '\0';
}
}
/* unravel the page specifiation */
/* we will never need more than strlen(pages) ints to hold the info */
if (pages != NULL)
{
page_select = (int *)allocate(strlen(pages) * sizeof(int));
unravel_pages(pages, page_select);
}
/* write the preamble for the interpress file */
Op(beginBlock);
Op(beginBody); /* preamble start */
/* setup font definitions in frame */
SetupFont(headfont.ft_universal_name,
headfont.ft_size * 10.,
F_headfont);
SetupFont(bodyfont.ft_universal_name,
bodyfont.ft_size * 10.,
F_bodyfont);
SetupFont(italicfont.ft_universal_name,
headfont.ft_size * 10., /* use headfont's size */
F_italicfont);
/* remember special fonts */
if (strcmp(bodyfont.ft_leaf_name, "Terminal") == 0)
{
special_font = Font_Terminal;
}
/* save scaling transform that uses 1/10 point co-ordinate system */
top_margin = (rflg ? Page_width : Page_length) - Orig_y;
bottom_margin = 2 * Sixth_INCH;
right_margin = (rflg ? Page_length : Page_width) - Orig_x;
column_separation = (right_margin - Orig_x) / columns;
line_spacing = (bodyfont.ft_size + 2) * 10;
if (rflg)
{
/* we need a rotation transform, too */
Rotate(90.);
Translate((double)Page_width, (double)0);
}
AppendRational(353L,10000000L);
Op(scale);
if (rflg)
{
Op(concat);
Op(concat);
}
AppendInteger((long) F_transform);
Op(fset);
Op(endBody); /* end preamble */
if (argc == 0)
{
/* no filenames -- do standard input */
filename = NULL;
do_file(stdin);
}
for (; argc > 0; argc--, argv++)
{
filename = argv[0];
if (strcmp(filename, "-") == 0)
{
/* this is really standard input */
filename = NULL;
do_file(stdin);
}
else
{
/* open the file */
if ((file = fopen(filename, "r")) == NULL)
{
system_error(filename);
}
else
{
do_file(file);
(void) fclose(file);
}
}
}
/* wrap up the output */
ip_select(ipress_file);
Op(endBlock);
ip_close();
/* send to the printer */
if (send_to_printer)
{
if (pages_printed == 0)
{
/* don't print anything but remove temporary */
#ifdef vax11c
delete(output);
#else
(void) unlink(output);
#endif
}
else
{
#ifdef vax11c
char buff[256];
int wait= 0;
$DESCRIPTOR(buffdesc,buff);
(void) strcpy(buff,"xpress/noformat ");
(void) strcat(buff,output);
buffdesc.dsc$w_length= strlen(buff);
if ( (error= lib$spawn(&buffdesc,0,0,&wait)) != SS$_NORMAL )
{
fprintf(stderr,"\nFile %s contains interpress master\n",output);
exit(error);
}
delete(output);
#else
char *buff;
/* exec a "qip" to queue the file */
buff = allocate(strlen(name) + 1 + 1);
(void) strcpy(buff, "F");
(void) strcat(buff, name);
execl(QIP, "qip", "-c", copies, "-nc", "-nk",
"-t", banner, "-x", buff, output, 0);
perror(QIP);
fprintf(stderr, "File %s contains interpress master.\n", output);
#endif
}
}
}
get_options()
{
while (--argc > 0)
{
argv++;
if (!process_arg())
{
break;
}
}
}
/*
* unravel_pages(str, spec) - unravel the page range specification in "str"
* into integer pairs in "spec". The first two
* ints in "spec" bound the first range of pages,
* the next two bound the second range, and so on.
* The array is terminated with the pair 0, 0.
*/
unravel_pages(str, spec)
char *str;
int *spec;
{
int last_num = 0;
int this_num = 0;
register char ch;
boolean is_range = No;
boolean bad_spec = No;
boolean done = No;
# define Start_new_num (last_num = this_num, this_num = 0)
while (!done)
{
if ((ch = *str++) == '\0')
{
/* set "done" flag and pretend it's the end of a number */
done = Yes;
ch = ',';
}
if (ch >= '0' && ch <= '9')
{
this_num *= 10;
this_num += ch - '0';
}
else if (ch == '-')
{
if (this_num < last_num && *str != '\0')
{
bad_spec = Yes;
}
*spec++ = this_num;
Start_new_num;
is_range = Yes;
}
else if (ch == ',')
{
if (this_num < last_num)
{
bad_spec = Yes;
}
*spec++ = this_num;
if (is_range)
{
is_range = No;
}
else
{
*spec++ = this_num;
}
Start_new_num;
}
else
{
fprintf(stderr, "%s: bad character in page specification\n",
myname);
exit(1);
}
}
if (*--spec == 0)
{
*spec = 1 << 15; /* infinity */
}
if (bad_spec)
{
fprintf(stderr,
"%s: pages should be given in non-descending order.\n",
myname);
}
}
process_arg()
{
register char ch;
register int temp;
register char *p1;
register char *p2;
if (argv[0][0] == '-')
{
if ((ch = argv[0][1]) > '0' && ch <= '9')
{
/* this is a column count specifier */
columns = ch - '0';
}
else switch(ch)
{
case '\0': /* not an option */
return(No);
case 'b':
banner = next_arg();
break;
case 'c':
temp = atoi(copies = next_arg());
if (temp < 1)
{
fprintf(stderr,
"%s: bogus number of copies; you only get one!\n",
myname);
copies = "1";
}
break;
case 'f':
bodyfont_name = next_arg();
break;
case 'F':
headfont_name = next_arg();
break;
case 'H': /* replace header */
header = next_arg();
break;
case 'h': /* append to header */
p1 = next_arg();
p2 = allocate(strlen(header) + strlen(p1) + 1);
(void) strcpy(p2, header);
(void) strcat(p2, " ");
(void) strcat(p2, p1);
header = p2;
break;
case 'l':
tflg = lflg = Yes;
break;
case 'n':
name = next_arg();
break;
case 'o':
output = next_arg();
send_to_printer = No;
break;
case 'r':
rflg = Yes;
break;
case 'R':
rflg = No;
break;
case 's':
pages = next_arg();
break;
case 't':
tflg = Yes;
break;
default:
fprintf(stderr, "%s: unknown option '%c'\n", myname, ch);
}
return(Yes);
}
else
{
return(No);
}
}
char *next_arg()
{
if (argv[0][2] == '\0')
{
if (--argc > 0)
{
return((++argv)[0]);
}
else
{
argv++;
return(NULL);
}
}
else
{
return(&(argv[0][2]));
}
}
/*
* establish_font(name, font) - break apart the parts of the string "name"
* and fill in the structure pointed to by
* "font". Also, verify that the font requested
* actually exists. This routine also
* understands universal font names.
*/
establish_font(name, font)
char *name;
struct font *font;
{
register char *unamep;
register char *ptr;
char *slashp;
register int size;
if (name[0] != '/')
{
/* not a universal name -- put the default on the front */
font->ft_universal_name = unamep =
allocate(strlen(Default_universal_prefix) +
strlen(name) + 1);
(void) strcpy(unamep, Default_universal_prefix);
(void) strcat(unamep, name);
}
else
{
/* already is a universal name -- just allocate space for it */
font->ft_universal_name = unamep = allocate(strlen(name));
/* copy in the whole name, without the leading slash */
(void) strcpy(unamep, name + 1);
}
/* strip size off the end, if it is there */
if ((slashp = ptr = rindex(unamep, '/')) != NULL)
{
register char ch;
size = 0;
while ((ch = *++ptr) != '\0')
{
if (ch < '0' || ch > '9')
{
/* last element is not a number -- no point size */
size = 0;
break;
}
/* shift this digit in */
size *= 10;
size += (ch - '0');
}
/* if no point size, use default */
if (size == 0)
{
font->ft_size = 10;
}
else
{
font->ft_size = size;
*slashp = '\0';
}
}
/* set pointer to last element */
if ((ptr = rindex(unamep, '/')) != NULL)
{
font->ft_leaf_name = ptr + 1;
}
else
{
font->ft_leaf_name = font->ft_universal_name;
}
}
do_file(file)
FILE *file;
{
char *src;
char *dest;
char input_line[Line_size];
char line_buffer[Line_size];
char ch;
int current_line;
int lines_on_page;
int length;
int column;
#ifndef vax11c
/* fstat it to get information displayed in the header */
if (fstat(fileno(file), &file_stat) == -1)
{
system_error("fstat botched");
return;
}
#endif
/* reset essentials */
page_number = 0;
line_number = 1;
lines_on_page = 0;
curr_page_select = page_select;
if (pages != NULL)
{
page_low = page_select[0];
page_high = page_select[1];
}
current_line = top_margin;
/*
* Strangeness: page_number is incremented by page_start and
* line_number is incremented in the "while(fgets..." loop.
*/
/* start the first page */
page_start();
/*
* More strangeness: we had to set line_number to 1 to trick
* page_start into reporting the right line count in the header. Now
* we reset it to 0 before entering the read/print loop.
*/
line_number = 0;
while (fgets(input_line, Line_size, file) != NULL)
{
/* new line */
line_number++;
/* remember the length */
length = strlen(input_line);
/* nuke any trailing newline */
if (input_line[length - 1] == '\n')
{
input_line[--length] = '\0';
}
if (lflg ? lines_on_page >= 66 : current_line < bottom_margin)
{
/* start a new page */
page_end(No);
page_start();
lines_on_page = 0;
/* remember, y goes backwards */
current_line = top_margin;
}
/* make sure that the line actually contains something */
if (input_line[0] != '\0')
{
/* set x and y for the beginning of the line */
Setxy((double)left_margin, (double)current_line);
/* copy from input_line to line_buffer making any necessary
changes along the way */
column = 0;
src = input_line;
dest = line_buffer;
while ((ch = *src) != '\0')
{
switch(ch)
{
case '\f': /* new page after this line */
current_line = bottom_margin;
lines_on_page = 66;
break;
case '\t': /* tab expansion */
do
{
*dest++ = ' ';
column++;
} while (column % tab_amount != 0);
break;
case '$':
*dest++ = '\244';
column++;
break;
case '-':
if (special_font == Font_Terminal)
{
/* heavy hackery here */
*dest = '\0';
ShowString(line_buffer);
Setyrel(-20.);
ShowString("\305");
Setyrel(20.);
dest = line_buffer;
column++;
break;
}
/* else fall thru ... */
default:
*dest++ = ch;
column++;
}
src++;
}
*dest = '\0';
if (line_buffer[0] != '\0')
{
ShowString(line_buffer);
}
}
/* advance the line counters */
current_line -= line_spacing;
lines_on_page++;
}
/* wrap up the file */
page_end(Yes);
}
/*
* page handling: a distinction is made between virtual pages and actual
* pages. A virtual page is one series of lines from the file that appears
* vertically on the printed page. The actual page is the page as the
* printer prints it (a printed page, if you will). There may be several
* virtual pages on one actual page. The page_start and page_end routines
* that follow start and terminate virtual pages. The mapping between
* virtual and actual pages is a function of the options specified by the
* user. If the user requests two column output then there will be two
* virtual pages for every actual page. These pages will sit side-by-side on
* the actual page. The mapping is accomplished by changing the variables
* left_margin and right_margin. "page_start" also handles printing of the
* page header, since there is only one of these on every actual page.
*/
static int current_column;
page_start()
{
boolean in_set;
#ifdef vax11c
long bintim;
#endif
/* reset the column count if starting a new file */
if (line_number == 1)
{
current_column = 0;
}
/* either move the left margin or put out a new page */
if (current_column != 0)
{
left_margin += column_separation;
}
else
{
/* increment page count and reset margin */
page_number++;
left_margin = Orig_x;
/* is it in the page specification set? */
if (page_select == NULL)
{
/* every page is in the set if there is no specification */
in_set = Yes;
}
else
{
if (page_low <= page_number && page_number <= page_high)
{
in_set = Yes;
ip_select(ipress_file);
if (page_number == page_high)
{
/* at the top of the current range -- time to move up */
curr_page_select += 2;
page_low = curr_page_select[0];
page_high = curr_page_select[1];
}
}
else
{
/* not in set -- redirect output to null device */
in_set = No;
ip_select(null_file);
}
}
if (in_set)
{
register char *src;
register char *dst;
register char ch;
/* increment total page count */
pages_printed++;
/* output stuff for new ip page */
Op(beginBody);
/* set the transformation */
Fget(F_transform);
Op(concatt);
/* build the header if we need to print it */
if (!tflg)
{
/* move characters from header to real_header */
/* and expand format items along the way. */
src = header;
dst = real_header;
while ((ch = *src) != '\0')
{
if (ch == '%')
{
switch(ch = *++src)
{
case 'f': /* file name */
dst = strecpy(dst,
filename == NULL ?
"Standard input" :
filename);
break;
case 't': /* mtime */
#ifdef vax11c
time(&bintim);
strncpy(dst,ctime(&bintim), 24);
dst += 24;
#else
/*
* ctime returns a 26 character string that
* has a newline and null at the end.
* 26 - 2 == 24.
*/
if (file_stat.st_mtime != 0)
{
(void) strncpy(dst,ctime(&file_stat.st_mtime),24);
dst += 24;
}
#endif
break;
case 'p': /* page number */
dst = itoa(dst, page_number);
break;
case 'l': /* line number */
dst = itoa(dst, line_number);
break;
case '\0': /* end of the string */
src--; /* maintain loop invariant */
break;
default: /* copy the character */
*dst++ = ch;
/* break; */
}
}
else
{
*dst++ = ch;
}
src++;
}
/* terminate the real header */
*dst = '\0';
/* display the header */
Setxy((double)(left_margin - Header_to_orig_x),
(double)(top_margin + Header_to_orig_y));
Setfont(F_headfont);
ShowString(real_header);
}
}
}
/* select the body font */
Setfont(F_bodyfont);
}
page_end(eof)
int eof;
{
if ((current_column = ++current_column % columns) == 0 || eof)
{
Op(endBody);
}
}
char *strecpy(dest, src)
register char *src;
register char *dest;
{
while (*dest++ = *src++)
;
return(--dest);
}
char *itoa(buff, val)
char *buff;
int val;
{
char tbuff[12]; /* will build number here -- max of 10 digits */
register char *ptr = tbuff + 11;
*ptr-- = '\0';
while (val != 0)
{
*ptr-- = (val % 10) + '0';
val /= 10;
}
return(strecpy(buff, ++ptr));
}
/*
* allocate(space) - allocate "space" bytes with sbrk. This routine uses a
* fairly naive algorithm. It sbrk-s space in Break_size
* chunks and allocates space from a chunk until a request
* for more space than is left in the chunk is made. Then,
* it allocates a new chunk. The unused space at the end
* of the old chunk remains unused. This does NOT depend
* on sbrk returning contiguous chunks of memory during the
* life of the program.
*/
char *allocate(space)
int space;
{
static char *hi_water = NULL;
static char *max_alloc = NULL;
register char *ptr;
/* this works with max_alloc = hi_water = NULL, although we probably
shouldn't depend on that! */
if (max_alloc + space > hi_water)
{
hi_water = sbrk(Break_size);
if ((int)hi_water == -1)
{
system_error("out of space");
exit(1);
}
max_alloc = hi_water + Break_size - 1;
}
ptr = hi_water;
hi_water += space;
return(ptr);
}
system_error(message)
char *message;
{
int saved_errno;
/* value of errno not preserved by fprintf */
saved_errno = errno;
fprintf(stderr, "%s: ", myname);
errno = saved_errno;
perror(message);
}
#ifdef vax11c
char *rindex(string, c)
char *string, c;
{
register char *pos;
pos = 0;
do {
if (*string == c)
pos = string;
} while (*string++);
return(pos);
}
#endif