def load(self, file_path): # Remove last three characters of the file_path path = file_path[:-3] # Adding cfg to end of file path path = path + 'cfg' self.max_trans = parse_file(path, 'MAXIMUM_TRANSITIONS=', 'MAXIMUM_CHARACTERS=') self.max_char = parse_file(path, 'MAXIMUM_CHARACTERS=', '') # If the max transition could not be found set to default if self.max_trans == 'Error' or self.max_trans == []: self.max_trans = [1] # If the max characters could not be found set to default if self.max_char == 'Error' or self.max_char == []: self.max_char = [32] # If the max transition is not a digit set to default if self.max_trans[0].isdigit() == False: self.max_trans = [1] # If the max character is not a digit set to default if self.max_char[0].isdigit() == False: self.max_char = [32]
def load(self, path): file_path = path description = parse_file(path, '', 'STATES:') self.States.load(path) self.Input_Alpha.load(path) self.Stack_Alpha.load(path) self.initial_state = parse_file(path, 'INITIAL_STATE:', 'START_CHARACTER:') self.start_character = parse_file(path, 'START_CHARACTER:', 'FINAL_STATES:') self.current_state = self.initial_state[0] self.stack = self.start_character[0] self.transitions_list = [] self.next_symbol = self.stack self.Final_States.load(path)
def load(self, file_path): self.states = parse_file(file_path, 'STATES:', 'INPUT_ALPHABET:')
def file_is_valid(self, file_path): self.Input_Alpha = Input_Alphabet() self.Input_Alpha.load(file_path) self.Stack_Alpha = Stack_Alphabet() self.Stack_Alpha.load(file_path) self.States = States() self.States.load(file_path) self.Final_States = Final_States() self.Final_States.load(file_path) self.transitions = parse_file(file_path, 'TRANSITION_FUNCTION:', 'INITIAL_STATE:') self.initial_state = parse_file(file_path, 'INITIAL_STATE:', 'START_CHARACTER:') self.start_character = parse_file(file_path, 'START_CHARACTER:', 'FINAL_STATES:') ### CHECK STATES KEYWORD CONTENT ### # Check if each element of STATES is not in INPUT ALPHABET, STACK ALPHABET, # or is the reserved character \ if not self.States.states: self.def_valid = False self.error_list.append('NO STATES FOUND!\n') for state in self.States.states: for letter in state: if (letter == '\\' or letter == '[' or letter == ']'): self.def_valid = False self.error_list.append('In STATES: ' + state + ' contains reserved character\n') elif (self.Input_Alpha.is_element(letter) == True): self.def_valid = False self.error_list.append( 'In STATES: ' + state + ' cannot contain INPUT_ALPHABET characters\n') elif (self.Stack_Alpha.is_element(letter) == True): self.def_valid = False self.error_list.append( 'In STATES: ' + state + ' cannot contain STACK_ALPHABET characters\n') ### CHECK INPUT ALPHABET KEYWORD CONTENT ### # Check if each element of INPUT_ALPHABET is not the reserved character \, [ or ] self.seen = [] if not self.Input_Alpha.alphabet: self.def_valid = False self.error_list.append('NO INPUT ALPHABET CHARACTERS FOUND!\n') for alphabet in self.Input_Alpha.alphabet: for letter in alphabet: if (letter not in self.seen): self.seen.append(letter) else: self.def_valid = False self.error_list.append('In INPUT_ALPHABET: ' + letter + ' is specified twice\n') if (letter == '\\' or letter == '[' or letter == ']'): self.def_valid = False self.error_list.append('In INPUT_ALPHABET: ' + letter + ' contains reserved character\n') #elif (self.Stack_Alpha.is_element(letter) == True): # self.def_valid = False # self.error_list.append('In INPUT_ALPHABET: ' + letter + ' cannot be in both STACK_ALPHABET and INPUT_ALPHABET\n') ### CHECK STACK ALPHABET KEYWORD CONTENT ### # Check if each element of STACK_ALPHABET is not the reserved character \, [ or ] self.seen = [] if not self.Stack_Alpha.stack_alphabet: self.def_valid = False self.error_list.append('NO STACK ALPHABET CHARACTERS FOUND!\n') for alphabet in self.Stack_Alpha.stack_alphabet: for letter in alphabet: if (letter not in self.seen): self.seen.append(letter) else: self.def_valid = False self.error_list.append('In STACK_ALPHABET: ' + letter + ' is specified twice\n') if (letter == '\\' or letter == '[' or letter == ']'): self.def_valid = False self.error_list.append('In STACK_ALPHABET: ' + letter + ' contains reserved character\n') #elif (self.Input_Alpha.is_element(letter) == True): # self.def_valid = False # self.error_list.append('In STACK_ALPHABET: ' + letter + ' cannot be in both INPUT_ALPHABET and STACK_ALPHABET\n') ### CHECK TRANSITION FUNCTION KEYWORD CONTENT ### # Check if the transitions is not empty if not self.transitions: self.def_valid = False self.error_list.append('NO TRANSITIONS FOUND!\n') # While the transition list is not empty while (len(self.transitions) > 0): # Get a transition transition = self.transitions[0:5] # Delete the transition extracted from the transitions list del self.transitions[0:5] ### CHECK SOURCE STATE ### # Check if the source state is a valid state if (self.States.is_element(transition[0]) == False): self.def_valid = False self.error_list.append('In Transition: \n' + ' '.join(transition) + ' \n' + transition[0] + ' is not a valid source state\n') # Check if each element of source state is not in INPUT ALPHABET, STACK ALPHABET, # or is the reserved characters else: for letter in transition[0]: if (letter == '\\' or letter == '[' or letter == ']'): self.def_valid = False self.error_list.append( 'In Transition: \n' + ' '.join(transition) + ' \n' + transition[0] + ' cannot contain reserved character\n') elif (self.Input_Alpha.is_element(letter) == True): self.def_valid = False self.error_list.append( 'In Transition: \n' + ' '.join(transition) + ' \n' + transition[0] + ' cannot contain INPUT_ALPHABET characters\n') elif (self.Stack_Alpha.is_element(letter) == True): self.def_valid = False self.error_list.append( 'In Transition: \n' + ' '.join(transition) + ' \n' + transition[0] + ' cannot contain STACK_ALPHABET characters\n') ### CHECK READ CHARACTER ### # Check if the read character is a valid input alphabet if (len(transition[1]) != 1): self.def_valid = False self.error_list.append('In Transition: \n' + ' '.join(transition) + ' \n' + transition[1] + ' is not a valid read character\n') elif (self.Input_Alpha.is_element(transition[1]) == False): if (transition[1] == '\\'): # Reserved character \ is allowed in a transition # The pass needs to stay DO NOT DELETE IT pass elif (transition[1] == '[' or transition[1] == ']'): self.def_valid = False self.error_list.append( 'In Transition: \n' + ' '.join(transition) + ' \n' + transition[1] + ' cannot contain reserved character\n') else: self.def_valid = False self.error_list.append('In Transition: \n' + ' '.join(transition) + ' \n' + transition[1] + ' is not a valid read character\n') ### CHECK TOP OF STACK CHARACTER ### # Check if the top of stack character is a valid stack character if (len(transition[2]) != 1): self.def_valid = False self.error_list.append( 'In Transition: \n' + ' '.join(transition) + ' \n' + transition[2] + ' is not a valid top of stack character\n') elif (transition[2] == '\\' or letter == '[' or letter == ']'): self.def_valid = False self.error_list.append('In Transition: \n' + ' '.join(transition) + ' \n' + transition[2] + ' cannot contain reserved character\n') elif (self.Stack_Alpha.is_element(transition[2]) == False): self.def_valid = False self.error_list.append( 'In Transition: \n' + ' '.join(transition) + ' \n' + transition[2] + ' is not a valid top of stack character\n') ### CHECK DESTINATION STATE ### # Check if the destination state is a valid state if (self.States.is_element(transition[3]) == False): self.def_valid = False self.error_list.append('In Transition: \n' + ' '.join(transition) + ' \n' + transition[3] + ' is not a valid destination state\n') else: for letter in transition[3]: if (letter == '\\' or letter == '[' or letter == ']'): self.def_valid = False self.error_list.append( 'In Transition: \n' + ' '.join(transition) + ' \n' + transition[3] + ' cannot contain reserved character\n') elif (self.Input_Alpha.is_element(letter) == True): self.def_valid = False self.error_list.append( 'In Transition: \n' + ' '.join(transition) + ' \n' + transition[3] + ' cannot contain INPUT_ALPHABET characters\n') elif (self.Stack_Alpha.is_element(letter) == True): self.def_valid = False self.error_list.append( 'In Transition: \n' + ' '.join(transition) + ' \n' + transition[3] + ' cannot contain STACK_ALPHABET characters\n') ### CHECK WRITE TO STACK CHARACTERS ### # Check if the write to stack characters are valid for letter in transition[4]: if (letter == '\\' and len(transition[4]) == 1): # Reserved character allowed in a transition # The pass needs to stay DO NOT DELETE IT pass elif (letter == '\\' and len(transition[4]) > 1): self.def_valid = False self.error_list.append('In Transition: \n' + ' '.join(transition) + ' \n' + letter + ' needs to be only character\n') elif (letter == '[' or letter == ']'): self.def_valid = False self.error_list.append( 'In Transition: \n' + ' '.join(transition) + ' \n' + letter + ' cannot contain reserved character\n') elif (self.Stack_Alpha.is_element(letter) == False): self.def_valid = False self.error_list.append( 'In Transition: \n' + ' '.join(transition) + ' \n' + letter + ' is not a valid write to stack character\n') ### CHECK INITIAL STATE KEYWORD CONTENT ### # Check if there are multiple start states if not self.initial_state: self.def_valid = False self.error_list.append('NO INITIAL STATE FOUND!\n') if (len(self.initial_state) != 1): self.def_valid = False self.error_list.append( 'In INITIAL_STATES: Only one initial state permitted\n') # Check if the start state is a element of the set of states elif (self.States.is_element(self.initial_state[0]) == False): self.def_valid = False self.error_list.append('In INITIAL_STATE: ' + self.initial_state[0] + ' is not in the set of STATES\n') # Check that the initial state does not contains INPUT_ALPHABET, STACK_ALPHABET, or reserved character else: for state in self.initial_state: for letter in state: if (letter == '\\' or letter == '[' or letter == ']'): self.def_valid = False self.error_list.append( 'In INITIAL_STATES: ' + state + ' cannot contain reserved character\n') elif (self.Input_Alpha.is_element(letter) == True): self.def_valid = False self.error_list.append( 'In INITIAL_STATES: ' + state + ' cannot contain INPUT_ALPHABET characters\n') elif (self.Stack_Alpha.is_element(letter) == True): self.def_valid = False self.error_list.append( 'In INITIAL_STATES: ' + state + ' cannot contain STACK_ALPHABET characters\n') ### CHECK START CHARACTER KEYWORD CONTENT ### # Check if there are multiple start characters if not self.start_character: self.def_valid = False self.error_list.append('NO START CHARACTER FOUND!\n') if (len(self.start_character) != 1): self.def_valid = False self.error_list.append( 'In STATE_CHARACTER: Only one start character permitted\n') # Check if the start character is a element of the set of stack characters elif (self.Stack_Alpha.is_element(self.start_character[0]) == False): self.def_valid = False self.error_list.append('In START_CHARACTER: ' + self.start_character[0] + ' is not in stack alphabet\n') # Check that the start character does not contain the INPUT_ALPHABET and reserved character else: for alphabet in self.start_character: for letter in alphabet: if (letter == '\\' or letter == '[' or letter == ']'): self.def_valid = False self.error_list.append( 'In START_CHARACTER: ' + alphabet + ' cannot contain reserved character\n') elif (self.Input_Alpha.is_element(letter) == True): self.def_valid = False self.error_list.append( 'In START_CHARACTER: ' + alphabet + ' cannot contain INPUT_ALPHABET characters\n') ### CHECK FINAL STATES KEYWORD CONTENT ### # Check if each final state is valid if not self.Final_States.final_states: self.def_valid = False self.error_list.append('NO FINAL STATES FOUND!\n') for state in self.Final_States.final_states: # Check if each final state is an element of states if (self.States.is_element(state) == False): self.def_valid = False self.error_list.append('In FINAL_STATES: ' + state + ' is not in the set of STATES\n') for letter in state: # Check for reserved character if (letter == '\\' or letter == '[' or letter == ']'): self.def_valid = False self.error_list.append( 'In FINAL_STATES: ' + state + ' cannot contain reserved character\n') # Check for input alphbet character elif (self.Input_Alpha.is_element(letter) == True): self.def_valid = False self.error_list.append( 'In FINAL_STATES: ' + state + ' cannot contain INPUT_ALPHABET characters\n') # Check for stack alphabet elif (self.Stack_Alpha.is_element(letter) == True): self.def_valid = False self.error_list.append( 'In FINAL_STATES: ' + state + ' cannot contain STACK_ALPHABET characters\n')
def load(self, file_path): self.final_states = parse_file(file_path, 'FINAL_STATES:', '')
def load(self, file_path): self.stack_alphabet = parse_file(file_path, 'STACK_ALPHABET:', 'TRANSITION_FUNCTION:')