General Purpose PostScript Generating Utility

1 Introduction

This document describes GNU a2ps version 4.14. The latest versions may be found on the a2ps . We plan to update the GNU a2ps in the near future, in which case the latter will be a better source of information.

We tried to make this document informative and pleasant. It tries to be more than a plain reference guide, and intends to offer information about the concepts or tools etc. that are related to printing PostScript. This is why it is now that big: to offer you all the information you might want, not because a2ps is difficult to use. See Glossary, for technical words or even general information.

Please, send us emailcards :). Whatever the comment is, or if you just like a2ps, write to Miguel Santana and Akim Demaille. But never write to either of us for asking questions, or to report bugs. Chances are very high never to receive an answer, as we receive too many messages. See a2ps Mailing Lists, for information on the mailing lists.

• Description: What a2ps is
• Reporting Bugs: What to do when you face problems
• a2ps Mailing Lists: Getting news about a2ps
• Helping the Development: How to contribute

1.1 Description

a2ps formats files for printing on a PostScript printer.

The format used is nice and compact: normally two pages on each physical page, borders surrounding pages, headers with useful information (page number, printing date, file name or supplied header), line numbering, pretty-printing, symbol substitution etc. This is very useful for making archive listings of programs or just to check your code in the bus. Actually a2ps is kind of bootstrapped: its sources are frequently printed with a2ps :).

While at the origin its names was derived from “ASCII to PostScript”, today we like to think of it as “Any to PostScript”. Indeed, a2ps supports delegations, i.e., you can safely use a2ps to print DVI, PostScript, LaTeX, JPEG etc., even compressed.

A short list of features of a2ps might look like this:

• Customizable through various configuration files (see Configuration Files)
• Powerful escapes to define the headers, table of contents etc. the way you want (see Escapes);
• Variables to push even further the customizability in a comfortable manner (see Your Variables);
• Open approach of encodings (see Encodings);
• Excellent support of the Latin 2, 3, 4, 5 and 6 encodings, thanks to Ogonkify (see Overview (Ogonkify manual)), written by Juliusz Chroboczek.
• Fully customizable output style: fonts, background and foreground colors, line numbering style etc. (see Designing PostScript Prologues).
• Possibility to delegate the processing of some files to other filters (see Your Delegations).
• Many contributions, e.g., pretty-print diffs, print reference cards of programs, sanitize broken PostScript files, print Duplex on Simplex printers etc. (see Contributions).
• And finally, the ability to pretty-print sources written in quite a few various languages (see Pretty Printing).

1.2 Reporting Bugs

We try hard to make a2ps portable on any Unix platform, and bug free. But sometimes there can still be bad surprises, even after having compiled and checked a2ps on several very different platforms.

You may encounter some of these problems yourself. In any case, please never abandon without giving us a chance. We need information from everybody so that mistakes get fixed as fast as possible.

So, if you have a problem (configuration error, compilation error, runtime error, documentation error or unclear), first check in the FAQ (see FAQ), then on the page Known a2ps if the issue has not been addressed yet. If it is not the case, but it appears that the version of a2ps you have is old, consider upgrading.

If the problem persists, send us a mail (bug-a2ps@gnu.org) which subject is a2ps version: short-description and which content mentions the name of your machine and OS, the version of a2ps, every detail you have on your compiler, and as much traces as possible (the error messages you get on the screen, or the output of make when it fails etc.).

Be sure to get a quick answer.

1.3 a2ps Mailing Lists

There are several mailing lists related to a2ps:

a2ps@gnu.org

This list is dedicated to announcements, questions/answers, etc. The alpha versions are announced too. Requests and suggestions can be sent there.

bug-a2ps@gnu.org

Any bug report should be sent to this address. Please, be sure to state the version of a2ps in the subject of your message, together with a short description of the problem. In the body of the message, include all the information that might be relevant: the system you run, etc.

a2ps-patches@gnu.org

Send patches, style sheets, new delegations etc. to this list. In other words, any candidate for inclusion into a2ps should be sent to this list. It also serves to coordinate the developers. If you are interested in the development of a2ps, then visit the Savannah a2ps page.

a2ps-commit@gnu.org

Each time a change is made the main a2ps repository, a message is sent to this mailing list. For developers only.

To subscribe to any of these list, go to their web pages: a2ps, bug-a2ps, a2ps-patches, and a2ps-commit.

Be sure never to send a private message to one of the authors, as it is approximately the best means never to get an answer. In addition it is counter productive for the community, as the answer to your question might have interested more people.

1.4 Helping the Development

If you like a2ps and if you feel like helping, there are several things you can do.

Testing

You just can't imagine how hard it is to make sure that the program that works perfectly here will work on your machine. Actually, in general the last weeks before a release are mostly dedicated to (Unix) portability issues.

So we need beta-testers! To be one is fairly simple: subscribe to the mailing-list where the betas are announced and distributed.

Translation

The interface of a2ps is under GNU gettext which means that all the messages can be translated, without having to look at the code of a2ps: you don't need to be a programmer at all. All the details are available on the a2ps translation page.

Style Sheets

Since a2ps is evolving and getting more powerful, the style sheets should be checked and improved. There are too many so that the authors work on them. Therefore if you feel your favorite language is not honored as it should be, improve the style sheet! (see Pretty Printing for details.)

Encodings

a2ps is wide open to any 8-bit encoding. If your language is not covered today by a2ps, you can easily provide the support yourself. Honestly, the trickiest part is to find correct free fonts that support your mother tongue (see Encoding Files, to know more).

Fonts

There are still some characters missing in Ogonkify. See the list of missing characters and the Ogonkify home page for details.

Documentation

If you feel something is missing or is unclear, send us your contributions.

Porting

Porting a program to special architectures (MS-DOS, OS/2 etc.), or building special packages (e.g., RPM) requires having an access to these architectures. If you feel like maintaining such a port, tell us.

Features

Well, if you feel like doing something else, go ahead! But contact us, because we have quite a big stack of things we want to do or have started to do, and synchronizing might be useful.

2 User's Guide

This chapter is devoted to people who don't know a2ps yet: we try to give a soft and smooth introduction to the most useful features. For a reference manual, see Invoking a2ps. For the definition of some words, see Glossary, for questions you have, see FAQ.

• Purpose: What a2ps is made for
• How to print: The basis
• Important parameters: What needs to be set
• Localizing: How to have a2ps speaking your language
• Interfacing: Using a2ps from common programs

2.1 Purpose

a2ps is a program that takes a text file (i.e., human readable), and makes a PostScript file out of it. Typically output is sent to a printer.

2.2 How to print

To print a file doc.txt, just give it to a2ps: the default setting should be the one you'd like:

     

     gargantua ~ $ a2ps doc.txt
     [doc.txt (plain): 9 pages on 5 sheets]
     [Total: 9 pages on 5 sheets] sent to the default printer
     

a2ps sent the file doc.txt to the default printer, writing two columns of text on a single face of the sheet. Indeed, by default a2ps uses the option -2, standing for two virtual pages.

• Basics for Printing: Printing text files
• Special Printers: Some useful fake printers
• Using Delegations: Printing special files (PS, DVI etc.)
• Printing Duplex: Doing Fancy Things
• Checking the Defaults: Is it set the way you want?

2.2.1 Basics for Printing

Say you want to print the C file bar.c, and its header foo.h, on 4 virtual pages, and save it into the file foobar.ps. Just hit:

     

     gargantua $ a2ps foo.h bar.c -4 -o foobar.ps
     [foo.h (C): 1 page on 1 sheet]
     [bar.c (C): 3 pages on 1 sheet]
     [Total: 4 pages on 2 sheets] saved into the file `foobar.ps'
     

The option -4 tells a2ps to make four virtual pages: two rows by two columns. The option -o foobar.ps (which is the short version of --output=foobar.ps) specifies the output file. Long options must always be separated by spaces, though short options with no arguments may be grouped.

Note too that the options may be specified before or after the files, it does not matter.

If you send foobar.ps to a printer, you'll discover that the keywords were highlighted, that the strings and comments have a different face. Indeed, a2ps is a pretty-printer: if it knows the (programming) language in which your file is written, it will try to make it look nice and clear on the paper.

But too bad: foo.h is only one virtual page long, and bar.c takes three. Moreover, the comments are essential in those files. And even worse: the system's default printer is out of ink. Thanks god, precious options may help you:

     

     gargantua $ a2ps -4 -Av foo.h bar.c --prologue=gray -P lw
     [foo.h (C): 1 page on 1 sheet]
     [bar.c (C): 3 pages on 1 sheet]
     [Total: 4 pages on 1 sheet] sent to the printer `lw'
     

Here the option -A is a short cut for the option --file-align which specifies how different files should be separated. This option allows several symbolic arguments: virtual, rank, page, sheet (See Sheet Options, for more details). The value virtual means not to start each file on a different virtual pages.

So to fill the page is asked by --file-align=virtual, or -A virtual. But symbolic arguments can be abbreviated when there are no ambiguity, so here, you can just use -Av.

The option -P lw means to print on the printer named lw, and finally, the long option --prologue requires the use one of the alternative printing styles. There are other prologues (See Input Options, option --prologue), and you can even design yours (see Designing PostScript Prologues).

2.2.2 Special Printers

There are three special printers pre-defined.

The first one, void, sends the output to the trash. Its main use is to see how many pages would have been used.

     

     gargantua ~ $ a2ps -P void parsessh.c
     [parsessh.c (C): 33 pages on 17 sheets]
     [Total: 33 pages on 17 sheets] sent to the printer `void'
     

The second, display sends the output to Ghostview, so that you can check the output without printing. Of course if you don't have Ghostview, it won't work... And it is up to you to configure another displaying application (see Your Printers).

The last, file saves the output into a file named after the file you printed (e.g., saves into foo.ps when you print foo.c).

2.2.3 Using Delegations

a2ps can decide that a2ps itself is not the right tool to do what you want. In that case it delegates the task to other programs. What you should retain from this, is, forget that there are delegations. Indeed, the interface with the delegations has been designed so that you don't need to be aware that they exist to use them. Do as usual.

As an example, if you need to print a PostScript file, just hit:

     

     gargantua ~ $ a2ps article.ps -d
     [article.ps (ps, delegated to PsNup): 7 pages on 4 sheets]
     [Total: 8 pages on 4 sheets] sent to the default printer
     

While honoring your defaults settings, a2ps delegates the task to put two virtual pages per physical page to psnup, a powerful filter part of the famous psutils by Angus Duggan.

Suppose now that you want to display a Texinfo file. Then, provided you have all the programs a2ps needs, just hit

     

     gargantua ~ $ a2ps a2ps.texi -P display
     [a2ps.texi (texinfo, delegated to texi2dvi): 75 pages on 38 sheets]
     [Total: 76 pages on 38 sheets] sent to the printer `display'
     

Once the read documentation, you know you want to print just pages 10 to 20, plus the cover. Just hit:

     

     gargantua ~ $ a2ps a2ps.texi --pages=1,10-20 -d
     [a2ps.texi (texinfo, delegated to texi2dvi): 13 pages on 7 sheets]
     [Total: 14 pages on 7 sheets] sent to the default printer
     

A final word: compressed files can be treated in the very same way:

     

     gargantua ~ $ a2ps a2ps.texi.gz -a1,10-20 -d
     [a2ps.texi (compressed, delegated to Gzip-a2ps): 13 pages on 7 sheets]
     [Total: 14 pages on 7 sheets] sent to the default printer
     

You should be aware that:

• the option -Z enables the delegations if they are not (see --list=defaults for your settings);
• the set of delegations is customizable, to know the delegations your a2ps knows, consult a2ps --list=delegations.

2.2.4 Printing Duplex

If you still want to save more paper, and you are amongst the set of happy users of Duplex printers, a2ps will also be able to help you (See Glossary, for definitions). The option to specify Duplex printing is --sides=mode (see PostScript Options).

Here is how to print the documentation in Duplex and send it to the Duplex printer margot:

     

     quasimodo ~ a2ps/doc $ a2ps -s2 -Pmargot a2ps.texi
     [a2ps.texi (texinfo, delegated to texi2dvi): 109 pages on 28 sheets]
     [Total: 110 pages on 28 sheets] sent to the printer `margot'
     

This is also valid for several files.

Actually, you can do something even more tricky: print a small book! This is much more complicated than printing Duplex, because the pages needs to be completely reorganized another way. This is precisely the job of psbook, yet another PsUtil from Angus Duggan. But there is a user option which encapsulates the magic sequence of options: book. Therefore, just run

     

     quasimodo a2ps/doc $ a2ps -=book -Pmargot a2ps.texi
     [a2ps.texi (texinfo, delegated to texi2dvi): 109 pages on 109 sheets]
     [Total: 109 pages on 109 sheets] sent to the printer `margot'
     

