Add StyleHint::Common, refactor BaseKind

Author: archaephyrryx

doodle-formats/src/format/opentype.rs

@@ -5590,7 +5590,7 @@ pub(crate) mod alt {
                                 "axis_value_offsets",
                                 with_view(
                                     ViewExpr::var("axis_value_scope"),
-                                    read_array(count, BaseKind::U16),
+                                    read_array(count, BaseKind::U16BE),
                                 ),
                             ), // TODO - ForEach(offset: u16) -> offsetu16(offset, axis_value_table)
                         ]),

src/alt.rs

@@ -7,8 +7,8 @@ use std::{
 };
 
 use crate::{
-    BaseKind, BaseType, ByteSet, DynFormat, Expr, Format, FormatModule, FormatRef, IntoLabel,
-    Label, Pattern, StyleHint, TypeScope, ValueKind, ValueType, ViewExpr,
+    BaseKind, BaseType, ByteSet, DynFormat, Endian, Expr, Format, FormatModule, FormatRef,
+    IntoLabel, Label, Pattern, StyleHint, TypeScope, ValueKind, ValueType, ViewExpr,
     typecheck::UnificationError, valuetype::Container,
 };
 use anyhow::{Result as AResult, anyhow};
@@ -129,7 +129,7 @@ pub enum ViewFormatExt {
     /// Captures a byte-slice of a View, given an expression for the byte-length of the slice
     CaptureBytes(Box<Expr>),
     /// Captures a scoped ReadArray of the given unit, given an expression for element-count (*NOT* byte-length)
-    ReadArray(Box<Expr>, BaseKind),
+    ReadArray(Box<Expr>, BaseKind<Endian>),
     /// Constructs a View-object in the value layer
     ReifyView,
 }

src/codegen/mod.rs

@@ -12,8 +12,8 @@ use resolve::Resolvable;
 pub use rust_ast::ToFragment;
 
 use crate::{
-    Arith, BaseType, DynFormat, Expr, Format, FormatModule, IntRel, IntoLabel, Label, MatchTree,
-    Pattern, StyleHint, UnaryOp, ViewExpr, ViewFormat,
+    Arith, BaseKind, BaseType, CommonOp, DynFormat, Endian, Expr, Format, FormatModule, IntRel,
+    IntoLabel, Label, MatchTree, Pattern, StyleHint, UnaryOp, ViewExpr, ViewFormat,
     byte_set::ByteSet,
     decoder::extract_pair,
     parser::error::TraceHash,
@@ -2702,7 +2702,7 @@ impl ToAst for SimpleLogic<GTExpr> {
 enum ViewLogic<ExprT> {
     LetView(Label, Box<CaseLogic<ExprT>>),
     CaptureBytes(RustExpr, RustExpr),
-    ReadArray(RustExpr, RustExpr, crate::BaseKind),
+    ReadArray(RustExpr, RustExpr, BaseKind<Endian>),
     ReifyView(RustExpr),
 }
 
@@ -3293,11 +3293,14 @@ where
             }
             OtherLogic::Hint(_hint, inner) => {
                 let inner_block = inner.to_ast(ctxt);
-
                 match _hint {
                     // REVIEW - do we want to perform any local modifications?
                     StyleHint::Record { .. } => inner_block,
                     StyleHint::AsciiStr => inner_block,
+                    StyleHint::Common(CommonOp::EndianParse(_kind_endian)) => {
+                        // REVIEW - do we want to swap-in particular endian parses instead?
+                        inner_block
+                    }
                 }
             }
         }
@@ -4401,7 +4404,25 @@ impl<'a> Elaborator<'a> {
                             }
                         }
                     }
-                    StyleHint::AsciiStr => (),
+                    StyleHint::AsciiStr => {
+                        // REVIEW - should we check for Seq(u8)-like types?
+                    }
+                    StyleHint::Common(common_op) => match common_op {
+                        CommonOp::EndianParse(base_kind) => {
+                            // double-check the base kind against the type
+                            let ty = gt.to_rust_type();
+                            let prim1 = PrimType::from(BaseType::from(*base_kind));
+                            let Some(prim0) = ty.try_as_prim() else {
+                                unreachable!(
+                                    "found non-primitive type for common format elaboration: {ty:?} @ {index} (expected {prim1:?})"
+                                );
+                            };
+                            assert_eq!(
+                                prim0, prim1,
+                                "CommonOp: actual inner-parse type ({prim0:?}) does not match claimed type ({prim1:?})"
+                            );
+                        }
+                    },
                 }
                 TypedFormat::Hint(gt, style_hint.clone(), Box::new(t_inner))
             }

src/codegen/model.rs

@@ -1,4 +1,4 @@
-use crate::{BaseKind, Label};
+use crate::{BaseKind, Endian, Label};
 
 use super::rust_ast::*;
 use super::{GenBlock, GenExpr, GenStmt};
@@ -343,13 +343,16 @@ pub fn read_from_view(view: RustExpr, len: RustExpr) -> RustExpr {
 }
 
 /// Model RustExpr for handling `ViewFormat::ReadArray(len, kind)` in the Parser (View) model.
-pub fn read_array_from_view(view: RustExpr, len: RustExpr, kind: BaseKind) -> RustExpr {
+pub fn read_array_from_view(view: RustExpr, len: RustExpr, kind: BaseKind<Endian>) -> RustExpr {
     // NOTE - we need these separate methods because RustExpr::MethodCall doesn't allow turbo-fish type-parameters
     match kind {
         BaseKind::U8 => try_call!(view, read_array_u8, len),
-        BaseKind::U16 => try_call!(view, read_array_u16be, len),
-        BaseKind::U32 => try_call!(view, read_array_u32be, len),
-        BaseKind::U64 => try_call!(view, read_array_u64be, len),
+        BaseKind::U16BE => try_call!(view, read_array_u16be, len),
+        BaseKind::U32BE => try_call!(view, read_array_u32be, len),
+        BaseKind::U64BE => try_call!(view, read_array_u64be, len),
+        BaseKind::U16LE | BaseKind::U32LE | BaseKind::U64LE => {
+            unimplemented!("little-endian read-array parses not yet implemented")
+        }
     }
 }
 

src/codegen/typed_decoder.rs

@@ -1,5 +1,7 @@
 use crate::byte_set::ByteSet;
-use crate::{BaseKind, Format, FormatModule, Label, MatchTree, MaybeTyped, Next, StyleHint};
+use crate::{
+    BaseKind, Endian, Format, FormatModule, Label, MatchTree, MaybeTyped, Next, StyleHint,
+};
 use anyhow::{Result as AResult, anyhow};
 use std::borrow::Cow;
 use std::collections::HashMap;
@@ -231,7 +233,7 @@ pub(crate) enum TypedDecoder<TypeRep> {
         TypeRep,
         TypedViewExpr<TypeRep>,
         Box<TypedExpr<TypeRep>>,
-        BaseKind,
+        BaseKind<Endian>,
     ),
     ReifyView(TypeRep, TypedViewExpr<TypeRep>),
 }

src/codegen/typed_format.rs

@@ -7,7 +7,7 @@ use super::{AtomType, LocalType};
 use crate::bounds::Bounds;
 use crate::byte_set::ByteSet;
 use crate::codegen::rust_ast::{RustLt, RustParams, UseParams};
-use crate::{Arith, BaseKind, IntRel, Label, StyleHint, TypeHint, UnaryOp};
+use crate::{Arith, BaseKind, Endian, IntRel, Label, StyleHint, TypeHint, UnaryOp};
 
 pub(crate) mod variables;
 
@@ -538,7 +538,7 @@ impl<TypeRep> std::hash::Hash for TypedDynFormat<TypeRep> {
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub enum TypedViewFormat<TypeRep> {
     CaptureBytes(Box<TypedExpr<TypeRep>>),
-    ReadArray(Box<TypedExpr<TypeRep>>, BaseKind),
+    ReadArray(Box<TypedExpr<TypeRep>>, BaseKind<Endian>),
     ReifyView,
 }
 

src/decoder.rs

@@ -5,7 +5,7 @@ use crate::{
     Arith, DynFormat, Expr, Format, FormatModule, IntRel, MatchTree, Next, TypeScope, ValueType,
     ViewExpr, pattern::Pattern,
 };
-use crate::{BaseKind, IntoLabel, Label, MaybeTyped, TypeHint, UnaryOp, ViewFormat};
+use crate::{BaseKind, Endian, IntoLabel, Label, MaybeTyped, TypeHint, UnaryOp, ViewFormat};
 use anyhow::{Result as AResult, anyhow};
 use serde::Serialize;
 use std::borrow::Cow;
@@ -965,7 +965,7 @@ pub enum Decoder {
     LiftedOption(Option<Box<Decoder>>),
     LetView(Label, Box<Decoder>),
     CaptureBytes(ViewExpr, Box<Expr>),
-    ReadArray(ViewExpr, Box<Expr>, BaseKind),
+    ReadArray(ViewExpr, Box<Expr>, BaseKind<Endian>),
     ReifyView(ViewExpr),
 }
 
@@ -1959,32 +1959,38 @@ impl Decoder {
     }
 }
 
