pointers.wil

/*
    In Wilfrid, you have direct access to the memory 
    and can manipulate it freely with pointers. 
    The results of pointer operations are not checked. 
    With great freedom comes great responsibility - Wilfrid 
    isn't a memory-safe language by choice.

    If you prefer automatic memory management, Wilfrid
    also offers optional garbage collection; 
    see the "Memory management" example.
*/

fn main()
{
/*
    To declare a pointer, use a type name and a caret sign:
*/

    let ptr : int^

/* 
    To take an address of something, use the at sign:
*/

    let some_int = 3
    ptr = @some_int

/*
    To dereference a pointer, i. e. take a value 
    that is pointed to by it, use the hash sign:
*/

    let some_int_copy = #ptr

    if (some_int_copy == some_int)
    {
        printf("some_int and some_int_copy are the same\\n")
    }

/*
    Let's use pointer arithmetic to traverse an array.
    First, we declare an array with initial values and take 
    a pointer to its beginning.
*/

    let array : int[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }
    let first_number = @array as int^
   
/*
    Let's use the for loop:
*/
    
    for (let offset := 0, offset < 10, offset++)
    {

/* 
    With each iteration of the loop, we increase the offset 
    by one. We add it to the pointer to the first number 
    and then dereference it. This way each iteration 
    of the loop we are one element in the array further.
*/

        let number := #(first_number + offset)

/*
    As we can see, pointer arithmetic moves a pointer 
    by a multiple of the size of a type that is pointed 
    to by it.

    Adding one to a pointer to a char moves us one byte,
    because a char is one byte long.

    Adding one to a pointer to a long integer moves us 
    by eight bytes, because that's the size of a long integer.
*/

        printf("Number is %d\\n", number)
    }

/*
    An alternative version of the same operation, this 
    time performing pointer arithmetic in the for loop
    statement itself:
*/
 
    for (let num_ptr := first_number, 
         num_ptr < first_number + 10, 
         num_ptr++)
    {
        let number = #num_ptr
        printf("Number is %d\\n", number)
    }

/*
    Pointers cannot be added together.
    They can, however, be subtracted:
*/

    let diff := @some_int - @some_int_copy
    
    printf("The difference between %p and %p is: %lld\\n", 
        @some_int, @some_int_copy, diff)

/* 
    A result of subtracting pointers is always a long integer.
*/

/*
    If a pointer points to a struct, there is no need 
    to dereference it before accessing the struct's fields.
    The same goes for unions. The dot operator automatically 
    performs dereference. An example:
*/

    let some_struct : test_struct = { int_field = 10 }
    let ptr_to_struct = @some_struct

    printf("The value of the field is: %d\\n", ptr_to_struct.int_field)

/*
    This works no matter how many layers of indirection 
    there are:
*/

    let ptr_to_ptr = @ptr_to_struct
    let meta_ptr = @ptr_to_ptr

    printf("The value of the field is: %d\\n", meta_ptr.int_field)

/*    
    For a more advanced example of pointers usage, see 
    the "Memory arena" example.
*/   
}

struct test_struct
{
    int_field: int
}