mirrors/z3
3
0
Fork 0
mirror of https://github.com/Z3Prover/z3 synced 2025-04-27 02:45:51 +00:00
Code Activity

working on symbolic execution for PDR

Browse source 
Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com>
This commit is contained in:
Nikolaj Bjorner 2012-10-18 21:09:32 -07:00
commit b22fb74c5c
35 changed files with 20978 additions and 20579 deletions
Download patch file Download diff file Expand all files Collapse all files

8
Makefile.in
View file

@ -338,6 +338,9 @@ install: $(BIN_DIR)/$(Z3) $(BIN_DIR)/lib$(Z3).@SO_EXT@ $(BIN_DIR)/lib$(Z3).a
@cp lib/z3.h $(PREFIX)/include
@cp lib/z3_v1.h $(PREFIX)/include
@cp lib/z3_macros.h $(PREFIX)/include
@cp lib/z3_internal.h $(PREFIX)/include
@cp lib/z3_internal_types.h $(PREFIX)/include
@cp lib/z3_poly.h $(PREFIX)/include
@cp c++/z3++.h $(PREFIX)/include
uninstall:
@ -349,6 +352,9 @@ uninstall:
@rm -f $(PREFIX)/include/z3_v1.h
@rm -f $(PREFIX)/include/z3_macros.h
@rm -f $(PREFIX)/include/z3++.h
@rm -f $(PREFIX)/include/z3_internal.h
@rm -f $(PREFIX)/include/z3_internal_types.h
@rm -f $(PREFIX)/include/z3_poly.h
install-z3py: $(BIN_DIR)/lib$(Z3).@SO_EXT@
@if test $(HAS_PYTHON) -eq 0; then echo "Python is not available in your system."; exit 1; fi
@ -360,6 +366,7 @@ install-z3py: $(BIN_DIR)/lib$(Z3).@SO_EXT@
@cp python/z3consts.pyc $(PYTHON_PACKAGE_DIR)
@cp python/z3tactics.pyc $(PYTHON_PACKAGE_DIR)
@cp python/z3printer.pyc $(PYTHON_PACKAGE_DIR)
@cp python/z3poly.pyc $(PYTHON_PACKAGE_DIR)
@cp $(BIN_DIR)/lib$(Z3).@SO_EXT@ $(PYTHON_PACKAGE_DIR)
@if python python/z3test.py; then echo "Z3Py was successfully installed."; else echo "Failed to execute Z3Py regressions..."; exit 1; fi
@ -372,4 +379,5 @@ uninstall-z3py:
@rm -f $(PYTHON_PACKAGE_DIR)/z3consts.pyc
@rm -f $(PYTHON_PACKAGE_DIR)/z3tactics.pyc
@rm -f $(PYTHON_PACKAGE_DIR)/z3printer.pyc
@rm -f $(PYTHON_PACKAGE_DIR)/z3poly.pyc
@rm -f $(PYTHON_PACKAGE_DIR)/$(BIN_DIR)/lib$(Z3).@SO_EXT@

516
Microsoft.Z3/Enumerations.cs
View file

@ -1,258 +1,258 @@
// Automatically generated file, generator: mk_z3consts.py
using System;
#pragma warning disable 1591
namespace Microsoft.Z3
{
/// <summary>Z3_lbool</summary>
public enum Z3_lbool {
Z3_L_TRUE = 1,
Z3_L_UNDEF = 0,
Z3_L_FALSE = -1,
}
/// <summary>Z3_symbol_kind</summary>
public enum Z3_symbol_kind {
Z3_INT_SYMBOL = 0,
Z3_STRING_SYMBOL = 1,
}
/// <summary>Z3_parameter_kind</summary>
public enum Z3_parameter_kind {
Z3_PARAMETER_FUNC_DECL = 6,
Z3_PARAMETER_DOUBLE = 1,
Z3_PARAMETER_SYMBOL = 3,
Z3_PARAMETER_INT = 0,
Z3_PARAMETER_AST = 5,
Z3_PARAMETER_SORT = 4,
Z3_PARAMETER_RATIONAL = 2,
}
/// <summary>Z3_sort_kind</summary>
public enum Z3_sort_kind {
Z3_BV_SORT = 4,
Z3_FINITE_DOMAIN_SORT = 8,
Z3_ARRAY_SORT = 5,
Z3_UNKNOWN_SORT = 1000,
Z3_RELATION_SORT = 7,
Z3_REAL_SORT = 3,
Z3_INT_SORT = 2,
Z3_UNINTERPRETED_SORT = 0,
Z3_BOOL_SORT = 1,
Z3_DATATYPE_SORT = 6,
}
/// <summary>Z3_ast_kind</summary>
public enum Z3_ast_kind {
Z3_VAR_AST = 2,
Z3_SORT_AST = 4,
Z3_QUANTIFIER_AST = 3,
Z3_UNKNOWN_AST = 1000,
Z3_FUNC_DECL_AST = 5,
Z3_NUMERAL_AST = 0,
Z3_APP_AST = 1,
}
/// <summary>Z3_decl_kind</summary>
public enum Z3_decl_kind {
Z3_OP_LABEL = 1792,
Z3_OP_PR_REWRITE = 1294,
Z3_OP_UNINTERPRETED = 2051,
Z3_OP_SUB = 519,
Z3_OP_ZERO_EXT = 1058,
Z3_OP_ADD = 518,
Z3_OP_IS_INT = 528,
Z3_OP_BREDOR = 1061,
Z3_OP_BNOT = 1051,
Z3_OP_BNOR = 1054,
Z3_OP_PR_CNF_STAR = 1315,
Z3_OP_RA_JOIN = 1539,
Z3_OP_LE = 514,
Z3_OP_SET_UNION = 773,
Z3_OP_PR_UNDEF = 1280,
Z3_OP_BREDAND = 1062,
Z3_OP_LT = 516,
Z3_OP_RA_UNION = 1540,
Z3_OP_BADD = 1028,
Z3_OP_BUREM0 = 1039,
Z3_OP_OEQ = 267,
Z3_OP_PR_MODUS_PONENS = 1284,
Z3_OP_RA_CLONE = 1548,
Z3_OP_REPEAT = 1060,
Z3_OP_RA_NEGATION_FILTER = 1544,
Z3_OP_BSMOD0 = 1040,
Z3_OP_BLSHR = 1065,
Z3_OP_BASHR = 1066,
Z3_OP_PR_UNIT_RESOLUTION = 1304,
Z3_OP_ROTATE_RIGHT = 1068,
Z3_OP_ARRAY_DEFAULT = 772,
Z3_OP_PR_PULL_QUANT = 1296,
Z3_OP_PR_APPLY_DEF = 1310,
Z3_OP_PR_REWRITE_STAR = 1295,
Z3_OP_IDIV = 523,
Z3_OP_PR_GOAL = 1283,
Z3_OP_PR_IFF_TRUE = 1305,
Z3_OP_LABEL_LIT = 1793,
Z3_OP_BOR = 1050,
Z3_OP_PR_SYMMETRY = 1286,
Z3_OP_TRUE = 256,
Z3_OP_SET_COMPLEMENT = 776,
Z3_OP_CONCAT = 1056,
Z3_OP_PR_NOT_OR_ELIM = 1293,
Z3_OP_IFF = 263,
Z3_OP_BSHL = 1064,
Z3_OP_PR_TRANSITIVITY = 1287,
Z3_OP_SGT = 1048,
Z3_OP_RA_WIDEN = 1541,
Z3_OP_PR_DEF_INTRO = 1309,
Z3_OP_NOT = 265,
Z3_OP_PR_QUANT_INTRO = 1290,
Z3_OP_UGT = 1047,
Z3_OP_DT_RECOGNISER = 2049,
Z3_OP_SET_INTERSECT = 774,
Z3_OP_BSREM = 1033,
Z3_OP_RA_STORE = 1536,
Z3_OP_SLT = 1046,
Z3_OP_ROTATE_LEFT = 1067,
Z3_OP_PR_NNF_NEG = 1313,
Z3_OP_PR_REFLEXIVITY = 1285,
Z3_OP_ULEQ = 1041,
Z3_OP_BIT1 = 1025,
Z3_OP_BIT0 = 1026,
Z3_OP_EQ = 258,
Z3_OP_BMUL = 1030,
Z3_OP_ARRAY_MAP = 771,
Z3_OP_STORE = 768,
Z3_OP_PR_HYPOTHESIS = 1302,
Z3_OP_RA_RENAME = 1545,
Z3_OP_AND = 261,
Z3_OP_TO_REAL = 526,
Z3_OP_PR_NNF_POS = 1312,
Z3_OP_PR_AND_ELIM = 1292,
Z3_OP_MOD = 525,
Z3_OP_BUDIV0 = 1037,
Z3_OP_PR_TRUE = 1281,
Z3_OP_BNAND = 1053,
Z3_OP_PR_ELIM_UNUSED_VARS = 1299,
Z3_OP_RA_FILTER = 1543,
Z3_OP_FD_LT = 1549,
Z3_OP_RA_EMPTY = 1537,
Z3_OP_DIV = 522,
Z3_OP_ANUM = 512,
Z3_OP_MUL = 521,
Z3_OP_UGEQ = 1043,
Z3_OP_BSREM0 = 1038,
Z3_OP_PR_TH_LEMMA = 1318,
Z3_OP_BXOR = 1052,
Z3_OP_DISTINCT = 259,
Z3_OP_PR_IFF_FALSE = 1306,
Z3_OP_BV2INT = 1072,
Z3_OP_EXT_ROTATE_LEFT = 1069,
Z3_OP_PR_PULL_QUANT_STAR = 1297,
Z3_OP_BSUB = 1029,
Z3_OP_PR_ASSERTED = 1282,
Z3_OP_BXNOR = 1055,
Z3_OP_EXTRACT = 1059,
Z3_OP_PR_DER = 1300,
Z3_OP_DT_CONSTRUCTOR = 2048,
Z3_OP_GT = 517,
Z3_OP_BUREM = 1034,
Z3_OP_IMPLIES = 266,
Z3_OP_SLEQ = 1042,
Z3_OP_GE = 515,
Z3_OP_BAND = 1049,
Z3_OP_ITE = 260,
Z3_OP_AS_ARRAY = 778,
Z3_OP_RA_SELECT = 1547,
Z3_OP_CONST_ARRAY = 770,
Z3_OP_BSDIV = 1031,
Z3_OP_OR = 262,
Z3_OP_PR_HYPER_RESOLVE = 1319,
Z3_OP_AGNUM = 513,
Z3_OP_PR_PUSH_QUANT = 1298,
Z3_OP_BSMOD = 1035,
Z3_OP_PR_IFF_OEQ = 1311,
Z3_OP_PR_LEMMA = 1303,
Z3_OP_SET_SUBSET = 777,
Z3_OP_SELECT = 769,
Z3_OP_RA_PROJECT = 1542,
Z3_OP_BNEG = 1027,
Z3_OP_UMINUS = 520,
Z3_OP_REM = 524,
Z3_OP_TO_INT = 527,
Z3_OP_PR_QUANT_INST = 1301,
Z3_OP_SGEQ = 1044,
Z3_OP_POWER = 529,
Z3_OP_XOR3 = 1074,
Z3_OP_RA_IS_EMPTY = 1538,
Z3_OP_CARRY = 1073,
Z3_OP_DT_ACCESSOR = 2050,
Z3_OP_PR_TRANSITIVITY_STAR = 1288,
Z3_OP_PR_NNF_STAR = 1314,
Z3_OP_PR_COMMUTATIVITY = 1307,
Z3_OP_ULT = 1045,
Z3_OP_BSDIV0 = 1036,
Z3_OP_SET_DIFFERENCE = 775,
Z3_OP_INT2BV = 1071,
Z3_OP_XOR = 264,
Z3_OP_PR_MODUS_PONENS_OEQ = 1317,
Z3_OP_BNUM = 1024,
Z3_OP_BUDIV = 1032,
Z3_OP_PR_MONOTONICITY = 1289,
Z3_OP_PR_DEF_AXIOM = 1308,
Z3_OP_FALSE = 257,
Z3_OP_EXT_ROTATE_RIGHT = 1070,
Z3_OP_PR_DISTRIBUTIVITY = 1291,
Z3_OP_SIGN_EXT = 1057,
Z3_OP_PR_SKOLEMIZE = 1316,
Z3_OP_BCOMP = 1063,
Z3_OP_RA_COMPLEMENT = 1546,
}
/// <summary>Z3_param_kind</summary>
public enum Z3_param_kind {
Z3_PK_BOOL = 1,
Z3_PK_SYMBOL = 3,
Z3_PK_OTHER = 5,
Z3_PK_INVALID = 6,
Z3_PK_UINT = 0,
Z3_PK_STRING = 4,
Z3_PK_DOUBLE = 2,
}
/// <summary>Z3_ast_print_mode</summary>
public enum Z3_ast_print_mode {
Z3_PRINT_SMTLIB2_COMPLIANT = 3,
Z3_PRINT_SMTLIB_COMPLIANT = 2,
Z3_PRINT_SMTLIB_FULL = 0,
Z3_PRINT_LOW_LEVEL = 1,
}
/// <summary>Z3_error_code</summary>
public enum Z3_error_code {
Z3_INVALID_PATTERN = 6,
Z3_MEMOUT_FAIL = 7,
Z3_NO_PARSER = 5,
Z3_OK = 0,
Z3_INVALID_ARG = 3,
Z3_EXCEPTION = 12,
Z3_IOB = 2,
Z3_INTERNAL_FATAL = 9,
Z3_INVALID_USAGE = 10,
Z3_FILE_ACCESS_ERROR = 8,
Z3_SORT_ERROR = 1,
Z3_PARSER_ERROR = 4,
Z3_DEC_REF_ERROR = 11,
}
/// <summary>Z3_goal_prec</summary>
public enum Z3_goal_prec {
Z3_GOAL_UNDER = 1,
Z3_GOAL_PRECISE = 0,
Z3_GOAL_UNDER_OVER = 3,
Z3_GOAL_OVER = 2,
}
}
// Automatically generated file, generator: update_api.py
using System;
#pragma warning disable 1591
namespace Microsoft.Z3
{
/// <summary>Z3_lbool</summary>
public enum Z3_lbool {
Z3_L_TRUE = 1,
Z3_L_UNDEF = 0,
Z3_L_FALSE = -1,
}
/// <summary>Z3_symbol_kind</summary>
public enum Z3_symbol_kind {
Z3_INT_SYMBOL = 0,
Z3_STRING_SYMBOL = 1,
}
/// <summary>Z3_parameter_kind</summary>
public enum Z3_parameter_kind {
Z3_PARAMETER_FUNC_DECL = 6,
Z3_PARAMETER_DOUBLE = 1,
Z3_PARAMETER_SYMBOL = 3,
Z3_PARAMETER_INT = 0,
Z3_PARAMETER_AST = 5,
Z3_PARAMETER_SORT = 4,
Z3_PARAMETER_RATIONAL = 2,
}
/// <summary>Z3_sort_kind</summary>
public enum Z3_sort_kind {
Z3_BV_SORT = 4,
Z3_FINITE_DOMAIN_SORT = 8,
Z3_ARRAY_SORT = 5,
Z3_UNKNOWN_SORT = 1000,
Z3_RELATION_SORT = 7,
Z3_REAL_SORT = 3,
Z3_INT_SORT = 2,
Z3_UNINTERPRETED_SORT = 0,
Z3_BOOL_SORT = 1,
Z3_DATATYPE_SORT = 6,
}
/// <summary>Z3_ast_kind</summary>
public enum Z3_ast_kind {
Z3_VAR_AST = 2,
Z3_SORT_AST = 4,
Z3_QUANTIFIER_AST = 3,
Z3_UNKNOWN_AST = 1000,
Z3_FUNC_DECL_AST = 5,
Z3_NUMERAL_AST = 0,
Z3_APP_AST = 1,
}
/// <summary>Z3_decl_kind</summary>
public enum Z3_decl_kind {
Z3_OP_LABEL = 1792,
Z3_OP_PR_REWRITE = 1294,
Z3_OP_UNINTERPRETED = 2051,
Z3_OP_SUB = 519,
Z3_OP_ZERO_EXT = 1058,
Z3_OP_ADD = 518,
Z3_OP_IS_INT = 528,
Z3_OP_BREDOR = 1061,
Z3_OP_BNOT = 1051,
Z3_OP_BNOR = 1054,
Z3_OP_PR_CNF_STAR = 1315,
Z3_OP_RA_JOIN = 1539,
Z3_OP_LE = 514,
Z3_OP_SET_UNION = 773,
Z3_OP_PR_UNDEF = 1280,
Z3_OP_BREDAND = 1062,
Z3_OP_LT = 516,
Z3_OP_RA_UNION = 1540,
Z3_OP_BADD = 1028,
Z3_OP_BUREM0 = 1039,
Z3_OP_OEQ = 267,
Z3_OP_PR_MODUS_PONENS = 1284,
Z3_OP_RA_CLONE = 1548,
Z3_OP_REPEAT = 1060,
Z3_OP_RA_NEGATION_FILTER = 1544,
Z3_OP_BSMOD0 = 1040,
Z3_OP_BLSHR = 1065,
Z3_OP_BASHR = 1066,
Z3_OP_PR_UNIT_RESOLUTION = 1304,
Z3_OP_ROTATE_RIGHT = 1068,
Z3_OP_ARRAY_DEFAULT = 772,
Z3_OP_PR_PULL_QUANT = 1296,
Z3_OP_PR_APPLY_DEF = 1310,
Z3_OP_PR_REWRITE_STAR = 1295,
Z3_OP_IDIV = 523,
Z3_OP_PR_GOAL = 1283,
Z3_OP_PR_IFF_TRUE = 1305,
Z3_OP_LABEL_LIT = 1793,
Z3_OP_BOR = 1050,
Z3_OP_PR_SYMMETRY = 1286,
Z3_OP_TRUE = 256,
Z3_OP_SET_COMPLEMENT = 776,
Z3_OP_CONCAT = 1056,
Z3_OP_PR_NOT_OR_ELIM = 1293,
Z3_OP_IFF = 263,
Z3_OP_BSHL = 1064,
Z3_OP_PR_TRANSITIVITY = 1287,
Z3_OP_SGT = 1048,
Z3_OP_RA_WIDEN = 1541,
Z3_OP_PR_DEF_INTRO = 1309,
Z3_OP_NOT = 265,
Z3_OP_PR_QUANT_INTRO = 1290,
Z3_OP_UGT = 1047,
Z3_OP_DT_RECOGNISER = 2049,
Z3_OP_SET_INTERSECT = 774,
Z3_OP_BSREM = 1033,
Z3_OP_RA_STORE = 1536,
Z3_OP_SLT = 1046,
Z3_OP_ROTATE_LEFT = 1067,
Z3_OP_PR_NNF_NEG = 1313,
Z3_OP_PR_REFLEXIVITY = 1285,
Z3_OP_ULEQ = 1041,
Z3_OP_BIT1 = 1025,
Z3_OP_BIT0 = 1026,
Z3_OP_EQ = 258,
Z3_OP_BMUL = 1030,
Z3_OP_ARRAY_MAP = 771,
Z3_OP_STORE = 768,
Z3_OP_PR_HYPOTHESIS = 1302,
Z3_OP_RA_RENAME = 1545,
Z3_OP_AND = 261,
Z3_OP_TO_REAL = 526,
Z3_OP_PR_NNF_POS = 1312,
Z3_OP_PR_AND_ELIM = 1292,
Z3_OP_MOD = 525,
Z3_OP_BUDIV0 = 1037,
Z3_OP_PR_TRUE = 1281,
Z3_OP_BNAND = 1053,
Z3_OP_PR_ELIM_UNUSED_VARS = 1299,
Z3_OP_RA_FILTER = 1543,
Z3_OP_FD_LT = 1549,
Z3_OP_RA_EMPTY = 1537,
Z3_OP_DIV = 522,
Z3_OP_ANUM = 512,
Z3_OP_MUL = 521,
Z3_OP_UGEQ = 1043,
Z3_OP_BSREM0 = 1038,
Z3_OP_PR_TH_LEMMA = 1318,
Z3_OP_BXOR = 1052,
Z3_OP_DISTINCT = 259,
Z3_OP_PR_IFF_FALSE = 1306,
Z3_OP_BV2INT = 1072,
Z3_OP_EXT_ROTATE_LEFT = 1069,
Z3_OP_PR_PULL_QUANT_STAR = 1297,
Z3_OP_BSUB = 1029,
Z3_OP_PR_ASSERTED = 1282,
Z3_OP_BXNOR = 1055,
Z3_OP_EXTRACT = 1059,
Z3_OP_PR_DER = 1300,
Z3_OP_DT_CONSTRUCTOR = 2048,
Z3_OP_GT = 517,
Z3_OP_BUREM = 1034,
Z3_OP_IMPLIES = 266,
Z3_OP_SLEQ = 1042,
Z3_OP_GE = 515,
Z3_OP_BAND = 1049,
Z3_OP_ITE = 260,
Z3_OP_AS_ARRAY = 778,
Z3_OP_RA_SELECT = 1547,
Z3_OP_CONST_ARRAY = 770,
Z3_OP_BSDIV = 1031,
Z3_OP_OR = 262,
Z3_OP_PR_HYPER_RESOLVE = 1319,
Z3_OP_AGNUM = 513,
Z3_OP_PR_PUSH_QUANT = 1298,
Z3_OP_BSMOD = 1035,
Z3_OP_PR_IFF_OEQ = 1311,
Z3_OP_PR_LEMMA = 1303,
Z3_OP_SET_SUBSET = 777,
Z3_OP_SELECT = 769,
Z3_OP_RA_PROJECT = 1542,
Z3_OP_BNEG = 1027,
Z3_OP_UMINUS = 520,
Z3_OP_REM = 524,
Z3_OP_TO_INT = 527,
Z3_OP_PR_QUANT_INST = 1301,
Z3_OP_SGEQ = 1044,
Z3_OP_POWER = 529,
Z3_OP_XOR3 = 1074,
Z3_OP_RA_IS_EMPTY = 1538,
Z3_OP_CARRY = 1073,
Z3_OP_DT_ACCESSOR = 2050,
Z3_OP_PR_TRANSITIVITY_STAR = 1288,
Z3_OP_PR_NNF_STAR = 1314,
Z3_OP_PR_COMMUTATIVITY = 1307,
Z3_OP_ULT = 1045,
Z3_OP_BSDIV0 = 1036,
Z3_OP_SET_DIFFERENCE = 775,
Z3_OP_INT2BV = 1071,
Z3_OP_XOR = 264,
Z3_OP_PR_MODUS_PONENS_OEQ = 1317,
Z3_OP_BNUM = 1024,
Z3_OP_BUDIV = 1032,
Z3_OP_PR_MONOTONICITY = 1289,
Z3_OP_PR_DEF_AXIOM = 1308,
Z3_OP_FALSE = 257,
Z3_OP_EXT_ROTATE_RIGHT = 1070,
Z3_OP_PR_DISTRIBUTIVITY = 1291,
Z3_OP_SIGN_EXT = 1057,
Z3_OP_PR_SKOLEMIZE = 1316,
Z3_OP_BCOMP = 1063,
Z3_OP_RA_COMPLEMENT = 1546,
}
/// <summary>Z3_param_kind</summary>
public enum Z3_param_kind {
Z3_PK_BOOL = 1,
Z3_PK_SYMBOL = 3,
Z3_PK_OTHER = 5,
Z3_PK_INVALID = 6,
Z3_PK_UINT = 0,
Z3_PK_STRING = 4,
Z3_PK_DOUBLE = 2,
}
/// <summary>Z3_ast_print_mode</summary>
public enum Z3_ast_print_mode {
Z3_PRINT_SMTLIB2_COMPLIANT = 3,
Z3_PRINT_SMTLIB_COMPLIANT = 2,
Z3_PRINT_SMTLIB_FULL = 0,
Z3_PRINT_LOW_LEVEL = 1,
}
/// <summary>Z3_error_code</summary>
public enum Z3_error_code {
Z3_INVALID_PATTERN = 6,
Z3_MEMOUT_FAIL = 7,
Z3_NO_PARSER = 5,
Z3_OK = 0,
Z3_INVALID_ARG = 3,
Z3_EXCEPTION = 12,
Z3_IOB = 2,
Z3_INTERNAL_FATAL = 9,
Z3_INVALID_USAGE = 10,
Z3_FILE_ACCESS_ERROR = 8,
Z3_SORT_ERROR = 1,
Z3_PARSER_ERROR = 4,
Z3_DEC_REF_ERROR = 11,
}
/// <summary>Z3_goal_prec</summary>
public enum Z3_goal_prec {
Z3_GOAL_UNDER = 1,
Z3_GOAL_PRECISE = 0,
Z3_GOAL_UNDER_OVER = 3,
Z3_GOAL_OVER = 2,
}
}

