Applesoft BASIC Quick Reference

This is intended as a quick reference for the Applesoft BASIC in JavaScript by Joshua Bell.

Extensions beyond Applesoft BASIC are called out with footnotes.

See also:

Statements

Variable Control

CLEAR
Clear all variables
[LET] var = expr
Assign variable
DIM var( size [ , size2 ...] ) [ , var2( size [ , size2 ...] ) ... ]
Allocate array
DEF FN f(var ) = expr
Define function of a single variable [1]

Flow Control

GOTO
Go to line number
GOSUB line
Go to subroutine
RETURN
Return from subroutine
ON expr GOTO line [, line2 ... ]
Branch based on index (value = 1, 2, ...)
ON expr GOSUB line [, line2 ... ]
Subroutine branch based on index (value = 1, 2, ...)
POP
Convert last gosub into a goto
FOR var = start TO end [ STEP incr ]
Loop with counter variable
NEXT [var [, var ...] ]
End of loop(s)
IF expr THEN statement
IF expr GOTO line
Conditional; if expr is false, rest of line is skipped
END
Terminate program
STOP
Break, as if an error occurred

Error Handling

ONERR GOTO line
Set error hook
RESUME
Retry line that caused ONERR GOTO

Input/Output

PRINT expr [ [;,] expr2 ... ] [;]
Output text
INPUT [string ;] var [, var2 ... ]
Read line of input
GET var
Read single key
HOME
Clear text display
HTAB expr
Position text cursor horizontally
VTAB expr
Position text cursor vertically
INVERSE
Set output mode to black-on-white
FLASH
Set output mode to flashing
NORMAL
Set output mode to white-on-black
TEXT
Set display to text mode

Miscellaneous

REM [ comment ]
Begin a comment; rest of line is skipped
TRACE
Turn on trace mode (line numbers printed)
NOTRACE
Turn off trace mode

Inline Data

DATA value [, value2 ... ]
Define inline data
READ var [, var2 ... ]
Read the next DATA value
RESTORE
Restore the DATA pointer to the first value

Lo-Res Graphics

GR
Set display to lores mode, clear screen
COLOR= expr
Set lores color (0...15)
PLOT expr, expr
Plot lores point (x = 0...39, y = 0...40/48)
HLIN expr, expr AT expr
Plot horizontal line (x1, x2 at y)
VLIN expr, expr AT expr
Plot vertical line (y1, y2 at x)

Hi-Res Graphics

HGR
Set display to hires mode, clear screen
HGR2
Set display to hires mode (page 2), clear screen
HPLOT [TO] expr, expr [ TO expr, expr ] ...
Plot hires point/line (x=0...279, y=0...191)
HCOLOR= expr
Set hires color (0...7)

Hi-Res Shape Tables - NOT IMPLEMENTED

ROT= expr
Set hires shape table rotation (0...63)
SCALE= expr
Set hires shape table scale (1...255)
DRAW expr [ AT expr, expr ]
Draw hires shape table shape in color
XDRAW expr [ AT expr, expr ]
Draw hires shape table shape with XOR

Interpreter and Program State - NOT IMPLEMENTED

CONT
Continue from a STOP
DEL
Delete lines of program
LIST [ expr [, expr ] ]
List lines of program
NEW
Clear program and variables
RUN [ expr ]
Start program execution at line

Native Platform Interaction - NOT IMPLEMENTED

HIMEM: expr
Set upper address of variable memory
IN# expr
Direct input from slot
LOMEM: expr
Set lower address of variable memory
WAIT expr, expr [, expr]
Wait until memory location masked by second argument equals third argument (or zero)

Cassette Tape - NOT IMPLEMENTED

LOAD
Load program from cassette
RECALL
Load variables from cassette
SAVE
Save program to cassette
STORE
Save variables to cassette
SHLOAD
Load hires shape table from cassette

Compatibility Shims

SPEED= expr
Set character output delay - has no effect
POKE expr, expr
Set memory location to value
CALL expr
Call native routine
PR# expr
Direct output to slot

Functions

Numeric Functions

