Skip to main content

sbpf_assembler/preprocessor/
include.rs

1use {
2    super::{
3        FileResolver, SourceLine,
4        source_map::{FileRegistry, SourceOrigin},
5    },
6    crate::errors::CompileError,
7    std::collections::HashSet,
8};
9
10/// Cut off a trailing `;`, `#` or `//` comment (the grammar's `COMMENT`), so
11/// the preprocessor never reads it as part of a macro argument or directive.
12/// Markers inside a string literal don't count.
13fn strip_comment(line: &str) -> &str {
14    let mut in_string = false;
15    for (i, c) in line.char_indices() {
16        match c {
17            '"' => in_string = !in_string,
18            ';' | '#' if !in_string => return &line[..i],
19            '/' if !in_string && line[i + 1..].starts_with('/') => return &line[..i],
20            _ => {}
21        }
22    }
23    line
24}
25
26/// Parse a `.include "path"` directive from a line.
27/// Returns Some(path) if the line is an include directive, None otherwise.
28fn parse_include_directive(line: &str) -> Option<&str> {
29    let trimmed = line.trim();
30    let rest = trimmed.strip_prefix(".include")?;
31
32    // Must have whitespace after .include
33    if !rest.starts_with(char::is_whitespace) {
34        return None;
35    }
36
37    let rest = rest.trim();
38
39    // Path must be quoted
40    if rest.starts_with('"') && rest.ends_with('"') && rest.len() >= 2 {
41        Some(&rest[1..rest.len() - 1])
42    } else {
43        None
44    }
45}
46
47/// Resolve all `.include` directives recursively, producing a flat list of source lines.
48///
49/// Each line tracks its origin (file + line number) for diagnostics.
50/// Cycle detection uses a stack-based approach: A including B including A is caught,
51/// but A including B, then A including C (which also includes B) is allowed.
52pub(crate) fn resolve_includes(
53    source: &str,
54    source_path: &str,
55    resolver: Option<&dyn FileResolver>,
56    registry: &mut FileRegistry,
57) -> Result<Vec<SourceLine>, Vec<CompileError>> {
58    let mut include_stack: HashSet<String> = HashSet::new();
59    let source_identity = resolver
60        .and_then(|r| r.resolve_path(source_path, "").ok())
61        .unwrap_or_else(|| source_path.to_string());
62    include_stack.insert(source_identity);
63
64    let file_id = registry.add(source_path, source.to_string());
65    let mut errors = Vec::new();
66    let mut output = Vec::new();
67
68    resolve_recursive(
69        source,
70        file_id,
71        source_path,
72        resolver,
73        registry,
74        &mut include_stack,
75        &mut output,
76        &mut errors,
77    );
78
79    if errors.is_empty() {
80        Ok(output)
81    } else {
82        Err(errors)
83    }
84}
85
86#[allow(clippy::too_many_arguments)]
87fn resolve_recursive(
88    source: &str,
89    file_id: super::source_map::FileId,
90    file_path: &str,
91    resolver: Option<&dyn FileResolver>,
92    registry: &mut FileRegistry,
93    include_stack: &mut HashSet<String>,
94    output: &mut Vec<SourceLine>,
95    errors: &mut Vec<CompileError>,
96) {
97    for (line_idx, line_text) in source.lines().enumerate() {
98        let line_number = (line_idx + 1) as u32;
99        let line_text = strip_comment(line_text);
100
101        if let Some(include_path) = parse_include_directive(line_text) {
102            // Calculate a span for error reporting.
103            // We use the byte offset of this line in the source.
104            let line_start: usize = source
105                .lines()
106                .take(line_idx)
107                .map(|l| l.len() + 1) // +1 for newline
108                .sum();
109            let span = line_start..line_start + line_text.len();
110
111            let resolver = match resolver {
112                Some(r) => r,
113                None => {
114                    errors.push(CompileError::IncludeNotFound {
115                        path: include_path.to_string(),
116                        span,
117                        custom_label: Some("No file resolver configured".to_string()),
118                    });
119                    continue;
120                }
121            };
122
123            // Keep the resolved filename, not just the literal include directive.
124            // Nested includes must start from the directory of the file we found.
125            let resolved = resolver
126                .resolve_path(include_path, file_path)
127                .and_then(|path| {
128                    if include_stack.contains(&path) {
129                        return Ok((path, None));
130                    }
131                    resolver
132                        .resolve(&path, file_path)
133                        .map(|content| (path, Some(content)))
134                });
135            match resolved {
136                Ok((_, None)) => {
137                    errors.push(CompileError::IncludeCycle {
138                        path: include_path.to_string(),
139                        span,
140                        custom_label: None,
141                    });
142                }
143                Ok((resolved_path, Some(content))) => {
144                    let included_file_id = registry.add(&resolved_path, content.clone());
145                    include_stack.insert(resolved_path.clone());
146
147                    resolve_recursive(
148                        &content,
149                        included_file_id,
150                        &resolved_path,
151                        Some(resolver),
152                        registry,
153                        include_stack,
154                        output,
155                        errors,
156                    );
157
158                    include_stack.remove(&resolved_path);
159                }
160                Err(e) => {
161                    if e.kind() == std::io::ErrorKind::NotFound {
162                        errors.push(CompileError::IncludeNotFound {
163                            path: include_path.to_string(),
164                            span,
165                            custom_label: None,
166                        });
167                    } else {
168                        errors.push(CompileError::IncludeReadError {
169                            path: include_path.to_string(),
170                            reason: e.to_string(),
171                            span,
172                            custom_label: None,
173                        });
174                    }
175                }
176            }
177        } else {
178            // Regular line -- pass through with origin tracking
179            output.push(SourceLine {
180                text: line_text.to_string(),
181                origin: SourceOrigin::new(file_id, line_number),
182            });
183        }
184    }
185}
186
187#[cfg(test)]
188mod tests {
189    use {super::*, crate::preprocessor::MockFileResolver};
190
191    #[test]
192    fn test_parse_include_directive() {
193        assert_eq!(parse_include_directive(".include \"foo.s\""), Some("foo.s"));
194        assert_eq!(
195            parse_include_directive("  .include \"path/to/file.s\"  "),
196            Some("path/to/file.s")
197        );
198        assert_eq!(parse_include_directive(".include foo.s"), None);
199        assert_eq!(parse_include_directive("mov64 r1, 1"), None);
200        assert_eq!(parse_include_directive(".includes \"foo.s\""), None);
201        assert_eq!(parse_include_directive(".include"), None);
202    }
203
204    #[test]
205    fn test_strip_comment() {
206        assert_eq!(strip_comment("SUB_LEN 1, 4 ; r2 = 3"), "SUB_LEN 1, 4 ");
207        assert_eq!(strip_comment(".endr # done"), ".endr ");
208        assert_eq!(strip_comment("mov64 r1, 8 / 2 // half"), "mov64 r1, 8 / 2 ");
209        assert_eq!(
210            strip_comment(".ascii \"a;b#c//d\" ; text"),
211            ".ascii \"a;b#c//d\" "
212        );
213        assert_eq!(strip_comment("exit"), "exit");
214    }
215
216    #[test]
217    fn test_no_includes() {
218        let source = "mov64 r1, 1\nexit\n";
219        let mut registry = FileRegistry::new();
220        let result = resolve_includes(source, "<input>", None, &mut registry).unwrap();
221
222        assert_eq!(result.len(), 2);
223        assert_eq!(result[0].text, "mov64 r1, 1");
224        assert_eq!(result[0].origin.line, 1);
225        assert_eq!(result[1].text, "exit");
226        assert_eq!(result[1].origin.line, 2);
227    }
228
229    #[test]
230    fn test_single_include() {
231        let mut resolver = MockFileResolver::new();
232        resolver.add_file("macros.s", "macro_line1\nmacro_line2");
233
234        let source = "before\n.include \"macros.s\"\nafter";
235        let mut registry = FileRegistry::new();
236        let result = resolve_includes(source, "<input>", Some(&resolver), &mut registry).unwrap();
237
238        assert_eq!(result.len(), 4);
239        assert_eq!(result[0].text, "before");
240        assert_eq!(result[1].text, "macro_line1");
241        assert_eq!(result[2].text, "macro_line2");
242        assert_eq!(result[3].text, "after");
243
244        // Check origin tracking
245        assert_eq!(registry.path(result[0].origin.file_id), "<input>");
246        assert_eq!(registry.path(result[1].origin.file_id), "macros.s");
247        assert_eq!(result[1].origin.line, 1);
248        assert_eq!(result[2].origin.line, 2);
249    }
250
251    #[test]
252    fn test_nested_includes() {
253        let mut resolver = MockFileResolver::new();
254        resolver.add_file("a.s", "a_line\n.include \"b.s\"\na_end");
255        resolver.add_file("b.s", "b_line");
256
257        let source = ".include \"a.s\"";
258        let mut registry = FileRegistry::new();
259        let result = resolve_includes(source, "<input>", Some(&resolver), &mut registry).unwrap();
260
261        assert_eq!(result.len(), 3);
262        assert_eq!(result[0].text, "a_line");
263        assert_eq!(result[1].text, "b_line");
264        assert_eq!(result[2].text, "a_end");
265    }
266
267    #[test]
268    fn test_nested_include_paths() {
269        for with_decoy in [false, true] {
270            let mut resolver = MockFileResolver::new();
271            resolver.add_file("src/program/includes/outer.s", ".include \"inner.s\"");
272            resolver.add_file("src/program/includes/inner.s", "mov64 r0, 7");
273            if with_decoy {
274                resolver.add_file("includes/inner.s", "mov64 r0, 99");
275            }
276
277            let mut registry = FileRegistry::new();
278            let result = resolve_includes(
279                ".include \"includes/outer.s\"\nexit",
280                "src/program/program.s",
281                Some(&resolver),
282                &mut registry,
283            )
284            .unwrap();
285
286            assert_eq!(result.len(), 2);
287            assert_eq!(result[0].text, "mov64 r0, 7");
288            assert_eq!(
289                registry.path(result[0].origin.file_id),
290                "src/program/includes/inner.s"
291            );
292            assert_eq!(result[0].origin.line, 1);
293            assert_eq!(result[1].text, "exit");
294            assert_eq!(
295                registry.path(result[1].origin.file_id),
296                "src/program/program.s"
297            );
298            assert_eq!(result[1].origin.line, 2);
299        }
300    }
301
302    #[test]
303    fn test_include_cycle_detection() {
304        let mut resolver = MockFileResolver::new();
305        resolver.add_file("a.s", ".include \"<input>\"");
306
307        let source = ".include \"a.s\"";
308        let mut registry = FileRegistry::new();
309        let result = resolve_includes(source, "<input>", Some(&resolver), &mut registry);
310
311        assert!(result.is_err());
312        let errors = result.unwrap_err();
313        assert_eq!(errors.len(), 1);
314        assert!(matches!(&errors[0], CompileError::IncludeCycle { path, .. } if path == "<input>"));
315    }
316
317    #[test]
318    fn test_include_not_found() {
319        let resolver = MockFileResolver::new();
320
321        let source = ".include \"missing.s\"";
322        let mut registry = FileRegistry::new();
323        let result = resolve_includes(source, "<input>", Some(&resolver), &mut registry);
324
325        assert!(result.is_err());
326        let errors = result.unwrap_err();
327        assert!(
328            matches!(&errors[0], CompileError::IncludeNotFound { path, .. } if path == "missing.s")
329        );
330    }
331
332    #[test]
333    fn test_diamond_include_allowed() {
334        // A includes B and C, both B and C include D -- this is allowed (not a cycle)
335        let mut resolver = MockFileResolver::new();
336        resolver.add_file("b.s", ".include \"d.s\"\nb_line");
337        resolver.add_file("c.s", ".include \"d.s\"\nc_line");
338        resolver.add_file("d.s", "d_line");
339
340        let source = ".include \"b.s\"\n.include \"c.s\"";
341        let mut registry = FileRegistry::new();
342        let result = resolve_includes(source, "<input>", Some(&resolver), &mut registry).unwrap();
343
344        assert_eq!(result.len(), 4);
345        assert_eq!(result[0].text, "d_line");
346        assert_eq!(result[1].text, "b_line");
347        assert_eq!(result[2].text, "d_line");
348        assert_eq!(result[3].text, "c_line");
349    }
350}