10504
Microsoft.Z3/Native.cs
View file

File diff suppressed because it is too large Load diff

86
Microsoft.Z3/mk_z3consts.py
View file

@ -1,86 +0,0 @@
############################################
# Copyright (c) 2012 Microsoft Corporation
#
# Extract enumeration types from z3_api.h
#
# Author: Leonardo de Moura (leonardo)
# Christoph M. Wintersteiger (cwinter)
############################################
import re
import os
blank_pat = re.compile("^ *$")
comment_pat = re.compile("^ *//.*$")
typedef_pat = re.compile("typedef enum *")
typedef2_pat = re.compile("typedef enum { *")
openbrace_pat = re.compile("{ *")
closebrace_pat = re.compile("}.*;")
api = open('..%slib%sz3_api.h' % (os.sep, os.sep), 'r')
DeprecatedEnums = { 'Z3_search_failure' }
z3consts = open('Enumerations.cs', 'w')
z3consts.write('// Automatically generated file, generator: mk_z3consts.py\n\n')
z3consts.write('using System;\n\n'
'#pragma warning disable 1591\n\n'
'namespace Microsoft.Z3\n'
'{\n');
SEARCHING = 0
FOUND_ENUM = 1
IN_ENUM = 2
mode = SEARCHING
decls = {}
idx = 0
linenum = 1
for line in api:
m1 = blank_pat.match(line)
m2 = comment_pat.match(line)
if m1 or m2:
# skip blank lines and comments
linenum = linenum + 1
elif mode == SEARCHING:
m = typedef_pat.match(line)
if m:
mode = FOUND_ENUM
m = typedef2_pat.match(line)
if m:
mode = IN_ENUM
decls = {}
idx = 0
elif mode == FOUND_ENUM:
m = openbrace_pat.match(line)
if m:
mode = IN_ENUM
decls = {}
idx = 0
else:
assert False, "Invalid z3_api.h, line: %s" % linenum
else:
assert mode == IN_ENUM
words = re.split('[^\-a-zA-Z0-9_]+', line)
m = closebrace_pat.match(line)
if m:
name = words[1]
if name not in DeprecatedEnums:
z3consts.write(' /// <summary>%s</summary>\n' % name)
z3consts.write(' public enum %s {\n' % name)
z3consts.write
for k, i in decls.iteritems():
z3consts.write(' %s = %s,\n' % (k, i))
z3consts.write(' }\n\n')
mode = SEARCHING
else:
if words[2] != '':
if len(words[2]) > 1 and words[2][1] == 'x':
idx = int(words[2], 16)
else:
idx = int(words[2])
decls[words[1]] = idx
idx = idx + 1
linenum = linenum + 1
z3consts.write('}\n');

15
dll/dll.vcxproj
View file

@ -1,4 +1,4 @@
<?xml version="1.0" encoding="utf-8"?>
<?xml version="1.0" encoding="utf-8"?>
<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<ItemGroup Label="ProjectConfigurations">
<ProjectConfiguration Include="commercial|Win32">
@ -264,8 +264,8 @@
<CodeAnalysisRuleSet Condition="'$(Configuration)|$(Platform)'=='trace|x64'">AllRules.ruleset</CodeAnalysisRuleSet>
<CodeAnalysisRules Condition="'$(Configuration)|$(Platform)'=='trace|x64'" />
<CodeAnalysisRuleAssemblies Condition="'$(Configuration)|$(Platform)'=='trace|x64'" />
<TargetName Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">z3_dbg</TargetName>
<TargetName Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">z3_dbg</TargetName>
<TargetName Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">z3</TargetName>
<TargetName Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">z3</TargetName>
<TargetName Condition="'$(Configuration)|$(Platform)'=='external_64|x64'">z3</TargetName>
<TargetName Condition="'$(Configuration)|$(Platform)'=='external_64|Win32'">z3</TargetName>
<TargetName Condition="'$(Configuration)|$(Platform)'=='external|Win32'">z3</TargetName>
@ -292,8 +292,8 @@
<DebugInformationFormat>EditAndContinue</DebugInformationFormat>
</ClCompile>
<Link>
<OutputFile>$(OutDir)z3_dbg.dll</OutputFile>
<ModuleDefinitionFile>z3_dbg.def</ModuleDefinitionFile>
<OutputFile>$(OutDir)z3.dll</OutputFile>
<ModuleDefinitionFile>z3.def</ModuleDefinitionFile>
<GenerateDebugInformation>true</GenerateDebugInformation>
<ProgramDatabaseFile>$(TargetDir)z3_dll.pdb</ProgramDatabaseFile>
<SubSystem>Windows</SubSystem>
@ -319,8 +319,8 @@
<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
</ClCompile>
<Link>
<OutputFile>$(OutDir)z3_dbg.dll</OutputFile>
<ModuleDefinitionFile>z3_dbg.def</ModuleDefinitionFile>
<OutputFile>$(OutDir)z3.dll</OutputFile>
<ModuleDefinitionFile>z3.def</ModuleDefinitionFile>
<GenerateDebugInformation>true</GenerateDebugInformation>
<ProgramDatabaseFile>$(TargetDir)z3_dll.pdb</ProgramDatabaseFile>
<SubSystem>Windows</SubSystem>
@ -610,7 +610,6 @@
</ItemGroup>
<ItemGroup>
<None Include="z3.def" />
<None Include="z3_dbg.def" />
</ItemGroup>
<ItemGroup>
<ClInclude Include="resource.h" />

25
dll/mk_def.py
View file

@ -1,25 +0,0 @@
import re
import os
pat1 = re.compile(".*Z3_API.*")
api = open('..%slib%sz3_api.h' % (os.sep, os.sep), 'r')
z3def = open('z3.def', 'w')
z3dbgdef = open('z3_dbg.def', 'w')
z3def.write('LIBRARY "Z3"\nEXPORTS\n')
z3dbgdef.write('LIBRARY "Z3_DBG"\nEXPORTS\n')
num = 1
for line in api:
m = pat1.match(line)
if m:
words = re.split('\W+', line)
i = 0
for w in words:
if w == 'Z3_API':
f = words[i+1]
z3def.write('\t%s @%s\n' % (f, num))
z3dbgdef.write('\t%s @%s\n' % (f, num))
i = i + 1
num = num + 1

1050
dll/z3.def
View file

File diff suppressed because it is too large Load diff

522
dll/z3_dbg.def
View file

