adsl 0.0.3 → 0.1.0

data/lib/adsl/util/general.rb

@@ -0,0 +1,228 @@
+require 'set'
+require 'open3'
+require 'thread'
+require 'active_support'
+
+class String
+  def increment_suffix
+    suffix = scan(/_(\d+)$/).last
+    if suffix.nil?
+      return self + "_2"
+    else
+      suffix = suffix.first
+      return self[0, self.length - suffix.length] + (suffix.to_i + 1).to_s
+    end
+  end
+
+  # for lolz
+  def dyslexicize
+    gsub(/(\w)(\w+)(\w)/) { |match| ([$1] + $2.chars.to_a.shuffle + [$3]).join('') }
+  end
+
+  def adsl_indent
+    indented = "  " + gsub("\n", "\n  ")
+    (/  $/ =~ indented) ? indented[0..-3] : indented
+  end
+end
+
+class Time
+  def self.time_execution
+    pre = Time.now
+    yield
+    ((Time.now - pre)*1000).to_i
+  end
+end
+
+class Array
+  def worklist_each
+    changed = true
+    until empty? or not changed
+      changed = false
+      length.times do
+        task = self.shift
+        new_value = yield task
+        self << new_value if new_value
+        changed = true if task != new_value
+      end
+    end
+  end
+
+  def adsl_indent
+    join("").adsl_indent
+  end
+
+  def select_reject
+    arr1 = []
+    arr2 = []
+    self.each do |e|
+      if yield e
+        arr1 << e
+      else
+        arr2 << e
+      end
+    end
+    return arr1, arr2
+  end
+
+  def set_to(array)
+    self.clear
+    array.each{ |e| self << e }
+    self
+  end
+end
+
+class Symbol
+  def dup; self; end
+end
+
+class NilClass
+  def dup; self; end
+end
+
+class Fixnum
+  def dup; self; end
+end
+
+class TrueClass
+  def dup; self; end
+end
+
+class FalseClass
+  def dup; self; end
+end
+
+class Module
+  def parent_module
+    name.split('::')[0..-2].join('::').constantize
+  end
+
+  def lookup_const(const)
+    lookup_container = self
+    const.to_s.split('::').each do |portion|
+      portion = 'Object' if portion.empty?
+      return nil unless lookup_container.const_defined? portion
+      lookup_container = lookup_container.const_get portion
+    end
+    lookup_container
+  end
+
+  def lookup_or_create_module(name)
+    lookup_container = self
+    name.to_s.split('::').each do |portion|
+      portion = 'Object' if portion.empty?
+      unless lookup_container.const_defined? portion
+        new_module = Module.new
+        lookup_container.const_set portion, new_module
+      end
+      lookup_container = lookup_container.const_get portion 
+    end
+    lookup_container
+  end
+  
+  def lookup_or_create_class(name, superclass)
+    already_defined = lookup_const name
+    return already_defined unless already_defined.nil?
+
+    container_name = name.match(/^(.*)::\w+$/) ? $1 : 'Object'
+    container = lookup_or_create_module container_name
+    new_class = Class.new(superclass)
+    container.const_set name.to_s.split('::').last, new_class
+    new_class
+  end
+  
+  def container_for(*fields, &block)
+    all_fields = Set.new(fields)
+    if respond_to? :container_for_fields
+      prev_fields = send :container_for_fields
+      all_fields.merge prev_fields
+    end
+    singleton_class.send :define_method, :container_for_fields, lambda{ all_fields }
+
+    attr_accessor *fields
+
+    send :define_method, :initialize do |*options|
+      options = options.empty? ? {} : options[0]
+      options ||= {}
+      options_trimmed = Hash[options]
+
+      all_fields.each do |field|
+        instance_variable_set "@#{field}".to_sym, options_trimmed.delete(field.to_sym)
+      end
+      if block
+        instance_eval &block
+      elsif not options_trimmed.empty?
+        raise ArgumentError, "Undefined fields mentioned in initializer of #{self.class}: #{options_trimmed.keys.map{ |key| ":#{key.to_s}"}.join(", ")}" + "\n[#{all_fields.to_a.join ' ' }]"
+      end
+    end
+
+    send :define_method, :recursively_gather do |method|
+      to_inspect = [self]
+      inspected = Set[]
+      while not to_inspect.empty?
+        elem = to_inspect.pop
+        inspected << elem
+        if elem.class.respond_to? :container_for_fields
+          elem.class.container_for_fields.each do |field|
+            field_val = elem.send(field)
+            next if field_val.nil?
+            [field_val].flatten.each do |subval|
+              to_inspect << subval unless inspected.include?(subval)
+            end
+          end
+        end
+      end
+      result = Set[]
+      inspected.each do |val|
+        result = result + [val.send(method)].flatten if val.class.method_defined?(method)
+      end
+      result.delete_if{ |a| a.nil? }.flatten
+    end
+  end
+end
+
+module Kernel
+  # returns stdout of the process that terminates first
+  # not completely thread safe; cannot be with 1.8.7
+  def process_race(*commands)
+    parent_thread = Thread.current
+    mutex = Mutex.new
+    children_threads = []
+    spawned_pids = []
+    result = nil
+    mutex.synchronize do
+      commands.each do |command|
+        children_threads << Thread.new do
+          begin
+            sleep 0.1
+            pipe = IO.popen command, 'r'
+            spawned_pids << pipe.pid
+            output = pipe.read
+            mutex.synchronize do
+              result = output if result.nil?
+              parent_thread.run
+            end
+          rescue => e
+            parent_thread.raise e unless e.message == 'die!'
+          end
+        end
+      end
+    end
+    Thread.stop
+    return result
+  ensure
+    children_threads.each do |child|
+      child.raise 'die!'
+    end
+    spawned_pids.each do |pid|
+      Process.kill 'HUP', pid
+    end
+  end
+
+  def until_no_change(object)
+    loop do
+      old_object = object
+      object = yield object
+      return object if old_object == object
+    end
+  end
+end

