px, section 2.

2. Operations

2.1. Naming conventions and operation summary

Table 2.1 outlines the opcode typing convention. The expression ``a above b'' means that `a' is on top of the stack with `b' below it. Table 2.3 describes each of the opcodes. The character `*' at the end of a name specifies that all operations with the root prefix before the `*' are summarized by one entry. Table 2.2 gives the codes used to describe the type inline data expected by each instruction.







box center;
c s s
c s s
c c c
n ap-2 a.
Table 2.1 - Operator Suffixes
=

Unary operator suffixes

Suffix	Example	Argument type
2	NEG2	Short integer (2 bytes)
4	SQR4	Long integer (4 bytes)
8	ABS8	Real (8 bytes)

_

c s s
c c c
n ap-2 a.
Binary operator suffixes

Suffix	Example	Argument type
2	ADD2	Two short integers
24	MUL24	Short above long integer
42	REL42	Long above short integer
4	DIV4	Two long integers
28	DVD28	Short integer above real
48	REL48	Long integer above real
82	SUB82	Real above short integer
84	MUL84	Real above long integer
8	ADD8	Two reals

_

c s s
c c c
n ap-2 a.
Other Suffixes

Suffix	Example	Argument types
T	ADDT	Sets
G	RELG	Strings







box center;
c s
c | c
ci | aw(3.25i).
Table 2.2 - Inline data type codes
_
Code	Description
=
a	T{

An address offset is given in the word following the instruction. T} _ A T{ An address offset is given in the four bytes following the instruction. T} _ l T{ An index into the display is given in the sub-opcode. T} _ r T{ A relational operator is encoded in the sub-opcode. (see section 2.3) T} _ s T{ A small integer is placed in the sub-opcode, or in the next word if it is zero or too large. T} _ v T{ Variable length inline data. T} _ w T{ A word value in the following word. T} _ W T{ A long value in the following four bytes. T} _ " T{ An inline constant string. T}

box center; c s s lw(14) | lw(12) | lw(40) lp-2 | a | l. Table 2.3 - Machine operations _ Mnemonic Reference Description =

ABS* 2.7 Absolute value ADD* 2.7 Addition AND 2.4 Boolean and ARGC 2.14 Returns number of arguments to current process ARGV 2.14 Copy specified process argument into char array AS* 2.5 Assignment operators ASRT 2.12 Assert true to continue ATAN 2.13 Returns arctangent of argument BEG s,W,w," 2.2,1.8 Write second part of block mark, enter block BUFF 3.11 Specify buffering for file "output" CALL l,A 2.2,1.8 Procedure or function call CARD s 2.11 Cardinality of set CASEOP* 2.9 Case statements CHR* 2.15 Returns integer to ascii mapping of argument CLCK 2.14 Returns user time of program CON* v 2.5 Load constant operators COS 2.13 Returns cos of argument COUNT w 2.10 Count a statement count point CTTOT s,w,w 2.11 Construct set DATE 2.14 Copy date into char array DEFNAME 3.11 Attach file name for program statement files DISPOSE 2.15 Dispose of a heap allocation DIV* 2.7 Fixed division DVD* 2.7 Floating division END 2.2,1.8 End block execution EOF 3.10 Returns true if end of file EOLN 3.10 Returns true if end of line on input text file EXP 2.13 Returns exponential of argument EXPO 2.13 Returns machine representation of real exponent FILE 3.9 Push descriptor for active file FLUSH 3.11 Flush a file FNIL 3.7 Check file initialized, not eof, synced FOR* a 2.12 For statements GET 3.7 Get next record from a file GOTO l,A 2.2,1.8 Non-local goto statement HALT 2.2 Produce control flow backtrace IF a 2.3 Conditional transfer IN s,w,w 2.11 Set membership INCT 2.11 Membership in a constructed set IND* 2.6 Indirection operators INX* s,w,w 2.6 Subscripting (indexing) operator ITOD 2.12 Convert integer to real ITOS 2.12 Convert integer to short integer LINO s 2.2 Set line number, count statements LLIMIT 2.14 Set linelimit for output text file LLV l,W 2.6 Address of operator LN 2.13 Returns natural log of argument LRV* l,A 2.5 Right value (load) operators LV l,w 2.6 Address of operator MAX s,w 3.8 Maximum of top of stack and w MESSAGE 3.6 Write to terminal MIN s 3.8 Minimum of top of stack and s MOD* 2.7 Modulus MUL* 2.7 Multiplication NAM A 3.8 Convert enumerated type value to print format NEG* 2.7 Negation NEW s 2.15 Allocate a record on heap, set pointer to it NIL 2.6 Assert non-nil pointer NODUMP s,W,w," 2.2 BEG main program, suppress dump NOT 2.4 Boolean not ODD* 2.15 Returns true if argument is odd, false if even OFF s 2.5 Offset address, typically used for field reference OR 2.4 Boolean or PACK s,w,w,w 2.15 Convert and copy from unpacked to packed PAGE 3.8 Output a formfeed to a text file POP s 2.2,1.9 Pop (arguments) off stack PRED* 2.7 Returns predecessor of argument PUSH s 2.2,1.9 Clear space (for function result) PUT 3.8 Output a record to a file PXPBUF w 2.10 Initialize pxp count buffer RANDOM 2.13 Returns random number RANG* v 2.8 Subrange checking READ* 3.7 Read a record from a file REL* r 2.3 Relational test yielding Boolean result REMOVE 3.11 Remove a file RESET 3.11 Open file for input REWRITE 3.11 Open file for output ROUND 2.13 Returns TRUNC(argument + 0.5) RV* l,a 2.5 Right value (load) operators SCLCK 2.14 Returns system time of program SDUP 2.2 Duplicate top stack word SEED 2.13 Set random seed, return old seed SIN 2.13 Returns sin of argument SQR* 2.7 Squaring SQRT 2.13 Returns square root of argument STLIM 2.14 Set program statement limit STOD 2.12 Convert short integer to real STOI 2.12 Convert short to long integer SUB* 2.7 Subtraction SUCC* 2.7 Returns successor of argument TIME 2.14 Copy time into char array TRA a 2.2 Short control transfer (local branching) TRA4 A 2.2 Long control transfer TRACNT w,A 2.10 Count a procedure entry TRUNC 2.13 Returns integer part of argument UNDEF 2.15 Returns false UNIT* 3.10 Set active file UNPACK s,w,w,w 2.15 Convert and copy from packed to unpacked WCLCK 2.14 Returns current time stamp WRITEC 3.8 Character unformatted write WRITEF l 3.8 General formatted write WRITES l 3.8 String unformatted write WRITLN 3.8 Output a newline to a text file

2.2. Basic control operations

HALT

Corresponds to the Pascal procedure halt; causes execution to end with a post-mortem backtrace as if a run-time error had occurred.

BEG s,W,w,"

Causes the second part of the block mark to be created, and W bytes of local variable space to be allocated and cleared to zero. Stack overflow is detected here. w is the first line of the body of this section for error traceback, and the inline string (length s) the character representation of its name.

NODUMP s,W,w,"

Equivalent to BEG, and used to begin the main program when the ``p'' option is disabled so that the post-mortem backtrace will be inhibited.

END

Complementary to the operators CALL and BEG, exits the current block, calling the procedure pclose to flush buffers for and release any local files. Restores the environment of the caller from the block mark. If this is the end for the main program, all files are flushed, and the interpreter is exited.

CALL l,A

Saves the current line number, return address, and active display entry pointer dp in the first part of the block mark, then transfers to the entry point given by the relative address A, that is the beginning of a procedure or function at level l.

PUSH s

Clears s bytes on the stack. Used to make space for the return value of a function just before calling it.

POP s

Pop s bytes off the stack. Used after a function or procedure returns to remove the arguments from the stack.

TRA a

Transfer control to relative address a as a local goto or part of a structured statement.

TRA4 A

Transfer control to an absolute address as part of a non-local goto or to branch over procedure bodies.

LINO s

Set current line number to s. For consistency, check that the expression stack is empty as it should be (as this is the start of a statement.) This consistency check will fail only if there is a bug in the interpreter or the interpreter code has somehow been damaged. Increment the statement count and if it exceeds the statement limit, generate a fault.

GOTO l,A

Transfer control to address A that is in the block at level l of the display. This is a non-local goto. Causes each block to be exited as if with END, flushing and freeing files with pclose, until the current display entry is at level l.

SDUP*

Duplicate the word or long on the top of the stack. This is used mostly for constructing sets. See section 2.11.

2.3. If and relational operators

IF a

The interpreter conditional transfers all take place using this operator that examines the Boolean value on the top of the stack. If the value is true, the next code is executed, otherwise control transfers to the specified address.

REL* r

These take two arguments on the stack, and the sub-operation code specifies the relational operation to be done, coded as follows with `a' above `b' on the stack:







