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))
}