def parse_expr(s):
iend, tree = ep.tokenTree(s, 0, len(s), 0)
print tree
#print "::::: ", ep.tokenTree2string(s,tree, 0)
print ep.tokenTree2string(s, tree, 0, indent=True)
ep.walkTree_2(s, tree, 0, checkVar, empty, checkFunc)
exit()
def test_validate_parentheses(self):
# true cases
with self.subTest():
self.assertTrue(EP.validate_parentheses(
('(', 'p', ')'))[0])
with self.subTest():
self.assertTrue(EP.validate_parentheses(
('(', '(', 'p', ')', ')'))[0])
with self.subTest():
self.assertTrue(EP.validate_parentheses(
('(', 'p', ')', '+', '(', 'q', ')'))[0])
with self.subTest():
self.assertTrue(EP.validate_parentheses(
('(', '(', 'p', ')', '+', '(', 'q', ')', ')'))[0])
with self.subTest():
self.assertTrue(EP.validate_parentheses(
('p', '+', 'q'))[0])
# false cases
with self.subTest():
self.assertFalse(EP.validate_parentheses(
('(', 'p'))[0])
with self.subTest():
self.assertFalse(EP.validate_parentheses(
('p', ')'))[0])
with self.subTest():
self.assertFalse(EP.validate_parentheses(
('(', '(', 'p', ')'))[0])
with self.subTest():
self.assertFalse(EP.validate_parentheses(
('(', 'p', ')', '+', 'q', ')'))[0])
def generate_table(self, show_message):
# convert the entered string into a standard format
expression = self.entry.get()
print("Expression: {}".format(expression))
# validate that the expression is consistant with the rules
try:
expression = EP.format_expression(expression)
EP.validate(expression)
# generate table
# draw table
except EP.InvalidExpressionException as ex:
if show_message:
messagebox.showinfo('Error', ex)
except Exception as ex:
print('Unexpected exception! Exception message: {}'.format(
ex.message))
def test_get_unique_variables(self):
# basic case
with self.subTest():
self.assertEqual(EP.get_unique_variables(
('p', '+', 'q')),
['p', 'q'])
# with repetition
with self.subTest():
self.assertEqual(EP.get_unique_variables(
('p', '+', '~', 'p')),
['p'])
with self.subTest():
self.assertEqual(EP.get_unique_variables(
('p', '+', 'q', '*', 'p')),
['p', 'q'])
# with only constants
with self.subTest():
self.assertEqual(EP.get_unique_variables(
('false', '+', 'true')),
[])
# complex expression
with self.subTest():
self.assertEqual(EP.get_unique_variables(
('p', '+', 'q', '*', 'r', '>', 's', '=', 't', '=', '~', 'u',
'=', '(', 'p', '+', 'q', ')')),
['p', 'q', 'r', 's', 't', 'u'])
# mulitchar variables
with self.subTest():
self.assertEqual(EP.get_unique_variables(
('first', '+', 'last')),
['first', 'last'])
def __init__(self, fn): self.currentOp = None self.filename = fn self.bs = BScanner(self.filename) self.exp = ExpressionParser(self.bs) self.forwardReferences = [] self.loopStatus = Status.CONTINUE self.nextLocation = 1 self.nextOp = None self.operand = None self.scope = SymbolScope.GLOBAL self.structureStack = [] self.suppressAdvance = False self.jvm = self.exp.jvm self.AC = ActionTable(self) self.advances = 0
def test_not_replacement(self):
with self.subTest():
self.assertEqual(EP.standardize_string('a not b'), 'a ~ b')
with self.subTest():
self.assertEqual(EP.standardize_string('not b'), '~ b')
with self.subTest():
self.assertEqual(EP.standardize_string('testnot'), 'testnot')
with self.subTest():
self.assertEqual(EP.standardize_string('nottest'), 'nottest')
with self.subTest():
self.assertEqual(EP.standardize_string('!b'), '~ b')
with self.subTest():
self.assertEqual(EP.standardize_string('! b'), '~ b')
with self.subTest():
self.assertEqual(EP.standardize_string('~'), '~')
def test_has_invalid_chars(self):
with self.subTest():
self.assertEqual(EP.has_invalid_chars('&'), '&')
with self.subTest():
self.assertIsNone(EP.has_invalid_chars('a + b'))
with self.subTest():
self.assertIsNone(EP.has_invalid_chars('a * b'))
with self.subTest():
self.assertIsNone(EP.has_invalid_chars('a > b'))
with self.subTest():
self.assertIsNone(EP.has_invalid_chars('a = b'))
with self.subTest():
self.assertIsNone(EP.has_invalid_chars('~ b'))
with self.subTest():
self.assertIsNone(EP.has_invalid_chars('( b )'))
def test_if_replacement(self):
with self.subTest():
self.assertEqual(EP.standardize_string('a if b'), 'a > b')
with self.subTest():
self.assertEqual(EP.standardize_string('testif'), 'testif')
with self.subTest():
self.assertEqual(EP.standardize_string('iftest'), 'iftest')
with self.subTest():
self.assertEqual(EP.standardize_string('a -> b'), 'a > b')
with self.subTest():
self.assertEqual(EP.standardize_string('a --> b'), 'a > b')
with self.subTest():
self.assertEqual(EP.standardize_string('>'), '>')
def test_or_replacement(self):
with self.subTest():
self.assertEqual(EP.standardize_string('a or b'), 'a + b')
with self.subTest():
self.assertEqual(EP.standardize_string('testor'), 'testor')
with self.subTest():
self.assertEqual(EP.standardize_string('ortest'), 'ortest')
with self.subTest():
self.assertEqual(EP.standardize_string('a\\/b'), 'a + b')
with self.subTest():
self.assertEqual(EP.standardize_string('a \\/ b'), 'a + b')
with self.subTest():
self.assertEqual(EP.standardize_string('+'), '+')
def test_and_replacement(self):
with self.subTest():
self.assertEqual(EP.standardize_string('a and b'), 'a * b')
with self.subTest():
self.assertEqual(EP.standardize_string('testand'), 'testand')
with self.subTest():
self.assertEqual(EP.standardize_string('andtest'), 'andtest')
with self.subTest():
self.assertEqual(EP.standardize_string('a/\\b'), 'a * b')
with self.subTest():
self.assertEqual(EP.standardize_string('a /\\ b'), 'a * b')
with self.subTest():
self.assertEqual(EP.standardize_string('*'), '*')
import sys
sys.path.append("../")
from ExpressionParser import *
exp = ExpressionParser()
exp.testExpression("check/e2.b")
def test_var_to_placeholder(self):
with self.subTest():
self.assertEqual(EP.var_to_placeholder('+'), '+')
with self.subTest():
self.assertEqual(EP.var_to_placeholder('*'), '*')
with self.subTest():
self.assertEqual(EP.var_to_placeholder('~'), '~')
with self.subTest():
self.assertEqual(EP.var_to_placeholder('>'), '>')
with self.subTest():
self.assertEqual(EP.var_to_placeholder('='), '=')
with self.subTest():
self.assertEqual(EP.var_to_placeholder('('), '(')
with self.subTest():
self.assertEqual(EP.var_to_placeholder(')'), ')')
with self.subTest():
self.assertEqual(EP.var_to_placeholder('true'), 'true')
with self.subTest():
self.assertEqual(EP.var_to_placeholder('false'), 'false')
with self.subTest():
self.assertIsNone(EP.var_to_placeholder(None))
with self.subTest():
self.assertEqual(EP.var_to_placeholder('p'), 'VAR')
with self.subTest():
self.assertEqual(EP.var_to_placeholder('q'), 'VAR')
with self.subTest():
self.assertEqual(EP.var_to_placeholder('andorvar'), 'VAR')
def test_trailing_spaces_replacement(self):
self.assertEqual(EP.standardize_string(' a '), 'a')
def test_complex_expression_no_spaces(self):
self.assertEqual(EP.standardize_string('a/\\b\\/c-->d<->e!f'),
'a * b + c > d = e ~ f')
def test_complex_expression(self):
self.assertEqual(EP.standardize_string(
'a and b or c if d iff e not f'),
'a * b + c > d = e ~ f')
def test_validate_neighbors(self):
# cases with none
with self.subTest():
self.assertTrue(EP.validate_neighbors(None, 'p', '+')[0])
with self.subTest():
self.assertTrue(EP.validate_neighbors(None, '~', 'p')[0])
with self.subTest():
self.assertTrue(EP.validate_neighbors(None, '~', '(')[0])
with self.subTest():
self.assertTrue(EP.validate_neighbors(None, '(', 'p')[0])
with self.subTest():
self.assertTrue(EP.validate_neighbors('*', 'p', None)[0])
with self.subTest():
self.assertTrue(EP.validate_neighbors('~', 'p', None)[0])
with self.subTest():
self.assertTrue(EP.validate_neighbors('p', ')', None)[0])
# basic valid cases
with self.subTest():
self.assertTrue(EP.validate_neighbors('p', '+', 'q')[0])
with self.subTest():
self.assertTrue(EP.validate_neighbors('p', '*', 'q')[0])
with self.subTest():
self.assertTrue(EP.validate_neighbors('p', '>', 'q')[0])
with self.subTest():
self.assertTrue(EP.validate_neighbors('p', '=', 'q')[0])
with self.subTest():
self.assertTrue(EP.validate_neighbors('~', 'p', '+')[0])
with self.subTest():
self.assertTrue(EP.validate_neighbors('(', 'p', ')')[0])
# double negation is valid
with self.subTest():
self.assertTrue(EP.validate_neighbors('~', '~', 'p')[0])
# invalid cases
# double vars
with self.subTest():
self.assertFalse(EP.validate_neighbors('p', 'q', '+')[0])
with self.subTest():
self.assertFalse(EP.validate_neighbors('+', 'p', 'q')[0])
# double binary ops
with self.subTest():
self.assertFalse(EP.validate_neighbors('+', '>', 'q')[0])
with self.subTest():
self.assertFalse(EP.validate_neighbors('p', '=', '+')[0])
# invalid parens
with self.subTest():
self.assertFalse(EP.validate_neighbors(')', '(', 'p')[0])
with self.subTest(): # empty parens is bad
self.assertFalse(EP.validate_neighbors('(', ')', 'p')[0])
with self.subTest():
self.assertFalse(EP.validate_neighbors('p', '(', ')')[0])
with self.subTest():
self.assertFalse(EP.validate_neighbors('p', ')', '(')[0])
with self.subTest():
self.assertFalse(EP.validate_neighbors(')', '~', 'p')[0])
with self.subTest():
self.assertFalse(EP.validate_neighbors('(', '>', 'p')[0])
# unlcosed parens
with self.subTest():
self.assertFalse(EP.validate_neighbors('~', '(', None)[0])
with self.subTest():
self.assertFalse(EP.validate_neighbors(None, ')', '*')[0])
#bexp.py import sys from ExpressionParser import * if len(sys.argv) == 1 or len(sys.argv) > 3 or not ".txt" in sys.argv[1]: #print "\nUsage: bexp <filename>\n" fileName = sys.argv[len(sys.argv) - 1] if sys.argv[1] == "-d": Compiler.debugOn() exp = ExpressionParser() exp.testExpression(fileName) #print "done"
class BParser(ParserBase):
#public
def __init__(self, fn):
self.currentOp = None
self.filename = fn
self.bs = BScanner(self.filename)
self.exp = ExpressionParser(self.bs)
self.forwardReferences = []
self.loopStatus = Status.CONTINUE
self.nextLocation = 1
self.nextOp = None
self.operand = None
self.scope = SymbolScope.GLOBAL
self.structureStack = []
self.suppressAdvance = False
self.jvm = self.exp.jvm
self.AC = ActionTable(self)
self.advances = 0
#print self.currentOp, self.operand, self.nextOp, "1"
#def compile(self, filename):
# self.bs = BScanner(filename)
# self.bs.debugOn()
# while self.nextOp.getTokenType() != TokenType.END_FILE:
# self.advance()
def compile(self):
#self.bs.debugOn()
#try:
main = Symbol("Main", SymbolType.FORWARD_FUNCTION, SymbolScope.GLOBAL)
self.bs._symbols.insert(main)
write = Symbol("write", SymbolType.DEFINED_FUNCTION, SymbolScope.GLOBAL)
self.bs._symbols.insert(write)
if self.bs.debugging():
self.bs._symbols.dump()
self.nextOp = self.bs.nextToken()
print self.nextOp
if self.nextOp.toString() == "void":
sym = self.bs._symbols.get("Main")
self.saveForwardReference(sym, self.jvm.getPC())
self.jvm.emit3byte(Opcode.GOTO, 0)
elif self.nextOp.toString() != "int":
self.setError("Invalid program. Illegal first token.")
return
while self.loopStatus != Status.EXIT:
print ".",
self.advance()
self._generate(self.currentOp, self.nextOp)
self.fillForwardReferences()
self.jvm.finish()
#except:
#self._debugFile.close()
#pass
def advance(self):
#if self.suppressAdvance ? self.supressAdvance = False : pass
if self.suppressAdvance == True:
self.suppressAdvance = False
return
if self.operand != None:
self.operand = None
self.currentOp = self.nextOp
try:
nt = self.bs.nextToken()
except:
nt = Token(TokenType.END_FILE, 'EOF')
#print self.currentOp, self.currentOp.toString(), nt, nt.toString()
if nt == "":
return
if nt.getTokenType() == TokenType.END_FILE:
self.nextOp = nt
return
elif nt.getTokenType() == TokenType.SYMBOL or nt.getTokenType() == TokenType.LITERAL:
self.operand = nt
print "OPERAND SET", self.operand.toString()
try:
nt = self.bs.nextToken()
except:
nt = Token(TokenType.END_FILE, 'EOF')
self.nextOp = nt
print hex(self.jvm.getPC()), "(", self.advances ,")", self.currentOp.toString(), self.operand, self.nextOp.toString()
self.advances += 1
#try:
# if self.bs.debugging():
# msg = self.currentOp.toString() + " "
# msg += self.operand.toString() + " "
# msg += self.nextOp.toString() + " "
# self.bs.showMessage(msg)
#except:
# self.bs.showMessage("")
def compileExpression(self):
print "compiling expression"
self.nextOp = self.exp.compileExpression()
def fillAddress(self, referenceLoc, targetLoc):
targetLoc = targetLoc - referenceLoc
self.jvm.emitFFR(referenceLoc + 1, targetLoc)
def saveForwardReference(self, symbol, address):
fr = ForwardRef(symbol, address)
print fr.reference.toString(), " SAVE FR:::"
self.forwardReferences.append(fr)
def fillForwardReferences(self):
while len(self.forwardReferences) != 0:
ref = self.forwardReferences.pop()
if self.bs._symbols.defined(ref.reference.toString()) == False:
raise CompilerException("Function not defined, " + ref.reference.toString() + self.bs.fln())
else:
sym = self.bs._symbols.get(ref.reference.toString())
self.fillAddress(ref.instrLocation, sym.getAddress())
#private
def _compileCondition(self):
self.compileExpression()
relop = self.nextOp
self.compileExpression()
relstr = relop.toString()
print "RELOP!!!1 :", relop
print "RELSTRING!!!", relstr
if relstr == "<":
self.jvm.emit3byte(Opcode.IF_ICMPGE, 0) #do you just emit the i_cmp opcode? (what about the offset)
if relstr == ">":
self.jvm.emit3byte(Opcode.IF_ICMPLE, 0)
if relstr == "<=":
self.jvm.emit3byte(Opcode.IF_ICMPGT, 0)
if relstr == ">=":
self.jvm.emit3byte(Opcode.IF_ICMPLT, 0)
if relstr == "==":
self.jvm.emit3byte(Opcode.IF_ICMPNE, 0)
if relstr == "!=":
self.jvm.emit3byte(Opcode.IF_ICMPEQ, 0)
def _generate(self, cOp, nOp):
cOpTT = cOp.getTokenType()
nOpTT = nOp.getTokenType()
if cOpTT >= TokenType.END_FILE or nOpTT >= TokenType.END_FILE:
self._xx()
else:
self.AC.cono[cOpTT][nOpTT]()
# code generators
# ASsignment
def _AS(self):
print "AS()"
print self.nextOp.toString(), "ASSIGNMENT&*&*&"
if self.nextOp.getTokenType() == TokenType.L_BRACKET:
sym = self.bs._symbols.get(self.operand.toString())
if sym.getSymbolType() != SymbolType.ARRAY:
raise CompilerException("Assignment Error, "+ sym.toString() +" is not an array. " + self.bs.fln())
self.jvm.chooseOp(Opcode.ALOAD, Opcode.ALOAD_0, sym.getAddress())
self.compileExpression()
self.advance()
self.compileExpression()
self.jvm.emit1byte(Opcode.IASTORE)
else:
sym = self.bs._symbols.get(self.operand.toString())
val = self.compileExpression()
print self.currentOp.toString(), self.operand.toString(), self.nextOp.toString()
self.jvm.chooseOp(Opcode.ISTORE, Opcode.ISTORE_0, sym.getAddress())
# CAll function
def _CA(self):
print "CA()"
print "calling a function: ", self.currentOp.toString(), self.operand.toString(), self.nextOp.toString()
if self.operand.toString() == "write":
print "calling the write function"
self.jvm.emit3byte(Opcode.GETSTATIC, 6)
self.compileExpression()
self.jvm.emit3byte(Opcode.INVOKEVIRTUAL, 7)
else:
if self.bs._symbols.defined(self.operand.toString()) == False:
print "function not defined"
sym = Symbol(self.operand.toString(), SymbolType.FORWARD_FUNCTION, self.scope)
self.bs._symbols.insert(sym)
sym = self.bs._symbols.get(self.operand.toString())
if sym.getSymbolType() == SymbolType.FORWARD_FUNCTION:
self.saveForwardReference(sym, self.jvm.getPC())
self.jvm.emit3byte(Opcode.JSR, 0) #jsr
elif sym.getSymbolType() == SymbolType.DEFINED_FUNCTION:
self.jvm.emit3byte(Opcode.JSR, sym.getAddress() - self.jvm.getPC()) #jsr
else:
raise CompilerException("Error, call to "+sym.toString()+" does not reference a function, "+self.bs.fln())
# COndition
def _CO(self):
print "CO()"
if self.currentOp.toString() == "if":
struc = Structure(StructureType.IF)
self._compileCondition()
struc.jumpLoc = self.jvm.getPC() - 3
self.structureStack.append(struc)
print "Pushed IF Structure"
elif self.currentOp.toString() == "while":
struc = Structure(StructureType.WHILE)
struc.conditionLoc = self.jvm.getPC()
self._compileCondition()
struc.jumpLoc = self.jvm.getPC() - 3
self.structureStack.append(struc)
print "Pushed WHILE structure"
pass #save position of conditional jump at end of the cond as jumpLoc (pc - 3)
# DEclaration
def _DE(self):
print "DE()"
#self.suppressAdvance = True
print "declaring a variable...", self.currentOp.toString(), self.operand.toString(), self.nextOp.toString()
if self.bs._symbols.defined(self.operand.toString()):
self.setError("Error: Multiple Declaration")
raise CompilerException("Multiple Declaration of variable "+ self.operand.toString() + self.bs.fln())
#if self.nextOp.toString() == ";":
# print "default declaration"
# sym = Symbol(self.operand.toString(), SymbolType.VARIABLE, self.scope)
# sym.setAddress(self.nextLocation)
# self.nexLocation += 1
# self.pushConstantInt(0)
# self.jvm.chooseOp(Opcode.ISTORE, Opcode.ISTORE_0, sym.getAddress())
# self.advance()
# self.bs._symbols.insert(sym)
# return
#
#while self.nextOp.toString() != ";":
# print self.operand.toString(), "SYMBOL!!!"
# self.advance()
# sym.setAddress(self.nextLocation)
# if self.nextOp.toString() == "[":
# sym.setSymbolType(SymbolType.ARRAY)
# self.advance() # co = '[', no = ']'
# self.pushConstant(self.operand)
# size = self.operand.toString()
# self.jvm.emit2byte(Opcode.NEWARRAY, 10)
# sym.setAddress(self.nextLocation)
# self.jvm.chooseOp(Opcode.ASTORE, Opcode.ASTORE_0, sym.getAddress())
# self.advance() # co = ']', no = ('=' | ';')
# if self.nextOp.toString() == "=":
# self.advance() # co = '=', no = '{'
# if self.nextOp.toString() != "{":
# self.setError("Syntax Error: Missing { after = ");
#
# self.advance() #co = '{', no = ','
# arr = []
# while self.nextOp.toString() != ";":
# print "Array Declaration :", self.operand.toString()
# arr.append(self.operand)
# self.advance()
# if len(arr) > size:
# self.setError("Syntax Error: Array Subscript exceeded")
# else:
# i = 0
# for val in arr:
# self.jvm.chooseOp(Opcode.ALOAD, Opcode.ALOAD_0, sym.getAddress())
# self.pushConstantInt(i)
# self.pushConstant(val)
# self.jvm.emit1byte(Opcode.IASTORE)
# i += 1
#
# else: #if not an array
# sym.setSymbolType(SymbolType.VARIABLE)
# #sym.setAddress(self.nextLocation)
# if self.nextOp.toString() == "=":
# self.advance()
# self.pushConstant(self.operand)
# self.jvm.chooseOp(Opcode.ISTORE, Opcode.ISTORE_0, sym.getAddress())
#
# print "declared a variable"
#
# #do variable declaration things
# self.bs._symbols.insert(sym)
# self.nextLocation += 1
self.done = False
while self.done is False:
#if self.currentOp.toString() == "int":
# self.advance()
if self.nextOp.toString() == ";":
#declare an uninitialzed variable, then end
sym = Symbol(self.operand.toString(), SymbolType.VARIABLE, self.scope)
sym.setAddress(self.nextLocation)
self.nextLocation += 1
self.pushConstantInt(0)
self.jvm.chooseOp(Opcode.ISTORE, Opcode.ISTORE_0, sym.getAddress())
self.advance()
self.bs._symbols.insert(sym)
self.done = True
elif self.nextOp.toString() == ",":
#declare this uninitalized variable, then go on to the next one
if self.currentOp.toString() == "," or self.currentOp.toString() == "int":
sym = Symbol(self.operand.toString(), SymbolType.VARIABLE, self.scope)
sym.setAddress(self.nextLocation)
self.nextLocation += 1
self.pushConstantInt(0)
self.jvm.chooseOp(Opcode.ISTORE, Opcode.ISTORE_0, sym.getAddress())
self.advance()
self.bs._symbols.insert(sym)
else:
self.advance()
elif self.nextOp.toString() == "[":
#declare an array, check the nextOp, and continue or end depending
sym = Symbol(self.operand.toString(), SymbolType.ARRAY, self.scope)
self.advance() # co = '[', no = ']'
print self.operand.toString(), "OPERAND"
self.pushConstant(self.operand)
size = self.operand.toString()
print "ARRAY SIZE", size
self.jvm.emit2byte(Opcode.NEWARRAY, 10)
sym.setAddress(self.nextLocation)
self.nextLocation += 1
self.bs._symbols.insert(sym)
self.jvm.chooseOp(Opcode.ASTORE, Opcode.ASTORE_0, sym.getAddress())
self.advance() # co = ']', no = ('=' | ';' | ',')
if self.nextOp.toString() == "=":
self.advance() # co = '=', no = '{'
if self.nextOp.toString() != "{":
self.setError("Syntax Error: Missing { after = ");
self.advance() #co = '{', no = ','
arr = []
while self.currentOp.toString() != "}":
print "Array Declaration :", self.operand.toString()
arr.append(self.operand)
self.advance()
print self.nextOp.toString(), "NEXT OP ========="
print "Attempted array declaration list size", len(arr)
if len(arr) > size:
self.setError("Syntax Error: Array Subscript exceeded")
raise CompilerException("Out-of-Bounds Error, Array subscript exceeded at symbol " + sym.toString() + self.bs.fln())
else:
i = 0
for val in arr:
print "assigning value", val, "to array"
self.jvm.chooseOp(Opcode.ALOAD, Opcode.ALOAD_0, sym.getAddress())
self.pushConstantInt(i)
self.pushConstant(val)
self.jvm.emit1byte(Opcode.IASTORE)
i += 1
if self.nextOp.toString() == ";":
self.done = True
print "AFTER DECLARATION, NEXTOP =", self.nextOp.toString()
elif self.nextOp.toString() == "=":
print "declare an initialized variable"
sym = Symbol(self.operand.toString(), SymbolType.VARIABLE, self.scope)
self.advance()
print self.operand.toString()
sym.setAddress(self.nextLocation)
self.nextLocation += 1
self.pushConstant(self.operand)
self.bs._symbols.insert(sym)
self.jvm.chooseOp(Opcode.ISTORE, Opcode.ISTORE_0, sym.getAddress())
if self.nextOp.toString() == ";":
self.done = True
pass
else:
#error
self.done = True
raise CompilerException("Invalid Assignment Sequence" + self.bs.fln())
pass
print "OUT OF LOOPS"
try:
if self.scope == SymbolScope.GLOBAL and self.nextOp.toString() == "void":
print "END OF A DECLARATION STATEMENT"
sym = self.bs._symbols.get("Main")
self.saveForwardReference(sym, self.jvm.getPC())
self.jvm.emit3byte(Opcode.GOTO, 0)
except:
pass
# Define Function
def _DF(self):
print "DF()"
self.scope = SymbolScope.LOCAL
if self.bs._symbols.defined(self.operand.toString()):
sym = self.bs._symbols.get(self.operand.toString())
sym.setSymbolType(SymbolType.DEFINED_FUNCTION)
else:
sym = Symbol(self.operand.toString(), SymbolType.DEFINED_FUNCTION, SymbolScope.GLOBAL)
self.bs._symbols.insert(sym)
sym.setAddress(self.jvm.getPC())
if sym.toString() == "Main":
print "Main Function Definition"
struct = Structure(StructureType.MAIN)
else:
struct = Structure(StructureType.FUNCTION)
print "Function Definition"
self.structureStack.append(struct)
print self.structureStack
print len(self.structureStack), ": structure pushed, "
# End Block
def _EB(self):
print "EB()"
#print "END BLOCK: ", self.currentOp.toString(), self.operand.toString(), self.nextOp.toString()
if len(self.structureStack) == 0:
raise CompilerException("Error, Found right brace without matching left brace" + self.bs.fln())
struct = self.structureStack.pop()
if struct.isOfType(StructureType.ELSE):
self.fillAddress(struct.jumpLoc, self.jvm.getPC()) #not done
elif struct.isOfType(StructureType.IF):
if self.bs.peekToken().toString() == "else":
pstru = Structure(StructureType.ELSE)
pstru.jumpLoc = self.jvm.getPC()
self.structureStack.append(pstru)
self.jvm.emit3byte(Opcode.GOTO, 0)
#emit code to jump past false part
self.jvm.emitFFR(struct.jumpLoc + 1, self.jvm.getPC() - struct.jumpLoc)
elif struct.isOfType(StructureType.WHILE):
self.jvm.emit3byte(Opcode.GOTO, struct.conditionLoc - self.jvm.getPC())
self.fillAddress(struct.jumpLoc, self.jvm.getPC())
elif struct.isOfType(StructureType.FUNCTION):
self.scope = SymbolScope.GLOBAL
self.bs._symbols.clearLocalTable()
#generate code to save the return address in loc0 and emit instruction
#return to the calling point
self.jvm.emit1byte(Opcode.ASTORE_0)
self.jvm.emit2byte(Opcode.RET, 0)
if self.bs.peekToken().getTokenType() == TokenType.END_FILE:
self.loopStatus = Status.EXIT
elif struct.isOfType(StructureType.MAIN):
self.scope = SymbolScope.GLOBAL
self.bs._symbols.clearLocalTable()
#emit the instruction to terminate the program
#emit return
self.jvm.emit1byte(Opcode.RETURN)
print self.bs.peekToken().toString(), "PEEK TOKEN^@#*&^@#*^"
if self.bs.peekToken().getTokenType() == TokenType.END_FILE:
self.loopStatus = Status.EXIT
del struct
#self.jvm.emit1byte(Opcode.RETURN)
#self.loopStatus = Status.EXIT
# No Op
def _NO(self):
print "NO()"
pass
# Error
def _xx(self):
print "XX()"
#self.setError("Invalid token sequence.")
#raise CompilerException("Invalid token sequence.")
pass
def test_iff_replacement(self):
with self.subTest():
self.assertEqual(EP.standardize_string('a iff b'), 'a = b')
with self.subTest():
self.assertEqual(EP.standardize_string('testiff'), 'testiff')
with self.subTest():
self.assertEqual(EP.standardize_string('ifftest'), 'ifftest')
with self.subTest():
self.assertEqual(EP.standardize_string('a if and only if b'),
'a = b')
with self.subTest():
self.assertEqual(EP.standardize_string('a <-> b'), 'a = b')
with self.subTest():
self.assertEqual(EP.standardize_string('a <> b'), 'a = b')
with self.subTest():
self.assertEqual(EP.standardize_string('a == b'), 'a = b')
with self.subTest():
self.assertEqual(EP.standardize_string('='), '=')
with self.subTest():
self.assertEqual(EP.standardize_string('testif and only if b'),
'testif * only > b')
with self.subTest():
self.assertEqual(EP.standardize_string('a if and only iftest'),
'a > * only iftest')
with self.subTest():
self.assertEqual(EP.standardize_string('a === b'), 'a = b')
import sys
sys.path.append("../")
from ExpressionParser import *
exp = ExpressionParser()
exp.testExpression()
def test_space_replacement(self):
self.assertEqual(EP.standardize_string('a b'), 'a b')