@ -1,522 +0,0 @@
LIBRARY "Z3_DBG"
EXPORTS
Z3_mk_config @1
Z3_del_config @2
Z3_set_param_value @3
Z3_mk_context @4
Z3_mk_context_rc @5
Z3_del_context @6
Z3_inc_ref @7
Z3_dec_ref @8
Z3_update_param_value @9
Z3_get_param_value @10
Z3_interrupt @11
Z3_mk_params @12
Z3_params_inc_ref @13
Z3_params_dec_ref @14
Z3_params_set_bool @15
Z3_params_set_uint @16
Z3_params_set_double @17
Z3_params_set_symbol @18
Z3_params_to_string @19
Z3_params_validate @20
Z3_param_descrs_inc_ref @21
Z3_param_descrs_dec_ref @22
Z3_param_descrs_get_kind @23
Z3_param_descrs_size @24
Z3_param_descrs_get_name @25
Z3_param_descrs_to_string @26
Z3_mk_int_symbol @27
Z3_mk_string_symbol @28
Z3_mk_uninterpreted_sort @29
Z3_mk_bool_sort @30
Z3_mk_int_sort @31
Z3_mk_real_sort @32
Z3_mk_bv_sort @33
Z3_mk_finite_domain_sort @34
Z3_mk_array_sort @35
Z3_mk_tuple_sort @36
Z3_mk_enumeration_sort @37
Z3_mk_list_sort @38
Z3_mk_constructor @39
Z3_del_constructor @40
Z3_mk_datatype @41
Z3_mk_constructor_list @42
Z3_del_constructor_list @43
Z3_mk_datatypes @44
Z3_query_constructor @45
Z3_mk_func_decl @46
Z3_mk_app @47
Z3_mk_const @48
Z3_mk_fresh_func_decl @49
Z3_mk_fresh_const @50
Z3_mk_true @51
Z3_mk_false @52
Z3_mk_eq @53
Z3_mk_distinct @54
Z3_mk_not @55
Z3_mk_ite @56
Z3_mk_iff @57
Z3_mk_implies @58
Z3_mk_xor @59
Z3_mk_and @60
Z3_mk_or @61
Z3_mk_add @62
Z3_mk_mul @63
Z3_mk_sub @64
Z3_mk_unary_minus @65
Z3_mk_div @66
Z3_mk_mod @67
Z3_mk_rem @68
Z3_mk_power @69
Z3_mk_lt @70
Z3_mk_le @71
Z3_mk_gt @72
Z3_mk_ge @73
Z3_mk_int2real @74
Z3_mk_real2int @75
Z3_mk_is_int @76
Z3_mk_bvnot @77
Z3_mk_bvredand @78
Z3_mk_bvredor @79
Z3_mk_bvand @80
Z3_mk_bvor @81
Z3_mk_bvxor @82
Z3_mk_bvnand @83
Z3_mk_bvnor @84
Z3_mk_bvxnor @85
Z3_mk_bvneg @86
Z3_mk_bvadd @87
Z3_mk_bvsub @88
Z3_mk_bvmul @89
Z3_mk_bvudiv @90
Z3_mk_bvsdiv @91
Z3_mk_bvurem @92
Z3_mk_bvsrem @93
Z3_mk_bvsmod @94
Z3_mk_bvult @95
Z3_mk_bvslt @96
Z3_mk_bvule @97
Z3_mk_bvsle @98
Z3_mk_bvuge @99
Z3_mk_bvsge @100
Z3_mk_bvugt @101
Z3_mk_bvsgt @102
Z3_mk_concat @103
Z3_mk_extract @104
Z3_mk_sign_ext @105
Z3_mk_zero_ext @106
Z3_mk_repeat @107
Z3_mk_bvshl @108
Z3_mk_bvlshr @109
Z3_mk_bvashr @110
Z3_mk_rotate_left @111
Z3_mk_rotate_right @112
Z3_mk_ext_rotate_left @113
Z3_mk_ext_rotate_right @114
Z3_mk_int2bv @115
Z3_mk_bv2int @116
Z3_mk_bvadd_no_overflow @117
Z3_mk_bvadd_no_underflow @118
Z3_mk_bvsub_no_overflow @119
Z3_mk_bvsub_no_underflow @120
Z3_mk_bvsdiv_no_overflow @121
Z3_mk_bvneg_no_overflow @122
Z3_mk_bvmul_no_overflow @123
Z3_mk_bvmul_no_underflow @124
Z3_mk_select @125
Z3_mk_store @126
Z3_mk_const_array @127
Z3_mk_map @128
Z3_mk_array_default @129
Z3_mk_set_sort @130
Z3_mk_empty_set @131
Z3_mk_full_set @132
Z3_mk_set_add @133
Z3_mk_set_del @134
Z3_mk_set_union @135
Z3_mk_set_intersect @136
Z3_mk_set_difference @137
Z3_mk_set_complement @138
Z3_mk_set_member @139
Z3_mk_set_subset @140
Z3_mk_numeral @141
Z3_mk_real @142
Z3_mk_int @143
Z3_mk_unsigned_int @144
Z3_mk_int64 @145
Z3_mk_unsigned_int64 @146
Z3_mk_pattern @147
Z3_mk_bound @148
Z3_mk_forall @149
Z3_mk_exists @150
Z3_mk_quantifier @151
Z3_mk_quantifier_ex @152
Z3_mk_forall_const @153
Z3_mk_exists_const @154
Z3_mk_quantifier_const @155
Z3_mk_quantifier_const_ex @156
Z3_get_symbol_kind @157
Z3_get_symbol_int @158
Z3_get_symbol_string @159
Z3_get_sort_name @160
Z3_get_sort_id @161
Z3_sort_to_ast @162
Z3_is_eq_sort @163
Z3_get_sort_kind @164
Z3_get_bv_sort_size @165
Z3_get_finite_domain_sort_size @166
Z3_get_array_sort_domain @167
Z3_get_array_sort_range @168
Z3_get_tuple_sort_mk_decl @169
Z3_get_tuple_sort_num_fields @170
Z3_get_tuple_sort_field_decl @171
Z3_get_datatype_sort_num_constructors @172
Z3_get_datatype_sort_constructor @173
Z3_get_datatype_sort_recognizer @174
Z3_get_datatype_sort_constructor_accessor @175
Z3_get_relation_arity @176
Z3_get_relation_column @177
Z3_func_decl_to_ast @178
Z3_is_eq_func_decl @179
Z3_get_func_decl_id @180
Z3_get_decl_name @181
Z3_get_decl_kind @182
Z3_get_domain_size @183
Z3_get_arity @184
Z3_get_domain @185
Z3_get_range @186
Z3_get_decl_num_parameters @187
Z3_get_decl_parameter_kind @188
Z3_get_decl_int_parameter @189
Z3_get_decl_double_parameter @190
Z3_get_decl_symbol_parameter @191
Z3_get_decl_sort_parameter @192
Z3_get_decl_ast_parameter @193
Z3_get_decl_func_decl_parameter @194
Z3_get_decl_rational_parameter @195
Z3_app_to_ast @196
Z3_get_app_decl @197
Z3_get_app_num_args @198
Z3_get_app_arg @199
Z3_is_eq_ast @200
Z3_get_ast_id @201
Z3_get_ast_hash @202
Z3_get_sort @203
Z3_is_well_sorted @204
Z3_get_bool_value @205
Z3_get_ast_kind @206
Z3_is_app @207
Z3_is_numeral_ast @208
Z3_is_algebraic_number @209
Z3_to_app @210
Z3_to_func_decl @211
Z3_get_numeral_string @212
Z3_get_numeral_decimal_string @213
Z3_get_numerator @214
Z3_get_denominator @215
Z3_get_numeral_small @216
Z3_get_numeral_int @217
Z3_get_numeral_uint @218
Z3_get_numeral_uint64 @219
Z3_get_numeral_int64 @220
Z3_get_numeral_rational_int64 @221
Z3_get_algebraic_number_lower @222
Z3_get_algebraic_number_upper @223
Z3_pattern_to_ast @224
Z3_get_pattern_num_terms @225
Z3_get_pattern @226
Z3_get_index_value @227
Z3_is_quantifier_forall @228
Z3_get_quantifier_weight @229
Z3_get_quantifier_num_patterns @230
Z3_get_quantifier_pattern_ast @231
Z3_get_quantifier_num_no_patterns @232
Z3_get_quantifier_no_pattern_ast @233
Z3_get_quantifier_num_bound @234
Z3_get_quantifier_bound_name @235
Z3_get_quantifier_bound_sort @236
Z3_get_quantifier_body @237
Z3_simplify @238
Z3_simplify_ex @239
Z3_simplify_get_help @240
Z3_simplify_get_param_descrs @241
Z3_update_term @242
Z3_substitute @243
Z3_substitute_vars @244
Z3_translate @245
Z3_model_inc_ref @246
Z3_model_dec_ref @247
Z3_model_eval @248
Z3_model_get_const_interp @249
Z3_model_get_func_interp @250
Z3_model_get_num_consts @251
Z3_model_get_const_decl @252
Z3_model_get_num_funcs @253
Z3_model_get_func_decl @254
Z3_model_get_num_sorts @255
Z3_model_get_sort @256
Z3_model_get_sort_universe @257
Z3_is_as_array @258
Z3_get_as_array_func_decl @259
Z3_func_interp_inc_ref @260
Z3_func_interp_dec_ref @261
Z3_func_interp_get_num_entries @262
Z3_func_interp_get_entry @263
Z3_func_interp_get_else @264
Z3_func_interp_get_arity @265
Z3_func_entry_inc_ref @266
Z3_func_entry_dec_ref @267
Z3_func_entry_get_value @268
Z3_func_entry_get_num_args @269
Z3_func_entry_get_arg @270
Z3_open_log @271
Z3_append_log @272
Z3_close_log @273
Z3_toggle_warning_messages @274
Z3_set_ast_print_mode @275
Z3_ast_to_string @276
Z3_pattern_to_string @277
Z3_sort_to_string @278
Z3_func_decl_to_string @279
Z3_model_to_string @280
Z3_benchmark_to_smtlib_string @281
Z3_parse_smtlib2_string @282
Z3_parse_smtlib2_file @283
Z3_parse_smtlib_string @284
Z3_parse_smtlib_file @285
Z3_get_smtlib_num_formulas @286
Z3_get_smtlib_formula @287
Z3_get_smtlib_num_assumptions @288
Z3_get_smtlib_assumption @289
Z3_get_smtlib_num_decls @290
Z3_get_smtlib_decl @291
Z3_get_smtlib_num_sorts @292
Z3_get_smtlib_sort @293
Z3_get_smtlib_error @294
Z3_parse_z3_string @295
Z3_parse_z3_file @296
Z3_get_error_code @297
Z3_set_error_handler @298
Z3_set_error @299
Z3_get_error_msg @300
Z3_get_error_msg_ex @301
Z3_get_version @302
Z3_reset_memory @303
Z3_mk_theory @304
Z3_theory_get_ext_data @305
Z3_theory_mk_sort @306
Z3_theory_mk_value @307
Z3_theory_mk_constant @308
Z3_theory_mk_func_decl @309
Z3_theory_get_context @310
Z3_set_delete_callback @311
Z3_set_reduce_app_callback @312
Z3_set_reduce_eq_callback @313
Z3_set_reduce_distinct_callback @314
Z3_set_new_app_callback @315
Z3_set_new_elem_callback @316
Z3_set_init_search_callback @317
Z3_set_push_callback @318
Z3_set_pop_callback @319
Z3_set_restart_callback @320
Z3_set_reset_callback @321
Z3_set_final_check_callback @322
Z3_set_new_eq_callback @323
Z3_set_new_diseq_callback @324
Z3_set_new_assignment_callback @325
Z3_set_new_relevant_callback @326
Z3_theory_assert_axiom @327
Z3_theory_assume_eq @328
Z3_theory_enable_axiom_simplification @329
Z3_theory_get_eqc_root @330
Z3_theory_get_eqc_next @331
Z3_theory_get_num_parents @332
Z3_theory_get_parent @333
Z3_theory_is_value @334
Z3_theory_is_decl @335
Z3_theory_get_num_elems @336
Z3_theory_get_elem @337
Z3_theory_get_num_apps @338
Z3_theory_get_app @339
Z3_mk_fixedpoint @340
Z3_fixedpoint_inc_ref @341
Z3_fixedpoint_dec_ref @342
Z3_fixedpoint_add_rule @343
Z3_fixedpoint_add_fact @344
Z3_fixedpoint_assert @345
Z3_fixedpoint_query @346
Z3_fixedpoint_query_relations @347
Z3_fixedpoint_get_answer @348
Z3_fixedpoint_get_reason_unknown @349
Z3_fixedpoint_update_rule @350
Z3_fixedpoint_get_num_levels @351
Z3_fixedpoint_get_cover_delta @352
Z3_fixedpoint_add_cover @353
Z3_fixedpoint_get_statistics @354
Z3_fixedpoint_register_relation @355
Z3_fixedpoint_set_predicate_representation @356
Z3_fixedpoint_simplify_rules @357
Z3_fixedpoint_set_params @358
Z3_fixedpoint_get_help @359
Z3_fixedpoint_get_param_descrs @360
Z3_fixedpoint_to_string @361
Z3_fixedpoint_push @362
Z3_fixedpoint_pop @363
Z3_fixedpoint_init @364
Z3_fixedpoint_set_reduce_assign_callback @365
Z3_fixedpoint_set_reduce_app_callback @366
Z3_mk_ast_vector @367
Z3_ast_vector_inc_ref @368
Z3_ast_vector_dec_ref @369
Z3_ast_vector_size @370
Z3_ast_vector_get @371
Z3_ast_vector_set @372
Z3_ast_vector_resize @373
Z3_ast_vector_push @374
Z3_ast_vector_translate @375
Z3_ast_vector_to_string @376
Z3_mk_ast_map @377
Z3_ast_map_inc_ref @378
Z3_ast_map_dec_ref @379
Z3_ast_map_contains @380
Z3_ast_map_find @381
Z3_ast_map_insert @382
Z3_ast_map_erase @383
Z3_ast_map_reset @384
Z3_ast_map_size @385
Z3_ast_map_keys @386
Z3_ast_map_to_string @387
Z3_mk_goal @388
Z3_goal_inc_ref @389
Z3_goal_dec_ref @390
Z3_goal_precision @391
Z3_goal_assert @392
Z3_goal_inconsistent @393
Z3_goal_depth @394
Z3_goal_reset @395
Z3_goal_size @396
Z3_goal_formula @397
Z3_goal_num_exprs @398
Z3_goal_is_decided_sat @399
Z3_goal_is_decided_unsat @400
Z3_goal_translate @401
Z3_goal_to_string @402
Z3_mk_tactic @403
Z3_tactic_inc_ref @404
Z3_tactic_dec_ref @405
Z3_mk_probe @406
Z3_probe_inc_ref @407
Z3_probe_dec_ref @408
Z3_tactic_and_then @409
Z3_tactic_or_else @410
Z3_tactic_par_or @411
Z3_tactic_par_and_then @412
Z3_tactic_try_for @413
Z3_tactic_when @414
Z3_tactic_cond @415
Z3_tactic_repeat @416
Z3_tactic_skip @417
Z3_tactic_fail @418
Z3_tactic_fail_if @419
Z3_tactic_fail_if_not_decided @420
Z3_tactic_using_params @421
Z3_probe_const @422
Z3_probe_lt @423
Z3_probe_gt @424
Z3_probe_le @425
Z3_probe_ge @426
Z3_probe_eq @427
Z3_probe_and @428
Z3_probe_or @429
Z3_probe_not @430
Z3_get_num_tactics @431
Z3_get_tactic_name @432
Z3_get_num_probes @433
Z3_get_probe_name @434
Z3_tactic_get_help @435
Z3_tactic_get_param_descrs @436
Z3_tactic_get_descr @437
Z3_probe_get_descr @438
Z3_probe_apply @439
Z3_tactic_apply @440
Z3_tactic_apply_ex @441
Z3_apply_result_inc_ref @442
Z3_apply_result_dec_ref @443
Z3_apply_result_to_string @444
Z3_apply_result_get_num_subgoals @445
Z3_apply_result_get_subgoal @446
Z3_apply_result_convert_model @447
Z3_mk_solver @448
Z3_mk_simple_solver @449
Z3_mk_solver_for_logic @450
Z3_mk_solver_from_tactic @451
Z3_solver_get_help @452
Z3_solver_get_param_descrs @453
Z3_solver_set_params @454
Z3_solver_inc_ref @455
Z3_solver_dec_ref @456
Z3_solver_push @457
Z3_solver_pop @458
Z3_solver_reset @459
Z3_solver_get_num_scopes @460
Z3_solver_assert @461
Z3_solver_get_assertions @462
Z3_solver_check @463
Z3_solver_check_assumptions @464
Z3_solver_get_model @465
Z3_solver_get_proof @466
Z3_solver_get_unsat_core @467
Z3_solver_get_reason_unknown @468
Z3_solver_get_statistics @469
Z3_solver_to_string @470
Z3_stats_to_string @471
Z3_stats_inc_ref @472
Z3_stats_dec_ref @473
Z3_stats_size @474
Z3_stats_get_key @475
Z3_stats_is_uint @476
Z3_stats_is_double @477
Z3_stats_get_uint_value @478
Z3_stats_get_double_value @479
Z3_mk_injective_function @480
Z3_set_logic @481
Z3_push @482
Z3_pop @483
Z3_get_num_scopes @484
Z3_persist_ast @485
Z3_assert_cnstr @486
Z3_check_and_get_model @487
Z3_check @488
Z3_check_assumptions @489
Z3_get_implied_equalities @490
Z3_del_model @491
Z3_soft_check_cancel @492
Z3_get_search_failure @493
Z3_mk_label @494
Z3_get_relevant_labels @495
Z3_get_relevant_literals @496
Z3_get_guessed_literals @497
Z3_del_literals @498
Z3_get_num_literals @499
Z3_get_label_symbol @500
Z3_get_literal @501
Z3_disable_literal @502
Z3_block_literals @503
Z3_get_model_num_constants @504
Z3_get_model_constant @505
Z3_get_model_num_funcs @506
Z3_get_model_func_decl @507
Z3_eval_func_decl @508
Z3_is_array_value @509
Z3_get_array_value @510
Z3_get_model_func_else @511
Z3_get_model_func_num_entries @512
Z3_get_model_func_entry_num_args @513
Z3_get_model_func_entry_arg @514
Z3_get_model_func_entry_value @515
Z3_eval @516
Z3_eval_decl @517
Z3_context_to_string @518
Z3_statistics_to_string @519
Z3_get_context_assignment @520

1236
lib/api.py
View file

File diff suppressed because it is too large Load diff

2
lib/api_ast.cpp
View file

@ -16,7 +16,7 @@ Revision History:
--*/
#include<iostream>
#include"z3.h"
#include"z3_internal.h"
#include"api_log_macros.h"
#include"api_context.h"
#include"api_util.h"

7009
lib/api_commands.cpp
View file

File diff suppressed because it is too large Load diff

6672
lib/api_log_macros.cpp
View file

