1 A Language for Printers

Postscript is a special-purpose language for preparing documents that mix text and graphics.

When the first laser printers came onto the market, the “obvious” idea was for the computer to compose each page as a raster image and send it to the printer.

• It added a significant computational load to the computer that was driving the printer.

• The resulting rasters were huge, and the time to simply transmit them from the computer to the printer would be prohibitively slow.

The solution was to send the printer, not a bitmap of the final image, but a program that could be executed on the printer’s own CPU to generate that bitmap. Postscript was the language designed for that purpose.

• On that page, a letter like ‘e’ in, say, a Times-Roman 11-pt font, might occur many dozens of times.
• Each ‘e’ would add their own little 2D block of bits to the image.

But, in Postscript, we would treat each letter in a font as a small function describing how to draw that letter.

• At worst, we might have to supply one copy of that 2D block of bits.
• A “font” could be nothing more than an array of such functions, indexed by the ASCII code of each character.
• A Postscript program to render that page of text would include repeated calls to the function in times-roman-font[101] (101 being the ASCII code for ‘e’).
  • In fact, the program probably just supplies a array of ASCII codes for an entire line of text,
  • looping through that array to pick up one character at a time and invoking the Times-Roman font “function” for each character in turn.

This offloads the computation of the entire raster onto the printer’s CPU.

It also provides a mechanism whereby fonts could be used whether pre-loaded into the printer or supplied with the as a data structure in the document’s program.

2 Postscript Overview

2.1 Simple Grammar

Postscript has the simplest grammar you will ever see:

<program> :== <program> <term> |
<term> ::= identifier | number | string

That’s it!

A Postscript program is just a list of terms, each of which can be am identifier, a number, or a string.

• Printers are genrally not built with the fastest CPUs, so no one wanted to waste time parsing an elaborate language.

2.2 Stack-Based Execution

The interpreter for Postscript is also remarkably simple.

Postscript is a stack-based language. A Postscript program is, at its most basic, a list of operators and constants. As each of these is “executed”, it pulls some number of values from the top of a stack, then pushes its results or answers onto the top of that same stack.

For example, the Postscript code to evaluate the expression $10 (x+1)$ is

10 x 1 add mul

which executes like this:

10 x 1 add mul

…

A constant is simply pushed onto the stack:

10 x 1 add mul

10

…

The same is true of variables. For the sake of illustration, let’s assume that $x$ has the value 25.

10 x 1 add mul

25

10

…

The next constant is also pushed onto the stack.

10 x 1 add mul

1

25

10

…

The add operator adds the two numbers on the top of the stack, replacing them by their sum.

10 x 1 add mul

26

10

…

The mul operator multiplies the two numbers on the top of the stack, replacing them by their product.

10 x 1 add mul

260

…

The final answer is left on the top of the stack.

1 of 6

2.3 Stack Operations

With so much emphasis on the stack, it’s not surprising that a number of the common operators are for manipulating or rearranging items on the stack:

Many of the most common operators in Postscript are for manipulating data on the stack:

3 Data Types

3.1 Numbers

Postscript data types start with numbers (integer and floating point). In addition to the add and mul operators already seen, there are

3.2 Strings, Arrays, & Procedures

• Postscript supports strings, which are written inside parentheses (like this) instead of quotation marks.

• It has arrays, which are created by using a special operator [ that pushes a “start of array mark”. This is followed by pushing an number of items onto the stack, then executing the end-of-array operator ‘]’, which collects all the items on that stack down to the ‘[’ into an array, leaving the reference to the array at the top of the stack.

  • Arrays can be joined to form matrices, which are key elements in many graphics calculations as ways to perform rotation and scaling.

• “Procedures”, stored blocks of code, are created in a similar fashion but use { } instead of [ ].

• In addition to the operand stack, Postscript maintains a dictionary stack.
• When a name’s value is needed, the name is hunted in the top dictionary, then the next lower, then the next, until
  • the name has been found
  • or all dictionaries in the stack have been searched unsuccessfully

This allows us to bind values to names.

Assignment is accomplished via the def operator. For example:

/x 42 def

assigned the value 42 to the variable x.

/double { 2 * } def

All parameters are passed on the stack.

5 Control Flow

Control flow in Postscript looks a bit strange at first, because of the stack-oriented model.

• We push the boolean condition expression
• Then we push the procedures we wish to choose among / iterate onto the stack
• Then we apply the appropriate control operator

Example: x 0 lt { /x x neg def } if

The x 0 lt evaluates a condition (is $x < 0$?), leaving a boolean on the stack. The {...} is a procedure that becomes the then-part of the if. The if operator checks the boolean value and decides whether to execute the then-part procedure or to simply discard it.

Similarly, we have an ifelse operator that takes two procedures, one representing the then-part and the next representing the else=-part.

Example: x 0 lt { /absx x neg def} { /absx x def } ifelse

Question: How would you define your own absolute value function?

/absolute
  { dup 0 lt { neg } if }
def

16 { 2 mul } repeats

would execute the procedure inside the { } sixteen times.

Unbounded loops are provided by the loop operator, which repeats a procedure until the procedure invokes an `exit operator.

E.g.,

{ 1 sub   % subtract 1 from top item
  dup 0 le { exit } if % until it becomes 0
} loop     

There is also a for-loop-like construction

for (tmp = init; tmp <= limit; tmp += incr)
{
  push tmp;
  proc;
}

Now, having established that Postscript has sequence, selection, and iteration, we could stop now and safely conclude that Postscript is Turing complete. Actually, it has recursion as well, so it’s doubly-qualified.

But, in case you’re wondering just why Postscript was useful for driving printers, let’s talk about the fun stuff.

• You can draw (stroke) the path so that it appears on the printed page.

• If the path is “closed” (starts and ends at the same point), you can fill the interior of the path with a color or pattern.

• If the path is “closed”, you can use it as a “clipping” boundary for future drawing. It then functions as a kind of window so that any future drawing operations are only visible if they lie within the window.

Graphics in Postscript use a basic coordinate system that lower-left corner of the paper as $(0,0)$.

• The units are “points”, a traditional unit in typesetting, roughly $\frac{1}{72}$ of an inch.
• The current page is displayed (printed) and then cleared by the showpage operator.

For convenience, I will use the following function to convert from inches to points:

/inch { 72 mul } def

E.g, 1.5 inch puts $108$ on the stack.

• Start a new path with newpath
• Create a path as a series of line segments and/or curves.
• Then do one or more of the following:
  • draw the current path (stroke)
  • fill the area enclosed by the path with a color (fill)
  • clip all future images lying outside the path (clip)

Drawing Lines

A simple Postscript program to draw a box:

6.3 Drawing Curves

where $(x,y)$ is the center of the circle, $r$ is the radius, and the portion of the arc drawn is from angle $\mbox{ang}_1$ to $\mbox{ang}_2$ (measured in degrees).

7 What’s Interesting About Postscript

(Well, graphics are always flashy.)

• It shows the power of a well-chosen set of special-purpose primitives

• The language itself is simple and easily processed.