enum Hello as u64 {
    a
    b
    c = 20 + 10
    d
    e
}

fn enums() Hello {
    mut a := Hello.a
    a = .c
    return a
}

struct AA {
    a u8
    b i64
}

fn of() {
    a := __offsetof(AA, b)
    b := sizeof(AA)
    _, _ := a, b
}

fn constant() int {
    return 100
}

const hello = 'hello\n'

const float = 1.0

const integer = 888

const runtime_init = constant()

// Test constants referencing other constants
const base_value = 53
const ref_const1 = base_value
const ref_const2 = ref_const1
const ref_const3 = ref_const2

struct EE {
    a int
    b int
}

fn ptr_arith() {
    mut a := EE{}
    mut b := &a.b

    unsafe {
        *b = 12
    }
    println(a.b.str())
    unsafe {
        *b = 14
    }
    println(a.b.str())
    unsafe {
        *b = 102
    }
    println((*b).str())
}

fn defer_if(cond bool) {
    if cond {
        defer {
            println('defer_if: defer!')
        }
    }
    println('defer_if: start')
}

fn run_defer() {
    defer {
        println('defer!')
    }
    println('before defer')
    defer_if(true)
    defer_if(false)
}

struct HasPointers {
    a   int
    msg &string
pub mut:
    same &HasPointers
}

fn ptr_in_struct() {
    msg := 'pointer in struct'
    mut s := HasPointers{1234, &msg, unsafe { nil }}
    println(*s.msg)
    s.same = &s
    println(*unsafe { &int(voidptr(s.same.a)) }) // FIXME: wont work without casts
}

fn main() {
    println('ptr_in_struct')
    ptr_in_struct()
    println('ptr_arith')
    ptr_arith()
    run_defer()
    println('constants')
    println(runtime_init)
    println(hello)
    // println(float)
    println(integer)
    println('const refs')
    println(ref_const1)
    println(ref_const2)
    println(ref_const3)
    println('enums')
    println(int(enums()))
    println(sizeof(Hello))
}