File diff suppressed because it is too large Load diff

1966
lib/api_log_macros.h
View file

File diff suppressed because it is too large Load diff

78
lib/api_poly.cpp Normal file
View file

@ -0,0 +1,78 @@
/*++
Copyright (c) 2012 Microsoft Corporation
Module Name:
api_poly.cpp
Abstract:
External API for polynomial package
Author:
Leonardo de Moura (leonardo) 2012-10-18.
Revision History:
--*/
#include"z3.h"
#include"z3_internal.h"
#include"api_context.h"
#include"api_poly.h"
#include"api_util.h"
#include"api_log_macros.h"
Z3_polynomial_manager Z3_mk_polynomial_manager(Z3_context c) {
Z3_TRY;
LOG_Z3_mk_polynomial_manager(c);
RESET_ERROR_CODE();
_Z3_polynomial_manager * m = alloc(_Z3_polynomial_manager);
RETURN_Z3(of_poly_manager(m));
Z3_CATCH_RETURN(0);
}
void Z3_del_polynomial_manager(Z3_context c, Z3_polynomial_manager m) {
Z3_TRY;
LOG_Z3_del_polynomial_manager(c, m);
RESET_ERROR_CODE();
dealloc(to_poly_manager(m));
Z3_CATCH;
}
Z3_polynomial Z3_mk_zero_polynomial(Z3_context c, Z3_polynomial_manager m) {
Z3_TRY;
LOG_Z3_mk_zero_polynomial(c, m);
RESET_ERROR_CODE();
polynomial::polynomial * r = to_poly_manager(m)->m_manager.mk_zero();
to_poly_manager(m)->m_result = r;
RETURN_Z3(of_poly(r));
Z3_CATCH_RETURN(0);
}
void Z3_polynomial_inc_ref(Z3_context c, Z3_polynomial_manager m, Z3_polynomial p) {
Z3_TRY;
LOG_Z3_polynomial_inc_ref(c, m, p);
RESET_ERROR_CODE();
to_poly_manager(m)->m_manager.inc_ref(to_poly(p));
Z3_CATCH;
}
void Z3_polynomial_dec_ref(Z3_context c, Z3_polynomial_manager m, Z3_polynomial p) {
Z3_TRY;
LOG_Z3_polynomial_inc_ref(c, m, p);
RESET_ERROR_CODE();
to_poly_manager(m)->m_manager.dec_ref(to_poly(p));
Z3_CATCH;
}
Z3_string Z3_polynomial_to_string(Z3_context c, Z3_polynomial_manager m, Z3_polynomial p) {
Z3_TRY;
LOG_Z3_polynomial_to_string(c, m, p);
RESET_ERROR_CODE();
std::ostringstream buffer;
to_poly_manager(m)->m_manager.display(buffer, to_poly(p));
return mk_c(c)->mk_external_string(buffer.str());
Z3_CATCH_RETURN("");
}

40
lib/api_poly.h Normal file
View file

@ -0,0 +1,40 @@
/*++
Copyright (c) 2012 Microsoft Corporation
Module Name:
api_poly.h
Abstract:
External API for polynomial package
Author:
Leonardo de Moura (leonardo) 2012-10-18.
Revision History:
--*/
#ifndef _API_POLY_H_
#define _API_POLY_H_
#include"polynomial.h"
struct _Z3_polynomial_manager {
unsynch_mpz_manager m_num_manager;
polynomial::manager m_manager;
polynomial_ref m_result;
_Z3_polynomial_manager():
m_manager(m_num_manager),
m_result(m_manager) {
}
};
inline _Z3_polynomial_manager * to_poly_manager(Z3_polynomial_manager m) { return reinterpret_cast<_Z3_polynomial_manager*>(m); }
inline Z3_polynomial_manager of_poly_manager(_Z3_polynomial_manager * m) { return reinterpret_cast<Z3_polynomial_manager>(m); }
inline polynomial::polynomial * to_poly(Z3_polynomial p) { return reinterpret_cast<polynomial::polynomial*>(p); }
inline Z3_polynomial of_poly(polynomial::polynomial * p) { return reinterpret_cast<Z3_polynomial>(p); }
#endif

1
lib/api_util.h
View file

@ -20,6 +20,7 @@ Revision History:
#include"params.h"
#include"lbool.h"
#include"ast.h"
#define Z3_TRY try {
#define Z3_CATCH_CORE(CODE) } catch (z3_exception & ex) { mk_c(c)->handle_exception(ex); CODE }

3
lib/lib.vcxproj
View file

@ -1,4 +1,4 @@
<?xml version="1.0" encoding="utf-8"?>
<?xml version="1.0" encoding="utf-8"?>
<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<ItemGroup Label="ProjectConfigurations">
<ProjectConfiguration Include="commercial|Win32">
@ -443,6 +443,7 @@
<ClCompile Include="api_numeral.cpp" />
<ClCompile Include="api_params.cpp" />
<ClCompile Include="api_parsers.cpp" />
<ClCompile Include="api_poly.cpp" />
<ClCompile Include="api_quant.cpp" />
<ClCompile Include="api_solver_old.cpp" />
<ClCompile Include="api_solver.cpp" />

1
lib/pdr_context.cpp
View file

@ -1737,7 +1737,6 @@ namespace pdr {
datalog::flatten_and(forms);
ptr_vector<expr> forms1(forms.size(), forms.c_ptr());
expr_ref_vector Phi = mev.minimize_literals(forms1, M);
ptr_vector<func_decl> preds;
pt.find_predecessors(r, preds);
pt.remove_predecessors(Phi);

7
lib/pdr_util.h
View file

@ -239,6 +239,13 @@ public:
*/
expr_ref_vector minimize_literals(ptr_vector<expr> const & formulas, model_ref& mdl);
/**
\brief extract literals from formulas that satisfy formulas.
\pre model satisfies formulas
*/
expr_ref_vector minimize_literals(ptr_vector<expr> const & formulas, expr_ref_vector const & model);
// for_each_expr visitor.
void operator()(expr* e) {}
};

1
lib/z3.h
View file

@ -24,6 +24,7 @@ Notes:
#include<stdio.h>
#include"z3_macros.h"
#include"z3_api.h"
#include"z3_internal_types.h"
#undef __in
#undef __out

1020
lib/z3_api.h
View file

File diff suppressed because it is too large Load diff

40
lib/z3_internal.h Normal file
View file

@ -0,0 +1,40 @@
/*++
Copyright (c) 2012 Microsoft Corporation
Module Name:
z3_internal.h
Abstract:
Z3 internal API for C and Python.
It provides access to internal Z3 components.
It should only be used by advanced users.
We used it to build regression tests in Python.
Author:
Leonardo de Moura (leonardo) 2012-10-18
Notes:
--*/
#ifndef _Z3_INTERNAL_H_
#define _Z3_INTERNAL_H_
#include"z3_macros.h"
#include"z3_api.h"
#include"z3_internal_types.h"
#include"z3_poly.h"
#undef __in
#undef __out
#undef __inout
#undef __in_z
#undef __out_z
#undef __ecount
#undef __in_ecount
#undef __out_ecount
#undef __inout_ecount
#endif

34
lib/z3_internal_types.h Normal file
View file

@ -0,0 +1,34 @@
/*++
Copyright (c) 2012 Microsoft Corporation
Module Name:
z3_internal_types.h
Abstract:
Z3 internal API type declarations.
Author:
Leonardo de Moura (leonardo) 2012-10-18
Notes:
--*/
#ifndef _Z3_INTERNAL_TYPES_H_
#define _Z3_INTERNAL_TYPES_H_
DEFINE_TYPE(Z3_polynomial_manager);
DEFINE_TYPE(Z3_polynomial);
DEFINE_TYPE(Z3_monomial);
/*
Definitions for update_api.py
def_Type('POLYNOMIAL_MANAGER', 'Z3_polynomial_manager', 'PolynomialManagerObj')
def_Type('POLYNOMIAL', 'Z3_polynomial', 'PolynomialObj')
def_Type('MONOMIAL', 'Z3_monomial', 'MonomialObj')
*/
#endif

72
lib/z3_poly.h Normal file
View file

@ -0,0 +1,72 @@
/*++
Copyright (c) 2012 Microsoft Corporation
Module Name:
z3_poly.h
Abstract:
Z3 multivariate polynomial API.
Author:
Leonardo de Moura (leonardo) 2012-10-18
Notes:
--*/
#ifndef _Z3_POLY_H_
#define _Z3_POLY_H_
#ifdef __cplusplus
extern "C" {
#endif // __cplusplus
/**
\brief Create a new polynomial manager.
def_API('Z3_mk_polynomial_manager', POLYNOMIAL_MANAGER, (_in(CONTEXT),))
*/
Z3_polynomial_manager Z3_API Z3_mk_polynomial_manager(__in Z3_context c);
/**
\brief Delete the given polynomial manager.
def_API('Z3_del_polynomial_manager', VOID, (_in(CONTEXT), _in(POLYNOMIAL_MANAGER)))
*/
void Z3_API Z3_del_polynomial_manager(__in Z3_context c, __in Z3_polynomial_manager m);
/**
\brief Return the zero polynomial.
def_API('Z3_mk_zero_polynomial', POLYNOMIAL, (_in(CONTEXT), _in(POLYNOMIAL_MANAGER)))
*/
Z3_polynomial Z3_API Z3_mk_zero_polynomial(__in Z3_context c, __in Z3_polynomial_manager m);
/**
\brief Increment p's reference counter
def_API('Z3_polynomial_inc_ref', VOID, (_in(CONTEXT), _in(POLYNOMIAL_MANAGER), _in(POLYNOMIAL)))
*/
void Z3_API Z3_polynomial_inc_ref(__in Z3_context c, __in Z3_polynomial_manager m, __in Z3_polynomial p);
/**
\brief Decrement p's reference counter.
def_API('Z3_polynomial_dec_ref', VOID, (_in(CONTEXT), _in(POLYNOMIAL_MANAGER), _in(POLYNOMIAL)))
*/
void Z3_API Z3_polynomial_dec_ref(__in Z3_context c, __in Z3_polynomial_manager m, __in Z3_polynomial p);
/**
\brief Convert the given polynomial into a string.
def_API('Z3_polynomial_to_string', STRING, (_in(CONTEXT), _in(POLYNOMIAL_MANAGER), _in(POLYNOMIAL)))
*/
Z3_string Z3_API Z3_polynomial_to_string(__in Z3_context c, __in Z3_polynomial_manager m, __in Z3_polynomial p);
#ifdef __cplusplus
};
#endif // __cplusplus
#endif

74
python/mk_z3consts.py
View file

@ -1,74 +0,0 @@
############################################
# Copyright (c) 2012 Microsoft Corporation
#
# Extract enumeration types from z3_api.h
#
# Author: Leonardo de Moura (leonardo)
############################################
import re
import os
blank_pat = re.compile("^ *$")
comment_pat = re.compile("^ *//.*$")
typedef_pat = re.compile("typedef enum *")
typedef2_pat = re.compile("typedef enum { *")
openbrace_pat = re.compile("{ *")
closebrace_pat = re.compile("}.*;")
api = open('..%slib%sz3_api.h' % (os.sep, os.sep), 'r')
z3consts = open('z3consts.py', 'w')
z3consts.write('# Automatically generated file, generator: mk_z3consts.py\n\n')
SEARCHING = 0
FOUND_ENUM = 1
IN_ENUM = 2
mode = SEARCHING
decls = {}
idx = 0
linenum = 1
for line in api:
m1 = blank_pat.match(line)
m2 = comment_pat.match(line)
if m1 or m2:
# skip blank lines and comments
linenum = linenum + 1
elif mode == SEARCHING:
m = typedef_pat.match(line)
if m:
mode = FOUND_ENUM
m = typedef2_pat.match(line)
if m:
mode = IN_ENUM
decls = {}
idx = 0
elif mode == FOUND_ENUM:
m = openbrace_pat.match(line)
if m:
mode = IN_ENUM
decls = {}
idx = 0
else:
assert False, "Invalid z3_api.h, line: %s" % linenum
else:
assert mode == IN_ENUM
words = re.split('[^\-a-zA-Z0-9_]+', line)
m = closebrace_pat.match(line)
if m:
name = words[1]
z3consts.write('# enum %s\n' % name)
for k, i in decls.iteritems():
z3consts.write('%s = %s\n' % (k, i))
z3consts.write('\n')
mode = SEARCHING
else:
if words[2] != '':
if len(words[2]) > 1 and words[2][1] == 'x':
idx = int(words[2], 16)
else:
idx = int(words[2])
decls[words[1]] = idx
idx = idx + 1
linenum = linenum + 1

39
python/mk_z3tactics.py
View file

@ -1,39 +0,0 @@
############################################
# Copyright (c) 2012 Microsoft Corporation
#
# Extract tactics and probes from install_tactics.cpp
#
# Author: Leonardo de Moura (leonardo)
############################################
import re
import os
tactic_pat = re.compile("^[ \t]*ADD_TACTIC_CMD")
probe_pat = re.compile("^[ \t]*ADD_PROBE")
cppfile = open('..%slib%sinstall_tactics.cpp' % (os.sep, os.sep), 'r')
z3tactics = open('z3tactics.py', 'w')
z3tactics.write('# Automatically generated file, generator: mk_z3tactics.py\n')
z3tactics.write('import z3core\n')
z3tactics.write('import z3\n\n')
for line in cppfile:
m1 = tactic_pat.match(line)
m2 = probe_pat.match(line)
if m1:
words = re.split('[^\-a-zA-Z0-9_]+', line)
tactic = words[2]
py_tactic = tactic.replace('-', '_')
z3tactics.write('def %s_tactic(ctx=None):\n' % py_tactic)
z3tactics.write(' ctx = z3._get_ctx(ctx)\n')
z3tactics.write(' return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), \'%s\'), ctx)\n\n' % tactic)
elif m2:
words = re.split('[^\-a-zA-Z0-9_]+', line)
probe = words[2]
py_probe = probe.replace('-', '_')
z3tactics.write('def %s_probe(ctx=None):\n' % py_probe)
z3tactics.write(' ctx = z3._get_ctx(ctx)\n')
z3tactics.write(' return z3.Probe(z3core.Z3_mk_probe(ctx.ref(), \'%s\'), ctx)\n\n' % probe)

482
python/z3consts.py
View file

