Change incomplete DFA to a complete one

Previously, a hash map was used for the DFA state transitions (key was
the symbol; value was the next state) because each DFA state had only
the transitions that were really necessary and did not have transitions
for every symbol of the alphabet.

Now a complete DFA is created, meaning each state has transitions for
each symbol of the alphabet. In addition, the DFA now has a real dead
state. So, the DFA now meets the strict definition of a complete DFA.

This change allowed the hash map that stored the DFA state transitions
to be replaced with an array, which greatly increases the speed of the
DFA since there is now no need to compute hashes.

Author: SicroAtGit

README.md

@@ -41,14 +41,16 @@ EndIf
 ```
 More code examples can be found in the [`examples`](examples) directory.
 
-## Public Enumerations
+## Public Constants
 
 ```purebasic
 Enumeration NfaSpecialSymbols 256
   #Symbol_Move  ; Used for NFA epsilon moves
   #Symbol_Split ; Used for NFA unions
   #Symbol_Final ; Used for NFA final state
 EndEnumeration
+
+#State_DfaDeadState = 0
 ```
 
 ## Public Structures
@@ -63,8 +65,8 @@ EndStructure
 
 ```purebasic
 Structure DfaStateStruc
-  Map symbols.i() ; Key is the symbol and the value is the next DFA state
-  isFinalState.i  ; `#True` if the DFA state is a final state, otherwise `#False`
+  symbols.i[256] ; Index is the symbol code and the value is the next DFA state
+  isFinalState.i ; `#True` if the DFA state is a final state, otherwise `#False`
 EndStructure
 ```
 

RegExEngine.pbi

@@ -9,15 +9,17 @@ DeclareModule RegEx
     #Symbol_Final ; Used for NFA final state
   EndEnumeration
 
+  #State_DfaDeadState = 0
+  
   Structure NfaStateStruc
     symbol.i    ; Unicode number or special symbol number
     *nextState1 ; Pointer to the first next NFA state
     *nextState2 ; Pointer to the second next NFA state
   EndStructure
 
   Structure DfaStateStruc
-    Map symbols.i() ; Key is the symbol and the value is the next DFA state
-    isFinalState.i  ; `#True` if the DFA state is a final state, otherwise `#False`
+    symbols.i[256] ; Index is the symbol code and the value is the next DFA state
+    isFinalState.i ; `#True` if the DFA state is a final state, otherwise `#False`
   EndStructure
 
   Structure RegExEngineStruc
@@ -440,7 +442,9 @@ Module RegEx
     sizeOfArray = ArraySize(eClosures())
     countOfStates = ListSize(*states())
 
-    For dfaState = 0 To sizeOfArray
+    ; dfaState '0' is the dead state, so it will be skipped.
+    
+    For dfaState = 1 To sizeOfArray
 
       isFound = #True
 
