The question mark, ?, is a BASIC operator to read or change bytes in memory. In this context it is pronounced 'query'. It is equivalent to PEEK and POKE statements in other dialects of BASIC.
|Availability||Present in all original versions of BBC BASIC.|
|Syntax||BASIC I-V|| <num-var> = [<num-var>]|
|Token (hex)||BASIC I-V|| |
|Description||BASIC I-V|| If there are two operands, |
In the first form,
In the second form, the value assigned to
|Associated keywords|| |
? is an operator providing access to the memory of the
machine running BASIC. It allows the contents of memory to be inspected
or changed one byte at a time. A byte is a unit of storage that can
hold a value between 0 and 255. By contrast the
operator acts on a doubleword, or four consecutive bytes.
? can be either a
unary or binary operator. This doesn't depend on whether it is
used to PEEK or POKE, but is a syntactic convenience to help with
handling data structures.
If used as a unary operator, for example
?o7f_block%, then the single operand is used as the effective
If used as a binary operator, for example
o7f_block%?6, then the two operands are added together to
form the effective address. The first operand, conventionally the
base address, must not be a constant. The second operand is the
offset, typically a constant offset into a MOS control block.
Whether unary or binary, the operator will either read or write to memory,
depending on whether it is evaluated as an expression, or assigned a
value. In the latter case the whole [<num-var>]
expression serves as an lvalue, or <num-var>.
?o7f_block% = drive% sets the byte at the
address given by
o7f_block%, to the value of
drive%. Other BASICs would use
result% = o7f_block%?10 fetches the byte ten addresses up
o7f_block%'s value, and returns it to
result%. This translates as
result% = PEEK
o7f_block%+10. (A more common idiom on the BBC Micro is
result% = o7f_block%?(7+o7f_block%?5), which fetches another
byte from the control block to calculate the offset of the result byte.)
The binary operation is the highest priority operation in any expression.
A%?PAGE+4 reads the byte at
(A%+PAGE) and then adds 4 to it.
reads the byte at
Bytes in BBC BASIC are unsigned, that is to say, between 0 and 255. If a
number outside this range is assigned to the
? operator, it
is rounded toward zero and the least significant byte is written to memory
(in two's-complement form if necessary). For instance 1000.1 is written
as 232, -254 becomes 2, and -253.5 is stored as 3.
The BBC Microcomputer User Guide is peppered with warnings about the use
$. They are not to be
used to access memory-mapped devices or the system's internal variables –
at least, not in published programs. The relevant addresses may change or
disappear on different machines and MOS versions, or the program may find
itself running on the other side of the Tube! The MOS offers a
comprehensive API to access system functions in a portable way.
The address space in which
? operates is the one BASIC
chooses to provide for
?. Normally this is the address space
of the processor running BASIC. The BASIC program appears in this space,
TOP, but as mentioned
above, well-behaved programs must not alter it.
BAS128 for the B+ and Master puts the 6502
address space from 0 to &FFFF, and adds an extended space between &10000
and &1FFFF. This is made of the four slots of sideways RAM and
contains the user's program , variables and memory blocks. The MOS cannot
access this space (unless its own extended addressing system is enabled)
and machine code definitely cannot run in it although it can be assembled
OPTions 4 to 7.
? operators cannot be made
LOCAL to, or be
the formal parameters of, procedures or functions. For example,
neither of the following lines are safe:
DEF FNfred(?block%) LOCAL ?temp
In 6502 BASIC I to III, the BASIC stack can only hold integers and strings, not bytes. On entry to the procedure or function, the global value of the byte is saved on the stack as an integer. On exit, this integer is 'restored', overwriting four bytes instead of one. Furthermore it is restored to the wrong address with potentially harmful results.
The bug was fixed in 6502 BASIC III.
! operators are safe to
use in this way from BASIC II onwards.
-- beardo 04:56, 11 October 2007 (BST)