//********************************************************************** /* */ // Description: Ascii to PostScript printer program. // File: bounty:/archive/src/a2ps/Last/a2ps.c // Created: Fri Nov 5 8:20 1993 by miguel@bountyimag.fr (Miguel Santana) // Version: 4.3 /* */ // Edit history: // 1) Derived of shell program written by evan@csli (Evan Kirshenbaum). // Written in C for improve speed execution and portability. Many // improvements have been added. // Fixes by Oscar Nierstrasz @ cui.uucp: // 2) Fixed incorrect handling of stdin (removed error if no file names) // 3) Added start_page variable to eliminate blank pages printed for // files that are exactly multiples of 132 lines (e.g., man pages) // Modified by santana@imag.fr: // 4) Added new options at installation : sheet format (height/width in // inches), page format (number of columns per line and of lines per // page). // Modified by santana@imag.fr: // 5) Added new option to print n copies of a same document. // 6) Cut long filenames if don't fit in the page header. // Modified by Tim Clark (T.Clark@warwick.ac.uk): // 7) Two additional modes of printing (portrait and wide format modes) // 8) Fixed to cope with filenames which contain a character which must // be escaped in a PostScript string. // Modified by santana@imag.fr to // 9) Added new option to suppress heading printing. // 10) Added new option to suppress page surrounding border printing. // 11) Added new option to change font size. Lines and columns are // automatically adjusted, depending on font size and printing mode // 12) Minor changes (best layout, usage message, etc). // Modified by tullemans@apolloway.prl.philips.nl // 13) Backspaces (^H) are now handled correctly. // Modified by Johan Vromans (jv@mh.nl) to // 14) Added new option to give a header title that replaces use of // filename. // Modified by craig.r.stevenson@att.com to // 15) Print last modification date/time in header // 16) Printing current date/time on left side of footer (optional) // Modified by erikt@cs.umu.se: // 17) Added lpr support for the BSD version // 18) Added som output of pages printed. // Modified by wstahw@lso.win.tue.nl: // 19) Added option to allowing the printing of 2 files in one sheet // Modified by mai@wolfen.cc.uow.oz // 20) Added an option to set the lines per page to a specified value. // 21) Added support for printing nroff manuals // Modified by santana@imag.fr // 22) Integration of changes. // 23) No more standard header file (printed directly by a2ps). // 24) New format for command options. // 25) Other minor changes. // Modified by Johan Garpendahl (garp@isy.liu.se) and santana@imag.fr: // 26) Added 8-bit characters printing as ISO-latin 1 chars // Modified by John Interrante (interran@uluru.stanford.edu) and // santana@imag.fr: // 27) Two pages per physical page in portrait mode // Modified by santana@imag.fr: // 28) New option for two-sided printing // 29) Several fixes // Modified by Chris Adamo (adamo@ll.mit.edu) and // Larry Barbieri (lbarbieri@ll.mit.edu) 3/12/93 // 30) Output format enhancements. // 31) Added login_id flag (for SYSV and BSD only) for printing user's // login ID at top of page. Added command line parameter (-nL) to // suppress this feature. // 33) Added filename_footer flag for printing file name at bottom // of page. Added command line parameter (-nu) to suppress this // feature. // 34) Added -B (-nB) options to enable (disable) bold font // Modified by santana@imag.fr: // 35) Adapted to respect Adobe conventions for page independence. A2ps // output can be now used by other Postscript processors. // 36) Names of most postscript variables have been coded in order to // reduce the size of the output. // 37) Ansi C compilers are now automatically taken into account. // 38) Enhanced routine for cutting long filenames // 39) Added -q option to print files in quiet mode (no summary) // 40) Fixed some little bugs (counters, modification time for stdin, // character separator when printing line numbers and cutting a // line). // 41) Some minor changes (new preprocessing variables, formatting) /* */ //********************************************************************** /* * Copyright (c) 1993, 1994, Miguel Santana, M.Santana@frgu.bull.fr * * Permission is granted to use, copy, and distribute this software for * non commercial use, provided that the above copyright notice appear in * all copies and that both that copyright notice and this permission * notice appear in supporting documentation. * * Permission to modify the software is granted, but not the right to * distribute the modified code. Please report bugs and changes to * M.Santana@frgu.bull.fr * * This software is provided "as is" without express or implied warranty. */ //********************************************************************** /* */ // I n c l u d e f i l e s /* */ //********************************************************************** #include #include #include #include #include #include #include #ifdef __STDC__ #include #include #include #else #include #ifdef SYSV #include #include #include #else #ifndef BSD #define BSD 1 #endif #include #endif #endif //********************************************************************** /* */ // P r e p r o c e s s i n g d e f i n i t i o n s /* */ //********************************************************************** /* * Common definitions */ #define FALSE 0 #define TRUE 1 #ifndef NULp #define NULp 0 #endif #ifndef NUL #define NUL '\0' #endif #ifndef EXIT_SUCCESS #define EXIT_SUCCESS 0 #endif #ifndef EXIT_FAILURE #define EXIT_FAILURE 1 #endif /* * Version */ #define VERSION "4.3" #define LPR_PRINT 1 /* * Default page dimensions */ #ifndef WIDTH #define WIDTH 8.27 #endif #ifndef HEIGHT #define HEIGHT 11.0 #endif #ifndef MARGIN #define MARGIN .5 #endif /* * Pathname separator for file system */ #ifndef DIR_SEP #define DIR_SEP '/' #endif /* * Printing parameters */ #if LPR_PRINT #ifndef LPR_COMMAND #define LPR_COMMAND "lpr" #endif #ifndef LPR_OPT #define LPR_OPT "-l" #endif #if defined(ONESIDED) && defined(TWOSIDED) #define RECTO_VERSO_PRINTING #ifndef TWOSIDED_DFLT #define TWOSIDED_DFLT TRUE #endif #endif #endif /* * Configuration values */ #define PORTRAIT_HEADER 0.29 #define LANDSCAPE_HEADER 0.22 #define PIXELS_INCH 72 #define MAXFILENAME 32 #define MAX_LINES 320 // max. lines per page #define MAN_LINES 66 // no lines for a man #define IS_ROMAN 0 // normal font #define IS_BOLD 1 // bold sequence flag #if defined(SYSV) || defined(BSD) #define MAX_HOSTNAME 40 #endif //********************************************************************** /* */ // G l o b a l d e f i n i t i o n s /* */ //********************************************************************** /* * Global types */ typedef enum { BOLD, NORMAL } WEIGHT; // font weights /* * Function declarations. */ static void print_page_prologue(int side); static void print_standard_prologue(char *datestring); static void startpage(); static void endpage(); #if defined(SYSV) || defined(BSD) char *getlogin(); #endif #if defined(BSD) int gethostname(char *name, int namelen); #endif /* * Flags related to options. */ static int numbering = FALSE; // Line numbering option static int folding = TRUE; // Line folding option static int restart = FALSE; // Don't restart page number after each file static int only_printable = FALSE; // Replace non printable char by space static int interpret = TRUE; // Interpret TAB, FF and BS chars option static int print_binaries = FALSE; // Force printing for binary files static int landscape = TRUE; // Otherwise portrait format sheets static int new_landscape = TRUE; // To scrute changes of landscape option static int twinpages = TRUE; // 2 pages per sheet if true, 1 otherwise static int new_twinpages = TRUE; // To scrute changes of twinpages option static int twinfiles = FALSE; // Allow 2 files per sheet static int no_header = FALSE; // TRUE if user doesn't want the header static int no_border = FALSE; // Don't print the surrounding border ? static int printdate = FALSE; // Print current date as footnote static int filename_footer = TRUE; // Print file name at bottom of page static int no_summary = FALSE; // Quiet mode? static WEIGHT fontweight = NORMAL; // Control font weight: BOLD or NORMAL static WEIGHT new_fontweight = NORMAL; // To scrute changes of bold option #if defined(SYSV) || defined(BSD) int login_id = TRUE; // Print login ID at top of page #endif #if LPR_PRINT static int lpr_print = TRUE; // Fork a lpr process to do the printing #ifdef RECTO_VERSO_PRINTING int rectoverso = TWOSIDED_DFLT; // Two-side printing #endif #endif static int ISOlatin1 = FALSE; // Print 8-bit characters? /* * Counters of different kinds. */ static int column = 0; // Column number (in current line) static int line = 0; // Line number (in current page) static int line_number = 0; // Source line number static int pages = 0; // Number of logical pages printed static int sheets = 0; // Number of physical pages printed static int old_pages, old_sheets; // Value before printing current file static int sheetside = 0; // Side of the sheet currently printing static int linesperpage; // Lines per page static int lines_requested = 0; // Lines per page requested by the user static int new_linesrequest = 0; // To scrute new values for lines_requested static int columnsperline; // Characters per output line static int nonprinting_chars, chars; // Number of nonprinting and total chars static int copies_number = 1; // Number of copies to print static int column_width = 8; // Default column tab width (8) /* * Other global variables. */ static int first_page; // First page for a file static int no_files = TRUE; // No file until now static int prefix_width; // Width in characters for line prefix static float fontsize = 0.0; // Size of a char for body font static float new_fontsize = 0.0; // To scrute new values for fontsize static char *command; // Name of a2ps program static char *lpr_opt = NULp; // Options to lpr static char *header_text = NULp; // Allow for different header text static float header_size; // Size of the page header static char *prologue = NULp; // postscript header file static char current_filename[MAXFILENAME+1]; // Name of the file being printed static char currentdate[18]; // Date for today static char filedate[18]; // Last modification time for current file #if defined(SYSV) || defined(BSD) char *login = NULp; // user's login name and host machine #endif /* * Sheet dimensions */ static double page_height = HEIGHT; // Paper height static double page_width = WIDTH; // Paper width //********************************************************************** /* */ /* */ //********************************************************************** /* * Print a usage message. */ static void usage(int failure) { // failure: Must we exit with a failure code? fprintf(stderr, "A2ps v%s usage: %s [pos. or global options] [ f1 [ [pos. options] f2 ...] ]\n", VERSION, command); fprintf(stderr, "pos. = -#num\t\tnumber of copies to print\n"); fprintf(stderr, " -1\t\tone page per sheet\n"); fprintf(stderr, " -2\t\tTWIN PAGES per sheet\n"); fprintf(stderr, " -d\t-nd\tprint (DON'T PRINT) current date at the bottom\n"); fprintf(stderr, " -Fnum\t\tfont size, num is a float number\n"); fprintf(stderr, " -Hstr\t\tuse str like header title for subsequent files\n"); #if defined(SYSV) || defined(BSD) fprintf(stderr, " \t-nL\tdon't print login ID on top of page\n"); #endif fprintf(stderr, " -l\t\tprint in LANDSCAPE mode\n"); fprintf(stderr, " -lnum\t\tuse num lines per page\n"); fprintf(stderr, " -m\t\tprocess the file as a man\n"); fprintf(stderr, " -n\t-nn\tNUMBER (don't number) line files\n"); fprintf(stderr, " -p\t\tprint in portrait mode\n"); fprintf(stderr, " -q\t\tprint in quiet mode (no summary)\n"); fprintf(stderr, " -s\t-ns\tPRINT (don't print) surrounding borders\n"); fprintf(stderr, "\n"); fprintf(stderr, "global = -?\t\tprint this information\n"); fprintf(stderr, " -B\t-nB\tprint (DON'T PRINT) in bold font\n"); fprintf(stderr, " -b\t-nb\tforce (DON'T FORCE) binary printing\n"); fprintf(stderr, " -c\t-nc\tallow (DON'T ALLOW) two files on the same sheet\n"); fprintf(stderr, " -f\t-nf\tFOLD (don't fold) lines\n"); fprintf(stderr, " \t-nH\tdon't print any header\n"); fprintf(stderr, " -h\t\tprint this information\n"); fprintf(stderr, " -Ifile\tinclude this file as a2ps prologue\n"); fprintf(stderr, " -i\t-ni\tINTERPRET (don't interpret) tab, bs and ff chars\n"); #if LPR_PRINT fprintf(stderr, " -Pprinter -nP\tSEND (don't send) directly to the printer"); #ifdef LPR_OPT if (LPR_OPT && sizeof(LPR_OPT) > 0) fprintf(stderr, "\n\t\t\t(with options '%s' and -Pprinter)", LPR_OPT); #endif fprintf(stderr, "\n"); #endif fprintf(stderr, " -r\t-nr\tRESTART (don't restart) page number after each file\n"); #ifdef RECTO_VERSO_PRINTING #ifdef TWOSIDED_DFLT fprintf(stderr, " -s1\t-s2\tone-sided (TWO-SIDED) printing\n"); #else fprintf(stderr, " -s1\t-s2\tONE-SIDED (two-sided) printing\n"); #endif #endif fprintf(stderr, " -tnum\t\tset tab size to n\n"); fprintf(stderr, " \t-nu\tdon't print a filename footer\n"); fprintf(stderr, " -v\t-nv\tVISIBLE (blank) display of unprintable chars\n"); fprintf(stderr, " -8\t-n8\tdisplay (DON'T DISPLAY) 8-bit chars\n"); exit(failure); } /* * Set an option only if it's global. */ static void set_global_option(char *arg) { switch (arg[1]) { case '?': // help case 'h': usage(EXIT_SUCCESS); break; // silence warning (never reached) case 'b': // print binary files if (arg[2] != NUL) usage(EXIT_FAILURE); print_binaries = TRUE; break; case 'c': // allow two files per sheet if (arg[2] != NUL) usage(EXIT_FAILURE); twinfiles = TRUE; break; case 'f': // fold lines too large if (arg[2] != NUL) usage(EXIT_FAILURE); folding = TRUE; break; case 'I': // include this file as a2ps prologue if (arg[2] == NUL) usage(EXIT_FAILURE); prologue = arg+2; break; case 'i': // interpret control chars if (arg[2] != NUL) usage(EXIT_FAILURE); interpret = TRUE; break; case 'n': if (arg[2] == NUL) return; if (arg[3] != NUL) usage(EXIT_FAILURE); switch (arg[2]) { case 'b': // don't print binaries print_binaries = FALSE; break; case 'c': // don't allow 2 files/sheet twinfiles = FALSE; break; case 'f': // cut lines too long folding = FALSE; break; case 'H': // don't print header no_header = TRUE; break; case 'i': // don't interpret ctrl chars interpret = FALSE; break; #if LPR_PRINT case 'P': // don't lpr lpr_print = FALSE; break; #endif case 'r': // don't restart sheet number restart = FALSE; break; case 'v': // only printable chars only_printable = TRUE; break; case '8': // don't print 8-bit chars ISOlatin1 = FALSE; break; case 'B': case 'd': case 'L': case 'm': case 'n': case 's': case 'u': if (arg[3] != NUL) usage(EXIT_FAILURE); return; default: usage(EXIT_FAILURE); } break; #if LPR_PRINT case 'P': // fork a process to print if (arg[2] != NUL) { lpr_opt = (char *)malloc(strlen(arg)+1); strcpy(lpr_opt, arg); } lpr_print = TRUE; break; #endif case 'q': // don't print a summary no_summary = TRUE; break; case 'r': // restart sheet number if (arg[2] != NUL) usage(EXIT_FAILURE); restart = TRUE; break; case 's': if (arg[2] == NUL) return; #ifdef RECTO_VERSO_PRINTING if (arg[3] == NUL) { if (arg[2] == '1') { // one-sided printing rectoverso = FALSE; break; } if (arg[2] == '2') { // two-sided printing rectoverso = TRUE; break; } } #endif usage(EXIT_FAILURE); break; case 't': // set tab size if (arg[2] == NUL || (column_width = atoi(arg+2)) <= 0) usage(EXIT_FAILURE); break; case 'v': // print control chars if (arg[2] != NUL) usage(EXIT_FAILURE); only_printable = FALSE; break; case '8': // print 8-bit chars if (arg[2] != NUL) usage(EXIT_FAILURE); ISOlatin1 = TRUE; break; case '1': case '2': case 'B': case 'd': case 'm': case 'p': if (arg[2] != NUL) usage(EXIT_FAILURE); case '#': case 'F': case 'H': case 'l': return; default: usage(EXIT_FAILURE); } arg[0] = NUL; } /* * Set an option of the command line. This option will be applied * to all files that will be found in the rest of the command line. * The -H option is the only exception: it is applied only to the * file. */ static void set_positional_option(char *arg) { int copies; int lines; float size; switch (arg[1]) { case NUL: // global option break; case '#': // n copies if (sscanf(&arg[2], "%d", &copies) != 1 || copies <= 0) fprintf(stderr, "Bad number of copies: '%s'. Ignored\n", &arg[2]); else copies_number = copies; printf("/#copies %d def\n", copies_number); break; case '1': // 1 logical page per sheet if (arg[2] != NUL) usage(EXIT_FAILURE); new_twinpages = FALSE; break; case '2': // twin pages if (arg[2] != NUL) usage(EXIT_FAILURE); new_twinpages = TRUE; break; case 'B': new_fontweight = BOLD; // use bold font break; case 'd': // print current date/time printdate = TRUE; break; case 'F': // change font size if (arg[2] == NUL || sscanf(&arg[2], "%f", &size) != 1 || size == 0.0) { fprintf(stderr, "Wrong value for option -F: '%s'. Ignored\n", &arg[2]); break; } new_fontsize = size; break; case 'H': // header text header_text = arg+2; break; case 'l': if (arg[2] == NUL) { // landscape format new_landscape = TRUE; break; } // set lines per page // Useful with preformatted files. Scaling is automatically // done when necessary. if (sscanf(&arg[2], "%d", &lines) != 1 || lines < 0 || lines > MAX_LINES) { fprintf(stderr, "Wrong value for option -l: '%s'. Ignored\n", &arg[2]); break; } new_linesrequest = lines; break; case 'm': // Process file as a man new_linesrequest = MAN_LINES; numbering = FALSE; break; case 'n': // number file lines if (arg[2] == NUL) { numbering = TRUE; break; } switch (arg[2]) { case 'B': // disable bold text new_fontweight = NORMAL; break; case 'd': // don't print date/time printdate = FALSE; break; #if defined(SYSV) || defined(BSD) case 'L': // no login name in footer login_id = FALSE; break; #endif case 'l': // portrait format new_landscape = FALSE; break; case 'm': // stop processing as a man new_linesrequest = 0; break; case 'n': // don't number lines numbering = FALSE; break; case 'p': // landscape format new_landscape = TRUE; break; case 's': // no surrounding border no_border = TRUE; break; case 'u': // no filename in footer filename_footer = FALSE; break; default: usage(EXIT_FAILURE); } break; case 'p': // portrait format if (arg[2] != NUL) usage(EXIT_FAILURE); new_landscape = FALSE; break; case 's': // surrounding border if (arg[2] != NUL) usage(EXIT_FAILURE); no_border = FALSE; break; default: usage(EXIT_FAILURE); } } //************************************************************** // Service routines //************************************************************** /* * This routine buffers a line of input, release one character at a time * or a whole sequence of characters with some meaning like bold sequences * produced by nroff (no others sequences are recognized by the moment): * <\b><\b><\b> */ static int mygetc(int *statusp) { #define BUFFER_SIZE 512 static int curr = 0; static int size = 0; static unsigned char buffer[BUFFER_SIZE+1]; int c; *statusp = IS_ROMAN; // Read a new line, if necessary if (curr >= size) { if (!fgets((char *)buffer, BUFFER_SIZE+1, stdin)) return EOF; size = strlen((char *)buffer); if (size < BUFFER_SIZE && buffer[size-1] != '\n') { buffer[size] = '\n'; buffer[++size] = '\0'; } curr = 0; } if (buffer[curr+1] != '\b') // this is not a special sequence return buffer[curr++]; // Check if it is a bold sequence c = buffer[curr++]; if (c == buffer[curr+1] && buffer[curr] == buffer[curr+2] && c == buffer[curr+3] && buffer[curr] == buffer[curr+4] && c == buffer[curr+5]) { *statusp = IS_BOLD; curr += 6; } // Return the first character of the sequence return c; } /* * Test if we have a binary file. */ static int is_binaryfile(char *name) { if (chars > 120 || pages > 1) { first_page = FALSE; if (chars && !print_binaries && (nonprinting_chars*100 / chars) >= 60) { fprintf(stderr, "%s is a binary file: printing aborted\n", name); return TRUE; } } return FALSE; } /* * Cut long filenames. */ static void cut_filename(char *old_name, char *new_name) { char *p; int i; char *separator; if ((i = strlen(old_name)) <= MAXFILENAME) { strcpy(new_name, old_name); return; } p = old_name + (i-1); separator = NULp; i = 1; while (p >= old_name && i < MAXFILENAME) { if (*p == DIR_SEP) separator = p; p--; i++; } if (separator) p = separator; else if (p >= old_name) while (p >= old_name && *p != DIR_SEP) p--; for (i = 0, p++; *p != NUL; i++) *new_name++ = *p++; *new_name = NUL; } /* * Print a char in a form accepted by postscript printers. */ static int printchar(unsigned char c) { if (c >= ' ' && c < 0177) { if (c == '(' || c == ')' || c == '\\') putchar('\\'); putchar(c); return 0; } if (ISOlatin1 && (c > 0177)) { printf("\\%o", c); return 0; } if (only_printable) { putchar(' '); return 1; } if (c > 0177) { printf("M-"); c &= 0177; } if (c < ' ') { putchar('^'); if ((c = c + '@') == '(' || c == ')' || c == '\\') putchar('\\'); putchar(c); } else if (c == 0177) printf("^?"); else { if (c == '(' || c == ')' || c == '\\') putchar('\\'); putchar(c); } return 1; } /* * Begins a new logical page. */ static void skip_page() { if (twinpages == FALSE || sheetside == 0) { printf("%%%%Page: %d %d\n", sheets+1, sheets+1); printf("/pagesave save def\n"); // Reinitialize state variables for each new sheet print_page_prologue(0); } startpage(); } /* * Fold a line too long. */ static int fold_line(char *name) { column = 0; printf(") s\n"); if (++line >= linesperpage) { endpage(); skip_page(); if (first_page && is_binaryfile(name)) return FALSE; line = 0; } if (numbering) printf("( +"); else printf("( "); return TRUE; } /* * Cut a textline too long to the size of a page line. */ static int cut_line() { int c; int status; while ((c = mygetc(&status)) != EOF && c != '\n' && c != '\f') ; return c; } //************************************************************** // "Postscript" routines. //************************************************************** /* * Print a physical page. */ static void printpage() { sheetside = 0; sheets++; printf("/sd 0 def\n"); if (no_border == FALSE) printf("%d sn\n", sheets - (restart ? old_sheets : 0)); if (printdate) printf("cd\n"); if (filename_footer && landscape) printf("fnf\n"); #if defined(SYSV) || defined(BSD) if (login_id) printf("lg lgp\n"); #endif printf("pagesave restore\n"); printf("showpage\n"); } /* * Prints page header and page border and * initializes printing of the file lines. */ void startpage() { if (sheetside == 0) { #ifdef RECTO_VERSO_PRINTING if (rectoverso && (sheets & 0x1)) { // Shift to left backside pages. printf("rm neg 0 translate\n"); } #endif if (landscape) { printf("sw 0 translate\n"); printf("90 rotate\n"); } } pages++; if (no_header == FALSE) printf("%d hp\n", pages - old_pages); if (no_border == FALSE) { printf("border\n"); if (no_header == FALSE) printf("hborder\n"); } printf("/x0 x %d get bm add def\n", sheetside); printf("/y0 y %d get bm bfs add %s add sub def\n", sheetside, no_header ? "0" : "hs"); printf("x0 y0 moveto\n"); printf("bf setfont\n"); } /* * Terminates printing, flushing last page. */ static void cleanup() { if (twinpages && sheetside == 1) printpage(); #ifdef RECTO_VERSO_PRINTING if (!twinfiles && rectoverso && (sheets & 0x1) != 0) { sheetside = 0; sheets++; printf("%%%%Page: %d %d\n", sheets, sheets); printf("showpage\n"); } #endif } /* * Adds a sheet number to the page (footnote) and prints the formatted * page (physical impression). Activated at the end of each source page. */ void endpage() { if (twinpages && sheetside == 0) { sheetside = 1; printf("/sd 1 def\n"); } else printpage(); } //************************************************************** // Printing a file //************************************************************** /* * Print the file prologue. */ static void init_file_printing(char *name, char *title) { int new_format, new_font; char *string; int lines; float char_width; struct stat statbuf; // Print last page of previous file, if necessary if (pages > 0 && !twinfiles) cleanup(); // Initialize variables related to the format new_format = FALSE; if (new_landscape != landscape || new_twinpages != twinpages) { landscape = new_landscape; twinpages = new_twinpages; new_format = TRUE; } // Initialize variables related to the header if (no_header && name == title) header_size = 0.0; else { if (landscape || twinpages) header_size = LANDSCAPE_HEADER * PIXELS_INCH; else header_size = PORTRAIT_HEADER * PIXELS_INCH; cut_filename(title, current_filename); } // Initialize variables related to the font size new_font = FALSE; if (fontsize != new_fontsize || new_format || lines_requested != new_linesrequest || fontweight != new_fontweight) { if (new_fontsize == 0.0 || (fontsize == new_fontsize && new_format)) { new_fontsize = landscape ? 6.8 : twinpages ? 6.4 : 9.0; } if (lines_requested != new_linesrequest) { if ((lines_requested = new_linesrequest) != 0) { // Scale fontsize if (landscape) lines = (int)((page_width-header_size) / new_fontsize) - 1; else if (twinpages) lines = (int)(((page_height - 2*header_size) / 2) / new_fontsize) - 2; else lines = (int)((page_height-header_size) / new_fontsize) - 1; new_fontsize *= (float)lines / (float)lines_requested; } } fontsize = new_fontsize; fontweight = new_fontweight; new_font = TRUE; } // Initialize file printing, if there is any change if (new_format || new_font) { char_width = 0.6 * fontsize; if (landscape) { linesperpage = (int)((page_width - header_size) / fontsize) - 1; if (! twinpages) columnsperline = (int)(page_height / char_width) - 1; else columnsperline = (int)((page_height / 2) / char_width) - 1; } else { if (!twinpages) linesperpage = (int)((page_height - header_size) / fontsize) - 1; else linesperpage = (int)(((page_height - 2*header_size) / 2) / fontsize) - 2; columnsperline = (int)(page_width / char_width) - 1; } if (lines_requested > 0) linesperpage = lines_requested; if (linesperpage <= 0 || columnsperline <= 0) { fprintf(stderr, "Font %g too big !!\n", fontsize); exit(EXIT_FAILURE); } } // Retrieve file modification date and hour if (fstat(fileno(stdin), &statbuf) == -1) { fprintf(stderr, "Error getting file modification time\n"); exit(EXIT_FAILURE); } // Do we have a pipe? if (S_ISFIFO(statbuf.st_mode)) strcpy(filedate, currentdate); else { string = ctime(&statbuf.st_mtime); sprintf(filedate, "%.6s %.4s %.5s", string+4, string+20, string+11); } } /* * Print the prologue necessary for printing each physical page. * Adobe convention for page independence is enforced through this routine. */ void print_page_prologue(int side) { // side: Logical page to print (left/right) // General format printf("/twp %s def\n", twinpages ? "true" : "false"); printf("/fnfs %d def\n", landscape ? 11 : twinpages ? 10 : 15); printf("/dfs fnfs 0.8 mul def\n"); printf("/df /Helvetica dfs getfont def\n"); printf("/dw df setfont td stringwidth pop def\n"); printf("/sfnf filenmfontname fnfs getfont def\n"); printf("/hm fnfs 0.25 mul def\n"); // Header size if (header_size == 0.0) printf("/hs 0.0 def\n"); else printf("/hs %g inch def\n", landscape || twinpages ? LANDSCAPE_HEADER : PORTRAIT_HEADER); // Font sizes printf("/bfs %g def\n", fontsize); printf("/bdf /Courier-Bold bfs getfont def\n"); printf("/bm bfs 0.7 mul def\n"); printf("/bf %s bfs getfont def\n", fontweight == NORMAL ? "/CourierBack" : "/Courier-Bold"); // Page attributes printf("/l %d def\n", linesperpage); printf("/c %d def\n", columnsperline); printf("/pw\n"); printf(" bf setfont (0) stringwidth pop c mul bm dup add add\n"); printf(" def\n"); printf("/ph\n"); printf(" bfs l mul bm dup add add hs add\n"); printf(" def\n"); printf("/fns\n"); printf(" pw\n"); printf(" fnfs 4 mul dw add (Page 999) stringwidth pop add\n"); printf(" sub\n"); printf(" def\n"); printf("/tm margin twp {3} {2} ifelse div def\n"); printf("/sd %d def\n", side); if (landscape) { printf("/y [ rm ph add bm add\n"); printf(" dup ] def\n"); printf("/sny dfs dfs add def\n"); printf("/snx sh tm dfs add sub def\n"); printf("/dy sny def\n"); printf("/dx tm dfs add def\n"); if (twinpages) { printf("/x [ tm %% left page\n"); printf(" dup 2 mul pw add %% right page\n"); printf(" ] def\n"); } else { printf("/x [ tm dup ] def\n"); } printf("/scx sh 2 div def\n"); } else { printf("/x [ lm dup ] def\n"); printf("/sny tm dfs 2 mul sub def\n"); printf("/snx sw rm sub dfs sub def\n"); printf("/dy sny def\n"); printf("/dx lm def\n"); if (twinpages) { printf("/y [ tm ph add 2 mul %% up\n"); printf(" tm ph add %% down\n"); printf(" ] def\n"); } else { printf("\n%% Only one logical page\n"); printf("/y [ sh tm sub dup ] def\n"); } printf("/scx sw 2 div def\n"); } printf("/fny dy def\n"); printf("/fnx scx def\n"); printf("/ly fnfs 2 div y sd get add def\n"); printf("/lx snx def\n"); printf("/d (%s) def\n", filedate); printf("( %s ) fn\n", current_filename); } /* * Print one file. */ static void print_file(char *name, char *header) { int c; int nchars; int start_line, start_page; int continue_exit; int status, new_status; // Reinitialize postscript variables depending on positional options init_file_printing(name, header ? header : name); // If we are in compact mode and the file beginning is to be printed // in the middle of a twinpage, we have to print a new page prologue if (twinfiles && sheetside == 1) print_page_prologue(1); /* * Boolean to indicates that previous char is \n (or interpreted \f) * and a new page would be started, if more text follows */ start_page = FALSE; /* * Printing binary files is not very useful. We stop printing * if we detect one of these files. Our heuristic to detect them: * if 75% characters of first page are non-printing characters, * the file is a binary file. * Option -b force binary files impression. */ nonprinting_chars = chars = 0; // Initialize printing variables column = 0; line = line_number = 0; first_page = TRUE; start_line = TRUE; prefix_width = numbering ? 6 : 1; // Start printing skip_page(); // Process each character of the file status = IS_ROMAN; c = mygetc(&new_status); while (c != EOF) { /* * Preprocessing (before printing): * - TABs expansion (see interpret option) * - FF and BS interpretation * - replace non printable characters by a space or a char sequence * like: * ^X for ascii codes < 0x20 (X = [@, A, B, ...]) * ^? for del char * M-c for ascii codes > 0x3f * - prefix parents and backslash ['(', ')', '\'] by backslash * (escape character in postscript) */ // Form feed if (c == '\f' && interpret) { // Close current line if (!start_line) { printf(") s\n"); start_line = TRUE; } // start a new page ? if (start_page) skip_page(); // Close current page and begin another endpage(); start_page = TRUE; // Verification for binary files if (first_page && is_binaryfile(name)) return; line = 0; column = 0; if ((c = mygetc(&new_status)) == EOF) break; } // Start a new line ? if (start_line) { if (start_page) { // only if there is something to print! skip_page(); start_page = FALSE; } if (numbering) printf("(%4d|", ++line_number); else printf("( "); start_line = FALSE; } // Is a new font ? This feature is used only to detect bold // sequences produced by nroff (man pages), in connexion with // mygetc. if (status != new_status) { printf(")\n"); printf("%s", status == IS_ROMAN ? "b" : "st"); printf(" ("); status = new_status; } // Interpret each character switch (c) { case '\b': if (!interpret) goto print; // A backspace is converted to 2 chars ('\b'). These chars // with the Courier backspace font produce correct under- // lined strings. if (column) column--; putchar('\\'); putchar('b'); break; case '\n': column = 0; start_line = TRUE; printf(") s\n"); if (++line >= linesperpage) { endpage(); start_page = TRUE; if (first_page && is_binaryfile(name)) return; line = 0; } break; case '\t': if (interpret) { continue_exit = FALSE; do { if (++column + prefix_width > columnsperline) { if (folding) { if (fold_line(name) == FALSE) return; } else { c = cut_line(); continue_exit = TRUE; break; } } putchar(' '); } while (column % column_width); if (continue_exit) continue; break; } __attribute__ ((fallthrough)); // implicit fallthrough default: print : if (only_printable) { nchars = 1; } else if (! ISOlatin1) { nchars = c > 0177 ? 2 : 0; nchars += (c&0177) < ' ' || (c&0177) == 0177 ? 2 : 1; } else { nchars = c < ' ' || (c >= 0177 && c < 144) ? 2 : 1; } if (prefix_width + (column += nchars) > columnsperline) { if (folding) { if (fold_line(name) == FALSE) { return; } } else { c = cut_line(); new_status = IS_ROMAN; continue; } } nonprinting_chars += printchar(c); chars++; break; } c = mygetc(&new_status); } if (!start_line) printf(") s\n"); if (!start_page) endpage(); } //************************************************************** // Print a postscript prologue for a2ps. //************************************************************** /* * Print the a2ps prologue. */ static void print_prologue() { int c; FILE *f = NULp; char *datestring; #if defined(SYSV) || defined(BSD) char *logname, *host; int rt; #endif #if defined(SYSV) struct utsname snames; #endif // Retrieve date and hour #if defined(__STDC__) time_t date; if (time(&date) == -1) { fprintf(stderr, "Error calculating time\n"); exit(EXIT_FAILURE); } datestring = ctime(&date); #else #ifdef BSD struct timeval date; struct tm *p; (void) gettimeofday(&date, (struct timezone *)0); p = localtime(&date.tv_sec); datestring = asctime(p); #else #ifdef SYSV struct timeb date; (void)ftime(&date); datestring = ctime(&date.time); #else datestring = "--- --- -- --:--:-- ----"; #endif #endif #endif #if defined(SYSV) || defined(BSD) // Retrieve user's login name and hostname logname = getlogin(); host = (char *)malloc(MAX_HOSTNAME); if (host) { #if defined(SYSV) if ((rt = uname(&snames)) == -1 || !snames.nodename[0]) { free(host); host = NULp; } else strcpy(host, snames.nodename); #else if ((rt = gethostname(host, MAX_HOSTNAME)) == -1 || !host[0]) { free(host); host = NULp; } #endif } #endif // Print a general prologue if (!prologue) print_standard_prologue(datestring); else if ((f = fopen(prologue, "r"))) { // Header file printing while ((c = getc(f)) != EOF) putchar(c); } else { fprintf(stderr, "Postscript header missing: %s\n", prologue); exit(EXIT_FAILURE); } // Completes the prologue with a2ps static variables printf("\n%% Initialize page description variables.\n"); printf("/x0 0 def\n"); printf("/y0 0 def\n"); printf("/sh %g inch def\n", (double)HEIGHT); printf("/sw %g inch def\n", (double)WIDTH); printf("/margin %g inch def\n", (double)MARGIN); printf("/rm margin 3 div def\n"); printf("/lm margin 2 mul 3 div def\n"); printf("/d () def\n"); // And print them sprintf(currentdate, "%.6s %.4s %.5s", datestring+4, datestring+20, datestring+11); printf("/td (%s) def\n", currentdate); #if defined(SYSV) || defined(BSD) // Add the user's login name string to the Postscript output if (logname || host) { if (logname && host) printf("/lg (Printed by %s from %s) def\n", logname, host); else if (logname) printf("/lg (Printed by %s) def\n", logname); else printf("/lg (Printed from %s) def\n", host); } // If the host string was allocated via malloc, release the memory if (host) free(host); #endif // Close prolog printf("%%%%EndProlog\n\n"); // Go on printf("/docsave save def\n"); if (f) fclose(f); } /* * Print the standard prologue. */ void print_standard_prologue(char *datestring) { printf("%%!PS-Adobe-3.0\n"); printf("%%%%Creator: A2ps version %s\n", VERSION); printf("%%%%CreationDate: %.24s\n", datestring); printf("%%%%Pages: (atend)\n"); printf("%%%%DocumentFonts: Courier Courier-Bold Helvetica Helvetica-Bold\n"); printf("%%%%EndComments\n"); printf("%% Copyright (c) 1993, 1994, Miguel Santana, M.Santana@frgu.bull.fr\n"); printf("\n/$a2psdict 100 dict def\n"); printf("$a2psdict begin\n"); printf("\n%% General macros.\n"); printf("/xdef {exch def} bind def\n"); printf("/getfont {exch findfont exch scalefont} bind def\n"); if (ISOlatin1) { printf("\n%% Set up ISO Latin 1 character encoding\n"); printf("/reencodeISO {\n"); printf(" dup dup findfont dup length dict begin\n"); printf(" { 1 index /FID ne { def }{ pop pop } ifelse\n"); printf(" } forall\n"); printf(" /Encoding ISOLatin1Encoding def\n"); printf(" currentdict end definefont\n"); printf("} def\n"); printf("/Helvetica-Bold reencodeISO def\n"); printf("/Helvetica reencodeISO def\n"); printf("/Courier reencodeISO def\n"); printf("/Courier-Bold reencodeISO def\n"); } printf("\n%% Create Courier backspace font\n"); printf("/backspacefont {\n"); printf(" /Courier findfont dup length dict begin\n"); printf(" { %% forall\n"); printf(" 1 index /FID eq { pop pop } { def } ifelse\n"); printf(" } forall\n"); printf(" currentdict /UniqueID known { %% if\n"); printf(" /UniqueID UniqueID 16#800000 xor def\n"); printf(" } if\n"); printf(" CharStrings length 1 add dict begin\n"); printf(" CharStrings { def } forall\n"); printf(" /backspace { -600 0 0 0 0 0 setcachedevice } bind def\n"); printf(" currentdict\n"); printf(" end\n"); printf(" /CharStrings exch def\n"); printf(" /Encoding Encoding 256 array copy def\n"); printf(" Encoding 8 /backspace put\n"); printf(" currentdict\n"); printf(" end\n"); printf(" definefont pop\n"); printf("} bind def\n"); printf("\n%% FUNCTIONS\n"); printf("\n%% Function filename: Initialize file printing.\n"); printf("/fn\n"); printf("{ /filenm xdef\n"); printf(" /filenmwidth filenm stringwidth pop def\n"); printf(" /filenmfont\n"); printf(" filenmwidth fns gt\n"); printf(" {\n"); printf(" filenmfontname\n"); printf(" fnfs fns mul filenmwidth div\n"); printf(" getfont\n"); printf(" }\n"); printf(" { sfnf }\n"); printf(" ifelse\n"); printf(" def\n"); printf("} bind def\n"); printf("\n%% Function header: prints page header. no page\n"); printf("%% is passed as argument.\n"); printf("/hp\n"); printf(" { x sd get y sd get hs sub 1 add moveto\n"); printf(" df setfont\n"); printf(" gsave\n"); printf(" x sd get y sd get moveto\n"); printf(" 0 hs 2 div neg rmoveto \n"); printf(" hs setlinewidth\n"); printf(" 0.95 setgray\n"); printf(" pw 0 rlineto stroke\n"); printf(" grestore\n"); printf(" gsave\n"); printf(" dfs hm rmoveto\n"); printf(" d show %% date/hour\n"); printf(" grestore\n"); printf(" gsave\n"); printf(" pnum cvs pop %% page pop up\n"); printf(" pw (Page 999) stringwidth pop sub\n"); printf(" hm\n"); printf(" rmoveto\n"); printf(" (Page ) show pnum show %% page number\n"); printf(" grestore\n"); printf(" empty pnum copy pop\n"); printf(" gsave\n"); printf(" filenmfont setfont\n"); printf(" fns filenm stringwidth pop sub 2 div dw add\n"); printf(" bm 2 mul \n"); printf(" add \n"); printf(" hm\n"); printf(" rmoveto\n"); printf(" filenm show %% file name\n"); printf(" grestore\n"); printf(" } bind def\n"); printf("\n%% Function border: prints border page\n"); printf("/border \n"); printf("{ x sd get y sd get moveto\n"); printf(" gsave %% print four sides\n"); printf(" 0.7 setlinewidth %% of the square\n"); printf(" pw 0 rlineto\n"); printf(" 0 ph neg rlineto\n"); printf(" pw neg 0 rlineto\n"); printf(" closepath stroke\n"); printf(" grestore\n"); printf("} bind def\n"); printf("\n%% Function hborder: completes border of the header.\n"); printf("/hborder \n"); printf("{ gsave\n"); printf(" 0.7 setlinewidth\n"); printf(" 0 hs neg rmoveto\n"); printf(" pw 0 rlineto\n"); printf(" stroke\n"); printf(" grestore\n"); printf("} bind def\n"); printf("\n%% Function sheetnumber: prints the sheet number.\n"); printf("/sn\n"); printf(" { snx sny moveto\n"); printf(" df setfont\n"); printf(" pnum cvs\n"); printf(" dup stringwidth pop (0) stringwidth pop sub neg 0 rmoveto show\n"); printf(" empty pnum copy pop\n"); printf(" } bind def\n"); printf("\n%% Function loginprint: prints the login id of the requestor.\n"); printf("/lgp\n"); printf(" { lx ly moveto\n"); printf(" df setfont\n"); printf(" dup stringwidth pop neg 0 rmoveto show\n"); printf(" } bind def\n"); printf("\n%% Function currentdate: prints the current date.\n"); printf("/cd\n"); printf(" { dx dy moveto\n"); printf(" df setfont\n"); printf(" (Printed: ) show\n"); printf(" td show\n"); printf(" } bind def\n"); printf("\n%% Function filename_footer: prints the file name at bottom of page.\n"); printf("/fnf\n"); printf(" { fnx fny moveto\n"); printf(" df setfont\n"); printf(" filenm center show\n"); printf(" } bind def\n"); printf("\n%% Function center: centers text.\n"); printf("/center\n"); printf(" { dup stringwidth pop\n"); printf(" 2 div neg 0 rmoveto\n"); printf(" } bind def\n"); printf("\n%% Function s: print a source line\n"); printf("/s { show\n"); printf(" /y0 y0 bfs sub def\n"); printf(" x0 y0 moveto\n"); printf(" } bind def\n"); printf("\n%% Functions b and st: change to bold or standard font\n"); printf("/b { show\n"); printf(" bdf setfont\n"); printf(" } bind def\n"); printf("/st { show\n"); printf(" bf setfont\n"); printf(" } bind def\n"); printf("\n%% Strings used to make easy printing numbers\n"); printf("/pnum 12 string def\n"); printf("/empty 12 string def\n"); printf("\n%% Global initializations\n"); printf("\n/CourierBack backspacefont\n"); printf("/filenmfontname /Helvetica-Bold def\n"); printf("/inch {72 mul} bind def\n"); printf("\n%%\n"); printf("%% Meaning of some variables and functions (coded names)\n"); printf("%%\n"); printf("%% twp: twinpages?\n"); printf("%% sd: sheet side\n"); printf("%% l: line counter\n"); printf("%% c: column counter\n"); printf("%% d: date\n"); printf("%% td: current date (for today)\n"); printf("%% lg: login name\n"); printf("%% fn: filename printing function\n"); printf("%% sn: sheetnumber printing function\n"); printf("%% cd: current date printing function\n"); printf("%% fnf: filename footer printing function\n"); printf("%% lgp: login printing function\n"); printf("%% hp: header printing function\n"); printf("%% y: y coordinate for the logical page\n"); printf("%% x: x coordinate for the logical page\n"); printf("%% sny: y coordinate for the sheet number\n"); printf("%% snx: x coordinate for the sheet number\n"); printf("%% dy: y coordinate for the date\n"); printf("%% dx: x coordinate for the date\n"); printf("%% ly: y coordinate for the login\n"); printf("%% lx: x coordinate for the login\n"); printf("%% scx: x coordinate for the sheet center\n"); printf("%% fny: y coordinate for the filename (footer)\n"); printf("%% fnx: x coordinate for the filename (footer)\n"); printf("%% fnfs: filename font size\n"); printf("%% bfs: body font size\n"); printf("%% dfs: date font size\n"); printf("%% bfs: body font size\n"); printf("%% df: date font\n"); printf("%% bf: body font\n"); printf("%% bdf: bold font\n"); printf("%% sfnf: standard filename font\n"); printf("%% dw: date width\n"); printf("%% pw: page width\n"); printf("%% sw: sheet width\n"); printf("%% ph: page height\n"); printf("%% sh: sheet height\n"); printf("%% hm: header margin\n"); printf("%% tm: top margin\n"); printf("%% bm: body margin\n"); printf("%% rm: right margin\n"); printf("%% lm: left margin\n"); printf("%% hs: header size\n"); printf("%% fns: filename size\n"); } /* * Main routine for a2ps. */ int ARB_main(int argc, char *cargv[]) { char **argv = (char**)cargv; int narg; char *arg; int total; #if LPR_PRINT int fd[2]; const char *lpr_args[10]; #endif // Process global options command = argv[0]; arg = argv[narg = 1]; while (narg < argc) { if (arg[0] == '-') set_global_option(arg); arg = argv[++narg]; } #if LPR_PRINT // Start lpr process if (lpr_print) { if (pipe(fd) != 0) { fprintf(stderr, "Could not create pipe (Reason: %s)\n", strerror(errno)); exit(EXIT_FAILURE); } if (fork() == 0) { dup2(fd[0], 0); close(fd[0]); close(fd[1]); narg = 0; lpr_args[narg++] = LPR_COMMAND; #ifdef LPR_OPT lpr_args[narg++] = LPR_OPT; #endif if (lpr_opt) lpr_args[narg++] = lpr_opt; #ifdef RECTO_VERSO_PRINTING if (rectoverso) lpr_args[narg++] = TWOSIDED; else lpr_args[narg++] = ONESIDED; #endif lpr_args[narg] = (char *)0; execvp(LPR_COMMAND, (char**)lpr_args); fprintf(stderr, "Error starting lpr process \n"); exit(EXIT_FAILURE); } dup2(fd[1], 1); close(fd[0]); close(fd[1]); } #endif // Initialize variables not depending of positional options landscape = twinpages = -1; // To force format switching fontsize = -1.0; // To force fontsize switching page_height = (double)(HEIGHT - MARGIN) * PIXELS_INCH; page_width = (double)(WIDTH - MARGIN) * PIXELS_INCH; // Postscript prologue printing print_prologue(); // Print files designated or standard input arg = argv[narg = 1]; while (narg < argc) { if (arg[0] != NUL) { if (arg[0] == '-') set_positional_option(arg); else { if (!freopen(arg, "r", stdin)) { fprintf(stderr, "Error opening %s\n", arg); cleanup(); printf("\n%%%%Trailer\ndocsave restore end\n\4"); exit(EXIT_FAILURE); } no_files = FALSE; // Save counters values old_pages = pages; if (twinfiles && twinpages) old_sheets = sheets; else old_sheets = sheets + sheetside; // Print the file print_file(arg, header_text); // Print the number of pages and sheets printed if (no_summary == FALSE) { total = pages - old_pages; fprintf(stderr, "[%s: %d page%s on ", arg, total, total == 1 ? "" : "s"); total = sheets - old_sheets + sheetside; #ifdef RECTO_VERSO_PRINTING if (rectoverso) total = (total+1) / 2; #endif fprintf(stderr, "%d sheet%s]\n", total, total == 1 ? "" : "s"); } // Reinitialize header title header_text = NULp; } } arg = argv[++narg]; } if (no_files) print_file((char*)"stdin", header_text); // Print the total number of pages printed if (no_summary == FALSE && pages != old_pages) { fprintf(stderr, "[Total: %d page%s on ", pages, pages == 1 ? "" : "s"); total = sheets + sheetside; #ifdef RECTO_VERSO_PRINTING if (rectoverso) total = (total+1) / 2; #endif fprintf(stderr, "%d sheet%s]\n", total, total == 1 ? "" : "s"); } // And stop cleanup(); printf("\n%%%%Trailer\n"); printf("%%%%Pages: %d\n", sheets + sheetside); printf("docsave restore end\n"); exit(EXIT_SUCCESS); }