boot2

M1pp.c (48376B)

---

 /*
  * Tiny single-pass M1 macro expander.
  *
  * Syntax:
  *   %macro NAME(a, b)
  *   ... body ...
  *   %endm
  *
  *   %struct NAME { f1 f2 ... }   fixed-layout 8-byte-field aggregate
  *   %enum   NAME { l1 l2 ... }   incrementing integer constants
  *
  *   %NAME(x, y)      function-like macro call
  *   ##               token pasting inside macro bodies
  *   !(expr)          evaluate an integer S-expression, emit LE 8-bit hex
  *   @(expr)          evaluate an integer S-expression, emit LE 16-bit hex
  *   %(expr)          evaluate an integer S-expression, emit LE 32-bit hex
  *   $(expr)          evaluate an integer S-expression, emit LE 64-bit hex
  *   %select(c,t,e)   evaluate condition S-expression; expand t if nonzero else e
  *   %str(IDENT)      stringify a single WORD token into a "..."-quoted literal
  *
  * Expression syntax is intentionally Lisp-shaped:
  *   atoms: decimal or 0x-prefixed integer literals
  *   calls: (+ a b), (- a b), (* a b), (/ a b), (% a b), (<< a b), (>> a b)
  *          (& a b), (| a b), (^ a b), (~ a), (= a b), (!= a b),
  *          (< a b), (<= a b), (> a b), (>= a b)
  *
  * Flow:
  *   1. lex_source(): scan input_buf into source_tokens[]. Tokens are words,
  *      strings, newlines, parens, commas, and ## paste markers. Whitespace
  *      (excluding newlines) is dropped; # and ; comments are dropped.
  *
  *   2. process_tokens(): main loop driven by a stream stack (streams[]).
  *      The source token array is pushed as the initial stream. Each iteration
  *      pops a token from the top stream:
  *
  *        %macro NAME(p,...) / %endm at line-start
  *          -> define_macro(): consume header + body tokens into macros[] and
  *             macro_body_tokens[]; register name and param list.
  *
  *        !(e) / @(e) / %(e) / $(e) / %select(c,t,e)
  *          -> expand_builtin_call(): parse arg spans, eval S-expression(s) via
  *             eval_expr_range(), emit LE hex or push the chosen token span.
  *
  *        %NAME(...) matching a defined macro
  *          -> expand_call() -> expand_macro_tokens(): substitute arguments,
  *             apply ## paste via paste_pool_range(), write result into
  *             expand_pool[], then push that slice as a new stream (rescan).
  *
  *        Anything else
  *          -> emit_token() / emit_newline() directly into output_buf.
  *
  *      When a stream is exhausted it is popped; pool_used is rewound to the
  *      stream's pool_mark, reclaiming the expand_pool space it used.
  *
  *   3. Write output_buf to the output file.
  *
  * Notes:
  *   - Macros are define-before-use. There is no prescan.
  *   - Expansion rescans by pushing expanded tokens back through the same loop.
  *   - There is no cycle detection. Recursive macros will loop until a limit.
  *   - Only recognized %NAME(...) calls expand. Other text passes through.
  *   - Output formatting is normalized to tokens plus '\n', not preserved.
  */
 
 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
 #define MAX_INPUT             262144
 #define MAX_OUTPUT            524288
 #define MAX_TEXT              524288
 #define MAX_TOKENS            65536
 #define MAX_MACROS            512
 #define MAX_PARAMS            16
 #define MAX_MACRO_BODY_TOKENS MAX_TOKENS
 #define MAX_EXPAND            65536
 #define MAX_STACK             64
 #define MAX_EXPR_FRAMES       256
 #define MAX_SCOPE_DEPTH       32
 
 enum {
     TOK_WORD,
     TOK_STRING,
     TOK_NEWLINE,
     TOK_LPAREN,
     TOK_RPAREN,
     TOK_COMMA,
     TOK_PASTE,
     TOK_LBRACE,
     TOK_RBRACE
 };
 
 enum ExprOp {
     EXPR_ADD,
     EXPR_SUB,
     EXPR_MUL,
     EXPR_DIV,
     EXPR_MOD,
     EXPR_SHL,
     EXPR_SHR,
     EXPR_AND,
     EXPR_OR,
     EXPR_XOR,
     EXPR_NOT,
     EXPR_EQ,
     EXPR_NE,
     EXPR_LT,
     EXPR_LE,
     EXPR_GT,
     EXPR_GE,
     EXPR_STRLEN,
     EXPR_INVALID
 };
 
 struct TextSpan {
     const char *ptr;
     int len;
 };
 
 struct Token {
     int kind;
     struct TextSpan text;
 };
 
 struct TokenSpan {
     struct Token *start;
     struct Token *end;
 };
 
 struct Macro {
     struct TextSpan name;
     int param_count;
     struct TextSpan params[MAX_PARAMS];
     struct Token *body_start;
     struct Token *body_end;
 };
 
 struct Stream {
     struct Token *start;
     struct Token *end;
     struct Token *pos;
     int line_start;
     int pool_mark;
 };
 
 struct ExprFrame {
     enum ExprOp op;
     long long args[MAX_PARAMS];
     int argc;
 };
 
 static char input_buf[MAX_INPUT + 1];
 static char output_buf[MAX_OUTPUT + 1];
 static char text_buf[MAX_TEXT];
 
 static struct Token source_tokens[MAX_TOKENS];
 static struct Token macro_body_tokens[MAX_MACRO_BODY_TOKENS];
 static struct Token expand_pool[MAX_EXPAND];
 static struct Macro macros[MAX_MACROS];
 static struct Stream streams[MAX_STACK];
 static struct TextSpan scope_stack[MAX_SCOPE_DEPTH];
 
 static int text_used;
 static int source_count;
 static int macro_count;
 static int macro_body_used;
 static int pool_used;
 static int output_used;
 static int output_need_space;
 static int stream_top;
 static int next_expansion_id;
 static int scope_depth;
 
 static struct Token *arg_starts[MAX_PARAMS];
 static struct Token *arg_ends[MAX_PARAMS];
 static int arg_count;
 static struct Token *call_end_pos;
 
 static const char *error_msg;
 
 static int fail(const char *msg)
 {
     error_msg = msg;
     return 0;
 }
 
 static int is_space_no_nl(int c)
 {
     return c == ' ' || c == '\t' || c == '\r' || c == '\f' || c == '\v';
 }
 
 static char *append_text_len(const char *s, int len)
 {
     int start;
 
     if (text_used + len + 1 > MAX_TEXT) {
         fail("text overflow");
         return NULL;
     }
     start = text_used;
     memcpy(text_buf + text_used, s, (size_t)len);
     text_used += len;
     text_buf[text_used++] = '\0';
     return text_buf + start;
 }
 
 static int push_token(struct Token *buf, int *count, int max_count,
                       int kind, struct TextSpan text)
 {
     if (*count >= max_count) {
         return fail("token overflow");
     }
     buf[*count].kind = kind;
     buf[*count].text = text;
     *count += 1;
     return 1;
 }
 
 static int push_pool_token(struct Token tok)
 {
     if (pool_used >= MAX_EXPAND) {
         return fail("expansion overflow");
     }
     expand_pool[pool_used++] = tok;
     return 1;
 }
 
 static int token_text_eq(const struct Token *tok, const char *s)
 {
     int len = (int)strlen(s);
 
     return tok->text.len == len &&
            memcmp(tok->text.ptr, s, (size_t)len) == 0;
 }
 
 static int span_eq_token(struct TextSpan span, const struct Token *tok)
 {
     return span.len == tok->text.len &&
            memcmp(span.ptr, tok->text.ptr, (size_t)span.len) == 0;
 }
 
 static int lex_source(const char *src)
 {
     int i = 0;
 
     while (src[i] != '\0') {
         int start;
         int len;
 
         if (is_space_no_nl((unsigned char)src[i])) {
             i++;
             continue;
         }
         if (src[i] == '\n') {
             if (!push_token(source_tokens, &source_count, MAX_TOKENS,
                             TOK_NEWLINE, (struct TextSpan){src + i, 1})) {
                 return 0;
             }
             i++;
             continue;
         }
         if (src[i] == '"' || src[i] == '\'') {
             int quote = src[i];
 
             start = i;
             i++;
             while (src[i] != '\0' && src[i] != quote) {
                 i++;
             }
             if (src[i] == quote) {
                 i++;
             }
             len = i - start;
             if (!push_token(source_tokens, &source_count, MAX_TOKENS,
                             TOK_STRING, (struct TextSpan){src + start, len})) {
                 return 0;
             }
             continue;
         }
         if (src[i] == '#' && src[i + 1] == '#') {
             if (!push_token(source_tokens, &source_count, MAX_TOKENS,
                             TOK_PASTE, (struct TextSpan){src + i, 2})) {
                 return 0;
             }
             i += 2;
             continue;
         }
         if (src[i] == '#' || src[i] == ';') {
             while (src[i] != '\0' && src[i] != '\n') {
                 i++;
             }
             continue;
         }
         if (src[i] == '(') {
             if (!push_token(source_tokens, &source_count, MAX_TOKENS,
                             TOK_LPAREN, (struct TextSpan){src + i, 1})) {
                 return 0;
             }
             i++;
             continue;
         }
         if (src[i] == ')') {
             if (!push_token(source_tokens, &source_count, MAX_TOKENS,
                             TOK_RPAREN, (struct TextSpan){src + i, 1})) {
                 return 0;
             }
             i++;
             continue;
         }
         if (src[i] == ',') {
             if (!push_token(source_tokens, &source_count, MAX_TOKENS,
                             TOK_COMMA, (struct TextSpan){src + i, 1})) {
                 return 0;
             }
             i++;
             continue;
         }
         if (src[i] == '{') {
             if (!push_token(source_tokens, &source_count, MAX_TOKENS,
                             TOK_LBRACE, (struct TextSpan){src + i, 1})) {
                 return 0;
             }
             i++;
             continue;
         }
         if (src[i] == '}') {
             if (!push_token(source_tokens, &source_count, MAX_TOKENS,
                             TOK_RBRACE, (struct TextSpan){src + i, 1})) {
                 return 0;
             }
             i++;
             continue;
         }
 
         start = i;
         while (src[i] != '\0' &&
                !is_space_no_nl((unsigned char)src[i]) &&
                src[i] != '\n' &&
                src[i] != '#' &&
                src[i] != ';' &&
                src[i] != '(' &&
                src[i] != ')' &&
                src[i] != ',' &&
                src[i] != '{' &&
                src[i] != '}' &&
                !(src[i] == '#' && src[i + 1] == '#')) {
             i++;
         }
         len = i - start;
         if (!push_token(source_tokens, &source_count, MAX_TOKENS,
                         TOK_WORD, (struct TextSpan){src + start, len})) {
             return 0;
         }
     }
 
     return 1;
 }
 
 static const struct Macro *find_macro(const struct Token *tok)
 {
     int i;
 
     if (tok->kind != TOK_WORD || tok->text.len < 2) {
         return NULL;
     }
     if (tok->text.ptr[0] != '%') {
         return NULL;
     }
     for (i = 0; i < macro_count; i++) {
         if (macros[i].name.len == tok->text.len - 1 &&
             memcmp(tok->text.ptr + 1,
                    macros[i].name.ptr,
                    (size_t)macros[i].name.len) == 0) {
             return &macros[i];
         }
     }
     return NULL;
 }
 
 static int find_param(const struct Macro *m, const struct Token *tok)
 {
     int i;
 
     if (tok->kind != TOK_WORD) {
         return 0;
     }
     for (i = 0; i < m->param_count; i++) {
         if (span_eq_token(m->params[i], tok)) {
             return i + 1;
         }
     }
     return 0;
 }
 
 static int emit_newline(void)
 {
     if (output_used + 1 >= MAX_OUTPUT) {
         return fail("output overflow");
     }
     output_buf[output_used++] = '\n';
     output_need_space = 0;
     return 1;
 }
 
 static int emit_scoped_label(const struct Token *tok, int skip, char sigil)
 {
     /* Rewrite `::name` or `&::name` against the current scope stack.
      * skip is the number of leading chars to drop (`::` -> 2, `&::` -> 3);
      * sigil is the single-char prefix to emit (`:` for definitions, `&`
      * for references). With a non-empty scope stack the output is
      * sigil + scope1 + "__" + ... + scopeN + "__" + name; with an empty
      * stack it degrades to sigil + name (pass-through). */
     int name_len = tok->text.len - skip;
     int i;
 
     if (name_len <= 0) {
         return fail("bad scope label");
     }
 
     if (output_need_space) {
         if (output_used + 1 >= MAX_OUTPUT) {
             return fail("output overflow");
         }
         output_buf[output_used++] = ' ';
     }
 
     if (output_used + 1 >= MAX_OUTPUT) {
         return fail("output overflow");
     }
     output_buf[output_used++] = sigil;
 
     for (i = 0; i < scope_depth; i++) {
         int span_len = scope_stack[i].len;
         if (output_used + span_len + 2 >= MAX_OUTPUT) {
             return fail("output overflow");
         }
         memcpy(output_buf + output_used, scope_stack[i].ptr,
                (size_t)span_len);
         output_used += span_len;
         output_buf[output_used++] = '_';
         output_buf[output_used++] = '_';
     }
 
     if (output_used + name_len >= MAX_OUTPUT) {
         return fail("output overflow");
     }
     memcpy(output_buf + output_used, tok->text.ptr + skip, (size_t)name_len);
     output_used += name_len;
     output_need_space = 1;
     return 1;
 }
 
 static int emit_token(const struct Token *tok)
 {
     if (tok->kind == TOK_LBRACE || tok->kind == TOK_RBRACE) {
         return 1;
     }
     if (tok->kind == TOK_WORD && tok->text.len >= 2 &&
         tok->text.ptr[0] == ':' && tok->text.ptr[1] == ':') {
         return emit_scoped_label(tok, 2, ':');
     }
     if (tok->kind == TOK_WORD && tok->text.len >= 3 &&
         tok->text.ptr[0] == '&' &&
         tok->text.ptr[1] == ':' && tok->text.ptr[2] == ':') {
         return emit_scoped_label(tok, 3, '&');
     }
     if (output_need_space) {
         if (output_used + 1 >= MAX_OUTPUT) {
             return fail("output overflow");
         }
         output_buf[output_used++] = ' ';
     }
     if (output_used + tok->text.len >= MAX_OUTPUT) {
         return fail("output overflow");
     }
     memcpy(output_buf + output_used, tok->text.ptr,
            (size_t)tok->text.len);
     output_used += tok->text.len;
     output_need_space = 1;
     return 1;
 }
 
 static int push_stream_span(struct TokenSpan span, int pool_mark)
 {
     struct Stream *s;
 
     if (stream_top >= MAX_STACK) {
         return fail("stream overflow");
     }
     s = &streams[stream_top++];
     s->start = span.start;
     s->end = span.end;
     s->pos = span.start;
     s->line_start = 1;
     s->pool_mark = pool_mark;
     return 1;
 }
 
 static struct Stream *current_stream(void)
 {
     if (stream_top <= 0) {
         return NULL;
     }
     return &streams[stream_top - 1];
 }
 
 static void pop_stream(void)
 {
     if (stream_top <= 0) {
         return;
     }
     stream_top--;
     if (streams[stream_top].pool_mark >= 0) {
         pool_used = streams[stream_top].pool_mark;
     }
 }
 
 static int copy_span_to_pool(struct TokenSpan span)
 {
     struct Token *tok;
 
     for (tok = span.start; tok < span.end; tok++) {
         if (!push_pool_token(*tok)) {
             return 0;
         }
     }
     return 1;
 }
 
 static int push_pool_stream_from_mark(int mark)
 {
     if (pool_used == mark) {
         pool_used = mark;
         return 1;
     }
     return push_stream_span((struct TokenSpan){expand_pool + mark, expand_pool + pool_used},
                             mark);
 }
 
 static void skip_expr_newlines(struct Token **pos, struct Token *end)
 {
     while (*pos < end && (*pos)->kind == TOK_NEWLINE) {
         *pos += 1;
     }
 }
 
 static int emit_decimal_text(long long value, struct TextSpan *out)
 {
     /* Render a non-negative integer as decimal into text_buf and
      * return the span. No snprintf; plain reverse-fill. */
     char digits[24];
     int digit_count = 0;
     long long v = value;
     int start;
     int i;
 
     if (v < 0) {
         return fail("bad directive");
     }
     if (v == 0) {
         digits[digit_count++] = '0';
     } else {
         while (v > 0) {
             digits[digit_count++] = (char)('0' + (v % 10));
             v /= 10;
         }
     }
 
     if (text_used + digit_count + 1 > MAX_TEXT) {
         return fail("text overflow");
     }
     start = text_used;
     for (i = digit_count - 1; i >= 0; i--) {
         text_buf[text_used++] = digits[i];
     }
     text_buf[text_used++] = '\0';
     out->ptr = text_buf + start;
     out->len = digit_count;
     return 1;
 }
 
 static int emit_dotted_name(struct TextSpan base, const char *suffix,
                             int suffix_len, struct TextSpan *out)
 {
     int total = base.len + 1 + suffix_len;
     int start;
 
     if (text_used + total + 1 > MAX_TEXT) {
         return fail("text overflow");
     }
     start = text_used;
     memcpy(text_buf + text_used, base.ptr, (size_t)base.len);
     text_used += base.len;
     text_buf[text_used++] = '.';
     memcpy(text_buf + text_used, suffix, (size_t)suffix_len);
     text_used += suffix_len;
     text_buf[text_used++] = '\0';
     out->ptr = text_buf + start;
     out->len = total;
     return 1;
 }
 
 static int define_fielded_macro(struct TextSpan base, const char *suffix,
                                 int suffix_len, long long value)
 {
     struct Macro *m;
     struct Token body_tok;
 
     if (macro_count >= MAX_MACROS) {
         return fail("too many macros");
     }
     if (macro_body_used >= MAX_MACRO_BODY_TOKENS) {
         return fail("macro body overflow");
     }
     m = &macros[macro_count];
     memset(m, 0, sizeof(*m));
     if (!emit_dotted_name(base, suffix, suffix_len, &m->name)) {
         return 0;
     }
     m->param_count = 0;
     body_tok.kind = TOK_WORD;
     if (!emit_decimal_text(value, &body_tok.text)) {
         return 0;
     }
     m->body_start = macro_body_tokens + macro_body_used;
     macro_body_tokens[macro_body_used++] = body_tok;
     m->body_end = macro_body_tokens + macro_body_used;
     macro_count++;
     return 1;
 }
 
 static int define_fielded(struct Stream *s, long long stride,
                           const char *total_name, int total_name_len)
 {
     /* Parses `%struct NAME { f1 f2 ... }` or `%enum NAME { ... }` and
      * synthesizes N+1 zero-parameter macros:
      *   NAME.field_k  -> k * stride
      *   NAME.<total>  -> N * stride    (SIZE for struct, COUNT for enum) */
     struct TextSpan base;
     long long index = 0;
 
     s->pos++;
     if (s->pos >= s->end || s->pos->kind != TOK_WORD) {
         return fail("bad directive");
     }
     base = s->pos->text;
     s->pos++;
 
     while (s->pos < s->end && s->pos->kind == TOK_NEWLINE) {
         s->pos++;
     }
     if (s->pos >= s->end || s->pos->kind != TOK_LBRACE) {
         return fail("bad directive");
     }
     s->pos++;
 
     for (;;) {
         while (s->pos < s->end &&
                (s->pos->kind == TOK_COMMA || s->pos->kind == TOK_NEWLINE)) {
             s->pos++;
         }
         if (s->pos >= s->end) {
             return fail("unterminated directive");
         }
         if (s->pos->kind == TOK_RBRACE) {
             s->pos++;
             break;
         }
         if (s->pos->kind != TOK_WORD) {
             return fail("bad directive");
         }
         if (!define_fielded_macro(base, s->pos->text.ptr, s->pos->text.len,
                                   index * stride)) {
             return 0;
         }
         s->pos++;
         index++;
     }
 
     if (!define_fielded_macro(base, total_name, total_name_len, index * stride)) {
         return 0;
     }
 
     while (s->pos < s->end && s->pos->kind != TOK_NEWLINE) {
         s->pos++;
     }
     if (s->pos < s->end && s->pos->kind == TOK_NEWLINE) {
         s->pos++;
     }
     s->line_start = 1;
     return 1;
 }
 
 static int define_macro(struct Stream *s)
 {
     struct Macro *m;
     int line_start;
 
     if (macro_count >= MAX_MACROS) {
         return fail("too many macros");
     }
     if (macro_body_used >= MAX_MACRO_BODY_TOKENS) {
         return fail("macro body overflow");
     }
 
     m = &macros[macro_count];
     memset(m, 0, sizeof(*m));
     s->pos++;
 
     if (s->pos >= s->end || s->pos->kind != TOK_WORD) {
         return fail("bad macro header");
     }
     m->name = s->pos->text;
     s->pos++;
 
     if (s->pos >= s->end || s->pos->kind != TOK_LPAREN) {
         return fail("bad macro header");
     }
     s->pos++;
 
     if (s->pos < s->end && s->pos->kind != TOK_RPAREN) {
         while (1) {
             if (m->param_count >= MAX_PARAMS) {
                 return fail("bad macro header");
             }
             if (s->pos >= s->end || s->pos->kind != TOK_WORD) {
                 return fail("bad macro header");
             }
             m->params[m->param_count] = s->pos->text;
             m->param_count++;
             s->pos++;
             if (s->pos < s->end && s->pos->kind == TOK_COMMA) {
                 s->pos++;
                 continue;
             }
             break;
         }
     }
 
     if (s->pos >= s->end || s->pos->kind != TOK_RPAREN) {
         return fail("bad macro header");
     }
     s->pos++;
 
     if (s->pos >= s->end || s->pos->kind != TOK_NEWLINE) {
         return fail("bad macro header");
     }
     s->pos++;
 
     m->body_start = macro_body_tokens + macro_body_used;
     line_start = 1;
     while (s->pos < s->end) {
         if (line_start &&
             s->pos->kind == TOK_WORD &&
             token_text_eq(s->pos, "%endm")) {
             while (s->pos < s->end && s->pos->kind != TOK_NEWLINE) {
                 s->pos++;
             }
             if (s->pos < s->end && s->pos->kind == TOK_NEWLINE) {
                 s->pos++;
             }
             m->body_end = macro_body_tokens + macro_body_used;
             s->line_start = 1;
             macro_count++;
             return 1;
         }
         if (macro_body_used >= MAX_MACRO_BODY_TOKENS) {
             return fail("macro body overflow");
         }
         macro_body_tokens[macro_body_used++] = *s->pos;
         line_start = (s->pos->kind == TOK_NEWLINE);
         s->pos++;
     }
 
     return fail("unterminated macro");
 }
 
 static int parse_args(struct Token *lparen, struct Token *limit)
 {
     struct Token *tok = lparen + 1;
     struct Token *arg_start = tok;
     int depth = 1;
     int brace_depth = 0;
     int arg_index = 0;
 
     while (tok < limit) {
         if (tok->kind == TOK_LPAREN) {
             depth++;
             tok++;
             continue;
         }
         if (tok->kind == TOK_RPAREN) {
             depth--;
             if (depth == 0) {
                 if (brace_depth != 0) {
                     return fail("unbalanced braces");
                 }
                 if (arg_start == tok && arg_index == 0) {
                     arg_count = 0;
                 } else {
                     if (arg_index >= MAX_PARAMS) {
                         return fail("too many args");
                     }
                     arg_starts[arg_index] = arg_start;
                     arg_ends[arg_index] = tok;
                     arg_count = arg_index + 1;
                 }
                 call_end_pos = tok + 1;
                 return 1;
             }
             tok++;
             continue;
         }
         if (tok->kind == TOK_LBRACE) {
             brace_depth++;
             tok++;
             continue;
         }
         if (tok->kind == TOK_RBRACE) {
             if (brace_depth <= 0) {
                 return fail("unbalanced braces");
             }
             brace_depth--;
             tok++;
             continue;
         }
         if (tok->kind == TOK_COMMA && depth == 1 && brace_depth == 0) {
             if (arg_index >= MAX_PARAMS) {
                 return fail("too many args");
             }
             arg_starts[arg_index] = arg_start;
             arg_ends[arg_index] = tok;
             arg_index++;
             arg_start = tok + 1;
             tok++;
             continue;
         }
         tok++;
     }
 
     return fail("unterminated macro call");
 }
 
 static int arg_is_braced(struct TokenSpan span)
 {
     struct Token *tok;
     int depth;
 
     if (span.end - span.start < 2) {
         return 0;
     }
     if (span.start->kind != TOK_LBRACE ||
         (span.end - 1)->kind != TOK_RBRACE) {
         return 0;
     }
     depth = 0;
     for (tok = span.start; tok < span.end; tok++) {
         if (tok->kind == TOK_LBRACE) {
             depth++;
         } else if (tok->kind == TOK_RBRACE) {
             depth--;
             if (depth == 0 && tok != span.end - 1) {
                 return 0;
             }
         }
     }
     return depth == 0;
 }
 
 static int copy_arg_tokens_to_pool(struct TokenSpan span)
 {
     if (span.start == span.end) {
         return fail("bad macro argument");
     }
     if (arg_is_braced(span)) {
         struct TokenSpan inner;
         inner.start = span.start + 1;
         inner.end = span.end - 1;
         if (inner.start == inner.end) {
             return 1;
         }
         return copy_span_to_pool(inner);
     }
     return copy_span_to_pool(span);
 }
 
 static int copy_paste_arg_to_pool(struct TokenSpan span)
 {
     if (arg_is_braced(span)) {
         return fail("bad macro argument");
     }
     if (span.end - span.start != 1) {
         return fail("bad macro argument");
     }
     return copy_span_to_pool(span);
 }
 
 static int append_pasted_token(struct Token *dst,
                                const struct Token *left,
                                const struct Token *right)
 {
     char tmp[512];
     char *text_ptr;
     int n;
 
     n = snprintf(tmp, sizeof(tmp), "%.*s%.*s",
                  left->text.len, left->text.ptr,
                  right->text.len, right->text.ptr);
     if (n < 0 || n >= (int)sizeof(tmp)) {
         return fail("bad paste");
     }
     text_ptr = append_text_len(tmp, n);
     if (text_ptr == NULL) {
         return 0;
     }
     dst->kind = TOK_WORD;
     dst->text.ptr = text_ptr;
     dst->text.len = n;
     return 1;
 }
 
 static int paste_pool_range(int mark)
 {
     struct Token *start = expand_pool + mark;
     struct Token *in = start;
     struct Token *out = start;
     struct Token *end = expand_pool + pool_used;
 
     while (in < end) {
         if (in->kind == TOK_PASTE) {
             if (out == start || in + 1 >= end) {
                 pool_used = mark;
                 return fail("bad paste");
             }
             if ((out - 1)->kind == TOK_NEWLINE ||
                 (out - 1)->kind == TOK_PASTE ||
                 (in + 1)->kind == TOK_NEWLINE ||
                 (in + 1)->kind == TOK_PASTE) {
                 pool_used = mark;
                 return fail("bad paste");
             }
             if (!append_pasted_token(out - 1, out - 1, in + 1)) {
                 pool_used = mark;
                 return 0;
             }
             in += 2;
             continue;
         }
         if (out != in) {
             *out = *in;
         }
         out++;
         in++;
     }
 
     pool_used = (int)(out - expand_pool);
     return 1;
 }
 
 static int is_local_label_token(const struct Token *tok)
 {
     if (tok->kind != TOK_WORD || tok->text.len < 3) {
         return 0;
     }
     if (tok->text.ptr[0] != ':' && tok->text.ptr[0] != '&') {
         return 0;
     }
     if (tok->text.ptr[1] != '@') {
         return 0;
     }
     return 1;
 }
 
 static int push_local_label_token(const struct Token *tok, int expansion_id)
 {
     /* Rewrite ":@name" -> ":name__NN", "&@name" -> "&name__NN".
      * Build the text directly in text_buf so the resulting span is stable. */
     char digits[16];
     int digit_count = 0;
     int unsigned_id;
     int start;
     int total;
     int i;
     struct Token out;
 
     unsigned_id = expansion_id;
     if (unsigned_id == 0) {
         digits[digit_count++] = '0';
     } else {
         while (unsigned_id > 0) {
             digits[digit_count++] = (char)('0' + (unsigned_id % 10));
             unsigned_id /= 10;
         }
     }
 
     /* Reserve: sigil(1) + tail(len-2) + "__"(2) + digits + NUL. */
     total = 1 + (tok->text.len - 2) + 2 + digit_count;
     if (text_used + total + 1 > MAX_TEXT) {
         return fail("text overflow");
     }
     start = text_used;
     text_buf[text_used++] = tok->text.ptr[0];
     memcpy(text_buf + text_used, tok->text.ptr + 2, (size_t)(tok->text.len - 2));
     text_used += tok->text.len - 2;
     text_buf[text_used++] = '_';
     text_buf[text_used++] = '_';
     for (i = digit_count - 1; i >= 0; i--) {
         text_buf[text_used++] = digits[i];
     }
     text_buf[text_used++] = '\0';
 
     out.kind = TOK_WORD;
     out.text.ptr = text_buf + start;
     out.text.len = total;
     return push_pool_token(out);
 }
 
 static int expand_macro_tokens(struct Token *call_tok, struct Token *limit,
                                const struct Macro *m, struct Token **after_out,
                                int *mark_out)
 {
     struct Token *body_tok;
     struct Token *end_pos;
     int mark;
     int expansion_id;
 
     if (call_tok + 1 < limit && (call_tok + 1)->kind == TOK_LPAREN) {
         if (!parse_args(call_tok + 1, limit)) {
             return 0;
         }
         if (arg_count != m->param_count) {
             return fail("wrong arg count");
         }
         end_pos = call_end_pos;
     } else if (m->param_count == 0) {
         arg_count = 0;
         end_pos = call_tok + 1;
     } else {
         return fail("bad macro call");
     }
 
     expansion_id = ++next_expansion_id;
     mark = pool_used;
     for (body_tok = m->body_start; body_tok < m->body_end; body_tok++) {
         int param_idx = find_param(m, body_tok);
         int pasted = 0;
         int ok;
 
         if (param_idx != 0) {
             struct TokenSpan arg = {arg_starts[param_idx - 1], arg_ends[param_idx - 1]};
             pasted = (body_tok > m->body_start && (body_tok - 1)->kind == TOK_PASTE) ||
                      (body_tok + 1 < m->body_end && (body_tok + 1)->kind == TOK_PASTE);
             ok = pasted ? copy_paste_arg_to_pool(arg) : copy_arg_tokens_to_pool(arg);
             if (!ok) {
                 pool_used = mark;
                 return 0;
             }
             continue;
         }
         if (is_local_label_token(body_tok)) {
             if (!push_local_label_token(body_tok, expansion_id)) {
                 pool_used = mark;
                 return 0;
             }
             continue;
         }
         if (!push_pool_token(*body_tok)) {
             pool_used = mark;
             return 0;
         }
     }
 
     if (!paste_pool_range(mark)) {
         return 0;
     }
     *after_out = end_pos;
     *mark_out = mark;
     return 1;
 }
 
 static int parse_int_token(const struct Token *tok, long long *out)
 {
     char tmp[128];
     char *end;
     unsigned long long uv;
     long long sv;
 
     if (tok->kind != TOK_WORD || tok->text.len <= 0 || tok->text.len >= (int)sizeof(tmp)) {
         return fail("bad integer");
     }
     memcpy(tmp, tok->text.ptr, (size_t)tok->text.len);
     tmp[tok->text.len] = '\0';
 
     errno = 0;
     if (tmp[0] == '-') {
         sv = strtoll(tmp, &end, 0);
         if (errno != 0 || *end != '\0') {
             return fail("bad integer");
         }
         *out = sv;
         return 1;
     }
 
     uv = strtoull(tmp, &end, 0);
     if (errno != 0 || *end != '\0') {
         return fail("bad integer");
     }
     *out = (long long)uv;
     return 1;
 }
 
 static enum ExprOp expr_op_code(const struct Token *tok)
 {
     if (tok->kind != TOK_WORD) {
         return EXPR_INVALID;
     }
     if (token_text_eq(tok, "+")) {
         return EXPR_ADD;
     }
     if (token_text_eq(tok, "-")) {
         return EXPR_SUB;
     }
     if (token_text_eq(tok, "*")) {
         return EXPR_MUL;
     }
     if (token_text_eq(tok, "/")) {
         return EXPR_DIV;
     }
     if (token_text_eq(tok, "%")) {
         return EXPR_MOD;
     }
     if (token_text_eq(tok, "<<")) {
         return EXPR_SHL;
     }
     if (token_text_eq(tok, ">>")) {
         return EXPR_SHR;
     }
     if (token_text_eq(tok, "&")) {
         return EXPR_AND;
     }
     if (token_text_eq(tok, "|")) {
         return EXPR_OR;
     }
     if (token_text_eq(tok, "^")) {
         return EXPR_XOR;
     }
     if (token_text_eq(tok, "~")) {
         return EXPR_NOT;
     }
     if (token_text_eq(tok, "=")) {
         return EXPR_EQ;
     }
     if (token_text_eq(tok, "!=")) {
         return EXPR_NE;
     }
     if (token_text_eq(tok, "<")) {
         return EXPR_LT;
     }
     if (token_text_eq(tok, "<=")) {
         return EXPR_LE;
     }
     if (token_text_eq(tok, ">")) {
         return EXPR_GT;
     }
     if (token_text_eq(tok, ">=")) {
         return EXPR_GE;
     }
     if (token_text_eq(tok, "strlen")) {
         return EXPR_STRLEN;
     }
     return EXPR_INVALID;
 }
 
 static int apply_expr_op(enum ExprOp op, const long long *args, int argc, long long *out)
 {
     int i;
 
     switch (op) {
     case EXPR_ADD:
         if (argc < 1) {
             return fail("bad expression");
         }
         *out = args[0];
         for (i = 1; i < argc; i++) {
             *out += args[i];
         }
         return 1;
     case EXPR_SUB:
         if (argc < 1) {
             return fail("bad expression");
         }
         *out = (argc == 1) ? -args[0] : args[0];
         for (i = 1; i < argc; i++) {
             *out -= args[i];
         }
         return 1;
     case EXPR_MUL:
         if (argc < 1) {
             return fail("bad expression");
         }
         *out = args[0];
         for (i = 1; i < argc; i++) {
             *out *= args[i];
         }
         return 1;
     case EXPR_DIV:
         if (argc != 2 || args[1] == 0) {
             return fail("bad expression");
         }
         *out = args[0] / args[1];
         return 1;
     case EXPR_MOD:
         if (argc != 2 || args[1] == 0) {
             return fail("bad expression");
         }
         *out = args[0] % args[1];
         return 1;
     case EXPR_SHL:
         if (argc != 2) {
             return fail("bad expression");
         }
         *out = (long long)((unsigned long long)args[0] << args[1]);
         return 1;
     case EXPR_SHR:
         if (argc != 2) {
             return fail("bad expression");
         }
         *out = args[0] >> args[1];
         return 1;
     case EXPR_AND:
         if (argc < 1) {
             return fail("bad expression");
         }
         *out = args[0];
         for (i = 1; i < argc; i++) {
             *out &= args[i];
         }
         return 1;
     case EXPR_OR:
         if (argc < 1) {
             return fail("bad expression");
         }
         *out = args[0];
         for (i = 1; i < argc; i++) {
             *out |= args[i];
         }
         return 1;
     case EXPR_XOR:
         if (argc < 1) {
             return fail("bad expression");
         }
         *out = args[0];
         for (i = 1; i < argc; i++) {
             *out ^= args[i];
         }
         return 1;
     case EXPR_NOT:
         if (argc != 1) {
             return fail("bad expression");
         }
         *out = ~args[0];
         return 1;
     case EXPR_EQ:
         if (argc != 2) {
             return fail("bad expression");
         }
         *out = (args[0] == args[1]);
         return 1;
     case EXPR_NE:
         if (argc != 2) {
             return fail("bad expression");
         }
         *out = (args[0] != args[1]);
         return 1;
     case EXPR_LT:
         if (argc != 2) {
             return fail("bad expression");
         }
         *out = (args[0] < args[1]);
         return 1;
     case EXPR_LE:
         if (argc != 2) {
             return fail("bad expression");
         }
         *out = (args[0] <= args[1]);
         return 1;
     case EXPR_GT:
         if (argc != 2) {
             return fail("bad expression");
         }
         *out = (args[0] > args[1]);
         return 1;
     case EXPR_GE:
         if (argc != 2) {
             return fail("bad expression");
         }
         *out = (args[0] >= args[1]);
         return 1;
     case EXPR_STRLEN:
     case EXPR_INVALID:
         break;
     }
 
     return fail("bad expression");
 }
 
 static int eval_expr_range(struct TokenSpan span, long long *out);
 
 static int eval_expr_atom(struct Token *tok, struct Token *limit,
                           struct Token **after_out, long long *out)
 {
     const struct Macro *macro;
     struct Token *after;
     int mark;
 
     macro = find_macro(tok);
     if (macro != NULL &&
         ((tok + 1 < limit && (tok + 1)->kind == TOK_LPAREN) ||
          macro->param_count == 0)) {
         if (!expand_macro_tokens(tok, limit, macro, &after, &mark)) {
             return 0;
         }
         if (pool_used == mark) {
             pool_used = mark;
             return fail("bad expression");
         }
         if (!eval_expr_range((struct TokenSpan){expand_pool + mark, expand_pool + pool_used}, out)) {
             pool_used = mark;
             return 0;
         }
         pool_used = mark;
         *after_out = after;
         return 1;
     }
 
     if (!parse_int_token(tok, out)) {
         return 0;
     }
     *after_out = tok + 1;
     return 1;
 }
 
 static int eval_expr_range(struct TokenSpan span, long long *out)
 {
     struct ExprFrame frames[MAX_EXPR_FRAMES];
     int frame_top = 0;
     struct Token *pos = span.start;
     long long value = 0;
     long long result = 0;
     int have_value = 0;
     int have_result = 0;
 
     for (;;) {
         if (have_value) {
             if (frame_top > 0) {
                 struct ExprFrame *frame = &frames[frame_top - 1];
 
                 if (frame->argc >= MAX_PARAMS) {
                     return fail("bad expression");
                 }
                 frame->args[frame->argc++] = value;
                 have_value = 0;
                 continue;
             }
             if (have_result) {
                 return fail("bad expression");
             }
             result = value;
             have_result = 1;
             have_value = 0;
             continue;
         }
 
         skip_expr_newlines(&pos, span.end);
         if (pos >= span.end) {
             break;
         }
 
         if (pos->kind == TOK_LPAREN) {
             enum ExprOp op;
 
             pos++;
             skip_expr_newlines(&pos, span.end);
             if (pos >= span.end) {
                 return fail("bad expression");
             }
             op = expr_op_code(pos);
             if (op == EXPR_INVALID) {
                 return fail("bad expression");
             }
             pos++;
             if (op == EXPR_STRLEN) {
                 /* strlen is degenerate: argument is a TOK_STRING atom,
                  * not a recursive expression. Handle inline and yield
                  * the string's raw byte count (span.len - 2). */
                 skip_expr_newlines(&pos, span.end);
                 if (pos >= span.end || pos->kind != TOK_STRING) {
                     return fail("bad expression");
                 }
                 if (pos->text.len < 2 || pos->text.ptr[0] != '"') {
                     return fail("bad expression");
                 }
                 value = (long long)(pos->text.len - 2);
                 pos++;
                 skip_expr_newlines(&pos, span.end);
                 if (pos >= span.end || pos->kind != TOK_RPAREN) {
                     return fail("bad expression");
                 }
                 pos++;
                 have_value = 1;
                 continue;
             }
             if (frame_top >= MAX_EXPR_FRAMES) {
                 return fail("expression overflow");
             }
             frames[frame_top].op = op;
             frames[frame_top].argc = 0;
             frame_top++;
             continue;
         }
 
         if (pos->kind == TOK_RPAREN) {
             if (frame_top <= 0) {
                 return fail("bad expression");
             }
             if (!apply_expr_op(frames[frame_top - 1].op,
                                frames[frame_top - 1].args,
                                frames[frame_top - 1].argc,
                                &value)) {
                 return 0;
             }
             frame_top--;
             pos++;
             have_value = 1;
             continue;
         }
 
         if (!eval_expr_atom(pos, span.end, &pos, &value)) {
             return 0;
         }
         have_value = 1;
     }
 
     if (frame_top != 0 || !have_result) {
         return fail("bad expression");
     }
     if (pos != span.end) {
         return fail("bad expression");
     }
 
     *out = result;
     return 1;
 }
 
 static int emit_hex_value(unsigned long long value, int bytes)
 {
     /* Wrap the hex digits in single quotes so M0 sees a STRING-literal
      * hex token, not a numeric token (which it would parse as decimal). */
     char tmp[19];
     static const char hex[] = "0123456789ABCDEF";
     struct Token tok;
     int i;
     char *text_ptr;
     int total_len = 2 + 2 * bytes;
 
     tmp[0] = '\'';
     for (i = 0; i < bytes; i++) {
         unsigned int b = (unsigned int)((value >> (8 * i)) & 0xFF);
         tmp[1 + 2 * i] = hex[b >> 4];
         tmp[1 + 2 * i + 1] = hex[b & 0x0F];
     }
     tmp[1 + 2 * bytes] = '\'';
     tmp[total_len] = '\0';
 
     text_ptr = append_text_len(tmp, total_len);
     if (text_ptr == NULL) {
         return 0;
     }
     tok.kind = TOK_STRING;
     tok.text.ptr = text_ptr;
     tok.text.len = total_len;
     return emit_token(&tok);
 }
 
 static int expand_builtin_call(struct Stream *s, const struct Token *tok)
 {
     long long value;
 
     if (tok + 1 >= s->end || (tok + 1)->kind != TOK_LPAREN) {
         return fail("bad builtin");
     }
     if (!parse_args((struct Token *)tok + 1, s->end)) {
         return 0;
     }
 
     if (token_text_eq(tok, "!") || token_text_eq(tok, "@") ||
         token_text_eq(tok, "%") || token_text_eq(tok, "$")) {
         struct TokenSpan arg;
         struct Token *end_pos;
         int bytes;
 
         if (arg_count != 1) {
             return fail("bad builtin");
         }
         arg.start = arg_starts[0];
         arg.end = arg_ends[0];
         end_pos = call_end_pos;
         if (!eval_expr_range(arg, &value)) {
             return 0;
         }
         s->pos = end_pos;
         s->line_start = 0;
         bytes = token_text_eq(tok, "!") ? 1 :
                 token_text_eq(tok, "@") ? 2 :
                 token_text_eq(tok, "%") ? 4 : 8;
         return emit_hex_value((unsigned long long)value, bytes);
     }
 
     if (token_text_eq(tok, "%select")) {
         struct TokenSpan cond_arg, then_arg, else_arg, chosen;
         struct Token *end_pos;
         int mark;
 
         if (arg_count != 3) {
             return fail("bad builtin");
         }
         cond_arg.start = arg_starts[0]; cond_arg.end = arg_ends[0];
         then_arg.start = arg_starts[1]; then_arg.end = arg_ends[1];
         else_arg.start = arg_starts[2]; else_arg.end = arg_ends[2];
         end_pos = call_end_pos;
         if (!eval_expr_range(cond_arg, &value)) {
             return 0;
         }
         chosen = (value != 0) ? then_arg : else_arg;
         s->pos = end_pos;
         s->line_start = 0;
         if (chosen.start == chosen.end) {
             return 1;
         }
         mark = pool_used;
         if (!copy_span_to_pool(chosen)) {
             pool_used = mark;
             return 0;
         }
         return push_pool_stream_from_mark(mark);
     }
 
     if (token_text_eq(tok, "%str")) {
         struct Token *arg_tok;
         struct Token *end_pos;
         struct Token out_tok;
         char *text_ptr;
         int orig_len;
         int out_len;
 
         if (arg_count != 1) {
             return fail("bad builtin");
         }
         if (arg_ends[0] - arg_starts[0] != 1) {
             return fail("bad builtin");
         }
         arg_tok = arg_starts[0];
         if (arg_tok->kind != TOK_WORD) {
             return fail("bad builtin");
         }
         end_pos = call_end_pos;
 
         orig_len = arg_tok->text.len;
         out_len = orig_len + 2;
         if (text_used + out_len + 1 > MAX_TEXT) {
             return fail("text overflow");
         }
         text_ptr = text_buf + text_used;
         text_buf[text_used++] = '"';
         memcpy(text_buf + text_used, arg_tok->text.ptr, (size_t)orig_len);
         text_used += orig_len;
         text_buf[text_used++] = '"';
         text_buf[text_used++] = '\0';
 
         out_tok.kind = TOK_STRING;
         out_tok.text.ptr = text_ptr;
         out_tok.text.len = out_len;
         s->pos = end_pos;
         s->line_start = 0;
         return emit_token(&out_tok);
     }
 
     return fail("bad builtin");
 }
 
 static int expand_call(struct Stream *s, const struct Macro *macro)
 {
     struct Token *after;
     int mark;
 
     if (!expand_macro_tokens(s->pos, s->end, macro, &after, &mark)) {
         return 0;
     }
     s->pos = after;
     s->line_start = 0;
     return push_pool_stream_from_mark(mark);
 }
 
 static int push_scope(struct Stream *s)
 {
     s->pos++;
     if (s->pos >= s->end || s->pos->kind != TOK_WORD) {
         return fail("bad scope header");
     }
     if (scope_depth >= MAX_SCOPE_DEPTH) {
         return fail("scope depth overflow");
     }
     scope_stack[scope_depth++] = s->pos->text;
     s->pos++;
     if (s->pos < s->end && s->pos->kind != TOK_NEWLINE) {
         return fail("bad scope header");
     }
     if (s->pos < s->end) {
         s->pos++;
     }
     s->line_start = 1;
     return 1;
 }
 
 static int pop_scope(struct Stream *s)
 {
     s->pos++;
     if (scope_depth <= 0) {
         return fail("scope underflow");
     }
     scope_depth--;
     while (s->pos < s->end && s->pos->kind != TOK_NEWLINE) {
         s->pos++;
     }
     if (s->pos < s->end) {
         s->pos++;
     }
     s->line_start = 1;
     return 1;
 }
 
 static int process_tokens(void)
 {
     if (!push_stream_span((struct TokenSpan){source_tokens, source_tokens + source_count}, -1)) {
         return 0;
     }
 
     for (;;) {
         struct Stream *s;
         struct Token *tok;
         const struct Macro *macro;
 
         s = current_stream();
         if (s == NULL) {
             break;
         }
         if (s->pos >= s->end) {
             pop_stream();
             continue;
         }
 
         tok = s->pos;
 
         if (s->line_start &&
             tok->kind == TOK_WORD &&
             token_text_eq(tok, "%macro")) {
             if (!define_macro(s)) {
                 return 0;
             }
             continue;
         }
 
         if (s->line_start &&
             tok->kind == TOK_WORD &&
             token_text_eq(tok, "%struct")) {
             if (!define_fielded(s, 8, "SIZE", 4)) {
                 return 0;
             }
             continue;
         }
 
         if (s->line_start &&
             tok->kind == TOK_WORD &&
             token_text_eq(tok, "%enum")) {
             if (!define_fielded(s, 1, "COUNT", 5)) {
                 return 0;
             }
             continue;
         }
 
         if (s->line_start &&
             tok->kind == TOK_WORD &&
             token_text_eq(tok, "%scope")) {
             if (!push_scope(s)) {
                 return 0;
             }
             continue;
         }
 
         if (s->line_start &&
             tok->kind == TOK_WORD &&
             token_text_eq(tok, "%endscope")) {
             if (!pop_scope(s)) {
                 return 0;
             }
             continue;
         }
 
         if (tok->kind == TOK_NEWLINE) {
             s->pos++;
             s->line_start = 1;
             if (!emit_newline()) {
                 return 0;
             }
             continue;
         }
 
         if (tok->kind == TOK_WORD &&
             tok + 1 < s->end &&
             (tok + 1)->kind == TOK_LPAREN &&
             (token_text_eq(tok, "!") ||
              token_text_eq(tok, "@") ||
              token_text_eq(tok, "%") ||
              token_text_eq(tok, "$") ||
              token_text_eq(tok, "%select") ||
              token_text_eq(tok, "%str"))) {
             if (!expand_builtin_call(s, tok)) {
                 return 0;
             }
             continue;
         }
 
         macro = find_macro(tok);
         if (macro != NULL &&
             ((tok + 1 < s->end && (tok + 1)->kind == TOK_LPAREN) ||
              macro->param_count == 0)) {
             if (!expand_call(s, macro)) {
                 return 0;
             }
             continue;
         }
 
         s->pos++;
         s->line_start = 0;
         if (!emit_token(tok)) {
             return 0;
         }
     }
 
     if (scope_depth != 0) {
         return fail("scope not closed");
     }
 
     if (output_used >= MAX_OUTPUT) {
         return fail("output overflow");
     }
     output_buf[output_used] = '\0';
     return 1;
 }
 
 int main(int argc, char **argv)
 {
     FILE *in;
     FILE *out;
     size_t nread;
 
     if (argc != 3) {
         fprintf(stderr, "usage: %s input.M1 output.M1\n", argv[0]);
         return 1;
     }
 
     in = fopen(argv[1], "rb");
     if (in == NULL) {
         perror(argv[1]);
         return 1;
     }
     nread = fread(input_buf, 1, MAX_INPUT, in);
     if (ferror(in)) {
         perror(argv[1]);
         fclose(in);
         return 1;
     }
     fclose(in);
     if (nread >= MAX_INPUT) {
         fprintf(stderr, "input too large\n");
         return 1;
     }
     input_buf[nread] = '\0';
 
     if (!lex_source(input_buf) || !process_tokens()) {
         fprintf(stderr, "m1macro: %s\n", error_msg != NULL ? error_msg : "failed");
         return 1;
     }
 
     out = fopen(argv[2], "wb");
     if (out == NULL) {
         perror(argv[2]);
         return 1;
     }
     if (fwrite(output_buf, 1, (size_t)output_used, out) != (size_t)output_used) {
         perror(argv[2]);
         fclose(out);
         return 1;
     }
     fclose(out);
     return 0;
 }