ivy/doc/mie/sample/Person.mie

meta.source-filename "Person.im"

ivy.package-scope "net.doorstuck.test"

ivy.package-ref "std.io"

ivy.module {
	%cout = ivy.global-ref @cout -> ptr

	ivy.class @Person {
		%self.name = ivy.object-var @name : #ivy.id -> ptr
		%self.age = ivy.object-var @age : #ivy.id -> ptr
		%self.val = ivy.object-var @val : #ivy.id -> ptr
		%self.__example-property-4 = ivy.object-var @val : #ivy.id -> ptr
		%self.__example-property-5 = ivy.object-var @val : #ivy.id -> ptr

		ivy.msgh.object init(name:%name, age:%age) -> void {
			ptr.store %name, %self.name : #ivy.id, ptr
			ptr.store %age, %self.age : #ivy.id, ptr
			func.return : ()
		}

		ivy.msgh.object test(param:%data, _:%extra) -> void {
			%0 = ivy.string-builder.begin

			ivy.string-builder.add %0 << "Received "
			ivy.string-builder.add %0 << %data : #ivy.id
			ivy.string-builder.add %0 << ", "
			ivy.string-builder.add %0 << %extra : #ivy.id

			%1 = ivy.string-builder.end %0 -> #ivy.id

			%2 = ptr.load %cout : ptr -> #ivy.id
			ivy.msg.send to %2, put:%1 -> void
			func.return : ()
		}

		ivy.msgh.object name -> #ivy.id {
			%0 = ptr.load %self.name : ptr -> #ivy.id
			func.return %0 : #ivy.id
		}

		ivy.msgh.object age -> #ivy.id {
			%0 = ptr.load %self.age : ptr -> #ivy.id
			func.return %0 : #ivy.id
		}

		ivy.msgh.object age-in-months -> #ivy.id {
			%0 = ptr.load %self.age : ptr -> #ivy.id
			%1 = i32.constant 12
			%multmp = ivy.mul %0, %1 : (#ivy.id, i32) -> #ivy.id
			func.return %multmp : #ivy.id
		}

		ivy.msgh.object set-name:%name -> void {
			ptr.store %name, %self.name : #ivy.id, ptr
			func.return : ()
		}

		ivy.msgh.object set-age:%age -> void {
			ptr.store %age, %self.age : #ivy.id, ptr
			func.return : ()
		}

		ivy.msgh.object set-age:%age in-units:%units -> void {
			scf.switch : () -> void
			case {
				%0 = ivy.atom "years"
				%cmptmp.0 = ivy.cmp eq %age, %0 : (#ivy.id, #ivy.atom) -> i1
				scf.switch-condition %cmptmp.0
			} then {
				ptr.store %age, %self.age : #ivy.id, ptr
				scf.switch-break : ()
			} case {
				%1 = ivy.atom "months"
				%cmptmp.1 = ivy.cmp eq %age, %1 : (#ivy.id, #ivy.atom) -> i1
				scf.condition %cmptmp.1
			} then {
				%d0 = i32.constant 12
				%divtmp.0 = ivy.div %age, %d0 : (#ivy.id, i32) -> #ivy.id
				ptr.store %divtmp.0, %self.age : #ivy.id, ptr
				scf.switch-break : ()
			} case {
				%2 = ivy.atom "days"
				%cmptmp.2 = ivy.cmp eq %age, %2 : (#ivy.id, #ivy.atom) -> i1
				scf.condition %cmptmp.2
			} then {
				%d1 = i32.constant 365
				%divtmp.1 = ivy.div %age, %d1 : (#ivy.id, i32) -> #ivy.id
				ptr.store %divtmp.1, %self.age : #ivy.id, ptr
				scf.switch-break : ()
			} default {
				%d2 = i32.constant 0
				scf.switch-break : ()
			}

			func.return : ()
		}

		ivy.msgh.object get-age-in-units:%units -> #ivy.id {
			%result = scf.switch : () -> #ivy.id
			case {
				%0 = ivy.atom "years"
				%cmptmp.0 = ivy.cmp eq %age, %0 : (#ivy.id, #ivy.atom) -> i1
				scf.switch-condition %cmptmp.0
			} then {
				%v0 = ptr.load %self.age : ptr -> #ivy.id
				scf.switch-break %v0 : #ivy.id
			} case {
				%1 = ivy.atom "months"
				%cmptmp.1 = ivy.cmp eq %age, %1 : (#ivy.id, #ivy.atom) -> i1
				scf.condition %cmptmp.1
			} then {
				%v0 = ptr.load %self.age : ptr -> #ivy.id
				%d0 = i32.constant 12
				%divtmp.0 = ivy.div %v0, %d0 : (#ivy.id, i32) -> #ivy.id
				scf.switch-break %divtmp.0 : #ivy.id
			} case {
				%2 = ivy.atom "days"
				%cmptmp.2 = ivy.cmp eq %age, %2 : (#ivy.id, #ivy.atom) -> i1
				scf.condition %cmptmp.2
			} then {
				%v1 = ptr.load %self.age : ptr -> #ivy.id
				%d1 = i32.constant 365
				%divtmp.1 = ivy.div %v1, %d1 : (#ivy.id, i32) -> #ivy.id
				scf.switch-break %divtmp.1 : #ivy.id
			} default {
				%d2 = i32.constant 0
				scf.switch-break %d2 : #ivy.id
			}

			func.return %result : #ivy.id
		}

		ivy.object-prop example-property
		get {
			%0 = ptr.load %self.val : ptr -> #ivy.id
			func.return %0 : #ivy.id
		}
		set (%value: #ivy.id) {
			ptr.store %value, %self.val : #ivy.id, ptr
			func.return : ()
		}

		ivy.object-prop example-property-2 get {
			%0 = ptr.load %self.val : ptr -> #ivy.id
			func.return %0 : #ivy.id
		} set (%x: #ivy.id) {
			ptr.store %x, %self.val : #ivy.id, ptr
			func.return : ()
		}

		ivy.object-prop example-property-3 get {
			%0 = i32.constant 42
			func.return %0 : i32
		}

		ivy.object-prop example-property-4 get {
			%0 = ptr.load %self.__example-property-4 : ptr -> #ivy.id
			func.return %0 : #ivy.id
		} set (%0: #ivy.id) {
			ptr.store %0, %self.__example-property-4 : #ivy.id, ptr
			func.return : ()
		}

		ivy.object-prop example-property-5 get {
			%0 = ptr.load %self.__example-property-5 : ptr -> #ivy.id
			func.return %0 : #ivy.id
		}
	}

	ivy.init-text {
		; p1 = Person new(name:'John Doe', age:34).
		%Person = ivy.global-ref @Person : ptr
		%0 = ivy.str.constant "John Doe"
		%1 = i32.constant 34

		%2 = ivy.msg.send to %Person, new(name:%0, age:%1) -> #ivy.id

		%p1 = ptr.alloca #ivy.id -> ptr
		ptr.store %2, %p1 : #ivy.id, ptr

		; p1 set-age:100 in-unit:$months.
		%3 = ptr.load %p1 : ptr -> #ivy.id
		%4 = i32.constant 100
		%5 = ivy.atom "months"
		ivy.msg.send to %3, set-age:%4 in-units:%5 -> void

		; p1 test(param:'Hello', 'World').
		%6 = ptr.load %p1 : ptr -> #ivy.id
		%7 = ivy.str.constant "Hello"
		%8 = ivy.str.constant "World"
		ivy.msg.send to %6, test(param:%7, _:%8) -> void

		; i = 0.
		%i = ptr.alloca i32 -> ptr
		%9 = i32.constant 0
		ptr.store %9, %i : i32, ptr

		; while i < 100 do
		scf.while -> void {
			; i < 100
			%10 = ptr.load %i : ptr -> i32
			%11 = i32.constant 100
			%cmptmp = ivy.cmp lt %10, %11 : (i32, i32) -> i1
			scf.condition(%cmptmp)
		} do {
			; cout put:'Count is {i}'.
			%12 = ivy.string-builder.begin

			ivy.string-builder.add %12 << "Count is "

			%14 = ptr.load %i : ptr -> i32
			ivy.string-builder.add %12 << %14 : i32

			%15 = ivy.string-builder.end %12 -> #ivy.id

			%16 = ptr.load %cout : ptr -> #ivy.id
			ivy.msg.send to %16, put:%15 -> void

			; i += 2
			%17 = ptr.load %i : ptr -> i32
			%18 = i32.constant 2
			%addtmp = ivy.add %17, %18 : (i32, i32) -> i32
			ptr.store %addtmp, %i : i32, ptr
		}

		; 0 to:100 step:2
		%19 = i32.constant 0
		%20 = i32.constant 100
		%21 = i32.constant 2
		%22 = ivy.msg.send to %19, to:%20 step:%21 -> #ivy.id

		; for x in 0 to:100 step:2 do
		ivy.for %x in %22 -> void {
			%23 = ivy.string-builder.begin

			; 'Count is {x}'
			ivy.string-builder.add %23 << "Count is "
			ivy.string-builder.add %23 << %x : #ivy.id

			%25 = ivy.string-builder.end %23 -> #ivy.id

			; cout put:"Count is {x}"
			%26 = ptr.load %cout : ptr -> #ivy.id
			ivy.msg.send to %26, put:%25 -> void
		}

		; 0 to:100 step:2 do:...
		%27 = i32.constant 0
		%28 = i32.constant 100
		%29 = i32.constant 2
		; [ :i | cout put:'Count: {i}' ]
		%30 = ivy.lambda %i : (#ivy.id) -> void {
			%0 = ivy.string-builder.begin

			ivy.string-builder.add %0 << "Count is "
			ivy.string-builder.add %0 << %i : #ivy.id

			%2 = ivy.string-builder.end %0 -> #ivy.id

			%cout = ivy.global-ref @cout -> ptr
			%3 = ptr.load %cout : ptr -> #ivy.id
			ivy.msg.send to %3, put:%2 -> void
		}

		; 0 to:100 step:2 do:[ :i | cout put:'Count: {i}' ].
		ivy.msg.send to %27, to:%28 step:%29 do:%30

		; q = 32.
		%q = ptr.alloca i32 -> ptr
		%31 = i32.constant 32
		ptr.store %31, %q : i32, ptr

		; l = [ cout put:'Value of q is {q}' ].
		%l = ptr.alloca #ivy.id
		%32 = ptr.load %q : ptr -> i32
		%33 = ivy.lambda (%env.q = %32) : () -> void {
			%0 = ivy.string-builder.begin

			ivy.string-builder.add %0 << "Value of q is "
			ivy.string-builder.add %0 << %env.q : #ivy.id

			%2 = ivy.string-builder.end %0 -> #ivy.id

			%cout = ivy.global-ref @cout -> ptr
			%3 = ptr.load %cout : ptr -> #ivy.id
			ivy.msg.send to %3, put:%2 -> void
		}

		ptr.store %33, %l : #ivy.id, ptr

		; q = 64.
		%34 = i32.constant 64
		ptr.store %34, %q : i32, ptr

		; l call.
		%35 = ptr.load %l : ptr -> #ivy.id
		ivy.msg.send to %35, call -> void

		%j = ptr.alloca i32 -> ptr

		%36 = i32.constant 32
		ptr.store %36, %j : i32, ptr

		%37 = ptr.load %i : ptr -> i32
		%38 = ptr.load %j : ptr -> i32

		%cmptmp = arith.cmp lt %37, %38 : (i32, i32) -> i1

		%39 = ivy.lambda : () -> void {
			%cout = ivy.global-ref @cout -> ptr
			%0 = ivy.str.constant "True!"
			%1 = ptr.load %cout : ptr -> #ivy.id
			ivy.msg.send to %1, put:%0 -> void
		}

		%40 = ivy.lambda : () -> void {
			%cout = ivy.global-ref @cout -> ptr
			%0 = ivy.str.constant "False!"
			%1 = ptr.load %cout : ptr -> #ivy.id
			ivy.msg.send to %1, put:%0 -> void
		}

		ivy.msg.send to %cmptmp, if:%39 else:%40 -> void

		%41 = ptr.load %i : ptr -> i32
		%42 = ptr.load %j : ptr -> i32

		%cmptmp.0 = arith.cmp lt %41, %42 : (i32, i32) -> i1

		scf.if %cmptmp.0 -> void {
			%43 = ivy.str.constant "True!"
			%44 = ptr.load %cout : ptr -> #ivy.id
			ivy.msg.send to %44, put:%43 -> void
		}

		; pkg = {}.
		%pkg = ptr.alloca #ivy.id -> ptr

		%Package = ivy.global-ref @std.lang.Package -> ptr

		%45 = ivy.msg.send to %Package, new -> #ivy.id
		ptr.store %45, %pkg : #ivy.id, ptr

		; pkg[0] = 16.
		%46 = ptr.load %pkg : ptr -> #ivy.id
		%47 = i32.constant 0
		%48 = i32.constant 16

		ivy.msg.send to %46, at:%47 put:%48 -> void

		; tuple = (32, 'a string')
		%tuple = ptr.alloca #ivy.id -> ptr

		%49 = i32.constant 32
		%50 = ivy.str.constant "a string"

		%51 = ivy.tuple.create %49, %50 : (i32, #ivy.id) -> #ivy.id

		ptr.store %51, %tuple : #ivy.id, ptr

		%52 = ptr.load %tuple : ptr -> #ivy.id
		%53 = ivy.msg.send to %52, get-iterator -> #ivy.id

		ivy.for %54 in %53 -> void {
			%key = ivy.tuple.get-item %54[0] : (#ivy.id, i32) -> #ivy.id
			%val = ivy.tuple.get-item %54[1] : (#ivy.id, i32) -> #ivy.id

			; '{key} -> {val}'
			%55 = ivy.string-builder.begin

			ivy.string-builder.add %55 << %key : #ivy.id
			ivy.string-builder.add %55 << " -> "
			ivy.string-builder.add %55 << %val : #ivy.id

			%57 = ivy.string-builder.end %55 -> #ivy.id

			; cout put:'{key} -> {val}'
			%58 = ptr.load %cout : ptr -> #ivy.id
			ivy.msg.send to %58, put:%57 -> void
		}

		; _ = 3 * 2.
		%59 = i32.constant 3
		%60 = i32.constant 2
		%multmp = arith.mul %59, %60 : (i32, i32) -> i32

		; a = (32, 64).
		%a = ptr.alloca #ivy.id -> ptr

		%61 = i32.constant 32
		%62 = i32.constant 64
		%63 = ivy.tuple.create %61, %62 : (i32, i32) -> #ivy.id

		ptr.store %63, %a : #ivy.id, ptr

		%v = ptr.alloca #ivy.id -> ptr

		%64 = ptr.load %a : ptr -> #ivy.id
		%65 = ivy.tuple.get-item %64[1] : #ivy.id -> #ivy.id

		ptr.store %65, %v : #ivy.id, ptr

		%66 = ivy.atom "err:number-format"

		ivy.try -> void {

		} catch (%ex = %66), %data {

		} catch-all %ex, %data {

		}

		%67 = ivy.lambda : () -> void {
			%v = ptr.alloca #ivy.id -> ptr
			%Int = ivy.global-ref @Int -> ptr
			%0 = ivy.str.constant "342"

			%1 = ivy.msg.send to %Int, parse:%0

			ptr.store %1, %v : #ivy.id, ptr
		}

		%68 = ivy.lambda %err, %data : (#ivy.id, #ivy.id) -> void {
			%0 = ivy.string-builder.begin

			ivy.string-builder.add %0 << "Cannot parse integer string ("
			ivy.string-builder.add %0 << %err : #ivy.id
			ivy.string-builder.add %0 << ")"

			%3 = ivy.string-builder.end %0 -> #ivy.id

			; cout put:'{key} -> {val}'
			%4 = ptr.load %cout : ptr -> #ivy.id
			ivy.msg.send to %4, put:%3 -> void
		}

		%69 = ivy.lambda %err, %data : (#ivy.id, #ivy.id) -> void {
			%0 = ivy.string-builder.create

			ivy.string-builder.add %0 << "Error "
			ivy.string-builder.add %0 << %err : #ivy.id
			ivy.string-builder.add %0 << " occurred ("
			ivy.string-builder.add %0 << %data : #ivy.id
			ivy.string-builder.add %0 << ")"

			%4 = ivy.string-builder.end %0 -> #ivy.id

			; cout put:'{key} -> {val}'
			%5 = ptr.load %cout : ptr -> #ivy.id
			ivy.msg.send to %5, put:%4 -> void
		}

		%70 = ivy.atom "err:number-format"
		ivy.msg.send to %67, on:%70 do:%68 -> #ivy.id
		ivy.msg.send to %67, on-error:%69 -> void
		ivy.msg.send to %67, call -> void
	}
}