Skip to main content

offlineasm_backend/
parser.rs

1use crate::ast::{builtin_origin, LabelTable, Node};
2use crate::code_origin::{CodeOrigin, FileRegistry, SourceFile};
3use crate::instructions as mnemonics;
4use crate::registers as reg;
5use proc_macro2::Span;
6use std::path::{Path, PathBuf};
7use syn::parse::ParseStream;
8use syn::Token;
9
10mod kw {
11    syn::custom_keyword!(then);
12    syn::custom_keyword!(elsif);
13    syn::custom_keyword!(end);
14    syn::custom_keyword!(and);
15    syn::custom_keyword!(or);
16    syn::custom_keyword!(not);
17    syn::custom_keyword!(global);
18    syn::custom_keyword!(globalexport);
19    syn::custom_keyword!(unalignedglobal);
20    syn::custom_keyword!(unalignedglobalexport);
21    syn::custom_keyword!(aligned);
22    syn::custom_keyword!(near);
23    syn::custom_keyword!(sizeof);
24    syn::custom_keyword!(constexpr);
25    syn::custom_keyword!(include);
26    syn::custom_keyword!(error);
27}
28
29#[derive(Clone, Debug, Default)]
30pub struct ParserOptions {
31    pub include_dirs: Vec<String>,
32}
33
34#[derive(Debug, Default)]
35pub struct ParseSession {
36    pub files: FileRegistry,
37    pub labels: LabelTable,
38    pub sources: Vec<String>,
39    pub options: ParserOptions,
40}
41
42impl ParseSession {
43    pub fn new(options: ParserOptions) -> Self {
44        Self {
45            files: FileRegistry::new(),
46            labels: LabelTable::new(),
47            sources: Vec::new(),
48            options,
49        }
50    }
51
52    fn note_source(&mut self, file_name: &str) {
53        if !self.sources.contains(&file_name.to_string()) {
54            self.sources.push(file_name.to_string());
55        }
56    }
57}
58
59pub fn read_text_file(path: &Path) -> Result<String, syn::Error> {
60    let data = std::fs::read(path)
61        .map_err(|e| err_here(format!("cannot read {}: {}", path.display(), e)))?;
62    if !data.is_ascii() {
63        return Err(err_here(format!(
64            "{} contains non-ASCII characters",
65            path.display()
66        )));
67    }
68    let mut text = String::from_utf8(data).map_err(|e| err_here(format!("bad utf8: {}", e)))?;
69    text.retain(|c| c != '\r');
70    Ok(text)
71}
72
73fn err_here(msg: impl Into<String>) -> syn::Error {
74    syn::Error::new(Span::call_site(), msg.into())
75}
76
77fn resolve_include_file(
78    module: &str,
79    options: &ParserOptions,
80    current_file_dir: Option<&Path>,
81) -> Option<PathBuf> {
82    for dir in &options.include_dirs {
83        let candidate = Path::new(dir).join(format!("{}.asm", module));
84        if candidate.is_file() {
85            return Some(candidate);
86        }
87    }
88    if let Some(dir) = current_file_dir {
89        let candidate = dir.join(format!("{}.asm", module));
90        if candidate.is_file() {
91            return Some(candidate);
92        }
93    }
94    let fallback = Path::new(module).with_extension("asm");
95    if fallback.is_file() {
96        return Some(fallback);
97    }
98    None
99}
100
101pub fn parse_data(data: &str, file_name: &str, session: &mut ParseSession) -> syn::Result<Node> {
102    let token_stream: proc_macro2::TokenStream = data
103        .parse()
104        .map_err(|e| err_here(format!("tokenizer error in {}: {}", file_name, e)))?;
105    parse_tokens(token_stream, file_name, session)
106}
107
108pub fn parse_tokens(
109    tokens: proc_macro2::TokenStream,
110    file_name: &str,
111    session: &mut ParseSession,
112) -> syn::Result<Node> {
113    session.note_source(file_name);
114    let file: SourceFile = session.files.intern(file_name);
115    let parser = move |input: ParseStream| -> syn::Result<Node> {
116        let mut ctx = Ctx {
117            session,
118            current_file: file,
119        };
120        let result = ctx.parse_sequence(input, &[], "")?;
121        if !input.is_empty() {
122            return Err(input.error("unexpected trailing tokens"));
123        }
124        Ok(result)
125    };
126    syn::parse::Parser::parse2(parser, tokens)
127}
128
129pub fn parse_file(path: &Path, session: &mut ParseSession) -> syn::Result<Node> {
130    let name = path.to_string_lossy().to_string();
131    let data = read_text_file(path)?;
132    parse_data(&data, &name, session)
133}
134
135pub fn parse_includes(path: &Path, session: &mut ParseSession) -> syn::Result<Vec<String>> {
136    let name = path.to_string_lossy().to_string();
137    let data = read_text_file(path)?;
138    let mut file_list = vec![name.clone()];
139    collect_includes(&data, path, &session.options.clone(), &mut file_list)?;
140    Ok(file_list)
141}
142
143fn collect_includes(
144    data: &str,
145    file_path: &Path,
146    options: &ParserOptions,
147    out: &mut Vec<String>,
148) -> syn::Result<()> {
149    let tokens: proc_macro2::TokenStream = data
150        .parse()
151        .map_err(|e| err_here(format!("tokenizer error: {}", e)))?;
152    let current_dir = file_path.parent().map(|p| p.to_path_buf());
153    scan_includes_in_stream(tokens, options, current_dir.as_deref(), out)
154}
155
156fn scan_includes_in_stream(
157    tokens: proc_macro2::TokenStream,
158    options: &ParserOptions,
159    current_dir: Option<&Path>,
160    out: &mut Vec<String>,
161) -> syn::Result<()> {
162    let mut iter = tokens.into_iter().peekable();
163    while let Some(tt) = iter.next() {
164        match tt {
165            proc_macro2::TokenTree::Ident(id) if id == "include" => {
166                if let Some(proc_macro2::TokenTree::Punct(p)) = iter.peek() {
167                    if p.as_char() == '?' {
168                        iter.next();
169                    }
170                }
171                let Some(proc_macro2::TokenTree::Ident(module)) = iter.next() else {
172                    continue;
173                };
174                let module = module.to_string();
175                if let Some(resolved) = resolve_include_file(&module, options, current_dir) {
176                    let rname = resolved.to_string_lossy().to_string();
177                    if !out.contains(&rname) {
178                        out.push(rname.clone());
179                        let data = read_text_file(&resolved)?;
180                        let inner_tokens: proc_macro2::TokenStream =
181                            data.parse().map_err(|e: proc_macro2::LexError| {
182                                err_here(format!("tokenizer error: {}", e))
183                            })?;
184                        scan_includes_in_stream(inner_tokens, options, resolved.parent(), out)?;
185                    }
186                }
187            }
188            proc_macro2::TokenTree::Group(g) => {
189                scan_includes_in_stream(g.stream(), options, current_dir, out)?;
190            }
191            _ => {}
192        }
193    }
194    Ok(())
195}
196
197struct Ctx<'a> {
198    session: &'a mut ParseSession,
199    current_file: SourceFile,
200}
201
202#[derive(Clone, Copy, PartialEq, Eq)]
203enum Term {
204    End,
205    Else,
206    Elsif,
207}
208
209fn peek_terminator(input: ParseStream) -> Option<Term> {
210    if input.peek(kw::end) {
211        Some(Term::End)
212    } else if input.peek(Token![else]) {
213        Some(Term::Else)
214    } else if input.peek(kw::elsif) {
215        Some(Term::Elsif)
216    } else {
217        None
218    }
219}
220
221#[allow(clippy::unwrap_used)]
222fn try_parse_word(input: ParseStream) -> Option<(String, Span)> {
223    if input.is_empty() {
224        return None;
225    }
226    input
227        .step(|cursor| {
228            let mut cur = *cursor;
229            let mut text = String::new();
230            let mut first_span: Option<Span> = None;
231
232            if let Some((punct, rest)) = cur.punct() {
233                if punct.as_char() == '%' {
234                    text.push('%');
235                    first_span = Some(punct.span());
236                    cur = rest;
237                }
238            }
239
240            // Exactly one leading core: a bare identifier, or `$ident`.
241            let mut got_piece = false;
242            if let Some((ident, rest)) = cur.ident() {
243                text.push_str(&ident.to_string());
244                first_span.get_or_insert(ident.span());
245                cur = rest;
246                got_piece = true;
247            } else if let Some((punct, rest)) = cur.punct() {
248                if punct.as_char() == '$' {
249                    if let Some((ident, rest2)) = rest.ident() {
250                        text.push('$');
251                        text.push_str(&ident.to_string());
252                        first_span.get_or_insert(punct.span());
253                        cur = rest2;
254                        got_piece = true;
255                    }
256                }
257            }
258            if !got_piece {
259                return Err(cursor.error("expected identifier"));
260            }
261
262            while let Some((punct, rest)) = cur.punct() {
263                if punct.as_char() != '$' {
264                    break;
265                }
266                let Some((ident, rest2)) = rest.ident() else {
267                    break;
268                };
269                text.push('$');
270                text.push_str(&ident.to_string());
271                cur = rest2;
272            }
273            Ok(((text, first_span.unwrap()), cur))
274        })
275        .ok()
276}
277
278fn peek_word(input: ParseStream) -> Option<String> {
279    let fork = input.fork();
280    try_parse_word(&fork).map(|(s, _)| s)
281}
282
283fn try_parse_local_label(input: ParseStream) -> Option<(String, Span)> {
284    if input.is_empty() {
285        return None;
286    }
287    input
288        .step(|cursor| {
289            let Some((dot, rest)) = cursor.punct() else {
290                return Err(cursor.error("expected `.`"));
291            };
292            if dot.as_char() != '.' {
293                return Err(cursor.error("expected `.`"));
294            }
295            let Some((ident, rest2)) = rest.ident() else {
296                return Err(cursor.error("expected label name"));
297            };
298            Ok(((format!(".{}", ident), dot.span()), rest2))
299        })
300        .ok()
301}
302
303fn peek_local_label(input: ParseStream) -> bool {
304    let fork = input.fork();
305    try_parse_local_label(&fork).is_some()
306}
307
308/// Reports whether `word` is a global label spelling (`_foo`).
309fn is_global_label_word(word: &str) -> bool {
310    word.starts_with('_')
311}
312
313/// Reports whether `word` is a physical-register escape (`%xmm8`).
314fn is_special_register_word(word: &str) -> bool {
315    word.starts_with('%')
316}
317
318/// Reports whether the upcoming token(s) start a value that could stand in
319/// operand position: a unary op, a parenthesized group, a literal, a
320/// register/identifier/label, `sizeof`, or a `const { ... }` block.
321fn starts_operand(input: ParseStream) -> bool {
322    if input.is_empty() {
323        return false;
324    }
325    if input.peek(Token![-])
326        || input.peek(Token![~])
327        || input.peek(syn::token::Paren)
328        || input.peek(syn::token::Brace)
329        || input.peek(kw::sizeof)
330        || input.peek(syn::Lit)
331    {
332        return true;
333    }
334    if peek_local_label(input) {
335        return true;
336    }
337    peek_word(input).is_some()
338}
339
340/// Reports whether `input` starts a label definition (`name:` or `.name:`).
341fn starts_label_def(input: ParseStream) -> bool {
342    let fork = input.fork();
343    let named = if peek_local_label(&fork) {
344        try_parse_local_label(&fork).is_some()
345    } else {
346        try_parse_word(&fork).is_some()
347    };
348    named && fork.peek(Token![:]) && !fork.peek(Token![::])
349}
350
351fn starts_new_statement(input: ParseStream) -> bool {
352    if input.is_empty() {
353        return true;
354    }
355    if peek_terminator(input).is_some() {
356        return true;
357    }
358    if input.peek(Token![const])
359        || input.peek(Token![macro])
360        || input.peek(Token![if])
361        || input.peek(kw::global)
362        || input.peek(kw::globalexport)
363        || input.peek(kw::unalignedglobal)
364        || input.peek(kw::unalignedglobalexport)
365        || input.peek(kw::aligned)
366        || input.peek(Token![extern])
367        || input.peek(kw::include)
368        || input.peek(kw::error)
369    {
370        return true;
371    }
372    // Without this, an operand-less mnemonic swallows the next label:
373    // `ret` followed by `_next:` would read as `ret _next`.
374    if starts_label_def(input) {
375        return true;
376    }
377    if let Some(word) = peek_word(input) {
378        if mnemonics::lookup(&word) {
379            return true;
380        }
381
382        let fork = input.fork();
383        if try_parse_word(&fork).is_some() && fork.peek(syn::token::Paren) {
384            return true;
385        }
386    }
387    false
388}
389
390impl Ctx<'_> {
391    fn origin_at(&self, span: Span) -> CodeOrigin {
392        CodeOrigin::new(&self.current_file, span.start().line)
393    }
394
395    fn parse_predicate_atom(&mut self, input: ParseStream) -> syn::Result<Node> {
396        if input.peek(kw::not) {
397            let k: kw::not = input.parse()?;
398            return Ok(Node::NotPred {
399                origin: self.origin_at(k.span),
400                child: Box::new(self.parse_predicate_atom(input)?),
401            });
402        }
403        if input.peek(syn::token::Paren) {
404            let inner;
405            syn::parenthesized!(inner in input);
406            return self.parse_predicate(&inner);
407        }
408        if input.peek(syn::LitBool) {
409            let lit: syn::LitBool = input.parse()?;
410            return Ok(if lit.value { Node::True } else { Node::False });
411        }
412        if let Some((word, span)) = try_parse_word(input) {
413            return Ok(Node::Setting {
414                origin: self.origin_at(span),
415                name: word,
416            });
417        }
418        Err(input.error("expected a predicate"))
419    }
420
421    fn parse_predicate_and(&mut self, input: ParseStream) -> syn::Result<Node> {
422        let mut result = self.parse_predicate_atom(input)?;
423        while input.peek(kw::and) {
424            let k: kw::and = input.parse()?;
425            let right = self.parse_predicate_atom(input)?;
426            result = Node::AndPred {
427                origin: self.origin_at(k.span),
428                left: Box::new(result),
429                right: Box::new(right),
430            };
431        }
432        Ok(result)
433    }
434
435    fn parse_predicate(&mut self, input: ParseStream) -> syn::Result<Node> {
436        let mut result = self.parse_predicate_and(input)?;
437        while input.peek(kw::or) {
438            let k: kw::or = input.parse()?;
439            let right = self.parse_predicate_and(input)?;
440            result = Node::OrPred {
441                origin: self.origin_at(k.span),
442                left: Box::new(result),
443                right: Box::new(right),
444            };
445        }
446        Ok(result)
447    }
448
449    fn parse_variable(&mut self, input: ParseStream) -> syn::Result<Node> {
450        let (word, span) =
451            try_parse_word(input).ok_or_else(|| input.error("expected a variable"))?;
452        let origin = self.origin_at(span);
453        if reg::is_register_name(&word) {
454            if reg::is_vec(&word) {
455                return Ok(Node::VecRegister { origin, name: word });
456            } else if reg::is_fpr(&word) {
457                return Ok(Node::FpRegister { origin, name: word });
458            }
459            return Ok(Node::Register { origin, name: word });
460        }
461        // A `%`-prefixed word names a physical register directly
462        // (`%xmm8`, `%x13`, ...), bypassing the portable vreg vocabulary.
463        if is_special_register_word(&word) {
464            return Ok(Node::SpecialRegister { name: word });
465        }
466        Ok(Node::Variable {
467            origin,
468            name: word.clone(),
469            original_name: word,
470        })
471    }
472
473    fn at_const_block(&self, input: ParseStream) -> bool {
474        if !input.peek(Token![const]) {
475            return false;
476        }
477        let fork = input.fork();
478        let _ = fork.parse::<Token![const]>();
479        fork.peek(syn::token::Brace)
480    }
481
482    fn parse_const_block(&mut self, input: ParseStream) -> syn::Result<Node> {
483        let k: Token![const] = input.parse()?;
484        let origin = self.origin_at(k.span);
485        let content;
486        syn::braced!(content in input);
487        let value: proc_macro2::TokenStream = content.parse()?;
488        Ok(Node::ConstExpr { origin, value })
489    }
490
491    /// Parses the `constexpr(...)`/`constexpr a::b::c` forms used only in
492    /// an address's scale position (see `parse_address`).
493    fn parse_constexpr_atom(&mut self, input: ParseStream) -> syn::Result<Node> {
494        let k: kw::constexpr = input.parse()?;
495        let origin = self.origin_at(k.span);
496        if input.peek(syn::token::Paren) {
497            let inner;
498            syn::parenthesized!(inner in input);
499            let value: proc_macro2::TokenStream = inner.parse()?;
500            return Ok(Node::ConstExpr { origin, value });
501        }
502        let names = self.parse_colon_colon(input)?;
503        let value: proc_macro2::TokenStream = names.join("::").parse().unwrap_or_default();
504        Ok(Node::ConstExpr { origin, value })
505    }
506
507    fn parse_colon_colon(&mut self, input: ParseStream) -> syn::Result<Vec<String>> {
508        let (first, _) = try_parse_word(input).ok_or_else(|| input.error("expected a name"))?;
509        let mut names = vec![first];
510        while input.peek(Token![::]) {
511            input.parse::<Token![::]>()?;
512            let (next, _) = try_parse_word(input).ok_or_else(|| input.error("expected a name"))?;
513            names.push(next);
514        }
515        Ok(names)
516    }
517
518    fn parse_address(&mut self, input: ParseStream, offset: Node) -> syn::Result<Node> {
519        let content;
520        let bracket = syn::bracketed!(content in input);
521        let origin = self.origin_at(bracket.span.open());
522        if content.is_empty() {
523            return Ok(Node::AbsoluteAddress {
524                origin,
525                address: Box::new(offset),
526            });
527        }
528        let a = self.parse_variable(&content)?;
529        if content.is_empty() {
530            return Ok(Node::Address {
531                origin,
532                base: Box::new(a),
533                offset: Box::new(offset),
534            });
535        }
536        content.parse::<Token![,]>()?;
537        let b = self.parse_variable(&content)?;
538        if content.is_empty() {
539            let one = Node::Immediate {
540                origin: origin.clone(),
541                value: 1,
542            };
543            return Ok(Node::BaseIndex {
544                origin,
545                base: Box::new(a),
546                index: Box::new(b),
547                scale: Box::new(one),
548                offset: Box::new(offset),
549            });
550        }
551        content.parse::<Token![,]>()?;
552        let c = if let Some(lit) = content.parse::<Option<syn::LitInt>>()? {
553            let v: i128 = lit
554                .base10_parse()
555                .map_err(|_| syn::Error::new(lit.span(), "expected a scale of 1, 2, 4, or 8"))?;
556            if ![1, 2, 4, 8].contains(&v) {
557                return Err(syn::Error::new(
558                    lit.span(),
559                    "expected a scale of 1, 2, 4, or 8",
560                ));
561            }
562            Node::Immediate {
563                origin: origin.clone(),
564                value: v,
565            }
566        } else if content.peek(kw::constexpr) {
567            self.parse_constexpr_atom(&content)?
568        } else if self.at_const_block(&content) {
569            self.parse_const_block(&content)?
570        } else {
571            self.parse_variable(&content)?
572        };
573        Ok(Node::BaseIndex {
574            origin,
575            base: Box::new(a),
576            index: Box::new(b),
577            scale: Box::new(c),
578            offset: Box::new(offset),
579        })
580    }
581
582    #[allow(clippy::expect_used)]
583    fn parse_expression_atom(&mut self, input: ParseStream) -> syn::Result<Node> {
584        if input.peek(Token![-]) {
585            let t: Token![-] = input.parse()?;
586            return Ok(Node::Neg {
587                origin: self.origin_at(t.span),
588                child: Box::new(self.parse_expression_atom(input)?),
589            });
590        }
591        if input.peek(Token![~]) {
592            let t: Token![~] = input.parse()?;
593            return Ok(Node::Bitnot {
594                origin: self.origin_at(t.span),
595                child: Box::new(self.parse_expression_atom(input)?),
596            });
597        }
598        if input.peek(syn::token::Paren) {
599            let inner;
600            syn::parenthesized!(inner in input);
601            let result = self.parse_expression(&inner)?;
602            if !inner.is_empty() {
603                return Err(inner.error("unexpected token inside `(...)`"));
604            }
605            return Ok(result);
606        }
607        if let Some(lit) = input.parse::<Option<syn::LitInt>>()? {
608            let origin = self.origin_at(lit.span());
609            let value = parse_int_literal(&lit)?;
610            return Ok(Node::Immediate { origin, value });
611        }
612        if let Some(lit) = input.parse::<Option<syn::LitStr>>()? {
613            return Ok(Node::StringLiteral {
614                origin: self.origin_at(lit.span()),
615                value: lit.value(),
616            });
617        }
618        if self.at_const_block(input) {
619            return self.parse_const_block(input);
620        }
621        if peek_local_label(input) {
622            let (name, span) = try_parse_local_label(input)
623                .ok_or_else(|| syn::Error::new(input.span(), "mus be parsed"))?;
624            let origin = self.origin_at(span);
625            self.session
626                .labels
627                .local_label_for_name(&origin, &name)
628                .map_err(|e| syn::Error::new(span, e))?;
629            return Ok(Node::LocalLabelReference {
630                origin,
631                label: name,
632            });
633        }
634        if input.peek(kw::sizeof) {
635            let k: kw::sizeof = input.parse()?;
636            let names = self.parse_colon_colon(input)?;
637            return Ok(Node::Sizeof {
638                origin: self.origin_at(k.span),
639                struct_name: names.join("::"),
640            });
641        }
642        if let Some((word, span)) = peek_word(input).map(|w| (w, input.span())) {
643            if is_special_register_word(&word) {
644                let _ = try_parse_word(input);
645                return Ok(Node::SpecialRegister { name: word });
646            }
647            if reg::is_register_name(&word) {
648                return self.parse_variable(input);
649            }
650            if is_global_label_word(&word) {
651                let _ = try_parse_word(input);
652                let origin = self.origin_at(span);
653                self.session
654                    .labels
655                    .label_for_name(&word, false)
656                    .map_err(|e| syn::Error::new(span, e))?;
657                return Ok(Node::LabelReference {
658                    origin,
659                    label: word,
660                    offset: 0,
661                });
662            }
663            let names = self.parse_colon_colon(input)?;
664            let origin = self.origin_at(span);
665            if names.len() > 1 {
666                let field = names.last().cloned().expect("at least one value");
667                let struct_name = names[..names.len() - 1].join("::");
668                return Ok(Node::StructOffset {
669                    origin,
670                    struct_name,
671                    field,
672                });
673            }
674            return Ok(Node::Variable {
675                origin,
676                name: names[0].clone(),
677                original_name: names[0].clone(),
678            });
679        }
680        Err(input.error("expected an operand"))
681    }
682
683    fn parse_expression_mul(&mut self, input: ParseStream) -> syn::Result<Node> {
684        let mut result = self.parse_expression_atom(input)?;
685        while input.peek(Token![*]) {
686            let t: Token![*] = input.parse()?;
687            let rhs = self.parse_expression_atom(input)?;
688            result = Node::Mul {
689                origin: self.origin_at(t.span),
690                left: Box::new(result),
691                right: Box::new(rhs),
692            };
693        }
694        Ok(result)
695    }
696
697    fn parse_expression_add(&mut self, input: ParseStream) -> syn::Result<Node> {
698        let mut result = self.parse_expression_mul(input)?;
699        loop {
700            if input.peek(Token![+]) {
701                let t: Token![+] = input.parse()?;
702                let rhs = self.parse_expression_mul(input)?;
703                result = Node::Add {
704                    origin: self.origin_at(t.span),
705                    left: Box::new(result),
706                    right: Box::new(rhs),
707                };
708            } else if input.peek(Token![-]) {
709                let t: Token![-] = input.parse()?;
710                let rhs = self.parse_expression_mul(input)?;
711                result = Node::Sub {
712                    origin: self.origin_at(t.span),
713                    left: Box::new(result),
714                    right: Box::new(rhs),
715                };
716            } else {
717                break;
718            }
719        }
720        Ok(result)
721    }
722
723    fn parse_expression_and(&mut self, input: ParseStream) -> syn::Result<Node> {
724        let mut result = self.parse_expression_add(input)?;
725        while input.peek(Token![&]) {
726            let t: Token![&] = input.parse()?;
727            let rhs = self.parse_expression_add(input)?;
728            result = Node::And {
729                origin: self.origin_at(t.span),
730                left: Box::new(result),
731                right: Box::new(rhs),
732            };
733        }
734        Ok(result)
735    }
736
737    fn parse_expression(&mut self, input: ParseStream) -> syn::Result<Node> {
738        let mut result = self.parse_expression_and(input)?;
739        loop {
740            if input.peek(Token![|]) {
741                let t: Token![|] = input.parse()?;
742                let rhs = self.parse_expression_and(input)?;
743                result = Node::Or {
744                    origin: self.origin_at(t.span),
745                    left: Box::new(result),
746                    right: Box::new(rhs),
747                };
748            } else if input.peek(Token![^]) {
749                let t: Token![^] = input.parse()?;
750                let rhs = self.parse_expression_and(input)?;
751                result = Node::Xor {
752                    origin: self.origin_at(t.span),
753                    left: Box::new(result),
754                    right: Box::new(rhs),
755                };
756            } else {
757                break;
758            }
759        }
760        Ok(result)
761    }
762
763    fn parse_operand(&mut self, input: ParseStream, comment: &str) -> syn::Result<Node> {
764        if starts_operand(input) {
765            let expr = self.parse_expression(input)?;
766            if input.peek(syn::token::Bracket) {
767                return self.parse_address(input, expr);
768            }
769            return Ok(expr);
770        }
771        if input.peek(syn::token::Bracket) {
772            let zero = Node::Immediate {
773                origin: self.origin_at(input.span()),
774                value: 0,
775            };
776            return self.parse_address(input, zero);
777        }
778        Err(input.error(format!("expected an operand {}", comment)))
779    }
780
781    fn parse_macro_variables(&mut self, input: ParseStream) -> syn::Result<Vec<Node>> {
782        let content;
783        syn::parenthesized!(content in input);
784        let mut variables = Vec::new();
785        while !content.is_empty() {
786            let (name, span) = try_parse_word(&content)
787                .ok_or_else(|| content.error("expected a macro parameter name"))?;
788            variables.push(Node::Variable {
789                origin: self.origin_at(span),
790                name: name.clone(),
791                original_name: name,
792            });
793            if content.is_empty() {
794                break;
795            }
796            content.parse::<Token![,]>()?;
797        }
798        Ok(variables)
799    }
800
801    fn parse_sequence(
802        &mut self,
803        input: ParseStream,
804        terminators: &[Term],
805        comment: &str,
806    ) -> syn::Result<Node> {
807        let first_origin = self.origin_at(input.span());
808        let mut list: Vec<Node> = Vec::new();
809        loop {
810            if input.is_empty() {
811                if terminators.is_empty() {
812                    break;
813                }
814                return Err(input.error(format!("expected end of block {}", comment)));
815            }
816            if let Some(t) = peek_terminator(input) {
817                if terminators.contains(&t) {
818                    break;
819                }
820            }
821
822            if input.peek(Token![const]) {
823                let k: Token![const] = input.parse()?;
824                let (name, span) = try_parse_word(input)
825                    .ok_or_else(|| input.error("expected a name after `const`"))?;
826                let variable = Node::Variable {
827                    origin: self.origin_at(span),
828                    name: name.clone(),
829                    original_name: name.clone(),
830                };
831                input.parse::<Token![=]>()?;
832                let value =
833                    self.parse_operand(input, &format!("while inside of const {}", name))?;
834                list.push(Node::ConstDecl {
835                    origin: self.origin_at(k.span),
836                    variable: Box::new(variable),
837                    value: Box::new(value),
838                });
839                continue;
840            }
841
842            if input.peek(kw::error) {
843                let k: kw::error = input.parse()?;
844                list.push(Node::Error {
845                    origin: self.origin_at(k.span),
846                });
847                continue;
848            }
849
850            if input.peek(Token![if]) {
851                self.parse_if(input, &mut list)?;
852                continue;
853            }
854
855            if input.peek(Token![macro]) {
856                let k: Token![macro] = input.parse()?;
857                let (name, _) =
858                    try_parse_word(input).ok_or_else(|| input.error("expected a macro name"))?;
859                let variables = self.parse_macro_variables(input)?;
860                let body = self.parse_sequence(
861                    input,
862                    &[Term::End],
863                    &format!("while inside of macro {}", name),
864                )?;
865                input.parse::<kw::end>()?;
866                list.push(Node::Macro {
867                    origin: self.origin_at(k.span),
868                    name: Some(name),
869                    variables,
870                    body: Box::new(body),
871                });
872                continue;
873            }
874
875            if input.peek(kw::global) {
876                input.parse::<kw::global>()?;
877                let (name, span) =
878                    try_parse_word(input).ok_or_else(|| input.error("expected a label name"))?;
879                if !is_global_label_word(&name) {
880                    return Err(syn::Error::new(span, "expected a global label (`_name`)"));
881                }
882                self.session
883                    .labels
884                    .set_as_global(&name)
885                    .map_err(|e| syn::Error::new(span, e))?;
886                continue;
887            }
888            if input.peek(kw::globalexport) {
889                input.parse::<kw::globalexport>()?;
890                let (name, span) =
891                    try_parse_word(input).ok_or_else(|| input.error("expected a label name"))?;
892                self.session
893                    .labels
894                    .set_as_global_export(&name)
895                    .map_err(|e| syn::Error::new(span, e))?;
896                continue;
897            }
898            if input.peek(kw::unalignedglobal) {
899                input.parse::<kw::unalignedglobal>()?;
900                let (name, span) =
901                    try_parse_word(input).ok_or_else(|| input.error("expected a label name"))?;
902                self.session
903                    .labels
904                    .set_as_unaligned_global(&name)
905                    .map_err(|e| syn::Error::new(span, e))?;
906                continue;
907            }
908            if input.peek(kw::unalignedglobalexport) {
909                input.parse::<kw::unalignedglobalexport>()?;
910                let (name, span) =
911                    try_parse_word(input).ok_or_else(|| input.error("expected a label name"))?;
912                self.session
913                    .labels
914                    .set_as_unaligned_global_export(&name)
915                    .map_err(|e| syn::Error::new(span, e))?;
916                continue;
917            }
918            if input.peek(Token![extern]) {
919                input.parse::<Token![extern]>()?;
920                let reach = if input.peek(kw::near) {
921                    input.parse::<kw::near>()?;
922                    offlineasm_ir::Reach::Near
923                } else {
924                    offlineasm_ir::Reach::Far
925                };
926                let (name, span) =
927                    try_parse_word(input).ok_or_else(|| input.error("expected a label name"))?;
928                if !is_global_label_word(&name) {
929                    return Err(syn::Error::new(span, "expected an extern label (`_name`)"));
930                }
931                self.session
932                    .labels
933                    .set_as_extern(&name, reach)
934                    .map_err(|e| syn::Error::new(span, e))?;
935                continue;
936            }
937            if input.peek(kw::aligned) {
938                let k: kw::aligned = input.parse()?;
939                let (name, span) =
940                    try_parse_word(input).ok_or_else(|| input.error("expected a label name"))?;
941                let origin = self.origin_at(k.span);
942                let align = if let Some(lit) = input.parse::<Option<syn::LitInt>>()? {
943                    Node::Immediate {
944                        origin: origin.clone(),
945                        value: lit.base10_parse().unwrap_or(0),
946                    }
947                } else {
948                    let (align_name, _) = try_parse_word(input)
949                        .ok_or_else(|| input.error("expected an alignment"))?;
950                    Node::Variable {
951                        origin: origin.clone(),
952                        name: align_name.clone(),
953                        original_name: align_name,
954                    }
955                };
956                self.session
957                    .labels
958                    .set_as_aligned(&name, Some(align))
959                    .map_err(|e| syn::Error::new(span, e))?;
960                continue;
961            }
962
963            if let Some(word) = peek_word(input) {
964                if mnemonics::lookup(&word) {
965                    self.parse_instruction(input, &mut list)?;
966                    continue;
967                }
968            }
969
970            if peek_local_label(input) || peek_word(input).is_some_and(|w| is_global_label_word(&w))
971            {
972                let fork = input.fork();
973                let is_local = peek_local_label(&fork);
974                let is_label_def = {
975                    let f2 = fork.fork();
976                    if is_local {
977                        try_parse_local_label(&f2).is_some() && f2.peek(Token![:])
978                    } else {
979                        try_parse_word(&f2).is_some() && f2.peek(Token![:])
980                    }
981                };
982                if is_label_def {
983                    if is_local {
984                        let (name, span) = try_parse_local_label(input)
985                            .ok_or_else(|| syn::Error::new(input.span(), "must be parsed"))?;
986                        input.parse::<Token![:]>()?;
987                        let origin = self.origin_at(span);
988                        self.session
989                            .labels
990                            .local_label_for_name(&origin, &name)
991                            .map_err(|e| syn::Error::new(span, e))?;
992                        list.push(Node::LocalLabel { origin, name });
993                    } else {
994                        let (name, span) = try_parse_word(input)
995                            .ok_or_else(|| syn::Error::new(input.span(), "must be parsed"))?;
996                        input.parse::<Token![:]>()?;
997                        let origin = self.origin_at(span);
998                        self.session
999                            .labels
1000                            .label_for_name(&name, true)
1001                            .map_err(|e| syn::Error::new(span, e))?;
1002                        list.push(Node::Label { origin, name });
1003                    }
1004                    continue;
1005                }
1006            }
1007
1008            if input.peek(kw::include) {
1009                input.parse::<kw::include>()?;
1010                if input.peek(Token![?]) {
1011                    input.parse::<Token![?]>()?;
1012                    let (module, _) = try_parse_word(input)
1013                        .ok_or_else(|| input.error("expected a module name"))?;
1014                    self.do_include(input, &module, true, &mut list)?;
1015                } else {
1016                    let (module, _) = try_parse_word(input)
1017                        .ok_or_else(|| input.error("expected a module name"))?;
1018                    self.do_include(input, &module, false, &mut list)?;
1019                }
1020                continue;
1021            }
1022
1023            if let Some((word, _span)) = peek_word(input).map(|w| (w, input.span())) {
1024                let fork = input.fork();
1025                if try_parse_word(&fork).is_some() && fork.peek(syn::token::Paren) {
1026                    self.parse_macro_call(input, &mut list)?;
1027                    continue;
1028                }
1029                let _ = word;
1030            }
1031
1032            return Err(input.error(format!("unexpected token {}", comment)));
1033        }
1034        Ok(Node::Sequence {
1035            origin: first_origin,
1036            list,
1037        })
1038    }
1039
1040    fn do_include(
1041        &mut self,
1042        _input: ParseStream,
1043        module: &str,
1044        optional: bool,
1045        list: &mut Vec<Node>,
1046    ) -> syn::Result<()> {
1047        let current_dir = Path::new(&self.current_file.name)
1048            .parent()
1049            .map(|p| p.to_path_buf());
1050        let resolved = resolve_include_file(module, &self.session.options, current_dir.as_deref());
1051        match resolved {
1052            Some(path) => {
1053                let rname = path.to_string_lossy().to_string();
1054                self.session.note_source(&rname);
1055                let data = read_text_file(&path)?;
1056                let inner = parse_data(&data, &rname, self.session)?;
1057                list.push(inner);
1058            }
1059            None if optional => {}
1060            None => return Err(err_here(format!("File not found: {}.asm", module))),
1061        }
1062        Ok(())
1063    }
1064
1065    fn parse_if(&mut self, input: ParseStream, list: &mut Vec<Node>) -> syn::Result<()> {
1066        let k: Token![if] = input.parse()?;
1067        let origin = self.origin_at(k.span);
1068        let predicate = self.parse_predicate(input)?;
1069        if input.peek(kw::then) {
1070            input.parse::<kw::then>()?;
1071        }
1072        let then_case = self.parse_sequence(
1073            input,
1074            &[Term::Else, Term::End, Term::Elsif],
1075            &format!("while inside of \"if {}\"", predicate.dump()),
1076        )?;
1077        let mut top = Node::IfThenElse {
1078            origin,
1079            predicate: Box::new(predicate),
1080            then_case: Box::new(then_case),
1081            else_case: Box::new(Node::Skip {
1082                origin: builtin_origin(),
1083            }),
1084        };
1085        while input.peek(kw::elsif) {
1086            let ek: kw::elsif = input.parse()?;
1087            let pred = self.parse_predicate(input)?;
1088            if input.peek(kw::then) {
1089                input.parse::<kw::then>()?;
1090            }
1091            let body = self.parse_sequence(
1092                input,
1093                &[Term::Else, Term::End, Term::Elsif],
1094                &format!("while inside of \"if {}\"", pred.dump()),
1095            )?;
1096            let nested = Node::IfThenElse {
1097                origin: self.origin_at(ek.span),
1098                predicate: Box::new(pred),
1099                then_case: Box::new(body),
1100                else_case: Box::new(Node::Skip {
1101                    origin: builtin_origin(),
1102                }),
1103            };
1104            set_else_case(&mut top, nested);
1105        }
1106        if input.peek(Token![else]) {
1107            input.parse::<Token![else]>()?;
1108            let else_case =
1109                self.parse_sequence(input, &[Term::End], "while inside of else case")?;
1110            set_else_case(&mut top, else_case);
1111            input.parse::<kw::end>()?;
1112        } else {
1113            input.parse::<kw::end>()?;
1114        }
1115        list.push(top);
1116        Ok(())
1117    }
1118
1119    fn parse_instruction(&mut self, input: ParseStream, list: &mut Vec<Node>) -> syn::Result<()> {
1120        let (name, span) = try_parse_word(input)
1121            .ok_or_else(|| syn::Error::new(input.span(), "already peeked mnemonic"))?;
1122        let origin = self.origin_at(span);
1123        // `[base, ...]` with no offset is an operand too (`jmp [t0, t1, 8]`).
1124        let has_operand = starts_operand(input) || input.peek(syn::token::Bracket);
1125        if !has_operand || starts_new_statement(input) {
1126            list.push(Node::Instruction {
1127                origin,
1128                opcode: name,
1129                operands: vec![],
1130                annotation: None,
1131            });
1132            return Ok(());
1133        }
1134        let mut operands = Vec::new();
1135        loop {
1136            let operand =
1137                self.parse_operand(input, &format!("while inside of instruction {}", name))?;
1138            operands.push(operand);
1139            if input.peek(Token![,]) {
1140                input.parse::<Token![,]>()?;
1141                continue;
1142            }
1143            break;
1144        }
1145        list.push(Node::Instruction {
1146            origin,
1147            opcode: name,
1148            operands,
1149            annotation: None,
1150        });
1151        Ok(())
1152    }
1153
1154    #[allow(clippy::expect_used)]
1155    fn parse_macro_call(&mut self, input: ParseStream, list: &mut Vec<Node>) -> syn::Result<()> {
1156        let (name, span) = try_parse_word(input)
1157            .ok_or_else(|| syn::Error::new(input.span(), "already peeked `(`"))?;
1158        let origin = self.origin_at(span);
1159        let content;
1160        syn::parenthesized!(content in input);
1161        let mut operands = Vec::new();
1162        while !content.is_empty() {
1163            if content.peek(Token![macro]) {
1164                let ik: Token![macro] = content.parse()?;
1165                let variables = self.parse_macro_variables(&content)?;
1166                let body = self.parse_sequence(
1167                    &content,
1168                    &[Term::End],
1169                    &format!(
1170                        "while inside of anonymous macro passed as argument to {}",
1171                        name
1172                    ),
1173                )?;
1174                content.parse::<kw::end>()?;
1175                operands.push(Node::Macro {
1176                    origin: self.origin_at(ik.span),
1177                    name: None,
1178                    variables,
1179                    body: Box::new(body),
1180                });
1181            } else {
1182                operands.push(
1183                    self.parse_operand(
1184                        &content,
1185                        &format!("while inside of macro call to {}", name),
1186                    )?,
1187                );
1188            }
1189            if content.is_empty() {
1190                break;
1191            }
1192            content.parse::<Token![,]>()?;
1193        }
1194        list.push(Node::MacroCall {
1195            origin,
1196            name: name.clone(),
1197            operands,
1198            annotation: None,
1199            original_name: name,
1200        });
1201        Ok(())
1202    }
1203}
1204
1205/// Parses an integer literal's value from its own raw text, matching
1206/// offlineasm's legacy lexer rather than trusting `syn`'s literal-value
1207/// interpretation: `0x`/`0X` is hex, a leading `0` followed by more
1208/// digits is C-style octal, anything else is decimal.
1209fn parse_int_literal(lit: &syn::LitInt) -> syn::Result<i128> {
1210    let text = lit.base10_digits().to_string();
1211    let raw = lit.token().to_string();
1212    let raw = raw.split(['u', 'i', 'U', 'I']).next().unwrap_or(&raw);
1213    if let Some(hex) = raw.strip_prefix("0x").or_else(|| raw.strip_prefix("0X")) {
1214        return u128::from_str_radix(hex, 16)
1215            .map(|v| v as i128)
1216            .map_err(|e| syn::Error::new(lit.span(), format!("bad hex literal: {e}")));
1217    }
1218    if raw.len() > 1 && raw.starts_with('0') && raw[1..].bytes().all(|b| (b'0'..=b'7').contains(&b))
1219    {
1220        return u128::from_str_radix(&raw[1..], 8)
1221            .map(|v| v as i128)
1222            .map_err(|e| syn::Error::new(lit.span(), format!("bad octal literal: {e}")));
1223    }
1224    text.parse::<i128>()
1225        .or_else(|_| text.parse::<u128>().map(|v| v as i128))
1226        .map_err(|e| syn::Error::new(lit.span(), format!("bad integer literal: {e}")))
1227}
1228
1229fn set_else_case(top: &mut Node, else_case: Node) {
1230    if let Node::IfThenElse {
1231        else_case: slot, ..
1232    } = top
1233    {
1234        if matches!(slot.as_ref(), Node::Skip { .. }) {
1235            **slot = else_case;
1236        } else {
1237            set_else_case(slot, else_case);
1238        }
1239    }
1240}