Merge branch 'unstable' of https://git01.codeplex.com/z3 into fpa-api

Conflicts:
	scripts/mk_project.py
	src/api/z3.h
	src/ast/float_decl_plugin.cpp
	src/ast/float_decl_plugin.h
	src/ast/fpa/fpa2bv_converter.cpp
	src/ast/fpa/fpa2bv_rewriter.h
	src/ast/rewriter/float_rewriter.cpp
	src/ast/rewriter/float_rewriter.h

Signed-off-by: Christoph M. Wintersteiger <cwinter@microsoft.com>

src/api/dotnet/Context.cs

@@ -3887,32 +3887,15 @@ namespace Microsoft.Z3
         /// </summary>
         /// <remarks>
         /// The list of all configuration parameters can be obtained using the Z3 executable:
-        /// <c>z3.exe -ini?</c>
+        /// <c>z3.exe -p</c>
         /// Only a few configuration parameters are mutable once the context is created.
         /// An exception is thrown when trying to modify an immutable parameter.
         /// </remarks>
-        /// <seealso cref="GetParamValue"/>
         public void UpdateParamValue(string id, string value)
         {
             Native.Z3_update_param_value(nCtx, id, value);
         }
 
-        /// <summary>
-        /// Get a configuration parameter.
-        /// </summary>
-        /// <remarks>
-        /// Returns null if the parameter value does not exist.
-        /// </remarks>
-        /// <seealso cref="UpdateParamValue"/>
-        public string GetParamValue(string id)
-        {
-            IntPtr res = IntPtr.Zero;
-            if (Native.Z3_get_param_value(nCtx, id, out res) == 0)
-                return null;
-            else
-                return Marshal.PtrToStringAnsi(res);
-        }
-
         #endregion
 
         #region Internal
@@ -4010,7 +3993,7 @@ namespace Microsoft.Z3
         internal Fixedpoint.DecRefQueue Fixedpoint_DRQ { get { Contract.Ensures(Contract.Result<Fixedpoint.DecRefQueue>() != null); return m_Fixedpoint_DRQ; } }
 
 
-        internal uint refCount = 0;
+        internal long refCount = 0;
 
         /// <summary>
         /// Finalizer.

src/api/dotnet/Expr.cs

@@ -323,6 +323,14 @@ namespace Microsoft.Z3
 
         #endregion
 
+        #region Interpolation
+        /// <summary>
+        /// Indicates whether the term is marked for interpolation.
+        /// </summary>
+        /// <remarks></remarks>
+        public bool IsInterpolant { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_INTERP; } }
+        #endregion
+
         #region Arithmetic Terms
         /// <summary>
         /// Indicates whether the term is of integer sort.
@@ -791,7 +799,7 @@ namespace Microsoft.Z3
         /// </summary>
         /// <remarks>A label literal has a set of string parameters. It takes no arguments.</remarks>
         public bool IsLabelLit { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_LABEL_LIT; } }
-        #endregion
+        #endregion        
 
         #region Proof Terms
         /// <summary>

src/api/dotnet/InterpolationContext.cs

