setpagedevice request can not be satisfied
dictionary is full
Occurs when a def, put, store operator attempts to define a new entry in a dictionary that is already full (i.e., whose length and maxlength are already equal). A dictionary has a fixed limit on the number of entries (with distinct keys) that it can hold; this limit is established by the operand to the dict operator that creates the dictionary.
too many begins
The dictionary stack has grown too large. Too many begins (without corresponding ends) have pushed too many dictionaries on the dictionary stack.
Before invoking this error, the interpreter creates an array containing all elements of the dictionary stack (stored as if by dictstack), pushes this array on the operand stack, and resets the dictionary stack to contain only systemdict and userdict.
too many ends
An attempt has been made to remove (end) the bottommost instance of userdict from the dictionary stack. This occurs if an end is executed for which there was no corresponding begin.
The execution stack has grown too large; procedure invocation is nested deeper than the PostScript interpreter permits. See Begrenzungen for the limit on the size of the execution stack.
See also: exec
Is looked up in errordict and executed to report error information saved by the default error handlers. There is also a procedure named handleerror in systemdict; it merely calls the one in errordict.
Process an external request to interrupt execution of a PostScript program. When the interpreter receives an interrupt request, it executes interrupt as if it were an error (i.e., it looks up the name 'interrupt' in errordict). Execution of interrupt is sandwiched between execution of two objects being interpreted in normal sequence.
The precise nature of an external interrupt request depends on the environment in which the PostScript interpreter is running. In typical environments, receipt of a Control-C character from a serial communication channel gives rise to the interrupt error. This permits a user to explicitly abort a PostScript computation. The default definition of interrupt executes a stop.
access attribute violated (e.g. attempted to write a read-only object)
An attempt has been made to reference an array, packed array, dictionary, file, or string object in a way that violates its access attribute (e.g, store into a read-only array). This error occurs if pathforall is executed when the current path includes the result of a charpath.
See also: rcheck, wcheck, readonly, executeonly, noaccess
An exit has been executed for which there is no dynamically enclosing looping context ( for, loop, repeat, pathforall, or renderbands), or it has attempted to leave the context of a run or stopped operator.
The access string specification to the file operator is unacceptable.
bad font name or dictionary
Either the operand to findfont is not a valid font name or the operand to makefont or setfont is not a well-formed font dictionary. (The invalidfont error may also be executed by other font operators upon discovering a font dictionary to be malformed in some way).
the saved state object is too old to restore
An improper restore has been attempted. One or more of the operand, dictionary or execution stack contains composite objects whose values were created more recently than the save whose context is being restored. Since restore would destroy those values but the stacks are unaffected by restore, the outcome would be undefined and cannot be allowed.
some kind of error during input or output
An execption (other than end-of-file) has occured during execution of one of the file operators. The nature of the execption is environment-dependent, but may include such events as parity or checksum errors, broken network connections, etc. Attempting to write to an input file or to a file that has been closed will also cause an ioerror. Occurrence of an ioerror does not cause the file to become closed unless it was already closed or the error occurs during closefile.
some implementation-dependent size restriction has been exceeded
A PostScript implementation limit has been exceeded (e.g., too many files have been opened simultaneously, or a path has become too complex). Begrenzungen gives the actual values for all such limits.
the current point is not defined, yet
The current path is empty, and thus there is no current point, but an operator requiring a current point has been executed (e.g., lineto, curveto, currentpoint, show). The most common cause of this error is neglecting to perform an initial moveto.
operand is too big or too small
A numeric operand's value is outside the range expected by an operator (e.g., an array or string index is out of bounds, a negative number appears where a non-negative number is required, etc.)
the stack was full before the last push
The operand stack has grown too large. Too many objects have been pushed on the stack and not popped off. See Begrenzungen for the limit on the size of the operand stack.
Before invoking this error, the interpreter creates an array containing all elements of the operand stack (stored as if by astore), resets the operand stack to empty, and pushes the array on the operand stack.
you tried to pop from an empty stack
An attempt has been made to remove an object from the operand stack when it is empty. This usually occurs because some operator did not have all of its required operands on the stack.
PostScript's syntax has been violated
The scanner has encountered program text that does not conform to the PostScript syntax rules. This can occur either during interpretation of an executable file or string object or during explicit invocation of the token operator.
Since PostScript syntax is simple, the set of possible causes for a syntaxerror is very small: Erroneous tokens such as malformed numbers do not produce a syntaxerror; such tokens are instead treated as name objects (often producing an undefined error when executed). Tokens that exceed implementation limits, such as names that are too long or numbers whose values are too large, produce a limitcheck.
A time limit has been exceeded; i.e., a PostScript program has executed for too long or has waited an excessive amount of time for some external event to occur.
operand is of the wrong type
Some operand's type is different from what an operator expects. This is probably the most frequent error encountered. It is often the result of faulty stack manipulation, such as operands supplied in the wrong order or procedures leaving results on the stack when they aren't supposed to.
name is not defined in any dictionary on the stack
A name used as a dictionary key in some context cannot be found. This occurs if a name is looked up explicitly in a specified dictionary (get) or in the current dictionary stack (load and is not found. It also occurs if an executable name is encountered by the interpreter and is not found in any dictionary on the dictionary stack.
A few PostScript operators are disabled in certain contexts (e.g., setgray after a setcachedevice in a BuildChar procedure); attempting to execute such a disabled operator results in an undefined error.
See also: known, where, exec
A file identified by a name string operand or file or run cannot be found or cannot be opened. The undefinedfilename eroor also occurs if the special file '%statementedit' or '%lineedit' is opened when the standard input file has reached end-of-file.
the result of the last numeric operation is invalid (e.g., division by zero)
A numeric computation would produce a meaningless result or one that cannot be represented as a PostScript number. Possible causes include numeric overflow or underflow, division by zero, or inverse transformation of a non-invertible matrix. See Begrenzungen for the limits of the values representable as integers and reals.
A mark object is sought on the operand stack by the ']', cleartomark, or counttomark operator, but none is present.
An operator object has been executed for which the interpreter has no built-in action. This represents an internal malfunction in the PostScript interpreter and should never occur.
virtual memory full
An error has occured in the virtual memory (VM) machinery. The most likely problems are: Begrenzungen gives the different sizes that objects occupy in the VM.

© Holger Gehringer, Dezember 1998