and voila` !, a booklet printed on margot!

We strongly discourage you to try with several files at once, because the tools then easily get lost. And, after all, the result will be exactly the same once you collated all the booklets together.

Another limitation is that this does not work if it is not sent to a printer. This kind of weird limitations will be solved in the future.

2.2.5 Checking the Defaults

If a2ps did not have the behavior expected, this may be because of the default settings given by your system administrator. Checking those default values is easy:

     

     ~ % a2ps --list=defaults
                     Configuration status of a2ps 4.12a
                     ==================================
     Sheets:
     -------
       medium          = A4, portrait
       page layout     = 1 x 1, rows first
       borders         = yes
       file alignment  = page
       interior margin = 0
     More stuff deleted here
     Internals:
     ----------
       verbosity level     = 2
       file command        = /usr/bin/file -L
       temporary directory = /tmp
       library path        =
             /home/akim/.a2ps
             /usr/share/a2ps/sheets
             /usr/share/a2ps/ps
             /usr/share/a2ps/encoding
             /usr/share/a2ps/afm
             /usr/share/ogonkify/afm
             /usr/share/a2ps/ppd
             /usr/share/a2ps/fonts
             /usr/share/ogonkify/fonts
             /usr/share/a2ps
     

Remember that the on-line help is always available. Moreover, if your screen is small, you may pipe it into more. Just trust this:

     a2ps --help | more

2.3 Important parameters

Many things are parameterizable in a2ps, but two things are just essential to make sure everything goes right:

The paper

Make sure that the paper a2ps uses is the same as your printer (See Sheet Options, option --medium).

The encoding

Make sure that the encoding a2ps uses is the same as the standard alphabet in your country (See Input Options, option --encoding).

Both values may be checked with a2ps --list=defaults.

2.4 Localizing

a2ps provides some Native Language Support, that is speaking your mother tongue. It uses three special features for non-English languages:

the tongue

i.e., the language used by the interface,

the date

i.e., the format and the words used in the language to specify a date.

To enable these features, properly set your environment variable LANG (see the documentation of your system, for instance man locale, man environ etc.).

The problem with this approach is that a lot more than just messages and time information is affected: especially the way numbers are written changes, what may cause problems with awk and such.

So if you just want messages and time format to be localized, then define:

     set LC_MESSAGES=fr ; export LC_MESSAGES
     set LC_TIME=fr     ; export LC_TIME

2.5 Interfacing with Other Programs

Here are some tips on how to use a2ps with other programs.

• Interfacing With a Mailer: Printing Mails or News
• Netscape: Interfacing with Netscape

2.5.1 Interfacing With a Mailer

When you print from a mailer (or a news reader), your mailer calls a tool, say a2ps on a part of the whole mailbox. This makes it difficult for a2ps to guess that the file is of the type mail. Therefore, for better results, make sure to tell a2ps the files are mails. The user option mail (or longmail for longer inputs) encapsulates most typical tuning users want to print mails (for instance, don't print all the headers).

Most specifically, if your mailer is:

elm

Once you are in elm, hit o to enter in the options edition menu, hit p to edit the printer command, and enter a2ps -=mail %s -d. The option -d means to print on the default printer.

pine

Jan Chrillesen suggests us how to use a2ps with the Pine mail-reader. Add the following to .pinerc (of course you can put it in pine.conf as well):

          # Your printer selection
          printer=a2ps -=mail -d
          
          # Special print command
          personal-print-command=a2ps -=mail -d
     

2.5.2 Netscape

This is actually valid for any program that generates PostScript that you want to post-process with a2ps. Use the following command:

     a2ps

Not too hard, isn't it?

Nevertheless, this setting suppose your world is OK, your file(1) detects correctly PostScript files, and your a2ps is configured to delegate. In case one one these conditions is not met, use:

     a2ps -ZEps

Do not forget to tell Netscape whether your printer supports colors, and the type of paper it uses.

3 Invoking a2ps

Calling a2ps is fairly simple:

     a2ps Options... Files...

If no Files... are given, a2ps prints its standard input. If - appears in the Files..., it designates the standard input too.

• Options: Command line options
• Escapes: Strings ready to use in the headers

3.1 Command line options

To read the options and arguments that you give, a2ps uses GNU getopt, hence:

• the options (short with arguments or long) must be separated by spaces.
• the order between options and files does not matter: a2ps -4m main.c and a2ps main.c -4m are identical.
• the order between options does matter, especially between options that influence the same parameters. For instance a2ps -1 -l132 is not the same as a2ps -l132 -1 (the latter being equivalent to a2ps -1).
• short options may be grouped together: a2ps -4mg main.c -P printer
• when there are no ambiguities, long options can be abbreviated, e.g., --pro will be understood as --prologue,
• -- ends the options. Anything behind -- is considered to be a file: a2ps -- -2 prints the file -2¹.

Here after a boolean is considered as true (i.e. setting the option on), if boolean is yes, or 1; as false if it equals no or 0; and raise an error otherwise. The corresponding short option takes no arguments, but corresponds to a positive answer.

When an argument is presented between square brackets, it means that it is optional. Optional arguments to short option must never be separated from the option.

• Tasks Options: Exclusive options
• Global Options: Settings involving the whole process
• Sheet Options: Specify the layout on the sheet
• Page Options: Specify the virtual pages
• Headings Options: Specify the headers you want
• Input Options: How to process the input files
• Pretty Print Options: Source files support
• Output Options: What should be done of the output
• PostScript Options: PostScript specific options

3.1.1 Tasks Options

Task options specify the task a2ps will perform. It will not print, it executes the task and exits successfully.

3.1.2 Global Options

These options are related to the interface between you and a2ps.

3.1.3 Sheet Options

This options specify the general layout, how the sheet should be used.

3.1.4 Page Options

This options are related to the content of the virtual pages.

Please note that the options -f, -L, -l, -m, and -1 .. -9 all have an influence on the font size. Only the last one will win (i.e., a2ps -L66 -l80 is the same as a2ps -l80).

3.1.5 Headings Options

These are the options through which you may define the information you want to see all around the pages.

All these options support text as an argument, which is composed of plain strings and escapes. See Escapes, for details.

3.1.6 Input Options

3.1.7 Pretty Printing Options

These options are related to the pretty printing features of a2ps.

3.1.8 Output Options

These are the options to specify what you want to do out of what a2ps produces. Only a single destination is possible at a time, i.e., if ever there are several options -o, -P or -d, the last one is honored.

3.1.9 PostScript Options

The following options are related only to variations you want to produce onto a PostScript output.

3.2 Escapes

The escapes are some sequences of characters that will be replaced by their values. They are very much like variables.

• Use of Escapes: Where they are used
• Structure of the Escapes: Their syntax
• Available Escapes: Detailed list

3.2.1 Use of Escapes

They are used in several places in a2ps:

Page markers

Headers, footers, titles and the water mark (see Headings Options), in general to print the name of file, page number etc. On a new sheet a2ps first draws the water mark, then the content of the first page, then the frame of the first page, (ditto with the others), and finally the sheet header and footers. This order must be taken into account for some escapes (e.g., $l., $l^).

Named output

To specify the generic name of the file to produce, or how to access a printer (see Your Printers).

Delegation

To specify the command associated to a delegation (see Your Delegations).

Table of Content

To specify an index/table of content printed at the end of the job.

Variables in PostScript prologue

To allow the user to change some parameters to your prologues (see Designing PostScript Prologues).

3.2.2 General Structure of the Escapes

All format directives can also be given in format

escape width directive

where

escape

In general

%

escapes are related to general information (e.g., the current date, the user's name etc.),

#

escapes are related to the output (e.g., the output file name) or to the options you gave (e.g., the number of virtual pages etc.), or to special constructions (e.g., enumerations of the files, or tests etc.),

$

escapes are related to the current input file (e.g., its name, its current page number etc.),

\

introduces classical escaping, or quoting, sequences (e.g., \n, \f etc.).

width

Specifies the width of the column to which the escape is printed. There are three forms for width

+paddinginteger

the result of the expansion is prefixed by the character padding so that the whole result is as long as integer. For instance $+.10n with a file name $n=foo.c gives .....foo.c.

If no padding is given, (white space) is used.

-paddinginteger

Idem as above, except that completion is done on the left: $+.10n gives foo.c......

integer

which is a short cut for +integer. For example, escape $5P will expand to something like 12.

directive

See Available Escapes.

3.2.3 Available Escapes

Supported escapes are:

\\

character \

\%

character %

\$

character $

\#

character #

#?cond|if_true|if_false|

this may be used for conditional assignment. The separator (presented here as |) may be any character. if_true and if_false may be defined exactly the same way as regular headers, included escapes and the #? construct.

The available tests are:

#?1

#?2

#?3

true if tag 1, 2 or 3 is not empty. See item $t1 for explanation.

#?d

true if Duplex printing is requested (-s2).

#?j

true if bordering is asked (-j).

#?l

true if printing in landscape mode.

#?o

true if only one virtual page per page (i.e., #v is 1).

#?p

a page range has been specified (i.e., #p is not empty).

#?q

true if a2ps is in quiet mode.

#?r

true if major is rows (--major=rows).

#?v

true if printing on the back side of the sheet (verso).

#?V

true if verbosity level includes the tools flag (See Global Options. option --verbosity).

#!key|in|between|

Used for enumerations. The separator (presented here as |) may be any character. in and between are escapes.

The enumerations may be:

#!$

enumeration of the command line options. In this case in in never used, but is replaced by the arguments.

#!f

enumeration of the input files in the other they were given.

#!F

enumeration of the input files in the alphabetical order of their names.

#!s

enumeration of the files appearing in the current sheet.

For instance, the escapes The files printed were: #!f|$n|, |. evaluated with input a2ps NEWS main.c -o foo.ps, gives The files printed were: NEWS, main.c..

As an exception, #! escapes use the width as the maximum number of objects to enumerate if it is positive, e.g., #10!f|$n|, | lists only the ten first file names. If width is negative, then it does not enumerate the -width last objects (e.g., #-1!f|$n|, | lists all the files but the last).

${var}

value of the environment variable var if defined, nothing otherwise.

${var:-word}

if the environment variable var is defined, then its value, otherwise word.

${var:+word}

if the environment variable var is defined, then word, otherwise nothing.

$[num]

value of the numth argument given on the command line. Note that $[0] is the name under which a2ps has been called.

#{key}

expansion of the value of the variable key if defined, nothing otherwise (see Your Variables)

#{key:-word}

if the variable var is defined, then the expansion of its, otherwise word.

#{key:+word}

if the variable var is defined, then word, otherwise nothing.

#.

the extension corresponding to the current output language (e.g. ps).

%*

current time in 24-hour format with seconds hh:mm:ss

$*

file modification time in 24-hour format with seconds hh:mm:ss

$#

the sequence number of the current input file

%#

the total number of files

%a

the localized equivalent for Printed by User Name. User Name is obtained from the variable user.name (see Predefined Variables).

%A

the localized equivalent for Printed by User Name from Host Name. The variables user.name and user.host are used (see Predefined Variables).

%c

trailing component of the current working directory

%C

current time in hh:mm:ss format

$C

file modification time in hh:mm:ss format

%d

current working directory

$d

directory part of the current file (. if the directory part is empty).

%D

current date in yy-mm-dd format

$D

file modification date in yy-mm-dd format

%D{string}

format current date according to string with the strftime(3) function.

$D{string}

format file's last modification date according to string with the strftime(3) function.

%e

current date in localized short format (e.g., Jul 4, 76 in English, or 14 Juil 89 in French).

$e

file modification date in localized short format.

%E

current date in localized long format (e.g., July 4, 76 in English, or Samedi 14 Juillet 89 in French).

$E

file modification date in localized long format.

$f

full file name (with directory and suffix).

\f

character \f (form feed).

#f0

#f9

ten temporary file names. You can do anything you want with them, a2ps removes them at the end of the job. It is useful for the delegations (see Your Delegations) and for the printer commands (see Your Printers).

%F

current date in dd.mm.yyyy format.

$F

file modification date in dd.mm.yyyy format.

#h

medium height in PostScript points

$l^

top most line number of the current page

$l.

current line number. To print the page number and the line interval in the right title, use --right-title="$q:$l^-$l.".

$l#

number of lines in the current file.

%m

the host name up to the first . character

%M

the full host name

\n

the character \n (new line).

%n

shortcut for the value of the variable user.login (see Predefined Variables).

$n

input file name without the directory part.

%N

shortcut for the value of the variable user.name (see Predefined Variables).

$N

input file name without the directory, and without its suffix (e.g., on foo.c, it will produce foo).

#o

name of the output, before substitution (i.e., argument of -P, or of -o).

#O

name of the output, after substitution. If output goes to a file, then the name of the file. If the output is a symbolic printer (see Your Printers), the result of the evaluation. For instance, if the symbolic printer file is defined as > $n.%., then #O returns foo.c.ps when printing foo.c to PostScript. #o would have returned file.

#p

the range of the page to print from this page. For instance if the user asked --pages=1-10,15, and the current page is 8, then #p evaluates to 1-3,8.

$p^

number of the first page of this file appearing on the current sheet. Note that $p., evaluated at the end of sheet, is also the number of the last page of this file appearing on this sheet.

$p-

interval of the page number of the current file appearing on the current sheet. It is the same as $p^-$p., if $p^ and $p. are different, otherwise it is equal to $p..

%p.

current page number

$p.

page number for this file

%p#

total number of pages printed

$p#

number of pages of the current file

$p<

number of the first page of the current file

$p>

number of the last page of the current file

%q

localized equivalent for Page %p.

$q

localized equivalent for Page $p.

%Q

localized equivalent for Page %p./%p#

$Q

localized equivalent for Page $p./$p#

$s<

number of the first sheet of the current file

%s.

current sheet number

$s.

sheet number for the current file

$s>

number of the last sheet of the current file

%s#

total number of sheets

$s#

number of sheets of the current file

%t

current time in 12-hour am/pm format

$t

file modification time in 12-hour am/pm format

$t1

$t2

$t3

Content of tag 1, 2 and 3. Tags are pieces of text a2ps fetches in the files, according to the style. For instance, in mail-folder style, tag 1 is the title of the mail, and tag 2 its author.

%T

current time in 24-hour format hh:mm

$T

file modification time in 24-hour format hh:mm

#v

number of virtual sheets

%V

the version string of a2ps.

#w

medium width in PostScript points

%W

current date in mm/dd/yy format

$W

file modification date in mm/dd/yy format

4 Configuration Files

a2ps reads several files before the command line options. In the order, they are:

1. the system configuration file (usually /usr/local/etc/a2ps.cfg) unless you have defined the environment variable A2PS_CONFIG, in which case a2ps reads the file it points to;
2. the user's home configuration file ($HOME/.a2ps/a2psrc)
3. the local file (./.a2psrc)

Because a2ps needs architecture dependent information (such as the local lpr command) and architecture independent information (such as the type of your printers), users have found useful that a2ps.cfg be dedicated to architecture dependent information. A sub configuration file, a2ps-site.cfg (see Including Configuration Files) is included from a2ps.cfg.

The file a2ps.cfg is updated when you update a2ps, while a2ps-site.cfg is not, to preserve local definitions.

In the configuration files, empty lines and lines starting with # are comments.

The other lines have all the following form:

     Topic: Arguments

where Topic: is a keyword related to what you are customizing, and Arguments the customization. Arguments may be spread on several lines, provided that the last character of a line to continue is a \.

In the following sections, each Topic: is detailed.

• Including Configuration Files: Isolating site specific values
• Your Library Path: Setting the files search path
• Your Default Options: Default state of a2ps
• Your Media: Sheets dimensions
• Your Printers: How to access the printers
• Your Shortcuts: Your very own command line options
• Your PostScript magic number: Handling very old printers
• Your Page Labels: Page names as in Ghostview
• Your Variables: Short cut for long sequences
• Your Delegations: Delegating some files to other filters
• Your Internal Details: Details you might want to tune

4.1 Including Configuration Files

This is especially useful for the site specific configuration file etc/a2ps.cfg: you may tune your printers etc. in a separate file for easy upgrade of a2ps (and hence of its configuration files).

4.2 Your Library Path

To define the default library path, you can use:

Note that for users configuration files, it is better not to set the library path, because the system's configuration has certainly been built to cope with your system's peculiarities. Use AppendLibraryPath: and PrependLibraryPath:.

4.3 Your Default Options

The quoting mechanism is the same as that of a shell. For instance

     Options: --right-title="Page $p" --center-title="Hello World!"
     Options: --title="arg 'Jack said \\\"hi\\\"' has double quotes"

4.4 Your Media

4.5 Your Printers

A general scheme is used, so that whatever the way you should address the printers on your system, the interface is still the same. Actually, the interface is so flexible, that you should understand `named destination' when we write `printer'.

