carbon-language/carbon-lang
1
0
Fork 0
mirror of https://github.com/carbon-language/carbon-lang.git synced 2026-09-28 22:02:37 +01:00
Code Issues Packages Projects Releases 10 Wiki Activity

Revert "improve abstraction for AssocList, fix bug in optional else (#315)" (#320)

Browse Source 
This reverts commit bf6bb800c4.
This commit is contained in:
Dave Abrahams
2021-03-01 12:26:56 -05:00
committed by GitHub
parent 8b3bb7c5e9
commit f5300a84e5
55 changed files with 7431 additions and 293 deletions
Download Patch File Download Diff File Expand all files Collapse all files
executable_semantics/testdata/block1.golden
Vendored
+264
View File
@@ -1 +1,265 @@
********** source program **********
fn main () -> Int {
var Int: x = 0;
{
var Int: x = 1;
}
return x;
}
********** type checking **********
--- step exp Int --->
--- step exp Int --->
--- step exp Int --->
--- step exp Int --->
********** type checking complete **********
fn main () -> Int {
var Int: x = 0;
{
var Int: x = 1;
}
return x;
}
********** starting execution **********
********** initializing globals **********
--- step exp () --->
********** calling main function **********
{
stack: top{main()<-1>}
heap: fun<main>,
env: main: fun<main>,
}
--- step exp main() --->
{
stack: top{main<-1> :: main()<0>}
heap: fun<main>,
env: main: fun<main>,
}
--- step exp main --->
{
stack: top{fun<main><-1> :: main()<0>}
heap: fun<main>,
env: main: fun<main>,
}
--- handle value fun<main> with main()<1>(fun<main>,) --->
{
stack: top{()<-1> :: main()<1>(fun<main>,)}
heap: fun<main>,
env: main: fun<main>,
}
--- step exp () --->
{
stack: top{()<-1> :: main()<1>(fun<main>,)}
heap: fun<main>,
env: main: fun<main>,
}
--- handle value () with main()<2>(fun<main>,(),) --->
pattern_match((), ())
{
stack: main{var Int: x = 0; ... <-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- step stmt var Int: x = 0; ... --->
{
stack: main{var Int: x = 0;<-1> :: {
...
}
... <-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- step stmt var Int: x = 0; --->
{
stack: main{0<-1> :: var Int: x = 0;<0> :: {
...
}
... <-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- step exp 0 --->
{
stack: main{0<-1> :: var Int: x = 0;<0> :: {
...
}
... <-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- handle value 0 with var Int: x = 0;<1>(0,) --->
{
stack: main{Int: x<-1> :: var Int: x = 0;<1>(0,) :: {
...
}
... <-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- step exp Int: x --->
{
stack: main{Int<-1> :: Int: x<0> :: var Int: x = 0;<1>(0,) :: {
...
}
... <-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- step exp Int --->
{
stack: main{Int<-1> :: Int: x<0> :: var Int: x = 0;<1>(0,) :: {
...
}
... <-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- handle value Int with Int: x<1>(Int,) --->
{
stack: main{Int: x<-1> :: var Int: x = 0;<1>(0,) :: {
...
}
... <-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- handle value Int: x with var Int: x = 0;<2>(0,Int: x,) --->
pattern_match(Int: x, 0)
{
stack: main{{
...
}
... <-1>} :: top{}
heap: fun<main>, 0,
env: x: 0, main: fun<main>,
}
--- step stmt {
...
}
... --->
{
stack: main{{
...
}
<-1> :: return x;<-1>} :: top{}
heap: fun<main>, 0,
env: x: 0, main: fun<main>,
}
--- step stmt {
...
}
--->
{
stack: main{var Int: x = 1;<-1> :: {
...
}
<0> :: return x;<-1>} :: top{}
heap: fun<main>, 0,
env: x: 0, main: fun<main>,
}
--- step stmt var Int: x = 1; --->
{
stack: main{var Int: x = 1;<-1> :: {
...
}
<0> :: return x;<-1>} :: top{}
heap: fun<main>, 0,
env: x: 0, main: fun<main>,
}
--- step stmt var Int: x = 1; --->
{
stack: main{1<-1> :: var Int: x = 1;<0> :: {
...
}
<0> :: return x;<-1>} :: top{}
heap: fun<main>, 0,
env: x: 0, main: fun<main>,
}
--- step exp 1 --->
{
stack: main{1<-1> :: var Int: x = 1;<0> :: {
...
}
<0> :: return x;<-1>} :: top{}
heap: fun<main>, 0,
env: x: 0, main: fun<main>,
}
--- handle value 1 with var Int: x = 1;<1>(1,) --->
{
stack: main{Int: x<-1> :: var Int: x = 1;<1>(1,) :: {
...
}
<0> :: return x;<-1>} :: top{}
heap: fun<main>, 0,
env: x: 0, main: fun<main>,
}
--- step exp Int: x --->
{
stack: main{Int<-1> :: Int: x<0> :: var Int: x = 1;<1>(1,) :: {
...
}
<0> :: return x;<-1>} :: top{}
heap: fun<main>, 0,
env: x: 0, main: fun<main>,
}
--- step exp Int --->
{
stack: main{Int<-1> :: Int: x<0> :: var Int: x = 1;<1>(1,) :: {
...
}
<0> :: return x;<-1>} :: top{}
heap: fun<main>, 0,
env: x: 0, main: fun<main>,
}
--- handle value Int with Int: x<1>(Int,) --->
{
stack: main{Int: x<-1> :: var Int: x = 1;<1>(1,) :: {
...
}
<0> :: return x;<-1>} :: top{}
heap: fun<main>, 0,
env: x: 0, main: fun<main>,
}
--- handle value Int: x with var Int: x = 1;<2>(1,Int: x,) --->
pattern_match(Int: x, 1)
{
stack: main{{
...
}
<0> :: return x;<-1>} :: top{}
heap: fun<main>, 0, 1,
env: x: 1, x: 0, main: fun<main>,
}
--- step stmt {
...
}
--->
{
stack: main{return x;<-1>} :: top{}
heap: fun<main>, 0, !!1,
env: x: 0, main: fun<main>,
}
--- step stmt return x; --->
{
stack: main{x<-1> :: return x;<0>} :: top{}
heap: fun<main>, 0, !!1,
env: x: 0, main: fun<main>,
}
--- step exp x --->
{
stack: main{0<-1> :: return x;<0>} :: top{}
heap: fun<main>, 0, !!1,
env: x: 0, main: fun<main>,
}
--- handle value 0 with return x;<1>(0,) --->
{
stack: top{0<-1>}
heap: fun<main>, !!0, !!1,
env: main: fun<main>,
}
result: 0
executable_semantics/testdata/break1.golden
Vendored
+819
View File
@@ -1,2 +1,821 @@
MakeBlock
********** source program **********
fn main () -> Int {
var Int: x = 2;
while (true)
{
if ((x == 0))
break;
else
x = (x - 1);
}
return x;
}
********** type checking **********
--- step exp Int --->
--- step exp Int --->
--- step exp Int --->
********** type checking complete **********
fn main () -> Int {
var Int: x = 2;
while (true)
{
if ((x == 0))
break;
else
x = (x - 1);
}
return x;
}
********** starting execution **********
********** initializing globals **********
--- step exp () --->
********** calling main function **********
{
stack: top{main()<-1>}
heap: fun<main>,
env: main: fun<main>,
}
--- step exp main() --->
{
stack: top{main<-1> :: main()<0>}
heap: fun<main>,
env: main: fun<main>,
}
--- step exp main --->
{
stack: top{fun<main><-1> :: main()<0>}
heap: fun<main>,
env: main: fun<main>,
}
--- handle value fun<main> with main()<1>(fun<main>,) --->
{
stack: top{()<-1> :: main()<1>(fun<main>,)}
heap: fun<main>,
env: main: fun<main>,
}
--- step exp () --->
{
stack: top{()<-1> :: main()<1>(fun<main>,)}
heap: fun<main>,
env: main: fun<main>,
}
--- handle value () with main()<2>(fun<main>,(),) --->
pattern_match((), ())
{
stack: main{var Int: x = 2; ... <-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- step stmt var Int: x = 2; ... --->
{
stack: main{var Int: x = 2;<-1> :: while (true)
... ... <-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- step stmt var Int: x = 2; --->
{
stack: main{2<-1> :: var Int: x = 2;<0> :: while (true)
... ... <-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- step exp 2 --->
{
stack: main{2<-1> :: var Int: x = 2;<0> :: while (true)
... ... <-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- handle value 2 with var Int: x = 2;<1>(2,) --->
{
stack: main{Int: x<-1> :: var Int: x = 2;<1>(2,) :: while (true)
... ... <-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- step exp Int: x --->
{
stack: main{Int<-1> :: Int: x<0> :: var Int: x = 2;<1>(2,) :: while (true)
... ... <-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- step exp Int --->
{
stack: main{Int<-1> :: Int: x<0> :: var Int: x = 2;<1>(2,) :: while (true)
... ... <-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- handle value Int with Int: x<1>(Int,) --->
{
stack: main{Int: x<-1> :: var Int: x = 2;<1>(2,) :: while (true)
... ... <-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- handle value Int: x with var Int: x = 2;<2>(2,Int: x,) --->
pattern_match(Int: x, 2)
{
stack: main{while (true)
... ... <-1>} :: top{}
heap: fun<main>, 2,
env: x: 2, main: fun<main>,
}
--- step stmt while (true)
... ... --->
{
stack: main{while (true)
... <-1> :: return x;<-1>} :: top{}
heap: fun<main>, 2,
env: x: 2, main: fun<main>,
}
--- step stmt while (true)
... --->
{
stack: main{true<-1> :: while (true)
... <0> :: return x;<-1>} :: top{}
heap: fun<main>, 2,
env: x: 2, main: fun<main>,
}
--- step exp true --->
{
stack: main{true<-1> :: while (true)
... <0> :: return x;<-1>} :: top{}
heap: fun<main>, 2,
env: x: 2, main: fun<main>,
}
--- handle value true with while (true)
... <1>(true,) --->
{
stack: main{{
...
}
<-1> :: while (true)
... <-1> :: return x;<-1>} :: top{}
heap: fun<main>, 2,
env: x: 2, main: fun<main>,
}
--- step stmt {
...
}
--->
{
stack: main{if ((x == 0))
...
else
... <-1> :: {
...
}
<0> :: while (true)
... <-1> :: return x;<-1>} :: top{}
heap: fun<main>, 2,
env: x: 2, main: fun<main>,
}
--- step stmt if ((x == 0))
...
else
... --->
{
stack: main{if ((x == 0))
...
else
... <-1> :: {
...
}
<0> :: while (true)
... <-1> :: return x;<-1>} :: top{}
heap: fun<main>, 2,
env: x: 2, main: fun<main>,
}
--- step stmt if ((x == 0))
...
else
... --->
{
stack: main{(x == 0)<-1> :: if ((x == 0))
...
else
... <0> :: {
...
}
<0> :: while (true)
... <-1> :: return x;<-1>} :: top{}
heap: fun<main>, 2,
env: x: 2, main: fun<main>,
}
--- step exp (x == 0) --->
{
stack: main{x<-1> :: (x == 0)<0> :: if ((x == 0))
...
else
... <0> :: {
...
}
<0> :: while (true)
... <-1> :: return x;<-1>} :: top{}
heap: fun<main>, 2,
env: x: 2, main: fun<main>,
}
--- step exp x --->
{
stack: main{2<-1> :: (x == 0)<0> :: if ((x == 0))
...
else
... <0> :: {
...
}
<0> :: while (true)
... <-1> :: return x;<-1>} :: top{}
heap: fun<main>, 2,
env: x: 2, main: fun<main>,
}
--- handle value 2 with (x == 0)<1>(2,) --->
{
stack: main{0<-1> :: (x == 0)<1>(2,) :: if ((x == 0))
...
else
... <0> :: {
...
}
<0> :: while (true)
... <-1> :: return x;<-1>} :: top{}
heap: fun<main>, 2,
env: x: 2, main: fun<main>,
}
--- step exp 0 --->
{
stack: main{0<-1> :: (x == 0)<1>(2,) :: if ((x == 0))
...
else
... <0> :: {
...
}
<0> :: while (true)
... <-1> :: return x;<-1>} :: top{}
heap: fun<main>, 2,
env: x: 2, main: fun<main>,
}
--- handle value 0 with (x == 0)<2>(2,0,) --->
{
stack: main{false<-1> :: if ((x == 0))
...
else
... <0> :: {
...
}
<0> :: while (true)
... <-1> :: return x;<-1>} :: top{}
heap: fun<main>, 2,
env: x: 2, main: fun<main>,
}
--- handle value false with if ((x == 0))
...
else
... <1>(false,) --->
{
stack: main{x = (x - 1);<-1> :: {
...
}
<0> :: while (true)
... <-1> :: return x;<-1>} :: top{}
heap: fun<main>, 2,
env: x: 2, main: fun<main>,
}
--- step stmt x = (x - 1); --->
{
stack: main{x<-1> :: x = (x - 1);<0> :: {
...
}
<0> :: while (true)
... <-1> :: return x;<-1>} :: top{}
heap: fun<main>, 2,
env: x: 2, main: fun<main>,
}
--- step lvalue x --->
{
stack: main{ptr<1><-1> :: x = (x - 1);<0> :: {
...
}
<0> :: while (true)
... <-1> :: return x;<-1>} :: top{}
heap: fun<main>, 2,
env: x: 2, main: fun<main>,
}
--- handle value ptr<1> with x = (x - 1);<1>(ptr<1>,) --->
{
stack: main{(x - 1)<-1> :: x = (x - 1);<1>(ptr<1>,) :: {
...
}
<0> :: while (true)
... <-1> :: return x;<-1>} :: top{}
heap: fun<main>, 2,
env: x: 2, main: fun<main>,
}
--- step exp (x - 1) --->
{
stack: main{x<-1> :: (x - 1)<0> :: x = (x - 1);<1>(ptr<1>,) :: {
...
}
<0> :: while (true)
... <-1> :: return x;<-1>} :: top{}
heap: fun<main>, 2,
env: x: 2, main: fun<main>,
}
--- step exp x --->
{
stack: main{2<-1> :: (x - 1)<0> :: x = (x - 1);<1>(ptr<1>,) :: {
...
}
<0> :: while (true)
... <-1> :: return x;<-1>} :: top{}
heap: fun<main>, 2,
env: x: 2, main: fun<main>,
}
--- handle value 2 with (x - 1)<1>(2,) --->
{
stack: main{1<-1> :: (x - 1)<1>(2,) :: x = (x - 1);<1>(ptr<1>,) :: {
...
}
<0> :: while (true)
... <-1> :: return x;<-1>} :: top{}
heap: fun<main>, 2,
env: x: 2, main: fun<main>,
}
--- step exp 1 --->
{
stack: main{1<-1> :: (x - 1)<1>(2,) :: x = (x - 1);<1>(ptr<1>,) :: {
...
}
<0> :: while (true)
... <-1> :: return x;<-1>} :: top{}
heap: fun<main>, 2,
env: x: 2, main: fun<main>,
}
--- handle value 1 with (x - 1)<2>(2,1,) --->
{
stack: main{1<-1> :: x = (x - 1);<1>(ptr<1>,) :: {
...
}
<0> :: while (true)
... <-1> :: return x;<-1>} :: top{}
heap: fun<main>, 2,
env: x: 2, main: fun<main>,
}
--- handle value 1 with x = (x - 1);<2>(ptr<1>,1,) --->
{
stack: main{{
...
}
<0> :: while (true)
... <-1> :: return x;<-1>} :: top{}
heap: fun<main>, 1,
env: x: 1, main: fun<main>,
}
--- step stmt {
...
}
--->
{
stack: main{while (true)
... <-1> :: return x;<-1>} :: top{}
heap: fun<main>, 1,
env: x: 1, main: fun<main>,
}
--- step stmt while (true)
... --->
{
stack: main{true<-1> :: while (true)
... <0> :: return x;<-1>} :: top{}
heap: fun<main>, 1,
env: x: 1, main: fun<main>,
}
--- step exp true --->
{
stack: main{true<-1> :: while (true)
... <0> :: return x;<-1>} :: top{}
heap: fun<main>, 1,
env: x: 1, main: fun<main>,
}
--- handle value true with while (true)
... <1>(true,) --->
{
stack: main{{
...
}
<-1> :: while (true)
... <-1> :: return x;<-1>} :: top{}
heap: fun<main>, 1,
env: x: 1, main: fun<main>,
}
--- step stmt {
...
}
--->
{
stack: main{if ((x == 0))
...
else
... <-1> :: {
...
}
<0> :: while (true)
... <-1> :: return x;<-1>} :: top{}
heap: fun<main>, 1,
env: x: 1, main: fun<main>,
}
--- step stmt if ((x == 0))
...
else
... --->
{
stack: main{if ((x == 0))
...
else
... <-1> :: {
...
}
<0> :: while (true)
... <-1> :: return x;<-1>} :: top{}
heap: fun<main>, 1,
env: x: 1, main: fun<main>,
}
--- step stmt if ((x == 0))
...
else
... --->
{
stack: main{(x == 0)<-1> :: if ((x == 0))
...
else
... <0> :: {
...
}
<0> :: while (true)
... <-1> :: return x;<-1>} :: top{}
heap: fun<main>, 1,
env: x: 1, main: fun<main>,
}
--- step exp (x == 0) --->
{
stack: main{x<-1> :: (x == 0)<0> :: if ((x == 0))
...
else
... <0> :: {
...
}
<0> :: while (true)
... <-1> :: return x;<-1>} :: top{}
heap: fun<main>, 1,
env: x: 1, main: fun<main>,
}
--- step exp x --->
{
stack: main{1<-1> :: (x == 0)<0> :: if ((x == 0))
...
else
... <0> :: {
...
}
<0> :: while (true)
... <-1> :: return x;<-1>} :: top{}
heap: fun<main>, 1,
env: x: 1, main: fun<main>,
}
--- handle value 1 with (x == 0)<1>(1,) --->
{
stack: main{0<-1> :: (x == 0)<1>(1,) :: if ((x == 0))
...
else
... <0> :: {
...
}
<0> :: while (true)
... <-1> :: return x;<-1>} :: top{}
heap: fun<main>, 1,
env: x: 1, main: fun<main>,
}
--- step exp 0 --->
{
stack: main{0<-1> :: (x == 0)<1>(1,) :: if ((x == 0))
...
else
... <0> :: {
...
}
<0> :: while (true)
... <-1> :: return x;<-1>} :: top{}
heap: fun<main>, 1,
env: x: 1, main: fun<main>,
}
--- handle value 0 with (x == 0)<2>(1,0,) --->
{
stack: main{false<-1> :: if ((x == 0))
...
else
... <0> :: {
...
}
<0> :: while (true)
... <-1> :: return x;<-1>} :: top{}
heap: fun<main>, 1,
env: x: 1, main: fun<main>,
}
--- handle value false with if ((x == 0))
...
else
... <1>(false,) --->
{
stack: main{x = (x - 1);<-1> :: {
...
}
<0> :: while (true)
... <-1> :: return x;<-1>} :: top{}
heap: fun<main>, 1,
env: x: 1, main: fun<main>,
}
--- step stmt x = (x - 1); --->
{
stack: main{x<-1> :: x = (x - 1);<0> :: {
...
}
<0> :: while (true)
... <-1> :: return x;<-1>} :: top{}
heap: fun<main>, 1,
env: x: 1, main: fun<main>,
}
--- step lvalue x --->
{
stack: main{ptr<1><-1> :: x = (x - 1);<0> :: {
...
}
<0> :: while (true)
... <-1> :: return x;<-1>} :: top{}
heap: fun<main>, 1,
env: x: 1, main: fun<main>,
}
--- handle value ptr<1> with x = (x - 1);<1>(ptr<1>,) --->
{
stack: main{(x - 1)<-1> :: x = (x - 1);<1>(ptr<1>,) :: {
...
}
<0> :: while (true)
... <-1> :: return x;<-1>} :: top{}
heap: fun<main>, 1,
env: x: 1, main: fun<main>,
}
--- step exp (x - 1) --->
{
stack: main{x<-1> :: (x - 1)<0> :: x = (x - 1);<1>(ptr<1>,) :: {
...
}
<0> :: while (true)
... <-1> :: return x;<-1>} :: top{}
heap: fun<main>, 1,
env: x: 1, main: fun<main>,
}
--- step exp x --->
{
stack: main{1<-1> :: (x - 1)<0> :: x = (x - 1);<1>(ptr<1>,) :: {
...
}
<0> :: while (true)
... <-1> :: return x;<-1>} :: top{}
heap: fun<main>, 1,
env: x: 1, main: fun<main>,
}
--- handle value 1 with (x - 1)<1>(1,) --->
{
stack: main{1<-1> :: (x - 1)<1>(1,) :: x = (x - 1);<1>(ptr<1>,) :: {
...
}
<0> :: while (true)
... <-1> :: return x;<-1>} :: top{}
heap: fun<main>, 1,
env: x: 1, main: fun<main>,
}
--- step exp 1 --->
{
stack: main{1<-1> :: (x - 1)<1>(1,) :: x = (x - 1);<1>(ptr<1>,) :: {
...
}
<0> :: while (true)
... <-1> :: return x;<-1>} :: top{}
heap: fun<main>, 1,
env: x: 1, main: fun<main>,
}
--- handle value 1 with (x - 1)<2>(1,1,) --->
{
stack: main{0<-1> :: x = (x - 1);<1>(ptr<1>,) :: {
...
}
<0> :: while (true)
... <-1> :: return x;<-1>} :: top{}
heap: fun<main>, 1,
env: x: 1, main: fun<main>,
}
--- handle value 0 with x = (x - 1);<2>(ptr<1>,0,) --->
{
stack: main{{
...
}
<0> :: while (true)
... <-1> :: return x;<-1>} :: top{}
heap: fun<main>, 0,
env: x: 0, main: fun<main>,
}
--- step stmt {
...
}
--->
{
stack: main{while (true)
... <-1> :: return x;<-1>} :: top{}
heap: fun<main>, 0,
env: x: 0, main: fun<main>,
}
--- step stmt while (true)
... --->
{
stack: main{true<-1> :: while (true)
... <0> :: return x;<-1>} :: top{}
heap: fun<main>, 0,
env: x: 0, main: fun<main>,
}
--- step exp true --->
{
stack: main{true<-1> :: while (true)
... <0> :: return x;<-1>} :: top{}
heap: fun<main>, 0,
env: x: 0, main: fun<main>,
}
--- handle value true with while (true)
... <1>(true,) --->
{
stack: main{{
...
}
<-1> :: while (true)
... <-1> :: return x;<-1>} :: top{}
heap: fun<main>, 0,
env: x: 0, main: fun<main>,
}
--- step stmt {
...
}
--->
{
stack: main{if ((x == 0))
...
else
... <-1> :: {
...
}
<0> :: while (true)
... <-1> :: return x;<-1>} :: top{}
heap: fun<main>, 0,
env: x: 0, main: fun<main>,
}
--- step stmt if ((x == 0))
...
else
... --->
{
stack: main{if ((x == 0))
...
else
... <-1> :: {
...
}
<0> :: while (true)
... <-1> :: return x;<-1>} :: top{}
heap: fun<main>, 0,
env: x: 0, main: fun<main>,
}
--- step stmt if ((x == 0))
...
else
... --->
{
stack: main{(x == 0)<-1> :: if ((x == 0))
...
else
... <0> :: {
...
}
<0> :: while (true)
... <-1> :: return x;<-1>} :: top{}
heap: fun<main>, 0,
env: x: 0, main: fun<main>,
}
--- step exp (x == 0) --->
{
stack: main{x<-1> :: (x == 0)<0> :: if ((x == 0))
...
else
... <0> :: {
...
}
<0> :: while (true)
... <-1> :: return x;<-1>} :: top{}
heap: fun<main>, 0,
env: x: 0, main: fun<main>,
}
--- step exp x --->
{
stack: main{0<-1> :: (x == 0)<0> :: if ((x == 0))
...
else
... <0> :: {
...
}
<0> :: while (true)
... <-1> :: return x;<-1>} :: top{}
heap: fun<main>, 0,
env: x: 0, main: fun<main>,
}
--- handle value 0 with (x == 0)<1>(0,) --->
{
stack: main{0<-1> :: (x == 0)<1>(0,) :: if ((x == 0))
...
else
... <0> :: {
...
}
<0> :: while (true)
... <-1> :: return x;<-1>} :: top{}
heap: fun<main>, 0,
env: x: 0, main: fun<main>,
}
--- step exp 0 --->
{
stack: main{0<-1> :: (x == 0)<1>(0,) :: if ((x == 0))
...
else
... <0> :: {
...
}
<0> :: while (true)
... <-1> :: return x;<-1>} :: top{}
heap: fun<main>, 0,
env: x: 0, main: fun<main>,
}
--- handle value 0 with (x == 0)<2>(0,0,) --->
{
stack: main{true<-1> :: if ((x == 0))
...
else
... <0> :: {
...
}
<0> :: while (true)
... <-1> :: return x;<-1>} :: top{}
heap: fun<main>, 0,
env: x: 0, main: fun<main>,
}
--- handle value true with if ((x == 0))
...
else
... <1>(true,) --->
{
stack: main{break;<-1> :: {
...
}
<0> :: while (true)
... <-1> :: return x;<-1>} :: top{}
heap: fun<main>, 0,
env: x: 0, main: fun<main>,
}
--- step stmt break; --->
{
stack: main{return x;<-1>} :: top{}
heap: fun<main>, 0,
env: x: 0, main: fun<main>,
}
--- step stmt return x; --->
{
stack: main{x<-1> :: return x;<0>} :: top{}
heap: fun<main>, 0,
env: x: 0, main: fun<main>,
}
--- step exp x --->
{
stack: main{0<-1> :: return x;<0>} :: top{}
heap: fun<main>, 0,
env: x: 0, main: fun<main>,
}
--- handle value 0 with return x;<1>(0,) --->
{
stack: top{0<-1>}
heap: fun<main>, !!0,
env: main: fun<main>,
}
result: 0
executable_semantics/testdata/choice1.golden
Vendored
+44 -1
View File
@@ -1 +1,44 @@
result: 0
********** source program **********
choice Ints {
alt None ();
alt One Int;
alt Two (0 = Int, 1 = Int);
}
fn main () -> Int {
var auto: x = Ints.None();
var auto: y = Ints.One(0 = 42);
var auto: n = 0;
match (y) {
case Ints.None =>
n = (n + 2);
case Ints.One(0 = auto: x) =>
n = ((x + 1) - 42);
case Ints.Two(0 = auto: a, 1 = auto: b) =>
n = 2;
}
match (x) {
case Ints.One(0 = auto: x) =>
n = (x + 2);
case Ints.None() =>
n = (n - 1);
case Ints.Two(0 = auto: x, 1 = auto: y) =>
n = 5;
}
return n;
}
********** type checking **********
--- step exp () --->
--- step exp Int --->
--- step exp (0 = Int, 1 = Int) --->
--- step exp Int --->
--- handle value Int with (0 = Int, 1 = Int)<1>(Int,) --->
--- step exp Int --->
--- handle value Int with (0 = Int, 1 = Int)<2>(Int,Int,) --->
--- step exp Int --->
--- step exp Int --->
--- step exp auto --->
13: type error in call
expected: Int
actual: Tuple(0 = Int)
EXIT CODE: 255
executable_semantics/testdata/continue1.golden
Vendored
+615
View File
@@ -1 +1,616 @@
********** source program **********
fn main () -> Int {
var auto: x = 2;
while ((! (x == 0)))
{
x = (x - 1);
continue;
x = (x + 1);
}
return x;
}
********** type checking **********
--- step exp Int --->
--- step exp Int --->
--- step exp auto --->
********** type checking complete **********
fn main () -> Int {
var auto: x = 2;
while ((! (x == 0)))
{
x = (x - 1);
continue;
x = (x + 1);
}
return x;
}
********** starting execution **********
********** initializing globals **********
--- step exp () --->
********** calling main function **********
{
stack: top{main()<-1>}
heap: fun<main>,
env: main: fun<main>,
}
--- step exp main() --->
{
stack: top{main<-1> :: main()<0>}
heap: fun<main>,
env: main: fun<main>,
}
--- step exp main --->
{
stack: top{fun<main><-1> :: main()<0>}
heap: fun<main>,
env: main: fun<main>,
}
--- handle value fun<main> with main()<1>(fun<main>,) --->
{
stack: top{()<-1> :: main()<1>(fun<main>,)}
heap: fun<main>,
env: main: fun<main>,
}
--- step exp () --->
{
stack: top{()<-1> :: main()<1>(fun<main>,)}
heap: fun<main>,
env: main: fun<main>,
}
--- handle value () with main()<2>(fun<main>,(),) --->
pattern_match((), ())
{
stack: main{var auto: x = 2; ... <-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- step stmt var auto: x = 2; ... --->
{
stack: main{var auto: x = 2;<-1> :: while ((! (x == 0)))
... ... <-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- step stmt var auto: x = 2; --->
{
stack: main{2<-1> :: var auto: x = 2;<0> :: while ((! (x == 0)))
... ... <-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- step exp 2 --->
{
stack: main{2<-1> :: var auto: x = 2;<0> :: while ((! (x == 0)))
... ... <-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- handle value 2 with var auto: x = 2;<1>(2,) --->
{
stack: main{auto: x<-1> :: var auto: x = 2;<1>(2,) :: while ((! (x == 0)))
... ... <-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- step exp auto: x --->
{
stack: main{auto<-1> :: auto: x<0> :: var auto: x = 2;<1>(2,) :: while ((! (x == 0)))
... ... <-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- step exp auto --->
{
stack: main{auto<-1> :: auto: x<0> :: var auto: x = 2;<1>(2,) :: while ((! (x == 0)))
... ... <-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- handle value auto with auto: x<1>(auto,) --->
{
stack: main{auto: x<-1> :: var auto: x = 2;<1>(2,) :: while ((! (x == 0)))
... ... <-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- handle value auto: x with var auto: x = 2;<2>(2,auto: x,) --->
pattern_match(auto: x, 2)
{
stack: main{while ((! (x == 0)))
... ... <-1>} :: top{}
heap: fun<main>, 2,
env: x: 2, main: fun<main>,
}
--- step stmt while ((! (x == 0)))
... ... --->
{
stack: main{while ((! (x == 0)))
... <-1> :: return x;<-1>} :: top{}
heap: fun<main>, 2,
env: x: 2, main: fun<main>,
}
--- step stmt while ((! (x == 0)))
... --->
{
stack: main{(! (x == 0))<-1> :: while ((! (x == 0)))
... <0> :: return x;<-1>} :: top{}
heap: fun<main>, 2,
env: x: 2, main: fun<main>,
}
--- step exp (! (x == 0)) --->
{
stack: main{(x == 0)<-1> :: (! (x == 0))<0> :: while ((! (x == 0)))
... <0> :: return x;<-1>} :: top{}
heap: fun<main>, 2,
env: x: 2, main: fun<main>,
}
--- step exp (x == 0) --->
{
stack: main{x<-1> :: (x == 0)<0> :: (! (x == 0))<0> :: while ((! (x == 0)))
... <0> :: return x;<-1>} :: top{}
heap: fun<main>, 2,
env: x: 2, main: fun<main>,
}
--- step exp x --->
{
stack: main{2<-1> :: (x == 0)<0> :: (! (x == 0))<0> :: while ((! (x == 0)))
... <0> :: return x;<-1>} :: top{}
heap: fun<main>, 2,
env: x: 2, main: fun<main>,
}
--- handle value 2 with (x == 0)<1>(2,) --->
{
stack: main{0<-1> :: (x == 0)<1>(2,) :: (! (x == 0))<0> :: while ((! (x == 0)))
... <0> :: return x;<-1>} :: top{}
heap: fun<main>, 2,
env: x: 2, main: fun<main>,
}
--- step exp 0 --->
{
stack: main{0<-1> :: (x == 0)<1>(2,) :: (! (x == 0))<0> :: while ((! (x == 0)))
... <0> :: return x;<-1>} :: top{}
heap: fun<main>, 2,
env: x: 2, main: fun<main>,
}
--- handle value 0 with (x == 0)<2>(2,0,) --->
{
stack: main{false<-1> :: (! (x == 0))<0> :: while ((! (x == 0)))
... <0> :: return x;<-1>} :: top{}
heap: fun<main>, 2,
env: x: 2, main: fun<main>,
}
--- handle value false with (! (x == 0))<1>(false,) --->
{
stack: main{true<-1> :: while ((! (x == 0)))
... <0> :: return x;<-1>} :: top{}
heap: fun<main>, 2,
env: x: 2, main: fun<main>,
}
--- handle value true with while ((! (x == 0)))
... <1>(true,) --->
{
stack: main{{
...
}
<-1> :: while ((! (x == 0)))
... <-1> :: return x;<-1>} :: top{}
heap: fun<main>, 2,
env: x: 2, main: fun<main>,
}
--- step stmt {
...
}
--->
{
stack: main{x = (x - 1); ... <-1> :: {
...
}
<0> :: while ((! (x == 0)))
... <-1> :: return x;<-1>} :: top{}
heap: fun<main>, 2,
env: x: 2, main: fun<main>,
}
--- step stmt x = (x - 1); ... --->
{
stack: main{x = (x - 1);<-1> :: continue; ... <-1> :: {
...
}
<0> :: while ((! (x == 0)))
... <-1> :: return x;<-1>} :: top{}
heap: fun<main>, 2,
env: x: 2, main: fun<main>,
}
--- step stmt x = (x - 1); --->
{
stack: main{x<-1> :: x = (x - 1);<0> :: continue; ... <-1> :: {
...
}
<0> :: while ((! (x == 0)))
... <-1> :: return x;<-1>} :: top{}
heap: fun<main>, 2,
env: x: 2, main: fun<main>,
}
--- step lvalue x --->
{
stack: main{ptr<1><-1> :: x = (x - 1);<0> :: continue; ... <-1> :: {
...
}
<0> :: while ((! (x == 0)))
... <-1> :: return x;<-1>} :: top{}
heap: fun<main>, 2,
env: x: 2, main: fun<main>,
}
--- handle value ptr<1> with x = (x - 1);<1>(ptr<1>,) --->
{
stack: main{(x - 1)<-1> :: x = (x - 1);<1>(ptr<1>,) :: continue; ... <-1> :: {
...
}
<0> :: while ((! (x == 0)))
... <-1> :: return x;<-1>} :: top{}
heap: fun<main>, 2,
env: x: 2, main: fun<main>,
}
--- step exp (x - 1) --->
{
stack: main{x<-1> :: (x - 1)<0> :: x = (x - 1);<1>(ptr<1>,) :: continue; ... <-1> :: {
...
}
<0> :: while ((! (x == 0)))
... <-1> :: return x;<-1>} :: top{}
heap: fun<main>, 2,
env: x: 2, main: fun<main>,
}
--- step exp x --->
{
stack: main{2<-1> :: (x - 1)<0> :: x = (x - 1);<1>(ptr<1>,) :: continue; ... <-1> :: {
...
}
<0> :: while ((! (x == 0)))
... <-1> :: return x;<-1>} :: top{}
heap: fun<main>, 2,
env: x: 2, main: fun<main>,
}
--- handle value 2 with (x - 1)<1>(2,) --->
{
stack: main{1<-1> :: (x - 1)<1>(2,) :: x = (x - 1);<1>(ptr<1>,) :: continue; ... <-1> :: {
...
}
<0> :: while ((! (x == 0)))
... <-1> :: return x;<-1>} :: top{}
heap: fun<main>, 2,
env: x: 2, main: fun<main>,
}
--- step exp 1 --->
{
stack: main{1<-1> :: (x - 1)<1>(2,) :: x = (x - 1);<1>(ptr<1>,) :: continue; ... <-1> :: {
...
}
<0> :: while ((! (x == 0)))
... <-1> :: return x;<-1>} :: top{}
heap: fun<main>, 2,
env: x: 2, main: fun<main>,
}
--- handle value 1 with (x - 1)<2>(2,1,) --->
{
stack: main{1<-1> :: x = (x - 1);<1>(ptr<1>,) :: continue; ... <-1> :: {
...
}
<0> :: while ((! (x == 0)))
... <-1> :: return x;<-1>} :: top{}
heap: fun<main>, 2,
env: x: 2, main: fun<main>,
}
--- handle value 1 with x = (x - 1);<2>(ptr<1>,1,) --->
{
stack: main{continue; ... <-1> :: {
...
}
<0> :: while ((! (x == 0)))
... <-1> :: return x;<-1>} :: top{}
heap: fun<main>, 1,
env: x: 1, main: fun<main>,
}
--- step stmt continue; ... --->
{
stack: main{continue;<-1> :: x = (x + 1);<-1> :: {
...
}
<0> :: while ((! (x == 0)))
... <-1> :: return x;<-1>} :: top{}
heap: fun<main>, 1,
env: x: 1, main: fun<main>,
}
--- step stmt continue; --->
{
stack: main{while ((! (x == 0)))
... <-1> :: return x;<-1>} :: top{}
heap: fun<main>, 1,
env: x: 1, main: fun<main>,
}
--- step stmt while ((! (x == 0)))
... --->
{
stack: main{(! (x == 0))<-1> :: while ((! (x == 0)))
... <0> :: return x;<-1>} :: top{}
heap: fun<main>, 1,
env: x: 1, main: fun<main>,
}
--- step exp (! (x == 0)) --->
{
stack: main{(x == 0)<-1> :: (! (x == 0))<0> :: while ((! (x == 0)))
... <0> :: return x;<-1>} :: top{}
heap: fun<main>, 1,
env: x: 1, main: fun<main>,
}
--- step exp (x == 0) --->
{
stack: main{x<-1> :: (x == 0)<0> :: (! (x == 0))<0> :: while ((! (x == 0)))
... <0> :: return x;<-1>} :: top{}
heap: fun<main>, 1,
env: x: 1, main: fun<main>,
}
--- step exp x --->
{
stack: main{1<-1> :: (x == 0)<0> :: (! (x == 0))<0> :: while ((! (x == 0)))
... <0> :: return x;<-1>} :: top{}
heap: fun<main>, 1,
env: x: 1, main: fun<main>,
}
--- handle value 1 with (x == 0)<1>(1,) --->
{
stack: main{0<-1> :: (x == 0)<1>(1,) :: (! (x == 0))<0> :: while ((! (x == 0)))
... <0> :: return x;<-1>} :: top{}
heap: fun<main>, 1,
env: x: 1, main: fun<main>,
}
--- step exp 0 --->
{
stack: main{0<-1> :: (x == 0)<1>(1,) :: (! (x == 0))<0> :: while ((! (x == 0)))
... <0> :: return x;<-1>} :: top{}
heap: fun<main>, 1,
env: x: 1, main: fun<main>,
}
--- handle value 0 with (x == 0)<2>(1,0,) --->
{
stack: main{false<-1> :: (! (x == 0))<0> :: while ((! (x == 0)))
... <0> :: return x;<-1>} :: top{}
heap: fun<main>, 1,
env: x: 1, main: fun<main>,
}
--- handle value false with (! (x == 0))<1>(false,) --->
{
stack: main{true<-1> :: while ((! (x == 0)))
... <0> :: return x;<-1>} :: top{}
heap: fun<main>, 1,
env: x: 1, main: fun<main>,
}
--- handle value true with while ((! (x == 0)))
... <1>(true,) --->
{
stack: main{{
...
}
<-1> :: while ((! (x == 0)))
... <-1> :: return x;<-1>} :: top{}
heap: fun<main>, 1,
env: x: 1, main: fun<main>,
}
--- step stmt {
...
}
--->
{
stack: main{x = (x - 1); ... <-1> :: {
...
}
<0> :: while ((! (x == 0)))
... <-1> :: return x;<-1>} :: top{}
heap: fun<main>, 1,
env: x: 1, main: fun<main>,
}
--- step stmt x = (x - 1); ... --->
{
stack: main{x = (x - 1);<-1> :: continue; ... <-1> :: {
...
}
<0> :: while ((! (x == 0)))
... <-1> :: return x;<-1>} :: top{}
heap: fun<main>, 1,
env: x: 1, main: fun<main>,
}
--- step stmt x = (x - 1); --->
{
stack: main{x<-1> :: x = (x - 1);<0> :: continue; ... <-1> :: {
...
}
<0> :: while ((! (x == 0)))
... <-1> :: return x;<-1>} :: top{}
heap: fun<main>, 1,
env: x: 1, main: fun<main>,
}
--- step lvalue x --->
{
stack: main{ptr<1><-1> :: x = (x - 1);<0> :: continue; ... <-1> :: {
...
}
<0> :: while ((! (x == 0)))
... <-1> :: return x;<-1>} :: top{}
heap: fun<main>, 1,
env: x: 1, main: fun<main>,
}
--- handle value ptr<1> with x = (x - 1);<1>(ptr<1>,) --->
{
stack: main{(x - 1)<-1> :: x = (x - 1);<1>(ptr<1>,) :: continue; ... <-1> :: {
...
}
<0> :: while ((! (x == 0)))
... <-1> :: return x;<-1>} :: top{}
heap: fun<main>, 1,
env: x: 1, main: fun<main>,
}
--- step exp (x - 1) --->
{
stack: main{x<-1> :: (x - 1)<0> :: x = (x - 1);<1>(ptr<1>,) :: continue; ... <-1> :: {
...
}
<0> :: while ((! (x == 0)))
... <-1> :: return x;<-1>} :: top{}
heap: fun<main>, 1,
env: x: 1, main: fun<main>,
}
--- step exp x --->
{
stack: main{1<-1> :: (x - 1)<0> :: x = (x - 1);<1>(ptr<1>,) :: continue; ... <-1> :: {
...
}
<0> :: while ((! (x == 0)))
... <-1> :: return x;<-1>} :: top{}
heap: fun<main>, 1,
env: x: 1, main: fun<main>,
}
--- handle value 1 with (x - 1)<1>(1,) --->
{
stack: main{1<-1> :: (x - 1)<1>(1,) :: x = (x - 1);<1>(ptr<1>,) :: continue; ... <-1> :: {
...
}
<0> :: while ((! (x == 0)))
... <-1> :: return x;<-1>} :: top{}
heap: fun<main>, 1,
env: x: 1, main: fun<main>,
}
--- step exp 1 --->
{
stack: main{1<-1> :: (x - 1)<1>(1,) :: x = (x - 1);<1>(ptr<1>,) :: continue; ... <-1> :: {
...
}
<0> :: while ((! (x == 0)))
... <-1> :: return x;<-1>} :: top{}
heap: fun<main>, 1,
env: x: 1, main: fun<main>,
}
--- handle value 1 with (x - 1)<2>(1,1,) --->
{
stack: main{0<-1> :: x = (x - 1);<1>(ptr<1>,) :: continue; ... <-1> :: {
...
}
<0> :: while ((! (x == 0)))
... <-1> :: return x;<-1>} :: top{}
heap: fun<main>, 1,
env: x: 1, main: fun<main>,
}
--- handle value 0 with x = (x - 1);<2>(ptr<1>,0,) --->
{
stack: main{continue; ... <-1> :: {
...
}
<0> :: while ((! (x == 0)))
... <-1> :: return x;<-1>} :: top{}
heap: fun<main>, 0,
env: x: 0, main: fun<main>,
}
--- step stmt continue; ... --->
{
stack: main{continue;<-1> :: x = (x + 1);<-1> :: {
...
}
<0> :: while ((! (x == 0)))
... <-1> :: return x;<-1>} :: top{}
heap: fun<main>, 0,
env: x: 0, main: fun<main>,
}
--- step stmt continue; --->
{
stack: main{while ((! (x == 0)))
... <-1> :: return x;<-1>} :: top{}
heap: fun<main>, 0,
env: x: 0, main: fun<main>,
}
--- step stmt while ((! (x == 0)))
... --->
{
stack: main{(! (x == 0))<-1> :: while ((! (x == 0)))
... <0> :: return x;<-1>} :: top{}
heap: fun<main>, 0,
env: x: 0, main: fun<main>,
}
--- step exp (! (x == 0)) --->
{
stack: main{(x == 0)<-1> :: (! (x == 0))<0> :: while ((! (x == 0)))
... <0> :: return x;<-1>} :: top{}
heap: fun<main>, 0,
env: x: 0, main: fun<main>,
}
--- step exp (x == 0) --->
{
stack: main{x<-1> :: (x == 0)<0> :: (! (x == 0))<0> :: while ((! (x == 0)))
... <0> :: return x;<-1>} :: top{}
heap: fun<main>, 0,
env: x: 0, main: fun<main>,
}
--- step exp x --->
{
stack: main{0<-1> :: (x == 0)<0> :: (! (x == 0))<0> :: while ((! (x == 0)))
... <0> :: return x;<-1>} :: top{}
heap: fun<main>, 0,
env: x: 0, main: fun<main>,
}
--- handle value 0 with (x == 0)<1>(0,) --->
{
stack: main{0<-1> :: (x == 0)<1>(0,) :: (! (x == 0))<0> :: while ((! (x == 0)))
... <0> :: return x;<-1>} :: top{}
heap: fun<main>, 0,
env: x: 0, main: fun<main>,
}
--- step exp 0 --->
{
stack: main{0<-1> :: (x == 0)<1>(0,) :: (! (x == 0))<0> :: while ((! (x == 0)))
... <0> :: return x;<-1>} :: top{}
heap: fun<main>, 0,
env: x: 0, main: fun<main>,
}
--- handle value 0 with (x == 0)<2>(0,0,) --->
{
stack: main{true<-1> :: (! (x == 0))<0> :: while ((! (x == 0)))
... <0> :: return x;<-1>} :: top{}
heap: fun<main>, 0,
env: x: 0, main: fun<main>,
}
--- handle value true with (! (x == 0))<1>(true,) --->
{
stack: main{false<-1> :: while ((! (x == 0)))
... <0> :: return x;<-1>} :: top{}
heap: fun<main>, 0,
env: x: 0, main: fun<main>,
}
--- handle value false with while ((! (x == 0)))
... <1>(false,) --->
{
stack: main{return x;<-1>} :: top{}
heap: fun<main>, 0,
env: x: 0, main: fun<main>,
}
--- step stmt return x; --->
{
stack: main{x<-1> :: return x;<0>} :: top{}
heap: fun<main>, 0,
env: x: 0, main: fun<main>,
}
--- step exp x --->
{
stack: main{0<-1> :: return x;<0>} :: top{}
heap: fun<main>, 0,
env: x: 0, main: fun<main>,
}
--- handle value 0 with return x;<1>(0,) --->
{
stack: top{0<-1>}
heap: fun<main>, !!0,
env: main: fun<main>,
}
result: 0
executable_semantics/testdata/fun1.golden
Vendored
+20 -1
View File
@@ -1 +1,20 @@
result: 0
********** source program **********
fn f Int: x -> Int {
return (x - 1);
}
fn main () -> Int {
return f(0 = 1);
}
********** type checking **********
--- step exp Int --->
--- step exp Int --->
--- step exp Int --->
--- step exp Int --->
--- step exp Int --->
--- step exp Int --->
10: type error in call
expected: Int
actual: Tuple(0 = Int)
EXIT CODE: 255
executable_semantics/testdata/fun2.golden
Vendored
+26 -1
View File
@@ -1 +1,26 @@
result: 0
********** source program **********
fn f Int: x -> Int {
return 0;
}
fn main () -> Int {
var Int: a = 0;
var Int: b = 1;
f(0 = a);
b = a;
return b;
}
********** type checking **********
--- step exp Int --->
--- step exp Int --->
--- step exp Int --->
--- step exp Int --->
--- step exp Int --->
--- step exp Int --->
--- step exp Int --->
--- step exp Int --->
15: type error in call
expected: Int
actual: Tuple(0 = Int)
EXIT CODE: 255
executable_semantics/testdata/fun3.golden
Vendored
+210
View File
@@ -1 +1,211 @@
********** source program **********
fn f (0 = Int: x, 1 = Int: y) -> Int {
return (x + y);
}
fn main () -> Int {
return (f(0 = 2, 1 = 3) - 5);
}
********** type checking **********
--- step exp Int --->
--- step exp Int --->
--- step exp Int --->
--- step exp Int --->
--- step exp Int --->
--- step exp Int --->
--- step exp Int --->
--- step exp Int --->
********** type checking complete **********
fn f (0 = Int: x, 1 = Int: y) -> Int {
return (x + y);
}
fn main () -> Int {
return (f(0 = 2, 1 = 3) - 5);
}
********** starting execution **********
********** initializing globals **********
--- step exp (0 = Int: x, 1 = Int: y) --->
--- step exp Int: x --->
--- step exp Int --->
--- handle value Int with Int: x<1>(Int,) --->
--- handle value Int: x with (0 = Int: x, 1 = Int: y)<1>(Int: x,) --->
--- step exp Int: y --->
--- step exp Int --->
--- handle value Int with Int: y<1>(Int,) --->
--- handle value Int: y with (0 = Int: x, 1 = Int: y)<2>(Int: x,Int: y,) --->
--- step exp () --->
********** calling main function **********
{
stack: top{main()<-1>}
heap: Int: x, Int: y, fun<f>, fun<main>,
env: main: fun<main>, f: fun<f>,
}
--- step exp main() --->
{
stack: top{main<-1> :: main()<0>}
heap: Int: x, Int: y, fun<f>, fun<main>,
env: main: fun<main>, f: fun<f>,
}
--- step exp main --->
{
stack: top{fun<main><-1> :: main()<0>}
heap: Int: x, Int: y, fun<f>, fun<main>,
env: main: fun<main>, f: fun<f>,
}
--- handle value fun<main> with main()<1>(fun<main>,) --->
{
stack: top{()<-1> :: main()<1>(fun<main>,)}
heap: Int: x, Int: y, fun<f>, fun<main>,
env: main: fun<main>, f: fun<f>,
}
--- step exp () --->
{
stack: top{()<-1> :: main()<1>(fun<main>,)}
heap: Int: x, Int: y, fun<f>, fun<main>,
env: main: fun<main>, f: fun<f>,
}
--- handle value () with main()<2>(fun<main>,(),) --->
pattern_match((), ())
{
stack: main{return (f(0 = 2, 1 = 3) - 5);<-1>} :: top{}
heap: Int: x, Int: y, fun<f>, fun<main>,
env: main: fun<main>, f: fun<f>,
}
--- step stmt return (f(0 = 2, 1 = 3) - 5); --->
{
stack: main{(f(0 = 2, 1 = 3) - 5)<-1> :: return (f(0 = 2, 1 = 3) - 5);<0>} :: top{}
heap: Int: x, Int: y, fun<f>, fun<main>,
env: main: fun<main>, f: fun<f>,
}
--- step exp (f(0 = 2, 1 = 3) - 5) --->
{
stack: main{f(0 = 2, 1 = 3)<-1> :: (f(0 = 2, 1 = 3) - 5)<0> :: return (f(0 = 2, 1 = 3) - 5);<0>} :: top{}
heap: Int: x, Int: y, fun<f>, fun<main>,
env: main: fun<main>, f: fun<f>,
}
--- step exp f(0 = 2, 1 = 3) --->
{
stack: main{f<-1> :: f(0 = 2, 1 = 3)<0> :: (f(0 = 2, 1 = 3) - 5)<0> :: return (f(0 = 2, 1 = 3) - 5);<0>} :: top{}
heap: Int: x, Int: y, fun<f>, fun<main>,
env: main: fun<main>, f: fun<f>,
}
--- step exp f --->
{
stack: main{fun<f><-1> :: f(0 = 2, 1 = 3)<0> :: (f(0 = 2, 1 = 3) - 5)<0> :: return (f(0 = 2, 1 = 3) - 5);<0>} :: top{}
heap: Int: x, Int: y, fun<f>, fun<main>,
env: main: fun<main>, f: fun<f>,
}
--- handle value fun<f> with f(0 = 2, 1 = 3)<1>(fun<f>,) --->
{
stack: main{(0 = 2, 1 = 3)<-1> :: f(0 = 2, 1 = 3)<1>(fun<f>,) :: (f(0 = 2, 1 = 3) - 5)<0> :: return (f(0 = 2, 1 = 3) - 5);<0>} :: top{}
heap: Int: x, Int: y, fun<f>, fun<main>,
env: main: fun<main>, f: fun<f>,
}
--- step exp (0 = 2, 1 = 3) --->
{
stack: main{2<-1> :: (0 = 2, 1 = 3)<0> :: f(0 = 2, 1 = 3)<1>(fun<f>,) :: (f(0 = 2, 1 = 3) - 5)<0> :: return (f(0 = 2, 1 = 3) - 5);<0>} :: top{}
heap: Int: x, Int: y, fun<f>, fun<main>,
env: main: fun<main>, f: fun<f>,
}
--- step exp 2 --->
{
stack: main{2<-1> :: (0 = 2, 1 = 3)<0> :: f(0 = 2, 1 = 3)<1>(fun<f>,) :: (f(0 = 2, 1 = 3) - 5)<0> :: return (f(0 = 2, 1 = 3) - 5);<0>} :: top{}
heap: Int: x, Int: y, fun<f>, fun<main>,
env: main: fun<main>, f: fun<f>,
}
--- handle value 2 with (0 = 2, 1 = 3)<1>(2,) --->
{
stack: main{3<-1> :: (0 = 2, 1 = 3)<1>(2,) :: f(0 = 2, 1 = 3)<1>(fun<f>,) :: (f(0 = 2, 1 = 3) - 5)<0> :: return (f(0 = 2, 1 = 3) - 5);<0>} :: top{}
heap: Int: x, Int: y, fun<f>, fun<main>,
env: main: fun<main>, f: fun<f>,
}
--- step exp 3 --->
{
stack: main{3<-1> :: (0 = 2, 1 = 3)<1>(2,) :: f(0 = 2, 1 = 3)<1>(fun<f>,) :: (f(0 = 2, 1 = 3) - 5)<0> :: return (f(0 = 2, 1 = 3) - 5);<0>} :: top{}
heap: Int: x, Int: y, fun<f>, fun<main>,
env: main: fun<main>, f: fun<f>,
}
--- handle value 3 with (0 = 2, 1 = 3)<2>(2,3,) --->
{
stack: main{(0 = 2@4, 1 = 3@5)<-1> :: f(0 = 2, 1 = 3)<1>(fun<f>,) :: (f(0 = 2, 1 = 3) - 5)<0> :: return (f(0 = 2, 1 = 3) - 5);<0>} :: top{}
heap: Int: x, Int: y, fun<f>, fun<main>, 2, 3,
env: main: fun<main>, f: fun<f>,
}
--- handle value (0 = 2@4, 1 = 3@5) with f(0 = 2, 1 = 3)<2>(fun<f>,(0 = 2@4, 1 = 3@5),) --->
pattern_match((0 = Int: x@0, 1 = Int: y@1), (0 = 2@4, 1 = 3@5))
pattern_match(Int: x, 2)
pattern_match(Int: y, 3)
{
stack: f{return (x + y);<-1>} :: main{(f(0 = 2, 1 = 3) - 5)<0> :: return (f(0 = 2, 1 = 3) - 5);<0>} :: top{}
heap: Int: x, Int: y, fun<f>, fun<main>, 2, 3, 2, 3,
env: y: 3, x: 2, main: fun<main>, f: fun<f>,
}
--- step stmt return (x + y); --->
{
stack: f{(x + y)<-1> :: return (x + y);<0>} :: main{(f(0 = 2, 1 = 3) - 5)<0> :: return (f(0 = 2, 1 = 3) - 5);<0>} :: top{}
heap: Int: x, Int: y, fun<f>, fun<main>, 2, 3, 2, 3,
env: y: 3, x: 2, main: fun<main>, f: fun<f>,
}
--- step exp (x + y) --->
{
stack: f{x<-1> :: (x + y)<0> :: return (x + y);<0>} :: main{(f(0 = 2, 1 = 3) - 5)<0> :: return (f(0 = 2, 1 = 3) - 5);<0>} :: top{}
heap: Int: x, Int: y, fun<f>, fun<main>, 2, 3, 2, 3,
env: y: 3, x: 2, main: fun<main>, f: fun<f>,
}
--- step exp x --->
{
stack: f{2<-1> :: (x + y)<0> :: return (x + y);<0>} :: main{(f(0 = 2, 1 = 3) - 5)<0> :: return (f(0 = 2, 1 = 3) - 5);<0>} :: top{}
heap: Int: x, Int: y, fun<f>, fun<main>, 2, 3, 2, 3,
env: y: 3, x: 2, main: fun<main>, f: fun<f>,
}
--- handle value 2 with (x + y)<1>(2,) --->
{
stack: f{y<-1> :: (x + y)<1>(2,) :: return (x + y);<0>} :: main{(f(0 = 2, 1 = 3) - 5)<0> :: return (f(0 = 2, 1 = 3) - 5);<0>} :: top{}
heap: Int: x, Int: y, fun<f>, fun<main>, 2, 3, 2, 3,
env: y: 3, x: 2, main: fun<main>, f: fun<f>,
}
--- step exp y --->
{
stack: f{3<-1> :: (x + y)<1>(2,) :: return (x + y);<0>} :: main{(f(0 = 2, 1 = 3) - 5)<0> :: return (f(0 = 2, 1 = 3) - 5);<0>} :: top{}
heap: Int: x, Int: y, fun<f>, fun<main>, 2, 3, 2, 3,
env: y: 3, x: 2, main: fun<main>, f: fun<f>,
}
--- handle value 3 with (x + y)<2>(2,3,) --->
{
stack: f{5<-1> :: return (x + y);<0>} :: main{(f(0 = 2, 1 = 3) - 5)<0> :: return (f(0 = 2, 1 = 3) - 5);<0>} :: top{}
heap: Int: x, Int: y, fun<f>, fun<main>, 2, 3, 2, 3,
env: y: 3, x: 2, main: fun<main>, f: fun<f>,
}
--- handle value 5 with return (x + y);<1>(5,) --->
{
stack: main{5<-1> :: (f(0 = 2, 1 = 3) - 5)<0> :: return (f(0 = 2, 1 = 3) - 5);<0>} :: top{}
heap: Int: x, Int: y, fun<f>, fun<main>, 2, 3, !!2, !!3,
env: main: fun<main>, f: fun<f>,
}
--- handle value 5 with (f(0 = 2, 1 = 3) - 5)<1>(5,) --->
{
stack: main{5<-1> :: (f(0 = 2, 1 = 3) - 5)<1>(5,) :: return (f(0 = 2, 1 = 3) - 5);<0>} :: top{}
heap: Int: x, Int: y, fun<f>, fun<main>, 2, 3, !!2, !!3,
env: main: fun<main>, f: fun<f>,
}
--- step exp 5 --->
{
stack: main{5<-1> :: (f(0 = 2, 1 = 3) - 5)<1>(5,) :: return (f(0 = 2, 1 = 3) - 5);<0>} :: top{}
heap: Int: x, Int: y, fun<f>, fun<main>, 2, 3, !!2, !!3,
env: main: fun<main>, f: fun<f>,
}
--- handle value 5 with (f(0 = 2, 1 = 3) - 5)<2>(5,5,) --->
{
stack: main{0<-1> :: return (f(0 = 2, 1 = 3) - 5);<0>} :: top{}
heap: Int: x, Int: y, fun<f>, fun<main>, 2, 3, !!2, !!3,
env: main: fun<main>, f: fun<f>,
}
--- handle value 0 with return (f(0 = 2, 1 = 3) - 5);<1>(0,) --->
{
stack: top{0<-1>}
heap: Int: x, Int: y, fun<f>, fun<main>, 2, 3, !!2, !!3,
env: main: fun<main>, f: fun<f>,
}
result: 0
executable_semantics/testdata/fun4.golden
Vendored
+147
View File
@@ -1 +1,148 @@
********** source program **********
fn f () -> ();
fn main () -> Int {
f();
return 0;
}
********** type checking **********
--- step exp () --->
--- step exp Int --->
--- step exp () --->
--- step exp Int --->
********** type checking complete **********
fn f () -> () {
return ();
}
fn main () -> Int {
f();
return 0;
}
********** starting execution **********
********** initializing globals **********
--- step exp () --->
--- step exp () --->
********** calling main function **********
{
stack: top{main()<-1>}
heap: fun<f>, fun<main>,
env: main: fun<main>, f: fun<f>,
}
--- step exp main() --->
{
stack: top{main<-1> :: main()<0>}
heap: fun<f>, fun<main>,
env: main: fun<main>, f: fun<f>,
}
--- step exp main --->
{
stack: top{fun<main><-1> :: main()<0>}
heap: fun<f>, fun<main>,
env: main: fun<main>, f: fun<f>,
}
--- handle value fun<main> with main()<1>(fun<main>,) --->
{
stack: top{()<-1> :: main()<1>(fun<main>,)}
heap: fun<f>, fun<main>,
env: main: fun<main>, f: fun<f>,
}
--- step exp () --->
{
stack: top{()<-1> :: main()<1>(fun<main>,)}
heap: fun<f>, fun<main>,
env: main: fun<main>, f: fun<f>,
}
--- handle value () with main()<2>(fun<main>,(),) --->
pattern_match((), ())
{
stack: main{f(); ... <-1>} :: top{}
heap: fun<f>, fun<main>,
env: main: fun<main>, f: fun<f>,
}
--- step stmt f(); ... --->
{
stack: main{f();<-1> :: return 0;<-1>} :: top{}
heap: fun<f>, fun<main>,
env: main: fun<main>, f: fun<f>,
}
--- step stmt f(); --->
{
stack: main{f()<-1> :: f();<-1> :: return 0;<-1>} :: top{}
heap: fun<f>, fun<main>,
env: main: fun<main>, f: fun<f>,
}
--- step exp f() --->
{
stack: main{f<-1> :: f()<0> :: f();<-1> :: return 0;<-1>} :: top{}
heap: fun<f>, fun<main>,
env: main: fun<main>, f: fun<f>,
}
--- step exp f --->
{
stack: main{fun<f><-1> :: f()<0> :: f();<-1> :: return 0;<-1>} :: top{}
heap: fun<f>, fun<main>,
env: main: fun<main>, f: fun<f>,
}
--- handle value fun<f> with f()<1>(fun<f>,) --->
{
stack: main{()<-1> :: f()<1>(fun<f>,) :: f();<-1> :: return 0;<-1>} :: top{}
heap: fun<f>, fun<main>,
env: main: fun<main>, f: fun<f>,
}
--- step exp () --->
{
stack: main{()<-1> :: f()<1>(fun<f>,) :: f();<-1> :: return 0;<-1>} :: top{}
heap: fun<f>, fun<main>,
env: main: fun<main>, f: fun<f>,
}
--- handle value () with f()<2>(fun<f>,(),) --->
pattern_match((), ())
{
stack: f{return ();<-1>} :: main{f();<-1> :: return 0;<-1>} :: top{}
heap: fun<f>, fun<main>,
env: main: fun<main>, f: fun<f>,
}
--- step stmt return (); --->
{
stack: f{()<-1> :: return ();<0>} :: main{f();<-1> :: return 0;<-1>} :: top{}
heap: fun<f>, fun<main>,
env: main: fun<main>, f: fun<f>,
}
--- step exp () --->
{
stack: f{()<-1> :: return ();<0>} :: main{f();<-1> :: return 0;<-1>} :: top{}
heap: fun<f>, fun<main>,
env: main: fun<main>, f: fun<f>,
}
--- handle value () with return ();<1>((),) --->
{
stack: main{()<-1> :: f();<-1> :: return 0;<-1>} :: top{}
heap: fun<f>, fun<main>,
env: main: fun<main>, f: fun<f>,
}
--- handle value () with f();<0>((),) --->
{
stack: main{return 0;<-1>} :: top{}
heap: fun<f>, fun<main>,
env: main: fun<main>, f: fun<f>,
}
--- step stmt return 0; --->
{
stack: main{0<-1> :: return 0;<0>} :: top{}
heap: fun<f>, fun<main>,
env: main: fun<main>, f: fun<f>,
}
--- step exp 0 --->
{
stack: main{0<-1> :: return 0;<0>} :: top{}
heap: fun<f>, fun<main>,
env: main: fun<main>, f: fun<f>,
}
--- handle value 0 with return 0;<1>(0,) --->
{
stack: top{0<-1>}
heap: fun<f>, fun<main>,
env: main: fun<main>, f: fun<f>,
}
result: 0
executable_semantics/testdata/fun5.golden
Vendored
+213
View File
@@ -1 +1,214 @@
********** source program **********
fn add (0 = Int: x, 1 = Int: y) -> auto {
return (x + y);
}
fn main () -> Int {
return (add(0 = 1, 1 = 2) - 3);
}
********** type checking **********
--- step exp Int --->
--- step exp Int --->
--- step exp auto --->
--- step exp Int --->
--- step exp Int --->
--- step exp auto --->
--- step exp Int --->
--- step exp Int --->
--- step exp Int --->
--- step exp Int --->
--- step exp auto --->
--- step exp Int --->
********** type checking complete **********
fn add (0 = Int: x, 1 = Int: y) -> Int {
return (x + y);
}
fn main () -> Int {
return (add(0 = 1, 1 = 2) - 3);
}
********** starting execution **********
********** initializing globals **********
--- step exp (0 = Int: x, 1 = Int: y) --->
--- step exp Int: x --->
--- step exp Int --->
--- handle value Int with Int: x<1>(Int,) --->
--- handle value Int: x with (0 = Int: x, 1 = Int: y)<1>(Int: x,) --->
--- step exp Int: y --->
--- step exp Int --->
--- handle value Int with Int: y<1>(Int,) --->
--- handle value Int: y with (0 = Int: x, 1 = Int: y)<2>(Int: x,Int: y,) --->
--- step exp () --->
********** calling main function **********
{
stack: top{main()<-1>}
heap: Int: x, Int: y, fun<add>, fun<main>,
env: main: fun<main>, add: fun<add>,
}
--- step exp main() --->
{
stack: top{main<-1> :: main()<0>}
heap: Int: x, Int: y, fun<add>, fun<main>,
env: main: fun<main>, add: fun<add>,
}
--- step exp main --->
{
stack: top{fun<main><-1> :: main()<0>}
heap: Int: x, Int: y, fun<add>, fun<main>,
env: main: fun<main>, add: fun<add>,
}
--- handle value fun<main> with main()<1>(fun<main>,) --->
{
stack: top{()<-1> :: main()<1>(fun<main>,)}
heap: Int: x, Int: y, fun<add>, fun<main>,
env: main: fun<main>, add: fun<add>,
}
--- step exp () --->
{
stack: top{()<-1> :: main()<1>(fun<main>,)}
heap: Int: x, Int: y, fun<add>, fun<main>,
env: main: fun<main>, add: fun<add>,
}
--- handle value () with main()<2>(fun<main>,(),) --->
pattern_match((), ())
{
stack: main{return (add(0 = 1, 1 = 2) - 3);<-1>} :: top{}
heap: Int: x, Int: y, fun<add>, fun<main>,
env: main: fun<main>, add: fun<add>,
}
--- step stmt return (add(0 = 1, 1 = 2) - 3); --->
{
stack: main{(add(0 = 1, 1 = 2) - 3)<-1> :: return (add(0 = 1, 1 = 2) - 3);<0>} :: top{}
heap: Int: x, Int: y, fun<add>, fun<main>,
env: main: fun<main>, add: fun<add>,
}
--- step exp (add(0 = 1, 1 = 2) - 3) --->
{
stack: main{add(0 = 1, 1 = 2)<-1> :: (add(0 = 1, 1 = 2) - 3)<0> :: return (add(0 = 1, 1 = 2) - 3);<0>} :: top{}
heap: Int: x, Int: y, fun<add>, fun<main>,
env: main: fun<main>, add: fun<add>,
}
--- step exp add(0 = 1, 1 = 2) --->
{
stack: main{add<-1> :: add(0 = 1, 1 = 2)<0> :: (add(0 = 1, 1 = 2) - 3)<0> :: return (add(0 = 1, 1 = 2) - 3);<0>} :: top{}
heap: Int: x, Int: y, fun<add>, fun<main>,
env: main: fun<main>, add: fun<add>,
}
--- step exp add --->
{
stack: main{fun<add><-1> :: add(0 = 1, 1 = 2)<0> :: (add(0 = 1, 1 = 2) - 3)<0> :: return (add(0 = 1, 1 = 2) - 3);<0>} :: top{}
heap: Int: x, Int: y, fun<add>, fun<main>,
env: main: fun<main>, add: fun<add>,
}
--- handle value fun<add> with add(0 = 1, 1 = 2)<1>(fun<add>,) --->
{
stack: main{(0 = 1, 1 = 2)<-1> :: add(0 = 1, 1 = 2)<1>(fun<add>,) :: (add(0 = 1, 1 = 2) - 3)<0> :: return (add(0 = 1, 1 = 2) - 3);<0>} :: top{}
heap: Int: x, Int: y, fun<add>, fun<main>,
env: main: fun<main>, add: fun<add>,
}
--- step exp (0 = 1, 1 = 2) --->
{
stack: main{1<-1> :: (0 = 1, 1 = 2)<0> :: add(0 = 1, 1 = 2)<1>(fun<add>,) :: (add(0 = 1, 1 = 2) - 3)<0> :: return (add(0 = 1, 1 = 2) - 3);<0>} :: top{}
heap: Int: x, Int: y, fun<add>, fun<main>,
env: main: fun<main>, add: fun<add>,
}
--- step exp 1 --->
{
stack: main{1<-1> :: (0 = 1, 1 = 2)<0> :: add(0 = 1, 1 = 2)<1>(fun<add>,) :: (add(0 = 1, 1 = 2) - 3)<0> :: return (add(0 = 1, 1 = 2) - 3);<0>} :: top{}
heap: Int: x, Int: y, fun<add>, fun<main>,
env: main: fun<main>, add: fun<add>,
}
--- handle value 1 with (0 = 1, 1 = 2)<1>(1,) --->
{
stack: main{2<-1> :: (0 = 1, 1 = 2)<1>(1,) :: add(0 = 1, 1 = 2)<1>(fun<add>,) :: (add(0 = 1, 1 = 2) - 3)<0> :: return (add(0 = 1, 1 = 2) - 3);<0>} :: top{}
heap: Int: x, Int: y, fun<add>, fun<main>,
env: main: fun<main>, add: fun<add>,
}
--- step exp 2 --->
{
stack: main{2<-1> :: (0 = 1, 1 = 2)<1>(1,) :: add(0 = 1, 1 = 2)<1>(fun<add>,) :: (add(0 = 1, 1 = 2) - 3)<0> :: return (add(0 = 1, 1 = 2) - 3);<0>} :: top{}
heap: Int: x, Int: y, fun<add>, fun<main>,
env: main: fun<main>, add: fun<add>,
}
--- handle value 2 with (0 = 1, 1 = 2)<2>(1,2,) --->
{
stack: main{(0 = 1@4, 1 = 2@5)<-1> :: add(0 = 1, 1 = 2)<1>(fun<add>,) :: (add(0 = 1, 1 = 2) - 3)<0> :: return (add(0 = 1, 1 = 2) - 3);<0>} :: top{}
heap: Int: x, Int: y, fun<add>, fun<main>, 1, 2,
env: main: fun<main>, add: fun<add>,
}
--- handle value (0 = 1@4, 1 = 2@5) with add(0 = 1, 1 = 2)<2>(fun<add>,(0 = 1@4, 1 = 2@5),) --->
pattern_match((0 = Int: x@0, 1 = Int: y@1), (0 = 1@4, 1 = 2@5))
pattern_match(Int: x, 1)
pattern_match(Int: y, 2)
{
stack: add{return (x + y);<-1>} :: main{(add(0 = 1, 1 = 2) - 3)<0> :: return (add(0 = 1, 1 = 2) - 3);<0>} :: top{}
heap: Int: x, Int: y, fun<add>, fun<main>, 1, 2, 1, 2,
env: y: 2, x: 1, main: fun<main>, add: fun<add>,
}
--- step stmt return (x + y); --->
{
stack: add{(x + y)<-1> :: return (x + y);<0>} :: main{(add(0 = 1, 1 = 2) - 3)<0> :: return (add(0 = 1, 1 = 2) - 3);<0>} :: top{}
heap: Int: x, Int: y, fun<add>, fun<main>, 1, 2, 1, 2,
env: y: 2, x: 1, main: fun<main>, add: fun<add>,
}
--- step exp (x + y) --->
{
stack: add{x<-1> :: (x + y)<0> :: return (x + y);<0>} :: main{(add(0 = 1, 1 = 2) - 3)<0> :: return (add(0 = 1, 1 = 2) - 3);<0>} :: top{}
heap: Int: x, Int: y, fun<add>, fun<main>, 1, 2, 1, 2,
env: y: 2, x: 1, main: fun<main>, add: fun<add>,
}
--- step exp x --->
{
stack: add{1<-1> :: (x + y)<0> :: return (x + y);<0>} :: main{(add(0 = 1, 1 = 2) - 3)<0> :: return (add(0 = 1, 1 = 2) - 3);<0>} :: top{}
heap: Int: x, Int: y, fun<add>, fun<main>, 1, 2, 1, 2,
env: y: 2, x: 1, main: fun<main>, add: fun<add>,
}
--- handle value 1 with (x + y)<1>(1,) --->
{
stack: add{y<-1> :: (x + y)<1>(1,) :: return (x + y);<0>} :: main{(add(0 = 1, 1 = 2) - 3)<0> :: return (add(0 = 1, 1 = 2) - 3);<0>} :: top{}
heap: Int: x, Int: y, fun<add>, fun<main>, 1, 2, 1, 2,
env: y: 2, x: 1, main: fun<main>, add: fun<add>,
}
--- step exp y --->
{
stack: add{2<-1> :: (x + y)<1>(1,) :: return (x + y);<0>} :: main{(add(0 = 1, 1 = 2) - 3)<0> :: return (add(0 = 1, 1 = 2) - 3);<0>} :: top{}
heap: Int: x, Int: y, fun<add>, fun<main>, 1, 2, 1, 2,
env: y: 2, x: 1, main: fun<main>, add: fun<add>,
}
--- handle value 2 with (x + y)<2>(1,2,) --->
{
stack: add{3<-1> :: return (x + y);<0>} :: main{(add(0 = 1, 1 = 2) - 3)<0> :: return (add(0 = 1, 1 = 2) - 3);<0>} :: top{}
heap: Int: x, Int: y, fun<add>, fun<main>, 1, 2, 1, 2,
env: y: 2, x: 1, main: fun<main>, add: fun<add>,
}
--- handle value 3 with return (x + y);<1>(3,) --->
{
stack: main{3<-1> :: (add(0 = 1, 1 = 2) - 3)<0> :: return (add(0 = 1, 1 = 2) - 3);<0>} :: top{}
heap: Int: x, Int: y, fun<add>, fun<main>, 1, 2, !!1, !!2,
env: main: fun<main>, add: fun<add>,
}
--- handle value 3 with (add(0 = 1, 1 = 2) - 3)<1>(3,) --->
{
stack: main{3<-1> :: (add(0 = 1, 1 = 2) - 3)<1>(3,) :: return (add(0 = 1, 1 = 2) - 3);<0>} :: top{}
heap: Int: x, Int: y, fun<add>, fun<main>, 1, 2, !!1, !!2,
env: main: fun<main>, add: fun<add>,
}
--- step exp 3 --->
{
stack: main{3<-1> :: (add(0 = 1, 1 = 2) - 3)<1>(3,) :: return (add(0 = 1, 1 = 2) - 3);<0>} :: top{}
heap: Int: x, Int: y, fun<add>, fun<main>, 1, 2, !!1, !!2,
env: main: fun<main>, add: fun<add>,
}
--- handle value 3 with (add(0 = 1, 1 = 2) - 3)<2>(3,3,) --->
{
stack: main{0<-1> :: return (add(0 = 1, 1 = 2) - 3);<0>} :: top{}
heap: Int: x, Int: y, fun<add>, fun<main>, 1, 2, !!1, !!2,
env: main: fun<main>, add: fun<add>,
}
--- handle value 0 with return (add(0 = 1, 1 = 2) - 3);<1>(0,) --->
{
stack: top{0<-1>}
heap: Int: x, Int: y, fun<add>, fun<main>, 1, 2, !!1, !!2,
env: main: fun<main>, add: fun<add>,
}
result: 0
executable_semantics/testdata/fun_recur.golden
Vendored
+22 -1
View File
@@ -1 +1,22 @@
result: 0
********** source program **********
fn f Int: x -> Int {
if ((x == 0))
return x;
else
return f(0 = (x - 1));
}
fn main () -> Int {
return f(0 = 2);
}
********** type checking **********
--- step exp Int --->
--- step exp Int --->
--- step exp Int --->
--- step exp Int --->
--- step exp Int --->
9: type error in call
expected: Int
actual: Tuple(0 = Int)
EXIT CODE: 255
executable_semantics/testdata/funptr1.golden
Vendored
+26 -1
View File
@@ -1 +1,26 @@
result: 0
********** source program **********
fn add1 Int: x -> Int {
return (x + 1);
}
fn main () -> Int {
var fn Int -> Int: f = add1;
return f(0 = (- 1));
}
********** type checking **********
--- step exp Int --->
--- step exp Int --->
--- step exp Int --->
--- step exp Int --->
--- step exp Int --->
--- step exp Int --->
--- step exp fn Int -> Int --->
--- step exp Int --->
--- handle value Int with fn Int -> Int<1>(Int,) --->
--- step exp Int --->
--- handle value Int with fn Int -> Int<2>(Int,Int,) --->
11: type error in call
expected: Int
actual: Tuple(0 = Int)
EXIT CODE: 255
executable_semantics/testdata/if1.golden
Vendored
+160
View File
@@ -1 +1,161 @@
********** source program **********
fn main () -> Int {
if ((1 == 1))
return 0;
else
return 1;
}
********** type checking **********
--- step exp Int --->
--- step exp Int --->
********** type checking complete **********
fn main () -> Int {
if ((1 == 1))
return 0;
else
return 1;
}
********** starting execution **********
********** initializing globals **********
--- step exp () --->
********** calling main function **********
{
stack: top{main()<-1>}
heap: fun<main>,
env: main: fun<main>,
}
--- step exp main() --->
{
stack: top{main<-1> :: main()<0>}
heap: fun<main>,
env: main: fun<main>,
}
--- step exp main --->
{
stack: top{fun<main><-1> :: main()<0>}
heap: fun<main>,
env: main: fun<main>,
}
--- handle value fun<main> with main()<1>(fun<main>,) --->
{
stack: top{()<-1> :: main()<1>(fun<main>,)}
heap: fun<main>,
env: main: fun<main>,
}
--- step exp () --->
{
stack: top{()<-1> :: main()<1>(fun<main>,)}
heap: fun<main>,
env: main: fun<main>,
}
--- handle value () with main()<2>(fun<main>,(),) --->
pattern_match((), ())
{
stack: main{if ((1 == 1))
...
else
... <-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- step stmt if ((1 == 1))
...
else
... --->
{
stack: main{if ((1 == 1))
...
else
<-1> :: return 1;<-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- step stmt if ((1 == 1))
...
else
--->
{
stack: main{(1 == 1)<-1> :: if ((1 == 1))
...
else
<0> :: return 1;<-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- step exp (1 == 1) --->
{
stack: main{1<-1> :: (1 == 1)<0> :: if ((1 == 1))
...
else
<0> :: return 1;<-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- step exp 1 --->
{
stack: main{1<-1> :: (1 == 1)<0> :: if ((1 == 1))
...
else
<0> :: return 1;<-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- handle value 1 with (1 == 1)<1>(1,) --->
{
stack: main{1<-1> :: (1 == 1)<1>(1,) :: if ((1 == 1))
...
else
<0> :: return 1;<-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- step exp 1 --->
{
stack: main{1<-1> :: (1 == 1)<1>(1,) :: if ((1 == 1))
...
else
<0> :: return 1;<-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- handle value 1 with (1 == 1)<2>(1,1,) --->
{
stack: main{true<-1> :: if ((1 == 1))
...
else
<0> :: return 1;<-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- handle value true with if ((1 == 1))
...
else
<1>(true,) --->
{
stack: main{return 0;<-1> :: return 1;<-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- step stmt return 0; --->
{
stack: main{0<-1> :: return 0;<0> :: return 1;<-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- step exp 0 --->
{
stack: main{0<-1> :: return 0;<0> :: return 1;<-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- handle value 0 with return 0;<1>(0,) --->
{
stack: top{0<-1>}
heap: fun<main>,
env: main: fun<main>,
}
result: 0
executable_semantics/testdata/if2.golden
Vendored
+143 -1
View File
@@ -1 +1,143 @@
result: 0
********** source program **********
fn main () -> Int {
if ((0 == 1))
return 1;
else
return 0;
}
********** type checking **********
--- step exp Int --->
--- step exp Int --->
********** type checking complete **********
fn main () -> Int {
if ((0 == 1))
return 1;
else
return 0;
}
********** starting execution **********
********** initializing globals **********
--- step exp () --->
********** calling main function **********
{
stack: top{main()<-1>}
heap: fun<main>,
env: main: fun<main>,
}
--- step exp main() --->
{
stack: top{main<-1> :: main()<0>}
heap: fun<main>,
env: main: fun<main>,
}
--- step exp main --->
{
stack: top{fun<main><-1> :: main()<0>}
heap: fun<main>,
env: main: fun<main>,
}
--- handle value fun<main> with main()<1>(fun<main>,) --->
{
stack: top{()<-1> :: main()<1>(fun<main>,)}
heap: fun<main>,
env: main: fun<main>,
}
--- step exp () --->
{
stack: top{()<-1> :: main()<1>(fun<main>,)}
heap: fun<main>,
env: main: fun<main>,
}
--- handle value () with main()<2>(fun<main>,(),) --->
pattern_match((), ())
{
stack: main{if ((0 == 1))
...
else
... <-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- step stmt if ((0 == 1))
...
else
... --->
{
stack: main{if ((0 == 1))
...
else
<-1> :: return 0;<-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- step stmt if ((0 == 1))
...
else
--->
{
stack: main{(0 == 1)<-1> :: if ((0 == 1))
...
else
<0> :: return 0;<-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- step exp (0 == 1) --->
{
stack: main{0<-1> :: (0 == 1)<0> :: if ((0 == 1))
...
else
<0> :: return 0;<-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- step exp 0 --->
{
stack: main{0<-1> :: (0 == 1)<0> :: if ((0 == 1))
...
else
<0> :: return 0;<-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- handle value 0 with (0 == 1)<1>(0,) --->
{
stack: main{1<-1> :: (0 == 1)<1>(0,) :: if ((0 == 1))
...
else
<0> :: return 0;<-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- step exp 1 --->
{
stack: main{1<-1> :: (0 == 1)<1>(0,) :: if ((0 == 1))
...
else
<0> :: return 0;<-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- handle value 1 with (0 == 1)<2>(0,1,) --->
{
stack: main{false<-1> :: if ((0 == 1))
...
else
<0> :: return 0;<-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- handle value false with if ((0 == 1))
...
else
<1>(false,) --->
{
stack: main{<-1> :: return 0;<-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- step stmt --->
executable_semantics/testdata/if3.golden
Vendored
+235
View File
@@ -1 +1,236 @@
********** source program **********
fn main () -> Int {
if ((0 == 0))
if ((0 == 1))
return 1;
else
return 0;
else
return 1;
}
********** type checking **********
--- step exp Int --->
--- step exp Int --->
********** type checking complete **********
fn main () -> Int {
if ((0 == 0))
if ((0 == 1))
return 1;
else
return 0;
else
return 1;
}
********** starting execution **********
********** initializing globals **********
--- step exp () --->
********** calling main function **********
{
stack: top{main()<-1>}
heap: fun<main>,
env: main: fun<main>,
}
--- step exp main() --->
{
stack: top{main<-1> :: main()<0>}
heap: fun<main>,
env: main: fun<main>,
}
--- step exp main --->
{
stack: top{fun<main><-1> :: main()<0>}
heap: fun<main>,
env: main: fun<main>,
}
--- handle value fun<main> with main()<1>(fun<main>,) --->
{
stack: top{()<-1> :: main()<1>(fun<main>,)}
heap: fun<main>,
env: main: fun<main>,
}
--- step exp () --->
{
stack: top{()<-1> :: main()<1>(fun<main>,)}
heap: fun<main>,
env: main: fun<main>,
}
--- handle value () with main()<2>(fun<main>,(),) --->
pattern_match((), ())
{
stack: main{if ((0 == 0))
...
else
... <-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- step stmt if ((0 == 0))
...
else
... --->
{
stack: main{if ((0 == 0))
...
else
<-1> :: return 1;<-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- step stmt if ((0 == 0))
...
else
--->
{
stack: main{(0 == 0)<-1> :: if ((0 == 0))
...
else
<0> :: return 1;<-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- step exp (0 == 0) --->
{
stack: main{0<-1> :: (0 == 0)<0> :: if ((0 == 0))
...
else
<0> :: return 1;<-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- step exp 0 --->
{
stack: main{0<-1> :: (0 == 0)<0> :: if ((0 == 0))
...
else
<0> :: return 1;<-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- handle value 0 with (0 == 0)<1>(0,) --->
{
stack: main{0<-1> :: (0 == 0)<1>(0,) :: if ((0 == 0))
...
else
<0> :: return 1;<-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- step exp 0 --->
{
stack: main{0<-1> :: (0 == 0)<1>(0,) :: if ((0 == 0))
...
else
<0> :: return 1;<-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- handle value 0 with (0 == 0)<2>(0,0,) --->
{
stack: main{true<-1> :: if ((0 == 0))
...
else
<0> :: return 1;<-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- handle value true with if ((0 == 0))
...
else
<1>(true,) --->
{
stack: main{if ((0 == 1))
...
else
... <-1> :: return 1;<-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- step stmt if ((0 == 1))
...
else
... --->
{
stack: main{(0 == 1)<-1> :: if ((0 == 1))
...
else
... <0> :: return 1;<-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- step exp (0 == 1) --->
{
stack: main{0<-1> :: (0 == 1)<0> :: if ((0 == 1))
...
else
... <0> :: return 1;<-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- step exp 0 --->
{
stack: main{0<-1> :: (0 == 1)<0> :: if ((0 == 1))
...
else
... <0> :: return 1;<-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- handle value 0 with (0 == 1)<1>(0,) --->
{
stack: main{1<-1> :: (0 == 1)<1>(0,) :: if ((0 == 1))
...
else
... <0> :: return 1;<-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- step exp 1 --->
{
stack: main{1<-1> :: (0 == 1)<1>(0,) :: if ((0 == 1))
...
else
... <0> :: return 1;<-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- handle value 1 with (0 == 1)<2>(0,1,) --->
{
stack: main{false<-1> :: if ((0 == 1))
...
else
... <0> :: return 1;<-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- handle value false with if ((0 == 1))
...
else
... <1>(false,) --->
{
stack: main{return 0;<-1> :: return 1;<-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- step stmt return 0; --->
{
stack: main{0<-1> :: return 0;<0> :: return 1;<-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- step exp 0 --->
{
stack: main{0<-1> :: return 0;<0> :: return 1;<-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- handle value 0 with return 0;<1>(0,) --->
{
stack: top{0<-1>}
heap: fun<main>,
env: main: fun<main>,
}
result: 0
executable_semantics/testdata/match_int.golden
Vendored
+174
View File
@@ -1 +1,175 @@
********** source program **********
fn main () -> Int {
var auto: t = 5;
match (t) {
case 5 =>
return 0;
case auto: _ =>
return 1;
}
}
********** type checking **********
--- step exp Int --->
--- step exp Int --->
--- step exp auto --->
--- step exp auto --->
********** type checking complete **********
fn main () -> Int {
var auto: t = 5;
match (t) {
case 5 =>
return 0;
case auto: _ =>
return 1;
}
}
********** starting execution **********
********** initializing globals **********
--- step exp () --->
********** calling main function **********
{
stack: top{main()<-1>}
heap: fun<main>,
env: main: fun<main>,
}
--- step exp main() --->
{
stack: top{main<-1> :: main()<0>}
heap: fun<main>,
env: main: fun<main>,
}
--- step exp main --->
{
stack: top{fun<main><-1> :: main()<0>}
heap: fun<main>,
env: main: fun<main>,
}
--- handle value fun<main> with main()<1>(fun<main>,) --->
{
stack: top{()<-1> :: main()<1>(fun<main>,)}
heap: fun<main>,
env: main: fun<main>,
}
--- step exp () --->
{
stack: top{()<-1> :: main()<1>(fun<main>,)}
heap: fun<main>,
env: main: fun<main>,
}
--- handle value () with main()<2>(fun<main>,(),) --->
pattern_match((), ())
{
stack: main{var auto: t = 5; ... <-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- step stmt var auto: t = 5; ... --->
{
stack: main{var auto: t = 5;<-1> :: match (t) {...}<-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- step stmt var auto: t = 5; --->
{
stack: main{5<-1> :: var auto: t = 5;<0> :: match (t) {...}<-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- step exp 5 --->
{
stack: main{5<-1> :: var auto: t = 5;<0> :: match (t) {...}<-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- handle value 5 with var auto: t = 5;<1>(5,) --->
{
stack: main{auto: t<-1> :: var auto: t = 5;<1>(5,) :: match (t) {...}<-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- step exp auto: t --->
{
stack: main{auto<-1> :: auto: t<0> :: var auto: t = 5;<1>(5,) :: match (t) {...}<-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- step exp auto --->
{
stack: main{auto<-1> :: auto: t<0> :: var auto: t = 5;<1>(5,) :: match (t) {...}<-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- handle value auto with auto: t<1>(auto,) --->
{
stack: main{auto: t<-1> :: var auto: t = 5;<1>(5,) :: match (t) {...}<-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- handle value auto: t with var auto: t = 5;<2>(5,auto: t,) --->
pattern_match(auto: t, 5)
{
stack: main{match (t) {...}<-1>} :: top{}
heap: fun<main>, 5,
env: t: 5, main: fun<main>,
}
--- step stmt match (t) {...} --->
{
stack: main{t<-1> :: match (t) {...}<0>} :: top{}
heap: fun<main>, 5,
env: t: 5, main: fun<main>,
}
--- step exp t --->
{
stack: main{5<-1> :: match (t) {...}<0>} :: top{}
heap: fun<main>, 5,
env: t: 5, main: fun<main>,
}
--- handle value 5 with match (t) {...}<1>(5,) --->
{
stack: main{5<-1> :: match (t) {...}<1>(5,)} :: top{}
heap: fun<main>, 5,
env: t: 5, main: fun<main>,
}
--- step exp 5 --->
{
stack: main{5<-1> :: match (t) {...}<1>(5,)} :: top{}
heap: fun<main>, 5,
env: t: 5, main: fun<main>,
}
--- handle value 5 with match (t) {...}<2>(5,5,) --->
pattern_match(5, 5)
{
stack: main{return 0;<-1> :: {
...
}
<0>} :: top{}
heap: fun<main>, 5,
env: t: 5, main: fun<main>,
}
--- step stmt return 0; --->
{
stack: main{0<-1> :: return 0;<0> :: {
...
}
<0>} :: top{}
heap: fun<main>, 5,
env: t: 5, main: fun<main>,
}
--- step exp 0 --->
{
stack: main{0<-1> :: return 0;<0> :: {
...
}
<0>} :: top{}
heap: fun<main>, 5,
env: t: 5, main: fun<main>,
}
--- handle value 0 with return 0;<1>(0,) --->
{
stack: top{0<-1>}
heap: fun<main>, !!5,
env: main: fun<main>,
}
result: 0
executable_semantics/testdata/match_int_default.golden
Vendored
+216
View File
@@ -1 +1,217 @@
********** source program **********
fn main () -> Int {
var auto: t = 5;
match (t) {
case 3 =>
return (- 1);
case 4 =>
return (- 1);
case auto: _ =>
return 0;
}
}
********** type checking **********
--- step exp Int --->
--- step exp Int --->
--- step exp auto --->
--- step exp auto --->
********** type checking complete **********
fn main () -> Int {
var auto: t = 5;
match (t) {
case 3 =>
return (- 1);
case 4 =>
return (- 1);
case auto: _ =>
return 0;
}
}
********** starting execution **********
********** initializing globals **********
--- step exp () --->
********** calling main function **********
{
stack: top{main()<-1>}
heap: fun<main>,
env: main: fun<main>,
}
--- step exp main() --->
{
stack: top{main<-1> :: main()<0>}
heap: fun<main>,
env: main: fun<main>,
}
--- step exp main --->
{
stack: top{fun<main><-1> :: main()<0>}
heap: fun<main>,
env: main: fun<main>,
}
--- handle value fun<main> with main()<1>(fun<main>,) --->
{
stack: top{()<-1> :: main()<1>(fun<main>,)}
heap: fun<main>,
env: main: fun<main>,
}
--- step exp () --->
{
stack: top{()<-1> :: main()<1>(fun<main>,)}
heap: fun<main>,
env: main: fun<main>,
}
--- handle value () with main()<2>(fun<main>,(),) --->
pattern_match((), ())
{
stack: main{var auto: t = 5; ... <-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- step stmt var auto: t = 5; ... --->
{
stack: main{var auto: t = 5;<-1> :: match (t) {...}<-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- step stmt var auto: t = 5; --->
{
stack: main{5<-1> :: var auto: t = 5;<0> :: match (t) {...}<-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- step exp 5 --->
{
stack: main{5<-1> :: var auto: t = 5;<0> :: match (t) {...}<-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- handle value 5 with var auto: t = 5;<1>(5,) --->
{
stack: main{auto: t<-1> :: var auto: t = 5;<1>(5,) :: match (t) {...}<-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- step exp auto: t --->
{
stack: main{auto<-1> :: auto: t<0> :: var auto: t = 5;<1>(5,) :: match (t) {...}<-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- step exp auto --->
{
stack: main{auto<-1> :: auto: t<0> :: var auto: t = 5;<1>(5,) :: match (t) {...}<-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- handle value auto with auto: t<1>(auto,) --->
{
stack: main{auto: t<-1> :: var auto: t = 5;<1>(5,) :: match (t) {...}<-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- handle value auto: t with var auto: t = 5;<2>(5,auto: t,) --->
pattern_match(auto: t, 5)
{
stack: main{match (t) {...}<-1>} :: top{}
heap: fun<main>, 5,
env: t: 5, main: fun<main>,
}
--- step stmt match (t) {...} --->
{
stack: main{t<-1> :: match (t) {...}<0>} :: top{}
heap: fun<main>, 5,
env: t: 5, main: fun<main>,
}
--- step exp t --->
{
stack: main{5<-1> :: match (t) {...}<0>} :: top{}
heap: fun<main>, 5,
env: t: 5, main: fun<main>,
}
--- handle value 5 with match (t) {...}<1>(5,) --->
{
stack: main{3<-1> :: match (t) {...}<1>(5,)} :: top{}
heap: fun<main>, 5,
env: t: 5, main: fun<main>,
}
--- step exp 3 --->
{
stack: main{3<-1> :: match (t) {...}<1>(5,)} :: top{}
heap: fun<main>, 5,
env: t: 5, main: fun<main>,
}
--- handle value 3 with match (t) {...}<2>(5,3,) --->
pattern_match(3, 5)
{
stack: main{4<-1> :: match (t) {...}<3>(5,3,)} :: top{}
heap: fun<main>, 5,
env: t: 5, main: fun<main>,
}
--- step exp 4 --->
{
stack: main{4<-1> :: match (t) {...}<3>(5,3,)} :: top{}
heap: fun<main>, 5,
env: t: 5, main: fun<main>,
}
--- handle value 4 with match (t) {...}<4>(5,3,4,) --->
pattern_match(4, 5)
{
stack: main{auto: _<-1> :: match (t) {...}<5>(5,3,4,)} :: top{}
heap: fun<main>, 5,
env: t: 5, main: fun<main>,
}
--- step exp auto: _ --->
{
stack: main{auto<-1> :: auto: _<0> :: match (t) {...}<5>(5,3,4,)} :: top{}
heap: fun<main>, 5,
env: t: 5, main: fun<main>,
}
--- step exp auto --->
{
stack: main{auto<-1> :: auto: _<0> :: match (t) {...}<5>(5,3,4,)} :: top{}
heap: fun<main>, 5,
env: t: 5, main: fun<main>,
}
--- handle value auto with auto: _<1>(auto,) --->
{
stack: main{auto: _<-1> :: match (t) {...}<5>(5,3,4,)} :: top{}
heap: fun<main>, 5,
env: t: 5, main: fun<main>,
}
--- handle value auto: _ with match (t) {...}<6>(5,3,4,auto: _,) --->
pattern_match(auto: _, 5)
{
stack: main{return 0;<-1> :: {
...
}
<0>} :: top{}
heap: fun<main>, 5, 5,
env: _: 5, t: 5, main: fun<main>,
}
--- step stmt return 0; --->
{
stack: main{0<-1> :: return 0;<0> :: {
...
}
<0>} :: top{}
heap: fun<main>, 5, 5,
env: _: 5, t: 5, main: fun<main>,
}
--- step exp 0 --->
{
stack: main{0<-1> :: return 0;<0> :: {
...
}
<0>} :: top{}
heap: fun<main>, 5, 5,
env: _: 5, t: 5, main: fun<main>,
}
--- handle value 0 with return 0;<1>(0,) --->
{
stack: top{0<-1>}
heap: fun<main>, !!5, !!5,
env: main: fun<main>,
}
result: 0
executable_semantics/testdata/match_type.golden
Vendored
+652
View File
@@ -1 +1,653 @@
********** source program **********
fn main () -> Int {
var auto: t = fn (0 = Int, 1 = Int) -> ();
var Int: x = 0;
match (t) {
case fn (0 = Int, 1 = Int) -> (): z =>
x = (x + 1);
}
match (t) {
case fn (0 = Type: a, 1 = Type: b) -> () =>
x = (x - 1);
}
return x;
}
********** type checking **********
--- step exp Int --->
--- step exp Int --->
--- step exp (0 = Int, 1 = Int) --->
--- step exp Int --->
--- handle value Int with (0 = Int, 1 = Int)<1>(Int,) --->
--- step exp Int --->
--- handle value Int with (0 = Int, 1 = Int)<2>(Int,Int,) --->
--- step exp () --->
--- step exp auto --->
--- step exp Int --->
--- step exp fn (0 = Int, 1 = Int) -> () --->
--- step exp (0 = Int, 1 = Int) --->
--- step exp Int --->
--- handle value Int with (0 = Int, 1 = Int)<1>(Int,) --->
--- step exp Int --->
--- handle value Int with (0 = Int, 1 = Int)<2>(Int,Int,) --->
--- handle value (0 = Int@2, 1 = Int@3) with fn (0 = Int, 1 = Int) -> ()<1>((0 = Int@2, 1 = Int@3),) --->
--- step exp () --->
--- handle value () with fn (0 = Int, 1 = Int) -> ()<2>((0 = Int@2, 1 = Int@3),(),) --->
--- step exp Type --->
--- step exp Type --->
********** type checking complete **********
fn main () -> Int {
var auto: t = fn (0 = Int, 1 = Int) -> ();
var Int: x = 0;
match (t) {
case fn (0 = Int, 1 = Int) -> (): z =>
x = (x + 1);
}
match (t) {
case fn (0 = Type: a, 1 = Type: b) -> () =>
x = (x - 1);
}
return x;
}
********** starting execution **********
********** initializing globals **********
--- step exp () --->
********** calling main function **********
{
stack: top{main()<-1>}
heap: fun<main>,
env: main: fun<main>,
}
--- step exp main() --->
{
stack: top{main<-1> :: main()<0>}
heap: fun<main>,
env: main: fun<main>,
}
--- step exp main --->
{
stack: top{fun<main><-1> :: main()<0>}
heap: fun<main>,
env: main: fun<main>,
}
--- handle value fun<main> with main()<1>(fun<main>,) --->
{
stack: top{()<-1> :: main()<1>(fun<main>,)}
heap: fun<main>,
env: main: fun<main>,
}
--- step exp () --->
{
stack: top{()<-1> :: main()<1>(fun<main>,)}
heap: fun<main>,
env: main: fun<main>,
}
--- handle value () with main()<2>(fun<main>,(),) --->
pattern_match((), ())
{
stack: main{var auto: t = fn (0 = Int, 1 = Int) -> (); ... <-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- step stmt var auto: t = fn (0 = Int, 1 = Int) -> (); ... --->
{
stack: main{var auto: t = fn (0 = Int, 1 = Int) -> ();<-1> :: var Int: x = 0; ... <-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- step stmt var auto: t = fn (0 = Int, 1 = Int) -> (); --->
{
stack: main{fn (0 = Int, 1 = Int) -> ()<-1> :: var auto: t = fn (0 = Int, 1 = Int) -> ();<0> :: var Int: x = 0; ... <-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- step exp fn (0 = Int, 1 = Int) -> () --->
{
stack: main{(0 = Int, 1 = Int)<-1> :: fn (0 = Int, 1 = Int) -> ()<0> :: var auto: t = fn (0 = Int, 1 = Int) -> ();<0> :: var Int: x = 0; ... <-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- step exp (0 = Int, 1 = Int) --->
{
stack: main{Int<-1> :: (0 = Int, 1 = Int)<0> :: fn (0 = Int, 1 = Int) -> ()<0> :: var auto: t = fn (0 = Int, 1 = Int) -> ();<0> :: var Int: x = 0; ... <-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- step exp Int --->
{
stack: main{Int<-1> :: (0 = Int, 1 = Int)<0> :: fn (0 = Int, 1 = Int) -> ()<0> :: var auto: t = fn (0 = Int, 1 = Int) -> ();<0> :: var Int: x = 0; ... <-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- handle value Int with (0 = Int, 1 = Int)<1>(Int,) --->
{
stack: main{Int<-1> :: (0 = Int, 1 = Int)<1>(Int,) :: fn (0 = Int, 1 = Int) -> ()<0> :: var auto: t = fn (0 = Int, 1 = Int) -> ();<0> :: var Int: x = 0; ... <-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- step exp Int --->
{
stack: main{Int<-1> :: (0 = Int, 1 = Int)<1>(Int,) :: fn (0 = Int, 1 = Int) -> ()<0> :: var auto: t = fn (0 = Int, 1 = Int) -> ();<0> :: var Int: x = 0; ... <-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- handle value Int with (0 = Int, 1 = Int)<2>(Int,Int,) --->
{
stack: main{(0 = Int@1, 1 = Int@2)<-1> :: fn (0 = Int, 1 = Int) -> ()<0> :: var auto: t = fn (0 = Int, 1 = Int) -> ();<0> :: var Int: x = 0; ... <-1>} :: top{}
heap: fun<main>, Int, Int,
env: main: fun<main>,
}
--- handle value (0 = Int@1, 1 = Int@2) with fn (0 = Int, 1 = Int) -> ()<1>((0 = Int@1, 1 = Int@2),) --->
{
stack: main{()<-1> :: fn (0 = Int, 1 = Int) -> ()<1>((0 = Int@1, 1 = Int@2),) :: var auto: t = fn (0 = Int, 1 = Int) -> ();<0> :: var Int: x = 0; ... <-1>} :: top{}
heap: fun<main>, Int, Int,
env: main: fun<main>,
}
--- step exp () --->
{
stack: main{()<-1> :: fn (0 = Int, 1 = Int) -> ()<1>((0 = Int@1, 1 = Int@2),) :: var auto: t = fn (0 = Int, 1 = Int) -> ();<0> :: var Int: x = 0; ... <-1>} :: top{}
heap: fun<main>, Int, Int,
env: main: fun<main>,
}
--- handle value () with fn (0 = Int, 1 = Int) -> ()<2>((0 = Int@1, 1 = Int@2),(),) --->
{
stack: main{fn (0 = Int@1, 1 = Int@2) -> ()<-1> :: var auto: t = fn (0 = Int, 1 = Int) -> ();<0> :: var Int: x = 0; ... <-1>} :: top{}
heap: fun<main>, Int, Int,
env: main: fun<main>,
}
--- handle value fn (0 = Int@1, 1 = Int@2) -> () with var auto: t = fn (0 = Int, 1 = Int) -> ();<1>(fn (0 = Int@1, 1 = Int@2) -> (),) --->
{
stack: main{auto: t<-1> :: var auto: t = fn (0 = Int, 1 = Int) -> ();<1>(fn (0 = Int@1, 1 = Int@2) -> (),) :: var Int: x = 0; ... <-1>} :: top{}
heap: fun<main>, Int, Int,
env: main: fun<main>,
}
--- step exp auto: t --->
{
stack: main{auto<-1> :: auto: t<0> :: var auto: t = fn (0 = Int, 1 = Int) -> ();<1>(fn (0 = Int@1, 1 = Int@2) -> (),) :: var Int: x = 0; ... <-1>} :: top{}
heap: fun<main>, Int, Int,
env: main: fun<main>,
}
--- step exp auto --->
{
stack: main{auto<-1> :: auto: t<0> :: var auto: t = fn (0 = Int, 1 = Int) -> ();<1>(fn (0 = Int@1, 1 = Int@2) -> (),) :: var Int: x = 0; ... <-1>} :: top{}
heap: fun<main>, Int, Int,
env: main: fun<main>,
}
--- handle value auto with auto: t<1>(auto,) --->
{
stack: main{auto: t<-1> :: var auto: t = fn (0 = Int, 1 = Int) -> ();<1>(fn (0 = Int@1, 1 = Int@2) -> (),) :: var Int: x = 0; ... <-1>} :: top{}
heap: fun<main>, Int, Int,
env: main: fun<main>,
}
--- handle value auto: t with var auto: t = fn (0 = Int, 1 = Int) -> ();<2>(fn (0 = Int@1, 1 = Int@2) -> (),auto: t,) --->
pattern_match(auto: t, fn (0 = Int@1, 1 = Int@2) -> ())
{
stack: main{var Int: x = 0; ... <-1>} :: top{}
heap: fun<main>, Int, Int, Int, Int, fn (0 = Int@3, 1 = Int@4) -> (),
env: t: fn (0 = Int@3, 1 = Int@4) -> (), main: fun<main>,
}
--- step stmt var Int: x = 0; ... --->
{
stack: main{var Int: x = 0;<-1> :: match (t) {...} ... <-1>} :: top{}
heap: fun<main>, Int, Int, Int, Int, fn (0 = Int@3, 1 = Int@4) -> (),
env: t: fn (0 = Int@3, 1 = Int@4) -> (), main: fun<main>,
}
--- step stmt var Int: x = 0; --->
{
stack: main{0<-1> :: var Int: x = 0;<0> :: match (t) {...} ... <-1>} :: top{}
heap: fun<main>, Int, Int, Int, Int, fn (0 = Int@3, 1 = Int@4) -> (),
env: t: fn (0 = Int@3, 1 = Int@4) -> (), main: fun<main>,
}
--- step exp 0 --->
{
stack: main{0<-1> :: var Int: x = 0;<0> :: match (t) {...} ... <-1>} :: top{}
heap: fun<main>, Int, Int, Int, Int, fn (0 = Int@3, 1 = Int@4) -> (),
env: t: fn (0 = Int@3, 1 = Int@4) -> (), main: fun<main>,
}
--- handle value 0 with var Int: x = 0;<1>(0,) --->
{
stack: main{Int: x<-1> :: var Int: x = 0;<1>(0,) :: match (t) {...} ... <-1>} :: top{}
heap: fun<main>, Int, Int, Int, Int, fn (0 = Int@3, 1 = Int@4) -> (),
env: t: fn (0 = Int@3, 1 = Int@4) -> (), main: fun<main>,
}
--- step exp Int: x --->
{
stack: main{Int<-1> :: Int: x<0> :: var Int: x = 0;<1>(0,) :: match (t) {...} ... <-1>} :: top{}
heap: fun<main>, Int, Int, Int, Int, fn (0 = Int@3, 1 = Int@4) -> (),
env: t: fn (0 = Int@3, 1 = Int@4) -> (), main: fun<main>,
}
--- step exp Int --->
{
stack: main{Int<-1> :: Int: x<0> :: var Int: x = 0;<1>(0,) :: match (t) {...} ... <-1>} :: top{}
heap: fun<main>, Int, Int, Int, Int, fn (0 = Int@3, 1 = Int@4) -> (),
env: t: fn (0 = Int@3, 1 = Int@4) -> (), main: fun<main>,
}
--- handle value Int with Int: x<1>(Int,) --->
{
stack: main{Int: x<-1> :: var Int: x = 0;<1>(0,) :: match (t) {...} ... <-1>} :: top{}
heap: fun<main>, Int, Int, Int, Int, fn (0 = Int@3, 1 = Int@4) -> (),
env: t: fn (0 = Int@3, 1 = Int@4) -> (), main: fun<main>,
}
--- handle value Int: x with var Int: x = 0;<2>(0,Int: x,) --->
pattern_match(Int: x, 0)
{
stack: main{match (t) {...} ... <-1>} :: top{}
heap: fun<main>, Int, Int, Int, Int, fn (0 = Int@3, 1 = Int@4) -> (), 0,
env: x: 0, t: fn (0 = Int@3, 1 = Int@4) -> (), main: fun<main>,
}
--- step stmt match (t) {...} ... --->
{
stack: main{match (t) {...}<-1> :: match (t) {...} ... <-1>} :: top{}
heap: fun<main>, Int, Int, Int, Int, fn (0 = Int@3, 1 = Int@4) -> (), 0,
env: x: 0, t: fn (0 = Int@3, 1 = Int@4) -> (), main: fun<main>,
}
--- step stmt match (t) {...} --->
{
stack: main{t<-1> :: match (t) {...}<0> :: match (t) {...} ... <-1>} :: top{}
heap: fun<main>, Int, Int, Int, Int, fn (0 = Int@3, 1 = Int@4) -> (), 0,
env: x: 0, t: fn (0 = Int@3, 1 = Int@4) -> (), main: fun<main>,
}
--- step exp t --->
{
stack: main{fn (0 = Int@3, 1 = Int@4) -> ()<-1> :: match (t) {...}<0> :: match (t) {...} ... <-1>} :: top{}
heap: fun<main>, Int, Int, Int, Int, fn (0 = Int@3, 1 = Int@4) -> (), 0,
env: x: 0, t: fn (0 = Int@3, 1 = Int@4) -> (), main: fun<main>,
}
--- handle value fn (0 = Int@3, 1 = Int@4) -> () with match (t) {...}<1>(fn (0 = Int@3, 1 = Int@4) -> (),) --->
{
stack: main{fn (0 = Int, 1 = Int) -> (): z<-1> :: match (t) {...}<1>(fn (0 = Int@3, 1 = Int@4) -> (),) :: match (t) {...} ... <-1>} :: top{}
heap: fun<main>, Int, Int, Int, Int, fn (0 = Int@3, 1 = Int@4) -> (), 0,
env: x: 0, t: fn (0 = Int@3, 1 = Int@4) -> (), main: fun<main>,
}
--- step exp fn (0 = Int, 1 = Int) -> (): z --->
{
stack: main{fn (0 = Int, 1 = Int) -> ()<-1> :: fn (0 = Int, 1 = Int) -> (): z<0> :: match (t) {...}<1>(fn (0 = Int@3, 1 = Int@4) -> (),) :: match (t) {...} ... <-1>} :: top{}
heap: fun<main>, Int, Int, Int, Int, fn (0 = Int@3, 1 = Int@4) -> (), 0,
env: x: 0, t: fn (0 = Int@3, 1 = Int@4) -> (), main: fun<main>,
}
--- step exp fn (0 = Int, 1 = Int) -> () --->
{
stack: main{(0 = Int, 1 = Int)<-1> :: fn (0 = Int, 1 = Int) -> ()<0> :: fn (0 = Int, 1 = Int) -> (): z<0> :: match (t) {...}<1>(fn (0 = Int@3, 1 = Int@4) -> (),) :: match (t) {...} ... <-1>} :: top{}
heap: fun<main>, Int, Int, Int, Int, fn (0 = Int@3, 1 = Int@4) -> (), 0,
env: x: 0, t: fn (0 = Int@3, 1 = Int@4) -> (), main: fun<main>,
}
--- step exp (0 = Int, 1 = Int) --->
{
stack: main{Int<-1> :: (0 = Int, 1 = Int)<0> :: fn (0 = Int, 1 = Int) -> ()<0> :: fn (0 = Int, 1 = Int) -> (): z<0> :: match (t) {...}<1>(fn (0 = Int@3, 1 = Int@4) -> (),) :: match (t) {...} ... <-1>} :: top{}
heap: fun<main>, Int, Int, Int, Int, fn (0 = Int@3, 1 = Int@4) -> (), 0,
env: x: 0, t: fn (0 = Int@3, 1 = Int@4) -> (), main: fun<main>,
}
--- step exp Int --->
{
stack: main{Int<-1> :: (0 = Int, 1 = Int)<0> :: fn (0 = Int, 1 = Int) -> ()<0> :: fn (0 = Int, 1 = Int) -> (): z<0> :: match (t) {...}<1>(fn (0 = Int@3, 1 = Int@4) -> (),) :: match (t) {...} ... <-1>} :: top{}
heap: fun<main>, Int, Int, Int, Int, fn (0 = Int@3, 1 = Int@4) -> (), 0,
env: x: 0, t: fn (0 = Int@3, 1 = Int@4) -> (), main: fun<main>,
}
--- handle value Int with (0 = Int, 1 = Int)<1>(Int,) --->
{
stack: main{Int<-1> :: (0 = Int, 1 = Int)<1>(Int,) :: fn (0 = Int, 1 = Int) -> ()<0> :: fn (0 = Int, 1 = Int) -> (): z<0> :: match (t) {...}<1>(fn (0 = Int@3, 1 = Int@4) -> (),) :: match (t) {...} ... <-1>} :: top{}
heap: fun<main>, Int, Int, Int, Int, fn (0 = Int@3, 1 = Int@4) -> (), 0,
env: x: 0, t: fn (0 = Int@3, 1 = Int@4) -> (), main: fun<main>,
}
--- step exp Int --->
{
stack: main{Int<-1> :: (0 = Int, 1 = Int)<1>(Int,) :: fn (0 = Int, 1 = Int) -> ()<0> :: fn (0 = Int, 1 = Int) -> (): z<0> :: match (t) {...}<1>(fn (0 = Int@3, 1 = Int@4) -> (),) :: match (t) {...} ... <-1>} :: top{}
heap: fun<main>, Int, Int, Int, Int, fn (0 = Int@3, 1 = Int@4) -> (), 0,
env: x: 0, t: fn (0 = Int@3, 1 = Int@4) -> (), main: fun<main>,
}
--- handle value Int with (0 = Int, 1 = Int)<2>(Int,Int,) --->
{
stack: main{(0 = Int@7, 1 = Int@8)<-1> :: fn (0 = Int, 1 = Int) -> ()<0> :: fn (0 = Int, 1 = Int) -> (): z<0> :: match (t) {...}<1>(fn (0 = Int@3, 1 = Int@4) -> (),) :: match (t) {...} ... <-1>} :: top{}
heap: fun<main>, Int, Int, Int, Int, fn (0 = Int@3, 1 = Int@4) -> (), 0, Int, Int,
env: x: 0, t: fn (0 = Int@3, 1 = Int@4) -> (), main: fun<main>,
}
--- handle value (0 = Int@7, 1 = Int@8) with fn (0 = Int, 1 = Int) -> ()<1>((0 = Int@7, 1 = Int@8),) --->
{
stack: main{()<-1> :: fn (0 = Int, 1 = Int) -> ()<1>((0 = Int@7, 1 = Int@8),) :: fn (0 = Int, 1 = Int) -> (): z<0> :: match (t) {...}<1>(fn (0 = Int@3, 1 = Int@4) -> (),) :: match (t) {...} ... <-1>} :: top{}
heap: fun<main>, Int, Int, Int, Int, fn (0 = Int@3, 1 = Int@4) -> (), 0, Int, Int,
env: x: 0, t: fn (0 = Int@3, 1 = Int@4) -> (), main: fun<main>,
}
--- step exp () --->
{
stack: main{()<-1> :: fn (0 = Int, 1 = Int) -> ()<1>((0 = Int@7, 1 = Int@8),) :: fn (0 = Int, 1 = Int) -> (): z<0> :: match (t) {...}<1>(fn (0 = Int@3, 1 = Int@4) -> (),) :: match (t) {...} ... <-1>} :: top{}
heap: fun<main>, Int, Int, Int, Int, fn (0 = Int@3, 1 = Int@4) -> (), 0, Int, Int,
env: x: 0, t: fn (0 = Int@3, 1 = Int@4) -> (), main: fun<main>,
}
--- handle value () with fn (0 = Int, 1 = Int) -> ()<2>((0 = Int@7, 1 = Int@8),(),) --->
{
stack: main{fn (0 = Int@7, 1 = Int@8) -> ()<-1> :: fn (0 = Int, 1 = Int) -> (): z<0> :: match (t) {...}<1>(fn (0 = Int@3, 1 = Int@4) -> (),) :: match (t) {...} ... <-1>} :: top{}
heap: fun<main>, Int, Int, Int, Int, fn (0 = Int@3, 1 = Int@4) -> (), 0, Int, Int,
env: x: 0, t: fn (0 = Int@3, 1 = Int@4) -> (), main: fun<main>,
}
--- handle value fn (0 = Int@7, 1 = Int@8) -> () with fn (0 = Int, 1 = Int) -> (): z<1>(fn (0 = Int@7, 1 = Int@8) -> (),) --->
{
stack: main{fn (0 = Int@7, 1 = Int@8) -> (): z<-1> :: match (t) {...}<1>(fn (0 = Int@3, 1 = Int@4) -> (),) :: match (t) {...} ... <-1>} :: top{}
heap: fun<main>, Int, Int, Int, Int, fn (0 = Int@3, 1 = Int@4) -> (), 0, Int, Int,
env: x: 0, t: fn (0 = Int@3, 1 = Int@4) -> (), main: fun<main>,
}
--- handle value fn (0 = Int@7, 1 = Int@8) -> (): z with match (t) {...}<2>(fn (0 = Int@3, 1 = Int@4) -> (),fn (0 = Int@7, 1 = Int@8) -> (): z,) --->
pattern_match(fn (0 = Int@7, 1 = Int@8) -> (): z, fn (0 = Int@3, 1 = Int@4) -> ())
{
stack: main{x = (x + 1);<-1> :: {
...
}
<0> :: match (t) {...} ... <-1>} :: top{}
heap: fun<main>, Int, Int, Int, Int, fn (0 = Int@3, 1 = Int@4) -> (), 0, Int, Int, Int, Int, fn (0 = Int@9, 1 = Int@10) -> (),
env: z: fn (0 = Int@9, 1 = Int@10) -> (), x: 0, t: fn (0 = Int@3, 1 = Int@4) -> (), main: fun<main>,
}
--- step stmt x = (x + 1); --->
{
stack: main{x<-1> :: x = (x + 1);<0> :: {
...
}
<0> :: match (t) {...} ... <-1>} :: top{}
heap: fun<main>, Int, Int, Int, Int, fn (0 = Int@3, 1 = Int@4) -> (), 0, Int, Int, Int, Int, fn (0 = Int@9, 1 = Int@10) -> (),
env: z: fn (0 = Int@9, 1 = Int@10) -> (), x: 0, t: fn (0 = Int@3, 1 = Int@4) -> (), main: fun<main>,
}
--- step lvalue x --->
{
stack: main{ptr<6><-1> :: x = (x + 1);<0> :: {
...
}
<0> :: match (t) {...} ... <-1>} :: top{}
heap: fun<main>, Int, Int, Int, Int, fn (0 = Int@3, 1 = Int@4) -> (), 0, Int, Int, Int, Int, fn (0 = Int@9, 1 = Int@10) -> (),
env: z: fn (0 = Int@9, 1 = Int@10) -> (), x: 0, t: fn (0 = Int@3, 1 = Int@4) -> (), main: fun<main>,
}
--- handle value ptr<6> with x = (x + 1);<1>(ptr<6>,) --->
{
stack: main{(x + 1)<-1> :: x = (x + 1);<1>(ptr<6>,) :: {
...
}
<0> :: match (t) {...} ... <-1>} :: top{}
heap: fun<main>, Int, Int, Int, Int, fn (0 = Int@3, 1 = Int@4) -> (), 0, Int, Int, Int, Int, fn (0 = Int@9, 1 = Int@10) -> (),
env: z: fn (0 = Int@9, 1 = Int@10) -> (), x: 0, t: fn (0 = Int@3, 1 = Int@4) -> (), main: fun<main>,
}
--- step exp (x + 1) --->
{
stack: main{x<-1> :: (x + 1)<0> :: x = (x + 1);<1>(ptr<6>,) :: {
...
}
<0> :: match (t) {...} ... <-1>} :: top{}
heap: fun<main>, Int, Int, Int, Int, fn (0 = Int@3, 1 = Int@4) -> (), 0, Int, Int, Int, Int, fn (0 = Int@9, 1 = Int@10) -> (),
env: z: fn (0 = Int@9, 1 = Int@10) -> (), x: 0, t: fn (0 = Int@3, 1 = Int@4) -> (), main: fun<main>,
}
--- step exp x --->
{
stack: main{0<-1> :: (x + 1)<0> :: x = (x + 1);<1>(ptr<6>,) :: {
...
}
<0> :: match (t) {...} ... <-1>} :: top{}
heap: fun<main>, Int, Int, Int, Int, fn (0 = Int@3, 1 = Int@4) -> (), 0, Int, Int, Int, Int, fn (0 = Int@9, 1 = Int@10) -> (),
env: z: fn (0 = Int@9, 1 = Int@10) -> (), x: 0, t: fn (0 = Int@3, 1 = Int@4) -> (), main: fun<main>,
}
--- handle value 0 with (x + 1)<1>(0,) --->
{
stack: main{1<-1> :: (x + 1)<1>(0,) :: x = (x + 1);<1>(ptr<6>,) :: {
...
}
<0> :: match (t) {...} ... <-1>} :: top{}
heap: fun<main>, Int, Int, Int, Int, fn (0 = Int@3, 1 = Int@4) -> (), 0, Int, Int, Int, Int, fn (0 = Int@9, 1 = Int@10) -> (),
env: z: fn (0 = Int@9, 1 = Int@10) -> (), x: 0, t: fn (0 = Int@3, 1 = Int@4) -> (), main: fun<main>,
}
--- step exp 1 --->
{
stack: main{1<-1> :: (x + 1)<1>(0,) :: x = (x + 1);<1>(ptr<6>,) :: {
...
}
<0> :: match (t) {...} ... <-1>} :: top{}
heap: fun<main>, Int, Int, Int, Int, fn (0 = Int@3, 1 = Int@4) -> (), 0, Int, Int, Int, Int, fn (0 = Int@9, 1 = Int@10) -> (),
env: z: fn (0 = Int@9, 1 = Int@10) -> (), x: 0, t: fn (0 = Int@3, 1 = Int@4) -> (), main: fun<main>,
}
--- handle value 1 with (x + 1)<2>(0,1,) --->
{
stack: main{1<-1> :: x = (x + 1);<1>(ptr<6>,) :: {
...
}
<0> :: match (t) {...} ... <-1>} :: top{}
heap: fun<main>, Int, Int, Int, Int, fn (0 = Int@3, 1 = Int@4) -> (), 0, Int, Int, Int, Int, fn (0 = Int@9, 1 = Int@10) -> (),
env: z: fn (0 = Int@9, 1 = Int@10) -> (), x: 0, t: fn (0 = Int@3, 1 = Int@4) -> (), main: fun<main>,
}
--- handle value 1 with x = (x + 1);<2>(ptr<6>,1,) --->
{
stack: main{{
...
}
<0> :: match (t) {...} ... <-1>} :: top{}
heap: fun<main>, Int, Int, Int, Int, fn (0 = Int@3, 1 = Int@4) -> (), 1, Int, Int, Int, Int, fn (0 = Int@9, 1 = Int@10) -> (),
env: z: fn (0 = Int@9, 1 = Int@10) -> (), x: 1, t: fn (0 = Int@3, 1 = Int@4) -> (), main: fun<main>,
}
--- step stmt {
...
}
--->
{
stack: main{match (t) {...} ... <-1>} :: top{}
heap: fun<main>, Int, Int, Int, Int, fn (0 = Int@3, 1 = Int@4) -> (), 1, Int, Int, Int, Int, !!fn (0 = Int@9, 1 = Int@10) -> (),
env: x: 1, t: fn (0 = Int@3, 1 = Int@4) -> (), main: fun<main>,
}
--- step stmt match (t) {...} ... --->
{
stack: main{match (t) {...}<-1> :: return x;<-1>} :: top{}
heap: fun<main>, Int, Int, Int, Int, fn (0 = Int@3, 1 = Int@4) -> (), 1, Int, Int, Int, Int, !!fn (0 = Int@9, 1 = Int@10) -> (),
env: x: 1, t: fn (0 = Int@3, 1 = Int@4) -> (), main: fun<main>,
}
--- step stmt match (t) {...} --->
{
stack: main{t<-1> :: match (t) {...}<0> :: return x;<-1>} :: top{}
heap: fun<main>, Int, Int, Int, Int, fn (0 = Int@3, 1 = Int@4) -> (), 1, Int, Int, Int, Int, !!fn (0 = Int@9, 1 = Int@10) -> (),
env: x: 1, t: fn (0 = Int@3, 1 = Int@4) -> (), main: fun<main>,
}
--- step exp t --->
{
stack: main{fn (0 = Int@3, 1 = Int@4) -> ()<-1> :: match (t) {...}<0> :: return x;<-1>} :: top{}
heap: fun<main>, Int, Int, Int, Int, fn (0 = Int@3, 1 = Int@4) -> (), 1, Int, Int, Int, Int, !!fn (0 = Int@9, 1 = Int@10) -> (),
env: x: 1, t: fn (0 = Int@3, 1 = Int@4) -> (), main: fun<main>,
}
--- handle value fn (0 = Int@3, 1 = Int@4) -> () with match (t) {...}<1>(fn (0 = Int@3, 1 = Int@4) -> (),) --->
{
stack: main{fn (0 = Type: a, 1 = Type: b) -> ()<-1> :: match (t) {...}<1>(fn (0 = Int@3, 1 = Int@4) -> (),) :: return x;<-1>} :: top{}
heap: fun<main>, Int, Int, Int, Int, fn (0 = Int@3, 1 = Int@4) -> (), 1, Int, Int, Int, Int, !!fn (0 = Int@9, 1 = Int@10) -> (),
env: x: 1, t: fn (0 = Int@3, 1 = Int@4) -> (), main: fun<main>,
}
--- step exp fn (0 = Type: a, 1 = Type: b) -> () --->
{
stack: main{(0 = Type: a, 1 = Type: b)<-1> :: fn (0 = Type: a, 1 = Type: b) -> ()<0> :: match (t) {...}<1>(fn (0 = Int@3, 1 = Int@4) -> (),) :: return x;<-1>} :: top{}
heap: fun<main>, Int, Int, Int, Int, fn (0 = Int@3, 1 = Int@4) -> (), 1, Int, Int, Int, Int, !!fn (0 = Int@9, 1 = Int@10) -> (),
env: x: 1, t: fn (0 = Int@3, 1 = Int@4) -> (), main: fun<main>,
}
--- step exp (0 = Type: a, 1 = Type: b) --->
{
stack: main{Type: a<-1> :: (0 = Type: a, 1 = Type: b)<0> :: fn (0 = Type: a, 1 = Type: b) -> ()<0> :: match (t) {...}<1>(fn (0 = Int@3, 1 = Int@4) -> (),) :: return x;<-1>} :: top{}
heap: fun<main>, Int, Int, Int, Int, fn (0 = Int@3, 1 = Int@4) -> (), 1, Int, Int, Int, Int, !!fn (0 = Int@9, 1 = Int@10) -> (),
env: x: 1, t: fn (0 = Int@3, 1 = Int@4) -> (), main: fun<main>,
}
--- step exp Type: a --->
{
stack: main{Type<-1> :: Type: a<0> :: (0 = Type: a, 1 = Type: b)<0> :: fn (0 = Type: a, 1 = Type: b) -> ()<0> :: match (t) {...}<1>(fn (0 = Int@3, 1 = Int@4) -> (),) :: return x;<-1>} :: top{}
heap: fun<main>, Int, Int, Int, Int, fn (0 = Int@3, 1 = Int@4) -> (), 1, Int, Int, Int, Int, !!fn (0 = Int@9, 1 = Int@10) -> (),
env: x: 1, t: fn (0 = Int@3, 1 = Int@4) -> (), main: fun<main>,
}
--- step exp Type --->
{
stack: main{Type<-1> :: Type: a<0> :: (0 = Type: a, 1 = Type: b)<0> :: fn (0 = Type: a, 1 = Type: b) -> ()<0> :: match (t) {...}<1>(fn (0 = Int@3, 1 = Int@4) -> (),) :: return x;<-1>} :: top{}
heap: fun<main>, Int, Int, Int, Int, fn (0 = Int@3, 1 = Int@4) -> (), 1, Int, Int, Int, Int, !!fn (0 = Int@9, 1 = Int@10) -> (),
env: x: 1, t: fn (0 = Int@3, 1 = Int@4) -> (), main: fun<main>,
}
--- handle value Type with Type: a<1>(Type,) --->
{
stack: main{Type: a<-1> :: (0 = Type: a, 1 = Type: b)<0> :: fn (0 = Type: a, 1 = Type: b) -> ()<0> :: match (t) {...}<1>(fn (0 = Int@3, 1 = Int@4) -> (),) :: return x;<-1>} :: top{}
heap: fun<main>, Int, Int, Int, Int, fn (0 = Int@3, 1 = Int@4) -> (), 1, Int, Int, Int, Int, !!fn (0 = Int@9, 1 = Int@10) -> (),
env: x: 1, t: fn (0 = Int@3, 1 = Int@4) -> (), main: fun<main>,
}
--- handle value Type: a with (0 = Type: a, 1 = Type: b)<1>(Type: a,) --->
{
stack: main{Type: b<-1> :: (0 = Type: a, 1 = Type: b)<1>(Type: a,) :: fn (0 = Type: a, 1 = Type: b) -> ()<0> :: match (t) {...}<1>(fn (0 = Int@3, 1 = Int@4) -> (),) :: return x;<-1>} :: top{}
heap: fun<main>, Int, Int, Int, Int, fn (0 = Int@3, 1 = Int@4) -> (), 1, Int, Int, Int, Int, !!fn (0 = Int@9, 1 = Int@10) -> (),
env: x: 1, t: fn (0 = Int@3, 1 = Int@4) -> (), main: fun<main>,
}
--- step exp Type: b --->
{
stack: main{Type<-1> :: Type: b<0> :: (0 = Type: a, 1 = Type: b)<1>(Type: a,) :: fn (0 = Type: a, 1 = Type: b) -> ()<0> :: match (t) {...}<1>(fn (0 = Int@3, 1 = Int@4) -> (),) :: return x;<-1>} :: top{}
heap: fun<main>, Int, Int, Int, Int, fn (0 = Int@3, 1 = Int@4) -> (), 1, Int, Int, Int, Int, !!fn (0 = Int@9, 1 = Int@10) -> (),
env: x: 1, t: fn (0 = Int@3, 1 = Int@4) -> (), main: fun<main>,
}
--- step exp Type --->
{
stack: main{Type<-1> :: Type: b<0> :: (0 = Type: a, 1 = Type: b)<1>(Type: a,) :: fn (0 = Type: a, 1 = Type: b) -> ()<0> :: match (t) {...}<1>(fn (0 = Int@3, 1 = Int@4) -> (),) :: return x;<-1>} :: top{}
heap: fun<main>, Int, Int, Int, Int, fn (0 = Int@3, 1 = Int@4) -> (), 1, Int, Int, Int, Int, !!fn (0 = Int@9, 1 = Int@10) -> (),
env: x: 1, t: fn (0 = Int@3, 1 = Int@4) -> (), main: fun<main>,
}
--- handle value Type with Type: b<1>(Type,) --->
{
stack: main{Type: b<-1> :: (0 = Type: a, 1 = Type: b)<1>(Type: a,) :: fn (0 = Type: a, 1 = Type: b) -> ()<0> :: match (t) {...}<1>(fn (0 = Int@3, 1 = Int@4) -> (),) :: return x;<-1>} :: top{}
heap: fun<main>, Int, Int, Int, Int, fn (0 = Int@3, 1 = Int@4) -> (), 1, Int, Int, Int, Int, !!fn (0 = Int@9, 1 = Int@10) -> (),
env: x: 1, t: fn (0 = Int@3, 1 = Int@4) -> (), main: fun<main>,
}
--- handle value Type: b with (0 = Type: a, 1 = Type: b)<2>(Type: a,Type: b,) --->
{
stack: main{(0 = Type: a@12, 1 = Type: b@13)<-1> :: fn (0 = Type: a, 1 = Type: b) -> ()<0> :: match (t) {...}<1>(fn (0 = Int@3, 1 = Int@4) -> (),) :: return x;<-1>} :: top{}
heap: fun<main>, Int, Int, Int, Int, fn (0 = Int@3, 1 = Int@4) -> (), 1, Int, Int, Int, Int, !!fn (0 = Int@9, 1 = Int@10) -> (), Type: a, Type: b,
env: x: 1, t: fn (0 = Int@3, 1 = Int@4) -> (), main: fun<main>,
}
--- handle value (0 = Type: a@12, 1 = Type: b@13) with fn (0 = Type: a, 1 = Type: b) -> ()<1>((0 = Type: a@12, 1 = Type: b@13),) --->
{
stack: main{()<-1> :: fn (0 = Type: a, 1 = Type: b) -> ()<1>((0 = Type: a@12, 1 = Type: b@13),) :: match (t) {...}<1>(fn (0 = Int@3, 1 = Int@4) -> (),) :: return x;<-1>} :: top{}
heap: fun<main>, Int, Int, Int, Int, fn (0 = Int@3, 1 = Int@4) -> (), 1, Int, Int, Int, Int, !!fn (0 = Int@9, 1 = Int@10) -> (), Type: a, Type: b,
env: x: 1, t: fn (0 = Int@3, 1 = Int@4) -> (), main: fun<main>,
}
--- step exp () --->
{
stack: main{()<-1> :: fn (0 = Type: a, 1 = Type: b) -> ()<1>((0 = Type: a@12, 1 = Type: b@13),) :: match (t) {...}<1>(fn (0 = Int@3, 1 = Int@4) -> (),) :: return x;<-1>} :: top{}
heap: fun<main>, Int, Int, Int, Int, fn (0 = Int@3, 1 = Int@4) -> (), 1, Int, Int, Int, Int, !!fn (0 = Int@9, 1 = Int@10) -> (), Type: a, Type: b,
env: x: 1, t: fn (0 = Int@3, 1 = Int@4) -> (), main: fun<main>,
}
--- handle value () with fn (0 = Type: a, 1 = Type: b) -> ()<2>((0 = Type: a@12, 1 = Type: b@13),(),) --->
{
stack: main{fn (0 = Type: a@12, 1 = Type: b@13) -> ()<-1> :: match (t) {...}<1>(fn (0 = Int@3, 1 = Int@4) -> (),) :: return x;<-1>} :: top{}
heap: fun<main>, Int, Int, Int, Int, fn (0 = Int@3, 1 = Int@4) -> (), 1, Int, Int, Int, Int, !!fn (0 = Int@9, 1 = Int@10) -> (), Type: a, Type: b,
env: x: 1, t: fn (0 = Int@3, 1 = Int@4) -> (), main: fun<main>,
}
--- handle value fn (0 = Type: a@12, 1 = Type: b@13) -> () with match (t) {...}<2>(fn (0 = Int@3, 1 = Int@4) -> (),fn (0 = Type: a@12, 1 = Type: b@13) -> (),) --->
pattern_match(fn (0 = Type: a@12, 1 = Type: b@13) -> (), fn (0 = Int@3, 1 = Int@4) -> ())
pattern_match((0 = Type: a@12, 1 = Type: b@13), (0 = Int@3, 1 = Int@4))
pattern_match(Type: a, Int)
pattern_match(Type: b, Int)
pattern_match((), ())
{
stack: main{x = (x - 1);<-1> :: {
...
}
<0> :: return x;<-1>} :: top{}
heap: fun<main>, Int, Int, Int, Int, fn (0 = Int@3, 1 = Int@4) -> (), 1, Int, Int, Int, Int, !!fn (0 = Int@9, 1 = Int@10) -> (), Type: a, Type: b, Int, Int,
env: b: Int, a: Int, x: 1, t: fn (0 = Int@3, 1 = Int@4) -> (), main: fun<main>,
}
--- step stmt x = (x - 1); --->
{
stack: main{x<-1> :: x = (x - 1);<0> :: {
...
}
<0> :: return x;<-1>} :: top{}
heap: fun<main>, Int, Int, Int, Int, fn (0 = Int@3, 1 = Int@4) -> (), 1, Int, Int, Int, Int, !!fn (0 = Int@9, 1 = Int@10) -> (), Type: a, Type: b, Int, Int,
env: b: Int, a: Int, x: 1, t: fn (0 = Int@3, 1 = Int@4) -> (), main: fun<main>,
}
--- step lvalue x --->
{
stack: main{ptr<6><-1> :: x = (x - 1);<0> :: {
...
}
<0> :: return x;<-1>} :: top{}
heap: fun<main>, Int, Int, Int, Int, fn (0 = Int@3, 1 = Int@4) -> (), 1, Int, Int, Int, Int, !!fn (0 = Int@9, 1 = Int@10) -> (), Type: a, Type: b, Int, Int,
env: b: Int, a: Int, x: 1, t: fn (0 = Int@3, 1 = Int@4) -> (), main: fun<main>,
}
--- handle value ptr<6> with x = (x - 1);<1>(ptr<6>,) --->
{
stack: main{(x - 1)<-1> :: x = (x - 1);<1>(ptr<6>,) :: {
...
}
<0> :: return x;<-1>} :: top{}
heap: fun<main>, Int, Int, Int, Int, fn (0 = Int@3, 1 = Int@4) -> (), 1, Int, Int, Int, Int, !!fn (0 = Int@9, 1 = Int@10) -> (), Type: a, Type: b, Int, Int,
env: b: Int, a: Int, x: 1, t: fn (0 = Int@3, 1 = Int@4) -> (), main: fun<main>,
}
--- step exp (x - 1) --->
{
stack: main{x<-1> :: (x - 1)<0> :: x = (x - 1);<1>(ptr<6>,) :: {
...
}
<0> :: return x;<-1>} :: top{}
heap: fun<main>, Int, Int, Int, Int, fn (0 = Int@3, 1 = Int@4) -> (), 1, Int, Int, Int, Int, !!fn (0 = Int@9, 1 = Int@10) -> (), Type: a, Type: b, Int, Int,
env: b: Int, a: Int, x: 1, t: fn (0 = Int@3, 1 = Int@4) -> (), main: fun<main>,
}
--- step exp x --->
{
stack: main{1<-1> :: (x - 1)<0> :: x = (x - 1);<1>(ptr<6>,) :: {
...
}
<0> :: return x;<-1>} :: top{}
heap: fun<main>, Int, Int, Int, Int, fn (0 = Int@3, 1 = Int@4) -> (), 1, Int, Int, Int, Int, !!fn (0 = Int@9, 1 = Int@10) -> (), Type: a, Type: b, Int, Int,
env: b: Int, a: Int, x: 1, t: fn (0 = Int@3, 1 = Int@4) -> (), main: fun<main>,
}
--- handle value 1 with (x - 1)<1>(1,) --->
{
stack: main{1<-1> :: (x - 1)<1>(1,) :: x = (x - 1);<1>(ptr<6>,) :: {
...
}
<0> :: return x;<-1>} :: top{}
heap: fun<main>, Int, Int, Int, Int, fn (0 = Int@3, 1 = Int@4) -> (), 1, Int, Int, Int, Int, !!fn (0 = Int@9, 1 = Int@10) -> (), Type: a, Type: b, Int, Int,
env: b: Int, a: Int, x: 1, t: fn (0 = Int@3, 1 = Int@4) -> (), main: fun<main>,
}
--- step exp 1 --->
{
stack: main{1<-1> :: (x - 1)<1>(1,) :: x = (x - 1);<1>(ptr<6>,) :: {
...
}
<0> :: return x;<-1>} :: top{}
heap: fun<main>, Int, Int, Int, Int, fn (0 = Int@3, 1 = Int@4) -> (), 1, Int, Int, Int, Int, !!fn (0 = Int@9, 1 = Int@10) -> (), Type: a, Type: b, Int, Int,
env: b: Int, a: Int, x: 1, t: fn (0 = Int@3, 1 = Int@4) -> (), main: fun<main>,
}
--- handle value 1 with (x - 1)<2>(1,1,) --->
{
stack: main{0<-1> :: x = (x - 1);<1>(ptr<6>,) :: {
...
}
<0> :: return x;<-1>} :: top{}
heap: fun<main>, Int, Int, Int, Int, fn (0 = Int@3, 1 = Int@4) -> (), 1, Int, Int, Int, Int, !!fn (0 = Int@9, 1 = Int@10) -> (), Type: a, Type: b, Int, Int,
env: b: Int, a: Int, x: 1, t: fn (0 = Int@3, 1 = Int@4) -> (), main: fun<main>,
}
--- handle value 0 with x = (x - 1);<2>(ptr<6>,0,) --->
{
stack: main{{
...
}
<0> :: return x;<-1>} :: top{}
heap: fun<main>, Int, Int, Int, Int, fn (0 = Int@3, 1 = Int@4) -> (), 0, Int, Int, Int, Int, !!fn (0 = Int@9, 1 = Int@10) -> (), Type: a, Type: b, Int, Int,
env: b: Int, a: Int, x: 0, t: fn (0 = Int@3, 1 = Int@4) -> (), main: fun<main>,
}
--- step stmt {
...
}
--->
{
stack: main{return x;<-1>} :: top{}
heap: fun<main>, Int, Int, Int, Int, fn (0 = Int@3, 1 = Int@4) -> (), 0, Int, Int, Int, Int, !!fn (0 = Int@9, 1 = Int@10) -> (), Type: a, Type: b, !!Int, !!Int,
env: x: 0, t: fn (0 = Int@3, 1 = Int@4) -> (), main: fun<main>,
}
--- step stmt return x; --->
{
stack: main{x<-1> :: return x;<0>} :: top{}
heap: fun<main>, Int, Int, Int, Int, fn (0 = Int@3, 1 = Int@4) -> (), 0, Int, Int, Int, Int, !!fn (0 = Int@9, 1 = Int@10) -> (), Type: a, Type: b, !!Int, !!Int,
env: x: 0, t: fn (0 = Int@3, 1 = Int@4) -> (), main: fun<main>,
}
--- step exp x --->
{
stack: main{0<-1> :: return x;<0>} :: top{}
heap: fun<main>, Int, Int, Int, Int, fn (0 = Int@3, 1 = Int@4) -> (), 0, Int, Int, Int, Int, !!fn (0 = Int@9, 1 = Int@10) -> (), Type: a, Type: b, !!Int, !!Int,
env: x: 0, t: fn (0 = Int@3, 1 = Int@4) -> (), main: fun<main>,
}
--- handle value 0 with return x;<1>(0,) --->
{
stack: top{0<-1>}
heap: fun<main>, Int, Int, Int, Int, !!fn (0 = Int@3, 1 = Int@4) -> (), !!0, Int, Int, Int, Int, !!fn (0 = Int@9, 1 = Int@10) -> (), Type: a, Type: b, !!Int, !!Int,
env: main: fun<main>,
}
result: 0
executable_semantics/testdata/next.golden
Vendored
+123
View File
@@ -1 +1,124 @@
********** source program **********
fn main () -> Int {
var Int: x = 0;
return x;
}
********** type checking **********
--- step exp Int --->
--- step exp Int --->
--- step exp Int --->
********** type checking complete **********
fn main () -> Int {
var Int: x = 0;
return x;
}
********** starting execution **********
********** initializing globals **********
--- step exp () --->
********** calling main function **********
{
stack: top{main()<-1>}
heap: fun<main>,
env: main: fun<main>,
}
--- step exp main() --->
{
stack: top{main<-1> :: main()<0>}
heap: fun<main>,
env: main: fun<main>,
}
--- step exp main --->
{
stack: top{fun<main><-1> :: main()<0>}
heap: fun<main>,
env: main: fun<main>,
}
--- handle value fun<main> with main()<1>(fun<main>,) --->
{
stack: top{()<-1> :: main()<1>(fun<main>,)}
heap: fun<main>,
env: main: fun<main>,
}
--- step exp () --->
{
stack: top{()<-1> :: main()<1>(fun<main>,)}
heap: fun<main>,
env: main: fun<main>,
}
--- handle value () with main()<2>(fun<main>,(),) --->
pattern_match((), ())
{
stack: main{var Int: x = 0; ... <-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- step stmt var Int: x = 0; ... --->
{
stack: main{var Int: x = 0;<-1> :: return x;<-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- step stmt var Int: x = 0; --->
{
stack: main{0<-1> :: var Int: x = 0;<0> :: return x;<-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- step exp 0 --->
{
stack: main{0<-1> :: var Int: x = 0;<0> :: return x;<-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- handle value 0 with var Int: x = 0;<1>(0,) --->
{
stack: main{Int: x<-1> :: var Int: x = 0;<1>(0,) :: return x;<-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- step exp Int: x --->
{
stack: main{Int<-1> :: Int: x<0> :: var Int: x = 0;<1>(0,) :: return x;<-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- step exp Int --->
{
stack: main{Int<-1> :: Int: x<0> :: var Int: x = 0;<1>(0,) :: return x;<-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- handle value Int with Int: x<1>(Int,) --->
{
stack: main{Int: x<-1> :: var Int: x = 0;<1>(0,) :: return x;<-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- handle value Int: x with var Int: x = 0;<2>(0,Int: x,) --->
pattern_match(Int: x, 0)
{
stack: main{return x;<-1>} :: top{}
heap: fun<main>, 0,
env: x: 0, main: fun<main>,
}
--- step stmt return x; --->
{
stack: main{x<-1> :: return x;<0>} :: top{}
heap: fun<main>, 0,
env: x: 0, main: fun<main>,
}
--- step exp x --->
{
stack: main{0<-1> :: return x;<0>} :: top{}
heap: fun<main>, 0,
env: x: 0, main: fun<main>,
}
--- handle value 0 with return x;<1>(0,) --->
{
stack: top{0<-1>}
heap: fun<main>, !!0,
env: main: fun<main>,
}
result: 0
executable_semantics/testdata/pattern_init.golden
Vendored
+234
View File
@@ -1 +1,235 @@
********** source program **********
fn main () -> Int {
var (0 = auto: x, 1 = auto: y) = (0 = 2, 1 = 3);
return ((y - x) - 1);
}
********** type checking **********
--- step exp Int --->
--- step exp Int --->
--- step exp auto --->
--- step exp auto --->
********** type checking complete **********
fn main () -> Int {
var (0 = auto: x, 1 = auto: y) = (0 = 2, 1 = 3);
return ((y - x) - 1);
}
********** starting execution **********
********** initializing globals **********
--- step exp () --->
********** calling main function **********
{
stack: top{main()<-1>}
heap: fun<main>,
env: main: fun<main>,
}
--- step exp main() --->
{
stack: top{main<-1> :: main()<0>}
heap: fun<main>,
env: main: fun<main>,
}
--- step exp main --->
{
stack: top{fun<main><-1> :: main()<0>}
heap: fun<main>,
env: main: fun<main>,
}
--- handle value fun<main> with main()<1>(fun<main>,) --->
{
stack: top{()<-1> :: main()<1>(fun<main>,)}
heap: fun<main>,
env: main: fun<main>,
}
--- step exp () --->
{
stack: top{()<-1> :: main()<1>(fun<main>,)}
heap: fun<main>,
env: main: fun<main>,
}
--- handle value () with main()<2>(fun<main>,(),) --->
pattern_match((), ())
{
stack: main{var (0 = auto: x, 1 = auto: y) = (0 = 2, 1 = 3); ... <-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- step stmt var (0 = auto: x, 1 = auto: y) = (0 = 2, 1 = 3); ... --->
{
stack: main{var (0 = auto: x, 1 = auto: y) = (0 = 2, 1 = 3);<-1> :: return ((y - x) - 1);<-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- step stmt var (0 = auto: x, 1 = auto: y) = (0 = 2, 1 = 3); --->
{
stack: main{(0 = 2, 1 = 3)<-1> :: var (0 = auto: x, 1 = auto: y) = (0 = 2, 1 = 3);<0> :: return ((y - x) - 1);<-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- step exp (0 = 2, 1 = 3) --->
{
stack: main{2<-1> :: (0 = 2, 1 = 3)<0> :: var (0 = auto: x, 1 = auto: y) = (0 = 2, 1 = 3);<0> :: return ((y - x) - 1);<-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- step exp 2 --->
{
stack: main{2<-1> :: (0 = 2, 1 = 3)<0> :: var (0 = auto: x, 1 = auto: y) = (0 = 2, 1 = 3);<0> :: return ((y - x) - 1);<-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- handle value 2 with (0 = 2, 1 = 3)<1>(2,) --->
{
stack: main{3<-1> :: (0 = 2, 1 = 3)<1>(2,) :: var (0 = auto: x, 1 = auto: y) = (0 = 2, 1 = 3);<0> :: return ((y - x) - 1);<-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- step exp 3 --->
{
stack: main{3<-1> :: (0 = 2, 1 = 3)<1>(2,) :: var (0 = auto: x, 1 = auto: y) = (0 = 2, 1 = 3);<0> :: return ((y - x) - 1);<-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- handle value 3 with (0 = 2, 1 = 3)<2>(2,3,) --->
{
stack: main{(0 = 2@1, 1 = 3@2)<-1> :: var (0 = auto: x, 1 = auto: y) = (0 = 2, 1 = 3);<0> :: return ((y - x) - 1);<-1>} :: top{}
heap: fun<main>, 2, 3,
env: main: fun<main>,
}
--- handle value (0 = 2@1, 1 = 3@2) with var (0 = auto: x, 1 = auto: y) = (0 = 2, 1 = 3);<1>((0 = 2@1, 1 = 3@2),) --->
{
stack: main{(0 = auto: x, 1 = auto: y)<-1> :: var (0 = auto: x, 1 = auto: y) = (0 = 2, 1 = 3);<1>((0 = 2@1, 1 = 3@2),) :: return ((y - x) - 1);<-1>} :: top{}
heap: fun<main>, 2, 3,
env: main: fun<main>,
}
--- step exp (0 = auto: x, 1 = auto: y) --->
{
stack: main{auto: x<-1> :: (0 = auto: x, 1 = auto: y)<0> :: var (0 = auto: x, 1 = auto: y) = (0 = 2, 1 = 3);<1>((0 = 2@1, 1 = 3@2),) :: return ((y - x) - 1);<-1>} :: top{}
heap: fun<main>, 2, 3,
env: main: fun<main>,
}
--- step exp auto: x --->
{
stack: main{auto<-1> :: auto: x<0> :: (0 = auto: x, 1 = auto: y)<0> :: var (0 = auto: x, 1 = auto: y) = (0 = 2, 1 = 3);<1>((0 = 2@1, 1 = 3@2),) :: return ((y - x) - 1);<-1>} :: top{}
heap: fun<main>, 2, 3,
env: main: fun<main>,
}
--- step exp auto --->
{
stack: main{auto<-1> :: auto: x<0> :: (0 = auto: x, 1 = auto: y)<0> :: var (0 = auto: x, 1 = auto: y) = (0 = 2, 1 = 3);<1>((0 = 2@1, 1 = 3@2),) :: return ((y - x) - 1);<-1>} :: top{}
heap: fun<main>, 2, 3,
env: main: fun<main>,
}
--- handle value auto with auto: x<1>(auto,) --->
{
stack: main{auto: x<-1> :: (0 = auto: x, 1 = auto: y)<0> :: var (0 = auto: x, 1 = auto: y) = (0 = 2, 1 = 3);<1>((0 = 2@1, 1 = 3@2),) :: return ((y - x) - 1);<-1>} :: top{}
heap: fun<main>, 2, 3,
env: main: fun<main>,
}
--- handle value auto: x with (0 = auto: x, 1 = auto: y)<1>(auto: x,) --->
{
stack: main{auto: y<-1> :: (0 = auto: x, 1 = auto: y)<1>(auto: x,) :: var (0 = auto: x, 1 = auto: y) = (0 = 2, 1 = 3);<1>((0 = 2@1, 1 = 3@2),) :: return ((y - x) - 1);<-1>} :: top{}
heap: fun<main>, 2, 3,
env: main: fun<main>,
}
--- step exp auto: y --->
{
stack: main{auto<-1> :: auto: y<0> :: (0 = auto: x, 1 = auto: y)<1>(auto: x,) :: var (0 = auto: x, 1 = auto: y) = (0 = 2, 1 = 3);<1>((0 = 2@1, 1 = 3@2),) :: return ((y - x) - 1);<-1>} :: top{}
heap: fun<main>, 2, 3,
env: main: fun<main>,
}
--- step exp auto --->
{
stack: main{auto<-1> :: auto: y<0> :: (0 = auto: x, 1 = auto: y)<1>(auto: x,) :: var (0 = auto: x, 1 = auto: y) = (0 = 2, 1 = 3);<1>((0 = 2@1, 1 = 3@2),) :: return ((y - x) - 1);<-1>} :: top{}
heap: fun<main>, 2, 3,
env: main: fun<main>,
}
--- handle value auto with auto: y<1>(auto,) --->
{
stack: main{auto: y<-1> :: (0 = auto: x, 1 = auto: y)<1>(auto: x,) :: var (0 = auto: x, 1 = auto: y) = (0 = 2, 1 = 3);<1>((0 = 2@1, 1 = 3@2),) :: return ((y - x) - 1);<-1>} :: top{}
heap: fun<main>, 2, 3,
env: main: fun<main>,
}
--- handle value auto: y with (0 = auto: x, 1 = auto: y)<2>(auto: x,auto: y,) --->
{
stack: main{(0 = auto: x@3, 1 = auto: y@4)<-1> :: var (0 = auto: x, 1 = auto: y) = (0 = 2, 1 = 3);<1>((0 = 2@1, 1 = 3@2),) :: return ((y - x) - 1);<-1>} :: top{}
heap: fun<main>, 2, 3, auto: x, auto: y,
env: main: fun<main>,
}
--- handle value (0 = auto: x@3, 1 = auto: y@4) with var (0 = auto: x, 1 = auto: y) = (0 = 2, 1 = 3);<2>((0 = 2@1, 1 = 3@2),(0 = auto: x@3, 1 = auto: y@4),) --->
pattern_match((0 = auto: x@3, 1 = auto: y@4), (0 = 2@1, 1 = 3@2))
pattern_match(auto: x, 2)
pattern_match(auto: y, 3)
{
stack: main{return ((y - x) - 1);<-1>} :: top{}
heap: fun<main>, 2, 3, auto: x, auto: y, 2, 3,
env: y: 3, x: 2, main: fun<main>,
}
--- step stmt return ((y - x) - 1); --->
{
stack: main{((y - x) - 1)<-1> :: return ((y - x) - 1);<0>} :: top{}
heap: fun<main>, 2, 3, auto: x, auto: y, 2, 3,
env: y: 3, x: 2, main: fun<main>,
}
--- step exp ((y - x) - 1) --->
{
stack: main{(y - x)<-1> :: ((y - x) - 1)<0> :: return ((y - x) - 1);<0>} :: top{}
heap: fun<main>, 2, 3, auto: x, auto: y, 2, 3,
env: y: 3, x: 2, main: fun<main>,
}
--- step exp (y - x) --->
{
stack: main{y<-1> :: (y - x)<0> :: ((y - x) - 1)<0> :: return ((y - x) - 1);<0>} :: top{}
heap: fun<main>, 2, 3, auto: x, auto: y, 2, 3,
env: y: 3, x: 2, main: fun<main>,
}
--- step exp y --->
{
stack: main{3<-1> :: (y - x)<0> :: ((y - x) - 1)<0> :: return ((y - x) - 1);<0>} :: top{}
heap: fun<main>, 2, 3, auto: x, auto: y, 2, 3,
env: y: 3, x: 2, main: fun<main>,
}
--- handle value 3 with (y - x)<1>(3,) --->
{
stack: main{x<-1> :: (y - x)<1>(3,) :: ((y - x) - 1)<0> :: return ((y - x) - 1);<0>} :: top{}
heap: fun<main>, 2, 3, auto: x, auto: y, 2, 3,
env: y: 3, x: 2, main: fun<main>,
}
--- step exp x --->
{
stack: main{2<-1> :: (y - x)<1>(3,) :: ((y - x) - 1)<0> :: return ((y - x) - 1);<0>} :: top{}
heap: fun<main>, 2, 3, auto: x, auto: y, 2, 3,
env: y: 3, x: 2, main: fun<main>,
}
--- handle value 2 with (y - x)<2>(3,2,) --->
{
stack: main{1<-1> :: ((y - x) - 1)<0> :: return ((y - x) - 1);<0>} :: top{}
heap: fun<main>, 2, 3, auto: x, auto: y, 2, 3,
env: y: 3, x: 2, main: fun<main>,
}
--- handle value 1 with ((y - x) - 1)<1>(1,) --->
{
stack: main{1<-1> :: ((y - x) - 1)<1>(1,) :: return ((y - x) - 1);<0>} :: top{}
heap: fun<main>, 2, 3, auto: x, auto: y, 2, 3,
env: y: 3, x: 2, main: fun<main>,
}
--- step exp 1 --->
{
stack: main{1<-1> :: ((y - x) - 1)<1>(1,) :: return ((y - x) - 1);<0>} :: top{}
heap: fun<main>, 2, 3, auto: x, auto: y, 2, 3,
env: y: 3, x: 2, main: fun<main>,
}
--- handle value 1 with ((y - x) - 1)<2>(1,1,) --->
{
stack: main{0<-1> :: return ((y - x) - 1);<0>} :: top{}
heap: fun<main>, 2, 3, auto: x, auto: y, 2, 3,
env: y: 3, x: 2, main: fun<main>,
}
--- handle value 0 with return ((y - x) - 1);<1>(0,) --->
{
stack: top{0<-1>}
heap: fun<main>, 2, 3, auto: x, auto: y, !!2, !!3,
env: main: fun<main>,
}
result: 0
executable_semantics/testdata/record1.golden
Vendored
+297
View File
@@ -1 +1,298 @@
********** source program **********
fn main () -> Int {
var (x = Int, y = Int): t2 = (y = 5, x = 2);
t2.y = 3;
return ((t2.y - t2.x) - 1);
}
********** type checking **********
--- step exp Int --->
--- step exp Int --->
--- step exp (x = Int, y = Int) --->
--- step exp Int --->
--- handle value Int with (x = Int, y = Int)<1>(Int,) --->
--- step exp Int --->
--- handle value Int with (x = Int, y = Int)<2>(Int,Int,) --->
********** type checking complete **********
fn main () -> Int {
var (x = Int, y = Int): t2 = (y = 5, x = 2);
t2.y = 3;
return ((t2.y - t2.x) - 1);
}
********** starting execution **********
********** initializing globals **********
--- step exp () --->
********** calling main function **********
{
stack: top{main()<-1>}
heap: fun<main>,
env: main: fun<main>,
}
--- step exp main() --->
{
stack: top{main<-1> :: main()<0>}
heap: fun<main>,
env: main: fun<main>,
}
--- step exp main --->
{
stack: top{fun<main><-1> :: main()<0>}
heap: fun<main>,
env: main: fun<main>,
}
--- handle value fun<main> with main()<1>(fun<main>,) --->
{
stack: top{()<-1> :: main()<1>(fun<main>,)}
heap: fun<main>,
env: main: fun<main>,
}
--- step exp () --->
{
stack: top{()<-1> :: main()<1>(fun<main>,)}
heap: fun<main>,
env: main: fun<main>,
}
--- handle value () with main()<2>(fun<main>,(),) --->
pattern_match((), ())
{
stack: main{var (x = Int, y = Int): t2 = (y = 5, x = 2); ... <-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- step stmt var (x = Int, y = Int): t2 = (y = 5, x = 2); ... --->
{
stack: main{var (x = Int, y = Int): t2 = (y = 5, x = 2);<-1> :: t2.y = 3; ... <-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- step stmt var (x = Int, y = Int): t2 = (y = 5, x = 2); --->
{
stack: main{(y = 5, x = 2)<-1> :: var (x = Int, y = Int): t2 = (y = 5, x = 2);<0> :: t2.y = 3; ... <-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- step exp (y = 5, x = 2) --->
{
stack: main{5<-1> :: (y = 5, x = 2)<0> :: var (x = Int, y = Int): t2 = (y = 5, x = 2);<0> :: t2.y = 3; ... <-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- step exp 5 --->
{
stack: main{5<-1> :: (y = 5, x = 2)<0> :: var (x = Int, y = Int): t2 = (y = 5, x = 2);<0> :: t2.y = 3; ... <-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- handle value 5 with (y = 5, x = 2)<1>(5,) --->
{
stack: main{2<-1> :: (y = 5, x = 2)<1>(5,) :: var (x = Int, y = Int): t2 = (y = 5, x = 2);<0> :: t2.y = 3; ... <-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- step exp 2 --->
{
stack: main{2<-1> :: (y = 5, x = 2)<1>(5,) :: var (x = Int, y = Int): t2 = (y = 5, x = 2);<0> :: t2.y = 3; ... <-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- handle value 2 with (y = 5, x = 2)<2>(5,2,) --->
{
stack: main{(y = 5@1, x = 2@2)<-1> :: var (x = Int, y = Int): t2 = (y = 5, x = 2);<0> :: t2.y = 3; ... <-1>} :: top{}
heap: fun<main>, 5, 2,
env: main: fun<main>,
}
--- handle value (y = 5@1, x = 2@2) with var (x = Int, y = Int): t2 = (y = 5, x = 2);<1>((y = 5@1, x = 2@2),) --->
{
stack: main{(x = Int, y = Int): t2<-1> :: var (x = Int, y = Int): t2 = (y = 5, x = 2);<1>((y = 5@1, x = 2@2),) :: t2.y = 3; ... <-1>} :: top{}
heap: fun<main>, 5, 2,
env: main: fun<main>,
}
--- step exp (x = Int, y = Int): t2 --->
{
stack: main{(x = Int, y = Int)<-1> :: (x = Int, y = Int): t2<0> :: var (x = Int, y = Int): t2 = (y = 5, x = 2);<1>((y = 5@1, x = 2@2),) :: t2.y = 3; ... <-1>} :: top{}
heap: fun<main>, 5, 2,
env: main: fun<main>,
}
--- step exp (x = Int, y = Int) --->
{
stack: main{Int<-1> :: (x = Int, y = Int)<0> :: (x = Int, y = Int): t2<0> :: var (x = Int, y = Int): t2 = (y = 5, x = 2);<1>((y = 5@1, x = 2@2),) :: t2.y = 3; ... <-1>} :: top{}
heap: fun<main>, 5, 2,
env: main: fun<main>,
}
--- step exp Int --->
{
stack: main{Int<-1> :: (x = Int, y = Int)<0> :: (x = Int, y = Int): t2<0> :: var (x = Int, y = Int): t2 = (y = 5, x = 2);<1>((y = 5@1, x = 2@2),) :: t2.y = 3; ... <-1>} :: top{}
heap: fun<main>, 5, 2,
env: main: fun<main>,
}
--- handle value Int with (x = Int, y = Int)<1>(Int,) --->
{
stack: main{Int<-1> :: (x = Int, y = Int)<1>(Int,) :: (x = Int, y = Int): t2<0> :: var (x = Int, y = Int): t2 = (y = 5, x = 2);<1>((y = 5@1, x = 2@2),) :: t2.y = 3; ... <-1>} :: top{}
heap: fun<main>, 5, 2,
env: main: fun<main>,
}
--- step exp Int --->
{
stack: main{Int<-1> :: (x = Int, y = Int)<1>(Int,) :: (x = Int, y = Int): t2<0> :: var (x = Int, y = Int): t2 = (y = 5, x = 2);<1>((y = 5@1, x = 2@2),) :: t2.y = 3; ... <-1>} :: top{}
heap: fun<main>, 5, 2,
env: main: fun<main>,
}
--- handle value Int with (x = Int, y = Int)<2>(Int,Int,) --->
{
stack: main{(x = Int@3, y = Int@4)<-1> :: (x = Int, y = Int): t2<0> :: var (x = Int, y = Int): t2 = (y = 5, x = 2);<1>((y = 5@1, x = 2@2),) :: t2.y = 3; ... <-1>} :: top{}
heap: fun<main>, 5, 2, Int, Int,
env: main: fun<main>,
}
--- handle value (x = Int@3, y = Int@4) with (x = Int, y = Int): t2<1>((x = Int@3, y = Int@4),) --->
{
stack: main{(x = Int@3, y = Int@4): t2<-1> :: var (x = Int, y = Int): t2 = (y = 5, x = 2);<1>((y = 5@1, x = 2@2),) :: t2.y = 3; ... <-1>} :: top{}
heap: fun<main>, 5, 2, Int, Int,
env: main: fun<main>,
}
--- handle value (x = Int@3, y = Int@4): t2 with var (x = Int, y = Int): t2 = (y = 5, x = 2);<2>((y = 5@1, x = 2@2),(x = Int@3, y = Int@4): t2,) --->
pattern_match((x = Int@3, y = Int@4): t2, (y = 5@1, x = 2@2))
{
stack: main{t2.y = 3; ... <-1>} :: top{}
heap: fun<main>, 5, 2, Int, Int, 5, 2, (y = 5@5, x = 2@6),
env: t2: (y = 5@5, x = 2@6), main: fun<main>,
}
--- step stmt t2.y = 3; ... --->
{
stack: main{t2.y = 3;<-1> :: return ((t2.y - t2.x) - 1);<-1>} :: top{}
heap: fun<main>, 5, 2, Int, Int, 5, 2, (y = 5@5, x = 2@6),
env: t2: (y = 5@5, x = 2@6), main: fun<main>,
}
--- step stmt t2.y = 3; --->
{
stack: main{t2.y<-1> :: t2.y = 3;<0> :: return ((t2.y - t2.x) - 1);<-1>} :: top{}
heap: fun<main>, 5, 2, Int, Int, 5, 2, (y = 5@5, x = 2@6),
env: t2: (y = 5@5, x = 2@6), main: fun<main>,
}
--- step lvalue t2.y --->
{
stack: main{t2<-1> :: t2.y<0> :: t2.y = 3;<0> :: return ((t2.y - t2.x) - 1);<-1>} :: top{}
heap: fun<main>, 5, 2, Int, Int, 5, 2, (y = 5@5, x = 2@6),
env: t2: (y = 5@5, x = 2@6), main: fun<main>,
}
--- step lvalue t2 --->
{
stack: main{ptr<7><-1> :: t2.y<0> :: t2.y = 3;<0> :: return ((t2.y - t2.x) - 1);<-1>} :: top{}
heap: fun<main>, 5, 2, Int, Int, 5, 2, (y = 5@5, x = 2@6),
env: t2: (y = 5@5, x = 2@6), main: fun<main>,
}
--- handle value ptr<7> with t2.y<1>(ptr<7>,) --->
{
stack: main{ptr<5><-1> :: t2.y = 3;<0> :: return ((t2.y - t2.x) - 1);<-1>} :: top{}
heap: fun<main>, 5, 2, Int, Int, 5, 2, (y = 5@5, x = 2@6),
env: t2: (y = 5@5, x = 2@6), main: fun<main>,
}
--- handle value ptr<5> with t2.y = 3;<1>(ptr<5>,) --->
{
stack: main{3<-1> :: t2.y = 3;<1>(ptr<5>,) :: return ((t2.y - t2.x) - 1);<-1>} :: top{}
heap: fun<main>, 5, 2, Int, Int, 5, 2, (y = 5@5, x = 2@6),
env: t2: (y = 5@5, x = 2@6), main: fun<main>,
}
--- step exp 3 --->
{
stack: main{3<-1> :: t2.y = 3;<1>(ptr<5>,) :: return ((t2.y - t2.x) - 1);<-1>} :: top{}
heap: fun<main>, 5, 2, Int, Int, 5, 2, (y = 5@5, x = 2@6),
env: t2: (y = 5@5, x = 2@6), main: fun<main>,
}
--- handle value 3 with t2.y = 3;<2>(ptr<5>,3,) --->
{
stack: main{return ((t2.y - t2.x) - 1);<-1>} :: top{}
heap: fun<main>, 5, 2, Int, Int, 3, 2, (y = 3@5, x = 2@6),
env: t2: (y = 3@5, x = 2@6), main: fun<main>,
}
--- step stmt return ((t2.y - t2.x) - 1); --->
{
stack: main{((t2.y - t2.x) - 1)<-1> :: return ((t2.y - t2.x) - 1);<0>} :: top{}
heap: fun<main>, 5, 2, Int, Int, 3, 2, (y = 3@5, x = 2@6),
env: t2: (y = 3@5, x = 2@6), main: fun<main>,
}
--- step exp ((t2.y - t2.x) - 1) --->
{
stack: main{(t2.y - t2.x)<-1> :: ((t2.y - t2.x) - 1)<0> :: return ((t2.y - t2.x) - 1);<0>} :: top{}
heap: fun<main>, 5, 2, Int, Int, 3, 2, (y = 3@5, x = 2@6),
env: t2: (y = 3@5, x = 2@6), main: fun<main>,
}
--- step exp (t2.y - t2.x) --->
{
stack: main{t2.y<-1> :: (t2.y - t2.x)<0> :: ((t2.y - t2.x) - 1)<0> :: return ((t2.y - t2.x) - 1);<0>} :: top{}
heap: fun<main>, 5, 2, Int, Int, 3, 2, (y = 3@5, x = 2@6),
env: t2: (y = 3@5, x = 2@6), main: fun<main>,
}
--- step exp t2.y --->
{
stack: main{t2<-1> :: t2.y<0> :: (t2.y - t2.x)<0> :: ((t2.y - t2.x) - 1)<0> :: return ((t2.y - t2.x) - 1);<0>} :: top{}
heap: fun<main>, 5, 2, Int, Int, 3, 2, (y = 3@5, x = 2@6),
env: t2: (y = 3@5, x = 2@6), main: fun<main>,
}
--- step lvalue t2 --->
{
stack: main{ptr<7><-1> :: t2.y<0> :: (t2.y - t2.x)<0> :: ((t2.y - t2.x) - 1)<0> :: return ((t2.y - t2.x) - 1);<0>} :: top{}
heap: fun<main>, 5, 2, Int, Int, 3, 2, (y = 3@5, x = 2@6),
env: t2: (y = 3@5, x = 2@6), main: fun<main>,
}
--- handle value ptr<7> with t2.y<1>(ptr<7>,) --->
{
stack: main{3<-1> :: (t2.y - t2.x)<0> :: ((t2.y - t2.x) - 1)<0> :: return ((t2.y - t2.x) - 1);<0>} :: top{}
heap: fun<main>, 5, 2, Int, Int, 3, 2, (y = 3@5, x = 2@6),
env: t2: (y = 3@5, x = 2@6), main: fun<main>,
}
--- handle value 3 with (t2.y - t2.x)<1>(3,) --->
{
stack: main{t2.x<-1> :: (t2.y - t2.x)<1>(3,) :: ((t2.y - t2.x) - 1)<0> :: return ((t2.y - t2.x) - 1);<0>} :: top{}
heap: fun<main>, 5, 2, Int, Int, 3, 2, (y = 3@5, x = 2@6),
env: t2: (y = 3@5, x = 2@6), main: fun<main>,
}
--- step exp t2.x --->
{
stack: main{t2<-1> :: t2.x<0> :: (t2.y - t2.x)<1>(3,) :: ((t2.y - t2.x) - 1)<0> :: return ((t2.y - t2.x) - 1);<0>} :: top{}
heap: fun<main>, 5, 2, Int, Int, 3, 2, (y = 3@5, x = 2@6),
env: t2: (y = 3@5, x = 2@6), main: fun<main>,
}
--- step lvalue t2 --->
{
stack: main{ptr<7><-1> :: t2.x<0> :: (t2.y - t2.x)<1>(3,) :: ((t2.y - t2.x) - 1)<0> :: return ((t2.y - t2.x) - 1);<0>} :: top{}
heap: fun<main>, 5, 2, Int, Int, 3, 2, (y = 3@5, x = 2@6),
env: t2: (y = 3@5, x = 2@6), main: fun<main>,
}
--- handle value ptr<7> with t2.x<1>(ptr<7>,) --->
{
stack: main{2<-1> :: (t2.y - t2.x)<1>(3,) :: ((t2.y - t2.x) - 1)<0> :: return ((t2.y - t2.x) - 1);<0>} :: top{}
heap: fun<main>, 5, 2, Int, Int, 3, 2, (y = 3@5, x = 2@6),
env: t2: (y = 3@5, x = 2@6), main: fun<main>,
}
--- handle value 2 with (t2.y - t2.x)<2>(3,2,) --->
{
stack: main{1<-1> :: ((t2.y - t2.x) - 1)<0> :: return ((t2.y - t2.x) - 1);<0>} :: top{}
heap: fun<main>, 5, 2, Int, Int, 3, 2, (y = 3@5, x = 2@6),
env: t2: (y = 3@5, x = 2@6), main: fun<main>,
}
--- handle value 1 with ((t2.y - t2.x) - 1)<1>(1,) --->
{
stack: main{1<-1> :: ((t2.y - t2.x) - 1)<1>(1,) :: return ((t2.y - t2.x) - 1);<0>} :: top{}
heap: fun<main>, 5, 2, Int, Int, 3, 2, (y = 3@5, x = 2@6),
env: t2: (y = 3@5, x = 2@6), main: fun<main>,
}
--- step exp 1 --->
{
stack: main{1<-1> :: ((t2.y - t2.x) - 1)<1>(1,) :: return ((t2.y - t2.x) - 1);<0>} :: top{}
heap: fun<main>, 5, 2, Int, Int, 3, 2, (y = 3@5, x = 2@6),
env: t2: (y = 3@5, x = 2@6), main: fun<main>,
}
--- handle value 1 with ((t2.y - t2.x) - 1)<2>(1,1,) --->
{
stack: main{0<-1> :: return ((t2.y - t2.x) - 1);<0>} :: top{}
heap: fun<main>, 5, 2, Int, Int, 3, 2, (y = 3@5, x = 2@6),
env: t2: (y = 3@5, x = 2@6), main: fun<main>,
}
--- handle value 0 with return ((t2.y - t2.x) - 1);<1>(0,) --->
{
stack: top{0<-1>}
heap: fun<main>, 5, 2, Int, Int, !!3, !!2, !!(y = !!3@5, x = !!2@6),
env: main: fun<main>,
}
result: 0
executable_semantics/testdata/struct1.golden
Vendored
+255
View File
@@ -1 +1,256 @@
********** source program **********
struct Point {
var x : Int;
var y : Int;
}
fn main () -> Int {
var auto: p = Point(x = 1, y = 2);
return ((p.y - p.x) - 1);
}
********** type checking **********
--- step exp Int --->
--- step exp Int --->
--- step exp Int --->
--- step exp Int --->
--- step exp auto --->
********** type checking complete **********
struct Point {
var x : Int;
var y : Int;
}
fn main () -> Int {
var auto: p = Point(x = 1, y = 2);
return ((p.y - p.x) - 1);
}
********** starting execution **********
********** initializing globals **********
--- step exp Int --->
--- step exp Int --->
--- step exp () --->
********** calling main function **********
{
stack: top{main()<-1>}
heap: struct Point, fun<main>,
env: main: fun<main>, Point: struct Point,
}
--- step exp main() --->
{
stack: top{main<-1> :: main()<0>}
heap: struct Point, fun<main>,
env: main: fun<main>, Point: struct Point,
}
--- step exp main --->
{
stack: top{fun<main><-1> :: main()<0>}
heap: struct Point, fun<main>,
env: main: fun<main>, Point: struct Point,
}
--- handle value fun<main> with main()<1>(fun<main>,) --->
{
stack: top{()<-1> :: main()<1>(fun<main>,)}
heap: struct Point, fun<main>,
env: main: fun<main>, Point: struct Point,
}
--- step exp () --->
{
stack: top{()<-1> :: main()<1>(fun<main>,)}
heap: struct Point, fun<main>,
env: main: fun<main>, Point: struct Point,
}
--- handle value () with main()<2>(fun<main>,(),) --->
pattern_match((), ())
{
stack: main{var auto: p = Point(x = 1, y = 2); ... <-1>} :: top{}
heap: struct Point, fun<main>,
env: main: fun<main>, Point: struct Point,
}
--- step stmt var auto: p = Point(x = 1, y = 2); ... --->
{
stack: main{var auto: p = Point(x = 1, y = 2);<-1> :: return ((p.y - p.x) - 1);<-1>} :: top{}
heap: struct Point, fun<main>,
env: main: fun<main>, Point: struct Point,
}
--- step stmt var auto: p = Point(x = 1, y = 2); --->
{
stack: main{Point(x = 1, y = 2)<-1> :: var auto: p = Point(x = 1, y = 2);<0> :: return ((p.y - p.x) - 1);<-1>} :: top{}
heap: struct Point, fun<main>,
env: main: fun<main>, Point: struct Point,
}
--- step exp Point(x = 1, y = 2) --->
{
stack: main{Point<-1> :: Point(x = 1, y = 2)<0> :: var auto: p = Point(x = 1, y = 2);<0> :: return ((p.y - p.x) - 1);<-1>} :: top{}
heap: struct Point, fun<main>,
env: main: fun<main>, Point: struct Point,
}
--- step exp Point --->
{
stack: main{struct Point<-1> :: Point(x = 1, y = 2)<0> :: var auto: p = Point(x = 1, y = 2);<0> :: return ((p.y - p.x) - 1);<-1>} :: top{}
heap: struct Point, fun<main>,
env: main: fun<main>, Point: struct Point,
}
--- handle value struct Point with Point(x = 1, y = 2)<1>(struct Point,) --->
{
stack: main{(x = 1, y = 2)<-1> :: Point(x = 1, y = 2)<1>(struct Point,) :: var auto: p = Point(x = 1, y = 2);<0> :: return ((p.y - p.x) - 1);<-1>} :: top{}
heap: struct Point, fun<main>,
env: main: fun<main>, Point: struct Point,
}
--- step exp (x = 1, y = 2) --->
{
stack: main{1<-1> :: (x = 1, y = 2)<0> :: Point(x = 1, y = 2)<1>(struct Point,) :: var auto: p = Point(x = 1, y = 2);<0> :: return ((p.y - p.x) - 1);<-1>} :: top{}
heap: struct Point, fun<main>,
env: main: fun<main>, Point: struct Point,
}
--- step exp 1 --->
{
stack: main{1<-1> :: (x = 1, y = 2)<0> :: Point(x = 1, y = 2)<1>(struct Point,) :: var auto: p = Point(x = 1, y = 2);<0> :: return ((p.y - p.x) - 1);<-1>} :: top{}
heap: struct Point, fun<main>,
env: main: fun<main>, Point: struct Point,
}
--- handle value 1 with (x = 1, y = 2)<1>(1,) --->
{
stack: main{2<-1> :: (x = 1, y = 2)<1>(1,) :: Point(x = 1, y = 2)<1>(struct Point,) :: var auto: p = Point(x = 1, y = 2);<0> :: return ((p.y - p.x) - 1);<-1>} :: top{}
heap: struct Point, fun<main>,
env: main: fun<main>, Point: struct Point,
}
--- step exp 2 --->
{
stack: main{2<-1> :: (x = 1, y = 2)<1>(1,) :: Point(x = 1, y = 2)<1>(struct Point,) :: var auto: p = Point(x = 1, y = 2);<0> :: return ((p.y - p.x) - 1);<-1>} :: top{}
heap: struct Point, fun<main>,
env: main: fun<main>, Point: struct Point,
}
--- handle value 2 with (x = 1, y = 2)<2>(1,2,) --->
{
stack: main{(x = 1@2, y = 2@3)<-1> :: Point(x = 1, y = 2)<1>(struct Point,) :: var auto: p = Point(x = 1, y = 2);<0> :: return ((p.y - p.x) - 1);<-1>} :: top{}
heap: struct Point, fun<main>, 1, 2,
env: main: fun<main>, Point: struct Point,
}
--- handle value (x = 1@2, y = 2@3) with Point(x = 1, y = 2)<2>(struct Point,(x = 1@2, y = 2@3),) --->
{
stack: main{Point(x = 1@4, y = 2@5)<-1> :: var auto: p = Point(x = 1, y = 2);<0> :: return ((p.y - p.x) - 1);<-1>} :: top{}
heap: struct Point, fun<main>, 1, 2, 1, 2,
env: main: fun<main>, Point: struct Point,
}
--- handle value Point(x = 1@4, y = 2@5) with var auto: p = Point(x = 1, y = 2);<1>(Point(x = 1@4, y = 2@5),) --->
{
stack: main{auto: p<-1> :: var auto: p = Point(x = 1, y = 2);<1>(Point(x = 1@4, y = 2@5),) :: return ((p.y - p.x) - 1);<-1>} :: top{}
heap: struct Point, fun<main>, 1, 2, 1, 2,
env: main: fun<main>, Point: struct Point,
}
--- step exp auto: p --->
{
stack: main{auto<-1> :: auto: p<0> :: var auto: p = Point(x = 1, y = 2);<1>(Point(x = 1@4, y = 2@5),) :: return ((p.y - p.x) - 1);<-1>} :: top{}
heap: struct Point, fun<main>, 1, 2, 1, 2,
env: main: fun<main>, Point: struct Point,
}
--- step exp auto --->
{
stack: main{auto<-1> :: auto: p<0> :: var auto: p = Point(x = 1, y = 2);<1>(Point(x = 1@4, y = 2@5),) :: return ((p.y - p.x) - 1);<-1>} :: top{}
heap: struct Point, fun<main>, 1, 2, 1, 2,
env: main: fun<main>, Point: struct Point,
}
--- handle value auto with auto: p<1>(auto,) --->
{
stack: main{auto: p<-1> :: var auto: p = Point(x = 1, y = 2);<1>(Point(x = 1@4, y = 2@5),) :: return ((p.y - p.x) - 1);<-1>} :: top{}
heap: struct Point, fun<main>, 1, 2, 1, 2,
env: main: fun<main>, Point: struct Point,
}
--- handle value auto: p with var auto: p = Point(x = 1, y = 2);<2>(Point(x = 1@4, y = 2@5),auto: p,) --->
pattern_match(auto: p, Point(x = 1@4, y = 2@5))
{
stack: main{return ((p.y - p.x) - 1);<-1>} :: top{}
heap: struct Point, fun<main>, 1, 2, 1, 2, 1, 2, Point(x = 1@6, y = 2@7),
env: p: Point(x = 1@6, y = 2@7), main: fun<main>, Point: struct Point,
}
--- step stmt return ((p.y - p.x) - 1); --->
{
stack: main{((p.y - p.x) - 1)<-1> :: return ((p.y - p.x) - 1);<0>} :: top{}
heap: struct Point, fun<main>, 1, 2, 1, 2, 1, 2, Point(x = 1@6, y = 2@7),
env: p: Point(x = 1@6, y = 2@7), main: fun<main>, Point: struct Point,
}
--- step exp ((p.y - p.x) - 1) --->
{
stack: main{(p.y - p.x)<-1> :: ((p.y - p.x) - 1)<0> :: return ((p.y - p.x) - 1);<0>} :: top{}
heap: struct Point, fun<main>, 1, 2, 1, 2, 1, 2, Point(x = 1@6, y = 2@7),
env: p: Point(x = 1@6, y = 2@7), main: fun<main>, Point: struct Point,
}
--- step exp (p.y - p.x) --->
{
stack: main{p.y<-1> :: (p.y - p.x)<0> :: ((p.y - p.x) - 1)<0> :: return ((p.y - p.x) - 1);<0>} :: top{}
heap: struct Point, fun<main>, 1, 2, 1, 2, 1, 2, Point(x = 1@6, y = 2@7),
env: p: Point(x = 1@6, y = 2@7), main: fun<main>, Point: struct Point,
}
--- step exp p.y --->
{
stack: main{p<-1> :: p.y<0> :: (p.y - p.x)<0> :: ((p.y - p.x) - 1)<0> :: return ((p.y - p.x) - 1);<0>} :: top{}
heap: struct Point, fun<main>, 1, 2, 1, 2, 1, 2, Point(x = 1@6, y = 2@7),
env: p: Point(x = 1@6, y = 2@7), main: fun<main>, Point: struct Point,
}
--- step lvalue p --->
{
stack: main{ptr<8><-1> :: p.y<0> :: (p.y - p.x)<0> :: ((p.y - p.x) - 1)<0> :: return ((p.y - p.x) - 1);<0>} :: top{}
heap: struct Point, fun<main>, 1, 2, 1, 2, 1, 2, Point(x = 1@6, y = 2@7),
env: p: Point(x = 1@6, y = 2@7), main: fun<main>, Point: struct Point,
}
--- handle value ptr<8> with p.y<1>(ptr<8>,) --->
{
stack: main{2<-1> :: (p.y - p.x)<0> :: ((p.y - p.x) - 1)<0> :: return ((p.y - p.x) - 1);<0>} :: top{}
heap: struct Point, fun<main>, 1, 2, 1, 2, 1, 2, Point(x = 1@6, y = 2@7),
env: p: Point(x = 1@6, y = 2@7), main: fun<main>, Point: struct Point,
}
--- handle value 2 with (p.y - p.x)<1>(2,) --->
{
stack: main{p.x<-1> :: (p.y - p.x)<1>(2,) :: ((p.y - p.x) - 1)<0> :: return ((p.y - p.x) - 1);<0>} :: top{}
heap: struct Point, fun<main>, 1, 2, 1, 2, 1, 2, Point(x = 1@6, y = 2@7),
env: p: Point(x = 1@6, y = 2@7), main: fun<main>, Point: struct Point,
}
--- step exp p.x --->
{
stack: main{p<-1> :: p.x<0> :: (p.y - p.x)<1>(2,) :: ((p.y - p.x) - 1)<0> :: return ((p.y - p.x) - 1);<0>} :: top{}
heap: struct Point, fun<main>, 1, 2, 1, 2, 1, 2, Point(x = 1@6, y = 2@7),
env: p: Point(x = 1@6, y = 2@7), main: fun<main>, Point: struct Point,
}
--- step lvalue p --->
{
stack: main{ptr<8><-1> :: p.x<0> :: (p.y - p.x)<1>(2,) :: ((p.y - p.x) - 1)<0> :: return ((p.y - p.x) - 1);<0>} :: top{}
heap: struct Point, fun<main>, 1, 2, 1, 2, 1, 2, Point(x = 1@6, y = 2@7),
env: p: Point(x = 1@6, y = 2@7), main: fun<main>, Point: struct Point,
}
--- handle value ptr<8> with p.x<1>(ptr<8>,) --->
{
stack: main{1<-1> :: (p.y - p.x)<1>(2,) :: ((p.y - p.x) - 1)<0> :: return ((p.y - p.x) - 1);<0>} :: top{}
heap: struct Point, fun<main>, 1, 2, 1, 2, 1, 2, Point(x = 1@6, y = 2@7),
env: p: Point(x = 1@6, y = 2@7), main: fun<main>, Point: struct Point,
}
--- handle value 1 with (p.y - p.x)<2>(2,1,) --->
{
stack: main{1<-1> :: ((p.y - p.x) - 1)<0> :: return ((p.y - p.x) - 1);<0>} :: top{}
heap: struct Point, fun<main>, 1, 2, 1, 2, 1, 2, Point(x = 1@6, y = 2@7),
env: p: Point(x = 1@6, y = 2@7), main: fun<main>, Point: struct Point,
}
--- handle value 1 with ((p.y - p.x) - 1)<1>(1,) --->
{
stack: main{1<-1> :: ((p.y - p.x) - 1)<1>(1,) :: return ((p.y - p.x) - 1);<0>} :: top{}
heap: struct Point, fun<main>, 1, 2, 1, 2, 1, 2, Point(x = 1@6, y = 2@7),
env: p: Point(x = 1@6, y = 2@7), main: fun<main>, Point: struct Point,
}
--- step exp 1 --->
{
stack: main{1<-1> :: ((p.y - p.x) - 1)<1>(1,) :: return ((p.y - p.x) - 1);<0>} :: top{}
heap: struct Point, fun<main>, 1, 2, 1, 2, 1, 2, Point(x = 1@6, y = 2@7),
env: p: Point(x = 1@6, y = 2@7), main: fun<main>, Point: struct Point,
}
--- handle value 1 with ((p.y - p.x) - 1)<2>(1,1,) --->
{
stack: main{0<-1> :: return ((p.y - p.x) - 1);<0>} :: top{}
heap: struct Point, fun<main>, 1, 2, 1, 2, 1, 2, Point(x = 1@6, y = 2@7),
env: p: Point(x = 1@6, y = 2@7), main: fun<main>, Point: struct Point,
}
--- handle value 0 with return ((p.y - p.x) - 1);<1>(0,) --->
{
stack: top{0<-1>}
heap: struct Point, fun<main>, 1, 2, 1, 2, !!1, !!2, !!Point!!(x = !!1@6, y = !!2@7),
env: main: fun<main>, Point: struct Point,
}
result: 0
executable_semantics/testdata/struct2.golden
Vendored
+321
View File
@@ -1 +1,322 @@
********** source program **********
struct Point {
var x : Int;
var y : Int;
}
fn main () -> Int {
var auto: p1 = Point(x = 1, y = 2);
var auto: p2 = p1;
p2.x = 3;
return (p1.x - 1);
}
********** type checking **********
--- step exp Int --->
--- step exp Int --->
--- step exp Int --->
--- step exp Int --->
--- step exp auto --->
--- step exp auto --->
********** type checking complete **********
struct Point {
var x : Int;
var y : Int;
}
fn main () -> Int {
var auto: p1 = Point(x = 1, y = 2);
var auto: p2 = p1;
p2.x = 3;
return (p1.x - 1);
}
********** starting execution **********
********** initializing globals **********
--- step exp Int --->
--- step exp Int --->
--- step exp () --->
********** calling main function **********
{
stack: top{main()<-1>}
heap: struct Point, fun<main>,
env: main: fun<main>, Point: struct Point,
}
--- step exp main() --->
{
stack: top{main<-1> :: main()<0>}
heap: struct Point, fun<main>,
env: main: fun<main>, Point: struct Point,
}
--- step exp main --->
{
stack: top{fun<main><-1> :: main()<0>}
heap: struct Point, fun<main>,
env: main: fun<main>, Point: struct Point,
}
--- handle value fun<main> with main()<1>(fun<main>,) --->
{
stack: top{()<-1> :: main()<1>(fun<main>,)}
heap: struct Point, fun<main>,
env: main: fun<main>, Point: struct Point,
}
--- step exp () --->
{
stack: top{()<-1> :: main()<1>(fun<main>,)}
heap: struct Point, fun<main>,
env: main: fun<main>, Point: struct Point,
}
--- handle value () with main()<2>(fun<main>,(),) --->
pattern_match((), ())
{
stack: main{var auto: p1 = Point(x = 1, y = 2); ... <-1>} :: top{}
heap: struct Point, fun<main>,
env: main: fun<main>, Point: struct Point,
}
--- step stmt var auto: p1 = Point(x = 1, y = 2); ... --->
{
stack: main{var auto: p1 = Point(x = 1, y = 2);<-1> :: var auto: p2 = p1; ... <-1>} :: top{}
heap: struct Point, fun<main>,
env: main: fun<main>, Point: struct Point,
}
--- step stmt var auto: p1 = Point(x = 1, y = 2); --->
{
stack: main{Point(x = 1, y = 2)<-1> :: var auto: p1 = Point(x = 1, y = 2);<0> :: var auto: p2 = p1; ... <-1>} :: top{}
heap: struct Point, fun<main>,
env: main: fun<main>, Point: struct Point,
}
--- step exp Point(x = 1, y = 2) --->
{
stack: main{Point<-1> :: Point(x = 1, y = 2)<0> :: var auto: p1 = Point(x = 1, y = 2);<0> :: var auto: p2 = p1; ... <-1>} :: top{}
heap: struct Point, fun<main>,
env: main: fun<main>, Point: struct Point,
}
--- step exp Point --->
{
stack: main{struct Point<-1> :: Point(x = 1, y = 2)<0> :: var auto: p1 = Point(x = 1, y = 2);<0> :: var auto: p2 = p1; ... <-1>} :: top{}
heap: struct Point, fun<main>,
env: main: fun<main>, Point: struct Point,
}
--- handle value struct Point with Point(x = 1, y = 2)<1>(struct Point,) --->
{
stack: main{(x = 1, y = 2)<-1> :: Point(x = 1, y = 2)<1>(struct Point,) :: var auto: p1 = Point(x = 1, y = 2);<0> :: var auto: p2 = p1; ... <-1>} :: top{}
heap: struct Point, fun<main>,
env: main: fun<main>, Point: struct Point,
}
--- step exp (x = 1, y = 2) --->
{
stack: main{1<-1> :: (x = 1, y = 2)<0> :: Point(x = 1, y = 2)<1>(struct Point,) :: var auto: p1 = Point(x = 1, y = 2);<0> :: var auto: p2 = p1; ... <-1>} :: top{}
heap: struct Point, fun<main>,
env: main: fun<main>, Point: struct Point,
}
--- step exp 1 --->
{
stack: main{1<-1> :: (x = 1, y = 2)<0> :: Point(x = 1, y = 2)<1>(struct Point,) :: var auto: p1 = Point(x = 1, y = 2);<0> :: var auto: p2 = p1; ... <-1>} :: top{}
heap: struct Point, fun<main>,
env: main: fun<main>, Point: struct Point,
}
--- handle value 1 with (x = 1, y = 2)<1>(1,) --->
{
stack: main{2<-1> :: (x = 1, y = 2)<1>(1,) :: Point(x = 1, y = 2)<1>(struct Point,) :: var auto: p1 = Point(x = 1, y = 2);<0> :: var auto: p2 = p1; ... <-1>} :: top{}
heap: struct Point, fun<main>,
env: main: fun<main>, Point: struct Point,
}
--- step exp 2 --->
{
stack: main{2<-1> :: (x = 1, y = 2)<1>(1,) :: Point(x = 1, y = 2)<1>(struct Point,) :: var auto: p1 = Point(x = 1, y = 2);<0> :: var auto: p2 = p1; ... <-1>} :: top{}
heap: struct Point, fun<main>,
env: main: fun<main>, Point: struct Point,
}
--- handle value 2 with (x = 1, y = 2)<2>(1,2,) --->
{
stack: main{(x = 1@2, y = 2@3)<-1> :: Point(x = 1, y = 2)<1>(struct Point,) :: var auto: p1 = Point(x = 1, y = 2);<0> :: var auto: p2 = p1; ... <-1>} :: top{}
heap: struct Point, fun<main>, 1, 2,
env: main: fun<main>, Point: struct Point,
}
--- handle value (x = 1@2, y = 2@3) with Point(x = 1, y = 2)<2>(struct Point,(x = 1@2, y = 2@3),) --->
{
stack: main{Point(x = 1@4, y = 2@5)<-1> :: var auto: p1 = Point(x = 1, y = 2);<0> :: var auto: p2 = p1; ... <-1>} :: top{}
heap: struct Point, fun<main>, 1, 2, 1, 2,
env: main: fun<main>, Point: struct Point,
}
--- handle value Point(x = 1@4, y = 2@5) with var auto: p1 = Point(x = 1, y = 2);<1>(Point(x = 1@4, y = 2@5),) --->
{
stack: main{auto: p1<-1> :: var auto: p1 = Point(x = 1, y = 2);<1>(Point(x = 1@4, y = 2@5),) :: var auto: p2 = p1; ... <-1>} :: top{}
heap: struct Point, fun<main>, 1, 2, 1, 2,
env: main: fun<main>, Point: struct Point,
}
--- step exp auto: p1 --->
{
stack: main{auto<-1> :: auto: p1<0> :: var auto: p1 = Point(x = 1, y = 2);<1>(Point(x = 1@4, y = 2@5),) :: var auto: p2 = p1; ... <-1>} :: top{}
heap: struct Point, fun<main>, 1, 2, 1, 2,
env: main: fun<main>, Point: struct Point,
}
--- step exp auto --->
{
stack: main{auto<-1> :: auto: p1<0> :: var auto: p1 = Point(x = 1, y = 2);<1>(Point(x = 1@4, y = 2@5),) :: var auto: p2 = p1; ... <-1>} :: top{}
heap: struct Point, fun<main>, 1, 2, 1, 2,
env: main: fun<main>, Point: struct Point,
}
--- handle value auto with auto: p1<1>(auto,) --->
{
stack: main{auto: p1<-1> :: var auto: p1 = Point(x = 1, y = 2);<1>(Point(x = 1@4, y = 2@5),) :: var auto: p2 = p1; ... <-1>} :: top{}
heap: struct Point, fun<main>, 1, 2, 1, 2,
env: main: fun<main>, Point: struct Point,
}
--- handle value auto: p1 with var auto: p1 = Point(x = 1, y = 2);<2>(Point(x = 1@4, y = 2@5),auto: p1,) --->
pattern_match(auto: p1, Point(x = 1@4, y = 2@5))
{
stack: main{var auto: p2 = p1; ... <-1>} :: top{}
heap: struct Point, fun<main>, 1, 2, 1, 2, 1, 2, Point(x = 1@6, y = 2@7),
env: p1: Point(x = 1@6, y = 2@7), main: fun<main>, Point: struct Point,
}
--- step stmt var auto: p2 = p1; ... --->
{
stack: main{var auto: p2 = p1;<-1> :: p2.x = 3; ... <-1>} :: top{}
heap: struct Point, fun<main>, 1, 2, 1, 2, 1, 2, Point(x = 1@6, y = 2@7),
env: p1: Point(x = 1@6, y = 2@7), main: fun<main>, Point: struct Point,
}
--- step stmt var auto: p2 = p1; --->
{
stack: main{p1<-1> :: var auto: p2 = p1;<0> :: p2.x = 3; ... <-1>} :: top{}
heap: struct Point, fun<main>, 1, 2, 1, 2, 1, 2, Point(x = 1@6, y = 2@7),
env: p1: Point(x = 1@6, y = 2@7), main: fun<main>, Point: struct Point,
}
--- step exp p1 --->
{
stack: main{Point(x = 1@6, y = 2@7)<-1> :: var auto: p2 = p1;<0> :: p2.x = 3; ... <-1>} :: top{}
heap: struct Point, fun<main>, 1, 2, 1, 2, 1, 2, Point(x = 1@6, y = 2@7),
env: p1: Point(x = 1@6, y = 2@7), main: fun<main>, Point: struct Point,
}
--- handle value Point(x = 1@6, y = 2@7) with var auto: p2 = p1;<1>(Point(x = 1@6, y = 2@7),) --->
{
stack: main{auto: p2<-1> :: var auto: p2 = p1;<1>(Point(x = 1@6, y = 2@7),) :: p2.x = 3; ... <-1>} :: top{}
heap: struct Point, fun<main>, 1, 2, 1, 2, 1, 2, Point(x = 1@6, y = 2@7),
env: p1: Point(x = 1@6, y = 2@7), main: fun<main>, Point: struct Point,
}
--- step exp auto: p2 --->
{
stack: main{auto<-1> :: auto: p2<0> :: var auto: p2 = p1;<1>(Point(x = 1@6, y = 2@7),) :: p2.x = 3; ... <-1>} :: top{}
heap: struct Point, fun<main>, 1, 2, 1, 2, 1, 2, Point(x = 1@6, y = 2@7),
env: p1: Point(x = 1@6, y = 2@7), main: fun<main>, Point: struct Point,
}
--- step exp auto --->
{
stack: main{auto<-1> :: auto: p2<0> :: var auto: p2 = p1;<1>(Point(x = 1@6, y = 2@7),) :: p2.x = 3; ... <-1>} :: top{}
heap: struct Point, fun<main>, 1, 2, 1, 2, 1, 2, Point(x = 1@6, y = 2@7),
env: p1: Point(x = 1@6, y = 2@7), main: fun<main>, Point: struct Point,
}
--- handle value auto with auto: p2<1>(auto,) --->
{
stack: main{auto: p2<-1> :: var auto: p2 = p1;<1>(Point(x = 1@6, y = 2@7),) :: p2.x = 3; ... <-1>} :: top{}
heap: struct Point, fun<main>, 1, 2, 1, 2, 1, 2, Point(x = 1@6, y = 2@7),
env: p1: Point(x = 1@6, y = 2@7), main: fun<main>, Point: struct Point,
}
--- handle value auto: p2 with var auto: p2 = p1;<2>(Point(x = 1@6, y = 2@7),auto: p2,) --->
pattern_match(auto: p2, Point(x = 1@6, y = 2@7))
{
stack: main{p2.x = 3; ... <-1>} :: top{}
heap: struct Point, fun<main>, 1, 2, 1, 2, 1, 2, Point(x = 1@6, y = 2@7), 1, 2, Point(x = 1@9, y = 2@10),
env: p2: Point(x = 1@9, y = 2@10), p1: Point(x = 1@6, y = 2@7), main: fun<main>, Point: struct Point,
}
--- step stmt p2.x = 3; ... --->
{
stack: main{p2.x = 3;<-1> :: return (p1.x - 1);<-1>} :: top{}
heap: struct Point, fun<main>, 1, 2, 1, 2, 1, 2, Point(x = 1@6, y = 2@7), 1, 2, Point(x = 1@9, y = 2@10),
env: p2: Point(x = 1@9, y = 2@10), p1: Point(x = 1@6, y = 2@7), main: fun<main>, Point: struct Point,
}
--- step stmt p2.x = 3; --->
{
stack: main{p2.x<-1> :: p2.x = 3;<0> :: return (p1.x - 1);<-1>} :: top{}
heap: struct Point, fun<main>, 1, 2, 1, 2, 1, 2, Point(x = 1@6, y = 2@7), 1, 2, Point(x = 1@9, y = 2@10),
env: p2: Point(x = 1@9, y = 2@10), p1: Point(x = 1@6, y = 2@7), main: fun<main>, Point: struct Point,
}
--- step lvalue p2.x --->
{
stack: main{p2<-1> :: p2.x<0> :: p2.x = 3;<0> :: return (p1.x - 1);<-1>} :: top{}
heap: struct Point, fun<main>, 1, 2, 1, 2, 1, 2, Point(x = 1@6, y = 2@7), 1, 2, Point(x = 1@9, y = 2@10),
env: p2: Point(x = 1@9, y = 2@10), p1: Point(x = 1@6, y = 2@7), main: fun<main>, Point: struct Point,
}
--- step lvalue p2 --->
{
stack: main{ptr<11><-1> :: p2.x<0> :: p2.x = 3;<0> :: return (p1.x - 1);<-1>} :: top{}
heap: struct Point, fun<main>, 1, 2, 1, 2, 1, 2, Point(x = 1@6, y = 2@7), 1, 2, Point(x = 1@9, y = 2@10),
env: p2: Point(x = 1@9, y = 2@10), p1: Point(x = 1@6, y = 2@7), main: fun<main>, Point: struct Point,
}
--- handle value ptr<11> with p2.x<1>(ptr<11>,) --->
{
stack: main{ptr<9><-1> :: p2.x = 3;<0> :: return (p1.x - 1);<-1>} :: top{}
heap: struct Point, fun<main>, 1, 2, 1, 2, 1, 2, Point(x = 1@6, y = 2@7), 1, 2, Point(x = 1@9, y = 2@10),
env: p2: Point(x = 1@9, y = 2@10), p1: Point(x = 1@6, y = 2@7), main: fun<main>, Point: struct Point,
}
--- handle value ptr<9> with p2.x = 3;<1>(ptr<9>,) --->
{
stack: main{3<-1> :: p2.x = 3;<1>(ptr<9>,) :: return (p1.x - 1);<-1>} :: top{}
heap: struct Point, fun<main>, 1, 2, 1, 2, 1, 2, Point(x = 1@6, y = 2@7), 1, 2, Point(x = 1@9, y = 2@10),
env: p2: Point(x = 1@9, y = 2@10), p1: Point(x = 1@6, y = 2@7), main: fun<main>, Point: struct Point,
}
--- step exp 3 --->
{
stack: main{3<-1> :: p2.x = 3;<1>(ptr<9>,) :: return (p1.x - 1);<-1>} :: top{}
heap: struct Point, fun<main>, 1, 2, 1, 2, 1, 2, Point(x = 1@6, y = 2@7), 1, 2, Point(x = 1@9, y = 2@10),
env: p2: Point(x = 1@9, y = 2@10), p1: Point(x = 1@6, y = 2@7), main: fun<main>, Point: struct Point,
}
--- handle value 3 with p2.x = 3;<2>(ptr<9>,3,) --->
{
stack: main{return (p1.x - 1);<-1>} :: top{}
heap: struct Point, fun<main>, 1, 2, 1, 2, 1, 2, Point(x = 1@6, y = 2@7), 3, 2, Point(x = 3@9, y = 2@10),
env: p2: Point(x = 3@9, y = 2@10), p1: Point(x = 1@6, y = 2@7), main: fun<main>, Point: struct Point,
}
--- step stmt return (p1.x - 1); --->
{
stack: main{(p1.x - 1)<-1> :: return (p1.x - 1);<0>} :: top{}
heap: struct Point, fun<main>, 1, 2, 1, 2, 1, 2, Point(x = 1@6, y = 2@7), 3, 2, Point(x = 3@9, y = 2@10),
env: p2: Point(x = 3@9, y = 2@10), p1: Point(x = 1@6, y = 2@7), main: fun<main>, Point: struct Point,
}
--- step exp (p1.x - 1) --->
{
stack: main{p1.x<-1> :: (p1.x - 1)<0> :: return (p1.x - 1);<0>} :: top{}
heap: struct Point, fun<main>, 1, 2, 1, 2, 1, 2, Point(x = 1@6, y = 2@7), 3, 2, Point(x = 3@9, y = 2@10),
env: p2: Point(x = 3@9, y = 2@10), p1: Point(x = 1@6, y = 2@7), main: fun<main>, Point: struct Point,
}
--- step exp p1.x --->
{
stack: main{p1<-1> :: p1.x<0> :: (p1.x - 1)<0> :: return (p1.x - 1);<0>} :: top{}
heap: struct Point, fun<main>, 1, 2, 1, 2, 1, 2, Point(x = 1@6, y = 2@7), 3, 2, Point(x = 3@9, y = 2@10),
env: p2: Point(x = 3@9, y = 2@10), p1: Point(x = 1@6, y = 2@7), main: fun<main>, Point: struct Point,
}
--- step lvalue p1 --->
{
stack: main{ptr<8><-1> :: p1.x<0> :: (p1.x - 1)<0> :: return (p1.x - 1);<0>} :: top{}
heap: struct Point, fun<main>, 1, 2, 1, 2, 1, 2, Point(x = 1@6, y = 2@7), 3, 2, Point(x = 3@9, y = 2@10),
env: p2: Point(x = 3@9, y = 2@10), p1: Point(x = 1@6, y = 2@7), main: fun<main>, Point: struct Point,
}
--- handle value ptr<8> with p1.x<1>(ptr<8>,) --->
{
stack: main{1<-1> :: (p1.x - 1)<0> :: return (p1.x - 1);<0>} :: top{}
heap: struct Point, fun<main>, 1, 2, 1, 2, 1, 2, Point(x = 1@6, y = 2@7), 3, 2, Point(x = 3@9, y = 2@10),
env: p2: Point(x = 3@9, y = 2@10), p1: Point(x = 1@6, y = 2@7), main: fun<main>, Point: struct Point,
}
--- handle value 1 with (p1.x - 1)<1>(1,) --->
{
stack: main{1<-1> :: (p1.x - 1)<1>(1,) :: return (p1.x - 1);<0>} :: top{}
heap: struct Point, fun<main>, 1, 2, 1, 2, 1, 2, Point(x = 1@6, y = 2@7), 3, 2, Point(x = 3@9, y = 2@10),
env: p2: Point(x = 3@9, y = 2@10), p1: Point(x = 1@6, y = 2@7), main: fun<main>, Point: struct Point,
}
--- step exp 1 --->
{
stack: main{1<-1> :: (p1.x - 1)<1>(1,) :: return (p1.x - 1);<0>} :: top{}
heap: struct Point, fun<main>, 1, 2, 1, 2, 1, 2, Point(x = 1@6, y = 2@7), 3, 2, Point(x = 3@9, y = 2@10),
env: p2: Point(x = 3@9, y = 2@10), p1: Point(x = 1@6, y = 2@7), main: fun<main>, Point: struct Point,
}
--- handle value 1 with (p1.x - 1)<2>(1,1,) --->
{
stack: main{0<-1> :: return (p1.x - 1);<0>} :: top{}
heap: struct Point, fun<main>, 1, 2, 1, 2, 1, 2, Point(x = 1@6, y = 2@7), 3, 2, Point(x = 3@9, y = 2@10),
env: p2: Point(x = 3@9, y = 2@10), p1: Point(x = 1@6, y = 2@7), main: fun<main>, Point: struct Point,
}
--- handle value 0 with return (p1.x - 1);<1>(0,) --->
{
stack: top{0<-1>}
heap: struct Point, fun<main>, 1, 2, 1, 2, !!1, !!2, !!Point!!(x = !!1@6, y = !!2@7), !!3, !!2, !!Point!!(x = !!3@9, y = !!2@10),
env: main: fun<main>, Point: struct Point,
}
result: 0
executable_semantics/testdata/struct3.golden
Vendored
+185
View File
@@ -1 +1,186 @@
********** source program **********
struct Point {
var x : Int;
var y : Int;
}
fn main () -> Int {
return (Point(x = 1, y = 2).x - 1);
}
********** type checking **********
--- step exp Int --->
--- step exp Int --->
--- step exp Int --->
--- step exp Int --->
********** type checking complete **********
struct Point {
var x : Int;
var y : Int;
}
fn main () -> Int {
return (Point(x = 1, y = 2).x - 1);
}
********** starting execution **********
********** initializing globals **********
--- step exp Int --->
--- step exp Int --->
--- step exp () --->
********** calling main function **********
{
stack: top{main()<-1>}
heap: struct Point, fun<main>,
env: main: fun<main>, Point: struct Point,
}
--- step exp main() --->
{
stack: top{main<-1> :: main()<0>}
heap: struct Point, fun<main>,
env: main: fun<main>, Point: struct Point,
}
--- step exp main --->
{
stack: top{fun<main><-1> :: main()<0>}
heap: struct Point, fun<main>,
env: main: fun<main>, Point: struct Point,
}
--- handle value fun<main> with main()<1>(fun<main>,) --->
{
stack: top{()<-1> :: main()<1>(fun<main>,)}
heap: struct Point, fun<main>,
env: main: fun<main>, Point: struct Point,
}
--- step exp () --->
{
stack: top{()<-1> :: main()<1>(fun<main>,)}
heap: struct Point, fun<main>,
env: main: fun<main>, Point: struct Point,
}
--- handle value () with main()<2>(fun<main>,(),) --->
pattern_match((), ())
{
stack: main{return (Point(x = 1, y = 2).x - 1);<-1>} :: top{}
heap: struct Point, fun<main>,
env: main: fun<main>, Point: struct Point,
}
--- step stmt return (Point(x = 1, y = 2).x - 1); --->
{
stack: main{(Point(x = 1, y = 2).x - 1)<-1> :: return (Point(x = 1, y = 2).x - 1);<0>} :: top{}
heap: struct Point, fun<main>,
env: main: fun<main>, Point: struct Point,
}
--- step exp (Point(x = 1, y = 2).x - 1) --->
{
stack: main{Point(x = 1, y = 2).x<-1> :: (Point(x = 1, y = 2).x - 1)<0> :: return (Point(x = 1, y = 2).x - 1);<0>} :: top{}
heap: struct Point, fun<main>,
env: main: fun<main>, Point: struct Point,
}
--- step exp Point(x = 1, y = 2).x --->
{
stack: main{Point(x = 1, y = 2)<-1> :: Point(x = 1, y = 2).x<0> :: (Point(x = 1, y = 2).x - 1)<0> :: return (Point(x = 1, y = 2).x - 1);<0>} :: top{}
heap: struct Point, fun<main>,
env: main: fun<main>, Point: struct Point,
}
--- step lvalue Point(x = 1, y = 2) --->
{
stack: main{Point(x = 1, y = 2)<-1> :: exp=>lval<-1> :: Point(x = 1, y = 2).x<0> :: (Point(x = 1, y = 2).x - 1)<0> :: return (Point(x = 1, y = 2).x - 1);<0>} :: top{}
heap: struct Point, fun<main>,
env: main: fun<main>, Point: struct Point,
}
--- step exp Point(x = 1, y = 2) --->
{
stack: main{Point<-1> :: Point(x = 1, y = 2)<0> :: exp=>lval<-1> :: Point(x = 1, y = 2).x<0> :: (Point(x = 1, y = 2).x - 1)<0> :: return (Point(x = 1, y = 2).x - 1);<0>} :: top{}
heap: struct Point, fun<main>,
env: main: fun<main>, Point: struct Point,
}
--- step exp Point --->
{
stack: main{struct Point<-1> :: Point(x = 1, y = 2)<0> :: exp=>lval<-1> :: Point(x = 1, y = 2).x<0> :: (Point(x = 1, y = 2).x - 1)<0> :: return (Point(x = 1, y = 2).x - 1);<0>} :: top{}
heap: struct Point, fun<main>,
env: main: fun<main>, Point: struct Point,
}
--- handle value struct Point with Point(x = 1, y = 2)<1>(struct Point,) --->
{
stack: main{(x = 1, y = 2)<-1> :: Point(x = 1, y = 2)<1>(struct Point,) :: exp=>lval<-1> :: Point(x = 1, y = 2).x<0> :: (Point(x = 1, y = 2).x - 1)<0> :: return (Point(x = 1, y = 2).x - 1);<0>} :: top{}
heap: struct Point, fun<main>,
env: main: fun<main>, Point: struct Point,
}
--- step exp (x = 1, y = 2) --->
{
stack: main{1<-1> :: (x = 1, y = 2)<0> :: Point(x = 1, y = 2)<1>(struct Point,) :: exp=>lval<-1> :: Point(x = 1, y = 2).x<0> :: (Point(x = 1, y = 2).x - 1)<0> :: return (Point(x = 1, y = 2).x - 1);<0>} :: top{}
heap: struct Point, fun<main>,
env: main: fun<main>, Point: struct Point,
}
--- step exp 1 --->
{
stack: main{1<-1> :: (x = 1, y = 2)<0> :: Point(x = 1, y = 2)<1>(struct Point,) :: exp=>lval<-1> :: Point(x = 1, y = 2).x<0> :: (Point(x = 1, y = 2).x - 1)<0> :: return (Point(x = 1, y = 2).x - 1);<0>} :: top{}
heap: struct Point, fun<main>,
env: main: fun<main>, Point: struct Point,
}
--- handle value 1 with (x = 1, y = 2)<1>(1,) --->
{
stack: main{2<-1> :: (x = 1, y = 2)<1>(1,) :: Point(x = 1, y = 2)<1>(struct Point,) :: exp=>lval<-1> :: Point(x = 1, y = 2).x<0> :: (Point(x = 1, y = 2).x - 1)<0> :: return (Point(x = 1, y = 2).x - 1);<0>} :: top{}
heap: struct Point, fun<main>,
env: main: fun<main>, Point: struct Point,
}
--- step exp 2 --->
{
stack: main{2<-1> :: (x = 1, y = 2)<1>(1,) :: Point(x = 1, y = 2)<1>(struct Point,) :: exp=>lval<-1> :: Point(x = 1, y = 2).x<0> :: (Point(x = 1, y = 2).x - 1)<0> :: return (Point(x = 1, y = 2).x - 1);<0>} :: top{}
heap: struct Point, fun<main>,
env: main: fun<main>, Point: struct Point,
}
--- handle value 2 with (x = 1, y = 2)<2>(1,2,) --->
{
stack: main{(x = 1@2, y = 2@3)<-1> :: Point(x = 1, y = 2)<1>(struct Point,) :: exp=>lval<-1> :: Point(x = 1, y = 2).x<0> :: (Point(x = 1, y = 2).x - 1)<0> :: return (Point(x = 1, y = 2).x - 1);<0>} :: top{}
heap: struct Point, fun<main>, 1, 2,
env: main: fun<main>, Point: struct Point,
}
--- handle value (x = 1@2, y = 2@3) with Point(x = 1, y = 2)<2>(struct Point,(x = 1@2, y = 2@3),) --->
{
stack: main{Point(x = 1@4, y = 2@5)<-1> :: exp=>lval<-1> :: Point(x = 1, y = 2).x<0> :: (Point(x = 1, y = 2).x - 1)<0> :: return (Point(x = 1, y = 2).x - 1);<0>} :: top{}
heap: struct Point, fun<main>, 1, 2, 1, 2,
env: main: fun<main>, Point: struct Point,
}
--- handle value Point(x = 1@4, y = 2@5) with exp=>lval<0>(Point(x = 1@4, y = 2@5),) --->
{
stack: main{ptr<6><-1> :: Point(x = 1, y = 2).x<0> :: (Point(x = 1, y = 2).x - 1)<0> :: delete_tmp(6)<-1> :: return (Point(x = 1, y = 2).x - 1);<0>} :: top{}
heap: struct Point, fun<main>, 1, 2, 1, 2, Point(x = 1@4, y = 2@5),
env: main: fun<main>, Point: struct Point,
}
--- handle value ptr<6> with Point(x = 1, y = 2).x<1>(ptr<6>,) --->
{
stack: main{1<-1> :: (Point(x = 1, y = 2).x - 1)<0> :: delete_tmp(6)<-1> :: return (Point(x = 1, y = 2).x - 1);<0>} :: top{}
heap: struct Point, fun<main>, 1, 2, 1, 2, Point(x = 1@4, y = 2@5),
env: main: fun<main>, Point: struct Point,
}
--- handle value 1 with (Point(x = 1, y = 2).x - 1)<1>(1,) --->
{
stack: main{1<-1> :: (Point(x = 1, y = 2).x - 1)<1>(1,) :: delete_tmp(6)<-1> :: return (Point(x = 1, y = 2).x - 1);<0>} :: top{}
heap: struct Point, fun<main>, 1, 2, 1, 2, Point(x = 1@4, y = 2@5),
env: main: fun<main>, Point: struct Point,
}
--- step exp 1 --->
{
stack: main{1<-1> :: (Point(x = 1, y = 2).x - 1)<1>(1,) :: delete_tmp(6)<-1> :: return (Point(x = 1, y = 2).x - 1);<0>} :: top{}
heap: struct Point, fun<main>, 1, 2, 1, 2, Point(x = 1@4, y = 2@5),
env: main: fun<main>, Point: struct Point,
}
--- handle value 1 with (Point(x = 1, y = 2).x - 1)<2>(1,1,) --->
{
stack: main{0<-1> :: delete_tmp(6)<-1> :: return (Point(x = 1, y = 2).x - 1);<0>} :: top{}
heap: struct Point, fun<main>, 1, 2, 1, 2, Point(x = 1@4, y = 2@5),
env: main: fun<main>, Point: struct Point,
}
--- handle value 0 with delete_tmp(6)<0>(0,) --->
{
stack: main{0<-1> :: return (Point(x = 1, y = 2).x - 1);<0>} :: top{}
heap: struct Point, fun<main>, 1, 2, !!1, !!2, !!Point!!(x = !!1@4, y = !!2@5),
env: main: fun<main>, Point: struct Point,
}
--- handle value 0 with return (Point(x = 1, y = 2).x - 1);<1>(0,) --->
{
stack: top{0<-1>}
heap: struct Point, fun<main>, 1, 2, !!1, !!2, !!Point!!(x = !!1@4, y = !!2@5),
env: main: fun<main>, Point: struct Point,
}
result: 0
executable_semantics/testdata/tuple1.golden
Vendored
+388
View File
@@ -1 +1,389 @@
********** source program **********
fn main () -> Int {
var Int: x = 1;
var (0 = Int, 1 = Int): t2 = (0 = 5, 1 = 2);
t2[0] = 3;
return ((t2[0] - t2[1]) - x);
}
********** type checking **********
--- step exp Int --->
--- step exp Int --->
--- step exp Int --->
--- step exp (0 = Int, 1 = Int) --->
--- step exp Int --->
--- handle value Int with (0 = Int, 1 = Int)<1>(Int,) --->
--- step exp Int --->
--- handle value Int with (0 = Int, 1 = Int)<2>(Int,Int,) --->
--- step exp 0 --->
--- step exp 0 --->
--- step exp 1 --->
********** type checking complete **********
fn main () -> Int {
var Int: x = 1;
var (0 = Int, 1 = Int): t2 = (0 = 5, 1 = 2);
t2[0] = 3;
return ((t2[0] - t2[1]) - x);
}
********** starting execution **********
********** initializing globals **********
--- step exp () --->
********** calling main function **********
{
stack: top{main()<-1>}
heap: fun<main>,
env: main: fun<main>,
}
--- step exp main() --->
{
stack: top{main<-1> :: main()<0>}
heap: fun<main>,
env: main: fun<main>,
}
--- step exp main --->
{
stack: top{fun<main><-1> :: main()<0>}
heap: fun<main>,
env: main: fun<main>,
}
--- handle value fun<main> with main()<1>(fun<main>,) --->
{
stack: top{()<-1> :: main()<1>(fun<main>,)}
heap: fun<main>,
env: main: fun<main>,
}
--- step exp () --->
{
stack: top{()<-1> :: main()<1>(fun<main>,)}
heap: fun<main>,
env: main: fun<main>,
}
--- handle value () with main()<2>(fun<main>,(),) --->
pattern_match((), ())
{
stack: main{var Int: x = 1; ... <-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- step stmt var Int: x = 1; ... --->
{
stack: main{var Int: x = 1;<-1> :: var (0 = Int, 1 = Int): t2 = (0 = 5, 1 = 2); ... <-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- step stmt var Int: x = 1; --->
{
stack: main{1<-1> :: var Int: x = 1;<0> :: var (0 = Int, 1 = Int): t2 = (0 = 5, 1 = 2); ... <-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- step exp 1 --->
{
stack: main{1<-1> :: var Int: x = 1;<0> :: var (0 = Int, 1 = Int): t2 = (0 = 5, 1 = 2); ... <-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- handle value 1 with var Int: x = 1;<1>(1,) --->
{
stack: main{Int: x<-1> :: var Int: x = 1;<1>(1,) :: var (0 = Int, 1 = Int): t2 = (0 = 5, 1 = 2); ... <-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- step exp Int: x --->
{
stack: main{Int<-1> :: Int: x<0> :: var Int: x = 1;<1>(1,) :: var (0 = Int, 1 = Int): t2 = (0 = 5, 1 = 2); ... <-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- step exp Int --->
{
stack: main{Int<-1> :: Int: x<0> :: var Int: x = 1;<1>(1,) :: var (0 = Int, 1 = Int): t2 = (0 = 5, 1 = 2); ... <-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- handle value Int with Int: x<1>(Int,) --->
{
stack: main{Int: x<-1> :: var Int: x = 1;<1>(1,) :: var (0 = Int, 1 = Int): t2 = (0 = 5, 1 = 2); ... <-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- handle value Int: x with var Int: x = 1;<2>(1,Int: x,) --->
pattern_match(Int: x, 1)
{
stack: main{var (0 = Int, 1 = Int): t2 = (0 = 5, 1 = 2); ... <-1>} :: top{}
heap: fun<main>, 1,
env: x: 1, main: fun<main>,
}
--- step stmt var (0 = Int, 1 = Int): t2 = (0 = 5, 1 = 2); ... --->
{
stack: main{var (0 = Int, 1 = Int): t2 = (0 = 5, 1 = 2);<-1> :: t2[0] = 3; ... <-1>} :: top{}
heap: fun<main>, 1,
env: x: 1, main: fun<main>,
}
--- step stmt var (0 = Int, 1 = Int): t2 = (0 = 5, 1 = 2); --->
{
stack: main{(0 = 5, 1 = 2)<-1> :: var (0 = Int, 1 = Int): t2 = (0 = 5, 1 = 2);<0> :: t2[0] = 3; ... <-1>} :: top{}
heap: fun<main>, 1,
env: x: 1, main: fun<main>,
}
--- step exp (0 = 5, 1 = 2) --->
{
stack: main{5<-1> :: (0 = 5, 1 = 2)<0> :: var (0 = Int, 1 = Int): t2 = (0 = 5, 1 = 2);<0> :: t2[0] = 3; ... <-1>} :: top{}
heap: fun<main>, 1,
env: x: 1, main: fun<main>,
}
--- step exp 5 --->
{
stack: main{5<-1> :: (0 = 5, 1 = 2)<0> :: var (0 = Int, 1 = Int): t2 = (0 = 5, 1 = 2);<0> :: t2[0] = 3; ... <-1>} :: top{}
heap: fun<main>, 1,
env: x: 1, main: fun<main>,
}
--- handle value 5 with (0 = 5, 1 = 2)<1>(5,) --->
{
stack: main{2<-1> :: (0 = 5, 1 = 2)<1>(5,) :: var (0 = Int, 1 = Int): t2 = (0 = 5, 1 = 2);<0> :: t2[0] = 3; ... <-1>} :: top{}
heap: fun<main>, 1,
env: x: 1, main: fun<main>,
}
--- step exp 2 --->
{
stack: main{2<-1> :: (0 = 5, 1 = 2)<1>(5,) :: var (0 = Int, 1 = Int): t2 = (0 = 5, 1 = 2);<0> :: t2[0] = 3; ... <-1>} :: top{}
heap: fun<main>, 1,
env: x: 1, main: fun<main>,
}
--- handle value 2 with (0 = 5, 1 = 2)<2>(5,2,) --->
{
stack: main{(0 = 5@2, 1 = 2@3)<-1> :: var (0 = Int, 1 = Int): t2 = (0 = 5, 1 = 2);<0> :: t2[0] = 3; ... <-1>} :: top{}
heap: fun<main>, 1, 5, 2,
env: x: 1, main: fun<main>,
}
--- handle value (0 = 5@2, 1 = 2@3) with var (0 = Int, 1 = Int): t2 = (0 = 5, 1 = 2);<1>((0 = 5@2, 1 = 2@3),) --->
{
stack: main{(0 = Int, 1 = Int): t2<-1> :: var (0 = Int, 1 = Int): t2 = (0 = 5, 1 = 2);<1>((0 = 5@2, 1 = 2@3),) :: t2[0] = 3; ... <-1>} :: top{}
heap: fun<main>, 1, 5, 2,
env: x: 1, main: fun<main>,
}
--- step exp (0 = Int, 1 = Int): t2 --->
{
stack: main{(0 = Int, 1 = Int)<-1> :: (0 = Int, 1 = Int): t2<0> :: var (0 = Int, 1 = Int): t2 = (0 = 5, 1 = 2);<1>((0 = 5@2, 1 = 2@3),) :: t2[0] = 3; ... <-1>} :: top{}
heap: fun<main>, 1, 5, 2,
env: x: 1, main: fun<main>,
}
--- step exp (0 = Int, 1 = Int) --->
{
stack: main{Int<-1> :: (0 = Int, 1 = Int)<0> :: (0 = Int, 1 = Int): t2<0> :: var (0 = Int, 1 = Int): t2 = (0 = 5, 1 = 2);<1>((0 = 5@2, 1 = 2@3),) :: t2[0] = 3; ... <-1>} :: top{}
heap: fun<main>, 1, 5, 2,
env: x: 1, main: fun<main>,
}
--- step exp Int --->
{
stack: main{Int<-1> :: (0 = Int, 1 = Int)<0> :: (0 = Int, 1 = Int): t2<0> :: var (0 = Int, 1 = Int): t2 = (0 = 5, 1 = 2);<1>((0 = 5@2, 1 = 2@3),) :: t2[0] = 3; ... <-1>} :: top{}
heap: fun<main>, 1, 5, 2,
env: x: 1, main: fun<main>,
}
--- handle value Int with (0 = Int, 1 = Int)<1>(Int,) --->
{
stack: main{Int<-1> :: (0 = Int, 1 = Int)<1>(Int,) :: (0 = Int, 1 = Int): t2<0> :: var (0 = Int, 1 = Int): t2 = (0 = 5, 1 = 2);<1>((0 = 5@2, 1 = 2@3),) :: t2[0] = 3; ... <-1>} :: top{}
heap: fun<main>, 1, 5, 2,
env: x: 1, main: fun<main>,
}
--- step exp Int --->
{
stack: main{Int<-1> :: (0 = Int, 1 = Int)<1>(Int,) :: (0 = Int, 1 = Int): t2<0> :: var (0 = Int, 1 = Int): t2 = (0 = 5, 1 = 2);<1>((0 = 5@2, 1 = 2@3),) :: t2[0] = 3; ... <-1>} :: top{}
heap: fun<main>, 1, 5, 2,
env: x: 1, main: fun<main>,
}
--- handle value Int with (0 = Int, 1 = Int)<2>(Int,Int,) --->
{
stack: main{(0 = Int@4, 1 = Int@5)<-1> :: (0 = Int, 1 = Int): t2<0> :: var (0 = Int, 1 = Int): t2 = (0 = 5, 1 = 2);<1>((0 = 5@2, 1 = 2@3),) :: t2[0] = 3; ... <-1>} :: top{}
heap: fun<main>, 1, 5, 2, Int, Int,
env: x: 1, main: fun<main>,
}
--- handle value (0 = Int@4, 1 = Int@5) with (0 = Int, 1 = Int): t2<1>((0 = Int@4, 1 = Int@5),) --->
{
stack: main{(0 = Int@4, 1 = Int@5): t2<-1> :: var (0 = Int, 1 = Int): t2 = (0 = 5, 1 = 2);<1>((0 = 5@2, 1 = 2@3),) :: t2[0] = 3; ... <-1>} :: top{}
heap: fun<main>, 1, 5, 2, Int, Int,
env: x: 1, main: fun<main>,
}
--- handle value (0 = Int@4, 1 = Int@5): t2 with var (0 = Int, 1 = Int): t2 = (0 = 5, 1 = 2);<2>((0 = 5@2, 1 = 2@3),(0 = Int@4, 1 = Int@5): t2,) --->
pattern_match((0 = Int@4, 1 = Int@5): t2, (0 = 5@2, 1 = 2@3))
{
stack: main{t2[0] = 3; ... <-1>} :: top{}
heap: fun<main>, 1, 5, 2, Int, Int, 5, 2, (0 = 5@6, 1 = 2@7),
env: t2: (0 = 5@6, 1 = 2@7), x: 1, main: fun<main>,
}
--- step stmt t2[0] = 3; ... --->
{
stack: main{t2[0] = 3;<-1> :: return ((t2[0] - t2[1]) - x);<-1>} :: top{}
heap: fun<main>, 1, 5, 2, Int, Int, 5, 2, (0 = 5@6, 1 = 2@7),
env: t2: (0 = 5@6, 1 = 2@7), x: 1, main: fun<main>,
}
--- step stmt t2[0] = 3; --->
{
stack: main{t2[0]<-1> :: t2[0] = 3;<0> :: return ((t2[0] - t2[1]) - x);<-1>} :: top{}
heap: fun<main>, 1, 5, 2, Int, Int, 5, 2, (0 = 5@6, 1 = 2@7),
env: t2: (0 = 5@6, 1 = 2@7), x: 1, main: fun<main>,
}
--- step lvalue t2[0] --->
{
stack: main{t2<-1> :: t2[0]<0> :: t2[0] = 3;<0> :: return ((t2[0] - t2[1]) - x);<-1>} :: top{}
heap: fun<main>, 1, 5, 2, Int, Int, 5, 2, (0 = 5@6, 1 = 2@7),
env: t2: (0 = 5@6, 1 = 2@7), x: 1, main: fun<main>,
}
--- step exp t2 --->
{
stack: main{(0 = 5@6, 1 = 2@7)<-1> :: t2[0]<0> :: t2[0] = 3;<0> :: return ((t2[0] - t2[1]) - x);<-1>} :: top{}
heap: fun<main>, 1, 5, 2, Int, Int, 5, 2, (0 = 5@6, 1 = 2@7),
env: t2: (0 = 5@6, 1 = 2@7), x: 1, main: fun<main>,
}
--- handle value (0 = 5@6, 1 = 2@7) with t2[0]<1>((0 = 5@6, 1 = 2@7),) --->
{
stack: main{0<-1> :: t2[0]<1>((0 = 5@6, 1 = 2@7),) :: t2[0] = 3;<0> :: return ((t2[0] - t2[1]) - x);<-1>} :: top{}
heap: fun<main>, 1, 5, 2, Int, Int, 5, 2, (0 = 5@6, 1 = 2@7),
env: t2: (0 = 5@6, 1 = 2@7), x: 1, main: fun<main>,
}
--- step exp 0 --->
{
stack: main{0<-1> :: t2[0]<1>((0 = 5@6, 1 = 2@7),) :: t2[0] = 3;<0> :: return ((t2[0] - t2[1]) - x);<-1>} :: top{}
heap: fun<main>, 1, 5, 2, Int, Int, 5, 2, (0 = 5@6, 1 = 2@7),
env: t2: (0 = 5@6, 1 = 2@7), x: 1, main: fun<main>,
}
--- handle value 0 with t2[0]<2>((0 = 5@6, 1 = 2@7),0,) --->
{
stack: main{ptr<6><-1> :: t2[0] = 3;<0> :: return ((t2[0] - t2[1]) - x);<-1>} :: top{}
heap: fun<main>, 1, 5, 2, Int, Int, 5, 2, (0 = 5@6, 1 = 2@7),
env: t2: (0 = 5@6, 1 = 2@7), x: 1, main: fun<main>,
}
--- handle value ptr<6> with t2[0] = 3;<1>(ptr<6>,) --->
{
stack: main{3<-1> :: t2[0] = 3;<1>(ptr<6>,) :: return ((t2[0] - t2[1]) - x);<-1>} :: top{}
heap: fun<main>, 1, 5, 2, Int, Int, 5, 2, (0 = 5@6, 1 = 2@7),
env: t2: (0 = 5@6, 1 = 2@7), x: 1, main: fun<main>,
}
--- step exp 3 --->
{
stack: main{3<-1> :: t2[0] = 3;<1>(ptr<6>,) :: return ((t2[0] - t2[1]) - x);<-1>} :: top{}
heap: fun<main>, 1, 5, 2, Int, Int, 5, 2, (0 = 5@6, 1 = 2@7),
env: t2: (0 = 5@6, 1 = 2@7), x: 1, main: fun<main>,
}
--- handle value 3 with t2[0] = 3;<2>(ptr<6>,3,) --->
{
stack: main{return ((t2[0] - t2[1]) - x);<-1>} :: top{}
heap: fun<main>, 1, 5, 2, Int, Int, 3, 2, (0 = 3@6, 1 = 2@7),
env: t2: (0 = 3@6, 1 = 2@7), x: 1, main: fun<main>,
}
--- step stmt return ((t2[0] - t2[1]) - x); --->
{
stack: main{((t2[0] - t2[1]) - x)<-1> :: return ((t2[0] - t2[1]) - x);<0>} :: top{}
heap: fun<main>, 1, 5, 2, Int, Int, 3, 2, (0 = 3@6, 1 = 2@7),
env: t2: (0 = 3@6, 1 = 2@7), x: 1, main: fun<main>,
}
--- step exp ((t2[0] - t2[1]) - x) --->
{
stack: main{(t2[0] - t2[1])<-1> :: ((t2[0] - t2[1]) - x)<0> :: return ((t2[0] - t2[1]) - x);<0>} :: top{}
heap: fun<main>, 1, 5, 2, Int, Int, 3, 2, (0 = 3@6, 1 = 2@7),
env: t2: (0 = 3@6, 1 = 2@7), x: 1, main: fun<main>,
}
--- step exp (t2[0] - t2[1]) --->
{
stack: main{t2[0]<-1> :: (t2[0] - t2[1])<0> :: ((t2[0] - t2[1]) - x)<0> :: return ((t2[0] - t2[1]) - x);<0>} :: top{}
heap: fun<main>, 1, 5, 2, Int, Int, 3, 2, (0 = 3@6, 1 = 2@7),
env: t2: (0 = 3@6, 1 = 2@7), x: 1, main: fun<main>,
}
--- step exp t2[0] --->
{
stack: main{t2<-1> :: t2[0]<0> :: (t2[0] - t2[1])<0> :: ((t2[0] - t2[1]) - x)<0> :: return ((t2[0] - t2[1]) - x);<0>} :: top{}
heap: fun<main>, 1, 5, 2, Int, Int, 3, 2, (0 = 3@6, 1 = 2@7),
env: t2: (0 = 3@6, 1 = 2@7), x: 1, main: fun<main>,
}
--- step exp t2 --->
{
stack: main{(0 = 3@6, 1 = 2@7)<-1> :: t2[0]<0> :: (t2[0] - t2[1])<0> :: ((t2[0] - t2[1]) - x)<0> :: return ((t2[0] - t2[1]) - x);<0>} :: top{}
heap: fun<main>, 1, 5, 2, Int, Int, 3, 2, (0 = 3@6, 1 = 2@7),
env: t2: (0 = 3@6, 1 = 2@7), x: 1, main: fun<main>,
}
--- handle value (0 = 3@6, 1 = 2@7) with t2[0]<1>((0 = 3@6, 1 = 2@7),) --->
{
stack: main{0<-1> :: t2[0]<1>((0 = 3@6, 1 = 2@7),) :: (t2[0] - t2[1])<0> :: ((t2[0] - t2[1]) - x)<0> :: return ((t2[0] - t2[1]) - x);<0>} :: top{}
heap: fun<main>, 1, 5, 2, Int, Int, 3, 2, (0 = 3@6, 1 = 2@7),
env: t2: (0 = 3@6, 1 = 2@7), x: 1, main: fun<main>,
}
--- step exp 0 --->
{
stack: main{0<-1> :: t2[0]<1>((0 = 3@6, 1 = 2@7),) :: (t2[0] - t2[1])<0> :: ((t2[0] - t2[1]) - x)<0> :: return ((t2[0] - t2[1]) - x);<0>} :: top{}
heap: fun<main>, 1, 5, 2, Int, Int, 3, 2, (0 = 3@6, 1 = 2@7),
env: t2: (0 = 3@6, 1 = 2@7), x: 1, main: fun<main>,
}
--- handle value 0 with t2[0]<2>((0 = 3@6, 1 = 2@7),0,) --->
{
stack: main{3<-1> :: (t2[0] - t2[1])<0> :: ((t2[0] - t2[1]) - x)<0> :: return ((t2[0] - t2[1]) - x);<0>} :: top{}
heap: fun<main>, 1, 5, 2, Int, Int, 3, 2, (0 = 3@6, 1 = 2@7),
env: t2: (0 = 3@6, 1 = 2@7), x: 1, main: fun<main>,
}
--- handle value 3 with (t2[0] - t2[1])<1>(3,) --->
{
stack: main{t2[1]<-1> :: (t2[0] - t2[1])<1>(3,) :: ((t2[0] - t2[1]) - x)<0> :: return ((t2[0] - t2[1]) - x);<0>} :: top{}
heap: fun<main>, 1, 5, 2, Int, Int, 3, 2, (0 = 3@6, 1 = 2@7),
env: t2: (0 = 3@6, 1 = 2@7), x: 1, main: fun<main>,
}
--- step exp t2[1] --->
{
stack: main{t2<-1> :: t2[1]<0> :: (t2[0] - t2[1])<1>(3,) :: ((t2[0] - t2[1]) - x)<0> :: return ((t2[0] - t2[1]) - x);<0>} :: top{}
heap: fun<main>, 1, 5, 2, Int, Int, 3, 2, (0 = 3@6, 1 = 2@7),
env: t2: (0 = 3@6, 1 = 2@7), x: 1, main: fun<main>,
}
--- step exp t2 --->
{
stack: main{(0 = 3@6, 1 = 2@7)<-1> :: t2[1]<0> :: (t2[0] - t2[1])<1>(3,) :: ((t2[0] - t2[1]) - x)<0> :: return ((t2[0] - t2[1]) - x);<0>} :: top{}
heap: fun<main>, 1, 5, 2, Int, Int, 3, 2, (0 = 3@6, 1 = 2@7),
env: t2: (0 = 3@6, 1 = 2@7), x: 1, main: fun<main>,
}
--- handle value (0 = 3@6, 1 = 2@7) with t2[1]<1>((0 = 3@6, 1 = 2@7),) --->
{
stack: main{1<-1> :: t2[1]<1>((0 = 3@6, 1 = 2@7),) :: (t2[0] - t2[1])<1>(3,) :: ((t2[0] - t2[1]) - x)<0> :: return ((t2[0] - t2[1]) - x);<0>} :: top{}
heap: fun<main>, 1, 5, 2, Int, Int, 3, 2, (0 = 3@6, 1 = 2@7),
env: t2: (0 = 3@6, 1 = 2@7), x: 1, main: fun<main>,
}
--- step exp 1 --->
{
stack: main{1<-1> :: t2[1]<1>((0 = 3@6, 1 = 2@7),) :: (t2[0] - t2[1])<1>(3,) :: ((t2[0] - t2[1]) - x)<0> :: return ((t2[0] - t2[1]) - x);<0>} :: top{}
heap: fun<main>, 1, 5, 2, Int, Int, 3, 2, (0 = 3@6, 1 = 2@7),
env: t2: (0 = 3@6, 1 = 2@7), x: 1, main: fun<main>,
}
--- handle value 1 with t2[1]<2>((0 = 3@6, 1 = 2@7),1,) --->
{
stack: main{2<-1> :: (t2[0] - t2[1])<1>(3,) :: ((t2[0] - t2[1]) - x)<0> :: return ((t2[0] - t2[1]) - x);<0>} :: top{}
heap: fun<main>, 1, 5, 2, Int, Int, 3, 2, (0 = 3@6, 1 = 2@7),
env: t2: (0 = 3@6, 1 = 2@7), x: 1, main: fun<main>,
}
--- handle value 2 with (t2[0] - t2[1])<2>(3,2,) --->
{
stack: main{1<-1> :: ((t2[0] - t2[1]) - x)<0> :: return ((t2[0] - t2[1]) - x);<0>} :: top{}
heap: fun<main>, 1, 5, 2, Int, Int, 3, 2, (0 = 3@6, 1 = 2@7),
env: t2: (0 = 3@6, 1 = 2@7), x: 1, main: fun<main>,
}
--- handle value 1 with ((t2[0] - t2[1]) - x)<1>(1,) --->
{
stack: main{x<-1> :: ((t2[0] - t2[1]) - x)<1>(1,) :: return ((t2[0] - t2[1]) - x);<0>} :: top{}
heap: fun<main>, 1, 5, 2, Int, Int, 3, 2, (0 = 3@6, 1 = 2@7),
env: t2: (0 = 3@6, 1 = 2@7), x: 1, main: fun<main>,
}
--- step exp x --->
{
stack: main{1<-1> :: ((t2[0] - t2[1]) - x)<1>(1,) :: return ((t2[0] - t2[1]) - x);<0>} :: top{}
heap: fun<main>, 1, 5, 2, Int, Int, 3, 2, (0 = 3@6, 1 = 2@7),
env: t2: (0 = 3@6, 1 = 2@7), x: 1, main: fun<main>,
}
--- handle value 1 with ((t2[0] - t2[1]) - x)<2>(1,1,) --->
{
stack: main{0<-1> :: return ((t2[0] - t2[1]) - x);<0>} :: top{}
heap: fun<main>, 1, 5, 2, Int, Int, 3, 2, (0 = 3@6, 1 = 2@7),
env: t2: (0 = 3@6, 1 = 2@7), x: 1, main: fun<main>,
}
--- handle value 0 with return ((t2[0] - t2[1]) - x);<1>(0,) --->
{
stack: top{0<-1>}
heap: fun<main>, !!1, 5, 2, Int, Int, !!3, !!2, !!(0 = !!3@6, 1 = !!2@7),
env: main: fun<main>,
}
result: 0
executable_semantics/testdata/tuple2.golden
Vendored
+198
View File
@@ -1 +1,199 @@
********** source program **********
fn main () -> Int {
var (0 = Int): t = (0 = 5);
return (t[0] - 5);
}
********** type checking **********
--- step exp Int --->
--- step exp Int --->
--- step exp (0 = Int) --->
--- step exp Int --->
--- handle value Int with (0 = Int)<1>(Int,) --->
--- step exp 0 --->
********** type checking complete **********
fn main () -> Int {
var (0 = Int): t = (0 = 5);
return (t[0] - 5);
}
********** starting execution **********
********** initializing globals **********
--- step exp () --->
********** calling main function **********
{
stack: top{main()<-1>}
heap: fun<main>,
env: main: fun<main>,
}
--- step exp main() --->
{
stack: top{main<-1> :: main()<0>}
heap: fun<main>,
env: main: fun<main>,
}
--- step exp main --->
{
stack: top{fun<main><-1> :: main()<0>}
heap: fun<main>,
env: main: fun<main>,
}
--- handle value fun<main> with main()<1>(fun<main>,) --->
{
stack: top{()<-1> :: main()<1>(fun<main>,)}
heap: fun<main>,
env: main: fun<main>,
}
--- step exp () --->
{
stack: top{()<-1> :: main()<1>(fun<main>,)}
heap: fun<main>,
env: main: fun<main>,
}
--- handle value () with main()<2>(fun<main>,(),) --->
pattern_match((), ())
{
stack: main{var (0 = Int): t = (0 = 5); ... <-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- step stmt var (0 = Int): t = (0 = 5); ... --->
{
stack: main{var (0 = Int): t = (0 = 5);<-1> :: return (t[0] - 5);<-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- step stmt var (0 = Int): t = (0 = 5); --->
{
stack: main{(0 = 5)<-1> :: var (0 = Int): t = (0 = 5);<0> :: return (t[0] - 5);<-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- step exp (0 = 5) --->
{
stack: main{5<-1> :: (0 = 5)<0> :: var (0 = Int): t = (0 = 5);<0> :: return (t[0] - 5);<-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- step exp 5 --->
{
stack: main{5<-1> :: (0 = 5)<0> :: var (0 = Int): t = (0 = 5);<0> :: return (t[0] - 5);<-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- handle value 5 with (0 = 5)<1>(5,) --->
{
stack: main{(0 = 5@1)<-1> :: var (0 = Int): t = (0 = 5);<0> :: return (t[0] - 5);<-1>} :: top{}
heap: fun<main>, 5,
env: main: fun<main>,
}
--- handle value (0 = 5@1) with var (0 = Int): t = (0 = 5);<1>((0 = 5@1),) --->
{
stack: main{(0 = Int): t<-1> :: var (0 = Int): t = (0 = 5);<1>((0 = 5@1),) :: return (t[0] - 5);<-1>} :: top{}
heap: fun<main>, 5,
env: main: fun<main>,
}
--- step exp (0 = Int): t --->
{
stack: main{(0 = Int)<-1> :: (0 = Int): t<0> :: var (0 = Int): t = (0 = 5);<1>((0 = 5@1),) :: return (t[0] - 5);<-1>} :: top{}
heap: fun<main>, 5,
env: main: fun<main>,
}
--- step exp (0 = Int) --->
{
stack: main{Int<-1> :: (0 = Int)<0> :: (0 = Int): t<0> :: var (0 = Int): t = (0 = 5);<1>((0 = 5@1),) :: return (t[0] - 5);<-1>} :: top{}
heap: fun<main>, 5,
env: main: fun<main>,
}
--- step exp Int --->
{
stack: main{Int<-1> :: (0 = Int)<0> :: (0 = Int): t<0> :: var (0 = Int): t = (0 = 5);<1>((0 = 5@1),) :: return (t[0] - 5);<-1>} :: top{}
heap: fun<main>, 5,
env: main: fun<main>,
}
--- handle value Int with (0 = Int)<1>(Int,) --->
{
stack: main{(0 = Int@2)<-1> :: (0 = Int): t<0> :: var (0 = Int): t = (0 = 5);<1>((0 = 5@1),) :: return (t[0] - 5);<-1>} :: top{}
heap: fun<main>, 5, Int,
env: main: fun<main>,
}
--- handle value (0 = Int@2) with (0 = Int): t<1>((0 = Int@2),) --->
{
stack: main{(0 = Int@2): t<-1> :: var (0 = Int): t = (0 = 5);<1>((0 = 5@1),) :: return (t[0] - 5);<-1>} :: top{}
heap: fun<main>, 5, Int,
env: main: fun<main>,
}
--- handle value (0 = Int@2): t with var (0 = Int): t = (0 = 5);<2>((0 = 5@1),(0 = Int@2): t,) --->
pattern_match((0 = Int@2): t, (0 = 5@1))
{
stack: main{return (t[0] - 5);<-1>} :: top{}
heap: fun<main>, 5, Int, 5, (0 = 5@3),
env: t: (0 = 5@3), main: fun<main>,
}
--- step stmt return (t[0] - 5); --->
{
stack: main{(t[0] - 5)<-1> :: return (t[0] - 5);<0>} :: top{}
heap: fun<main>, 5, Int, 5, (0 = 5@3),
env: t: (0 = 5@3), main: fun<main>,
}
--- step exp (t[0] - 5) --->
{
stack: main{t[0]<-1> :: (t[0] - 5)<0> :: return (t[0] - 5);<0>} :: top{}
heap: fun<main>, 5, Int, 5, (0 = 5@3),
env: t: (0 = 5@3), main: fun<main>,
}
--- step exp t[0] --->
{
stack: main{t<-1> :: t[0]<0> :: (t[0] - 5)<0> :: return (t[0] - 5);<0>} :: top{}
heap: fun<main>, 5, Int, 5, (0 = 5@3),
env: t: (0 = 5@3), main: fun<main>,
}
--- step exp t --->
{
stack: main{(0 = 5@3)<-1> :: t[0]<0> :: (t[0] - 5)<0> :: return (t[0] - 5);<0>} :: top{}
heap: fun<main>, 5, Int, 5, (0 = 5@3),
env: t: (0 = 5@3), main: fun<main>,
}
--- handle value (0 = 5@3) with t[0]<1>((0 = 5@3),) --->
{
stack: main{0<-1> :: t[0]<1>((0 = 5@3),) :: (t[0] - 5)<0> :: return (t[0] - 5);<0>} :: top{}
heap: fun<main>, 5, Int, 5, (0 = 5@3),
env: t: (0 = 5@3), main: fun<main>,
}
--- step exp 0 --->
{
stack: main{0<-1> :: t[0]<1>((0 = 5@3),) :: (t[0] - 5)<0> :: return (t[0] - 5);<0>} :: top{}
heap: fun<main>, 5, Int, 5, (0 = 5@3),
env: t: (0 = 5@3), main: fun<main>,
}
--- handle value 0 with t[0]<2>((0 = 5@3),0,) --->
{
stack: main{5<-1> :: (t[0] - 5)<0> :: return (t[0] - 5);<0>} :: top{}
heap: fun<main>, 5, Int, 5, (0 = 5@3),
env: t: (0 = 5@3), main: fun<main>,
}
--- handle value 5 with (t[0] - 5)<1>(5,) --->
{
stack: main{5<-1> :: (t[0] - 5)<1>(5,) :: return (t[0] - 5);<0>} :: top{}
heap: fun<main>, 5, Int, 5, (0 = 5@3),
env: t: (0 = 5@3), main: fun<main>,
}
--- step exp 5 --->
{
stack: main{5<-1> :: (t[0] - 5)<1>(5,) :: return (t[0] - 5);<0>} :: top{}
heap: fun<main>, 5, Int, 5, (0 = 5@3),
env: t: (0 = 5@3), main: fun<main>,
}
--- handle value 5 with (t[0] - 5)<2>(5,5,) --->
{
stack: main{0<-1> :: return (t[0] - 5);<0>} :: top{}
heap: fun<main>, 5, Int, 5, (0 = 5@3),
env: t: (0 = 5@3), main: fun<main>,
}
--- handle value 0 with return (t[0] - 5);<1>(0,) --->
{
stack: top{0<-1>}
heap: fun<main>, 5, Int, !!5, !!(0 = !!5@3),
env: main: fun<main>,
}
result: 0
executable_semantics/testdata/tuple_assign.golden
Vendored
+297
View File
@@ -1 +1,298 @@
********** source program **********
fn main () -> Int {
var auto: x = 0;
var auto: y = 1;
(0 = x, 1 = y) = (0 = 5, 1 = (- 5));
return (x + y);
}
********** type checking **********
--- step exp Int --->
--- step exp Int --->
--- step exp auto --->
--- step exp auto --->
********** type checking complete **********
fn main () -> Int {
var auto: x = 0;
var auto: y = 1;
(0 = x, 1 = y) = (0 = 5, 1 = (- 5));
return (x + y);
}
********** starting execution **********
********** initializing globals **********
--- step exp () --->
********** calling main function **********
{
stack: top{main()<-1>}
heap: fun<main>,
env: main: fun<main>,
}
--- step exp main() --->
{
stack: top{main<-1> :: main()<0>}
heap: fun<main>,
env: main: fun<main>,
}
--- step exp main --->
{
stack: top{fun<main><-1> :: main()<0>}
heap: fun<main>,
env: main: fun<main>,
}
--- handle value fun<main> with main()<1>(fun<main>,) --->
{
stack: top{()<-1> :: main()<1>(fun<main>,)}
heap: fun<main>,
env: main: fun<main>,
}
--- step exp () --->
{
stack: top{()<-1> :: main()<1>(fun<main>,)}
heap: fun<main>,
env: main: fun<main>,
}
--- handle value () with main()<2>(fun<main>,(),) --->
pattern_match((), ())
{
stack: main{var auto: x = 0; ... <-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- step stmt var auto: x = 0; ... --->
{
stack: main{var auto: x = 0;<-1> :: var auto: y = 1; ... <-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- step stmt var auto: x = 0; --->
{
stack: main{0<-1> :: var auto: x = 0;<0> :: var auto: y = 1; ... <-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- step exp 0 --->
{
stack: main{0<-1> :: var auto: x = 0;<0> :: var auto: y = 1; ... <-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- handle value 0 with var auto: x = 0;<1>(0,) --->
{
stack: main{auto: x<-1> :: var auto: x = 0;<1>(0,) :: var auto: y = 1; ... <-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- step exp auto: x --->
{
stack: main{auto<-1> :: auto: x<0> :: var auto: x = 0;<1>(0,) :: var auto: y = 1; ... <-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- step exp auto --->
{
stack: main{auto<-1> :: auto: x<0> :: var auto: x = 0;<1>(0,) :: var auto: y = 1; ... <-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- handle value auto with auto: x<1>(auto,) --->
{
stack: main{auto: x<-1> :: var auto: x = 0;<1>(0,) :: var auto: y = 1; ... <-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- handle value auto: x with var auto: x = 0;<2>(0,auto: x,) --->
pattern_match(auto: x, 0)
{
stack: main{var auto: y = 1; ... <-1>} :: top{}
heap: fun<main>, 0,
env: x: 0, main: fun<main>,
}
--- step stmt var auto: y = 1; ... --->
{
stack: main{var auto: y = 1;<-1> :: (0 = x, 1 = y) = (0 = 5, 1 = (- 5)); ... <-1>} :: top{}
heap: fun<main>, 0,
env: x: 0, main: fun<main>,
}
--- step stmt var auto: y = 1; --->
{
stack: main{1<-1> :: var auto: y = 1;<0> :: (0 = x, 1 = y) = (0 = 5, 1 = (- 5)); ... <-1>} :: top{}
heap: fun<main>, 0,
env: x: 0, main: fun<main>,
}
--- step exp 1 --->
{
stack: main{1<-1> :: var auto: y = 1;<0> :: (0 = x, 1 = y) = (0 = 5, 1 = (- 5)); ... <-1>} :: top{}
heap: fun<main>, 0,
env: x: 0, main: fun<main>,
}
--- handle value 1 with var auto: y = 1;<1>(1,) --->
{
stack: main{auto: y<-1> :: var auto: y = 1;<1>(1,) :: (0 = x, 1 = y) = (0 = 5, 1 = (- 5)); ... <-1>} :: top{}
heap: fun<main>, 0,
env: x: 0, main: fun<main>,
}
--- step exp auto: y --->
{
stack: main{auto<-1> :: auto: y<0> :: var auto: y = 1;<1>(1,) :: (0 = x, 1 = y) = (0 = 5, 1 = (- 5)); ... <-1>} :: top{}
heap: fun<main>, 0,
env: x: 0, main: fun<main>,
}
--- step exp auto --->
{
stack: main{auto<-1> :: auto: y<0> :: var auto: y = 1;<1>(1,) :: (0 = x, 1 = y) = (0 = 5, 1 = (- 5)); ... <-1>} :: top{}
heap: fun<main>, 0,
env: x: 0, main: fun<main>,
}
--- handle value auto with auto: y<1>(auto,) --->
{
stack: main{auto: y<-1> :: var auto: y = 1;<1>(1,) :: (0 = x, 1 = y) = (0 = 5, 1 = (- 5)); ... <-1>} :: top{}
heap: fun<main>, 0,
env: x: 0, main: fun<main>,
}
--- handle value auto: y with var auto: y = 1;<2>(1,auto: y,) --->
pattern_match(auto: y, 1)
{
stack: main{(0 = x, 1 = y) = (0 = 5, 1 = (- 5)); ... <-1>} :: top{}
heap: fun<main>, 0, 1,
env: y: 1, x: 0, main: fun<main>,
}
--- step stmt (0 = x, 1 = y) = (0 = 5, 1 = (- 5)); ... --->
{
stack: main{(0 = x, 1 = y) = (0 = 5, 1 = (- 5));<-1> :: return (x + y);<-1>} :: top{}
heap: fun<main>, 0, 1,
env: y: 1, x: 0, main: fun<main>,
}
--- step stmt (0 = x, 1 = y) = (0 = 5, 1 = (- 5)); --->
{
stack: main{(0 = x, 1 = y)<-1> :: (0 = x, 1 = y) = (0 = 5, 1 = (- 5));<0> :: return (x + y);<-1>} :: top{}
heap: fun<main>, 0, 1,
env: y: 1, x: 0, main: fun<main>,
}
--- step lvalue (0 = x, 1 = y) --->
{
stack: main{x<-1> :: (0 = x, 1 = y)<0> :: (0 = x, 1 = y) = (0 = 5, 1 = (- 5));<0> :: return (x + y);<-1>} :: top{}
heap: fun<main>, 0, 1,
env: y: 1, x: 0, main: fun<main>,
}
--- step lvalue x --->
{
stack: main{ptr<1><-1> :: (0 = x, 1 = y)<0> :: (0 = x, 1 = y) = (0 = 5, 1 = (- 5));<0> :: return (x + y);<-1>} :: top{}
heap: fun<main>, 0, 1,
env: y: 1, x: 0, main: fun<main>,
}
--- handle value ptr<1> with (0 = x, 1 = y)<1>(ptr<1>,) --->
{
stack: main{y<-1> :: (0 = x, 1 = y)<1>(ptr<1>,) :: (0 = x, 1 = y) = (0 = 5, 1 = (- 5));<0> :: return (x + y);<-1>} :: top{}
heap: fun<main>, 0, 1,
env: y: 1, x: 0, main: fun<main>,
}
--- step lvalue y --->
{
stack: main{ptr<2><-1> :: (0 = x, 1 = y)<1>(ptr<1>,) :: (0 = x, 1 = y) = (0 = 5, 1 = (- 5));<0> :: return (x + y);<-1>} :: top{}
heap: fun<main>, 0, 1,
env: y: 1, x: 0, main: fun<main>,
}
--- handle value ptr<2> with (0 = x, 1 = y)<2>(ptr<1>,ptr<2>,) --->
{
stack: main{(0 = ptr<1>@3, 1 = ptr<2>@4)<-1> :: (0 = x, 1 = y) = (0 = 5, 1 = (- 5));<0> :: return (x + y);<-1>} :: top{}
heap: fun<main>, 0, 1, ptr<1>, ptr<2>,
env: y: 1, x: 0, main: fun<main>,
}
--- handle value (0 = ptr<1>@3, 1 = ptr<2>@4) with (0 = x, 1 = y) = (0 = 5, 1 = (- 5));<1>((0 = ptr<1>@3, 1 = ptr<2>@4),) --->
{
stack: main{(0 = 5, 1 = (- 5))<-1> :: (0 = x, 1 = y) = (0 = 5, 1 = (- 5));<1>((0 = ptr<1>@3, 1 = ptr<2>@4),) :: return (x + y);<-1>} :: top{}
heap: fun<main>, 0, 1, ptr<1>, ptr<2>,
env: y: 1, x: 0, main: fun<main>,
}
--- step exp (0 = 5, 1 = (- 5)) --->
{
stack: main{5<-1> :: (0 = 5, 1 = (- 5))<0> :: (0 = x, 1 = y) = (0 = 5, 1 = (- 5));<1>((0 = ptr<1>@3, 1 = ptr<2>@4),) :: return (x + y);<-1>} :: top{}
heap: fun<main>, 0, 1, ptr<1>, ptr<2>,
env: y: 1, x: 0, main: fun<main>,
}
--- step exp 5 --->
{
stack: main{5<-1> :: (0 = 5, 1 = (- 5))<0> :: (0 = x, 1 = y) = (0 = 5, 1 = (- 5));<1>((0 = ptr<1>@3, 1 = ptr<2>@4),) :: return (x + y);<-1>} :: top{}
heap: fun<main>, 0, 1, ptr<1>, ptr<2>,
env: y: 1, x: 0, main: fun<main>,
}
--- handle value 5 with (0 = 5, 1 = (- 5))<1>(5,) --->
{
stack: main{(- 5)<-1> :: (0 = 5, 1 = (- 5))<1>(5,) :: (0 = x, 1 = y) = (0 = 5, 1 = (- 5));<1>((0 = ptr<1>@3, 1 = ptr<2>@4),) :: return (x + y);<-1>} :: top{}
heap: fun<main>, 0, 1, ptr<1>, ptr<2>,
env: y: 1, x: 0, main: fun<main>,
}
--- step exp (- 5) --->
{
stack: main{5<-1> :: (- 5)<0> :: (0 = 5, 1 = (- 5))<1>(5,) :: (0 = x, 1 = y) = (0 = 5, 1 = (- 5));<1>((0 = ptr<1>@3, 1 = ptr<2>@4),) :: return (x + y);<-1>} :: top{}
heap: fun<main>, 0, 1, ptr<1>, ptr<2>,
env: y: 1, x: 0, main: fun<main>,
}
--- step exp 5 --->
{
stack: main{5<-1> :: (- 5)<0> :: (0 = 5, 1 = (- 5))<1>(5,) :: (0 = x, 1 = y) = (0 = 5, 1 = (- 5));<1>((0 = ptr<1>@3, 1 = ptr<2>@4),) :: return (x + y);<-1>} :: top{}
heap: fun<main>, 0, 1, ptr<1>, ptr<2>,
env: y: 1, x: 0, main: fun<main>,
}
--- handle value 5 with (- 5)<1>(5,) --->
{
stack: main{-5<-1> :: (0 = 5, 1 = (- 5))<1>(5,) :: (0 = x, 1 = y) = (0 = 5, 1 = (- 5));<1>((0 = ptr<1>@3, 1 = ptr<2>@4),) :: return (x + y);<-1>} :: top{}
heap: fun<main>, 0, 1, ptr<1>, ptr<2>,
env: y: 1, x: 0, main: fun<main>,
}
--- handle value -5 with (0 = 5, 1 = (- 5))<2>(5,-5,) --->
{
stack: main{(0 = 5@5, 1 = -5@6)<-1> :: (0 = x, 1 = y) = (0 = 5, 1 = (- 5));<1>((0 = ptr<1>@3, 1 = ptr<2>@4),) :: return (x + y);<-1>} :: top{}
heap: fun<main>, 0, 1, ptr<1>, ptr<2>, 5, -5,
env: y: 1, x: 0, main: fun<main>,
}
--- handle value (0 = 5@5, 1 = -5@6) with (0 = x, 1 = y) = (0 = 5, 1 = (- 5));<2>((0 = ptr<1>@3, 1 = ptr<2>@4),(0 = 5@5, 1 = -5@6),) --->
{
stack: main{return (x + y);<-1>} :: top{}
heap: fun<main>, 5, -5, ptr<1>, ptr<2>, 5, -5,
env: y: -5, x: 5, main: fun<main>,
}
--- step stmt return (x + y); --->
{
stack: main{(x + y)<-1> :: return (x + y);<0>} :: top{}
heap: fun<main>, 5, -5, ptr<1>, ptr<2>, 5, -5,
env: y: -5, x: 5, main: fun<main>,
}
--- step exp (x + y) --->
{
stack: main{x<-1> :: (x + y)<0> :: return (x + y);<0>} :: top{}
heap: fun<main>, 5, -5, ptr<1>, ptr<2>, 5, -5,
env: y: -5, x: 5, main: fun<main>,
}
--- step exp x --->
{
stack: main{5<-1> :: (x + y)<0> :: return (x + y);<0>} :: top{}
heap: fun<main>, 5, -5, ptr<1>, ptr<2>, 5, -5,
env: y: -5, x: 5, main: fun<main>,
}
--- handle value 5 with (x + y)<1>(5,) --->
{
stack: main{y<-1> :: (x + y)<1>(5,) :: return (x + y);<0>} :: top{}
heap: fun<main>, 5, -5, ptr<1>, ptr<2>, 5, -5,
env: y: -5, x: 5, main: fun<main>,
}
--- step exp y --->
{
stack: main{-5<-1> :: (x + y)<1>(5,) :: return (x + y);<0>} :: top{}
heap: fun<main>, 5, -5, ptr<1>, ptr<2>, 5, -5,
env: y: -5, x: 5, main: fun<main>,
}
--- handle value -5 with (x + y)<2>(5,-5,) --->
{
stack: main{0<-1> :: return (x + y);<0>} :: top{}
heap: fun<main>, 5, -5, ptr<1>, ptr<2>, 5, -5,
env: y: -5, x: 5, main: fun<main>,
}
--- handle value 0 with return (x + y);<1>(0,) --->
{
stack: top{0<-1>}
heap: fun<main>, !!5, !!-5, ptr<1>, ptr<2>, !!5, !!-5,
env: main: fun<main>,
}
result: 0
executable_semantics/testdata/tuple_match.golden
Vendored
+317
View File
@@ -1 +1,318 @@
********** source program **********
fn main () -> Int {
var auto: t = (0 = 5, 1 = 2);
match (t) {
case (0 = auto: a, 1 = auto: b) =>
return ((a + b) - 7);
}
}
********** type checking **********
--- step exp Int --->
--- step exp Int --->
--- step exp auto --->
--- step exp auto --->
--- step exp auto --->
********** type checking complete **********
fn main () -> Int {
var auto: t = (0 = 5, 1 = 2);
match (t) {
case (0 = auto: a, 1 = auto: b) =>
return ((a + b) - 7);
}
}
********** starting execution **********
********** initializing globals **********
--- step exp () --->
********** calling main function **********
{
stack: top{main()<-1>}
heap: fun<main>,
env: main: fun<main>,
}
--- step exp main() --->
{
stack: top{main<-1> :: main()<0>}
heap: fun<main>,
env: main: fun<main>,
}
--- step exp main --->
{
stack: top{fun<main><-1> :: main()<0>}
heap: fun<main>,
env: main: fun<main>,
}
--- handle value fun<main> with main()<1>(fun<main>,) --->
{
stack: top{()<-1> :: main()<1>(fun<main>,)}
heap: fun<main>,
env: main: fun<main>,
}
--- step exp () --->
{
stack: top{()<-1> :: main()<1>(fun<main>,)}
heap: fun<main>,
env: main: fun<main>,
}
--- handle value () with main()<2>(fun<main>,(),) --->
pattern_match((), ())
{
stack: main{var auto: t = (0 = 5, 1 = 2); ... <-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- step stmt var auto: t = (0 = 5, 1 = 2); ... --->
{
stack: main{var auto: t = (0 = 5, 1 = 2);<-1> :: match (t) {...}<-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- step stmt var auto: t = (0 = 5, 1 = 2); --->
{
stack: main{(0 = 5, 1 = 2)<-1> :: var auto: t = (0 = 5, 1 = 2);<0> :: match (t) {...}<-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- step exp (0 = 5, 1 = 2) --->
{
stack: main{5<-1> :: (0 = 5, 1 = 2)<0> :: var auto: t = (0 = 5, 1 = 2);<0> :: match (t) {...}<-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- step exp 5 --->
{
stack: main{5<-1> :: (0 = 5, 1 = 2)<0> :: var auto: t = (0 = 5, 1 = 2);<0> :: match (t) {...}<-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- handle value 5 with (0 = 5, 1 = 2)<1>(5,) --->
{
stack: main{2<-1> :: (0 = 5, 1 = 2)<1>(5,) :: var auto: t = (0 = 5, 1 = 2);<0> :: match (t) {...}<-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- step exp 2 --->
{
stack: main{2<-1> :: (0 = 5, 1 = 2)<1>(5,) :: var auto: t = (0 = 5, 1 = 2);<0> :: match (t) {...}<-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- handle value 2 with (0 = 5, 1 = 2)<2>(5,2,) --->
{
stack: main{(0 = 5@1, 1 = 2@2)<-1> :: var auto: t = (0 = 5, 1 = 2);<0> :: match (t) {...}<-1>} :: top{}
heap: fun<main>, 5, 2,
env: main: fun<main>,
}
--- handle value (0 = 5@1, 1 = 2@2) with var auto: t = (0 = 5, 1 = 2);<1>((0 = 5@1, 1 = 2@2),) --->
{
stack: main{auto: t<-1> :: var auto: t = (0 = 5, 1 = 2);<1>((0 = 5@1, 1 = 2@2),) :: match (t) {...}<-1>} :: top{}
heap: fun<main>, 5, 2,
env: main: fun<main>,
}
--- step exp auto: t --->
{
stack: main{auto<-1> :: auto: t<0> :: var auto: t = (0 = 5, 1 = 2);<1>((0 = 5@1, 1 = 2@2),) :: match (t) {...}<-1>} :: top{}
heap: fun<main>, 5, 2,
env: main: fun<main>,
}
--- step exp auto --->
{
stack: main{auto<-1> :: auto: t<0> :: var auto: t = (0 = 5, 1 = 2);<1>((0 = 5@1, 1 = 2@2),) :: match (t) {...}<-1>} :: top{}
heap: fun<main>, 5, 2,
env: main: fun<main>,
}
--- handle value auto with auto: t<1>(auto,) --->
{
stack: main{auto: t<-1> :: var auto: t = (0 = 5, 1 = 2);<1>((0 = 5@1, 1 = 2@2),) :: match (t) {...}<-1>} :: top{}
heap: fun<main>, 5, 2,
env: main: fun<main>,
}
--- handle value auto: t with var auto: t = (0 = 5, 1 = 2);<2>((0 = 5@1, 1 = 2@2),auto: t,) --->
pattern_match(auto: t, (0 = 5@1, 1 = 2@2))
{
stack: main{match (t) {...}<-1>} :: top{}
heap: fun<main>, 5, 2, 5, 2, (0 = 5@3, 1 = 2@4),
env: t: (0 = 5@3, 1 = 2@4), main: fun<main>,
}
--- step stmt match (t) {...} --->
{
stack: main{t<-1> :: match (t) {...}<0>} :: top{}
heap: fun<main>, 5, 2, 5, 2, (0 = 5@3, 1 = 2@4),
env: t: (0 = 5@3, 1 = 2@4), main: fun<main>,
}
--- step exp t --->
{
stack: main{(0 = 5@3, 1 = 2@4)<-1> :: match (t) {...}<0>} :: top{}
heap: fun<main>, 5, 2, 5, 2, (0 = 5@3, 1 = 2@4),
env: t: (0 = 5@3, 1 = 2@4), main: fun<main>,
}
--- handle value (0 = 5@3, 1 = 2@4) with match (t) {...}<1>((0 = 5@3, 1 = 2@4),) --->
{
stack: main{(0 = auto: a, 1 = auto: b)<-1> :: match (t) {...}<1>((0 = 5@3, 1 = 2@4),)} :: top{}
heap: fun<main>, 5, 2, 5, 2, (0 = 5@3, 1 = 2@4),
env: t: (0 = 5@3, 1 = 2@4), main: fun<main>,
}
--- step exp (0 = auto: a, 1 = auto: b) --->
{
stack: main{auto: a<-1> :: (0 = auto: a, 1 = auto: b)<0> :: match (t) {...}<1>((0 = 5@3, 1 = 2@4),)} :: top{}
heap: fun<main>, 5, 2, 5, 2, (0 = 5@3, 1 = 2@4),
env: t: (0 = 5@3, 1 = 2@4), main: fun<main>,
}
--- step exp auto: a --->
{
stack: main{auto<-1> :: auto: a<0> :: (0 = auto: a, 1 = auto: b)<0> :: match (t) {...}<1>((0 = 5@3, 1 = 2@4),)} :: top{}
heap: fun<main>, 5, 2, 5, 2, (0 = 5@3, 1 = 2@4),
env: t: (0 = 5@3, 1 = 2@4), main: fun<main>,
}
--- step exp auto --->
{
stack: main{auto<-1> :: auto: a<0> :: (0 = auto: a, 1 = auto: b)<0> :: match (t) {...}<1>((0 = 5@3, 1 = 2@4),)} :: top{}
heap: fun<main>, 5, 2, 5, 2, (0 = 5@3, 1 = 2@4),
env: t: (0 = 5@3, 1 = 2@4), main: fun<main>,
}
--- handle value auto with auto: a<1>(auto,) --->
{
stack: main{auto: a<-1> :: (0 = auto: a, 1 = auto: b)<0> :: match (t) {...}<1>((0 = 5@3, 1 = 2@4),)} :: top{}
heap: fun<main>, 5, 2, 5, 2, (0 = 5@3, 1 = 2@4),
env: t: (0 = 5@3, 1 = 2@4), main: fun<main>,
}
--- handle value auto: a with (0 = auto: a, 1 = auto: b)<1>(auto: a,) --->
{
stack: main{auto: b<-1> :: (0 = auto: a, 1 = auto: b)<1>(auto: a,) :: match (t) {...}<1>((0 = 5@3, 1 = 2@4),)} :: top{}
heap: fun<main>, 5, 2, 5, 2, (0 = 5@3, 1 = 2@4),
env: t: (0 = 5@3, 1 = 2@4), main: fun<main>,
}
--- step exp auto: b --->
{
stack: main{auto<-1> :: auto: b<0> :: (0 = auto: a, 1 = auto: b)<1>(auto: a,) :: match (t) {...}<1>((0 = 5@3, 1 = 2@4),)} :: top{}
heap: fun<main>, 5, 2, 5, 2, (0 = 5@3, 1 = 2@4),
env: t: (0 = 5@3, 1 = 2@4), main: fun<main>,
}
--- step exp auto --->
{
stack: main{auto<-1> :: auto: b<0> :: (0 = auto: a, 1 = auto: b)<1>(auto: a,) :: match (t) {...}<1>((0 = 5@3, 1 = 2@4),)} :: top{}
heap: fun<main>, 5, 2, 5, 2, (0 = 5@3, 1 = 2@4),
env: t: (0 = 5@3, 1 = 2@4), main: fun<main>,
}
--- handle value auto with auto: b<1>(auto,) --->
{
stack: main{auto: b<-1> :: (0 = auto: a, 1 = auto: b)<1>(auto: a,) :: match (t) {...}<1>((0 = 5@3, 1 = 2@4),)} :: top{}
heap: fun<main>, 5, 2, 5, 2, (0 = 5@3, 1 = 2@4),
env: t: (0 = 5@3, 1 = 2@4), main: fun<main>,
}
--- handle value auto: b with (0 = auto: a, 1 = auto: b)<2>(auto: a,auto: b,) --->
{
stack: main{(0 = auto: a@6, 1 = auto: b@7)<-1> :: match (t) {...}<1>((0 = 5@3, 1 = 2@4),)} :: top{}
heap: fun<main>, 5, 2, 5, 2, (0 = 5@3, 1 = 2@4), auto: a, auto: b,
env: t: (0 = 5@3, 1 = 2@4), main: fun<main>,
}
--- handle value (0 = auto: a@6, 1 = auto: b@7) with match (t) {...}<2>((0 = 5@3, 1 = 2@4),(0 = auto: a@6, 1 = auto: b@7),) --->
pattern_match((0 = auto: a@6, 1 = auto: b@7), (0 = 5@3, 1 = 2@4))
pattern_match(auto: a, 5)
pattern_match(auto: b, 2)
{
stack: main{return ((a + b) - 7);<-1> :: {
...
}
<0>} :: top{}
heap: fun<main>, 5, 2, 5, 2, (0 = 5@3, 1 = 2@4), auto: a, auto: b, 5, 2,
env: b: 2, a: 5, t: (0 = 5@3, 1 = 2@4), main: fun<main>,
}
--- step stmt return ((a + b) - 7); --->
{
stack: main{((a + b) - 7)<-1> :: return ((a + b) - 7);<0> :: {
...
}
<0>} :: top{}
heap: fun<main>, 5, 2, 5, 2, (0 = 5@3, 1 = 2@4), auto: a, auto: b, 5, 2,
env: b: 2, a: 5, t: (0 = 5@3, 1 = 2@4), main: fun<main>,
}
--- step exp ((a + b) - 7) --->
{
stack: main{(a + b)<-1> :: ((a + b) - 7)<0> :: return ((a + b) - 7);<0> :: {
...
}
<0>} :: top{}
heap: fun<main>, 5, 2, 5, 2, (0 = 5@3, 1 = 2@4), auto: a, auto: b, 5, 2,
env: b: 2, a: 5, t: (0 = 5@3, 1 = 2@4), main: fun<main>,
}
--- step exp (a + b) --->
{
stack: main{a<-1> :: (a + b)<0> :: ((a + b) - 7)<0> :: return ((a + b) - 7);<0> :: {
...
}
<0>} :: top{}
heap: fun<main>, 5, 2, 5, 2, (0 = 5@3, 1 = 2@4), auto: a, auto: b, 5, 2,
env: b: 2, a: 5, t: (0 = 5@3, 1 = 2@4), main: fun<main>,
}
--- step exp a --->
{
stack: main{5<-1> :: (a + b)<0> :: ((a + b) - 7)<0> :: return ((a + b) - 7);<0> :: {
...
}
<0>} :: top{}
heap: fun<main>, 5, 2, 5, 2, (0 = 5@3, 1 = 2@4), auto: a, auto: b, 5, 2,
env: b: 2, a: 5, t: (0 = 5@3, 1 = 2@4), main: fun<main>,
}
--- handle value 5 with (a + b)<1>(5,) --->
{
stack: main{b<-1> :: (a + b)<1>(5,) :: ((a + b) - 7)<0> :: return ((a + b) - 7);<0> :: {
...
}
<0>} :: top{}
heap: fun<main>, 5, 2, 5, 2, (0 = 5@3, 1 = 2@4), auto: a, auto: b, 5, 2,
env: b: 2, a: 5, t: (0 = 5@3, 1 = 2@4), main: fun<main>,
}
--- step exp b --->
{
stack: main{2<-1> :: (a + b)<1>(5,) :: ((a + b) - 7)<0> :: return ((a + b) - 7);<0> :: {
...
}
<0>} :: top{}
heap: fun<main>, 5, 2, 5, 2, (0 = 5@3, 1 = 2@4), auto: a, auto: b, 5, 2,
env: b: 2, a: 5, t: (0 = 5@3, 1 = 2@4), main: fun<main>,
}
--- handle value 2 with (a + b)<2>(5,2,) --->
{
stack: main{7<-1> :: ((a + b) - 7)<0> :: return ((a + b) - 7);<0> :: {
...
}
<0>} :: top{}
heap: fun<main>, 5, 2, 5, 2, (0 = 5@3, 1 = 2@4), auto: a, auto: b, 5, 2,
env: b: 2, a: 5, t: (0 = 5@3, 1 = 2@4), main: fun<main>,
}
--- handle value 7 with ((a + b) - 7)<1>(7,) --->
{
stack: main{7<-1> :: ((a + b) - 7)<1>(7,) :: return ((a + b) - 7);<0> :: {
...
}
<0>} :: top{}
heap: fun<main>, 5, 2, 5, 2, (0 = 5@3, 1 = 2@4), auto: a, auto: b, 5, 2,
env: b: 2, a: 5, t: (0 = 5@3, 1 = 2@4), main: fun<main>,
}
--- step exp 7 --->
{
stack: main{7<-1> :: ((a + b) - 7)<1>(7,) :: return ((a + b) - 7);<0> :: {
...
}
<0>} :: top{}
heap: fun<main>, 5, 2, 5, 2, (0 = 5@3, 1 = 2@4), auto: a, auto: b, 5, 2,
env: b: 2, a: 5, t: (0 = 5@3, 1 = 2@4), main: fun<main>,
}
--- handle value 7 with ((a + b) - 7)<2>(7,7,) --->
{
stack: main{0<-1> :: return ((a + b) - 7);<0> :: {
...
}
<0>} :: top{}
heap: fun<main>, 5, 2, 5, 2, (0 = 5@3, 1 = 2@4), auto: a, auto: b, 5, 2,
env: b: 2, a: 5, t: (0 = 5@3, 1 = 2@4), main: fun<main>,
}
--- handle value 0 with return ((a + b) - 7);<1>(0,) --->
{
stack: top{0<-1>}
heap: fun<main>, 5, 2, !!5, !!2, !!(0 = !!5@3, 1 = !!2@4), auto: a, auto: b, !!5, !!2,
env: main: fun<main>,
}
result: 0
executable_semantics/testdata/undef1.6c
Vendored
+18
View File
@@ -0,0 +1,18 @@
// Part of the Carbon Language project, under the Apache License v2.0 with LLVM
// Exceptions. See /LICENSE for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// The behavior of this program is undefined because it tries to
// access a local variable after its lifetime is over.
fn f() -> Int* {
var int: x;
x = 0;
return &x;
}
fn main() -> int {
var Ptr(int): p;
p = f();
return *p;
}
executable_semantics/testdata/undef1.golden
Vendored
+2
View File
@@ -0,0 +1,2 @@
executable_semantics/testdata/undef1.6c:8: syntax error
EXIT CODE: 255
executable_semantics/testdata/undef2.6c
Vendored
+13
View File
@@ -0,0 +1,13 @@
// Part of the Carbon Language project, under the Apache License v2.0 with LLVM
// Exceptions. See /LICENSE for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// Use-after-free.
fun main() -> Int {
var Ptr(int): p;
p = malloc(Int);
*p = 0;
free(p);
return *p;
}
executable_semantics/testdata/undef2.golden
Vendored
+4
View File
@@ -0,0 +1,4 @@
********** source program **********
********** type checking **********
error, program must contain a function named `main`
EXIT CODE: 255
executable_semantics/testdata/while1.golden
Vendored
+463
View File
@@ -1 +1,464 @@
********** source program **********
fn main () -> Int {
var auto: x = 2;
while ((! (x == 0)))
x = (x - 1);
return x;
}
********** type checking **********
--- step exp Int --->
--- step exp Int --->
--- step exp auto --->
********** type checking complete **********
fn main () -> Int {
var auto: x = 2;
while ((! (x == 0)))
x = (x - 1);
return x;
}
********** starting execution **********
********** initializing globals **********
--- step exp () --->
********** calling main function **********
{
stack: top{main()<-1>}
heap: fun<main>,
env: main: fun<main>,
}
--- step exp main() --->
{
stack: top{main<-1> :: main()<0>}
heap: fun<main>,
env: main: fun<main>,
}
--- step exp main --->
{
stack: top{fun<main><-1> :: main()<0>}
heap: fun<main>,
env: main: fun<main>,
}
--- handle value fun<main> with main()<1>(fun<main>,) --->
{
stack: top{()<-1> :: main()<1>(fun<main>,)}
heap: fun<main>,
env: main: fun<main>,
}
--- step exp () --->
{
stack: top{()<-1> :: main()<1>(fun<main>,)}
heap: fun<main>,
env: main: fun<main>,
}
--- handle value () with main()<2>(fun<main>,(),) --->
pattern_match((), ())
{
stack: main{var auto: x = 2; ... <-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- step stmt var auto: x = 2; ... --->
{
stack: main{var auto: x = 2;<-1> :: while ((! (x == 0)))
... ... <-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- step stmt var auto: x = 2; --->
{
stack: main{2<-1> :: var auto: x = 2;<0> :: while ((! (x == 0)))
... ... <-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- step exp 2 --->
{
stack: main{2<-1> :: var auto: x = 2;<0> :: while ((! (x == 0)))
... ... <-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- handle value 2 with var auto: x = 2;<1>(2,) --->
{
stack: main{auto: x<-1> :: var auto: x = 2;<1>(2,) :: while ((! (x == 0)))
... ... <-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- step exp auto: x --->
{
stack: main{auto<-1> :: auto: x<0> :: var auto: x = 2;<1>(2,) :: while ((! (x == 0)))
... ... <-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- step exp auto --->
{
stack: main{auto<-1> :: auto: x<0> :: var auto: x = 2;<1>(2,) :: while ((! (x == 0)))
... ... <-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- handle value auto with auto: x<1>(auto,) --->
{
stack: main{auto: x<-1> :: var auto: x = 2;<1>(2,) :: while ((! (x == 0)))
... ... <-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- handle value auto: x with var auto: x = 2;<2>(2,auto: x,) --->
pattern_match(auto: x, 2)
{
stack: main{while ((! (x == 0)))
... ... <-1>} :: top{}
heap: fun<main>, 2,
env: x: 2, main: fun<main>,
}
--- step stmt while ((! (x == 0)))
... ... --->
{
stack: main{while ((! (x == 0)))
... <-1> :: return x;<-1>} :: top{}
heap: fun<main>, 2,
env: x: 2, main: fun<main>,
}
--- step stmt while ((! (x == 0)))
... --->
{
stack: main{(! (x == 0))<-1> :: while ((! (x == 0)))
... <0> :: return x;<-1>} :: top{}
heap: fun<main>, 2,
env: x: 2, main: fun<main>,
}
--- step exp (! (x == 0)) --->
{
stack: main{(x == 0)<-1> :: (! (x == 0))<0> :: while ((! (x == 0)))
... <0> :: return x;<-1>} :: top{}
heap: fun<main>, 2,
env: x: 2, main: fun<main>,
}
--- step exp (x == 0) --->
{
stack: main{x<-1> :: (x == 0)<0> :: (! (x == 0))<0> :: while ((! (x == 0)))
... <0> :: return x;<-1>} :: top{}
heap: fun<main>, 2,
env: x: 2, main: fun<main>,
}
--- step exp x --->
{
stack: main{2<-1> :: (x == 0)<0> :: (! (x == 0))<0> :: while ((! (x == 0)))
... <0> :: return x;<-1>} :: top{}
heap: fun<main>, 2,
env: x: 2, main: fun<main>,
}
--- handle value 2 with (x == 0)<1>(2,) --->
{
stack: main{0<-1> :: (x == 0)<1>(2,) :: (! (x == 0))<0> :: while ((! (x == 0)))
... <0> :: return x;<-1>} :: top{}
heap: fun<main>, 2,
env: x: 2, main: fun<main>,
}
--- step exp 0 --->
{
stack: main{0<-1> :: (x == 0)<1>(2,) :: (! (x == 0))<0> :: while ((! (x == 0)))
... <0> :: return x;<-1>} :: top{}
heap: fun<main>, 2,
env: x: 2, main: fun<main>,
}
--- handle value 0 with (x == 0)<2>(2,0,) --->
{
stack: main{false<-1> :: (! (x == 0))<0> :: while ((! (x == 0)))
... <0> :: return x;<-1>} :: top{}
heap: fun<main>, 2,
env: x: 2, main: fun<main>,
}
--- handle value false with (! (x == 0))<1>(false,) --->
{
stack: main{true<-1> :: while ((! (x == 0)))
... <0> :: return x;<-1>} :: top{}
heap: fun<main>, 2,
env: x: 2, main: fun<main>,
}
--- handle value true with while ((! (x == 0)))
... <1>(true,) --->
{
stack: main{x = (x - 1);<-1> :: while ((! (x == 0)))
... <-1> :: return x;<-1>} :: top{}
heap: fun<main>, 2,
env: x: 2, main: fun<main>,
}
--- step stmt x = (x - 1); --->
{
stack: main{x<-1> :: x = (x - 1);<0> :: while ((! (x == 0)))
... <-1> :: return x;<-1>} :: top{}
heap: fun<main>, 2,
env: x: 2, main: fun<main>,
}
--- step lvalue x --->
{
stack: main{ptr<1><-1> :: x = (x - 1);<0> :: while ((! (x == 0)))
... <-1> :: return x;<-1>} :: top{}
heap: fun<main>, 2,
env: x: 2, main: fun<main>,
}
--- handle value ptr<1> with x = (x - 1);<1>(ptr<1>,) --->
{
stack: main{(x - 1)<-1> :: x = (x - 1);<1>(ptr<1>,) :: while ((! (x == 0)))
... <-1> :: return x;<-1>} :: top{}
heap: fun<main>, 2,
env: x: 2, main: fun<main>,
}
--- step exp (x - 1) --->
{
stack: main{x<-1> :: (x - 1)<0> :: x = (x - 1);<1>(ptr<1>,) :: while ((! (x == 0)))
... <-1> :: return x;<-1>} :: top{}
heap: fun<main>, 2,
env: x: 2, main: fun<main>,
}
--- step exp x --->
{
stack: main{2<-1> :: (x - 1)<0> :: x = (x - 1);<1>(ptr<1>,) :: while ((! (x == 0)))
... <-1> :: return x;<-1>} :: top{}
heap: fun<main>, 2,
env: x: 2, main: fun<main>,
}
--- handle value 2 with (x - 1)<1>(2,) --->
{
stack: main{1<-1> :: (x - 1)<1>(2,) :: x = (x - 1);<1>(ptr<1>,) :: while ((! (x == 0)))
... <-1> :: return x;<-1>} :: top{}
heap: fun<main>, 2,
env: x: 2, main: fun<main>,
}
--- step exp 1 --->
{
stack: main{1<-1> :: (x - 1)<1>(2,) :: x = (x - 1);<1>(ptr<1>,) :: while ((! (x == 0)))
... <-1> :: return x;<-1>} :: top{}
heap: fun<main>, 2,
env: x: 2, main: fun<main>,
}
--- handle value 1 with (x - 1)<2>(2,1,) --->
{
stack: main{1<-1> :: x = (x - 1);<1>(ptr<1>,) :: while ((! (x == 0)))
... <-1> :: return x;<-1>} :: top{}
heap: fun<main>, 2,
env: x: 2, main: fun<main>,
}
--- handle value 1 with x = (x - 1);<2>(ptr<1>,1,) --->
{
stack: main{while ((! (x == 0)))
... <-1> :: return x;<-1>} :: top{}
heap: fun<main>, 1,
env: x: 1, main: fun<main>,
}
--- step stmt while ((! (x == 0)))
... --->
{
stack: main{(! (x == 0))<-1> :: while ((! (x == 0)))
... <0> :: return x;<-1>} :: top{}
heap: fun<main>, 1,
env: x: 1, main: fun<main>,
}
--- step exp (! (x == 0)) --->
{
stack: main{(x == 0)<-1> :: (! (x == 0))<0> :: while ((! (x == 0)))
... <0> :: return x;<-1>} :: top{}
heap: fun<main>, 1,
env: x: 1, main: fun<main>,
}
--- step exp (x == 0) --->
{
stack: main{x<-1> :: (x == 0)<0> :: (! (x == 0))<0> :: while ((! (x == 0)))
... <0> :: return x;<-1>} :: top{}
heap: fun<main>, 1,
env: x: 1, main: fun<main>,
}
--- step exp x --->
{
stack: main{1<-1> :: (x == 0)<0> :: (! (x == 0))<0> :: while ((! (x == 0)))
... <0> :: return x;<-1>} :: top{}
heap: fun<main>, 1,
env: x: 1, main: fun<main>,
}
--- handle value 1 with (x == 0)<1>(1,) --->
{
stack: main{0<-1> :: (x == 0)<1>(1,) :: (! (x == 0))<0> :: while ((! (x == 0)))
... <0> :: return x;<-1>} :: top{}
heap: fun<main>, 1,
env: x: 1, main: fun<main>,
}
--- step exp 0 --->
{
stack: main{0<-1> :: (x == 0)<1>(1,) :: (! (x == 0))<0> :: while ((! (x == 0)))
... <0> :: return x;<-1>} :: top{}
heap: fun<main>, 1,
env: x: 1, main: fun<main>,
}
--- handle value 0 with (x == 0)<2>(1,0,) --->
{
stack: main{false<-1> :: (! (x == 0))<0> :: while ((! (x == 0)))
... <0> :: return x;<-1>} :: top{}
heap: fun<main>, 1,
env: x: 1, main: fun<main>,
}
--- handle value false with (! (x == 0))<1>(false,) --->
{
stack: main{true<-1> :: while ((! (x == 0)))
... <0> :: return x;<-1>} :: top{}
heap: fun<main>, 1,
env: x: 1, main: fun<main>,
}
--- handle value true with while ((! (x == 0)))
... <1>(true,) --->
{
stack: main{x = (x - 1);<-1> :: while ((! (x == 0)))
... <-1> :: return x;<-1>} :: top{}
heap: fun<main>, 1,
env: x: 1, main: fun<main>,
}
--- step stmt x = (x - 1); --->
{
stack: main{x<-1> :: x = (x - 1);<0> :: while ((! (x == 0)))
... <-1> :: return x;<-1>} :: top{}
heap: fun<main>, 1,
env: x: 1, main: fun<main>,
}
--- step lvalue x --->
{
stack: main{ptr<1><-1> :: x = (x - 1);<0> :: while ((! (x == 0)))
... <-1> :: return x;<-1>} :: top{}
heap: fun<main>, 1,
env: x: 1, main: fun<main>,
}
--- handle value ptr<1> with x = (x - 1);<1>(ptr<1>,) --->
{
stack: main{(x - 1)<-1> :: x = (x - 1);<1>(ptr<1>,) :: while ((! (x == 0)))
... <-1> :: return x;<-1>} :: top{}
heap: fun<main>, 1,
env: x: 1, main: fun<main>,
}
--- step exp (x - 1) --->
{
stack: main{x<-1> :: (x - 1)<0> :: x = (x - 1);<1>(ptr<1>,) :: while ((! (x == 0)))
... <-1> :: return x;<-1>} :: top{}
heap: fun<main>, 1,
env: x: 1, main: fun<main>,
}
--- step exp x --->
{
stack: main{1<-1> :: (x - 1)<0> :: x = (x - 1);<1>(ptr<1>,) :: while ((! (x == 0)))
... <-1> :: return x;<-1>} :: top{}
heap: fun<main>, 1,
env: x: 1, main: fun<main>,
}
--- handle value 1 with (x - 1)<1>(1,) --->
{
stack: main{1<-1> :: (x - 1)<1>(1,) :: x = (x - 1);<1>(ptr<1>,) :: while ((! (x == 0)))
... <-1> :: return x;<-1>} :: top{}
heap: fun<main>, 1,
env: x: 1, main: fun<main>,
}
--- step exp 1 --->
{
stack: main{1<-1> :: (x - 1)<1>(1,) :: x = (x - 1);<1>(ptr<1>,) :: while ((! (x == 0)))
... <-1> :: return x;<-1>} :: top{}
heap: fun<main>, 1,
env: x: 1, main: fun<main>,
}
--- handle value 1 with (x - 1)<2>(1,1,) --->
{
stack: main{0<-1> :: x = (x - 1);<1>(ptr<1>,) :: while ((! (x == 0)))
... <-1> :: return x;<-1>} :: top{}
heap: fun<main>, 1,
env: x: 1, main: fun<main>,
}
--- handle value 0 with x = (x - 1);<2>(ptr<1>,0,) --->
{
stack: main{while ((! (x == 0)))
... <-1> :: return x;<-1>} :: top{}
heap: fun<main>, 0,
env: x: 0, main: fun<main>,
}
--- step stmt while ((! (x == 0)))
... --->
{
stack: main{(! (x == 0))<-1> :: while ((! (x == 0)))
... <0> :: return x;<-1>} :: top{}
heap: fun<main>, 0,
env: x: 0, main: fun<main>,
}
--- step exp (! (x == 0)) --->
{
stack: main{(x == 0)<-1> :: (! (x == 0))<0> :: while ((! (x == 0)))
... <0> :: return x;<-1>} :: top{}
heap: fun<main>, 0,
env: x: 0, main: fun<main>,
}
--- step exp (x == 0) --->
{
stack: main{x<-1> :: (x == 0)<0> :: (! (x == 0))<0> :: while ((! (x == 0)))
... <0> :: return x;<-1>} :: top{}
heap: fun<main>, 0,
env: x: 0, main: fun<main>,
}
--- step exp x --->
{
stack: main{0<-1> :: (x == 0)<0> :: (! (x == 0))<0> :: while ((! (x == 0)))
... <0> :: return x;<-1>} :: top{}
heap: fun<main>, 0,
env: x: 0, main: fun<main>,
}
--- handle value 0 with (x == 0)<1>(0,) --->
{
stack: main{0<-1> :: (x == 0)<1>(0,) :: (! (x == 0))<0> :: while ((! (x == 0)))
... <0> :: return x;<-1>} :: top{}
heap: fun<main>, 0,
env: x: 0, main: fun<main>,
}
--- step exp 0 --->
{
stack: main{0<-1> :: (x == 0)<1>(0,) :: (! (x == 0))<0> :: while ((! (x == 0)))
... <0> :: return x;<-1>} :: top{}
heap: fun<main>, 0,
env: x: 0, main: fun<main>,
}
--- handle value 0 with (x == 0)<2>(0,0,) --->
{
stack: main{true<-1> :: (! (x == 0))<0> :: while ((! (x == 0)))
... <0> :: return x;<-1>} :: top{}
heap: fun<main>, 0,
env: x: 0, main: fun<main>,
}
--- handle value true with (! (x == 0))<1>(true,) --->
{
stack: main{false<-1> :: while ((! (x == 0)))
... <0> :: return x;<-1>} :: top{}
heap: fun<main>, 0,
env: x: 0, main: fun<main>,
}
--- handle value false with while ((! (x == 0)))
... <1>(false,) --->
{
stack: main{return x;<-1>} :: top{}
heap: fun<main>, 0,
env: x: 0, main: fun<main>,
}
--- step stmt return x; --->
{
stack: main{x<-1> :: return x;<0>} :: top{}
heap: fun<main>, 0,
env: x: 0, main: fun<main>,
}
--- step exp x --->
{
stack: main{0<-1> :: return x;<0>} :: top{}
heap: fun<main>, 0,
env: x: 0, main: fun<main>,
}
--- handle value 0 with return x;<1>(0,) --->
{
stack: top{0<-1>}
heap: fun<main>, !!0,
env: main: fun<main>,
}
result: 0
executable_semantics/testdata/zero.golden
Vendored
+71
View File
@@ -1 +1,72 @@
********** source program **********
fn main () -> Int {
return 0;
}
********** type checking **********
--- step exp Int --->
--- step exp Int --->
********** type checking complete **********
fn main () -> Int {
return 0;
}
********** starting execution **********
********** initializing globals **********
--- step exp () --->
********** calling main function **********
{
stack: top{main()<-1>}
heap: fun<main>,
env: main: fun<main>,
}
--- step exp main() --->
{
stack: top{main<-1> :: main()<0>}
heap: fun<main>,
env: main: fun<main>,
}
--- step exp main --->
{
stack: top{fun<main><-1> :: main()<0>}
heap: fun<main>,
env: main: fun<main>,
}
--- handle value fun<main> with main()<1>(fun<main>,) --->
{
stack: top{()<-1> :: main()<1>(fun<main>,)}
heap: fun<main>,
env: main: fun<main>,
}
--- step exp () --->
{
stack: top{()<-1> :: main()<1>(fun<main>,)}
heap: fun<main>,
env: main: fun<main>,
}
--- handle value () with main()<2>(fun<main>,(),) --->
pattern_match((), ())
{
stack: main{return 0;<-1>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- step stmt return 0; --->
{
stack: main{0<-1> :: return 0;<0>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- step exp 0 --->
{
stack: main{0<-1> :: return 0;<0>} :: top{}
heap: fun<main>,
env: main: fun<main>,
}
--- handle value 0 with return 0;<1>(0,) --->
{
stack: top{0<-1>}
heap: fun<main>,
env: main: fun<main>,
}
result: 0