commit 7f8ceb9a19fdfb5f894827e596261da1d3c5fb87
parent 19c3c3bd465f5e192537c247239a4d27497536e7
Author: Ryan Sepassi <rsepassi@gmail.com>
Date: Thu, 23 Apr 2026 14:28:39 -0700
m1pp: annotate m1pp.M1 with pseudo-C inline comments
Each logical chunk of assembly now carries a single-line # comment
in pseudo-C form: register/field loads as "name = expr", branches
as "if (cond) ...", loops as "for (i = 0; i < len; i++) ...",
token field accesses as "tok->kind" / "tok->text_ptr", etc.
Function-header ## comments call out args, return value, leaf/non-
leaf status, and relevant invariants (token layout, the shared shape
of the lparen/rparen/comma dispatch, the caller-saved register
juggling in fatal). Distinct hash levels (# vs ##) keep inline
annotations from colliding with the structural section dividers.
No code changes; tests still pass.
Diffstat:
| M | m1pp/m1pp.M1 | | | 176 | +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++---------- |
1 file changed, 154 insertions(+), 22 deletions(-)
diff --git a/m1pp/m1pp.M1 b/m1pp/m1pp.M1
@@ -22,10 +22,10 @@
## --- Constants & sizing ------------------------------------------------------
-DEFINE M1M_INPUT_CAP 0020000000000000
-DEFINE M1M_OUTPUT_CAP 0020000000000000
-DEFINE M1M_TEXT_CAP 0010000000000000
-DEFINE M1M_TOKENS_END 0018000000000000
+DEFINE M1PP_INPUT_CAP 0020000000000000
+DEFINE M1PP_OUTPUT_CAP 0020000000000000
+DEFINE M1PP_TEXT_CAP 0010000000000000
+DEFINE M1PP_TOKENS_END 0018000000000000
DEFINE O_WRONLY_CREAT_TRUNC 4102000000000000
DEFINE MODE_0644 A401000000000000
DEFINE AT_FDCWD 9CFFFFFFFFFFFFFF
@@ -42,39 +42,43 @@ DEFINE TOK_PASTE 0600000000000000
## --- Runtime shell: argv, read input, call pipeline, write output, exit ------
:_start
+ # if (argc < 3) usage
ld_a0,sp,0
li_a1 %3 %0
la_br &err_usage
blt_a0,a1
+ # output_path = argv[2]
ld_t0,sp,24
la_a0 &output_path
st_t0,a0,0
+ # source_end = &source_tokens (running tail pointer)
la_a0 &source_tokens
la_a1 &source_end
st_a0,a1,0
+ # input_fd = openat(AT_FDCWD, argv[1], O_RDONLY, 0)
li_a0 sys_openat
li_a1 AT_FDCWD
ld_a2,sp,16
li_a3 %0 %0
li_t0 %0 %0
syscall
-
la_br &err_open_input
bltz_a0
-
la_a1 &input_fd
st_a0,a1,0
:read_loop
+ # while (input_len < INPUT_CAP)
la_a0 &input_len
ld_t1,a0,0
- li_t2 M1M_INPUT_CAP
+ li_t2 M1PP_INPUT_CAP
la_br &read_done
beq_t1,t2
+ # n = read(input_fd, &input_buf[input_len], INPUT_CAP - input_len)
la_a0 &input_fd
ld_a1,a0,0
la_a2 &input_buf
@@ -83,11 +87,13 @@ DEFINE TOK_PASTE 0600000000000000
li_a0 sys_read
syscall
+ # if (n == 0) break; if (n < 0) fatal
la_br &read_done
beqz_a0
la_br &err_read
bltz_a0
+ # input_len += n
la_a1 &input_len
ld_a2,a1,0
add_a2,a2,a0
@@ -96,17 +102,20 @@ DEFINE TOK_PASTE 0600000000000000
b
:read_done
+ # if (input_len == INPUT_CAP) fatal (no room for null terminator)
la_a0 &input_len
ld_t0,a0,0
- li_t1 M1M_INPUT_CAP
+ li_t1 M1PP_INPUT_CAP
la_br &err_input_too_big
beq_t0,t1
+ # input_buf[input_len] = '\0'
la_a0 &input_buf
add_a0,a0,t0
li_t1 %0 %0
sb_t1,a0,0
+ # lex_source(); process_tokens()
la_br &lex_source
call
la_br &process_tokens
@@ -116,6 +125,7 @@ DEFINE TOK_PASTE 0600000000000000
b
:write_output
+ # output_fd = openat(AT_FDCWD, output_path, O_WRONLY|O_CREAT|O_TRUNC, 0644)
la_a0 &output_path
ld_a2,a0,0
li_a0 sys_openat
@@ -123,13 +133,13 @@ DEFINE TOK_PASTE 0600000000000000
li_a3 O_WRONLY_CREAT_TRUNC
li_t0 MODE_0644
syscall
-
la_br &err_open_output
bltz_a0
la_a1 &output_fd
st_a0,a1,0
:write_loop
+ # while (output_written < output_used)
la_a0 &output_written
ld_t0,a0,0
la_a1 &output_used
@@ -137,6 +147,7 @@ DEFINE TOK_PASTE 0600000000000000
la_br &write_done
beq_t0,t1
+ # n = write(output_fd, &output_buf[output_written], output_used - output_written)
la_a0 &output_fd
ld_a1,a0,0
la_a2 &output_buf
@@ -145,11 +156,13 @@ DEFINE TOK_PASTE 0600000000000000
li_a0 sys_write
syscall
+ # n <= 0 is fatal (short write or error)
la_br &err_write
bltz_a0
la_br &err_write
beqz_a0
+ # output_written += n
la_a1 &output_written
ld_a2,a1,0
add_a2,a2,a0
@@ -158,6 +171,7 @@ DEFINE TOK_PASTE 0600000000000000
b
:write_done
+ # exit(0)
li_a0 sys_exit
li_a1 %0 %0
syscall
@@ -167,19 +181,24 @@ DEFINE TOK_PASTE 0600000000000000
## e.g. single-char parens/commas and the paste `##`). Source-word and string
## tokens point directly into input_buf and skip this arena.
-## append_text(a0=src, a1=len) -> a0=text ptr. Leaf; clobbers a0..a3, t0..t2.
+## append_text(a0=src, a1=len) -> a0=text ptr. Leaf.
:append_text
+ # a3 = text_used
la_a2 &text_used
ld_a3,a2,0
+
+ # if (text_used + len + 1) > TEXT_CAP: fatal
add_t0,a3,a1
addi_t0,t0,1
- li_t1 M1M_TEXT_CAP
+ li_t1 M1PP_TEXT_CAP
la_br &err_text_overflow
blt_t1,t0
+ # dst = &text_buf[text_used]
la_t0 &text_buf
add_t0,t0,a3
+ # for (i = 0; i < len; i++) dst[i] = src[i]
li_t1 %0 %0
:append_text_loop
la_br &append_text_done
@@ -192,51 +211,71 @@ DEFINE TOK_PASTE 0600000000000000
la_br &append_text_loop
b
:append_text_done
+ # dst[len] = '\0'
add_a2,t0,t1
li_t2 %0 %0
sb_t2,a2,0
+ # text_used += len + 1
la_a2 &text_used
ld_a3,a2,0
add_a3,a3,a1
addi_a3,a3,1
st_a3,a2,0
+ # return dst
mov_a0,t0
ret
## push_source_token(a0=kind, a1=text_ptr, a2=text_len). Leaf.
+## Token layout: +0 kind, +8 text_ptr, +16 text_len (24 bytes total).
:push_source_token
+ # tok = source_end
la_a3 &source_end
ld_t0,a3,0
+
+ # if (tok == &source_tokens[0] + TOKENS_END) fatal
la_t1 &source_tokens
- li_t2 M1M_TOKENS_END
+ li_t2 M1PP_TOKENS_END
add_t1,t1,t2
la_br &err_token_overflow
beq_t0,t1
+
+ # tok->kind = kind; tok->text_ptr = text_ptr; tok->text_len = text_len
st_a0,t0,0
st_a1,t0,8
st_a2,t0,16
+
+ # source_end = tok + 1 (advance 24 bytes)
addi_t0,t0,24
st_t0,a3,0
ret
## tok_eq_const(a0=token_ptr, a1=const_ptr, a2=const_len) -> a0=0/1. Leaf.
+## Compares a token's text against a constant byte string.
:tok_eq_const
+ # if (tok->text_len != const_len) return 0
ld_a3,a0,16
la_br &tok_eq_false
bne_a3,a2
+
+ # src = tok->text_ptr; i = 0
ld_t0,a0,8
li_t1 %0 %0
:tok_eq_loop
+ # if (i == const_len) return 1
la_br &tok_eq_true
beq_t1,a2
+
+ # if (src[i] != const_ptr[i]) return 0
add_t2,t0,t1
lb_t2,t2,0
add_a3,a1,t1
lb_a3,a3,0
la_br &tok_eq_false
bne_t2,a3
+
+ # i++
addi_t1,t1,1
la_br &tok_eq_loop
b
@@ -267,12 +306,14 @@ DEFINE TOK_PASTE 0600000000000000
la_a1 &lex_ptr
st_a0,a1,0
:lex_loop
+ # c = *lex_ptr; if (c == '\0') done
la_a0 &lex_ptr
ld_t0,a0,0
lb_a0,t0,0
la_br &lex_done
beqz_a0
+ # non-newline whitespace: ' ' '\t' '\r' '\f' '\v' -> skip one
li_a1 %32 %0
la_br &lex_skip_one
beq_a0,a1
@@ -289,6 +330,7 @@ DEFINE TOK_PASTE 0600000000000000
la_br &lex_skip_one
beq_a0,a1
+ # single-char dispatch: '\n' '"' '\'' '#' ';' '(' ')' ','
li_a1 %10 %0
la_br &lex_newline
beq_a0,a1
@@ -313,10 +355,13 @@ DEFINE TOK_PASTE 0600000000000000
li_a1 %44 %0
la_br &lex_comma
beq_a0,a1
+
+ # otherwise: word
la_br &lex_word
b
:lex_skip_one
+ # lex_ptr++
addi_t0,t0,1
la_a0 &lex_ptr
st_t0,a0,0
@@ -324,11 +369,14 @@ DEFINE TOK_PASTE 0600000000000000
b
:lex_newline
+ # push_source_token(TOK_NEWLINE, lex_ptr, 1)
mov_a1,t0
li_a0 TOK_NEWLINE
li_a2 %1 %0
la_br &push_source_token
call
+
+ # lex_ptr++
la_a0 &lex_ptr
ld_t0,a0,0
addi_t0,t0,1
@@ -337,33 +385,42 @@ DEFINE TOK_PASTE 0600000000000000
b
:lex_string
+ # lex_start = lex_ptr; lex_quote = c; lex_ptr++
la_a1 &lex_start
st_t0,a1,0
la_a1 &lex_quote
st_a0,a1,0
addi_t0,t0,1
:lex_string_scan
+ # c = *lex_ptr
lb_a0,t0,0
+ # if (c == '\0') finish (unterminated; keep what we have)
la_br &lex_string_finish
beqz_a0
+ # if (c == quote) consume closing quote and finish
la_a1 &lex_quote
ld_a1,a1,0
la_br &lex_string_after_quote
beq_a0,a1
+ # else lex_ptr++
addi_t0,t0,1
la_br &lex_string_scan
b
:lex_string_after_quote
addi_t0,t0,1
:lex_string_finish
+ # lex_ptr = t0
la_a1 &lex_ptr
st_t0,a1,0
+
+ # text_ptr = append_text(lex_start, lex_ptr - lex_start)
la_a1 &lex_start
ld_a0,a1,0
sub_a1,t0,a0
la_br &append_text
call
+ # push_source_token(TOK_STRING, text_ptr, lex_ptr - lex_start)
la_a1 &lex_ptr
ld_t0,a1,0
la_a1 &lex_start
@@ -377,6 +434,7 @@ DEFINE TOK_PASTE 0600000000000000
b
:lex_hash
+ # if (lex_ptr[1] == '#') goto lex_paste, else lex_comment
addi_a1,t0,1
lb_a1,a1,0
li_a2 %35 %0
@@ -386,15 +444,20 @@ DEFINE TOK_PASTE 0600000000000000
b
:lex_paste
+ # text_ptr = append_text("##", 2)
la_a0 &const_paste
li_a1 %2 %0
la_br &append_text
call
+
+ # push_source_token(TOK_PASTE, text_ptr, 2)
mov_a1,a0
li_a0 TOK_PASTE
li_a2 %2 %0
la_br &push_source_token
call
+
+ # lex_ptr += 2
la_a0 &lex_ptr
ld_t0,a0,0
addi_t0,t0,2
@@ -403,6 +466,7 @@ DEFINE TOK_PASTE 0600000000000000
b
:lex_comment
+ # skip to end of line: while (c != '\0' && c != '\n') lex_ptr++
la_a0 &lex_ptr
ld_t0,a0,0
:lex_comment_loop
@@ -421,6 +485,10 @@ DEFINE TOK_PASTE 0600000000000000
la_br &lex_loop
b
+## lex_lparen / lex_rparen / lex_comma all share the same shape:
+## append the single-char constant, push a 1-byte token of the right kind,
+## then fall through to lex_advance_one_then_loop to bump lex_ptr.
+
:lex_lparen
la_a0 &const_lparen
li_a1 %1 %0
@@ -456,6 +524,7 @@ DEFINE TOK_PASTE 0600000000000000
la_br &push_source_token
call
:lex_advance_one_then_loop
+ # lex_ptr++
la_a0 &lex_ptr
ld_t0,a0,0
addi_t0,t0,1
@@ -464,9 +533,11 @@ DEFINE TOK_PASTE 0600000000000000
b
:lex_word
+ # lex_start = lex_ptr
la_a1 &lex_start
st_t0,a1,0
:lex_word_scan
+ # c = *lex_ptr; stop at: '\0' ws/\n '#' ';' '(' ')' ','
lb_a0,t0,0
la_br &lex_word_finish
beqz_a0
@@ -503,18 +574,23 @@ DEFINE TOK_PASTE 0600000000000000
li_a1 %44 %0
la_br &lex_word_finish
beq_a0,a1
+ # else lex_ptr++
addi_t0,t0,1
la_br &lex_word_scan
b
:lex_word_finish
+ # lex_ptr = t0
la_a1 &lex_ptr
st_t0,a1,0
+
+ # text_ptr = append_text(lex_start, lex_ptr - lex_start)
la_a1 &lex_start
ld_a0,a1,0
sub_a1,t0,a0
la_br &append_text
call
+ # push_source_token(TOK_WORD, text_ptr, lex_ptr - lex_start)
la_a1 &lex_ptr
ld_t0,a1,0
la_a1 &lex_start
@@ -540,17 +616,22 @@ DEFINE TOK_PASTE 0600000000000000
## emit_newline(). Leaf.
:emit_newline
+ # if (output_used == OUTPUT_CAP) fatal
la_a0 &output_used
ld_t0,a0,0
- li_t1 M1M_OUTPUT_CAP
+ li_t1 M1PP_OUTPUT_CAP
la_br &err_output_overflow
beq_t0,t1
+
+ # output_buf[output_used] = '\n'; output_used++
la_a1 &output_buf
add_a1,a1,t0
li_t2 %10 %0
sb_t2,a1,0
addi_t0,t0,1
st_t0,a0,0
+
+ # output_need_space = 0
la_a0 &output_need_space
li_a1 %0 %0
st_a1,a0,0
@@ -558,6 +639,7 @@ DEFINE TOK_PASTE 0600000000000000
## emit_token(a0=token_ptr). Leaf.
:emit_token
+ # if (output_need_space) emit ' ' (skip the space for the first token on a line)
la_a1 &output_need_space
ld_t0,a1,0
la_br &emit_token_copy
@@ -565,7 +647,7 @@ DEFINE TOK_PASTE 0600000000000000
la_a1 &output_used
ld_t0,a1,0
- li_t1 M1M_OUTPUT_CAP
+ li_t1 M1PP_OUTPUT_CAP
la_br &err_output_overflow
beq_t0,t1
la_a2 &output_buf
@@ -576,17 +658,23 @@ DEFINE TOK_PASTE 0600000000000000
st_t0,a1,0
:emit_token_copy
+ # src = tok->text_ptr; len = tok->text_len; i = 0
ld_t0,a0,8
ld_t1,a0,16
li_t2 %0 %0
:emit_token_loop
+ # if (i == len) done
la_br &emit_token_done
beq_t2,t1
+
+ # if (output_used == OUTPUT_CAP) fatal
la_a1 &output_used
ld_a2,a1,0
- li_a3 M1M_OUTPUT_CAP
+ li_a3 M1PP_OUTPUT_CAP
la_br &err_output_overflow
beq_a2,a3
+
+ # output_buf[output_used++] = src[i]
add_a3,t0,t2
lb_a3,a3,0
la_a0 &output_buf
@@ -594,10 +682,13 @@ DEFINE TOK_PASTE 0600000000000000
sb_a3,a0,0
addi_a2,a2,1
st_a2,a1,0
+
+ # i++
addi_t2,t2,1
la_br &emit_token_loop
b
:emit_token_done
+ # output_need_space = 1
la_a0 &output_need_space
li_a1 %1 %0
st_a1,a0,0
@@ -614,13 +705,17 @@ DEFINE TOK_PASTE 0600000000000000
## process_tokens(): pass-through with structural %macro skipping.
:process_tokens
enter_0
+
+ # proc_pos = &source_tokens; proc_line_start = 1
la_a0 &source_tokens
la_a1 &proc_pos
st_a0,a1,0
la_a0 &proc_line_start
li_a1 %1 %0
st_a1,a0,0
+
:process_loop
+ # tok = proc_pos; if (tok == source_end) done
la_a0 &proc_pos
ld_t0,a0,0
la_a1 &source_end
@@ -628,14 +723,19 @@ DEFINE TOK_PASTE 0600000000000000
la_br &process_done
beq_t0,t1
+ # if (!line_start) fall through to non-macro branch
la_a0 &proc_line_start
ld_t2,a0,0
la_br &process_not_macro
beqz_t2
+
+ # if (tok->kind != TOK_WORD) not a %macro line
ld_a1,t0,0
li_a2 TOK_WORD
la_br &process_not_macro
bne_a1,a2
+
+ # if (!tok_eq_const(tok, "%macro", 6)) not a %macro line
mov_a0,t0
la_a1 &const_macro
li_a2 %6 %0
@@ -643,18 +743,25 @@ DEFINE TOK_PASTE 0600000000000000
call
la_br &process_not_macro
beqz_a0
+
+ # line-start %macro -> consume the definition
la_br &skip_macro_def
call
la_br &process_loop
b
:process_not_macro
+ # reload tok (registers clobbered by the tok_eq_const call above)
la_a0 &proc_pos
ld_t0,a0,0
ld_a1,t0,0
+
+ # if (tok->kind != TOK_NEWLINE) emit it
li_a2 TOK_NEWLINE
la_br &process_regular_token
bne_a1,a2
+
+ # newline: emit_newline, proc_pos++, line_start = 1
la_br &emit_newline
call
la_a0 &proc_pos
@@ -668,6 +775,7 @@ DEFINE TOK_PASTE 0600000000000000
b
:process_regular_token
+ # emit_token(tok); proc_pos++; line_start = 0
la_a0 &proc_pos
ld_a0,a0,0
la_br &emit_token
@@ -694,6 +802,8 @@ DEFINE TOK_PASTE 0600000000000000
## skip_macro_def(): proc_pos at %macro. Leaves proc_pos after %endm line.
:skip_macro_def
enter_0
+
+ # consume the %macro token itself, then scan with our own line_start bit
la_a0 &proc_pos
ld_t0,a0,0
addi_t0,t0,24
@@ -701,7 +811,9 @@ DEFINE TOK_PASTE 0600000000000000
la_a0 &skip_line_start
li_a1 %0 %0
st_a1,a0,0
+
:skip_macro_loop
+ # tok = proc_pos; if (tok == source_end) fatal (unterminated)
la_a0 &proc_pos
ld_t0,a0,0
la_a1 &source_end
@@ -709,14 +821,19 @@ DEFINE TOK_PASTE 0600000000000000
la_br &err_unterminated_macro
beq_t0,t1
+ # if (!skip_line_start) just advance past tok
la_a0 &skip_line_start
ld_t2,a0,0
la_br &skip_check_advance
beqz_t2
+
+ # if (tok->kind != TOK_WORD) just advance
ld_a1,t0,0
li_a2 TOK_WORD
la_br &skip_check_advance
bne_a1,a2
+
+ # if (!tok_eq_const(tok, "%endm", 5)) just advance
mov_a0,t0
la_a1 &const_endm
li_a2 %5 %0
@@ -725,7 +842,10 @@ DEFINE TOK_PASTE 0600000000000000
la_br &skip_check_advance
beqz_a0
+ # matched %endm at line start -- fall through to skip_to_line_end
+
:skip_to_line_end
+ # walk to the first newline (inclusive) and stop
la_a0 &proc_pos
ld_t0,a0,0
la_a1 &source_end
@@ -744,6 +864,7 @@ DEFINE TOK_PASTE 0600000000000000
:skip_done_after_newline
:skip_done_at_eof
+ # caller resumes at line start
la_a0 &proc_line_start
li_a1 %1 %0
st_a1,a0,0
@@ -751,12 +872,15 @@ DEFINE TOK_PASTE 0600000000000000
ret
:skip_check_advance
+ # update skip_line_start based on tok->kind, then bump proc_pos
la_a0 &proc_pos
ld_t0,a0,0
ld_a1,t0,0
li_a2 TOK_NEWLINE
la_br &skip_set_not_line_start
bne_a1,a2
+
+ # tok is TOK_NEWLINE: next iteration is at line start
la_a0 &skip_line_start
li_a1 %1 %0
st_a1,a0,0
@@ -767,6 +891,7 @@ DEFINE TOK_PASTE 0600000000000000
li_a1 %0 %0
st_a1,a0,0
:skip_inc_pos
+ # proc_pos++
la_a0 &proc_pos
ld_t0,a0,0
addi_t0,t0,24
@@ -775,7 +900,7 @@ DEFINE TOK_PASTE 0600000000000000
b
## --- Error paths -------------------------------------------------------------
-## Each err_* loads a (msg, len) pair for fatal; fatal writes "m1m: <msg>\n"
+## Each err_* loads a (msg, len) pair for fatal; fatal writes "m1pp: <msg>\n"
## to stderr and exits 1. Error labels are branched to from range/overflow
## checks throughout the code.
@@ -830,18 +955,23 @@ DEFINE TOK_PASTE 0600000000000000
la_br &fatal
b
+## fatal(a0=msg_ptr, a1=msg_len): writes "m1pp: <msg>\n" to stderr, exits 1.
+## Saves args across the three syscalls since a0..a3 are caller-saved.
:fatal
+ # stash msg/len so the first syscall doesn't clobber them
la_a2 &err_saved_msg
st_a0,a2,0
la_a2 &err_saved_len
st_a1,a2,0
+ # write(2, "m1pp: ", 5)
li_a0 sys_write
li_a1 %2 %0
la_a2 &msg_prefix
li_a3 %5 %0
syscall
+ # write(2, msg, len)
la_a0 &err_saved_msg
ld_a2,a0,0
la_a0 &err_saved_len
@@ -850,12 +980,14 @@ DEFINE TOK_PASTE 0600000000000000
li_a1 %2 %0
syscall
+ # write(2, "\n", 1)
li_a0 sys_write
li_a1 %2 %0
la_a2 &msg_newline
li_a3 %1 %0
syscall
+ # exit(1)
li_a0 sys_exit
li_a1 %1 %0
syscall
@@ -869,10 +1001,10 @@ DEFINE TOK_PASTE 0600000000000000
:const_rparen ")"
:const_comma ","
-:msg_prefix "m1m: "
+:msg_prefix "m1pp: "
:msg_newline "
"
-:msg_usage "usage: m1m input.M1 output.M1"
+:msg_usage "usage: m1pp input.M1 output.M1"
:msg_open_input "failed to open input file"
:msg_read "failed to read input"
:msg_input_too_big "input file too large"
@@ -928,7 +1060,7 @@ ZERO32
:err_saved_len
ZERO32
-## input_buf: 8 KB (M1M_INPUT_CAP)
+## input_buf: 8 KB (M1PP_INPUT_CAP)
:input_buf
ZERO32 ZERO32 ZERO32 ZERO32 ZERO32 ZERO32 ZERO32 ZERO32
ZERO32 ZERO32 ZERO32 ZERO32 ZERO32 ZERO32 ZERO32 ZERO32
@@ -963,7 +1095,7 @@ ZERO32 ZERO32 ZERO32 ZERO32 ZERO32 ZERO32 ZERO32 ZERO32
ZERO32 ZERO32 ZERO32 ZERO32 ZERO32 ZERO32 ZERO32 ZERO32
ZERO32 ZERO32 ZERO32 ZERO32 ZERO32 ZERO32 ZERO32 ZERO32
-## output_buf: 8 KB (M1M_OUTPUT_CAP)
+## output_buf: 8 KB (M1PP_OUTPUT_CAP)
:output_buf
ZERO32 ZERO32 ZERO32 ZERO32 ZERO32 ZERO32 ZERO32 ZERO32
ZERO32 ZERO32 ZERO32 ZERO32 ZERO32 ZERO32 ZERO32 ZERO32
@@ -998,7 +1130,7 @@ ZERO32 ZERO32 ZERO32 ZERO32 ZERO32 ZERO32 ZERO32 ZERO32
ZERO32 ZERO32 ZERO32 ZERO32 ZERO32 ZERO32 ZERO32 ZERO32
ZERO32 ZERO32 ZERO32 ZERO32 ZERO32 ZERO32 ZERO32 ZERO32
-## text_buf: 4 KB (M1M_TEXT_CAP)
+## text_buf: 4 KB (M1PP_TEXT_CAP)
:text_buf
ZERO32 ZERO32 ZERO32 ZERO32 ZERO32 ZERO32 ZERO32 ZERO32
ZERO32 ZERO32 ZERO32 ZERO32 ZERO32 ZERO32 ZERO32 ZERO32
@@ -1017,7 +1149,7 @@ ZERO32 ZERO32 ZERO32 ZERO32 ZERO32 ZERO32 ZERO32 ZERO32
ZERO32 ZERO32 ZERO32 ZERO32 ZERO32 ZERO32 ZERO32 ZERO32
ZERO32 ZERO32 ZERO32 ZERO32 ZERO32 ZERO32 ZERO32 ZERO32
-## source_tokens: 256 slots × 24 bytes = 6 KB (M1M_TOKENS_END)
+## source_tokens: 256 slots × 24 bytes = 6 KB (M1PP_TOKENS_END)
:source_tokens
ZERO32 ZERO32 ZERO32 ZERO32 ZERO32 ZERO32 ZERO32 ZERO32
ZERO32 ZERO32 ZERO32 ZERO32 ZERO32 ZERO32 ZERO32 ZERO32
