wac
1.0.0
Un interpréteur Minimal WebAssembly écrit en C. Prend en charge la version WebAssembly MVP (minimum viable product) de la spécification WebAssembly.
Il existe trois versions différentes de wac :
wat2wasm ou wasm-as . Réussit la plupart des tests de spécifications, à l'exception de certains tests d'importation/exportation multi-modules.-s SIDE_MODULE=1 -s LEGALIZE_JS_FFI=0 ). Pour construire wac/wax/wace, vous avez besoin d'une version 32 bits de gcc et des versions 32 bits de SDL2 et libedit. Sur Ubuntu/Debian 64 bits, ceux-ci peuvent être installés comme ceci :
dpkg --add-architecture i386
apt-get update
apt-get install lib32gcc-4.9-dev libSDL2-dev:i386 libedit-dev:i386
Pour compiler les fichiers sources Wat en modules binaires Wasm, vous aurez besoin du programme wasm-as de Binaryen. Pour compiler des programmes C en modules wasm, vous aurez besoin de Binaryen et d'emscripten.
Comme alternative au téléchargement et à la création des outils ci-dessus, l'image docker kanaka/wac (1,7 Go) contient un compilateur/bibliothèques gcc 32 bits, des emscripten et des binaires préinstallés. L'image Docker peut être démarrée avec des montages de fichiers appropriés comme celui-ci :
docker run -v `pwd`:/wac -w /wac -it kanaka/wac bash
Toutes les commandes de construction ci-dessous peuvent être exécutées dans le conteneur Docker.
Construire WAC :
$ make wac Utilisez wasm-as pour compiler un programme wat simple en wasm :
$ make examples_wat/arith.wasmChargez maintenant le fichier wasm compilé et invoquez quelques fonctions :
$ ./wac examples_wat/arith.wasm add 2 3
0x5:i32
$ ./wac examples_wat/arith.wasm mul 7 8
0x38:i32 wac prend également en charge un mode REPL (read-eval-print-loop) très simple qui exécute des commandes sous la forme de FUNC ARG... :
$ ./wac --repl examples_wat/arith.wasm
> sub 10 5
0x5:i32
> div 13 4
0x3:i32
Construire de la cire :
$ make wax Utilisez wasm-as pour compiler un programme Wat qui utilise l'interface WASI :
$ make examples_wat/echo.wasmExécutez maintenant le fichier wasm compilé. Le programme lit le texte depuis stdin et le renvoie sur stdout jusqu'à ce qu'un EOF (Ctrl-D) soit envoyé.
$ ./wax examples_wat/echo.wasm
> foo
foo
> bar
bar
> < Ctrl-D > Construire du wace :
$ make waceUtilisez emscripten/binaryen pour compiler quelques programmes C simples et exécutez-les à l'aide de wace :
$ make examples_c/hello1.wasm
$ ./wace examples_c/hello1.wasm
hello world
$ make examples_c/hello2.wasm
$ ./wace examples_c/hello2.wasm
hello malloc peopleUtilisez emscripten/binaryen pour compiler certains programmes C SDL et exécutez-les à l'aide de wace :
$ make examples_c/hello_sdl.wasm
$ ./wace examples_c/hello_sdl.wasm
INFO: OpenGL shaders: ENABLED
INFO: Created renderer: opengl
# Blue Window displayed for 2 seconds
Done.
$ make examples_c/triangle.wasm
$ ./wace examples_c/triangle.wasm
# A colorfully shaded triangle is rendered wac inclut un pilote de test runtest.py qui peut être utilisé pour exécuter des tests à partir de la spécification WebAssembly.
Consultez les spécifications :
git clone https://github.com/WebAssembly/spec
Vous aurez besoin wat2wasm pour compiler les tests de spécifications. Extraire et construire wabt (wabbit) :
git clone --recursive https://github.com/WebAssembly/wabt
make -C wabt gcc-release
Exécutez le fichier de test func.wast (pour tester les appels de fonction) à partir de la spécification :
./runtest.py --wat2wasm ./wabt/out/gcc/Release/wat2wasm --interpreter ./wac spec/test/core/func.wast
Exécutez tous les tests de spécifications, à l'exception de quelques-uns qui échouent actuellement (principalement en raison du manque de prise en charge runtest.py de certaines syntaxes utilisées dans ces fichiers de test) :
BROKE_TESTS="comments exports imports linking names data elem inline-module"
for t in $(ls spec/test/core/*.wast | grep -Fv "${BROKE_TESTS// /$'n'}"); do
echo -e "nTESTING ${t}"
./runtest.py ${t} || break
done
wac et wace peuvent être construits pour s'exécuter en tant que programmes de démarrage autonomes en utilisant fooboot :
cd wac
git clone https://github.com/kanaka/fooboot
make PLATFORM=fooboot clean
make PLATFORM=fooboot wac wace examples_wat/addTwo.wasm
Le script fooboot/runfoo peut être utilisé pour démarrer wac/wace avec QEMU. fooboot/runfoo crée également une connexion sur un port série (COM2) qui permet de lire les fichiers depuis le système hôte :
fooboot/runfoo wac --repl examples_wat/addTwo.wasm
QEMU waiting for connection on: disconnected:tcp:localhost:21118,server
webassembly> addTwo 2 3
0x5:i32
Les versions wac/wace autonomes peuvent également être intégrées dans une image ISO qui peut démarrer directement sur du matériel réel. Vous aurez besoin de Grub 2 et des fichiers binaires Grub PC/BIOS (grub-pc-bin) ainsi que du programme xorriso pour pouvoir le faire. De plus, les modules wasm que vous souhaitez exécuter doivent être intégrés au binaire pour faire partie d'un simple système de fichiers en mémoire :
echo "examples_wat/addTwo.wasm" > mem_fs_files
make PLATFORM=fooboot
FOO_TARGETS="wac"
FOO_CMDLINE="examples_wat/addTwo.wasm addTwo 3 4"
boot.iso
Vous pouvez maintenant démarrer l'ISO avec QEMU comme ceci :
qemu-system-i386 -cdrom boot.iso
Ou vous pouvez graver l'ISO sur un périphérique USB et démarrer à partir de celui-ci sur du matériel réel. Cela détruira toutes les données présentes sur le périphérique USB ! Assurez-vous également que /dev/MY_USB_DEVICE est bien le périphérique USB que vous souhaitez écraser et non votre disque dur. Vous êtes prévenu !
sudo dd if=boot.iso of=/dev/MY_USB_DEVICE && sync
# Now boot you can boot from the USB device
MPL-2.0 (voir LICENCE).
