├── test ├── ex │ ├── 0.code │ ├── 2.code │ ├── 10.code │ ├── 15.code │ ├── 1.code │ ├── 30.code │ ├── 12.code │ ├── 35.code │ ├── 25.code │ ├── 26.code │ ├── 27.code │ ├── 3.code │ ├── 31.code │ ├── 36.code │ ├── 13.code │ ├── 14.code │ ├── 20.code │ ├── 23.code │ ├── 28.code │ ├── 29.code │ ├── 32.code │ ├── 4.code │ ├── 21.code │ ├── 24.code │ ├── 11.code │ ├── 16.code │ ├── 22.code │ ├── 2450.code │ ├── 33.code │ ├── 103.code │ ├── 230.code │ ├── 42.code │ ├── 90.code │ ├── 233168.code │ ├── 34.code │ └── 100.code ├── componeer.code ├── index ├── doe.lua ├── stroom.lua ├── kogel.code ├── oplos.lua ├── exp.lua ├── defunc.lua ├── codegen.lua.1 ├── pong.lua ├── langecode.lua ├── sb.code ├── incrementeel.lua ├── optimiseer.lua ├── luagen.lua ├── ontleed.lua ├── stress.lua ├── typeer.lua └── bouw.lua ├── a.code ├── ex ├── wisk.code ├── dht.code ├── tmp │ ├── bdec.code │ ├── y.code │ ├── e.code │ ├── q.code │ ├── z.code │ ├── spel.code │ ├── c.code │ ├── p.code │ ├── k.code │ ├── w.code │ ├── a.code │ ├── bt.code │ ├── d.code │ ├── b.code │ ├── x.code │ └── s.code ├── spiderman.torrent ├── mooi.sh ├── fib.code ├── schaakstukken.code ├── priem.code ├── 27.5.code ├── func.code ├── animatie.code ├── geom.code ├── graaf.code ├── abc.code ├── landschap.code ├── kristal.code ├── leip.code ├── zen.code ├── icode.code ├── paint.code ├── oog.code ├── pe1.c ├── json.code ├── recursie.code ├── funkypaint.code ├── http.code ├── benc.code ├── kleur.code ├── klad ├── pe1.code ├── pe6.code ├── grafiek.code ├── midi.code ├── snake.code ├── slang.code ├── sb.code ├── kanaal.code ├── pe3.code ├── cirkels.code ├── mat.code ├── paint2.code ├── trippy.code ├── pe2.code ├── bdec.code ├── pe5.code ├── pe4.code ├── bdec1.code ├── b.code ├── cool1.code ├── screensaver.code ├── buis.code ├── kubus.code ├── set.lua ├── 3d.code ├── muziek.code ├── bencode.code ├── demo.code ├── pong.code ├── bdec1.exp.ansi ├── bieb.code ├── schaken2.code ├── ontleed.code ├── syntax.html └── voer.code ├── lib ├── x75.code ├── lua.code ├── n.code ├── net.code ├── wisk.code ├── demo.code ├── geom.code ├── regels.code ├── demo.lst ├── unistd.code ├── 3d.code ├── geom.js.lst ├── x64.code ├── atomenjs.lst ├── std.code~Stashed changes ├── std.code~Stashed changes_0 ├── std.code~Stashed changes_1 └── std2.code ├── web ├── www │ ├── ex │ │ ├── aap.code │ │ ├── aap2.code │ │ ├── aap3.code │ │ ├── aap4.code │ │ ├── aap5.code │ │ ├── buis.code │ │ ├── demo.code │ │ ├── leip.code │ │ ├── oog.code │ │ ├── paint.code │ │ ├── pe1.code │ │ ├── pe2.code │ │ ├── pe3.code │ │ ├── pe4.code │ │ ├── pe5.code │ │ ├── pe6.code │ │ ├── pong.code │ │ ├── voer.code │ │ ├── cirkels.code │ │ ├── grafiek.code │ │ ├── paint2.code │ │ ├── schaken.code │ │ ├── terrein.code │ │ └── salvobal.code │ ├── coord.png │ ├── taal.png │ ├── favicon.ico │ ├── res │ │ ├── crate.jpg │ │ ├── dodo.png │ │ ├── gras.png │ │ ├── muur.png │ │ ├── symf.mid │ │ └── tetrisc.mid │ ├── les │ │ ├── 1.2-Waarde.code │ │ ├── 2.2-Priemgetallen.code │ │ ├── 1.1-Intro.code │ │ ├── 1.3-Aanroepen.code │ │ └── 1.4-Als-Dan.code │ ├── nl.svg │ ├── promo.html │ ├── privacy.html │ ├── en.svg │ ├── lib │ │ ├── slang.css │ │ └── addon │ │ │ └── selection │ │ │ └── active-line.js │ ├── gl.html │ ├── id.svg │ └── webgl.js ├── demoon ├── enc └── a.code ├── .gdbinit ├── asm ├── hoi ├── mul ├── hoi.o ├── hoi0 ├── hoi1 ├── mul.o ├── vb │ ├── vb │ └── Makefile ├── win │ ├── hoi.exe │ ├── hoi0.exe │ ├── hoi1.exe │ ├── hoi2.exe │ ├── win.exe │ ├── hoi1.c │ ├── hoi0.s │ ├── hoi.s │ ├── hoi1.s │ ├── Makefile │ └── win.c ├── abs.c ├── double.c ├── fib.c ├── win.s ├── a.c ├── comp.s ├── hoi.s ├── abs.s ├── call.s ├── hoi0.c ├── mul.s ├── double.s ├── fib.s ├── magnitude.s ├── Makefile ├── xcb.c ├── hoi0.s └── xcb2.c ├── DEPS ├── socket ├── test.lua ├── Makefile └── main.c ├── test.lua ├── parse ├── loc.h ├── Makefile ├── set.lua ├── lua.h └── test.c ├── template.lua ├── .gitignore ├── translate.lua ├── template ├── doe ├── tolk ├── set.lua ├── hoi.lua ├── mmap.lua ├── getopt.lua ├── unicode.lua ├── byte.lua ├── Makefile ├── func.lua ├── README.md ├── symbol.lua ├── constoptm.lua └── fout.lua /test/ex/0.code: -------------------------------------------------------------------------------- 1 | main = 0 2 | -------------------------------------------------------------------------------- /test/ex/2.code: -------------------------------------------------------------------------------- 1 | 2 = main 2 | -------------------------------------------------------------------------------- /a.code: -------------------------------------------------------------------------------- 1 | out = grabbel [1,2,3] 2 | -------------------------------------------------------------------------------- /test/ex/10.code: -------------------------------------------------------------------------------- 1 | main = 3 + 7 2 | -------------------------------------------------------------------------------- /test/ex/15.code: -------------------------------------------------------------------------------- 1 | main = 15 ^ 1 2 | -------------------------------------------------------------------------------- /test/ex/1.code: -------------------------------------------------------------------------------- 1 | x = 1 2 | main = x 3 | -------------------------------------------------------------------------------- /test/ex/30.code: -------------------------------------------------------------------------------- 1 | main = (ja ⇒ 30) 2 | -------------------------------------------------------------------------------- /ex/wisk.code: -------------------------------------------------------------------------------- 1 | ;hilbert-curve : curve 2 | -------------------------------------------------------------------------------- /lib/x75.code: -------------------------------------------------------------------------------- 1 | (#) = X → uint8ptr (X-8) 2 | -------------------------------------------------------------------------------- /test/ex/12.code: -------------------------------------------------------------------------------- 1 | x = -12 2 | main = - x 3 | -------------------------------------------------------------------------------- /test/ex/35.code: -------------------------------------------------------------------------------- 1 | main = (2 > 1 ⇒ 35) 2 | -------------------------------------------------------------------------------- /web/www/ex/aap.code: -------------------------------------------------------------------------------- 1 | ../../../ex/aap.code -------------------------------------------------------------------------------- /web/www/ex/aap2.code: -------------------------------------------------------------------------------- 1 | ../../../ex/aap2.code -------------------------------------------------------------------------------- /web/www/ex/aap3.code: -------------------------------------------------------------------------------- 1 | ../../../ex/aap3.code -------------------------------------------------------------------------------- /web/www/ex/aap4.code: -------------------------------------------------------------------------------- 1 | ../../../ex/aap4.code -------------------------------------------------------------------------------- /web/www/ex/aap5.code: -------------------------------------------------------------------------------- 1 | ../../../ex/aap5.code -------------------------------------------------------------------------------- /web/www/ex/buis.code: -------------------------------------------------------------------------------- 1 | ../../../ex/buis.code -------------------------------------------------------------------------------- /web/www/ex/demo.code: -------------------------------------------------------------------------------- 1 | ../../../ex/demo.code -------------------------------------------------------------------------------- /web/www/ex/leip.code: -------------------------------------------------------------------------------- 1 | ../../../ex/leip.code -------------------------------------------------------------------------------- /web/www/ex/oog.code: -------------------------------------------------------------------------------- 1 | ../../../ex/oog.code -------------------------------------------------------------------------------- /web/www/ex/paint.code: -------------------------------------------------------------------------------- 1 | ../../../ex/paint.code -------------------------------------------------------------------------------- /web/www/ex/pe1.code: -------------------------------------------------------------------------------- 1 | ../../../ex/pe1.code -------------------------------------------------------------------------------- /web/www/ex/pe2.code: -------------------------------------------------------------------------------- 1 | ../../../ex/pe2.code -------------------------------------------------------------------------------- /web/www/ex/pe3.code: -------------------------------------------------------------------------------- 1 | ../../../ex/pe3.code -------------------------------------------------------------------------------- /web/www/ex/pe4.code: -------------------------------------------------------------------------------- 1 | ../../../ex/pe4.code -------------------------------------------------------------------------------- /web/www/ex/pe5.code: -------------------------------------------------------------------------------- 1 | ../../../ex/pe5.code -------------------------------------------------------------------------------- /web/www/ex/pe6.code: -------------------------------------------------------------------------------- 1 | ../../../ex/pe6.code -------------------------------------------------------------------------------- /web/www/ex/pong.code: -------------------------------------------------------------------------------- 1 | ../../../ex/pong.code -------------------------------------------------------------------------------- /web/www/ex/voer.code: -------------------------------------------------------------------------------- 1 | ../../../ex/voer.code -------------------------------------------------------------------------------- /ex/dht.code: -------------------------------------------------------------------------------- 1 | id : int 2 | id : 0 .. 2^160 3 | -------------------------------------------------------------------------------- /lib/lua.code: -------------------------------------------------------------------------------- 1 | app = stduitSchrijf(tekst(uit)) 2 | -------------------------------------------------------------------------------- /test/ex/25.code: -------------------------------------------------------------------------------- 1 | x = [0]^25 2 | main = #x 3 | -------------------------------------------------------------------------------- /test/ex/26.code: -------------------------------------------------------------------------------- 1 | x = [3,4] ^ 13 2 | main = #x 3 | -------------------------------------------------------------------------------- /test/ex/27.code: -------------------------------------------------------------------------------- 1 | x = 0..10 2 | main = 17 + #x 3 | -------------------------------------------------------------------------------- /test/ex/3.code: -------------------------------------------------------------------------------- 1 | a = 3 2 | b = a 3 | main = b 4 | -------------------------------------------------------------------------------- /test/ex/31.code: -------------------------------------------------------------------------------- 1 | main = (⇒)(nee, 100, 31) 2 | -------------------------------------------------------------------------------- /test/ex/36.code: -------------------------------------------------------------------------------- 1 | main = (⇒)(2 < 1, 0, 36) 2 | -------------------------------------------------------------------------------- /web/www/ex/cirkels.code: -------------------------------------------------------------------------------- 1 | ../../../ex/cirkels.code -------------------------------------------------------------------------------- /web/www/ex/grafiek.code: -------------------------------------------------------------------------------- 1 | ../../../ex/grafiek.code -------------------------------------------------------------------------------- /web/www/ex/paint2.code: -------------------------------------------------------------------------------- 1 | ../../../ex/paint2.code -------------------------------------------------------------------------------- /web/www/ex/schaken.code: -------------------------------------------------------------------------------- 1 | ../../../ex/schaken.code -------------------------------------------------------------------------------- /web/www/ex/terrein.code: -------------------------------------------------------------------------------- 1 | ../../../ex/terrein.code -------------------------------------------------------------------------------- /test/ex/13.code: -------------------------------------------------------------------------------- 1 | x = 14 2 | y = 1 3 | main = x - y 4 | -------------------------------------------------------------------------------- /test/ex/14.code: -------------------------------------------------------------------------------- 1 | x = 28 2 | y = 2 3 | main = x / y 4 | -------------------------------------------------------------------------------- /test/ex/20.code: -------------------------------------------------------------------------------- 1 | x = [20, 30, 40] 2 | main = x₀ 3 | -------------------------------------------------------------------------------- /test/ex/23.code: -------------------------------------------------------------------------------- 1 | x = [1,2,3] 2 | main = 20 + #x 3 | -------------------------------------------------------------------------------- /test/ex/28.code: -------------------------------------------------------------------------------- 1 | x = 10..20 2 | main = 18 + #x 3 | -------------------------------------------------------------------------------- /test/ex/29.code: -------------------------------------------------------------------------------- 1 | 2 | x = -10 .. 19 3 | main = #x 4 | -------------------------------------------------------------------------------- /web/demoon: -------------------------------------------------------------------------------- 1 | (cd /home/ymte/taal/web/ ; ./dienst) 2 | -------------------------------------------------------------------------------- /web/www/ex/salvobal.code: -------------------------------------------------------------------------------- 1 | ../../../ex/salvobal.code -------------------------------------------------------------------------------- /lib/n.code: -------------------------------------------------------------------------------- 1 | ;mainuit = uit 2 | main = in.vars → uit 3 | -------------------------------------------------------------------------------- /test/ex/32.code: -------------------------------------------------------------------------------- 1 | als ja dan 2 | main = 32 3 | eind 4 | -------------------------------------------------------------------------------- /test/ex/4.code: -------------------------------------------------------------------------------- 1 | main = x 2 | x = c 3 | x = a 4 | a = 4 5 | -------------------------------------------------------------------------------- /.gdbinit: -------------------------------------------------------------------------------- 1 | layout regs 2 | 3 | set disassembly-flavor intel 4 | -------------------------------------------------------------------------------- /lib/net.code: -------------------------------------------------------------------------------- 1 | lokale-gastheer = 0x7F000001 2 | elk-adres = 0 3 | -------------------------------------------------------------------------------- /lib/wisk.code: -------------------------------------------------------------------------------- 1 | τ = 6.28318530717958647692528676655901 2 | 3 | -------------------------------------------------------------------------------- /test/componeer.code: -------------------------------------------------------------------------------- 1 | f = x → x + 1 2 | g = y → y + 2 3 | 4 | -------------------------------------------------------------------------------- /test/ex/21.code: -------------------------------------------------------------------------------- 1 | x = [20, 21, 22] 2 | y = 1 3 | main = x(y) 4 | -------------------------------------------------------------------------------- /test/ex/24.code: -------------------------------------------------------------------------------- 1 | x = [1, 2, 3] || [4] 2 | main = #x + 20 3 | -------------------------------------------------------------------------------- /asm/hoi: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/caminadab/metamine/HEAD/asm/hoi -------------------------------------------------------------------------------- /asm/mul: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/caminadab/metamine/HEAD/asm/mul -------------------------------------------------------------------------------- /test/ex/11.code: -------------------------------------------------------------------------------- 1 | main = a + b + c 2 | a = 9 3 | b = 1 4 | c = 1 5 | -------------------------------------------------------------------------------- /asm/hoi.o: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/caminadab/metamine/HEAD/asm/hoi.o -------------------------------------------------------------------------------- /asm/hoi0: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/caminadab/metamine/HEAD/asm/hoi0 -------------------------------------------------------------------------------- /asm/hoi1: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/caminadab/metamine/HEAD/asm/hoi1 -------------------------------------------------------------------------------- /asm/mul.o: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/caminadab/metamine/HEAD/asm/mul.o -------------------------------------------------------------------------------- /asm/vb/vb: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/caminadab/metamine/HEAD/asm/vb/vb -------------------------------------------------------------------------------- /ex/tmp/bdec.code: -------------------------------------------------------------------------------- 1 | bdec = data → waarde 2 | data₀ = 'i' ⇒ waarde = 3 | -------------------------------------------------------------------------------- /test/ex/16.code: -------------------------------------------------------------------------------- 1 | main = z · x · y 2 | x = 2 3 | y = 2 4 | z = x · y 5 | -------------------------------------------------------------------------------- /test/ex/22.code: -------------------------------------------------------------------------------- 1 | ; var index 2 | x = [1, 22, 23] 3 | main = x( x₀ ) 4 | -------------------------------------------------------------------------------- /DEPS: -------------------------------------------------------------------------------- 1 | sudo apt install gcc bison flex luajit liblua5.1-dev make lua-socket 2 | -------------------------------------------------------------------------------- /ex/tmp/y.code: -------------------------------------------------------------------------------- 1 | h = "0123456789ABCDEF" 2 | a = h(-1) 3 | uit = [h₀, h₃, h₂] 4 | -------------------------------------------------------------------------------- /test/ex/2450.code: -------------------------------------------------------------------------------- 1 | main = Σ (0..100) filter f 2 | f = X → (X mod 2 = 0) 3 | -------------------------------------------------------------------------------- /test/ex/33.code: -------------------------------------------------------------------------------- 1 | als nee dan 2 | main = 100 3 | anders 4 | main = 33 5 | eind 6 | -------------------------------------------------------------------------------- /asm/win/hoi.exe: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/caminadab/metamine/HEAD/asm/win/hoi.exe -------------------------------------------------------------------------------- /asm/win/hoi0.exe: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/caminadab/metamine/HEAD/asm/win/hoi0.exe -------------------------------------------------------------------------------- /asm/win/hoi1.exe: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/caminadab/metamine/HEAD/asm/win/hoi1.exe -------------------------------------------------------------------------------- /asm/win/hoi2.exe: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/caminadab/metamine/HEAD/asm/win/hoi2.exe -------------------------------------------------------------------------------- /asm/win/win.exe: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/caminadab/metamine/HEAD/asm/win/win.exe -------------------------------------------------------------------------------- /web/www/coord.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/caminadab/metamine/HEAD/web/www/coord.png -------------------------------------------------------------------------------- /web/www/taal.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/caminadab/metamine/HEAD/web/www/taal.png -------------------------------------------------------------------------------- /web/www/favicon.ico: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/caminadab/metamine/HEAD/web/www/favicon.ico -------------------------------------------------------------------------------- /ex/spiderman.torrent: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/caminadab/metamine/HEAD/ex/spiderman.torrent -------------------------------------------------------------------------------- /test/ex/103.code: -------------------------------------------------------------------------------- 1 | main = 100 + f(0) + b + b + b + b 2 | 3 | b = 1/2 4 | 5 | f = x → b + b 6 | -------------------------------------------------------------------------------- /test/ex/230.code: -------------------------------------------------------------------------------- 1 | l = (0..10) filter (x → x > 5) map (y → y²) 2 | main = reduceer(0, l, (+)) 3 | -------------------------------------------------------------------------------- /test/ex/42.code: -------------------------------------------------------------------------------- 1 | main = 40 + val₀ + val₁ 2 | val = [(0,0),(1,1)] map (id ∘ (+)) 3 | id = x → x 4 | -------------------------------------------------------------------------------- /web/www/res/crate.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/caminadab/metamine/HEAD/web/www/res/crate.jpg -------------------------------------------------------------------------------- /web/www/res/dodo.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/caminadab/metamine/HEAD/web/www/res/dodo.png -------------------------------------------------------------------------------- /web/www/res/gras.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/caminadab/metamine/HEAD/web/www/res/gras.png -------------------------------------------------------------------------------- /web/www/res/muur.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/caminadab/metamine/HEAD/web/www/res/muur.png -------------------------------------------------------------------------------- /web/www/res/symf.mid: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/caminadab/metamine/HEAD/web/www/res/symf.mid -------------------------------------------------------------------------------- /ex/mooi.sh: -------------------------------------------------------------------------------- 1 | vt -IBOKd a | sed -r "s/\x1B\[([0-9]{1,2}(;[0-9]{1,2})?)?[mGK]//g" | pr -2 -w180 -e8 2 | -------------------------------------------------------------------------------- /ex/tmp/e.code: -------------------------------------------------------------------------------- 1 | a : int 2 | a = 2.4 3 | 4 | b : (int, int) 5 | b = (2, 3, 4) 6 | 7 | uit = tekst a 8 | -------------------------------------------------------------------------------- /test/index: -------------------------------------------------------------------------------- 1 | 0 nul 2 | 1 vars 3 | 10 arith 4 | 20 lijst 5 | 30 causatie 6 | 100 diversen 7 | 8 | 9 | -------------------------------------------------------------------------------- /web/www/res/tetrisc.mid: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/caminadab/metamine/HEAD/web/www/res/tetrisc.mid -------------------------------------------------------------------------------- /test/ex/90.code: -------------------------------------------------------------------------------- 1 | lijst = (0..10) map verdubbel 2 | verdubbel = X → X · 2 3 | main = lijst vouw (+) 4 | 5 | 6 | -------------------------------------------------------------------------------- /test/ex/233168.code: -------------------------------------------------------------------------------- 1 | multiple = i → ((i mod 3 = 0) of (i mod 5 = 0)) 2 | main = Σ (1 .. 1000) filter multiple 3 | 4 | -------------------------------------------------------------------------------- /test/ex/34.code: -------------------------------------------------------------------------------- 1 | als ja dan 2 | als nee dan 3 | main = 100 4 | anders 5 | main = 34 6 | eind 7 | eind 8 | 9 | -------------------------------------------------------------------------------- /web/enc: -------------------------------------------------------------------------------- 1 | #!/usr/bin/lua 2 | require 'util' 3 | local pad = ... 4 | local data = lees(pad) 5 | print(escape(data)) 6 | -------------------------------------------------------------------------------- /ex/fib.code: -------------------------------------------------------------------------------- 1 | uit = "fib(20) = " || tekst(x) || [10] 2 | x = fib 20 3 | fib = n → (fⁿ[0,1]) 0 4 | f = [a,b] → [b,a+b] 5 | -------------------------------------------------------------------------------- /ex/schaakstukken.code: -------------------------------------------------------------------------------- 1 | stukken = " ♜♞♝♛♚♝♞♜ ♟♟♟♟♟♟♟♟ ♙♙♙♙♙♙♙♙ ♖♘♗♕♔♗♘♖ " 2 | uit = teken [ label((5,5), stukken) ] 3 | -------------------------------------------------------------------------------- /test/doe.lua: -------------------------------------------------------------------------------- 1 | require 'compile' 2 | require 'doe' 3 | 4 | local app = compile "uit = 1 + 2" 5 | 6 | --assert(doe(app) == 3) 7 | -------------------------------------------------------------------------------- /web/www/les/1.2-Waarde.code: -------------------------------------------------------------------------------- 1 | ; Extra waarden definieer je met vergelijkingen: 2 | a = "hoi" 3 | b = a 4 | c = a 5 | uit = a 6 | -------------------------------------------------------------------------------- /ex/priem.code: -------------------------------------------------------------------------------- 1 | ispriem = x → ⋀ bereik map rest 2 | bereik = 2 .. √(x + 1) 3 | rest = n → (x mod n ≠ 0) 4 | 5 | uit = ispriem ;(99999199999) 6 | -------------------------------------------------------------------------------- /ex/27.5.code: -------------------------------------------------------------------------------- 1 | main = Σ (0..10) map k 2 | k = f ∘ g ∘ h ∘ i ∘ f ∘ g 3 | f = x → x + 1 4 | g = y → y / 2 5 | h = z → z · 2 6 | i = w → w - 1 7 | -------------------------------------------------------------------------------- /ex/tmp/q.code: -------------------------------------------------------------------------------- 1 | ;a = {1, 2, 3} waarvoor sin 2 | f(a,b) = a + b 3 | A(ff,gg) = yy → ff(gg(yy)) 4 | h = f A f 5 | c = h(2,3) 6 | uit = tekst(c) 7 | 8 | -------------------------------------------------------------------------------- /asm/win/hoi1.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int __main() { 4 | WriteConsoleA(GetStdHandle(STD_OUTPUT_HANDLE), "hoi", 3, 0, 0); 5 | return 0; 6 | } 7 | -------------------------------------------------------------------------------- /ex/func.code: -------------------------------------------------------------------------------- 1 | uit = Σ (0..10 × 0..10) map call 2 | 3 | als looptijd mod 2 < 1 dan 4 | call = (+) 5 | anders 6 | call = x,y → - x - y 7 | eind 8 | 9 | -------------------------------------------------------------------------------- /ex/tmp/z.code: -------------------------------------------------------------------------------- 1 | zwart = 0 2 | wit = 1 3 | kleur = {zwart, wit} 4 | 5 | zwart ∈ kleur ⇒ p = [zwart] 6 | zwart ∉ kleur ⇒ p = [wit] 7 | 8 | uit = tekst p₀ 9 | -------------------------------------------------------------------------------- /test/ex/100.code: -------------------------------------------------------------------------------- 1 | ispriem = x → ⋀ bereik map rest 2 | bereik = 2 .. √(x + 1) 3 | rest = n → (x mod n ≠ 0) 4 | 5 | main = (⇒)(ispriem 2147483647, 100, 0) 6 | -------------------------------------------------------------------------------- /ex/animatie.code: -------------------------------------------------------------------------------- 1 | uit = hoi 2 | a = int((nu·40) mod 40) 3 | 4 | n = 40 5 | 6 | hoi = hois cat " " 7 | hois = (0 .. 40) map (x → ((x = a)⇒"O") | ((x ≠ a)⇒"_")) 8 | 9 | -------------------------------------------------------------------------------- /web/www/les/2.2-Priemgetallen.code: -------------------------------------------------------------------------------- 1 | delers(n) = (2 .. n/2) waarvoor (n mod ★ = 0) 2 | ispriem(n) = (# delers(n) = 0) 3 | priemgetallen = (2 .. 1000) waarvoor ispriem 4 | -------------------------------------------------------------------------------- /asm/abs.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main() { 5 | volatile int a = - 3; 6 | int b = abs(a); 7 | printf("%d\n", b); 8 | return 0; 9 | } 10 | -------------------------------------------------------------------------------- /ex/geom.code: -------------------------------------------------------------------------------- 1 | cirkel: (pos, radius) 2 | pos: getal, getal 3 | 4 | vierkant: (lo, hi) 5 | vierkant: (x, y, w, h) 6 | 7 | pos: (2,3) ∧ (4,5) 8 | 9 | vierkant(x,y,w,h) 10 | -------------------------------------------------------------------------------- /ex/graaf.code: -------------------------------------------------------------------------------- 1 | graaf.is-bereikbaar(a, b) = b ∈ bereikbaar 2 | nieuw := {a} 3 | nieuw := ∪ graaf.van(nieuw').naar 4 | bereikbaar := {} 5 | bereikbaar := bereikbaar' ∪ nieuw 6 | -------------------------------------------------------------------------------- /socket/test.lua: -------------------------------------------------------------------------------- 1 | require 'socket' 2 | 3 | local host = socket.bind('127.0.0.1', '10101') 4 | 5 | assert(host) 6 | assert(host.accept) 7 | 8 | print('host:', host) 9 | 10 | -------------------------------------------------------------------------------- /ex/abc.code: -------------------------------------------------------------------------------- 1 | ; bereken de lengte van a, gegeven b en c 2 | ; a /\ c 3 | ; /__\ 4 | ; b 5 | 6 | a² + b² = c² 7 | b = 4 8 | c = 5 9 | uit = "a = " || tekst(a) 10 | 11 | -------------------------------------------------------------------------------- /test/stroom.lua: -------------------------------------------------------------------------------- 1 | require 'flow' 2 | require 'set' 3 | 4 | local flow = maakflow() 5 | flow:link(set('a'), 'b') 6 | flow:link(set('b'), 'c') 7 | 8 | assert(flow:flowopwaarts('a', 'c')) 9 | -------------------------------------------------------------------------------- /ex/landschap.code: -------------------------------------------------------------------------------- 1 | ; bereken the lengte van a, gegeven b and c 2 | ; a /\ c 3 | ; /__\ 4 | ; b 5 | 6 | a² + b² = c² 7 | b = 4 8 | c = 5 9 | out = "a = " || string(a) 10 | 11 | -------------------------------------------------------------------------------- /ex/kristal.code: -------------------------------------------------------------------------------- 1 | punten = (0..1000) map f 2 | f = x → (90+10·sin(x/10),50) + sin(x/0.7+looptijd)·looptijd·(x mod 20)·cossin(x + looptijd) 3 | 4 | uit = teken [ verf(polygoon(punten), kleur.geel) ] 5 | -------------------------------------------------------------------------------- /ex/leip.code: -------------------------------------------------------------------------------- 1 | punten = (0..1000) map f 2 | f = x → p1 + p2 3 | p1 = 90+10·sin(x/10), 50 4 | p2 = sin(x/0.7+looptijd)·looptijd·(x mod 20)·cossin(x) 5 | 6 | uit = teken [ polygoon(punten) verf kleur.geel ] 7 | -------------------------------------------------------------------------------- /ex/zen.code: -------------------------------------------------------------------------------- 1 | ; zen 2 | pos = (90, 50) 3 | posA = pos + 30·sincos(i/6·τ) 4 | posB = pos + 30·sincos((i+1)/6·τ) 5 | rechthoeken = (0..6 + looptijd) map (i → rechthoek(posA,posB)) 6 | uit = teken rechthoeken 7 | -------------------------------------------------------------------------------- /ex/tmp/spel.code: -------------------------------------------------------------------------------- 1 | ; simpel spel 2 | begin = [] 3 | 4 | stap = [spelA, dt, invoer] → spelB 5 | spelB = spelA 6 | 7 | teken = spel → [ [cirkeltype,0,0,1/4,oranje] ] 8 | 9 | 10 | cirkeltype = 0 11 | 12 | -------------------------------------------------------------------------------- /test.lua: -------------------------------------------------------------------------------- 1 | #!/usr/bin/luajit 2 | require 'util' 3 | 4 | local bestanden = io.popen('ls test/*.lua') 5 | for bestand in bestanden:lines() do 6 | print(color.yellow .. bestand .. color.white) 7 | dofile(bestand) 8 | end 9 | -------------------------------------------------------------------------------- /test/kogel.code: -------------------------------------------------------------------------------- 1 | kogel: getal,getal 2 | 3 | kogelpos = (k₀+1/10, k₁) 4 | kogelstraal = (i → k₀/4/i) 5 | tekenkogel = k → (0..10) map (i → cirkel(kogelpos, kogelstraal)) 6 | 7 | a = tekenkogel(2,3) 8 | uit = canvas [a] 9 | -------------------------------------------------------------------------------- /web/www/les/1.1-Intro.code: -------------------------------------------------------------------------------- 1 | ; Programma's worden geschreven als lijsten van feiten. 2 | ; Elk feit is geldig zolang dat het programma draait. 3 | ; Dit programma print wat tekst en exit dan. 4 | uit = "hallo aardkloot" 5 | -------------------------------------------------------------------------------- /ex/icode.code: -------------------------------------------------------------------------------- 1 | f = x → x · 3 2 | g = y → y / 2 3 | v = f ∘ g² 4 | 5 | 6 | print = ins → ins vouw (a,b → a ‖ "
" ‖ b) 7 | uit = "=== icode ===

" ‖ print(icode(v)) ; ‖ "

=== javascript === " ‖ tekst(v) 8 | 9 | -------------------------------------------------------------------------------- /ex/paint.code: -------------------------------------------------------------------------------- 1 | ; paint 2 | circles := [] 3 | 4 | if mouse.click then 5 | circles := circles ‖ [ circle(mouse.pos, 3) ] 6 | end 7 | 8 | if key.space then 9 | circles := [] 10 | end 11 | 12 | out = draw circles 13 | -------------------------------------------------------------------------------- /asm/vb/Makefile: -------------------------------------------------------------------------------- 1 | vb: main.c 2 | gcc -Wl,--build-id=none -Wa,--no-pad-sections -Wa,-R -Os main.c -lSDL2 -o vb 3 | objcopy --remove-section .comment vb 4 | objcopy --remove-section .eh_frame vb 5 | strip -S vb 6 | strip -s vb 7 | -------------------------------------------------------------------------------- /ex/oog.code: -------------------------------------------------------------------------------- 1 | punten = ((0..1000) map f) 2 | f = i → (((looptijd · 10) mod scherm.breedte),50) + cossin(i/1000·τ+looptijd) · 30 · sin(i/10·looptijd) 3 | uit = teken [verf(polygoon(punten), rgb(.3,cos(looptijd·.7),sin looptijd))] 4 | -------------------------------------------------------------------------------- /asm/double.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int _start() { 5 | volatile double A = 212312312.5; 6 | volatile double B = 3.5; 7 | int D = A + B; 8 | printf("%d %d\n", D, D); 9 | 10 | return 0; 11 | } 12 | -------------------------------------------------------------------------------- /ex/pe1.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main() { 4 | int s = 0; 5 | for (int i = 0; i < 10000000; i++) { 6 | if (i % 3 == 0 || i % 5 == 0) 7 | s += i; 8 | } 9 | printf("%d\n", s); 10 | return 0; 11 | } 12 | 13 | -------------------------------------------------------------------------------- /ex/tmp/c.code: -------------------------------------------------------------------------------- 1 | f(x) = x + 1 2 | uit = tekst(f(3)) 3 | 4 | sin 3 = a 5 | 6 | ; f(1) = 2 7 | ; f(2) = 3 8 | ; ________ 9 | ; 10 | ; f ∐= 1 ↦ 2 11 | ; f ∐= 2 ↦ 3 12 | ; f = (1 → 2 ∐ 2 → 3) 13 | 14 | f = 15 | 1 → 2 16 | 2 → 3 17 | -------------------------------------------------------------------------------- /socket/Makefile: -------------------------------------------------------------------------------- 1 | socket.so: main.c 2 | mkdir -p bin 3 | gcc -g -Wall -Wno-unused -std=c11 -shared -I/usr/include/lua5.1 -o bin/socket.so -fPIC main.c -Wno-multichar 4 | ln -sf bin/socket.so . 5 | 6 | test: socket.so 7 | luajit test.lua 8 | -------------------------------------------------------------------------------- /web/www/nl.svg: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | -------------------------------------------------------------------------------- /parse/loc.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #define YYLTYPE_IS_DECLARED 3 | typedef struct YYLTYPE 4 | { 5 | int first_line; 6 | int first_column; 7 | int last_line; 8 | int last_column; 9 | char* file; 10 | } YYLTYPE; 11 | 12 | -------------------------------------------------------------------------------- /web/www/les/1.3-Aanroepen.code: -------------------------------------------------------------------------------- 1 | ; De standaard functies +, -, ·, / zijn aan te roepen met infixnotatie: 2 | vijf = - 1 + 4 · 3 / 2 3 | 4 | ; Net als normale functies: 5 | oi = "hoi" vanaf 1 6 | 7 | ; Ook reguliere notatie wordt ondersteund. 8 | uit = vanaf("hoi", 1) 9 | -------------------------------------------------------------------------------- /ex/json.code: -------------------------------------------------------------------------------- 1 | json = f → g 2 | 3 | g = w → a | b 4 | a = (w:lijst ⇒ "[" || (w map f) cat "," || "]") 5 | b = (w:int ⇒ tekst w) 6 | 7 | n = wa → na | nb 8 | na = (wa:lijst ⇒ "[]") 9 | nb = (wa:int ⇒ tekst wa) 10 | 11 | j = (json^3) n 12 | uit = j [[[[[[2]]]]]] 13 | -------------------------------------------------------------------------------- /ex/recursie.code: -------------------------------------------------------------------------------- 1 | json = f → g 2 | 3 | g = w → a | b 4 | a = (w:lijst ⇒ "[" || (w map f) cat "," || "]") 5 | b = (w:int ⇒ tekst w) 6 | 7 | n = wa → na | nb 8 | na = (wa:lijst ⇒ "[]") 9 | nb = (wa:int ⇒ tekst wa) 10 | 11 | j = (json^3) n 12 | uit = j [[[[[[2]]]]]] 13 | -------------------------------------------------------------------------------- /ex/tmp/p.code: -------------------------------------------------------------------------------- 1 | ; bereken de som van alle priemgetallen onder de duizend 2 | priem: int 3 | priem > 1 4 | priem als |delers| = 2 5 | 6 | deler: 1 .. priem 7 | deler: delers als 8 | priem mod deler = 0 9 | 10 | p: priem 11 | p < 1000 12 | 13 | s = Σ p 14 | uit = tekst s 15 | -------------------------------------------------------------------------------- /ex/funkypaint.code: -------------------------------------------------------------------------------- 1 | hist := [(10,10,10)] 2 | 3 | prev := (0,0) 4 | 5 | lengte = X,Y → √(X²+Y²) 6 | 7 | als muis.beweegt dan 8 | prev := muis.pos 9 | hist := [nieuw] ‖ (hist tot 1000) 10 | eind 11 | nieuw = muis.pos ‖ [l] 12 | l = lengte(muis.pos - prev) / 5 13 | 14 | uit = teken (hist map cirkel) 15 | -------------------------------------------------------------------------------- /lib/demo.code: -------------------------------------------------------------------------------- 1 | ;main = (in.vars, start, toets.neer, toets.neer.begin, toets.neer.eind, nu, canvas2d, canvas3d) → (uit, uit.vars) 2 | main = (in.vars, start, nu, in.element) → (uit.vars, uit) 3 | 4 | ;teken = z → (canvas.clear ∘ z)(canvas.context canvas) 5 | ;vierkant = x,y,r → (c → canvas.fillRect(c,x,y,r,r)) 6 | -------------------------------------------------------------------------------- /ex/http.code: -------------------------------------------------------------------------------- 1 | uit = (kop || data) map succ 2 | 3 | ; kop 4 | kop = status || host || length || re 5 | status = regel "200 HTTP/1.0 OK" 6 | host = regel "Host: localhost" 7 | length = regel ("Content-Length: " || tekst(#data)) 8 | regel = text → text || re 9 | re = [10,13] 10 | 11 | ; data 12 | data = "hoi" 13 | -------------------------------------------------------------------------------- /test/oplos.lua: -------------------------------------------------------------------------------- 1 | require 'solve' 2 | require 'compile' 3 | require 'fout' 4 | 5 | local code = "b := 1\nc := 2\napp = b\nin.vars = []" 6 | local b,fouten = solve(parse(code), "app") 7 | print(code) 8 | print(deparse(b)) 9 | for i,fout in ipairs(fouten) do 10 | print(fout2ansi(fout)) 11 | os.exit() 12 | end 13 | -------------------------------------------------------------------------------- /asm/fib.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | uint64_t fib(uint64_t n) { 5 | if (n == 0 || n == 1) 6 | return n; 7 | else 8 | return fib(n-1) + fib(n-2); 9 | } 10 | 11 | int main() { 12 | uint64_t n = 10; 13 | uint64_t a = fib(n); 14 | printf("fib(10) = %d\n", a); 15 | return 0; 16 | } 17 | -------------------------------------------------------------------------------- /ex/benc.code: -------------------------------------------------------------------------------- 1 | bencB = w → d 2 | w:lijst ⇒ d = "l" || cat(w map bencA) || "e" 3 | w:int ⇒ d = "i" || tekst w || "e" 4 | 5 | ; iteratief verdiepen 6 | ;benc = ((bencA → bencB)^999) (x → []) 7 | ;benc = kortsluit (bencA → bencB) 8 | benc = ((bencA → bencB)^99) bencB 9 | 10 | in = [1,[2],3,[],[[[]],4]] 11 | uit = benc in 12 | -------------------------------------------------------------------------------- /web/a.code: -------------------------------------------------------------------------------- 1 | totaal = Σ 1 .. 1000 2 | t = "de som van 1 tot 1000 = " || tekst(totaal) 3 | 4 | y = sin(looptijd) / 2 5 | posA = (80%, 20%) 6 | posB = (70% + y, 80%) 7 | 8 | ; vormen 9 | achtergrond = rechthoek((0,0), (2,1), zwart) 10 | 11 | tekening = [ achtergrond ] 12 | 13 | zwart = (0,0,0) 14 | rechthoek(a,b,c) = (1,a,b,c) 15 | -------------------------------------------------------------------------------- /ex/kleur.code: -------------------------------------------------------------------------------- 1 | hexcijfers = "0123456789ABCDEF" 2 | 3 | hex = n → h 4 | b = int(n · 255) 5 | cijferB = int(b / 16) 6 | cijferA = int(b mod 16) 7 | h = [hexcijfers(cijferB), hexcijfers(cijferA)] 8 | 9 | kleurcode = rgb → code 10 | code = "#" || cat(rgb map hex) 11 | 12 | kleur = [100%, 50%, 0%] 13 | uit = kleurcode(kleur) 14 | -------------------------------------------------------------------------------- /ex/klad: -------------------------------------------------------------------------------- 1 | ; rij = [4]^10 2 | 3 | 4 | ; ℝ^(n × m) 5 | [1,2,3] + 10 6 | [1,2,3]i ^ 10 7 | ; (3 * 3 * 3 * ...) 8 | ; (3 x 3 x 3 x ...) 9 | 10 | r = [1]^(10 11 | rij = [1,2,3]^10 12 | rij(0..10) = 3 13 | 14 | a = [0,1,2,…] 15 | a = [0,1,2,…,10] 16 | a = 0:1:10 17 | a = b :: c 18 | 19 | rij (0..10) = 3 20 | rij = (0..10) → 3 21 | -; 22 | -------------------------------------------------------------------------------- /web/www/les/1.4-Als-Dan.code: -------------------------------------------------------------------------------- 1 | a = -3 2 | 3 | ; Als-dan statements schrijf je met "als". 4 | ; De tabs bepalen welke feiten onder het 5 | ; "dan"-gedeelte vallen. 6 | 7 | als a < 0 8 | bericht = "a is negatief!" 9 | 10 | ; optioneel met "anders"-gedeelte 11 | als a > 0 12 | uit = "a is positief" 13 | anders 14 | uit = "a is niet-positief" 15 | -------------------------------------------------------------------------------- /ex/pe1.code: -------------------------------------------------------------------------------- 1 | ; The following problem is taken from Project Euler. 2 | ; If we list all the natural numbers below 10 that are multiples of 3 or 5, we get 3, 5, 6 and 9. The sum of these multiples is 23. 3 | ; Find the sum of all the multiples of 3 or 5 below 1000. 4 | 5 | multiple = i → ((i mod 3 = 0) ∨ (i mod 5 = 0)) 6 | uit = Σ (1 .. 1000) filter multiple 7 | -------------------------------------------------------------------------------- /template.lua: -------------------------------------------------------------------------------- 1 | function template(fmt, dict) 2 | local function vervang(name) 3 | local waarde = assert(dict[name], 'ongedefinieerd: '..name) 4 | return waarde 5 | end 6 | return string.gsub(fmt, '%{(%w+)%}', vervang) 7 | end 8 | 9 | if test then 10 | local t = template('welkom, {name}', {name="baap"}) 11 | assert(t == 'welkom, baap') 12 | end 13 | -------------------------------------------------------------------------------- /ex/pe6.code: -------------------------------------------------------------------------------- 1 | ; The following problem is taken from Project Euler. 2 | ; 2520 is the smallest number that can be divided by each of the numbers from 1 to 10 without any remainder. 3 | 4 | ; What is the smallest positive number that is evenly divisible by all of the numbers from 1 to 20? 5 | 6 | 7 | a = Σ ((1..101) map (x → x²)) 8 | b = (Σ 1..101)² 9 | 10 | uit = b - a 11 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | .* 2 | 3 | # autogen 4 | *.yy.* 5 | *.gen.* 6 | *.en.code 7 | *.log 8 | ontleed/taal.c 9 | ontleed/taal.h 10 | 11 | res/ 12 | 13 | web/www/index.nl.html 14 | web/www/index.en.html 15 | web/www/index.html 16 | web/www/en 17 | web/www/nl 18 | 19 | *.output 20 | bin/ 21 | troep/ 22 | asm/xcb 23 | a.s 24 | a.js 25 | *.so 26 | *.dll 27 | *.elf 28 | *.out 29 | *.o 30 | 31 | *.stackdump 32 | -------------------------------------------------------------------------------- /asm/win.s: -------------------------------------------------------------------------------- 1 | .686 2 | .model flat, stdcall 3 | 4 | EXTERN MessageBoxA@16 : proc 5 | EXTERN ExitProcess@4 : proc 6 | 7 | .const 8 | msgText db 'Windows assembly language lives!', 0 9 | msgCaption db 'Hello World', 0 10 | 11 | .code 12 | Main: 13 | push 0 14 | push offset msgCaption 15 | push offset msgText 16 | push 0 17 | call MessageBoxA@16 18 | push eax 19 | call ExitProcess@4 20 | 21 | End Main 22 | -------------------------------------------------------------------------------- /asm/win/hoi0.s: -------------------------------------------------------------------------------- 1 | .file "win.c" 2 | .section .rdata 3 | .LC0: 4 | .ascii "ok\0" 5 | .LC1: 6 | .ascii "hoi\0" 7 | .text 8 | .globl __main 9 | .def __main; .scl 2; .type 32; .endef 10 | __main: 11 | subq $40, %rsp 12 | leaq .LC0(%rip), %r8 13 | leaq .LC1(%rip), %rdx 14 | xorl %r9d, %r9d 15 | xorl %ecx, %ecx 16 | call *__imp_MessageBoxA(%rip) 17 | xorl %eax, %eax 18 | addq $40, %rsp 19 | ret 20 | -------------------------------------------------------------------------------- /ex/grafiek.code: -------------------------------------------------------------------------------- 1 | ; twee grafieken 2 | 3 | f = c → 50 + 1 · (c mod (20 + mouse.x/10)) mod (c mod runtime) 4 | g = d → 50 + 20 · sin ((1.01^d) · runtime/10) 5 | 6 | x = 0..200 7 | y1 = x map f 8 | y2 = x map g 9 | 10 | punten1 = x zip y1 11 | punten2 = x zip y2 12 | grafiek1 = paint(line(punten1), color.red) 13 | grafiek2 = paint(line(punten2), color.green) 14 | 15 | out = draw [grafiek1, grafiek2] 16 | -------------------------------------------------------------------------------- /asm/a.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main() { 5 | int i0 = 3; 6 | float f0 = (float)i0; 7 | f0 += 2.4; 8 | printf("%f\n", f0); 9 | 10 | volatile int a = 10; 11 | volatile int b = 8; 12 | int c = pow(a, b); 13 | printf("%d\n", c); 14 | 15 | volatile double A = 2.0; 16 | volatile double B = 3.0; 17 | double C = A + B; 18 | printf("%f\n", C); 19 | 20 | return 0; 21 | } 22 | -------------------------------------------------------------------------------- /ex/midi.code: -------------------------------------------------------------------------------- 1 | midi = download "res/symf.mid" 2 | 3 | bytes2int = bytes → Σ [bytes₀,bytes₁,bytes₂,bytes₃] zip [2^24,2^16,2^8,2^0] map (·) 4 | 5 | brokken := [] 6 | 7 | i := 0 8 | als i < #midi dan 9 | brokken := brokken ‖ [(i, deel(midi,i,i+4), broklengte(midi,i))] 10 | i := i + 8 + broklengte(midi,i) 11 | eind 12 | 13 | broklengte = Midi,I → bytes2int(deel(Midi,I+4,I+8)) 14 | 15 | uit = i, brokken 16 | -------------------------------------------------------------------------------- /ex/snake.code: -------------------------------------------------------------------------------- 1 | ; snake 2 | snake := 0..3 × [0] 3 | dir := 1,0 4 | head = Lijst → Lijst(#Lijst-1) 5 | 6 | ; draw 7 | block = pos → square(pos · 10, 9) 8 | out = draw (snake map block) 9 | 10 | dirs = [(1,0),(0,1),(-1,0),(0,-1)] 11 | 12 | 13 | ; update 14 | nextstep := now + 1 15 | 16 | 17 | if now > nextstep then 18 | nextstep := now + 1 19 | snake := (snake from 1) ‖ [head(snake) + dir] 20 | end 21 | -------------------------------------------------------------------------------- /lib/geom.code: -------------------------------------------------------------------------------- 1 | ; teken een pijl 2 | pijl = pijl.begin, pijl.eind → pijl.lijnen 3 | pijl.rot = atan (pijl.eind VMIN pijl.begin) 4 | pijl.ltip0 = (sincos(rot + τ/4 + τ/8)) VSCALE 4 5 | pijl.ltip1 = (sincos(rot + τ/4 + τ/4 + τ/8)) VSCALE 4 6 | pijl.tip0 = pijl.eind VPLUS pijl.ltip0 7 | pijl.tip1 = pijl.eind VPLUS pijl.ltip1 8 | pijl.lijnen = [ lijn(pijl.begin,pijl.eind), lijn(pijl.eind,pijl.tip0), lijn(pijl.eind,pijl.tip1) ] 9 | -------------------------------------------------------------------------------- /ex/slang.code: -------------------------------------------------------------------------------- 1 | slang := [(0,0),(1,0)] 2 | kop := (2,0) 3 | 4 | ; vec2 5 | vplus = (vx,vy),(wx,wy) → (vx+wx,vy+wy) 6 | vschaal = (vx,vy),vf → (vx·vf,vy·vf) 7 | 8 | uit = teken(slang map (pos → vierkant(pos vschaal 10, 9))) 9 | 10 | frame := 0 11 | als scherm.ververst dan 12 | frame := frame' + 1 13 | eind 14 | 15 | als frame mod 19 = 18 dan 16 | slang := (slang' vanaf 1) ‖ [kop'] 17 | kop := kop' vplus (0,-1) 18 | eind 19 | -------------------------------------------------------------------------------- /web/www/promo.html: -------------------------------------------------------------------------------- 1 | 2 | Taal is de eerste general purpose vijfde-generatie programmeertaal. 3 | Met een simpele syntax en een veilig typesysteem is code schrijven voor 4 | iedereen toegankelijk geworden. 5 |

6 |
    7 |
  • Makkelijke en declaratieve code, zonder traditionele beslommeringen
    • 8 |
  • Genereer efficiënte machinecode
    • 9 |
  • Compileer functies naar SQL, GLSL, html+js
    • 10 |
11 | -------------------------------------------------------------------------------- /web/www/privacy.html: -------------------------------------------------------------------------------- 1 | Metamine verwerkt persoonsgegevens met geen ander voornemen dan (1) om misbruik door kwaadwillende partijen tegen te gaan en (2) om ontbrekende functionaliteit toe te voegen of foutmeldingen te verhelderen. Je ingestuurde gegevens worden zes maanden bewaard en kunnen geanalyseerd worden volgens bovenstaande redenen. 2 | 3 | Bij deze geef ik toestemming aan metamine om mijn opgestuurde data te bewaren voor zes maanden. 4 | -------------------------------------------------------------------------------- /ex/sb.code: -------------------------------------------------------------------------------- 1 | ; hele veld is ~180 2 | l := (45, 0) 3 | r := (135, 0) 4 | 5 | speler = pos → boog(pos, 10, τ/2, τ) 6 | net = rechthoek((88,0),(92,20)) 7 | 8 | als toetsLinks dan r := r' vplus (-1, 0) eind 9 | als toetsRechts dan r := r' vplus (1, 0) eind 10 | 11 | als toetsA dan l := l' vplus (-1, 0) eind 12 | als toetsD dan l := l' vplus (1, 0) eind 13 | 14 | ;x = (Vx,Vy) → Vx 15 | vplus = (vx,vy),(wx,wy) → vx+wx,vy+wy 16 | 17 | uit = teken [speler l, speler r, net] 18 | -------------------------------------------------------------------------------- /ex/tmp/k.code: -------------------------------------------------------------------------------- 1 | f = [dataA, objsA] → (obj ⇒ [dataB, objsB]) 2 | #dataA ≠ 0 ⇒ obj = dataA deel [ 1, 1 + dataA₀ ] 3 | objsB = (obj ⇒ objsA || [obj]) | (¬obj ⇒ objsA) 4 | dataB = (obj ⇒ dataA vanaf (1 + dataA₀)) | (¬obj ⇒ []) 5 | 6 | objsB = obj ⇒ objsA || [obj] 7 | 8 | decodeer = i → ((herhaal f) [i, []])₁ 9 | encodeer = bers → cat(bers map (b → [#b] || b)) 10 | 11 | berichten = ["hoi", "hoe", "is", "het", "dan"] 12 | uit = ((encodeer ∘ decodeer) berichten) cat ", " 13 | -------------------------------------------------------------------------------- /ex/tmp/w.code: -------------------------------------------------------------------------------- 1 | uit = "hoi" als looptijd > 1 2 | uit = ∅ 3 | 4 | uit(-1) = "a" 5 | 6 | ; looptijd: moment 7 | ; looptijd: 0..∞ 8 | ; looptijd > 1 ⇒ looptijd: 1..∞ 9 | ; (looptijd: 1..∞ ⇒ "hoi"): 10 | ; Δ (looptijd > 1) = {0, 1} 11 | ; delta((>), looptijd, X) = 12 | ; Δ(looptijd > 1) = Δ(looptijd = 1) 13 | ; Δlooptijd = looptijd' + 1 14 | ; Δ1 = (start → 1) 15 | ; Δ(a = b) = {Δa 16 | ; Δlooptijd = (altijd → nu - looptijd') 17 | ; Δ = (waarde → (moment → functie)) 18 | -------------------------------------------------------------------------------- /ex/tmp/a.code: -------------------------------------------------------------------------------- 1 | tekening = [ speler ] 2 | speler = (pos, straal, blauw) 3 | pos = (x, y) 4 | 5 | startpos = (50%,50%) 6 | 7 | ; speler 8 | blauw = (9%,8%,70%) 9 | straal = 3% 10 | pos := startpos 11 | 12 | ; x = (x → x-1)^(toets-links)(50%) 13 | ;a := 1 14 | ;toets-links ⇒ a := 2 15 | 16 | toets-links ⇒ x := x' - 1 17 | toets-rechts ⇒ x := x' + 1 18 | 19 | toets-omhoog ⇒ y := y' - 1 20 | toets-omlaag ⇒ y := y' + 1 21 | 22 | toets-spatie ⇒ pos := startpos 23 | -------------------------------------------------------------------------------- /test/exp.lua: -------------------------------------------------------------------------------- 1 | require 'exp' 2 | 3 | local function vassert(i, moetname) 4 | local name = varname(i) 5 | assert(name == moetname, 'varname('..i..') = "'..name..'" maar moet "'..moetname..'" zijn') 6 | end 7 | 8 | 9 | vassert(1, 'A') 10 | vassert(2, 'B') 11 | vassert(25, 'Y') 12 | vassert(26, 'Z') 13 | vassert(27, 'AA') 14 | vassert(27+25, 'AZ') 15 | vassert(26 + 26*26 + 1, 'AAA') 16 | vassert(26 + 26*26 + 2, 'AAB') 17 | 18 | -- bevat 19 | assert(bevat(X('_arg', '0'), X'_arg')) 20 | -------------------------------------------------------------------------------- /lib/regels.code: -------------------------------------------------------------------------------- 1 | (a := b) ⇒ (start ⇒ b) | a' 2 | (f(a) = b) ⇒ (f ∐= a → b) 3 | (b = f(a)) ⇒ (f ∐= a → b) 4 | (a ||= b) ⇒ ( a |= a' || b) 5 | (a < b) → (a: (b..∞) ∧ b: (-∞ .. a)) 6 | 7 | VAR ⇒ _naam(AUTOINC) 8 | a. ⇒ (a = _atomen(AUTOINC)) 9 | 10 | (c ⇒ (a = b)) ⇒ (a |= (c ⇒ b) ∧ b |= (c ⇒ a)) 11 | (⇒)(c, d, (x = y)) ⇒ (x |= (¬d ⇒ y) ∧ y |= (¬d ⇒ x)) 12 | 13 | a = (|)( VOORALLE ((a |= b), b) ) 14 | a = _var( VOORALLE ((a |:= b), b) ) 15 | 16 | (a = f(a')) ⇒ (a = (herhaal(a' → a)) ??? 17 | -------------------------------------------------------------------------------- /ex/kanaal.code: -------------------------------------------------------------------------------- 1 | ; encodeer 2 | kenc = w → d 3 | d = cat(w map (b → [#b] || b)) 4 | 5 | ; decodeer (recursief) 6 | kdecA = data → Berichten 7 | len = 1 + data₀ 8 | #data > 0 ⇒ Berichten = [ bericht ] || kdecB (data vanaf len) 9 | bericht = data deel (1, len) 10 | 11 | kdec = ((kdecB → kdecA)^999) (x → []) 12 | 13 | ; (||) : (a:lijst(ta), b:lijst(tb)) → c:lijst(ta ∪ tb) 14 | 15 | uit = check cat "," 16 | check = (kenc ∘ kdec) berichten 17 | berichten = ["hoi", "hoe", "is", "het", "dan"] 18 | 19 | 20 | -------------------------------------------------------------------------------- /ex/pe3.code: -------------------------------------------------------------------------------- 1 | ; The following problem is taken from Project Euler. 2 | ; The prime factors of 13195 are 5, 7, 13 and 29. 3 | ; What is the largest prime factor of the number 600851475143 ? 4 | 5 | n := 600851475143 6 | m := 2 7 | factors := [] 8 | klaar = (n ≤ 2) 9 | 10 | als n > 2 dan 11 | als n mod m = 0 dan 12 | factors := factors ‖ [ m ] 13 | m := 2 14 | n := n / m 15 | anders 16 | m := m + 1 17 | eind 18 | eind 19 | 20 | uit = (klaar,m,factors,factors vouw max) 21 | 22 | 23 | 24 | -------------------------------------------------------------------------------- /ex/cirkels.code: -------------------------------------------------------------------------------- 1 | ; concentric circles 2 | w = 18 3 | h = 10 4 | pos = 0..w × 0..h 5 | 6 | ; circlepattern 7 | dx = x - mouse.x/10 8 | dy = y - mouse.y/10 9 | dst = √(dx²+dy²) 10 | 11 | ; is the block on (x,y) on? 12 | isaan = (x,y) → golf < sin(runtime)+2 13 | golf = (runtime·10 - dst) mod 5 14 | blocks = pos filter isaan 15 | 16 | ; blocks 17 | shape = square(a·10,b·10,9) paint color 18 | color = rgb(a/10,b/10,blue) 19 | blue = sin(runtime)/2+0.5 20 | squares = blocks map (a,b → shape) 21 | out = draw squares 22 | 23 | 24 | -------------------------------------------------------------------------------- /asm/comp.s: -------------------------------------------------------------------------------- 1 | # Compositie oefening 2 | 3 | .intel_syntax noprefix 4 | .text 5 | .global _start 6 | 7 | .section .text 8 | 9 | _start: 10 | 11 | mov rax, 1 12 | mov rdi, 1 13 | lea rsi, .groet[rip] 14 | mov rdx, 4 15 | syscall 16 | 17 | # Open bestand 18 | call inc 19 | 20 | # Exit 21 | mov rax, 60 22 | mov rdi, 3 23 | syscall 24 | ret 25 | 26 | # Increment function 27 | inc: 28 | mov rax, 1 29 | ret 30 | 31 | 32 | .section .rodata 33 | 34 | .bestand: 35 | .string "test.txt" 36 | 37 | .groet: 38 | .string "hoi\n" 39 | -------------------------------------------------------------------------------- /ex/mat.code: -------------------------------------------------------------------------------- 1 | breedte = 5 2 | hoogte = 5 3 | puzzel = [punten, horiz, verti] 4 | punten = vul-matrix [ kies-int[0,3], [breedte, hoogte] ] 5 | horiz = vul-matrix [ kies-int[0,3], [breedte - 1, hoogte] ] 6 | verti = vul-matrix [ kies-int[0,3], [breedte, hoogte - 1] ] 7 | 8 | uit = tekst(puzzel) || [10] 9 | 10 | ;geef-score = p → score 11 | ;- 12 | A - B 13 | | 14 | C - D 15 | -; 16 | ; maak matrix gevuld met shit 17 | vul-matrix = (cel, (w, h)) → mat 18 | rij = (f^w) [] 19 | mat = (g^h) [] 20 | f = r → ;r ||-; [cel] 21 | g = m → m || [rij] 22 | -------------------------------------------------------------------------------- /ex/paint2.code: -------------------------------------------------------------------------------- 1 | ; color paint 2 | 3 | colors = [color.blue, color.red, color.green, color.yellow] 4 | lijnen := [] 5 | points := [] 6 | kleurindex := 0 7 | 8 | if mouse.click.begin then 9 | points := [] 10 | end 11 | 12 | if mouse.click and mouse.moves then 13 | points := points ‖ [mouse.pos] 14 | end 15 | 16 | 17 | if mouse.click.end then 18 | lijnen := lijnen ‖ [paint(polygon(points), colors(kleurindex))] 19 | kleurindex := (kleurindex + 1) mod (# colors) 20 | points := [] 21 | end 22 | 23 | out = draw (lijnen ‖ [line(points)]) 24 | 25 | -------------------------------------------------------------------------------- /ex/trippy.code: -------------------------------------------------------------------------------- 1 | ; concentric circles 2 | w = scherm.breedte 3 | h = scherm.hoogte 4 | pos = 0..w × 0..h ; every blockpositions 5 | 6 | 7 | ; circlepattern 8 | f = 20 + 10 · sin(runtime) 9 | dx = x - 80 10 | dy = y - 50 11 | dst = (dx²+dy²)/4 12 | 13 | ; is the block on (x,y) on? 14 | isblock = (x,y) → (-dst + runtime·100) mod 50 < 10 15 | blocks = pos filter isblock 16 | 17 | shape = square(a,b,1) 18 | disco = shape ;paint(shape, color) 19 | color = rgb(a/100,b/100,sin(runtime)/2+0.5) 20 | squares = blocks map ((a,b) → disco) 21 | out = draw squares 22 | 23 | -------------------------------------------------------------------------------- /web/www/en.svg: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | -------------------------------------------------------------------------------- /test/defunc.lua: -------------------------------------------------------------------------------- 1 | do return end 2 | require 'parse' 3 | require 'defunc' 4 | 5 | -- id 6 | local a = X('_arg', '0') 7 | local b = defunc(a, '0') 8 | assert(atom(b) == 'fn.id') 9 | 10 | -- kruid R 11 | local a = X('+', '2', X('_arg', '0')) 12 | local b = defunc(a, '0') 13 | print(deparse(a), deparse(b)) 14 | 15 | -- kruid L 16 | local a = X('+', X('_arg', '0'), '2') 17 | local b = defunc(a, '0') 18 | print(deparse(a), deparse(b)) 19 | 20 | -- merge 21 | local a = X('+', X('_arg', '1'), X('_arg', '2')) 22 | local b = defunc(a, '0') 23 | print(deparse(a), deparse(b)) 24 | -------------------------------------------------------------------------------- /translate.lua: -------------------------------------------------------------------------------- 1 | require 'lisp' 2 | 3 | local lijst = file('lib/en.lst') 4 | 5 | NL2EN = {} 6 | EN2NL = {} 7 | 8 | for NL, EN in lijst:gmatch('([%w%.]+)\t([%w%.]+)\n') do 9 | NL2EN[NL] = EN 10 | EN2NL[EN] = NL 11 | end 12 | 13 | function translate(asb) 14 | for exp in treepairs(asb) do 15 | if isatom(exp) then 16 | if EN2NL[exp.v] then 17 | exp.v = EN2NL[exp.v] 18 | end 19 | end 20 | end 21 | return asb 22 | end 23 | 24 | if test then 25 | require 'parse' 26 | local a = parseexp("a = sqrt(3)") 27 | local b = translate(a) 28 | assert(hash(b) == '=(a wortel(3))', e2s(b)) 29 | end 30 | -------------------------------------------------------------------------------- /asm/hoi.s: -------------------------------------------------------------------------------- 1 | .intel_syntax noprefix 2 | .text 3 | .global _start 4 | 5 | .section .text 6 | 7 | _start: 8 | # Print groet 9 | mov rax, 1 10 | mov rdi, 1 11 | lea rsi, .groet[rip] 12 | mov rdx, 4 13 | syscall 14 | 15 | # Open bestand 16 | mov rax, 2 17 | lea rdi, .bestand[rip] 18 | mov rsi, 0x40 19 | mov rdx, 0644 20 | syscall 21 | 22 | # Sluit bestand 23 | mov rdi, rax 24 | mov rax, 3 25 | syscall 26 | 27 | # Exit 28 | mov rax, 60 29 | mov rdi, 0 30 | syscall 31 | ret 32 | 33 | .section .rodata 34 | 35 | .bestand: 36 | .string "test.txt" 37 | 38 | .groet: 39 | .string "hoi\n" 40 | -------------------------------------------------------------------------------- /ex/pe2.code: -------------------------------------------------------------------------------- 1 | ; The following problem is taken from Project Euler. 2 | ; Each new term in the Fibonacci sequence is generated by adding the previous two terms. By starting with 1 and 2, the first 10 terms will be: 3 | 4 | ; 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, ... 5 | 6 | ; By considering the terms in the Fibonacci sequence whose values do not exceed four million, find the sum of the even-valued terms. 7 | 8 | x := 1 9 | y := 2 10 | s := 0 11 | 12 | stop = 4000000 13 | 14 | als y < stop dan 15 | x := y 16 | y := x + y 17 | 18 | als y mod 2 = 0 dan 19 | s := s + y 20 | eind 21 | eind 22 | 23 | 24 | uit = s 25 | -------------------------------------------------------------------------------- /test/codegen.lua.1: -------------------------------------------------------------------------------- 1 | require 'ontleed' 2 | require 'bouw.codegen' 3 | require 'bouw.luagen' 4 | 5 | local function verwacht(code, val) 6 | local a = ontleedexp(code) 7 | local im = codegen(a) 8 | local lua = luagen(im) 9 | 10 | print('code') 11 | print(table.concat(map(im, combineer), '\n')) 12 | print() 13 | 14 | print('lua') 15 | print(lua) 16 | print() 17 | 18 | local func = assert(load(lua)) 19 | 20 | local a = func() 21 | assert(a == val, string.format('%s moet %s zijn maar was %s', code, lenc(a), lenc(val))) 22 | end 23 | 24 | 25 | verwacht("1 + 2 · 3", 7) 26 | verwacht("(fn.merge(id,id) ∘ (+))(2)", 4) 27 | -------------------------------------------------------------------------------- /asm/win/hoi.s: -------------------------------------------------------------------------------- 1 | .file "hoi1.c" 2 | .intel_syntax noprefix 3 | .text 4 | .section .rdata,"dr" 5 | .LC0: 6 | .ascii "hoi\0" 7 | .text 8 | .globl __main 9 | .def __main; .scl 2; .type 32; .endef 10 | .seh_proc __main 11 | __main: 12 | sub rsp, 56 13 | .seh_stackalloc 56 14 | .seh_endprologue 15 | mov ecx, -11 16 | call [QWORD PTR __imp_GetStdHandle[rip]] 17 | xor r9d, r9d 18 | mov r8d, 3 19 | lea rdx, .LC0[rip] 20 | mov rcx, rax 21 | mov QWORD PTR 32[rsp], 0 22 | call [QWORD PTR __imp_WriteConsoleA[rip]] 23 | xor eax, eax 24 | add rsp, 56 25 | ret 26 | .seh_endproc 27 | .ident "GCC: (GNU) 8.3-win32 20191201" 28 | -------------------------------------------------------------------------------- /asm/win/hoi1.s: -------------------------------------------------------------------------------- 1 | .file "hoi1.c" 2 | .intel_syntax noprefix 3 | .text 4 | .section .rdata,"dr" 5 | .LC0: 6 | .ascii "hoi\0" 7 | .text 8 | .globl __main 9 | .def __main; .scl 2; .type 32; .endef 10 | .seh_proc __main 11 | __main: 12 | sub rsp, 56 13 | .seh_stackalloc 56 14 | .seh_endprologue 15 | mov ecx, -11 16 | call [QWORD PTR __imp_GetStdHandle[rip]] 17 | xor r9d, r9d 18 | mov r8d, 3 19 | lea rdx, .LC0[rip] 20 | mov rcx, rax 21 | mov QWORD PTR 32[rsp], 0 22 | call [QWORD PTR __imp_WriteConsoleA[rip]] 23 | xor eax, eax 24 | add rsp, 56 25 | ret 26 | .seh_endproc 27 | .ident "GCC: (GNU) 8.3-win32 20191201" 28 | -------------------------------------------------------------------------------- /ex/tmp/bt.code: -------------------------------------------------------------------------------- 1 | ; kanaal encodeer 2 | kenc = w → d 3 | d = cat(w map (b → [#b] || b)) 4 | 5 | ; kanaal decodeer 6 | kdec = data → ((herhaal kdecEen) [data, []])₁ 7 | kdecEen = [dataA, berichtenA] → (#dataA > 0 ⇒ [dataB, berichtenB]) 8 | bericht = dataA deel [1, 1 + dataA₀] 9 | dataB = dataA vanaf (1 + dataA₀) 10 | berichtenB = berichtenA || [bericht] 11 | 12 | ; b encodeer 13 | bencB = w → d 14 | w:lijst ⇒ d = "l" || cat(w map bencA) || "e" 15 | w:int ⇒ d = "i" || tekst w || "e" 16 | 17 | ; iteratief verdiepen 18 | verdiep = bencA → bencB 19 | benc = (verdiep^1000) (x → []) 20 | 21 | ; kdec, kenc, bdec, benc 22 | uit = 23 | -------------------------------------------------------------------------------- /ex/tmp/d.code: -------------------------------------------------------------------------------- 1 | totaal = Σ 1 .. 1000 2 | t = "de som van 1 tot 1000 = " || tekst(totaal) 3 | 4 | y = sin(looptijd)/2 5 | posA = (80%, 20%) 6 | posB = (70% + y, 80%) 7 | 8 | ; vormen 9 | achtergrond = rechthoek((0,0), (2,1), zwart) 10 | balA = cirkel(posA, 0.1, geel) 11 | balB = cirkel(posB, 0.1, blauw) 12 | bericht = schrijf((30%, 30%), t, wit) 13 | 14 | tekening = [ achtergrond, balA, balB, bericht ] 15 | 16 | ; openGL-frame = vertices[ 17 | 18 | wit = (1,1,1) 19 | zwart = (0,0,0) 20 | geel = (1,1,0) 21 | blauw = (0,0,1) 22 | 23 | rechthoek(a,b,c) = (1, a, b, c) 24 | cirkel(d,e,f) = (0, d, e, f) 25 | schrijf(g,h,i) = (2, g, h, i) 26 | -------------------------------------------------------------------------------- /ex/bdec.code: -------------------------------------------------------------------------------- 1 | bdecB = d → w 2 | d₀ = 'l' ⇒ w = "l" || cat(inhoud) || "e" 3 | d₀ = 'i' ⇒ w = d tot (1 + d vind "e") 4 | 5 | ; blijst 6 | inhoud = (leesMeerdere [lijstdata, []]) 1 7 | lijstdata = d vanaf 1 8 | 9 | ; meerdere lezen 10 | leesEen = [subdataA, objsA] → (obj ⇒ [subdataB, objsB]) 11 | leesMeerdere = leesEen ^ breedte 12 | obj = bdecA subdataA 13 | objsB = objsA || [ obj ] 14 | subdataB = subdataA vanaf (#obj) 15 | 16 | ; iteratief verdiepen 17 | verdiep = bdecA → bdecB 18 | bdec = (verdiep^diepte) (x → []) 19 | 20 | ;in = "li1ee" 21 | in = "llei3ei4ee" 22 | uit = "bdec('" || in || "') = " || (bdec in) 23 | diepte = 2 24 | breedte = 2 25 | 26 | -------------------------------------------------------------------------------- /template: -------------------------------------------------------------------------------- 1 | #!/usr/bin/lua 2 | require 'util' 3 | local fmt,lst,uit = ... 4 | local gebruik = "usage: template [SJABLOON] [LIJST] [UITVOER]\n\tThe list must be in the format:\n\ttitel [TAB] Terminator\n\tgenre [TAB] tragikomedie" 5 | assert(fmt, gebruik) 6 | assert(lst, gebruik) 7 | assert(uit, gebruik) 8 | 9 | fmt = assert(file(fmt), 'niet gevonden: '..fmt) 10 | lst = assert(file(lst), 'niet gevonden: '..lst) 11 | 12 | require 'template' 13 | 14 | local dict = {} 15 | 16 | for naam, tekst in lst:gmatch('(%w+)\t+(.-)\n') do 17 | dict[naam] = unescape(tekst) 18 | end 19 | 20 | local res = template(fmt, dict) 21 | assert(res, 'fout!') 22 | file(uit, res) 23 | -------------------------------------------------------------------------------- /asm/win/Makefile: -------------------------------------------------------------------------------- 1 | hoi: hoi.s 2 | x86_64-w64-mingw32-gcc -nostdlib hoi.s -lkernel32 -luser32 -o hoi.exe 3 | #strip hoi.exe 4 | 5 | hoi0: hoi0.s 6 | x86_64-w64-mingw32-gcc -nostdlib hoi0.s -luser32 -o hoi0.exe 7 | #strip hoi0.exe 8 | 9 | hoi1: hoi1.c 10 | x86_64-w64-mingw32-gcc -S -Os -masm=intel -nostdlib hoi1.c -luser32 -lkernel32 -o hoi1.s 11 | x86_64-w64-mingw32-gcc -Os -nostdlib hoi1.c -luser32 -lkernel32 -o hoi1.exe 12 | #strip hoi1.exe 13 | 14 | win: win.c 15 | x86_64-w64-mingw32-gcc -S -Os -masm=intel win.c -lgdi32 -luser32 -lkernel32 -o win.s 16 | x86_64-w64-mingw32-gcc -Os win.c -lgdi32 -luser32 -lkernel32 -o win.exe 17 | -------------------------------------------------------------------------------- /asm/abs.s: -------------------------------------------------------------------------------- 1 | .file "abs.c" 2 | .text 3 | .section .rodata.str1.1,"aMS",@progbits,1 4 | .LC0: 5 | .string "%d\n" 6 | .section .text.startup,"ax",@progbits 7 | .p2align 4,,15 8 | .globl main 9 | .type main, @function 10 | main: 11 | .LFB11: 12 | .cfi_startproc 13 | subq $24, %rsp 14 | .cfi_def_cfa_offset 32 15 | leaq .LC0(%rip), %rdi 16 | movl $-3, 12(%rsp) 17 | movl 12(%rsp), %esi 18 | movl %esi, %eax 19 | sarl $31, %eax 20 | xorl %eax, %esi 21 | subl %eax, %esi 22 | xorl %eax, %eax 23 | call printf@PLT 24 | xorl %eax, %eax 25 | addq $24, %rsp 26 | .cfi_def_cfa_offset 8 27 | ret 28 | .cfi_endproc 29 | .LFE11: 30 | .size main, .-main 31 | .ident "GCC: (Debian 8.3.0-7) 8.3.0" 32 | .section .note.GNU-stack,"",@progbits 33 | -------------------------------------------------------------------------------- /ex/pe5.code: -------------------------------------------------------------------------------- 1 | ; The following problem is taken from Project Euler. 2 | 3 | ; 2520 is the smallest number that can be divided by each of the numbers from 1 to 10 without any remainder. 4 | 5 | ; What is the smallest positive number that is evenly divisible by all of the numbers from 1 to 20? 6 | 7 | 8 | ispriem := ja 9 | 10 | n := 1 11 | i := 2 12 | deler := 0 13 | priems := [1] 14 | 15 | als i ≤ √n dan 16 | als n mod i = 0 dan 17 | ispriem := nee 18 | deler := i 19 | eind 20 | i := i + 1 21 | anders 22 | i := 2 23 | n := n + 1 24 | als ispriem en n ≤ 20 dan 25 | priems := priems ‖ [n] 26 | eind 27 | ispriem := ja 28 | eind 29 | 30 | priemmod = priems reduceer (·) 31 | 32 | uit = (n, ispriem, deler, priems, priemmod) 33 | -------------------------------------------------------------------------------- /test/pong.lua: -------------------------------------------------------------------------------- 1 | require 'util' 2 | require 'compile' 3 | require 'doe' 4 | local socket = require 'socket' 5 | 6 | local pong = file 'ex/pong.code' 7 | local lib = file 'lib/std.code' 8 | local prog = pong .. lib 9 | 10 | do 11 | local _,numlines = prog:gsub('\n', ' ') 12 | print('==== compile(pong) ====') 13 | print('bron: '..numlines..' lines, '..#prog..' bytes') 14 | end 15 | 16 | local voor = socket.gettime() 17 | 18 | local app = compile(prog) 19 | local n = 0 20 | assert(app, 'pong kon niet eens gecompileerd worden') 21 | for i,ins in ipairs(app) do 22 | n = n + #exp2string(ins) 23 | end 24 | print('resultaat: '..n..' bytes') 25 | 26 | local na = socket.gettime() 27 | local dt = math.floor((na - voor)*1000) 28 | print('compile(pong) duurde '..dt..'ms') 29 | 30 | 31 | -------------------------------------------------------------------------------- /asm/call.s: -------------------------------------------------------------------------------- 1 | # Assembly 2 | .intel_syntax noprefix 3 | .text 4 | .global _start 5 | 6 | .section .text 7 | 8 | _start: 9 | jmp fn1_eind 10 | fn1: # (fn)(1) 11 | sub rsp, 8 # (arg)(1) 12 | mov [rsp], rdi 13 | sub rsp, 8 # 1 14 | mov rax, 1 15 | mov [rsp], rax 16 | mov rax, 8[rsp] # (+) 17 | mov rbx, [rsp] 18 | add rax, rbx 19 | mov 8[rsp], rax 20 | add rsp, 8 21 | mov rax, [rsp] 22 | ret 23 | fn1_eind: 24 | sub rsp, 8 25 | mov rax, fn1 26 | mov [rsp], rax 27 | sub rsp, 8 # 1 28 | mov rax, 1 29 | mov [rsp], rax 30 | mov rax, 8[rsp] # (_f) 31 | mov rbx, [rsp] 32 | mov rdi, rbx 33 | mov 8[rsp], rbx 34 | add rsp, 8 35 | call rax 36 | 37 | # Exit 38 | mov rax, 60 39 | mov rdi, [rsp] 40 | syscall 41 | ret 42 | -------------------------------------------------------------------------------- /asm/hoi0.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | 6 | uint64_t atoi(uint64_t a, char* t) { 7 | if (a == 0) { 8 | t[0] = '0'; 9 | return 1; 10 | } 11 | int len = 0; 12 | int p = 0; 13 | if (a < 0) { 14 | a = -a; 15 | t[len++] = '-'; 16 | t[len++] = '-'; 17 | p = 1; 18 | } 19 | while (a > 0) { 20 | int b = a % 10; 21 | t[len++] = b + '0'; 22 | a /= 10; 23 | } 24 | for (int i = 0; i < len/2; i++) { 25 | int tt = t[i+p]; 26 | t[i+p] = t[len-i-1+p]; 27 | t[len-i-1+p] = tt; 28 | } 29 | 30 | return len; 31 | } 32 | 33 | int _start() { 34 | char data[(LONG_MAX%10)+1]; 35 | int len = atoi(LONG_MAX,data); 36 | syscall(SYS_write, STDOUT_FILENO, data, len); 37 | syscall(SYS_exit, 0); 38 | } 39 | -------------------------------------------------------------------------------- /ex/tmp/b.code: -------------------------------------------------------------------------------- 1 | ;tor = bestand "spiderman.torrent" 2 | uit = tekst(w) 3 | 4 | w = bdec tor 5 | tor = "li3ee" 6 | bdec = d → ((herhaal bdecz)(d, []))₁ 7 | 8 | ttekst = 1 9 | tint = 2 10 | tlijst = 3 11 | tmap = 4 12 | tmapW = 4 13 | 14 | vlees = data deel (1, data vind "e") 15 | 16 | bdecz = (data, stapel) → (rest, stapelB) 17 | cijfer data₀ ⇒ stapelB = stapel || [ ttekst ] 18 | data₀ = 'i' ⇒ stapelB = stapel || [ tint ] 19 | data₀ = 'l' ⇒ stapelB = stapel || [ tlijst ] 20 | data₀ = 'd' ⇒ stapelB = stapel || [ tmap ] 21 | data₀ = 'e' ⇒ stapelB = stapel tot (#stapel - 1) 22 | 23 | cijfer data₀ ⇒ rest = data vanaf (data vind ":" + 1) 24 | data₀ = 'i' ⇒ rest = data vanaf (data vind "e" + 1) 25 | data₀ = 'l' ⇒ rest = data vanaf 1 26 | data₀ = 'd' ⇒ rest = data vanaf 1 27 | -------------------------------------------------------------------------------- /ex/pe4.code: -------------------------------------------------------------------------------- 1 | ; The following problem is taken from Project Euler. 2 | ; A palindromic number reads the same both ways. The largest palindrome made from the product of two 2-digit numbers is 9009 = 91 × 99. 3 | 4 | ; Find the largest palindrome made from the product of two 3-digit numbers. 5 | 6 | palindroom = p → ispalindroom 7 | 8 | t = tekst p 9 | half1 = ⌊#t / 2⌋ 10 | half2 = ⌈#t / 2⌉ 11 | hoog = t tot half1 12 | laag = t vanaf half2 13 | moetlaag = omdraai hoog 14 | ispalindroom = (laag = moetlaag) 15 | 16 | x := 100 17 | y := 100 18 | 19 | als x < 1000 dan 20 | als y < 1000 dan 21 | x := x + 1 22 | 23 | als palindroom(x·y) dan 24 | pmax := x·y 25 | eind 26 | eind 27 | anders 28 | y := y + 1 29 | x := 100 30 | eind 31 | 32 | pmax := 11 33 | 34 | uit = x·y, pmax 35 | -------------------------------------------------------------------------------- /ex/bdec1.code: -------------------------------------------------------------------------------- 1 | ;in = "li1ee" 2 | in = "li3ee" 3 | uit = "bdec('" || in || "') = " || (bdec in) 4 | diepte = 2 5 | breedte = 1 6 | 7 | ; bdecodeer 8 | bdecB = data → bint | blijst 9 | data₀ = 'i' ⇒ bint = data tot eind 10 | data₀ = 'l' ⇒ blijst = "l" || cat(inhoud) || "e" 11 | 12 | ; bint 13 | eind = 1 + data vind "e" 14 | 15 | ; blijst 16 | lijstdata = data vanaf 1 17 | inhoud = (leesMeerdere [[], lijstdata]) 0 18 | 19 | leesMeerdere = leesEen ^ breedte 20 | leesEen = [subs, subdata] → volgende | einde 21 | 22 | sub = bdecA subdata 23 | ¬sub ⇒ einde = [subs, "i3e"] 24 | sub ⇒ volgende = [subs || [sub], rest] 25 | rest = subdata vanaf (#sub) 26 | 27 | ; iteratief verdiepen 28 | verdiep = bdecA → bdecB 29 | bdec = (verdiep^diepte) bdecI 30 | bdecI = (x → []) 31 | 32 | -------------------------------------------------------------------------------- /ex/b.code: -------------------------------------------------------------------------------- 1 | uit = "looptijd: " ‖ itoa(atoi(itoa(atoi(itoa(atoi(itoa(-3))))))) 2 | 3 | ; tekst -> integer 4 | atoi = b → i 5 | ; negatief? 6 | als b₀ = '-' dan 7 | sign = -1 8 | tekens = b vanaf 1 9 | anders 10 | sign = 1 11 | tekens = b 12 | eind 13 | 14 | ; cijfers van de tekst 15 | cijfers = tekens map (t → t - '0') 16 | 17 | ; waarde van elk cijfer gegeven de positie 18 | waarde = (k → cijfers(j) · 10^k) 19 | j = #tekens - k - 1 20 | 21 | ; positie en resultaat 22 | pos = 0 .. #tekens 23 | i = sign · Σ (pos map waarde) 24 | 25 | ; integer -> tekst 26 | itoa = x → a 27 | n = 1 + entier(log10(max(abs x, 1))) 28 | neg = (⇒)((x < 0), "-", "") 29 | a = neg ‖ ((n .. 0) map cijfer) 30 | geschaald = (abs x)/10^m 31 | cijfer = m → '0' + (entier geschaald) mod 10 32 | -------------------------------------------------------------------------------- /lib/demo.lst: -------------------------------------------------------------------------------- 1 | blokken blocks 2 | isblok isblock 3 | blokken blocks 4 | vierkanten squares 5 | cirkelpatroon circlepattern 6 | breedte width 7 | hoogte height 8 | huidige current 9 | alle every 10 | blokposities blockpositions 11 | staat is 12 | het the 13 | blok block 14 | op on 15 | aan on 16 | houdt keeps 17 | bij track 18 | welke which 19 | dit this 20 | 21 | rechts right 22 | bal ball 23 | links left 24 | speler player 25 | pauze pause 26 | raakt hits 27 | tot til 28 | besturing controls 29 | spelers players 30 | 31 | de the 32 | stuiter bounce 33 | onder below 34 | variabelen variables 35 | verplaatsing movement 36 | STUITER BOUNCE 37 | hele whole 38 | veld field 39 | plus add 40 | 41 | loop walk 42 | pijltjes arrows 43 | boven up 44 | rechtdoor straight 45 | transformeer transform 46 | met with 47 | -------------------------------------------------------------------------------- /ex/tmp/x.code: -------------------------------------------------------------------------------- 1 | uit = bestand '/dev/urandom' 2 | 3 | bestand(naam). 4 | ; bestand = atoom(0) 5 | ; naam = bestand.atoom(1) 6 | 7 | ;- 8 | cirkel((0.2, 0.2), 0.3, blauw) 9 | 10 | cirkel( 11 | -; 12 | 13 | ; bd := bestands-open naam 14 | ; data,bd := bestand-lees bd' 15 | 16 | Δbestand = 17 | 0 → is-leesbaar bd → 18 | 0 → bd = bestand-open naam 19 | 20 | in = stdin 21 | uit = stduit 22 | stduit: schrijfbaar-per-blok 23 | 24 | 25 | uit = bestand('/dev/urandom') 26 | 27 | bestand(naam). 28 | 29 | bestand-open: 30 | 31 | bd = bestand-open naam 32 | brok = lees(bd) als is-leesbaar(bd) 33 | ; brok: moment → data 34 | ; is-leesbaar: bd → (moment → bit) 35 | ; lees: bd → (moment → data) 36 | 37 | stduit = stduit' || brok 38 | 39 | 40 | Δ stduit(a) = schrijf(stduit, a) 41 | Δ stdin(a) = lees(stdin, a) 42 | -------------------------------------------------------------------------------- /lib/unistd.code: -------------------------------------------------------------------------------- 1 | bestand: int 2 | stdin = 0 3 | stduit = 1 4 | stdfout = 2 5 | stdin: bestand 6 | stduit: bestand 7 | stdfout: bestand 8 | 9 | sysread = 0 10 | syswrite = 1 11 | sysopen = 2 12 | sysclose = 3 13 | 14 | ordonly = 0 15 | owronly = 1 16 | ordwr = 2 17 | ocreat = 64 18 | 19 | succ = succa → succa + 1 20 | 21 | ; push 22 | app = schrijf(stduit, uit) 23 | schrijf = (Bd, Dat) → syscall(syswrite, Bd, Dat, #Dat) · 0 + Bd 24 | sluit = Bc → syscall(sysclose, Bc) 25 | ;- 26 | -; 27 | ;app = stduit schrijf uit 28 | ;app = uit 29 | ; bestanden 30 | ; syscalls 31 | ; libcalls 32 | ;- 33 | Bd: bestand 34 | Dat: data 35 | lees = (Bl) → syscall(sysRead, Bl, Buf, 1024) · 0 + Buf 36 | Buf = "hoi" 37 | open = Pad → syscall(sysOpen, Pad, oRdwr + oCreat, 420) 38 | -; 39 | ;app = sluit(schrijf(stduit, uit)) 40 | -------------------------------------------------------------------------------- /ex/cool1.code: -------------------------------------------------------------------------------- 1 | ; twee grafieken 2 | 3 | f = c → 50 + 10 · tan(c³) · sin(c²/10+looptijd) 4 | g = d → 50 5 | h = e → 50; + 30 · sin(e²-3+1.1^looptijd) 6 | i = E → 50; + klem(10·sin(E/10·looptijd),0,10) 7 | j = F → 50; + 20 · sin F/8 + 10 · sin (F/17) + (looptijd·F) mod 10 8 | 9 | x = 0..200 10 | y1 = x map f 11 | y2 = x map g 12 | y3 = x map h 13 | y4 = x map i 14 | y5 = x map j 15 | 16 | punten1 = x rits y1 17 | punten2 = x rits y2 18 | punten3 = x rits y3 19 | punten4 = x rits y4 20 | punten5 = x rits y5 21 | grafiek1 = verf(polygoon(punten1), kleur.rood) 22 | grafiek2 = verf(lijn(punten2), kleur.groen) 23 | grafiek3 = verf(lijn(punten3), kleur.blauw) 24 | grafiek4 = verf(lijn(punten4), kleur.geel) 25 | grafiek5 = verf(lijn(punten5), rgb(1,looptijd mod 1,1)) 26 | 27 | uit = teken [grafiek1, grafiek2, grafiek3, grafiek4, grafiek5] 28 | 29 | -------------------------------------------------------------------------------- /doe: -------------------------------------------------------------------------------- 1 | #!/usr/bin/lua 2 | package.path = package.path .. ";../?.lua" 3 | require 'doe' 4 | require 'lisp' 5 | require 'util' 6 | require 'typeer' 7 | 8 | local vlag,pad = ... 9 | if vlag == '-v' then 10 | _G.verboos = true 11 | end 12 | if not pad then pad = vlag end 13 | if not pad then 14 | print('geen invoer') 15 | print( 16 | [[gebruik: doe [OPTIES...] [BESTANDEN...] 17 | Voert een programma uit. Het programma moet opgeslagen zijn als lispbestand 18 | en een lijst van waarderingen representeren. 19 | -v verboos zijn 20 | ]]) 21 | return 22 | end 23 | if pad:sub(-9) ~= '.app.lisp' then 24 | pad = pad .. '.app.lisp' 25 | end 26 | local opdrachten = file(pad) 27 | if not opdrachten then 28 | print('bestand niet gevonden') 29 | return 30 | end 31 | local opdrachten = lisp(opdrachten) 32 | 33 | local res = doe(opdrachten) 34 | print(leed(res)) 35 | -------------------------------------------------------------------------------- /asm/mul.s: -------------------------------------------------------------------------------- 1 | .intel_syntax noprefix 2 | .text 3 | .global _start 4 | 5 | .section .text 6 | 7 | _start: 8 | # Spannend 9 | mov rax, 1234567 10 | sub rsp, 64 11 | mov rcx, rsp 12 | call atoi 13 | 14 | # Print groet 15 | mov rax, 1 16 | mov rdi, 1 17 | mov rsi, rsp 18 | mov rdx, r8 19 | syscall 20 | 21 | # Exit 22 | mov rax, 60 23 | mov rdi, 0 24 | syscall 25 | ret 26 | 27 | 28 | # int, data -> len 29 | # rax, rcx -> r8 30 | atoi: 31 | mov r9, rcx # waar zijn we 32 | cmp rax, 0 # getal 33 | jne lus 34 | 35 | nul: 36 | inc rcx 37 | movb [rcx], '0' 38 | jmp eind 39 | 40 | lus: 41 | cmp rax, 0 42 | je eind 43 | cdq 44 | mov rbx, 10 45 | idiv rbx 46 | add rdx, '0' 47 | mov rbx, rdx 48 | movb [rcx], bl 49 | inc rcx 50 | jmp lus 51 | 52 | eind: 53 | mov r8, rcx 54 | sub r8, rsp 55 | ret 56 | 57 | .groet: 58 | .string "hoi\n" 59 | -------------------------------------------------------------------------------- /lib/3d.code: -------------------------------------------------------------------------------- 1 | ; 3d poging 999 2 | punten = [20,80] × [20,80] × [20,80] 3 | qpunten = punten map ((x,y),z → [x,y,z,2]) 4 | tpunten = qpunten map (qpunt → mat · qpunt) 5 | spunten = tpunten map ([tx,ty,tz,tw] → [(tx-80)/tw+80,(ty-50)/tw+50]) 6 | 7 | d = zdraai looptijd 8 | x = verplaats(0,0,2) 9 | cam = d ;x · d 10 | 11 | z1 = (0.1+1000)/(1000-0.1) 12 | z2 = (2·0.1·1000)/(1000-0.1) 13 | proj = [[1,0,0,0],[0,1,0,0],[0,0,z1,-1],[0,0,z2,0]] 14 | 15 | mat = cam · proj 16 | 17 | indices1 = [ [0,1,3,2], [0,1,5,4], [0,4,6,2] ] 18 | indices2 = [ indices1₀+4, indices1₁+2, indices1₂+1] 19 | indices = omdraai(indices1 ‖ indices2) 20 | pdata = indices map (is → is map spunten) 21 | kleuren = [kleur.rood, kleur.groen, kleur.blauw, kleur.geel, kleur.paars, kleur.cyaan] 22 | 23 | polygonen = pdata map polygoon 24 | kpolygonen = polygonen zip kleuren map verf 25 | uit = teken kpolygonen 26 | -------------------------------------------------------------------------------- /tolk: -------------------------------------------------------------------------------- 1 | #!/usr/bin/lua 2 | require 'util' 3 | 4 | NL2EN = {} 5 | EN2NL = {} 6 | 7 | function toepas(pad) 8 | local flijst = io.open(pad) 9 | local lijst = flijst:read('*a') 10 | flijst:close() 11 | 12 | 13 | for NL, EN in lijst:gmatch('([%w%.]+)\t([%w%.]+)\n') do 14 | NL2EN[NL] = EN 15 | EN2NL[EN] = NL 16 | end 17 | end 18 | 19 | toepas('lib/en.lst') 20 | toepas('lib/demo.lst') 21 | 22 | 23 | local inn, uit = ... 24 | if not inn and not uit then error('gebruik: tolk [IN] [UIT]') end 25 | if not inn then error('IN niet gedefineerd') end 26 | local code = file((inn)) 27 | if not code then error('bestand niet gevonden') end 28 | 29 | if not uit then 30 | uit = inn 31 | end 32 | 33 | local res = code:gsub('([%w%.]+)', function (token) 34 | return NL2EN[token] or token 35 | end) 36 | 37 | local res = res:gsub('(%w+)', function (token) 38 | return NL2EN[token] or token 39 | end) 40 | 41 | if uit then 42 | file(uit, res) 43 | else 44 | print(res) 45 | end 46 | 47 | -------------------------------------------------------------------------------- /ex/tmp/s.code: -------------------------------------------------------------------------------- 1 | ; dit programma tekent door "tekening" te vullen met vormen 2 | ; qua coordinaten: linksonder is (0,0) en rechtsboven is (16/9,1) 3 | ; de code hoeft niet gesorteerd te staan 4 | tekening = [ achtergrond ] ;, bal, groet ] 5 | 6 | ; de tekst "Hoi" aan de linkerkant 7 | groet = schrijf(groetpos, "Hoi", wit) 8 | groetpos = (0, (1 + sin looptijd) / 2) 9 | 10 | 11 | ; een gele cirkel die om het centrum (0.9, 0.5) cirkelt 12 | bal = cirkel(pos, straal, geel) 13 | pos = (x, y) 14 | x = 0.9 + 0.5 · cos(looptijd) 15 | y = 0.5 + 0.5 · sin(looptijd) 16 | straal = 0.2 17 | 18 | interpoleer = (a,b,n) → (n·a₀+m·b₀, n·a₁+b₁·m₁, n·c₁+m·b₂) 19 | n + m = 1 20 | 21 | ; maak de achtergrond zwartblauw 22 | achtergrond = rechthoek((0,0), (2,1), achtergrondkleur) 23 | achtergrondkleur = (0, 0, sin looptijd + 0.5) 24 | 25 | ; lib 26 | cirkel = c → (0, c₀, c₁, c₂) 27 | rechthoek = v → (1, v₀, v₁, v₂) 28 | zwart = (0, 0, 0) 29 | groen = (0, 1, 0) 30 | geel = (1, 1, 0) 31 | rood = (1, 0, 0) 32 | wit = (1, 1, 1) 33 | -------------------------------------------------------------------------------- /test/langecode.lua: -------------------------------------------------------------------------------- 1 | require 'compile' 2 | require 'doe' 3 | socket = require 'socket' 4 | 5 | function langecode(maxlen) 6 | local len = 0 7 | local bron = {} 8 | 9 | local makevar = makevars() 10 | local prev2 = makevar() 11 | local prev1 = makevar() 12 | bron[#bron+1] = string.format('%s = 10', prev1) 13 | bron[#bron+1] = string.format('%s = 1000', prev2) 14 | while len < maxlen do 15 | local var = makevar() 16 | local lijn = string.format('%s = (%s + %s) / 2 + 3', var, prev1, prev2) 17 | bron[#bron+1] = lijn 18 | len = len + #lijn + 1 19 | prev1,prev2 = var,prev1 20 | end 21 | bron[#bron+1] = 'uit = '..prev1 22 | local moetlijnen = #bron 23 | local lang = table.concat(bron, '\n') 24 | len = len + #bron[#bron] 25 | return lang, #bron 26 | end 27 | 28 | -- 10 kb 29 | local code = langecode(10000) 30 | 31 | local voor = socket.gettime() 32 | uit = compile(code) 33 | local na = socket.gettime() 34 | local ms = math.floor((na - voor) * 1000) 35 | print('10 kB vertalen duurde '..ms..' ms') 36 | -------------------------------------------------------------------------------- /test/sb.code: -------------------------------------------------------------------------------- 1 | kantW = 178 / 2 ; breedte van 1 zijde 2 | uit = teken [links, rechts, net] 3 | geel = rgb(1,1,0) 4 | blauw = rgb(0,0,1) 5 | wit = rgb(1,1,1) 6 | spelerBoog = pos → boog(pos, 10, τ/2, τ) 7 | net = (rechthoek((kantW-2,0),(kantW+2,20))) verf wit 8 | 9 | ; links 10 | links.x := kantW/2 11 | links.y := 0 12 | links.vy := 0 13 | links = (spelerBoog(links.x, links.y)) verf geel 14 | 15 | ; rechts 16 | rechts.x := kantW/2·3 17 | rechts.y := 0 18 | rechts = (spelerBoog(rechts.x, rechts.y)) verf blauw 19 | 20 | ; links invoer 21 | als toets.a en links.x' > 0 dan 22 | links.x := links.x' - 1 23 | eind 24 | als toets.d en links.x < kantW dan 25 | links.x := links.x' + 1 26 | eind 27 | als toets.w en links.y = 0 dan 28 | links.vy := -8 29 | eind 30 | als links.y ≠ 0 en links.vy ≠ 0 dan 31 | links.y := linksy + links.vy' 32 | eind 33 | 34 | als toets.links en rechts.x > kantW dan 35 | rechts.x := rechts.x - 1 36 | eind 37 | als toets.rechts en rechts.x < kantW·2 dan 38 | rechts.x := rechts.x + 1 39 | eind 40 | -------------------------------------------------------------------------------- /asm/double.s: -------------------------------------------------------------------------------- 1 | .file "double.c" 2 | .section .rodata 3 | .LC2: 4 | .string "%f\n" 5 | .text 6 | .globl main 7 | .type main, @function 8 | main: 9 | .LFB0: 10 | .cfi_startproc 11 | pushq %rbp 12 | .cfi_def_cfa_offset 16 13 | .cfi_offset 6, -16 14 | movq %rsp, %rbp 15 | .cfi_def_cfa_register 6 16 | subq $48, %rsp 17 | movq .LC0(%rip), %rax 18 | movq %rax, -16(%rbp) 19 | movq .LC1(%rip), %rax 20 | movq %rax, -24(%rbp) 21 | fldl -16(%rbp) 22 | fldl -24(%rbp) 23 | faddp %st, %st(1) 24 | fstpl -40(%rbp) 25 | fldl -40(%rbp) 26 | fstpl -8(%rbp) 27 | movq -8(%rbp), %rax 28 | movq %rax, -40(%rbp) 29 | movlps -40(%rbp), %xmm0 30 | leaq .LC2(%rip), %rdi 31 | movl $1, %eax 32 | call printf@PLT 33 | movl $0, %eax 34 | leave 35 | .cfi_def_cfa 7, 8 36 | ret 37 | .cfi_endproc 38 | .LFE0: 39 | .size main, .-main 40 | .section .rodata 41 | .align 8 42 | .LC0: 43 | .long 0 44 | .long 1073741824 45 | .align 8 46 | .LC1: 47 | .long 0 48 | .long 1074266112 49 | .ident "GCC: (Debian 6.3.0-18+deb9u1) 6.3.0 20170516" 50 | .section .note.GNU-stack,"",@progbits 51 | -------------------------------------------------------------------------------- /test/incrementeel.lua: -------------------------------------------------------------------------------- 1 | require 'util' 2 | 3 | local files = io.popen('ls -v test/ex') 4 | 5 | local function assert(cond, msg) 6 | if not cond then 7 | print(msg) 8 | end 9 | end 10 | 11 | 12 | opt = {['0'] = true} 13 | for pad in files:lines() do 14 | local moetzijn = pad:match('[^.]*') 15 | local moetzijn = tonumber(moetzijn) 16 | io.write(moetzijn, '\n') 17 | local code = file('test/ex/'..pad) 18 | local icode = compile(code) 19 | local ok, is = pcall(doe, icode) 20 | assert(ok, is) 21 | if ok then 22 | local is = lenc(is) 23 | local moetzijn = lenc(moetzijn) 24 | assert(is == moetzijn, 'waarde was '..is..' maar hasht '..moetzijn..' zijn') 25 | end 26 | end 27 | 28 | opt = {['0'] = false} 29 | for pad in files:lines() do 30 | local moetzijn = pad:match('[^.]*') 31 | local moetzijn = tonumber(moetzijn) 32 | print(moetzijn) 33 | local code = file('test/ex/'..pad) 34 | local icode = compile(code) 35 | local is = doe(icode) 36 | assert(lenc(is) == lenc(moetzijn), '(geoptimaliseerd) waarde was '..is..' maar hasht '..moetzijn..' zijn') 37 | end 38 | -------------------------------------------------------------------------------- /ex/screensaver.code: -------------------------------------------------------------------------------- 1 | ; twee grafieken 2 | 3 | als toets.spatie dan 4 | looptijd := 0 5 | eind 6 | 7 | f = c → 50 + 10 · tan(c³) · sin(c²/10+looptijd) 8 | g = d → 20 + 10·sin(d/2+looptijd) + 10·sin(d/4+√looptijd) + 10·sin((d+looptijd)/5) 9 | h = e → 50 + 2·(20·sin(e/20)) mod (10·sin(looptijd)); + 30 · sin(e²-3+1.1^looptijd) 10 | i = E → 80 + 10 · atan(E,E²/2) · 20 + 2·sin(E/10·looptijd) + 3·cos(E/15); + klem(10·sin(E/10·looptijd),0,10) 11 | j = F → 50; + 20 · sin F/8 + 10 · sin (F/17) + (looptijd·F) mod 10 12 | 13 | x = 0..200 14 | y1 = x map f 15 | y2 = x map g 16 | y3 = x map h 17 | y4 = x map i 18 | y5 = x map j 19 | 20 | punten1 = x zip y1 21 | punten2 = x zip y2 22 | punten3 = x zip y3 23 | punten4 = x zip y4 24 | punten5 = x zip y5 25 | grafiek1 = verf(polygoon(punten1), kleur.rood) 26 | grafiek2 = verf(polygoon([(0,0)] ‖ punten2 ‖ [(scherm.breedte,0)]), kleur.groen) 27 | grafiek3 = verf(polygoon(punten3), kleur.cyaan) 28 | grafiek4 = verf(polygoon([(0,100)] ‖ punten4 ‖ [(scherm.breedte,100)]), kleur.geel) 29 | grafiek5 = verf(lijn(punten5), rgb(1,looptijd mod 1,1)) 30 | 31 | uit = teken [grafiek1, grafiek2, grafiek3, grafiek4, grafiek5] 32 | 33 | -------------------------------------------------------------------------------- /ex/buis.code: -------------------------------------------------------------------------------- 1 | ; 3D Buis 2 | 3 | ; loop met pijltjes en WASD 4 | veld2 = -2..3 × -2..3 × -2..3 × [1] 5 | veld = veld2 map ((((A,B),C),D) → (X,Y,Z,1)) 6 | X = cos ((A/5+B/25)·τ+looptijd) 7 | Y = sin ((A/5+B/25)·τ+looptijd) 8 | Z = C/2 9 | 10 | l = looptijd / 100 11 | 12 | ; camera 13 | x := 0 14 | y := 0 15 | z := 0 16 | 17 | als toets.w dan z := z + .1 eind 18 | als toets.s dan z := z - .1 eind 19 | als toets.d dan x := x - .1 eind 20 | als toets.a dan x := x + .1 eind 21 | als toets.omhoog dan y := y - .1 eind 22 | als toets.omlaag dan y := y + .1 eind 23 | 24 | ; viewport 25 | rechts = [10·cos x,0,10·sin x,0] 26 | boven = [0,10,0,0] 27 | rechtdoor = [10·sin x,0,10·-cos x,0] 28 | pos = [90,55+y,-z·20+muis.x,50,1] 29 | 30 | matrix = (rechts, boven, rechtdoor, pos) 31 | 32 | K = 20/pz-10 33 | k = rgb(K/w₀,K/w₁,K/w₂) 34 | h = matrix mat4.vmul w 35 | 36 | transformeer = w → h 37 | plot = px,py,pz·(muis.x-10),pw → verf(cirkel( ((px-90)/pz+90,(py-50)/pz+50), max(0,3/pz)), k) 38 | 39 | 40 | punten = veld map transformeer 41 | gesorteerd = punten sorteer ggg 42 | ggg = fa,fb → fa₂ < fb₂ 43 | 44 | ; util 45 | uit = teken (gesorteerd map plot) 46 | 47 | 48 | -------------------------------------------------------------------------------- /ex/kubus.code: -------------------------------------------------------------------------------- 1 | points = [50,80] × [50,80] × [50,80] 2 | punten2 = points map (((x,y),z) → (x,y,z,1)) 3 | 4 | camx = mouse.x/10 5 | camy = mouse.y/10 6 | camz := 0 7 | ;if screen.refreshes and key.a then camx := camx - 1 end 8 | ;if screen.refreshes and key.d then camx := camx + 1 end 9 | if screen.refreshes and key.w then camz := camz - .1 end 10 | if screen.refreshes and key.s then camz := camz + .1 end 11 | mat = verplaats(camx,camy,camz) 12 | 13 | hw = screen.width / 2 14 | toscreen = X,Y,Z,V → (X-hw)/(Z/100)+hw, (Y-50)/(Z/100)+50 15 | 16 | punten3 = punten2 map (punt → toscreen(mat mat4.vmul punt)) 17 | 18 | ;indices = [[0,1,3,2],[0,4,5,1],[0,2,6,4]] 19 | poly1 = paint(line([0,1,3,2,0] map punten3), color.yellow) 20 | poly2 = paint(line([0,4,5,1,0] map punten3), color.blue) 21 | poly3 = paint(line([0,2,6,4,0] map punten3), color.green) 22 | poly4 = paint(line(([0,1,3,2]+4) map punten3), color.red) 23 | poly5 = paint(line(([0,4,5,1]+2) map punten3), color.purple) 24 | poly6 = paint(line(([0,2,6,4]+1) map punten3), color.cyaan) 25 | polys = [poly1,poly2,poly3,poly4,poly5,poly6] 26 | out = draw(polys) 27 | 28 | frame := 0 29 | if screen.refreshes then 30 | frame := frame + 1 31 | end 32 | -------------------------------------------------------------------------------- /parse/Makefile: -------------------------------------------------------------------------------- 1 | linux: parse.so 2 | 3 | parse.so: lua.c .lex.yy.h .lex.yy.c .lang.yy.h .lang.yy.c 4 | mkdir -p bin 5 | gcc -g -Wall -Wno-unused -std=c11 -shared -I/usr/include/lua5.1 -o bin/parse.so -fPIC lua.c .lang.yy.c .lex.yy.c -Wno-multichar 6 | ln -sf bin/parse.so . 7 | 8 | test: test.c lua.c .lang.yy.h .lang.yy.c .lex.yy.h .lex.yy.c 9 | mkdir -p bin 10 | gcc -g -o bin/test -std=c11 -I/usr/include/lua5.1 -fPIC .lang.yy.c .lex.yy.c test.c lua.c -lm -llua5.1 11 | bin/test 12 | 13 | windows: main.c lang.yy.c lua.c 14 | mkdir -p bin 15 | gcc -std=c99 -O2 -ggdb -fPIC -shared -I/usr/include/lua5.1 -o bin/parse.dll main.c .lang.yy.c lua.c -llua test.c .lex.yy.c 16 | 17 | wintest: main.c .lang.yy.c 18 | gcc -std=c99 -ggdb -o bin/test main.c .lang.yy.c .lex.yy.c test.c -lm --lua5.1 19 | 20 | .lex.yy.h .lex.yy.c: lex.l 21 | flex --header-file=.lex.yy.h --outfile=.lex.yy.c lex.l 22 | 23 | .lang.yy.h .lang.yy.c: lang.y 24 | bison --report=all -d -t --locations --defines=.lang.yy.h --output=.lang.yy.c lang.y 25 | 26 | bin/parse: .lang.yy.c 27 | gcc -ggdb -o bin/parse .lang.yy.c .lex.yy.c -lm -llua 28 | 29 | clean: 30 | rm -f .lang.yy.h .lex.yy.h .lang.yy.c .lex.yy.c parse.so parse 31 | -------------------------------------------------------------------------------- /asm/fib.s: -------------------------------------------------------------------------------- 1 | .file "fib.c" 2 | .intel_syntax noprefix 3 | .text 4 | .globl fib 5 | .type fib, @function 6 | fib: 7 | .LFB0: 8 | push rbp 9 | mov rbp, rsp 10 | push rbx 11 | sub rsp, 24 12 | mov QWORD PTR -24[rbp], rdi 13 | cmp QWORD PTR -24[rbp], 0 14 | je .L2 15 | cmp QWORD PTR -24[rbp], 1 16 | jne .L3 17 | .L2: 18 | mov rax, QWORD PTR -24[rbp] 19 | jmp .L4 20 | .L3: 21 | mov rax, QWORD PTR -24[rbp] 22 | sub rax, 1 23 | mov rdi, rax 24 | call fib 25 | mov rbx, rax 26 | mov rax, QWORD PTR -24[rbp] 27 | sub rax, 2 28 | mov rdi, rax 29 | call fib 30 | add rax, rbx 31 | .L4: 32 | add rsp, 24 33 | pop rbx 34 | pop rbp 35 | ret 36 | .LFE0: 37 | .size fib, .-fib 38 | .section .rodata 39 | .LC0: 40 | .string "fib(10) = %d\n" 41 | .text 42 | .globl main 43 | .type main, @function 44 | main: 45 | .LFB1: 46 | push rbp 47 | mov rbp, rsp 48 | sub rsp, 16 49 | mov QWORD PTR -8[rbp], 10 50 | mov rax, QWORD PTR -8[rbp] 51 | mov rdi, rax 52 | call fib 53 | mov QWORD PTR -16[rbp], rax 54 | mov rax, QWORD PTR -16[rbp] 55 | mov rsi, rax 56 | lea rdi, .LC0[rip] 57 | mov eax, 0 58 | call printf@PLT 59 | mov eax, 0 60 | leave 61 | ret 62 | .LFE1: 63 | .size main, .-main 64 | .ident "GCC: (Debian 8.3.0-6) 8.3.0" 65 | .section .note.GNU-stack,"",@progbits 66 | -------------------------------------------------------------------------------- /ex/set.lua: -------------------------------------------------------------------------------- 1 | function set(...) 2 | local list = {...} 3 | local s = {} 4 | for i,v in ipairs(list) do 5 | s[v] = true 6 | end 7 | setmetatable(s, { 8 | __call = function(s,x) return s[x] end; 9 | __tostring = function(s) 10 | local t = { '{' } 11 | for val in spairs(s) do 12 | t[#t+1] = tostring(val) 13 | t[#t+1] = ',' 14 | end 15 | if t[#t] == ',' then 16 | t[#t] = nil 17 | end 18 | t[#t+1] = '}' 19 | return table.concat(t) 20 | end; 21 | }) 22 | return s 23 | end 24 | 25 | function verschil(a,b) 26 | local s = set() 27 | for k,v in pairs(a) do 28 | if not b[k] then 29 | s[k] = val 30 | end 31 | end 32 | return s 33 | end 34 | 35 | function unie(...) 36 | local t = {...} 37 | if #t == 1 then t = t[1] end 38 | local r = set() 39 | for i,set in ipairs(t) do 40 | for v in pairs(set) do 41 | r[v] = true 42 | end 43 | end 44 | return r 45 | end 46 | 47 | function complement(a, b) 48 | local s = {} 49 | for v in pairs(a) do 50 | if not b[v] then 51 | s[v] = true 52 | end 53 | end 54 | return s 55 | end 56 | 57 | function cat(...) 58 | local tt = {...} 59 | local r = {} 60 | for i,t in ipairs(tt) do 61 | log(t) 62 | for i,v in ipairs(t) do 63 | r[#r+1] = v 64 | end 65 | end 66 | return r 67 | end 68 | 69 | -------------------------------------------------------------------------------- /set.lua: -------------------------------------------------------------------------------- 1 | function set(...) 2 | local list = {...} 3 | local s = {} 4 | for i,v in ipairs(list) do 5 | s[v] = true 6 | end 7 | setmetatable(s, { 8 | __call = function(s,x) return s[x] end; 9 | __tostring = function(s) 10 | local t = { '{' } 11 | for val in spairs(s) do 12 | t[#t+1] = tostring(val) 13 | t[#t+1] = ',' 14 | end 15 | if t[#t] == ',' then 16 | t[#t] = nil 17 | end 18 | t[#t+1] = '}' 19 | return table.concat(t) 20 | end; 21 | }) 22 | return s 23 | end 24 | 25 | function verschil(a,b) 26 | local s = set() 27 | for k,v in pairs(a) do 28 | if not b[k] then 29 | s[k] = val 30 | end 31 | end 32 | return s 33 | end 34 | 35 | function unie(...) 36 | local t = {...} 37 | if #t == 1 then t = t[1] end 38 | local r = set() 39 | for i,set in ipairs(t) do 40 | for v in pairs(set) do 41 | r[v] = true 42 | end 43 | end 44 | return r 45 | end 46 | 47 | function complement(a, b) 48 | local s = {} 49 | for v in pairs(a) do 50 | if not b[v] then 51 | s[v] = true 52 | end 53 | end 54 | return s 55 | end 56 | 57 | function cat(...) 58 | local tt = {...} 59 | local r = {} 60 | for i,t in ipairs(tt) do 61 | log(t) 62 | for i,v in ipairs(t) do 63 | r[#r+1] = v 64 | end 65 | end 66 | return r 67 | end 68 | 69 | -------------------------------------------------------------------------------- /parse/set.lua: -------------------------------------------------------------------------------- 1 | function set(...) 2 | local list = {...} 3 | local s = {} 4 | for i,v in ipairs(list) do 5 | s[v] = true 6 | end 7 | setmetatable(s, { 8 | __call = function(s,x) return s[x] end; 9 | __tostring = function(s) 10 | local t = { '{' } 11 | for val in spairs(s) do 12 | t[#t+1] = tostring(val) 13 | t[#t+1] = ',' 14 | end 15 | if t[#t] == ',' then 16 | t[#t] = nil 17 | end 18 | t[#t+1] = '}' 19 | return table.concat(t) 20 | end; 21 | }) 22 | return s 23 | end 24 | 25 | function verschil(a,b) 26 | local s = set() 27 | for k,v in pairs(a) do 28 | if not b[k] then 29 | s[k] = val 30 | end 31 | end 32 | return s 33 | end 34 | 35 | function unie(...) 36 | local t = {...} 37 | if #t == 1 then t = t[1] end 38 | local r = set() 39 | for i,set in ipairs(t) do 40 | for v in pairs(set) do 41 | r[v] = true 42 | end 43 | end 44 | return r 45 | end 46 | 47 | function complement(a, b) 48 | local s = {} 49 | for v in pairs(a) do 50 | if not b[v] then 51 | s[v] = true 52 | end 53 | end 54 | return s 55 | end 56 | 57 | function cat(...) 58 | local tt = {...} 59 | local r = {} 60 | for i,t in ipairs(tt) do 61 | log(t) 62 | for i,v in ipairs(t) do 63 | r[#r+1] = v 64 | end 65 | end 66 | return r 67 | end 68 | 69 | -------------------------------------------------------------------------------- /ex/3d.code: -------------------------------------------------------------------------------- 1 | ; 3d poging 999 2 | qpunten = [-20,20] × [-20,20] × [-20,20] × [1] 3 | tpunten = qpunten map (qpunt → mat · qpunt) 4 | spunten = tpunten map naarscherm 5 | gpunten = spunten 6 | 7 | naarscherm = tx,ty,tz,tw → (tx-80)/tw+80, (ty-50)/tw+50, tz 8 | 9 | als toets.links dan cam.hoek := cam.hoek - 0.03 eind 10 | als toets.rechts dan cam.hoek := cam.hoek + 0.03 eind 11 | 12 | v = verplaats(30,0,100) 13 | cam = ydraai(looptijd) · v 14 | 15 | ; matrix math 16 | z1 = (0.1+1000)/(1000-0.1) 17 | z2 = (2·0.1·1000)/(1000-0.1) 18 | proj = [[100,0,0,0],[0,100,0,0],[0,0,z1,-1],[0,0,z2,0]] 19 | a 20 | mat = cam · proj 21 | 22 | indices1 = [ [0,1,5,4], [0,4,6,2], [0,1,3,2] ] 23 | indices2 = [ indices1₀+2, indices1₁+1, indices1₂+4] 24 | indices = indices1 ‖ indices2 25 | pdata = indices map (is → is map gpunten) 26 | fdata = pdata filter zichtbaar 27 | zichtbaar = zp → (zc₂ > 0) 28 | za = (zp₃ - zp₀) 29 | zb = (zp₁ - zp₀) 30 | zc = cross(za, zb) 31 | kleuren = [kleur.rood, kleur.groen, kleur.blauw, kleur.geel, kleur.paars, kleur.cyaan] 32 | 33 | cross = (ax,ay,az),(bx,by,bz) → (ay·bz-az·by, az·bx - ax·bz, ax·by-ay·bx) 34 | 35 | polygonen = fdata map polygoon 36 | kpolygonen = polygonen zip kleuren map verf 37 | uit = teken (kpolygonen ‖ debug) 38 | 39 | debug = label(1,1,type(cross)) 40 | P = pdata₀ 41 | 42 | -------------------------------------------------------------------------------- /asm/magnitude.s: -------------------------------------------------------------------------------- 1 | .intel_syntax noprefix 2 | .globl main 3 | main: 4 | mov rdi, 1000000000000 #;your value here 5 | bsr rax, rdi 6 | movzx eax, BYTE PTR maxdigits[1+rax] 7 | cmp rdi, QWORD PTR powers[0+eax*8] 8 | sbb al, 0 9 | ret 10 | maxdigits: 11 | .byte 0 12 | .byte 0 13 | .byte 0 14 | .byte 0 15 | .byte 1 16 | .byte 1 17 | .byte 1 18 | .byte 2 19 | .byte 2 20 | .byte 2 21 | .byte 3 22 | .byte 3 23 | .byte 3 24 | .byte 3 25 | .byte 4 26 | .byte 4 27 | .byte 4 28 | .byte 5 29 | .byte 5 30 | .byte 5 31 | .byte 6 32 | .byte 6 33 | .byte 6 34 | .byte 6 35 | .byte 7 36 | .byte 7 37 | .byte 7 38 | .byte 8 39 | .byte 8 40 | .byte 8 41 | .byte 9 42 | .byte 9 43 | .byte 9 44 | .byte 9 45 | .byte 10 46 | .byte 10 47 | .byte 10 48 | .byte 11 49 | .byte 11 50 | .byte 11 51 | .byte 12 52 | powers: 53 | .quad 0 54 | .quad 10 55 | .quad 100 56 | .quad 1000 57 | .quad 10000 58 | .quad 100000 59 | .quad 1000000 60 | .quad 10000000 61 | .quad 100000000 62 | .quad 1000000000 63 | .quad 10000000000 64 | .quad 100000000000 65 | .quad 1000000000000 66 | -------------------------------------------------------------------------------- /ex/muziek.code: -------------------------------------------------------------------------------- 1 | ss = 8.4 2 | stamafb = afbeelding(stam, (23, 40), ss, ss·3) 3 | 4 | achtergrond = rechthoek(0,0,200,100) verf kleur.wit 5 | 6 | stam = loadimage "stam.svg" 7 | 8 | uit = teken ([achtergrond, stamafb] ‖ balken ‖ noten) 9 | 10 | basepos = 20,20 11 | bb = .3 12 | h = 3 13 | 14 | ; teken balk 15 | balken = (0..5) map balklijn 16 | balklijn = bh → balk 17 | balk = canvas.linewidth(balk0, bb) verf kleur.zwart 18 | balk0 = lijn[basepos+(0,bh·h),basepos+(100,bh·h)] 19 | noten = plet (muziek map noot) 20 | 21 | muziek = [(0,dy),(0,dy+2),(0,dy+5),(1,1),(2,2),(3,4),(4,2),(5,1),(int(muis.x/10),int(muis.y/10))] 22 | 23 | 24 | dy := 0 25 | als toets.omhoog.begin dan 26 | dy := dy + 1 27 | eind 28 | als toets.omlaag.begin dan 29 | dy := dy - 1 30 | eind 31 | 32 | ; teken noot 33 | noot = nootx,nooty → [ ovaal(nootpos₀,nootpos₁,2,3/2,5.8) verf kleur.zwart, nootlijn ] ‖ lagebalken ‖ hogebalken 34 | nootpos = basepos + (10·(2+nootx),h·(nooty-2)/2) 35 | lijnpos = nootpos + (3-1.4-lw,0) 36 | lw = (⇒)((nooty < 6), 0, 3.1) 37 | 38 | lvan = ⌈nooty/2⌉-1 39 | lnaar = ⌊nooty/2⌋ 40 | lagebalken = (lvan .. 0) map lagebalk 41 | hogebalken = (5 .. lnaar) map lagebalk 42 | lagebalk0 = lijn[nootpos0+(-3,lb·h), nootpos0+(3,lb·h)] 43 | nootpos0 = nootpos₀, basepos₁ 44 | lagebalk = lb → canvas.linewidth(lagebalk0,bb) verf kleur.zwart 45 | nootlijn = canvas.linewidth(nootlijn0, 0.6) verf kleur.zwart 46 | nootlijn0 = lijn[lijnpos,lijnpos+(0,lh)] 47 | lh = (⇒)((nooty < 6), h·3.5, -h·3.5) 48 | -------------------------------------------------------------------------------- /test/optimiseer.lua: -------------------------------------------------------------------------------- 1 | require 'compile' 2 | require 'build.codegen' 3 | require 'doe' 4 | require 'optimise' 5 | require 'deparse' require 'parse' 6 | require 'util' 7 | 8 | opt = {['0'] = false} 9 | 10 | local function T(x) 11 | local code,err = compile("main = "..x) 12 | for i,msg in ipairs(err) do 13 | print(fout2ansi(msg)) 14 | end 15 | return doe(code) 16 | end 17 | 18 | -- LINQ 19 | local a = T "Σ 0..10" 20 | assert(a == 45) 21 | 22 | local a = T "Σ (0..10) filter (x → (x mod 2 = 0))" 23 | assert(a == 20, a) 24 | 25 | local a = T "Σ (0..10) map (-)" 26 | assert(a == -45) 27 | 28 | local a = T "Σ (0..10 × 0..10) map (·)" 29 | assert(a == 2025, a) 30 | 31 | local a = T "Σ 3..6" 32 | assert(a == 12, a) 33 | 34 | local a = T "Σ (0..10) map (√)" 35 | assert(math.floor(a) == 19, a) 36 | 37 | 38 | local a = T "1 + 2" 39 | assert(a == 3, a) 40 | 41 | local a = T "1 - 2 + 3" 42 | assert(a == 2, a) 43 | 44 | local a = T "3 · 2 + 8" 45 | assert(a == 14, a) 46 | 47 | local a = T "√ 9" 48 | assert(a == 3, a) 49 | 50 | local a = T "(((1 + 1) + 1) + 1)" 51 | assert(a == 4, a) 52 | 53 | local a = T "2 + 3" 54 | assert(a == 5, a) 55 | 56 | local a = T "max(2,1)" 57 | assert(a == 2, a) 58 | 59 | local a = T "(1 + 1) + (1 + 1)" 60 | assert(a == 4, a) 61 | 62 | local a = T "((1 + 1) + 1)" 63 | assert(a == 3, a) 64 | 65 | local a = T "((((1 + 1) + 1) + 1) + 1)" 66 | assert(a == 5, a) 67 | 68 | local a = T "1 + 1 + 1 + 1" 69 | assert(a == 4, a) 70 | 71 | print('alles ok') 72 | -------------------------------------------------------------------------------- /hoi.lua: -------------------------------------------------------------------------------- 1 | local sdl = require 'sdl2' 2 | local ffi = require 'ffi' 3 | local C = ffi.C 4 | 5 | sdl.init(sdl.INIT_VIDEO) 6 | 7 | require 'util' 8 | for k in spairs(sdl) do 9 | --print(k) 10 | end 11 | --do return end 12 | 13 | local window = sdl.createWindow("Taal", 14 | sdl.WINDOWPOS_CENTERED, 15 | sdl.WINDOWPOS_CENTERED, 16 | 1280, 17 | 720, 18 | sdl.WINDOW_SHOWN + sdl.WINDOW_RESIZABLE) 19 | 20 | local windowsurface = sdl.getWindowSurface(window) 21 | 22 | 23 | local rect = ffi.new('SDL_Rect', -100, 0, 100, 100) 24 | local renderer = sdl.createRenderer(window, -1, sdl.RENDERER_ACCELERATED + sdl.RENDERER_PRESENTVSYNC) 25 | sdl.setRenderDrawColor(renderer, 255, 255, 0, 0) 26 | 27 | --local image = sdl.loadBMP("lena.bmp") 28 | --sdl.upperBlit(image, nil, windowsurface, nil) 29 | --sdl.updateWindowSurface(window) 30 | --sdl.freeSurface(image) 31 | 32 | local running = true 33 | local event = ffi.new('SDL_Event') 34 | while running do 35 | while sdl.pollEvent(event) ~= 0 do 36 | if event.type == sdl.QUIT then 37 | running = false 38 | end 39 | end 40 | 41 | sdl.renderFillRect(renderer, rect) 42 | if rect.x > 1280 then 43 | rect.x = -100 44 | rect.y = rect.y + 100 45 | else 46 | rect.x = rect.x + 10 47 | end 48 | sdl.renderPresent(renderer) 49 | 50 | end 51 | 52 | sdl.destroyWindow(window) 53 | sdl.quit() 54 | -------------------------------------------------------------------------------- /test/luagen.lua: -------------------------------------------------------------------------------- 1 | require 'build.gen.lua' 2 | require 'parse' 3 | 4 | function imparse(imcode) 5 | local im = X'[]' 6 | for line in imcode:gmatch('([^\n]+)') do 7 | local a, b = line:match('(%S+)%s+(%S+)') 8 | if a and b then 9 | im[#im+1] = X(a, b) 10 | else 11 | local a = line:match('(%S+)') 12 | im[#im+1] = X(a) 13 | end 14 | end 15 | return im 16 | end 17 | 18 | 19 | function verwacht(im, val) 20 | local lua = luagen(im) 21 | 22 | local func, err = loadstring(lua) 23 | assert(not err, tostring(err) .. '\n' .. lua) 24 | 25 | local ok,res = pcall(func) 26 | assert(ok, tostring(res) .. '\n' .. lua) 27 | 28 | if res ~= val then 29 | print(string.format('moet %s zijn maar was %s', lenc(val), lenc(res))) 30 | print('Im:') 31 | for i,ins in ipairs(im) do 32 | print(deparse(ins)) 33 | end 34 | print('Lua:') 35 | print(lua) 36 | end 37 | end 38 | 39 | 40 | -- (- 1) 41 | local a = imparse [[ 42 | push 1 43 | - 44 | ]] 45 | verwacht(a, -1) 46 | 47 | 48 | -- 1 + 2 49 | local a = imparse [[ 50 | push 1 51 | push 2 52 | + 53 | ]] 54 | verwacht(a, 3) 55 | 56 | 57 | -- 1 · 2 + 3 58 | local a = imparse [[ 59 | push 1 60 | push 2 61 | + 62 | push 3 63 | · 64 | ]] 65 | verwacht(a, 9) 66 | 67 | 68 | -- ((-) ∘ (-))(1) = 1 69 | local a = imparse [[ 70 | push - 71 | push - 72 | ∘ 73 | push 1 74 | _f 75 | ]] 76 | verwacht(a, 1) 77 | 78 | 79 | -- ((-) ∘ (-))(1) = 1 80 | local a = imparse [[ 81 | push fn.id 82 | push 1 83 | _f 84 | ]] 85 | verwacht(a, 1) 86 | 87 | -------------------------------------------------------------------------------- /test/ontleed.lua: -------------------------------------------------------------------------------- 1 | require 'parse' 2 | require 'util' 3 | 4 | function unlisp(x) 5 | local t = {} 6 | if not x then return '' end 7 | local function U(y) 8 | 9 | if type(y) ~= 'table' then 10 | t[#t+1] = '? ' 11 | y = nil 12 | end 13 | 14 | if isatom(y) then 15 | t[#t+1] = atom(y) 16 | end 17 | 18 | -- obj 19 | if isobj(y) then 20 | if obj(y) ~= ',' then 21 | t[#t+1] = obj(y) 22 | t[#t+1] = '(' 23 | end 24 | for i,v in ipairs(y) do 25 | if i > 1 then 26 | t[#t+1] = ' ' 27 | end 28 | U(v) 29 | end 30 | if obj(y) ~= ',' then 31 | t[#t+1] = ')' 32 | end 33 | end 34 | 35 | -- fn 36 | if isfn(y) then 37 | t[#t+1] = fn(y) 38 | t[#t+1] = '(' 39 | U(arg(y)) 40 | t[#t+1] = ')' 41 | end 42 | end 43 | 44 | U(x) 45 | 46 | return table.concat(t) 47 | end 48 | 49 | local totaal,goed = 0,0 50 | local function passert(ok, msg) 51 | totaal = totaal + 1 52 | if not ok then 53 | --print('ASSERT FAILED: ' .. msg) 54 | else 55 | goed = goed + 1 56 | end 57 | end 58 | 59 | local tests = file('test/parse.lst') 60 | for code in tests:gmatch('(.-)\n\n') do 61 | local taal,moet = code:match('(.*)\n([^n]-)$') 62 | if taal and moet then 63 | --print() 64 | --print(taal, moet) 65 | local lisp = unlisp(parseexp(taal)) 66 | passert(lisp == moet, string.format('parse("%s") moet %s zijn maar is %s', taal, moet, lisp)) 67 | end 68 | end 69 | 70 | print(string.format('%d/%d goed (%.2d%%)', goed, totaal, goed/totaal*100)) 71 | -------------------------------------------------------------------------------- /ex/bencode.code: -------------------------------------------------------------------------------- 1 | ;tor = "d3:hoii123e3:abcli1ei2ei3eee" 2 | tor = download "debian10.torrent" 3 | 4 | LIJST = 1 5 | DICT = 2 6 | 7 | isnaam := nee 8 | stack := [] 9 | i := 0 10 | dec := " " 11 | slen := 0 12 | klaar := nee 13 | 14 | als i > 0 en i ≥ #tor dan 15 | klaar := ja 16 | eind 17 | als tor(i) = 'd' dan 18 | i := i + 1 19 | dec := dec ‖ "{" 20 | stack := stack ‖ [DICT] 21 | isnaam := ja 22 | eind 23 | als dec ⇒ tor(i) = 'l' dan 24 | i := i + 1 25 | dec := dec ‖ "[" 26 | stack := stack ‖ [LIJST] 27 | eind 28 | als tor(i) = 'i' dan 29 | i := vind(tor,"e",i)+1 30 | dec := dec ‖ deel(tor,i+1,vind(tor,"e",i)) ‖ "," 31 | isnaam := ja 32 | eind 33 | als '0' ≤ tor(i) en tor(i) ≤ '9' dan 34 | i := vind(tor,":",i) 35 | slen := int(deel(tor,i,vind(tor,":",i))) 36 | eind 37 | als dec ⇒ tor(i) = ':' dan 38 | i := i + slen + 1 39 | als isnaam dan 40 | isnaam := nee 41 | dec := dec ‖ jsonencode(deel(tor,i+1,i+slen+1)) ‖ ":" 42 | anders 43 | dec := dec ‖ jsonencode(deel(tor,i+1,i+slen+1)) ‖ "," 44 | isnaam := (stack(#stack-1) = DICT) 45 | eind 46 | eind 47 | als dec ⇒ tor(i) = 'e' dan 48 | i := i + 1 49 | stack := stack tot (#stack-1) 50 | als dec ⇒ stack(#stack-1) = DICT dan 51 | dec := dec ‖ "}," 52 | anders 53 | dec := dec ‖ "]," 54 | eind 55 | eind 56 | 57 | torobj := 3 58 | als klaar dan 59 | torobj := jsondecodeer("[]") 60 | eind 61 | 62 | ;uit = klaar,i,dec,tor(0),(tor(0) = 'd') 63 | ;uit = klaar,i,dec 64 | uit = klaar,i,#tor, ((i > 0 en i ≥ #tor) ⇒ jsondecodeer(dec ‖ "")) 65 | 66 | 67 | 68 | 69 | 70 | 71 | -------------------------------------------------------------------------------- /mmap.lua: -------------------------------------------------------------------------------- 1 | local meta = {} 2 | 3 | function meta:__newindex(index,waarde) 4 | local s = self.s 5 | if waarde == nil then 6 | if s[index] then 7 | s[index][waarde] = false 8 | if next(s[index]) == nil then 9 | s[index] = nil 10 | end 11 | end 12 | else 13 | s[index] = s[index] or {} 14 | s[index][waarde] = true 15 | end 16 | end 17 | 18 | function meta:__index(index) 19 | return self.s[index] or {} 20 | end 21 | 22 | function meta:__pairs() 23 | 24 | -- Iterator function takes the table 25 | -- and an index and returns the next index and associated value 26 | -- or nil to end iteration 27 | 28 | -- tabel, index 29 | --local t,tk 30 | 31 | -- mk: {k, v}: sleutel, set van waarden, waarde 32 | local v = nil 33 | 34 | local function stateless_iter(self, k) 35 | local self = self.s 36 | if k == nil then 37 | local s 38 | k,s = next(self) 39 | if k then 40 | assert(next(s)) 41 | v = next(s) 42 | return k, v 43 | else 44 | return nil 45 | end 46 | else 47 | v = next(self[k], v) 48 | 49 | -- nieuwe key 50 | if not v then 51 | local s 52 | k,s = next(self, k) 53 | if k then 54 | assert(next(s)) 55 | v = next(s) 56 | return k, v 57 | else 58 | return nil 59 | end 60 | end 61 | 62 | return k,v 63 | end 64 | end 65 | 66 | -- Return an iterator function, the table, starting point 67 | return stateless_iter, self, nil 68 | end 69 | 70 | function mmap() 71 | local t = {s = {}} 72 | setmetatable(t, meta) 73 | return t 74 | end 75 | -------------------------------------------------------------------------------- /ex/demo.code: -------------------------------------------------------------------------------- 1 | ; demo 2 | fase = ⌊ looptijd·2 ⌋ 3 | fasetijd = (looptijd·2) mod 1 4 | ;fase = ⌊ muis.x / 100 · 5 ⌋ 5 | ;fasetijd = (muis.x / 100 · 5) mod 1 6 | 7 | als fase = 0 dan 8 | uit = teken [ vierkant(0,0,9) ] 9 | eind 10 | 11 | x1 = 0..(fasetijd·18)·10 12 | 13 | als fase = 1 dan 14 | uit = teken ( (x1 × [0] × [9]) map vierkant) 15 | eind 16 | 17 | x2 = 0..18·10 18 | y2 = 10·(0..(fasetijd·10)) 19 | 20 | als fase = 2 dan 21 | uit = teken ( (x2 × y2 × [9]) map vierkant) 22 | eind 23 | 24 | y3 = 0..10·10 25 | 26 | als fase = 3 dan 27 | uit = teken ( (x2 × y3 × [9]) map vierkant) 28 | eind 29 | 30 | ;als fase ≥ 5 dan 31 | ;uit = teken ( (x2 × y3 × [9]) filter isaan map vierkant) 32 | ;eind 33 | 34 | 35 | ; wegschalen 36 | uitschaal = (x,y),z → [x,y,z] · (1 - fasetijd · 0.9) 37 | als fase = 4 dan 38 | uit = teken ( (x2 × y3 × [9+fasetijd]) map uitschaal map vierkant) 39 | eind 40 | 41 | dx = ix - 80 42 | dy = iy - 50 43 | dst = (dx²+dy²)/4 44 | isaan = (ix,iy),iz → ((fasetijd·100 - dst + 3000) mod 50) < 10 / fasetijd 45 | 46 | 47 | ; klein infaden 48 | als fase = 5 dan 49 | uit = teken ( (0..18 × 0..10 × [1.1]) filter isaan map vierkant) 50 | eind 51 | 52 | dx1 = ix1 - 80 53 | dy1 = iy1 - 50 54 | dst1 = (dx1²+dy1²)/4 55 | isaan2 = (ix1,iy1),iz1 → ((fasetijd·100 - dst1 + 3000) mod 50) < 10 56 | 57 | ; klein opschalen 58 | als fase = 6 dan 59 | uit = teken ( (0..(18+18·fasetijd·9) × 0..(10+10·fasetijd·10) × [1.1]) filter isaan2 map vierkant) 60 | eind 61 | 62 | ; klaar 63 | als fase ≥ 7 dan 64 | uit = teken ( (0..180 × 0..100 × [1.1]) filter isaan2 map vierkant) 65 | eind 66 | 67 | 68 | 69 | 70 | 71 | 72 | 73 | 74 | -------------------------------------------------------------------------------- /getopt.lua: -------------------------------------------------------------------------------- 1 | -- getopt, POSIX style command line argument parser 2 | -- param arg contains the command line arguments in a standard table. 3 | -- param options is a string with the letters that expect string values. 4 | -- returns a table where associated keys are true, nil, or a string value. 5 | -- The following example styles are supported 6 | -- -a one ==> opts["a"]=="one" 7 | -- -bone ==> opts["b"]=="one" 8 | -- -c ==> opts["c"]==true 9 | -- --c=one ==> opts["c"]=="one" 10 | -- -cdaone ==> opts["c"]==true opts["d"]==true opts["a"]=="one" 11 | -- note POSIX demands the parser ends at the first non option 12 | -- this behavior isn't implemented. 13 | 14 | function getopt( arg, options ) 15 | local tab,reg = {},{} 16 | for k, v in ipairs(arg) do 17 | if string.sub( v, 1, 2) == "--" then 18 | local x = string.find( v, "=", 1, true ) 19 | if x then tab[ string.sub( v, 3, x-1 ) ] = string.sub( v, x+1 ) 20 | else tab[ string.sub( v, 3 ) ] = true 21 | end 22 | elseif string.sub( v, 1, 1 ) == "-" then 23 | local y = 2 24 | local l = string.len(v) 25 | local jopt 26 | while ( y <= l ) do 27 | jopt = string.sub( v, y, y ) 28 | if string.find( options, jopt, 1, true ) then 29 | if y < l then 30 | tab[ jopt ] = string.sub( v, y+1 ) 31 | y = l 32 | else 33 | tab[ jopt ] = arg[ k + 1 ] 34 | end 35 | else 36 | tab[ jopt ] = true 37 | end 38 | y = y + 1 39 | end 40 | else 41 | reg[#reg+1] = v 42 | end 43 | end 44 | return tab,reg 45 | end 46 | -------------------------------------------------------------------------------- /parse/lua.h: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | #include "loc.h" 5 | 6 | // exp = atoom | fn | obj 7 | int xlua_istupel(lua_State* L, int ref); 8 | int xlua_isopen(lua_State* L, int ref); 9 | int xlua_sluit(lua_State* L, int ref); 10 | int xlua_append(lua_State* L, int aid, int bid, YYLTYPE loc); 11 | int xlua_appenda(lua_State* L, int aid, int bid, YYLTYPE loc); 12 | int xlua_metloc(lua_State* L, int aid, YYLTYPE loc); 13 | void xlua_pushloc(lua_State* L, YYLTYPE loc); 14 | int xlua_pushatoom(lua_State* L, char* text, YYLTYPE loc); 15 | int xlua_reftekst(lua_State* L, char* str, YYLTYPE loc); 16 | int xlua_reflijst(lua_State*L, int oid, int aid, YYLTYPE loc); 17 | int xlua_refatoom(lua_State* L, char* text, YYLTYPE loc); 18 | int xlua_refobj(lua_State* L, int fid, YYLTYPE loc); 19 | int xlua_refobj1(lua_State* L, int oid, int aid, YYLTYPE loc); 20 | int xlua_reffn0(lua_State* L, int fid, YYLTYPE loc); 21 | int xlua_reffn1(lua_State* L, int fid, int aid, YYLTYPE loc); 22 | int xlua_reffn2(lua_State* L, int fid, int aid, int bid, YYLTYPE loc); 23 | int xlua_reffn3(lua_State* L, int fid, int aid, int bid, int cid, YYLTYPE loc); 24 | int xlua_reffn4(lua_State* L, int fid, int aid, int bid, int cid, int did, YYLTYPE loc); 25 | int xlua_reffn5(lua_State* L, int fid, int aid, int bid, int cid, int did, int eid, YYLTYPE loc); 26 | int xlua_reftup2(lua_State* L, int fid, int aid, int bid, YYLTYPE loc); 27 | 28 | #define TN2 xlua_reftup2 29 | 30 | int lua_code(lua_State* L); 31 | int lua_ontleed(lua_State* L); 32 | //int yyerror(YYLTYPE* loc, lua_State* L, int* ref, void* scanner, const char* yymsg); 33 | int lua_ontleedexp(lua_State* L); 34 | 35 | /* 36 | #include 37 | #include ".taal.yy.h" 38 | #include ".lex.yy.h" 39 | #define LREG LUA_REGISTRYINDEX 40 | */ 41 | -------------------------------------------------------------------------------- /lib/geom.js.lst: -------------------------------------------------------------------------------- 1 | vierkant function(x,y,h) { 2 | return (function(c) { 3 | c.beginPath(); 4 | c.rect(x * 72, 720 - ((y+h) * 72) - 1, z * 72, z * 72); 5 | c.fillStyle = "white"; 6 | c.fill(); 7 | return c;}); 8 | }) 9 | rechthoek function(x,y,w,h) { 10 | return (function(c){ 11 | c.beginPath(); 12 | c.rect(x * 72, 720 - ((y+h) * 72) - 1, w * 72, h * 72); 13 | c.fillStyle = "white"; 14 | c.fill(); 15 | return c; 16 | }); 17 | } 18 | cirkel function(x,y,z) { 19 | return (function(c){ 20 | c.beginPath(); 21 | c.arc(x * 72, 720 - (y * 72) - 1, z * 72/2, 0, Math.PI * 2); 22 | c.fillStyle = "white"; 23 | c.fill(); 24 | return c; 25 | }); 26 | } 27 | label function(x,y,z) { 28 | return (function(c){ 29 | c.font = "48px Arial"; 30 | c.fillStyle = "white"; 31 | c.fillText(z, x * 72, 720 - (y * 72) - 1);return c; 32 | })(x,y; 33 | }) 34 | tekst function(x) { return Array.isArray(x) ? x.toSource() : x.toString(); } 35 | clearCanvas function(x) { return x.clearRect(0,0,1280,720) || x; } 36 | setInnerHtml function(a) { 37 | var t = Array.isArray($1) ? $1.toSource() : $1.toString(); 38 | if (html != t) { 39 | uit.innerHTML = t; 40 | html = t; 41 | } 42 | return uit.children[0]; 43 | } 44 | requestAnimationFrame (function f(t) { 45 | if (stop) {stop = false; uit.innerHTML = ''; return; } 46 | var r = t && t(); 47 | mouseLeftPressed = false; 48 | mouseLeftReleased = false; 49 | keySpacePressed = false; 50 | keySpaceReleased = false; 51 | requestAnimationFrame(f); 52 | return true; 53 | })() 54 | 55 | herhaal 56 | (function(f, x) { 57 | var a = x; 58 | while (1) { 59 | var b = f(a); 60 | if (b) { 61 | a = b; 62 | } else { 63 | break; 64 | } 65 | } 66 | return a; 67 | })($1, $2) 68 | getContext uit.children[0].getContext("2d")' 69 | consolelog console.log($1)' 70 | -------------------------------------------------------------------------------- /parse/test.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include "lua.h" 5 | 6 | void test() { 7 | lua_State* L = luaL_newstate(); 8 | luaL_openlibs(L); 9 | 10 | // push werkt? 11 | int top = lua_gettop(L); 12 | YYLTYPE loc; 13 | xlua_pushloc(L, loc); 14 | assert(lua_gettop(L) == top + 1); 15 | 16 | // atoom 17 | xlua_pushatoom(L, "hoi", loc); 18 | assert(lua_gettop(L) == top + 2); 19 | 20 | // ref atoom 21 | int atoom = xlua_refatoom(L, "hallo", loc); 22 | assert(lua_gettop(L) == top + 2); 23 | 24 | // met loc 25 | xlua_metloc(L, atoom, loc); 26 | assert(lua_gettop(L) == top + 2); 27 | } 28 | 29 | /* 30 | int xlua_append(lua_State* L, int aid, int bid, YYLTYPE loc); 31 | int xlua_metloc(lua_State* L, int aid, YYLTYPE loc); 32 | int xlua_pushatoom(lua_State* L, char* text, YYLTYPE loc); 33 | int xlua_reftekst(lua_State* L, char* str, YYLTYPE loc); 34 | int xlua_refatoom(lua_State* L, char* text, YYLTYPE loc); 35 | int xlua_reffn0(lua_State* L, int fid, YYLTYPE loc); 36 | int xlua_reffn1(lua_State* L, int fid, int aid, YYLTYPE loc); 37 | int xlua_reffn2(lua_State* L, int fid, int aid, int bid, YYLTYPE loc); 38 | int xlua_reffn3(lua_State* L, int fid, int aid, int bid, int cid, YYLTYPE loc); 39 | int xlua_reffn4(lua_State* L, int fid, int aid, int bid, int cid, int did, YYLTYPE loc); 40 | int xlua_reffn5(lua_State* L, int fid, int aid, int bid, int cid, int did, int eid, YYLTYPE loc); 41 | */ 42 | 43 | int main() { 44 | lua_State* L = luaL_newstate(); 45 | luaL_openlibs(L); 46 | char* str = " require 'parse'; require 'util' ; print('ontleden b') ; b = file('b.code') ; print(b); parse(b) ;print('hoi'); b = parse(file('../bieb/std.code')) ; print('ja!')"; 47 | //luaL_dostring(L, str); 48 | if (lua_gettop(L) > 0) { 49 | puts(luaL_checkstring(L, 1)); 50 | } 51 | 52 | test(); 53 | 54 | return 0; 55 | } 56 | 57 | -------------------------------------------------------------------------------- /asm/Makefile: -------------------------------------------------------------------------------- 1 | hoi: hoi.s 2 | as hoi.s -o hoi.o --no-pad-sections -R 3 | ld hoi.o -o hoi -n --build-id=none -static 4 | strip hoi 5 | 6 | dump: hoi 7 | objdump -D hoi -M intel 8 | 9 | mul: mul.s 10 | as mul.s -g -o mul.o --no-pad-sections -R 11 | ld mul.o -G -o mul -n --build-id=none -static 12 | 13 | hoi0.s: hoi0.c 14 | gcc hoi0.c -Os -S -fno-data-sections -nostartfiles -masm=intel 15 | 16 | hoi0: hoi0.s 17 | gcc hoi0.s -Os -Wl,-n -Wl,--build-id=none -Wa,--no-pad-sections -Wa,-R -static -nostartfiles -o hoi0 18 | strip hoi0 19 | objcopy --remove-section .comment hoi0 20 | objcopy --remove-section .tbss hoi0 21 | objcopy --remove-section .eh_frame hoi0 22 | 23 | double: double.c 24 | gcc -mno-sse2 -Wa,-adhln -nostdlib double.c -o double 25 | 26 | clean: 27 | rm *.o 28 | 29 | dump0: hoi0 30 | objdump -D hoi0 -M intel 31 | 32 | xcb: xcb.c 33 | gcc xcb.c -o xcb -lxcb -lc 34 | 35 | win64.exe: win64.s 36 | x86_64-w64-mingw32-gcc -Wl,-luser32 win64.s -Os -Wl,-n -Wl,--build-id=none -Wa,--no-pad-sections -Wa,-R -static -nostdlib -o win64.exe 37 | # x86_64-w64-mingw32-gcc -luser32 -nostdlib -nostartfiles win64.s -luser32 38 | #-Os -Wl,-n -Wl,--build-id=none -Wa,--no-pad-sections -Wa,-R -static -o win64.exe 39 | #x86_64-w64-mingw32-as --no-std-lib win64.s -o win64.o --no-pad-sections -R 40 | #x86_64-w64-mingw32-ld -l/usr/x86_64-w64-mingw32/lib/libuser32.a -luser32 -mwindows win64.o -o win64.exe -n --build-id=none -static -luser32 41 | 42 | win.exe: win.c 43 | gcc hoi0.s -Os -Wl,-n -Wl,--build-id=none -Wa,--no-pad-sections -Wa,-R -static -nostartfiles -o hoi0 44 | #x86_64-w64-mingw32-gcc -S -Os -Wl,-n -Wl,--build-id=none -Wa,--no-pad-sections -Wa,-R -static -nostdlib win.c -o win.exe -luser32 45 | 46 | #x86_64-w64-mingw32-as --no-std-lib win64.s -o win64.o --no-pad-sections -R 47 | #x86_64-w64-mingw32-ld -l/usr/x86_64-w64-mingw32/lib/libuser32.a -luser32 -mwindows win64.o -o win64.exe -n --build-id=none -static -luser32 48 | -------------------------------------------------------------------------------- /lib/x64.code: -------------------------------------------------------------------------------- 1 | byte: 0 .. 256 2 | float : getal 3 | int : getal 4 | 5 | (+): (getal,getal) → getal 6 | 7 | (+i) : (+) 8 | (+i) : (int,int) → int 9 | (+i) = asm.iadd 10 | (+f) : (+) 11 | (+f) : (float,float) → float 12 | (+f) = asm.fadd 13 | 14 | ;- 15 | (+) = addq 16 | addq : (intq, intq) → intq 17 | 18 | inet-adres (ip, poort) = 19 | af-inet || htons(poort) || htonl(ip) || intq(0) 20 | 21 | als udpuit ∋ (van, naar, data) dan 22 | van = udp-adres (0, 0) 23 | naar = kanaal-adres (deze-gastheer, 10101) 24 | 25 | als start dan 26 | k := sys.socket(af-inet, sock-dgram, 0) 27 | bk := sys.bind(k, van, #van) 28 | 29 | als bk.schrijfbaar dan 30 | sys.sendto(bk, h, #h, 0, pakket.naar, #pakket.naar) 31 | 32 | htons(intw) = ((intw bit-en 0xFF00) bit-schr 8) bit-of (intw bit-en 0x00FF) 33 | 34 | ; sys-errno 35 | sys-bind: (bd, sys-sockaddr, int) → int 36 | sys-write: (bd, data, int) → int 37 | sys-socket: (af, type, proto) → bd 38 | -; 39 | 40 | ; tijd 41 | starttijd := nu 42 | na(delta) = (looptijd > delta) 43 | 44 | ;std-uit = bestanden-uit 0 45 | ;uit = [ bestanden-uit ] 46 | uit = exitcode 47 | ;std-uit |= niets 48 | 49 | ;std-uit = bestanden-uit 0 50 | ;std-in = 1 51 | ;std-fout = 2 52 | 53 | ; bestanden 54 | ;open-lees: tekst → leesbaar-bestand 55 | ;open-schrijf: tekst → schrijfbaar-bestand 56 | 57 | ;lees-bestand: (leesbaar-bestand, data) → len 58 | ;schrijf-bestand: (leesbaar-bestand, data) → len 59 | 60 | ; netwerk 61 | ;udp (kanaal) 62 | 63 | ; netwerkconstanten 64 | af-unix = uintd 1 65 | af-inet = uintd 2 66 | af-inet6 = uintd 10 67 | 68 | sock-stream = uintd 1 69 | sock-dgram = uintd 2 70 | 71 | localhost = 16777343 72 | elk-adres = (0, 0) 73 | 74 | udp-plug: (van) → kanaal 75 | udp-kanaal: (van, naar) → gebonden-kanaal 76 | schrijf-naar: (kanaal, doel, data) → (kanaal, len) 77 | ;schrijf: (gebonden-kanaal, data) → (gebonden-kanaal, len) 78 | 79 | gastheer : uintq 80 | poort : uintd 81 | 82 | adres : (gastheer, poort) 83 | -------------------------------------------------------------------------------- /web/www/lib/slang.css: -------------------------------------------------------------------------------- 1 | .cm-s-slang.CodeMirror { background: #001; color: #fff; } 2 | .cm-s-slang div.CodeMirror-selected { background: #515151; } 3 | .cm-s-slang .CodeMirror-line::selection, .cm-s-slang .CodeMirror-line > span::selection, .cm-s-slang .CodeMirror-line > span > span::selection { background: rgba(56, 56, 56, 0.99); } 4 | .cm-s-slang .CodeMirror-line::-moz-selection, .cm-s-slang .CodeMirror-line > span::-moz-selection, .cm-s-slang .CodeMirror-line > span > span::-moz-selection { background: rgba(56, 56, 56, 0.99); } 5 | .cm-s-slang .CodeMirror-gutters { background: #555; border-right: 0px solid #314151; } 6 | .cm-s-slang .CodeMirror-guttermarker { color: #222; } 7 | .cm-s-slang .CodeMirror-guttermarker-subtle { color: azure; } 8 | .cm-s-slang .CodeMirror-linenumber { color: #FFFFFF; } 9 | .cm-s-slang .CodeMirror-cursor { border-left: 1px solid #00FF00; } 10 | .cm-s-slang .CodeMirror-activeline-background { background: #050010; } 11 | 12 | .cm-s-slang span.cm-keyword { color: #8ff; font-weight: bold; } 13 | .cm-s-slang span.cm-atom { color: cyan; } 14 | .cm-s-slang span.cm-number { color: #f88; } 15 | .cm-s-slang span.cm-def { color: #fffabc; } 16 | .cm-s-slang span.cm-punctuation { color: orange; } 17 | .cm-s-slang span.cm-variable { color: #cff; } 18 | .cm-s-slang span.cm-variable-2 { color: #cacbcc; } 19 | .cm-s-slang span.cm-variable-3 { color: #def; } 20 | .cm-s-slang span.cm-property { color: #fedcba; } 21 | .cm-s-slang span.cm-operator { color: #fc8; } 22 | .cm-s-slang span.cm-comment { color: #8f8; } 23 | .cm-s-slang span.cm-string { color: yellow; } 24 | .cm-s-slang span.cm-meta { color: #C9F; } 25 | .cm-s-slang span.cm-qualifier { color: purple; } 26 | .cm-s-slang span.cm-builtin { color: #8ab; /*#30aabc;*/ } 27 | .cm-s-slang span.cm-bracket { color: orange; } 28 | .cm-s-slang span.cm-tag { color: #FFDD44; } 29 | .cm-s-slang span.cm-attribute { color: #DDFF00; } 30 | .cm-s-slang span.cm-error { color: #FF0000; } 31 | .cm-s-slang span.cm-header { color: aquamarine; font-weight: bold; } 32 | .cm-s-slang span.cm-link { color: blueviolet; } 33 | -------------------------------------------------------------------------------- /unicode.lua: -------------------------------------------------------------------------------- 1 | function utf8encode(unicode) 2 | if unicode <= 0x7F then return string.char(unicode) end 3 | 4 | if (unicode <= 0x7FF) then 5 | local Byte0 = 0xC0 + math.floor(unicode / 0x40); 6 | local Byte1 = 0x80 + (unicode % 0x40); 7 | return string.char(Byte0, Byte1); 8 | end; 9 | 10 | if (unicode <= 0xFFFF) then 11 | local Byte0 = 0xE0 + math.floor(unicode / 0x1000); 12 | local Byte1 = 0x80 + (math.floor(unicode / 0x40) % 0x40); 13 | local Byte2 = 0x80 + (unicode % 0x40); 14 | return string.char(Byte0, Byte1, Byte2); 15 | end; 16 | 17 | if (unicode <= 0x10FFFF) then 18 | local code = unicode 19 | local Byte3= 0x80 + (code % 0x40); 20 | code = math.floor(code / 0x40) 21 | local Byte2= 0x80 + (code % 0x40); 22 | code = math.floor(code / 0x40) 23 | local Byte1= 0x80 + (code % 0x40); 24 | code = math.floor(code / 0x40) 25 | local Byte0= 0xF0 + code; 26 | 27 | return string.char(Byte0, Byte1, Byte2, Byte3); 28 | end; 29 | 30 | error 'unicode cannot be greater than U+10FFFF' 31 | end 32 | 33 | function utf8pairs(str) 34 | local i = 1 35 | local index = 1 36 | 37 | return function() 38 | 39 | local value 40 | local a, b, c, d = string.byte (str, index, index+3) 41 | a, b, c, d = a or 0, b or 0, c or 0, d or 0 42 | 43 | if a <= 0x7f then 44 | value = a 45 | len = 1 46 | elseif 0xc0 <= a and a <= 0xdf and b >= 0x80 then 47 | value = (a - 0xc0) * 0x40 + b - 0x80 48 | len = 2 49 | elseif 0xe0 <= a and a <= 0xef and b >= 0x80 and c >= 0x80 then 50 | value = ((a - 0xe0) * 0x40 + b - 0x80) * 0x40 + c - 0x80 51 | len = 3 52 | elseif 0xf0 <= a and a <= 0xf7 and b >= 0x80 and c >= 0x80 and d >= 0x80 then 53 | value = (((a - 0xf0) * 0x40 + b - 0x80) * 0x40 + c - 0x80) * 0x40 + d - 0x80 54 | len = 4 55 | else 56 | value = -1 57 | len = 1 58 | end 59 | 60 | --print('i', i, str:sub(i,i+len-1)) 61 | 62 | local previ = i 63 | local previndex = index 64 | i = i + 1 65 | index = index + len 66 | 67 | if previ > #str then 68 | previ = nil 69 | value = nil 70 | end 71 | 72 | return previ, value 73 | end 74 | end 75 | -------------------------------------------------------------------------------- /test/stress.lua: -------------------------------------------------------------------------------- 1 | package.path = package.path ..';../?.lua' 2 | require 'util' 3 | require 'exp' 4 | require 'deparse' 5 | require 'typify' 6 | require 'test.langecode' 7 | require 'build.codegen' 8 | 9 | -- 1 MB 10 | local code,numlijnen = langecode(124 * 1024 / 10) 11 | 12 | -- parse 13 | require 'parse' 14 | local socket = require 'socket' 15 | 16 | --------------------- ONTLEED 17 | -- ⋀([](...)) 18 | local voor = socket.gettime() 19 | local lang = parse(code) 20 | local na = socket.gettime() 21 | local dt = na - voor 22 | 23 | local snelheid = #code / 1000 / dt 24 | 25 | local leeslijnen = #lang.a 26 | print(string.format('%s lijnen (%.1f kB) parse in %d ms (%1.f klijnen/s, %.1f kB/s)', 27 | leeslijnen, #code/1000, dt*1000, leeslijnen/dt/1000, snelheid)) 28 | 29 | if numlijnen ~= leeslijnen then 30 | print('FOUT!', leeslijnen..' lijnen parse, maar moeten er '..numlijnen..' zijn') 31 | local feiten = lang.a 32 | print(deparse(feiten[#feiten])) 33 | end 34 | 35 | 36 | 37 | --------------------- TYPEER 38 | require 'typify' 39 | 40 | local voor = socket.gettime() 41 | local types,fouten = typify(lang) 42 | local na = socket.gettime() 43 | local dt = na - voor 44 | print(string.format('%s feiten getypifyd in %d ms (%.1f kfeit/s, %.1f kB/s)', leeslijnen, dt*1000, leeslijnen/dt/1000, #code/1000/dt)) 45 | for i = 1,math.min(#fouten, 10) do 46 | print(fout2ansi(fouten[i])) 47 | end 48 | 49 | do return end 50 | 51 | 52 | 53 | --------------------- OPLOS 54 | local voor = socket.gettime() 55 | local exp = solve(lang, "uit") 56 | local na = socket.gettime() 57 | local dt = na - voor 58 | print(string.format('%s feiten opgelost in %d ms (%.1f kfeit/s, %.1f kB/s)', leeslijnen, dt*1000, leeslijnen/dt/1000, #code/1000/dt)) 59 | for i = 1,math.min(#fouten, 10) do 60 | print(fout2ansi(fouten[i])) 61 | end 62 | 63 | 64 | 65 | 66 | 67 | --------------------- CODEGEN 68 | local voor = socket.gettime() 69 | local prog = codegen(exp) 70 | local na = socket.gettime() 71 | local dt = na - voor 72 | print(string.format('%s feiten opgelost in %d ms (%.1f kfeit/s, %.1f kB/s)', leeslijnen, dt*1000, leeslijnen/dt/1000, #code/1000/dt)) 73 | -------------------------------------------------------------------------------- /byte.lua: -------------------------------------------------------------------------------- 1 | function float2hex (n) 2 | if n == 0.0 then return 0.0 end 3 | 4 | local sign = 0 5 | if n < 0.0 then 6 | sign = 0x80 7 | n = -n 8 | end 9 | 10 | local mant, expo = math.frexp(n) 11 | local hext = {} 12 | 13 | if mant ~= mant then 14 | hext[#hext+1] = string.char(0xFF, 0x88, 0x00, 0x00) 15 | 16 | elseif mant == math.huge or expo > 0x80 then 17 | if sign == 0 then 18 | hext[#hext+1] = string.char(0x7F, 0x80, 0x00, 0x00) 19 | else 20 | hext[#hext+1] = string.char(0xFF, 0x80, 0x00, 0x00) 21 | end 22 | 23 | elseif (mant == 0.0 and expo == 0) or expo < -0x7E then 24 | hext[#hext+1] = string.char(sign, 0x00, 0x00, 0x00) 25 | 26 | else 27 | expo = expo + 0x7E 28 | mant = (mant * 2.0 - 1.0) * math.ldexp(0.5, 24) 29 | hext[#hext+1] = string.char(sign + math.floor(expo / 0x2), 30 | (expo % 0x2) * 0x80 + math.floor(mant / 0x10000), 31 | math.floor(mant / 0x100) % 0x100, 32 | mant % 0x100) 33 | end 34 | 35 | return tonumber(string.gsub(table.concat(hext),"(.)", 36 | function (c) return string.format("%02X%s",string.byte(c),"") end), 16) 37 | end 38 | 39 | 40 | function hex2float (c) 41 | if c == 0 then return 0.0 end 42 | local c = string.gsub(string.format("%X", c),"(..)",function (x) return string.char(tonumber(x, 16)) end) 43 | local b1,b2,b3,b4 = string.byte(c, 1, 4) 44 | local sign = b1 > 0x7F 45 | local expo = (b1 % 0x80) * 0x2 + math.floor(b2 / 0x80) 46 | local mant = ((b2 % 0x80) * 0x100 + b3) * 0x100 + b4 47 | 48 | if sign then 49 | sign = -1 50 | else 51 | sign = 1 52 | end 53 | 54 | local n 55 | 56 | if mant == 0 and expo == 0 then 57 | n = sign * 0.0 58 | elseif expo == 0xFF then 59 | if mant == 0 then 60 | n = sign * math.huge 61 | else 62 | n = 0.0/0.0 63 | end 64 | else 65 | n = sign * math.ldexp(1.0 + mant / 0x800000, expo - 0x7F) 66 | end 67 | 68 | return n 69 | end 70 | -------------------------------------------------------------------------------- /Makefile: -------------------------------------------------------------------------------- 1 | linux: parse.so 2 | deploy: parse.so web/www/ 3 | scp -r web/www/* metamine.nl:/var/www/html/ 4 | 5 | #ssh -f pi 'cd taal ; git pull ; make ; pkill lua ; /etc/dienst' 6 | 7 | run: linux 8 | lua web/dienst.lua 9 | 10 | test: linux 11 | luajit test.lua 12 | 13 | webdemos: web/www/ex/ 14 | ./tolk ex/aap5.code web/www/ex/aap5.en.code 15 | ./tolk ex/pong.code web/www/ex/pong.en.code 16 | ./tolk ex/cirkels.code web/www/ex/cirkels.en.code 17 | ./tolk ex/salvobal.code web/www/ex/salvobal.en.code 18 | ./tolk ex/buis.code web/www/ex/buis.en.code 19 | ./tolk ex/paint.code web/www/ex/paint.en.code 20 | ./tolk ex/paint2.code web/www/ex/paint2.en.code 21 | ./tolk ex/grafiek.code web/www/ex/grafiek.en.code 22 | ./tolk ex/demo.code web/www/ex/demo.en.code 23 | ./tolk ex/leip.code web/www/ex/leip.en.code 24 | ./tolk ex/oog.code web/www/ex/oog.en.code 25 | ./tolk ex/schaken.code web/www/ex/schaken.en.code 26 | ./tolk ex/voer.code web/www/ex/voer.en.code 27 | ./tolk ex/pe1.code web/www/ex/pe1.en.code 28 | ./tolk ex/pe2.code web/www/ex/pe2.en.code 29 | ./tolk ex/pe3.code web/www/ex/pe3.en.code 30 | ./tolk ex/pe4.code web/www/ex/pe4.en.code 31 | ./tolk ex/pe5.code web/www/ex/pe5.en.code 32 | ./tolk ex/pe6.code web/www/ex/pe6.en.code 33 | 34 | 35 | parse.so: parse/lex.l parse/lang.y parse/lua.c 36 | cd parse; make linux 37 | mkdir -p bin 38 | cp -r parse/bin/* bin/ 39 | ln -sf ../bin/parse.so web/ 40 | ln -sf bin/parse.so . 41 | ln -sf ../vt bin/ 42 | ln -sf ../doe bin/ 43 | 44 | windows: 45 | mkdir -p bin 46 | cd parse; make windows 47 | cp -r parse/bin/* bin/ 48 | ln -sf ../vt bin/ 49 | ln -sf ../doe bin/ 50 | 51 | 52 | #scp -r web/* pi:/var/www/blog/taal-0.1.1 53 | 54 | all: 55 | mkdir -p bin 56 | cd parse; make 57 | cp -r parse/bin/* bin/ 58 | 59 | malloc.o: bieb/malloc.c 60 | cc -c -fPIC -DLACKS_STDLIB_H -DNO_MALLOC_STATS bieb/malloc.c -o bieb/malloc.o 61 | 62 | web: 63 | cd parse; make web 64 | mkdir -p bin 65 | cp -r parse/bin/* bin/ 66 | lua2js lex.lua > bin/lex.js 67 | lua2js lisp.lua > bin/lisp.js 68 | 69 | clean: 70 | rm -rf bin/ 71 | rm -rf web/www/index.html web/www/en web/www/nl web/www/index.*.html 72 | 73 | objects := $(patsubst %.lua,%.o,$(wildcard *.lua)) 74 | 75 | main.o: main.s 76 | as main.s -o main.o 77 | 78 | sources := $(wildcard *.lua) 79 | -------------------------------------------------------------------------------- /lib/atomenjs.lst: -------------------------------------------------------------------------------- 1 | [] [$ARGS] 2 | []u $TARGS 3 | {} new Set([$ARGS]) 4 | | $1 || $2 5 | 6 | atoom atoom$1 7 | % $1 / 100 8 | + $1 + $2 9 | - $1 - $2 10 | · $1 * $2 11 | / $1 / $2 12 | √ Math.sqrt($1) 13 | 14 | +d $1 + $2 15 | -d $1 - $2 16 | ·d $1 * $2 17 | /d $1 / $2 18 | 19 | /i $1 / $2 20 | -i $1 - $2 21 | ·i $1 * $2 22 | 23 | mod $1 % $2 24 | modi $1 % $2 25 | modd $1 % $2 26 | 27 | ^ Math.pow($1, $2) 28 | ^i Math.pow($1, $2) 29 | ^d Math.pow($1, $2) 30 | ^f function(res) { for (var i = 0; i < $2; i++) res = $1(res); return res; } 31 | 32 | willekeurigTussen Math.random()*($2-$1) + $1 33 | 34 | > $1 > $2 35 | ≥ $1 >= $2 36 | = $1 === $2 37 | ≠ $1 !=== $2 38 | ≤ $1 <= $2 39 | < $1 < $2 40 | 41 | ∧ $1 && $2' 42 | ∨ $1 || $2' 43 | ⇒ $1 ? $2 : $3' 44 | 45 | ; trig 46 | sin Math.sin($1) 47 | cos Math.cos($1) 48 | tan Math.tan($1) 49 | sincos [Math.sin($1), Math.cos($1)] 50 | 51 | -- discreet 52 | min Math.min($1,$2) 53 | max Math.max($1,$2) 54 | entier Math.floor($1) 55 | int Math.floor($1) 56 | intd Math.floor($1) 57 | abs Math.abs($1) 58 | absd Math.abs($1) 59 | absi Math.abs($1) 60 | sign ($1 > 0 ? 1 : -1) 61 | 62 | -- exp 63 | log10 Math.log($1, 10) 64 | ‖ $1.join($2) 65 | ‖u $1 + $2 66 | mapuu (function() { var totaal = ""; for (int i = 0; i < $1.length; i++) { totaal += $2($1[i]); }; return totaal; })() 67 | 68 | -- lijst 69 | # $1.length 70 | Σ $1.reduce((a,b) => a + b, 0) 71 | .. $1 == $2 ? [] : ($1 <= $2 ? Array.from(new Array(Math.max(0,$2-$1)), (x,i) => $1 + i) : Array.from(new Array(Math.max(0,$2-$1)), (x,i) => $2 - 1 - i)) 72 | _ $1[$2] != null ? $1[$2] : (function() {throw("ongeldige index in lijst");})() 73 | _u $1[$2] != null ? $1[$2] : (function() {throw("ongeldige index in lijst");})() 74 | _ Array.isArray($1) ? $1[$2] : $1($2) 75 | _u $1[$2] 76 | vanaf $1.slice($2, $1.length) 77 | × $1.map(x => $2.map(y => [x, y])) 78 | 79 | map $1.map($2) 80 | filter $1.filter($2) 81 | reduceer $1.reduce($2) 82 | ∘ (function() { return $1.apply($2.apply(arguments)); } 83 | , [$ARGS] 84 | 85 | prevvar vars[$1] 86 | var (function(varindex, ass) {\n var array = Array.from(ass);\n var ret = vars[varindex];\n for (var i = 0; i < array.length; i++) {\n if (array[i] != null) {\n ret = array[i];\n }\n } \n vars[varindex] = ret;\n return ret;\n })($1, $2) 87 | 88 | -------------------------------------------------------------------------------- /func.lua: -------------------------------------------------------------------------------- 1 | function componeer(...) 2 | local fns = {...} 3 | if #fns == 1 then 4 | fns = fns[1] 5 | end 6 | 7 | return function (...) 8 | local r = {...} 9 | for i,fn in ipairs(fns) do 10 | 11 | r = {fn(...)} 12 | if r[1] == nil then return nil end 13 | end 14 | return unpack(r) 15 | end 16 | end 17 | 18 | function curry(a,b) 19 | return nil 20 | end 21 | 22 | function map(v, fn, ...) 23 | local r = {} 24 | for k,v in pairs(v) do r[k] = fn(v, ...) end 25 | return r 26 | end 27 | 28 | function imap(v, fn, ...) 29 | local r = {} 30 | for k,v in ipairs(v) do r[k] = fn(v, ...) end 31 | return r 32 | end 33 | 34 | function imap(v, fn) 35 | local r = {} 36 | for k,v in ipairs(v) do r[k] = fn(v) end 37 | return r 38 | end 39 | 40 | function filter(t,fn) 41 | local r = {} 42 | for i,v in ipairs(t) do 43 | if fn(v) then 44 | r[#r+1] = v 45 | end 46 | end 47 | return r 48 | end 49 | 50 | function keerom(t) 51 | local r = {} 52 | for i,v in ipairs(t) do 53 | r[#t-i+1] = v 54 | end 55 | return r 56 | end 57 | 58 | function setlijst(set) 59 | local r = {} 60 | for k in spairs(set) do 61 | r[#r+1] = k 62 | end 63 | return r 64 | end 65 | 66 | function join(a,b) 67 | local r = {} 68 | for i,v in ipairs(a) do 69 | for i,v in ipairs(v) do 70 | r[#r+1] = v 71 | end 72 | if b then 73 | r[#r+1] = b 74 | end 75 | end 76 | return r 77 | end 78 | 79 | -- past binop toe op alle leden 80 | -- zoals som 81 | function binop(lijst, fn) 82 | local r = lijst[1] 83 | for i=2,#lijst do 84 | r = fn(r, lijst[i]) 85 | end 86 | return r 87 | end 88 | 89 | function staart(lijst) 90 | local t = {} 91 | for i=2,#lijst do 92 | t[i-1] = lijst[i] 93 | end 94 | return t 95 | end 96 | 97 | func = { 98 | ['-'] = function(A) if b then return a - b else return a end end; 99 | ['·'] = function(A) return a * b end; 100 | ['/'] = function(A) return a / b end; 101 | ['^'] = function(A) return a ^ b end; 102 | 103 | ['..'] = function(a,b) 104 | local t = {} 105 | for i,v in ipairs(a) do t[#t+1] = v end 106 | for i,v in ipairs(b) do t[#t+1] = v end 107 | return t 108 | end; 109 | 110 | -- lib 111 | ['cat'] = cat; 112 | 113 | ['split'] = function(a,b) 114 | local r = {} 115 | local t = {} 116 | for i,v in ipairs(a) do 117 | if v == b then 118 | r[#r+1] = t 119 | t = {} 120 | else 121 | t[#t+1] = v 122 | end 123 | end 124 | return r 125 | end; 126 | } 127 | -------------------------------------------------------------------------------- /web/www/gl.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 69 | 70 | 71 | -------------------------------------------------------------------------------- /ex/pong.code: -------------------------------------------------------------------------------- 1 | ; Pong Deluxe 2 | 3 | ; ball variables 4 | ball.x.min = 15 5 | ball.y.min = 5 6 | ball.x.max = screen.width - 15 7 | ball.y.max = screen.height - 5 8 | ball.vx := 3 9 | ball.vy := random(-3,3) 10 | 11 | ; player variables 12 | player.y.start = player.y.max / 2 13 | player.y.max = screen.height - 25 14 | 15 | ; ball movement 16 | ball.x := screen.width / 2 17 | ball.y := screen.height / 2 18 | 19 | ; pause 20 | pause.til := runtime + 1 21 | pause = runtime < pause.til 22 | 23 | if screen.refreshes and ¬ pause then 24 | ball.x := ball.x + ball.vx 25 | ball.y := ball.y + ball.vy 26 | end 27 | 28 | ; hits ball the players? 29 | right.hits = (ball.y > right.y and ball.y < right.y + 25) 30 | left.hits = (ball.y > left.y and ball.y < left.y + 25) 31 | 32 | ; right bounce 33 | ball.x.min = 0 + 5 + 10 34 | ball.x.max = screen.width - 5 - 10 35 | 36 | if ball.x > ball.x.max and right.hits then 37 | ball.x := ball.x.max 38 | ball.vx := - abs ball.vx 39 | ball.vy := -(right.y - ball.y + 25/2) / 8 40 | end 41 | 42 | ; left bounce 43 | if ball.x < ball.x.min and left.hits then 44 | ball.x := ball.x.min 45 | ball.vx := abs ball.vx 46 | ball.vy := -(left.y - ball.y + 25/2) / 8 47 | end 48 | 49 | ; top and below bounce 50 | if ball.y < ball.y.min then 51 | ball.vy := abs ball.vy 52 | end 53 | if ball.y > ball.y.max then 54 | ball.vy := - abs ball.vy 55 | end 56 | 57 | 58 | ; score 59 | score1 := 0 60 | score2 := 0 61 | 62 | ; er wordt gescoord 63 | if ball.x < 0 or ball.x > screen.width then 64 | ball.x := 90 65 | ball.y := 50 66 | pause.til := runtime + 1 67 | end 68 | if ball.x < 0 then score1 := score1 + 1 end 69 | if ball.x > screen.width then score2 := score2 + 1 end 70 | 71 | ; players 72 | left.y := player.y.start 73 | right.y := player.y.start 74 | 75 | ; controls 76 | if screen.refreshes and key.down and right.y > 0 then right.y := right.y - 2 end 77 | if screen.refreshes and key.up and right.y < player.y.max then right.y := right.y + 2 end 78 | if screen.refreshes and key.s and left.y > 0 then left.y := left.y - 2 end 79 | if screen.refreshes and key.w and left.y < player.y.max then left.y := left.y + 2 end 80 | 81 | ; draw players 82 | left.min = (0, left.y) 83 | left.max = (10, left.y + 25) 84 | right.min = (screen.width - 10, right.y) 85 | right.max = (screen.width, right.y + 25) 86 | 87 | right = rectangle(right.min, right.max) 88 | left = rectangle(left.min, left.max) 89 | 90 | ; draw ball 91 | ball = circle((ball.x, ball.y), 5) 92 | 93 | label1 = label((90-9, 90), string(score2)) 94 | label2 = label((90-2, 90), "-") 95 | label3 = label((90+3, 90), string(score1)) 96 | 97 | out = draw [ left, right, ball, label1, label2, label3 ] 98 | 99 | -------------------------------------------------------------------------------- /ex/bdec1.exp.ansi: -------------------------------------------------------------------------------- 1 | ||( 2 | ||( 3 | ||( 4 | []( 5 | 98 6 | 100 7 | 101 8 | 99 9 | 40 10 | 39 11 | ) 12 | []( 13 | 108 14 | 105 15 | 49 16 | 101 17 | 105 18 | 50 19 | 101 20 | 105 21 | 51 22 | 101 23 | 101 24 | ) 25 | ) 26 | [](39 41 32 61 32) 27 | ) 28 | ((^( 29 | ->( 30 | _A 31 | ->( 32 | _B 33 | |( 34 | =>( 35 | =(_B(0) 105) 36 | tot(_B +(vind(_B [](101)) 1)) 37 | ) 38 | =>( 39 | =(_B(0) 108) 40 | ||( 41 | ||([](108) cat(((^( 42 | ->( 43 | _C 44 | []( 45 | ||( 46 | _C(0) 47 | =>(_A(_C(1)) [](_A(_C(1)))) 48 | ) 49 | vanaf(_C(1) #(_A(_C(1)))) 50 | ) 51 | ) 52 | 3 53 | ))([]([]() vanaf(_B 1))))(0))) 54 | [](101) 55 | ) 56 | ) 57 | ) 58 | ) 59 | ) 60 | 4 61 | ))(->(_D []())))( 62 | []( 63 | 108 64 | 105 65 | 49 66 | 101 67 | 105 68 | 50 69 | 101 70 | 105 71 | 51 72 | 101 73 | 101 74 | ) 75 | ) 76 | ) 77 | -------------------------------------------------------------------------------- /asm/xcb.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | #include 6 | 7 | int main () 8 | { 9 | xcb_connection_t *c; 10 | xcb_screen_t *screen; 11 | xcb_drawable_t win; 12 | xcb_gcontext_t foreground; 13 | xcb_gcontext_t background; 14 | xcb_generic_event_t *e; 15 | uint32_t mask = 0; 16 | uint32_t values[2]; 17 | 18 | char string[] = "Hello, XCB!"; 19 | uint8_t string_len = strlen(string); 20 | 21 | xcb_rectangle_t rectangles[] = { 22 | {40, 40, 20, 20}, 23 | }; 24 | 25 | c = xcb_connect (NULL, NULL); 26 | 27 | /* get the first screen */ 28 | screen = xcb_setup_roots_iterator (xcb_get_setup (c)).data; 29 | 30 | /* root window */ 31 | win = screen->root; 32 | 33 | /* create black (foreground) graphic context */ 34 | foreground = xcb_generate_id (c); 35 | mask = XCB_GC_FOREGROUND | XCB_GC_GRAPHICS_EXPOSURES; 36 | values[0] = screen->black_pixel; 37 | values[1] = 0; 38 | xcb_create_gc (c, foreground, win, mask, values); 39 | 40 | /* create white (background) graphic context */ 41 | background = xcb_generate_id (c); 42 | mask = XCB_GC_BACKGROUND | XCB_GC_GRAPHICS_EXPOSURES; 43 | values[0] = screen->white_pixel; 44 | values[1] = 0; 45 | xcb_create_gc (c, background, win, mask, values); 46 | 47 | /* create the window */ 48 | win = xcb_generate_id(c); 49 | mask = XCB_CW_BACK_PIXEL | XCB_CW_EVENT_MASK; 50 | values[0] = screen->white_pixel; 51 | values[1] = XCB_EVENT_MASK_EXPOSURE | XCB_EVENT_MASK_KEY_PRESS; 52 | xcb_create_window (c, /* connection */ 53 | XCB_COPY_FROM_PARENT, /* depth */ 54 | win, /* window Id */ 55 | screen->root, /* parent window */ 56 | 0, 0, /* x, y */ 57 | 150, 150, /* width, height */ 58 | 10, /* border_width */ 59 | XCB_WINDOW_CLASS_INPUT_OUTPUT, /* class */ 60 | screen->root_visual, /* visual */ 61 | mask, values); /* masks */ 62 | 63 | /* map the window on the screen */ 64 | xcb_map_window (c, win); 65 | 66 | xcb_flush (c); 67 | 68 | while ((e = xcb_wait_for_event (c))) { 69 | switch (e->response_type & ~0x80) { 70 | case XCB_EXPOSE: 71 | xcb_poly_rectangle (c, win, foreground, 1, rectangles); 72 | xcb_image_text_8 (c, string_len, win, background, 40, 40, string); 73 | xcb_flush (c); 74 | break; 75 | case XCB_KEY_PRESS: 76 | goto endloop; 77 | } 78 | free (e); 79 | } 80 | endloop: 81 | 82 | return 0; 83 | } 84 | -------------------------------------------------------------------------------- /ex/bieb.code: -------------------------------------------------------------------------------- 1 | ; arith 2 | (^) : (getal,getal) -> getal 3 | (_) : (getal,getal) -> getal 4 | (*) : (getal,getal) -> getal 5 | (/) : (getal,getal) -> getal 6 | (+) : (getal,getal) -> getal 7 | (-) : (getal,getal) -> getal 8 | 9 | ; relatief 10 | ;(^=) : (getal,getal) -> ok 11 | ;(_=) : (getal,getal) -> ok 12 | ;(*=) : (getal,getal) -> ok 13 | ;(/=) : (getal,getal) -> ok 14 | ;(+=) : (getal,getal) -> ok 15 | ;(-=) : (getal,getal) -> ok 16 | 17 | ; trig 18 | sin : getal -> getal 19 | cos : getal -> getal 20 | tan : getal -> getal 21 | sincos : getal -> getal^2 22 | asin : getal -> getal 23 | acos : getal -> getal 24 | atan : getal -> getal 25 | abs : getal -> getal 26 | 27 | ; wiskunde 28 | pi : getal 29 | tau : getal 30 | som : getal^int -> getal 31 | wortel : getal -> getal 32 | 33 | ; toetsen 34 | toets-links : bit 35 | toets-rechts : bit 36 | toets-omhoog : bit 37 | toets-omlaag : bit 38 | toets-a : bit 39 | toets-s : bit 40 | toets-d : bit 41 | toets-f : bit 42 | toets-j : bit 43 | toets-k : bit 44 | toets-l : bit 45 | toets-puntkomma : bit 46 | toets-spatie : bit 47 | toets-spatie-aan : bit 48 | toets-spatie-uit : bit 49 | 50 | ; logica 51 | bit : int 52 | ja : bit 53 | nee : bit 54 | ;ok : iets 55 | 56 | (niet) : bit -> bit 57 | (en) : bit,bit -> bit 58 | of : bit,bit -> bit 59 | xof : bit,bit -> bit 60 | noch : bit,bit -> bit 61 | (=>) : bit,iets -> iets 62 | 63 | ; vergelijking 64 | (=) : (iets,iets) -> bit 65 | ;(!=) : (iets,iets) -> bit 66 | ;(~=) : (iets,iets) -> bit 67 | (:=) : (iets,iets) -> bit 68 | (>) : (iets,iets) -> bit 69 | (<) : (iets,iets) -> bit 70 | (>=) : (iets,iets) -> bit 71 | (<=) : (iets,iets) -> bit 72 | 73 | goed : bit 74 | ;fout : bit 75 | ;getal : iets 76 | int : getal 77 | bit : int 78 | tekst : teken^int 79 | teken : int 80 | 81 | ; functioneel 82 | ;(->) : iets,iets -> (iets -> iets) 83 | (@) : (iets->iets),(iets->iets) -> (iets->iets) 84 | 85 | ; collectie 86 | ([]) : iets -> iets^int 87 | ({}) : iets -> iets^int ; klopt niet! 88 | (#) : iets^int -> int 89 | (||) : (iets^int, iets^int) -> iets^int 90 | ;(..) : getal,getal -> getal..getal 91 | (xx) : iets -> iets ; ehh 92 | 93 | ; tijd 94 | nu : getal 95 | start : bit 96 | beeld : getal 97 | ;(') : iets -> iets 98 | 99 | ; kleur 100 | kleur : int^3 101 | rood : kleur 102 | groen : kleur 103 | blauw : kleur 104 | geel : kleur 105 | oranje : kleur 106 | roze : kleur 107 | cyaan : kleur 108 | zwart : kleur 109 | wit : kleur 110 | grijs : kleur 111 | bruin : kleur 112 | paars : kleur 113 | magenta : kleur 114 | 115 | ; divers 116 | (:) : (iets,iets) -> ok 117 | ;in : (iets,iets) -> ok 118 | (|) : (iets,iets) -> iets 119 | (&) : (iets,iets) -> iets 120 | ;(>>) : (iets,iets) -> iets 121 | ;(<<) : (iets,iets) -> iets 122 | 123 | ;(.) : iets,iets -> iets 124 | (') : iets -> iets 125 | 126 | ; geo 127 | stip : getal^2 128 | -------------------------------------------------------------------------------- /asm/hoi0.s: -------------------------------------------------------------------------------- 1 | .file "hoi0.c" 2 | .intel_syntax noprefix 3 | .text 4 | .p2align 4,,15 5 | .globl atoi 6 | .type atoi, @function 7 | atoi: 8 | .LFB4: 9 | .cfi_startproc 10 | test rdi, rdi 11 | je .L2 12 | movabs r9, -3689348814741910323 13 | mov ecx, 1 14 | jmp .L3 15 | .p2align 4,,10 16 | .p2align 3 17 | .L8: 18 | mov rdi, rdx 19 | .L3: 20 | mov rax, rdi 21 | mov r10, rdi 22 | mov r8d, ecx 23 | mul r9 24 | shr rdx, 3 25 | lea rax, [rdx+rdx*4] 26 | add rax, rax 27 | sub r10, rax 28 | mov rax, r10 29 | add eax, 48 30 | mov BYTE PTR -1[rsi+rcx], al 31 | add rcx, 1 32 | cmp rdi, 9 33 | ja .L8 34 | mov ecx, r8d 35 | movsx rax, r8d 36 | sar ecx 37 | je .L11 38 | lea r8, -2[rsi+rax] 39 | sub ecx, 1 40 | lea rdx, -1[rsi+rax] 41 | sub r8, rcx 42 | .p2align 4,,10 43 | .p2align 3 44 | .L6: 45 | movzx ecx, BYTE PTR [rsi] 46 | movzx edi, BYTE PTR [rdx] 47 | sub rdx, 1 48 | add rsi, 1 49 | mov BYTE PTR -1[rsi], dil 50 | mov BYTE PTR 1[rdx], cl 51 | cmp r8, rdx 52 | jne .L6 53 | ret 54 | .p2align 4,,10 55 | .p2align 3 56 | .L2: 57 | mov BYTE PTR [rsi], 48 58 | mov eax, 1 59 | ret 60 | .p2align 4,,10 61 | .p2align 3 62 | .L11: 63 | ret 64 | .cfi_endproc 65 | .LFE4: 66 | .size atoi, .-atoi 67 | .p2align 4,,15 68 | .globl _start 69 | .type _start, @function 70 | _start: 71 | .LFB5: 72 | .cfi_startproc 73 | push rbx 74 | .cfi_def_cfa_offset 16 75 | .cfi_offset 3, -16 76 | mov r10d, 1 77 | movabs rsi, 9223372036854775807 78 | movabs r11, -3689348814741910323 79 | sub rsp, 16 80 | .cfi_def_cfa_offset 32 81 | lea rdi, 8[rsp] 82 | lea rbx, 27[rsp] 83 | mov r9, rdi 84 | mov r8, rdi 85 | sub r10d, edi 86 | .p2align 4,,10 87 | .p2align 3 88 | .L13: 89 | mov rax, rsi 90 | lea ecx, [r10+r8] 91 | add r8, 1 92 | mul r11 93 | shr rdx, 3 94 | lea rax, [rdx+rdx*4] 95 | add rax, rax 96 | sub rsi, rax 97 | add esi, 48 98 | mov BYTE PTR -1[r8], sil 99 | mov rsi, rdx 100 | cmp rbx, r8 101 | jne .L13 102 | mov esi, ecx 103 | sar esi 104 | je .L14 105 | movsx rax, ecx 106 | lea rdx, 1[rdi] 107 | sub esi, 1 108 | add rax, rdi 109 | add rsi, rdx 110 | jmp .L15 111 | .p2align 4,,10 112 | .p2align 3 113 | .L22: 114 | add rdx, 1 115 | .L15: 116 | movzx r8d, BYTE PTR [r9] 117 | movzx r10d, BYTE PTR -1[rax] 118 | sub rax, 1 119 | mov BYTE PTR [r9], r10b 120 | mov r9, rdx 121 | mov BYTE PTR [rax], r8b 122 | cmp rdx, rsi 123 | jne .L22 124 | .L14: 125 | mov rdx, rdi 126 | mov esi, 1 127 | mov edi, 1 128 | xor eax, eax 129 | call syscall@PLT 130 | xor esi, esi 131 | mov edi, 60 132 | xor eax, eax 133 | call syscall@PLT 134 | add rsp, 16 135 | .cfi_def_cfa_offset 16 136 | pop rbx 137 | .cfi_def_cfa_offset 8 138 | ret 139 | .cfi_endproc 140 | .LFE5: 141 | .size _start, .-_start 142 | .ident "GCC: (Debian 8.3.0-6) 8.3.0" 143 | .section .note.GNU-stack,"",@progbits 144 | -------------------------------------------------------------------------------- /web/www/lib/addon/selection/active-line.js: -------------------------------------------------------------------------------- 1 | // CodeMirror, copyright (c) by Marijn Haverbeke and others 2 | // Distributed under an MIT license: http://codemirror.net/LICENSE 3 | 4 | // Because sometimes you need to style the cursor's line. 5 | // 6 | // Adds an option 'styleActiveLine' which, when enabled, gives the 7 | // active line's wrapping
the CSS class "CodeMirror-activeline", 8 | // and gives its background
the class "CodeMirror-activeline-background". 9 | 10 | (function(mod) { 11 | if (typeof exports == "object" && typeof module == "object") // CommonJS 12 | mod(require("../../lib/codemirror")); 13 | else if (typeof define == "function" && define.amd) // AMD 14 | define(["../../lib/codemirror"], mod); 15 | else // Plain browser env 16 | mod(CodeMirror); 17 | })(function(CodeMirror) { 18 | "use strict"; 19 | var WRAP_CLASS = "CodeMirror-activeline"; 20 | var BACK_CLASS = "CodeMirror-activeline-background"; 21 | var GUTT_CLASS = "CodeMirror-activeline-gutter"; 22 | 23 | CodeMirror.defineOption("styleActiveLine", false, function(cm, val, old) { 24 | var prev = old && old != CodeMirror.Init; 25 | if (val && !prev) { 26 | cm.state.activeLines = []; 27 | updateActiveLines(cm, cm.listSelections()); 28 | cm.on("beforeSelectionChange", selectionChange); 29 | } else if (!val && prev) { 30 | cm.off("beforeSelectionChange", selectionChange); 31 | clearActiveLines(cm); 32 | delete cm.state.activeLines; 33 | } 34 | }); 35 | 36 | function clearActiveLines(cm) { 37 | for (var i = 0; i < cm.state.activeLines.length; i++) { 38 | cm.removeLineClass(cm.state.activeLines[i], "wrap", WRAP_CLASS); 39 | cm.removeLineClass(cm.state.activeLines[i], "background", BACK_CLASS); 40 | cm.removeLineClass(cm.state.activeLines[i], "gutter", GUTT_CLASS); 41 | } 42 | } 43 | 44 | function sameArray(a, b) { 45 | if (a.length != b.length) return false; 46 | for (var i = 0; i < a.length; i++) 47 | if (a[i] != b[i]) return false; 48 | return true; 49 | } 50 | 51 | function updateActiveLines(cm, ranges) { 52 | var active = []; 53 | for (var i = 0; i < ranges.length; i++) { 54 | var range = ranges[i]; 55 | if (!range.empty()) continue; 56 | var line = cm.getLineHandleVisualStart(range.head.line); 57 | if (active[active.length - 1] != line) active.push(line); 58 | } 59 | if (sameArray(cm.state.activeLines, active)) return; 60 | cm.operation(function() { 61 | clearActiveLines(cm); 62 | for (var i = 0; i < active.length; i++) { 63 | cm.addLineClass(active[i], "wrap", WRAP_CLASS); 64 | cm.addLineClass(active[i], "background", BACK_CLASS); 65 | cm.addLineClass(active[i], "gutter", GUTT_CLASS); 66 | } 67 | cm.state.activeLines = active; 68 | }); 69 | } 70 | 71 | function selectionChange(cm, sel) { 72 | updateActiveLines(cm, sel.ranges); 73 | } 74 | }); 75 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Metamine 2 | A completely declarative programming language. Imperative programming is a thing of the past! 3 | 4 | Instead of building code the traditional way - using for loops, a linear control flow, and variables - metamine enables you to write code using equations instead of statements. These equations are immutable and timeless: an equation such as `x = y + 1` can be placed anywhere in the source code and will always hold. An application is simply how you define the term `out`. 5 | 6 | A bunch of predefined terms (not variables) are defined, such as `now` (which refers to the current time), `mouse.x` (which refers to the x-position of the mouse), `screen.width` (the screen width), etcetera. Refer to the catalogue to view all built-in variables. All these terms are always live; simply writing `out = runtime` would result in a timer application. 7 | 8 | # Data types 9 | Metamine uses a type system but does not support type annotations. The following basic types are supported: `int`, `letter`, `number`, `bit`. Compound types are `list`, `set`, `tuple`. Compound types allow type arguments so that you can have `list(letter)` as text or `list(list(number))` for a matrix. 10 | 11 | # Examples 12 | 13 | ## Hello world 14 | A simple hello world example would be: 15 | 16 | out = "hello world" 17 | 18 | This would result in the predictable output: 19 | 20 | hello world 21 | 22 | ## Timer 23 | To create a simple timer you can use: 24 | 25 | out = 10 - runtime 26 | 27 | Which would result in an application that counts back from 10. 28 | 29 | ## Paint 30 | To create visual output, we can use the function `draw`. This takes a list of objects as arguments and outputs a canvas with those objects. 31 | 32 | out = draw objects 33 | objects = [ circle(mouse.x, mouse.y, 10) ] 34 | 35 | This results in a canvas with a circle that follows the mouse: `[` and `]` denote a list, `circle` is a function that takes the x- and y-position and the radius of the circle. 36 | 37 | # Variables 38 | Metamine supports variables, but in a declarative way. Using the assign operator `:=` it is possible to assign values at certain moments. Let's see at an example program that prints how many times you have clicked: 39 | 40 | numclicks := 0 41 | if mouse.click.begin then 42 | numclicks := numclicks + 1 43 | end 44 | out = numclicks 45 | 46 | Note that the equations can still be in any order: the compiler aggregates all assignments for a variable and creates an *update* function for this variable. 47 | The first equation, `numclicks := 0`, is in the *main scope*: not inside any if-statement. This means that this variable is updated at the start at the program with the value `0`. 48 | 49 | The second equation, `numclicks := numclicks + 1`, is inside the if-statement. This means that anytime the if-statement is `true`, the assignment will execute and increase `numclicks` by `1`. Note that you cannot write `numclicks = numclicks + 1` because this is not an assignment and should generate an error. 50 | 51 | # How to use 52 | Clone the repository and execute `make run` to start a local metamine server. In the browser, open http://localhost:1237/ to edit and run metamine code. 53 | -------------------------------------------------------------------------------- /symbol.lua: -------------------------------------------------------------------------------- 1 | require 'exp' 2 | 3 | local assoc = set{'+', '=', 'and', 'or', 'xor', 'nor', '·', '∘'} 4 | 5 | function isvar(name) 6 | if not isatom(name) then 7 | return false 8 | end 9 | if tonumber(name.v) then 10 | return false 11 | elseif name.v == '||' then 12 | return false 13 | elseif string.match(name.v, '^[%w\\.]*$') then 14 | return true 15 | end 16 | return false 17 | end 18 | 19 | function var0(exp,t) 20 | vars = var 21 | local f = var 22 | local t = t or {} 23 | if atom(exp) then 24 | if isvar(exp) then 25 | t[exp] = true 26 | end 27 | else 28 | -- SHADUW IS GEEN VAR 29 | if exp[1] == "'" then 30 | return t 31 | end 32 | for i,s in ipairs(exp) do 33 | f(s,t) 34 | end 35 | end 36 | return t 37 | end 38 | 39 | function var(exp,c,t) 40 | if not c then c = tonumber end 41 | local t = t or {} 42 | if isatom(exp) then 43 | if not c(exp) then t[exp] = true end 44 | else 45 | for k, sub in subs(exp) do 46 | var(sub,c,t) 47 | end 48 | end 49 | return t 50 | end 51 | vars = var 52 | 53 | function val(exp,t) 54 | local t = t or {} 55 | if atom(exp) then 56 | if isvar(exp) or tonumber(exp) then 57 | t[exp] = true 58 | end 59 | else 60 | -- SHADUW IS GEEN VAR 61 | if exp[1] == "'" then 62 | return t 63 | end 64 | for i,s in ipairs(exp) do 65 | val(s,t) 66 | end 67 | end 68 | return t 69 | end 70 | 71 | function substitute(exp, van, naar, klaar) 72 | local klaar = klaar or {} 73 | if klaar[exp] then return klaar[exp], 1 end 74 | if isatom(exp) then 75 | if exp.v == van.v then 76 | klaar[exp] = naar 77 | return naar, 1 78 | else 79 | klaar[exp] = exp 80 | return exp, 0 81 | end 82 | else 83 | if isfn(van) then 84 | if hash(exp) == hash(van) then 85 | klaar[exp] = naar 86 | return naar, 1 87 | end 88 | end 89 | local t = {loc=exp.loc,o=exp.o,f=exp.f} 90 | local n = 0 91 | for k,v in subs(exp) do 92 | t[k],m = substitute(v, van, naar, klaar) 93 | n = n + m 94 | end 95 | klaar[exp] = t 96 | return t, n 97 | end 98 | end 99 | 100 | sym = { 101 | plus = X'+', 102 | min = X'-', 103 | keer = X'·', 104 | deel = X'/', 105 | plusis = X'+=', 106 | minis = X'-=', 107 | keeris = X'·=', 108 | deelis = X'/=', 109 | 110 | alt = X'|', 111 | altis = X'|=', 112 | call = X'call', 113 | cat = X'‖', 114 | catass = X'‖=', 115 | co = X'∐', 116 | cois = X'∐=', 117 | dan = X'⇒', 118 | als = X'⇒', 119 | niet = X'¬', 120 | iets = X'iets', 121 | ja = '⊤', 122 | niets = X'niets', 123 | lijst = X'[]', 124 | is = X'=', 125 | oud = X"'", 126 | ass = X':=', 127 | map = X'→', 128 | maplet = X'↦', 129 | start = X'start', 130 | set = X'{}', 131 | stop = X'stop', 132 | 133 | bit = X'bit', 134 | int = X'int', 135 | getal = X'getal', 136 | lijst = X'lijst', 137 | set = X'set', 138 | tupe = X'tupel', 139 | text = X'text', 140 | } 141 | symbol = sym 142 | 143 | if test then 144 | local a = X('+', 'a', 'a') 145 | local s = X('/', '1', '2') 146 | local b = substitutezuinig(a, X'a', s, makevars()) 147 | local _, tel = string.gsub(hash(b), "/", "") 148 | assert(tel == 1, hash(b)) 149 | --assert(b[2].exp == s, e2s(b)) 150 | end 151 | -------------------------------------------------------------------------------- /web/www/id.svg: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 20 | 22 | 25 | 29 | 30 | 31 | 49 | 51 | 52 | 54 | image/svg+xml 55 | 57 | 58 | 59 | 60 | 61 | 65 | 72 | 73 | 77 | 80 | 86 | 92 | 93 | 94 | 95 | -------------------------------------------------------------------------------- /test/typeer.lua: -------------------------------------------------------------------------------- 1 | require 'deparse' 2 | require 'parse' 3 | require 'typify' 4 | require 'fout' 5 | 6 | function moettypezijn(code, typecode) 7 | local moettype = parseexp(typecode) 8 | local type,fouten = typify(parseexp(code)) 9 | local istype = type 10 | 11 | if hash(istype) ~= hash(moettype) then 12 | print(string.format('type van "%s" is "%s" maar moet "%s" zijn', 13 | code, deparse(istype), deparse(moettype))) 14 | print('typefouten:') 15 | if #fouten > 0 then 16 | for i,fout in ipairs(fouten) do 17 | print(fout2ansi(fout)) 18 | end 19 | end 20 | --assert(false) 21 | end 22 | return fouten 23 | end 24 | 25 | moettypezijn('1 + 2', 'getal') 26 | 27 | -- begin makkelijk 28 | moettypezijn('0', 'int') 29 | moettypezijn('1.5', 'getal') 30 | moettypezijn('sin', 'getal → getal') 31 | 32 | moettypezijn('a + b', 'getal') 33 | moettypezijn('a ∧ b', 'bit') 34 | 35 | moettypezijn('x → x', 'iets → iets') 36 | moettypezijn('x → x + 1', 'getal → getal') 37 | --moettypezijn('[1,2,3] vouw (+)', 'getal') 38 | 39 | 40 | -- kijk of exp's gelijk worden 41 | local exp = parseexp('a = a') 42 | local _,fouten,types = typify(exp) 43 | assert(types[arg0(exp)] == types[arg1(exp)]) 44 | 45 | local exp = parseexp('a = a + 1') 46 | local _,fouten,types = typify(exp) 47 | assert(types[arg0(exp)] == types[arg0(arg1(exp))]) 48 | 49 | local exp = parseexp('a → a') 50 | local _,fouten,types = typify(exp) 51 | assert(types[arg0(exp)] == types[arg1(exp)]) 52 | 53 | local exp = parseexp('x → x + 1') 54 | local _,fouten,types = typify(exp) 55 | assert(types[arg0(exp)] == types[arg0(arg1(exp))]) 56 | 57 | 58 | -- func 59 | moettypezijn('x → x', 'iets → iets') 60 | moettypezijn('x → x + 1', 'getal → getal') 61 | moettypezijn('sin ∘ cos', 'getal → getal') 62 | moettypezijn('sin 3', 'getal') 63 | 64 | -- moeilijke lijsten 65 | moettypezijn('[1,2,3] || [4,5,6]', 'nat → int') 66 | moettypezijn('[1, 2, 0.5] || [1]', 'nat → getal') 67 | 68 | 69 | -- compositiefout check 70 | local type,fouten = typify(parse[[ 71 | f = x → x + 1 72 | g = a, b → a + b 73 | uit = (f ∘ g)(3) 74 | ]]) 75 | assert(#fouten > 0, C(type)) 76 | 77 | -- text types 78 | moettypezijn('"hoi"', 'nat → letter') 79 | local fouten = moettypezijn(' "hoi" || "ja" ', 'nat → letter') 80 | if #fouten > 0 then 81 | print('\n' .. table.concat(map(fouten, fout2ansi), '\n')) 82 | end 83 | 84 | 85 | 86 | -- foutjes 87 | local t,f = typify(parse([[ 88 | w = 177.78 89 | h = 100 90 | spelerW = 5 91 | spelerH = 20 92 | midden = (spelerH + h) / 2 93 | linksY := 0 94 | rechtsY := 0 95 | 96 | links = rechthoek((0,linksY'),(spelerW,linksY'+spelerH)) 97 | rechts = rechthoek((w-spelerW,rechtsY'),(w,rechtsY'+spelerH)) 98 | uit = teken [links, rechts] 99 | ]])) 100 | 101 | 102 | -- functie type mismatch 103 | local t,f = typify(parse([[ 104 | uit = f(3) 105 | f = sin 106 | f = cirkel 107 | ]])) 108 | assert(#f > 0, 'geen typefouten in ongeldig programma!') 109 | 110 | local t,f,types = typify(parse([[ 111 | uit = a + b 112 | a = (1,2) 113 | b = (3,4) 114 | ]])) 115 | assert(#f == 0, 'fouten maar hasht niet') 116 | 117 | -- vouw mismatch 118 | local t,f = typify(parse([[ 119 | L = [1, 2, 3] 120 | uit = (L vouw (>)) 121 | ]])) 122 | if #f == 0 then 123 | print 'geen typefouten in ongeldig programma!' 124 | end 125 | -------------------------------------------------------------------------------- /lib/std.code~Stashed changes: -------------------------------------------------------------------------------- 1 | ;uit: bit 2 | 3 | ; getal 4 | getal: iets 5 | int: getal 6 | nat: int ; natuurlijk getal (≥ 0) 7 | byte: nat 8 | 9 | bit: iets 10 | ja: bit 11 | nee: bit 12 | 13 | verzameling: iets 14 | lijst: verzameling 15 | tupel: verzameling 16 | zak: verzameling 17 | (→): iets 18 | (,): tupel 19 | 20 | ; telbaar aantal 21 | ; vgl. "a = 1..1000" (aantal, telbaar) en "0 < a < 1" (ontelbaar) 22 | aantal: verzameling 23 | ontelbaar: verzameling 24 | 25 | succ: nat → nat 26 | sin : getal → getal 27 | cos : getal → getal 28 | tan : getal → getal 29 | sincos : getal → (getal, getal) 30 | (+) : (getal, getal) → getal 31 | (+) : (int, int) → int 32 | (-) : (getal, getal) → getal 33 | (-) : getal → getal 34 | (*) : (getal, getal) → getal 35 | (/) : (getal, getal) → getal 36 | (/) : (int, int) → getal 37 | (^) : (getal, getal) → getal 38 | (^) : (int, int) → int 39 | ;(^) : ((→), int) → iets 40 | (#) : verzameling → int 41 | ;([) : lijst 42 | ;(=) : (iets, iets) → bit 43 | ;(→) : (iets,iets) → (iets → iets) 44 | (||) : (lijst, lijst) → lijst 45 | 46 | ; set! 47 | set: verzameling 48 | ({) : set 49 | (∩) : (set, set) → set 50 | (∪) : (set, set) → set 51 | ;(-) : (set, set) → set 52 | ;(∖) : (set, set) → set 53 | ;(⋂) : (aantal set) → set 54 | ;(⋃) : (aantal set) → set 55 | 56 | ; logica 57 | ;(⇒) : (bit, iets) → iets 58 | (>) : (getal, getal) → bit 59 | (≥) : (getal, getal) → bit 60 | (≤) : (getal, getal) → bit 61 | (<) : (getal, getal) → bit 62 | (∧) : (bit, bit) → bit 63 | (⋀) : iets → bit 64 | (⋁) : verzameling bit → bit 65 | 66 | ; multi 67 | (Σ) : (verzameling getal) → getal 68 | ;(∫) : (ontelbaar getal) → getal 69 | (..) : (int, int) → lijst int 70 | 71 | ; util 72 | abs: getal → getal 73 | max: (getal,getal) → getal 74 | min: (getal,getal) → getal 75 | entier: getal → int 76 | (:): (iets,iets) → bit 77 | 78 | (iets → iets) : iets 79 | (iets → int) : iets 80 | 81 | byte: int 82 | teken: int 83 | data: lijst byte 84 | tekst: lijst byte 85 | ;tekst: data ;lijst teken 86 | 87 | tijdstip : getal 88 | int : getal 89 | nu : tijdstip 90 | ;cijfer : iets → bit 91 | vind : (lijst, lijst) → int 92 | tot : (lijst, int) → lijst 93 | vanaf : (lijst, int) → lijst 94 | deel : (lijst, (int, int)) → lijst 95 | 96 | ;herhaal : ((→) → (→)) 97 | ;herhaal : ((→), int) → (→) 98 | waarvoor : (verzameling, (iets → bit)) → verzameling 99 | mod : (getal, getal) → getal 100 | 101 | ; tekening! 102 | vorm: iets 103 | tekening: lijst(vorm) 104 | cirkel: vorm 105 | cirkel: ((getal, getal), getal, kleur) → cirkel 106 | rechthoek: vorm 107 | rechthoek: ((getal, getal), (getal, getal), kleur) → rechthoek 108 | ;schrijf: ((getal, getal), tekst, kleur) → rechthoek 109 | genormaliseerd : getal ; tussen 0 en 1 110 | kleur: (genormaliseerd, genormaliseerd, genormaliseerd) 111 | ;kleur: (getal, getal, getal) 112 | rood: kleur 113 | oranje: kleur 114 | groen: kleur 115 | blauw: kleur 116 | geel: kleur 117 | paars: kleur 118 | zwart: kleur 119 | wit: kleur 120 | 121 | ;- 122 | pos : (kommagetal, kommagetal) 123 | pos : (int, int) 124 | pos : (getal, int) 125 | pos : (int, getal) 126 | tekening : lijst 127 | straal : kommagetal 128 | cirkel : (pos,straal,(getal, getal, getal)) → (int, pos, straal, (getal, getal, getal)) 129 | rechthoek : (pos,pos,(getal, getal, getal)) → (int, pos, pos, (getal, getal, getal)) 130 | -; 131 | -------------------------------------------------------------------------------- /lib/std.code~Stashed changes_0: -------------------------------------------------------------------------------- 1 | ;uit: bit 2 | 3 | ; getal 4 | getal: iets 5 | int: getal 6 | nat: int ; natuurlijk getal (≥ 0) 7 | byte: nat 8 | 9 | bit: iets 10 | ja: bit 11 | nee: bit 12 | 13 | verzameling: iets 14 | lijst: verzameling 15 | tupel: verzameling 16 | zak: verzameling 17 | (→): iets 18 | (,): tupel 19 | 20 | ; telbaar aantal 21 | ; vgl. "a = 1..1000" (aantal, telbaar) en "0 < a < 1" (ontelbaar) 22 | aantal: verzameling 23 | ontelbaar: verzameling 24 | 25 | succ: nat → nat 26 | sin : getal → getal 27 | cos : getal → getal 28 | tan : getal → getal 29 | sincos : getal → (getal, getal) 30 | (+) : (getal, getal) → getal 31 | (+) : (int, int) → int 32 | (-) : (getal, getal) → getal 33 | (-) : getal → getal 34 | (*) : (getal, getal) → getal 35 | (/) : (getal, getal) → getal 36 | (/) : (int, int) → getal 37 | (^) : (getal, getal) → getal 38 | (^) : (int, int) → int 39 | ;(^) : ((→), int) → iets 40 | (#) : verzameling → int 41 | ;([) : lijst 42 | ;(=) : (iets, iets) → bit 43 | ;(→) : (iets,iets) → (iets → iets) 44 | (||) : (lijst, lijst) → lijst 45 | 46 | ; set! 47 | set: verzameling 48 | ({) : set 49 | (∩) : (set, set) → set 50 | (∪) : (set, set) → set 51 | ;(-) : (set, set) → set 52 | ;(∖) : (set, set) → set 53 | ;(⋂) : (aantal set) → set 54 | ;(⋃) : (aantal set) → set 55 | 56 | ; logica 57 | ;(⇒) : (bit, iets) → iets 58 | (>) : (getal, getal) → bit 59 | (≥) : (getal, getal) → bit 60 | (≤) : (getal, getal) → bit 61 | (<) : (getal, getal) → bit 62 | (∧) : (bit, bit) → bit 63 | (⋀) : iets → bit 64 | (⋁) : verzameling bit → bit 65 | 66 | ; multi 67 | (Σ) : (verzameling getal) → getal 68 | ;(∫) : (ontelbaar getal) → getal 69 | (..) : (int, int) → lijst int 70 | 71 | ; util 72 | abs: getal → getal 73 | max: (getal,getal) → getal 74 | min: (getal,getal) → getal 75 | entier: getal → int 76 | (:): (iets,iets) → bit 77 | 78 | (iets → iets) : iets 79 | (iets → int) : iets 80 | 81 | byte: int 82 | teken: int 83 | data: lijst byte 84 | tekst: lijst byte 85 | ;tekst: data ;lijst teken 86 | 87 | tijdstip : getal 88 | int : getal 89 | nu : tijdstip 90 | ;cijfer : iets → bit 91 | vind : (lijst, lijst) → int 92 | tot : (lijst, int) → lijst 93 | vanaf : (lijst, int) → lijst 94 | deel : (lijst, (int, int)) → lijst 95 | 96 | ;herhaal : ((→) → (→)) 97 | ;herhaal : ((→), int) → (→) 98 | waarvoor : (verzameling, (iets → bit)) → verzameling 99 | mod : (getal, getal) → getal 100 | 101 | ; tekening! 102 | vorm: iets 103 | tekening: lijst(vorm) 104 | cirkel: vorm 105 | cirkel: ((getal, getal), getal, kleur) → cirkel 106 | rechthoek: vorm 107 | rechthoek: ((getal, getal), (getal, getal), kleur) → rechthoek 108 | ;schrijf: ((getal, getal), tekst, kleur) → rechthoek 109 | genormaliseerd : getal ; tussen 0 en 1 110 | kleur: (genormaliseerd, genormaliseerd, genormaliseerd) 111 | ;kleur: (getal, getal, getal) 112 | rood: kleur 113 | oranje: kleur 114 | groen: kleur 115 | blauw: kleur 116 | geel: kleur 117 | paars: kleur 118 | zwart: kleur 119 | wit: kleur 120 | 121 | ;- 122 | pos : (kommagetal, kommagetal) 123 | pos : (int, int) 124 | pos : (getal, int) 125 | pos : (int, getal) 126 | tekening : lijst 127 | straal : kommagetal 128 | cirkel : (pos,straal,(getal, getal, getal)) → (int, pos, straal, (getal, getal, getal)) 129 | rechthoek : (pos,pos,(getal, getal, getal)) → (int, pos, pos, (getal, getal, getal)) 130 | -; 131 | -------------------------------------------------------------------------------- /lib/std.code~Stashed changes_1: -------------------------------------------------------------------------------- 1 | ;uit: bit 2 | 3 | ; getal 4 | getal: iets 5 | int: getal 6 | nat: int ; natuurlijk getal (≥ 0) 7 | byte: nat 8 | 9 | bit: iets 10 | ja: bit 11 | nee: bit 12 | 13 | verzameling: iets 14 | lijst: verzameling 15 | tupel: verzameling 16 | zak: verzameling 17 | (→): iets 18 | (,): tupel 19 | 20 | ; telbaar aantal 21 | ; vgl. "a = 1..1000" (aantal, telbaar) en "0 < a < 1" (ontelbaar) 22 | aantal: verzameling 23 | ontelbaar: verzameling 24 | 25 | succ: nat → nat 26 | sin : getal → getal 27 | cos : getal → getal 28 | tan : getal → getal 29 | sincos : getal → (getal, getal) 30 | (+) : (getal, getal) → getal 31 | (+) : (int, int) → int 32 | (-) : (getal, getal) → getal 33 | (-) : getal → getal 34 | (*) : (getal, getal) → getal 35 | (/) : (getal, getal) → getal 36 | (/) : (int, int) → getal 37 | (^) : (getal, getal) → getal 38 | (^) : (int, int) → int 39 | ;(^) : ((→), int) → iets 40 | (#) : verzameling → int 41 | ;([) : lijst 42 | ;(=) : (iets, iets) → bit 43 | ;(→) : (iets,iets) → (iets → iets) 44 | (||) : (lijst, lijst) → lijst 45 | 46 | ; set! 47 | set: verzameling 48 | ({) : set 49 | (∩) : (set, set) → set 50 | (∪) : (set, set) → set 51 | ;(-) : (set, set) → set 52 | ;(∖) : (set, set) → set 53 | ;(⋂) : (aantal set) → set 54 | ;(⋃) : (aantal set) → set 55 | 56 | ; logica 57 | ;(⇒) : (bit, iets) → iets 58 | (>) : (getal, getal) → bit 59 | (≥) : (getal, getal) → bit 60 | (≤) : (getal, getal) → bit 61 | (<) : (getal, getal) → bit 62 | (∧) : (bit, bit) → bit 63 | (⋀) : iets → bit 64 | (⋁) : verzameling bit → bit 65 | 66 | ; multi 67 | (Σ) : (verzameling getal) → getal 68 | ;(∫) : (ontelbaar getal) → getal 69 | (..) : (int, int) → lijst int 70 | 71 | ; util 72 | abs: getal → getal 73 | max: (getal,getal) → getal 74 | min: (getal,getal) → getal 75 | entier: getal → int 76 | (:): (iets,iets) → bit 77 | 78 | (iets → iets) : iets 79 | (iets → int) : iets 80 | 81 | byte: int 82 | teken: int 83 | data: lijst byte 84 | tekst: lijst byte 85 | ;tekst: data ;lijst teken 86 | 87 | tijdstip : getal 88 | int : getal 89 | nu : tijdstip 90 | ;cijfer : iets → bit 91 | vind : (lijst, lijst) → int 92 | tot : (lijst, int) → lijst 93 | vanaf : (lijst, int) → lijst 94 | deel : (lijst, (int, int)) → lijst 95 | 96 | ;herhaal : ((→) → (→)) 97 | ;herhaal : ((→), int) → (→) 98 | waarvoor : (verzameling, (iets → bit)) → verzameling 99 | mod : (getal, getal) → getal 100 | 101 | ; tekening! 102 | vorm: iets 103 | tekening: lijst(vorm) 104 | cirkel: vorm 105 | cirkel: ((getal, getal), getal, kleur) → cirkel 106 | rechthoek: vorm 107 | rechthoek: ((getal, getal), (getal, getal), kleur) → rechthoek 108 | ;schrijf: ((getal, getal), tekst, kleur) → rechthoek 109 | genormaliseerd : getal ; tussen 0 en 1 110 | kleur: (genormaliseerd, genormaliseerd, genormaliseerd) 111 | ;kleur: (getal, getal, getal) 112 | rood: kleur 113 | oranje: kleur 114 | groen: kleur 115 | blauw: kleur 116 | geel: kleur 117 | paars: kleur 118 | zwart: kleur 119 | wit: kleur 120 | 121 | ;- 122 | pos : (kommagetal, kommagetal) 123 | pos : (int, int) 124 | pos : (getal, int) 125 | pos : (int, getal) 126 | tekening : lijst 127 | straal : kommagetal 128 | cirkel : (pos,straal,(getal, getal, getal)) → (int, pos, straal, (getal, getal, getal)) 129 | rechthoek : (pos,pos,(getal, getal, getal)) → (int, pos, pos, (getal, getal, getal)) 130 | -; 131 | -------------------------------------------------------------------------------- /ex/schaken2.code: -------------------------------------------------------------------------------- 1 | ; constant 2 | leeg,pion,paard,loper,toren,dame,heer = 0,1,2,3,4,5,6 3 | wit = 0 4 | zwart = 10 5 | w = 12.5 6 | symbolen = [ 7 | "","♟","♞","♝","♜","♛","♚","","","", 8 | "","♙","♘","♗","♖","♕","♔" 9 | ] 10 | 11 | ; startdata 12 | wit.achter = [toren,paard,loper,dame,heer,loper,paard,toren] 13 | wit.pionnen = [pion]^8 14 | wit.start = wit.achter ‖ wit.pionnen 15 | zwart.achter = zwart + wit.achter 16 | zwart.pionnen = [zwart+pion]^8 17 | zwart.start = zwart.pionnen ‖ zwart.achter 18 | 19 | ; startbord 20 | startgrid = 1..17 ‖ [0]^32 ‖ 17..33 21 | startposs = [0] ‖ 0..16 ‖ 48..64 22 | starttypes = [0] ‖ wit.start ‖ zwart.start 23 | startbord = startgrid, startposs, starttypes, ja 24 | 25 | 26 | 27 | bord := startbord 28 | pos := -1,-1 29 | 30 | 31 | 32 | 33 | ; teken 34 | bordsymbolen = bord₀ map starttypes map symbolen 35 | borddata = (0..8·w × 0..8·w) zip bordsymbolen 36 | labels = borddata map label 37 | flabels = (labels × [14]) map canvas.fontsize 38 | 39 | hover = vierkant(posx·w, posy·w, w) verf kleur.geel 40 | selectie = vierkant(pos₀·w, pos₁·w, w) verf kleur.groen 41 | 42 | vaksom = (0..8 × 0..8) map (+) 43 | indices = (vaksom × [2]) map mod 44 | palet = [ rgb(.7,.3,.1), rgb(.8,.4,.1) ] 45 | kleuren = indices map palet 46 | 47 | vakken = (0..8·w × 0..8·w × [w]) map vierkant 48 | kvakken = vakken zip kleuren map verf 49 | 50 | 51 | 52 | 53 | ; zet 54 | doezet = dzBord, (posA, posB) → ndzBord 55 | dzBord = (dzGrid, dzPos, dzTypes, dzAanzet) 56 | ndzBord = ndzGrid, ndzPos, dzTypes, ¬dzAanzet 57 | ndzGrid0 = newindex(dzGrid, posB, dzGrid(posA)) 58 | ndzGrid = newindex(ndzGrid0, posA, 0) 59 | ndzPos0 = newindex(dzPos, dzGrid(posA), posB) 60 | ndzPos = newindex(ndzPos0, dzGrid(posB), 0) 61 | 62 | kanzet = kzBord,(kzA,kzB) → (kzA ≠ kzB) 63 | 64 | 65 | zetten = zBord → zZetten 66 | zBord = (zGrid, zPos, zTypes, zAanzet) 67 | 68 | 69 | ; zetten 70 | 71 | als bord₃ dan ;TODO 72 | zZetten = (8..16) zip (24..32) 73 | anders 74 | zZetten = (48..56) zip (32..40) 75 | eind 76 | 77 | 78 | ; GUI 79 | posx = klem(⌊muis.x/12.5⌋, 0, 7) 80 | posy = klem(⌊muis.y/12.5⌋, 0, 7) 81 | posi = posx + posy · 8 82 | seli := -1 83 | 84 | als muis.klik.begin en seli = -1 en (bord₀)(posi) > 0 dan 85 | pos := posx, posy 86 | seli := posi 87 | eind 88 | 89 | hist := [] 90 | log := [] 91 | 92 | als muis.klik.begin en seli ≠ -1 dan 93 | als kanzet(bord, (seli,posi)) dan 94 | bord := doezet(bord, (seli, posi)) 95 | hist := hist ‖ [bord] 96 | eind 97 | seli := -1 98 | pos := -1,-1 99 | eind 100 | 101 | als toets.spatie.begin en #hist > 0 dan 102 | bord := hist(#hist-1) 103 | hist := hist tot (#hist-1) 104 | eind 105 | 106 | als toets.w.begin dan 107 | bord := doezet(bord, (zetten(bord))₀ ) 108 | hist := hist ‖ [bord] 109 | log := log ‖ [ (zetten(bord))₀ ] 110 | eind 111 | 112 | ; debug 113 | debug1 = label((105,90),type(zetten)) canvas.fontsize 3 114 | debug2 = label((105,85),"aanzet = "‖tekst(x)) canvas.fontsize 3 115 | debug3 = label((105,80),"log = "‖tekst(log)) canvas.fontsize 3 116 | debug4 = label((105,75),"zetten = "‖tekst(zetten(bord))) canvas.fontsize 3 117 | x = bord₃ 118 | 119 | uit = teken(kvakken ‖ [hover, selectie] ‖ flabels ‖ [debug1, debug2, debug3, debug4]) 120 | 121 | 122 | 123 | 124 | 125 | 126 | 127 | 128 | 129 | 130 | 131 | 132 | 133 | 134 | 135 | 136 | 137 | -------------------------------------------------------------------------------- /ex/ontleed.code: -------------------------------------------------------------------------------- 1 | ; lex 2 | in = "1 / 2 + 2 / 3\n" 3 | lex = code → tokens 4 | 5 | modus := nniets 6 | i := 0 7 | iprev := 0 8 | tokens := [ "" ] vanaf 1 9 | types := [] 10 | 11 | -1,0,1,2,3,4,5,6 = klaar,nniets,comment,commentdeel,var,num,op,newline 12 | 13 | als modus = nniets dan 14 | i := i + 1 15 | als 'a' ≤ in(i) en in(i) ≤ 'z' dan 16 | iprev := i 17 | modus := var 18 | types := types ‖ [var] 19 | eind 20 | als '0' ≤ in(i) en in(i) ≤ '9' of in(i) = '.' dan 21 | iprev := i 22 | modus := num 23 | types := types ‖ [num] 24 | eind 25 | als in(i) = ' ' dan 26 | ; niets 27 | eind 28 | als in(i) = 10 dan 29 | modus := newline 30 | types := types ‖ [newline] 31 | eind 32 | als in(i) = ';' dan 33 | modus := comment 34 | types := types ‖ [newline] 35 | eind 36 | als in(i) = ';' en in(i+1) = '-' dan 37 | modus := commentdeel 38 | eind 39 | als in(i) = '-' of in(i) = '=' of in(i) = '+' of in(i) = '>' of in(i) = '/' dan 40 | modus := op 41 | types := types ‖ [op] 42 | eind 43 | eind 44 | 45 | als i ≥ #in dan 46 | modus := klaar 47 | eind 48 | 49 | als modus = commentdeel dan 50 | als in(i) = '-' en in(i+1) = ';' dan 51 | i := i + 2 52 | modus := nniets 53 | anders 54 | i := i + 1 55 | eind 56 | eind 57 | 58 | als modus = comment dan 59 | als in(i) = 10 of in(i) = nniets dan 60 | modus := nniets 61 | i := i + 1 62 | tokens := tokens ‖ [ "\n" ] 63 | anders 64 | i := i + 1 65 | eind 66 | eind 67 | 68 | als modus = op of modus = newline dan 69 | ;i := i + 1 70 | modus := nniets 71 | tokens := tokens ‖ [ in vanaf (i-1) tot 1 ] 72 | eind 73 | 74 | als modus = var dan 75 | als 'a' ≤ in(i) en in(i) ≤ 'z' dan 76 | i := i + 1 77 | anders 78 | tokens := tokens ‖ [ in vanaf iprev tot (i - iprev) ] 79 | modus := nniets 80 | eind 81 | eind 82 | 83 | als modus = num dan 84 | als '0' ≤ in(i) en in(i) ≤ '9' of in(i) = '.' of in(i) = 'e' dan 85 | i := i + 1 86 | anders 87 | tokens := tokens ‖ [ in vanaf iprev tot (i - iprev) ] 88 | modus := nniets 89 | eind 90 | eind 91 | 92 | 93 | ; ontleed 94 | j := 0 95 | stats := [] 96 | omodus := nniets 97 | 98 | valstack := [] 99 | opstack := [] 100 | res := [] 101 | 102 | prioriteit = px → pp 103 | als px = "=" dan pp = 1 eind 104 | als px = "+" dan pp = 2 eind 105 | als px = "/" dan pp = 3 eind 106 | als px = "" dan pp = 0 eind 107 | 108 | als toets.spatie.begin en (types ⇒ j < #types) dan 109 | als types(j) = var then 110 | valstack := valstack ‖ [ tokens(j) ] 111 | j := j + 1 112 | eind 113 | als types(j) = op then 114 | als (opstack ⇒ #opstack = 0 of prioriteit(tokens(j)) > prioriteit(opstack(#opstack-1)) ) dan 115 | opstack := [ tokens(j) ] ‖ opstack 116 | anders 117 | res := res ‖ valstack ‖ opstack 118 | valstack := ["ok"] vanaf 1 119 | opstack := [ tokens(j) ] 120 | eind 121 | j := j + 1 122 | eind 123 | als types(j) = num then 124 | valstack := valstack ‖ [ tokens(j) ] 125 | j := j + 1 126 | eind 127 | als types(j) = newline then 128 | j := j + 1 129 | res := res ‖ valstack ‖ opstack 130 | valstack := ["ok"] vanaf 1 131 | opstack := ["ok"] vanaf 1 132 | eind 133 | eind 134 | 135 | uit = tokens, res, valstack, opstack 136 | 137 | 138 | 139 | 140 | 141 | 142 | 143 | 144 | 145 | 146 | 147 | 148 | 149 | 150 | 151 | 152 | 153 | 154 | 155 | 156 | 157 | 158 | 159 | 160 | 161 | 162 | 163 | 164 | 165 | -------------------------------------------------------------------------------- /ex/syntax.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 48 | 
uit[102,105,98,40,50,48,41,32,61,32] || tekst((_A -> ((_B -> [_B(1),_B(0) + _B(1)] ^ _A)([0,1]))(0))(20)) || [10] = "fib(20) = " || tekst(x)(_A -> ((_B -> [_B(1),_B(0) + _B(1)] ^ _A)([0,1]))(0))(20) || [10]
49 | x(_A -> ((_B -> [_B(1),_B(0) + _B(1)] ^ _A)([0,1]))(0))(20) = fib_A -> ((_B -> [_B(1),_B(0) + _B(1)] ^ _A)([0,1]))(0) 20
50 | fib_A -> ((_B -> [_B(1),_B(0) + _B(1)] ^ _A)([0,1]))(0) = n → (f_B -> [_B(1),_B(0) + _B(1)]ⁿ_A[0,1]) 0
51 | f_B -> [_B(1),_B(0) + _B(1)] = [a,b] → [b_B(1),a_B(0)+b_B(1)]
52 |
53 | 54 | 55 | -------------------------------------------------------------------------------- /lib/std2.code: -------------------------------------------------------------------------------- 1 | ververs = moment → schrijf(tekst(uit)) 2 | app = herhaal.langzaam(ververs) 3 | 4 | ; canvas 5 | canvas = invoer.registreer(schrijf "") 6 | canvas.teken = canvas.wis ∘ (vormen2d vouw (∘)) 7 | canvas.render = vormen3d vouw (∘) 8 | 9 | ;video: nu → beeld 10 | ;schilder: canvas → canvas 11 | 12 | ;app = (video, audio, vars) 13 | ;in = (toets.neer, toets.op, nu, vars) 14 | 15 | context = canvas.context2d(schrijf "") 16 | ;teken = objs → (objs vouw (_)) context 17 | teken = obj → obj(context) 18 | 19 | ;rechthoek = ((x1,y1),(x2,y2)) → (ctx → (pad.begin ∘ pad.rect ∘ pad.eind)) 20 | 21 | ; verf: ctx → ctx 22 | 23 | ; schilder: obj → (canvas → canvas) 24 | ;render = vormen3d → (canvas.render(canvas.context3d(canvas)) ⇒ "") 25 | 26 | 27 | ; vec 28 | vec.plus = va,vb → va zip vb map (+) 29 | ;vec.min = va,vb → va zip (vb map (-)) map (+) 30 | vec.mul = va,vb → va zip vb map (·) 31 | vec.dot = vda,vdb → Σ (vda zip vdb map (·)) 32 | vec.schaal = vsv,vsf → vsv zip1 vsf map (·) 33 | 34 | ; vec4 35 | vec4.plus = vec.plus 36 | vec4.mul = vec.mul 37 | mat4.vmul = mvm,mvv → (mat4.transponeer mvm) zip1 mvv map vec.dot 38 | mat4.mul = mma,mmb → (mat4.transponeer mma) rzip1 mmb map mat4.vmul 39 | 40 | ; transformatie 41 | transform.verplaats = tva,tvb,tvc → ((1,0,0,0),(0,1,0,0),(0,0,1,0),(tva,tvb,tvc,1)) 42 | transform.schaal = tsx,tsy,tsz → ((tsx,0,0,0),(0,tsy,0,0),(0,0,tsz,0),(0,0,0,1)) 43 | 44 | ; [a b 0] [a 0 b] [1 0 0] 45 | ; [c d 0] [0 1 0] [0 a b] 46 | ; [0 0 1] [c 0 d] [0 c d] 47 | transform.xdraai = tdx → (1,0,0,0), (0, cos tdx, sin tdx, 0), (0, -sin tdx, cos tdx, 0), (0,0,0,1) 48 | transform.ydraai = tdy → (cos tdy, 0, sin tdy, 0), (0,1,0,0), (-sin tdy, 0, cos tdy, 0), (0,0,0,1) 49 | transform.zdraai = tdz → (cos tdz, sin tdz, 0, 0), (-sin tdz, cos tdz, 0, 0), (0,0,1,0), (0,0,0,1) 50 | transform.comp = mat4.mul 51 | 52 | ; scherm 53 | scherm.breedte = 177.778 54 | scherm.hoogte = 100 55 | ;scherm.frequentie = ? 56 | ;dt = scherm.frequentie 57 | 58 | ; mat4 59 | mat4.id = ((1,0,0,0),(0,1,0,0),(0,0,1,0),(0,0,0,1)) 60 | mat4.transponeer = mta,mtb,mtc,mtd → ((mta₀,mtb₀,mtc₀,mtd₀),(mta₁,mtb₁,mtc₁,mtd₁),(mta₂,mtb₂,mtc₂,mtd₂),(mta₃,mtb₃,mtc₃,mtd₃)) 61 | 62 | ; vec 63 | vec2.plus = (Va,Vb),(Vc,Vd) → Va+Vc, Vb+Vd 64 | vec2.mul = vec.mul 65 | vec2.schaal = (vx,vy),vf → (vx·vf,vy·vf) 66 | vec2.min = (px1,py1),(px2,py2) → px1-px2,py1-py2 67 | vec2.unit = sincos 68 | 69 | ; toetsenbord 70 | toets.spatie = toets.neer(32) 71 | toets.links = toets.neer(37) 72 | toets.omhoog = toets.neer(38) 73 | toets.rechts = toets.neer(39) 74 | toets.omlaag = toets.neer(40) 75 | toets.a = toets.neer(65) 76 | toets.w = toets.neer(87) 77 | toets.d = toets.neer(68) 78 | toets.s = toets.neer(83) 79 | 80 | toets.spatie.begin = toets.neer.begin(32) 81 | toets.links.begin = toets.neer.begin(37) 82 | toets.omhoog.begin = toets.neer.begin(38) 83 | toets.rechts.begin = toets.neer.begin(39) 84 | toets.omlaag.begin = toets.neer.begin(40) 85 | toets.a.begin = toets.neer.begin(97) 86 | toets.d.begin = toets.neer.begin(100) 87 | toets.s.begin = toets.neer.begin(115) 88 | toets.w.begin = toets.neer.begin(119) 89 | 90 | toets.spatie.eind = toets.neer.eind(32) 91 | toets.links.eind = toets.neer.eind(37) 92 | toets.omhoog.eind = toets.neer.eind(38) 93 | toets.rechts.eind = toets.neer.eind(39) 94 | toets.omlaag.eind = toets.neer.eind(40) 95 | toets.A.eind = toets.neer.eind(97) 96 | toets.D.eind = toets.neer.eind(100) 97 | toets.S.eind = toets.neer.eind(115) 98 | toets.W.eind = toets.neer.eind(119) 99 | -------------------------------------------------------------------------------- /constoptm.lua: -------------------------------------------------------------------------------- 1 | require 'util' 2 | require 'lib' 3 | local lib = lib() 4 | local makkelijk = set('+', '-', '·', '/', '%', '#', '_', '^', '√', '∧', '∨', 'Σ', '>', '<', '≥', '≤', '=', '≠', '⇒', '⊤', '⊥', '_l', '_t', '_t') 5 | local dynamic = set('looptijd', 'nu', 'starttijd', 'start', '∘', 6 | 'tcp.lees', 'tcp.schrijf', 'tcp.accepteer', 'tcp.bind', 7 | 'pad.begin', 'pad.eind', 'pad.rect', 'pad.vul', 'pad.verf', 8 | 'canvas.context', 'html', 9 | '_arg', 'schrijf', 'vierkant', 'cirkel', 'label', 'rechthoek', 'lijn', '_V', '_var', 'toets.neer', 'muis.klik', 'muis.klik.begin', 'muis.klik.eind', 'toets.neer.begin', 'toets.neer.eind', 'misschien', 'willekeurig', 'constant', 'id', 'merge', 'kruid') 10 | 11 | local function w2exp(w) 12 | local uit 13 | if w == true then 14 | uit = X'⊤' 15 | elseif w == false then 16 | uit = X'⊥' 17 | elseif w == nil then 18 | uit = X'niets' 19 | elseif type(w) == 'function' then 20 | -- functies kunnen we (nog) niet tot waarde maken 21 | assert(false) 22 | elseif w == 1/0 then 23 | uit = X('/', '1', '0') 24 | elseif tonumber(w) then 25 | uit = X(tostring(w)) 26 | elseif type(w) == 'string' then 27 | error'ok' 28 | elseif type(w) == 'table' then 29 | if w.isset then 30 | uit = X('{}', table.unpack(map(w, w2exp))) 31 | else 32 | uit = {} 33 | uit.o = X'[]' 34 | for i,v in ipairs(w) do 35 | uit[i] = w2exp(v) 36 | end 37 | end 38 | else 39 | uit = X(tostring(w)) 40 | end 41 | uit.w = w 42 | return uit 43 | end 44 | 45 | local function fname(exp) 46 | return isfn(exp) and fn(exp):sub(1,1) == '_' and atom(arg0(exp)) 47 | end 48 | 49 | 50 | function constoptm(exp) 51 | local constants = {} 52 | for exp in treepairsdfs(exp) do 53 | 54 | end 55 | end 56 | 57 | -- constanten vouwen 58 | function constoptm2(exp) 59 | -- literals 60 | if isatom(exp) then 61 | if tonumber(atom(exp)) then 62 | return exp, tonumber(atom(exp)) 63 | end 64 | if atom(exp) == "⊤" then return exp, true end 65 | if atom(exp) == "⊥" then return exp, false end 66 | if lib[atom(exp)] and not dynamic[atom(exp)] then 67 | if type(lib[atom(exp)]) ~= 'function' then 68 | return exp, lib[atom(exp)] 69 | else 70 | return nil, lib[atom(exp)] 71 | end 72 | end 73 | return exp, nil 74 | end 75 | 76 | -- string 77 | if obj(exp) == '"' then 78 | return exp, nil 79 | end 80 | 81 | 82 | -- objects 83 | if isobj(exp) then 84 | local nexp = {o=exp.o} 85 | local val = {} 86 | local isconstant = true 87 | for k, sub in subs(exp) do 88 | local sub, wsub = constoptm(sub) 89 | nexp[k] = sub 90 | if wsub then 91 | val[k] = wsub 92 | else 93 | isconstant = false 94 | end 95 | end 96 | assign(exp, nexp) 97 | nexp = exp 98 | if isconstant then 99 | return nexp, val 100 | else 101 | return nexp, nil 102 | end 103 | end 104 | 105 | 106 | -- operators 107 | if isfn(exp) then 108 | local narg,warg = constoptm(arg(exp)) 109 | 110 | local nexp, wexp 111 | if makkelijk[fn(exp)] and warg then 112 | if type(warg) == 'table' then 113 | wexp = lib[fn(exp)](warg[1], warg[2], warg[3], warg[4]) 114 | else 115 | wexp = lib[fn(exp)](warg) 116 | end 117 | nexp = w2exp(wexp) 118 | if nexp == nil then 119 | wexp = nil 120 | end 121 | elseif false then 122 | if fn(exp) == '_fn' then 123 | wexp = nil 124 | end 125 | --nexp = {f=exp.f, a=narg} --X(fn(exp), narg) 126 | --error(deparse(exp)) 127 | nexp = exp 128 | --wexp = nil 129 | end 130 | return nexp, wexp 131 | end 132 | return exp 133 | 134 | --assert(false) 135 | end 136 | -------------------------------------------------------------------------------- /test/bouw.lua: -------------------------------------------------------------------------------- 1 | do return end 2 | require 'build.assembleer' 3 | require 'build.link' 4 | require 'build.gen.asm' 5 | require 'build.gen.lua' 6 | require 'build.gen.js' 7 | require 'compile' 8 | require 'doe' 9 | 10 | function doelua(lua) 11 | return load(lua)() 12 | end 13 | 14 | function doeasm(asm) 15 | file('.test.s', asm) 16 | local elf = link(assembleer(asm, 'test')) 17 | file('.test.elf', elf) 18 | os.execute('chmod +x .test.elf') 19 | os.execute('./.test.elf ; echo $? > .test.out') 20 | local uit = file('.test.out') 21 | os.execute('rm .test.out') 22 | os.execute('rm .test.elf') 23 | local uit = uit:sub(1,#uit-1) 24 | return uit 25 | end 26 | 27 | function doejs(js) 28 | local src = "process.exit((function() {\n" .. js .. "\n})())" 29 | file('.test.js', src) 30 | os.execute('node .test.js ; echo $? > .test.out') 31 | local uit = file('.test.out') 32 | os.execute('rm .test.out') 33 | local uit = uit:sub(1,#uit-1) 34 | return uit 35 | end 36 | 37 | function test(code, moetzijn) 38 | -- niet optimaliseren aub 39 | opt = {['0'] = false} 40 | local im,fouten = compile(code) 41 | assert(im, "oncompilebaar: "..code) 42 | 43 | local js = jsgen(im) 44 | local asm = asmgen(im) 45 | 46 | 47 | local imval = tostring(doe(im)) 48 | local asmval = tostring(doeasm(asm)) 49 | local jsval = tostring(doejs(js)) 50 | 51 | if imval ~= asmval or imval ~= jsval then 52 | print(code) 53 | print('Im', 'Js', 'Asm') 54 | print(imval, jsval, asmval) 55 | print() 56 | 57 | 58 | print('# Im') 59 | for i,ins in ipairs(im) do 60 | print(unlisp(ins)) 61 | end 62 | print() 63 | 64 | if imval ~= jsval then 65 | print('# Javascript') 66 | print(js) 67 | print() 68 | end 69 | if imval ~= asmval then 70 | print('# Assembly') 71 | print(asm:sub(1,100)) 72 | print() 73 | end 74 | 75 | --assert(false) 76 | end 77 | 78 | end 79 | 80 | -- arit 81 | test("main = 2", 2) 82 | test("main = 1 + 2", 3) 83 | test("main = 1 + 2 · 3", 7) 84 | test("main = 6 - 2", 4) 85 | 86 | -- functioneel 87 | test("f = x → x + 1\nmain = f(1)", 2) 88 | test("f = x → x + 1\nmain = (f ∘ f)(1)", 3) 89 | test("f = x → x + 1\nmain = (f ^ 3)(1)", 4) 90 | 91 | -- logica 92 | test("main = (ja ⇒ 2)", 2) 93 | 94 | 95 | test([[ 96 | f = x → x + 10 97 | g = y → y + 100 98 | h = (f ∘ g)³ 99 | main = h(3)]], 100 | 333) 101 | test("main = (x → x + 1)(2)", 3) 102 | test("main = [1,2,3] vouw (+)", 6) 103 | test([[ 104 | f = x,y → y,x 105 | a = f(2, 3) 106 | main = a₀ 107 | ]], 3) 108 | 109 | test([[ 110 | sgn = x → y 111 | 112 | als x < 0 dan 113 | y = -1 114 | anders 115 | y = 1 116 | end 117 | 118 | main = sgn 3 119 | ]], 1) 120 | 121 | test('main = -3' --[[ 122 | main = itoa(atoi(itoa(atoi(itoa(atoi(itoa(-3))))))) 123 | 124 | ; text -> integer 125 | atoi = b → i 126 | ; negatief? 127 | als b₀ = '-' dan 128 | sign = -1 129 | tekens = b vanaf 1 130 | anders 131 | sign = 1 132 | tekens = b 133 | eind 134 | 135 | ; cijfers van de text 136 | cijfers = tekens map (t → t - '0') 137 | cijfers = tekens zip1 ('0') map (-) 138 | 139 | ; waarde van elk cijfer gegeven de positie 140 | waarde = (k → cijfers(j) · 10^k) 141 | j = #tekens - k - 1 142 | 143 | ; positie en resultaat 144 | pos = 0 .. #tekens 145 | i = sign · Σ (pos map waarde) 146 | 147 | ; integer -> text 148 | itoa = x → a 149 | n = 1 + ⌊log10(max(abs x, 1))⌋ 150 | als x < 0 dan 151 | neg = "-" 152 | anders 153 | neg = "" 154 | eind 155 | a = neg ‖ ((n .. 0) map cijfer) 156 | geschaald = (abs x)/10^m 157 | cijfer = m → '0' + ⌊geschaald mod 10⌋ 158 | ]], -3) 159 | 160 | print('alles ok') 161 | -------------------------------------------------------------------------------- /socket/main.c: -------------------------------------------------------------------------------- 1 | #define _POSIX_C_SOURCE 199309L 2 | #ifdef _WIN32 //defined(_MSC_VER) 3 | #define EXPORT __declspec(dllexport) 4 | #define IMPORT __declspec(dllimport) 5 | #elif defined(__GNUC__) 6 | #define EXPORT __attribute__((visibility("default"))) 7 | #define IMPORT 8 | #else 9 | #define EXPORT 10 | #define IMPORT 11 | #pragma warning Hoe te exporteren? 12 | #endif 13 | 14 | 15 | #include 16 | #include 17 | 18 | #include 19 | #include 20 | #include 21 | #include 22 | #include 23 | 24 | 25 | // meta 26 | int socket_tostring(lua_State* L) { 27 | int sock = *(int*) luaL_checkudata(L, 1, "socket"); 28 | lua_pushfstring(L, "socket %d", sock); 29 | return 1; 30 | } 31 | 32 | int socket_gc(lua_State* L) { 33 | int sock = *(int*) luaL_checkudata(L, 1, "socket"); 34 | close(sock); 35 | return 0; 36 | } 37 | 38 | int socket_accept(lua_State* L) { 39 | int server = *(int*) luaL_checkudata(L, 1, "socket"); 40 | int client = accept(server, 0, 0); 41 | 42 | int* luaclient = lua_newuserdata(L, sizeof(int)); 43 | *luaclient = client; 44 | 45 | luaL_newmetatable(L, "socket"); 46 | lua_setmetatable(L, -2); 47 | 48 | return 1; 49 | } 50 | 51 | int socket_bind(lua_State* L) { 52 | const char* ip = luaL_checkstring(L, 1); 53 | int port = luaL_checkint(L, 2); 54 | 55 | int sock = socket(AF_INET, SOCK_STREAM, 0); 56 | 57 | int* luasock = lua_newuserdata(L, sizeof(int)); 58 | *luasock = sock; 59 | 60 | luaL_newmetatable(L, "socket"); 61 | lua_setmetatable(L, -2); 62 | 63 | return 1; 64 | } 65 | 66 | int socket_select(lua_State* L) { 67 | int nfds = 0; 68 | fd_set read; 69 | fd_set write; 70 | struct timeval time; 71 | 72 | FD_ZERO(&read); 73 | FD_ZERO(&write); 74 | struct timeval* ptime = 0; 75 | 76 | // read 77 | if (!lua_isnil(L, 1)) { 78 | luaL_checktype(L, 1, LUA_TTABLE); 79 | lua_pushvalue(L, 1); 80 | 81 | lua_pushnil(L); 82 | while (lua_next(L, -2)) { 83 | if (lua_isuserdata(L, -1)) { 84 | int sock = *(int*) lua_touserdata(L, -2); 85 | FD_SET(sock, &read); 86 | nfds ++; 87 | } 88 | } 89 | lua_pop(L, 1); 90 | } 91 | 92 | // write 93 | if (!lua_isnil(L, 2)) { 94 | luaL_checktype(L, 2, LUA_TTABLE); 95 | lua_pushvalue(L, 2); 96 | 97 | lua_pushnil(L); 98 | while (lua_next(L, -2)) { 99 | if (lua_isuserdata(L, -1)) { 100 | int sock = *(int*) lua_touserdata(L, -2); 101 | FD_SET(sock, &write); 102 | nfds ++; 103 | } 104 | } 105 | lua_pop(L, 1); 106 | } 107 | 108 | // time 109 | if (!lua_isnil(L, 3)) { 110 | ptime = &time; 111 | time.tv_sec = luaL_checknumber(L, 3); 112 | time.tv_usec = fmod(luaL_checknumber(L, 3), 1.0) / 1e6; 113 | } 114 | 115 | // daar is ie dan 116 | select(nfds, &read, &write, 0, ptime); 117 | 118 | 119 | // deel 2: extract 120 | 121 | return 0; 122 | } 123 | 124 | EXPORT int luaopen_socket(lua_State* L) { 125 | // static socket funcs 126 | luaL_Reg funcs[] = { 127 | {"bind", socket_bind }, 128 | {"select", socket_select }, 129 | { 0, 0 }, 130 | }; 131 | lua_newtable(L); 132 | luaL_register(L, NULL, funcs); 133 | lua_setglobal(L, "socket"); 134 | 135 | // socket index 136 | luaL_Reg index[] = { 137 | {"accept", socket_accept}, 138 | {0, 0}, 139 | }; 140 | 141 | // socket meta 142 | luaL_Reg meta[] = { 143 | {"__gc", socket_gc }, 144 | {"__tostring", socket_tostring }, 145 | {0, 0}, 146 | }; 147 | luaL_newmetatable(L, "socket"); 148 | luaL_register(L, NULL, meta); 149 | 150 | lua_newtable(L); 151 | luaL_register(L, NULL, index); 152 | lua_setfield(L, -2, "__index"); 153 | 154 | return 0; 155 | } 156 | -------------------------------------------------------------------------------- /web/www/webgl.js: -------------------------------------------------------------------------------- 1 | 2 | function shaderProgram(args) { 3 | var gl = args[0]; 4 | var vertCode = args[1][0]; 5 | var fragCode = args[1][1]; 6 | 7 | var vertCode = 8 | 'attribute vec2 coordinates;' + 9 | 'void main(void) {' + ' gl_Position = vec4(coordinates,0.0, 1.0);' + '}'; 10 | 11 | //Create a vertex shader object 12 | var vertShader = gl.createShader(gl.VERTEX_SHADER); 13 | gl.shaderSource(vertShader, vertCode); 14 | gl.compileShader(vertShader); 15 | 16 | //Fragment shader source code 17 | var fragCode = 'void main(void) {' + 'gl_FragColor = vec4(0.0, 0.0, 0.0, 0.1);' + '}'; 18 | 19 | var fragShader = gl.createShader(gl.FRAGMENT_SHADER); 20 | gl.shaderSource(fragShader, fragCode); 21 | gl.compileShader(fragShader); 22 | 23 | // Create a shader program object to store combined shader program 24 | var shaderProgram = gl.createProgram(); 25 | 26 | gl.attachShader(shaderProgram, vertShader); 27 | gl.attachShader(shaderProgram, fragShader); 28 | gl.linkProgram(shaderProgram); 29 | gl.useProgram(shaderProgram); 30 | 31 | /* Step 4: Associate the shader programs to buffer objects */ 32 | 33 | gl.bindBuffer(gl.ARRAY_BUFFER, vertex_buffer); 34 | 35 | var coord = gl.getAttribLocation(shaderProgram, "coordinates"); 36 | 37 | //point an attribute to the currently bound VBO 38 | gl.vertexAttribPointer(coord, 2, gl.FLOAT, false, 0, 0); 39 | 40 | gl.enableVertexAttribArray(coord); 41 | 42 | return shaderProgram; 43 | } 44 | 45 | function drawModel(gl) { 46 | // Clear the canvas 47 | gl.clearColor(0.5, 0.5, 0.5, 0.9); 48 | 49 | gl.enable(gl.DEPTH_TEST); 50 | gl.clear(gl.COLOR_BUFFER_BIT); 51 | gl.viewport(0,0,1280,720); 52 | 53 | gl.drawArrays(gl.TRIANGLES, 0, 3); 54 | 55 | return gl; 56 | } 57 | 58 | function MODEL(args) { 59 | var gl = window.gl; 60 | var positions = new Float32Array(args[0]); 61 | var indices = new Int32Array(args[1]); 62 | 63 | if (!window.J) { 64 | window.J = true; 65 | } 66 | 67 | g_vbo = gl.createBuffer(); 68 | g_elementVbo = gl.createBuffer(); 69 | 70 | // punten 71 | gl.bindBuffer(gl.ARRAY_BUFFER, g_vbo); 72 | gl.bufferData(gl.ARRAY_BUFFER, positions.length * 4, gl.STATIC_DRAW); 73 | gl.bufferSubData(gl.ARRAY_BUFFER, 0, positions); 74 | 75 | // indices 76 | gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, g_elementVbo); 77 | gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, indices.length * 4, gl.STATIC_DRAW); 78 | gl.bufferSubData(gl.ELEMENT_ARRAY_BUFFER, 0, indices); 79 | g_numElements = indices.length; 80 | 81 | gl.viewport(0, 0, 180, 100); 82 | gl.enable(gl.DEPTH_TEST); 83 | 84 | // errors 85 | var e = gl.getError(); 86 | if (e != gl.NO_ERROR && e != gl.CONTEXT_LOST_WEBGL) 87 | uit.innerHTML = 'opengl error ' + e; 88 | 89 | return ((args) => { 90 | gl.clearColor(1,1,0,1); 91 | gl.clear(gl.COLOR_BUFFER_BIT); //| gl.DEPTH_BUFFER_BIT); 92 | gl.viewport(0, 0, 180, 100); 93 | 94 | // Bind and set up vertex streams 95 | gl.bindBuffer(gl.ARRAY_BUFFER, g_vbo); 96 | gl.vertexAttribPointer(0, 3, gl.FLOAT, false, 0, 0); 97 | gl.enableVertexAttribArray(0); 98 | gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, g_elementVbo); 99 | gl.enableVertexAttribArray(1); 100 | 101 | if (!window.A) { 102 | gl.drawElements(gl.TRIANGLES, g_numElements, gl.UNSIGNED_SHORT, 0); 103 | window.A = true; 104 | } 105 | 106 | // errors 107 | var e = gl.getError(); 108 | if (e != gl.NO_ERROR && e != gl.CONTEXT_LOST_WEBGL) 109 | uit.innerHTML = 'opengl error ' + e; 110 | 111 | return gl; 112 | }); 113 | } 114 | -------------------------------------------------------------------------------- /ex/voer.code: -------------------------------------------------------------------------------- 1 | ;;;;;;;;;;;;;;;;;;;; SPEL LOGICA ;;;;;;;;;;;;;;;;;;;; 2 | 3 | bord := [0]^42 4 | aanzet := ja 5 | status := "aan zet" 6 | klaar := nee 7 | 8 | ckleur = palet(bord(y·7+x)) 9 | palet = [kleur.zwart, kleur.rood, kleur.geel, kleur.groen] 10 | 11 | ; kan de zet? 12 | kanzet = kbord,kx → (kbord(kx + 7·5) = 0) 13 | doezet = dbord,dx,dkleur → dbord0 14 | als kanzet(dbord,dx) dan 15 | dbord0 = newindex(dbord, dx + dy·7, dkleur) 16 | anders 17 | dbord0 = newindex(dbord, 0, 3) 18 | eind 19 | 20 | dy = (|)[ (dbord(dx)=0 ⇒ 0), (dbord(dx+7)=0 ⇒ 1), (dbord(dx+14)=0 ⇒ 2), (dbord(dx+21)=0 ⇒ 3), (dbord(dx+28)=0 ⇒ 4), (dbord(dx+35)=0 ⇒ 5) ] 21 | 22 | als aanzet dan 23 | kleur = 1 24 | anders 25 | kleur = 2 26 | eind 27 | 28 | als wint(bord,1) dan 29 | status := "rood heeft gewonnen" 30 | klaar := ja 31 | eind 32 | als wint(bord,2) dan 33 | status := "geel heeft gewonnen" 34 | klaar := ja 35 | eind 36 | 37 | 38 | ; wint er iemand ? 39 | wint = wbord,ws → (hwint of vwint of dwint of rwint) 40 | 41 | hindices = (0..4 × (0..6 · 7)) map (+) 42 | vindices = (0..7 × (0..3 · 7)) map (+) 43 | dindices = (0..4 × (0..3 · 7)) map (+) 44 | rindices = (3..7 × (0..3 · 7)) map (+) 45 | 46 | hwint = ⋁ hindices map hwint0 47 | vwint = ⋁ vindices map vwint0 48 | dwint = ⋁ dindices map dwint0 49 | rwint = ⋁ rindices map rwint0 50 | 51 | hwint0 = hs → (wbord(hs)=ws en wbord(hs+1)=ws en wbord(hs+2)=ws en wbord(hs+3)=ws) 52 | vwint0 = vs → (wbord(vs)=ws en wbord(vs+7)=ws en wbord(vs+14)=ws en wbord(vs+21)=ws) 53 | dwint0 = ds → (wbord(ds)=ws en wbord(ds+8)=ws en wbord(ds+16)=ws en wbord(ds+24)=1) 54 | rwint0 = rs → (wbord(rs)=ws en wbord(rs+6)=ws en wbord(rs+12)=ws en wbord(rs+18)=1) 55 | 56 | ;;;;;;;;;;;;;;;;;;;; GUI ;;;;;;;;;;;;;;;;;;;; 57 | 58 | ; speler dropt coin 59 | als ¬ klaar en muis.klik.begin en aanzet dan 60 | bord := doezet(bord, xsnap, 1) 61 | status := "denken..." 62 | aanzet := nee 63 | nadenktot := nu + 0.1 64 | prev := nu + 0.1 65 | eind 66 | 67 | 68 | ; computer dropt coin 69 | klaar := nee 70 | nadenktot := nu 71 | bz := 0 72 | prev := nu 73 | denktijd := 0 74 | 75 | als ¬ klaar en ¬ aanzet en nu > nadenktot dan 76 | ;scores := bscores 77 | bord := doezet(bord, bestezet(bord,2), 2) 78 | status := "aan zet" 79 | aanzet := ja 80 | denktijd := klok(X → bestezet(bord,2)) 81 | ;scores := (0..7 × 0..7) map (I0,J0 → score(Bbord1)) 82 | eind 83 | 84 | ;Bbord1 = doezet(doezet(bbord,I0,2),J0,1) 85 | 86 | 87 | 88 | ;;;;;;;;;;;;;;;;;;;; AI ;;;;;;;;;;;;;;;;;;;; 89 | 90 | ; beste zet berekenen 91 | bestezet = bbord,bspeler → bzet 92 | 93 | scores = (0..7) map (ii → score(bbord,ii)) 94 | bzet = maxindex scores 95 | 96 | ;scoorzet2 = (I → score(doezet(bord,I,2),2)) 97 | ;scoorzet1 = (J → 1000-score(doezet(bord,J,1),1)) 98 | 99 | ; score berekenen 100 | score = sbord,szet → predefscores(szet) 101 | 102 | predefscores = [3, 4, 5, 7, 5, 4, 3] 103 | 104 | 105 | 106 | ;;;;;;;;;;;;;;;;;;;; TEKENEN ;;;;;;;;;;;;;;;;;;;; 107 | 108 | xmod = ⌊(muis.x-30) / 15⌋ 109 | xsnap = klem(xmod, 0, 6) 110 | xdraw = 30 + xsnap · 15 + 7.5 111 | 112 | ; teken 113 | blauwbord = rechthoek((29,0),(135,90)) verf kleur.blauw 114 | selectie = cirkel(xdraw, 95, 3) verf (palet(2 - kleur)) 115 | stuk = cirkel(x·15+37,y·15+7,7) verf ckleur 116 | stukken = (0..7 × 0..6) map (x,y → stuk) 117 | 118 | statuslabel = label(0,90,status) 119 | infolabel1 = label(0,80,"wint(1) = " ‖ tekst(wint(bord,1))) 120 | infolabel2 = label(0,75,"wint(2) = " ‖ tekst(wint(bord,2))) 121 | infolabel3 = label(0,70,"score = " ‖ tekst(score(bord,0))) 122 | infolabel4 = label(0,65,"denktijd = " ‖ tekst(denktijd)) 123 | 124 | uit = teken ([blauwbord] ‖ stukken ‖ [selectie, statuslabel, infolabel1, infolabel2, infolabel3, infolabel4]) 125 | 126 | 127 | 128 | 129 | 130 | 131 | 132 | 133 | 134 | 135 | -------------------------------------------------------------------------------- /fout.lua: -------------------------------------------------------------------------------- 1 | require 'util' 2 | require 'exp' 3 | 4 | -- fmt: {rood} is {exp} maar moet {cyaan} zijn 5 | function fout(type, loc, fmt, ...) 6 | -- Typefout: a is int (loc1) maar moet text zijn (loc2) 7 | local t = { 8 | loc = loc, 9 | type = assert(type), 10 | fmt = assert(fmt), 11 | args = {...}, 12 | } 13 | return t 14 | end 15 | 16 | -- loc, fmt, ... 17 | function executiefout(...) return fout("executie", ...) end 18 | function syntaxerror(...) return fout("syntax", ...) end 19 | function solvefout(...) return fout("solve", ...) end 20 | function typifyfout(...) return fout("typify", ...) end 21 | 22 | function jsloc(loc) 23 | loc = loc or nergens 24 | local jloc = { 25 | anchor = { 26 | ch = loc.x1 - 1, 27 | line = loc.y1 - 1, 28 | }, 29 | head = { 30 | ch = loc.x2 - 1, 31 | line = loc.y2 - 1, 32 | }, 33 | source = loc.bron, 34 | } 35 | return jloc 36 | end 37 | 38 | -- → {loc: loc, html: demohtml} 39 | function fout2json(fout) 40 | local hfout = {} 41 | hfout.loc = jsloc(fout.loc) 42 | hfout.type = fout.type 43 | 44 | local i = 0 45 | local t = fout.args 46 | local html = fout.fmt:gsub('{([^}]*)}', function (spec) 47 | i = i + 1 48 | if spec == 'loc' then 49 | return '' .. loctext(t[i]) .. '' 50 | elseif spec == 'rood' then 51 | return ''.. t[i] .. '' 52 | elseif spec == 'code' then 53 | return '' .. tostring(t[i]) .. '' 54 | elseif spec == 'exp' then 55 | return '' .. deparse(t[i]) .. '' 56 | elseif spec == 'int' then 57 | return tostring(math.floor(t[i])) 58 | elseif spec == 'cyaan' then 59 | return '' .. tostring(t[i]) .. '' 60 | else 61 | error('onbekend type: '..spec) 62 | end 63 | end 64 | ) 65 | hfout.html = html 66 | return hfout 67 | end 68 | 69 | function fout2ansi(fout) 70 | local loc = ansi.underline .. loctext(fout.loc) .. ansi.normal 71 | local type = color.brightred .. fout.type:gsub('^(.)', string.upper) .. 'fout' .. color.white .. ': ' 72 | local i = 0 73 | local t = fout.args 74 | local ansi = loc .. '\t' .. type .. '\t' .. fout.fmt:gsub('{([^}]*)}', function (spec) 75 | i = i + 1 76 | if spec == 'loc' then 77 | return ansi.underline .. loctext(t[i]) .. ansi.normal 78 | elseif spec == 'rood' then 79 | return color.brightred .. t[i] .. color.white 80 | elseif spec == 'code' then 81 | return color.brightyellow .. tostring(t[i]) .. color.white 82 | elseif spec == 'exp' then 83 | return color.brightcyan .. deparse(t[i]) .. color.white 84 | elseif spec == 'int' then 85 | return tostring(math.floor(t[i])) 86 | elseif spec == 'cyaan' then 87 | return color.brightcyan .. tostring(t[i]) .. color.white 88 | else 89 | error('onbekend type: '..spec) 90 | end 91 | end 92 | ) 93 | return ansi 94 | end 95 | 96 | function fout2string(fout) 97 | local loc = loctext(fout.loc) 98 | local type = fout.type:gsub('^(.)', string.upper) .. 'fout' .. ': ' 99 | local i = 0 100 | local t = fout.args 101 | local string = loc .. '\t' .. type .. '\t' .. fout.fmt:gsub('{([^}]*)}', function (spec) 102 | i = i + 1 103 | if spec == 'loc' then 104 | return loctext(t[i]) 105 | elseif spec == 'rood' then 106 | return t[i] 107 | elseif spec == 'code' then 108 | return tostring(t[i]) 109 | elseif spec == 'exp' then 110 | return deparse(t[i]) 111 | elseif spec == 'int' then 112 | return tostring(math.floor(t[i])) 113 | elseif spec == 'cyaan' then 114 | return tostring(t[i]) 115 | else 116 | error('onbekend type: '..spec) 117 | end 118 | end 119 | ) 120 | return string 121 | end 122 | 123 | --[[ 124 | solve 125 | type 126 | zelftest 127 | executie 128 | ]] 129 | 130 | -- f[#f+1] = fout("solve", "{code} is {type} ({loc}) maar moet {type} ({loc}) zijn") 131 | -------------------------------------------------------------------------------- /asm/win/win.c: -------------------------------------------------------------------------------- 1 | #ifndef UNICODE 2 | #define UNICODE 3 | #endif 4 | 5 | #include 6 | 7 | LRESULT CALLBACK WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam); 8 | 9 | int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hInstance2, PSTR pCmdLine, int nCmdShow) 10 | { 11 | // Register the window class. 12 | const wchar_t CLASS_NAME[] = L"Metamine"; 13 | 14 | WNDCLASS wc = { }; 15 | 16 | wc.lpfnWndProc = WindowProc; 17 | wc.hInstance = hInstance; 18 | wc.lpszClassName = CLASS_NAME; 19 | wc.hIcon = LoadIcon(NULL, IDI_APPLICATION); 20 | wc.hCursor = LoadIcon(NULL, IDC_ARROW); 21 | 22 | SetConsoleOutputCP(CP_UTF8); 23 | WriteConsole(GetStdHandle(STD_OUTPUT_HANDLE), L"hoi", 3, NULL, 0); 24 | 25 | unsigned int num; 26 | WriteConsole(GetStdHandle(STD_OUTPUT_HANDLE), L"hoi\n", 4, &num, 0); 27 | 28 | RegisterClass(&wc); 29 | 30 | // Create the window. 31 | 32 | HWND hwnd = CreateWindowEx( 33 | 0, // Optional window styles. 34 | CLASS_NAME, // Window class 35 | L"Metamine", // Window text 36 | WS_OVERLAPPEDWINDOW, // Window style 37 | 38 | // Size and position 39 | CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, 40 | 41 | NULL, // Parent window 42 | NULL, // Menu 43 | hInstance, // Instance handle 44 | NULL // Additional application data 45 | ); 46 | 47 | if (hwnd == NULL) 48 | { 49 | return 0; 50 | } 51 | 52 | unsigned long long int n = 1; 53 | SetTimer(hwnd, &n, 16, 0); 54 | 55 | ShowWindow(hwnd, nCmdShow); 56 | 57 | // Run the message loop. 58 | 59 | MSG msg = { }; 60 | while (GetMessage(&msg, NULL, 0, 0)) 61 | { 62 | TranslateMessage(&msg); 63 | DispatchMessage(&msg); 64 | } 65 | 66 | return 0; 67 | } 68 | 69 | int muisX = 0; 70 | int muisY = 0; 71 | int i = 0; 72 | float looptijd = 0.0f; 73 | 74 | LRESULT CALLBACK WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) 75 | { 76 | switch (uMsg) 77 | { 78 | case WM_DESTROY: 79 | PostQuitMessage(0); 80 | return 0; 81 | 82 | case WM_MOUSEMOVE: 83 | { 84 | muisX = LOWORD(lParam); 85 | muisY = HIWORD(lParam); 86 | return 0; 87 | } 88 | 89 | case WM_PAINT: 90 | { 91 | PAINTSTRUCT ps; 92 | HDC hdc = BeginPaint(hwnd, &ps); 93 | 94 | FillRect(hdc, &ps.rcPaint, (HBRUSH) (COLOR_WINDOW+3)); 95 | 96 | // draw text 97 | RECT rect; 98 | GetClientRect(hwnd, &rect); 99 | wchar_t * text = L"Schaak ♞"; 100 | DrawTextW(hdc, text, -1, &rect, DT_CENTER | DT_VCENTER); 101 | 102 | // draw poly 103 | HBRUSH hBrush = CreateSolidBrush(RGB(200,0,50)); 104 | SelectObject(hdc, hBrush); 105 | POINT x = {0, 0}; 106 | POINT y = {muisX, muisY}; 107 | POINT z = { + 100, looptijd * 1.0f + 500}; //muisX, muisY}; 108 | looptijd = looptijd + 1.0f/60.0f; 109 | i ++; 110 | POINT w = {0, looptijd / 10}; 111 | POINT pt[] = {x, y, z, w}; 112 | SetPolyFillMode(hdc, WINDING); 113 | Polygon(hdc, pt, 4); 114 | 115 | EndPaint(hwnd, &ps); 116 | ReleaseDC(hwnd, hdc); 117 | 118 | } 119 | return 0; 120 | 121 | case WM_KEYDOWN: 122 | WriteConsole(GetStdHandle(STD_OUTPUT_HANDLE), "hoi", 3, NULL, 0); 123 | return 0; 124 | 125 | case WM_TIMER: 126 | { 127 | InvalidateRect(hwnd, NULL, 0); 128 | RedrawWindow(hwnd, NULL, NULL, RDW_INVALIDATE | RDW_UPDATENOW); 129 | unsigned int n = 1; 130 | SetTimer(hwnd, 0, 16, NULL); 131 | return 0; 132 | } 133 | } 134 | return DefWindowProc(hwnd, uMsg, wParam, lParam); 135 | } 136 | -------------------------------------------------------------------------------- /asm/xcb2.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | #include 5 | 6 | int 7 | main () 8 | { 9 | xcb_connection_t *c; 10 | xcb_screen_t *screen; 11 | xcb_drawable_t win; 12 | xcb_gcontext_t foreground; 13 | xcb_generic_event_t *e; 14 | uint32_t mask = 0; 15 | uint32_t values[2]; 16 | 17 | /* geometric objects */ 18 | xcb_point_t points[] = { 19 | {10, 10}, 20 | {10, 20}, 21 | {20, 10}, 22 | {20, 20}}; 23 | 24 | xcb_point_t polyline[] = { 25 | {500, 100}, 26 | { 50, 200}, /* rest of points are relative */ 27 | {250,-200}, 28 | {100, 100}}; 29 | 30 | xcb_segment_t segments[] = { 31 | {100, 10, 140, 30}, 32 | {110, 25, 130, 60}}; 33 | 34 | xcb_rectangle_t rectangles[] = { 35 | { 10, 50, 40, 20}, 36 | { 80, 50, 10, 40}}; 37 | 38 | xcb_arc_t arcs[] = { 39 | {10, 100, 60, 40, 0, 90 << 6}, 40 | {90, 100, 55, 40, 0, 270 << 6}}; 41 | 42 | /* Open the connection to the X server */ 43 | c = xcb_connect (NULL, NULL); 44 | 45 | /* Get the first screen */ 46 | screen = xcb_setup_roots_iterator (xcb_get_setup (c)).data; 47 | 48 | /* Create black (foreground) graphic context */ 49 | win = screen->root; 50 | 51 | foreground = xcb_generate_id (c); 52 | mask = XCB_GC_FOREGROUND | XCB_GC_GRAPHICS_EXPOSURES; 53 | values[0] = screen->black_pixel; 54 | values[1] = 0; 55 | xcb_create_gc (c, foreground, win, mask, values); 56 | 57 | /* Ask for our window's Id */ 58 | win = xcb_generate_id(c); 59 | 60 | /* Create the window */ 61 | mask = XCB_CW_BACK_PIXEL | XCB_CW_EVENT_MASK; 62 | values[0] = screen->white_pixel; 63 | values[1] = XCB_EVENT_MASK_EXPOSURE; 64 | xcb_create_window (c, /* Connection */ 65 | XCB_COPY_FROM_PARENT, /* depth */ 66 | win, /* window Id */ 67 | screen->root, /* parent window */ 68 | 0, 0, /* x, y */ 69 | 150, 150, /* width, height */ 70 | 10, /* border_width */ 71 | XCB_WINDOW_CLASS_INPUT_OUTPUT, /* class */ 72 | screen->root_visual, /* visual */ 73 | mask, values); /* masks */ 74 | 75 | /* Map the window on the screen */ 76 | xcb_map_window (c, win); 77 | 78 | 79 | /* We flush the request */ 80 | xcb_flush (c); 81 | 82 | while ((e = xcb_wait_for_event (c))) { 83 | printf("event %d\n\n", e->response_type); 84 | switch (e->response_type & ~0x80) { 85 | case XCB_EXPOSE: { 86 | /* We draw the points */ 87 | xcb_poly_point (c, XCB_COORD_MODE_ORIGIN, win, foreground, 4, points); 88 | 89 | /* We draw the polygonal line */ 90 | //xcb_poly_line (c, XCB_COORD_MODE_PREVIOUS, win, foreground, 4, polyline); 91 | xcb_fill_poly(c, win, foreground, XCB_POLY_SHAPE_COMPLEX, XCB_COORD_MODE_PREVIOUS, 4, polyline); 92 | 93 | /* We draw the segements */ 94 | xcb_poly_segment (c, win, foreground, 2, segments); 95 | 96 | /* We draw the rectangles */ 97 | xcb_poly_rectangle (c, win, foreground, 2, rectangles); 98 | 99 | /* We draw the arcs */ 100 | xcb_poly_arc (c, win, foreground, 2, arcs); 101 | 102 | /* We flush the request */ 103 | xcb_flush (c); 104 | 105 | break; 106 | } 107 | default: { 108 | /* Unknown event type, ignore it */ 109 | break; 110 | } 111 | } 112 | /* Free the Generic Event */ 113 | free (e); 114 | } 115 | 116 | return 0; 117 | } 118 | --------------------------------------------------------------------------------