class TestParserExtensibility(TestCase): def setUp(self): self.ts_parser = TSSmtLibParser() self.smt_parser = SmtLibParser() def test_wrong(self): txt = """ (declare-fun A () Bool) (declare-fun B () Bool) (assert (and A B)) (check-sat) (exit) """ with self.assertRaises(UnknownSmtLibCommandError): self.ts_parser.get_ts(cStringIO(txt)) script = self.smt_parser.get_script(cStringIO(txt)) self.assertIsNotNone(script) def test_basic(self): txt = """ (declare-fun A () Bool) (declare-fun B () Bool) (init (and A B)) (trans (=> A (next A))) (exit) """ with self.assertRaises(UnknownSmtLibCommandError): self.smt_parser.get_script(cStringIO(txt)) ts = self.ts_parser.get_ts(cStringIO(txt)) self.assertIsNotNone(ts)
def __init__(self, env=None, interactive=False): SmtLibParser.__init__(self, env, interactive) # Add new commands # # The mapping function takes care of consuming the command # name from the input stream, e.g., '(init' . Therefore, # _cmd_init will receive the rest of the stream, in our # example, '(and A B)) ...' self.commands["init"] = self._cmd_init self.commands["trans"] = self._cmd_trans # Remove unused commands # # If some commands are not compatible with the extension, they # can be removed from the parser. If found, they will cause # the raising of the exception UnknownSmtLibCommandError del self.commands["check-sat"] del self.commands["get-value"] # ... # Add 'next' function # # New operators can be added similarly as done for commands. # e.g., 'next'. The helper function _operator_adapter, # simplifies the writing of such extensions. In this example, # we will rewrite the content of the next without the need of # introducing a new pySMT operator. If you are interested in a # simple way of handling new operators in pySMT see # pysmt.test.test_dwf. self.interpreted["next"] = self._operator_adapter(self._next_var)
def parse(self, file_id): fname = SMTLIB_FILE_PATTERN % file_id reset_env() parser = SmtLibParser() script = parser.get_script_fname(fname) self.assertIsNotNone(script) return script
def test_parse_bvconst_width(self): smtlib_input = "(assert (> #x10 #x10))" parser = SmtLibParser() buffer_ = cStringIO(smtlib_input) expr = parser.get_script(buffer_).get_last_formula() const = expr.args()[0] self.assertEqual(const.bv_width(), 8, const.bv_width())
def test_dumped_logic(self): # Dumped logic matches the logic in the example fs = get_example_formulae() for (f_out, _, _, logic) in fs: buf_out = cStringIO() script_out = smtlibscript_from_formula(f_out) script_out.serialize(outstream=buf_out) buf_in = cStringIO(buf_out.getvalue()) parser = SmtLibParser() script_in = parser.get_script(buf_in) for cmd in script_in: if cmd.name == "set-logic": logic_in = cmd.args[0] if logic == logics.QF_BOOL: self.assertEqual(logic_in, logics.QF_UF) elif logic == logics.BOOL: self.assertEqual(logic_in, logics.LRA) else: self.assertEqual(logic_in, logic, script_in) break else: # Loops exited normally print("-"*40) print(script_in)
def test_define_funs_arg_and_fun(self): smtlib_script = "\n".join(['(define-fun f ((n Int)) Int n)', '(declare-fun n () Real)']) stream = cStringIO(smtlib_script) parser = SmtLibParser() _ = parser.get_script(stream) # No exceptions are thrown self.assertTrue(True)
def test_define_funs_same_args(self): # n is defined once as an Int and once as a Real smtlib_script = "\n".join(['(define-fun f ((n Int)) Int n)', '(define-fun f ((n Real)) Real n)']) stream = cStringIO(smtlib_script) parser = SmtLibParser() _ = parser.get_script(stream) # No exceptions are thrown self.assertTrue(True)
def test_parse_declare_const(self): smtlib_input = """ (declare-const s Int) (check-sat)""" parser = SmtLibParser() buffer_ = cStringIO(smtlib_input) script = parser.get_script(buffer_) self.assertIsNotNone(script)
def test_smtlib_define_fun_serialization(self): smtlib_input = "(define-fun init ((x Bool)) Bool (and x (and x (and x (and x (and x (and x x)))))))" parser = SmtLibParser() buffer_ = cStringIO(smtlib_input) s = parser.get_script(buffer_) for c in s: res = c.serialize_to_string(daggify=False) self.assertEqual(res.replace('__x0', 'x'), smtlib_input)
def smtlib_solver(self, stream): smt_parser = SmtLibParser() name = self.args.solver if name == "auto": solver = Solver() else: solver = Solver(name=name) for cmd in smt_parser.get_command_generator(stream): r = evaluate_command(cmd, solver) self.print_result(cmd, r)
def test_complex_annotations_values(self): source ="""\ (declare-fun |"v__AT0"| () Bool) (define-fun .def_1 () Bool (! |"v__AT0"| :next (+ 1 meaningless))) """ buf = StringIO(source) parser = SmtLibParser() script = parser.get_script(buf) ann = script.annotations v0 = self.env.formula_manager.get_symbol('"v__AT0"') v1_str = next(iter(ann[v0]["next"])) self.assertEquals(v1_str, "(+ 1 meaningless)")
def test_annotations_colon_values(self): source ="""\ (declare-fun |"v__AT0"| () Bool) (define-fun .def_1 () Bool (! |"v__AT0"| :next :this_is_considered_a_value)) """ buf = StringIO(source) parser = SmtLibParser() script = parser.get_script(buf) ann = script.annotations v0 = self.env.formula_manager.get_symbol('"v__AT0"') v1_str = next(iter(ann[v0]["next"])) self.assertEquals(v1_str, ":this_is_considered_a_value")
def test_parse_exception(self): from pysmt.exceptions import PysmtSyntaxError smtlib_input = "(declare-const x x x Int)" +\ "(check-sat)" parser = SmtLibParser() buffer_ = cStringIO(smtlib_input) try: parser.get_script(buffer_) self.assertFalse(True) except PysmtSyntaxError as ex: self.assertEqual(ex.pos_info[0], 0) self.assertEqual(ex.pos_info[1], 19)
def test_all_parsing(self): # Create a small file that tests all commands of smt-lib 2 parser = SmtLibParser() nie = 0 for cmd in DEMO_SMTSCRIPT: try: next(parser.get_command_generator(cStringIO(cmd))) except NotImplementedError: nie += 1 # There are currently 3 not-implemented commands self.assertEquals(nie, 3)
def __init__(self, env=None, interactive=False): SmtLibParser.__init__(self, env, interactive) # Add new commands self.commands["init"] = self._cmd_init self.commands["trans"] = self._cmd_trans # Remove unused commands del self.commands["check-sat"] del self.commands["get-value"] # ... # Add 'next' function self.interpreted["next"] = self._operator_adapter(self._next_var)
def test_interpreting_annotations(self): source ="""\ (declare-fun |"v__AT0"| () Bool) (declare-fun |"v__AT1"| () Bool) (define-fun .def_1 () Bool (! |"v__AT0"| :next |"v__AT1"|)) """ buf = StringIO(source) parser = SmtLibParser() script = parser.get_script(buf) ann = script.annotations v0 = self.env.formula_manager.get_symbol('"v__AT0"') v1_str = next(iter(ann[v0]["next"])) self.env.formula_manager.get_symbol(v1_str) self.assertEquals(v1_str, '"v__AT1"')
def test_string_constant_quote_escaping_parsing(self): script = """ (declare-const x String) (assert (= x "a""b")) (assert (= x "\"\"")) (assert (= x "\"\"\"\"")) """ p = SmtLibParser() buffer = cStringIO(script) s = p.get_script(buffer) self.assertEqual('a"b', s.commands[1].args[0].arg(1).constant_value()) self.assertEqual('"', s.commands[2].args[0].arg(1).constant_value()) self.assertEqual('""', s.commands[3].args[0].arg(1).constant_value())
def test_parse_examples_daggified_bv(self): fs = get_example_formulae() for (f_out, _, _, logic) in fs: if logic != logics.QF_BV: # See test_parse_examples_daggified continue buf_out = cStringIO() script_out = smtlibscript_from_formula(f_out) script_out.serialize(outstream=buf_out, daggify=True) buf_in = cStringIO(buf_out.getvalue()) parser = SmtLibParser() script_in = parser.get_script(buf_in) f_in = script_in.get_last_formula() self.assertValid(Iff(f_in, f_out), f_in.serialize())
def __init__(self, args, environment, logic, LOGICS=None, **options): Solver.__init__(self, environment, logic=logic, **options) self.to = self.environment.typeso if LOGICS is not None: self.LOGICS = LOGICS self.args = args self.declared_vars = set() self.declared_sorts = set() self.solver = Popen(args, stdout=PIPE, stderr=PIPE, stdin=PIPE, bufsize=-1) # Give time to the process to start-up time.sleep(0.01) self.parser = SmtLibParser(interactive=True) if PY2: self.solver_stdin = self.solver.stdin self.solver_stdout = self.solver.stdout else: self.solver_stdin = TextIOWrapper(self.solver.stdin) self.solver_stdout = TextIOWrapper(self.solver.stdout) # Initialize solver self.options(self) self.set_logic(logic)
def __init__(self, args, environment, logic, user_options=None, LOGICS=None): Solver.__init__(self, environment, logic=logic, user_options=user_options) if LOGICS is not None: self.LOGICS = LOGICS self.args = args self.declared_vars = set() self.solver = Popen(args, stdout=PIPE, stderr=PIPE, stdin=PIPE) self.parser = SmtLibParser(interactive=True) if PY2: self.solver_stdin = self.solver.stdin self.solver_stdout = self.solver.stdout else: self.solver_stdin = TextIOWrapper(self.solver.stdin) self.solver_stdout = TextIOWrapper(self.solver.stdout) self.dbg = False # Initialize solver self._send_command(SmtLibCommand(smtcmd.SET_OPTION, [":print-success", "false"])) self._send_command(SmtLibCommand(smtcmd.SET_OPTION, [":produce-models", "true"])) if self.options is not None: for o, v in iteritems(self.options): self._send_command(SmtLibCommand(smtcmd.SET_OPTION, [o, v])) self._send_command(SmtLibCommand(smtcmd.SET_LOGIC, [logic]))
def test_parse_examples(self): fs = get_example_formulae() for (f_out, _, _, logic) in fs: if logic == logics.QF_BV: # See test_parse_examples_bv continue buf_out = cStringIO() script_out = smtlibscript_from_formula(f_out) script_out.serialize(outstream=buf_out) buf_in = cStringIO(buf_out.getvalue()) parser = SmtLibParser() script_in = parser.get_script(buf_in) f_in = script_in.get_last_formula() self.assertEqual(f_in.simplify(), f_out.simplify())
def __init__(self, args, environment, logic, user_options=None, LOGICS=None): Solver.__init__(self, environment, logic=logic, user_options=user_options) # Flag used to debug interaction with the solver self.dbg = False if LOGICS is not None: self.LOGICS = LOGICS self.args = args self.declared_vars = set() self.solver = Popen(args, stdout=PIPE, stderr=PIPE, stdin=PIPE) self.parser = SmtLibParser(interactive=True) if PY2: self.solver_stdin = self.solver.stdin self.solver_stdout = self.solver.stdout else: self.solver_stdin = TextIOWrapper(self.solver.stdin) self.solver_stdout = TextIOWrapper(self.solver.stdout) # Initialize solver self.set_option(":print-success", "true") if self.options.generate_models: self.set_option(":produce-models", "true") # Redirect diagnostic output to stdout self.set_option(":diagnostic-output-channel", '"stdout"') if self.options is not None: for o,v in iteritems(self.options): self.set_option(o,v) self.set_logic(logic)
def validateModel(smtFile, modelFile): try: if (not path.exists(smtFile)): raise Exception("File not found: {}".format(smtFile)) if (not path.exists(modelFile)): raise Exception("File not found: {}".format(modelFile)) parser = SmtLibParser() formula = readSmtFile(parser, smtFile) symbols = getSymbols(parser) model = readModel(parser, modelFile) checkFullModel(model, symbols) result = simplify(formula.substitute(model)) if (not result.is_constant()): print("INVALID: Did not provide a full model.") elif (not result.is_true()): print("INVALID: Model does not evaluate to true.") else: print("VALID") except Exception as e: print(e) sys.exit(1)
def test_parse_examples(self): fs = get_example_formulae() for (f_out, _, _, logic) in fs: if logic == logics.QF_BV: # See test_parse_examples_bv continue buf = cStringIO() script_out = smtlibscript_from_formula(f_out) script_out.serialize(outstream=buf) #print(buf) buf.seek(0) parser = SmtLibParser() script_in = parser.get_script(buf) f_in = script_in.get_last_formula() self.assertEqual(f_in.simplify(), f_out.simplify())
def test_parse_examples(self): fs = get_example_formulae() for (f_out, _, _, logic) in fs: if logic == QF_BV: # See test_parse_examples_bv continue buf_out = cStringIO() script_out = smtlibscript_from_formula(f_out) script_out.serialize(outstream=buf_out) buf_in = cStringIO(buf_out.getvalue()) parser = SmtLibParser() script_in = parser.get_script(buf_in) f_in = script_in.get_last_formula() self.assertEqual(f_in, f_out)
def execute_script_fname(smtfile, logic, expected_result): """Read and call a Solver to solve the instance""" reset_env() assert os.path.exists(smtfile), smtfile parser = SmtLibParser() script = parser.get_script_fname(smtfile) try: log = script.evaluate(Solver(logic=logic)) except NoSolverAvailableError: raise SkipTest("No solver for logic %s." % logic) res = check_sat_filter(log) if res: assert expected_result == "sat" else: assert expected_result == "unsat"
def execute_script_fname(smtfile): """Read and call a Solver to solve the instance""" print(smtfile) reset_env() assert os.path.exists(smtfile) parser = SmtLibParser() solver = NoopSolver(get_env()) start = time.clock() script = parser.get_script_fname(smtfile) end = time.clock() script.evaluate(solver) res = solver.get_asserted_formula() assert res is not None return (smtfile, (end - start))
def main(args): from pysmt.logics import QF_AUFBV from pysmt.smtlib.parser import SmtLibParser from pysmt.shortcuts import get_env file = args[0] config = parseArgs(args[1:]) logging.basicConfig(format='[%(name)s] %(levelname)s: %(message)s', level=config.getLogLevel()) logger = logging.getLogger('Ablector') t = time.clock() with tempfile.NamedTemporaryFile() as tmpF: with open(os.devnull, 'w') as FNULL: process = subprocess.Popen(["boolector", "-ds", args[0]], stdout=tmpF, stderr=FNULL) process.communicate() with open(tmpF.name) as f: lines = f.readlines() isUnsat = False isCheck = False for l in lines: if l.strip() == "(assert false)": isUnsat = True if l.strip() == "(check-sat)": isCheck = True if isUnsat and isCheck: logger.info("ABLECTOR TIME: {0:.6f}".format(time.clock()-t)) print("UNSAT") exit() timeOffset = (time.clock() - t) config.addTimeOffset(timeOffset) parser = SmtLibParser() with open(file) as f: script = parser.get_script(f) a = AblectorSolver(get_env(), QF_AUFBV, config) script.evaluate(a) if a.last_result: print("SAT") # NOTE(steuber): This model also contains function assignments which were assigned in previous rounds! This means that there may be *wrong* assignments for MUL, SDIV etc! # The function assignments therefore consist of a mix of wrong (later found to be irrelevant) assignments and right assignments # a.btor.Print_model() else: print("UNSAT")
def execute_script_fname(smtfile, logic, expected_result): """Read and call a Solver to solve the instance""" reset_env() assert os.path.exists(smtfile), smtfile parser = SmtLibParser() script = parser.get_script_fname(smtfile) try: log = script.evaluate(Solver(logic=logic)) except NoSolverAvailableError: raise unittest.SkipTest("No solver for logic %s." % logic) res = check_sat_filter(log) if res: assert expected_result == "sat" else: assert expected_result == "unsat"
def __init__(self, args, environment, logic, options=None): Solver.__init__(self, environment, logic=logic, options=options) self.args = args self.declared_vars = set() self.solver = Popen(args, stdout=PIPE, stderr=PIPE, stdin=PIPE) self.parser = SmtLibParser() self.dbg = False # Initialize solver self._send_command( SmtLibCommand(smtcmd.SET_OPTION, [":print-success", "false"])) self._send_command( SmtLibCommand(smtcmd.SET_OPTION, [":produce-models", "true"])) if options is not None: for o, v in iteritems(options): self._send_command(SmtLibCommand(smtcmd.SET_OPTION, [o, v])) self._send_command(SmtLibCommand(smtcmd.SET_LOGIC, [logic]))
def test_parse_bvx_var(self): """bvX is a valid identifier.""" smtlib_input = """ (declare-fun bv1 () (_ BitVec 8)) (assert (bvult (_ bv0 8) (bvmul (bvadd bv1 (_ bv1 8)) (_ bv5 8)))) (check-sat)""" parser = SmtLibParser() buffer_ = cStringIO(smtlib_input) script = parser.get_script(buffer_) # Check Parsed result iscript = iter(script) cmd = next(iscript) self.assertEqual(cmd.name, DECLARE_FUN) bv1 = cmd.args[0] self.assertEqual(bv1.symbol_type().width, 8) cmd = next(iscript) parsed_f = cmd.args[0] target_f = BVULT(BV(0, 8), BVMul(BVAdd(bv1, BV(1, 8)), BV(5, 8))) self.assertEqual(parsed_f, target_f)
def __init__(self,var_next,init,safe,reach,goal,depth=0,id='0'): self.next = var_next self.prev = {n: v for v, n in self.next.items()} self.init = init self.safe = safe self.reach = reach self.goal = goal self.parser = SmtLibParser() self.depth=depth self.id=id self.formula_print_depth = 10
def execute_script_fname(smtfile, logic, expected_result): """Read and call a Solver to solve the instance""" reset_env() Solver = get_env().factory.Solver parser = SmtLibParser() script = parser.get_script_fname(smtfile) try: log = script.evaluate(Solver(logic=logic, incremental=False, generate_models=False)) except NoSolverAvailableError: raise SkipTest("No solver for logic %s." % logic) except SolverReturnedUnknownResultError: if not logic.quantifier_free: warnings.warn("Test (%s, %s) could not be solver due to quantifiers." % (logic, smtfile)) return raise res = check_sat_filter(log) assert expected_result == res
def _recover_declarations(self, data): decls = {'consts': {}, 'funs': {}} parser = SmtLibParser() parser._reset() script = SmtLibScript() try: for cmd in parser.get_command_generator(cStringIO(data)): script.add_command(cmd) except RuntimeError: # Oblivious hack to prevent oop pysmt-related error pass script.annotations = parser.cache.annotations symbol_decls = script.filter_by_command_name('declare-fun') self._recover_declared_symbols(symbol_decls, decls) symbol_decls = script.filter_by_command_name('declare-const') self._recover_declared_symbols(symbol_decls, decls) asserts = script.filter_by_command_name('assert') self._prune_unused_symbols(asserts, decls) return decls
def __init__(self, args, environment, logic, LOGICS=None, **options): Solver.__init__(self, environment, logic=logic, **options) self.to = self.environment.typeso if LOGICS is not None: self.LOGICS = LOGICS self.args = args self.declared_vars = [set()] self.declared_sorts = [set()] self.solver = Popen(args, stdout=PIPE, stderr=PIPE, stdin=PIPE, bufsize=-1) # Give time to the process to start-up time.sleep(0.01) self.parser = SmtLibParser(interactive=True) self.solver_stdin = TextIOWrapper(self.solver.stdin) self.solver_stdout = TextIOWrapper(self.solver.stdout) # Initialize solver self.options(self) self.set_logic(logic)
class SMTParser: def __init__(self, tokens): self.p = SmtLibParser() self.tokens = tokens def expect(self, *allowed): t = self.tokens.consume() if t not in allowed: raise PysmtSyntaxError("Invalid token, expected any of {}, got '{}'".format(allowed, t)) return t def expect_assignment_tuple(self): self.expect('(') cmd = self.expect('define-fun') vname = self.p.parse_atom(self.tokens, cmd) self.expect('(') self.expect(')') t = self.p.parse_type(self.tokens, cmd) value = self.p.get_expression(self.tokens) self.expect(')') return Symbol(vname, t), getattr(pysmt.shortcuts, t.name)(value.constant_value()) def consume_assignment_list(self): self.expect('(') self.expect('model') """Parses a list of expressions from the tokens""" assignments = [] while True: next_token = self.tokens.consume() self.tokens.add_extra_token(next_token) # push it back if next_token == ')': break assignments.append(self.expect_assignment_tuple()) self.expect(')') return assignments
def test_parse_consume(self): smt_script = """ (model (define-fun STRING_cmd_line_arg_1_1000 () String "AAAAAAAAAAAA") ) """ tokens = Tokenizer(StringIO(smt_script), interactive=True) parser = SmtLibParser() tokens.consume() tokens.consume() next_token = tokens.consume() tokens.add_extra_token(next_token) tokens.consume()
def test_parse_examples_bv(self): """For BV we represent a superset of the operators defined in SMT-LIB. We verify the correctness of the serialization process by checking the equivalence of the original and serialized expression. """ fs = get_example_formulae() for (f_out, _, _, logic) in fs: if logic != logics.QF_BV: continue buf_out = StringIO() script_out = smtlibscript_from_formula(f_out) script_out.serialize(outstream=buf_out) buf_in = StringIO(buf_out.getvalue()) parser = SmtLibParser() script_in = parser.get_script(buf_in) f_in = script_in.get_last_formula() self.assertValid(Iff(f_in, f_out))
def test_vmt(self): parser = SmtLibParser() fname = os.path.join(SMTLIB_DIR, "small_set/vmt/c432_0f.vmt") script = parser.get_script_fname(fname) ann = script.annotations self.assertIn("A_1__AT0 ->", str(ann)) a1 = Symbol("A_1__AT0") self.assertIn(a1, ann) self.assertTrue(ann.has_annotation(a1, "next")) self.assertFalse(ann.has_annotation(a1, "non-existent")) self.assertTrue(ann.has_annotation(a1, "next", "A_1__AT1")) self.assertFalse(ann.has_annotation(a1, "next", "non-existent")) self.assertIn("A_1__AT1", ann.annotations(a1)["next"]) self.assertIn("A_1__AT1", ann[a1]["next"]) curr_a1 = ann.all_annotated_formulae("next", "A_1__AT1") self.assertEqual(curr_a1, set([a1]))
def load_from(self, infile): """ Loads the encoding from an input file. """ with open(infile, 'r') as fp: file_content = fp.readlines() # empty intervals for the standard encoding self.intvs, self.imaps, self.ivars = {}, {}, {} for line in file_content: if line[0] != ';': break elif line.startswith('; i '): f, arr = line[4:].strip().split(': ', 1) f = f.replace('-', '_') self.intvs[f], self.imaps[f], self.ivars[f] = [], {}, [] for i, pair in enumerate(arr.split(', ')): ub, symb = pair.split('<->') if ub[0] != '+': ub = float(ub) symb = Symbol(symb, typename=BOOL) self.intvs[f].append(ub) self.ivars[f].append(symb) self.imaps[f][ub] = i elif line.startswith('; features:'): self.feats = line[11:].strip().split(', ') elif line.startswith('; classes:'): self.nofcl = int(line[10:].strip()) parser = SmtLibParser() script = parser.get_script(StringIO(''.join(file_content))) self.enc = script.get_last_formula()
def test_parse_examples_bv(self): """For BV we represent a superset of the operators defined in SMT-LIB. We verify the correctness of the serialization process by checking the equivalence of the original and serialized expression. """ fs = get_example_formulae() for (f_out, _, _, logic) in fs: if logic != logics.QF_BV: continue buf_out = cStringIO() script_out = smtlibscript_from_formula(f_out) script_out.serialize(outstream=buf_out) buf_in = cStringIO(buf_out.getvalue()) parser = SmtLibParser() script_in = parser.get_script(buf_in) f_in = script_in.get_last_formula() self.assertValid(Iff(f_in, f_out))
def main(): config = parseArgs(sys.argv[1:]) logging.basicConfig(format='[%(name)s] %(levelname)s: %(message)s', level=config.getLogLevel()) folderName = os.path.join(os.path.dirname(__file__), 'smtlib') onlyfiles = [ os.path.join(folderName, f) for f in os.listdir(folderName) if os.path.isfile(os.path.join(folderName, f)) and f.endswith(".smt2") ] for filePath in onlyfiles: with open(filePath, "r") as f: print(filePath) reset_env() parser = SmtLibParser() parser._reset() script = parser.get_script(f) status = "unsat" for f in script.filter_by_command_name("set-info"): if f.args[0] == ":status": status = f.args[1] assert (status == "sat" or status == "unsat") a = AblectorSolver(get_env(), QF_AUFBV, config) script.evaluate(a) b = BoolectorSolver(get_env(), QF_AUFBV, generate_models=True) if a.last_result: # Check if assignment actually makes sense... assert (status == "sat") with open(filePath) as f: newScriptSrc = "" content = f.readlines() for line in content: if line.startswith(";ASSERT "): varName = line[8:].strip() print(varName + ": " + a.btor.Match_by_symbol(varName).assignment) newScriptSrc += "(assert (= " + varName + " #b" + a.btor.Match_by_symbol( varName).assignment + "))\n" else: newScriptSrc += line parser._reset() scriptWithValues = parser.get_script( io.StringIO(newScriptSrc)) scriptWithValues.evaluate(b) assert (b.last_result) print("SAT") else: assert (status == "unsat") print("UNSAT")
def parse_input_formula(path): with open(path, "r") as f: script_str = f.read() parser = SmtLibParser() script = parser.get_script_fname(path) smtlib_formula = script.get_strict_formula() #verify that the input formula is in cnf assert (smtlib_formula.is_and()) for clause in smtlib_formula.args(): assert (clause.is_or()) for l in clause.args(): assert (l.is_literal()) #transform the input formula to a set of sets of literals cnf_formula = [ list(set(clause.args())) for clause in smtlib_formula.args() ] #obtain all the boolean variables of the input formula free_vars = smtlib_formula.get_free_variables() return cnf_formula, free_vars
def test_declare_sort(self): class SmtLibIgnore(SmtLibIgnoreMixin): declare_sort_history = [] def declare_sort(self, name, arity): self.declare_sort_history.append((name, arity)) mock = SmtLibIgnore() parser = SmtLibParser() smtlib_script = '\n'.join(['(declare-sort s0 0)', \ '(declare-sort s1 1)', \ '(declare-const c0 s0)', \ '(declare-const c1 (s1 Int))']) outstream = cStringIO(smtlib_script) script = parser.get_script(outstream) script.evaluate(solver=mock) self.assertEqual(len(mock.declare_sort_history), 2) s0_name, s0_arity = mock.declare_sort_history[0] s1_name, s1_arity = mock.declare_sort_history[1] self.assertEqual(s0_name, "s0") self.assertEqual(s0_arity, 0) self.assertEqual(s1_name, "s1") self.assertEqual(s1_arity, 1)
def test_declare_sort(self): class SmtLibIgnore(SmtLibIgnoreMixin): declare_sort_history = [] def declare_sort(self, name, arity): self.declare_sort_history.append((name, arity)) mock = SmtLibIgnore() parser = SmtLibParser() smtlib_script = '\n'.join(['(declare-sort s0 0)', \ '(declare-sort s1 1)', \ '(declare-const c0 s0)', \ '(declare-const c1 (s1 Int))']) outstream = StringIO(smtlib_script) script = parser.get_script(outstream) script.evaluate(solver=mock) self.assertEqual(len(mock.declare_sort_history), 2) s0_name, s0_arity = mock.declare_sort_history[0] s1_name, s1_arity = mock.declare_sort_history[1] self.assertEqual(s0_name, "s0") self.assertEqual(s0_arity, 0) self.assertEqual(s1_name, "s1") self.assertEqual(s1_arity, 1)
def generate_special_paths(con_loc, ppc_str): parser = SmtLibParser() special_list = [] script = parser.get_script(cStringIO(ppc_str)) path_condition = script.get_last_formula() angelic_count = int(len(re.findall("angelic!(.+?)!0", str(path_condition.serialize()))) / 4) if angelic_count > 1: false_path = generate_false_path(path_condition) true_path = generate_true_path(path_condition) if true_path: special_list.append((con_loc, true_path, len(str(true_path.serialize())))) if false_path: special_list.append((con_loc, false_path, len(str(false_path.serialize())))) return special_list
def test_dumped_logic(self): # Dumped logic matches the logic in the example fs = get_example_formulae() for (f_out, _, _, logic) in fs: buf_out = cStringIO() script_out = smtlibscript_from_formula(f_out) script_out.serialize(outstream=buf_out) buf_in = cStringIO(buf_out.getvalue()) parser = SmtLibParser() script_in = parser.get_script(buf_in) for cmd in script_in: if cmd.name == "set-logic": logic_in = cmd.args[0] if logic == logics.QF_BOOL: self.assertEqual(logic_in, logics.QF_UF) elif logic == logics.BOOL: self.assertEqual(logic_in, logics.LRA) else: self.assertEqual(logic_in, logic, script_in) break else: # Loops exited normally print("-" * 40) print(script_in)
def generate_flipped_path(ppc): """ This function will check if a selected path is feasible ppc : partial path conditoin at chosen control loc chosen_control_loc: branch location selected for flip returns satisfiability of the negated path """ parser = SmtLibParser() script = parser.get_script(cStringIO(ppc)) formula = script.get_last_formula() prefix = formula.arg(0) constraint = formula.arg(1) new_path = And(prefix, Not(constraint)) assert str(new_path.serialize()) != str(formula.serialize()) return new_path
def validateModel(smtFile, modelFile, inputFile): try: if not path.exists(smtFile): raise Exception("File not found: {}".format(smtFile)) if not path.exists(modelFile): raise Exception("File not found: {}".format(modelFile)) if path.getsize(modelFile) == 0: print("model_validator_status=UNKNOWN") print("model_validator_error=no_output") sys.exit(0) parser = SmtLibParser() (formula, symbols) = readSmtFile(parser, smtFile) model, interpretation = readModel(parser, modelFile, inputFile) checkFullModel(model, interpretation, symbols) simplifier = SmtLibModelValidationSimplifier() result = simplifier.simplify(formula.substitute(model, interpretation)) if result.is_false(): print("model_validator_status=INVALID") print("model_validator_error=model_evaluates_to_false") elif result.is_true(): print("model_validator_status=VALID") print("model_validator_error=none") print("starexec-result=sat") else: print("model_validator_status=UNKNOWN") print("model_validator_error=not_full_model") except Exception as e: print("model_validator_status=UNKNOWN") print("model_validator_error=unhandled_exception") print("model_validator_exception=\"{}\"".format( str(e).replace("'", "\\'").replace('"', '\\"').replace('\n', ' '))) sys.exit(0)
def generate_path_for_negation(): constraint_list = [] parser = SmtLibParser() emitter.normal("\tgenerating path for negation of patch constraint") for control_loc, sym_path in values.LIST_PPC: if control_loc == values.CONF_LOC_PATCH: script = parser.get_script(cStringIO(sym_path)) formula = script.get_last_formula() patch_constraint = formula if formula.is_and(): patch_constraint = formula.arg(1) constraint_list.append(patch_constraint.serialize()) if not constraint_list: return None last_sym_path = values.LAST_PPC_FORMULA # script = parser.get_script(cStringIO(last_sym_path)) # formula = script.get_last_formula() negated_path = None while constraint_list: constraint = last_sym_path if last_sym_path.is_and(): constraint = last_sym_path.arg(1) constraint_str = constraint.serialize() if constraint_str in constraint_list: constraint_list.remove(constraint_str) constraint = Not(constraint) if negated_path is None: negated_path = constraint else: negated_path = And(negated_path, constraint) if last_sym_path.is_and(): last_sym_path = last_sym_path.arg(0) else: break negated_path = And(negated_path, last_sym_path) return negated_path
import sys import time import json from six.moves import cStringIO from pysmt.shortcuts import Solver from pysmt.smtlib.parser import SmtLibParser if __name__ == '__main__': filename = sys.argv[1] solver_name = sys.argv[2] smt_file = open(filename, 'r').read().replace('\r', "") parser = SmtLibParser() script = parser.get_script(cStringIO(smt_file)) # with Solver(name=solver_name) as solver: solver = Solver(name=solver_name) error = False s = time.time() try: log = script.evaluate(solver) e = time.time() except: e = time.time() error = True log = [] """ print json.dumps({
import sys import pysmt from pysmt.rewritings import PrenexNormalizer, Ackermannizer from pysmt.smtlib.script import SmtLibScript from pysmt.smtlib.parser import SmtLibParser from pysmt.shortcuts import to_smtlib, write_smtlib from six.moves import cStringIO parser = SmtLibParser() with open("/home/yoniz/git/hermes/dispatcher/dispatcher/examples/Assessment2/nodtbbg.smt2", 'r') as f: smtlib_str = f.read(); stream = cStringIO(smtlib_str) script = parser.get_script(stream) formula = script.get_last_formula() ackermanization = Ackermannizer() ackermized_formula = ackermanization.do_ackermannization(formula) write_smtlib(ackermized_formula, "/home/yoniz/git/hermes/dispatcher/dispatcher/examples/Assessment2/nodtbbg_ack.smt2" )
def test_define_funs_arg_and_fun(self): smtlib_script = "\n".join( ['(define-fun f ((n Int)) Int n)', '(declare-fun n () Real)']) stream = cStringIO(smtlib_script) parser = SmtLibParser() script = parser.get_script(stream)
def __init__(self, tokens): self.p = SmtLibParser() self.tokens = tokens
class SmtLibSolver(Solver): """Wrapper for using a solver via textual SMT-LIB interface. The solver is launched in a subprocess using args as arguments of the executable. Interaction with the solver occurs via pipe. """ def __init__(self, args, environment, logic, user_options=None, LOGICS=None): Solver.__init__(self, environment, logic=logic, user_options=user_options) if LOGICS is not None: self.LOGICS = LOGICS self.args = args self.declared_vars = set() self.solver = Popen(args, stdout=PIPE, stderr=PIPE, stdin=PIPE) self.parser = SmtLibParser() if PY2: self.solver_stdin = self.solver.stdin self.solver_stdout = self.solver.stdout else: self.solver_stdin = TextIOWrapper(self.solver.stdin) self.solver_stdout = TextIOWrapper(self.solver.stdout) self.dbg = False # Initialize solver self._send_command( SmtLibCommand(smtcmd.SET_OPTION, [":print-success", "false"])) self._send_command( SmtLibCommand(smtcmd.SET_OPTION, [":produce-models", "true"])) if self.options is not None: for o, v in iteritems(self.options): self._send_command(SmtLibCommand(smtcmd.SET_OPTION, [o, v])) self._send_command(SmtLibCommand(smtcmd.SET_LOGIC, [logic])) def get_default_options(self, logic=None, user_options=None): res = {} for o, v in iteritems(user_options): if o not in ["generate_models", "unsat_cores_mode"]: res[o] = v return res def _send_command(self, cmd): if self.dbg: print("Sending: " + cmd.serialize_to_string()) cmd.serialize(self.solver_stdin, daggify=True) self.solver_stdin.write("\n") self.solver_stdin.flush() def _get_answer(self): res = self.solver_stdout.readline().strip() if self.dbg: print("Read: " + str(res)) return res def _get_value_answer(self): lst = self.parser.get_assignment_list(self.solver_stdout) if self.dbg: print("Read: " + str(lst)) return lst def _declare_variable(self, symbol): cmd = SmtLibCommand(smtcmd.DECLARE_FUN, [symbol]) self._send_command(cmd) self.declared_vars.add(symbol) def solve(self, assumptions=None): assert assumptions is None self._send_command(SmtLibCommand(smtcmd.CHECK_SAT, [])) ans = self._get_answer() if ans == "sat": return True elif ans == "unsat": return False elif ans == "unknown": raise SolverReturnedUnknownResultError else: raise UnknownSolverAnswerError("Solver returned: " + ans) def reset_assertions(self): self._send_command(SmtLibCommand(smtcmd.RESET_ASSERTIONS, [])) return def add_assertion(self, formula, named=None): deps = formula.get_free_variables() for d in deps: if d not in self.declared_vars: self._declare_variable(d) self._send_command(SmtLibCommand(smtcmd.ASSERT, [formula])) def push(self, levels=1): self._send_command(SmtLibCommand(smtcmd.PUSH, [levels])) def pop(self, levels=1): self._send_command(SmtLibCommand(smtcmd.POP, [levels])) def get_value(self, item): self._send_command(SmtLibCommand(smtcmd.GET_VALUE, [item])) lst = self._get_value_answer() assert len(lst) == 1 assert len(lst[0]) == 2 return lst[0][1] def print_model(self, name_filter=None): if name_filter is not None: raise NotImplementedError for v in self.declared_vars: print("%s = %s" % (v, self.get_value(v))) def get_model(self): assignment = {} for s in self.environment.formula_manager.get_all_symbols(): if s.is_term(): v = self.get_value(s) assignment[s] = v return EagerModel(assignment=assignment, environment=self.environment) def exit(self): self._send_command(SmtLibCommand(smtcmd.EXIT, [])) self.solver_stdin.close() self.solver_stdout.close() self.solver.terminate() return