data/lib/adsl/util/test_helper.rb

@@ -0,0 +1,71 @@
+require 'test/unit'
+require 'adsl/parser/adsl_parser.tab'
+require 'adsl/spass/bin'
+require 'adsl/spass/spass_ds_extensions'
+require 'adsl/spass/util'
+require 'adsl/util/general'
+
+class Test::Unit::TestCase
+  include ADSL::Spass::Bin
+  include ADSL::Spass::Util
+
+  SPASS_TIMEOUT = 5
+  
+  def adsl_assert(expected_result, input, options={})
+    ds_spec = ADSL::Parser::ADSLParser.new.parse input
+    raise "Exactly one action required in ADSL" if ds_spec.actions.length != 1
+    action_name = ds_spec.actions.first.name
+    spass = ds_spec.translate_action(action_name)
+    spass = replace_conjecture spass, options[:conjecture] if options.include? :conjecture
+    result = exec_spass(spass, options[:timeout] || SPASS_TIMEOUT)
+    if result == :inconclusive
+      puts "inconclusive result on testcase #{self.class.name}.#{method_name}"
+    else
+      assert_equal expected_result, result 
+    end
+  rescue Exception => e
+    puts spass unless spass.nil?
+    raise e
+  end
+
+  def spass_assert(expected_result, input, timeout = SPASS_TIMEOUT)
+    adsl_assert expected_result, input, :timeout => timeout
+  end
+
+  def unload_class(*classes)
+    classes.each do |klass_name|
+      const = self.class.lookup_const klass_name
+      next if const.nil?
+      const.parent_module.send :remove_const, const.name.split('::').last
+    end
+  end
+
+  def class_defined?(*classes)
+    classes.each do |klass_name|
+      return true unless self.class.lookup_const(klass_name).nil?
+    end
+    return false
+  end
+
+  def in_temp_file(content)
+    file = Tempfile.new('test_util')
+    file.write content
+    file.close
+    yield file.path
+  ensure
+    file.unlink unless file.nil?
+  end
+
+  def assert_set_equal(expected, actual, failure_msg = nil)
+    expected.each do |elem|
+      assert_block failure_msg || "Actual collection does not contain `#{elem}'" do
+        actual.include? elem
+      end
+    end
+    actual.each do |elem|
+      assert_block failure_msg || "Expected collection does not contain `#{elem}'" do
+        expected.include? elem
+      end
+    end
+  end
+end