Escapes expansion is performed on destination (see Escapes). Recall that #o is evaluated to the destination name, i.e., the argument given to -P.

For instance

     # My Default Printer is called dominique
     DefaultPrinter: | lp -d dominique
     
     # `a2ps foo.c -P bar' will pipe into `lp -d bar'
     UnknownPrinter: | lp -d #o
     
     # `a2ps -P foo' saves into the file `foo'
     Printer: foo > foo.ps
     Printer: wc | wc
     Printer: lw | lp -d printer-with-a-rather-big-name
     
     # E.g. `a2ps foo.c bar.h -P file' will save into `foo.c.ps'
     Printer: file > $n.#.
     
     # E.g. `a2ps foo.c bar.h -P home' will save into `foo.ps'
     # in user's home
     Printer: home > ${HOME}/$N.#.
     
     # Here we address a printer which is not PostScript
     Printer: deskj | gs -q -sDEVICE=ljet3d -sOutputFile=- - \
              | lpr -P laserwriter -h -l

MS-DOS users, and non-PostScript printer owners should take advantage in getting good configuration of these entries.

4.6 Your Shortcuts

You can define some kind of `Macro Options' which stand for a set of options.

Examples are

     # This emulates a line printer: no features at all
     # call a2ps -=lp to use it
     UserOption: lp -1m --pretty-print=plain -B --borders=no
     
     # When printing mail, I want to use the right style sheet with strong
     # highlight level, and stripping `useless' headers.
     UserOption: mail -Email -g --strip=1

4.7 Your PostScript magic number

a2ps produces full DSC conformant PostScript (see Glossary). Adobe said

Thou shalt start your PostScript DSC conformant files with

          %!PS-Adobe-3.0
     

The bad news is that some printers will reject this header. Then you may change this header without any worry since the PostScript produced by a2ps is also 100% PostScript level 1².

4.8 Your Page Labels

In the PostScript file is dropped information on where sheets begin and end, so that post processing tools know where is the physical page 1, 2 etc. With this information can be also stored a label, i.e., a human readable text (typically the logical page numbers), which is for instance what Ghostview shows as the list of page numbers.

a2ps lets you define what you want in this field.

4.9 Your Variables

There are many places in a2ps where one would like to have uniform way of extending things. It once became clear that variables where needed in a2ps.

• Defining Variables: Syntax and conventions
• Predefined Variables: Builtin variables

4.9.1 Defining Variables

As as example, here is a variable for psnup, which encloses all the option passing one would like. Delegations are then easier to write:

     Variable: psnup psnup -#v -q #?j|-d|| #?r||-c| -w#w -h#h

It is strongly suggested to follow a . (dot) separated hierarchy, starting with:

del

for variables that are related to delegations.

pro

for variables used in prologues (see Designing PostScript Prologues). Please, specify the name of the prologue (e.g., pro.matrix.gray).

ps

for variables related to PostScript matters, such as the page label (which is associated to ps.page_label), the header etc.

pl

for page label formats. See Your Page Labels, the option --page-label in Input Options.

toc

for toc formats. See the option --toc in Input Options.

user

for user related information. See Predefined Variables.

This naming convention has not fully stabilized. We apologize for the inconvenience this might cause to users.

4.9.2 Predefined Variables

There are a few predefined variables. The fact that a2ps builds them at startup changes nothing to their status: they can be modified like any other variable using --define (see Global Options).

In what follows, there are numbers (i) like this, or (ii) this. It means that a2ps first tries the solution (i), if a result is obtained (non empty value), this is the value given to the variable. Otherwise it tries solution (ii), etc. The rationale behind the order is usually from user modifiable values (e.g. environment variables) through system's hard coded values (e.g., calls to getpwuid) and finally arbitrary values.

user.comments

Comments on the user. Computed by (i) the system's database (the part of pw_gecos after the first ,), (ii) not defined.

user.home

The user's home directory. Determined by (i) the environment variable HOME, (ii) the system's database (using getpwuid), (iii) the empty string.

user.host

The user's host name. Assigned from (i) the system (gethostname or uname), (ii) the empty string.

user.login

The user's login (e.g. bgates). Computed by (i) the environment variable LOGNAME, (ii) the environment variable USERNAME, (iii) the system's database (using getpwuid), (iv) the translated string user.

user.name

The user's name (e.g. William Gates). Computed by (i) the system's database (pw_gecos up to the first ,), (ii) capitalized value of the variable user.login unless it was the translated string user, (iii) the translated string Unknown User.

4.10 Your Delegations

There are some files you don't really want a2ps to pretty-print, typically page description files (e.g., PostScript files, roff files, etc.). You can let a2ps delegate the treatment of these files to other applications. The behavior at run time depends upon the option --delegate (see Input Options).

• Defining a Delegation: Syntax of the definitions of the delegations
• Guide Line for Delegations: What should be respected
• Predefined Delegations: Making the best use of these delegations

4.10.1 Defining a Delegation

command should produce the file on its standard output. Of course escapes substitution is performed on command (see Escapes). In particular, command should use the input file $f.

     # In general, people don't want to pretty-print PostScript files.
     # Pass the PostScript files to psnup
     Delegation: PsNup ps:ps \
             psselect #?V||-q| -p#?p|#p|-| $f | \
             psnup -#v -q #?j|-d|| #?r||-c| -w#w -h#h

Advantage should be taken from the variables, to encapsulate the peculiarities of the various programs.

     # Passes the options to psnup.
     # The files (in and out) are to be given
     Variable: psnup psnup -#v #?V||-q| #?j|-d|| #?r||-c| -w#w -h#h
     
     # Passes to psselect for PS page selection
     Variable: psselect psselect #?V||-q| -p#?p|#p|-|
     
     # In general, people don't want to pretty-print PostScript files.
     # Pass the PostScript files to psnup
     Delegation: PsNup ps:ps     #{psselect} $f | #{psnup}

Temporary file names (#f0 to #f9) are available for complex commands.

     # Pass DVI files to dvips.
     # A problem with dvips is that even on failure it dumps its prologue,
     # hence it looks like a success (output is produced).
     # To avoid that, we use an auxiliary file and a conditional call to
     # psnup instead of piping.
     Delegation: dvips dvi:ps    #{dvips} $f -o #f0 && #{psnup} #f0

4.10.2 Guide Line for Delegations

First of all, select carefully the applications you will use for the delegations. If a filter is known to cause problems, try to avoid it in delegations⁴. As a thumb rule, you should check that the PostScript generating applications produce files that start by:

     %!PS-Adobe-3.0

a2ps needs the %%BeginSetup-%%EndSetup section in order to output correctly the page device definitions. It can happen that your filters don't output this section. In that case, you should insert a call to fixps right after the PostScript generation:

     ########## ROFF files
     # Pass the roff files to groff.  Ask grog how groff should be called.
     # Use fixps to ensure there is a %%BeginSetup/%%EndSetup section.
     Delegation: Groff roff:ps	\
        eval `grog -Tps '$f'` | fixps #?V!!-q! | #{d.psselect} | #{d.psnup}

There are some services expected from the delegations. The delegations you may write should honor:

the input file

available via the escape $f. You should be aware that there are people who have great fun having spaces or dollars in their file names, so you probably should always use '$f'. Some other variables are affected. Yes, I know, we need a special mechanism for ' itself. Well, we'll see that later ;-).

the medium

the dimension of the medium selected by the user are available through #w and #h.

the page layout

the number of virtual pages is #v.

the page range

the page range (in a form 1-2,4-6,10- for instance) is available by #p.

the verbosity level

please, do not make your delegations verbose by default. The silent mode should always be requested, unless #?V is set (see the above example with groff).

If ever you need several commands, do not use ; to separate them, since it may prevent detection of failure. Use && instead.

The slogan "the sooner, the better" should be applied here: in the processing chain, it is better to ask a service to the first application that supports it. An example will make it clear: when processing a DVI file, dvips knows better the page numbers than psselect would. So a DVI to PostScript delegation should ask the page selection (#p) to dvips, instead of using psselect later in the chain. An other obvious reason here is plain efficiency (globally, less data is processed).

4.10.3 Predefined Delegations

The purpose of this section is not to document all the predefined delegations, for this you should read the comments in the system configuration file a2ps.cfg. We just want to explain some choices, and give hints on how to make the best use of these delegations.

4.11 Your Internal Details

There are settings that only meant for a2ps that you can tune by yourself.

5 Library Files

To be general and to allow as much customization as possible, a2ps avoids to hard code its knowledge (encodings, PostScript routines, etc.), and tries to split it in various files. Hence it needs a path, i.e., a list of directories, in which it may find the files it needs.

The exact value of this library path is available by a2ps --list=defaults. Typically its value is:

     

     gargantua ~ $ a2ps --list=defaults
     Configuration status of a2ps 4.14
     More stuff deleted here
     Internals:
       verbosity level     = 2
       file command        = /usr/ucb/file -L
       temporary directory =
       library path        =
             /inf/soft/infthes/demaille/.a2ps
             /usr/local/share/a2ps/sheets
             /usr/local/share/a2ps/ps
             /usr/local/share/a2ps/encoding
             /usr/local/share/a2ps/afm
             /usr/local/share/a2ps/printers
             /usr/local/share/a2ps
     

You may change this default path through the configuration files (see Your Library Path).

If you plan to define yourself some files for a2ps, they should be in one of those directories.

• Documentation Format: Special tags to write a documentation
• Map Files: Their general shape and rationale
• Font Files: Using other fonts
• Style Sheet Files: Defining pretty printing rules

5.1 Documentation Format

In various places a documentation can be given. Since some parts of this document and of web pages are extracted from documentations, some tags are needed to provide a better layout. The format is a mixture made out of Texinfo like commands, but built so that quick and easy processing can be made.

These tags are:

code(text)code

Typeset text like a piece of code. This should be used for keys, variables, options etc. For instance the documentation of the bold prologue mentions the bw prologue:

          Documentation
          This style is meant to replace the old option
          code(-b)code of a2ps 4.3.  It is a copy of the
          black and white prologue, but in which all the
          fonts are in Bold.
          EndDocumentation
     

href(link)href(text)href

Specifies a hyper text link displayed as text.

@example

@end example

They must be alone on the line. The text between these tags is displayed in a code-like fonts. This should be used for including a piece of code. For instance, in the documentation of the gnuc style sheet:

          documentation is
           "Declaration of functions are highlighted"
           "emph(only)emph if you start the function name"
           "in the first column, and it is followed by an"
           "opening parenthesis.  In other words, if you"
           "write"
           "@example"
           "int main (void)"
           "@end example"
           "it won't work.  Write:"
           "@example"
           "int"
           "main (void)"
           "@end example"
          end documentation
     

@itemize

@item text

@end itemize

Typeset a list of items. The opening and closing tags must be alone on the line.

5.2 Map Files

Many things are defined through files. There is a general scheme to associate an object to the files to use: map files. They are typically used to:

• resolve aliases. For instance the ISO-8859-1 encoding is also called ISO Latin 1, or Latin 1 for short. The encoding.map file will map these three names to the same Encoding Description File.
• cope with broken files systems. For instance, the-one-you-know-I-don't-need-to-name cannot handle files named Courier-BoldOblique.afm: it is the same as Courier-Bold.afm. The fonts.map file is here to associate a font file name to a font name.

The syntax of these files is:

• any empty line, or any line starting by a # is a comment.
• a line with the format

            ***              path
       

  requests that the file designated by path be included at this point.

• any other line has the format

            key               value
       

  meaning that when looking for key (e.g., name of a font, an encoding etc.), a2ps should use value (e.g., font file name, encoding description file name etc.).

The map files used in a2ps are:

encoding.map

Resolving encodings aliases.

fonts.map

Mapping font names to font file names.

sheets.map

Rules to decide what style sheet to use.

5.3 Font Files

Even when a PostScript printer knows the fonts you want to use, using these fonts requires some description files.

• Fonts Map File: Mapping a font name to a file name
• Fonts Description Files: Needed files to use a Font
• Adding More Font Support: Using even more Fonts

5.3.1 Fonts Map File

See Map Files, for a description of the map files. This file associates the font-key to a font name. For instance:

     Courier                 pcrr
     Courier-Bold            pcrb
     Courier-BoldOblique     pcrbo
     Courier-Oblique         pcrro

associates to font named Courier, the key pcrr. To be recognized, the font name must be exact: courier and COURIER are not admitted.

5.3.2 Fonts Description Files

There are two kinds of data a2ps needs to use a font:

• the AFM file (font-key.afm), which describes the metrics information corresponding to font;
• in the case font is not known from the printer, the PFA or PFB file which is down loaded to the printer. These files are actually the PostScript programs which execution produces the characters to be drawn on the page, in this font.

5.3.3 Adding More Font Support

a2ps can use as many fonts as you want, provided that you teach it the name of the files in which are stored the fonts (see Fonts Map File). To this end, a very primitive but still useful shell script is provided: make_fonts_map.sh.

First, you need to find the directories which store the fonts you want to use, and extend the library path so that a2ps sees those directories. For instance, add:

     AppendLibraryPath: /usr/local/share/ghostscript/fonts

Then run make_fonts_map.sh. It should be located in the afm/ directory of the system's a2ps hierarchy. Typically /usr/local/share/a2ps/afm/make_fonts_map.sh.

This script asks a2ps for the library path, wanders in this path collecting AFM files, and digging information in them.

Once the script has finished, a file fonts.map.new was created. Check its integrity, and if it's correct, either replace the old fonts.map with it, or rename fonts.map.new as fonts.map and place it higher in the the library path (for instance in your ~/.a2ps/ directory).

5.4 Style Sheet Files

The style sheets are defined in various files. See see Pretty Printing for the structure of these files. As for most other features, there is main file, a road map, which defines in which condition a style sheet should be used (see Map Files). This file is sheets.map.

Its format is simple:

     style-key: patterns

or

     include(file)

The patterns need not be on separate lines. There are two kinds of patterns:

/pattern/flags

if the current file name matches pattern, then select style style-key (i.e. file style-key.ssh).

<pattern>flags

if the result of a call to file(1) matches pattern, then select style style-key.

Currently flags can only be i, standing for an insentive match. Please note that the matching is not truly case insensitive: rather, a lower case version of the string is compared to the pattern as is, i.e., the pattern should itself be lower case.

The special style-key binary tells a2ps to consider that the file should not be printed, and will be ignored, unless option --print-anyway is given.

If a style name can't be found, the plain style is used.

The map file is read bottom up, so that the “last” match is honored.

Two things are to retain from this:

1. if the file is presented through stdin, then a2ps will run file(1). However, unless you specify a fake file name with --stdin, pattern matching upon the name is turn off. In general you can expect correct delegations, but almost never pretty printing.
2. if file is wrong on some files, a2ps may use bad style sheets. In this case, do try option --guess, compare it with the output of file, and if the culprit is file, go and complain to your system administrator :-), or fix it by defining your own filename pattern matching rules.

