EhBASIC represents hundreds of hours work over nearly three years, lots of frustration, lots of joy and the occasional twinge from RSI induced tendonitis.

EhBASIC is free but not copyright free. For non commercial use there is only one restriction, any derivative work should include, in any binary image distributed, the string “Derived from EhBASIC” and in any distribution that includes human readable files a file that includes the above string in a human readable form e.g. not as a comment in

• Update
• Requirements
• Language reference
• EhBASIC reference manual in PDF format
• How to use
• Starting BASIC
• Advanced techniques
• Extending CALL
• Using USR()
• Useful routines
• Internals
• Download version 2.09
• Download the latest original version 2.22, with some extra information by Klaus Dormann, fixing bugs 
• EhBASIC bug Ibuffs location
• Jeff trantor made a CC65 assemblerversion of EhBASIC 2.22 for the Apple 1 and OSI 1P
• Notes on LOAD and SAVE

With the change to v2.xx a lot of the details for the use and internal working of EhBASIC have changed!

• Square calculator Calculates a 16-bit unsigned integer square
• Root calculator Calculates the 8-bit root of a 16-bit integer
• Ring buffer Setting up an interrupt serviced buffer
• Pseudo random Generating 8-bit pseudo random numbers

Square Calculator

This routine calculates the 16-bit unsigned integer square of a signed 16-bit integer in the range +/-255 (decimal).

; by Lee Davison; Calculates the 16 bit unsigned integer square of the signed 
; 16 bit integer in Numberl/Numberh.
; The result is always in the range 0 to 65025 and is held in Squarel/Squareh
;
; The maximum input range is only +/-255 and no checking is done to ensure that
; this is so.
;
; This routine is useful if you are trying to draw circles as for any circle
;
; x^2+y^2=r^2 where x and y are the co-ordinates of any point on the circle and
; r is the circle radius
;
; Destroys all registers

	.ORG	8000		; these must be in RAM

Numberl				; number to square low byte
Numberh	= Numberl+		; number to square high byte
	.word $FFFF

Squarel				; square low byte
Squareh	= Squarel+1		; square high byte
	.word $FFFF

Tempsq				; temp byte for intermediate result
	.byte $00

	.ORG	8192		; any address will do

Square
	LDA	#$00		; clear A
	STA	Squarel		; clear square low byte
				; (the high byte gets shifted out)
	LDA	Numberl		; get number low byte
	LDX	Numberh		; get number high byte
	BPL	NoNneg		; if +ve don't negate it
				; else do a two's complement
	EOR	#$FF		; invert
	SEC			; +1
	ADC	#$00		; and add it

NoNneg:
	STA	Tempsq		; save ABS(number)
	LDX	#$08		; set bit count

Nextr2bit:
	ASL	Squarel		; low byte *2
	ROL	Squareh		; high byte *2+carry from low
	ASL	A		; shift number byte
	BCC	NoSqadd		; don't do add if C = 0
	TAY			; save A
	CLC			; clear carry for add
	LDA	Tempsq		; get number
	ADC	Squarel		; add number^2 low byte
	STA	Squarel		; save number^2 low byte
	LDA	#$00		; clear A
	ADC	Squareh		; add number^2 high byte
	STA	Squareh		; save number^2 high byte
	TYA			; get A back

NoSqadd:
	DEX			; decrement bit count
	BNE	Nextr2bit	; go do next bit
	RTS

Square Root Calculator

This routine calculates the 8-bit integer square root and 9 bit integer remainder of an unsigned 16-bit integer.

; by Lee Davison
; Calculates the 8 bit root and 9 bit remainder of a 16 bit unsigned integer in	
; Numberl/Numberh. The result is always in the range 0 to 255 and is held in
; Root, the remainder is in the range 0 to 511 and is held in Reml/Remh
;
; partial results are held in templ/temph
;
; This routine is the complement to the integer square program.
;
; Destroys A, X registers.

; variables - must be in RAM

Numberl		= $F0		; number to find square root of low byte
Numberh		= Numberl+1	; number to find square root of high byte
Reml		= $F2		; remainder low byte
Remh		= Reml+1	; remainder high byte
templ		= $F4		; temp partial low byte
temph		= templ+1	; temp partial high byte
Root		= $F6		; square root

	*= $8000		; can be anywhere, ROM or RAM

