Add trace support for json, fix ParsedValue matches_inner

Author: archaephyrryx

doodle-formats/src/main.rs

@@ -263,19 +263,33 @@ fn main() -> Result<(), Box<dyn std::error::Error + 'static>> {
             let program = Compiler::compile_program(&module, &format)?;
 
             let input = fs::read(filename)?;
-            let (value, _) = program.run(ReadCtxt::new(&input))?;
-
             match output {
-                FileOutput::Debug => println!("{value:?}"),
-                FileOutput::Json => serde_json::to_writer(std::io::stdout(), &value).unwrap(),
-                FileOutput::Tree if !trace => {
-                    doodle::output::tree::print_decoded_value(&module, &value, &format);
+                FileOutput::Debug => {
+                    let (value, _) = program.run(ReadCtxt::new(&input))?;
+                    println!("{value:?}");
+                }
+                FileOutput::Json => {
+                    if trace {
+                        let (p_value, _) = program.run_with_loc(ReadCtxt::new(&input))?;
+                        serde_json::to_writer(std::io::stdout(), &p_value).unwrap()
+                    } else {
+                        let (value, _) = program.run(ReadCtxt::new(&input))?;
+                        serde_json::to_writer(std::io::stdout(), &value).unwrap()
+                    }
                 }
                 FileOutput::Tree => {
-                    let (p_value, _) = program.run_with_loc(ReadCtxt::new(&input))?;
-                    doodle::output::tree::print_parsed_decoded_value(&module, &p_value, &format);
+                    if trace {
+                        let (p_value, _) = program.run_with_loc(ReadCtxt::new(&input))?;
+                        doodle::output::tree::print_parsed_decoded_value(
+                            &module, &p_value, &format,
+                        );
+                    } else {
+                        let (value, _) = program.run(ReadCtxt::new(&input))?;
+                        doodle::output::tree::print_decoded_value(&module, &value, &format);
+                    }
                 }
                 FileOutput::Flat => {
+                    let (value, _) = program.run(ReadCtxt::new(&input))?;
                     doodle::output::flat::print_decoded_value(&module, &value, &format);
                 }
             }

src/decoder.rs

@@ -149,6 +149,7 @@ impl Value {
             (Pattern::Int(bounds), Value::U16(n)) => bounds.contains(usize::from(*n)),
             (Pattern::Int(bounds), Value::U32(n)) => bounds.contains(usize::try_from(*n).unwrap()),
             (Pattern::Int(bounds), Value::U64(n)) => bounds.contains(usize::try_from(*n).unwrap()),
+            (Pattern::Int(bounds), Value::Usize(n)) => bounds.contains(*n),
             (Pattern::Char(c0), Value::Char(c1)) => c0 == c1,
             (Pattern::Tuple(ps), Value::Tuple(vs)) if ps.len() == vs.len() => {
                 for (p, v) in Iterator::zip(ps.iter(), vs.iter()) {
@@ -247,6 +248,8 @@ impl Value {
     /// # Panics
     ///
     /// Panics if the value is not numeric.
+    ///
+    /// May additionally panic in rare cases such as `u64`-to-`usize` conversion on 32-bit architectures.
     pub(crate) fn unwrap_usize(&self) -> usize {
         match self {
             Value::U8(n) => usize::from(*n),
@@ -979,7 +982,7 @@ pub struct Program {
 }
 
 impl Program {
-    fn new() -> Self {
+    pub(crate) fn new() -> Self {
         let decoders = Vec::new();
         Program { decoders }
     }

src/decoder/seq_kind.rs

@@ -3,6 +3,7 @@ use std::{borrow::Cow, fmt::Debug, ops::Index};
 use serde::Serialize;
 
 #[derive(Clone, PartialEq, Debug, Serialize, Hash, Eq)]
+#[serde(tag = "tag", content = "data")]
 // NOTE - T must be clone in order for `Dup` to be well-founded, as non-Clone values cannot be duped
 pub enum SeqKind<T: Clone> {
     Strict(Vec<T>),

src/loc_decoder.rs

@@ -11,10 +11,11 @@ use crate::read::ReadCtxt;
 use crate::{
     Arith, BaseKind, DynFormat, Endian, Expr, Format, IntRel, Label, Pattern, UnaryOp, ViewExpr,
 };
+use serde::Serialize;
 use std::borrow::Cow;
 use std::cmp::Ordering;
 
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Default)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Default, Serialize)]
 pub enum ParseLoc {
     InBuffer {
         offset: usize,
@@ -124,9 +125,10 @@ impl ParseLoc {
 }
 
 /// Helper type for associating a [`ParseLoc`] with a value of a generic type.
-#[derive(Clone, Copy, Debug)]
+#[derive(Clone, Copy, Debug, Serialize)]
 pub struct Parsed<T: Clone> {
     pub(crate) loc: ParseLoc,
+    #[serde(rename = "data")]
     pub(crate) inner: T,
 }
 
@@ -143,7 +145,8 @@ impl<T: Clone> AsRef<T> for Parsed<T> {
     }
 }
 
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, Serialize)]
+#[serde(tag = "tag", content = "data")]
 pub enum ParsedValue {
     /// Flat parses of the sub-set of `Value` variants that do not contain any embedded `Value` terms
     Flat(Parsed<Value>),
@@ -408,6 +411,14 @@ impl ParsedValue {
             }
             (Pattern::Option(None), ParsedValue::Option(None)) => true,
             (Pattern::Option(Some(p)), ParsedValue::Option(Some(v))) => v.matches_inner(scope, p),
+            (Pattern::Int(bounds), ParsedValue::Flat(Parsed { inner: v, .. })) => match v {
+                Value::U8(n) => bounds.contains(usize::from(*n)),
+                Value::U16(n) => bounds.contains(usize::from(*n)),
+                Value::U32(n) => bounds.contains(usize::try_from(*n).unwrap()),
+                Value::U64(n) => bounds.contains(usize::try_from(*n).unwrap()),
+                Value::Usize(n) => bounds.contains(*n),
+                _ => false,
+            },
             _ => false,
         }
     }
@@ -792,9 +803,18 @@ impl Expr {
             Expr::AsU8(x) => Cow::Owned(ParsedValue::from_evaluated(
                 match x.eval_value_with_loc(scope) {
                     Value::U8(x) => Value::U8(x),
-                    Value::U16(x) => Value::U8(u8::try_from(x).unwrap()),
-                    Value::U32(x) => Value::U8(u8::try_from(x).unwrap()),
-                    Value::U64(x) => Value::U8(u8::try_from(x).unwrap()),
+                    Value::U16(x) => Value::U8(u8::try_from(x).unwrap_or_else(|err| {
+                        panic!("cannot perform AsU8 cast on u16 {x}: {err}")
+                    })),
+                    Value::U32(x) => Value::U8(u8::try_from(x).unwrap_or_else(|err| {
+                        panic!("cannot perform AsU8 cast on u32 {x}: {err}")
+                    })),
+                    Value::U64(x) => Value::U8(u8::try_from(x).unwrap_or_else(|err| {
+                        panic!("cannot perform AsU8 cast on u64 {x}: {err}")
+                    })),
+                    Value::Usize(x) => Value::U8(u8::try_from(x).unwrap_or_else(|err| {
+                        panic!("cannot perform AsU8 cast on usize {x}: {err}")
+                    })),
                     x => panic!("cannot convert {x:?} to U8"),
                 },
             )),