@@ -0,0 +1,162 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Diagnostics.Contracts;
+using System.Runtime.InteropServices;
+
+namespace Microsoft.Z3
+{
+    /// <summary>
+    /// The InterpolationContext is suitable for generation of interpolants.
+    /// </summary>
+    /// <remarks>For more information on interpolation please refer
+    /// too the C/C++ API, which is well documented.</remarks>
+    [ContractVerification(true)]
+    class InterpolationContext : Context
+    {
+
+        /// <summary>
+        /// Constructor.
+        /// </summary>
+        public InterpolationContext() : base() { }
+
+        /// <summary>
+        /// Constructor.
+        /// </summary>
+        /// <remarks><seealso cref="Context.Context(Dictionary&lt;string, string&gt;)"/></remarks>
+        public InterpolationContext(Dictionary<string, string> settings) : base(settings) { }
+
+        #region Terms
+        /// <summary>
+        /// Create an expression that marks a formula position for interpolation.
+        /// </summary>
+        public BoolExpr MkInterpolant(BoolExpr a)
+        {
+            Contract.Requires(a != null);
+            Contract.Ensures(Contract.Result<BoolExpr>() != null);
+
+            CheckContextMatch(a);
+            return new BoolExpr(this, Native.Z3_mk_interpolant(nCtx, a.NativeObject));
+        }
+        #endregion
+
+        /// <summary> 
+        /// Computes an interpolant.
+        /// </summary>    
+        /// <remarks>For more information on interpolation please refer
+        /// too the function Z3_get_interpolant in the C/C++ API, which is 
+        /// well documented.</remarks>
+        Expr[] GetInterpolant(Expr pf, Expr pat, Params p)
+        {
+            Contract.Requires(pf != null);
+            Contract.Requires(pat != null);
+            Contract.Requires(p != null);
+            Contract.Ensures(Contract.Result<Expr>() != null);
+
+            CheckContextMatch(pf);
+            CheckContextMatch(pat);
+            CheckContextMatch(p);
+
+            ASTVector seq = new ASTVector(this, Native.Z3_get_interpolant(nCtx, pf.NativeObject, pat.NativeObject, p.NativeObject));
+            uint n = seq.Size;
+            Expr[] res = new Expr[n];
+            for (uint i = 0; i < n; i++)
+                res[i] = Expr.Create(this, seq[i].NativeObject);
+            return res;
+        }
+
+        /// <summary> 
+        /// Computes an interpolant.
+        /// </summary>    
+        /// <remarks>For more information on interpolation please refer
+        /// too the function Z3_compute_interpolant in the C/C++ API, which is 
+        /// well documented.</remarks>
+        Z3_lbool ComputeInterpolant(Expr pat, Params p, out ASTVector interp, out Model model)
+        {
+            Contract.Requires(pat != null);
+            Contract.Requires(p != null);
+            Contract.Ensures(Contract.ValueAtReturn(out interp) != null);
+            Contract.Ensures(Contract.ValueAtReturn(out model) != null);
+
+            CheckContextMatch(pat);
+            CheckContextMatch(p);
+
+            IntPtr i = IntPtr.Zero, m = IntPtr.Zero;
+            int r = Native.Z3_compute_interpolant(nCtx, pat.NativeObject, p.NativeObject, ref i, ref m);
+            interp = new ASTVector(this, i);
+            model = new Model(this, m);
+            return (Z3_lbool)r;
+        }
+
+        /// <summary> 
+        /// Return a string summarizing cumulative time used for interpolation.
+        /// </summary>    
+        /// <remarks>For more information on interpolation please refer
+        /// too the function Z3_interpolation_profile in the C/C++ API, which is 
+        /// well documented.</remarks>
+        public string InterpolationProfile()
+        {
+            return Native.Z3_interpolation_profile(nCtx);
+        }
+
+        /// <summary> 
+        /// Checks the correctness of an interpolant.
+        /// </summary>    
+        /// <remarks>For more information on interpolation please refer
+        /// too the function Z3_check_interpolant in the C/C++ API, which is 
+        /// well documented.</remarks>
+        public int CheckInterpolant(Expr[] cnsts, uint[] parents, Expr[] interps, out string error, Expr[] theory)
+        {
+            Contract.Requires(cnsts.Length == parents.Length);
+            Contract.Requires(cnsts.Length == interps.Length + 1);
+            IntPtr n_err_str;
+            int r = Native.Z3_check_interpolant(nCtx,
+                                                (uint)cnsts.Length,
+                                                Expr.ArrayToNative(cnsts),
+                                                parents,
+                                                Expr.ArrayToNative(interps),
+                                                out n_err_str,
+                                                (uint)theory.Length,
+                                                Expr.ArrayToNative(theory));
+            error = Marshal.PtrToStringAnsi(n_err_str);
+            return r;
+        }
+
+        /// <summary> 
+        /// Reads an interpolation problem from a file.
+        /// </summary>    
+        /// <remarks>For more information on interpolation please refer
+        /// too the function Z3_read_interpolation_problem in the C/C++ API, which is 
+        /// well documented.</remarks>
+        public int ReadInterpolationProblem(string filename, out Expr[] cnsts, out uint[] parents, out string error, out Expr[] theory)
+        {
+            uint num = 0, num_theory = 0;
+            IntPtr[] n_cnsts;
+            IntPtr[] n_theory;
+            IntPtr n_err_str;
+            int r = Native.Z3_read_interpolation_problem(nCtx, ref num, out n_cnsts, out parents, filename, out n_err_str, ref num_theory, out n_theory);
+            error = Marshal.PtrToStringAnsi(n_err_str);
+            cnsts = new Expr[num];
+            parents = new uint[num];
+            theory = new Expr[num_theory];
+            for (int i = 0; i < num; i++)
+                cnsts[i] = Expr.Create(this, n_cnsts[i]);
+            for (int i = 0; i < num_theory; i++)
+                theory[i] = Expr.Create(this, n_theory[i]);
+            return r;
+        }
+
+        /// <summary> 
+        /// Writes an interpolation problem to a file.
+        /// </summary>    
+        /// <remarks>For more information on interpolation please refer
+        /// too the function Z3_write_interpolation_problem in the C/C++ API, which is 
+        /// well documented.</remarks>
+        public void WriteInterpolationProblem(string filename, Expr[] cnsts, uint[] parents, Expr[] theory)
+        {
+            Contract.Requires(cnsts.Length == parents.Length);
+            Native.Z3_write_interpolation_problem(nCtx, (uint)cnsts.Length, Expr.ArrayToNative(cnsts), parents, filename, (uint)theory.Length, Expr.ArrayToNative(theory));
+        }
+    }
+}

src/api/dotnet/Microsoft.Z3.csproj

@@ -254,7 +254,7 @@
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|x86'">
     <DebugSymbols>true</DebugSymbols>
