Subversion Repositories programming

    def __unique_sort(self, li):

        """Make sure everything in a list is unique, and then sort it"""

        newlist = []

        for i in li:

            if i not in newlist:

                newlist.append(i)

        newlist.sort()

        return newlist

    def __generate_dfa_table(self):

        # get the list of all letters

        possible_letters = []

        for (state, letter) in self.trans_func.keys():

            if letter not in possible_letters:

                possible_letters.append(letter)

        # DFA_TABLE STRUCTURE

        #

        # [ [Final, DFA_State_Number, [States_in_NFA], letter_1, letter_2, ..., letter_n]

        #   [Final, DFA_State_Number, [States_in_NFA], letter_1, letter_2, ..., letter_n]

        #   [Final, DFA_State_Number, [States_in_NFA], letter_1, letter_2, ..., letter_n] ]

        #

        dfa_table = []

        # find the first state's definition

        def_in_nfa = self.__E(0)

        is_final = False

        temp_record = []

        # find out if we're final

        for i in def_in_nfa:

            if i in self.final_states:

                is_final = True

                break

        temp_record.append(is_final)

        temp_record.append(len(dfa_table))

        temp_record.append(def_in_nfa)

        # find out where we can go by each letter

        for l in possible_letters:

            where_to_go = []

            for s in def_in_nfa:

                where_to_go.extend(self.__next_states(s, l))

            where_to_go = self.__unique_sort(where_to_go)

            create_new_state = True

            for s in dfa_table:

                if s[2] == where_to_go:

                    temp_record.append(s[1])

                    create_new_state = False

                    break

            if create_new_state:

                # recurse???

                pass

################################################################################

# NEW STUFF IS AFTER THIS

################################################################################

        temp_record = [None for n in range(len(possible_letters) + 3)]

        # start at initial state

        # generate E(initial_state)

        # find out if we are a final state (based on E() )

        # name the state (starting at 0)

        #