@ -1,241 +1,241 @@
# Automatically generated file, generator: mk_z3consts.py
# enum Z3_lbool
Z3_L_TRUE = 1
Z3_L_UNDEF = 0
Z3_L_FALSE = -1
# enum Z3_symbol_kind
Z3_INT_SYMBOL = 0
Z3_STRING_SYMBOL = 1
# enum Z3_parameter_kind
Z3_PARAMETER_FUNC_DECL = 6
Z3_PARAMETER_DOUBLE = 1
Z3_PARAMETER_SYMBOL = 3
Z3_PARAMETER_INT = 0
Z3_PARAMETER_AST = 5
Z3_PARAMETER_SORT = 4
Z3_PARAMETER_RATIONAL = 2
# enum Z3_sort_kind
Z3_BV_SORT = 4
Z3_FINITE_DOMAIN_SORT = 8
Z3_ARRAY_SORT = 5
Z3_UNKNOWN_SORT = 1000
Z3_RELATION_SORT = 7
Z3_REAL_SORT = 3
Z3_INT_SORT = 2
Z3_UNINTERPRETED_SORT = 0
Z3_BOOL_SORT = 1
Z3_DATATYPE_SORT = 6
# enum Z3_ast_kind
Z3_VAR_AST = 2
Z3_SORT_AST = 4
Z3_QUANTIFIER_AST = 3
Z3_UNKNOWN_AST = 1000
Z3_FUNC_DECL_AST = 5
Z3_NUMERAL_AST = 0
Z3_APP_AST = 1
# enum Z3_decl_kind
Z3_OP_LABEL = 1792
Z3_OP_PR_REWRITE = 1294
Z3_OP_UNINTERPRETED = 2051
Z3_OP_SUB = 519
Z3_OP_ZERO_EXT = 1058
Z3_OP_ADD = 518
Z3_OP_IS_INT = 528
Z3_OP_BREDOR = 1061
Z3_OP_BNOT = 1051
Z3_OP_BNOR = 1054
Z3_OP_PR_CNF_STAR = 1315
Z3_OP_RA_JOIN = 1539
Z3_OP_LE = 514
Z3_OP_SET_UNION = 773
Z3_OP_PR_UNDEF = 1280
Z3_OP_BREDAND = 1062
Z3_OP_LT = 516
Z3_OP_RA_UNION = 1540
Z3_OP_BADD = 1028
Z3_OP_BUREM0 = 1039
Z3_OP_OEQ = 267
Z3_OP_PR_MODUS_PONENS = 1284
Z3_OP_RA_CLONE = 1548
Z3_OP_REPEAT = 1060
Z3_OP_RA_NEGATION_FILTER = 1544
Z3_OP_BSMOD0 = 1040
Z3_OP_BLSHR = 1065
Z3_OP_BASHR = 1066
Z3_OP_PR_UNIT_RESOLUTION = 1304
Z3_OP_ROTATE_RIGHT = 1068
Z3_OP_ARRAY_DEFAULT = 772
Z3_OP_PR_PULL_QUANT = 1296
Z3_OP_PR_APPLY_DEF = 1310
Z3_OP_PR_REWRITE_STAR = 1295
Z3_OP_IDIV = 523
Z3_OP_PR_GOAL = 1283
Z3_OP_PR_IFF_TRUE = 1305
Z3_OP_LABEL_LIT = 1793
Z3_OP_BOR = 1050
Z3_OP_PR_SYMMETRY = 1286
Z3_OP_TRUE = 256
Z3_OP_SET_COMPLEMENT = 776
Z3_OP_CONCAT = 1056
Z3_OP_PR_NOT_OR_ELIM = 1293
Z3_OP_IFF = 263
Z3_OP_BSHL = 1064
Z3_OP_PR_TRANSITIVITY = 1287
Z3_OP_SGT = 1048
Z3_OP_RA_WIDEN = 1541
Z3_OP_PR_DEF_INTRO = 1309
Z3_OP_NOT = 265
Z3_OP_PR_QUANT_INTRO = 1290
Z3_OP_UGT = 1047
Z3_OP_DT_RECOGNISER = 2049
Z3_OP_SET_INTERSECT = 774
Z3_OP_BSREM = 1033
Z3_OP_RA_STORE = 1536
Z3_OP_SLT = 1046
Z3_OP_ROTATE_LEFT = 1067
Z3_OP_PR_NNF_NEG = 1313
Z3_OP_PR_REFLEXIVITY = 1285
Z3_OP_ULEQ = 1041
Z3_OP_BIT1 = 1025
Z3_OP_BIT0 = 1026
Z3_OP_EQ = 258
Z3_OP_BMUL = 1030
Z3_OP_ARRAY_MAP = 771
Z3_OP_STORE = 768
Z3_OP_PR_HYPOTHESIS = 1302
Z3_OP_RA_RENAME = 1545
Z3_OP_AND = 261
Z3_OP_TO_REAL = 526
Z3_OP_PR_NNF_POS = 1312
Z3_OP_PR_AND_ELIM = 1292
Z3_OP_MOD = 525
Z3_OP_BUDIV0 = 1037
Z3_OP_PR_TRUE = 1281
Z3_OP_BNAND = 1053
Z3_OP_PR_ELIM_UNUSED_VARS = 1299
Z3_OP_RA_FILTER = 1543
Z3_OP_FD_LT = 1549
Z3_OP_RA_EMPTY = 1537
Z3_OP_DIV = 522
Z3_OP_ANUM = 512
Z3_OP_MUL = 521
Z3_OP_UGEQ = 1043
Z3_OP_BSREM0 = 1038
Z3_OP_PR_TH_LEMMA = 1318
Z3_OP_BXOR = 1052
Z3_OP_DISTINCT = 259
Z3_OP_PR_IFF_FALSE = 1306
Z3_OP_BV2INT = 1072
Z3_OP_EXT_ROTATE_LEFT = 1069
Z3_OP_PR_PULL_QUANT_STAR = 1297
Z3_OP_BSUB = 1029
Z3_OP_PR_ASSERTED = 1282
Z3_OP_BXNOR = 1055
Z3_OP_EXTRACT = 1059
Z3_OP_PR_DER = 1300
Z3_OP_DT_CONSTRUCTOR = 2048
Z3_OP_GT = 517
Z3_OP_BUREM = 1034
Z3_OP_IMPLIES = 266
Z3_OP_SLEQ = 1042
Z3_OP_GE = 515
Z3_OP_BAND = 1049
Z3_OP_ITE = 260
Z3_OP_AS_ARRAY = 778
Z3_OP_RA_SELECT = 1547
Z3_OP_CONST_ARRAY = 770
Z3_OP_BSDIV = 1031
Z3_OP_OR = 262
Z3_OP_PR_HYPER_RESOLVE = 1319
Z3_OP_AGNUM = 513
Z3_OP_PR_PUSH_QUANT = 1298
Z3_OP_BSMOD = 1035
Z3_OP_PR_IFF_OEQ = 1311
Z3_OP_PR_LEMMA = 1303
Z3_OP_SET_SUBSET = 777
Z3_OP_SELECT = 769
Z3_OP_RA_PROJECT = 1542
Z3_OP_BNEG = 1027
Z3_OP_UMINUS = 520
Z3_OP_REM = 524
Z3_OP_TO_INT = 527
Z3_OP_PR_QUANT_INST = 1301
Z3_OP_SGEQ = 1044
Z3_OP_POWER = 529
Z3_OP_XOR3 = 1074
Z3_OP_RA_IS_EMPTY = 1538
Z3_OP_CARRY = 1073
Z3_OP_DT_ACCESSOR = 2050
Z3_OP_PR_TRANSITIVITY_STAR = 1288
Z3_OP_PR_NNF_STAR = 1314
Z3_OP_PR_COMMUTATIVITY = 1307
Z3_OP_ULT = 1045
Z3_OP_BSDIV0 = 1036
Z3_OP_SET_DIFFERENCE = 775
Z3_OP_INT2BV = 1071
Z3_OP_XOR = 264
Z3_OP_PR_MODUS_PONENS_OEQ = 1317
Z3_OP_BNUM = 1024
Z3_OP_BUDIV = 1032
Z3_OP_PR_MONOTONICITY = 1289
Z3_OP_PR_DEF_AXIOM = 1308
Z3_OP_FALSE = 257
Z3_OP_EXT_ROTATE_RIGHT = 1070
Z3_OP_PR_DISTRIBUTIVITY = 1291
Z3_OP_SIGN_EXT = 1057
Z3_OP_PR_SKOLEMIZE = 1316
Z3_OP_BCOMP = 1063
Z3_OP_RA_COMPLEMENT = 1546
# enum Z3_param_kind
Z3_PK_BOOL = 1
Z3_PK_SYMBOL = 3
Z3_PK_OTHER = 5
Z3_PK_INVALID = 6
Z3_PK_UINT = 0
Z3_PK_STRING = 4
Z3_PK_DOUBLE = 2
# enum Z3_search_failure
Z3_QUANTIFIERS = 7
Z3_UNKNOWN = 1
Z3_CANCELED = 4
Z3_MEMOUT_WATERMARK = 3
Z3_THEORY = 6
Z3_NO_FAILURE = 0
Z3_TIMEOUT = 2
Z3_NUM_CONFLICTS = 5
# enum Z3_ast_print_mode
Z3_PRINT_SMTLIB2_COMPLIANT = 3
Z3_PRINT_SMTLIB_COMPLIANT = 2
Z3_PRINT_SMTLIB_FULL = 0
Z3_PRINT_LOW_LEVEL = 1
# enum Z3_error_code
Z3_INVALID_PATTERN = 6
Z3_MEMOUT_FAIL = 7
Z3_NO_PARSER = 5
Z3_OK = 0
Z3_INVALID_ARG = 3
Z3_EXCEPTION = 12
Z3_IOB = 2
Z3_INTERNAL_FATAL = 9
Z3_INVALID_USAGE = 10
Z3_FILE_ACCESS_ERROR = 8
Z3_SORT_ERROR = 1
Z3_PARSER_ERROR = 4
Z3_DEC_REF_ERROR = 11
# enum Z3_goal_prec
Z3_GOAL_UNDER = 1
Z3_GOAL_PRECISE = 0
Z3_GOAL_UNDER_OVER = 3
Z3_GOAL_OVER = 2
# Automatically generated file, generator: update_api.py
# enum Z3_lbool
Z3_L_TRUE = 1
Z3_L_UNDEF = 0
Z3_L_FALSE = -1
# enum Z3_symbol_kind
Z3_INT_SYMBOL = 0
Z3_STRING_SYMBOL = 1
# enum Z3_parameter_kind
Z3_PARAMETER_FUNC_DECL = 6
Z3_PARAMETER_DOUBLE = 1
Z3_PARAMETER_SYMBOL = 3
Z3_PARAMETER_INT = 0
Z3_PARAMETER_AST = 5
Z3_PARAMETER_SORT = 4
Z3_PARAMETER_RATIONAL = 2
# enum Z3_sort_kind
Z3_BV_SORT = 4
Z3_FINITE_DOMAIN_SORT = 8
Z3_ARRAY_SORT = 5
Z3_UNKNOWN_SORT = 1000
Z3_RELATION_SORT = 7
Z3_REAL_SORT = 3
Z3_INT_SORT = 2
Z3_UNINTERPRETED_SORT = 0
Z3_BOOL_SORT = 1
Z3_DATATYPE_SORT = 6
# enum Z3_ast_kind
Z3_VAR_AST = 2
Z3_SORT_AST = 4
Z3_QUANTIFIER_AST = 3
Z3_UNKNOWN_AST = 1000
Z3_FUNC_DECL_AST = 5
Z3_NUMERAL_AST = 0
Z3_APP_AST = 1
# enum Z3_decl_kind
Z3_OP_LABEL = 1792
Z3_OP_PR_REWRITE = 1294
Z3_OP_UNINTERPRETED = 2051
Z3_OP_SUB = 519
Z3_OP_ZERO_EXT = 1058
Z3_OP_ADD = 518
Z3_OP_IS_INT = 528
Z3_OP_BREDOR = 1061
Z3_OP_BNOT = 1051
Z3_OP_BNOR = 1054
Z3_OP_PR_CNF_STAR = 1315
Z3_OP_RA_JOIN = 1539
Z3_OP_LE = 514
Z3_OP_SET_UNION = 773
Z3_OP_PR_UNDEF = 1280
Z3_OP_BREDAND = 1062
Z3_OP_LT = 516
Z3_OP_RA_UNION = 1540
Z3_OP_BADD = 1028
Z3_OP_BUREM0 = 1039
Z3_OP_OEQ = 267
Z3_OP_PR_MODUS_PONENS = 1284
Z3_OP_RA_CLONE = 1548
Z3_OP_REPEAT = 1060
Z3_OP_RA_NEGATION_FILTER = 1544
Z3_OP_BSMOD0 = 1040
Z3_OP_BLSHR = 1065
Z3_OP_BASHR = 1066
Z3_OP_PR_UNIT_RESOLUTION = 1304
Z3_OP_ROTATE_RIGHT = 1068
Z3_OP_ARRAY_DEFAULT = 772
Z3_OP_PR_PULL_QUANT = 1296
Z3_OP_PR_APPLY_DEF = 1310
Z3_OP_PR_REWRITE_STAR = 1295
Z3_OP_IDIV = 523
Z3_OP_PR_GOAL = 1283
Z3_OP_PR_IFF_TRUE = 1305
Z3_OP_LABEL_LIT = 1793
Z3_OP_BOR = 1050
Z3_OP_PR_SYMMETRY = 1286
Z3_OP_TRUE = 256
Z3_OP_SET_COMPLEMENT = 776
Z3_OP_CONCAT = 1056
Z3_OP_PR_NOT_OR_ELIM = 1293
Z3_OP_IFF = 263
Z3_OP_BSHL = 1064
Z3_OP_PR_TRANSITIVITY = 1287
Z3_OP_SGT = 1048
Z3_OP_RA_WIDEN = 1541
Z3_OP_PR_DEF_INTRO = 1309
Z3_OP_NOT = 265
Z3_OP_PR_QUANT_INTRO = 1290
Z3_OP_UGT = 1047
Z3_OP_DT_RECOGNISER = 2049
Z3_OP_SET_INTERSECT = 774
Z3_OP_BSREM = 1033
Z3_OP_RA_STORE = 1536
Z3_OP_SLT = 1046
Z3_OP_ROTATE_LEFT = 1067
Z3_OP_PR_NNF_NEG = 1313
Z3_OP_PR_REFLEXIVITY = 1285
Z3_OP_ULEQ = 1041
Z3_OP_BIT1 = 1025
Z3_OP_BIT0 = 1026
Z3_OP_EQ = 258
Z3_OP_BMUL = 1030
Z3_OP_ARRAY_MAP = 771
Z3_OP_STORE = 768
Z3_OP_PR_HYPOTHESIS = 1302
Z3_OP_RA_RENAME = 1545
Z3_OP_AND = 261
Z3_OP_TO_REAL = 526
Z3_OP_PR_NNF_POS = 1312
Z3_OP_PR_AND_ELIM = 1292
Z3_OP_MOD = 525
Z3_OP_BUDIV0 = 1037
Z3_OP_PR_TRUE = 1281
Z3_OP_BNAND = 1053
Z3_OP_PR_ELIM_UNUSED_VARS = 1299
Z3_OP_RA_FILTER = 1543
Z3_OP_FD_LT = 1549
Z3_OP_RA_EMPTY = 1537
Z3_OP_DIV = 522
Z3_OP_ANUM = 512
Z3_OP_MUL = 521
Z3_OP_UGEQ = 1043
Z3_OP_BSREM0 = 1038
Z3_OP_PR_TH_LEMMA = 1318
Z3_OP_BXOR = 1052
Z3_OP_DISTINCT = 259
Z3_OP_PR_IFF_FALSE = 1306
Z3_OP_BV2INT = 1072
Z3_OP_EXT_ROTATE_LEFT = 1069
Z3_OP_PR_PULL_QUANT_STAR = 1297
Z3_OP_BSUB = 1029
Z3_OP_PR_ASSERTED = 1282
Z3_OP_BXNOR = 1055
Z3_OP_EXTRACT = 1059
Z3_OP_PR_DER = 1300
Z3_OP_DT_CONSTRUCTOR = 2048
Z3_OP_GT = 517
Z3_OP_BUREM = 1034
Z3_OP_IMPLIES = 266
Z3_OP_SLEQ = 1042
Z3_OP_GE = 515
Z3_OP_BAND = 1049
Z3_OP_ITE = 260
Z3_OP_AS_ARRAY = 778
Z3_OP_RA_SELECT = 1547
Z3_OP_CONST_ARRAY = 770
Z3_OP_BSDIV = 1031
Z3_OP_OR = 262
Z3_OP_PR_HYPER_RESOLVE = 1319
Z3_OP_AGNUM = 513
Z3_OP_PR_PUSH_QUANT = 1298
Z3_OP_BSMOD = 1035
Z3_OP_PR_IFF_OEQ = 1311
Z3_OP_PR_LEMMA = 1303
Z3_OP_SET_SUBSET = 777
Z3_OP_SELECT = 769
Z3_OP_RA_PROJECT = 1542
Z3_OP_BNEG = 1027
Z3_OP_UMINUS = 520
Z3_OP_REM = 524
Z3_OP_TO_INT = 527
Z3_OP_PR_QUANT_INST = 1301
Z3_OP_SGEQ = 1044
Z3_OP_POWER = 529
Z3_OP_XOR3 = 1074
Z3_OP_RA_IS_EMPTY = 1538
Z3_OP_CARRY = 1073
Z3_OP_DT_ACCESSOR = 2050
Z3_OP_PR_TRANSITIVITY_STAR = 1288
Z3_OP_PR_NNF_STAR = 1314
Z3_OP_PR_COMMUTATIVITY = 1307
Z3_OP_ULT = 1045
Z3_OP_BSDIV0 = 1036
Z3_OP_SET_DIFFERENCE = 775
Z3_OP_INT2BV = 1071
Z3_OP_XOR = 264
Z3_OP_PR_MODUS_PONENS_OEQ = 1317
Z3_OP_BNUM = 1024
Z3_OP_BUDIV = 1032
Z3_OP_PR_MONOTONICITY = 1289
Z3_OP_PR_DEF_AXIOM = 1308
Z3_OP_FALSE = 257
Z3_OP_EXT_ROTATE_RIGHT = 1070
Z3_OP_PR_DISTRIBUTIVITY = 1291
Z3_OP_SIGN_EXT = 1057
Z3_OP_PR_SKOLEMIZE = 1316
Z3_OP_BCOMP = 1063
Z3_OP_RA_COMPLEMENT = 1546
# enum Z3_param_kind
Z3_PK_BOOL = 1
Z3_PK_SYMBOL = 3
Z3_PK_OTHER = 5
Z3_PK_INVALID = 6
Z3_PK_UINT = 0
Z3_PK_STRING = 4
Z3_PK_DOUBLE = 2
# enum Z3_search_failure
Z3_QUANTIFIERS = 7
Z3_UNKNOWN = 1
Z3_CANCELED = 4
Z3_MEMOUT_WATERMARK = 3
Z3_THEORY = 6
Z3_NO_FAILURE = 0
Z3_TIMEOUT = 2
Z3_NUM_CONFLICTS = 5
# enum Z3_ast_print_mode
Z3_PRINT_SMTLIB2_COMPLIANT = 3
Z3_PRINT_SMTLIB_COMPLIANT = 2
Z3_PRINT_SMTLIB_FULL = 0
Z3_PRINT_LOW_LEVEL = 1
# enum Z3_error_code
Z3_INVALID_PATTERN = 6
Z3_MEMOUT_FAIL = 7
Z3_NO_PARSER = 5
Z3_OK = 0
Z3_INVALID_ARG = 3
Z3_EXCEPTION = 12
Z3_IOB = 2
Z3_INTERNAL_FATAL = 9
Z3_INVALID_USAGE = 10
Z3_FILE_ACCESS_ERROR = 8
Z3_SORT_ERROR = 1
Z3_PARSER_ERROR = 4
Z3_DEC_REF_ERROR = 11
# enum Z3_goal_prec
Z3_GOAL_UNDER = 1
Z3_GOAL_PRECISE = 0
Z3_GOAL_UNDER_OVER = 3
Z3_GOAL_OVER = 2

