diff --git a/scripts/update_api.py b/scripts/update_api.py index b43c07ea5..3caca21ab 100644 --- a/scripts/update_api.py +++ b/scripts/update_api.py @@ -252,11 +252,11 @@ def param2java(p): k = param_kind(p) if k == OUT: if param_type(p) == INT or param_type(p) == UINT: - return "IntPtr" + return "Integer" elif param_type(p) == INT64 or param_type(p) == UINT64 or param_type(p) >= FIRST_OBJ_ID: - return "LongPtr" + return "Long" elif param_type(p) == STRING: - return "StringPtr" + return "String" else: print "ERROR: unreachable code" assert(False) @@ -496,14 +496,17 @@ def mk_java(): if not is_java_enabled(): return java_dir = get_component('java').src_dir - java_nativef = '%s/Z3Native.java' % java_dir - java_wrapperf = '%s/Z3Native.c' % java_dir + try: + os.mkdir('%s/com/Microsoft/Z3/' % java_dir) + except: + pass # OK if it exists already. + java_nativef = '%s/com/Microsoft/Z3/Native.java' % java_dir + java_wrapperf = '%s/com/Microsoft/Z3/Native.c' % java_dir java_native = open(java_nativef, 'w') java_native.write('// Automatically generated file\n') - java_native.write('public final class Z3Native {\n') - java_native.write(' public static class IntPtr { public int value; }\n') - java_native.write(' public static class LongPtr { public long value; }\n') - java_native.write(' public static class StringPtr { public String value; }\n') + java_native.write('package com.Microsoft.Z3;\n') + java_native.write('public final class Native {\n') + if is_windows(): java_native.write(' static { System.loadLibrary("%s"); }\n' % get_component('java')) else: @@ -521,9 +524,9 @@ def mk_java(): i = i + 1 java_native.write(');\n') java_native.write(' public static void main(String[] args) {\n') - java_native.write(' IntPtr major = new IntPtr(), minor = new IntPtr(), build = new IntPtr(), revision = new IntPtr();\n') + java_native.write(' Integer major = 0, minor = 0, build = 0, revision = 0;\n') java_native.write(' getVersion(major, minor, build, revision);\n') - java_native.write(' System.out.format("Z3 (for Java) %d.%d.%d%n", major.value, minor.value, build.value);\n') + java_native.write(' System.out.format("Z3 (for Java) %d.%d.%d%n", major, minor, build);\n') java_native.write(' }\n') java_native.write('}\n'); java_wrapper = open(java_wrapperf, 'w') diff --git a/src/api/java/com/Microsoft/Z3/AST.java b/src/api/java/com/Microsoft/Z3/AST.java new file mode 100644 index 000000000..9cd3286a2 --- /dev/null +++ b/src/api/java/com/Microsoft/Z3/AST.java @@ -0,0 +1,209 @@ +/** + * This file was automatically generated from AST.cs + **/ + +package com.Microsoft.Z3; + +/* using System; */ +/* using System.Collections; */ +/* using System.Collections.Generic; */ + + /** + * The abstract syntax tree (AST) class. + **/ + public class AST extends Z3Object + { + /** + * Comparison operator. + * An AST + * An AST + * @return True if and are from the same context + * and represent the same sort; false otherwise. + **/ + /* Overloaded operators are not translated. */ + + /** + * Comparison operator. + * An AST + * An AST + * @return True if and are not from the same context + * or represent different sorts; false otherwise. + **/ + /* Overloaded operators are not translated. */ + + /** + * Object comparison. + **/ + public boolean Equals(object o) + { + AST casted = (AST) o; + if (casted == null) return false; + return this == casted; + } + + /** + * Object Comparison. + * Another AST + * @return Negative if the object should be sorted before , positive if after else zero. + **/ + public int CompareTo(object other) + { + if (other == null) return 1; + AST oAST = (AST) other; + if (oAST == null) + return 1; + else + { + if (Id < oAST.Id) + return -1; + else if (Id > oAST.Id) + return +1; + else + return 0; + } + } + + /** + * The AST's hash code. + * @return A hash code + **/ + public int GetHashCode() + { + return (int)Native.getAstHash(Context.nCtx, NativeObject); + } + + /** + * A unique identifier for the AST (unique among all ASTs). + **/ + public Integer Id() { return Native.getAstId(Context.nCtx, NativeObject); } + + /** + * Translates (copies) the AST to the Context . + * A context + * @return A copy of the AST which is associated with + **/ + public AST Translate(Context ctx) + { + + + + if (ReferenceEquals(Context, ctx)) + return this; + else + return new AST(ctx, Native.translate(Context.nCtx, NativeObject, ctx.nCtx)); + } + + /** + * The kind of the AST. + **/ + public Z3_ast_kind ASTKind() { return (Z3AstKind)Native.getAstKind(Context.nCtx, NativeObject); } + + /** + * Indicates whether the AST is an Expr + **/ + public boolean IsExpr() + { + switch (ASTKind) + { + case Z3AstKind.Z3APPAST: + case Z3AstKind.Z3NUMERALAST: + case Z3AstKind.Z3QUANTIFIERAST: + case Z3AstKind.Z3VARAST: return true; + default: return false; + } + } + + /** + * Indicates whether the AST is a BoundVariable + **/ + public boolean IsVar() { return this.ASTKind == Z3AstKind.Z3VARAST; } + + /** + * Indicates whether the AST is a Quantifier + **/ + public boolean IsQuantifier() { return this.ASTKind == Z3AstKind.Z3QUANTIFIERAST; } + + /** + * Indicates whether the AST is a Sort + **/ + public boolean IsSort() { return this.ASTKind == Z3AstKind.Z3SORTAST; } + + /** + * Indicates whether the AST is a FunctionDeclaration + **/ + public boolean IsFuncDecl() { return this.ASTKind == Z3AstKind.Z3FUNCDECLAST; } + + /** + * A string representation of the AST. + **/ + public String toString() + { + return Native.asttoString(Context.nCtx, NativeObject); + } + + /** + * A string representation of the AST in s-expression notation. + **/ + public String SExpr() + { + + + return Native.asttoString(Context.nCtx, NativeObject); + } + + AST(Context ctx) { super(ctx); } + AST(Context ctx, IntPtr obj) { super(ctx, obj); } + + class DecRefQueue extends Z3.DecRefQueue + { + public void IncRef(Context ctx, IntPtr obj) + { + Native.incRef(ctx.nCtx, obj); + } + + public void DecRef(Context ctx, IntPtr obj) + { + Native.decRef(ctx.nCtx, obj); + } + }; + + void IncRef(IntPtr o) + { + // Console.WriteLine("AST IncRef()"); + if (Context == null) + throw new Z3Exception("inc() called on null context"); + if (o == IntPtr.Zero) + throw new Z3Exception("inc() called on null AST"); + Context.ASTDRQ.IncAndClear(Context, o); + super.IncRef(o); + } + + void DecRef(IntPtr o) + { + // Console.WriteLine("AST DecRef()"); + if (Context == null) + throw new Z3Exception("dec() called on null context"); + if (o == IntPtr.Zero) + throw new Z3Exception("dec() called on null AST"); + Context.ASTDRQ.Add(o); + super.DecRef(o); + } + + static AST Create(Context ctx, IntPtr obj) + { + + + + switch ((Z3AstKind)Native.getAstKind(ctx.nCtx, obj)) + { + case Z3AstKind.Z3FUNCDECLAST: return new FuncDecl(ctx, obj); + case Z3AstKind.Z3QUANTIFIERAST: return new Quantifier(ctx, obj); + case Z3AstKind.Z3SORTAST: return Sort.Create(ctx, obj); + case Z3AstKind.Z3APPAST: + case Z3AstKind.Z3NUMERALAST: + case Z3AstKind.Z3VARAST: return Expr.Create(ctx, obj); + default: + throw new Z3Exception("Unknown AST kind"); + } + } + } diff --git a/src/api/java/com/Microsoft/Z3/ASTMap.java b/src/api/java/com/Microsoft/Z3/ASTMap.java new file mode 100644 index 000000000..55a100a7b --- /dev/null +++ b/src/api/java/com/Microsoft/Z3/ASTMap.java @@ -0,0 +1,127 @@ +/** + * This file was automatically generated from ASTMap.cs + **/ + +package com.Microsoft.Z3; + +/* using System; */ + + /** + * Map from AST to AST + **/ + class ASTMap extends Z3Object + { + /** + * Checks whether the map contains the key . + * An AST + * @return True if is a key in the map, false otherwise. + **/ + public boolean Contains(AST k) + { + + + return Native.astMapContains(Context.nCtx, NativeObject, k.NativeObject) != 0; + } + + /** + * Finds the value associated with the key . + * + * This function signs an error when is not a key in the map. + * + * An AST + **/ + public AST Find(AST k) + { + + + + return new AST(Context, Native.astMapFind(Context.nCtx, NativeObject, k.NativeObject)); + } + + /** + * Stores or replaces a new key/value pair in the map. + * The key AST + * The value AST + **/ + public void Insert(AST k, AST v) + { + + + + Native.astMapInsert(Context.nCtx, NativeObject, k.NativeObject, v.NativeObject); + } + + /** + * Erases the key from the map. + * An AST + **/ + public void Erase(AST k) + { + + + Native.astMapErase(Context.nCtx, NativeObject, k.NativeObject); + } + + /** + * Removes all keys from the map. + **/ + public void Reset() + { + Native.astMapReset(Context.nCtx, NativeObject); + } + + /** + * The size of the map + **/ + public Integer Size() { return Native.astMapSize(Context.nCtx, NativeObject); } + + /** + * The keys stored in the map. + **/ + public ASTVector Keys() + { + return new ASTVector(Context, Native.astMapKeys(Context.nCtx, NativeObject)); + } + + /** + * Retrieves a string representation of the map. + **/ + public String toString() + { + return Native.astMaptoString(Context.nCtx, NativeObject); + } + + ASTMap(Context ctx, IntPtr obj) + { super(ctx, obj); + + } + ASTMap(Context ctx) + { super(ctx, Native.mkAstMap(ctx.nCtx)); + + } + + class DecRefQueue extends Z3.DecRefQueue + { + public void IncRef(Context ctx, IntPtr obj) + { + Native.astMapIncRef(ctx.nCtx, obj); + } + + public void DecRef(Context ctx, IntPtr obj) + { + Native.astMapDecRef(ctx.nCtx, obj); + } + }; + + void IncRef(IntPtr o) + { + Context.ASTMapDRQ.IncAndClear(Context, o); + super.IncRef(o); + } + + void DecRef(IntPtr o) + { + Context.ASTMapDRQ.Add(o); + super.DecRef(o); + } + } diff --git a/src/api/java/com/Microsoft/Z3/ASTVector.java b/src/api/java/com/Microsoft/Z3/ASTVector.java new file mode 100644 index 000000000..c57635289 --- /dev/null +++ b/src/api/java/com/Microsoft/Z3/ASTVector.java @@ -0,0 +1,107 @@ +/** + * This file was automatically generated from ASTVector.cs + **/ + +package com.Microsoft.Z3; + +/* using System; */ + + /** + * Vectors of ASTs. + **/ + class ASTVector extends Z3Object + { + /** + * The size of the vector + **/ + public Integer Size() { return Native.astVectorSize(Context.nCtx, NativeObject); } + + /** + * Retrieves the i-th object in the vector. + * May throw an IndexOutOfBoundsException when is out of range. + * Index + * @return An AST + **/ + public AST this[Integer i]() + { + + + return new AST(Context, Native.astVectorGet(Context.nCtx, NativeObject, i)); + set + { + + + Native.astVectorSet(Context.nCtx, NativeObject, i, value.NativeObject); + } + } + + /** + * Resize the vector to . + * The new size of the vector. + **/ + public void Resize(Integer newSize) + { + Native.astVectorResize(Context.nCtx, NativeObject, newSize); + } + + /** + * Add the AST to the back of the vector. The size + * is increased by 1. + * An AST + **/ + public void Push(AST a) + { + + + Native.astVectorPush(Context.nCtx, NativeObject, a.NativeObject); + } + + /** + * Translates all ASTs in the vector to . + * A context + * @return A new ASTVector + **/ + public ASTVector Translate(Context ctx) + { + + + + return new ASTVector(Context, Native.astVectorTranslate(Context.nCtx, NativeObject, ctx.nCtx)); + } + + /** + * Retrieves a string representation of the vector. + **/ + public String toString() + { + return Native.astVectortoString(Context.nCtx, NativeObject); + } + + ASTVector(Context ctx, IntPtr obj) { super(ctx, obj); } + ASTVector(Context ctx) { super(ctx, Native.mkAstVector(ctx.nCtx)); } + + class DecRefQueue extends Z3.DecRefQueue + { + public void IncRef(Context ctx, IntPtr obj) + { + Native.astVectorIncRef(ctx.nCtx, obj); + } + + public void DecRef(Context ctx, IntPtr obj) + { + Native.astVectorDecRef(ctx.nCtx, obj); + } + }; + + void IncRef(IntPtr o) + { + Context.ASTVectorDRQ.IncAndClear(Context, o); + super.IncRef(o); + } + + void DecRef(IntPtr o) + { + Context.ASTVectorDRQ.Add(o); + super.DecRef(o); + } + } diff --git a/src/api/java/com/Microsoft/Z3/ApplyResult.java b/src/api/java/com/Microsoft/Z3/ApplyResult.java new file mode 100644 index 000000000..7e5390237 --- /dev/null +++ b/src/api/java/com/Microsoft/Z3/ApplyResult.java @@ -0,0 +1,84 @@ +/** + * This file was automatically generated from ApplyResult.cs + **/ + +package com.Microsoft.Z3; + +/* using System; */ + + /** + * ApplyResult objects represent the result of an application of a + * tactic to a goal. It contains the subgoals that were produced. + **/ + public class ApplyResult extends Z3Object + { + /** + * The number of Subgoals. + **/ + public Integer NumSubgoals() { return Native.applyResultGetNumSubgoals(Context.nCtx, NativeObject); } + + /** + * Retrieves the subgoals from the ApplyResult. + **/ + public Goal[] Subgoals() + { + + + + Integer n = NumSubgoals; + Goal[] res = new Goal[n]; + for (Integer i = 0; i < n; i++) + res[i] = new Goal(Context, Native.applyResultGetSubgoal(Context.nCtx, NativeObject, i)); + return res; + } + + /** + * Convert a model for the subgoal into a model for the original + * goal g, that the ApplyResult was obtained from. + * @return A model for g + **/ + public Model ConvertModel(Integer i, Model m) + { + + + + return new Model(Context, Native.applyResultConvertModel(Context.nCtx, NativeObject, i, m.NativeObject)); + } + + /** + * A string representation of the ApplyResult. + **/ + public String toString() + { + return Native.applyResulttoString(Context.nCtx, NativeObject); + } + + ApplyResult(Context ctx, IntPtr obj) { super(ctx, obj); + + } + + class DecRefQueue extends Z3.DecRefQueue + { + public void IncRef(Context ctx, IntPtr obj) + { + Native.applyResultIncRef(ctx.nCtx, obj); + } + + public void DecRef(Context ctx, IntPtr obj) + { + Native.applyResultDecRef(ctx.nCtx, obj); + } + }; + + void IncRef(IntPtr o) + { + Context.ApplyResultDRQ.IncAndClear(Context, o); + super.IncRef(o); + } + + void DecRef(IntPtr o) + { + Context.ApplyResultDRQ.Add(o); + super.DecRef(o); + } + } diff --git a/src/api/java/com/Microsoft/Z3/Constructor.java b/src/api/java/com/Microsoft/Z3/Constructor.java new file mode 100644 index 000000000..2f9a2009e --- /dev/null +++ b/src/api/java/com/Microsoft/Z3/Constructor.java @@ -0,0 +1,130 @@ +/** + * This file was automatically generated from Constructor.cs + **/ + +package com.Microsoft.Z3; + +/* using System; */ + + /** + * Constructors are used for datatype sorts. + **/ + public class Constructor extends Z3Object + { + /** + * The number of fields of the constructor. + **/ + public Integer NumFields() { init(); return n; } + + /** + * The function declaration of the constructor. + **/ + public FuncDecl ConstructorDecl() { + + init(); return mConstructorDecl; } + + /** + * The function declaration of the tester. + **/ + public FuncDecl TesterDecl() { + + init(); return mTesterDecl; } + + /** + * The function declarations of the accessors + **/ + public FuncDecl[] AccessorDecls() { + + init(); return mAccessorDecls; } + + /** + * Destructor. + **/ + protected void finalize() + { + Native.delConstructor(Context.nCtx, NativeObject); + } + + + private void ObjectInvariant() + { + + + } + + + private Integer n = 0; + private FuncDecl mTesterDecl = null; + private FuncDecl mConstructorDecl = null; + private FuncDecl[] mAccessorDecls = null; + + Constructor(Context ctx, Symbol name, Symbol recognizer, Symbol[] fieldNames, + Sort[] sorts, Integer[] sortRefs) + { super(ctx); + + + + + n = AST.ArrayLength(fieldNames); + + if (n != AST.ArrayLength(sorts)) + throw new Z3Exception("Number of field names does not match number of sorts"); + if (sortRefs != null && sortRefs.Length != n) + throw new Z3Exception("Number of field names does not match number of sort refs"); + + if (sortRefs == null) sortRefs = new Integer[n]; + + NativeObject = Native.mkConstructor(ctx.nCtx, name.NativeObject, recognizer.NativeObject, + n, + Symbol.ArrayToNative(fieldNames), + Sort.ArrayToNative(sorts), + sortRefs); + + } + + private void init() + { + + + + + if (mTesterDecl != null) return; + IntPtr constructor = IntPtr.Zero; + IntPtr tester = IntPtr.Zero; + IntPtr[] accessors = new IntPtr[n]; + Native.queryConstructor(Context.nCtx, NativeObject, n, constructor, tester, accessors); + mConstructorDecl = new FuncDecl(Context, constructor); + mTesterDecl = new FuncDecl(Context, tester); + mAccessorDecls = new FuncDecl[n]; + for (Integer i = 0; i < n; i++) + mAccessorDecls[i] = new FuncDecl(Context, accessors[i]); + } + + } + + /** + * Lists of constructors + **/ + public class ConstructorList extends Z3Object + { + /** + * Destructor. + **/ + protected void finalize() + { + Native.delConstructorList(Context.nCtx, NativeObject); + } + + ConstructorList(Context ctx, IntPtr obj) + { super(ctx, obj); + + } + + ConstructorList(Context ctx, Constructor[] constructors) + { super(ctx); + + + + NativeObject = Native.mkConstructorList(Context.nCtx, (Integer)constructors.Length, Constructor.ArrayToNative(constructors)); + } + } diff --git a/src/api/java/com/Microsoft/Z3/Context.java b/src/api/java/com/Microsoft/Z3/Context.java new file mode 100644 index 000000000..471c82120 --- /dev/null +++ b/src/api/java/com/Microsoft/Z3/Context.java @@ -0,0 +1,3534 @@ +/** + * This file was automatically generated from Context.cs + **/ + +package com.Microsoft.Z3; + +/* using System; */ +/* using System.Collections.Generic; */ +/* using System.Runtime.InteropServices; */ + + /** + * The main interaction with Z3 happens via the Context. + **/ + public class Context extends IDisposable + { + /** + * Constructor. + **/ + public Context() + { super(); + mCtx = Native.mkContextRc(IntPtr.Zero); + InitContext(); + } + + /** + * Constructor. + **/ + public Context(Dictionary settings) + { super(); + + + IntPtr cfg = Native.mkConfig(); + for (KeyValuePair.Iterator kv = settings.iterator(); kv.hasNext(); ) + Native.setParamValue(cfg, kv.Key, kv.Value); + mCtx = Native.mkContextRc(cfg); + Native.delConfig(cfg); + InitContext(); + } + + /** + * Creates a new symbol using an integer. + * + * Not all integers can be passed to this function. + * The legal range of unsigned integers is 0 to 2^30-1. + * + **/ + public IntSymbol MkSymbol(int i) + { + + + return new IntSymbol(this, i); + } + + /** + * Create a symbol using a string. + **/ + public StringSymbol MkSymbol(String name) + { + + + return new StringSymbol(this, name); + } + + /** + * Create an array of symbols. + **/ + Symbol[] MkSymbols(String[] names) + { + + + + + + if (names == null) return null; + Symbol[] result = new Symbol[names.Length]; + for (int i = 0; i < names.Length; ++i) result[i] = MkSymbol(names[i]); + return result; + } + + private BoolSort mBooleanSort = null; + private IntSort mIntSort = null; + private RealSort mRealSort = null; + + /** + * Retrieves the Boolean sort of the context. + **/ + public BoolSort BoolSort() + { + + + if (mBooleanSort == null) mBooleanSort = new BoolSort(this); return mBooleanSort; + } + + /** + * Retrieves the Integer sort of the context. + **/ + public IntSort IntSort() + { + + if (mIntSort == null) mIntSort = new IntSort(this); return mIntSort; + } + + + /** + * Retrieves the Real sort of the context. + **/ + /* Overloaded operators are not translated. */ + + /** + * Create a new uninterpreted sort. + **/ + public UninterpretedSort MkUninterpretedSort(Symbol s) + { + + + + CheckContextMatch(s); + return new UninterpretedSort(this, s); + } + + /** + * Create a new uninterpreted sort. + **/ + public UninterpretedSort MkUninterpretedSort(String str) + { + + + return MkUninterpretedSort(MkSymbol(str)); + } + + /** + * Create a new integer sort. + **/ + public IntSort MkIntSort() + { + + + return new IntSort(this); + } + + /** + * Create a real sort. + **/ + public RealSort MkRealSort() + { + + return new RealSort(this); + } + + /** + * Create a new bit-vector sort. + **/ + public BitVecSort MkBitVecSort(Integer size) + { + + + return new BitVecSort(this, size); + } + + /** + * Create a new array sort. + **/ + public ArraySort MkArraySort(Sort domain, Sort range) + { + + + + + CheckContextMatch(domain); + CheckContextMatch(range); + return new ArraySort(this, domain, range); + } + + /** + * Create a new tuple sort. + **/ + public TupleSort MkTupleSort(Symbol name, Symbol[] fieldNames, Sort[] fieldSorts) + { + + + + + + + CheckContextMatch(name); + CheckContextMatch(fieldNames); + CheckContextMatch(fieldSorts); + return new TupleSort(this, name, (Integer)fieldNames.Length, fieldNames, fieldSorts); + } + + /** + * Create a new enumeration sort. + **/ + public EnumSort MkEnumSort(Symbol name, Symbol[] enumNames) + { + + + + + + + CheckContextMatch(name); + CheckContextMatch(enumNames); + return new EnumSort(this, name, enumNames); + } + + /** + * Create a new enumeration sort. + **/ + public EnumSort MkEnumSort(String name, String[] enumNames) + { + + + + return new EnumSort(this, MkSymbol(name), MkSymbols(enumNames)); + } + + /** + * Create a new list sort. + **/ + public ListSort MkListSort(Symbol name, Sort elemSort) + { + + + + + CheckContextMatch(name); + CheckContextMatch(elemSort); + return new ListSort(this, name, elemSort); + } + + /** + * Create a new list sort. + **/ + public ListSort MkListSort(String name, Sort elemSort) + { + + + + CheckContextMatch(elemSort); + return new ListSort(this, MkSymbol(name), elemSort); + } + + /** + * Create a new finite domain sort. + **/ + public FiniteDomainSort MkFiniteDomainSort(Symbol name, ulong size) + { + + + + CheckContextMatch(name); + return new FiniteDomainSort(this, name, size); + } + + /** + * Create a new finite domain sort. + **/ + public FiniteDomainSort MkFiniteDomainSort(String name, ulong size) + { + + + return new FiniteDomainSort(this, MkSymbol(name), size); + } + + + /** + * Create a datatype constructor. + * constructor name + * name of recognizer function. + * names of the constructor fields. + * field sorts, 0 if the field sort refers to a recursive sort. + * reference to datatype sort that is an argument to the constructor; + * if the corresponding sort reference is 0, then the value in sort_refs should be an index + * referring to one of the recursive datatypes that is declared. + **/ + public Constructor MkConstructor(Symbol name, Symbol recognizer, Symbol[] fieldNames, Sort[] sorts, Integer[] sortRefs) + { + + + + + return new Constructor(this, name, recognizer, fieldNames, sorts, sortRefs); + } + + /** + * Create a datatype constructor. + * + * + * + * + * + * @return + **/ + public Constructor MkConstructor(String name, String recognizer, String[] fieldNames, Sort[] sorts, Integer[] sortRefs) + { + + + return new Constructor(this, MkSymbol(name), MkSymbol(recognizer), MkSymbols(fieldNames), sorts, sortRefs); + } + + /** + * Create a new datatype sort. + **/ + public DatatypeSort MkDatatypeSort(Symbol name, Constructor[] constructors) + { + + + + + + + CheckContextMatch(name); + CheckContextMatch(constructors); + return new DatatypeSort(this, name, constructors); + } + + /** + * Create a new datatype sort. + **/ + public DatatypeSort MkDatatypeSort(String name, Constructor[] constructors) + { + + + + + CheckContextMatch(constructors); + return new DatatypeSort(this, MkSymbol(name), constructors); + } + + /** + * Create mutually recursive datatypes. + * names of datatype sorts + * list of constructors, one list per sort. + **/ + public DatatypeSort[] MkDatatypeSorts(Symbol[] names, Constructor[][] c) + { + + + + + + + + CheckContextMatch(names); + Integer n = (Integer)names.Length; + ConstructorList[] cla = new ConstructorList[n]; + IntPtr[] nConstr = new IntPtr[n]; + for (Integer i = 0; i < n; i++) + { + var constructor = c[i]; + + CheckContextMatch(constructor); + cla[i] = new ConstructorList(this, constructor); + nConstr[i] = cla[i].NativeObject; + } + IntPtr[] nRes = new IntPtr[n]; + Native.mkDatatypes(nCtx, n, Symbol.ArrayToNative(names), nRes, nConstr); + DatatypeSort[] res = new DatatypeSort[n]; + for (Integer i = 0; i < n; i++) + res[i] = new DatatypeSort(this, nRes[i]); + return res; + } + + /** + * Create mutually recursive data-types. + * + * + * @return + **/ + public DatatypeSort[] MkDatatypeSorts(String[] names, Constructor[][] c) + { + + + + + + + + return MkDatatypeSorts(MkSymbols(names), c); + } + + + /** + * Creates a new function declaration. + **/ + public FuncDecl MkFuncDecl(Symbol name, Sort[] domain, Sort range) + { + + + + + + CheckContextMatch(name); + CheckContextMatch(domain); + CheckContextMatch(range); + return new FuncDecl(this, name, domain, range); + } + + /** + * Creates a new function declaration. + **/ + public FuncDecl MkFuncDecl(Symbol name, Sort domain, Sort range) + { + + + + + + CheckContextMatch(name); + CheckContextMatch(domain); + CheckContextMatch(range); + Sort[] q = new Sort[] { domain }; + return new FuncDecl(this, name, q, range); + } + + /** + * Creates a new function declaration. + **/ + public FuncDecl MkFuncDecl(String name, Sort[] domain, Sort range) + { + + + + + CheckContextMatch(domain); + CheckContextMatch(range); + return new FuncDecl(this, MkSymbol(name), domain, range); + } + + /** + * Creates a new function declaration. + **/ + public FuncDecl MkFuncDecl(String name, Sort domain, Sort range) + { + + + + + CheckContextMatch(domain); + CheckContextMatch(range); + Sort[] q = new Sort[] { domain }; + return new FuncDecl(this, MkSymbol(name), q, range); + } + + /** + * Creates a fresh function declaration with a name prefixed with . + * + * + **/ + public FuncDecl MkFreshFuncDecl(String prefix, Sort[] domain, Sort range) + { + + + + + CheckContextMatch(domain); + CheckContextMatch(range); + return new FuncDecl(this, prefix, domain, range); + } + + /** + * Creates a new constant function declaration. + **/ + public FuncDecl MkConstDecl(Symbol name, Sort range) + { + + + + + CheckContextMatch(name); + CheckContextMatch(range); + return new FuncDecl(this, name, null, range); + } + + /** + * Creates a new constant function declaration. + **/ + public FuncDecl MkConstDecl(String name, Sort range) + { + + + + CheckContextMatch(range); + return new FuncDecl(this, MkSymbol(name), null, range); + } + + /** + * Creates a fresh constant function declaration with a name prefixed with . + * + * + **/ + public FuncDecl MkFreshConstDecl(String prefix, Sort range) + { + + + + CheckContextMatch(range); + return new FuncDecl(this, prefix, null, range); + } + + /** + * Creates a new bound variable. + * The de-Bruijn index of the variable + * The sort of the variable + **/ + public Expr MkBound(Integer index, Sort ty) + { + + + + return Expr.Create(this, Native.mkBound(nCtx, index, ty.NativeObject)); + } + + /** + * Create a quantifier pattern. + **/ + public Pattern MkPattern(Expr[] terms) + { + + if (terms.Length == 0) + throw new Z3Exception("Cannot create a pattern from zero terms"); + + + + + + IntPtr[] termsNative = AST.ArrayToNative(terms); + return new Pattern(this, Native.mkPattern(nCtx, (Integer)terms.Length, termsNative)); + } + + /** + * Creates a new Constant of sort and named . + **/ + public Expr MkConst(Symbol name, Sort range) + { + + + + + CheckContextMatch(name); + CheckContextMatch(range); + + return Expr.Create(this, Native.mkConst(nCtx, name.NativeObject, range.NativeObject)); + } + + /** + * Creates a new Constant of sort and named . + **/ + public Expr MkConst(String name, Sort range) + { + + + + return MkConst(MkSymbol(name), range); + } + + /** + * Creates a fresh Constant of sort and a + * name prefixed with . + **/ + public Expr MkFreshConst(String prefix, Sort range) + { + + + + CheckContextMatch(range); + return Expr.Create(this, Native.mkFreshConst(nCtx, prefix, range.NativeObject)); + } + + /** + * Creates a fresh constant from the FuncDecl . + * A decl of a 0-arity function + **/ + public Expr MkConst(FuncDecl f) + { + + + + return MkApp(f); + } + + /** + * Create a Boolean constant. + **/ + public BoolExpr MkBoolConst(Symbol name) + { + + + + return (BoolExpr)MkConst(name, BoolSort); + } + + /** + * Create a Boolean constant. + **/ + public BoolExpr MkBoolConst(String name) + { + + + return (BoolExpr)MkConst(MkSymbol(name), BoolSort); + } + + /** + * Creates an integer constant. + **/ + public IntExpr MkIntConst(Symbol name) + { + + + + return (IntExpr)MkConst(name, IntSort); + } + + /** + * Creates an integer constant. + **/ + public IntExpr MkIntConst(String name) + { + + + + return (IntExpr)MkConst(name, IntSort); + } + + /** + * Creates a real constant. + **/ + public RealExpr MkRealConst(Symbol name) + { + + + + return (RealExpr)MkConst(name, RealSort); + } + + /** + * Creates a real constant. + **/ + public RealExpr MkRealConst(String name) + { + + + return (RealExpr)MkConst(name, RealSort); + } + + /** + * Creates a bit-vector constant. + **/ + public BitVecExpr MkBVConst(Symbol name, Integer size) + { + + + + return (BitVecExpr)MkConst(name, MkBitVecSort(size)); + } + + /** + * Creates a bit-vector constant. + **/ + public BitVecExpr MkBVConst(String name, Integer size) + { + + + return (BitVecExpr)MkConst(name, MkBitVecSort(size)); + } + + /** + * Create a new function application. + **/ + public Expr MkApp(FuncDecl f, Expr[] args) + { + + + + + CheckContextMatch(f); + CheckContextMatch(args); + return Expr.Create(this, f, args); + } + + /** + * The true Term. + **/ + public BoolExpr MkTrue() + { + + + return new BoolExpr(this, Native.mkTrue(nCtx)); + } + + /** + * The false Term. + **/ + public BoolExpr MkFalse() + { + + + return new BoolExpr(this, Native.mkFalse(nCtx)); + } + + /** + * Creates a Boolean value. + **/ + public BoolExpr MkBool(boolean value) + { + + + return value ? MkTrue() : MkFalse(); + } + + /** + * Creates the equality = . + **/ + public BoolExpr MkEq(Expr x, Expr y) + { + + + + + CheckContextMatch(x); + CheckContextMatch(y); + return new BoolExpr(this, Native.mkEq(nCtx, x.NativeObject, y.NativeObject)); + } + + /** + * Creates a distinct term. + **/ + public BoolExpr MkDistinct(Expr[] args) + { + + + + + + CheckContextMatch(args); + return new BoolExpr(this, Native.mkDistinct(nCtx, (Integer)args.Length, AST.ArrayToNative(args))); + } + + /** + * Mk an expression representing not(a). + **/ + public BoolExpr MkNot(BoolExpr a) + { + + + + CheckContextMatch(a); + return new BoolExpr(this, Native.mkNot(nCtx, a.NativeObject)); + } + + /** + * Create an expression representing an if-then-else: ite(t1, t2, t3). + * An expression with Boolean sort + * An expression + * An expression with the same sort as + **/ + public Expr MkITE(BoolExpr t1, Expr t2, Expr t3) + { + + + + + + CheckContextMatch(t1); + CheckContextMatch(t2); + CheckContextMatch(t3); + return Expr.Create(this, Native.mkIte(nCtx, t1.NativeObject, t2.NativeObject, t3.NativeObject)); + } + + /** + * Create an expression representing t1 iff t2. + **/ + public BoolExpr MkIff(BoolExpr t1, BoolExpr t2) + { + + + + + CheckContextMatch(t1); + CheckContextMatch(t2); + return new BoolExpr(this, Native.mkIff(nCtx, t1.NativeObject, t2.NativeObject)); + } + + /** + * Create an expression representing t1 -> t2. + **/ + public BoolExpr MkImplies(BoolExpr t1, BoolExpr t2) + { + + + + + CheckContextMatch(t1); + CheckContextMatch(t2); + return new BoolExpr(this, Native.mkImplies(nCtx, t1.NativeObject, t2.NativeObject)); + } + + /** + * Create an expression representing t1 xor t2. + **/ + public BoolExpr MkXor(BoolExpr t1, BoolExpr t2) + { + + + + + CheckContextMatch(t1); + CheckContextMatch(t2); + return new BoolExpr(this, Native.mkXor(nCtx, t1.NativeObject, t2.NativeObject)); + } + + /** + * Create an expression representing t[0] and t[1] and .... + **/ + public BoolExpr MkAnd(BoolExpr[] t) + { + + + + + CheckContextMatch(t); + return new BoolExpr(this, Native.mkAnd(nCtx, (Integer)t.Length, AST.ArrayToNative(t))); + } + + /** + * Create an expression representing t[0] or t[1] or .... + **/ + public BoolExpr MkOr(BoolExpr[] t) + { + + + + + CheckContextMatch(t); + return new BoolExpr(this, Native.mkOr(nCtx, (Integer)t.Length, AST.ArrayToNative(t))); + } + + /** + * Create an expression representing t[0] + t[1] + .... + **/ + public ArithExpr MkAdd(ArithExpr[] t) + { + + + + + CheckContextMatch(t); + return (ArithExpr)Expr.Create(this, Native.mkAdd(nCtx, (Integer)t.Length, AST.ArrayToNative(t))); + } + + /** + * Create an expression representing t[0] * t[1] * .... + **/ + public ArithExpr MkMul(ArithExpr[] t) + { + + + + + CheckContextMatch(t); + return (ArithExpr)Expr.Create(this, Native.mkMul(nCtx, (Integer)t.Length, AST.ArrayToNative(t))); + } + + /** + * Create an expression representing t[0] - t[1] - .... + **/ + public ArithExpr MkSub(ArithExpr[] t) + { + + + + + CheckContextMatch(t); + return (ArithExpr)Expr.Create(this, Native.mkSub(nCtx, (Integer)t.Length, AST.ArrayToNative(t))); + } + + /** + * Create an expression representing -t. + **/ + public ArithExpr MkUnaryMinus(ArithExpr t) + { + + + + CheckContextMatch(t); + return (ArithExpr)Expr.Create(this, Native.mkUnaryMinus(nCtx, t.NativeObject)); + } + + /** + * Create an expression representing t1 / t2. + **/ + public ArithExpr MkDiv(ArithExpr t1, ArithExpr t2) + { + + + + + CheckContextMatch(t1); + CheckContextMatch(t2); + return (ArithExpr)Expr.Create(this, Native.mkDiv(nCtx, t1.NativeObject, t2.NativeObject)); + } + + /** + * Create an expression representing t1 mod t2. + * The arguments must have int type. + **/ + public IntExpr MkMod(IntExpr t1, IntExpr t2) + { + + + + + CheckContextMatch(t1); + CheckContextMatch(t2); + return new IntExpr(this, Native.mkMod(nCtx, t1.NativeObject, t2.NativeObject)); + } + + /** + * Create an expression representing t1 rem t2. + * The arguments must have int type. + **/ + public IntExpr MkRem(IntExpr t1, IntExpr t2) + { + + + + + CheckContextMatch(t1); + CheckContextMatch(t2); + return new IntExpr(this, Native.mkRem(nCtx, t1.NativeObject, t2.NativeObject)); + } + + /** + * Create an expression representing t1 ^ t2. + **/ + public ArithExpr MkPower(ArithExpr t1, ArithExpr t2) + { + + + + + CheckContextMatch(t1); + CheckContextMatch(t2); + return (ArithExpr)Expr.Create(this, Native.mkPower(nCtx, t1.NativeObject, t2.NativeObject)); + } + + /** + * Create an expression representing t1 < t2 + **/ + public BoolExpr MkLt(ArithExpr t1, ArithExpr t2) + { + + + + + CheckContextMatch(t1); + CheckContextMatch(t2); + return new BoolExpr(this, Native.mkLt(nCtx, t1.NativeObject, t2.NativeObject)); + } + + /** + * Create an expression representing t1 <= t2 + **/ + public BoolExpr MkLe(ArithExpr t1, ArithExpr t2) + { + + + + + CheckContextMatch(t1); + CheckContextMatch(t2); + return new BoolExpr(this, Native.mkLe(nCtx, t1.NativeObject, t2.NativeObject)); + } + + /** + * Create an expression representing t1 > t2 + **/ + public BoolExpr MkGt(ArithExpr t1, ArithExpr t2) + { + + + + + CheckContextMatch(t1); + CheckContextMatch(t2); + return new BoolExpr(this, Native.mkGt(nCtx, t1.NativeObject, t2.NativeObject)); + } + + /** + * Create an expression representing t1 >= t2 + **/ + public BoolExpr MkGe(ArithExpr t1, ArithExpr t2) + { + + + + + CheckContextMatch(t1); + CheckContextMatch(t2); + return new BoolExpr(this, Native.mkGe(nCtx, t1.NativeObject, t2.NativeObject)); + } + + /** + * Coerce an integer to a real. + * + * There is also a converse operation exposed. It follows the semantics prescribed by the SMT-LIB standard. + * + * You can take the floor of a real by creating an auxiliary integer Term k and + * and asserting MakeInt2Real(k) <= t1 < MkInt2Real(k)+1. + * The argument must be of integer sort. + * + **/ + public RealExpr MkInt2Real(IntExpr t) + { + + + + CheckContextMatch(t); + return new RealExpr(this, Native.mkInt2real(nCtx, t.NativeObject)); + } + + /** + * Coerce a real to an integer. + * + * The semantics of this function follows the SMT-LIB standard for the function to_int. + * The argument must be of real sort. + * + **/ + public IntExpr MkReal2Int(RealExpr t) + { + + + + CheckContextMatch(t); + return new IntExpr(this, Native.mkReal2int(nCtx, t.NativeObject)); + } + + /** + * Creates an expression that checks whether a real number is an integer. + **/ + public BoolExpr MkIsInteger(RealExpr t) + { + + + + CheckContextMatch(t); + return new BoolExpr(this, Native.mkIsInt(nCtx, t.NativeObject)); + } + + /** + * Bitwise negation. + * The argument must have a bit-vector sort. + **/ + public BitVecExpr MkBVNot(BitVecExpr t) + { + + + + CheckContextMatch(t); + return new BitVecExpr(this, Native.mkBvnot(nCtx, t.NativeObject)); + } + + /** + * Take conjunction of bits in a vector, return vector of length 1. + * The argument must have a bit-vector sort. + **/ + public BitVecExpr MkBVRedAND(BitVecExpr t) + { + + + + CheckContextMatch(t); + return new BitVecExpr(this, Native.mkBvredand(nCtx, t.NativeObject)); + } + + /** + * Take disjunction of bits in a vector, return vector of length 1. + * The argument must have a bit-vector sort. + **/ + public BitVecExpr MkBVRedOR(BitVecExpr t) + { + + + + CheckContextMatch(t); + return new BitVecExpr(this, Native.mkBvredor(nCtx, t.NativeObject)); + } + + /** + * Bitwise conjunction. + * The arguments must have a bit-vector sort. + **/ + public BitVecExpr MkBVAND(BitVecExpr t1, BitVecExpr t2) + { + + + + + CheckContextMatch(t1); + CheckContextMatch(t2); + return new BitVecExpr(this, Native.mkBvand(nCtx, t1.NativeObject, t2.NativeObject)); + } + + /** + * Bitwise disjunction. + * The arguments must have a bit-vector sort. + **/ + public BitVecExpr MkBVOR(BitVecExpr t1, BitVecExpr t2) + { + + + + + CheckContextMatch(t1); + CheckContextMatch(t2); + return new BitVecExpr(this, Native.mkBvor(nCtx, t1.NativeObject, t2.NativeObject)); + } + + /** + * Bitwise XOR. + * The arguments must have a bit-vector sort. + **/ + public BitVecExpr MkBVXOR(BitVecExpr t1, BitVecExpr t2) + { + + + + + CheckContextMatch(t1); + CheckContextMatch(t2); + return new BitVecExpr(this, Native.mkBvxor(nCtx, t1.NativeObject, t2.NativeObject)); + } + + /** + * Bitwise NAND. + * The arguments must have a bit-vector sort. + **/ + public BitVecExpr MkBVNAND(BitVecExpr t1, BitVecExpr t2) + { + + + + + CheckContextMatch(t1); + CheckContextMatch(t2); + return new BitVecExpr(this, Native.mkBvnand(nCtx, t1.NativeObject, t2.NativeObject)); + } + + /** + * Bitwise NOR. + * The arguments must have a bit-vector sort. + **/ + public BitVecExpr MkBVNOR(BitVecExpr t1, BitVecExpr t2) + { + + + + + CheckContextMatch(t1); + CheckContextMatch(t2); + return new BitVecExpr(this, Native.mkBvnor(nCtx, t1.NativeObject, t2.NativeObject)); + } + + /** + * Bitwise XNOR. + * The arguments must have a bit-vector sort. + **/ + public BitVecExpr MkBVXNOR(BitVecExpr t1, BitVecExpr t2) + { + + + + + CheckContextMatch(t1); + CheckContextMatch(t2); + return new BitVecExpr(this, Native.mkBvxnor(nCtx, t1.NativeObject, t2.NativeObject)); + } + + /** + * Standard two's complement unary minus. + * The arguments must have a bit-vector sort. + **/ + public BitVecExpr MkBVNeg(BitVecExpr t) + { + + + + CheckContextMatch(t); + return new BitVecExpr(this, Native.mkBvneg(nCtx, t.NativeObject)); + } + + /** + * Two's complement addition. + * The arguments must have the same bit-vector sort. + **/ + public BitVecExpr MkBVAdd(BitVecExpr t1, BitVecExpr t2) + { + + + + + CheckContextMatch(t1); + CheckContextMatch(t2); + return new BitVecExpr(this, Native.mkBvadd(nCtx, t1.NativeObject, t2.NativeObject)); + } + + /** + * Two's complement subtraction. + * The arguments must have the same bit-vector sort. + **/ + public BitVecExpr MkBVSub(BitVecExpr t1, BitVecExpr t2) + { + + + + + CheckContextMatch(t1); + CheckContextMatch(t2); + return new BitVecExpr(this, Native.mkBvsub(nCtx, t1.NativeObject, t2.NativeObject)); + } + + /** + * Two's complement multiplication. + * The arguments must have the same bit-vector sort. + **/ + public BitVecExpr MkBVMul(BitVecExpr t1, BitVecExpr t2) + { + + + + + CheckContextMatch(t1); + CheckContextMatch(t2); + return new BitVecExpr(this, Native.mkBvmul(nCtx, t1.NativeObject, t2.NativeObject)); + } + + /** + * Unsigned division. + * + * It is defined as the floor of t1/t2 if \c t2 is + * different from zero. If t2 is zero, then the result + * is undefined. + * The arguments must have the same bit-vector sort. + * + **/ + public BitVecExpr MkBVUDiv(BitVecExpr t1, BitVecExpr t2) + { + + + + + CheckContextMatch(t1); + CheckContextMatch(t2); + return new BitVecExpr(this, Native.mkBvudiv(nCtx, t1.NativeObject, t2.NativeObject)); + } + + /** + * Signed division. + * + * It is defined in the following way: + * + * - The \c floor of t1/t2 if \c t2 is different from zero, and t1*t2 >= 0. + * + * - The \c ceiling of t1/t2 if \c t2 is different from zero, and t1*t2 < 0. + * + * If t2 is zero, then the result is undefined. + * The arguments must have the same bit-vector sort. + * + **/ + public BitVecExpr MkBVSDiv(BitVecExpr t1, BitVecExpr t2) + { + + + + + CheckContextMatch(t1); + CheckContextMatch(t2); + return new BitVecExpr(this, Native.mkBvsdiv(nCtx, t1.NativeObject, t2.NativeObject)); + } + + /** + * Unsigned remainder. + * + * It is defined as t1 - (t1 /u t2) * t2, where /u represents unsigned division. + * If t2 is zero, then the result is undefined. + * The arguments must have the same bit-vector sort. + * + **/ + public BitVecExpr MkBVURem(BitVecExpr t1, BitVecExpr t2) + { + + + + + CheckContextMatch(t1); + CheckContextMatch(t2); + return new BitVecExpr(this, Native.mkBvurem(nCtx, t1.NativeObject, t2.NativeObject)); + } + + /** + * Signed remainder. + * + * It is defined as t1 - (t1 /s t2) * t2, where /s represents signed division. + * The most significant bit (sign) of the result is equal to the most significant bit of \c t1. + * + * If t2 is zero, then the result is undefined. + * The arguments must have the same bit-vector sort. + * + **/ + public BitVecExpr MkBVSRem(BitVecExpr t1, BitVecExpr t2) + { + + + + + CheckContextMatch(t1); + CheckContextMatch(t2); + return new BitVecExpr(this, Native.mkBvsrem(nCtx, t1.NativeObject, t2.NativeObject)); + } + + /** + * Two's complement signed remainder (sign follows divisor). + * + * If t2 is zero, then the result is undefined. + * The arguments must have the same bit-vector sort. + * + **/ + public BitVecExpr MkBVSMod(BitVecExpr t1, BitVecExpr t2) + { + + + + + CheckContextMatch(t1); + CheckContextMatch(t2); + return new BitVecExpr(this, Native.mkBvsmod(nCtx, t1.NativeObject, t2.NativeObject)); + } + + /** + * Unsigned less-than + * + * The arguments must have the same bit-vector sort. + * + **/ + public BoolExpr MkBVULT(BitVecExpr t1, BitVecExpr t2) + { + + + + + CheckContextMatch(t1); + CheckContextMatch(t2); + return new BoolExpr(this, Native.mkBvult(nCtx, t1.NativeObject, t2.NativeObject)); + } + + /** + * Two's complement signed less-than + * + * The arguments must have the same bit-vector sort. + * + **/ + public BoolExpr MkBVSLT(BitVecExpr t1, BitVecExpr t2) + { + + + + + CheckContextMatch(t1); + CheckContextMatch(t2); + return new BoolExpr(this, Native.mkBvslt(nCtx, t1.NativeObject, t2.NativeObject)); + } + + /** + * Unsigned less-than or equal to. + * + * The arguments must have the same bit-vector sort. + * + **/ + public BoolExpr MkBVULE(BitVecExpr t1, BitVecExpr t2) + { + + + + + CheckContextMatch(t1); + CheckContextMatch(t2); + return new BoolExpr(this, Native.mkBvule(nCtx, t1.NativeObject, t2.NativeObject)); + } + + /** + * Two's complement signed less-than or equal to. + * + * The arguments must have the same bit-vector sort. + * + **/ + public BoolExpr MkBVSLE(BitVecExpr t1, BitVecExpr t2) + { + + + + + CheckContextMatch(t1); + CheckContextMatch(t2); + return new BoolExpr(this, Native.mkBvsle(nCtx, t1.NativeObject, t2.NativeObject)); + } + + /** + * Unsigned greater than or equal to. + * + * The arguments must have the same bit-vector sort. + * + **/ + public BoolExpr MkBVUGE(BitVecExpr t1, BitVecExpr t2) + { + + + + + CheckContextMatch(t1); + CheckContextMatch(t2); + return new BoolExpr(this, Native.mkBvuge(nCtx, t1.NativeObject, t2.NativeObject)); + } + + /** + * Two's complement signed greater than or equal to. + * + * The arguments must have the same bit-vector sort. + * + **/ + public BoolExpr MkBVSGE(BitVecExpr t1, BitVecExpr t2) + { + + + + + CheckContextMatch(t1); + CheckContextMatch(t2); + return new BoolExpr(this, Native.mkBvsge(nCtx, t1.NativeObject, t2.NativeObject)); + } + + /** + * Unsigned greater-than. + * + * The arguments must have the same bit-vector sort. + * + **/ + public BoolExpr MkBVUGT(BitVecExpr t1, BitVecExpr t2) + { + + + + + CheckContextMatch(t1); + CheckContextMatch(t2); + return new BoolExpr(this, Native.mkBvugt(nCtx, t1.NativeObject, t2.NativeObject)); + } + + /** + * Two's complement signed greater-than. + * + * The arguments must have the same bit-vector sort. + * + **/ + public BoolExpr MkBVSGT(BitVecExpr t1, BitVecExpr t2) + { + + + + + CheckContextMatch(t1); + CheckContextMatch(t2); + return new BoolExpr(this, Native.mkBvsgt(nCtx, t1.NativeObject, t2.NativeObject)); + } + + /** + * Bit-vector concatenation. + * + * The arguments must have a bit-vector sort. + * + * @return + * The result is a bit-vector of size n1+n2, where n1 (n2) + * is the size of t1 (t2). + * + **/ + public BitVecExpr MkConcat(BitVecExpr t1, BitVecExpr t2) + { + + + + + CheckContextMatch(t1); + CheckContextMatch(t2); + return new BitVecExpr(this, Native.mkConcat(nCtx, t1.NativeObject, t2.NativeObject)); + } + + /** + * Bit-vector extraction. + * + * Extract the bits down to from a bitvector of + * size m to yield a new bitvector of size n, where + * n = high - low + 1. + * The argument must have a bit-vector sort. + * + **/ + public BitVecExpr MkExtract(Integer high, Integer low, BitVecExpr t) + { + + + + CheckContextMatch(t); + return new BitVecExpr(this, Native.mkExtract(nCtx, high, low, t.NativeObject)); + } + + /** + * Bit-vector sign extension. + * + * Sign-extends the given bit-vector to the (signed) equivalent bitvector of + * size m+i, where \c m is the size of the given bit-vector. + * The argument must have a bit-vector sort. + * + **/ + public BitVecExpr MkSignExt(Integer i, BitVecExpr t) + { + + + + CheckContextMatch(t); + return new BitVecExpr(this, Native.mkSignExt(nCtx, i, t.NativeObject)); + } + + /** + * Bit-vector zero extension. + * + * Extend the given bit-vector with zeros to the (unsigned) equivalent + * bitvector of size m+i, where \c m is the size of the + * given bit-vector. + * The argument must have a bit-vector sort. + * + **/ + public BitVecExpr MkZeroExt(Integer i, BitVecExpr t) + { + + + + CheckContextMatch(t); + return new BitVecExpr(this, Native.mkZeroExt(nCtx, i, t.NativeObject)); + } + + /** + * Bit-vector repetition. + * + * The argument must have a bit-vector sort. + * + **/ + public BitVecExpr MkRepeat(Integer i, BitVecExpr t) + { + + + + CheckContextMatch(t); + return new BitVecExpr(this, Native.mkRepeat(nCtx, i, t.NativeObject)); + } + + /** + * Shift left. + * + * It is equivalent to multiplication by 2^x where \c x is the value of . + * + * NB. The semantics of shift operations varies between environments. This + * definition does not necessarily capture directly the semantics of the + * programming language or assembly architecture you are modeling. + * + * The arguments must have a bit-vector sort. + * + **/ + public BitVecExpr MkBVSHL(BitVecExpr t1, BitVecExpr t2) + { + + + + + CheckContextMatch(t1); + CheckContextMatch(t2); + return new BitVecExpr(this, Native.mkBvshl(nCtx, t1.NativeObject, t2.NativeObject)); + } + + /** + * Logical shift right + * + * It is equivalent to unsigned division by 2^x where \c x is the value of . + * + * NB. The semantics of shift operations varies between environments. This + * definition does not necessarily capture directly the semantics of the + * programming language or assembly architecture you are modeling. + * + * The arguments must have a bit-vector sort. + * + **/ + public BitVecExpr MkBVLSHR(BitVecExpr t1, BitVecExpr t2) + { + + + + + CheckContextMatch(t1); + CheckContextMatch(t2); + return new BitVecExpr(this, Native.mkBvlshr(nCtx, t1.NativeObject, t2.NativeObject)); + } + + /** + * Arithmetic shift right + * + * It is like logical shift right except that the most significant + * bits of the result always copy the most significant bit of the + * second argument. + * + * NB. The semantics of shift operations varies between environments. This + * definition does not necessarily capture directly the semantics of the + * programming language or assembly architecture you are modeling. + * + * The arguments must have a bit-vector sort. + * + **/ + public BitVecExpr MkBVASHR(BitVecExpr t1, BitVecExpr t2) + { + + + + + CheckContextMatch(t1); + CheckContextMatch(t2); + return new BitVecExpr(this, Native.mkBvashr(nCtx, t1.NativeObject, t2.NativeObject)); + } + + /** + * Rotate Left. + * + * Rotate bits of \c t to the left \c i times. + * The argument must have a bit-vector sort. + * + **/ + public BitVecExpr MkBVRotateLeft(Integer i, BitVecExpr t) + { + + + + CheckContextMatch(t); + return new BitVecExpr(this, Native.mkRotateLeft(nCtx, i, t.NativeObject)); + } + + /** + * Rotate Right. + * + * Rotate bits of \c t to the right \c i times. + * The argument must have a bit-vector sort. + * + **/ + public BitVecExpr MkBVRotateRight(Integer i, BitVecExpr t) + { + + + + CheckContextMatch(t); + return new BitVecExpr(this, Native.mkRotateRight(nCtx, i, t.NativeObject)); + } + + /** + * Rotate Left. + * + * Rotate bits of to the left times. + * The arguments must have the same bit-vector sort. + * + **/ + public BitVecExpr MkBVRotateLeft(BitVecExpr t1, BitVecExpr t2) + { + + + + + CheckContextMatch(t1); + CheckContextMatch(t2); + return new BitVecExpr(this, Native.mkExtRotateLeft(nCtx, t1.NativeObject, t2.NativeObject)); + } + + /** + * Rotate Right. + * + * Rotate bits of to the right times. + * The arguments must have the same bit-vector sort. + * + **/ + public BitVecExpr MkBVRotateRight(BitVecExpr t1, BitVecExpr t2) + { + + + + + CheckContextMatch(t1); + CheckContextMatch(t2); + return new BitVecExpr(this, Native.mkExtRotateRight(nCtx, t1.NativeObject, t2.NativeObject)); + } + + /** + * Create an bit bit-vector from the integer argument . + * + * NB. This function is essentially treated as uninterpreted. + * So you cannot expect Z3 to precisely reflect the semantics of this function + * when solving constraints with this function. + * + * The argument must be of integer sort. + * + **/ + public BitVecExpr MkInt2BV(Integer n, IntExpr t) + { + + + + CheckContextMatch(t); + return new BitVecExpr(this, Native.mkInt2bv(nCtx, n, t.NativeObject)); + } + + /** + * Create an integer from the bit-vector argument . + * + * If \c is_signed is false, then the bit-vector \c t1 is treated as unsigned. + * So the result is non-negative and in the range [0..2^N-1], where + * N are the number of bits in . + * If \c is_signed is true, \c t1 is treated as a signed bit-vector. + * + * NB. This function is essentially treated as uninterpreted. + * So you cannot expect Z3 to precisely reflect the semantics of this function + * when solving constraints with this function. + * + * The argument must be of bit-vector sort. + * + **/ + public IntExpr MkBV2Int(BitVecExpr t, boolean signed) + { + + + + CheckContextMatch(t); + return new IntExpr(this, Native.mkBv2int(nCtx, t.NativeObject, (signed) ? 1 : 0)); + } + + /** + * Create a predicate that checks that the bit-wise addition does not overflow. + * + * The arguments must be of bit-vector sort. + * + **/ + public BoolExpr MkBVAddNoOverflow(BitVecExpr t1, BitVecExpr t2, boolean isSigned) + { + + + + + CheckContextMatch(t1); + CheckContextMatch(t2); + return new BoolExpr(this, Native.mkBvaddNoOverflow(nCtx, t1.NativeObject, t2.NativeObject, (isSigned) ? 1 : 0)); + } + + /** + * Create a predicate that checks that the bit-wise addition does not underflow. + * + * The arguments must be of bit-vector sort. + * + **/ + public BoolExpr MkBVAddNoUnderflow(BitVecExpr t1, BitVecExpr t2) + { + + + + + CheckContextMatch(t1); + CheckContextMatch(t2); + return new BoolExpr(this, Native.mkBvaddNoUnderflow(nCtx, t1.NativeObject, t2.NativeObject)); + } + + /** + * Create a predicate that checks that the bit-wise subtraction does not overflow. + * + * The arguments must be of bit-vector sort. + * + **/ + public BoolExpr MkBVSubNoOverflow(BitVecExpr t1, BitVecExpr t2) + { + + + + + CheckContextMatch(t1); + CheckContextMatch(t2); + return new BoolExpr(this, Native.mkBvsubNoOverflow(nCtx, t1.NativeObject, t2.NativeObject)); + } + + /** + * Create a predicate that checks that the bit-wise subtraction does not underflow. + * + * The arguments must be of bit-vector sort. + * + **/ + public BoolExpr MkBVSubNoUnderflow(BitVecExpr t1, BitVecExpr t2, boolean isSigned) + { + + + + + CheckContextMatch(t1); + CheckContextMatch(t2); + return new BoolExpr(this, Native.mkBvsubNoUnderflow(nCtx, t1.NativeObject, t2.NativeObject, (isSigned) ? 1 : 0)); + } + + /** + * Create a predicate that checks that the bit-wise signed division does not overflow. + * + * The arguments must be of bit-vector sort. + * + **/ + public BoolExpr MkBVSDivNoOverflow(BitVecExpr t1, BitVecExpr t2) + { + + + + + CheckContextMatch(t1); + CheckContextMatch(t2); + return new BoolExpr(this, Native.mkBvsdivNoOverflow(nCtx, t1.NativeObject, t2.NativeObject)); + } + + /** + * Create a predicate that checks that the bit-wise negation does not overflow. + * + * The arguments must be of bit-vector sort. + * + **/ + public BoolExpr MkBVNegNoOverflow(BitVecExpr t) + { + + + + CheckContextMatch(t); + return new BoolExpr(this, Native.mkBvnegNoOverflow(nCtx, t.NativeObject)); + } + + /** + * Create a predicate that checks that the bit-wise multiplication does not overflow. + * + * The arguments must be of bit-vector sort. + * + **/ + public BoolExpr MkBVMulNoOverflow(BitVecExpr t1, BitVecExpr t2, boolean isSigned) + { + + + + + CheckContextMatch(t1); + CheckContextMatch(t2); + return new BoolExpr(this, Native.mkBvmulNoOverflow(nCtx, t1.NativeObject, t2.NativeObject, (isSigned) ? 1 : 0)); + } + + /** + * Create a predicate that checks that the bit-wise multiplication does not underflow. + * + * The arguments must be of bit-vector sort. + * + **/ + public BoolExpr MkBVMulNoUnderflow(BitVecExpr t1, BitVecExpr t2) + { + + + + + CheckContextMatch(t1); + CheckContextMatch(t2); + return new BoolExpr(this, Native.mkBvmulNoUnderflow(nCtx, t1.NativeObject, t2.NativeObject)); + } + + /** + * Create an array constant. + **/ + public ArrayExpr MkArrayConst(Symbol name, Sort domain, Sort range) + { + + + + + + return (ArrayExpr)MkConst(name, MkArraySort(domain, range)); + } + + /** + * Create an array constant. + **/ + public ArrayExpr MkArrayConst(String name, Sort domain, Sort range) + { + + + + + return (ArrayExpr)MkConst(MkSymbol(name), MkArraySort(domain, range)); + } + + /** + * Array read. + * + * The argument a is the array and i is the index + * of the array that gets read. + * + * The node a must have an array sort [domain -> range], + * and i must have the sort domain. + * The sort of the result is range. + * + * + * + **/ + public Expr MkSelect(ArrayExpr a, Expr i) + { + + + + + CheckContextMatch(a); + CheckContextMatch(i); + return Expr.Create(this, Native.mkSelect(nCtx, a.NativeObject, i.NativeObject)); + } + + /** + * Array update. + * + * The node a must have an array sort [domain -> range], + * i must have sort domain, + * v must have sort range. The sort of the result is [domain -> range]. + * The semantics of this function is given by the theory of arrays described in the SMT-LIB + * standard. See http://smtlib.org for more details. + * The result of this function is an array that is equal to a + * (with respect to select) + * on all indices except for i, where it maps to v + * (and the select of a with + * respect to i may be a different value). + * + * + * + **/ + public ArrayExpr MkStore(ArrayExpr a, Expr i, Expr v) + { + + + + + + CheckContextMatch(a); + CheckContextMatch(i); + CheckContextMatch(v); + return new ArrayExpr(this, Native.mkStore(nCtx, a.NativeObject, i.NativeObject, v.NativeObject)); + } + + /** + * Create a constant array. + * + * The resulting term is an array, such that a selecton an arbitrary index + * produces the value v. + * + * + * + **/ + public ArrayExpr MkConstArray(Sort domain, Expr v) + { + + + + + CheckContextMatch(domain); + CheckContextMatch(v); + return new ArrayExpr(this, Native.mkConstArray(nCtx, domain.NativeObject, v.NativeObject)); + } + + /** + * Maps f on the argument arrays. + * + * Eeach element of args must be of an array sort [domain_i -> range_i]. + * The function declaration f must have type range_1 .. range_n -> range. + * v must have sort range. The sort of the result is [domain_i -> range]. + * + * + * + * + **/ + public ArrayExpr MkMap(FuncDecl f, ArrayExpr[] args) + { + + + + + CheckContextMatch(f); + CheckContextMatch(args); + return (ArrayExpr)Expr.Create(this, Native.mkMap(nCtx, f.NativeObject, AST.ArrayLength(args), AST.ArrayToNative(args))); + } + + /** + * Access the array default value. + * + * Produces the default range value, for arrays that can be represented as + * finite maps with a default range value. + * + **/ + public Expr MkTermArray(ArrayExpr array) + { + + + + CheckContextMatch(array); + return Expr.Create(this, Native.mkArrayDefault(nCtx, array.NativeObject)); + } + + /** + * Create a set type. + **/ + public SetSort MkSetSort(Sort ty) + { + + + + CheckContextMatch(ty); + return new SetSort(this, ty); + } + + /** + * Create an empty set. + **/ + public Expr MkEmptySet(Sort domain) + { + + + + CheckContextMatch(domain); + return Expr.Create(this, Native.mkEmptySet(nCtx, domain.NativeObject)); + } + + /** + * Create the full set. + **/ + public Expr MkFullSet(Sort domain) + { + + + + CheckContextMatch(domain); + return Expr.Create(this, Native.mkFullSet(nCtx, domain.NativeObject)); + } + + /** + * Add an element to the set. + **/ + public Expr MkSetAdd(Expr set, Expr element) + { + + + + + CheckContextMatch(set); + CheckContextMatch(element); + return Expr.Create(this, Native.mkSetAdd(nCtx, set.NativeObject, element.NativeObject)); + } + + + /** + * Remove an element from a set. + **/ + public Expr MkSetDel(Expr set, Expr element) + { + + + + + CheckContextMatch(set); + CheckContextMatch(element); + return Expr.Create(this, Native.mkSetDel(nCtx, set.NativeObject, element.NativeObject)); + } + + /** + * Take the union of a list of sets. + **/ + public Expr MkSetUnion(Expr[] args) + { + + + + CheckContextMatch(args); + return Expr.Create(this, Native.mkSetUnion(nCtx, (Integer)args.Length, AST.ArrayToNative(args))); + } + + /** + * Take the intersection of a list of sets. + **/ + public Expr MkSetIntersection(Expr[] args) + { + + + + + CheckContextMatch(args); + return Expr.Create(this, Native.mkSetIntersect(nCtx, (Integer)args.Length, AST.ArrayToNative(args))); + } + + /** + * Take the difference between two sets. + **/ + public Expr MkSetDifference(Expr arg1, Expr arg2) + { + + + + + CheckContextMatch(arg1); + CheckContextMatch(arg2); + return Expr.Create(this, Native.mkSetDifference(nCtx, arg1.NativeObject, arg2.NativeObject)); + } + + /** + * Take the complement of a set. + **/ + public Expr MkSetComplement(Expr arg) + { + + + + CheckContextMatch(arg); + return Expr.Create(this, Native.mkSetComplement(nCtx, arg.NativeObject)); + } + + /** + * Check for set membership. + **/ + public Expr MkSetMembership(Expr elem, Expr set) + { + + + + + CheckContextMatch(elem); + CheckContextMatch(set); + return Expr.Create(this, Native.mkSetMember(nCtx, elem.NativeObject, set.NativeObject)); + } + + /** + * Check for subsetness of sets. + **/ + public Expr MkSetSubset(Expr arg1, Expr arg2) + { + + + + + CheckContextMatch(arg1); + CheckContextMatch(arg2); + return Expr.Create(this, Native.mkSetSubset(nCtx, arg1.NativeObject, arg2.NativeObject)); + } + + + /** + * Create a Term of a given sort. + * A string representing the Term value in decimal notation. If the given sort is a real, then the Term can be a rational, that is, a string of the form [num]* / [num]*. + * The sort of the numeral. In the current implementation, the given sort can be an int, real, or bit-vectors of arbitrary size. + * @return A Term with value and sort + **/ + public Expr MkNumeral(String v, Sort ty) + { + + + + CheckContextMatch(ty); + return Expr.Create(this, Native.mkNumeral(nCtx, v, ty.NativeObject)); + } + + /** + * Create a Term of a given sort. This function can be use to create numerals that fit in a machine integer. + * It is slightly faster than MakeNumeral since it is not necessary to parse a string. + * Value of the numeral + * Sort of the numeral + * @return A Term with value and type + **/ + public Expr MkNumeral(int v, Sort ty) + { + + + + CheckContextMatch(ty); + return Expr.Create(this, Native.mkInt(nCtx, v, ty.NativeObject)); + } + + /** + * Create a Term of a given sort. This function can be use to create numerals that fit in a machine integer. + * It is slightly faster than MakeNumeral since it is not necessary to parse a string. + * Value of the numeral + * Sort of the numeral + * @return A Term with value and type + **/ + public Expr MkNumeral(Integer v, Sort ty) + { + + + + CheckContextMatch(ty); + return Expr.Create(this, Native.mkUnsignedInt(nCtx, v, ty.NativeObject)); + } + + /** + * Create a Term of a given sort. This function can be use to create numerals that fit in a machine integer. + * It is slightly faster than MakeNumeral since it is not necessary to parse a string. + * Value of the numeral + * Sort of the numeral + * @return A Term with value and type + **/ + public Expr MkNumeral(long v, Sort ty) + { + + + + CheckContextMatch(ty); + return Expr.Create(this, Native.mkInt64(nCtx, v, ty.NativeObject)); + } + + /** + * Create a Term of a given sort. This function can be use to create numerals that fit in a machine integer. + * It is slightly faster than MakeNumeral since it is not necessary to parse a string. + * Value of the numeral + * Sort of the numeral + * @return A Term with value and type + **/ + public Expr MkNumeral(ulong v, Sort ty) + { + + + + CheckContextMatch(ty); + return Expr.Create(this, Native.mkUnsignedInt64(nCtx, v, ty.NativeObject)); + } + + /** + * Create a real from a fraction. + * numerator of rational. + * denominator of rational. + * @return A Term with value / and sort Real + * + **/ + public RatNum MkReal(int num, int den) + { + if (den == 0) + throw new Z3Exception("Denominator is zero"); + + + + + return new RatNum(this, Native.mkReal(nCtx, num, den)); + } + + /** + * Create a real numeral. + * A string representing the Term value in decimal notation. + * @return A Term with value and sort Real + **/ + public RatNum MkReal(String v) + { + + + return new RatNum(this, Native.mkNumeral(nCtx, v, RealSort.NativeObject)); + } + + /** + * Create a real numeral. + * value of the numeral. + * @return A Term with value and sort Real + **/ + public RatNum MkReal(int v) + { + + + return new RatNum(this, Native.mkInt(nCtx, v, RealSort.NativeObject)); + } + + /** + * Create a real numeral. + * value of the numeral. + * @return A Term with value and sort Real + **/ + public RatNum MkReal(Integer v) + { + + + return new RatNum(this, Native.mkUnsignedInt(nCtx, v, RealSort.NativeObject)); + } + + /** + * Create a real numeral. + * value of the numeral. + * @return A Term with value and sort Real + **/ + public RatNum MkReal(long v) + { + + + return new RatNum(this, Native.mkInt64(nCtx, v, RealSort.NativeObject)); + } + + /** + * Create a real numeral. + * value of the numeral. + * @return A Term with value and sort Real + **/ + public RatNum MkReal(ulong v) + { + + + return new RatNum(this, Native.mkUnsignedInt64(nCtx, v, RealSort.NativeObject)); + } + + /** + * Create an integer numeral. + * A string representing the Term value in decimal notation. + **/ + public IntNum MkInt(String v) + { + + + return new IntNum(this, Native.mkNumeral(nCtx, v, IntSort.NativeObject)); + } + + /** + * Create an integer numeral. + * value of the numeral. + * @return A Term with value and sort Integer + **/ + public IntNum MkInt(int v) + { + + + return new IntNum(this, Native.mkInt(nCtx, v, IntSort.NativeObject)); + } + + /** + * Create an integer numeral. + * value of the numeral. + * @return A Term with value and sort Integer + **/ + public IntNum MkInt(Integer v) + { + + + return new IntNum(this, Native.mkUnsignedInt(nCtx, v, IntSort.NativeObject)); + } + + /** + * Create an integer numeral. + * value of the numeral. + * @return A Term with value and sort Integer + **/ + public IntNum MkInt(long v) + { + + + return new IntNum(this, Native.mkInt64(nCtx, v, IntSort.NativeObject)); + } + + /** + * Create an integer numeral. + * value of the numeral. + * @return A Term with value and sort Integer + **/ + public IntNum MkInt(ulong v) + { + + + return new IntNum(this, Native.mkUnsignedInt64(nCtx, v, IntSort.NativeObject)); + } + + /** + * Create a bit-vector numeral. + * A string representing the value in decimal notation. + * the size of the bit-vector + **/ + public BitVecNum MkBV(String v, Integer size) + { + + + return (BitVecNum)MkNumeral(v, MkBitVecSort(size)); + } + + /** + * Create a bit-vector numeral. + * value of the numeral. + * the size of the bit-vector + **/ + public BitVecNum MkBV(int v, Integer size) + { + + + return (BitVecNum)MkNumeral(v, MkBitVecSort(size)); + } + + /** + * Create a bit-vector numeral. + * value of the numeral. + * the size of the bit-vector + **/ + public BitVecNum MkBV(Integer v, Integer size) + { + + + return (BitVecNum)MkNumeral(v, MkBitVecSort(size)); + } + + /** + * Create a bit-vector numeral. + * value of the numeral. + * * the size of the bit-vector + **/ + public BitVecNum MkBV(long v, Integer size) + { + + + return (BitVecNum)MkNumeral(v, MkBitVecSort(size)); + } + + /** + * Create a bit-vector numeral. + * value of the numeral. + * the size of the bit-vector + **/ + public BitVecNum MkBV(ulong v, Integer size) + { + + + return (BitVecNum)MkNumeral(v, MkBitVecSort(size)); + } + + + /** + * Create a universal Quantifier. + * + * Creates a forall formula, where is the weight, + * is an array of patterns, is an array + * with the sorts of the bound variables, is an array with the + * 'names' of the bound variables, and is the body of the + * quantifier. Quantifiers are associated with weights indicating + * the importance of using the quantifier during instantiation. + * + * the sorts of the bound variables. + * names of the bound variables + * the body of the quantifier. + * quantifiers are associated with weights indicating the importance of using the quantifier during instantiation. By default, pass the weight 0. + * array containing the patterns created using MkPattern. + * array containing the anti-patterns created using MkPattern. + * optional symbol to track quantifier. + * optional symbol to track skolem constants. + **/ + public Quantifier MkForall(Sort[] sorts, Symbol[] names, Expr body, Integer weight, Pattern[] patterns, Expr[] noPatterns, Symbol quantifierID, Symbol skolemID) + { + + + + + + + + + + + + return new Quantifier(this, true, sorts, names, body, weight, patterns, noPatterns, quantifierID, skolemID); + } + + + /** + * Create a universal Quantifier. + **/ + public Quantifier MkForall(Expr[] boundConstants, Expr body, Integer weight, Pattern[] patterns, Expr[] noPatterns, Symbol quantifierID, Symbol skolemID) + { + + + + + + + + return new Quantifier(this, true, boundConstants, body, weight, patterns, noPatterns, quantifierID, skolemID); + } + + /** + * Create an existential Quantifier. + * + **/ + public Quantifier MkExists(Sort[] sorts, Symbol[] names, Expr body, Integer weight, Pattern[] patterns, Expr[] noPatterns, Symbol quantifierID, Symbol skolemID) + { + + + + + + + + + + + return new Quantifier(this, false, sorts, names, body, weight, patterns, noPatterns, quantifierID, skolemID); + } + + /** + * Create an existential Quantifier. + **/ + public Quantifier MkExists(Expr[] boundConstants, Expr body, Integer weight, Pattern[] patterns, Expr[] noPatterns, Symbol quantifierID, Symbol skolemID) + { + + + + + + + return new Quantifier(this, false, boundConstants, body, weight, patterns, noPatterns, quantifierID, skolemID); + } + + + /** + * Create a Quantifier. + **/ + public Quantifier MkQuantifier(boolean universal, Sort[] sorts, Symbol[] names, Expr body, Integer weight, Pattern[] patterns, Expr[] noPatterns, Symbol quantifierID, Symbol skolemID) + { + + + + + + + + + + + + if (universal) + return MkForall(sorts, names, body, weight, patterns, noPatterns, quantifierID, skolemID); + else + return MkExists(sorts, names, body, weight, patterns, noPatterns, quantifierID, skolemID); + } + + + /** + * Create a Quantifier. + **/ + public Quantifier MkQuantifier(boolean universal, Expr[] boundConstants, Expr body, Integer weight, Pattern[] patterns, Expr[] noPatterns, Symbol quantifierID, Symbol skolemID) + { + + + + + + + + if (universal) + return MkForall(boundConstants, body, weight, patterns, noPatterns, quantifierID, skolemID); + else + return MkExists(boundConstants, body, weight, patterns, noPatterns, quantifierID, skolemID); + } + + + + /** + * Selects the format used for pretty-printing expressions. + * + * The default mode for pretty printing expressions is to produce + * SMT-LIB style output where common subexpressions are printed + * at each occurrence. The mode is called Z3_PRINT_SMTLIB_FULL. + * To print shared common subexpressions only once, + * use the Z3_PRINT_LOW_LEVEL mode. + * To print in way that conforms to SMT-LIB standards and uses let + * expressions to share common sub-expressions use Z3_PRINT_SMTLIB_COMPLIANT. + * + * + * + * + * + **/ + public void setPrintMode(Z3_ast_print_mode value) { Native.setAstPrintMode(nCtx, Integer(value)); } + + /** + * Convert a benchmark into an SMT-LIB formatted string. + * Name of the benchmark. The argument is optional. + * The benchmark logic. + * The status string (sat, unsat, or unknown) + * Other attributes, such as source, difficulty or category. + * Auxiliary assumptions. + * Formula to be checked for consistency in conjunction with assumptions. + * @return A string representation of the benchmark. + **/ + public String BenchmarkToSMTString(String name, String logic, String status, String attributes, + BoolExpr[] assumptions, BoolExpr formula) + { + + + + + return Native.benchmarkToSmtlibString(nCtx, name, logic, status, attributes, + (Integer)assumptions.Length, AST.ArrayToNative(assumptions), + formula.NativeObject); + } + + /** + * Parse the given string using the SMT-LIB parser. + * + * The symbol table of the parser can be initialized using the given sorts and declarations. + * The symbols in the arrays and + * don't need to match the names of the sorts and declarations in the arrays + * and . This is a useful feature since we can use arbitrary names to + * reference sorts and declarations. + * + **/ + public void ParseSMTLIBString(String str, Symbol[] sortNames, Sort[] sorts, Symbol[] declNames, FuncDecl[] decls) + { + Integer csn = Symbol.ArrayLength(sortNames); + Integer cs = Sort.ArrayLength(sorts); + Integer cdn = Symbol.ArrayLength(declNames); + Integer cd = AST.ArrayLength(decls); + if (csn != cs || cdn != cd) + throw new Z3Exception("Argument size mismatch"); + Native.parseSmtlibString(nCtx, str, + AST.ArrayLength(sorts), Symbol.ArrayToNative(sortNames), AST.ArrayToNative(sorts), + AST.ArrayLength(decls), Symbol.ArrayToNative(declNames), AST.ArrayToNative(decls)); + } + + /** + * Parse the given file using the SMT-LIB parser. + * + **/ + public void ParseSMTLIBFile(String fileName, Symbol[] sortNames, Sort[] sorts, Symbol[] declNames, FuncDecl[] decls) + { + Integer csn = Symbol.ArrayLength(sortNames); + Integer cs = Sort.ArrayLength(sorts); + Integer cdn = Symbol.ArrayLength(declNames); + Integer cd = AST.ArrayLength(decls); + if (csn != cs || cdn != cd) + throw new Z3Exception("Argument size mismatch"); + Native.parseSmtlibFile(nCtx, fileName, + AST.ArrayLength(sorts), Symbol.ArrayToNative(sortNames), AST.ArrayToNative(sorts), + AST.ArrayLength(decls), Symbol.ArrayToNative(declNames), AST.ArrayToNative(decls)); + } + + /** + * The number of SMTLIB formulas parsed by the last call to ParseSMTLIBString or ParseSMTLIBFile. + **/ + public Integer NumSMTLIBFormulas () { return Native.getSmtlibNumFormulas(nCtx); } + + /** + * The formulas parsed by the last call to ParseSMTLIBString or ParseSMTLIBFile. + **/ + public BoolExpr[] SMTLIBFormulas() + { + + + Integer n = NumSMTLIBFormulas; + BoolExpr[] res = new BoolExpr[n]; + for (Integer i = 0; i < n; i++) + res[i] = (BoolExpr)Expr.Create(this, Native.getSmtlibFormula(nCtx, i)); + return res; + } + + /** + * The number of SMTLIB assumptions parsed by the last call to ParseSMTLIBString or ParseSMTLIBFile. + **/ + public Integer NumSMTLIBAssumptions () { return Native.getSmtlibNumAssumptions(nCtx); } + + /** + * The assumptions parsed by the last call to ParseSMTLIBString or ParseSMTLIBFile. + **/ + public BoolExpr[] SMTLIBAssumptions() + { + + + Integer n = NumSMTLIBAssumptions; + BoolExpr[] res = new BoolExpr[n]; + for (Integer i = 0; i < n; i++) + res[i] = (BoolExpr)Expr.Create(this, Native.getSmtlibAssumption(nCtx, i)); + return res; + } + + /** + * The number of SMTLIB declarations parsed by the last call to ParseSMTLIBString or ParseSMTLIBFile. + **/ + public Integer NumSMTLIBDecls () { return Native.getSmtlibNumDecls(nCtx); } + + /** + * The declarations parsed by the last call to ParseSMTLIBString or ParseSMTLIBFile. + **/ + public FuncDecl[] SMTLIBDecls() + { + + + Integer n = NumSMTLIBDecls; + FuncDecl[] res = new FuncDecl[n]; + for (Integer i = 0; i < n; i++) + res[i] = new FuncDecl(this, Native.getSmtlibDecl(nCtx, i)); + return res; + } + + /** + * The number of SMTLIB sorts parsed by the last call to ParseSMTLIBString or ParseSMTLIBFile. + **/ + public Integer NumSMTLIBSorts () { return Native.getSmtlibNumSorts(nCtx); } + + /** + * The declarations parsed by the last call to ParseSMTLIBString or ParseSMTLIBFile. + **/ + public Sort[] SMTLIBSorts() + { + + + Integer n = NumSMTLIBSorts; + Sort[] res = new Sort[n]; + for (Integer i = 0; i < n; i++) + res[i] = Sort.Create(this, Native.getSmtlibSort(nCtx, i)); + return res; + } + + /** + * Parse the given string using the SMT-LIB2 parser. + * + * @return A conjunction of assertions in the scope (up to push/pop) at the end of the string. + **/ + public BoolExpr ParseSMTLIB2String(String str, Symbol[] sortNames, Sort[] sorts, Symbol[] declNames, FuncDecl[] decls) + { + + + Integer csn = Symbol.ArrayLength(sortNames); + Integer cs = Sort.ArrayLength(sorts); + Integer cdn = Symbol.ArrayLength(declNames); + Integer cd = AST.ArrayLength(decls); + if (csn != cs || cdn != cd) + throw new Z3Exception("Argument size mismatch"); + return (BoolExpr)Expr.Create(this, Native.parseSmtlib2String(nCtx, str, + AST.ArrayLength(sorts), Symbol.ArrayToNative(sortNames), AST.ArrayToNative(sorts), + AST.ArrayLength(decls), Symbol.ArrayToNative(declNames), AST.ArrayToNative(decls))); + } + + /** + * Parse the given file using the SMT-LIB2 parser. + * + **/ + public BoolExpr ParseSMTLIB2File(String fileName, Symbol[] sortNames, Sort[] sorts, Symbol[] declNames, FuncDecl[] decls) + { + + + Integer csn = Symbol.ArrayLength(sortNames); + Integer cs = Sort.ArrayLength(sorts); + Integer cdn = Symbol.ArrayLength(declNames); + Integer cd = AST.ArrayLength(decls); + if (csn != cs || cdn != cd) + throw new Z3Exception("Argument size mismatch"); + return (BoolExpr)Expr.Create(this, Native.parseSmtlib2File(nCtx, fileName, + AST.ArrayLength(sorts), Symbol.ArrayToNative(sortNames), AST.ArrayToNative(sorts), + AST.ArrayLength(decls), Symbol.ArrayToNative(declNames), AST.ArrayToNative(decls))); + } + + /** + * Creates a new Goal. + * + * Note that the Context must have been created with proof generation support if + * is set to true here. + * + * Indicates whether model generation should be enabled. + * Indicates whether unsat core generation should be enabled. + * Indicates whether proof generation should be enabled. + **/ + public Goal MkGoal(boolean models, boolean unsatCores, boolean proofs) + { + + + return new Goal(this, models, unsatCores, proofs); + } + + /** + * Creates a new ParameterSet. + **/ + public Params MkParams() + { + + + return new Params(this); + } + + /** + * The number of supported tactics. + **/ + public Integer NumTactics() { return Native.getNumTactics(nCtx); } + + /** + * The names of all supported tactics. + **/ + public String[] TacticNames() + { + + + Integer n = NumTactics; + String[] res = new String[n]; + for (Integer i = 0; i < n; i++) + res[i] = Native.getTacticName(nCtx, i); + return res; + } + + /** + * Returns a string containing a description of the tactic with the given name. + **/ + public String TacticDescription(String name) + { + + + return Native.tacticGetDescr(nCtx, name); + } + + /** + * Creates a new Tactic. + **/ + public Tactic MkTactic(String name) + { + + + return new Tactic(this, name); + } + + /** + * Create a tactic that applies to a Goal and + * then to every subgoal produced by . + **/ + public Tactic AndThen(Tactic t1, Tactic t2, Tactic[] ts) + { + + + + + + + CheckContextMatch(t1); + CheckContextMatch(t2); + CheckContextMatch(ts); + + IntPtr last = IntPtr.Zero; + if (ts != null && ts.Length > 0) + { + last = ts[ts.Length - 1].NativeObject; + for (int i = ts.Length - 2; i >= 0; i--) + last = Native.tacticAndThen(nCtx, ts[i].NativeObject, last); + } + if (last != IntPtr.Zero) + { + last = Native.tacticAndThen(nCtx, t2.NativeObject, last); + return new Tactic(this, Native.tacticAndThen(nCtx, t1.NativeObject, last)); + } + else + return new Tactic(this, Native.tacticAndThen(nCtx, t1.NativeObject, t2.NativeObject)); + } + + /** + * Create a tactic that applies to a Goal and + * then to every subgoal produced by . + * + * Shorthand for AndThen. + * + **/ + public Tactic Then(Tactic t1, Tactic t2, Tactic[] ts) + { + + + + + + return AndThen(t1, t2, ts); + } + + /** + * Create a tactic that first applies to a Goal and + * if it fails then returns the result of applied to the Goal. + **/ + public Tactic OrElse(Tactic t1, Tactic t2) + { + + + + + CheckContextMatch(t1); + CheckContextMatch(t2); + return new Tactic(this, Native.tacticOrElse(nCtx, t1.NativeObject, t2.NativeObject)); + } + + /** + * Create a tactic that applies to a goal for milliseconds. + * + * If does not terminate within milliseconds, then it fails. + * + **/ + public Tactic TryFor(Tactic t, Integer ms) + { + + + + CheckContextMatch(t); + return new Tactic(this, Native.tacticTryFor(nCtx, t.NativeObject, ms)); + } + + /** + * Create a tactic that applies to a given goal if the probe + * evaluates to true. + * + * If evaluates to false, then the new tactic behaves like the skip tactic. + * + **/ + public Tactic When(Probe p, Tactic t) + { + + + + + CheckContextMatch(t); + CheckContextMatch(p); + return new Tactic(this, Native.tacticWhen(nCtx, p.NativeObject, t.NativeObject)); + } + + /** + * Create a tactic that applies to a given goal if the probe + * evaluates to true and otherwise. + **/ + public Tactic Cond(Probe p, Tactic t1, Tactic t2) + { + + + + + + CheckContextMatch(p); + CheckContextMatch(t1); + CheckContextMatch(t2); + return new Tactic(this, Native.tacticCond(nCtx, p.NativeObject, t1.NativeObject, t2.NativeObject)); + } + + /** + * Create a tactic that keeps applying until the goal is not + * modified anymore or the maximum number of iterations is reached. + **/ + public Tactic Repeat(Tactic t, Integer max) + { + + + + CheckContextMatch(t); + return new Tactic(this, Native.tacticRepeat(nCtx, t.NativeObject, max)); + } + + /** + * Create a tactic that just returns the given goal. + **/ + public Tactic Skip() + { + + + return new Tactic(this, Native.tacticSkip(nCtx)); + } + + /** + * Create a tactic always fails. + **/ + public Tactic Fail() + { + + + return new Tactic(this, Native.tacticFail(nCtx)); + } + + /** + * Create a tactic that fails if the probe evaluates to false. + **/ + public Tactic FailIf(Probe p) + { + + + + CheckContextMatch(p); + return new Tactic(this, Native.tacticFailIf(nCtx, p.NativeObject)); + } + + /** + * Create a tactic that fails if the goal is not triviall satisfiable (i.e., empty) + * or trivially unsatisfiable (i.e., contains `false'). + **/ + public Tactic FailIfNotDecided() + { + + + return new Tactic(this, Native.tacticFailIfNotDecided(nCtx)); + } + + /** + * Create a tactic that applies using the given set of parameters . + **/ + public Tactic UsingParams(Tactic t, Params p) + { + + + + + CheckContextMatch(t); + CheckContextMatch(p); + return new Tactic(this, Native.tacticUsingParams(nCtx, t.NativeObject, p.NativeObject)); + } + + /** + * Create a tactic that applies using the given set of parameters . + * Alias for UsingParams + **/ + public Tactic With(Tactic t, Params p) + { + + + + + return UsingParams(t, p); + } + + /** + * Create a tactic that applies the given tactics in parallel. + **/ + public Tactic ParOr(Tactic[] t) + { + + + + CheckContextMatch(t); + return new Tactic(this, Native.tacticParOr(nCtx, Tactic.ArrayLength(t), Tactic.ArrayToNative(t))); + } + + /** + * Create a tactic that applies to a given goal and then + * to every subgoal produced by . The subgoals are processed in parallel. + **/ + public Tactic ParAndThen(Tactic t1, Tactic t2) + { + + + + + CheckContextMatch(t1); + CheckContextMatch(t2); + return new Tactic(this, Native.tacticParAndThen(nCtx, t1.NativeObject, t2.NativeObject)); + } + + /** + * Interrupt the execution of a Z3 procedure. + * This procedure can be used to interrupt: solvers, simplifiers and tactics. + **/ + public void Interrupt() + { + Native.interrupt(nCtx); + } + + /** + * The number of supported Probes. + **/ + public Integer NumProbes() { return Native.getNumProbes(nCtx); } + + /** + * The names of all supported Probes. + **/ + public String[] ProbeNames() + { + + + Integer n = NumProbes; + String[] res = new String[n]; + for (Integer i = 0; i < n; i++) + res[i] = Native.getProbeName(nCtx, i); + return res; + } + + /** + * Returns a string containing a description of the probe with the given name. + **/ + public String ProbeDescription(String name) + { + + + return Native.probeGetDescr(nCtx, name); + } + + /** + * Creates a new Probe. + **/ + public Probe MkProbe(String name) + { + + + return new Probe(this, name); + } + + /** + * Create a probe that always evaluates to . + **/ + public Probe Const(double val) + { + + + return new Probe(this, Native.probeConst(nCtx, val)); + } + + /** + * Create a probe that evaluates to "true" when the value returned by + * is less than the value returned by + **/ + public Probe Lt(Probe p1, Probe p2) + { + + + + + CheckContextMatch(p1); + CheckContextMatch(p2); + return new Probe(this, Native.probeLt(nCtx, p1.NativeObject, p2.NativeObject)); + } + + /** + * Create a probe that evaluates to "true" when the value returned by + * is greater than the value returned by + **/ + public Probe Gt(Probe p1, Probe p2) + { + + + + + CheckContextMatch(p1); + CheckContextMatch(p2); + return new Probe(this, Native.probeGt(nCtx, p1.NativeObject, p2.NativeObject)); + } + + /** + * Create a probe that evaluates to "true" when the value returned by + * is less than or equal the value returned by + **/ + public Probe Le(Probe p1, Probe p2) + { + + + + + CheckContextMatch(p1); + CheckContextMatch(p2); + return new Probe(this, Native.probeLe(nCtx, p1.NativeObject, p2.NativeObject)); + } + + /** + * Create a probe that evaluates to "true" when the value returned by + * is greater than or equal the value returned by + **/ + public Probe Ge(Probe p1, Probe p2) + { + + + + + CheckContextMatch(p1); + CheckContextMatch(p2); + return new Probe(this, Native.probeGe(nCtx, p1.NativeObject, p2.NativeObject)); + } + + /** + * Create a probe that evaluates to "true" when the value returned by + * is equal to the value returned by + **/ + public Probe Eq(Probe p1, Probe p2) + { + + + + + CheckContextMatch(p1); + CheckContextMatch(p2); + return new Probe(this, Native.probeEq(nCtx, p1.NativeObject, p2.NativeObject)); + } + + /** + * Create a probe that evaluates to "true" when the value + * and evaluate to "true". + **/ + public Probe And(Probe p1, Probe p2) + { + + + + + CheckContextMatch(p1); + CheckContextMatch(p2); + return new Probe(this, Native.probeAnd(nCtx, p1.NativeObject, p2.NativeObject)); + } + + /** + * Create a probe that evaluates to "true" when the value + * or evaluate to "true". + **/ + public Probe Or(Probe p1, Probe p2) + { + + + + + CheckContextMatch(p1); + CheckContextMatch(p2); + return new Probe(this, Native.probeOr(nCtx, p1.NativeObject, p2.NativeObject)); + } + + /** + * Create a probe that evaluates to "true" when the value + * does not evaluate to "true". + **/ + public Probe Not(Probe p) + { + + + + CheckContextMatch(p); + return new Probe(this, Native.probeNot(nCtx, p.NativeObject)); + } + + /** + * Creates a new (incremental) solver. + * + * This solver also uses a set of builtin tactics for handling the first + * check-sat command, and check-sat commands that take more than a given + * number of milliseconds to be solved. + * + **/ + public Solver MkSolver(Symbol logic) + { + + + if (logic == null) + return new Solver(this, Native.mkSolver(nCtx)); + else + return new Solver(this, Native.mkSolverForLogic(nCtx, logic.NativeObject)); + } + + /** + * Creates a new (incremental) solver. + * + **/ + public Solver MkSolver(String logic) + { + + + return MkSolver(MkSymbol(logic)); + } + + /** + * Creates a new (incremental) solver. + **/ + public Solver MkSimpleSolver() + { + + + return new Solver(this, Native.mkSimpleSolver(nCtx)); + } + + /** + * Creates a solver that is implemented using the given tactic. + * + * The solver supports the commands Push and Pop, but it + * will always solve each check from scratch. + * + **/ + public Solver MkSolver(Tactic t) + { + + + + return new Solver(this, Native.mkSolverFromTactic(nCtx, t.NativeObject)); + } + + /** + * Create a Fixedpoint context. + **/ + public Fixedpoint MkFixedpoint() + { + + + return new Fixedpoint(this); + } + + + /** + * Wraps an AST. + * This function is used for transitions between native and + * managed objects. Note that must be a + * native object obtained from Z3 (e.g., through ) + * and that it must have a correct reference count (see e.g., + * . + * + * The native pointer to wrap. + **/ + public AST WrapAST(IntPtr nativeObject) + { + + return AST.Create(this, nativeObject); + } + + /** + * Unwraps an AST. + * This function is used for transitions between native and + * managed objects. It returns the native pointer to the AST. Note that + * AST objects are reference counted and unwrapping an AST disables automatic + * reference counting, i.e., all references to the IntPtr that is returned + * must be handled externally and through native calls (see e.g., + * ). + * + * The AST to unwrap. + **/ + public IntPtr UnwrapAST(AST a) + { + return a.NativeObject; + } + + /** + * Return a string describing all available parameters to Expr.Simplify. + **/ + public String SimplifyHelp() + { + + + return Native.simplifyGetHelp(nCtx); + } + + /** + * Retrieves parameter descriptions for simplifier. + **/ + public ParamDescrs SimplifyParameterDescriptions() { return new ParamDescrs(this, Native.simplifyGetParamDescrs(nCtx)); } + + /** + * Enable/disable printing of warning messages to the console. + * Note that this function is static and effects the behaviour of + * all contexts globally. + **/ + public static void ToggleWarningMessages(boolean enabled) + { + Native.toggleWarningMessages((enabled) ? 1 : 0); + } + + ///// + ///// A delegate which is executed when an error is raised. + ///// + ///// + ///// Note that it is possible for memory leaks to occur if error handlers + ///// throw exceptions. + ///// + //public delegate void ErrorHandler(Context ctx, Z3ErrorCode errorCode, String errorString); + + ///// + ///// The OnError event. + ///// + //public event ErrorHandler OnError = null; + + /** + * Update a mutable configuration parameter. + * + * The list of all configuration parameters can be obtained using the Z3 executable: + * z3.exe -ini? + * Only a few configuration parameters are mutable once the context is created. + * An exception is thrown when trying to modify an immutable parameter. + * + * + **/ + public void UpdateParamValue(String id, String value) + { + Native.updateParamValue(nCtx, id, value); + } + + /** + * Get a configuration parameter. + * + * Returns null if the parameter value does not exist. + * + * + **/ + public String GetParamValue(String id) + { + IntPtr res = IntPtr.Zero; + int r = Native.getParamValue(nCtx, id, out res); + if (r == (int)Z3Lboolean.Z3LFALSE) + return null; + else + return Marshal.PtrtoStringAnsi(res); + } + + + IntPtr mCtx = IntPtr.Zero; + Native.errorHandler mNErrHandler = null; + IntPtr nCtx () { return mCtx; } + + void NativeErrorHandler(IntPtr ctx, Z3ErrorCode errorCode) + { + // Do-nothing error handler. The wrappers in Z3.Native will throw exceptions upon errors. + } + + void InitContext() + { + PrintMode = Z3AstPrintMode.Z3PRINTSMTLIB2COMPLIANT; + mNErrHandler = new Native.errorHandler(NativeErrorHandler); // keep reference so it doesn't get collected. + Native.setErrorHandler(mCtx, mNErrHandler); + GC.SuppressFinalize(this); + } + + void CheckContextMatch(Z3Object other) + { + + + if (!ReferenceEquals(this, other.Context)) + throw new Z3Exception("Context mismatch"); + } + + void CheckContextMatch(Z3Object[] arr) + { + + + if (arr != null) + { + for (Z3Object.Iterator a = arr.iterator(); a.hasNext(); ) + { + // It was an assume, now we added the precondition, and we made it into an assert + CheckContextMatch(a); + } + } + } + + private void ObjectInvariant() + { + + + + + + + + + + + + + + + + } + + private AST.DecRefQueue mASTDRQ = new AST.DecRefQueue(); + private ASTMap.DecRefQueue mASTMapDRQ = new ASTMap.DecRefQueue(); + private ASTVector.DecRefQueue mASTVectorDRQ = new ASTVector.DecRefQueue(); + private ApplyResult.DecRefQueue mApplyResultDRQ = new ApplyResult.DecRefQueue(); + private FuncInterp.Entry.DecRefQueue mFuncEntryDRQ = new FuncInterp.Entry.DecRefQueue(); + private FuncInterp.DecRefQueue mFuncInterpDRQ = new FuncInterp.DecRefQueue(); + private Goal.DecRefQueue mGoalDRQ = new Goal.DecRefQueue(); + private Model.DecRefQueue mModelDRQ = new Model.DecRefQueue(); + private Params.DecRefQueue mParamsDRQ = new Params.DecRefQueue(); + private ParamDescrs.DecRefQueue mParamDescrsDRQ = new ParamDescrs.DecRefQueue(); + private Probe.DecRefQueue mProbeDRQ = new Probe.DecRefQueue(); + private Solver.DecRefQueue mSolverDRQ = new Solver.DecRefQueue(); + private Statistics.DecRefQueue mStatisticsDRQ = new Statistics.DecRefQueue(); + private Tactic.DecRefQueue mTacticDRQ = new Tactic.DecRefQueue(); + private Fixedpoint.DecRefQueue mFixedpointDRQ = new Fixedpoint.DecRefQueue(); + + AST.DecRefQueue AST_DRQ () { Contract.Ensures(Contract.Result() != null); return mASTDRQ; } + ASTMap.DecRefQueue ASTMap_DRQ () { Contract.Ensures(Contract.Result() != null); return mASTMapDRQ; } + ASTVector.DecRefQueue ASTVector_DRQ () { Contract.Ensures(Contract.Result() != null); return mASTVectorDRQ; } + ApplyResult.DecRefQueue ApplyResult_DRQ () { Contract.Ensures(Contract.Result() != null); return mApplyResultDRQ; } + FuncInterp.Entry.DecRefQueue FuncEntry_DRQ () { Contract.Ensures(Contract.Result() != null); return mFuncEntryDRQ; } + FuncInterp.DecRefQueue FuncInterp_DRQ () { Contract.Ensures(Contract.Result() != null); return mFuncInterpDRQ; } + Goal.DecRefQueue Goal_DRQ () { Contract.Ensures(Contract.Result() != null); return mGoalDRQ; } + Model.DecRefQueue Model_DRQ () { Contract.Ensures(Contract.Result() != null); return mModelDRQ; } + Params.DecRefQueue Params_DRQ () { Contract.Ensures(Contract.Result() != null); return mParamsDRQ; } + ParamDescrs.DecRefQueue ParamDescrs_DRQ () { Contract.Ensures(Contract.Result() != null); return mParamDescrsDRQ; } + Probe.DecRefQueue Probe_DRQ () { Contract.Ensures(Contract.Result() != null); return mProbeDRQ; } + Solver.DecRefQueue Solver_DRQ () { Contract.Ensures(Contract.Result() != null); return mSolverDRQ; } + Statistics.DecRefQueue Statistics_DRQ () { Contract.Ensures(Contract.Result() != null); return mStatisticsDRQ; } + Tactic.DecRefQueue Tactic_DRQ () { Contract.Ensures(Contract.Result() != null); return mTacticDRQ; } + Fixedpoint.DecRefQueue Fixedpoint_DRQ () { Contract.Ensures(Contract.Result() != null); return mFixedpointDRQ; } + + + Integer refCount = 0; + + /** + * Finalizer. + **/ + protected void finalize() + { + // Console.WriteLine("Context Finalizer from " + System.Threading.Thread.CurrentThread.ManagedThreadId); + Dispose(); + + if (refCount == 0) + { + mNErrHandler = null; + Native.delContext(mCtx); + mCtx = IntPtr.Zero; + } + else + GC.ReRegisterForFinalize(this); + } + + /** + * Disposes of the context. + **/ + public void Dispose() + { + // Console.WriteLine("Context Dispose from " + System.Threading.Thread.CurrentThread.ManagedThreadId); + ASTDRQ.Clear(this); + ASTMapDRQ.Clear(this); + ASTVectorDRQ.Clear(this); + ApplyResultDRQ.Clear(this); + FuncEntryDRQ.Clear(this); + FuncInterpDRQ.Clear(this); + GoalDRQ.Clear(this); + ModelDRQ.Clear(this); + ParamsDRQ.Clear(this); + ProbeDRQ.Clear(this); + SolverDRQ.Clear(this); + StatisticsDRQ.Clear(this); + TacticDRQ.Clear(this); + FixedpointDRQ.Clear(this); + + mBooleanSort = null; + mIntSort = null; + mRealSort = null; + } + } diff --git a/src/api/java/com/Microsoft/Z3/DecRefQUeue.java b/src/api/java/com/Microsoft/Z3/DecRefQUeue.java new file mode 100644 index 000000000..1e1f13881 --- /dev/null +++ b/src/api/java/com/Microsoft/Z3/DecRefQUeue.java @@ -0,0 +1,50 @@ +/** + * This file was automatically generated from DecRefQUeue.cs + **/ + +package com.Microsoft.Z3; + +/* using System; */ +/* using System.Collections; */ +/* using System.Collections.Generic; */ +/* using System.Threading; */ + + abstract class DecRefQueue + + private void ObjectInvariant() + + + + readonly protected Object mLock = new Object(); + readonly protected List mQueue = new List(); + const Integer mMoveLimit = 1024; + + public abstract void IncRef(Context ctx, IntPtr obj); + public abstract void DecRef(Context ctx, IntPtr obj); + + public void IncAndClear(Context ctx, IntPtr o) + + + IncRef(ctx, o); + if (mQueue.Count >= mMoveLimit) Clear(ctx); + + public void Add(IntPtr o) + if (o == IntPtr.Zero) return; + + lock (mLock) + mQueue.Add(o); + + public void Clear(Context ctx) + + + lock (mLock) + for (IntPtr.Iterator o = mQueue.iterator(); o.hasNext(); ) + DecRef(ctx, o); + mQueue.Clear(); + + abstract class DecRefQueueContracts : DecRefQueue + public void IncRef(Context ctx, IntPtr obj) + + + public void DecRef(Context ctx, IntPtr obj) + diff --git a/src/api/java/com/Microsoft/Z3/Expr.java b/src/api/java/com/Microsoft/Z3/Expr.java new file mode 100644 index 000000000..480f5f6b6 --- /dev/null +++ b/src/api/java/com/Microsoft/Z3/Expr.java @@ -0,0 +1,428 @@ +/** + * This file was automatically generated from Expr.cs + **/ + +package com.Microsoft.Z3; + +/* using System; */ + + /** + * Expressions are terms. + **/ + public class Expr extends AST + { + /** + * Returns a simplified version of the expression. + * A set of parameters to configure the simplifier + * + **/ + public Expr Simplify(Params p) + { + + + if (p == null) + return Expr.Create(Context, Native.simplify(Context.nCtx, NativeObject)); + else + return Expr.Create(Context, Native.simplifyEx(Context.nCtx, NativeObject, p.NativeObject)); + } + + /** + * The function declaration of the function that is applied in this expression. + **/ + public FuncDecl FuncDecl() { + + return new FuncDecl(Context, Native.getAppDecl(Context.nCtx, NativeObject)); } + + /** + * Indicates whether the expression is the true or false expression + * or something else (Z3_L_UNDEF). + **/ + public Z3_lboolean BoolValue() { return (Z3Lboolean)Native.getBooleanValue(Context.nCtx, NativeObject); } + + /** + * The number of arguments of the expression. + **/ + public Integer NumArgs() { return Native.getAppNumArgs(Context.nCtx, NativeObject); } + + /** + * The arguments of the expression. + **/ + public Expr[] Args() + { + + + Integer n = NumArgs; + Expr[] res = new Expr[n]; + for (Integer i = 0; i < n; i++) + res[i] = Expr.Create(Context, Native.getAppArg(Context.nCtx, NativeObject, i)); + return res; + } + + /** + * Update the arguments of the expression using the arguments + * The number of new arguments should coincide with the current number of arguments. + **/ + public void Update(Expr[] args) + { + + + + Context.CheckContextMatch(args); + if (args.Length != NumArgs) + throw new Z3Exception("Number of arguments does not match"); + NativeObject = Native.updateTerm(Context.nCtx, NativeObject, (Integer)args.Length, Expr.ArrayToNative(args)); + } + + /** + * Substitute every occurrence of from[i] in the expression with to[i], for i smaller than num_exprs. + * + * The result is the new expression. The arrays from and to must have size num_exprs. + * For every i smaller than num_exprs, we must have that + * sort of from[i] must be equal to sort of to[i]. + * + **/ + public Expr Substitute(Expr[] from, Expr[] to) + { + + + + + + + Context.CheckContextMatch(from); + Context.CheckContextMatch(to); + if (from.Length != to.Length) + throw new Z3Exception("Argument sizes do not match"); + return Expr.Create(Context, Native.substitute(Context.nCtx, NativeObject, (Integer)from.Length, Expr.ArrayToNative(from), Expr.ArrayToNative(to))); + } + + /** + * Substitute every occurrence of from in the expression with to. + * + **/ + public Expr Substitute(Expr from, Expr to) + { + + + + + return Substitute(new Expr[] { from }, new Expr[] { to }); + } + + /** + * Substitute the free variables in the expression with the expressions in + * + * For every i smaller than num_exprs, the variable with de-Bruijn index i is replaced with term to[i]. + * + **/ + public Expr SubstituteVars(Expr[] to) + { + + + + + Context.CheckContextMatch(to); + return Expr.Create(Context, Native.substituteVars(Context.nCtx, NativeObject, (Integer)to.Length, Expr.ArrayToNative(to))); + } + + /** + * Translates (copies) the term to the Context . + * A context + * @return A copy of the term which is associated with + **/ + public Expr Translate(Context ctx) + { + + + + if (ReferenceEquals(Context, ctx)) + return this; + else + return Expr.Create(ctx, Native.translate(Context.nCtx, NativeObject, ctx.nCtx)); + } + + /** + * Returns a string representation of the expression. + **/ + public String toString() + { + return super.toString(); + } + + /** + * Indicates whether the term is a numeral + **/ + public boolean IsNumeral() { return Native.isNumeralAst(Context.nCtx, NativeObject) != 0; } + + /** + * Indicates whether the term is well-sorted. + * @return True if the term is well-sorted, false otherwise. + **/ + public boolean IsWellSorted() { return Native.isWellSorted(Context.nCtx, NativeObject) != 0; } + + /** + * The Sort of the term. + **/ + public Sort Sort() { + + return Sort.Create(Context, Native.getSort(Context.nCtx, NativeObject)); } + + /** + * Indicates whether the term represents a constant. + **/ + public boolean IsConst() { return IsExpr && NumArgs == 0 && FuncDecl.DomainSize == 0; } + + /** + * Indicates whether the term is an integer numeral. + **/ + public boolean IsIntNum() { return IsNumeral && IsInt; } + + /** + * Indicates whether the term is a real numeral. + **/ + public boolean IsRatNum() { return IsNumeral && IsReal; } + + /** + * Indicates whether the term is an algebraic number + **/ + public boolean IsAlgebraicNumber() { return Native.isAlgebraicNumber(Context.nCtx, NativeObject) != 0; } + + + /** + * Indicates whether the term has Boolean sort. + **/ + public boolean IsBool() + { + return (IsExpr && + Native.isEqSort(Context.nCtx, + Native.mkBooleanSort(Context.nCtx), + Native.getSort(Context.nCtx, NativeObject)) != 0); + } + + /** + * Indicates whether the term is the constant true. + **/ + /* Overloaded operators are not translated. */ + } + + /** + * Indicates whether the term is of sort real. + **/ + public boolean IsReal() { return Native.getSortKind(Context.nCtx, Native.getSort(Context.nCtx, NativeObject)) == (Integer)Z3SortKind.Z3REALSORT; } + + /** + * Indicates whether the term is an arithmetic numeral. + **/ + /* Overloaded operators are not translated. */ + } + + /** + * Indicates whether the term is an array store. + * It satisfies select(store(a,i,v),j) = if i = j then v else select(a,j). + * Array store takes at least 3 arguments. + **/ + /* Overloaded operators are not translated. */ + + /** + * Indicates whether the term is a bit-vector numeral + **/ + /* Overloaded operators are not translated. */ + } + + /** + * Indicates whether the term is an relation store + * + * Insert a record into a relation. + * The function takes n+1 arguments, where the first argument is the relation and the remaining n elements + * correspond to the n columns of the relation. + * + **/ + /* Overloaded operators are not translated. */ + } + + /** + * Indicates whether the term is a less than predicate over a finite domain. + **/ + /* Overloaded operators are not translated. */ + } + + /** Constructor for Expr + **/ + protected Expr(Context ctx) { super(ctx); } + /** Constructor for Expr + **/ + protected Expr(Context ctx, IntPtr obj) { super(ctx, obj); } + + void CheckNativeObject(IntPtr obj) + { + if (Native.isApp(Context.nCtx, obj) == 0 && + (Z3AstKind)Native.getAstKind(Context.nCtx, obj) != Z3AstKind.Z3VARAST && + (Z3AstKind)Native.getAstKind(Context.nCtx, obj) != Z3AstKind.Z3QUANTIFIERAST) + throw new Z3Exception("Underlying object is not a term"); + super.CheckNativeObject(obj); + } + + static Expr Create(Context ctx, FuncDecl f, params Expr[] arguments) + { + + + + + IntPtr obj = Native.mkApp(ctx.nCtx, f.NativeObject, + AST.ArrayLength(arguments), + AST.ArrayToNative(arguments)); + return Create(ctx, obj); + } + + new static Expr Create(Context ctx, IntPtr obj) + { + + + + Z3AstKind k = (Z3AstKind)Native.getAstKind(ctx.nCtx, obj); + if (k == Z3AstKind.Z3QUANTIFIERAST) + return new Quantifier(ctx, obj); + IntPtr s = Native.getSort(ctx.nCtx, obj); + Z3SortKind sk = (Z3SortKind)Native.getSortKind(ctx.nCtx, s); + + if (Native.isAlgebraicNumber(ctx.nCtx, obj) != 0) // is this a numeral ast? + return new AlgebraicNum(ctx, obj); + + if (Native.isNumeralAst(ctx.nCtx, obj) != 0) + { + switch (sk) + { + case Z3SortKind.Z3INTSORT: return new IntNum(ctx, obj); + case Z3SortKind.Z3REALSORT: return new RatNum(ctx, obj); + case Z3SortKind.Z3BVSORT: return new BitVecNum(ctx, obj); + } + } + + switch (sk) + { + case Z3SortKind.Z3BOOLSORT: return new BoolExpr(ctx, obj); + case Z3SortKind.Z3INTSORT: return new IntExpr(ctx, obj); + case Z3SortKind.Z3REALSORT: return new RealExpr(ctx, obj); + case Z3SortKind.Z3BVSORT: return new BitVecExpr(ctx, obj); + case Z3SortKind.Z3ARRAYSORT: return new ArrayExpr(ctx, obj); + case Z3SortKind.Z3DATATYPESORT: return new DatatypeExpr(ctx, obj); + } + + return new Expr(ctx, obj); + } + } + + /** + * Boolean expressions + **/ + public class BoolExpr extends Expr + { + /** Constructor for BoolExpr + **/ + protected BoolExpr(Context ctx) { super(ctx); } + /** Constructor for BoolExpr + **/ + BoolExpr(Context ctx, IntPtr obj) { super(ctx, obj); } + } + + /** + * Arithmetic expressions (int/real) + **/ + public class ArithExpr extends Expr + { + /** Constructor for ArithExpr + **/ + protected ArithExpr(Context ctx) + { super(ctx); + + } + ArithExpr(Context ctx, IntPtr obj) + { super(ctx, obj); + + } + } + + /** + * Int expressions + **/ + public class IntExpr extends ArithExpr + { + /** Constructor for IntExpr + **/ + protected IntExpr(Context ctx) + { super(ctx); + + } + IntExpr(Context ctx, IntPtr obj) + { super(ctx, obj); + + } + } + + /** + * Real expressions + **/ + public class RealExpr extends ArithExpr + { + /** Constructor for RealExpr + **/ + protected RealExpr(Context ctx) + { super(ctx); + + } + RealExpr(Context ctx, IntPtr obj) + { super(ctx, obj); + + } + } + + /** + * Bit-vector expressions + **/ + public class BitVecExpr extends Expr + { + + /** + * The size of the sort of a bit-vector term. + **/ + public Integer SortSize() { return ((BitVecSort)Sort).Size; } + + /** Constructor for BitVecExpr + **/ + protected BitVecExpr(Context ctx) { super(ctx); } + BitVecExpr(Context ctx, IntPtr obj) { super(ctx, obj); } + } + + /** + * Array expressions + **/ + public class ArrayExpr extends Expr + { + /** Constructor for ArrayExpr + **/ + protected ArrayExpr(Context ctx) + { super(ctx); + + } + ArrayExpr(Context ctx, IntPtr obj) + { super(ctx, obj); + + } + } + + /** + * Datatype expressions + **/ + public class DatatypeExpr extends Expr + { + /** Constructor for DatatypeExpr + **/ + protected DatatypeExpr(Context ctx) + { super(ctx); + + } + DatatypeExpr(Context ctx, IntPtr obj) + { super(ctx, obj); + + } + } diff --git a/src/api/java/com/Microsoft/Z3/Fixedpoint.java b/src/api/java/com/Microsoft/Z3/Fixedpoint.java new file mode 100644 index 000000000..9d4f61c94 --- /dev/null +++ b/src/api/java/com/Microsoft/Z3/Fixedpoint.java @@ -0,0 +1,300 @@ +/** + * This file was automatically generated from Fixedpoint.cs + **/ + +package com.Microsoft.Z3; + +/* using System; */ + + /** + * Object for managing fixedpoints + **/ + public class Fixedpoint extends Z3Object + { + + /** + * A string that describes all available fixedpoint solver parameters. + **/ + public String Help() + { + + return Native.fixedpointGetHelp(Context.nCtx, NativeObject); + } + + /** + * Sets the fixedpoint solver parameters. + **/ + public void setParameters(Params value) + { + + Context.CheckContextMatch(value); + Native.fixedpointSetParams(Context.nCtx, NativeObject, value.NativeObject); + } + + /** + * Retrieves parameter descriptions for Fixedpoint solver. + **/ + public ParamDescrs ParameterDescriptions() { return new ParamDescrs(Context, Native.fixedpointGetParamDescrs(Context.nCtx, NativeObject)); } + + + /** + * Assert a constraint (or multiple) into the fixedpoint solver. + **/ + public void Assert(BoolExpr[] constraints) + { + + + + Context.CheckContextMatch(constraints); + for (BoolExpr.Iterator a = constraints.iterator(); a.hasNext(); ) + { + Native.fixedpointAssert(Context.nCtx, NativeObject, a.NativeObject); + } + } + + /** + * Register predicate as recursive relation. + **/ + public void RegisterRelation(FuncDecl f) + { + + + Context.CheckContextMatch(f); + Native.fixedpointRegisterRelation(Context.nCtx, NativeObject, f.NativeObject); + } + + /** + * Add rule into the fixedpoint solver. + **/ + public void AddRule(BoolExpr rule, Symbol name) + { + + + Context.CheckContextMatch(rule); + Native.fixedpointAddRule(Context.nCtx, NativeObject, rule.NativeObject, AST.GetNativeObject(name)); + } + + /** + * Add table fact to the fixedpoint solver. + **/ + public void AddFact(FuncDecl pred, Integer[] args) + { + + + + Context.CheckContextMatch(pred); + Native.fixedpointAddFact(Context.nCtx, NativeObject, pred.NativeObject, (Integer)args.Length, args); + } + + /** + * Query the fixedpoint solver. + * A query is a conjunction of constraints. The constraints may include the recursively defined relations. + * The query is satisfiable if there is an instance of the query variables and a derivation for it. + * The query is unsatisfiable if there are no derivations satisfying the query variables. + **/ + public Status Query(BoolExpr query) + { + + + Context.CheckContextMatch(query); + Z3Lboolean r = (Z3Lboolean)Native.fixedpointQuery(Context.nCtx, NativeObject, query.NativeObject); + switch (r) + { + case Z3Lboolean.Z3LTRUE: return Status.SATISFIABLE; + case Z3Lboolean.Z3LFALSE: return Status.UNSATISFIABLE; + default: return Status.UNKNOWN; + } + } + + /** + * Query the fixedpoint solver. + * A query is an array of relations. + * The query is satisfiable if there is an instance of some relation that is non-empty. + * The query is unsatisfiable if there are no derivations satisfying any of the relations. + **/ + public Status Query(FuncDecl[] relations) + { + + + + Context.CheckContextMatch(relations); + Z3Lboolean r = (Z3Lboolean)Native.fixedpointQueryRelations(Context.nCtx, NativeObject, + AST.ArrayLength(relations), AST.ArrayToNative(relations)); + switch (r) + { + case Z3Lboolean.Z3LTRUE: return Status.SATISFIABLE; + case Z3Lboolean.Z3LFALSE: return Status.UNSATISFIABLE; + default: return Status.UNKNOWN; + } + } + + /** + * Creates a backtracking point. + * + **/ + public void Push() + { + Native.fixedpointPush(Context.nCtx, NativeObject); + } + + /** + * Backtrack one backtracking point. + * Note that an exception is thrown if Pop is called without a corresponding Push + * + **/ + public void Pop() + { + Native.fixedpointPop(Context.nCtx, NativeObject); + } + + + /** + * Update named rule into in the fixedpoint solver. + **/ + public void UpdateRule(BoolExpr rule, Symbol name) + { + + + Context.CheckContextMatch(rule); + Native.fixedpointUpdateRule(Context.nCtx, NativeObject, rule.NativeObject, AST.GetNativeObject(name)); + } + + /** + * Retrieve satisfying instance or instances of solver, + * or definitions for the recursive predicates that show unsatisfiability. + **/ + public Expr GetAnswer() + { + IntPtr ans = Native.fixedpointGetAnswer(Context.nCtx, NativeObject); + return (ans == IntPtr.Zero) ? null : Expr.Create(Context, ans); + } + + /** + * Retrieve explanation why fixedpoint engine returned status Unknown. + **/ + public String GetReasonUnknown() + { + + + return Native.fixedpointGetReasonUnknown(Context.nCtx, NativeObject); + } + + /** + * Retrieve the number of levels explored for a given predicate. + **/ + public Integer GetNumLevels(FuncDecl predicate) + { + return Native.fixedpointGetNumLevels(Context.nCtx, NativeObject, predicate.NativeObject); + } + + /** + * Retrieve the cover of a predicate. + **/ + public Expr GetCoverDelta(int level, FuncDecl predicate) + { + IntPtr res = Native.fixedpointGetCoverDelta(Context.nCtx, NativeObject, level, predicate.NativeObject); + return (res == IntPtr.Zero) ? null : Expr.Create(Context, res); + } + + /** + * Add property about the predicate. + * The property is added at level. + **/ + public void AddCover(int level, FuncDecl predicate, Expr property) + { + Native.fixedpointAddCover(Context.nCtx, NativeObject, level, predicate.NativeObject, property.NativeObject); + } + + /** + * Retrieve internal string representation of fixedpoint object. + **/ + public String toString() + { + return Native.fixedpointtoString(Context.nCtx, NativeObject, 0, null); + } + + /** + * Instrument the Datalog engine on which table representation to use for recursive predicate. + **/ + public void SetPredicateRepresentation(FuncDecl f, Symbol[] kinds) + { + + + Native.fixedpointSetPredicateRepresentation(Context.nCtx, NativeObject, + f.NativeObject, AST.ArrayLength(kinds), Symbol.ArrayToNative(kinds)); + + } + + /** + * Convert benchmark given as set of axioms, rules and queries to a string. + **/ + public String toString(BoolExpr[] queries) + { + + return Native.fixedpointtoString(Context.nCtx, NativeObject, + AST.ArrayLength(queries), AST.ArrayToNative(queries)); + } + + /** + * Retrieve set of rules added to fixedpoint context. + **/ + public BoolExpr[] Rules {() + + + ASTVector v = new ASTVector(Context, Native.fixedpointGetRules(Context.nCtx, NativeObject)); + Integer n = v.Size; + BoolExpr[] res = new BoolExpr[n]; + for (Integer i = 0; i < n; i++) + res[i] = new BoolExpr(Context, v[i].NativeObject); + return res; + } + + /** + * Retrieve set of assertions added to fixedpoint context. + **/ + public BoolExpr[] Assertions {() + + + ASTVector v = new ASTVector(Context, Native.fixedpointGetAssertions(Context.nCtx, NativeObject)); + Integer n = v.Size; + BoolExpr[] res = new BoolExpr[n]; + for (Integer i = 0; i < n; i++) + res[i] = new BoolExpr(Context, v[i].NativeObject); + return res; + } + + + Fixedpoint(Context ctx, IntPtr obj) + { super(ctx, obj); + + } + Fixedpoint(Context ctx) + { super(ctx, Native.mkFixedpoint(ctx.nCtx)); + + } + + class DecRefQueue extends Z3.DecRefQueue + { + public void IncRef(Context ctx, IntPtr obj) + { + Native.fixedpointIncRef(ctx.nCtx, obj); + } + + public void DecRef(Context ctx, IntPtr obj) + { + Native.fixedpointDecRef(ctx.nCtx, obj); + } + }; + + void IncRef(IntPtr o) + { + Context.FixedpointDRQ.IncAndClear(Context, o); + super.IncRef(o); + } + + void DecRef(IntPtr o) + { + Context.FixedpointDRQ.Add(o); + super.DecRef(o); + } + } diff --git a/src/api/java/com/Microsoft/Z3/FuncDecl.java b/src/api/java/com/Microsoft/Z3/FuncDecl.java new file mode 100644 index 000000000..afd171813 --- /dev/null +++ b/src/api/java/com/Microsoft/Z3/FuncDecl.java @@ -0,0 +1,257 @@ +/** + * This file was automatically generated from FuncDecl.cs + **/ + +package com.Microsoft.Z3; + +/* using System; */ + + /** + * Function declarations. + **/ + public class FuncDecl extends AST + { + /** + * Comparison operator. + * @return True if and share the same context and are equal, false otherwise. + **/ + /* Overloaded operators are not translated. */ + + /** + * Comparison operator. + * @return True if and do not share the same context or are not equal, false otherwise. + **/ + /* Overloaded operators are not translated. */ + + /** + * Object comparison. + **/ + public boolean Equals(object o) + { + FuncDecl casted = o as FuncDecl; + if (casted == null) return false; + return this == casted; + } + + /** + * A hash code. + **/ + public int GetHashCode() + { + return super.GetHashCode(); + } + + /** + * A string representations of the function declaration. + **/ + public String toString() + { + return Native.funcDecltoString(Context.nCtx, NativeObject); + } + + /** + * Returns a unique identifier for the function declaration. + **/ + new public Integer Id() { return Native.getFuncDeclId(Context.nCtx, NativeObject); } + + /** + * The arity of the function declaration + **/ + public Integer Arity() { return Native.getArity(Context.nCtx, NativeObject); } + + /** + * The size of the domain of the function declaration + * + **/ + public Integer DomainSize() { return Native.getDomainSize(Context.nCtx, NativeObject); } + + /** + * The domain of the function declaration + **/ + public Sort[] Domain() + { + + + var n = DomainSize; + + Sort[] res = new Sort[n]; + for (Integer i = 0; i < n; i++) + res[i] = Sort.Create(Context, Native.getDomain(Context.nCtx, NativeObject, i)); + return res; + } + + /** + * The range of the function declaration + **/ + public Sort Range() { + + return Sort.Create(Context, Native.getRange(Context.nCtx, NativeObject)); } + + /** + * The kind of the function declaration. + **/ + public Z3_decl_kind DeclKind() { return (Z3DeclKind)Native.getDeclKind(Context.nCtx, NativeObject); } + + /** + * The name of the function declaration + **/ + public Symbol Name() { + + return Symbol.Create(Context, Native.getDeclName(Context.nCtx, NativeObject)); } + + /** + * The number of parameters of the function declaration + **/ + public Integer NumParameters() { return Native.getDeclNumParameters(Context.nCtx, NativeObject); } + + /** + * The parameters of the function declaration + **/ + public Parameter[] Parameters() + { + + + Integer num = NumParameters; + Parameter[] res = new Parameter[num]; + for (Integer i = 0; i < num; i++) + { + Z3ParameterKind k = (Z3ParameterKind)Native.getDeclParameterKind(Context.nCtx, NativeObject, i); + switch (k) + { + case Z3ParameterKind.Z3PARAMETERINT: + res[i] = new Parameter(k, Native.getDeclIntParameter(Context.nCtx, NativeObject, i)); + break; + case Z3ParameterKind.Z3PARAMETERDOUBLE: + res[i] = new Parameter(k, Native.getDeclDoubleParameter(Context.nCtx, NativeObject, i)); + break; + case Z3ParameterKind.Z3PARAMETERSYMBOL: + res[i] = new Parameter(k, Symbol.Create(Context, Native.getDeclSymbolParameter(Context.nCtx, NativeObject, i))); + break; + case Z3ParameterKind.Z3PARAMETERSORT: + res[i] = new Parameter(k, Sort.Create(Context, Native.getDeclSortParameter(Context.nCtx, NativeObject, i))); + break; + case Z3ParameterKind.Z3PARAMETERAST: + res[i] = new Parameter(k, new AST(Context, Native.getDeclAstParameter(Context.nCtx, NativeObject, i))); + break; + case Z3ParameterKind.Z3PARAMETERFUNCDECL: + res[i] = new Parameter(k, new FuncDecl(Context, Native.getDeclFuncDeclParameter(Context.nCtx, NativeObject, i))); + break; + case Z3ParameterKind.Z3PARAMETERRATIONAL: + res[i] = new Parameter(k, Native.getDeclRationalParameter(Context.nCtx, NativeObject, i)); + break; + default: + throw new Z3Exception("Unknown function declaration parameter kind encountered"); + } + return res; + } + } + + /** + * Function declarations can have Parameters associated with them. + **/ + public class Parameter + { + private Z3ParameterKind kind; + private int i; + private double d; + private Symbol sym; + private Sort srt; + private AST ast; + private FuncDecl fd; + private String r; + + /**The int value of the parameter. + **/ + /* Overloaded operators are not translated. */ + + Parameter(Z3ParameterKind k, double d) + { + this.kind = k; + this.d = d; + } + + Parameter(Z3ParameterKind k, Symbol s) + { + this.kind = k; + this.sym = s; + } + + Parameter(Z3ParameterKind k, Sort s) + { + this.kind = k; + this.srt = s; + } + + Parameter(Z3ParameterKind k, AST a) + { + this.kind = k; + this.ast = a; + } + + Parameter(Z3ParameterKind k, FuncDecl fd) + { + this.kind = k; + this.fd = fd; + } + + Parameter(Z3ParameterKind k, String r) + { + this.kind = k; + this.r = r; + } + } + + FuncDecl(Context ctx, IntPtr obj) { super(ctx, obj); + + } + + FuncDecl(Context ctx, Symbol name, Sort[] domain, Sort range) + : base(ctx, Native.mkFuncDecl(ctx.nCtx, name.NativeObject, + AST.ArrayLength(domain), AST.ArrayToNative(domain), + range.NativeObject)) + + + + } + + FuncDecl(Context ctx, String prefix, Sort[] domain, Sort range) + : base(ctx, Native.mkFreshFuncDecl(ctx.nCtx, prefix, + AST.ArrayLength(domain), AST.ArrayToNative(domain), + range.NativeObject)) + + + } + + void CheckNativeObject(IntPtr obj) + { + if (Native.getAstKind(Context.nCtx, obj) != (Integer)Z3AstKind.Z3FUNCDECLAST) + throw new Z3Exception("Underlying object is not a function declaration"); + super.CheckNativeObject(obj); + } + + /** + * Create expression that applies function to arguments. + * + * @return + **/ + public Expr this[params() lic Expr this[params Expr[] args] + public Expr this[params() { + + + return Apply(args); + } + + /** + * Create expression that applies function to arguments. + * + * @return + **/ + public Expr Apply(Expr[] args) + { + + + Context.CheckContextMatch(args); + return Expr.Create(Context, this, args); + } + + } diff --git a/src/api/java/com/Microsoft/Z3/FuncInterp.java b/src/api/java/com/Microsoft/Z3/FuncInterp.java new file mode 100644 index 000000000..e6b5dd7f1 --- /dev/null +++ b/src/api/java/com/Microsoft/Z3/FuncInterp.java @@ -0,0 +1,177 @@ +/** + * This file was automatically generated from FuncInterp.cs + **/ + +package com.Microsoft.Z3; + +/* using System; */ + + /** + * A function interpretation is represented as a finite map and an 'else' value. + * Each entry in the finite map represents the value of a function given a set of arguments. + **/ + public class FuncInterp extends Z3Object + { + /** + * An Entry object represents an element in the finite map used to encode + * a function interpretation. + **/ + public class Entry extends Z3Object + { + /** + * Return the (symbolic) value of this entry. + **/ + public Expr Value() { + + return Expr.Create(Context, Native.funcEntryGetValue(Context.nCtx, NativeObject)); } + + /** + * The number of arguments of the entry. + **/ + public Integer NumArgs() { return Native.funcEntryGetNumArgs(Context.nCtx, NativeObject); } + + /** + * The arguments of the function entry. + **/ + public Expr[] Args() + { + + + + Integer n = NumArgs; + Expr[] res = new Expr[n]; + for (Integer i = 0; i < n; i++) + res[i] = Expr.Create(Context, Native.funcEntryGetArg(Context.nCtx, NativeObject, i)); + return res; + } + + /** + * A string representation of the function entry. + **/ + public String toString() + { + Integer n = NumArgs; + String res = "["; + Expr[] args = Args; + for (Integer i = 0; i < n; i++) + res += args[i] + ", "; + return res + Value + "]"; + } + + Entry(Context ctx, IntPtr obj) { super(ctx, obj); } + + class DecRefQueue extends Z3.DecRefQueue + { + public void IncRef(Context ctx, IntPtr obj) + { + Native.funcEntryIncRef(ctx.nCtx, obj); + } + + public void DecRef(Context ctx, IntPtr obj) + { + Native.funcEntryDecRef(ctx.nCtx, obj); + } + }; + + void IncRef(IntPtr o) + { + Context.FuncEntryDRQ.IncAndClear(Context, o); + super.IncRef(o); + } + + void DecRef(IntPtr o) + { + Context.FuncEntryDRQ.Add(o); + super.DecRef(o); + } + }; + + /** + * The number of entries in the function interpretation. + **/ + public Integer NumEntries() { return Native.funcInterpGetNumEntries(Context.nCtx, NativeObject); } + + /** + * The entries in the function interpretation + **/ + public Entry[] Entries() + { + + Contract.Ensures(Contract.ForAll(0, Contract.Result().Length, + j => Contract.Result()[j] != null)); + + Integer n = NumEntries; + Entry[] res = new Entry[n]; + for (Integer i = 0; i < n; i++) + res[i] = new Entry(Context, Native.funcInterpGetEntry(Context.nCtx, NativeObject, i)); + return res; + } + + /** + * The (symbolic) `else' value of the function interpretation. + **/ + public Expr Else() { + + + return Expr.Create(Context, Native.funcInterpGetElse(Context.nCtx, NativeObject)); } + + /** + * The arity of the function interpretation + **/ + public Integer Arity() { return Native.funcInterpGetArity(Context.nCtx, NativeObject); } + + /** + * A string representation of the function interpretation. + **/ + public String toString() + { + String res = ""; + res += "["; + for (Entry.Iterator e = Entries.iterator(); e.hasNext(); ) + { + Integer n = e.NumArgs; + if (n > 1) res += "["; + Expr[] args = e.Args; + for (Integer i = 0; i < n; i++) + { + if (i != 0) res += ", "; + res += args[i]; + } + if (n > 1) res += "]"; + res += " -> " + e.Value + ", "; + } + res += "else -> " + Else; + res += "]"; + return res; + } + + FuncInterp(Context ctx, IntPtr obj) + { super(ctx, obj); + + } + + class DecRefQueue extends Z3.DecRefQueue + { + public void IncRef(Context ctx, IntPtr obj) + { + Native.funcInterpIncRef(ctx.nCtx, obj); + } + + public void DecRef(Context ctx, IntPtr obj) + { + Native.funcInterpDecRef(ctx.nCtx, obj); + } + }; + + void IncRef(IntPtr o) + { + Context.FuncInterpDRQ.IncAndClear(Context, o); + super.IncRef(o); + } + + void DecRef(IntPtr o) + { + Context.FuncInterpDRQ.Add(o); + super.DecRef(o); + } + } diff --git a/src/api/java/com/Microsoft/Z3/Goal.java b/src/api/java/com/Microsoft/Z3/Goal.java new file mode 100644 index 000000000..0042d2bac --- /dev/null +++ b/src/api/java/com/Microsoft/Z3/Goal.java @@ -0,0 +1,182 @@ +/** + * This file was automatically generated from Goal.cs + **/ + +package com.Microsoft.Z3; + +/* using System; */ + + /** + * A goal (aka problem). A goal is essentially a set + * of formulas, that can be solved and/or transformed using + * tactics and solvers. + **/ + public class Goal extends Z3Object + { + /** + * The precision of the goal. + * + * Goals can be transformed using over and under approximations. + * An under approximation is applied when the objective is to find a model for a given goal. + * An over approximation is applied when the objective is to find a proof for a given goal. + * + **/ + public Z3_goal_prec Precision() { return (Z3GoalPrec)Native.goalPrecision(Context.nCtx, NativeObject); } + + /** + * Indicates whether the goal is precise. + **/ + public boolean IsPrecise() { return Precision == Z3GoalPrec.Z3GOALPRECISE; } + /** + * Indicates whether the goal is an under-approximation. + **/ + public boolean IsUnderApproximation() { return Precision == Z3GoalPrec.Z3GOALUNDER; } + + /** + * Indicates whether the goal is an over-approximation. + **/ + public boolean IsOverApproximation() { return Precision == Z3GoalPrec.Z3GOALOVER; } + + /** + * Indicates whether the goal is garbage (i.e., the product of over- and under-approximations). + **/ + public boolean IsGarbage() { return Precision == Z3GoalPrec.Z3GOALUNDEROVER; } + + /** + * Adds the to the given goal. + **/ + public void Assert(BoolExpr[] constraints) + { + + + + Context.CheckContextMatch(constraints); + for (BoolExpr.Iterator c = constraints.iterator(); c.hasNext(); ) + { + // It was an assume, now made an assert just to be sure we do not regress + Native.goalAssert(Context.nCtx, NativeObject, c.NativeObject); + } + } + + /** + * Indicates whether the goal contains `false'. + **/ + public boolean Inconsistent() { return Native.goalInconsistent(Context.nCtx, NativeObject) != 0; } + + /** + * The depth of the goal. + * + * This tracks how many transformations were applied to it. + * + **/ + public Integer Depth() { return Native.goalDepth(Context.nCtx, NativeObject); } + + /** + * Erases all formulas from the given goal. + **/ + public void Reset() + { + Native.goalReset(Context.nCtx, NativeObject); + } + + /** + * The number of formulas in the goal. + **/ + public Integer Size() { return Native.goalSize(Context.nCtx, NativeObject); } + + /** + * The formulas in the goal. + **/ + public BoolExpr[] Formulas() + { + + + Integer n = Size; + BoolExpr[] res = new BoolExpr[n]; + for (Integer i = 0; i < n; i++) + res[i] = new BoolExpr(Context, Native.goalFormula(Context.nCtx, NativeObject, i)); + return res; + } + + /** + * The number of formulas, subformulas and terms in the goal. + **/ + public Integer NumExprs() { return Native.goalNumExprs(Context.nCtx, NativeObject); } + + /** + * Indicates whether the goal is empty, and it is precise or the product of an under approximation. + **/ + public boolean IsDecidedSat() { return Native.goalIsDecidedSat(Context.nCtx, NativeObject) != 0; } + + /** + * Indicates whether the goal contains `false', and it is precise or the product of an over approximation. + **/ + public boolean IsDecidedUnsat() { return Native.goalIsDecidedUnsat(Context.nCtx, NativeObject) != 0; } + + /** + * Translates (copies) the Goal to the target Context . + **/ + public Goal Translate(Context ctx) + { + + + return new Goal(ctx, Native.goalTranslate(Context.nCtx, NativeObject, ctx.nCtx)); + } + + /** + * Simplifies the goal. + * Essentially invokes the `simplify' tactic on the goal. + **/ + public Goal Simplify(Params p) + { + Tactic t = Context.MkTactic("simplify"); + ApplyResult res = t.Apply(this, p); + + if (res.NumSubgoals == 0) + return Context.MkGoal(); + else + return res.Subgoals[0]; + } + + /** + * Goal to string conversion. + * @return A string representation of the Goal. + **/ + public String toString() + { + return Native.goaltoString(Context.nCtx, NativeObject); + } + + Goal(Context ctx, IntPtr obj) { super(ctx, obj); } + + Goal(Context ctx, boolean models, boolean unsatCores, boolean proofs) + { super(ctx, Native.mkGoal(ctx.nCtx, (models); ? 1 : 0, (unsatCores) ? 1 : 0, (proofs) ? 1 : 0)) + + } + + class DecRefQueue extends Z3.DecRefQueue + { + public void IncRef(Context ctx, IntPtr obj) + { + Native.goalIncRef(ctx.nCtx, obj); + } + + public void DecRef(Context ctx, IntPtr obj) + { + Native.goalDecRef(ctx.nCtx, obj); + } + }; + + void IncRef(IntPtr o) + { + Context.GoalDRQ.IncAndClear(Context, o); + super.IncRef(o); + } + + void DecRef(IntPtr o) + { + Context.GoalDRQ.Add(o); + super.DecRef(o); + } + + } diff --git a/src/api/java/com/Microsoft/Z3/IDisposable.java b/src/api/java/com/Microsoft/Z3/IDisposable.java new file mode 100644 index 000000000..03885d1e7 --- /dev/null +++ b/src/api/java/com/Microsoft/Z3/IDisposable.java @@ -0,0 +1,25 @@ +/*++ +Copyright (c) 2012 Microsoft Corporation + +Module Name: + + IDisposable.java + +Abstract: + + Compatability interface (C# -> Java) + +Author: + + Christoph Wintersteiger (cwinter) 2012-03-16 + +Notes: + +--*/ + +package com.Microsoft.Z3; + +public class IDisposable +{ + public void Dispose() {} +} diff --git a/src/api/java/com/Microsoft/Z3/Log.java b/src/api/java/com/Microsoft/Z3/Log.java new file mode 100644 index 000000000..28a9e015e --- /dev/null +++ b/src/api/java/com/Microsoft/Z3/Log.java @@ -0,0 +1,60 @@ +/** + * This file was automatically generated from Log.cs + **/ + +package com.Microsoft.Z3; + +/* using System; */ + + /** + * Interaction logging for Z3. + * + * Note that this is a global, static log and if multiple Context + * objects are created, it logs the interaction with all of them. + * + **/ + public final class Log + { + private boolean mIsOpen = false; + + /** + * Open an interaction log file. + * the name of the file to open + * @return True if opening the log file succeeds, false otherwise. + **/ + public boolean Open(String filename) + { + mIsOpen = true; + return Native.openLog(filename) == 1; + } + + /** + * Closes the interaction log. + **/ + public void Close() + { + mIsOpen = false; + Native.closeLog(); + } + + /** + * Appends the user-provided string to the interaction log. + **/ + public void Append(String s) + { + + + if (!mIsOpen) + throw new Z3Exception("Log cannot be closed."); + Native.appendLog(s); + } + + /** + * Checks whether the interaction log is opened. + * @return True if the interaction log is open, false otherwise. + **/ + public boolean isOpen() + { + return mIsOpen; + } + } diff --git a/src/api/java/com/Microsoft/Z3/Model.java b/src/api/java/com/Microsoft/Z3/Model.java new file mode 100644 index 000000000..467d5e566 --- /dev/null +++ b/src/api/java/com/Microsoft/Z3/Model.java @@ -0,0 +1,279 @@ +/** + * This file was automatically generated from Model.cs + **/ + +package com.Microsoft.Z3; + +/* using System; */ + + /** + * A Model contains interpretations (assignments) of constants and functions. + **/ + public class Model extends Z3Object + { + /** + * Retrieves the interpretation (the assignment) of in the model. + * A Constant + * @return An expression if the constant has an interpretation in the model, null otherwise. + **/ + public Expr ConstInterp(Expr a) + { + + + Context.CheckContextMatch(a); + return ConstInterp(a.FuncDecl); + } + + /** + * Retrieves the interpretation (the assignment) of in the model. + * A function declaration of zero arity + * @return An expression if the function has an interpretation in the model, null otherwise. + **/ + public Expr ConstInterp(FuncDecl f) + { + + + Context.CheckContextMatch(f); + if (f.Arity != 0 || + Native.getSortKind(Context.nCtx, Native.getRange(Context.nCtx, f.NativeObject)) == (Integer)Z3SortKind.Z3ARRAYSORT) + throw new Z3Exception("Non-zero arity functions and arrays have FunctionInterpretations as a model. Use FuncInterp."); + + IntPtr n = Native.modelGetConstInterp(Context.nCtx, NativeObject, f.NativeObject); + if (n == IntPtr.Zero) + return null; + else + return Expr.Create(Context, n); + } + + /** + * Retrieves the interpretation (the assignment) of a non-constant in the model. + * A function declaration of non-zero arity + * @return A FunctionInterpretation if the function has an interpretation in the model, null otherwise. + **/ + public FuncInterp FuncInterp(FuncDecl f) + { + + + Context.CheckContextMatch(f); + + Z3SortKind sk = (Z3SortKind)Native.getSortKind(Context.nCtx, Native.getRange(Context.nCtx, f.NativeObject)); + + if (f.Arity == 0) + { + IntPtr n = Native.modelGetConstInterp(Context.nCtx, NativeObject, f.NativeObject); + + if (sk == Z3SortKind.Z3ARRAYSORT) + { + if (n == IntPtr.Zero) + return null; + else + { + if (Native.isAsArray(Context.nCtx, n) == 0) + throw new Z3Exception("Argument was not an array constant"); + IntPtr fd = Native.getAsArrayFuncDecl(Context.nCtx, n); + return FuncInterp(new FuncDecl(Context, fd)); + } + } + else + { + throw new Z3Exception("Constant functions do not have a function interpretation; use ConstInterp"); + } + } + else + { + IntPtr n = Native.modelGetFuncInterp(Context.nCtx, NativeObject, f.NativeObject); + if (n == IntPtr.Zero) + return null; + else + return new FuncInterp(Context, n); + } + } + + /** + * The number of constants that have an interpretation in the model. + **/ + public Integer NumConsts() { return Native.modelGetNumConsts(Context.nCtx, NativeObject); } + + /** + * The function declarations of the constants in the model. + **/ + public FuncDecl[] ConstDecls() + { + + + Integer n = NumConsts; + FuncDecl[] res = new FuncDecl[n]; + for (Integer i = 0; i < n; i++) + res[i] = new FuncDecl(Context, Native.modelGetConstDecl(Context.nCtx, NativeObject, i)); + return res; + } + + /** + * The number of function interpretations in the model. + **/ + public Integer NumFuncs() { return Native.modelGetNumFuncs(Context.nCtx, NativeObject); } + + /** + * The function declarations of the function interpretations in the model. + **/ + public FuncDecl[] FuncDecls() + { + + + Integer n = NumFuncs; + FuncDecl[] res = new FuncDecl[n]; + for (Integer i = 0; i < n; i++) + res[i] = new FuncDecl(Context, Native.modelGetFuncDecl(Context.nCtx, NativeObject, i)); + return res; + } + + /** + * All symbols that have an interpretation in the model. + **/ + public FuncDecl[] Decls() + { + + + var nFuncs = NumFuncs; + var nConsts = NumConsts; + Integer n = nFuncs + nConsts; + FuncDecl[] res = new FuncDecl[n]; + for (Integer i = 0; i < nConsts; i++) + res[i] = new FuncDecl(Context, Native.modelGetConstDecl(Context.nCtx, NativeObject, i)); + for (Integer i = 0; i < nFuncs; i++) + res[nConsts + i] = new FuncDecl(Context, Native.modelGetFuncDecl(Context.nCtx, NativeObject, i)); + return res; + } + + /** + * A ModelEvaluationFailedException is thrown when an expression cannot be evaluated by the model. + **/ + public class ModelEvaluationFailedException extends Z3Exception + { + /** + * An exception that is thrown when model evaluation fails. + **/ + public ModelEvaluationFailedException() { super(); } + } + + /** + * Evaluates the expression in the current model. + * + * This function may fail if contains quantifiers, + * is partial (MODEL_PARTIAL enabled), or if is not well-sorted. + * In this case a ModelEvaluationFailedException is thrown. + * + * An expression + * + * When this flag is enabled, a model value will be assigned to any constant + * or function that does not have an interpretation in the model. + * + * @return The evaluation of in the model. + **/ + public Expr Eval(Expr t, boolean completion) + { + + + + IntPtr v = IntPtr.Zero; + if (Native.modelEval(Context.nCtx, NativeObject, t.NativeObject, (completion) ? 1 : 0, v) == 0) + throw new ModelEvaluationFailedException(); + else + return Expr.Create(Context, v); + } + + /** + * Alias for Eval. + **/ + public Expr Evaluate(Expr t, boolean completion) + { + + + + return Eval(t, completion); + } + + /** + * The number of uninterpreted sorts that the model has an interpretation for. + **/ + public Integer NumSorts () { return Native.modelGetNumSorts(Context.nCtx, NativeObject); } + + /** + * The uninterpreted sorts that the model has an interpretation for. + * + * Z3 also provides an intepretation for uninterpreted sorts used in a formula. + * The interpretation for a sort is a finite set of distinct values. We say this finite set is + * the "universe" of the sort. + * + * + * + **/ + public Sort[] Sorts() + { + + + Integer n = NumSorts; + Sort[] res = new Sort[n]; + for (Integer i = 0; i < n; i++) + res[i] = Sort.Create(Context, Native.modelGetSort(Context.nCtx, NativeObject, i)); + return res; + } + + /** + * The finite set of distinct values that represent the interpretation for sort . + * + * An uninterpreted sort + * @return An array of expressions, where each is an element of the universe of + **/ + public Expr[] SortUniverse(Sort s) + { + + + + ASTVector nUniv = new ASTVector(Context, Native.modelGetSortUniverse(Context.nCtx, NativeObject, s.NativeObject)); + Integer n = nUniv.Size; + Expr[] res = new Expr[n]; + for (Integer i = 0; i < n; i++) + res[i] = Expr.Create(Context, nUniv[i].NativeObject); + return res; + } + + /** + * Conversion of models to strings. + * @return A string representation of the model. + **/ + public String toString() + { + return Native.modeltoString(Context.nCtx, NativeObject); + } + + Model(Context ctx, IntPtr obj) + { super(ctx, obj); + + } + + class DecRefQueue extends Z3.DecRefQueue + { + public void IncRef(Context ctx, IntPtr obj) + { + Native.modelIncRef(ctx.nCtx, obj); + } + + public void DecRef(Context ctx, IntPtr obj) + { + Native.modelDecRef(ctx.nCtx, obj); + } + }; + + void IncRef(IntPtr o) + { + Context.ModelDRQ.IncAndClear(Context, o); + super.IncRef(o); + } + + void DecRef(IntPtr o) + { + Context.ModelDRQ.Add(o); + super.DecRef(o); + } + } diff --git a/src/api/java/com/Microsoft/Z3/Native.c b/src/api/java/com/Microsoft/Z3/Native.c new file mode 100644 index 000000000..653e32bc5 --- /dev/null +++ b/src/api/java/com/Microsoft/Z3/Native.c @@ -0,0 +1,2259 @@ +// Automatically generated file +#include +#include +#include"z3.h" +#ifdef __cplusplus +extern "C" { +#endif +JNIEXPORT jlong JNICALL Java_Z3Native_mkConfig(JNIEnv * jenv, jclass cls) { + Z3_config result = Z3_mk_config(); + return (jlong) result; +} +JNIEXPORT void JNICALL Java_Z3Native_delConfig(JNIEnv * jenv, jclass cls, jlong a0) { + Z3_del_config((Z3_config)a0); +} +JNIEXPORT void JNICALL Java_Z3Native_setParamValue(JNIEnv * jenv, jclass cls, jlong a0, jstring a1, jstring a2) { + Z3_string _a1 = (Z3_string) jenv->GetStringUTFChars(a1, NULL); + Z3_string _a2 = (Z3_string) jenv->GetStringUTFChars(a2, NULL); + Z3_set_param_value((Z3_config)a0, _a1, _a2); +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkContext(JNIEnv * jenv, jclass cls, jlong a0) { + Z3_context result = Z3_mk_context((Z3_config)a0); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkContextRc(JNIEnv * jenv, jclass cls, jlong a0) { + Z3_context result = Z3_mk_context_rc((Z3_config)a0); + return (jlong) result; +} +JNIEXPORT void JNICALL Java_Z3Native_delContext(JNIEnv * jenv, jclass cls, jlong a0) { + Z3_del_context((Z3_context)a0); +} +JNIEXPORT void JNICALL Java_Z3Native_incRef(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_inc_ref((Z3_context)a0, (Z3_ast)a1); +} +JNIEXPORT void JNICALL Java_Z3Native_decRef(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_dec_ref((Z3_context)a0, (Z3_ast)a1); +} +JNIEXPORT void JNICALL Java_Z3Native_updateParamValue(JNIEnv * jenv, jclass cls, jlong a0, jstring a1, jstring a2) { + Z3_string _a1 = (Z3_string) jenv->GetStringUTFChars(a1, NULL); + Z3_string _a2 = (Z3_string) jenv->GetStringUTFChars(a2, NULL); + Z3_update_param_value((Z3_context)a0, _a1, _a2); +} +JNIEXPORT jboolean JNICALL Java_Z3Native_getParamValue(JNIEnv * jenv, jclass cls, jlong a0, jstring a1, jobject a2) { + Z3_string _a1 = (Z3_string) jenv->GetStringUTFChars(a1, NULL); + Z3_string _a2; + Z3_bool result = Z3_get_param_value((Z3_context)a0, _a1, &_a2); + { + jclass mc = jenv->GetObjectClass(a2); + jfieldID fid = jenv->GetFieldID(mc, "value", "J"); + jenv->SetLongField(a2, fid, (jlong) _a2); + } + return (jboolean) result; +} +JNIEXPORT void JNICALL Java_Z3Native_interrupt(JNIEnv * jenv, jclass cls, jlong a0) { + Z3_interrupt((Z3_context)a0); +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkParams(JNIEnv * jenv, jclass cls, jlong a0) { + Z3_params result = Z3_mk_params((Z3_context)a0); + return (jlong) result; +} +JNIEXPORT void JNICALL Java_Z3Native_paramsIncRef(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_params_inc_ref((Z3_context)a0, (Z3_params)a1); +} +JNIEXPORT void JNICALL Java_Z3Native_paramsDecRef(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_params_dec_ref((Z3_context)a0, (Z3_params)a1); +} +JNIEXPORT void JNICALL Java_Z3Native_paramsSetBool(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2, jboolean a3) { + Z3_params_set_bool((Z3_context)a0, (Z3_params)a1, (Z3_symbol)a2, (Z3_bool)a3); +} +JNIEXPORT void JNICALL Java_Z3Native_paramsSetUint(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2, jint a3) { + Z3_params_set_uint((Z3_context)a0, (Z3_params)a1, (Z3_symbol)a2, (unsigned)a3); +} +JNIEXPORT void JNICALL Java_Z3Native_paramsSetDouble(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2, jdouble a3) { + Z3_params_set_double((Z3_context)a0, (Z3_params)a1, (Z3_symbol)a2, (double)a3); +} +JNIEXPORT void JNICALL Java_Z3Native_paramsSetSymbol(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2, jlong a3) { + Z3_params_set_symbol((Z3_context)a0, (Z3_params)a1, (Z3_symbol)a2, (Z3_symbol)a3); +} +JNIEXPORT jstring JNICALL Java_Z3Native_paramsToString(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_string result = Z3_params_to_string((Z3_context)a0, (Z3_params)a1); + return jenv->NewStringUTF(result); +} +JNIEXPORT void JNICALL Java_Z3Native_paramsValidate(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2) { + Z3_params_validate((Z3_context)a0, (Z3_params)a1, (Z3_param_descrs)a2); +} +JNIEXPORT void JNICALL Java_Z3Native_paramDescrsIncRef(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_param_descrs_inc_ref((Z3_context)a0, (Z3_param_descrs)a1); +} +JNIEXPORT void JNICALL Java_Z3Native_paramDescrsDecRef(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_param_descrs_dec_ref((Z3_context)a0, (Z3_param_descrs)a1); +} +JNIEXPORT jint JNICALL Java_Z3Native_paramDescrsGetKind(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2) { + unsigned result = Z3_param_descrs_get_kind((Z3_context)a0, (Z3_param_descrs)a1, (Z3_symbol)a2); + return (jint) result; +} +JNIEXPORT jint JNICALL Java_Z3Native_paramDescrsSize(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + unsigned result = Z3_param_descrs_size((Z3_context)a0, (Z3_param_descrs)a1); + return (jint) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_paramDescrsGetName(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jint a2) { + Z3_symbol result = Z3_param_descrs_get_name((Z3_context)a0, (Z3_param_descrs)a1, (unsigned)a2); + return (jlong) result; +} +JNIEXPORT jstring JNICALL Java_Z3Native_paramDescrsToString(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_string result = Z3_param_descrs_to_string((Z3_context)a0, (Z3_param_descrs)a1); + return jenv->NewStringUTF(result); +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkIntSymbol(JNIEnv * jenv, jclass cls, jlong a0, jint a1) { + Z3_symbol result = Z3_mk_int_symbol((Z3_context)a0, (int)a1); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkStringSymbol(JNIEnv * jenv, jclass cls, jlong a0, jstring a1) { + Z3_string _a1 = (Z3_string) jenv->GetStringUTFChars(a1, NULL); + Z3_symbol result = Z3_mk_string_symbol((Z3_context)a0, _a1); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkUninterpretedSort(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_sort result = Z3_mk_uninterpreted_sort((Z3_context)a0, (Z3_symbol)a1); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkBoolSort(JNIEnv * jenv, jclass cls, jlong a0) { + Z3_sort result = Z3_mk_bool_sort((Z3_context)a0); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkIntSort(JNIEnv * jenv, jclass cls, jlong a0) { + Z3_sort result = Z3_mk_int_sort((Z3_context)a0); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkRealSort(JNIEnv * jenv, jclass cls, jlong a0) { + Z3_sort result = Z3_mk_real_sort((Z3_context)a0); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkBvSort(JNIEnv * jenv, jclass cls, jlong a0, jint a1) { + Z3_sort result = Z3_mk_bv_sort((Z3_context)a0, (unsigned)a1); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkFiniteDomainSort(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2) { + Z3_sort result = Z3_mk_finite_domain_sort((Z3_context)a0, (Z3_symbol)a1, (__uint64)a2); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkArraySort(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2) { + Z3_sort result = Z3_mk_array_sort((Z3_context)a0, (Z3_sort)a1, (Z3_sort)a2); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkTupleSort(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jint a2, jlongArray a3, jlongArray a4, jobject a5, jlongArray a6) { + Z3_symbol * _a3 = (Z3_symbol *) jenv->GetLongArrayElements(a3, NULL); + Z3_sort * _a4 = (Z3_sort *) jenv->GetLongArrayElements(a4, NULL); + Z3_func_decl _a5; + Z3_func_decl * _a6 = (Z3_func_decl *) malloc(((unsigned)a2) * sizeof(Z3_func_decl)); + Z3_sort result = Z3_mk_tuple_sort((Z3_context)a0, (Z3_symbol)a1, (unsigned)a2, _a3, _a4, &_a5, _a6); + jenv->ReleaseLongArrayElements(a3, (jlong *) _a3, JNI_ABORT); + jenv->ReleaseLongArrayElements(a4, (jlong *) _a4, JNI_ABORT); + { + jclass mc = jenv->GetObjectClass(a5); + jfieldID fid = jenv->GetFieldID(mc, "value", "J"); + jenv->SetLongField(a5, fid, (jlong) _a5); + } + jenv->SetLongArrayRegion(a6, 0, (jsize)a2, (jlong *) _a6); + free(_a6); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkEnumerationSort(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jint a2, jlongArray a3, jlongArray a4, jlongArray a5) { + Z3_symbol * _a3 = (Z3_symbol *) jenv->GetLongArrayElements(a3, NULL); + Z3_func_decl * _a4 = (Z3_func_decl *) malloc(((unsigned)a2) * sizeof(Z3_func_decl)); + Z3_func_decl * _a5 = (Z3_func_decl *) malloc(((unsigned)a2) * sizeof(Z3_func_decl)); + Z3_sort result = Z3_mk_enumeration_sort((Z3_context)a0, (Z3_symbol)a1, (unsigned)a2, _a3, _a4, _a5); + jenv->ReleaseLongArrayElements(a3, (jlong *) _a3, JNI_ABORT); + jenv->SetLongArrayRegion(a4, 0, (jsize)a2, (jlong *) _a4); + free(_a4); + jenv->SetLongArrayRegion(a5, 0, (jsize)a2, (jlong *) _a5); + free(_a5); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkListSort(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2, jobject a3, jobject a4, jobject a5, jobject a6, jobject a7, jobject a8) { + Z3_func_decl _a3; + Z3_func_decl _a4; + Z3_func_decl _a5; + Z3_func_decl _a6; + Z3_func_decl _a7; + Z3_func_decl _a8; + Z3_sort result = Z3_mk_list_sort((Z3_context)a0, (Z3_symbol)a1, (Z3_sort)a2, &_a3, &_a4, &_a5, &_a6, &_a7, &_a8); + { + jclass mc = jenv->GetObjectClass(a3); + jfieldID fid = jenv->GetFieldID(mc, "value", "J"); + jenv->SetLongField(a3, fid, (jlong) _a3); + } + { + jclass mc = jenv->GetObjectClass(a4); + jfieldID fid = jenv->GetFieldID(mc, "value", "J"); + jenv->SetLongField(a4, fid, (jlong) _a4); + } + { + jclass mc = jenv->GetObjectClass(a5); + jfieldID fid = jenv->GetFieldID(mc, "value", "J"); + jenv->SetLongField(a5, fid, (jlong) _a5); + } + { + jclass mc = jenv->GetObjectClass(a6); + jfieldID fid = jenv->GetFieldID(mc, "value", "J"); + jenv->SetLongField(a6, fid, (jlong) _a6); + } + { + jclass mc = jenv->GetObjectClass(a7); + jfieldID fid = jenv->GetFieldID(mc, "value", "J"); + jenv->SetLongField(a7, fid, (jlong) _a7); + } + { + jclass mc = jenv->GetObjectClass(a8); + jfieldID fid = jenv->GetFieldID(mc, "value", "J"); + jenv->SetLongField(a8, fid, (jlong) _a8); + } + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkConstructor(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2, jint a3, jlongArray a4, jlongArray a5, jintArray a6) { + Z3_symbol * _a4 = (Z3_symbol *) jenv->GetLongArrayElements(a4, NULL); + Z3_sort * _a5 = (Z3_sort *) jenv->GetLongArrayElements(a5, NULL); + unsigned * _a6 = (unsigned *) jenv->GetIntArrayElements(a6, NULL); + Z3_constructor result = Z3_mk_constructor((Z3_context)a0, (Z3_symbol)a1, (Z3_symbol)a2, (unsigned)a3, _a4, _a5, _a6); + jenv->ReleaseLongArrayElements(a4, (jlong *) _a4, JNI_ABORT); + jenv->ReleaseLongArrayElements(a5, (jlong *) _a5, JNI_ABORT); + jenv->ReleaseIntArrayElements(a6, (jint *) _a6, JNI_ABORT); + return (jlong) result; +} +JNIEXPORT void JNICALL Java_Z3Native_delConstructor(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_del_constructor((Z3_context)a0, (Z3_constructor)a1); +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkDatatype(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jint a2, jlongArray a3) { + Z3_constructor * _a3 = (Z3_constructor *) jenv->GetLongArrayElements(a3, NULL); + Z3_sort result = Z3_mk_datatype((Z3_context)a0, (Z3_symbol)a1, (unsigned)a2, _a3); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkConstructorList(JNIEnv * jenv, jclass cls, jlong a0, jint a1, jlongArray a2) { + Z3_constructor * _a2 = (Z3_constructor *) jenv->GetLongArrayElements(a2, NULL); + Z3_constructor_list result = Z3_mk_constructor_list((Z3_context)a0, (unsigned)a1, _a2); + jenv->ReleaseLongArrayElements(a2, (jlong *) _a2, JNI_ABORT); + return (jlong) result; +} +JNIEXPORT void JNICALL Java_Z3Native_delConstructorList(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_del_constructor_list((Z3_context)a0, (Z3_constructor_list)a1); +} +JNIEXPORT void JNICALL Java_Z3Native_mkDatatypes(JNIEnv * jenv, jclass cls, jlong a0, jint a1, jlongArray a2, jlongArray a3, jlongArray a4) { + Z3_symbol * _a2 = (Z3_symbol *) jenv->GetLongArrayElements(a2, NULL); + Z3_sort * _a3 = (Z3_sort *) malloc(((unsigned)a1) * sizeof(Z3_sort)); + Z3_constructor_list * _a4 = (Z3_constructor_list *) jenv->GetLongArrayElements(a4, NULL); + Z3_mk_datatypes((Z3_context)a0, (unsigned)a1, _a2, _a3, _a4); + jenv->ReleaseLongArrayElements(a2, (jlong *) _a2, JNI_ABORT); + jenv->SetLongArrayRegion(a3, 0, (jsize)a1, (jlong *) _a3); + free(_a3); +} +JNIEXPORT void JNICALL Java_Z3Native_queryConstructor(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jint a2, jobject a3, jobject a4, jlongArray a5) { + Z3_func_decl _a3; + Z3_func_decl _a4; + Z3_func_decl * _a5 = (Z3_func_decl *) malloc(((unsigned)a2) * sizeof(Z3_func_decl)); + Z3_query_constructor((Z3_context)a0, (Z3_constructor)a1, (unsigned)a2, &_a3, &_a4, _a5); + { + jclass mc = jenv->GetObjectClass(a3); + jfieldID fid = jenv->GetFieldID(mc, "value", "J"); + jenv->SetLongField(a3, fid, (jlong) _a3); + } + { + jclass mc = jenv->GetObjectClass(a4); + jfieldID fid = jenv->GetFieldID(mc, "value", "J"); + jenv->SetLongField(a4, fid, (jlong) _a4); + } + jenv->SetLongArrayRegion(a5, 0, (jsize)a2, (jlong *) _a5); + free(_a5); +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkFuncDecl(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jint a2, jlongArray a3, jlong a4) { + Z3_sort * _a3 = (Z3_sort *) jenv->GetLongArrayElements(a3, NULL); + Z3_func_decl result = Z3_mk_func_decl((Z3_context)a0, (Z3_symbol)a1, (unsigned)a2, _a3, (Z3_sort)a4); + jenv->ReleaseLongArrayElements(a3, (jlong *) _a3, JNI_ABORT); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkApp(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jint a2, jlongArray a3) { + Z3_ast * _a3 = (Z3_ast *) jenv->GetLongArrayElements(a3, NULL); + Z3_ast result = Z3_mk_app((Z3_context)a0, (Z3_func_decl)a1, (unsigned)a2, _a3); + jenv->ReleaseLongArrayElements(a3, (jlong *) _a3, JNI_ABORT); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkConst(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2) { + Z3_ast result = Z3_mk_const((Z3_context)a0, (Z3_symbol)a1, (Z3_sort)a2); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkFreshFuncDecl(JNIEnv * jenv, jclass cls, jlong a0, jstring a1, jint a2, jlongArray a3, jlong a4) { + Z3_string _a1 = (Z3_string) jenv->GetStringUTFChars(a1, NULL); + Z3_sort * _a3 = (Z3_sort *) jenv->GetLongArrayElements(a3, NULL); + Z3_func_decl result = Z3_mk_fresh_func_decl((Z3_context)a0, _a1, (unsigned)a2, _a3, (Z3_sort)a4); + jenv->ReleaseLongArrayElements(a3, (jlong *) _a3, JNI_ABORT); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkFreshConst(JNIEnv * jenv, jclass cls, jlong a0, jstring a1, jlong a2) { + Z3_string _a1 = (Z3_string) jenv->GetStringUTFChars(a1, NULL); + Z3_ast result = Z3_mk_fresh_const((Z3_context)a0, _a1, (Z3_sort)a2); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkTrue(JNIEnv * jenv, jclass cls, jlong a0) { + Z3_ast result = Z3_mk_true((Z3_context)a0); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkFalse(JNIEnv * jenv, jclass cls, jlong a0) { + Z3_ast result = Z3_mk_false((Z3_context)a0); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkEq(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2) { + Z3_ast result = Z3_mk_eq((Z3_context)a0, (Z3_ast)a1, (Z3_ast)a2); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkDistinct(JNIEnv * jenv, jclass cls, jlong a0, jint a1, jlongArray a2) { + Z3_ast * _a2 = (Z3_ast *) jenv->GetLongArrayElements(a2, NULL); + Z3_ast result = Z3_mk_distinct((Z3_context)a0, (unsigned)a1, _a2); + jenv->ReleaseLongArrayElements(a2, (jlong *) _a2, JNI_ABORT); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkNot(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_ast result = Z3_mk_not((Z3_context)a0, (Z3_ast)a1); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkIte(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2, jlong a3) { + Z3_ast result = Z3_mk_ite((Z3_context)a0, (Z3_ast)a1, (Z3_ast)a2, (Z3_ast)a3); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkIff(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2) { + Z3_ast result = Z3_mk_iff((Z3_context)a0, (Z3_ast)a1, (Z3_ast)a2); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkImplies(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2) { + Z3_ast result = Z3_mk_implies((Z3_context)a0, (Z3_ast)a1, (Z3_ast)a2); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkXor(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2) { + Z3_ast result = Z3_mk_xor((Z3_context)a0, (Z3_ast)a1, (Z3_ast)a2); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkAnd(JNIEnv * jenv, jclass cls, jlong a0, jint a1, jlongArray a2) { + Z3_ast * _a2 = (Z3_ast *) jenv->GetLongArrayElements(a2, NULL); + Z3_ast result = Z3_mk_and((Z3_context)a0, (unsigned)a1, _a2); + jenv->ReleaseLongArrayElements(a2, (jlong *) _a2, JNI_ABORT); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkOr(JNIEnv * jenv, jclass cls, jlong a0, jint a1, jlongArray a2) { + Z3_ast * _a2 = (Z3_ast *) jenv->GetLongArrayElements(a2, NULL); + Z3_ast result = Z3_mk_or((Z3_context)a0, (unsigned)a1, _a2); + jenv->ReleaseLongArrayElements(a2, (jlong *) _a2, JNI_ABORT); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkAdd(JNIEnv * jenv, jclass cls, jlong a0, jint a1, jlongArray a2) { + Z3_ast * _a2 = (Z3_ast *) jenv->GetLongArrayElements(a2, NULL); + Z3_ast result = Z3_mk_add((Z3_context)a0, (unsigned)a1, _a2); + jenv->ReleaseLongArrayElements(a2, (jlong *) _a2, JNI_ABORT); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkMul(JNIEnv * jenv, jclass cls, jlong a0, jint a1, jlongArray a2) { + Z3_ast * _a2 = (Z3_ast *) jenv->GetLongArrayElements(a2, NULL); + Z3_ast result = Z3_mk_mul((Z3_context)a0, (unsigned)a1, _a2); + jenv->ReleaseLongArrayElements(a2, (jlong *) _a2, JNI_ABORT); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkSub(JNIEnv * jenv, jclass cls, jlong a0, jint a1, jlongArray a2) { + Z3_ast * _a2 = (Z3_ast *) jenv->GetLongArrayElements(a2, NULL); + Z3_ast result = Z3_mk_sub((Z3_context)a0, (unsigned)a1, _a2); + jenv->ReleaseLongArrayElements(a2, (jlong *) _a2, JNI_ABORT); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkUnaryMinus(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_ast result = Z3_mk_unary_minus((Z3_context)a0, (Z3_ast)a1); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkDiv(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2) { + Z3_ast result = Z3_mk_div((Z3_context)a0, (Z3_ast)a1, (Z3_ast)a2); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkMod(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2) { + Z3_ast result = Z3_mk_mod((Z3_context)a0, (Z3_ast)a1, (Z3_ast)a2); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkRem(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2) { + Z3_ast result = Z3_mk_rem((Z3_context)a0, (Z3_ast)a1, (Z3_ast)a2); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkPower(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2) { + Z3_ast result = Z3_mk_power((Z3_context)a0, (Z3_ast)a1, (Z3_ast)a2); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkLt(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2) { + Z3_ast result = Z3_mk_lt((Z3_context)a0, (Z3_ast)a1, (Z3_ast)a2); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkLe(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2) { + Z3_ast result = Z3_mk_le((Z3_context)a0, (Z3_ast)a1, (Z3_ast)a2); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkGt(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2) { + Z3_ast result = Z3_mk_gt((Z3_context)a0, (Z3_ast)a1, (Z3_ast)a2); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkGe(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2) { + Z3_ast result = Z3_mk_ge((Z3_context)a0, (Z3_ast)a1, (Z3_ast)a2); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkInt2real(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_ast result = Z3_mk_int2real((Z3_context)a0, (Z3_ast)a1); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkReal2int(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_ast result = Z3_mk_real2int((Z3_context)a0, (Z3_ast)a1); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkIsInt(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_ast result = Z3_mk_is_int((Z3_context)a0, (Z3_ast)a1); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkBvnot(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_ast result = Z3_mk_bvnot((Z3_context)a0, (Z3_ast)a1); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkBvredand(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_ast result = Z3_mk_bvredand((Z3_context)a0, (Z3_ast)a1); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkBvredor(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_ast result = Z3_mk_bvredor((Z3_context)a0, (Z3_ast)a1); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkBvand(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2) { + Z3_ast result = Z3_mk_bvand((Z3_context)a0, (Z3_ast)a1, (Z3_ast)a2); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkBvor(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2) { + Z3_ast result = Z3_mk_bvor((Z3_context)a0, (Z3_ast)a1, (Z3_ast)a2); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkBvxor(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2) { + Z3_ast result = Z3_mk_bvxor((Z3_context)a0, (Z3_ast)a1, (Z3_ast)a2); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkBvnand(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2) { + Z3_ast result = Z3_mk_bvnand((Z3_context)a0, (Z3_ast)a1, (Z3_ast)a2); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkBvnor(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2) { + Z3_ast result = Z3_mk_bvnor((Z3_context)a0, (Z3_ast)a1, (Z3_ast)a2); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkBvxnor(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2) { + Z3_ast result = Z3_mk_bvxnor((Z3_context)a0, (Z3_ast)a1, (Z3_ast)a2); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkBvneg(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_ast result = Z3_mk_bvneg((Z3_context)a0, (Z3_ast)a1); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkBvadd(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2) { + Z3_ast result = Z3_mk_bvadd((Z3_context)a0, (Z3_ast)a1, (Z3_ast)a2); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkBvsub(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2) { + Z3_ast result = Z3_mk_bvsub((Z3_context)a0, (Z3_ast)a1, (Z3_ast)a2); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkBvmul(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2) { + Z3_ast result = Z3_mk_bvmul((Z3_context)a0, (Z3_ast)a1, (Z3_ast)a2); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkBvudiv(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2) { + Z3_ast result = Z3_mk_bvudiv((Z3_context)a0, (Z3_ast)a1, (Z3_ast)a2); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkBvsdiv(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2) { + Z3_ast result = Z3_mk_bvsdiv((Z3_context)a0, (Z3_ast)a1, (Z3_ast)a2); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkBvurem(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2) { + Z3_ast result = Z3_mk_bvurem((Z3_context)a0, (Z3_ast)a1, (Z3_ast)a2); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkBvsrem(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2) { + Z3_ast result = Z3_mk_bvsrem((Z3_context)a0, (Z3_ast)a1, (Z3_ast)a2); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkBvsmod(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2) { + Z3_ast result = Z3_mk_bvsmod((Z3_context)a0, (Z3_ast)a1, (Z3_ast)a2); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkBvult(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2) { + Z3_ast result = Z3_mk_bvult((Z3_context)a0, (Z3_ast)a1, (Z3_ast)a2); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkBvslt(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2) { + Z3_ast result = Z3_mk_bvslt((Z3_context)a0, (Z3_ast)a1, (Z3_ast)a2); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkBvule(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2) { + Z3_ast result = Z3_mk_bvule((Z3_context)a0, (Z3_ast)a1, (Z3_ast)a2); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkBvsle(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2) { + Z3_ast result = Z3_mk_bvsle((Z3_context)a0, (Z3_ast)a1, (Z3_ast)a2); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkBvuge(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2) { + Z3_ast result = Z3_mk_bvuge((Z3_context)a0, (Z3_ast)a1, (Z3_ast)a2); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkBvsge(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2) { + Z3_ast result = Z3_mk_bvsge((Z3_context)a0, (Z3_ast)a1, (Z3_ast)a2); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkBvugt(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2) { + Z3_ast result = Z3_mk_bvugt((Z3_context)a0, (Z3_ast)a1, (Z3_ast)a2); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkBvsgt(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2) { + Z3_ast result = Z3_mk_bvsgt((Z3_context)a0, (Z3_ast)a1, (Z3_ast)a2); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkConcat(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2) { + Z3_ast result = Z3_mk_concat((Z3_context)a0, (Z3_ast)a1, (Z3_ast)a2); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkExtract(JNIEnv * jenv, jclass cls, jlong a0, jint a1, jint a2, jlong a3) { + Z3_ast result = Z3_mk_extract((Z3_context)a0, (unsigned)a1, (unsigned)a2, (Z3_ast)a3); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkSignExt(JNIEnv * jenv, jclass cls, jlong a0, jint a1, jlong a2) { + Z3_ast result = Z3_mk_sign_ext((Z3_context)a0, (unsigned)a1, (Z3_ast)a2); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkZeroExt(JNIEnv * jenv, jclass cls, jlong a0, jint a1, jlong a2) { + Z3_ast result = Z3_mk_zero_ext((Z3_context)a0, (unsigned)a1, (Z3_ast)a2); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkRepeat(JNIEnv * jenv, jclass cls, jlong a0, jint a1, jlong a2) { + Z3_ast result = Z3_mk_repeat((Z3_context)a0, (unsigned)a1, (Z3_ast)a2); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkBvshl(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2) { + Z3_ast result = Z3_mk_bvshl((Z3_context)a0, (Z3_ast)a1, (Z3_ast)a2); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkBvlshr(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2) { + Z3_ast result = Z3_mk_bvlshr((Z3_context)a0, (Z3_ast)a1, (Z3_ast)a2); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkBvashr(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2) { + Z3_ast result = Z3_mk_bvashr((Z3_context)a0, (Z3_ast)a1, (Z3_ast)a2); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkRotateLeft(JNIEnv * jenv, jclass cls, jlong a0, jint a1, jlong a2) { + Z3_ast result = Z3_mk_rotate_left((Z3_context)a0, (unsigned)a1, (Z3_ast)a2); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkRotateRight(JNIEnv * jenv, jclass cls, jlong a0, jint a1, jlong a2) { + Z3_ast result = Z3_mk_rotate_right((Z3_context)a0, (unsigned)a1, (Z3_ast)a2); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkExtRotateLeft(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2) { + Z3_ast result = Z3_mk_ext_rotate_left((Z3_context)a0, (Z3_ast)a1, (Z3_ast)a2); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkExtRotateRight(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2) { + Z3_ast result = Z3_mk_ext_rotate_right((Z3_context)a0, (Z3_ast)a1, (Z3_ast)a2); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkInt2bv(JNIEnv * jenv, jclass cls, jlong a0, jint a1, jlong a2) { + Z3_ast result = Z3_mk_int2bv((Z3_context)a0, (unsigned)a1, (Z3_ast)a2); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkBv2int(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jboolean a2) { + Z3_ast result = Z3_mk_bv2int((Z3_context)a0, (Z3_ast)a1, (Z3_bool)a2); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkBvaddNoOverflow(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2, jboolean a3) { + Z3_ast result = Z3_mk_bvadd_no_overflow((Z3_context)a0, (Z3_ast)a1, (Z3_ast)a2, (Z3_bool)a3); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkBvaddNoUnderflow(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2) { + Z3_ast result = Z3_mk_bvadd_no_underflow((Z3_context)a0, (Z3_ast)a1, (Z3_ast)a2); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkBvsubNoOverflow(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2) { + Z3_ast result = Z3_mk_bvsub_no_overflow((Z3_context)a0, (Z3_ast)a1, (Z3_ast)a2); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkBvsubNoUnderflow(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2, jboolean a3) { + Z3_ast result = Z3_mk_bvsub_no_underflow((Z3_context)a0, (Z3_ast)a1, (Z3_ast)a2, (Z3_bool)a3); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkBvsdivNoOverflow(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2) { + Z3_ast result = Z3_mk_bvsdiv_no_overflow((Z3_context)a0, (Z3_ast)a1, (Z3_ast)a2); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkBvnegNoOverflow(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_ast result = Z3_mk_bvneg_no_overflow((Z3_context)a0, (Z3_ast)a1); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkBvmulNoOverflow(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2, jboolean a3) { + Z3_ast result = Z3_mk_bvmul_no_overflow((Z3_context)a0, (Z3_ast)a1, (Z3_ast)a2, (Z3_bool)a3); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkBvmulNoUnderflow(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2) { + Z3_ast result = Z3_mk_bvmul_no_underflow((Z3_context)a0, (Z3_ast)a1, (Z3_ast)a2); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkSelect(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2) { + Z3_ast result = Z3_mk_select((Z3_context)a0, (Z3_ast)a1, (Z3_ast)a2); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkStore(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2, jlong a3) { + Z3_ast result = Z3_mk_store((Z3_context)a0, (Z3_ast)a1, (Z3_ast)a2, (Z3_ast)a3); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkConstArray(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2) { + Z3_ast result = Z3_mk_const_array((Z3_context)a0, (Z3_sort)a1, (Z3_ast)a2); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkMap(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jint a2, jlongArray a3) { + Z3_ast * _a3 = (Z3_ast *) jenv->GetLongArrayElements(a3, NULL); + Z3_ast result = Z3_mk_map((Z3_context)a0, (Z3_func_decl)a1, (unsigned)a2, _a3); + jenv->ReleaseLongArrayElements(a3, (jlong *) _a3, JNI_ABORT); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkArrayDefault(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_ast result = Z3_mk_array_default((Z3_context)a0, (Z3_ast)a1); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkSetSort(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_sort result = Z3_mk_set_sort((Z3_context)a0, (Z3_sort)a1); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkEmptySet(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_ast result = Z3_mk_empty_set((Z3_context)a0, (Z3_sort)a1); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkFullSet(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_ast result = Z3_mk_full_set((Z3_context)a0, (Z3_sort)a1); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkSetAdd(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2) { + Z3_ast result = Z3_mk_set_add((Z3_context)a0, (Z3_ast)a1, (Z3_ast)a2); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkSetDel(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2) { + Z3_ast result = Z3_mk_set_del((Z3_context)a0, (Z3_ast)a1, (Z3_ast)a2); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkSetUnion(JNIEnv * jenv, jclass cls, jlong a0, jint a1, jlongArray a2) { + Z3_ast * _a2 = (Z3_ast *) jenv->GetLongArrayElements(a2, NULL); + Z3_ast result = Z3_mk_set_union((Z3_context)a0, (unsigned)a1, _a2); + jenv->ReleaseLongArrayElements(a2, (jlong *) _a2, JNI_ABORT); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkSetIntersect(JNIEnv * jenv, jclass cls, jlong a0, jint a1, jlongArray a2) { + Z3_ast * _a2 = (Z3_ast *) jenv->GetLongArrayElements(a2, NULL); + Z3_ast result = Z3_mk_set_intersect((Z3_context)a0, (unsigned)a1, _a2); + jenv->ReleaseLongArrayElements(a2, (jlong *) _a2, JNI_ABORT); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkSetDifference(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2) { + Z3_ast result = Z3_mk_set_difference((Z3_context)a0, (Z3_ast)a1, (Z3_ast)a2); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkSetComplement(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_ast result = Z3_mk_set_complement((Z3_context)a0, (Z3_ast)a1); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkSetMember(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2) { + Z3_ast result = Z3_mk_set_member((Z3_context)a0, (Z3_ast)a1, (Z3_ast)a2); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkSetSubset(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2) { + Z3_ast result = Z3_mk_set_subset((Z3_context)a0, (Z3_ast)a1, (Z3_ast)a2); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkNumeral(JNIEnv * jenv, jclass cls, jlong a0, jstring a1, jlong a2) { + Z3_string _a1 = (Z3_string) jenv->GetStringUTFChars(a1, NULL); + Z3_ast result = Z3_mk_numeral((Z3_context)a0, _a1, (Z3_sort)a2); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkReal(JNIEnv * jenv, jclass cls, jlong a0, jint a1, jint a2) { + Z3_ast result = Z3_mk_real((Z3_context)a0, (int)a1, (int)a2); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkInt(JNIEnv * jenv, jclass cls, jlong a0, jint a1, jlong a2) { + Z3_ast result = Z3_mk_int((Z3_context)a0, (int)a1, (Z3_sort)a2); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkUnsignedInt(JNIEnv * jenv, jclass cls, jlong a0, jint a1, jlong a2) { + Z3_ast result = Z3_mk_unsigned_int((Z3_context)a0, (unsigned)a1, (Z3_sort)a2); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkInt64(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2) { + Z3_ast result = Z3_mk_int64((Z3_context)a0, (__int64)a1, (Z3_sort)a2); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkUnsignedInt64(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2) { + Z3_ast result = Z3_mk_unsigned_int64((Z3_context)a0, (__uint64)a1, (Z3_sort)a2); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkPattern(JNIEnv * jenv, jclass cls, jlong a0, jint a1, jlongArray a2) { + Z3_ast * _a2 = (Z3_ast *) jenv->GetLongArrayElements(a2, NULL); + Z3_pattern result = Z3_mk_pattern((Z3_context)a0, (unsigned)a1, _a2); + jenv->ReleaseLongArrayElements(a2, (jlong *) _a2, JNI_ABORT); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkBound(JNIEnv * jenv, jclass cls, jlong a0, jint a1, jlong a2) { + Z3_ast result = Z3_mk_bound((Z3_context)a0, (unsigned)a1, (Z3_sort)a2); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkForall(JNIEnv * jenv, jclass cls, jlong a0, jint a1, jint a2, jlongArray a3, jint a4, jlongArray a5, jlongArray a6, jlong a7) { + Z3_pattern * _a3 = (Z3_pattern *) jenv->GetLongArrayElements(a3, NULL); + Z3_sort * _a5 = (Z3_sort *) jenv->GetLongArrayElements(a5, NULL); + Z3_symbol * _a6 = (Z3_symbol *) jenv->GetLongArrayElements(a6, NULL); + Z3_ast result = Z3_mk_forall((Z3_context)a0, (unsigned)a1, (unsigned)a2, _a3, (unsigned)a4, _a5, _a6, (Z3_ast)a7); + jenv->ReleaseLongArrayElements(a3, (jlong *) _a3, JNI_ABORT); + jenv->ReleaseLongArrayElements(a5, (jlong *) _a5, JNI_ABORT); + jenv->ReleaseLongArrayElements(a6, (jlong *) _a6, JNI_ABORT); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkExists(JNIEnv * jenv, jclass cls, jlong a0, jint a1, jint a2, jlongArray a3, jint a4, jlongArray a5, jlongArray a6, jlong a7) { + Z3_pattern * _a3 = (Z3_pattern *) jenv->GetLongArrayElements(a3, NULL); + Z3_sort * _a5 = (Z3_sort *) jenv->GetLongArrayElements(a5, NULL); + Z3_symbol * _a6 = (Z3_symbol *) jenv->GetLongArrayElements(a6, NULL); + Z3_ast result = Z3_mk_exists((Z3_context)a0, (unsigned)a1, (unsigned)a2, _a3, (unsigned)a4, _a5, _a6, (Z3_ast)a7); + jenv->ReleaseLongArrayElements(a3, (jlong *) _a3, JNI_ABORT); + jenv->ReleaseLongArrayElements(a5, (jlong *) _a5, JNI_ABORT); + jenv->ReleaseLongArrayElements(a6, (jlong *) _a6, JNI_ABORT); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkQuantifier(JNIEnv * jenv, jclass cls, jlong a0, jboolean a1, jint a2, jint a3, jlongArray a4, jint a5, jlongArray a6, jlongArray a7, jlong a8) { + Z3_pattern * _a4 = (Z3_pattern *) jenv->GetLongArrayElements(a4, NULL); + Z3_sort * _a6 = (Z3_sort *) jenv->GetLongArrayElements(a6, NULL); + Z3_symbol * _a7 = (Z3_symbol *) jenv->GetLongArrayElements(a7, NULL); + Z3_ast result = Z3_mk_quantifier((Z3_context)a0, (Z3_bool)a1, (unsigned)a2, (unsigned)a3, _a4, (unsigned)a5, _a6, _a7, (Z3_ast)a8); + jenv->ReleaseLongArrayElements(a4, (jlong *) _a4, JNI_ABORT); + jenv->ReleaseLongArrayElements(a6, (jlong *) _a6, JNI_ABORT); + jenv->ReleaseLongArrayElements(a7, (jlong *) _a7, JNI_ABORT); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkQuantifierEx(JNIEnv * jenv, jclass cls, jlong a0, jboolean a1, jint a2, jlong a3, jlong a4, jint a5, jlongArray a6, jint a7, jlongArray a8, jint a9, jlongArray a10, jlongArray a11, jlong a12) { + Z3_pattern * _a6 = (Z3_pattern *) jenv->GetLongArrayElements(a6, NULL); + Z3_ast * _a8 = (Z3_ast *) jenv->GetLongArrayElements(a8, NULL); + Z3_sort * _a10 = (Z3_sort *) jenv->GetLongArrayElements(a10, NULL); + Z3_symbol * _a11 = (Z3_symbol *) jenv->GetLongArrayElements(a11, NULL); + Z3_ast result = Z3_mk_quantifier_ex((Z3_context)a0, (Z3_bool)a1, (unsigned)a2, (Z3_symbol)a3, (Z3_symbol)a4, (unsigned)a5, _a6, (unsigned)a7, _a8, (unsigned)a9, _a10, _a11, (Z3_ast)a12); + jenv->ReleaseLongArrayElements(a6, (jlong *) _a6, JNI_ABORT); + jenv->ReleaseLongArrayElements(a8, (jlong *) _a8, JNI_ABORT); + jenv->ReleaseLongArrayElements(a10, (jlong *) _a10, JNI_ABORT); + jenv->ReleaseLongArrayElements(a11, (jlong *) _a11, JNI_ABORT); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkForallConst(JNIEnv * jenv, jclass cls, jlong a0, jint a1, jint a2, jlongArray a3, jint a4, jlongArray a5, jlong a6) { + Z3_app * _a3 = (Z3_app *) jenv->GetLongArrayElements(a3, NULL); + Z3_pattern * _a5 = (Z3_pattern *) jenv->GetLongArrayElements(a5, NULL); + Z3_ast result = Z3_mk_forall_const((Z3_context)a0, (unsigned)a1, (unsigned)a2, _a3, (unsigned)a4, _a5, (Z3_ast)a6); + jenv->ReleaseLongArrayElements(a3, (jlong *) _a3, JNI_ABORT); + jenv->ReleaseLongArrayElements(a5, (jlong *) _a5, JNI_ABORT); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkExistsConst(JNIEnv * jenv, jclass cls, jlong a0, jint a1, jint a2, jlongArray a3, jint a4, jlongArray a5, jlong a6) { + Z3_app * _a3 = (Z3_app *) jenv->GetLongArrayElements(a3, NULL); + Z3_pattern * _a5 = (Z3_pattern *) jenv->GetLongArrayElements(a5, NULL); + Z3_ast result = Z3_mk_exists_const((Z3_context)a0, (unsigned)a1, (unsigned)a2, _a3, (unsigned)a4, _a5, (Z3_ast)a6); + jenv->ReleaseLongArrayElements(a3, (jlong *) _a3, JNI_ABORT); + jenv->ReleaseLongArrayElements(a5, (jlong *) _a5, JNI_ABORT); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkQuantifierConst(JNIEnv * jenv, jclass cls, jlong a0, jboolean a1, jint a2, jint a3, jlongArray a4, jint a5, jlongArray a6, jlong a7) { + Z3_app * _a4 = (Z3_app *) jenv->GetLongArrayElements(a4, NULL); + Z3_pattern * _a6 = (Z3_pattern *) jenv->GetLongArrayElements(a6, NULL); + Z3_ast result = Z3_mk_quantifier_const((Z3_context)a0, (Z3_bool)a1, (unsigned)a2, (unsigned)a3, _a4, (unsigned)a5, _a6, (Z3_ast)a7); + jenv->ReleaseLongArrayElements(a4, (jlong *) _a4, JNI_ABORT); + jenv->ReleaseLongArrayElements(a6, (jlong *) _a6, JNI_ABORT); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkQuantifierConstEx(JNIEnv * jenv, jclass cls, jlong a0, jboolean a1, jint a2, jlong a3, jlong a4, jint a5, jlongArray a6, jint a7, jlongArray a8, jint a9, jlongArray a10, jlong a11) { + Z3_app * _a6 = (Z3_app *) jenv->GetLongArrayElements(a6, NULL); + Z3_pattern * _a8 = (Z3_pattern *) jenv->GetLongArrayElements(a8, NULL); + Z3_ast * _a10 = (Z3_ast *) jenv->GetLongArrayElements(a10, NULL); + Z3_ast result = Z3_mk_quantifier_const_ex((Z3_context)a0, (Z3_bool)a1, (unsigned)a2, (Z3_symbol)a3, (Z3_symbol)a4, (unsigned)a5, _a6, (unsigned)a7, _a8, (unsigned)a9, _a10, (Z3_ast)a11); + jenv->ReleaseLongArrayElements(a6, (jlong *) _a6, JNI_ABORT); + jenv->ReleaseLongArrayElements(a8, (jlong *) _a8, JNI_ABORT); + jenv->ReleaseLongArrayElements(a10, (jlong *) _a10, JNI_ABORT); + return (jlong) result; +} +JNIEXPORT jint JNICALL Java_Z3Native_getSymbolKind(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + unsigned result = Z3_get_symbol_kind((Z3_context)a0, (Z3_symbol)a1); + return (jint) result; +} +JNIEXPORT jint JNICALL Java_Z3Native_getSymbolInt(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + int result = Z3_get_symbol_int((Z3_context)a0, (Z3_symbol)a1); + return (jint) result; +} +JNIEXPORT jstring JNICALL Java_Z3Native_getSymbolString(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_string result = Z3_get_symbol_string((Z3_context)a0, (Z3_symbol)a1); + return jenv->NewStringUTF(result); +} +JNIEXPORT jlong JNICALL Java_Z3Native_getSortName(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_symbol result = Z3_get_sort_name((Z3_context)a0, (Z3_sort)a1); + return (jlong) result; +} +JNIEXPORT jint JNICALL Java_Z3Native_getSortId(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + unsigned result = Z3_get_sort_id((Z3_context)a0, (Z3_sort)a1); + return (jint) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_sortToAst(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_ast result = Z3_sort_to_ast((Z3_context)a0, (Z3_sort)a1); + return (jlong) result; +} +JNIEXPORT jboolean JNICALL Java_Z3Native_isEqSort(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2) { + Z3_bool result = Z3_is_eq_sort((Z3_context)a0, (Z3_sort)a1, (Z3_sort)a2); + return (jboolean) result; +} +JNIEXPORT jint JNICALL Java_Z3Native_getSortKind(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + unsigned result = Z3_get_sort_kind((Z3_context)a0, (Z3_sort)a1); + return (jint) result; +} +JNIEXPORT jint JNICALL Java_Z3Native_getBvSortSize(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + unsigned result = Z3_get_bv_sort_size((Z3_context)a0, (Z3_sort)a1); + return (jint) result; +} +JNIEXPORT jboolean JNICALL Java_Z3Native_getFiniteDomainSortSize(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jobject a2) { + __uint64 _a2; + Z3_bool result = Z3_get_finite_domain_sort_size((Z3_context)a0, (Z3_sort)a1, &_a2); + { + jclass mc = jenv->GetObjectClass(a2); + jfieldID fid = jenv->GetFieldID(mc, "value", "J"); + jenv->SetLongField(a2, fid, (jlong) _a2); + } + return (jboolean) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_getArraySortDomain(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_sort result = Z3_get_array_sort_domain((Z3_context)a0, (Z3_sort)a1); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_getArraySortRange(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_sort result = Z3_get_array_sort_range((Z3_context)a0, (Z3_sort)a1); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_getTupleSortMkDecl(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_func_decl result = Z3_get_tuple_sort_mk_decl((Z3_context)a0, (Z3_sort)a1); + return (jlong) result; +} +JNIEXPORT jint JNICALL Java_Z3Native_getTupleSortNumFields(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + unsigned result = Z3_get_tuple_sort_num_fields((Z3_context)a0, (Z3_sort)a1); + return (jint) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_getTupleSortFieldDecl(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jint a2) { + Z3_func_decl result = Z3_get_tuple_sort_field_decl((Z3_context)a0, (Z3_sort)a1, (unsigned)a2); + return (jlong) result; +} +JNIEXPORT jint JNICALL Java_Z3Native_getDatatypeSortNumConstructors(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + unsigned result = Z3_get_datatype_sort_num_constructors((Z3_context)a0, (Z3_sort)a1); + return (jint) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_getDatatypeSortConstructor(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jint a2) { + Z3_func_decl result = Z3_get_datatype_sort_constructor((Z3_context)a0, (Z3_sort)a1, (unsigned)a2); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_getDatatypeSortRecognizer(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jint a2) { + Z3_func_decl result = Z3_get_datatype_sort_recognizer((Z3_context)a0, (Z3_sort)a1, (unsigned)a2); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_getDatatypeSortConstructorAccessor(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jint a2, jint a3) { + Z3_func_decl result = Z3_get_datatype_sort_constructor_accessor((Z3_context)a0, (Z3_sort)a1, (unsigned)a2, (unsigned)a3); + return (jlong) result; +} +JNIEXPORT jint JNICALL Java_Z3Native_getRelationArity(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + unsigned result = Z3_get_relation_arity((Z3_context)a0, (Z3_sort)a1); + return (jint) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_getRelationColumn(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jint a2) { + Z3_sort result = Z3_get_relation_column((Z3_context)a0, (Z3_sort)a1, (unsigned)a2); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_funcDeclToAst(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_ast result = Z3_func_decl_to_ast((Z3_context)a0, (Z3_func_decl)a1); + return (jlong) result; +} +JNIEXPORT jboolean JNICALL Java_Z3Native_isEqFuncDecl(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2) { + Z3_bool result = Z3_is_eq_func_decl((Z3_context)a0, (Z3_func_decl)a1, (Z3_func_decl)a2); + return (jboolean) result; +} +JNIEXPORT jint JNICALL Java_Z3Native_getFuncDeclId(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + unsigned result = Z3_get_func_decl_id((Z3_context)a0, (Z3_func_decl)a1); + return (jint) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_getDeclName(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_symbol result = Z3_get_decl_name((Z3_context)a0, (Z3_func_decl)a1); + return (jlong) result; +} +JNIEXPORT jint JNICALL Java_Z3Native_getDeclKind(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + unsigned result = Z3_get_decl_kind((Z3_context)a0, (Z3_func_decl)a1); + return (jint) result; +} +JNIEXPORT jint JNICALL Java_Z3Native_getDomainSize(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + unsigned result = Z3_get_domain_size((Z3_context)a0, (Z3_func_decl)a1); + return (jint) result; +} +JNIEXPORT jint JNICALL Java_Z3Native_getArity(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + unsigned result = Z3_get_arity((Z3_context)a0, (Z3_func_decl)a1); + return (jint) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_getDomain(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jint a2) { + Z3_sort result = Z3_get_domain((Z3_context)a0, (Z3_func_decl)a1, (unsigned)a2); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_getRange(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_sort result = Z3_get_range((Z3_context)a0, (Z3_func_decl)a1); + return (jlong) result; +} +JNIEXPORT jint JNICALL Java_Z3Native_getDeclNumParameters(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + unsigned result = Z3_get_decl_num_parameters((Z3_context)a0, (Z3_func_decl)a1); + return (jint) result; +} +JNIEXPORT jint JNICALL Java_Z3Native_getDeclParameterKind(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jint a2) { + unsigned result = Z3_get_decl_parameter_kind((Z3_context)a0, (Z3_func_decl)a1, (unsigned)a2); + return (jint) result; +} +JNIEXPORT jint JNICALL Java_Z3Native_getDeclIntParameter(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jint a2) { + int result = Z3_get_decl_int_parameter((Z3_context)a0, (Z3_func_decl)a1, (unsigned)a2); + return (jint) result; +} +JNIEXPORT jdouble JNICALL Java_Z3Native_getDeclDoubleParameter(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jint a2) { + double result = Z3_get_decl_double_parameter((Z3_context)a0, (Z3_func_decl)a1, (unsigned)a2); + return (jdouble) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_getDeclSymbolParameter(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jint a2) { + Z3_symbol result = Z3_get_decl_symbol_parameter((Z3_context)a0, (Z3_func_decl)a1, (unsigned)a2); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_getDeclSortParameter(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jint a2) { + Z3_sort result = Z3_get_decl_sort_parameter((Z3_context)a0, (Z3_func_decl)a1, (unsigned)a2); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_getDeclAstParameter(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jint a2) { + Z3_ast result = Z3_get_decl_ast_parameter((Z3_context)a0, (Z3_func_decl)a1, (unsigned)a2); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_getDeclFuncDeclParameter(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jint a2) { + Z3_func_decl result = Z3_get_decl_func_decl_parameter((Z3_context)a0, (Z3_func_decl)a1, (unsigned)a2); + return (jlong) result; +} +JNIEXPORT jstring JNICALL Java_Z3Native_getDeclRationalParameter(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jint a2) { + Z3_string result = Z3_get_decl_rational_parameter((Z3_context)a0, (Z3_func_decl)a1, (unsigned)a2); + return jenv->NewStringUTF(result); +} +JNIEXPORT jlong JNICALL Java_Z3Native_appToAst(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_ast result = Z3_app_to_ast((Z3_context)a0, (Z3_app)a1); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_getAppDecl(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_func_decl result = Z3_get_app_decl((Z3_context)a0, (Z3_app)a1); + return (jlong) result; +} +JNIEXPORT jint JNICALL Java_Z3Native_getAppNumArgs(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + unsigned result = Z3_get_app_num_args((Z3_context)a0, (Z3_app)a1); + return (jint) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_getAppArg(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jint a2) { + Z3_ast result = Z3_get_app_arg((Z3_context)a0, (Z3_app)a1, (unsigned)a2); + return (jlong) result; +} +JNIEXPORT jboolean JNICALL Java_Z3Native_isEqAst(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2) { + Z3_bool result = Z3_is_eq_ast((Z3_context)a0, (Z3_ast)a1, (Z3_ast)a2); + return (jboolean) result; +} +JNIEXPORT jint JNICALL Java_Z3Native_getAstId(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + unsigned result = Z3_get_ast_id((Z3_context)a0, (Z3_ast)a1); + return (jint) result; +} +JNIEXPORT jint JNICALL Java_Z3Native_getAstHash(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + unsigned result = Z3_get_ast_hash((Z3_context)a0, (Z3_ast)a1); + return (jint) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_getSort(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_sort result = Z3_get_sort((Z3_context)a0, (Z3_ast)a1); + return (jlong) result; +} +JNIEXPORT jboolean JNICALL Java_Z3Native_isWellSorted(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_bool result = Z3_is_well_sorted((Z3_context)a0, (Z3_ast)a1); + return (jboolean) result; +} +JNIEXPORT jint JNICALL Java_Z3Native_getBoolValue(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + unsigned result = Z3_get_bool_value((Z3_context)a0, (Z3_ast)a1); + return (jint) result; +} +JNIEXPORT jint JNICALL Java_Z3Native_getAstKind(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + unsigned result = Z3_get_ast_kind((Z3_context)a0, (Z3_ast)a1); + return (jint) result; +} +JNIEXPORT jboolean JNICALL Java_Z3Native_isApp(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_bool result = Z3_is_app((Z3_context)a0, (Z3_ast)a1); + return (jboolean) result; +} +JNIEXPORT jboolean JNICALL Java_Z3Native_isNumeralAst(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_bool result = Z3_is_numeral_ast((Z3_context)a0, (Z3_ast)a1); + return (jboolean) result; +} +JNIEXPORT jboolean JNICALL Java_Z3Native_isAlgebraicNumber(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_bool result = Z3_is_algebraic_number((Z3_context)a0, (Z3_ast)a1); + return (jboolean) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_toApp(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_app result = Z3_to_app((Z3_context)a0, (Z3_ast)a1); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_toFuncDecl(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_func_decl result = Z3_to_func_decl((Z3_context)a0, (Z3_ast)a1); + return (jlong) result; +} +JNIEXPORT jstring JNICALL Java_Z3Native_getNumeralString(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_string result = Z3_get_numeral_string((Z3_context)a0, (Z3_ast)a1); + return jenv->NewStringUTF(result); +} +JNIEXPORT jstring JNICALL Java_Z3Native_getNumeralDecimalString(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jint a2) { + Z3_string result = Z3_get_numeral_decimal_string((Z3_context)a0, (Z3_ast)a1, (unsigned)a2); + return jenv->NewStringUTF(result); +} +JNIEXPORT jlong JNICALL Java_Z3Native_getNumerator(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_ast result = Z3_get_numerator((Z3_context)a0, (Z3_ast)a1); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_getDenominator(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_ast result = Z3_get_denominator((Z3_context)a0, (Z3_ast)a1); + return (jlong) result; +} +JNIEXPORT jboolean JNICALL Java_Z3Native_getNumeralSmall(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jobject a2, jobject a3) { + __int64 _a2; + __int64 _a3; + Z3_bool result = Z3_get_numeral_small((Z3_context)a0, (Z3_ast)a1, &_a2, &_a3); + { + jclass mc = jenv->GetObjectClass(a2); + jfieldID fid = jenv->GetFieldID(mc, "value", "J"); + jenv->SetLongField(a2, fid, (jlong) _a2); + } + { + jclass mc = jenv->GetObjectClass(a3); + jfieldID fid = jenv->GetFieldID(mc, "value", "J"); + jenv->SetLongField(a3, fid, (jlong) _a3); + } + return (jboolean) result; +} +JNIEXPORT jboolean JNICALL Java_Z3Native_getNumeralInt(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jobject a2) { + int _a2; + Z3_bool result = Z3_get_numeral_int((Z3_context)a0, (Z3_ast)a1, &_a2); + { + jclass mc = jenv->GetObjectClass(a2); + jfieldID fid = jenv->GetFieldID(mc, "value", "I"); + jenv->SetIntField(a2, fid, (jint) _a2); + } + return (jboolean) result; +} +JNIEXPORT jboolean JNICALL Java_Z3Native_getNumeralUint(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jobject a2) { + unsigned _a2; + Z3_bool result = Z3_get_numeral_uint((Z3_context)a0, (Z3_ast)a1, &_a2); + { + jclass mc = jenv->GetObjectClass(a2); + jfieldID fid = jenv->GetFieldID(mc, "value", "I"); + jenv->SetIntField(a2, fid, (jint) _a2); + } + return (jboolean) result; +} +JNIEXPORT jboolean JNICALL Java_Z3Native_getNumeralUint64(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jobject a2) { + __uint64 _a2; + Z3_bool result = Z3_get_numeral_uint64((Z3_context)a0, (Z3_ast)a1, &_a2); + { + jclass mc = jenv->GetObjectClass(a2); + jfieldID fid = jenv->GetFieldID(mc, "value", "J"); + jenv->SetLongField(a2, fid, (jlong) _a2); + } + return (jboolean) result; +} +JNIEXPORT jboolean JNICALL Java_Z3Native_getNumeralInt64(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jobject a2) { + __int64 _a2; + Z3_bool result = Z3_get_numeral_int64((Z3_context)a0, (Z3_ast)a1, &_a2); + { + jclass mc = jenv->GetObjectClass(a2); + jfieldID fid = jenv->GetFieldID(mc, "value", "J"); + jenv->SetLongField(a2, fid, (jlong) _a2); + } + return (jboolean) result; +} +JNIEXPORT jboolean JNICALL Java_Z3Native_getNumeralRationalInt64(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jobject a2, jobject a3) { + __int64 _a2; + __int64 _a3; + Z3_bool result = Z3_get_numeral_rational_int64((Z3_context)a0, (Z3_ast)a1, &_a2, &_a3); + { + jclass mc = jenv->GetObjectClass(a2); + jfieldID fid = jenv->GetFieldID(mc, "value", "J"); + jenv->SetLongField(a2, fid, (jlong) _a2); + } + { + jclass mc = jenv->GetObjectClass(a3); + jfieldID fid = jenv->GetFieldID(mc, "value", "J"); + jenv->SetLongField(a3, fid, (jlong) _a3); + } + return (jboolean) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_getAlgebraicNumberLower(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jint a2) { + Z3_ast result = Z3_get_algebraic_number_lower((Z3_context)a0, (Z3_ast)a1, (unsigned)a2); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_getAlgebraicNumberUpper(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jint a2) { + Z3_ast result = Z3_get_algebraic_number_upper((Z3_context)a0, (Z3_ast)a1, (unsigned)a2); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_patternToAst(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_ast result = Z3_pattern_to_ast((Z3_context)a0, (Z3_pattern)a1); + return (jlong) result; +} +JNIEXPORT jint JNICALL Java_Z3Native_getPatternNumTerms(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + unsigned result = Z3_get_pattern_num_terms((Z3_context)a0, (Z3_pattern)a1); + return (jint) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_getPattern(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jint a2) { + Z3_ast result = Z3_get_pattern((Z3_context)a0, (Z3_pattern)a1, (unsigned)a2); + return (jlong) result; +} +JNIEXPORT jint JNICALL Java_Z3Native_getIndexValue(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + unsigned result = Z3_get_index_value((Z3_context)a0, (Z3_ast)a1); + return (jint) result; +} +JNIEXPORT jboolean JNICALL Java_Z3Native_isQuantifierForall(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_bool result = Z3_is_quantifier_forall((Z3_context)a0, (Z3_ast)a1); + return (jboolean) result; +} +JNIEXPORT jint JNICALL Java_Z3Native_getQuantifierWeight(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + unsigned result = Z3_get_quantifier_weight((Z3_context)a0, (Z3_ast)a1); + return (jint) result; +} +JNIEXPORT jint JNICALL Java_Z3Native_getQuantifierNumPatterns(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + unsigned result = Z3_get_quantifier_num_patterns((Z3_context)a0, (Z3_ast)a1); + return (jint) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_getQuantifierPatternAst(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jint a2) { + Z3_pattern result = Z3_get_quantifier_pattern_ast((Z3_context)a0, (Z3_ast)a1, (unsigned)a2); + return (jlong) result; +} +JNIEXPORT jint JNICALL Java_Z3Native_getQuantifierNumNoPatterns(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + unsigned result = Z3_get_quantifier_num_no_patterns((Z3_context)a0, (Z3_ast)a1); + return (jint) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_getQuantifierNoPatternAst(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jint a2) { + Z3_ast result = Z3_get_quantifier_no_pattern_ast((Z3_context)a0, (Z3_ast)a1, (unsigned)a2); + return (jlong) result; +} +JNIEXPORT jint JNICALL Java_Z3Native_getQuantifierNumBound(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + unsigned result = Z3_get_quantifier_num_bound((Z3_context)a0, (Z3_ast)a1); + return (jint) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_getQuantifierBoundName(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jint a2) { + Z3_symbol result = Z3_get_quantifier_bound_name((Z3_context)a0, (Z3_ast)a1, (unsigned)a2); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_getQuantifierBoundSort(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jint a2) { + Z3_sort result = Z3_get_quantifier_bound_sort((Z3_context)a0, (Z3_ast)a1, (unsigned)a2); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_getQuantifierBody(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_ast result = Z3_get_quantifier_body((Z3_context)a0, (Z3_ast)a1); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_simplify(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_ast result = Z3_simplify((Z3_context)a0, (Z3_ast)a1); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_simplifyEx(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2) { + Z3_ast result = Z3_simplify_ex((Z3_context)a0, (Z3_ast)a1, (Z3_params)a2); + return (jlong) result; +} +JNIEXPORT jstring JNICALL Java_Z3Native_simplifyGetHelp(JNIEnv * jenv, jclass cls, jlong a0) { + Z3_string result = Z3_simplify_get_help((Z3_context)a0); + return jenv->NewStringUTF(result); +} +JNIEXPORT jlong JNICALL Java_Z3Native_simplifyGetParamDescrs(JNIEnv * jenv, jclass cls, jlong a0) { + Z3_param_descrs result = Z3_simplify_get_param_descrs((Z3_context)a0); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_updateTerm(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jint a2, jlongArray a3) { + Z3_ast * _a3 = (Z3_ast *) jenv->GetLongArrayElements(a3, NULL); + Z3_ast result = Z3_update_term((Z3_context)a0, (Z3_ast)a1, (unsigned)a2, _a3); + jenv->ReleaseLongArrayElements(a3, (jlong *) _a3, JNI_ABORT); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_substitute(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jint a2, jlongArray a3, jlongArray a4) { + Z3_ast * _a3 = (Z3_ast *) jenv->GetLongArrayElements(a3, NULL); + Z3_ast * _a4 = (Z3_ast *) jenv->GetLongArrayElements(a4, NULL); + Z3_ast result = Z3_substitute((Z3_context)a0, (Z3_ast)a1, (unsigned)a2, _a3, _a4); + jenv->ReleaseLongArrayElements(a3, (jlong *) _a3, JNI_ABORT); + jenv->ReleaseLongArrayElements(a4, (jlong *) _a4, JNI_ABORT); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_substituteVars(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jint a2, jlongArray a3) { + Z3_ast * _a3 = (Z3_ast *) jenv->GetLongArrayElements(a3, NULL); + Z3_ast result = Z3_substitute_vars((Z3_context)a0, (Z3_ast)a1, (unsigned)a2, _a3); + jenv->ReleaseLongArrayElements(a3, (jlong *) _a3, JNI_ABORT); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_translate(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2) { + Z3_ast result = Z3_translate((Z3_context)a0, (Z3_ast)a1, (Z3_context)a2); + return (jlong) result; +} +JNIEXPORT void JNICALL Java_Z3Native_modelIncRef(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_model_inc_ref((Z3_context)a0, (Z3_model)a1); +} +JNIEXPORT void JNICALL Java_Z3Native_modelDecRef(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_model_dec_ref((Z3_context)a0, (Z3_model)a1); +} +JNIEXPORT jboolean JNICALL Java_Z3Native_modelEval(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2, jboolean a3, jobject a4) { + Z3_ast _a4; + Z3_bool result = Z3_model_eval((Z3_context)a0, (Z3_model)a1, (Z3_ast)a2, (Z3_bool)a3, &_a4); + { + jclass mc = jenv->GetObjectClass(a4); + jfieldID fid = jenv->GetFieldID(mc, "value", "J"); + jenv->SetLongField(a4, fid, (jlong) _a4); + } + return (jboolean) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_modelGetConstInterp(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2) { + Z3_ast result = Z3_model_get_const_interp((Z3_context)a0, (Z3_model)a1, (Z3_func_decl)a2); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_modelGetFuncInterp(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2) { + Z3_func_interp result = Z3_model_get_func_interp((Z3_context)a0, (Z3_model)a1, (Z3_func_decl)a2); + return (jlong) result; +} +JNIEXPORT jint JNICALL Java_Z3Native_modelGetNumConsts(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + unsigned result = Z3_model_get_num_consts((Z3_context)a0, (Z3_model)a1); + return (jint) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_modelGetConstDecl(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jint a2) { + Z3_func_decl result = Z3_model_get_const_decl((Z3_context)a0, (Z3_model)a1, (unsigned)a2); + return (jlong) result; +} +JNIEXPORT jint JNICALL Java_Z3Native_modelGetNumFuncs(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + unsigned result = Z3_model_get_num_funcs((Z3_context)a0, (Z3_model)a1); + return (jint) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_modelGetFuncDecl(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jint a2) { + Z3_func_decl result = Z3_model_get_func_decl((Z3_context)a0, (Z3_model)a1, (unsigned)a2); + return (jlong) result; +} +JNIEXPORT jint JNICALL Java_Z3Native_modelGetNumSorts(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + unsigned result = Z3_model_get_num_sorts((Z3_context)a0, (Z3_model)a1); + return (jint) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_modelGetSort(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jint a2) { + Z3_sort result = Z3_model_get_sort((Z3_context)a0, (Z3_model)a1, (unsigned)a2); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_modelGetSortUniverse(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2) { + Z3_ast_vector result = Z3_model_get_sort_universe((Z3_context)a0, (Z3_model)a1, (Z3_sort)a2); + return (jlong) result; +} +JNIEXPORT jboolean JNICALL Java_Z3Native_isAsArray(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_bool result = Z3_is_as_array((Z3_context)a0, (Z3_ast)a1); + return (jboolean) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_getAsArrayFuncDecl(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_func_decl result = Z3_get_as_array_func_decl((Z3_context)a0, (Z3_ast)a1); + return (jlong) result; +} +JNIEXPORT void JNICALL Java_Z3Native_funcInterpIncRef(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_func_interp_inc_ref((Z3_context)a0, (Z3_func_interp)a1); +} +JNIEXPORT void JNICALL Java_Z3Native_funcInterpDecRef(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_func_interp_dec_ref((Z3_context)a0, (Z3_func_interp)a1); +} +JNIEXPORT jint JNICALL Java_Z3Native_funcInterpGetNumEntries(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + unsigned result = Z3_func_interp_get_num_entries((Z3_context)a0, (Z3_func_interp)a1); + return (jint) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_funcInterpGetEntry(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jint a2) { + Z3_func_entry result = Z3_func_interp_get_entry((Z3_context)a0, (Z3_func_interp)a1, (unsigned)a2); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_funcInterpGetElse(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_ast result = Z3_func_interp_get_else((Z3_context)a0, (Z3_func_interp)a1); + return (jlong) result; +} +JNIEXPORT jint JNICALL Java_Z3Native_funcInterpGetArity(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + unsigned result = Z3_func_interp_get_arity((Z3_context)a0, (Z3_func_interp)a1); + return (jint) result; +} +JNIEXPORT void JNICALL Java_Z3Native_funcEntryIncRef(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_func_entry_inc_ref((Z3_context)a0, (Z3_func_entry)a1); +} +JNIEXPORT void JNICALL Java_Z3Native_funcEntryDecRef(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_func_entry_dec_ref((Z3_context)a0, (Z3_func_entry)a1); +} +JNIEXPORT jlong JNICALL Java_Z3Native_funcEntryGetValue(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_ast result = Z3_func_entry_get_value((Z3_context)a0, (Z3_func_entry)a1); + return (jlong) result; +} +JNIEXPORT jint JNICALL Java_Z3Native_funcEntryGetNumArgs(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + unsigned result = Z3_func_entry_get_num_args((Z3_context)a0, (Z3_func_entry)a1); + return (jint) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_funcEntryGetArg(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jint a2) { + Z3_ast result = Z3_func_entry_get_arg((Z3_context)a0, (Z3_func_entry)a1, (unsigned)a2); + return (jlong) result; +} +JNIEXPORT jint JNICALL Java_Z3Native_openLog(JNIEnv * jenv, jclass cls, jstring a0) { + Z3_string _a0 = (Z3_string) jenv->GetStringUTFChars(a0, NULL); + int result = Z3_open_log(_a0); + return (jint) result; +} +JNIEXPORT void JNICALL Java_Z3Native_appendLog(JNIEnv * jenv, jclass cls, jstring a0) { + Z3_string _a0 = (Z3_string) jenv->GetStringUTFChars(a0, NULL); + Z3_append_log(_a0); +} +JNIEXPORT void JNICALL Java_Z3Native_closeLog(JNIEnv * jenv, jclass cls) { + Z3_close_log(); +} +JNIEXPORT void JNICALL Java_Z3Native_toggleWarningMessages(JNIEnv * jenv, jclass cls, jboolean a0) { + Z3_toggle_warning_messages((Z3_bool)a0); +} +JNIEXPORT void JNICALL Java_Z3Native_setAstPrintMode(JNIEnv * jenv, jclass cls, jlong a0, jint a1) { + Z3_set_ast_print_mode((Z3_context)a0, (Z3_ast_print_mode)a1); +} +JNIEXPORT jstring JNICALL Java_Z3Native_astToString(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_string result = Z3_ast_to_string((Z3_context)a0, (Z3_ast)a1); + return jenv->NewStringUTF(result); +} +JNIEXPORT jstring JNICALL Java_Z3Native_patternToString(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_string result = Z3_pattern_to_string((Z3_context)a0, (Z3_pattern)a1); + return jenv->NewStringUTF(result); +} +JNIEXPORT jstring JNICALL Java_Z3Native_sortToString(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_string result = Z3_sort_to_string((Z3_context)a0, (Z3_sort)a1); + return jenv->NewStringUTF(result); +} +JNIEXPORT jstring JNICALL Java_Z3Native_funcDeclToString(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_string result = Z3_func_decl_to_string((Z3_context)a0, (Z3_func_decl)a1); + return jenv->NewStringUTF(result); +} +JNIEXPORT jstring JNICALL Java_Z3Native_modelToString(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_string result = Z3_model_to_string((Z3_context)a0, (Z3_model)a1); + return jenv->NewStringUTF(result); +} +JNIEXPORT jstring JNICALL Java_Z3Native_benchmarkToSmtlibString(JNIEnv * jenv, jclass cls, jlong a0, jstring a1, jstring a2, jstring a3, jstring a4, jint a5, jlongArray a6, jlong a7) { + Z3_string _a1 = (Z3_string) jenv->GetStringUTFChars(a1, NULL); + Z3_string _a2 = (Z3_string) jenv->GetStringUTFChars(a2, NULL); + Z3_string _a3 = (Z3_string) jenv->GetStringUTFChars(a3, NULL); + Z3_string _a4 = (Z3_string) jenv->GetStringUTFChars(a4, NULL); + Z3_ast * _a6 = (Z3_ast *) jenv->GetLongArrayElements(a6, NULL); + Z3_string result = Z3_benchmark_to_smtlib_string((Z3_context)a0, _a1, _a2, _a3, _a4, (unsigned)a5, _a6, (Z3_ast)a7); + jenv->ReleaseLongArrayElements(a6, (jlong *) _a6, JNI_ABORT); + return jenv->NewStringUTF(result); +} +JNIEXPORT jlong JNICALL Java_Z3Native_parseSmtlib2String(JNIEnv * jenv, jclass cls, jlong a0, jstring a1, jint a2, jlongArray a3, jlongArray a4, jint a5, jlongArray a6, jlongArray a7) { + Z3_string _a1 = (Z3_string) jenv->GetStringUTFChars(a1, NULL); + Z3_symbol * _a3 = (Z3_symbol *) jenv->GetLongArrayElements(a3, NULL); + Z3_sort * _a4 = (Z3_sort *) jenv->GetLongArrayElements(a4, NULL); + Z3_symbol * _a6 = (Z3_symbol *) jenv->GetLongArrayElements(a6, NULL); + Z3_func_decl * _a7 = (Z3_func_decl *) jenv->GetLongArrayElements(a7, NULL); + Z3_ast result = Z3_parse_smtlib2_string((Z3_context)a0, _a1, (unsigned)a2, _a3, _a4, (unsigned)a5, _a6, _a7); + jenv->ReleaseLongArrayElements(a3, (jlong *) _a3, JNI_ABORT); + jenv->ReleaseLongArrayElements(a4, (jlong *) _a4, JNI_ABORT); + jenv->ReleaseLongArrayElements(a6, (jlong *) _a6, JNI_ABORT); + jenv->ReleaseLongArrayElements(a7, (jlong *) _a7, JNI_ABORT); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_parseSmtlib2File(JNIEnv * jenv, jclass cls, jlong a0, jstring a1, jint a2, jlongArray a3, jlongArray a4, jint a5, jlongArray a6, jlongArray a7) { + Z3_string _a1 = (Z3_string) jenv->GetStringUTFChars(a1, NULL); + Z3_symbol * _a3 = (Z3_symbol *) jenv->GetLongArrayElements(a3, NULL); + Z3_sort * _a4 = (Z3_sort *) jenv->GetLongArrayElements(a4, NULL); + Z3_symbol * _a6 = (Z3_symbol *) jenv->GetLongArrayElements(a6, NULL); + Z3_func_decl * _a7 = (Z3_func_decl *) jenv->GetLongArrayElements(a7, NULL); + Z3_ast result = Z3_parse_smtlib2_file((Z3_context)a0, _a1, (unsigned)a2, _a3, _a4, (unsigned)a5, _a6, _a7); + jenv->ReleaseLongArrayElements(a3, (jlong *) _a3, JNI_ABORT); + jenv->ReleaseLongArrayElements(a4, (jlong *) _a4, JNI_ABORT); + jenv->ReleaseLongArrayElements(a6, (jlong *) _a6, JNI_ABORT); + jenv->ReleaseLongArrayElements(a7, (jlong *) _a7, JNI_ABORT); + return (jlong) result; +} +JNIEXPORT void JNICALL Java_Z3Native_parseSmtlibString(JNIEnv * jenv, jclass cls, jlong a0, jstring a1, jint a2, jlongArray a3, jlongArray a4, jint a5, jlongArray a6, jlongArray a7) { + Z3_string _a1 = (Z3_string) jenv->GetStringUTFChars(a1, NULL); + Z3_symbol * _a3 = (Z3_symbol *) jenv->GetLongArrayElements(a3, NULL); + Z3_sort * _a4 = (Z3_sort *) jenv->GetLongArrayElements(a4, NULL); + Z3_symbol * _a6 = (Z3_symbol *) jenv->GetLongArrayElements(a6, NULL); + Z3_func_decl * _a7 = (Z3_func_decl *) jenv->GetLongArrayElements(a7, NULL); + Z3_parse_smtlib_string((Z3_context)a0, _a1, (unsigned)a2, _a3, _a4, (unsigned)a5, _a6, _a7); + jenv->ReleaseLongArrayElements(a3, (jlong *) _a3, JNI_ABORT); + jenv->ReleaseLongArrayElements(a4, (jlong *) _a4, JNI_ABORT); + jenv->ReleaseLongArrayElements(a6, (jlong *) _a6, JNI_ABORT); + jenv->ReleaseLongArrayElements(a7, (jlong *) _a7, JNI_ABORT); +} +JNIEXPORT void JNICALL Java_Z3Native_parseSmtlibFile(JNIEnv * jenv, jclass cls, jlong a0, jstring a1, jint a2, jlongArray a3, jlongArray a4, jint a5, jlongArray a6, jlongArray a7) { + Z3_string _a1 = (Z3_string) jenv->GetStringUTFChars(a1, NULL); + Z3_symbol * _a3 = (Z3_symbol *) jenv->GetLongArrayElements(a3, NULL); + Z3_sort * _a4 = (Z3_sort *) jenv->GetLongArrayElements(a4, NULL); + Z3_symbol * _a6 = (Z3_symbol *) jenv->GetLongArrayElements(a6, NULL); + Z3_func_decl * _a7 = (Z3_func_decl *) jenv->GetLongArrayElements(a7, NULL); + Z3_parse_smtlib_file((Z3_context)a0, _a1, (unsigned)a2, _a3, _a4, (unsigned)a5, _a6, _a7); + jenv->ReleaseLongArrayElements(a3, (jlong *) _a3, JNI_ABORT); + jenv->ReleaseLongArrayElements(a4, (jlong *) _a4, JNI_ABORT); + jenv->ReleaseLongArrayElements(a6, (jlong *) _a6, JNI_ABORT); + jenv->ReleaseLongArrayElements(a7, (jlong *) _a7, JNI_ABORT); +} +JNIEXPORT jint JNICALL Java_Z3Native_getSmtlibNumFormulas(JNIEnv * jenv, jclass cls, jlong a0) { + unsigned result = Z3_get_smtlib_num_formulas((Z3_context)a0); + return (jint) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_getSmtlibFormula(JNIEnv * jenv, jclass cls, jlong a0, jint a1) { + Z3_ast result = Z3_get_smtlib_formula((Z3_context)a0, (unsigned)a1); + return (jlong) result; +} +JNIEXPORT jint JNICALL Java_Z3Native_getSmtlibNumAssumptions(JNIEnv * jenv, jclass cls, jlong a0) { + unsigned result = Z3_get_smtlib_num_assumptions((Z3_context)a0); + return (jint) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_getSmtlibAssumption(JNIEnv * jenv, jclass cls, jlong a0, jint a1) { + Z3_ast result = Z3_get_smtlib_assumption((Z3_context)a0, (unsigned)a1); + return (jlong) result; +} +JNIEXPORT jint JNICALL Java_Z3Native_getSmtlibNumDecls(JNIEnv * jenv, jclass cls, jlong a0) { + unsigned result = Z3_get_smtlib_num_decls((Z3_context)a0); + return (jint) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_getSmtlibDecl(JNIEnv * jenv, jclass cls, jlong a0, jint a1) { + Z3_func_decl result = Z3_get_smtlib_decl((Z3_context)a0, (unsigned)a1); + return (jlong) result; +} +JNIEXPORT jint JNICALL Java_Z3Native_getSmtlibNumSorts(JNIEnv * jenv, jclass cls, jlong a0) { + unsigned result = Z3_get_smtlib_num_sorts((Z3_context)a0); + return (jint) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_getSmtlibSort(JNIEnv * jenv, jclass cls, jlong a0, jint a1) { + Z3_sort result = Z3_get_smtlib_sort((Z3_context)a0, (unsigned)a1); + return (jlong) result; +} +JNIEXPORT jstring JNICALL Java_Z3Native_getSmtlibError(JNIEnv * jenv, jclass cls, jlong a0) { + Z3_string result = Z3_get_smtlib_error((Z3_context)a0); + return jenv->NewStringUTF(result); +} +JNIEXPORT jint JNICALL Java_Z3Native_getErrorCode(JNIEnv * jenv, jclass cls, jlong a0) { + unsigned result = Z3_get_error_code((Z3_context)a0); + return (jint) result; +} +JNIEXPORT void JNICALL Java_Z3Native_setError(JNIEnv * jenv, jclass cls, jlong a0, jint a1) { + Z3_set_error((Z3_context)a0, (Z3_error_code)a1); +} +JNIEXPORT jstring JNICALL Java_Z3Native_getErrorMsg(JNIEnv * jenv, jclass cls, jint a0) { + Z3_string result = Z3_get_error_msg((Z3_error_code)a0); + return jenv->NewStringUTF(result); +} +JNIEXPORT jstring JNICALL Java_Z3Native_getErrorMsgEx(JNIEnv * jenv, jclass cls, jlong a0, jint a1) { + Z3_string result = Z3_get_error_msg_ex((Z3_context)a0, (Z3_error_code)a1); + return jenv->NewStringUTF(result); +} +JNIEXPORT void JNICALL Java_Z3Native_getVersion(JNIEnv * jenv, jclass cls, jobject a0, jobject a1, jobject a2, jobject a3) { + unsigned _a0; + unsigned _a1; + unsigned _a2; + unsigned _a3; + Z3_get_version(&_a0, &_a1, &_a2, &_a3); + { + jclass mc = jenv->GetObjectClass(a0); + jfieldID fid = jenv->GetFieldID(mc, "value", "I"); + jenv->SetIntField(a0, fid, (jint) _a0); + } + { + jclass mc = jenv->GetObjectClass(a1); + jfieldID fid = jenv->GetFieldID(mc, "value", "I"); + jenv->SetIntField(a1, fid, (jint) _a1); + } + { + jclass mc = jenv->GetObjectClass(a2); + jfieldID fid = jenv->GetFieldID(mc, "value", "I"); + jenv->SetIntField(a2, fid, (jint) _a2); + } + { + jclass mc = jenv->GetObjectClass(a3); + jfieldID fid = jenv->GetFieldID(mc, "value", "I"); + jenv->SetIntField(a3, fid, (jint) _a3); + } +} +JNIEXPORT void JNICALL Java_Z3Native_enableTrace(JNIEnv * jenv, jclass cls, jstring a0) { + Z3_string _a0 = (Z3_string) jenv->GetStringUTFChars(a0, NULL); + Z3_enable_trace(_a0); +} +JNIEXPORT void JNICALL Java_Z3Native_disableTrace(JNIEnv * jenv, jclass cls, jstring a0) { + Z3_string _a0 = (Z3_string) jenv->GetStringUTFChars(a0, NULL); + Z3_disable_trace(_a0); +} +JNIEXPORT void JNICALL Java_Z3Native_resetMemory(JNIEnv * jenv, jclass cls) { + Z3_reset_memory(); +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkFixedpoint(JNIEnv * jenv, jclass cls, jlong a0) { + Z3_fixedpoint result = Z3_mk_fixedpoint((Z3_context)a0); + return (jlong) result; +} +JNIEXPORT void JNICALL Java_Z3Native_fixedpointIncRef(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_fixedpoint_inc_ref((Z3_context)a0, (Z3_fixedpoint)a1); +} +JNIEXPORT void JNICALL Java_Z3Native_fixedpointDecRef(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_fixedpoint_dec_ref((Z3_context)a0, (Z3_fixedpoint)a1); +} +JNIEXPORT void JNICALL Java_Z3Native_fixedpointAddRule(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2, jlong a3) { + Z3_fixedpoint_add_rule((Z3_context)a0, (Z3_fixedpoint)a1, (Z3_ast)a2, (Z3_symbol)a3); +} +JNIEXPORT void JNICALL Java_Z3Native_fixedpointAddFact(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2, jint a3, jintArray a4) { + unsigned * _a4 = (unsigned *) jenv->GetIntArrayElements(a4, NULL); + Z3_fixedpoint_add_fact((Z3_context)a0, (Z3_fixedpoint)a1, (Z3_func_decl)a2, (unsigned)a3, _a4); + jenv->ReleaseIntArrayElements(a4, (jint *) _a4, JNI_ABORT); +} +JNIEXPORT void JNICALL Java_Z3Native_fixedpointAssert(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2) { + Z3_fixedpoint_assert((Z3_context)a0, (Z3_fixedpoint)a1, (Z3_ast)a2); +} +JNIEXPORT jint JNICALL Java_Z3Native_fixedpointQuery(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2) { + int result = Z3_fixedpoint_query((Z3_context)a0, (Z3_fixedpoint)a1, (Z3_ast)a2); + return (jint) result; +} +JNIEXPORT jint JNICALL Java_Z3Native_fixedpointQueryRelations(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jint a2, jlongArray a3) { + Z3_func_decl * _a3 = (Z3_func_decl *) jenv->GetLongArrayElements(a3, NULL); + int result = Z3_fixedpoint_query_relations((Z3_context)a0, (Z3_fixedpoint)a1, (unsigned)a2, _a3); + jenv->ReleaseLongArrayElements(a3, (jlong *) _a3, JNI_ABORT); + return (jint) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_fixedpointGetAnswer(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_ast result = Z3_fixedpoint_get_answer((Z3_context)a0, (Z3_fixedpoint)a1); + return (jlong) result; +} +JNIEXPORT jstring JNICALL Java_Z3Native_fixedpointGetReasonUnknown(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_string result = Z3_fixedpoint_get_reason_unknown((Z3_context)a0, (Z3_fixedpoint)a1); + return jenv->NewStringUTF(result); +} +JNIEXPORT void JNICALL Java_Z3Native_fixedpointUpdateRule(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2, jlong a3) { + Z3_fixedpoint_update_rule((Z3_context)a0, (Z3_fixedpoint)a1, (Z3_ast)a2, (Z3_symbol)a3); +} +JNIEXPORT jint JNICALL Java_Z3Native_fixedpointGetNumLevels(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2) { + unsigned result = Z3_fixedpoint_get_num_levels((Z3_context)a0, (Z3_fixedpoint)a1, (Z3_func_decl)a2); + return (jint) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_fixedpointGetCoverDelta(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jint a2, jlong a3) { + Z3_ast result = Z3_fixedpoint_get_cover_delta((Z3_context)a0, (Z3_fixedpoint)a1, (int)a2, (Z3_func_decl)a3); + return (jlong) result; +} +JNIEXPORT void JNICALL Java_Z3Native_fixedpointAddCover(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jint a2, jlong a3, jlong a4) { + Z3_fixedpoint_add_cover((Z3_context)a0, (Z3_fixedpoint)a1, (int)a2, (Z3_func_decl)a3, (Z3_ast)a4); +} +JNIEXPORT jlong JNICALL Java_Z3Native_fixedpointGetStatistics(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_stats result = Z3_fixedpoint_get_statistics((Z3_context)a0, (Z3_fixedpoint)a1); + return (jlong) result; +} +JNIEXPORT void JNICALL Java_Z3Native_fixedpointRegisterRelation(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2) { + Z3_fixedpoint_register_relation((Z3_context)a0, (Z3_fixedpoint)a1, (Z3_func_decl)a2); +} +JNIEXPORT void JNICALL Java_Z3Native_fixedpointSetPredicateRepresentation(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2, jint a3, jlongArray a4) { + Z3_symbol * _a4 = (Z3_symbol *) jenv->GetLongArrayElements(a4, NULL); + Z3_fixedpoint_set_predicate_representation((Z3_context)a0, (Z3_fixedpoint)a1, (Z3_func_decl)a2, (unsigned)a3, _a4); + jenv->ReleaseLongArrayElements(a4, (jlong *) _a4, JNI_ABORT); +} +JNIEXPORT jlong JNICALL Java_Z3Native_fixedpointGetRules(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_ast_vector result = Z3_fixedpoint_get_rules((Z3_context)a0, (Z3_fixedpoint)a1); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_fixedpointGetAssertions(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_ast_vector result = Z3_fixedpoint_get_assertions((Z3_context)a0, (Z3_fixedpoint)a1); + return (jlong) result; +} +JNIEXPORT void JNICALL Java_Z3Native_fixedpointSetParams(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2) { + Z3_fixedpoint_set_params((Z3_context)a0, (Z3_fixedpoint)a1, (Z3_params)a2); +} +JNIEXPORT jstring JNICALL Java_Z3Native_fixedpointGetHelp(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_string result = Z3_fixedpoint_get_help((Z3_context)a0, (Z3_fixedpoint)a1); + return jenv->NewStringUTF(result); +} +JNIEXPORT jlong JNICALL Java_Z3Native_fixedpointGetParamDescrs(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_param_descrs result = Z3_fixedpoint_get_param_descrs((Z3_context)a0, (Z3_fixedpoint)a1); + return (jlong) result; +} +JNIEXPORT jstring JNICALL Java_Z3Native_fixedpointToString(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jint a2, jlongArray a3) { + Z3_ast * _a3 = (Z3_ast *) jenv->GetLongArrayElements(a3, NULL); + Z3_string result = Z3_fixedpoint_to_string((Z3_context)a0, (Z3_fixedpoint)a1, (unsigned)a2, _a3); + jenv->ReleaseLongArrayElements(a3, (jlong *) _a3, JNI_ABORT); + return jenv->NewStringUTF(result); +} +JNIEXPORT jlong JNICALL Java_Z3Native_fixedpointFromString(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jstring a2) { + Z3_string _a2 = (Z3_string) jenv->GetStringUTFChars(a2, NULL); + Z3_ast_vector result = Z3_fixedpoint_from_string((Z3_context)a0, (Z3_fixedpoint)a1, _a2); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_fixedpointFromFile(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jstring a2) { + Z3_string _a2 = (Z3_string) jenv->GetStringUTFChars(a2, NULL); + Z3_ast_vector result = Z3_fixedpoint_from_file((Z3_context)a0, (Z3_fixedpoint)a1, _a2); + return (jlong) result; +} +JNIEXPORT void JNICALL Java_Z3Native_fixedpointPush(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_fixedpoint_push((Z3_context)a0, (Z3_fixedpoint)a1); +} +JNIEXPORT void JNICALL Java_Z3Native_fixedpointPop(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_fixedpoint_pop((Z3_context)a0, (Z3_fixedpoint)a1); +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkAstVector(JNIEnv * jenv, jclass cls, jlong a0) { + Z3_ast_vector result = Z3_mk_ast_vector((Z3_context)a0); + return (jlong) result; +} +JNIEXPORT void JNICALL Java_Z3Native_astVectorIncRef(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_ast_vector_inc_ref((Z3_context)a0, (Z3_ast_vector)a1); +} +JNIEXPORT void JNICALL Java_Z3Native_astVectorDecRef(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_ast_vector_dec_ref((Z3_context)a0, (Z3_ast_vector)a1); +} +JNIEXPORT jint JNICALL Java_Z3Native_astVectorSize(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + unsigned result = Z3_ast_vector_size((Z3_context)a0, (Z3_ast_vector)a1); + return (jint) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_astVectorGet(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jint a2) { + Z3_ast result = Z3_ast_vector_get((Z3_context)a0, (Z3_ast_vector)a1, (unsigned)a2); + return (jlong) result; +} +JNIEXPORT void JNICALL Java_Z3Native_astVectorSet(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jint a2, jlong a3) { + Z3_ast_vector_set((Z3_context)a0, (Z3_ast_vector)a1, (unsigned)a2, (Z3_ast)a3); +} +JNIEXPORT void JNICALL Java_Z3Native_astVectorResize(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jint a2) { + Z3_ast_vector_resize((Z3_context)a0, (Z3_ast_vector)a1, (unsigned)a2); +} +JNIEXPORT void JNICALL Java_Z3Native_astVectorPush(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2) { + Z3_ast_vector_push((Z3_context)a0, (Z3_ast_vector)a1, (Z3_ast)a2); +} +JNIEXPORT jlong JNICALL Java_Z3Native_astVectorTranslate(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2) { + Z3_ast_vector result = Z3_ast_vector_translate((Z3_context)a0, (Z3_ast_vector)a1, (Z3_context)a2); + return (jlong) result; +} +JNIEXPORT jstring JNICALL Java_Z3Native_astVectorToString(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_string result = Z3_ast_vector_to_string((Z3_context)a0, (Z3_ast_vector)a1); + return jenv->NewStringUTF(result); +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkAstMap(JNIEnv * jenv, jclass cls, jlong a0) { + Z3_ast_map result = Z3_mk_ast_map((Z3_context)a0); + return (jlong) result; +} +JNIEXPORT void JNICALL Java_Z3Native_astMapIncRef(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_ast_map_inc_ref((Z3_context)a0, (Z3_ast_map)a1); +} +JNIEXPORT void JNICALL Java_Z3Native_astMapDecRef(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_ast_map_dec_ref((Z3_context)a0, (Z3_ast_map)a1); +} +JNIEXPORT jboolean JNICALL Java_Z3Native_astMapContains(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2) { + Z3_bool result = Z3_ast_map_contains((Z3_context)a0, (Z3_ast_map)a1, (Z3_ast)a2); + return (jboolean) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_astMapFind(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2) { + Z3_ast result = Z3_ast_map_find((Z3_context)a0, (Z3_ast_map)a1, (Z3_ast)a2); + return (jlong) result; +} +JNIEXPORT void JNICALL Java_Z3Native_astMapInsert(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2, jlong a3) { + Z3_ast_map_insert((Z3_context)a0, (Z3_ast_map)a1, (Z3_ast)a2, (Z3_ast)a3); +} +JNIEXPORT void JNICALL Java_Z3Native_astMapErase(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2) { + Z3_ast_map_erase((Z3_context)a0, (Z3_ast_map)a1, (Z3_ast)a2); +} +JNIEXPORT void JNICALL Java_Z3Native_astMapReset(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_ast_map_reset((Z3_context)a0, (Z3_ast_map)a1); +} +JNIEXPORT jint JNICALL Java_Z3Native_astMapSize(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + unsigned result = Z3_ast_map_size((Z3_context)a0, (Z3_ast_map)a1); + return (jint) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_astMapKeys(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_ast_vector result = Z3_ast_map_keys((Z3_context)a0, (Z3_ast_map)a1); + return (jlong) result; +} +JNIEXPORT jstring JNICALL Java_Z3Native_astMapToString(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_string result = Z3_ast_map_to_string((Z3_context)a0, (Z3_ast_map)a1); + return jenv->NewStringUTF(result); +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkGoal(JNIEnv * jenv, jclass cls, jlong a0, jboolean a1, jboolean a2, jboolean a3) { + Z3_goal result = Z3_mk_goal((Z3_context)a0, (Z3_bool)a1, (Z3_bool)a2, (Z3_bool)a3); + return (jlong) result; +} +JNIEXPORT void JNICALL Java_Z3Native_goalIncRef(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_goal_inc_ref((Z3_context)a0, (Z3_goal)a1); +} +JNIEXPORT void JNICALL Java_Z3Native_goalDecRef(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_goal_dec_ref((Z3_context)a0, (Z3_goal)a1); +} +JNIEXPORT jint JNICALL Java_Z3Native_goalPrecision(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + unsigned result = Z3_goal_precision((Z3_context)a0, (Z3_goal)a1); + return (jint) result; +} +JNIEXPORT void JNICALL Java_Z3Native_goalAssert(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2) { + Z3_goal_assert((Z3_context)a0, (Z3_goal)a1, (Z3_ast)a2); +} +JNIEXPORT jboolean JNICALL Java_Z3Native_goalInconsistent(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_bool result = Z3_goal_inconsistent((Z3_context)a0, (Z3_goal)a1); + return (jboolean) result; +} +JNIEXPORT jint JNICALL Java_Z3Native_goalDepth(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + unsigned result = Z3_goal_depth((Z3_context)a0, (Z3_goal)a1); + return (jint) result; +} +JNIEXPORT void JNICALL Java_Z3Native_goalReset(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_goal_reset((Z3_context)a0, (Z3_goal)a1); +} +JNIEXPORT jint JNICALL Java_Z3Native_goalSize(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + unsigned result = Z3_goal_size((Z3_context)a0, (Z3_goal)a1); + return (jint) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_goalFormula(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jint a2) { + Z3_ast result = Z3_goal_formula((Z3_context)a0, (Z3_goal)a1, (unsigned)a2); + return (jlong) result; +} +JNIEXPORT jint JNICALL Java_Z3Native_goalNumExprs(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + unsigned result = Z3_goal_num_exprs((Z3_context)a0, (Z3_goal)a1); + return (jint) result; +} +JNIEXPORT jboolean JNICALL Java_Z3Native_goalIsDecidedSat(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_bool result = Z3_goal_is_decided_sat((Z3_context)a0, (Z3_goal)a1); + return (jboolean) result; +} +JNIEXPORT jboolean JNICALL Java_Z3Native_goalIsDecidedUnsat(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_bool result = Z3_goal_is_decided_unsat((Z3_context)a0, (Z3_goal)a1); + return (jboolean) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_goalTranslate(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2) { + Z3_goal result = Z3_goal_translate((Z3_context)a0, (Z3_goal)a1, (Z3_context)a2); + return (jlong) result; +} +JNIEXPORT jstring JNICALL Java_Z3Native_goalToString(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_string result = Z3_goal_to_string((Z3_context)a0, (Z3_goal)a1); + return jenv->NewStringUTF(result); +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkTactic(JNIEnv * jenv, jclass cls, jlong a0, jstring a1) { + Z3_string _a1 = (Z3_string) jenv->GetStringUTFChars(a1, NULL); + Z3_tactic result = Z3_mk_tactic((Z3_context)a0, _a1); + return (jlong) result; +} +JNIEXPORT void JNICALL Java_Z3Native_tacticIncRef(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_tactic_inc_ref((Z3_context)a0, (Z3_tactic)a1); +} +JNIEXPORT void JNICALL Java_Z3Native_tacticDecRef(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_tactic_dec_ref((Z3_context)a0, (Z3_tactic)a1); +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkProbe(JNIEnv * jenv, jclass cls, jlong a0, jstring a1) { + Z3_string _a1 = (Z3_string) jenv->GetStringUTFChars(a1, NULL); + Z3_probe result = Z3_mk_probe((Z3_context)a0, _a1); + return (jlong) result; +} +JNIEXPORT void JNICALL Java_Z3Native_probeIncRef(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_probe_inc_ref((Z3_context)a0, (Z3_probe)a1); +} +JNIEXPORT void JNICALL Java_Z3Native_probeDecRef(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_probe_dec_ref((Z3_context)a0, (Z3_probe)a1); +} +JNIEXPORT jlong JNICALL Java_Z3Native_tacticAndThen(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2) { + Z3_tactic result = Z3_tactic_and_then((Z3_context)a0, (Z3_tactic)a1, (Z3_tactic)a2); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_tacticOrElse(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2) { + Z3_tactic result = Z3_tactic_or_else((Z3_context)a0, (Z3_tactic)a1, (Z3_tactic)a2); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_tacticParOr(JNIEnv * jenv, jclass cls, jlong a0, jint a1, jlongArray a2) { + Z3_tactic * _a2 = (Z3_tactic *) jenv->GetLongArrayElements(a2, NULL); + Z3_tactic result = Z3_tactic_par_or((Z3_context)a0, (unsigned)a1, _a2); + jenv->ReleaseLongArrayElements(a2, (jlong *) _a2, JNI_ABORT); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_tacticParAndThen(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2) { + Z3_tactic result = Z3_tactic_par_and_then((Z3_context)a0, (Z3_tactic)a1, (Z3_tactic)a2); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_tacticTryFor(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jint a2) { + Z3_tactic result = Z3_tactic_try_for((Z3_context)a0, (Z3_tactic)a1, (unsigned)a2); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_tacticWhen(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2) { + Z3_tactic result = Z3_tactic_when((Z3_context)a0, (Z3_probe)a1, (Z3_tactic)a2); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_tacticCond(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2, jlong a3) { + Z3_tactic result = Z3_tactic_cond((Z3_context)a0, (Z3_probe)a1, (Z3_tactic)a2, (Z3_tactic)a3); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_tacticRepeat(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jint a2) { + Z3_tactic result = Z3_tactic_repeat((Z3_context)a0, (Z3_tactic)a1, (unsigned)a2); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_tacticSkip(JNIEnv * jenv, jclass cls, jlong a0) { + Z3_tactic result = Z3_tactic_skip((Z3_context)a0); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_tacticFail(JNIEnv * jenv, jclass cls, jlong a0) { + Z3_tactic result = Z3_tactic_fail((Z3_context)a0); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_tacticFailIf(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_tactic result = Z3_tactic_fail_if((Z3_context)a0, (Z3_probe)a1); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_tacticFailIfNotDecided(JNIEnv * jenv, jclass cls, jlong a0) { + Z3_tactic result = Z3_tactic_fail_if_not_decided((Z3_context)a0); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_tacticUsingParams(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2) { + Z3_tactic result = Z3_tactic_using_params((Z3_context)a0, (Z3_tactic)a1, (Z3_params)a2); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_probeConst(JNIEnv * jenv, jclass cls, jlong a0, jdouble a1) { + Z3_probe result = Z3_probe_const((Z3_context)a0, (double)a1); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_probeLt(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2) { + Z3_probe result = Z3_probe_lt((Z3_context)a0, (Z3_probe)a1, (Z3_probe)a2); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_probeGt(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2) { + Z3_probe result = Z3_probe_gt((Z3_context)a0, (Z3_probe)a1, (Z3_probe)a2); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_probeLe(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2) { + Z3_probe result = Z3_probe_le((Z3_context)a0, (Z3_probe)a1, (Z3_probe)a2); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_probeGe(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2) { + Z3_probe result = Z3_probe_ge((Z3_context)a0, (Z3_probe)a1, (Z3_probe)a2); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_probeEq(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2) { + Z3_probe result = Z3_probe_eq((Z3_context)a0, (Z3_probe)a1, (Z3_probe)a2); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_probeAnd(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2) { + Z3_probe result = Z3_probe_and((Z3_context)a0, (Z3_probe)a1, (Z3_probe)a2); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_probeOr(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2) { + Z3_probe result = Z3_probe_or((Z3_context)a0, (Z3_probe)a1, (Z3_probe)a2); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_probeNot(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_probe result = Z3_probe_not((Z3_context)a0, (Z3_probe)a1); + return (jlong) result; +} +JNIEXPORT jint JNICALL Java_Z3Native_getNumTactics(JNIEnv * jenv, jclass cls, jlong a0) { + unsigned result = Z3_get_num_tactics((Z3_context)a0); + return (jint) result; +} +JNIEXPORT jstring JNICALL Java_Z3Native_getTacticName(JNIEnv * jenv, jclass cls, jlong a0, jint a1) { + Z3_string result = Z3_get_tactic_name((Z3_context)a0, (unsigned)a1); + return jenv->NewStringUTF(result); +} +JNIEXPORT jint JNICALL Java_Z3Native_getNumProbes(JNIEnv * jenv, jclass cls, jlong a0) { + unsigned result = Z3_get_num_probes((Z3_context)a0); + return (jint) result; +} +JNIEXPORT jstring JNICALL Java_Z3Native_getProbeName(JNIEnv * jenv, jclass cls, jlong a0, jint a1) { + Z3_string result = Z3_get_probe_name((Z3_context)a0, (unsigned)a1); + return jenv->NewStringUTF(result); +} +JNIEXPORT jstring JNICALL Java_Z3Native_tacticGetHelp(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_string result = Z3_tactic_get_help((Z3_context)a0, (Z3_tactic)a1); + return jenv->NewStringUTF(result); +} +JNIEXPORT jlong JNICALL Java_Z3Native_tacticGetParamDescrs(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_param_descrs result = Z3_tactic_get_param_descrs((Z3_context)a0, (Z3_tactic)a1); + return (jlong) result; +} +JNIEXPORT jstring JNICALL Java_Z3Native_tacticGetDescr(JNIEnv * jenv, jclass cls, jlong a0, jstring a1) { + Z3_string _a1 = (Z3_string) jenv->GetStringUTFChars(a1, NULL); + Z3_string result = Z3_tactic_get_descr((Z3_context)a0, _a1); + return jenv->NewStringUTF(result); +} +JNIEXPORT jstring JNICALL Java_Z3Native_probeGetDescr(JNIEnv * jenv, jclass cls, jlong a0, jstring a1) { + Z3_string _a1 = (Z3_string) jenv->GetStringUTFChars(a1, NULL); + Z3_string result = Z3_probe_get_descr((Z3_context)a0, _a1); + return jenv->NewStringUTF(result); +} +JNIEXPORT jdouble JNICALL Java_Z3Native_probeApply(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2) { + double result = Z3_probe_apply((Z3_context)a0, (Z3_probe)a1, (Z3_goal)a2); + return (jdouble) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_tacticApply(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2) { + Z3_apply_result result = Z3_tactic_apply((Z3_context)a0, (Z3_tactic)a1, (Z3_goal)a2); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_tacticApplyEx(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2, jlong a3) { + Z3_apply_result result = Z3_tactic_apply_ex((Z3_context)a0, (Z3_tactic)a1, (Z3_goal)a2, (Z3_params)a3); + return (jlong) result; +} +JNIEXPORT void JNICALL Java_Z3Native_applyResultIncRef(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_apply_result_inc_ref((Z3_context)a0, (Z3_apply_result)a1); +} +JNIEXPORT void JNICALL Java_Z3Native_applyResultDecRef(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_apply_result_dec_ref((Z3_context)a0, (Z3_apply_result)a1); +} +JNIEXPORT jstring JNICALL Java_Z3Native_applyResultToString(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_string result = Z3_apply_result_to_string((Z3_context)a0, (Z3_apply_result)a1); + return jenv->NewStringUTF(result); +} +JNIEXPORT jint JNICALL Java_Z3Native_applyResultGetNumSubgoals(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + unsigned result = Z3_apply_result_get_num_subgoals((Z3_context)a0, (Z3_apply_result)a1); + return (jint) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_applyResultGetSubgoal(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jint a2) { + Z3_goal result = Z3_apply_result_get_subgoal((Z3_context)a0, (Z3_apply_result)a1, (unsigned)a2); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_applyResultConvertModel(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jint a2, jlong a3) { + Z3_model result = Z3_apply_result_convert_model((Z3_context)a0, (Z3_apply_result)a1, (unsigned)a2, (Z3_model)a3); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkSolver(JNIEnv * jenv, jclass cls, jlong a0) { + Z3_solver result = Z3_mk_solver((Z3_context)a0); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkSimpleSolver(JNIEnv * jenv, jclass cls, jlong a0) { + Z3_solver result = Z3_mk_simple_solver((Z3_context)a0); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkSolverForLogic(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_solver result = Z3_mk_solver_for_logic((Z3_context)a0, (Z3_symbol)a1); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkSolverFromTactic(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_solver result = Z3_mk_solver_from_tactic((Z3_context)a0, (Z3_tactic)a1); + return (jlong) result; +} +JNIEXPORT jstring JNICALL Java_Z3Native_solverGetHelp(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_string result = Z3_solver_get_help((Z3_context)a0, (Z3_solver)a1); + return jenv->NewStringUTF(result); +} +JNIEXPORT jlong JNICALL Java_Z3Native_solverGetParamDescrs(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_param_descrs result = Z3_solver_get_param_descrs((Z3_context)a0, (Z3_solver)a1); + return (jlong) result; +} +JNIEXPORT void JNICALL Java_Z3Native_solverSetParams(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2) { + Z3_solver_set_params((Z3_context)a0, (Z3_solver)a1, (Z3_params)a2); +} +JNIEXPORT void JNICALL Java_Z3Native_solverIncRef(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_solver_inc_ref((Z3_context)a0, (Z3_solver)a1); +} +JNIEXPORT void JNICALL Java_Z3Native_solverDecRef(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_solver_dec_ref((Z3_context)a0, (Z3_solver)a1); +} +JNIEXPORT void JNICALL Java_Z3Native_solverPush(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_solver_push((Z3_context)a0, (Z3_solver)a1); +} +JNIEXPORT void JNICALL Java_Z3Native_solverPop(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jint a2) { + Z3_solver_pop((Z3_context)a0, (Z3_solver)a1, (unsigned)a2); +} +JNIEXPORT void JNICALL Java_Z3Native_solverReset(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_solver_reset((Z3_context)a0, (Z3_solver)a1); +} +JNIEXPORT jint JNICALL Java_Z3Native_solverGetNumScopes(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + unsigned result = Z3_solver_get_num_scopes((Z3_context)a0, (Z3_solver)a1); + return (jint) result; +} +JNIEXPORT void JNICALL Java_Z3Native_solverAssert(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2) { + Z3_solver_assert((Z3_context)a0, (Z3_solver)a1, (Z3_ast)a2); +} +JNIEXPORT void JNICALL Java_Z3Native_solverAssertAndTrack(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2, jlong a3) { + Z3_solver_assert_and_track((Z3_context)a0, (Z3_solver)a1, (Z3_ast)a2, (Z3_ast)a3); +} +JNIEXPORT jlong JNICALL Java_Z3Native_solverGetAssertions(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_ast_vector result = Z3_solver_get_assertions((Z3_context)a0, (Z3_solver)a1); + return (jlong) result; +} +JNIEXPORT jint JNICALL Java_Z3Native_solverCheck(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + int result = Z3_solver_check((Z3_context)a0, (Z3_solver)a1); + return (jint) result; +} +JNIEXPORT jint JNICALL Java_Z3Native_solverCheckAssumptions(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jint a2, jlongArray a3) { + Z3_ast * _a3 = (Z3_ast *) jenv->GetLongArrayElements(a3, NULL); + int result = Z3_solver_check_assumptions((Z3_context)a0, (Z3_solver)a1, (unsigned)a2, _a3); + jenv->ReleaseLongArrayElements(a3, (jlong *) _a3, JNI_ABORT); + return (jint) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_solverGetModel(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_model result = Z3_solver_get_model((Z3_context)a0, (Z3_solver)a1); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_solverGetProof(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_ast result = Z3_solver_get_proof((Z3_context)a0, (Z3_solver)a1); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_solverGetUnsatCore(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_ast_vector result = Z3_solver_get_unsat_core((Z3_context)a0, (Z3_solver)a1); + return (jlong) result; +} +JNIEXPORT jstring JNICALL Java_Z3Native_solverGetReasonUnknown(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_string result = Z3_solver_get_reason_unknown((Z3_context)a0, (Z3_solver)a1); + return jenv->NewStringUTF(result); +} +JNIEXPORT jlong JNICALL Java_Z3Native_solverGetStatistics(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_stats result = Z3_solver_get_statistics((Z3_context)a0, (Z3_solver)a1); + return (jlong) result; +} +JNIEXPORT jstring JNICALL Java_Z3Native_solverToString(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_string result = Z3_solver_to_string((Z3_context)a0, (Z3_solver)a1); + return jenv->NewStringUTF(result); +} +JNIEXPORT jstring JNICALL Java_Z3Native_statsToString(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_string result = Z3_stats_to_string((Z3_context)a0, (Z3_stats)a1); + return jenv->NewStringUTF(result); +} +JNIEXPORT void JNICALL Java_Z3Native_statsIncRef(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_stats_inc_ref((Z3_context)a0, (Z3_stats)a1); +} +JNIEXPORT void JNICALL Java_Z3Native_statsDecRef(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_stats_dec_ref((Z3_context)a0, (Z3_stats)a1); +} +JNIEXPORT jint JNICALL Java_Z3Native_statsSize(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + unsigned result = Z3_stats_size((Z3_context)a0, (Z3_stats)a1); + return (jint) result; +} +JNIEXPORT jstring JNICALL Java_Z3Native_statsGetKey(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jint a2) { + Z3_string result = Z3_stats_get_key((Z3_context)a0, (Z3_stats)a1, (unsigned)a2); + return jenv->NewStringUTF(result); +} +JNIEXPORT jboolean JNICALL Java_Z3Native_statsIsUint(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jint a2) { + Z3_bool result = Z3_stats_is_uint((Z3_context)a0, (Z3_stats)a1, (unsigned)a2); + return (jboolean) result; +} +JNIEXPORT jboolean JNICALL Java_Z3Native_statsIsDouble(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jint a2) { + Z3_bool result = Z3_stats_is_double((Z3_context)a0, (Z3_stats)a1, (unsigned)a2); + return (jboolean) result; +} +JNIEXPORT jint JNICALL Java_Z3Native_statsGetUintValue(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jint a2) { + unsigned result = Z3_stats_get_uint_value((Z3_context)a0, (Z3_stats)a1, (unsigned)a2); + return (jint) result; +} +JNIEXPORT jdouble JNICALL Java_Z3Native_statsGetDoubleValue(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jint a2) { + double result = Z3_stats_get_double_value((Z3_context)a0, (Z3_stats)a1, (unsigned)a2); + return (jdouble) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkInjectiveFunction(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jint a2, jlongArray a3, jlong a4) { + Z3_sort * _a3 = (Z3_sort *) jenv->GetLongArrayElements(a3, NULL); + Z3_func_decl result = Z3_mk_injective_function((Z3_context)a0, (Z3_symbol)a1, (unsigned)a2, _a3, (Z3_sort)a4); + jenv->ReleaseLongArrayElements(a3, (jlong *) _a3, JNI_ABORT); + return (jlong) result; +} +JNIEXPORT void JNICALL Java_Z3Native_setLogic(JNIEnv * jenv, jclass cls, jlong a0, jstring a1) { + Z3_string _a1 = (Z3_string) jenv->GetStringUTFChars(a1, NULL); + Z3_set_logic((Z3_context)a0, _a1); +} +JNIEXPORT void JNICALL Java_Z3Native_push(JNIEnv * jenv, jclass cls, jlong a0) { + Z3_push((Z3_context)a0); +} +JNIEXPORT void JNICALL Java_Z3Native_pop(JNIEnv * jenv, jclass cls, jlong a0, jint a1) { + Z3_pop((Z3_context)a0, (unsigned)a1); +} +JNIEXPORT jint JNICALL Java_Z3Native_getNumScopes(JNIEnv * jenv, jclass cls, jlong a0) { + unsigned result = Z3_get_num_scopes((Z3_context)a0); + return (jint) result; +} +JNIEXPORT void JNICALL Java_Z3Native_persistAst(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jint a2) { + Z3_persist_ast((Z3_context)a0, (Z3_ast)a1, (unsigned)a2); +} +JNIEXPORT void JNICALL Java_Z3Native_assertCnstr(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_assert_cnstr((Z3_context)a0, (Z3_ast)a1); +} +JNIEXPORT jint JNICALL Java_Z3Native_checkAndGetModel(JNIEnv * jenv, jclass cls, jlong a0, jobject a1) { + Z3_model _a1; + int result = Z3_check_and_get_model((Z3_context)a0, &_a1); + { + jclass mc = jenv->GetObjectClass(a1); + jfieldID fid = jenv->GetFieldID(mc, "value", "J"); + jenv->SetLongField(a1, fid, (jlong) _a1); + } + return (jint) result; +} +JNIEXPORT jint JNICALL Java_Z3Native_check(JNIEnv * jenv, jclass cls, jlong a0) { + int result = Z3_check((Z3_context)a0); + return (jint) result; +} +JNIEXPORT jint JNICALL Java_Z3Native_checkAssumptions(JNIEnv * jenv, jclass cls, jlong a0, jint a1, jlongArray a2, jobject a3, jobject a4, jobject a5, jlongArray a6) { + Z3_ast * _a2 = (Z3_ast *) jenv->GetLongArrayElements(a2, NULL); + Z3_model _a3; + Z3_ast _a4; + unsigned _a5; + Z3_ast * _a6 = (Z3_ast *) malloc(((unsigned)a1) * sizeof(Z3_ast)); + int result = Z3_check_assumptions((Z3_context)a0, (unsigned)a1, _a2, &_a3, &_a4, &_a5, _a6); + jenv->ReleaseLongArrayElements(a2, (jlong *) _a2, JNI_ABORT); + { + jclass mc = jenv->GetObjectClass(a3); + jfieldID fid = jenv->GetFieldID(mc, "value", "J"); + jenv->SetLongField(a3, fid, (jlong) _a3); + } + { + jclass mc = jenv->GetObjectClass(a4); + jfieldID fid = jenv->GetFieldID(mc, "value", "J"); + jenv->SetLongField(a4, fid, (jlong) _a4); + } + { + jclass mc = jenv->GetObjectClass(a5); + jfieldID fid = jenv->GetFieldID(mc, "value", "I"); + jenv->SetIntField(a5, fid, (jint) _a5); + } + jenv->SetLongArrayRegion(a6, 0, (jsize)a1, (jlong *) _a6); + free(_a6); + return (jint) result; +} +JNIEXPORT jint JNICALL Java_Z3Native_getImpliedEqualities(JNIEnv * jenv, jclass cls, jlong a0, jint a1, jlongArray a2, jintArray a3) { + Z3_ast * _a2 = (Z3_ast *) jenv->GetLongArrayElements(a2, NULL); + unsigned * _a3 = (unsigned *) malloc(((unsigned)a1) * sizeof(unsigned)); + unsigned result = Z3_get_implied_equalities((Z3_context)a0, (unsigned)a1, _a2, _a3); + jenv->ReleaseLongArrayElements(a2, (jlong *) _a2, JNI_ABORT); + jenv->SetIntArrayRegion(a3, 0, (jsize)a1, (jint *) _a3); + free(_a3); + return (jint) result; +} +JNIEXPORT void JNICALL Java_Z3Native_delModel(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_del_model((Z3_context)a0, (Z3_model)a1); +} +JNIEXPORT void JNICALL Java_Z3Native_softCheckCancel(JNIEnv * jenv, jclass cls, jlong a0) { + Z3_soft_check_cancel((Z3_context)a0); +} +JNIEXPORT jint JNICALL Java_Z3Native_getSearchFailure(JNIEnv * jenv, jclass cls, jlong a0) { + unsigned result = Z3_get_search_failure((Z3_context)a0); + return (jint) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_mkLabel(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jboolean a2, jlong a3) { + Z3_ast result = Z3_mk_label((Z3_context)a0, (Z3_symbol)a1, (Z3_bool)a2, (Z3_ast)a3); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_getRelevantLabels(JNIEnv * jenv, jclass cls, jlong a0) { + Z3_literals result = Z3_get_relevant_labels((Z3_context)a0); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_getRelevantLiterals(JNIEnv * jenv, jclass cls, jlong a0) { + Z3_literals result = Z3_get_relevant_literals((Z3_context)a0); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_getGuessedLiterals(JNIEnv * jenv, jclass cls, jlong a0) { + Z3_literals result = Z3_get_guessed_literals((Z3_context)a0); + return (jlong) result; +} +JNIEXPORT void JNICALL Java_Z3Native_delLiterals(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_del_literals((Z3_context)a0, (Z3_literals)a1); +} +JNIEXPORT jint JNICALL Java_Z3Native_getNumLiterals(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + unsigned result = Z3_get_num_literals((Z3_context)a0, (Z3_literals)a1); + return (jint) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_getLabelSymbol(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jint a2) { + Z3_symbol result = Z3_get_label_symbol((Z3_context)a0, (Z3_literals)a1, (unsigned)a2); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_getLiteral(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jint a2) { + Z3_ast result = Z3_get_literal((Z3_context)a0, (Z3_literals)a1, (unsigned)a2); + return (jlong) result; +} +JNIEXPORT void JNICALL Java_Z3Native_disableLiteral(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jint a2) { + Z3_disable_literal((Z3_context)a0, (Z3_literals)a1, (unsigned)a2); +} +JNIEXPORT void JNICALL Java_Z3Native_blockLiterals(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + Z3_block_literals((Z3_context)a0, (Z3_literals)a1); +} +JNIEXPORT jint JNICALL Java_Z3Native_getModelNumConstants(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + unsigned result = Z3_get_model_num_constants((Z3_context)a0, (Z3_model)a1); + return (jint) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_getModelConstant(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jint a2) { + Z3_func_decl result = Z3_get_model_constant((Z3_context)a0, (Z3_model)a1, (unsigned)a2); + return (jlong) result; +} +JNIEXPORT jint JNICALL Java_Z3Native_getModelNumFuncs(JNIEnv * jenv, jclass cls, jlong a0, jlong a1) { + unsigned result = Z3_get_model_num_funcs((Z3_context)a0, (Z3_model)a1); + return (jint) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_getModelFuncDecl(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jint a2) { + Z3_func_decl result = Z3_get_model_func_decl((Z3_context)a0, (Z3_model)a1, (unsigned)a2); + return (jlong) result; +} +JNIEXPORT jboolean JNICALL Java_Z3Native_evalFuncDecl(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2, jobject a3) { + Z3_ast _a3; + Z3_bool result = Z3_eval_func_decl((Z3_context)a0, (Z3_model)a1, (Z3_func_decl)a2, &_a3); + { + jclass mc = jenv->GetObjectClass(a3); + jfieldID fid = jenv->GetFieldID(mc, "value", "J"); + jenv->SetLongField(a3, fid, (jlong) _a3); + } + return (jboolean) result; +} +JNIEXPORT jboolean JNICALL Java_Z3Native_isArrayValue(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2, jobject a3) { + unsigned _a3; + Z3_bool result = Z3_is_array_value((Z3_context)a0, (Z3_model)a1, (Z3_ast)a2, &_a3); + { + jclass mc = jenv->GetObjectClass(a3); + jfieldID fid = jenv->GetFieldID(mc, "value", "I"); + jenv->SetIntField(a3, fid, (jint) _a3); + } + return (jboolean) result; +} +JNIEXPORT void JNICALL Java_Z3Native_getArrayValue(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2, jint a3, jlongArray a4, jlongArray a5, jobject a6) { + Z3_ast * _a4 = (Z3_ast *) malloc(((unsigned)a3) * sizeof(Z3_ast)); + Z3_ast * _a5 = (Z3_ast *) malloc(((unsigned)a3) * sizeof(Z3_ast)); + Z3_ast _a6; + Z3_get_array_value((Z3_context)a0, (Z3_model)a1, (Z3_ast)a2, (unsigned)a3, _a4, _a5, &_a6); + jenv->SetLongArrayRegion(a4, 0, (jsize)a3, (jlong *) _a4); + free(_a4); + jenv->SetLongArrayRegion(a5, 0, (jsize)a3, (jlong *) _a5); + free(_a5); + { + jclass mc = jenv->GetObjectClass(a6); + jfieldID fid = jenv->GetFieldID(mc, "value", "J"); + jenv->SetLongField(a6, fid, (jlong) _a6); + } +} +JNIEXPORT jlong JNICALL Java_Z3Native_getModelFuncElse(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jint a2) { + Z3_ast result = Z3_get_model_func_else((Z3_context)a0, (Z3_model)a1, (unsigned)a2); + return (jlong) result; +} +JNIEXPORT jint JNICALL Java_Z3Native_getModelFuncNumEntries(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jint a2) { + unsigned result = Z3_get_model_func_num_entries((Z3_context)a0, (Z3_model)a1, (unsigned)a2); + return (jint) result; +} +JNIEXPORT jint JNICALL Java_Z3Native_getModelFuncEntryNumArgs(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jint a2, jint a3) { + unsigned result = Z3_get_model_func_entry_num_args((Z3_context)a0, (Z3_model)a1, (unsigned)a2, (unsigned)a3); + return (jint) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_getModelFuncEntryArg(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jint a2, jint a3, jint a4) { + Z3_ast result = Z3_get_model_func_entry_arg((Z3_context)a0, (Z3_model)a1, (unsigned)a2, (unsigned)a3, (unsigned)a4); + return (jlong) result; +} +JNIEXPORT jlong JNICALL Java_Z3Native_getModelFuncEntryValue(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jint a2, jint a3) { + Z3_ast result = Z3_get_model_func_entry_value((Z3_context)a0, (Z3_model)a1, (unsigned)a2, (unsigned)a3); + return (jlong) result; +} +JNIEXPORT jboolean JNICALL Java_Z3Native_eval(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2, jobject a3) { + Z3_ast _a3; + Z3_bool result = Z3_eval((Z3_context)a0, (Z3_model)a1, (Z3_ast)a2, &_a3); + { + jclass mc = jenv->GetObjectClass(a3); + jfieldID fid = jenv->GetFieldID(mc, "value", "J"); + jenv->SetLongField(a3, fid, (jlong) _a3); + } + return (jboolean) result; +} +JNIEXPORT jboolean JNICALL Java_Z3Native_evalDecl(JNIEnv * jenv, jclass cls, jlong a0, jlong a1, jlong a2, jint a3, jlongArray a4, jobject a5) { + Z3_ast * _a4 = (Z3_ast *) jenv->GetLongArrayElements(a4, NULL); + Z3_ast _a5; + Z3_bool result = Z3_eval_decl((Z3_context)a0, (Z3_model)a1, (Z3_func_decl)a2, (unsigned)a3, _a4, &_a5); + jenv->ReleaseLongArrayElements(a4, (jlong *) _a4, JNI_ABORT); + { + jclass mc = jenv->GetObjectClass(a5); + jfieldID fid = jenv->GetFieldID(mc, "value", "J"); + jenv->SetLongField(a5, fid, (jlong) _a5); + } + return (jboolean) result; +} +JNIEXPORT jstring JNICALL Java_Z3Native_contextToString(JNIEnv * jenv, jclass cls, jlong a0) { + Z3_string result = Z3_context_to_string((Z3_context)a0); + return jenv->NewStringUTF(result); +} +JNIEXPORT jstring JNICALL Java_Z3Native_statisticsToString(JNIEnv * jenv, jclass cls, jlong a0) { + Z3_string result = Z3_statistics_to_string((Z3_context)a0); + return jenv->NewStringUTF(result); +} +JNIEXPORT jlong JNICALL Java_Z3Native_getContextAssignment(JNIEnv * jenv, jclass cls, jlong a0) { + Z3_ast result = Z3_get_context_assignment((Z3_context)a0); + return (jlong) result; +} +#ifdef __cplusplus +} +#endif diff --git a/src/api/java/com/Microsoft/Z3/Native.class b/src/api/java/com/Microsoft/Z3/Native.class new file mode 100644 index 000000000..04e71cfb4 Binary files /dev/null and b/src/api/java/com/Microsoft/Z3/Native.class differ diff --git a/src/api/java/com/Microsoft/Z3/Native.java b/src/api/java/com/Microsoft/Z3/Native.java new file mode 100644 index 000000000..564b5cb6f --- /dev/null +++ b/src/api/java/com/Microsoft/Z3/Native.java @@ -0,0 +1,494 @@ +// Automatically generated file +package com.Microsoft.Z3; +public final class Native { + static { System.loadLibrary(""); } + public static native long mkConfig(); + public static native void delConfig(long a0); + public static native void setParamValue(long a0, String a1, String a2); + public static native long mkContext(long a0); + public static native long mkContextRc(long a0); + public static native void delContext(long a0); + public static native void incRef(long a0, long a1); + public static native void decRef(long a0, long a1); + public static native void updateParamValue(long a0, String a1, String a2); + public static native boolean getParamValue(long a0, String a1, String a2); + public static native void interrupt(long a0); + public static native long mkParams(long a0); + public static native void paramsIncRef(long a0, long a1); + public static native void paramsDecRef(long a0, long a1); + public static native void paramsSetBool(long a0, long a1, long a2, boolean a3); + public static native void paramsSetUint(long a0, long a1, long a2, int a3); + public static native void paramsSetDouble(long a0, long a1, long a2, double a3); + public static native void paramsSetSymbol(long a0, long a1, long a2, long a3); + public static native String paramsToString(long a0, long a1); + public static native void paramsValidate(long a0, long a1, long a2); + public static native void paramDescrsIncRef(long a0, long a1); + public static native void paramDescrsDecRef(long a0, long a1); + public static native int paramDescrsGetKind(long a0, long a1, long a2); + public static native int paramDescrsSize(long a0, long a1); + public static native long paramDescrsGetName(long a0, long a1, int a2); + public static native String paramDescrsToString(long a0, long a1); + public static native long mkIntSymbol(long a0, int a1); + public static native long mkStringSymbol(long a0, String a1); + public static native long mkUninterpretedSort(long a0, long a1); + public static native long mkBoolSort(long a0); + public static native long mkIntSort(long a0); + public static native long mkRealSort(long a0); + public static native long mkBvSort(long a0, int a1); + public static native long mkFiniteDomainSort(long a0, long a1, long a2); + public static native long mkArraySort(long a0, long a1, long a2); + public static native long mkTupleSort(long a0, long a1, int a2, long[] a3, long[] a4, Long a5, long[] a6); + public static native long mkEnumerationSort(long a0, long a1, int a2, long[] a3, long[] a4, long[] a5); + public static native long mkListSort(long a0, long a1, long a2, Long a3, Long a4, Long a5, Long a6, Long a7, Long a8); + public static native long mkConstructor(long a0, long a1, long a2, int a3, long[] a4, long[] a5, int[] a6); + public static native void delConstructor(long a0, long a1); + public static native long mkDatatype(long a0, long a1, int a2, long[] a3); + public static native long mkConstructorList(long a0, int a1, long[] a2); + public static native void delConstructorList(long a0, long a1); + public static native void mkDatatypes(long a0, int a1, long[] a2, long[] a3, long[] a4); + public static native void queryConstructor(long a0, long a1, int a2, Long a3, Long a4, long[] a5); + public static native long mkFuncDecl(long a0, long a1, int a2, long[] a3, long a4); + public static native long mkApp(long a0, long a1, int a2, long[] a3); + public static native long mkConst(long a0, long a1, long a2); + public static native long mkFreshFuncDecl(long a0, String a1, int a2, long[] a3, long a4); + public static native long mkFreshConst(long a0, String a1, long a2); + public static native long mkTrue(long a0); + public static native long mkFalse(long a0); + public static native long mkEq(long a0, long a1, long a2); + public static native long mkDistinct(long a0, int a1, long[] a2); + public static native long mkNot(long a0, long a1); + public static native long mkIte(long a0, long a1, long a2, long a3); + public static native long mkIff(long a0, long a1, long a2); + public static native long mkImplies(long a0, long a1, long a2); + public static native long mkXor(long a0, long a1, long a2); + public static native long mkAnd(long a0, int a1, long[] a2); + public static native long mkOr(long a0, int a1, long[] a2); + public static native long mkAdd(long a0, int a1, long[] a2); + public static native long mkMul(long a0, int a1, long[] a2); + public static native long mkSub(long a0, int a1, long[] a2); + public static native long mkUnaryMinus(long a0, long a1); + public static native long mkDiv(long a0, long a1, long a2); + public static native long mkMod(long a0, long a1, long a2); + public static native long mkRem(long a0, long a1, long a2); + public static native long mkPower(long a0, long a1, long a2); + public static native long mkLt(long a0, long a1, long a2); + public static native long mkLe(long a0, long a1, long a2); + public static native long mkGt(long a0, long a1, long a2); + public static native long mkGe(long a0, long a1, long a2); + public static native long mkInt2real(long a0, long a1); + public static native long mkReal2int(long a0, long a1); + public static native long mkIsInt(long a0, long a1); + public static native long mkBvnot(long a0, long a1); + public static native long mkBvredand(long a0, long a1); + public static native long mkBvredor(long a0, long a1); + public static native long mkBvand(long a0, long a1, long a2); + public static native long mkBvor(long a0, long a1, long a2); + public static native long mkBvxor(long a0, long a1, long a2); + public static native long mkBvnand(long a0, long a1, long a2); + public static native long mkBvnor(long a0, long a1, long a2); + public static native long mkBvxnor(long a0, long a1, long a2); + public static native long mkBvneg(long a0, long a1); + public static native long mkBvadd(long a0, long a1, long a2); + public static native long mkBvsub(long a0, long a1, long a2); + public static native long mkBvmul(long a0, long a1, long a2); + public static native long mkBvudiv(long a0, long a1, long a2); + public static native long mkBvsdiv(long a0, long a1, long a2); + public static native long mkBvurem(long a0, long a1, long a2); + public static native long mkBvsrem(long a0, long a1, long a2); + public static native long mkBvsmod(long a0, long a1, long a2); + public static native long mkBvult(long a0, long a1, long a2); + public static native long mkBvslt(long a0, long a1, long a2); + public static native long mkBvule(long a0, long a1, long a2); + public static native long mkBvsle(long a0, long a1, long a2); + public static native long mkBvuge(long a0, long a1, long a2); + public static native long mkBvsge(long a0, long a1, long a2); + public static native long mkBvugt(long a0, long a1, long a2); + public static native long mkBvsgt(long a0, long a1, long a2); + public static native long mkConcat(long a0, long a1, long a2); + public static native long mkExtract(long a0, int a1, int a2, long a3); + public static native long mkSignExt(long a0, int a1, long a2); + public static native long mkZeroExt(long a0, int a1, long a2); + public static native long mkRepeat(long a0, int a1, long a2); + public static native long mkBvshl(long a0, long a1, long a2); + public static native long mkBvlshr(long a0, long a1, long a2); + public static native long mkBvashr(long a0, long a1, long a2); + public static native long mkRotateLeft(long a0, int a1, long a2); + public static native long mkRotateRight(long a0, int a1, long a2); + public static native long mkExtRotateLeft(long a0, long a1, long a2); + public static native long mkExtRotateRight(long a0, long a1, long a2); + public static native long mkInt2bv(long a0, int a1, long a2); + public static native long mkBv2int(long a0, long a1, boolean a2); + public static native long mkBvaddNoOverflow(long a0, long a1, long a2, boolean a3); + public static native long mkBvaddNoUnderflow(long a0, long a1, long a2); + public static native long mkBvsubNoOverflow(long a0, long a1, long a2); + public static native long mkBvsubNoUnderflow(long a0, long a1, long a2, boolean a3); + public static native long mkBvsdivNoOverflow(long a0, long a1, long a2); + public static native long mkBvnegNoOverflow(long a0, long a1); + public static native long mkBvmulNoOverflow(long a0, long a1, long a2, boolean a3); + public static native long mkBvmulNoUnderflow(long a0, long a1, long a2); + public static native long mkSelect(long a0, long a1, long a2); + public static native long mkStore(long a0, long a1, long a2, long a3); + public static native long mkConstArray(long a0, long a1, long a2); + public static native long mkMap(long a0, long a1, int a2, long[] a3); + public static native long mkArrayDefault(long a0, long a1); + public static native long mkSetSort(long a0, long a1); + public static native long mkEmptySet(long a0, long a1); + public static native long mkFullSet(long a0, long a1); + public static native long mkSetAdd(long a0, long a1, long a2); + public static native long mkSetDel(long a0, long a1, long a2); + public static native long mkSetUnion(long a0, int a1, long[] a2); + public static native long mkSetIntersect(long a0, int a1, long[] a2); + public static native long mkSetDifference(long a0, long a1, long a2); + public static native long mkSetComplement(long a0, long a1); + public static native long mkSetMember(long a0, long a1, long a2); + public static native long mkSetSubset(long a0, long a1, long a2); + public static native long mkNumeral(long a0, String a1, long a2); + public static native long mkReal(long a0, int a1, int a2); + public static native long mkInt(long a0, int a1, long a2); + public static native long mkUnsignedInt(long a0, int a1, long a2); + public static native long mkInt64(long a0, long a1, long a2); + public static native long mkUnsignedInt64(long a0, long a1, long a2); + public static native long mkPattern(long a0, int a1, long[] a2); + public static native long mkBound(long a0, int a1, long a2); + public static native long mkForall(long a0, int a1, int a2, long[] a3, int a4, long[] a5, long[] a6, long a7); + public static native long mkExists(long a0, int a1, int a2, long[] a3, int a4, long[] a5, long[] a6, long a7); + public static native long mkQuantifier(long a0, boolean a1, int a2, int a3, long[] a4, int a5, long[] a6, long[] a7, long a8); + public static native long mkQuantifierEx(long a0, boolean a1, int a2, long a3, long a4, int a5, long[] a6, int a7, long[] a8, int a9, long[] a10, long[] a11, long a12); + public static native long mkForallConst(long a0, int a1, int a2, long[] a3, int a4, long[] a5, long a6); + public static native long mkExistsConst(long a0, int a1, int a2, long[] a3, int a4, long[] a5, long a6); + public static native long mkQuantifierConst(long a0, boolean a1, int a2, int a3, long[] a4, int a5, long[] a6, long a7); + public static native long mkQuantifierConstEx(long a0, boolean a1, int a2, long a3, long a4, int a5, long[] a6, int a7, long[] a8, int a9, long[] a10, long a11); + public static native int getSymbolKind(long a0, long a1); + public static native int getSymbolInt(long a0, long a1); + public static native String getSymbolString(long a0, long a1); + public static native long getSortName(long a0, long a1); + public static native int getSortId(long a0, long a1); + public static native long sortToAst(long a0, long a1); + public static native boolean isEqSort(long a0, long a1, long a2); + public static native int getSortKind(long a0, long a1); + public static native int getBvSortSize(long a0, long a1); + public static native boolean getFiniteDomainSortSize(long a0, long a1, Long a2); + public static native long getArraySortDomain(long a0, long a1); + public static native long getArraySortRange(long a0, long a1); + public static native long getTupleSortMkDecl(long a0, long a1); + public static native int getTupleSortNumFields(long a0, long a1); + public static native long getTupleSortFieldDecl(long a0, long a1, int a2); + public static native int getDatatypeSortNumConstructors(long a0, long a1); + public static native long getDatatypeSortConstructor(long a0, long a1, int a2); + public static native long getDatatypeSortRecognizer(long a0, long a1, int a2); + public static native long getDatatypeSortConstructorAccessor(long a0, long a1, int a2, int a3); + public static native int getRelationArity(long a0, long a1); + public static native long getRelationColumn(long a0, long a1, int a2); + public static native long funcDeclToAst(long a0, long a1); + public static native boolean isEqFuncDecl(long a0, long a1, long a2); + public static native int getFuncDeclId(long a0, long a1); + public static native long getDeclName(long a0, long a1); + public static native int getDeclKind(long a0, long a1); + public static native int getDomainSize(long a0, long a1); + public static native int getArity(long a0, long a1); + public static native long getDomain(long a0, long a1, int a2); + public static native long getRange(long a0, long a1); + public static native int getDeclNumParameters(long a0, long a1); + public static native int getDeclParameterKind(long a0, long a1, int a2); + public static native int getDeclIntParameter(long a0, long a1, int a2); + public static native double getDeclDoubleParameter(long a0, long a1, int a2); + public static native long getDeclSymbolParameter(long a0, long a1, int a2); + public static native long getDeclSortParameter(long a0, long a1, int a2); + public static native long getDeclAstParameter(long a0, long a1, int a2); + public static native long getDeclFuncDeclParameter(long a0, long a1, int a2); + public static native String getDeclRationalParameter(long a0, long a1, int a2); + public static native long appToAst(long a0, long a1); + public static native long getAppDecl(long a0, long a1); + public static native int getAppNumArgs(long a0, long a1); + public static native long getAppArg(long a0, long a1, int a2); + public static native boolean isEqAst(long a0, long a1, long a2); + public static native int getAstId(long a0, long a1); + public static native int getAstHash(long a0, long a1); + public static native long getSort(long a0, long a1); + public static native boolean isWellSorted(long a0, long a1); + public static native int getBoolValue(long a0, long a1); + public static native int getAstKind(long a0, long a1); + public static native boolean isApp(long a0, long a1); + public static native boolean isNumeralAst(long a0, long a1); + public static native boolean isAlgebraicNumber(long a0, long a1); + public static native long toApp(long a0, long a1); + public static native long toFuncDecl(long a0, long a1); + public static native String getNumeralString(long a0, long a1); + public static native String getNumeralDecimalString(long a0, long a1, int a2); + public static native long getNumerator(long a0, long a1); + public static native long getDenominator(long a0, long a1); + public static native boolean getNumeralSmall(long a0, long a1, Long a2, Long a3); + public static native boolean getNumeralInt(long a0, long a1, Integer a2); + public static native boolean getNumeralUint(long a0, long a1, Integer a2); + public static native boolean getNumeralUint64(long a0, long a1, Long a2); + public static native boolean getNumeralInt64(long a0, long a1, Long a2); + public static native boolean getNumeralRationalInt64(long a0, long a1, Long a2, Long a3); + public static native long getAlgebraicNumberLower(long a0, long a1, int a2); + public static native long getAlgebraicNumberUpper(long a0, long a1, int a2); + public static native long patternToAst(long a0, long a1); + public static native int getPatternNumTerms(long a0, long a1); + public static native long getPattern(long a0, long a1, int a2); + public static native int getIndexValue(long a0, long a1); + public static native boolean isQuantifierForall(long a0, long a1); + public static native int getQuantifierWeight(long a0, long a1); + public static native int getQuantifierNumPatterns(long a0, long a1); + public static native long getQuantifierPatternAst(long a0, long a1, int a2); + public static native int getQuantifierNumNoPatterns(long a0, long a1); + public static native long getQuantifierNoPatternAst(long a0, long a1, int a2); + public static native int getQuantifierNumBound(long a0, long a1); + public static native long getQuantifierBoundName(long a0, long a1, int a2); + public static native long getQuantifierBoundSort(long a0, long a1, int a2); + public static native long getQuantifierBody(long a0, long a1); + public static native long simplify(long a0, long a1); + public static native long simplifyEx(long a0, long a1, long a2); + public static native String simplifyGetHelp(long a0); + public static native long simplifyGetParamDescrs(long a0); + public static native long updateTerm(long a0, long a1, int a2, long[] a3); + public static native long substitute(long a0, long a1, int a2, long[] a3, long[] a4); + public static native long substituteVars(long a0, long a1, int a2, long[] a3); + public static native long translate(long a0, long a1, long a2); + public static native void modelIncRef(long a0, long a1); + public static native void modelDecRef(long a0, long a1); + public static native boolean modelEval(long a0, long a1, long a2, boolean a3, Long a4); + public static native long modelGetConstInterp(long a0, long a1, long a2); + public static native long modelGetFuncInterp(long a0, long a1, long a2); + public static native int modelGetNumConsts(long a0, long a1); + public static native long modelGetConstDecl(long a0, long a1, int a2); + public static native int modelGetNumFuncs(long a0, long a1); + public static native long modelGetFuncDecl(long a0, long a1, int a2); + public static native int modelGetNumSorts(long a0, long a1); + public static native long modelGetSort(long a0, long a1, int a2); + public static native long modelGetSortUniverse(long a0, long a1, long a2); + public static native boolean isAsArray(long a0, long a1); + public static native long getAsArrayFuncDecl(long a0, long a1); + public static native void funcInterpIncRef(long a0, long a1); + public static native void funcInterpDecRef(long a0, long a1); + public static native int funcInterpGetNumEntries(long a0, long a1); + public static native long funcInterpGetEntry(long a0, long a1, int a2); + public static native long funcInterpGetElse(long a0, long a1); + public static native int funcInterpGetArity(long a0, long a1); + public static native void funcEntryIncRef(long a0, long a1); + public static native void funcEntryDecRef(long a0, long a1); + public static native long funcEntryGetValue(long a0, long a1); + public static native int funcEntryGetNumArgs(long a0, long a1); + public static native long funcEntryGetArg(long a0, long a1, int a2); + public static native int openLog(String a0); + public static native void appendLog(String a0); + public static native void closeLog(); + public static native void toggleWarningMessages(boolean a0); + public static native void setAstPrintMode(long a0, int a1); + public static native String astToString(long a0, long a1); + public static native String patternToString(long a0, long a1); + public static native String sortToString(long a0, long a1); + public static native String funcDeclToString(long a0, long a1); + public static native String modelToString(long a0, long a1); + public static native String benchmarkToSmtlibString(long a0, String a1, String a2, String a3, String a4, int a5, long[] a6, long a7); + public static native long parseSmtlib2String(long a0, String a1, int a2, long[] a3, long[] a4, int a5, long[] a6, long[] a7); + public static native long parseSmtlib2File(long a0, String a1, int a2, long[] a3, long[] a4, int a5, long[] a6, long[] a7); + public static native void parseSmtlibString(long a0, String a1, int a2, long[] a3, long[] a4, int a5, long[] a6, long[] a7); + public static native void parseSmtlibFile(long a0, String a1, int a2, long[] a3, long[] a4, int a5, long[] a6, long[] a7); + public static native int getSmtlibNumFormulas(long a0); + public static native long getSmtlibFormula(long a0, int a1); + public static native int getSmtlibNumAssumptions(long a0); + public static native long getSmtlibAssumption(long a0, int a1); + public static native int getSmtlibNumDecls(long a0); + public static native long getSmtlibDecl(long a0, int a1); + public static native int getSmtlibNumSorts(long a0); + public static native long getSmtlibSort(long a0, int a1); + public static native String getSmtlibError(long a0); + public static native int getErrorCode(long a0); + public static native void setError(long a0, int a1); + public static native String getErrorMsg(int a0); + public static native String getErrorMsgEx(long a0, int a1); + public static native void getVersion(Integer a0, Integer a1, Integer a2, Integer a3); + public static native void enableTrace(String a0); + public static native void disableTrace(String a0); + public static native void resetMemory(); + public static native long mkFixedpoint(long a0); + public static native void fixedpointIncRef(long a0, long a1); + public static native void fixedpointDecRef(long a0, long a1); + public static native void fixedpointAddRule(long a0, long a1, long a2, long a3); + public static native void fixedpointAddFact(long a0, long a1, long a2, int a3, int[] a4); + public static native void fixedpointAssert(long a0, long a1, long a2); + public static native int fixedpointQuery(long a0, long a1, long a2); + public static native int fixedpointQueryRelations(long a0, long a1, int a2, long[] a3); + public static native long fixedpointGetAnswer(long a0, long a1); + public static native String fixedpointGetReasonUnknown(long a0, long a1); + public static native void fixedpointUpdateRule(long a0, long a1, long a2, long a3); + public static native int fixedpointGetNumLevels(long a0, long a1, long a2); + public static native long fixedpointGetCoverDelta(long a0, long a1, int a2, long a3); + public static native void fixedpointAddCover(long a0, long a1, int a2, long a3, long a4); + public static native long fixedpointGetStatistics(long a0, long a1); + public static native void fixedpointRegisterRelation(long a0, long a1, long a2); + public static native void fixedpointSetPredicateRepresentation(long a0, long a1, long a2, int a3, long[] a4); + public static native long fixedpointGetRules(long a0, long a1); + public static native long fixedpointGetAssertions(long a0, long a1); + public static native void fixedpointSetParams(long a0, long a1, long a2); + public static native String fixedpointGetHelp(long a0, long a1); + public static native long fixedpointGetParamDescrs(long a0, long a1); + public static native String fixedpointToString(long a0, long a1, int a2, long[] a3); + public static native long fixedpointFromString(long a0, long a1, String a2); + public static native long fixedpointFromFile(long a0, long a1, String a2); + public static native void fixedpointPush(long a0, long a1); + public static native void fixedpointPop(long a0, long a1); + public static native long mkAstVector(long a0); + public static native void astVectorIncRef(long a0, long a1); + public static native void astVectorDecRef(long a0, long a1); + public static native int astVectorSize(long a0, long a1); + public static native long astVectorGet(long a0, long a1, int a2); + public static native void astVectorSet(long a0, long a1, int a2, long a3); + public static native void astVectorResize(long a0, long a1, int a2); + public static native void astVectorPush(long a0, long a1, long a2); + public static native long astVectorTranslate(long a0, long a1, long a2); + public static native String astVectorToString(long a0, long a1); + public static native long mkAstMap(long a0); + public static native void astMapIncRef(long a0, long a1); + public static native void astMapDecRef(long a0, long a1); + public static native boolean astMapContains(long a0, long a1, long a2); + public static native long astMapFind(long a0, long a1, long a2); + public static native void astMapInsert(long a0, long a1, long a2, long a3); + public static native void astMapErase(long a0, long a1, long a2); + public static native void astMapReset(long a0, long a1); + public static native int astMapSize(long a0, long a1); + public static native long astMapKeys(long a0, long a1); + public static native String astMapToString(long a0, long a1); + public static native long mkGoal(long a0, boolean a1, boolean a2, boolean a3); + public static native void goalIncRef(long a0, long a1); + public static native void goalDecRef(long a0, long a1); + public static native int goalPrecision(long a0, long a1); + public static native void goalAssert(long a0, long a1, long a2); + public static native boolean goalInconsistent(long a0, long a1); + public static native int goalDepth(long a0, long a1); + public static native void goalReset(long a0, long a1); + public static native int goalSize(long a0, long a1); + public static native long goalFormula(long a0, long a1, int a2); + public static native int goalNumExprs(long a0, long a1); + public static native boolean goalIsDecidedSat(long a0, long a1); + public static native boolean goalIsDecidedUnsat(long a0, long a1); + public static native long goalTranslate(long a0, long a1, long a2); + public static native String goalToString(long a0, long a1); + public static native long mkTactic(long a0, String a1); + public static native void tacticIncRef(long a0, long a1); + public static native void tacticDecRef(long a0, long a1); + public static native long mkProbe(long a0, String a1); + public static native void probeIncRef(long a0, long a1); + public static native void probeDecRef(long a0, long a1); + public static native long tacticAndThen(long a0, long a1, long a2); + public static native long tacticOrElse(long a0, long a1, long a2); + public static native long tacticParOr(long a0, int a1, long[] a2); + public static native long tacticParAndThen(long a0, long a1, long a2); + public static native long tacticTryFor(long a0, long a1, int a2); + public static native long tacticWhen(long a0, long a1, long a2); + public static native long tacticCond(long a0, long a1, long a2, long a3); + public static native long tacticRepeat(long a0, long a1, int a2); + public static native long tacticSkip(long a0); + public static native long tacticFail(long a0); + public static native long tacticFailIf(long a0, long a1); + public static native long tacticFailIfNotDecided(long a0); + public static native long tacticUsingParams(long a0, long a1, long a2); + public static native long probeConst(long a0, double a1); + public static native long probeLt(long a0, long a1, long a2); + public static native long probeGt(long a0, long a1, long a2); + public static native long probeLe(long a0, long a1, long a2); + public static native long probeGe(long a0, long a1, long a2); + public static native long probeEq(long a0, long a1, long a2); + public static native long probeAnd(long a0, long a1, long a2); + public static native long probeOr(long a0, long a1, long a2); + public static native long probeNot(long a0, long a1); + public static native int getNumTactics(long a0); + public static native String getTacticName(long a0, int a1); + public static native int getNumProbes(long a0); + public static native String getProbeName(long a0, int a1); + public static native String tacticGetHelp(long a0, long a1); + public static native long tacticGetParamDescrs(long a0, long a1); + public static native String tacticGetDescr(long a0, String a1); + public static native String probeGetDescr(long a0, String a1); + public static native double probeApply(long a0, long a1, long a2); + public static native long tacticApply(long a0, long a1, long a2); + public static native long tacticApplyEx(long a0, long a1, long a2, long a3); + public static native void applyResultIncRef(long a0, long a1); + public static native void applyResultDecRef(long a0, long a1); + public static native String applyResultToString(long a0, long a1); + public static native int applyResultGetNumSubgoals(long a0, long a1); + public static native long applyResultGetSubgoal(long a0, long a1, int a2); + public static native long applyResultConvertModel(long a0, long a1, int a2, long a3); + public static native long mkSolver(long a0); + public static native long mkSimpleSolver(long a0); + public static native long mkSolverForLogic(long a0, long a1); + public static native long mkSolverFromTactic(long a0, long a1); + public static native String solverGetHelp(long a0, long a1); + public static native long solverGetParamDescrs(long a0, long a1); + public static native void solverSetParams(long a0, long a1, long a2); + public static native void solverIncRef(long a0, long a1); + public static native void solverDecRef(long a0, long a1); + public static native void solverPush(long a0, long a1); + public static native void solverPop(long a0, long a1, int a2); + public static native void solverReset(long a0, long a1); + public static native int solverGetNumScopes(long a0, long a1); + public static native void solverAssert(long a0, long a1, long a2); + public static native void solverAssertAndTrack(long a0, long a1, long a2, long a3); + public static native long solverGetAssertions(long a0, long a1); + public static native int solverCheck(long a0, long a1); + public static native int solverCheckAssumptions(long a0, long a1, int a2, long[] a3); + public static native long solverGetModel(long a0, long a1); + public static native long solverGetProof(long a0, long a1); + public static native long solverGetUnsatCore(long a0, long a1); + public static native String solverGetReasonUnknown(long a0, long a1); + public static native long solverGetStatistics(long a0, long a1); + public static native String solverToString(long a0, long a1); + public static native String statsToString(long a0, long a1); + public static native void statsIncRef(long a0, long a1); + public static native void statsDecRef(long a0, long a1); + public static native int statsSize(long a0, long a1); + public static native String statsGetKey(long a0, long a1, int a2); + public static native boolean statsIsUint(long a0, long a1, int a2); + public static native boolean statsIsDouble(long a0, long a1, int a2); + public static native int statsGetUintValue(long a0, long a1, int a2); + public static native double statsGetDoubleValue(long a0, long a1, int a2); + public static native long mkInjectiveFunction(long a0, long a1, int a2, long[] a3, long a4); + public static native void setLogic(long a0, String a1); + public static native void push(long a0); + public static native void pop(long a0, int a1); + public static native int getNumScopes(long a0); + public static native void persistAst(long a0, long a1, int a2); + public static native void assertCnstr(long a0, long a1); + public static native int checkAndGetModel(long a0, Long a1); + public static native int check(long a0); + public static native int checkAssumptions(long a0, int a1, long[] a2, Long a3, Long a4, Integer a5, long[] a6); + public static native int getImpliedEqualities(long a0, int a1, long[] a2, int[] a3); + public static native void delModel(long a0, long a1); + public static native void softCheckCancel(long a0); + public static native int getSearchFailure(long a0); + public static native long mkLabel(long a0, long a1, boolean a2, long a3); + public static native long getRelevantLabels(long a0); + public static native long getRelevantLiterals(long a0); + public static native long getGuessedLiterals(long a0); + public static native void delLiterals(long a0, long a1); + public static native int getNumLiterals(long a0, long a1); + public static native long getLabelSymbol(long a0, long a1, int a2); + public static native long getLiteral(long a0, long a1, int a2); + public static native void disableLiteral(long a0, long a1, int a2); + public static native void blockLiterals(long a0, long a1); + public static native int getModelNumConstants(long a0, long a1); + public static native long getModelConstant(long a0, long a1, int a2); + public static native int getModelNumFuncs(long a0, long a1); + public static native long getModelFuncDecl(long a0, long a1, int a2); + public static native boolean evalFuncDecl(long a0, long a1, long a2, Long a3); + public static native boolean isArrayValue(long a0, long a1, long a2, Integer a3); + public static native void getArrayValue(long a0, long a1, long a2, int a3, long[] a4, long[] a5, Long a6); + public static native long getModelFuncElse(long a0, long a1, int a2); + public static native int getModelFuncNumEntries(long a0, long a1, int a2); + public static native int getModelFuncEntryNumArgs(long a0, long a1, int a2, int a3); + public static native long getModelFuncEntryArg(long a0, long a1, int a2, int a3, int a4); + public static native long getModelFuncEntryValue(long a0, long a1, int a2, int a3); + public static native boolean eval(long a0, long a1, long a2, Long a3); + public static native boolean evalDecl(long a0, long a1, long a2, int a3, long[] a4, Long a5); + public static native String contextToString(long a0); + public static native String statisticsToString(long a0); + public static native long getContextAssignment(long a0); + public static void main(String[] args) { + Integer major = 0, minor = 0, build = 0, revision = 0; + getVersion(major, minor, build, revision); + System.out.format("Z3 (for Java) %d.%d.%d%n", major, minor, build); + } +} diff --git a/src/api/java/com/Microsoft/Z3/Numeral.java b/src/api/java/com/Microsoft/Z3/Numeral.java new file mode 100644 index 000000000..5f9291b51 --- /dev/null +++ b/src/api/java/com/Microsoft/Z3/Numeral.java @@ -0,0 +1,262 @@ +/** + * This file was automatically generated from Numeral.cs + **/ + +package com.Microsoft.Z3; +/* using System; */ + +/* using System.Numerics; */ + + /** + * Integer Numerals + **/ + public class IntNum extends IntExpr + { + + IntNum(Context ctx, IntPtr obj) + { super(ctx, obj); + + } + + + /** + * Retrieve the 64-bit unsigned integer value. + **/ + public UInt64 UInt64() + { + UInt64 res = 0; + if (Native.getNumeralInteger64(Context.nCtx, NativeObject, res) == 0) + throw new Z3Exception("Numeral is not a 64 bit unsigned"); + return res; + } + + /** + * Retrieve the int value. + **/ + public int Int() + { + int res = 0; + if (Native.getNumeralInt(Context.nCtx, NativeObject, res) == 0) + throw new Z3Exception("Numeral is not an int"); + return res; + } + + /** + * Retrieve the 64-bit int value. + **/ + public Int64 Int64() + { + Int64 res = 0; + if (Native.getNumeralInt64(Context.nCtx, NativeObject, res) == 0) + throw new Z3Exception("Numeral is not an int64"); + return res; + } + + /** + * Retrieve the int value. + **/ + public Integer UInt() + { + Integer res = 0; + if (Native.getNumeralInteger(Context.nCtx, NativeObject, res) == 0) + throw new Z3Exception("Numeral is not a Integer"); + return res; + } + + /** + * Retrieve the BigInteger value. + **/ + public BigInteger BigInteger() + { + return BigInteger.Parse(this.toString()); + } + + /** + * Returns a string representation of the numeral. + **/ + public String toString() + { + return Native.getNumeralString(Context.nCtx, NativeObject); + } + } + + /** + * Rational Numerals + **/ + public class RatNum extends RealExpr + { + /** + * The numerator of a rational numeral. + **/ + public IntNum Numerator() { + + + return new IntNum(Context, Native.getNumerator(Context.nCtx, NativeObject)); } + + /** + * The denominator of a rational numeral. + **/ + public IntNum Denominator() { + + + return new IntNum(Context, Native.getDenominator(Context.nCtx, NativeObject)); } + + /** + * Converts the numerator of the rational to a BigInteger + **/ + public BigInteger BigIntNumerator() + { + IntNum n = Numerator; + return BigInteger.Parse(n.toString()); + } + + /** + * Converts the denominator of the rational to a BigInteger + **/ + public BigInteger BigIntDenominator() + { + IntNum n = Denominator; + return BigInteger.Parse(n.toString()); + } + + /** + * Returns a string representation in decimal notation. + * The result has at most decimal places. + **/ + public String ToDecimalString(Integer precision) + { + return Native.getNumeralDecimalString(Context.nCtx, NativeObject, precision); + } + + /** + * Returns a string representation of the numeral. + **/ + public String toString() + { + return Native.getNumeralString(Context.nCtx, NativeObject); + } + + RatNum(Context ctx, IntPtr obj) + { super(ctx, obj); + + } + } + + + /** + * Bit-vector numerals + **/ + public class BitVecNum extends BitVecExpr + { + /** + * Retrieve the 64-bit unsigned integer value. + **/ + public UInt64 UInt64() + { + UInt64 res = 0; + if (Native.getNumeralInteger64(Context.nCtx, NativeObject, res) == 0) + throw new Z3Exception("Numeral is not a 64 bit unsigned"); + return res; + } + + /** + * Retrieve the int value. + **/ + public int Int() + { + int res = 0; + if (Native.getNumeralInt(Context.nCtx, NativeObject, res) == 0) + throw new Z3Exception("Numeral is not an int"); + return res; + } + + /** + * Retrieve the 64-bit int value. + **/ + public Int64 Int64() + { + Int64 res = 0; + if (Native.getNumeralInt64(Context.nCtx, NativeObject, res) == 0) + throw new Z3Exception("Numeral is not an int64"); + return res; + } + + /** + * Retrieve the int value. + **/ + public Integer UInt() + { + Integer res = 0; + if (Native.getNumeralInteger(Context.nCtx, NativeObject, res) == 0) + throw new Z3Exception("Numeral is not a Integer"); + return res; + } + + /** + * Retrieve the BigInteger value. + **/ + public BigInteger BigInteger() + { + return BigInteger.Parse(this.toString()); + } + + /** + * Returns a string representation of the numeral. + **/ + public String toString() + { + return Native.getNumeralString(Context.nCtx, NativeObject); + } + + BitVecNum(Context ctx, IntPtr obj) { super(ctx, obj); } + } + + /** + * Algebraic numbers + **/ + public class AlgebraicNum extends ArithExpr + { + /** + * Return a upper bound for a given real algebraic number. + * The interval isolating the number is smaller than 1/10^. + * + * the precision of the result + * @return A numeral Expr of sort Real + **/ + public RatNum ToUpper(Integer precision) + { + + + return new RatNum(Context, Native.getAlgebraicNumberUpper(Context.nCtx, NativeObject, precision)); + } + + /** + * Return a lower bound for the given real algebraic number. + * The interval isolating the number is smaller than 1/10^. + * + * + * @return A numeral Expr of sort Real + **/ + public RatNum ToLower(Integer precision) + { + + + return new RatNum(Context, Native.getAlgebraicNumberLower(Context.nCtx, NativeObject, precision)); + } + + /** + * Returns a string representation in decimal notation. + * The result has at most decimal places. + **/ + public String ToDecimal(Integer precision) + { + + + return Native.getNumeralDecimalString(Context.nCtx, NativeObject, precision); + } + + AlgebraicNum(Context ctx, IntPtr obj) + { super(ctx, obj); + + } + } diff --git a/src/api/java/com/Microsoft/Z3/ParamDescrs.java b/src/api/java/com/Microsoft/Z3/ParamDescrs.java new file mode 100644 index 000000000..c4e9d4be4 --- /dev/null +++ b/src/api/java/com/Microsoft/Z3/ParamDescrs.java @@ -0,0 +1,87 @@ +/** + * This file was automatically generated from ParamDescrs.cs + **/ + +package com.Microsoft.Z3; + +/* using System; */ + + /** + * A ParamDescrs describes a set of parameters. + **/ + public class ParamDescrs extends Z3Object + { + /** + * validate a set of parameters. + **/ + public void Validate(Params p) + { + + Native.paramsValidate(Context.nCtx, p.NativeObject, NativeObject); + } + + /** + * Retrieve kind of parameter. + **/ + public Z3ParamKind GetKind(Symbol name) + { + + return (Z3ParamKind)Native.paramDescrsGetKind(Context.nCtx, NativeObject, name.NativeObject); + } + + /** + * Retrieve all names of parameters. + **/ + public Symbol[] Names() + { + Integer sz = Native.paramDescrsSize(Context.nCtx, NativeObject); + Symbol[] names = new Symbol[sz]; + for (Integer i = 0; i < sz; ++i) { + names[i] = Symbol.Create(Context, Native.paramDescrsGetName(Context.nCtx, NativeObject, i)); + return names; + } + } + + /** + * The size of the ParamDescrs. + **/ + public Integer Size() { return Native.paramDescrsSize(Context.nCtx, NativeObject); } + + /** + * Retrieves a string representation of the ParamDescrs. + **/ + public String toString() + { + return Native.paramDescrstoString(Context.nCtx, NativeObject); + } + + ParamDescrs(Context ctx, IntPtr obj) + { super(ctx, obj); + + } + + class DecRefQueue extends Z3.DecRefQueue + { + public void IncRef(Context ctx, IntPtr obj) + { + Native.paramDescrsIncRef(ctx.nCtx, obj); + } + + public void DecRef(Context ctx, IntPtr obj) + { + Native.paramDescrsDecRef(ctx.nCtx, obj); + } + }; + + void IncRef(IntPtr o) + { + Context.ParamDescrsDRQ.IncAndClear(Context, o); + super.IncRef(o); + } + + void DecRef(IntPtr o) + { + Context.ParamDescrsDRQ.Add(o); + super.DecRef(o); + } + } diff --git a/src/api/java/com/Microsoft/Z3/Params.java b/src/api/java/com/Microsoft/Z3/Params.java new file mode 100644 index 000000000..0dd320778 --- /dev/null +++ b/src/api/java/com/Microsoft/Z3/Params.java @@ -0,0 +1,126 @@ +/** + * This file was automatically generated from Params.cs + **/ + +package com.Microsoft.Z3; + +/* using System; */ + + /** + * A ParameterSet represents a configuration in the form of Symbol/value pairs. + **/ + public class Params extends Z3Object + { + /** + * Adds a parameter setting. + **/ + public void Add(Symbol name, boolean value) + { + + + Native.paramsSetBoolean(Context.nCtx, NativeObject, name.NativeObject, (value) ? 1 : 0); + } + + /** + * Adds a parameter setting. + **/ + public void Add(Symbol name, Integer value) + { + + + Native.paramsSetInteger(Context.nCtx, NativeObject, name.NativeObject, value); + } + + /** + * Adds a parameter setting. + **/ + public void Add(Symbol name, double value) + { + + + Native.paramsSetDouble(Context.nCtx, NativeObject, name.NativeObject, value); + } + + /** + * Adds a parameter setting. + **/ + public void Add(Symbol name, Symbol value) + { + + + + Native.paramsSetSymbol(Context.nCtx, NativeObject, name.NativeObject, value.NativeObject); + } + + /** + * Adds a parameter setting. + **/ + public void Add(String name, boolean value) + { + Native.paramsSetBoolean(Context.nCtx, NativeObject, Context.MkSymbol(name).NativeObject, (value) ? 1 : 0); + } + + /** + * Adds a parameter setting. + **/ + public void Add(String name, Integer value) + { + Native.paramsSetInteger(Context.nCtx, NativeObject, Context.MkSymbol(name).NativeObject, value); + } + + /** + * Adds a parameter setting. + **/ + public void Add(String name, double value) + { + Native.paramsSetDouble(Context.nCtx, NativeObject, Context.MkSymbol(name).NativeObject, value); + } + + /** + * Adds a parameter setting. + **/ + public void Add(String name, Symbol value) + { + + + Native.paramsSetSymbol(Context.nCtx, NativeObject, Context.MkSymbol(name).NativeObject, value.NativeObject); + } + + /** + * A string representation of the parameter set. + **/ + public String toString() + { + return Native.paramstoString(Context.nCtx, NativeObject); + } + + Params(Context ctx) + { super(ctx, Native.mkParams(ctx.nCtx)); + + } + + class DecRefQueue extends Z3.DecRefQueue + { + public void IncRef(Context ctx, IntPtr obj) + { + Native.paramsIncRef(ctx.nCtx, obj); + } + + public void DecRef(Context ctx, IntPtr obj) + { + Native.paramsDecRef(ctx.nCtx, obj); + } + }; + + void IncRef(IntPtr o) + { + Context.ParamsDRQ.IncAndClear(Context, o); + super.IncRef(o); + } + + void DecRef(IntPtr o) + { + Context.ParamsDRQ.Add(o); + super.DecRef(o); + } + } diff --git a/src/api/java/com/Microsoft/Z3/Pattern.java b/src/api/java/com/Microsoft/Z3/Pattern.java new file mode 100644 index 000000000..6bd1ef811 --- /dev/null +++ b/src/api/java/com/Microsoft/Z3/Pattern.java @@ -0,0 +1,48 @@ +/** + * This file was automatically generated from Pattern.cs + **/ + +package com.Microsoft.Z3; + +/* using System; */ +/* using System.Runtime.InteropServices; */ + + /** + * Patterns comprise a list of terms. The list should be + * non-empty. If the list comprises of more than one term, it is + * also called a multi-pattern. + **/ + public class Pattern extends AST + { + /** + * The number of terms in the pattern. + **/ + public Integer NumTerms() { return Native.getPatternNumTerms(Context.nCtx, NativeObject); } + + /** + * The terms in the pattern. + **/ + public Expr[] Terms() + { + + + Integer n = NumTerms; + Expr[] res = new Expr[n]; + for (Integer i = 0; i < n; i++) + res[i] = Expr.Create(Context, Native.getPattern(Context.nCtx, NativeObject, i)); + return res; + } + + /** + * A string representation of the pattern. + **/ + public String toString() + { + return Native.patterntoString(Context.nCtx, NativeObject); + } + + Pattern(Context ctx, IntPtr obj) + { super(ctx, obj); + + } + } diff --git a/src/api/java/com/Microsoft/Z3/Probe.java b/src/api/java/com/Microsoft/Z3/Probe.java new file mode 100644 index 000000000..c651edb86 --- /dev/null +++ b/src/api/java/com/Microsoft/Z3/Probe.java @@ -0,0 +1,72 @@ +/** + * This file was automatically generated from Probe.cs + **/ + +package com.Microsoft.Z3; + +/* using System; */ +/* using System.Runtime.InteropServices; */ + + /** + * Probes are used to inspect a goal (aka problem) and collect information that may be used to decide + * which solver and/or preprocessing step will be used. + * The complete list of probes may be obtained using the procedures Context.NumProbes + * and Context.ProbeNames. + * It may also be obtained using the command (help-tactics) in the SMT 2.0 front-end. + **/ + public class Probe extends Z3Object + { + /** + * Execute the probe over the goal. + * @return A probe always produce a double value. + * "Boolean" probes return 0.0 for false, and a value different from 0.0 for true. + **/ + public double Apply(Goal g) + { + + + Context.CheckContextMatch(g); + return Native.probeApply(Context.nCtx, NativeObject, g.NativeObject); + } + + /** + * Apply the probe to a goal. + **/ + public double this[Goal() + + + return Apply(g); } } + + Probe(Context ctx, IntPtr obj) + { super(ctx, obj); + + Probe(Context ctx, String name) + { super(ctx, Native.mkProbe(ctx.nCtx, name)); + + } + + class DecRefQueue extends Z3.DecRefQueue + { + public void IncRef(Context ctx, IntPtr obj) + { + Native.probeIncRef(ctx.nCtx, obj); + } + + public void DecRef(Context ctx, IntPtr obj) + { + Native.probeDecRef(ctx.nCtx, obj); + } + }; + + void IncRef(IntPtr o) + { + Context.ProbeDRQ.IncAndClear(Context, o); + super.IncRef(o); + } + + void DecRef(IntPtr o) + { + Context.ProbeDRQ.Add(o); + super.DecRef(o); + } + } diff --git a/src/api/java/com/Microsoft/Z3/Quantifier.java b/src/api/java/com/Microsoft/Z3/Quantifier.java new file mode 100644 index 000000000..1a279aff0 --- /dev/null +++ b/src/api/java/com/Microsoft/Z3/Quantifier.java @@ -0,0 +1,198 @@ +/** + * This file was automatically generated from Quantifier.cs + **/ + +package com.Microsoft.Z3; + +/* using System; */ + + /** + * Quantifier expressions. + **/ + public class Quantifier extends BoolExpr + { + /** + * Indicates whether the quantifier is universal. + **/ + public boolean IsUniversal() { return Native.isQuantifierForall(Context.nCtx, NativeObject) != 0; } + + /** + * Indicates whether the quantifier is existential. + **/ + public boolean IsExistential() { return !IsUniversal; } + + /** + * The weight of the quantifier. + **/ + public Integer Weight() { return Native.getQuantifierWeight(Context.nCtx, NativeObject); } + + /** + * The number of patterns. + **/ + public Integer NumPatterns() { return Native.getQuantifierNumPatterns(Context.nCtx, NativeObject); } + + /** + * The patterns. + **/ + public Pattern[] Patterns() + { + + + Integer n = NumPatterns; + Pattern[] res = new Pattern[n]; + for (Integer i = 0; i < n; i++) + res[i] = new Pattern(Context, Native.getQuantifierPatternAst(Context.nCtx, NativeObject, i)); + return res; + } + + /** + * The number of no-patterns. + **/ + public Integer NumNoPatterns() { return Native.getQuantifierNumNoPatterns(Context.nCtx, NativeObject); } + + /** + * The no-patterns. + **/ + public Pattern[] NoPatterns() + { + + + Integer n = NumNoPatterns; + Pattern[] res = new Pattern[n]; + for (Integer i = 0; i < n; i++) + res[i] = new Pattern(Context, Native.getQuantifierNoPatternAst(Context.nCtx, NativeObject, i)); + return res; + } + + /** + * The number of bound variables. + **/ + public Integer NumBound() { return Native.getQuantifierNumBound(Context.nCtx, NativeObject); } + + /** + * The symbols for the bound variables. + **/ + public Symbol[] BoundVariableNames() + { + + + Integer n = NumBound; + Symbol[] res = new Symbol[n]; + for (Integer i = 0; i < n; i++) + res[i] = Symbol.Create(Context, Native.getQuantifierBoundName(Context.nCtx, NativeObject, i)); + return res; + } + + /** + * The sorts of the bound variables. + **/ + public Sort[] BoundVariableSorts() + { + + + Integer n = NumBound; + Sort[] res = new Sort[n]; + for (Integer i = 0; i < n; i++) + res[i] = Sort.Create(Context, Native.getQuantifierBoundSort(Context.nCtx, NativeObject, i)); + return res; + } + + /** + * The body of the quantifier. + **/ + public BoolExpr Body() { + + + return new BoolExpr(Context, Native.getQuantifierBody(Context.nCtx, NativeObject)); } + + Quantifier(Context ctx, boolean isForall, Sort[] sorts, Symbol[] names, Expr body, + Integer weight = 1, Pattern[] patterns = null, Expr[] noPatterns = null, + Symbol quantifierID = null, Symbol skolemID = null + ) + { super(ctx); + + + + + + + + + + + Context.CheckContextMatch(patterns); + Context.CheckContextMatch(noPatterns); + Context.CheckContextMatch(sorts); + Context.CheckContextMatch(names); + Context.CheckContextMatch(body); + + if (sorts.Length != names.Length) + throw new Z3Exception("Number of sorts does not match number of names"); + + IntPtr[] Patterns = AST.ArrayToNative(patterns); + + if (noPatterns == null && quantifierID == null && skolemID == null) + { + NativeObject = Native.mkQuantifier(ctx.nCtx, (isForall) ? 1 : 0, weight, + AST.ArrayLength(patterns), AST.ArrayToNative(patterns), + AST.ArrayLength(sorts), AST.ArrayToNative(sorts), + Symbol.ArrayToNative(names), + body.NativeObject); + } + else + { + NativeObject = Native.mkQuantifierEx(ctx.nCtx, (isForall) ? 1 : 0, weight, + AST.GetNativeObject(quantifierID), AST.GetNativeObject(skolemID), + AST.ArrayLength(patterns), AST.ArrayToNative(patterns), + AST.ArrayLength(noPatterns), AST.ArrayToNative(noPatterns), + AST.ArrayLength(sorts), AST.ArrayToNative(sorts), + Symbol.ArrayToNative(names), + body.NativeObject); + } + } + + Quantifier(Context ctx, boolean isForall, Expr[] bound, Expr body, + Integer weight = 1, Pattern[] patterns = null, Expr[] noPatterns = null, + Symbol quantifierID = null, Symbol skolemID = null + ) + { super(ctx); + + + + + + + + Context.CheckContextMatch(noPatterns); + Context.CheckContextMatch(patterns); + //Context.CheckContextMatch(bound); + Context.CheckContextMatch(body); + + if (noPatterns == null && quantifierID == null && skolemID == null) + { + NativeObject = Native.mkQuantifierConst(ctx.nCtx, (isForall) ? 1 : 0, weight, + AST.ArrayLength(bound), AST.ArrayToNative(bound), + AST.ArrayLength(patterns), AST.ArrayToNative(patterns), + body.NativeObject); + } + else + { + NativeObject = Native.mkQuantifierConstEx(ctx.nCtx, (isForall) ? 1 : 0, weight, + AST.GetNativeObject(quantifierID), AST.GetNativeObject(skolemID), + AST.ArrayLength(bound), AST.ArrayToNative(bound), + AST.ArrayLength(patterns), AST.ArrayToNative(patterns), + AST.ArrayLength(noPatterns), AST.ArrayToNative(noPatterns), + body.NativeObject); + } + } + + + Quantifier(Context ctx, IntPtr obj) { super(ctx, obj); } + + void CheckNativeObject(IntPtr obj) + { + if ((Z3AstKind)Native.getAstKind(Context.nCtx, obj) != Z3AstKind.Z3QUANTIFIERAST) + throw new Z3Exception("Underlying object is not a quantifier"); + super.CheckNativeObject(obj); + } + } diff --git a/src/api/java/com/Microsoft/Z3/Solver.java b/src/api/java/com/Microsoft/Z3/Solver.java new file mode 100644 index 000000000..a28687722 --- /dev/null +++ b/src/api/java/com/Microsoft/Z3/Solver.java @@ -0,0 +1,247 @@ +/** + * This file was automatically generated from Solver.cs + **/ + +package com.Microsoft.Z3; + +/* using System; */ + + /** + * Solvers. + **/ + public class Solver extends Z3Object + { + /** + * A string that describes all available solver parameters. + **/ + public String Help() + { + + + return Native.solverGetHelp(Context.nCtx, NativeObject); + } + + /** + * Sets the solver parameters. + **/ + public void setParameters(Params value) + { + + + Context.CheckContextMatch(value); + Native.solverSetParams(Context.nCtx, NativeObject, value.NativeObject); + } + + /** + * Retrieves parameter descriptions for solver. + **/ + public ParamDescrs ParameterDescriptions() { return new ParamDescrs(Context, Native.solverGetParamDescrs(Context.nCtx, NativeObject)); } + + + /** + * The current number of backtracking points (scopes). + * + * + **/ + public Integer NumScopes() { return Native.solverGetNumScopes(Context.nCtx, NativeObject); } + + /** + * Creates a backtracking point. + * + **/ + public void Push() + { + Native.solverPush(Context.nCtx, NativeObject); + } + + /** + * Backtracks backtracking points. + * Note that an exception is thrown if is not smaller than NumScopes + * + **/ + public void Pop(Integer n) + { + Native.solverPop(Context.nCtx, NativeObject, n); + } + + /** + * Resets the Solver. + * This removes all assertions from the solver. + **/ + public void Reset() + { + Native.solverReset(Context.nCtx, NativeObject); + } + + /** + * Assert a constraint (or multiple) into the solver. + **/ + public void Assert(BoolExpr[] constraints) + { + + + + Context.CheckContextMatch(constraints); + for (BoolExpr.Iterator a = constraints.iterator(); a.hasNext(); ) + { + Native.solverAssert(Context.nCtx, NativeObject, a.NativeObject); + } + } + + /** + * The number of assertions in the solver. + **/ + public Integer NumAssertions() + { + ASTVector ass = new ASTVector(Context, Native.solverGetAssertions(Context.nCtx, NativeObject)); + return ass.Size; + } + + /** + * The set of asserted formulas. + **/ + public BoolExpr[] Assertions() + { + + + ASTVector ass = new ASTVector(Context, Native.solverGetAssertions(Context.nCtx, NativeObject)); + Integer n = ass.Size; + BoolExpr[] res = new BoolExpr[n]; + for (Integer i = 0; i < n; i++) + res[i] = new BoolExpr(Context, ass[i].NativeObject); + return res; + } + + /** + * Checks whether the assertions in the solver are consistent or not. + * + * + * + * + * + **/ + public Status Check(Expr[] assumptions) + { + Z3Lboolean r; + if (assumptions == null) + r = (Z3Lboolean)Native.solverCheck(Context.nCtx, NativeObject); + else + r = (Z3Lboolean)Native.solverCheckAssumptions(Context.nCtx, NativeObject, (Integer)assumptions.Length, AST.ArrayToNative(assumptions)); + switch (r) + { + case Z3Lboolean.Z3LTRUE: return Status.SATISFIABLE; + case Z3Lboolean.Z3LFALSE: return Status.UNSATISFIABLE; + default: return Status.UNKNOWN; + } + } + + /** + * The model of the last Check. + * + * The result is null if Check was not invoked before, + * if its results was not SATISFIABLE, or if model production is not enabled. + * + **/ + public Model Model() + { + IntPtr x = Native.solverGetModel(Context.nCtx, NativeObject); + if (x == IntPtr.Zero) + return null; + else + return new Model(Context, x); + } + + /** + * The proof of the last Check. + * + * The result is null if Check was not invoked before, + * if its results was not UNSATISFIABLE, or if proof production is disabled. + * + **/ + public Expr Proof() + { + IntPtr x = Native.solverGetProof(Context.nCtx, NativeObject); + if (x == IntPtr.Zero) + return null; + else + return Expr.Create(Context, x); + } + + /** + * The unsat core of the last Check. + * + * The unsat core is a subset of Assertions + * The result is empty if Check was not invoked before, + * if its results was not UNSATISFIABLE, or if core production is disabled. + * + **/ + public Expr[] UnsatCore() + { + + + ASTVector core = new ASTVector(Context, Native.solverGetUnsatCore(Context.nCtx, NativeObject)); + Integer n = core.Size; + Expr[] res = new Expr[n]; + for (Integer i = 0; i < n; i++) + res[i] = Expr.Create(Context, core[i].NativeObject); + return res; + } + + /** + * A brief justification of why the last call to Check returned UNKNOWN. + **/ + public String ReasonUnknown() + { + + + return Native.solverGetReasonUnknown(Context.nCtx, NativeObject); + } + + /** + * Solver statistics. + **/ + public Statistics Statistics() + { + + + return new Statistics(Context, Native.solverGetStatistics(Context.nCtx, NativeObject)); + } + + /** + * A string representation of the solver. + **/ + public String toString() + { + return Native.solvertoString(Context.nCtx, NativeObject); + } + + Solver(Context ctx, IntPtr obj) + { super(ctx, obj); + + } + + class DecRefQueue extends Z3.DecRefQueue + { + public void IncRef(Context ctx, IntPtr obj) + { + Native.solverIncRef(ctx.nCtx, obj); + } + + public void DecRef(Context ctx, IntPtr obj) + { + Native.solverDecRef(ctx.nCtx, obj); + } + }; + + void IncRef(IntPtr o) + { + Context.SolverDRQ.IncAndClear(Context, o); + super.IncRef(o); + } + + void DecRef(IntPtr o) + { + Context.SolverDRQ.Add(o); + super.DecRef(o); + } + } diff --git a/src/api/java/com/Microsoft/Z3/Sort.java b/src/api/java/com/Microsoft/Z3/Sort.java new file mode 100644 index 000000000..f75624f1a --- /dev/null +++ b/src/api/java/com/Microsoft/Z3/Sort.java @@ -0,0 +1,579 @@ +/** + * This file was automatically generated from Sort.cs + **/ + +package com.Microsoft.Z3; + +/* using System; */ + + /** + * The Sort class implements type information for ASTs. + **/ + public class Sort extends AST + { + /** + * Comparison operator. + * A Sort + * A Sort + * @return True if and are from the same context + * and represent the same sort; false otherwise. + **/ + /* Overloaded operators are not translated. */ + + /** + * Comparison operator. + * A Sort + * A Sort + * @return True if and are not from the same context + * or represent different sorts; false otherwise. + **/ + /* Overloaded operators are not translated. */ + + /** + * Equality operator for objects of type Sort. + * + * @return + **/ + public boolean Equals(object o) + { + Sort casted = o as Sort; + if (casted == null) return false; + return this == casted; + } + + /** + * Hash code generation for Sorts + * @return A hash code + **/ + public int GetHashCode() + { + return super.GetHashCode(); + } + + /** + * Returns a unique identifier for the sort. + **/ + new public Integer Id() { return Native.getSortId(Context.nCtx, NativeObject); } + + /** + * The kind of the sort. + **/ + public Z3_sort_kind SortKind() { return (Z3SortKind)Native.getSortKind(Context.nCtx, NativeObject); } + + /** + * The name of the sort + **/ + public Symbol Name() { + + return Symbol.Create(Context, Native.getSortName(Context.nCtx, NativeObject)); } + + /** + * A string representation of the sort. + **/ + public String toString() + { + return Native.sorttoString(Context.nCtx, NativeObject); + } + + /** + * Sort constructor + **/ + protected Sort(Context ctx) { super(ctx); } + Sort(Context ctx, IntPtr obj) { super(ctx, obj); } + + void CheckNativeObject(IntPtr obj) + { + if (Native.getAstKind(Context.nCtx, obj) != (Integer)Z3AstKind.Z3SORTAST) + throw new Z3Exception("Underlying object is not a sort"); + super.CheckNativeObject(obj); + } + + new static Sort Create(Context ctx, IntPtr obj) + { + + + + switch ((Z3SortKind)Native.getSortKind(ctx.nCtx, obj)) + { + case Z3SortKind.Z3ARRAYSORT: return new ArraySort(ctx, obj); + case Z3SortKind.Z3BOOLSORT: return new BoolSort(ctx, obj); + case Z3SortKind.Z3BVSORT: return new BitVecSort(ctx, obj); + case Z3SortKind.Z3DATATYPESORT: return new DatatypeSort(ctx, obj); + case Z3SortKind.Z3INTSORT: return new IntSort(ctx, obj); + case Z3SortKind.Z3REALSORT: return new RealSort(ctx, obj); + case Z3SortKind.Z3UNINTERPRETEDSORT: return new UninterpretedSort(ctx, obj); + case Z3SortKind.Z3FINITEDOMAINSORT: return new FiniteDomainSort(ctx, obj); + case Z3SortKind.Z3RELATIONSORT: return new RelationSort(ctx, obj); + default: + throw new Z3Exception("Unknown sort kind"); + } + } + } + + /** + * A Boolean sort. + **/ + public class BoolSort extends Sort + { + BoolSort(Context ctx, IntPtr obj) { super(ctx, obj); } + BoolSort(Context ctx) { super(ctx, Native.mkBooleanSort(ctx.nCtx)); } + }; + + /** + * An arithmetic sort, i.e., Int or Real. + **/ + public class ArithSort extends Sort + { + ArithSort(Context ctx, IntPtr obj) { super(ctx, obj); } + }; + + /** + * An Integer sort + **/ + public class IntSort extends ArithSort + { + IntSort(Context ctx, IntPtr obj) + { super(ctx, obj); + + } + IntSort(Context ctx) + { super(ctx, Native.mkIntSort(ctx.nCtx)); + + } + } + + /** + * A real sort + **/ + public class RealSort extends ArithSort + { + RealSort(Context ctx, IntPtr obj) + { super(ctx, obj); + + } + RealSort(Context ctx) + { super(ctx, Native.mkRealSort(ctx.nCtx)); + + } + } + + /** + * Bit-vector sorts. + **/ + public class BitVecSort extends Sort + { + /** + * The size of the bit-vector sort. + **/ + public Integer Size() { return Native.getBvSortSize(Context.nCtx, NativeObject); } + + BitVecSort(Context ctx, IntPtr obj) { super(ctx, obj); } + BitVecSort(Context ctx, Integer size) { super(ctx, Native.mkBvSort(ctx.nCtx, size)); } + }; + + /** + * Array sorts. + **/ + public class ArraySort extends Sort + { + /** + * The domain of the array sort. + **/ + public Sort Domain() { + + + return Sort.Create(Context, Native.getArraySortDomain(Context.nCtx, NativeObject)); } + + /** + * The range of the array sort. + **/ + public Sort Range() { + + + return Sort.Create(Context, Native.getArraySortRange(Context.nCtx, NativeObject)); } + + ArraySort(Context ctx, IntPtr obj) { super(ctx, obj); } + ArraySort(Context ctx, Sort domain, Sort range) + { super(ctx, Native.mkArraySort(ctx.nCtx, domain.NativeObject, range.NativeObject)); + + + + } + }; + + /** + * Datatype sorts. + **/ + public class DatatypeSort extends Sort + { + /** + * The number of constructors of the datatype sort. + **/ + public Integer NumConstructors() { return Native.getDatatypeSortNumConstructors(Context.nCtx, NativeObject); } + + /** + * The constructors. + **/ + public FuncDecl[] Constructors() + { + + + Integer n = NumConstructors; + FuncDecl[] res = new FuncDecl[n]; + for (Integer i = 0; i < n; i++) + res[i] = new FuncDecl(Context, Native.getDatatypeSortConstructor(Context.nCtx, NativeObject, i)); + return res; + } + + /** + * The recognizers. + **/ + public FuncDecl[] Recognizers() + { + + + Integer n = NumConstructors; + FuncDecl[] res = new FuncDecl[n]; + for (Integer i = 0; i < n; i++) + res[i] = new FuncDecl(Context, Native.getDatatypeSortRecognizer(Context.nCtx, NativeObject, i)); + return res; + } + + /** + * The constructor accessors. + **/ + public FuncDecl[][] Accessors() + { + + + Integer n = NumConstructors; + FuncDecl[][] res = new FuncDecl[n][]; + for (Integer i = 0; i < n; i++) + { + FuncDecl fd = new FuncDecl(Context, Native.getDatatypeSortConstructor(Context.nCtx, NativeObject, i)); + Integer ds = fd.DomainSize; + FuncDecl[] tmp = new FuncDecl[ds]; + for (Integer j = 0; j < ds; j++) + tmp[j] = new FuncDecl(Context, Native.getDatatypeSortConstructorAccessor(Context.nCtx, NativeObject, i, j)); + res[i] = tmp; + return res; + } + } + + DatatypeSort(Context ctx, IntPtr obj) { super(ctx, obj); } + + DatatypeSort(Context ctx, Symbol name, Constructor[] constructors) + { super(ctx, Native.mkDatatype(ctx.nCtx, name.NativeObject, (Integer)constructors.Length, ArrayToNative(constructors))); + + + + } + }; + + /** + * Uninterpreted Sorts + **/ + public class UninterpretedSort extends Sort + { + UninterpretedSort(Context ctx, IntPtr obj) + { super(ctx, obj); + + } + UninterpretedSort(Context ctx, Symbol s) + { super(ctx, Native.mkUninterpretedSort(ctx.nCtx, s.NativeObject)); + + + } + } + + /** + * Tuple sorts. + **/ + public class TupleSort extends Sort + { + /** + * The constructor function of the tuple. + **/ + public FuncDecl MkDecl() { + + + return new FuncDecl(Context, Native.getTupleSortMkDecl(Context.nCtx, NativeObject)); } + + /** + * The number of fields in the tuple. + **/ + public Integer NumFields() { return Native.getTupleSortNumFields(Context.nCtx, NativeObject); } + + /** + * The field declarations. + **/ + public FuncDecl[] FieldDecls() + { + + + Integer n = NumFields; + FuncDecl[] res = new FuncDecl[n]; + for (Integer i = 0; i < n; i++) + res[i] = new FuncDecl(Context, Native.getTupleSortFieldDecl(Context.nCtx, NativeObject, i)); + return res; + } + + TupleSort(Context ctx, Symbol name, Integer numFields, Symbol[] fieldNames, Sort[] fieldSorts) + { super(ctx); + + + + IntPtr t = IntPtr.Zero; + NativeObject = Native.mkTupleSort(ctx.nCtx, name.NativeObject, numFields, + Symbol.ArrayToNative(fieldNames), AST.ArrayToNative(fieldSorts), + t, new IntPtr[numFields]); + } + }; + + /** + * Enumeration sorts. + **/ + public class EnumSort extends Sort + { + /** + * The function declarations of the constants in the enumeration. + **/ + public FuncDecl[] ConstDecls() { + + + return Constdecls; } + + /** + * The constants in the enumeration. + **/ + public Expr[] Consts() { + + + return Consts; } + + /** + * The test predicates for the constants in the enumeration. + **/ + public FuncDecl[] TesterDecls() { + + + return Testerdecls; + } + + + private void ObjectInvariant() + { + + + + } + + + + private FuncDecl[] Constdecls = null, Testerdecls = null; + private Expr[] Consts = null; + + EnumSort(Context ctx, Symbol name, Symbol[] enumNames) + { super(ctx); + + + + + int n = enumNames.Length; + IntPtr[] nConstdecls = new IntPtr[n]; + IntPtr[] nTesters = new IntPtr[n]; + NativeObject = Native.mkEnumerationSort(ctx.nCtx, name.NativeObject, (Integer)n, + Symbol.ArrayToNative(enumNames), nConstdecls, nTesters); + Constdecls = new FuncDecl[n]; + for (Integer i = 0; i < n; i++) + Constdecls[i] = new FuncDecl(ctx, nConstdecls[i]); + Testerdecls = new FuncDecl[n]; + for (Integer i = 0; i < n; i++) + Testerdecls[i] = new FuncDecl(ctx, nTesters[i]); + Consts = new Expr[n]; + for (Integer i = 0; i < n; i++) + Consts[i] = ctx.MkApp(Constdecls[i]); + } + }; + + /** + * List sorts. + **/ + public class ListSort extends Sort + { + /** + * The declaration of the nil function of this list sort. + **/ + public FuncDecl NilDecl() + + return nilDecl; } } + + /** + * The empty list. + **/ + public Expr Nil() + { + + return nilConst; + } + + /** + * The declaration of the isNil function of this list sort. + **/ + public FuncDecl IsNilDecl() + { + + return isNilDecl; + } + + /** + * The declaration of the cons function of this list sort. + **/ + public FuncDecl ConsDecl() + { + + return consDecl; + } + + /** + * The declaration of the isCons function of this list sort. + * + **/ + public FuncDecl IsConsDecl() + { + + return isConsDecl; + } + + /** + * The declaration of the head function of this list sort. + **/ + public FuncDecl HeadDecl() + { + + return headDecl; + } + + /** + * The declaration of the tail function of this list sort. + **/ + public FuncDecl TailDecl() + { + + return tailDecl; + } + + + private void ObjectInvariant() + { + + + + + + + + } + + + + private FuncDecl nilDecl, isNilDecl, consDecl, isConsDecl, headDecl, tailDecl; + private Expr nilConst; + + ListSort(Context ctx, Symbol name, Sort elemSort) + { super(ctx); + + + + + IntPtr inil = IntPtr.Zero, + iisnil = IntPtr.Zero, + icons = IntPtr.Zero, + iiscons = IntPtr.Zero, + ihead = IntPtr.Zero, + itail = IntPtr.Zero; + + NativeObject = Native.mkListSort(ctx.nCtx, name.NativeObject, elemSort.NativeObject, + inil, iisnil, icons, iiscons, ihead, itail); + nilDecl = new FuncDecl(ctx, inil); + isNilDecl = new FuncDecl(ctx, iisnil); + consDecl = new FuncDecl(ctx, icons); + isConsDecl = new FuncDecl(ctx, iiscons); + headDecl = new FuncDecl(ctx, ihead); + tailDecl = new FuncDecl(ctx, itail); + nilConst = ctx.MkConst(nilDecl); + } + }; + + /** + * Relation sorts. + **/ + public class RelationSort extends Sort + { + /** + * The arity of the relation sort. + **/ + public Integer Arity() { return Native.getRelationArity(Context.nCtx, NativeObject); } + + /** + * The sorts of the columns of the relation sort. + **/ + public Sort[] ColumnSorts() + { + + + if (mColumnSorts != null) + return mColumnSorts; + + Integer n = Arity; + Sort[] res = new Sort[n]; + for (Integer i = 0; i < n; i++) + res[i] = Sort.Create(Context, Native.getRelationColumn(Context.nCtx, NativeObject, i)); + return res; + } + + private Sort[] mColumnSorts = null; + + RelationSort(Context ctx, IntPtr obj) + { super(ctx, obj); + + } + } + + /** + * Finite domain sorts. + **/ + public class FiniteDomainSort extends Sort + { + /** + * The size of the finite domain sort. + **/ + public ulong Size() { ulong res = 0; Native.getFiniteDomainSortSize(Context.nCtx, NativeObject, ref res); return res; } + + FiniteDomainSort(Context ctx, IntPtr obj) + { super(ctx, obj); + + } + FiniteDomainSort(Context ctx, Symbol name, ulong size) + { super(ctx, Native.mkFiniteDomainSort(ctx.nCtx, name.NativeObject, size)); + + + + } + } + + /** + * Set sorts. + **/ + public class SetSort extends Sort + { + SetSort(Context ctx, IntPtr obj) + { super(ctx, obj); + + } + SetSort(Context ctx, Sort ty) + { super(ctx, Native.mkSetSort(ctx.nCtx, ty.NativeObject)); + + + } + } diff --git a/src/api/java/com/Microsoft/Z3/Statistics.java b/src/api/java/com/Microsoft/Z3/Statistics.java new file mode 100644 index 000000000..0e509a5d9 --- /dev/null +++ b/src/api/java/com/Microsoft/Z3/Statistics.java @@ -0,0 +1,167 @@ +/** + * This file was automatically generated from Statistics.cs + **/ + +package com.Microsoft.Z3; + +/* using System; */ + + /** + * Objects of this class track statistical information about solvers. + **/ + public class Statistics extends Z3Object + { + /** + * Statistical data is organized into pairs of [Key, Entry], where every + * Entry is either a DoubleEntry or a UIntEntry + **/ + public class Entry + { + /** + * The key of the entry. + **/ + /** + * The uint-value of the entry. + **/ + public Integer UIntValue() { return mInteger; } + /** + * The double-value of the entry. + **/ + public double DoubleValue() { return mDouble; } + /** + * True if the entry is uint-valued. + **/ + public boolean IsUInt() { return mIsInteger; } + /** + * True if the entry is double-valued. + **/ + public boolean IsDouble() { return mIsDouble; } + + /** + * The string representation of the the entry's value. + **/ + public String Value() + { + + + if (IsUInt) + return mInteger.toString(); + else if (IsDouble) + return mDouble.toString(); + else + throw new Z3Exception("Unknown statistical entry type"); + } + + /** + * The string representation of the Entry. + **/ + public String toString() + { + return Key + ": " + Value; + } + + private boolean mIsInteger = false; + private boolean mIsDouble = false; + private Integer mInteger = 0; + private double mDouble = 0.0; + Entry(String k, Integer v) { Key = k; mIsInteger = true; mInteger = v; } + Entry(String k, double v) { Key = k; mIsDouble = true; mDouble = v; } + } + + /** + * A string representation of the statistical data. + **/ + public String toString() + { + return Native.statstoString(Context.nCtx, NativeObject); + } + + /** + * The number of statistical data. + **/ + public Integer Size() { return Native.statsSize(Context.nCtx, NativeObject); } + + /** + * The data entries. + **/ + public Entry[] Entries() + { + + + + + Integer n = Size; + Entry[] res = new Entry[n]; + for (Integer i = 0; i < n; i++) + { + Entry e; + String k = Native.statsGetKey(Context.nCtx, NativeObject, i); + if (Native.statsIsInteger(Context.nCtx, NativeObject, i) != 0) + e = new Entry(k, Native.statsGetIntegerValue(Context.nCtx, NativeObject, i)); + else if (Native.statsIsDouble(Context.nCtx, NativeObject, i) != 0) + e = new Entry(k, Native.statsGetDoubleValue(Context.nCtx, NativeObject, i)); + else + throw new Z3Exception("Unknown data entry value"); + res[i] = e; + return res; + } + } + + /** + * The statistical counters. + **/ + public String[] Keys() + { + + + Integer n = Size; + String[] res = new String[n]; + for (Integer i = 0; i < n; i++) + res[i] = Native.statsGetKey(Context.nCtx, NativeObject, i); + return res; + } + + /** + * The value of a particular statistical counter. + * Returns null if the key is unknown. + **/ + public Entry this[String key]() + { + Integer n = Size; + Entry[] es = Entries; + for (Integer i = 0; i < n; i++) + if (es[i].Key == key) + return es[i]; + return null; + } + + Statistics(Context ctx, IntPtr obj) + { super(ctx, obj); + + } + + class DecRefQueue extends Z3.DecRefQueue + { + public void IncRef(Context ctx, IntPtr obj) + { + Native.statsIncRef(ctx.nCtx, obj); + } + + public void DecRef(Context ctx, IntPtr obj) + { + Native.statsDecRef(ctx.nCtx, obj); + } + }; + + void IncRef(IntPtr o) + { + Context.StatisticsDRQ.IncAndClear(Context, o); + super.IncRef(o); + } + + void DecRef(IntPtr o) + { + Context.StatisticsDRQ.Add(o); + super.DecRef(o); + } + } diff --git a/src/api/java/com/Microsoft/Z3/Status.java b/src/api/java/com/Microsoft/Z3/Status.java new file mode 100644 index 000000000..86c902285 --- /dev/null +++ b/src/api/java/com/Microsoft/Z3/Status.java @@ -0,0 +1,26 @@ +/** + * This file was automatically generated from Status.cs + **/ + +package com.Microsoft.Z3; + +/* using System; */ + + /** + * Status values. + **/ + /** + * Used to signify an unsatisfiable status. + **/ + UNSATISFIABLE = -1, + + /** + * Used to signify an unknown status. + **/ + UNKNOWN = 0, + + /** + * Used to signify a satisfiable status. + **/ + SATISFIABLE = 1 + diff --git a/src/api/java/com/Microsoft/Z3/Symbol.java b/src/api/java/com/Microsoft/Z3/Symbol.java new file mode 100644 index 000000000..0023bc670 --- /dev/null +++ b/src/api/java/com/Microsoft/Z3/Symbol.java @@ -0,0 +1,140 @@ +/** + * This file was automatically generated from Symbol.cs + **/ + +package com.Microsoft.Z3; + +/* using System; */ +/* using System.Runtime.InteropServices; */ + + /** + * Symbols are used to name several term and type constructors. + **/ + public class Symbol extends Z3Object + { + /** + * The kind of the symbol (int or string) + **/ + protected Z3SymbolKind Kind + { + get { return (Z3SymbolKind)Native.getSymbolKind(Context.nCtx, NativeObject); } + } + + /** + * Indicates whether the symbol is of Int kind + **/ + public boolean IsIntSymbol() + { + return Kind == Z3SymbolKind.Z3INTSYMBOL; + } + + /** + * Indicates whether the symbol is of string kind. + **/ + public boolean IsStringSymbol() + { + return Kind == Z3SymbolKind.Z3STRINGSYMBOL; + } + + /** + * A string representation of the symbol. + **/ + public String toString() + { + if (IsIntSymbol()) + return ((IntSymbol)this).Int.toString(); + else if (IsStringSymbol()) + return ((StringSymbol)this).String; + else + throw new Z3Exception("Unknown symbol kind encountered"); + } + + /** + * Symbol constructor + **/ + protected Symbol(Context ctx, IntPtr obj) { super(ctx, obj); + + } + + static Symbol Create(Context ctx, IntPtr obj) + { + + + + switch ((Z3SymbolKind)Native.getSymbolKind(ctx.nCtx, obj)) + { + case Z3SymbolKind.Z3INTSYMBOL: return new IntSymbol(ctx, obj); + case Z3SymbolKind.Z3STRINGSYMBOL: return new StringSymbol(ctx, obj); + default: + throw new Z3Exception("Unknown symbol kind encountered"); + } + } + } + + /** + * Numbered symbols + **/ + public class IntSymbol extends Symbol + { + /** + * The int value of the symbol. + * Throws an exception if the symbol is not of int kind. + **/ + public int Int() + { + if (!IsIntSymbol()) + throw new Z3Exception("Int requested from non-Int symbol"); + return Native.getSymbolInt(Context.nCtx, NativeObject); + } + + IntSymbol(Context ctx, IntPtr obj) + { super(ctx, obj); + + } + IntSymbol(Context ctx, int i) + { super(ctx, Native.mkIntSymbol(ctx.nCtx, i)); + + } + + void CheckNativeObject(IntPtr obj) + { + if ((Z3SymbolKind)Native.getSymbolKind(Context.nCtx, obj) != Z3SymbolKind.Z3INTSYMBOL) + throw new Z3Exception("Symbol is not of integer kind"); + super.CheckNativeObject(obj); + } + } + + /** + * Named symbols + **/ + public class StringSymbol extends Symbol + { + /** + * The string value of the symbol. + * Throws an exception if the symbol is not of string kind. + **/ + public String String() + { + + + if (!IsStringSymbol()) + throw new Z3Exception("String requested from non-String symbol"); + return Native.getSymbolString(Context.nCtx, NativeObject); + } + + StringSymbol(Context ctx, IntPtr obj) { super(ctx, obj); + + } + + StringSymbol(Context ctx, String s) { super(ctx, Native.mkStringSymbol(ctx.nCtx, s)); + + } + + void CheckNativeObject(IntPtr obj) + { + if ((Z3SymbolKind)Native.getSymbolKind(Context.nCtx, obj) != Z3SymbolKind.Z3STRINGSYMBOL) + throw new Z3Exception("Symbol is not of String kind"); + + super.CheckNativeObject(obj); + } + } diff --git a/src/api/java/com/Microsoft/Z3/Tactic.java b/src/api/java/com/Microsoft/Z3/Tactic.java new file mode 100644 index 000000000..a73d1faa7 --- /dev/null +++ b/src/api/java/com/Microsoft/Z3/Tactic.java @@ -0,0 +1,107 @@ +/** + * This file was automatically generated from Tactic.cs + **/ + +package com.Microsoft.Z3; + +/* using System; */ + + /** + * Tactics are the basic building block for creating custom solvers for specific problem domains. + * The complete list of tactics may be obtained using Context.NumTactics + * and Context.TacticNames. + * It may also be obtained using the command (help-tactics) in the SMT 2.0 front-end. + **/ + public class Tactic extends Z3Object + { + /** + * A string containing a description of parameters accepted by the tactic. + **/ + public String Help() + { + + + return Native.tacticGetHelp(Context.nCtx, NativeObject); + } + + + /** + * Retrieves parameter descriptions for Tactics. + **/ + public ParamDescrs ParameterDescriptions() { return new ParamDescrs(Context, Native.tacticGetParamDescrs(Context.nCtx, NativeObject)); } + + + /** + * Execute the tactic over the goal. + **/ + public ApplyResult Apply(Goal g, Params p) + { + + + + Context.CheckContextMatch(g); + if (p == null) + return new ApplyResult(Context, Native.tacticApply(Context.nCtx, NativeObject, g.NativeObject)); + else + { + Context.CheckContextMatch(p); + return new ApplyResult(Context, Native.tacticApplyEx(Context.nCtx, NativeObject, g.NativeObject, p.NativeObject)); + } + } + + /** + * Apply the tactic to a goal. + **/ + public ApplyResult this[Goal g]() + { + + + + return Apply(g); + } + + /** + * Creates a solver that is implemented using the given tactic. + * + **/ + public Solver Solver() + { + + + return Context.MkSolver(this); + } + + Tactic(Context ctx, IntPtr obj) + { super(ctx, obj); + + } + Tactic(Context ctx, String name) + { super(ctx, Native.mkTactic(ctx.nCtx, name)); + + } + + class DecRefQueue extends Z3.DecRefQueue + { + public void IncRef(Context ctx, IntPtr obj) + { + Native.tacticIncRef(ctx.nCtx, obj); + } + + public void DecRef(Context ctx, IntPtr obj) + { + Native.tacticDecRef(ctx.nCtx, obj); + } + }; + + void IncRef(IntPtr o) + { + Context.TacticDRQ.IncAndClear(Context, o); + super.IncRef(o); + } + + void DecRef(IntPtr o) + { + Context.TacticDRQ.Add(o); + super.DecRef(o); + } + } diff --git a/src/api/java/com/Microsoft/Z3/Version.class b/src/api/java/com/Microsoft/Z3/Version.class new file mode 100644 index 000000000..472674ff6 Binary files /dev/null and b/src/api/java/com/Microsoft/Z3/Version.class differ diff --git a/src/api/java/com/Microsoft/Z3/Version.java b/src/api/java/com/Microsoft/Z3/Version.java new file mode 100644 index 000000000..c6384df02 --- /dev/null +++ b/src/api/java/com/Microsoft/Z3/Version.java @@ -0,0 +1,68 @@ +/** + * This file was automatically generated from Version.cs + **/ + +package com.Microsoft.Z3; + +/* using System; */ + + /** + * Version information. + * Note that this class is static. + **/ + public final class Version + { + Version() { } + + /** + * The major version + **/ + public Integer Major() + { + Integer major = 0, minor = 0, build = 0, revision = 0; + Native.getVersion(major, minor, build, revision); + return major; + } + + /** + * The minor version + **/ + public Integer Minor() + { + Integer major = 0, minor = 0, build = 0, revision = 0; + Native.getVersion(major, minor, build, revision); + return minor; + } + + /** + * The build version + **/ + public Integer Build() + { + Integer major = 0, minor = 0, build = 0, revision = 0; + Native.getVersion(major, minor, build, revision); + return build; + } + + /** + * The revision + **/ + public Integer Revision() + { + Integer major = 0, minor = 0, build = 0, revision = 0; + Native.getVersion(major, minor, build, revision); + return revision; + } + + /** + * A string representation of the version information. + **/ + public String toString() + { + + + Integer major = 0, minor = 0, build = 0, revision = 0; + Native.getVersion(major, minor, build, revision); + return major.toString() + "." + minor.toString() + "." + build.toString() + "." + revision.toString(); + } + } diff --git a/src/api/java/com/Microsoft/Z3/Z3Exception.java b/src/api/java/com/Microsoft/Z3/Z3Exception.java new file mode 100644 index 000000000..0e05add87 --- /dev/null +++ b/src/api/java/com/Microsoft/Z3/Z3Exception.java @@ -0,0 +1,28 @@ +/** + * This file was automatically generated from Z3Exception.cs + **/ + +package com.Microsoft.Z3; + +/* using System; */ + + /** + * The exception base class for error reporting from Z3 + **/ + public class Z3Exception extends Exception + { + /** + * Constructor. + **/ + public Z3Exception() { super(); } + + /** + * Constructor. + **/ + public Z3Exception(String message) { super(message); } + + /** + * Constructor. + **/ + public Z3Exception(String message, System.Exception inner) { super(message, inner); } + } diff --git a/src/api/java/com/Microsoft/Z3/Z3Object.java b/src/api/java/com/Microsoft/Z3/Z3Object.java new file mode 100644 index 000000000..980f200ef --- /dev/null +++ b/src/api/java/com/Microsoft/Z3/Z3Object.java @@ -0,0 +1,120 @@ +/** + * This file was automatically generated from Z3Object.cs + **/ + +package com.Microsoft.Z3; + +/* using System; */ + + /** + * Internal base class for interfacing with native Z3 objects. + * Should not be used externally. + **/ + public class Z3Object extends IDisposable + { + /** + * Finalizer. + **/ + protected void finalize() + { + Dispose(); + } + + /** + * Disposes of the underlying native Z3 object. + **/ + public void Dispose() + { + if (mNObj != IntPtr.Zero) + { + DecRef(mNObj); + mNObj = IntPtr.Zero; + } + + if (mCtx != null) + { + mCtx.refCount--; + if (mCtx.refCount == 0) + GC.ReRegisterForFinalize(mCtx); + mCtx = null; + } + + GC.SuppressFinalize(this); + } + + + private void ObjectInvariant() + { + + } + + + private Context mCtx = null; + private IntPtr mNObj = IntPtr.Zero; + + Z3Object(Context ctx) + { + + + ctx.refCount++; + mCtx = ctx; + } + + Z3Object(Context ctx, IntPtr obj) + { + + + ctx.refCount++; + mCtx = ctx; + IncRef(obj); + mNObj = obj; + } + + void IncRef(IntPtr o) { } + void DecRef(IntPtr o) { } + + void CheckNativeObject(IntPtr obj) { } + + IntPtr NativeObject + { + get { return mNObj; } + set + { + if (value != IntPtr.Zero) { CheckNativeObject(value); IncRef(value); } + if (mNObj != IntPtr.Zero) { DecRef(mNObj); } + mNObj = value; + } + } + + static IntPtr GetNativeObject(Z3Object s) + { + if (s == null) return new IntPtr(); + return s.NativeObject; + } + + Context Context + { + get + { + + return mCtx; + } + } + + static IntPtr[] ArrayToNative(Z3Object[] a) + { + + + + if (a == null) return null; + IntPtr[] an = new IntPtr[a.Length]; + for (Integer i = 0; i < a.Length; i++) + if (a[i] != null) an[i] = a[i].NativeObject; + return an; + } + + static Integer ArrayLength(Z3Object[] a) + { + return (a == null)?0:(Integer)a.Length; + } + } diff --git a/src/api/java/mk_java.py b/src/api/java/mk_java.py new file mode 100644 index 000000000..fc69fa9b5 --- /dev/null +++ b/src/api/java/mk_java.py @@ -0,0 +1,233 @@ +############################################ +# Copyright (c) 2012 Microsoft Corporation +# +# Auxiliary scripts for generating Java bindings +# from the managed API. +# +# Author: Christoph M. Wintersteiger (cwinter) +############################################ + +CS="../dotnet/" +EXT=".cs" +EXCLUDE=["Enumerations.cs", "Native.cs", "AssemblyInfo.cs"] +OUTDIR="com/Microsoft/Z3/" + +import os +import fileinput +import string +import re + +def mk_java_bindings(): + print "Generating Java bindings (from C# bindings in " + CS + ")." + for root, dirs, files in os.walk(CS): + for fn in files: + if not fn in EXCLUDE and fn.endswith(EXT): + translate(fn) + +def subst_getters(s, getters): + for g in getters: + s = s.replace(g, g + "()") + +def type_replace(s): + s = s.replace("bool", "boolean") + s = s.replace("uint", "Integer") + s = s.replace("string", "String") + return s + +def rename_native(s): + a = re.sub("Native.Z3_(?P\w+)", "Native.\g", s) + lc_callback = lambda pat: pat.group("id").upper() + return re.sub("_(?P\w)", lc_callback, a) + + +def translate(filename): + tgtfn = OUTDIR + filename.replace(EXT, ".java") + print "Translating " + filename + " to " + tgtfn + tgt = open(tgtfn, "w") + in_header = 0 + in_class = 0 + in_static_class = 0 + in_javadoc = 0 + lastindent = 0 + skip_brace = 0 + in_getter = "" + in_getter_type = "" + in_unsupported = 0 + getters = [] + for line in fileinput.input(os.path.join(CS, filename)): + s = string.rstrip(string.lstrip(line)) + if in_javadoc: + if s.startswith("///"): + lastindent = line.find(s); + if s.startswith("/// "): + pass + else: + a = line + a = a.replace("", "") + a = a.replace("", "") + a = a.replace("///"," *") + a = a.replace("","@return ") + a = a.replace("","") + tgt.write(a) + else: + t = "" + for i in range(0, lastindent): + t += " " + tgt.write(t + " **/\n") + in_javadoc = 0 + + if in_unsupported: + if s == "}": + in_unsupported = 0 + elif not in_javadoc: + if not in_header and s.find("/*++") != -1: + in_header = 1 + tgt.write("/**\n") + elif in_header and s.startswith("--*/"): + in_header = 0 + tgt.write(" * This file was automatically generated from " + filename + " \n") + tgt.write(" **/\n") + tgt.write("\npackage com.Microsoft.Z3;\n") + + elif in_header == 1: + # tgt.write(" * " + line.replace(filename, tgtfn)) + pass + elif s.startswith("using"): + if s.find("System.Diagnostics.Contracts") == -1: + tgt.write("/* " + s + " */\n") + elif s.startswith("namespace"): + pass + elif s.startswith("public") and s.find("operator") and (s.find("==") != -1 or s.find("!=") != -1): + t = "" + for i in range(0, line.find(s)+1): + t += " " + tgt.write(t + "/* Overloaded operators are not translated. */\n") + in_unsupported = 1; + elif s.startswith("public class") or s.startswith("internal class"): + a = line.replace(":", "extends").replace("internal ", "") + a = a.replace(", IComparable", "") + tgt.write(a) + in_class = 1 + in_static_class = 0 + elif s.startswith("public static class"): + tgt.write(line.replace(":", "extends").replace("static", "final")) + in_class = 1 + in_static_class = 1 + elif s.startswith("/// "): + tgt.write(line.replace("/// ", "/**")) + in_javadoc = 1 + elif skip_brace and s == "{": + skip_brace = 0 + elif s.find("public") != -1 and s.find("class") == -1 and s.find("event") == -1 and s.find("(") == -1: + tokens = s.split(" ") + print "# TOKENS: " + str(len(tokens)) + if len(tokens) == 3: + in_getter = tokens[2] + in_getter_type = type_replace((tokens[0] + " " + tokens[1])) + if in_static_class: + in_getter_type = in_getter_type.replace("static", "") + lastindent = line.find(s) + skip_brace = 1 + elif len(tokens) == 4: + in_getter = tokens[3] + in_getter_type = type_replace(tokens[0] + " " + tokens[1] + " " + tokens[2]) + if in_static_class: + in_getter_type = in_getter_type.replace("static", "") + lastindent = line.find(s) + skip_brace = 1 + else: + in_getter = tokens[2] + in_getter_type = type_replace(tokens[0] + " " + tokens[1]) + if in_static_class: + in_getter_type = in_getter_type.replace("static", "") + rest = s[s.find("get ") + 4:-1] + subst_getters(rest, getters) + rest = type_replace(rest) + rest = rename_native(rest) + t = "" + for i in range(0, lastindent): + t += " " + tgt.write(t + in_getter_type + " " + in_getter + "() " + rest + "\n") + getters.append(in_getter) + print "ACC: " + s + " --> " + in_getter + elif s.find("{ get {") != -1: + line = type_replace(line) + line = line.replace("internal ", "") + d = line[0:line.find("{ get")] + rest = line[line.find("{ get")+5:] + rest = rest.replace("} }", "}") + subst_getters(rest, getters) + rest = rename_native(rest) + tgt.write(d + "()" + rest) + print "ACC: " + s + " --> " + in_getter + elif in_getter != "" and s.startswith("get"): + t = "" + for i in range(0, lastindent): + t += " " + if len(s) > 3: rest = s[3:] + else: rest = "" + subst_getters(rest, getters) + rest = type_replace(rest) + rest = rename_native(rest) + tgt.write(t + in_getter_type + " " + in_getter + "() " + rest + "\n") + elif in_getter != "" and s.startswith("set"): + t = "" + for i in range(0, lastindent): + t += " " + if len(s) > 3: rest = type_replace(s[3:]) + else: rest = "" + subst_getters(rest, getters) + rest = rest.replace("(Integer)value", "Integer(value)") + rest = type_replace(rest) + rest = rename_native(rest) + ac_acc = in_getter_type[:in_getter_type.find(' ')] + ac_type = in_getter_type[in_getter_type.find(' ')+1:] + tgt.write(t + ac_acc + " void set" + in_getter + "(" + ac_type + " value) " + rest + "\n") + elif in_getter != "" and s == "}": + in_getter = "" + in_getter_type == "" + skip_brace = 0 + elif s.startswith("uint ") and s.find("=") == -1: + line = line.replace("uint", "Integer", line) + line = re.sub("(?P\w+)(?P[,;])", "\g\g", line) + tgt.write(line); + elif (not in_class and (s.startswith("{") or s.startswith("}"))) or s.startswith("[") or s.startswith("#"): + # print "Skipping: " + s; + pass + elif line == "}\n": + pass + else: + # indent = line.find(s) + if line.find(": base") != -1: + line = re.sub(": base\((?P

[\w,.\(\) ]*)\)", "{ super(\g

);", line) + if line.find("; {") != -1: + line = line.replace("; {", ";") + else: + skip_brace = 1 + if s.startswith("public"): + line = re.sub(" = [\w.]+(?P[,;\)])", "\g", line) + line = re.sub("(?P[\(, ])params ", "\g", line) + line = line.replace("base.", "super.") + a = type_replace(line) + a = re.sub("Contract.\w+\([\s\S]*\);", "", a) + a = rename_native(a) + a = re.sub("~\w+\(\)", "protected void finalize()", a) + a = re.sub("foreach\s*\((?P[\w <>,]+)\s+(?P\w+)\s+in\s+(?P\w+)\)", + "for (\g.Iterator \g = \g.iterator(); \g.hasNext(); )", a) + a = a.replace("readonly private", "private") + a = a.replace("new public", "public") + a = a.replace("ToString", "toString") + a = a.replace("internal ", "") + a = a.replace("override ", "") + a = a.replace("virtual ", "") + a = a.replace("o as AST", "(AST) o") + a = a.replace("other as AST", "(AST) other") + if in_static_class: + a = a.replace("static", "") + a = re.sub("ref (?P\w+)", "\g", a) + subst_getters(a, getters) + tgt.write(a) + + tgt.close() + +mk_java_bindings()