# Skull

Skull is an esoteric programming language designed by Emil Svensson (User:fr34k). The name comes from the sketch the author had drawn next to the language draft.

## Commands

Note that the commands have been whitespaced to increase readability

Command Function
{ x [ y ] } Increment or decrement the specified cell (x) by the specified number (y)
{ x { While the specified cell (x) is not 0...
} } End while
| x | Print out the specified cell (x) to the screen
:ASC: / :NUM: Set the mode to ASCII or NUM (number)

## Examples

### Hello, world!

```:ASC:     // set mode to ASCII (without this code the program would just output every cell as a number)
{0[+72]}   // set cell 0 to the ASCII value 72 (H)
{1[+101]}  // set cell 1 to the ASCII value 101(e)
{2[+108]}  // set cell 2 to the ASCII value 108(l)
{3[+111]}  // set cell 3 to the ASCII value 111(o)
{4[+32]}   // set cell 4 to the ASCII value 32 (space)
{5[+87]}   // set cell 5 to the ASCII value 87 (W)
{6[+114]}  // set cell 6 to the ASCII value 114(r)
{7[+100]}  // set cell 7 to the ASCII value 100(d)
{8[+33]}   // set cell 8 to the ASCII value 33 (!)
{9[+10]}   // set cell 9 to the ASCII value 10 (newline)
|0|       // H
|1|       // e
|2|       // l
|2|       // l
|3|       // o
|4|       //
|5|       // W
|3|       // o
|6|       // r
|2|       // l
|7|       // d
|8|       // !
|9|       // newline
```

```:ASC:{0[+72]}{1[+101]}{2[+108]}{3[+111]}{4[+32]}{5[+87]}{6[+114]}{7[+100]}{8[+33]}{9[+10]}|0||1||2||2||3||4||5||3||6||2||7||8||9|
```

This is a simple program doing addition (4+2)

```:NUM:       // set mode to NUM
{0[+4]}      // set cell 0 to 4
{1[+2]}      // set cell 1 to 2
{0{         // while cell 0 is not 0
{0[-1]}   // subtract cell 0 by 1
{1[+1]}   // add 1 to cell 1
}}          // end while
|1|         // print cell 1 (6)
```

```:NUM:{0[+4]}{1[+2]}{0{{0[-1]}{1[+1]}}}|1|
```

Another addition programming, displaying + and = symbols by changing the mode between ASC and NUM

```:NUM:       // set mode to NUM
{0[+7]}      // set cell 0 to 7
{1[+3]}      // set cell 1 to 3

{2[+43]}     // set cell 2 to 43
{3[+61]}     // set cell 3 to 61
|0|         // print cell 0
:ASC:
|2|         // print cell 2 (+)
:NUM:
|1|         // print cell 1
{0{         // while cell 0 is not 0
{0[-1]}   // subtract cell 0 by 1
{1[+1]}   // add 1 to cell 1
}}          // end while
:ASC:
|3|         // print cell 3 (=)
:NUM:
|1|         // print cell 1 (10)
```

The above program would output

```7+3=10
```

## Implementation

### Skull2C

This Perl script compiles completely correct Skull into C.

```#!/bin/perl -w

use strict;
\$|=1;
\$/=undef;

while(<>)
{
my \$maxe=1;
s/\/\/.*\$//g;
s/\{([0-9]+)\[([0-9]+)\]\}/scalar((\$1>=\$maxe and \$maxe=\$1+1),"c[\$1]=\$2;")/ge;
s/\{([0-9]+)\[\+([0-9]+)\]\}/scalar((\$1>=\$maxe and \$maxe=\$1+1),"c[\$1]+=\$2;")/ge;
s/\{([0-9]+)\[\-([0-9]+)\]\}/scalar((\$1>=\$maxe and \$maxe=\$1+1),"c[\$1]-=\$2;")/ge;
s/\{([0-9]+)\{/scalar((\$1>=\$maxe and \$maxe=\$1+1),"while(c[\$1]){")/ge;
s/\|([0-9]+)\|/scalar((\$1>=\$maxe and \$maxe=\$1+1),"ofunc(c[\$1]);")/ge;
s/:ASC:/ofunc=putchar;/g;
s/:NUM:/ofunc=putnum;/g;
s/\}\}/\}/g;
print "#include <stdio.h>\nint putnum(int x){return printf(\"\%d\",x);}\n";
print "int main(void)\n{\nint (*ofunc)(int)=putchar;\nint c[\$maxe];\n\$_\nreturn 0;\n}\n";
}
```

### Sofa Skull

Sofa Skull should work flawlessly with Skull programs

## Computational class

Skull is Turing complete, as it is easy to compile a Minsky machine into a Skull program.