lb lb
c a.
Code	Operation
_
0	a = b
2	a <> b
4	a < b
6	a > b
8	a <= b
10	a >= b

Each operation does a test to set the condition code
appropriately and then does an indexed branch based on the
sub-operation code to a test of the condition here specified,
pushing a Boolean value on the stack.

Consider the statement fragment:

if a = b then

If
a
and
b
are integers this generates the following code:







lp-2w(8) l.
RV4:l	a
RV4:l	b
REL4	=
IF	Else part offset

c s.
... Then part code ...

2.4. Boolean operators

The Boolean operators AND, OR, and NOT manipulate values on the top of the stack. All Boolean values are kept in single bytes in memory, or in single words on the stack. Zero represents a Boolean false, and one a Boolean true.

2.5. Right value, constant, and assignment operators

LRV* l,A
RV* l,a

The right value operators load values on the stack. They take a block number as a sub-opcode and load the appropriate number of bytes from that block at the offset specified in the following word onto the stack. As an example, consider LRV4:

_LRV4:
	cvtbl	(lc)+,r0	#r0 has display index
	addl3	_display(r0),(lc)+,r1	#r1 has variable address
	pushl	(r1)	#put value on the stack
	jmp	(loop)

Here the interpreter places the display level in r0.
It then adds the appropriate display value to the inline offset and
pushes the value at this location onto the stack.
Control then returns to the main
interpreter loop.
The
RV*
operators have short inline data that
reduces the space required to address the first 32K of
stack space in each stack frame.
The operators
RV14
and
RV24
provide explicit conversion to long as the data
is pushed.
This saves the generation of
STOI
to align arguments to 
C
subroutines.

