mirrors/z3
3
0
Fork 0
mirror of https://github.com/Z3Prover/z3 synced 2025-11-04 05:19:11 +00:00
Code Activity

Fix some PEP-8 violations in Python code (#5295)

Browse source 
* reformat python code using autopep8

* manually wrap some too long lines and adjust some checks

* run autopep8 in aggressive mode

* run autopep8 in very aggressive mode

* manually reformat z3types.py

* unify: use double quotes

* use sys.version_info instead of sys.version

* drop accidentally commited src/util/z3_version.h
This commit is contained in:
Gram 2021-05-23 19:27:55 +02:00 • committed by GitHub
parent f1545b04d2
commit 3d8865d925
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
7 changed files with 1669 additions and 910 deletions
Download patch file Download diff file Expand all files Collapse all files

849
src/api/python/z3/z3.py
View file

File diff suppressed because it is too large Load diff

10
src/api/python/z3/z3num.py
View file

@ -12,12 +12,14 @@ from fractions import Fraction
from .z3 import _get_ctx from .z3 import _get_ctx
def _to_numeral(num, ctx=None): def _to_numeral(num, ctx=None):
if isinstance(num, Numeral): if isinstance(num, Numeral):
return num return num
else: else:
return Numeral(num, ctx) return Numeral(num, ctx)
class Numeral: class Numeral:
""" """
A Z3 numeral can be used to perform computations over arbitrary A Z3 numeral can be used to perform computations over arbitrary
@ -85,6 +87,7 @@ class Numeral:
[2.8538479564?] [2.8538479564?]
""" """
def __init__(self, num, ctx=None): def __init__(self, num, ctx=None):
if isinstance(num, Ast): if isinstance(num, Ast):
self.ast = num self.ast = num
@ -151,7 +154,6 @@ class Numeral:
assert(self.is_rational()) assert(self.is_rational())
return Numeral(Z3_get_numerator(self.ctx_ref(), self.as_ast()), self.ctx) return Numeral(Z3_get_numerator(self.ctx_ref(), self.as_ast()), self.ctx)
def is_irrational(self): def is_irrational(self):
""" Return True if the numeral is irrational. """ Return True if the numeral is irrational.
@ -169,7 +171,7 @@ class Numeral:
""" """
assert(self.is_integer()) assert(self.is_integer())
if sys.version_info[0] >= 3: if sys.version_info.major >= 3:
return int(Z3_get_numeral_string(self.ctx_ref(), self.as_ast())) return int(Z3_get_numeral_string(self.ctx_ref(), self.as_ast()))
else: else:
return long(Z3_get_numeral_string(self.ctx_ref(), self.as_ast())) return long(Z3_get_numeral_string(self.ctx_ref(), self.as_ast()))
@ -440,7 +442,6 @@ class Numeral:
""" """
return self < other return self < other
def __le__(self, other): def __le__(self, other):
""" Return True if `self <= other`. """ Return True if `self <= other`.
@ -523,6 +524,7 @@ class Numeral:
def ctx_ref(self): def ctx_ref(self):
return self.ctx.ref() return self.ctx.ref()
def eval_sign_at(p, vs): def eval_sign_at(p, vs):
""" """
Evaluate the sign of the polynomial `p` at `vs`. `p` is a Z3 Evaluate the sign of the polynomial `p` at `vs`. `p` is a Z3
@ -547,6 +549,7 @@ def eval_sign_at(p, vs):
_vs[i] = vs[i].ast _vs[i] = vs[i].ast
return Z3_algebraic_eval(p.ctx_ref(), p.as_ast(), num, _vs) return Z3_algebraic_eval(p.ctx_ref(), p.as_ast(), num, _vs)
def isolate_roots(p, vs=[]): def isolate_roots(p, vs=[]):
""" """
Given a multivariate polynomial p(x_0, ..., x_{n-1}, x_n), returns the Given a multivariate polynomial p(x_0, ..., x_{n-1}, x_n), returns the
@ -574,4 +577,3 @@ def isolate_roots(p, vs=[]):
_vs[i] = vs[i].ast _vs[i] = vs[i].ast
_roots = AstVector(Z3_algebraic_roots(p.ctx_ref(), p.as_ast(), num, _vs), p.ctx) _roots = AstVector(Z3_algebraic_roots(p.ctx_ref(), p.as_ast(), num, _vs), p.ctx)
return [Numeral(r) for r in _roots] return [Numeral(r) for r in _roots]

2
src/api/python/z3/z3poly.py
View file

@ -8,6 +8,7 @@
from .z3 import * from .z3 import *
def subresultants(p, q, x): def subresultants(p, q, x):
""" """
Return the non-constant subresultants of 'p' and 'q' with respect to the "variable" 'x'. Return the non-constant subresultants of 'p' and 'q' with respect to the "variable" 'x'.
@ -29,6 +30,7 @@ def subresultants(p, q, x):
""" """
return AstVector(Z3_polynomial_subresultants(p.ctx_ref(), p.as_ast(), q.as_ast(), x.as_ast()), p.ctx) return AstVector(Z3_polynomial_subresultants(p.ctx_ref(), p.as_ast(), q.as_ast(), x.as_ast()), p.ctx)
if __name__ == "__main__": if __name__ == "__main__":
import doctest import doctest
if doctest.testmod().failed: if doctest.testmod().failed:

399
src/api/python/z3/z3printer.py
View file

@ -5,11 +5,12 @@
# #
# Author: Leonardo de Moura (leonardo) # Author: Leonardo de Moura (leonardo)
############################################ ############################################
import sys, io import sys
import io
# We want to import submodule z3 here, but there's no way # We want to import submodule z3 here, but there's no way
# to do that that works correctly on both Python 2 and 3. # to do that that works correctly on both Python 2 and 3.
if sys.version < '3': if sys.version_info.major < 3:
# In Python 2: an implicit-relative import of submodule z3. # In Python 2: an implicit-relative import of submodule z3.
# In Python 3: an undesirable import of global package z3. # In Python 3: an undesirable import of global package z3.
import z3 import z3
@ -22,6 +23,7 @@ from .z3consts import *
from .z3core import * from .z3core import *
from ctypes import * from ctypes import *
def _z3_assert(cond, msg): def _z3_assert(cond, msg):
if not cond: if not cond:
raise Z3Exception(msg) raise Z3Exception(msg)
@ -32,33 +34,34 @@ def _z3_assert(cond, msg):
# #
############################## ##############################
# Z3 operator names to Z3Py # Z3 operator names to Z3Py
_z3_op_to_str = { _z3_op_to_str = {
Z3_OP_TRUE : 'True', Z3_OP_FALSE : 'False', Z3_OP_EQ : '==', Z3_OP_DISTINCT : 'Distinct', Z3_OP_TRUE: "True", Z3_OP_FALSE: "False", Z3_OP_EQ: "==", Z3_OP_DISTINCT: "Distinct",
Z3_OP_ITE : 'If', Z3_OP_AND : 'And', Z3_OP_OR : 'Or', Z3_OP_IFF : '==', Z3_OP_XOR : 'Xor', Z3_OP_ITE: "If", Z3_OP_AND: "And", Z3_OP_OR: "Or", Z3_OP_IFF: "==", Z3_OP_XOR: "Xor",
Z3_OP_NOT : 'Not', Z3_OP_IMPLIES : 'Implies', Z3_OP_IDIV : '/', Z3_OP_MOD : '%', Z3_OP_NOT: "Not", Z3_OP_IMPLIES: "Implies", Z3_OP_IDIV: "/", Z3_OP_MOD: "%",
Z3_OP_TO_REAL : 'ToReal', Z3_OP_TO_INT : 'ToInt', Z3_OP_POWER : '**', Z3_OP_IS_INT : 'IsInt', Z3_OP_TO_REAL: "ToReal", Z3_OP_TO_INT: "ToInt", Z3_OP_POWER: "**", Z3_OP_IS_INT: "IsInt",
Z3_OP_BADD : '+', Z3_OP_BSUB : '-', Z3_OP_BMUL : '*', Z3_OP_BOR : '|', Z3_OP_BAND : '&', Z3_OP_BADD: "+", Z3_OP_BSUB: "-", Z3_OP_BMUL: "*", Z3_OP_BOR: "|", Z3_OP_BAND: "&",
Z3_OP_BNOT : '~', Z3_OP_BXOR : '^', Z3_OP_BNEG : '-', Z3_OP_BUDIV : 'UDiv', Z3_OP_BSDIV : '/', Z3_OP_BSMOD : '%', Z3_OP_BNOT: "~", Z3_OP_BXOR: "^", Z3_OP_BNEG: "-", Z3_OP_BUDIV: "UDiv", Z3_OP_BSDIV: "/", Z3_OP_BSMOD: "%",
Z3_OP_BSREM : 'SRem', Z3_OP_BUREM : 'URem', Z3_OP_EXT_ROTATE_LEFT : 'RotateLeft', Z3_OP_EXT_ROTATE_RIGHT : 'RotateRight', Z3_OP_BSREM: "SRem", Z3_OP_BUREM: "URem", Z3_OP_EXT_ROTATE_LEFT: "RotateLeft", Z3_OP_EXT_ROTATE_RIGHT: "RotateRight",
Z3_OP_SLEQ : '<=', Z3_OP_SLT : '<', Z3_OP_SGEQ : '>=', Z3_OP_SGT : '>', Z3_OP_SLEQ: "<=", Z3_OP_SLT: "<", Z3_OP_SGEQ: ">=", Z3_OP_SGT: ">",
Z3_OP_ULEQ : 'ULE', Z3_OP_ULT : 'ULT', Z3_OP_UGEQ : 'UGE', Z3_OP_UGT : 'UGT', Z3_OP_ULEQ: "ULE", Z3_OP_ULT: "ULT", Z3_OP_UGEQ: "UGE", Z3_OP_UGT: "UGT",
Z3_OP_SIGN_EXT : 'SignExt', Z3_OP_ZERO_EXT : 'ZeroExt', Z3_OP_REPEAT : 'RepeatBitVec', Z3_OP_SIGN_EXT: "SignExt", Z3_OP_ZERO_EXT: "ZeroExt", Z3_OP_REPEAT: "RepeatBitVec",
Z3_OP_BASHR : '>>', Z3_OP_BSHL : '<<', Z3_OP_BLSHR : 'LShR', Z3_OP_BASHR: ">>", Z3_OP_BSHL: "<<", Z3_OP_BLSHR: "LShR",
Z3_OP_CONCAT : 'Concat', Z3_OP_EXTRACT : 'Extract', Z3_OP_BV2INT : 'BV2Int', Z3_OP_CONCAT: "Concat", Z3_OP_EXTRACT: "Extract", Z3_OP_BV2INT: "BV2Int",
Z3_OP_ARRAY_MAP : 'Map', Z3_OP_SELECT : 'Select', Z3_OP_STORE : 'Store', Z3_OP_ARRAY_MAP: "Map", Z3_OP_SELECT: "Select", Z3_OP_STORE: "Store",
Z3_OP_CONST_ARRAY : 'K', Z3_OP_ARRAY_EXT : 'Ext', Z3_OP_CONST_ARRAY: "K", Z3_OP_ARRAY_EXT: "Ext",
Z3_OP_PB_AT_MOST : 'AtMost', Z3_OP_PB_LE : 'PbLe', Z3_OP_PB_GE : 'PbGe', Z3_OP_PB_EQ : 'PbEq', Z3_OP_PB_AT_MOST: "AtMost", Z3_OP_PB_LE: "PbLe", Z3_OP_PB_GE: "PbGe", Z3_OP_PB_EQ: "PbEq",
Z3_OP_SEQ_CONCAT : 'Concat', Z3_OP_SEQ_PREFIX : 'PrefixOf', Z3_OP_SEQ_SUFFIX : 'SuffixOf', Z3_OP_SEQ_CONCAT: "Concat", Z3_OP_SEQ_PREFIX: "PrefixOf", Z3_OP_SEQ_SUFFIX: "SuffixOf",
Z3_OP_SEQ_UNIT : 'Unit', Z3_OP_SEQ_CONTAINS : 'Contains' , Z3_OP_SEQ_REPLACE : 'Replace', Z3_OP_SEQ_UNIT: "Unit", Z3_OP_SEQ_CONTAINS: "Contains", Z3_OP_SEQ_REPLACE: "Replace",
Z3_OP_SEQ_AT : 'At', Z3_OP_SEQ_NTH : 'Nth', Z3_OP_SEQ_INDEX : 'IndexOf', Z3_OP_SEQ_AT: "At", Z3_OP_SEQ_NTH: "Nth", Z3_OP_SEQ_INDEX: "IndexOf",
Z3_OP_SEQ_LAST_INDEX : 'LastIndexOf', Z3_OP_SEQ_LENGTH : 'Length', Z3_OP_STR_TO_INT : 'StrToInt', Z3_OP_INT_TO_STR : 'IntToStr', Z3_OP_SEQ_LAST_INDEX: "LastIndexOf", Z3_OP_SEQ_LENGTH: "Length", Z3_OP_STR_TO_INT: "StrToInt", Z3_OP_INT_TO_STR: "IntToStr",
Z3_OP_SEQ_IN_RE : 'InRe', Z3_OP_SEQ_TO_RE : 'Re', Z3_OP_SEQ_IN_RE: "InRe", Z3_OP_SEQ_TO_RE: "Re",
Z3_OP_RE_PLUS : 'Plus', Z3_OP_RE_STAR : 'Star', Z3_OP_RE_OPTION : 'Option', Z3_OP_RE_UNION : 'Union', Z3_OP_RE_RANGE : 'Range', Z3_OP_RE_PLUS: "Plus", Z3_OP_RE_STAR: "Star", Z3_OP_RE_OPTION: "Option", Z3_OP_RE_UNION: "Union", Z3_OP_RE_RANGE: "Range",
Z3_OP_RE_INTERSECT : 'Intersect', Z3_OP_RE_COMPLEMENT : 'Complement', Z3_OP_RE_INTERSECT: "Intersect", Z3_OP_RE_COMPLEMENT: "Complement",
Z3_OP_FPA_IS_NAN : 'fpIsNaN', Z3_OP_FPA_IS_INF : 'fpIsInf', Z3_OP_FPA_IS_ZERO : 'fpIsZero', Z3_OP_FPA_IS_NAN: "fpIsNaN", Z3_OP_FPA_IS_INF: "fpIsInf", Z3_OP_FPA_IS_ZERO: "fpIsZero",
Z3_OP_FPA_IS_NORMAL : 'fpIsNormal', Z3_OP_FPA_IS_SUBNORMAL : 'fpIsSubnormal', Z3_OP_FPA_IS_NORMAL: "fpIsNormal", Z3_OP_FPA_IS_SUBNORMAL: "fpIsSubnormal",
Z3_OP_FPA_IS_NEGATIVE : 'fpIsNegative', Z3_OP_FPA_IS_POSITIVE : 'fpIsPositive', Z3_OP_FPA_IS_NEGATIVE: "fpIsNegative", Z3_OP_FPA_IS_POSITIVE: "fpIsPositive",
} }
# List of infix operators # List of infix operators
@ -91,35 +94,35 @@ _z3_precedence = {
# FPA operators # FPA operators
_z3_op_to_fpa_normal_str = { _z3_op_to_fpa_normal_str = {
Z3_OP_FPA_RM_NEAREST_TIES_TO_EVEN : 'RoundNearestTiesToEven()', Z3_OP_FPA_RM_NEAREST_TIES_TO_AWAY : 'RoundNearestTiesToAway()', Z3_OP_FPA_RM_NEAREST_TIES_TO_EVEN: "RoundNearestTiesToEven()", Z3_OP_FPA_RM_NEAREST_TIES_TO_AWAY: "RoundNearestTiesToAway()",
Z3_OP_FPA_RM_TOWARD_POSITIVE : 'RoundTowardPositive()', Z3_OP_FPA_RM_TOWARD_NEGATIVE : 'RoundTowardNegative()', Z3_OP_FPA_RM_TOWARD_POSITIVE: "RoundTowardPositive()", Z3_OP_FPA_RM_TOWARD_NEGATIVE: "RoundTowardNegative()",
Z3_OP_FPA_RM_TOWARD_ZERO : 'RoundTowardZero()', Z3_OP_FPA_RM_TOWARD_ZERO: "RoundTowardZero()",
Z3_OP_FPA_PLUS_INF : 'fpPlusInfinity', Z3_OP_FPA_MINUS_INF : 'fpMinusInfinity', Z3_OP_FPA_PLUS_INF: "fpPlusInfinity", Z3_OP_FPA_MINUS_INF: "fpMinusInfinity",
Z3_OP_FPA_NAN : 'fpNaN', Z3_OP_FPA_PLUS_ZERO : 'fpPZero', Z3_OP_FPA_MINUS_ZERO : 'fpNZero', Z3_OP_FPA_NAN: "fpNaN", Z3_OP_FPA_PLUS_ZERO: "fpPZero", Z3_OP_FPA_MINUS_ZERO: "fpNZero",
Z3_OP_FPA_ADD : 'fpAdd', Z3_OP_FPA_SUB : 'fpSub', Z3_OP_FPA_NEG : 'fpNeg', Z3_OP_FPA_MUL : 'fpMul', Z3_OP_FPA_ADD: "fpAdd", Z3_OP_FPA_SUB: "fpSub", Z3_OP_FPA_NEG: "fpNeg", Z3_OP_FPA_MUL: "fpMul",
Z3_OP_FPA_DIV : 'fpDiv', Z3_OP_FPA_REM : 'fpRem', Z3_OP_FPA_ABS : 'fpAbs', Z3_OP_FPA_DIV: "fpDiv", Z3_OP_FPA_REM: "fpRem", Z3_OP_FPA_ABS: "fpAbs",
Z3_OP_FPA_MIN : 'fpMin', Z3_OP_FPA_MAX : 'fpMax', Z3_OP_FPA_MIN: "fpMin", Z3_OP_FPA_MAX: "fpMax",
Z3_OP_FPA_FMA : 'fpFMA', Z3_OP_FPA_SQRT : 'fpSqrt', Z3_OP_FPA_ROUND_TO_INTEGRAL : 'fpRoundToIntegral', Z3_OP_FPA_FMA: "fpFMA", Z3_OP_FPA_SQRT: "fpSqrt", Z3_OP_FPA_ROUND_TO_INTEGRAL: "fpRoundToIntegral",
Z3_OP_FPA_EQ : 'fpEQ', Z3_OP_FPA_LT : 'fpLT', Z3_OP_FPA_GT : 'fpGT', Z3_OP_FPA_LE : 'fpLEQ', Z3_OP_FPA_EQ: "fpEQ", Z3_OP_FPA_LT: "fpLT", Z3_OP_FPA_GT: "fpGT", Z3_OP_FPA_LE: "fpLEQ",
Z3_OP_FPA_GE : 'fpGEQ', Z3_OP_FPA_GE: "fpGEQ",
Z3_OP_FPA_FP : 'fpFP', Z3_OP_FPA_TO_FP : 'fpToFP', Z3_OP_FPA_TO_FP_UNSIGNED: 'fpToFPUnsigned', Z3_OP_FPA_FP: "fpFP", Z3_OP_FPA_TO_FP: "fpToFP", Z3_OP_FPA_TO_FP_UNSIGNED: "fpToFPUnsigned",
Z3_OP_FPA_TO_UBV : 'fpToUBV', Z3_OP_FPA_TO_SBV : 'fpToSBV', Z3_OP_FPA_TO_REAL: 'fpToReal', Z3_OP_FPA_TO_UBV: "fpToUBV", Z3_OP_FPA_TO_SBV: "fpToSBV", Z3_OP_FPA_TO_REAL: "fpToReal",
Z3_OP_FPA_TO_IEEE_BV : 'fpToIEEEBV' Z3_OP_FPA_TO_IEEE_BV: "fpToIEEEBV"
} }
_z3_op_to_fpa_pretty_str = { _z3_op_to_fpa_pretty_str = {
Z3_OP_FPA_RM_NEAREST_TIES_TO_EVEN : 'RNE()', Z3_OP_FPA_RM_NEAREST_TIES_TO_AWAY : 'RNA()', Z3_OP_FPA_RM_NEAREST_TIES_TO_EVEN: "RNE()", Z3_OP_FPA_RM_NEAREST_TIES_TO_AWAY: "RNA()",
Z3_OP_FPA_RM_TOWARD_POSITIVE : 'RTP()', Z3_OP_FPA_RM_TOWARD_NEGATIVE : 'RTN()', Z3_OP_FPA_RM_TOWARD_POSITIVE: "RTP()", Z3_OP_FPA_RM_TOWARD_NEGATIVE: "RTN()",
Z3_OP_FPA_RM_TOWARD_ZERO : 'RTZ()', Z3_OP_FPA_RM_TOWARD_ZERO: "RTZ()",
Z3_OP_FPA_PLUS_INF : '+oo', Z3_OP_FPA_MINUS_INF : '-oo', Z3_OP_FPA_PLUS_INF: "+oo", Z3_OP_FPA_MINUS_INF: "-oo",
Z3_OP_FPA_NAN : 'NaN', Z3_OP_FPA_PLUS_ZERO : '+0.0', Z3_OP_FPA_MINUS_ZERO : '-0.0', Z3_OP_FPA_NAN: "NaN", Z3_OP_FPA_PLUS_ZERO: "+0.0", Z3_OP_FPA_MINUS_ZERO: "-0.0",
Z3_OP_FPA_ADD : '+', Z3_OP_FPA_SUB : '-', Z3_OP_FPA_MUL : '*', Z3_OP_FPA_DIV : '/', Z3_OP_FPA_ADD: "+", Z3_OP_FPA_SUB: "-", Z3_OP_FPA_MUL: "*", Z3_OP_FPA_DIV: "/",
Z3_OP_FPA_REM : '%', Z3_OP_FPA_NEG : '-', Z3_OP_FPA_REM: "%", Z3_OP_FPA_NEG: "-",
Z3_OP_FPA_EQ : 'fpEQ', Z3_OP_FPA_LT : '<', Z3_OP_FPA_GT : '>', Z3_OP_FPA_LE : '<=', Z3_OP_FPA_GE : '>=' Z3_OP_FPA_EQ: "fpEQ", Z3_OP_FPA_LT: "<", Z3_OP_FPA_GT: ">", Z3_OP_FPA_LE: "<=", Z3_OP_FPA_GE: ">="
} }
_z3_fpa_infix = [ _z3_fpa_infix = [
@ -127,27 +130,34 @@ _z3_fpa_infix = [
Z3_OP_FPA_LT, Z3_OP_FPA_GT, Z3_OP_FPA_LE, Z3_OP_FPA_GE Z3_OP_FPA_LT, Z3_OP_FPA_GT, Z3_OP_FPA_LE, Z3_OP_FPA_GE
] ]
def _is_assoc(k): def _is_assoc(k):
return k == Z3_OP_BOR or k == Z3_OP_BXOR or k == Z3_OP_BAND or k == Z3_OP_ADD or k == Z3_OP_BADD or k == Z3_OP_MUL or k == Z3_OP_BMUL return k == Z3_OP_BOR or k == Z3_OP_BXOR or k == Z3_OP_BAND or k == Z3_OP_ADD or k == Z3_OP_BADD or k == Z3_OP_MUL or k == Z3_OP_BMUL
def _is_left_assoc(k): def _is_left_assoc(k):
return _is_assoc(k) or k == Z3_OP_SUB or k == Z3_OP_BSUB return _is_assoc(k) or k == Z3_OP_SUB or k == Z3_OP_BSUB
def _is_html_assoc(k): def _is_html_assoc(k):
return k == Z3_OP_AND or k == Z3_OP_OR or k == Z3_OP_IFF or _is_assoc(k) return k == Z3_OP_AND or k == Z3_OP_OR or k == Z3_OP_IFF or _is_assoc(k)
def _is_html_left_assoc(k): def _is_html_left_assoc(k):
return _is_html_assoc(k) or k == Z3_OP_SUB or k == Z3_OP_BSUB return _is_html_assoc(k) or k == Z3_OP_SUB or k == Z3_OP_BSUB
def _is_add(k): def _is_add(k):
return k == Z3_OP_ADD or k == Z3_OP_BADD return k == Z3_OP_ADD or k == Z3_OP_BADD
def _is_sub(k): def _is_sub(k):
return k == Z3_OP_SUB or k == Z3_OP_BSUB return k == Z3_OP_SUB or k == Z3_OP_BSUB
import sys
if sys.version < '3': if sys.version_info.major < 3:
import codecs import codecs
def u(x): def u(x):
return codecs.unicode_escape_decode(x)[0] return codecs.unicode_escape_decode(x)[0]
else: else:
@ -156,21 +166,21 @@ else:
_z3_infix_compact = [Z3_OP_MUL, Z3_OP_BMUL, Z3_OP_POWER, Z3_OP_DIV, Z3_OP_IDIV, Z3_OP_MOD, Z3_OP_BSDIV, Z3_OP_BSMOD] _z3_infix_compact = [Z3_OP_MUL, Z3_OP_BMUL, Z3_OP_POWER, Z3_OP_DIV, Z3_OP_IDIV, Z3_OP_MOD, Z3_OP_BSDIV, Z3_OP_BSMOD]
_ellipses = '...' _ellipses = "..."
_html_ellipses = '&hellip;' _html_ellipses = "&hellip;"
# Overwrite some of the operators for HTML # Overwrite some of the operators for HTML
_z3_pre_html_op_to_str = { Z3_OP_EQ : '=', Z3_OP_IFF : '=', Z3_OP_NOT : '&not;', _z3_pre_html_op_to_str = {Z3_OP_EQ: "=", Z3_OP_IFF: "=", Z3_OP_NOT: "&not;",
Z3_OP_AND : '&and;', Z3_OP_OR : '&or;', Z3_OP_IMPLIES : '&rArr;', Z3_OP_AND: "&and;", Z3_OP_OR: "&or;", Z3_OP_IMPLIES: "&rArr;",
Z3_OP_LT : '&lt;', Z3_OP_GT : '&gt;', Z3_OP_LE : '&le;', Z3_OP_GE : '&ge;', Z3_OP_LT: "&lt;", Z3_OP_GT: "&gt;", Z3_OP_LE: "&le;", Z3_OP_GE: "&ge;",
Z3_OP_MUL : '&middot;', Z3_OP_MUL: "&middot;",
Z3_OP_SLEQ : '&le;', Z3_OP_SLT : '&lt;', Z3_OP_SGEQ : '&ge;', Z3_OP_SGT : '&gt;', Z3_OP_SLEQ: "&le;", Z3_OP_SLT: "&lt;", Z3_OP_SGEQ: "&ge;", Z3_OP_SGT: "&gt;",
Z3_OP_ULEQ : '&le;<sub>u</sub>', Z3_OP_ULT : '&lt;<sub>u</sub>', Z3_OP_ULEQ: "&le;<sub>u</sub>", Z3_OP_ULT: "&lt;<sub>u</sub>",
Z3_OP_UGEQ : '&ge;<sub>u</sub>', Z3_OP_UGT : '&gt;<sub>u</sub>', Z3_OP_UGEQ: "&ge;<sub>u</sub>", Z3_OP_UGT: "&gt;<sub>u</sub>",
Z3_OP_BMUL : '&middot;', Z3_OP_BMUL: "&middot;",
Z3_OP_BUDIV : '/<sub>u</sub>', Z3_OP_BUREM : '%<sub>u</sub>', Z3_OP_BUDIV: "/<sub>u</sub>", Z3_OP_BUREM: "%<sub>u</sub>",
Z3_OP_BASHR : '&gt;&gt;', Z3_OP_BSHL : '&lt;&lt;', Z3_OP_BASHR: "&gt;&gt;", Z3_OP_BSHL: "&lt;&lt;",
Z3_OP_BLSHR : '&gt;&gt;<sub>u</sub>' Z3_OP_BLSHR: "&gt;&gt;<sub>u</sub>"
} }
# Extra operators that are infix/unary for HTML # Extra operators that are infix/unary for HTML
@ -198,9 +208,11 @@ _z3_pre_html_precedence = { Z3_OP_BUDIV : 2, Z3_OP_BUREM : 2,
# #
############################## ##############################
def _support_pp(a): def _support_pp(a):
return isinstance(a, z3.Z3PPObject) or isinstance(a, list) or isinstance(a, tuple) return isinstance(a, z3.Z3PPObject) or isinstance(a, list) or isinstance(a, tuple)
_infix_map = {} _infix_map = {}
_unary_map = {} _unary_map = {}
_infix_compact_map = {} _infix_compact_map = {}
@ -213,18 +225,22 @@ for _k in _z3_unary:
for _k in _z3_infix_compact: for _k in _z3_infix_compact:
_infix_compact_map[_k] = True _infix_compact_map[_k] = True
def _is_infix(k): def _is_infix(k):
global _infix_map global _infix_map
return _infix_map.get(k, False) return _infix_map.get(k, False)
def _is_infix_compact(k): def _is_infix_compact(k):
global _infix_compact_map global _infix_compact_map
return _infix_compact_map.get(k, False) return _infix_compact_map.get(k, False)
def _is_unary(k): def _is_unary(k):
global _unary_map global _unary_map
return _unary_map.get(k, False) return _unary_map.get(k, False)
def _op_name(a): def _op_name(a):
if isinstance(a, z3.FuncDeclRef): if isinstance(a, z3.FuncDeclRef):
f = a f = a
@ -232,15 +248,17 @@ def _op_name(a):
f = a.decl() f = a.decl()
k = f.kind() k = f.kind()
n = _z3_op_to_str.get(k, None) n = _z3_op_to_str.get(k, None)
if n == None: if n is None:
return f.name() return f.name()
else: else:
return n return n
def _get_precedence(k): def _get_precedence(k):
global _z3_precedence global _z3_precedence
return _z3_precedence.get(k, 100000) return _z3_precedence.get(k, 100000)
_z3_html_op_to_str = {} _z3_html_op_to_str = {}
for _k in _z3_op_to_str: for _k in _z3_op_to_str:
_v = _z3_op_to_str[_k] _v = _z3_op_to_str[_k]
@ -268,14 +286,17 @@ for _k in _z3_unary:
for _k in _z3_html_unary: for _k in _z3_html_unary:
_html_unary_map[_k] = True _html_unary_map[_k] = True
def _is_html_infix(k): def _is_html_infix(k):
global _html_infix_map global _html_infix_map
return _html_infix_map.get(k, False) return _html_infix_map.get(k, False)
def _is_html_unary(k): def _is_html_unary(k):
global _html_unary_map global _html_unary_map
return _html_unary_map.get(k, False) return _html_unary_map.get(k, False)
def _html_op_name(a): def _html_op_name(a):
global _z3_html_op_to_str global _z3_html_op_to_str
if isinstance(a, z3.FuncDeclRef): if isinstance(a, z3.FuncDeclRef):
@ -284,7 +305,7 @@ def _html_op_name(a):
f = a.decl() f = a.decl()
k = f.kind() k = f.kind()
n = _z3_html_op_to_str.get(k, None) n = _z3_html_op_to_str.get(k, None)
if n == None: if n is None:
sym = Z3_get_decl_name(f.ctx_ref(), f.ast) sym = Z3_get_decl_name(f.ctx_ref(), f.ast)
if Z3_get_symbol_kind(f.ctx_ref(), sym) == Z3_INT_SYMBOL: if Z3_get_symbol_kind(f.ctx_ref(), sym) == Z3_INT_SYMBOL:
return "&#950;<sub>%s</sub>" % Z3_get_symbol_int(f.ctx_ref(), sym) return "&#950;<sub>%s</sub>" % Z3_get_symbol_int(f.ctx_ref(), sym)
@ -294,44 +315,60 @@ def _html_op_name(a):
else: else:
return n return n
def _get_html_precedence(k): def _get_html_precedence(k):
global _z3_html_predence global _z3_html_predence
return _z3_html_precedence.get(k, 100000) return _z3_html_precedence.get(k, 100000)
class FormatObject: class FormatObject:
def is_compose(self): def is_compose(self):
return False return False
def is_choice(self): def is_choice(self):
return False return False
def is_indent(self): def is_indent(self):
return False return False
def is_string(self): def is_string(self):
return False return False
def is_linebreak(self): def is_linebreak(self):
return False return False
def is_nil(self): def is_nil(self):
return True return True
def children(self): def children(self):
return [] return []
def as_tuple(self): def as_tuple(self):
return None return None
def space_upto_nl(self): def space_upto_nl(self):
return (0, False) return (0, False)
def flat(self): def flat(self):
return self return self
class NAryFormatObject(FormatObject): class NAryFormatObject(FormatObject):
def __init__(self, fs): def __init__(self, fs):
assert all([isinstance(a, FormatObject) for a in fs]) assert all([isinstance(a, FormatObject) for a in fs])
self.children = fs self.children = fs
def children(self): def children(self):
return self.children return self.children
class ComposeFormatObject(NAryFormatObject): class ComposeFormatObject(NAryFormatObject):
def is_compose(sef): def is_compose(sef):
return True return True
def as_tuple(self): def as_tuple(self):
return ('compose', [ a.as_tuple() for a in self.children ]) return ("compose", [a.as_tuple() for a in self.children])
def space_upto_nl(self): def space_upto_nl(self):
r = 0 r = 0
for child in self.children: for child in self.children:
@ -340,95 +377,123 @@ class ComposeFormatObject(NAryFormatObject):
if nl: if nl:
return (r, True) return (r, True)
return (r, False) return (r, False)
def flat(self): def flat(self):
return compose([a.flat() for a in self.children]) return compose([a.flat() for a in self.children])
class ChoiceFormatObject(NAryFormatObject): class ChoiceFormatObject(NAryFormatObject):
def is_choice(sef): def is_choice(sef):
return True return True
def as_tuple(self): def as_tuple(self):
return ('choice', [ a.as_tuple() for a in self.children ]) return ("choice", [a.as_tuple() for a in self.children])
def space_upto_nl(self): def space_upto_nl(self):
return self.children[0].space_upto_nl() return self.children[0].space_upto_nl()
def flat(self): def flat(self):
return self.children[0].flat() return self.children[0].flat()
class IndentFormatObject(FormatObject): class IndentFormatObject(FormatObject):
def __init__(self, indent, child): def __init__(self, indent, child):
assert isinstance(child, FormatObject) assert isinstance(child, FormatObject)
self.indent = indent self.indent = indent
self.child = child self.child = child
def children(self): def children(self):
return [self.child] return [self.child]
def as_tuple(self): def as_tuple(self):
return ('indent', self.indent, self.child.as_tuple()) return ("indent", self.indent, self.child.as_tuple())
def space_upto_nl(self): def space_upto_nl(self):
return self.child.space_upto_nl() return self.child.space_upto_nl()
def flat(self): def flat(self):
return indent(self.indent, self.child.flat()) return indent(self.indent, self.child.flat())
def is_indent(self): def is_indent(self):
return True return True
class LineBreakFormatObject(FormatObject): class LineBreakFormatObject(FormatObject):
def __init__(self): def __init__(self):
self.space = ' ' self.space = " "
def is_linebreak(self): def is_linebreak(self):
return True return True
def as_tuple(self): def as_tuple(self):
return '<line-break>' return "<line-break>"
def space_upto_nl(self): def space_upto_nl(self):
return (0, True) return (0, True)
def flat(self): def flat(self):
return to_format(self.space) return to_format(self.space)
class StringFormatObject(FormatObject): class StringFormatObject(FormatObject):
def __init__(self, string): def __init__(self, string):
assert isinstance(string, str) assert isinstance(string, str)
self.string = string self.string = string
def is_string(self): def is_string(self):
return True return True
def as_tuple(self): def as_tuple(self):
return self.string return self.string
def space_upto_nl(self): def space_upto_nl(self):
return (getattr(self, 'size', len(self.string)), False) return (getattr(self, "size", len(self.string)), False)
def fits(f, space_left): def fits(f, space_left):
s, nl = f.space_upto_nl() s, nl = f.space_upto_nl()
return s <= space_left return s <= space_left
def to_format(arg, size=None): def to_format(arg, size=None):
if isinstance(arg, FormatObject): if isinstance(arg, FormatObject):
return arg return arg
else: else:
r = StringFormatObject(str(arg)) r = StringFormatObject(str(arg))
if size != None: if size is not None:
r.size = size r.size = size
return r return r
def compose(*args): def compose(*args):
if len(args) == 1 and (isinstance(args[0], list) or isinstance(args[0], tuple)): if len(args) == 1 and (isinstance(args[0], list) or isinstance(args[0], tuple)):
args = args[0] args = args[0]
return ComposeFormatObject(args) return ComposeFormatObject(args)
def indent(i, arg): def indent(i, arg):
return IndentFormatObject(i, arg) return IndentFormatObject(i, arg)
def group(arg): def group(arg):
return ChoiceFormatObject([arg.flat(), arg]) return ChoiceFormatObject([arg.flat(), arg])
def line_break(): def line_break():
return LineBreakFormatObject() return LineBreakFormatObject()
def _len(a): def _len(a):
if isinstance(a, StringFormatObject): if isinstance(a, StringFormatObject):
return getattr(a, 'size', len(a.string)) return getattr(a, "size", len(a.string))
else: else:
return len(a) return len(a)
def seq(args, sep=',', space=True):
def seq(args, sep=",", space=True):
nl = line_break() nl = line_break()
if not space: if not space:
nl.space = '' nl.space = ""
r = [] r = []
r.append(args[0]) r.append(args[0])
num = len(args) num = len(args)
@ -438,29 +503,34 @@ def seq(args, sep=',', space=True):
r.append(args[i + 1]) r.append(args[i + 1])
return compose(r) return compose(r)
def seq1(header, args, lp='(', rp=')'):
def seq1(header, args, lp="(", rp=")"):
return group(compose(to_format(header), return group(compose(to_format(header),
to_format(lp), to_format(lp),
indent(len(lp) + _len(header), indent(len(lp) + _len(header),
seq(args)), seq(args)),
to_format(rp))) to_format(rp)))
def seq2(header, args, i=4, lp='(', rp=')'):
def seq2(header, args, i=4, lp="(", rp=")"):
if len(args) == 0: if len(args) == 0:
return compose(to_format(header), to_format(lp), to_format(rp)) return compose(to_format(header), to_format(lp), to_format(rp))
else: else:
return group(compose(indent(len(lp), compose(to_format(lp), to_format(header))), return group(compose(indent(len(lp), compose(to_format(lp), to_format(header))),
indent(i, compose(seq(args), to_format(rp))))) indent(i, compose(seq(args), to_format(rp)))))
def seq3(args, lp='(', rp=')'):
def seq3(args, lp="(", rp=")"):
if len(args) == 0: if len(args) == 0:
return compose(to_format(lp), to_format(rp)) return compose(to_format(lp), to_format(rp))
else: else:
return group(indent(len(lp), compose(to_format(lp), seq(args), to_format(rp)))) return group(indent(len(lp), compose(to_format(lp), seq(args), to_format(rp))))
class StopPPException(Exception): class StopPPException(Exception):
def __str__(self): def __str__(self):
return 'pp-interrupted' return "pp-interrupted"
class PP: class PP:
def __init__(self): def __init__(self):
@ -495,11 +565,11 @@ class PP:
self.ribbon_pos = 0 self.ribbon_pos = 0
self.line = self.line + 1 self.line = self.line + 1
if self.line < self.max_lines: if self.line < self.max_lines:
self.out.write(u('\n')) self.out.write(u("\n"))
for i in range(indent): for i in range(indent):
self.out.write(u(' ')) self.out.write(u(" "))
else: else:
self.out.write(u('\n...')) self.out.write(u("\n..."))
raise StopPPException() raise StopPPException()
def pp(self, f, indent): def pp(self, f, indent):
@ -528,6 +598,7 @@ class PP:
except StopPPException: except StopPPException:
return return
class Formatter: class Formatter:
def __init__(self): def __init__(self):
global _ellipses global _ellipses
@ -543,10 +614,10 @@ class Formatter:
return self.ellipses return self.ellipses
def pp_arrow(self): def pp_arrow(self):
return ' ->' return " ->"
def pp_unknown(self): def pp_unknown(self):
return '<unknown>' return "<unknown>"
def pp_name(self, a): def pp_name(self, a):
return to_format(_op_name(a)) return to_format(_op_name(a))
@ -567,21 +638,21 @@ class Formatter:
return self.is_infix(a) or self.is_unary(a) return self.is_infix(a) or self.is_unary(a)
def add_paren(self, a): def add_paren(self, a):
return compose(to_format('('), indent(1, a), to_format(')')) return compose(to_format("("), indent(1, a), to_format(")"))
def pp_sort(self, s): def pp_sort(self, s):
if isinstance(s, z3.ArraySortRef): if isinstance(s, z3.ArraySortRef):
return seq1('Array', (self.pp_sort(s.domain()), self.pp_sort(s.range()))) return seq1("Array", (self.pp_sort(s.domain()), self.pp_sort(s.range())))
elif isinstance(s, z3.BitVecSortRef): elif isinstance(s, z3.BitVecSortRef):
return seq1('BitVec', (to_format(s.size()), )) return seq1("BitVec", (to_format(s.size()), ))
elif isinstance(s, z3.FPSortRef): elif isinstance(s, z3.FPSortRef):
return seq1('FPSort', (to_format(s.ebits()), to_format(s.sbits()))) return seq1("FPSort", (to_format(s.ebits()), to_format(s.sbits())))
elif isinstance(s, z3.ReSortRef): elif isinstance(s, z3.ReSortRef):
return seq1('ReSort', (self.pp_sort(s.basis()), )) return seq1("ReSort", (self.pp_sort(s.basis()), ))
elif isinstance(s, z3.SeqSortRef): elif isinstance(s, z3.SeqSortRef):
if s.is_string(): if s.is_string():
return to_format("String") return to_format("String")
return seq1('Seq', (self.pp_sort(s.basis()), )) return seq1("Seq", (self.pp_sort(s.basis()), ))
else: else:
return to_format(s.name()) return to_format(s.name())
@ -617,53 +688,53 @@ class Formatter:
return to_format(a.as_string()) return to_format(a.as_string())
def pp_fprm_value(self, a): def pp_fprm_value(self, a):
_z3_assert(z3.is_fprm_value(a), 'expected FPRMNumRef') _z3_assert(z3.is_fprm_value(a), "expected FPRMNumRef")
if self.fpa_pretty and (a.decl().kind() in _z3_op_to_fpa_pretty_str): if self.fpa_pretty and (a.decl().kind() in _z3_op_to_fpa_pretty_str):
return to_format(_z3_op_to_fpa_pretty_str.get(a.decl().kind())) return to_format(_z3_op_to_fpa_pretty_str.get(a.decl().kind()))
else: else:
return to_format(_z3_op_to_fpa_normal_str.get(a.decl().kind())) return to_format(_z3_op_to_fpa_normal_str.get(a.decl().kind()))
def pp_fp_value(self, a): def pp_fp_value(self, a):
_z3_assert(isinstance(a, z3.FPNumRef), 'type mismatch') _z3_assert(isinstance(a, z3.FPNumRef), "type mismatch")
if not self.fpa_pretty: if not self.fpa_pretty:
r = [] r = []
if (a.isNaN()): if (a.isNaN()):
r.append(to_format(_z3_op_to_fpa_normal_str[Z3_OP_FPA_NAN])) r.append(to_format(_z3_op_to_fpa_normal_str[Z3_OP_FPA_NAN]))
r.append(to_format('(')) r.append(to_format("("))
r.append(to_format(a.sort())) r.append(to_format(a.sort()))
r.append(to_format(')')) r.append(to_format(")"))
return compose(r) return compose(r)
elif (a.isInf()): elif (a.isInf()):
if (a.isNegative()): if (a.isNegative()):
r.append(to_format(_z3_op_to_fpa_normal_str[Z3_OP_FPA_MINUS_INF])) r.append(to_format(_z3_op_to_fpa_normal_str[Z3_OP_FPA_MINUS_INF]))
else: else:
r.append(to_format(_z3_op_to_fpa_normal_str[Z3_OP_FPA_PLUS_INF])) r.append(to_format(_z3_op_to_fpa_normal_str[Z3_OP_FPA_PLUS_INF]))
r.append(to_format('(')) r.append(to_format("("))
r.append(to_format(a.sort())) r.append(to_format(a.sort()))
r.append(to_format(')')) r.append(to_format(")"))
return compose(r) return compose(r)
elif (a.isZero()): elif (a.isZero()):
if (a.isNegative()): if (a.isNegative()):
return to_format('-zero') return to_format("-zero")
else: else:
return to_format('+zero') return to_format("+zero")
else: else:
_z3_assert(z3.is_fp_value(a), 'expecting FP num ast') _z3_assert(z3.is_fp_value(a), "expecting FP num ast")
r = [] r = []
sgn = c_int(0) sgn = c_int(0)
sgnb = Z3_fpa_get_numeral_sign(a.ctx_ref(), a.ast, byref(sgn)) sgnb = Z3_fpa_get_numeral_sign(a.ctx_ref(), a.ast, byref(sgn))
exp = Z3_fpa_get_numeral_exponent_string(a.ctx_ref(), a.ast, False) exp = Z3_fpa_get_numeral_exponent_string(a.ctx_ref(), a.ast, False)
sig = Z3_fpa_get_numeral_significand_string(a.ctx_ref(), a.ast) sig = Z3_fpa_get_numeral_significand_string(a.ctx_ref(), a.ast)
r.append(to_format('FPVal(')) r.append(to_format("FPVal("))
if sgnb and sgn.value != 0: if sgnb and sgn.value != 0:
r.append(to_format('-')) r.append(to_format("-"))
r.append(to_format(sig)) r.append(to_format(sig))
r.append(to_format('*(2**')) r.append(to_format("*(2**"))
r.append(to_format(exp)) r.append(to_format(exp))
r.append(to_format(', ')) r.append(to_format(", "))
r.append(to_format(a.sort())) r.append(to_format(a.sort()))
r.append(to_format('))')) r.append(to_format("))"))
return compose(r) return compose(r)
else: else:
if (a.isNaN()): if (a.isNaN()):
@ -679,26 +750,25 @@ class Formatter:
else: else:
return to_format(_z3_op_to_fpa_pretty_str[Z3_OP_FPA_PLUS_ZERO]) return to_format(_z3_op_to_fpa_pretty_str[Z3_OP_FPA_PLUS_ZERO])
else: else:
_z3_assert(z3.is_fp_value(a), 'expecting FP num ast') _z3_assert(z3.is_fp_value(a), "expecting FP num ast")
r = [] r = []
sgn = (ctypes.c_int)(0) sgn = (ctypes.c_int)(0)
sgnb = Z3_fpa_get_numeral_sign(a.ctx_ref(), a.ast, byref(sgn)) sgnb = Z3_fpa_get_numeral_sign(a.ctx_ref(), a.ast, byref(sgn))
exp = Z3_fpa_get_numeral_exponent_string(a.ctx_ref(), a.ast, False) exp = Z3_fpa_get_numeral_exponent_string(a.ctx_ref(), a.ast, False)
sig = Z3_fpa_get_numeral_significand_string(a.ctx_ref(), a.ast) sig = Z3_fpa_get_numeral_significand_string(a.ctx_ref(), a.ast)
if sgnb and sgn.value != 0: if sgnb and sgn.value != 0:
r.append(to_format('-')) r.append(to_format("-"))
r.append(to_format(sig)) r.append(to_format(sig))
if (exp != '0'): if (exp != "0"):
r.append(to_format('*(2**')) r.append(to_format("*(2**"))
r.append(to_format(exp)) r.append(to_format(exp))
r.append(to_format(')')) r.append(to_format(")"))
return compose(r) return compose(r)
def pp_fp(self, a, d, xs): def pp_fp(self, a, d, xs):
_z3_assert(isinstance(a, z3.FPRef), "type mismatch") _z3_assert(isinstance(a, z3.FPRef), "type mismatch")
k = a.decl().kind() k = a.decl().kind()
op = '?' op = "?"
if (self.fpa_pretty and k in _z3_op_to_fpa_pretty_str): if (self.fpa_pretty and k in _z3_op_to_fpa_pretty_str):
op = _z3_op_to_fpa_pretty_str[k] op = _z3_op_to_fpa_pretty_str[k]
elif k in _z3_op_to_fpa_normal_str: elif k in _z3_op_to_fpa_normal_str:
@ -716,13 +786,13 @@ class Formatter:
arg2 = to_format(self.pp_expr(a.arg(2), d + 1, xs)) arg2 = to_format(self.pp_expr(a.arg(2), d + 1, xs))
r = [] r = []
r.append(arg1) r.append(arg1)
r.append(to_format(' ')) r.append(to_format(" "))
r.append(to_format(op)) r.append(to_format(op))
r.append(to_format(' ')) r.append(to_format(" "))
r.append(arg2) r.append(arg2)
return compose(r) return compose(r)
elif k == Z3_OP_FPA_NEG: elif k == Z3_OP_FPA_NEG:
return compose([to_format('-') , to_format(self.pp_expr(a.arg(0), d+1, xs))]) return compose([to_format("-"), to_format(self.pp_expr(a.arg(0), d + 1, xs))])
if k in _z3_op_to_fpa_normal_str: if k in _z3_op_to_fpa_normal_str:
op = _z3_op_to_fpa_normal_str[k] op = _z3_op_to_fpa_normal_str[k]
@ -730,15 +800,15 @@ class Formatter:
r = [] r = []
r.append(to_format(op)) r.append(to_format(op))
if not z3.is_const(a): if not z3.is_const(a):
r.append(to_format('(')) r.append(to_format("("))
first = True first = True
for c in a.children(): for c in a.children():
if first: if first:
first = False first = False
else: else:
r.append(to_format(', ')) r.append(to_format(", "))
r.append(self.pp_expr(c, d + 1, xs)) r.append(self.pp_expr(c, d + 1, xs))
r.append(to_format(')')) r.append(to_format(")"))
return compose(r) return compose(r)
else: else:
return to_format(a.as_string()) return to_format(a.as_string())
@ -805,7 +875,7 @@ class Formatter:
else: else:
op = self.pp_name(a) op = self.pp_name(a)
sz = _len(op) sz = _len(op)
op.string = ' ' + op.string op.string = " " + op.string
op.size = sz + 1 op.size = sz + 1
return group(seq(self.infix_args(a, d, xs), op)) return group(seq(self.infix_args(a, d, xs), op))
@ -839,7 +909,7 @@ class Formatter:
def pp_power(self, a, d, xs): def pp_power(self, a, d, xs):
arg1_pp = self.pp_power_arg(a.arg(0), d + 1, xs) arg1_pp = self.pp_power_arg(a.arg(0), d + 1, xs)
arg2_pp = self.pp_power_arg(a.arg(1), d + 1, xs) arg2_pp = self.pp_power_arg(a.arg(1), d + 1, xs)
return group(seq((arg1_pp, arg2_pp), '**', False)) return group(seq((arg1_pp, arg2_pp), "**", False))
def pp_neq(self): def pp_neq(self):
return to_format("!=") return to_format("!=")
@ -848,7 +918,7 @@ class Formatter:
if a.num_args() == 2: if a.num_args() == 2:
op = self.pp_neq() op = self.pp_neq()
sz = _len(op) sz = _len(op)
op.string = ' ' + op.string op.string = " " + op.string
op.size = sz + 1 op.size = sz + 1
return group(seq(self.infix_args(a, d, xs), op)) return group(seq(self.infix_args(a, d, xs), op))
else: else:
@ -860,7 +930,7 @@ class Formatter:
else: else:
arg1_pp = self.pp_expr(a.arg(0), d + 1, xs) arg1_pp = self.pp_expr(a.arg(0), d + 1, xs)
arg2_pp = self.pp_expr(a.arg(1), d + 1, xs) arg2_pp = self.pp_expr(a.arg(1), d + 1, xs)
return compose(arg1_pp, indent(2, compose(to_format('['), arg2_pp, to_format(']')))) return compose(arg1_pp, indent(2, compose(to_format("["), arg2_pp, to_format("]"))))
def pp_unary_param(self, a, d, xs): def pp_unary_param(self, a, d, xs):
p = Z3_get_decl_int_parameter(a.ctx_ref(), a.decl().ast, 0) p = Z3_get_decl_int_parameter(a.ctx_ref(), a.decl().ast, 0)
@ -888,7 +958,7 @@ class Formatter:
if a.num_args() == 1: if a.num_args() == 1:
return self.pp_expr(a.arg(0), d, xs) return self.pp_expr(a.arg(0), d, xs)
else: else:
return seq1('MultiPattern', [ self.pp_expr(arg, d+1, xs) for arg in a.children() ]) return seq1("MultiPattern", [self.pp_expr(arg, d + 1, xs) for arg in a.children()])
def pp_is(self, a, d, xs): def pp_is(self, a, d, xs):
f = a.params()[0] f = a.params()[0]
@ -925,7 +995,6 @@ class Formatter:
ls = [seq3([self.pp_expr(chs[i], d + 1, xs), to_format(ks[i])]) for i in rchs] ls = [seq3([self.pp_expr(chs[i], d + 1, xs), to_format(ks[i])]) for i in rchs]
return seq1(self.pp_name(a), [seq3(ls), to_format(k)]) return seq1(self.pp_name(a), [seq3(ls), to_format(k)])
def pp_app(self, a, d, xs): def pp_app(self, a, d, xs):
if z3.is_int_value(a): if z3.is_int_value(a):
return self.pp_int(a) return self.pp_int(a)
@ -989,7 +1058,7 @@ class Formatter:
idx = z3.get_var_index(a) idx = z3.get_var_index(a)
sz = len(xs) sz = len(xs)
if idx >= sz: if idx >= sz:
return seq1('Var', (to_format(idx),)) return seq1("Var", (to_format(idx),))
else: else:
return to_format(xs[sz - idx - 1]) return to_format(xs[sz - idx - 1])
@ -1000,13 +1069,13 @@ class Formatter:
if len(ys) == 1: if len(ys) == 1:
ys_pp = ys[0] ys_pp = ys[0]
else: else:
ys_pp = seq3(ys, '[', ']') ys_pp = seq3(ys, "[", "]")
if a.is_forall(): if a.is_forall():
header = 'ForAll' header = "ForAll"
elif a.is_exists(): elif a.is_exists():
header = 'Exists' header = "Exists"
else: else:
header = 'Lambda' header = "Lambda"
return seq1(header, (ys_pp, body_pp)) return seq1(header, (ys_pp, body_pp))
def pp_expr(self, a, d, xs): def pp_expr(self, a, d, xs):
@ -1042,7 +1111,7 @@ class Formatter:
if sz > self.max_args: if sz > self.max_args:
r.append(self.pp_ellipses()) r.append(self.pp_ellipses())
break break
return seq3(r, '[', ']') return seq3(r, "[", "]")
def pp_seq(self, a, d, xs): def pp_seq(self, a, d, xs):
return self.pp_seq_core(self.pp_expr, a, d, xs) return self.pp_seq_core(self.pp_expr, a, d, xs)
@ -1060,12 +1129,12 @@ class Formatter:
else: else:
i_pp = self.pp_expr(i, 0, []) i_pp = self.pp_expr(i, 0, [])
name = self.pp_name(d) name = self.pp_name(d)
r.append(compose(name, to_format(' = '), indent(_len(name) + 3, i_pp))) r.append(compose(name, to_format(" = "), indent(_len(name) + 3, i_pp)))
sz = sz + 1 sz = sz + 1
if sz > self.max_args: if sz > self.max_args:
r.append(self.pp_ellipses()) r.append(self.pp_ellipses())
break break
return seq3(r, '[', ']') return seq3(r, "[", "]")
def pp_func_entry(self, e): def pp_func_entry(self, e):
num = e.num_args() num = e.num_args()
@ -1091,12 +1160,12 @@ class Formatter:
break break
if sz <= self.max_args: if sz <= self.max_args:
else_val = f.else_value() else_val = f.else_value()
if else_val == None: if else_val is None:
else_pp = to_format('#unspecified') else_pp = to_format("#unspecified")
else: else:
else_pp = self.pp_expr(else_val, 0, []) else_pp = self.pp_expr(else_val, 0, [])
r.append(group(seq((to_format('else'), else_pp), self.pp_arrow()))) r.append(group(seq((to_format("else"), else_pp), self.pp_arrow())))
return seq3(r, '[', ']') return seq3(r, "[", "]")
def pp_list(self, a): def pp_list(self, a):
r = [] r = []
@ -1113,7 +1182,7 @@ class Formatter:
if isinstance(a, tuple): if isinstance(a, tuple):
return seq3(r) return seq3(r)
else: else:
return seq3(r, '[', ']') return seq3(r, "[", "]")
def main(self, a): def main(self, a):
if z3.is_expr(a): if z3.is_expr(a):
@ -1145,6 +1214,7 @@ class Formatter:
self.visited = 0 self.visited = 0
return self.main(a) return self.main(a)
class HTMLFormatter(Formatter): class HTMLFormatter(Formatter):
def __init__(self): def __init__(self):
Formatter.__init__(self) Formatter.__init__(self)
@ -1152,17 +1222,17 @@ class HTMLFormatter(Formatter):
self.ellipses = to_format(_html_ellipses) self.ellipses = to_format(_html_ellipses)
def pp_arrow(self): def pp_arrow(self):
return to_format(' &rarr;', 1) return to_format(" &rarr;", 1)
def pp_unknown(self): def pp_unknown(self):
return '<b>unknown</b>' return "<b>unknown</b>"
def pp_name(self, a): def pp_name(self, a):
r = _html_op_name(a) r = _html_op_name(a)
if r[0] == '&' or r[0] == '/' or r[0] == '%': if r[0] == "&" or r[0] == "/" or r[0] == "%":
return to_format(r, 1) return to_format(r, 1)
else: else:
pos = r.find('__') pos = r.find("__")
if pos == -1 or pos == 0: if pos == -1 or pos == 0:
return to_format(r) return to_format(r)
else: else:
@ -1170,7 +1240,7 @@ class HTMLFormatter(Formatter):
if pos + 2 == sz: if pos + 2 == sz:
return to_format(r) return to_format(r)
else: else:
return to_format('%s<sub>%s</sub>' % (r[0:pos], r[pos+2:sz]), sz - 2) return to_format("%s<sub>%s</sub>" % (r[0:pos], r[pos + 2:sz]), sz - 2)
def is_assoc(self, k): def is_assoc(self, k):
return _is_html_assoc(k) return _is_html_assoc(k)
@ -1193,14 +1263,14 @@ class HTMLFormatter(Formatter):
def pp_power(self, a, d, xs): def pp_power(self, a, d, xs):
arg1_pp = self.pp_power_arg(a.arg(0), d + 1, xs) arg1_pp = self.pp_power_arg(a.arg(0), d + 1, xs)
arg2_pp = self.pp_expr(a.arg(1), d + 1, xs) arg2_pp = self.pp_expr(a.arg(1), d + 1, xs)
return compose(arg1_pp, to_format('<sup>', 1), arg2_pp, to_format('</sup>', 1)) return compose(arg1_pp, to_format("<sup>", 1), arg2_pp, to_format("</sup>", 1))
def pp_var(self, a, d, xs): def pp_var(self, a, d, xs):
idx = z3.get_var_index(a) idx = z3.get_var_index(a)
sz = len(xs) sz = len(xs)
if idx >= sz: if idx >= sz:
# 957 is the greek letter nu # 957 is the greek letter nu
return to_format('&#957;<sub>%s</sub>' % idx, 1) return to_format("&#957;<sub>%s</sub>" % idx, 1)
else: else:
return to_format(xs[sz - idx - 1]) return to_format(xs[sz - idx - 1])
@ -1210,48 +1280,52 @@ class HTMLFormatter(Formatter):
body_pp = self.pp_expr(a.body(), d + 1, new_xs) body_pp = self.pp_expr(a.body(), d + 1, new_xs)
ys_pp = group(seq(ys)) ys_pp = group(seq(ys))
if a.is_forall(): if a.is_forall():
header = '&forall;' header = "&forall;"
else: else:
header = '&exist;' header = "&exist;"
return group(compose(to_format(header, 1), return group(compose(to_format(header, 1),
indent(1, compose(ys_pp, to_format(' :'), line_break(), body_pp)))) indent(1, compose(ys_pp, to_format(" :"), line_break(), body_pp))))
_PP = PP() _PP = PP()
_Formatter = Formatter() _Formatter = Formatter()
def set_pp_option(k, v): def set_pp_option(k, v):
if k == 'html_mode': if k == "html_mode":
if v: if v:
set_html_mode(True) set_html_mode(True)
else: else:
set_html_mode(False) set_html_mode(False)
return True return True
if k == 'fpa_pretty': if k == "fpa_pretty":
if v: if v:
set_fpa_pretty(True) set_fpa_pretty(True)
else: else:
set_fpa_pretty(False) set_fpa_pretty(False)
return True return True
val = getattr(_PP, k, None) val = getattr(_PP, k, None)
if val != None: if val is not None:
_z3_assert(type(v) == type(val), "Invalid pretty print option value") _z3_assert(isinstance(v, type(val)), "Invalid pretty print option value")
setattr(_PP, k, v) setattr(_PP, k, v)
return True return True
val = getattr(_Formatter, k, None) val = getattr(_Formatter, k, None)
if val != None: if val is not None:
_z3_assert(type(v) == type(val), "Invalid pretty print option value") _z3_assert(isinstance(v, type(val)), "Invalid pretty print option value")
setattr(_Formatter, k, v) setattr(_Formatter, k, v)
return True return True
return False return False
def obj_to_string(a): def obj_to_string(a):
out = io.StringIO() out = io.StringIO()
_PP(out, _Formatter(a)) _PP(out, _Formatter(a))
return out.getvalue() return out.getvalue()
_html_out = None _html_out = None
def set_html_mode(flag=True): def set_html_mode(flag=True):
global _Formatter global _Formatter
if flag: if flag:
@ -1259,6 +1333,7 @@ def set_html_mode(flag=True):
else: else:
_Formatter = Formatter() _Formatter = Formatter()
def set_fpa_pretty(flag=True): def set_fpa_pretty(flag=True):
global _Formatter global _Formatter
global _z3_op_to_str global _z3_op_to_str
@ -1274,21 +1349,26 @@ def set_fpa_pretty(flag=True):
for _k in _z3_fpa_infix: for _k in _z3_fpa_infix:
_infix_map[_k] = False _infix_map[_k] = False
set_fpa_pretty(True) set_fpa_pretty(True)
def get_fpa_pretty(): def get_fpa_pretty():
global Formatter global Formatter
return _Formatter.fpa_pretty return _Formatter.fpa_pretty
def in_html_mode(): def in_html_mode():
return isinstance(_Formatter, HTMLFormatter) return isinstance(_Formatter, HTMLFormatter)
def pp(a): def pp(a):
if _support_pp(a): if _support_pp(a):
print(obj_to_string(a)) print(obj_to_string(a))
else: else:
print(a) print(a)
def print_matrix(m): def print_matrix(m):
_z3_assert(isinstance(m, list) or isinstance(m, tuple), "matrix expected") _z3_assert(isinstance(m, list) or isinstance(m, tuple), "matrix expected")
if not in_html_mode(): if not in_html_mode():
@ -1297,11 +1377,12 @@ def print_matrix(m):
print('<table cellpadding="2", cellspacing="0", border="1">') print('<table cellpadding="2", cellspacing="0", border="1">')
for r in m: for r in m:
_z3_assert(isinstance(r, list) or isinstance(r, tuple), "matrix expected") _z3_assert(isinstance(r, list) or isinstance(r, tuple), "matrix expected")
print('<tr>') print("<tr>")
for c in r: for c in r:
print('<td>%s</td>' % c) print("<td>%s</td>" % c)
print('</tr>') print("</tr>")
print('</table>') print("</table>")
def insert_line_breaks(s, width): def insert_line_breaks(s, width):
"""Break s in lines of size width (approx)""" """Break s in lines of size width (approx)"""
@ -1311,8 +1392,8 @@ def insert_line_breaks(s, width):
new_str = io.StringIO() new_str = io.StringIO()
w = 0 w = 0
for i in range(sz): for i in range(sz):
if w > width and s[i] == ' ': if w > width and s[i] == " ":
new_str.write(u('<br />')) new_str.write(u("<br />"))
w = 0 w = 0
else: else:
new_str.write(u(s[i])) new_str.write(u(s[i]))

6
src/api/python/z3/z3rcf.py
View file

@ -14,26 +14,31 @@ from .z3core import *
from .z3printer import * from .z3printer import *
from fractions import Fraction from fractions import Fraction
def _to_rcfnum(num, ctx=None): def _to_rcfnum(num, ctx=None):
if isinstance(num, RCFNum): if isinstance(num, RCFNum):
return num return num
else: else:
return RCFNum(num, ctx) return RCFNum(num, ctx)
def Pi(ctx=None): def Pi(ctx=None):
ctx = z3.get_ctx(ctx) ctx = z3.get_ctx(ctx)
return RCFNum(Z3_rcf_mk_pi(ctx.ref()), ctx) return RCFNum(Z3_rcf_mk_pi(ctx.ref()), ctx)
def E(ctx=None): def E(ctx=None):
ctx = z3.get_ctx(ctx) ctx = z3.get_ctx(ctx)
return RCFNum(Z3_rcf_mk_e(ctx.ref()), ctx) return RCFNum(Z3_rcf_mk_e(ctx.ref()), ctx)
def MkInfinitesimal(name="eps", ctx=None): def MkInfinitesimal(name="eps", ctx=None):
# Todo: remove parameter name. # Todo: remove parameter name.
# For now, we keep it for backward compatibility. # For now, we keep it for backward compatibility.
ctx = z3.get_ctx(ctx) ctx = z3.get_ctx(ctx)
return RCFNum(Z3_rcf_mk_infinitesimal(ctx.ref()), ctx) return RCFNum(Z3_rcf_mk_infinitesimal(ctx.ref()), ctx)
def MkRoots(p, ctx=None): def MkRoots(p, ctx=None):
ctx = z3.get_ctx(ctx) ctx = z3.get_ctx(ctx)
num = len(p) num = len(p)
@ -50,6 +55,7 @@ def MkRoots(p, ctx=None):
r.append(RCFNum(_rs[i], ctx)) r.append(RCFNum(_rs[i], ctx))
return r return r
class RCFNum: class RCFNum:
def __init__(self, num, ctx=None): def __init__(self, num, ctx=None):
# TODO: add support for converting AST numeral values into RCFNum # TODO: add support for converting AST numeral values into RCFNum

227
src/api/python/z3/z3types.py
View file

@ -8,123 +8,234 @@
import ctypes import ctypes
class Z3Exception(Exception): class Z3Exception(Exception):
def __init__(self, value): def __init__(self, value):
self.value = value self.value = value
def __str__(self): def __str__(self):
return str(self.value) return str(self.value)
class ContextObj(ctypes.c_void_p): class ContextObj(ctypes.c_void_p):
def __init__(self, context): self._as_parameter_ = context def __init__(self, context):
def from_param(obj): return obj self._as_parameter_ = context
def from_param(obj):
return obj
class Config(ctypes.c_void_p): class Config(ctypes.c_void_p):
def __init__(self, config): self._as_parameter_ = config def __init__(self, config):
def from_param(obj): return obj self._as_parameter_ = config
def from_param(obj):
return obj
class Symbol(ctypes.c_void_p): class Symbol(ctypes.c_void_p):
def __init__(self, symbol): self._as_parameter_ = symbol def __init__(self, symbol):
def from_param(obj): return obj self._as_parameter_ = symbol
def from_param(obj):
return obj
class Sort(ctypes.c_void_p): class Sort(ctypes.c_void_p):
def __init__(self, sort): self._as_parameter_ = sort def __init__(self, sort):
def from_param(obj): return obj self._as_parameter_ = sort
def from_param(obj):
return obj
class FuncDecl(ctypes.c_void_p): class FuncDecl(ctypes.c_void_p):
def __init__(self, decl): self._as_parameter_ = decl def __init__(self, decl):
def from_param(obj): return obj self._as_parameter_ = decl
def from_param(obj):
return obj
class Ast(ctypes.c_void_p): class Ast(ctypes.c_void_p):
def __init__(self, ast): self._as_parameter_ = ast def __init__(self, ast):
def from_param(obj): return obj self._as_parameter_ = ast
def from_param(obj):
return obj
class Pattern(ctypes.c_void_p): class Pattern(ctypes.c_void_p):
def __init__(self, pattern): self._as_parameter_ = pattern def __init__(self, pattern):
def from_param(obj): return obj self._as_parameter_ = pattern
def from_param(obj):
return obj
class Model(ctypes.c_void_p): class Model(ctypes.c_void_p):
def __init__(self, model): self._as_parameter_ = model def __init__(self, model):
def from_param(obj): return obj self._as_parameter_ = model
def from_param(obj):
return obj
class Literals(ctypes.c_void_p): class Literals(ctypes.c_void_p):
def __init__(self, literals): self._as_parameter_ = literals def __init__(self, literals):
def from_param(obj): return obj self._as_parameter_ = literals
def from_param(obj):
return obj
class Constructor(ctypes.c_void_p): class Constructor(ctypes.c_void_p):
def __init__(self, constructor): self._as_parameter_ = constructor def __init__(self, constructor):
def from_param(obj): return obj self._as_parameter_ = constructor
def from_param(obj):
return obj
class ConstructorList(ctypes.c_void_p): class ConstructorList(ctypes.c_void_p):
def __init__(self, constructor_list): self._as_parameter_ = constructor_list def __init__(self, constructor_list):
def from_param(obj): return obj self._as_parameter_ = constructor_list
def from_param(obj):
return obj
class GoalObj(ctypes.c_void_p): class GoalObj(ctypes.c_void_p):
def __init__(self, goal): self._as_parameter_ = goal def __init__(self, goal):
def from_param(obj): return obj self._as_parameter_ = goal
def from_param(obj):
return obj
class TacticObj(ctypes.c_void_p): class TacticObj(ctypes.c_void_p):
def __init__(self, tactic): self._as_parameter_ = tactic def __init__(self, tactic):
def from_param(obj): return obj self._as_parameter_ = tactic
def from_param(obj):
return obj
class ProbeObj(ctypes.c_void_p): class ProbeObj(ctypes.c_void_p):
def __init__(self, probe): self._as_parameter_ = probe def __init__(self, probe):
def from_param(obj): return obj self._as_parameter_ = probe
def from_param(obj):
return obj
class ApplyResultObj(ctypes.c_void_p): class ApplyResultObj(ctypes.c_void_p):
def __init__(self, obj): self._as_parameter_ = obj def __init__(self, obj):
def from_param(obj): return obj self._as_parameter_ = obj
def from_param(obj):
return obj
class StatsObj(ctypes.c_void_p): class StatsObj(ctypes.c_void_p):
def __init__(self, statistics): self._as_parameter_ = statistics def __init__(self, statistics):
def from_param(obj): return obj self._as_parameter_ = statistics
def from_param(obj):
return obj
class SolverObj(ctypes.c_void_p): class SolverObj(ctypes.c_void_p):
def __init__(self, solver): self._as_parameter_ = solver def __init__(self, solver):
def from_param(obj): return obj self._as_parameter_ = solver
def from_param(obj):
return obj
class SolverCallbackObj(ctypes.c_void_p): class SolverCallbackObj(ctypes.c_void_p):
def __init__(self, solver): self._as_parameter_ = solver def __init__(self, solver):
def from_param(obj): return obj self._as_parameter_ = solver
def from_param(obj):
return obj
class FixedpointObj(ctypes.c_void_p): class FixedpointObj(ctypes.c_void_p):
def __init__(self, fixedpoint): self._as_parameter_ = fixedpoint def __init__(self, fixedpoint):
def from_param(obj): return obj self._as_parameter_ = fixedpoint
def from_param(obj):
return obj
class OptimizeObj(ctypes.c_void_p): class OptimizeObj(ctypes.c_void_p):
def __init__(self, optimize): self._as_parameter_ = optimize def __init__(self, optimize):
def from_param(obj): return obj self._as_parameter_ = optimize
def from_param(obj):
return obj
class ModelObj(ctypes.c_void_p): class ModelObj(ctypes.c_void_p):
def __init__(self, model): self._as_parameter_ = model def __init__(self, model):
def from_param(obj): return obj self._as_parameter_ = model
def from_param(obj):
return obj
class AstVectorObj(ctypes.c_void_p): class AstVectorObj(ctypes.c_void_p):
def __init__(self, vector): self._as_parameter_ = vector def __init__(self, vector):
def from_param(obj): return obj self._as_parameter_ = vector
def from_param(obj):
return obj
class AstMapObj(ctypes.c_void_p): class AstMapObj(ctypes.c_void_p):
def __init__(self, ast_map): self._as_parameter_ = ast_map def __init__(self, ast_map):
def from_param(obj): return obj self._as_parameter_ = ast_map
def from_param(obj):
return obj
class Params(ctypes.c_void_p): class Params(ctypes.c_void_p):
def __init__(self, params): self._as_parameter_ = params def __init__(self, params):
def from_param(obj): return obj self._as_parameter_ = params
def from_param(obj):
return obj
class ParamDescrs(ctypes.c_void_p): class ParamDescrs(ctypes.c_void_p):
def __init__(self, paramdescrs): self._as_parameter_ = paramdescrs def __init__(self, paramdescrs):
def from_param(obj): return obj self._as_parameter_ = paramdescrs
def from_param(obj):
return obj
class FuncInterpObj(ctypes.c_void_p): class FuncInterpObj(ctypes.c_void_p):
def __init__(self, f): self._as_parameter_ = f def __init__(self, f):
def from_param(obj): return obj self._as_parameter_ = f
def from_param(obj):
return obj
class FuncEntryObj(ctypes.c_void_p): class FuncEntryObj(ctypes.c_void_p):
def __init__(self, e): self._as_parameter_ = e def __init__(self, e):
def from_param(obj): return obj self._as_parameter_ = e
def from_param(obj):
return obj
class RCFNumObj(ctypes.c_void_p): class RCFNumObj(ctypes.c_void_p):
def __init__(self, e): self._as_parameter_ = e def __init__(self, e):
def from_param(obj): return obj self._as_parameter_ = e
def from_param(obj):
return obj

32
src/api/python/z3/z3util.py
View file

@ -14,6 +14,7 @@ import common_z3 as CM_Z3
import ctypes import ctypes
from .z3 import * from .z3 import *
def vset(seq, idfun=None, as_list=True): def vset(seq, idfun=None, as_list=True):
# This functions preserves the order of arguments while removing duplicates. # This functions preserves the order of arguments while removing duplicates.
# This function is from https://code.google.com/p/common-python-vu/source/browse/vu_common.py # This function is from https://code.google.com/p/common-python-vu/source/browse/vu_common.py
@ -87,6 +88,7 @@ In Z3, variables are called *uninterpreted* consts and
variables are *interpreted* consts. variables are *interpreted* consts.
""" """
def is_expr_var(v): def is_expr_var(v):
""" """
EXAMPLES: EXAMPLES:
@ -113,6 +115,7 @@ def is_expr_var(v):
return is_const(v) and v.decl().kind() == Z3_OP_UNINTERPRETED return is_const(v) and v.decl().kind() == Z3_OP_UNINTERPRETED
def is_expr_val(v): def is_expr_val(v):
""" """
EXAMPLES: EXAMPLES:
@ -139,8 +142,6 @@ def is_expr_val(v):
return is_const(v) and v.decl().kind() != Z3_OP_UNINTERPRETED return is_const(v) and v.decl().kind() != Z3_OP_UNINTERPRETED
def get_vars(f, rs=None): def get_vars(f, rs=None):
""" """
>>> x,y = Ints('x y') >>> x,y = Ints('x y')
@ -168,7 +169,6 @@ def get_vars(f, rs = None):
return vset(rs, str) return vset(rs, str)
def mk_var(name, vsort): def mk_var(name, vsort):
if vsort.kind() == Z3_INT_SORT: if vsort.kind() == Z3_INT_SORT:
v = Int(name) v = Int(name)
@ -179,12 +179,11 @@ def mk_var(name, vsort):
elif vsort.kind() == Z3_DATATYPE_SORT: elif vsort.kind() == Z3_DATATYPE_SORT:
v = Const(name, vsort) v = Const(name, vsort)
else: else:
raise TypeError('Cannot handle this sort (s: %sid: %d)' %(vsort,vsort.kind())) raise TypeError("Cannot handle this sort (s: %sid: %d)" % (vsort, vsort.kind()))
return v return v
def prove(claim, assume=None, verbose=0): def prove(claim, assume=None, verbose=0):
""" """
>>> r,m = prove(BoolVal(True),verbose=0); r,model_str(m,as_str=False) >>> r,m = prove(BoolVal(True),verbose=0); r,model_str(m,as_str=False)
@ -249,18 +248,18 @@ def prove(claim,assume=None,verbose=0):
to_prove = Implies(assume, to_prove) to_prove = Implies(assume, to_prove)
if verbose >= 2: if verbose >= 2:
print('assume: ') print("assume: ")
print(assume) print(assume)
print('claim: ') print("claim: ")
print(claim) print(claim)
print('to_prove: ') print("to_prove: ")
print(to_prove) print(to_prove)
f = Not(to_prove) f = Not(to_prove)
models = get_models(f, k=1) models = get_models(f, k=1)
if models is None: # unknown if models is None: # unknown
print('E: cannot solve !') print("E: cannot solve !")
return None, None return None, None
elif models == False: # unsat elif models == False: # unsat
return True, None return True, None
@ -280,7 +279,7 @@ def get_models(f,k):
If f is not satisfiable, returns False. If f is not satisfiable, returns False.
If f cannot be solved, returns None If f cannot be solved, returns None
If f is satisfiable, returns the first k models If f is satisfiable, returns the first k models
Note that if f is a tautology, e.g.\ True, then the result is [] Note that if f is a tautology, e.g.\\ True, then the result is []
Based on http://stackoverflow.com/questions/11867611/z3py-checking-all-solutions-for-equation Based on http://stackoverflow.com/questions/11867611/z3py-checking-all-solutions-for-equation
@ -327,12 +326,10 @@ def get_models(f,k):
break break
models.append(m) models.append(m)
# create new constraint to block the current model # create new constraint to block the current model
block = Not(And([v() == m[v] for v in m])) block = Not(And([v() == m[v] for v in m]))
s.add(block) s.add(block)
if s.check() == unknown: if s.check() == unknown:
return None return None
elif s.check() == unsat and i == 0: elif s.check() == unsat and i == 0:
@ -340,6 +337,7 @@ def get_models(f,k):
else: else:
return models return models
def is_tautology(claim, verbose=0): def is_tautology(claim, verbose=0):
""" """
>>> is_tautology(Implies(Bool('x'),Bool('x'))) >>> is_tautology(Implies(Bool('x'),Bool('x')))
@ -410,7 +408,6 @@ def exact_one_model(f):
return False return False
def myBinOp(op, *L): def myBinOp(op, *L):
""" """
>>> myAnd(*[Bool('x'),Bool('y')]) >>> myAnd(*[Bool('x'),Bool('y')])
@ -467,14 +464,18 @@ def myBinOp(op,*L):
def myAnd(*L): def myAnd(*L):
return myBinOp(Z3_OP_AND, *L) return myBinOp(Z3_OP_AND, *L)
def myOr(*L): def myOr(*L):
return myBinOp(Z3_OP_OR, *L) return myBinOp(Z3_OP_OR, *L)
def myImplies(a, b): def myImplies(a, b):
return myBinOp(Z3_OP_IMPLIES, [a, b]) return myBinOp(Z3_OP_IMPLIES, [a, b])
Iff = lambda f: And(Implies(f[0],f[1]),Implies(f[1],f[0])) def Iff(f):
return And(Implies(f[0], f[1]), Implies(f[1], f[0]))
def model_str(m, as_str=True): def model_str(m, as_str=True):
""" """
@ -494,9 +495,8 @@ def model_str(m,as_str=True):
vs = [(v, m[v]) for v in m] vs = [(v, m[v]) for v in m]
vs = sorted(vs, key=lambda a, _: str(a)) vs = sorted(vs, key=lambda a, _: str(a))
if as_str: if as_str:
return '\n'.join(['{} = {}'.format(k,v) for (k,v) in vs]) return "\n".join(["{} = {}".format(k, v) for (k, v) in vs])
else: else:
return vs return vs
else: else:
return str(m) if as_str else m return str(m) if as_str else m