wasm-glue example

Open console ↓

19 |

20 | 21 |

22 |

23 | 24 |

25 |

	// keep a WebAssembly memory reference for `readString`
	let memory;

	// read a null terminated c string at a wasm memory buffer index
	function readString(ptr) {
	const view = new Uint8Array(memory.buffer);

	// find the end of the string (null)
	let end = ptr;
	while (view[end]) ++end;

	// `subarray` uses the same underlying ArrayBuffer as the view
	const buf = new Uint8Array(view.subarray(ptr, end));
	const str = (new TextDecoder()).decode(buf); // (utf-8 by default)

	return str;
	}

	// necessary imports under the `env` namespace (rust looks for exports here)
	//
	// `wasm_glue::hook()` requires all three
	const imports = {
	env: {
	// needed for `wasm_glue::set_stdout()` or `#[macro_use(print)]`
	print(ptr) {
	// sidenote: this doesn't have to be a console.log(). You could put
	// this up in the html too if you wanted.
	console.log(readString(ptr));
	},

	// needed for `wasm_glue::set_stderr()` or `#[macro_use(eprint)]`
	eprint(ptr) {
	console.warn(readString(ptr));
	},

	// needed for `wasm_glue::set_panic_hook()`
	trace(ptr) {
	const err = new Error(readString(ptr));
	// here is where you could demangle the stack trace with:
	// https://github.com/demille/wasm-ffi/blob/master/src/demangle.js
	throw err;
	},
	},
	};

	// fetch and instantiate the wasm module
	fetch('example.wasm')
	.then(response => response.arrayBuffer())
	.then(buffer => WebAssembly.instantiate(buffer, imports))
	.then((result) => {
	console.log('wasm loaded!: ', result);
	const exports = result.instance.exports;

	// update memory reference for readString
	memory = exports.memory;

	// wasm_glue::hook() need to be called before anything that will print
	exports.hook();

	// wasm calls: imports.env.print()
	exports.print_add(2, 2);

	// wasm calls: imports.env.eprint()
	exports.print_err_msg();

	// wasm panic will trigger: imports.env.trace()
	exports.cause_panic();
	})
	.catch(err => setTimeout(() => { throw err; }));

	extern crate wasm_glue;

	// hook up stdout and stderr. do this first.
	#[no_mangle]
	pub fn hook() {
	wasm_glue::hook();
	}

	#[no_mangle]
	pub fn print_add(a: u32, b: u32) {
	println!("{} + {} = {}", a, b, a + b);
	}

	#[no_mangle]
	pub fn print_err_msg() {
	eprintln!(r"Danger! Danger! /!\\");
	}

	#[no_mangle]
	pub fn cause_panic() {
	None::<Option<u32>>.unwrap();
	}

{ 89 | self.buffer.push_str(&String::from_utf8_lossy(buf)); 90 | 91 | if !self.is_buffered { 92 | (self.printfn)(&self.buffer)?; 93 | self.buffer.clear(); 94 | 95 | return Ok(buf.len()); 96 | } 97 | 98 | if let Some(i) = self.buffer.rfind('\n') { 99 | let buffered = { 100 | let (first, last) = self.buffer.split_at(i); 101 | (self.printfn)(first)?; 102 | 103 | String::from(&last[1..]) 104 | }; 105 | 106 | self.buffer.clear(); 107 | self.buffer.push_str(&buffered); 108 | } 109 | 110 | Ok(buf.len()) 111 | } 112 | 113 | fn flush(&mut self) -> io::Result<()> { 114 | (self.printfn)(&self.buffer)?; 115 | self.buffer.clear(); 116 | 117 | Ok(()) 118 | } 119 | } 120 | 121 | 122 | /// Sets a line-buffered stdout, uses your JavaScript `print` function 123 | pub fn set_stdout() { 124 | let printer = Printer::new(_print, true); 125 | io::set_print(Some(Box::new(printer))); 126 | } 127 | 128 | /// Sets an unbuffered stdout, uses your JavaScript `print` function 129 | pub fn set_stdout_unbuffered() { 130 | let printer = Printer::new(_print, false); 131 | io::set_print(Some(Box::new(printer))); 132 | } 133 | 134 | /// Sets a line-buffered stderr, uses your JavaScript `eprint` function 135 | pub fn set_stderr() { 136 | let eprinter = Printer::new(_eprint, true); 137 | io::set_panic(Some(Box::new(eprinter))); 138 | } 139 | 140 | /// Sets an unbuffered stderr, uses your JavaScript `eprint` function 141 | pub fn set_stderr_unbuffered() { 142 | let eprinter = Printer::new(_eprint, false); 143 | io::set_panic(Some(Box::new(eprinter))); 144 | } 145 | 146 | /// Sets a custom panic hook, uses your JavaScript `trace` function 147 | pub fn set_panic_hook() { 148 | panic::set_hook(Box::new(|info| { 149 | let file = info.location().unwrap().file(); 150 | let line = info.location().unwrap().line(); 151 | let col = info.location().unwrap().column(); 152 | 153 | let msg = match info.payload().downcast_ref::<&'static str>() { 154 | Some(s) => *s, 155 | None => { 156 | match info.payload().downcast_ref::() { 157 | Some(s) => &s[..], 158 | None => "Box", 159 | } 160 | } 161 | }; 162 | 163 | let err_info = format!("Panicked at '{}', {}:{}:{}", msg, file, line, col); 164 | let cstring = CString::new(err_info).unwrap(); 165 | 166 | unsafe { 167 | trace(cstring.as_ptr()); 168 | } 169 | })); 170 | } 171 | 172 | /// Sets stdout, stderr, and a custom panic hook 173 | pub fn hook() { 174 | set_stdout(); 175 | set_stderr(); 176 | set_panic_hook(); 177 | } 178 | --------------------------------------------------------------------------------