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 (dead link)