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")
