sbpf_assembler/preprocessor/
include.rs1use {
2 super::{
3 FileResolver, SourceLine,
4 source_map::{FileRegistry, SourceOrigin},
5 },
6 crate::errors::CompileError,
7 std::collections::HashSet,
8};
9
10fn 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
26fn parse_include_directive(line: &str) -> Option<&str> {
29 let trimmed = line.trim();
30 let rest = trimmed.strip_prefix(".include")?;
31
32 if !rest.starts_with(char::is_whitespace) {
34 return None;
35 }
36
37 let rest = rest.trim();
38
39 if rest.starts_with('"') && rest.ends_with('"') && rest.len() >= 2 {
41 Some(&rest[1..rest.len() - 1])
42 } else {
43 None
44 }
45}
46
47pub(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 let line_start: usize = source
105 .lines()
106 .take(line_idx)
107 .map(|l| l.len() + 1) .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 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 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 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 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}