Recursive formats with infinite loop check.

Author: mikeday

src/lib.rs

@@ -527,6 +527,14 @@ impl FormatModule {
         self.define_format_args(name, vec![], format)
     }
 
+    pub fn define_format_rec(
+        &mut self,
+        name: impl Into<String>,
+        f: impl FnOnce(FormatRef) -> Format,
+    ) -> FormatRef {
+        self.define_format_args_rec(name, vec![], f)
+    }
+
     pub fn define_format_args(
         &mut self,
         name: impl Into<String>,
@@ -549,6 +557,32 @@ impl FormatModule {
         FormatRef(level)
     }
 
+    pub fn define_format_args_rec(
+        &mut self,
+        name: impl Into<String>,
+        args: Vec<(String, ValueType)>,
+        f: impl FnOnce(FormatRef) -> Format,
+    ) -> FormatRef {
+        let format_ref = FormatRef(self.names.len());
+        let format = f(format_ref);
+        if let Err(()) = format.recursion_check(self, format_ref) {
+            panic!("format fails recursion check!");
+        }
+        let mut scope = TypeScope::new();
+        for (arg_name, arg_type) in &args {
+            scope.push(arg_name.clone(), arg_type.clone());
+        }
+        let format_type = match self.infer_format_type(&mut scope, &format) {
+            Ok(t) => t,
+            Err(msg) => panic!("{msg}"),
+        };
+        self.names.push(name.into());
+        self.args.push(args);
+        self.formats.push(format);
+        self.format_types.push(format_type);
+        format_ref
+    }
+
     fn get_name(&self, level: usize) -> &str {
         &self.names[level]
     }
@@ -1307,6 +1341,93 @@ impl Format {
         }
         MatchTree::build(module, &fs, Rc::new(Next::Empty)).is_none()
     }
+
+    fn recursion_check(&self, module: &FormatModule, format_ref: FormatRef) -> Result<bool, ()> {
+        match self {
+            Format::ItemVar(level, _arg_exprs) => {
+                if format_ref.get_level() == *level {
+                    Err(())
+                } else {
+                    Ok(module.get_format(*level).is_nullable(module))
+                }
+            }
+            Format::Fail => Ok(false),
+            Format::EndOfInput => Ok(true),
+            Format::Align(_n) => Ok(true),
+            Format::Byte(_bs) => Ok(false),
+            Format::Union(branches) | Format::NondetUnion(branches) => {
+                let mut nullable = false;
+                for (_label, f) in branches {
+                    nullable = nullable || f.recursion_check(module, format_ref)?;
+                }
+                Ok(nullable)
+            }
+            Format::Tuple(fields) => {
+                for f in fields {
+                    if !f.recursion_check(module, format_ref)? {
+                        return Ok(false);
+                    }
+                }
+                Ok(true)
+            }
+            Format::Record(fields) => {
+                for (_label, f) in fields {
+                    if !f.recursion_check(module, format_ref)? {
+                        return Ok(false);
+                    }
+                }
+                Ok(true)
+            }
+            Format::Repeat(a) => {
+                a.recursion_check(module, format_ref)?;
+                Ok(true)
+            }
+            Format::Repeat1(a) => {
+                a.recursion_check(module, format_ref)?;
+                Ok(false)
+            }
+            Format::RepeatCount(_expr, a)
+            | Format::RepeatUntilLast(_expr, a)
+            | Format::RepeatUntilSeq(_expr, a) => {
+                a.recursion_check(module, format_ref)?;
+                Ok(true) // FIXME bit sloppy but okay
+            }
+            Format::Peek(a) => {
+                a.recursion_check(module, format_ref)?;
+                Ok(true)
+            }
+            Format::PeekNot(a) => {
+                a.recursion_check(module, format_ref)?;
+                Ok(true)
+            }
+            Format::Slice(expr, a) => {
+                a.recursion_check(module, format_ref)?;
+                Ok(expr.bounds().min == 0)
+            }
+            Format::Bits(_a) => Ok(false),
+            Format::WithRelativeOffset(_expr, a) => {
+                a.recursion_check(module, format_ref)?; // technically okay if expr > 0
+                Ok(true)
+            }
+            Format::Compute(_expr) => Ok(true),
+            Format::Match(_head, branches) => {
+                let mut nullable = false;
+                for (_pattern, f) in branches {
+                    nullable = nullable || f.recursion_check(module, format_ref)?;
+                }
+                Ok(nullable)
+            }
+            Format::MatchVariant(_head, branches) => {
+                let mut nullable = false;
+                for (_label, _pattern, f) in branches {
+                    nullable = nullable || f.recursion_check(module, format_ref)?;
+                }
+                Ok(nullable)
+            }
+            Format::Dynamic(DynFormat::Huffman(_, _)) => Ok(true),
+            Format::Apply(_expr) => Ok(false),
+        }
+    }
 }
 
 impl Format {