Capuirequiem

Capuirequiem is an esoteric programming language by User:Zzo38 from the year 2006. All of the ASCII characters mapping to the code range 33 to 126 constitute valid content. The digits 0 to 9 as commands push their own value onto the stack. Lowercase letters and the apostrophe are valid characters to use as a part of a name. The language is stack-based and discriminates between three types: array, string, and integer.
There exists no command for comments, but this lacuna can be circumvented by defining a string of temporary duration only: Enclosing the commentary text with [ and ] and appending a Z command to immediately discard this string, the programmatically ineffectual object acts as a note to the reader without influencing the code. For example:
 [This is a comment.]Z
Capuirequiem is known to be Turing-complete because Underload without output can be compiled into it; albeit there are some pathological Underload programs which produce different output after being compiled.
==List of commands==
Character	Function
[0-9] 	Number to stack
[a-z'] 	Append character to end of current name
[] 	Square brackets indicate a string, push to stack
A 	Make new array
B 	Integer division
C 	Concatenate strings
D 	Duplicate top entry of stack
E 	Multiplies exp(a) by (b) round down
F 	Logarithm log(a,b) rounded down
G 	Sets pointer position of array, or modulo of 2 numbers
H 	Calculates a to power of b
I 	Input one byte
J 	Position of program pointer inside of current block
K 	Absolute value of difference
L 	Loop if not zero, or replaces current block with a different string
M 	Calculates which of 2 numbers is larger
N 	Number negative one
O 	Output one byte, or output a string, or use external add-in function of a array
P 	Get position of pointer in array, or add brackets around a string
Q 	Cancels the current block
R 	Reverse the stack
S 	Swap top 2 values of the stack
T 	Figures out type of value at top of stack, 0=number, 1=string, 2=array
U 	Cancel block if zero
V 	Execute sub-routine in array using its own memory, or executes a string inline
W 	Converts number 0-255 to string of a single character, or adds backtrack point to global stack, or retrieves backtrack point, or can just discard a number -1 (which is a dead backtrack point)
X 	Executes a string as a separate block, or multiply 2 numbers together
Y 	Discard second from top entry of stack
Z 	Discard top entry from stack
( 	Number 100
) 	Number 256
" 	Removes current name
{ 	Store value in a variable with given current name
} 	Retrieve value from variable with given current name
@ 	Skip a number of commands
_ 	Negative value of number
, 	Get value from array, or multiply a number by ten and add the other number
. 	Store value in array, or subtraction of 2 numbers
- 	Decrement
+ 	Increment
< 	Move array pointer 1 space backwards
> 	Move array pointer 1 space forwards
 	Separate number to half of it and the remainder, or split string at first character
= 	1 if equal, 0 if not-equal
; 	Recombines numbers that were separated to half and remainder
/ 	Move data to global stack
\ 	Move data to normal stack
& 	Bit AND of 2 numbers
? 	Bit XOR of 2 numbers
* 	Bit OR of 2 numbers
# 	Add current name to stack
$ 	Pop a,b,s,v, push (s-v)*(a%b)
% 	Search stack for a value according to index into stack, or search a array for a value
^ 	Removes a number of values from the stack
: 	Count number of entries in the stack
! 	Number 10
==Examples==
Beer program:
 [99 bottles of beer program]Z
 
 99"n{"m{
 "b[ bottles of beer]{
 "w[ on the wall]!WC{
 "o[
 ["n}U48,"n}_KO]X
 48,"m}_KO
 ]{
 
 [
 "o}X"b}O"w}O
 "o}X"b}O!O
 [Take one down, pass it around,]O!O
 "m}-DN=[U"n}-"n{Z9]X"m{
 10"n}"m},=KU
 "o}X"b}O!O!O
 1L
 ]X
 [No more]O"b}O"w}O
Hello World program:
 [Hello World!]O
Cat program (forever):
 IO!L
Cat program (stop at NULL):
 IDOL
Reverse input (stop as NULL):
 A0.>[ID"{.>"}L]X
 <[<D,DOL]X
ROT13 program (forever):
 [Initialze array of values 0 to 255]Z
 A[DP.>DP25,6,KL]X
 
 [Add 13 to value at position 65 to 77 in the array]Z
 65,G[+++++++++++++>DP78,KL]X
 
 [Subtract 13 from value at position 78 to 90 in the array]Z
 78,G[------------->DP91,KL]X
 
 [Add 13 to value at position 97 to 109 in the array]Z
 97,G[+++++++++++++>DP11,0,KL]X
 
 [Subtract 13 from value at position 110 to 122 in the array]Z
 11,0,G[------------->DP12,3,KL]X
 
 [Get values from input and transform according to ROT13]Z
 [IGD,O1L]X
Quine program:
 [91,OO93,O[DX]O]DX
Kimian quine program:
 ERR
Fibonacci program:
 [This function output a number in decimal format]Z
 [
 []D/V
 D /01!\$ 48,_KW\C/
 !SB DL Z\O
 ]"n{
 
 [Print out the fibonacci sequence]Z
 [1.]O 0"a{1"b{ [
 "a}"b}D"a{_KD"b{
 "n}X [.]O
 1L
 ]X
Backtracking:
 [These are the examples of backtracking-INTERCAL,
 and they have been converted to Capuirequiem.]Z
 
 [0]"{
 [[1]"{]W
 "}O
 \W
 
 !O
 
 [0]"a{
 [2]"b{
 1[Z0]W[U[1]"a{]X
 1[Z0]W[U[3]"b{]X
 "a}O
 "b}O
 \W
 [.]O
 \W
 
 !O
 
 [0]"a{
 [2]"b{
 1[Z0]W[U[1]"a{]X
 1[Z0]W[U[3]"b{]X
 "a}O
 "b}O
 \Z
 [.]O
 \W
Input a Capuirequiem program ending in NULL and execute:
 #[IDUWC!L]XZV
Brainfuck interpreter:
 [ Brainfuck interpreter in Capuirequiem ]Z
 
 [Initialize variables]Z
 A+- "tape{
 [] "prog{
 
 [Load program]Z
 [IDU
 
 [Begin loop]Z
 [D91,=U }91,W[},U]CC{ ]X
 
 [End loop]Z
 [D93,=U }[1L]93,W[X]CCC{ ]X
 
 [Tape pointer left]Z
 [D60,=U }[}<+-{]C{ ]X
 
 [Tape pointer right]Z
 [D62,=U }[}>+-{]C{ ]X
 
 [Increment]Z
 [D43,=U }[}+D{,[)=U}0.{]X]C{ ]X
 
 [Decrement]Z
 [D45,=U }[}-D{,[N=U})-.{]X]C{ ]X
 
 [Input]Z
 [D44,=U }[}I.{]C{ ]X
 
 [Output]Z
 [D46,=U }[},O]C{ ]X
 
 L]X
 
 [Execute program]Z
 "prog}"tapeX
==External resources==
* Implementation in PHP 
Category:Languages
Category:Implemented
Category:Turing complete
Category:2006