2610 lines
63 KiB
TypeScript
2610 lines
63 KiB
TypeScript
export interface LangConfig {
|
||
aliases?: string[];
|
||
name: string;
|
||
monacoLang?: string;
|
||
daemon?: string;
|
||
setup?: string;
|
||
repl?: string;
|
||
input?: string;
|
||
output?: string;
|
||
main: string;
|
||
prefix?: string;
|
||
suffix?: string;
|
||
createEmpty?: string;
|
||
compile?: string;
|
||
run: string;
|
||
helloInput?: string;
|
||
hello?: string;
|
||
helloMaxLength?: number;
|
||
runReplInput?: string;
|
||
runReplOutput?: string;
|
||
scope?: {
|
||
code: string;
|
||
after?: string;
|
||
input?: string;
|
||
output?: string;
|
||
};
|
||
ensure?: string;
|
||
format?: {
|
||
run: string;
|
||
input?: string;
|
||
output?: string;
|
||
};
|
||
pkg?: {
|
||
install: string;
|
||
uninstall?: string;
|
||
all?: string;
|
||
search?: string;
|
||
};
|
||
lsp?: {
|
||
setup?: string;
|
||
start: string;
|
||
disableDynamicRegistration?: boolean;
|
||
init?: any;
|
||
config?: any;
|
||
lang?: string;
|
||
code?: string; // required unless test is skipped
|
||
after?: string;
|
||
item?: string; // required unless test is skipped
|
||
};
|
||
template: string;
|
||
timeout?: number;
|
||
skip?: string[];
|
||
}
|
||
|
||
export const langs: { [key: string]: LangConfig } = {
|
||
"><>": {
|
||
aliases: ["esofish"],
|
||
name: "><>",
|
||
main: "main.fish",
|
||
run: "esofish main.fish",
|
||
template: `"Hello, world!"r\\
|
||
o;!?l<
|
||
`,
|
||
},
|
||
ada: {
|
||
aliases: ["adb"],
|
||
name: "Ada",
|
||
main: "main.adb",
|
||
compile: "x86_64-linux-gnu-gnatmake-9 main.adb",
|
||
run: "./main",
|
||
lsp: {
|
||
start: "ada_language_server",
|
||
code: `
|
||
Ada.IO`,
|
||
after: `);`,
|
||
item: "IO_Exceptions",
|
||
},
|
||
template: `with Ada.Text_IO;
|
||
|
||
procedure Main is
|
||
begin
|
||
Ada.Text_IO.Put_Line("Hello, world!");
|
||
end Main;
|
||
`,
|
||
},
|
||
algol: {
|
||
aliases: ["alg"],
|
||
name: "ALGOL 68",
|
||
main: "main.alg",
|
||
run: "a68g main.alg",
|
||
template: `print(("Hello, world!",new line))
|
||
`,
|
||
},
|
||
apl: {
|
||
name: "APL",
|
||
repl: "apl",
|
||
input: "123 × 234",
|
||
main: "main.apl",
|
||
run: "apl -f main.apl",
|
||
scope: {
|
||
code: `x ← 123 × 234`,
|
||
},
|
||
template: `'Hello, world!'
|
||
`,
|
||
},
|
||
arm: {
|
||
name: "ARM",
|
||
main: "main.S",
|
||
compile: "arm-linux-gnueabihf-gcc main.S -o main -static",
|
||
run: "qemu-arm-static main",
|
||
template: ` .text
|
||
.globl main
|
||
main:
|
||
mov r7, #4
|
||
mov r0, #1
|
||
ldr r1, =message
|
||
mov r2, #14
|
||
swi 0
|
||
mov r7, #1
|
||
mov r0, #0
|
||
swi 0
|
||
.data
|
||
message:
|
||
.string "Hello, world!\\n"
|
||
`,
|
||
},
|
||
asciidoc: {
|
||
aliases: ["adoc", "asc"],
|
||
name: "AsciiDoc",
|
||
main: "main.adoc",
|
||
compile: "asciidoc -s main.adoc",
|
||
run: "prettier --no-config main.html",
|
||
template: `Hello, world!
|
||
`,
|
||
},
|
||
ats: {
|
||
aliases: ["dats"],
|
||
name: "ATS",
|
||
monacoLang: "postiats",
|
||
main: "main.dats",
|
||
compile: "patscc main.dats -o main",
|
||
run: "./main",
|
||
template: `val _ = print ("Hello, world!\\n")
|
||
implement main0 () = ()
|
||
`,
|
||
},
|
||
awk: {
|
||
aliases: ["gawk", "mawk"],
|
||
name: "Awk",
|
||
main: "main.awk",
|
||
run: `awk -f main.awk`,
|
||
template: `BEGIN { print "Hello, world!" }
|
||
`,
|
||
},
|
||
bash: {
|
||
aliases: ["bashrc", "bourneshell"],
|
||
name: "Bash",
|
||
monacoLang: "shell",
|
||
repl: "bash --rcfile /dev/null",
|
||
input: `expr 123 \\* 234`,
|
||
main: "main.bash",
|
||
run: "bash --rcfile main.bash",
|
||
scope: { code: `x="$(expr 123 \\* 234)"`, input: `echo "$x"` },
|
||
lsp: {
|
||
start: "bash-language-server start",
|
||
code: "read",
|
||
item: "readonly",
|
||
},
|
||
template: `echo "Hello, world!"
|
||
`,
|
||
},
|
||
basic: {
|
||
aliases: ["bas", "qbasic"],
|
||
name: "BASIC",
|
||
repl: "bwbasic",
|
||
input: "PRINT 123 * 234",
|
||
main: "main.bas",
|
||
run: "bwbasic main.bas",
|
||
scope: {
|
||
code: `x = 123 * 234`,
|
||
input: `PRINT x`,
|
||
},
|
||
template: `PRINT "Hello, world!"
|
||
`,
|
||
},
|
||
battlestar: {
|
||
aliases: ["battlestarc", "bts"],
|
||
name: "Battlestar",
|
||
main: "main.bts",
|
||
run: "bts main.bts",
|
||
template: `const message = "Hello, world!\n"
|
||
|
||
fun main
|
||
syscall(1, 1, message, len(message))
|
||
end
|
||
`,
|
||
},
|
||
beatnik: {
|
||
name: "Beatnik",
|
||
main: "main.beatnik",
|
||
run: "beatnik main.beatnik",
|
||
template: `Soars, larkspurs, rains.
|
||
Indistinctness.
|
||
Mario snarl (nurses, natures, rules...) sensuously retries goal.
|
||
Agribusinesses' costs par lain ropes (mopes) autos' cores.
|
||
Tuner ambitiousness.
|
||
Flit.
|
||
Dour entombment.
|
||
Legals' saner kinking lapse.
|
||
Nests glint.
|
||
Dread, tied futures, dourer usual tumor grunts alter atonal
|
||
garb tries shouldered coins.
|
||
Taste a vast lustiness.
|
||
Stile stuns gad subgroup gram lanes.
|
||
Draftee insurer road: cuckold blunt, strut sunnier.
|
||
Rely enure pantheism: arty gain groups (genies, pan) titters, tattles, nears.
|
||
Bluffer tapes? Idle diatom stooge!
|
||
Feted antes anklets ague? Remit goiter gout!
|
||
Doubtless teared toed alohas will dull gangs' aerials' tails' sluices;
|
||
Gusset ends! Gawkier halo!
|
||
|
||
Enter abstruse rested loser beer guy louts.
|
||
Curtain roams lasso weir lupus stunt.
|
||
Truant bears animate talon. Entire torte originally timer.
|
||
Redo stilt gobs.
|
||
|
||
Utter centaurs;
|
||
Urgent stars;
|
||
Usurers (dilute);
|
||
Noses;
|
||
Bones;
|
||
Brig sonar graders;
|
||
Utensil silts;
|
||
Lazies.
|
||
Fret arson veterinary rows.
|
||
|
||
Atlas grunted: "Pates, slues, sulfuric manor liaising tines,
|
||
trailers, rep... unfair! Instant snots!"
|
||
|
||
Sled rested until eatery fail.
|
||
Ergs fortitude
|
||
Indent spotter
|
||
Euros enter egg.
|
||
Curious tenures.
|
||
Torus cutlasses.
|
||
Sarong torso earns cruel lags it reeled.
|
||
|
||
Engineer: "Erase handbag -- unite ratification!"
|
||
|
||
oaring oaten donkeys unsold, surer rapid saltest tags
|
||
BUTTERED TIBIA LUGS REWIRING TOILETS
|
||
anion festers raring edit epilogues.
|
||
DIRGE ROTOR.
|
||
linnet oaring.
|
||
GORE BOOTIES.
|
||
Ironed goon lists tallest sublets --
|
||
Riots,
|
||
Raucous onset.
|
||
|
||
Ignobly, runners' diet anguishes sunrise loner.
|
||
Erode mob, slier switcher!
|
||
Loaners stilt drudge pearl atoll, risking hats' ends.
|
||
|
||
Rebind sitters.
|
||
|
||
Toga epistles -- crud lard. (Pager purse dons souls.)
|
||
|
||
glob title a curio hired rites shed suds lade grease strut arctic revs toad
|
||
unless idlers rind stilt region land GERMICIDES SULTANA GUTS gill siting leans
|
||
nice spurs
|
||
tests gloves
|
||
roused asp
|
||
|
||
Holes! Moles! (Sores!)
|
||
Hygienists! Scars! (Asses!)
|
||
Smells spell rares.
|
||
|
||
Cubs instant sing in parse goodies.
|
||
Rosin. Unhelpful sisal acres. Slope told.
|
||
MALENESS PASTA LAB. "Infirmary vine," rang illiterates (beans).
|
||
Rosin sours, insults truss abalones, nailed rules, helical atlases.
|
||
Dear remodeling stings mar rents.
|
||
Sunless shiner orb (silly idol.)
|
||
Clarity disses senna.
|
||
Vagabonds sauted; sloes performed gelds.
|
||
Alter post radial lip sectioning gums.
|
||
Saint Towellings.
|
||
Larger aeons telephone stolid char, pal!
|
||
Boats Dean forsook, rosters, tunas, terrariums -- united, traced.
|
||
Nude pagoda careens.
|
||
`,
|
||
},
|
||
befunge: {
|
||
aliases: ["be"],
|
||
name: "Befunge",
|
||
main: "main.be",
|
||
run: "befunge-repl main.be",
|
||
template: `64+"!dlrow ,olleH">:#,_@
|
||
`,
|
||
},
|
||
blc: {
|
||
aliases: [
|
||
"binarylambdacalculus",
|
||
"lc",
|
||
"binary",
|
||
"lambdacalculus",
|
||
"lambda",
|
||
],
|
||
name: "Binary Lambda Calculus",
|
||
main: "main.blc",
|
||
run: "cat main.blc | binary-to-text | tromp",
|
||
template: `001010100100100001100101011011000110110001101111001011000010
|
||
000001110111011011110111001001101100011001000010000100001010
|
||
`,
|
||
},
|
||
boo: {
|
||
aliases: ["booc"],
|
||
name: "Boo",
|
||
setup: `mkdir -p "$HOME/.local/share" && touch "$HOME/.local/share/booish_history"`,
|
||
main: "main.boo",
|
||
repl: "booish",
|
||
compile: "booc main.boo",
|
||
run: "mono main.exe; booish",
|
||
template: `print "Hello, world!"
|
||
`,
|
||
},
|
||
brainf: {
|
||
aliases: ["brainfuck", "bf"],
|
||
name: "Brainf***",
|
||
repl: "brainf-repl",
|
||
input:
|
||
">++>+[>++++[-<++++>]<<]> [>>+>+<<<-]>>>[<<<+>>>-]<<+>[<->[>++++++++++<[->-[>+>>]>[+[-<+>]>+>>]<<<<<]>[-]++++++++[<++++++>-]>[<<+>>-]>[<<+>>-]<<]>]<[->>++++++++[<++++++>-]]<[.[-]<]<",
|
||
output: "86",
|
||
main: "main.bf",
|
||
run: "brainf-repl main.bf",
|
||
hello: "Hello World",
|
||
template: `++++++++
|
||
[
|
||
>++++
|
||
[
|
||
>++
|
||
>+++
|
||
>+++
|
||
>+
|
||
<<<<-
|
||
]
|
||
>+
|
||
>+
|
||
>-
|
||
>>+
|
||
[<]
|
||
|
||
<-
|
||
]
|
||
|
||
>>.
|
||
>---.
|
||
+++++++..+++.
|
||
>>.
|
||
<-.
|
||
<.
|
||
+++.------.--------.
|
||
>>+.
|
||
>++.
|
||
`,
|
||
},
|
||
c: {
|
||
aliases: ["gcc", "clang", "h", "cc", "c99", "c11", "c18"],
|
||
name: "C",
|
||
monacoLang: "c",
|
||
main: "main.c",
|
||
compile: "clang -Wall -Wextra main.c -o main",
|
||
run: "./main",
|
||
format: {
|
||
run: "clang-format --assume-filename=format.c",
|
||
input: `#include <stdio.h>
|
||
|
||
int main()
|
||
{
|
||
printf("Hello, world!\\n");
|
||
return 0;
|
||
}
|
||
`,
|
||
},
|
||
lsp: {
|
||
setup: `echo '-Wall -Wextra' | sed -E 's/\\s+/\\n/g' > compile_flags.txt`,
|
||
start: "clangd",
|
||
},
|
||
template: `#include <stdio.h>
|
||
|
||
int main() {
|
||
printf("Hello, world!\\n");
|
||
return 0;
|
||
}
|
||
`,
|
||
skip: ["lsp"],
|
||
},
|
||
cat: {
|
||
aliases: ["cat-language"],
|
||
name: "Cat",
|
||
repl: "NODE_PATH=/opt/cat node /opt/cat/repl.js",
|
||
input: "123 234 mul",
|
||
main: "main.cat",
|
||
run: "NODE_PATH=/opt/cat node /opt/cat/repl.js main.cat",
|
||
hello: "72,101,108,108,111,44,32,119,111,114,108,100,33,10",
|
||
template: `72 101 108 108 111 44 32 119 111 114 108 100 33 10
|
||
`,
|
||
},
|
||
ceylon: {
|
||
name: "Ceylon",
|
||
main: "source/main.ceylon",
|
||
run: `PATH="/usr/lib/jvm/java-8-openjdk-amd64/bin:$PATH" ceylon run --compile=force default`,
|
||
template: `shared void run() {
|
||
print("Hello, world!");
|
||
}
|
||
`,
|
||
timeout: 15,
|
||
},
|
||
chef: {
|
||
name: "Chef",
|
||
main: "main.chef",
|
||
run: "chef main.chef",
|
||
hello: "Hello world!",
|
||
template: `Hello World Cake with Chocolate Sauce.
|
||
|
||
Ingredients.
|
||
33 g chocolate chips
|
||
100 g butter
|
||
54 ml double cream
|
||
2 pinches baking powder
|
||
114 g sugar
|
||
111 ml beaten eggs
|
||
119 g flour
|
||
32 g cocoa powder
|
||
0 g cake mixture
|
||
|
||
Cooking time: 25 minutes.
|
||
|
||
Pre-heat oven to 180 degrees Celsius.
|
||
|
||
Method.
|
||
Put chocolate chips into the mixing bowl.
|
||
Put butter into the mixing bowl.
|
||
Put sugar into the mixing bowl.
|
||
Put beaten eggs into the mixing bowl.
|
||
Put flour into the mixing bowl.
|
||
Put baking powder into the mixing bowl.
|
||
Put cocoa powder into the mixing bowl.
|
||
Stir the mixing bowl for 1 minute.
|
||
Combine double cream into the mixing bowl.
|
||
Stir the mixing bowl for 4 minutes.
|
||
Liquefy the contents of the mixing bowl.
|
||
Pour contents of the mixing bowl into the baking dish.
|
||
bake the cake mixture.
|
||
Wait until baked.
|
||
Serve with chocolate sauce.
|
||
|
||
Chocolate Sauce.
|
||
|
||
Ingredients.
|
||
111 g sugar
|
||
108 ml hot water
|
||
108 ml heated double cream
|
||
101 g dark chocolate
|
||
72 g milk chocolate
|
||
|
||
Method.
|
||
Clean the mixing bowl.
|
||
Put sugar into the mixing bowl.
|
||
Put hot water into the mixing bowl.
|
||
Put heated double cream into the mixing bowl.
|
||
dissolve the sugar.
|
||
agitate the sugar until dissolved.
|
||
Liquefy the dark chocolate.
|
||
Put dark chocolate into the mixing bowl.
|
||
Liquefy the milk chocolate.
|
||
Put milk chocolate into the mixing bowl.
|
||
Liquefy contents of the mixing bowl.
|
||
Pour contents of the mixing bowl into the baking dish.
|
||
Refrigerate for 1 hour.
|
||
`,
|
||
},
|
||
cmd: {
|
||
aliases: ["bat", "batch", "wine"],
|
||
name: "Cmd",
|
||
monacoLang: "bat",
|
||
setup: "shopt -s dotglob; cp -R /opt/cmd/home-template/* ./",
|
||
repl: "wine cmd",
|
||
input: "set /a 123 * 234",
|
||
main: "main.bat",
|
||
run: `wine cmd /k main.bat`,
|
||
scope: {
|
||
code: `set /a x = 123 * 234`,
|
||
input: `echo %x%`,
|
||
},
|
||
template: `echo "Hello, world!"
|
||
`,
|
||
timeout: 15,
|
||
},
|
||
commonlisp: {
|
||
aliases: ["lisp", "sbcl"],
|
||
name: "Common Lisp",
|
||
repl: "rlwrap sbcl",
|
||
input: "(* 123 234)",
|
||
main: "main.lisp",
|
||
run: "rlwrap sbcl --userinit main.lisp",
|
||
scope: {
|
||
code: `(defvar x (* 123 234))`,
|
||
},
|
||
template: `(format t "Hello, world!")
|
||
`,
|
||
},
|
||
confluence: {
|
||
aliases: ["jira", "atlassian"],
|
||
name: "Confluence",
|
||
main: "main.txt",
|
||
compile: "pandoc main.txt -f jira -o main.html",
|
||
run: "prettier --no-config main.html",
|
||
template: `Hello, world!
|
||
`,
|
||
},
|
||
"c++": {
|
||
aliases: [
|
||
"cpp",
|
||
"g++",
|
||
"clang++",
|
||
"c++98",
|
||
"c++03",
|
||
"c++11",
|
||
"c++14",
|
||
"c++17",
|
||
"c++20",
|
||
"cpp98",
|
||
"cpp03",
|
||
"cpp11",
|
||
"cpp14",
|
||
"cpp17",
|
||
"cpp20",
|
||
"hpp",
|
||
"cxx",
|
||
"hxx",
|
||
],
|
||
name: "C++",
|
||
monacoLang: "cpp",
|
||
main: "main.cpp",
|
||
compile: "clang++ -Wall -Wextra main.cpp -o main",
|
||
run: "./main",
|
||
format: {
|
||
run: "clang-format --assume-filename=format.cpp",
|
||
input: `#include <iostream>
|
||
|
||
int main()
|
||
{
|
||
std::cout << "Hello, world!" << std::endl;
|
||
return 0;
|
||
}
|
||
`,
|
||
},
|
||
lsp: {
|
||
setup: `echo '-Wall -Wextra' | sed -E 's/\\s+/\\n/g' > compile_flags.txt`,
|
||
start: "clangd",
|
||
},
|
||
template: `#include <iostream>
|
||
|
||
int main() {
|
||
std::cout << "Hello, world!" << std::endl;
|
||
return 0;
|
||
}
|
||
`,
|
||
skip: ["lsp"],
|
||
},
|
||
crystal: {
|
||
aliases: ["cr"],
|
||
name: "Crystal",
|
||
main: "main.cr",
|
||
run: "crystal main.cr",
|
||
template: `puts "Hello, world!"
|
||
`,
|
||
timeout: 15,
|
||
},
|
||
csharp: {
|
||
aliases: ["cs", "mcs"],
|
||
name: "C#",
|
||
monacoLang: "csharp",
|
||
main: "main.cs",
|
||
compile: "mcs main.cs",
|
||
run: "mono main.exe",
|
||
format: {
|
||
run: `clang-format --style="{BasedOnStyle: llvm, IndentWidth: 4}" --assume-filename=format.cs`,
|
||
input: `class main
|
||
{
|
||
static void Main(string[] args)
|
||
{
|
||
System.Console.WriteLine("Hello, world!");
|
||
}
|
||
}
|
||
`,
|
||
},
|
||
template: `class main {
|
||
static void Main(string[] args) {
|
||
System.Console.WriteLine("Hello, world!");
|
||
}
|
||
}
|
||
`,
|
||
},
|
||
clojure: {
|
||
aliases: ["clj"],
|
||
name: "Clojure",
|
||
monacoLang: "clojure",
|
||
repl: "clojure",
|
||
input: "(* 123 234)",
|
||
main: "main.clj",
|
||
run: "clojure -i main.clj -r",
|
||
scope: {
|
||
code: `(def x (* 123 234))`,
|
||
},
|
||
lsp: { start: "clojure-lsp" },
|
||
template: `(println "Hello, world!")
|
||
`,
|
||
skip: ["lsp"],
|
||
},
|
||
clojurescript: {
|
||
aliases: ["cljs", "lumo"],
|
||
name: "ClojureScript",
|
||
monacoLang: "clojure",
|
||
repl: "lumo -r",
|
||
input: "(* 123 234)",
|
||
main: "main.cljs",
|
||
run: "lumo -i main.cljs -r",
|
||
scope: {
|
||
code: `(def x (* 123 234))`,
|
||
},
|
||
template: `(println "Hello, world!")
|
||
`,
|
||
},
|
||
cobol: {
|
||
aliases: ["cbl", "cobc"],
|
||
name: "COBOL",
|
||
main: "main.cbl",
|
||
compile: "cobc -free -x main.cbl -o main",
|
||
run: "./main",
|
||
template: `IDENTIFICATION DIVISION.
|
||
PROGRAM-ID. MAIN.
|
||
PROCEDURE DIVISION.
|
||
DISPLAY "Hello, world!".
|
||
STOP RUN.
|
||
`,
|
||
},
|
||
coffeescript: {
|
||
aliases: ["coffee"],
|
||
name: "CoffeeScript",
|
||
monacoLang: "coffee",
|
||
repl: "coffee",
|
||
main: "main.coffee",
|
||
compile: "coffee -b -c main.coffee",
|
||
run: `node -e '
|
||
eval.apply(this, [require("fs").readFileSync("main.js", {encoding: "utf-8"})])
|
||
require("/usr/lib/node_modules/coffeescript/repl").start()
|
||
'`,
|
||
scope: {
|
||
code: `x = 123 * 234`,
|
||
},
|
||
template: `console.log "Hello, world!"
|
||
`,
|
||
},
|
||
d: {
|
||
aliases: ["dmd"],
|
||
name: "D",
|
||
main: "main.d",
|
||
compile: "dmd main.d",
|
||
run: "./main",
|
||
format: {
|
||
run: "dfmt",
|
||
input: `import std.stdio;
|
||
|
||
void main() {
|
||
writeln("Hello, world!");
|
||
}
|
||
`,
|
||
},
|
||
template: `import std.stdio;
|
||
|
||
void main()
|
||
{
|
||
writeln("Hello, world!");
|
||
}
|
||
`,
|
||
},
|
||
dart: {
|
||
name: "Dart",
|
||
monacoLang: "dart",
|
||
main: "main.dart",
|
||
run: "dart main.dart",
|
||
lsp: {
|
||
start:
|
||
"dart /usr/lib/dart/bin/snapshots/analysis_server.dart.snapshot --lsp",
|
||
disableDynamicRegistration: true,
|
||
lang: "dart",
|
||
},
|
||
template: `void main() {
|
||
print('Hello, world!');
|
||
}
|
||
`,
|
||
skip: ["lsp"],
|
||
},
|
||
dogescript: {
|
||
aliases: ["doge", "ds", "wow"],
|
||
name: "Dogescript",
|
||
repl: "dogescript",
|
||
main: "main.djs",
|
||
run: "dogescript main.djs | node; dogescript",
|
||
template: `plz console.loge with "Hello, world!"
|
||
`,
|
||
},
|
||
dhall: {
|
||
name: "Dhall",
|
||
main: "main.dhall",
|
||
compile: "cat main.dhall | dhall-to-json > main.json",
|
||
run: "cat main.json | jq .",
|
||
template: `{ output = "Hello, world!" }
|
||
`,
|
||
},
|
||
dokuwiki: {
|
||
aliases: ["doku"],
|
||
name: "DokuWiki",
|
||
main: "main.txt",
|
||
compile: "pandoc main.txt -f dokuwiki -o main.html",
|
||
run: "prettier --no-config main.html",
|
||
template: `Hello, world!
|
||
`,
|
||
},
|
||
elixir: {
|
||
aliases: ["iex", "exs"],
|
||
name: "Elixir",
|
||
repl: "iex",
|
||
main: "main.exs",
|
||
run: "iex main.exs",
|
||
scope: {
|
||
code: `defmodule Scope do
|
||
def x do
|
||
123 * 234
|
||
end
|
||
end`,
|
||
input: `Scope.x`,
|
||
},
|
||
lsp: { start: "/opt/elixir-ls/language_server.sh" },
|
||
template: `IO.puts("Hello, world!")
|
||
`,
|
||
skip: ["repl", "runrepl", "scope", "lsp"],
|
||
},
|
||
elm: {
|
||
name: "Elm",
|
||
repl: "elm repl",
|
||
main: "Main.elm",
|
||
run: "cp /opt/elm/elm.json elm.json && run-elm Main.elm; elm repl",
|
||
scope: {
|
||
code: `x = 123 * 234`,
|
||
input: `import Main
|
||
Main.x`,
|
||
},
|
||
lsp: {
|
||
setup: "cp /opt/elm/elm.json elm.json",
|
||
start: "elm-language-server --stdio",
|
||
},
|
||
template: `module Main exposing (..)
|
||
|
||
output : String
|
||
output = "Hello, world!"
|
||
`,
|
||
skip: ["lsp"],
|
||
},
|
||
elvish: {
|
||
aliases: ["elv"],
|
||
name: "Elvish",
|
||
repl: `SHELL=/usr/bin/elvish HOME="$PWD" elvish`,
|
||
input: `* 123 234`,
|
||
main: ".elvish/rc.elv",
|
||
createEmpty: ``,
|
||
run: `SHELL=/usr/bin/elvish HOME="$PWD" elvish`,
|
||
scope: {
|
||
code: `x = (* 123 234)`,
|
||
input: `echo $x`,
|
||
},
|
||
template: `echo "Hello, world!"
|
||
`,
|
||
},
|
||
emacs: {
|
||
aliases: ["emacslisp", "elisp", "gnuemacs", "xemacs", "ielm"],
|
||
name: "Emacs Lisp",
|
||
repl: `emacs --eval "(progn (require 'package) (push '(\"melpa\" . \"https://melpa.org/packages/\") package-archives) (package-initialize) (ielm))"`,
|
||
input: "(* 123 234)",
|
||
main: "main.el",
|
||
run: `emacs --load main.el --eval "(progn (require 'package) (push '(\"melpa\" . \"https://melpa.org/packages/\") package-archives) (package-initialize) (ielm))"`,
|
||
scope: {
|
||
code: `(defvar x (* 123 234))`,
|
||
},
|
||
pkg: {
|
||
install: `emacs -Q --batch --eval "(progn (require 'package) (push '(\"melpa\" . \"https://melpa.org/packages/\") package-archives) (package-initialize) (unless (ignore-errors (>= (length (directory-files \"~/.emacs.d/elpa/archives\")) 4)) (package-refresh-contents)) (package-install 'NAME))"`,
|
||
uninstall: `ls ~/.emacs.d/elpa | grep -- - | grep '^NAME-[0-9]' | while read pkg; do emacs -Q --batch --eval "(progn (require 'package) (push '(\"melpa\" . \"https://melpa.org/packages/\") package-archives) (package-initialize) (unless (ignore-errors (>= (length (directory-files \"~/.emacs.d/elpa/archives\")) 4)) (package-refresh-contents)) (call-interactively 'package-delete))" <<< "$pkg"; done`,
|
||
all: `set -o pipefail; (curl -sS https://elpa.gnu.org/packages/ | grep '<td>' | grep -Eo '[^>]+</a>' | grep -Eo '^[^<]+' && curl -sS https://melpa.org/archive.json | jq -r 'keys | .[]') | sort | uniq`,
|
||
},
|
||
template: `(message "Hello, world!")
|
||
`,
|
||
},
|
||
emojicode: {
|
||
aliases: ["emoji", "emojic", "emojicodec"],
|
||
name: "Emojicode",
|
||
main: "main.emojic",
|
||
compile: "emojicodec main.emojic",
|
||
run: "./main",
|
||
template: `🏁 🍇
|
||
😀 🔤Hello, world!🔤❗️
|
||
🍉
|
||
`,
|
||
},
|
||
entropy: {
|
||
aliases: ["ent", "entc", "vge"],
|
||
name: "Entropy",
|
||
main: "main.vge",
|
||
compile: `mono /opt/entropy/entc.exe main.vge | grep -Ev 'WARNING:|Using default' > main.cs && mcs -lib:/opt/entropy -r:Rottytooth.Esolang.Entropy main.cs`,
|
||
run: "MONO_PATH=/opt/entropy mono main.exe",
|
||
hello: `[F-J][c-g][j-n][j-n][m-q][*-.][\\x1e-"][u-y][m-q][p-t][j-n][b-f][\\x1f-#]`,
|
||
helloMaxLength: "Hello, world!".length,
|
||
template: `Program MyNamespace MyProgram [
|
||
print "Hello, world!";
|
||
]
|
||
`,
|
||
},
|
||
erlang: {
|
||
aliases: ["erl"],
|
||
name: "Erlang",
|
||
repl: "erl",
|
||
input: "123 * 234.",
|
||
main: "main.erl",
|
||
compile: "erl -compile main",
|
||
run: "erl -s main main",
|
||
lsp: { start: "erlang_ls" },
|
||
scope: {
|
||
code: `-export([x/0]).
|
||
x() -> 123 * 234.
|
||
`,
|
||
after: `-export([main/0]).`,
|
||
input: `main:x().`,
|
||
},
|
||
template: `-module(main).
|
||
-export([main/0]).
|
||
|
||
main() ->
|
||
io:fwrite("Hello, world!\\n").
|
||
`,
|
||
skip: ["lsp"],
|
||
},
|
||
euphoria: {
|
||
aliases: ["ex", "exw", "exu", "euc", "eui", "eub"],
|
||
name: "Euphoria",
|
||
main: "main.exu",
|
||
run: "exu main.exu",
|
||
template: `puts(1, "Hello, world!\\n")
|
||
`,
|
||
},
|
||
factor: {
|
||
aliases: ["fact"],
|
||
name: "Factor",
|
||
repl: "factor-lang",
|
||
input: "123 234 *",
|
||
main: ".factor-rc",
|
||
createEmpty: ``,
|
||
run: "factor-lang",
|
||
scope: {
|
||
code: `USE: math
|
||
: x ( -- x ) 123 234 * ;`,
|
||
input: `USE: main
|
||
x`,
|
||
},
|
||
template: `IN: main
|
||
USE: io
|
||
|
||
"Hello, world!" print
|
||
`,
|
||
},
|
||
fish: {
|
||
name: "Fish",
|
||
repl: "SHELL=/usr/bin/fish fish",
|
||
input: `expr 123 \\* 234`,
|
||
main: "main.fish",
|
||
run: 'SHELL=/usr/bin/fish fish -C "$(< main.fish)"',
|
||
scope: {
|
||
code: `set x (expr 123 \\* 234)`,
|
||
input: `echo $x`,
|
||
},
|
||
template: `echo "Hello, world!"
|
||
`,
|
||
},
|
||
forth: {
|
||
aliases: ["gforth"],
|
||
name: "Forth",
|
||
repl: "gforth",
|
||
input: "123 234 * .",
|
||
main: "main.fs",
|
||
run: "gforth main.fs",
|
||
scope: {
|
||
code: `VARIABLE X
|
||
123 234 * X !`,
|
||
input: `X @ .`,
|
||
},
|
||
template: `." Hello, world!" CR
|
||
`,
|
||
},
|
||
fortran: {
|
||
aliases: [
|
||
"f",
|
||
"flang",
|
||
"fortran77",
|
||
"fortran90",
|
||
"fortran95",
|
||
"fortran2003",
|
||
"fortran2008",
|
||
],
|
||
name: "FORTRAN",
|
||
main: "main.f",
|
||
compile: "flang main.f -o main",
|
||
run: "./main",
|
||
lsp: { start: "fortls" },
|
||
template: ` program hello
|
||
print *, "Hello, world!"
|
||
end program hello
|
||
`,
|
||
skip: ["lsp"],
|
||
},
|
||
fsharp: {
|
||
aliases: ["fsharpi", "fsx", "fs"],
|
||
name: "F#",
|
||
monacoLang: "fsharp",
|
||
repl: "fsharpi",
|
||
input: "123 * 234 ;;",
|
||
main: "main.fsx",
|
||
run: "fsharpi --use:main.fsx",
|
||
scope: {
|
||
code: `let x = 123 * 234`,
|
||
input: `x ;;`,
|
||
},
|
||
template: `printfn "Hello, world!"
|
||
`,
|
||
timeout: 15,
|
||
},
|
||
go: {
|
||
aliases: ["golang"],
|
||
name: "Go",
|
||
monacoLang: "go",
|
||
main: "main.go",
|
||
compile: "go build main.go",
|
||
run: "./main",
|
||
format: {
|
||
run: "gofmt",
|
||
input: `package main
|
||
|
||
import "fmt"
|
||
|
||
func main() {
|
||
fmt.Println("Hello, world!");
|
||
}
|
||
`,
|
||
},
|
||
lsp: { start: "gopls" },
|
||
template: `package main
|
||
|
||
import "fmt"
|
||
|
||
func main() {
|
||
fmt.Println("Hello, world!")
|
||
}
|
||
`,
|
||
skip: ["lsp"],
|
||
},
|
||
golfscript: {
|
||
aliases: ["gs", "golf"],
|
||
name: "GolfScript",
|
||
main: "main.gs",
|
||
run: "golfscript main.gs",
|
||
template: `'Hello, world!'
|
||
`,
|
||
},
|
||
groovy: {
|
||
name: "Groovy",
|
||
repl: `JAVA_OPTS="-Djava.util.prefs.systemRoot=$PWD/.java -Djava.util.prefs.userRoot=$PWD/.java/.userPrefs" groovysh`,
|
||
main: "main.groovy",
|
||
run: `JAVA_OPTS="-Djava.util.prefs.systemRoot=$PWD/.java -Djava.util.prefs.userRoot=$PWD/.java/.userPrefs" groovysh main.groovy`,
|
||
scope: {
|
||
code: `x = 123 * 234;`,
|
||
},
|
||
template: `print "Hello, world!";
|
||
`,
|
||
timeout: 15,
|
||
},
|
||
hack: {
|
||
aliases: ["hhvm"],
|
||
name: "Hack",
|
||
repl: "hhvm -a",
|
||
input: "print 123 * 234",
|
||
main: "main.hack",
|
||
run: `echo "Type 'r' at the debugger prompt to run the code" && hhvm -a main.hack`,
|
||
helloInput: "r",
|
||
scope: {
|
||
code: `function x() : int {
|
||
return 123 * 234;
|
||
}`,
|
||
input: `r
|
||
p x()`,
|
||
},
|
||
template: `<<__EntryPoint>>
|
||
function main(): void {
|
||
echo "Hello, world!\\n";
|
||
}
|
||
`,
|
||
},
|
||
haskell: {
|
||
aliases: ["ghc", "ghci", "hs"],
|
||
name: "Haskell",
|
||
repl: "rm -f .ghci && ghci",
|
||
main: "Main.hs",
|
||
run: "(echo ':load Main' && echo 'main') > .ghci && ghci",
|
||
scope: {
|
||
code: `x = 123 * 234`,
|
||
},
|
||
format: {
|
||
run: "brittany",
|
||
input: `module Main where
|
||
|
||
main :: IO ()
|
||
main =
|
||
putStrLn "Hello, world!"
|
||
`,
|
||
},
|
||
lsp: {
|
||
setup: "cp /opt/haskell/hie.yaml hie.yaml",
|
||
start: "HIE_HOOGLE_DATABASE=/opt/haskell/hoogle.hoo hie --lsp",
|
||
init: {
|
||
languageServerHaskell: {},
|
||
},
|
||
},
|
||
template: `module Main where
|
||
|
||
main :: IO ()
|
||
main = putStrLn "Hello, world!"
|
||
`,
|
||
skip: ["lsp"],
|
||
},
|
||
haxe: {
|
||
aliases: ["hx"],
|
||
name: "Haxe",
|
||
main: "Main.hx",
|
||
compile: "haxe --main Main --js Main.js",
|
||
run: "node Main.js",
|
||
template: `class Main {
|
||
static public function main() {
|
||
trace("Hello, world!");
|
||
}
|
||
}
|
||
`,
|
||
},
|
||
hcl: {
|
||
aliases: ["tf", "terraform", "hashicorp", "hc"],
|
||
name: "HCL",
|
||
main: "main.hcl",
|
||
compile: "cat main.hcl | yj -cj > main.json",
|
||
run: "cat main.json | jq .",
|
||
template: `output = "Hello, world!"
|
||
`,
|
||
},
|
||
hexagony: {
|
||
aliases: ["hxg", "hex"],
|
||
name: "Hexagony",
|
||
main: "main.hxg",
|
||
run: "/opt/hexagony/interpreter.rb main.hxg",
|
||
template: ` H ; e ;
|
||
l ; d ; *
|
||
; r ; o ; w
|
||
l ; ; o ; * 4
|
||
3 3 ; @ . >
|
||
; 2 3 < \\
|
||
4 ; * /
|
||
`,
|
||
},
|
||
hy: {
|
||
name: "Hy",
|
||
repl: "hy",
|
||
input: "(* 123 234)",
|
||
main: "main.hy",
|
||
run: "hy -i main.hy",
|
||
scope: {
|
||
code: `(setv x (* 123 234))`,
|
||
},
|
||
template: `(print "Hello, world!")
|
||
`,
|
||
},
|
||
ink: {
|
||
name: "Ink",
|
||
repl: "ink",
|
||
main: "main.ink",
|
||
run: "ink main.ink; ink",
|
||
template: `std := load('../../../opt/ink/std')
|
||
str := load('../../../opt/ink/str')
|
||
|
||
log := std.log
|
||
|
||
log('Hello, world!')
|
||
`,
|
||
},
|
||
intercal: {
|
||
aliases: ["i", "ick"],
|
||
name: "INTERCAL",
|
||
main: "main.i",
|
||
compile: "ick -b main.i",
|
||
run: "./main",
|
||
template: `DO ,1 <- #14
|
||
PLEASE DO ,1 SUB #1 <- #238
|
||
DO ,1 SUB #2 <- #108
|
||
DO ,1 SUB #3 <- #112
|
||
DO ,1 SUB #4 <- #0
|
||
DO ,1 SUB #5 <- #64
|
||
DO ,1 SUB #6 <- #194
|
||
DO ,1 SUB #7 <- #48
|
||
PLEASE DO ,1 SUB #8 <- #22
|
||
DO ,1 SUB #9 <- #248
|
||
DO ,1 SUB #10 <- #168
|
||
DO ,1 SUB #11 <- #24
|
||
DO ,1 SUB #12 <- #16
|
||
PLEASE DO ,1 SUB #13 <- #162
|
||
DO ,1 SUB #14 <- #52
|
||
PLEASE READ OUT ,1
|
||
PLEASE GIVE UP
|
||
`,
|
||
},
|
||
ioke: {
|
||
aliases: ["ik"],
|
||
name: "Ioke",
|
||
repl: `JAVA_OPTS="-Duser.home=$PWD" ioke`,
|
||
main: "main.ik",
|
||
run: `JAVA_OPTS="-Duser.home=$PWD" ioke main.ik; JAVA_OPTS="-Duser.home=$PWD" ioke`,
|
||
template: `"Hello, world!" println
|
||
`,
|
||
timeout: 15,
|
||
},
|
||
java: {
|
||
aliases: ["javac"],
|
||
name: "Java",
|
||
monacoLang: "java",
|
||
main: "Main.java",
|
||
compile: "javac Main.java",
|
||
run: "java Main",
|
||
format: {
|
||
run: `clang-format --style="{BasedOnStyle: llvm, IndentWidth: 4}" --assume-filename=Format.java`,
|
||
input: `public class Main
|
||
{
|
||
public static void main(String[] args)
|
||
{
|
||
System.out.println("Hello, world!");
|
||
}
|
||
}
|
||
`,
|
||
},
|
||
lsp: {
|
||
setup: "rm -rf jdt && cp -RT /opt/jdt/config_linux jdt",
|
||
start: `java -Declipse.application=org.eclipse.jdt.ls.core.id1 -Dosgi.bundles.defaultStartLevel=4 -Declipse.product=org.eclipse.jdt.ls.core.product -Dlog.level=ALL -noverify -Xmx1G -jar /opt/jdt/plugins/org.eclipse.equinox.launcher_*.jar -configuration "$PWD/jdt" -data "$PWD" --add-modules=ALL-SYSTEM --add-opens java.base/java.util=ALL-UNNAMED --add-opens java.base/java.lang=ALL-UNNAMED`,
|
||
init: {
|
||
settings: {
|
||
java: {
|
||
codeGeneration: {
|
||
toString: {
|
||
limitElements: 0,
|
||
listArrayContents: true,
|
||
skipNullValues: false,
|
||
codeStyle: "STRING_CONCATENATION",
|
||
template:
|
||
"${object.className} [${member.name()}=${member.value}, ${otherMembers}]",
|
||
},
|
||
generateComments: false,
|
||
useBlocks: false,
|
||
hashCodeEquals: {
|
||
useInstanceof: false,
|
||
useJava7Objects: false,
|
||
},
|
||
},
|
||
format: {
|
||
onType: {
|
||
enabled: true,
|
||
},
|
||
comments: {
|
||
enabled: true,
|
||
},
|
||
enabled: true,
|
||
},
|
||
progressReports: {
|
||
enabled: true,
|
||
},
|
||
foldingRange: {
|
||
enabled: true,
|
||
},
|
||
completion: {
|
||
importOrder: ["java", "javax", "com", "org"],
|
||
favoriteStaticMembers: [
|
||
"org.junit.Assert.*",
|
||
"org.junit.Assume.*",
|
||
"org.junit.jupiter.api.Assertions.*",
|
||
"org.junit.jupiter.api.Assumptions.*",
|
||
"org.junit.jupiter.api.DynamicContainer.*",
|
||
"org.junit.jupiter.api.DynamicTest.*",
|
||
"org.mockito.Mockito.*",
|
||
"org.mockito.ArgumentMatchers.*",
|
||
"org.mockito.Answers.*",
|
||
],
|
||
guessMethodArguments: true,
|
||
overwrite: true,
|
||
enabled: true,
|
||
filteredTypes: ["java.awt.*", "com.sun.*"],
|
||
},
|
||
maxConcurrentBuilds: 1,
|
||
autobuild: {
|
||
enabled: true,
|
||
},
|
||
selection: {
|
||
enabled: true,
|
||
},
|
||
import: {
|
||
exclusions: [
|
||
"**/node_modules/**",
|
||
"**/.metadata/**",
|
||
"**/archetype-resources/**",
|
||
"**/META-INF/maven/**",
|
||
],
|
||
maven: {
|
||
enabled: true,
|
||
},
|
||
gradle: {
|
||
enabled: true,
|
||
wrapper: {
|
||
enabled: true,
|
||
},
|
||
},
|
||
},
|
||
saveActions: {
|
||
organizeImports: false,
|
||
},
|
||
implementationsCodeLens: {
|
||
enabled: false,
|
||
},
|
||
signatureHelp: {
|
||
enabled: true,
|
||
},
|
||
referencesCodeLens: {
|
||
enabled: false,
|
||
},
|
||
maven: {
|
||
downloadSources: false,
|
||
},
|
||
trace: {
|
||
server: "off",
|
||
},
|
||
configuration: {
|
||
updateBuildConfiguration: "automatic",
|
||
checkProjectSettingsExclusions: true,
|
||
},
|
||
errors: {
|
||
incompleteClasspath: {
|
||
severity: "warning",
|
||
},
|
||
},
|
||
dependency: {
|
||
packagePresentation: "flat",
|
||
},
|
||
},
|
||
},
|
||
extendedClientCapabilities: {
|
||
progressReportProvider: true,
|
||
classFileContentsSupport: true,
|
||
overrideMethodsPromptSupport: true,
|
||
hashCodeEqualsPromptSupport: true,
|
||
advancedOrganizeImportsSupport: true,
|
||
generateConstructorsPromptSupport: true,
|
||
generateToStringPromptSupport: true,
|
||
advancedGenerateAccessorsSupport: true,
|
||
advancedExtractRefactoringSupport: true,
|
||
moveRefactoringSupport: true,
|
||
},
|
||
bundles: [
|
||
"/opt/jdt/bundles/com.microsoft.java.test.plugin-0.19.0.jar",
|
||
"/opt/jdt/bundles/com.microsoft.jdtls.ext.core-0.5.1.jar",
|
||
"/opt/jdt/bundles/dg.jdt.ls.decompiler.cfr-0.0.2-201802221740.jar",
|
||
"/opt/jdt/bundles/dg.jdt.ls.decompiler.common-0.0.2-201802221740.jar",
|
||
"/opt/jdt/bundles/dg.jdt.ls.decompiler.fernflower-0.0.2-201802221740.jar",
|
||
"/opt/jdt/bundles/dg.jdt.ls.decompiler.procyon-0.0.2-201802221740.jar",
|
||
"/opt/jdt/bundles/io.projectreactor.reactor-core.jar",
|
||
"/opt/jdt/bundles/java.debug.plugin.jar",
|
||
"/opt/jdt/bundles/jdt-ls-commons.jar",
|
||
"/opt/jdt/bundles/jdt-ls-extension.jar",
|
||
"/opt/jdt/bundles/org.reactivestreams.reactive-streams.jar",
|
||
],
|
||
},
|
||
},
|
||
template: `public class Main {
|
||
public static void main(String[] args) {
|
||
System.out.println("Hello, world!");
|
||
}
|
||
}
|
||
`,
|
||
skip: ["lsp"],
|
||
},
|
||
javascript: {
|
||
aliases: ["node", "js", "web", "jsx", "v8", "closure", "nodejs"],
|
||
name: "Node.js",
|
||
monacoLang: "javascript",
|
||
repl: "node",
|
||
main: "main.js",
|
||
run: `node -e "$(< main.js)" -i`,
|
||
scope: {
|
||
code: `let x = 123 * 234;`,
|
||
},
|
||
format: {
|
||
run: "prettier --no-config --stdin-filepath=format.js",
|
||
input: `console.log('Hello, world!');
|
||
`,
|
||
},
|
||
pkg: {
|
||
install: "yarn add NAME",
|
||
uninstall: "yarn remove NAME",
|
||
search:
|
||
"curl -sS 'https://registry.npmjs.org/-/v1/search?text=NAME' | jq -r '.objects | map(.package.name) | .[]'",
|
||
},
|
||
template: `console.log("Hello, world!");
|
||
`,
|
||
},
|
||
julia: {
|
||
aliases: ["jl"],
|
||
name: "Julia",
|
||
repl: "julia",
|
||
main: "main.jl",
|
||
run: "julia -L main.jl",
|
||
scope: {
|
||
code: `x = 123 * 234`,
|
||
},
|
||
lsp: {
|
||
start: `JULIA_DEPOT_PATH=:/opt/julia julia -e 'using LanguageServer; run(LanguageServerInstance(stdin, stdout))'`,
|
||
config: null,
|
||
},
|
||
template: `println("Hello, world!")
|
||
`,
|
||
skip: ["lsp"],
|
||
},
|
||
kalyn: {
|
||
name: "Kalyn",
|
||
main: "src-kalyn/Main.kalyn",
|
||
compile: "kalyn",
|
||
run: "out-kalyn/Main",
|
||
template: `(import "/opt/kalyn/Stdlib.kalyn")
|
||
|
||
(public def main (IO Empty)
|
||
(print "Hello, world!\\n"))
|
||
`,
|
||
},
|
||
kitten: {
|
||
aliases: ["ktn"],
|
||
name: "Kitten",
|
||
repl: "kitten",
|
||
input: "(123 * 234) say",
|
||
main: "main.ktn",
|
||
run: "kitten main.ktn; kitten",
|
||
template: `"Hello, world!" say
|
||
`,
|
||
timeout: 15,
|
||
},
|
||
kotlin: {
|
||
aliases: ["kts", "kotlinc"],
|
||
name: "Kotlin",
|
||
monacoLang: "kotlin",
|
||
repl: `JAVA_OPTS="-Duser.home=$PWD" kotlinc`,
|
||
main: "main.kts",
|
||
run: `JAVA_OPTS="-Duser.home=$PWD" kotlinc -script main.kts; kotlinc`,
|
||
template: `println("Hello, world!")
|
||
`,
|
||
timeout: 30,
|
||
},
|
||
ksh: {
|
||
aliases: ["kshell"],
|
||
name: "Ksh",
|
||
monacoLang: "shell",
|
||
repl: `SHELL=/usr/bin/ksh HOME="$PWD" ksh`,
|
||
input: "expr 123 * 234",
|
||
main: ".kshrc",
|
||
createEmpty: ``,
|
||
run: `SHELL=/usr/bin/ksh HOME="$PWD" ksh`,
|
||
scope: {
|
||
code: `x="$(expr 123 * 234)"`,
|
||
input: `echo "$x"`,
|
||
},
|
||
template: `echo "Hello, world!"
|
||
`,
|
||
},
|
||
less: {
|
||
aliases: ["lessc"],
|
||
name: "Less",
|
||
monacoLang: "less",
|
||
main: "main.less",
|
||
run: "lessc main.less",
|
||
format: {
|
||
run: "prettier --no-config --stdin-filepath=format.less",
|
||
input: `body:before {
|
||
content: "Hello, world!";
|
||
}
|
||
`,
|
||
},
|
||
template: `body:before {
|
||
content: "Hello, world!";
|
||
}
|
||
`,
|
||
},
|
||
livescript: {
|
||
aliases: ["lsc", "ls"],
|
||
name: "LiveScript",
|
||
repl: "lsc",
|
||
main: "main.ls",
|
||
run: "lsc -r ./main.ls",
|
||
template: `console.log "Hello, world!"
|
||
`,
|
||
skip: ["repl", "runrepl"],
|
||
},
|
||
llvm: {
|
||
name: "LLVM",
|
||
monacoLang: "shell",
|
||
main: "main.ll",
|
||
compile: "clang -Wno-override-module main.ll -o main",
|
||
run: "./main",
|
||
template: `@.str = private unnamed_addr constant [13 x i8] c"Hello, world!"
|
||
|
||
declare i32 @puts(i8* nocapture) nounwind
|
||
|
||
define i32 @main() {
|
||
%cast210 = getelementptr [13 x i8],[13 x i8]* @.str, i64 0, i64 0
|
||
call i32 @puts(i8* %cast210)
|
||
ret i32 0
|
||
}
|
||
`,
|
||
},
|
||
lolcode: {
|
||
aliases: ["lol", "lci"],
|
||
name: "LOLCODE",
|
||
main: "main.lol",
|
||
run: "lci main.lol",
|
||
template: `HAI 1.2
|
||
VISIBLE "Hello, world!"
|
||
KTHXBYE
|
||
`,
|
||
},
|
||
lua: {
|
||
name: "Lua",
|
||
monacoLang: "lua",
|
||
repl: "lua",
|
||
main: "main.lua",
|
||
run: "lua -i main.lua",
|
||
scope: {
|
||
code: `x = 123 * 234`,
|
||
},
|
||
lsp: { start: "java -cp /usr/lib/EmmyLua-LS.jar com.tang.vscode.MainKt" },
|
||
template: `print("Hello, world!")
|
||
`,
|
||
skip: ["lsp"],
|
||
},
|
||
malbolge: {
|
||
aliases: ["mb"],
|
||
name: "Malbolge",
|
||
main: "main.mb",
|
||
run: "malbolge main.mb",
|
||
hello: "Hello World!",
|
||
template:
|
||
" (=<`#9]~6ZY32Vx/4Rs+0No-&Jk)\"Fh}|Bcy?`=*z]Kw%oG4UUS0/@-ejc(:'8dc\n",
|
||
},
|
||
mariadb: {
|
||
aliases: ["maria"],
|
||
name: "MariaDB",
|
||
repl: `rm -rf data && /opt/mariadb/scripts/mariadb-install-db --user="$(id -un)" && (/opt/mariadb/bin/mysqld --datadir="$PWD/data" --socket="$PWD/socket" --skip-networking &) && until [[ -e socket ]]; do sleep 0.01; done && mysql --socket="$PWD/socket"`,
|
||
input: "SELECT 123 * 234;",
|
||
main: "main.sql",
|
||
run: `rm -rf data && /opt/mariadb/scripts/mariadb-install-db --user="$(id -un)" && (/opt/mariadb/bin/mysqld --datadir="$PWD/data" --socket="$PWD/socket" --skip-networking &) && until [[ -e socket ]]; do sleep 0.01; done && (mysql --socket="$PWD/socket" < main.sql; mysql --socket="$PWD/socket")`,
|
||
lsp: {
|
||
start: "sqls",
|
||
},
|
||
template: `SELECT 'Hello, world!';
|
||
`,
|
||
skip: ["lsp"],
|
||
},
|
||
markdown: {
|
||
aliases: [
|
||
"mdown",
|
||
"mkdn",
|
||
"md",
|
||
"mkd",
|
||
"mdwn",
|
||
"mdtxt",
|
||
"mdtext",
|
||
"text",
|
||
"rmd",
|
||
],
|
||
name: "Markdown",
|
||
monacoLang: "markdown",
|
||
main: "main.md",
|
||
compile: "pandoc main.md -o main.html",
|
||
run: "prettier --no-config main.html",
|
||
format: {
|
||
run: "prettier --no-config --stdin-filepath=format.md",
|
||
input: `Hello, world!
|
||
|
||
`,
|
||
},
|
||
template: `Hello, world!
|
||
`,
|
||
},
|
||
mediawiki: {
|
||
aliases: ["media"],
|
||
name: "MediaWiki",
|
||
main: "main.txt",
|
||
compile: "pandoc main.txt -f mediawiki -o main.html",
|
||
run: "prettier --no-config main.html",
|
||
template: `Hello, world!
|
||
`,
|
||
},
|
||
mips: {
|
||
aliases: ["mips64"],
|
||
name: "MIPS",
|
||
monacoLang: "mips",
|
||
main: "main.S",
|
||
compile: "mips64-linux-gnuabi64-gcc main.S -o main -static",
|
||
run: "qemu-mips64-static main",
|
||
template: ` .text
|
||
.global main
|
||
main:
|
||
li $v0, 5001
|
||
li $a0, 1
|
||
dla $a1, message
|
||
li $a2, 14
|
||
syscall
|
||
li $v0, 5058
|
||
li $a0, 0
|
||
syscall
|
||
.data
|
||
message:
|
||
.string "Hello, world!\\n"
|
||
`,
|
||
},
|
||
mongodb: {
|
||
aliases: ["mongo", "mongod"],
|
||
name: "MongoDB",
|
||
repl: `while ps -u "$(id -un)" -o comm | grep -q mongod; do sleep 0.01; done && rm -rf data && mkdir data && (mongod --dbpath=data --unixSocketPrefix="$PWD" --bind_ip=, &) && until mongo --host "$PWD/mongodb-27017.sock" --eval ' ' &>/dev/null; do sleep 0.01; done && mongo --host "$PWD/mongodb-27017.sock"`,
|
||
main: "main.js",
|
||
run: `while ps -u "$(id -un)" -o comm | grep -q mongod; do sleep 0.01; done && rm -rf data && mkdir data && (mongod --dbpath=data --unixSocketPrefix="$PWD" --bind_ip=, &) && until mongo --host "$PWD/mongodb-27017.sock" --eval ' ' &>/dev/null; do sleep 0.01; done && mongo --host "$PWD/mongodb-27017.sock" --shell main.js`,
|
||
template: `print("Hello, world!")
|
||
`,
|
||
},
|
||
mumps: {
|
||
aliases: ["mlang", "gtm", "fisgtm"],
|
||
name: "MUMPS",
|
||
main: "main.m",
|
||
run:
|
||
"gtm_dist=/usr/lib/x86_64-linux-gnu/fis-gtm/V6.3-007_x86_64 /usr/lib/x86_64-linux-gnu/fis-gtm/V6.3-007_x86_64/utf8/mumps -r main main.m",
|
||
template: `main()
|
||
write "Hello, world!",!
|
||
quit
|
||
`,
|
||
},
|
||
mysql: {
|
||
aliases: ["my"],
|
||
name: "MySQL",
|
||
repl: `rm -rf data && mysqld -h "$PWD/data" --initialize-insecure && (mysqld -h "$PWD/data" --socket="$PWD/socket" --pid-file="$PWD/pid-file" --mysqlx=OFF --skip-networking &) && until [[ -e socket ]]; do sleep 0.01; done && mysql --socket="$PWD/socket" -u root`,
|
||
input: "SELECT 123 * 234;",
|
||
main: "main.sql",
|
||
run: `rm -rf data && mysqld -h "$PWD/data" --initialize-insecure && (mysqld -h "$PWD/data" --socket="$PWD/socket" --pid-file="$PWD/pid-file" --mysqlx=OFF --skip-networking &) && until [[ -e socket ]]; do sleep 0.01; done && (mysql --socket="$PWD/socket" -u root < main.sql; mysql --socket="$PWD/socket" -u root)`,
|
||
lsp: {
|
||
start: "sqls",
|
||
},
|
||
template: `SELECT 'Hello, world!';
|
||
`,
|
||
timeout: 15,
|
||
skip: ["lsp"],
|
||
},
|
||
nim: {
|
||
name: "Nim",
|
||
main: "main.nim",
|
||
compile: "nim compile main.nim",
|
||
run: "./main",
|
||
template: `echo "Hello, world!"
|
||
`,
|
||
},
|
||
objectivec: {
|
||
aliases: ["objc", "gnustep"],
|
||
name: "Objective-C",
|
||
monacoLang: "objective-c",
|
||
main: "main.m",
|
||
compile:
|
||
"gcc $(gnustep-config --objc-flags) main.m $(gnustep-config --base-libs) -o main",
|
||
run: "./main",
|
||
format: {
|
||
run: "clang-format --assume-filename=format.m",
|
||
input: `#import <Foundation/Foundation.h>
|
||
|
||
int main() {
|
||
NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
|
||
NSLog(@"Hello, world!");
|
||
[pool drain];
|
||
return 0;
|
||
}
|
||
`,
|
||
},
|
||
lsp: {
|
||
setup: `(gnustep-config --objc-flags && gnustep-config --base-libs) | sed -E 's/\\s+/\\n/g' > compile_flags.txt`,
|
||
start: "clangd",
|
||
},
|
||
template: `#import <Foundation/Foundation.h>
|
||
|
||
int main() {
|
||
NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
|
||
NSLog(@"Hello, world!");
|
||
[pool drain];
|
||
return 0;
|
||
}
|
||
`,
|
||
skip: ["lsp"],
|
||
},
|
||
ocaml: {
|
||
name: "OCaml",
|
||
main: "main.ml",
|
||
repl: "ocaml",
|
||
input: "123 * 234 ;;",
|
||
run: "ocaml -init main.ml",
|
||
scope: {
|
||
code: `;;
|
||
let x = 123 * 234`,
|
||
input: `x ;;`,
|
||
},
|
||
format: {
|
||
run: "touch .ocamlformat; ocamlformat --name=format.ml -",
|
||
input: `print_string "Hello, world!\\n";;
|
||
`,
|
||
},
|
||
lsp: { start: "ocamllsp", lang: "ocaml" },
|
||
template: `;;
|
||
print_string "Hello, world!\\n"
|
||
`,
|
||
skip: ["lsp"],
|
||
},
|
||
octave: {
|
||
aliases: ["matlab", "m", "mathworks"],
|
||
name: "Octave",
|
||
repl: "octave",
|
||
main: "main.m",
|
||
run: "octave --persist main.m",
|
||
scope: {
|
||
code: `x = 123 * 234`,
|
||
},
|
||
template: `disp("Hello, world!")
|
||
`,
|
||
},
|
||
omgrofl: {
|
||
aliases: ["omg", "rofl"],
|
||
name: "Omgrofl",
|
||
main: "main.omgrofl",
|
||
run: "java -jar /opt/omgrofl/Omgrofl.jar main.omgrofl",
|
||
template: `lol iz 72
|
||
rofl lol
|
||
lol iz 101
|
||
rofl lol
|
||
lol iz 108
|
||
rofl lol
|
||
rofl lol
|
||
lool iz 111
|
||
rofl lool
|
||
loool iz 44
|
||
rofl loool
|
||
loool iz 32
|
||
rofl loool
|
||
loool iz 119
|
||
rofl loool
|
||
rofl lool
|
||
lool iz 114
|
||
rofl lool
|
||
rofl lol
|
||
lol iz 100
|
||
rofl lol
|
||
lol iz 33
|
||
rofl lol
|
||
lol iz 10
|
||
rofl lol
|
||
`,
|
||
},
|
||
org: {
|
||
aliases: ["orgmode"],
|
||
name: "Org",
|
||
main: "main.org",
|
||
compile: "pandoc main.org -o main.html",
|
||
run: "prettier --no-config main.html",
|
||
template: `Hello, world!
|
||
`,
|
||
},
|
||
pascal: {
|
||
aliases: ["pas", "fpc"],
|
||
name: "Pascal",
|
||
monacoLang: "pascal",
|
||
main: "main.pas",
|
||
compile: "fpc main.pas",
|
||
run: "./main",
|
||
template: `program Main;
|
||
begin
|
||
writeln('Hello, world!');
|
||
end.
|
||
`,
|
||
},
|
||
perl: {
|
||
aliases: ["pl", "repl"],
|
||
name: "Perl",
|
||
monacoLang: "perl",
|
||
repl: "re.pl",
|
||
main: "main.pl",
|
||
run: "re.pl --rcfile ./main.pl",
|
||
scope: {
|
||
code: `my $x = 123 * 234;`,
|
||
input: `$x`,
|
||
},
|
||
format: {
|
||
run: "perltidy",
|
||
input: `print ("Hello, world!\\n");
|
||
`,
|
||
},
|
||
template: `print("Hello, world!\\n");
|
||
`,
|
||
},
|
||
php: {
|
||
aliases: ["phpcli"],
|
||
name: "PHP",
|
||
monacoLang: "php",
|
||
repl: "php -a",
|
||
input: "print 123 * 234;",
|
||
main: "main.php",
|
||
run: "php -d auto_prepend_file=main.php -a",
|
||
scope: {
|
||
code: `$x = 123 * 234;`,
|
||
input: `echo $x;`,
|
||
},
|
||
lsp: { start: "intelephense --stdio" },
|
||
template: `<?php
|
||
|
||
echo "Hello, world!\\n";
|
||
`,
|
||
skip: ["lsp"],
|
||
},
|
||
pikachu: {
|
||
aliases: [
|
||
"pika",
|
||
"pi",
|
||
"ka",
|
||
"chu",
|
||
"pipi",
|
||
"pichu",
|
||
"pikapi",
|
||
"poke",
|
||
"pokemon",
|
||
"pokeball",
|
||
],
|
||
name: "Pikachu",
|
||
main: "main.pokeball",
|
||
run: "pikalang main.pokeball",
|
||
hello: "Hello World!",
|
||
template: `pi pi pi pi pi pi pi pi pi pi pika pipi pi pi pi pi pi pi pi pipi pi pi
|
||
pi pi pi pi pi pi pi pi pipi pi pi pi pipi pi pichu pichu pichu pichu ka
|
||
chu pipi pi pi pikachu pipi pi pikachu pi pi pi pi pi pi pi pikachu
|
||
pikachu pi pi pi pikachu pipi pi pi pikachu pichu pichu pi pi pi pi pi
|
||
pi pi pi pi pi pi pi pi pi pi pikachu pipi pikachu pi pi pi pikachu ka
|
||
ka ka ka ka ka pikachu ka ka ka ka ka ka ka ka pikachu pipi pi pikachu
|
||
pipi pikachu
|
||
`,
|
||
},
|
||
postgresql: {
|
||
aliases: ["psql", "postgres", "pgsql", "postgre"],
|
||
name: "PostgreSQL",
|
||
monacoLang: "pgsql",
|
||
repl: `rm -rf data && /usr/lib/postgresql/*/bin/initdb -D data && (echo "listen_addresses = ''" && echo "unix_socket_directories = '.'") >> data/postgresql.conf && /usr/lib/postgresql/*/bin/pg_ctl -D data -w start && psql -h "$PWD/data" postgres`,
|
||
input: "SELECT 123 * 234;",
|
||
main: "main.sql",
|
||
run: `rm -rf data && /usr/lib/postgresql/*/bin/initdb -D data && (echo "listen_addresses = ''" && echo "unix_socket_directories = '.'") >> data/postgresql.conf && /usr/lib/postgresql/*/bin/pg_ctl -D data -w start && (psql -h "$PWD/data" postgres -f main.sql; psql -h "$PWD/data" postgres)`,
|
||
lsp: {
|
||
start: "sqls",
|
||
},
|
||
template: `SELECT 'Hello, world!';
|
||
`,
|
||
timeout: 15,
|
||
skip: ["lsp"],
|
||
},
|
||
powershell: {
|
||
aliases: ["pwsh", "ps1"],
|
||
name: "PowerShell",
|
||
monacoLang: "powershell",
|
||
repl: "SHELL=/usr/bin/pwsh pwsh",
|
||
input: `expr 123 "*" 234`,
|
||
main: "main.ps1",
|
||
run: "SHELL=/usr/bin/pwsh pwsh -NoExit main.ps1",
|
||
scope: {
|
||
code: `Set-Variable x "$(expr 123 "*" 234)"`,
|
||
input: `echo $x`,
|
||
},
|
||
lsp: {
|
||
start: `pwsh -NoLogo -NoProfile -Command "/opt/powershell-editor-services/PowerShellEditorServices/Start-EditorServices.ps1 -BundledModulesPath /opt/powershell-editor-services -LogPath '$PWD/.powershell-editor-services/lsp.log' -SessionDetailsPath '$PWD/.powershell-editor-services/session.json' -FeatureFlags @() -AdditionalModules @() -HostName Riju -HostProfileId 'riju' -HostVersion 0.0 -Stdio -LogLevel Normal"`,
|
||
},
|
||
template: `Write-Host "Hello, world!"
|
||
`,
|
||
skip: ["repl", "runrepl", "scope", "lsp"],
|
||
},
|
||
prolog: {
|
||
name: "Prolog",
|
||
repl: "prolog",
|
||
input: "X is 123 * 234.",
|
||
main: "main.pl",
|
||
run: "prolog main.pl",
|
||
scope: {
|
||
code: `x(X) :- X is 123 * 234.`,
|
||
input: `x(X).`,
|
||
},
|
||
template: `:- initialization main.
|
||
|
||
main :-
|
||
write("Hello, world!"), nl.
|
||
`,
|
||
},
|
||
pug: {
|
||
name: "Pug",
|
||
monacoLang: "pug",
|
||
main: "main.pug",
|
||
compile: "pug main.pug",
|
||
run: "prettier --no-config main.html",
|
||
template: `html
|
||
body
|
||
p Hello, world!
|
||
`,
|
||
},
|
||
purescript: {
|
||
aliases: ["purs", "pure", "ps"],
|
||
name: "PureScript",
|
||
setup: `shopt -s dotglob; cp -R /opt/purescript/project-template/* "$PWD/"`,
|
||
repl: "spago repl",
|
||
main: "src/Main.purs",
|
||
run: `if spago build -n; then spago run -n; (echo 'import Prelude'; echo 'import Main') > .purs-repl; spago repl; else echo 'import Prelude' > .purs-repl; spago repl -d; fi`,
|
||
template: `module Main where
|
||
|
||
import Prelude
|
||
|
||
import Effect (Effect)
|
||
import Effect.Console (log)
|
||
|
||
main :: Effect Unit
|
||
main = do
|
||
log "Hello, world!"
|
||
`,
|
||
timeout: 60,
|
||
},
|
||
python: {
|
||
aliases: ["python3", "python2", "py"],
|
||
name: "Python",
|
||
monacoLang: "python",
|
||
repl: "python3 -u",
|
||
main: "main.py",
|
||
run: "python3 -u -i main.py",
|
||
scope: {
|
||
code: `x = 123 * 234`,
|
||
},
|
||
format: {
|
||
run: "black -",
|
||
input: `print('Hello, world!')
|
||
`,
|
||
},
|
||
pkg: {
|
||
install: "pip3 install --user NAME",
|
||
uninstall: "pip3 uninstall NAME",
|
||
search: `python3 -c 'import json; from xmlrpc import client; print(json.dumps(client.ServerProxy("https://pypi.org/pypi").search({"name": "NAME"})))' | jq -r 'map(.name) | .[]'`,
|
||
},
|
||
lsp: {
|
||
start: "Microsoft.Python.LanguageServer",
|
||
init: {
|
||
interpreter: {
|
||
properties: {
|
||
InterpreterPath: "/usr/bin/python3",
|
||
},
|
||
},
|
||
},
|
||
code: "import func",
|
||
item: "functools",
|
||
},
|
||
template: `print("Hello, world!")
|
||
`,
|
||
timeout: 15,
|
||
},
|
||
قلب: {
|
||
aliases: ["qalb"],
|
||
name: "قلب",
|
||
repl: "node /opt/qalb/repl.js",
|
||
input: "(ضرب ١٢٣ ٢٣٤)",
|
||
main: "main.qalb",
|
||
hello: "مرحبا يا عالم",
|
||
run: "node /opt/qalb/repl.js main.qalb",
|
||
scope: {
|
||
code: `(حدد خ (ضرب ١٢٣ ٢٣٤))`,
|
||
input: `خ`,
|
||
},
|
||
template: `(قول "مرحبا يا عالم")
|
||
`,
|
||
},
|
||
r: {
|
||
aliases: ["rlang"],
|
||
name: "R",
|
||
monacoLang: "r",
|
||
repl: "R",
|
||
main: ".Rprofile",
|
||
run: "R --no-save",
|
||
scope: {
|
||
code: `x = 123 * 234`,
|
||
},
|
||
template: `print("Hello, world!")
|
||
`,
|
||
},
|
||
racket: {
|
||
aliases: ["rkt"],
|
||
name: "Racket",
|
||
repl: "racket",
|
||
input: "(* 123 234)",
|
||
main: "main.rkt",
|
||
run: `racket -i -e '(enter! "main.rkt") (display "[ type (enter! \\"main.rkt\\") to access local variables ]\\n")'`,
|
||
scope: {
|
||
code: `(define x (* 123 234))`,
|
||
input: `(enter! "main.rkt")
|
||
x`,
|
||
},
|
||
template: `#lang racket/base
|
||
(display "Hello, world!\\n")
|
||
`,
|
||
},
|
||
рапира: {
|
||
aliases: ["rap", "rerap", "rerap2", "rapira"],
|
||
name: "Рапира",
|
||
main: "main.rap",
|
||
run: "rapira main.rap",
|
||
template: `вывод: "Hello, world!"
|
||
`,
|
||
},
|
||
reasonml: {
|
||
aliases: ["re", "reason", "bsc", "buckle", "bucklescript"],
|
||
name: "ReasonML",
|
||
main: "main.re",
|
||
compile: "bsc main.re > main.js",
|
||
run: "NODE_PATH=/usr/lib/node_modules node main.js",
|
||
format: {
|
||
run: "refmt",
|
||
input: `print_string("Hello, world!\\n")
|
||
`,
|
||
},
|
||
lsp: {
|
||
setup: `cp -a /opt/reasonml/project-template/* ./`,
|
||
start: "reason-language-server",
|
||
},
|
||
template: `print_string("Hello, world!\\n");
|
||
`,
|
||
skip: ["lsp"],
|
||
},
|
||
redis: {
|
||
name: "Redis",
|
||
monacoLang: "redis",
|
||
repl:
|
||
"rm -f socket; (redis-server --port 0 --unixsocket socket &); until [[ -e socket ]]; do sleep 0.01; done; redis-cli -s socket",
|
||
input: `EVAL "return 123 * 234" 0`,
|
||
main: "main.redis",
|
||
run:
|
||
"rm -f socket; (redis-server --port 0 --unixsocket socket &); until [[ -e socket ]]; do sleep 0.01; done; redis-cli -s socket < main.redis; redis-cli -s socket",
|
||
template: `ECHO "Hello, world!"
|
||
`,
|
||
skip: ["repl", "runrepl"],
|
||
},
|
||
restructuredtext: {
|
||
aliases: ["rst"],
|
||
name: "reStructuredText",
|
||
monacoLang: "restructuredtext",
|
||
main: "main.rst",
|
||
compile: "pandoc main.rst -o main.html",
|
||
run: "prettier --no-config main.html",
|
||
template: `Hello, world!
|
||
`,
|
||
},
|
||
riscv: {
|
||
aliases: ["risc"],
|
||
name: "RISC-V",
|
||
main: "main.S",
|
||
compile: "riscv64-linux-gnu-gcc main.S -o main -static",
|
||
run: "qemu-riscv64-static main",
|
||
template: ` .text
|
||
.global main
|
||
main:
|
||
addi a7, x0, 64
|
||
addi a0, x0, 1
|
||
la a1, message
|
||
addi a2, x0, 14
|
||
ecall
|
||
addi a7, x0, 93
|
||
addi a0, x0, 0
|
||
ecall
|
||
.data
|
||
message:
|
||
.string "Hello, world!\\n"
|
||
`,
|
||
},
|
||
roff: {
|
||
aliases: [
|
||
"groff",
|
||
"nroff",
|
||
"troff",
|
||
"1",
|
||
"2",
|
||
"3",
|
||
"4",
|
||
"5",
|
||
"6",
|
||
"7",
|
||
"8",
|
||
"9",
|
||
"man",
|
||
"manual",
|
||
],
|
||
name: "roff",
|
||
main: "main.roff",
|
||
compile: "pandoc main.roff -f man -o main.html",
|
||
run: "prettier --no-config main.html",
|
||
template: `.PP
|
||
Hello, world!
|
||
`,
|
||
},
|
||
ruby: {
|
||
aliases: ["irb", "rb"],
|
||
name: "Ruby",
|
||
monacoLang: "ruby",
|
||
repl: "irb",
|
||
main: "main.rb",
|
||
suffix: `
|
||
require 'irb'
|
||
IRB.setup(ARGV[0], argv: [])
|
||
workspace = IRB::WorkSpace.new(binding)
|
||
binding_irb = IRB::Irb.new(workspace)
|
||
binding_irb.run(IRB.conf)
|
||
`,
|
||
run: "ruby main.rb",
|
||
scope: {
|
||
code: `x = 5`,
|
||
},
|
||
format: {
|
||
run: "rufo -x",
|
||
input: `puts "Hello, world!";
|
||
`,
|
||
},
|
||
pkg: {
|
||
install: "gem install --user-install NAME",
|
||
uninstall: "gem uninstall --user-install NAME",
|
||
search: `curl -sS 'https://rubygems.org/api/v1/search.json?query=NAME' | jq -r 'map(.name) | .[]'`,
|
||
},
|
||
lsp: { start: "solargraph stdio" },
|
||
template: `puts "Hello, world!"
|
||
`,
|
||
skip: ["repl", "runrepl", "scope", "lsp"],
|
||
},
|
||
rust: {
|
||
aliases: ["rs", "rustc"],
|
||
name: "Rust",
|
||
monacoLang: "rust",
|
||
main: "main.rs",
|
||
compile: "rustc main.rs",
|
||
run: "./main",
|
||
lsp: { start: "rls" },
|
||
template: `fn main() {
|
||
println!("Hello, world!");
|
||
}
|
||
`,
|
||
skip: ["lsp"],
|
||
},
|
||
sass: {
|
||
name: "Sass",
|
||
main: "main.sass",
|
||
run: "sass main.sass",
|
||
template: `body:before
|
||
content: "Hello, world!"
|
||
`,
|
||
},
|
||
scala: {
|
||
name: "Scala",
|
||
repl: "scala",
|
||
main: "main.scala",
|
||
run: "scala -i main.scala",
|
||
scope: {
|
||
code: `val x = 123 * 234`,
|
||
},
|
||
template: `println("Hello, world!")
|
||
`,
|
||
timeout: 30,
|
||
},
|
||
scheme: {
|
||
aliases: ["scm", "mitscheme"],
|
||
name: "Scheme",
|
||
monacoLang: "scheme",
|
||
repl: "mit-scheme",
|
||
input: "(* 123 234)",
|
||
main: "main.scm",
|
||
run: "mit-scheme --load main.scm",
|
||
scope: {
|
||
code: `(define x (* 123 234))`,
|
||
},
|
||
template: `(display "Hello, world!")
|
||
(newline)
|
||
`,
|
||
},
|
||
scss: {
|
||
name: "SCSS",
|
||
monacoLang: "scss",
|
||
main: "main.scss",
|
||
run: "sass main.scss",
|
||
format: {
|
||
run: "prettier --no-config --stdin-filepath=format.scss",
|
||
input: `body:before {
|
||
content: "Hello, world!";
|
||
}
|
||
`,
|
||
},
|
||
template: `body:before {
|
||
content: "Hello, world!";
|
||
}
|
||
`,
|
||
},
|
||
sed: {
|
||
aliases: ["gsed"],
|
||
name: "Sed",
|
||
main: "main.sed",
|
||
helloInput: "",
|
||
run: "echo 'Reading from stdin...' >&2; sed -f main.sed",
|
||
template: `s/.*/Hello, world!/
|
||
`,
|
||
},
|
||
setl: {
|
||
name: "SETL",
|
||
main: "main.setl",
|
||
run: "setl main.setl",
|
||
template: `print("Hello, world!");
|
||
`,
|
||
},
|
||
sh: {
|
||
aliases: ["shell", "posix", "posixsh", "ash", "dash", "posh"],
|
||
name: "Sh",
|
||
monacoLang: "shell",
|
||
repl: `SHELL=/usr/bin/sh HOME="$PWD" posh -l`,
|
||
input: `expr 123 \\* 234`,
|
||
main: ".profile",
|
||
createEmpty: ``,
|
||
run: `SHELL=/usr/bin/sh HOME="$PWD" posh -l`,
|
||
scope: {
|
||
code: `x="$(expr 123 \\* 234)"`,
|
||
input: `echo "$x"`,
|
||
},
|
||
template: `echo "Hello, world!"
|
||
`,
|
||
},
|
||
shakespeare: {
|
||
aliases: ["spl"],
|
||
name: "Shakespeare",
|
||
repl: "shakespeare console",
|
||
input: `Hamlet, a placeholder.
|
||
done
|
||
stage`,
|
||
output: "Off stage",
|
||
main: "main.spl",
|
||
hello: "Hello World!",
|
||
suffix: "\n[A pause]",
|
||
run: "shakespeare debug main.spl",
|
||
runReplInput: "stage",
|
||
template: `The Infamous Hello World Program.
|
||
|
||
Romeo, a young man with a remarkable patience.
|
||
Juliet, a likewise young woman of remarkable grace.
|
||
Ophelia, a remarkable woman much in dispute with Hamlet.
|
||
Hamlet, the flatterer of Andersen Insulting A/S.
|
||
|
||
|
||
Act I: Hamlet's insults and flattery.
|
||
|
||
Scene I: The insulting of Romeo.
|
||
|
||
[Enter Hamlet and Romeo]
|
||
|
||
Hamlet:
|
||
You lying stupid fatherless big smelly half-witted coward!
|
||
You are as stupid as the difference between a handsome rich brave
|
||
hero and thyself! Speak your mind!
|
||
|
||
You are as brave as the sum of your fat little stuffed misused dusty
|
||
old rotten codpiece and a beautiful fair warm peaceful sunny summer's
|
||
day. You are as healthy as the difference between the sum of the
|
||
sweetest reddest rose and my father and yourself! Speak your mind!
|
||
|
||
You are as cowardly as the sum of yourself and the difference
|
||
between a big mighty proud kingdom and a horse. Speak your mind.
|
||
|
||
Speak your mind!
|
||
|
||
[Exit Romeo]
|
||
|
||
Scene II: The praising of Juliet.
|
||
|
||
[Enter Juliet]
|
||
|
||
Hamlet:
|
||
Thou art as sweet as the sum of the sum of Romeo and his horse and his
|
||
black cat! Speak thy mind!
|
||
|
||
[Exit Juliet]
|
||
|
||
Scene III: The praising of Ophelia.
|
||
|
||
[Enter Ophelia]
|
||
|
||
Hamlet:
|
||
Thou art as lovely as the product of a large rural town and my amazing
|
||
bottomless embroidered purse. Speak thy mind!
|
||
|
||
Thou art as loving as the product of the bluest clearest sweetest sky
|
||
and the sum of a squirrel and a white horse. Thou art as beautiful as
|
||
the difference between Juliet and thyself. Speak thy mind!
|
||
|
||
[Exeunt Ophelia and Hamlet]
|
||
|
||
|
||
Act II: Behind Hamlet's back.
|
||
|
||
Scene I: Romeo and Juliet's conversation.
|
||
|
||
[Enter Romeo and Juliet]
|
||
|
||
Romeo:
|
||
Speak your mind. You are as worried as the sum of yourself and the
|
||
difference between my small smooth hamster and my nose. Speak your
|
||
mind!
|
||
|
||
Juliet:
|
||
Speak YOUR mind! You are as bad as Hamlet! You are as small as the
|
||
difference between the square of the difference between my little pony
|
||
and your big hairy hound and the cube of your sorry little
|
||
codpiece. Speak your mind!
|
||
|
||
[Exit Romeo]
|
||
|
||
Scene II: Juliet and Ophelia's conversation.
|
||
|
||
[Enter Ophelia]
|
||
|
||
Juliet:
|
||
Thou art as good as the quotient between Romeo and the sum of a small
|
||
furry animal and a leech. Speak your mind!
|
||
|
||
Ophelia:
|
||
Thou art as disgusting as the quotient between Romeo and twice the
|
||
difference between a mistletoe and an oozing infected blister! Speak
|
||
your mind!
|
||
|
||
[Exeunt]
|
||
`,
|
||
timeout: 15,
|
||
},
|
||
smalltalk: {
|
||
aliases: ["gst", "st"],
|
||
name: "Smalltalk",
|
||
repl: "gst",
|
||
main: "main.st",
|
||
run: "gst main.st; gst",
|
||
template: `'Hello, world!' displayNl !
|
||
`,
|
||
},
|
||
snobol: {
|
||
aliases: ["snobol4", "spitbol", "sno"],
|
||
name: "SNOBOL",
|
||
repl: "snobol4",
|
||
input: ` OUTPUT = 123 * 234
|
||
END`,
|
||
main: "main.sno",
|
||
run: "snobol4 main.sno; snobol4",
|
||
template: ` OUTPUT = "Hello, world!"
|
||
END
|
||
`,
|
||
},
|
||
sqlite: {
|
||
aliases: ["sql", "db", "sqlite3"],
|
||
name: "SQLite",
|
||
monacoLang: "sql",
|
||
repl: "sqlite3",
|
||
input: "SELECT 123 * 234;",
|
||
main: "main.sql",
|
||
run: `sqlite3 -cmd "$(< main.sql)"`,
|
||
lsp: {
|
||
start: "sqls",
|
||
},
|
||
template: `SELECT 'Hello, world!';
|
||
`,
|
||
skip: ["lsp"],
|
||
},
|
||
standardml: {
|
||
aliases: ["sml", "ml"],
|
||
name: "Standard ML",
|
||
repl: "rlwrap sml",
|
||
input: "123 * 234;",
|
||
main: "main.sml",
|
||
run: "rlwrap sml main.sml",
|
||
scope: {
|
||
code: `val x = 123 * 234;`,
|
||
input: `x;`,
|
||
},
|
||
template: `print "Hello, world!\\n";
|
||
`,
|
||
},
|
||
swift: {
|
||
aliases: ["swiftc"],
|
||
name: "Swift",
|
||
monacoLang: "swift",
|
||
main: "main.swift",
|
||
compile: "swiftc main.swift",
|
||
run: "./main",
|
||
lsp: { start: "sourcekit-lsp" },
|
||
template: `print("Hello, world!")
|
||
`,
|
||
skip: ["lsp"],
|
||
},
|
||
tcl: {
|
||
aliases: ["tclsh", "tclshrc"],
|
||
name: "Tcl",
|
||
monacoLang: "tcl",
|
||
repl: "tclsh",
|
||
input: "expr 123 * 234",
|
||
main: ".tclshrc",
|
||
createEmpty: ``,
|
||
run: `HOME="$PWD" tclsh`,
|
||
scope: {
|
||
code: `set x [expr 123 * 234]`,
|
||
input: `echo $x`,
|
||
},
|
||
template: `puts {Hello, world!}
|
||
`,
|
||
},
|
||
tcsh: {
|
||
aliases: ["tcshell", "tcshrc", "csh"],
|
||
name: "Tcsh",
|
||
monacoLang: "shell",
|
||
repl: `SHELL=/usr/bin/tcsh HOME="$PWD" tcsh`,
|
||
input: `expr 123 \\* 234`,
|
||
main: ".tcshrc",
|
||
createEmpty: ``,
|
||
run: `SHELL=/usr/bin/tcsh HOME="$PWD" tcsh`,
|
||
scope: {
|
||
code: "set x=`expr 123 \\* 234`",
|
||
input: `echo "$x"`,
|
||
},
|
||
template: `echo "Hello, world!"
|
||
`,
|
||
},
|
||
tex: {
|
||
aliases: ["latex", "xetex", "plaintex"],
|
||
name: "TeX",
|
||
repl: "tex",
|
||
input: `\\newcount\\x
|
||
\\advance\\x by 123
|
||
\\multiply\\x by 234
|
||
\\message{\\the\\x}`,
|
||
main: "main.tex",
|
||
run: "tex main.tex",
|
||
scope: {
|
||
code: `\\newcount\\x
|
||
\\advance\\x by 123
|
||
\\multiply\\x by 234`,
|
||
input: `\\message{\\the\\x}`,
|
||
},
|
||
lsp: { start: "digestif", lang: "tex" },
|
||
template: `\\message{Hello, world!}
|
||
`,
|
||
skip: ["lsp"],
|
||
},
|
||
textile: {
|
||
name: "Textile",
|
||
main: "main.textile",
|
||
compile: "pandoc main.textile -o main.html",
|
||
run: "prettier --no-config main.html",
|
||
template: `Hello, world!
|
||
`,
|
||
},
|
||
thue: {
|
||
name: "Thue",
|
||
main: "main.thue",
|
||
run: "thue main.thue",
|
||
template: `a::=~Hello, world!
|
||
::=
|
||
a
|
||
`,
|
||
},
|
||
tikiwiki: {
|
||
aliases: ["tiki"],
|
||
name: "Tiki Wiki",
|
||
main: "main.txt",
|
||
compile: "pandoc main.txt -f tikiwiki -o main.html",
|
||
run: "prettier --no-config main.html",
|
||
template: `Hello, world!
|
||
`,
|
||
},
|
||
toml: {
|
||
aliases: ["tom"],
|
||
name: "TOML",
|
||
main: "main.toml",
|
||
compile: "cat main.toml | yj -tj > main.json",
|
||
run: "cat main.json | jq .",
|
||
template: `output = "Hello, world!"
|
||
`,
|
||
},
|
||
twiki: {
|
||
name: "TWiki",
|
||
main: "main.txt",
|
||
compile: "pandoc main.txt -f twiki -o main.html",
|
||
run: "prettier --no-config main.html",
|
||
template: `Hello, world!
|
||
`,
|
||
},
|
||
typescript: {
|
||
aliases: ["ts", "tsnode", "tsc"],
|
||
name: "TypeScript",
|
||
monacoLang: "typescript",
|
||
repl: "ts-node",
|
||
main: "main.ts",
|
||
run: `ts-node -i -e "$(< main.ts)"`,
|
||
scope: {
|
||
code: `let x = 123 * 234;`,
|
||
},
|
||
format: {
|
||
run: "prettier --no-config --stdin-filepath=format.ts",
|
||
input: `console.log('Hello, world!');
|
||
`,
|
||
},
|
||
template: `console.log("Hello, world!");
|
||
`,
|
||
timeout: 15,
|
||
},
|
||
unlambda: {
|
||
aliases: ["unl"],
|
||
name: "Unlambda",
|
||
repl: "unlambda-repl",
|
||
input: "`.2`.8`.7`.8`.2i",
|
||
main: "main.unl",
|
||
run: "unlambda-repl main.unl",
|
||
template: "`.\n`.!`.d`.l`.r`.o`.w`. `.,`.o`.l`.l`.e`.Hi\n",
|
||
},
|
||
vim: {
|
||
aliases: ["viml", "vimscript"],
|
||
name: "Vimscript",
|
||
repl: "vim",
|
||
input: ":echo 123 * 234",
|
||
main: "main.vim",
|
||
run: `vim -c "$(< main.vim)"`,
|
||
scope: {
|
||
code: `:let x = 123 * 234`,
|
||
input: `:echo x`,
|
||
},
|
||
lsp: { start: "vim-language-server --stdio" },
|
||
template: `:echo "Hello, world!"
|
||
`,
|
||
skip: ["lsp"],
|
||
},
|
||
vimwiki: {
|
||
name: "Vimwiki",
|
||
main: "main.txt",
|
||
compile: "pandoc main.txt -f vimwiki -o main.html",
|
||
run: "prettier --no-config main.html",
|
||
template: `Hello, world!
|
||
`,
|
||
},
|
||
visualbasic: {
|
||
aliases: ["vbasic", "vb", "vbnc"],
|
||
name: "Visual Basic",
|
||
monacoLang: "vb",
|
||
main: "main.vb",
|
||
compile: "vbnc main.vb",
|
||
run: "mono main.exe",
|
||
template: `Module Main
|
||
Sub Main(args As String())
|
||
Console.WriteLine("Hello, world!")
|
||
End Sub
|
||
End Module
|
||
`,
|
||
timeout: 15,
|
||
},
|
||
whitespace: {
|
||
aliases: ["ws"],
|
||
name: "Whitespace",
|
||
main: "main.ws",
|
||
run: "whitespace main.ws",
|
||
hello: "Hello, world",
|
||
template: `Hello, world \t \t \n\t\n \t\t \t \t\n\t\n \t\t \t\t \n\t\n \t\t \t\t \n\t\n \t\t \t\t\t\t\n\t\n \t \t\t \n\t\n \t \n\t\n \t\t\t \t\t\t\n\t\n \t\t \t\t\t\t\n\t\n \t\t\t \t \n\t\n \t\t \t\t \n\t\n \t\t \t \n\t\n \n\n\n`,
|
||
},
|
||
wolframlanguage: {
|
||
aliases: [
|
||
"wolfram",
|
||
"mathematica",
|
||
"mathics",
|
||
"wolframmathematica",
|
||
"wls",
|
||
"expreduce",
|
||
"symja",
|
||
],
|
||
name: "Wolfram Language",
|
||
repl: "mathics",
|
||
main: "main.wls",
|
||
run: "mathics --persist main.wls",
|
||
scope: {
|
||
code: `x = 123 * 234`,
|
||
},
|
||
template: `Print["Hello, world!"]
|
||
`,
|
||
timeout: 15,
|
||
},
|
||
x86: {
|
||
aliases: ["s", "asm", "assembly", "x86-64"],
|
||
name: "x86",
|
||
main: "main.S",
|
||
compile: "clang main.S -o main",
|
||
run: "./main",
|
||
template: ` .text
|
||
.globl main
|
||
main:
|
||
movq $1, %rax
|
||
movq $1, %rdi
|
||
leaq message(%rip), %rsi
|
||
movq $14, %rdx
|
||
syscall
|
||
movq $60, %rax
|
||
movq $0, %rdi
|
||
syscall
|
||
.data
|
||
message:
|
||
.string "Hello, world!\\n"
|
||
`,
|
||
},
|
||
yaml: {
|
||
aliases: ["yml"],
|
||
name: "YAML",
|
||
monacoLang: "yaml",
|
||
main: "main.yaml",
|
||
compile: "cat main.yaml | yj -yj > main.json",
|
||
run: "cat main.json | jq .",
|
||
format: {
|
||
run: "prettier --no-config --stdin-filepath=format.yaml",
|
||
input: `output: 'Hello, world!'
|
||
`,
|
||
},
|
||
template: `output: "Hello, world!"
|
||
`,
|
||
},
|
||
zot: {
|
||
name: "Zot",
|
||
main: "main.zot",
|
||
run: "zot --file main.zot",
|
||
hello: `0100100001100101011011000110110001101111001011000010000001110111011011110111001001101100011001000010000100001010`,
|
||
template: `111101010100111010101001001101010010010011101010100111010101
|
||
001101010010101010011101010100110101001101010100110101001010
|
||
101001110101010011101010100110101001010101001110101010011010
|
||
100110101010011010100101010100111010101001101010011010101001
|
||
101010011010101001110101010011101010100111010101001110101010
|
||
010011010100100110101001001101010010011010100101010011101010
|
||
100110101001101010100110101001101010100110101001010100111010
|
||
101001110101010011010100101010100111010101001101010011010101
|
||
001101010010101010011101010100110101001101010100111010101001
|
||
101010010101010010101001110101010011010100101010011101010100
|
||
111010101001101010010101010011101010100110101001010100111010
|
||
101001101010010101010010101001101010011101010100110101001101
|
||
010100100101010011010100101010011101010100110101001101010100
|
||
110101001101010100110101001010100111010101001110101010011010
|
||
100101010100111010101001101010011010101001101010010101010011
|
||
101010100110101001101010100111010101001101010010101010010101
|
||
001110101010011010100101010011101010100111010101001101010010
|
||
101010011101010100110101001010100111010101001101010010101010
|
||
010101001101010011101010100110101001101010100100101010011010
|
||
100101010011101010100110101001010100101010001010000100001000
|
||
010011000110110010011101111011011101110000001000011010011110
|
||
11000110110001101101010011000010010
|
||
`,
|
||
timeout: 30,
|
||
},
|
||
zsh: {
|
||
aliases: ["zshell", "zshrc"],
|
||
name: "Zsh",
|
||
monacoLang: "shell",
|
||
repl: "SHELL=/usr/bin/zsh zsh",
|
||
input: `expr 123 \\* 234`,
|
||
main: ".zshrc",
|
||
createEmpty: ``,
|
||
run: `SHELL=/usr/bin/zsh ZDOTDIR="$PWD" zsh`,
|
||
scope: {
|
||
code: `x="$(expr 123 \\* 234)"`,
|
||
input: `echo "$x"`,
|
||
},
|
||
template: `echo "Hello, world!"
|
||
`,
|
||
},
|
||
};
|