8336
python/z3core.py
View file

File diff suppressed because it is too large Load diff

67
python/z3poly.py Normal file
View file

@ -0,0 +1,67 @@
############################################
# Copyright (c) 2012 Microsoft Corporation
#
# Z3 Polynomial interface
#
# Author: Leonardo de Moura (leonardo)
############################################
from z3 import *
class PolynomialManager:
"""Polynomial Manager.
"""
def __init__(self, ctx=None):
self.ctx = z3._get_ctx(ctx)
self.manager = Z3_mk_polynomial_manager(self.ctx_ref())
def __del__(self):
Z3_del_polynomial_manager(self.ctx_ref(), self.manager)
def ctx_ref(self):
return self.ctx.ref()
def m(self):
return self.manager
_main_pmanager = None
def main_pmanager():
"""Return a reference to the global Polynomial manager.
"""
global _main_pmanager
if _main_pmanager == None:
_main_pmanager = PolynomialManager()
return _main_pmanager
def _get_pmanager(ctx):
if ctx == None:
return main_pmanager()
else:
return ctx
class Polynomial:
"""Multivariate polynomials.
"""
def __init__(self, poly=None, m=None):
self.pmanager = _get_pmanager(m)
if poly == None:
self.poly = Z3_mk_zero_polynomial(self.ctx_ref(), self.m())
else:
self.poly = poly
Z3_polynomial_inc_ref(self.ctx_ref(), self.m(), self.poly)
def __del__(self):
Z3_polynomial_dec_ref(self.ctx_ref(), self.m(), self.poly)
def m(self):
return self.pmanager.m()
def ctx_ref(self):
return self.pmanager.ctx_ref()
def __repr__(self):
return Z3_polynomial_to_string(self.ctx_ref(), self.m(), self.poly)
# test
p = Polynomial()
print p

716
python/z3tactics.py
View file

