5876 - address -> addr

16 files changed, 182 insertions, 182 deletions

diff --git a/apps/assort.subx b/apps/assort.subx
index 0aa18555..87a940cb 100644
--- a/apps/assort.subx
+++ b/apps/assort.subx
@@ -83,12 +83,12 @@ $subx-assort-main:end:
     cd/syscall  0x80/imm8
 
 # data structure:
-#   table: (address stream {string, (address stream byte)})     (8 bytes per row)
+#   table: (addr stream {string, (addr stream byte)})     (8 bytes per row)
 # inefficient; uses sequential search for looking up segments by name
 
-subx-assort:  # in : (address buffered-file), out : (address buffered-file)
+subx-assort:  # in : (addr buffered-file), out : (addr buffered-file)
     # pseudocode:
-    #   var table : (address stream {string, (address stream byte)} 10/rows)
+    #   var table : (addr stream {string, (addr stream byte)} 10/rows)
     #   read-segments(in, table)
     #   write-segments(out, table)
     #
@@ -97,7 +97,7 @@ subx-assort:  # in : (address buffered-file), out : (address buffered-file)
     89/copy                         3/mod/direct    5/rm32/ebp    .           .             .           4/r32/esp   .               .                 # copy esp to ebp
     # . save registers
     51/push-ecx
-    # var table/ecx : (ref stream {string, (address stream byte)} 80)  # 10 rows * 8 bytes/row
+    # var table/ecx : (ref stream {string, (addr stream byte)} 80)  # 10 rows * 8 bytes/row
     81          5/subop/subtract    3/mod/direct    4/rm32/esp    .           .             .           .           .               0x50/imm32        # subtract from esp
     68/push  0x50/imm32/length
     68/push  0/imm32/read
@@ -450,10 +450,10 @@ test-subx-assort:
     5d/pop-to-ebp
     c3/return
 
-# type string_key = (address array byte)
+# type string_key = (addr array byte)
 
 # beware: leaks memory (one name per segment read)
-read-segments:  # in : (address buffered-file), table : (address stream {string_key, (handle stream byte)})
+read-segments:  # in : (addr buffered-file), table : (addr stream {string_key, (handle stream byte)})
     # pseudocode:
     #   var curr-segment : (handle stream byte) = 0
     #   var line : (stream byte 512)
@@ -599,7 +599,7 @@ $read-segments:check-for-comment:
 #?     81          0/subop/add         3/mod/direct    4/rm32/esp    .           .             .           .           .               8/imm32           # add to esp
 #?     # }}}
     # if (slice-starts-with?(word-slice, "#")) continue
-    # . var start/esi : (address byte) = word-slice->start
+    # . var start/esi : (addr byte) = word-slice->start
     8b/copy                         0/mod/indirect  2/rm32/edx    .           .             .           6/r32/esi   .               .                 # copy *ecx to esi
     # . var c/eax : byte = *start
     31/xor                          3/mod/direct    0/rm32/eax    .           .             .           0/r32/eax   .               .                 # clear eax
@@ -717,7 +717,7 @@ $read-segments:check-for-segment-header:
 #?     # . . discard args
 #?     81          0/subop/add         3/mod/direct    4/rm32/esp    .           .             .           .           .               8/imm32           # add to esp
 #?     # }}}
-    # var segment-slot/eax : (address handle stream byte) = leaky-get-or-insert-slice(table, segment-name, row-size=8)
+    # var segment-slot/eax : (addr handle stream byte) = leaky-get-or-insert-slice(table, segment-name, row-size=8)
     # . . push args
     68/push  8/imm32/row-size
     52/push-edx
@@ -843,7 +843,7 @@ $read-segments:end:
     5d/pop-to-ebp
     c3/return
 
-write-segments:  # out : (address buffered-file), table : (address stream {string_key, (handle stream byte)})
+write-segments:  # out : (addr buffered-file), table : (addr stream {string_key, (handle stream byte)})
     # pseudocode:
     #   var curr = table->data
     #   var max = &table->data[table->write]
