acs                 n1 .. n2
computes the inverse cosine of n1 and
leaves the result as n2 on the stack

allot               n1 ..
Leave n1 bytes empty space between the
last defined word and the next word
that will be defined. Useful for
defining arrays and other data
structures.

arguments            n ..
Internal use only.
Modifies the last defined word to
have n arguments as inline code
when compiled

array               n1 ..
define a vector with n1 elements
(0..n1-1) with a name identical to the
next word typed on the keyboard.

asn                 n1 .. n2
computes the inverse sine of n1 and
leaves the result as n2 on the stack

atn                 n1 .. n2
finds the arctangent of n1 and
leaves result as n2. n2 is in rads

chs                 n1 .. -n1
changes the sign of n1 and leaves the
result as -n1 on the stack

clr              n1 n2 ..
clear the stack

constant            n1 ..
define a constant with value n1. The
name of the constant is the word
entered following constant

cos                 n1 .. n2
computes the cosine of n1 and leaves
the result as n2 on the stack

drop                n1 ..
remove the number at the head of the
stack

dup                 n1 .. n1 n1
duplicate the number at the head of
the stack

else                n1 .. n2
part of a "if ... else ... endif"
construction. The words between
if and else are executed only
if a "1" was at the head of the
stack when the "if" was encountered.
Otherwise, the words between else
and endif are executed.

emit                n1 ..
display the character whose ascii
value is n1

endif
This word ends a list of conditionally
executed words. This list should be
started by the word if

exp                 n1 .. n2
finds e to the power of n1 and leaves
result as n2

forget
forget all definitions defined since
the word entered as the next word on
the keyboard

graphics
switch computer display to graphics
mode

here                   .. n1
Leaves the address immediately
following the last compiled word on
the stack as n1

if
This word starts a conditional
statement of the form:
"if ... endif" or:
"if ... else ... endif"
The words following "if" will
only be executed if a "1" was at
the head of the stack when executing
the "if". The words following else
will be executed if there was no
"1" at the head of the stack.

immediate
Modifies the last defined word to
execute always, even if used inside
a macro definition

initialize
Clear the screen, switch of the stack
display, and display a version header.

inv                 n1 .. n2
computes the inverse of n1 (=1/n1) and
leaves the result as n2 on the stack

jmp                  n ..
Internal use only
This is an unconditional jump, which
will be used by else in future releases

jz                   n ..
Internal use only
This is a conditional jump, used by
if, until etc.

key                    .. n1
wait for a key to be pressed and put
it's ascii value as n1 on the stack

line       n1 n2 n3 n4 ..
display a line from x=n1, y=n2 to
x=n3, y=n4. The line is displayed
with the mode defined by PointMode

list
show a list of all the words defined
in the current BCL image

literal              n ..
Internal use only
This is the word which is compiled
when you type a number inside a macro

ln                  n1 .. n2
compute the natural logarithm of n1
and leave the result as n2

load
load the image file with name xxx.bcl,
with xxx equal to the word entered
following load

log                 n1 .. n2
computes the 10 base logarithm of n1
and leaves the result as n2 on the
stack

noshow
Switch off stack display until the
word "show" is executed

not                 n1 .. n2
if n1 is zero, n2 is one. If n1 not
zero, n2 is zero.

offset              n1 .. n2
computes the size of n1 numbers in
bytes and leaves it on the stack as n2

pi                     .. 3.1415926536
leaves an approximation for the number
pi on the stack

pi/2                   .. n1
leaves a number n1 on the stack equal
to half the value of pi

PointMode           n1 ..
This word can be used to change the
mode in which graphics are displayed.
Useful values for n1 are:
0:  points and lines are black
    (or white on an LCD screen)
1:  points and lines are white
    (or black on an LCD screen)
129:points and lines are inverted
    (white becomes black and
     vice versa)

point            n1 n2 ..
display the pixel at x=n1, y=n2. x=0,
y=0 is upperleft corner. The pixel
is displayed with the mode defined
by PointMode

primitive           n1 ..
create a word with a name equal to the
word entered next on the keyboard.
This word will, when executed, invoke
primitive n1.

quit
quit bcl, return to dos. Forget all
changes to the image. Can also be
achieved by pressing the escape key

repeat                 .. n1
start a loop control structure. Repeat
all words between repeat and until as
long as the condition before until
evaluates to 1.
In fact, this word leaves the current
address on the stack for the compiler
to use when compiling "until". It does
not generate code itself.

save
save the image to a file with name
xxx.bcl, with xxx equal to the word
entered following save

show
starts displaying the stack after
each word entered by the user

sin                 n1 .. n2
finds the sine of n1 and leaves
result as n2. n1 is in rads

sqr                 n1 .. n2
computes the square of n1 (n1*n1) and
leaves the result as n2 on the stack

sqrt                n1 .. n2
computes the square root of n1 and
leaves the result as n2 on the stack

swap             n1 n2 .. n2 n1
exchange the top two items on the stack

tan                 n1 .. n2
computes the tangent of n1 and leaves
the result as n2 on the stack

text
switch computer display to text mode

until               n1 ..
completion of repeat..until structure.
Jump back to the matching repeat if
a "1" is encountered on the stack.
This word in fact compiles a "jz"
with the address calculated from the
n1 left on the stack by repeat.

update                 ..
If there is more than one word defined
with the same name, replace the 1st
word with this name with the last word
defined with this name. This can be
used to replace old definitions of
macros or constants without having
to "forget" and reenter all the words
defined after it.

variable            n1 ..
define a variable with initial value
n1. The name of the variable is the
word entered following variable

version                ..
display a message identifying the
program and it's version

!                n1 n2 ..
store the number n2 at the address
of n1, which is typically put on the
stack by executing a variable word

*                n1 n2 .. n3
finds the product of n1 and n2 and
leaves the result as n3

+                n1 n2 .. n3
finds the sum of n1 and n2 and leaves
result as n3

-                n1 n2 .. n3
finds the sum of n1 and n2 and leaves
result as n3

.                   n1 ..
Print the number at the head of the
stack, removing it from the stack
in the process

:
start a macro definition

/                n1 n2 .. n3
finds the quotient of n1 and n2 and
leaves the result as n3

;
complete a macro definition

<                n1 n2 .. n3
This word will leave the number 0 as n3
on the stack if n1 >= n2, else it will
leave the number 1 as n3

<=               n1 n2 .. n3
This word will leave the number 0 as n3
on the stack if n1 > n2, else it will
leave the number 1 as n3

<>               n1 n2 .. n3
if n1 <> n2 then n3 is one, else n3 is
zero

=                n1 n2 .. n3
Leave the number 0 as n3 if n1 is
different from n2, otherwise leave
the number 1 as n3

>                n1 n2 .. n3
if n1 > n2 then n3 is one, else n3 is
zero

>                n1 n2 .. n3
if n1 > n2 then n3 is one, else n3 is
zero

>=               n1 n2 .. n3
if n1 >= n2 then n3 is one, else n3 is
zero

@                   n1 .. n2
recall the number at address n1,
and leave the result as n2. N1 is
typically put on the stack by
executing a variable word

[]               n1 n2 .. n3
finds the address of the n2th number
of an array starting at address n1.
N1 is typically obtained by entering
the name of an array

^                n1 n2 .. n3
computes the power of n1 and n2
(n1^n2) and leaves the result as n2
on the stack