ABS( expr )
Absolute value of number
ATN( expr )
Arctangent of number
COS( expr )
Cosine of number
EXP( expr )
Raise e to number
INT( expr )
Integer part of number
LOG( expr )
Natural log of number
RND( expr )
Pseudo-random number generator (0 repeats last, negative reseeds)
SGN( expr )
Sign of number (-1,0,1)
SIN( expr )
Sine of number
SQR( expr )
Square root of number
TAN( expr )
Tangent of number

String Functions

LEN( expr )
Length of string
LEFT$( expr, expr )
Left portion of (string, length)
MID$( expr, expr [, expr] )
Substring of (string, start character, length)
RIGHT$( expr, expr )
Right portion of (string, length)

Type Conversion Functions

ASC( expr )
ASCII code for first character of string
CHR$( expr )
Character at specified ASCII code point[3]
STR$( expr )
String representation of number
VAL( expr )
Parse string into number

System Interaction Functions

FRE( expr )
Garbage collect strings (returns 0)
PDL( expr )
Paddle position (paddle number)
POS( expr )
Horizontal cursor position
SCRN( expr, expr )
Lores color at pixel (x,y)
HSCRN( expr, expr )
Hires color at pixel (x,y)[4]
USR( expr )
Execute assembly code at address, return accumulator value - NOT IMPLEMENTED

User Defined Functions

FN f( expr )
Execute user defined function [1]

Function Compatibility Shims

PEEK( expr )
Value at memory location

Operators

Comparison Operators

=
Equality[2]
<
Less than
>
Greater than
<=
=<
Less than or equal
>=
=>
Greater than or equal
<>
><
Not equal

Boolean Operators

AND
Conjunction
OR
Disjunction
NOT
Negation

Arithmetic Operators

^
Exponentiation
*
Multiplication
/
Division
+
Addition
-
Subtraction

String Operators

+
String Concatenation

Error Codes

Error codes can be determined by calling PEEK(222) in an ONERR handler.

0
Next without for
16
Syntax error - Not generated
22
Return without gosub
42
Out of data
53
Illegal quantity
69
Overflow
77
Out of memory - Not generated by all browsers
90
Undefined statement
107
Bad subscript
120
Redimensioned array
133
Division by zero
163
Type mismatch
176
String too long - Not generated
191
Formula too complex - Not generated by all browsers
224
Undefined function
254
Re-enter
255
Break

DOS 3.3 / ProDOS Quick Reference

See also

DOS Commands

MON[,C][,I][,O]
Traces DOS 3.3 commands ('Commands', 'Input' and 'Output')
NOMON[,C][,I][,O]
Cancels tracing of DOS 3.3 commands ('Commands', 'Input' and 'Output')
OPEN filename[,Llen]
Opens a text file.
APPEND filename
Appends to a text file.
CLOSE [filename]
Closes specified (or all) open text files.
POSITION filename[,Rnum]
Advances position in text file.
READ filename[,Rnum][,Bbyte]
Reads from a text file.
WRITE filename[,Rnum][,Bbyte]
Writes to a text file
DELETE filename
Delete a file
RENAME oldname,newname
Rename a file
PR# slot
Same as the BASIC command

Other DOS commands are NOT IMPLEMENTED.

Some sample files are present in a server-side store loaded on-demand into a client-side virtual file system (VFS). Creating or writing to a file will write to the VFS. Subsequent reads will read from the VFS. Files may be deleted from the VFS. These changes will not persist if the browser is refreshed or closed.

DOS Error Codes

Error codes can be determined by calling PEEK(222) in an ONERR handler.

1
Language not available - Not generated
2
Range error - Not generated
4
Write protected - Not generated
5
End of data
6
File not found
7
Volume mismatch - Not generated
8
I/O error - Not generated
9
Disk full - Not generated
10
File locked - Not generated
11
Invalid option
12
No buffers available - Not generated
13
File type mismatch - Not generated
14
Program too large - Not generated
15
Not direct command - Not generated

Input and Output

Input

The page attempts to emulate an Apple II keyboard. Note that the keyboard API available in Web browsers is not standardized and is poorly defined; a best-effort has been made testing on available systems and browsers.

The Open Apple and Closed Apple keys on later Apple II models correspond to the Button #0 and Button #1 inputs and are emulated on modern keyboards with the Home and End keys respectively. (Unfortunately, browsers are currently unable to distinguish the left and right Alt or Command keys.)