@ -1,356 +1,360 @@
# Automatically generated file, generator: mk_z3tactics.py
import z3core
import z3
def simplify_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'simplify'), ctx)
def split_clause_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'split-clause'), ctx)
def normalize_bounds_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'normalize-bounds'), ctx)
def elim_uncnstr_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'elim-uncnstr'), ctx)
def elim_and_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'elim-and'), ctx)
def add_bounds_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'add-bounds'), ctx)
def aig_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'aig'), ctx)
def skip_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'skip'), ctx)
def fail_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'fail'), ctx)
def smt_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'smt'), ctx)
def bit_blast_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'bit-blast'), ctx)
def bv1_blast_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'bv1-blast'), ctx)
def sat_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'sat'), ctx)
def sat_preprocess_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'sat-preprocess'), ctx)
def ctx_simplify_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'ctx-simplify'), ctx)
def ctx_solver_simplify_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'ctx-solver-simplify'), ctx)
def der_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'der'), ctx)
def unit_subsume_simplify_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'unit-subsume-simplify'), ctx)
def occf_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'occf'), ctx)
def qe_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'qe'), ctx)
def qe_sat_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'qe-sat'), ctx)
def propagate_values_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'propagate-values'), ctx)
def snf_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'snf'), ctx)
def nnf_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'nnf'), ctx)
def solve_eqs_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'solve-eqs'), ctx)
def max_bv_sharing_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'max-bv-sharing'), ctx)
def elim_term_ite_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'elim-term-ite'), ctx)
def fix_dl_var_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'fix-dl-var'), ctx)
def tseitin_cnf_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'tseitin-cnf'), ctx)
def tseitin_cnf_core_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'tseitin-cnf-core'), ctx)
def degree_shift_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'degree-shift'), ctx)
def purify_arith_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'purify-arith'), ctx)
def nlsat_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'nlsat'), ctx)
def factor_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'factor'), ctx)
def fm_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'fm'), ctx)
def fail_if_undecided_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'fail-if-undecided'), ctx)
def diff_neq_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'diff-neq'), ctx)
def lia2pb_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'lia2pb'), ctx)
def fpa2bv_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'fpa2bv'), ctx)
def qffpa_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'qffpa'), ctx)
def pb2bv_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'pb2bv'), ctx)
def recover_01_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'recover-01'), ctx)
def symmetry_reduce_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'symmetry-reduce'), ctx)
def distribute_forall_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'distribute-forall'), ctx)
def reduce_args_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'reduce-args'), ctx)
def reduce_bv_size_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'reduce-bv-size'), ctx)
def propagate_ineqs_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'propagate-ineqs'), ctx)
def cofactor_term_ite_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'cofactor-term-ite'), ctx)
def mip_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'mip'), ctx)
def nla2bv_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'nla2bv'), ctx)
def vsubst_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'vsubst'), ctx)
def qfbv_sls_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'qfbv-sls'), ctx)
def qflia_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'qflia'), ctx)
def qflra_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'qflra'), ctx)
def qfnia_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'qfnia'), ctx)
def qfnra_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'qfnra'), ctx)
def qfbv_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'qfbv'), ctx)
def subpaving_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'subpaving'), ctx)
def memory_probe(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Probe(z3core.Z3_mk_probe(ctx.ref(), 'memory'), ctx)
def depth_probe(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Probe(z3core.Z3_mk_probe(ctx.ref(), 'depth'), ctx)
def size_probe(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Probe(z3core.Z3_mk_probe(ctx.ref(), 'size'), ctx)
def num_exprs_probe(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Probe(z3core.Z3_mk_probe(ctx.ref(), 'num-exprs'), ctx)
def num_consts_probe(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Probe(z3core.Z3_mk_probe(ctx.ref(), 'num-consts'), ctx)
def num_bool_consts_probe(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Probe(z3core.Z3_mk_probe(ctx.ref(), 'num-bool-consts'), ctx)
def num_arith_consts_probe(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Probe(z3core.Z3_mk_probe(ctx.ref(), 'num-arith-consts'), ctx)
def num_bv_consts_probe(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Probe(z3core.Z3_mk_probe(ctx.ref(), 'num-bv-consts'), ctx)
def produce_proofs_probe(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Probe(z3core.Z3_mk_probe(ctx.ref(), 'produce-proofs'), ctx)
def produce_model_probe(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Probe(z3core.Z3_mk_probe(ctx.ref(), 'produce-model'), ctx)
def produce_unsat_cores_probe(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Probe(z3core.Z3_mk_probe(ctx.ref(), 'produce-unsat-cores'), ctx)
def has_patterns_probe(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Probe(z3core.Z3_mk_probe(ctx.ref(), 'has-patterns'), ctx)
def is_propositional_probe(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Probe(z3core.Z3_mk_probe(ctx.ref(), 'is-propositional'), ctx)
def is_qfbv_probe(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Probe(z3core.Z3_mk_probe(ctx.ref(), 'is-qfbv'), ctx)
def is_qfbv_eq_probe(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Probe(z3core.Z3_mk_probe(ctx.ref(), 'is-qfbv-eq'), ctx)
def is_qflia_probe(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Probe(z3core.Z3_mk_probe(ctx.ref(), 'is-qflia'), ctx)
def is_qflra_probe(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Probe(z3core.Z3_mk_probe(ctx.ref(), 'is-qflra'), ctx)
def is_qflira_probe(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Probe(z3core.Z3_mk_probe(ctx.ref(), 'is-qflira'), ctx)
def is_ilp_probe(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Probe(z3core.Z3_mk_probe(ctx.ref(), 'is-ilp'), ctx)
def is_mip_probe(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Probe(z3core.Z3_mk_probe(ctx.ref(), 'is-mip'), ctx)
def is_unbounded_probe(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Probe(z3core.Z3_mk_probe(ctx.ref(), 'is-unbounded'), ctx)
def is_pb_probe(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Probe(z3core.Z3_mk_probe(ctx.ref(), 'is-pb'), ctx)
def arith_max_deg_probe(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Probe(z3core.Z3_mk_probe(ctx.ref(), 'arith-max-deg'), ctx)
def arith_avg_deg_probe(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Probe(z3core.Z3_mk_probe(ctx.ref(), 'arith-avg-deg'), ctx)
def arith_max_bw_probe(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Probe(z3core.Z3_mk_probe(ctx.ref(), 'arith-max-bw'), ctx)
def arith_avg_bw_probe(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Probe(z3core.Z3_mk_probe(ctx.ref(), 'arith-avg-bw'), ctx)
def is_qfnia_probe(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Probe(z3core.Z3_mk_probe(ctx.ref(), 'is-qfnia'), ctx)
def is_qfnra_probe(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Probe(z3core.Z3_mk_probe(ctx.ref(), 'is-qfnra'), ctx)
def is_nia_probe(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Probe(z3core.Z3_mk_probe(ctx.ref(), 'is-nia'), ctx)
def is_nra_probe(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Probe(z3core.Z3_mk_probe(ctx.ref(), 'is-nra'), ctx)
# Automatically generated file, generator: update_api.py
import z3core
import z3
def simplify_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'simplify'), ctx)
def split_clause_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'split-clause'), ctx)
def normalize_bounds_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'normalize-bounds'), ctx)
def elim_uncnstr_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'elim-uncnstr'), ctx)
def elim_and_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'elim-and'), ctx)
def add_bounds_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'add-bounds'), ctx)
def aig_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'aig'), ctx)
def skip_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'skip'), ctx)
def fail_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'fail'), ctx)
def smt_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'smt'), ctx)
def bit_blast_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'bit-blast'), ctx)
def bv1_blast_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'bv1-blast'), ctx)
def sat_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'sat'), ctx)
def sat_preprocess_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'sat-preprocess'), ctx)
def ctx_simplify_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'ctx-simplify'), ctx)
def ctx_solver_simplify_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'ctx-solver-simplify'), ctx)
def der_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'der'), ctx)
def unit_subsume_simplify_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'unit-subsume-simplify'), ctx)
def occf_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'occf'), ctx)
def qe_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'qe'), ctx)
def qe_sat_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'qe-sat'), ctx)
def propagate_values_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'propagate-values'), ctx)
def snf_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'snf'), ctx)
def nnf_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'nnf'), ctx)
def solve_eqs_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'solve-eqs'), ctx)
def max_bv_sharing_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'max-bv-sharing'), ctx)
def elim_term_ite_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'elim-term-ite'), ctx)
def fix_dl_var_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'fix-dl-var'), ctx)
def tseitin_cnf_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'tseitin-cnf'), ctx)
def tseitin_cnf_core_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'tseitin-cnf-core'), ctx)
def degree_shift_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'degree-shift'), ctx)
def purify_arith_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'purify-arith'), ctx)
def nlsat_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'nlsat'), ctx)
def factor_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'factor'), ctx)
def fm_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'fm'), ctx)
def fail_if_undecided_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'fail-if-undecided'), ctx)
def diff_neq_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'diff-neq'), ctx)
def lia2pb_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'lia2pb'), ctx)
def fpa2bv_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'fpa2bv'), ctx)
def qffpa_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'qffpa'), ctx)
def pb2bv_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'pb2bv'), ctx)
def recover_01_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'recover-01'), ctx)
def symmetry_reduce_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'symmetry-reduce'), ctx)
def distribute_forall_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'distribute-forall'), ctx)
def reduce_args_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'reduce-args'), ctx)
def reduce_bv_size_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'reduce-bv-size'), ctx)
def propagate_ineqs_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'propagate-ineqs'), ctx)
def cofactor_term_ite_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'cofactor-term-ite'), ctx)
def mip_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'mip'), ctx)
def nla2bv_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'nla2bv'), ctx)
def vsubst_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'vsubst'), ctx)
def qfbv_sls_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'qfbv-sls'), ctx)
def qflia_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'qflia'), ctx)
def qflra_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'qflra'), ctx)
def qfnia_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'qfnia'), ctx)
def qfnra_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'qfnra'), ctx)
def qfnra_nlsat_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'qfnra-nlsat'), ctx)
def qfbv_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'qfbv'), ctx)
def subpaving_tactic(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), 'subpaving'), ctx)
def memory_probe(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Probe(z3core.Z3_mk_probe(ctx.ref(), 'memory'), ctx)
def depth_probe(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Probe(z3core.Z3_mk_probe(ctx.ref(), 'depth'), ctx)
def size_probe(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Probe(z3core.Z3_mk_probe(ctx.ref(), 'size'), ctx)
def num_exprs_probe(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Probe(z3core.Z3_mk_probe(ctx.ref(), 'num-exprs'), ctx)
def num_consts_probe(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Probe(z3core.Z3_mk_probe(ctx.ref(), 'num-consts'), ctx)
def num_bool_consts_probe(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Probe(z3core.Z3_mk_probe(ctx.ref(), 'num-bool-consts'), ctx)
def num_arith_consts_probe(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Probe(z3core.Z3_mk_probe(ctx.ref(), 'num-arith-consts'), ctx)
def num_bv_consts_probe(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Probe(z3core.Z3_mk_probe(ctx.ref(), 'num-bv-consts'), ctx)
def produce_proofs_probe(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Probe(z3core.Z3_mk_probe(ctx.ref(), 'produce-proofs'), ctx)
def produce_model_probe(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Probe(z3core.Z3_mk_probe(ctx.ref(), 'produce-model'), ctx)
def produce_unsat_cores_probe(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Probe(z3core.Z3_mk_probe(ctx.ref(), 'produce-unsat-cores'), ctx)
def has_patterns_probe(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Probe(z3core.Z3_mk_probe(ctx.ref(), 'has-patterns'), ctx)
def is_propositional_probe(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Probe(z3core.Z3_mk_probe(ctx.ref(), 'is-propositional'), ctx)
def is_qfbv_probe(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Probe(z3core.Z3_mk_probe(ctx.ref(), 'is-qfbv'), ctx)
def is_qfbv_eq_probe(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Probe(z3core.Z3_mk_probe(ctx.ref(), 'is-qfbv-eq'), ctx)
def is_qflia_probe(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Probe(z3core.Z3_mk_probe(ctx.ref(), 'is-qflia'), ctx)
def is_qflra_probe(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Probe(z3core.Z3_mk_probe(ctx.ref(), 'is-qflra'), ctx)
def is_qflira_probe(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Probe(z3core.Z3_mk_probe(ctx.ref(), 'is-qflira'), ctx)
def is_ilp_probe(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Probe(z3core.Z3_mk_probe(ctx.ref(), 'is-ilp'), ctx)
def is_mip_probe(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Probe(z3core.Z3_mk_probe(ctx.ref(), 'is-mip'), ctx)
def is_unbounded_probe(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Probe(z3core.Z3_mk_probe(ctx.ref(), 'is-unbounded'), ctx)
def is_pb_probe(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Probe(z3core.Z3_mk_probe(ctx.ref(), 'is-pb'), ctx)
def arith_max_deg_probe(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Probe(z3core.Z3_mk_probe(ctx.ref(), 'arith-max-deg'), ctx)
def arith_avg_deg_probe(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Probe(z3core.Z3_mk_probe(ctx.ref(), 'arith-avg-deg'), ctx)
def arith_max_bw_probe(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Probe(z3core.Z3_mk_probe(ctx.ref(), 'arith-max-bw'), ctx)
def arith_avg_bw_probe(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Probe(z3core.Z3_mk_probe(ctx.ref(), 'arith-avg-bw'), ctx)
def is_qfnia_probe(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Probe(z3core.Z3_mk_probe(ctx.ref(), 'is-qfnia'), ctx)
def is_qfnra_probe(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Probe(z3core.Z3_mk_probe(ctx.ref(), 'is-qfnra'), ctx)
def is_nia_probe(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Probe(z3core.Z3_mk_probe(ctx.ref(), 'is-nia'), ctx)
def is_nra_probe(ctx=None):
ctx = z3._get_ctx(ctx)
return z3.Probe(z3core.Z3_mk_probe(ctx.ref(), 'is-nra'), ctx)

12
python/z3types.py
View file

@ -105,3 +105,15 @@ class FuncInterpObj(ctypes.c_void_p):
class FuncEntryObj(ctypes.c_void_p):
def __init__(self, e): self._as_parameter_ = e
def from_param(obj): return obj
class PolynomialManagerObj(ctypes.c_void_p):
def __init__(self, e): self._as_parameter_ = e
def from_param(obj): return obj
class PolynomialObj(ctypes.c_void_p):
def __init__(self, e): self._as_parameter_ = e
def from_param(obj): return obj
class MonomialObj(ctypes.c_void_p):
def __init__(self, e): self._as_parameter_ = e
def from_param(obj): return obj

13
update_api.cmd
View file

@ -1,13 +0,0 @@
pushd dll
python mk_def.py
popd
pushd lib
python api.py
popd
pushd Microsoft.Z3
python mk_z3consts.py
popd
pushd python
python mk_z3consts.py
python mk_z3tactics.py
popd

871
update_api.py Normal file
View file

@ -0,0 +1,871 @@
############################################
# Copyright (c) 2012 Microsoft Corporation
#
# Scripts for generate API bindings and definitions
#
# Author: Leonardo de Moura (leonardo)
############################################
import re
import sys
import os
from sets import Set
API_FILES = []
def add_api_file(dir, file):
API_FILES.append("%s%s%s" % (dir, os.sep, file))
add_api_file('lib', 'z3_api.h')
add_api_file('lib', 'z3_internal_types.h')
add_api_file('lib', 'z3_poly.h')
# Extract enumeration types from z3_api.h, and add .Net definitions
def mk_z3consts_donet():
blank_pat = re.compile("^ *$")
comment_pat = re.compile("^ *//.*$")
typedef_pat = re.compile("typedef enum *")
typedef2_pat = re.compile("typedef enum { *")
openbrace_pat = re.compile("{ *")
closebrace_pat = re.compile("}.*;")
DeprecatedEnums = { 'Z3_search_failure' }
z3consts = open('Microsoft.Z3%sEnumerations.cs' % os.sep, 'w')
z3consts.write('// Automatically generated file, generator: update_api.py\n\n')
z3consts.write('using System;\n\n'
'#pragma warning disable 1591\n\n'
'namespace Microsoft.Z3\n'
'{\n');
for api_file in API_FILES:
api = open(api_file, 'r')
SEARCHING = 0
FOUND_ENUM = 1
IN_ENUM = 2
mode = SEARCHING
decls = {}
idx = 0
linenum = 1
for line in api:
m1 = blank_pat.match(line)
m2 = comment_pat.match(line)
if m1 or m2:
# skip blank lines and comments
linenum = linenum + 1
elif mode == SEARCHING:
m = typedef_pat.match(line)
if m:
mode = FOUND_ENUM
m = typedef2_pat.match(line)
if m:
mode = IN_ENUM
decls = {}
idx = 0
elif mode == FOUND_ENUM:
m = openbrace_pat.match(line)
if m:
mode = IN_ENUM
decls = {}
idx = 0
else:
assert False, "Invalid %s, line: %s" % (api_file, linenum)
else:
assert mode == IN_ENUM
words = re.split('[^\-a-zA-Z0-9_]+', line)
m = closebrace_pat.match(line)
if m:
name = words[1]
if name not in DeprecatedEnums:
z3consts.write(' /// <summary>%s</summary>\n' % name)
z3consts.write(' public enum %s {\n' % name)
z3consts.write
for k, i in decls.iteritems():
z3consts.write(' %s = %s,\n' % (k, i))
z3consts.write(' }\n\n')
mode = SEARCHING
else:
if words[2] != '':
if len(words[2]) > 1 and words[2][1] == 'x':
idx = int(words[2], 16)
else:
idx = int(words[2])
decls[words[1]] = idx
idx = idx + 1
linenum = linenum + 1
z3consts.write('}\n');
# Extract enumeration types from z3_api.h, and add python definitions.
def mk_z3consts_py():
blank_pat = re.compile("^ *$")
comment_pat = re.compile("^ *//.*$")
typedef_pat = re.compile("typedef enum *")
typedef2_pat = re.compile("typedef enum { *")
openbrace_pat = re.compile("{ *")
closebrace_pat = re.compile("}.*;")
z3consts = open('python%sz3consts.py' % (os.sep), 'w')
z3consts.write('# Automatically generated file, generator: update_api.py\n\n')
for api_file in API_FILES:
api = open(api_file, 'r')
SEARCHING = 0
FOUND_ENUM = 1
IN_ENUM = 2
mode = SEARCHING
decls = {}
idx = 0
linenum = 1
for line in api:
m1 = blank_pat.match(line)
m2 = comment_pat.match(line)
if m1 or m2:
# skip blank lines and comments
linenum = linenum + 1
elif mode == SEARCHING:
m = typedef_pat.match(line)
if m:
mode = FOUND_ENUM
m = typedef2_pat.match(line)
if m:
mode = IN_ENUM
decls = {}
idx = 0
elif mode == FOUND_ENUM:
m = openbrace_pat.match(line)
if m:
mode = IN_ENUM
decls = {}
idx = 0
else:
assert False, "Invalid %s, line: %s" % (api_file, linenum)
else:
assert mode == IN_ENUM
words = re.split('[^\-a-zA-Z0-9_]+', line)
m = closebrace_pat.match(line)
if m:
name = words[1]
z3consts.write('# enum %s\n' % name)
for k, i in decls.iteritems():
z3consts.write('%s = %s\n' % (k, i))
z3consts.write('\n')
mode = SEARCHING
else:
if words[2] != '':
if len(words[2]) > 1 and words[2][1] == 'x':
idx = int(words[2], 16)
else:
idx = int(words[2])
decls[words[1]] = idx
idx = idx + 1
linenum = linenum + 1
# Extract tactic and probe definitions from lib\install_tactics.cpp, and
# Add python function definitions for them.
def mk_z3tactics_py():
tactic_pat = re.compile("^[ \t]*ADD_TACTIC_CMD")
probe_pat = re.compile("^[ \t]*ADD_PROBE")
cppfile = open('lib%sinstall_tactics.cpp' % os.sep, 'r')
z3tactics = open('python%sz3tactics.py' % os.sep, 'w')
z3tactics.write('# Automatically generated file, generator: update_api.py\n')
z3tactics.write('import z3core\n')
z3tactics.write('import z3\n\n')
for line in cppfile:
m1 = tactic_pat.match(line)
m2 = probe_pat.match(line)
if m1:
words = re.split('[^\-a-zA-Z0-9_]+', line)
tactic = words[2]
py_tactic = tactic.replace('-', '_')
z3tactics.write('def %s_tactic(ctx=None):\n' % py_tactic)
z3tactics.write(' ctx = z3._get_ctx(ctx)\n')
z3tactics.write(' return z3.Tactic(z3core.Z3_mk_tactic(ctx.ref(), \'%s\'), ctx)\n\n' % tactic)
elif m2:
words = re.split('[^\-a-zA-Z0-9_]+', line)
probe = words[2]
py_probe = probe.replace('-', '_')
z3tactics.write('def %s_probe(ctx=None):\n' % py_probe)
z3tactics.write(' ctx = z3._get_ctx(ctx)\n')
z3tactics.write(' return z3.Probe(z3core.Z3_mk_probe(ctx.ref(), \'%s\'), ctx)\n\n' % probe)
# Create .def files for DLL generation
def mk_dll_defs():
pat1 = re.compile(".*Z3_API.*")
z3def = open('dll%sz3.def' % os.sep, 'w')
z3def.write('LIBRARY "Z3"\nEXPORTS\n')
num = 1
for api_file in API_FILES:
api = open(api_file, 'r')
for line in api:
m = pat1.match(line)
if m:
words = re.split('\W+', line)
i = 0
for w in words:
if w == 'Z3_API':
f = words[i+1]
z3def.write('\t%s @%s\n' % (f, num))
i = i + 1
num = num + 1
#
# Generate logging support and bindings
#
log_h = open('lib%sapi_log_macros.h' % os.sep, 'w')
log_c = open('lib%sapi_log_macros.cpp' % os.sep, 'w')
exe_c = open('lib%sapi_commands.cpp' % os.sep, 'w')
core_py = open('python%sz3core.py' % os.sep, 'w')
dotnet_fileout = 'Microsoft.Z3%sNative.cs' % os.sep
##
log_h.write('// Automatically generated file, generator: update_api.py\n')
log_h.write('#include\"z3.h\"\n')
##
log_c.write('// Automatically generated file, generator: update_api.py\n')
log_c.write('#include<iostream>\n')
log_c.write('#include\"z3.h\"\n')
log_c.write('#include\"api_log_macros.h\"\n')
log_c.write('#include\"z3_logger.h\"\n')
##
exe_c.write('// Automatically generated file, generator: update_api.py\n')
exe_c.write('#include\"z3.h\"\n')
exe_c.write('#include\"z3_internal.h\"\n')
exe_c.write('#include\"z3_replayer.h\"\n')
##
log_h.write('extern std::ostream * g_z3_log;\n')
log_h.write('extern bool g_z3_log_enabled;\n')
log_h.write('class z3_log_ctx { bool m_prev; public: z3_log_ctx():m_prev(g_z3_log_enabled) { g_z3_log_enabled = false; } ~z3_log_ctx() { g_z3_log_enabled = m_prev; } bool enabled() const { return m_prev; } };\n')
log_h.write('inline void SetR(void * obj) { *g_z3_log << "= " << obj << "\\n"; }\ninline void SetO(void * obj, unsigned pos) { *g_z3_log << "* " << obj << " " << pos << "\\n"; } \ninline void SetAO(void * obj, unsigned pos, unsigned idx) { *g_z3_log << "@ " << obj << " " << pos << " " << idx << "\\n"; }\n')
log_h.write('#define RETURN_Z3(Z3RES) if (_LOG_CTX.enabled()) { SetR(Z3RES); } return Z3RES\n')
log_h.write('void _Z3_append_log(char const * msg);\n')
##
exe_c.write('void Z3_replacer_error_handler(Z3_context ctx, Z3_error_code c) { printf("[REPLAYER ERROR HANDLER]: %s\\n", Z3_get_error_msg_ex(ctx, c)); }\n')
##
core_py.write('# Automatically generated file, generator: update_api.py\n')
core_py.write('import sys, os\n')
core_py.write('import ctypes\n')
core_py.write('from z3types import *\n')
core_py.write('from z3consts import *\n')
core_py.write("""
def _find_lib():
_dir = os.path.dirname(os.path.abspath(__file__))
libs = ['z3.dll', 'libz3.so', 'libz3.dylib']
if sys.maxsize > 2**32:
locs = [_dir, '%s%s..%sx64%sexternal' % (_dir, os.sep, os.sep, os.sep), '%s%s..%sbin%sexternal' % (_dir, os.sep, os.sep, os.sep)]
else:
locs = [_dir, '%s%s..%sexternal' % (_dir, os.sep, os.sep), '%s%s..%sbin%sexternal' % (_dir, os.sep, os.sep, os.sep)]
for loc in locs:
for lib in libs:
f = '%s%s%s' % (loc, os.sep, lib)
if os.path.exists(f):
return f
return None
_lib = None
def lib():
if _lib == None:
l = _find_lib()
if l == None:
raise Z3Exception("init(Z3_LIBRARY_PATH) must be invoked before using Z3-python")
init(l)
assert _lib != None
return _lib
def init(PATH):
global _lib
_lib = ctypes.CDLL(PATH)
""")
IN = 0
OUT = 1
INOUT = 2
IN_ARRAY = 3
OUT_ARRAY = 4
INOUT_ARRAY = 5
# Primitive Types
VOID = 0
VOID_PTR = 1
INT = 2
UINT = 3
INT64 = 4
UINT64 = 5
STRING = 6
STRING_PTR = 7
BOOL = 8
SYMBOL = 9
PRINT_MODE = 10
ERROR_CODE = 11
DOUBLE = 12
FIRST_OBJ_ID = 100
def is_obj(ty):
return ty >= FIRST_OBJ_ID
Type2Str = { VOID : 'void', VOID_PTR : 'void*', INT : 'int', UINT : 'unsigned', INT64 : '__int64', UINT64 : '__uint64', DOUBLE : 'double',
STRING : 'Z3_string', STRING_PTR : 'Z3_string_ptr', BOOL : 'Z3_bool', SYMBOL : 'Z3_symbol',
PRINT_MODE : 'Z3_ast_print_mode', ERROR_CODE : 'Z3_error_code',
}
Type2PyStr = { VOID_PTR : 'ctypes.c_void_p', INT : 'ctypes.c_int', UINT : 'ctypes.c_uint', INT64 : 'ctypes.c_longlong',
UINT64 : 'ctypes.c_ulonglong', DOUBLE : 'ctypes.c_double',
STRING : 'ctypes.c_char_p', STRING_PTR : 'ctypes.POINTER(ctypes.c_char_p)', BOOL : 'ctypes.c_bool', SYMBOL : 'Symbol',
PRINT_MODE : 'ctypes.c_uint', ERROR_CODE : 'ctypes.c_uint',
}
# Mapping to .NET types
Type2Dotnet = { VOID : 'void', VOID_PTR : 'IntPtr', INT : 'int', UINT : 'uint', INT64 : 'Int64', UINT64 : 'UInt64', DOUBLE : 'double',
STRING : 'string', STRING_PTR : 'byte**', BOOL : 'int', SYMBOL : 'IntPtr',
PRINT_MODE : 'uint', ERROR_CODE : 'uint' }
next_type_id = FIRST_OBJ_ID
def def_Type(var, c_type, py_type):
global next_type_id
exec ('%s = %s' % (var, next_type_id)) in globals()
Type2Str[next_type_id] = c_type
Type2PyStr[next_type_id] = py_type
next_type_id = next_type_id + 1
def def_Types():
pat1 = re.compile(" *def_Type.*")
for api_file in API_FILES:
api = open(api_file, 'r')
for line in api:
m = pat1.match(line)
if m:
print line.strip()
eval(line)
for k, v in Type2Str.iteritems():
if is_obj(k):
Type2Dotnet[k] = v
def type2str(ty):
global Type2Str
return Type2Str[ty]
def type2pystr(ty):
global Type2PyStr
return Type2PyStr[ty]
def type2dotnet(ty):
global Type2Dotnet
return Type2Dotnet[ty]
def _in(ty):
return (IN, ty);
def _in_array(sz, ty):
return (IN_ARRAY, ty, sz);
def _out(ty):
return (OUT, ty);
def _out_array(sz, ty):
return (OUT_ARRAY, ty, sz, sz);
# cap contains the position of the argument that stores the capacity of the array
# sz contains the position of the output argument that stores the (real) size of the array
def _out_array2(cap, sz, ty):
return (OUT_ARRAY, ty, cap, sz)
def _inout_array(sz, ty):
return (INOUT_ARRAY, ty, sz, sz);
def param_kind(p):
return p[0]
def param_type(p):
return p[1]
def param_array_capacity_pos(p):
return p[2]
def param_array_size_pos(p):
return p[3]
def param2str(p):
if param_kind(p) == IN_ARRAY:
return "%s const *" % type2str(param_type(p))
elif param_kind(p) == OUT_ARRAY or param_kind(p) == IN_ARRAY or param_kind(p) == INOUT_ARRAY:
return "%s*" % type2str(param_type(p))
elif param_kind(p) == OUT:
return "%s*" % type2str(param_type(p))
else:
return type2str(param_type(p))
def param2dotnet(p):
k = param_kind(p)
if k == OUT:
if param_type(p) == STRING:
return "out IntPtr"
else:
return "[In, Out] ref %s" % type2dotnet(param_type(p))
if k == IN_ARRAY:
return "[In] %s[]" % type2dotnet(param_type(p))
if k == INOUT_ARRAY:
return "[In, Out] %s[]" % type2dotnet(param_type(p))
if k == OUT_ARRAY:
return "[Out] %s[]" % type2dotnet(param_type(p))
else:
return type2dotnet(param_type(p))
def param2pystr(p):
if param_kind(p) == IN_ARRAY or param_kind(p) == OUT_ARRAY or param_kind(p) == IN_ARRAY or param_kind(p) == INOUT_ARRAY or param_kind(p) == OUT:
return "ctypes.POINTER(%s)" % type2pystr(param_type(p))
else:
return type2pystr(param_type(p))
# Save name, result, params to generate wrapper
_API2PY = []
def mk_py_binding(name, result, params):
global core_py
global _API2PY
_API2PY.append((name, result, params))
if result != VOID:
core_py.write(" _lib.%s.restype = %s\n" % (name, type2pystr(result)))
core_py.write(" _lib.%s.argtypes = [" % name)
first = True
for p in params:
if first:
first = False
else:
core_py.write(", ")
core_py.write(param2pystr(p))
core_py.write("]\n")
def extra_API(name, result, params):
print 'extra_API(%s)' % name
mk_py_binding(name, result, params)
reg_dotnet(name, result, params)
def display_args(num):
for i in range(num):
if i > 0:
core_py.write(", ")
core_py.write("a%s" % i)
def mk_py_wrappers():
core_py.write("\n")
for sig in _API2PY:
name = sig[0]
result = sig[1]
params = sig[2]
num = len(params)
core_py.write("def %s(" % name)
display_args(num)
core_py.write("):\n")
if result != VOID:
core_py.write(" r = lib().%s(" % name)
else:
core_py.write(" lib().%s(" % name)
display_args(num)
core_py.write(")\n")
if len(params) > 0 and param_type(params[0]) == CONTEXT:
core_py.write(" err = lib().Z3_get_error_code(a0)\n")
core_py.write(" if err != Z3_OK:\n")
core_py.write(" raise Z3Exception(lib().Z3_get_error_msg_ex(a0, err))\n")
if result != VOID:
core_py.write(" return r\n")
core_py.write("\n")
## .NET API native interface
_dotnet_decls = []
def reg_dotnet(name, result, params):
global _dotnet_decls
_dotnet_decls.append((name, result, params))
def mk_dotnet():
global Type2Str
global dotnet_fileout
dotnet = open(dotnet_fileout, 'w')
dotnet.write('// Automatically generated file, generator: api.py\n')
dotnet.write('using System;\n')
dotnet.write('using System.Collections.Generic;\n')
dotnet.write('using System.Text;\n')
dotnet.write('using System.Runtime.InteropServices;\n\n')
dotnet.write('#pragma warning disable 1591\n\n');
dotnet.write('namespace Microsoft.Z3\n')
dotnet.write('{\n')
for k, v in Type2Str.iteritems():
if is_obj(k):
dotnet.write(' using %s = System.IntPtr;\n' % v)
dotnet.write('\n');
dotnet.write(' public class Native\n')
dotnet.write(' {\n\n')
dotnet.write(' [UnmanagedFunctionPointer(CallingConvention.Cdecl)]\n')
dotnet.write(' public delegate void Z3_error_handler(Z3_context c, Z3_error_code e);\n\n')
dotnet.write(' public unsafe class LIB\n')
dotnet.write(' {\n')
dotnet.write(' '
' const string Z3_DLL_NAME = \"z3.dll\";\n'
' \n');
dotnet.write(' [DllImport(Z3_DLL_NAME, CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi)]\n')
dotnet.write(' public extern static void Z3_set_error_handler(Z3_context a0, Z3_error_handler a1);\n\n')
for name, result, params in _dotnet_decls:
dotnet.write(' [DllImport(Z3_DLL_NAME, CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi)]\n')
dotnet.write(' ')
if result == STRING:
dotnet.write('public extern static IntPtr %s(' % (name))
else:
dotnet.write('public extern static %s %s(' % (type2dotnet(result), name))
first = True
i = 0;
for param in params:
if first:
first = False
else:
dotnet.write(', ')
dotnet.write('%s a%d' % (param2dotnet(param), i))
i = i + 1
dotnet.write(');\n\n')
dotnet.write(' }\n')
DotnetUnwrapped = { 'Z3_del_context' }
def mk_dotnet_wrappers():
global Type2Str
global dotnet_fileout
dotnet = open(dotnet_fileout, 'a')
dotnet.write("\n")
dotnet.write(" public static void Z3_set_error_handler(Z3_context a0, Z3_error_handler a1) {\n")
dotnet.write(" LIB.Z3_set_error_handler(a0, a1);\n")
dotnet.write(" Z3_error_code err = (Z3_error_code)LIB.Z3_get_error_code(a0);\n")
dotnet.write(" if (err != Z3_error_code.Z3_OK)\n")
dotnet.write(" throw new Z3Exception(Marshal.PtrToStringAnsi(LIB.Z3_get_error_msg_ex(a0, (uint)err)));\n")
dotnet.write(" }\n\n")
for name, result, params in _dotnet_decls:
if result == STRING:
dotnet.write(' public static string %s(' % (name))
else:
dotnet.write(' public static %s %s(' % (type2dotnet(result), name))
first = True
i = 0;
for param in params:
if first:
first = False
else:
dotnet.write(', ')
dotnet.write('%s a%d' % (param2dotnet(param), i))
i = i + 1
dotnet.write(') {\n')
dotnet.write(' ')
if result == STRING:
dotnet.write('IntPtr r = ');
elif result != VOID:
dotnet.write('%s r = ' % type2dotnet(result));
dotnet.write('LIB.%s(' % (name))
first = True
i = 0
for param in params:
if first:
first = False
else:
dotnet.write(', ')
if param_kind(param) == OUT:
if param_type(param) == STRING:
dotnet.write('out ');
else:
dotnet.write('ref ')
dotnet.write('a%d' % i)
i = i + 1
dotnet.write(');\n');
if name not in DotnetUnwrapped:
if len(params) > 0 and param_type(params[0]) == CONTEXT:
dotnet.write(" Z3_error_code err = (Z3_error_code)LIB.Z3_get_error_code(a0);\n")
dotnet.write(" if (err != Z3_error_code.Z3_OK)\n")
dotnet.write(" throw new Z3Exception(Marshal.PtrToStringAnsi(LIB.Z3_get_error_msg_ex(a0, (uint)err)));\n")
if result == STRING:
dotnet.write(" return Marshal.PtrToStringAnsi(r);\n")
elif result != VOID:
dotnet.write(" return r;\n")
dotnet.write(" }\n\n")
dotnet.write(" }\n\n")
dotnet.write("}\n\n")
def mk_log_header(file, name, params):
file.write("void log_%s(" % name)
i = 0
for p in params:
if i > 0:
file.write(", ");
file.write("%s a%s" % (param2str(p), i))
i = i + 1
file.write(")");
def log_param(p):
kind = param_kind(p)
ty = param_type(p)
return is_obj(ty) and (kind == OUT or kind == INOUT or kind == OUT_ARRAY or kind == INOUT_ARRAY)
def log_result(result, params):
for p in params:
if log_param(p):
return True
return False
def mk_log_macro(file, name, params):
file.write("#define LOG_%s(" % name)
i = 0
for p in params:
if i > 0:
file.write(", ")
file.write("_ARG%s" % i)
i = i + 1
file.write(") z3_log_ctx _LOG_CTX; ")
auxs = Set([])
i = 0
for p in params:
if log_param(p):
kind = param_kind(p)
if kind == OUT_ARRAY or kind == INOUT_ARRAY:
cap = param_array_capacity_pos(p)
if cap not in auxs:
auxs.add(cap)
file.write("unsigned Z3ARG%s; " % cap)
sz = param_array_size_pos(p)
if sz not in auxs:
auxs.add(sz)
file.write("unsigned * Z3ARG%s; " % sz)
file.write("%s Z3ARG%s; " % (param2str(p), i))
i = i + 1
file.write("if (_LOG_CTX.enabled()) { log_%s(" % name)
i = 0
for p in params:
if (i > 0):
file.write(', ')
file.write("_ARG%s" %i)
i = i + 1
file.write("); ")
auxs = Set([])
i = 0
for p in params:
if log_param(p):
kind = param_kind(p)
if kind == OUT_ARRAY or kind == INOUT_ARRAY:
cap = param_array_capacity_pos(p)
if cap not in auxs:
auxs.add(cap)
file.write("Z3ARG%s = _ARG%s; " % (cap, cap))
sz = param_array_size_pos(p)
if sz not in auxs:
auxs.add(sz)
file.write("Z3ARG%s = _ARG%s; " % (sz, sz))
file.write("Z3ARG%s = _ARG%s; " % (i, i))
i = i + 1
file.write("}\n")
def mk_log_result_macro(file, name, result, params):
file.write("#define RETURN_%s" % name)
if is_obj(result):
file.write("(Z3RES)")
file.write(" ")
file.write("if (_LOG_CTX.enabled()) { ")
if is_obj(result):
file.write("SetR(Z3RES); ")
i = 0
for p in params:
if log_param(p):
kind = param_kind(p)
if kind == OUT_ARRAY or kind == INOUT_ARRAY:
cap = param_array_capacity_pos(p)
sz = param_array_size_pos(p)
if cap == sz:
file.write("for (unsigned i = 0; i < Z3ARG%s; i++) { SetAO(Z3ARG%s[i], %s, i); } " % (sz, i, i))
else:
file.write("for (unsigned i = 0; Z3ARG%s && i < *Z3ARG%s; i++) { SetAO(Z3ARG%s[i], %s, i); } " % (sz, sz, i, i))
if kind == OUT or kind == INOUT:
file.write("SetO((Z3ARG%s == 0 ? 0 : *Z3ARG%s), %s); " % (i, i, i))
i = i + 1
file.write("} ")
if is_obj(result):
file.write("return Z3RES\n")
else:
file.write("return\n")
def mk_exec_header(file, name):
file.write("void exec_%s(z3_replayer & in)" % name)
def error(msg):
sys.stderr.write(msg)
exit(-1)
next_id = 0
API2Id = {}
def def_API(name, result, params):
global API2Id, next_id
global log_h, log_c
print 'def_API(%s)' % name
# print "generating ", name
mk_py_binding(name, result, params)
reg_dotnet(name, result, params)
API2Id[next_id] = name
mk_log_header(log_h, name, params)
log_h.write(';\n')
mk_log_header(log_c, name, params)
log_c.write(' {\n R();\n')
mk_exec_header(exe_c, name)
exe_c.write(' {\n')
# Create Log function & Function call
i = 0
exe_c.write(" ")
if is_obj(result):
exe_c.write("%s result = " % type2str(result))
exe_c.write("%s(\n " % name)
for p in params:
kind = param_kind(p)
ty = param_type(p)
if (i > 0):
exe_c.write(",\n ")
if kind == IN:
if is_obj(ty):
log_c.write(" P(a%s);\n" % i)
exe_c.write("reinterpret_cast<%s>(in.get_obj(%s))" % (param2str(p), i))
elif ty == STRING:
log_c.write(" S(a%s);\n" % i)
exe_c.write("in.get_str(%s)" % i)
elif ty == SYMBOL:
log_c.write(" Sy(a%s);\n" % i)
exe_c.write("in.get_symbol(%s)" % i)
elif ty == UINT:
log_c.write(" U(a%s);\n" % i)
exe_c.write("in.get_uint(%s)" % i)
elif ty == UINT64:
log_c.write(" U(a%s);\n" % i)
exe_c.write("in.get_uint64(%s)" % i)
elif ty == INT:
log_c.write(" I(a%s);\n" % i)
exe_c.write("in.get_int(%s)" % i)
elif ty == INT64:
log_c.write(" I(a%s);\n" % i)
exe_c.write("in.get_int64(%s)" % i)
elif ty == DOUBLE:
log_c.write(" D(a%s);\n" % i)
exe_c.write("in.get_double(%s)" % i)
elif ty == BOOL:
log_c.write(" I(a%s);\n" % i)
exe_c.write("in.get_bool(%s)" % i)
elif ty == PRINT_MODE or ty == ERROR_CODE:
log_c.write(" U(static_cast<unsigned>(a%s));\n" % i);
exe_c.write("static_cast<%s>(in.get_uint(%s))" % (type2str(ty), i))
else:
error("unsupported parameter for %s, %s" % (name, p))
elif kind == INOUT:
error("unsupported parameter for %s, %s" % (name, p))
elif kind == OUT:
if is_obj(ty):
log_c.write(" P(0);\n")
exe_c.write("reinterpret_cast<%s>(in.get_obj_addr(%s))" % (param2str(p), i))
elif ty == STRING:
log_c.write(" S(\"\");\n")
exe_c.write("in.get_str_addr(%s)" % i)
elif ty == UINT:
log_c.write(" U(0);\n")
exe_c.write("in.get_uint_addr(%s)" % i)
elif ty == UINT64:
log_c.write(" U(0);\n")
exe_c.write("in.get_uint64_addr(%s)" % i)
elif ty == INT:
log_c.write(" I(0);\n")
exe_c.write("in.get_int_addr(%s)" % i)
elif ty == INT64:
log_c.write(" I(0);\n")
exe_c.write("in.get_int64_addr(%s)" % i)
else:
error("unsupported parameter for %s, %s" % (name, p))
elif kind == IN_ARRAY or kind == INOUT_ARRAY:
sz = param_array_capacity_pos(p)
log_c.write(" for (unsigned i = 0; i < a%s; i++) { " % sz)
if is_obj(ty):
log_c.write("P(a%s[i]);" % i)
log_c.write(" }\n")
log_c.write(" Ap(a%s);\n" % sz)
exe_c.write("reinterpret_cast<%s*>(in.get_obj_array(%s))" % (type2str(ty), i))
elif ty == SYMBOL:
log_c.write("Sy(a%s[i]);" % i)
log_c.write(" }\n")
log_c.write(" Asy(a%s);\n" % sz)
exe_c.write("in.get_symbol_array(%s)" % i)
elif ty == UINT:
log_c.write("U(a%s[i]);" % i)
log_c.write(" }\n")
log_c.write(" Au(a%s);\n" % sz)
exe_c.write("in.get_uint_array(%s)" % i)
else:
error ("unsupported parameter for %s, %s" % (name, p))
elif kind == OUT_ARRAY:
sz = param_array_capacity_pos(p)
log_c.write(" for (unsigned i = 0; i < a%s; i++) { " % sz)
if is_obj(ty):
log_c.write("P(0);")
log_c.write(" }\n")
log_c.write(" Ap(a%s);\n" % sz)
exe_c.write("reinterpret_cast<%s*>(in.get_obj_array(%s))" % (type2str(ty), i))
elif ty == UINT:
log_c.write("U(0);")
log_c.write(" }\n")
log_c.write(" Au(a%s);\n" % sz)
exe_c.write("in.get_uint_array(%s)" % i)
else:
error ("unsupported parameter for %s, %s" % (name, p))
else:
error ("unsupported parameter for %s, %s" % (name, p))
i = i + 1
log_c.write(" C(%s);\n" % next_id)
exe_c.write(");\n")
if is_obj(result):
exe_c.write(" in.store_result(result);\n")
if name == 'Z3_mk_context' or name == 'Z3_mk_context_rc':
exe_c.write(" Z3_set_error_handler(result, Z3_replacer_error_handler);")
log_c.write('}\n')
exe_c.write('}\n')
mk_log_macro(log_h, name, params)
if log_result(result, params):
mk_log_result_macro(log_h, name, result, params)
next_id = next_id + 1
def mk_bindings():
exe_c.write("void register_z3_replayer_cmds(z3_replayer & in) {\n")
for key, val in API2Id.items():
exe_c.write(" in.register_cmd(%s, exec_%s);\n" % (key, val))
exe_c.write("}\n")
# Collect API(...) commands from
def def_APIs():
pat1 = re.compile(" *def_API.*")
pat2 = re.compile(" *extra_API.*")
for api_file in API_FILES:
api = open(api_file, 'r')
for line in api:
m = pat1.match(line)
if m:
eval(line)
m = pat2.match(line)
if m:
eval(line)
mk_z3consts_donet()
mk_z3consts_py()
mk_z3tactics_py()
mk_dll_defs()
def_Types()
def_APIs()
mk_bindings()
mk_py_wrappers()
mk_dotnet()
mk_dotnet_wrappers()

14
update_api.sh
View file

@ -1,14 +0,0 @@
#!/bin/sh
cd dll
python mk_def.py
cd ..
cd lib
python api.py
cd ..
cd Microsoft.Z3
python mk_z3consts.py
cd ..
cd python
python mk_z3consts.py
python mk_z3tactics.py
cd ..

25
update_api.txt
View file

@ -1,26 +1,11 @@
Instructions for updating external Z3 API
-----------------------------------------
1) Add the new function to the file lib\z3_api.h
2) If the function requires logging, then add its definition to lib\api.py.
Each definition is a call to the API function in this python script.
This function has the following signature:
API(function name, return type, argument list)
The return type only needs to be specified if the function returns a Z3 object.
The file lib\api.py contains many examples.
3) Execute update_api.cmd (on Windows) update_api.sh (on Linux or OSX)
This script updates the .def files in the directory dll, and generates the API logging macros.
If one only wants to generate the logging macros. Then it only needs to execute
cd lib
python api.py
The script api.py generates the following files:
lib\z3_api_log.h: macros and function definitions for logging API invocations.
lib\z3_api_log.cpp
lib\z3_api_commands.cpp: bindings for z3_replayer.cpp (log interpreter)
The python "macros": def_Type() and def_API() are used to add new types and function definitions to the Z3 API.
The .h files listed at update_api.py contain these definitions.
See lib\z3_api.py for many examples.
To generate bindings and the API logging infrastructure, the following command must be used:
python update_api.py