Library Routines

Add

Adds the Addend to the Augend and stores the sum in the Answer.

All three numbers must have the same word length (specified by P4). The addend and the augend are preserved, unless overlaid by the answer. No error indication is given if overflow occurs.

Add to Double Word

The Addend is added to the Accumulator. Both are double word binary numbers.

Calculate Check Digit

Calculates the “Check Digit” corresponding to the number in the A-Register on entry. On return, the A-Register contains the check digit in ASCII (the top byte of A is NUL).

• The standard calculation routine returns a letter A:Z.

Clear Block of Core

Sets each word of the block to binary zeros.

Complement Double Word

Subtracts the Double Word Binary number from zero. The result overlays the original number.

 Compute

Multiplies the Multiplicand by the Multiplier and divides the intermediate result by the Divisor, storing the Result rounded to the nearest ½. If the Result is invalid for any reason (e.g. Divisor is zero) the answer given will be zero. The Multiplicand, Multiplier and Divisor are preserved unless overlaid by the result.

Word length may be specified as Single by setting B16 of the appropriate parameter; otherwise Word Length is taken as Double.

Parameter Format (P1, P2, P3 only)

Conversion: ASCII ® Binary

Converts the ASCII source string to Binary as specified by the Control Word.

On return from this subroutine, A-Register B17 will be set if the number was too large to fit in the Binary Target. The B-Register B16:B1 will contain the Byte Address of the next character following the detected end of field. In the case of a variable length source, the end-of-field character will be in the bottom of the A-Register. If a fixed-length source contained non-numeric characters, B-Register B17 will be set.

• Numeric characters are the digits 0 to 9, hyphen (minus-sign), period (decimal point) and comma (ignored).

Control Word

Conversion: ASCII ® Metacode

Converts the source string to Metacode (a system of encoding three characters per 17-bit word) until either a NUL character is encountered in the source or the source string is exhausted or an unconvertible character is encountered in the source.

The NUL character (when encountered) is inserted into the target.

• The Metacode character set is restricted to a choice of 49 characters plus NUL. If an unconvertible character was encountered in the source string, the A-Register is non-zero on return from this routine.

Control Word

The standard Metacode character set consists of:

Conversion: Binary ® ASCII

Converts the Binary Number into a fixed length decimal character string formatted as specified by the Control Word. The last character of the string will contain a hyphen if the number is negative, or a space or the “check digit” (if requested) if the number is positive.

No error indication is given if the number is too large to fit the string.

Control Word

• The Check Digit may only be requested for single word positive integers.

• The Target string must not overlay the Source.

• For integer conversions (Target Precision=0), (Precision of Source + Length of Target String) must not exceed 15.

• For non-integer conversions, Precision of Source must not exceed 14; Target Length must not be less than (Precision of Target + 2) nor exceed 17; (Precision of Source + Length of Target – Precision of Target) must not exceed 16.

Conversion: Binary ® Octal Characters

Converts the contents of the A-Register on entry into octal digits stored in ASCII in the six-character Target String. Leading zeros are not space filled.

Conversion: Metacode ® ASCII

Converts each Word of the Source Metacode into three ASCII characters in the Target until either a NUL character is encountered in the source or the target string is exhausted.

The NUL character (when encountered) is inserted into the target string unless B17 of P3 is set.

Control Word

Convert Input to Binary and test Limits

Using the issuing task’s Input Buffer as the ASCII Source String, this routine converts the next numeric field within the String to a Single Word Binary Number.

If the number is outside the limits specified by P1 and P2 the Error Handler is called (ERROR is sent to the task’s I/O station and upon acknowledgement the most recent GET subroutine call issued by the task is restarted).

On return from this subroutine, the A-Register will contain the Single Word Binary Number extracted from the Input Buffer. The non-numeric character which terminated the field will be found in the bottom byte of absolute core location 000043 (the top byte will be NUL); if this word is zero then the end of the source string has been reached.

The source string may contain several numeric fields, each separated by a single non-numeric character, and successive calls to this subroutine will yield the next field (provided the Error Handler is not called).

If an attempt is made to extract a field after the source string has been exhausted, the Binary Number will be set to zero. If two non-numeric characters are adjacent in the Source String, an intervening zero field will be created. In both cases, control passes to the Error Handler if zero is outside the specified limits.

P1 must be positive or zero, P2 must not be less than P1.

Convert to Negative if Positive

Tests the Binary Number and if positive subtracts it from zero.

On return, the A-Register will be clear if and only if the number was already negative when the routine was entered.

Convert to Positive if Negative

Tests the Binary Number and if negative subtracts it from zero.

On return, the A-Register will be clear if and only if the number was already positive (or zero) when the routine was entered.

Divide with Remainder

Divides the Dividend by the Divisor, storing the Result and overlaying the Dividend with the Remainder. The Divisor is preserved. If the Divisor is zero, the result is set zero and the remainder will equal the dividend.

The division is performed by a process of repetitive subtractions coupled with right shifts.

Parameter Format

Caution

• The Dividend and the Divisor must always be positive numbers.

• The Parameter Format restricts addressing; no parameter may b addressed above 16K absolute.

Divide and Round

Divides the Dividend by the Divisor and stores the Result rounded to the nearest half. The Dividend and the Divisor are preserved. If the Divisor is zero, the result is set zero.

Parameter Format

Caution

• The Dividend and the Divisor must always be positive numbers.

• The Parameter Format restricts addressing; no parameter may b addressed above 16K absolute.

Divide by 10 with Remainder

Divides the contents of the A-Register by 10 and stores the remainder in the B-Register.

Divide by 10 Rounded

Divides the contents of the A-Register by 10, rounding the result (5 goes up).

Duplicate Block of Core

The source is copied, word by word, to the target.

Left Shift Block of Core

