Currently, a variable can be used like this:

func Print(buffer: []const u8);

func Main() {
    var my_var: []const u8;
    Print(my_var);
}

This is undefined behavior and we want to avoid it. Throw an error when this occurs.

A standard while statement:

var i = 0;
while i < 10 {
    i = i + 1;
}
printf("%d", i); // => 10

With an optional condition:

while {
    Print("Going on forever...");
}

struct MyStruct {
    member: i32,
}

func InitMember(member: ~mut i32) {
    *member = 0;
}

func Main() {
    var my_struct = MyStruct .{};
    InitMember(~mut my_struct.member);
}

This currently doesn't compile when it should:

struct MyStruct {
    member: i32,
}

func MyStruct(self: ~mut MyStruct) {
    self.member = 42;
}

func Main() {
    var s = MyStruct .{ member = 0 };
    MyStruct(~mut s);
}

It would be useful for the command line to allow multiple Amp files to be linked together, like so:

// test1.amp
func Print(str: []const u8);
func Test() {
    Print("Hello, world!");
}

// test2.amp
func Test();

func Main() {
    Test();
}

And then link them together with the command line:

amp test1.amp test2.amp -o test
./test

func printf(str: ~mut u8) -> i32;

func Main() {
    var my_str: ~mut u8 = "Hello, world!";
    *my_str = 0x66;
    printf(my_str); // => Bello, world!
}

Allow function calls as values:

func GetStr() -> []const u8 {
    return "Hello, world!";
}

func Print(str: []const u8);

func Main() {
    Print(GetStr());
}

Big values, such as slices, do not fit in registers and must be implemented differently than primitive values such as integers.

func GetStr() -> []const u8 {
    return "Hello, world!";
}

This should follow the C ABI for returning struct values.

Implement a slice type for strings.

The layout for [u8] should be the same as the following C code:

typedef struct {
    char *ptr;
    size_t len;
} U8Slice;

That is, the pointer value followed by the number of items in the slice.

Currently, the compile reads the path of the input file to the command line and panics if the file can't be read. This behavior should instead be replaced with displaying a diagnostic message.

Implement integer values and types.

Currently, we need i32 types and decimal integers. Already implemented in the scanner, the rest should be relatively simple.

Description

Loops should be possible to label, so they can be broken or continued from an inner loop.

I am unsure of the best syntax for this, we can go for the classic:

label: while true {}

Or we can go for a different syntax:

while:label true {}

Use Cases

var x = 0;
outer: while x < 100 {
    var y = 0;
    while y < 100 {
        if my_condition {
            break outer;
        }
        y = y + 1;
    }
    x = x + 1;
}

Syntax

import "Std";

The compiler searches the following paths for the module with the given name, in order:

• Std
• Std.amp
• Std/Main.amp

Local modules can be imported using the following syntax:

import "./MyModule";

The compiler searches the following paths for the module with the given name, in order:

• ./MyModule
• ./MyModule.amp
• ./MyModule/Main.amp

Command Line

This would also introduce the -I compiler flag, which would add a path to search for modules in:

amp test.amp -I runtime

Given the above example, the compiler would search the following paths for the Std module (in order):

• runtime/Std
• runtime/Std.amp
• runtime/Std/Main.amp