Update example disassemblies

[bpt/guile.git] / doc / ref / vm.texi

diff --git a/doc/ref/vm.texi b/doc/ref/vm.texi
index 6a7a0a9..2c279bf 100644 (file)
--- a/doc/ref/vm.texi
+++ b/doc/ref/vm.texi
@@ -309,31 +309,27 @@ We can see how these concepts tie together by disassembling the
 @smallexample
 scheme@@(guile-user)> (define (foo a) (lambda (b) (list foo a b)))
 scheme@@(guile-user)> ,x foo
-Disassembly of #<procedure foo (a)>:
-
-   0    (assert-nargs-ee 0 1)           
-   3    (reserve-locals 0 1)            
-   6    (object-ref 1)                  ;; #<procedure 85bfec0 at <current input>:0:16 (b)>
-   8    (local-ref 0)                   ;; `a'
-  10    (make-closure 0 1)              
-  13    (return)                        
+   0    (assert-nargs-ee/locals 1)      
+   2    (object-ref 1)                  ;; #<procedure 8ebec20 at <current input>:0:17 (b)>
+   4    (local-ref 0)                   ;; `a'
+   6    (make-closure 0 1)              
+   9    (return)                        
 
 ----------------------------------------
-Disassembly of #<procedure 85bfec0 at <current input>:0:16 (b)>:
-
-   0    (assert-nargs-ee 0 1)           
-   3    (reserve-locals 0 1)            
-   6    (toplevel-ref 1)                ;; `foo'
-   8    (free-ref 0)                    ;; (closure variable)
-  10    (local-ref 0)                   ;; `b'
-  12    (list 0 3)                      ;; 3 elements         at (unknown file):0:28
-  15    (return)                        
+Disassembly of #<procedure 8ebec20 at <current input>:0:17 (b)>:
+
+   0    (assert-nargs-ee/locals 1)      
+   2    (toplevel-ref 1)                ;; `foo'
+   4    (free-ref 0)                    ;; (closure variable)
+   6    (local-ref 0)                   ;; `b'
+   8    (list 0 3)                      ;; 3 elements         at (unknown file):0:29
+  11    (return)                        
 @end smallexample
 
 First there's some prelude, where @code{foo} checks that it was called with only
-1 argument. Then at @code{ip} 6, we load up the compiled lambda. @code{Ip} 8
+1 argument. Then at @code{ip} 2, we load up the compiled lambda. @code{Ip} 4
 loads up `a', so that it can be captured into a closure by at @code{ip}
-10---binding code (from the compiled lambda) with data (the free-variable
+6---binding code (from the compiled lambda) with data (the free-variable
 vector). Finally we return the closure.
 
 The second stanza disassembles the compiled lambda. After the prelude, we note