Mouse (programming language)

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.

## Contents

* 1 Details
* 1.1 Symbols
* 1.2 Expressions
* 1.2.1 Common idioms
* 1.2.2 Input
* 1.2.3 Output
* 1.2.4 Conditionals
* 1.2.5 Loops
* 1.2.6 Macro calls
* 1.3 Example programs
* 2 Notes
* 3 External links

## Details

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

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

#### Common idioms

These expressions appear frequently in Mouse programs.

X:           ~ store into variable X
X.           ~ recall variable X
X. Y:        ~ copy X into 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

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

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

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

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

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

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

1. ↑ 1.0 1.1 Grogono, Peter (July 1979). mii/n197/mode/2up "Mouse / A Language for Microcomputers". BYTE: pp. 198–220. https://archive.org/stream/byte-magazine-1979-07/1979_07_BYTE_04-07_Automating_Eclipses#page mii/n197/mode/2up. Retrieved 18 October 2013.
2. ↑ Lane, Tom; Grogono, Peter (June 1980). "Comment and Correction for Mouse". BYTE. https://archive.org/stream/byte-magazine-1980-06/1980_06_BYTE_05-06_Inter_Computer_Communications#page/n243/mode/2up. Retrieved 18 October 2013.
3. ↑ 3.0 3.1 3.2 3.3 Grogono, Peter. Mouse: A Language for Microcomputers. 151 pages. Petrocelli Books, Inc.: 1983. ISBN 0-89433-201-5.

## External links

* The Mouse Programming Language
* The Great MOUSE Programming Language Revival
* Friends of the Mouse
* Mouse, the Language
* Mouse: Computer Programming Language (includes source code for Mouse interpreters)
* Information on sourceforge.net

0.00

(0 votes)

Original source: https://en.wikipedia.org/wiki/Mouse (programming language). Read more

|

Retrieved from "https://handwiki.org/wiki/index.php?title=Mouse_(programming_language)&oldid=293510"