Upload
paul-cockshott
View
229
Download
0
Embed Size (px)
Citation preview
8/2/2019 Tiny Basic
1/31
Tiny BasicA minimal langue for experimenting with
8/2/2019 Tiny Basic
2/31
History
Basic was introduced in 1964 at
Dartmouth college in the US as one of the
first computer timesharing systems that
allowed students to actually log on to anduse a computer interactively.
It ran on mainframe computers with
teletype terminals attached.
It was an interpretive language so that asyou typed commands in it stored them
and then executed them when you said
RUN
8/2/2019 Tiny Basic
3/31
IBM 5100
In 1975 IBM introduced the
5100, the first personal
computer with built in screen
and storage.
It had the option of being
supplied either with Basic or
with APL another interpretive
language.
Expensive and not widely used.
8/2/2019 Tiny Basic
4/31
PET
Launched in 1977 the PET was the first
successful mass market personal
computer. It again came with Basic as
an interpreter.
Much cheaper due to use of 8 bit
microprocessors.
8/2/2019 Tiny Basic
5/31
Tiny Basic
Tiny basic was developed by amateurs
wanting a small programming language
that would fit into 2 kilobytes of ROM
which was a standard cheap ROM chip in
1977. It ran on hobby machines like the
Altair ( top left) and can still be obtained
for contemporary hobby machines like the
TinyBrick computer (bottom left)
A version Ti Basic also run on some
calculators like the TI-83 on the right which
use the Z80 chip used on early PCs
8/2/2019 Tiny Basic
6/31
Features of the language : line numbers
Here is a very simple Tiny Basic
programme
10 FOR I := 1 TO 5
20 PRINT I30 NEXT I
40 END
The language has numbered lines which
should go up in ascending order. On aninterpreter the line numbers normally
substitute for an editor, allowing you to
replace individual lines
8/2/2019 Tiny Basic
7/31
Control structure
The version you will be working with is very
simple it only has three control structures:
For loops
Goto statements If statements
8/2/2019 Tiny Basic
8/31
For loops
A FOR loop has the structure
10 FOR I := 1 TO 100
20 LET A := I+A
30 NEXT I The lines between the FOR and the NEXT
lines are executed 100 times in this case.
For loops can be nested provided that
each loop uses a different iterationvariable.
8/2/2019 Tiny Basic
9/31
Jumps
An unconditional jump to another line can
be done using the GOTO statement, a
conditional jump can be done using an IF
statement which transfers to another line.
10 IF A>B THEN 30
20 GOTO 40
30 PRINT A
35 GOTO 5040 PRINT B
50 END
8/2/2019 Tiny Basic
10/31
Input output
There are 3 input output commands
supported in the version of basic you will
be working with, shown below. They allow
reading and writing of integers.
10 READ I
20 PRINT 2*I
30 PRINTLN
40 END
8/2/2019 Tiny Basic
11/31
LET statements
The LET keyword allows you to perform
assignments to variables
320 LET J:= I*2+1
There is no need to declare variables. Inthe original Basic variables were either
single letters, or a letter followed by a digit
thus P,S,N1, Q9, T would all be valid
In many Tiny Basic systems only a singleletter is used.
8/2/2019 Tiny Basic
12/31
Statements not currently implemented
REM allows comments
GOSUB and RETURN allow for
subroutines
DIM allows for array variables.10 DIM A(10)
20 GOSUB 100
30 PRINT S
100 REM calculate sum in A105 FOR I:= 1 TO 10
110 LET S:= S+A(I)
120 NEXT I
130 RETURN
8/2/2019 Tiny Basic
13/31
Your tasks
You will be working with a Basic compiler
that I have written and will have to modify
it to extend the language slightly
1. Allow variables to be strings of letters anddigits starting with a letter
2. Add the REM statement to the language
to allow comments
3. Add the DIM statement and support forarray indexing to the language.
8/2/2019 Tiny Basic
14/31
Interpret or compile
The early versions of Basic were all
interpreters, that is to say the statements
were translated into equivalent machine
operations every time they were executed.
Advantages of interpreters
Allow interactive use
Can be implemented in very little code
Advantage of compilers
Allow much faster execution once programme
is compiled
8/2/2019 Tiny Basic
15/31
Phases of translation
Both interpreters and compilers share the
first two tasks
1. Lexical analysis recognising keywords,
variables etc
2. Syntax analysis checking the grammar
They differ in the way they cause
execution to take place. In an interpreter a
computed jump is performed to a routine
that will execute a particular type ofstatement. In a compiler a sequence of
machine instructions are output.
8/2/2019 Tiny Basic
16/31
Outline data flow
10 LET A:=12
tokenizer
000a 06 82 41 91 92 000C
dispatcher
line len
Code
for let
A
Code
for :=Code for
number
Number 12
Note codes are above hex
80 decimal 128, and thusoutside ASCII range
8/2/2019 Tiny Basic
17/31
Why tokenize
It performs data compression so the
tokenized programme takes up less space
in memory this used to be very
important
It allows faster interpretation since what is
being interpreted is now a byte code
which can be interpreted by a simple
mechanism.
Note that in Basic the semantics are
always defined by the first token.
8/2/2019 Tiny Basic
18/31
Word to token translation table
word Token
GOTO 80HIF 81H
LET 82H
NEXT 83H
PRINT 84H
etc
Note codes are above
80H decimal 128, and thus
outside ASCII range
8/2/2019 Tiny Basic
19/31
Tokenizing Keyboard
On small computers and calculators thetokenizer was sometimes integrated into
the keyboard scanning software so that
it directly returned a token for a single
key stroke, so that for example SHIFT P
generated the PRINT token.
8/2/2019 Tiny Basic
20/31
How a Basic interpreter worked
We will look at how an interpreter would have worked on theoriginal IBM PC with the following hardware registers
8/2/2019 Tiny Basic
21/31
A few basic reminders about assembler
Assembler works on machine registers
On Intel assemblers the mov instruction moves data
mov ax,[varstart]
Means load the ax register with the word at label
varstart
Mov ax, [si]
Means move the ax register with the word pointed
to by si register
Mov ax, [si*2+mylab] Means mov the word at address 2*si+varstart into
ax
Case is not significant in opcodes or register names
8/2/2019 Tiny Basic
22/31
arithmetic
Add ax, varstart
Means add the address of label varstart to
ax
sub ax,[si] Means ax = ax- memory[si ]
Add ax, si
Means add the si register to ax
8/2/2019 Tiny Basic
23/31
How the dispatcher works
000a 06 82 41 91 92 000Cline
len
Code
for let
A
Code
for :=Code for
number
Number 12
SI register
dispatchtabgotoaddr
ifaddr
letaddr
Code to
handle LET
8/2/2019 Tiny Basic
24/31
How the dispatcher works
Reserve a register as the interpreter PC (for example the SI )
register, assume we are pointing at the first token of a linenextstatement: ; dispatch routine
movsb ax, [si] ; get the token
inc si ; move pc on
jmp [ax*2+dispatchtab-2*80h] ; jump to routine
; we subtract 2*80h from the address since codes; start at 80h
dispatchtab :
dw gotoaddr
dw ifaddr
dw letaddr
This shows the typical feature of a fast interpreter, a smallshort sequence of assembly code that performs rapid
dispatch to interpretive routines using byte codes.
Only 3 instructions are used to do the dispatch
8/2/2019 Tiny Basic
25/31
An interpret routine for Let
letaddr:
call checkletter ; checks it is a letter
push ax ; address of var in ax
call checkcoleq ; look for a :=
call expression ; evaluate expression
; result in ax
pop di ; recover the address
mov [di],ax ; do the assignment
jmp advance ; this moves to the
; next line
Note that the interpreter is made up of a sequence of calls
to routines that do subsidiary matching tasks to
recognise
. :=
Bold means an
instruction that
does REAL work
8/2/2019 Tiny Basic
26/31
Checking for letters
checkletter:
movxb ax,[si] ; get next char into ax register
sub al,A ; subtract letter A
jle notletter ; if negative was not a letter
cmp al, 26 ; compare with 26
jge notletter ; if al>=26 not a letter; ax now in range 0..25
inc si ; move past the letter
add ax,ax ; map to range 0..50
add ax, varstart; add the start address of the
; variables in memory
return
8/2/2019 Tiny Basic
27/31
Expressions
Suppose we define an expression to be
either
1. An identifier : A, B etc
2. A number : 1, 14 etc3. An expression followed by an operator
followed by another expression: A+1, B-C
etc
4. An expression in brackets : ( A+9)The interpreter routine for expressions must
recognise these cases
8/2/2019 Tiny Basic
28/31
Expression code
expression:
cmp [si],( ; check for (jneq nobracket
inc si ; found it so move past
call expression ; must be an expression
cmp [si],) ; check we have )
jneq error ; othewise it is an errorinc si ; move past
jmp checkop ; go look for an operator
nobracket:
cmp [si],numprefix; check for number prefix
jneq mustbeletter ; look for a lettermov ax,[si+1] ; assume the number follows
add si ,3 ; move pointer past it
jmp checkop ; go look for an operator
8/2/2019 Tiny Basic
29/31
Doing actual arithmetic
At this point we have the expression value so far in
the ax register. We will only look for + and here, you
can imagine the other operations
Checkop: cmp [si],+
jne tryminusinc si ; move past
push ax ; save value so far
call expression; look for another expression
pop di ; get back first value
add ax,di ; add to the secondreturn ; with result in ax
tryminus: cmp [si],-
etc etc
Bold means an
instruction that
does REAL work
8/2/2019 Tiny Basic
30/31
Efficiency
I have obviously only given you a part of
an interpreter here but it is enough to
show several things
1. The style of tight hand coded assemblerthat they typically used allowed a very
small interpreter.
2. The way the code is structured by the
syntax of the Basic
3. That you are lucky if one instruction in 10
or 20 does real computational work, rather
than parsing and checking
8/2/2019 Tiny Basic
31/31
Motivation for compiling
The major motivation is to get greater
speed.
Against this the complexity of a compiler
is much greater, both the size of thecompiler and the number of tools needed
to build it.
Also you have a slower debug cycle time
for programmes: edit, compile, run instead
of just edit, run