Exemplo n.º 1
0
        /*
         * Function: in_dstates
         */
        private static int in_dstates(Spec s, Bunch bunch)
        {
            Dfa dfa;

#if OLD_DEBUG
            Console.Write("Looking for set : ");
            Print_Set(bunch.GetNFASet());
            bunch.dump();
#endif

            if (s.dfa_sets.TryGetValue(bunch.GetNFABit(), out dfa))
            {
#if OLD_DUMP_DEBUG
                Console.WriteLine(" FOUND!");
#endif
                return(dfa.GetLabel());
            }

#if OLD_DUMP_DEBUG
            Console.WriteLine(" NOT FOUND!");
#endif
            return(NOT_IN_DSTATES);
        }
Exemplo n.º 2
0
        /*
         * 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();
            States();
            Helpers();
            Driver();
            Footer();

            outstream.Flush();
            reset();
        }
Exemplo n.º 3
0
        /*
         * 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 List <Nfa>(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 #" + 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());
        }
Exemplo n.º 4
0
 /*
  * Function: reset
  * Description: Clears member variables.
  */
 private void reset()
 {
     spec      = null;
     outstream = null;
 }
Exemplo n.º 5
0
 /*
  * Function: reset
  * Description: Resets member variables.
  */
 private void reset()
 {
     spec    = null;
     group   = null;
     ingroup = null;
 }
Exemplo n.º 6
0
        /*
         * 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();
            Dictionary <int, int> h = new Dictionary <int, int>();

            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;
        }
Exemplo n.º 7
0
        /*
         * 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();

            /* 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(Properties.Settings.Default.MaxStr);
                    sb1.Append("Current count = " + s.dtrans_list.Count + "\n");
                    for (int i1 = 0; i1 < dt.GetDTransLength(); i1++)
                    {
                        sb1.Append(dt.GetDTrans(i1) + ",");
                    }
                    sb1.Append("end\n");
                    Console.Write(sb1.ToString());
#endif
                    s.dtrans_list.Add(dt);
                }
            }
            Console.WriteLine("");
        }
Exemplo n.º 8
0
 /*
  * 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;
 }