SECRET OF CSS

Build a WebAssembly Language: Lexing


WebAssembly (wasm) is a high-performance assembly-like format optimized for the web. Code targeting WebAssembly can run at near-native speeds while still benefiting from the safe environment of a browser VM. Wasm has opened up a whole new world of demanding desktop-class apps that can comfortably run in the browser. For example, AutoCAD was able to port decades of code to the web using wasm. Cases like AutoCAD’s have made it clear that wasm will be a major disruptive force in how web apps are developed.

To facilitate the adoption of wasm, WebAssembly team developed a powerful compiler toolchain library called binaryen. Binaryen does a huge amount of heavy lifting for compiler authors. It offers dead code removal, code size reduction, and various performance optimizations out of the box.

As someone who has long been interested in programming languages, this piqued my interest. Writing compiled languages has always been a daunting task. What I found is binaryen made it incredibly fun and easy to build _new_ languages that are shockingly speedy.

That’s why I decided to create this guide and provide a simple overview designed to help get your feet wet in building languages and exploring the inner workings of wasm. 

Here’s a quick taste of the lisp-inspired language we’ll build, wispy:

(fn fib:i32 [val:i32]
  (if (lt_i32 val 2)
    val
    (add_i32 (fib (sub_i32 val 1)) (fib (sub_i32 val 2)))))

(fn main:i32 [] (fib 15))

This simple function calculates values of the Fibonacci sequence, a sequence of numbers that appears in surprising places through mathematics and nature. It’s one of my favorite illustrations of how elegantly patterns of the universe can be described in code.

This guide is designed for intermediate to advanced software developers looking for a fun side

project to challenge themselves with. By the end, we’ll have built a working compiler and runtime for wispy.

The guide will be broken down into three articles:

Setup and Lexing(this article): the process of converting the characters of code into meaningful units called tokens

Parsing: the process of converting the tokens into a logical tree known as an AST.

Compiling (or code generation): the process of converting the AST into the binary instructions run by our computer

Setup

In this guide, we will be using TypeScript and NodeJS. The concepts are highly portable, so

feel free to use the environment you’re most comfortable with. Our only major dependency, binaryen, has a simple C API. You are welcome to skip ahead to the next section if you’re using a different language.

Requirements:

Quick Start

bash

git clone git@github.com:drew-y/wispy.git

cd wispy

git checkout quickstart

npm i

Manual Setup

I’ve included manual setup instructions as an alternative to the quick start, in case you want to know exactly how the project was set up or just like doing things from scratch. If you’ve already done the quick start, skip to the next section.

1. Open a terminal window and make a new directory:

bash

mkdir wispy

cd wispy

2. Initialize package.json:

bash

npm init -y # Be sure to have NodeJS 16+ installed

3. Install the project dependencies:

npm i @types/node binaryen typescript

4. Add these two fields to the package.json

"type": "module", // Binaryen uses the new module format so we must follow suit

"bin": {

  "wispy": "dist/index.mjs" // This will allow us to easily run the compiler from our terminal

},

5. Create a tsconfig file:

6. Set the following fields in `tsconfig.json`:

"module": "ES2022",

"rootDir": "./src",

"moduleResolution": "node",

"outDir": "./dist"

Lexing

Lexing is the process of digesting each individual character of our program into a set of tokens. A token is a group of characters that take on a special meaning when put together. Take the following snippet of wispy:

There are five unique tokens in that snippet `(`, `add`, `1`, `2` and `)`. The lexer’s job is simply to identify and list those tokens in order. Lexing is typically the first step in turning human-readable code into something closer to what a computer can understand.

Defining Our Tokens

We’ll start by defining our tokens in a new file:

bash

# mts extension is important, it tells typescript to create a corresponding mjs file, so Node knows to use modules 



mkdirp -p src/types/token.mts

First up is the `IntToken`. This token represents whole numbers like `1045`

ts

// src/types/token.mts

export type IntToken = { type: "int"; value: number };

Next up is the `FloatToken`. This token represents numbers that may have a decimal, like `1.8`:

ts

// src/types/token.mts

