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:')