ivy/doc/mie/sample/Person.2.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
	%StringBuilder = ivy.global-ref @StringBuilder : 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

		%lambda.0 = ivy.lambda.body <%env> (%i: #ivy.id) -> void {
			%StringBuilder = ivy.global-ref @StringBuilder -> ptr
			%0 = ivy.msg.send to %StringBuilder, new -> #ivy.id

			%1 = ivy.str.constant "Count is "
			ivy.msg.send to %0, append:%1 -> void

			ivy.msg.send to %0, append:%i -> void

			%2 = ivy.msg.send to %0, to-string -> #ivy.id

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

			func.return : ()
		}

		%lambda.1 = ivy.lambda.body <%env> () -> void {
			%env.q = ivy.pkg.get %env[@q] : #ivy.id -> #ivy.id

			%StringBuilder = ivy.global-ref @StringBuilder -> ptr
			%0 = ivy.msg.send to %StringBuilder, new -> #ivy.id

			%1 = ivy.str.constant "Value of q is "
			ivy.msg.send to %0, append:%1 -> void

			ivy.msg.send to %0, append:%env.q -> void

			%2 = ivy.msg.send to %0, to-string -> #ivy.id

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

		ivy.method 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.method test(param:%data, _:%extra) -> void {
			%0 = ptr.load %StringBuilder : ptr -> #ivy.id
			%1 = ivy.msg.send to %0, new -> #ivy.id

			%2 = ivy.str.constant "Received "
			ivy.msg.send to %1, append:%2 -> void

			ivy.msg.send to %1, append:%data -> void

			%3 = ivy.str.constant ", "
			ivy.msg.send to %1, append:%3 -> void

			ivy.msg.send to %1, append:%extra -> void

			%4 = ivy.msg.send to %1, to-string -> #ivy.id

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

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

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

		ivy.method 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.method set-name:%name -> void {
			ptr.store %name, %self.name : #ivy.id, ptr
			func.return : ()
		}

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

		ivy.method set-age:%age in-units:%units -> void {
		^switch.cond.0:
				%0 = ivy.atom "years"
				%cmptmp.0 = ivy.cmp eq %age, %0 : (#ivy.id, #ivy.atom) -> i1
				cf.br-cond %cmptmp.0, ^switch.body.0, ^switch.cond.1

		^switch.body.0:
				ptr.store %age, %self.age : #ivy.id, ptr
				cf.br ^switch.end.0

		^switch.cond.1:
				%1 = ivy.atom "months"
				%cmptmp.1 = ivy.cmp eq %age, %1 : (#ivy.id, #ivy.atom) -> i1
				cf.br-cond %cmptmp.1, ^switch.body.1, ^switch.cond.2

		^switch.body.1:
				%d0 = i32.constant 12
				%divtmp.0 = ivy.div %age, %d0 : (#ivy.id, i32) -> #ivy.id
				ptr.store %divtmp.0, %self.age : #ivy.id, ptr
				cf.br ^switch.end.0

		^switch.cond.2:
				%2 = ivy.atom "days"
				%cmptmp.2 = ivy.cmp eq %age, %2 : (#ivy.id, #ivy.atom) -> i1
				cf.br-cond %cmptmp.2, ^switch.body.2, ^switch.default

		^switch.body.2:
				%d1 = i32.constant 365
				%divtmp.1 = ivy.div %age, %d1 : (#ivy.id, i32) -> #ivy.id
				ptr.store %divtmp.1, %self.age : #ivy.id, ptr
				cf.br ^switch.end.0

		^switch.default:
				%d2 = i32.constant 0
				cf.br ^switch.end.0

		^switch.end:
			func.return : ()
		}

		ivy.method get-age-in-units:%units -> #ivy.id {
		^switch.cond.0:
			%0 = ivy.atom "years"
			%cmptmp.0 = ivy.cmp eq %age, %0 : (#ivy.id, #ivy.atom) -> i1
			cf.br-cond %cmptmp.0, ^switch.body.0, ^switch.cond.1

		^switch.body.0:
			%v0 = ptr.load %self.age : ptr -> #ivy.id
			cf.br ^switch.end(%v0: #ivy.id)

		^switch.cond.0:
			%1 = ivy.atom "months"
			%cmptmp.1 = ivy.cmp eq %age, %1 : (#ivy.id, #ivy.atom) -> i1
			cf.br-cond %cmptmp.1, ^switch.body.1, ^switch.cond.2

		^switch.body.0:
			%v0 = ptr.load %self.age : ptr -> #ivy.id
			%d0 = i32.constant 12
			%divtmp.0 = ivy.div %v0, %d0 : (#ivy.id, i32) -> #ivy.id
			cf.br ^switch.end(%divtmp.0: #ivy.id)

		^switch.cond.0:
			%2 = ivy.atom "days"
			%cmptmp.2 = ivy.cmp eq %age, %2 : (#ivy.id, #ivy.atom) -> i1
			cf.br-cond %cmptmp.2, ^switch.body.2, ^switch.default

		^switch.body.0:
			%v1 = ptr.load %self.age : ptr -> #ivy.id
			%d1 = i32.constant 365
			%divtmp.1 = ivy.div %v1, %d1 : (#ivy.id, i32) -> #ivy.id
			cf.br ^switch.end(%divtmp.1: #ivy.id)

		^switch.default:
			%d2 = i32.constant 0
			cf.br ^switch.end(%d2.1: i32)

		^switch.end(%result: #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.p-example-property-4 : ptr -> #ivy.id
			func.return %0 : #ivy.id
		} set (%0: #ivy.id) {
			ptr.store %0, %self.p-example-property-4 : #ivy.id, ptr
			func.return : ()
		}

		ivy.object-prop example-property-5 get {
			%0 = ptr.load %self.p-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
	^while.cond:
		; i < 100
		%10 = ptr.load %i : ptr -> i32
		%11 = i32.constant 100
		%cmptmp = ivy.cmp lt %10, %11 : (i32, i32) -> i1
		scf.condition(%cmptmp)
		cf.br-cond %cmptmp, ^while.body, ^while.end

	^while.body:
		; cout put:'Count is {i}'.
		%12 = ivy.msg.send to %StringBuilder, new -> #ivy.id

		%13 = ivy.str.constant "Count is "
		ivy.msg.send to %12, append:%13 -> void

		%14 = ptr.load %i : ptr -> i32
		ivy.msg.send to %12, append:14 -> void

		%15 = ivy.msg.send to %12, to-string -> #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
		cf.br ^while.cond

	^while.end:
		; 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.iv.0 = ivy.msg.send to %22, value -> #ivy.id
		cf.br ^for.cond(%for.iv.0: #ivy.id)

	^for.step:
		ivy.msg.send to %22, move-next -> void
		%for.iv.next = ivy.msg.send to %22, value -> #ivy.id
		cf.br ^for.cond(%for.iv.next: #ivy.id)

	^for.cond(%iv: #ivy.id):
		%for.valid = ivy.is-null-ref %iv : #ivy.id -> i1
		cf.br-cond %for.valid, ^for.body(%iv: #ivy.id), ^for.end

	^for.body(%x: #ivy.id):
		; for x in 0 to:100 step:2 do
		%23 = ivy.msg.send to %StringBuilder, new -> #ivy.id

		; 'Count is {x}'
		%24 = ivy.str.constant "Count is "
		ivy.msg.send to %23, append:%24 -> void

		ivy.msg.send to %23, append:%x -> void

		%25 = ivy.msg.send to %23, to-string -> #ivy.id

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

		cf.br ^for.step

	^for.end:
		; 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.create %lambda.0 -> #ivy.id

		; 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
		%lambda.env = ivy.pkg.create -> #ivy.id
		ivy.pkg.put %lambda.env[@q] = %32 : (#ivy.id, #ivy.id)

		%33 = ivy.lambda.create <%lambda.env> %lambda.1 -> #ivy.id

		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


		%45 = ivy.pkg.create -> #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 -> #ivy.id
			%val = ivy.tuple.get-item %54[1] : #ivy.id -> #ivy.id

			; '{key} -> {val}'
			%55 = ivy.msg.send to %StringBuilder, new -> #ivy.id

			ivy.msg.send to %55, append:%key -> void

			%56 = ivy.str.constant " -> "
			ivy.msg.send to %55, append:%56 -> void

			ivy.msg.send to %55, append:%val -> void

			%57 = ivy.msg.send to %23, to-string -> #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.msg.send to %StringBuilder, new -> #ivy.id

			ivy.msg.send to %0, append:%key -> void

			%1 = ivy.str.constant "Cannot parse integer string ("
			ivy.msg.send to %0, append:%1 -> void

			ivy.msg.send to %0, append:%err -> void

			%2 = ivy.str.constant ")"
			ivy.msg.send to %0, append:%2 -> void

			%3 = ivy.msg.send to %0, to-string -> #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.msg.send to %StringBuilder, new -> #ivy.id

			ivy.msg.send to %0, append:%key -> void

			%1 = ivy.str.constant "Error "
			ivy.msg.send to %0, append:%1 -> void

			ivy.msg.send to %0, append:%err -> void

			%2 = ivy.str.constant " occurred ("
			ivy.msg.send to %0, append:%2 -> void

			ivy.msg.send to %0, append:%data -> void

			%3 = ivy.str.constant ")"

			%4 = ivy.msg.send to %0, to-string -> #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
	}
}