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 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
308fn is_global_label_word(word: &str) -> bool {
310 word.starts_with('_')
311}
312
313fn is_special_register_word(word: &str) -> bool {
315 word.starts_with('%')
316}
317
318fn 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
340fn 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 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 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 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 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
1205fn 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}