WebAssembly transform giving support for multi return values

100%

WebAssembly transform giving support for multi return values

✓ Published0🌍 Public

Last edited May 29, 2018

Created on May 29, 2018

This example demonstrates a WebAssembly transformation that rewrites WebAssembly text (WAT) modules to support multiple return values, a feature not natively supported. The code parses an input `.wat` file using `@webassemblyjs/wast-parser`, traverses and modifies the abstract syntax tree, and prints the result with `@webassemblyjs/wast-printer`. It calculates the maximum function return count, inserts global variables, and rewrites call sites, replacing multi-value returns with `set_global` and `get_global` instructions. The transform relies on the `traverse` API to visit `Func` and `CallInstruction` nodes.

AI-generated description

Similar vizzes

Loading thumbnail…

WebAssembly integer operations

This example demonstrates a JavaScript WebAssembly module that exports integer division and echo functions, highlighting a discrepancy between WebAssembly’s spec-defined `ToWebAssemblyValue` coercion and its inverse `ToJSValue` conversion for i32 values. It uses the WebAssembly JavaScript API’s `instantiate` and `instance.exports` to call compiled wasm functions, while manually implementing the ECMA-262 `ToInt32` algorithm and a guessed JavaScript conversion. The visualization presents console output comparing wasm results against equivalent JavaScript conversions, revealing that unsigned division produces different values due to overflow handling.

CColinEberhardt

60% match

Loading thumbnail…

Using WebAssembly in LLVM on Windows

This example demonstrates how to compile C code to WebAssembly on Windows using LLVM's experimental WebAssembly backend, and visualizes the intermediate and final artifacts generated at each stage of the toolchain. The source code defines a Fibonacci function in C, and the visualization walks through the transformation pipeline: C source (fib.c) → LLVM bitcode (fib.bc) → LLVM assembly (fib.s) → WebAssembly text format (fib.wast) → WebAssembly binary (fib.wasm). A hex dump of the resulting .wasm file shows the compiled binary, including the memory table and the fib function export. The gist includes commands for setting up the required tools—Git, Subversion, CMake, and Visual Studio—to build the necessary LLVM/Clang, Binaryen, and Wabt toolchain on Windows, along with a compile.bat script that automates the build steps.

AAntonio24

56% match

Loading thumbnail…

Gist 3745f53a79313afd139b4eb0a4e97bd2

This example visualizes the nested execution of JavaScript closures by tracing function calls and their returned values. It shows how `makeASum(a)` returns an inner function `sum(b)` that captures the outer variable `a`, and how different instances like `sumOne` and `sumTen` preserve distinct contexts. The rendering uses a custom SVG-based trace, likely driven by D3’s `d3.forceSimulation` for layout and `d3.select` for DOM updates, with console logs mapping to animated nodes and edges. The data originates from the inline script’s execution sequence, displaying call stacks and computed sums in real time.

MMistyBlunch

49% match

Loading thumbnail…

Freecodecamp

This example visualizes the process of refactoring a JavaScript function that returns the largest number from each sub-array in a nested array. It shows three successive code versions—using `Math.max.apply`, the spread operator with `Math.max(...arr[i])`, and a manual nested loop—to achieve the same result. The code relies on standard JavaScript array methods and the `Math.max` API, with no external libraries. The visualization likely renders the code side-by-side or as a sequence, highlighting syntax differences and algorithmic approaches. The data source is the hardcoded sample array passed to each function call, demonstrating how the output remains identical across implementations.

EEelsie

47% match

Loading thumbnail…

An XSLT siteswap validator by Colin E.

This example validates juggling siteswap patterns through a pipeline of three XSLT transformations. It first splits each siteswap string into individual throw elements using a recursive template, then inserts catch elements where throws land on subsequent beats, and finally evaluates validity by checking that each beat contains at most one catch and the pattern forms a valid permutation. The transformations use XSLT 1.0 with standard functions like `substring`, `position`, and `mod`, operating on structured XML documents rather than raw text. The source data is an XML file containing siteswap sequences, processed through the stylesheets to produce annotated output with valid or invalid attributes.

CColinEberhardt

47% match

Loading thumbnail…

CS 891 Web Archiving Seminar

This visualization demonstrates the process of web archiving by showing the WARC file records produced when using `wget` to archive two websites: `http://example.com` and the React Router documentation. The code uses `wget` with extensive arguments including `--mirror`, `--warc-cdx`, and `--page-requisites` to capture complete page snapshots. The example displays the resulting WARC file structure, containing request, response, metadata, and resource records, along with a shell script that orchestrates the archiving workflow and manages the Wayback Machine collections.

NN0taN3rd

46% match

Loading thumbnail…

Gist 7d6a7404e99051bb7d2f36c61f0113ae

This example demonstrates functional programming techniques in JavaScript, including currying, composition, and generator functions. It shows how currying enables partial application, as seen with the `sum` function and reusable helpers like `getName` and `mapUserNames`. The code uses `compose` with `reduceRight` to chain array transformations, filtering user names by length. It also illustrates generator behavior with `next(true)` to control iteration completion. The data is a hardcoded array of user objects, and output is logged to the console via `console.log`.

IIliaIdakiev

46% match

Loading thumbnail…

Gist 6ca203fa1eab16a0f3c98d442ba9eea0

This example demonstrates a JavaScript function that transforms an input string into a "mumbling" pattern, where each character is repeated incrementally, capitalized at the start, and joined by hyphens. The visualization shows the result of applying this logic to sample strings like "abcd," "cwAt," and "RqaEzty" using the built-in `split`, `toLowerCase`, `toUpperCase`, `slice`, `map`, and `join` methods, along with custom `capitalize` and `accum` functions. The code relies on plain JavaScript string array manipulation without external libraries, producing outputs such as "A-Bb-Ccc-Dddd" for the first example.

MMistyBlunch

46% match