A 'newly declared variable' is being used. So first the length of its name is found.

Enter a loop to deal with the characters of a long name. Any spaces or colour codes in the name are ignored.

Separate 'numeric' and 'string' names.

The 'newly declared numeric variable' presently being handled will require BC spaces in the variables area for its name and its value. The room is made available and the name of the variable is copied over with the characters being 'marked' as required.

The 'extra' codes of a long name are passed to the variables area.

The last code of a 'long' name has to be ORed with +80.

The first letter of the name of the variable being handled is now considered.

The subroutine L_FIRST is now called to enter the 'letter' into its appropriate location.

The 'last value' can now be transferred to the variables area. Note that at this point HL always points to the location after the five locations allotted to the number.

A 'RST $28' instruction is used to call the calculator and the 'last value' is deleted. However this value is not overwritten.

Come here if considering a variable that 'exists already'. First bit 6 of FLAGS is tested so as to separate numeric variables from string or array of string variables.

For numeric variables the 'new' number overwrites the 'old' number. So first HL has to be made to point to the location after the five bytes of the existing entry. At present HL points to the location before the five bytes.

The parameters of the string variable are fetched and complete simple strings separated from 'sliced' strings and array strings.

When dealing with a 'slice' of an existing simple string, a 'slice' of a string from an array of strings or a complete string from an array of strings there are two distinct stages involved. The first is to build up the 'new' string in the work space, lengthening or shortening it as required. The second stage is then to copy the 'new' string to its allotted room in the variables area.

However do nothing if the string has no 'length'.

Then make the required number of spaces available in the work space.

The parameters of the string being handled are now fetched from the calculator stack.

Note: at this point the required amount of room has been made available in the work space for the 'variable in assignment'; e.g. for the statement 'LET A$(4 TO 8)="abcdefg"' five locations have been made.

The parameters fetched above as a 'last value' represent the string that is to be copied into the new locations with Procrustean lengthening or shortening as required.

The length of the 'new' string is compared to the length of the room made available for it.

As long as the new string is not a 'null string' it is copied into the work space. Procrustean lengthening is achieved automatically if the 'new' string is shorter than the room available for it.

The values that have been saved on the machine stack are restored.

The following short subroutine is used to pass either a numeric value from the calculator stack, or a string from the work space, to its appropriate position in the variables area.

The subroutine is therefore used for all except 'newly declared' simple strings and 'complete and existing' simple strings.

When handling a 'complete and existing' simple string the new string is entered as if it were a 'newly declared' simple string before the existing version is 'reclaimed'.

'Newly declared' simple strings are handled as follows:

The parameters of the 'new' string are fetched, sufficient room is made available for it and the string is then transferred.

The following subroutine is entered with the letter of the variable, suitably marked, in the A register. The letter overwrites the 'old +80-byte' in the variables area. The subroutine returns with the HL register pair pointing to the 'new +80-byte'.