Implement look-around index generation

Author: Multimodcrafter

regex-automata/src/nfa/thompson/compiler.rs

@@ -711,7 +711,13 @@ pub struct Compiler {
     /// State used for caching common suffixes when compiling reverse UTF-8
     /// automata (for Unicode character classes).
     utf8_suffix: RefCell<Utf8SuffixMap>,
+    /// Top level alternation state which is used to run all look-around
+    /// assertion checks in lockstep with the main expression. Each look-around
+    /// expression is compiled to a set of states that is patched into this
+    /// state, and this state is updated on each new pattern being compiled.
     lookaround_alt: RefCell<Option<StateID>>,
+    /// The next index to use for a look-around expression.
+    lookaround_index: RefCell<SmallIndex>,
 }
 
 impl Compiler {
@@ -725,6 +731,7 @@ impl Compiler {
             trie_state: RefCell::new(RangeTrie::new()),
             utf8_suffix: RefCell::new(Utf8SuffixMap::new(1000)),
             lookaround_alt: RefCell::new(None),
+            lookaround_index: RefCell::new(SmallIndex::ZERO),
         }
     }
 
@@ -1046,7 +1053,11 @@ impl Compiler {
             LookAround::NegativeLookBehind(_) => false,
             LookAround::PositiveLookBehind(_) => true,
         };
-        let idx = todo!("get index");
+        let idx = *self.lookaround_index.borrow();
+        *self.lookaround_index.borrow_mut() = SmallIndex::new(idx.one_more())
+            .map_err(|e| {
+                BuildError::too_many_lookarounds(e.attempted() as usize)
+            })?;
         let check = self.add_check_lookaround(idx, pos)?;
         let write = self.add_write_lookaround(idx)?;
         self.patch(sub.end, write)?;

regex-automata/src/nfa/thompson/error.rs

@@ -1,6 +1,6 @@
 use crate::util::{
     captures, look,
-    primitives::{PatternID, StateID},
+    primitives::{PatternID, SmallIndex, StateID},
 };
 
 /// An error that can occurred during the construction of a thompson NFA.
@@ -55,6 +55,14 @@ enum BuildErrorKind {
         /// The limit on the number of states.
         limit: usize,
     },
+    /// An error that occurs if too many indices need to be generated for
+    /// look-around sub-expressions while building an NFA.
+    TooManyLookArounds {
+        /// The number of sub-expressions that exceeded the limit.
+        given: usize,
+        /// The limit on the number of sub-expressions.
+        limit: usize,
+    },
     /// An error that occurs when NFA compilation exceeds a configured heap
     /// limit.
     ExceededSizeLimit {
@@ -115,6 +123,13 @@ impl BuildError {
         BuildError { kind: BuildErrorKind::TooManyStates { given, limit } }
     }
 
+    pub(crate) fn too_many_lookarounds(given: usize) -> BuildError {
+        let limit = SmallIndex::LIMIT;
+        BuildError {
+            kind: BuildErrorKind::TooManyLookArounds { given, limit },
+        }
+    }
+
     pub(crate) fn exceeded_size_limit(limit: usize) -> BuildError {
         BuildError { kind: BuildErrorKind::ExceededSizeLimit { limit } }
     }
@@ -164,6 +179,12 @@ impl core::fmt::Display for BuildError {
                  which exceeds the limit of {}",
                 given, limit,
             ),
+            BuildErrorKind::TooManyLookArounds { given, limit } => write!(
+                f,
+                "attempted to compile {} look-around expressions, \
+                 which exceeds the limit of {}",
+                given, limit,
+            ),
             BuildErrorKind::ExceededSizeLimit { limit } => write!(
                 f,
                 "heap usage during NFA compilation exceeded limit of {}",