data/lib/adsl/verification/formula_generators.rb

@@ -0,0 +1,231 @@
+require 'adsl/verification/utils'
+require 'adsl/parser/ast_nodes'
+require 'adsl/util/general'
+
+module ADSL
+  module Verification
+
+    # forward declaration
+    class FormulaBuilder; end
+
+    module FormulaGenerators
+      include Utils
+      include ADSL::Parser
+
+      def in_formula_builder
+        formula_builder = nil
+        if self.is_a? ::ADSL::Verification::FormulaBuilder
+          formula_builder = self
+        else
+          formula_builder = ::ADSL::Verification::FormulaBuilder.new
+          formula_builder.adsl_stack << self.adsl_ast if self.respond_to? :adsl_ast
+        end
+        yield formula_builder
+        formula_builder
+      end
+
+      def handle_quantifier(quantifier, adsl_ast_node_klass, arg_types, block)
+        raise "A block needs to be passed to quantifiers" if block.nil?
+        raise "At least some variables need to be given to the block" if block.parameters.empty?
+        in_formula_builder do |fb|
+          
+          param_types = {}
+          block.parameters.each do |param|
+            classname = infer_classname_from_varname param[1]
+            klass = Object.lookup_const classname
+            param_types[param[1].to_sym] = klass
+          end
+          arg_types.each do |explicit_name, explicit_type|
+            classname = classname_for_classname explicit_type
+            klass = Object.lookup_const classname
+            raise "Unknown class #{explicit_type} for parameter #{explicit_name}" if klass.nil?
+            param_types[explicit_name.to_sym] = klass
+          end
+
+          param_types.each do |name, klass|
+            raise "Unknown klass for variable `#{name}' in #{quantifier} quantifier" if klass.nil?
+            raise "Class #{klass.name} is not instrumented" unless klass.respond_to? :adsl_ast
+          end
+
+          vars_and_objsets = block.parameters.map{ |param|
+            [
+              t(param[1].to_s),
+              param_types[param[1].to_sym].all.adsl_ast
+            ]
+          }
+          subformula = block.(*block.parameters.map do |param|
+            param_types[param[1].to_sym].new :adsl_ast => ASTVariable.new(:var_name => t(param[1]))
+          end)
+          subformula = true if subformula.nil?
+          raise "Invalid formula returned by block in `#{quantifier}'" unless subformula.respond_to? :adsl_ast 
+          fb.adsl_stack << adsl_ast_node_klass.new(:vars => vars_and_objsets, :subformula => subformula.adsl_ast)
+        end
+      end
+
+      def forall(arg_types = {}, &block)
+        handle_quantifier :forall, ASTForAll, arg_types, block
+      end
+
+      def exists(arg_types = {}, &block)
+        handle_quantifier :exists, ASTExists, arg_types, block
+      end
+
+      def not(param = nil)
+        in_formula_builder do |fb|
+          if param.nil?
+            fb.adsl_stack << :not
+          else
+            fb.adsl_stack << ASTNot.new(:subformula => param.adsl_ast)
+          end
+        end
+      end
+      alias_method :neg, :not
+
+      def true
+        in_formula_builder do |fb|
+          fb.adsl_stack << true.adsl_ast
+        end
+      end
+
+      def false
+        in_formula_builder do |fb|
+          fb.adsl_stack << false.adsl_ast
+        end
+      end
+
+      def [](formula)
+        in_formula_builder do |fb|
+          formula = formula.adsl_ast if formula.respond_to? :adsl_ast
+          fb.adsl_stack << formula
+        end
+      end
+
+      def binary_op_with_any_number_of_params(op, klass, params)
+        in_formula_builder do |fb|
+          if params.empty?
+            fb.adsl_stack << op
+          else
+            params.each do |param|
+              raise "Invalid formula `#{param}' in `#{op}' parameter list" unless param.respond_to? :adsl_ast
+            end
+            fb.adsl_stack << klass.new(:subformulae => params.map(&:adsl_ast))
+          end
+        end
+      end
+
+      def binary_op(op, klass, params)
+        raise "`#{op}' takes two parameters or none at all" unless params.empty? or params.length == 2
+        in_formula_builder do |fb|
+          if params.empty?
+            fb.adsl_stack << op
+          else
+            params.each do |param|
+              raise "Invalid formula `#{param}' in `#{op}' parameter list" unless param.respond_to? :adsl_ast
+            end
+            fb.adsl_stack << klass.new(:subformula1 => params.first.adsl_ast, :subformula2 => params.last.adsl_ast)
+          end
+        end
+      end
+
+      def and(*params)
+        binary_op_with_any_number_of_params :and, ASTAnd, params
+      end
+      
+      def or(*params)
+        binary_op_with_any_number_of_params :or, ASTOr, params
+      end
+
+      def equiv(*params)
+        binary_op_with_any_number_of_params :equiv, ASTEquiv, params
+      end
+      
+      def implies(*params)
+        binary_op :implies, ASTImplies, params
+      end
+    end
+    
+    class FormulaBuilder
+      include FormulaGenerators
+
+      attr_reader :adsl_stack
+      
+      def initialize(component = nil)
+        @adsl_stack = []
+        @adsl_stack << component unless component.nil?
+      end
+
+      def handle_unary_operator(elements, operator)
+        until (index = elements.find_index(operator)).nil?
+          raise "Unary operator `#{operator}' not prefix-called" if index == elements.length-1
+          arg = elements[index+1]
+          raise "`#{arg}', used by operator `#{operator}', is not a formula" unless arg.is_a? ASTNode
+          result = yield arg
+          elements.delete_at index
+          elements[index] = result
+        end
+      end
+      
+      def handle_binary_operator(elements, operator)
+        until (index = elements.find_index(operator)).nil?
+          raise "Binary operator `#{operator}' not infix-called" if index == 0 or index == elements.length-1
+          args = [elements[index-1], elements[index+1]]
+          args.each do |arg|
+            raise "`#{arg}', used by operator `#{operator}', is not a formula" unless arg.is_a? ASTNode
+          end
+          result = yield *args
+          elements.delete_at index - 1
+          elements.delete_at index - 1
+          elements[index - 1] = result
+        end
+      end
+
+      def gather_adsl_asts
+        elements = @adsl_stack.clone
+        handle_unary_operator elements, :not do |formula|
+          ASTNot.new(:subformula => formula)
+        end
+        handle_binary_operator elements, :and do |formula1, formula2|
+          ASTAnd.new(:subformulae => [formula1, formula2])
+        end
+        handle_binary_operator elements, :or do |formula1, formula2|
+          ASTOr.new(:subformulae => [formula1, formula2])
+        end
+        handle_binary_operator elements, :implies do |formula1, formula2|
+          ASTImplies.new(:subformula1 => formula1, :subformula2 => formula2)
+        end
+        handle_binary_operator elements, :equiv do |formula1, formula2|
+          ASTEquiv.new(:subformula1 => formula1, :subformula2 => formula2)
+        end
+        elements 
+      end
+
+      def adsl_ast
+        elements = gather_adsl_asts
+        if elements.length != 1
+          raise "Invalid formula/operator stack state [#{ elements.map{ |e| e.respond_to?(:to_adsl) ? e.to_adsl : e }.join(', ') }]"
+        end
+        elements.first
+      end
+    end
+  end
+end
+
+class TrueClass
+  include ADSL::Verification::FormulaGenerators
+
+  def adsl_ast
+    ASTBoolean.new(:bool_value => self)
+  end
+end
+
+class FalseClass
+  include ADSL::Verification::FormulaGenerators
+  
+  def adsl_ast
+    ASTBoolean.new(:bool_value => self)
+  end
+end
+
+class ADSL::Parser::ASTNode
+  include ADSL::Verification::FormulaGenerators
+end