It has been a couple of months since the last update. As usual, there are a lot of internal changes to the compiler, but there are some interesting externally visible changes as well. I spent some time tightening things that seem stable enough, such as tokenization, encoding, and functions.

For the tokenization, I have switched from a hand-written tokenizer to re2c. It provided a nice boost to the compilation speed almost for free. I have also implemented caching for common number literals (0-9) and identifier names for another small boost.

With encoding, once I decided to ignore possible machine code size improvements from a relaxation step, I have realized that I could eagerly turn assembly instructions into bytes which save a whole lot of memory and some compilation speed. You can see me working on it in a YouTube video.

The big thing with functions is the basic support for generic arguments. Right now there is no way to constrain the type when matching overload, but even this basic functionality allowed moving type definitions of some of the compiler intrinsics into the user land: 

1
2
type_of :: @fn(x) -> (Type) PRELUDE_MASS.type_of
size_of :: @fn(x) -> (Number_Literal) PRELUDE_MASS.size_of


Generic function support also tightened up internals quite a bit allowing to move allowing to move some of the previously intrinsics to the user land. The main example of this is the fixed-size array type function: 

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
Array :: fn(item : Type, length : u64) -> (Type) {
  mass :: PRELUDE_MASS
  byte_size :: mass.Descriptor.bit_size.as_u64 * 8
  byte_alignment :: mass.Descriptor.bit_alignment.as_u64 * 8
  t : Type = mass.allocator_allocate_bytes(mass.allocator, byte_size, byte_alignment)
  t.tag = mass.Descriptor_Tag.Fixed_Size_Array
  t.bit_size.as_u64 = item.bit_size.as_u64 * length
  t.bit_alignment = item.bit_alignment
  t.Fixed_Size_Array.item = item
  t.Fixed_Size_Array.length = length
  t
}


There were also a bunch of smaller notable changes:

  • Linux Syscall Support
  • Basic Tuple Support
  • Support specifying output path for the CLI
  • Moved arithmetic operator definitions to the user land
  • Support bulding with Clang-CL on Windows
  • Significantly simplify and speed up `using` implementation