Mouse (programming language)

From Wikipedia, the free encyclopedia
Jump to: navigation, search

The Mouse programming language is a small computer programming language developed by Dr. Peter Grogono in the late 1970s and early 1980s.[1][2][3] It was developed as an extension of an earlier language called MUSYS, which was used to control digital and analog devices in an electronic music studio.

Mouse was originally intended as a small, efficient language for microcomputers with limited memory. It is an interpreted, stack-based language and uses Reverse Polish notation. To make an interpreter as easy as possible to implement, Mouse is designed so that a program is processed as a stream of characters, interpreted one character at a time.

The elements of the Mouse language consist of a set of (mostly) one-character symbols, each of which performs a specific function (see table below). Since variable names are limited to one character, there are only 26 possible variables in Mouse (named A-Z). Integers and characters are the only available data types.

Despite these limits, Mouse includes a number of relatively advanced features, including:

  • Conditional branching
  • Loops
  • Pointers
  • Macros (subroutines (which may be recursive))
  • Arrays
  • Code tracing

The design of the Mouse language makes it ideal for teaching the design of a simple interpreter. Much of the book describing Mouse[3] is devoted to describing the implementation of two interpreters, one in Z80 assembly language, the other in Pascal.

Details[edit]

The language described here is the later version of Mouse, as described in the Mouse book.[3] This version is an extension of the language described in the original magazine article.[1]

Symbols[edit]

The following table describes each of the symbols used by Mouse.[3] Here X refers to the number on the top of the stack, and Y is the next number on the stack.

Symbol Action
<space> No action
$ End of program
<number> Push <number> onto stack
+ Add
- Subtract
* Multiply
/ Integer divide
\ Remainder
 ? Input integer
 ?' Input character
 ! Print integer
 !' Print character
' Push character onto stack
" Print string
<letter> Get variable address
 : Store variable
. Recall variable
< Return 1 if Y < X; else return 0
= Return 1 if Y = X; else return 0
> Return 1 if Y > X; else return 0
[ Start of conditional statement
] End of conditional statement
( Start of loop
) End of loop
^ Exit loop (if false)
# Macro call
@ Exit from macro
 % Macro parameter
, End of actual macro parameter
 ; End of list of macro parameters
{ Start trace
} End trace
~ Comment

Expressions[edit]

Common idioms[edit]

These expressions appear frequently in Mouse programs.

X:           ~ store into variable X
X.           ~ recall variable X
X. Y:        ~ assign X to Y
N. 1 + N:    ~ increment N by 1
P. Q. P: Q:  ~ swap values of P and Q
? A:         ~ input a number and store in A
P. !         ~ print variable P

Input[edit]

Mouse may input integers or characters. When a character is input, it is automatically converted to its ASCII code.

? X:         ~ input a number and store into X
?' X:        ~ input a character and store its ASCII code into X

Output[edit]

Mouse may print integers, characters, or string constants, as shown in these examples. If an exclamation point appears in a string constant, a new line is printed.

X. !             ~ recall number X and print it
X. !'            ~ recall ASCII code X and print character
"Hello"          ~ print string "Hello"
"Line 1!Line 2"  ~ print strings "Line 1" and "Line 2" on two lines

Conditionals[edit]

A conditional statement has the general form:

B [ S ]  ~ equivalent to:  if B then S

Here B is an expression that evaluates to 1 (true) or 0 (false), and S is a sequence of statements.

Loops[edit]

Loops may have one of several forms. Most common are the forms:

(B ^ S)   ~ equivalent to:  while B do S
(S B ^)   ~ equivalent to:  repeat S until (not B)

Here again B is a boolean value (0 or 1), and S is a sequence of statements.

Macro calls[edit]

The format of a macro (subroutine) call may be illustrated by the following example. Macro A in this example adds the two parameters passed to it from the main program, and returns the sum on the top of the stack.

#A,p1,p2;     ~ call in main program to macro A
...
$A 1% 2% + @  ~ macro A (add parameters p1 and p2)

Here p1 and p2 are parameters passed to the macro.

Example programs[edit]

This short program prints 'Hello world.'

"Hello world."
$

This program displays the squares of the integers from 1 to 10.

1 N:              ~ initialize N to 1
( N. N. * ! " "   ~ begin loop; print squares of numbers
  N. 10 - 0 < ^   ~ exit loop if N >= 10
  N. 1 + N: ) $   ~ increment N and repeat loop

Notes[edit]

  1. ^ a b Grogono, Peter (July 1979). "Mouse / A Language for Microcomputers". BYTE. pp. 198–220. Retrieved 18 October 2013. 
  2. ^ Lane, Tom; Grogono, Peter (June 1980). "Comment and Correction for Mouse". BYTE. Retrieved 18 October 2013. 
  3. ^ a b c d Grogono, Peter. Mouse: A Language for Microcomputers. 151 pages. Petrocelli Books, Inc.: 1983. ISBN 0-89433-201-5.

See also[edit]

  • FALSE esoteric programming language

External links[edit]