SMT50001

Garbage collection with zero cost at non-GC time

Every once in a while I investigate low-level backend options for PL-s, although so far I haven't actually written any such backend for my projects. Recently I've been looking at precise garbage collection in popular backends, and I've been (like on previous occasions) annoyed by limitations and compromises.

I was compelled to think about a system which accommodates precise relocating GC as much as possible. In one extreme configuration, described in this note, there

Language & VM design

Lexing & parsing

Articles

Parsing inputs in Nim

Writing own parser

ANSI Escape Sequences

Standard escape codes are prefixed with Escape:

Ctrl-Key: ^[
Octal: \033
Unicode: \u001b
Hexadecimal: \x1B
Decimal: 27

C99 List of Undefined Behavior

From N1256: (See http://port70.net/~nsz/c/c99/n1256.html#J.2)

A "shall" or "shall not" requirement that appears outside of a constraint is violated (clause 4).
A nonempty source file does not end in a new-line character which is not immediately preceded by a backslash character or ends in a partial preprocessing token or comment (5.1.1.2).
Token concatenation produces a character sequence matching the syntax of a universal character name (5.1.1.2).
A program in a hosted environment does not define a function named main using one of the specified forms (5.1.2.2.1).
A character not in the basic source character set is encountered in a source file, except in an identifier, a character constant, a string literal, a header name, a comment, or a preprocessing token that is never converted to a token (5.2.1).
An identifier, comment, string literal, character constant, or header name contains an invalid multibyte character or does not

	type term =
	\| Lam of (term -> term)
	\| Pi of term * (term -> term)
	\| Appl of term * term
	\| Ann of term * term
	\| FreeVar of int
	\| Star
	\| Box

	let unfurl lvl f = f (FreeVar lvl)

	##[
	Fixed point arithmetic

	A fixed point number is an alternative representation for a real number.
	IEEE floats, `f32` and `f64`, being the standard format in processors with
	Floating Point Units (FPU). You should consider using fixed numbers on
	systems where there's no FPU and performance is critical as fixed point
	arithmetic is faster than software emulated IEEE float arithmetic. Do note
	that fixed point numbers tend to be more prone to overflows as they operate
	in ranges much smaller than floats.