MCA (Old)

MCA is a programming language designed by user:Almostahexagon (need to replace later with the actual username) for the purpose of creating an assembly language for a mechanical computer. MCA stands for Mechanical Computer Assembly.
NOTE: This is the old version! Please check out the new one (when it's done). Version 1.1 only shows that has changed, so this page is helpful for background information.
 ┌─────────────────────────┐
 │ │
 │ │
 data in │ Program RAM │ ┌─Flags───────┐
 ┌────────────────────────┤ Progrom │ │+│is Positive│
 │ │ ◄──────┐ │-│is Negative│
 │ │ │ │ │0│is Zero │
 │ └───────────────────┬─────┘ │ │c│Carry │
 │ │ │ └─┴───────────┘
 │ MeComp │ Flags
 │ Mechanical Computer Opcode │
 │ │ │
 │ │ │
 │ ┌─────────────┐ ┌──▼────────────┴──┐
 │ ┌───┐ │ ├──M1────► │
 └──► │ │ │ │ Arithmetic │
 │ │ │ RAM ├──M0────► Unit │
 ┌───► ├─data in───► │ │ ├─┐
 │ │ │ │ ├──┐ └──────────────────┘ │
 │ ┌─► │ └──────▲───▲──┘ │ │
 │ │ └───┘ │ │ │ ┌─────────┐ │
 │ │ │ │ │ │ Display │ │
 │ └───────────label────────┼───┼─────┘ └─▲───────┘ │
 │ │ │ │ │
 └──────────────────────────┼───┼───────────┴──AU Result─────────┘
 │ │
 ▼ ▼
 I/O
==Mechanical computer information==
===Memory===
MCA uses a RAM as it's memory. This can be emulated, and doesn't have to be using actual RAM. Each "cell" is 8 bits, ranging from 00-FF or 0-255. There are 256 of these "cells".
In this page, memory "cells" will be referred as M#, where the # is replaced with an address in hex.
M0 and M1 will always be used as the 2 AU inputs.
===AU===
The AU (arithmetic unit) is where all the calculations happen. It's not ALU because there's no logic. On every cycle, it will take M0 and M1 and do an operation, if specified. The result will output a certain flag. So, if you wanted to add 1 and 2, for example, you would load 1 into M0 and 2 into M1, then give the add instruction. The AU will then output the is positive flag because the result was positive. If no AU operation was specified, then nothing happens.
===Reserved memory cells===
These cannot be used in the program.
M2 is always -1, M3 is always 0, and M4 is always 1. M254 and M255 are the two I/O ports.
If you try to write to M2-M4, they will be ignored.
===Instruction writing===
Writing instructions to the computer isn't fully clear yet. In this page, instructions (or lines) will be in the format of I#, where # is a line in hex.
===AU flags===
The AU will output four different flags, depending on the last AU result.
* is Zero
* is Negative
* is Positive
* carry
(insert whatever the carry flag actually does) The carry flag is enabled/raised/met (edit) when the last AU operation results in a carry out at the end.
An example would be if you're adding 100 and 101. You would line them up like this:
 1 0 0
 + 1 0 1
 -------
 1 0 0 1
 ^
When you add the numbers, you get a carry at the end (meaning it required an extra bit).
==Instructions==
===Conditional branching===
Opcode	Name	Full name	Parameter A	Parameter B	Function
000 	JMP 	Jump 	Condition 	Destination	Jumps to I[Destination] if the [Condition] AU flag is met/raised (pls edit). See AU flags for more info about flags.
===Memory management===
Opcode	Name	Full name 	Parameter A 	Parameter B 	Function
001 	LOD 	Load 	Value 	Destination address	Loads [Value] into [Destination address] of memory.
010 	CPY 	Copy 	Address 	Destination 	Copies [Address] to [Destination].
011 	UIP 	User input	1 byte from user	Destination 	Takes an 8-bit input from the user and loads it into [Destination].
===AU operations===
Opcode	Name	Full name 	Parameter A	Parameter B	Function
100 	ADD 	Load 	Destination	‐ 	AU takes M0 and M1 and adds them together. Result goes in [Destination]. Does \mathrm{M0} + \mathrm{M1}
101 	SUB 	Subtract 	Destination	‐ 	Does the same thing as ADD, but subtracts instead. Does \mathrm{M0} - \mathrm{M1}
110 	ASB 	A-shift-B 	Destination	‐ 	Takes M0 and shifts it by M1 bits. Does \mathrm{M0} \times 2^{\mathrm{M1}}
111 	2SC 	2's Complement	Destination	‐ 	Takes M0 and outputs the Two's Complement result into [Destination]. Does 0 - \mathrm{M0}
===Jump command information===
The jump command looks like this:
 JMP ? I#
Where ? is one of the below, and I# is the line to jump to. Jumping to IFF will halt the CPU.
U	Unconditionally (no matter what)
+	is Positive
-	is Negative
0	is Zero
c	carry
===Output===
Notice how there's no output command. If you look at the diagram, there is a display. The display will just output the last AU result, so that means number-only output.
==Examples==
===Add 2 numbers (A+B problem)===
User input version:
 0 | UIP M0
 1 | UIP M1
 2 | ADD M0
===Truth-machine===
 0 | UIP M0
 1 | JMP + IB
 2 | JMP 0 I5
 3 |
 4 | // 0
 5 | LOD 0 M0
 6 | LOD 0 M1
 7 | ADD M0
 8 | JMP U IFF
 9 |
 A | // 1
 B | LOD 0 M0
 C | LOD 1 M0
 D | ADD M0
 E | LOD 0 M1
 F | ADD M0
 10 | JMP IF
Note: I don't know if this works properly
Category:Unimplemented
Category:Languages