mbt-gen 0.0.3 → 0.0.5

data/lib/solver-lib.rb

@@ -1,433 +1,572 @@
-#!/usr/bin/ruby
-
-require 'open3'
-
-
-class SolverSession
-
-  def initialize(z3in, z3outAndErr, logFileName)
-    @z3in = z3in
-    @z3outAndErr = z3outAndErr
-    @protocol_filename = logFileName
-    @protocol = File.open(@protocol_filename, "w")
-    @assertCounter = -1
-    @associations = {}
-    @consts = {}
-  end
-
-  def emptyReadBuffer(progress)
-    empty = false
-    while !empty do
-      begin
-        c = ""
-        @z3outAndErr.read_nonblock(1, c)
-        line = c + @z3outAndErr.gets
-        checkLineForSolverError(line, progress)
-        @protocol.puts("; Solver Response: #{line}")
-      rescue Errno::EWOULDBLOCK
-        # there is nothing to read -> just continue
-        empty = true
-      rescue Errno::EAGAIN
-        # there is nothing to read -> just continue
-        empty = true
-      rescue EOFError
-        # there is nothing to read -> just continue
-        empty = true
-      end
-    end
-  end
-
-  def declare_const(progress, name, type, info)
-    info[:type] = type
-    @consts[name] = info
-    to_solver(progress, "(declare-const #{name} #{type})")
-  end
-
-  def to_solver(progress, line)
-    emptyReadBuffer(progress);
-    @protocol.puts(line)
-    begin
-      @z3in.puts(line)
-    rescue Errno::EINVAL
-      progress.print_line "ERROR: could not write the line #{line.inspect} to the solver."
-      writeProtocolToFile("failure.smt2")
-    rescue Errno::EPIPE
-      writeProtocolToFile("failure.smt2")
-      throw RuntimeError.new("Broken Pipe")
-    end
-  end
-
-  def checkLineForSolverError(line, progress)
-    if line =~ /\(error \"(.*)\"\)/ then
-      progress.print_line("WARN: Solver reported ERROR: #{$1}")
-    end
-  end
-
-
-  def from_solver(progress)
-    result = @z3outAndErr.gets
-    checkLineForSolverError(result, progress)
-    @protocol.puts("; Solver Response: #{result}")
-    return result
-  end
-
-  def replace_strings(line)
-    line.gsub(/"([^"\\]|\\.)*"/, "")
-  end
-
-  def read_multiline_from_solver()
-    result = ""
-    for_counting = ""
-    @protocol.puts
-    @protocol.puts("; BEGIN Multiline Solver Response:")
-    line = @z3outAndErr.gets
-    result += line
-    for_counting += replace_strings(line)
-    @protocol.puts("; #{line}")
-    
-    num_opening = for_counting.count("(")
-    num_closing = for_counting.count(")")
-    while num_opening > num_closing do
-      line = @z3outAndErr.gets
-      result += line
-      for_counting += replace_strings(line)
-      @protocol.puts("; #{line}")
-
-      num_opening = for_counting.count("(")
-      num_closing = for_counting.count(")")
-    end
-    @protocol.puts("; END Multiline Solver Response")
-    return result
-  end
-
-  def writeProtocolToFile(progress, filename)
-    dir = File.dirname(filename)
-    FileUtils.mkdir_p(dir) unless Dir.exist?(dir)
-    FileUtils.cp(@protocol_filename, filename) unless @protocol_filename == filename
-    progress.print_line "Solver protocol written to file #{filename}"
-  end
-
-  def generateNextAssertionIDAndAssociateWith(hash)
-    nextAssertionID = "a#{@assertCounter += 1}"
-    @associations[nextAssertionID] = hash
-    return nextAssertionID
-  end
-
-  def associateAssertionIDWith(assertionID, hash)
-    if @associations.has_key?(assertionID) then
-      raise RuntimeError.new("AssertionID #{assertionID.inspect} already has info associated with it!")
-    end
-    @associations[assertionID] = hash
-  end
-
-  def getAssociationForAssertionID(assertionID)
-    return @associations[assertionID]
-  end
-
-  def for_each_const(&block)
-    @consts.each do |key, value|
-      block.call(key, value)
-    end
-  end
-
-  def get_const_info(name)
-    @consts[name]
-  end
-end
-
-class Z3Solver
-
-  def initialize(progress, z3path)
-    z3version = `#{z3path} --version`.chomp()
-    if $?.exitstatus == 0 then
-      progress.print_line "INFO: Using #{z3version} found in z3path=#{z3path}"
-      @z3in, @z3outAndErr, @z3thr = Open3.popen2e(z3path, '-in', '-smt2')
-      Process.detach(@z3thr.pid)
-    else
-      progress.print_line "WARN: could not find z3 in z3path=#{z3path.inspect}"
-      `which z3`
-      if $?.exitstatus == 0 then
-        z3version = `z3 --version`.chomp()
-        progress.print_line "However, #{z3version} is availlable on the PATH. Using this one."
-        @z3in, @z3outAndErr, @z3thr = Open3.popen2e('z3', '-in', '-smt2')
-        Process.detach(@z3thr.pid)
-      else
-        raise RuntimeError.new("ERROR: unable to find Z3. Exiting! (Please provide its location in the config file using the key :z3path)")
-      end
-    end
-    @z3in.sync = true
-
-    @sessionIdCounter = 0
-  end
-
-  def close()
-    @z3in.close()
-    @z3outAndErr.close()
-    Thread.kill(@z3thr)
-  end
-
-  def query(progress, options, &block)
-    unless options[:solverLog]
-      raise RuntimeError.new("No solverLog specified, but the option :solverLog is required!")
-    end
-    progress.print_line("calling solver (solver-log is written to #{options[:solverLog]})")
-    solver = SolverSession.new(@z3in, @z3outAndErr, options[:solverLog])
-
-    block.call(solver)
-
-    solver.to_solver(progress, "(check-sat)")
-    result = solver.from_solver(progress)
-    explanation = true
-    if result.chomp == "sat"
-        # model is not contradictory -> continue
-    elsif result.chomp == "unsat"
-        # model is contradictory -> add a message
-
-        solver.to_solver(progress, "(get-unsat-core)")
-        unsat_core = solver.from_solver(progress)
-        explanation = parse_unsat_core(solver, unsat_core)
-    else
-      handleSolverError(progress, solver, options, result)
-    end
-
-    solver.to_solver(progress, "(reset)")
-    solver.to_solver(progress, "(set-logic ALL)") 
-    solver.to_solver(progress, "(set-option :produce-unsat-cores true)") 
-    return explanation
-  end
-
-  def display_assertion(assertion, solver)
-    if assertion =~ /validation_rule_(.*)_instance_(.*)/ then
-      return "Validation rule #{$1} of structure #{$2.gsub("_", "/")}"
-    else
-      info = solver.getAssociationForAssertionID(assertion)
-      if info then
-        if info[:assertion_type] == :doc_field_filled then
-          return "Field #{info[:xpath]} contains value #{info[:value].inspect} in document"
-        elsif info[:assertion_type] == :doc_field_empty then
-          return "Field #{info[:xpath]} is empty in document"
-        elsif info[:assertion_type] == :doc_structure_exists then
-          return "Structure #{info[:xpath]} exists in document"
-        elsif info[:assertion_type] == :doc_structure_not_exists then
-          return "Structure #{info[:xpath]} does not exist in document"
-        elsif info[:assertion_type] == :constraint then
-          if info[:constraint_type] == :min then
-            return "Field #{info[:xpath]} has a minimum value of #{info[:value]}."
-          elsif info[:constraint_type] == :max then
-            return "Field #{info[:xpath]} has a maximum value of #{info[:value]}."
-          elsif info[:constraint_type] == :required then
-            return "Field #{info[:xpath]} is required."
-          else
-            p info
-            raise RuntimeError.new("encountered unknown :constraint_type #{info[:constraint_type].inspect} for assertionID #{assertion.inspect}")
-          end
-        else
-          raise RuntimeError.new("encountered unknown :assertion_type #{info[:assertion_type].inspect} for assertionID #{assertion.inspect}")
-        end
-      else
-        return assertion
-      end
-    end
-  end
-
-  def parse_unsat_core(solver, unsat_core)
-    unsat_core = unsat_core.chomp
-    # TODO: implement
-    unless unsat_core =~ /\((.*)\)/ then
-      raise RuntimeError.new("could not parse unsat core: #{unsat_core.inspect}")
-    end
-    list = $1.split(" ")
-
-    result = "EXPLANATION:\n"
-    result += "The following values\n"
-
-    list.filter{|a| a.start_with?("doc-")}.each do |assertion|
-      result += "- #{display_assertion(assertion, solver)} (#{assertion})\n"
-    end
-    result += "\nviolate the following constraints\n"
-    list.filter{|a| !a.start_with?("doc-")}.each do |assertion|
-      result += "- #{display_assertion(assertion, solver)} (#{assertion})\n"
-    end
-    return result
-  end
-
-  # main entry point!
-  def query_model(progress, options, &block)
-    unless options[:solverLog]
-      raise RuntimeError.new("No solverLog specified, but the option :solverLog is required!")
-    end
-    progress.print_line("calling solver (solver-log is written to #{options[:solverLog]})")
-    solver = SolverSession.new(@z3in, @z3outAndErr, options[:solverLog])
-
-    block.call(solver)
-    
-    solver.to_solver(progress, "(check-sat)")
-    result = solver.from_solver(progress)
-    if result.chomp == "sat"
-        # model is not contradictory -> extract model
-        const_list = []
-        const_info = {}
-        solver.for_each_const do |name, info|
-          const_list << name
-          const_info[name] = info
-        end
-        solver.to_solver(progress, "(get-value (#{const_list.join(" ")}))")
-        model_str = solver.read_multiline_from_solver()
-        model = {}
-        foreach_field_in_model_str(model_str, solver, const_info) do |varname, value, info|
-          unless info then
-            progress.print_line "WARN: no info availlable for varname=#{varname.inspect}, value=#{value.inspect}"
-          end
-          xpath = info[:xpath]
-          if model.has_key?(xpath) then
-            if varname.end_with?("-filled") then
-              unless model[xpath][:type] == :field then
-                raise RuntimeError.new("inconsistent model: xpath #{xpath} should be a field, not a #{model[xpath][:type]}.")
-              end
-              unless value == "true" or value == "false" then
-                raise RuntimeError.new("inconsistent model value filled-value of #{xpath} should be a Bool, but was #{value.inspect}.")
-              end
-              if value == "true" then
-                model[xpath][:filled] = true
-              else
-                model[xpath][:filled] = false
-              end
-            elsif varname.end_with?("-value") then
-              unless model[xpath][:type] == :field || model[xpath][:type] == :list then
-                raise RuntimeError.new("inconsistent model: xpath #{xpath} should be a field or a list, not a #{model[xpath][:type]}.")
-              end
-              if model[xpath][:type] == :field then
-                model[xpath][:value] = convert_solver_value(info[:type], info[:datatype], value, xpath)
-              elsif model[xpath][:type] == :list then
-                unless varname =~ /-index-(\d+)-value$/
-                  raise RuntimeError.new("inconsistent model: xpath #{xpath} is a list value and hence its varname should end like -index-X-value, not #{varname.inspect}.")
-                end
-                index = Integer($1)
-                model[xpath][:xpath_element] = info[:xpath_element]
-                if model[xpath].has_key?(:value) then
-                  val = convert_solver_value(info[:type], info[:datatype], value, xpath)
-                  model[xpath][:value].insert(index, val)
-                else
-                  val = convert_solver_value(info[:type], info[:datatype], value, xpath)
-                  model[xpath][:value] = [val]
-                end
-              end
-            elsif varname.end_with?("-size") then
-              unless model[xpath][:type] == :list || model[xpath][:type] == :field then
-                raise RuntimeError.new("inconsistent model: xpath #{xpath} should be a list or a field, not a #{model[xpath][:type]}.")
-              end
-              if model[xpath][:type] == :field then
-                model[xpath][:type] = :list
-              end
-              model[xpath][:size] = Integer(value)
-            elsif varname.start_with?("struct-") && varname.end_with?("-exists") then
-              unless model[xpath][:type] == :struct then
-                raise RuntimeError.new("inconsistent model: xpath #{xpath} should be a struct, not a #{model[xpath][:type]}.")
-              end
-              model[xpath][:exists] = value
-            end
-          else
-            if varname.end_with?("-filled") then
-              unless value == "true" or value == "false" then
-                raise RuntimeError.new("inconsistent model value filled-value of #{xpath} should be a Bool, but was #{value.inspect}.")
-              end
-              if value == "true" then
-                model[xpath] = { :type => :field, :filled => true }
-              else
-                model[xpath] = { :type => :field, :filled => false }
-              end
-            elsif varname.end_with?("-value") then
-              check_type(info[:type], value, xpath)
-              model[xpath] = {  :type => :field, :value => value }
-            elsif varname.start_with?("struct-") && varname.end_with?("-exists") then
-              unless value == "true" or value == "false" then
-                raise RuntimeError.new("inconsistent model value exists-value of struct #{xpath} should be a Bool, but was #{value.inspect}.")
-              end
-              model[xpath] = { :type => :struct, :exists => value }
-            elsif varname.end_with?("-size") then
-              model[xpath] = { :type => :list, :size => value }
-            end
-          end
-        end
-        return model
-    elsif result.chomp == "unsat"
-        # model is contradictory -> add a message
-
-        solver.to_solver(progress, "(get-unsat-core)")
-        unsat_core = solver.from_solver(progress)
-        solver.writeProtocolToFile(progress, options[:solverLog])
-        progress.print_line "Solver reported a contradiction! please see #{options[:solverLog]} for further information."
-        return nil
-    else
-      handleSolverError(progress, solver, options, result)
-    end
-
-    messages = []
-    solver.to_solver "(reset)"
-    solver.to_solver "(set-logic ALL)"
-    solver.to_solver "(set-option :produce-unsat-cores true)"
-
-    return messages
-  end
-
-  def check_type(type, value, xpath)
-    if type == "String" then
-      unless value =~ /\".*\"/ then
-        raise RuntimeError.new("inconsistent model value: model value for #{xpath} should be a String, but was #{value}.")
-      end
-    elsif type == "Bool"
-      unless value == "true" or value == "false" then
-        raise RuntimeError.new("inconsistent model value for #{xpath} should be a Bool, but was #{value.inspect}.")
-      end
-    elsif type == "Int"
-      unless value =~ /\d+/ then
-        raise RuntimeError.new("inconsistent model value: model value for #{xpath} should be a Int, but was #{value}.")
-      end
-    else
-      raise RuntimeError.new("encountered unknown solver type: type of solver-var for #{xpath} is #{info[:type]}.")
-    end
-  end
-
-  def convert_solver_value(type, datatype, value, xpath)
-    check_type(type, value, xpath)
-    if datatype == :date then
-      return (Time.at(0).to_date + Integer(value)).to_s
-    elsif datatype == :timestamp then
-      return Time.at(Integer(value)).to_s
-    else
-      return value
-    end
-  end
-
-  def foreach_field_in_model_str(str, solver, const_info, &block)
-    unless str =~ /^\((.*)\)$/m
-      raise RuntimeError.new("could not parse model: #{str.inspect}")
-    end
-    str = $1
-
-    str.split("\n").each do |line|
-      unless line =~ /\(([^\ ]*)\ (.*)\)/
-        raise RuntimeError.new("could not parse model line: #{line.inspect}")
-      end
-      varname = $1
-      value = $2
-      if value =~ /\(-\ (\d+)\)/ then
-        simplified = "-#{$1}"
-        value = simplified
-      end
-      info = const_info[varname]
-
-      block.call(varname, value, info)
-    end
-
-    return nil
-  end
-
-  def handleSolverError(progress, solver, options, result)
-    solver.writeProtocolToFile(progress, options[:solverLog])
-    raise RuntimeError.new("Solver Error: Solver returned '#{result}', for more information see #{options[:solverLog]}")
-  end
-
-end
-
-
+#!/usr/bin/ruby
+
+require 'open3'
+
+
+class SolverSession
+
+  def initialize(solverFactory, logFileName)
+    @solverFactory = solverFactory
+    @solver = @solverFactory.new_solver()
+    @protocol_filename = logFileName
+    @protocol = File.open(@protocol_filename, "w")
+    @assertCounter = -1
+    @associations = {}
+    @consts = {}
+  end
+
+  def switch_solver(progress)
+    @solver.close()
+    @solver = @solverFactory.new_solver()
+    # re-feed the session protocol into the new solver to get it up-to-date
+    @protocol.close()
+    File.open(@protocol_filename, "r") do |protocol|
+      protocol.each_line do |line|
+        to_solver(progress, line)
+      end
+    end
+    @protocol = File.open(@protocol_filename, "a")
+  end
+
+  def emptyReadBuffer(progress)
+    empty = false
+    while !empty do
+      begin
+        c = ""
+        @solver.z3outAndErr.read_nonblock(1, c)
+        line = c + @solver.z3outAndErr.gets
+        checkLineForSolverError(line, progress)
+        @protocol.puts("; Solver Response: #{line}")
+      rescue Errno::EWOULDBLOCK
+        # there is nothing to read -> just continue
+        empty = true
+      rescue Errno::EAGAIN
+        # there is nothing to read -> just continue
+        empty = true
+      rescue EOFError
+        # there is nothing to read -> just continue
+        empty = true
+      end
+    end
+  end
+
+  def declare_const(progress, name, type, info)
+    info[:type] = type
+    @consts[name] = info
+    to_solver(progress, "(declare-const #{name} #{type})")
+  end
+
+  def to_solver(progress, line)
+    emptyReadBuffer(progress);
+    success = false
+    while (!success) do
+      begin
+        @solver.z3in.puts(line)
+        success = true
+      rescue Errno::EINVAL => e
+        progress.print_line("DEBUG: Invalid argument to puts(): #{line.inspect}")
+        progress.print_line("An Error occured: #{e.message}")
+        e.backtrace.each { |stline| progress.print_line(stline) }
+        progress.print_line("=> Switching Solver")
+        switch_solver(progress)
+        progress.print_line("=> Switch successful. Trying again.")
+      rescue Errno::EPIPE => e
+        progress.print_line("An Error occured: #{e.message}")
+        e.backtrace.each { |stline| progress.print_line(stline) }
+        progress.print_line("=> Switching Solver")
+        switch_solver(progress)
+        progress.print_line("=> Switch successful. Trying again.")
+      end
+    end
+    @protocol.puts(line)
+  end
+
+  def checkLineForSolverError(line, progress)
+    if line =~ /\(error \"(.*)\"\)/ then
+      progress.print_line("WARN: Solver reported ERROR: #{$1}")
+    end
+  end
+
+
+  def from_solver(progress)
+    result = @solver.z3outAndErr.gets(chomp: true)
+    checkLineForSolverError(result, progress)
+    @protocol.puts("; Solver Response: #{result}")
+    return result
+  end
+
+  def replace_strings(line)
+    line.gsub(/"[^"]*"/, "")
+  end
+
+  def read_multiline_from_solver()
+    result = ""
+    for_counting = ""
+    @protocol.puts
+    @protocol.puts("; BEGIN Multiline Solver Response:")
+    line = @solver.z3outAndErr.gets(chomp: true)
+    result += line
+    for_counting = replace_strings(line)
+    @protocol.puts("; #{line}")
+    
+    num_opening = for_counting.count("(")
+    num_closing = for_counting.count(")")
+    while num_opening > num_closing && line != nil do
+      line = @solver.z3outAndErr.gets(chomp: true)
+      if line
+        result += "#{line}\n"
+        for_counting = replace_strings(line)
+        @protocol.puts("; #{line}")
+        
+        num_opening += for_counting.count("(")
+        num_closing += for_counting.count(")")
+      end
+    end
+    @protocol.puts("; END Multiline Solver Response")
+    return result
+  end
+
+  def writeProtocolToFile(progress, filename)
+    dir = File.dirname(filename)
+    FileUtils.mkdir_p(dir) unless Dir.exist?(dir)
+    FileUtils.cp(@protocol_filename, filename) unless @protocol_filename == filename
+    progress.print_line "Solver protocol written to file #{filename}"
+  end
+
+  def generateNextAssertionIDAndAssociateWith(hash)
+    nextAssertionID = "a#{@assertCounter += 1}"
+    @associations[nextAssertionID] = hash
+    return nextAssertionID
+  end
+
+  def associateAssertionIDWith(assertionID, hash)
+    if @associations.has_key?(assertionID) then
+      raise RuntimeError.new("AssertionID #{assertionID.inspect} already has info associated with it!")
+    end
+    @associations[assertionID] = hash
+  end
+
+  def getAssociationForAssertionID(assertionID)
+    return @associations[assertionID]
+  end
+
+  def for_each_const(&block)
+    @consts.each do |key, value|
+      block.call(key, value)
+    end
+  end
+
+  def get_const_info(name)
+    @consts[name]
+  end
+
+  def parse_unsat_core(unsat_core)
+    @solver.parse_unsat_core(unsat_core, self)
+  end
+
+  def handleSolverError(progress, options, result)
+    ModelUtils.handleSolverError(progress, self, options, result)
+  end
+end
+
+class SolverFactory
+
+  attr_reader :z3path, :z3version
+
+  def initialize(progress, z3path)
+    @progress = progress
+    z3version = nil
+    exitstatus = nil
+    begin
+      z3version = `#{z3path} --version`.chomp()
+      exitstatus = $?.exitstatus
+    rescue Errno::ENOENT
+    end
+    if exitstatus == 0 && z3version != nil then
+      progress.print_line "INFO: Using #{z3version} found in z3path=#{z3path}"
+      @z3path = z3path
+      @z3version = z3version
+    else
+      progress.print_line "WARN: could not find z3 in z3path=#{z3path.inspect}"
+      `which z3`
+      if $?.exitstatus == 0 then
+        z3version = `z3 --version`.chomp()
+        progress.print_line "However, #{z3version} is availlable on the PATH. Using this one."
+        @z3path = 'z3'
+        @z3version = z3version
+      else
+        raise RuntimeError.new("ERROR: unable to find Z3 solver. Exiting! (Please provide its location in the config file using the key :z3path)")
+      end
+    end
+  end
+
+  def new_solver()
+    Z3Solver.new(@progress, @z3path)
+  end
+
+  def query(options, &block)
+    unless options[:solverLog]
+      raise RuntimeError.new("No solverLog specified, but the option :solverLog is required!")
+    end
+    @progress.print_line("calling solver (solver-log is written to #{options[:solverLog]})")
+
+    session = SolverSession.new(self, options[:solverLog])
+    block.call(session)
+
+    session.to_solver(@progress, "(check-sat)")
+    result = session.from_solver(@progress)
+    explanation = true
+    if result == "sat"
+        # model is not contradictory -> continue
+    elsif result == "unsat"
+        # model is contradictory -> add a message
+
+        session.to_solver(@progress, "(get-unsat-core)")
+        unsat_core = session.from_solver(@progress)
+        explanation = session.parse_unsat_core(unsat_core)
+    else
+      ModelUtils.handleSolverError(@progress, options, result)
+    end
+
+    return explanation
+  end
+
+  def display_assertion(assertion, solver)
+    if assertion =~ /validation_rule_(.*)_instance_(.*)/ then
+      return "Validation rule #{$1} of structure #{$2.gsub("_", "/")}"
+    else
+      info = solver.getAssociationForAssertionID(assertion)
+      if info then
+        if info[:assertion_type] == :doc_field_filled then
+          return "Field #{info[:xpath]} contains value #{info[:value].inspect} in document"
+        elsif info[:assertion_type] == :doc_field_empty then
+          return "Field #{info[:xpath]} is empty in document"
+        elsif info[:assertion_type] == :doc_structure_exists then
+          return "Structure #{info[:xpath]} exists in document"
+        elsif info[:assertion_type] == :doc_structure_not_exists then
+          return "Structure #{info[:xpath]} does not exist in document"
+        elsif info[:assertion_type] == :constraint then
+          if info[:constraint_type] == :min then
+            return "Field #{info[:xpath]} has a minimum value of #{info[:value]}."
+          elsif info[:constraint_type] == :max then
+            return "Field #{info[:xpath]} has a maximum value of #{info[:value]}."
+          elsif info[:constraint_type] == :required then
+            return "Field #{info[:xpath]} is required."
+          elsif info[:constraint_type] == :values then
+            return "Field #{info[:xpath]} is an enum field and can only contain the values #{info[:values].inspect}."
+          else
+            p info
+            raise RuntimeError.new("encountered unknown :constraint_type #{info[:constraint_type].inspect} for assertionID #{assertion.inspect}")
+          end
+        else
+          raise RuntimeError.new("encountered unknown :assertion_type #{info[:assertion_type].inspect} for assertionID #{assertion.inspect}")
+        end
+      else
+        return assertion
+      end
+    end
+  end
+
+  def parse_unsat_core(solver, unsat_core)
+    # TODO: implement
+    unless unsat_core =~ /\((.*)\)/ then
+      raise RuntimeError.new("could not parse unsat core: #{unsat_core.inspect}")
+    end
+    list = $1.split(" ")
+
+    result = "EXPLANATION:\n"
+    result += "The following values\n"
+
+    list.filter{|a| a.start_with?("doc-")}.each do |assertion|
+      result += "- #{display_assertion(assertion, solver)} (#{assertion})\n"
+    end
+    result += "\nviolate the following constraints\n"
+    list.filter{|a| !a.start_with?("doc-")}.each do |assertion|
+      result += "- #{display_assertion(assertion, solver)} (#{assertion})\n"
+    end
+    return result
+  end
+
+  # main entry point!
+  def query_model(options, &block)
+    unless options[:solverLog]
+      raise RuntimeError.new("No solverLog specified, but the option :solverLog is required!")
+    end
+    @progress.print_line("calling solver (solver-log is written to #{options[:solverLog]})")
+    session = SolverSession.new(self, options[:solverLog])
+
+    block.call(session)
+    session.to_solver(@progress, "(check-sat)")
+    result = session.from_solver(@progress)
+    if result.chomp == "sat"
+        # model is not contradictory -> extract model
+        const_list = []
+        const_info = {}
+        session.for_each_const do |name, info|
+          const_list << name
+          const_info[name] = info
+        end
+        session.to_solver(@progress, "(get-value (#{const_list.join(" ")}))")
+        model_str = session.read_multiline_from_solver()
+        model = {}
+        ModelUtils.foreach_field_in_model_str(model_str, const_info) do |varname, value, info|
+          unless info then
+            @progress.print_line "WARN: no info availlable for varname=#{varname.inspect}, value=#{value.inspect}"
+          end
+          xpath = info[:xpath]
+          if model.has_key?(xpath) then
+            if varname.end_with?("-filled") then
+              unless model[xpath][:type] == :field then
+                raise RuntimeError.new("inconsistent model: xpath #{xpath} should be a field, not a #{model[xpath][:type]}.")
+              end
+              unless value == "true" or value == "false" then
+                raise RuntimeError.new("inconsistent model value: filled-value of #{xpath} should be a Bool, but was #{value.inspect}.")
+              end
+              if value == "true" then
+                model[xpath][:filled] = true
+              else
+                model[xpath][:filled] = false
+              end
+            elsif varname.end_with?("-value") then
+              unless model[xpath][:type] == :field || model[xpath][:type] == :list then
+                raise RuntimeError.new("inconsistent model: xpath #{xpath} should be a field or a list, not a #{model[xpath][:type]}.")
+              end
+              if model[xpath][:type] == :field then
+                model[xpath][:value] = convert_solver_value(info[:type], info[:datatype], value, xpath)
+              elsif model[xpath][:type] == :list then
+                unless varname =~ /-index-(\d+)-value$/
+                  raise RuntimeError.new("inconsistent model: xpath #{xpath} is a list value and hence its varname should end like -index-X-value, not #{varname.inspect}.")
+                end
+                index = Integer($1)
+                model[xpath][:xpath_element] = info[:xpath_element]
+                if model[xpath].has_key?(:value) then
+                  val = convert_solver_value(info[:type], info[:datatype], value, xpath)
+                  model[xpath][:value].insert(index, val)
+                else
+                  val = convert_solver_value(info[:type], info[:datatype], value, xpath)
+                  model[xpath][:value] = [val]
+                end
+              end
+            elsif varname.end_with?("-size") then
+              unless model[xpath][:type] == :list || model[xpath][:type] == :field then
+                raise RuntimeError.new("inconsistent model: xpath #{xpath} should be a list or a field, not a #{model[xpath][:type].inspect}.")
+              end
+              if model[xpath][:type] == :field then
+                model[xpath][:type] = :list
+              end
+              model[xpath][:size] = Integer(value)
+            elsif varname.start_with?("struct-") && varname.end_with?("-exists") then
+              unless model[xpath][:type] == :struct then
+                raise RuntimeError.new("inconsistent model: xpath #{xpath} should be a struct, not a #{model[xpath][:type]}.")
+              end
+              model[xpath][:exists] = value
+            end
+          else
+            if varname.end_with?("-filled") then
+              unless value == "true" or value == "false" then
+                raise RuntimeError.new("inconsistent model value: filled-value of #{xpath} should be a Bool, but was #{value.inspect}.")
+              end
+              if value == "true" then
+                model[xpath] = { :type => :field, :filled => true }
+              else
+                model[xpath] = { :type => :field, :filled => false }
+              end
+            elsif varname.end_with?("-value") then
+              check_type(info[:type], value, xpath)
+              model[xpath] = {  :type => :field, :value => value }
+            elsif varname.start_with?("struct-") && varname.end_with?("-exists") then
+              unless value == "true" or value == "false" then
+                raise RuntimeError.new("inconsistent model value: exists-value of struct #{xpath} should be a Bool, but was #{value.inspect}.")
+              end
+              model[xpath] = { :type => :struct, :exists => value }
+            elsif varname.end_with?("-size") then
+              model[xpath] = { :type => :list, :size => value }
+            end
+          end
+        end
+        return model
+    elsif result.chomp == "unsat"
+        # model is contradictory -> add a message
+
+        session.to_solver(@progress, "(get-unsat-core)")
+        unsat_core = session.from_solver(@progress)
+        session.writeProtocolToFile(@progress, options[:solverLog])
+        @progress.print_line "Solver reported a contradiction! please see #{options[:solverLog]} for further information."
+        return nil
+    else
+      ModelUtils.handleSolverError(@progress, session, options, result)
+    end
+
+    return nil
+  end
+
+  def convert_solver_value(type, datatype, value, xpath)
+    check_type(type, value, xpath)
+    if datatype == :date then
+      return (Time.at(0).to_date + Integer(value)).to_s
+    elsif datatype == :timestamp then
+      return Time.at(Integer(value)).to_s
+    else
+      return value
+    end
+  end
+
+  def check_type(type, value, xpath)
+    if type == "String" then
+      unless value =~ /\".*\"/ then
+        raise RuntimeError.new("inconsistent model value: model value for #{xpath} should be a String, but was #{value}.")
+      end
+    elsif type == "Bool"
+      unless value == "true" or value == "false" then
+        raise RuntimeError.new("inconsistent model value for #{xpath} should be a Bool, but was #{value.inspect}.")
+      end
+    elsif type == "Int"
+      unless value =~ /\d+/ then
+        raise RuntimeError.new("inconsistent model value: model value for #{xpath} should be a Int, but was #{value}.")
+      end
+    else
+      raise RuntimeError.new("encountered unknown solver type: type of solver-var for #{xpath} is #{info[:type]}.")
+    end
+  end
+
+end
+
+class Z3Solver
+
+  attr_reader :z3in, :z3outAndErr
+
+  def initialize(progress, z3path)
+      @progress = progress
+      @z3in, @z3outAndErr, @z3thr = Open3.popen2e(z3path, '-in', '-smt2')
+      Process.detach(@z3thr.pid)
+      @z3in.sync = true
+      @sessionIdCounter = 0
+  end
+
+  def close()
+    begin
+      @z3in.close() unless @z3in.closed?
+    rescue Errno::EINVAL
+    end
+    begin
+      @z3outAndErr.close() unless @z3outAndErr.closed?
+    rescue Errno::EINVAL
+    end
+    Thread.kill(@z3thr)
+  end
+
+  def display_assertion(assertion, session)
+    if assertion =~ /validation_rule_(.*)_instance_(.*)/ then
+      return "Validation rule #{$1} of structure #{$2.gsub("_", "/")}"
+    else
+      info = session.getAssociationForAssertionID(assertion)
+      if info then
+        if info[:assertion_type] == :doc_field_filled then
+          return "Field #{info[:xpath]} contains value #{info[:value].inspect} in document"
+        elsif info[:assertion_type] == :doc_field_empty then
+          return "Field #{info[:xpath]} is empty in document"
+        elsif info[:assertion_type] == :doc_structure_exists then
+          return "Structure #{info[:xpath]} exists in document"
+        elsif info[:assertion_type] == :doc_structure_not_exists then
+          return "Structure #{info[:xpath]} does not exist in document"
+        elsif info[:assertion_type] == :constraint then
+          if info[:constraint_type] == :min then
+            return "Field #{info[:xpath]} has a minimum value of #{info[:value]}."
+          elsif info[:constraint_type] == :max then
+            return "Field #{info[:xpath]} has a maximum value of #{info[:value]}."
+          elsif info[:constraint_type] == :required then
+            return "Field #{info[:xpath]} is required."
+          else
+            p info
+            raise RuntimeError.new("encountered unknown :constraint_type #{info[:constraint_type].inspect} for assertionID #{assertion.inspect}")
+          end
+        else
+          raise RuntimeError.new("encountered unknown :assertion_type #{info[:assertion_type].inspect} for assertionID #{assertion.inspect}")
+        end
+      else
+        return assertion
+      end
+    end
+  end
+
+  def parse_unsat_core(unsat_core, session)
+    unless unsat_core =~ /\((.*)\)/ then
+      raise RuntimeError.new("could not parse unsat core: #{unsat_core.inspect}")
+    end
+    list = $1.split(" ")
+
+    result = "EXPLANATION:\n"
+    result += "The following values\n"
+
+    list.filter{|a| a.start_with?("doc-")}.each do |assertion|
+      result += "- #{display_assertion(assertion, session)} (#{assertion})\n"
+    end
+    result += "\nviolate the following constraints\n"
+    list.filter{|a| !a.start_with?("doc-")}.each do |assertion|
+      result += "- #{display_assertion(assertion, session)} (#{assertion})\n"
+    end
+    return result
+  end
+
+  def self.find_matching_bracket(str)
+    i = 0
+    open = 0
+    in_str = false
+    while open <= 0 do
+      if str[i] == '(' and !in_str then
+        open += 1
+      elsif str[i] == '"' then
+        in_str = !in_str
+      end
+      i += 1    
+    end
+    while open > 0 do
+      if str[i] == '(' && !in_str then
+        open += 1
+      elsif str[i] == ')' && !in_str then
+        open -= 1
+      elsif str[i] == '"' then
+        in_str = !in_str
+      end
+      i += 1
+    end
+    str[0,i]
+  end
+
+end
+
+class ModelUtils
+
+  def self.foreach_field_in_model_str(str, const_info, &block)
+    unless str =~ /^\((.*)\)$/m
+      raise RuntimeError.new("could not parse model: #{str.inspect}")
+    end
+    str = $1
+
+    while str.size() > 0 do
+      line = Z3Solver.find_matching_bracket(str)
+      str = str[line.size()..]
+      unless line =~ /\(([^\ ]*)\ (.*)\)/
+        raise RuntimeError.new("could not parse model line: #{line.inspect}")
+      end
+      varname = $1
+      value = $2
+      if value =~ /\(-\ (\d+)\)/ then
+        simplified = "-#{$1}"
+        value = simplified
+      end
+      info = const_info[varname]
+
+      block.call(varname, value, info)
+    end
+
+    return nil
+  end
+
+  def self.handleSolverError(progress, session, options, result)
+    session.writeProtocolToFile(progress, options[:solverLog])
+    raise RuntimeError.new("Solver Error: Solver returned '#{result}', for more information see #{options[:solverLog]}")
+  end
+
+end
+