@@ -864,15 +864,15 @@ write-segments:  # out : (address buffered-file), table : (address stream {strin
     8b/copy                         1/mod/*+disp8   5/rm32/ebp    .           .             .           6/r32/esi   0xc/disp8       .                 # copy *(ebp+12) to esi
     # var write/edx : int = table->write
     8b/copy                         0/mod/indirect  6/rm32/esi    .           .             .           2/r32/edx   .               .                 # copy *esi to edx
-    # var curr/esi : (address byte) = table->data
+    # var curr/esi : (addr byte) = table->data
     81          0/subop/add         3/mod/direct    6/rm32/esi    .           .             .           .           .               0xc/imm32         # add to eax
-    # var max/edx : (address byte) = curr + write
+    # var max/edx : (addr byte) = curr + write
     01/add                          3/mod/direct    2/rm32/edx    .           .             .           6/r32/esi   .               .                 # add esi to edx
 $write-segments:loop:
     # if (curr >= max) break
     39/compare                      3/mod/direct    6/rm32/esi    .           .             .           2/r32/edx   .               .                 # compare esi with edx
     73/jump-if-greater-or-equal-unsigned  $write-segments:break/disp8
-    # var stream/eax : (address stream byte) = table[i].stream
+    # var stream/eax : (addr stream byte) = table[i].stream
     8b/copy                         1/mod/*+disp8   6/rm32/esi    .           .             .           0/r32/eax   4/disp8         .                 # copy *(esi+4) to eax
     # write-stream-data(out, stream)
     # . . push args
diff --git a/apps/braces.subx b/apps/braces.subx
index 95b6a7ea..44e931a7 100644
--- a/apps/braces.subx
+++ b/apps/braces.subx
@@ -75,7 +75,7 @@ $subx-braces-main:end:
     b8/copy-to-eax 1/imm32/exit
     cd/syscall 0x80/imm8
 
-subx-braces:  # in : (address buffered-file), out : (address buffered-file)
+subx-braces:  # in : (addr buffered-file), out : (addr buffered-file)
     # pseudocode:
     #   var line : (ref stream byte 512)
     #   var label-stack : (stack int 32)  # at most 32 levels of nesting
@@ -95,7 +95,7 @@ subx-braces:  # in : (address buffered-file), out : (address buffered-file)
     #       print(out, "_break" top ":\n")
     #       continue
     #     while true
-    #       var word-slice : (address slice) = next-word-or-string(line)
+    #       var word-slice : (addr slice) = next-word-or-string(line)
     #       if slice-empty?(word-slice)                         # end of line
     #         break
     #       if slice-starts-with?(word-slice, "#")              # comment
diff --git a/apps/calls.subx b/apps/calls.subx
index 0e4d113e..a4615297 100644
--- a/apps/calls.subx
+++ b/apps/calls.subx
@@ -75,7 +75,7 @@ $subx-calls-main:end:
     b8/copy-to-eax 1/imm32/exit
     cd/syscall 0x80/imm8
 
-subx-calls:  # in : (address buffered-file), out : (address buffered-file)
+subx-calls:  # in : (addr buffered-file), out : (addr buffered-file)
     # pseudocode:
     #   var line : (ref stream byte 512)
     #   var words : (ref stream slice 16)  # at most function name and 15 args
@@ -231,7 +231,7 @@ $subx-calls:end:
     5d/pop-to-ebp
     c3/return
 
-parse-line:  # line : (address stream byte), words : (address stream slice)
+parse-line:  # line : (addr stream byte), words : (addr stream slice)
     # pseudocode:
     #   var word-slice : (ref slice)
     #   while true
@@ -340,7 +340,7 @@ $parse-line:end:
     5d/pop-to-ebp
     c3/return
 
-emit-call:  # out : (address buffered-file), words : (address stream slice)
+emit-call:  # out : (addr buffered-file), words : (addr stream slice)
     # pseudocode:
     #   if (words->write < 8) abort
     #   curr = &words->data[words->write-8]
@@ -381,9 +381,9 @@ emit-call:  # out : (address buffered-file), words : (address stream slice)
     8b/-> *esi 1/r32/ecx
     81 5/subop/subtract %ecx 8/imm32
     0f 8c/jump-if-lesser $emit-call:error1/disp32
-    # var curr/ecx : (address slice) = &words->data[words->write-8]
+    # var curr/ecx : (addr slice) = &words->data[words->write-8]
     8d/copy-address *(esi+ecx+0xc) 1/r32/ecx
-    # var min/edx : (address byte) = words->data
+    # var min/edx : (addr byte) = words->data
     8d/copy-address *(esi+0xc) 2/r32/edx
     # - emit pushes
 $emit-call:push-loop:
@@ -391,7 +391,7 @@ $emit-call:push-loop:
     39/compare %ecx 2/r32/edx
     0f 8e/jump-if-lesser-or-equal $emit-call:call-instruction/disp32
     # if (*curr->start in '%' '*') goto push-rm32
-    # . var start/eax : (address byte) = curr->start
+    # . var start/eax : (addr byte) = curr->start
     8b/-> *ecx 0/r32/eax
     # . var c/eax : byte = *eax
     8b/-> *eax 0/r32/eax
@@ -741,7 +741,7 @@ test-subx-calls-processes-calls:
     5d/pop-to-ebp
     c3/return
 
-next-word-string-or-expression-without-metadata:  # line : (address stream byte), out : (address slice)
+next-word-string-or-expression-without-metadata:  # line : (addr stream byte), out : (addr slice)
     # pseudocode:
     #   skip-chars-matching(line, ' ')
     #   if line->read >= line->write              # end of line
diff --git a/apps/crenshaw2-1.subx b/apps/crenshaw2-1.subx
index 228f4696..c1dd79a7 100644
--- a/apps/crenshaw2-1.subx
+++ b/apps/crenshaw2-1.subx
@@ -90,7 +90,7 @@ $main:end:
     cd/syscall  0x80/imm8
 
 # the main entry point
-compile:  # in : (address buffered-file), out : fd or (address stream byte), err : fd or (address stream byte), ed : (address exit-descriptor)
+compile:  # in : (addr buffered-file), out : fd or (addr stream byte), err : fd or (addr stream byte), ed : (addr exit-descriptor)
     # . prologue
     55/push-ebp
     89/copy                         3/mod/direct    5/rm32/ebp    .           .             .           4/r32/esp   .               .                 # copy esp to ebp
@@ -191,7 +191,7 @@ $compile:end:
 # space in 'out'.
 # Input comes from the global variable 'Look' (first byte) and the argument
 # 'in' (rest). We leave the next byte from 'in' into 'Look' on exit.
-get-num:  # in : (address buffered-file), out : (address stream byte), err : fd or (address stream byte), ed : (address exit-descriptor)
+get-num:  # in : (addr buffered-file), out : (addr stream byte), err : fd or (addr stream byte), ed : (addr exit-descriptor)
     # pseudocode:
     #   if (!is-digit?(Look)) expected(ed, err, "integer")
     #   if out->write >= out->length
@@ -470,7 +470,7 @@ test-get-num-aborts-on-non-digit-in-Look:
 ## helpers
 
 # write(f, "Error: "+s+" expected\n") then stop(ed, 1)
-expected:  # ed : (address exit-descriptor), f : fd or (address stream byte), s : (address array byte)
+expected:  # ed : (addr exit-descriptor), f : fd or (addr stream byte), s : (addr array byte)
     # . prologue
     55/push-ebp
     89/copy                         3/mod/direct    5/rm32/ebp    .           .             .           4/r32/esp   .               .                 # copy esp to ebp
@@ -512,7 +512,7 @@ $expected:dead-end:
     c3/return
 
 # read a byte from 'f', and save it in 'Look'
-get-char:  # f : (address buffered-file)
+get-char:  # f : (addr buffered-file)
     # . prologue
     55/push-ebp
     89/copy                         3/mod/direct    5/rm32/ebp    .           .             .           4/r32/esp   .               .                 # copy esp to ebp
diff --git a/apps/crenshaw2-1b.subx b/apps/crenshaw2-1b.subx
index 374625e9..8efd9ca4 100644
--- a/apps/crenshaw2-1b.subx
+++ b/apps/crenshaw2-1b.subx
@@ -90,7 +90,7 @@ $main:end:
     cd/syscall  0x80/imm8
 
 # the main entry point
-compile:  # in : (address buffered-file), out : fd or (address stream byte), err : fd or (address stream byte), ed : (address exit-descriptor)
+compile:  # in : (addr buffered-file), out : fd or (addr stream byte), err : fd or (addr stream byte), ed : (addr exit-descriptor)
     # . prologue
     55/push-ebp
     89/copy                         3/mod/direct    5/rm32/ebp    .           .             .           4/r32/esp   .               .                 # copy esp to ebp
@@ -191,7 +191,7 @@ $compile:end:
 # no space in 'out'.
 # Input comes from the global variable 'Look' (first byte) and the argument
 # 'in' (rest). We leave the next byte from 'in' into 'Look' on exit.
-get-num:  # in : (address buffered-file), out : (address stream byte), err : fd or (address stream byte), ed : (address exit-descriptor)
+get-num:  # in : (addr buffered-file), out : (addr stream byte), err : fd or (addr stream byte), ed : (addr exit-descriptor)
     # pseudocode:
     #   if (!is-digit?(Look)) expected(ed, err, "integer")
     #   do
@@ -664,7 +664,7 @@ test-get-num-reads-multiple-digits-followed-by-nondigit:
 ## helpers
 
 # write(f, "Error: "+s+" expected\n") then stop(ed, 1)
-expected:  # ed : (address exit-descriptor), f : fd or (address stream byte), s : (address array byte)
+expected:  # ed : (addr exit-descriptor), f : fd or (addr stream byte), s : (addr array byte)
     # . prologue
     55/push-ebp
     89/copy                         3/mod/direct    5/rm32/ebp    .           .             .           4/r32/esp   .               .                 # copy esp to ebp
@@ -706,7 +706,7 @@ $expected:dead-end:
     c3/return
 
 # read a byte from 'f', and save it in 'Look'
-get-char:  # f : (address buffered-file)
+get-char:  # f : (addr buffered-file)
     # . prologue
     55/push-ebp
     89/copy                         3/mod/direct    5/rm32/ebp    .           .             .           4/r32/esp   .               .                 # copy esp to ebp
diff --git a/apps/dquotes.subx b/apps/dquotes.subx
index 4b985fbb..3f3fa452 100644
--- a/apps/dquotes.subx
+++ b/apps/dquotes.subx
@@ -82,7 +82,7 @@ $subx-dquotes-main:end:
 #   line = words separated by ' ', maybe followed by comment starting with '#'
 #   word = datum until '/', then 0 or more metadata separated by '/'
 
-subx-dquotes:  # in : (address buffered-file), out : (address buffered-file)
+subx-dquotes:  # in : (addr buffered-file), out : (addr buffered-file)
     # pseudocode:
     #   var line : (ref stream byte 512)
     #   var new-data-segment : (handle stream byte) = new-stream(Heap, Segment-size, 1)
@@ -198,7 +198,7 @@ $subx-dquotes:check1:
     0f 85/jump-if-not-equal  $subx-dquotes:next-line/disp32
 $subx-dquotes:check-for-comment:
     # if (slice-starts-with?(word-slice, "#")) continue
-    # . var start/esi : (address byte) = word-slice->start
+    # . var start/esi : (addr byte) = word-slice->start
     8b/copy                         0/mod/indirect  2/rm32/edx    .           .             .           6/r32/esi   .               .                 # copy *edx to esi
     # . var c/eax : byte = *start
     31/xor                          3/mod/direct    0/rm32/eax    .           .             .           0/r32/eax   .               .                 # clear eax
@@ -287,7 +287,7 @@ $subx-dquotes:end:
 
 # Write out 'string-literal' in a new format to 'out-segment', assign it a new
 # label, and write the new label out to 'out'.
-process-string-literal:  # string-literal : (address slice), out : (address buffered-file), out-segment : (address stream byte)
+process-string-literal:  # string-literal : (addr slice), out : (addr buffered-file), out-segment : (addr stream byte)
     # pseudocode:
     #   print(out-segment, "_string#{Next-string-literal}:\n")
     #   emit-string-literal-data(out-segment, string-literal)
@@ -846,7 +846,7 @@ test-subx-dquotes-processes-string-literals:
     c3/return
 
 # generate the data segment contents byte by byte for a given slice
-emit-string-literal-data:  # out : (address stream byte), word : (address slice)
+emit-string-literal-data:  # out : (addr stream byte), word : (addr slice)
     # pseudocode
     #   len = string-length-at-start-of-slice(word->start, word->end)
     #   print(out, "#{len}/imm32 ")
@@ -887,9 +887,9 @@ emit-string-literal-data:  # out : (address stream byte), word : (address slice)
     8b/copy                         1/mod/*+disp8   5/rm32/ebp    .           .             .           6/r32/esi   0xc/disp8       .                 # copy *(ebp+12) to esi
     # var idx/ebx : int = 0
     31/xor                          3/mod/direct    3/rm32/ebx    .           .             .           3/r32/ebx   .               .                 # clear ebx
-    # var curr/edx : (address byte) = word->start
+    # var curr/edx : (addr byte) = word->start
     8b/copy                         0/mod/indirect  6/rm32/esi    .           .             .           2/r32/edx   .               .                 # copy *esi to edx
-    # var max/esi : (address byte) = word->end
+    # var max/esi : (addr byte) = word->end
     8b/copy                         1/mod/*+disp8   6/rm32/esi    .           .             .           6/r32/esi   4/disp8         .                 # copy *(esi+4) to esi
 $emit-string-literal-data:emit-length:
     # var len/eax : int = string-length-at-start-of-slice(word->start, word->end)
@@ -1379,7 +1379,7 @@ test-emit-string-literal-data-handles-newline-escape:
     c3/return
 
 # emit everything from a word except the initial datum
-emit-metadata:  # out : (address buffered-file), word : (address slice)
+emit-metadata:  # out : (addr buffered-file), word : (addr slice)
     # pseudocode
     #   var slice : (ref slice) = {0, word->end}
     #   curr = word->start
@@ -1406,9 +1406,9 @@ emit-metadata:  # out : (address buffered-file), word : (address slice)
     56/push-esi
     # esi = word
     8b/copy                         1/mod/*+disp8   5/rm32/ebp    .           .             .           6/r32/esi   0xc/disp8       .                 # copy *(ebp+12) to esi
-    # var curr/ecx : (address byte) = word->start
+    # var curr/ecx : (addr byte) = word->start
     8b/copy                         0/mod/indirect  6/rm32/esi    .           .             .           1/r32/ecx   .               .                 # copy *esi to ecx
-    # var end/edx : (address byte) = word->end
+    # var end/edx : (addr byte) = word->end
     8b/copy                         1/mod/*+disp8   6/rm32/esi    .           .             .           2/r32/edx   4/disp8         .                 # copy *(esi+4) to edx
     # var slice/ebx : (ref slice) = {0, end}
     52/push-edx
@@ -1778,7 +1778,7 @@ test-emit-metadata-in-string-literal:
     5d/pop-to-ebp
     c3/return
 
-string-length-at-start-of-slice:  # curr : (address byte), end : (address byte) -> length/eax
+string-length-at-start-of-slice:  # curr : (addr byte), end : (addr byte) -> length/eax
     # . prologue
     55/push-ebp
     89/copy                         3/mod/direct    5/rm32/ebp    .           .             .           4/r32/esp   .               .                 # copy esp to ebp
diff --git a/apps/ex11.subx b/apps/ex11.subx
index b235927d..2469542d 100644
--- a/apps/ex11.subx
+++ b/apps/ex11.subx
@@ -258,7 +258,7 @@ test-compare-kernel-string-with-longer-array:
 # - helpers
 
 # print msg to stderr if a != b, otherwise print "."
-check-ints-equal:  # (a : int, b : int, msg : (address array byte)) -> boolean
+check-ints-equal:  # (a : int, b : int, msg : (addr array byte)) -> boolean
     # . prologue
     55/push-ebp
     89/copy                         3/mod/direct    5/rm32/ebp    .           .             .           4/r32/esp   .               .                 # copy esp to ebp
@@ -307,7 +307,7 @@ $check-ints-equal:end:
     5d/pop-to-ebp
     c3/return
 
-write-stderr:  # s : (address array byte) -> <void>
+write-stderr:  # s : (addr array byte) -> <void>
     # . prologue
     55/push-ebp
     89/copy                         3/mod/direct    5/rm32/ebp    .           .             .           4/r32/esp   .               .                 # copy esp to ebp
diff --git a/apps/ex8.subx b/apps/ex8.subx
index 0e44a883..2ea653f1 100644
--- a/apps/ex8.subx
+++ b/apps/ex8.subx
@@ -34,7 +34,7 @@ Entry:
     89/copy                         3/mod/direct    3/rm32/ebx    .           .             .           0/r32/eax   .               .                 # copy eax to ebx
     e8/call  syscall_exit/disp32
 
-ascii-length:  # s : (address array byte) -> n/eax
+ascii-length:  # s : (addr array byte) -> n/eax
     # edx = s
     8b/copy                         1/mod/*+disp8   4/rm32/sib    4/base/esp  4/index/none  .           2/r32/edx   4/disp8         .                 # copy *(esp+4) to edx
     # var result/eax = 0
diff --git a/apps/handle.subx b/apps/handle.subx
index 07611596..fba9db1c 100644
--- a/apps/handle.subx
+++ b/apps/handle.subx
@@ -44,7 +44,7 @@ $handle-main:end:
     b8/copy-to-eax  1/imm32/exit
     cd/syscall  0x80/imm8
 
-new:  # ad : (address allocation-descriptor), n : int, out : (handle _)
+new:  # ad : (addr allocation-descriptor), n : int, out : (handle _)
     # . prologue
     55/push-ebp
     89/copy                         3/mod/direct    5/rm32/ebp    .           .             .           4/r32/esp   .               .                 # copy esp to ebp
@@ -221,7 +221,7 @@ _pending-test-new-failure:
     5d/pop-to-ebp
     c3/return
 
-lookup:  # h : (handle T) -> eax : (address T)
+lookup:  # h : (handle T) -> eax : (addr T)
     # . prologue
     55/push-ebp
     89/copy                         3/mod/direct    5/rm32/ebp    .           .             .           4/r32/esp   .               .                 # copy esp to ebp
diff --git a/apps/hex.subx b/apps/hex.subx
index 09e394bd..d3af0105 100644
--- a/apps/hex.subx
+++ b/apps/hex.subx
@@ -77,7 +77,7 @@ $subx-hex-main:end:
     cd/syscall  0x80/imm8
 
 # the main entry point
-subx-hex:  # in : (address buffered-file), out : (address buffered-file), err : (address buffered-file), ed : (address exit-descriptor)
+subx-hex:  # in : (addr buffered-file), out : (addr buffered-file), err : (addr buffered-file), ed : (addr exit-descriptor)
     # pseudocode:
     #   while true
     #     eax = convert-next-octet(in, err, ed)
@@ -135,7 +135,7 @@ $subx-hex:end:
 # raise an error and abort on all other unexpected bytes
 # return in eax an _octet_ containing the binary value of the two hex characters
 # return Eof on reaching end of file
-convert-next-octet:  # in : (address buffered-file), err : (address buffered-file), ed : (address exit-descriptor) -> byte-or-Eof/eax
+convert-next-octet:  # in : (addr buffered-file), err : (addr buffered-file), ed : (addr exit-descriptor) -> byte-or-Eof/eax
     # pseudocode:
     #   eax = scan-next-byte(in, err, ed)
     #   if (eax == Eof) return
@@ -481,7 +481,7 @@ $test-convert-next-octet-aborts-on-single-hex-byte:end:
 # return Eof if file ends without finding a hex byte
 # on '#' skip all bytes until newline
 # abort on any other byte
-scan-next-byte:  # in : (address buffered-file), err : (address buffered-file), ed : (address exit-descriptor) -> byte-or-Eof/eax
+scan-next-byte:  # in : (addr buffered-file), err : (addr buffered-file), ed : (addr exit-descriptor) -> byte-or-Eof/eax
     # pseudocode:
     #   while true
     #     eax = read-byte-buffered(in)
@@ -1350,7 +1350,7 @@ $test-scan-next-byte-aborts-on-invalid-byte:end:
     5d/pop-to-ebp
     c3/return
 
-skip-until-newline:  # in : (address buffered-file)
+skip-until-newline:  # in : (addr buffered-file)
     # pseudocode:
     #   push eax
     #   while true
diff --git a/apps/mu.subx b/apps/mu.subx
index 7c056d46..534f247d 100644
--- a/apps/mu.subx
+++ b/apps/mu.subx
@@ -246,7 +246,7 @@
 
 == data
 
-Program:  # (address (handle function))
+Program:  # (addr (handle function))
   0/imm32
 
 Function-name:
@@ -378,7 +378,7 @@ $mu-main:end:
     b8/copy-to-eax 1/imm32/exit
     cd/syscall 0x80/imm8
 
-convert-mu:  # in : (address buffered-file), out : (address buffered-file)
+convert-mu:  # in : (addr buffered-file), out : (addr buffered-file)
     # . prologue
     55/push-ebp
     89/<- %ebp 4/r32/esp
@@ -952,9 +952,9 @@ test-convert-function-call-with-literal-arg:
 # Parsing
 #######################################################
 
-parse-mu:  # in : (address buffered-file)
+parse-mu:  # in : (addr buffered-file)
     # pseudocode
-    #   var curr-function : (address (handle function)) = Program
+    #   var curr-function : (addr (handle function)) = Program
     #   var line : (ref stream byte 512)
     #   var word-slice : (ref slice)
     #   while true                                  # line loop
@@ -968,7 +968,7 @@ parse-mu:  # in : (address buffered-file)
     #       continue                                # end of line
     #     else if slice-equal(word-slice, "fn")
     #       var new-function : (handle function) = allocate(function)
-    #       var vars : (ref stack (address var) 256)
+    #       var vars : (ref stack (addr var) 256)
     #       populate-mu-function-header(in, new-function, vars)
     #       populate-mu-function-body(in, new-function, vars)
     #       assert(vars->top == 0)
@@ -996,9 +996,9 @@ parse-mu:  # in : (address buffered-file)
     68/push 0/imm32/end
     68/push 0/imm32/start
     89/<- %edx 4/r32/esp
-    # var curr-function/edi : (address (handle function)) = Program
+    # var curr-function/edi : (addr (handle function)) = Program
     bf/copy-to-edi Program/imm32
-    # var vars/ebx : (ref stack (address var) 256)
+    # var vars/ebx : (ref stack (addr var) 256)
     81 5/subop/subtract %esp 0x400/imm32
     68/push 0x400/imm32/length
     68/push 0/imm32/top
@@ -1100,7 +1100,7 @@ $parse-mu:error2:
 # ✓ fn foo x : int {
 # ✓ fn foo x: int {
 # ✓ fn foo x: int -> y/eax: int {
-populate-mu-function-header:  # first-line : (address stream byte), out : (handle function), vars : (address stack (handle var))
+populate-mu-function-header:  # first-line : (addr stream byte), out : (handle function), vars : (addr stack (handle var))
     # pseudocode:
     #   var name : (ref slice)
     #   next-word(first-line, name)
@@ -1297,7 +1297,7 @@ test-function-header-with-arg:
     2b/subtract-> *Function-size 4/r32/esp
     89/<- %ecx 4/r32/esp
     (zero-out %ecx *Function-size)
-    # var vars/ebx : (ref stack (address var) 16)
+    # var vars/ebx : (ref stack (addr var) 16)
     81 5/subop/subtract %esp 0x10/imm32
     68/push 0x10/imm32/length
     68/push 0/imm32/top
@@ -1329,7 +1329,7 @@ test-function-header-with-multiple-args:
     2b/subtract-> *Function-size 4/r32/esp
     89/<- %ecx 4/r32/esp
     (zero-out %ecx *Function-size)
-    # var vars/ebx : (ref stack (address var) 16)
+    # var vars/ebx : (ref stack (addr var) 16)
     81 5/subop/subtract %esp 0x10/imm32
     68/push 0x10/imm32/length
     68/push 0/imm32/top
@@ -1376,7 +1376,7 @@ test-function-with-multiple-args-and-outputs:
     2b/subtract-> *Function-size 4/r32/esp
     89/<- %ecx 4/r32/esp
     (zero-out %ecx *Function-size)
-    # var vars/ebx : (ref stack (address var) 16)
+    # var vars/ebx : (ref stack (addr var) 16)
     81 5/subop/subtract %esp 0x10/imm32
     68/push 0x10/imm32/length
     68/push 0/imm32/top
@@ -1427,12 +1427,12 @@ test-function-with-multiple-args-and-outputs:
 #   x: int
 #   x: int,
 # ignores at most one trailing colon or comma
-parse-var-with-type:  # name: (address slice), first-line: (address stream byte) -> result/eax: (handle var)
+parse-var-with-type:  # name: (addr slice), first-line: (addr stream byte) -> result/eax: (handle var)
     # pseudocode:
     #   var v : (handle var) = allocate(Heap, Var-size)
     #   var s : (ref slice)
     #   next-token-from-slice(name->start, name->end, '/', s)
-    #   var end : (address byte) = s->end
+    #   var end : (addr byte) = s->end
     #   if (slice-ends-with(s, ":"))
     #     decrement s->end
     #   if (slice-ends-with(s, ","))
@@ -1603,7 +1603,7 @@ $parse-var-with-type:abort:
     cd/syscall  0x80/imm8
     # never gets here
 
-next-mu-token:  # in: (address stream byte), out: (address slice)
+next-mu-token:  # in: (addr stream byte), out: (addr slice)
     # . prologue
     55/push-ebp
     89/<- %ebp 4/r32/esp
@@ -1644,7 +1644,7 @@ $next-mu-token:end:
     5d/pop-to-ebp
     c3/return
 
-type-for:  # name: (address slice) -> result/eax: (handle s-expression type-id)
+type-for:  # name: (addr slice) -> result/eax: (handle s-expression type-id)
     # . prologue
     55/push-ebp
     89/<- %ebp 4/r32/esp
@@ -1778,7 +1778,7 @@ test-parse-var-with-register-and-trailing-characters:
 # identifier starts with a letter or '$' or '_'
 # no constraints at the moment on later letters
 # all we really want to do so far is exclude '{', '}' and '->'
-is-identifier?:  # in : (address slice) -> result/eax : boolean
+is-identifier?:  # in : (addr slice) -> result/eax : boolean
     # . prologue
     55/push-ebp
     89/<- %ebp 4/r32/esp
@@ -2074,7 +2074,7 @@ test-is-identifier-hyphen:
     5d/pop-to-ebp
     c3/return
 
-populate-mu-function-body:  # in : (address buffered-file), out : (handle function), vars : (address stack (handle var))
+populate-mu-function-body:  # in : (addr buffered-file), out : (handle function), vars : (addr stack (handle var))
     # . prologue
     55/push-ebp
     89/<- %ebp 4/r32/esp
@@ -2101,7 +2101,7 @@ $populate-mu-function-body:end:
     c3/return
 
 # parses a block, assuming that the leading '{' has already been read by the caller
-parse-mu-block:  # in : (address buffered-file), vars : (address stack (handle var)), fn : (handle function) -> result/eax : (handle block)
+parse-mu-block:  # in : (addr buffered-file), vars : (addr stack (handle var)), fn : (handle function) -> result/eax : (handle block)
     # pseudocode:
     #   var line : (ref stream byte 512)
     #   var word-slice : (ref slice)
@@ -2262,7 +2262,7 @@ $parse-mu-block:abort:
     cd/syscall  0x80/imm8
     # never gets here
 
-check-no-tokens-left:  # line : (address stream byte)
+check-no-tokens-left:  # line : (addr stream byte)
     # . prologue
     55/push-ebp
     89/<- %ebp 4/r32/esp
@@ -2309,7 +2309,7 @@ $check-no-tokens-left:end:
     5d/pop-to-ebp
     c3/return
 
-parse-mu-named-block:  # name : (address slice), first-line : (address stream byte), in : (address buffered-file), vars : (address stack (handle var)) -> result/eax : (handle stmt)
+parse-mu-named-block:  # name : (addr slice), first-line : (addr stream byte), in : (addr buffered-file), vars : (addr stack (handle var)) -> result/eax : (handle stmt)
     # pseudocode:
     #   var line : (ref stream byte 512)
     #   var word-slice : (ref slice)
@@ -2353,7 +2353,7 @@ $parse-mu-named-block:end:
     5d/pop-to-ebp
     c3/return
 
-parse-mu-var-def:  # line : (address stream byte), vars : (address stack (handle var)) -> result/eax : (handle stmt)
+parse-mu-var-def:  # line : (addr stream byte), vars : (addr stack (handle var)) -> result/eax : (handle stmt)
     # pseudocode:
     #
     # . prologue
@@ -2368,7 +2368,7 @@ $parse-mu-var-def:end:
     5d/pop-to-ebp
     c3/return
 
-parse-mu-stmt:  # line : (address stream byte), vars : (address stack (handle var)), fn : (handle function) -> result/eax : (handle stmt)
+parse-mu-stmt:  # line : (addr stream byte), vars : (addr stack (handle var)), fn : (handle function) -> result/eax : (handle stmt)
     # pseudocode:
     #   var name : (ref slice)
     #   result = allocate(Heap, Stmt-size)
@@ -2488,7 +2488,7 @@ $parse-mu-stmt:abort2:
     cd/syscall  0x80/imm8
     # never gets here
 
-stmt-has-outputs?:  # line : (address stream byte) -> result/eax : boolean
+stmt-has-outputs?:  # line : (addr stream byte) -> result/eax : boolean
     # . prologue
     55/push-ebp
     89/<- %ebp 4/r32/esp
@@ -2536,7 +2536,7 @@ $stmt-has-outputs:end:
 
 # if 'name' starts with a digit, create a new literal var for it
 # otherwise return first 'name' from the top (back) of 'vars' and abort if not found
-lookup-var-or-literal:  # name: (address slice), vars : (address stack (handle var)) -> result/eax: (handle var)
+lookup-var-or-literal:  # name: (addr slice), vars : (addr stack (handle var)) -> result/eax: (handle var)
     # . prologue
     55/push-ebp
     89/<- %ebp 4/r32/esp
@@ -2584,7 +2584,7 @@ $lookup-var-or-literal:abort:
     # never gets here
 
 # return first 'name' from the top (back) of 'vars' and abort if not found
-lookup-var:  # name: (address slice), vars : (address stack (handle var)) -> result/eax: (handle var)
+lookup-var:  # name: (addr slice), vars : (addr stack (handle var)) -> result/eax: (handle var)
     # . prologue
     55/push-ebp
     89/<- %ebp 4/r32/esp
@@ -2613,9 +2613,9 @@ $lookup-var:abort:
     # never gets here
 
 # return first 'name' from the top (back) of 'vars', and 0/null if not found
-lookup-var-helper:  # name: (address array byte), vars : (address stack (handle var)) -> result/eax: (handle var)
+lookup-var-helper:  # name: (addr array byte), vars : (addr stack (handle var)) -> result/eax: (handle var)
     # pseudocode:
-    #   var curr : (address handle var) = &vars->data[vars->top - 4]
+    #   var curr : (addr handle var) = &vars->data[vars->top - 4]
     #   var min = vars->data
     #   while curr >= min
     #     var v : (handle var) = *curr
@@ -2637,9 +2637,9 @@ lookup-var-helper:  # name: (address array byte), vars : (address stack (handle
     # if (vars->top > vars->length) abort
     3b/compare 0/r32/eax *(esi+4)
     0f 8f/jump-if-greater $lookup-var-helper:error1/disp32
-    # var min/edx : (address handle var) = vars->data
+    # var min/edx : (addr handle var) = vars->data
     8d/copy-address *(esi+8) 2/r32/edx
-    # var curr/ebx : (address handle var) = &vars->data[vars->top - 4]
+    # var curr/ebx : (addr handle var) = &vars->data[vars->top - 4]
     81 5/subop/subtract %ebx 4/imm32
     8d/copy-address *(esi+ebx+8) 3/r32/ebx
     {
@@ -2680,7 +2680,7 @@ $lookup-var-helper:error1:
     # never gets here
 
 # return first 'name' from the top (back) of 'vars' and create a new var for a fn output if not found
-lookup-or-define-var:  # name: (address slice), vars : (address stack (handle var)), fn : (handle function) -> result/eax: (handle var)
+lookup-or-define-var:  # name: (addr slice), vars : (addr stack (handle var)), fn : (handle function) -> result/eax: (handle var)
     # . prologue
     55/push-ebp
     89/<- %ebp 4/r32/esp
@@ -2753,7 +2753,7 @@ test-parse-mu-stmt:
     # setup
     (clear-stream _test-input-stream)
     (write _test-input-stream "increment n\n")
-    # var vars/ecx : (ref stack (address var) 4)
+    # var vars/ecx : (ref stack (addr var) 4)
     81 5/subop/subtract %esp 0x10/imm32
     68/push 0x10/imm32/length
     68/push 0/imm32/top
@@ -2781,7 +2781,7 @@ test-parse-mu-stmt:
     5d/pop-to-ebp
     c3/return
 
-new-function:  # ad: (address allocation-descriptor), name: (address array byte), subx-name: (address array byte), inouts: (handle list var), outputs: (handle list var), body: (handle block), next: (handle function) -> result/eax: (handle function)
+new-function:  # ad: (addr allocation-descriptor), name: (addr array byte), subx-name: (addr array byte), inouts: (handle list var), outputs: (handle list var), body: (handle block), next: (handle function) -> result/eax: (handle function)
     # . prologue
     55/push-ebp
     89/<- %ebp 4/r32/esp
@@ -2809,7 +2809,7 @@ $new-function:end:
     5d/pop-to-ebp
     c3/return
 
-new-var:  # ad: (address allocation-descriptor), name: (address array byte), type: int, block: int, stack-offset: int, register: (address array byte) -> result/eax: (handle var)
+new-var:  # ad: (addr allocation-descriptor), name: (addr array byte), type: int, block: int, stack-offset: int, register: (addr array byte) -> result/eax: (handle var)
     # . prologue
     55/push-ebp
     89/<- %ebp 4/r32/esp
@@ -2835,7 +2835,7 @@ $new-var:end:
     5d/pop-to-ebp
     c3/return
 
-new-literal-integer:  # ad: (address allocation-descriptor), name: (address slice) -> result/eax: (handle var)
+new-literal-integer:  # ad: (addr allocation-descriptor), name: (addr slice) -> result/eax: (handle var)
     # . prologue
     55/push-ebp
     89/<- %ebp 4/r32/esp
@@ -2845,7 +2845,7 @@ new-literal-integer:  # ad: (address allocation-descriptor), name: (address slic
     (is-hex-int? *(ebp+0xc))  # => eax
     3d/compare-eax-and 0/imm32
     0f 84/jump-if-equal $new-literal-integer:abort/disp32
-    # var s/ecx : (address array byte)
+    # var s/ecx : (addr array byte)
     (slice-to-string Heap *(ebp+0xc))  # => eax
     89/<- %ecx 0/r32/eax
     #
@@ -2874,7 +2874,7 @@ $new-literal-integer:abort:
     cd/syscall  0x80/imm8
     # never gets here
 
-new-block:  # ad: (address allocation-descriptor), data: (handle list statement) -> result/eax: (handle statement)
+new-block:  # ad: (addr allocation-descriptor), data: (handle list statement) -> result/eax: (handle statement)
     # . prologue
     55/push-ebp
     89/<- %ebp 4/r32/esp
@@ -2894,7 +2894,7 @@ $new-block:end:
     5d/pop-to-ebp
     c3/return
 
-new-stmt:  # ad: (address allocation-descriptor), operation: (address array byte), inouts: (handle list var), outputs: (handle list var) -> result/eax: (handle statement)
+new-stmt:  # ad: (addr allocation-descriptor), operation: (addr array byte), inouts: (handle list var), outputs: (handle list var) -> result/eax: (handle statement)
     # . prologue
     55/push-ebp
     89/<- %ebp 4/r32/esp
@@ -2918,7 +2918,7 @@ $new-stmt:end:
     5d/pop-to-ebp
     c3/return
 
-new-vardef:  # ad: (address allocation-descriptor), name: (address array byte), type: int -> result/eax: (handle statement)
+new-vardef:  # ad: (addr allocation-descriptor), name: (addr array byte), type: int -> result/eax: (handle statement)
     # . prologue
     55/push-ebp
     89/<- %ebp 4/r32/esp
@@ -2940,7 +2940,7 @@ $new-vardef:end:
     5d/pop-to-ebp
     c3/return
 
-new-regvardef:  # ad: (address allocation-descriptor), name: (address array byte), type: int, register: (address array byte) -> result/eax: (handle statement)
+new-regvardef:  # ad: (addr allocation-descriptor), name: (addr array byte), type: int, register: (addr array byte) -> result/eax: (handle statement)
     # . prologue
     55/push-ebp
     89/<- %ebp 4/r32/esp
@@ -2964,7 +2964,7 @@ $new-regvardef:end:
     5d/pop-to-ebp
     c3/return
 
-new-named-block:  # ad: (address allocation-descriptor), name: (address array byte), data: (handle list statement) -> result/eax: (handle statement)
+new-named-block:  # ad: (addr allocation-descriptor), name: (addr array byte), data: (handle list statement) -> result/eax: (handle statement)
     # . prologue
     55/push-ebp
     89/<- %ebp 4/r32/esp
@@ -2986,7 +2986,7 @@ $new-named-block:end:
     5d/pop-to-ebp
     c3/return
 
-new-list:  # ad: (address allocation-descriptor), value: _type, next: (handle list _type) -> result/eax : (handle list _type)
+new-list:  # ad: (addr allocation-descriptor), value: _type, next: (handle list _type) -> result/eax : (handle list _type)
     # . prologue
     55/push-ebp
     89/<- %ebp 4/r32/esp
@@ -3006,7 +3006,7 @@ $new-list:end:
     5d/pop-to-ebp
     c3/return
 
-append-list:  # ad: (address allocation-descriptor), value: _type, list: (handle list _type) -> result/eax : (handle list _type)
+append-list:  # ad: (addr allocation-descriptor), value: _type, list: (handle list _type) -> result/eax : (handle list _type)
     # . prologue
     55/push-ebp
     89/<- %ebp 4/r32/esp
@@ -3042,7 +3042,7 @@ $append-list:end:
     5d/pop-to-ebp
     c3/return
 
-append-to-block:  # ad: (address allocation-descriptor), block: (handle block), x: (handle stmt)
+append-to-block:  # ad: (addr allocation-descriptor), block: (handle block), x: (handle stmt)
     # . prologue
     55/push-ebp
     89/<- %ebp 4/r32/esp
@@ -3075,7 +3075,7 @@ $check-mu-types:end:
     5d/pop-to-ebp
     c3/return
 
-size-of:  # n : (address var)
+size-of:  # n : (addr var)
     # . prologue
     55/push-ebp
     89/<- %ebp 4/r32/esp
@@ -3091,7 +3091,7 @@ $size-of:end:
 # Code-generation
 #######################################################
 
-emit-subx:  # out : (address buffered-file)
+emit-subx:  # out : (addr buffered-file)
     # . prologue
     55/push-ebp
     89/<- %ebp 4/r32/esp
@@ -3122,7 +3122,7 @@ $emit-subx:end:
     5d/pop-to-ebp
     c3/return
 
-emit-subx-function:  # out : (address buffered-file), f : (handle function)
+emit-subx-function:  # out : (addr buffered-file), f : (handle function)
     # . prologue
     55/push-ebp
     89/<- %ebp 4/r32/esp
@@ -3150,7 +3150,7 @@ $emit-subx-function:end:
     5d/pop-to-ebp
     c3/return
 
-emit-subx-block:  # out : (address buffered-file), block : (handle block)
+emit-subx-block:  # out : (addr buffered-file), block : (handle block)
     # . prologue
     55/push-ebp
     89/<- %ebp 4/r32/esp
@@ -3180,7 +3180,7 @@ $emit-subx-block:end:
     5d/pop-to-ebp
     c3/return
 
-emit-subx-statement:  # out : (address buffered-file), stmt : (handle statement), primitives : (handle primitive), functions : (handle function)
+emit-subx-statement:  # out : (addr buffered-file), stmt : (handle statement), primitives : (handle primitive), functions : (handle function)
     # . prologue
     55/push-ebp
     89/<- %ebp 4/r32/esp
@@ -3975,7 +3975,7 @@ Lit-var:
     0/imm32/no-register
 
 == code
-emit-subx-primitive:  # out : (address buffered-file), stmt : (handle statement), primitive : (handle function)
+emit-subx-primitive:  # out : (addr buffered-file), stmt : (handle statement), primitive : (handle function)
     # . prologue
     55/push-ebp
     89/<- %ebp 4/r32/esp
@@ -4001,7 +4001,7 @@ $emit-subx-primitive:end:
     5d/pop-to-ebp
     c3/return
 
-emit-subx-rm32:  # out : (address buffered-file), l : arg-location, stmt : (handle statement)
+emit-subx-rm32:  # out : (addr buffered-file), l : arg-location, stmt : (handle statement)
     # . prologue
     55/push-ebp
     89/<- %ebp 4/r32/esp
@@ -4081,7 +4081,7 @@ $get-stmt-operand-from-arg-location:abort:
     cd/syscall  0x80/imm8
     # never gets here
 
-emit-subx-r32:  # out : (address buffered-file), l : arg-location, stmt : (handle statement)
+emit-subx-r32:  # out : (addr buffered-file), l : arg-location, stmt : (handle statement)
     # . prologue
     55/push-ebp
     89/<- %ebp 4/r32/esp
@@ -4093,7 +4093,7 @@ emit-subx-r32:  # out : (address buffered-file), l : arg-location, stmt : (handl
     0f 84/jump-if-equal $emit-subx-r32:end/disp32
     #
     (get-stmt-operand-from-arg-location *(ebp+0x10) *(ebp+0xc))  # stmt, l => var/eax
-    (maybe-get Registers *(eax+0x10) 8)  # Var-register => eax : (address register-index)
+    (maybe-get Registers *(eax+0x10) 8)  # Var-register => eax : (addr register-index)
     (write-buffered *(ebp+8) Space)
     (print-int32-buffered *(ebp+8) *eax)
     (write-buffered *(ebp+8) "/r32")
@@ -4106,7 +4106,7 @@ $emit-subx-r32:end:
     5d/pop-to-ebp
     c3/return
 
-emit-subx-imm32:  # out : (address buffered-file), l : arg-location, stmt : (handle statement)
+emit-subx-imm32:  # out : (addr buffered-file), l : arg-location, stmt : (handle statement)
     # . prologue
     55/push-ebp
     89/<- %ebp 4/r32/esp
@@ -4130,7 +4130,7 @@ $emit-subx-imm32:end:
     5d/pop-to-ebp
     c3/return
 
-emit-subx-call:  # out : (address buffered-file), stmt : (handle statement), callee : (handle function)
+emit-subx-call:  # out : (addr buffered-file), stmt : (handle statement), callee : (handle function)
     # . prologue
     55/push-ebp
     89/<- %ebp 4/r32/esp
@@ -4167,7 +4167,7 @@ $emit-subx-call:end:
     5d/pop-to-ebp
     c3/return
 
-emit-subx-call-operand:  # out : (address buffered-file), operand : (handle variable)
+emit-subx-call-operand:  # out : (addr buffered-file), operand : (handle variable)
     # . prologue
     55/push-ebp
     89/<- %ebp 4/r32/esp
@@ -4193,7 +4193,7 @@ $emit-subx-call-operand:end:
     5d/pop-to-ebp
     c3/return
 
-emit-subx-var-as-rm32:  # out : (address buffered-file), operand : (handle variable)
+emit-subx-var-as-rm32:  # out : (addr buffered-file), operand : (handle variable)
     # . prologue
     55/push-ebp
     89/<- %ebp 4/r32/esp
@@ -4228,7 +4228,7 @@ $emit-subx-var-as-rm32:end:
     5d/pop-to-ebp
     c3/return
 
-find-matching-function:  # functions : (address function), stmt : (handle statement) -> result/eax : (handle function)
+find-matching-function:  # functions : (addr function), stmt : (handle statement) -> result/eax : (handle function)
     # . prologue
     55/push-ebp
     89/<- %ebp 4/r32/esp
@@ -5402,7 +5402,7 @@ test-emit-subx-statement-function-call-with-literal-arg:
     5d/pop-to-ebp
     c3/return
 
-emit-subx-prologue:  # out : (address buffered-file)
+emit-subx-prologue:  # out : (addr buffered-file)
     # . prologue
     55/push-ebp
     89/<- %ebp 4/r32/esp
@@ -5416,7 +5416,7 @@ $emit-subx-prologue:end:
     5d/pop-to-ebp
     c3/return
 
-emit-subx-epilogue:  # out : (address buffered-file)
+emit-subx-epilogue:  # out : (addr buffered-file)
     # . prologue
     55/push-ebp
     89/<- %ebp 4/r32/esp
diff --git a/apps/mulisp.subx b/apps/mulisp.subx
index 1cfdeb03..d9fbb594 100644
--- a/apps/mulisp.subx
+++ b/apps/mulisp.subx
@@ -49,7 +49,7 @@ $main:end:
 #     NIL NUM CHAR STRING SYMBOL PAIR ARRAY
 #   memory type: a type specifying memory layout at the SubX level. Starts
 #   with a '$'.
-#     $int $array $(address _)
+#     $int $array $(addr _)
 #
 # Lisp values are represented in memory by the _cell_ data structure. A cell
 # is 12 bytes long:
@@ -63,18 +63,18 @@ $main:end:
 #   - char: cell{ tag: 2/CHAR, data: $int 0 }
 #     data contains the utf-8 code of the character (no compound glyphs, no
 #     modifiers, etc., etc.)
-#   - string: cell{ tag: 3/STRING, data: $(address stream byte)
-#     data contains an (address array byte) containing the string in utf-8
-#   - symbol: cell{ tag: 4/SYMBOL, data: $(address array byte) 0 }
-#     data contains an (address array byte) containing the name of the symbol in utf-8
+#   - string: cell{ tag: 3/STRING, data: $(addr stream byte)
+#     data contains an (addr array byte) containing the string in utf-8
+#   - symbol: cell{ tag: 4/SYMBOL, data: $(addr array byte) 0 }
+#     data contains an (addr array byte) containing the name of the symbol in utf-8
 #     alternatively, data could contain an index into the table of interned symbols
-#   - pair: cell{ tag: 5/PAIR, data: $(address cell) $(address cell)  }
+#   - pair: cell{ tag: 5/PAIR, data: $(addr cell) $(addr cell)  }
 #     data contains pointers to car and cdr
-#   - array: cell{ tag: 6/ARRAY, data: $tag $(address stream data)
+#   - array: cell{ tag: 6/ARRAY, data: $tag $(addr stream data)
 #     data contains a pointer to an array of 8-byte data fields and the common
 #     tag for them all
 
-repl:  # in : (address buffered-file), out : (address buffered-file)
+repl:  # in : (addr buffered-file), out : (addr buffered-file)
     # . prologue
     55/push-ebp
     89/<- %ebp 4/r32/esp
@@ -104,7 +104,7 @@ $repl:end:
 # arrays start with '['
 # symbols start with anything else but quote, backquote, unquote or splice
 # only one s-expression per line
-lisp-read:  # in : (address buffered-file) -> eax : (handle cell)
+lisp-read:  # in : (addr buffered-file) -> eax : (handle cell)
     # . prologue
     55/push-ebp
     89/<- %ebp 4/r32/esp
@@ -142,14 +142,14 @@ $lisp-read:end:
     5d/pop-to-ebp
     c3/return
 
-# lisp-read:  in : (address buffered-file) -> (handle cell)
+# lisp-read:  in : (addr buffered-file) -> (handle cell)
 #   token tmp = next-mulisp-token(in)
 #   if is-int(tmp) return cell(tmp)
 #   if is-string(tmp) return cell(tmp)
 #   if is-pair(tmp) ...
 #   if is-array(tmp) ...
 
-next-mulisp-token:  # in : (address buffered-file), line : (address stream byte), result : (address slice)
+next-mulisp-token:  # in : (addr buffered-file), line : (addr stream byte), result : (addr slice)
     # pseudocode:
     #   if (line->read >= line->write)
     #     read-line-buffered(in, line)
@@ -194,11 +194,11 @@ $next-mulisp-token:end:
     5d/pop-to-ebp
     c3/return
 
-new-int-cell:  # in : (address slice) -> eax : (handle cell)
+new-int-cell:  # in : (addr slice) -> eax : (handle cell)
 
-new-string-cell:  # in : (address slice) -> eax : (handle cell)
+new-string-cell:  # in : (addr slice) -> eax : (handle cell)
 
-lisp-eval:  # in : (address cell) -> eax : (handle cell)
+lisp-eval:  # in : (addr cell) -> eax : (handle cell)
     # . prologue
     55/push-ebp
     89/<- %ebp 4/r32/esp
@@ -211,7 +211,7 @@ $lisp-eval:end:
     5d/pop-to-ebp
     c3/return
 
-lisp-print:  # out : (address buffered-file), x : (address cell)
+lisp-print:  # out : (addr buffered-file), x : (addr cell)
     # . prologue
     55/push-ebp
     89/<- %ebp 4/r32/esp
diff --git a/apps/pack.subx b/apps/pack.subx
index df683f84..5d5d8033 100644
--- a/apps/pack.subx
+++ b/apps/pack.subx
@@ -97,7 +97,7 @@ $subx-pack-main:end:
 #   next-token-from-slice(start, end, delim char) -> slice
 #   slice-equal?(slice, string)
 
-subx-pack:  # in : (address buffered-file), out : (address buffered-file)
+subx-pack:  # in : (addr buffered-file), out : (addr buffered-file)
     # pseudocode:
     #   var line : (ref stream byte 512)
     #   var in-code? = false
@@ -909,7 +909,7 @@ test-subx-pack-code-and-data-segments:
     5d/pop-to-ebp
     c3/return
 
-convert-data:  # line : (address stream byte), out : (address buffered-file)
+convert-data:  # line : (addr stream byte), out : (addr buffered-file)
     # pseudocode:
     #   var word-slice : (ref slice)
     #   while true
@@ -1029,7 +1029,7 @@ $convert-data:check0:
     0f 85/jump-if-not-equal  $convert-data:break/disp32
 $convert-data:check-for-comment:
     # if (slice-starts-with?(word-slice, "#"))
-    # . var start/edx : (address byte) = word-slice->start
+    # . var start/edx : (addr byte) = word-slice->start
     8b/copy                         0/mod/indirect  1/rm32/ecx    .           .             .           2/r32/edx   .               .                 # copy *ecx to edx
     # . var c/eax : byte = *start
     31/xor                          3/mod/direct    0/rm32/eax    .           .             .           0/r32/eax   .               .                 # clear eax
@@ -1050,7 +1050,7 @@ $convert-data:comment:
     0f 85/jump-if-not-equal  $convert-data:end/disp32
 $convert-data:check-for-label:
     # if (slice-ends-with?(word-slice, ":"))
-    # . var end/edx : (address byte) = word-slice->end
+    # . var end/edx : (addr byte) = word-slice->end
     8b/copy                         1/mod/*+disp8   1/rm32/ecx    .           .             .           2/r32/edx   4/disp8         .                 # copy *(ecx+4) to edx
     # . var c/eax : byte = *(end-1)
     31/xor                          3/mod/direct    0/rm32/eax    .           .             .           0/r32/eax   .               .                 # clear eax
@@ -1809,7 +1809,7 @@ test-convert-data-trailing-comment:
 #   unceremoniously abort on non-numeric operands except disp or imm
 #   opcodes must be lowercase and zero padded
 #   opcodes with misleading operand metadata may get duplicated as operands as well. don't rely on this.
-convert-instruction:  # line : (address stream byte), out : (address buffered-file)
+convert-instruction:  # line : (addr stream byte), out : (addr buffered-file)
     # pseudocode:
     #   # some early exits
     #   var word-slice = next-word(line)
@@ -1863,7 +1863,7 @@ $convert-instruction:check0:
     75/jump-if-not-equal  $convert-instruction:pass-through/disp8
 $convert-instruction:check1:
     # if (slice-starts-with?(word-slice, "#")) write-stream-data(out, line)
-    # . var start/edx : (address byte) = word-slice->start
+    # . var start/edx : (addr byte) = word-slice->start
     8b/copy                         0/mod/indirect  1/rm32/ecx    .           .             .           2/r32/edx   .               .                 # copy *ecx to edx
     # . var c/eax : byte = *start
     31/xor                          3/mod/direct    0/rm32/eax    .           .             .           0/r32/eax   .               .                 # clear eax
@@ -1873,7 +1873,7 @@ $convert-instruction:check1:
     74/jump-if-equal  $convert-instruction:pass-through/disp8
 $convert-instruction:check2:
     # if (slice-ends-with?(word-slice, ":")) write-stream-data(out, line)
-    # . var end/edx : (address byte) = word-slice->end
+    # . var end/edx : (addr byte) = word-slice->end
     8b/copy                         1/mod/*+disp8   1/rm32/ecx    .           .             .           2/r32/edx   4/disp8         .                 # copy *(ecx+4) to edx
     # . var c/eax : byte = *(end-1)
     31/xor                          3/mod/direct    0/rm32/eax    .           .             .           0/r32/eax   .               .                 # clear eax
@@ -1953,7 +1953,7 @@ $convert-instruction:end:
     5d/pop-to-ebp
     c3/return
 
-emit-opcodes:  # line : (address stream byte), out : (address buffered-file)
+emit-opcodes:  # line : (addr stream byte), out : (addr buffered-file)
     # opcodes occupy 1-3 bytes:
     #   xx
     #   0f xx
@@ -2030,7 +2030,7 @@ $emit-opcodes:op1:
     3d/compare-eax-and  0/imm32/false
     0f 85/jump-if-not-equal  $emit-opcodes:end/disp32
     # if (slice-starts-with?(op1, "#")) return
-    # . var start/ebx : (address byte) = op1->start
+    # . var start/ebx : (addr byte) = op1->start
     8b/copy                         0/mod/indirect  1/rm32/ecx    .           .             .           3/r32/ebx   .               .                 # copy *ecx to ebx
     # . var c/eax : byte = *start
     31/xor                          3/mod/direct    0/rm32/eax    .           .             .           0/r32/eax   .               .                 # clear eax
@@ -2123,7 +2123,7 @@ $emit-opcodes:op2:
     3d/compare-eax-and  0/imm32/false
     0f 85/jump-if-not-equal  $emit-opcodes:end/disp32
     # if (slice-starts-with?(op2, "#")) return
-    # . var start/ebx : (address byte) = op2->start
+    # . var start/ebx : (addr byte) = op2->start
     8b/copy                         0/mod/indirect  2/rm32/edx    .           .             .           3/r32/ebx   .               .                 # copy *edx to ebx
     # . var c/eax : byte = *start
     31/xor                          3/mod/direct    0/rm32/eax    .           .             .           0/r32/eax   .               .                 # clear eax
@@ -2202,7 +2202,7 @@ $emit-opcodes:op3:
     3d/compare-eax-and  0/imm32/false
     0f 85/jump-if-not-equal  $emit-opcodes:end/disp32
     # if (slice-starts-with?(op3, "#")) return
-    # . var start/ebx : (address byte) = op2->start
+    # . var start/ebx : (addr byte) = op2->start
     8b/copy                         0/mod/indirect  2/rm32/edx    .           .             .           3/r32/ebx   .               .                 # copy *edx to ebx
     # . var c/eax : byte = *start
     31/xor                          3/mod/direct    0/rm32/eax    .           .             .           0/r32/eax   .               .                 # clear eax
@@ -2249,7 +2249,7 @@ $emit-opcodes:end:
     5d/pop-to-ebp
     c3/return
 
-emit-modrm:  # line : (address stream byte), out : (address buffered-file)
+emit-modrm:  # line : (addr stream byte), out : (addr buffered-file)
     # pseudocode:
     #   rewind-stream(line)
     #   var has-modrm? = false, mod = 0, rm32 = 0, r32 = 0
@@ -2402,7 +2402,7 @@ $emit-modrm:check1:
     # if (slice-starts-with?(word-slice, "#")) break
     # . spill edx
     52/push-edx
-    # . var start/edx : (address byte) = word-slice->start
+    # . var start/edx : (addr byte) = word-slice->start
     8b/copy                         0/mod/indirect  1/rm32/ecx    .           .             .           2/r32/edx   .               .                 # copy *ecx to edx
     # . var c/eax : byte = *start
     31/xor                          3/mod/direct    0/rm32/eax    .           .             .           0/r32/eax   .               .                 # clear eax
@@ -2566,7 +2566,7 @@ $emit-modrm:end:
     5d/pop-to-ebp
     c3/return
 
-emit-sib:  # line : (address stream byte), out : (address buffered-file)
+emit-sib:  # line : (addr stream byte), out : (addr buffered-file)
     # pseudocode:
     #   var has-sib? = false, base = 0, index = 0, scale = 0
     #   var word-slice : (ref slice)
@@ -2711,7 +2711,7 @@ $emit-sib:check1:
     # if (slice-starts-with?(word-slice, "#")) break
     # . spill edx
     52/push-edx
-    # . var start/edx : (address byte) = word-slice->start
+    # . var start/edx : (addr byte) = word-slice->start
     8b/copy                         0/mod/indirect  1/rm32/ecx    .           .             .           2/r32/edx   .               .                 # copy *ecx to edx
     # . var c/eax : byte = *start
     31/xor                          3/mod/direct    0/rm32/eax    .           .             .           0/r32/eax   .               .                 # clear eax
@@ -2847,7 +2847,7 @@ $emit-sib:end:
     5d/pop-to-ebp
     c3/return
 
-emit-disp:  # line : (address stream byte), out : (address buffered-file)
+emit-disp:  # line : (addr stream byte), out : (addr buffered-file)
     # pseudocode:
     #   rewind-stream(line)
     #   var word-slice : (ref slice)
@@ -2972,7 +2972,7 @@ $emit-disp:check0:
     0f 85/jump-if-not-equal  $emit-disp:break/disp32
 $emit-disp:check1:
     # if (slice-starts-with?(word-slice, "#")) break
-    # . var start/edx : (address byte) = word-slice->start
+    # . var start/edx : (addr byte) = word-slice->start
     8b/copy                         0/mod/indirect  1/rm32/ecx    .           .             .           2/r32/edx   .               .                 # copy *ecx to edx
     # . var c/eax : byte = *start
     31/xor                          3/mod/direct    0/rm32/eax    .           .             .           0/r32/eax   .               .                 # clear eax
@@ -3066,7 +3066,7 @@ $emit-disp:break:
     5d/pop-to-ebp
     c3/return
 
-emit-imm:  # line : (address stream byte), out : (address buffered-file)
+emit-imm:  # line : (addr stream byte), out : (addr buffered-file)
     # pseudocode:
     #   rewind-stream(line)
     #   var word-slice : (ref slice)
@@ -3191,7 +3191,7 @@ $emit-imm:check0:
     0f 85/jump-if-not-equal  $emit-imm:break/disp32
 $emit-imm:check1:
     # if (slice-starts-with?(word-slice, "#")) break
-    # . var start/edx : (address byte) = slice->start
+    # . var start/edx : (addr byte) = slice->start
     8b/copy                         0/mod/indirect  1/rm32/ecx    .           .             .           2/r32/edx   .               .                 # copy *ecx to edx
     # . var c/eax : byte = *start
     31/xor                          3/mod/direct    0/rm32/eax    .           .             .           0/r32/eax   .               .                 # clear eax
@@ -3285,7 +3285,7 @@ $emit-imm:break:
     5d/pop-to-ebp
     c3/return
 
-emit-line-in-comment:  # line : (address stream byte), out : (address buffered-file)
+emit-line-in-comment:  # line : (addr stream byte), out : (addr buffered-file)
     # . prologue
     55/push-ebp
     89/copy                         3/mod/direct    5/rm32/ebp    .           .             .           4/r32/esp   .               .                 # copy esp to ebp
@@ -5837,7 +5837,7 @@ test-convert-instruction-handles-imm8-operand:
     c3/return
 
 # shortcut for parse-hex-int(next-token-from-slice(word->start, word->end, '/'))
-parse-datum-of-word:  # word : (address slice) -> value/eax : int
+parse-datum-of-word:  # word : (addr slice) -> value/eax : int
     # . prologue
     55/push-ebp
     89/copy                         3/mod/direct    5/rm32/ebp    .           .             .           4/r32/esp   .               .                 # copy esp to ebp
diff --git a/apps/sigils.subx b/apps/sigils.subx
index a22aee44..485463d7 100644
--- a/apps/sigils.subx
+++ b/apps/sigils.subx
@@ -104,7 +104,7 @@ $subx-sigils-main:end:
 
 # error messages considered:
 #   *x + 34                 -> error: base+disp addressing must be within '()'
-subx-sigils:  # in : (address buffered-file), out : (address buffered-file)
+subx-sigils:  # in : (addr buffered-file), out : (addr buffered-file)
     # pseudocode:
     #   var line : (stream byte 512)
     #   while true
@@ -1359,7 +1359,7 @@ test-subx-sigils-indirect-mode-without-register:
     5d/pop-to-ebp
     c3/return
 
-emit-direct-mode:  # out : (address buffered-file), word-slice : (address slice)
+emit-direct-mode:  # out : (addr buffered-file), word-slice : (addr slice)
     # . prologue
     55/push-ebp
     89/copy                         3/mod/direct    5/rm32/ebp    .           .             .           4/r32/esp   .               .                 # copy esp to ebp
@@ -1599,7 +1599,7 @@ test-emit-direct-mode-2:
 # error messages considered:
 #   * ...                   -> error: no space after '*'
 #   *(...                   -> error: *(...) expression must be all on a single line
-next-word-or-expression:  # line : (address stream byte), out : (address slice)
+next-word-or-expression:  # line : (addr stream byte), out : (addr slice)
     # pseudocode:
     #   skip-chars-matching(line, ' ')
     #   if line->read >= line->write              # end of line
@@ -2207,7 +2207,7 @@ test-next-word-or-expression-returns-whole-expression:
 #   *(reg1+reg2<<s+disp)    -> 2/mod 4/rm32 reg1/base reg2/index s/scale disp/disp32
 # Intermediate structure: base, index, scale, disp
 # Default values: base: 0, index: 4 (none), scale: 0, disp: 0
-parse-effective-address:  # word-slice : (address slice) -> base/eax, index/ecx, scale/edx, disp/ebx
+parse-effective-address:  # word-slice : (addr slice) -> base/eax, index/ecx, scale/edx, disp/ebx
     # pseudocode:
     #   var local-slice = {word-slice->start, word-slice->end}
     #   ++local-slice->start to skip '*'
@@ -2670,7 +2670,7 @@ $parse-effective-address:error4:
 
 # assumes 'in' starts with a register name, and returns pointer to its code
 # side-effect: modifies 'in' to scan past the initial register name
-next-register:  # in : (address slice) -> reg/eax : int
+next-register:  # in : (addr slice) -> reg/eax : int
     # . prologue
     55/push-ebp
     89/copy                         3/mod/direct    5/rm32/ebp    .           .             .           4/r32/esp   .               .                 # copy esp to ebp
@@ -3149,7 +3149,7 @@ test-parse-effective-address-base-index-scale-displacement:
 #   if index is none, then mod = 2 and rm32 = base and disp32 = disp
 # emit-sib:
 #   if index is not none, then mod = 2 and rm32 = 4 and base = base and index = index and disp32 = disp
-emit-indirect-mode:  # out : (address buffered-file), base : int, index : int, scale : int, disp : int
+emit-indirect-mode:  # out : (addr buffered-file), base : int, index : int, scale : int, disp : int
     # . prologue
     55/push-ebp
     89/copy                         3/mod/direct    5/rm32/ebp    .           .             .           4/r32/esp   .               .                 # copy esp to ebp
@@ -3858,7 +3858,7 @@ test-emit-indirect-mode-esp:
     5d/pop-to-ebp
     c3/return
 
-disp32-mode?:  # in : (address slice) -> reg/eax : boolean
+disp32-mode?:  # in : (addr slice) -> reg/eax : boolean
     # . prologue
     55/push-ebp
     89/copy                         3/mod/direct    5/rm32/ebp    .           .             .           4/r32/esp   .               .                 # copy esp to ebp
@@ -3917,7 +3917,7 @@ $disp32-mode?:end:
     5d/pop-to-ebp
     c3/return
 
-emit-indirect-disp32:  # out : (address buffered-file), word-slice : (address slice)
+emit-indirect-disp32:  # out : (addr buffered-file), word-slice : (addr slice)
     # . prologue
     55/push-ebp
     89/copy                         3/mod/direct    5/rm32/ebp    .           .             .           4/r32/esp   .               .                 # copy esp to ebp
@@ -3967,7 +3967,7 @@ $emit-indirect-disp32:end:
 # assumes 'in' starts with optional '+' or '-', optional whitespace, and an unsigned integer
 # returns the value of the integer
 # side-effect: modifies 'in' to skip past the integer
-next-hex-int:  # in : (address slice) -> result/eax
+next-hex-int:  # in : (addr slice) -> result/eax
     # . prologue
     55/push-ebp
     89/copy                         3/mod/direct    5/rm32/ebp    .           .             .           4/r32/esp   .               .                 # copy esp to ebp
@@ -4382,7 +4382,7 @@ test-next-hex-int-negative-with-space:
 # assumes 'in' starts a positive unsigned integer
 # returns the value of the integer
 # side-effect: modifies 'in' to skip past the integer
-next-positive-hex-int:  # in : (address slice) -> result/eax
+next-positive-hex-int:  # in : (addr slice) -> result/eax
     # . prologue
     55/push-ebp
     89/copy                         3/mod/direct    5/rm32/ebp    .           .             .           4/r32/esp   .               .                 # copy esp to ebp
diff --git a/apps/survey.subx b/apps/survey.subx
index e365ac1b..7983e6c5 100644
--- a/apps/survey.subx
+++ b/apps/survey.subx
@@ -107,13 +107,13 @@ $subx-survey-main:end:
     cd/syscall  0x80/imm8
 
 # data structures:
-#   segment-info: {address, file-offset, size}            (12 bytes)
-#   segments: (address stream {string, segment-info})     (16 bytes per row)
-#   label-info: {segment-name, segment-offset, address}   (12 bytes)
-#   labels: (address stream {string, label-info})         (16 bytes per row)
+#   segment-info: {addr, file-offset, size}            (12 bytes)
+#   segments: (addr stream {string, segment-info})     (16 bytes per row)
+#   label-info: {segment-name, segment-offset, addr}   (12 bytes)
+#   labels: (addr stream {string, label-info})         (16 bytes per row)
 # these are all inefficient; use sequential scans for lookups
 
-subx-survey:  # infile : (address buffered-file), out : (address buffered-file)
+subx-survey:  # infile : (addr buffered-file), out : (addr buffered-file)
     # pseudocode
     #   var in : (ref stream byte 4096)
     #   slurp(infile, in)
@@ -618,7 +618,7 @@ compute-offsets:segment-tmp:  # slice
 
 == code
 
-compute-offsets:  # in : (address stream byte), segments : (address stream {string, segment-info}), labels : (address stream {string, label-info})
+compute-offsets:  # in : (addr stream byte), segments : (addr stream {string, segment-info}), labels : (addr stream {string, label-info})
     # skeleton:
     #   for lines in 'in'
     #     for words in line
@@ -629,7 +629,7 @@ compute-offsets:  # in : (address stream byte), segments : (address stream {stri
     #         default
     #
     # pseudocode:
-    #   curr-segment-name : (address string) = 0
+    #   curr-segment-name : (addr string) = 0
     #   var line : (stream byte 512)
     #   while true                                  # line loop
     #     clear-stream(line)
@@ -661,7 +661,7 @@ compute-offsets:  # in : (address stream byte), segments : (address stream {stri
     #         break  (next line)
     #       else if is-label?(word-slice)
     #         strip trailing ':' from word-slice
-    #         x : (address label-info) = get-or-insert(labels, name)
+    #         x : (addr label-info) = get-or-insert(labels, name)
     #         x->segment-name = curr-segment-name
     #         trace("label '", word-slice, "' is in segment '", curr-segment-name, "'.")
     #         x->segment-offset = segment-offset
@@ -1378,9 +1378,9 @@ test-compute-offsets:
     5d/pop-to-ebp
     c3/return
 
-compute-addresses:  # segments : (address stream {string, segment-info}), labels : (address stream {string, label-info})
+compute-addresses:  # segments : (addr stream {string, segment-info}), labels : (addr stream {string, label-info})
     # pseudocode:
-    #   srow : (address segment-info) = segments->data
+    #   srow : (addr segment-info) = segments->data
     #   max = &segments->data[segments->write]
     #   num-segments = segments->write / 16
     #   starting-offset = 0x34 + (num-segments * 0x20)
@@ -1391,12 +1391,12 @@ compute-addresses:  # segments : (address stream {string, segment-info}), labels
     #     s->address += (s->file-offset & 0x00000fff)
     #     trace-sssns("segment " s->key " starts at address " s->address)
     #     srow += 16  # row-size
-    #   lrow : (address label-info) = labels->data
+    #   lrow : (addr label-info) = labels->data
     #   max = &labels->data[labels->write]
     #   while true
     #     if (lrow >= max) break
-    #     seg-name : (address string) = lrow->segment-name
-    #     label-seg : (address segment-info) = get(segments, seg-name)
+    #     seg-name : (addr string) = lrow->segment-name
+    #     label-seg : (addr segment-info) = get(segments, seg-name)
     #     lrow->address = label-seg->address + lrow->segment-offset
     #     trace-sssns("label " lrow->key " is at address " lrow->address)
     #     lrow += 16  # row-size
@@ -1550,7 +1550,7 @@ $compute-addresses:label-loop:
 #?     # . . discard args
 #?     81          0/subop/add         3/mod/direct    4/rm32/esp    .           .             .           .           .               8/imm32           # add to esp
 #?     # }}}
-    # label-seg/edx : (address segment-info) = get(segments, seg-name, row-size=16, "segment table")
+    # label-seg/edx : (addr segment-info) = get(segments, seg-name, row-size=16, "segment table")
     # . save eax
     50/push-eax
     # . eax = get(segments, seg-name, row-size=16)
@@ -1871,7 +1871,7 @@ test-compute-addresses-large-segments:
     5d/pop-to-ebp
     c3/return
 
-emit-output:  # in : (address stream byte), out : (address buffered-file), segments : (address stream {string, segment-info}), labels : (address stream {string, label-info})
+emit-output:  # in : (addr stream byte), out : (addr buffered-file), segments : (addr stream {string, segment-info}), labels : (addr stream {string, label-info})
     # pseudocode:
     #   emit-headers(out, segments, labels)
     #   emit-segments(in, out, segments, labels)
@@ -1922,7 +1922,7 @@ $emit-output:end:
     5d/pop-to-ebp
     c3/return
 
-emit-segments:  # in : (address stream byte), out : (address buffered-file), segments : (address stream {string, segment-info}), labels : (address stream {string, label-info})
+emit-segments:  # in : (addr stream byte), out : (addr buffered-file), segments : (addr stream {string, segment-info}), labels : (addr stream {string, label-info})
     # pseudocode:
     #   var offset-of-next-instruction = 0
     #   var line : (stream byte 512)
@@ -3173,7 +3173,7 @@ test-emit-segments-code-label-absolute:
     5d/pop-to-ebp
     c3/return
 
-emit-headers:  # out : (address buffered-file), segments : (address stream {string, segment-info}), labels : (address stream {string, label-info})
+emit-headers:  # out : (addr buffered-file), segments : (addr stream {string, segment-info}), labels : (addr stream {string, label-info})
     # pseudocode:
     #   emit-elf-header(out, segments, labels)
     #   curr-segment = segments->data
@@ -3311,7 +3311,7 @@ $emit-headers:end:
     5d/pop-to-ebp
     c3/return
 
-emit-elf-header:  # out : (address buffered-file), segments : (address stream {string, segment-info}), labels : (address stream {string, label-info})
+emit-elf-header:  # out : (addr buffered-file), segments : (addr stream {string, segment-info}), labels : (addr stream {string, label-info})
     # pseudocode
     #   *$Elf_e_entry = get(labels, "Entry")->address
     #   *$Elf_e_phnum = segments->write / 16         # size of a row
@@ -3379,7 +3379,7 @@ $emit-elf-header:end:
     5d/pop-to-ebp
     c3/return
 
-emit-elf-program-header-entry:  # out : (address buffered-file), curr-segment : (address {string, segment-info})
+emit-elf-program-header-entry:  # out : (addr buffered-file), curr-segment : (addr {string, segment-info})
     # pseudocode:
     #   *$Elf_p_offset = curr-segment->file-offset
     #   *$Elf_p_vaddr = curr-segment->address
@@ -3468,7 +3468,7 @@ $emit-elf-program-header-entry:end:
 
 # - some helpers for tests
 
-stream-add4:  # in : (address stream byte), key : address, val1 : address, val2 : address, val3 : address
+stream-add4:  # in : (addr stream byte), key : addr, val1 : addr, val2 : addr, val3 : addr
     # . prologue
     55/push-ebp
     89/copy                         3/mod/direct    5/rm32/ebp    .           .             .           4/r32/esp   .               .                 # copy esp to ebp
@@ -3550,11 +3550,11 @@ $stream-add4:abort:
 # some variants of 'trace' that take multiple arguments in different combinations of types:
 #   n: int
 #   c: character [4-bytes, will eventually be UTF-8]
-#   s: (address string)
-#   l: (address slice)
+#   s: (addr string)
+#   l: (addr slice)
 # one gotcha: 's5' must not be empty
 
-trace-sssns:  # s1 : (address string), s2 : (address string), s3 : (address string), n4 : int, s5 : (address string)
+trace-sssns:  # s1 : (addr string), s2 : (addr string), s3 : (addr string), n4 : int, s5 : (addr string)
     # . prologue
     55/push-ebp
     89/copy                         3/mod/direct    5/rm32/ebp    .           .             .           4/r32/esp   .               .                 # copy esp to ebp
@@ -3661,7 +3661,7 @@ test-trace-sssns:
     5d/pop-to-ebp
     c3/return
 
-trace-snsns:  # s1 : (address string), n2 : int, s3 : (address string), n4 : int, s5 : (address string)
+trace-snsns:  # s1 : (addr string), n2 : int, s3 : (addr string), n4 : int, s5 : (addr string)
     # . prologue
     55/push-ebp
     89/copy                         3/mod/direct    5/rm32/ebp    .           .             .           4/r32/esp   .               .                 # copy esp to ebp
@@ -3768,7 +3768,7 @@ test-trace-snsns:
     5d/pop-to-ebp
     c3/return
 
-trace-slsls:  # s1 : (address string), l2 : (address slice), s3 : (address string), l4 : (address slice), s5 : (address string)
+trace-slsls:  # s1 : (addr string), l2 : (addr slice), s3 : (addr string), l4 : (addr slice), s5 : (addr string)
     # . prologue
     55/push-ebp
     89/copy                         3/mod/direct    5/rm32/ebp    .           .             .           4/r32/esp   .               .                 # copy esp to ebp
@@ -3893,7 +3893,7 @@ test-trace-slsls:
     5d/pop-to-ebp
     c3/return
 
-trace-slsns:  # s1 : (address string), l2 : (address slice), s3 : (address string), n4 : int, s5 : (address string)
+trace-slsns:  # s1 : (addr string), l2 : (addr slice), s3 : (addr string), n4 : int, s5 : (addr string)
     # . prologue
     55/push-ebp
     89/copy                         3/mod/direct    5/rm32/ebp    .           .             .           4/r32/esp   .               .                 # copy esp to ebp
@@ -4009,7 +4009,7 @@ test-trace-slsns:
     5d/pop-to-ebp
     c3/return
 
-trace-slsss:  # s1 : (address string), l2 : (address slice), s3 : (address string), s4 : (address string), s5 : (address string)
+trace-slsss:  # s1 : (addr string), l2 : (addr slice), s3 : (addr string), s4 : (addr string), s5 : (addr string)
     # . prologue
     55/push-ebp
     89/copy                         3/mod/direct    5/rm32/ebp    .           .             .           4/r32/esp   .               .                 # copy esp to ebp
@@ -4125,7 +4125,7 @@ test-trace-slsss:
     5d/pop-to-ebp
     c3/return
 
-num-bytes:  # line : (address stream byte) -> eax : int
+num-bytes:  # line : (addr stream byte) -> eax : int
     # pseudocode:
     #   result = 0
     #   while true
diff --git a/apps/tests.subx b/apps/tests.subx
index 1d00cf30..2cef958b 100644
--- a/apps/tests.subx
+++ b/apps/tests.subx
@@ -67,7 +67,7 @@ $subx-tests-main:end:
     b8/copy-to-eax  1/imm32/exit
     cd/syscall  0x80/imm8
 
-subx-gen-run-tests:  # in : (address buffered-file), out : (address buffered-file)
+subx-gen-run-tests:  # in : (addr buffered-file), out : (addr buffered-file)
     # pseudocode
     #   bool tests-found = false
     #   var line : (stream byte 512)