Elite on the BBC Micro

# Text: ex [Elite-A, Encyclopedia]

```       Name: ex                                                      [Show more]
Type: Subroutine
Category: Text
Summary: Print a recursive token
Context: See this subroutine in context in the source code
References: This subroutine is called as follows:
* TT27 calls ex
* qw calls ex
* LL9 (Part 1 of 12) calls entry point TT48
* LL9 (Part 9 of 12) calls entry point TT48
* TT43 calls entry point TT48
* TT45 calls entry point TT48

This routine works its way through the recursive tokens that are stored in
tokenised form in memory at &0400 to &06FF, and when it finds token number A,
it prints it. Tokens are null-terminated in memory and fill three pages,
but there is no lookup table as that would consume too much memory, so the
only way to find the correct token is to start at the beginning and look
through the table byte by byte, counting tokens as we go until we are in the
right place. This approach might not be terribly speed efficient, but it is
certainly memory-efficient.

For details of the tokenisation system, see variable QQ18.

Arguments:

A                    The recursive token to be printed, in the range 0-148

Other entry points:

TT48                 Contains an RTS

.ex

TAX                    \ Copy the token number into X

LDA #LO(QQ18)          \ Set V(1 0) to point to the recursive token table at
STA V                  \ location QQ18
LDA #HI(QQ18)
STA V+1

LDY #0                 \ Set a counter Y to point to the character offset
\ as we scan through the table

TXA                    \ Copy the token number back into A, so both A and X
\ now contain the token number we want to print

BEQ TT50               \ If the token number we want is 0, then we have
\ already found the token we are looking for, so jump
\ to TT50, otherwise start working our way through the
\ null-terminated token table until we find the X-th
\ token

.TT51

LDA (V),Y              \ Fetch the Y-th character from the token table page
\ we are currently scanning

BEQ TT49               \ If the character is null, we've reached the end of

INY                    \ Increment character pointer and loop back round for
BNE TT51               \ the next character in this token, assuming Y hasn't
\ yet wrapped around to 0

INC V+1                \ If it has wrapped round to 0, we have just crossed
BNE TT51               \ into a new page, so increment V+1 so that V points
\ to the start of the new page

.TT49

INY                    \ Increment the character pointer

BNE TT59               \ If Y hasn't just wrapped around to 0, skip the next
\ instruction

INC V+1                \ We have just crossed into a new page, so increment
\ V+1 so that V points to the start of the new page

.TT59

DEX                    \ We have just reached a new token, so decrement the
\ token number we are looking for

BNE TT51               \ Assuming we haven't yet reached the token number in
\ X, look back up to keep fetching characters

.TT50

\ We have now reached the correct token in the token
\ table, with Y pointing to the start of the token as
\ an offset within the page pointed to by V, so let's
\ print the recursive token. Because recursive tokens
\ can contain other recursive tokens, we need to store
\ our current state on the stack, so we can retrieve
\ it after printing each character in this token

TYA                    \ Store the offset in Y on the stack
PHA

LDA V+1                \ Store the high byte of V (the page containing the
PHA                    \ token we have found) on the stack, so the stack now
\ contains the address of the start of this token

LDA (V),Y              \ Load the character at offset Y in the token table,
\ which is the next character of this token that we
\ want to print

EOR #35                \ Tokens are stored in memory having been EOR'd with 35
\ (see variable QQ18 for details), so we repeat the
\ EOR to get the actual character to print

JSR TT27               \ Print the text token in A, which could be a letter,
\ number, control code, two-letter token or another
\ recursive token

PLA                    \ Restore the high byte of V (the page containing the
STA V+1                \ token we have found) into V+1

PLA                    \ Restore the offset into Y
TAY

INY                    \ Increment Y to point to the next character in the
\ token we are printing

BNE P%+4               \ If Y is zero then we have just crossed into a new
INC V+1                \ page, so increment V+1 so that V points to the start
\ of the new page

LDA (V),Y              \ Load the next character we want to print into A

BNE TT50               \ If this is not the null character at the end of the
\ token, jump back up to TT50 to print the next
\ character, otherwise we are done printing

.TT48

RTS                    \ Return from the subroutine
```