CON* r

The constant operators load a value onto the stack from inline code. Small integer values are condensed and loaded by the CON1 operator, that is given by

_CON1:
	cvtbw	(lc)+,-(sp)
	jmp	(loop)

Here note that little work was required as the required constant
was available at (lc)+.
For longer constants,
lc
must be incremented before moving the constant.
The operator
CON
takes a length specification in the sub-opcode and can be used to load
strings and other variable length data onto the stack.
The operators 
CON14
and
CON24
provide explicit conversion to long as the constant is pushed.

AS*

The assignment operators are similar to arithmetic and relational operators in that they take two operands, both in the stack, but the lengths given for them specify first the length of the value on the stack and then the length of the target in memory. The target address in memory is under the value to be stored. Thus the statement

i := 1

where
i
is a full-length, 4 byte, integer,
will generate the code sequence







lp-2w(8) l.
LV:l	i
CON1:1
AS24

Here
LV
will load the address of
i,
that is really given as a block number in the sub-opcode and an
offset in the following word,
onto the stack, occupying a single word.
CON1,
that is a single word instruction,
then loads the constant 1,
that is in its sub-opcode,
onto the stack.
Since there are not one byte constants on the stack,
this becomes a 2 byte, single word integer.
The interpreter then assigns a length 2 integer to a length 4 integer using
AS24.
The code sequence for
AS24
is given by:

_AS24:
	incl	lc
	cvtwl	(sp)+,*(sp)+
	jmp	(loop)

Thus the interpreter gets the single word off the stack,
extends it to be a 4 byte integer
gets the target address off the stack,
and finally stores the value in the target.
This is a typical use of the constant and assignment operators.

2.6. Addressing operations

LLV l,W
LV l,w

The most common operation done by the interpreter is the ``left value'' or ``address of'' operation. It is given by:

_LLV:
	cvtbl	(lc)+,r0	#r0 has display index
	addl3	_display(r0),(lc)+,-(sp)	#push address onto the stack
	jmp	(loop)

It calculates an address in the block specified in the sub-opcode
by adding the associated display entry to the
offset that appears in the following word.
The
LV
operator has a short inline data that reduces the space
required to address the first 32K of stack space in each call frame.

OFF s

The offset operator is used in field names. Thus to get the address of

p^.f1

pi
would generate the sequence







lp-2w(8) l.
RV:l	p
OFF	f1

where the
RV
loads the value of
p,
given its block in the sub-opcode and offset in the following word,
and the interpreter then adds the offset of the field
f1
in its record to get the correct address.
OFF
takes its argument in the sub-opcode if it is small enough.

NIL

The example above is incomplete, lacking a check for a nil pointer. The code generated would be







lp-2w(8) l.
RV:l	p
NIL
OFF	f1

