862 changed files with 4113 additions and 2043512 deletions
@ -1,38 +0,0 @@
|
||||
c{0: 0 (((1 integer)) <- ((copy)) ((1 literal))) -- nil |
||||
c{0: 1 (((2 integer)) <- ((copy)) ((3 literal))) -- nil |
||||
c{0: 2 (((3 integer)) <- ((add)) ((1 integer)) ((2 integer))) -- nil |
||||
c{1: 0 ✓ (((1 integer)) <- ((copy)) ((1 literal))) |
||||
c{1: 1 ✓ (((2 integer)) <- ((copy)) ((3 literal))) |
||||
c{1: 2 ✓ (((3 integer)) <- ((add)) ((1 integer)) ((2 integer))) |
||||
cn0: convert-names in main |
||||
cn0: (((1 integer)) <- ((copy)) ((1 literal))) nil nil |
||||
cn0: checking arg ((1 literal)) |
||||
cn0: checking oarg ((1 integer)) |
||||
maybe-add: ((1 integer)) |
||||
cn0: (((2 integer)) <- ((copy)) ((3 literal))) nil nil |
||||
cn0: checking arg ((3 literal)) |
||||
cn0: checking oarg ((2 integer)) |
||||
maybe-add: ((2 integer)) |
||||
cn0: (((3 integer)) <- ((add)) ((1 integer)) ((2 integer))) nil nil |
||||
cn0: checking arg ((1 integer)) |
||||
maybe-add: ((1 integer)) |
||||
cn0: checking arg ((2 integer)) |
||||
maybe-add: ((2 integer)) |
||||
cn0: checking oarg ((3 integer)) |
||||
maybe-add: ((3 integer)) |
||||
cn1: (((1 integer)) <- ((copy)) ((1 literal))) |
||||
cn1: (((2 integer)) <- ((copy)) ((3 literal))) |
||||
cn1: (((3 integer)) <- ((add)) ((1 integer)) ((2 integer))) |
||||
schedule: main |
||||
run: main 0: (((1 integer)) <- ((copy)) ((1 literal))) |
||||
run: main 0: 1 => ((1 integer)) |
||||
mem: ((1 integer)): 1 <= 1 |
||||
run: main 1: (((2 integer)) <- ((copy)) ((3 literal))) |
||||
run: main 1: 3 => ((2 integer)) |
||||
mem: ((2 integer)): 2 <= 3 |
||||
run: main 2: (((3 integer)) <- ((add)) ((1 integer)) ((2 integer))) |
||||
mem: ((1 integer)) => 1 |
||||
mem: ((2 integer)) => 3 |
||||
run: main 2: 4 => ((3 integer)) |
||||
mem: ((3 integer)): 3 <= 4 |
||||
schedule: done with routine nil |
@ -1,14 +0,0 @@
|
||||
c{0: 0 (((1 integer)) <- ((add)) ((2 literal)) ((3 literal))) -- nil |
||||
c{1: 0 ✓ (((1 integer)) <- ((add)) ((2 literal)) ((3 literal))) |
||||
cn0: convert-names in main |
||||
cn0: (((1 integer)) <- ((add)) ((2 literal)) ((3 literal))) nil nil |
||||
cn0: checking arg ((2 literal)) |
||||
cn0: checking arg ((3 literal)) |
||||
cn0: checking oarg ((1 integer)) |
||||
maybe-add: ((1 integer)) |
||||
cn1: (((1 integer)) <- ((add)) ((2 literal)) ((3 literal))) |
||||
schedule: main |
||||
run: main 0: (((1 integer)) <- ((add)) ((2 literal)) ((3 literal))) |
||||
run: main 0: 5 => ((1 integer)) |
||||
mem: ((1 integer)): 1 <= 5 |
||||
schedule: done with routine nil |
@ -1,14 +0,0 @@
|
||||
c{0: 0 (((1 boolean)) <- ((and)) ((t literal)) ((nil literal))) -- nil |
||||
c{1: 0 ✓ (((1 boolean)) <- ((and)) ((t literal)) ((nil literal))) |
||||
cn0: convert-names in main |
||||
cn0: (((1 boolean)) <- ((and)) ((t literal)) ((nil literal))) nil nil |
||||
cn0: checking arg ((t literal)) |
||||
cn0: checking arg ((nil literal)) |
||||
cn0: checking oarg ((1 boolean)) |
||||
maybe-add: ((1 boolean)) |
||||
cn1: (((1 boolean)) <- ((and)) ((t literal)) ((nil literal))) |
||||
schedule: main |
||||
run: main 0: (((1 boolean)) <- ((and)) ((t literal)) ((nil literal))) |
||||
run: main 0: nil => ((1 boolean)) |
||||
mem: ((1 boolean)): 1 <= nil |
||||
schedule: done with routine nil |
@ -1,43 +0,0 @@
|
||||
c{0: 0 (((1 integer)) <- ((copy)) ((34 literal))) -- nil |
||||
c{0: 1 (((2 boolean)) <- ((copy)) ((nil literal))) -- nil |
||||
c{0: 2 (((test1)) ((1 integer-boolean-pair))) -- nil |
||||
c{1: 0 ✓ (((1 integer)) <- ((copy)) ((34 literal))) |
||||
c{1: 1 ✓ (((2 boolean)) <- ((copy)) ((nil literal))) |
||||
c{1: 2 ✓ (((test1)) ((1 integer-boolean-pair))) |
||||
c{0: 0 (((4 integer-boolean-pair)) <- ((next-input))) -- nil |
||||
c{1: 0 ✓ (((4 integer-boolean-pair)) <- ((next-input))) |
||||
cn0: convert-names in main |
||||
cn0: (((1 integer)) <- ((copy)) ((34 literal))) nil nil |
||||
cn0: checking arg ((34 literal)) |
||||
cn0: checking oarg ((1 integer)) |
||||
maybe-add: ((1 integer)) |
||||
cn0: (((2 boolean)) <- ((copy)) ((nil literal))) nil nil |
||||
cn0: checking arg ((nil literal)) |
||||
cn0: checking oarg ((2 boolean)) |
||||
maybe-add: ((2 boolean)) |
||||
cn0: (((test1)) ((1 integer-boolean-pair))) nil nil |
||||
cn0: checking arg ((1 integer-boolean-pair)) |
||||
maybe-add: ((1 integer-boolean-pair)) |
||||
cn0: convert-names in test1 |
||||
cn0: (((4 integer-boolean-pair)) <- ((next-input))) nil nil |
||||
cn0: checking oarg ((4 integer-boolean-pair)) |
||||
maybe-add: ((4 integer-boolean-pair)) |
||||
cn1: (((1 integer)) <- ((copy)) ((34 literal))) |
||||
cn1: (((2 boolean)) <- ((copy)) ((nil literal))) |
||||
cn1: (((test1)) ((1 integer-boolean-pair))) |
||||
cn1: (((4 integer-boolean-pair)) <- ((next-input))) |
||||
schedule: main |
||||
run: main 0: (((1 integer)) <- ((copy)) ((34 literal))) |
||||
run: main 0: 34 => ((1 integer)) |
||||
mem: ((1 integer)): 1 <= 34 |
||||
run: main 1: (((2 boolean)) <- ((copy)) ((nil literal))) |
||||
run: main 1: nil => ((2 boolean)) |
||||
mem: ((2 boolean)): 2 <= nil |
||||
run: main 2: (((test1)) ((1 integer-boolean-pair))) |
||||
mem: ((1 integer-boolean-pair)) => #(tagged record (34 nil . nil)) |
||||
run: test1/main 0: (((4 integer-boolean-pair)) <- ((next-input))) |
||||
arg: nil 0 (#(tagged record (34 nil . nil))) |
||||
run: test1/main 0: #(tagged record (34 nil . nil)) => ((4 integer-boolean-pair)) |
||||
mem: ((4 integer-boolean-pair)): 4 <= 34 |
||||
mem: ((4 integer-boolean-pair)): 5 <= nil |
||||
schedule: done with routine nil |
@ -1,53 +0,0 @@
|
||||
c{0: 0 (((1 integer)) <- ((copy)) ((34 literal))) -- nil |
||||
c{0: 1 (((2 boolean)) <- ((copy)) ((nil literal))) -- nil |
||||
c{0: 2 (((3 integer-boolean-pair-address)) <- ((copy)) ((1 literal))) -- nil |
||||
c{0: 3 (((test1)) ((3 integer-boolean-pair-address) (deref))) -- nil |
||||
c{1: 0 ✓ (((1 integer)) <- ((copy)) ((34 literal))) |
||||
c{1: 1 ✓ (((2 boolean)) <- ((copy)) ((nil literal))) |
||||
c{1: 2 ✓ (((3 integer-boolean-pair-address)) <- ((copy)) ((1 literal))) |
||||
c{1: 3 ✓ (((test1)) ((3 integer-boolean-pair-address) (deref))) |
||||
c{0: 0 (((4 integer-boolean-pair)) <- ((next-input))) -- nil |
||||
c{1: 0 ✓ (((4 integer-boolean-pair)) <- ((next-input))) |
||||
cn0: convert-names in main |
||||
cn0: (((1 integer)) <- ((copy)) ((34 literal))) nil nil |
||||
cn0: checking arg ((34 literal)) |
||||
cn0: checking oarg ((1 integer)) |
||||
maybe-add: ((1 integer)) |
||||
cn0: (((2 boolean)) <- ((copy)) ((nil literal))) nil nil |
||||
cn0: checking arg ((nil literal)) |
||||
cn0: checking oarg ((2 boolean)) |
||||
maybe-add: ((2 boolean)) |
||||
cn0: (((3 integer-boolean-pair-address)) <- ((copy)) ((1 literal))) nil nil |
||||
cn0: checking arg ((1 literal)) |
||||
cn0: checking oarg ((3 integer-boolean-pair-address)) |
||||
maybe-add: ((3 integer-boolean-pair-address)) |
||||
cn0: (((test1)) ((3 integer-boolean-pair-address) (deref))) nil nil |
||||
cn0: checking arg ((3 integer-boolean-pair-address) (deref)) |
||||
maybe-add: ((3 integer-boolean-pair-address) (deref)) |
||||
cn0: convert-names in test1 |
||||
cn0: (((4 integer-boolean-pair)) <- ((next-input))) nil nil |
||||
cn0: checking oarg ((4 integer-boolean-pair)) |
||||
maybe-add: ((4 integer-boolean-pair)) |
||||
cn1: (((1 integer)) <- ((copy)) ((34 literal))) |
||||
cn1: (((2 boolean)) <- ((copy)) ((nil literal))) |
||||
cn1: (((3 integer-boolean-pair-address)) <- ((copy)) ((1 literal))) |
||||
cn1: (((test1)) ((3 integer-boolean-pair-address) (deref))) |
||||
cn1: (((4 integer-boolean-pair)) <- ((next-input))) |
||||
schedule: main |
||||
run: main 0: (((1 integer)) <- ((copy)) ((34 literal))) |
||||
run: main 0: 34 => ((1 integer)) |
||||
mem: ((1 integer)): 1 <= 34 |
||||
run: main 1: (((2 boolean)) <- ((copy)) ((nil literal))) |
||||
run: main 1: nil => ((2 boolean)) |
||||
mem: ((2 boolean)): 2 <= nil |
||||
run: main 2: (((3 integer-boolean-pair-address)) <- ((copy)) ((1 literal))) |
||||
run: main 2: 1 => ((3 integer-boolean-pair-address)) |
||||
mem: ((3 integer-boolean-pair-address)): 3 <= 1 |
||||
run: main 3: (((test1)) ((3 integer-boolean-pair-address) (deref))) |
||||
mem: ((3 integer-boolean-pair-address) (deref)) => #(tagged record (34 nil . nil)) |
||||
run: test1/main 0: (((4 integer-boolean-pair)) <- ((next-input))) |
||||
arg: nil 0 (#(tagged record (34 nil . nil))) |
||||
run: test1/main 0: #(tagged record (34 nil . nil)) => ((4 integer-boolean-pair)) |
||||
mem: ((4 integer-boolean-pair)): 4 <= 34 |
||||
mem: ((4 integer-boolean-pair)): 5 <= nil |
||||
schedule: done with routine nil |
@ -1,46 +0,0 @@
|
||||
c{0: 0 (((1 integer)) <- ((copy)) ((2 literal))) -- nil |
||||
c{0: 1 (((2 integer)) <- ((copy)) ((23 literal))) -- nil |
||||
c{0: 2 (((3 integer)) <- ((copy)) ((24 literal))) -- nil |
||||
c{0: 3 (((4 integer)) <- ((index)) ((1 integer-array)) ((2 literal))) -- nil |
||||
c{1: 0 ✓ (((1 integer)) <- ((copy)) ((2 literal))) |
||||
c{1: 1 ✓ (((2 integer)) <- ((copy)) ((23 literal))) |
||||
c{1: 2 ✓ (((3 integer)) <- ((copy)) ((24 literal))) |
||||
c{1: 3 ✓ (((4 integer)) <- ((index)) ((1 integer-array)) ((2 literal))) |
||||
cn0: convert-names in main |
||||
cn0: (((1 integer)) <- ((copy)) ((2 literal))) nil nil |
||||
cn0: checking arg ((2 literal)) |
||||
cn0: checking oarg ((1 integer)) |
||||
maybe-add: ((1 integer)) |
||||
cn0: (((2 integer)) <- ((copy)) ((23 literal))) nil nil |
||||
cn0: checking arg ((23 literal)) |
||||
cn0: checking oarg ((2 integer)) |
||||
maybe-add: ((2 integer)) |
||||
cn0: (((3 integer)) <- ((copy)) ((24 literal))) nil nil |
||||
cn0: checking arg ((24 literal)) |
||||
cn0: checking oarg ((3 integer)) |
||||
maybe-add: ((3 integer)) |
||||
cn0: (((4 integer)) <- ((index)) ((1 integer-array)) ((2 literal))) nil nil |
||||
cn0: checking arg ((1 integer-array)) |
||||
maybe-add: ((1 integer-array)) |
||||
cn0: checking arg ((2 literal)) |
||||
cn0: checking oarg ((4 integer)) |
||||
maybe-add: ((4 integer)) |
||||
cn1: (((1 integer)) <- ((copy)) ((2 literal))) |
||||
cn1: (((2 integer)) <- ((copy)) ((23 literal))) |
||||
cn1: (((3 integer)) <- ((copy)) ((24 literal))) |
||||
cn1: (((4 integer)) <- ((index)) ((1 integer-array)) ((2 literal))) |
||||
schedule: main |
||||
run: main 0: (((1 integer)) <- ((copy)) ((2 literal))) |
||||
run: main 0: 2 => ((1 integer)) |
||||
mem: ((1 integer)): 1 <= 2 |
||||
run: main 1: (((2 integer)) <- ((copy)) ((23 literal))) |
||||
run: main 1: 23 => ((2 integer)) |
||||
mem: ((2 integer)): 2 <= 23 |
||||
run: main 2: (((3 integer)) <- ((copy)) ((24 literal))) |
||||
run: main 2: 24 => ((3 integer)) |
||||
mem: ((3 integer)): 3 <= 24 |
||||
run: main 3: (((4 integer)) <- ((index)) ((1 integer-array)) ((2 literal))) |
||||
array-len: ((1 integer-array)) |
||||
mem: ((1 integer)) => 2 |
||||
-: die: 2 is out of bounds of array 1integer-array |
||||
schedule: done with dead routine main |
@ -1,100 +0,0 @@
|
||||
c{0: 0 (((10 integer)) <- ((copy)) ((30 literal))) -- nil |
||||
c{0: 1 (((default-space space-address)) <- ((copy)) ((10 literal))) -- nil |
||||
c{0: 2 (((1 integer)) <- ((copy)) ((2 literal))) -- nil |
||||
c{0: 3 (((2 integer)) <- ((copy)) ((23 literal))) -- nil |
||||
c{0: 4 (((3 boolean)) <- ((copy)) ((nil literal))) -- nil |
||||
c{0: 5 (((4 integer)) <- ((copy)) ((24 literal))) -- nil |
||||
c{0: 6 (((5 boolean)) <- ((copy)) ((t literal))) -- nil |
||||
c{0: 7 (((6 integer-boolean-pair-array-address)) <- ((copy)) ((12 literal))) -- nil |
||||
c{0: 8 (((7 integer-boolean-pair-array)) <- ((copy)) ((6 integer-boolean-pair-array-address) (deref))) -- nil |
||||
c{1: 0 ✓ (((10 integer)) <- ((copy)) ((30 literal))) |
||||
c{1: 1 ✓ (((default-space space-address)) <- ((copy)) ((10 literal))) |
||||
c{1: 2 ✓ (((1 integer)) <- ((copy)) ((2 literal))) |
||||
c{1: 3 ✓ (((2 integer)) <- ((copy)) ((23 literal))) |
||||
c{1: 4 ✓ (((3 boolean)) <- ((copy)) ((nil literal))) |
||||
c{1: 5 ✓ (((4 integer)) <- ((copy)) ((24 literal))) |
||||
c{1: 6 ✓ (((5 boolean)) <- ((copy)) ((t literal))) |
||||
c{1: 7 ✓ (((6 integer-boolean-pair-array-address)) <- ((copy)) ((12 literal))) |
||||
c{1: 8 ✓ (((7 integer-boolean-pair-array)) <- ((copy)) ((6 integer-boolean-pair-array-address) (deref))) |
||||
cn0: convert-names in main |
||||
cn0: (((10 integer)) <- ((copy)) ((30 literal))) nil nil |
||||
cn0: checking arg ((30 literal)) |
||||
cn0: checking oarg ((10 integer)) |
||||
maybe-add: ((10 integer)) |
||||
cn0: (((default-space space-address)) <- ((copy)) ((10 literal))) nil nil |
||||
cn0: checking arg ((10 literal)) |
||||
cn0: checking oarg ((default-space space-address)) |
||||
maybe-add: ((default-space space-address)) |
||||
cn0: (((1 integer)) <- ((copy)) ((2 literal))) nil nil |
||||
cn0: checking arg ((2 literal)) |
||||
cn0: checking oarg ((1 integer)) |
||||
maybe-add: ((1 integer)) |
||||
cn0: (((2 integer)) <- ((copy)) ((23 literal))) nil nil |
||||
cn0: checking arg ((23 literal)) |
||||
cn0: checking oarg ((2 integer)) |
||||
maybe-add: ((2 integer)) |
||||
cn0: (((3 boolean)) <- ((copy)) ((nil literal))) nil nil |
||||
cn0: checking arg ((nil literal)) |
||||
cn0: checking oarg ((3 boolean)) |
||||
maybe-add: ((3 boolean)) |
||||
cn0: (((4 integer)) <- ((copy)) ((24 literal))) nil nil |
||||
cn0: checking arg ((24 literal)) |
||||
cn0: checking oarg ((4 integer)) |
||||
maybe-add: ((4 integer)) |
||||
cn0: (((5 boolean)) <- ((copy)) ((t literal))) nil nil |
||||
cn0: checking arg ((t literal)) |
||||
cn0: checking oarg ((5 boolean)) |
||||
maybe-add: ((5 boolean)) |
||||
cn0: (((6 integer-boolean-pair-array-address)) <- ((copy)) ((12 literal))) nil nil |
||||
cn0: checking arg ((12 literal)) |
||||
cn0: checking oarg ((6 integer-boolean-pair-array-address)) |
||||
maybe-add: ((6 integer-boolean-pair-array-address)) |
||||
cn0: (((7 integer-boolean-pair-array)) <- ((copy)) ((6 integer-boolean-pair-array-address) (deref))) nil nil |
||||
cn0: checking arg ((6 integer-boolean-pair-array-address) (deref)) |
||||
maybe-add: ((6 integer-boolean-pair-array-address) (deref)) |
||||
cn0: checking oarg ((7 integer-boolean-pair-array)) |
||||
maybe-add: ((7 integer-boolean-pair-array)) |
||||
cn1: (((10 integer)) <- ((copy)) ((30 literal))) |
||||
cn1: (((default-space space-address)) <- ((copy)) ((10 literal))) |
||||
cn1: (((1 integer)) <- ((copy)) ((2 literal))) |
||||
cn1: (((2 integer)) <- ((copy)) ((23 literal))) |
||||
cn1: (((3 boolean)) <- ((copy)) ((nil literal))) |
||||
cn1: (((4 integer)) <- ((copy)) ((24 literal))) |
||||
cn1: (((5 boolean)) <- ((copy)) ((t literal))) |
||||
cn1: (((6 integer-boolean-pair-array-address)) <- ((copy)) ((12 literal))) |
||||
cn1: (((7 integer-boolean-pair-array)) <- ((copy)) ((6 integer-boolean-pair-array-address) (deref))) |
||||
schedule: main |
||||
run: main 0: (((10 integer)) <- ((copy)) ((30 literal))) |
||||
run: main 0: 30 => ((10 integer)) |
||||
mem: ((10 integer)): 10 <= 30 |
||||
run: main 1: (((default-space space-address)) <- ((copy)) ((10 literal))) |
||||
run: main 1: 10 => ((default-space space-address)) |
||||
run: main 2: (((1 integer)) <- ((copy)) ((2 literal))) |
||||
run: main 2: 2 => ((1 integer)) |
||||
mem: ((1 integer)): 12 <= 2 |
||||
run: main 3: (((2 integer)) <- ((copy)) ((23 literal))) |
||||
run: main 3: 23 => ((2 integer)) |
||||
mem: ((2 integer)): 13 <= 23 |
||||
run: main 4: (((3 boolean)) <- ((copy)) ((nil literal))) |
||||
run: main 4: nil => ((3 boolean)) |
||||
mem: ((3 boolean)): 14 <= nil |
||||
run: main 5: (((4 integer)) <- ((copy)) ((24 literal))) |
||||
run: main 5: 24 => ((4 integer)) |
||||
mem: ((4 integer)): 15 <= 24 |
||||
run: main 6: (((5 boolean)) <- ((copy)) ((t literal))) |
||||
run: main 6: t => ((5 boolean)) |
||||
mem: ((5 boolean)): 16 <= t |
||||
run: main 7: (((6 integer-boolean-pair-array-address)) <- ((copy)) ((12 literal))) |
||||
run: main 7: 12 => ((6 integer-boolean-pair-array-address)) |
||||
mem: ((6 integer-boolean-pair-array-address)): 17 <= 12 |
||||
run: main 8: (((7 integer-boolean-pair-array)) <- ((copy)) ((6 integer-boolean-pair-array-address) (deref))) |
||||
array-len: ((12 integer-boolean-pair-array) (raw)) |
||||
mem: ((12 integer) (raw)) => 2 |
||||
mem: ((6 integer-boolean-pair-array-address) (deref)) => #(tagged record (2 23 nil 24 t . nil)) |
||||
run: main 8: #(tagged record (2 23 nil 24 t . nil)) => ((7 integer-boolean-pair-array)) |
||||
mem: ((7 integer-boolean-pair-array)): 18 <= 2 |
||||
mem: ((7 integer-boolean-pair-array)): 19 <= 23 |
||||
mem: ((7 integer-boolean-pair-array)): 20 <= nil |
||||
mem: ((7 integer-boolean-pair-array)): 21 <= 24 |
||||
mem: ((7 integer-boolean-pair-array)): 22 <= t |
||||
schedule: done with routine nil |
@ -1,10 +0,0 @@
|
||||
c{0: 0 label1 -- ((open 0)) |
||||
c{0: 1 (((1 integer)) <- ((copy)) ((0 literal))) -- ((open 0)) |
||||
c{1: 1 ✓ (((1 integer)) <- ((copy)) ((0 literal))) |
||||
cn0: convert-names in f1 |
||||
cn0: (((1 integer)) <- ((copy)) ((0 literal))) nil nil |
||||
cn0: checking arg ((0 literal)) |
||||
cn0: checking oarg ((1 integer)) |
||||
maybe-add: ((1 integer)) |
||||
cn1: label1 |
||||
cn1: (((1 integer)) <- ((copy)) ((0 literal))) |
@ -1,10 +0,0 @@
|
||||
c{0: 0 label1 -- ((open 0)) |
||||
c{0: 1 (((1 integer)) <- ((copy)) ((0 literal))) -- ((open 0)) |
||||
c{1: 1 ✓ (((1 integer)) <- ((copy)) ((0 literal))) |
||||
cn0: convert-names in f1 |
||||
cn0: (((1 integer)) <- ((copy)) ((0 literal))) nil nil |
||||
cn0: checking arg ((0 literal)) |
||||
cn0: checking oarg ((1 integer)) |
||||
maybe-add: ((1 integer)) |
||||
cn1: label1 |
||||
cn1: (((1 integer)) <- ((copy)) ((0 literal))) |
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in new issue