Left shifts B16:B1 of each word of the block by one bit position. B16 carries into B1 of the word to the left. Each B17 is unchanged.

• If the block contains a binary number, its value is doubled.

Load A from Offset

This subroutine returns to the step following P1. The A-Register will contain the contents of the word addressed by P1 and the B-Register will contain the absolute value of P1.

• Memory aid: 21=LDA

Move and Pad Character String

The source string is copied, byte by byte, to the Target string until either a NUL byte is encountered in the Source String or the Target String is exhausted.

The A-Register is non-zero on return if the Target String was exhausted without encountering a NUL byte in, or immediately after, the Source String (this indicates truncation).

When a NUL byte is encountered in the Source string, the remainder of the target string is space-filled. The NUL byte is not entered into the target string.

Multiply

Multiplies the Multiplicand by the Multiplier and stores the Result. If the Result is rendered invalid for any reason (e.g. insufficient word length) the answer given will be zero.

Parameter Format

Caution

• The Multiplicand and the Multiplier must always be positive numbers.

• The Parameter Format restricts addressing; no parameter may b addressed above 16K absolute.

Multiply by 10

Multiplies the Binary Number by 10 and adds the contents of the A-Register at entry to the routine to the result of the multiplication.

Maximum word length is 3.

On return, A-Register contains the overflow (if any) from the most significant word. The result overlays the original Binary Number.

Name and Address Processor

Given any number of names and addresses, each held in ASCII in separate source strings, this routine creates an ASCII target string containing the first line from each name and address. The routine then passes control to a user-written Exit Routine, which will normally perform an output operation and which must return control, whereupon the next line from each name and address is set up in the target string and the Exit Routine is called again. The process is repeated (provided the Exit Routine returns control) until the Exit Routine has been called the number of times specified by P3, whereupon control returns to the step following P3.

Each source string is ended with a NUL byte. Each line within each source string is ended with ASCII code CR (optional on the last line). Each source string is allocated a field within the target string (the field position and length being user-defined) into which the next source line is copied byte by byte. The terminating CR is never stored in the target, neither is a NUL byte. If the target field becomes full, excess source characters are ignored. Each new source line is copied to the start of the appropriate target field, until a NUL byte indicates that the end of the source string has been reached.

The target string must be space-filled initially and upon each return from the Exit Routine (N.B. Inner Print Buffer is automatically space-filled by the Printer Output routine).

On entry to the Exit Routine, the A-Register will contain the Call Number (=1 first time). The Exit Routine will always be called exactly the number of times specified by P3. The Exit Routine may set up further fields within the target string before it is output; but in most cases it will simply output and return:

Parameter Block

There is one five-word parameter block for each source string, format as follows:

Pack Date

This routine uses the Convert Input to Binary and Test Limits subroutine to to extract a date from the issuing task’s Input Buffer. The date must be input to the buffer in ASCII as three numeric fields (day, month and last two digits of year) separated by a single non-numeric character (usually a space).

If an error is detected in the input ASCII the Error Handler is called (ERROR is sent to the task’s I/O station and upon acknowledgement the most recent GET subroutine call issued by the task is restarted).

On return from this subroutine, the A-Register will contain a properly validated date packed in the format shown below and suitable for presentation to the Unpack subroutine.

Format of Packed Date

Resolve Offset Address

Tests the contents of the A-Register on entry for an Offset Address and, if found, converts the address to absolute.

On return, the A-Register contains the Absolute address. The B-Register is unchanged.

An Offset Address is indicated by B17 set.

Resolve Block of Offset Addresses

Tests each word of the block for the presence of an Offset Address and, if found, overlays the word with the resolved absolute address.

The end of the block is indicated by a zero word.

Words within the block not containing offset addresses (i.e. B17 not set) are unchanged.

Right Shift Block of Core

Right-shifts B16:B1 of each word of the block by one bit position. B1 carries into B16 of the word to the right. Each B17 is unchanged.

This routine should not be used to halve binary numbers, because the sign bit is not propagated into B16 in the most significant word.

Skip if Blocks Equal

Compares the first block word for word with the second block. If an inequality is detected the routine returns to the step following P3. If both blocks are identical, the routine skips this step on returning.

The greater-than flag will be set or clear according as P1 is greater than P2. The comparison is logical, not arithmetic (i.e. B17 of each word is not interpreted as a sign bit).

Skip if Block not Zero

Tests the block word by word for zero. If all words are zero, the routine returns to the step following P2. If a non-zero word is found, the routine skips this step on returning.

An equivalent but more efficient method for double words is:

Space Fill Block of Core

Sets each word of the block to ASCII SP SP.

Store A at Offset

The contents of the A-Register at entry are stored at the word addressed by P1.

The subroutine returns to the step following P1 with the A-Register unchanged and the B-Register containing the absolute value of P1.

• Memory aid: 25=STA.

Store Byte

The bottom byte (B8:B1) of the A-Register at entry are stored at the byte addressed by P1.

The subroutine returns to the step following P1 with A-Register and B-Register undefined.

Subtract

Subtracts the Subtrahend from the Minuend and stores the difference in the Answer.

All three numbers must have the same word length (specified by P4). The minuend and the subtrahend are preserved, unless overlaid by the answer. No error indication is given if overflow occurs.

Subtract from Double Word

The Subtrahend is subtracted from the Accumulator. Both are double word binary numbers.

Swap Blocks of Core

The blocks are swapped word by word.

A block of core may be rotated by any desired number of words by swapping two suitably overlapping sub-blocks.

Unpack Date

Converts the contents of the A-Register on entry into a nine-character string stored in he Target with the format:

dd mmm yy

where dd, yy are numeric and mmm is alphabetic.

The word presented in the A-Register should be a date previously packed by the Pack Date subroutine.