export type FloatToken = { type: "float"; value: number };



/** Previously defined tokens omitted for brevity */

Now, let’s define some identifier tokens. In wispy, an identifier can represent either the name of a function or the name of a function parameter. We have two types of identifier tokens, a standard `IdentifierToken` and a `TypedIdentifierToken`.

An `IdentifierToken` is used in the body of a function to refer to the function’s parameters or to call another function.

A `TypedIdentifierToken` is used when defining a function or a parameter. Typed identifiers take the form `identifier:type`. For example, `val:i32` defines a parameter that is a 32-bit integer. When defining a function, the type represents the function’s return type. For example, `fib:i32` is a function that returns a 32-bit integer.

Here are the definitions:

ts

// src/types/token.mts

export type IdentifierToken = { type: "identifier"; value: string };

export type TypedIdentifierToken = { type: "typed-identifier"; value: string };



/** Previously defined tokens omitted for brevity */

Up next is `BracketToken`. Wispy uses [S-expression](https://en.wikipedia.org/wiki/S-expression) syntax, like lisp. So brackets are very important. To keep things simple we allow two kinds of brackets `()` and `[]`. To keep things even more simple the compiler will treat `()` and `[]` as interchangeable. In actual use, we will only use `[]` to define parameters.

// src/types/token.mts

export type BracketToken = { type: "bracket"; value: Bracket };

export type Bracket = "(" | ")" | "[" | "]";



/** Previously defined tokens omitted for brevity */

 

Finally, we define the top-level `Token` type:

// src/types/token.mts

export type Token = BracketToken | IntToken | FloatToken | IdentifierToken | TypedIdentifierToken;

/** Previously defined tokens omitted for brevity */

`Token` is a discriminated union. Discriminated Unions are an incredibly powerful programming language construct. They represent a value that can be one of many types. In our case, a `Token` can be any one of the more specific token types we defined earlier, such as `IntToken` or `FloatToken`. You’ll notice that each of these tokens have a unique `type` field, such as `type: “int”` in the case of `IntToken`. This is the discriminator. Down the line you can pass a `Token` to a function and that function can use the `type` field to figure out which specific token it’s working with.

At this point `src/types/token.mts` is finished and should look like a file. 

To make our new types easily accessible, export them from a new `index.mts` file:

// src/types/index.mts

export * from "./token.mjs";

The Lex Function

Now that we have our tokens defined we can write the actual `lex` function. The lex function will take a `string` (i.e. a .wispy file) and output an array of tokens (`Token[]`):

Make a new lex file:

bash

mkdirp -p src/lexer.mts

Define the lex function:

// src/lexer.mts

import { Bracket, Token } from "./types/index.mjs";



export const lex = (input: string): Token[] => {

  const chars = input

    // Remove any leading or trailing whitespace for simplicity

    .trim()

    // Break up the file into single characters

    .split("");



  // This array stores our tokens

  const tokens: Token[] = [];



  // The loop continues as long as we have characters to consume

  while (chars.length) {

    // Here, a word is an unidentified token. It is usually any single group of non-whitespace

    // characters such as 123 or 123.4 or im_a_function

    const word = consumeNextWord(chars); // We'll define this function later



    // We ran out of tokens. Break out of the loop.

    if (word === undefined) break;



    const token = identifyToken(word); // We'll define this function later



    // Add the token to our store

    tokens.push(token);

  }



  // Return the tokens

  return tokens;

};

Next we define the `consumeNextWord` function:

// src/lexer.mts



/** previous function(s) omitted for brevity */



const consumeNextWord = (chars: string[]): string | undefined => {

  const token: string[] = [];



  while (chars.length) {

    // Save a preview of the current character without modifying the array

    const char = chars[0];



    // No more characters to read

    if (char === undefined) break;



    // Whitespace characters terminate the token (we'll define the isWhitespace function later)

    if (isWhitespace(char) && token.length) {

      chars.shift(); // Remove the whitespace so it doesn't get included in the next token

      break;

    }



    // Discard leading whitespace characters

    if (isWhitespace(char)) {

      chars.shift();

      continue;

    }



    // Terminator tokens signify the end of the current token (if any). (we'll define the isTerminatorToken function later)

    if (isTerminatorToken(char) && token.length) break;



    // Add the character to the token and discard it from the input

    token.push(char);

    chars.shift();



    // If the only token we've received so far is a single character token, that's our whole token.

    if (isTerminatorToken(char)) break;

  }



  // If we have characters for our token, join them into a single word. Otherwise, return undefined to signal to the lexer

  // that we are finished processing tokens.

  return token.length ? token.join("") : undefined;

};

Now we’ll define our `identifyToken` function. As the name suggests, this function takes a word and figures out what token that word represents.

// src/lexer.mts



/** previous function(s) omitted for brevity */



const identifyToken = (word: string): Token => {

  // Don't worry we'll get to all the `is` helper functions in a bit

  if (isInt(word)) return { type: "int", value: parseInt(word) };

  if (isFloat(word)) return { type: "float", value: parseFloat(word) };

  if (isIdentifier(word)) return { type: "identifier", value: word };

  if (isBracket(word)) return { type: "bracket", value: word };

  if (isTypedIdentifier(word)) return { type: "typed-identifier", value: word };



  throw new Error(`Unknown token: ${word}`);

};

Finally, we define our helper functions. These functions all take a string and return `true` if the string passes their test, `false` otherwise. Most are written using regex. If you’re unfamiliar with regex, I highly recommend regexone as a resource to learn more. In a nutshell, regex is an expression syntax that’s used to extract meaningful information from text. In our case, we’ll use it to match words against tokens. 

const isInt = (word: string) => /^[0-9]+$/.test(word);



const isFloat = (word: string) => /^[0-9]+\.[0-9]+$/.test(word);



const isIdentifier = (word: string) => /^[a-zA-Z_][a-zA-Z0-9_\-]*$/.test(word);



const isTypedIdentifier = (word: string) =>

  /^[a-zA-Z_][a-zA-Z0-9_\-]*:[a-zA-Z_][a-zA-Z0-9_\-]*$/.test(word);



const isBracket = (word: string): word is Bracket => /[\(\)\[\]]/.test(word);



/** Brackets are the only terminator tokens for now */

const isTerminatorToken = (word: string): word is Bracket => isBracket(word);



// Not sure why I didn't use regex here ¯\_(ツ)_/¯

const isWhitespace = (char: string) => char === " " || char === "\n" || char === "\t";  

At this point, `src/lexer.mts` is finished and should look something like this file.  

Running the Lexer 

It’s time to actually run the lexer. Start by making a new file `src/index.mts`:

#!/usr/bin/env node



// src/index.mts



import { readFileSync } from "fs";

const file = process.argv[2];

const input = readFileSync(file, "utf8");

const tokens = lex(input);

console.log(JSON.stringify(tokens, undefined, 2));

 

Next, create an `example.wispy` file in the project root to compile.

(fn fib:i32 [val:i32]

  (if (lt_i32 val 2)

    val

    (add_i32 (fib (sub_i32 val 1)) (fib (sub_i32 val 2)))))



(fn main:i32 [] (fib 15))

  

Now build the lexer 

bash

npx tsc

npm link # This will make wispy available to run as its own command

 

Finally, run the lexer:

bash

wispy example.wispy



# Note, if npm link failed you can call our compiler directly with this as an alternative:

node dist/index.mjs example.wispy

If everything goes well, `wispy` should output something like this:

[

  {

    "type": "bracket",

    "value": "("

  },

  {

    "type": "identifier",

    "value": "fn"

  },

  {

    "type": "typed-identifier",

    "value": "fib:i32"

  },

  {

    "type": "bracket",

    "value": "["

  },

  {

    "type": "typed-identifier",

    "value": "val:i32"

  },

  // Omitting the rest for brevity

]

With that, we have a working lexer. We can break our code down into tokens. This is a good place to break for now. In the next article, we’ll move onto parsing these tokens into a logical tree that will ultimately be converted to wasm. 



News Credit

%d bloggers like this: