xpat

sub/xpat/src/atoms.rs

@@ -0,0 +1,83 @@
+pub type Pattern<'l> = &'l[Atom];
+
+/// Pattern atoms.
+///
+/// The scanner will silently ignore nonsensical arguments.
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+pub enum Atom {
+    /// Matches a single byte.
+    Byte(u8),
+    /// Captures the cursor in the save array at the specified index.
+    Save(u8),
+    /// After a Pop later continue matching at the current cursor plus the argument.
+    Push(u8),
+    /// Pops the cursor from the stack and continues matching.
+    Pop,
+    /// Sets a mask to apply on next byte match.
+    Fuzzy(u8),
+    /// Skips a fixed number of bytes.
+    Skip(u8),
+    /// Rewinds the cursor a fixed number of bytes.
+    Back(u8),
+    /// Extends the push, skip, back and many range by `argument * 256`.
+    Rangext(u8),
+    /// Looks for the next pattern at most a certain number of bytes ahead.
+    Many(u8),
+    /// Follows a signed 1 byte jump.
+    ///
+    /// Reads the byte under the cursor, sign extends it, adds it plus 1 to the cursor and continues matching.
+    Jump1,
+    /// Follows a signed 4 byte jump.
+    ///
+    /// Reads the dword under the cursor and adds it plus 4 to the cursor and continues matching.
+    Jump4,
+    /// Follows an absolute pointer.
+    ///
+    /// Reads the pointer under the cursor, translates it to an RVA, assigns it to the cursor and continues matching.
+    ///
+    /// Matching fails immediately when translation to an RVA fails.
+    Ptr,
+    /// Follows a position independent reference.
+    ///
+    /// Reads the dword under the cursor and adds it to the saved cursor for the given slot and continues matching.
+    Pir(u8),
+    /// Compares the cursor with the value in the given save slot and fails if they're not equal.
+    Check(u8),
+    /// Checks if the cursor is aligned to `(1 << value)`.
+    Aligned(u8),
+    /// Reads and sign-extends the byte under the cursor, writes to the given slot and advances the cursor by 1.
+    ReadI8(u8),
+    /// Reads and zero-extends the byte under the cursor, writes to the given slot and advances the cursor by 1.
+    ReadU8(u8),
+    /// Reads and sign-extends the word under the cursor, writes to the given slot and advances the cursor by 2.
+    ReadI16(u8),
+    /// Reads and zero-extends the word under the cursor, writes to the given slot and advances the cursor by 2.
+    ReadU16(u8),
+    /// Reads the dword under the cursor, writes to the given slot and advances the cursor by 4.
+    ReadI32(u8),
+    /// Reads the dword under the cursor, writes to the given slot and advances the cursor by 4.
+    ReadU32(u8),
+    /// Writes zero to the given save slot.
+    Zero(u8),
+    /// Sets a retry point when matching fails.
+    ///
+    /// When matching fails the cursor is restored and matching begins again skipping _N_ atoms.
+    Case(u8),
+    /// Continues matching after a case atom, skipping the next _N_ atoms.
+    Break(u8),
+    /// Null instruction, used to make the parser easier to write.
+    Nop,
+}
+
+impl Atom {
+    pub fn save_len(pat: &[Atom]) -> usize {
+        pat.iter().filter_map(|&atom| {
+            match atom {
+                Atom::Save(slot) | Atom::Pir(slot) | Atom::Check(slot) | Atom::Zero(slot) |
+                Atom::ReadI8(slot) | Atom::ReadI16(slot) | Atom::ReadI32(slot) |
+                Atom::ReadU8(slot) | Atom::ReadU16(slot)| Atom::ReadU32(slot) => Some(slot as usize + 1),
+                _ => None,
+            }
+        }).max().unwrap_or(0)
+    }
+}