-    <OutputPath>bin\x86\Debug\</OutputPath>
+    <OutputPath>..\x86\Debug\</OutputPath>
     <DefineConstants>DEBUG;TRACE</DefineConstants>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
     <DebugType>full</DebugType>
@@ -266,7 +266,7 @@
     <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
     <CodeAnalysisRuleSetDirectories>;C:\Program Files (x86)\Microsoft Visual Studio 10.0\Team Tools\Static Analysis Tools\\Rule Sets</CodeAnalysisRuleSetDirectories>
     <CodeAnalysisRuleDirectories>;C:\Program Files (x86)\Microsoft Visual Studio 10.0\Team Tools\Static Analysis Tools\FxCop\\Rules</CodeAnalysisRuleDirectories>
-    <DocumentationFile>bin\x86\Debug\Microsoft.Z3.XML</DocumentationFile>
+    <DocumentationFile>..\x86\Debug\Microsoft.Z3.XML</DocumentationFile>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|x86'">
     <OutputPath>bin\x86\Release\</OutputPath>
@@ -358,6 +358,7 @@
     <Compile Include="FuncDecl.cs" />
     <Compile Include="FuncInterp.cs" />
     <Compile Include="Goal.cs" />
+    <Compile Include="InterpolationContext.cs" />
     <Compile Include="IntExpr.cs" />
     <Compile Include="IntNum.cs" />
     <Compile Include="IntSort.cs" />

src/api/dotnet/Params.cs

@@ -58,6 +58,16 @@ namespace Microsoft.Z3
             Native.Z3_params_set_double(Context.nCtx, NativeObject, name.NativeObject, value);
         }
 
+        /// <summary>
+        /// Adds a parameter setting.
+        /// </summary>
+        public void Add(Symbol name, string value)
+        {
+            Contract.Requires(value != null);
+
+            Native.Z3_params_set_symbol(Context.nCtx, NativeObject, name.NativeObject, Context.MkSymbol(value).NativeObject);
+        }
+
         /// <summary>
         /// Adds a parameter setting.
         /// </summary>
@@ -103,6 +113,16 @@ namespace Microsoft.Z3
             Native.Z3_params_set_symbol(Context.nCtx, NativeObject, Context.MkSymbol(name).NativeObject, value.NativeObject);
         }
 
+        /// <summary>
+        /// Adds a parameter setting.
+        /// </summary>
+        public void Add(string name, string value)
+        {
+            Contract.Requires(value != null);
+
+            Native.Z3_params_set_symbol(Context.nCtx, NativeObject, Context.MkSymbol(name).NativeObject, Context.MkSymbol(value).NativeObject);
+        }
+
         /// <summary>
         /// A string representation of the parameter set.
         /// </summary>

src/api/dotnet/Properties/AssemblyInfo

@@ -12,7 +12,7 @@ using System.Security.Permissions;
 [assembly: AssemblyConfiguration("")]
 [assembly: AssemblyCompany("Microsoft Corporation")]
 [assembly: AssemblyProduct("Z3")]
-[assembly: AssemblyCopyright("Copyright © Microsoft Corporation 2006")]
+[assembly: AssemblyCopyright("Copyright (C) 2006-2014 Microsoft Corporation")]
 [assembly: AssemblyTrademark("")]
 [assembly: AssemblyCulture("")]
 

src/api/dotnet/TupleSort.cs

@@ -74,9 +74,10 @@ namespace Microsoft.Z3
             Contract.Requires(name != null);
 
             IntPtr t = IntPtr.Zero;
+            IntPtr[] f = new IntPtr[numFields];
             NativeObject = Native.Z3_mk_tuple_sort(ctx.nCtx, name.NativeObject, numFields,
                                                    Symbol.ArrayToNative(fieldNames), AST.ArrayToNative(fieldSorts),
-                                                   ref t, new IntPtr[numFields]);
+                                                   ref t, f);
         }
         #endregion
     };

src/api/dotnet/Z3Object.cs

@@ -19,6 +19,7 @@ Notes:
 
 using System;
 using System.Diagnostics.Contracts;
+using System.Threading;
 
 namespace Microsoft.Z3
 {
@@ -50,8 +51,7 @@ namespace Microsoft.Z3
 
             if (m_ctx != null)
             {
-                m_ctx.refCount--;
-                if (m_ctx.refCount == 0)
+                if (Interlocked.Decrement(ref m_ctx.refCount) == 0)
                     GC.ReRegisterForFinalize(m_ctx);
                 m_ctx = null;
             }
@@ -77,7 +77,7 @@ namespace Microsoft.Z3
         {
             Contract.Requires(ctx != null);
 
-            ctx.refCount++;
+            Interlocked.Increment(ref ctx.refCount);
             m_ctx = ctx;
         }
 
@@ -85,7 +85,7 @@ namespace Microsoft.Z3
         {
             Contract.Requires(ctx != null);
 
-            ctx.refCount++;
+            Interlocked.Increment(ref ctx.refCount);
             m_ctx = ctx;
             IncRef(obj);
             m_n_obj = obj;