// -----------------------------------------------------------------------------------------------------------------------------------------------
func (dfa *DFA_PoolType) GetDFAName(StateSet []int) int {
A := dfa.GetDFA()
StateSet = com.USortIntSlice(StateSet) // Make set unique
dfa.Pool[A].StateSet = StateSet
dfa.Pool[A].StateName = com.NameOf(StateSet)
dfa.Pool[A].Visited = false
return A
}
// -----------------------------------------------------------------------------------------------------------------------------------------------
func (dfa *DFA_PoolType) HaveStateAlready(inputSet []int) (loc int) {
// fmt.Printf("HaveStateAlready: >>>>>>>>>>>>>>>>>>>>>>> 0 inputSet: %s\n", com.SVar(inputSet))
inputSet = com.USortIntSlice(inputSet) // Make set unique
// fmt.Printf("HaveStateAlready: >>>>>>>>>>>>>>>>>>>>>>> 1 inputSet: %s\n", com.SVar(inputSet))
s := com.NameOf(inputSet)
// fmt.Printf("HaveStateAlready: >>>>>>>>>>>>>>>>>>>>>>> Name searcing for is: %s\n", s)
for ii, vv := range dfa.Pool {
// if ii >= dfa.Cur || ii >= dfa.Top {
// fmt.Printf(" Reached break\n")
// break
// }
if vv.IsUsed {
// fmt.Printf(" ****** Checking for match between dfa.Pool[%d].StateName ->%s<- and ->%s<-\n", ii, vv.StateName, s)
if vv.StateName == s {
// fmt.Printf(" Match found at %d\n", ii)
return ii
}
}
}
// fmt.Printf(" no Match found, returing -1\n")
return -1
}
func (dfa *DFA_PoolType) ConvNDA_to_DFA(nn *nfa.NFA_PoolType) {
StartState := nn.InitState
dfa.NoneVisited()
nn.Sigma = nn.GenerateSigma()
dfa.Sigma = nn.Sigma
com.DbPrintf("dfa2", "Sigma at top ->%s<-\n", dfa.Sigma)
// Build initial state
dfa_set := nn.LambdaClosure([]int{StartState}) // Find all the lambda closures from specified state
dfa_set = append(dfa_set, StartState) // Add in initial state
dfa_set = com.USortIntSlice(dfa_set) // Make set unique
com.DbPrintf("db_DFAGen", "\nStart: %s, \u03a3 =->%s<-, %s\n", com.SVar(dfa_set), dfa.Sigma, com.LF())
A := dfa.GetDFAName(dfa_set)
if r, is, info, Is0Ch := nn.IsTerminalState(dfa_set); is {
dfa.Pool[A].Rv = r
dfa.Pool[A].Is0Ch = Is0Ch
dfa.Pool[A].Info = info
} else {
dfa.Pool[A].Info = info
}
if com.DbOn("db_DFAGen") {
dfa.DumpPool(false)
}
// Look at all the locaitons we can get to from this "state"
for _, S := range dfa.Sigma {
StateSet := nn.LambdaClosureSet(dfa_set, string(S))
com.DbPrintf("db_DFAGen", "FOR INITIAL state ->%s<- StateSet=%s, %s\n", string(S), com.SVar(StateSet), com.LF())
if len(StateSet) > 0 {
com.DbPrintf("db_DFAGen", "Have a non-empty result, %s\n", com.LF())
com.DbPrintf("db_DFAGen", "<><><> this is the point where we should check to see if 'S' is DOT or NCCL, %s\n", com.LF())
StateSetT := nn.LambdaClosure(StateSet) // need to lambda complete the state set
StateSet = append(StateSet, StateSetT...)
StateSet = com.USortIntSlice(StateSet) // Make set unique
com.DbPrintf("db_DFAGen", " Output Is %s, %s\n", com.SVar(StateSet), com.LF())
B := 0
if t := dfa.HaveStateAlready(StateSet); t != -1 { // Have Already
B = t
com.DbPrintf("db_DFAGen", " Already have this state at location %d, %s\n", t, com.LF())
} else {
B = dfa.GetDFAName(StateSet)
com.DbPrintf("db_DFAGen", " *** New state %d, %s\n", B, com.LF())
}
dfa.AddEdge(A, B, string(S))
com.DbPrintf("db_DFAGen", " *** Before (top) %s\n", com.LF())
if r, is, info, Is0Ch := nn.IsTerminalState(StateSet); is {
dfa.Pool[B].Rv = r
dfa.Pool[B].Is0Ch = Is0Ch
dfa.Pool[B].Info = info
com.DbPrintf("db_DFAGen", " *** New state %d, %s\n", B, com.LF())
} else if _, is, info, Is0Ch := nn.IsNonTerminalPushPopState(StateSet); is {
dfa.Pool[B].Is0Ch = Is0Ch
dfa.Pool[B].Info = info
com.DbPrintf("db_DFAGen", " *** New info for state %d, %s\n", B, com.LF())
} else {
dfa.Pool[B].Info = info
com.DbPrintf("db_DFAGen", " *** NO State Info for state %d, %s\n", B, com.LF())
}
com.DbPrintf("db_DFAGen", " *** After (top) %s\n", com.LF())
if com.DbOn("db_DFAGen") {
fmt.Printf("for %s StateSet=%s, A=%d, B=%s %s\n", string(S), com.SVar(StateSet), A, com.SVar(B), com.LF())
dfa.DumpPool(false)
}
}
}
dfa.Pool[A].Visited = true
com.DbPrintf("db_DFAGen", "\nBefore Main Loop, %s\n", com.LF())
limit := 0
for stateToDo := dfa.FindNotVisited(); stateToDo != -1; stateToDo = dfa.FindNotVisited() {
com.DbPrintf("db_DFAGen", "\nMain Loop: !!TOP!! State:%d\n", stateToDo)
// -----------------------------------------------------------------------------------------------------------
if !dfa.Pool[stateToDo].Visited {
dfa_set := nn.LambdaClosure(dfa.Pool[stateToDo].StateSet) // Find all the lambda closures from specified state
dfa_set = append(dfa_set, dfa.Pool[stateToDo].StateSet...) // Add in initial state
dfa_set = com.USortIntSlice(dfa_set) // Make set unique
for _, S := range dfa.Sigma {
StateSet := nn.LambdaClosureSet(dfa_set, string(S))
com.DbPrintf("db_DFAGen", " for initial state %s StateSet=%s, %s\n", string(S), com.SVar(StateSet), com.LF())
com.DbPrintf("db_DFAGen", "<><><> this is the point where we should check to see if 'S' is DOT or NCCL, %s\n", com.LF())
if len(StateSet) > 0 {
com.DbPrintf("db_DFAGen", " >>> Have a non-empty result, Input Is %s, %s\n", com.SVar(StateSet), com.LF())
StateSetT := nn.LambdaClosure(StateSet) // need to lambda complete the state set
StateSet = append(StateSet, StateSetT...)
StateSet = com.USortIntSlice(StateSet) // Make set unique
com.DbPrintf("db_DFAGen", " >>> Output Is %s, %s\n", com.SVar(StateSet), com.LF())
B := 0
if t := dfa.HaveStateAlready(StateSet); t != -1 { // Have Already
B = t
com.DbPrintf("db_DFAGen", " Already have this state at location %d, %s\n", t, com.LF())
} else {
B = dfa.GetDFAName(StateSet)
}
dfa.AddEdge(stateToDo, B, string(S))
com.DbPrintf("db_DFAGen", " *** Before %s\n", com.LF())
if r, is, info, Is0Ch := nn.IsTerminalState(StateSet); is {
dfa.Pool[B].Rv = r
dfa.Pool[B].Is0Ch = Is0Ch
dfa.Pool[B].Info = info
com.DbPrintf("db_DFAGen", " *** New state %d, %s\n", B, com.LF())
} else if _, is, info, Is0Ch := nn.IsNonTerminalPushPopState(StateSet); is {
dfa.Pool[B].Is0Ch = Is0Ch
dfa.Pool[B].Info = info
com.DbPrintf("db_DFAGen", " *** New info for state %d, %s\n", B, com.LF())
} else {
com.DbPrintf("db_DFAGen", " *** NO State Info for state %d, %s\n", B, com.LF())
dfa.Pool[B].Info = info
}
com.DbPrintf("db_DFAGen", " *** After %s\n", com.LF())
if com.DbOn("db_DFAGen") {
fmt.Printf(" Add New Edge on %s fr %d to %d, %s\n", string(S), stateToDo, B, com.LF())
fmt.Printf(" for %s StateSet=%s, A(stateToDo)=%d, %s\n", string(S), com.SVar(StateSet), stateToDo, com.LF())
dfa.DumpPool(false)
}
}
}
}
// -----------------------------------------------------------------------------------------------------------
dfa.Pool[stateToDo].Visited = true
limit++
if limit > 50000 {
break
}
}
dfa.VerifyMachine()
}