SqRoot
	LDA	#$00		; clear A
	STA	Reml		; clear remainder low byte
	STA	Remh		; clear remainder high byte
	STA	Root		; clear Root
	LDX	#$08		; 8 pairs of bits to do
Loop
	ASL	Root		; Root = Root * 2

	ASL	Numberl		; shift highest bit of number ..
	ROL	Numberh		;
	ROL	Reml		; .. into remainder
	ROL	Remh		;

	ASL	Numberl		; shift highest bit of number ..
	ROL	Numberh		;
	ROL	Reml		; .. into remainder
	ROL	Remh		;

	LDA	Root		; copy Root ..
	STA	templ		; .. to templ
	LDA	#$00		; clear byte
	STA	temph		; clear temp high byte

	SEC			; +1
	ROL	templ		; temp = temp * 2 + 1
	ROL	temph		;

	LDA	Remh		; get remainder high byte
	CMP	temph		; comapre with partial high byte
	BCC	Next		; skip sub if remainder high byte smaller

	BNE	Subtr		; do sub if <> (must be remainder>partial !)

	LDA	Reml		; get remainder low byte
	CMP	templ		; comapre with partial low byte
	BCC	Next		; skip sub if remainder low byte smaller

				; else remainder>=partial so subtract then
				; and add 1 to root. carry is always set here
Subtr
	LDA	Reml		; get remainder low byte
	SBC	templ		; subtract partial low byte
	STA	Reml		; save remainder low byte
	LDA	Remh		; get remainder high byte
	SBC	temph		; subtract partial high byte
	STA	Remh		; save remainder high byte

	INC	Root		; increment Root
Next
	DEX			; decrement bit pair count
	BNE	Loop		; loop if not all done

	RTS

256-Byte Data Buffer

This routine is an interrupt serviced 256 byte data buffer for serial ports and the like.
Very similar code was used to supply the stepper motor driver routine with line co-ordinate pairs.
This is not a finished solution, you will need to add your own code to drive the target of the buffer.

; By Lee Davison
; code for an interrupt serviced data buffer. similar code is used to drive
; the XY stepper motors on a plotter with new position information every 5mS
; and also to allow pen up/down movement time of 70mS

; buffer and variables must be in RAM

Buffer				; 256 byte buffer (must start at page edge)
	.ds	$100

BRindx				; buffer read index
	.byte	$00

BWindx				; buffer write index
	.byte	$00

Sendf				; am sending flag
	.byte	$00

WByte				; temp store for the byte to be sent
	.byte	$00

; write the data to the buffer a byte at a time and increment the pointer.
; the routine is called with the byte to write in A. If the interrupt
; device is idle when this routine is called it will wake it up by doing
; a BRK before it exits

; destroys the Y register

; can be ROM or RAM

Incwritb
	STA	WByte		; save byte to write
	LDA	BRindx		; get read index
	SEC			; set carry for subtract
	SBC	BWindx		; subtract write index
	BEQ	Dowrite		; if equal then buffer empty so do write
	CMP	#$02		; need at least n+1 bytes to avoid rollover
	BCC	Incwritb	; loop if no space


				; construct and write data to buffer
Dowrite
	LDY	BWindx		; get write index
	LDA	WByte		; get byte to write
	STA	Buffer,Y	; save it
	INY			; increment index to next byte
	STY	BWindx		; save new write index byte

; now see if the interrupt service routine is already running or if it's
; idle

	LDA	Sendf		; get the sending flag
	BNE	Doingit		; skip call if running
	BRK			; software call to interrupt routine
	NOP			; need this as return from BRK is +1 byte!
	CLI			; enable the interrupts

Doingit
	RTS				

; this is the interrupt service routine. takes a byte a time from the
; buffer and does some thing with it. also sets up the device(s) for
; the next interrupt

; no registers altered

BuffIRQ
	PHA			; save A
	TXA			; copy X
	PHA			; save X
	TYA			; copy Y
	PHA			; save Y

; insert code here to ensure this is the interrupt you want. if it
; isn't then just exit quietly via ResExit the end of the routine

Getnext
	JSR	Increadb	; increment pointer and read byte from buffer
	BCS	ExitIRQ		; branch if no byte to do