@@ -468,13 +472,18 @@ Module RegEx
   EndProcedure
 
   Procedure CreateDfa(*regExEngine.RegExEngineStruc, clearNfa = #True)
-    Protected.EClosureStruc Dim eClosures(0), NewMap symbols()
+    Protected.EClosureStruc Dim eClosures(1), NewMap symbols()
     Protected.NfaStateStruc *state
     Protected sizeOfArray, dfaState, result
 
+    dfaState = 1
+    
+    ; dfaState '0' is the dead state, so it will be skipped.
+    ; eClosures(0) is then always unused, but it is easier that way.
+    
     AddState(*regExEngine\initialNfaState, eClosures(dfaState)\nfaStates())
 
-    For dfaState = 0 To ArraySize(eClosures())
+    For dfaState = 1 To ArraySize(eClosures())
 
       ClearMap(symbols())
 
@@ -491,13 +500,13 @@ Module RegEx
       ForEach symbols()
         result = FindStatesSet(eClosures(), symbols()\nfaStates())
         If result
-          *regExEngine\dfaStatesPool(dfaState)\symbols(MapKey(symbols())) = result
+          *regExEngine\dfaStatesPool(dfaState)\symbols[Asc(MapKey(symbols()))] = result
         Else
           sizeOfArray = ArraySize(eClosures())
           ReDim eClosures(sizeOfArray + 1)
           ReDim *regExEngine\dfaStatesPool(sizeOfArray + 1)
           CopyList(symbols()\nfaStates(), eClosures(sizeOfArray + 1)\nfaStates())
-          *regExEngine\dfaStatesPool(dfaState)\symbols(MapKey(symbols())) = sizeOfArray + 1
+          *regExEngine\dfaStatesPool(dfaState)\symbols[Asc(MapKey(symbols()))] = sizeOfArray + 1
         EndIf
       Next
 
@@ -547,12 +556,15 @@ Module RegEx
   Procedure DfaMatch(*regExEngine.RegExEngineStruc, *string.Ascii)
     Protected dfaState, matchLength, lastFinalStateMatchLength
 
+    dfaState = 1
+    
+    ; dfaState '0' is the dead state, so it will be skipped.
+    
     Repeat
-      
-      If Not FindMapElement(*regExEngine\dfaStatesPool(dfaState)\symbols(), Chr(*string\a))
+      dfaState = *regExEngine\dfaStatesPool(dfaState)\symbols[*string\a]
+      If dfaState = #State_DfaDeadState
         Break
       EndIf
-      dfaState = *regExEngine\dfaStatesPool(dfaState)\symbols()
 
       matchLength + 1
       *string + SizeOf(Ascii)
@@ -566,7 +578,7 @@ Module RegEx
   EndProcedure
 
   Procedure Match(*regExEngine.RegExEngineStruc, *string.Character)
-    If MapSize(*regExEngine\dfaStatesPool(0)\symbols())
+    If ArraySize(*regExEngine\dfaStatesPool())
       ProcedureReturn DfaMatch(*regExEngine, *string)
     Else
       ProcedureReturn NfaMatch(*regExEngine, *string)

examples/Debug_DFA_table.pb

@@ -3,7 +3,7 @@ IncludePath ".."
 IncludeFile "RegExEngine.pbi"
 
 Define.RegEx::RegExEngineStruc *regEx
-Define sizeOfArray, i
+Define sizeOfArray, i, i2
 Define hex$
 
 *regEx = RegEx::Create("ab*")
@@ -17,19 +17,21 @@ RegEx::CreateDfa(*regEx)
 Debug "| State               | Symbol | Next state          |"
 Debug "| =================== | ====== | =================== |"
 sizeOfArray = ArraySize(*regEx\dfaStatesPool())
-For i = 0 To sizeOfArray
+For i = 1 To sizeOfArray
   If *regEx\dfaStatesPool(i)\isFinalState
     Debug "| " + LSet(Str(i) + " (final)", 19) + " | " + Space(6) + " | " +
           Space(19) + " |"
   Else
     Debug "| " + LSet(Str(i), 19) + " | " + Space(6) + " | " + Space(19) + " |"
   EndIf
 
-  ForEach *regEx\dfaStatesPool(i)\symbols()
-    hex$ = RSet(Hex(Asc(MapKey(*regEx\dfaStatesPool(i)\symbols()))), 2, "0")
-    Debug "| " + Space(19) +
-          " | " + LSet(hex$, 6) +
-          " | " + LSet(Str(*regEx\dfaStatesPool(i)\symbols()), 19) + " |"
+  For i2 = 0 To 255
+    If *regEx\dfaStatesPool(i)\symbols[i2] <> RegEx::#State_DfaDeadState
+      hex$ = RSet(Hex(i2), 2, "0")
+      Debug "| " + Space(19) +
+            " | " + LSet(hex$, 6) +
+            " | " + LSet(Str(*regEx\dfaStatesPool(i)\symbols[i2]), 19) + " |"
+    EndIf
   Next
   Debug "| ------------------- | ------ | ------------------- |"
 Next