Consider the case of Texinfo files as an example (the language in which this documentation is written). Files are usually named foo.texi, bar.txi, or even baz.texinfo. file(1) is able to recognize Texinfo files:

doc % file a2ps.texi a2ps.texi: Texinfo source text

Therefore the sheets.map would look like:

     # Texinfo files
     texinfo:  /*.txi/  /*.texi/  /*.texinfo/
               <Texinfo source*>

6 Encodings

a2ps is trying to support the various usual encodings that its users use. This chapter presents what an encoding is, how the encodings support is handled within a2ps, and some encodings it supports.

• What is an Encoding: The concept of encoding explained
• Encoding Files: How a2ps handles the encodings

6.1 What is an Encoding

This section is actually taken from the web pages of Alis Technologies inc.

Document encoding is the most important but also the most sensitive and explosive topic in Internet internationalization. It is an essential factor since most of the information distributed over the Internet is in text format. But the history of the Internet is such that the predominant - and in some cases the only possible - encoding is the very limited ASCII, which can represent only a handful of languages, only three of which are used to any great extent: English, Indonesian and Swahili.

All the other languages, spoken by more than 90% of the world's population, must fall back on other character sets. And there is a plethora of them, created over the years to satisfy writing constraints and constantly changing technological limitations. The ISO international character set registry contains only a small fraction; IBM's character registry is over three centimeters thick; Microsoft and Apple each have a bunch of their own, as do other software manufacturers and editors.

The problem is not that there are too few but rather too many choices, at least whenever Internet standards allow them. And the surplus is a real problem; if every Arabic user made his own choice among the three dozen or so codes available for this language, there is little likelihood that his "neighbor" would do the same and that they would thus be able to understand each other. This example is rather extreme, but it does illustrate the importance of standards in the area of internationalization. For a group of users sharing the same language to be able to communicate,

1. the code used in the shared document must always be identified (labeling)
2. they must agree on a small number of codes - only one, if possible (standards);
3. their software must recognize and process all codes (versatility)

Certain character sets stand out either because of their status as an official national or international standard, or simply because of their widespread use.

First off, there is the ISO 8859 standards series that standardize a dozen character sets that are useful for a large number of languages using the Latin, Cyrillic, Arabic, Greek and Hebrew alphabets. These standards have a limited range of application (8 bits per character, a maximum of 190 characters, no combining) but where they suffice (as they do for 10 of the 20 most widely used languages), they should be used on the Internet in preference to other codes. For all other languages, national standards should preferably be chosen or, if none are available, a well-known and widely-used code should be the second choice.

Even when we limit ourselves to the most widely used standards, the overabundance remains considerable, and this significantly complicates life for truly international software developers and users of several languages, especially when such languages can only be represented by a single code. It was to resolve this problem that both Unicode and the ISO 10646 International standard were created. Two standards? Oh no! Their designers soon realized the problem and were able to cooperate to the extent of making the character set repertoires and coding identical.

ISO 10646 (and Unicode) contain over 30,000 characters capable of representing most of the living languages within a single code. All of these characters, except for the Han (Chinese characters also used in Japanese and Korean), have a name. And there is still room to encode the missing languages as soon as enough of the necessary research is done. Unicode can be used to represent several languages, using different alphabets, within the same electronic document.

6.2 Encoding Files

• Encoding Map File: Mapping an encoding name to a file name
• Encoding Description Files: Specifying an encoding
• Some Encodings: Classical or standard encodings

The support of the encodings in a2ps is completely taken out of the code. That is to say, adding, removing or changing anything in its support for an encoding does not require programming, nor even being a programmer.

See What is an Encoding, if you want to know more about this.

6.2.1 Encoding Map File

See Map Files, for a description of the map files.

The meaningful lines of the encoding.map file have the form:

     alias      key
     iso-8859-1 latin1
     latin1     latin1
     l1         latin1

where

alias

specifies any name under which the encoding may be used. It influences the option --encoding, but also the encodings dynamically required, as for instance in the mail style sheet (support for MIME).

When encoding is asked, the lower case version of encoding must be equal to alias.

key

specifies the prefix of the file describing the encoding (key.edf, Encoding Description Files).

6.2.2 Encoding Description Files

The encoding description file describing the encoding key is named key.edf. It is subject to the same rules as any other a2ps file:

• please make the name portable: alpha-numerical, at most 8 characters,
• empty lines and lines starting by # are ignored.

The entries are

Name:

Specifies the full name of the encoding. Please, try to use the official name if there is one.

          Name: ISO-8859-1
     

Documentation/EndDocumentation

Introduces the documentation on the encoding (see Documentation Format). Typical informations expected are the other important names this encoding has, and the languages it covers.

          Documentation
          Also known as ISO Latin 1, or Latin 1.  It is a superset
          of ASCII, and covers most West-European languages.
          EndDocumentation
     

Substitute:

Introduces a font substitution. The most common fonts (e.g., Courier, Times-Roman...) do not support many encodings (for instance it does not support Latin 2). To avoid that Latin 2 users have to replace everywhere calls to Courier, a2ps allows to specify that whenever a font is called in an encoding, then another font should be used.

For instance in iso2.edf one can read:

          # Fonts from Ogonkify offer full support of ISO Latin 2
          Substitute: Courier              Courier-Ogonki
          Substitute: Courier-Bold         Courier-Bold-Ogonki
          Substitute: Courier-BoldOblique  Courier-BoldOblique-Ogonki
          Substitute: Courier-Oblique      Courier-Oblique-Ogonki
     

Default:

Introduces the name of the font that should be used when a font (not substituted as per the previous item) is called but provides to poor a support of the encoding. The Courier equivalent is the best choice.

          Default: Courier-Ogonki
     

Vector:

Introduces the PostScript encoding vector, that is a list of the 256 PostScript names of the characters. Note that only the printable characters are named in PostScript (e.g., bell in ASCII (^G) should not be named). The special name .notdef is to be used when the character is not printable.

Warning. Make sure to use real, official, PostScript names. Using names such as c123 may be the sign you use unusual names. On the other hand PostScript names such as afii8879 are common.

6.2.3 Some Encodings

Most of the following information is a courtesy of Alis Technologies inc. and of Roman Czyborra's page about The ISO 8859 Alphabet Soup. See What is an Encoding, is an instructive presentation of the encodings.

The known encodings are:

7 Pretty Printing

The main feature of a2ps is its pretty-printing capabilities. Two different levels of pretty printing can be reached:

• basic (normal highlight level) in which what you print is what you wrote.
• string (heavy highlight level), in which in general, some keywords are replaced by a Symbol character which best represents them. For instance, in most languages <= and >= will be replaced by the corresponding single character from the font Symbol.

Note that the difference is up to the author of the style sheet.

• Syntactic limits: What can't be done
• Known Style Sheets: Some supported languages
• Type Setting Style Sheets: a2ps as a tiny word processor
• Faces: Encoding the look of pieces of text
• Style sheets semantics: What is to be defined
• Style Sheets Implementation: How they should be defined
• A tutorial on style sheets: Step by step example

7.1 Syntactic limits

a2ps is not a powerful syntactic pretty-printer: it just handles lexical structures, i.e., if in your favorite language

     IF IF == THEN THEN THEN := ELSE ELSE ELSE := IF

is legal, then a2ps is not the tool you need. Indeed a2ps just looks for some keywords, or some sequences.

7.2 Known Style Sheets

7.3 Type Setting Style Sheets

This section presents a few style sheets that define page description languages (compared to most other style sheet meant to pretty print source files).

• Symbol: Access to the glyphs of the Symbol font
• PreScript: Typesetting in an a2ps like syntax
• PreTeX: Typesetting in a LaTeX like syntax
• TeXScript: Typesetting in a mixture of both

7.3.1 Symbol

The style sheet Symbol introduces easy to type keywords to obtain the special characters of the PostScript font Symbol. The keywords are named to provide a LaTeX taste. These keywords are also the names used when designing a style sheet, hence to get the full list, see A Bit of Syntax.

If you want to know the correspondence, it is suggested to print the style sheet file of Symbol:

     a2ps -g symbol.ssh

7.3.2 PreScript

PreScript has been designed in conjunction with a2ps. Since bold sequences, special characters etc. were implemented in a2ps, we thought it would be good to allow direct access to those features: PreScript became an input language for a2ps, where special font treatments are specified in an ssh syntax (see Style Sheets Implementation).

The main advantages for using PreScript are:

• it is fairly simple,
• a2ps is small and easy to install, hence it is available on every UNIX platform.

It can be a good candidate for generation of PostScript output (syntactic pretty-printers, generation of various reports etc.).

• Syntax: Lexical specifications
• PreScript Commands
• PreScript examples

7.3.2.1 Syntax

Every command name begins with a backslash (\). If the command uses an argument, it is given between curly braces with no spaces between the command name and the argument.

The main limit on PreScript is that no command can be used inside another command. For instance the following line will be badly interpreted by a2ps:

     \Keyword{Problems using \keyword{recursive \copyright} calls}

The correct way to write this in PreScript is

     \Keyword{Problems using} \keyword{recursive} \copyright \Keyword{calls}.

Everything from an unquoted % to the end of line is ignored (comments).

7.3.2.2 PreScript Commands

These commands required arguments.

\keyword{text}

\Keyword{text}

Highlight lightly/strongly the given text. Should be used only for a couple of adjacent words.

\comment{text}

\Comment{text}

The text is given a special face. The text may be removed if option --strip is used.

\label{text}

\Label{text}

text should be considered as a definition, or an important point in the structure of the whole text.

\string{text}

Write text with string's face (e.g., in font Times).

\error{text}

Write text with error's face (generally a very different face, so that you see immediately).

\symbol{text}

text is written in the PostScript symbol font. This feature is not compatible with LaTeX. It is recommended, when possible, to use the special keywords denoting symbols, which are compatible with LaTeX (see Symbol).

\header{text}

\footer{text}

Use text as header (footer) for the current page. If several headers or footers are defined on the same page, the last one is taken into account.

\encoding{key}

Change dynamically the current encoding. After this command, the text is printed using the encoding corresponding to key.

7.3.2.3 Examples

PreScript and a2ps can be used for one-the-fly formating. For instance, on the passwd file:

     ypcat passwd |
      awk -F: \
        '{print "\Keyword{" $5 "} (" $1 ") \rightarrow\keyword{" $7 "}"}'\
      | a2ps -Epre -P

7.3.3 PreTeX

The aim of the PreTeX style sheet is to provide something similar to PreScript, but with a more LaTeX like syntax.

• Special characters
• PreTeX Commands
• Differences with LaTeX

7.3.3.1 Special characters

$ is ignored in PreTeX for compatibility with LaTeX, and % introduces a comment. Hence they are the only symbols which have to be quoted by a \. The following characters should also be quoted to produce good LaTeX files, but are accepted by PreScript: _, &, #.

Note that inside a command, like \textbf, the quotation mechanism does not work in PreScript (\textrm{#$%} writes #$%) though LaTeX still requires quotation. Hence whenever special characters or symbols are introduced, they should be at the outer most level.

7.3.3.2 PreTeX Commands

These commands required arguments.

\section{Title}

\subsection{Title}

\subsubsection{Title}.

Used to specify the title of a section, subsection or subsubsection.

\textbf{text}

\textit{text}

\textbi{text}

\textrm{text}

write text in bold, italic, bold-italic, Times. Default font is Courier.

\textsy{text}

text is written in the PostScript symbol font. This feature is not compatible with LaTeX. It is recommended, when possible, to use the special keywords denoting symbols, which are compatible with LaTeX (See the style sheet Symbol).

\header{text}

\footer{text}

Use text as header (footer) for the current page. If several headers or footers are defined on the same page, the last one is taken into account.

\verb+text+

Quote text so that no special sequence will be interpreted. In \verb+quoted string+ + can be any symbol in +, !, |, #, =.

\begin{document}

\end{document}

\begin{itemize}

\end{itemize}

\begin{enumerate}

\end{enumerate}

\begin{description}

\end{description}

These commands are legal in LaTeX but have no sense in PreTeX. Hence there are simply ignored and not printed (if immediately followed by an end-of-line).

7.3.3.3 Differences with LaTeX

The following symbols, inherited from the style sheet Symbol, are not supported by LaTeX:

\Alpha, \apple, \Beta, \carriagereturn, \Chi, \Epsilon, \Eta, \florin, \Iota, \Kappa, \Mu, \Nu, \Omicron, \omicron, \radicalex, \register, \Rho, \suchthat, \Tau, \therefore, \trademark, \varUpsilon, \Zeta.

LaTeX is more demanding about special symbols. Most of them must be in so-called math mode, which means that the command must be inside $ signs. For instance, though

     If \forall x \in E, x \in F then E \subseteq F.

is perfectly legal in PreTeX, it should be written

     If $\forall x \in E, x \in F$ then $E \subseteq F$.

for LaTeX. Since in PreTeX every $ is discarded (unless quoted by a \), the second form is also admitted.

7.3.4 TeXScript

TeXScript is a replacement of the old version of PreScript: it combines both the a2ps-like and the LaTeX-like syntaxes through inheritance of both PreScript and PreTeX.

In addition it provides commands meant to ease processing of file for a2ps by LaTeX.

Everything between %%TeXScript:skip and %%TeXScript:piks will be ignored in TeXScript, so that there can be inserted command definitions for LaTeX exclusively.

The commands \textbi (for bold-italic) and \textsy (for symbol) do not exist in LaTeX. They should be defined in the preamble:

     %%TeXScript:skip
     \newcommand{\textbi}[1]{\textbf{\textit{#1}}}
     \newcommand{\textsy}[1]{#1}
     %%TeXScript:piks

There is no way in TeXScript to get an automatic numbering. There is no equivalent to the LaTeX environment enumerate. But every command beginning by \text is doubled by a command beginning by \magic. a2ps behaves the same way on both families of commands. Hence, if one specifies that arguments of those functions should be ignored in the preamble of the LaTeX document, the numbering is emulated. For instance

     \begin{enumerate}
     \magicbf{1.}\item First line
     \magicbf{2.}\item Second line
     \end{enumerate}

will be treated the same way both in TeXScript and LaTeX.

\header and \footer, are not understood by LaTeX.

7.4 Faces

A face is an attribute given to a piece of text, which specifies how it should look like. Since a2ps is devoted to pretty-printing source files, the faces it uses are related to the syntactic entities that can be encountered in a file.

The faces a2ps uses are:

Plain

This corresponds to the text body.

Keyword

Keyword_strong

These are related to the keywords that may appear in a text.

Comment

Comment_strong

These are related to comments in the text. Remember that comments should be considered as non essential ("Aaaeaaarg" says the programmer); indeed, the user might suppress the comments thanks (?) to the option --strip-level. Hence, never use these faces just because you think they look better on, say, strings.

Label

Label_strong

These are used when a point of extreme importance, or a sectioning point, is met. Typically, functions declarations etc.

String

Used mainly for string and character literals.

Error

Used to underline the presence of an error. For instance in Encapsulated PostScript, some PostScript operators are forbidden: they are underlined as errors.

Actually, there is also the face Symbol, but this one is particular: it is not legal changing its font.

7.5 Style Sheets Semantics

a2ps pretty prints a source file thanks to style sheets, one per language. In the following is described how the style sheets are defined. You may skip this section if you don't care how a2ps does this, and if you don't expect to implement new styles.

• Name and key: Both names of a style sheet
• Comments: Author name, version etc.
• Alphabets: What words are legal
• Case sensitivity: Is BEGIN different of begin
• P-Rules: Pretty Printing Rules
• Sequences: Strings, comments etc.
• Optional entries: Second level of pretty printing

7.5.1 Name and key

Every style sheet has both a key, and a name. The name can be clean and beautiful, with any character you might want. The key is in fact the prefix part of the file name, and is alpha-numerical, lower case, and less than 8 characters long.

Anywhere a2ps needs to recognize a style sheet by a name, it uses the key (in the sheets.map file, with the option -E, etc.).

As an example, C++ is implemented in a file called cxx.ssh, in which the name is declared to be C++.

The rationale is that not every system accepts any character in the file name (e.g., no + in MS-DOS). Moreover, it allows to make symbolic links on the ssh files (e.g., ln -s cxx.ssh c++.ssh let's you use -E c++).

7.5.2 Comments

ssh files can include the name of its author, a version number, a documentation note and a requirement on the version of a2ps. For instance, if a style sheet requires a2ps version 4.9.6, then a2ps version 4.9.5 will reject it.

7.5.3 Alphabets

a2ps needs to know the beginning and the end of a word, especially keywords. Hence it needs two alphabets: the first one specifying by which letters an identifier can begin, and the second one for the rest of the word. If you prefer, a keyword starts with a character belonging to the first alphabet, and a character not pertaining to the second is a separator.

7.5.4 Case sensitivity

If the style is case insensitive, then matching is case insensitive (keywords, operators and sequences).

7.5.5 P-Rules

A P-rule (Pretty printing rule), or rule for short, is a structure which consists of two items:

lhs

left-hand side

its source string, with which the source file is compared;

rhs

right hand side

a list of faced strings which will replace the text matched in the pretty-printed output. A faced string is composed of

• a string, or a reference to a part of the source string (see Back-reference Operator (Regex manual))
• the face to use to print it

Just a short example: (foo, bar, Keyword_strong) as a rule means that every input occurrence of foo will be replaced by bar, written with the Keyword_strong face.

If the destination string is empty, then a2ps will use the source string. This is different from giving the source string as a destination string if the case is different. An example will make it fairly clear.

Let foobar be a case insensitive style sheet including the rules (foo, "", Keyword) and (bar, bar, Keyword). Then, on the input FOO BAR, a2ps will produce FOO bar in Keyword.

a2ps implements two different ways to match a string. The difference comes from that some keywords are sensitive to the delimiters around them (such as unsigned and int in C, which are definitely not the same thing as unsignedint), and others not (in C, != is "different from" both in a != b and a!=b).

The first ones are called keywords in a2ps jargon, and the seconds are operators. Operators are matched anywhere they appear, while keywords need to have separators around them (see Alphabets).

Let us give a more complicated example: that of the Yacc rules. A rule in Yacc is of the form:

     a_rule : part1 part2 ;

Suppose you want to highlight these rules. To recognize them, you will write a regular expression specifying that:

1. it must start at the beginning of the line,
2. then there is string composed of symbols, which is what you want to highlight,
3. and a colon, which can be preceded by blank characters.

The regexp you want is: /^[a-zA-Z0-9_]*[\t ]*:/. But with the rule

     /^[a-zA-Z0-9_]*[\t ]*:/, "", Label_strong

the blanks and the colon are highlighted too. Hence you need to specify some parts in the regexp (see Back-reference Operator (Regex manual)), and use a longer list of destination strings. The correct rule is

     (/^([a-zA-Z0-9_]*)([\t ]*:)/, \1 Label_strong, \2 Plain)

Since it is a bit painful to read, regexps can be spread upon several lines. It is strongly suggested to break them by groups, and to document the group:

     (/^([a-zA-Z0-9_]*)/    # \1. Name of the rule
      /([\t ]*:)/           # \2. Trailing space and colon
      \1 Label_strong, \2 Plain)

7.5.6 Sequences

A sequence is a string between two markers, along with a list of exceptions. A marker is a fixed string. Typical examples are comments, string (with usually " as opening and closing markers, and \\ and \" as exceptions) etc. Three faces are used: one for the initial marker, one for the core of the sequence, and a last one for the final maker.

7.5.7 Optional entries

There are two levels of pretty-printing encoded in the style sheets. By default, a2ps uses the first level, called normal, unless the option -g is specified, in which case, heavy highlighting is invoked, i.e., optional keywords, operators and sequences are considered.

7.6 Style Sheets Implementation

In the previous section (see Style sheets semantics) were explained the various items needed to understand the machinery involved in pretty printing. Here, their implementation, i.e., how to write a style sheet file, is explained. The next section (see A tutorial on style sheets), exposes a step by step simple example.

• A Bit of Syntax: Lexical rules of the ssh language
• Style Sheet Header: Declaration of a style
• Syntax of the Words: Classes of the Characters
• Inheriting: Extending existing style sheets
• Syntax for the P-Rules: Atomic Pretty Printing rules
• Declaring keywords and operators: Special Classes of Identifiers
• Declaring sequences: Bordered Lexical Entities
• Checking a Style Sheet: Ask a2ps to Check the Sheet

7.6.1 A Bit of Syntax

Here are the lexical rules underlying the style sheet language:

• the separators are white space, form feed, new line, and tab.
• # introduces a comment, ended at the end of the line.
• special characters are the separators, plus #, ", ,, (, ), + and /. Any other character is a regular character.
• the list of the structuring keywords is

  alphabet, alphabets, are, case, documentation, end, exceptions, first, in, insensitive, is, keywords, operators, optional, second, sensitive, sequences, style

• the list of the keywords designating faces is

  Comment, Comment_strong, Encoding, Error, Index1, Index2, Index3, Index4, Invisible, Keyword, Keyword_strong, Label, Label_strong, Plain, String, Symbol, Tag1, Tag2, Tag3, Tag4

• the list of keywords designating special sequences is

  C-char, C-string

• the list of keywords representing special characters is

  ---, \Alpha, \Beta, \Chi, \Delta, \Downarrow, \Epsilon, \Eta, \Gamma, \Im, \Iota, \Kappa, \Lambda, \Leftarrow, \Leftrightarrow, \Mu, \Nu, \Omega, \Omicron, \Phi, \Pi, \Psi, \Re, \Rho, \Rightarrow, \Sigma, \Tau, \Theta, \Uparrow, \Upsilon, \Xi, \Zeta, \aleph, \alpha, \angle, \approx, \beta, \bullet, \cap, \carriagereturn, \cdot, \chi, \circ, \clubsuit, \cong, \copyright, \cup, \delta, \diamondsuit, \div, \downarrow, \emptyset, \epsilon, \equiv, \eta, \exists, \florin, \forall, \gamma, \geq, \heartsuit, \in, \infty, \int, \iota, \kappa, \lambda, \langle, \lceil, \ldots, \leftarrow, \leftrightarrow, \leq, \lfloor, \mu, \nabla, \neq, \not, \not\in, \not\subset, \nu, \omega, \omicron, \oplus, \otimes, \partial, \perp, \phi, \pi, \pm, \prime, \prod, \propto, \psi, \radicalex, \rangle, \rceil, \register, \rfloor, \rho, \rightarrow, \sigma, \sim, \spadesuit, \subset, \subseteq, \suchthat, \sum, \supset, \supseteq, \surd, \tau, \theta, \therefore, \times, \trademark, \uparrow, \upsilon, \varUpsilon, \varcopyright, \vardiamondsuit, \varphi, \varpi, \varregister, \varsigma, \vartheta, \vartrademark, \vee, \wedge, \wp, \xi, \zeta

  It is a good idea to print the style sheet symbols.ssh to see them:

            a2ps symbols.ssh
       

• a string starts and finishes with ", and may contain anything. Regular C escaping mechanism is used.
• a regular expression starts and finishes with /, and may contain anything. Regular C escaping mechanism is used. Regexps can be split in several parts, a` la C strings (i.e., /part 1/ /part 2/).
• any sequence of regular characters which is not a keyword, is a string (consider this as a shortcut, avoiding extraneous ").

7.6.2 Style Sheet Header

The definition of the name of the style sheet is:

     style name is
       # body of the style sheet
     end style

The following constructions are optional:

version

To define the version number of the style sheet

          version is version-number
     

written

To define the author(s).

          written by authors
     

Giving your email is useful for bug reports about style sheets.

          written by "Some Body <Some.Body@some.whe.re>"
     

requires

To specify the version of a2ps it requires. a2ps won't accept a file which requires a higher version number than its own.

          requires a2ps a2ps-version-number
     

documentation

To leave extra comments people should read.

          documentation is
             strings
          end documentation
     

strings may be a list of strings, without comas, in which case new lines are automatically inserted between each item. See Documentation Format, for details on the format.

Please, write useful comments, not This style is devoted to C files, since the name is here for that, nor Report errors to mail@me.somewhere, since written by is there for that.

          documentation is
              "Not all the keywords are used, to avoid too much"
              "bolding. Heavy highlighting (code(-g)code), covers"
              "the whole language."
          end documentation
     

7.6.3 Syntax of the Words

There are two things a2ps needs to know: what is symbol consistent, and whether the style is case insensitive.

alphabet

To define two different alphabets, use

          first alphabet is string
          second alphabet is string
     

If both are identical, you may use the shortcut

          alphabets are string
     

The default alphabets are

          first alphabet is
            "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_"
          second alphabet is
          "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_\
          0123456789"
     

Note that it is on purpose that no characters interval are used.

case

          case insensitive        # e.g., C, C++ etc.
          case sensitive          # e.g., Perl, Sather, Java etc.
     

The default is case insensitive.

7.6.4 Inheriting from Other Style Sheets

It is possible to extend an existing style. The syntax is:

     ancestors are
        ancestor_1[, ancestor_2...]
     end ancestors

where ancestor1 etc. are style sheet keys.

For semantics, the rules are the following:

• the ancestors are read in order;
• the definition of the current style is read last;
• it is always the last item read which wins (last defined alphabets, case sensitivity, keywords, operators and sequences).

As an example, both C++ and Objective C style sheets extend the C style sheet:

     style "Objective C" is
     #[...]
     ancestors are
        c
     end ancestors
     #[...]
     end style

To the biggest surprise of the author, mutually dependent style sheets do work!

7.6.5 Syntax for the P-Rules

See P-Rules, for the definition of P-rule.

Because of various short cuts, there are many ways to declare a rule:

     rules     ::= rule_1 , rule_2...
     rule      ::= ( lhs rhs )
                | lhs srhs ;
     lhs       ::= string | regex ;
     rhs       ::= srhs , ...
     srhs      ::= latex-keyword | expansion face
     expansion ::= string | \num | <nothing>;
     face      ::= face-keyword | <nothing>;

The rules are the following:

• If the left-hand side (lhs) is a regular expression, then it is compiled with the following syntax bits:

            #define RE_SYNTAX_A2PS \
              (/* Allow char classes. */					\
                RE_CHAR_CLASSES						\
              /* Be picky. */						\
              | RE_CONTEXT_INVALID_OPS					\
              /* Allow intervals with `{' and `}', forbid invalid ranges. */\
              | RE_INTERVALS | RE_NO_BK_BRACES | RE_NO_EMPTY_RANGES		\
              /* `(' and `)' are the grouping operators. */			\
              | RE_NO_BK_PARENS						\
              /* `|' is the alternation. */					\
              | RE_NO_BK_VBAR)
       

  Basically it means that all of the possible operators are used, and that they are in non-backslashed form. For instance ( and ) stand for the group operator, while \\( stands for the character (. See Regular Expression Syntax (Regex manual), for a detailed description of the regular expressions.

• If no expansion is specified, then the matched string is used. For instance (/fo*/, NULL, Keyword) applied on the source fooooo produces fooooo in Keyword.
• If no face is given, then
  • if the context defines the default face, then this face is used;
  • if no default face is given, PLAIN is used.

7.6.6 Declaring the keywords and the operators

Basically, keywords and operators are lists of rules. The syntax is:

     keywords are
       rules
     end keywords

or

     keywords in face-keyword are
       rules
     end keywords

in which case the default face is set to face-keyword.

As an example:

     keywords in Keyword_strong are
       /foo*/,
       "bar" "BAR" Keyword,
       -> \rightarrow
     end keywords

is valid.

The syntax for the operators is the same, and both constructs can be qualified with an optional flag, in which case they are taken into account in the heavy highlighting mode (see Pretty Print Options).

This is an extract of the C style sheet:

     optional operators are
        -> \rightarrow,
        && \wedge,
        || \vee,
        != \neq,
        == \equiv,
        # We need to protect these, so that <= is not replaced in <<=
        <<=,
        >>=,
        <= \leq,
        >= \geq,
        ! \not
     end operators

Note how <<= and >>= are protected (there are defined to be written as is when met in the source). This is to prevent the two last characters of <<= from being converted into a `less or equal' sign.

The order in which you define the elements of a category (but the sequences) does not matter. But since a2ps sorts them at run time, it may save time if the alphabetical C-order is more or less followed.

You should be aware that when declaring a keyword with a regular expression as lhs, then a2ps automatically makes this expression matching only if there are no character of the first alphabet both just before, and just after the string.

In term of implementation, it means that

     keywords are
       /foo|bar/
     end keywords

is exactly the same as

     operators are
       /\\b(foo|bar)\\b/
     end operators

This can cause problems if you use anchors (e.g. $, or ^) in keywords: the matcher will be broken. In this particular case, define your keywords as operators, taking care of the \\b by yourself.

See Match-word-boundary Operator (Regex manual), for details on \b.

7.6.7 Declaring the sequences

Sequences admit several declarations too:

     sequences      ::= sequences are
                          sequence_1 , sequence_2...
                        end sequences
     sequence       ::= rule in_face close_opt exceptions_opt
                      | C-string
                      | C-char
                      ;
     close_opt      ::= rule
                      | closers are
                          rules
                        end closers
                      | <nothing>
                      ;
     exceptions_opt ::= exceptions are
                          rules
                        end exceptions
                      | <nothing>
                      ;

The rules are:

• The default face is then in_face.
• If no closing rule is given, "\n" (i.e., end-of-line) is used.

As a first example, here is the correct definition for a C string:

     sequences are
      "\"" Plain String "\"" Plain
          exceptions are
             "\\\\", "\\\""
          end exceptions
     end sequences

Since a great deal of languages uses this kind of constructs, you may use C-string to mean exactly this, and C-char for manifest characters defined the C way.

The following example comes from ssh.ssh, the style sheet for style sheet files, in which there are two kinds of pseudo-strings: the strings ("example"), and the regular expressions (/example/). We do not want the content of the pseudo-strings in the face String.

     sequences are
       # The comments
       "#" Comment,
     
       # The name of the style sheet
       "style " Keyword_strong (Label + Index1) " is" Keyword_strong,
     
       # Strings are exactly the C-strings, though we don't want to
       # have them in the "string" face
       "\"" Plain "\""
          exceptions are
             "\\\\", "\\\""
          end exceptions,
     
       # Regexps
       "/" Plain "/"
          exceptions are
             "\\\\", "\\\/"
          end exceptions
     
     end sequences

The order between sequences does matter. For instance in Java, /** introduces strong comments, and /* comments. /** must be declared before /*, or it will be hidden.

There are actually some sequences that could have been implemented as operators with a specific regular expression (that goes up to the closer). Nevertheless be aware of a big difference: regular expression are applied to a single line of the source file, hence, they cannot match on several lines. For instance, the C comments,

     /*
      * a comment
      */

cannot be implemented with operators, though C++ comments can:

     //
     // a comment
     //

7.6.8 Checking a Style Sheet

Once your style sheet is written, you may want to let a2ps perform simple tests on it (e.g., checking there are no rules involving upper case characters in a case insensitive style sheet, etc.). These tests are performed when verbosity includes the style sheets.

you may also want to use the special convention that when a style sheet is required with a suffix, then a2ps will not look at it in its library path, but precisely from when you are.

Suppose for instance you extended the c.ssh style sheet, which is in the current directory, and is said case insensitive. Run

     ubu $ a2ps foo.c -Ec.ssh -P void -v sheets
     # Long output deleted
     Checking coherence of "C" (c.ssh)
     a2ps: c.ssh:`FILE' uses upper case characters
     a2ps: c.ssh:`NULL' uses upper case characters
     "C" (c.ssh) is corrupted.
     ---------- End of Finalization of c.ssh

Here, it is clear that C is not case insensitive.

7.7 A Tutorial on Style Sheets

In this section a simple example of style sheet is entirely covered: that of ChangeLog files.

ChangeLog files are some kind of memory of changes done to files, so that various programmers can understand what happened to the sources. This helps a lot, for instance, in guessing what recent changes may have introduced new bugs.

• Example and syntax: ChangeLog files
• Implementation: Implementation of chlog.ssh
• The Entry in sheets.map: Getting automatic style selection
• More Sophisticated Rules: Complex regular expressions
• Distributed Style Sheets: Additional Constraints

7.7.1 Example and syntax

First of all, here is a sample of a ChangeLog file, taken from the misc/ directory of the original a2ps package:

     Sun Apr 27 14:29:22 1997  Akim Demaille  <demaille@inf.enst.fr>
     
             * base.ps: Merged in color.ps, since now a lot is
               common [added box and underline features].
     
     Fri Apr 25 14:05:20 1997  Akim Demaille  <demaille@inf.enst.fr>
     
             * color.ps: Added box and underline routines.
     
     Mon Mar 17 20:39:11 1997  Akim Demaille  <demaille@gargantua.enst.fr>
     
             * base.ps: Got rid of CourierBack and reencoded_backspace_font.
               Now the C has to handle this by itself.
     
     Sat Mar  1 19:12:22 1997  Akim Demaille  <demaille@gargantua.enst.fr>
     
             * *.enc: they build their own dictionaries, to ease multi
               lingual documents.

The syntax is really simple: A line specifying the author and the date of the changes, then a list of changes, all of them starting with an star followed by the name of the files concerned, then optionally between parentheses the functions affected, and then some comments.

7.7.2 Implementation

Quite naturally the style will be called ChangeLog, hence:

     style ChangeLog is
     written by "Akim Demaille <demaille@inf.enst.fr>"
     version is 1.0
     requires a2ps 4.9.5
     
     documentation is
        "This is a tutorial style sheet.\n"
     end documentation
       ...
     end style

A first interesting and easy entry is that of function names, between ( and ):

     sequences are
       "(" Plain Label ")" Plain
     end sequences

A small problem that may occur is that there can be several functions mentioned separated by commas, that we don't want to highlight this way. Commas, here, are exceptions. Since regular expressions are not yet implemented in a2ps, there is a simple but stupid way to avoid that white spaces are all considered as part of a function name, namely defining two exceptions: one which captures a single comma, and a second, capturing a comma and its trailing space.

For the file names, the problem is a bit more delicate, since they may end with :, or when starts the list of functions. Then, we define two sequences, each one with one of the possible closers, the exceptions being attached to the first one:

     sequences are
       "* " Plain Label_strong ":" Plain
          exceptions are
             ", " Plain, "," Plain
          end exceptions,
       "* " Plain Label_strong " " Plain
     end sequences

Finally, let us say that some words have a higher importance in the core of text: those about removing or adding something.

     keywords in Keyword_strong are
       add, added, remove, removed
     end keywords

Since they may appear in lower or upper, of mixed case, the style will be defined as case insensitive.

Finally, we end up with this style sheet file, in which an optional highlighting of the mail address of the author is done. Saving the file is last step. But do not forget that a style sheet has both a name as nice as you may want (such as Common Lisp), and a key on which there are strict rules: the prefix must be alpha-numerical, lower case, with no more than 8 characters. Let's chose chlog.ssh.

     # This is a tutorial on a2ps' style sheets
     style ChangeLog is
     written by "Akim Demaille <demaille@inf.enst.fr>"
     version is 1.0
     requires a2ps 4.9.5
     
     documentation is
        "Second level of high lighting covers emails."
     end documentation
     
     sequences are
       "(" Plain Label ")" Plain
          exceptions are
             ", " Plain, "," Plain
          end exceptions,
       "* " Plain Label_strong ":" Plain
          exceptions are
             ", " Plain, "," Plain
          end exceptions,
       "* " Plain Label_strong " " Plain
     end sequences
     
     keywords in Keyword_strong are
       add, added, remove, removed
     end keywords
     
     optional sequences are
        < Plain Keyword > Plain
     end sequences
     end style

As a last step, you may which to let a2ps check your style sheet, both its syntax, and common errors:

     ubu $ a2ps -vsheet -E/tmp/chlog.ssh ChangeLog -P void
     Long output deleted
     Checking coherence of "ChangeLog" (/tmp/chlog.ssh)
     "ChangeLog" (/tmp/chlog.ssh) is sane.
     ---------- End of Finalization of /tmp/chlog.ssh

It's all set, your style sheet is ready!

7.7.3 The Entry in sheets.map

The last touch is to include the pattern rules about ChangeLog files (which could appear as ChangeLog.old etc.) in sheets.map:

     # ChangeLog files
     chlog:  /ChangeLog*/

This won't work... Well, not always. Not for instance if you print misc/ChangeLog. This is not a bug, but truly a feature, since sometimes one gets more information about the type of a file from its path, than from the file name.

Here, to match the preceding path that may appear, just use *:

     # ChangeLog files
     chlog:  /*ChangeLog*/

If you want to be more specific (FooChangeLog should not match), use:

     # ChangeLog files
     chlog:  /ChangeLog*/ /*\/ChangeLog*/

7.7.4 More Sophisticated Rules

The example we have presented until now uses only basic features, and does not take advantage of the regexp. In this section we should how to write more evolved pretty printing rules.

The target will be the lines like:

     Sun Apr 27 14:29:22 1997  Akim Demaille  <demaille@inf.enst.fr>
     
     Fri Apr 25 14:05:20 1997  Akim Demaille  <demaille@inf.enst.fr>

There are three fields: the date, the name, the mail. These lines all start at the beginning of line. The last field is the easier to recognize: is starts with a <, and finishes with a >. Its rule is then /<[^>]+>/. It is now easier to specify the second: it is composed only of words, at least one, separated by blanks, and is followed by the mail: /[[:alpha:]]+([ \t]+[[:alpha:]]+)*/. To concatenate the two, we introduce optional blanks, and we put each one into a pair of (-) to make each one a recognizable part:

     ([[:alpha:]]+([ \t]+[[:alpha:]]+)*)
     (.+)
     (<[^>]+>)

Now the first part is rather easy: it starts at the beginning of the line, finishes with a digit. Once again, it is separated from the following field by blanks. Split by groups (see Grouping Operators (Regex manual)), we have:

     ^
     ([^\t ].*[0-9])
     ([ \t]+)
     ([[:alpha:]]+([ \t]+[[:alpha:]]+)*)
     (.+)
     (<[^>]+>)

Now the destination is composed of back references to those groups, together with a face:

     # We want to highlight the date and the maintainer name
     optional operators are
       (/^([^\t ].*[0-9])/                        # \1. The date
        /([ \t]+)/                                # \2. Spaces
        /([[:alpha:]]+([ \t]+[[:alpha:]]+)*)/     # \3. Name
        /(.+)/                                    # \5. space and <
        /(<[^>]+)>/                               # \6. email
        \1 Keyword, \2 Plain, \3 Keyword_strong,
        \5 Plain, \6 Keyword, > Plain)
     end operators

Notice the way regexps are split, to ease reading.

7.7.5 Guide Line for Distributed Style Sheets

This section is meant for people who wish to contribute style sheets. There is a couple of additional constraints, explained here.

The Copyright

Please, do put a copyright in your file, the same as all other distributed files have: it should include your name, but also the three paragraphs stating the sheet is covered by the GPL. I won't distribute files without these paragraphs.

The Version

Do put a version number, so that people can track evolutions.

The Requirements

Make sure to include a requirement on the needed version of a2ps. If you don't know what to put, just put the version of the a2ps you run.

The Documentation

The documentation string is mandatory. Unless the language your style sheet covers is widely known, please document a bit what the style sheet is meant for. If there were choices you made, if there are special behaviors, document them.

The sheets.map Entries

Put in a comment on the sheets.map lines that correspond to your style sheet.

A Test File

It is better to give a test file, as small as possible, that contains the most specific and/or most difficult contructs that your style sheet supports. I need to be able to distribute this file, therefore, do not put anything that is copyrighted.

Finally, make sure your style sheet behaves well! (see Checking a Style Sheet)

8 PostScript

This chapter is devoted to the information which is only relevant to PostScript.

• Good and Bad PostScript: How to lose, how to win
• Page Device Options: Accessing some printers' features
• Statusdict Options: Some other features
• Colors in PostScript: Specifying a color or a gray
• a2ps PostScript Files: Convention for PostScript library files
• Designing PostScript Prologues: Make it look like what you want

8.1 Foreword: Good and Bad PostScript

To read this section, the reader must understand what DSC are (see Glossary).

Why are there good PostScript files, easy to post-process, and bad files that none of my tools seem to understand? They print fine though!

Once you understood that PostScript is not a page description format (like PDF is), you'll have understood most of the problem. Let's imagine for a second that you are a word processor.

The user asks you to print his/her 100 page document in PostScript. Up to page 50, there are few different fonts used. Then, on pages 51 to 80, there are now many different heavy fonts.

When/where will you download the fonts?

The most typical choice, sometimes called Optimize for Speed, is, once you arrived to page 51, to download those fonts once for the rest of the document. The global processing chain will have worked quite quickly: little effort from the software, same from the printer; better yet: you can start sending the file to the printer even before it is finished! The problem is that this is not DSC conformant, and it is easy to understand why: if somebody wants to print only the page 60, then s/he will lack the three fonts which were defined in page 51... This document is not page independent.

Another choice is to download the three fonts in each page ranging from 51 to 80, that is the PostScript file contains 30 times the definition of each font. It is easy for the application to do that, but the file is getting real big, and the printer will have to interpret 30 times the same definitions of fonts. But it is DSC conformant! And you can still send the file while you make it.

Now you understand why

Non DSC conformant files are not necessarily badly designed files from broken applications.

They are files meant to be sent directly to the printer (they are still perfect PostScript files after all!), they are not meant to be post-processed. And the example clearly shows why they are right.

There is a third possibility, sometimes called Optimize for Portability: downloading the three fonts in the prologue of the document, i.e., the section before the first page where are given all the common definitions of the whole file. This is a bit more complicated to implement (the prologue, which is issued first though, grows at the same time as you process the file), and cannot be sent concurrently with the processing (you have to process the whole file to design the prologue). This file is small (the fonts are downloaded once only), and DSC conformant. Well, there are problems, of course... You need to wait before sending the output, it can be costly for the computer (which cannot transfer as it produces), and for the printer (you've burnt quite a lot of RAM right since the beginning just to hold fonts that won't be used before page 51... This can be a real problem for small printers).

This is what a2ps does.

If should be clear that documents optimized for speed should never escape the way between the computer and the printer: no post-processing is possible.

What you should remember is that some applications offer the possibility to tune the PostScript output, and they can be praised for that. Unfortunately, when these very same applications don't automatically switch to “Optimize for Portability” when you save the PostScript file, and they can be criticized for that.

So please, think of the people after you: if you create a PostScript file meant to be exchanged, read, printed, etc; by other people: give sane DSC conformant, optimized for portability files.

8.2 Page Device Options

Page device is a PostScript level 2 feature that offers an uniform interface to control the printer's output device. a2ps protects all page device options inside an if block so they have no effect in level 1 interpreters. Although all level 2 interpreters support page device, they do not have to support all page device options. For example some printers can print in duplex mode and some can not. Refer to the documentation of your printer for supported options.

Here are some usable page device options which can be selected with the -S option (--setpagedevice). For a complete listing, see PostScript Language Reference Manual (section 4.11 Device Setup in the second edition, or section 6, Device Control in the third edition).

Collate boolean

how output is organized when printing multiple copies

Duplex boolean

duplex (two side) printing

ManualFeed boolean

manual feed paper tray

OutputFaceUp boolean

print output `face up' or `face down'

Tumble boolean

how opposite sides are positioned in duplex printing

8.3 Statusdict Options

The statusdict is a special storage entity in PostScript (called a dictionary), in which some variables and operators determine the behavior of the printer. This is an historic horror that existed before page device definitions were defined. They are even more printer dependent, and are provided only for the people who don't have a level printer. In any case, refer to the documentation of your printer for supported options.

Here are some statusdict definitions in which you might be interested:

manualfeed boolean

Variable which determine that the manual fed paper tray will be used. Use is --statusdict=manualfeed::true.

setmanualfeed boolean

Idem as the previous point, but use is --statusdict=setmanualfeed:true.

setduplexmode boolean

If boolean, then print Duplex. Use if --statusdict=setduplexmode:true.

8.4 Colors in PostScript

Nevertheless, here are some tips on how to design your PostScript styles. It is strongly recommended to use gray.pro or color.pro as a template.

There are two PostScript instructions you might want to use in your new PostScript prologue:

setgray

this instruction must be preceded by a number between 0 (black) and 1 (white). It defines the gray level used.

setrgbcolor

this instruction must be preceded by three numbers between 0 (0 %) and 1 (100%). Those three numbers are related to red, green and blue proportions used to designate a color.

a2ps uses two higher level procedures, BG and FG, but both use an argument as in setrgbcolor. So if you wanted a gray shade, just give three times the same ratio.

8.5 a2ps PostScript Files

a2ps uses several types of PostScript files. Some are standards, such as font files, and others are meant for a2ps only.

All a2ps files have two parts, one being the comments, and the other being the content, separated by the following line:

     % code follows this line

8.6 Designing PostScript Prologues

It is pretty known that satisfying the various human tastes is an NEXPTIME-hard problem, so a2ps offers ways to customize its output through the prologue files. But since the authors feel a little small against NEXPTIME, they agreed on the fact that you are the one who will design the look you like.

Hence in this section, you will find what you need to know to be able to customize a2ps output.

Basically, a2ps uses faces which are associated to their "meaning" in the text. a2ps let's you change the way the faces look.

• Definition of the faces: What goes in a characters style
• Prologue File Format: Including documentation
• A prologue example: A step by step example

8.6.1 Definition of the faces

There are three things that define a face:

Its font

You should never call the font by yourself, because sometimes a2ps may decide that another font would be better. This is what happens for instance if a font does not support the encoding you use.

Hence, never set the font by yourself, but ask a2ps to do it. This is done through a line:

          %Face: face real-font-name size
     

This line tells a2ps that the font of face is real-font-name. It will replace this line by the correct PostScript line to call the needed font, and will do everything needed to set up the font.

The size of the text body is bfs.

Its background color

There are two cases:

1. You want a background color, then give the RGB (see Colors in PostScript) ratio and true to BG:

                  0.8 0.8 0 true BG
             

2. You don't want a background color, then call BG with false:

                  false BG
             

Its foreground color

As BG, call FG with an RGB ratio:

          0 0.5 0 FG
     

Its underlining

UL requires a boolean argument, depending whether you want or not the current face to be underlined.

          true UL
     

Its boxing

Requiring a boolean, BX let's a face have a box drawn around.

8.6.2 Prologue File Format

Prologue files for a2ps must have pro as suffix. Documentation (reported with --list-prologues) can be included in the comment part:

     Documentation
     This prologue is the same as the prologue code(pb)code, but using
     the bold version of the fonts.
     EndDocumentation
     % code follows this line

See Documentation Format, for more on the format.

8.6.3 A step by step example

We strongly suggest our readers not to start from scratch, but to copy one of the available styles (see the result of a2ps --list=prologues), to drop it in one of a2ps directories (say $HOME/.a2ps, and to patch it until you like it.

Here, we will start from color.pro, trying to give it a funky look.

Say you want the keywords to be in Helvetica, drawn in a flashy pink on a light green. And strong keywords, in Times Bold Italic in brown on a soft Hawaiian sea green (you are definitely a fine art amateur).

Then you need to look for k and K:

     /k {
       false BG
       0 0 0.9 FG
     %Face: Keyword Courier bfs
       Show
     } bind def
     
     /K {
       false BG
       0 0 0.8 FG
     %Face: Keyword_strong Courier-Bold bfs
       Show
     } bind def

and turn it into:

     /k {
       0.2 1 0.2 true BG
       1 0.2 1 FG
     %Face: Keyword Helvetica bfs
       Show
     } bind def
     
     /K {
       0.4 0.2 0 true BG
       0.5 1 1 FG
     %Face: Keyword_strong Times-BoldItalic bfs
       Show
     } bind def

Waouh! It looks great!

A bit trickier: let change the way the line numbers are printed.

First, let's look for the font definition:

     %%BeginSetup
     % The font for line numbering
     /f# /Helvetica findfont bfs .6 mul scalefont def
     %%EndSetup

Let it be in Times, twice bigger than the body font.

     %%BeginSetup
     % The font for line numbering
     /f# /Times-Roman findfont bfs 2 mul scalefont def
     %%EndSetup

How about its foreground color?

     % Function print line number (<string> # -)
     /# {
       gsave
         sx cw mul 2 div neg 0 rmoveto
         f# setfont
         0.8 0.1 0.1 FG
         c-show
       grestore
     } bind def

Let it be blue. Now you know the process: just put 0 0 1 as FG arguments.

9 Contributions

This chapter documents the various shell scripts or other tools that are distributed with the a2ps package, but are not a2ps itself. The reader should also look at the documentation of Ogonkify (see Overview (Ogonkify manual)), written by Juliusz Chroboczek.

• card: Printing Reference Cards
• fixps: Fixing Some Ill Designed PostScript Files
• fixnt: Fixing Microsoft NT PostScript Files
• pdiff: Produce Pretty Comparison of Files
• psmandup: Printing Duplex on Simplex Printers
• psset: Inserting calls to setpagedevice

9.1 card

Many users of a2ps have asked for a reference card, presenting a summary of the options. In fact, something closely related to the output of a2ps --help.

The first version of this reference card was a PreScript file (see PreScript) to be printed by a2ps. Very soon a much better scheme was found: using a style sheet to pretty print directly the output of a2ps --help! A first advantage is then that the reference cards can be printed in the tongue you choose.

A second was that this treatment could be applied to any application supporting a --help-like option.

• Invoking card: Command Line Interface
• Caution when Using card: card runs commands

9.1.1 Invoking card

     card [options] applications [-- a2ps-options]

card is a shell script which tries to guess how to get your applications' help message (typically by the options --help or -h), and pretty prints it thanks to a2ps (or the content of the environment variable A2PS if it is set). a2ps-options are passed to a2ps.

Supported options are:

It is possible to give options to a2ps (see Options) by specifying them after --. For instance

     card gmake gtar --command="cc -flags" -- -Pdisplay

builds the reference card of GNU make, GNU tar (automatic detection of --help support), and cc thanks to -flags.

9.1.2 Caution when Using card

Remember that card runs the programs you give it, and the commands you supplied. Hence if there is a silly programs that has a weird behavior given the option -h etc., beware of the result.

It is even clearer using --command: avoid running card --command="rm -rf *", because the result will be exactly what you think it will be!

9.2 fixps

The shell script fixps tries its best to fix common problems in PostScript files that may prevent post processing. It makes heavy use of the psutils. It is a good idea to use fixps in the PostScript delegations.

It first tries to make simple fixes, but some really broken files may require a much deeper treatment. If fixps feels the need for such a major surgery act, it may give up local changes and ask Ghostscript for a global rewriting.

• Invoking fixps: Command Line Interface

9.2.1 Invoking fixps

     fixps [options] [file]

sanitize the PostScript file (or of the standard input if no file is given, or if file is -).

Supported options are:

9.3 fixnt

fixnt (see its http://www.itsm.uni-stuttgart.de/~bauer/fixnt.html, home page) is maintained by Holger Bauer and Michael Rath. It is meant to fix the problems of the PostScript files generated by the Microsoft PostScript driver under Windows NT (3.5 and 4.0).

fixps is aware of the cases where fixnt should be used, hence you should not worry of when to use fixnt.

• Invoking fixnt: Command Line Interface

9.3.1 Invoking fixnt

     fixnt < file.ps

sanitize the PostScript file file.ps and produce the result on the standard output.

9.4 pdiff

The shell script pdiff aims to pretty print diffs between files. It basically uses GNU diff (see Overview (Comparing and Merging Files)) or GNU wdiff (see The word difference finder (GNU wdiff)) to extract the diff, then calls a2ps with the correct settings to get a nice, printed contextual diff.

• Invoking pdiff: Command Line Interface

9.4.1 Invoking pdiff

     pdiff [options] file-1 file-2 [-- a2ps-options]

make a pretty comparison between file-1 and file-2. a2ps-options are passed to a2ps.

Supported options are:

It is possible to give options to a2ps (see Options) by specifying them after --. For instance

     pdiff COPYING COPYING.LIB -- -1 -P display

Compares the files COPYING and COPYING.LIB, and prints it on the printer display (usually Ghostview or gv).

9.5 psmandup

I personally hate to print documents of hundreds of pages on a single sided printer. Too bad, here there are no Duplex printers. The idea is then simply first to print the odd pages, then the even in reversed order. To make sure one flips the page in the meanwhile, the second half should be printed from the manual feed tray.

Make a shell script that automates this, and you get psmandup.

• Invoking psmandup: Command Line Interface

9.5.1 Invoking psmandup

     psmandup [options] [file]

produce a manual duplex version of the PostScript file (or of the standard input if no file is given, or if file is -). Once the first half is printed, put the sheet stack in the manual feed tray for the second half⁵.

Be aware that there is a time out for manually fed jobs, usually short, hence do not miss the moment when the printer asks for the stack. If ever you missed that moment, see option --back to recover the second half.

Supported options are:

psmandup assumes the printer is Level 2, and supports manual feeding. The file should be reasonably sane, otherwise psmandup fails miserably.

Typical use is

     psmandup file.ps | lp

or can be put into a2ps' printer commands (see Your Printers).

9.6 psset

The shell script psset inserts calls to setpagedevice in a PostScript file. This is useful for instance to add Tumble or Manual feed request. Actually, psmandup uses psset.

You should know nevertheless that a2ps is able to make the calls to setpagedevice by itself, i.e., you can run a2ps -SManualFeed foo to print foo onto the manually fed tray, or run a2ps -s2 foo to print Duplex. There are no need of psset from a2ps.

• Invoking psset: Command Line Interface

9.6.1 Invoking psset

     psset [options] [file]

produce a version of the PostScript file (or of the standard input if no file is given, or if file is -) that makes protected calls to the PostScript operator setpagedevice. Typical use is making file print duplex, or on the manual tray etc.

The call is protected so that the resulting file is safe, i.e., will still be portable, even with requests such as -Sfoo:bar.

It is safe to run psset with no feature requests. Depending upon the option --no-fix, it is either equivalent to doing nothing, or to running fixps (see fixps).

Supported options are:

10 Frequently asked questions

Please, before sending us mail, make sure the problem you have is not known, and explained. Moreover, avoid using the mailing list for asking question about the options, etc. It has been built for announces and suggestions, not to contact the authors.

• Why Does ...?: Questions on Error
• How Can I ...?: a2ps' How-To
• Please tell me...: Existential Questions on a2ps

10.1 Why Does...?

Error related questions.

• It Prints Nothing: The printer issues nothing
• It Prints in Simplex: While I asked for Duplex
• It Prints in Duplex: While I asked for Simplex
• It Does Not Fit on the Paper: Some parts are missing
• It Prints Junk: Random characters
• It Says my File is Binary: And refuses to print it
• It Refuses to Change the Font Size

10.1.1 Why Does it Print Nothing?

a2ps works OK, but the printer prints nothing.

There are two ways that printing can fail: silently, or with a diagnostic.

First, check that the printer received what you sent. a2ps may correctly do its job, but have the printer queue fail to deliver the job. In case of doubt, please check that the printer's leds blink (or whatever is its way to show that something is being processed).

If the printer does receive the job, but prints nothing at all, check that you did not give exotic options to an old printer (typically, avoid printing on two sides on a printer that does not support it). Avoid using -S, --setpagedevice (see Page Device Options) and --statusdict (see Statusdict Options).

If the trouble persists, please try again but with the option --debug (a PostScript error handler is downloaded), and then send us:

1. the input file that gives problems
2. the output file created by a2ps with the option --debug
3. the error message that was printed.

10.1.2 Why Does it Print in Simplex?

Though I ask a2ps to print Duplex via --sides, the job is printed Simplex.

If your printer is too old, then a2ps will not be able to send it the code it needs when -s2 is specified. This is because your printer uses an old and not standardized interface for special features.

So you need to

1. specify that you want Duplex mode: -s2,
2. remove by hand the standardized call to the Duplex feature: -SDuplex,
3. add the non standard call to Duplex. Try --statusdict=setduplexmode:true.

Since this is painful to hit, a User Option (see Your Shortcuts) should help.

10.1.3 Why Does it Print in Duplex?

Though I ask a2ps to print Simplex via --sides, the job is printed Duplex.

Actually when you require Simplex, a2ps issues nothing, for portability reasons. Hence, if your printer is defaulted to Duplex, the job will be Duplexed. So you have to force a2ps to issue the Simplex request with -SDuplex:false. The user options -=s1 and -=simplex have names easier to remember.

In the next version of a2ps this kind of portability problems will be fixed in a user friendly way.

10.1.4 Why Does it Not Fit on the Paper?

When I print text files with a2ps, it prints beyond the frame of the paper.

You are most probably printing with a bad medium, for instance using A4 paper within a2ps, while your printer uses Letter paper. Some jet printers have a small printable area, and a2ps may not expect it. In both case, read Sheet Options, option --medium for more.

10.1.5 Why Does it Print Junk?

What I get on the printer is long and incomprehensible. It does not seem to correspond to what I wanted to print.

You are probably printing a PostScript file or equivalent. Try to print with -Z: a2ps will try to do his best to find what is the program that can help you (see Your Delegations). In case of doubt, don't hesitate to save into a file, and check the content with Ghostview, or equivalent:

     

     $ a2ps my_weird_file -Z -o mwf.ps
     $ gv mwf.ps
     

If your a2ps is correctly installed, you can use the display fake-printer:

     

     $ a2ps my_weird_file -Z -P display
     

If it is incorrect, ask for help around you.

10.1.6 Why Does it Say my File is Binary?

a2ps complains that my file is binary though it is not.

There are several reasons that can cause a2ps to consider a file is binary:

• there are many non printable characters in the file. Then you need to use the option --print-anyway.
• the file is sane, composed of printable characters. Then it is very likely that file(1) said the type of the file is data, in which case a2ps prefers not to print the file. Then you can either:
  • specify the type of the file, for instance -Eplain;
  • specify to print in any case, --print-anyway;
  • remove the annoying rule from the system's sheets.map:

                   binary: <data*>
              

  • insert in your own ~/.a2ps/sheets.map a rule that overrides that of the system's sheets.map:

                   # Load the system's sheets.map
                   include(/usr/local/share/a2ps/sheets/sheets.map)
                   
                   # Override the rule for files with type `data' according to file(1)
                   plain: <data*>
              

    But this is not very good, since then this rule is always the first tested, which means that any file with type data according to file(1) will be printed in plain style, even if the file is called foo.c.

  • if your files can be recognized, insert a new rule in a sheets.map, such as

                   # file(1) says it's data, but it's pure text
                   plain:   /*.txx/
              

10.1.7 Why Does it Refuse to Change the Font Size

a2ps does not seem to honor --font-size (or --lines-per-page, or --chars-per-line).

This is probably because you used -1..-9 after the --font-size. This is wrong, because the options -1..-9 set the font size (so that there are 80 characters per lines), and many other things (See Page Options, option --font-size).

Hence a2ps --font-size=12km -4 is exactly the same thing as a2ps -4, but is different from a2ps -4 --font-size=12km. Note that the `pure' options (no side-effects) to specify the number of virtual pages are --columns and --rows.

10.2 How Can I ...?

A mini how-to on a2ps.

• Leave Room for Binding: Specifying Margins
• Print stdin: Using a2ps in a pipe chain
• Change the Fonts: Tired of Courier?
• The Old Option -b?: Printing in Bold
• Pass Options to lpr: Disable the banner
• Non PostScript Printers: Using GhostScript
• Man Pages with Underlines: Now it Prints With Italics

10.2.1 How Can I Leave Room for Binding?

The option --margin[=size] is meant for this. See Sheet Options.

10.2.2 How Can I Print stdin?

a2ps prints the standard input if you give no file name, or if you gave - as file name. Automatic style selection is of course much weaker: without the file name, a2ps can only get file(1)'s opinion (see Style Sheet Files). In general it means most delegations are safe, but there will probably be no pretty-printing.

You can supply a name to the standard input (--stdin=name) with which it could guess the language.

10.2.3 How Can I Change the Fonts?

See Designing PostScript Prologues, for details. Make sure that all the information a2ps needs is available (see Font Files).

10.2.4 How Can I Simulate the Old Option -b?

By the past, a2ps had an option -b with which the fonts were bold. Since now the fonts are defined by prologues (see Designing PostScript Prologues) this option no longer makes sense. A replacement prologue is provided: bold. To use it, give the option --prologue=bold.

10.2.5 How Can I Pass Options to lpr

How can I tell a2ps to ask lpr no to print the banner?

How can I pass specific options to lp?

If your Printer: fields in the configuration files were properly filled (see Your Printers), you can use the variable lp.options to pass options to lpr (or lp, depending on your environment):

     a2ps -Dlp.options="-h -s" -P printer

You can also define lp.options once for all, See Defining Variables.

Finally, you can use Printer: several times to reach a printer with different lpr options.

10.2.6 How Can I Print on Non PostScript Printers?

I use a2ps at work and wish to use it at home, but my printer is not PostScript. How can I do?

Ghostscript might be the tool you need (see Glossary). It support conversion to many different non PostScript printers.

Here are some tips on how to use a non PostScript printer. If somebody feels like writing a more precise documentation, she really is welcome.

Please refer to the Ghostscript documentation for a precise description of the tuning you need.

Basically, the first step you need is to achieve to call Ghostscript in a pipe chain. In other words, try to find out the right arguments Ghostscript needs in order to print with a command like this:

     $ cat file.ps | gs more arguments

In general it is the same command as for calling Ghostscript with a filename, except that the file name to use is -:

     $ cat file.ps \
       | gs -q -dNOPAUSE -sDEVICE=deskjet -sOutputFile=- - -c quit\
       | lp -dprinter-name

Once it works, it is then easy to settle the right Printer: line in your configuration file (see Your Printers). For instance:

     Printer: djet \
       | gs -q -dNOPAUSE -sDEVICE=deskjet -sOutputFile=- - -c quit\
       | lp -d djet

Christian Mondrup uses a2ps under Windows with a non PostScript printer. He uses:

     DefaultPrinter: | //c/gstools/gs5.10/Gswin32c.exe         \
        -Ic:\gstools\gs5.10;c:\gstools\gs5.10\fonts            \
        -sDEVICE=ljet4 -sPAPERSIZE=a4 -dNOPAUSE -r300 -dSAFER  \
        -sOutputFile="\\spool\HP LaserJet 5L (PCL)"            \
        -q - -c quit

10.2.7 How Can I Print Man Pages with Underlines

By the past, when I printed a man page with a2ps, it used underlines, but now it uses italics. I want underlines back!

Use a2ps --pro=ul.

10.3 Please tell me...

Wondering something?

• Is a2ps Y2K compliant?: Printing dates in short format
• The Options Have Changed: Respect The Users
• Why not using yacc: Why Using Style Sheets
• Why do you not use mozilla: Using remote commands

10.3.1 Is a2ps Y2K compliant?

The famous Y2K⁶ problem...

Yes, a2ps is Y2K compliant... provided that you have either a version more recent than 4.10.3. The expansions of the following escapes were broken (giving 100 instead of 00): %D, %W, $D, $W.

Nevertheless, please note that if you required a two digit year, expect to have Jan 1st, 00 someday. You are responsible of the format you want for the date: See Escapes.

10.3.2 Why Have the Options Changed?

The options of this a2ps are not the same as in the previous versions.

True. But the old scheme (up to version 4.6.1) prevented us from offering more options. We had to drop it, and to fully redesign the options handling.

Since that profound change, we try to change as little as possible between versions. Nevertheless, as the time passes, we discover that some never used options should be renamed, or used for something else. In these cases, compatibility code is left for a long time.

Anywhere you put options but the command line (e.g., in a2ps configuration files or in shell scripts), avoid using short options, since short options are much more likely to be changed (there are not so many, so it is a precious resource). Since there are as many long options as one wants, we can leave compatibility code with the long options.

10.3.3 Why not having used yacc and such

There are several reasons why we decided not to use grammars to parse the files. Firstly it would have made the design of the style sheets much more tricky, and today a2ps would know only 4 or 5 languages.

Secondly, it limits the number of persons who could build a style sheet.

Thirdly, we did not feel the need for such a powerful tool: handling the keywords and the sequences is just what the users expect.

Fourthly, any extension of a2ps would have required to recompile.

And last but not least, using a parser requires that the sources are syntactic bug free, which is too strong a requirement.