Merge branch 'master' of ssh://git.labs.intellij.net/jet
Conflicts: compiler/tests/org/jetbrains/jet/cfg/JetControlFlowTest.java
This commit is contained in:
svtk
@@ -0,0 +1,38 @@
|
||||
== foo ==
|
||||
fun foo() {
|
||||
val a = Array<Int>
|
||||
3
|
||||
a[10] = 4
|
||||
2
|
||||
a[10]
|
||||
100
|
||||
a[10] += 1
|
||||
}
|
||||
---------------------
|
||||
l0:
|
||||
<START> NEXT:[r(Array)] PREV:[]
|
||||
r(Array) NEXT:[r(Array<Int>)] PREV:[<START>]
|
||||
r(Array<Int>) NEXT:[w(a)] PREV:[r(Array)]
|
||||
w(a) NEXT:[r(3)] PREV:[r(Array<Int>)]
|
||||
r(3) NEXT:[r(4)] PREV:[w(a)]
|
||||
r(4) NEXT:[r(10)] PREV:[r(3)]
|
||||
r(10) NEXT:[r(a)] PREV:[r(4)]
|
||||
r(a) NEXT:[r(=)] PREV:[r(10)]
|
||||
r(=) NEXT:[w(a[10])] PREV:[r(a)]
|
||||
w(a[10]) NEXT:[r(2)] PREV:[r(=)]
|
||||
r(2) NEXT:[r(10)] PREV:[w(a[10])]
|
||||
r(10) NEXT:[r(a)] PREV:[r(2)]
|
||||
r(a) NEXT:[r(a[10])] PREV:[r(10)]
|
||||
r(a[10]) NEXT:[r(100)] PREV:[r(a)]
|
||||
r(100) NEXT:[r(10)] PREV:[r(a[10])]
|
||||
r(10) NEXT:[r(a)] PREV:[r(100)]
|
||||
r(a) NEXT:[r(a[10])] PREV:[r(10)]
|
||||
r(a[10]) NEXT:[r(1)] PREV:[r(a)]
|
||||
r(1) NEXT:[r(+=)] PREV:[r(a[10])]
|
||||
r(+=) NEXT:[w(a[10])] PREV:[r(1)]
|
||||
w(a[10]) NEXT:[<END>] PREV:[r(+=)]
|
||||
l1:
|
||||
<END> NEXT:[] PREV:[w(a[10])]
|
||||
error:
|
||||
<ERROR> NEXT:[] PREV:[]
|
||||
=====================
|
||||
@@ -0,0 +1,9 @@
|
||||
fun foo() {
|
||||
val a = Array<Int>
|
||||
3
|
||||
a[10] = 4
|
||||
2
|
||||
a[10]
|
||||
100
|
||||
a[10] += 1
|
||||
}
|
||||
@@ -0,0 +1,57 @@
|
||||
== assignments ==
|
||||
fun assignments() : Unit {
|
||||
var x = 1
|
||||
x = 2
|
||||
x += 2
|
||||
|
||||
x = if (true) 1 else 2
|
||||
|
||||
val y = true && false
|
||||
val z = false && true
|
||||
|
||||
val t = Test();
|
||||
t.x = 1
|
||||
}
|
||||
---------------------
|
||||
l0:
|
||||
<START> NEXT:[r(1)] PREV:[]
|
||||
r(1) NEXT:[w(x)] PREV:[<START>]
|
||||
w(x) NEXT:[r(2)] PREV:[r(1)]
|
||||
r(2) NEXT:[w(x)] PREV:[w(x)]
|
||||
w(x) NEXT:[r(x)] PREV:[r(2)]
|
||||
r(x) NEXT:[r(2)] PREV:[w(x)]
|
||||
r(2) NEXT:[r(+=)] PREV:[r(x)]
|
||||
r(+=) NEXT:[w(x)] PREV:[r(2)]
|
||||
w(x) NEXT:[r(true)] PREV:[r(+=)]
|
||||
r(true) NEXT:[jf(l2)] PREV:[w(x)]
|
||||
jf(l2) NEXT:[r(2), r(1)] PREV:[r(true)]
|
||||
r(1) NEXT:[jmp(l3)] PREV:[jf(l2)]
|
||||
jmp(l3) NEXT:[w(x)] PREV:[r(1)]
|
||||
l2:
|
||||
r(2) NEXT:[w(x)] PREV:[jf(l2)]
|
||||
l3:
|
||||
w(x) NEXT:[r(true)] PREV:[jmp(l3), r(2)]
|
||||
r(true) NEXT:[jf(l4)] PREV:[w(x)]
|
||||
jf(l4) NEXT:[r(true && false), r(false)] PREV:[r(true)]
|
||||
r(false) NEXT:[r(true && false)] PREV:[jf(l4)]
|
||||
l4:
|
||||
r(true && false) NEXT:[w(y)] PREV:[jf(l4), r(false)]
|
||||
w(y) NEXT:[r(false)] PREV:[r(true && false)]
|
||||
r(false) NEXT:[jf(l5)] PREV:[w(y)]
|
||||
jf(l5) NEXT:[r(false && true), r(true)] PREV:[r(false)]
|
||||
r(true) NEXT:[r(false && true)] PREV:[jf(l5)]
|
||||
l5:
|
||||
r(false && true) NEXT:[w(z)] PREV:[jf(l5), r(true)]
|
||||
w(z) NEXT:[r(Test)] PREV:[r(false && true)]
|
||||
r(Test) NEXT:[r(Test())] PREV:[w(z)]
|
||||
r(Test()) NEXT:[w(t)] PREV:[r(Test)]
|
||||
w(t) NEXT:[r(1)] PREV:[r(Test())]
|
||||
r(1) NEXT:[r(t)] PREV:[w(t)]
|
||||
r(t) NEXT:[r(=)] PREV:[r(1)]
|
||||
r(=) NEXT:[w(t.x)] PREV:[r(t)]
|
||||
w(t.x) NEXT:[<END>] PREV:[r(=)]
|
||||
l1:
|
||||
<END> NEXT:[] PREV:[w(t.x)]
|
||||
error:
|
||||
<ERROR> NEXT:[] PREV:[]
|
||||
=====================
|
||||
@@ -0,0 +1,17 @@
|
||||
class Test {
|
||||
var x : Int;
|
||||
}
|
||||
|
||||
fun assignments() : Unit {
|
||||
var x = 1
|
||||
x = 2
|
||||
x += 2
|
||||
|
||||
x = if (true) 1 else 2
|
||||
|
||||
val y = true && false
|
||||
val z = false && true
|
||||
|
||||
val t = Test();
|
||||
t.x = 1
|
||||
}
|
||||
@@ -0,0 +1,114 @@
|
||||
== anonymous_0 ==
|
||||
{1}
|
||||
---------------------
|
||||
l2:
|
||||
<START> NEXT:[r(1)] PREV:[]
|
||||
r(1) NEXT:[<END>] PREV:[<START>]
|
||||
l3:
|
||||
<END> NEXT:[] PREV:[r(1)]
|
||||
error:
|
||||
<ERROR> NEXT:[] PREV:[]
|
||||
=====================
|
||||
== f ==
|
||||
fun f(a : Boolean) : Unit {
|
||||
1
|
||||
a
|
||||
2.lng
|
||||
foo(a, 3)
|
||||
genfun<Any>()
|
||||
flfun {1}
|
||||
3.equals(4)
|
||||
|
||||
3 equals 4
|
||||
|
||||
1 + 2
|
||||
|
||||
a && true
|
||||
a || false
|
||||
|
||||
}
|
||||
---------------------
|
||||
l0:
|
||||
<START> NEXT:[r(1)] PREV:[]
|
||||
r(1) NEXT:[r(a)] PREV:[<START>]
|
||||
r(a) NEXT:[r(2)] PREV:[r(1)]
|
||||
r(2) NEXT:[r(lng)] PREV:[r(a)]
|
||||
r(lng) NEXT:[r(2.lng)] PREV:[r(2)]
|
||||
r(2.lng) NEXT:[r(a)] PREV:[r(lng)]
|
||||
r(a) NEXT:[r(3)] PREV:[r(2.lng)]
|
||||
r(3) NEXT:[r(foo)] PREV:[r(a)]
|
||||
r(foo) NEXT:[r(foo(a, 3))] PREV:[r(3)]
|
||||
r(foo(a, 3)) NEXT:[r(genfun)] PREV:[r(foo)]
|
||||
r(genfun) NEXT:[r(genfun<Any>())] PREV:[r(foo(a, 3))]
|
||||
r(genfun<Any>()) NEXT:[rf({1})] PREV:[r(genfun)]
|
||||
rf({1}) NEXT:[r(flfun)] PREV:[r(genfun<Any>())]
|
||||
r(flfun) NEXT:[r(flfun {1})] PREV:[rf({1})]
|
||||
r(flfun {1}) NEXT:[r(3)] PREV:[r(flfun)]
|
||||
r(3) NEXT:[r(4)] PREV:[r(flfun {1})]
|
||||
r(4) NEXT:[r(equals)] PREV:[r(3)]
|
||||
r(equals) NEXT:[r(equals(4))] PREV:[r(4)]
|
||||
r(equals(4)) NEXT:[r(3.equals(4))] PREV:[r(equals)]
|
||||
r(3.equals(4)) NEXT:[r(3)] PREV:[r(equals(4))]
|
||||
r(3) NEXT:[r(4)] PREV:[r(3.equals(4))]
|
||||
r(4) NEXT:[r(equals)] PREV:[r(3)]
|
||||
r(equals) NEXT:[r(3 equals 4)] PREV:[r(4)]
|
||||
r(3 equals 4) NEXT:[r(1)] PREV:[r(equals)]
|
||||
r(1) NEXT:[r(2)] PREV:[r(3 equals 4)]
|
||||
r(2) NEXT:[r(+)] PREV:[r(1)]
|
||||
r(+) NEXT:[r(1 + 2)] PREV:[r(2)]
|
||||
r(1 + 2) NEXT:[r(a)] PREV:[r(+)]
|
||||
r(a) NEXT:[jf(l4)] PREV:[r(1 + 2)]
|
||||
jf(l4) NEXT:[r(a && true), r(true)] PREV:[r(a)]
|
||||
r(true) NEXT:[r(a && true)] PREV:[jf(l4)]
|
||||
l4:
|
||||
r(a && true) NEXT:[r(a)] PREV:[jf(l4), r(true)]
|
||||
r(a) NEXT:[jt(l5)] PREV:[r(a && true)]
|
||||
jt(l5) NEXT:[r(false), r(a || false)] PREV:[r(a)]
|
||||
r(false) NEXT:[r(a || false)] PREV:[jt(l5)]
|
||||
l5:
|
||||
r(a || false) NEXT:[<END>] PREV:[jt(l5), r(false)]
|
||||
l1:
|
||||
<END> NEXT:[] PREV:[r(a || false)]
|
||||
error:
|
||||
<ERROR> NEXT:[] PREV:[]
|
||||
l2:
|
||||
<START> NEXT:[r(1)] PREV:[]
|
||||
r(1) NEXT:[<END>] PREV:[<START>]
|
||||
l3:
|
||||
<END> NEXT:[] PREV:[r(1)]
|
||||
error:
|
||||
<ERROR> NEXT:[] PREV:[]
|
||||
=====================
|
||||
== foo ==
|
||||
fun foo(a : Boolean, b : Int) : Unit {}
|
||||
---------------------
|
||||
l0:
|
||||
<START> NEXT:[read (Unit)] PREV:[]
|
||||
read (Unit) NEXT:[<END>] PREV:[<START>]
|
||||
l1:
|
||||
<END> NEXT:[] PREV:[read (Unit)]
|
||||
error:
|
||||
<ERROR> NEXT:[] PREV:[]
|
||||
=====================
|
||||
== genfun ==
|
||||
fun genfun<T>() : Unit {}
|
||||
---------------------
|
||||
l0:
|
||||
<START> NEXT:[read (Unit)] PREV:[]
|
||||
read (Unit) NEXT:[<END>] PREV:[<START>]
|
||||
l1:
|
||||
<END> NEXT:[] PREV:[read (Unit)]
|
||||
error:
|
||||
<ERROR> NEXT:[] PREV:[]
|
||||
=====================
|
||||
== flfun ==
|
||||
fun flfun(f : fun () : Any) : Unit {}
|
||||
---------------------
|
||||
l0:
|
||||
<START> NEXT:[read (Unit)] PREV:[]
|
||||
read (Unit) NEXT:[<END>] PREV:[<START>]
|
||||
l1:
|
||||
<END> NEXT:[] PREV:[read (Unit)]
|
||||
error:
|
||||
<ERROR> NEXT:[] PREV:[]
|
||||
=====================
|
||||
@@ -0,0 +1,23 @@
|
||||
fun f(a : Boolean) : Unit {
|
||||
1
|
||||
a
|
||||
2.lng
|
||||
foo(a, 3)
|
||||
genfun<Any>()
|
||||
flfun {1}
|
||||
3.equals(4)
|
||||
|
||||
3 equals 4
|
||||
|
||||
1 + 2
|
||||
|
||||
a && true
|
||||
a || false
|
||||
|
||||
}
|
||||
|
||||
fun foo(a : Boolean, b : Int) : Unit {}
|
||||
|
||||
fun genfun<T>() : Unit {}
|
||||
|
||||
fun flfun(f : fun () : Any) : Unit {}
|
||||
@@ -0,0 +1,11 @@
|
||||
== empty ==
|
||||
fun empty() {}
|
||||
---------------------
|
||||
l0:
|
||||
<START> NEXT:[read (Unit)] PREV:[]
|
||||
read (Unit) NEXT:[<END>] PREV:[<START>]
|
||||
l1:
|
||||
<END> NEXT:[] PREV:[read (Unit)]
|
||||
error:
|
||||
<ERROR> NEXT:[] PREV:[]
|
||||
=====================
|
||||
@@ -0,0 +1 @@
|
||||
fun empty() {}
|
||||
@@ -0,0 +1,19 @@
|
||||
== fail ==
|
||||
fun fail() : Nothing {
|
||||
throw java.lang.RuntimeException()
|
||||
}
|
||||
---------------------
|
||||
l0:
|
||||
<START> NEXT:[r(java)] PREV:[]
|
||||
r(java) NEXT:[r(lang)] PREV:[<START>]
|
||||
r(lang) NEXT:[r(java.lang)] PREV:[r(java)]
|
||||
r(java.lang) NEXT:[r(RuntimeException)] PREV:[r(lang)]
|
||||
r(RuntimeException) NEXT:[r(RuntimeException())] PREV:[r(java.lang)]
|
||||
r(RuntimeException()) NEXT:[r(java.lang.RuntimeException())] PREV:[r(RuntimeException)]
|
||||
r(java.lang.RuntimeException()) NEXT:[jmp(error)] PREV:[r(RuntimeException())]
|
||||
jmp(error) NEXT:[<ERROR>] PREV:[r(java.lang.RuntimeException())]
|
||||
l1:
|
||||
<END> NEXT:[] PREV:[]
|
||||
error:
|
||||
<ERROR> NEXT:[] PREV:[jmp(error)]
|
||||
=====================
|
||||
@@ -0,0 +1,3 @@
|
||||
fun fail() : Nothing {
|
||||
throw java.lang.RuntimeException()
|
||||
}
|
||||
@@ -0,0 +1,511 @@
|
||||
== t3 ==
|
||||
fun t3() {
|
||||
try {
|
||||
1
|
||||
} finally {
|
||||
2
|
||||
}
|
||||
}
|
||||
---------------------
|
||||
l0:
|
||||
<START> NEXT:[jmp?(l2)] PREV:[]
|
||||
jmp?(l2) NEXT:[r(2), r(1)] PREV:[<START>]
|
||||
r(1) NEXT:[r(2)] PREV:[jmp?(l2)]
|
||||
l2:
|
||||
r(2) NEXT:[<END>] PREV:[jmp?(l2), r(1)]
|
||||
l1:
|
||||
<END> NEXT:[] PREV:[r(2)]
|
||||
error:
|
||||
<ERROR> NEXT:[] PREV:[]
|
||||
=====================
|
||||
== t3 ==
|
||||
fun t3() {
|
||||
try {
|
||||
1
|
||||
if (2 > 3) {
|
||||
return
|
||||
}
|
||||
} finally {
|
||||
2
|
||||
}
|
||||
}
|
||||
---------------------
|
||||
l0:
|
||||
<START> NEXT:[jmp?(l2)] PREV:[]
|
||||
jmp?(l2) NEXT:[r(2), r(1)] PREV:[<START>]
|
||||
r(1) NEXT:[r(2)] PREV:[jmp?(l2)]
|
||||
r(2) NEXT:[r(3)] PREV:[r(1)]
|
||||
r(3) NEXT:[r(>)] PREV:[r(2)]
|
||||
r(>) NEXT:[r(2 > 3)] PREV:[r(3)]
|
||||
r(2 > 3) NEXT:[jf(l3)] PREV:[r(>)]
|
||||
jf(l3) NEXT:[read (Unit), r(2)] PREV:[r(2 > 3)]
|
||||
r(2) NEXT:[ret l1] PREV:[jf(l3)]
|
||||
ret l1 NEXT:[<END>] PREV:[r(2)]
|
||||
jmp(l4) NEXT:[r(2)] PREV:[]
|
||||
l3:
|
||||
read (Unit) NEXT:[r(2)] PREV:[jf(l3)]
|
||||
l2:
|
||||
l4:
|
||||
r(2) NEXT:[<END>] PREV:[jmp?(l2), jmp(l4), read (Unit)]
|
||||
l1:
|
||||
<END> NEXT:[] PREV:[ret l1, r(2)]
|
||||
error:
|
||||
<ERROR> NEXT:[] PREV:[]
|
||||
=====================
|
||||
== anonymous_0 ==
|
||||
{ () =>
|
||||
if (2 > 3) {
|
||||
return@
|
||||
}
|
||||
}
|
||||
---------------------
|
||||
l3:
|
||||
<START> NEXT:[r(2)] PREV:[]
|
||||
r(2) NEXT:[r(3)] PREV:[<START>]
|
||||
r(3) NEXT:[r(>)] PREV:[r(2)]
|
||||
r(>) NEXT:[r(2 > 3)] PREV:[r(3)]
|
||||
r(2 > 3) NEXT:[jf(l5)] PREV:[r(>)]
|
||||
jf(l5) NEXT:[read (Unit), ret l4] PREV:[r(2 > 3)]
|
||||
ret l4 NEXT:[<END>] PREV:[jf(l5)]
|
||||
jmp(l6) NEXT:[<END>] PREV:[]
|
||||
l5:
|
||||
read (Unit) NEXT:[<END>] PREV:[jf(l5)]
|
||||
l4:
|
||||
l6:
|
||||
<END> NEXT:[] PREV:[ret l4, jmp(l6), read (Unit)]
|
||||
error:
|
||||
<ERROR> NEXT:[] PREV:[]
|
||||
=====================
|
||||
== t3 ==
|
||||
fun t3() {
|
||||
try {
|
||||
1
|
||||
@{ () =>
|
||||
if (2 > 3) {
|
||||
return@
|
||||
}
|
||||
}
|
||||
} finally {
|
||||
2
|
||||
}
|
||||
}
|
||||
---------------------
|
||||
l0:
|
||||
<START> NEXT:[jmp?(l2)] PREV:[]
|
||||
jmp?(l2) NEXT:[r(2), r(1)] PREV:[<START>]
|
||||
r(1) NEXT:[rf({ () => if (2 > 3) { retu..)] PREV:[jmp?(l2)]
|
||||
rf({ () =>
|
||||
if (2 > 3) {
|
||||
return@
|
||||
}
|
||||
}) NEXT:[r(2)] PREV:[r(1)]
|
||||
l2:
|
||||
r(2) NEXT:[<END>] PREV:[jmp?(l2), rf({ () => if (2 > 3) { retu..)]
|
||||
l1:
|
||||
<END> NEXT:[] PREV:[r(2)]
|
||||
error:
|
||||
<ERROR> NEXT:[] PREV:[]
|
||||
l3:
|
||||
<START> NEXT:[r(2)] PREV:[]
|
||||
r(2) NEXT:[r(3)] PREV:[<START>]
|
||||
r(3) NEXT:[r(>)] PREV:[r(2)]
|
||||
r(>) NEXT:[r(2 > 3)] PREV:[r(3)]
|
||||
r(2 > 3) NEXT:[jf(l5)] PREV:[r(>)]
|
||||
jf(l5) NEXT:[read (Unit), ret l4] PREV:[r(2 > 3)]
|
||||
ret l4 NEXT:[<END>] PREV:[jf(l5)]
|
||||
jmp(l6) NEXT:[<END>] PREV:[]
|
||||
l5:
|
||||
read (Unit) NEXT:[<END>] PREV:[jf(l5)]
|
||||
l4:
|
||||
l6:
|
||||
<END> NEXT:[] PREV:[ret l4, jmp(l6), read (Unit)]
|
||||
error:
|
||||
<ERROR> NEXT:[] PREV:[]
|
||||
=====================
|
||||
== anonymous_1 ==
|
||||
{ () =>
|
||||
try {
|
||||
1
|
||||
if (2 > 3) {
|
||||
return@
|
||||
}
|
||||
} finally {
|
||||
2
|
||||
}
|
||||
}
|
||||
---------------------
|
||||
l2:
|
||||
<START> NEXT:[jmp?(l4)] PREV:[]
|
||||
jmp?(l4) NEXT:[r(2), r(1)] PREV:[<START>]
|
||||
r(1) NEXT:[r(2)] PREV:[jmp?(l4)]
|
||||
r(2) NEXT:[r(3)] PREV:[r(1)]
|
||||
r(3) NEXT:[r(>)] PREV:[r(2)]
|
||||
r(>) NEXT:[r(2 > 3)] PREV:[r(3)]
|
||||
r(2 > 3) NEXT:[jf(l5)] PREV:[r(>)]
|
||||
jf(l5) NEXT:[read (Unit), r(2)] PREV:[r(2 > 3)]
|
||||
r(2) NEXT:[ret l3] PREV:[jf(l5)]
|
||||
ret l3 NEXT:[<END>] PREV:[r(2)]
|
||||
jmp(l6) NEXT:[r(2)] PREV:[]
|
||||
l5:
|
||||
read (Unit) NEXT:[r(2)] PREV:[jf(l5)]
|
||||
l4:
|
||||
l6:
|
||||
r(2) NEXT:[<END>] PREV:[jmp?(l4), jmp(l6), read (Unit)]
|
||||
l3:
|
||||
<END> NEXT:[] PREV:[ret l3, r(2)]
|
||||
error:
|
||||
<ERROR> NEXT:[] PREV:[]
|
||||
=====================
|
||||
== t3 ==
|
||||
fun t3() {
|
||||
@{ () =>
|
||||
try {
|
||||
1
|
||||
if (2 > 3) {
|
||||
return@
|
||||
}
|
||||
} finally {
|
||||
2
|
||||
}
|
||||
}
|
||||
}
|
||||
---------------------
|
||||
l0:
|
||||
<START> NEXT:[rf({ () => try { 1 if (2 > 3..)] PREV:[]
|
||||
rf({ () =>
|
||||
try {
|
||||
1
|
||||
if (2 > 3) {
|
||||
return@
|
||||
}
|
||||
} finally {
|
||||
2
|
||||
}
|
||||
}) NEXT:[<END>] PREV:[<START>]
|
||||
l1:
|
||||
<END> NEXT:[] PREV:[rf({ () => try { 1 if (2 > 3..)]
|
||||
error:
|
||||
<ERROR> NEXT:[] PREV:[]
|
||||
l2:
|
||||
<START> NEXT:[jmp?(l4)] PREV:[]
|
||||
jmp?(l4) NEXT:[r(2), r(1)] PREV:[<START>]
|
||||
r(1) NEXT:[r(2)] PREV:[jmp?(l4)]
|
||||
r(2) NEXT:[r(3)] PREV:[r(1)]
|
||||
r(3) NEXT:[r(>)] PREV:[r(2)]
|
||||
r(>) NEXT:[r(2 > 3)] PREV:[r(3)]
|
||||
r(2 > 3) NEXT:[jf(l5)] PREV:[r(>)]
|
||||
jf(l5) NEXT:[read (Unit), r(2)] PREV:[r(2 > 3)]
|
||||
r(2) NEXT:[ret l3] PREV:[jf(l5)]
|
||||
ret l3 NEXT:[<END>] PREV:[r(2)]
|
||||
jmp(l6) NEXT:[r(2)] PREV:[]
|
||||
l5:
|
||||
read (Unit) NEXT:[r(2)] PREV:[jf(l5)]
|
||||
l4:
|
||||
l6:
|
||||
r(2) NEXT:[<END>] PREV:[jmp?(l4), jmp(l6), read (Unit)]
|
||||
l3:
|
||||
<END> NEXT:[] PREV:[ret l3, r(2)]
|
||||
error:
|
||||
<ERROR> NEXT:[] PREV:[]
|
||||
=====================
|
||||
== t3 ==
|
||||
fun t3() {
|
||||
@ while(true) {
|
||||
try {
|
||||
1
|
||||
if (2 > 3) {
|
||||
break @
|
||||
}
|
||||
} finally {
|
||||
2
|
||||
}
|
||||
}
|
||||
}
|
||||
---------------------
|
||||
l0:
|
||||
<START> NEXT:[r(true)] PREV:[]
|
||||
l2:
|
||||
l5:
|
||||
r(true) NEXT:[jf(l3)] PREV:[<START>, jmp(l2)]
|
||||
jf(l3) NEXT:[read (Unit), jmp?(l6)] PREV:[r(true)]
|
||||
l4:
|
||||
jmp?(l6) NEXT:[r(2), r(1)] PREV:[jf(l3)]
|
||||
r(1) NEXT:[r(2)] PREV:[jmp?(l6)]
|
||||
r(2) NEXT:[r(3)] PREV:[r(1)]
|
||||
r(3) NEXT:[r(>)] PREV:[r(2)]
|
||||
r(>) NEXT:[r(2 > 3)] PREV:[r(3)]
|
||||
r(2 > 3) NEXT:[jf(l7)] PREV:[r(>)]
|
||||
jf(l7) NEXT:[read (Unit), r(2)] PREV:[r(2 > 3)]
|
||||
r(2) NEXT:[jmp(l3)] PREV:[jf(l7)]
|
||||
jmp(l3) NEXT:[read (Unit)] PREV:[r(2)]
|
||||
jmp(l8) NEXT:[r(2)] PREV:[]
|
||||
l7:
|
||||
read (Unit) NEXT:[r(2)] PREV:[jf(l7)]
|
||||
l6:
|
||||
l8:
|
||||
r(2) NEXT:[jmp(l2)] PREV:[jmp?(l6), jmp(l8), read (Unit)]
|
||||
jmp(l2) NEXT:[r(true)] PREV:[r(2)]
|
||||
l3:
|
||||
read (Unit) NEXT:[<END>] PREV:[jf(l3), jmp(l3)]
|
||||
l1:
|
||||
<END> NEXT:[] PREV:[read (Unit)]
|
||||
error:
|
||||
<ERROR> NEXT:[] PREV:[]
|
||||
=====================
|
||||
== t3 ==
|
||||
fun t3() {
|
||||
try {
|
||||
@ while(true) {
|
||||
1
|
||||
if (2 > 3) {
|
||||
break @
|
||||
}
|
||||
}
|
||||
5
|
||||
} finally {
|
||||
2
|
||||
}
|
||||
}
|
||||
---------------------
|
||||
l0:
|
||||
<START> NEXT:[jmp?(l2)] PREV:[]
|
||||
jmp?(l2) NEXT:[r(2), r(true)] PREV:[<START>]
|
||||
l3:
|
||||
l6:
|
||||
r(true) NEXT:[jf(l4)] PREV:[jmp?(l2), jmp(l3)]
|
||||
jf(l4) NEXT:[read (Unit), r(1)] PREV:[r(true)]
|
||||
l5:
|
||||
r(1) NEXT:[r(2)] PREV:[jf(l4)]
|
||||
r(2) NEXT:[r(3)] PREV:[r(1)]
|
||||
r(3) NEXT:[r(>)] PREV:[r(2)]
|
||||
r(>) NEXT:[r(2 > 3)] PREV:[r(3)]
|
||||
r(2 > 3) NEXT:[jf(l7)] PREV:[r(>)]
|
||||
jf(l7) NEXT:[read (Unit), jmp(l4)] PREV:[r(2 > 3)]
|
||||
jmp(l4) NEXT:[read (Unit)] PREV:[jf(l7)]
|
||||
jmp(l8) NEXT:[jmp(l3)] PREV:[]
|
||||
l7:
|
||||
read (Unit) NEXT:[jmp(l3)] PREV:[jf(l7)]
|
||||
l8:
|
||||
jmp(l3) NEXT:[r(true)] PREV:[jmp(l8), read (Unit)]
|
||||
l4:
|
||||
read (Unit) NEXT:[r(5)] PREV:[jf(l4), jmp(l4)]
|
||||
r(5) NEXT:[r(2)] PREV:[read (Unit)]
|
||||
l2:
|
||||
r(2) NEXT:[<END>] PREV:[jmp?(l2), r(5)]
|
||||
l1:
|
||||
<END> NEXT:[] PREV:[r(2)]
|
||||
error:
|
||||
<ERROR> NEXT:[] PREV:[]
|
||||
=====================
|
||||
== t3 ==
|
||||
fun t3() {
|
||||
try {
|
||||
@ while(true) {
|
||||
1
|
||||
if (2 > 3) {
|
||||
break @
|
||||
}
|
||||
}
|
||||
} finally {
|
||||
2
|
||||
}
|
||||
}
|
||||
---------------------
|
||||
l0:
|
||||
<START> NEXT:[jmp?(l2)] PREV:[]
|
||||
jmp?(l2) NEXT:[r(2), r(true)] PREV:[<START>]
|
||||
l3:
|
||||
l6:
|
||||
r(true) NEXT:[jf(l4)] PREV:[jmp?(l2), jmp(l3)]
|
||||
jf(l4) NEXT:[read (Unit), r(1)] PREV:[r(true)]
|
||||
l5:
|
||||
r(1) NEXT:[r(2)] PREV:[jf(l4)]
|
||||
r(2) NEXT:[r(3)] PREV:[r(1)]
|
||||
r(3) NEXT:[r(>)] PREV:[r(2)]
|
||||
r(>) NEXT:[r(2 > 3)] PREV:[r(3)]
|
||||
r(2 > 3) NEXT:[jf(l7)] PREV:[r(>)]
|
||||
jf(l7) NEXT:[read (Unit), jmp(l4)] PREV:[r(2 > 3)]
|
||||
jmp(l4) NEXT:[read (Unit)] PREV:[jf(l7)]
|
||||
jmp(l8) NEXT:[jmp(l3)] PREV:[]
|
||||
l7:
|
||||
read (Unit) NEXT:[jmp(l3)] PREV:[jf(l7)]
|
||||
l8:
|
||||
jmp(l3) NEXT:[r(true)] PREV:[jmp(l8), read (Unit)]
|
||||
l4:
|
||||
read (Unit) NEXT:[r(2)] PREV:[jf(l4), jmp(l4)]
|
||||
l2:
|
||||
r(2) NEXT:[<END>] PREV:[jmp?(l2), read (Unit)]
|
||||
l1:
|
||||
<END> NEXT:[] PREV:[r(2)]
|
||||
error:
|
||||
<ERROR> NEXT:[] PREV:[]
|
||||
=====================
|
||||
== t3 ==
|
||||
fun t3(a : Int) {
|
||||
@ for (i in 1..a) {
|
||||
try {
|
||||
1
|
||||
if (2 > 3) {
|
||||
continue @
|
||||
}
|
||||
} finally {
|
||||
2
|
||||
}
|
||||
}
|
||||
}
|
||||
---------------------
|
||||
l0:
|
||||
<START> NEXT:[r(1)] PREV:[]
|
||||
r(1) NEXT:[r(a)] PREV:[<START>]
|
||||
r(a) NEXT:[r(..)] PREV:[r(1)]
|
||||
r(..) NEXT:[r(1..a)] PREV:[r(a)]
|
||||
r(1..a) NEXT:[w(i)] PREV:[r(..)]
|
||||
w(i) NEXT:[jmp?(l2)] PREV:[r(1..a)]
|
||||
l3:
|
||||
jmp?(l2) NEXT:[read (Unit), jmp?(l6)] PREV:[w(i)]
|
||||
l4:
|
||||
l5:
|
||||
jmp?(l6) NEXT:[r(2), r(1)] PREV:[jmp?(l2), jmp(l4), jmp?(l4)]
|
||||
r(1) NEXT:[r(2)] PREV:[jmp?(l6)]
|
||||
r(2) NEXT:[r(3)] PREV:[r(1)]
|
||||
r(3) NEXT:[r(>)] PREV:[r(2)]
|
||||
r(>) NEXT:[r(2 > 3)] PREV:[r(3)]
|
||||
r(2 > 3) NEXT:[jf(l7)] PREV:[r(>)]
|
||||
jf(l7) NEXT:[read (Unit), r(2)] PREV:[r(2 > 3)]
|
||||
r(2) NEXT:[jmp(l4)] PREV:[jf(l7)]
|
||||
jmp(l4) NEXT:[jmp?(l6)] PREV:[r(2)]
|
||||
jmp(l8) NEXT:[r(2)] PREV:[]
|
||||
l7:
|
||||
read (Unit) NEXT:[r(2)] PREV:[jf(l7)]
|
||||
l6:
|
||||
l8:
|
||||
r(2) NEXT:[jmp?(l4)] PREV:[jmp?(l6), jmp(l8), read (Unit)]
|
||||
jmp?(l4) NEXT:[jmp?(l6), read (Unit)] PREV:[r(2)]
|
||||
l2:
|
||||
read (Unit) NEXT:[<END>] PREV:[jmp?(l2), jmp?(l4)]
|
||||
l1:
|
||||
<END> NEXT:[] PREV:[read (Unit)]
|
||||
error:
|
||||
<ERROR> NEXT:[] PREV:[]
|
||||
=====================
|
||||
== t3 ==
|
||||
fun t3(a : Int) {
|
||||
try {
|
||||
@ for (i in 1..a) {
|
||||
1
|
||||
if (2 > 3) {
|
||||
continue @
|
||||
}
|
||||
}
|
||||
5
|
||||
} finally {
|
||||
2
|
||||
}
|
||||
}
|
||||
---------------------
|
||||
l0:
|
||||
<START> NEXT:[jmp?(l2)] PREV:[]
|
||||
jmp?(l2) NEXT:[r(2), r(1)] PREV:[<START>]
|
||||
r(1) NEXT:[r(a)] PREV:[jmp?(l2)]
|
||||
r(a) NEXT:[r(..)] PREV:[r(1)]
|
||||
r(..) NEXT:[r(1..a)] PREV:[r(a)]
|
||||
r(1..a) NEXT:[w(i)] PREV:[r(..)]
|
||||
w(i) NEXT:[jmp?(l3)] PREV:[r(1..a)]
|
||||
l4:
|
||||
jmp?(l3) NEXT:[read (Unit), r(1)] PREV:[w(i)]
|
||||
l5:
|
||||
l6:
|
||||
r(1) NEXT:[r(2)] PREV:[jmp?(l3), jmp(l5), jmp?(l5)]
|
||||
r(2) NEXT:[r(3)] PREV:[r(1)]
|
||||
r(3) NEXT:[r(>)] PREV:[r(2)]
|
||||
r(>) NEXT:[r(2 > 3)] PREV:[r(3)]
|
||||
r(2 > 3) NEXT:[jf(l7)] PREV:[r(>)]
|
||||
jf(l7) NEXT:[read (Unit), jmp(l5)] PREV:[r(2 > 3)]
|
||||
jmp(l5) NEXT:[r(1)] PREV:[jf(l7)]
|
||||
jmp(l8) NEXT:[jmp?(l5)] PREV:[]
|
||||
l7:
|
||||
read (Unit) NEXT:[jmp?(l5)] PREV:[jf(l7)]
|
||||
l8:
|
||||
jmp?(l5) NEXT:[r(1), read (Unit)] PREV:[jmp(l8), read (Unit)]
|
||||
l3:
|
||||
read (Unit) NEXT:[r(5)] PREV:[jmp?(l3), jmp?(l5)]
|
||||
r(5) NEXT:[r(2)] PREV:[read (Unit)]
|
||||
l2:
|
||||
r(2) NEXT:[<END>] PREV:[jmp?(l2), r(5)]
|
||||
l1:
|
||||
<END> NEXT:[] PREV:[r(2)]
|
||||
error:
|
||||
<ERROR> NEXT:[] PREV:[]
|
||||
=====================
|
||||
== t3 ==
|
||||
fun t3(a : Int) {
|
||||
try {
|
||||
@ for (i in 1..a) {
|
||||
1
|
||||
if (2 > 3) {
|
||||
continue @
|
||||
}
|
||||
}
|
||||
} finally {
|
||||
2
|
||||
}
|
||||
}
|
||||
---------------------
|
||||
l0:
|
||||
<START> NEXT:[jmp?(l2)] PREV:[]
|
||||
jmp?(l2) NEXT:[r(2), r(1)] PREV:[<START>]
|
||||
r(1) NEXT:[r(a)] PREV:[jmp?(l2)]
|
||||
r(a) NEXT:[r(..)] PREV:[r(1)]
|
||||
r(..) NEXT:[r(1..a)] PREV:[r(a)]
|
||||
r(1..a) NEXT:[w(i)] PREV:[r(..)]
|
||||
w(i) NEXT:[jmp?(l3)] PREV:[r(1..a)]
|
||||
l4:
|
||||
jmp?(l3) NEXT:[read (Unit), r(1)] PREV:[w(i)]
|
||||
l5:
|
||||
l6:
|
||||
r(1) NEXT:[r(2)] PREV:[jmp?(l3), jmp(l5), jmp?(l5)]
|
||||
r(2) NEXT:[r(3)] PREV:[r(1)]
|
||||
r(3) NEXT:[r(>)] PREV:[r(2)]
|
||||
r(>) NEXT:[r(2 > 3)] PREV:[r(3)]
|
||||
r(2 > 3) NEXT:[jf(l7)] PREV:[r(>)]
|
||||
jf(l7) NEXT:[read (Unit), jmp(l5)] PREV:[r(2 > 3)]
|
||||
jmp(l5) NEXT:[r(1)] PREV:[jf(l7)]
|
||||
jmp(l8) NEXT:[jmp?(l5)] PREV:[]
|
||||
l7:
|
||||
read (Unit) NEXT:[jmp?(l5)] PREV:[jf(l7)]
|
||||
l8:
|
||||
jmp?(l5) NEXT:[r(1), read (Unit)] PREV:[jmp(l8), read (Unit)]
|
||||
l3:
|
||||
read (Unit) NEXT:[r(2)] PREV:[jmp?(l3), jmp?(l5)]
|
||||
l2:
|
||||
r(2) NEXT:[<END>] PREV:[jmp?(l2), read (Unit)]
|
||||
l1:
|
||||
<END> NEXT:[] PREV:[r(2)]
|
||||
error:
|
||||
<ERROR> NEXT:[] PREV:[]
|
||||
=====================
|
||||
== tf ==
|
||||
fun tf() {
|
||||
try {
|
||||
return 1
|
||||
}
|
||||
finally {
|
||||
return 2
|
||||
}
|
||||
}
|
||||
---------------------
|
||||
l0:
|
||||
<START> NEXT:[jmp?(l2)] PREV:[]
|
||||
jmp?(l2) NEXT:[r(2), r(1)] PREV:[<START>]
|
||||
r(1) NEXT:[r(2)] PREV:[jmp?(l2)]
|
||||
r(2) NEXT:[ret(*) l1] PREV:[r(1)]
|
||||
ret(*) l1 NEXT:[<END>] PREV:[r(2)]
|
||||
ret(*) l1 NEXT:[<END>] PREV:[]
|
||||
l2:
|
||||
r(2) NEXT:[ret(*) l1] PREV:[jmp?(l2)]
|
||||
ret(*) l1 NEXT:[<END>] PREV:[r(2)]
|
||||
l1:
|
||||
<END> NEXT:[] PREV:[ret(*) l1, ret(*) l1, ret(*) l1]
|
||||
error:
|
||||
<ERROR> NEXT:[] PREV:[]
|
||||
=====================
|
||||
@@ -0,0 +1,133 @@
|
||||
fun t3() {
|
||||
try {
|
||||
1
|
||||
} finally {
|
||||
2
|
||||
}
|
||||
}
|
||||
|
||||
fun t3() {
|
||||
try {
|
||||
1
|
||||
if (2 > 3) {
|
||||
return
|
||||
}
|
||||
} finally {
|
||||
2
|
||||
}
|
||||
}
|
||||
|
||||
fun t3() {
|
||||
try {
|
||||
1
|
||||
@{ () =>
|
||||
if (2 > 3) {
|
||||
return@
|
||||
}
|
||||
}
|
||||
} finally {
|
||||
2
|
||||
}
|
||||
}
|
||||
|
||||
fun t3() {
|
||||
@{ () =>
|
||||
try {
|
||||
1
|
||||
if (2 > 3) {
|
||||
return@
|
||||
}
|
||||
} finally {
|
||||
2
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fun t3() {
|
||||
@ while(true) {
|
||||
try {
|
||||
1
|
||||
if (2 > 3) {
|
||||
break @
|
||||
}
|
||||
} finally {
|
||||
2
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fun t3() {
|
||||
try {
|
||||
@ while(true) {
|
||||
1
|
||||
if (2 > 3) {
|
||||
break @
|
||||
}
|
||||
}
|
||||
5
|
||||
} finally {
|
||||
2
|
||||
}
|
||||
}
|
||||
|
||||
fun t3() {
|
||||
try {
|
||||
@ while(true) {
|
||||
1
|
||||
if (2 > 3) {
|
||||
break @
|
||||
}
|
||||
}
|
||||
} finally {
|
||||
2
|
||||
}
|
||||
}
|
||||
|
||||
fun t3(a : Int) {
|
||||
@ for (i in 1..a) {
|
||||
try {
|
||||
1
|
||||
if (2 > 3) {
|
||||
continue @
|
||||
}
|
||||
} finally {
|
||||
2
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fun t3(a : Int) {
|
||||
try {
|
||||
@ for (i in 1..a) {
|
||||
1
|
||||
if (2 > 3) {
|
||||
continue @
|
||||
}
|
||||
}
|
||||
5
|
||||
} finally {
|
||||
2
|
||||
}
|
||||
}
|
||||
|
||||
fun t3(a : Int) {
|
||||
try {
|
||||
@ for (i in 1..a) {
|
||||
1
|
||||
if (2 > 3) {
|
||||
continue @
|
||||
}
|
||||
}
|
||||
} finally {
|
||||
2
|
||||
}
|
||||
}
|
||||
|
||||
fun tf() {
|
||||
try {
|
||||
return 1
|
||||
}
|
||||
finally {
|
||||
return 2
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,72 @@
|
||||
== lazyBooleans ==
|
||||
fun lazyBooleans(a : Boolean, b : Boolean) : Unit {
|
||||
if (a) {
|
||||
1
|
||||
}
|
||||
else {
|
||||
2
|
||||
}
|
||||
3
|
||||
if (a && b) 5 else 6
|
||||
7
|
||||
if (a || b) 8 else 9
|
||||
10
|
||||
if (a) 11
|
||||
12
|
||||
if (a) else 13
|
||||
14
|
||||
}
|
||||
---------------------
|
||||
l0:
|
||||
<START> NEXT:[r(a)] PREV:[]
|
||||
r(a) NEXT:[jf(l2)] PREV:[<START>]
|
||||
jf(l2) NEXT:[r(2), r(1)] PREV:[r(a)]
|
||||
r(1) NEXT:[jmp(l3)] PREV:[jf(l2)]
|
||||
jmp(l3) NEXT:[r(3)] PREV:[r(1)]
|
||||
l2:
|
||||
r(2) NEXT:[r(3)] PREV:[jf(l2)]
|
||||
l3:
|
||||
r(3) NEXT:[r(a)] PREV:[jmp(l3), r(2)]
|
||||
r(a) NEXT:[jf(l4)] PREV:[r(3)]
|
||||
jf(l4) NEXT:[jf(l5), r(b)] PREV:[r(a)]
|
||||
r(b) NEXT:[jf(l5)] PREV:[jf(l4)]
|
||||
l4:
|
||||
jf(l5) NEXT:[r(6), r(5)] PREV:[jf(l4), r(b)]
|
||||
r(5) NEXT:[jmp(l6)] PREV:[jf(l5)]
|
||||
jmp(l6) NEXT:[r(7)] PREV:[r(5)]
|
||||
l5:
|
||||
r(6) NEXT:[r(7)] PREV:[jf(l5)]
|
||||
l6:
|
||||
r(7) NEXT:[r(a)] PREV:[jmp(l6), r(6)]
|
||||
r(a) NEXT:[jt(l7)] PREV:[r(7)]
|
||||
jt(l7) NEXT:[r(b), jf(l8)] PREV:[r(a)]
|
||||
r(b) NEXT:[jf(l8)] PREV:[jt(l7)]
|
||||
l7:
|
||||
jf(l8) NEXT:[r(9), r(8)] PREV:[jt(l7), r(b)]
|
||||
r(8) NEXT:[jmp(l9)] PREV:[jf(l8)]
|
||||
jmp(l9) NEXT:[r(10)] PREV:[r(8)]
|
||||
l8:
|
||||
r(9) NEXT:[r(10)] PREV:[jf(l8)]
|
||||
l9:
|
||||
r(10) NEXT:[r(a)] PREV:[jmp(l9), r(9)]
|
||||
r(a) NEXT:[jf(l10)] PREV:[r(10)]
|
||||
jf(l10) NEXT:[read (Unit), r(11)] PREV:[r(a)]
|
||||
r(11) NEXT:[jmp(l11)] PREV:[jf(l10)]
|
||||
jmp(l11) NEXT:[r(12)] PREV:[r(11)]
|
||||
l10:
|
||||
read (Unit) NEXT:[r(12)] PREV:[jf(l10)]
|
||||
l11:
|
||||
r(12) NEXT:[r(a)] PREV:[jmp(l11), read (Unit)]
|
||||
r(a) NEXT:[jf(l12)] PREV:[r(12)]
|
||||
jf(l12) NEXT:[r(13), read (Unit)] PREV:[r(a)]
|
||||
read (Unit) NEXT:[jmp(l13)] PREV:[jf(l12)]
|
||||
jmp(l13) NEXT:[r(14)] PREV:[read (Unit)]
|
||||
l12:
|
||||
r(13) NEXT:[r(14)] PREV:[jf(l12)]
|
||||
l13:
|
||||
r(14) NEXT:[<END>] PREV:[jmp(l13), r(13)]
|
||||
l1:
|
||||
<END> NEXT:[] PREV:[r(14)]
|
||||
error:
|
||||
<ERROR> NEXT:[] PREV:[]
|
||||
=====================
|
||||
@@ -0,0 +1,17 @@
|
||||
fun lazyBooleans(a : Boolean, b : Boolean) : Unit {
|
||||
if (a) {
|
||||
1
|
||||
}
|
||||
else {
|
||||
2
|
||||
}
|
||||
3
|
||||
if (a && b) 5 else 6
|
||||
7
|
||||
if (a || b) 8 else 9
|
||||
10
|
||||
if (a) 11
|
||||
12
|
||||
if (a) else 13
|
||||
14
|
||||
}
|
||||
@@ -0,0 +1,50 @@
|
||||
== main ==
|
||||
fun main() {
|
||||
while(1 > 0) {
|
||||
2
|
||||
}
|
||||
}
|
||||
---------------------
|
||||
l0:
|
||||
<START> NEXT:[r(1)] PREV:[]
|
||||
l2:
|
||||
l5:
|
||||
r(1) NEXT:[r(0)] PREV:[<START>, jmp(l2)]
|
||||
r(0) NEXT:[r(>)] PREV:[r(1)]
|
||||
r(>) NEXT:[r(1 > 0)] PREV:[r(0)]
|
||||
r(1 > 0) NEXT:[jf(l3)] PREV:[r(>)]
|
||||
jf(l3) NEXT:[read (Unit), r(2)] PREV:[r(1 > 0)]
|
||||
l4:
|
||||
r(2) NEXT:[jmp(l2)] PREV:[jf(l3)]
|
||||
jmp(l2) NEXT:[r(1)] PREV:[r(2)]
|
||||
l3:
|
||||
read (Unit) NEXT:[<END>] PREV:[jf(l3)]
|
||||
l1:
|
||||
<END> NEXT:[] PREV:[read (Unit)]
|
||||
error:
|
||||
<ERROR> NEXT:[] PREV:[]
|
||||
=====================
|
||||
== dowhile ==
|
||||
fun dowhile() {
|
||||
do {return}
|
||||
while(1 > 0)
|
||||
}
|
||||
---------------------
|
||||
l0:
|
||||
<START> NEXT:[ret l1] PREV:[]
|
||||
l2:
|
||||
l4:
|
||||
ret l1 NEXT:[<END>] PREV:[<START>, jt(l2)]
|
||||
l5:
|
||||
r(1) NEXT:[r(0)] PREV:[]
|
||||
r(0) NEXT:[r(>)] PREV:[r(1)]
|
||||
r(>) NEXT:[r(1 > 0)] PREV:[r(0)]
|
||||
r(1 > 0) NEXT:[jt(l2)] PREV:[r(>)]
|
||||
jt(l2) NEXT:[read (Unit), ret l1] PREV:[r(1 > 0)]
|
||||
l3:
|
||||
read (Unit) NEXT:[<END>] PREV:[jt(l2)]
|
||||
l1:
|
||||
<END> NEXT:[] PREV:[ret l1, read (Unit)]
|
||||
error:
|
||||
<ERROR> NEXT:[] PREV:[]
|
||||
=====================
|
||||
@@ -0,0 +1,10 @@
|
||||
fun main() {
|
||||
while(1 > 0) {
|
||||
2
|
||||
}
|
||||
}
|
||||
|
||||
fun dowhile() {
|
||||
do {return}
|
||||
while(1 > 0)
|
||||
}
|
||||
@@ -0,0 +1,18 @@
|
||||
== blockAndAndMismatch ==
|
||||
fun blockAndAndMismatch() : Boolean {
|
||||
false || (return false)
|
||||
}
|
||||
---------------------
|
||||
l0:
|
||||
<START> NEXT:[r(false)] PREV:[]
|
||||
r(false) NEXT:[jt(l2)] PREV:[<START>]
|
||||
jt(l2) NEXT:[r(false), r(false || (return false))] PREV:[r(false)]
|
||||
r(false) NEXT:[ret(*) l1] PREV:[jt(l2)]
|
||||
ret(*) l1 NEXT:[<END>] PREV:[r(false)]
|
||||
l2:
|
||||
r(false || (return false)) NEXT:[<END>] PREV:[jt(l2)]
|
||||
l1:
|
||||
<END> NEXT:[] PREV:[ret(*) l1, r(false || (return false))]
|
||||
error:
|
||||
<ERROR> NEXT:[] PREV:[]
|
||||
=====================
|
||||
@@ -0,0 +1,3 @@
|
||||
fun blockAndAndMismatch() : Boolean {
|
||||
false || (return false)
|
||||
}
|
||||
@@ -0,0 +1,11 @@
|
||||
== short ==
|
||||
fun short() = 1
|
||||
---------------------
|
||||
l0:
|
||||
<START> NEXT:[r(1)] PREV:[]
|
||||
r(1) NEXT:[<END>] PREV:[<START>]
|
||||
l1:
|
||||
<END> NEXT:[] PREV:[r(1)]
|
||||
error:
|
||||
<ERROR> NEXT:[] PREV:[]
|
||||
=====================
|
||||
@@ -0,0 +1 @@
|
||||
fun short() = 1
|
||||
Reference in New Issue
Block a user