cppc

:..:

:..: (colon period period colon) is an esoteric programming language based on the manipulation of four unbounded integer registers.

Language

Syntax

A program in :..:

1. Consists only of the symbols : (colon) and . (period); all other symbols are ignored.
2. Is a sequence of 4-tuples that form program instructions (the program length % 4 == 0).
3. Has a length greater than zero (at least one 4-tuple).

Semantics

Registers

Each 4-tuple reads or manipulates one of the four registers A, B, C, D.

The current register is determined by the index of the instruction in the program code. For instance, the first instruction works with A, fourth with D, fifth with A, and so on.

Instructions

Four possible instructions can be formed based on the position of the colon in a 4-tuple:

Instruction	Name	Meaning	Code
	Noop	Do nothing	....
+	Increment	Increments the current register value	.:..
-	Decrement	Decrements the current register value	..:.
[	Loop begin	Jumps to the loop end if the current register value is not zero	:...
]	Loop end	Jumps to the paring [	...:

Instructions [ and ] are paired, meaning each [ must have a following ] and vice versa.

Instructions can be combined into compact ones. For instance, the 4-tuple ::.. contains both instructions [ (loop begin) and + (increment). Compact instructions are executed in the order they appear in the 4-tuple.

Examples

No-op program

Does nothing:

....

Infinite loop

Loops forever:

:..:

Alternativelly:

::::

Clear

Sets register A to zero:

.... .... :... ....
:... .... .:.. ....
.:.: .... .... ....
..:: .... ..:. .... 

The program reads as follows:

C[ A[ C+ A+] A-] C-

Move

Moves register B to register A:

.... .... :... ....
.... :... .:.. ....
.... .:.: .... ....
.:.. ..:. ...: ....
..:. ..:. ..:. ....

The program reads as follows:

C[ B[ C+ B+] A+ B- C] A- B- C-

Copy

Copies register A to register B:

.... .... :... ....
:... .... .:.. ....
.:.: .... .... ....
..:. .:.. .... .:.:
.... ..:. ..:. ..:.
.... .... :... :...
.... .... .:.. .:.:
.... .... .... ..:.
.:.: .... .... ....
..:. .... ..:. ....

The program reads as follows:

C[ A[ C+ A+] A- B+ D+] B- C- D- 
C[ D[ C+ D+] D- A+] A- C-

Switch

Switches register A with register B:

.... .... :... ....
::.. .... .:.: .:..
..:: .... ..:. ..:.
.... .... :... ....
.... ::.. .:.: ....
.:.. ..:: ..:. ....
..:. .... :... ::..
.... .... .:.: ..:.
.... .:.: ..:. ....
.... ..:. .... ....

The program reads as follows:

C[ A[ A+ C+] D+ A-] C- D-   move A to D
C[ B[ B+ C+] A+ B-] C- A-   move B to A
C[ D[ D+ C+] D- B+] C- B-   move D to B

Fibonacci sequence

Computes the sequence in register A:

.... .:.. :... ....
.... .... :... ....
::.. .... .:.: .:..
..:: .... ..:. ..:.
.... .... :... ....
.... ::.. .:.: ....
.:.. ..:: ..:. ....
..:. .... :... ::..
.... .... .:.: ..:.
.... .:.: ..:. ....
.... ..:. :... ....
::.. .... .:.: .:..
..:. .:.: ..:. ..:.
.... ..:. :... ::..
.... .... .:.: ..:.
.:.: .... ..:. ....
..:: .... .... ....

The program reads as follows:

B+                              init 0 1 0 0
C[                              loop forever
    C[ A[ A+ C+] D+ A-] C- D-   move A to D
    C[ B[ B+ C+] A+ B-] C- A-   move B to A
    C[ D[ D+ C+] D- B+] C- B-   move D to B
    C[ A[ A+ C+] D+ A- B+] C- D- B- 
    C[ D[ D+ C+] D- A+] C- A-   copy A to B
]

Hello World

For computing "Hello World," we need to interpret integers in registers as a string. We can achieve this by defining an alphabet and concatenating register values.

Symbol	Binary
	000
d	001
e	010
H	011
l	100
o	101
r	110
W	111

Registers must contain the following values:

Register	Binary	Decimal	Interpreted
A	011010100	212	Hel
B	100101000	296	lo
C	111101110	494	Wor
D	100001	33	ld

Shortened code:

.:.. .:.. .:.. .:..     33 times
.:.. .:.. .:.. ....    179 times
.... .:.. .:.. ....     84 times
.... .... .:.. ....    198 times

Turing completeness

:..: is intuitively Turing-complete as it provides four unbounded registers (two have been proven to be sufficient), elementary arithmetics, and while loops.

A concrete proof is still to be done.

JavaScript interpreter

npm i cppc

const cppc = require('cppc')

// [2, 0, 1, 1]
cppc(`.:...:...:...:...:....:.`)

License

MIT