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:

• Apple II Programmer's Reference: Applesoft Commands
• Applesoft BASIC Frequently Asked Questions (FAQ)
• Beagle Bros. Peeks, Pokes & Pointers Chart (Colors, ASCII values, etc)
• More Beagle Bros. Posters — including Apple Commands Chart, in PDF format
• Applesoft Basic Programming Reference Manual

Statements

Functions

Numeric Functions

ABS( aexpr )

Absolute value of number

ATN( aexpr )

Arctangent of number

COS( aexpr )

Cosine of number

EXP( aexpr )

Raise e to number

INT( aexpr )

Integer part of number

LOG( aexpr )

Natural log of number

RND( aexpr )

Pseudo-random number generator. If aexpr is positive, returns a random number from 0 to 0.999.... If aexpr is zero, repeats the last result. If aexpr is negative, reseeds the generator.

SGN( aexpr )

Sign of number (-1, 0, 1)

SIN( aexpr )

Sine of number

SQR( aexpr )

Square root of number

TAN( aexpr )

Tangent of number

String Functions

LEN( sexpr )

Length of string

LEFT$( sexpr, aexpr )

Left portion of (string, length)

MID$( sexpr, aexpr [, aexpr] )

Substring of (string, start character, length)

RIGHT$( sexpr, aexpr )

Right portion of (string, length)

Type Conversion Functions

ASC( sexpr )

ASCII code for first character of string

CHR$( aexpr )

Character at specified ASCII code point [3]

STR$( aexpr )

String representation of number

VAL( sexpr )

Parse string into number

System Interaction Functions

FRE( aexpr )

Garbage collect strings (returns 0)

PDL( aexpr )

Paddle position (paddle number)

POS( aexpr )

Horizontal cursor position

SCRN( aexpr, aexpr )

Lores color at pixel (x,y) [4]

USR( aexpr )

Execute assembly code at address, return accumulator value - NOT IMPLEMENTED

User Defined Functions

FN name( expr )

Execute user defined function [1]

Function Compatibility Shims

PEEK( aexpr )

Value at memory location

• PEEK(32) — Text window left edge
• PEEK(33) — Text window width
• PEEK(34) — Text window top edge
• PEEK(35) — Text window bottom
• PEEK(36) — Text cursor x
• PEEK(37) — Text cursor y
• PEEK(78) & PEEK(79) — Random-Number Field
• PEEK(222) — Last error code
• PEEK(230) — Hi-Res plotting page (32 = page 1, 64 = page 2)
• PEEK(49152) or PEEK(-16384) — Read Keyboard
• PEEK(49168) or PEEK(-16368) — Clear Keyboard strobe
• PEEK(49178) or PEEK(-16358) — See if text mode (> 127) or graphics mode (< 128)
• PEEK(49179) or PEEK(-16357) — See if mixed mode (> 127) or full mode (< 128)
• PEEK(49180) or PEEK(-16356) — See if page2 (> 127) or page1 (< 128)
• PEEK(49181) or PEEK(-16355) — See if hires mode (> 127) or lores mode (< 128)
• PEEK(49182) or PEEK(-16354) — See if mousetext mode (> 127)
• PEEK(49183) or PEEK(-16353) — See if 80-column mode (> 127)
• PEEK(49200) or PEEK(-16336) — Click Speaker (no-op)
• PEEK(49248) or PEEK(-16288) — Read Paddle Button #3 — Use the PageDown key
• PEEK(49249) or PEEK(-16287) — Read Paddle Button #0 — Use the Home key
• PEEK(49250) or PEEK(-16286) — Read Paddle Button #1 — Use the End key
• PEEK(49251) or PEEK(-16285) — Read Paddle Button #2 — Use the PageUp or Shift key

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

Operator Precedence

Operators are listed vertically in order of precedence, from highest to lowest. Operators on the same line are of the same priority, and in an expression are executed from left to right. This order differs from the order in some other dialects of BASIC, but does match Applesoft.

• ( )
• + - NOT           (unary operators)
• ^
• * /
• + -
• = < > <= =< >= => <> ><
• AND
• OR

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

• Apple II DOS & Commands FAQ
• Apple II Textfiles: the DOS 3.3 Anatomy
• Vectronic's Apple World DOS 3.3 and ProDOS Guide

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 Left Alt and Right Alt keys respectively if possible, otherwise the Home and End keys respectively.

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) or PEEK(-16384) (non-blocking):

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:

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

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 [5], 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 yield an array of strings from the comma-delimited, optionally-quoted values in the source.

[x]

zero or one occurences of x

{x}

zero or more occurences of x

x|y

one of either x or y

(x)

grouping construct

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 /*...*/

Due to the irregular structure of the BASIC language, 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 an executor function which implements the logic for walking over the array.

Extensions beyond Standard Applesoft

1. DEF FN supports string and integer functions e.g. DEF FN IN$(X$) = " " + X$ — the return type must match the argument type, so string-to-number or number-to-string functions can not be implemented.
2. "Double equals" == is supported for equality comparisons, with the same meaning as "single equals" =
3. When printing characters, CHR$() values greater than 255 generate glyphs that might be useful for implementing certain maze games. (An earlier version of this page allowed arbitrary Unicode characters to be displayed, but the text is now displayed using bitmaps so that is not possible.)
4. HSCRN(x,y) is added to allow reading the hires screen. On a real Apple II this required a machine-language routine (or a shape table and XDRAW) and extensive knowledge of the Apple II's color generation scheme.
5. Hexadecimal number literals are permitted, with $ as a prefix, e.g. POKE $C010, 0