Since the Tab key is necessary for keyboard access to browser functions and the rest of the web page, it is not available. Otherwise, special keys can be detected using GET (blocking) or PEEK(49152) (non-blocking):

CHR$(8)Left arrow
CHR$(10)Down arrow
CHR$(11)Up arrow
CHR$(13)Enter or Return
CHR$(21)Right arrow
CHR$(24)Clear
CHR$(27)Escape
CHR$(127)Delete or Backspace

Output

The page attempts to emulate the display of an Apple II system with 80-column card firmware, which can be activated with the PR#3 statement.

When printing characters, CHR$ functions as expected for values from 32-126 (printable ASCII). Control characters have the typical Apple II meanings:

CHR$(4)DOS command escape prefix
CHR$(7)Make a "beep" (if your browser supports it)
CHR$(8)Backspace (move cursor left, wrap up)
CHR$(10)Line feed (move cursor down)
CHR$(13)Carriage return (move cursor down and to left edge)
CHR$(127)Displays a cursor glyph

If 80-column firmware is active, the following additional codes are available:

CHR$(11)Clears from the cursor position to the end of the window
CHR$(12)Move cursor to upper left and clear window
CHR$(14)Set normal text output
CHR$(15)Set inverse text output
CHR$(17)Set display to 40 columns
CHR$(18)Set display to 80 columns
CHR$(21)Deactivate the 80-column firmware
CHR$(22)Scroll display down, preserving cursor position
CHR$(23)Scroll display up, preserving cursor position
CHR$(24)Disable mousetext
CHR$(25)Move cursor to upper left (but don't clear window)
CHR$(26)Clear the current line
CHR$(27)Enable mousetext
CHR$(28)Forward space (move cursor right, wrap down)
CHR$(29)Clear from cursor position to end of line

The text window can be changed and cursor finely controlled with POKE 32,n ... POKE 37,n

Process and Grammars

For the even geekier in the audience...

Compilation is done by splitting the input into tokens which are then consumed by a recursive descent parser which outputs a JavaScript object representing the program.

The token types (treated as terminals) are reserved, identifier, string-literal, number-literal, operator, line-number, separator, remark, data-declaration - take a peek at the code if you want the gruesome details. Source lines may only start with line numbers or (as an extension) separators. Special statement parsing is done while lexing: REM consumes anything to the next line break, and DATA statements yeild an array of strings from the comma-delimited, optionally-quoted values in the source.

Overall program parsing is done with a recursive descent parser.

    Program                  = Line { Line }
    Line                     = line-number Statement { separator Statement }
    Statement                = data-declaration | remark | Command | EmptyStatement
    Command                  = identifier /*...*/ | reserved /*...*/

Statements ("commands" in the above grammar) are parsed with distinct cases for each statement type. Most statements compile into a function call to a library of Applesoft routines. Expressions are parsed with a standard recursive descent parser. The parser generates JavaScript expressions for each expression, which are used as arguments for the library calls.

    Expression               = OrExpression
    OrExpression             = AndExpression [ 'OR' AndExpression ... ]
    AndExpression            = RelationalExpression [ 'AND' RelationalExpression ... ]
    RelationalExpression     = AdditiveExpression [ ( '=' | '<' | '>' | '<=' | '=<' | '>=' | '=>' | '<>' | '><' ) AdditiveExpression ... ]
    AdditiveExpression       = MultiplicativeExpression [ ( '+' | '-' ) MultiplicativeExpression ... ]
    MultiplicativeExpression = PowerExpression [ ( '*' | '/' ) PowerExpression ... ]
    PowerExpression          = UnaryExpression [ '^' UnaryExpression ]
    UnaryExpression          = ( '+' | '-' | 'NOT' ) UnaryExpression
                              | FinalExpression
    FinalExpression          = number-literal
                              | string-literal
                              | 'FN' user_function_name '(' Expression ')'
                              | reserved '(' Expression [, Expression ...] ')'
                              | identifier [ '(' Expression [, Expression ...] ')' ]
                              | '(' Expression ')'

Since Applesoft supports re-entrant error handling and synchronous input, the output of the compiler is an array of statement-functions plus a driver function which implements the logic for walking over the array.

Extensions beyond Standard Applesoft