public Class T2Interpreter

Returns the absolute value of num.

Returns the sum of the two numbers num1 and num2.

Puts a 1 on the stack if num1 and num2 are both non-zero, and puts a 0 on the stack if either argument is zero.

Operates in the same manner as callsubr except that it calls a global subroutine.

Calls a charstring subroutine with index subr# (actually the subr number plus the subroutine bias number, as described in section 2.3) in the Subrs array. Each element of the Subrs array is a charstring encoded like any other charstring. Arguments pushed on the Type 2 argument stack prior to calling the subroutine, and results pushed on this stack by the subroutine, act according to the manner in which the subroutine is coded. Calling an undefined subr (gsubr) has undefined results.

Returns the quotient of num1 divided by num2. The result is undefined if overflow occurs and is zero for underflow.

Removes the top element num from the Type 2 argument stack.

Duplicates the top element on the argument stack.

Finishes a charstring outline definition, and must be the last operator in a character's outline.

Puts a 1 on the stack if num1 equals num2, otherwise a 0 (zero) is put on the stack.

Exchanges the top two elements on the argument stack.

Causes two Bezier curves, as described by the arguments (as shown in Figure 2 below), to be rendered as a straight line when the flex depth is less than fd /100 device pixels, and as curved lines when the flex depth is greater than or equal to fd/100 device pixels.

Causes the two curves described by the arguments to be rendered as a straight line when the flex depth is less than 0.5 device pixels, and as curved lines when the flex depth is greater than or equal to 0.5 device pixels.

Retrieves the value stored in the transient array at the location given by i and pushes the value onto the argument stack. If get is executed prior to put for i during execution of the current charstring, the value returned is undefined.

Causes the two curves described by the arguments dx1...dx6 to be rendered as a straight line when the flex depth is less than 0.5 (that is, fd is 50) device pixels, and as curved lines when the flex depth is greater than or equal to 0.5 device pixels.

Causes the two curves described by the arguments to be rendered as a straight line when the flex depth is less than 0.5 device pixels, and as curved lines when the flex depth is greater than or equal to 0.5 device pixels.

Appends one or more Bezier curves, as described by the dxa...dxc set of arguments, to the current point. For each curve, if there are 4 arguments, the curve starts and ends horizontal. The first curve need not start horizontal (the odd argument case). Note the argument order for the odd argument case.

Appends a horizontal line of length dx1 to the current point. With an odd number of arguments, subsequent argument pairs are interpreted as alternating values of dy and dx, for which additional lineto operators draw alternating vertical and horizontal lines. With an even number of arguments, the arguments are interpreted as alternating horizontal and vertical lines. The number of lines is determined from the number of arguments on the stack.

Moves the current point dx1 units in the horizontal direction.

Appends one or more Bezier curves to the current point. The tangent for the first Bezier must be horizontal, and the second must be vertical (except as noted below). If there is a multiple of four arguments, the curve starts horizontal and ends vertical. Note that the curves alternate between start horizontal, end vertical, and start vertical, and end horizontal. The last curve (the odd argument case) need not end horizontal/vertical.

Leaves the value s1 on the stack if v1 ? v2, or leaves s2 on the stack if v1 > v2. The value of s1 and s2 is usually the biased number of a subroutine.

Retrieves the element i from the top of the argument stack and pushes a copy of that element onto that stack. If i is negative, the top element is copied. If i is greater than X, the operation is undefined.

Returns the product of num1 and num2. If overflow occurs, the result is undefined, and zero is returned for underflow.

Returns the negative of num.

Returns a 0 if num1 is non-zero; returns a 1 if num1 is zero.

Puts a 1 on the stack if either num1 or num2 are non-zero, and puts a 0 on the stack if both arguments are zero.

Stores val into the transient array at the location given by i.

Returns a pseudo random number num2 in the range (0,1], that is, greater than zero and less than or equal to one.

Is equivalent to one rrcurveto for each set of six arguments dxa...dyc, followed by exactly one rlineto using the dxd, dyd arguments. The number of curves is determined from the count on the argument stack.

Returns from either a local or global charstring subroutine, and continues execution after the corresponding call(g)subr.

Is equivalent to one rlineto for each pair of arguments beyond the six arguments dxb...dyd needed for the one rrcurveto command. The number of lines is determined from the count of items on the argument stack.

Appends a line from the current point to a position at the relative coordinates dxa, dya. Additional rlineto operations are performed for all subsequent argument pairs. The number of lines is determined from the number of arguments on the stack.

Moves the current point to a position at the relative coordinates (dx1, dy1).

Performs a circular shift of the elements num(Nx1) ... num0 on the argument stack by the amount J. Positive J indicates upward motion of the stack; negative J indicates downward motion. The value N must be a non-negative integer, otherwise the operation is undefined.

Appends a Bezier curve, defined by dxa...dyc, to the current point. For each subsequent set of six arguments, an additional curve is appended to the current point. The number of curve segments is determined from the number of arguments on the number stack and is limited only by the size of the number stack.

Returns the square root of num. If num is negative, the result is undefined.

Returns the result of subtracting num2 from num1.

Appends one or more Bezier curves to the current point, where the first tangent is vertical and the second tangent is horizontal. This command is the complement of hvcurveto; see the description of hvcurveto for more information.

Appends a vertical line of length dy1 to the current point. With an odd number of arguments, subsequent argument pairs are interpreted as alternating values of dx and dy, for which additional lineto operators draw alternating horizontal and vertical lines. With an even number of arguments, the arguments are interpreted as alternating vertical and horizontal lines. The number of lines is determined from the number of arguments on the stack.

Moves the current point dy1 units in the vertical direction.

Appends one or more curves to the current point. If the argument count is a multiple of four, the curve starts and ends vertical. If the argument count is odd, the first curve does not begin with a vertical tangent.

Clear the argument stack

The number of arguments on the argument stack

Pop a value off the argument stack

Pop a value off the subroutine stack

Push a value on to the argument stack

Push a value on to the subroutine stack