where the
NIL
operation checks for a
nil
pointer and generates the appropriate runtime error if it is.

LVCON s,"

A pointer to the specified length inline data is pushed onto the stack. This is primarily used for printf type strings used by WRITEF. (see sections 3.6 and 3.8)

INX* s,w,w

The operators INX2 and INX4 are used for subscripting. For example, the statement

a[i] := 2.0

with
i
an integer and
a
an
``array [1..1000] of real''
would generate







lp-2w(8) l.
LV:l	a
RV4:l	i
INX4:8	1,999
CON8	2.0
AS8

Here the
LV
operation takes the address of
a
and places it on the stack.
The value of
i
is then placed on top of this on the stack.
The array address is indexed by the
length 4 index (a length 2 index would use
INX2)
where the individual elements have a size of 8 bytes.
The code for 
INX4
is:

_INX4:
	cvtbl	(lc)+,r0
	bneq	L1
	cvtwl	(lc)+,r0	#r0 has size of records
L1:
	cvtwl	(lc)+,r1	#r1 has lower bound
	movzwl	(lc)+,r2	#r2 has upper-lower bound
	subl3	r1,(sp)+,r3	#r3 has base subscript
	cmpl	r3,r2	#check for out of bounds
	bgtru	esubscr
	mull2	r0,r3	#calculate byte offset
	addl2	r3,(sp)		#calculate actual address
	jmp	(loop)
esubscr:
	movw	$ESUBSCR,_perrno
	jbr	error

Here the lower bound is subtracted, and range checked against the
upper minus lower bound.
The offset is then scaled to a byte offset into the array
and added to the base address on the stack.
Multi-dimension subscripts are translated as a sequence of single subscriptings.

IND*

For indirect references through var parameters and pointers, the interpreter has a set of indirection operators that convert a pointer on the stack into a value on the stack from that address. different IND operators are necessary because of the possibility of different length operands. The IND14 and IND24 operators do conversions to long as they push their data.

2.7. Arithmetic operators

The interpreter has many arithmetic operators. All operators produce results long enough to prevent overflow unless the bounds of the base type are exceeded. The basic operators available are

Addition:	ADD*, SUCC*
Subtraction:	SUB*, PRED*
Multiplication:	MUL*, SQR*
Division:	DIV*, DVD*, MOD*
Unary:		NEG*, ABS*

2.8. Range checking

The interpreter has several range checking operators. The important distinction among these operators is between values whose legal range begins at zero and those that do not begin at zero, for example a subrange variable whose values range from 45 to 70. For those that begin at zero, a simpler ``logical'' comparison against the upper bound suffices. For others, both the low and upper bounds must be checked independently, requiring two comparisons. On the 11/780"" VAX 11/780 both checks are done using a single index instruction so the only gain is in reducing the inline data.

2.9. Case operators

The interpreter includes three operators for case statements that are used depending on the width of the case label type. For each width, the structure of the case data is the same, and is represented in figure 2.4.

center, box; cw(15). CASEOP _ No. of cases _

Case transfer table

Array of case label values

Figure 2.4 - Case data structure

The CASEOP case statement operators do a sequential search through the case label values. If they find the label value, they take the corresponding entry from the transfer table and cause the interpreter to branch to the specified statement. If the specified label is not found, an error results.

The CASE operators take the number of cases as a sub-opcode if possible. Three different operators are needed to handle single byte, word, and long case transfer table values. For example, the CASEOP1 operator has the following code sequence:

_CASEOP1:
	cvtbl	(lc)+,r0
	bneq	L1
	cvtwl	(lc)+,r0	#r0 has length of case table
L1:
	movaw	(lc)[r0],r2	#r2 has pointer to case labels
	movzwl	(sp)+,r3	#r3 has the element to find
	locc	r3,r0,(r2)	#r0 has index of located element
	beql	caserr	#element not found
	mnegl	r0,r0	#calculate new lc
	cvtwl	(r2)[r0],r1	#r1 has lc offset
	addl2	r1,lc
	jmp	(loop)
caserr:
	movw	$ECASE,_perrno
	jbr	error

Here the interpreter first computes the address of the beginning of the case label value area by adding twice the number of case label values to the address of the transfer table, since the transfer table entries are 2 byte address offsets. It then searches through the label values, and generates an ECASE error if the label is not found. If the label is found, the index of the corresponding entry in the transfer table is extracted and that offset is added to the interpreter location counter.