-fn read_base(buf: ReadCtxt<'_>, kind: BaseKind) -> Result<(Value, ReadCtxt<'_>), DecodeError> {
+fn read_base(
+    buf: ReadCtxt<'_>,
+    kind: BaseKind<Endian>,
+) -> Result<(Value, ReadCtxt<'_>), DecodeError> {
     match kind {
         BaseKind::U8 => {
             let Some((byte, new_buf)) = buf.read_byte() else {
                 return Err(DecodeError::overbyte(buf.offset));
             };
             Ok((Value::U8(byte), new_buf))
         }
-        BaseKind::U16 => {
+        BaseKind::U16BE => {
             let Some((val, new_buf)) = buf.read_u16be() else {
                 return Err(DecodeError::overrun(kind.size(), buf.offset));
             };
             Ok((Value::U16(val), new_buf))
         }
-        BaseKind::U32 => {
+        BaseKind::U32BE => {
             let Some((val, new_buf)) = buf.read_u32be() else {
                 return Err(DecodeError::overrun(kind.size(), buf.offset));
             };
             Ok((Value::U32(val), new_buf))
         }
-        BaseKind::U64 => {
+        BaseKind::U64BE => {
             let Some((val, new_buf)) = buf.read_u64be() else {
                 return Err(DecodeError::overrun(kind.size(), buf.offset));
             };
             Ok((Value::U64(val), new_buf))
         }
+        BaseKind::U16LE | BaseKind::U32LE | BaseKind::U64LE => {
+            unimplemented!("little-endian read-base parses not yet implemented")
+        }
     }
 }
 

src/helper.rs

@@ -2,13 +2,13 @@ use std::collections::BTreeSet;
 
 use num_traits::{ToPrimitive, Zero};
 
-use crate::bounds::Bounds;
 use crate::byte_set::ByteSet;
 pub use crate::marker::BaseKind;
 use crate::{
     Arith, BaseType, Expr, Format, IntRel, IntoLabel, Label, Pattern, StyleHint, TypeHint, UnaryOp,
     ValueType, ViewExpr, ViewFormat,
 };
+use crate::{Endian, bounds::Bounds};
 
 #[derive(Debug, Clone, Copy, PartialEq)]
 pub enum BitFieldKind {
@@ -1478,6 +1478,44 @@ pub fn capture_bytes(len: Expr) -> ViewFormat {
 }
 
 /// Helper for [`ViewFormat::ReadArray`]
-pub fn read_array(len: Expr, kind: BaseKind) -> ViewFormat {
+pub fn read_array(len: Expr, kind: BaseKind<Endian>) -> ViewFormat {
     ViewFormat::ReadArray(Box::new(len), kind)
 }
+
+pub mod base {
+    use super::*;
+    use crate::CommonOp;
+
+    macro_rules! endian {
+        ( $( $fname:ident, $kind_endian:ident, $size:expr, $op:ident );* $(;)? ) => {
+            $(
+                pub fn $fname() -> Format {
+                    Format::Hint(
+                        StyleHint::Common(CommonOp::EndianParse(BaseKind::$kind_endian)),
+                        Box::new(map(
+                            tuple_repeat($size, Format::ANY_BYTE),
+                            lambda("x", Expr::$op(Box::new(var("x")))),
+                        ))
+                    )
+                }
+            )*
+        };
+    }
+
+    pub fn u8() -> Format {
+        Format::Hint(
+            StyleHint::Common(CommonOp::EndianParse(BaseKind::U8)),
+            Box::new(Format::ANY_BYTE),
+        )
+    }
+
+    endian! {
+        u16be, U16BE, 2, U16Be;
+        u16le, U16LE, 2, U16Le;
+        u32be, U32BE, 4, U32Be;
+        u32le, U32LE, 4, U32Le;
+        u64be, U64BE, 8, U64Be;
+        u64le, U64LE, 8, U64Le;
+    }
+}
+pub use base::*;

src/lib.rs

@@ -24,7 +24,7 @@ pub mod error;
 pub mod helper;
 pub mod loc_decoder;
 pub mod marker;
-pub use marker::BaseKind;
+pub use marker::{BaseKind, Endian};
 pub mod output;
 pub mod parser;
 mod precedence;
@@ -690,7 +690,7 @@ pub enum ViewFormat {
     /// CaptureBytes(N): captures a slice of N bytes from the start of the View
     CaptureBytes(Box<Expr>),
     /// ReadArray(M, Kind): captures an array of M elements of the indicate Kind
-    ReadArray(Box<Expr>, BaseKind),
+    ReadArray(Box<Expr>, BaseKind<Endian>),
     /// ReifyView: produces a value-element that encapsulates the View-object
     ReifyView,
 }
@@ -758,6 +758,15 @@ impl ViewExpr {
     }
 }
 
+/// Operations we want to treat as semi-first-class in downstream processing,
+/// without forcing us to add new primitives into the Format layer.
+#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd, Serialize)]
+#[serde(tag = "tag", content = "args")]
+pub enum CommonOp {
+    EndianParse(BaseKind<Endian>),
+}
+
+/// The input is a UTF-8 encoded string, and the output is a UTF-8 encoded string
 // NOTE - as currently defined, StyleHint could easily be Copy, but it would be a breaking change if we later had to remove that trait
 #[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd, Serialize)]
 #[serde(tag = "tag", content = "args")]
@@ -768,6 +777,7 @@ pub enum StyleHint {
         old_style: bool,
     },
     AsciiStr,
+    Common(CommonOp),
 }
 
 #[derive(Copy, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]

src/loc_decoder.rs

@@ -8,7 +8,9 @@ use crate::decoder::{
 };
 use crate::error::{DecodeError, LocDecodeError};
 use crate::read::ReadCtxt;
-use crate::{Arith, BaseKind, DynFormat, Expr, Format, IntRel, Label, Pattern, UnaryOp, ViewExpr};
+use crate::{
+    Arith, BaseKind, DynFormat, Endian, Expr, Format, IntRel, Label, Pattern, UnaryOp, ViewExpr,
+};
 use std::borrow::Cow;
 use std::cmp::Ordering;
 
@@ -1859,7 +1861,7 @@ impl Decoder {
 
 fn read_base(
     buf: ReadCtxt<'_>,
-    kind: BaseKind,
+    kind: BaseKind<Endian>,
 ) -> Result<(ParsedValue, ReadCtxt<'_>), DecodeError<ParsedValue>> {
     let (val, new_buf) = match kind {
         BaseKind::U8 => {
@@ -1868,24 +1870,27 @@ fn read_base(
             };
             (Value::U8(byte), new_buf)
         }
-        BaseKind::U16 => {
+        BaseKind::U16BE => {
             let Some((val, new_buf)) = buf.read_u16be() else {
                 return Err(DecodeError::overrun(kind.size(), buf.offset));
             };
             (Value::U16(val), new_buf)
         }
-        BaseKind::U32 => {
+        BaseKind::U32BE => {
             let Some((val, new_buf)) = buf.read_u32be() else {
                 return Err(DecodeError::overrun(kind.size(), buf.offset));
             };
             (Value::U32(val), new_buf)
         }
-        BaseKind::U64 => {
+        BaseKind::U64BE => {
             let Some((val, new_buf)) = buf.read_u64be() else {
                 return Err(DecodeError::overrun(kind.size(), buf.offset));
             };
             (Value::U64(val), new_buf)
         }
+        BaseKind::U16LE | BaseKind::U32LE | BaseKind::U64LE => {
+            unimplemented!("little-endian read-base parses not yet implemented")
+        }
     };
     Ok((ParsedValue::new_flat(val, buf.offset, kind.size()), new_buf))
 }