def main(): s = input("please enter a string of a's and b's: ") strm = streamreader.StreamReader(io.StringIO(s)) q0 = state.State(0) q1 = state.State(1) q2 = state.State(2, True) #can be any value except None classes = {"a": frozenset("a"), "b": frozenset("b")} q0.setClasses(classes) q1.setClasses(classes) q2.setClasses(classes) q0.addTransition("a", 2) q0.addTransition("b", 1) q1.addTransition("a", 2) q1.addTransition("b", 1) q2.addTransition("b", 2) states = {0: q0, 1: q1, 2: q2} dfa = FiniteStateMachine(states, 0, classes) dfa.accepts(strm)
def main(): q0 = state.State(0, 1) q1 = state.State(1, 1) q2 = state.State(2, 1) q3 = state.State(3, 1) q4 = state.State(4) classes = {"a": frozenset("a"), "b": frozenset("b")} q0.addTransition("a", 1) q0.addTransition("b", 0) q1.addTransition("a", 2) q1.addTransition("b", 1) q2.addTransition("a", 3) q2.addTransition("b", 2) q3.addTransition("a", 4) q3.addTransition("b", 3) q4.addTransition("a", 4) q4.addTransition("b", 4) dfa = FiniteStateMachine({0: q0, 1: q1, 2: q2, 3: q3, 4: q4}, 0, classes) # You must complete the main function here but you can # create a stream over a string s by writing # strm = streamreader.StreamReader(io.StringIO(s)) s = raw_input("Please enter a string of a's and b's: ") # apparently I'm using python 2.7 instead of 3.x, so I need to use raw_input() instead of input() # REMEMBER TO CHANGE AFTER UPDATING PYTHON!! while s != "": strm = streamreader.StreamReader(io.StringIO(s)) print(dfa.accepts(strm)) s = raw_input("Please enter a string of a's and b's: ")
def main(): q0 = state.State(0) q1 = state.State(1,1) q2 = state.State(2) classes = {"zero":frozenset("0"), "one":frozenset("1")} q0.addTransition("zero", 0) q0.addTransition("one", 1) q1.addTransition("zero", 0) q1.addTransition("one",2) q2.addTransition("zero",2) q2.addTransition("one",1) dfa = FiniteStateMachine({0:q0, 1:q1, 2:q2}, 0, classes) done = False while not done: s = input("Please enter a string of zeros and ones: ").strip() if len(s) == 0: done = True else: strm = streamreader.StreamReader(io.StringIO(s)) if dfa.accepts(strm): print("The string is accepted by the finite state machine.") else: print("The string is not accepted.") print("Program Completed.")
def main(): q1 = state.State(1) q2 = state.State(2) q3 = state.State(3) q4 = state.State(4) q5 = state.State(5) q6 = state.State(6) q7 = state.State(7, True) q8 = state.State(8, True) q9 = state.State(9, True) q10 = state.State(10) classes = {} classes["a"] = set(["a"]) classes["b"] = set(["b"]) q1.addTransition("a", 2) q1.addTransition("b", 1) q2.addTransition("a", 3) q2.addTransition("b", 1) q3.addTransition("a", 4) q3.addTransition("b", 1) q4.addTransition("a", 5) q4.addTransition("b", 4) q5.addTransition("a", 6) q5.addTransition("b", 4) q6.addTransition("a", 7) q6.addTransition("b", 4) q7.addTransition("a", 10) q7.addTransition("b", 8) q8.addTransition("a", 9) q8.addTransition("b", 8) q9.addTransition("a", 7) q9.addTransition("b", 8) q10.addTransition("a", 10) q10.addTransition("b", 10) s = input("Please enter a string of a's and b's:") while s: dfa = FiniteStateMachine( { 1: q1, 2: q2, 3: q3, 4: q4, 5: q5, 6: q6, 7: q7, 8: q8, 9: q9, 10: q10 }, 1, classes) strm = streamreader.StreamReader(io.StringIO(s)) dfa.accepts(strm) s = input("Please enter a string of a's and b's:") print('Program Completed.')
def buildReturnValue(self, item, prodStack): # We found an item to reduce by. prodNames = { } # this is a map from return value names to locations with rhs tntCount = {} rhsVals = { } # this is a map from index location of rhs to value from the stack. # this loop builds a map from names of rhs terminals or nonterminals to # their index value for the rhs for i in range(len(item.production.rhs)): tntId = item.production.rhs[i] tnt = self.tnts[tntId] if not tnt in tntCount: tntCount[tnt] = 1 prodNames[tnt] = i prodNames[tnt + "1"] = i else: numVal = tntCount[tnt] + 1 tntCount[tnt] = numVal prodNames[tnt + str(numVal)] = i # this loop builds a map from index value of rhs location to # the actual value popped from the pda stack. for i in range(len(item.production.rhs) - 1, -1, -1): stateId, val = prodStack.pop() rhsVals[i] = val returnValue = "" rvStrm = streamreader.StreamReader( io.StringIO(item.production.returnValue)) # Here we iterate through the parts of the return value replacing any # non-terminal token with the actual value popped from the stack # used in parsing. This builds the actual return value for the expression # being parsed. token = rvStrm.getToken() while not rvStrm.eof(): if token in prodNames: returnValue += rhsVals[prodNames[token]] else: returnValue += token token = rvStrm.getToken() # Here we call the overridden eval method to evaluate # the return value string in the context of the parser's # back end module. This is because each parser instance # inherits from this class to define its own parser # and backend code. val = repr(self.eval(returnValue)) return val
def main(): while True: expression = input( "Please enter a prefix expression (or press enter to stop): ") if len(expression) < 1: return reader = streamreader.StreamReader(io.StringIO(expression)) postfix = LL1(reader) print("The postfix form is:", postfix.eval())
def main(): q0 = nfastate.NFAState(0) q1 = nfastate.NFAState(1, True) q2 = nfastate.NFAState(2) q3 = nfastate.NFAState(3) q4 = nfastate.NFAState(4, True) q5 = nfastate.NFAState(5) q6 = nfastate.NFAState(6) q7 = nfastate.NFAState(7) q8 = nfastate.NFAState(8) classes = { "a": frozenset(["a"]), "epsilon": frozenset([]) } q0.addTransition("epsilon", 1) q0.addTransition("epsilon", 4) q1.addTransition("a", 2) q2.addTransition("a", 3) q3.addTransition("a", 1) q4.addTransition("a", 5) q5.addTransition("a", 6) q6.addTransition("a", 7) q7.addTransition("a", 8) q8.addTransition("a", 4) nfa = NFAStateMachine({ 0: q0, 1: q1, 2: q2, 3: q3, 4: q4, 5: q5, 6: q6, 7: q7, 8: q8 }, 0, classes) s = input("Please enter a string of a(s) (type done to quit): ").strip() while s!="done": strm = streamreader.StreamReader(io.StringIO(s)) if nfa.accepts(strm): print("The string is accepted by the finite state machine.") else: print("The string is not accepted.") s = input("Please enter a string of a(s) (type done to quit): ").strip() print("Program Completed.")
def main(): s = input("please enter a string of 0's and 1's:") strm = streamreader.StreamReader(io.StringIO(s)) q0 = state.State(0, True) q1 = state.State(1, True) q2 = state.State(2) classes = {} classes["0"] = set(["0"]) classes["1"] = set(["1"]) q0.addTransition("0",1) q0.addTransition("1",2) q1.addTransition("0",1) q1.addTransition("1",2) q2.addTransition("0",2) q2.addTransition("1",0) q0.setClasses(classes) q1.setClasses(classes) q2.setClasses(classes) accepted = False states = {0:q0, 1:q1, 2:q2} stateId = 0 c = strm.readChar() while not strm.eof(): print(c, stateId) # process character q = states[stateId] stateId = states[stateId].onGoTo(c) #state.NoTransition? Handle this? if stateId == state.NoTransition: print("rejected") return c = strm.readChar() if states[stateId].isAccepting(): print("accepted") else: print("rejected")
def main(): q0 = state.State(0) q1 = state.State(1) q2 = state.State(2) q3 = state.State(3) q4 = state.State(4) q5 = state.State(5, True) classes = {} classes["a"] = set(["a"]) classes["b"] = set(["b"]) q0.addTransition("a", 2) q0.addTransition("b", 1) q1.addTransition("a", 1) q1.addTransition("b", 1) q2.addTransition("a", 3) q2.addTransition("b", 2) q3.addTransition("a", 4) q3.addTransition("b", 2) q4.addTransition("a", 5) q4.addTransition("b", 4) q5.addTransition("a", 5) q5.addTransition("b", 4) q0.setClasses(classes) q1.setClasses(classes) q2.setClasses(classes) states = {0: q0, 1: q1, 2: q2, 3: q3, 4: q4, 5: q5} dfa = FiniteStateMachine(states, 0, classes) while True: s = input("Please enter a string of a's and b's: ") if len(s) > 0: strm = streamreader.StreamReader(io.StringIO(s)) if dfa.accepts(strm): print("That string is accepted by this finite state machine.") else: print("That string is not accepted.") else: print("Program Completed.") break
def main(): expression = input( "Please enter a prefix expression (or press enter to stop): ") while expression != "": reader = streamreader.StreamReader(io.StringIO(expression)) try: ast = Prog(reader) print("The postfix form is: ", ast.eval()) except Exception as e: print(e) expression = input( "Please enter a prefix expression (or press enter to stop): ")
def main(): q0 = state.State(0) q1 = state.State(1) q2 = state.State(2) q3 = state.State(3) q4 = state.State(4) q5 = state.State(5, 1) classes = {"a": frozenset("a"), "b": frozenset("b")} q0.addTransition("a", 2) q0.addTransition("b", 1) q1.addTransition("a", 1) q1.addTransition("b", 1) q2.addTransition("a", 3) q2.addTransition("b", 2) q3.addTransition("a", 4) q3.addTransition("b", 2) q4.addTransition("a", 5) q4.addTransition("b", 4) q5.addTransition("a", 5) q5.addTransition("b", 4) dfa = FiniteStateMachine({ 0: q0, 1: q1, 2: q2, 3: q3, 4: q4, 5: q5 }, 0, classes) # You must complete the main function here but you can # create a stream over a string s by writing # strm = streamreader.StreamReader(io.StringIO(s)) s = input("Please enter a string of a's and b's: ") while s != "": strm = streamreader.StreamReader(io.StringIO(s)) print(dfa.accepts(strm)) s = input("Please enter a string of a's and b's: ")
def __init__(self, instream=None, startStateId=None, states={}, classes={}, keywords={}, identifierTokenId=-1, eatComments=False, commentTokenId=-1): # The use of dict below creates a copy of the default parameter because # only one copy of default parameters is created and if multiple scanner # objects were created this would be a problem... for Python... self.states = dict(states) self.classes = dict(classes) self.startStateId = startStateId self.reader = streamreader.StreamReader(instream) self.keywords = dict(keywords) self.identiferTokenId = identifierTokenId self.eatComments = eatComments self.commentTokenId = commentTokenId for stateId in states: states[stateId].setClasses(classes)
def main(): q1 = state.State(1, True) q2 = state.State(2, True) q3 = state.State(3, True) q4 = state.State(4, True) q5 = state.State(5) classes = {} classes["a"] = set(["a"]) classes["b"] = set(["b"]) q1.addTransition("a", 2) q1.addTransition("b", 1) q2.addTransition("a", 3) q2.addTransition("b", 2) q3.addTransition("a", 4) q3.addTransition("b", 3) q4.addTransition("a", 5) q4.addTransition("b", 4) q5.addTransition("a", 5) q5.addTransition("b", 5) s = input("Please enter a string of a's and b's:") while s: dfa = FiniteStateMachine({ 1: q1, 2: q2, 3: q3, 4: q4, 5: q5 }, 1, classes) strm = streamreader.StreamReader(io.StringIO(s)) dfa.accepts(strm) s = input("Please enter a string of a's and b's:") print('Program Completed.')
if token == "+": return Plus(E(reader), E(reader)) if token == "-": return Minus(E(reader), E(reader)) if token == "*": return Times(E(reader), E(reader)) if token == "/": return Divide(E(reader), E(reader)) return Num(int(token)) def parse(reader): tree = E(reader) t = reader.getToken() if not t == chr(streamreader.EOF): raise Exception("Parse Error") return tree if __name__ == '__main__': s = input("Please enter a postfix expression (or press enter to stop): ") while not s == "": # print(s) strm = io.StringIO(s) strmreader = streamreader.StreamReader(strm) tree = parse(strmreader) # print(tree) print("The postfix form is:" + str(tree)) s = input("Please enter a postfix expression (or press enter to stop): ")
# delta[(2, epsilon, "0")] = {(3, "")} # builds npda of ww^R language # delta[(0, "a", "a")] = {0, "aa"} # delta[(0, "b", "a")] = {0, "ba"} # delta[(0, "a", "b")] = {0, "ab"} # delta[(0, "b", "b")] = {0, "bb"} # delta[(0, "a", "z")] = {0, "az"} # delta[(0, "b", "z")] = {0, "bz"} # delta[(0, epsilon, "a")] = {1, "a"} # delta[(0, epsilon, "b")] = {1, "b"} # delta[(1, "a", "a")] = {1, ""} # delta[(1, "b", "b")] = {1, ""} # delta[(1, epsilon, "z")] = {2, ""} # delta[(0, epsilon, "z")] = {2, ""} # a^n b^2n, code provided in class, Chapter7Excercise4(a) delta[(0, "a", "0")] = {(1, "110")} delta[(0, epsilon, "0")] = {(3, "")} delta[(1, "a", "1")] = {(1, "111")} delta[(1, "b", "1")] = {(2, "")} delta[(2, "b", "1")] = {(2, "")} delta[(2, epsilon, "0")] = {(3, "")} npda = NPDA(delta, 0, "0", {3}) x = input("Please enter a string of a's and b's: ") # x = ("a" * 1000) + ("b" * 2000) if npda.accepts(streamreader.StreamReader(io.StringIO(x))): print("Yes, in the language") else: print("Not in the language")
def buildMachine(self, instream): ####################################################################### # The newState function should be called to create any new state. It enters # the state information into the self.states dictionary for use later. Then # it returns the state Id (its state number) of the newly created state. ####################################################################### def newState(): self.numStates += 1 aState = nfastate.NFAState(self.numStates) self.states[self.numStates] = aState return self.numStates ####################################################################### # The operate function is given an: # op : the operator # # opStack: the stack of operators # # stateStack: the stack of first,last states (which is the operand stack) # the function does not return anything. Instead it operates on the two # stacks as described in the two stack calculator algorithm. # # For each new state be sure to call the newState() function to enter # the new state in the self.states dictionary correctly. ####################################################################### def operate(op, opStack, stateStack): precedence = {'(': 0, '|': 1, '.': 2, '*': 3, ')': 0} if op == '(': opStack.push(op) return None elif opStack.isEmpty(): return None else: topOp = opStack.pop() opStack.push(topOp) while precedence[op] <= precedence[topOp]: topOp = opStack.pop() if topOp == '*': q0ID, q1ID = stateStack.pop() startStateID = newState() endStateID = newState() startState = self.states[startStateID] endState = self.states[endStateID] q0 = self.states[q0ID] q1 = self.states[q1ID] startState.addTransition(epsilon, q0ID) startState.addTransition(epsilon, q1ID) q1.addTransition(epsilon, endStateID) endState.addTransition(epsilon, startStateID) stateStack.push((startStateID, endStateID)) elif topOp == '.': q0ID, q1ID = stateStack.pop() startStateID = newState() endStateID = newState() startState = self.states[startStateID] endState = self.states[endStateID] q0 = self.states[q0ID] q1 = self.states[q1ID] startState.addTransition(epsilon, q0ID) q1.addTransition(epsilon, endStateID) stateStack.push((startStateID, endStateID)) elif topOp == '|': q0ID, q1ID = stateStack.pop() q2ID, q3ID = stateStack.pop() startStateID = newState() endStateID = newState() startState = self.states[startStateID] endState = self.states[endStateID] q0 = self.states[q0ID] q1 = self.states[q1ID] q2 = self.states[q2ID] q3 = self.states[q3ID] q1.addTransition(epsilon, endStateID) q3.addTransition(epsilon, endStateID) startState.addTransition(epsilon, q0ID) startState.addTransition(epsilon, q2ID) stateStack.push((startStateID, endStateID)) elif topOp == '(': return None opStack.push(op) ####################################################################### # The evaluateRegExpression function is given the StreamReader called # reader and reads the regular expression and returns a tuple of start,stop state # for the expression. The stop state will be set to an accepting state by the code # that calls this function. When this function is called the regular expression must be # read. For instance in the line # # identifier = letter.(letter|digit)*; # # everything up to the = has already been read. You need to write code to read the # regular expression up to the semicolon (i.e. ;) and then run your regular expression # calculator code on it to build an NFA from this. To create each new state be sure to call # the newState() function to create it so the state gets entered into the self.states dictionary # correctly. ####################################################################### def evaluateRegExpression(reader): operatorStack = stack.Stack() operandStack = stack.Stack() operatorStack.push('(') token = reader.getToken() while token != ';': if token in "(|.*": operate(token, operatorStack, operandStack) else: startStateID = newState() endStateID = newState() startState = self.states[startStateID] endState = self.states[endStateID] startState.addTransition(token, endStateID) operandStack.push((startStateID, endStateID)) token = reader.getToken() operate(')', operatorStack, operandStack) startStateID, endStateID = operandStack.pop() reader.unreadChar(';') return startStateID, endStateID #################################################### # This is the start of the buildMachine code here #################################################### reader = streamreader.StreamReader(instream) startStates = [] reader.skipComments() if reader.peek("#CLASSES"): # print("Found #CLASSES") reader.readUpTo("\n") while (not reader.peek("#")): # The "#" marks the beginning of the next section. Either # KEYWORDS or TOKENS. KEYWORDS are optional. reader.skipComments() # We could have keywords right after a comment. So if keyword section is found, don't read # any more character classes. if not reader.peek("#KEYWORDS"): className = reader.readIdentifier() reader.readUpTo("=") if reader.peek("^"): anticlass = True reader.readUpTo("^") classSet = orderedcollections.OrderedSet(range(256)) else: anticlass = False classSet = orderedcollections.OrderedSet() done = False while not done: if reader.peek("'"): # Found a character constant reader.readUpTo("'") character = reader.readUpTo("'")[0] # print(character) ordVal = ord(character) else: ordVal = reader.readInt() # Add the end of the range if there is a range of # characters if reader.peek(".."): reader.readUpTo("..") if reader.peek("'"): reader.readUpTo("'") character = reader.readUpTo("'")[0] # print(character) lastOrdVal = ord(character) else: lastOrdVal = reader.readInt() else: lastOrdVal = ordVal # Now build the set for i in range(ordVal, lastOrdVal + 1): if anticlass: classSet.remove(i) else: classSet.add(i) if reader.peek(","): reader.readUpTo(",") else: done = True # print(className) # Add the class to the class dictionary self.classes[className] = classSet reader.readUpTo(";") #print("These are the classes") # print(self.classes) # keyword and token id numbers idnum = 0 keywordsPresent = False if reader.peek("#KEYWORDS"): reader.readUpTo("#KEYWORDS") keywordsPresent = True reader.skipComments() while (not reader.peek("#TOKENS")): #idnum = reader.readInt() # reader.readUpTo(":") reader.readUpTo("'") keyword = reader.readUpTo("'")[:-1].strip() # print(idnum,keyword) self.keywords[keyword] = idnum idnum += 1 reader.readUpTo(";") reader.skipComments() # print(self.keywords) reader.readUpTo("#TOKENS") reader.skipComments() readingFirstToken = True while not (reader.peek("#PRODUCTIONS") or reader.peek("#END") or reader.peek("#DEFINITIONS")): #idnum = reader.readInt() # reader.readUpTo(":") if reader.peek("'"): # Then the token was specified as a string like this: # '>='; reader.readUpTo("'") token = reader.readUpTo("'")[:-1].strip() previousId = newState() startStateId = previousId for c in token: nextId = newState() classSet = orderedcollections.OrderedSet([ord(c)]) if not (c in self.classes and self.classes[c] == classSet): self.classes[c] = classSet self.states[previousId].addTransition(c, nextId) previousId = nextId self.states[nextId].setAccepting(idnum) startStates.append(startStateId) reader.readUpTo(";") self.tokens[idnum] = token idnum += 1 if readingFirstToken and keywordsPresent: raise Exception( "First Token must be identifier token for matching keywords!" ) else: # The token was specified as a regular expression like this: # identifier = letter.(letter|digit)*; name = reader.readUpTo("=")[:-1].strip() self.tokens[idnum] = name if readingFirstToken: self.firstTokenId = idnum readingFirstToken = False # You must write the evaluateRegExpression(reader) function # that reads a regular expression using the reader StreamReader # object and returns its start and stop state ids. startStateId, stopStateId = evaluateRegExpression(reader) self.states[stopStateId].setAccepting(idnum) idnum += 1 startStates.append(startStateId) reader.readUpTo(";") reader.skipComments() # Create a 0th State as the start state startState = nfastate.NFAState(0) self.numStates += 1 self.states[0] = startState for startId in startStates: self.states[0].addTransition(epsilon, startId) self.startStateId = 0 reader.readUpTo("#END")
def buildMachine(self, instream): def operate(op, opStack, stateStack): #print "Operating..." #print "The operator is ", op.getOpChar() if (op.getOpChar() == '('): opStack.push(Operator('(')) return while op.precedence() <= opStack.peek().precedence(): topOp = opStack.pop() opChar = topOp.getOpChar() #print "The topOp is ", opChar if opChar == '|': b1, b2 = stateStack.pop() a1, a2 = stateStack.pop() firstId = newState() secondId = newState() self.states[firstId].addTransition(epsilon, a1) self.states[firstId].addTransition(epsilon, b1) self.states[a2].addTransition(epsilon, secondId) self.states[b2].addTransition(epsilon, secondId) stateStack.push((firstId, secondId)) elif opChar == '.': b1, b2 = stateStack.pop() a1, a2 = stateStack.pop() firstId = newState() secondId = newState() self.states[firstId].addTransition(epsilon, a1) self.states[a2].addTransition(epsilon, b1) self.states[b2].addTransition(epsilon, secondId) stateStack.push((firstId, secondId)) elif opChar == '*': a1, a2 = stateStack.pop() firstId = newState() secondId = newState() self.states[firstId].addTransition(epsilon, a1) self.states[firstId].addTransition(epsilon, secondId) self.states[a2].addTransition(epsilon, secondId) self.states[secondId].addTransition(epsilon, firstId) stateStack.push((firstId, secondId)) elif opChar == '(': # do nothing if (op.getOpChar() == ')'): return opStack.push(op) def evaluateRegExpression(reader): opStack = stack.Stack() stateStack = stack.Stack() opStack.push(Operator("(")) while not reader.peek(";"): token = reader.getToken() if token in "(+|.*)": #if reader.peek("(") or reader.peek(")") or reader.peek(".") or reader.peek("*") or reader.peek("|"): op = Operator(token) operate(op, opStack, stateStack) else: # it is a character class set name firstId = newState() secondId = newState() self.states[firstId].addTransition(token, secondId) stateStack.push((firstId, secondId)) operate(Operator(')'), opStack, stateStack) if (not opStack.isEmpty()): raise Exception("Malformed Regular Expression") return stateStack.pop() def newState(): self.numStates += 1 aState = nfastate.NFAState(self.numStates) self.states[self.numStates] = aState return self.numStates reader = streamreader.StreamReader(instream) startStates = [] reader.skipComments() if reader.peek("#CLASSES"): #print("Found #CLASSES") reader.readUpTo("\n") while (not reader.peek("#")): # The "#" marks the beginning of the next section. Either KEYWORDS or TOKENS. KEYWORDS are optional. reader.skipComments() # We could have keywords right after a comment. So if keyword section is found, don't read # any more character classes. if not reader.peek("#KEYWORDS"): className = reader.readIdentifier() reader.readUpTo("=") if reader.peek("^"): anticlass = True reader.readUpTo("^") classSet = orderedcollections.OrderedSet(range(256)) else: anticlass = False classSet = orderedcollections.OrderedSet() done = False while not done: if reader.peek("'"): # Found a character constant reader.readUpTo("'") character = reader.readUpTo("'")[0] #print(character) ordVal = ord(character) else: ordVal = reader.readInt() # Add the end of the range if there is a range of characters if reader.peek(".."): reader.readUpTo("..") if reader.peek("'"): reader.readUpTo("'") character = reader.readUpTo("'")[0] #print(character) lastOrdVal = ord(character) else: lastOrdVal = reader.readInt() else: lastOrdVal = ordVal # Now build the set for i in range(ordVal, lastOrdVal + 1): if anticlass: classSet.remove(i) else: classSet.add(i) if reader.peek(","): reader.readUpTo(",") else: done = True #print(className) #Add the class to the class dictionary self.classes[className] = classSet reader.readUpTo(";") #print("These are the classes") #print(self.classes) # keyword and token id numbers idnum = 0 keywordsPresent = False if reader.peek("#KEYWORDS"): reader.readUpTo("#KEYWORDS") keywordsPresent = True reader.skipComments() while (not reader.peek("#TOKENS")): #idnum = reader.readInt() #reader.readUpTo(":") reader.readUpTo("'") keyword = reader.readUpTo("'")[:-1].strip() #print(idnum,keyword) self.keywords[keyword] = idnum idnum += 1 reader.readUpTo(";") reader.skipComments() #print(self.keywords) reader.readUpTo("#TOKENS") reader.skipComments() readingFirstToken = True while not (reader.peek("#PRODUCTIONS") or reader.peek("#END") or reader.peek("#DEFINITIONS")): #idnum = reader.readInt() #reader.readUpTo(":") if reader.peek("'"): # Then the token was specified as a string like this: # '>='; reader.readUpTo("'") token = reader.readUpTo("'")[:-1].strip() previousId = newState() startStateId = previousId for c in token: nextId = newState() classSet = orderedcollections.OrderedSet([ord(c)]) if not (c in self.classes and self.classes[c] == classSet): self.classes[c] = classSet self.states[previousId].addTransition(c, nextId) previousId = nextId self.states[nextId].setAccepting(idnum) startStates.append(startStateId) reader.readUpTo(";") self.tokens[idnum] = token idnum += 1 if readingFirstToken and keywordsPresent: raise Exception( "First Token must be identifier token for matching keywords!" ) else: # The token was specified as a regular expression like this: # identifier = letter.(letter|digit)*; name = reader.readUpTo("=")[:-1].strip() self.tokens[idnum] = name if readingFirstToken: self.firstTokenId = idnum readingFirstToken = False startStateId, stopStateId = evaluateRegExpression(reader) self.states[stopStateId].setAccepting(idnum) idnum += 1 startStates.append(startStateId) reader.readUpTo(";") reader.skipComments() # Create a 0th State as the start state startState = nfastate.NFAState(0) self.numStates += 1 self.states[0] = startState for startId in startStates: self.states[0].addTransition(epsilon, startId) self.startStateId = 0 reader.readUpTo("#END")
def main(): q0 = state.State(0) q1 = state.State(1) q2 = state.State(2) q3 = state.State(3) q4 = state.State(4) q5 = state.State(5) q6 = state.State(6) q7 = state.State(7) q8 = state.State(8, True) q9 = state.State(9) q10 = state.State(10) q11 = state.State(11, True) q12 = state.State(12, True) q13 = state.State(13, True) q14 = state.State(14) classes = {} classes["a"] = set(["a"]) classes["b"] = set(["b"]) q0.addTransition("a", 1) q0.addTransition("b", 0) q1.addTransition("a", 2) q1.addTransition("b", 0) q2.addTransition("a", 3) q2.addTransition("b", 0) q3.addTransition("a", 4) q3.addTransition("b", 5) q4.addTransition("a", 4) q4.addTransition("b", 0) q5.addTransition("a", 6) q5.addTransition("b", 5) q6.addTransition("a", 7) q6.addTransition("b", 5) q7.addTransition("a", 8) q7.addTransition("b", 5) q8.addTransition("a", 9) q8.addTransition("b", 11) q9.addTransition("a", 9) q9.addTransition("b", 10) q10.addTransition("a", 9) q10.addTransition("b", 5) q11.addTransition("a", 12) q11.addTransition("b", 11) q12.addTransition("a", 13) q12.addTransition("b", 11) q13.addTransition("a", 14) q13.addTransition("b", 11) q14.addTransition("a", 14) q14.addTransition("b", 14) q0.setClasses(classes) q1.setClasses(classes) q2.setClasses(classes) q3.setClasses(classes) q4.setClasses(classes) q5.setClasses(classes) q6.setClasses(classes) q7.setClasses(classes) q8.setClasses(classes) q9.setClasses(classes) q10.setClasses(classes) q11.setClasses(classes) q12.setClasses(classes) q13.setClasses(classes) q14.setClasses(classes) states = { 0: q0, 1: q1, 2: q2, 3: q3, 4: q4, 5: q5, 6: q6, 7: q7, 8: q8, 9: q9, 10: q10, 11: q11, 12: q12, 13: q13, 14: q14 } dfa = FiniteStateMachine(states, 0, classes) while True: s = input("Please enter a string of a's and b's: ") if len(s) > 0: strm = streamreader.StreamReader(io.StringIO(s)) if dfa.accepts(strm): print("That string is accepted by this finite state machine.") else: print("That string is not accepted.") else: print("Program Completed.") break
def readInputFile(self, instream): def addNonterminal(nonterminal): if not nonterminal in self.nonterminals: self.nonterminals.add(nonterminal) self.tnts.append(nonterminal) self.tntMap[nonterminal] = len(self.tnts) - 1 def readRHS(prod): while not reader.peek("("): if reader.peek( "'"): # This is a token that starts with a quote. reader.readUpTo("'") terminal = "'" + reader.readUpTo("'") #print("Found terminal", terminal) if not terminal in self.terminals: raise Exception("Undefined terminal: " + terminal) prod.addRHSItem(self.tntMap[terminal]) else: tntName = reader.readIdentifier() #print("Found item", tntName) if tntName != "null": if not tntName in self.terminals: addNonterminal(tntName) prod.addRHSItem(self.tntMap[tntName]) reader.readUpTo("(") returnValue = reader.readUpTo(");")[:-2] if returnValue.count("::=") > 0: raise Exception( "Found ::= within production return value. Likely a ; is missing at the end of line " + str(reader.getLineNumber() - 1) + ".") prod.returnValue = returnValue reader = streamreader.StreamReader(instream) index = 0 reader.readUpTo("#") while not (reader.peek("KEYWORDS") or reader.peek("TOKENS")): reader.readUpTo("#") if reader.peek("KEYWORDS"): reader.readUpTo("KEYWORDS") #print("Found Keywords in file.") reader.skipComments() while reader.peek("'"): reader.readUpTo("'") keyword = "'" + reader.readUpTo("'") self.terminals.add(keyword) self.tnts.append(keyword) self.tntMap[keyword] = len(self.tnts) - 1 reader.readUpTo(";") reader.skipComments() reader.readUpTo("#TOKENS") else: reader.readUpTo("TOKENS") #print("Keywords=", self.terminals) reader.skipComments() while (not reader.peek("#DEFINITIONS")) and ( not reader.peek("#PRODUCTIONS")): if reader.peek("'"): reader.readUpTo("'") tokenName = "'" + reader.readUpTo("'") else: tokenName = reader.readIdentifier() self.tnts.append(tokenName) self.terminals.add(tokenName) self.tntMap[tokenName] = len(self.tnts) - 1 reader.readUpTo(";") reader.skipComments() #print(self.tnts) #print(self.tntMap) #print(self.terminals) if reader.peek("#DEFINITIONS"): reader.readUpTo("#DEFINITIONS") self.definitions = reader.readUpTo( "#PRODUCTIONS")[:-len("#PRODUCTIONS")] else: self.definitions = "" reader.readUpTo("#PRODUCTIONS") # Add the goal nonterminal and production # before reading the other productions. #addNonterminal("$$GOAL$$") #prod = Production(0,self.tntMap["$$GOAL$$"]) #prod.addRHSItem(len(self.terminals)+1) #prod.tnts = self.tnts #prod.terminals = self.terminals #self.productions.append(prod) while not reader.peek("#END"): lhsName = reader.readIdentifier() addNonterminal(lhsName) prod = Production(len(self.productions), self.tntMap[lhsName]) prod.tnts = self.tnts prod.terminals = self.terminals self.productions.append(prod) reader.readUpTo("::=") readRHS(prod) while reader.peek("|"): prod = Production(len(self.productions), self.tntMap[lhsName]) prod.tnts = self.tnts prod.terminals = self.terminals self.productions.append(prod) reader.readUpTo("|") readRHS(prod) reader.readUpTo("#END")