; here would be the guts of the routine such as sending the byte to
; the ACIA or a printer port or some other byte device. it will also
; ensure the device is set to generate an interrupt when it's completed
; it's task

	LDA	#$FF		; set byte
	STA	Sendf		; set sending flag
	JMP	ResExit		; restore the registers & exit

				; all done, clear the flag restore the
				; registers & exit
ExitIRQ
	LDA	#$00		; clear byte
	STA	Sendf		; clear sending flag

ResExit
	PLA			; pull Y
	TAY			; restore it
	PLA			; pull X
	TAX			; restore it
	PLA			; restore A
	RTI			; this was an interrupt service request
				; so exit properly

; get byte from the buffer and increment the pointer. If the buffer is empty
; then exit with the carry flag set else exit with carry clear and the byte
; in A

Increadb
	LDY	BRindx		; get buffer read index
	CPY	BWindx		; compare write index
	BEQ	NOktoread	; branch if empty (= sets carry)
	LDA	Buffer,Y	; get byte from buffer
	INY			; increment pointer
	STY	BRindx		; save buffer read index
	CLC			; clear not ok flag

NOktoread
	RTS

6502 8 bit PRNG

This is a short piece of code that generates a maximal length, 8 bit, pseudo random
number sequence. This routine is no great shakes in the speed stakes, it’s just a demo of a usefull
technique.

; by Lee Davison
; returns pseudo random 8 bit number in A. Affects A, X and Y.
; (r_seed) is the byte from which the number is generated and MUST be
; initialised to a non zero value or this function will always return
; zero. Also r_seed must be in RAM, you can see why......

rand_8
	LDA	r_seed		; get seed
	AND	#$B8		; mask non feedback bits
				; for maximal length run with 8 bits we need
				; taps at b7, b5, b4 and b3
	LDX	#$05		; bit count (shift top 5 bits)
	LDY	#$00		; clear feedback count
F_loop
	ASL	A		; shift bit into carry
	BCC	bit_clr		; branch if bit = 0

	INY			; increment feedback count (b0 is XOR all the	
				; shifted bits from A)
bit_clr
	DEX			; decrement count
	BNE	F_loop		; loop if not all done

no_clr
	TYA			; copy feedback count
	LSR	A		; bit 0 into Cb
	LDA	r_seed		; get seed back
	ROL	A		; rotate carry into byte
	STA	r_seed		; save number as next seed
	RTS			; done

r_seed
	.byte	1		; prng seed byte (must not be zero)

Other number lengths
A maximal length pseudo random number generator is basically just a shif register with feedback from the later stages to generate the next input bit. The form for a generator of length n with feedback from t is shown below.
Pseudo random sequence generator

You don’t have to limit the length to only 8 bits, any number of bits from two upwards will work if you chose the right feedback tap(s). Here is a table of some values.

In the last case, with 31 bits, if you took a new value once a second the sequence
wouldn’t repeat for over sixty eight years. Even clocked at 1MHz it would still take
over thirty five minutes to cycle through every state.
Faster, shorter method
The above pseudo random number generator is known as a Fibonacci generator and, while it works, it turns out there is a much better generator to implement with a microprocessor.

Galois pseudo random sequence generator.

The Galois generator needs only to test the state of one bit and that can be tested after
the shift has been performed. The state of this bit determines whether the feedback term
is exclusive ORed with the result. This single bit test and multiple bit feedback is
easily done as can be seen from the code below.

; returns pseudo random 8 bit number in A. Affects A. (r_seed) is the
; byte from which the number is generated and MUST be initialised to a
; non zero value or this function will always return zero. Also r_seed		
; must be in RAM, you can see why......

rand_8
	LDA	r_seed		; get seed
	ASL			; shift byte
	BCC	no_eor		; branch if no carry

	EOR	#$CF		; else EOR with $CF
no_eor
	STA	r_seed		; save number as next seed
	RTS			; done

r_seed
	.byte	1		; prng seed byte, must not be zero

You don’t have to limit the length to only 8 bits, any number of bits from three upwards will work if you chose the right feedback value. Here is a table of some values that have been chosen to give a feedback value that fits in a byte, this makes implementation on an 8 bit micro as short as possible. For these values bit n is the least significant bit in the value and the tested bit is the bit shifted out from bit 1.

This is now the form of sequence generator used to generate values for the RND() function in EhBASIC.