1276 - make C++ version the default
I've tried to update the Readme, but there are at least a couple of issues.
This commit is contained in:
Kartik K. Agaram
parent
2e3b597fe8
commit
b96af395b9
111
Readme.md
111
Readme.md
|
|
@ -61,57 +61,53 @@ before we invest in the *visual* tools for making them concise.
|
|||
|
||||
**Taking Mu for a spin**
|
||||
|
||||
First install [Racket](http://racket-lang.org) (just for the initial
|
||||
prototype). Then:
|
||||
|
||||
```shell
|
||||
$ cd mu
|
||||
$ git clone http://github.com/arclanguage/anarki
|
||||
$ make test
|
||||
```
|
||||
|
||||
As a sneak peek, here's how you compute factorial in Mu:
|
||||
|
||||
```lisp
|
||||
function factorial [
|
||||
; allocate local variables
|
||||
default-space:space-address <- new space:literal, 30:literal
|
||||
; receive inputs in a queue
|
||||
n:integer <- next-input
|
||||
```python
|
||||
recipe factorial [
|
||||
default-space:address:array:location <- new location:type, 30:literal
|
||||
n:integer <- next-ingredient
|
||||
{
|
||||
; if n=0 return 1
|
||||
# if n=0 return 1
|
||||
zero?:boolean <- equal n:integer, 0:literal
|
||||
break-unless zero?:boolean
|
||||
reply 1:literal
|
||||
}
|
||||
; return n*factorial(n-1)
|
||||
tmp1:integer <- subtract n:integer, 1:literal
|
||||
tmp2:integer <- factorial tmp1:integer
|
||||
result:integer <- multiply n:integer, tmp2:integer
|
||||
# return n * factorial(n - 1)
|
||||
x:integer <- subtract n:integer, 1:literal
|
||||
subresult:integer <- factorial x:integer
|
||||
result:integer <- multiply subresult:integer, n:integer
|
||||
reply result:integer
|
||||
]
|
||||
```
|
||||
|
||||
Programs are lists of instructions, each on a line, sometimes grouped with
|
||||
brackets. Each instruction operates on some *operands* and returns some *results*.
|
||||
Mu functions or 'recipes' are lists of instructions, each on a line, sometimes
|
||||
grouped with brackets. Each instruction operates on some *ingredients* and
|
||||
returns some *results*.
|
||||
|
||||
```
|
||||
[results] <- instruction [operands]
|
||||
[results] <- instruction [ingredients]
|
||||
```
|
||||
|
||||
Result and operand values have to be simple; you can't nest operations. But
|
||||
you can have any number of values. In particular you can have any number of
|
||||
Result and ingredient *reagents* have to be simple; you can't nest operations.
|
||||
But you can have any number of them. In particular you can have any number of
|
||||
results. For example, you can perform integer division as follows:
|
||||
|
||||
```
|
||||
quotient:integer, remainder:integer <- divide-with-remainder 11:literal, 3:literal
|
||||
```
|
||||
|
||||
Each value provides its name as well as its type separated by a colon. Types
|
||||
Each reagent provides its name as well as its type separated by a colon. Types
|
||||
can be multiple words, like:
|
||||
|
||||
```lisp
|
||||
x:integer-array:3 ; x is an array of 3 integers
|
||||
y:list:integer ; y is a list of integers
|
||||
```python
|
||||
x:array:integer:3 # x is an array of 3 integers
|
||||
y:list:integer # y is a list of integers
|
||||
```
|
||||
|
||||
Try out the factorial program now:
|
||||
|
|
@ -119,25 +115,21 @@ Try out the factorial program now:
|
|||
```shell
|
||||
$ ./mu factorial.mu
|
||||
result: 120 # factorial of 5
|
||||
... # ignore the memory dump for now
|
||||
```
|
||||
|
||||
(The code in `factorial.mu` has a few more parentheses than the idealized
|
||||
syntax above. We'll drop them when we build a real parser.)
|
||||
|
||||
---
|
||||
|
||||
The name of a value is for humans, but what the computer needs to access it is
|
||||
The name of a reagent is for humans, but what the computer needs to access it is
|
||||
its address. Mu maps names to addresses for you like in other languages, but
|
||||
in a more transparent, lightweight, hackable manner. This instruction:
|
||||
|
||||
```lisp
|
||||
```python
|
||||
z:integer <- add x:integer, y:integer
|
||||
```
|
||||
|
||||
might turn into this:
|
||||
|
||||
```lisp
|
||||
```python
|
||||
3:integer <- add 1:integer, 2:integer
|
||||
```
|
||||
|
||||
|
|
@ -150,15 +142,15 @@ doesn't preserve uniqueness of addresses across functions, so you need to
|
|||
organize your names into spaces. At the start of each function (like
|
||||
`factorial` above), set its *default space*:
|
||||
|
||||
```lisp
|
||||
default-space:space-address <- new space:literal, 30:literal
|
||||
```python
|
||||
default-space:address:array:location <- new location:type, 30:literal
|
||||
```
|
||||
|
||||
Without this line, all variables in the function will be *global*, something
|
||||
you rarely want. (Luckily, this is also the sort of mistake that will be
|
||||
easily caught by tests. Later we'll automatically generate this boilerplate.)
|
||||
*With* this line, all addresses in your function will by default refer to one
|
||||
of the 30 slots inside this local space.
|
||||
of the 30 slots inside this local space. (If you need more, mu will complain.)
|
||||
|
||||
Spaces can do more than just implement local variables. You can string them
|
||||
together, pass them around, return them from functions, share them between
|
||||
|
|
@ -171,18 +163,18 @@ identical to it.)
|
|||
To string two spaces together, write one into slot 0 of the other. This
|
||||
instruction chains a space received from its caller:
|
||||
|
||||
```lisp
|
||||
0:space-address <- next-input
|
||||
```python
|
||||
0:address:array:location <- next-ingredient
|
||||
```
|
||||
|
||||
Once you've chained spaces together, you can access variables in them by
|
||||
adding a 'space' property to values:
|
||||
adding a 'space' property:
|
||||
|
||||
```lisp
|
||||
```python
|
||||
3:integer/space:1
|
||||
```
|
||||
|
||||
This value is the integer in slot 3 of the space chained in slot 0 of the
|
||||
This reagent is the integer in slot 3 of the space chained in slot 0 of the
|
||||
default space. We usually call it slot 3 in the 'next space'. `/space:2` would
|
||||
be the next space of the next space, and so on.
|
||||
|
||||
|
|
@ -193,11 +185,11 @@ in Mu provide the same functionality.
|
|||
|
||||
---
|
||||
|
||||
You can append arbitrary properties to values besides types and spaces. Just
|
||||
You can append arbitrary properties to reagents besides types and spaces. Just
|
||||
separate them with slashes.
|
||||
|
||||
```lisp
|
||||
x:integer-array:3/uninitialized
|
||||
```python
|
||||
x:array:integer:3/uninitialized
|
||||
y:string/tainted:yes
|
||||
z:list:integer/assign-once:true/assigned:false
|
||||
```
|
||||
|
|
@ -210,9 +202,9 @@ system permits and forces them to use, you'll learn to create new checks that
|
|||
make sense for your specific program. If it makes sense to perform different
|
||||
checks in different parts of your program, you'll be able to do that.
|
||||
|
||||
To summarize: Mu instructions have multiple operand and result values. Values
|
||||
can have multiple rows separated by slashes, and rows can have multiple
|
||||
columns separated by colons. The address of a value is always in the very
|
||||
To summarize: Mu instructions have multiple ingredient and result reagents.
|
||||
Values can have multiple rows separated by slashes, and rows can have multiple
|
||||
columns separated by colons. The address of a reagent is always in the very
|
||||
first column of the first row of its 'table'. You can visualize the last
|
||||
example above as:
|
||||
|
||||
|
|
@ -227,10 +219,10 @@ example above as:
|
|||
An alternative way to define factorial is by inserting *labels* and later
|
||||
inserting code at them.
|
||||
|
||||
```lisp
|
||||
function factorial [
|
||||
default-space:space-address <- new space:literal, 30:literal
|
||||
n:integer <- next-operand
|
||||
```python
|
||||
recipe factorial [
|
||||
default-space:address:array:location <- new location:type, 30:literal
|
||||
n:integer <- next-ingredient
|
||||
{
|
||||
base-case:
|
||||
}
|
||||
|
|
@ -238,17 +230,17 @@ inserting code at them.
|
|||
]
|
||||
|
||||
after base-case [
|
||||
; if n=0 return 1
|
||||
# if n=0 return 1
|
||||
zero?:boolean <- equal n:integer, 0:literal
|
||||
break-unless zero?:boolean
|
||||
reply 1:literal
|
||||
]
|
||||
|
||||
after recursive-case [
|
||||
; return n*factorial(n-1)
|
||||
tmp1:integer <- subtract n:integer, 1:literal
|
||||
tmp2:integer <- factorial tmp1:integer
|
||||
result:integer <- multiply n:integer, tmp2:integer
|
||||
# return n * factorial(n-1)
|
||||
x:integer <- subtract n:integer, 1:literal
|
||||
subresult:integer <- factorial x:integer
|
||||
result:integer <- multiply subresult:integer, n:integer
|
||||
reply result:integer
|
||||
]
|
||||
```
|
||||
|
|
@ -289,8 +281,6 @@ Yet another example forks two 'routines' that communicate over a channel:
|
|||
|
||||
# The exact order above might shift over time, but you'll never see a number
|
||||
# consumed before it's produced.
|
||||
|
||||
error - deadlock detected
|
||||
```
|
||||
|
||||
Channels are the unit of synchronization in Mu. Blocking on channels are the
|
||||
|
|
@ -304,21 +294,14 @@ random memory locations. Bounds checking is baked deeply into the semantics,
|
|||
and pointer arithmetic will be mostly forbidden (except inside the memory
|
||||
allocator and a few other places).
|
||||
|
||||
Notice also the error at the end. Mu can detect deadlock when running tests:
|
||||
routines waiting on channels that nobody will ever write to.
|
||||
|
||||
---
|
||||
|
||||
Try running the tests:
|
||||
|
||||
```shell
|
||||
$ ./mu test mu.arc.t
|
||||
$ # all tests passed!
|
||||
$ ./mu test
|
||||
```
|
||||
|
||||
Now start reading `mu.arc.t` to see how it works. A colorized copy of it is at
|
||||
`mu.arc.t.html` and http://akkartik.github.io/mu.
|
||||
|
||||
You might also want to peek in the `.traces` directory, which automatically
|
||||
includes logs for each test showing you just how it ran on my machine. If Mu
|
||||
eventually gets complex enough that you have trouble running examples, these
|
||||
|
|
|
|||
|
|
@ -0,0 +1,38 @@
|
|||
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
|
||||
|
|
@ -0,0 +1,14 @@
|
|||
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
|
||||
|
|
@ -0,0 +1,14 @@
|
|||
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
|
||||
|
|
@ -0,0 +1,43 @@
|
|||
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
|
||||
|
|
@ -0,0 +1,53 @@
|
|||
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
|
||||
|
|
@ -0,0 +1,46 @@
|
|||
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
|
||||
|
|
@ -0,0 +1,100 @@
|
|||
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
|
||||
|
|
@ -0,0 +1,10 @@
|
|||
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)))
|
||||
|
|
@ -0,0 +1,10 @@
|
|||
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)))
|
||||
|
|
@ -0,0 +1,91 @@
|
|||
c{0: 0 (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal) (capacity))) -- nil
|
||||
c{0: 1 (((1 channel-address)) <- ((init-channel)) ((3 literal))) -- nil
|
||||
c{0: 2 (((2 integer) (routine)) <- ((fork-helper)) ((reader fn)) ((default-space space-address) (globals)) ((50 literal) (limit))) -- nil
|
||||
c{1: 0 ✓ (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal) (capacity)))
|
||||
c{1: 1 ✓ (((1 channel-address)) <- ((init-channel)) ((3 literal)))
|
||||
c{1: 2 ✓ (((2 integer) (routine)) <- ((fork-helper)) ((reader fn)) ((default-space space-address) (globals)) ((50 literal) (limit)))
|
||||
c{0: 0 (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal) (capacity))) -- nil
|
||||
c{0: 1 (((x tagged-value)) ((1 channel-address) (space global)) <- ((read)) ((1 channel-address) (space global))) -- nil
|
||||
c{1: 0 ✓ (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal) (capacity)))
|
||||
c{1: 1 ✓ (((x tagged-value)) ((1 channel-address) (space global)) <- ((read)) ((1 channel-address) (space global)))
|
||||
cn0: convert-names in main
|
||||
cn0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal) (capacity))) nil nil
|
||||
cn0: checking arg ((space literal))
|
||||
cn0: checking arg ((30 literal) (capacity))
|
||||
cn0: checking oarg ((default-space space-address))
|
||||
maybe-add: ((default-space space-address))
|
||||
cn0: (((1 channel-address)) <- ((init-channel)) ((3 literal))) nil nil
|
||||
cn0: checking arg ((3 literal))
|
||||
cn0: checking oarg ((1 channel-address))
|
||||
maybe-add: ((1 channel-address))
|
||||
cn0: (((2 integer) (routine)) <- ((fork-helper)) ((reader fn)) ((default-space space-address) (globals)) ((50 literal) (limit))) nil nil
|
||||
cn0: checking arg ((reader fn))
|
||||
cn0: checking arg ((default-space space-address) (globals))
|
||||
maybe-add: ((default-space space-address) (globals))
|
||||
cn0: checking arg ((50 literal) (limit))
|
||||
cn0: checking oarg ((2 integer) (routine))
|
||||
maybe-add: ((2 integer) (routine))
|
||||
cn0: convert-names in reader
|
||||
cn0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal) (capacity))) nil nil
|
||||
cn0: checking arg ((space literal))
|
||||
cn0: checking arg ((30 literal) (capacity))
|
||||
cn0: checking oarg ((default-space space-address))
|
||||
maybe-add: ((default-space space-address))
|
||||
cn0: (((x tagged-value)) ((1 channel-address) (space global)) <- ((read)) ((1 channel-address) (space global))) nil nil
|
||||
cn0: checking arg ((1 channel-address) (space global))
|
||||
maybe-add: ((1 channel-address) (space global))
|
||||
cn0: checking oarg ((x tagged-value))
|
||||
maybe-add: ((x tagged-value))
|
||||
cn0: location for oarg ((x tagged-value)): 1
|
||||
cn0: checking oarg ((1 channel-address) (space global))
|
||||
maybe-add: ((1 channel-address) (space global))
|
||||
cn1: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal) (capacity)))
|
||||
cn1: (((1 channel-address)) <- ((init-channel)) ((3 literal)))
|
||||
cn1: (((2 integer) (routine)) <- ((fork-helper)) ((reader fn)) ((default-space space-address) (globals)) ((50 literal) (limit)))
|
||||
cn1: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal) (capacity)))
|
||||
cn1: (((1 tagged-value)) ((1 channel-address) (space global)) <- ((read)) ((1 channel-address) (space global)))
|
||||
schedule: main
|
||||
run: main 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal) (capacity)))
|
||||
run: main 0: 1000 => ((default-space space-address))
|
||||
run: main 1: (((1 channel-address)) <- ((init-channel)) ((3 literal)))
|
||||
run: init-channel/main 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
|
||||
run: init-channel/main 0: 1031 => ((default-space space-address))
|
||||
run: init-channel/main 1: (((1 channel-address)) <- ((new)) ((channel literal)))
|
||||
run: init-channel/main 1: 1062 => ((1 channel-address))
|
||||
mem: ((1 channel-address)): 1033 <= 1062
|
||||
run: init-channel/main 2: (((2 integer-address)) <- ((get-address)) ((1 channel-address) (deref)) ((0 offset)))
|
||||
run: init-channel/main 2: 1062 => ((2 integer-address))
|
||||
mem: ((2 integer-address)): 1034 <= 1062
|
||||
run: init-channel/main 3: (((2 integer-address) (deref)) <- ((copy)) ((0 literal)))
|
||||
run: init-channel/main 3: 0 => ((2 integer-address) (deref))
|
||||
mem: ((2 integer-address) (deref)): 1062 <= 0
|
||||
run: init-channel/main 4: (((3 integer-address)) <- ((get-address)) ((1 channel-address) (deref)) ((1 offset)))
|
||||
run: init-channel/main 4: 1063 => ((3 integer-address))
|
||||
mem: ((3 integer-address)): 1035 <= 1063
|
||||
run: init-channel/main 5: (((3 integer-address) (deref)) <- ((copy)) ((0 literal)))
|
||||
run: init-channel/main 5: 0 => ((3 integer-address) (deref))
|
||||
mem: ((3 integer-address) (deref)): 1063 <= 0
|
||||
run: init-channel/main 6: (((4 integer)) <- ((next-input)))
|
||||
arg: nil 0 (3)
|
||||
run: init-channel/main 6: 3 => ((4 integer))
|
||||
mem: ((4 integer)): 1036 <= 3
|
||||
run: init-channel/main 7: (((4 integer)) <- ((add)) ((4 integer)) ((1 literal)))
|
||||
mem: ((4 integer)) => 3
|
||||
run: init-channel/main 7: 4 => ((4 integer))
|
||||
mem: ((4 integer)): 1036 <= 4
|
||||
run: init-channel/main 8: (((5 tagged-value-array-address-address)) <- ((get-address)) ((1 channel-address) (deref)) ((2 offset)))
|
||||
run: init-channel/main 8: 1064 => ((5 tagged-value-array-address-address))
|
||||
mem: ((5 tagged-value-array-address-address)): 1037 <= 1064
|
||||
run: init-channel/main 9: (((5 tagged-value-array-address-address) (deref)) <- ((new)) ((tagged-value-array literal)) ((4 integer)))
|
||||
mem: ((4 integer)) => 4
|
||||
run: init-channel/main 9: 1065 => ((5 tagged-value-array-address-address) (deref))
|
||||
mem: ((5 tagged-value-array-address-address) (deref)): 1064 <= 1065
|
||||
run: init-channel/main 10: (((reply)) ((1 channel-address)))
|
||||
mem: ((1 channel-address)) => 1062
|
||||
run: main 1: 1062 => ((1 channel-address))
|
||||
mem: ((1 channel-address)): 1002 <= 1062
|
||||
run: main 2: (((2 integer) (routine)) <- ((fork-helper)) ((reader fn)) ((default-space space-address) (globals)) ((50 literal) (limit)))
|
||||
run: main 2: 1 => ((2 integer) (routine))
|
||||
mem: ((2 integer) (routine)): 1003 <= 1
|
||||
schedule: done with routine nil
|
||||
schedule: just helpers left; stopping everything
|
||||
|
|
@ -0,0 +1,12 @@
|
|||
c{0: 0 (((1 integer)) <- ((copy)) ((0 literal))) -- nil
|
||||
c{0: 1 (((break)) ((2 blocks))) -- ((open 1) (open 1))
|
||||
c{0: 2 (((2 integer)) <- ((copy)) ((0 literal))) -- ((close 2) (open 1) (open 1))
|
||||
c{0: 3 (((3 integer)) <- ((copy)) ((0 literal))) -- ((close 2) (open 1) (open 1))
|
||||
c{0: 4 (((4 integer)) <- ((copy)) ((0 literal))) -- ((close 2) (open 1) (open 1))
|
||||
c{0: 5 (((5 integer)) <- ((copy)) ((0 literal))) -- ((close 2) (open 1) (open 1))
|
||||
c{1: 0 ✓ (((1 integer)) <- ((copy)) ((0 literal)))
|
||||
c{1: 1 X (((break)) ((2 blocks))) => (((jump)) ((4 offset)))
|
||||
c{1: 2 ✓ (((2 integer)) <- ((copy)) ((0 literal)))
|
||||
c{1: 3 ✓ (((3 integer)) <- ((copy)) ((0 literal)))
|
||||
c{1: 4 ✓ (((4 integer)) <- ((copy)) ((0 literal)))
|
||||
c{1: 5 ✓ (((5 integer)) <- ((copy)) ((0 literal)))
|
||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
|
|
@ -0,0 +1,335 @@
|
|||
c{0: 0 (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal))) -- nil
|
||||
c{0: 1 (((chan channel-address)) <- ((init-channel)) ((3 literal))) -- nil
|
||||
c{0: 2 (((fork)) ((producer fn)) ((nil literal) (globals)) ((nil literal) (limit)) ((chan channel-address))) -- nil
|
||||
c{0: 3 (((1 tagged-value) (raw)) <- ((read)) ((chan channel-address))) -- nil
|
||||
c{1: 0 ✓ (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
|
||||
c{1: 1 ✓ (((chan channel-address)) <- ((init-channel)) ((3 literal)))
|
||||
c{1: 2 ✓ (((fork)) ((producer fn)) ((nil literal) (globals)) ((nil literal) (limit)) ((chan channel-address)))
|
||||
c{1: 3 ✓ (((1 tagged-value) (raw)) <- ((read)) ((chan channel-address)))
|
||||
c{0: 0 (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal))) -- nil
|
||||
c{0: 1 (((n integer)) <- ((copy)) ((24 literal))) -- nil
|
||||
c{0: 2 (((ochan channel-address)) <- ((next-input))) -- nil
|
||||
c{0: 3 (((x tagged-value)) <- ((save-type)) ((n integer))) -- nil
|
||||
c{0: 4 (((ochan channel-address) (deref)) <- ((write)) ((ochan channel-address)) ((x tagged-value))) -- nil
|
||||
c{1: 0 ✓ (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
|
||||
c{1: 1 ✓ (((n integer)) <- ((copy)) ((24 literal)))
|
||||
c{1: 2 ✓ (((ochan channel-address)) <- ((next-input)))
|
||||
c{1: 3 ✓ (((x tagged-value)) <- ((save-type)) ((n integer)))
|
||||
c{1: 4 ✓ (((ochan channel-address) (deref)) <- ((write)) ((ochan channel-address)) ((x tagged-value)))
|
||||
cn0: convert-names in consumer
|
||||
cn0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal))) nil nil
|
||||
cn0: checking arg ((space literal))
|
||||
cn0: checking arg ((30 literal))
|
||||
cn0: checking oarg ((default-space space-address))
|
||||
maybe-add: ((default-space space-address))
|
||||
cn0: (((chan channel-address)) <- ((init-channel)) ((3 literal))) nil nil
|
||||
cn0: checking arg ((3 literal))
|
||||
cn0: checking oarg ((chan channel-address))
|
||||
maybe-add: ((chan channel-address))
|
||||
cn0: location for oarg ((chan channel-address)): 1
|
||||
cn0: (((fork)) ((producer fn)) ((nil literal) (globals)) ((nil literal) (limit)) ((chan channel-address))) ((chan 1)) nil
|
||||
cn0: checking arg ((producer fn))
|
||||
cn0: checking arg ((nil literal) (globals))
|
||||
cn0: checking arg ((nil literal) (limit))
|
||||
cn0: checking arg ((chan channel-address))
|
||||
maybe-add: ((chan channel-address))
|
||||
cn0: (((1 tagged-value) (raw)) <- ((read)) ((chan channel-address))) ((chan 1)) nil
|
||||
cn0: checking arg ((chan channel-address))
|
||||
maybe-add: ((chan channel-address))
|
||||
cn0: checking oarg ((1 tagged-value) (raw))
|
||||
maybe-add: ((1 tagged-value) (raw))
|
||||
cn0: convert-names in producer
|
||||
cn0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal))) nil nil
|
||||
cn0: checking arg ((space literal))
|
||||
cn0: checking arg ((30 literal))
|
||||
cn0: checking oarg ((default-space space-address))
|
||||
maybe-add: ((default-space space-address))
|
||||
cn0: (((n integer)) <- ((copy)) ((24 literal))) nil nil
|
||||
cn0: checking arg ((24 literal))
|
||||
cn0: checking oarg ((n integer))
|
||||
maybe-add: ((n integer))
|
||||
cn0: location for oarg ((n integer)): 1
|
||||
cn0: (((ochan channel-address)) <- ((next-input))) ((n 1)) nil
|
||||
cn0: checking oarg ((ochan channel-address))
|
||||
maybe-add: ((ochan channel-address))
|
||||
cn0: location for oarg ((ochan channel-address)): 2
|
||||
cn0: (((x tagged-value)) <- ((save-type)) ((n integer))) ((n 1) (ochan 2)) nil
|
||||
cn0: checking arg ((n integer))
|
||||
maybe-add: ((n integer))
|
||||
cn0: checking oarg ((x tagged-value))
|
||||
maybe-add: ((x tagged-value))
|
||||
cn0: location for oarg ((x tagged-value)): 3
|
||||
cn0: (((ochan channel-address) (deref)) <- ((write)) ((ochan channel-address)) ((x tagged-value))) ((n 1) (ochan 2) (x 3)) nil
|
||||
cn0: checking arg ((ochan channel-address))
|
||||
maybe-add: ((ochan channel-address))
|
||||
cn0: checking arg ((x tagged-value))
|
||||
maybe-add: ((x tagged-value))
|
||||
cn0: checking oarg ((ochan channel-address) (deref))
|
||||
maybe-add: ((ochan channel-address) (deref))
|
||||
cn1: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
|
||||
cn1: (((1 channel-address)) <- ((init-channel)) ((3 literal)))
|
||||
cn1: (((fork)) ((producer fn)) ((nil literal) (globals)) ((nil literal) (limit)) ((1 channel-address)))
|
||||
cn1: (((1 tagged-value) (raw)) <- ((read)) ((1 channel-address)))
|
||||
cn1: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
|
||||
cn1: (((1 integer)) <- ((copy)) ((24 literal)))
|
||||
cn1: (((2 channel-address)) <- ((next-input)))
|
||||
cn1: (((3 tagged-value)) <- ((save-type)) ((1 integer)))
|
||||
cn1: (((2 channel-address) (deref)) <- ((write)) ((2 channel-address)) ((3 tagged-value)))
|
||||
schedule: consumer
|
||||
run: consumer 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
|
||||
run: consumer 0: 1000 => ((default-space space-address))
|
||||
run: consumer 1: (((1 channel-address)) <- ((init-channel)) ((3 literal)))
|
||||
run: init-channel/consumer 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
|
||||
run: init-channel/consumer 0: 1031 => ((default-space space-address))
|
||||
run: init-channel/consumer 1: (((1 channel-address)) <- ((new)) ((channel literal)))
|
||||
run: init-channel/consumer 1: 1062 => ((1 channel-address))
|
||||
mem: ((1 channel-address)): 1033 <= 1062
|
||||
run: init-channel/consumer 2: (((2 integer-address)) <- ((get-address)) ((1 channel-address) (deref)) ((0 offset)))
|
||||
run: init-channel/consumer 2: 1062 => ((2 integer-address))
|
||||
mem: ((2 integer-address)): 1034 <= 1062
|
||||
run: init-channel/consumer 3: (((2 integer-address) (deref)) <- ((copy)) ((0 literal)))
|
||||
run: init-channel/consumer 3: 0 => ((2 integer-address) (deref))
|
||||
mem: ((2 integer-address) (deref)): 1062 <= 0
|
||||
run: init-channel/consumer 4: (((3 integer-address)) <- ((get-address)) ((1 channel-address) (deref)) ((1 offset)))
|
||||
run: init-channel/consumer 4: 1063 => ((3 integer-address))
|
||||
mem: ((3 integer-address)): 1035 <= 1063
|
||||
run: init-channel/consumer 5: (((3 integer-address) (deref)) <- ((copy)) ((0 literal)))
|
||||
run: init-channel/consumer 5: 0 => ((3 integer-address) (deref))
|
||||
mem: ((3 integer-address) (deref)): 1063 <= 0
|
||||
run: init-channel/consumer 6: (((4 integer)) <- ((next-input)))
|
||||
arg: nil 0 (3)
|
||||
run: init-channel/consumer 6: 3 => ((4 integer))
|
||||
mem: ((4 integer)): 1036 <= 3
|
||||
run: init-channel/consumer 7: (((4 integer)) <- ((add)) ((4 integer)) ((1 literal)))
|
||||
mem: ((4 integer)) => 3
|
||||
run: init-channel/consumer 7: 4 => ((4 integer))
|
||||
mem: ((4 integer)): 1036 <= 4
|
||||
run: init-channel/consumer 8: (((5 tagged-value-array-address-address)) <- ((get-address)) ((1 channel-address) (deref)) ((2 offset)))
|
||||
run: init-channel/consumer 8: 1064 => ((5 tagged-value-array-address-address))
|
||||
mem: ((5 tagged-value-array-address-address)): 1037 <= 1064
|
||||
run: init-channel/consumer 9: (((5 tagged-value-array-address-address) (deref)) <- ((new)) ((tagged-value-array literal)) ((4 integer)))
|
||||
mem: ((4 integer)) => 4
|
||||
run: init-channel/consumer 9: 1065 => ((5 tagged-value-array-address-address) (deref))
|
||||
mem: ((5 tagged-value-array-address-address) (deref)): 1064 <= 1065
|
||||
run: init-channel/consumer 10: (((reply)) ((1 channel-address)))
|
||||
mem: ((1 channel-address)) => 1062
|
||||
run: consumer 1: 1062 => ((1 channel-address))
|
||||
mem: ((1 channel-address)): 1002 <= 1062
|
||||
run: consumer 2: (((fork)) ((producer fn)) ((nil literal) (globals)) ((nil literal) (limit)) ((1 channel-address)))
|
||||
mem: ((1 channel-address)) => 1062
|
||||
run: consumer 3: (((1 tagged-value) (raw)) <- ((read)) ((1 channel-address)))
|
||||
mem: ((1 channel-address)) => 1062
|
||||
run: read/consumer 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
|
||||
run: read/consumer 0: 1074 => ((default-space space-address))
|
||||
run: read/consumer 1: (((1 channel-address)) <- ((next-input)))
|
||||
arg: nil 0 (1062)
|
||||
run: read/consumer 1: 1062 => ((1 channel-address))
|
||||
mem: ((1 channel-address)): 1076 <= 1062
|
||||
run: read/consumer 2: (((2 boolean)) <- ((empty?)) ((1 channel-address) (deref)))
|
||||
mem: ((1 channel-address) (deref)) => #(tagged record (0 0 1065 . nil))
|
||||
run: empty?/read/consumer 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
|
||||
run: empty?/read/consumer 0: 1105 => ((default-space space-address))
|
||||
run: empty?/read/consumer 1: (((1 channel)) <- ((next-input)))
|
||||
arg: nil 0 (#(tagged record (0 0 1065 . nil)))
|
||||
run: empty?/read/consumer 1: #(tagged record (0 0 1065 . nil)) => ((1 channel))
|
||||
mem: ((1 channel)): 1107 <= 0
|
||||
mem: ((1 channel)): 1108 <= 0
|
||||
mem: ((1 channel)): 1109 <= 1065
|
||||
run: empty?/read/consumer 2: (((4 integer)) <- ((get)) ((1 channel)) ((0 offset)))
|
||||
mem: ((1107 integer) (raw)) => 0
|
||||
run: empty?/read/consumer 2: 0 => ((4 integer))
|
||||
mem: ((4 integer)): 1110 <= 0
|
||||
run: empty?/read/consumer 3: (((5 integer)) <- ((get)) ((1 channel)) ((1 offset)))
|
||||
mem: ((1108 integer) (raw)) => 0
|
||||
run: empty?/read/consumer 3: 0 => ((5 integer))
|
||||
mem: ((5 integer)): 1111 <= 0
|
||||
run: empty?/read/consumer 4: (((6 boolean)) <- ((equal)) ((4 integer)) ((5 integer)))
|
||||
mem: ((4 integer)) => 0
|
||||
mem: ((5 integer)) => 0
|
||||
run: empty?/read/consumer 4: t => ((6 boolean))
|
||||
mem: ((6 boolean)): 1112 <= t
|
||||
run: empty?/read/consumer 5: (((reply)) ((6 boolean)))
|
||||
mem: ((6 boolean)) => t
|
||||
run: read/consumer 2: t => ((2 boolean))
|
||||
mem: ((2 boolean)): 1077 <= t
|
||||
run: read/consumer 3: (((jump-unless)) ((2 boolean)) ((2 offset)))
|
||||
mem: ((2 boolean)) => t
|
||||
run: read/consumer 4: (((3 integer-address)) <- ((get-address)) ((1 channel-address) (deref)) ((1 offset)))
|
||||
run: read/consumer 4: 1063 => ((3 integer-address))
|
||||
mem: ((3 integer-address)): 1078 <= 1063
|
||||
run: read/consumer 5: (((sleep)) ((until-location-changes literal)) ((3 integer-address) (deref)))
|
||||
mem: ((3 integer-address) (deref)) => 0
|
||||
schedule: pushing read/consumer to sleep queue
|
||||
schedule: producer
|
||||
run: producer 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
|
||||
run: producer 0: 101000 => ((default-space space-address))
|
||||
run: producer 1: (((1 integer)) <- ((copy)) ((24 literal)))
|
||||
run: producer 1: 24 => ((1 integer))
|
||||
mem: ((1 integer)): 101002 <= 24
|
||||
run: producer 2: (((2 channel-address)) <- ((next-input)))
|
||||
arg: nil 0 (1062)
|
||||
run: producer 2: 1062 => ((2 channel-address))
|
||||
mem: ((2 channel-address)): 101003 <= 1062
|
||||
run: producer 3: (((3 tagged-value)) <- ((save-type)) ((1 integer)))
|
||||
mem: ((1 integer)) => 24
|
||||
run: producer 3: #(tagged record (integer 24)) => ((3 tagged-value))
|
||||
mem: ((3 tagged-value)): 101004 <= integer
|
||||
mem: ((3 tagged-value)): 101005 <= 24
|
||||
run: producer 4: (((2 channel-address) (deref)) <- ((write)) ((2 channel-address)) ((3 tagged-value)))
|
||||
mem: ((2 channel-address)) => 1062
|
||||
mem: ((3 tagged-value)) => #(tagged record (integer 24 . nil))
|
||||
run: write/producer 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
|
||||
run: write/producer 0: 101031 => ((default-space space-address))
|
||||
run: write/producer 1: (((1 channel-address)) <- ((next-input)))
|
||||
arg: nil 0 (1062 #(tagged record (integer 24 . nil)))
|
||||
run: write/producer 1: 1062 => ((1 channel-address))
|
||||
mem: ((1 channel-address)): 101033 <= 1062
|
||||
run: write/producer 2: (((2 tagged-value)) <- ((next-input)))
|
||||
arg: nil 1 (1062 #(tagged record (integer 24 . nil)))
|
||||
run: write/producer 2: #(tagged record (integer 24 . nil)) => ((2 tagged-value))
|
||||
mem: ((2 tagged-value)): 101034 <= integer
|
||||
mem: ((2 tagged-value)): 101035 <= 24
|
||||
run: write/producer 3: (((4 boolean)) <- ((full?)) ((1 channel-address) (deref)))
|
||||
mem: ((1 channel-address) (deref)) => #(tagged record (0 0 1065 . nil))
|
||||
run: full?/write/producer 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
|
||||
run: full?/write/producer 0: 101062 => ((default-space space-address))
|
||||
run: full?/write/producer 1: (((1 channel)) <- ((next-input)))
|
||||
arg: nil 0 (#(tagged record (0 0 1065 . nil)))
|
||||
run: full?/write/producer 1: #(tagged record (0 0 1065 . nil)) => ((1 channel))
|
||||
mem: ((1 channel)): 101064 <= 0
|
||||
mem: ((1 channel)): 101065 <= 0
|
||||
mem: ((1 channel)): 101066 <= 1065
|
||||
run: full?/write/producer 2: (((4 integer)) <- ((get)) ((1 channel)) ((1 offset)))
|
||||
mem: ((101065 integer) (raw)) => 0
|
||||
run: full?/write/producer 2: 0 => ((4 integer))
|
||||
mem: ((4 integer)): 101067 <= 0
|
||||
run: full?/write/producer 3: (((4 integer)) <- ((add)) ((4 integer)) ((1 literal)))
|
||||
mem: ((4 integer)) => 0
|
||||
run: full?/write/producer 3: 1 => ((4 integer))
|
||||
mem: ((4 integer)): 101067 <= 1
|
||||
run: full?/write/producer 4: (((5 integer)) <- ((capacity)) ((1 channel)))
|
||||
mem: ((1 channel)) => #(tagged record (0 0 1065 . nil))
|
||||
run: capacity/full?/write/producer 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
|
||||
run: capacity/full?/write/producer 0: 101093 => ((default-space space-address))
|
||||
run: capacity/full?/write/producer 1: (((1 channel)) <- ((next-input)))
|
||||
arg: nil 0 (#(tagged record (0 0 1065 . nil)))
|
||||
run: capacity/full?/write/producer 1: #(tagged record (0 0 1065 . nil)) => ((1 channel))
|
||||
mem: ((1 channel)): 101095 <= 0
|
||||
mem: ((1 channel)): 101096 <= 0
|
||||
mem: ((1 channel)): 101097 <= 1065
|
||||
run: capacity/full?/write/producer 2: (((4 tagged-value-array-address)) <- ((get)) ((1 channel)) ((2 offset)))
|
||||
mem: ((101097 tagged-value-array-address) (raw)) => 1065
|
||||
run: capacity/full?/write/producer 2: 1065 => ((4 tagged-value-array-address))
|
||||
mem: ((4 tagged-value-array-address)): 101098 <= 1065
|
||||
run: capacity/full?/write/producer 3: (((5 integer)) <- ((length)) ((4 tagged-value-array-address) (deref)))
|
||||
array-len: ((4 tagged-value-array-address) (deref))
|
||||
mem: ((1065 integer) (raw)) => 4
|
||||
run: capacity/full?/write/producer 3: 4 => ((5 integer))
|
||||
mem: ((5 integer)): 101099 <= 4
|
||||
run: capacity/full?/write/producer 4: (((reply)) ((5 integer)))
|
||||
mem: ((5 integer)) => 4
|
||||
run: full?/write/producer 4: 4 => ((5 integer))
|
||||
mem: ((5 integer)): 101068 <= 4
|
||||
run: full?/write/producer 5: (((6 boolean)) <- ((less-than)) ((4 integer)) ((5 integer)))
|
||||
mem: ((4 integer)) => 1
|
||||
mem: ((5 integer)) => 4
|
||||
run: full?/write/producer 5: t => ((6 boolean))
|
||||
mem: ((6 boolean)): 101069 <= t
|
||||
run: full?/write/producer 6: (((jump-if)) ((6 boolean)) ((1 offset)))
|
||||
mem: ((6 boolean)) => t
|
||||
run: full?/write/producer 8: (((7 integer)) <- ((get)) ((1 channel)) ((0 offset)))
|
||||
mem: ((101064 integer) (raw)) => 0
|
||||
run: full?/write/producer 8: 0 => ((7 integer))
|
||||
mem: ((7 integer)): 101070 <= 0
|
||||
run: full?/write/producer 9: (((8 boolean)) <- ((equal)) ((7 integer)) ((4 integer)))
|
||||
mem: ((7 integer)) => 0
|
||||
mem: ((4 integer)) => 1
|
||||
run: full?/write/producer 9: nil => ((8 boolean))
|
||||
mem: ((8 boolean)): 101071 <= nil
|
||||
run: full?/write/producer 10: (((reply)) ((8 boolean)))
|
||||
mem: ((8 boolean)) => nil
|
||||
run: write/producer 3: nil => ((4 boolean))
|
||||
mem: ((4 boolean)): 101036 <= nil
|
||||
run: write/producer 4: (((jump-unless)) ((4 boolean)) ((2 offset)))
|
||||
mem: ((4 boolean)) => nil
|
||||
run: write/producer 7: (((6 tagged-value-array-address)) <- ((get)) ((1 channel-address) (deref)) ((2 offset)))
|
||||
mem: ((1064 tagged-value-array-address) (raw)) => 1065
|
||||
run: write/producer 7: 1065 => ((6 tagged-value-array-address))
|
||||
mem: ((6 tagged-value-array-address)): 101038 <= 1065
|
||||
run: write/producer 8: (((7 integer-address)) <- ((get-address)) ((1 channel-address) (deref)) ((1 offset)))
|
||||
run: write/producer 8: 1063 => ((7 integer-address))
|
||||
mem: ((7 integer-address)): 101039 <= 1063
|
||||
run: write/producer 9: (((8 tagged-value-address)) <- ((index-address)) ((6 tagged-value-array-address) (deref)) ((7 integer-address) (deref)))
|
||||
mem: ((7 integer-address) (deref)) => 0
|
||||
array-len: ((1065 tagged-value-array) (raw))
|
||||
mem: ((1065 integer) (raw)) => 4
|
||||
run: write/producer 9: 1066 => ((8 tagged-value-address))
|
||||
mem: ((8 tagged-value-address)): 101040 <= 1066
|
||||
run: write/producer 10: (((8 tagged-value-address) (deref)) <- ((copy)) ((2 tagged-value)))
|
||||
mem: ((2 tagged-value)) => #(tagged record (integer 24 . nil))
|
||||
run: write/producer 10: #(tagged record (integer 24 . nil)) => ((8 tagged-value-address) (deref))
|
||||
mem: ((8 tagged-value-address) (deref)): 1066 <= integer
|
||||
mem: ((8 tagged-value-address) (deref)): 1067 <= 24
|
||||
run: write/producer 11: (((7 integer-address) (deref)) <- ((add)) ((7 integer-address) (deref)) ((1 literal)))
|
||||
mem: ((7 integer-address) (deref)) => 0
|
||||
run: write/producer 11: 1 => ((7 integer-address) (deref))
|
||||
mem: ((7 integer-address) (deref)): 1063 <= 1
|
||||
run: write/producer 12: (((9 integer)) <- ((length)) ((6 tagged-value-array-address) (deref)))
|
||||
array-len: ((6 tagged-value-array-address) (deref))
|
||||
mem: ((1065 integer) (raw)) => 4
|
||||
run: write/producer 12: 4 => ((9 integer))
|
||||
mem: ((9 integer)): 101041 <= 4
|
||||
run: write/producer 13: (((10 boolean)) <- ((less-than)) ((7 integer-address) (deref)) ((9 integer)))
|
||||
mem: ((7 integer-address) (deref)) => 1
|
||||
mem: ((9 integer)) => 4
|
||||
run: write/producer 13: t => ((10 boolean))
|
||||
mem: ((10 boolean)): 101042 <= t
|
||||
run: write/producer 14: (((jump-if)) ((10 boolean)) ((1 offset)))
|
||||
mem: ((10 boolean)) => t
|
||||
run: write/producer 16: (((reply)) ((1 channel-address) (deref) (same-as-arg 0)))
|
||||
mem: ((1 channel-address) (deref) (same-as-arg 0)) => #(tagged record (0 1 1065 . nil))
|
||||
run: producer 4: #(tagged record (0 1 1065 . nil)) => ((2 channel-address) (deref))
|
||||
mem: ((2 channel-address) (deref)): 1062 <= 0
|
||||
mem: ((2 channel-address) (deref)): 1063 <= 1
|
||||
mem: ((2 channel-address) (deref)): 1064 <= 1065
|
||||
schedule: done with routine nil
|
||||
schedule: waking up read/consumer
|
||||
schedule: read/consumer
|
||||
run: read/consumer 6: (((4 integer-address)) <- ((get-address)) ((1 channel-address) (deref)) ((0 offset)))
|
||||
run: read/consumer 6: 1062 => ((4 integer-address))
|
||||
mem: ((4 integer-address)): 1079 <= 1062
|
||||
run: read/consumer 7: (((5 tagged-value-array-address)) <- ((get)) ((1 channel-address) (deref)) ((2 offset)))
|
||||
mem: ((1064 tagged-value-array-address) (raw)) => 1065
|
||||
run: read/consumer 7: 1065 => ((5 tagged-value-array-address))
|
||||
mem: ((5 tagged-value-array-address)): 1080 <= 1065
|
||||
run: read/consumer 8: (((6 tagged-value)) <- ((index)) ((5 tagged-value-array-address) (deref)) ((4 integer-address) (deref)))
|
||||
mem: ((4 integer-address) (deref)) => 0
|
||||
array-len: ((1065 tagged-value-array) (raw))
|
||||
mem: ((1065 integer) (raw)) => 4
|
||||
mem: ((1066 tagged-value) (raw)) => #(tagged record (integer 24 . nil))
|
||||
run: read/consumer 8: #(tagged record (integer 24 . nil)) => ((6 tagged-value))
|
||||
mem: ((6 tagged-value)): 1081 <= integer
|
||||
mem: ((6 tagged-value)): 1082 <= 24
|
||||
run: read/consumer 9: (((4 integer-address) (deref)) <- ((add)) ((4 integer-address) (deref)) ((1 literal)))
|
||||
mem: ((4 integer-address) (deref)) => 0
|
||||
run: read/consumer 9: 1 => ((4 integer-address) (deref))
|
||||
mem: ((4 integer-address) (deref)): 1062 <= 1
|
||||
run: read/consumer 10: (((8 integer)) <- ((length)) ((5 tagged-value-array-address) (deref)))
|
||||
array-len: ((5 tagged-value-array-address) (deref))
|
||||
mem: ((1065 integer) (raw)) => 4
|
||||
run: read/consumer 10: 4 => ((8 integer))
|
||||
mem: ((8 integer)): 1083 <= 4
|
||||
run: read/consumer 11: (((9 boolean)) <- ((less-than)) ((4 integer-address) (deref)) ((8 integer)))
|
||||
mem: ((4 integer-address) (deref)) => 1
|
||||
mem: ((8 integer)) => 4
|
||||
run: read/consumer 11: t => ((9 boolean))
|
||||
mem: ((9 boolean)): 1084 <= t
|
||||
run: read/consumer 12: (((jump-if)) ((9 boolean)) ((1 offset)))
|
||||
mem: ((9 boolean)) => t
|
||||
run: read/consumer 14: (((reply)) ((6 tagged-value)) ((1 channel-address) (deref) (same-as-arg 0)))
|
||||
mem: ((6 tagged-value)) => #(tagged record (integer 24 . nil))
|
||||
mem: ((1 channel-address) (deref) (same-as-arg 0)) => #(tagged record (1 1 1065 . nil))
|
||||
run: consumer 3: #(tagged record (integer 24 . nil)) => ((1 tagged-value) (raw))
|
||||
mem: ((1 tagged-value) (raw)): 1 <= integer
|
||||
mem: ((1 tagged-value) (raw)): 2 <= 24
|
||||
schedule: done with routine nil
|
||||
|
|
@ -0,0 +1,321 @@
|
|||
c{0: 0 (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal))) -- nil
|
||||
c{0: 1 (((1 channel-address)) <- ((init-channel)) ((3 literal))) -- nil
|
||||
c{0: 2 (((fork)) ((producer fn)) ((default-space space-address) (globals)) ((nil literal) (limit))) -- nil
|
||||
c{0: 3 (((1 tagged-value) (raw)) <- ((read)) ((1 channel-address))) -- nil
|
||||
c{1: 0 ✓ (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
|
||||
c{1: 1 ✓ (((1 channel-address)) <- ((init-channel)) ((3 literal)))
|
||||
c{1: 2 ✓ (((fork)) ((producer fn)) ((default-space space-address) (globals)) ((nil literal) (limit)))
|
||||
c{1: 3 ✓ (((1 tagged-value) (raw)) <- ((read)) ((1 channel-address)))
|
||||
c{0: 0 (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal))) -- nil
|
||||
c{0: 1 (((n integer)) <- ((copy)) ((24 literal))) -- nil
|
||||
c{0: 2 (((x tagged-value)) <- ((save-type)) ((n integer))) -- nil
|
||||
c{0: 3 (((1 channel-address) (space global) (deref)) <- ((write)) ((1 channel-address) (space global)) ((x tagged-value))) -- nil
|
||||
c{1: 0 ✓ (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
|
||||
c{1: 1 ✓ (((n integer)) <- ((copy)) ((24 literal)))
|
||||
c{1: 2 ✓ (((x tagged-value)) <- ((save-type)) ((n integer)))
|
||||
c{1: 3 ✓ (((1 channel-address) (space global) (deref)) <- ((write)) ((1 channel-address) (space global)) ((x tagged-value)))
|
||||
cn0: convert-names in consumer
|
||||
cn0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal))) nil nil
|
||||
cn0: checking arg ((space literal))
|
||||
cn0: checking arg ((30 literal))
|
||||
cn0: checking oarg ((default-space space-address))
|
||||
maybe-add: ((default-space space-address))
|
||||
cn0: (((1 channel-address)) <- ((init-channel)) ((3 literal))) nil nil
|
||||
cn0: checking arg ((3 literal))
|
||||
cn0: checking oarg ((1 channel-address))
|
||||
maybe-add: ((1 channel-address))
|
||||
cn0: (((fork)) ((producer fn)) ((default-space space-address) (globals)) ((nil literal) (limit))) nil nil
|
||||
cn0: checking arg ((producer fn))
|
||||
cn0: checking arg ((default-space space-address) (globals))
|
||||
maybe-add: ((default-space space-address) (globals))
|
||||
cn0: checking arg ((nil literal) (limit))
|
||||
cn0: (((1 tagged-value) (raw)) <- ((read)) ((1 channel-address))) nil nil
|
||||
cn0: checking arg ((1 channel-address))
|
||||
maybe-add: ((1 channel-address))
|
||||
cn0: checking oarg ((1 tagged-value) (raw))
|
||||
maybe-add: ((1 tagged-value) (raw))
|
||||
cn0: convert-names in producer
|
||||
cn0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal))) nil nil
|
||||
cn0: checking arg ((space literal))
|
||||
cn0: checking arg ((30 literal))
|
||||
cn0: checking oarg ((default-space space-address))
|
||||
maybe-add: ((default-space space-address))
|
||||
cn0: (((n integer)) <- ((copy)) ((24 literal))) nil nil
|
||||
cn0: checking arg ((24 literal))
|
||||
cn0: checking oarg ((n integer))
|
||||
maybe-add: ((n integer))
|
||||
cn0: location for oarg ((n integer)): 1
|
||||
cn0: (((x tagged-value)) <- ((save-type)) ((n integer))) ((n 1)) nil
|
||||
cn0: checking arg ((n integer))
|
||||
maybe-add: ((n integer))
|
||||
cn0: checking oarg ((x tagged-value))
|
||||
maybe-add: ((x tagged-value))
|
||||
cn0: location for oarg ((x tagged-value)): 2
|
||||
cn0: (((1 channel-address) (space global) (deref)) <- ((write)) ((1 channel-address) (space global)) ((x tagged-value))) ((n 1) (x 2)) nil
|
||||
cn0: checking arg ((1 channel-address) (space global))
|
||||
maybe-add: ((1 channel-address) (space global))
|
||||
cn0: checking arg ((x tagged-value))
|
||||
maybe-add: ((x tagged-value))
|
||||
cn0: checking oarg ((1 channel-address) (space global) (deref))
|
||||
maybe-add: ((1 channel-address) (space global) (deref))
|
||||
cn1: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
|
||||
cn1: (((1 channel-address)) <- ((init-channel)) ((3 literal)))
|
||||
cn1: (((fork)) ((producer fn)) ((default-space space-address) (globals)) ((nil literal) (limit)))
|
||||
cn1: (((1 tagged-value) (raw)) <- ((read)) ((1 channel-address)))
|
||||
cn1: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
|
||||
cn1: (((1 integer)) <- ((copy)) ((24 literal)))
|
||||
cn1: (((2 tagged-value)) <- ((save-type)) ((1 integer)))
|
||||
cn1: (((1 channel-address) (space global) (deref)) <- ((write)) ((1 channel-address) (space global)) ((2 tagged-value)))
|
||||
schedule: consumer
|
||||
run: consumer 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
|
||||
run: consumer 0: 1000 => ((default-space space-address))
|
||||
run: consumer 1: (((1 channel-address)) <- ((init-channel)) ((3 literal)))
|
||||
run: init-channel/consumer 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
|
||||
run: init-channel/consumer 0: 1031 => ((default-space space-address))
|
||||
run: init-channel/consumer 1: (((1 channel-address)) <- ((new)) ((channel literal)))
|
||||
run: init-channel/consumer 1: 1062 => ((1 channel-address))
|
||||
mem: ((1 channel-address)): 1033 <= 1062
|
||||
run: init-channel/consumer 2: (((2 integer-address)) <- ((get-address)) ((1 channel-address) (deref)) ((0 offset)))
|
||||
run: init-channel/consumer 2: 1062 => ((2 integer-address))
|
||||
mem: ((2 integer-address)): 1034 <= 1062
|
||||
run: init-channel/consumer 3: (((2 integer-address) (deref)) <- ((copy)) ((0 literal)))
|
||||
run: init-channel/consumer 3: 0 => ((2 integer-address) (deref))
|
||||
mem: ((2 integer-address) (deref)): 1062 <= 0
|
||||
run: init-channel/consumer 4: (((3 integer-address)) <- ((get-address)) ((1 channel-address) (deref)) ((1 offset)))
|
||||
run: init-channel/consumer 4: 1063 => ((3 integer-address))
|
||||
mem: ((3 integer-address)): 1035 <= 1063
|
||||
run: init-channel/consumer 5: (((3 integer-address) (deref)) <- ((copy)) ((0 literal)))
|
||||
run: init-channel/consumer 5: 0 => ((3 integer-address) (deref))
|
||||
mem: ((3 integer-address) (deref)): 1063 <= 0
|
||||
run: init-channel/consumer 6: (((4 integer)) <- ((next-input)))
|
||||
arg: nil 0 (3)
|
||||
run: init-channel/consumer 6: 3 => ((4 integer))
|
||||
mem: ((4 integer)): 1036 <= 3
|
||||
run: init-channel/consumer 7: (((4 integer)) <- ((add)) ((4 integer)) ((1 literal)))
|
||||
mem: ((4 integer)) => 3
|
||||
run: init-channel/consumer 7: 4 => ((4 integer))
|
||||
mem: ((4 integer)): 1036 <= 4
|
||||
run: init-channel/consumer 8: (((5 tagged-value-array-address-address)) <- ((get-address)) ((1 channel-address) (deref)) ((2 offset)))
|
||||
run: init-channel/consumer 8: 1064 => ((5 tagged-value-array-address-address))
|
||||
mem: ((5 tagged-value-array-address-address)): 1037 <= 1064
|
||||
run: init-channel/consumer 9: (((5 tagged-value-array-address-address) (deref)) <- ((new)) ((tagged-value-array literal)) ((4 integer)))
|
||||
mem: ((4 integer)) => 4
|
||||
run: init-channel/consumer 9: 1065 => ((5 tagged-value-array-address-address) (deref))
|
||||
mem: ((5 tagged-value-array-address-address) (deref)): 1064 <= 1065
|
||||
run: init-channel/consumer 10: (((reply)) ((1 channel-address)))
|
||||
mem: ((1 channel-address)) => 1062
|
||||
run: consumer 1: 1062 => ((1 channel-address))
|
||||
mem: ((1 channel-address)): 1002 <= 1062
|
||||
run: consumer 2: (((fork)) ((producer fn)) ((default-space space-address) (globals)) ((nil literal) (limit)))
|
||||
run: consumer 3: (((1 tagged-value) (raw)) <- ((read)) ((1 channel-address)))
|
||||
mem: ((1 channel-address)) => 1062
|
||||
run: read/consumer 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
|
||||
run: read/consumer 0: 1074 => ((default-space space-address))
|
||||
run: read/consumer 1: (((1 channel-address)) <- ((next-input)))
|
||||
arg: nil 0 (1062)
|
||||
run: read/consumer 1: 1062 => ((1 channel-address))
|
||||
mem: ((1 channel-address)): 1076 <= 1062
|
||||
run: read/consumer 2: (((2 boolean)) <- ((empty?)) ((1 channel-address) (deref)))
|
||||
mem: ((1 channel-address) (deref)) => #(tagged record (0 0 1065 . nil))
|
||||
run: empty?/read/consumer 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
|
||||
run: empty?/read/consumer 0: 1105 => ((default-space space-address))
|
||||
run: empty?/read/consumer 1: (((1 channel)) <- ((next-input)))
|
||||
arg: nil 0 (#(tagged record (0 0 1065 . nil)))
|
||||
run: empty?/read/consumer 1: #(tagged record (0 0 1065 . nil)) => ((1 channel))
|
||||
mem: ((1 channel)): 1107 <= 0
|
||||
mem: ((1 channel)): 1108 <= 0
|
||||
mem: ((1 channel)): 1109 <= 1065
|
||||
run: empty?/read/consumer 2: (((4 integer)) <- ((get)) ((1 channel)) ((0 offset)))
|
||||
mem: ((1107 integer) (raw)) => 0
|
||||
run: empty?/read/consumer 2: 0 => ((4 integer))
|
||||
mem: ((4 integer)): 1110 <= 0
|
||||
run: empty?/read/consumer 3: (((5 integer)) <- ((get)) ((1 channel)) ((1 offset)))
|
||||
mem: ((1108 integer) (raw)) => 0
|
||||
run: empty?/read/consumer 3: 0 => ((5 integer))
|
||||
mem: ((5 integer)): 1111 <= 0
|
||||
run: empty?/read/consumer 4: (((6 boolean)) <- ((equal)) ((4 integer)) ((5 integer)))
|
||||
mem: ((4 integer)) => 0
|
||||
mem: ((5 integer)) => 0
|
||||
run: empty?/read/consumer 4: t => ((6 boolean))
|
||||
mem: ((6 boolean)): 1112 <= t
|
||||
run: empty?/read/consumer 5: (((reply)) ((6 boolean)))
|
||||
mem: ((6 boolean)) => t
|
||||
run: read/consumer 2: t => ((2 boolean))
|
||||
mem: ((2 boolean)): 1077 <= t
|
||||
run: read/consumer 3: (((jump-unless)) ((2 boolean)) ((2 offset)))
|
||||
mem: ((2 boolean)) => t
|
||||
run: read/consumer 4: (((3 integer-address)) <- ((get-address)) ((1 channel-address) (deref)) ((1 offset)))
|
||||
run: read/consumer 4: 1063 => ((3 integer-address))
|
||||
mem: ((3 integer-address)): 1078 <= 1063
|
||||
run: read/consumer 5: (((sleep)) ((until-location-changes literal)) ((3 integer-address) (deref)))
|
||||
mem: ((3 integer-address) (deref)) => 0
|
||||
schedule: pushing read/consumer to sleep queue
|
||||
schedule: producer
|
||||
run: producer 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
|
||||
run: producer 0: 101000 => ((default-space space-address))
|
||||
run: producer 1: (((1 integer)) <- ((copy)) ((24 literal)))
|
||||
run: producer 1: 24 => ((1 integer))
|
||||
mem: ((1 integer)): 101002 <= 24
|
||||
run: producer 2: (((2 tagged-value)) <- ((save-type)) ((1 integer)))
|
||||
mem: ((1 integer)) => 24
|
||||
run: producer 2: #(tagged record (integer 24)) => ((2 tagged-value))
|
||||
mem: ((2 tagged-value)): 101003 <= integer
|
||||
mem: ((2 tagged-value)): 101004 <= 24
|
||||
run: producer 3: (((1 channel-address) (space global) (deref)) <- ((write)) ((1 channel-address) (space global)) ((2 tagged-value)))
|
||||
mem: ((1 channel-address) (space global)) => 1062
|
||||
mem: ((2 tagged-value)) => #(tagged record (integer 24 . nil))
|
||||
run: write/producer 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
|
||||
run: write/producer 0: 101031 => ((default-space space-address))
|
||||
run: write/producer 1: (((1 channel-address)) <- ((next-input)))
|
||||
arg: nil 0 (1062 #(tagged record (integer 24 . nil)))
|
||||
run: write/producer 1: 1062 => ((1 channel-address))
|
||||
mem: ((1 channel-address)): 101033 <= 1062
|
||||
run: write/producer 2: (((2 tagged-value)) <- ((next-input)))
|
||||
arg: nil 1 (1062 #(tagged record (integer 24 . nil)))
|
||||
run: write/producer 2: #(tagged record (integer 24 . nil)) => ((2 tagged-value))
|
||||
mem: ((2 tagged-value)): 101034 <= integer
|
||||
mem: ((2 tagged-value)): 101035 <= 24
|
||||
run: write/producer 3: (((4 boolean)) <- ((full?)) ((1 channel-address) (deref)))
|
||||
mem: ((1 channel-address) (deref)) => #(tagged record (0 0 1065 . nil))
|
||||
run: full?/write/producer 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
|
||||
run: full?/write/producer 0: 101062 => ((default-space space-address))
|
||||
run: full?/write/producer 1: (((1 channel)) <- ((next-input)))
|
||||
arg: nil 0 (#(tagged record (0 0 1065 . nil)))
|
||||
run: full?/write/producer 1: #(tagged record (0 0 1065 . nil)) => ((1 channel))
|
||||
mem: ((1 channel)): 101064 <= 0
|
||||
mem: ((1 channel)): 101065 <= 0
|
||||
mem: ((1 channel)): 101066 <= 1065
|
||||
run: full?/write/producer 2: (((4 integer)) <- ((get)) ((1 channel)) ((1 offset)))
|
||||
mem: ((101065 integer) (raw)) => 0
|
||||
run: full?/write/producer 2: 0 => ((4 integer))
|
||||
mem: ((4 integer)): 101067 <= 0
|
||||
run: full?/write/producer 3: (((4 integer)) <- ((add)) ((4 integer)) ((1 literal)))
|
||||
mem: ((4 integer)) => 0
|
||||
run: full?/write/producer 3: 1 => ((4 integer))
|
||||
mem: ((4 integer)): 101067 <= 1
|
||||
run: full?/write/producer 4: (((5 integer)) <- ((capacity)) ((1 channel)))
|
||||
mem: ((1 channel)) => #(tagged record (0 0 1065 . nil))
|
||||
run: capacity/full?/write/producer 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
|
||||
run: capacity/full?/write/producer 0: 101093 => ((default-space space-address))
|
||||
run: capacity/full?/write/producer 1: (((1 channel)) <- ((next-input)))
|
||||
arg: nil 0 (#(tagged record (0 0 1065 . nil)))
|
||||
run: capacity/full?/write/producer 1: #(tagged record (0 0 1065 . nil)) => ((1 channel))
|
||||
mem: ((1 channel)): 101095 <= 0
|
||||
mem: ((1 channel)): 101096 <= 0
|
||||
mem: ((1 channel)): 101097 <= 1065
|
||||
run: capacity/full?/write/producer 2: (((4 tagged-value-array-address)) <- ((get)) ((1 channel)) ((2 offset)))
|
||||
mem: ((101097 tagged-value-array-address) (raw)) => 1065
|
||||
run: capacity/full?/write/producer 2: 1065 => ((4 tagged-value-array-address))
|
||||
mem: ((4 tagged-value-array-address)): 101098 <= 1065
|
||||
run: capacity/full?/write/producer 3: (((5 integer)) <- ((length)) ((4 tagged-value-array-address) (deref)))
|
||||
array-len: ((4 tagged-value-array-address) (deref))
|
||||
mem: ((1065 integer) (raw)) => 4
|
||||
run: capacity/full?/write/producer 3: 4 => ((5 integer))
|
||||
mem: ((5 integer)): 101099 <= 4
|
||||
run: capacity/full?/write/producer 4: (((reply)) ((5 integer)))
|
||||
mem: ((5 integer)) => 4
|
||||
run: full?/write/producer 4: 4 => ((5 integer))
|
||||
mem: ((5 integer)): 101068 <= 4
|
||||
run: full?/write/producer 5: (((6 boolean)) <- ((less-than)) ((4 integer)) ((5 integer)))
|
||||
mem: ((4 integer)) => 1
|
||||
mem: ((5 integer)) => 4
|
||||
run: full?/write/producer 5: t => ((6 boolean))
|
||||
mem: ((6 boolean)): 101069 <= t
|
||||
run: full?/write/producer 6: (((jump-if)) ((6 boolean)) ((1 offset)))
|
||||
mem: ((6 boolean)) => t
|
||||
run: full?/write/producer 8: (((7 integer)) <- ((get)) ((1 channel)) ((0 offset)))
|
||||
mem: ((101064 integer) (raw)) => 0
|
||||
run: full?/write/producer 8: 0 => ((7 integer))
|
||||
mem: ((7 integer)): 101070 <= 0
|
||||
run: full?/write/producer 9: (((8 boolean)) <- ((equal)) ((7 integer)) ((4 integer)))
|
||||
mem: ((7 integer)) => 0
|
||||
mem: ((4 integer)) => 1
|
||||
run: full?/write/producer 9: nil => ((8 boolean))
|
||||
mem: ((8 boolean)): 101071 <= nil
|
||||
run: full?/write/producer 10: (((reply)) ((8 boolean)))
|
||||
mem: ((8 boolean)) => nil
|
||||
run: write/producer 3: nil => ((4 boolean))
|
||||
mem: ((4 boolean)): 101036 <= nil
|
||||
run: write/producer 4: (((jump-unless)) ((4 boolean)) ((2 offset)))
|
||||
mem: ((4 boolean)) => nil
|
||||
run: write/producer 7: (((6 tagged-value-array-address)) <- ((get)) ((1 channel-address) (deref)) ((2 offset)))
|
||||
mem: ((1064 tagged-value-array-address) (raw)) => 1065
|
||||
run: write/producer 7: 1065 => ((6 tagged-value-array-address))
|
||||
mem: ((6 tagged-value-array-address)): 101038 <= 1065
|
||||
run: write/producer 8: (((7 integer-address)) <- ((get-address)) ((1 channel-address) (deref)) ((1 offset)))
|
||||
run: write/producer 8: 1063 => ((7 integer-address))
|
||||
mem: ((7 integer-address)): 101039 <= 1063
|
||||
run: write/producer 9: (((8 tagged-value-address)) <- ((index-address)) ((6 tagged-value-array-address) (deref)) ((7 integer-address) (deref)))
|
||||
mem: ((7 integer-address) (deref)) => 0
|
||||
array-len: ((1065 tagged-value-array) (raw))
|
||||
mem: ((1065 integer) (raw)) => 4
|
||||
run: write/producer 9: 1066 => ((8 tagged-value-address))
|
||||
mem: ((8 tagged-value-address)): 101040 <= 1066
|
||||
run: write/producer 10: (((8 tagged-value-address) (deref)) <- ((copy)) ((2 tagged-value)))
|
||||
mem: ((2 tagged-value)) => #(tagged record (integer 24 . nil))
|
||||
run: write/producer 10: #(tagged record (integer 24 . nil)) => ((8 tagged-value-address) (deref))
|
||||
mem: ((8 tagged-value-address) (deref)): 1066 <= integer
|
||||
mem: ((8 tagged-value-address) (deref)): 1067 <= 24
|
||||
run: write/producer 11: (((7 integer-address) (deref)) <- ((add)) ((7 integer-address) (deref)) ((1 literal)))
|
||||
mem: ((7 integer-address) (deref)) => 0
|
||||
run: write/producer 11: 1 => ((7 integer-address) (deref))
|
||||
mem: ((7 integer-address) (deref)): 1063 <= 1
|
||||
run: write/producer 12: (((9 integer)) <- ((length)) ((6 tagged-value-array-address) (deref)))
|
||||
array-len: ((6 tagged-value-array-address) (deref))
|
||||
mem: ((1065 integer) (raw)) => 4
|
||||
run: write/producer 12: 4 => ((9 integer))
|
||||
mem: ((9 integer)): 101041 <= 4
|
||||
run: write/producer 13: (((10 boolean)) <- ((less-than)) ((7 integer-address) (deref)) ((9 integer)))
|
||||
mem: ((7 integer-address) (deref)) => 1
|
||||
mem: ((9 integer)) => 4
|
||||
run: write/producer 13: t => ((10 boolean))
|
||||
mem: ((10 boolean)): 101042 <= t
|
||||
run: write/producer 14: (((jump-if)) ((10 boolean)) ((1 offset)))
|
||||
mem: ((10 boolean)) => t
|
||||
run: write/producer 16: (((reply)) ((1 channel-address) (deref) (same-as-arg 0)))
|
||||
mem: ((1 channel-address) (deref) (same-as-arg 0)) => #(tagged record (0 1 1065 . nil))
|
||||
run: producer 3: #(tagged record (0 1 1065 . nil)) => ((1 channel-address) (space global) (deref))
|
||||
mem: ((1 channel-address) (space global) (deref)): 1062 <= 0
|
||||
mem: ((1 channel-address) (space global) (deref)): 1063 <= 1
|
||||
mem: ((1 channel-address) (space global) (deref)): 1064 <= 1065
|
||||
schedule: done with routine nil
|
||||
schedule: waking up read/consumer
|
||||
schedule: read/consumer
|
||||
run: read/consumer 6: (((4 integer-address)) <- ((get-address)) ((1 channel-address) (deref)) ((0 offset)))
|
||||
run: read/consumer 6: 1062 => ((4 integer-address))
|
||||
mem: ((4 integer-address)): 1079 <= 1062
|
||||
run: read/consumer 7: (((5 tagged-value-array-address)) <- ((get)) ((1 channel-address) (deref)) ((2 offset)))
|
||||
mem: ((1064 tagged-value-array-address) (raw)) => 1065
|
||||
run: read/consumer 7: 1065 => ((5 tagged-value-array-address))
|
||||
mem: ((5 tagged-value-array-address)): 1080 <= 1065
|
||||
run: read/consumer 8: (((6 tagged-value)) <- ((index)) ((5 tagged-value-array-address) (deref)) ((4 integer-address) (deref)))
|
||||
mem: ((4 integer-address) (deref)) => 0
|
||||
array-len: ((1065 tagged-value-array) (raw))
|
||||
mem: ((1065 integer) (raw)) => 4
|
||||
mem: ((1066 tagged-value) (raw)) => #(tagged record (integer 24 . nil))
|
||||
run: read/consumer 8: #(tagged record (integer 24 . nil)) => ((6 tagged-value))
|
||||
mem: ((6 tagged-value)): 1081 <= integer
|
||||
mem: ((6 tagged-value)): 1082 <= 24
|
||||
run: read/consumer 9: (((4 integer-address) (deref)) <- ((add)) ((4 integer-address) (deref)) ((1 literal)))
|
||||
mem: ((4 integer-address) (deref)) => 0
|
||||
run: read/consumer 9: 1 => ((4 integer-address) (deref))
|
||||
mem: ((4 integer-address) (deref)): 1062 <= 1
|
||||
run: read/consumer 10: (((8 integer)) <- ((length)) ((5 tagged-value-array-address) (deref)))
|
||||
array-len: ((5 tagged-value-array-address) (deref))
|
||||
mem: ((1065 integer) (raw)) => 4
|
||||
run: read/consumer 10: 4 => ((8 integer))
|
||||
mem: ((8 integer)): 1083 <= 4
|
||||
run: read/consumer 11: (((9 boolean)) <- ((less-than)) ((4 integer-address) (deref)) ((8 integer)))
|
||||
mem: ((4 integer-address) (deref)) => 1
|
||||
mem: ((8 integer)) => 4
|
||||
run: read/consumer 11: t => ((9 boolean))
|
||||
mem: ((9 boolean)): 1084 <= t
|
||||
run: read/consumer 12: (((jump-if)) ((9 boolean)) ((1 offset)))
|
||||
mem: ((9 boolean)) => t
|
||||
run: read/consumer 14: (((reply)) ((6 tagged-value)) ((1 channel-address) (deref) (same-as-arg 0)))
|
||||
mem: ((6 tagged-value)) => #(tagged record (integer 24 . nil))
|
||||
mem: ((1 channel-address) (deref) (same-as-arg 0)) => #(tagged record (1 1 1065 . nil))
|
||||
run: consumer 3: #(tagged record (integer 24 . nil)) => ((1 tagged-value) (raw))
|
||||
mem: ((1 tagged-value) (raw)): 1 <= integer
|
||||
mem: ((1 tagged-value) (raw)): 2 <= 24
|
||||
schedule: done with routine nil
|
||||
|
|
@ -0,0 +1,79 @@
|
|||
c{0: 0 (((1 channel-address)) <- ((init-channel)) ((3 literal))) -- nil
|
||||
c{0: 1 (((2 integer)) <- ((get)) ((1 channel-address) (deref)) ((first-full offset))) -- nil
|
||||
c{0: 2 (((3 integer)) <- ((get)) ((1 channel-address) (deref)) ((first-free offset))) -- nil
|
||||
c{1: 0 ✓ (((1 channel-address)) <- ((init-channel)) ((3 literal)))
|
||||
c{1: 1 ✓ (((2 integer)) <- ((get)) ((1 channel-address) (deref)) ((first-full offset)))
|
||||
c{1: 2 ✓ (((3 integer)) <- ((get)) ((1 channel-address) (deref)) ((first-free offset)))
|
||||
cn0: convert-names in main
|
||||
cn0: (((1 channel-address)) <- ((init-channel)) ((3 literal))) nil nil
|
||||
cn0: checking arg ((3 literal))
|
||||
cn0: checking oarg ((1 channel-address))
|
||||
maybe-add: ((1 channel-address))
|
||||
cn0: (((2 integer)) <- ((get)) ((1 channel-address) (deref)) ((first-full offset))) nil nil
|
||||
cn0: field-access first-full in 1channel-addressderef of type channel
|
||||
cn0: new field; computing location
|
||||
cn0: field location 0
|
||||
cn0: checking arg ((1 channel-address) (deref))
|
||||
maybe-add: ((1 channel-address) (deref))
|
||||
cn0: checking arg ((first-full offset))
|
||||
cn0: checking oarg ((2 integer))
|
||||
maybe-add: ((2 integer))
|
||||
cn0: (((3 integer)) <- ((get)) ((1 channel-address) (deref)) ((first-free offset))) ((first-full 0)) ((first-full t))
|
||||
cn0: field-access first-free in 1channel-addressderef of type channel
|
||||
cn0: new field; computing location
|
||||
cn0: field location 1
|
||||
cn0: checking arg ((1 channel-address) (deref))
|
||||
maybe-add: ((1 channel-address) (deref))
|
||||
cn0: checking arg ((first-free offset))
|
||||
cn0: checking oarg ((3 integer))
|
||||
maybe-add: ((3 integer))
|
||||
cn1: (((1 channel-address)) <- ((init-channel)) ((3 literal)))
|
||||
cn1: (((2 integer)) <- ((get)) ((1 channel-address) (deref)) ((0 offset)))
|
||||
cn1: (((3 integer)) <- ((get)) ((1 channel-address) (deref)) ((1 offset)))
|
||||
schedule: main
|
||||
run: main 0: (((1 channel-address)) <- ((init-channel)) ((3 literal)))
|
||||
run: init-channel/main 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
|
||||
run: init-channel/main 0: 1000 => ((default-space space-address))
|
||||
run: init-channel/main 1: (((1 channel-address)) <- ((new)) ((channel literal)))
|
||||
run: init-channel/main 1: 1031 => ((1 channel-address))
|
||||
mem: ((1 channel-address)): 1002 <= 1031
|
||||
run: init-channel/main 2: (((2 integer-address)) <- ((get-address)) ((1 channel-address) (deref)) ((0 offset)))
|
||||
run: init-channel/main 2: 1031 => ((2 integer-address))
|
||||
mem: ((2 integer-address)): 1003 <= 1031
|
||||
run: init-channel/main 3: (((2 integer-address) (deref)) <- ((copy)) ((0 literal)))
|
||||
run: init-channel/main 3: 0 => ((2 integer-address) (deref))
|
||||
mem: ((2 integer-address) (deref)): 1031 <= 0
|
||||
run: init-channel/main 4: (((3 integer-address)) <- ((get-address)) ((1 channel-address) (deref)) ((1 offset)))
|
||||
run: init-channel/main 4: 1032 => ((3 integer-address))
|
||||
mem: ((3 integer-address)): 1004 <= 1032
|
||||
run: init-channel/main 5: (((3 integer-address) (deref)) <- ((copy)) ((0 literal)))
|
||||
run: init-channel/main 5: 0 => ((3 integer-address) (deref))
|
||||
mem: ((3 integer-address) (deref)): 1032 <= 0
|
||||
run: init-channel/main 6: (((4 integer)) <- ((next-input)))
|
||||
arg: nil 0 (3)
|
||||
run: init-channel/main 6: 3 => ((4 integer))
|
||||
mem: ((4 integer)): 1005 <= 3
|
||||
run: init-channel/main 7: (((4 integer)) <- ((add)) ((4 integer)) ((1 literal)))
|
||||
mem: ((4 integer)) => 3
|
||||
run: init-channel/main 7: 4 => ((4 integer))
|
||||
mem: ((4 integer)): 1005 <= 4
|
||||
run: init-channel/main 8: (((5 tagged-value-array-address-address)) <- ((get-address)) ((1 channel-address) (deref)) ((2 offset)))
|
||||
run: init-channel/main 8: 1033 => ((5 tagged-value-array-address-address))
|
||||
mem: ((5 tagged-value-array-address-address)): 1006 <= 1033
|
||||
run: init-channel/main 9: (((5 tagged-value-array-address-address) (deref)) <- ((new)) ((tagged-value-array literal)) ((4 integer)))
|
||||
mem: ((4 integer)) => 4
|
||||
run: init-channel/main 9: 1034 => ((5 tagged-value-array-address-address) (deref))
|
||||
mem: ((5 tagged-value-array-address-address) (deref)): 1033 <= 1034
|
||||
run: init-channel/main 10: (((reply)) ((1 channel-address)))
|
||||
mem: ((1 channel-address)) => 1031
|
||||
run: main 0: 1031 => ((1 channel-address))
|
||||
mem: ((1 channel-address)): 1 <= 1031
|
||||
run: main 1: (((2 integer)) <- ((get)) ((1 channel-address) (deref)) ((0 offset)))
|
||||
mem: ((1031 integer) (raw)) => 0
|
||||
run: main 1: 0 => ((2 integer))
|
||||
mem: ((2 integer)): 2 <= 0
|
||||
run: main 2: (((3 integer)) <- ((get)) ((1 channel-address) (deref)) ((1 offset)))
|
||||
mem: ((1032 integer) (raw)) => 0
|
||||
run: main 2: 0 => ((3 integer))
|
||||
mem: ((3 integer)): 3 <= 0
|
||||
schedule: done with routine nil
|
||||
|
|
@ -0,0 +1,151 @@
|
|||
c{0: 0 (((1 channel-address)) <- ((init-channel)) ((3 literal))) -- nil
|
||||
c{0: 1 (((2 boolean)) <- ((empty?)) ((1 channel-address) (deref))) -- nil
|
||||
c{0: 2 (((3 boolean)) <- ((full?)) ((1 channel-address) (deref))) -- nil
|
||||
c{1: 0 ✓ (((1 channel-address)) <- ((init-channel)) ((3 literal)))
|
||||
c{1: 1 ✓ (((2 boolean)) <- ((empty?)) ((1 channel-address) (deref)))
|
||||
c{1: 2 ✓ (((3 boolean)) <- ((full?)) ((1 channel-address) (deref)))
|
||||
cn0: convert-names in main
|
||||
cn0: (((1 channel-address)) <- ((init-channel)) ((3 literal))) nil nil
|
||||
cn0: checking arg ((3 literal))
|
||||
cn0: checking oarg ((1 channel-address))
|
||||
maybe-add: ((1 channel-address))
|
||||
cn0: (((2 boolean)) <- ((empty?)) ((1 channel-address) (deref))) nil nil
|
||||
cn0: checking arg ((1 channel-address) (deref))
|
||||
maybe-add: ((1 channel-address) (deref))
|
||||
cn0: checking oarg ((2 boolean))
|
||||
maybe-add: ((2 boolean))
|
||||
cn0: (((3 boolean)) <- ((full?)) ((1 channel-address) (deref))) nil nil
|
||||
cn0: checking arg ((1 channel-address) (deref))
|
||||
maybe-add: ((1 channel-address) (deref))
|
||||
cn0: checking oarg ((3 boolean))
|
||||
maybe-add: ((3 boolean))
|
||||
cn1: (((1 channel-address)) <- ((init-channel)) ((3 literal)))
|
||||
cn1: (((2 boolean)) <- ((empty?)) ((1 channel-address) (deref)))
|
||||
cn1: (((3 boolean)) <- ((full?)) ((1 channel-address) (deref)))
|
||||
schedule: main
|
||||
run: main 0: (((1 channel-address)) <- ((init-channel)) ((3 literal)))
|
||||
run: init-channel/main 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
|
||||
run: init-channel/main 0: 1000 => ((default-space space-address))
|
||||
run: init-channel/main 1: (((1 channel-address)) <- ((new)) ((channel literal)))
|
||||
run: init-channel/main 1: 1031 => ((1 channel-address))
|
||||
mem: ((1 channel-address)): 1002 <= 1031
|
||||
run: init-channel/main 2: (((2 integer-address)) <- ((get-address)) ((1 channel-address) (deref)) ((0 offset)))
|
||||
run: init-channel/main 2: 1031 => ((2 integer-address))
|
||||
mem: ((2 integer-address)): 1003 <= 1031
|
||||
run: init-channel/main 3: (((2 integer-address) (deref)) <- ((copy)) ((0 literal)))
|
||||
run: init-channel/main 3: 0 => ((2 integer-address) (deref))
|
||||
mem: ((2 integer-address) (deref)): 1031 <= 0
|
||||
run: init-channel/main 4: (((3 integer-address)) <- ((get-address)) ((1 channel-address) (deref)) ((1 offset)))
|
||||
run: init-channel/main 4: 1032 => ((3 integer-address))
|
||||
mem: ((3 integer-address)): 1004 <= 1032
|
||||
run: init-channel/main 5: (((3 integer-address) (deref)) <- ((copy)) ((0 literal)))
|
||||
run: init-channel/main 5: 0 => ((3 integer-address) (deref))
|
||||
mem: ((3 integer-address) (deref)): 1032 <= 0
|
||||
run: init-channel/main 6: (((4 integer)) <- ((next-input)))
|
||||
arg: nil 0 (3)
|
||||
run: init-channel/main 6: 3 => ((4 integer))
|
||||
mem: ((4 integer)): 1005 <= 3
|
||||
run: init-channel/main 7: (((4 integer)) <- ((add)) ((4 integer)) ((1 literal)))
|
||||
mem: ((4 integer)) => 3
|
||||
run: init-channel/main 7: 4 => ((4 integer))
|
||||
mem: ((4 integer)): 1005 <= 4
|
||||
run: init-channel/main 8: (((5 tagged-value-array-address-address)) <- ((get-address)) ((1 channel-address) (deref)) ((2 offset)))
|
||||
run: init-channel/main 8: 1033 => ((5 tagged-value-array-address-address))
|
||||
mem: ((5 tagged-value-array-address-address)): 1006 <= 1033
|
||||
run: init-channel/main 9: (((5 tagged-value-array-address-address) (deref)) <- ((new)) ((tagged-value-array literal)) ((4 integer)))
|
||||
mem: ((4 integer)) => 4
|
||||
run: init-channel/main 9: 1034 => ((5 tagged-value-array-address-address) (deref))
|
||||
mem: ((5 tagged-value-array-address-address) (deref)): 1033 <= 1034
|
||||
run: init-channel/main 10: (((reply)) ((1 channel-address)))
|
||||
mem: ((1 channel-address)) => 1031
|
||||
run: main 0: 1031 => ((1 channel-address))
|
||||
mem: ((1 channel-address)): 1 <= 1031
|
||||
run: main 1: (((2 boolean)) <- ((empty?)) ((1 channel-address) (deref)))
|
||||
mem: ((1 channel-address) (deref)) => #(tagged record (0 0 1034 . nil))
|
||||
run: empty?/main 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
|
||||
run: empty?/main 0: 1043 => ((default-space space-address))
|
||||
run: empty?/main 1: (((1 channel)) <- ((next-input)))
|
||||
arg: nil 0 (#(tagged record (0 0 1034 . nil)))
|
||||
run: empty?/main 1: #(tagged record (0 0 1034 . nil)) => ((1 channel))
|
||||
mem: ((1 channel)): 1045 <= 0
|
||||
mem: ((1 channel)): 1046 <= 0
|
||||
mem: ((1 channel)): 1047 <= 1034
|
||||
run: empty?/main 2: (((4 integer)) <- ((get)) ((1 channel)) ((0 offset)))
|
||||
mem: ((1045 integer) (raw)) => 0
|
||||
run: empty?/main 2: 0 => ((4 integer))
|
||||
mem: ((4 integer)): 1048 <= 0
|
||||
run: empty?/main 3: (((5 integer)) <- ((get)) ((1 channel)) ((1 offset)))
|
||||
mem: ((1046 integer) (raw)) => 0
|
||||
run: empty?/main 3: 0 => ((5 integer))
|
||||
mem: ((5 integer)): 1049 <= 0
|
||||
run: empty?/main 4: (((6 boolean)) <- ((equal)) ((4 integer)) ((5 integer)))
|
||||
mem: ((4 integer)) => 0
|
||||
mem: ((5 integer)) => 0
|
||||
run: empty?/main 4: t => ((6 boolean))
|
||||
mem: ((6 boolean)): 1050 <= t
|
||||
run: empty?/main 5: (((reply)) ((6 boolean)))
|
||||
mem: ((6 boolean)) => t
|
||||
run: main 1: t => ((2 boolean))
|
||||
mem: ((2 boolean)): 2 <= t
|
||||
run: main 2: (((3 boolean)) <- ((full?)) ((1 channel-address) (deref)))
|
||||
mem: ((1 channel-address) (deref)) => #(tagged record (0 0 1034 . nil))
|
||||
run: full?/main 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
|
||||
run: full?/main 0: 1074 => ((default-space space-address))
|
||||
run: full?/main 1: (((1 channel)) <- ((next-input)))
|
||||
arg: nil 0 (#(tagged record (0 0 1034 . nil)))
|
||||
run: full?/main 1: #(tagged record (0 0 1034 . nil)) => ((1 channel))
|
||||
mem: ((1 channel)): 1076 <= 0
|
||||
mem: ((1 channel)): 1077 <= 0
|
||||
mem: ((1 channel)): 1078 <= 1034
|
||||
run: full?/main 2: (((4 integer)) <- ((get)) ((1 channel)) ((1 offset)))
|
||||
mem: ((1077 integer) (raw)) => 0
|
||||
run: full?/main 2: 0 => ((4 integer))
|
||||
mem: ((4 integer)): 1079 <= 0
|
||||
run: full?/main 3: (((4 integer)) <- ((add)) ((4 integer)) ((1 literal)))
|
||||
mem: ((4 integer)) => 0
|
||||
run: full?/main 3: 1 => ((4 integer))
|
||||
mem: ((4 integer)): 1079 <= 1
|
||||
run: full?/main 4: (((5 integer)) <- ((capacity)) ((1 channel)))
|
||||
mem: ((1 channel)) => #(tagged record (0 0 1034 . nil))
|
||||
run: capacity/full?/main 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
|
||||
run: capacity/full?/main 0: 1105 => ((default-space space-address))
|
||||
run: capacity/full?/main 1: (((1 channel)) <- ((next-input)))
|
||||
arg: nil 0 (#(tagged record (0 0 1034 . nil)))
|
||||
run: capacity/full?/main 1: #(tagged record (0 0 1034 . nil)) => ((1 channel))
|
||||
mem: ((1 channel)): 1107 <= 0
|
||||
mem: ((1 channel)): 1108 <= 0
|
||||
mem: ((1 channel)): 1109 <= 1034
|
||||
run: capacity/full?/main 2: (((4 tagged-value-array-address)) <- ((get)) ((1 channel)) ((2 offset)))
|
||||
mem: ((1109 tagged-value-array-address) (raw)) => 1034
|
||||
run: capacity/full?/main 2: 1034 => ((4 tagged-value-array-address))
|
||||
mem: ((4 tagged-value-array-address)): 1110 <= 1034
|
||||
run: capacity/full?/main 3: (((5 integer)) <- ((length)) ((4 tagged-value-array-address) (deref)))
|
||||
array-len: ((4 tagged-value-array-address) (deref))
|
||||
mem: ((1034 integer) (raw)) => 4
|
||||
run: capacity/full?/main 3: 4 => ((5 integer))
|
||||
mem: ((5 integer)): 1111 <= 4
|
||||
run: capacity/full?/main 4: (((reply)) ((5 integer)))
|
||||
mem: ((5 integer)) => 4
|
||||
run: full?/main 4: 4 => ((5 integer))
|
||||
mem: ((5 integer)): 1080 <= 4
|
||||
run: full?/main 5: (((6 boolean)) <- ((less-than)) ((4 integer)) ((5 integer)))
|
||||
mem: ((4 integer)) => 1
|
||||
mem: ((5 integer)) => 4
|
||||
run: full?/main 5: t => ((6 boolean))
|
||||
mem: ((6 boolean)): 1081 <= t
|
||||
run: full?/main 6: (((jump-if)) ((6 boolean)) ((1 offset)))
|
||||
mem: ((6 boolean)) => t
|
||||
run: full?/main 8: (((7 integer)) <- ((get)) ((1 channel)) ((0 offset)))
|
||||
mem: ((1076 integer) (raw)) => 0
|
||||
run: full?/main 8: 0 => ((7 integer))
|
||||
mem: ((7 integer)): 1082 <= 0
|
||||
run: full?/main 9: (((8 boolean)) <- ((equal)) ((7 integer)) ((4 integer)))
|
||||
mem: ((7 integer)) => 0
|
||||
mem: ((4 integer)) => 1
|
||||
run: full?/main 9: nil => ((8 boolean))
|
||||
mem: ((8 boolean)): 1083 <= nil
|
||||
run: full?/main 10: (((reply)) ((8 boolean)))
|
||||
mem: ((8 boolean)) => nil
|
||||
run: main 2: nil => ((3 boolean))
|
||||
mem: ((3 boolean)): 3 <= nil
|
||||
schedule: done with routine nil
|
||||
|
|
@ -0,0 +1,362 @@
|
|||
c{0: 0 (((1 channel-address)) <- ((init-channel)) ((3 literal))) -- nil
|
||||
c{0: 1 (((2 integer)) <- ((copy)) ((34 literal))) -- nil
|
||||
c{0: 2 (((3 tagged-value)) <- ((save-type)) ((2 integer))) -- nil
|
||||
c{0: 3 (((1 channel-address) (deref)) <- ((write)) ((1 channel-address)) ((3 tagged-value))) -- nil
|
||||
c{0: 4 (((5 tagged-value)) ((1 channel-address) (deref)) <- ((read)) ((1 channel-address))) -- nil
|
||||
c{0: 5 (((7 integer)) <- ((maybe-coerce)) ((5 tagged-value)) ((integer literal))) -- nil
|
||||
c{0: 6 (((8 integer)) <- ((get)) ((1 channel-address) (deref)) ((first-full offset))) -- nil
|
||||
c{0: 7 (((9 integer)) <- ((get)) ((1 channel-address) (deref)) ((first-free offset))) -- nil
|
||||
c{1: 0 ✓ (((1 channel-address)) <- ((init-channel)) ((3 literal)))
|
||||
c{1: 1 ✓ (((2 integer)) <- ((copy)) ((34 literal)))
|
||||
c{1: 2 ✓ (((3 tagged-value)) <- ((save-type)) ((2 integer)))
|
||||
c{1: 3 ✓ (((1 channel-address) (deref)) <- ((write)) ((1 channel-address)) ((3 tagged-value)))
|
||||
c{1: 4 ✓ (((5 tagged-value)) ((1 channel-address) (deref)) <- ((read)) ((1 channel-address)))
|
||||
c{1: 5 ✓ (((7 integer)) <- ((maybe-coerce)) ((5 tagged-value)) ((integer literal)))
|
||||
c{1: 6 ✓ (((8 integer)) <- ((get)) ((1 channel-address) (deref)) ((first-full offset)))
|
||||
c{1: 7 ✓ (((9 integer)) <- ((get)) ((1 channel-address) (deref)) ((first-free offset)))
|
||||
cn0: convert-names in main
|
||||
cn0: (((1 channel-address)) <- ((init-channel)) ((3 literal))) nil nil
|
||||
cn0: checking arg ((3 literal))
|
||||
cn0: checking oarg ((1 channel-address))
|
||||
maybe-add: ((1 channel-address))
|
||||
cn0: (((2 integer)) <- ((copy)) ((34 literal))) nil nil
|
||||
cn0: checking arg ((34 literal))
|
||||
cn0: checking oarg ((2 integer))
|
||||
maybe-add: ((2 integer))
|
||||
cn0: (((3 tagged-value)) <- ((save-type)) ((2 integer))) nil nil
|
||||
cn0: checking arg ((2 integer))
|
||||
maybe-add: ((2 integer))
|
||||
cn0: checking oarg ((3 tagged-value))
|
||||
maybe-add: ((3 tagged-value))
|
||||
cn0: (((1 channel-address) (deref)) <- ((write)) ((1 channel-address)) ((3 tagged-value))) nil nil
|
||||
cn0: checking arg ((1 channel-address))
|
||||
maybe-add: ((1 channel-address))
|
||||
cn0: checking arg ((3 tagged-value))
|
||||
maybe-add: ((3 tagged-value))
|
||||
cn0: checking oarg ((1 channel-address) (deref))
|
||||
maybe-add: ((1 channel-address) (deref))
|
||||
cn0: (((5 tagged-value)) ((1 channel-address) (deref)) <- ((read)) ((1 channel-address))) nil nil
|
||||
cn0: checking arg ((1 channel-address))
|
||||
maybe-add: ((1 channel-address))
|
||||
cn0: checking oarg ((5 tagged-value))
|
||||
maybe-add: ((5 tagged-value))
|
||||
cn0: checking oarg ((1 channel-address) (deref))
|
||||
maybe-add: ((1 channel-address) (deref))
|
||||
cn0: (((7 integer)) <- ((maybe-coerce)) ((5 tagged-value)) ((integer literal))) nil nil
|
||||
cn0: checking arg ((5 tagged-value))
|
||||
maybe-add: ((5 tagged-value))
|
||||
cn0: checking arg ((integer literal))
|
||||
cn0: checking oarg ((7 integer))
|
||||
maybe-add: ((7 integer))
|
||||
cn0: (((8 integer)) <- ((get)) ((1 channel-address) (deref)) ((first-full offset))) nil nil
|
||||
cn0: field-access first-full in 1channel-addressderef of type channel
|
||||
cn0: new field; computing location
|
||||
cn0: field location 0
|
||||
cn0: checking arg ((1 channel-address) (deref))
|
||||
maybe-add: ((1 channel-address) (deref))
|
||||
cn0: checking arg ((first-full offset))
|
||||
cn0: checking oarg ((8 integer))
|
||||
maybe-add: ((8 integer))
|
||||
cn0: (((9 integer)) <- ((get)) ((1 channel-address) (deref)) ((first-free offset))) ((first-full 0)) ((first-full t))
|
||||
cn0: field-access first-free in 1channel-addressderef of type channel
|
||||
cn0: new field; computing location
|
||||
cn0: field location 1
|
||||
cn0: checking arg ((1 channel-address) (deref))
|
||||
maybe-add: ((1 channel-address) (deref))
|
||||
cn0: checking arg ((first-free offset))
|
||||
cn0: checking oarg ((9 integer))
|
||||
maybe-add: ((9 integer))
|
||||
cn1: (((1 channel-address)) <- ((init-channel)) ((3 literal)))
|
||||
cn1: (((2 integer)) <- ((copy)) ((34 literal)))
|
||||
cn1: (((3 tagged-value)) <- ((save-type)) ((2 integer)))
|
||||
cn1: (((1 channel-address) (deref)) <- ((write)) ((1 channel-address)) ((3 tagged-value)))
|
||||
cn1: (((5 tagged-value)) ((1 channel-address) (deref)) <- ((read)) ((1 channel-address)))
|
||||
cn1: (((7 integer)) <- ((maybe-coerce)) ((5 tagged-value)) ((integer literal)))
|
||||
cn1: (((8 integer)) <- ((get)) ((1 channel-address) (deref)) ((0 offset)))
|
||||
cn1: (((9 integer)) <- ((get)) ((1 channel-address) (deref)) ((1 offset)))
|
||||
schedule: main
|
||||
run: main 0: (((1 channel-address)) <- ((init-channel)) ((3 literal)))
|
||||
run: init-channel/main 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
|
||||
run: init-channel/main 0: 1000 => ((default-space space-address))
|
||||
run: init-channel/main 1: (((1 channel-address)) <- ((new)) ((channel literal)))
|
||||
run: init-channel/main 1: 1031 => ((1 channel-address))
|
||||
mem: ((1 channel-address)): 1002 <= 1031
|
||||
run: init-channel/main 2: (((2 integer-address)) <- ((get-address)) ((1 channel-address) (deref)) ((0 offset)))
|
||||
run: init-channel/main 2: 1031 => ((2 integer-address))
|
||||
mem: ((2 integer-address)): 1003 <= 1031
|
||||
run: init-channel/main 3: (((2 integer-address) (deref)) <- ((copy)) ((0 literal)))
|
||||
run: init-channel/main 3: 0 => ((2 integer-address) (deref))
|
||||
mem: ((2 integer-address) (deref)): 1031 <= 0
|
||||
run: init-channel/main 4: (((3 integer-address)) <- ((get-address)) ((1 channel-address) (deref)) ((1 offset)))
|
||||
run: init-channel/main 4: 1032 => ((3 integer-address))
|
||||
mem: ((3 integer-address)): 1004 <= 1032
|
||||
run: init-channel/main 5: (((3 integer-address) (deref)) <- ((copy)) ((0 literal)))
|
||||
run: init-channel/main 5: 0 => ((3 integer-address) (deref))
|
||||
mem: ((3 integer-address) (deref)): 1032 <= 0
|
||||
run: init-channel/main 6: (((4 integer)) <- ((next-input)))
|
||||
arg: nil 0 (3)
|
||||
run: init-channel/main 6: 3 => ((4 integer))
|
||||
mem: ((4 integer)): 1005 <= 3
|
||||
run: init-channel/main 7: (((4 integer)) <- ((add)) ((4 integer)) ((1 literal)))
|
||||
mem: ((4 integer)) => 3
|
||||
run: init-channel/main 7: 4 => ((4 integer))
|
||||
mem: ((4 integer)): 1005 <= 4
|
||||
run: init-channel/main 8: (((5 tagged-value-array-address-address)) <- ((get-address)) ((1 channel-address) (deref)) ((2 offset)))
|
||||
run: init-channel/main 8: 1033 => ((5 tagged-value-array-address-address))
|
||||
mem: ((5 tagged-value-array-address-address)): 1006 <= 1033
|
||||
run: init-channel/main 9: (((5 tagged-value-array-address-address) (deref)) <- ((new)) ((tagged-value-array literal)) ((4 integer)))
|
||||
mem: ((4 integer)) => 4
|
||||
run: init-channel/main 9: 1034 => ((5 tagged-value-array-address-address) (deref))
|
||||
mem: ((5 tagged-value-array-address-address) (deref)): 1033 <= 1034
|
||||
run: init-channel/main 10: (((reply)) ((1 channel-address)))
|
||||
mem: ((1 channel-address)) => 1031
|
||||
run: main 0: 1031 => ((1 channel-address))
|
||||
mem: ((1 channel-address)): 1 <= 1031
|
||||
run: main 1: (((2 integer)) <- ((copy)) ((34 literal)))
|
||||
run: main 1: 34 => ((2 integer))
|
||||
mem: ((2 integer)): 2 <= 34
|
||||
run: main 2: (((3 tagged-value)) <- ((save-type)) ((2 integer)))
|
||||
mem: ((2 integer)) => 34
|
||||
run: main 2: #(tagged record (integer 34)) => ((3 tagged-value))
|
||||
mem: ((3 tagged-value)): 3 <= integer
|
||||
mem: ((3 tagged-value)): 4 <= 34
|
||||
run: main 3: (((1 channel-address) (deref)) <- ((write)) ((1 channel-address)) ((3 tagged-value)))
|
||||
mem: ((1 channel-address)) => 1031
|
||||
mem: ((3 tagged-value)) => #(tagged record (integer 34 . nil))
|
||||
run: write/main 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
|
||||
run: write/main 0: 1043 => ((default-space space-address))
|
||||
run: write/main 1: (((1 channel-address)) <- ((next-input)))
|
||||
arg: nil 0 (1031 #(tagged record (integer 34 . nil)))
|
||||
run: write/main 1: 1031 => ((1 channel-address))
|
||||
mem: ((1 channel-address)): 1045 <= 1031
|
||||
run: write/main 2: (((2 tagged-value)) <- ((next-input)))
|
||||
arg: nil 1 (1031 #(tagged record (integer 34 . nil)))
|
||||
run: write/main 2: #(tagged record (integer 34 . nil)) => ((2 tagged-value))
|
||||
mem: ((2 tagged-value)): 1046 <= integer
|
||||
mem: ((2 tagged-value)): 1047 <= 34
|
||||
run: write/main 3: (((4 boolean)) <- ((full?)) ((1 channel-address) (deref)))
|
||||
mem: ((1 channel-address) (deref)) => #(tagged record (0 0 1034 . nil))
|
||||
run: full?/write/main 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
|
||||
run: full?/write/main 0: 1074 => ((default-space space-address))
|
||||
run: full?/write/main 1: (((1 channel)) <- ((next-input)))
|
||||
arg: nil 0 (#(tagged record (0 0 1034 . nil)))
|
||||
run: full?/write/main 1: #(tagged record (0 0 1034 . nil)) => ((1 channel))
|
||||
mem: ((1 channel)): 1076 <= 0
|
||||
mem: ((1 channel)): 1077 <= 0
|
||||
mem: ((1 channel)): 1078 <= 1034
|
||||
run: full?/write/main 2: (((4 integer)) <- ((get)) ((1 channel)) ((1 offset)))
|
||||
mem: ((1077 integer) (raw)) => 0
|
||||
run: full?/write/main 2: 0 => ((4 integer))
|
||||
mem: ((4 integer)): 1079 <= 0
|
||||
run: full?/write/main 3: (((4 integer)) <- ((add)) ((4 integer)) ((1 literal)))
|
||||
mem: ((4 integer)) => 0
|
||||
run: full?/write/main 3: 1 => ((4 integer))
|
||||
mem: ((4 integer)): 1079 <= 1
|
||||
run: full?/write/main 4: (((5 integer)) <- ((capacity)) ((1 channel)))
|
||||
mem: ((1 channel)) => #(tagged record (0 0 1034 . nil))
|
||||
run: capacity/full?/write/main 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
|
||||
run: capacity/full?/write/main 0: 1105 => ((default-space space-address))
|
||||
run: capacity/full?/write/main 1: (((1 channel)) <- ((next-input)))
|
||||
arg: nil 0 (#(tagged record (0 0 1034 . nil)))
|
||||
run: capacity/full?/write/main 1: #(tagged record (0 0 1034 . nil)) => ((1 channel))
|
||||
mem: ((1 channel)): 1107 <= 0
|
||||
mem: ((1 channel)): 1108 <= 0
|
||||
mem: ((1 channel)): 1109 <= 1034
|
||||
run: capacity/full?/write/main 2: (((4 tagged-value-array-address)) <- ((get)) ((1 channel)) ((2 offset)))
|
||||
mem: ((1109 tagged-value-array-address) (raw)) => 1034
|
||||
run: capacity/full?/write/main 2: 1034 => ((4 tagged-value-array-address))
|
||||
mem: ((4 tagged-value-array-address)): 1110 <= 1034
|
||||
run: capacity/full?/write/main 3: (((5 integer)) <- ((length)) ((4 tagged-value-array-address) (deref)))
|
||||
array-len: ((4 tagged-value-array-address) (deref))
|
||||
mem: ((1034 integer) (raw)) => 4
|
||||
run: capacity/full?/write/main 3: 4 => ((5 integer))
|
||||
mem: ((5 integer)): 1111 <= 4
|
||||
run: capacity/full?/write/main 4: (((reply)) ((5 integer)))
|
||||
mem: ((5 integer)) => 4
|
||||
run: full?/write/main 4: 4 => ((5 integer))
|
||||
mem: ((5 integer)): 1080 <= 4
|
||||
run: full?/write/main 5: (((6 boolean)) <- ((less-than)) ((4 integer)) ((5 integer)))
|
||||
mem: ((4 integer)) => 1
|
||||
mem: ((5 integer)) => 4
|
||||
run: full?/write/main 5: t => ((6 boolean))
|
||||
mem: ((6 boolean)): 1081 <= t
|
||||
run: full?/write/main 6: (((jump-if)) ((6 boolean)) ((1 offset)))
|
||||
mem: ((6 boolean)) => t
|
||||
run: full?/write/main 8: (((7 integer)) <- ((get)) ((1 channel)) ((0 offset)))
|
||||
mem: ((1076 integer) (raw)) => 0
|
||||
run: full?/write/main 8: 0 => ((7 integer))
|
||||
mem: ((7 integer)): 1082 <= 0
|
||||
run: full?/write/main 9: (((8 boolean)) <- ((equal)) ((7 integer)) ((4 integer)))
|
||||
mem: ((7 integer)) => 0
|
||||
mem: ((4 integer)) => 1
|
||||
run: full?/write/main 9: nil => ((8 boolean))
|
||||
mem: ((8 boolean)): 1083 <= nil
|
||||
run: full?/write/main 10: (((reply)) ((8 boolean)))
|
||||
mem: ((8 boolean)) => nil
|
||||
run: write/main 3: nil => ((4 boolean))
|
||||
mem: ((4 boolean)): 1048 <= nil
|
||||
run: write/main 4: (((jump-unless)) ((4 boolean)) ((2 offset)))
|
||||
mem: ((4 boolean)) => nil
|
||||
run: write/main 7: (((6 tagged-value-array-address)) <- ((get)) ((1 channel-address) (deref)) ((2 offset)))
|
||||
mem: ((1033 tagged-value-array-address) (raw)) => 1034
|
||||
run: write/main 7: 1034 => ((6 tagged-value-array-address))
|
||||
mem: ((6 tagged-value-array-address)): 1050 <= 1034
|
||||
run: write/main 8: (((7 integer-address)) <- ((get-address)) ((1 channel-address) (deref)) ((1 offset)))
|
||||
run: write/main 8: 1032 => ((7 integer-address))
|
||||
mem: ((7 integer-address)): 1051 <= 1032
|
||||
run: write/main 9: (((8 tagged-value-address)) <- ((index-address)) ((6 tagged-value-array-address) (deref)) ((7 integer-address) (deref)))
|
||||
mem: ((7 integer-address) (deref)) => 0
|
||||
array-len: ((1034 tagged-value-array) (raw))
|
||||
mem: ((1034 integer) (raw)) => 4
|
||||
run: write/main 9: 1035 => ((8 tagged-value-address))
|
||||
mem: ((8 tagged-value-address)): 1052 <= 1035
|
||||
run: write/main 10: (((8 tagged-value-address) (deref)) <- ((copy)) ((2 tagged-value)))
|
||||
mem: ((2 tagged-value)) => #(tagged record (integer 34 . nil))
|
||||
run: write/main 10: #(tagged record (integer 34 . nil)) => ((8 tagged-value-address) (deref))
|
||||
mem: ((8 tagged-value-address) (deref)): 1035 <= integer
|
||||
mem: ((8 tagged-value-address) (deref)): 1036 <= 34
|
||||
run: write/main 11: (((7 integer-address) (deref)) <- ((add)) ((7 integer-address) (deref)) ((1 literal)))
|
||||
mem: ((7 integer-address) (deref)) => 0
|
||||
run: write/main 11: 1 => ((7 integer-address) (deref))
|
||||
mem: ((7 integer-address) (deref)): 1032 <= 1
|
||||
run: write/main 12: (((9 integer)) <- ((length)) ((6 tagged-value-array-address) (deref)))
|
||||
array-len: ((6 tagged-value-array-address) (deref))
|
||||
mem: ((1034 integer) (raw)) => 4
|
||||
run: write/main 12: 4 => ((9 integer))
|
||||
mem: ((9 integer)): 1053 <= 4
|
||||
run: write/main 13: (((10 boolean)) <- ((less-than)) ((7 integer-address) (deref)) ((9 integer)))
|
||||
mem: ((7 integer-address) (deref)) => 1
|
||||
mem: ((9 integer)) => 4
|
||||
run: write/main 13: t => ((10 boolean))
|
||||
mem: ((10 boolean)): 1054 <= t
|
||||
run: write/main 14: (((jump-if)) ((10 boolean)) ((1 offset)))
|
||||
mem: ((10 boolean)) => t
|
||||
run: write/main 16: (((reply)) ((1 channel-address) (deref) (same-as-arg 0)))
|
||||
mem: ((1 channel-address) (deref) (same-as-arg 0)) => #(tagged record (0 1 1034 . nil))
|
||||
run: main 3: #(tagged record (0 1 1034 . nil)) => ((1 channel-address) (deref))
|
||||
mem: ((1 channel-address) (deref)): 1031 <= 0
|
||||
mem: ((1 channel-address) (deref)): 1032 <= 1
|
||||
mem: ((1 channel-address) (deref)): 1033 <= 1034
|
||||
run: main 4: (((5 tagged-value)) ((1 channel-address) (deref)) <- ((read)) ((1 channel-address)))
|
||||
mem: ((1 channel-address)) => 1031
|
||||
run: read/main 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
|
||||
run: read/main 0: 1136 => ((default-space space-address))
|
||||
run: read/main 1: (((1 channel-address)) <- ((next-input)))
|
||||
arg: nil 0 (1031)
|
||||
run: read/main 1: 1031 => ((1 channel-address))
|
||||
mem: ((1 channel-address)): 1138 <= 1031
|
||||
run: read/main 2: (((2 boolean)) <- ((empty?)) ((1 channel-address) (deref)))
|
||||
mem: ((1 channel-address) (deref)) => #(tagged record (0 1 1034 . nil))
|
||||
run: empty?/read/main 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
|
||||
run: empty?/read/main 0: 1167 => ((default-space space-address))
|
||||
run: empty?/read/main 1: (((1 channel)) <- ((next-input)))
|
||||
arg: nil 0 (#(tagged record (0 1 1034 . nil)))
|
||||
run: empty?/read/main 1: #(tagged record (0 1 1034 . nil)) => ((1 channel))
|
||||
mem: ((1 channel)): 1169 <= 0
|
||||
mem: ((1 channel)): 1170 <= 1
|
||||
mem: ((1 channel)): 1171 <= 1034
|
||||
run: empty?/read/main 2: (((4 integer)) <- ((get)) ((1 channel)) ((0 offset)))
|
||||
mem: ((1169 integer) (raw)) => 0
|
||||
run: empty?/read/main 2: 0 => ((4 integer))
|
||||
mem: ((4 integer)): 1172 <= 0
|
||||
run: empty?/read/main 3: (((5 integer)) <- ((get)) ((1 channel)) ((1 offset)))
|
||||
mem: ((1170 integer) (raw)) => 1
|
||||
run: empty?/read/main 3: 1 => ((5 integer))
|
||||
mem: ((5 integer)): 1173 <= 1
|
||||
run: empty?/read/main 4: (((6 boolean)) <- ((equal)) ((4 integer)) ((5 integer)))
|
||||
mem: ((4 integer)) => 0
|
||||
mem: ((5 integer)) => 1
|
||||
run: empty?/read/main 4: nil => ((6 boolean))
|
||||
mem: ((6 boolean)): 1174 <= nil
|
||||
run: empty?/read/main 5: (((reply)) ((6 boolean)))
|
||||
mem: ((6 boolean)) => nil
|
||||
run: read/main 2: nil => ((2 boolean))
|
||||
mem: ((2 boolean)): 1139 <= nil
|
||||
run: read/main 3: (((jump-unless)) ((2 boolean)) ((2 offset)))
|
||||
mem: ((2 boolean)) => nil
|
||||
run: read/main 6: (((4 integer-address)) <- ((get-address)) ((1 channel-address) (deref)) ((0 offset)))
|
||||
run: read/main 6: 1031 => ((4 integer-address))
|
||||
mem: ((4 integer-address)): 1141 <= 1031
|
||||
run: read/main 7: (((5 tagged-value-array-address)) <- ((get)) ((1 channel-address) (deref)) ((2 offset)))
|
||||
mem: ((1033 tagged-value-array-address) (raw)) => 1034
|
||||
run: read/main 7: 1034 => ((5 tagged-value-array-address))
|
||||
mem: ((5 tagged-value-array-address)): 1142 <= 1034
|
||||
run: read/main 8: (((6 tagged-value)) <- ((index)) ((5 tagged-value-array-address) (deref)) ((4 integer-address) (deref)))
|
||||
mem: ((4 integer-address) (deref)) => 0
|
||||
array-len: ((1034 tagged-value-array) (raw))
|
||||
mem: ((1034 integer) (raw)) => 4
|
||||
mem: ((1035 tagged-value) (raw)) => #(tagged record (integer 34 . nil))
|
||||
run: read/main 8: #(tagged record (integer 34 . nil)) => ((6 tagged-value))
|
||||
mem: ((6 tagged-value)): 1143 <= integer
|
||||
mem: ((6 tagged-value)): 1144 <= 34
|
||||
run: read/main 9: (((4 integer-address) (deref)) <- ((add)) ((4 integer-address) (deref)) ((1 literal)))
|
||||
mem: ((4 integer-address) (deref)) => 0
|
||||
run: read/main 9: 1 => ((4 integer-address) (deref))
|
||||
mem: ((4 integer-address) (deref)): 1031 <= 1
|
||||
run: read/main 10: (((8 integer)) <- ((length)) ((5 tagged-value-array-address) (deref)))
|
||||
array-len: ((5 tagged-value-array-address) (deref))
|
||||
mem: ((1034 integer) (raw)) => 4
|
||||
run: read/main 10: 4 => ((8 integer))
|
||||
mem: ((8 integer)): 1145 <= 4
|
||||
run: read/main 11: (((9 boolean)) <- ((less-than)) ((4 integer-address) (deref)) ((8 integer)))
|
||||
mem: ((4 integer-address) (deref)) => 1
|
||||
mem: ((8 integer)) => 4
|
||||
run: read/main 11: t => ((9 boolean))
|
||||
mem: ((9 boolean)): 1146 <= t
|
||||
run: read/main 12: (((jump-if)) ((9 boolean)) ((1 offset)))
|
||||
mem: ((9 boolean)) => t
|
||||
run: read/main 14: (((reply)) ((6 tagged-value)) ((1 channel-address) (deref) (same-as-arg 0)))
|
||||
mem: ((6 tagged-value)) => #(tagged record (integer 34 . nil))
|
||||
mem: ((1 channel-address) (deref) (same-as-arg 0)) => #(tagged record (1 1 1034 . nil))
|
||||
run: main 4: #(tagged record (integer 34 . nil)) => ((5 tagged-value))
|
||||
mem: ((5 tagged-value)): 5 <= integer
|
||||
mem: ((5 tagged-value)): 6 <= 34
|
||||
run: main 4: #(tagged record (1 1 1034 . nil)) => ((1 channel-address) (deref))
|
||||
mem: ((1 channel-address) (deref)): 1031 <= 1
|
||||
mem: ((1 channel-address) (deref)): 1032 <= 1
|
||||
mem: ((1 channel-address) (deref)): 1033 <= 1034
|
||||
run: main 5: (((7 integer)) <- ((maybe-coerce)) ((5 tagged-value)) ((integer literal)))
|
||||
mem: ((5 tagged-value)) => #(tagged record (integer 34 . nil))
|
||||
run: maybe-coerce/main 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
|
||||
run: maybe-coerce/main 0: 1198 => ((default-space space-address))
|
||||
run: maybe-coerce/main 1: (((1 tagged-value-address)) <- ((new)) ((tagged-value literal)))
|
||||
run: maybe-coerce/main 1: 1229 => ((1 tagged-value-address))
|
||||
mem: ((1 tagged-value-address)): 1200 <= 1229
|
||||
run: maybe-coerce/main 2: (((1 tagged-value-address) (deref)) <- ((next-input)))
|
||||
arg: nil 0 (#(tagged record (integer 34 . nil)) integer)
|
||||
run: maybe-coerce/main 2: #(tagged record (integer 34 . nil)) => ((1 tagged-value-address) (deref))
|
||||
mem: ((1 tagged-value-address) (deref)): 1229 <= integer
|
||||
mem: ((1 tagged-value-address) (deref)): 1230 <= 34
|
||||
run: maybe-coerce/main 3: (((2 type)) <- ((next-input)))
|
||||
arg: nil 1 (#(tagged record (integer 34 . nil)) integer)
|
||||
run: maybe-coerce/main 3: integer => ((2 type))
|
||||
mem: ((2 type)): 1201 <= integer
|
||||
run: maybe-coerce/main 4: (((3 type)) <- ((get)) ((1 tagged-value-address) (deref)) ((0 offset)))
|
||||
mem: ((1229 type) (raw)) => integer
|
||||
run: maybe-coerce/main 4: integer => ((3 type))
|
||||
mem: ((3 type)): 1202 <= integer
|
||||
run: maybe-coerce/main 5: (((4 boolean)) <- ((equal)) ((3 type)) ((2 type)))
|
||||
mem: ((3 type)) => integer
|
||||
mem: ((2 type)) => integer
|
||||
run: maybe-coerce/main 5: t => ((4 boolean))
|
||||
mem: ((4 boolean)): 1203 <= t
|
||||
run: maybe-coerce/main 6: (((jump-if)) ((4 boolean)) ((1 offset)))
|
||||
mem: ((4 boolean)) => t
|
||||
run: maybe-coerce/main 8: (((5 location)) <- ((get)) ((1 tagged-value-address) (deref)) ((1 offset)))
|
||||
mem: ((1230 location) (raw)) => 34
|
||||
run: maybe-coerce/main 8: 34 => ((5 location))
|
||||
mem: ((5 location)): 1204 <= 34
|
||||
run: maybe-coerce/main 9: (((reply)) ((5 location)) ((4 boolean)))
|
||||
mem: ((5 location)) => 34
|
||||
mem: ((4 boolean)) => t
|
||||
run: main 5: 34 => ((7 integer))
|
||||
mem: ((7 integer)): 7 <= 34
|
||||
run: main 6: (((8 integer)) <- ((get)) ((1 channel-address) (deref)) ((0 offset)))
|
||||
mem: ((1031 integer) (raw)) => 1
|
||||
run: main 6: 1 => ((8 integer))
|
||||
mem: ((8 integer)): 8 <= 1
|
||||
run: main 7: (((9 integer)) <- ((get)) ((1 channel-address) (deref)) ((1 offset)))
|
||||
mem: ((1032 integer) (raw)) => 1
|
||||
run: main 7: 1 => ((9 integer))
|
||||
mem: ((9 integer)): 9 <= 1
|
||||
schedule: done with routine nil
|
||||
|
|
@ -0,0 +1,99 @@
|
|||
c{0: 0 (((1 channel-address)) <- ((init-channel)) ((3 literal))) -- nil
|
||||
c{0: 1 (((2 tagged-value)) ((1 channel-address) (deref)) <- ((read)) ((1 channel-address))) -- nil
|
||||
c{1: 0 ✓ (((1 channel-address)) <- ((init-channel)) ((3 literal)))
|
||||
c{1: 1 ✓ (((2 tagged-value)) ((1 channel-address) (deref)) <- ((read)) ((1 channel-address)))
|
||||
cn0: convert-names in main
|
||||
cn0: (((1 channel-address)) <- ((init-channel)) ((3 literal))) nil nil
|
||||
cn0: checking arg ((3 literal))
|
||||
cn0: checking oarg ((1 channel-address))
|
||||
maybe-add: ((1 channel-address))
|
||||
cn0: (((2 tagged-value)) ((1 channel-address) (deref)) <- ((read)) ((1 channel-address))) nil nil
|
||||
cn0: checking arg ((1 channel-address))
|
||||
maybe-add: ((1 channel-address))
|
||||
cn0: checking oarg ((2 tagged-value))
|
||||
maybe-add: ((2 tagged-value))
|
||||
cn0: checking oarg ((1 channel-address) (deref))
|
||||
maybe-add: ((1 channel-address) (deref))
|
||||
cn1: (((1 channel-address)) <- ((init-channel)) ((3 literal)))
|
||||
cn1: (((2 tagged-value)) ((1 channel-address) (deref)) <- ((read)) ((1 channel-address)))
|
||||
schedule: main
|
||||
run: main 0: (((1 channel-address)) <- ((init-channel)) ((3 literal)))
|
||||
run: init-channel/main 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
|
||||
run: init-channel/main 0: 1000 => ((default-space space-address))
|
||||
run: init-channel/main 1: (((1 channel-address)) <- ((new)) ((channel literal)))
|
||||
run: init-channel/main 1: 1031 => ((1 channel-address))
|
||||
mem: ((1 channel-address)): 1002 <= 1031
|
||||
run: init-channel/main 2: (((2 integer-address)) <- ((get-address)) ((1 channel-address) (deref)) ((0 offset)))
|
||||
run: init-channel/main 2: 1031 => ((2 integer-address))
|
||||
mem: ((2 integer-address)): 1003 <= 1031
|
||||
run: init-channel/main 3: (((2 integer-address) (deref)) <- ((copy)) ((0 literal)))
|
||||
run: init-channel/main 3: 0 => ((2 integer-address) (deref))
|
||||
mem: ((2 integer-address) (deref)): 1031 <= 0
|
||||
run: init-channel/main 4: (((3 integer-address)) <- ((get-address)) ((1 channel-address) (deref)) ((1 offset)))
|
||||
run: init-channel/main 4: 1032 => ((3 integer-address))
|
||||
mem: ((3 integer-address)): 1004 <= 1032
|
||||
run: init-channel/main 5: (((3 integer-address) (deref)) <- ((copy)) ((0 literal)))
|
||||
run: init-channel/main 5: 0 => ((3 integer-address) (deref))
|
||||
mem: ((3 integer-address) (deref)): 1032 <= 0
|
||||
run: init-channel/main 6: (((4 integer)) <- ((next-input)))
|
||||
arg: nil 0 (3)
|
||||
run: init-channel/main 6: 3 => ((4 integer))
|
||||
mem: ((4 integer)): 1005 <= 3
|
||||
run: init-channel/main 7: (((4 integer)) <- ((add)) ((4 integer)) ((1 literal)))
|
||||
mem: ((4 integer)) => 3
|
||||
run: init-channel/main 7: 4 => ((4 integer))
|
||||
mem: ((4 integer)): 1005 <= 4
|
||||
run: init-channel/main 8: (((5 tagged-value-array-address-address)) <- ((get-address)) ((1 channel-address) (deref)) ((2 offset)))
|
||||
run: init-channel/main 8: 1033 => ((5 tagged-value-array-address-address))
|
||||
mem: ((5 tagged-value-array-address-address)): 1006 <= 1033
|
||||
run: init-channel/main 9: (((5 tagged-value-array-address-address) (deref)) <- ((new)) ((tagged-value-array literal)) ((4 integer)))
|
||||
mem: ((4 integer)) => 4
|
||||
run: init-channel/main 9: 1034 => ((5 tagged-value-array-address-address) (deref))
|
||||
mem: ((5 tagged-value-array-address-address) (deref)): 1033 <= 1034
|
||||
run: init-channel/main 10: (((reply)) ((1 channel-address)))
|
||||
mem: ((1 channel-address)) => 1031
|
||||
run: main 0: 1031 => ((1 channel-address))
|
||||
mem: ((1 channel-address)): 1 <= 1031
|
||||
run: main 1: (((2 tagged-value)) ((1 channel-address) (deref)) <- ((read)) ((1 channel-address)))
|
||||
mem: ((1 channel-address)) => 1031
|
||||
run: read/main 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
|
||||
run: read/main 0: 1043 => ((default-space space-address))
|
||||
run: read/main 1: (((1 channel-address)) <- ((next-input)))
|
||||
arg: nil 0 (1031)
|
||||
run: read/main 1: 1031 => ((1 channel-address))
|
||||
mem: ((1 channel-address)): 1045 <= 1031
|
||||
run: read/main 2: (((2 boolean)) <- ((empty?)) ((1 channel-address) (deref)))
|
||||
mem: ((1 channel-address) (deref)) => #(tagged record (0 0 1034 . nil))
|
||||
run: empty?/read/main 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
|
||||
run: empty?/read/main 0: 1074 => ((default-space space-address))
|
||||
run: empty?/read/main 1: (((1 channel)) <- ((next-input)))
|
||||
arg: nil 0 (#(tagged record (0 0 1034 . nil)))
|
||||
run: empty?/read/main 1: #(tagged record (0 0 1034 . nil)) => ((1 channel))
|
||||
mem: ((1 channel)): 1076 <= 0
|
||||
mem: ((1 channel)): 1077 <= 0
|
||||
mem: ((1 channel)): 1078 <= 1034
|
||||
run: empty?/read/main 2: (((4 integer)) <- ((get)) ((1 channel)) ((0 offset)))
|
||||
mem: ((1076 integer) (raw)) => 0
|
||||
run: empty?/read/main 2: 0 => ((4 integer))
|
||||
mem: ((4 integer)): 1079 <= 0
|
||||
run: empty?/read/main 3: (((5 integer)) <- ((get)) ((1 channel)) ((1 offset)))
|
||||
mem: ((1077 integer) (raw)) => 0
|
||||
run: empty?/read/main 3: 0 => ((5 integer))
|
||||
mem: ((5 integer)): 1080 <= 0
|
||||
run: empty?/read/main 4: (((6 boolean)) <- ((equal)) ((4 integer)) ((5 integer)))
|
||||
mem: ((4 integer)) => 0
|
||||
mem: ((5 integer)) => 0
|
||||
run: empty?/read/main 4: t => ((6 boolean))
|
||||
mem: ((6 boolean)): 1081 <= t
|
||||
run: empty?/read/main 5: (((reply)) ((6 boolean)))
|
||||
mem: ((6 boolean)) => t
|
||||
run: read/main 2: t => ((2 boolean))
|
||||
mem: ((2 boolean)): 1046 <= t
|
||||
run: read/main 3: (((jump-unless)) ((2 boolean)) ((2 offset)))
|
||||
mem: ((2 boolean)) => t
|
||||
run: read/main 4: (((3 integer-address)) <- ((get-address)) ((1 channel-address) (deref)) ((1 offset)))
|
||||
run: read/main 4: 1032 => ((3 integer-address))
|
||||
mem: ((3 integer-address)): 1047 <= 1032
|
||||
run: read/main 5: (((sleep)) ((until-location-changes literal)) ((3 integer-address) (deref)))
|
||||
mem: ((3 integer-address) (deref)) => 0
|
||||
schedule: pushing read/main to sleep queue
|
||||
|
|
@ -0,0 +1,386 @@
|
|||
c{0: 0 (((1 channel-address)) <- ((init-channel)) ((3 literal))) -- nil
|
||||
c{0: 1 (((2 integer)) <- ((copy)) ((34 literal))) -- nil
|
||||
c{0: 2 (((3 tagged-value)) <- ((save-type)) ((2 integer))) -- nil
|
||||
c{0: 3 (((1 channel-address) (deref)) <- ((write)) ((1 channel-address)) ((3 tagged-value))) -- nil
|
||||
c{0: 4 (_ ((1 channel-address) (deref)) <- ((read)) ((1 channel-address))) -- nil
|
||||
c{0: 5 (((5 boolean)) <- ((empty?)) ((1 channel-address) (deref))) -- nil
|
||||
c{0: 6 (((6 boolean)) <- ((full?)) ((1 channel-address) (deref))) -- nil
|
||||
c{1: 0 ✓ (((1 channel-address)) <- ((init-channel)) ((3 literal)))
|
||||
c{1: 1 ✓ (((2 integer)) <- ((copy)) ((34 literal)))
|
||||
c{1: 2 ✓ (((3 tagged-value)) <- ((save-type)) ((2 integer)))
|
||||
c{1: 3 ✓ (((1 channel-address) (deref)) <- ((write)) ((1 channel-address)) ((3 tagged-value)))
|
||||
c{1: 4 ✓ (_ ((1 channel-address) (deref)) <- ((read)) ((1 channel-address)))
|
||||
c{1: 5 ✓ (((5 boolean)) <- ((empty?)) ((1 channel-address) (deref)))
|
||||
c{1: 6 ✓ (((6 boolean)) <- ((full?)) ((1 channel-address) (deref)))
|
||||
cn0: convert-names in main
|
||||
cn0: (((1 channel-address)) <- ((init-channel)) ((3 literal))) nil nil
|
||||
cn0: checking arg ((3 literal))
|
||||
cn0: checking oarg ((1 channel-address))
|
||||
maybe-add: ((1 channel-address))
|
||||
cn0: (((2 integer)) <- ((copy)) ((34 literal))) nil nil
|
||||
cn0: checking arg ((34 literal))
|
||||
cn0: checking oarg ((2 integer))
|
||||
maybe-add: ((2 integer))
|
||||
cn0: (((3 tagged-value)) <- ((save-type)) ((2 integer))) nil nil
|
||||
cn0: checking arg ((2 integer))
|
||||
maybe-add: ((2 integer))
|
||||
cn0: checking oarg ((3 tagged-value))
|
||||
maybe-add: ((3 tagged-value))
|
||||
cn0: (((1 channel-address) (deref)) <- ((write)) ((1 channel-address)) ((3 tagged-value))) nil nil
|
||||
cn0: checking arg ((1 channel-address))
|
||||
maybe-add: ((1 channel-address))
|
||||
cn0: checking arg ((3 tagged-value))
|
||||
maybe-add: ((3 tagged-value))
|
||||
cn0: checking oarg ((1 channel-address) (deref))
|
||||
maybe-add: ((1 channel-address) (deref))
|
||||
cn0: (_ ((1 channel-address) (deref)) <- ((read)) ((1 channel-address))) nil nil
|
||||
cn0: checking arg ((1 channel-address))
|
||||
maybe-add: ((1 channel-address))
|
||||
cn0: checking oarg _
|
||||
cn0: checking oarg ((1 channel-address) (deref))
|
||||
maybe-add: ((1 channel-address) (deref))
|
||||
cn0: (((5 boolean)) <- ((empty?)) ((1 channel-address) (deref))) nil nil
|
||||
cn0: checking arg ((1 channel-address) (deref))
|
||||
maybe-add: ((1 channel-address) (deref))
|
||||
cn0: checking oarg ((5 boolean))
|
||||
maybe-add: ((5 boolean))
|
||||
cn0: (((6 boolean)) <- ((full?)) ((1 channel-address) (deref))) nil nil
|
||||
cn0: checking arg ((1 channel-address) (deref))
|
||||
maybe-add: ((1 channel-address) (deref))
|
||||
cn0: checking oarg ((6 boolean))
|
||||
maybe-add: ((6 boolean))
|
||||
cn1: (((1 channel-address)) <- ((init-channel)) ((3 literal)))
|
||||
cn1: (((2 integer)) <- ((copy)) ((34 literal)))
|
||||
cn1: (((3 tagged-value)) <- ((save-type)) ((2 integer)))
|
||||
cn1: (((1 channel-address) (deref)) <- ((write)) ((1 channel-address)) ((3 tagged-value)))
|
||||
cn1: (_ ((1 channel-address) (deref)) <- ((read)) ((1 channel-address)))
|
||||
cn1: (((5 boolean)) <- ((empty?)) ((1 channel-address) (deref)))
|
||||
cn1: (((6 boolean)) <- ((full?)) ((1 channel-address) (deref)))
|
||||
schedule: main
|
||||
run: main 0: (((1 channel-address)) <- ((init-channel)) ((3 literal)))
|
||||
run: init-channel/main 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
|
||||
run: init-channel/main 0: 1000 => ((default-space space-address))
|
||||
run: init-channel/main 1: (((1 channel-address)) <- ((new)) ((channel literal)))
|
||||
run: init-channel/main 1: 1031 => ((1 channel-address))
|
||||
mem: ((1 channel-address)): 1002 <= 1031
|
||||
run: init-channel/main 2: (((2 integer-address)) <- ((get-address)) ((1 channel-address) (deref)) ((0 offset)))
|
||||
run: init-channel/main 2: 1031 => ((2 integer-address))
|
||||
mem: ((2 integer-address)): 1003 <= 1031
|
||||
run: init-channel/main 3: (((2 integer-address) (deref)) <- ((copy)) ((0 literal)))
|
||||
run: init-channel/main 3: 0 => ((2 integer-address) (deref))
|
||||
mem: ((2 integer-address) (deref)): 1031 <= 0
|
||||
run: init-channel/main 4: (((3 integer-address)) <- ((get-address)) ((1 channel-address) (deref)) ((1 offset)))
|
||||
run: init-channel/main 4: 1032 => ((3 integer-address))
|
||||
mem: ((3 integer-address)): 1004 <= 1032
|
||||
run: init-channel/main 5: (((3 integer-address) (deref)) <- ((copy)) ((0 literal)))
|
||||
run: init-channel/main 5: 0 => ((3 integer-address) (deref))
|
||||
mem: ((3 integer-address) (deref)): 1032 <= 0
|
||||
run: init-channel/main 6: (((4 integer)) <- ((next-input)))
|
||||
arg: nil 0 (3)
|
||||
run: init-channel/main 6: 3 => ((4 integer))
|
||||
mem: ((4 integer)): 1005 <= 3
|
||||
run: init-channel/main 7: (((4 integer)) <- ((add)) ((4 integer)) ((1 literal)))
|
||||
mem: ((4 integer)) => 3
|
||||
run: init-channel/main 7: 4 => ((4 integer))
|
||||
mem: ((4 integer)): 1005 <= 4
|
||||
run: init-channel/main 8: (((5 tagged-value-array-address-address)) <- ((get-address)) ((1 channel-address) (deref)) ((2 offset)))
|
||||
run: init-channel/main 8: 1033 => ((5 tagged-value-array-address-address))
|
||||
mem: ((5 tagged-value-array-address-address)): 1006 <= 1033
|
||||
run: init-channel/main 9: (((5 tagged-value-array-address-address) (deref)) <- ((new)) ((tagged-value-array literal)) ((4 integer)))
|
||||
mem: ((4 integer)) => 4
|
||||
run: init-channel/main 9: 1034 => ((5 tagged-value-array-address-address) (deref))
|
||||
mem: ((5 tagged-value-array-address-address) (deref)): 1033 <= 1034
|
||||
run: init-channel/main 10: (((reply)) ((1 channel-address)))
|
||||
mem: ((1 channel-address)) => 1031
|
||||
run: main 0: 1031 => ((1 channel-address))
|
||||
mem: ((1 channel-address)): 1 <= 1031
|
||||
run: main 1: (((2 integer)) <- ((copy)) ((34 literal)))
|
||||
run: main 1: 34 => ((2 integer))
|
||||
mem: ((2 integer)): 2 <= 34
|
||||
run: main 2: (((3 tagged-value)) <- ((save-type)) ((2 integer)))
|
||||
mem: ((2 integer)) => 34
|
||||
run: main 2: #(tagged record (integer 34)) => ((3 tagged-value))
|
||||
mem: ((3 tagged-value)): 3 <= integer
|
||||
mem: ((3 tagged-value)): 4 <= 34
|
||||
run: main 3: (((1 channel-address) (deref)) <- ((write)) ((1 channel-address)) ((3 tagged-value)))
|
||||
mem: ((1 channel-address)) => 1031
|
||||
mem: ((3 tagged-value)) => #(tagged record (integer 34 . nil))
|
||||
run: write/main 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
|
||||
run: write/main 0: 1043 => ((default-space space-address))
|
||||
run: write/main 1: (((1 channel-address)) <- ((next-input)))
|
||||
arg: nil 0 (1031 #(tagged record (integer 34 . nil)))
|
||||
run: write/main 1: 1031 => ((1 channel-address))
|
||||
mem: ((1 channel-address)): 1045 <= 1031
|
||||
run: write/main 2: (((2 tagged-value)) <- ((next-input)))
|
||||
arg: nil 1 (1031 #(tagged record (integer 34 . nil)))
|
||||
run: write/main 2: #(tagged record (integer 34 . nil)) => ((2 tagged-value))
|
||||
mem: ((2 tagged-value)): 1046 <= integer
|
||||
mem: ((2 tagged-value)): 1047 <= 34
|
||||
run: write/main 3: (((4 boolean)) <- ((full?)) ((1 channel-address) (deref)))
|
||||
mem: ((1 channel-address) (deref)) => #(tagged record (0 0 1034 . nil))
|
||||
run: full?/write/main 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
|
||||
run: full?/write/main 0: 1074 => ((default-space space-address))
|
||||
run: full?/write/main 1: (((1 channel)) <- ((next-input)))
|
||||
arg: nil 0 (#(tagged record (0 0 1034 . nil)))
|
||||
run: full?/write/main 1: #(tagged record (0 0 1034 . nil)) => ((1 channel))
|
||||
mem: ((1 channel)): 1076 <= 0
|
||||
mem: ((1 channel)): 1077 <= 0
|
||||
mem: ((1 channel)): 1078 <= 1034
|
||||
run: full?/write/main 2: (((4 integer)) <- ((get)) ((1 channel)) ((1 offset)))
|
||||
mem: ((1077 integer) (raw)) => 0
|
||||
run: full?/write/main 2: 0 => ((4 integer))
|
||||
mem: ((4 integer)): 1079 <= 0
|
||||
run: full?/write/main 3: (((4 integer)) <- ((add)) ((4 integer)) ((1 literal)))
|
||||
mem: ((4 integer)) => 0
|
||||
run: full?/write/main 3: 1 => ((4 integer))
|
||||
mem: ((4 integer)): 1079 <= 1
|
||||
run: full?/write/main 4: (((5 integer)) <- ((capacity)) ((1 channel)))
|
||||
mem: ((1 channel)) => #(tagged record (0 0 1034 . nil))
|
||||
run: capacity/full?/write/main 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
|
||||
run: capacity/full?/write/main 0: 1105 => ((default-space space-address))
|
||||
run: capacity/full?/write/main 1: (((1 channel)) <- ((next-input)))
|
||||
arg: nil 0 (#(tagged record (0 0 1034 . nil)))
|
||||
run: capacity/full?/write/main 1: #(tagged record (0 0 1034 . nil)) => ((1 channel))
|
||||
mem: ((1 channel)): 1107 <= 0
|
||||
mem: ((1 channel)): 1108 <= 0
|
||||
mem: ((1 channel)): 1109 <= 1034
|
||||
run: capacity/full?/write/main 2: (((4 tagged-value-array-address)) <- ((get)) ((1 channel)) ((2 offset)))
|
||||
mem: ((1109 tagged-value-array-address) (raw)) => 1034
|
||||
run: capacity/full?/write/main 2: 1034 => ((4 tagged-value-array-address))
|
||||
mem: ((4 tagged-value-array-address)): 1110 <= 1034
|
||||
run: capacity/full?/write/main 3: (((5 integer)) <- ((length)) ((4 tagged-value-array-address) (deref)))
|
||||
array-len: ((4 tagged-value-array-address) (deref))
|
||||
mem: ((1034 integer) (raw)) => 4
|
||||
run: capacity/full?/write/main 3: 4 => ((5 integer))
|
||||
mem: ((5 integer)): 1111 <= 4
|
||||
run: capacity/full?/write/main 4: (((reply)) ((5 integer)))
|
||||
mem: ((5 integer)) => 4
|
||||
run: full?/write/main 4: 4 => ((5 integer))
|
||||
mem: ((5 integer)): 1080 <= 4
|
||||
run: full?/write/main 5: (((6 boolean)) <- ((less-than)) ((4 integer)) ((5 integer)))
|
||||
mem: ((4 integer)) => 1
|
||||
mem: ((5 integer)) => 4
|
||||
run: full?/write/main 5: t => ((6 boolean))
|
||||
mem: ((6 boolean)): 1081 <= t
|
||||
run: full?/write/main 6: (((jump-if)) ((6 boolean)) ((1 offset)))
|
||||
mem: ((6 boolean)) => t
|
||||
run: full?/write/main 8: (((7 integer)) <- ((get)) ((1 channel)) ((0 offset)))
|
||||
mem: ((1076 integer) (raw)) => 0
|
||||
run: full?/write/main 8: 0 => ((7 integer))
|
||||
mem: ((7 integer)): 1082 <= 0
|
||||
run: full?/write/main 9: (((8 boolean)) <- ((equal)) ((7 integer)) ((4 integer)))
|
||||
mem: ((7 integer)) => 0
|
||||
mem: ((4 integer)) => 1
|
||||
run: full?/write/main 9: nil => ((8 boolean))
|
||||
mem: ((8 boolean)): 1083 <= nil
|
||||
run: full?/write/main 10: (((reply)) ((8 boolean)))
|
||||
mem: ((8 boolean)) => nil
|
||||
run: write/main 3: nil => ((4 boolean))
|
||||
mem: ((4 boolean)): 1048 <= nil
|
||||
run: write/main 4: (((jump-unless)) ((4 boolean)) ((2 offset)))
|
||||
mem: ((4 boolean)) => nil
|
||||
run: write/main 7: (((6 tagged-value-array-address)) <- ((get)) ((1 channel-address) (deref)) ((2 offset)))
|
||||
mem: ((1033 tagged-value-array-address) (raw)) => 1034
|
||||
run: write/main 7: 1034 => ((6 tagged-value-array-address))
|
||||
mem: ((6 tagged-value-array-address)): 1050 <= 1034
|
||||
run: write/main 8: (((7 integer-address)) <- ((get-address)) ((1 channel-address) (deref)) ((1 offset)))
|
||||
run: write/main 8: 1032 => ((7 integer-address))
|
||||
mem: ((7 integer-address)): 1051 <= 1032
|
||||
run: write/main 9: (((8 tagged-value-address)) <- ((index-address)) ((6 tagged-value-array-address) (deref)) ((7 integer-address) (deref)))
|
||||
mem: ((7 integer-address) (deref)) => 0
|
||||
array-len: ((1034 tagged-value-array) (raw))
|
||||
mem: ((1034 integer) (raw)) => 4
|
||||
run: write/main 9: 1035 => ((8 tagged-value-address))
|
||||
mem: ((8 tagged-value-address)): 1052 <= 1035
|
||||
run: write/main 10: (((8 tagged-value-address) (deref)) <- ((copy)) ((2 tagged-value)))
|
||||
mem: ((2 tagged-value)) => #(tagged record (integer 34 . nil))
|
||||
run: write/main 10: #(tagged record (integer 34 . nil)) => ((8 tagged-value-address) (deref))
|
||||
mem: ((8 tagged-value-address) (deref)): 1035 <= integer
|
||||
mem: ((8 tagged-value-address) (deref)): 1036 <= 34
|
||||
run: write/main 11: (((7 integer-address) (deref)) <- ((add)) ((7 integer-address) (deref)) ((1 literal)))
|
||||
mem: ((7 integer-address) (deref)) => 0
|
||||
run: write/main 11: 1 => ((7 integer-address) (deref))
|
||||
mem: ((7 integer-address) (deref)): 1032 <= 1
|
||||
run: write/main 12: (((9 integer)) <- ((length)) ((6 tagged-value-array-address) (deref)))
|
||||
array-len: ((6 tagged-value-array-address) (deref))
|
||||
mem: ((1034 integer) (raw)) => 4
|
||||
run: write/main 12: 4 => ((9 integer))
|
||||
mem: ((9 integer)): 1053 <= 4
|
||||
run: write/main 13: (((10 boolean)) <- ((less-than)) ((7 integer-address) (deref)) ((9 integer)))
|
||||
mem: ((7 integer-address) (deref)) => 1
|
||||
mem: ((9 integer)) => 4
|
||||
run: write/main 13: t => ((10 boolean))
|
||||
mem: ((10 boolean)): 1054 <= t
|
||||
run: write/main 14: (((jump-if)) ((10 boolean)) ((1 offset)))
|
||||
mem: ((10 boolean)) => t
|
||||
run: write/main 16: (((reply)) ((1 channel-address) (deref) (same-as-arg 0)))
|
||||
mem: ((1 channel-address) (deref) (same-as-arg 0)) => #(tagged record (0 1 1034 . nil))
|
||||
run: main 3: #(tagged record (0 1 1034 . nil)) => ((1 channel-address) (deref))
|
||||
mem: ((1 channel-address) (deref)): 1031 <= 0
|
||||
mem: ((1 channel-address) (deref)): 1032 <= 1
|
||||
mem: ((1 channel-address) (deref)): 1033 <= 1034
|
||||
run: main 4: (_ ((1 channel-address) (deref)) <- ((read)) ((1 channel-address)))
|
||||
mem: ((1 channel-address)) => 1031
|
||||
run: read/main 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
|
||||
run: read/main 0: 1136 => ((default-space space-address))
|
||||
run: read/main 1: (((1 channel-address)) <- ((next-input)))
|
||||
arg: nil 0 (1031)
|
||||
run: read/main 1: 1031 => ((1 channel-address))
|
||||
mem: ((1 channel-address)): 1138 <= 1031
|
||||
run: read/main 2: (((2 boolean)) <- ((empty?)) ((1 channel-address) (deref)))
|
||||
mem: ((1 channel-address) (deref)) => #(tagged record (0 1 1034 . nil))
|
||||
run: empty?/read/main 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
|
||||
run: empty?/read/main 0: 1167 => ((default-space space-address))
|
||||
run: empty?/read/main 1: (((1 channel)) <- ((next-input)))
|
||||
arg: nil 0 (#(tagged record (0 1 1034 . nil)))
|
||||
run: empty?/read/main 1: #(tagged record (0 1 1034 . nil)) => ((1 channel))
|
||||
mem: ((1 channel)): 1169 <= 0
|
||||
mem: ((1 channel)): 1170 <= 1
|
||||
mem: ((1 channel)): 1171 <= 1034
|
||||
run: empty?/read/main 2: (((4 integer)) <- ((get)) ((1 channel)) ((0 offset)))
|
||||
mem: ((1169 integer) (raw)) => 0
|
||||
run: empty?/read/main 2: 0 => ((4 integer))
|
||||
mem: ((4 integer)): 1172 <= 0
|
||||
run: empty?/read/main 3: (((5 integer)) <- ((get)) ((1 channel)) ((1 offset)))
|
||||
mem: ((1170 integer) (raw)) => 1
|
||||
run: empty?/read/main 3: 1 => ((5 integer))
|
||||
mem: ((5 integer)): 1173 <= 1
|
||||
run: empty?/read/main 4: (((6 boolean)) <- ((equal)) ((4 integer)) ((5 integer)))
|
||||
mem: ((4 integer)) => 0
|
||||
mem: ((5 integer)) => 1
|
||||
run: empty?/read/main 4: nil => ((6 boolean))
|
||||
mem: ((6 boolean)): 1174 <= nil
|
||||
run: empty?/read/main 5: (((reply)) ((6 boolean)))
|
||||
mem: ((6 boolean)) => nil
|
||||
run: read/main 2: nil => ((2 boolean))
|
||||
mem: ((2 boolean)): 1139 <= nil
|
||||
run: read/main 3: (((jump-unless)) ((2 boolean)) ((2 offset)))
|
||||
mem: ((2 boolean)) => nil
|
||||
run: read/main 6: (((4 integer-address)) <- ((get-address)) ((1 channel-address) (deref)) ((0 offset)))
|
||||
run: read/main 6: 1031 => ((4 integer-address))
|
||||
mem: ((4 integer-address)): 1141 <= 1031
|
||||
run: read/main 7: (((5 tagged-value-array-address)) <- ((get)) ((1 channel-address) (deref)) ((2 offset)))
|
||||
mem: ((1033 tagged-value-array-address) (raw)) => 1034
|
||||
run: read/main 7: 1034 => ((5 tagged-value-array-address))
|
||||
mem: ((5 tagged-value-array-address)): 1142 <= 1034
|
||||
run: read/main 8: (((6 tagged-value)) <- ((index)) ((5 tagged-value-array-address) (deref)) ((4 integer-address) (deref)))
|
||||
mem: ((4 integer-address) (deref)) => 0
|
||||
array-len: ((1034 tagged-value-array) (raw))
|
||||
mem: ((1034 integer) (raw)) => 4
|
||||
mem: ((1035 tagged-value) (raw)) => #(tagged record (integer 34 . nil))
|
||||
run: read/main 8: #(tagged record (integer 34 . nil)) => ((6 tagged-value))
|
||||
mem: ((6 tagged-value)): 1143 <= integer
|
||||
mem: ((6 tagged-value)): 1144 <= 34
|
||||
run: read/main 9: (((4 integer-address) (deref)) <- ((add)) ((4 integer-address) (deref)) ((1 literal)))
|
||||
mem: ((4 integer-address) (deref)) => 0
|
||||
run: read/main 9: 1 => ((4 integer-address) (deref))
|
||||
mem: ((4 integer-address) (deref)): 1031 <= 1
|
||||
run: read/main 10: (((8 integer)) <- ((length)) ((5 tagged-value-array-address) (deref)))
|
||||
array-len: ((5 tagged-value-array-address) (deref))
|
||||
mem: ((1034 integer) (raw)) => 4
|
||||
run: read/main 10: 4 => ((8 integer))
|
||||
mem: ((8 integer)): 1145 <= 4
|
||||
run: read/main 11: (((9 boolean)) <- ((less-than)) ((4 integer-address) (deref)) ((8 integer)))
|
||||
mem: ((4 integer-address) (deref)) => 1
|
||||
mem: ((8 integer)) => 4
|
||||
run: read/main 11: t => ((9 boolean))
|
||||
mem: ((9 boolean)): 1146 <= t
|
||||
run: read/main 12: (((jump-if)) ((9 boolean)) ((1 offset)))
|
||||
mem: ((9 boolean)) => t
|
||||
run: read/main 14: (((reply)) ((6 tagged-value)) ((1 channel-address) (deref) (same-as-arg 0)))
|
||||
mem: ((6 tagged-value)) => #(tagged record (integer 34 . nil))
|
||||
mem: ((1 channel-address) (deref) (same-as-arg 0)) => #(tagged record (1 1 1034 . nil))
|
||||
run: main 4: #(tagged record (integer 34 . nil)) => _
|
||||
run: main 4: #(tagged record (1 1 1034 . nil)) => ((1 channel-address) (deref))
|
||||
mem: ((1 channel-address) (deref)): 1031 <= 1
|
||||
mem: ((1 channel-address) (deref)): 1032 <= 1
|
||||
mem: ((1 channel-address) (deref)): 1033 <= 1034
|
||||
run: main 5: (((5 boolean)) <- ((empty?)) ((1 channel-address) (deref)))
|
||||
mem: ((1 channel-address) (deref)) => #(tagged record (1 1 1034 . nil))
|
||||
run: empty?/main 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
|
||||
run: empty?/main 0: 1198 => ((default-space space-address))
|
||||
run: empty?/main 1: (((1 channel)) <- ((next-input)))
|
||||
arg: nil 0 (#(tagged record (1 1 1034 . nil)))
|
||||
run: empty?/main 1: #(tagged record (1 1 1034 . nil)) => ((1 channel))
|
||||
mem: ((1 channel)): 1200 <= 1
|
||||
mem: ((1 channel)): 1201 <= 1
|
||||
mem: ((1 channel)): 1202 <= 1034
|
||||
run: empty?/main 2: (((4 integer)) <- ((get)) ((1 channel)) ((0 offset)))
|
||||
mem: ((1200 integer) (raw)) => 1
|
||||
run: empty?/main 2: 1 => ((4 integer))
|
||||
mem: ((4 integer)): 1203 <= 1
|
||||
run: empty?/main 3: (((5 integer)) <- ((get)) ((1 channel)) ((1 offset)))
|
||||
mem: ((1201 integer) (raw)) => 1
|
||||
run: empty?/main 3: 1 => ((5 integer))
|
||||
mem: ((5 integer)): 1204 <= 1
|
||||
run: empty?/main 4: (((6 boolean)) <- ((equal)) ((4 integer)) ((5 integer)))
|
||||
mem: ((4 integer)) => 1
|
||||
mem: ((5 integer)) => 1
|
||||
run: empty?/main 4: t => ((6 boolean))
|
||||
mem: ((6 boolean)): 1205 <= t
|
||||
run: empty?/main 5: (((reply)) ((6 boolean)))
|
||||
mem: ((6 boolean)) => t
|
||||
run: main 5: t => ((5 boolean))
|
||||
mem: ((5 boolean)): 5 <= t
|
||||
run: main 6: (((6 boolean)) <- ((full?)) ((1 channel-address) (deref)))
|
||||
mem: ((1 channel-address) (deref)) => #(tagged record (1 1 1034 . nil))
|
||||
run: full?/main 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
|
||||
run: full?/main 0: 1229 => ((default-space space-address))
|
||||
run: full?/main 1: (((1 channel)) <- ((next-input)))
|
||||
arg: nil 0 (#(tagged record (1 1 1034 . nil)))
|
||||
run: full?/main 1: #(tagged record (1 1 1034 . nil)) => ((1 channel))
|
||||
mem: ((1 channel)): 1231 <= 1
|
||||
mem: ((1 channel)): 1232 <= 1
|
||||
mem: ((1 channel)): 1233 <= 1034
|
||||
run: full?/main 2: (((4 integer)) <- ((get)) ((1 channel)) ((1 offset)))
|
||||
mem: ((1232 integer) (raw)) => 1
|
||||
run: full?/main 2: 1 => ((4 integer))
|
||||
mem: ((4 integer)): 1234 <= 1
|
||||
run: full?/main 3: (((4 integer)) <- ((add)) ((4 integer)) ((1 literal)))
|
||||
mem: ((4 integer)) => 1
|
||||
run: full?/main 3: 2 => ((4 integer))
|
||||
mem: ((4 integer)): 1234 <= 2
|
||||
run: full?/main 4: (((5 integer)) <- ((capacity)) ((1 channel)))
|
||||
mem: ((1 channel)) => #(tagged record (1 1 1034 . nil))
|
||||
run: capacity/full?/main 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
|
||||
run: capacity/full?/main 0: 1260 => ((default-space space-address))
|
||||
run: capacity/full?/main 1: (((1 channel)) <- ((next-input)))
|
||||
arg: nil 0 (#(tagged record (1 1 1034 . nil)))
|
||||
run: capacity/full?/main 1: #(tagged record (1 1 1034 . nil)) => ((1 channel))
|
||||
mem: ((1 channel)): 1262 <= 1
|
||||
mem: ((1 channel)): 1263 <= 1
|
||||
mem: ((1 channel)): 1264 <= 1034
|
||||
run: capacity/full?/main 2: (((4 tagged-value-array-address)) <- ((get)) ((1 channel)) ((2 offset)))
|
||||
mem: ((1264 tagged-value-array-address) (raw)) => 1034
|
||||
run: capacity/full?/main 2: 1034 => ((4 tagged-value-array-address))
|
||||
mem: ((4 tagged-value-array-address)): 1265 <= 1034
|
||||
run: capacity/full?/main 3: (((5 integer)) <- ((length)) ((4 tagged-value-array-address) (deref)))
|
||||
array-len: ((4 tagged-value-array-address) (deref))
|
||||
mem: ((1034 integer) (raw)) => 4
|
||||
run: capacity/full?/main 3: 4 => ((5 integer))
|
||||
mem: ((5 integer)): 1266 <= 4
|
||||
run: capacity/full?/main 4: (((reply)) ((5 integer)))
|
||||
mem: ((5 integer)) => 4
|
||||
run: full?/main 4: 4 => ((5 integer))
|
||||
mem: ((5 integer)): 1235 <= 4
|
||||
run: full?/main 5: (((6 boolean)) <- ((less-than)) ((4 integer)) ((5 integer)))
|
||||
mem: ((4 integer)) => 2
|
||||
mem: ((5 integer)) => 4
|
||||
run: full?/main 5: t => ((6 boolean))
|
||||
mem: ((6 boolean)): 1236 <= t
|
||||
run: full?/main 6: (((jump-if)) ((6 boolean)) ((1 offset)))
|
||||
mem: ((6 boolean)) => t
|
||||
run: full?/main 8: (((7 integer)) <- ((get)) ((1 channel)) ((0 offset)))
|
||||
mem: ((1231 integer) (raw)) => 1
|
||||
run: full?/main 8: 1 => ((7 integer))
|
||||
mem: ((7 integer)): 1237 <= 1
|
||||
run: full?/main 9: (((8 boolean)) <- ((equal)) ((7 integer)) ((4 integer)))
|
||||
mem: ((7 integer)) => 1
|
||||
mem: ((4 integer)) => 2
|
||||
run: full?/main 9: nil => ((8 boolean))
|
||||
mem: ((8 boolean)): 1238 <= nil
|
||||
run: full?/main 10: (((reply)) ((8 boolean)))
|
||||
mem: ((8 boolean)) => nil
|
||||
run: main 6: nil => ((6 boolean))
|
||||
mem: ((6 boolean)): 6 <= nil
|
||||
schedule: done with routine nil
|
||||
|
|
@ -0,0 +1,513 @@
|
|||
c{0: 0 (((1 channel-address)) <- ((init-channel)) ((3 literal))) -- nil
|
||||
c{0: 1 (((2 integer)) <- ((copy)) ((34 literal))) -- nil
|
||||
c{0: 2 (((3 tagged-value)) <- ((save-type)) ((2 integer))) -- nil
|
||||
c{0: 3 (((1 channel-address) (deref)) <- ((write)) ((1 channel-address)) ((3 tagged-value))) -- nil
|
||||
c{0: 4 (((1 channel-address) (deref)) <- ((write)) ((1 channel-address)) ((3 tagged-value))) -- nil
|
||||
c{0: 5 (_ ((1 channel-address) (deref)) <- ((read)) ((1 channel-address))) -- nil
|
||||
c{0: 6 (((5 boolean)) <- ((empty?)) ((1 channel-address) (deref))) -- nil
|
||||
c{0: 7 (((6 boolean)) <- ((full?)) ((1 channel-address) (deref))) -- nil
|
||||
c{1: 0 ✓ (((1 channel-address)) <- ((init-channel)) ((3 literal)))
|
||||
c{1: 1 ✓ (((2 integer)) <- ((copy)) ((34 literal)))
|
||||
c{1: 2 ✓ (((3 tagged-value)) <- ((save-type)) ((2 integer)))
|
||||
c{1: 3 ✓ (((1 channel-address) (deref)) <- ((write)) ((1 channel-address)) ((3 tagged-value)))
|
||||
c{1: 4 ✓ (((1 channel-address) (deref)) <- ((write)) ((1 channel-address)) ((3 tagged-value)))
|
||||
c{1: 5 ✓ (_ ((1 channel-address) (deref)) <- ((read)) ((1 channel-address)))
|
||||
c{1: 6 ✓ (((5 boolean)) <- ((empty?)) ((1 channel-address) (deref)))
|
||||
c{1: 7 ✓ (((6 boolean)) <- ((full?)) ((1 channel-address) (deref)))
|
||||
cn0: convert-names in main
|
||||
cn0: (((1 channel-address)) <- ((init-channel)) ((3 literal))) nil nil
|
||||
cn0: checking arg ((3 literal))
|
||||
cn0: checking oarg ((1 channel-address))
|
||||
maybe-add: ((1 channel-address))
|
||||
cn0: (((2 integer)) <- ((copy)) ((34 literal))) nil nil
|
||||
cn0: checking arg ((34 literal))
|
||||
cn0: checking oarg ((2 integer))
|
||||
maybe-add: ((2 integer))
|
||||
cn0: (((3 tagged-value)) <- ((save-type)) ((2 integer))) nil nil
|
||||
cn0: checking arg ((2 integer))
|
||||
maybe-add: ((2 integer))
|
||||
cn0: checking oarg ((3 tagged-value))
|
||||
maybe-add: ((3 tagged-value))
|
||||
cn0: (((1 channel-address) (deref)) <- ((write)) ((1 channel-address)) ((3 tagged-value))) nil nil
|
||||
cn0: checking arg ((1 channel-address))
|
||||
maybe-add: ((1 channel-address))
|
||||
cn0: checking arg ((3 tagged-value))
|
||||
maybe-add: ((3 tagged-value))
|
||||
cn0: checking oarg ((1 channel-address) (deref))
|
||||
maybe-add: ((1 channel-address) (deref))
|
||||
cn0: (((1 channel-address) (deref)) <- ((write)) ((1 channel-address)) ((3 tagged-value))) nil nil
|
||||
cn0: checking arg ((1 channel-address))
|
||||
maybe-add: ((1 channel-address))
|
||||
cn0: checking arg ((3 tagged-value))
|
||||
maybe-add: ((3 tagged-value))
|
||||
cn0: checking oarg ((1 channel-address) (deref))
|
||||
maybe-add: ((1 channel-address) (deref))
|
||||
cn0: (_ ((1 channel-address) (deref)) <- ((read)) ((1 channel-address))) nil nil
|
||||
cn0: checking arg ((1 channel-address))
|
||||
maybe-add: ((1 channel-address))
|
||||
cn0: checking oarg _
|
||||
cn0: checking oarg ((1 channel-address) (deref))
|
||||
maybe-add: ((1 channel-address) (deref))
|
||||
cn0: (((5 boolean)) <- ((empty?)) ((1 channel-address) (deref))) nil nil
|
||||
cn0: checking arg ((1 channel-address) (deref))
|
||||
maybe-add: ((1 channel-address) (deref))
|
||||
cn0: checking oarg ((5 boolean))
|
||||
maybe-add: ((5 boolean))
|
||||
cn0: (((6 boolean)) <- ((full?)) ((1 channel-address) (deref))) nil nil
|
||||
cn0: checking arg ((1 channel-address) (deref))
|
||||
maybe-add: ((1 channel-address) (deref))
|
||||
cn0: checking oarg ((6 boolean))
|
||||
maybe-add: ((6 boolean))
|
||||
cn1: (((1 channel-address)) <- ((init-channel)) ((3 literal)))
|
||||
cn1: (((2 integer)) <- ((copy)) ((34 literal)))
|
||||
cn1: (((3 tagged-value)) <- ((save-type)) ((2 integer)))
|
||||
cn1: (((1 channel-address) (deref)) <- ((write)) ((1 channel-address)) ((3 tagged-value)))
|
||||
cn1: (((1 channel-address) (deref)) <- ((write)) ((1 channel-address)) ((3 tagged-value)))
|
||||
cn1: (_ ((1 channel-address) (deref)) <- ((read)) ((1 channel-address)))
|
||||
cn1: (((5 boolean)) <- ((empty?)) ((1 channel-address) (deref)))
|
||||
cn1: (((6 boolean)) <- ((full?)) ((1 channel-address) (deref)))
|
||||
schedule: main
|
||||
run: main 0: (((1 channel-address)) <- ((init-channel)) ((3 literal)))
|
||||
run: init-channel/main 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
|
||||
run: init-channel/main 0: 1000 => ((default-space space-address))
|
||||
run: init-channel/main 1: (((1 channel-address)) <- ((new)) ((channel literal)))
|
||||
run: init-channel/main 1: 1031 => ((1 channel-address))
|
||||
mem: ((1 channel-address)): 1002 <= 1031
|
||||
run: init-channel/main 2: (((2 integer-address)) <- ((get-address)) ((1 channel-address) (deref)) ((0 offset)))
|
||||
run: init-channel/main 2: 1031 => ((2 integer-address))
|
||||
mem: ((2 integer-address)): 1003 <= 1031
|
||||
run: init-channel/main 3: (((2 integer-address) (deref)) <- ((copy)) ((0 literal)))
|
||||
run: init-channel/main 3: 0 => ((2 integer-address) (deref))
|
||||
mem: ((2 integer-address) (deref)): 1031 <= 0
|
||||
run: init-channel/main 4: (((3 integer-address)) <- ((get-address)) ((1 channel-address) (deref)) ((1 offset)))
|
||||
run: init-channel/main 4: 1032 => ((3 integer-address))
|
||||
mem: ((3 integer-address)): 1004 <= 1032
|
||||
run: init-channel/main 5: (((3 integer-address) (deref)) <- ((copy)) ((0 literal)))
|
||||
run: init-channel/main 5: 0 => ((3 integer-address) (deref))
|
||||
mem: ((3 integer-address) (deref)): 1032 <= 0
|
||||
run: init-channel/main 6: (((4 integer)) <- ((next-input)))
|
||||
arg: nil 0 (3)
|
||||
run: init-channel/main 6: 3 => ((4 integer))
|
||||
mem: ((4 integer)): 1005 <= 3
|
||||
run: init-channel/main 7: (((4 integer)) <- ((add)) ((4 integer)) ((1 literal)))
|
||||
mem: ((4 integer)) => 3
|
||||
run: init-channel/main 7: 4 => ((4 integer))
|
||||
mem: ((4 integer)): 1005 <= 4
|
||||
run: init-channel/main 8: (((5 tagged-value-array-address-address)) <- ((get-address)) ((1 channel-address) (deref)) ((2 offset)))
|
||||
run: init-channel/main 8: 1033 => ((5 tagged-value-array-address-address))
|
||||
mem: ((5 tagged-value-array-address-address)): 1006 <= 1033
|
||||
run: init-channel/main 9: (((5 tagged-value-array-address-address) (deref)) <- ((new)) ((tagged-value-array literal)) ((4 integer)))
|
||||
mem: ((4 integer)) => 4
|
||||
run: init-channel/main 9: 1034 => ((5 tagged-value-array-address-address) (deref))
|
||||
mem: ((5 tagged-value-array-address-address) (deref)): 1033 <= 1034
|
||||
run: init-channel/main 10: (((reply)) ((1 channel-address)))
|
||||
mem: ((1 channel-address)) => 1031
|
||||
run: main 0: 1031 => ((1 channel-address))
|
||||
mem: ((1 channel-address)): 1 <= 1031
|
||||
run: main 1: (((2 integer)) <- ((copy)) ((34 literal)))
|
||||
run: main 1: 34 => ((2 integer))
|
||||
mem: ((2 integer)): 2 <= 34
|
||||
run: main 2: (((3 tagged-value)) <- ((save-type)) ((2 integer)))
|
||||
mem: ((2 integer)) => 34
|
||||
run: main 2: #(tagged record (integer 34)) => ((3 tagged-value))
|
||||
mem: ((3 tagged-value)): 3 <= integer
|
||||
mem: ((3 tagged-value)): 4 <= 34
|
||||
run: main 3: (((1 channel-address) (deref)) <- ((write)) ((1 channel-address)) ((3 tagged-value)))
|
||||
mem: ((1 channel-address)) => 1031
|
||||
mem: ((3 tagged-value)) => #(tagged record (integer 34 . nil))
|
||||
run: write/main 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
|
||||
run: write/main 0: 1043 => ((default-space space-address))
|
||||
run: write/main 1: (((1 channel-address)) <- ((next-input)))
|
||||
arg: nil 0 (1031 #(tagged record (integer 34 . nil)))
|
||||
run: write/main 1: 1031 => ((1 channel-address))
|
||||
mem: ((1 channel-address)): 1045 <= 1031
|
||||
run: write/main 2: (((2 tagged-value)) <- ((next-input)))
|
||||
arg: nil 1 (1031 #(tagged record (integer 34 . nil)))
|
||||
run: write/main 2: #(tagged record (integer 34 . nil)) => ((2 tagged-value))
|
||||
mem: ((2 tagged-value)): 1046 <= integer
|
||||
mem: ((2 tagged-value)): 1047 <= 34
|
||||
run: write/main 3: (((4 boolean)) <- ((full?)) ((1 channel-address) (deref)))
|
||||
mem: ((1 channel-address) (deref)) => #(tagged record (0 0 1034 . nil))
|
||||
run: full?/write/main 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
|
||||
run: full?/write/main 0: 1074 => ((default-space space-address))
|
||||
run: full?/write/main 1: (((1 channel)) <- ((next-input)))
|
||||
arg: nil 0 (#(tagged record (0 0 1034 . nil)))
|
||||
run: full?/write/main 1: #(tagged record (0 0 1034 . nil)) => ((1 channel))
|
||||
mem: ((1 channel)): 1076 <= 0
|
||||
mem: ((1 channel)): 1077 <= 0
|
||||
mem: ((1 channel)): 1078 <= 1034
|
||||
run: full?/write/main 2: (((4 integer)) <- ((get)) ((1 channel)) ((1 offset)))
|
||||
mem: ((1077 integer) (raw)) => 0
|
||||
run: full?/write/main 2: 0 => ((4 integer))
|
||||
mem: ((4 integer)): 1079 <= 0
|
||||
run: full?/write/main 3: (((4 integer)) <- ((add)) ((4 integer)) ((1 literal)))
|
||||
mem: ((4 integer)) => 0
|
||||
run: full?/write/main 3: 1 => ((4 integer))
|
||||
mem: ((4 integer)): 1079 <= 1
|
||||
run: full?/write/main 4: (((5 integer)) <- ((capacity)) ((1 channel)))
|
||||
mem: ((1 channel)) => #(tagged record (0 0 1034 . nil))
|
||||
run: capacity/full?/write/main 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
|
||||
run: capacity/full?/write/main 0: 1105 => ((default-space space-address))
|
||||
run: capacity/full?/write/main 1: (((1 channel)) <- ((next-input)))
|
||||
arg: nil 0 (#(tagged record (0 0 1034 . nil)))
|
||||
run: capacity/full?/write/main 1: #(tagged record (0 0 1034 . nil)) => ((1 channel))
|
||||
mem: ((1 channel)): 1107 <= 0
|
||||
mem: ((1 channel)): 1108 <= 0
|
||||
mem: ((1 channel)): 1109 <= 1034
|
||||
run: capacity/full?/write/main 2: (((4 tagged-value-array-address)) <- ((get)) ((1 channel)) ((2 offset)))
|
||||
mem: ((1109 tagged-value-array-address) (raw)) => 1034
|
||||
run: capacity/full?/write/main 2: 1034 => ((4 tagged-value-array-address))
|
||||
mem: ((4 tagged-value-array-address)): 1110 <= 1034
|
||||
run: capacity/full?/write/main 3: (((5 integer)) <- ((length)) ((4 tagged-value-array-address) (deref)))
|
||||
array-len: ((4 tagged-value-array-address) (deref))
|
||||
mem: ((1034 integer) (raw)) => 4
|
||||
run: capacity/full?/write/main 3: 4 => ((5 integer))
|
||||
mem: ((5 integer)): 1111 <= 4
|
||||
run: capacity/full?/write/main 4: (((reply)) ((5 integer)))
|
||||
mem: ((5 integer)) => 4
|
||||
run: full?/write/main 4: 4 => ((5 integer))
|
||||
mem: ((5 integer)): 1080 <= 4
|
||||
run: full?/write/main 5: (((6 boolean)) <- ((less-than)) ((4 integer)) ((5 integer)))
|
||||
mem: ((4 integer)) => 1
|
||||
mem: ((5 integer)) => 4
|
||||
run: full?/write/main 5: t => ((6 boolean))
|
||||
mem: ((6 boolean)): 1081 <= t
|
||||
run: full?/write/main 6: (((jump-if)) ((6 boolean)) ((1 offset)))
|
||||
mem: ((6 boolean)) => t
|
||||
run: full?/write/main 8: (((7 integer)) <- ((get)) ((1 channel)) ((0 offset)))
|
||||
mem: ((1076 integer) (raw)) => 0
|
||||
run: full?/write/main 8: 0 => ((7 integer))
|
||||
mem: ((7 integer)): 1082 <= 0
|
||||
run: full?/write/main 9: (((8 boolean)) <- ((equal)) ((7 integer)) ((4 integer)))
|
||||
mem: ((7 integer)) => 0
|
||||
mem: ((4 integer)) => 1
|
||||
run: full?/write/main 9: nil => ((8 boolean))
|
||||
mem: ((8 boolean)): 1083 <= nil
|
||||
run: full?/write/main 10: (((reply)) ((8 boolean)))
|
||||
mem: ((8 boolean)) => nil
|
||||
run: write/main 3: nil => ((4 boolean))
|
||||
mem: ((4 boolean)): 1048 <= nil
|
||||
run: write/main 4: (((jump-unless)) ((4 boolean)) ((2 offset)))
|
||||
mem: ((4 boolean)) => nil
|
||||
run: write/main 7: (((6 tagged-value-array-address)) <- ((get)) ((1 channel-address) (deref)) ((2 offset)))
|
||||
mem: ((1033 tagged-value-array-address) (raw)) => 1034
|
||||
run: write/main 7: 1034 => ((6 tagged-value-array-address))
|
||||
mem: ((6 tagged-value-array-address)): 1050 <= 1034
|
||||
run: write/main 8: (((7 integer-address)) <- ((get-address)) ((1 channel-address) (deref)) ((1 offset)))
|
||||
run: write/main 8: 1032 => ((7 integer-address))
|
||||
mem: ((7 integer-address)): 1051 <= 1032
|
||||
run: write/main 9: (((8 tagged-value-address)) <- ((index-address)) ((6 tagged-value-array-address) (deref)) ((7 integer-address) (deref)))
|
||||
mem: ((7 integer-address) (deref)) => 0
|
||||
array-len: ((1034 tagged-value-array) (raw))
|
||||
mem: ((1034 integer) (raw)) => 4
|
||||
run: write/main 9: 1035 => ((8 tagged-value-address))
|
||||
mem: ((8 tagged-value-address)): 1052 <= 1035
|
||||
run: write/main 10: (((8 tagged-value-address) (deref)) <- ((copy)) ((2 tagged-value)))
|
||||
mem: ((2 tagged-value)) => #(tagged record (integer 34 . nil))
|
||||
run: write/main 10: #(tagged record (integer 34 . nil)) => ((8 tagged-value-address) (deref))
|
||||
mem: ((8 tagged-value-address) (deref)): 1035 <= integer
|
||||
mem: ((8 tagged-value-address) (deref)): 1036 <= 34
|
||||
run: write/main 11: (((7 integer-address) (deref)) <- ((add)) ((7 integer-address) (deref)) ((1 literal)))
|
||||
mem: ((7 integer-address) (deref)) => 0
|
||||
run: write/main 11: 1 => ((7 integer-address) (deref))
|
||||
mem: ((7 integer-address) (deref)): 1032 <= 1
|
||||
run: write/main 12: (((9 integer)) <- ((length)) ((6 tagged-value-array-address) (deref)))
|
||||
array-len: ((6 tagged-value-array-address) (deref))
|
||||
mem: ((1034 integer) (raw)) => 4
|
||||
run: write/main 12: 4 => ((9 integer))
|
||||
mem: ((9 integer)): 1053 <= 4
|
||||
run: write/main 13: (((10 boolean)) <- ((less-than)) ((7 integer-address) (deref)) ((9 integer)))
|
||||
mem: ((7 integer-address) (deref)) => 1
|
||||
mem: ((9 integer)) => 4
|
||||
run: write/main 13: t => ((10 boolean))
|
||||
mem: ((10 boolean)): 1054 <= t
|
||||
run: write/main 14: (((jump-if)) ((10 boolean)) ((1 offset)))
|
||||
mem: ((10 boolean)) => t
|
||||
run: write/main 16: (((reply)) ((1 channel-address) (deref) (same-as-arg 0)))
|
||||
mem: ((1 channel-address) (deref) (same-as-arg 0)) => #(tagged record (0 1 1034 . nil))
|
||||
run: main 3: #(tagged record (0 1 1034 . nil)) => ((1 channel-address) (deref))
|
||||
mem: ((1 channel-address) (deref)): 1031 <= 0
|
||||
mem: ((1 channel-address) (deref)): 1032 <= 1
|
||||
mem: ((1 channel-address) (deref)): 1033 <= 1034
|
||||
run: main 4: (((1 channel-address) (deref)) <- ((write)) ((1 channel-address)) ((3 tagged-value)))
|
||||
mem: ((1 channel-address)) => 1031
|
||||
mem: ((3 tagged-value)) => #(tagged record (integer 34 . nil))
|
||||
run: write/main 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
|
||||
run: write/main 0: 1136 => ((default-space space-address))
|
||||
run: write/main 1: (((1 channel-address)) <- ((next-input)))
|
||||
arg: nil 0 (1031 #(tagged record (integer 34 . nil)))
|
||||
run: write/main 1: 1031 => ((1 channel-address))
|
||||
mem: ((1 channel-address)): 1138 <= 1031
|
||||
run: write/main 2: (((2 tagged-value)) <- ((next-input)))
|
||||
arg: nil 1 (1031 #(tagged record (integer 34 . nil)))
|
||||
run: write/main 2: #(tagged record (integer 34 . nil)) => ((2 tagged-value))
|
||||
mem: ((2 tagged-value)): 1139 <= integer
|
||||
mem: ((2 tagged-value)): 1140 <= 34
|
||||
run: write/main 3: (((4 boolean)) <- ((full?)) ((1 channel-address) (deref)))
|
||||
mem: ((1 channel-address) (deref)) => #(tagged record (0 1 1034 . nil))
|
||||
run: full?/write/main 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
|
||||
run: full?/write/main 0: 1167 => ((default-space space-address))
|
||||
run: full?/write/main 1: (((1 channel)) <- ((next-input)))
|
||||
arg: nil 0 (#(tagged record (0 1 1034 . nil)))
|
||||
run: full?/write/main 1: #(tagged record (0 1 1034 . nil)) => ((1 channel))
|
||||
mem: ((1 channel)): 1169 <= 0
|
||||
mem: ((1 channel)): 1170 <= 1
|
||||
mem: ((1 channel)): 1171 <= 1034
|
||||
run: full?/write/main 2: (((4 integer)) <- ((get)) ((1 channel)) ((1 offset)))
|
||||
mem: ((1170 integer) (raw)) => 1
|
||||
run: full?/write/main 2: 1 => ((4 integer))
|
||||
mem: ((4 integer)): 1172 <= 1
|
||||
run: full?/write/main 3: (((4 integer)) <- ((add)) ((4 integer)) ((1 literal)))
|
||||
mem: ((4 integer)) => 1
|
||||
run: full?/write/main 3: 2 => ((4 integer))
|
||||
mem: ((4 integer)): 1172 <= 2
|
||||
run: full?/write/main 4: (((5 integer)) <- ((capacity)) ((1 channel)))
|
||||
mem: ((1 channel)) => #(tagged record (0 1 1034 . nil))
|
||||
run: capacity/full?/write/main 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
|
||||
run: capacity/full?/write/main 0: 1198 => ((default-space space-address))
|
||||
run: capacity/full?/write/main 1: (((1 channel)) <- ((next-input)))
|
||||
arg: nil 0 (#(tagged record (0 1 1034 . nil)))
|
||||
run: capacity/full?/write/main 1: #(tagged record (0 1 1034 . nil)) => ((1 channel))
|
||||
mem: ((1 channel)): 1200 <= 0
|
||||
mem: ((1 channel)): 1201 <= 1
|
||||
mem: ((1 channel)): 1202 <= 1034
|
||||
run: capacity/full?/write/main 2: (((4 tagged-value-array-address)) <- ((get)) ((1 channel)) ((2 offset)))
|
||||
mem: ((1202 tagged-value-array-address) (raw)) => 1034
|
||||
run: capacity/full?/write/main 2: 1034 => ((4 tagged-value-array-address))
|
||||
mem: ((4 tagged-value-array-address)): 1203 <= 1034
|
||||
run: capacity/full?/write/main 3: (((5 integer)) <- ((length)) ((4 tagged-value-array-address) (deref)))
|
||||
array-len: ((4 tagged-value-array-address) (deref))
|
||||
mem: ((1034 integer) (raw)) => 4
|
||||
run: capacity/full?/write/main 3: 4 => ((5 integer))
|
||||
mem: ((5 integer)): 1204 <= 4
|
||||
run: capacity/full?/write/main 4: (((reply)) ((5 integer)))
|
||||
mem: ((5 integer)) => 4
|
||||
run: full?/write/main 4: 4 => ((5 integer))
|
||||
mem: ((5 integer)): 1173 <= 4
|
||||
run: full?/write/main 5: (((6 boolean)) <- ((less-than)) ((4 integer)) ((5 integer)))
|
||||
mem: ((4 integer)) => 2
|
||||
mem: ((5 integer)) => 4
|
||||
run: full?/write/main 5: t => ((6 boolean))
|
||||
mem: ((6 boolean)): 1174 <= t
|
||||
run: full?/write/main 6: (((jump-if)) ((6 boolean)) ((1 offset)))
|
||||
mem: ((6 boolean)) => t
|
||||
run: full?/write/main 8: (((7 integer)) <- ((get)) ((1 channel)) ((0 offset)))
|
||||
mem: ((1169 integer) (raw)) => 0
|
||||
run: full?/write/main 8: 0 => ((7 integer))
|
||||
mem: ((7 integer)): 1175 <= 0
|
||||
run: full?/write/main 9: (((8 boolean)) <- ((equal)) ((7 integer)) ((4 integer)))
|
||||
mem: ((7 integer)) => 0
|
||||
mem: ((4 integer)) => 2
|
||||
run: full?/write/main 9: nil => ((8 boolean))
|
||||
mem: ((8 boolean)): 1176 <= nil
|
||||
run: full?/write/main 10: (((reply)) ((8 boolean)))
|
||||
mem: ((8 boolean)) => nil
|
||||
run: write/main 3: nil => ((4 boolean))
|
||||
mem: ((4 boolean)): 1141 <= nil
|
||||
run: write/main 4: (((jump-unless)) ((4 boolean)) ((2 offset)))
|
||||
mem: ((4 boolean)) => nil
|
||||
run: write/main 7: (((6 tagged-value-array-address)) <- ((get)) ((1 channel-address) (deref)) ((2 offset)))
|
||||
mem: ((1033 tagged-value-array-address) (raw)) => 1034
|
||||
run: write/main 7: 1034 => ((6 tagged-value-array-address))
|
||||
mem: ((6 tagged-value-array-address)): 1143 <= 1034
|
||||
run: write/main 8: (((7 integer-address)) <- ((get-address)) ((1 channel-address) (deref)) ((1 offset)))
|
||||
run: write/main 8: 1032 => ((7 integer-address))
|
||||
mem: ((7 integer-address)): 1144 <= 1032
|
||||
run: write/main 9: (((8 tagged-value-address)) <- ((index-address)) ((6 tagged-value-array-address) (deref)) ((7 integer-address) (deref)))
|
||||
mem: ((7 integer-address) (deref)) => 1
|
||||
array-len: ((1034 tagged-value-array) (raw))
|
||||
mem: ((1034 integer) (raw)) => 4
|
||||
run: write/main 9: 1037 => ((8 tagged-value-address))
|
||||
mem: ((8 tagged-value-address)): 1145 <= 1037
|
||||
run: write/main 10: (((8 tagged-value-address) (deref)) <- ((copy)) ((2 tagged-value)))
|
||||
mem: ((2 tagged-value)) => #(tagged record (integer 34 . nil))
|
||||
run: write/main 10: #(tagged record (integer 34 . nil)) => ((8 tagged-value-address) (deref))
|
||||
mem: ((8 tagged-value-address) (deref)): 1037 <= integer
|
||||
mem: ((8 tagged-value-address) (deref)): 1038 <= 34
|
||||
run: write/main 11: (((7 integer-address) (deref)) <- ((add)) ((7 integer-address) (deref)) ((1 literal)))
|
||||
mem: ((7 integer-address) (deref)) => 1
|
||||
run: write/main 11: 2 => ((7 integer-address) (deref))
|
||||
mem: ((7 integer-address) (deref)): 1032 <= 2
|
||||
run: write/main 12: (((9 integer)) <- ((length)) ((6 tagged-value-array-address) (deref)))
|
||||
array-len: ((6 tagged-value-array-address) (deref))
|
||||
mem: ((1034 integer) (raw)) => 4
|
||||
run: write/main 12: 4 => ((9 integer))
|
||||
mem: ((9 integer)): 1146 <= 4
|
||||
run: write/main 13: (((10 boolean)) <- ((less-than)) ((7 integer-address) (deref)) ((9 integer)))
|
||||
mem: ((7 integer-address) (deref)) => 2
|
||||
mem: ((9 integer)) => 4
|
||||
run: write/main 13: t => ((10 boolean))
|
||||
mem: ((10 boolean)): 1147 <= t
|
||||
run: write/main 14: (((jump-if)) ((10 boolean)) ((1 offset)))
|
||||
mem: ((10 boolean)) => t
|
||||
run: write/main 16: (((reply)) ((1 channel-address) (deref) (same-as-arg 0)))
|
||||
mem: ((1 channel-address) (deref) (same-as-arg 0)) => #(tagged record (0 2 1034 . nil))
|
||||
run: main 4: #(tagged record (0 2 1034 . nil)) => ((1 channel-address) (deref))
|
||||
mem: ((1 channel-address) (deref)): 1031 <= 0
|
||||
mem: ((1 channel-address) (deref)): 1032 <= 2
|
||||
mem: ((1 channel-address) (deref)): 1033 <= 1034
|
||||
run: main 5: (_ ((1 channel-address) (deref)) <- ((read)) ((1 channel-address)))
|
||||
mem: ((1 channel-address)) => 1031
|
||||
run: read/main 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
|
||||
run: read/main 0: 1229 => ((default-space space-address))
|
||||
run: read/main 1: (((1 channel-address)) <- ((next-input)))
|
||||
arg: nil 0 (1031)
|
||||
run: read/main 1: 1031 => ((1 channel-address))
|
||||
mem: ((1 channel-address)): 1231 <= 1031
|
||||
run: read/main 2: (((2 boolean)) <- ((empty?)) ((1 channel-address) (deref)))
|
||||
mem: ((1 channel-address) (deref)) => #(tagged record (0 2 1034 . nil))
|
||||
run: empty?/read/main 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
|
||||
run: empty?/read/main 0: 1260 => ((default-space space-address))
|
||||
run: empty?/read/main 1: (((1 channel)) <- ((next-input)))
|
||||
arg: nil 0 (#(tagged record (0 2 1034 . nil)))
|
||||
run: empty?/read/main 1: #(tagged record (0 2 1034 . nil)) => ((1 channel))
|
||||
mem: ((1 channel)): 1262 <= 0
|
||||
mem: ((1 channel)): 1263 <= 2
|
||||
mem: ((1 channel)): 1264 <= 1034
|
||||
run: empty?/read/main 2: (((4 integer)) <- ((get)) ((1 channel)) ((0 offset)))
|
||||
mem: ((1262 integer) (raw)) => 0
|
||||
run: empty?/read/main 2: 0 => ((4 integer))
|
||||
mem: ((4 integer)): 1265 <= 0
|
||||
run: empty?/read/main 3: (((5 integer)) <- ((get)) ((1 channel)) ((1 offset)))
|
||||
mem: ((1263 integer) (raw)) => 2
|
||||
run: empty?/read/main 3: 2 => ((5 integer))
|
||||
mem: ((5 integer)): 1266 <= 2
|
||||
run: empty?/read/main 4: (((6 boolean)) <- ((equal)) ((4 integer)) ((5 integer)))
|
||||
mem: ((4 integer)) => 0
|
||||
mem: ((5 integer)) => 2
|
||||
run: empty?/read/main 4: nil => ((6 boolean))
|
||||
mem: ((6 boolean)): 1267 <= nil
|
||||
run: empty?/read/main 5: (((reply)) ((6 boolean)))
|
||||
mem: ((6 boolean)) => nil
|
||||
run: read/main 2: nil => ((2 boolean))
|
||||
mem: ((2 boolean)): 1232 <= nil
|
||||
run: read/main 3: (((jump-unless)) ((2 boolean)) ((2 offset)))
|
||||
mem: ((2 boolean)) => nil
|
||||
run: read/main 6: (((4 integer-address)) <- ((get-address)) ((1 channel-address) (deref)) ((0 offset)))
|
||||
run: read/main 6: 1031 => ((4 integer-address))
|
||||
mem: ((4 integer-address)): 1234 <= 1031
|
||||
run: read/main 7: (((5 tagged-value-array-address)) <- ((get)) ((1 channel-address) (deref)) ((2 offset)))
|
||||
mem: ((1033 tagged-value-array-address) (raw)) => 1034
|
||||
run: read/main 7: 1034 => ((5 tagged-value-array-address))
|
||||
mem: ((5 tagged-value-array-address)): 1235 <= 1034
|
||||
run: read/main 8: (((6 tagged-value)) <- ((index)) ((5 tagged-value-array-address) (deref)) ((4 integer-address) (deref)))
|
||||
mem: ((4 integer-address) (deref)) => 0
|
||||
array-len: ((1034 tagged-value-array) (raw))
|
||||
mem: ((1034 integer) (raw)) => 4
|
||||
mem: ((1035 tagged-value) (raw)) => #(tagged record (integer 34 . nil))
|
||||
run: read/main 8: #(tagged record (integer 34 . nil)) => ((6 tagged-value))
|
||||
mem: ((6 tagged-value)): 1236 <= integer
|
||||
mem: ((6 tagged-value)): 1237 <= 34
|
||||
run: read/main 9: (((4 integer-address) (deref)) <- ((add)) ((4 integer-address) (deref)) ((1 literal)))
|
||||
mem: ((4 integer-address) (deref)) => 0
|
||||
run: read/main 9: 1 => ((4 integer-address) (deref))
|
||||
mem: ((4 integer-address) (deref)): 1031 <= 1
|
||||
run: read/main 10: (((8 integer)) <- ((length)) ((5 tagged-value-array-address) (deref)))
|
||||
array-len: ((5 tagged-value-array-address) (deref))
|
||||
mem: ((1034 integer) (raw)) => 4
|
||||
run: read/main 10: 4 => ((8 integer))
|
||||
mem: ((8 integer)): 1238 <= 4
|
||||
run: read/main 11: (((9 boolean)) <- ((less-than)) ((4 integer-address) (deref)) ((8 integer)))
|
||||
mem: ((4 integer-address) (deref)) => 1
|
||||
mem: ((8 integer)) => 4
|
||||
run: read/main 11: t => ((9 boolean))
|
||||
mem: ((9 boolean)): 1239 <= t
|
||||
run: read/main 12: (((jump-if)) ((9 boolean)) ((1 offset)))
|
||||
mem: ((9 boolean)) => t
|
||||
run: read/main 14: (((reply)) ((6 tagged-value)) ((1 channel-address) (deref) (same-as-arg 0)))
|
||||
mem: ((6 tagged-value)) => #(tagged record (integer 34 . nil))
|
||||
mem: ((1 channel-address) (deref) (same-as-arg 0)) => #(tagged record (1 2 1034 . nil))
|
||||
run: main 5: #(tagged record (integer 34 . nil)) => _
|
||||
run: main 5: #(tagged record (1 2 1034 . nil)) => ((1 channel-address) (deref))
|
||||
mem: ((1 channel-address) (deref)): 1031 <= 1
|
||||
mem: ((1 channel-address) (deref)): 1032 <= 2
|
||||
mem: ((1 channel-address) (deref)): 1033 <= 1034
|
||||
run: main 6: (((5 boolean)) <- ((empty?)) ((1 channel-address) (deref)))
|
||||
mem: ((1 channel-address) (deref)) => #(tagged record (1 2 1034 . nil))
|
||||
run: empty?/main 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
|
||||
run: empty?/main 0: 1291 => ((default-space space-address))
|
||||
run: empty?/main 1: (((1 channel)) <- ((next-input)))
|
||||
arg: nil 0 (#(tagged record (1 2 1034 . nil)))
|
||||
run: empty?/main 1: #(tagged record (1 2 1034 . nil)) => ((1 channel))
|
||||
mem: ((1 channel)): 1293 <= 1
|
||||
mem: ((1 channel)): 1294 <= 2
|
||||
mem: ((1 channel)): 1295 <= 1034
|
||||
run: empty?/main 2: (((4 integer)) <- ((get)) ((1 channel)) ((0 offset)))
|
||||
mem: ((1293 integer) (raw)) => 1
|
||||
run: empty?/main 2: 1 => ((4 integer))
|
||||
mem: ((4 integer)): 1296 <= 1
|
||||
run: empty?/main 3: (((5 integer)) <- ((get)) ((1 channel)) ((1 offset)))
|
||||
mem: ((1294 integer) (raw)) => 2
|
||||
run: empty?/main 3: 2 => ((5 integer))
|
||||
mem: ((5 integer)): 1297 <= 2
|
||||
run: empty?/main 4: (((6 boolean)) <- ((equal)) ((4 integer)) ((5 integer)))
|
||||
mem: ((4 integer)) => 1
|
||||
mem: ((5 integer)) => 2
|
||||
run: empty?/main 4: nil => ((6 boolean))
|
||||
mem: ((6 boolean)): 1298 <= nil
|
||||
run: empty?/main 5: (((reply)) ((6 boolean)))
|
||||
mem: ((6 boolean)) => nil
|
||||
run: main 6: nil => ((5 boolean))
|
||||
mem: ((5 boolean)): 5 <= nil
|
||||
run: main 7: (((6 boolean)) <- ((full?)) ((1 channel-address) (deref)))
|
||||
mem: ((1 channel-address) (deref)) => #(tagged record (1 2 1034 . nil))
|
||||
run: full?/main 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
|
||||
run: full?/main 0: 1322 => ((default-space space-address))
|
||||
run: full?/main 1: (((1 channel)) <- ((next-input)))
|
||||
arg: nil 0 (#(tagged record (1 2 1034 . nil)))
|
||||
run: full?/main 1: #(tagged record (1 2 1034 . nil)) => ((1 channel))
|
||||
mem: ((1 channel)): 1324 <= 1
|
||||
mem: ((1 channel)): 1325 <= 2
|
||||
mem: ((1 channel)): 1326 <= 1034
|
||||
run: full?/main 2: (((4 integer)) <- ((get)) ((1 channel)) ((1 offset)))
|
||||
mem: ((1325 integer) (raw)) => 2
|
||||
run: full?/main 2: 2 => ((4 integer))
|
||||
mem: ((4 integer)): 1327 <= 2
|
||||
run: full?/main 3: (((4 integer)) <- ((add)) ((4 integer)) ((1 literal)))
|
||||
mem: ((4 integer)) => 2
|
||||
run: full?/main 3: 3 => ((4 integer))
|
||||
mem: ((4 integer)): 1327 <= 3
|
||||
run: full?/main 4: (((5 integer)) <- ((capacity)) ((1 channel)))
|
||||
mem: ((1 channel)) => #(tagged record (1 2 1034 . nil))
|
||||
run: capacity/full?/main 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
|
||||
run: capacity/full?/main 0: 1353 => ((default-space space-address))
|
||||
run: capacity/full?/main 1: (((1 channel)) <- ((next-input)))
|
||||
arg: nil 0 (#(tagged record (1 2 1034 . nil)))
|
||||
run: capacity/full?/main 1: #(tagged record (1 2 1034 . nil)) => ((1 channel))
|
||||
mem: ((1 channel)): 1355 <= 1
|
||||
mem: ((1 channel)): 1356 <= 2
|
||||
mem: ((1 channel)): 1357 <= 1034
|
||||
run: capacity/full?/main 2: (((4 tagged-value-array-address)) <- ((get)) ((1 channel)) ((2 offset)))
|
||||
mem: ((1357 tagged-value-array-address) (raw)) => 1034
|
||||
run: capacity/full?/main 2: 1034 => ((4 tagged-value-array-address))
|
||||
mem: ((4 tagged-value-array-address)): 1358 <= 1034
|
||||
run: capacity/full?/main 3: (((5 integer)) <- ((length)) ((4 tagged-value-array-address) (deref)))
|
||||
array-len: ((4 tagged-value-array-address) (deref))
|
||||
mem: ((1034 integer) (raw)) => 4
|
||||
run: capacity/full?/main 3: 4 => ((5 integer))
|
||||
mem: ((5 integer)): 1359 <= 4
|
||||
run: capacity/full?/main 4: (((reply)) ((5 integer)))
|
||||
mem: ((5 integer)) => 4
|
||||
run: full?/main 4: 4 => ((5 integer))
|
||||
mem: ((5 integer)): 1328 <= 4
|
||||
run: full?/main 5: (((6 boolean)) <- ((less-than)) ((4 integer)) ((5 integer)))
|
||||
mem: ((4 integer)) => 3
|
||||
mem: ((5 integer)) => 4
|
||||
run: full?/main 5: t => ((6 boolean))
|
||||
mem: ((6 boolean)): 1329 <= t
|
||||
run: full?/main 6: (((jump-if)) ((6 boolean)) ((1 offset)))
|
||||
mem: ((6 boolean)) => t
|
||||
run: full?/main 8: (((7 integer)) <- ((get)) ((1 channel)) ((0 offset)))
|
||||
mem: ((1324 integer) (raw)) => 1
|
||||
run: full?/main 8: 1 => ((7 integer))
|
||||
mem: ((7 integer)): 1330 <= 1
|
||||
run: full?/main 9: (((8 boolean)) <- ((equal)) ((7 integer)) ((4 integer)))
|
||||
mem: ((7 integer)) => 1
|
||||
mem: ((4 integer)) => 3
|
||||
run: full?/main 9: nil => ((8 boolean))
|
||||
mem: ((8 boolean)): 1331 <= nil
|
||||
run: full?/main 10: (((reply)) ((8 boolean)))
|
||||
mem: ((8 boolean)) => nil
|
||||
run: main 7: nil => ((6 boolean))
|
||||
mem: ((6 boolean)): 6 <= nil
|
||||
schedule: done with routine nil
|
||||
|
|
@ -0,0 +1,533 @@
|
|||
c{0: 0 (((1 channel-address)) <- ((init-channel)) ((1 literal))) -- nil
|
||||
c{0: 1 (((2 integer)) <- ((copy)) ((34 literal))) -- nil
|
||||
c{0: 2 (((3 tagged-value)) <- ((save-type)) ((2 integer))) -- nil
|
||||
c{0: 3 (((1 channel-address) (deref)) <- ((write)) ((1 channel-address)) ((3 tagged-value))) -- nil
|
||||
c{0: 4 (_ ((1 channel-address) (deref)) <- ((read)) ((1 channel-address))) -- nil
|
||||
c{0: 5 (((5 integer)) <- ((get)) ((1 channel-address) (deref)) ((first-full offset))) -- nil
|
||||
c{0: 6 (((1 channel-address) (deref)) <- ((write)) ((1 channel-address)) ((3 tagged-value))) -- nil
|
||||
c{0: 7 (_ ((1 channel-address) (deref)) <- ((read)) ((1 channel-address))) -- nil
|
||||
c{0: 8 (((6 integer)) <- ((get)) ((1 channel-address) (deref)) ((first-full offset))) -- nil
|
||||
c{1: 0 ✓ (((1 channel-address)) <- ((init-channel)) ((1 literal)))
|
||||
c{1: 1 ✓ (((2 integer)) <- ((copy)) ((34 literal)))
|
||||
c{1: 2 ✓ (((3 tagged-value)) <- ((save-type)) ((2 integer)))
|
||||
c{1: 3 ✓ (((1 channel-address) (deref)) <- ((write)) ((1 channel-address)) ((3 tagged-value)))
|
||||
c{1: 4 ✓ (_ ((1 channel-address) (deref)) <- ((read)) ((1 channel-address)))
|
||||
c{1: 5 ✓ (((5 integer)) <- ((get)) ((1 channel-address) (deref)) ((first-full offset)))
|
||||
c{1: 6 ✓ (((1 channel-address) (deref)) <- ((write)) ((1 channel-address)) ((3 tagged-value)))
|
||||
c{1: 7 ✓ (_ ((1 channel-address) (deref)) <- ((read)) ((1 channel-address)))
|
||||
c{1: 8 ✓ (((6 integer)) <- ((get)) ((1 channel-address) (deref)) ((first-full offset)))
|
||||
cn0: convert-names in main
|
||||
cn0: (((1 channel-address)) <- ((init-channel)) ((1 literal))) nil nil
|
||||
cn0: checking arg ((1 literal))
|
||||
cn0: checking oarg ((1 channel-address))
|
||||
maybe-add: ((1 channel-address))
|
||||
cn0: (((2 integer)) <- ((copy)) ((34 literal))) nil nil
|
||||
cn0: checking arg ((34 literal))
|
||||
cn0: checking oarg ((2 integer))
|
||||
maybe-add: ((2 integer))
|
||||
cn0: (((3 tagged-value)) <- ((save-type)) ((2 integer))) nil nil
|
||||
cn0: checking arg ((2 integer))
|
||||
maybe-add: ((2 integer))
|
||||
cn0: checking oarg ((3 tagged-value))
|
||||
maybe-add: ((3 tagged-value))
|
||||
cn0: (((1 channel-address) (deref)) <- ((write)) ((1 channel-address)) ((3 tagged-value))) nil nil
|
||||
cn0: checking arg ((1 channel-address))
|
||||
maybe-add: ((1 channel-address))
|
||||
cn0: checking arg ((3 tagged-value))
|
||||
maybe-add: ((3 tagged-value))
|
||||
cn0: checking oarg ((1 channel-address) (deref))
|
||||
maybe-add: ((1 channel-address) (deref))
|
||||
cn0: (_ ((1 channel-address) (deref)) <- ((read)) ((1 channel-address))) nil nil
|
||||
cn0: checking arg ((1 channel-address))
|
||||
maybe-add: ((1 channel-address))
|
||||
cn0: checking oarg _
|
||||
cn0: checking oarg ((1 channel-address) (deref))
|
||||
maybe-add: ((1 channel-address) (deref))
|
||||
cn0: (((5 integer)) <- ((get)) ((1 channel-address) (deref)) ((first-full offset))) nil nil
|
||||
cn0: field-access first-full in 1channel-addressderef of type channel
|
||||
cn0: new field; computing location
|
||||
cn0: field location 0
|
||||
cn0: checking arg ((1 channel-address) (deref))
|
||||
maybe-add: ((1 channel-address) (deref))
|
||||
cn0: checking arg ((first-full offset))
|
||||
cn0: checking oarg ((5 integer))
|
||||
maybe-add: ((5 integer))
|
||||
cn0: (((1 channel-address) (deref)) <- ((write)) ((1 channel-address)) ((3 tagged-value))) ((first-full 0)) ((first-full t))
|
||||
cn0: checking arg ((1 channel-address))
|
||||
maybe-add: ((1 channel-address))
|
||||
cn0: checking arg ((3 tagged-value))
|
||||
maybe-add: ((3 tagged-value))
|
||||
cn0: checking oarg ((1 channel-address) (deref))
|
||||
maybe-add: ((1 channel-address) (deref))
|
||||
cn0: (_ ((1 channel-address) (deref)) <- ((read)) ((1 channel-address))) ((first-full 0)) ((first-full t))
|
||||
cn0: checking arg ((1 channel-address))
|
||||
maybe-add: ((1 channel-address))
|
||||
cn0: checking oarg _
|
||||
cn0: checking oarg ((1 channel-address) (deref))
|
||||
maybe-add: ((1 channel-address) (deref))
|
||||
cn0: (((6 integer)) <- ((get)) ((1 channel-address) (deref)) ((first-full offset))) ((first-full 0)) ((first-full t))
|
||||
cn0: field-access first-full in 1channel-addressderef of type channel
|
||||
cn0: checking arg ((1 channel-address) (deref))
|
||||
maybe-add: ((1 channel-address) (deref))
|
||||
cn0: checking arg ((first-full offset))
|
||||
cn0: checking oarg ((6 integer))
|
||||
maybe-add: ((6 integer))
|
||||
cn1: (((1 channel-address)) <- ((init-channel)) ((1 literal)))
|
||||
cn1: (((2 integer)) <- ((copy)) ((34 literal)))
|
||||
cn1: (((3 tagged-value)) <- ((save-type)) ((2 integer)))
|
||||
cn1: (((1 channel-address) (deref)) <- ((write)) ((1 channel-address)) ((3 tagged-value)))
|
||||
cn1: (_ ((1 channel-address) (deref)) <- ((read)) ((1 channel-address)))
|
||||
cn1: (((5 integer)) <- ((get)) ((1 channel-address) (deref)) ((0 offset)))
|
||||
cn1: (((1 channel-address) (deref)) <- ((write)) ((1 channel-address)) ((3 tagged-value)))
|
||||
cn1: (_ ((1 channel-address) (deref)) <- ((read)) ((1 channel-address)))
|
||||
cn1: (((6 integer)) <- ((get)) ((1 channel-address) (deref)) ((0 offset)))
|
||||
schedule: main
|
||||
run: main 0: (((1 channel-address)) <- ((init-channel)) ((1 literal)))
|
||||
run: init-channel/main 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
|
||||
run: init-channel/main 0: 1000 => ((default-space space-address))
|
||||
run: init-channel/main 1: (((1 channel-address)) <- ((new)) ((channel literal)))
|
||||
run: init-channel/main 1: 1031 => ((1 channel-address))
|
||||
mem: ((1 channel-address)): 1002 <= 1031
|
||||
run: init-channel/main 2: (((2 integer-address)) <- ((get-address)) ((1 channel-address) (deref)) ((0 offset)))
|
||||
run: init-channel/main 2: 1031 => ((2 integer-address))
|
||||
mem: ((2 integer-address)): 1003 <= 1031
|
||||
run: init-channel/main 3: (((2 integer-address) (deref)) <- ((copy)) ((0 literal)))
|
||||
run: init-channel/main 3: 0 => ((2 integer-address) (deref))
|
||||
mem: ((2 integer-address) (deref)): 1031 <= 0
|
||||
run: init-channel/main 4: (((3 integer-address)) <- ((get-address)) ((1 channel-address) (deref)) ((1 offset)))
|
||||
run: init-channel/main 4: 1032 => ((3 integer-address))
|
||||
mem: ((3 integer-address)): 1004 <= 1032
|
||||
run: init-channel/main 5: (((3 integer-address) (deref)) <- ((copy)) ((0 literal)))
|
||||
run: init-channel/main 5: 0 => ((3 integer-address) (deref))
|
||||
mem: ((3 integer-address) (deref)): 1032 <= 0
|
||||
run: init-channel/main 6: (((4 integer)) <- ((next-input)))
|
||||
arg: nil 0 (1)
|
||||
run: init-channel/main 6: 1 => ((4 integer))
|
||||
mem: ((4 integer)): 1005 <= 1
|
||||
run: init-channel/main 7: (((4 integer)) <- ((add)) ((4 integer)) ((1 literal)))
|
||||
mem: ((4 integer)) => 1
|
||||
run: init-channel/main 7: 2 => ((4 integer))
|
||||
mem: ((4 integer)): 1005 <= 2
|
||||
run: init-channel/main 8: (((5 tagged-value-array-address-address)) <- ((get-address)) ((1 channel-address) (deref)) ((2 offset)))
|
||||
run: init-channel/main 8: 1033 => ((5 tagged-value-array-address-address))
|
||||
mem: ((5 tagged-value-array-address-address)): 1006 <= 1033
|
||||
run: init-channel/main 9: (((5 tagged-value-array-address-address) (deref)) <- ((new)) ((tagged-value-array literal)) ((4 integer)))
|
||||
mem: ((4 integer)) => 2
|
||||
run: init-channel/main 9: 1034 => ((5 tagged-value-array-address-address) (deref))
|
||||
mem: ((5 tagged-value-array-address-address) (deref)): 1033 <= 1034
|
||||
run: init-channel/main 10: (((reply)) ((1 channel-address)))
|
||||
mem: ((1 channel-address)) => 1031
|
||||
run: main 0: 1031 => ((1 channel-address))
|
||||
mem: ((1 channel-address)): 1 <= 1031
|
||||
run: main 1: (((2 integer)) <- ((copy)) ((34 literal)))
|
||||
run: main 1: 34 => ((2 integer))
|
||||
mem: ((2 integer)): 2 <= 34
|
||||
run: main 2: (((3 tagged-value)) <- ((save-type)) ((2 integer)))
|
||||
mem: ((2 integer)) => 34
|
||||
run: main 2: #(tagged record (integer 34)) => ((3 tagged-value))
|
||||
mem: ((3 tagged-value)): 3 <= integer
|
||||
mem: ((3 tagged-value)): 4 <= 34
|
||||
run: main 3: (((1 channel-address) (deref)) <- ((write)) ((1 channel-address)) ((3 tagged-value)))
|
||||
mem: ((1 channel-address)) => 1031
|
||||
mem: ((3 tagged-value)) => #(tagged record (integer 34 . nil))
|
||||
run: write/main 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
|
||||
run: write/main 0: 1039 => ((default-space space-address))
|
||||
run: write/main 1: (((1 channel-address)) <- ((next-input)))
|
||||
arg: nil 0 (1031 #(tagged record (integer 34 . nil)))
|
||||
run: write/main 1: 1031 => ((1 channel-address))
|
||||
mem: ((1 channel-address)): 1041 <= 1031
|
||||
run: write/main 2: (((2 tagged-value)) <- ((next-input)))
|
||||
arg: nil 1 (1031 #(tagged record (integer 34 . nil)))
|
||||
run: write/main 2: #(tagged record (integer 34 . nil)) => ((2 tagged-value))
|
||||
mem: ((2 tagged-value)): 1042 <= integer
|
||||
mem: ((2 tagged-value)): 1043 <= 34
|
||||
run: write/main 3: (((4 boolean)) <- ((full?)) ((1 channel-address) (deref)))
|
||||
mem: ((1 channel-address) (deref)) => #(tagged record (0 0 1034 . nil))
|
||||
run: full?/write/main 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
|
||||
run: full?/write/main 0: 1070 => ((default-space space-address))
|
||||
run: full?/write/main 1: (((1 channel)) <- ((next-input)))
|
||||
arg: nil 0 (#(tagged record (0 0 1034 . nil)))
|
||||
run: full?/write/main 1: #(tagged record (0 0 1034 . nil)) => ((1 channel))
|
||||
mem: ((1 channel)): 1072 <= 0
|
||||
mem: ((1 channel)): 1073 <= 0
|
||||
mem: ((1 channel)): 1074 <= 1034
|
||||
run: full?/write/main 2: (((4 integer)) <- ((get)) ((1 channel)) ((1 offset)))
|
||||
mem: ((1073 integer) (raw)) => 0
|
||||
run: full?/write/main 2: 0 => ((4 integer))
|
||||
mem: ((4 integer)): 1075 <= 0
|
||||
run: full?/write/main 3: (((4 integer)) <- ((add)) ((4 integer)) ((1 literal)))
|
||||
mem: ((4 integer)) => 0
|
||||
run: full?/write/main 3: 1 => ((4 integer))
|
||||
mem: ((4 integer)): 1075 <= 1
|
||||
run: full?/write/main 4: (((5 integer)) <- ((capacity)) ((1 channel)))
|
||||
mem: ((1 channel)) => #(tagged record (0 0 1034 . nil))
|
||||
run: capacity/full?/write/main 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
|
||||
run: capacity/full?/write/main 0: 1101 => ((default-space space-address))
|
||||
run: capacity/full?/write/main 1: (((1 channel)) <- ((next-input)))
|
||||
arg: nil 0 (#(tagged record (0 0 1034 . nil)))
|
||||
run: capacity/full?/write/main 1: #(tagged record (0 0 1034 . nil)) => ((1 channel))
|
||||
mem: ((1 channel)): 1103 <= 0
|
||||
mem: ((1 channel)): 1104 <= 0
|
||||
mem: ((1 channel)): 1105 <= 1034
|
||||
run: capacity/full?/write/main 2: (((4 tagged-value-array-address)) <- ((get)) ((1 channel)) ((2 offset)))
|
||||
mem: ((1105 tagged-value-array-address) (raw)) => 1034
|
||||
run: capacity/full?/write/main 2: 1034 => ((4 tagged-value-array-address))
|
||||
mem: ((4 tagged-value-array-address)): 1106 <= 1034
|
||||
run: capacity/full?/write/main 3: (((5 integer)) <- ((length)) ((4 tagged-value-array-address) (deref)))
|
||||
array-len: ((4 tagged-value-array-address) (deref))
|
||||
mem: ((1034 integer) (raw)) => 2
|
||||
run: capacity/full?/write/main 3: 2 => ((5 integer))
|
||||
mem: ((5 integer)): 1107 <= 2
|
||||
run: capacity/full?/write/main 4: (((reply)) ((5 integer)))
|
||||
mem: ((5 integer)) => 2
|
||||
run: full?/write/main 4: 2 => ((5 integer))
|
||||
mem: ((5 integer)): 1076 <= 2
|
||||
run: full?/write/main 5: (((6 boolean)) <- ((less-than)) ((4 integer)) ((5 integer)))
|
||||
mem: ((4 integer)) => 1
|
||||
mem: ((5 integer)) => 2
|
||||
run: full?/write/main 5: t => ((6 boolean))
|
||||
mem: ((6 boolean)): 1077 <= t
|
||||
run: full?/write/main 6: (((jump-if)) ((6 boolean)) ((1 offset)))
|
||||
mem: ((6 boolean)) => t
|
||||
run: full?/write/main 8: (((7 integer)) <- ((get)) ((1 channel)) ((0 offset)))
|
||||
mem: ((1072 integer) (raw)) => 0
|
||||
run: full?/write/main 8: 0 => ((7 integer))
|
||||
mem: ((7 integer)): 1078 <= 0
|
||||
run: full?/write/main 9: (((8 boolean)) <- ((equal)) ((7 integer)) ((4 integer)))
|
||||
mem: ((7 integer)) => 0
|
||||
mem: ((4 integer)) => 1
|
||||
run: full?/write/main 9: nil => ((8 boolean))
|
||||
mem: ((8 boolean)): 1079 <= nil
|
||||
run: full?/write/main 10: (((reply)) ((8 boolean)))
|
||||
mem: ((8 boolean)) => nil
|
||||
run: write/main 3: nil => ((4 boolean))
|
||||
mem: ((4 boolean)): 1044 <= nil
|
||||
run: write/main 4: (((jump-unless)) ((4 boolean)) ((2 offset)))
|
||||
mem: ((4 boolean)) => nil
|
||||
run: write/main 7: (((6 tagged-value-array-address)) <- ((get)) ((1 channel-address) (deref)) ((2 offset)))
|
||||
mem: ((1033 tagged-value-array-address) (raw)) => 1034
|
||||
run: write/main 7: 1034 => ((6 tagged-value-array-address))
|
||||
mem: ((6 tagged-value-array-address)): 1046 <= 1034
|
||||
run: write/main 8: (((7 integer-address)) <- ((get-address)) ((1 channel-address) (deref)) ((1 offset)))
|
||||
run: write/main 8: 1032 => ((7 integer-address))
|
||||
mem: ((7 integer-address)): 1047 <= 1032
|
||||
run: write/main 9: (((8 tagged-value-address)) <- ((index-address)) ((6 tagged-value-array-address) (deref)) ((7 integer-address) (deref)))
|
||||
mem: ((7 integer-address) (deref)) => 0
|
||||
array-len: ((1034 tagged-value-array) (raw))
|
||||
mem: ((1034 integer) (raw)) => 2
|
||||
run: write/main 9: 1035 => ((8 tagged-value-address))
|
||||
mem: ((8 tagged-value-address)): 1048 <= 1035
|
||||
run: write/main 10: (((8 tagged-value-address) (deref)) <- ((copy)) ((2 tagged-value)))
|
||||
mem: ((2 tagged-value)) => #(tagged record (integer 34 . nil))
|
||||
run: write/main 10: #(tagged record (integer 34 . nil)) => ((8 tagged-value-address) (deref))
|
||||
mem: ((8 tagged-value-address) (deref)): 1035 <= integer
|
||||
mem: ((8 tagged-value-address) (deref)): 1036 <= 34
|
||||
run: write/main 11: (((7 integer-address) (deref)) <- ((add)) ((7 integer-address) (deref)) ((1 literal)))
|
||||
mem: ((7 integer-address) (deref)) => 0
|
||||
run: write/main 11: 1 => ((7 integer-address) (deref))
|
||||
mem: ((7 integer-address) (deref)): 1032 <= 1
|
||||
run: write/main 12: (((9 integer)) <- ((length)) ((6 tagged-value-array-address) (deref)))
|
||||
array-len: ((6 tagged-value-array-address) (deref))
|
||||
mem: ((1034 integer) (raw)) => 2
|
||||
run: write/main 12: 2 => ((9 integer))
|
||||
mem: ((9 integer)): 1049 <= 2
|
||||
run: write/main 13: (((10 boolean)) <- ((less-than)) ((7 integer-address) (deref)) ((9 integer)))
|
||||
mem: ((7 integer-address) (deref)) => 1
|
||||
mem: ((9 integer)) => 2
|
||||
run: write/main 13: t => ((10 boolean))
|
||||
mem: ((10 boolean)): 1050 <= t
|
||||
run: write/main 14: (((jump-if)) ((10 boolean)) ((1 offset)))
|
||||
mem: ((10 boolean)) => t
|
||||
run: write/main 16: (((reply)) ((1 channel-address) (deref) (same-as-arg 0)))
|
||||
mem: ((1 channel-address) (deref) (same-as-arg 0)) => #(tagged record (0 1 1034 . nil))
|
||||
run: main 3: #(tagged record (0 1 1034 . nil)) => ((1 channel-address) (deref))
|
||||
mem: ((1 channel-address) (deref)): 1031 <= 0
|
||||
mem: ((1 channel-address) (deref)): 1032 <= 1
|
||||
mem: ((1 channel-address) (deref)): 1033 <= 1034
|
||||
run: main 4: (_ ((1 channel-address) (deref)) <- ((read)) ((1 channel-address)))
|
||||
mem: ((1 channel-address)) => 1031
|
||||
run: read/main 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
|
||||
run: read/main 0: 1132 => ((default-space space-address))
|
||||
run: read/main 1: (((1 channel-address)) <- ((next-input)))
|
||||
arg: nil 0 (1031)
|
||||
run: read/main 1: 1031 => ((1 channel-address))
|
||||
mem: ((1 channel-address)): 1134 <= 1031
|
||||
run: read/main 2: (((2 boolean)) <- ((empty?)) ((1 channel-address) (deref)))
|
||||
mem: ((1 channel-address) (deref)) => #(tagged record (0 1 1034 . nil))
|
||||
run: empty?/read/main 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
|
||||
run: empty?/read/main 0: 1163 => ((default-space space-address))
|
||||
run: empty?/read/main 1: (((1 channel)) <- ((next-input)))
|
||||
arg: nil 0 (#(tagged record (0 1 1034 . nil)))
|
||||
run: empty?/read/main 1: #(tagged record (0 1 1034 . nil)) => ((1 channel))
|
||||
mem: ((1 channel)): 1165 <= 0
|
||||
mem: ((1 channel)): 1166 <= 1
|
||||
mem: ((1 channel)): 1167 <= 1034
|
||||
run: empty?/read/main 2: (((4 integer)) <- ((get)) ((1 channel)) ((0 offset)))
|
||||
mem: ((1165 integer) (raw)) => 0
|
||||
run: empty?/read/main 2: 0 => ((4 integer))
|
||||
mem: ((4 integer)): 1168 <= 0
|
||||
run: empty?/read/main 3: (((5 integer)) <- ((get)) ((1 channel)) ((1 offset)))
|
||||
mem: ((1166 integer) (raw)) => 1
|
||||
run: empty?/read/main 3: 1 => ((5 integer))
|
||||
mem: ((5 integer)): 1169 <= 1
|
||||
run: empty?/read/main 4: (((6 boolean)) <- ((equal)) ((4 integer)) ((5 integer)))
|
||||
mem: ((4 integer)) => 0
|
||||
mem: ((5 integer)) => 1
|
||||
run: empty?/read/main 4: nil => ((6 boolean))
|
||||
mem: ((6 boolean)): 1170 <= nil
|
||||
run: empty?/read/main 5: (((reply)) ((6 boolean)))
|
||||
mem: ((6 boolean)) => nil
|
||||
run: read/main 2: nil => ((2 boolean))
|
||||
mem: ((2 boolean)): 1135 <= nil
|
||||
run: read/main 3: (((jump-unless)) ((2 boolean)) ((2 offset)))
|
||||
mem: ((2 boolean)) => nil
|
||||
run: read/main 6: (((4 integer-address)) <- ((get-address)) ((1 channel-address) (deref)) ((0 offset)))
|
||||
run: read/main 6: 1031 => ((4 integer-address))
|
||||
mem: ((4 integer-address)): 1137 <= 1031
|
||||
run: read/main 7: (((5 tagged-value-array-address)) <- ((get)) ((1 channel-address) (deref)) ((2 offset)))
|
||||
mem: ((1033 tagged-value-array-address) (raw)) => 1034
|
||||
run: read/main 7: 1034 => ((5 tagged-value-array-address))
|
||||
mem: ((5 tagged-value-array-address)): 1138 <= 1034
|
||||
run: read/main 8: (((6 tagged-value)) <- ((index)) ((5 tagged-value-array-address) (deref)) ((4 integer-address) (deref)))
|
||||
mem: ((4 integer-address) (deref)) => 0
|
||||
array-len: ((1034 tagged-value-array) (raw))
|
||||
mem: ((1034 integer) (raw)) => 2
|
||||
mem: ((1035 tagged-value) (raw)) => #(tagged record (integer 34 . nil))
|
||||
run: read/main 8: #(tagged record (integer 34 . nil)) => ((6 tagged-value))
|
||||
mem: ((6 tagged-value)): 1139 <= integer
|
||||
mem: ((6 tagged-value)): 1140 <= 34
|
||||
run: read/main 9: (((4 integer-address) (deref)) <- ((add)) ((4 integer-address) (deref)) ((1 literal)))
|
||||
mem: ((4 integer-address) (deref)) => 0
|
||||
run: read/main 9: 1 => ((4 integer-address) (deref))
|
||||
mem: ((4 integer-address) (deref)): 1031 <= 1
|
||||
run: read/main 10: (((8 integer)) <- ((length)) ((5 tagged-value-array-address) (deref)))
|
||||
array-len: ((5 tagged-value-array-address) (deref))
|
||||
mem: ((1034 integer) (raw)) => 2
|
||||
run: read/main 10: 2 => ((8 integer))
|
||||
mem: ((8 integer)): 1141 <= 2
|
||||
run: read/main 11: (((9 boolean)) <- ((less-than)) ((4 integer-address) (deref)) ((8 integer)))
|
||||
mem: ((4 integer-address) (deref)) => 1
|
||||
mem: ((8 integer)) => 2
|
||||
run: read/main 11: t => ((9 boolean))
|
||||
mem: ((9 boolean)): 1142 <= t
|
||||
run: read/main 12: (((jump-if)) ((9 boolean)) ((1 offset)))
|
||||
mem: ((9 boolean)) => t
|
||||
run: read/main 14: (((reply)) ((6 tagged-value)) ((1 channel-address) (deref) (same-as-arg 0)))
|
||||
mem: ((6 tagged-value)) => #(tagged record (integer 34 . nil))
|
||||
mem: ((1 channel-address) (deref) (same-as-arg 0)) => #(tagged record (1 1 1034 . nil))
|
||||
run: main 4: #(tagged record (integer 34 . nil)) => _
|
||||
run: main 4: #(tagged record (1 1 1034 . nil)) => ((1 channel-address) (deref))
|
||||
mem: ((1 channel-address) (deref)): 1031 <= 1
|
||||
mem: ((1 channel-address) (deref)): 1032 <= 1
|
||||
mem: ((1 channel-address) (deref)): 1033 <= 1034
|
||||
run: main 5: (((5 integer)) <- ((get)) ((1 channel-address) (deref)) ((0 offset)))
|
||||
mem: ((1031 integer) (raw)) => 1
|
||||
run: main 5: 1 => ((5 integer))
|
||||
mem: ((5 integer)): 5 <= 1
|
||||
run: main 6: (((1 channel-address) (deref)) <- ((write)) ((1 channel-address)) ((3 tagged-value)))
|
||||
mem: ((1 channel-address)) => 1031
|
||||
mem: ((3 tagged-value)) => #(tagged record (integer 34 . nil))
|
||||
run: write/main 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
|
||||
run: write/main 0: 1194 => ((default-space space-address))
|
||||
run: write/main 1: (((1 channel-address)) <- ((next-input)))
|
||||
arg: nil 0 (1031 #(tagged record (integer 34 . nil)))
|
||||
run: write/main 1: 1031 => ((1 channel-address))
|
||||
mem: ((1 channel-address)): 1196 <= 1031
|
||||
run: write/main 2: (((2 tagged-value)) <- ((next-input)))
|
||||
arg: nil 1 (1031 #(tagged record (integer 34 . nil)))
|
||||
run: write/main 2: #(tagged record (integer 34 . nil)) => ((2 tagged-value))
|
||||
mem: ((2 tagged-value)): 1197 <= integer
|
||||
mem: ((2 tagged-value)): 1198 <= 34
|
||||
run: write/main 3: (((4 boolean)) <- ((full?)) ((1 channel-address) (deref)))
|
||||
mem: ((1 channel-address) (deref)) => #(tagged record (1 1 1034 . nil))
|
||||
run: full?/write/main 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
|
||||
run: full?/write/main 0: 1225 => ((default-space space-address))
|
||||
run: full?/write/main 1: (((1 channel)) <- ((next-input)))
|
||||
arg: nil 0 (#(tagged record (1 1 1034 . nil)))
|
||||
run: full?/write/main 1: #(tagged record (1 1 1034 . nil)) => ((1 channel))
|
||||
mem: ((1 channel)): 1227 <= 1
|
||||
mem: ((1 channel)): 1228 <= 1
|
||||
mem: ((1 channel)): 1229 <= 1034
|
||||
run: full?/write/main 2: (((4 integer)) <- ((get)) ((1 channel)) ((1 offset)))
|
||||
mem: ((1228 integer) (raw)) => 1
|
||||
run: full?/write/main 2: 1 => ((4 integer))
|
||||
mem: ((4 integer)): 1230 <= 1
|
||||
run: full?/write/main 3: (((4 integer)) <- ((add)) ((4 integer)) ((1 literal)))
|
||||
mem: ((4 integer)) => 1
|
||||
run: full?/write/main 3: 2 => ((4 integer))
|
||||
mem: ((4 integer)): 1230 <= 2
|
||||
run: full?/write/main 4: (((5 integer)) <- ((capacity)) ((1 channel)))
|
||||
mem: ((1 channel)) => #(tagged record (1 1 1034 . nil))
|
||||
run: capacity/full?/write/main 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
|
||||
run: capacity/full?/write/main 0: 1256 => ((default-space space-address))
|
||||
run: capacity/full?/write/main 1: (((1 channel)) <- ((next-input)))
|
||||
arg: nil 0 (#(tagged record (1 1 1034 . nil)))
|
||||
run: capacity/full?/write/main 1: #(tagged record (1 1 1034 . nil)) => ((1 channel))
|
||||
mem: ((1 channel)): 1258 <= 1
|
||||
mem: ((1 channel)): 1259 <= 1
|
||||
mem: ((1 channel)): 1260 <= 1034
|
||||
run: capacity/full?/write/main 2: (((4 tagged-value-array-address)) <- ((get)) ((1 channel)) ((2 offset)))
|
||||
mem: ((1260 tagged-value-array-address) (raw)) => 1034
|
||||
run: capacity/full?/write/main 2: 1034 => ((4 tagged-value-array-address))
|
||||
mem: ((4 tagged-value-array-address)): 1261 <= 1034
|
||||
run: capacity/full?/write/main 3: (((5 integer)) <- ((length)) ((4 tagged-value-array-address) (deref)))
|
||||
array-len: ((4 tagged-value-array-address) (deref))
|
||||
mem: ((1034 integer) (raw)) => 2
|
||||
run: capacity/full?/write/main 3: 2 => ((5 integer))
|
||||
mem: ((5 integer)): 1262 <= 2
|
||||
run: capacity/full?/write/main 4: (((reply)) ((5 integer)))
|
||||
mem: ((5 integer)) => 2
|
||||
run: full?/write/main 4: 2 => ((5 integer))
|
||||
mem: ((5 integer)): 1231 <= 2
|
||||
run: full?/write/main 5: (((6 boolean)) <- ((less-than)) ((4 integer)) ((5 integer)))
|
||||
mem: ((4 integer)) => 2
|
||||
mem: ((5 integer)) => 2
|
||||
run: full?/write/main 5: nil => ((6 boolean))
|
||||
mem: ((6 boolean)): 1232 <= nil
|
||||
run: full?/write/main 6: (((jump-if)) ((6 boolean)) ((1 offset)))
|
||||
mem: ((6 boolean)) => nil
|
||||
run: full?/write/main 7: (((4 integer)) <- ((copy)) ((0 literal)))
|
||||
run: full?/write/main 7: 0 => ((4 integer))
|
||||
mem: ((4 integer)): 1230 <= 0
|
||||
run: full?/write/main 8: (((7 integer)) <- ((get)) ((1 channel)) ((0 offset)))
|
||||
mem: ((1227 integer) (raw)) => 1
|
||||
run: full?/write/main 8: 1 => ((7 integer))
|
||||
mem: ((7 integer)): 1233 <= 1
|
||||
run: full?/write/main 9: (((8 boolean)) <- ((equal)) ((7 integer)) ((4 integer)))
|
||||
mem: ((7 integer)) => 1
|
||||
mem: ((4 integer)) => 0
|
||||
run: full?/write/main 9: nil => ((8 boolean))
|
||||
mem: ((8 boolean)): 1234 <= nil
|
||||
run: full?/write/main 10: (((reply)) ((8 boolean)))
|
||||
mem: ((8 boolean)) => nil
|
||||
run: write/main 3: nil => ((4 boolean))
|
||||
mem: ((4 boolean)): 1199 <= nil
|
||||
run: write/main 4: (((jump-unless)) ((4 boolean)) ((2 offset)))
|
||||
mem: ((4 boolean)) => nil
|
||||
run: write/main 7: (((6 tagged-value-array-address)) <- ((get)) ((1 channel-address) (deref)) ((2 offset)))
|
||||
mem: ((1033 tagged-value-array-address) (raw)) => 1034
|
||||
run: write/main 7: 1034 => ((6 tagged-value-array-address))
|
||||
mem: ((6 tagged-value-array-address)): 1201 <= 1034
|
||||
run: write/main 8: (((7 integer-address)) <- ((get-address)) ((1 channel-address) (deref)) ((1 offset)))
|
||||
run: write/main 8: 1032 => ((7 integer-address))
|
||||
mem: ((7 integer-address)): 1202 <= 1032
|
||||
run: write/main 9: (((8 tagged-value-address)) <- ((index-address)) ((6 tagged-value-array-address) (deref)) ((7 integer-address) (deref)))
|
||||
mem: ((7 integer-address) (deref)) => 1
|
||||
array-len: ((1034 tagged-value-array) (raw))
|
||||
mem: ((1034 integer) (raw)) => 2
|
||||
run: write/main 9: 1037 => ((8 tagged-value-address))
|
||||
mem: ((8 tagged-value-address)): 1203 <= 1037
|
||||
run: write/main 10: (((8 tagged-value-address) (deref)) <- ((copy)) ((2 tagged-value)))
|
||||
mem: ((2 tagged-value)) => #(tagged record (integer 34 . nil))
|
||||
run: write/main 10: #(tagged record (integer 34 . nil)) => ((8 tagged-value-address) (deref))
|
||||
mem: ((8 tagged-value-address) (deref)): 1037 <= integer
|
||||
mem: ((8 tagged-value-address) (deref)): 1038 <= 34
|
||||
run: write/main 11: (((7 integer-address) (deref)) <- ((add)) ((7 integer-address) (deref)) ((1 literal)))
|
||||
mem: ((7 integer-address) (deref)) => 1
|
||||
run: write/main 11: 2 => ((7 integer-address) (deref))
|
||||
mem: ((7 integer-address) (deref)): 1032 <= 2
|
||||
run: write/main 12: (((9 integer)) <- ((length)) ((6 tagged-value-array-address) (deref)))
|
||||
array-len: ((6 tagged-value-array-address) (deref))
|
||||
mem: ((1034 integer) (raw)) => 2
|
||||
run: write/main 12: 2 => ((9 integer))
|
||||
mem: ((9 integer)): 1204 <= 2
|
||||
run: write/main 13: (((10 boolean)) <- ((less-than)) ((7 integer-address) (deref)) ((9 integer)))
|
||||
mem: ((7 integer-address) (deref)) => 2
|
||||
mem: ((9 integer)) => 2
|
||||
run: write/main 13: nil => ((10 boolean))
|
||||
mem: ((10 boolean)): 1205 <= nil
|
||||
run: write/main 14: (((jump-if)) ((10 boolean)) ((1 offset)))
|
||||
mem: ((10 boolean)) => nil
|
||||
run: write/main 15: (((7 integer-address) (deref)) <- ((copy)) ((0 literal)))
|
||||
run: write/main 15: 0 => ((7 integer-address) (deref))
|
||||
mem: ((7 integer-address) (deref)): 1032 <= 0
|
||||
run: write/main 16: (((reply)) ((1 channel-address) (deref) (same-as-arg 0)))
|
||||
mem: ((1 channel-address) (deref) (same-as-arg 0)) => #(tagged record (1 0 1034 . nil))
|
||||
run: main 6: #(tagged record (1 0 1034 . nil)) => ((1 channel-address) (deref))
|
||||
mem: ((1 channel-address) (deref)): 1031 <= 1
|
||||
mem: ((1 channel-address) (deref)): 1032 <= 0
|
||||
mem: ((1 channel-address) (deref)): 1033 <= 1034
|
||||
run: main 7: (_ ((1 channel-address) (deref)) <- ((read)) ((1 channel-address)))
|
||||
mem: ((1 channel-address)) => 1031
|
||||
run: read/main 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
|
||||
run: read/main 0: 1287 => ((default-space space-address))
|
||||
run: read/main 1: (((1 channel-address)) <- ((next-input)))
|
||||
arg: nil 0 (1031)
|
||||
run: read/main 1: 1031 => ((1 channel-address))
|
||||
mem: ((1 channel-address)): 1289 <= 1031
|
||||
run: read/main 2: (((2 boolean)) <- ((empty?)) ((1 channel-address) (deref)))
|
||||
mem: ((1 channel-address) (deref)) => #(tagged record (1 0 1034 . nil))
|
||||
run: empty?/read/main 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
|
||||
run: empty?/read/main 0: 1318 => ((default-space space-address))
|
||||
run: empty?/read/main 1: (((1 channel)) <- ((next-input)))
|
||||
arg: nil 0 (#(tagged record (1 0 1034 . nil)))
|
||||
run: empty?/read/main 1: #(tagged record (1 0 1034 . nil)) => ((1 channel))
|
||||
mem: ((1 channel)): 1320 <= 1
|
||||
mem: ((1 channel)): 1321 <= 0
|
||||
mem: ((1 channel)): 1322 <= 1034
|
||||
run: empty?/read/main 2: (((4 integer)) <- ((get)) ((1 channel)) ((0 offset)))
|
||||
mem: ((1320 integer) (raw)) => 1
|
||||
run: empty?/read/main 2: 1 => ((4 integer))
|
||||
mem: ((4 integer)): 1323 <= 1
|
||||
run: empty?/read/main 3: (((5 integer)) <- ((get)) ((1 channel)) ((1 offset)))
|
||||
mem: ((1321 integer) (raw)) => 0
|
||||
run: empty?/read/main 3: 0 => ((5 integer))
|
||||
mem: ((5 integer)): 1324 <= 0
|
||||
run: empty?/read/main 4: (((6 boolean)) <- ((equal)) ((4 integer)) ((5 integer)))
|
||||
mem: ((4 integer)) => 1
|
||||
mem: ((5 integer)) => 0
|
||||
run: empty?/read/main 4: nil => ((6 boolean))
|
||||
mem: ((6 boolean)): 1325 <= nil
|
||||
run: empty?/read/main 5: (((reply)) ((6 boolean)))
|
||||
mem: ((6 boolean)) => nil
|
||||
run: read/main 2: nil => ((2 boolean))
|
||||
mem: ((2 boolean)): 1290 <= nil
|
||||
run: read/main 3: (((jump-unless)) ((2 boolean)) ((2 offset)))
|
||||
mem: ((2 boolean)) => nil
|
||||
run: read/main 6: (((4 integer-address)) <- ((get-address)) ((1 channel-address) (deref)) ((0 offset)))
|
||||
run: read/main 6: 1031 => ((4 integer-address))
|
||||
mem: ((4 integer-address)): 1292 <= 1031
|
||||
run: read/main 7: (((5 tagged-value-array-address)) <- ((get)) ((1 channel-address) (deref)) ((2 offset)))
|
||||
mem: ((1033 tagged-value-array-address) (raw)) => 1034
|
||||
run: read/main 7: 1034 => ((5 tagged-value-array-address))
|
||||
mem: ((5 tagged-value-array-address)): 1293 <= 1034
|
||||
run: read/main 8: (((6 tagged-value)) <- ((index)) ((5 tagged-value-array-address) (deref)) ((4 integer-address) (deref)))
|
||||
mem: ((4 integer-address) (deref)) => 1
|
||||
array-len: ((1034 tagged-value-array) (raw))
|
||||
mem: ((1034 integer) (raw)) => 2
|
||||
mem: ((1037 tagged-value) (raw)) => #(tagged record (integer 34 . nil))
|
||||
run: read/main 8: #(tagged record (integer 34 . nil)) => ((6 tagged-value))
|
||||
mem: ((6 tagged-value)): 1294 <= integer
|
||||
mem: ((6 tagged-value)): 1295 <= 34
|
||||
run: read/main 9: (((4 integer-address) (deref)) <- ((add)) ((4 integer-address) (deref)) ((1 literal)))
|
||||
mem: ((4 integer-address) (deref)) => 1
|
||||
run: read/main 9: 2 => ((4 integer-address) (deref))
|
||||
mem: ((4 integer-address) (deref)): 1031 <= 2
|
||||
run: read/main 10: (((8 integer)) <- ((length)) ((5 tagged-value-array-address) (deref)))
|
||||
array-len: ((5 tagged-value-array-address) (deref))
|
||||
mem: ((1034 integer) (raw)) => 2
|
||||
run: read/main 10: 2 => ((8 integer))
|
||||
mem: ((8 integer)): 1296 <= 2
|
||||
run: read/main 11: (((9 boolean)) <- ((less-than)) ((4 integer-address) (deref)) ((8 integer)))
|
||||
mem: ((4 integer-address) (deref)) => 2
|
||||
mem: ((8 integer)) => 2
|
||||
run: read/main 11: nil => ((9 boolean))
|
||||
mem: ((9 boolean)): 1297 <= nil
|
||||
run: read/main 12: (((jump-if)) ((9 boolean)) ((1 offset)))
|
||||
mem: ((9 boolean)) => nil
|
||||
run: read/main 13: (((4 integer-address) (deref)) <- ((copy)) ((0 literal)))
|
||||
run: read/main 13: 0 => ((4 integer-address) (deref))
|
||||
mem: ((4 integer-address) (deref)): 1031 <= 0
|
||||
run: read/main 14: (((reply)) ((6 tagged-value)) ((1 channel-address) (deref) (same-as-arg 0)))
|
||||
mem: ((6 tagged-value)) => #(tagged record (integer 34 . nil))
|
||||
mem: ((1 channel-address) (deref) (same-as-arg 0)) => #(tagged record (0 0 1034 . nil))
|
||||
run: main 7: #(tagged record (integer 34 . nil)) => _
|
||||
run: main 7: #(tagged record (0 0 1034 . nil)) => ((1 channel-address) (deref))
|
||||
mem: ((1 channel-address) (deref)): 1031 <= 0
|
||||
mem: ((1 channel-address) (deref)): 1032 <= 0
|
||||
mem: ((1 channel-address) (deref)): 1033 <= 1034
|
||||
run: main 8: (((6 integer)) <- ((get)) ((1 channel-address) (deref)) ((0 offset)))
|
||||
mem: ((1031 integer) (raw)) => 0
|
||||
run: main 8: 0 => ((6 integer))
|
||||
mem: ((6 integer)): 6 <= 0
|
||||
schedule: done with routine nil
|
||||
|
|
@ -0,0 +1,229 @@
|
|||
c{0: 0 (((1 channel-address)) <- ((init-channel)) ((3 literal))) -- nil
|
||||
c{0: 1 (((2 integer)) <- ((copy)) ((34 literal))) -- nil
|
||||
c{0: 2 (((3 tagged-value)) <- ((save-type)) ((2 integer))) -- nil
|
||||
c{0: 3 (((1 channel-address) (deref)) <- ((write)) ((1 channel-address)) ((3 tagged-value))) -- nil
|
||||
c{0: 4 (((5 integer)) <- ((get)) ((1 channel-address) (deref)) ((first-full offset))) -- nil
|
||||
c{0: 5 (((6 integer)) <- ((get)) ((1 channel-address) (deref)) ((first-free offset))) -- nil
|
||||
c{1: 0 ✓ (((1 channel-address)) <- ((init-channel)) ((3 literal)))
|
||||
c{1: 1 ✓ (((2 integer)) <- ((copy)) ((34 literal)))
|
||||
c{1: 2 ✓ (((3 tagged-value)) <- ((save-type)) ((2 integer)))
|
||||
c{1: 3 ✓ (((1 channel-address) (deref)) <- ((write)) ((1 channel-address)) ((3 tagged-value)))
|
||||
c{1: 4 ✓ (((5 integer)) <- ((get)) ((1 channel-address) (deref)) ((first-full offset)))
|
||||
c{1: 5 ✓ (((6 integer)) <- ((get)) ((1 channel-address) (deref)) ((first-free offset)))
|
||||
cn0: convert-names in main
|
||||
cn0: (((1 channel-address)) <- ((init-channel)) ((3 literal))) nil nil
|
||||
cn0: checking arg ((3 literal))
|
||||
cn0: checking oarg ((1 channel-address))
|
||||
maybe-add: ((1 channel-address))
|
||||
cn0: (((2 integer)) <- ((copy)) ((34 literal))) nil nil
|
||||
cn0: checking arg ((34 literal))
|
||||
cn0: checking oarg ((2 integer))
|
||||
maybe-add: ((2 integer))
|
||||
cn0: (((3 tagged-value)) <- ((save-type)) ((2 integer))) nil nil
|
||||
cn0: checking arg ((2 integer))
|
||||
maybe-add: ((2 integer))
|
||||
cn0: checking oarg ((3 tagged-value))
|
||||
maybe-add: ((3 tagged-value))
|
||||
cn0: (((1 channel-address) (deref)) <- ((write)) ((1 channel-address)) ((3 tagged-value))) nil nil
|
||||
cn0: checking arg ((1 channel-address))
|
||||
maybe-add: ((1 channel-address))
|
||||
cn0: checking arg ((3 tagged-value))
|
||||
maybe-add: ((3 tagged-value))
|
||||
cn0: checking oarg ((1 channel-address) (deref))
|
||||
maybe-add: ((1 channel-address) (deref))
|
||||
cn0: (((5 integer)) <- ((get)) ((1 channel-address) (deref)) ((first-full offset))) nil nil
|
||||
cn0: field-access first-full in 1channel-addressderef of type channel
|
||||
cn0: new field; computing location
|
||||
cn0: field location 0
|
||||
cn0: checking arg ((1 channel-address) (deref))
|
||||
maybe-add: ((1 channel-address) (deref))
|
||||
cn0: checking arg ((first-full offset))
|
||||
cn0: checking oarg ((5 integer))
|
||||
maybe-add: ((5 integer))
|
||||
cn0: (((6 integer)) <- ((get)) ((1 channel-address) (deref)) ((first-free offset))) ((first-full 0)) ((first-full t))
|
||||
cn0: field-access first-free in 1channel-addressderef of type channel
|
||||
cn0: new field; computing location
|
||||
cn0: field location 1
|
||||
cn0: checking arg ((1 channel-address) (deref))
|
||||
maybe-add: ((1 channel-address) (deref))
|
||||
cn0: checking arg ((first-free offset))
|
||||
cn0: checking oarg ((6 integer))
|
||||
maybe-add: ((6 integer))
|
||||
cn1: (((1 channel-address)) <- ((init-channel)) ((3 literal)))
|
||||
cn1: (((2 integer)) <- ((copy)) ((34 literal)))
|
||||
cn1: (((3 tagged-value)) <- ((save-type)) ((2 integer)))
|
||||
cn1: (((1 channel-address) (deref)) <- ((write)) ((1 channel-address)) ((3 tagged-value)))
|
||||
cn1: (((5 integer)) <- ((get)) ((1 channel-address) (deref)) ((0 offset)))
|
||||
cn1: (((6 integer)) <- ((get)) ((1 channel-address) (deref)) ((1 offset)))
|
||||
schedule: main
|
||||
run: main 0: (((1 channel-address)) <- ((init-channel)) ((3 literal)))
|
||||
run: init-channel/main 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
|
||||
run: init-channel/main 0: 1000 => ((default-space space-address))
|
||||
run: init-channel/main 1: (((1 channel-address)) <- ((new)) ((channel literal)))
|
||||
run: init-channel/main 1: 1031 => ((1 channel-address))
|
||||
mem: ((1 channel-address)): 1002 <= 1031
|
||||
run: init-channel/main 2: (((2 integer-address)) <- ((get-address)) ((1 channel-address) (deref)) ((0 offset)))
|
||||
run: init-channel/main 2: 1031 => ((2 integer-address))
|
||||
mem: ((2 integer-address)): 1003 <= 1031
|
||||
run: init-channel/main 3: (((2 integer-address) (deref)) <- ((copy)) ((0 literal)))
|
||||
run: init-channel/main 3: 0 => ((2 integer-address) (deref))
|
||||
mem: ((2 integer-address) (deref)): 1031 <= 0
|
||||
run: init-channel/main 4: (((3 integer-address)) <- ((get-address)) ((1 channel-address) (deref)) ((1 offset)))
|
||||
run: init-channel/main 4: 1032 => ((3 integer-address))
|
||||
mem: ((3 integer-address)): 1004 <= 1032
|
||||
run: init-channel/main 5: (((3 integer-address) (deref)) <- ((copy)) ((0 literal)))
|
||||
run: init-channel/main 5: 0 => ((3 integer-address) (deref))
|
||||
mem: ((3 integer-address) (deref)): 1032 <= 0
|
||||
run: init-channel/main 6: (((4 integer)) <- ((next-input)))
|
||||
arg: nil 0 (3)
|
||||
run: init-channel/main 6: 3 => ((4 integer))
|
||||
mem: ((4 integer)): 1005 <= 3
|
||||
run: init-channel/main 7: (((4 integer)) <- ((add)) ((4 integer)) ((1 literal)))
|
||||
mem: ((4 integer)) => 3
|
||||
run: init-channel/main 7: 4 => ((4 integer))
|
||||
mem: ((4 integer)): 1005 <= 4
|
||||
run: init-channel/main 8: (((5 tagged-value-array-address-address)) <- ((get-address)) ((1 channel-address) (deref)) ((2 offset)))
|
||||
run: init-channel/main 8: 1033 => ((5 tagged-value-array-address-address))
|
||||
mem: ((5 tagged-value-array-address-address)): 1006 <= 1033
|
||||
run: init-channel/main 9: (((5 tagged-value-array-address-address) (deref)) <- ((new)) ((tagged-value-array literal)) ((4 integer)))
|
||||
mem: ((4 integer)) => 4
|
||||
run: init-channel/main 9: 1034 => ((5 tagged-value-array-address-address) (deref))
|
||||
mem: ((5 tagged-value-array-address-address) (deref)): 1033 <= 1034
|
||||
run: init-channel/main 10: (((reply)) ((1 channel-address)))
|
||||
mem: ((1 channel-address)) => 1031
|
||||
run: main 0: 1031 => ((1 channel-address))
|
||||
mem: ((1 channel-address)): 1 <= 1031
|
||||
run: main 1: (((2 integer)) <- ((copy)) ((34 literal)))
|
||||
run: main 1: 34 => ((2 integer))
|
||||
mem: ((2 integer)): 2 <= 34
|
||||
run: main 2: (((3 tagged-value)) <- ((save-type)) ((2 integer)))
|
||||
mem: ((2 integer)) => 34
|
||||
run: main 2: #(tagged record (integer 34)) => ((3 tagged-value))
|
||||
mem: ((3 tagged-value)): 3 <= integer
|
||||
mem: ((3 tagged-value)): 4 <= 34
|
||||
run: main 3: (((1 channel-address) (deref)) <- ((write)) ((1 channel-address)) ((3 tagged-value)))
|
||||
mem: ((1 channel-address)) => 1031
|
||||
mem: ((3 tagged-value)) => #(tagged record (integer 34 . nil))
|
||||
run: write/main 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
|
||||
run: write/main 0: 1043 => ((default-space space-address))
|
||||
run: write/main 1: (((1 channel-address)) <- ((next-input)))
|
||||
arg: nil 0 (1031 #(tagged record (integer 34 . nil)))
|
||||
run: write/main 1: 1031 => ((1 channel-address))
|
||||
mem: ((1 channel-address)): 1045 <= 1031
|
||||
run: write/main 2: (((2 tagged-value)) <- ((next-input)))
|
||||
arg: nil 1 (1031 #(tagged record (integer 34 . nil)))
|
||||
run: write/main 2: #(tagged record (integer 34 . nil)) => ((2 tagged-value))
|
||||
mem: ((2 tagged-value)): 1046 <= integer
|
||||
mem: ((2 tagged-value)): 1047 <= 34
|
||||
run: write/main 3: (((4 boolean)) <- ((full?)) ((1 channel-address) (deref)))
|
||||
mem: ((1 channel-address) (deref)) => #(tagged record (0 0 1034 . nil))
|
||||
run: full?/write/main 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
|
||||
run: full?/write/main 0: 1074 => ((default-space space-address))
|
||||
run: full?/write/main 1: (((1 channel)) <- ((next-input)))
|
||||
arg: nil 0 (#(tagged record (0 0 1034 . nil)))
|
||||
run: full?/write/main 1: #(tagged record (0 0 1034 . nil)) => ((1 channel))
|
||||
mem: ((1 channel)): 1076 <= 0
|
||||
mem: ((1 channel)): 1077 <= 0
|
||||
mem: ((1 channel)): 1078 <= 1034
|
||||
run: full?/write/main 2: (((4 integer)) <- ((get)) ((1 channel)) ((1 offset)))
|
||||
mem: ((1077 integer) (raw)) => 0
|
||||
run: full?/write/main 2: 0 => ((4 integer))
|
||||
mem: ((4 integer)): 1079 <= 0
|
||||
run: full?/write/main 3: (((4 integer)) <- ((add)) ((4 integer)) ((1 literal)))
|
||||
mem: ((4 integer)) => 0
|
||||
run: full?/write/main 3: 1 => ((4 integer))
|
||||
mem: ((4 integer)): 1079 <= 1
|
||||
run: full?/write/main 4: (((5 integer)) <- ((capacity)) ((1 channel)))
|
||||
mem: ((1 channel)) => #(tagged record (0 0 1034 . nil))
|
||||
run: capacity/full?/write/main 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
|
||||
run: capacity/full?/write/main 0: 1105 => ((default-space space-address))
|
||||
run: capacity/full?/write/main 1: (((1 channel)) <- ((next-input)))
|
||||
arg: nil 0 (#(tagged record (0 0 1034 . nil)))
|
||||
run: capacity/full?/write/main 1: #(tagged record (0 0 1034 . nil)) => ((1 channel))
|
||||
mem: ((1 channel)): 1107 <= 0
|
||||
mem: ((1 channel)): 1108 <= 0
|
||||
mem: ((1 channel)): 1109 <= 1034
|
||||
run: capacity/full?/write/main 2: (((4 tagged-value-array-address)) <- ((get)) ((1 channel)) ((2 offset)))
|
||||
mem: ((1109 tagged-value-array-address) (raw)) => 1034
|
||||
run: capacity/full?/write/main 2: 1034 => ((4 tagged-value-array-address))
|
||||
mem: ((4 tagged-value-array-address)): 1110 <= 1034
|
||||
run: capacity/full?/write/main 3: (((5 integer)) <- ((length)) ((4 tagged-value-array-address) (deref)))
|
||||
array-len: ((4 tagged-value-array-address) (deref))
|
||||
mem: ((1034 integer) (raw)) => 4
|
||||
run: capacity/full?/write/main 3: 4 => ((5 integer))
|
||||
mem: ((5 integer)): 1111 <= 4
|
||||
run: capacity/full?/write/main 4: (((reply)) ((5 integer)))
|
||||
mem: ((5 integer)) => 4
|
||||
run: full?/write/main 4: 4 => ((5 integer))
|
||||
mem: ((5 integer)): 1080 <= 4
|
||||
run: full?/write/main 5: (((6 boolean)) <- ((less-than)) ((4 integer)) ((5 integer)))
|
||||
mem: ((4 integer)) => 1
|
||||
mem: ((5 integer)) => 4
|
||||
run: full?/write/main 5: t => ((6 boolean))
|
||||
mem: ((6 boolean)): 1081 <= t
|
||||
run: full?/write/main 6: (((jump-if)) ((6 boolean)) ((1 offset)))
|
||||
mem: ((6 boolean)) => t
|
||||
run: full?/write/main 8: (((7 integer)) <- ((get)) ((1 channel)) ((0 offset)))
|
||||
mem: ((1076 integer) (raw)) => 0
|
||||
run: full?/write/main 8: 0 => ((7 integer))
|
||||
mem: ((7 integer)): 1082 <= 0
|
||||
run: full?/write/main 9: (((8 boolean)) <- ((equal)) ((7 integer)) ((4 integer)))
|
||||
mem: ((7 integer)) => 0
|
||||
mem: ((4 integer)) => 1
|
||||
run: full?/write/main 9: nil => ((8 boolean))
|
||||
mem: ((8 boolean)): 1083 <= nil
|
||||
run: full?/write/main 10: (((reply)) ((8 boolean)))
|
||||
mem: ((8 boolean)) => nil
|
||||
run: write/main 3: nil => ((4 boolean))
|
||||
mem: ((4 boolean)): 1048 <= nil
|
||||
run: write/main 4: (((jump-unless)) ((4 boolean)) ((2 offset)))
|
||||
mem: ((4 boolean)) => nil
|
||||
run: write/main 7: (((6 tagged-value-array-address)) <- ((get)) ((1 channel-address) (deref)) ((2 offset)))
|
||||
mem: ((1033 tagged-value-array-address) (raw)) => 1034
|
||||
run: write/main 7: 1034 => ((6 tagged-value-array-address))
|
||||
mem: ((6 tagged-value-array-address)): 1050 <= 1034
|
||||
run: write/main 8: (((7 integer-address)) <- ((get-address)) ((1 channel-address) (deref)) ((1 offset)))
|
||||
run: write/main 8: 1032 => ((7 integer-address))
|
||||
mem: ((7 integer-address)): 1051 <= 1032
|
||||
run: write/main 9: (((8 tagged-value-address)) <- ((index-address)) ((6 tagged-value-array-address) (deref)) ((7 integer-address) (deref)))
|
||||
mem: ((7 integer-address) (deref)) => 0
|
||||
array-len: ((1034 tagged-value-array) (raw))
|
||||
mem: ((1034 integer) (raw)) => 4
|
||||
run: write/main 9: 1035 => ((8 tagged-value-address))
|
||||
mem: ((8 tagged-value-address)): 1052 <= 1035
|
||||
run: write/main 10: (((8 tagged-value-address) (deref)) <- ((copy)) ((2 tagged-value)))
|
||||
mem: ((2 tagged-value)) => #(tagged record (integer 34 . nil))
|
||||
run: write/main 10: #(tagged record (integer 34 . nil)) => ((8 tagged-value-address) (deref))
|
||||
mem: ((8 tagged-value-address) (deref)): 1035 <= integer
|
||||
mem: ((8 tagged-value-address) (deref)): 1036 <= 34
|
||||
run: write/main 11: (((7 integer-address) (deref)) <- ((add)) ((7 integer-address) (deref)) ((1 literal)))
|
||||
mem: ((7 integer-address) (deref)) => 0
|
||||
run: write/main 11: 1 => ((7 integer-address) (deref))
|
||||
mem: ((7 integer-address) (deref)): 1032 <= 1
|
||||
run: write/main 12: (((9 integer)) <- ((length)) ((6 tagged-value-array-address) (deref)))
|
||||
array-len: ((6 tagged-value-array-address) (deref))
|
||||
mem: ((1034 integer) (raw)) => 4
|
||||
run: write/main 12: 4 => ((9 integer))
|
||||
mem: ((9 integer)): 1053 <= 4
|
||||
run: write/main 13: (((10 boolean)) <- ((less-than)) ((7 integer-address) (deref)) ((9 integer)))
|
||||
mem: ((7 integer-address) (deref)) => 1
|
||||
mem: ((9 integer)) => 4
|
||||
run: write/main 13: t => ((10 boolean))
|
||||
mem: ((10 boolean)): 1054 <= t
|
||||
run: write/main 14: (((jump-if)) ((10 boolean)) ((1 offset)))
|
||||
mem: ((10 boolean)) => t
|
||||
run: write/main 16: (((reply)) ((1 channel-address) (deref) (same-as-arg 0)))
|
||||
mem: ((1 channel-address) (deref) (same-as-arg 0)) => #(tagged record (0 1 1034 . nil))
|
||||
run: main 3: #(tagged record (0 1 1034 . nil)) => ((1 channel-address) (deref))
|
||||
mem: ((1 channel-address) (deref)): 1031 <= 0
|
||||
mem: ((1 channel-address) (deref)): 1032 <= 1
|
||||
mem: ((1 channel-address) (deref)): 1033 <= 1034
|
||||
run: main 4: (((5 integer)) <- ((get)) ((1 channel-address) (deref)) ((0 offset)))
|
||||
mem: ((1031 integer) (raw)) => 0
|
||||
run: main 4: 0 => ((5 integer))
|
||||
mem: ((5 integer)): 5 <= 0
|
||||
run: main 5: (((6 integer)) <- ((get)) ((1 channel-address) (deref)) ((1 offset)))
|
||||
mem: ((1032 integer) (raw)) => 1
|
||||
run: main 5: 1 => ((6 integer))
|
||||
mem: ((6 integer)): 6 <= 1
|
||||
schedule: done with routine nil
|
||||
|
|
@ -0,0 +1,292 @@
|
|||
c{0: 0 (((1 channel-address)) <- ((init-channel)) ((1 literal))) -- nil
|
||||
c{0: 1 (((2 integer)) <- ((copy)) ((34 literal))) -- nil
|
||||
c{0: 2 (((3 tagged-value)) <- ((save-type)) ((2 integer))) -- nil
|
||||
c{0: 3 (((1 channel-address) (deref)) <- ((write)) ((1 channel-address)) ((3 tagged-value))) -- nil
|
||||
c{0: 4 (((1 channel-address) (deref)) <- ((write)) ((1 channel-address)) ((3 tagged-value))) -- nil
|
||||
c{1: 0 ✓ (((1 channel-address)) <- ((init-channel)) ((1 literal)))
|
||||
c{1: 1 ✓ (((2 integer)) <- ((copy)) ((34 literal)))
|
||||
c{1: 2 ✓ (((3 tagged-value)) <- ((save-type)) ((2 integer)))
|
||||
c{1: 3 ✓ (((1 channel-address) (deref)) <- ((write)) ((1 channel-address)) ((3 tagged-value)))
|
||||
c{1: 4 ✓ (((1 channel-address) (deref)) <- ((write)) ((1 channel-address)) ((3 tagged-value)))
|
||||
cn0: convert-names in main
|
||||
cn0: (((1 channel-address)) <- ((init-channel)) ((1 literal))) nil nil
|
||||
cn0: checking arg ((1 literal))
|
||||
cn0: checking oarg ((1 channel-address))
|
||||
maybe-add: ((1 channel-address))
|
||||
cn0: (((2 integer)) <- ((copy)) ((34 literal))) nil nil
|
||||
cn0: checking arg ((34 literal))
|
||||
cn0: checking oarg ((2 integer))
|
||||
maybe-add: ((2 integer))
|
||||
cn0: (((3 tagged-value)) <- ((save-type)) ((2 integer))) nil nil
|
||||
cn0: checking arg ((2 integer))
|
||||
maybe-add: ((2 integer))
|
||||
cn0: checking oarg ((3 tagged-value))
|
||||
maybe-add: ((3 tagged-value))
|
||||
cn0: (((1 channel-address) (deref)) <- ((write)) ((1 channel-address)) ((3 tagged-value))) nil nil
|
||||
cn0: checking arg ((1 channel-address))
|
||||
maybe-add: ((1 channel-address))
|
||||
cn0: checking arg ((3 tagged-value))
|
||||
maybe-add: ((3 tagged-value))
|
||||
cn0: checking oarg ((1 channel-address) (deref))
|
||||
maybe-add: ((1 channel-address) (deref))
|
||||
cn0: (((1 channel-address) (deref)) <- ((write)) ((1 channel-address)) ((3 tagged-value))) nil nil
|
||||
cn0: checking arg ((1 channel-address))
|
||||
maybe-add: ((1 channel-address))
|
||||
cn0: checking arg ((3 tagged-value))
|
||||
maybe-add: ((3 tagged-value))
|
||||
cn0: checking oarg ((1 channel-address) (deref))
|
||||
maybe-add: ((1 channel-address) (deref))
|
||||
cn1: (((1 channel-address)) <- ((init-channel)) ((1 literal)))
|
||||
cn1: (((2 integer)) <- ((copy)) ((34 literal)))
|
||||
cn1: (((3 tagged-value)) <- ((save-type)) ((2 integer)))
|
||||
cn1: (((1 channel-address) (deref)) <- ((write)) ((1 channel-address)) ((3 tagged-value)))
|
||||
cn1: (((1 channel-address) (deref)) <- ((write)) ((1 channel-address)) ((3 tagged-value)))
|
||||
schedule: main
|
||||
run: main 0: (((1 channel-address)) <- ((init-channel)) ((1 literal)))
|
||||
run: init-channel/main 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
|
||||
run: init-channel/main 0: 1000 => ((default-space space-address))
|
||||
run: init-channel/main 1: (((1 channel-address)) <- ((new)) ((channel literal)))
|
||||
run: init-channel/main 1: 1031 => ((1 channel-address))
|
||||
mem: ((1 channel-address)): 1002 <= 1031
|
||||
run: init-channel/main 2: (((2 integer-address)) <- ((get-address)) ((1 channel-address) (deref)) ((0 offset)))
|
||||
run: init-channel/main 2: 1031 => ((2 integer-address))
|
||||
mem: ((2 integer-address)): 1003 <= 1031
|
||||
run: init-channel/main 3: (((2 integer-address) (deref)) <- ((copy)) ((0 literal)))
|
||||
run: init-channel/main 3: 0 => ((2 integer-address) (deref))
|
||||
mem: ((2 integer-address) (deref)): 1031 <= 0
|
||||
run: init-channel/main 4: (((3 integer-address)) <- ((get-address)) ((1 channel-address) (deref)) ((1 offset)))
|
||||
run: init-channel/main 4: 1032 => ((3 integer-address))
|
||||
mem: ((3 integer-address)): 1004 <= 1032
|
||||
run: init-channel/main 5: (((3 integer-address) (deref)) <- ((copy)) ((0 literal)))
|
||||
run: init-channel/main 5: 0 => ((3 integer-address) (deref))
|
||||
mem: ((3 integer-address) (deref)): 1032 <= 0
|
||||
run: init-channel/main 6: (((4 integer)) <- ((next-input)))
|
||||
arg: nil 0 (1)
|
||||
run: init-channel/main 6: 1 => ((4 integer))
|
||||
mem: ((4 integer)): 1005 <= 1
|
||||
run: init-channel/main 7: (((4 integer)) <- ((add)) ((4 integer)) ((1 literal)))
|
||||
mem: ((4 integer)) => 1
|
||||
run: init-channel/main 7: 2 => ((4 integer))
|
||||
mem: ((4 integer)): 1005 <= 2
|
||||
run: init-channel/main 8: (((5 tagged-value-array-address-address)) <- ((get-address)) ((1 channel-address) (deref)) ((2 offset)))
|
||||
run: init-channel/main 8: 1033 => ((5 tagged-value-array-address-address))
|
||||
mem: ((5 tagged-value-array-address-address)): 1006 <= 1033
|
||||
run: init-channel/main 9: (((5 tagged-value-array-address-address) (deref)) <- ((new)) ((tagged-value-array literal)) ((4 integer)))
|
||||
mem: ((4 integer)) => 2
|
||||
run: init-channel/main 9: 1034 => ((5 tagged-value-array-address-address) (deref))
|
||||
mem: ((5 tagged-value-array-address-address) (deref)): 1033 <= 1034
|
||||
run: init-channel/main 10: (((reply)) ((1 channel-address)))
|
||||
mem: ((1 channel-address)) => 1031
|
||||
run: main 0: 1031 => ((1 channel-address))
|
||||
mem: ((1 channel-address)): 1 <= 1031
|
||||
run: main 1: (((2 integer)) <- ((copy)) ((34 literal)))
|
||||
run: main 1: 34 => ((2 integer))
|
||||
mem: ((2 integer)): 2 <= 34
|
||||
run: main 2: (((3 tagged-value)) <- ((save-type)) ((2 integer)))
|
||||
mem: ((2 integer)) => 34
|
||||
run: main 2: #(tagged record (integer 34)) => ((3 tagged-value))
|
||||
mem: ((3 tagged-value)): 3 <= integer
|
||||
mem: ((3 tagged-value)): 4 <= 34
|
||||
run: main 3: (((1 channel-address) (deref)) <- ((write)) ((1 channel-address)) ((3 tagged-value)))
|
||||
mem: ((1 channel-address)) => 1031
|
||||
mem: ((3 tagged-value)) => #(tagged record (integer 34 . nil))
|
||||
run: write/main 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
|
||||
run: write/main 0: 1039 => ((default-space space-address))
|
||||
run: write/main 1: (((1 channel-address)) <- ((next-input)))
|
||||
arg: nil 0 (1031 #(tagged record (integer 34 . nil)))
|
||||
run: write/main 1: 1031 => ((1 channel-address))
|
||||
mem: ((1 channel-address)): 1041 <= 1031
|
||||
run: write/main 2: (((2 tagged-value)) <- ((next-input)))
|
||||
arg: nil 1 (1031 #(tagged record (integer 34 . nil)))
|
||||
run: write/main 2: #(tagged record (integer 34 . nil)) => ((2 tagged-value))
|
||||
mem: ((2 tagged-value)): 1042 <= integer
|
||||
mem: ((2 tagged-value)): 1043 <= 34
|
||||
run: write/main 3: (((4 boolean)) <- ((full?)) ((1 channel-address) (deref)))
|
||||
mem: ((1 channel-address) (deref)) => #(tagged record (0 0 1034 . nil))
|
||||
run: full?/write/main 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
|
||||
run: full?/write/main 0: 1070 => ((default-space space-address))
|
||||
run: full?/write/main 1: (((1 channel)) <- ((next-input)))
|
||||
arg: nil 0 (#(tagged record (0 0 1034 . nil)))
|
||||
run: full?/write/main 1: #(tagged record (0 0 1034 . nil)) => ((1 channel))
|
||||
mem: ((1 channel)): 1072 <= 0
|
||||
mem: ((1 channel)): 1073 <= 0
|
||||
mem: ((1 channel)): 1074 <= 1034
|
||||
run: full?/write/main 2: (((4 integer)) <- ((get)) ((1 channel)) ((1 offset)))
|
||||
mem: ((1073 integer) (raw)) => 0
|
||||
run: full?/write/main 2: 0 => ((4 integer))
|
||||
mem: ((4 integer)): 1075 <= 0
|
||||
run: full?/write/main 3: (((4 integer)) <- ((add)) ((4 integer)) ((1 literal)))
|
||||
mem: ((4 integer)) => 0
|
||||
run: full?/write/main 3: 1 => ((4 integer))
|
||||
mem: ((4 integer)): 1075 <= 1
|
||||
run: full?/write/main 4: (((5 integer)) <- ((capacity)) ((1 channel)))
|
||||
mem: ((1 channel)) => #(tagged record (0 0 1034 . nil))
|
||||
run: capacity/full?/write/main 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
|
||||
run: capacity/full?/write/main 0: 1101 => ((default-space space-address))
|
||||
run: capacity/full?/write/main 1: (((1 channel)) <- ((next-input)))
|
||||
arg: nil 0 (#(tagged record (0 0 1034 . nil)))
|
||||
run: capacity/full?/write/main 1: #(tagged record (0 0 1034 . nil)) => ((1 channel))
|
||||
mem: ((1 channel)): 1103 <= 0
|
||||
mem: ((1 channel)): 1104 <= 0
|
||||
mem: ((1 channel)): 1105 <= 1034
|
||||
run: capacity/full?/write/main 2: (((4 tagged-value-array-address)) <- ((get)) ((1 channel)) ((2 offset)))
|
||||
mem: ((1105 tagged-value-array-address) (raw)) => 1034
|
||||
run: capacity/full?/write/main 2: 1034 => ((4 tagged-value-array-address))
|
||||
mem: ((4 tagged-value-array-address)): 1106 <= 1034
|
||||
run: capacity/full?/write/main 3: (((5 integer)) <- ((length)) ((4 tagged-value-array-address) (deref)))
|
||||
array-len: ((4 tagged-value-array-address) (deref))
|
||||
mem: ((1034 integer) (raw)) => 2
|
||||
run: capacity/full?/write/main 3: 2 => ((5 integer))
|
||||
mem: ((5 integer)): 1107 <= 2
|
||||
run: capacity/full?/write/main 4: (((reply)) ((5 integer)))
|
||||
mem: ((5 integer)) => 2
|
||||
run: full?/write/main 4: 2 => ((5 integer))
|
||||
mem: ((5 integer)): 1076 <= 2
|
||||
run: full?/write/main 5: (((6 boolean)) <- ((less-than)) ((4 integer)) ((5 integer)))
|
||||
mem: ((4 integer)) => 1
|
||||
mem: ((5 integer)) => 2
|
||||
run: full?/write/main 5: t => ((6 boolean))
|
||||
mem: ((6 boolean)): 1077 <= t
|
||||
run: full?/write/main 6: (((jump-if)) ((6 boolean)) ((1 offset)))
|
||||
mem: ((6 boolean)) => t
|
||||
run: full?/write/main 8: (((7 integer)) <- ((get)) ((1 channel)) ((0 offset)))
|
||||
mem: ((1072 integer) (raw)) => 0
|
||||
run: full?/write/main 8: 0 => ((7 integer))
|
||||
mem: ((7 integer)): 1078 <= 0
|
||||
run: full?/write/main 9: (((8 boolean)) <- ((equal)) ((7 integer)) ((4 integer)))
|
||||
mem: ((7 integer)) => 0
|
||||
mem: ((4 integer)) => 1
|
||||
run: full?/write/main 9: nil => ((8 boolean))
|
||||
mem: ((8 boolean)): 1079 <= nil
|
||||
run: full?/write/main 10: (((reply)) ((8 boolean)))
|
||||
mem: ((8 boolean)) => nil
|
||||
run: write/main 3: nil => ((4 boolean))
|
||||
mem: ((4 boolean)): 1044 <= nil
|
||||
run: write/main 4: (((jump-unless)) ((4 boolean)) ((2 offset)))
|
||||
mem: ((4 boolean)) => nil
|
||||
run: write/main 7: (((6 tagged-value-array-address)) <- ((get)) ((1 channel-address) (deref)) ((2 offset)))
|
||||
mem: ((1033 tagged-value-array-address) (raw)) => 1034
|
||||
run: write/main 7: 1034 => ((6 tagged-value-array-address))
|
||||
mem: ((6 tagged-value-array-address)): 1046 <= 1034
|
||||
run: write/main 8: (((7 integer-address)) <- ((get-address)) ((1 channel-address) (deref)) ((1 offset)))
|
||||
run: write/main 8: 1032 => ((7 integer-address))
|
||||
mem: ((7 integer-address)): 1047 <= 1032
|
||||
run: write/main 9: (((8 tagged-value-address)) <- ((index-address)) ((6 tagged-value-array-address) (deref)) ((7 integer-address) (deref)))
|
||||
mem: ((7 integer-address) (deref)) => 0
|
||||
array-len: ((1034 tagged-value-array) (raw))
|
||||
mem: ((1034 integer) (raw)) => 2
|
||||
run: write/main 9: 1035 => ((8 tagged-value-address))
|
||||
mem: ((8 tagged-value-address)): 1048 <= 1035
|
||||
run: write/main 10: (((8 tagged-value-address) (deref)) <- ((copy)) ((2 tagged-value)))
|
||||
mem: ((2 tagged-value)) => #(tagged record (integer 34 . nil))
|
||||
run: write/main 10: #(tagged record (integer 34 . nil)) => ((8 tagged-value-address) (deref))
|
||||
mem: ((8 tagged-value-address) (deref)): 1035 <= integer
|
||||
mem: ((8 tagged-value-address) (deref)): 1036 <= 34
|
||||
run: write/main 11: (((7 integer-address) (deref)) <- ((add)) ((7 integer-address) (deref)) ((1 literal)))
|
||||
mem: ((7 integer-address) (deref)) => 0
|
||||
run: write/main 11: 1 => ((7 integer-address) (deref))
|
||||
mem: ((7 integer-address) (deref)): 1032 <= 1
|
||||
run: write/main 12: (((9 integer)) <- ((length)) ((6 tagged-value-array-address) (deref)))
|
||||
array-len: ((6 tagged-value-array-address) (deref))
|
||||
mem: ((1034 integer) (raw)) => 2
|
||||
run: write/main 12: 2 => ((9 integer))
|
||||
mem: ((9 integer)): 1049 <= 2
|
||||
run: write/main 13: (((10 boolean)) <- ((less-than)) ((7 integer-address) (deref)) ((9 integer)))
|
||||
mem: ((7 integer-address) (deref)) => 1
|
||||
mem: ((9 integer)) => 2
|
||||
run: write/main 13: t => ((10 boolean))
|
||||
mem: ((10 boolean)): 1050 <= t
|
||||
run: write/main 14: (((jump-if)) ((10 boolean)) ((1 offset)))
|
||||
mem: ((10 boolean)) => t
|
||||
run: write/main 16: (((reply)) ((1 channel-address) (deref) (same-as-arg 0)))
|
||||
mem: ((1 channel-address) (deref) (same-as-arg 0)) => #(tagged record (0 1 1034 . nil))
|
||||
run: main 3: #(tagged record (0 1 1034 . nil)) => ((1 channel-address) (deref))
|
||||
mem: ((1 channel-address) (deref)): 1031 <= 0
|
||||
mem: ((1 channel-address) (deref)): 1032 <= 1
|
||||
mem: ((1 channel-address) (deref)): 1033 <= 1034
|
||||
run: main 4: (((1 channel-address) (deref)) <- ((write)) ((1 channel-address)) ((3 tagged-value)))
|
||||
mem: ((1 channel-address)) => 1031
|
||||
mem: ((3 tagged-value)) => #(tagged record (integer 34 . nil))
|
||||
run: write/main 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
|
||||
run: write/main 0: 1132 => ((default-space space-address))
|
||||
run: write/main 1: (((1 channel-address)) <- ((next-input)))
|
||||
arg: nil 0 (1031 #(tagged record (integer 34 . nil)))
|
||||
run: write/main 1: 1031 => ((1 channel-address))
|
||||
mem: ((1 channel-address)): 1134 <= 1031
|
||||
run: write/main 2: (((2 tagged-value)) <- ((next-input)))
|
||||
arg: nil 1 (1031 #(tagged record (integer 34 . nil)))
|
||||
run: write/main 2: #(tagged record (integer 34 . nil)) => ((2 tagged-value))
|
||||
mem: ((2 tagged-value)): 1135 <= integer
|
||||
mem: ((2 tagged-value)): 1136 <= 34
|
||||
run: write/main 3: (((4 boolean)) <- ((full?)) ((1 channel-address) (deref)))
|
||||
mem: ((1 channel-address) (deref)) => #(tagged record (0 1 1034 . nil))
|
||||
run: full?/write/main 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
|
||||
run: full?/write/main 0: 1163 => ((default-space space-address))
|
||||
run: full?/write/main 1: (((1 channel)) <- ((next-input)))
|
||||
arg: nil 0 (#(tagged record (0 1 1034 . nil)))
|
||||
run: full?/write/main 1: #(tagged record (0 1 1034 . nil)) => ((1 channel))
|
||||
mem: ((1 channel)): 1165 <= 0
|
||||
mem: ((1 channel)): 1166 <= 1
|
||||
mem: ((1 channel)): 1167 <= 1034
|
||||
run: full?/write/main 2: (((4 integer)) <- ((get)) ((1 channel)) ((1 offset)))
|
||||
mem: ((1166 integer) (raw)) => 1
|
||||
run: full?/write/main 2: 1 => ((4 integer))
|
||||
mem: ((4 integer)): 1168 <= 1
|
||||
run: full?/write/main 3: (((4 integer)) <- ((add)) ((4 integer)) ((1 literal)))
|
||||
mem: ((4 integer)) => 1
|
||||
run: full?/write/main 3: 2 => ((4 integer))
|
||||
mem: ((4 integer)): 1168 <= 2
|
||||
run: full?/write/main 4: (((5 integer)) <- ((capacity)) ((1 channel)))
|
||||
mem: ((1 channel)) => #(tagged record (0 1 1034 . nil))
|
||||
run: capacity/full?/write/main 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
|
||||
run: capacity/full?/write/main 0: 1194 => ((default-space space-address))
|
||||
run: capacity/full?/write/main 1: (((1 channel)) <- ((next-input)))
|
||||
arg: nil 0 (#(tagged record (0 1 1034 . nil)))
|
||||
run: capacity/full?/write/main 1: #(tagged record (0 1 1034 . nil)) => ((1 channel))
|
||||
mem: ((1 channel)): 1196 <= 0
|
||||
mem: ((1 channel)): 1197 <= 1
|
||||
mem: ((1 channel)): 1198 <= 1034
|
||||
run: capacity/full?/write/main 2: (((4 tagged-value-array-address)) <- ((get)) ((1 channel)) ((2 offset)))
|
||||
mem: ((1198 tagged-value-array-address) (raw)) => 1034
|
||||
run: capacity/full?/write/main 2: 1034 => ((4 tagged-value-array-address))
|
||||
mem: ((4 tagged-value-array-address)): 1199 <= 1034
|
||||
run: capacity/full?/write/main 3: (((5 integer)) <- ((length)) ((4 tagged-value-array-address) (deref)))
|
||||
array-len: ((4 tagged-value-array-address) (deref))
|
||||
mem: ((1034 integer) (raw)) => 2
|
||||
run: capacity/full?/write/main 3: 2 => ((5 integer))
|
||||
mem: ((5 integer)): 1200 <= 2
|
||||
run: capacity/full?/write/main 4: (((reply)) ((5 integer)))
|
||||
mem: ((5 integer)) => 2
|
||||
run: full?/write/main 4: 2 => ((5 integer))
|
||||
mem: ((5 integer)): 1169 <= 2
|
||||
run: full?/write/main 5: (((6 boolean)) <- ((less-than)) ((4 integer)) ((5 integer)))
|
||||
mem: ((4 integer)) => 2
|
||||
mem: ((5 integer)) => 2
|
||||
run: full?/write/main 5: nil => ((6 boolean))
|
||||
mem: ((6 boolean)): 1170 <= nil
|
||||
run: full?/write/main 6: (((jump-if)) ((6 boolean)) ((1 offset)))
|
||||
mem: ((6 boolean)) => nil
|
||||
run: full?/write/main 7: (((4 integer)) <- ((copy)) ((0 literal)))
|
||||
run: full?/write/main 7: 0 => ((4 integer))
|
||||
mem: ((4 integer)): 1168 <= 0
|
||||
run: full?/write/main 8: (((7 integer)) <- ((get)) ((1 channel)) ((0 offset)))
|
||||
mem: ((1165 integer) (raw)) => 0
|
||||
run: full?/write/main 8: 0 => ((7 integer))
|
||||
mem: ((7 integer)): 1171 <= 0
|
||||
run: full?/write/main 9: (((8 boolean)) <- ((equal)) ((7 integer)) ((4 integer)))
|
||||
mem: ((7 integer)) => 0
|
||||
mem: ((4 integer)) => 0
|
||||
run: full?/write/main 9: t => ((8 boolean))
|
||||
mem: ((8 boolean)): 1172 <= t
|
||||
run: full?/write/main 10: (((reply)) ((8 boolean)))
|
||||
mem: ((8 boolean)) => t
|
||||
run: write/main 3: t => ((4 boolean))
|
||||
mem: ((4 boolean)): 1137 <= t
|
||||
run: write/main 4: (((jump-unless)) ((4 boolean)) ((2 offset)))
|
||||
mem: ((4 boolean)) => t
|
||||
run: write/main 5: (((5 integer-address)) <- ((get-address)) ((1 channel-address) (deref)) ((0 offset)))
|
||||
run: write/main 5: 1031 => ((5 integer-address))
|
||||
mem: ((5 integer-address)): 1138 <= 1031
|
||||
run: write/main 6: (((sleep)) ((until-location-changes literal)) ((5 integer-address) (deref)))
|
||||
mem: ((5 integer-address) (deref)) => 0
|
||||
schedule: pushing write/main to sleep queue
|
||||
|
|
@ -0,0 +1,304 @@
|
|||
c{0: 0 (((1 channel-address)) <- ((init-channel)) ((1 literal))) -- nil
|
||||
c{0: 1 (((2 integer)) <- ((copy)) ((34 literal))) -- nil
|
||||
c{0: 2 (((3 tagged-value)) <- ((save-type)) ((2 integer))) -- nil
|
||||
c{0: 3 (((1 channel-address) (deref)) <- ((write)) ((1 channel-address)) ((3 tagged-value))) -- nil
|
||||
c{0: 4 (((5 boolean)) <- ((empty?)) ((1 channel-address) (deref))) -- nil
|
||||
c{0: 5 (((6 boolean)) <- ((full?)) ((1 channel-address) (deref))) -- nil
|
||||
c{1: 0 ✓ (((1 channel-address)) <- ((init-channel)) ((1 literal)))
|
||||
c{1: 1 ✓ (((2 integer)) <- ((copy)) ((34 literal)))
|
||||
c{1: 2 ✓ (((3 tagged-value)) <- ((save-type)) ((2 integer)))
|
||||
c{1: 3 ✓ (((1 channel-address) (deref)) <- ((write)) ((1 channel-address)) ((3 tagged-value)))
|
||||
c{1: 4 ✓ (((5 boolean)) <- ((empty?)) ((1 channel-address) (deref)))
|
||||
c{1: 5 ✓ (((6 boolean)) <- ((full?)) ((1 channel-address) (deref)))
|
||||
cn0: convert-names in main
|
||||
cn0: (((1 channel-address)) <- ((init-channel)) ((1 literal))) nil nil
|
||||
cn0: checking arg ((1 literal))
|
||||
cn0: checking oarg ((1 channel-address))
|
||||
maybe-add: ((1 channel-address))
|
||||
cn0: (((2 integer)) <- ((copy)) ((34 literal))) nil nil
|
||||
cn0: checking arg ((34 literal))
|
||||
cn0: checking oarg ((2 integer))
|
||||
maybe-add: ((2 integer))
|
||||
cn0: (((3 tagged-value)) <- ((save-type)) ((2 integer))) nil nil
|
||||
cn0: checking arg ((2 integer))
|
||||
maybe-add: ((2 integer))
|
||||
cn0: checking oarg ((3 tagged-value))
|
||||
maybe-add: ((3 tagged-value))
|
||||
cn0: (((1 channel-address) (deref)) <- ((write)) ((1 channel-address)) ((3 tagged-value))) nil nil
|
||||
cn0: checking arg ((1 channel-address))
|
||||
maybe-add: ((1 channel-address))
|
||||
cn0: checking arg ((3 tagged-value))
|
||||
maybe-add: ((3 tagged-value))
|
||||
cn0: checking oarg ((1 channel-address) (deref))
|
||||
maybe-add: ((1 channel-address) (deref))
|
||||
cn0: (((5 boolean)) <- ((empty?)) ((1 channel-address) (deref))) nil nil
|
||||
cn0: checking arg ((1 channel-address) (deref))
|
||||
maybe-add: ((1 channel-address) (deref))
|
||||
cn0: checking oarg ((5 boolean))
|
||||
maybe-add: ((5 boolean))
|
||||
cn0: (((6 boolean)) <- ((full?)) ((1 channel-address) (deref))) nil nil
|
||||
cn0: checking arg ((1 channel-address) (deref))
|
||||
maybe-add: ((1 channel-address) (deref))
|
||||
cn0: checking oarg ((6 boolean))
|
||||
maybe-add: ((6 boolean))
|
||||
cn1: (((1 channel-address)) <- ((init-channel)) ((1 literal)))
|
||||
cn1: (((2 integer)) <- ((copy)) ((34 literal)))
|
||||
cn1: (((3 tagged-value)) <- ((save-type)) ((2 integer)))
|
||||
cn1: (((1 channel-address) (deref)) <- ((write)) ((1 channel-address)) ((3 tagged-value)))
|
||||
cn1: (((5 boolean)) <- ((empty?)) ((1 channel-address) (deref)))
|
||||
cn1: (((6 boolean)) <- ((full?)) ((1 channel-address) (deref)))
|
||||
schedule: main
|
||||
run: main 0: (((1 channel-address)) <- ((init-channel)) ((1 literal)))
|
||||
run: init-channel/main 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
|
||||
run: init-channel/main 0: 1000 => ((default-space space-address))
|
||||
run: init-channel/main 1: (((1 channel-address)) <- ((new)) ((channel literal)))
|
||||
run: init-channel/main 1: 1031 => ((1 channel-address))
|
||||
mem: ((1 channel-address)): 1002 <= 1031
|
||||
run: init-channel/main 2: (((2 integer-address)) <- ((get-address)) ((1 channel-address) (deref)) ((0 offset)))
|
||||
run: init-channel/main 2: 1031 => ((2 integer-address))
|
||||
mem: ((2 integer-address)): 1003 <= 1031
|
||||
run: init-channel/main 3: (((2 integer-address) (deref)) <- ((copy)) ((0 literal)))
|
||||
run: init-channel/main 3: 0 => ((2 integer-address) (deref))
|
||||
mem: ((2 integer-address) (deref)): 1031 <= 0
|
||||
run: init-channel/main 4: (((3 integer-address)) <- ((get-address)) ((1 channel-address) (deref)) ((1 offset)))
|
||||
run: init-channel/main 4: 1032 => ((3 integer-address))
|
||||
mem: ((3 integer-address)): 1004 <= 1032
|
||||
run: init-channel/main 5: (((3 integer-address) (deref)) <- ((copy)) ((0 literal)))
|
||||
run: init-channel/main 5: 0 => ((3 integer-address) (deref))
|
||||
mem: ((3 integer-address) (deref)): 1032 <= 0
|
||||
run: init-channel/main 6: (((4 integer)) <- ((next-input)))
|
||||
arg: nil 0 (1)
|
||||
run: init-channel/main 6: 1 => ((4 integer))
|
||||
mem: ((4 integer)): 1005 <= 1
|
||||
run: init-channel/main 7: (((4 integer)) <- ((add)) ((4 integer)) ((1 literal)))
|
||||
mem: ((4 integer)) => 1
|
||||
run: init-channel/main 7: 2 => ((4 integer))
|
||||
mem: ((4 integer)): 1005 <= 2
|
||||
run: init-channel/main 8: (((5 tagged-value-array-address-address)) <- ((get-address)) ((1 channel-address) (deref)) ((2 offset)))
|
||||
run: init-channel/main 8: 1033 => ((5 tagged-value-array-address-address))
|
||||
mem: ((5 tagged-value-array-address-address)): 1006 <= 1033
|
||||
run: init-channel/main 9: (((5 tagged-value-array-address-address) (deref)) <- ((new)) ((tagged-value-array literal)) ((4 integer)))
|
||||
mem: ((4 integer)) => 2
|
||||
run: init-channel/main 9: 1034 => ((5 tagged-value-array-address-address) (deref))
|
||||
mem: ((5 tagged-value-array-address-address) (deref)): 1033 <= 1034
|
||||
run: init-channel/main 10: (((reply)) ((1 channel-address)))
|
||||
mem: ((1 channel-address)) => 1031
|
||||
run: main 0: 1031 => ((1 channel-address))
|
||||
mem: ((1 channel-address)): 1 <= 1031
|
||||
run: main 1: (((2 integer)) <- ((copy)) ((34 literal)))
|
||||
run: main 1: 34 => ((2 integer))
|
||||
mem: ((2 integer)): 2 <= 34
|
||||
run: main 2: (((3 tagged-value)) <- ((save-type)) ((2 integer)))
|
||||
mem: ((2 integer)) => 34
|
||||
run: main 2: #(tagged record (integer 34)) => ((3 tagged-value))
|
||||
mem: ((3 tagged-value)): 3 <= integer
|
||||
mem: ((3 tagged-value)): 4 <= 34
|
||||
run: main 3: (((1 channel-address) (deref)) <- ((write)) ((1 channel-address)) ((3 tagged-value)))
|
||||
mem: ((1 channel-address)) => 1031
|
||||
mem: ((3 tagged-value)) => #(tagged record (integer 34 . nil))
|
||||
run: write/main 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
|
||||
run: write/main 0: 1039 => ((default-space space-address))
|
||||
run: write/main 1: (((1 channel-address)) <- ((next-input)))
|
||||
arg: nil 0 (1031 #(tagged record (integer 34 . nil)))
|
||||
run: write/main 1: 1031 => ((1 channel-address))
|
||||
mem: ((1 channel-address)): 1041 <= 1031
|
||||
run: write/main 2: (((2 tagged-value)) <- ((next-input)))
|
||||
arg: nil 1 (1031 #(tagged record (integer 34 . nil)))
|
||||
run: write/main 2: #(tagged record (integer 34 . nil)) => ((2 tagged-value))
|
||||
mem: ((2 tagged-value)): 1042 <= integer
|
||||
mem: ((2 tagged-value)): 1043 <= 34
|
||||
run: write/main 3: (((4 boolean)) <- ((full?)) ((1 channel-address) (deref)))
|
||||
mem: ((1 channel-address) (deref)) => #(tagged record (0 0 1034 . nil))
|
||||
run: full?/write/main 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
|
||||
run: full?/write/main 0: 1070 => ((default-space space-address))
|
||||
run: full?/write/main 1: (((1 channel)) <- ((next-input)))
|
||||
arg: nil 0 (#(tagged record (0 0 1034 . nil)))
|
||||
run: full?/write/main 1: #(tagged record (0 0 1034 . nil)) => ((1 channel))
|
||||
mem: ((1 channel)): 1072 <= 0
|
||||
mem: ((1 channel)): 1073 <= 0
|
||||
mem: ((1 channel)): 1074 <= 1034
|
||||
run: full?/write/main 2: (((4 integer)) <- ((get)) ((1 channel)) ((1 offset)))
|
||||
mem: ((1073 integer) (raw)) => 0
|
||||
run: full?/write/main 2: 0 => ((4 integer))
|
||||
mem: ((4 integer)): 1075 <= 0
|
||||
run: full?/write/main 3: (((4 integer)) <- ((add)) ((4 integer)) ((1 literal)))
|
||||
mem: ((4 integer)) => 0
|
||||
run: full?/write/main 3: 1 => ((4 integer))
|
||||
mem: ((4 integer)): 1075 <= 1
|
||||
run: full?/write/main 4: (((5 integer)) <- ((capacity)) ((1 channel)))
|
||||
mem: ((1 channel)) => #(tagged record (0 0 1034 . nil))
|
||||
run: capacity/full?/write/main 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
|
||||
run: capacity/full?/write/main 0: 1101 => ((default-space space-address))
|
||||
run: capacity/full?/write/main 1: (((1 channel)) <- ((next-input)))
|
||||
arg: nil 0 (#(tagged record (0 0 1034 . nil)))
|
||||
run: capacity/full?/write/main 1: #(tagged record (0 0 1034 . nil)) => ((1 channel))
|
||||
mem: ((1 channel)): 1103 <= 0
|
||||
mem: ((1 channel)): 1104 <= 0
|
||||
mem: ((1 channel)): 1105 <= 1034
|
||||
run: capacity/full?/write/main 2: (((4 tagged-value-array-address)) <- ((get)) ((1 channel)) ((2 offset)))
|
||||
mem: ((1105 tagged-value-array-address) (raw)) => 1034
|
||||
run: capacity/full?/write/main 2: 1034 => ((4 tagged-value-array-address))
|
||||
mem: ((4 tagged-value-array-address)): 1106 <= 1034
|
||||
run: capacity/full?/write/main 3: (((5 integer)) <- ((length)) ((4 tagged-value-array-address) (deref)))
|
||||
array-len: ((4 tagged-value-array-address) (deref))
|
||||
mem: ((1034 integer) (raw)) => 2
|
||||
run: capacity/full?/write/main 3: 2 => ((5 integer))
|
||||
mem: ((5 integer)): 1107 <= 2
|
||||
run: capacity/full?/write/main 4: (((reply)) ((5 integer)))
|
||||
mem: ((5 integer)) => 2
|
||||
run: full?/write/main 4: 2 => ((5 integer))
|
||||
mem: ((5 integer)): 1076 <= 2
|
||||
run: full?/write/main 5: (((6 boolean)) <- ((less-than)) ((4 integer)) ((5 integer)))
|
||||
mem: ((4 integer)) => 1
|
||||
mem: ((5 integer)) => 2
|
||||
run: full?/write/main 5: t => ((6 boolean))
|
||||
mem: ((6 boolean)): 1077 <= t
|
||||
run: full?/write/main 6: (((jump-if)) ((6 boolean)) ((1 offset)))
|
||||
mem: ((6 boolean)) => t
|
||||
run: full?/write/main 8: (((7 integer)) <- ((get)) ((1 channel)) ((0 offset)))
|
||||
mem: ((1072 integer) (raw)) => 0
|
||||
run: full?/write/main 8: 0 => ((7 integer))
|
||||
mem: ((7 integer)): 1078 <= 0
|
||||
run: full?/write/main 9: (((8 boolean)) <- ((equal)) ((7 integer)) ((4 integer)))
|
||||
mem: ((7 integer)) => 0
|
||||
mem: ((4 integer)) => 1
|
||||
run: full?/write/main 9: nil => ((8 boolean))
|
||||
mem: ((8 boolean)): 1079 <= nil
|
||||
run: full?/write/main 10: (((reply)) ((8 boolean)))
|
||||
mem: ((8 boolean)) => nil
|
||||
run: write/main 3: nil => ((4 boolean))
|
||||
mem: ((4 boolean)): 1044 <= nil
|
||||
run: write/main 4: (((jump-unless)) ((4 boolean)) ((2 offset)))
|
||||
mem: ((4 boolean)) => nil
|
||||
run: write/main 7: (((6 tagged-value-array-address)) <- ((get)) ((1 channel-address) (deref)) ((2 offset)))
|
||||
mem: ((1033 tagged-value-array-address) (raw)) => 1034
|
||||
run: write/main 7: 1034 => ((6 tagged-value-array-address))
|
||||
mem: ((6 tagged-value-array-address)): 1046 <= 1034
|
||||
run: write/main 8: (((7 integer-address)) <- ((get-address)) ((1 channel-address) (deref)) ((1 offset)))
|
||||
run: write/main 8: 1032 => ((7 integer-address))
|
||||
mem: ((7 integer-address)): 1047 <= 1032
|
||||
run: write/main 9: (((8 tagged-value-address)) <- ((index-address)) ((6 tagged-value-array-address) (deref)) ((7 integer-address) (deref)))
|
||||
mem: ((7 integer-address) (deref)) => 0
|
||||
array-len: ((1034 tagged-value-array) (raw))
|
||||
mem: ((1034 integer) (raw)) => 2
|
||||
run: write/main 9: 1035 => ((8 tagged-value-address))
|
||||
mem: ((8 tagged-value-address)): 1048 <= 1035
|
||||
run: write/main 10: (((8 tagged-value-address) (deref)) <- ((copy)) ((2 tagged-value)))
|
||||
mem: ((2 tagged-value)) => #(tagged record (integer 34 . nil))
|
||||
run: write/main 10: #(tagged record (integer 34 . nil)) => ((8 tagged-value-address) (deref))
|
||||
mem: ((8 tagged-value-address) (deref)): 1035 <= integer
|
||||
mem: ((8 tagged-value-address) (deref)): 1036 <= 34
|
||||
run: write/main 11: (((7 integer-address) (deref)) <- ((add)) ((7 integer-address) (deref)) ((1 literal)))
|
||||
mem: ((7 integer-address) (deref)) => 0
|
||||
run: write/main 11: 1 => ((7 integer-address) (deref))
|
||||
mem: ((7 integer-address) (deref)): 1032 <= 1
|
||||
run: write/main 12: (((9 integer)) <- ((length)) ((6 tagged-value-array-address) (deref)))
|
||||
array-len: ((6 tagged-value-array-address) (deref))
|
||||
mem: ((1034 integer) (raw)) => 2
|
||||
run: write/main 12: 2 => ((9 integer))
|
||||
mem: ((9 integer)): 1049 <= 2
|
||||
run: write/main 13: (((10 boolean)) <- ((less-than)) ((7 integer-address) (deref)) ((9 integer)))
|
||||
mem: ((7 integer-address) (deref)) => 1
|
||||
mem: ((9 integer)) => 2
|
||||
run: write/main 13: t => ((10 boolean))
|
||||
mem: ((10 boolean)): 1050 <= t
|
||||
run: write/main 14: (((jump-if)) ((10 boolean)) ((1 offset)))
|
||||
mem: ((10 boolean)) => t
|
||||
run: write/main 16: (((reply)) ((1 channel-address) (deref) (same-as-arg 0)))
|
||||
mem: ((1 channel-address) (deref) (same-as-arg 0)) => #(tagged record (0 1 1034 . nil))
|
||||
run: main 3: #(tagged record (0 1 1034 . nil)) => ((1 channel-address) (deref))
|
||||
mem: ((1 channel-address) (deref)): 1031 <= 0
|
||||
mem: ((1 channel-address) (deref)): 1032 <= 1
|
||||
mem: ((1 channel-address) (deref)): 1033 <= 1034
|
||||
run: main 4: (((5 boolean)) <- ((empty?)) ((1 channel-address) (deref)))
|
||||
mem: ((1 channel-address) (deref)) => #(tagged record (0 1 1034 . nil))
|
||||
run: empty?/main 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
|
||||
run: empty?/main 0: 1132 => ((default-space space-address))
|
||||
run: empty?/main 1: (((1 channel)) <- ((next-input)))
|
||||
arg: nil 0 (#(tagged record (0 1 1034 . nil)))
|
||||
run: empty?/main 1: #(tagged record (0 1 1034 . nil)) => ((1 channel))
|
||||
mem: ((1 channel)): 1134 <= 0
|
||||
mem: ((1 channel)): 1135 <= 1
|
||||
mem: ((1 channel)): 1136 <= 1034
|
||||
run: empty?/main 2: (((4 integer)) <- ((get)) ((1 channel)) ((0 offset)))
|
||||
mem: ((1134 integer) (raw)) => 0
|
||||
run: empty?/main 2: 0 => ((4 integer))
|
||||
mem: ((4 integer)): 1137 <= 0
|
||||
run: empty?/main 3: (((5 integer)) <- ((get)) ((1 channel)) ((1 offset)))
|
||||
mem: ((1135 integer) (raw)) => 1
|
||||
run: empty?/main 3: 1 => ((5 integer))
|
||||
mem: ((5 integer)): 1138 <= 1
|
||||
run: empty?/main 4: (((6 boolean)) <- ((equal)) ((4 integer)) ((5 integer)))
|
||||
mem: ((4 integer)) => 0
|
||||
mem: ((5 integer)) => 1
|
||||
run: empty?/main 4: nil => ((6 boolean))
|
||||
mem: ((6 boolean)): 1139 <= nil
|
||||
run: empty?/main 5: (((reply)) ((6 boolean)))
|
||||
mem: ((6 boolean)) => nil
|
||||
run: main 4: nil => ((5 boolean))
|
||||
mem: ((5 boolean)): 5 <= nil
|
||||
run: main 5: (((6 boolean)) <- ((full?)) ((1 channel-address) (deref)))
|
||||
mem: ((1 channel-address) (deref)) => #(tagged record (0 1 1034 . nil))
|
||||
run: full?/main 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
|
||||
run: full?/main 0: 1163 => ((default-space space-address))
|
||||
run: full?/main 1: (((1 channel)) <- ((next-input)))
|
||||
arg: nil 0 (#(tagged record (0 1 1034 . nil)))
|
||||
run: full?/main 1: #(tagged record (0 1 1034 . nil)) => ((1 channel))
|
||||
mem: ((1 channel)): 1165 <= 0
|
||||
mem: ((1 channel)): 1166 <= 1
|
||||
mem: ((1 channel)): 1167 <= 1034
|
||||
run: full?/main 2: (((4 integer)) <- ((get)) ((1 channel)) ((1 offset)))
|
||||
mem: ((1166 integer) (raw)) => 1
|
||||
run: full?/main 2: 1 => ((4 integer))
|
||||
mem: ((4 integer)): 1168 <= 1
|
||||
run: full?/main 3: (((4 integer)) <- ((add)) ((4 integer)) ((1 literal)))
|
||||
mem: ((4 integer)) => 1
|
||||
run: full?/main 3: 2 => ((4 integer))
|
||||
mem: ((4 integer)): 1168 <= 2
|
||||
run: full?/main 4: (((5 integer)) <- ((capacity)) ((1 channel)))
|
||||
mem: ((1 channel)) => #(tagged record (0 1 1034 . nil))
|
||||
run: capacity/full?/main 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
|
||||
run: capacity/full?/main 0: 1194 => ((default-space space-address))
|
||||
run: capacity/full?/main 1: (((1 channel)) <- ((next-input)))
|
||||
arg: nil 0 (#(tagged record (0 1 1034 . nil)))
|
||||
run: capacity/full?/main 1: #(tagged record (0 1 1034 . nil)) => ((1 channel))
|
||||
mem: ((1 channel)): 1196 <= 0
|
||||
mem: ((1 channel)): 1197 <= 1
|
||||
mem: ((1 channel)): 1198 <= 1034
|
||||
run: capacity/full?/main 2: (((4 tagged-value-array-address)) <- ((get)) ((1 channel)) ((2 offset)))
|
||||
mem: ((1198 tagged-value-array-address) (raw)) => 1034
|
||||
run: capacity/full?/main 2: 1034 => ((4 tagged-value-array-address))
|
||||
mem: ((4 tagged-value-array-address)): 1199 <= 1034
|
||||
run: capacity/full?/main 3: (((5 integer)) <- ((length)) ((4 tagged-value-array-address) (deref)))
|
||||
array-len: ((4 tagged-value-array-address) (deref))
|
||||
mem: ((1034 integer) (raw)) => 2
|
||||
run: capacity/full?/main 3: 2 => ((5 integer))
|
||||
mem: ((5 integer)): 1200 <= 2
|
||||
run: capacity/full?/main 4: (((reply)) ((5 integer)))
|
||||
mem: ((5 integer)) => 2
|
||||
run: full?/main 4: 2 => ((5 integer))
|
||||
mem: ((5 integer)): 1169 <= 2
|
||||
run: full?/main 5: (((6 boolean)) <- ((less-than)) ((4 integer)) ((5 integer)))
|
||||
mem: ((4 integer)) => 2
|
||||
mem: ((5 integer)) => 2
|
||||
run: full?/main 5: nil => ((6 boolean))
|
||||
mem: ((6 boolean)): 1170 <= nil
|
||||
run: full?/main 6: (((jump-if)) ((6 boolean)) ((1 offset)))
|
||||
mem: ((6 boolean)) => nil
|
||||
run: full?/main 7: (((4 integer)) <- ((copy)) ((0 literal)))
|
||||
run: full?/main 7: 0 => ((4 integer))
|
||||
mem: ((4 integer)): 1168 <= 0
|
||||
run: full?/main 8: (((7 integer)) <- ((get)) ((1 channel)) ((0 offset)))
|
||||
mem: ((1165 integer) (raw)) => 0
|
||||
run: full?/main 8: 0 => ((7 integer))
|
||||
mem: ((7 integer)): 1171 <= 0
|
||||
run: full?/main 9: (((8 boolean)) <- ((equal)) ((7 integer)) ((4 integer)))
|
||||
mem: ((7 integer)) => 0
|
||||
mem: ((4 integer)) => 0
|
||||
run: full?/main 9: t => ((8 boolean))
|
||||
mem: ((8 boolean)): 1172 <= t
|
||||
run: full?/main 10: (((reply)) ((8 boolean)))
|
||||
mem: ((8 boolean)) => t
|
||||
run: main 5: t => ((6 boolean))
|
||||
mem: ((6 boolean)): 6 <= t
|
||||
schedule: done with routine nil
|
||||
|
|
@ -0,0 +1,301 @@
|
|||
c{0: 0 (((1 channel-address)) <- ((init-channel)) ((3 literal))) -- nil
|
||||
c{0: 1 (((2 integer)) <- ((copy)) ((34 literal))) -- nil
|
||||
c{0: 2 (((3 tagged-value)) <- ((save-type)) ((2 integer))) -- nil
|
||||
c{0: 3 (((1 channel-address) (deref)) <- ((write)) ((1 channel-address)) ((3 tagged-value))) -- nil
|
||||
c{0: 4 (((5 boolean)) <- ((empty?)) ((1 channel-address) (deref))) -- nil
|
||||
c{0: 5 (((6 boolean)) <- ((full?)) ((1 channel-address) (deref))) -- nil
|
||||
c{1: 0 ✓ (((1 channel-address)) <- ((init-channel)) ((3 literal)))
|
||||
c{1: 1 ✓ (((2 integer)) <- ((copy)) ((34 literal)))
|
||||
c{1: 2 ✓ (((3 tagged-value)) <- ((save-type)) ((2 integer)))
|
||||
c{1: 3 ✓ (((1 channel-address) (deref)) <- ((write)) ((1 channel-address)) ((3 tagged-value)))
|
||||
c{1: 4 ✓ (((5 boolean)) <- ((empty?)) ((1 channel-address) (deref)))
|
||||
c{1: 5 ✓ (((6 boolean)) <- ((full?)) ((1 channel-address) (deref)))
|
||||
cn0: convert-names in main
|
||||
cn0: (((1 channel-address)) <- ((init-channel)) ((3 literal))) nil nil
|
||||
cn0: checking arg ((3 literal))
|
||||
cn0: checking oarg ((1 channel-address))
|
||||
maybe-add: ((1 channel-address))
|
||||
cn0: (((2 integer)) <- ((copy)) ((34 literal))) nil nil
|
||||
cn0: checking arg ((34 literal))
|
||||
cn0: checking oarg ((2 integer))
|
||||
maybe-add: ((2 integer))
|
||||
cn0: (((3 tagged-value)) <- ((save-type)) ((2 integer))) nil nil
|
||||
cn0: checking arg ((2 integer))
|
||||
maybe-add: ((2 integer))
|
||||
cn0: checking oarg ((3 tagged-value))
|
||||
maybe-add: ((3 tagged-value))
|
||||
cn0: (((1 channel-address) (deref)) <- ((write)) ((1 channel-address)) ((3 tagged-value))) nil nil
|
||||
cn0: checking arg ((1 channel-address))
|
||||
maybe-add: ((1 channel-address))
|
||||
cn0: checking arg ((3 tagged-value))
|
||||
maybe-add: ((3 tagged-value))
|
||||
cn0: checking oarg ((1 channel-address) (deref))
|
||||
maybe-add: ((1 channel-address) (deref))
|
||||
cn0: (((5 boolean)) <- ((empty?)) ((1 channel-address) (deref))) nil nil
|
||||
cn0: checking arg ((1 channel-address) (deref))
|
||||
maybe-add: ((1 channel-address) (deref))
|
||||
cn0: checking oarg ((5 boolean))
|
||||
maybe-add: ((5 boolean))
|
||||
cn0: (((6 boolean)) <- ((full?)) ((1 channel-address) (deref))) nil nil
|
||||
cn0: checking arg ((1 channel-address) (deref))
|
||||
maybe-add: ((1 channel-address) (deref))
|
||||
cn0: checking oarg ((6 boolean))
|
||||
maybe-add: ((6 boolean))
|
||||
cn1: (((1 channel-address)) <- ((init-channel)) ((3 literal)))
|
||||
cn1: (((2 integer)) <- ((copy)) ((34 literal)))
|
||||
cn1: (((3 tagged-value)) <- ((save-type)) ((2 integer)))
|
||||
cn1: (((1 channel-address) (deref)) <- ((write)) ((1 channel-address)) ((3 tagged-value)))
|
||||
cn1: (((5 boolean)) <- ((empty?)) ((1 channel-address) (deref)))
|
||||
cn1: (((6 boolean)) <- ((full?)) ((1 channel-address) (deref)))
|
||||
schedule: main
|
||||
run: main 0: (((1 channel-address)) <- ((init-channel)) ((3 literal)))
|
||||
run: init-channel/main 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
|
||||
run: init-channel/main 0: 1000 => ((default-space space-address))
|
||||
run: init-channel/main 1: (((1 channel-address)) <- ((new)) ((channel literal)))
|
||||
run: init-channel/main 1: 1031 => ((1 channel-address))
|
||||
mem: ((1 channel-address)): 1002 <= 1031
|
||||
run: init-channel/main 2: (((2 integer-address)) <- ((get-address)) ((1 channel-address) (deref)) ((0 offset)))
|
||||
run: init-channel/main 2: 1031 => ((2 integer-address))
|
||||
mem: ((2 integer-address)): 1003 <= 1031
|
||||
run: init-channel/main 3: (((2 integer-address) (deref)) <- ((copy)) ((0 literal)))
|
||||
run: init-channel/main 3: 0 => ((2 integer-address) (deref))
|
||||
mem: ((2 integer-address) (deref)): 1031 <= 0
|
||||
run: init-channel/main 4: (((3 integer-address)) <- ((get-address)) ((1 channel-address) (deref)) ((1 offset)))
|
||||
run: init-channel/main 4: 1032 => ((3 integer-address))
|
||||
mem: ((3 integer-address)): 1004 <= 1032
|
||||
run: init-channel/main 5: (((3 integer-address) (deref)) <- ((copy)) ((0 literal)))
|
||||
run: init-channel/main 5: 0 => ((3 integer-address) (deref))
|
||||
mem: ((3 integer-address) (deref)): 1032 <= 0
|
||||
run: init-channel/main 6: (((4 integer)) <- ((next-input)))
|
||||
arg: nil 0 (3)
|
||||
run: init-channel/main 6: 3 => ((4 integer))
|
||||
mem: ((4 integer)): 1005 <= 3
|
||||
run: init-channel/main 7: (((4 integer)) <- ((add)) ((4 integer)) ((1 literal)))
|
||||
mem: ((4 integer)) => 3
|
||||
run: init-channel/main 7: 4 => ((4 integer))
|
||||
mem: ((4 integer)): 1005 <= 4
|
||||
run: init-channel/main 8: (((5 tagged-value-array-address-address)) <- ((get-address)) ((1 channel-address) (deref)) ((2 offset)))
|
||||
run: init-channel/main 8: 1033 => ((5 tagged-value-array-address-address))
|
||||
mem: ((5 tagged-value-array-address-address)): 1006 <= 1033
|
||||
run: init-channel/main 9: (((5 tagged-value-array-address-address) (deref)) <- ((new)) ((tagged-value-array literal)) ((4 integer)))
|
||||
mem: ((4 integer)) => 4
|
||||
run: init-channel/main 9: 1034 => ((5 tagged-value-array-address-address) (deref))
|
||||
mem: ((5 tagged-value-array-address-address) (deref)): 1033 <= 1034
|
||||
run: init-channel/main 10: (((reply)) ((1 channel-address)))
|
||||
mem: ((1 channel-address)) => 1031
|
||||
run: main 0: 1031 => ((1 channel-address))
|
||||
mem: ((1 channel-address)): 1 <= 1031
|
||||
run: main 1: (((2 integer)) <- ((copy)) ((34 literal)))
|
||||
run: main 1: 34 => ((2 integer))
|
||||
mem: ((2 integer)): 2 <= 34
|
||||
run: main 2: (((3 tagged-value)) <- ((save-type)) ((2 integer)))
|
||||
mem: ((2 integer)) => 34
|
||||
run: main 2: #(tagged record (integer 34)) => ((3 tagged-value))
|
||||
mem: ((3 tagged-value)): 3 <= integer
|
||||
mem: ((3 tagged-value)): 4 <= 34
|
||||
run: main 3: (((1 channel-address) (deref)) <- ((write)) ((1 channel-address)) ((3 tagged-value)))
|
||||
mem: ((1 channel-address)) => 1031
|
||||
mem: ((3 tagged-value)) => #(tagged record (integer 34 . nil))
|
||||
run: write/main 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
|
||||
run: write/main 0: 1043 => ((default-space space-address))
|
||||
run: write/main 1: (((1 channel-address)) <- ((next-input)))
|
||||
arg: nil 0 (1031 #(tagged record (integer 34 . nil)))
|
||||
run: write/main 1: 1031 => ((1 channel-address))
|
||||
mem: ((1 channel-address)): 1045 <= 1031
|
||||
run: write/main 2: (((2 tagged-value)) <- ((next-input)))
|
||||
arg: nil 1 (1031 #(tagged record (integer 34 . nil)))
|
||||
run: write/main 2: #(tagged record (integer 34 . nil)) => ((2 tagged-value))
|
||||
mem: ((2 tagged-value)): 1046 <= integer
|
||||
mem: ((2 tagged-value)): 1047 <= 34
|
||||
run: write/main 3: (((4 boolean)) <- ((full?)) ((1 channel-address) (deref)))
|
||||
mem: ((1 channel-address) (deref)) => #(tagged record (0 0 1034 . nil))
|
||||
run: full?/write/main 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
|
||||
run: full?/write/main 0: 1074 => ((default-space space-address))
|
||||
run: full?/write/main 1: (((1 channel)) <- ((next-input)))
|
||||
arg: nil 0 (#(tagged record (0 0 1034 . nil)))
|
||||
run: full?/write/main 1: #(tagged record (0 0 1034 . nil)) => ((1 channel))
|
||||
mem: ((1 channel)): 1076 <= 0
|
||||
mem: ((1 channel)): 1077 <= 0
|
||||
mem: ((1 channel)): 1078 <= 1034
|
||||
run: full?/write/main 2: (((4 integer)) <- ((get)) ((1 channel)) ((1 offset)))
|
||||
mem: ((1077 integer) (raw)) => 0
|
||||
run: full?/write/main 2: 0 => ((4 integer))
|
||||
mem: ((4 integer)): 1079 <= 0
|
||||
run: full?/write/main 3: (((4 integer)) <- ((add)) ((4 integer)) ((1 literal)))
|
||||
mem: ((4 integer)) => 0
|
||||
run: full?/write/main 3: 1 => ((4 integer))
|
||||
mem: ((4 integer)): 1079 <= 1
|
||||
run: full?/write/main 4: (((5 integer)) <- ((capacity)) ((1 channel)))
|
||||
mem: ((1 channel)) => #(tagged record (0 0 1034 . nil))
|
||||
run: capacity/full?/write/main 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
|
||||
run: capacity/full?/write/main 0: 1105 => ((default-space space-address))
|
||||
run: capacity/full?/write/main 1: (((1 channel)) <- ((next-input)))
|
||||
arg: nil 0 (#(tagged record (0 0 1034 . nil)))
|
||||
run: capacity/full?/write/main 1: #(tagged record (0 0 1034 . nil)) => ((1 channel))
|
||||
mem: ((1 channel)): 1107 <= 0
|
||||
mem: ((1 channel)): 1108 <= 0
|
||||
mem: ((1 channel)): 1109 <= 1034
|
||||
run: capacity/full?/write/main 2: (((4 tagged-value-array-address)) <- ((get)) ((1 channel)) ((2 offset)))
|
||||
mem: ((1109 tagged-value-array-address) (raw)) => 1034
|
||||
run: capacity/full?/write/main 2: 1034 => ((4 tagged-value-array-address))
|
||||
mem: ((4 tagged-value-array-address)): 1110 <= 1034
|
||||
run: capacity/full?/write/main 3: (((5 integer)) <- ((length)) ((4 tagged-value-array-address) (deref)))
|
||||
array-len: ((4 tagged-value-array-address) (deref))
|
||||
mem: ((1034 integer) (raw)) => 4
|
||||
run: capacity/full?/write/main 3: 4 => ((5 integer))
|
||||
mem: ((5 integer)): 1111 <= 4
|
||||
run: capacity/full?/write/main 4: (((reply)) ((5 integer)))
|
||||
mem: ((5 integer)) => 4
|
||||
run: full?/write/main 4: 4 => ((5 integer))
|
||||
mem: ((5 integer)): 1080 <= 4
|
||||
run: full?/write/main 5: (((6 boolean)) <- ((less-than)) ((4 integer)) ((5 integer)))
|
||||
mem: ((4 integer)) => 1
|
||||
mem: ((5 integer)) => 4
|
||||
run: full?/write/main 5: t => ((6 boolean))
|
||||
mem: ((6 boolean)): 1081 <= t
|
||||
run: full?/write/main 6: (((jump-if)) ((6 boolean)) ((1 offset)))
|
||||
mem: ((6 boolean)) => t
|
||||
run: full?/write/main 8: (((7 integer)) <- ((get)) ((1 channel)) ((0 offset)))
|
||||
mem: ((1076 integer) (raw)) => 0
|
||||
run: full?/write/main 8: 0 => ((7 integer))
|
||||
mem: ((7 integer)): 1082 <= 0
|
||||
run: full?/write/main 9: (((8 boolean)) <- ((equal)) ((7 integer)) ((4 integer)))
|
||||
mem: ((7 integer)) => 0
|
||||
mem: ((4 integer)) => 1
|
||||
run: full?/write/main 9: nil => ((8 boolean))
|
||||
mem: ((8 boolean)): 1083 <= nil
|
||||
run: full?/write/main 10: (((reply)) ((8 boolean)))
|
||||
mem: ((8 boolean)) => nil
|
||||
run: write/main 3: nil => ((4 boolean))
|
||||
mem: ((4 boolean)): 1048 <= nil
|
||||
run: write/main 4: (((jump-unless)) ((4 boolean)) ((2 offset)))
|
||||
mem: ((4 boolean)) => nil
|
||||
run: write/main 7: (((6 tagged-value-array-address)) <- ((get)) ((1 channel-address) (deref)) ((2 offset)))
|
||||
mem: ((1033 tagged-value-array-address) (raw)) => 1034
|
||||
run: write/main 7: 1034 => ((6 tagged-value-array-address))
|
||||
mem: ((6 tagged-value-array-address)): 1050 <= 1034
|
||||
run: write/main 8: (((7 integer-address)) <- ((get-address)) ((1 channel-address) (deref)) ((1 offset)))
|
||||
run: write/main 8: 1032 => ((7 integer-address))
|
||||
mem: ((7 integer-address)): 1051 <= 1032
|
||||
run: write/main 9: (((8 tagged-value-address)) <- ((index-address)) ((6 tagged-value-array-address) (deref)) ((7 integer-address) (deref)))
|
||||
mem: ((7 integer-address) (deref)) => 0
|
||||
array-len: ((1034 tagged-value-array) (raw))
|
||||
mem: ((1034 integer) (raw)) => 4
|
||||
run: write/main 9: 1035 => ((8 tagged-value-address))
|
||||
mem: ((8 tagged-value-address)): 1052 <= 1035
|
||||
run: write/main 10: (((8 tagged-value-address) (deref)) <- ((copy)) ((2 tagged-value)))
|
||||
mem: ((2 tagged-value)) => #(tagged record (integer 34 . nil))
|
||||
run: write/main 10: #(tagged record (integer 34 . nil)) => ((8 tagged-value-address) (deref))
|
||||
mem: ((8 tagged-value-address) (deref)): 1035 <= integer
|
||||
mem: ((8 tagged-value-address) (deref)): 1036 <= 34
|
||||
run: write/main 11: (((7 integer-address) (deref)) <- ((add)) ((7 integer-address) (deref)) ((1 literal)))
|
||||
mem: ((7 integer-address) (deref)) => 0
|
||||
run: write/main 11: 1 => ((7 integer-address) (deref))
|
||||
mem: ((7 integer-address) (deref)): 1032 <= 1
|
||||
run: write/main 12: (((9 integer)) <- ((length)) ((6 tagged-value-array-address) (deref)))
|
||||
array-len: ((6 tagged-value-array-address) (deref))
|
||||
mem: ((1034 integer) (raw)) => 4
|
||||
run: write/main 12: 4 => ((9 integer))
|
||||
mem: ((9 integer)): 1053 <= 4
|
||||
run: write/main 13: (((10 boolean)) <- ((less-than)) ((7 integer-address) (deref)) ((9 integer)))
|
||||
mem: ((7 integer-address) (deref)) => 1
|
||||
mem: ((9 integer)) => 4
|
||||
run: write/main 13: t => ((10 boolean))
|
||||
mem: ((10 boolean)): 1054 <= t
|
||||
run: write/main 14: (((jump-if)) ((10 boolean)) ((1 offset)))
|
||||
mem: ((10 boolean)) => t
|
||||
run: write/main 16: (((reply)) ((1 channel-address) (deref) (same-as-arg 0)))
|
||||
mem: ((1 channel-address) (deref) (same-as-arg 0)) => #(tagged record (0 1 1034 . nil))
|
||||
run: main 3: #(tagged record (0 1 1034 . nil)) => ((1 channel-address) (deref))
|
||||
mem: ((1 channel-address) (deref)): 1031 <= 0
|
||||
mem: ((1 channel-address) (deref)): 1032 <= 1
|
||||
mem: ((1 channel-address) (deref)): 1033 <= 1034
|
||||
run: main 4: (((5 boolean)) <- ((empty?)) ((1 channel-address) (deref)))
|
||||
mem: ((1 channel-address) (deref)) => #(tagged record (0 1 1034 . nil))
|
||||
run: empty?/main 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
|
||||
run: empty?/main 0: 1136 => ((default-space space-address))
|
||||
run: empty?/main 1: (((1 channel)) <- ((next-input)))
|
||||
arg: nil 0 (#(tagged record (0 1 1034 . nil)))
|
||||
run: empty?/main 1: #(tagged record (0 1 1034 . nil)) => ((1 channel))
|
||||
mem: ((1 channel)): 1138 <= 0
|
||||
mem: ((1 channel)): 1139 <= 1
|
||||
mem: ((1 channel)): 1140 <= 1034
|
||||
run: empty?/main 2: (((4 integer)) <- ((get)) ((1 channel)) ((0 offset)))
|
||||
mem: ((1138 integer) (raw)) => 0
|
||||
run: empty?/main 2: 0 => ((4 integer))
|
||||
mem: ((4 integer)): 1141 <= 0
|
||||
run: empty?/main 3: (((5 integer)) <- ((get)) ((1 channel)) ((1 offset)))
|
||||
mem: ((1139 integer) (raw)) => 1
|
||||
run: empty?/main 3: 1 => ((5 integer))
|
||||
mem: ((5 integer)): 1142 <= 1
|
||||
run: empty?/main 4: (((6 boolean)) <- ((equal)) ((4 integer)) ((5 integer)))
|
||||
mem: ((4 integer)) => 0
|
||||
mem: ((5 integer)) => 1
|
||||
run: empty?/main 4: nil => ((6 boolean))
|
||||
mem: ((6 boolean)): 1143 <= nil
|
||||
run: empty?/main 5: (((reply)) ((6 boolean)))
|
||||
mem: ((6 boolean)) => nil
|
||||
run: main 4: nil => ((5 boolean))
|
||||
mem: ((5 boolean)): 5 <= nil
|
||||
run: main 5: (((6 boolean)) <- ((full?)) ((1 channel-address) (deref)))
|
||||
mem: ((1 channel-address) (deref)) => #(tagged record (0 1 1034 . nil))
|
||||
run: full?/main 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
|
||||
run: full?/main 0: 1167 => ((default-space space-address))
|
||||
run: full?/main 1: (((1 channel)) <- ((next-input)))
|
||||
arg: nil 0 (#(tagged record (0 1 1034 . nil)))
|
||||
run: full?/main 1: #(tagged record (0 1 1034 . nil)) => ((1 channel))
|
||||
mem: ((1 channel)): 1169 <= 0
|
||||
mem: ((1 channel)): 1170 <= 1
|
||||
mem: ((1 channel)): 1171 <= 1034
|
||||
run: full?/main 2: (((4 integer)) <- ((get)) ((1 channel)) ((1 offset)))
|
||||
mem: ((1170 integer) (raw)) => 1
|
||||
run: full?/main 2: 1 => ((4 integer))
|
||||
mem: ((4 integer)): 1172 <= 1
|
||||
run: full?/main 3: (((4 integer)) <- ((add)) ((4 integer)) ((1 literal)))
|
||||
mem: ((4 integer)) => 1
|
||||
run: full?/main 3: 2 => ((4 integer))
|
||||
mem: ((4 integer)): 1172 <= 2
|
||||
run: full?/main 4: (((5 integer)) <- ((capacity)) ((1 channel)))
|
||||
mem: ((1 channel)) => #(tagged record (0 1 1034 . nil))
|
||||
run: capacity/full?/main 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
|
||||
run: capacity/full?/main 0: 1198 => ((default-space space-address))
|
||||
run: capacity/full?/main 1: (((1 channel)) <- ((next-input)))
|
||||
arg: nil 0 (#(tagged record (0 1 1034 . nil)))
|
||||
run: capacity/full?/main 1: #(tagged record (0 1 1034 . nil)) => ((1 channel))
|
||||
mem: ((1 channel)): 1200 <= 0
|
||||
mem: ((1 channel)): 1201 <= 1
|
||||
mem: ((1 channel)): 1202 <= 1034
|
||||
run: capacity/full?/main 2: (((4 tagged-value-array-address)) <- ((get)) ((1 channel)) ((2 offset)))
|
||||
mem: ((1202 tagged-value-array-address) (raw)) => 1034
|
||||
run: capacity/full?/main 2: 1034 => ((4 tagged-value-array-address))
|
||||
mem: ((4 tagged-value-array-address)): 1203 <= 1034
|
||||
run: capacity/full?/main 3: (((5 integer)) <- ((length)) ((4 tagged-value-array-address) (deref)))
|
||||
array-len: ((4 tagged-value-array-address) (deref))
|
||||
mem: ((1034 integer) (raw)) => 4
|
||||
run: capacity/full?/main 3: 4 => ((5 integer))
|
||||
mem: ((5 integer)): 1204 <= 4
|
||||
run: capacity/full?/main 4: (((reply)) ((5 integer)))
|
||||
mem: ((5 integer)) => 4
|
||||
run: full?/main 4: 4 => ((5 integer))
|
||||
mem: ((5 integer)): 1173 <= 4
|
||||
run: full?/main 5: (((6 boolean)) <- ((less-than)) ((4 integer)) ((5 integer)))
|
||||
mem: ((4 integer)) => 2
|
||||
mem: ((5 integer)) => 4
|
||||
run: full?/main 5: t => ((6 boolean))
|
||||
mem: ((6 boolean)): 1174 <= t
|
||||
run: full?/main 6: (((jump-if)) ((6 boolean)) ((1 offset)))
|
||||
mem: ((6 boolean)) => t
|
||||
run: full?/main 8: (((7 integer)) <- ((get)) ((1 channel)) ((0 offset)))
|
||||
mem: ((1169 integer) (raw)) => 0
|
||||
run: full?/main 8: 0 => ((7 integer))
|
||||
mem: ((7 integer)): 1175 <= 0
|
||||
run: full?/main 9: (((8 boolean)) <- ((equal)) ((7 integer)) ((4 integer)))
|
||||
mem: ((7 integer)) => 0
|
||||
mem: ((4 integer)) => 2
|
||||
run: full?/main 9: nil => ((8 boolean))
|
||||
mem: ((8 boolean)): 1176 <= nil
|
||||
run: full?/main 10: (((reply)) ((8 boolean)))
|
||||
mem: ((8 boolean)) => nil
|
||||
run: main 5: nil => ((6 boolean))
|
||||
mem: ((6 boolean)): 6 <= nil
|
||||
schedule: done with routine nil
|
||||
|
|
@ -0,0 +1,445 @@
|
|||
c{0: 0 (((1 channel-address)) <- ((init-channel)) ((1 literal))) -- nil
|
||||
c{0: 1 (((2 integer)) <- ((copy)) ((34 literal))) -- nil
|
||||
c{0: 2 (((3 tagged-value)) <- ((save-type)) ((2 integer))) -- nil
|
||||
c{0: 3 (((1 channel-address) (deref)) <- ((write)) ((1 channel-address)) ((3 tagged-value))) -- nil
|
||||
c{0: 4 (((5 integer)) <- ((get)) ((1 channel-address) (deref)) ((first-free offset))) -- nil
|
||||
c{0: 5 (_ ((1 channel-address) (deref)) <- ((read)) ((1 channel-address))) -- nil
|
||||
c{0: 6 (((1 channel-address) (deref)) <- ((write)) ((1 channel-address)) ((3 tagged-value))) -- nil
|
||||
c{0: 7 (((6 integer)) <- ((get)) ((1 channel-address) (deref)) ((first-free offset))) -- nil
|
||||
c{1: 0 ✓ (((1 channel-address)) <- ((init-channel)) ((1 literal)))
|
||||
c{1: 1 ✓ (((2 integer)) <- ((copy)) ((34 literal)))
|
||||
c{1: 2 ✓ (((3 tagged-value)) <- ((save-type)) ((2 integer)))
|
||||
c{1: 3 ✓ (((1 channel-address) (deref)) <- ((write)) ((1 channel-address)) ((3 tagged-value)))
|
||||
c{1: 4 ✓ (((5 integer)) <- ((get)) ((1 channel-address) (deref)) ((first-free offset)))
|
||||
c{1: 5 ✓ (_ ((1 channel-address) (deref)) <- ((read)) ((1 channel-address)))
|
||||
c{1: 6 ✓ (((1 channel-address) (deref)) <- ((write)) ((1 channel-address)) ((3 tagged-value)))
|
||||
c{1: 7 ✓ (((6 integer)) <- ((get)) ((1 channel-address) (deref)) ((first-free offset)))
|
||||
cn0: convert-names in main
|
||||
cn0: (((1 channel-address)) <- ((init-channel)) ((1 literal))) nil nil
|
||||
cn0: checking arg ((1 literal))
|
||||
cn0: checking oarg ((1 channel-address))
|
||||
maybe-add: ((1 channel-address))
|
||||
cn0: (((2 integer)) <- ((copy)) ((34 literal))) nil nil
|
||||
cn0: checking arg ((34 literal))
|
||||
cn0: checking oarg ((2 integer))
|
||||
maybe-add: ((2 integer))
|
||||
cn0: (((3 tagged-value)) <- ((save-type)) ((2 integer))) nil nil
|
||||
cn0: checking arg ((2 integer))
|
||||
maybe-add: ((2 integer))
|
||||
cn0: checking oarg ((3 tagged-value))
|
||||
maybe-add: ((3 tagged-value))
|
||||
cn0: (((1 channel-address) (deref)) <- ((write)) ((1 channel-address)) ((3 tagged-value))) nil nil
|
||||
cn0: checking arg ((1 channel-address))
|
||||
maybe-add: ((1 channel-address))
|
||||
cn0: checking arg ((3 tagged-value))
|
||||
maybe-add: ((3 tagged-value))
|
||||
cn0: checking oarg ((1 channel-address) (deref))
|
||||
maybe-add: ((1 channel-address) (deref))
|
||||
cn0: (((5 integer)) <- ((get)) ((1 channel-address) (deref)) ((first-free offset))) nil nil
|
||||
cn0: field-access first-free in 1channel-addressderef of type channel
|
||||
cn0: new field; computing location
|
||||
cn0: field location 1
|
||||
cn0: checking arg ((1 channel-address) (deref))
|
||||
maybe-add: ((1 channel-address) (deref))
|
||||
cn0: checking arg ((first-free offset))
|
||||
cn0: checking oarg ((5 integer))
|
||||
maybe-add: ((5 integer))
|
||||
cn0: (_ ((1 channel-address) (deref)) <- ((read)) ((1 channel-address))) ((first-free 1)) ((first-free t))
|
||||
cn0: checking arg ((1 channel-address))
|
||||
maybe-add: ((1 channel-address))
|
||||
cn0: checking oarg _
|
||||
cn0: checking oarg ((1 channel-address) (deref))
|
||||
maybe-add: ((1 channel-address) (deref))
|
||||
cn0: (((1 channel-address) (deref)) <- ((write)) ((1 channel-address)) ((3 tagged-value))) ((first-free 1)) ((first-free t))
|
||||
cn0: checking arg ((1 channel-address))
|
||||
maybe-add: ((1 channel-address))
|
||||
cn0: checking arg ((3 tagged-value))
|
||||
maybe-add: ((3 tagged-value))
|
||||
cn0: checking oarg ((1 channel-address) (deref))
|
||||
maybe-add: ((1 channel-address) (deref))
|
||||
cn0: (((6 integer)) <- ((get)) ((1 channel-address) (deref)) ((first-free offset))) ((first-free 1)) ((first-free t))
|
||||
cn0: field-access first-free in 1channel-addressderef of type channel
|
||||
cn0: checking arg ((1 channel-address) (deref))
|
||||
maybe-add: ((1 channel-address) (deref))
|
||||
cn0: checking arg ((first-free offset))
|
||||
cn0: checking oarg ((6 integer))
|
||||
maybe-add: ((6 integer))
|
||||
cn1: (((1 channel-address)) <- ((init-channel)) ((1 literal)))
|
||||
cn1: (((2 integer)) <- ((copy)) ((34 literal)))
|
||||
cn1: (((3 tagged-value)) <- ((save-type)) ((2 integer)))
|
||||
cn1: (((1 channel-address) (deref)) <- ((write)) ((1 channel-address)) ((3 tagged-value)))
|
||||
cn1: (((5 integer)) <- ((get)) ((1 channel-address) (deref)) ((1 offset)))
|
||||
cn1: (_ ((1 channel-address) (deref)) <- ((read)) ((1 channel-address)))
|
||||
cn1: (((1 channel-address) (deref)) <- ((write)) ((1 channel-address)) ((3 tagged-value)))
|
||||
cn1: (((6 integer)) <- ((get)) ((1 channel-address) (deref)) ((1 offset)))
|
||||
schedule: main
|
||||
run: main 0: (((1 channel-address)) <- ((init-channel)) ((1 literal)))
|
||||
run: init-channel/main 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
|
||||
run: init-channel/main 0: 1000 => ((default-space space-address))
|
||||
run: init-channel/main 1: (((1 channel-address)) <- ((new)) ((channel literal)))
|
||||
run: init-channel/main 1: 1031 => ((1 channel-address))
|
||||
mem: ((1 channel-address)): 1002 <= 1031
|
||||
run: init-channel/main 2: (((2 integer-address)) <- ((get-address)) ((1 channel-address) (deref)) ((0 offset)))
|
||||
run: init-channel/main 2: 1031 => ((2 integer-address))
|
||||
mem: ((2 integer-address)): 1003 <= 1031
|
||||
run: init-channel/main 3: (((2 integer-address) (deref)) <- ((copy)) ((0 literal)))
|
||||
run: init-channel/main 3: 0 => ((2 integer-address) (deref))
|
||||
mem: ((2 integer-address) (deref)): 1031 <= 0
|
||||
run: init-channel/main 4: (((3 integer-address)) <- ((get-address)) ((1 channel-address) (deref)) ((1 offset)))
|
||||
run: init-channel/main 4: 1032 => ((3 integer-address))
|
||||
mem: ((3 integer-address)): 1004 <= 1032
|
||||
run: init-channel/main 5: (((3 integer-address) (deref)) <- ((copy)) ((0 literal)))
|
||||
run: init-channel/main 5: 0 => ((3 integer-address) (deref))
|
||||
mem: ((3 integer-address) (deref)): 1032 <= 0
|
||||
run: init-channel/main 6: (((4 integer)) <- ((next-input)))
|
||||
arg: nil 0 (1)
|
||||
run: init-channel/main 6: 1 => ((4 integer))
|
||||
mem: ((4 integer)): 1005 <= 1
|
||||
run: init-channel/main 7: (((4 integer)) <- ((add)) ((4 integer)) ((1 literal)))
|
||||
mem: ((4 integer)) => 1
|
||||
run: init-channel/main 7: 2 => ((4 integer))
|
||||
mem: ((4 integer)): 1005 <= 2
|
||||
run: init-channel/main 8: (((5 tagged-value-array-address-address)) <- ((get-address)) ((1 channel-address) (deref)) ((2 offset)))
|
||||
run: init-channel/main 8: 1033 => ((5 tagged-value-array-address-address))
|
||||
mem: ((5 tagged-value-array-address-address)): 1006 <= 1033
|
||||
run: init-channel/main 9: (((5 tagged-value-array-address-address) (deref)) <- ((new)) ((tagged-value-array literal)) ((4 integer)))
|
||||
mem: ((4 integer)) => 2
|
||||
run: init-channel/main 9: 1034 => ((5 tagged-value-array-address-address) (deref))
|
||||
mem: ((5 tagged-value-array-address-address) (deref)): 1033 <= 1034
|
||||
run: init-channel/main 10: (((reply)) ((1 channel-address)))
|
||||
mem: ((1 channel-address)) => 1031
|
||||
run: main 0: 1031 => ((1 channel-address))
|
||||
mem: ((1 channel-address)): 1 <= 1031
|
||||
run: main 1: (((2 integer)) <- ((copy)) ((34 literal)))
|
||||
run: main 1: 34 => ((2 integer))
|
||||
mem: ((2 integer)): 2 <= 34
|
||||
run: main 2: (((3 tagged-value)) <- ((save-type)) ((2 integer)))
|
||||
mem: ((2 integer)) => 34
|
||||
run: main 2: #(tagged record (integer 34)) => ((3 tagged-value))
|
||||
mem: ((3 tagged-value)): 3 <= integer
|
||||
mem: ((3 tagged-value)): 4 <= 34
|
||||
run: main 3: (((1 channel-address) (deref)) <- ((write)) ((1 channel-address)) ((3 tagged-value)))
|
||||
mem: ((1 channel-address)) => 1031
|
||||
mem: ((3 tagged-value)) => #(tagged record (integer 34 . nil))
|
||||
run: write/main 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
|
||||
run: write/main 0: 1039 => ((default-space space-address))
|
||||
run: write/main 1: (((1 channel-address)) <- ((next-input)))
|
||||
arg: nil 0 (1031 #(tagged record (integer 34 . nil)))
|
||||
run: write/main 1: 1031 => ((1 channel-address))
|
||||
mem: ((1 channel-address)): 1041 <= 1031
|
||||
run: write/main 2: (((2 tagged-value)) <- ((next-input)))
|
||||
arg: nil 1 (1031 #(tagged record (integer 34 . nil)))
|
||||
run: write/main 2: #(tagged record (integer 34 . nil)) => ((2 tagged-value))
|
||||
mem: ((2 tagged-value)): 1042 <= integer
|
||||
mem: ((2 tagged-value)): 1043 <= 34
|
||||
run: write/main 3: (((4 boolean)) <- ((full?)) ((1 channel-address) (deref)))
|
||||
mem: ((1 channel-address) (deref)) => #(tagged record (0 0 1034 . nil))
|
||||
run: full?/write/main 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
|
||||
run: full?/write/main 0: 1070 => ((default-space space-address))
|
||||
run: full?/write/main 1: (((1 channel)) <- ((next-input)))
|
||||
arg: nil 0 (#(tagged record (0 0 1034 . nil)))
|
||||
run: full?/write/main 1: #(tagged record (0 0 1034 . nil)) => ((1 channel))
|
||||
mem: ((1 channel)): 1072 <= 0
|
||||
mem: ((1 channel)): 1073 <= 0
|
||||
mem: ((1 channel)): 1074 <= 1034
|
||||
run: full?/write/main 2: (((4 integer)) <- ((get)) ((1 channel)) ((1 offset)))
|
||||
mem: ((1073 integer) (raw)) => 0
|
||||
run: full?/write/main 2: 0 => ((4 integer))
|
||||
mem: ((4 integer)): 1075 <= 0
|
||||
run: full?/write/main 3: (((4 integer)) <- ((add)) ((4 integer)) ((1 literal)))
|
||||
mem: ((4 integer)) => 0
|
||||
run: full?/write/main 3: 1 => ((4 integer))
|
||||
mem: ((4 integer)): 1075 <= 1
|
||||
run: full?/write/main 4: (((5 integer)) <- ((capacity)) ((1 channel)))
|
||||
mem: ((1 channel)) => #(tagged record (0 0 1034 . nil))
|
||||
run: capacity/full?/write/main 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
|
||||
run: capacity/full?/write/main 0: 1101 => ((default-space space-address))
|
||||
run: capacity/full?/write/main 1: (((1 channel)) <- ((next-input)))
|
||||
arg: nil 0 (#(tagged record (0 0 1034 . nil)))
|
||||
run: capacity/full?/write/main 1: #(tagged record (0 0 1034 . nil)) => ((1 channel))
|
||||
mem: ((1 channel)): 1103 <= 0
|
||||
mem: ((1 channel)): 1104 <= 0
|
||||
mem: ((1 channel)): 1105 <= 1034
|
||||
run: capacity/full?/write/main 2: (((4 tagged-value-array-address)) <- ((get)) ((1 channel)) ((2 offset)))
|
||||
mem: ((1105 tagged-value-array-address) (raw)) => 1034
|
||||
run: capacity/full?/write/main 2: 1034 => ((4 tagged-value-array-address))
|
||||
mem: ((4 tagged-value-array-address)): 1106 <= 1034
|
||||
run: capacity/full?/write/main 3: (((5 integer)) <- ((length)) ((4 tagged-value-array-address) (deref)))
|
||||
array-len: ((4 tagged-value-array-address) (deref))
|
||||
mem: ((1034 integer) (raw)) => 2
|
||||
run: capacity/full?/write/main 3: 2 => ((5 integer))
|
||||
mem: ((5 integer)): 1107 <= 2
|
||||
run: capacity/full?/write/main 4: (((reply)) ((5 integer)))
|
||||
mem: ((5 integer)) => 2
|
||||
run: full?/write/main 4: 2 => ((5 integer))
|
||||
mem: ((5 integer)): 1076 <= 2
|
||||
run: full?/write/main 5: (((6 boolean)) <- ((less-than)) ((4 integer)) ((5 integer)))
|
||||
mem: ((4 integer)) => 1
|
||||
mem: ((5 integer)) => 2
|
||||
run: full?/write/main 5: t => ((6 boolean))
|
||||
mem: ((6 boolean)): 1077 <= t
|
||||
run: full?/write/main 6: (((jump-if)) ((6 boolean)) ((1 offset)))
|
||||
mem: ((6 boolean)) => t
|
||||
run: full?/write/main 8: (((7 integer)) <- ((get)) ((1 channel)) ((0 offset)))
|
||||
mem: ((1072 integer) (raw)) => 0
|
||||
run: full?/write/main 8: 0 => ((7 integer))
|
||||
mem: ((7 integer)): 1078 <= 0
|
||||
run: full?/write/main 9: (((8 boolean)) <- ((equal)) ((7 integer)) ((4 integer)))
|
||||
mem: ((7 integer)) => 0
|
||||
mem: ((4 integer)) => 1
|
||||
run: full?/write/main 9: nil => ((8 boolean))
|
||||
mem: ((8 boolean)): 1079 <= nil
|
||||
run: full?/write/main 10: (((reply)) ((8 boolean)))
|
||||
mem: ((8 boolean)) => nil
|
||||
run: write/main 3: nil => ((4 boolean))
|
||||
mem: ((4 boolean)): 1044 <= nil
|
||||
run: write/main 4: (((jump-unless)) ((4 boolean)) ((2 offset)))
|
||||
mem: ((4 boolean)) => nil
|
||||
run: write/main 7: (((6 tagged-value-array-address)) <- ((get)) ((1 channel-address) (deref)) ((2 offset)))
|
||||
mem: ((1033 tagged-value-array-address) (raw)) => 1034
|
||||
run: write/main 7: 1034 => ((6 tagged-value-array-address))
|
||||
mem: ((6 tagged-value-array-address)): 1046 <= 1034
|
||||
run: write/main 8: (((7 integer-address)) <- ((get-address)) ((1 channel-address) (deref)) ((1 offset)))
|
||||
run: write/main 8: 1032 => ((7 integer-address))
|
||||
mem: ((7 integer-address)): 1047 <= 1032
|
||||
run: write/main 9: (((8 tagged-value-address)) <- ((index-address)) ((6 tagged-value-array-address) (deref)) ((7 integer-address) (deref)))
|
||||
mem: ((7 integer-address) (deref)) => 0
|
||||
array-len: ((1034 tagged-value-array) (raw))
|
||||
mem: ((1034 integer) (raw)) => 2
|
||||
run: write/main 9: 1035 => ((8 tagged-value-address))
|
||||
mem: ((8 tagged-value-address)): 1048 <= 1035
|
||||
run: write/main 10: (((8 tagged-value-address) (deref)) <- ((copy)) ((2 tagged-value)))
|
||||
mem: ((2 tagged-value)) => #(tagged record (integer 34 . nil))
|
||||
run: write/main 10: #(tagged record (integer 34 . nil)) => ((8 tagged-value-address) (deref))
|
||||
mem: ((8 tagged-value-address) (deref)): 1035 <= integer
|
||||
mem: ((8 tagged-value-address) (deref)): 1036 <= 34
|
||||
run: write/main 11: (((7 integer-address) (deref)) <- ((add)) ((7 integer-address) (deref)) ((1 literal)))
|
||||
mem: ((7 integer-address) (deref)) => 0
|
||||
run: write/main 11: 1 => ((7 integer-address) (deref))
|
||||
mem: ((7 integer-address) (deref)): 1032 <= 1
|
||||
run: write/main 12: (((9 integer)) <- ((length)) ((6 tagged-value-array-address) (deref)))
|
||||
array-len: ((6 tagged-value-array-address) (deref))
|
||||
mem: ((1034 integer) (raw)) => 2
|
||||
run: write/main 12: 2 => ((9 integer))
|
||||
mem: ((9 integer)): 1049 <= 2
|
||||
run: write/main 13: (((10 boolean)) <- ((less-than)) ((7 integer-address) (deref)) ((9 integer)))
|
||||
mem: ((7 integer-address) (deref)) => 1
|
||||
mem: ((9 integer)) => 2
|
||||
run: write/main 13: t => ((10 boolean))
|
||||
mem: ((10 boolean)): 1050 <= t
|
||||
run: write/main 14: (((jump-if)) ((10 boolean)) ((1 offset)))
|
||||
mem: ((10 boolean)) => t
|
||||
run: write/main 16: (((reply)) ((1 channel-address) (deref) (same-as-arg 0)))
|
||||
mem: ((1 channel-address) (deref) (same-as-arg 0)) => #(tagged record (0 1 1034 . nil))
|
||||
run: main 3: #(tagged record (0 1 1034 . nil)) => ((1 channel-address) (deref))
|
||||
mem: ((1 channel-address) (deref)): 1031 <= 0
|
||||
mem: ((1 channel-address) (deref)): 1032 <= 1
|
||||
mem: ((1 channel-address) (deref)): 1033 <= 1034
|
||||
run: main 4: (((5 integer)) <- ((get)) ((1 channel-address) (deref)) ((1 offset)))
|
||||
mem: ((1032 integer) (raw)) => 1
|
||||
run: main 4: 1 => ((5 integer))
|
||||
mem: ((5 integer)): 5 <= 1
|
||||
run: main 5: (_ ((1 channel-address) (deref)) <- ((read)) ((1 channel-address)))
|
||||
mem: ((1 channel-address)) => 1031
|
||||
run: read/main 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
|
||||
run: read/main 0: 1132 => ((default-space space-address))
|
||||
run: read/main 1: (((1 channel-address)) <- ((next-input)))
|
||||
arg: nil 0 (1031)
|
||||
run: read/main 1: 1031 => ((1 channel-address))
|
||||
mem: ((1 channel-address)): 1134 <= 1031
|
||||
run: read/main 2: (((2 boolean)) <- ((empty?)) ((1 channel-address) (deref)))
|
||||
mem: ((1 channel-address) (deref)) => #(tagged record (0 1 1034 . nil))
|
||||
run: empty?/read/main 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
|
||||
run: empty?/read/main 0: 1163 => ((default-space space-address))
|
||||
run: empty?/read/main 1: (((1 channel)) <- ((next-input)))
|
||||
arg: nil 0 (#(tagged record (0 1 1034 . nil)))
|
||||
run: empty?/read/main 1: #(tagged record (0 1 1034 . nil)) => ((1 channel))
|
||||
mem: ((1 channel)): 1165 <= 0
|
||||
mem: ((1 channel)): 1166 <= 1
|
||||
mem: ((1 channel)): 1167 <= 1034
|
||||
run: empty?/read/main 2: (((4 integer)) <- ((get)) ((1 channel)) ((0 offset)))
|
||||
mem: ((1165 integer) (raw)) => 0
|
||||
run: empty?/read/main 2: 0 => ((4 integer))
|
||||
mem: ((4 integer)): 1168 <= 0
|
||||
run: empty?/read/main 3: (((5 integer)) <- ((get)) ((1 channel)) ((1 offset)))
|
||||
mem: ((1166 integer) (raw)) => 1
|
||||
run: empty?/read/main 3: 1 => ((5 integer))
|
||||
mem: ((5 integer)): 1169 <= 1
|
||||
run: empty?/read/main 4: (((6 boolean)) <- ((equal)) ((4 integer)) ((5 integer)))
|
||||
mem: ((4 integer)) => 0
|
||||
mem: ((5 integer)) => 1
|
||||
run: empty?/read/main 4: nil => ((6 boolean))
|
||||
mem: ((6 boolean)): 1170 <= nil
|
||||
run: empty?/read/main 5: (((reply)) ((6 boolean)))
|
||||
mem: ((6 boolean)) => nil
|
||||
run: read/main 2: nil => ((2 boolean))
|
||||
mem: ((2 boolean)): 1135 <= nil
|
||||
run: read/main 3: (((jump-unless)) ((2 boolean)) ((2 offset)))
|
||||
mem: ((2 boolean)) => nil
|
||||
run: read/main 6: (((4 integer-address)) <- ((get-address)) ((1 channel-address) (deref)) ((0 offset)))
|
||||
run: read/main 6: 1031 => ((4 integer-address))
|
||||
mem: ((4 integer-address)): 1137 <= 1031
|
||||
run: read/main 7: (((5 tagged-value-array-address)) <- ((get)) ((1 channel-address) (deref)) ((2 offset)))
|
||||
mem: ((1033 tagged-value-array-address) (raw)) => 1034
|
||||
run: read/main 7: 1034 => ((5 tagged-value-array-address))
|
||||
mem: ((5 tagged-value-array-address)): 1138 <= 1034
|
||||
run: read/main 8: (((6 tagged-value)) <- ((index)) ((5 tagged-value-array-address) (deref)) ((4 integer-address) (deref)))
|
||||
mem: ((4 integer-address) (deref)) => 0
|
||||
array-len: ((1034 tagged-value-array) (raw))
|
||||
mem: ((1034 integer) (raw)) => 2
|
||||
mem: ((1035 tagged-value) (raw)) => #(tagged record (integer 34 . nil))
|
||||
run: read/main 8: #(tagged record (integer 34 . nil)) => ((6 tagged-value))
|
||||
mem: ((6 tagged-value)): 1139 <= integer
|
||||
mem: ((6 tagged-value)): 1140 <= 34
|
||||
run: read/main 9: (((4 integer-address) (deref)) <- ((add)) ((4 integer-address) (deref)) ((1 literal)))
|
||||
mem: ((4 integer-address) (deref)) => 0
|
||||
run: read/main 9: 1 => ((4 integer-address) (deref))
|
||||
mem: ((4 integer-address) (deref)): 1031 <= 1
|
||||
run: read/main 10: (((8 integer)) <- ((length)) ((5 tagged-value-array-address) (deref)))
|
||||
array-len: ((5 tagged-value-array-address) (deref))
|
||||
mem: ((1034 integer) (raw)) => 2
|
||||
run: read/main 10: 2 => ((8 integer))
|
||||
mem: ((8 integer)): 1141 <= 2
|
||||
run: read/main 11: (((9 boolean)) <- ((less-than)) ((4 integer-address) (deref)) ((8 integer)))
|
||||
mem: ((4 integer-address) (deref)) => 1
|
||||
mem: ((8 integer)) => 2
|
||||
run: read/main 11: t => ((9 boolean))
|
||||
mem: ((9 boolean)): 1142 <= t
|
||||
run: read/main 12: (((jump-if)) ((9 boolean)) ((1 offset)))
|
||||
mem: ((9 boolean)) => t
|
||||
run: read/main 14: (((reply)) ((6 tagged-value)) ((1 channel-address) (deref) (same-as-arg 0)))
|
||||
mem: ((6 tagged-value)) => #(tagged record (integer 34 . nil))
|
||||
mem: ((1 channel-address) (deref) (same-as-arg 0)) => #(tagged record (1 1 1034 . nil))
|
||||
run: main 5: #(tagged record (integer 34 . nil)) => _
|
||||
run: main 5: #(tagged record (1 1 1034 . nil)) => ((1 channel-address) (deref))
|
||||
mem: ((1 channel-address) (deref)): 1031 <= 1
|
||||
mem: ((1 channel-address) (deref)): 1032 <= 1
|
||||
mem: ((1 channel-address) (deref)): 1033 <= 1034
|
||||
run: main 6: (((1 channel-address) (deref)) <- ((write)) ((1 channel-address)) ((3 tagged-value)))
|
||||
mem: ((1 channel-address)) => 1031
|
||||
mem: ((3 tagged-value)) => #(tagged record (integer 34 . nil))
|
||||
run: write/main 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
|
||||
run: write/main 0: 1194 => ((default-space space-address))
|
||||
run: write/main 1: (((1 channel-address)) <- ((next-input)))
|
||||
arg: nil 0 (1031 #(tagged record (integer 34 . nil)))
|
||||
run: write/main 1: 1031 => ((1 channel-address))
|
||||
mem: ((1 channel-address)): 1196 <= 1031
|
||||
run: write/main 2: (((2 tagged-value)) <- ((next-input)))
|
||||
arg: nil 1 (1031 #(tagged record (integer 34 . nil)))
|
||||
run: write/main 2: #(tagged record (integer 34 . nil)) => ((2 tagged-value))
|
||||
mem: ((2 tagged-value)): 1197 <= integer
|
||||
mem: ((2 tagged-value)): 1198 <= 34
|
||||
run: write/main 3: (((4 boolean)) <- ((full?)) ((1 channel-address) (deref)))
|
||||
mem: ((1 channel-address) (deref)) => #(tagged record (1 1 1034 . nil))
|
||||
run: full?/write/main 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
|
||||
run: full?/write/main 0: 1225 => ((default-space space-address))
|
||||
run: full?/write/main 1: (((1 channel)) <- ((next-input)))
|
||||
arg: nil 0 (#(tagged record (1 1 1034 . nil)))
|
||||
run: full?/write/main 1: #(tagged record (1 1 1034 . nil)) => ((1 channel))
|
||||
mem: ((1 channel)): 1227 <= 1
|
||||
mem: ((1 channel)): 1228 <= 1
|
||||
mem: ((1 channel)): 1229 <= 1034
|
||||
run: full?/write/main 2: (((4 integer)) <- ((get)) ((1 channel)) ((1 offset)))
|
||||
mem: ((1228 integer) (raw)) => 1
|
||||
run: full?/write/main 2: 1 => ((4 integer))
|
||||
mem: ((4 integer)): 1230 <= 1
|
||||
run: full?/write/main 3: (((4 integer)) <- ((add)) ((4 integer)) ((1 literal)))
|
||||
mem: ((4 integer)) => 1
|
||||
run: full?/write/main 3: 2 => ((4 integer))
|
||||
mem: ((4 integer)): 1230 <= 2
|
||||
run: full?/write/main 4: (((5 integer)) <- ((capacity)) ((1 channel)))
|
||||
mem: ((1 channel)) => #(tagged record (1 1 1034 . nil))
|
||||
run: capacity/full?/write/main 0: (((default-space space-address)) <- ((new)) ((space literal)) ((30 literal)))
|
||||
run: capacity/full?/write/main 0: 1256 => ((default-space space-address))
|
||||
run: capacity/full?/write/main 1: (((1 channel)) <- ((next-input)))
|
||||
arg: nil 0 (#(tagged record (1 1 1034 . nil)))
|
||||
run: capacity/full?/write/main 1: #(tagged record (1 1 1034 . nil)) => ((1 channel))
|
||||
mem: ((1 channel)): 1258 <= 1
|
||||
mem: ((1 channel)): 1259 <= 1
|
||||
mem: ((1 channel)): 1260 <= 1034
|
||||
run: capacity/full?/write/main 2: (((4 tagged-value-array-address)) <- ((get)) ((1 channel)) ((2 offset)))
|
||||
mem: ((1260 tagged-value-array-address) (raw)) => 1034
|
||||
run: capacity/full?/write/main 2: 1034 => ((4 tagged-value-array-address))
|
||||
mem: ((4 tagged-value-array-address)): 1261 <= 1034
|
||||
run: capacity/full?/write/main 3: (((5 integer)) <- ((length)) ((4 tagged-value-array-address) (deref)))
|
||||
array-len: ((4 tagged-value-array-address) (deref))
|
||||
mem: ((1034 integer) (raw)) => 2
|
||||
run: capacity/full?/write/main 3: 2 => ((5 integer))
|
||||
mem: ((5 integer)): 1262 <= 2
|
||||
run: capacity/full?/write/main 4: (((reply)) ((5 integer)))
|
||||
mem: ((5 integer)) => 2
|
||||
run: full?/write/main 4: 2 => ((5 integer))
|
||||
mem: ((5 integer)): 1231 <= 2
|
||||
run: full?/write/main 5: (((6 boolean)) <- ((less-than)) ((4 integer)) ((5 integer)))
|
||||
mem: ((4 integer)) => 2
|
||||
mem: ((5 integer)) => 2
|
||||
run: full?/write/main 5: nil => ((6 boolean))
|
||||
mem: ((6 boolean)): 1232 <= nil
|
||||
run: full?/write/main 6: (((jump-if)) ((6 boolean)) ((1 offset)))
|
||||
mem: ((6 boolean)) => nil
|
||||
run: full?/write/main 7: (((4 integer)) <- ((copy)) ((0 literal)))
|
||||
run: full?/write/main 7: 0 => ((4 integer))
|
||||
mem: ((4 integer)): 1230 <= 0
|
||||
run: full?/write/main 8: (((7 integer)) <- ((get)) ((1 channel)) ((0 offset)))
|
||||
mem: ((1227 integer) (raw)) => 1
|
||||
run: full?/write/main 8: 1 => ((7 integer))
|
||||
mem: ((7 integer)): 1233 <= 1
|
||||
run: full?/write/main 9: (((8 boolean)) <- ((equal)) ((7 integer)) ((4 integer)))
|
||||
mem: ((7 integer)) => 1
|
||||
mem: ((4 integer)) => 0
|
||||
run: full?/write/main 9: nil => ((8 boolean))
|
||||
mem: ((8 boolean)): 1234 <= nil
|
||||
run: full?/write/main 10: (((reply)) ((8 boolean)))
|
||||
mem: ((8 boolean)) => nil
|
||||
run: write/main 3: nil => ((4 boolean))
|
||||
mem: ((4 boolean)): 1199 <= nil
|
||||
run: write/main 4: (((jump-unless)) ((4 boolean)) ((2 offset)))
|
||||
mem: ((4 boolean)) => nil
|
||||
run: write/main 7: (((6 tagged-value-array-address)) <- ((get)) ((1 channel-address) (deref)) ((2 offset)))
|
||||
mem: ((1033 tagged-value-array-address) (raw)) => 1034
|
||||
run: write/main 7: 1034 => ((6 tagged-value-array-address))
|
||||
mem: ((6 tagged-value-array-address)): 1201 <= 1034
|
||||
run: write/main 8: (((7 integer-address)) <- ((get-address)) ((1 channel-address) (deref)) ((1 offset)))
|
||||
run: write/main 8: 1032 => ((7 integer-address))
|
||||
mem: ((7 integer-address)): 1202 <= 1032
|
||||
run: write/main 9: (((8 tagged-value-address)) <- ((index-address)) ((6 tagged-value-array-address) (deref)) ((7 integer-address) (deref)))
|
||||
mem: ((7 integer-address) (deref)) => 1
|
||||
array-len: ((1034 tagged-value-array) (raw))
|
||||
mem: ((1034 integer) (raw)) => 2
|
||||
run: write/main 9: 1037 => ((8 tagged-value-address))
|
||||
mem: ((8 tagged-value-address)): 1203 <= 1037
|
||||
run: write/main 10: (((8 tagged-value-address) (deref)) <- ((copy)) ((2 tagged-value)))
|
||||
mem: ((2 tagged-value)) => #(tagged record (integer 34 . nil))
|
||||
run: write/main 10: #(tagged record (integer 34 . nil)) => ((8 tagged-value-address) (deref))
|
||||
mem: ((8 tagged-value-address) (deref)): 1037 <= integer
|
||||
mem: ((8 tagged-value-address) (deref)): 1038 <= 34
|
||||
run: write/main 11: (((7 integer-address) (deref)) <- ((add)) ((7 integer-address) (deref)) ((1 literal)))
|
||||
mem: ((7 integer-address) (deref)) => 1
|
||||
run: write/main 11: 2 => ((7 integer-address) (deref))
|
||||
mem: ((7 integer-address) (deref)): 1032 <= 2
|
||||
run: write/main 12: (((9 integer)) <- ((length)) ((6 tagged-value-array-address) (deref)))
|
||||
array-len: ((6 tagged-value-array-address) (deref))
|
||||
mem: ((1034 integer) (raw)) => 2
|
||||
run: write/main 12: 2 => ((9 integer))
|
||||
mem: ((9 integer)): 1204 <= 2
|
||||
run: write/main 13: (((10 boolean)) <- ((less-than)) ((7 integer-address) (deref)) ((9 integer)))
|
||||
mem: ((7 integer-address) (deref)) => 2
|
||||
mem: ((9 integer)) => 2
|
||||
run: write/main 13: nil => ((10 boolean))
|
||||
mem: ((10 boolean)): 1205 <= nil
|
||||
run: write/main 14: (((jump-if)) ((10 boolean)) ((1 offset)))
|
||||
mem: ((10 boolean)) => nil
|
||||
run: write/main 15: (((7 integer-address) (deref)) <- ((copy)) ((0 literal)))
|
||||
run: write/main 15: 0 => ((7 integer-address) (deref))
|
||||
mem: ((7 integer-address) (deref)): 1032 <= 0
|
||||
run: write/main 16: (((reply)) ((1 channel-address) (deref) (same-as-arg 0)))
|
||||
mem: ((1 channel-address) (deref) (same-as-arg 0)) => #(tagged record (1 0 1034 . nil))
|
||||
run: main 6: #(tagged record (1 0 1034 . nil)) => ((1 channel-address) (deref))
|
||||
mem: ((1 channel-address) (deref)): 1031 <= 1
|
||||
mem: ((1 channel-address) (deref)): 1032 <= 0
|
||||
mem: ((1 channel-address) (deref)): 1033 <= 1034
|
||||
run: main 7: (((6 integer)) <- ((get)) ((1 channel-address) (deref)) ((1 offset)))
|
||||
mem: ((1032 integer) (raw)) => 0
|
||||
run: main 7: 0 => ((6 integer))
|
||||
mem: ((6 integer)): 6 <= 0
|
||||
schedule: done with routine nil
|
||||
|
|
@ -0,0 +1,14 @@
|
|||
c{0: 0 (((1 integer)) <- ((copy)) ((0 literal))) -- nil
|
||||
c{0: 1 (((2 integer)) <- ((copy)) ((0 literal))) -- nil
|
||||
c{0: 2 (((3 integer)) <- ((copy)) ((0 literal))) -- nil
|
||||
c{0: 3 (((4 boolean)) <- ((not-equal)) ((1 integer)) ((3 integer))) -- ((open 3))
|
||||
c{0: 4 (((break-if)) ((4 boolean))) -- ((open 3))
|
||||
c{0: 5 (((5 integer)) <- ((copy)) ((0 literal))) -- ((open 3))
|
||||
c{0: 6 (((reply))) -- ((close 6) (open 3))
|
||||
c{1: 0 ✓ (((1 integer)) <- ((copy)) ((0 literal)))
|
||||
c{1: 1 ✓ (((2 integer)) <- ((copy)) ((0 literal)))
|
||||
c{1: 2 ✓ (((3 integer)) <- ((copy)) ((0 literal)))
|
||||
c{1: 3 ✓ (((4 boolean)) <- ((not-equal)) ((1 integer)) ((3 integer)))
|
||||
c{1: 4 X (((break-if)) ((4 boolean))) => (((jump-if)) ((4 boolean)) ((1 offset)))
|
||||
c{1: 5 ✓ (((5 integer)) <- ((copy)) ((0 literal)))
|
||||
c{1: 6 ✓ (((reply)))
|
||||
|
|
@ -0,0 +1,10 @@
|
|||
c{0: 0 (((1 integer)) <- ((copy)) ((0 literal))) -- nil
|
||||
c{0: 1 (((2 integer)) <- ((copy)) ((0 literal))) -- nil
|
||||
c{0: 2 (((3 integer)) <- ((copy)) ((0 literal))) -- nil
|
||||
c{0: 3 (((break))) -- ((open 3))
|
||||
c{0: 4 (((reply))) -- ((close 4) (open 3))
|
||||
c{1: 0 ✓ (((1 integer)) <- ((copy)) ((0 literal)))
|
||||
c{1: 1 ✓ (((2 integer)) <- ((copy)) ((0 literal)))
|
||||
c{1: 2 ✓ (((3 integer)) <- ((copy)) ((0 literal)))
|
||||
c{1: 3 X (((break))) => (((jump)) ((0 offset)))
|
||||
c{1: 4 ✓ (((reply)))
|
||||
|
|
@ -0,0 +1,5 @@
|
|||
c{0: 0 (((1 integer)) <- ((copy)) ((0 literal))) -- nil
|
||||
c{0: 1 foo -- nil
|
||||
c{0: 2 (((2 integer)) <- ((copy)) ((0 literal))) -- nil
|
||||
c{1: 0 ✓ (((1 integer)) <- ((copy)) ((0 literal)))
|
||||
c{1: 2 ✓ (((2 integer)) <- ((copy)) ((0 literal)))
|
||||
|
|
@ -0,0 +1,7 @@
|
|||
c{0: 0 (((1 integer)) <- ((copy)) ((0 literal))) -- nil
|
||||
c{0: 1 (((break))) -- ((open 1))
|
||||
c{0: 2 foo -- ((open 1))
|
||||
c{0: 3 (((2 integer)) <- ((copy)) ((0 literal))) -- ((close 3) (open 1))
|
||||
c{1: 0 ✓ (((1 integer)) <- ((copy)) ((0 literal)))
|
||||
c{1: 1 X (((break))) => (((jump)) ((1 offset)))
|
||||
c{1: 3 ✓ (((2 integer)) <- ((copy)) ((0 literal)))
|
||||
|
|
@ -0,0 +1,13 @@
|
|||
c{0: 0 (((1 integer)) <- ((copy)) ((0 literal))) -- nil
|
||||
c{0: 1 (((break))) -- ((open 1))
|
||||
c{0: 2 foo -- ((open 1))
|
||||
c{0: 3 (((2 integer)) <- ((copy)) ((0 literal))) -- ((close 3) (open 1))
|
||||
c{0: 4 (((break))) -- ((open 4) (close 3) (open 1))
|
||||
c{0: 5 (((3 integer)) <- ((copy)) ((0 literal))) -- ((open 4) (close 3) (open 1))
|
||||
c{0: 6 (((4 integer)) <- ((copy)) ((0 literal))) -- ((close 6) (open 4) (close 3) (open 1))
|
||||
c{1: 0 ✓ (((1 integer)) <- ((copy)) ((0 literal)))
|
||||
c{1: 1 X (((break))) => (((jump)) ((1 offset)))
|
||||
c{1: 3 ✓ (((2 integer)) <- ((copy)) ((0 literal)))
|
||||
c{1: 4 X (((break))) => (((jump)) ((1 offset)))
|
||||
c{1: 5 ✓ (((3 integer)) <- ((copy)) ((0 literal)))
|
||||
c{1: 6 ✓ (((4 integer)) <- ((copy)) ((0 literal)))
|
||||
|
|
@ -0,0 +1,14 @@
|
|||
c{0: 0 (((1 integer)) <- ((copy)) ((0 literal))) -- nil
|
||||
c{0: 1 (((2 integer)) <- ((copy)) ((0 literal))) -- nil
|
||||
c{0: 2 (((3 integer)) <- ((copy)) ((0 literal))) -- nil
|
||||
c{0: 3 (((4 boolean)) <- ((not-equal)) ((1 integer)) ((3 integer))) -- ((open 3))
|
||||
c{0: 4 (((break-if)) ((4 boolean))) -- ((open 3))
|
||||
c{0: 5 (((5 integer)) <- ((copy)) ((0 literal))) -- ((open 5) (open 3))
|
||||
c{0: 6 (((reply))) -- ((close 6) (close 6) (open 5) (open 3))
|
||||
c{1: 0 ✓ (((1 integer)) <- ((copy)) ((0 literal)))
|
||||
c{1: 1 ✓ (((2 integer)) <- ((copy)) ((0 literal)))
|
||||
c{1: 2 ✓ (((3 integer)) <- ((copy)) ((0 literal)))
|
||||
c{1: 3 ✓ (((4 boolean)) <- ((not-equal)) ((1 integer)) ((3 integer)))
|
||||
c{1: 4 X (((break-if)) ((4 boolean))) => (((jump-if)) ((4 boolean)) ((1 offset)))
|
||||
c{1: 5 ✓ (((5 integer)) <- ((copy)) ((0 literal)))
|
||||
c{1: 6 ✓ (((reply)))
|
||||
|
|
@ -0,0 +1,14 @@
|
|||
c{0: 0 (((1 integer)) <- ((copy)) ((0 literal))) -- nil
|
||||
c{0: 1 (((2 integer)) <- ((copy)) ((0 literal))) -- nil
|
||||
c{0: 2 (((3 integer)) <- ((copy)) ((0 literal))) -- ((open 2))
|
||||
c{0: 3 (((4 boolean)) <- ((not-equal)) ((1 integer)) ((3 integer))) -- ((open 3) (open 2))
|
||||
c{0: 4 (((loop-if)) ((4 boolean))) -- ((close 4) (open 3) (open 2))
|
||||
c{0: 5 (((5 integer)) <- ((copy)) ((0 literal))) -- ((close 4) (open 3) (open 2))
|
||||
c{0: 6 (((reply))) -- ((close 6) (close 4) (open 3) (open 2))
|
||||
c{1: 0 ✓ (((1 integer)) <- ((copy)) ((0 literal)))
|
||||
c{1: 1 ✓ (((2 integer)) <- ((copy)) ((0 literal)))
|
||||
c{1: 2 ✓ (((3 integer)) <- ((copy)) ((0 literal)))
|
||||
c{1: 3 ✓ (((4 boolean)) <- ((not-equal)) ((1 integer)) ((3 integer)))
|
||||
c{1: 4 X (((loop-if)) ((4 boolean))) => (((jump-if)) ((4 boolean)) ((-3 offset)))
|
||||
c{1: 5 ✓ (((5 integer)) <- ((copy)) ((0 literal)))
|
||||
c{1: 6 ✓ (((reply)))
|
||||
|
|
@ -0,0 +1,12 @@
|
|||
c{0: 0 (((1 integer)) <- ((copy)) ((0 literal))) -- nil
|
||||
c{0: 1 (((break))) -- ((open 1))
|
||||
c{0: 2 (((2 integer)) <- ((copy)) ((0 literal))) -- ((open 1))
|
||||
c{0: 3 (((break))) -- ((open 3) (close 3) (open 1))
|
||||
c{0: 4 (((3 integer)) <- ((copy)) ((0 literal))) -- ((open 3) (close 3) (open 1))
|
||||
c{0: 5 (((4 integer)) <- ((copy)) ((0 literal))) -- ((close 5) (open 3) (close 3) (open 1))
|
||||
c{1: 0 ✓ (((1 integer)) <- ((copy)) ((0 literal)))
|
||||
c{1: 1 X (((break))) => (((jump)) ((1 offset)))
|
||||
c{1: 2 ✓ (((2 integer)) <- ((copy)) ((0 literal)))
|
||||
c{1: 3 X (((break))) => (((jump)) ((1 offset)))
|
||||
c{1: 4 ✓ (((3 integer)) <- ((copy)) ((0 literal)))
|
||||
c{1: 5 ✓ (((4 integer)) <- ((copy)) ((0 literal)))
|
||||
|
|
@ -0,0 +1,19 @@
|
|||
cn0: convert-names in
|
||||
cn0: (((x integer)) <- ((copy)) ((0 literal))) nil nil
|
||||
cn0: checking arg ((0 literal))
|
||||
cn0: checking oarg ((x integer))
|
||||
maybe-add: ((x integer))
|
||||
cn0: location for oarg ((x integer)): 1
|
||||
cn0: (((y integer)) <- ((copy)) ((0 literal))) ((x 1)) nil
|
||||
cn0: checking arg ((0 literal))
|
||||
cn0: checking oarg ((y integer))
|
||||
maybe-add: ((y integer))
|
||||
cn0: location for oarg ((y integer)): 2
|
||||
cn0: (((z integer)) <- ((copy)) ((0 literal))) ((x 1) (y 2)) nil
|
||||
cn0: checking arg ((0 literal))
|
||||
cn0: checking oarg ((z integer))
|
||||
maybe-add: ((z integer))
|
||||
cn0: location for oarg ((z integer)): 3
|
||||
cn1: (((1 integer)) <- ((copy)) ((0 literal)))
|
||||
cn1: (((2 integer)) <- ((copy)) ((0 literal)))
|
||||
cn1: (((3 integer)) <- ((copy)) ((0 literal)))
|
||||
|
|
@ -0,0 +1,13 @@
|
|||
cn0: convert-names in
|
||||
cn0: (((x integer-boolean-pair)) <- ((copy)) ((0 literal))) nil nil
|
||||
cn0: checking arg ((0 literal))
|
||||
cn0: checking oarg ((x integer-boolean-pair))
|
||||
maybe-add: ((x integer-boolean-pair))
|
||||
cn0: location for oarg ((x integer-boolean-pair)): 1
|
||||
cn0: (((y integer)) <- ((copy)) ((0 literal))) ((x 1)) nil
|
||||
cn0: checking arg ((0 literal))
|
||||
cn0: checking oarg ((y integer))
|
||||
maybe-add: ((y integer))
|
||||
cn0: location for oarg ((y integer)): 3
|
||||
cn1: (((1 integer-boolean-pair)) <- ((copy)) ((0 literal)))
|
||||
cn1: (((3 integer)) <- ((copy)) ((0 literal)))
|
||||
|
|
@ -0,0 +1,21 @@
|
|||
cn0: convert-names in
|
||||
cn0: (((x integer)) <- ((copy)) ((4 literal))) nil nil
|
||||
cn0: checking arg ((4 literal))
|
||||
cn0: checking oarg ((x integer))
|
||||
maybe-add: ((x integer))
|
||||
cn0: location for oarg ((x integer)): 1
|
||||
cn0: (((y integer)) <- ((copy)) ((2 literal))) ((x 1)) nil
|
||||
cn0: checking arg ((2 literal))
|
||||
cn0: checking oarg ((y integer))
|
||||
maybe-add: ((y integer))
|
||||
cn0: location for oarg ((y integer)): 2
|
||||
cn0: (((default-space integer)) <- ((add)) ((x integer)) ((y integer))) ((x 1) (y 2)) nil
|
||||
cn0: checking arg ((x integer))
|
||||
maybe-add: ((x integer))
|
||||
cn0: checking arg ((y integer))
|
||||
maybe-add: ((y integer))
|
||||
cn0: checking oarg ((default-space integer))
|
||||
maybe-add: ((default-space integer))
|
||||
cn1: (((1 integer)) <- ((copy)) ((4 literal)))
|
||||
cn1: (((2 integer)) <- ((copy)) ((2 literal)))
|
||||
cn1: (((default-space integer)) <- ((add)) ((1 integer)) ((2 integer)))
|
||||
|
|
@ -0,0 +1,18 @@
|
|||
cn0: convert-names in
|
||||
cn0: (((x integer)) <- ((copy)) ((0 literal))) nil nil
|
||||
cn0: checking arg ((0 literal))
|
||||
cn0: checking oarg ((x integer))
|
||||
maybe-add: ((x integer))
|
||||
cn0: location for oarg ((x integer)): 1
|
||||
cn0: (((y integer)) <- ((copy)) ((0 literal))) ((x 1)) nil
|
||||
cn0: checking arg ((0 literal))
|
||||
cn0: checking oarg ((y integer))
|
||||
maybe-add: ((y integer))
|
||||
cn0: location for oarg ((y integer)): 2
|
||||
cn0: (((z fn)) <- ((copy)) ((0 literal))) ((x 1) (y 2)) nil
|
||||
cn0: checking arg ((0 literal))
|
||||
cn0: checking oarg ((z fn))
|
||||
maybe-add: ((z fn))
|
||||
cn1: (((1 integer)) <- ((copy)) ((0 literal)))
|
||||
cn1: (((2 integer)) <- ((copy)) ((0 literal)))
|
||||
cn1: (((z fn)) <- ((copy)) ((0 literal)))
|
||||
|
|
@ -0,0 +1,7 @@
|
|||
cn0: convert-names in
|
||||
cn0: (((1 integer)) <- ((copy)) ((0 literal))) nil nil
|
||||
cn0: checking arg ((0 literal))
|
||||
cn0: checking oarg ((1 integer))
|
||||
maybe-add: ((1 integer))
|
||||
cn1: (((1 integer)) <- ((copy)) ((0 literal)))
|
||||
cn1: foo
|
||||
|
|
@ -0,0 +1,6 @@
|
|||
cn0: convert-names in
|
||||
cn0: (((x literal)) <- ((copy)) ((0 literal))) nil nil
|
||||
cn0: checking arg ((0 literal))
|
||||
cn0: checking oarg ((x literal))
|
||||
maybe-add: ((x literal))
|
||||
cn1: (((x literal)) <- ((copy)) ((0 literal)))
|
||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue