EnScript

EnScript is an esoteric programming language invented by User:A mainly based on encrypting data. It was created due to the desire of creating a simple language(4 instructions) that will probably result in complex documents. It is created to make writing an implementation very hard, due to the CHS command.

Syntax

The language runs inside an infinite loop. If a "9" appears in the beginning of one of the accumulators, then the execution halts.

There are a infinitely of unbounded accumulators, each represented by a series of alphabets in English. All of the are pre-set to 0.

Commands

They can be written lazily, from 0 to 6, in the order that they are presented.

ENC

ENC means to encrypt the accumulators. Take ENC A, b as an example:

• Assume that the accumulator A was set to 123, and that the accumulator b was set to 231;
• Encryption happens on the accumulator A.
• Both accumulators are saved, and it will act as a lookup table. The values inside the accumulator A will be changed to another number according to the lookup table.
• (The lookup table acts like this: according to a value in A, find the same value inside the preserved b. Navigate to the value of the preserved A in the same index, and that number in A gets changed to that corresponding number.)
• For example, 1 will be converted to 3; likewise, A will be changed into 312.
• All unmapped numbers will map to 0. All repeated numbers in the lookup table will be deleted, and the frontmost one will be recovered.

CHS

CHS means to chase all of the numbers inside an accumulator. This is the hardest command to implement in this language.

• Chasing a number means to move a number forward inside the accumulator that-number times. Chasing an accumulator means to move all of the numbers inside an accumulator from the lowest number (0) to the highest number (9) sequentially, without repeating.
• Take A=123 as an example.
• Value 1 will move forward 1 number. (It will be inserted behind 2.) So, the number will be 213. 1 will be marked as chased.
• Likewise, 2 will also be moved. It will be moved forward twice, so the number will be 132.
• 3 will also be chased. It will move forward 1 time (finding that the end of the list is reached), and then it will go to the place before 1. Then, it will go back to where it was.
• Accumulator A "chased" will be 132.

REV

This one is simpler. I promise.

• Reverse-cat an accumulator and copy the resulting value to another accumulator. So, REV A, A(where A was set to 123) will be 321.

INC

• Increment all of the values inside the accumulator by 1, with 10 mapping down to 0, and copy the result to another accumulator. So, the code INC B, A will increment A and put it into B. 129(in A) will be 230(in B).

"Syntactic sugars" (convenience operations not in the documentation)

This is not part of the documentation; this is just syntactic sugar for this language just to make sure that the language is usable for writing programs.

LDA

• Load a value into the accumulator. LDA A, 12341234

INP

• Input an accumulator if there is nothing inside the accumulator.

OUT

• Output an accumulator.

Examples

Hello, world! program

(Fortunately the characters don't contain a "9" in the beginning. Phew!)

LDA A, 72
OUT A
LDA A, 101
OUT A
LDA A, 108
OUT A
OUT A
LDA A, 111
OUT A
LDA A, 44
OUT A
LDA A, 32
OUT A
LDA A, 119
OUT A
LDA A, 111
OUT A
LDA A, 114
OUT A
LDA A, 108
OUT A
LDA A, 100
OUT A
LDA A, 33
OUT A
LDA A, 9

Exchange 2 accumulators

Make sure that all numbers are unique.

//Swap A and B
ENC A, B
ENC B, A
ENC A, B
// Halting code here (if neccecary)

There is another way without limitations:

//Swap A and B
REV C, B
REV C, C
REV B, A
REV B, B
REV A, C
REV A, A

Looping counter

INC A

Truth-machine

Please make sure that you have a "9" after your one integer of input!

INP A
OUT A//19 or 09
LDA Z, 10
ENC A, Z
OUT A

Lazily:

5A 6A 4Z,10 1A,Z 6A

Cat program

INP A
OUT A

Computational class

It is unknown, but it definitely is more powerful than a FSA.