About strings manipulation

[carlosbazilio]

Dear,
first of all, congratulations for your excellent work!
I've seen Bril does only deals with integer and boolean values. How about strings? How do you usually deal with it?
Thanks in advance for any hint!
Carlos

[sampsyo]

Hi! Good question! The language doesn't have any support for strings, so the answer is mostly "we don't"—people just confine themselves to focusing on numeric programs in a Bril context. If you really want to get creative, you could fake them with the memory extension, which would let you allocate an array of integers representing the characters!

Part of the Bril philosophy is extensibility, so it could be fun to imagine designing a string extension (in the same vein as our current floating-point extension).

[carlosbazilio]

Nice! I had thought about it, but I've imagined someone else could've been working on it. I'll get used to Bril to give it a try! ;)

[carlosbazilio]

I'd like to know if you have some hints about how to build a Bril extension. For instance, is the extension code for floating point numbers stored at Bril's Github repository? How are Bril's binaries (brili and bril2json, for instance) modified to incorporate these extensions?

[Pat-Lafon]

Hello. I would agree that it isn't that clear how to extend Bril as Adrian has noted in #38. Because writing an extension is not so well structured, I don't believe there is any "extension code for floating point numbers". Instead, my understanding is that extensions are specified like in https://github.com/sampsyo/bril/tree/main/docs/lang which describe what new fields are used in the Bril JSON by the extension. These extensions are then implemented in tools such as brili and bril2json as needed.

For what it's worth, I would start implementing a string extension by laying out what values and operations do you want to use in the extension(are you just sticking with arrays of ints or are you using string literals? do you have chars? Is there a type called "string"? What operations will be supported and are they effect or value operations?). Then you probably want to modify the reference interpreter(brili) source code to support this. A quick glance suggests you will need to add to

bril/brili.ts

Lines 103 to 141 in 732f63f

	const argCounts: {[key in bril.OpCode]: number | null} = {
	add: 2,
	mul: 2,
	sub: 2,
	div: 2,
	id: 1,
	lt: 2,
	le: 2,
	gt: 2,
	ge: 2,
	eq: 2,
	not: 1,
	and: 2,
	or: 2,
	fadd: 2,
	fmul: 2,
	fsub: 2,
	fdiv: 2,
	flt: 2,
	fle: 2,
	fgt: 2,
	fge: 2,
	feq: 2,
	print: null, // Any number of arguments.
	br: 1,
	jmp: 0,
	ret: null, // (Should be 0 or 1.)
	nop: 0,
	call: null,
	alloc: 1,
	free: 1,
	store: 2,
	load: 1,
	ptradd: 2,
	phi: null,
	speculate: 0,
	guard: 1,
	commit: 0,
	};

bril/brili.ts

Line 148 in 732f63f

type Value = boolean | BigInt | Pointer | number;

bril/brili.ts

Lines 151 to 165 in 732f63f

	/**
	* Check whether a run-time value matches the given static type.
	*/
	function typeCheck(val: Value, typ: bril.Type): boolean {
	if (typ === "int") {
	return typeof val === "bigint";
	} else if (typ === "bool") {
	return typeof val === "boolean";
	} else if (typ === "float") {
	return typeof val === "number";
	} else if (typeof typ === "object" && typ.hasOwnProperty("ptr")) {
	return val.hasOwnProperty("loc");
	}
	throw error(`unknown type ${typ}`);
	}

bril/brili.ts

Lines 167 to 180 in 732f63f

	/**
	* Check whether the types are equal.
	*/
	function typeCmp(lhs: bril.Type, rhs: bril.Type): boolean {
	if (lhs === "int" || lhs == "bool" || lhs == "float") {
	return lhs == rhs;
	} else {
	if (typeof rhs === "object" && rhs.hasOwnProperty("ptr")) {
	return typeCmp(lhs.ptr, rhs.ptr);
	} else {
	return false;
	}
	}
	}

bril/brili.ts

Line 420 in 732f63f

switch (instr.op) {

bril/brili.ts

Lines 811 to 836 in 732f63f

	function parseMainArguments(expected: bril.Argument[], args: string[]) : Env {
	let newEnv: Env = new Map();
	if (args.length !== expected.length) {
	throw error(`mismatched main argument arity: expected ${expected.length}; got ${args.length}`);
	}
	for (let i = 0; i < args.length; i++) {
	let type = expected[i].type;
	switch (type) {
	case "int":
	let n: bigint = BigInt(parseInt(args[i]));
	newEnv.set(expected[i].name, n as Value);
	break;
	case "float":
	let f: number = parseNumber(args[i]);
	newEnv.set(expected[i].name, f as Value);
	break;
	case "bool":
	let b: boolean = parseBool(args[i]);
	newEnv.set(expected[i].name, b as Value);
	break;
	}
	}
	return newEnv;
	}

bril/bril-ts/bril.ts

Line 13 in 732f63f

export type PrimType = "int" | "bool" | "float";

bril/bril-ts/bril.ts

Lines 40 to 64 in 732f63f

	/**
	* An instruction that does not produce any result.
	*/
	export interface EffectOperation extends Op {
	op: "br" | "jmp" | "print" | "ret" | "call" |
	"store" | "free" |
	"speculate" | "guard" | "commit";
	}
	/**
	* An operation that produces a value and places its result in the
	* destination variable.
	*/
	export interface ValueOperation extends Op {
	op: "add" | "mul" | "sub" | "div" |
	"id" | "nop" |
	"eq" | "lt" | "gt" | "ge" | "le" | "not" | "and" | "or" |
	"call" |
	"load" | "ptradd" | "alloc" |
	"fadd" | "fmul" | "fsub" | "fdiv" |
	"feq" | "flt" | "fle" | "fgt" | "fge" |
	"phi";
	dest: Ident;
	type: Type;
	}

bril/bril-ts/bril.ts

Lines 66 to 69 in 732f63f

	/**
	* The type of Bril values that may appear in constants.
	*/
	export type Value = number | boolean;

I don't know if I've answered your questions but I hope this post was helpful as I think it would be very interesting to have a String extension in Bril.

[sampsyo]

Very well put, @Pat-Lafon! This is a great overview of how to get started with implementing a Bril extension. To summarize, I would personally start with careful thinking about the value types and new opcodes, possibly even by writing the human-language docs first. Then the next step would be to hack the reference interpreter. Eventually, I would probably extend the text syntax, but only as a convenience for the real third step: writing a bunch of tests.