New page wikitext, after the edit (new_wikitext) | '= Letterfuck =
'''Letterfuck''' (LF) is an esoteric programming language inspired by [[Brainfuck]] and [[Piet]], but using letters as commands. LF combines a ''memory tray'' similar to Brainfuck with a [[Stack (data structure)|stack]] like Piet. Programs are sequences of letters, with the differences between letters encoding commands and repeated letters forming blocks.
== Overview ==
LF programs use a memory tray (array of cells) and a stack (LIFO). Each command is represented by the change in letters. <br>
- Syntax (bytecode): aAbB
* a is a parameter for the current command
* b is a parameter for the next command
* A,B are letters from A-Z
- Opcode = index(B) - index(A) if B > A, or 26 + index(B) - index(A) if B < A.
- Repeated letters form a ''block'', with size representing the parameter for some commands.
- Example: AAAB does command 1, parameter 3
== Commands ==
{| class="wikitable"
! STT !! Command !! Param !! Description
|-
| 1 || IDXINC || VAL || Increase memory index: index += VAL
|-
| 2 || IDXDEC || VAL || Decrease memory index: index -= VAL
|-
| 3 || INC || VAL || Add VAL to current cell: tray[index] += VAL
|-
| 4 || DEC || VAL || Subtract VAL from current cell: tray[index] -= VAL
|-
| 5 || IN(CHAR) || NONE || Input a character: tray[index] = ASCII(input_char())
|-
| 6 || ZERO (ZZ) || NONE || Next command receives 0 or ZZ (boolean false) as parameter
|-
| 7 || IN(NUM) || NONE || Input a number: tray[index] = input_number()
|-
| 8 || OUT(CHAR) || CELL || Output ASCII character: system.write(tray[index])
|-
| 9 || OUT(NUM) || CELL || Output number: system.write(tray[index])
|-
| 10 || NEG || VAL || Negation: NEG a = -a; if a=ZZ → 1; number ≥1 → TRUE
|-
| 11 || STARTLOOP || VAL || Loop VAL times
|-
| 12 || ENDLOOP || NONE || End loop
|-
| 13 || EQ || VAL || Compare top of stack with VAL: 1 if equal, ZZ if not
|-
| 14 || BRK || NONE || Break loop
|-
| 15 || WHILE || VAL || While VAL=1, repeat loop
|-
| 16 || ENDWHILE || NONE || End while loop
|-
| 17 || PUSH || CELL || Push cell to stack, reset cell
|-
| 18 || POP || STACK || Pop stack to cell
|-
| 19 || CMP || STACK || Compare top two stack values
|-
| 20 || DUP || STACK || Duplicate top of stack
|-
| 21 || SUB || STACK || Subtract top stack values
|-
| 22 || ADD || STACK || Add top stack values
|-
| 23 || MUL || STACK || Multiply top stack values
|-
| 24 || DIV || STACK || Divide top stack values
|-
| 25 || END || NONE || End program
|}
== LFSP and LFASM ==
LF is hard to read, so two helper syntaxes exist:
* '''LFSP''' (LF-Simplified): compresses repeated letters. Example:
AAAAAAAAALLLLLLLLOAIH → 9A8LOAIH
* '''LFASM''' (LF Assembly): easier coding:
9A8LOAIH → STARTLOOP 9, INC 8, ENDLOOP, OUT(CHAR), END
= LF-High (LFH) =
LF-High is an advanced version of LF with major improvements:
* Compact commands:
** in, form, dest (opcode 5)
** out, form, target, start, end (opcode 8)
** idx, val (val can be negative) (opcode 1)
** inc, val, ... (val can be negative, supports increasing multiple cells at once) (opcode 3)
* New commands (to fill in the spot of: IDXDEC, DEC, IN(NUM), OUT(NUM)):
** mov, pt, val (opcode 2)
** sel, target (opcode 4)
* Zone support with flags:
** ^ → start zone
** !! → end zone
** # → zone pointer
** $ → self (current zone)
* Advanced stack operations, select stack, arithmetic on stack and cell. Local pointers for zones, and stack pointer (sp).
=== Example that includes all of the new commands ===
<pre>
inc, ^4 // start zone and makes the first value 4
sel, $ // select current cell
idx, 2
inc, !!9
sel, $
add // adds the 2 selected cells
out, num, sp // outs 13
end
</pre>
Output: <code>13</code>
* $ references the current zone or the current cell, depending on instruction:
{| class="wikitable"
|+ Caption text
|-
! Instructions !! $ means
|-
| add, sub, mul, div || current cell
|-
| out || current zone
|}
== Advantages and disadvantages ==
* '''Advantages''': Very powerful; supports self-replicating code, complex stack operations, and zones.
* '''Disadvantages''': Difficult to read and debug, requires hard thinking and wise coding.
== See also ==
* [[Brainfuck]]
* [[Piet]]' |
Unified diff of changes made by edit (edit_diff) | '@@ -1,0 +1,127 @@
+= Letterfuck =
+
+'''Letterfuck''' (LF) is an esoteric programming language inspired by [[Brainfuck]] and [[Piet]], but using letters as commands. LF combines a ''memory tray'' similar to Brainfuck with a [[Stack (data structure)|stack]] like Piet. Programs are sequences of letters, with the differences between letters encoding commands and repeated letters forming blocks.
+
+== Overview ==
+LF programs use a memory tray (array of cells) and a stack (LIFO). Each command is represented by the change in letters. <br>
+- Syntax (bytecode): aAbB
+* a is a parameter for the current command
+* b is a parameter for the next command
+* A,B are letters from A-Z
+- Opcode = index(B) - index(A) if B > A, or 26 + index(B) - index(A) if B < A.
+- Repeated letters form a ''block'', with size representing the parameter for some commands.
+- Example: AAAB does command 1, parameter 3
+
+== Commands ==
+{| class="wikitable"
+! STT !! Command !! Param !! Description
+|-
+| 1 || IDXINC || VAL || Increase memory index: index += VAL
+|-
+| 2 || IDXDEC || VAL || Decrease memory index: index -= VAL
+|-
+| 3 || INC || VAL || Add VAL to current cell: tray[index] += VAL
+|-
+| 4 || DEC || VAL || Subtract VAL from current cell: tray[index] -= VAL
+|-
+| 5 || IN(CHAR) || NONE || Input a character: tray[index] = ASCII(input_char())
+|-
+| 6 || ZERO (ZZ) || NONE || Next command receives 0 or ZZ (boolean false) as parameter
+|-
+| 7 || IN(NUM) || NONE || Input a number: tray[index] = input_number()
+|-
+| 8 || OUT(CHAR) || CELL || Output ASCII character: system.write(tray[index])
+|-
+| 9 || OUT(NUM) || CELL || Output number: system.write(tray[index])
+|-
+| 10 || NEG || VAL || Negation: NEG a = -a; if a=ZZ → 1; number ≥1 → TRUE
+|-
+| 11 || STARTLOOP || VAL || Loop VAL times
+|-
+| 12 || ENDLOOP || NONE || End loop
+|-
+| 13 || EQ || VAL || Compare top of stack with VAL: 1 if equal, ZZ if not
+|-
+| 14 || BRK || NONE || Break loop
+|-
+| 15 || WHILE || VAL || While VAL=1, repeat loop
+|-
+| 16 || ENDWHILE || NONE || End while loop
+|-
+| 17 || PUSH || CELL || Push cell to stack, reset cell
+|-
+| 18 || POP || STACK || Pop stack to cell
+|-
+| 19 || CMP || STACK || Compare top two stack values
+|-
+| 20 || DUP || STACK || Duplicate top of stack
+|-
+| 21 || SUB || STACK || Subtract top stack values
+|-
+| 22 || ADD || STACK || Add top stack values
+|-
+| 23 || MUL || STACK || Multiply top stack values
+|-
+| 24 || DIV || STACK || Divide top stack values
+|-
+| 25 || END || NONE || End program
+|}
+
+== LFSP and LFASM ==
+LF is hard to read, so two helper syntaxes exist:
+
+* '''LFSP''' (LF-Simplified): compresses repeated letters. Example:
+AAAAAAAAALLLLLLLLOAIH → 9A8LOAIH
+
+* '''LFASM''' (LF Assembly): easier coding:
+9A8LOAIH → STARTLOOP 9, INC 8, ENDLOOP, OUT(CHAR), END
+
+= LF-High (LFH) =
+
+LF-High is an advanced version of LF with major improvements:
+* Compact commands:
+** in, form, dest (opcode 5)
+** out, form, target, start, end (opcode 8)
+** idx, val (val can be negative) (opcode 1)
+** inc, val, ... (val can be negative, supports increasing multiple cells at once) (opcode 3)
+* New commands (to fill in the spot of: IDXDEC, DEC, IN(NUM), OUT(NUM)):
+** mov, pt, val (opcode 2)
+** sel, target (opcode 4)
+* Zone support with flags:
+** ^ → start zone
+** !! → end zone
+** # → zone pointer
+** $ → self (current zone)
+* Advanced stack operations, select stack, arithmetic on stack and cell. Local pointers for zones, and stack pointer (sp).
+
+=== Example that includes all of the new commands ===
+<pre>
+inc, ^4 // start zone and makes the first value 4
+sel, $ // select current cell
+idx, 2
+inc, !!9
+sel, $
+add // adds the 2 selected cells
+out, num, sp // outs 13
+end
+</pre>
+Output: <code>13</code>
+
+* $ references the current zone or the current cell, depending on instruction:
+{| class="wikitable"
+|+ Caption text
+|-
+! Instructions !! $ means
+|-
+| add, sub, mul, div || current cell
+|-
+| out || current zone
+|}
+
+== Advantages and disadvantages ==
+* '''Advantages''': Very powerful; supports self-replicating code, complex stack operations, and zones.
+* '''Disadvantages''': Difficult to read and debug, requires hard thinking and wise coding.
+
+== See also ==
+* [[Brainfuck]]
+* [[Piet]]
' |
Lines added in edit (added_lines) | [
0 => '= Letterfuck =',
1 => '',
2 => ''''Letterfuck''' (LF) is an esoteric programming language inspired by [[Brainfuck]] and [[Piet]], but using letters as commands. LF combines a ''memory tray'' similar to Brainfuck with a [[Stack (data structure)|stack]] like Piet. Programs are sequences of letters, with the differences between letters encoding commands and repeated letters forming blocks.',
3 => '',
4 => '== Overview ==',
5 => 'LF programs use a memory tray (array of cells) and a stack (LIFO). Each command is represented by the change in letters. <br> ',
6 => '- Syntax (bytecode): aAbB',
7 => '* a is a parameter for the current command ',
8 => '* b is a parameter for the next command ',
9 => '* A,B are letters from A-Z ',
10 => '- Opcode = index(B) - index(A) if B > A, or 26 + index(B) - index(A) if B < A. ',
11 => '- Repeated letters form a ''block'', with size representing the parameter for some commands.',
12 => '- Example: AAAB does command 1, parameter 3',
13 => '',
14 => '== Commands ==',
15 => '{| class="wikitable"',
16 => '! STT !! Command !! Param !! Description',
17 => '|-',
18 => '| 1 || IDXINC || VAL || Increase memory index: index += VAL',
19 => '|-',
20 => '| 2 || IDXDEC || VAL || Decrease memory index: index -= VAL',
21 => '|-',
22 => '| 3 || INC || VAL || Add VAL to current cell: tray[index] += VAL',
23 => '|-',
24 => '| 4 || DEC || VAL || Subtract VAL from current cell: tray[index] -= VAL',
25 => '|-',
26 => '| 5 || IN(CHAR) || NONE || Input a character: tray[index] = ASCII(input_char())',
27 => '|-',
28 => '| 6 || ZERO (ZZ) || NONE || Next command receives 0 or ZZ (boolean false) as parameter',
29 => '|-',
30 => '| 7 || IN(NUM) || NONE || Input a number: tray[index] = input_number()',
31 => '|-',
32 => '| 8 || OUT(CHAR) || CELL || Output ASCII character: system.write(tray[index])',
33 => '|-',
34 => '| 9 || OUT(NUM) || CELL || Output number: system.write(tray[index])',
35 => '|-',
36 => '| 10 || NEG || VAL || Negation: NEG a = -a; if a=ZZ → 1; number ≥1 → TRUE',
37 => '|-',
38 => '| 11 || STARTLOOP || VAL || Loop VAL times',
39 => '|-',
40 => '| 12 || ENDLOOP || NONE || End loop',
41 => '|-',
42 => '| 13 || EQ || VAL || Compare top of stack with VAL: 1 if equal, ZZ if not',
43 => '|-',
44 => '| 14 || BRK || NONE || Break loop',
45 => '|-',
46 => '| 15 || WHILE || VAL || While VAL=1, repeat loop',
47 => '|-',
48 => '| 16 || ENDWHILE || NONE || End while loop',
49 => '|-',
50 => '| 17 || PUSH || CELL || Push cell to stack, reset cell',
51 => '|-',
52 => '| 18 || POP || STACK || Pop stack to cell',
53 => '|-',
54 => '| 19 || CMP || STACK || Compare top two stack values',
55 => '|-',
56 => '| 20 || DUP || STACK || Duplicate top of stack',
57 => '|-',
58 => '| 21 || SUB || STACK || Subtract top stack values',
59 => '|-',
60 => '| 22 || ADD || STACK || Add top stack values',
61 => '|-',
62 => '| 23 || MUL || STACK || Multiply top stack values',
63 => '|-',
64 => '| 24 || DIV || STACK || Divide top stack values',
65 => '|-',
66 => '| 25 || END || NONE || End program',
67 => '|}',
68 => '',
69 => '== LFSP and LFASM ==',
70 => 'LF is hard to read, so two helper syntaxes exist:',
71 => '',
72 => '* '''LFSP''' (LF-Simplified): compresses repeated letters. Example:',
73 => 'AAAAAAAAALLLLLLLLOAIH → 9A8LOAIH',
74 => '',
75 => '* '''LFASM''' (LF Assembly): easier coding:',
76 => '9A8LOAIH → STARTLOOP 9, INC 8, ENDLOOP, OUT(CHAR), END',
77 => '',
78 => '= LF-High (LFH) =',
79 => '',
80 => 'LF-High is an advanced version of LF with major improvements:',
81 => '* Compact commands:',
82 => '** in, form, dest (opcode 5)',
83 => '** out, form, target, start, end (opcode 8)',
84 => '** idx, val (val can be negative) (opcode 1)',
85 => '** inc, val, ... (val can be negative, supports increasing multiple cells at once) (opcode 3)',
86 => '* New commands (to fill in the spot of: IDXDEC, DEC, IN(NUM), OUT(NUM)):',
87 => '** mov, pt, val (opcode 2)',
88 => '** sel, target (opcode 4)',
89 => '* Zone support with flags:',
90 => '** ^ → start zone',
91 => '** !! → end zone',
92 => '** # → zone pointer',
93 => '** $ → self (current zone)',
94 => '* Advanced stack operations, select stack, arithmetic on stack and cell. Local pointers for zones, and stack pointer (sp).',
95 => '',
96 => '=== Example that includes all of the new commands ===',
97 => '<pre>',
98 => 'inc, ^4 // start zone and makes the first value 4',
99 => 'sel, $ // select current cell',
100 => 'idx, 2',
101 => 'inc, !!9',
102 => 'sel, $',
103 => 'add // adds the 2 selected cells',
104 => 'out, num, sp // outs 13',
105 => 'end',
106 => '</pre>',
107 => 'Output: <code>13</code>',
108 => '',
109 => '* $ references the current zone or the current cell, depending on instruction:',
110 => '{| class="wikitable"',
111 => '|+ Caption text',
112 => '|-',
113 => '! Instructions !! $ means',
114 => '|-',
115 => '| add, sub, mul, div || current cell',
116 => '|-',
117 => '| out || current zone',
118 => '|}',
119 => '',
120 => '== Advantages and disadvantages ==',
121 => '* '''Advantages''': Very powerful; supports self-replicating code, complex stack operations, and zones.',
122 => '* '''Disadvantages''': Difficult to read and debug, requires hard thinking and wise coding.',
123 => '',
124 => '== See also ==',
125 => '* [[Brainfuck]]',
126 => '* [[Piet]]'
] |