ikra 0.0.1

data/lib/sourcify/spec/run_build.sh

@@ -0,0 +1,25 @@
+#!/bin/bash
+if [ -z "$TRAVIS" ]; then
+  echo ''
+  echo `gem env | grep 'INSTALLATION DIRECTORY' | sed 's/.*\/\(.*\)/\1:/'`
+  rm -rf ~/.ruby_inline/*ParseTree*
+fi
+
+SUPPORTS_METHOD_TO_SOURCE=`ruby -e '
+  begin
+    [:source_location, :parameters].each{|meth| 1.method(:to_s).send(meth) }
+    raise RuntimeError if RUBY_PLATFORM =~ /java/i
+    puts :true
+  rescue NoMethodError, RuntimeError
+    puts :false
+  end
+'`
+
+if [ "$SUPPORTS_METHOD_TO_SOURCE" == "true" ]; then
+  bundle exec bacon spec/{proc,method}/*/*_spec.rb spec/{proc,method}/*_spec.rb
+else
+  echo "NOTE: This ruby doesn't support Method#to_source (& friends) !!"
+  bundle exec bacon spec/proc/*/*_spec.rb spec/{proc,no_method}/*_spec.rb
+fi
+
+# __END__

data/lib/sourcify/spec/spec_helper.rb

@@ -0,0 +1,130 @@
+require 'rubygems'
+require 'ruby_parser'
+require 'ruby2ruby'
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'sourcify'
+
+# ///////////////////////////////////////////////////////////
+# Bacon
+# ///////////////////////////////////////////////////////////
+
+require 'bacon'
+Bacon.extend(Bacon::TestUnitOutput)
+Bacon.summary_on_exit
+
+# Removing the extra noises in output, making bacon even less verbose !!
+if ENV['MUTE_BACON'] == 'true'
+  Bacon.extend(Module.new {
+
+    def handle_requirement(description)
+      unless (error = yield).empty?
+        print error[0..0]
+      end
+    end
+
+    def handle_summary
+      puts "", "  %d tests, %d assertions, %d failures, %d errors" %
+        Bacon::Counter.values_at(:specifications, :requirements, :failed, :errors)
+    end
+
+  })
+end
+
+# ///////////////////////////////////////////////////////////
+# Spec helpers & matchers
+# ///////////////////////////////////////////////////////////
+
+def has_parsetree?
+  Object.const_defined?(:ParseTree)
+end
+
+def watever(*args, &block)
+  Proc.new(&block)
+end
+
+def code_to_sexp(code)
+  if has_parsetree?
+    require 'parse_tree'
+    Unifier.new.process(ParseTree.translate(code))
+  else
+    require 'ruby_parser'
+    RubyParser.new.parse(code)
+  end
+end
+
+def normalize_code(code)
+  Ruby2Ruby.new.process(code_to_sexp(code))
+end
+
+def having_source(expected, opts={}, &matcher)
+  lambda do |thing|
+    #normalize_code(expected) # added for bug fixing
+    normalize_code(block_given? ? thing.to_source(&matcher) : thing.to_source(opts)) \
+      == normalize_code(expected)
+  end
+end
+
+def having_raw_source(expected, opts={}, &matcher)
+  lambda do |thing|
+    found = block_given? ? thing.to_raw_source(&matcher) : thing.to_raw_source(opts)
+    found == expected.strip
+  end
+end
+
+def having_sexp(expected, opts={}, &matcher)
+  lambda do |thing|
+    expected = eval(expected) if expected.is_a?(String)
+    if block_given?
+      thing.to_sexp(&matcher).inspect == expected.inspect
+    else
+      thing.to_sexp(opts).inspect == expected.inspect
+    end
+  end
+end
+
+def capture(stdin_str = '')
+  begin
+    require 'stringio'
+    $o_stdin, $o_stdout, $o_stderr = $stdin, $stdout, $stderr
+    $stdin, $stdout, $stderr = StringIO.new(stdin_str), StringIO.new, StringIO.new
+    yield
+    {:stdout => $stdout.string, :stderr => $stderr.string}
+  ensure
+    $stdin, $stdout, $stderr = $o_stdin, $o_stdout, $o_stderr
+  end
+end
+
+def irb_exec(stdin_str)
+  # See http://tyenglog.heroku.com/2010/9/how-to-test-irb-specific-support &
+  # http://tyenglog.heroku.com/2010/9/how-to-test-irb-specific-support-2-
+  sourcify_rb = File.join(File.expand_path(File.dirname(__FILE__)), '..', 'lib', 'sourcify.rb')
+  irb_feedback = /^ ?=> /
+  irb_opts = '--simple-prompt'
+  values = %x(echo "#{stdin_str}" | irb #{irb_opts} -r #{sourcify_rb}).split("\n").
+    grep(irb_feedback).map{|s| eval(s.sub(irb_feedback,'').strip) }
+
+  # IRB behaves slightly differently in 1.9.2 for appending newline
+  (values[-1].nil? && RUBY_VERSION =~ /1.9.(2|3)/) ? values[0 .. -2] : values
+end
+
+def pry_exec(stdin_str)
+  sourcify_rb = File.join(File.expand_path(File.dirname(__FILE__)), '..', 'lib', 'sourcify.rb')
+  pry_opts = '--simple-prompt --no-color'
+  results = []
+
+  %x(echo "#{stdin_str}" | pry #{pry_opts} -r #{sourcify_rb}).
+    split("\n").each do |line|
+      case line
+      when /^((?:>> |)=> )/
+        results << [line.sub($1,'')]
+      when /^( )/
+        results[-1] << line
+      end
+    end
+
+  results = results.map{|lines| eval(lines.join) }
+  results[-1].nil? ? results[0..-2] : results
+end
+

data/lib/symbolic/symbolic.rb

@@ -0,0 +1,248 @@
+require "set"
+require_relative "../translator/command_translator"
+require_relative "../types/primitive_type"
+require_relative "../types/class_type"
+require_relative "../types/union_type"
+require_relative "../types/array_type"
+require_relative "../type_aware_array"
+require_relative "../parsing"
+require_relative "../ast/nodes"
+require_relative "../ast/lexical_variables_enumerator"
+require_relative "../config/os_configuration"
+
+Ikra::Configuration.check_software_configuration
+
+module Ikra
+    module Symbolic
+        class BlockParameter
+            Normal = 0
+            Index = 1
+            PreviousFusion = 2
+            
+            attr_accessor :name
+            attr_accessor :type
+            attr_accessor :source_type
+
+            def initialize(name:, type:, source_type: Normal)
+                @name = name
+                @type = type
+                @source_type = source_type
+            end
+        end
+
+        module ArrayCommand
+
+            attr_reader :unique_id                  # [Fixnum] Returns a unique ID for this command. It is used during name mangling in the code generator to determine the name of array identifiers (and do other stuff?).
+
+            @@unique_id  = 1
+
+            def initialize
+                super
+
+                # Generate unique ID
+                @unique_id = @@unique_id
+                @@unique_id += 1
+            end
+
+            def [](index)
+                if @result == nil
+                    execute
+                end
+                
+                @result[index]
+            end
+            
+            def execute
+                @result = Translator.translate_command(self).execute
+            end
+            
+            def to_command
+                self
+            end
+            
+            def pmap(&block)
+                ArrayMapCommand.new(self, block)
+            end
+
+            # Returns a collection of the names of all block parameters.
+            # @return [Array(Symbol)] list of block parameters
+            def block_parameter_names
+                block.parameters.map do |param|
+                    param[1]
+                end
+            end
+
+            # Returns the size (number of elements) of the result, after executing the parallel section.
+            # @return [Fixnum] size
+            def size
+                raise NotImplementedError
+            end
+
+            def target
+                raise NotImplementedError
+            end
+
+            # Returns the abstract syntax tree for a parallel section.
+            def ast
+                # TODO: add caching for AST here
+                # TODO: maybe set dummy class_owner here?
+                parser_local_vars = block.binding.local_variables + block_parameter_names
+                source = Parsing.parse_block(block, parser_local_vars)
+                AST::Builder.from_parser_ast(source)
+            end
+
+            # Returns a collection of lexical variables that are accessed within a parallel section.
+            # @return [Hash{Symbol => Object}]
+            def lexical_externals
+                all_lexical_vars = block.binding.local_variables
+                lexical_vars_enumerator = AST::LexicalVariablesEnumerator.new(all_lexical_vars)
+                ast.accept(lexical_vars_enumerator)
+                accessed_variables = lexical_vars_enumerator.lexical_variables
+
+                result = Hash.new
+                for var_name in accessed_variables
+                    result[var_name] = block.binding.local_variable_get(var_name)
+                end
+
+                result
+            end
+
+            # Returns a collection of external objects that are accessed within a parallel section.
+            def externals
+                lexical_externals.keys
+            end
+
+            protected
+
+            # Returns the block of the parallel section.
+            # @return [Proc] block
+            def block
+                raise NotImplementedError
+            end
+        end
+
+        class ArrayNewCommand
+            include ArrayCommand
+            
+            def initialize(size, block)
+                super()
+
+                @size = size
+                @block = block
+            end
+            
+            def size
+                @size
+            end
+
+            protected
+
+            attr_reader :block
+        end
+
+        class ArrayMapCommand
+            include ArrayCommand
+            
+            attr_reader :target
+
+            def initialize(target, block)
+                super()
+
+                @target = target
+                @block = block
+            end
+            
+            def size
+                @target.size
+            end
+            
+            protected
+
+            attr_reader :block
+        end
+
+        class ArraySelectCommand
+            include ArrayCommand
+
+            attr_reader :target
+
+            def initialize(target, block)
+                super
+
+                @target = target
+                @block = block
+            end
+            
+            # how to implement SELECT?
+            # idea: two return values (actual value and boolean indicator as struct type)
+        end
+
+        class ArrayIdentityCommand
+            include ArrayCommand
+            
+            attr_reader :target
+
+            Block = Proc.new do |element|
+                element
+            end
+
+            @@unique_id = 1
+
+            def initialize(target)
+                super()
+
+                @target = target
+
+                # Ensure that base array cannot be modified
+                target.freeze
+            end
+            
+            def execute
+                @target
+            end
+            
+            def size
+                @target.size
+            end
+
+            # Returns a collection of external objects that are accessed within a parallel section. This includes all elements of the base array.
+            def externals
+                lexical_externals.keys + @target
+            end
+
+            def base_type
+                # TODO: add caching (@target is frozen)
+                type = Types::UnionType.new
+
+                @target.each do |element|
+                    type.expand_with_singleton_type(element.class.to_ikra_type)
+                end
+
+                type
+            end
+
+            protected
+
+            def block
+                Block
+            end
+        end
+    end
+end
+
+class Array
+    class << self
+        def pnew(size, &block)
+            Ikra::Symbolic::ArrayNewCommand.new(size, block)
+        end
+    end
+    
+    def pmap(&block)
+        Ikra::Symbolic::ArrayMapCommand.new(to_command, block)
+    end
+    
+    def to_command
+        Ikra::Symbolic::ArrayIdentityCommand.new(self)
+    end
+end
+

data/lib/symbolic/visitor.rb

@@ -0,0 +1,51 @@
+module Ikra
+    module Symbolic
+        class ArrayNewCommand
+            def accept(visitor)
+                visitor.visit_array_new_command(self)
+            end
+        end
+
+        class ArrayMapCommand
+            def accept(visitor)
+                visitor.visit_array_map_command(self)
+            end
+        end
+
+        class ArraySelectCommand
+            def accept(visitor)
+                visitor.visit_array_select_command(self)
+            end
+        end
+
+        class ArrayIdentityCommand
+            def accept(visitor)
+                visitor.visit_array_identity_command(self)
+            end
+        end
+
+        class Visitor
+            def visit_array_command(command)
+
+            end
+
+            def visit_array_new_command(command)
+                visit_array_command(command)
+            end
+
+            def visit_array_map_command(command)
+                visit_array_command(command)
+                command.target.accept(self)
+            end
+
+            def visit_array_select_command(command)
+                visit_array_command(command)
+                command.target.accept(self)
+            end
+
+            def visit_array_identity_command(command)
+                visit_array_command(command)
+            end
+        end
+    end
+end