def test_trivial(self):
self.assertEqual(yacc.parse('p'), p)
self.assertEqual(yacc.parse('~q'), ~q)
self.assertEqual(yacc.parse('1'), t)
self.assertEqual(yacc.parse('0'), f)
self.assertEqual(yacc.parse(r'p \/ q'), BinaryDisjunction(p, q))
self.assertEqual(yacc.parse(r'p /\ q'), BinaryConjunction(p, q))
self.assertEqual(yacc.parse(r'p -> q'), BinaryImplication(p, q))
def test_simplify(self):
self.assertEqual(yacc.parse(r'p /\ p'), p)
self.assertEqual(yacc.parse(r'p /\ ~p'), f)
self.assertEqual(yacc.parse(r'p \/ p'), p)
self.assertEqual(yacc.parse(r'p \/ 1'), t)
self.assertEqual(yacc.parse(r'p /\ 0'), f)
self.assertEqual(yacc.parse('(p) -> ~(p)'), ~p)
self.assertEqual(yacc.parse('~~((~p)) -> 0'), p)
def _external_tests():
from Environ import Environ # Circular dependency.
environ = Environ()
while 1:
try:
s = raw_input("squeamish> ")
except EOFError:
break
if not s:
continue
print evaluate(yacc.parse(s), environ)
def test_priority(self):
self.assertEqual(yacc.parse(r'~x \/ y'), yacc.parse(r'(~x) \/ y'))
self.assertEqual(yacc.parse(r'~x /\ y'), yacc.parse(r'(~x) /\ y'))
self.assertEqual(yacc.parse(r'x /\ y \/ z'),
yacc.parse(r'(x /\ y) \/ z'))
# There are no general agreement how to interpret this line, so one have to use brackets here.
self.assertRaises(ParserException, yacc.parse, r'x -> y -> z')
def test_readability(self):
formula = r'(p->q) /\ (q->s) /\ (s->r) /\ (r->~p) /\ p'
parsed = yacc.parse(formula)
self.assertEqual(
parsed,
BinaryConjunction(
BinaryConjunction(
BinaryConjunction(
BinaryConjunction(
BinaryImplication(Variable('p'), Variable('q')),
BinaryImplication(Variable('q'), Variable('s'))),
BinaryImplication(Variable('s'), Variable('r'))),
BinaryImplication(Variable('r'),
NegationOperator(Variable('p')))),
Variable('p')))
def mainLoop(self):
"""This is the main loop."""
while 1:
try:
line = ""
while not self.isComplete(line):
line += self.readline(line)
value = evaluate(yacc.parse(line), self.environ)
if self.isStdin and value:
print value
except EOFError:
self.input.close()
break
except:
print_exception(*(sys.exc_info()))
def _internal_tests():
from Environ import Environ # Circular dependency.
plus = Symbol(name = "+")
tests = [
("()", None),
("(' 1 2)", [1, 2]),
("(+ 1 2)", 3),
("(+ (+ 1 2) 3)", 6),
("(+ 1(+ 2 3))", 6),
('(+ "foo" "bar")', "foobar")
]
for i in tests:
(s, value) = i
try:
returned = evaluate(yacc.parse(s), Environ())
assert value == returned
except AssertionError, e:
sys.stderr.write("squeamish: test failed: %s led to %s\n" % (
`i`, returned))
raise AssertionError
#!/usr/bin/python
# -----------------------------------------------------------------------------
# calc.py
#
# A simple calculator with variables -- all in one file.
# -----------------------------------------------------------------------------
from lexer import lex
from parser import yacc
while 1:
try:
s = input('calc > ') # Use raw_input on Python 2
except EOFError:
break
lexer = lex.input(s)
for tok in iter(lex.token, None):
print("({0}, {1})".format(tok.type, tok.value))
print("Result: ", end='')
yacc.parse(s)
def execute(filename, context):
with open(filename, "r") as file:
source = file.read()
yacc.parse(source)(c)
def execute(filename, context): with open(filename, "r") as file: source = file.read() yacc.parse(source)(c)
explored = definitions[symbol].used>1
#TODO understand why this test is even needed
diff = other!=symbol #avoid loops
if is_var and explored and args.back and diff:
print quote(other), "->", quote(symbol), "[style=dashed];"
print >>sys.stderr, "returning", repr(id)
return id
if __name__=="__main__":
import sys
import argparse
p = argparse.ArgumentParser()
p.add_argument("script", help="input file")
p.add_argument("--back", action="store_true", help="show backreferences")
p.add_argument("--unused", action="store_true", help="show unused rules")
args = p.parse_args()
if args.script == "-":
inp = sys.stdin.read()
else:
inp = open(args.script, "r").read()
axiom = yacc.parse(inp, debug=("-d" in sys.argv))
if axiom == None:
print >>sys.stderr, "No PLY rules could be found."
else:
to_gv()
if args.unused:
for v in definitions:
if not definitions[v].used:
print >>sys.stderr, repr(v), "is never used."
r = self.out == self._exp tr = "passed" if r else "***FAILED***" print self._name, tr if not r: print "\texpected:", repr(self._exp) print "\tgot:", repr(self.out) print return r if __name__ == "__main__": import sys import os if len(sys.argv) > 1: res = True for f in sys.argv[1:]: base = os.path.splitext(f)[0] exp = base + ".exp" if os.path.exists(exp) and exp!=f: with open(exp, "r") as file: expected = file.read() with open(f, "r") as file: source = file.read() o = TestOutput(os.path.basename(base), expected) c = Context(o) yacc.parse(source)(c) res = res and o.test() sys.exit(int(not res)) else: print >>sys.stderr, "usage: %s test [test...]" % sys.argv[0] sys.exit(2)
