public void min_dfa(Spec s) { this.set(s); this.minimize(); this.reduce(); this.reset(); }
public DTrans(Spec s, Dfa dfa) { this.dtrans = new int[s.dtrans_ncols]; this.label = s.dtrans_list.Count; this.accept = dfa.GetAccept(); this.anchor = dfa.GetAnchor(); }
public static Nfa NewNfa(Spec spec) { Nfa nfa = new Nfa(); spec.nfa_states.Add(nfa); nfa.Edge = ''; return nfa; }
private static int in_dstates(Spec s, Bunch bunch) { Dfa dfa; if (!s.dfa_sets.TryGetValue(bunch.GetNFABit(), out dfa)) { return -1; } return dfa.Label; }
private static int add_to_dstates(Spec s, Bunch bunch) { Dfa dfa = Alloc.NewDfa(s); dfa.SetNFASet(new List<Nfa>(bunch.GetNFASet())); dfa.SetNFABit(new BitSet(bunch.GetNFABit())); dfa.SetAccept(bunch.GetAccept()); dfa.SetAnchor(bunch.GetAnchor()); dfa.ClearMarked(); s.dfa_sets[dfa.GetNFABit()] = dfa; return dfa.Label; }
private static void computeClasses(Spec spec) { SimplifyNfa.original_charset_size = spec.dtrans_ncols; SimplifyNfa.ccls = new char[SimplifyNfa.original_charset_size]; char c = '\u0001'; BitSet bitSet = new BitSet(); BitSet bitSet2 = new BitSet(); Dictionary<char, char> dictionary = new Dictionary<char, char>(); Console.WriteLine("Working on character classes."); for (int i = 0; i < spec.nfa_states.Count; i++) { Nfa nfa = spec.nfa_states[i]; if (nfa.Edge != '�' && nfa.Edge != '') { bitSet.ClearAll(); bitSet2.ClearAll(); for (int j = 0; j < SimplifyNfa.ccls.Length; j++) { if ((int)nfa.Edge == j || (nfa.Edge == '' && nfa.GetCharSet().contains(j))) { bitSet.Set((int)SimplifyNfa.ccls[j], true); } else { bitSet2.Set((int)SimplifyNfa.ccls[j], true); } } bitSet.And(bitSet2); if (bitSet.GetLength() != 0) { dictionary.Clear(); for (int k = 0; k < SimplifyNfa.ccls.Length; k++) { if (bitSet.Get((int)SimplifyNfa.ccls[k]) && ((int)nfa.Edge == k || (nfa.Edge == '' && nfa.GetCharSet().contains(k)))) { char c2 = SimplifyNfa.ccls[k]; if (!dictionary.ContainsKey(c2)) { Dictionary<char, char> arg_14F_0 = dictionary; char arg_14F_1 = c2; char expr_14A = c; c = (char)(expr_14A + '\u0001'); arg_14F_0.Add(arg_14F_1, expr_14A); } SimplifyNfa.ccls[k] = dictionary[c2]; } } } } } SimplifyNfa.mapped_charset_size = (int)c; }
private static void make_dtrans(Spec s) { Console.WriteLine("Working on DFA states."); s.InitUnmarkedDFA(); int num = s.state_rules.Length; s.state_dtrans = new int[num]; for (int i = 0; i < num; i++) { Bunch bunch = new Bunch(s.state_rules[i]); bunch.e_closure(); Nfa2Dfa.add_to_dstates(s, bunch); s.state_dtrans[i] = s.dtrans_list.Count; Dfa nextUnmarkedDFA; while ((nextUnmarkedDFA = s.GetNextUnmarkedDFA()) != null) { nextUnmarkedDFA.SetMarked(); DTrans dTrans = new DTrans(s, nextUnmarkedDFA); for (int j = 0; j < s.dtrans_ncols; j++) { bunch.move(nextUnmarkedDFA, j); if (!bunch.IsEmpty()) { bunch.e_closure(); } int num2; if (bunch.IsEmpty()) { num2 = -1; } else { num2 = Nfa2Dfa.in_dstates(s, bunch); if (num2 == -1) { num2 = Nfa2Dfa.add_to_dstates(s, bunch); } } dTrans.SetDTrans(j, num2); } s.dtrans_list.Add(dTrans); } } Console.WriteLine(""); }
/* * Function: Write * Description: High-level access function to module. */ public void Write(Spec spec, StreamWriter o) { set(spec, o); #if DEBUG Utility.assert(null != spec); Utility.assert(null != o); #endif #if OLD_DEBUG print_details(); #endif Header(); Construct(); Helpers(); Driver(); Footer(); reset(); }
internal static void simplify(Spec spec) { SimplifyNfa.computeClasses(spec); for (int i = 0; i < spec.nfa_states.Count; i++) { Nfa nfa = spec.nfa_states[i]; if (nfa.Edge != '�' && nfa.Edge != '') { if (nfa.Edge == '') { CharSet charSet = new CharSet(); charSet.map(nfa.GetCharSet(), SimplifyNfa.ccls); nfa.SetCharSet(charSet); } else { nfa.Edge = SimplifyNfa.ccls[(int)nfa.Edge]; } } } spec.ccls_map = SimplifyNfa.ccls; spec.dtrans_ncols = SimplifyNfa.mapped_charset_size; }
public static NfaPair NewNLPair(Spec spec) { NfaPair nfaPair = Alloc.NewNfaPair(); nfaPair.end = Alloc.NewNfa(spec); nfaPair.start = Alloc.NewNfa(spec); Nfa start = nfaPair.start; start.Next = Alloc.NewNfa(spec); Nfa next = start.Next; next.Edge = ''; next.SetCharSet(new CharSet()); next.GetCharSet().add(10); next.Next = nfaPair.end; start.Sibling = Alloc.NewNfa(spec); Nfa sibling = start.Sibling; sibling.Edge = '\r'; sibling.Next = Alloc.NewNfa(spec); Nfa next2 = sibling.Next; next2.Next = null; next2.Sibling = Alloc.NewNfa(spec); next2.Sibling.Edge = '\n'; next2.Sibling.Next = nfaPair.end; return nfaPair; }
/* * function: add_to_dstates * Description: Takes as input a CBunch with details of * a dfa state that needs to be created. * 1) Allocates a new dfa state and saves it in the appropriate Spec list * 2) Initializes the fields of the dfa state with the information in the CBunch. * 3) Returns index of new dfa. */ private static int add_to_dstates(Spec s, Bunch bunch) { Dfa dfa; #if DEBUG Utility.assert(null != bunch.GetNFASet()); Utility.assert(null != bunch.GetNFABit()); Utility.assert(null != bunch.GetAccept() || Spec.NONE == bunch.GetAnchor()); #endif /* Allocate, passing Spec so dfa label can be set. */ dfa = Alloc.NewDfa(s); /* Initialize fields, including the mark field. */ dfa.SetNFASet(new ArrayList(bunch.GetNFASet())); dfa.SetNFABit(new BitSet(bunch.GetNFABit())); dfa.SetAccept(bunch.GetAccept()); dfa.SetAnchor(bunch.GetAnchor()); dfa.ClearMarked(); #if OLD_DUMP_DEBUG Console.WriteLine("[Created new dfa_state #" + Int32.ToString(dfa.GetLabel()) + "]"); dfa.dump(); #endif /* Register dfa state using BitSet in spec Hashtable. */ s.dfa_sets[dfa.GetNFABit()] = dfa; #if OLD_DUMP_DEBUG Console.Write("Registering set : "); Print_Set(dfa.GetNFASet()); Console.WriteLine(""); #endif return(dfa.GetLabel()); }
public static void CreateMachine(Gen cmg, Spec cms, Input cmi) { MakeNfa.spec = cms; MakeNfa.gen = cmg; MakeNfa.input = cmi; MakeNfa.spec.AddInitialState(); int count = MakeNfa.spec.States.Count; MakeNfa.spec.state_rules = new List<Nfa>[count]; for (int i = 0; i < count; i++) { MakeNfa.spec.state_rules[i] = new List<Nfa>(); } MakeNfa.spec.nfa_start = MakeNfa.machine(); count = MakeNfa.spec.nfa_states.Count; for (int i = 0; i < count; i++) { Nfa nfa = MakeNfa.spec.nfa_states[i]; nfa.Label = i; } if (MakeNfa.spec.verbose) { Console.WriteLine("NFA comprised of " + (MakeNfa.spec.nfa_states.Count + 1) + " states."); } }
public static void MakeDFA(Spec s) { Nfa2Dfa.make_dtrans(s); Nfa2Dfa.free_nfa_states(s); Nfa2Dfa.free_dfa_states(s); }
private static void free_nfa_states(Spec s) { s.nfa_states = null; s.nfa_start = null; s.state_rules = null; }
/* * Compute minimum set of character classes needed to disambiguate * edges. We optimistically assume that every character belongs to * a single character class, and then incrementally split classes * as we see edges that require discrimination between characters in * the class. */ static private void computeClasses(Spec spec) { original_charset_size = spec.dtrans_ncols; ccls = new int[original_charset_size]; // initially all zero. int nextcls = 1; BitSet clsA = new BitSet(); BitSet clsB = new BitSet(); Hashtable h = new Hashtable(); Console.WriteLine("Working on character classes."); for (int index = 0; index < spec.nfa_states.Count; index++) { Nfa nfa = (Nfa)spec.nfa_states[index]; if (nfa.GetEdge() == Nfa.EMPTY || nfa.GetEdge() == Nfa.EPSILON) { continue; // no discriminatory information. } clsA.ClearAll(); clsB.ClearAll(); for (int i = 0; i < ccls.Length; i++) { if (nfa.GetEdge() == i || // edge labeled with a character nfa.GetEdge() == Nfa.CCL && nfa.GetCharSet().contains(i)) // set of characters { clsA.Set(ccls[i], true); } else { clsB.Set(ccls[i], true); } } /* * now figure out which character classes we need to split. */ clsA.And(clsB); // split the classes which show up on both sides of edge if (clsA.GetLength() == 0) { Console.Write("."); continue; } Console.Write(":"); /* * and split them. */ h.Clear(); // h will map old to new class name for (int i = 0; i < ccls.Length; i++) { if (clsA.Get(ccls[i])) // a split class { if (nfa.GetEdge() == i || nfa.GetEdge() == Nfa.CCL && nfa.GetCharSet().contains(i)) { // on A side int split = ccls[i]; if (!h.ContainsKey(split)) { h.Add(split, nextcls++); // make new class #if DEBUG Console.WriteLine("Adding char " + (nextcls - 1) + " split=" + split + " i=" + i); #endif } ccls[i] = (int)h[split]; } } } } Console.WriteLine(); Console.WriteLine("NFA has " + nextcls + " distinct character classes."); mapped_charset_size = nextcls; }
/* * Function: reset * Description: Clears member variables. */ private void reset() { spec = null; outstream = null; }
public static void Allocate_BOL_EOF(Spec s) { s.BOL = (char)s.dtrans_ncols++; s.EOF = (char)s.dtrans_ncols++; }
private void reset() { this.spec = null; this.group = null; this.ingroup = null; }
private void set(Spec s) { this.spec = s; this.group = null; this.ingroup = null; }
private void reset() { this.spec = null; this.outstream = null; }
private void set(Spec spec, IndentedTextWriter outstream, string inputFilePath) { this.spec = spec; this.outstream = outstream; this.inputFilePath = inputFilePath; }
public Gen(string filename, string outfile, int version) { this.init_flag = false; this.inputFilePath = Path.GetFullPath(filename); this.instream = File.OpenText(this.inputFilePath); this.outstream = new IndentedTextWriter(File.CreateText(outfile), "\t"); this.outstream.Indent = 2; this.ibuf = new Input(this.instream); this.spec = new Spec(); this.spec.Version = version; this.nfa2dfa = new Nfa2Dfa(); this.minimize = new Minimize(); this.makeNfa = new MakeNfa(); this.emit = new Emit(); this.init_flag = true; }
public static Dfa NewDfa(Spec spec) { Dfa dfa = new Dfa(spec.dfa_states.Count); spec.dfa_states.Add(dfa); return dfa; }
/* * Function: free_dfa_states */ //private void free_dfa_states() private static void free_dfa_states(Spec s) { s.dfa_states = null; s.dfa_sets = null; }
public void Write(Spec spec, IndentedTextWriter o, string inputFilePath) { this.set(spec, o, inputFilePath); this.Header(); this.Construct(); this.Helpers(); this.Driver(); this.Footer(); this.reset(); }
/* * Function: make_dtrans * Description: Creates uncompressed CDTrans transition table. */ //private void make_dtrans() private static void make_dtrans(Spec s) { Dfa dfa; int nextstate; Console.WriteLine("Working on DFA states."); /* Reference passing type and initializations. */ s.InitUnmarkedDFA(); Console.WriteLine("done init"); /* Allocate mapping array. */ int nstates = s.state_rules.Length; s.state_dtrans = new int[nstates]; for (int istate = 0; istate < nstates; istate++) { /* Create start state and initialize fields. */ Bunch bunch = new Bunch(s.state_rules[istate]); bunch.e_closure(); add_to_dstates(s, bunch); s.state_dtrans[istate] = s.dtrans_list.Count; /* Main loop of DTrans creation. */ while (null != (dfa = s.GetNextUnmarkedDFA())) { Console.Write("."); #if DEBUG Utility.assert(!dfa.IsMarked()); #endif /* Get first unmarked node, then mark it. */ dfa.SetMarked(); /* Allocate new DTrans, then initialize fields. */ DTrans dt = new DTrans(s, dfa); /* Set dt array for each character transition. */ for (int i = 0; i < s.dtrans_ncols; i++) { /* Create new dfa set by attempting character transition. */ bunch.move(dfa, i); if (!bunch.IsEmpty()) { bunch.e_closure(); } #if DEBUG Utility.assert((null == bunch.GetNFASet() && null == bunch.GetNFABit()) || (null != bunch.GetNFASet() && null != bunch.GetNFABit())); #endif /* Create new state or set state to empty. */ if (bunch.IsEmpty()) { nextstate = DTrans.F; } else { nextstate = in_dstates(s, bunch); if (nextstate == NOT_IN_DSTATES) { nextstate = add_to_dstates(s, bunch); } } #if DEBUG Utility.assert(nextstate < s.dfa_states.Count); #endif dt.SetDTrans(i, nextstate); } #if DEBUG Utility.assert(s.dtrans_list.Count == dfa.GetLabel()); #endif #if DEBUG StringBuilder sb1 = new StringBuilder(Lex.MAXSTR); sb1.Append("Current count = " + s.dtrans_list.Count.ToString() + "\n"); for (int i1 = 0; i1 < dt.GetDTransLength(); i1++) { sb1.Append(dt.GetDTrans(i1).ToString() + ","); } sb1.Append("end\n"); Console.Write(sb1.ToString()); #endif s.dtrans_list.Add(dt); } } Console.WriteLine(""); }
/* * Function: reset * Description: Resets member variables. */ private void reset() { spec = null; group = null; ingroup = null; }
private static void free_dfa_states(Spec s) { s.dfa_states = null; s.dfa_sets = null; }