2.10. Operations supporting pxp

The following operations are defined to do execution profiling.

PXPBUF w

Causes the interpreter to allocate a count buffer with w four byte counters and to clear them to zero. The count buffer is placed within an image of the pmon.out file as described in the PXP Implementation Notes. The contents of this buffer are written to the file pmon.out when the program ends.

COUNT w

Increments the counter specified by w.

TRACNT w,A

Used at the entry point to procedures and functions, combining a transfer to the entry point of the block with an incrementing of its entry count.

2.11. Set operations

The set operations: union ADDT, intersection MULT, element removal SUBT, and the set relationals RELT are straightforward. The following operations are more interesting.

CARD s

Takes the cardinality of a set of size s bytes on top of the stack, leaving a 2 byte integer count. CARD uses the ffs opcode to successively count the number of set bits in the set.

CTTOT s,w,w

Constructs a set. This operation requires a non-trivial amount of work, checking bounds and setting individual bits or ranges of bits. This operation sequence is slow, and motivates the presence of the operator INCT below. The arguments to CTTOT include the number of elements s in the constructed set, the lower and upper bounds of the set, the two w values, and a pair of values on the stack for each range in the set, single elements in constructed sets being duplicated with SDUP to form degenerate ranges.

IN s,w,w

The operator in for sets. The value s specifies the size of the set, the two w values the lower and upper bounds of the set. The value on the stack is checked to be in the set on the stack, and a Boolean value of true or false replaces the operands.

INCT

The operator in on a constructed set without constructing it. The left operand of in is on top of the stack followed by the number of pairs in the constructed set, and then the pairs themselves, all as single word integers. Pairs designate runs of values and single values are represented by a degenerate pair with both value equal. This operator is generated in grammatical constructs such as
```
if character in [`+', '-', `*', `/']

or
```
```
if character in [`a'..`z', `$', `_']

These constructs are common in Pascal, and
INCT
makes them run much faster in the interpreter,
as if they were written as an efficient series of
if
statements.
```

2.12. Miscellaneous

Other miscellaneous operators that are present in the interpreter are ASRT that causes the program to end if the Boolean value on the stack is not true, and STOI, STOD, ITOD, and ITOS that convert between different length arithmetic operands for use in aligning the arguments in procedure and function calls, and with some untyped built-ins, such as SIN and COS.

Finally, if the program is run with the run-time testing disabled, there are special operators for for statements and special indexing operators for arrays that have individual element size that is a power of 2. The code can run significantly faster using these operators.

2.13. Mathematical Functions

The transcendental functions SIN, COS, ATAN, EXP, LN, SQRT, SEED, and RANDOM are taken from the standard UNIX mathematical package. These functions take double precision floating point values and return the same.

The functions EXPO, TRUNC, and ROUND take a double precision floating point number. EXPO returns an integer representing the machine representation of its argument's exponent, TRUNC returns the integer part of its argument, and ROUND returns the rounded integer part of its argument.

2.14. System functions and procedures

LLIMIT

A line limit and a file pointer are passed on the stack. If the limit is non-negative the line limit is set to the specified value, otherwise it is set to unlimited. The default is unlimited.

STLIM

A statement limit is passed on the stack. The statement limit is set as specified. The default is 500,000. No limit is enforced when the ``p'' option is disabled.

CLCK
SCLCK

CLCK returns the number of milliseconds of user time used by the program; SCLCK returns the number of milliseconds of system time used by the program.

WCLCK

The number of seconds since some predefined time is returned. Its primary usefulness is in determining elapsed time and in providing a unique time stamp.

The other system time procedures are DATE and TIME that copy an appropriate text string into a pascal string array. The function ARGC returns the number of command line arguments passed to the program. The procedure ARGV takes an index on the stack and copies the specified command line argument into a pascal string array.

2.15. Pascal procedures and functions

PACK s,w,w,w
UNPACK s,w,w,w

They function as a memory to memory move with several semantic checks. They do no ``unpacking'' or ``packing'' in the true sense as the interpreter supports no packed data types.

NEW s
DISPOSE s

An LV of a pointer is passed. NEW allocates a record of a specified size and puts a pointer to it into the pointer variable. DISPOSE deallocates the record pointed to by the pointer and sets the pointer to NIL.

The function CHR* converts a suitably small integer into an ascii character. Its primary purpose is to do a range check. The function ODD* returns true if its argument is odd and returns false if its argument is even. The function UNDEF always returns the value false.